diff --git a/Makefile b/Makefile
index 7a2514e..cbf9b07 100644
--- a/Makefile
+++ b/Makefile
@@ -25,7 +25,7 @@ NORMAL_MARK := $(BUILD_DIR)/normal.mark
 TEX_FILES := $(wildcard $(LATEX_DIR)/*.tex)
 SVG_FILES := $(patsubst %.tex,%.svg,$(subst $(LATEX_DIR),$(IMAGES_DIR),$(TEX_FILES)))
 GIF_FILES := $(patsubst %.tex,%.gif,$(subst $(LATEX_DIR),$(IMAGES_DIR),$(TEX_FILES)))
-CONTENT := $(shell find src -type f -not -name .DS_Store) src/mimetype
+CONTENT := $(shell find src -type f -not -name .DS_Store -not -name \*.tex -not -name \*.sty -not -name \*book-Z-H-4.html) src/mimetype
 XML     := $(shell find src -type f -name \*html)
 
 
@@ -44,6 +44,7 @@ check:
 	xmllint --noout $(XML)
 
 $(BUILD_DIR)/huge/%_cropped.pdf: $(BUILD_DIR)/huge/ $(LATEX_DIR)/%.tex
+	@echo "Building huge $@"
 	sed 's/\\sicpsize}{\\fontsize{16}{18}/\\sicpsize}{\\fontsize{200}{220}/' < $(LATEX_DIR)/sicpstyle.sty > $(LATEX_DIR)/sicpstyle2.sty
 	mv $(LATEX_DIR)/sicpstyle2.sty $(LATEX_DIR)/sicpstyle.sty
 	cd $(LATEX_DIR) && pdflatex -output-dir ./build/huge/ ./$*.tex
@@ -58,14 +59,18 @@ $(IMAGES_DIR)/%.svg: $(BUILD_DIR)/huge/%.pbm
 
 
 $(BUILD_DIR)/%_cropped.pdf: $(BUILD_DIR) $(LATEX_DIR)/%.tex
+	@echo "Building regular"
+	@echo "$(CONTENT)"
+	false
 	sed 's/\\sicpsize}{\\fontsize{200}{220}/\\sicpsize}{\\fontsize{16}{18}/' < $(LATEX_DIR)/sicpstyle.sty > $(LATEX_DIR)/sicpstyle2.sty
 	mv $(LATEX_DIR)/sicpstyle2.sty $(LATEX_DIR)/sicpstyle.sty
 	cd $(LATEX_DIR) && pdflatex -output-dir ./build ./$*.tex
 	pdfcrop --clip $(BUILD_DIR)/$*.pdf $(BUILD_DIR)/$*_cropped.pdf
 	rm -f $(NORMAL_MARK)
 
-$(IMAGES_DIR)/%.gif: $(BUILD_DIR)/%_cropped.pdf
-	convert $(BUILD_DIR)/$*_cropped.pdf $@
+# $(IMAGES_DIR)/%.gif: $(BUILD_DIR)/%_cropped.pdf
+# 	@echo "Converting $@"
+# 	convert $(BUILD_DIR)/$*_cropped.pdf $@
 
 $(BUILD_DIR):
 	mkdir -p $(BUILD_DIR)
@@ -79,4 +84,4 @@ svg: $(SVG_FILES)
 gif: $(GIF_FILES)
 
 clean:
-	rm -rf sicp.epub $(BUILD_DIR) $(SVG_FILES) $(GIF_FILES) src/mimetype
+	rm -rf sicp.epub $(BUILD_DIR) $(SVG_FILES) src/mimetype
diff --git a/error_counts.txt b/error_counts.txt
new file mode 100644
index 0000000..3de7daf
--- /dev/null
+++ b/error_counts.txt
@@ -0,0 +1,16 @@
+ 103 element "p" not allowed here; expected the element end-tag, text or element "a", "abbr", "acronym", "applet", "b", "bdo", "big", "br", "cite", "code", "del", "dfn", "em", "i", "iframe", "img", "ins", "kbd", "map", "noscript", "ns:svg", "object", "q", "samp", "script", "small", "span", "strong", "sub", "sup", "tt" or "var" (with xmlns:ns="http://www.w3.org/2000/svg")
+ 101 element "div" not allowed here; expected the element end-tag, text or element "a", "abbr", "acronym", "applet", "b", "bdo", "big", "br", "cite", "code", "del", "dfn", "em", "i", "iframe", "img", "ins", "kbd", "map", "noscript", "ns:svg", "object", "q", "samp", "script", "small", "span", "strong", "sub", "sup", "tt" or "var" (with xmlns:ns="http://www.w3.org/2000/svg")
+  94 element "caption" not allowed here; expected the element end-tag or element "tr"
+  50 text not allowed here; expected the element end-tag or element "address", "blockquote", "del", "div", "dl", "h1", "h2", "h3", "h4", "h5", "h6", "hr", "ins", "noscript", "ns:svg", "ol", "p", "pre", "script", "table" or "ul" (with xmlns:ns="http://www.w3.org/2000/svg")
+  39 text not allowed here; expected element "address", "blockquote", "del", "div", "dl", "h1", "h2", "h3", "h4", "h5", "h6", "hr", "ins", "noscript", "ns:svg", "ol", "p", "pre", "script", "table" or "ul" (with xmlns:ns="http://www.w3.org/2000/svg")
+  35 element "u" not allowed anywhere; expected the element end-tag, text or element "a", "abbr", "acronym", "applet", "b", "bdo", "big", "br", "cite", "code", "del", "dfn", "em", "i", "iframe", "img", "ins", "kbd", "map", "noscript", "ns:svg", "object", "q", "samp", "script", "small", "span", "strong", "sub", "sup", "tt" or "var" (with xmlns:ns="http://www.w3.org/2000/svg")
+  35 element "a" not allowed here; expected element "address", "blockquote", "del", "div", "dl", "h1", "h2", "h3", "h4", "h5", "h6", "hr", "ins", "noscript", "ns:svg", "ol", "p", "pre", "script", "table" or "ul" (with xmlns:ns="http://www.w3.org/2000/svg")
+  28 element "em" not allowed here; expected the element end-tag or element "address", "blockquote", "del", "div", "dl", "h1", "h2", "h3", "h4", "h5", "h6", "hr", "ins", "noscript", "ns:svg", "ol", "p", "pre", "script", "table" or "ul" (with xmlns:ns="http://www.w3.org/2000/svg")
+  10 element "font" not allowed anywhere; expected the element end-tag, text or element "a", "abbr", "acronym", "applet", "b", "bdo", "big", "br", "cite", "code", "del", "dfn", "em", "i", "iframe", "img", "ins", "kbd", "map", "noscript", "ns:svg", "object", "q", "samp", "script", "small", "span", "strong", "sub", "sup", "tt" or "var" (with xmlns:ns="http://www.w3.org/2000/svg")
+  10 element "a" not allowed here; expected element "li"
+   8 element "blockquote" incomplete; expected element "address", "blockquote", "del", "div", "dl", "h1", "h2", "h3", "h4", "h5", "h6", "hr", "ins", "noscript", "ns:svg", "ol", "p", "pre", "script", "table" or "ul" (with xmlns:ns="http://www.w3.org/2000/svg")
+   7 element "tt" not allowed here; expected element "address", "blockquote", "del", "div", "dl", "h1", "h2", "h3", "h4", "h5", "h6", "hr", "ins", "noscript", "ns:svg", "ol", "p", "pre", "script", "table" or "ul" (with xmlns:ns="http://www.w3.org/2000/svg")
+   5 element "a" not allowed here; expected the element end-tag or element "address", "blockquote", "del", "div", "dl", "h1", "h2", "h3", "h4", "h5", "h6", "hr", "ins", "noscript", "ns:svg", "ol", "p", "pre", "script", "table" or "ul" (with xmlns:ns="http://www.w3.org/2000/svg")
+   4 element "tt" not allowed here; expected the element end-tag or element "address", "blockquote", "del", "div", "dl", "h1", "h2", "h3", "h4", "h5", "h6", "hr", "ins", "noscript", "ns:svg", "ol", "p", "pre", "script", "table" or "ul" (with xmlns:ns="http://www.w3.org/2000/svg")
+   3 element "p" not allowed here; expected element "li"
+   2 element "sub" not allowed here; expected the element end-tag or element "address", "blockquote", "del", "div", "dl", "h1", "h2", "h3", "h4", "h5", "h6", "hr", "ins", "noscript", "ns:svg", "ol", "p", "pre", "script", "table" or "ul" (with xmlns:ns="http://www.w3.org/2000/svg")
diff --git a/fetch_images.sh b/fetch_images.sh
new file mode 100755
index 0000000..c89d406
--- /dev/null
+++ b/fetch_images.sh
@@ -0,0 +1,13 @@
+#! /bin/bash
+
+SRC_DIR="src/OEBPS/"
+IMAGE_SRC="http://mitpress.mit.edu/sicp/full-text/book/"
+
+for img in `grep "media-type=\"image/" ${SRC_DIR}content.opf | sed "s/.*href=\"\([^\"]*\)\".*/\1/"`; do
+    destination_file="${SRC_DIR}${img}"
+    if [ ! -e "${destination_file}" ]; then
+	image_file=`echo "${img}" | sed "s/^images\/\(.*\)/\1/"`
+	echo ${destination_file}
+	curl -s -o "${destination_file}" "${IMAGE_SRC}${image_file}"
+    fi
+done
diff --git a/fix_toc.py b/fix_toc.py
new file mode 100644
index 0000000..c92fad1
--- /dev/null
+++ b/fix_toc.py
@@ -0,0 +1,114 @@
+from collections import defaultdict, Counter
+from HTMLParser import HTMLParser
+import os.path
+import re
+import sys
+from urlparse import urldefrag
+from xml.etree import ElementTree
+
+ncx_namespace = 'http://www.daisy.org/z3986/2005/ncx/'
+
+ElementTree.register_namespace('', ncx_namespace)
+
+toc_file = sys.argv[1]
+content_dir, _ = os.path.split(toc_file)
+
+found_sections = defaultdict(Counter)
+
+
+def _tag_name(name):
+    return '{{{0}}}{1}'.format(ncx_namespace, name)
+
+
+def _section_id(section_number):
+    return '__sec_' + section_number
+
+
+def subsection_source(content_src, subsection_number):
+    section_number = subsection_match.group(1)
+    section_id = _section_id(section_number)
+
+    new_src = '#'.join([content_src, section_id])
+    return new_src
+
+
+class SectionFinder(HTMLParser):
+    def __init__(self, src_file, section_title):
+        HTMLParser.__init__(self)
+        self.last_id = None
+        self.new_src = None
+        self.consume_text = False
+        self.current_text = ''
+        self.section_title = section_title
+        self.src_file = src_file
+        self.section_title_index = found_sections[src_file][section_title]
+        self.found_sections = 0
+
+    def build_src(self, anchor_id):
+        return '#'.join([self.src_file, anchor_id])
+
+    def handle_starttag(self, tag, attrs):
+        attrs = dict(attrs)
+        if tag == 'a' and 'id' in attrs:
+            self.last_id = attrs['id']
+        elif self.last_id is not None and tag.startswith('h'):
+            self.consume_text = True
+
+    def handle_endtag(self, tag):
+        if self.last_id and tag.startswith('h'):
+            if self.current_text == self.section_title:
+                if self.found_sections == self.section_title_index:
+                    self.new_src = self.build_src(self.last_id)
+                    found_sections[self.src_file][self.section_title] += 1
+
+                self.found_sections += 1
+
+            self.last_id = None
+            self.consume_text = False
+            self.current_text = ''
+
+    def handle_data(self, data):
+        if self.consume_text:
+            self.current_text += data
+
+
+def find_content_source(section_title, content_src):
+    source_path = os.path.join(content_dir, content_src)
+    section_finder = SectionFinder(content_src, section_title)
+
+    with open(source_path) as source_file:
+        section_finder.feed(source_file.read())
+
+    return section_finder.new_src
+
+
+doc = ElementTree.parse(toc_file)
+
+for nav_point in doc.iter(_tag_name('navPoint')):
+    text_node = nav_point.find(_tag_name('navLabel')).find(_tag_name('text'))
+    content_node = nav_point.find(_tag_name('content'))
+
+    if text_node is None or content_node is None:
+        continue
+
+    old_src = content_node.get('src')
+    content_src, fragment = urldefrag(old_src)
+
+    if not fragment:
+        continue
+
+    subsection_match = re.match(r'^([0-9.]+)', text_node.text)
+    if subsection_match:
+        new_src = subsection_source(content_src, subsection_match.group(1))
+    else:
+        new_src = find_content_source(text_node.text, content_src)
+
+    if new_src is None:
+        print 'Cannot find reference for {0} in {1}'.format(text_node.text, content_src)
+        continue
+
+    print old_src, '->', new_src
+
+    content_node.set('src', new_src)
+
+doc.write(toc_file + '-new', xml_declaration=True, encoding='UTF-8')
diff --git a/src/OEBPS/book-Z-H-1.html b/src/OEBPS/book-Z-H-1.html
index 5a9cf74..7a2c09d 100644
--- a/src/OEBPS/book-Z-H-1.html
+++ b/src/OEBPS/book-Z-H-1.html
@@ -5,15 +5,15 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
   <body>
-<a name="titlepage" id="titlepage"></a>
+<a id="titlepage"></a>
 <h1>Structure and Interpretation<br />
 of Computer Programs</h1>
-<div align="left">second edition </div>
+<div style="text-align: left;">second edition </div>
 
 <p style="padding-top:7em;">Harold Abelson and Gerald Jay Sussman <br />
 with Julie Sussman </p>
diff --git a/src/OEBPS/book-Z-H-10.html b/src/OEBPS/book-Z-H-10.html
index 5aefee3..2fb7150 100644
--- a/src/OEBPS/book-Z-H-10.html
+++ b/src/OEBPS/book-Z-H-10.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,11 +13,11 @@
 
 
 
-<a name="%_sec_1.1" id="%_sec_1.1"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming</a></h2><p>
+<a id="__sec_1.1"></a>
+<h2>1.1  The Elements of Programming</h2><p>
 
 
-<a name="%_idx_118" id="%_idx_118"></a>
+<a id="__idx_118"></a>
 A powerful programming language is more than just a means for
 instructing a computer to perform tasks.  The language also serves as
 a framework within which we organize our ideas about processes.  Thus,
@@ -26,32 +26,32 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 more complex ideas.  Every powerful language has three mechanisms for
 accomplishing this:</p><p>
 
-</p><p></p><ul><a name="%_idx_120" id="%_idx_120"></a><li><strong>primitive expressions</strong>, which represent the simplest
+</p><p></p><ul><a id="__idx_120"></a><li><strong>primitive expressions</strong>, which represent the simplest
 entities the language is concerned with,<p>
 
-<a name="%_idx_122" id="%_idx_122"></a><a name="%_idx_124" id="%_idx_124"></a></p></li><li><strong>means of combination</strong>, by which compound
+<a id="__idx_122"></a><a id="__idx_124"></a></p></li><li><strong>means of combination</strong>, by which compound
 elements are built from simpler ones, and<p>
 
-<a name="%_idx_126" id="%_idx_126"></a></p></li><li><strong>means of abstraction</strong>, by
+<a id="__idx_126"></a></p></li><li><strong>means of abstraction</strong>, by
 which compound elements can be named and manipulated as units.<p>
 
 </p></li></ul><p></p><p>
 
-In programming, we deal with two kinds of elements: <a name="%_idx_128" id="%_idx_128"></a>procedures and
-<a name="%_idx_130" id="%_idx_130"></a>data. (Later we will discover that they are really not so distinct.)
+In programming, we deal with two kinds of elements: <a id="__idx_128"></a>procedures and
+<a id="__idx_130"></a>data. (Later we will discover that they are really not so distinct.)
 Informally, data is “stuff” that we want to manipulate, and
 procedures are descriptions of the rules for manipulating the data.
 Thus, any powerful programming language should be able to describe
 primitive data and primitive procedures and should have methods for
 combining and abstracting procedures and data.</p><p>
 
-In this chapter we will deal only with simple <a name="%_idx_132" id="%_idx_132"></a><a name="%_idx_134" id="%_idx_134"></a>numerical data so that
-we can focus on the rules for building procedures.<a name="call_footnote_Temp_10" href="#footnote_Temp_10" id="call_footnote_Temp_10"><sup><small>4</small></sup></a> In later chapters we will see that
+In this chapter we will deal only with simple <a id="__idx_132"></a><a id="__idx_134"></a>numerical data so that
+we can focus on the rules for building procedures.<a href="#footnote_Temp_10" id="call_footnote_Temp_10"><sup><small>4</small></sup></a> In later chapters we will see that
 these same rules allow us to build procedures to manipulate compound
 data as well.</p><p>
 
-<a name="%_sec_1.1.1" id="%_sec_1.1.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.1.1">1.1.1  Expressions</a></h3><p>
+<a id="__sec_1.1.1"></a>
+</p><h3>1.1.1  Expressions</h3><p>
 
 </p><p>
 
@@ -61,38 +61,38 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 <em>expression</em>, and the interpreter responds by displaying the result of
 its <em>evaluating</em> that expression.</p><p>
 
-<a name="%_idx_148" id="%_idx_148"></a><a name="%_idx_150" id="%_idx_150"></a>One kind of primitive expression you might type is a number.  (More
+<a id="__idx_148"></a><a id="__idx_150"></a>One kind of primitive expression you might type is a number.  (More
 precisely, the expression that you type consists of the numerals that
 represent the number in base 10.)  If you present Lisp with
 a number</p><p>
 
 </p><p></p><p><tt>486<br /></tt></p><p></p><p>
-the interpreter will respond by printing<a name="call_footnote_Temp_11" href="#footnote_Temp_11" id="call_footnote_Temp_11"><sup><small>5</small></sup></a></p><p>
+the interpreter will respond by printing<a href="#footnote_Temp_11" id="call_footnote_Temp_11"><sup><small>5</small></sup></a></p><p>
 
 </p><p></p><p><tt><i>486</i><br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_154" id="%_idx_154"></a><a name="%_idx_156" id="%_idx_156"></a>Expressions representing numbers may be combined with an <a name="%_idx_158" id="%_idx_158"></a>expression
-representing a <a name="%_idx_160" id="%_idx_160"></a><a name="%_idx_162" id="%_idx_162"></a><a name="%_idx_164" id="%_idx_164"></a><a name="%_idx_166" id="%_idx_166"></a><a name="%_idx_168" id="%_idx_168"></a>primitive procedure (such as <tt>+</tt> or <tt>*</tt>) to form a
+<a id="__idx_154"></a><a id="__idx_156"></a>Expressions representing numbers may be combined with an <a id="__idx_158"></a>expression
+representing a <a id="__idx_160"></a><a id="__idx_162"></a><a id="__idx_164"></a><a id="__idx_166"></a><a id="__idx_168"></a>primitive procedure (such as <tt>+</tt> or <tt>*</tt>) to form a
 compound expression that represents the
 application of the procedure to those numbers.  For example:</p><p>
 
-</p><p></p><p><tt>(+ 137 349)<br /><i>486</i><br /><a name="%_idx_170" id="%_idx_170"></a><a name="%_idx_172" id="%_idx_172"></a>(- 1000 334)<br /><i>666</i><br />
-(* 5 99)<br /><i>495</i><br /><a name="%_idx_174" id="%_idx_174"></a><a name="%_idx_176" id="%_idx_176"></a>(/ 10 5)<br /><i>2</i><br />
+</p><p></p><p><tt>(+ 137 349)<br /><i>486</i><br /><a id="__idx_170"></a><a id="__idx_172"></a>(- 1000 334)<br /><i>666</i><br />
+(* 5 99)<br /><i>495</i><br /><a id="__idx_174"></a><a id="__idx_176"></a>(/ 10 5)<br /><i>2</i><br />
 (+ 2.7 10)<br /><i>12.7</i><br /></tt></p><p></p><p></p><p>
 
-Expressions such as these, formed by <a name="%_idx_178" id="%_idx_178"></a>delimiting a list of expressions
-within parentheses in order to denote <a name="%_idx_180" id="%_idx_180"></a>procedure application,
+Expressions such as these, formed by <a id="__idx_178"></a>delimiting a list of expressions
+within parentheses in order to denote <a id="__idx_180"></a>procedure application,
 are called <em>combinations</em>.  The leftmost
-element in the list is called the <a name="%_idx_182" id="%_idx_182"></a><em>operator</em>, and the other
-elements are called <a name="%_idx_184" id="%_idx_184"></a><em>operands</em>.  The <a name="%_idx_186" id="%_idx_186"></a>value of a combination is
+element in the list is called the <a id="__idx_182"></a><em>operator</em>, and the other
+elements are called <a id="__idx_184"></a><em>operands</em>.  The <a id="__idx_186"></a>value of a combination is
 obtained by applying the procedure specified by the operator to the
-<a name="%_idx_188" id="%_idx_188"></a><em>arguments</em> that are the values of the operands.</p><p>
+<a id="__idx_188"></a><em>arguments</em> that are the values of the operands.</p><p>
 
 The convention of placing the operator to the left of the operands is
-known as <a name="%_idx_190" id="%_idx_190"></a><em>prefix notation</em>, and it may be somewhat confusing at
+known as <a id="__idx_190"></a><em>prefix notation</em>, and it may be somewhat confusing at
 first because it departs significantly from the customary mathematical
 convention.  Prefix notation has several advantages, however.  One of
-them is that it can accommodate <a name="%_idx_192" id="%_idx_192"></a><a name="%_idx_194" id="%_idx_194"></a>procedures that may take an arbitrary
+them is that it can accommodate <a id="__idx_192"></a><a id="__idx_194"></a>procedures that may take an arbitrary
 number of arguments, as in the following examples:</p><p>
 
 </p><p></p><p><tt>(+ 21 35 12 7)<br /><i>75</i><br /><br />
@@ -101,7 +101,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 element and the entire combination is delimited by the
 parentheses.</p><p>
 
-<a name="%_idx_196" id="%_idx_196"></a>A second advantage of prefix notation is that it extends in a
+<a id="__idx_196"></a>A second advantage of prefix notation is that it extends in a
 straightforward way to allow combinations to be <em>nested</em>, that is,
 to have combinations whose elements are themselves
 combinations:</p><p>
@@ -123,32 +123,32 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
          (+ 3 5)))<br />
    (+ (- 10 7)<br />
       6))<br /></tt></p><p></p><p>
-following a formatting convention known as <a name="%_idx_198" id="%_idx_198"></a><em>pretty-printing</em>, in
+following a formatting convention known as <a id="__idx_198"></a><em>pretty-printing</em>, in
 which each long combination is written so that the operands are
 aligned vertically.  The resulting indentations display clearly the
-structure of the expression.<a name="call_footnote_Temp_12" href="#footnote_Temp_12" id="call_footnote_Temp_12"><sup><small>6</small></sup></a></p><p>
+structure of the expression.<a href="#footnote_Temp_12" id="call_footnote_Temp_12"><sup><small>6</small></sup></a></p><p>
 
 Even with complex expressions, the interpreter always operates in the
 same basic cycle: It reads an expression from the terminal,
 evaluates the expression, and prints the result.
 This mode of operation is often expressed by saying that the
-interpreter runs in a <a name="%_idx_204" id="%_idx_204"></a><a name="%_idx_206" id="%_idx_206"></a><em>read-eval-print loop</em>.
+interpreter runs in a <a id="__idx_204"></a><a id="__idx_206"></a><em>read-eval-print loop</em>.
 Observe in particular that it is not necessary to explicitly
-instruct the interpreter to print the value of the expression.<a name="call_footnote_Temp_13" href="#footnote_Temp_13" id="call_footnote_Temp_13"><sup><small>7</small></sup></a></p><p>
+instruct the interpreter to print the value of the expression.<a href="#footnote_Temp_13" id="call_footnote_Temp_13"><sup><small>7</small></sup></a></p><p>
 
-<a name="%_sec_1.1.2" id="%_sec_1.1.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.1.2">1.1.2  Naming and the Environment</a></h3><p>
+<a id="__sec_1.1.2"></a>
+</p><h3>1.1.2  Naming and the Environment</h3><p>
 
 A critical aspect of a programming language is the means it provides
-for using <a name="%_idx_216" id="%_idx_216"></a>names to refer to computational objects.  We say that the
-<a name="%_idx_218" id="%_idx_218"></a>name identifies a <a name="%_idx_220" id="%_idx_220"></a><em>variable</em> whose <a name="%_idx_222" id="%_idx_222"></a><em>value</em> is the object.</p><p>
+for using <a id="__idx_216"></a>names to refer to computational objects.  We say that the
+<a id="__idx_218"></a>name identifies a <a id="__idx_220"></a><em>variable</em> whose <a id="__idx_222"></a><em>value</em> is the object.</p><p>
 
 In the Scheme dialect of Lisp, we
-name things with <a name="%_idx_224" id="%_idx_224"></a><a name="%_idx_226" id="%_idx_226"></a><tt>define</tt>.  Typing</p><p>
+name things with <a id="__idx_224"></a><a id="__idx_226"></a><tt>define</tt>.  Typing</p><p>
 
 </p><p></p><p><tt>(define size 2)<br /></tt></p><p></p><p>
 causes the interpreter to associate the value 2 with the
-name <tt>size</tt>.<a name="call_footnote_Temp_14" href="#footnote_Temp_14" id="call_footnote_Temp_14"><sup><small>8</small></sup></a>
+name <tt>size</tt>.<a href="#footnote_Temp_14" id="call_footnote_Temp_14"><sup><small>8</small></sup></a>
 Once the name <tt>size</tt> has been associated with the number 2, we can
 refer to the value 2 by name:</p><p>
 
@@ -163,7 +163,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 (define circumference (* 2 pi radius))<br />
 circumference<br /><i>62.8318</i><br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_232" id="%_idx_232"></a><tt>Define</tt> is our language's
+<a id="__idx_232"></a><tt>Define</tt> is our language's
 simplest means of abstraction, for it allows us to use simple names to
 refer to the results of compound operations, such as the
 <tt>circumference</tt> computed above.
@@ -175,23 +175,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 interpreter makes this step-by-step program construction particularly
 convenient because name-object associations can be created
 incrementally in successive interactions.  This feature encourages the
-<a name="%_idx_234" id="%_idx_234"></a><a name="%_idx_236" id="%_idx_236"></a>incremental development and testing of programs and is largely
-responsible for the fact that <a name="%_idx_238" id="%_idx_238"></a>a Lisp program usually consists of a large
+<a id="__idx_234"></a><a id="__idx_236"></a>incremental development and testing of programs and is largely
+responsible for the fact that <a id="__idx_238"></a>a Lisp program usually consists of a large
 number of relatively simple procedures.</p><p>
 
 It should be clear that the possibility of associating values with
 symbols and later retrieving them means that the interpreter must
 maintain some sort of memory that keeps track of the name-object
-pairs.  This memory is called the <a name="%_idx_240" id="%_idx_240"></a><em>environment</em> (more precisely
-the <a name="%_idx_242" id="%_idx_242"></a><em>global environment</em>, since we will see later that a
+pairs.  This memory is called the <a id="__idx_240"></a><em>environment</em> (more precisely
+the <a id="__idx_242"></a><em>global environment</em>, since we will see later that a
 computation may involve a number of different
-environments).<a name="call_footnote_Temp_15" href="#footnote_Temp_15" id="call_footnote_Temp_15"><sup><small>9</small></sup></a></p><p>
+environments).<a href="#footnote_Temp_15" id="call_footnote_Temp_15"><sup><small>9</small></sup></a></p><p>
 
-<a name="%_sec_1.1.3" id="%_sec_1.1.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.1.3">1.1.3  Evaluating Combinations</a></h3><p>
+<a id="__sec_1.1.3"></a>
+</p><h3>1.1.3  Evaluating Combinations</h3><p>
 
 
-<a name="%_idx_244" id="%_idx_244"></a><a name="%_idx_246" id="%_idx_246"></a>
+<a id="__idx_244"></a><a id="__idx_246"></a>
 One of our goals in this chapter is to isolate issues about thinking
 procedurally.  As a case in point, let us consider that, in evaluating
 combinations, the interpreter is itself following a procedure.</p><p>
@@ -211,23 +211,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 processes in general.  First, observe that the first step dictates
 that in order to accomplish the evaluation process for a combination
 we must first perform the evaluation process on each element of the
-combination.  Thus, the evaluation rule is <a name="%_idx_248" id="%_idx_248"></a><em>recursive</em> in nature;
+combination.  Thus, the evaluation rule is <a id="__idx_248"></a><em>recursive</em> in nature;
 that is, it includes, as one of its steps, the need to invoke the rule
-itself.<a name="call_footnote_Temp_16" href="#footnote_Temp_16" id="call_footnote_Temp_16"><sup><small>10</small></sup></a></p><p>
+itself.<a href="#footnote_Temp_16" id="call_footnote_Temp_16"><sup><small>10</small></sup></a></p><p>
 
-<a name="%_idx_250" id="%_idx_250"></a>Notice how succinctly the idea of recursion can be used to express
+<a id="__idx_250"></a>Notice how succinctly the idea of recursion can be used to express
 what, in the case of a deeply nested combination, would otherwise be
 viewed as a rather complicated process.  For example, evaluating</p><p>
 
 </p><p></p><p><tt>(* (+ 2 (* 4 6))<br />
    (+ 3 5 7))<br /></tt></p><p></p><p>
 requires that the evaluation rule be applied to four different
-combinations.  We can obtain a picture of this process by <a name="%_idx_252" id="%_idx_252"></a>representing
-the combination in the form of a <a name="%_idx_254" id="%_idx_254"></a>tree, as shown in
-figure <a href="#%_fig_1.1">1.1</a>.  Each combination is represented by a
-<a name="%_idx_256" id="%_idx_256"></a>node with <a name="%_idx_258" id="%_idx_258"></a>branches corresponding to the operator and the
+combinations.  We can obtain a picture of this process by <a id="__idx_252"></a>representing
+the combination in the form of a <a id="__idx_254"></a>tree, as shown in
+figure <a href="#__fig_1.1">1.1</a>.  Each combination is represented by a
+<a id="__idx_256"></a>node with <a id="__idx_258"></a>branches corresponding to the operator and the
 operands of the combination stemming from it.
-The <a name="%_idx_260" id="%_idx_260"></a>terminal nodes (that is, nodes with
+The <a id="__idx_260"></a>terminal nodes (that is, nodes with
 no branches stemming from them) represent either operators or numbers.
 Viewing evaluation in terms of the tree, we can imagine that the
 values of the operands percolate upward, starting from the terminal
@@ -235,9 +235,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 shall see that recursion is a very powerful technique for dealing with
 hierarchical, treelike objects.  In fact, the “percolate values
 upward” form of the evaluation rule is an example of a general kind
-of process known as <a name="%_idx_262" id="%_idx_262"></a><em>tree accumulation</em>.</p><p>
+of process known as <a id="__idx_262"></a><em>tree accumulation</em>.</p><p>
 
-<a name="%_fig_1.1" id="%_fig_1.1"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch1-Z-G-1.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 1.1:</b>  Tree representation, showing the value of each subcombination.</div></caption><tr><td>
+<a id="__fig_1.1"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch1-Z-G-1.gif" alt="ch1-Z-G-1" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 1.1:</b>  Tree representation, showing the value of each subcombination.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
@@ -246,7 +246,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 primitive expressions such as numerals, built-in operators, or other
 names.  We take care of the primitive cases by stipulating that</p><p>
 
-<a name="%_idx_264" id="%_idx_264"></a><a name="%_idx_266" id="%_idx_266"></a></p><p></p><ul><li>the values of numerals are the numbers that they name,<p>
+<a id="__idx_264"></a><a id="__idx_266"></a></p><p></p><ul><li>the values of numerals are the numbers that they name,<p>
 
 </p></li><li>the values of built-in operators are the machine
 instruction sequences that carry out the corresponding operations, and<p>
@@ -259,7 +259,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 stipulating that symbols such as <tt>+</tt> and <tt>*</tt> are also included
 in the global environment, and are associated with the sequences of
 machine instructions that are their “values.”  The key point to
-notice is the role of the <a name="%_idx_268" id="%_idx_268"></a>environment in determining the meaning of
+notice is the role of the <a id="__idx_268"></a>environment in determining the meaning of
 the symbols in expressions.  In an interactive language such as
 Lisp, it is meaningless to speak of the value of an expression such as
 <tt>(+ x 1)</tt> without specifying any information about the environment
@@ -268,7 +268,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 the environment as providing a context in which evaluation takes place
 will play an important role in our understanding of program execution.</p><p>
 
-<a name="%_idx_270" id="%_idx_270"></a>Notice that the
+<a id="__idx_270"></a>Notice that the
 evaluation rule given above does not handle definitions.
 For instance, evaluating
 <tt>(define x 3)</tt> does not apply <tt>define</tt> to two arguments, one
@@ -277,19 +277,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 <tt>x</tt> with a value.
 (That is, <tt>(define x 3)</tt> is not a combination.)</p><p>
 
-<a name="%_idx_272" id="%_idx_272"></a>Such exceptions to the general evaluation rule are called <em>special
+<a id="__idx_272"></a>Such exceptions to the general evaluation rule are called <em>special
 forms</em>.  <tt>Define</tt> is the only example of a special form that we
-have seen so far, but we will meet others shortly.  <a name="%_idx_274" id="%_idx_274"></a>Each special form
+have seen so far, but we will meet others shortly.  <a id="__idx_274"></a>Each special form
 has its own evaluation rule. The various kinds of expressions (each
-with its associated evaluation rule) constitute the <a name="%_idx_276" id="%_idx_276"></a>syntax of the
+with its associated evaluation rule) constitute the <a id="__idx_276"></a>syntax of the
 programming language.  In comparison with most other programming
 languages, Lisp has a very simple syntax; that is, the evaluation rule
 for expressions can be described by a simple general rule together
 with specialized rules for a small number of special
-forms.<a name="call_footnote_Temp_17" href="#footnote_Temp_17" id="call_footnote_Temp_17"><sup><small>11</small></sup></a></p><p>
+forms.<a href="#footnote_Temp_17" id="call_footnote_Temp_17"><sup><small>11</small></sup></a></p><p>
 
-<a name="%_sec_1.1.4" id="%_sec_1.1.4"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.1.4">1.1.4  Compound Procedures</a></h3><p>
+<a id="__sec_1.1.4"></a>
+</p><h3>1.1.4  Compound Procedures</h3><p>
 
 </p><p>
 
@@ -308,7 +308,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 </li></ul><p></p><p>
 
 Now we will learn about
-<a name="%_idx_292" id="%_idx_292"></a><em>procedure definitions</em>, a much more powerful abstraction
+<a id="__idx_292"></a><em>procedure definitions</em>, a much more powerful abstraction
 technique by which a compound operation can be given a name and then
 referred to as a unit.</p><p>
 
@@ -316,7 +316,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 might say, “To square something, multiply it by itself.”  This is
 expressed in our language as </p><p>
 
-</p><p></p><p><tt><a name="%_idx_294" id="%_idx_294"></a>(define (square x) (* x x))<br /></tt></p><p></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_294"></a>(define (square x) (* x x))<br /></tt></p><p></p><p></p><p>
 
 We can understand this in the following way:</p><p>
 
@@ -325,27 +325,27 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 </p><p></p><p><tt>(define (square  x)        (*         x     x))<br />
    ↑        ↑     ↑          ↑         ↑    ↑<br />
  To      square something, multiply   it by itself.<br /></tt></p><p></p><p>
-<a name="%_idx_296" id="%_idx_296"></a><a name="%_idx_298" id="%_idx_298"></a>We have here a <em>compound procedure</em>, which has been given the name
+<a id="__idx_296"></a><a id="__idx_298"></a>We have here a <em>compound procedure</em>, which has been given the name
 <tt>square</tt>.  The procedure represents the operation of multiplying
 something by itself.  The thing to be multiplied is given a local
 name, <tt>x</tt>, which plays the same role that a pronoun plays in
-natural language.  <a name="%_idx_300" id="%_idx_300"></a><a name="%_idx_302" id="%_idx_302"></a><a name="%_idx_304" id="%_idx_304"></a>Evaluating the definition creates this
-compound procedure and associates it with the name <tt>square</tt>.<a name="call_footnote_Temp_18" href="#footnote_Temp_18" id="call_footnote_Temp_18"><sup><small>12</small></sup></a></p><p>
+natural language.  <a id="__idx_300"></a><a id="__idx_302"></a><a id="__idx_304"></a>Evaluating the definition creates this
+compound procedure and associates it with the name <tt>square</tt>.<a href="#footnote_Temp_18" id="call_footnote_Temp_18"><sup><small>12</small></sup></a></p><p>
 
-<a name="%_idx_306" id="%_idx_306"></a><a name="%_idx_308" id="%_idx_308"></a>The general form of a procedure definition is</p><p>
+<a id="__idx_306"></a><a id="__idx_308"></a>The general form of a procedure definition is</p><p>
 
 </p><p></p><p><tt>(define (&lt;<em>name</em>&gt; &lt;<em>formal parameters</em>&gt;) &lt;<em>body</em>&gt;)<br /></tt></p><p></p><p>
-<a name="%_idx_310" id="%_idx_310"></a><a name="%_idx_312" id="%_idx_312"></a>The &lt;<em>name</em>&gt; is a symbol to be associated with the procedure
-definition in the environment.<a name="call_footnote_Temp_19" href="#footnote_Temp_19" id="call_footnote_Temp_19"><sup><small>13</small></sup></a>
-The <a name="%_idx_318" id="%_idx_318"></a><a name="%_idx_320" id="%_idx_320"></a>&lt;<em>formal parameters</em>&gt; are
+<a id="__idx_310"></a><a id="__idx_312"></a>The &lt;<em>name</em>&gt; is a symbol to be associated with the procedure
+definition in the environment.<a href="#footnote_Temp_19" id="call_footnote_Temp_19"><sup><small>13</small></sup></a>
+The <a id="__idx_318"></a><a id="__idx_320"></a>&lt;<em>formal parameters</em>&gt; are
 the names used within the body of the procedure to refer to the
 corresponding arguments of the procedure.  The
-<a name="%_idx_322" id="%_idx_322"></a><a name="%_idx_324" id="%_idx_324"></a>&lt;<em>body</em>&gt; is an expression that will yield the value of
+<a id="__idx_322"></a><a id="__idx_324"></a>&lt;<em>body</em>&gt; is an expression that will yield the value of
 the procedure application when the formal parameters are replaced by
-the actual arguments to which the procedure is applied.<a name="call_footnote_Temp_20" href="#footnote_Temp_20" id="call_footnote_Temp_20"><sup><small>14</small></sup></a>
+the actual arguments to which the procedure is applied.<a href="#footnote_Temp_20" id="call_footnote_Temp_20"><sup><small>14</small></sup></a>
 The &lt;<em>name</em>&gt;
 and the &lt;<em>formal parameters</em>&gt;
-are grouped within <a name="%_idx_328" id="%_idx_328"></a>parentheses, just as they
+are grouped within <a id="__idx_328"></a>parentheses, just as they
 would be in an actual call to the procedure being defined.</p><p>
 
 Having defined <tt>square</tt>, we can now use it:</p><p>
@@ -362,7 +362,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 <tt>sum-of-squares</tt> that, given any two numbers as arguments, produces the
 sum of their squares:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_330" id="%_idx_330"></a>(define (sum-of-squares x y)<br />
+</p><p></p><p><tt><a id="__idx_330"></a>(define (sum-of-squares x y)<br />
   (+ (square x) (square y)))<br /><br />
 (sum-of-squares 3 4)<br /><i>25</i><br /></tt></p><p></p><p>
 Now we can use <tt>sum-of-squares</tt> as a building block in constructing
@@ -371,20 +371,20 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 </p><p></p><p><tt>(define (f a)<br />
   (sum-of-squares (+ a 1) (* a 2)))<br /><br />
 (f 5)<br /><i>136</i><br /></tt></p><p></p><p>
-<a name="%_idx_332" id="%_idx_332"></a>Compound procedures are used in exactly the same way as primitive
+<a id="__idx_332"></a>Compound procedures are used in exactly the same way as primitive
 procedures.  Indeed, one could not tell by looking at the definition
 of <tt>sum-of-squares</tt> given above whether <tt>square</tt> was built into
 the interpreter, like <tt>+</tt> and <tt>*</tt>, or defined as a compound procedure.</p><p>
 
-<a name="%_sec_1.1.5" id="%_sec_1.1.5"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.1.5">1.1.5  The Substitution Model for Procedure Application</a></h3><p>
+<a id="__sec_1.1.5"></a>
+</p><h3>1.1.5  The Substitution Model for Procedure Application</h3><p>
 
 
-<a name="%_idx_334" id="%_idx_334"></a>
+<a id="__idx_334"></a>
 To evaluate a combination whose operator names a compound procedure, the
 interpreter follows much the same process as for combinations whose
 operators name primitive procedures, which we described in
-section <a href="#%_sec_1.1.3">1.1.3</a>.  That is, the interpreter
+section <a href="#__sec_1.1.3">1.1.3</a>.  That is, the interpreter
 evaluates the elements of the combination and applies the procedure
 (which is the value of the operator of the combination) to the
 arguments (which are the values of the operands of the combination).</p><p>
@@ -402,7 +402,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 
 </p><p></p><p><tt>(f 5)<br /></tt></p><p></p><p>
 where <tt>f</tt> is the procedure defined in
-section <a href="#%_sec_1.1.4">1.1.4</a>.  We begin by retrieving the
+section <a href="#__sec_1.1.4">1.1.4</a>.  We begin by retrieving the
 body of <tt>f</tt>:</p><p>
 
 </p><p></p><p><tt>(sum-of-squares (+ a 1) (* a 2))<br /></tt></p><p></p><p>
@@ -451,21 +451,21 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 with a complete implementation of an interpreter and compiler in
 chapter 5.  The substitution model is only the first of these
 models – a way to get started thinking formally about the evaluation
-process.  In general, when <a name="%_idx_336" id="%_idx_336"></a>modeling phenomena in science and
+process.  In general, when <a id="__idx_336"></a>modeling phenomena in science and
 engineering, we begin with simplified, incomplete models.  As we
 examine things in greater detail, these simple models become
 inadequate and must be replaced by more refined models.  The
 substitution model is no exception.  In particular, when we address in
 chapter 3 the use of procedures with “mutable data,” we will see that
 the substitution model breaks down and must be replaced by a more
-complicated model of procedure application.<a name="call_footnote_Temp_21" href="#footnote_Temp_21" id="call_footnote_Temp_21"><sup><small>15</small></sup></a>
+complicated model of procedure application.<a href="#footnote_Temp_21" id="call_footnote_Temp_21"><sup><small>15</small></sup></a>
 </li></ul><p></p><p>
 
-<a name="%_sec_Temp_22" id="%_sec_Temp_22"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_22">Applicative order versus normal order</a></h4><p>
+<a id="__sec_Temp_22"></a>
+</p><h4>Applicative order versus normal order</h4><p>
 
 According to the description of evaluation given in
-section <a href="#%_sec_1.1.3">1.1.3</a>, the interpreter first
+section <a href="#__sec_1.1.3">1.1.3</a>, the interpreter first
 evaluates the operator and operands and then applies the resulting procedure
 to the resulting arguments.  This is not the only way to perform
 evaluation.  An alternative evaluation model would not evaluate the
@@ -495,47 +495,47 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 with <tt>x</tt> replaced respectively by <tt>(+ 5 1)</tt> and <tt>(* 5 2)</tt>.</p><p>
 
 This alternative “fully expand and then reduce” evaluation method is
-known as <a name="%_idx_340" id="%_idx_340"></a><em>normal-order evaluation</em>, in contrast to the “evaluate
+known as <a id="__idx_340"></a><em>normal-order evaluation</em>, in contrast to the “evaluate
 the arguments and then apply” method that the interpreter actually
-uses, which is called <a name="%_idx_342" id="%_idx_342"></a><em>applicative-order evaluation</em>.  It can be
+uses, which is called <a id="__idx_342"></a><em>applicative-order evaluation</em>.  It can be
 shown that, for procedure applications that can be modeled using
 substitution (including all the procedures in the first two chapters
 of this book) and that yield legitimate values, normal-order and
 applicative-order evaluation produce the same value.  (See
-exercise <a href="#%_thm_1.5">1.5</a> for an instance of
+exercise <a href="#__thm_1.5">1.5</a> for an instance of
 an “illegitimate” value where normal-order and applicative-order
 evaluation do not give the same result.)</p><p>
 
-<a name="%_idx_344" id="%_idx_344"></a><a name="%_idx_346" id="%_idx_346"></a>Lisp uses applicative-order evaluation, partly because of the
+<a id="__idx_344"></a><a id="__idx_346"></a>Lisp uses applicative-order evaluation, partly because of the
 additional efficiency obtained from avoiding multiple evaluations of
 expressions such as those illustrated with <tt>(+ 5 1)</tt> and <tt>(* 5
 2)</tt> above and, more significantly, because normal-order evaluation
 becomes much more complicated to deal with when we leave the realm of
 procedures that can be modeled by substitution.  On the other hand,
 normal-order evaluation can be an extremely valuable tool, and we will
-investigate some of its implications in chapters 3 and 4.<a name="call_footnote_Temp_23" href="#footnote_Temp_23" id="call_footnote_Temp_23"><sup><small>16</small></sup></a></p><p>
+investigate some of its implications in chapters 3 and 4.<a href="#footnote_Temp_23" id="call_footnote_Temp_23"><sup><small>16</small></sup></a></p><p>
 
-<a name="%_sec_1.1.6" id="%_sec_1.1.6"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.1.6">1.1.6  Conditional Expressions and Predicates</a></h3><p>
+<a id="__sec_1.1.6"></a>
+</p><h3>1.1.6  Conditional Expressions and Predicates</h3><p>
 
 </p><p>
 
 The expressive power of the class of procedures that we can define at
 this point is very limited, because we have no way to make tests and
 to perform different operations depending on the result of a test.
-For instance, we cannot define a procedure that computes the <a name="%_idx_348" id="%_idx_348"></a>absolute
+For instance, we cannot define a procedure that computes the <a id="__idx_348"></a>absolute
 value of a number by testing whether the number is positive, negative,
 or zero and taking different actions in the different cases according
 to the rule</p><p>
 
-</p><p></p><div align="left"><img src="images/ch1-Z-G-2.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch1-Z-G-2.gif" alt="ch1-Z-G-2" style="border: none;" /></div><p></p><p>
 
-<a name="%_idx_350" id="%_idx_350"></a>This construct is called a <em>case analysis</em>, and
+<a id="__idx_350"></a>This construct is called a <em>case analysis</em>, and
 there is a special form in Lisp for notating such a case
-analysis.  It is called <a name="%_idx_352" id="%_idx_352"></a><a name="%_idx_354" id="%_idx_354"></a><a name="%_idx_356" id="%_idx_356"></a><tt>cond</tt> (which stands for
+analysis.  It is called <a id="__idx_352"></a><a id="__idx_354"></a><a id="__idx_356"></a><tt>cond</tt> (which stands for
 “conditional”), and it is used as follows:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_358" id="%_idx_358"></a>(define (abs x)<br />
+</p><p></p><p><tt><a id="__idx_358"></a>(define (abs x)<br />
   (cond ((&gt; x 0) x)<br />
         ((= x 0) 0)<br />
         ((&lt; x 0) (- x))))<br /></tt></p><p></p><p>
@@ -546,35 +546,35 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
       ⋮<br />
       (&lt;<em>p<sub><em>n</em></sub></em>&gt; &lt;<em>e<sub><em>n</em></sub></em>&gt;))<br /></tt></p><p></p><p>
 consisting of the symbol <tt>cond</tt> followed by
-<a name="%_idx_360" id="%_idx_360"></a>parenthesized pairs of expressions <tt>(&lt;<em>p</em>&gt; &lt;<em>e</em>&gt;)</tt>
-called <a name="%_idx_362" id="%_idx_362"></a><a name="%_idx_364" id="%_idx_364"></a><em>clauses</em>. The first expression in each pair is a <a name="%_idx_366" id="%_idx_366"></a><em>predicate</em> – that is, an expression whose value is interpreted as
-either true or false.<a name="call_footnote_Temp_24" href="#footnote_Temp_24" id="call_footnote_Temp_24"><sup><small>17</small></sup></a></p><p>
+<a id="__idx_360"></a>parenthesized pairs of expressions <tt>(&lt;<em>p</em>&gt; &lt;<em>e</em>&gt;)</tt>
+called <a id="__idx_362"></a><a id="__idx_364"></a><em>clauses</em>. The first expression in each pair is a <a id="__idx_366"></a><em>predicate</em> – that is, an expression whose value is interpreted as
+either true or false.<a href="#footnote_Temp_24" id="call_footnote_Temp_24"><sup><small>17</small></sup></a></p><p>
 
-<a name="%_idx_384" id="%_idx_384"></a><a name="%_idx_386" id="%_idx_386"></a>Conditional expressions are evaluated as follows.  The predicate
+<a id="__idx_384"></a><a id="__idx_386"></a>Conditional expressions are evaluated as follows.  The predicate
 &lt;<em>p<sub>1</sub></em>&gt; is evaluated first.  If its value is false, then
 &lt;<em>p<sub>2</sub></em>&gt; is evaluated.  If &lt;<em>p<sub>2</sub></em>&gt;'s value is also false, then
 &lt;<em>p<sub>3</sub></em>&gt; is evaluated.  This process continues until a predicate is
 found whose value is true, in which case the interpreter returns the
-value of the corresponding <a name="%_idx_388" id="%_idx_388"></a><em>consequent expression</em> &lt;<em>e</em>&gt; of the
+value of the corresponding <a id="__idx_388"></a><em>consequent expression</em> &lt;<em>e</em>&gt; of the
 clause as the value of the conditional expression.  If none of the
 &lt;<em>p</em>&gt;'s is found to be true, the value of the <tt>cond</tt> is
 undefined.</p><p>
 
-<a name="%_idx_390" id="%_idx_390"></a>The word <em>predicate</em> is used for procedures that return true
+<a id="__idx_390"></a>The word <em>predicate</em> is used for procedures that return true
 or false, as well as for expressions that evaluate to true or false.
-The absolute-value procedure <tt>abs</tt> makes use of the <a name="%_idx_392" id="%_idx_392"></a><a name="%_idx_394" id="%_idx_394"></a><a name="%_idx_396" id="%_idx_396"></a><a name="%_idx_398" id="%_idx_398"></a><a name="%_idx_400" id="%_idx_400"></a><a name="%_idx_402" id="%_idx_402"></a><a name="%_idx_404" id="%_idx_404"></a><a name="%_idx_406" id="%_idx_406"></a><a name="%_idx_408" id="%_idx_408"></a>primitive
-predicates <tt>&gt;</tt>, <tt>&lt;</tt>, and <tt>=</tt>.<a name="call_footnote_Temp_25" href="#footnote_Temp_25" id="call_footnote_Temp_25"><sup><small>18</small></sup></a> These take two
+The absolute-value procedure <tt>abs</tt> makes use of the <a id="__idx_392"></a><a id="__idx_394"></a><a id="__idx_396"></a><a id="__idx_398"></a><a id="__idx_400"></a><a id="__idx_402"></a><a id="__idx_404"></a><a id="__idx_406"></a><a id="__idx_408"></a>primitive
+predicates <tt>&gt;</tt>, <tt>&lt;</tt>, and <tt>=</tt>.<a href="#footnote_Temp_25" id="call_footnote_Temp_25"><sup><small>18</small></sup></a> These take two
 numbers as arguments and test whether the first number is,
 respectively, greater than, less than, or equal to the second number,
 returning true or false accordingly.</p><p>
 
 Another way to write the absolute-value procedure is</p><p>
 
-</p><p></p><p><tt><a name="%_idx_414" id="%_idx_414"></a>(define (abs x)<br />
+</p><p></p><p><tt><a id="__idx_414"></a>(define (abs x)<br />
   (cond ((&lt; x 0) (- x))<br />
         (else x)))<br /></tt></p><p></p><p>
 which could be expressed in English as “If <em>x</em> is less than zero
-return  - <em>x</em>; otherwise return <em>x</em>.”  <a name="%_idx_416" id="%_idx_416"></a><tt>Else</tt> is a special symbol
+return  - <em>x</em>; otherwise return <em>x</em>.”  <a id="__idx_416"></a><tt>Else</tt> is a special symbol
 that can be used in place of the &lt;<em>p</em>&gt; in the final clause of a <tt>cond</tt>.  This causes the <tt>cond</tt> to return as its value the value of
 the corresponding &lt;<em>e</em>&gt; whenever all previous clauses have been
 bypassed.  In fact, any expression that always evaluates to a true
@@ -582,27 +582,27 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 
 Here is yet another way to write the absolute-value procedure:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_418" id="%_idx_418"></a>(define (abs x)<br />
+</p><p></p><p><tt><a id="__idx_418"></a>(define (abs x)<br />
   (if (&lt; x 0)<br />
       (- x)<br />
       x))<br /></tt></p><p></p><p>
-<a name="%_idx_420" id="%_idx_420"></a><a name="%_idx_422" id="%_idx_422"></a><a name="%_idx_424" id="%_idx_424"></a>This uses the special form <tt>if</tt>, a restricted type of conditional
-that can be used when there are precisely <a name="%_idx_426" id="%_idx_426"></a>two cases in the case
+<a id="__idx_420"></a><a id="__idx_422"></a><a id="__idx_424"></a>This uses the special form <tt>if</tt>, a restricted type of conditional
+that can be used when there are precisely <a id="__idx_426"></a>two cases in the case
 analysis.  The general form of an <tt>if</tt> expression is</p><p>
 
 </p><p></p><p><tt>(if &lt;<em>predicate</em>&gt; &lt;<em>consequent</em>&gt; &lt;<em>alternative</em>&gt;)<br /></tt></p><p></p><p>
-<a name="%_idx_428" id="%_idx_428"></a><a name="%_idx_430" id="%_idx_430"></a><a name="%_idx_432" id="%_idx_432"></a>To evaluate an <tt>if</tt> expression, the interpreter starts by evaluating
-the <a name="%_idx_434" id="%_idx_434"></a>&lt;<em>predicate</em>&gt; part of the expression.  If the &lt;<em>predicate</em>&gt;
+<a id="__idx_428"></a><a id="__idx_430"></a><a id="__idx_432"></a>To evaluate an <tt>if</tt> expression, the interpreter starts by evaluating
+the <a id="__idx_434"></a>&lt;<em>predicate</em>&gt; part of the expression.  If the &lt;<em>predicate</em>&gt;
 evaluates to a true value, the interpreter then evaluates
-the <a name="%_idx_436" id="%_idx_436"></a>&lt;<em>consequent</em>&gt; and returns its value.  Otherwise it evaluates
-the <a name="%_idx_438" id="%_idx_438"></a>&lt;<em>alternative</em>&gt; and returns its value.<a name="call_footnote_Temp_26" href="#footnote_Temp_26" id="call_footnote_Temp_26"><sup><small>19</small></sup></a></p><p>
+the <a id="__idx_436"></a>&lt;<em>consequent</em>&gt; and returns its value.  Otherwise it evaluates
+the <a id="__idx_438"></a>&lt;<em>alternative</em>&gt; and returns its value.<a href="#footnote_Temp_26" id="call_footnote_Temp_26"><sup><small>19</small></sup></a></p><p>
 
 In addition to primitive
 predicates such as <tt>&lt;</tt>, <tt>=</tt>, and <tt>&gt;</tt>, there are logical
 composition operations, which enable us to construct compound
 predicates.  The three most frequently used are these:</p><p>
 
-</p><p></p><ul><a name="%_idx_446" id="%_idx_446"></a><a name="%_idx_448" id="%_idx_448"></a><a name="%_idx_450" id="%_idx_450"></a><a name="%_idx_452" id="%_idx_452"></a><li><tt>(and &lt;<em>e<sub>1</sub></em>&gt; <tt>...</tt> &lt;<em>e<sub><em>n</em></sub></em>&gt;)</tt><p>
+</p><p></p><ul><a id="__idx_446"></a><a id="__idx_448"></a><a id="__idx_450"></a><a id="__idx_452"></a><li><tt>(and &lt;<em>e<sub>1</sub></em>&gt; <tt>...</tt> &lt;<em>e<sub><em>n</em></sub></em>&gt;)</tt><p>
 
 The interpreter
 evaluates the expressions &lt;<em>e</em>&gt; one at a time, in left-to-right order.  If
@@ -611,7 +611,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 If all &lt;<em>e</em>&gt;'s evaluate to true values, the value of the <tt>and</tt>
 expression is the value of the last one.</p><p>
 
-<a name="%_idx_454" id="%_idx_454"></a><a name="%_idx_456" id="%_idx_456"></a><a name="%_idx_458" id="%_idx_458"></a><a name="%_idx_460" id="%_idx_460"></a></p></li><li><tt>(or &lt;<em>e<sub>1</sub></em>&gt; <tt>...</tt> &lt;<em>e<sub><em>n</em></sub></em>&gt;)</tt><p>
+<a id="__idx_454"></a><a id="__idx_456"></a><a id="__idx_458"></a><a id="__idx_460"></a></p></li><li><tt>(or &lt;<em>e<sub>1</sub></em>&gt; <tt>...</tt> &lt;<em>e<sub><em>n</em></sub></em>&gt;)</tt><p>
 
 The interpreter
 evaluates the expressions &lt;<em>e</em>&gt; one at a time, in left-to-right order.  If
@@ -621,13 +621,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 If all &lt;<em>e</em>&gt;'s evaluate to false,
 the value of the <tt>or</tt> expression is false.</p><p>
 
-<a name="%_idx_462" id="%_idx_462"></a><a name="%_idx_464" id="%_idx_464"></a></p></li><li><tt>(not &lt;<em>e</em>&gt;)</tt><p>
+<a id="__idx_462"></a><a id="__idx_464"></a></p></li><li><tt>(not &lt;<em>e</em>&gt;)</tt><p>
 
 The value of a <tt>not</tt> expression is true
 when the expression &lt;<em>e</em>&gt; evaluates to false, and false otherwise.
 </p></li></ul><p></p><p>
 
-<a name="%_idx_466" id="%_idx_466"></a><a name="%_idx_468" id="%_idx_468"></a>Notice that <tt>and</tt> and <tt>or</tt> are special forms, not procedures,
+<a id="__idx_466"></a><a id="__idx_468"></a>Notice that <tt>and</tt> and <tt>or</tt> are special forms, not procedures,
 because the subexpressions are not necessarily all evaluated.
 <tt>Not</tt> is an ordinary procedure.</p><p>
 
@@ -638,14 +638,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 As another example, we can define a predicate to test whether one
 number is greater than or equal to another as</p><p>
 
-</p><p></p><p><tt><a name="%_idx_470" id="%_idx_470"></a>(define (&gt;= x y)<br />
+</p><p></p><p><tt><a id="__idx_470"></a>(define (&gt;= x y)<br />
   (or (&gt; x y) (= x y)))<br /></tt></p><p></p><p>
 or alternatively as</p><p>
 
-</p><p></p><p><tt><a name="%_idx_472" id="%_idx_472"></a>(define (&gt;= x y)<br />
+</p><p></p><p><tt><a id="__idx_472"></a>(define (&gt;= x y)<br />
   (not (&lt; x y)))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_1.1" id="%_thm_1.1"></a>
+</p><p><a id="__thm_1.1"></a>
 <b>Exercise 1.1.</b>  Below is a sequence of expressions.
 What is the result printed by the interpreter in response to each
 expression?  Assume that the sequence is to be evaluated in the order
@@ -673,26 +673,26 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
    (+ a 1))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.2" id="%_thm_1.2"></a>
+</p><p><a id="__thm_1.2"></a>
 <b>Exercise 1.2.</b>  Translate the following expression into prefix form
-</p><p></p><div align="left"><img src="images/ch1-Z-G-3.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch1-Z-G-3.gif" alt="ch1-Z-G-3" style="border: none;" /></div><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.3" id="%_thm_1.3"></a>
+</p><p><a id="__thm_1.3"></a>
 <b>Exercise 1.3.</b>  Define a procedure that takes three numbers as arguments and returns
 the sum of the squares of the two larger numbers.
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.4" id="%_thm_1.4"></a>
-<b>Exercise 1.4.</b>  <a name="%_idx_474" id="%_idx_474"></a><a name="%_idx_476" id="%_idx_476"></a><a name="%_idx_478" id="%_idx_478"></a>Observe that our model of evaluation allows for combinations whose
+</p><p><a id="__thm_1.4"></a>
+<b>Exercise 1.4.</b>  <a id="__idx_474"></a><a id="__idx_476"></a><a id="__idx_478"></a>Observe that our model of evaluation allows for combinations whose
 operators are compound expressions.  Use this observation to
 describe the behavior of the following procedure:
 </p><p></p><p><tt>(define (a-plus-abs-b a b)<br />
   ((if (&gt; b 0) + -) a b))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.5" id="%_thm_1.5"></a>
-<b>Exercise 1.5.</b>  <a name="%_idx_480" id="%_idx_480"></a><a name="%_idx_482" id="%_idx_482"></a>Ben Bitdiddle has invented a test to determine whether the interpreter
+</p><p><a id="__thm_1.5"></a>
+<b>Exercise 1.5.</b>  <a id="__idx_480"></a><a id="__idx_482"></a>Ben Bitdiddle has invented a test to determine whether the interpreter
 he is faced with is using applicative-order evaluation or normal-order
 evaluation.  He defines the following two procedures:
 </p><p></p><p><tt>(define (p) (p))<br /><br />
@@ -705,7 +705,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 What behavior will Ben observe with an interpreter that uses
 applicative-order evaluation?  What behavior will he observe with an
 interpreter that uses normal-order evaluation?  Explain your answer.
-<a name="%_idx_484" id="%_idx_484"></a><a name="%_idx_486" id="%_idx_486"></a>(Assume that the evaluation rule for the special form <tt>if</tt> is the
+<a id="__idx_484"></a><a id="__idx_486"></a>(Assume that the evaluation rule for the special form <tt>if</tt> is the
 same whether the interpreter is using normal or applicative order:
 The predicate expression is evaluated first, and the result
 determines whether to evaluate
@@ -714,12 +714,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 </p><p></p><p>
 
 
-<a name="%_sec_1.1.7" id="%_sec_1.1.7"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.1.7">1.1.7  Example: Square Roots by Newton's Method</a></h3><p>
+<a id="__sec_1.1.7"></a>
+</p><h3>1.1.7  Example: Square Roots by Newton's Method</h3><p>
 
 </p><p>
 
-<a name="%_idx_488" id="%_idx_488"></a><a name="%_idx_490" id="%_idx_490"></a>Procedures, as introduced above, are much like ordinary mathematical
+<a id="__idx_488"></a><a id="__idx_490"></a>Procedures, as introduced above, are much like ordinary mathematical
 functions.  They specify a value that is determined by one or more
 parameters.  But there is an important difference between
 mathematical functions and computer procedures.  Procedures must be
@@ -727,7 +727,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 
 As a case in point, consider the problem of computing square
 roots.  We can define the square-root function as
-</p><p></p><div align="left"><img src="images/ch1-Z-G-4.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch1-Z-G-4.gif" alt="ch1-Z-G-4" style="border: none;" /></div><p></p><p>
 
 This describes a perfectly legitimate mathematical function.  We could
 use it to recognize whether one number is the square root of another, or
@@ -744,29 +744,29 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 The contrast between function and procedure is a reflection of the
 general distinction between describing properties of things and
 describing how to do things, or, as it is sometimes referred to, the
-distinction between <a name="%_idx_492" id="%_idx_492"></a><a name="%_idx_494" id="%_idx_494"></a>declarative knowledge and imperative knowledge.
-In <a name="%_idx_496" id="%_idx_496"></a><a name="%_idx_498" id="%_idx_498"></a>mathematics we are usually concerned with declarative (what is)
+distinction between <a id="__idx_492"></a><a id="__idx_494"></a>declarative knowledge and imperative knowledge.
+In <a id="__idx_496"></a><a id="__idx_498"></a>mathematics we are usually concerned with declarative (what is)
 descriptions, whereas in computer science we are usually concerned
-with imperative (how to) descriptions.<a name="call_footnote_Temp_32" href="#footnote_Temp_32" id="call_footnote_Temp_32"><sup><small>20</small></sup></a></p><p>
+with imperative (how to) descriptions.<a href="#footnote_Temp_32" id="call_footnote_Temp_32"><sup><small>20</small></sup></a></p><p>
 
-<a name="%_idx_508" id="%_idx_508"></a><a name="%_idx_510" id="%_idx_510"></a>How does one compute square roots?  The most common way is to use
+<a id="__idx_508"></a><a id="__idx_510"></a>How does one compute square roots?  The most common way is to use
 Newton's method of successive approximations, which says that whenever
 we have a guess <em>y</em> for the value of the square root of a number <em>x</em>,
 we can perform a simple manipulation to get a better guess (one closer
 to the actual square root) by averaging <em>y</em> with
-<em>x</em>/<em>y</em>.<a name="call_footnote_Temp_33" href="#footnote_Temp_33" id="call_footnote_Temp_33"><sup><small>21</small></sup></a> For example, we can compute
+<em>x</em>/<em>y</em>.<a href="#footnote_Temp_33" id="call_footnote_Temp_33"><sup><small>21</small></sup></a> For example, we can compute
 the square root of 2 as follows.  Suppose our initial guess is 1:</p><p>
 
-</p><table border="0"><tr><td valign="top">Guess </td><td valign="top">Quotient </td><td valign="top">Average</td></tr><tr><td valign="top">  </td></tr><tr><td valign="top">1      </td><td valign="top"> (2/1)  =  2        </td><td valign="top">
-((2 + 1)/2)  =  1.5 </td></tr><tr><td valign="top">  </td></tr><tr><td valign="top">1.5    </td><td valign="top"> (2/1.5)  =  1.3333 </td><td valign="top">
-((1.3333 + 1.5)/2)  =  1.4167 </td></tr><tr><td valign="top">  </td></tr><tr><td valign="top">1.4167 </td><td valign="top"> (2/1.4167)  =  1.4118 </td><td valign="top">
-((1.4167 + 1.4118)/2)  =  1.4142 </td></tr><tr><td valign="top">  </td></tr><tr><td valign="top">1.4142 </td><td valign="top"><tt>...</tt></td><td valign="top"><tt>...</tt></td></tr><tr><td valign="top"></td></tr></table><p>
+</p><table style="border: none;"><tr><td style="text-align: top;">Guess </td><td style="text-align: top;">Quotient </td><td style="text-align: top;">Average</td></tr><tr><td style="text-align: top;">  </td></tr><tr><td style="text-align: top;">1      </td><td style="text-align: top;"> (2/1)  =  2        </td><td style="text-align: top;">
+((2 + 1)/2)  =  1.5 </td></tr><tr><td style="text-align: top;">  </td></tr><tr><td style="text-align: top;">1.5    </td><td style="text-align: top;"> (2/1.5)  =  1.3333 </td><td style="text-align: top;">
+((1.3333 + 1.5)/2)  =  1.4167 </td></tr><tr><td style="text-align: top;">  </td></tr><tr><td style="text-align: top;">1.4167 </td><td style="text-align: top;"> (2/1.4167)  =  1.4118 </td><td style="text-align: top;">
+((1.4167 + 1.4118)/2)  =  1.4142 </td></tr><tr><td style="text-align: top;">  </td></tr><tr><td style="text-align: top;">1.4142 </td><td style="text-align: top;"><tt>...</tt></td><td style="text-align: top;"><tt>...</tt></td></tr><tr><td style="text-align: top;"></td></tr></table><p>
 
 Continuing this process, we obtain better and better
 approximations to the square root.</p><p>
 
 Now let's formalize the process in terms of procedures.  We start with
-a value for the <a name="%_idx_514" id="%_idx_514"></a>radicand (the number whose square root we are trying
+a value for the <a id="__idx_514"></a>radicand (the number whose square root we are trying
 to compute) and a value for the guess.  If the guess is good enough
 for our purposes, we are done; if not, we must repeat the process with an
 improved guess.  We write this basic strategy as a procedure:</p><p>
@@ -783,21 +783,21 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
   (average guess (/ x guess)))<br /></tt></p><p></p><p>
 where</p><p>
 
-</p><p></p><p><tt><a name="%_idx_516" id="%_idx_516"></a>(define (average x y)<br />
+</p><p></p><p><tt><a id="__idx_516"></a>(define (average x y)<br />
   (/ (+ x y) 2))<br /></tt></p><p></p><p>
 We also have to say what we mean by “good enough.”  The
 following will do for illustration, but it is not really a very good
-test.  (See exercise <a href="#%_thm_1.7">1.7</a>.)
+test.  (See exercise <a href="#__thm_1.7">1.7</a>.)
 The idea is to improve the answer until it is close enough so that its
 square differs from the radicand by less than a predetermined
-tolerance (here 0.001):<a name="call_footnote_Temp_34" href="#footnote_Temp_34" id="call_footnote_Temp_34"><sup><small>22</small></sup></a></p><p>
+tolerance (here 0.001):<a href="#footnote_Temp_34" id="call_footnote_Temp_34"><sup><small>22</small></sup></a></p><p>
 
 </p><p></p><p><tt>(define (good-enough? guess x)<br />
   (&lt; (abs (- (square guess) x)) 0.001))<br /></tt></p><p></p><p>
 Finally, we need a way to get started.  For instance, we can
-always guess that the square root of any number is 1:<a name="call_footnote_Temp_35" href="#footnote_Temp_35" id="call_footnote_Temp_35"><sup><small>23</small></sup></a></p><p>
+always guess that the square root of any number is 1:<a href="#footnote_Temp_35" id="call_footnote_Temp_35"><sup><small>23</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_550" id="%_idx_550"></a>(define (sqrt x)<br />
+</p><p></p><p><tt><a id="__idx_550"></a>(define (sqrt x)<br />
   (sqrt-iter 1.0 x))<br /></tt></p><p></p><p>
 If we type these definitions to the interpreter, we can use <tt>sqrt</tt>
 just as we can use any procedure:</p><p>
@@ -808,18 +808,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 (square (sqrt 1000))<br /><i>1000.000369924366</i><br /></tt></p><p></p><p>
 </p><p>
 
-<a name="%_idx_552" id="%_idx_552"></a>The <tt>sqrt</tt> program also illustrates that the simple procedural
+<a id="__idx_552"></a>The <tt>sqrt</tt> program also illustrates that the simple procedural
 language we have introduced so far is sufficient for writing any
 purely numerical program that one could write in, say, C or
 Pascal.  This might seem surprising, since we have not included in
-our language any iterative <a name="%_idx_554" id="%_idx_554"></a>(looping) constructs that direct the
+our language any iterative <a id="__idx_554"></a>(looping) constructs that direct the
 computer to do something over and over again.  <tt>Sqrt-iter</tt>, on the
 other hand, demonstrates how iteration can be accomplished using no
 special construct other than the ordinary ability to call a
-procedure.<a name="call_footnote_Temp_36" href="#footnote_Temp_36" id="call_footnote_Temp_36"><sup><small>24</small></sup></a>
+procedure.<a href="#footnote_Temp_36" id="call_footnote_Temp_36"><sup><small>24</small></sup></a>
 
-</p><p><a name="%_thm_1.6" id="%_thm_1.6"></a>
-<b>Exercise 1.6.</b>  <a name="%_idx_556" id="%_idx_556"></a><a name="%_idx_558" id="%_idx_558"></a>Alyssa P. Hacker doesn't see why <tt>if</tt> needs
+</p><p><a id="__thm_1.6"></a>
+<b>Exercise 1.6.</b>  <a id="__idx_556"></a><a id="__idx_558"></a>Alyssa P. Hacker doesn't see why <tt>if</tt> needs
 to be provided as a special form.  “Why can't I just define it as an
 ordinary procedure in terms of <tt>cond</tt>?” she asks.
 Alyssa's friend Eva Lu Ator claims this can indeed be done, and
@@ -845,7 +845,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.7" id="%_thm_1.7"></a>
+</p><p><a id="__thm_1.7"></a>
 <b>Exercise 1.7.</b>  The <tt>good-enough?</tt> test used in computing square roots will not be
 very effective for finding the square roots of very small numbers.
 Also, in real computers, arithmetic operations are almost always
@@ -858,65 +858,65 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 small and large numbers?
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.8" id="%_thm_1.8"></a>
-<b>Exercise 1.8.</b>  <a name="%_idx_560" id="%_idx_560"></a><a name="%_idx_562" id="%_idx_562"></a>Newton's method for cube roots is based on the fact that if <em>y</em> is an
+</p><p><a id="__thm_1.8"></a>
+<b>Exercise 1.8.</b>  <a id="__idx_560"></a><a id="__idx_562"></a>Newton's method for cube roots is based on the fact that if <em>y</em> is an
 approximation to the cube root of <em>x</em>, then a better approximation is
 given by the value
-</p><p></p><div align="left"><img src="images/ch1-Z-G-5.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch1-Z-G-5.gif" alt="ch1-Z-G-5" style="border: none;" /></div><p>
 Use this formula to implement a cube-root procedure analogous to the
-square-root procedure.  (In section <a href="book-Z-H-12.html#%_sec_1.3.4">1.3.4</a> we
+square-root procedure.  (In section <a href="book-Z-H-12.html#__sec_1.3.4">1.3.4</a> we
 will see how to implement Newton's method in general as an abstraction
 of these square-root and cube-root procedures.)
 </p><p></p><p>
 
-<a name="%_sec_1.1.8" id="%_sec_1.1.8"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.1.8">1.1.8  Procedures as Black-Box Abstractions</a></h3><p>
+<a id="__sec_1.1.8"></a>
+</p><h3>1.1.8  Procedures as Black-Box Abstractions</h3><p>
 
 </p><p>
 
 <tt>Sqrt</tt> is our first example of a process defined by a set of
-mutually defined procedures.  Notice that the definition of <tt>sqrt-iter</tt> is <a name="%_idx_564" id="%_idx_564"></a><em>recursive</em>; that is, the procedure is defined in
+mutually defined procedures.  Notice that the definition of <tt>sqrt-iter</tt> is <a id="__idx_564"></a><em>recursive</em>; that is, the procedure is defined in
 terms of itself.  The idea of being able to define a procedure in
 terms of itself may be disturbing; it may seem unclear how such a
 “circular” definition could make sense at all, much less specify a
 well-defined process to be carried out by a computer.  This will be
 addressed more carefully in
-section <a href="book-Z-H-11.html#%_sec_1.2">1.2</a>.  But first let's consider
+section <a href="book-Z-H-11.html#__sec_1.2">1.2</a>.  But first let's consider
 some other important points illustrated by the <tt>sqrt</tt> example.</p><p>
 
-<a name="%_idx_566" id="%_idx_566"></a>Observe that the problem of computing square roots breaks up naturally
+<a id="__idx_566"></a>Observe that the problem of computing square roots breaks up naturally
 into a number of subproblems: how to tell whether a guess is good
 enough, how to improve a guess, and so on.  Each of these tasks is
 accomplished by a separate procedure.  The entire <tt>sqrt</tt> program
 can be viewed as a cluster of procedures (shown in
-figure <a href="#%_fig_1.2">1.2</a>) that mirrors the decomposition of
+figure <a href="#__fig_1.2">1.2</a>) that mirrors the decomposition of
 the problem into subproblems.</p><p>
 
-<a name="%_fig_1.2" id="%_fig_1.2"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch1-Z-G-6.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 1.2:</b>  Procedural decomposition of the <tt>sqrt</tt> program.</div></caption><tr><td>
+<a id="__fig_1.2"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch1-Z-G-6.gif" alt="ch1-Z-G-6" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 1.2:</b>  Procedural decomposition of the <tt>sqrt</tt> program.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_idx_568" id="%_idx_568"></a>The importance of this decomposition strategy is not simply that one
+<a id="__idx_568"></a>The importance of this decomposition strategy is not simply that one
 is dividing the program into parts.  After all, we could take any
 large program and divide it into parts – the first ten lines, the next
 ten lines, the next ten lines, and so on.  Rather, it is crucial that
 each procedure accomplishes an identifiable task that can be used as a
-module in defining other procedures.  <a name="%_idx_570" id="%_idx_570"></a>For example, when we define the
+module in defining other procedures.  <a id="__idx_570"></a>For example, when we define the
 <tt>good-enough?</tt> procedure in terms of <tt>square</tt>, we are able to
-regard the <tt>square</tt> procedure as a <a name="%_idx_572" id="%_idx_572"></a>“black box.”  We are not at
+regard the <tt>square</tt> procedure as a <a id="__idx_572"></a>“black box.”  We are not at
 that moment concerned with <em>how</em> the procedure computes its
 result, only with the fact that it computes the square.  The details
 of how the square is computed can be suppressed, to be considered at a
 later time.  Indeed, as far as the <tt>good-enough?</tt> procedure is
 concerned, <tt>square</tt> is not quite a procedure but rather an
-abstraction of a procedure, a so-called <a name="%_idx_574" id="%_idx_574"></a><a name="%_idx_576" id="%_idx_576"></a><em>procedural abstraction</em>.
+abstraction of a procedure, a so-called <a id="__idx_574"></a><a id="__idx_576"></a><em>procedural abstraction</em>.
 At this level of abstraction, any procedure that computes the square
 is equally good.</p><p>
 
 Thus, considering only the values they return, the following two procedures for
 squaring a number should be indistinguishable.  Each takes a numerical
 argument and produces the square of that number as the
-value.<a name="call_footnote_Temp_40" href="#footnote_Temp_40" id="call_footnote_Temp_40"><sup><small>25</small></sup></a></p><p>
+value.<a href="#footnote_Temp_40" id="call_footnote_Temp_40"><sup><small>25</small></sup></a></p><p>
 
 </p><p></p><p><tt>(define (square x) (* x x))<br /><br />
 (define (square x) <br />
@@ -929,10 +929,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 user should not need to know how the procedure is implemented in order
 to use it.</p><p>
 
-<a name="%_sec_Temp_41" id="%_sec_Temp_41"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_41">Local names</a></h4><p>
+<a id="__sec_Temp_41"></a>
+</p><h4>Local names</h4><p>
 
-<a name="%_idx_578" id="%_idx_578"></a>
+<a id="__idx_578"></a>
 One detail of a procedure's implementation that should not matter to
 the user of the procedure is the implementer's choice of names for the
 procedure's formal parameters.  Thus, the following procedures should
@@ -966,16 +966,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 <tt>square</tt> we used.  Thus, <tt>square</tt> would not be the black box
 we desired.</p><p>
 
-<a name="%_idx_580" id="%_idx_580"></a><a name="%_idx_582" id="%_idx_582"></a>A formal parameter of a procedure has a very special role in the
+<a id="__idx_580"></a><a id="__idx_582"></a>A formal parameter of a procedure has a very special role in the
 procedure definition, in that it doesn't matter what name the formal
-parameter has.  Such a name is called a <a name="%_idx_584" id="%_idx_584"></a><a name="%_idx_586" id="%_idx_586"></a><em>bound variable</em>, and we
-say that the procedure definition <a name="%_idx_588" id="%_idx_588"></a><em>binds</em> its formal parameters.
+parameter has.  Such a name is called a <a id="__idx_584"></a><a id="__idx_586"></a><em>bound variable</em>, and we
+say that the procedure definition <a id="__idx_588"></a><em>binds</em> its formal parameters.
 The meaning of a procedure definition is unchanged if a bound variable
-is consistently renamed throughout the definition.<a name="call_footnote_Temp_42" href="#footnote_Temp_42" id="call_footnote_Temp_42"><sup><small>26</small></sup></a>  If a variable is not bound, we say that it is <a name="%_idx_590" id="%_idx_590"></a><a name="%_idx_592" id="%_idx_592"></a><em>free</em>.  The
+is consistently renamed throughout the definition.<a href="#footnote_Temp_42" id="call_footnote_Temp_42"><sup><small>26</small></sup></a>  If a variable is not bound, we say that it is <a id="__idx_590"></a><a id="__idx_592"></a><em>free</em>.  The
 set of expressions for which a binding defines a name is called the
-<a name="%_idx_594" id="%_idx_594"></a><a name="%_idx_596" id="%_idx_596"></a><em>scope</em> of that name.
+<a id="__idx_594"></a><a id="__idx_596"></a><em>scope</em> of that name.
 In a procedure definition, the bound variables
-declared as the <a name="%_idx_598" id="%_idx_598"></a><a name="%_idx_600" id="%_idx_600"></a><a name="%_idx_602" id="%_idx_602"></a>formal parameters of the procedure have the body of
+declared as the <a id="__idx_598"></a><a id="__idx_600"></a><a id="__idx_602"></a>formal parameters of the procedure have the body of
 the procedure as their scope.</p><p>
 
 In the definition of <tt>good-enough?</tt> above, <tt>guess</tt> and <tt>x</tt> are
@@ -983,7 +983,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 The meaning of <tt>good-enough?</tt> should be independent of the names we
 choose for <tt>guess</tt> and <tt>x</tt> so long as they are distinct and
 different from <tt>&lt;</tt>, <tt>-</tt>, <tt>abs</tt>, and <tt>square</tt>.  (If we renamed
-<tt>guess</tt> to <tt>abs</tt> we would have introduced a bug by <a name="%_idx_604" id="%_idx_604"></a><a name="%_idx_606" id="%_idx_606"></a><a name="%_idx_608" id="%_idx_608"></a><em>capturing</em>
+<tt>guess</tt> to <tt>abs</tt> we would have introduced a bug by <a id="__idx_604"></a><a id="__idx_606"></a><a id="__idx_608"></a><em>capturing</em>
 the variable <tt>abs</tt>.  It would have changed from free to bound.)  The
 meaning of <tt>good-enough?</tt> is not independent of the names of its
 free variables, however.  It surely depends upon the fact (external to
@@ -992,15 +992,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 compute a different function if we substitute <tt>cos</tt> for <tt>abs</tt> in
 its definition.</p><p>
 
-<a name="%_sec_Temp_43" id="%_sec_Temp_43"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_43">Internal definitions and block structure</a></h4><p>
+<a id="__sec_Temp_43"></a>
+</p><h4>Internal definitions and block structure</h4><p>
 
 </p><p>
 
 We have one kind of name isolation available to us so far: The formal
 parameters of a procedure are local to the body of the procedure.  The
 square-root program illustrates another way in which we would like to
-control the use of names.  <a name="%_idx_610" id="%_idx_610"></a>The existing program consists of
+control the use of names.  <a id="__idx_610"></a>The existing program consists of
 separate procedures:</p><p>
 
 </p><p></p><p><tt>(define (sqrt x)<br />
@@ -1029,7 +1029,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 approximations, each having its own private
 <tt>good-enough?</tt> procedure.  To make this possible, we allow a
 procedure to have
-<a name="%_idx_612" id="%_idx_612"></a><a name="%_idx_614" id="%_idx_614"></a>internal definitions that are local to that procedure.  For example,
+<a id="__idx_612"></a><a id="__idx_614"></a>internal definitions that are local to that procedure.  For example,
 in the square-root problem we can write</p><p>
 
 </p><p></p><p><tt>(define (sqrt x)<br />
@@ -1051,13 +1051,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 <tt>sqrt</tt>, the procedures <tt>good-enough?</tt>, <tt>improve</tt>, and
 <tt>sqrt-iter</tt>, which are defined internally to <tt>sqrt</tt>, are in the
 scope of <tt>x</tt>.  Thus, it is not necessary to pass <tt>x</tt> explicitly to
-each of these procedures.  Instead, we allow <tt>x</tt> to be a <a name="%_idx_616" id="%_idx_616"></a><a name="%_idx_618" id="%_idx_618"></a>free
+each of these procedures.  Instead, we allow <tt>x</tt> to be a <a id="__idx_616"></a><a id="__idx_618"></a>free
 variable in the internal definitions, as shown below. Then <tt>x</tt>
 gets its value from the argument with which the enclosing
-procedure <tt>sqrt</tt> is called.  This discipline is called <a name="%_idx_620" id="%_idx_620"></a><em>lexical
-scoping</em>.<a name="call_footnote_Temp_44" href="#footnote_Temp_44" id="call_footnote_Temp_44"><sup><small>27</small></sup></a></p><p>
+procedure <tt>sqrt</tt> is called.  This discipline is called <a id="__idx_620"></a><em>lexical
+scoping</em>.<a href="#footnote_Temp_44" id="call_footnote_Temp_44"><sup><small>27</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_624" id="%_idx_624"></a>(define (sqrt x)<br />
+</p><p></p><p><tt><a id="__idx_624"></a>(define (sqrt x)<br />
   (define (good-enough? guess)<br />
     (&lt; (abs (- (square guess) x)) 0.001))<br />
   (define (improve guess)<br />
@@ -1069,26 +1069,26 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
   (sqrt-iter 1.0))<br /></tt></p><p></p><p></p><p>
 
 We will use block structure extensively to help us break
-up large programs into tractable pieces.<a name="call_footnote_Temp_45" href="#footnote_Temp_45" id="call_footnote_Temp_45"><sup><small>28</small></sup></a>
+up large programs into tractable pieces.<a href="#footnote_Temp_45" id="call_footnote_Temp_45"><sup><small>28</small></sup></a>
 The idea of block structure originated with the
-programming language <a name="%_idx_628" id="%_idx_628"></a>Algol 60.  It appears in most advanced
+programming language <a id="__idx_628"></a>Algol 60.  It appears in most advanced
 programming languages and is an important tool for helping to organize
 the construction of large programs.</p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_10" href="#call_footnote_Temp_10" id="footnote_Temp_10"><sup><small>4</small></sup></a> The
+</p><div class="footnote"><p><a href="#call_footnote_Temp_10" id="footnote_Temp_10"><sup><small>4</small></sup></a> The
 characterization of numbers as “simple data” is a barefaced bluff.
 In fact, the treatment of numbers is one of the trickiest and most
 confusing aspects of any programming language.  Some typical issues
 involved are these:
-<a name="%_idx_136" id="%_idx_136"></a><a name="%_idx_138" id="%_idx_138"></a><a name="%_idx_140" id="%_idx_140"></a>Some computer systems distinguish <em>integers</em>, such as 2, from
+<a id="__idx_136"></a><a id="__idx_138"></a><a id="__idx_140"></a>Some computer systems distinguish <em>integers</em>, such as 2, from
 <em>real numbers</em>, such as 2.71.  Is the real number 2.00 different
 from the integer 2?
 Are the arithmetic operations used
 for integers the same as the operations used for real numbers?  Does 6
 divided by 2 produce 3, or 3.0?  How large a number can we represent?
 How many decimal places of accuracy can we represent?  Is the range of
-integers the same as the range of real numbers?  <a name="%_idx_142" id="%_idx_142"></a><a name="%_idx_144" id="%_idx_144"></a><a name="%_idx_146" id="%_idx_146"></a>Above and beyond
+integers the same as the range of real numbers?  <a id="__idx_142"></a><a id="__idx_144"></a><a id="__idx_146"></a>Above and beyond
 these questions, of course, lies a collection of issues concerning
 roundoff and truncation errors – the entire science of numerical
 analysis.  Since our focus in this book is on large-scale program
@@ -1098,34 +1098,34 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 operations that preserve a limited number of decimal places of
 accuracy in noninteger operations.
 
-</p><p><a name="footnote_Temp_11" href="#call_footnote_Temp_11" id="footnote_Temp_11"><sup><small>5</small></sup></a> Throughout this book,
-<a name="%_idx_152" id="%_idx_152"></a>when we wish to emphasize the distinction between the input typed by
+</p><p><a href="#call_footnote_Temp_11" id="footnote_Temp_11"><sup><small>5</small></sup></a> Throughout this book,
+<a id="__idx_152"></a>when we wish to emphasize the distinction between the input typed by
 the user and the response printed by the interpreter, we will show the
 latter in slanted characters.
 
-</p><p><a name="footnote_Temp_12" href="#call_footnote_Temp_12" id="footnote_Temp_12"><sup><small>6</small></sup></a> <a name="%_idx_200" id="%_idx_200"></a><a name="%_idx_202" id="%_idx_202"></a>Lisp systems typically provide
+</p><p><a href="#call_footnote_Temp_12" id="footnote_Temp_12"><sup><small>6</small></sup></a> <a id="__idx_200"></a><a id="__idx_202"></a>Lisp systems typically provide
 features to aid the user in formatting expressions.  Two especially
 useful features are one that automatically indents to the proper
 pretty-print position whenever a new line is started and one that
 highlights the matching left parenthesis whenever a right parenthesis
 is typed.
 
-</p><p><a name="footnote_Temp_13" href="#call_footnote_Temp_13" id="footnote_Temp_13"><sup><small>7</small></sup></a> <a name="%_idx_208" id="%_idx_208"></a><a name="%_idx_210" id="%_idx_210"></a><a name="%_idx_212" id="%_idx_212"></a><a name="%_idx_214" id="%_idx_214"></a>Lisp obeys the convention that every
+</p><p><a href="#call_footnote_Temp_13" id="footnote_Temp_13"><sup><small>7</small></sup></a> <a id="__idx_208"></a><a id="__idx_210"></a><a id="__idx_212"></a><a id="__idx_214"></a>Lisp obeys the convention that every
 expression has a value. This convention, together with the old
 reputation of Lisp as an inefficient language, is the source of the
 quip by Alan Perlis (paraphrasing Oscar Wilde)
 that “Lisp programmers know the value of
 everything but the cost of nothing.”
 
-</p><p><a name="footnote_Temp_14" href="#call_footnote_Temp_14" id="footnote_Temp_14"><sup><small>8</small></sup></a> <a name="%_idx_228" id="%_idx_228"></a><a name="%_idx_230" id="%_idx_230"></a>In this book, we do not show the interpreter's response to
+</p><p><a href="#call_footnote_Temp_14" id="footnote_Temp_14"><sup><small>8</small></sup></a> <a id="__idx_228"></a><a id="__idx_230"></a>In this book, we do not show the interpreter's response to
 evaluating definitions, since this is highly
 implementation-dependent.
 
-</p><p><a name="footnote_Temp_15" href="#call_footnote_Temp_15" id="footnote_Temp_15"><sup><small>9</small></sup></a> Chapter 3 will show that this notion of
+</p><p><a href="#call_footnote_Temp_15" id="footnote_Temp_15"><sup><small>9</small></sup></a> Chapter 3 will show that this notion of
 environment is crucial, both for understanding how the interpreter
 works and for implementing interpreters.
 
-</p><p><a name="footnote_Temp_16" href="#call_footnote_Temp_16" id="footnote_Temp_16"><sup><small>10</small></sup></a> It may seem strange that the evaluation rule says, as
+</p><p><a href="#call_footnote_Temp_16" id="footnote_Temp_16"><sup><small>10</small></sup></a> It may seem strange that the evaluation rule says, as
 part of the first step, that we should evaluate the leftmost element
 of a combination, since at this point that can only be an operator
 such as <tt>+</tt> or <tt>*</tt>
@@ -1133,7 +1133,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 multiplication.  We will see later that it is useful to be able to work with
 combinations whose operators are themselves compound expressions.
 
-</p><p><a name="footnote_Temp_17" href="#call_footnote_Temp_17" id="footnote_Temp_17"><sup><small>11</small></sup></a> <a name="%_idx_278" id="%_idx_278"></a><a name="%_idx_280" id="%_idx_280"></a><a name="%_idx_282" id="%_idx_282"></a><a name="%_idx_284" id="%_idx_284"></a><a name="%_idx_286" id="%_idx_286"></a><a name="%_idx_288" id="%_idx_288"></a><a name="%_idx_290" id="%_idx_290"></a>Special syntactic forms that are simply convenient
+</p><p><a href="#call_footnote_Temp_17" id="footnote_Temp_17"><sup><small>11</small></sup></a> <a id="__idx_278"></a><a id="__idx_280"></a><a id="__idx_282"></a><a id="__idx_284"></a><a id="__idx_286"></a><a id="__idx_288"></a><a id="__idx_290"></a>Special syntactic forms that are simply convenient
 alternative surface structures for things that can be written in more
 uniform ways are sometimes called <em>syntactic sugar</em>, to use a
 phrase coined by Peter Landin.  In comparison with users of other
@@ -1147,26 +1147,26 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 become large and complex.  In the words of Alan Perlis, “Syntactic
 sugar causes cancer of the semicolon.”
 
-</p><p><a name="footnote_Temp_18" href="#call_footnote_Temp_18" id="footnote_Temp_18"><sup><small>12</small></sup></a> Observe that there are two different operations
+</p><p><a href="#call_footnote_Temp_18" id="footnote_Temp_18"><sup><small>12</small></sup></a> Observe that there are two different operations
 being combined here: we are creating the procedure, and we are giving
 it the name <tt>square</tt>.  It is possible, indeed important, to be
 able to separate these two notions – to create procedures without
 naming them, and to give names to procedures that have already been
-created.  We will see how to do this in section <a href="book-Z-H-12.html#%_sec_1.3.2">1.3.2</a>.
+created.  We will see how to do this in section <a href="book-Z-H-12.html#__sec_1.3.2">1.3.2</a>.
 
-</p><p><a name="footnote_Temp_19" href="#call_footnote_Temp_19" id="footnote_Temp_19"><sup><small>13</small></sup></a> Throughout this book, we will
-<a name="%_idx_314" id="%_idx_314"></a><a name="%_idx_316" id="%_idx_316"></a>describe the general syntax of expressions by using italic symbols
+</p><p><a href="#call_footnote_Temp_19" id="footnote_Temp_19"><sup><small>13</small></sup></a> Throughout this book, we will
+<a id="__idx_314"></a><a id="__idx_316"></a>describe the general syntax of expressions by using italic symbols
 delimited by angle brackets – e.g., &lt;<em>name</em>&gt; – to denote the
 “slots” in the expression to be filled in when such an expression is
 actually used.
 
-</p><p><a name="footnote_Temp_20" href="#call_footnote_Temp_20" id="footnote_Temp_20"><sup><small>14</small></sup></a> More
-<a name="%_idx_326" id="%_idx_326"></a>generally, the body of the procedure can be a sequence of expressions.
+</p><p><a href="#call_footnote_Temp_20" id="footnote_Temp_20"><sup><small>14</small></sup></a> More
+<a id="__idx_326"></a>generally, the body of the procedure can be a sequence of expressions.
 In this case, the interpreter evaluates each expression in the
 sequence in turn and returns the value of the final expression as the
 value of the procedure application.
 
-</p><p><a name="footnote_Temp_21" href="#call_footnote_Temp_21" id="footnote_Temp_21"><sup><small>15</small></sup></a> Despite the
+</p><p><a href="#call_footnote_Temp_21" id="footnote_Temp_21"><sup><small>15</small></sup></a> Despite the
 simplicity of the substitution idea, it turns out to be surprisingly
 complicated to give a rigorous mathematical definition of the
 substitution process.  The problem arises from the possibility of
@@ -1174,17 +1174,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 procedure and the (possibly identical) names used in the expressions
 to which the procedure may be applied.  Indeed, there is a long
 history of erroneous definitions of <em>substitution</em> in the
-literature of logic and programming semantics.  <a name="%_idx_338" id="%_idx_338"></a>See Stoy 1977 for a
+literature of logic and programming semantics.  <a id="__idx_338"></a>See Stoy 1977 for a
 careful discussion of substitution.
 
-</p><p><a name="footnote_Temp_23" href="#call_footnote_Temp_23" id="footnote_Temp_23"><sup><small>16</small></sup></a> In
+</p><p><a href="#call_footnote_Temp_23" id="footnote_Temp_23"><sup><small>16</small></sup></a> In
 chapter 3 we will introduce <em>stream processing</em>, which is a way of
 handling apparently “infinite” data structures by incorporating a
 limited form of normal-order evaluation.  In
-section <a href="book-Z-H-27.html#%_sec_4.2">4.2</a> we will modify the Scheme
+section <a href="book-Z-H-27.html#__sec_4.2">4.2</a> we will modify the Scheme
 interpreter to produce a normal-order variant of Scheme.
 
-</p><p><a name="footnote_Temp_24" href="#call_footnote_Temp_24" id="footnote_Temp_24"><sup><small>17</small></sup></a> <a name="%_idx_368" id="%_idx_368"></a><a name="%_idx_370" id="%_idx_370"></a><a name="%_idx_372" id="%_idx_372"></a><a name="%_idx_374" id="%_idx_374"></a><a name="%_idx_376" id="%_idx_376"></a><a name="%_idx_378" id="%_idx_378"></a><a name="%_idx_380" id="%_idx_380"></a><a name="%_idx_382" id="%_idx_382"></a>“Interpreted as either true or false”
+</p><p><a href="#call_footnote_Temp_24" id="footnote_Temp_24"><sup><small>17</small></sup></a> <a id="__idx_368"></a><a id="__idx_370"></a><a id="__idx_372"></a><a id="__idx_374"></a><a id="__idx_376"></a><a id="__idx_378"></a><a id="__idx_380"></a><a id="__idx_382"></a>“Interpreted as either true or false”
 means this: In Scheme, there are two distinguished values that are
 denoted by the constants <tt>#t</tt> and <tt>#f</tt>.  When the interpreter
 checks a predicate's value, it interprets <tt>#f</tt> as false.  Any other value
@@ -1193,12 +1193,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 names <tt>true</tt> and <tt>false</tt>, which are associated
 with the values <tt>#t</tt> and <tt>#f</tt> respectively.
 
-</p><p><a name="footnote_Temp_25" href="#call_footnote_Temp_25" id="footnote_Temp_25"><sup><small>18</small></sup></a> <tt>Abs</tt> also uses
-<a name="%_idx_410" id="%_idx_410"></a><a name="%_idx_412" id="%_idx_412"></a>the “minus” operator <tt>-</tt>, which, when used with a single
+</p><p><a href="#call_footnote_Temp_25" id="footnote_Temp_25"><sup><small>18</small></sup></a> <tt>Abs</tt> also uses
+<a id="__idx_410"></a><a id="__idx_412"></a>the “minus” operator <tt>-</tt>, which, when used with a single
 operand, as in <tt>(- x)</tt>, indicates negation.
 
-</p><p><a name="footnote_Temp_26" href="#call_footnote_Temp_26" id="footnote_Temp_26"><sup><small>19</small></sup></a> A minor difference
-<a name="%_idx_440" id="%_idx_440"></a><a name="%_idx_442" id="%_idx_442"></a><a name="%_idx_444" id="%_idx_444"></a>between <tt>if</tt> and <tt>cond</tt> is that the
+</p><p><a href="#call_footnote_Temp_26" id="footnote_Temp_26"><sup><small>19</small></sup></a> A minor difference
+<a id="__idx_440"></a><a id="__idx_442"></a><a id="__idx_444"></a>between <tt>if</tt> and <tt>cond</tt> is that the
 &lt;<em>e</em>&gt; part of each <tt>cond</tt> clause may be a sequence of expressions.
 If the corresponding &lt;<em>p</em>&gt; is found to be true, the expressions
 &lt;<em>e</em>&gt; are evaluated in sequence and the value of the final
@@ -1206,78 +1206,78 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.1">1.1  The Elements of Programming
 In an <tt>if</tt> expression, however, the &lt;<em>consequent</em>&gt; and
 &lt;<em>alternative</em>&gt; must be single expressions.
 
-</p><p><a name="footnote_Temp_32" href="#call_footnote_Temp_32" id="footnote_Temp_32"><sup><small>20</small></sup></a> Declarative and
+</p><p><a href="#call_footnote_Temp_32" id="footnote_Temp_32"><sup><small>20</small></sup></a> Declarative and
 imperative descriptions are intimately related, as indeed are
 mathematics and computer science.  For instance, to say that the
-answer produced by a program is <a name="%_idx_500" id="%_idx_500"></a>“correct” is to make a declarative
+answer produced by a program is <a id="__idx_500"></a>“correct” is to make a declarative
 statement about the program.  There is a large amount of research
-aimed at establishing techniques for <a name="%_idx_502" id="%_idx_502"></a>proving that programs are
+aimed at establishing techniques for <a id="__idx_502"></a>proving that programs are
 correct, and much of the technical difficulty of this subject has to
 do with negotiating the transition between imperative statements (from
 which programs are constructed) and declarative statements (which can
 be used to deduce things).  In a related vein, an important current
 area in programming-language design is the exploration of so-called
-<a name="%_idx_504" id="%_idx_504"></a><a name="%_idx_506" id="%_idx_506"></a>very high-level languages, in which one actually programs in terms of
+<a id="__idx_504"></a><a id="__idx_506"></a>very high-level languages, in which one actually programs in terms of
 declarative statements.  The idea is to make interpreters
 sophisticated enough so that, given “what is” knowledge specified by
 the programmer, they can generate “how to” knowledge automatically.
 This cannot be done in general, but there are important areas where
 progress has been made.  We shall revisit this idea in chapter 4.
 
-</p><p><a name="footnote_Temp_33" href="#call_footnote_Temp_33" id="footnote_Temp_33"><sup><small>21</small></sup></a> This square-root algorithm is actually a special case
+</p><p><a href="#call_footnote_Temp_33" id="footnote_Temp_33"><sup><small>21</small></sup></a> This square-root algorithm is actually a special case
 of Newton's method, which is a general technique for finding roots of
 equations.  The square-root algorithm itself was developed by Heron of
-<a name="%_idx_512" id="%_idx_512"></a>Alexandria in the first century <font size="-2">A</font>.<font size="-2">D</font>.  We will see how to express
+<a id="__idx_512"></a>Alexandria in the first century <font size="-2">A</font>.<font size="-2">D</font>.  We will see how to express
 the general Newton's method as a Lisp procedure in
-section <a href="book-Z-H-12.html#%_sec_1.3.4">1.3.4</a>.
+section <a href="book-Z-H-12.html#__sec_1.3.4">1.3.4</a>.
 
-</p><p><a name="footnote_Temp_34" href="#call_footnote_Temp_34" id="footnote_Temp_34"><sup><small>22</small></sup></a> We will usually give
-<a name="%_idx_518" id="%_idx_518"></a><a name="%_idx_520" id="%_idx_520"></a><a name="%_idx_522" id="%_idx_522"></a><a name="%_idx_524" id="%_idx_524"></a>predicates names ending with question marks, to help us
+</p><p><a href="#call_footnote_Temp_34" id="footnote_Temp_34"><sup><small>22</small></sup></a> We will usually give
+<a id="__idx_518"></a><a id="__idx_520"></a><a id="__idx_522"></a><a id="__idx_524"></a>predicates names ending with question marks, to help us
 remember that they are predicates.  This
 is just a stylistic convention.  As far as the interpreter is
 concerned, the question mark is just an ordinary character.
 
-</p><p><a name="footnote_Temp_35" href="#call_footnote_Temp_35" id="footnote_Temp_35"><sup><small>23</small></sup></a> Observe that we express our initial guess as 1.0 rather than
+</p><p><a href="#call_footnote_Temp_35" id="footnote_Temp_35"><sup><small>23</small></sup></a> Observe that we express our initial guess as 1.0 rather than
 1.  This would not make any difference in many Lisp implementations.
-<a name="%_idx_526" id="%_idx_526"></a><a name="%_idx_528" id="%_idx_528"></a><a name="%_idx_530" id="%_idx_530"></a><a name="%_idx_532" id="%_idx_532"></a><a name="%_idx_534" id="%_idx_534"></a><a name="%_idx_536" id="%_idx_536"></a><a name="%_idx_538" id="%_idx_538"></a><a name="%_idx_540" id="%_idx_540"></a><a name="%_idx_542" id="%_idx_542"></a><a name="%_idx_544" id="%_idx_544"></a><a name="%_idx_546" id="%_idx_546"></a><a name="%_idx_548" id="%_idx_548"></a>MIT Scheme, however, distinguishes between exact integers and decimal
+<a id="__idx_526"></a><a id="__idx_528"></a><a id="__idx_530"></a><a id="__idx_532"></a><a id="__idx_534"></a><a id="__idx_536"></a><a id="__idx_538"></a><a id="__idx_540"></a><a id="__idx_542"></a><a id="__idx_544"></a><a id="__idx_546"></a><a id="__idx_548"></a>MIT Scheme, however, distinguishes between exact integers and decimal
 values, and dividing two integers produces a rational number rather
 than a decimal.  For example, dividing 10 by 6 yields 5/3, while
 dividing 10.0 by 6.0 yields 1.6666666666666667.  (We will learn how to
 implement arithmetic on rational numbers in
-section <a href="book-Z-H-14.html#%_sec_2.1.1">2.1.1</a>.)  If we start with an initial guess of 1
+section <a href="book-Z-H-14.html#__sec_2.1.1">2.1.1</a>.)  If we start with an initial guess of 1
 in our square-root program, and <em>x</em> is an exact integer, all
 subsequent values produced in the square-root computation will be
 rational numbers rather than decimals.  Mixed operations on rational
 numbers and decimals always yield decimals, so starting with an
 initial guess of 1.0 forces all subsequent values to be decimals.
 
-</p><p><a name="footnote_Temp_36" href="#call_footnote_Temp_36" id="footnote_Temp_36"><sup><small>24</small></sup></a> Readers who are worried about the efficiency
+</p><p><a href="#call_footnote_Temp_36" id="footnote_Temp_36"><sup><small>24</small></sup></a> Readers who are worried about the efficiency
 issues involved in using procedure calls to implement iteration should
 note the remarks on “tail recursion” in
-section <a href="book-Z-H-11.html#%_sec_1.2.1">1.2.1</a>.
+section <a href="book-Z-H-11.html#__sec_1.2.1">1.2.1</a>.
 
-</p><p><a name="footnote_Temp_40" href="#call_footnote_Temp_40" id="footnote_Temp_40"><sup><small>25</small></sup></a> It is not even clear which of these procedures is a
+</p><p><a href="#call_footnote_Temp_40" id="footnote_Temp_40"><sup><small>25</small></sup></a> It is not even clear which of these procedures is a
 more efficient implementation.  This depends upon the hardware
 available.  There are machines for which the “obvious”
 implementation is the less efficient one.  Consider a machine that has
 extensive tables of logarithms and antilogarithms stored in a very
 efficient manner.
 
-</p><p><a name="footnote_Temp_42" href="#call_footnote_Temp_42" id="footnote_Temp_42"><sup><small>26</small></sup></a> The
+</p><p><a href="#call_footnote_Temp_42" id="footnote_Temp_42"><sup><small>26</small></sup></a> The
 concept of consistent renaming is actually subtle and difficult to
 define formally.  Famous logicians have made embarrassing errors
 here.
 
-</p><p><a name="footnote_Temp_44" href="#call_footnote_Temp_44" id="footnote_Temp_44"><sup><small>27</small></sup></a> Lexical
+</p><p><a href="#call_footnote_Temp_44" id="footnote_Temp_44"><sup><small>27</small></sup></a> Lexical
 scoping dictates that free variables in a procedure are taken to refer to
 bindings made by enclosing procedure definitions;
 that is, they are looked up in
-<a name="%_idx_622" id="%_idx_622"></a>the environment in which the procedure was defined.  We will see how
+<a id="__idx_622"></a>the environment in which the procedure was defined.  We will see how
 this works in detail in chapter 3 when we study environments and the
 detailed behavior of the interpreter.
 
-</p><p><a name="footnote_Temp_45" href="#call_footnote_Temp_45" id="footnote_Temp_45"><sup><small>28</small></sup></a> Embedded definitions
-<a name="%_idx_626" id="%_idx_626"></a>must come first in a procedure body.  The management is not responsible
+</p><p><a href="#call_footnote_Temp_45" id="footnote_Temp_45"><sup><small>28</small></sup></a> Embedded definitions
+<a id="__idx_626"></a>must come first in a procedure body.  The management is not responsible
 for the consequences of running programs that intertwine definition
 and use.
 
diff --git a/src/OEBPS/book-Z-H-11.html b/src/OEBPS/book-Z-H-11.html
index e370191..7f48b6a 100644
--- a/src/OEBPS/book-Z-H-11.html
+++ b/src/OEBPS/book-Z-H-11.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,8 +13,8 @@
 
 
 
-<a name="%_sec_1.2" id="%_sec_1.2"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processes They Generate</a></h2><p>
+<a id="__sec_1.2"></a>
+<h2>1.2  Procedures and the Processes They Generate</h2><p>
 
 </p><p>
 
@@ -45,7 +45,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 procedures.  Only after we have developed such a skill can we learn
 to reliably construct programs that exhibit the desired behavior.</p><p>
 
-<a name="%_idx_630" id="%_idx_630"></a><a name="%_idx_632" id="%_idx_632"></a><a name="%_idx_634" id="%_idx_634"></a>A procedure is a pattern for the <em>local evolution</em> of a
+<a id="__idx_630"></a><a id="__idx_632"></a><a id="__idx_634"></a>A procedure is a pattern for the <em>local evolution</em> of a
 computational process.  It specifies how each stage of the process is
 built upon the previous stage.  We would like to be able to make
 statements about the overall, or <em>global</em>, behavior of a
@@ -61,16 +61,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 photography: as oversimplified prototypical patterns, rather than
 practical examples in their own right.</p><p>
 
-<a name="%_sec_1.2.1" id="%_sec_1.2.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.2.1">1.2.1  Linear Recursion and Iteration</a></h3><p>
+<a id="__sec_1.2.1"></a>
+</p><h3>1.2.1  Linear Recursion and Iteration</h3><p>
 
 
-<a name="%_idx_636" id="%_idx_636"></a><a name="%_idx_638" id="%_idx_638"></a>
-<a name="%_fig_1.3" id="%_fig_1.3"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch1-Z-G-7.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 1.3:</b>  A linear recursive process for computing 6!.</div></caption><tr><td>
+<a id="__idx_636"></a><a id="__idx_638"></a>
+<a id="__fig_1.3"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch1-Z-G-7.gif" alt="ch1-Z-G-7" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 1.3:</b>  A linear recursive process for computing 6!.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_idx_640" id="%_idx_640"></a>We begin by considering the factorial function, defined by</p><p>
+<a id="__idx_640"></a>We begin by considering the factorial function, defined by</p><p>
 
 </p><p><em>n</em>! = <em>n</em> · (<em>n</em> - 1) · (<em>n</em> - 2) ⋯ 3 · 2 · 1</p>
 
@@ -84,13 +84,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 result by <em>n</em>.  If we add the stipulation that 1! is equal to 1,
 this observation translates directly into a procedure:<p>
 
-</p><p></p><p><tt><a name="%_idx_642" id="%_idx_642"></a>(define (factorial n)<br />
+</p><p></p><p><tt><a id="__idx_642"></a>(define (factorial n)<br />
   (if (= n 1)<br />
       1<br />
       (* n (factorial (- n 1)))))<br /></tt></p><p></p><p>
-<a name="%_idx_644" id="%_idx_644"></a>We can use the substitution model of
-section <a href="book-Z-H-10.html#%_sec_1.1.5">1.1.5</a> to watch this procedure in action
-computing 6!, as shown in figure <a href="#%_fig_1.3">1.3</a>.</p><p>
+<a id="__idx_644"></a>We can use the substitution model of
+section <a href="book-Z-H-10.html#__sec_1.1.5">1.1.5</a> to watch this procedure in action
+computing 6!, as shown in figure <a href="#__fig_1.3">1.3</a>.</p><p>
 
 
 Now let's take a different perspective on computing factorials.  We
@@ -111,14 +111,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 and stipulating that <em>n</em>! is the value of the product when
 the counter exceeds <em>n</em>.</p><p>
 
-<a name="%_fig_1.4" id="%_fig_1.4"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch1-Z-G-10.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 1.4:</b>  A linear iterative process for computing 6!.</div></caption><tr><td>
+<a id="__fig_1.4"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch1-Z-G-10.gif" alt="ch1-Z-G-10" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 1.4:</b>  A linear iterative process for computing 6!.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
 Once again, we can recast our description as a procedure for computing
-factorials:<a name="call_footnote_Temp_46" href="#footnote_Temp_46" id="call_footnote_Temp_46"><sup><small>29</small></sup></a></p><p>
+factorials:<a href="#footnote_Temp_46" id="call_footnote_Temp_46"><sup><small>29</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_646" id="%_idx_646"></a>(define (factorial n)<br />
+</p><p></p><p><tt><a id="__idx_646"></a>(define (factorial n)<br />
   (fact-iter 1 1 n))<br /><br />
 (define (fact-iter product counter max-count)<br />
   (if (&gt; counter max-count)<br />
@@ -129,41 +129,41 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 
 
 As before, we can use the substitution model to visualize the process
-of computing 6!, as shown in figure <a href="#%_fig_1.4">1.4</a>.</p><p>
+of computing 6!, as shown in figure <a href="#__fig_1.4">1.4</a>.</p><p>
 
 Compare the two processes.  From one point of view, they seem hardly
 different at all.  Both compute the same mathematical function on the
 same domain, and each requires a number of steps proportional to <em>n</em>
 to compute <em>n</em>!.  Indeed, both processes even carry out the same
 sequence of multiplications, obtaining the same sequence of partial
-products.  On the other hand, when we consider the <a name="%_idx_648" id="%_idx_648"></a><a name="%_idx_650" id="%_idx_650"></a>“shapes” of the
+products.  On the other hand, when we consider the <a id="__idx_648"></a><a id="__idx_650"></a>“shapes” of the
 two processes, we find that they evolve quite differently.</p><p>
 
 Consider the first process.  The substitution model reveals a shape of
 expansion followed by contraction, indicated by the arrow in
-figure <a href="#%_fig_1.3">1.3</a>.  The expansion occurs as the
-process builds up a chain of <a name="%_idx_652" id="%_idx_652"></a><em>deferred operations</em> (in this case,
+figure <a href="#__fig_1.3">1.3</a>.  The expansion occurs as the
+process builds up a chain of <a id="__idx_652"></a><em>deferred operations</em> (in this case,
 a chain of multiplications).  The contraction occurs as
 the operations are
 actually performed.  This type of process, characterized by a chain of
-deferred operations, is called a <a name="%_idx_654" id="%_idx_654"></a><a name="%_idx_656" id="%_idx_656"></a><em>recursive process</em>.  Carrying
+deferred operations, is called a <a id="__idx_654"></a><a id="__idx_656"></a><em>recursive process</em>.  Carrying
 out this process requires that the interpreter keep track of the
 operations to be performed later on.  In the computation of <em>n</em>!,
 the length of the chain of deferred multiplications, and hence the amount
-of information needed to keep track of it, <a name="%_idx_658" id="%_idx_658"></a>grows linearly with <em>n</em>
+of information needed to keep track of it, <a id="__idx_658"></a>grows linearly with <em>n</em>
 (is proportional to <em>n</em>), just like the number of steps.
-<a name="%_idx_660" id="%_idx_660"></a><a name="%_idx_662" id="%_idx_662"></a><a name="%_idx_664" id="%_idx_664"></a>Such a process is called a <em>linear recursive process</em>.</p><p>
+<a id="__idx_660"></a><a id="__idx_662"></a><a id="__idx_664"></a>Such a process is called a <em>linear recursive process</em>.</p><p>
 
 By contrast, the second process does not grow and shrink.  At each
 step, all we need to keep track of, for any <em>n</em>, are the current
-values of the variables <tt>product</tt>, <tt>counter</tt>, and <tt>max-count</tt>.  We call this an <a name="%_idx_666" id="%_idx_666"></a><a name="%_idx_668" id="%_idx_668"></a><em>iterative process</em>.  In general, an
+values of the variables <tt>product</tt>, <tt>counter</tt>, and <tt>max-count</tt>.  We call this an <a id="__idx_666"></a><a id="__idx_668"></a><em>iterative process</em>.  In general, an
 iterative process is one whose state can be summarized by a fixed
-number of <a name="%_idx_670" id="%_idx_670"></a><em>state variables</em>, together with a fixed rule that
+number of <a id="__idx_670"></a><em>state variables</em>, together with a fixed rule that
 describes how the state variables should be updated as the process
 moves from state to state and an (optional) end test that specifies
 conditions under which the process should terminate.  In computing
 <em>n</em>!, the number of steps required grows linearly with <em>n</em>.  Such a process is
-called a <a name="%_idx_672" id="%_idx_672"></a><a name="%_idx_674" id="%_idx_674"></a><a name="%_idx_676" id="%_idx_676"></a><em>linear iterative process</em>.</p><p>
+called a <a id="__idx_672"></a><a id="__idx_674"></a><a id="__idx_676"></a><em>linear iterative process</em>.</p><p>
 
 The contrast between the two processes can be seen in another way.  In
 the iterative case, the program variables provide a complete
@@ -175,10 +175,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 interpreter and not contained in the program variables, which
 indicates “where the process is” in negotiating the chain of
 deferred operations.  The longer the chain, the more information must
-be maintained.<a name="call_footnote_Temp_47" href="#footnote_Temp_47" id="call_footnote_Temp_47"><sup><small>30</small></sup></a></p><p>
+be maintained.<a href="#footnote_Temp_47" id="call_footnote_Temp_47"><sup><small>30</small></sup></a></p><p>
 
 In contrasting iteration and recursion, we must be careful not to
-confuse the notion of a <a name="%_idx_680" id="%_idx_680"></a><a name="%_idx_682" id="%_idx_682"></a>recursive <em>process</em> with the notion of a
+confuse the notion of a <a id="__idx_680"></a><a id="__idx_682"></a>recursive <em>process</em> with the notion of a
 recursive <em>procedure</em>.  When we describe a procedure as recursive,
 we are referring to the syntactic fact that the procedure definition
 refers (either directly or indirectly) to the procedure itself.  But
@@ -192,22 +192,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 
 One reason that the distinction between process and procedure may be
 confusing is that most implementations of common languages (including
-<a name="%_idx_684" id="%_idx_684"></a><a name="%_idx_686" id="%_idx_686"></a><a name="%_idx_688" id="%_idx_688"></a>Ada, Pascal, and C) are designed in such a way that the
+<a id="__idx_684"></a><a id="__idx_686"></a><a id="__idx_688"></a>Ada, Pascal, and C) are designed in such a way that the
 interpretation of any recursive procedure consumes an amount of memory
 that grows with the number of procedure calls, even when the process
 described is, in principle, iterative.  As a consequence, these
 languages can describe iterative processes only by resorting to
-special-purpose <a name="%_idx_690" id="%_idx_690"></a>“looping constructs” such as <tt>do</tt>, <tt>repeat</tt>,
+special-purpose <a id="__idx_690"></a>“looping constructs” such as <tt>do</tt>, <tt>repeat</tt>,
 <tt>until</tt>, <tt>for</tt>, and <tt>while</tt>.  The implementation of Scheme
 we shall consider in chapter 5 does not share this defect.  It will
 execute an iterative process in constant space, even if the iterative
 process is described by a recursive procedure.  An implementation with
-this property is called <a name="%_idx_692" id="%_idx_692"></a><em>tail-recursive</em>.  With a tail-recursive
-implementation, <a name="%_idx_694" id="%_idx_694"></a>iteration can be expressed using the ordinary
+this property is called <a id="__idx_692"></a><em>tail-recursive</em>.  With a tail-recursive
+implementation, <a id="__idx_694"></a>iteration can be expressed using the ordinary
 procedure call mechanism, so that special iteration constructs are
-useful only as <a name="%_idx_696" id="%_idx_696"></a>syntactic sugar.<a name="call_footnote_Temp_48" href="#footnote_Temp_48" id="call_footnote_Temp_48"><sup><small>31</small></sup></a></p><p>
+useful only as <a id="__idx_696"></a>syntactic sugar.<a href="#footnote_Temp_48" id="call_footnote_Temp_48"><sup><small>31</small></sup></a></p><p>
 
-</p><p><a name="%_thm_1.9" id="%_thm_1.9"></a>
+</p><p><a id="__thm_1.9"></a>
 <b>Exercise 1.9.</b>  Each of the following two procedures defines a method for adding two
 positive integers in terms of the procedures <tt>inc</tt>,
 which increments its argument by 1, and <tt>dec</tt>, which decrements
@@ -226,8 +226,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 iterative or recursive?
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.10" id="%_thm_1.10"></a>
-<b>Exercise 1.10.</b>  <a name="%_idx_708" id="%_idx_708"></a><a name="%_idx_710" id="%_idx_710"></a>The following procedure computes a mathematical function called
+</p><p><a id="__thm_1.10"></a>
+<b>Exercise 1.10.</b>  <a id="__idx_708"></a><a id="__idx_710"></a>The following procedure computes a mathematical function called
 Ackermann's function.</p><p>
 
 </p><p></p><p><tt>(define (A x y)<br />
@@ -252,36 +252,36 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 values of <em>n</em>.  For example, <tt>(k n)</tt> computes 5<em>n</em><sup>2</sup>.
 </p><p></p><p>
 
-<a name="%_sec_1.2.2" id="%_sec_1.2.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.2.2">1.2.2  Tree Recursion</a></h3><p>
+<a id="__sec_1.2.2"></a>
+</p><h3>1.2.2  Tree Recursion</h3><p>
 
 
-<a name="%_idx_712" id="%_idx_712"></a><a name="%_idx_714" id="%_idx_714"></a><a name="%_idx_716" id="%_idx_716"></a>
+<a id="__idx_712"></a><a id="__idx_714"></a><a id="__idx_716"></a>
 Another common pattern of computation is called <em>tree recursion</em>.
-As an example, consider computing the sequence of <a name="%_idx_718" id="%_idx_718"></a>Fibonacci numbers,
+As an example, consider computing the sequence of <a id="__idx_718"></a>Fibonacci numbers,
 in which each number is the sum of the preceding two:</p><p>
 
 </p><p>0, 1, 1, 2, 3, 5, 8, 13, 21, …</p>
 
 In general, the Fibonacci numbers can be defined by the rule
-<p></p><div align="left"><img src="images/ch1-Z-G-12.gif" border="0" /></div><p>
+<p></p><div style="text-align: left;"><img src="images/ch1-Z-G-12.gif" alt="ch1-Z-G-12" style="border: none;" /></div><p>
 We can immediately translate this definition into a recursive
 procedure for computing Fibonacci numbers:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_720" id="%_idx_720"></a>(define (fib n)<br />
+</p><p></p><p><tt><a id="__idx_720"></a>(define (fib n)<br />
   (cond ((= n 0) 0)<br />
         ((= n 1) 1)<br />
         (else (+ (fib (- n 1))<br />
                  (fib (- n 2))))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_fig_1.5" id="%_fig_1.5"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch1-Z-G-13.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 1.5:</b>  The tree-recursive process generated in computing <tt>(fib 5)</tt>.</div></caption><tr><td>
+<a id="__fig_1.5"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch1-Z-G-13.gif" alt="ch1-Z-G-13" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 1.5:</b>  The tree-recursive process generated in computing <tt>(fib 5)</tt>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
 Consider the pattern of this computation.  To compute <tt>(fib 5)</tt>,
 we compute <tt>(fib 4)</tt> and <tt>(fib 3)</tt>.  To compute <tt>(fib 4)</tt>,
 we compute <tt>(fib 3)</tt> and <tt>(fib 2)</tt>.  In general, the evolved
-process looks like a tree, as shown in figure <a href="#%_fig_1.5">1.5</a>.
+process looks like a tree, as shown in figure <a href="#__fig_1.5">1.5</a>.
 Notice that the branches split into two at each level (except at the
 bottom); this reflects the fact that the <tt>fib</tt> procedure calls
 itself twice each time it is invoked.</p><p>
@@ -289,19 +289,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 
 This procedure is instructive as a prototypical tree recursion, but it
 is a terrible way to compute Fibonacci numbers because it does so much
-redundant computation.  Notice in figure <a href="#%_fig_1.5">1.5</a> that
+redundant computation.  Notice in figure <a href="#__fig_1.5">1.5</a> that
 the entire computation of <tt>(fib 3)</tt> – almost half the work – is
 duplicated.  In fact, it is not hard to show that the number of times
 the procedure will compute <tt>(fib 1)</tt> or <tt>(fib 0)</tt> (the number
 of leaves in the above tree, in general) is precisely
 <em>F</em><em>i</em><em>b</em>(<em>n</em> + 1).  To get an idea of how bad this is, one can show that the
-value of  <em>F</em><em>i</em><em>b</em>(<em>n</em>) <a name="%_idx_722" id="%_idx_722"></a>grows exponentially with <em>n</em>.  More precisely
-(see exercise <a href="#%_thm_1.13">1.13</a>),  <em>F</em><em>i</em><em>b</em>(<em>n</em>) is the closest
+value of  <em>F</em><em>i</em><em>b</em>(<em>n</em>) <a id="__idx_722"></a>grows exponentially with <em>n</em>.  More precisely
+(see exercise <a href="#__thm_1.13">1.13</a>),  <em>F</em><em>i</em><em>b</em>(<em>n</em>) is the closest
 integer to <em>φ</em><sup><em>n</em></sup> /√5, where</p>
 
 <p><em>φ</em> = (1 + √5)/2 ≈ 1.6180</p>
 
-<p>is the <a name="%_idx_724" id="%_idx_724"></a><em>golden ratio</em>, which satisfies the equation</p>
+<p>is the <a id="__idx_724"></a><em>golden ratio</em>, which satisfies the equation</p>
 
 <p><em>φ</em><sup>2</sup> = <em>φ</em> + 1</p>
 
@@ -327,7 +327,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
  <em>F</em><em>i</em><em>b</em>(<em>n</em>).  Thus, we can compute Fibonacci numbers iteratively using
 the procedure<p>
 
-</p><p></p><p><tt><a name="%_idx_726" id="%_idx_726"></a>(define (fib n)<br />
+</p><p></p><p><tt><a id="__idx_726"></a>(define (fib n)<br />
   (fib-iter 1 0 n))<br /><br />
 (define (fib-iter a b count)<br />
   (if (= count 0)<br />
@@ -341,7 +341,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 One should not conclude from this that tree-recursive processes are
 useless.  When we consider processes that operate on hierarchically
 structured data rather than numbers, we will find that tree recursion
-is a natural and powerful tool.<a name="call_footnote_Temp_51" href="#footnote_Temp_51" id="call_footnote_Temp_51"><sup><small>32</small></sup></a> But even in numerical operations,
+is a natural and powerful tool.<a href="#footnote_Temp_51" id="call_footnote_Temp_51"><sup><small>32</small></sup></a> But even in numerical operations,
 tree-recursive processes can be useful in helping us to understand and
 design programs.  For instance, although the first <tt>fib</tt> procedure
 is much less efficient than the second one, it is more
@@ -350,10 +350,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 algorithm required noticing that the computation could be recast as an
 iteration with three state variables.</p><p>
 
-<a name="%_sec_Temp_52" id="%_sec_Temp_52"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_52">Example: Counting change</a></h4><p>
+<a id="__sec_Temp_52"></a>
+</p><h4>Example: Counting change</h4><p>
 
-<a name="%_idx_728" id="%_idx_728"></a>
+<a id="__idx_728"></a>
 It takes only a bit of cleverness to come up with the iterative
 Fibonacci algorithm.  In contrast, consider the
 following problem: How many different ways can we make change of $ 1.00,
@@ -388,7 +388,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 to the problem of changing smaller amounts using fewer kinds of coins.
 Consider this reduction rule carefully, and convince yourself that we
 can use it to describe an algorithm if we specify the following
-degenerate cases:<a name="call_footnote_Temp_53" href="#footnote_Temp_53" id="call_footnote_Temp_53"><sup><small>33</small></sup></a></p><p>
+degenerate cases:<a href="#footnote_Temp_53" id="call_footnote_Temp_53"><sup><small>33</small></sup></a></p><p>
 
 </p><p></p><ul><li>If <em>a</em> is exactly 0, we should count that as 1 way to make change.<p>
 
@@ -400,7 +400,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 We can easily translate this description into a recursive
 procedure:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_730" id="%_idx_730"></a>(define (count-change amount)<br />
+</p><p></p><p><tt><a id="__idx_730"></a>(define (count-change amount)<br />
   (cc amount 5))<br />
 (define (cc amount kinds-of-coins)<br />
   (cond ((= amount 0) 1)<br />
@@ -428,21 +428,21 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 redundancies similar to those in our first implementation of <tt>fib</tt>.  (It will take quite a while for that 292 to be computed.)  On
 the other hand, it is not obvious how to design a better algorithm
 for computing the result, and we leave this problem as a challenge.
-The observation that a <a name="%_idx_732" id="%_idx_732"></a>tree-recursive process may be highly
+The observation that a <a id="__idx_732"></a>tree-recursive process may be highly
 inefficient but often easy to specify and understand has led people to
 propose that one could get the best of both worlds by designing a
 “smart compiler” that could transform tree-recursive procedures into
-more efficient procedures that compute the same result.<a name="call_footnote_Temp_54" href="#footnote_Temp_54" id="call_footnote_Temp_54"><sup><small>34</small></sup></a></p><p>
+more efficient procedures that compute the same result.<a href="#footnote_Temp_54" id="call_footnote_Temp_54"><sup><small>34</small></sup></a></p><p>
 
-</p><p><a name="%_thm_1.11" id="%_thm_1.11"></a>
+</p><p><a id="__thm_1.11"></a>
 <b>Exercise 1.11.</b>  A function <em>f</em> is defined by the rule that <em>f</em>(<em>n</em>) = <em>n</em> if <em>n</em>&lt;3 and
 <em>f</em>(<em>n</em>) = <em>f</em>(<em>n</em> - 1) + 2<em>f</em>(<em>n</em> - 2) + 3<em>f</em>(<em>n</em> - 3) if <em>n</em><u>&gt;</u> 3.  Write a procedure that
 computes <em>f</em> by means of a recursive process.  Write a procedure that
 computes <em>f</em> by means of an iterative process.
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.12" id="%_thm_1.12"></a>
-<b>Exercise 1.12.</b>  <a name="%_idx_738" id="%_idx_738"></a>The following pattern of numbers is called
+</p><p><a id="__thm_1.12"></a>
+<b>Exercise 1.12.</b>  <a id="__idx_738"></a>The following pattern of numbers is called
 <em>Pascal's triangle</em>.</p>
 
 <pre>
@@ -455,30 +455,30 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 </pre>
 
 <p>The numbers at the edge of the triangle are all 1, and
-each number inside the triangle is the sum of the two numbers above it.<a name="call_footnote_Temp_57" href="#footnote_Temp_57" id="call_footnote_Temp_57"><sup><small>35</small></sup></a>
+each number inside the triangle is the sum of the two numbers above it.<a href="#footnote_Temp_57" id="call_footnote_Temp_57"><sup><small>35</small></sup></a>
 Write a procedure that computes elements of Pascal's triangle by means
 of a recursive process.
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.13" id="%_thm_1.13"></a>
+</p><p><a id="__thm_1.13"></a>
 <b>Exercise 1.13.</b>  Prove that  <em>F</em><em>i</em><em>b</em>(<em>n</em>) is the closest integer to <em>φ</em><sup><em>n</em></sup>/√5,
 where <em>φ</em> =  (1 + √5)/2.  Hint: Let <em>ψ</em> =  (1 - √5)/2.  Use
 induction and the definition of the Fibonacci numbers (see
-section <a href="#%_sec_1.2.2">1.2.2</a>) to prove that  <em>F</em><em>i</em><em>b</em>(<em>n</em>) = (<em>φ</em><sup><em>n</em></sup>
+section <a href="#__sec_1.2.2">1.2.2</a>) to prove that  <em>F</em><em>i</em><em>b</em>(<em>n</em>) = (<em>φ</em><sup><em>n</em></sup>
  - <em>ψ</em><sup><em>n</em></sup>)/√5.
 
 </p><p></p><p>
 
-<a name="%_sec_1.2.3" id="%_sec_1.2.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.2.3">1.2.3  Orders of Growth</a></h3><p>
+<a id="__sec_1.2.3"></a>
+</p><h3>1.2.3  Orders of Growth</h3><p>
 
 
-<a name="%_idx_752" id="%_idx_752"></a>
+<a id="__idx_752"></a>
 The previous examples illustrate that processes can differ
 considerably in the rates at which they consume computational
 resources.  One convenient way to describe this difference is to use
-the notion of <a name="%_idx_754" id="%_idx_754"></a><em>order of growth</em> to obtain a gross measure of the
-<a name="%_idx_756" id="%_idx_756"></a>resources required by a process as the inputs become larger.</p><p>
+the notion of <a id="__idx_754"></a><em>order of growth</em> to obtain a gross measure of the
+<a id="__idx_756"></a>resources required by a process as the inputs become larger.</p><p>
 
 
 Let <em>n</em> be a parameter that measures the size of the problem, and let
@@ -497,7 +497,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 time required will be proportional to the number of elementary machine
 operations performed.</p><p>
 
-<a name="%_idx_758" id="%_idx_758"></a><a name="%_idx_760" id="%_idx_760"></a>We say that <em>R</em>(<em>n</em>) has order of growth θ(<em>f</em>(<em>n</em>)), written
+<a id="__idx_758"></a><a id="__idx_760"></a>We say that <em>R</em>(<em>n</em>) has order of growth θ(<em>f</em>(<em>n</em>)), written
 <em>R</em>(<em>n</em>) = θ(<em>f</em>(<em>n</em>)) (pronounced “theta of <em>f</em>(<em>n</em>)”), if there are
 positive constants <em>k</em><sub>1</sub> and <em>k</em><sub>2</sub> independent of <em>n</em> such that
 </p><p><em>k</em><sub>1</sub><em>f</em>(<em>n</em>) ≤ <em>R</em>(<em>n</em>) ≤ <em>k</em><sub>2</sub><em>f</em>(<em>n</em>)</p>
@@ -505,15 +505,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 words, for large <em>n</em>, the value <em>R</em>(<em>n</em>) is sandwiched between <em>k</em><sub>1</sub><em>f</em>(<em>n</em>)
 and <em>k</em><sub>2</sub><em>f</em>(<em>n</em>).)<p>
 
-<a name="%_idx_762" id="%_idx_762"></a><a name="%_idx_764" id="%_idx_764"></a><a name="%_idx_766" id="%_idx_766"></a>For instance, with the linear recursive process for computing
-factorial described in section <a href="#%_sec_1.2.1">1.2.1</a> the
+<a id="__idx_762"></a><a id="__idx_764"></a><a id="__idx_766"></a>For instance, with the linear recursive process for computing
+factorial described in section <a href="#__sec_1.2.1">1.2.1</a> the
 number of steps grows proportionally to the input <em>n</em>.  Thus, the
 steps required for this process grows as θ(<em>n</em>).  We also saw
-that the space required grows as θ(<em>n</em>).  For the <a name="%_idx_768" id="%_idx_768"></a><a name="%_idx_770" id="%_idx_770"></a><a name="%_idx_772" id="%_idx_772"></a>iterative
+that the space required grows as θ(<em>n</em>).  For the <a id="__idx_768"></a><a id="__idx_770"></a><a id="__idx_772"></a>iterative
 factorial, the number of steps is still θ(<em>n</em>) but the space is
-θ(1) – that is, constant.<a name="call_footnote_Temp_59" href="#footnote_Temp_59" id="call_footnote_Temp_59"><sup><small>36</small></sup></a> The <a name="%_idx_774" id="%_idx_774"></a><a name="%_idx_776" id="%_idx_776"></a><a name="%_idx_778" id="%_idx_778"></a>tree-recursive Fibonacci computation requires
+θ(1) – that is, constant.<a href="#footnote_Temp_59" id="call_footnote_Temp_59"><sup><small>36</small></sup></a> The <a id="__idx_774"></a><a id="__idx_776"></a><a id="__idx_778"></a>tree-recursive Fibonacci computation requires
 θ(<em>φ</em><sup><em>n</em></sup>) steps and space θ(<em>n</em>), where <em>φ</em> is the
-golden ratio described in section <a href="#%_sec_1.2.2">1.2.2</a>.</p><p>
+golden ratio described in section <a href="#__sec_1.2.2">1.2.2</a>.</p><p>
 
 
 Orders of growth provide only a crude description of the behavior of a
@@ -522,34 +522,34 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 all have θ(<em>n</em><sup>2</sup>) order of growth.  On the other hand, order of
 growth provides a useful indication of how we may expect the behavior
 of the process to change as we change the size of the problem.  For a
-<a name="%_idx_780" id="%_idx_780"></a>θ(<em>n</em>) (linear) process, doubling the size will roughly double the amount
-of resources used.  For an <a name="%_idx_782" id="%_idx_782"></a>exponential process, each increment in
+<a id="__idx_780"></a>θ(<em>n</em>) (linear) process, doubling the size will roughly double the amount
+of resources used.  For an <a id="__idx_782"></a>exponential process, each increment in
 problem size will multiply the resource utilization by a constant
-factor.  In the remainder of section <a href="#%_sec_1.2">1.2</a>
+factor.  In the remainder of section <a href="#__sec_1.2">1.2</a>
 we will examine two
-algorithms whose order of growth is <a name="%_idx_784" id="%_idx_784"></a>logarithmic, so that doubling the
+algorithms whose order of growth is <a id="__idx_784"></a>logarithmic, so that doubling the
 problem size increases the resource requirement by a constant amount.</p><p>
 
-</p><p><a name="%_thm_1.14" id="%_thm_1.14"></a>
-<b>Exercise 1.14.</b>  Draw the tree illustrating the process generated by the <tt>count-change</tt> procedure of section <a href="#%_sec_1.2.2">1.2.2</a> in making
+</p><p><a id="__thm_1.14"></a>
+<b>Exercise 1.14.</b>  Draw the tree illustrating the process generated by the <tt>count-change</tt> procedure of section <a href="#__sec_1.2.2">1.2.2</a> in making
 change for 11 cents.  What are the orders of growth of the space and
 number of steps used by this process as the amount to be changed
 increases?
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.15" id="%_thm_1.15"></a>
-<b>Exercise 1.15.</b>  <a name="%_idx_786" id="%_idx_786"></a>The sine of an angle (specified in
+</p><p><a id="__thm_1.15"></a>
+<b>Exercise 1.15.</b>  <a id="__idx_786"></a>The sine of an angle (specified in
 radians) can be computed by making use of the approximation
 <tt>sin</tt> <em>x</em> ≈  <em>x</em>
 if <em>x</em> is
 sufficiently small, and the trigonometric identity
-</p><p></p><div align="left"><img src="images/ch1-Z-G-19.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch1-Z-G-19.gif" alt="ch1-Z-G-19" style="border: none;" /></div><p>
 to reduce the size of the argument of <tt>sin</tt>.  (For
 purposes of this exercise an angle is considered “sufficiently
 small” if its magnitude is not greater than 0.1 radians.) These
 ideas are incorporated in the following procedures:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_788" id="%_idx_788"></a>(define (cube x) (* x x x))<br />
+</p><p></p><p><tt><a id="__idx_788"></a>(define (cube x) (* x x x))<br />
 (define (p x) (- (* 3 x) (* 4 (cube x))))<br />
 (define (sine angle)<br />
    (if (not (&gt; (abs angle) 0.1))<br />
@@ -564,11 +564,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 procedure when <tt>(sine a)</tt> is evaluated?
 </p><p></p><p>
 
-<a name="%_sec_1.2.4" id="%_sec_1.2.4"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.2.4">1.2.4  Exponentiation</a></h3><p>
+<a id="__sec_1.2.4"></a>
+</p><h3>1.2.4  Exponentiation</h3><p>
 
 
-<a name="%_idx_790" id="%_idx_790"></a>
+<a id="__idx_790"></a>
 
 Consider the problem of computing the exponential of a given number.
 We would like a procedure that takes as arguments a base <em>b</em> and a
@@ -580,7 +580,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 
 <p>which translates readily into the procedure </p><p>
 
-</p><p></p><p><tt><a name="%_idx_792" id="%_idx_792"></a>(define (expt b n)<br />
+</p><p></p><p><tt><a id="__idx_792"></a>(define (expt b n)<br />
   (if (= n 0)<br />
       1<br />
       (* b (expt b (- n 1)))))<br /></tt></p><p></p><p>
@@ -589,7 +589,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 formulate an equivalent linear iteration:</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_794" id="%_idx_794"></a>(define (expt b n)<br />
+</p><p></p><p><tt><a id="__idx_794"></a>(define (expt b n)<br />
   (expt-iter b n 1))<br /><br />
 (define (expt-iter b counter product)<br />
   (if (= counter 0)<br />
@@ -599,7 +599,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
                 (* b product)))) <br /></tt></p><p></p><p>
 This version requires θ(<em>n</em>) steps and θ(1) space.</p><p>
 
-<a name="%_idx_796" id="%_idx_796"></a>We can compute exponentials in fewer steps by using successive
+<a id="__idx_796"></a>We can compute exponentials in fewer steps by using successive
 squaring.  For instance, rather than computing <em>b</em><sup>8</sup> as
 </p><p><em>b</em> · (<em>b</em> · (<em>b</em> · (<em>b</em> · (<em>b</em> · (<em>b</em> · (<em>b</em> · <em>b</em>))))))</p>
 we can compute it using three multiplications:
@@ -618,18 +618,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 <p>We can express this method as a procedure:</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_798" id="%_idx_798"></a>(define (fast-expt b n)<br />
+</p><p></p><p><tt><a id="__idx_798"></a>(define (fast-expt b n)<br />
   (cond ((= n 0) 1)<br />
         ((even? n) (square (fast-expt b (/ n 2))))<br />
         (else (* b (fast-expt b (- n 1))))))<br /></tt></p><p></p><p>
 where the predicate to test whether an integer is even is defined in terms of
-the <a name="%_idx_800" id="%_idx_800"></a><a name="%_idx_802" id="%_idx_802"></a>primitive procedure <tt>remainder</tt> by
+the <a id="__idx_800"></a><a id="__idx_802"></a>primitive procedure <tt>remainder</tt> by
 </p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_804" id="%_idx_804"></a>(define (even? n)<br />
+</p><p></p><p><tt><a id="__idx_804"></a>(define (even? n)<br />
   (= (remainder n 2) 0))<br /></tt></p><p></p><p>
-<a name="%_idx_806" id="%_idx_806"></a><a name="%_idx_808" id="%_idx_808"></a>The process evolved by <tt>fast-expt</tt> grows logarithmically with <em>n</em>
+<a id="__idx_806"></a><a id="__idx_808"></a>The process evolved by <tt>fast-expt</tt> grows logarithmically with <em>n</em>
 in both space and number of steps.  To see this, observe that
 computing <em>b</em><sup>2<em>n</em></sup> using <tt>fast-expt</tt> requires only one more
 multiplication than computing <em>b</em><sup><em>n</em></sup>.  The size of the exponent we can
@@ -637,20 +637,20 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 multiplication we are allowed.  Thus, the number of multiplications
 required for an exponent of <em>n</em> grows about as fast as the logarithm
 of <em>n</em> to the base 2.  The process has θ(<tt>log</tt> <em>n</em>)
-growth.<a name="call_footnote_Temp_62" href="#footnote_Temp_62" id="call_footnote_Temp_62"><sup><small>37</small></sup></a></p><p>
+growth.<a href="#footnote_Temp_62" id="call_footnote_Temp_62"><sup><small>37</small></sup></a></p><p>
 
 The difference between θ(<tt>log</tt> <em>n</em>) growth and θ(<em>n</em>) growth
 becomes striking as <em>n</em> becomes large.  For example, <tt>fast-expt</tt>
-for <em>n</em> = 1000 requires only 14 multiplications.<a name="call_footnote_Temp_63" href="#footnote_Temp_63" id="call_footnote_Temp_63"><sup><small>38</small></sup></a> It is also possible to use the idea of
+for <em>n</em> = 1000 requires only 14 multiplications.<a href="#footnote_Temp_63" id="call_footnote_Temp_63"><sup><small>38</small></sup></a> It is also possible to use the idea of
 successive squaring to devise an iterative algorithm that computes
 exponentials with a logarithmic number of steps
-(see exercise <a href="#%_thm_1.16">1.16</a>), although, as is often
+(see exercise <a href="#__thm_1.16">1.16</a>), although, as is often
 the case with iterative algorithms, this is not written down so
-straightforwardly as the recursive algorithm.<a name="call_footnote_Temp_64" href="#footnote_Temp_64" id="call_footnote_Temp_64"><sup><small>39</small></sup></a>
+straightforwardly as the recursive algorithm.<a href="#footnote_Temp_64" id="call_footnote_Temp_64"><sup><small>39</small></sup></a>
 
 </p><p>
 
-</p><p><a name="%_thm_1.16" id="%_thm_1.16"></a>
+</p><p><a id="__thm_1.16"></a>
 <b>Exercise 1.16.</b>  Design a procedure that evolves an iterative exponentiation process
 that uses successive squaring and uses a logarithmic number of steps,
 as does <tt>fast-expt</tt>.  (Hint: Using the observation that
@@ -659,13 +659,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 transformation in such a way that the product <em>a</em> <em>b</em><sup><em>n</em></sup> is unchanged
 from state to state.  At the beginning of the process <em>a</em> is taken to
 be 1, and the answer is given by the value of <em>a</em> at the end of the
-process.  In general, the technique of defining an <a name="%_idx_816" id="%_idx_816"></a><em>invariant
+process.  In general, the technique of defining an <a id="__idx_816"></a><em>invariant
 quantity</em> that remains unchanged from state to state is a powerful way
-to think about the <a name="%_idx_818" id="%_idx_818"></a>design of iterative algorithms.)
+to think about the <a id="__idx_818"></a>design of iterative algorithms.)
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.17" id="%_thm_1.17"></a>
+</p><p><a id="__thm_1.17"></a>
 <b>Exercise 1.17.</b>  The exponentiation algorithms in this section are based on performing
 exponentiation by means of repeated multiplication.  In a similar way,
 one can perform integer multiplication by means of repeated addition.
@@ -684,21 +684,21 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 to <tt>fast-expt</tt> that uses a logarithmic number of steps.
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.18" id="%_thm_1.18"></a>
-<b>Exercise 1.18.</b>  Using the results of exercises <a href="#%_thm_1.16">1.16</a>
-and <a href="#%_thm_1.17">1.17</a>, devise a procedure that generates an iterative
+</p><p><a id="__thm_1.18"></a>
+<b>Exercise 1.18.</b>  Using the results of exercises <a href="#__thm_1.16">1.16</a>
+and <a href="#__thm_1.17">1.17</a>, devise a procedure that generates an iterative
 process for multiplying two integers in terms of adding, doubling, and
-halving and uses a logarithmic number of steps.<a name="call_footnote_Temp_68" href="#footnote_Temp_68" id="call_footnote_Temp_68"><sup><small>40</small></sup></a>
+halving and uses a logarithmic number of steps.<a href="#footnote_Temp_68" id="call_footnote_Temp_68"><sup><small>40</small></sup></a>
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.19" id="%_thm_1.19"></a>
+</p><p><a id="__thm_1.19"></a>
 <b>Exercise 1.19.</b>  
-<a name="%_idx_828" id="%_idx_828"></a>There is a clever algorithm for computing the Fibonacci numbers in
+<a id="__idx_828"></a>There is a clever algorithm for computing the Fibonacci numbers in
 a logarithmic number of steps.
 Recall the transformation of the state variables
 <em>a</em> and <em>b</em> in the <tt>fib-iter</tt> process of
-section <a href="#%_sec_1.2.2">1.2.2</a>: <em>a</em> ⟵  <em>a</em> + <em>b</em> and <em>b</em> ⟵
+section <a href="#__sec_1.2.2">1.2.2</a>: <em>a</em> ⟵  <em>a</em> + <em>b</em> and <em>b</em> ⟵
 <em>a</em>.  Call this transformation <em>T</em>, and observe that applying <em>T</em> over
 and over again <em>n</em> times, starting with 1 and 0, produces the pair
  <em>F</em><em>i</em><em>b</em>(<em>n</em> + 1) and  <em>F</em><em>i</em><em>b</em>(<em>n</em>).  In other words, the Fibonacci
@@ -713,7 +713,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 explicit way to square these transformations, and thus we can compute
 <em>T</em><sup><em>n</em></sup> using successive squaring, as in the <tt>fast-expt</tt>
 procedure.  Put this all together to complete the following procedure,
-which runs in a logarithmic number of steps:<a name="call_footnote_Temp_70" href="#footnote_Temp_70" id="call_footnote_Temp_70"><sup><small>41</small></sup></a></p><p>
+which runs in a logarithmic number of steps:<a href="#footnote_Temp_70" id="call_footnote_Temp_70"><sup><small>41</small></sup></a></p><p>
 
 </p><p></p><p><tt>(define (fib n)<br />
   (fib-iter 1 0 0 1 n))<br />
@@ -732,11 +732,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
                         (- count 1)))))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-<a name="%_sec_1.2.5" id="%_sec_1.2.5"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.2.5">1.2.5  Greatest Common Divisors</a></h3><p>
+<a id="__sec_1.2.5"></a>
+</p><h3>1.2.5  Greatest Common Divisors</h3><p>
 
 
-<a name="%_idx_834" id="%_idx_834"></a>
+<a id="__idx_834"></a>
 The greatest common divisor (GCD) of two integers <em>a</em> and <em>b</em> is
 defined to be the largest integer that divides both <em>a</em> and
 <em>b</em> with no remainder.  For example, the GCD of 16 and 28 is 4.  In chapter 2,
@@ -748,7 +748,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 GCD of two integers is to factor them and search for common
 factors, but there is a famous algorithm that is much more efficient.</p><p>
 
-<a name="%_idx_836" id="%_idx_836"></a>The idea of the algorithm is based on the observation that, if <em>r</em> is
+<a id="__idx_836"></a>The idea of the algorithm is based on the observation that, if <em>r</em> is
 the remainder when <em>a</em> is divided by <em>b</em>, then the common divisors of
 <em>a</em> and <em>b</em> are precisely the same as the common divisors of <em>b</em> and
 <em>r</em>.  Thus, we can use the equation
@@ -772,24 +772,24 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 performing repeated reductions will always eventually produce a pair
 where the second number is 0.  Then the GCD is the other
 number in the pair.  This method for computing the GCD is
-known as <em>Euclid's Algorithm</em>.<a name="call_footnote_Temp_71" href="#footnote_Temp_71" id="call_footnote_Temp_71"><sup><small>42</small></sup></a></p><p>
+known as <em>Euclid's Algorithm</em>.<a href="#footnote_Temp_71" id="call_footnote_Temp_71"><sup><small>42</small></sup></a></p><p>
 
 It is easy to express Euclid's Algorithm as a procedure:
-</p><p></p><p><tt><a name="%_idx_842" id="%_idx_842"></a>(define (gcd a b)<br />
+</p><p></p><p><tt><a id="__idx_842"></a>(define (gcd a b)<br />
   (if (= b 0)<br />
       a<br />
       (gcd b (remainder a b))))<br /></tt></p><p></p><p>
 This generates an iterative process, whose number of steps grows as
 the logarithm of the numbers involved.</p><p>
 
-<a name="%_idx_844" id="%_idx_844"></a>The fact that the number of steps required by Euclid's Algorithm has
+<a id="__idx_844"></a>The fact that the number of steps required by Euclid's Algorithm has
 logarithmic growth bears an interesting relation to the Fibonacci
 numbers:</p><p>
 
-</p><p></p><p><a name="%_idx_846" id="%_idx_846"></a><a name="%_idx_848" id="%_idx_848"></a><strong>Lamé's Theorem:</strong> If Euclid's Algorithm requires <em>k</em> steps to
+</p><p></p><p><a id="__idx_846"></a><a id="__idx_848"></a><strong>Lamé's Theorem:</strong> If Euclid's Algorithm requires <em>k</em> steps to
 compute the GCD of some pair, then the smaller number in the pair
 must be greater than or equal to the <em>k</em>th Fibonacci
-number.<a name="call_footnote_Temp_72" href="#footnote_Temp_72" id="call_footnote_Temp_72"><sup><small>43</small></sup></a></p><p>
+number.<a href="#footnote_Temp_72" id="call_footnote_Temp_72"><sup><small>43</small></sup></a></p><p>
 
 </p><p></p><p></p><p>
 
@@ -800,14 +800,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 the number of steps <em>k</em> grows as the logarithm (to the base
 <em>φ</em>) of <em>n</em>.  Hence, the order of growth is θ(<tt>log</tt> <em>n</em>).</p><p>
 
-</p><p><a name="%_thm_1.20" id="%_thm_1.20"></a>
-<b>Exercise 1.20.</b>  <a name="%_idx_852" id="%_idx_852"></a><a name="%_idx_854" id="%_idx_854"></a>The process that a procedure generates is of course dependent on the
+</p><p><a id="__thm_1.20"></a>
+<b>Exercise 1.20.</b>  <a id="__idx_852"></a><a id="__idx_854"></a>The process that a procedure generates is of course dependent on the
 rules used by the interpreter.  As an example, consider the iterative
 <tt>gcd</tt> procedure given above.
 Suppose we were to interpret this procedure using normal-order
-evaluation, as discussed in section <a href="book-Z-H-10.html#%_sec_1.1.5">1.1.5</a>.
+evaluation, as discussed in section <a href="book-Z-H-10.html#__sec_1.1.5">1.1.5</a>.
 (The normal-order-evaluation rule for <tt>if</tt> is described in
-exercise <a href="book-Z-H-10.html#%_thm_1.5">1.5</a>.)  Using the
+exercise <a href="book-Z-H-10.html#__thm_1.5">1.5</a>.)  Using the
 substitution method (for normal order), illustrate the process
 generated in evaluating <tt>(gcd 206 40)</tt> and indicate the
 <tt>remainder</tt> operations that are actually performed.
@@ -816,19 +816,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 In the applicative-order evaluation?
 </p><p></p><p>
 
-<a name="%_sec_1.2.6" id="%_sec_1.2.6"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.2.6">1.2.6  Example: Testing for Primality</a></h3><p>
+<a id="__sec_1.2.6"></a>
+</p><h3>1.2.6  Example: Testing for Primality</h3><p>
 
 
-<a name="%_idx_856" id="%_idx_856"></a><a name="%_idx_858" id="%_idx_858"></a>
+<a id="__idx_856"></a><a id="__idx_858"></a>
 This section describes two methods for checking the primality of an
 integer <em>n</em>, one with order of growth θ(√<em>n</em>), and a
 “probabilistic” algorithm with order of growth θ(<tt>log</tt> <em>n</em>).  The
 exercises at the end of this section suggest programming
 projects based on these algorithms.</p><p>
 
-<a name="%_sec_Temp_74" id="%_sec_Temp_74"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_74">Searching for divisors</a></h4><p>
+<a id="__sec_Temp_74"></a>
+</p><h4>Searching for divisors</h4><p>
 
 Since ancient times, mathematicians have been fascinated by problems
 concerning prime numbers, and many people have worked on the problem
@@ -838,45 +838,45 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 of a given number <em>n</em>.  It does this in a straightforward way, by
 testing <em>n</em> for divisibility by successive integers starting with 2.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_860" id="%_idx_860"></a>(define (smallest-divisor n)<br />
-  (find-divisor n 2))<br /><a name="%_idx_862" id="%_idx_862"></a>(define (find-divisor n test-divisor)<br />
+</p><p></p><p><tt><a id="__idx_860"></a>(define (smallest-divisor n)<br />
+  (find-divisor n 2))<br /><a id="__idx_862"></a>(define (find-divisor n test-divisor)<br />
   (cond ((&gt; (square test-divisor) n) n)<br />
         ((divides? test-divisor n) test-divisor)<br />
-        (else (find-divisor n (+ test-divisor 1)))))<br /><a name="%_idx_864" id="%_idx_864"></a>(define (divides? a b)<br />
+        (else (find-divisor n (+ test-divisor 1)))))<br /><a id="__idx_864"></a>(define (divides? a b)<br />
   (= (remainder b a) 0))<br /></tt></p><p></p><p></p><p>
 
 We can test whether a number is prime as follows: <em>n</em> is prime if
 and only if <em>n</em> is its own smallest divisor.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_866" id="%_idx_866"></a>(define (prime? n)<br />
+</p><p></p><p><tt><a id="__idx_866"></a>(define (prime? n)<br />
   (= n (smallest-divisor n)))<br /></tt></p><p></p><p></p><p>
 
 The end test for <tt>find-divisor</tt> is based on the fact that if <em>n</em>
 is not prime it must have a divisor less than or equal to
-√<em>n</em>.<a name="call_footnote_Temp_75" href="#footnote_Temp_75" id="call_footnote_Temp_75"><sup><small>44</small></sup></a>  This
+√<em>n</em>.<a href="#footnote_Temp_75" id="call_footnote_Temp_75"><sup><small>44</small></sup></a>  This
 means that the algorithm need only test divisors between 1 and
 √<em>n</em>.  Consequently, the number of steps required to identify
 <em>n</em> as prime will have order of growth θ(√<em>n</em>).</p><p>
 
-<a name="%_sec_Temp_76" id="%_sec_Temp_76"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_76">The Fermat test</a></h4><p>
+<a id="__sec_Temp_76"></a>
+</p><h4>The Fermat test</h4><p>
 
-<a name="%_idx_868" id="%_idx_868"></a><a name="%_idx_870" id="%_idx_870"></a>The θ(<tt>log</tt> <em>n</em>) primality test is based on a result from number
-theory known as Fermat's Little Theorem.<a name="call_footnote_Temp_77" href="#footnote_Temp_77" id="call_footnote_Temp_77"><sup><small>45</small></sup></a></p><p>
+<a id="__idx_868"></a><a id="__idx_870"></a>The θ(<tt>log</tt> <em>n</em>) primality test is based on a result from number
+theory known as Fermat's Little Theorem.<a href="#footnote_Temp_77" id="call_footnote_Temp_77"><sup><small>45</small></sup></a></p><p>
 
-</p><p></p><p><a name="%_idx_886" id="%_idx_886"></a><strong>Fermat's Little Theorem:</strong> If <em>n</em> is a prime number and
+</p><p></p><p><a id="__idx_886"></a><strong>Fermat's Little Theorem:</strong> If <em>n</em> is a prime number and
 <em>a</em> is any positive integer less than <em>n</em>, then <em>a</em> raised to the
 <em>n</em>th power is congruent to <em>a</em> modulo <em>n</em>.</p><p>
 
-</p><p></p><p><a name="%_idx_888" id="%_idx_888"></a>(Two numbers are said to be <em>congruent modulo</em> <em>n</em> if
+</p><p></p><p><a id="__idx_888"></a>(Two numbers are said to be <em>congruent modulo</em> <em>n</em> if
 they both have the same remainder when divided by <em>n</em>.  The
 remainder of a number <em>a</em> when divided by <em>n</em> is also referred to as
-the <a name="%_idx_890" id="%_idx_890"></a><a name="%_idx_892" id="%_idx_892"></a><em>remainder of</em> <em>a</em> <em>modulo</em> <em>n</em>, or simply as <em>a</em>
+the <a id="__idx_890"></a><a id="__idx_892"></a><em>remainder of</em> <em>a</em> <em>modulo</em> <em>n</em>, or simply as <em>a</em>
 <em>modulo</em> <em>n</em>.)</p><p>
 
 If <em>n</em> is not prime, then, in general, most of the numbers <em>a</em>&lt; <em>n</em> will not
 satisfy the above relation.  This leads to the following algorithm for
-testing primality: Given a number <em>n</em>, pick a <a name="%_idx_894" id="%_idx_894"></a>random number <em>a</em> &lt; <em>n</em> and
+testing primality: Given a number <em>n</em>, pick a <a id="__idx_894"></a>random number <em>a</em> &lt; <em>n</em> and
 compute the remainder of <em>a</em><sup><em>n</em></sup> modulo <em>n</em>.  If the result is not equal to
 <em>a</em>, then <em>n</em> is certainly not prime.  If it is <em>a</em>, then chances are good
 that <em>n</em> is prime.  Now pick another random number <em>a</em> and test it with the
@@ -885,10 +885,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 increase our confidence in the result.  This algorithm is known as the
 Fermat test.</p><p>
 
-<a name="%_idx_896" id="%_idx_896"></a>To implement the Fermat test, we need a procedure that computes the
+<a id="__idx_896"></a>To implement the Fermat test, we need a procedure that computes the
 exponential of a number modulo another number:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_898" id="%_idx_898"></a>(define (expmod base exp m)<br />
+</p><p></p><p><tt><a id="__idx_898"></a>(define (expmod base exp m)<br />
   (cond ((= exp 0) 1)<br />
         ((even? exp)<br />
          (remainder (square (expmod base (/ exp 2) m))<br />
@@ -897,20 +897,20 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
          (remainder (* base (expmod base (- exp 1) m))<br />
                     m))))        <br /></tt></p><p></p><p>
 This is very similar to the <tt>fast-expt</tt> procedure of
-section <a href="#%_sec_1.2.4">1.2.4</a>.  It uses successive squaring, so
+section <a href="#__sec_1.2.4">1.2.4</a>.  It uses successive squaring, so
 that the number of steps grows logarithmically with the
-exponent.<a name="call_footnote_Temp_78" href="#footnote_Temp_78" id="call_footnote_Temp_78"><sup><small>46</small></sup></a></p><p>
+exponent.<a href="#footnote_Temp_78" id="call_footnote_Temp_78"><sup><small>46</small></sup></a></p><p>
 
 The Fermat test is performed by choosing at random a number <em>a</em>
 between 1 and <em>n</em> - 1 inclusive and checking whether the remainder
 modulo <em>n</em> of the <em>n</em>th power of <em>a</em> is equal to <em>a</em>.  The random
-number <em>a</em> is chosen using the procedure <a name="%_idx_900" id="%_idx_900"></a><a name="%_idx_902" id="%_idx_902"></a><tt>random</tt>, which we assume is
+number <em>a</em> is chosen using the procedure <a id="__idx_900"></a><a id="__idx_902"></a><tt>random</tt>, which we assume is
 included as a primitive in Scheme. <tt>Random</tt> returns a
 nonnegative integer less than its integer input.  Hence, to obtain a random
 number between 1 and <em>n</em> - 1, we call <tt>random</tt> with an input of
 <em>n</em> - 1 and add 1 to the result:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_904" id="%_idx_904"></a>(define (fermat-test n)<br />
+</p><p></p><p><tt><a id="__idx_904"></a>(define (fermat-test n)<br />
   (define (try-it a)<br />
     (= (expmod a n n) a))<br />
   (try-it (+ 1 (random (- n 1)))))<br /></tt></p><p></p><p></p><p>
@@ -919,15 +919,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 specified by a parameter.  Its value is true if the test succeeds
 every time, and false otherwise.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_906" id="%_idx_906"></a>(define (fast-prime? n times)<br />
+</p><p></p><p><tt><a id="__idx_906"></a>(define (fast-prime? n times)<br />
   (cond ((= times 0) true)<br />
         ((fermat-test n) (fast-prime? n (- times 1)))<br />
         (else false)))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_79" id="%_sec_Temp_79"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_79">Probabilistic methods</a></h4><p>
+<a id="__sec_Temp_79"></a>
+</p><h4>Probabilistic methods</h4><p>
 
-<a name="%_idx_908" id="%_idx_908"></a><a name="%_idx_910" id="%_idx_910"></a>
+<a id="__idx_908"></a><a id="__idx_910"></a>
 The Fermat test differs in character from most familiar algorithms, in
 which one computes an answer that is guaranteed to be correct.  Here,
 the answer obtained is only probably correct.  More precisely, if <em>n</em>
@@ -943,12 +943,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 numbers that fool the Fermat test: numbers <em>n</em> that are not prime and
 yet have the property that <em>a</em><sup><em>n</em></sup> is congruent to <em>a</em> modulo <em>n</em> for
 all integers <em>a</em> &lt; <em>n</em>.  Such numbers are extremely rare, so the Fermat
-test is quite reliable in practice.<a name="call_footnote_Temp_80" href="#footnote_Temp_80" id="call_footnote_Temp_80"><sup><small>47</small></sup></a>
+test is quite reliable in practice.<a href="#footnote_Temp_80" id="call_footnote_Temp_80"><sup><small>47</small></sup></a>
 There are variations of the Fermat test that cannot be fooled.  In
 these tests, as with the Fermat method, one tests the primality of an
 integer <em>n</em> by choosing a random integer <em>a</em>&lt;<em>n</em> and checking some
 condition that depends upon <em>n</em> and <em>a</em>.  (See
-exercise <a href="#%_thm_1.28">1.28</a> for an example of such a test.)  On the
+exercise <a href="#__thm_1.28">1.28</a> for an example of such a test.)  On the
 other hand, in contrast to the Fermat test, one can prove that, for
 any <em>n</em>, the condition does not hold for most of the integers <em>a</em>&lt;<em>n</em>
 unless <em>n</em> is prime.  Thus, if <em>n</em> passes the test for some random
@@ -963,15 +963,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 this type, which have come to be known as <em>probabilistic
 algorithms</em>.  There is a great deal of research activity in this area,
 and probabilistic algorithms have been fruitfully applied to many
-fields.<a name="call_footnote_Temp_81" href="#footnote_Temp_81" id="call_footnote_Temp_81"><sup><small>48</small></sup></a></p><p>
+fields.<a href="#footnote_Temp_81" id="call_footnote_Temp_81"><sup><small>48</small></sup></a></p><p>
 
-</p><p><a name="%_thm_1.21" id="%_thm_1.21"></a>
+</p><p><a id="__thm_1.21"></a>
 <b>Exercise 1.21.</b>  Use the <tt>smallest-divisor</tt> procedure to find the smallest divisor
 of each of the following numbers: 199, 1999, 19999.
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.22" id="%_thm_1.22"></a>
-<b>Exercise 1.22.</b>  <a name="%_idx_932" id="%_idx_932"></a><a name="%_idx_934" id="%_idx_934"></a>Most Lisp implementations include a primitive called <tt>runtime</tt>
+</p><p><a id="__thm_1.22"></a>
+<b>Exercise 1.22.</b>  <a id="__idx_932"></a><a id="__idx_934"></a>Most Lisp implementations include a primitive called <tt>runtime</tt>
 that returns an integer that specifies the amount of time the system
 has been running (measured, for example, in microseconds).  The
 following <tt>timed-prime-test</tt> procedure, when called with an
@@ -979,7 +979,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 prime, the procedure prints three asterisks followed by the amount of time
 used in performing the test.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_936" id="%_idx_936"></a><a name="%_idx_938" id="%_idx_938"></a><a name="%_idx_940" id="%_idx_940"></a>(define (timed-prime-test n)<br />
+</p><p></p><p><tt><a id="__idx_936"></a><a id="__idx_938"></a><a id="__idx_940"></a>(define (timed-prime-test n)<br />
   (newline)<br />
   (display n)<br />
   (start-prime-test n (runtime)))<br />
@@ -1004,8 +1004,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.23" id="%_thm_1.23"></a>
-<b>Exercise 1.23.</b>  <a name="%_idx_942" id="%_idx_942"></a>The <tt>smallest-divisor</tt> procedure shown at the start of this section
+</p><p><a id="__thm_1.23"></a>
+<b>Exercise 1.23.</b>  <a id="__idx_942"></a>The <tt>smallest-divisor</tt> procedure shown at the start of this section
 does lots of needless testing: After it checks to see if the
 number is divisible by 2 there is no point in checking to see if
 it is divisible by any larger even numbers.  This suggests that the
@@ -1016,16 +1016,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 of <tt>(+ test-divisor 1)</tt>.  With <tt>timed-prime-test</tt>
 incorporating this modified version of <tt>smallest-divisor</tt>, run the
 test for each of the 12 primes found in
-exercise <a href="#%_thm_1.22">1.22</a>.  Since this modification halves the
+exercise <a href="#__thm_1.22">1.22</a>.  Since this modification halves the
 number of test steps, you should expect it to run about twice as fast.
 Is this expectation confirmed?  If not, what is the observed ratio of
 the speeds of the two algorithms, and how do you explain the fact that
 it is different from 2?
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.24" id="%_thm_1.24"></a>
+</p><p><a id="__thm_1.24"></a>
 <b>Exercise 1.24.</b>  Modify the <tt>timed-prime-test</tt> procedure of
-exercise <a href="#%_thm_1.22">1.22</a> to use <tt>fast-prime?</tt> (the
+exercise <a href="#__thm_1.22">1.22</a> to use <tt>fast-prime?</tt> (the
 Fermat method), and test each of the 12 primes you found in that
 exercise.  Since the Fermat test has θ(<tt>log</tt> <em>n</em>) growth, how
 would you expect the time to test primes near 1,000,000 to compare
@@ -1034,27 +1034,27 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.25" id="%_thm_1.25"></a>
+</p><p><a id="__thm_1.25"></a>
 <b>Exercise 1.25.</b>  Alyssa P. Hacker complains that we went to a lot of extra work in
 writing <tt>expmod</tt>.  After all, she says, since we already know how
 to compute exponentials, we could have simply written</p><p>
 
-</p><p></p><p><tt><a name="%_idx_944" id="%_idx_944"></a>(define (expmod base exp m)<br />
+</p><p></p><p><tt><a id="__idx_944"></a>(define (expmod base exp m)<br />
   (remainder (fast-expt base exp) m))<br /></tt></p><p></p><p>
 Is she correct?  Would this procedure serve as well for our fast prime
 tester?  Explain.
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.26" id="%_thm_1.26"></a>
+</p><p><a id="__thm_1.26"></a>
 <b>Exercise 1.26.</b>  Louis Reasoner is having great difficulty doing
-exercise <a href="#%_thm_1.24">1.24</a>.  His <tt>fast-prime?</tt> test
+exercise <a href="#__thm_1.24">1.24</a>.  His <tt>fast-prime?</tt> test
 seems to run more slowly than his <tt>prime?</tt> test.  Louis calls his
 friend Eva Lu Ator over to help.  When they examine Louis's code, they
 find that he has rewritten the <tt>expmod</tt> procedure to use an
 explicit multiplication, rather than calling <tt>square</tt>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_946" id="%_idx_946"></a>(define (expmod base exp m)<br />
+</p><p></p><p><tt><a id="__idx_946"></a>(define (expmod base exp m)<br />
   (cond ((= exp 0) 1)<br />
         ((even? exp)<br />
          (remainder (* (expmod base (/ exp 2) m)<br />
@@ -1069,8 +1069,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 Explain.
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.27" id="%_thm_1.27"></a>
-<b>Exercise 1.27.</b>  <a name="%_idx_948" id="%_idx_948"></a>Demonstrate that the Carmichael numbers listed in
+</p><p><a id="__thm_1.27"></a>
+<b>Exercise 1.27.</b>  <a id="__idx_948"></a>Demonstrate that the Carmichael numbers listed in
 footnote <a href="#footnote_Temp_80">47</a> really do fool
 the Fermat test.  That is, write a procedure that takes an integer <em>n</em>
 and tests whether <em>a</em><sup><em>n</em></sup> is congruent to <em>a</em> modulo <em>n</em> for every
@@ -1078,10 +1078,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 </p><p></p><p>
 
 
-</p><p><a name="%_thm_1.28" id="%_thm_1.28"></a>
-<b>Exercise 1.28.</b>  <a name="%_idx_950" id="%_idx_950"></a><a name="%_idx_952" id="%_idx_952"></a><a name="%_idx_954" id="%_idx_954"></a><a name="%_idx_956" id="%_idx_956"></a><a name="%_idx_958" id="%_idx_958"></a>One variant of the Fermat test that cannot be fooled is called the
+</p><p><a id="__thm_1.28"></a>
+<b>Exercise 1.28.</b>  <a id="__idx_950"></a><a id="__idx_952"></a><a id="__idx_954"></a><a id="__idx_956"></a><a id="__idx_958"></a>One variant of the Fermat test that cannot be fooled is called the
 <em>Miller-Rabin test</em> (Miller 1976; Rabin 1980).  This starts from
-<a name="%_idx_960" id="%_idx_960"></a>an alternate form of Fermat's Little Theorem, which states that if <em>n</em>
+<a id="__idx_960"></a>an alternate form of Fermat's Little Theorem, which states that if <em>n</em>
 is a prime number and <em>a</em> is any positive integer less than <em>n</em>, then
 <em>a</em> raised to the (<em>n</em> - 1)st power is congruent to 1 modulo <em>n</em>.  To test
 the primality of a number <em>n</em> by the Miller-Rabin test, we pick a
@@ -1105,7 +1105,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 </p><p></p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_46" href="#call_footnote_Temp_46" id="footnote_Temp_46"><sup><small>29</small></sup></a> In a real program we would probably use the
+</p><div class="footnote"><p><a href="#call_footnote_Temp_46" id="footnote_Temp_46"><sup><small>29</small></sup></a> In a real program we would probably use the
 block structure introduced in the last section to hide the definition
 of <tt>fact-iter</tt>:
 </p><p></p><p><tt>(define (factorial n)<br />
@@ -1118,59 +1118,59 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 We avoided doing this here so as to minimize the number of things to
 think about at once.
 
-</p><p><a name="footnote_Temp_47" href="#call_footnote_Temp_47" id="footnote_Temp_47"><sup><small>30</small></sup></a> When we discuss the implementation of
+</p><p><a href="#call_footnote_Temp_47" id="footnote_Temp_47"><sup><small>30</small></sup></a> When we discuss the implementation of
 procedures on register machines in chapter 5, we will see that any
 iterative process can be realized “in hardware” as a machine that
 has a fixed set of registers and no auxiliary memory.  In contrast,
 realizing a recursive process requires a machine that uses an
-<a name="%_idx_678" id="%_idx_678"></a>auxiliary data structure known as a <em>stack</em>.
+<a id="__idx_678"></a>auxiliary data structure known as a <em>stack</em>.
 
-</p><p><a name="footnote_Temp_48" href="#call_footnote_Temp_48" id="footnote_Temp_48"><sup><small>31</small></sup></a> Tail recursion has long been
-<a name="%_idx_698" id="%_idx_698"></a><a name="%_idx_700" id="%_idx_700"></a><a name="%_idx_702" id="%_idx_702"></a>known as a compiler optimization trick.  A coherent semantic basis for
+</p><p><a href="#call_footnote_Temp_48" id="footnote_Temp_48"><sup><small>31</small></sup></a> Tail recursion has long been
+<a id="__idx_698"></a><a id="__idx_700"></a><a id="__idx_702"></a>known as a compiler optimization trick.  A coherent semantic basis for
 tail recursion was provided by Carl Hewitt (1977), who explained it in
-<a name="%_idx_704" id="%_idx_704"></a>terms of the “message-passing” model of computation that we shall
+<a id="__idx_704"></a>terms of the “message-passing” model of computation that we shall
 discuss in chapter 3. Inspired by this, Gerald Jay Sussman and Guy
 Lewis Steele Jr. (see Steele 1975) constructed a tail-recursive
 interpreter for Scheme.  Steele later showed how tail recursion is a
 consequence of the natural way to compile procedure calls (Steele
 1977).  The IEEE standard for Scheme requires that Scheme implementations
-<a name="%_idx_706" id="%_idx_706"></a>be tail-recursive.
+<a id="__idx_706"></a>be tail-recursive.
 
-</p><p><a name="footnote_Temp_51" href="#call_footnote_Temp_51" id="footnote_Temp_51"><sup><small>32</small></sup></a> An example of this was hinted
-at in section <a href="book-Z-H-10.html#%_sec_1.1.3">1.1.3</a>:
+</p><p><a href="#call_footnote_Temp_51" id="footnote_Temp_51"><sup><small>32</small></sup></a> An example of this was hinted
+at in section <a href="book-Z-H-10.html#__sec_1.1.3">1.1.3</a>:
 The interpreter itself evaluates expressions
 using a tree-recursive process.
 
-</p><p><a name="footnote_Temp_53" href="#call_footnote_Temp_53" id="footnote_Temp_53"><sup><small>33</small></sup></a> For example, work through in detail how the
+</p><p><a href="#call_footnote_Temp_53" id="footnote_Temp_53"><sup><small>33</small></sup></a> For example, work through in detail how the
 reduction rule applies to the problem of making change for 10 cents
 using pennies and nickels.
 
-</p><p><a name="footnote_Temp_54" href="#call_footnote_Temp_54" id="footnote_Temp_54"><sup><small>34</small></sup></a> One
+</p><p><a href="#call_footnote_Temp_54" id="footnote_Temp_54"><sup><small>34</small></sup></a> One
 approach to coping with redundant computations is to arrange matters
 so that we automatically construct a table of values as they
 are computed.  Each time we are asked to apply the procedure to some
 argument, we first look to see if the value is already stored in the
 table, in which case we avoid performing the redundant computation.
-This strategy, known as <a name="%_idx_734" id="%_idx_734"></a><a name="%_idx_736" id="%_idx_736"></a><em>tabulation</em> or <em>memoization</em>, can be
+This strategy, known as <a id="__idx_734"></a><a id="__idx_736"></a><em>tabulation</em> or <em>memoization</em>, can be
 implemented in a straightforward way.  Tabulation can sometimes be
 used to transform processes that require an exponential number of
 steps (such as <tt>count-change</tt>) into processes whose space and time
 requirements grow linearly with the input.  See
-exercise <a href="book-Z-H-22.html#%_thm_3.27">3.27</a>.
+exercise <a href="book-Z-H-22.html#__thm_3.27">3.27</a>.
 
-</p><p><a name="footnote_Temp_57" href="#call_footnote_Temp_57" id="footnote_Temp_57"><sup><small>35</small></sup></a> The elements of Pascal's triangle are called the <em>binomial
+</p><p><a href="#call_footnote_Temp_57" id="footnote_Temp_57"><sup><small>35</small></sup></a> The elements of Pascal's triangle are called the <em>binomial
 coefficients</em>, because the <em>n</em>th row consists of
-<a name="%_idx_740" id="%_idx_740"></a>the coefficients of the terms in the
+<a id="__idx_740"></a>the coefficients of the terms in the
 expansion of (<em>x</em> + <em>y</em>)<sup><em>n</em></sup>.  This pattern for computing the coefficients
-<a name="%_idx_742" id="%_idx_742"></a>appeared in Blaise Pascal's 1653 seminal work on probability theory, <em>Traité du triangle arithmétique</em>.  According to
-<a name="%_idx_744" id="%_idx_744"></a>Knuth (1973), the same pattern appears in the <em>Szu-yuen
+<a id="__idx_742"></a>appeared in Blaise Pascal's 1653 seminal work on probability theory, <em>Traité du triangle arithmétique</em>.  According to
+<a id="__idx_744"></a>Knuth (1973), the same pattern appears in the <em>Szu-yuen
 Yü-chien</em> (“The Precious Mirror of the Four Elements”), published
-<a name="%_idx_746" id="%_idx_746"></a><a name="%_idx_748" id="%_idx_748"></a><a name="%_idx_750" id="%_idx_750"></a>by the Chinese mathematician Chu Shih-chieh in 1303, in the
+<a id="__idx_746"></a><a id="__idx_748"></a><a id="__idx_750"></a>by the Chinese mathematician Chu Shih-chieh in 1303, in the
 works of the twelfth-century Persian poet and mathematician Omar
 Khayyam, and in the works of the twelfth-century Hindu mathematician
 Bháscara Áchárya.
 
-</p><p><a name="footnote_Temp_59" href="#call_footnote_Temp_59" id="footnote_Temp_59"><sup><small>36</small></sup></a> These statements mask a
+</p><p><a href="#call_footnote_Temp_59" id="footnote_Temp_59"><sup><small>36</small></sup></a> These statements mask a
 great deal of oversimplification.  For instance, if we count process
 steps as “machine operations” we are making the assumption that the
 number of machine operations needed to perform, say, a multiplication
@@ -1180,7 +1180,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 the analysis of a process can be carried out at various levels of
 abstraction.
 
-</p><p><a name="footnote_Temp_62" href="#call_footnote_Temp_62" id="footnote_Temp_62"><sup><small>37</small></sup></a> More precisely, the number of multiplications
+</p><p><a href="#call_footnote_Temp_62" id="footnote_Temp_62"><sup><small>37</small></sup></a> More precisely, the number of multiplications
 required is equal to 1 less than the log base 2 of <em>n</em> plus the number
 of ones in the binary representation of <em>n</em>.  This total is always
 less than twice the log base 2 of <em>n</em>.  The arbitrary constants
@@ -1189,37 +1189,37 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 process, the base to which logarithms are taken does not matter, so
 all such processes are described as θ(<tt>log</tt> <em>n</em>).
 
-</p><p><a name="footnote_Temp_63" href="#call_footnote_Temp_63" id="footnote_Temp_63"><sup><small>38</small></sup></a> You may wonder
+</p><p><a href="#call_footnote_Temp_63" id="footnote_Temp_63"><sup><small>38</small></sup></a> You may wonder
 why anyone would care about raising numbers to the 1000th power.  See
-section <a href="#%_sec_1.2.6">1.2.6</a>.
+section <a href="#__sec_1.2.6">1.2.6</a>.
 
-</p><p><a name="footnote_Temp_64" href="#call_footnote_Temp_64" id="footnote_Temp_64"><sup><small>39</small></sup></a> This iterative
+</p><p><a href="#call_footnote_Temp_64" id="footnote_Temp_64"><sup><small>39</small></sup></a> This iterative
 algorithm is ancient.  It appears in the <em>Chandah-sutra</em> by
-<a name="%_idx_810" id="%_idx_810"></a><a name="%_idx_812" id="%_idx_812"></a><a name="%_idx_814" id="%_idx_814"></a>Áchárya Pingala, written before 200 <font size="-2">B</font>.<font size="-2">C</font>. See Knuth 1981, section
+<a id="__idx_810"></a><a id="__idx_812"></a><a id="__idx_814"></a>Áchárya Pingala, written before 200 <font size="-2">B</font>.<font size="-2">C</font>. See Knuth 1981, section
 4.6.3, for a full discussion and analysis of this and other methods of
 exponentiation.
 
-</p><p><a name="footnote_Temp_68" href="#call_footnote_Temp_68" id="footnote_Temp_68"><sup><small>40</small></sup></a> This
-<a name="%_idx_820" id="%_idx_820"></a><a name="%_idx_822" id="%_idx_822"></a>algorithm, which is sometimes known as the “Russian peasant method”
+</p><p><a href="#call_footnote_Temp_68" id="footnote_Temp_68"><sup><small>40</small></sup></a> This
+<a id="__idx_820"></a><a id="__idx_822"></a>algorithm, which is sometimes known as the “Russian peasant method”
 of multiplication, is ancient.  Examples of its use are found in the
-<a name="%_idx_824" id="%_idx_824"></a>Rhind Papyrus, one of the two oldest mathematical documents in
+<a id="__idx_824"></a>Rhind Papyrus, one of the two oldest mathematical documents in
 existence, written about 1700 <font size="-2">B</font>.<font size="-2">C</font>. (and copied from an even
-<a name="%_idx_826" id="%_idx_826"></a>older document) by an Egyptian scribe named A'h-mose.
+<a id="__idx_826"></a>older document) by an Egyptian scribe named A'h-mose.
 
-</p><p><a name="footnote_Temp_70" href="#call_footnote_Temp_70" id="footnote_Temp_70"><sup><small>41</small></sup></a> This exercise was
-<a name="%_idx_830" id="%_idx_830"></a><a name="%_idx_832" id="%_idx_832"></a>suggested to us by Joe Stoy, based on an example in Kaldewaij 1990.
+</p><p><a href="#call_footnote_Temp_70" id="footnote_Temp_70"><sup><small>41</small></sup></a> This exercise was
+<a id="__idx_830"></a><a id="__idx_832"></a>suggested to us by Joe Stoy, based on an example in Kaldewaij 1990.
 
-</p><p><a name="footnote_Temp_71" href="#call_footnote_Temp_71" id="footnote_Temp_71"><sup><small>42</small></sup></a> Euclid's Algorithm is so
-<a name="%_idx_838" id="%_idx_838"></a>called because it appears in Euclid's <em>Elements</em> (Book 7, ca. 300
+</p><p><a href="#call_footnote_Temp_71" id="footnote_Temp_71"><sup><small>42</small></sup></a> Euclid's Algorithm is so
+<a id="__idx_838"></a>called because it appears in Euclid's <em>Elements</em> (Book 7, ca. 300
 <font size="-2">B</font>.<font size="-2">C</font>.).  According to Knuth (1973), it can be considered the
-<a name="%_idx_840" id="%_idx_840"></a>oldest known nontrivial algorithm.  The ancient Egyptian method of
-multiplication (exercise <a href="#%_thm_1.18">1.18</a>) is surely older,
+<a id="__idx_840"></a>oldest known nontrivial algorithm.  The ancient Egyptian method of
+multiplication (exercise <a href="#__thm_1.18">1.18</a>) is surely older,
 but, as Knuth explains, Euclid's algorithm is the oldest known to have
 been presented as a general algorithm, rather than as a set of
 illustrative examples.
 
-</p><p><a name="footnote_Temp_72" href="#call_footnote_Temp_72" id="footnote_Temp_72"><sup><small>43</small></sup></a> This theorem was proved in 1845 by Gabriel Lamé, a
-<a name="%_idx_850" id="%_idx_850"></a>French mathematician and engineer known chiefly for his contributions
+</p><p><a href="#call_footnote_Temp_72" id="footnote_Temp_72"><sup><small>43</small></sup></a> This theorem was proved in 1845 by Gabriel Lamé, a
+<a id="__idx_850"></a>French mathematician and engineer known chiefly for his contributions
 to mathematical physics.  To prove the theorem, we consider pairs
 (<em>a</em><sub><em>k</em></sub> ,<em>b</em><sub><em>k</em></sub>), where <em>a</em><sub><em>k</em></sub><u>&gt;</u> <em>b</em><sub><em>k</em></sub>, for which Euclid's Algorithm
 terminates in <em>k</em> steps.  The proof is based on the claim that, if
@@ -1247,23 +1247,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 <em>b</em><sub><em>k</em>+1</sub><u>&gt;</u> <em>b</em><sub><em>k</em></sub>  +  <em>b</em><sub><em>k</em>-1</sub><u>&gt;</u>  <em>F</em><em>i</em><em>b</em>(<em>k</em>)  +   <em>F</em><em>i</em><em>b</em>(<em>k</em> - 1)  =  <em>F</em><em>i</em><em>b</em>(<em>k</em> + 1), which
 completes the proof of Lamé's Theorem.
 
-</p><p><a name="footnote_Temp_75" href="#call_footnote_Temp_75" id="footnote_Temp_75"><sup><small>44</small></sup></a> If <em>d</em> is a divisor of <em>n</em>, then so is <em>n</em>/<em>d</em>.
+</p><p><a href="#call_footnote_Temp_75" id="footnote_Temp_75"><sup><small>44</small></sup></a> If <em>d</em> is a divisor of <em>n</em>, then so is <em>n</em>/<em>d</em>.
 But <em>d</em> and <em>n</em>/<em>d</em> cannot both be greater than √<em>n</em>.
 
-</p><p><a name="footnote_Temp_77" href="#call_footnote_Temp_77" id="footnote_Temp_77"><sup><small>45</small></sup></a> Pierre de Fermat (1601-1665) is considered to be the founder of
-<a name="%_idx_872" id="%_idx_872"></a><a name="%_idx_874" id="%_idx_874"></a>modern number theory.  He obtained many important number-theoretic
+</p><p><a href="#call_footnote_Temp_77" id="footnote_Temp_77"><sup><small>45</small></sup></a> Pierre de Fermat (1601-1665) is considered to be the founder of
+<a id="__idx_872"></a><a id="__idx_874"></a>modern number theory.  He obtained many important number-theoretic
 results, but he usually announced just the results, without providing
-his proofs.  <a name="%_idx_876" id="%_idx_876"></a>Fermat's Little Theorem was stated in a letter he wrote in
-1640.  The first published proof was given by <a name="%_idx_878" id="%_idx_878"></a>Euler in 1736 (and an
-<a name="%_idx_880" id="%_idx_880"></a>earlier, identical proof was discovered in the unpublished manuscripts
+his proofs.  <a id="__idx_876"></a>Fermat's Little Theorem was stated in a letter he wrote in
+1640.  The first published proof was given by <a id="__idx_878"></a>Euler in 1736 (and an
+<a id="__idx_880"></a>earlier, identical proof was discovered in the unpublished manuscripts
 of Leibniz).  The most famous of Fermat's results – known as Fermat's
-Last Theorem – was jotted down in 1637 in his copy of the book <em>Arithmetic</em> (by the third-century Greek mathematician <a name="%_idx_882" id="%_idx_882"></a>Diophantus) with the
+Last Theorem – was jotted down in 1637 in his copy of the book <em>Arithmetic</em> (by the third-century Greek mathematician <a id="__idx_882"></a>Diophantus) with the
 remark “I have discovered a truly remarkable proof, but this margin is
 too small to contain it.”  Finding a proof of Fermat's Last Theorem
 became one of the most famous challenges in number theory.  A complete
-<a name="%_idx_884" id="%_idx_884"></a>solution was finally given in 1995 by Andrew Wiles of Princeton University.
+<a id="__idx_884"></a>solution was finally given in 1995 by Andrew Wiles of Princeton University.
 
-</p><p><a name="footnote_Temp_78" href="#call_footnote_Temp_78" id="footnote_Temp_78"><sup><small>46</small></sup></a> The reduction steps in the cases where the exponent
+</p><p><a href="#call_footnote_Temp_78" id="footnote_Temp_78"><sup><small>46</small></sup></a> The reduction steps in the cases where the exponent
 <em>e</em> is greater than 1 are based on the fact that, for any integers
 <em>x</em>, <em>y</em>, and <em>m</em>, we can find the remainder of <em>x</em> times <em>y</em> modulo
 <em>m</em> by computing separately the remainders of <em>x</em> modulo <em>m</em> and <em>y</em>
@@ -1273,30 +1273,30 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.2">1.2  Procedures and the Processe
 the remainder modulo <em>m</em>.  This technique is useful because it means
 we can perform our computation without ever having to deal with
 numbers much larger than <em>m</em>.  (Compare
-exercise <a href="#%_thm_1.25">1.25</a>.)
+exercise <a href="#__thm_1.25">1.25</a>.)
 
-</p><p><a name="footnote_Temp_80" href="#call_footnote_Temp_80" id="footnote_Temp_80"><sup><small>47</small></sup></a> Numbers that fool the
-<a name="%_idx_912" id="%_idx_912"></a>Fermat test are called <em>Carmichael numbers</em>, and little is known
+</p><p><a href="#call_footnote_Temp_80" id="footnote_Temp_80"><sup><small>47</small></sup></a> Numbers that fool the
+<a id="__idx_912"></a>Fermat test are called <em>Carmichael numbers</em>, and little is known
 about them other than that they are extremely rare.  There are 255
 Carmichael numbers below 100,000,000.  The smallest few are 561, 1105,
 1729, 2465, 2821, and 6601.  In testing primality of very large
 numbers chosen at random, the chance of stumbling upon a value that
-fools the Fermat test is less than the chance that <a name="%_idx_914" id="%_idx_914"></a>cosmic radiation
+fools the Fermat test is less than the chance that <a id="__idx_914"></a>cosmic radiation
 will cause the computer to make an error in carrying out a “correct”
 algorithm.  Considering an algorithm to be inadequate for the first
 reason but not for the second illustrates the difference between
-<a name="%_idx_916" id="%_idx_916"></a><a name="%_idx_918" id="%_idx_918"></a>mathematics and engineering.
+<a id="__idx_916"></a><a id="__idx_918"></a>mathematics and engineering.
 
-</p><p><a name="footnote_Temp_81" href="#call_footnote_Temp_81" id="footnote_Temp_81"><sup><small>48</small></sup></a> One of the most striking applications of
-<a name="%_idx_920" id="%_idx_920"></a>probabilistic prime testing has been to the field of cryptography.
+</p><p><a href="#call_footnote_Temp_81" id="footnote_Temp_81"><sup><small>48</small></sup></a> One of the most striking applications of
+<a id="__idx_920"></a>probabilistic prime testing has been to the field of cryptography.
 Although it is now computationally infeasible to factor an arbitrary
 200-digit number, the primality of such a number can be checked in a
 few seconds with the Fermat test.  This fact forms the basis of a
-technique for constructing “unbreakable codes” suggested by <a name="%_idx_922" id="%_idx_922"></a>Rivest,
-<a name="%_idx_924" id="%_idx_924"></a>Shamir, and <a name="%_idx_926" id="%_idx_926"></a>Adleman (1977).  The resulting <a name="%_idx_928" id="%_idx_928"></a><em>RSA algorithm</em> has
+technique for constructing “unbreakable codes” suggested by <a id="__idx_922"></a>Rivest,
+<a id="__idx_924"></a>Shamir, and <a id="__idx_926"></a>Adleman (1977).  The resulting <a id="__idx_928"></a><em>RSA algorithm</em> has
 become a widely used technique for enhancing the security of
 electronic communications.  Because of this and related developments,
-the study of <a name="%_idx_930" id="%_idx_930"></a>prime numbers, once considered the epitome of a topic in
+the study of <a id="__idx_930"></a>prime numbers, once considered the epitome of a topic in
 “pure” mathematics to be studied only for its own sake, now turns
 out to have important practical applications to cryptography,
 electronic funds transfer, and information retrieval.
diff --git a/src/OEBPS/book-Z-H-12.html b/src/OEBPS/book-Z-H-12.html
index 0d3c22e..ecc339d 100644
--- a/src/OEBPS/book-Z-H-12.html
+++ b/src/OEBPS/book-Z-H-12.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,8 +13,8 @@
 
 
 
-<a name="%_sec_1.3" id="%_sec_1.3"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions with Higher-Order Procedures</a></h2><p>
+<a id="__sec_1.3"></a>
+<h2>1.3  Formulating Abstractions with Higher-Order Procedures</h2><p>
 
 </p><p>
 
@@ -24,7 +24,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 For example, when we</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_962" id="%_idx_962"></a>(define (cube x) (* x x x))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_962"></a>(define (cube x) (* x x x))<br /></tt></p><p></p><p>
 we are not talking about the cube of a particular number, but rather
 about a method for obtaining the cube of any number.  Of course we
 could get along without ever defining this procedure, by
@@ -52,36 +52,36 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 will be used with a number of different procedures.  To express such
 patterns as concepts, we will need to construct procedures that can
 accept procedures as arguments or return procedures as values.
-Procedures that manipulate procedures are called <a name="%_idx_964" id="%_idx_964"></a><em>higher-order
+Procedures that manipulate procedures are called <a id="__idx_964"></a><em>higher-order
 procedures</em>.  This section shows how higher-order procedures can serve
 as powerful abstraction mechanisms, vastly increasing the expressive
 power of our language.</p><p>
 
-<a name="%_sec_1.3.1" id="%_sec_1.3.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.3.1">1.3.1  Procedures as Arguments</a></h3><p>
+<a id="__sec_1.3.1"></a>
+</p><h3>1.3.1  Procedures as Arguments</h3><p>
 
 
-<a name="%_idx_966" id="%_idx_966"></a><a name="%_idx_968" id="%_idx_968"></a>
+<a id="__idx_966"></a><a id="__idx_968"></a>
 
 Consider the following three procedures.  The first computes the sum
 of the integers from <tt>a</tt> through <tt>b</tt>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_970" id="%_idx_970"></a>(define (sum-integers a b)<br />
+</p><p></p><p><tt><a id="__idx_970"></a>(define (sum-integers a b)<br />
   (if (&gt; a b)<br />
       0<br />
       (+ a (sum-integers (+ a 1) b))))<br /></tt></p><p></p><p>
 The second computes the sum of the cubes of the integers in the given range:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_972" id="%_idx_972"></a>(define (sum-cubes a b)<br />
+</p><p></p><p><tt><a id="__idx_972"></a>(define (sum-cubes a b)<br />
   (if (&gt; a b)<br />
       0<br />
       (+ (cube a) (sum-cubes (+ a 1) b))))<br /></tt></p><p></p><p>
 The third computes the sum of a sequence of terms in the
 series
-</p><p></p><div align="left"><img src="images/ch1-Z-G-26.gif" border="0" /></div><p>
-which converges to π/8 (very slowly):<a name="call_footnote_Temp_90" href="#footnote_Temp_90" id="call_footnote_Temp_90"><sup><small>49</small></sup></a></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch1-Z-G-26.gif" alt="ch1-Z-G-26" style="border: none;" /></div><p>
+which converges to π/8 (very slowly):<a href="#footnote_Temp_90" id="call_footnote_Temp_90"><sup><small>49</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_978" id="%_idx_978"></a>(define (pi-sum a b)<br />
+</p><p></p><p><tt><a id="__idx_978"></a>(define (pi-sum a b)<br />
   (if (&gt; a b)<br />
       0<br />
       (+ (/ 1.0 (* a (+ a 2))) (pi-sum (+ a 4) b))))<br /></tt></p><p></p><p></p><p>
@@ -98,13 +98,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
       (+ (&lt;<em>term</em>&gt; a)<br />
          (&lt;<em>name</em>&gt; (&lt;<em>next</em>&gt; a) b))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_980" id="%_idx_980"></a>The presence of such a common pattern is strong evidence that there is
+<a id="__idx_980"></a>The presence of such a common pattern is strong evidence that there is
 a useful abstraction waiting to be brought to the surface.  Indeed,
 mathematicians long ago identified the abstraction of
-<a name="%_idx_982" id="%_idx_982"></a><a name="%_idx_984" id="%_idx_984"></a><em>summation of a series</em> and invented “sigma
-<a name="%_idx_986" id="%_idx_986"></a><a name="%_idx_988" id="%_idx_988"></a>notation,” for example</p><p>
+<a id="__idx_982"></a><a id="__idx_984"></a><em>summation of a series</em> and invented “sigma
+<a id="__idx_986"></a><a id="__idx_988"></a>notation,” for example</p><p>
 
-</p><p></p><div align="left"><img src="images/ch1-Z-G-27.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch1-Z-G-27.gif" alt="ch1-Z-G-27" style="border: none;" /></div><p></p><p>
 
 to express this concept.  The power of sigma notation is that it
 allows mathematicians to deal with the concept of summation
@@ -119,7 +119,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 procedural language by taking the common template shown above and
 transforming the “slots” into formal parameters:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_990" id="%_idx_990"></a>(define (sum term a next b)<br />
+</p><p></p><p><tt><a id="__idx_990"></a>(define (sum term a next b)<br />
   (if (&gt; a b)<br />
       0<br />
       (+ (term a)<br />
@@ -130,7 +130,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 use it (along with a procedure <tt>inc</tt> that increments its argument by 1)
 to define <tt>sum-cubes</tt>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_992" id="%_idx_992"></a>(define (inc n) (+ n 1))<br /><a name="%_idx_994" id="%_idx_994"></a>(define (sum-cubes a b)<br />
+</p><p></p><p><tt><a id="__idx_992"></a>(define (inc n) (+ n 1))<br /><a id="__idx_994"></a>(define (sum-cubes a b)<br />
   (sum cube a inc b))<br /></tt></p><p></p><p>
 Using this, we can compute the sum of the cubes of the integers from 1
 to 10:</p><p>
@@ -141,16 +141,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 <tt>sum-integers</tt> in terms of <tt>sum</tt>:</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_996" id="%_idx_996"></a>(define (identity x) x)<br /><br /><a name="%_idx_998" id="%_idx_998"></a>(define (sum-integers a b)<br />
+</p><p></p><p><tt><a id="__idx_996"></a>(define (identity x) x)<br /><br /><a id="__idx_998"></a>(define (sum-integers a b)<br />
   (sum identity a inc b))<br /></tt></p><p></p><p>
 Then we can add up the integers from 1 to 10:</p><p>
 
 
 </p><p></p><p><tt>(sum-integers 1 10)<br /><i>55</i><br /></tt></p><p></p><p>
-We can also define <tt>pi-sum</tt> in the same way:<a name="call_footnote_Temp_91" href="#footnote_Temp_91" id="call_footnote_Temp_91"><sup><small>50</small></sup></a></p><p>
+We can also define <tt>pi-sum</tt> in the same way:<a href="#footnote_Temp_91" id="call_footnote_Temp_91"><sup><small>50</small></sup></a></p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_1000" id="%_idx_1000"></a>(define (pi-sum a b)<br />
+</p><p></p><p><tt><a id="__idx_1000"></a>(define (pi-sum a b)<br />
   (define (pi-term x)<br />
     (/ 1.0 (* x (+ x 2))))<br />
   (define (pi-next x)<br />
@@ -164,14 +164,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 
 
 Once we have <tt>sum</tt>, we can use it as a building block in
-formulating further concepts.  For instance, the <a name="%_idx_1002" id="%_idx_1002"></a>definite integral of a
+formulating further concepts.  For instance, the <a id="__idx_1002"></a>definite integral of a
 function <em>f</em> between the limits <em>a</em> and <em>b</em> can be approximated
 numerically using the formula
-</p><p></p><p></p><div align="left"><img src="images/ch1-Z-G-28.gif" border="0" /></div><p>
+</p><p></p><p></p><div style="text-align: left;"><img src="images/ch1-Z-G-28.gif" alt="ch1-Z-G-28" style="border: none;" /></div><p>
 for small values of <em>d</em><em>x</em>.  We can express this directly as a
 procedure:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1004" id="%_idx_1004"></a>(define (integral f a b dx)<br />
+</p><p></p><p><tt><a id="__idx_1004"></a>(define (integral f a b dx)<br />
   (define (add-dx x) (+ x dx))<br />
   (* (sum f (+ a (/ dx 2.0)) add-dx b)<br />
      dx))<br />
@@ -179,11 +179,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 (integral cube 0 1 0.001)<br /><i>.249999875000001</i><br /></tt></p><p></p><p>
 (The exact value of the integral of <tt>cube</tt> between 0 and 1 is 1/4.)</p><p>
 
-</p><p><a name="%_thm_1.29" id="%_thm_1.29"></a>
-<b>Exercise 1.29.</b>  <a name="%_idx_1006" id="%_idx_1006"></a>Simpson's Rule is a more accurate method of numerical integration than
+</p><p><a id="__thm_1.29"></a>
+<b>Exercise 1.29.</b>  <a id="__idx_1006"></a>Simpson's Rule is a more accurate method of numerical integration than
 the method illustrated above.  Using Simpson's Rule, the integral of a
 function <em>f</em> between <em>a</em> and <em>b</em> is approximated as
-</p><p></p><div align="left"><img src="images/ch1-Z-G-29.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch1-Z-G-29.gif" alt="ch1-Z-G-29" style="border: none;" /></div><p></p><p>
 
 where <em>h</em> = (<em>b</em> - <em>a</em>)/<em>n</em>, for some even integer <em>n</em>, and <em>y</em><sub><em>k</em></sub>  = <em>f</em>(<em>a</em> + <em>k</em><em>h</em>).
 (Increasing <em>n</em> increases the accuracy of the approximation.)  Define
@@ -194,8 +194,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 <tt>integral</tt> procedure shown above.
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.30" id="%_thm_1.30"></a>
-<b>Exercise 1.30.</b>  <a name="%_idx_1008" id="%_idx_1008"></a>The <tt>sum</tt> procedure above generates a linear recursion.  The
+</p><p><a id="__thm_1.30"></a>
+<b>Exercise 1.30.</b>  <a id="__idx_1008"></a>The <tt>sum</tt> procedure above generates a linear recursion.  The
 procedure can be rewritten so that the sum is performed iteratively.
 Show how to do this by filling in the missing expressions in the
 following definition:</p><p>
@@ -208,16 +208,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
   (iter &lt;<em>??</em>&gt; &lt;<em>??</em>&gt;))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.31" id="%_thm_1.31"></a>
+</p><p><a id="__thm_1.31"></a>
 <b>Exercise 1.31.</b>  
-<a name="%_idx_1010" id="%_idx_1010"></a><br />a.  The <tt>sum</tt> procedure is only the simplest of a vast number of
-similar abstractions that can be captured as higher-order procedures.<a name="call_footnote_Temp_95" href="#footnote_Temp_95" id="call_footnote_Temp_95"><sup><small>51</small></sup></a>  Write an analogous procedure
+<a id="__idx_1010"></a><br />a.  The <tt>sum</tt> procedure is only the simplest of a vast number of
+similar abstractions that can be captured as higher-order procedures.<a href="#footnote_Temp_95" id="call_footnote_Temp_95"><sup><small>51</small></sup></a>  Write an analogous procedure
 called <tt>product</tt> that returns the product of the values of a
 function at points over a given range.
-Show how to define <a name="%_idx_1012" id="%_idx_1012"></a><tt>factorial</tt> in terms of
+Show how to define <a id="__idx_1012"></a><tt>factorial</tt> in terms of
 <tt>product</tt>.  Also use <tt>product</tt> to compute approximations to
-<a name="%_idx_1014" id="%_idx_1014"></a>π using the formula<a name="call_footnote_Temp_96" href="#footnote_Temp_96" id="call_footnote_Temp_96"><sup><small>52</small></sup></a>
-</p><p></p><div align="left"><img src="images/ch1-Z-G-30.gif" border="0" /></div><p></p><p>
+<a id="__idx_1014"></a>π using the formula<a href="#footnote_Temp_96" id="call_footnote_Temp_96"><sup><small>52</small></sup></a>
+</p><p></p><div style="text-align: left;"><img src="images/ch1-Z-G-30.gif" alt="ch1-Z-G-30" style="border: none;" /></div><p></p><p>
 
 b.  If your <tt>product</tt>
 procedure generates a recursive process, write one that generates
@@ -227,9 +227,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.32" id="%_thm_1.32"></a>
-<b>Exercise 1.32.</b>  <a name="%_idx_1018" id="%_idx_1018"></a><a name="%_idx_1020" id="%_idx_1020"></a><a name="%_idx_1022" id="%_idx_1022"></a>a. Show that <tt>sum</tt> and <tt>product</tt>
-(exercise <a href="#%_thm_1.31">1.31</a>) are both special cases of a still more
+</p><p><a id="__thm_1.32"></a>
+<b>Exercise 1.32.</b>  <a id="__idx_1018"></a><a id="__idx_1020"></a><a id="__idx_1022"></a>a. Show that <tt>sum</tt> and <tt>product</tt>
+(exercise <a href="#__thm_1.31">1.31</a>) are both special cases of a still more
 general notion called <tt>accumulate</tt> that combines a collection of
 terms, using some general accumulation function:</p><p>
 
@@ -251,9 +251,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.33" id="%_thm_1.33"></a>
-<b>Exercise 1.33.</b>  <a name="%_idx_1024" id="%_idx_1024"></a>You can obtain an even more general version of <tt>accumulate</tt>
-(exercise <a href="#%_thm_1.32">1.32</a>) by introducing the notion of a <a name="%_idx_1026" id="%_idx_1026"></a><em>filter</em> on the terms to be combined.  That is, combine only those
+</p><p><a id="__thm_1.33"></a>
+<b>Exercise 1.33.</b>  <a id="__idx_1024"></a>You can obtain an even more general version of <tt>accumulate</tt>
+(exercise <a href="#__thm_1.32">1.32</a>) by introducing the notion of a <a id="__idx_1026"></a><em>filter</em> on the terms to be combined.  That is, combine only those
 terms derived from values in the range that satisfy a specified
 condition.  The resulting <tt>filtered-accumulate</tt> abstraction takes
 the same arguments as accumulate, together with an additional
@@ -264,18 +264,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 <em>b</em> (assuming that you have a <tt>prime?</tt> predicate already written)</p><p>
 
 </p><p></p><p>b. the product of all the positive integers less than <em>n</em>
-<a name="%_idx_1028" id="%_idx_1028"></a>that are relatively prime to <em>n</em> (i.e., all positive integers
+<a id="__idx_1028"></a>that are relatively prime to <em>n</em> (i.e., all positive integers
 <em>i</em> &lt; <em>n</em> such that  <em>G</em><em>C</em><em>D</em>(<em>i</em>,<em>n</em>) = 1).
 
 </p><p></p><p>
 
-<a name="%_sec_1.3.2" id="%_sec_1.3.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.3.2">1.3.2  Constructing Procedures Using <tt>Lambda</tt></a></h3><p>
+<a id="__sec_1.3.2"></a>
+</p><h3>1.3.2  Constructing Procedures Using <tt>Lambda</tt></h3><p>
 
 
 </p><p>
 
-In using <tt>sum</tt> as in section <a href="#%_sec_1.3.1">1.3.1</a>,
+In using <tt>sum</tt> as in section <a href="#__sec_1.3.1">1.3.1</a>,
 it seems terribly awkward to have to define trivial procedures such as
 <tt>pi-term</tt> and <tt>pi-next</tt> just so we can use them as arguments to
 our higher-order procedure.  Rather than define <tt>pi-next</tt> and <tt>pi-term</tt>, it would be more convenient
@@ -292,7 +292,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 Then our <tt>pi-sum</tt> procedure can be expressed without defining any
 auxiliary procedures as</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1030" id="%_idx_1030"></a>(define (pi-sum a b)<br />
+</p><p></p><p><tt><a id="__idx_1030"></a>(define (pi-sum a b)<br />
   (sum (lambda (x) (/ 1.0 (* x (+ x 2))))<br />
        a<br />
        (lambda (x) (+ x 4))<br />
@@ -301,22 +301,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 Again using <tt>lambda</tt>, we can write the <tt>integral</tt> procedure
 without having to define the auxiliary procedure <tt>add-dx</tt>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1032" id="%_idx_1032"></a>(define (integral f a b dx)<br />
+</p><p></p><p><tt><a id="__idx_1032"></a>(define (integral f a b dx)<br />
   (* (sum f<br />
           (+ a (/ dx 2.0))<br />
           (lambda (x) (+ x dx))<br />
           b)<br />
      dx))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_1034" id="%_idx_1034"></a><a name="%_idx_1036" id="%_idx_1036"></a><a name="%_idx_1038" id="%_idx_1038"></a><a name="%_idx_1040" id="%_idx_1040"></a><a name="%_idx_1042" id="%_idx_1042"></a>In general, <tt>lambda</tt> is used to create procedures in the same way as
-<tt>define</tt>, except that <a name="%_idx_1044" id="%_idx_1044"></a>no name is specified for the procedure:</p><p>
+<a id="__idx_1034"></a><a id="__idx_1036"></a><a id="__idx_1038"></a><a id="__idx_1040"></a><a id="__idx_1042"></a>In general, <tt>lambda</tt> is used to create procedures in the same way as
+<tt>define</tt>, except that <a id="__idx_1044"></a>no name is specified for the procedure:</p><p>
 
 </p><p></p><p><tt>(lambda (&lt;<em>formal-parameters</em>&gt;) &lt;<em>body</em>&gt;)<br /></tt></p><p></p><p>
 The resulting procedure is just as much a procedure as one that is
 created using <tt>define</tt>.  The only difference is that it has not
 been associated with any name in the environment.  In fact,</p><p>
 
-<a name="%_idx_1046" id="%_idx_1046"></a></p><p></p><p><tt>(define (plus4 x) (+ x 4))<br /></tt></p><p></p><p>
+<a id="__idx_1046"></a></p><p></p><p><tt>(define (plus4 x) (+ x 4))<br /></tt></p><p></p><p>
 is equivalent to</p><p>
 
 </p><p></p><p><tt>(define plus4 (lambda (x) (+ x 4)))<br /></tt></p><p></p><p>
@@ -325,17 +325,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
         ↑                 ↑               ↑    ↑    ↑<br />
  the procedure   of an argument <tt>x</tt>  that adds  <tt>x</tt> and 4<br /></tt></p><p></p><p>
 
-<a name="%_idx_1048" id="%_idx_1048"></a><a name="%_idx_1050" id="%_idx_1050"></a><a name="%_idx_1052" id="%_idx_1052"></a>Like any expression that has a procedure as its value, a
+<a id="__idx_1048"></a><a id="__idx_1050"></a><a id="__idx_1052"></a>Like any expression that has a procedure as its value, a
 <tt>lambda</tt> expression can be used as the operator in a combination such as</p><p>
 
 </p><p></p><p><tt>((lambda (x y z) (+ x y (square z))) 1 2 3)<br /><i>12</i><br /></tt></p><p></p><p>
 or, more generally, in any context where we would normally use a
-procedure name.<a name="call_footnote_Temp_99" href="#footnote_Temp_99" id="call_footnote_Temp_99"><sup><small>53</small></sup></a></p><p>
+procedure name.<a href="#footnote_Temp_99" id="call_footnote_Temp_99"><sup><small>53</small></sup></a></p><p>
 
-<a name="%_sec_Temp_100" id="%_sec_Temp_100"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_100">Using <tt>let</tt> to create local variables</a></h4><p>
+<a id="__sec_Temp_100"></a>
+</p><h4>Using <tt>let</tt> to create local variables</h4><p>
 
-<a name="%_idx_1058" id="%_idx_1058"></a><a name="%_idx_1060" id="%_idx_1060"></a>
+<a id="__idx_1058"></a><a id="__idx_1060"></a>
 
 Another use of <tt>lambda</tt> is in creating local variables.
 We often need local variables in our procedures other than those that have
@@ -390,7 +390,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
     (+ (* x (square a))<br />
        (* y b)<br />
        (* a b))))<br /></tt></p><p></p><p>
-<a name="%_idx_1062" id="%_idx_1062"></a><a name="%_idx_1064" id="%_idx_1064"></a>The general form of a <tt>let</tt> expression is</p><p>
+<a id="__idx_1062"></a><a id="__idx_1064"></a>The general form of a <tt>let</tt> expression is</p><p>
 
 
 </p><p></p><p><tt>(let ((&lt;<em>var<sub>1</sub></em>&gt; &lt;<em>exp<sub>1</sub></em>&gt;)<br />
@@ -400,7 +400,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
    &lt;<em>body</em>&gt;)<br /></tt></p><p></p><p>
 which can be thought of as saying</p><p>
 
-</p><table border="0"><tr><td valign="top">let </td><td valign="top">&lt;<em>var<sub>1</sub></em>&gt; have the value &lt;<em>exp<sub>1</sub></em>&gt; and</td></tr><tr><td valign="top"></td><td valign="top">&lt;<em>var<sub>2</sub></em>&gt; have the value &lt;<em>exp<sub>2</sub></em>&gt; and</td></tr><tr><td valign="top"></td><td valign="top">⋮</td></tr><tr><td valign="top"></td><td valign="top">&lt;<em>var<sub><em>n</em></sub></em>&gt; have the value &lt;<em>exp<sub><em>n</em></sub></em>&gt;</td></tr><tr><td valign="top">in  </td><td valign="top">&lt;<em>body</em>&gt;
+</p><table style="border: none;"><tr><td style="text-align: top;">let </td><td style="text-align: top;">&lt;<em>var<sub>1</sub></em>&gt; have the value &lt;<em>exp<sub>1</sub></em>&gt; and</td></tr><tr><td style="text-align: top;"></td><td style="text-align: top;">&lt;<em>var<sub>2</sub></em>&gt; have the value &lt;<em>exp<sub>2</sub></em>&gt; and</td></tr><tr><td style="text-align: top;"></td><td style="text-align: top;">⋮</td></tr><tr><td style="text-align: top;"></td><td style="text-align: top;">&lt;<em>var<sub><em>n</em></sub></em>&gt; have the value &lt;<em>exp<sub><em>n</em></sub></em>&gt;</td></tr><tr><td style="text-align: top;">in  </td><td style="text-align: top;">&lt;<em>body</em>&gt;
 </td></tr></table><p>
 
 The first part of the <tt>let</tt> expression is a list of
@@ -415,10 +415,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
  ⋮<br />
  &lt;<em>exp<sub><em>n</em></sub></em>&gt;)<br /></tt></p><p></p><p>
 No new mechanism is required in the interpreter in order to
-provide local variables.  A <a name="%_idx_1066" id="%_idx_1066"></a><a name="%_idx_1068" id="%_idx_1068"></a><tt>let</tt> expression is simply syntactic sugar for
+provide local variables.  A <a id="__idx_1066"></a><a id="__idx_1068"></a><tt>let</tt> expression is simply syntactic sugar for
 the underlying <tt>lambda</tt> application.</p><p>
 
-<a name="%_idx_1070" id="%_idx_1070"></a><a name="%_idx_1072" id="%_idx_1072"></a>We can see from this equivalence that
+<a id="__idx_1070"></a><a id="__idx_1072"></a>We can see from this equivalence that
 the scope of a variable specified by a <tt>let</tt> expression is the body of
 the <tt>let</tt>.
 This implies that:</p><p>
@@ -451,7 +451,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 </p></li></ul><p></p><p>
 
 
-<a name="%_idx_1074" id="%_idx_1074"></a><a name="%_idx_1076" id="%_idx_1076"></a>Sometimes we can use internal definitions to get the same effect as
+<a id="__idx_1074"></a><a id="__idx_1076"></a>Sometimes we can use internal definitions to get the same effect as
 with <tt>let</tt>.  For example, we could have defined the procedure <tt>f</tt> above as
 </p><p></p><p><tt>(define (f x y)<br />
   (define a (+ 1 (* x y)))<br />
@@ -460,9 +460,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
      (* y b)<br />
      (* a b)))<br /></tt></p><p></p><p>
 We prefer, however, to use <tt>let</tt> in situations like this
-and to use internal <tt>define</tt> only for internal procedures.<a name="call_footnote_Temp_101" href="#footnote_Temp_101" id="call_footnote_Temp_101"><sup><small>54</small></sup></a></p><p>
+and to use internal <tt>define</tt> only for internal procedures.<a href="#footnote_Temp_101" id="call_footnote_Temp_101"><sup><small>54</small></sup></a></p><p>
 
-</p><p><a name="%_thm_1.34" id="%_thm_1.34"></a>
+</p><p><a id="__thm_1.34"></a>
 <b>Exercise 1.34.</b>  Suppose we define the procedure</p><p>
 
 </p><p></p><p><tt>(define (f g)<br />
@@ -475,17 +475,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 combination <tt>(f f)</tt>?  Explain.
 </p><p></p><p>
 
-<a name="%_sec_1.3.3" id="%_sec_1.3.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.3.3">1.3.3  Procedures as General Methods</a></h3><p>
+<a id="__sec_1.3.3"></a>
+</p><h3>1.3.3  Procedures as General Methods</h3><p>
 
 
-<a name="%_idx_1078" id="%_idx_1078"></a><a name="%_idx_1080" id="%_idx_1080"></a>
+<a id="__idx_1078"></a><a id="__idx_1080"></a>
 We introduced compound procedures in
-section <a href="book-Z-H-10.html#%_sec_1.1.4">1.1.4</a> as a mechanism for abstracting
+section <a href="book-Z-H-10.html#__sec_1.1.4">1.1.4</a> as a mechanism for abstracting
 patterns of numerical operations so as to make them independent of the
 particular numbers involved.  With higher-order procedures, such as
 the <tt>integral</tt> procedure of
-section <a href="#%_sec_1.3.1">1.3.1</a>, we began to see a more
+section <a href="#__sec_1.3.1">1.3.1</a>, we began to see a more
 powerful kind of abstraction: procedures used to express general
 methods of computation, independent of the particular functions
 involved.  In this section we discuss two more elaborate
@@ -493,10 +493,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 functions – and show how these methods can be expressed directly as
 procedures.</p><p>
 
-<a name="%_sec_Temp_103" id="%_sec_Temp_103"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_103">Finding roots of equations by the half-interval method</a></h4><p>
+<a id="__sec_Temp_103"></a>
+</p><h4>Finding roots of equations by the half-interval method</h4><p>
 
-<a name="%_idx_1082" id="%_idx_1082"></a>
+<a id="__idx_1082"></a>
 The <em>half-interval method</em> is a simple but powerful technique for
 finding roots of an equation <em>f</em>(<em>x</em>) = 0, where <em>f</em> is a continuous
 function.  The idea is that, if we are given points <em>a</em> and <em>b</em> such
@@ -514,7 +514,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 Here is a procedure that implements this strategy:</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_1084" id="%_idx_1084"></a>(define (search f neg-point pos-point)<br />
+</p><p></p><p><tt><a id="__idx_1084"></a>(define (search f neg-point pos-point)<br />
   (let ((midpoint (average neg-point pos-point)))<br />
     (if (close-enough? neg-point pos-point)<br />
         midpoint<br />
@@ -539,8 +539,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 
 
 To test whether the endpoints are “close enough” we can use a
-procedure similar to the one used in section <a href="book-Z-H-10.html#%_sec_1.1.7">1.1.7</a> for
-computing square roots:<a name="call_footnote_Temp_104" href="#footnote_Temp_104" id="call_footnote_Temp_104"><sup><small>55</small></sup></a></p><p>
+procedure similar to the one used in section <a href="book-Z-H-10.html#__sec_1.1.7">1.1.7</a> for
+computing square roots:<a href="#footnote_Temp_104" id="call_footnote_Temp_104"><sup><small>55</small></sup></a></p><p>
 
 </p><p></p><p><tt>(define (close-enough? x y)<br />
   (&lt; (abs (- x y)) 0.001))<br /></tt></p><p></p><p></p><p>
@@ -553,9 +553,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 which has a positive value, and calls the <tt>search</tt> procedure
 accordingly.  If the function has the same sign on the two given
 points, the half-interval method cannot be used, in which case the
-procedure signals an error.<a name="call_footnote_Temp_105" href="#footnote_Temp_105" id="call_footnote_Temp_105"><sup><small>56</small></sup></a></p><p>
+procedure signals an error.<a href="#footnote_Temp_105" id="call_footnote_Temp_105"><sup><small>56</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_1092" id="%_idx_1092"></a>(define (half-interval-method f a b)<br />
+</p><p></p><p><tt><a id="__idx_1092"></a>(define (half-interval-method f a b)<br />
   (let ((a-value (f a))<br />
         (b-value (f b)))<br />
     (cond ((and (negative? a-value) (positive? b-value))<br />
@@ -565,7 +565,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
           (else<br />
            (error "Values are not of opposite sign" a b)))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_1094" id="%_idx_1094"></a>The following example uses the half-interval method to approximate π
+<a id="__idx_1094"></a>The following example uses the half-interval method to approximate π
 as the root between 2 and 4 of <tt>sin</tt>  <em>x</em>  =  0:</p><p>
 
 </p><p></p><p><tt>(half-interval-method sin 2.0 4.0)<br /><i>3.14111328125</i><br /></tt></p><p></p><p></p><p>
@@ -578,10 +578,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
                       1.0<br />
                       2.0)<br /><i>1.89306640625</i><br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_106" id="%_sec_Temp_106"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_106">Finding fixed points of functions</a></h4><p>
+<a id="__sec_Temp_106"></a>
+</p><h4>Finding fixed points of functions</h4><p>
 
-<a name="%_idx_1096" id="%_idx_1096"></a><a name="%_idx_1098" id="%_idx_1098"></a>
+<a id="__idx_1096"></a><a id="__idx_1098"></a>
 A number <em>x</em> is called a <em>fixed point</em> of a function <em>f</em> if <em>x</em>
 satisfies the equation <em>f</em>(<em>x</em>) = <em>x</em>.  For some functions <em>f</em> we can locate
 a fixed point by beginning with an initial guess and applying <em>f</em>
@@ -597,7 +597,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 tolerance:</p><p>
 
 
-</p><p></p><p><tt>(define tolerance 0.00001)<br /><a name="%_idx_1100" id="%_idx_1100"></a>(define (fixed-point f first-guess)<br />
+</p><p></p><p><tt>(define tolerance 0.00001)<br /><a id="__idx_1100"></a>(define (fixed-point f first-guess)<br />
   (define (close-enough? v1 v2)<br />
     (&lt; (abs (- v1 v2)) tolerance))<br />
   (define (try guess)<br />
@@ -606,27 +606,27 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
           next<br />
           (try next))))<br />
   (try first-guess))<br /></tt></p><p></p><p>
-<a name="%_idx_1102" id="%_idx_1102"></a><a name="%_idx_1104" id="%_idx_1104"></a>For example, we can use this method to approximate the fixed point of
-the cosine function, starting with 1 as an initial approximation:<a name="call_footnote_Temp_107" href="#footnote_Temp_107" id="call_footnote_Temp_107"><sup><small>57</small></sup></a></p><p>
+<a id="__idx_1102"></a><a id="__idx_1104"></a>For example, we can use this method to approximate the fixed point of
+the cosine function, starting with 1 as an initial approximation:<a href="#footnote_Temp_107" id="call_footnote_Temp_107"><sup><small>57</small></sup></a></p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_1112" id="%_idx_1112"></a><a name="%_idx_1114" id="%_idx_1114"></a>(fixed-point cos 1.0)<br /><i>.7390822985224023</i><br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_1112"></a><a id="__idx_1114"></a>(fixed-point cos 1.0)<br /><i>.7390822985224023</i><br /></tt></p><p></p><p>
 Similarly, we can find a solution to the equation
 <em>y</em> = <tt>sin</tt> <em>y</em>  +  <tt>cos</tt> <em>y</em>:</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_1116" id="%_idx_1116"></a><a name="%_idx_1118" id="%_idx_1118"></a>(fixed-point (lambda (y) (+ (sin y) (cos y)))<br />
+</p><p></p><p><tt><a id="__idx_1116"></a><a id="__idx_1118"></a>(fixed-point (lambda (y) (+ (sin y) (cos y)))<br />
              1.0)<br /><i>1.2587315962971173</i><br /></tt></p><p></p><p></p><p>
 
 
 The fixed-point process is reminiscent of the process we used for
-finding square roots in section <a href="book-Z-H-10.html#%_sec_1.1.7">1.1.7</a>.  Both are based on the
+finding square roots in section <a href="book-Z-H-10.html#__sec_1.1.7">1.1.7</a>.  Both are based on the
 idea of repeatedly improving a guess until the result satisfies some
-criterion.  In fact, we can readily formulate the <a name="%_idx_1120" id="%_idx_1120"></a>square-root
+criterion.  In fact, we can readily formulate the <a id="__idx_1120"></a>square-root
 computation as a fixed-point search.  Computing the square root of
 some number <em>x</em> requires finding a <em>y</em> such that <em>y</em><sup>2</sup>  =  <em>x</em>.  Putting
 this equation into the equivalent form <em>y</em>  =  <em>x</em>/<em>y</em>, we recognize that we
-are looking for a fixed point of the function<a name="call_footnote_Temp_108" href="#footnote_Temp_108" id="call_footnote_Temp_108"><sup><small>58</small></sup></a> <em>y</em>  ⟼  <em>x</em>/<em>y</em>, and we
+are looking for a fixed point of the function<a href="#footnote_Temp_108" id="call_footnote_Temp_108"><sup><small>58</small></sup></a> <em>y</em>  ⟼  <em>x</em>/<em>y</em>, and we
 can therefore try to compute square roots as</p><p>
 
 
@@ -649,7 +649,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 The process of making such a sequence of guesses is simply the process
 of looking for a fixed point of <em>y</em>  ⟼  (1/2)(<em>y</em> + <em>x</em>/<em>y</em>):</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1126" id="%_idx_1126"></a>(define (sqrt x)<br />
+</p><p></p><p><tt><a id="__idx_1126"></a>(define (sqrt x)<br />
   (fixed-point (lambda (y) (average y (/ x y)))<br />
                1.0))<br /></tt></p><p></p><p>
 (Note that <em>y</em> = (1/2)(<em>y</em> + <em>x</em>/<em>y</em>) is a simple transformation of the
@@ -660,43 +660,43 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 we unravel the definitions, we can see that the sequence of
 approximations to the square root generated here is precisely the
 same as the one generated by our original square-root procedure of
-section <a href="book-Z-H-10.html#%_sec_1.1.7">1.1.7</a>.  This approach of averaging
+section <a href="book-Z-H-10.html#__sec_1.1.7">1.1.7</a>.  This approach of averaging
 successive approximations to a solution, a technique we that we call
-<a name="%_idx_1128" id="%_idx_1128"></a><em>average damping</em>, often aids the convergence of fixed-point
+<a id="__idx_1128"></a><em>average damping</em>, often aids the convergence of fixed-point
 searches.</p><p>
 
-</p><p><a name="%_thm_1.35" id="%_thm_1.35"></a>
-<b>Exercise 1.35.</b>  <a name="%_idx_1130" id="%_idx_1130"></a><a name="%_idx_1132" id="%_idx_1132"></a>Show that the golden ratio <em>φ</em> (section <a href="book-Z-H-11.html#%_sec_1.2.2">1.2.2</a>)
+</p><p><a id="__thm_1.35"></a>
+<b>Exercise 1.35.</b>  <a id="__idx_1130"></a><a id="__idx_1132"></a>Show that the golden ratio <em>φ</em> (section <a href="book-Z-H-11.html#__sec_1.2.2">1.2.2</a>)
 is a fixed point of the transformation <em>x</em>  ⟼  1  +  1/<em>x</em>, and use
 this fact to compute <em>φ</em> by means of the <tt>fixed-point</tt>
 procedure.
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.36" id="%_thm_1.36"></a>
+</p><p><a id="__thm_1.36"></a>
 <b>Exercise 1.36.</b>  Modify <tt>fixed-point</tt> so that it prints the sequence of
 approximations it generates, using
 the <tt>newline</tt> and <tt>display</tt> primitives shown in
-exercise <a href="book-Z-H-11.html#%_thm_1.22">1.22</a>.  Then find a solution to <em>x</em><sup><em>x</em></sup>  =
+exercise <a href="book-Z-H-11.html#__thm_1.22">1.22</a>.  Then find a solution to <em>x</em><sup><em>x</em></sup>  =
 1000 by finding a fixed point of <em>x</em>  ⟼  <tt>log</tt>(1000)/<tt>log</tt>(<em>x</em>).  (Use
-Scheme's <a name="%_idx_1134" id="%_idx_1134"></a><a name="%_idx_1136" id="%_idx_1136"></a>primitive <tt>log</tt> procedure, which computes natural
+Scheme's <a id="__idx_1134"></a><a id="__idx_1136"></a>primitive <tt>log</tt> procedure, which computes natural
 logarithms.)  Compare the number of steps this takes with and without
 average damping.  (Note that you cannot start <tt>fixed-point</tt> with a
 guess of 1, as this would cause division by <tt>log</tt>(1) = 0.)
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.37" id="%_thm_1.37"></a>
-<b>Exercise 1.37.</b>  <a name="%_idx_1138" id="%_idx_1138"></a>a. An infinite <em>continued fraction</em> is an expression of the form
-</p><p></p><div align="left"><img src="images/ch1-Z-G-34.svg" border="0" /></div><p>
-<a name="%_idx_1140" id="%_idx_1140"></a><a name="%_idx_1142" id="%_idx_1142"></a>As an example, one can show that the infinite continued fraction
+</p><p><a id="__thm_1.37"></a>
+<b>Exercise 1.37.</b>  <a id="__idx_1138"></a>a. An infinite <em>continued fraction</em> is an expression of the form
+</p><p></p><div style="text-align: left;"><img src="images/ch1-Z-G-34.gif" alt="ch1-Z-G-34" style="border: none;" /></div><p>
+<a id="__idx_1140"></a><a id="__idx_1142"></a>As an example, one can show that the infinite continued fraction
 expansion with the <em>N</em><sub><em>i</em></sub> and the <em>D</em><sub><em>i</em></sub> all equal to 1 produces
 1/<em>φ</em>, where <em>φ</em> is the golden ratio (described in
-section <a href="book-Z-H-11.html#%_sec_1.2.2">1.2.2</a>).
+section <a href="book-Z-H-11.html#__sec_1.2.2">1.2.2</a>).
 One way to approximate an
 infinite continued fraction is to truncate the expansion after a given
 number of terms.  Such a truncation – a so-called <em><em>k</em>-term finite
 continued fraction</em> – has the form
-</p><p></p><div align="left"><img src="images/ch1-Z-G-35.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch1-Z-G-35.gif" alt="ch1-Z-G-35" style="border: none;" /></div><p>
 Suppose that <tt>n</tt> and <tt>d</tt> are procedures of one argument (the
 term index <em>i</em>) that return the <em>N</em><sub><em>i</em></sub> and <em>D</em><sub><em>i</em></sub> of the terms of the
 continued fraction.  Define a procedure <tt>cont-frac</tt>
@@ -717,33 +717,33 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.38" id="%_thm_1.38"></a>
-<b>Exercise 1.38.</b>  <a name="%_idx_1144" id="%_idx_1144"></a>In 1737, the Swiss mathematician Leonhard Euler published a memoir
-<em>De Fractionibus Continuis</em>, which included a <a name="%_idx_1146" id="%_idx_1146"></a><a name="%_idx_1148" id="%_idx_1148"></a>continued fraction
+</p><p><a id="__thm_1.38"></a>
+<b>Exercise 1.38.</b>  <a id="__idx_1144"></a>In 1737, the Swiss mathematician Leonhard Euler published a memoir
+<em>De Fractionibus Continuis</em>, which included a <a id="__idx_1146"></a><a id="__idx_1148"></a>continued fraction
 expansion for <em>e</em> - 2, where <em>e</em> is the base of the natural logarithms.
 In this fraction, the <em>N</em><sub><em>i</em></sub> are all 1, and the <em>D</em><sub><em>i</em></sub> are successively
 1, 2, 1, 1, 4, 1, 1, 6, 1, 1, 8, <tt>...</tt>.  Write a program that uses
 your <tt>cont-frac</tt> procedure from
-exercise <a href="#%_thm_1.37">1.37</a> to approximate <em>e</em>, based on
+exercise <a href="#__thm_1.37">1.37</a> to approximate <em>e</em>, based on
 Euler's expansion.
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.39" id="%_thm_1.39"></a>
-<b>Exercise 1.39.</b>  <a name="%_idx_1150" id="%_idx_1150"></a><a name="%_idx_1152" id="%_idx_1152"></a><a name="%_idx_1154" id="%_idx_1154"></a>A continued fraction representation of the tangent function was
+</p><p><a id="__thm_1.39"></a>
+<b>Exercise 1.39.</b>  <a id="__idx_1150"></a><a id="__idx_1152"></a><a id="__idx_1154"></a>A continued fraction representation of the tangent function was
 published in 1770 by the German mathematician J.H. Lambert:
-</p><p></p><div align="left"><img src="images/ch1-Z-G-36.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch1-Z-G-36.gif" alt="ch1-Z-G-36" style="border: none;" /></div><p>
 where <em>x</em> is in radians.
 Define a procedure <tt>(tan-cf x k)</tt> that computes an approximation
 to the tangent function based on Lambert's
 formula.  <tt>K</tt> specifies the number of terms to compute, as in
-exercise <a href="#%_thm_1.37">1.37</a>.
+exercise <a href="#__thm_1.37">1.37</a>.
 </p><p></p><p>
 
-<a name="%_sec_1.3.4" id="%_sec_1.3.4"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_1.3.4">1.3.4  Procedures as Returned Values</a></h3><p>
+<a id="__sec_1.3.4"></a>
+</p><h3>1.3.4  Procedures as Returned Values</h3><p>
 
 
-<a name="%_idx_1156" id="%_idx_1156"></a><a name="%_idx_1158" id="%_idx_1158"></a>
+<a id="__idx_1156"></a><a id="__idx_1158"></a>
 The above examples demonstrate how
 the ability to pass procedures as arguments significantly enhances
 the expressive power of our programming language.  We can achieve even
@@ -752,7 +752,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 
 We can illustrate this idea by looking again at the fixed-point
 example described at the end of
-section <a href="#%_sec_1.3.3">1.3.3</a>.  We formulated a new version
+section <a href="#__sec_1.3.3">1.3.3</a>.  We formulated a new version
 of the square-root procedure as a fixed-point search, starting with
 the observation that √<em>x</em> is a fixed-point of the function
 <em>y</em> ⟼  <em>x</em>/<em>y</em>.  Then we used average damping to make the
@@ -764,7 +764,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 We can express the idea of average damping by means of the
 following procedure:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1160" id="%_idx_1160"></a>(define (average-damp f)<br />
+</p><p></p><p><tt><a id="__idx_1160"></a>(define (average-damp f)<br />
   (lambda (x) (average x (f x))))<br /></tt></p><p></p><p>
 <tt>Average-damp</tt> is a procedure that takes as its argument a
 procedure <tt>f</tt> and returns as its value a procedure (produced by
@@ -772,23 +772,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 average of <tt>x</tt> and <tt>(f x)</tt>.  For example, applying <tt>average-damp</tt> to the <tt>square</tt> procedure produces a procedure whose
 value at some number <em>x</em> is the average of <em>x</em> and <em>x</em><sup>2</sup>.  Applying
 this resulting procedure to 10 returns the average of 10 and 100, or
-55:<a name="call_footnote_Temp_114" href="#footnote_Temp_114" id="call_footnote_Temp_114"><sup><small>59</small></sup></a></p><p>
+55:<a href="#footnote_Temp_114" id="call_footnote_Temp_114"><sup><small>59</small></sup></a></p><p>
 
 
 </p><p></p><p><tt>((average-damp square) 10)<br /><i>55</i><br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_1168" id="%_idx_1168"></a>Using <tt>average-damp</tt>, we can reformulate the square-root procedure
+<a id="__idx_1168"></a>Using <tt>average-damp</tt>, we can reformulate the square-root procedure
 as follows:</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_1170" id="%_idx_1170"></a>(define (sqrt x)<br />
+</p><p></p><p><tt><a id="__idx_1170"></a>(define (sqrt x)<br />
   (fixed-point (average-damp (lambda (y) (/ x y)))<br />
                1.0))<br /></tt></p><p></p><p>
 Notice how this formulation makes explicit the three ideas in the
 method: fixed-point search, average damping, and the function
 <em>y</em> ⟼  <em>x</em>/<em>y</em>.  It is instructive to compare this formulation of the
 square-root method with the original version given in
-section <a href="book-Z-H-10.html#%_sec_1.1.7">1.1.7</a>.  Bear in mind that these procedures express
+section <a href="book-Z-H-10.html#__sec_1.1.7">1.1.7</a>.  Bear in mind that these procedures express
 the same process, and notice how much clearer the idea becomes when we
 express the process in terms of these abstractions.  In general, there
 are many ways to formulate a process as a procedure.  Experienced
@@ -797,36 +797,36 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 exposed as separate entities that can be reused in other applications.
 As a simple example of reuse, notice that the cube root of <em>x</em> is a
 fixed point of the function <em>y</em> ⟼  <em>x</em>/<em>y</em><sup>2</sup>, so we can immediately
-generalize our square-root procedure to one that extracts <a name="%_idx_1172" id="%_idx_1172"></a><a name="%_idx_1174" id="%_idx_1174"></a>cube
-roots:<a name="call_footnote_Temp_115" href="#footnote_Temp_115" id="call_footnote_Temp_115"><sup><small>60</small></sup></a></p><p>
+generalize our square-root procedure to one that extracts <a id="__idx_1172"></a><a id="__idx_1174"></a>cube
+roots:<a href="#footnote_Temp_115" id="call_footnote_Temp_115"><sup><small>60</small></sup></a></p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_1176" id="%_idx_1176"></a>(define (cube-root x)<br />
+</p><p></p><p><tt><a id="__idx_1176"></a>(define (cube-root x)<br />
   (fixed-point (average-damp (lambda (y) (/ x (square y))))<br />
                1.0))<br /></tt></p><p></p><p></p><p>
 
 
-<a name="%_sec_Temp_116" id="%_sec_Temp_116"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_116">Newton's method</a></h4><p>
+<a id="__sec_Temp_116"></a>
+</p><h4>Newton's method</h4><p>
 
-<a name="%_idx_1178" id="%_idx_1178"></a>
+<a id="__idx_1178"></a>
 When we first introduced the square-root procedure, in
-section <a href="book-Z-H-10.html#%_sec_1.1.7">1.1.7</a>, we mentioned that this was a special case of
+section <a href="book-Z-H-10.html#__sec_1.1.7">1.1.7</a>, we mentioned that this was a special case of
 <em>Newton's method</em>.
 If <em>x</em> ⟼  <em>g</em>(<em>x</em>) is a differentiable function, then a solution of
 the equation <em>g</em>(<em>x</em>) = 0 is a fixed point of the function <em>x</em> ⟼  <em>f</em>(<em>x</em>)
 where
-</p><p></p><div align="left"><img src="images/ch1-Z-G-37.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch1-Z-G-37.gif" alt="ch1-Z-G-37" style="border: none;" /></div><p>
 and
-<em>D</em><em>g</em>(<em>x</em>) is the derivative of <em>g</em> evaluated at <em>x</em>.  <a name="%_idx_1180" id="%_idx_1180"></a>Newton's
+<em>D</em><em>g</em>(<em>x</em>) is the derivative of <em>g</em> evaluated at <em>x</em>.  <a id="__idx_1180"></a>Newton's
 method is the use of the fixed-point method we saw above to
 approximate a solution of the equation by finding a fixed point of
-the function <em>f</em>.<a name="call_footnote_Temp_117" href="#footnote_Temp_117" id="call_footnote_Temp_117"><sup><small>61</small></sup></a>
+the function <em>f</em>.<a href="#footnote_Temp_117" id="call_footnote_Temp_117"><sup><small>61</small></sup></a>
 For many functions <em>g</em> and for sufficiently good initial guesses for
 <em>x</em>, Newton's method converges very rapidly to a solution of
-<em>g</em>(<em>x</em>) = 0.<a name="call_footnote_Temp_118" href="#footnote_Temp_118" id="call_footnote_Temp_118"><sup><small>62</small></sup></a></p><p>
+<em>g</em>(<em>x</em>) = 0.<a href="#footnote_Temp_118" id="call_footnote_Temp_118"><sup><small>62</small></sup></a></p><p>
 
-<a name="%_idx_1186" id="%_idx_1186"></a><a name="%_idx_1188" id="%_idx_1188"></a><a name="%_idx_1190" id="%_idx_1190"></a>In order to implement Newton's method as a procedure, we must first
+<a id="__idx_1186"></a><a id="__idx_1188"></a><a id="__idx_1190"></a>In order to implement Newton's method as a procedure, we must first
 express the idea of derivative.  Note that “derivative,” like
 average damping, is something that transforms a function into another
 function.  For instance, the derivative of the function <em>x</em> ⟼
@@ -834,11 +834,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 function and <em>d</em><em>x</em> is a small number, then the derivative <em>D</em><em>g</em> of <em>g</em> is
 the function whose value at any number <em>x</em> is given (in the limit of
 small <em>d</em><em>x</em>) by
-</p><p></p><div align="left"><img src="images/ch1-Z-G-38.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch1-Z-G-38.gif" alt="ch1-Z-G-38" style="border: none;" /></div><p>
 Thus, we can express the idea of derivative (taking <em>d</em><em>x</em> to be, say,
 0.00001) as the procedure</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1192" id="%_idx_1192"></a>(define (deriv g)<br />
+</p><p></p><p><tt><a id="__idx_1192"></a>(define (deriv g)<br />
   (lambda (x)<br />
     (/ (- (g (+ x dx)) (g x))<br />
        dx)))<br /></tt></p><p></p><p>
@@ -851,69 +851,69 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 to approximate the derivative of <em>x</em>  ⟼  <em>x</em><sup>3</sup> at 5 (whose exact
 value is 75) we can evaluate</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1194" id="%_idx_1194"></a>(define (cube x) (* x x x))<br />
+</p><p></p><p><tt><a id="__idx_1194"></a>(define (cube x) (* x x x))<br />
 ((deriv cube) 5)<br /><i>75.00014999664018</i><br /></tt></p><p></p><p></p><p>
 
 With the aid of <tt>deriv</tt>, we can express Newton's method as a
 fixed-point process:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1196" id="%_idx_1196"></a>(define (newton-transform g)<br />
+</p><p></p><p><tt><a id="__idx_1196"></a>(define (newton-transform g)<br />
   (lambda (x)<br />
-    (- x (/ (g x) ((deriv g) x)))))<br /><a name="%_idx_1198" id="%_idx_1198"></a>(define (newtons-method g guess)<br />
+    (- x (/ (g x) ((deriv g) x)))))<br /><a id="__idx_1198"></a>(define (newtons-method g guess)<br />
   (fixed-point (newton-transform g) guess))<br /></tt></p><p></p><p>
 The <tt>newton-transform</tt> procedure expresses the formula at the
 beginning of this section, and <tt>newtons-method</tt> is readily defined
 in terms of this.  It takes as arguments a procedure that computes the
 function for which we want to find a zero, together with an initial
-guess.  For instance, to find the <a name="%_idx_1200" id="%_idx_1200"></a>square root of <em>x</em>, we can use
+guess.  For instance, to find the <a id="__idx_1200"></a>square root of <em>x</em>, we can use
 Newton's method to find a zero of the function <em>y</em> ⟼  <em>y</em><sup>2</sup> - <em>x</em> starting with
-an initial guess of 1.<a name="call_footnote_Temp_119" href="#footnote_Temp_119" id="call_footnote_Temp_119"><sup><small>63</small></sup></a>
+an initial guess of 1.<a href="#footnote_Temp_119" id="call_footnote_Temp_119"><sup><small>63</small></sup></a>
 This provides yet another form of the square-root
 procedure:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1202" id="%_idx_1202"></a>(define (sqrt x)<br />
+</p><p></p><p><tt><a id="__idx_1202"></a>(define (sqrt x)<br />
   (newtons-method (lambda (y) (- (square y) x))<br />
                   1.0))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_120" id="%_sec_Temp_120"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_120">Abstractions and first-class procedures</a></h4><p>
+<a id="__sec_Temp_120"></a>
+</p><h4>Abstractions and first-class procedures</h4><p>
 
 We've seen two ways to express the square-root
 computation as an instance of a more general method, once as a fixed-point
 search and once using Newton's method.  Since Newton's method
 was itself expressed as a fixed-point process,
 we actually saw two ways to compute square roots as fixed points.
-Each method begins with a function and finds a <a name="%_idx_1204" id="%_idx_1204"></a>fixed
+Each method begins with a function and finds a <a id="__idx_1204"></a>fixed
 point of some transformation of the function.  We can express this
 general idea itself as a procedure:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1206" id="%_idx_1206"></a>(define (fixed-point-of-transform g transform guess)<br />
+</p><p></p><p><tt><a id="__idx_1206"></a>(define (fixed-point-of-transform g transform guess)<br />
   (fixed-point (transform g) guess))<br /></tt></p><p></p><p>
 This very general procedure takes as its arguments a procedure <tt>g</tt>
 that computes some function, a procedure that transforms <tt>g</tt>, and
 an initial guess.  The returned result is a fixed point of the
 transformed function.</p><p>
 
-<a name="%_idx_1208" id="%_idx_1208"></a>Using this abstraction, we can recast the first square-root
+<a id="__idx_1208"></a>Using this abstraction, we can recast the first square-root
 computation from this section (where we look for
 a fixed point of the average-damped version of <em>y</em>  ⟼  <em>x</em>/<em>y</em>)
 as an instance of this general method:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1210" id="%_idx_1210"></a>(define (sqrt x)<br />
+</p><p></p><p><tt><a id="__idx_1210"></a>(define (sqrt x)<br />
   (fixed-point-of-transform (lambda (y) (/ x y))<br />
                             average-damp<br />
                             1.0))<br /></tt></p><p></p><p>
-<a name="%_idx_1212" id="%_idx_1212"></a>Similarly, we can express the second square-root computation from this section
+<a id="__idx_1212"></a>Similarly, we can express the second square-root computation from this section
 (an instance
 of Newton's method that finds a fixed point of the
 Newton transform of <em>y</em> ⟼  <em>y</em><sup>2</sup> - <em>x</em>) as</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1214" id="%_idx_1214"></a><a name="%_idx_1216" id="%_idx_1216"></a>(define (sqrt x)<br />
+</p><p></p><p><tt><a id="__idx_1214"></a><a id="__idx_1216"></a>(define (sqrt x)<br />
   (fixed-point-of-transform (lambda (y) (- (square y) x))<br />
                             newton-transform<br />
                             1.0))<br /></tt></p><p></p><p></p><p>
 
-We began section <a href="#%_sec_1.3">1.3</a> with the observation
+We began section <a href="#__sec_1.3">1.3</a> with the observation
 that compound procedures
 are a crucial abstraction mechanism, because they permit us to
 express general methods of computing as explicit elements in our
@@ -935,19 +935,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 
 In general, programming languages impose restrictions on the ways in
 which computational elements can be manipulated.  Elements with the
-fewest restrictions are said to have <a name="%_idx_1218" id="%_idx_1218"></a><em>first-class</em> status.  Some
-of the “rights and privileges” of first-class elements are:<a name="call_footnote_Temp_121" href="#footnote_Temp_121" id="call_footnote_Temp_121"><sup><small>64</small></sup></a>
+fewest restrictions are said to have <a id="__idx_1218"></a><em>first-class</em> status.  Some
+of the “rights and privileges” of first-class elements are:<a href="#footnote_Temp_121" id="call_footnote_Temp_121"><sup><small>64</small></sup></a>
 </p><p></p><ul><li>They may be named by variables.
 </li><li>They may be passed as arguments to procedures.
 </li><li>They may be returned as the results of procedures.
-</li><li>They may be included in data structures.<a name="call_footnote_Temp_122" href="#footnote_Temp_122" id="call_footnote_Temp_122"><sup><small>65</small></sup></a>
+</li><li>They may be included in data structures.<a href="#footnote_Temp_122" id="call_footnote_Temp_122"><sup><small>65</small></sup></a>
 </li></ul><p>
-<a name="%_idx_1222" id="%_idx_1222"></a><a name="%_idx_1224" id="%_idx_1224"></a>Lisp, unlike other common programming languages, awards procedures
+<a id="__idx_1222"></a><a id="__idx_1224"></a>Lisp, unlike other common programming languages, awards procedures
 full first-class status.  This poses challenges for efficient
 implementation, but the resulting gain in expressive power is
-enormous.<a name="call_footnote_Temp_123" href="#footnote_Temp_123" id="call_footnote_Temp_123"><sup><small>66</small></sup></a></p><p>
+enormous.<a href="#footnote_Temp_123" id="call_footnote_Temp_123"><sup><small>66</small></sup></a></p><p>
 
-</p><p><a name="%_thm_1.40" id="%_thm_1.40"></a>
+</p><p><a id="__thm_1.40"></a>
 <b>Exercise 1.40.</b>  Define a procedure <tt>cubic</tt> that can be used together with the <tt>newtons-method</tt> procedure in expressions of the form</p><p>
 
 
@@ -955,7 +955,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 to approximate zeros of the cubic <em>x</em><sup>3</sup>  + <em>a</em><em>x</em><sup>2</sup>  + <em>b</em><em>x</em>  + <em>c</em>.
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.41" id="%_thm_1.41"></a>
+</p><p><a id="__thm_1.41"></a>
 <b>Exercise 1.41.</b>  Define a procedure <tt>double</tt> that takes a procedure of one
 argument as argument and
 returns a procedure that applies the original procedure twice.  For
@@ -967,8 +967,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 </p><p></p><p><tt>(((double (double double)) inc) 5)<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.42" id="%_thm_1.42"></a>
-<b>Exercise 1.42.</b>  <a name="%_idx_1226" id="%_idx_1226"></a><a name="%_idx_1228" id="%_idx_1228"></a>Let <em>f</em> and <em>g</em> be two one-argument functions.  The <em>composition</em>
+</p><p><a id="__thm_1.42"></a>
+<b>Exercise 1.42.</b>  <a id="__idx_1226"></a><a id="__idx_1228"></a>Let <em>f</em> and <em>g</em> be two one-argument functions.  The <em>composition</em>
 <em>f</em> after <em>g</em> is defined to be the function <em>x</em> ⟼  <em>f</em>(<em>g</em>(<em>x</em>)).
 Define a procedure <tt>compose</tt> that implements composition.  For
 example, if <tt>inc</tt> is a procedure that adds 1 to its argument,
@@ -977,8 +977,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 </p><p></p><p>
 
 
-</p><p><a name="%_thm_1.43" id="%_thm_1.43"></a>
-<b>Exercise 1.43.</b>  <a name="%_idx_1230" id="%_idx_1230"></a>If <em>f</em> is a numerical function and <em>n</em> is a positive integer, then we
+</p><p><a id="__thm_1.43"></a>
+<b>Exercise 1.43.</b>  <a id="__idx_1230"></a>If <em>f</em> is a numerical function and <em>n</em> is a positive integer, then we
 can form the <em>n</em>th repeated application of <em>f</em>, which is defined to be
 the function whose value at <em>x</em> is <em>f</em>(<em>f</em>(<tt>...</tt>(<em>f</em>(<em>x</em>))<tt>...</tt>)).  For
 example, if <em>f</em> is the function <em>x</em>  ⟼  <em>x</em> + 1,
@@ -994,12 +994,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 
 </p><p></p><p><tt>((repeated square 2) 5)<br /><i>625</i><br /></tt></p><p></p><p>
 Hint: You may find it convenient to use <tt>compose</tt> from
-exercise <a href="#%_thm_1.42">1.42</a>.
+exercise <a href="#__thm_1.42">1.42</a>.
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.44" id="%_thm_1.44"></a>
-<b>Exercise 1.44.</b>  <a name="%_idx_1232" id="%_idx_1232"></a><a name="%_idx_1234" id="%_idx_1234"></a><a name="%_idx_1236" id="%_idx_1236"></a>The idea of <em>smoothing</em> a function is an important concept in
+</p><p><a id="__thm_1.44"></a>
+<b>Exercise 1.44.</b>  <a id="__idx_1232"></a><a id="__idx_1234"></a><a id="__idx_1236"></a>The idea of <em>smoothing</em> a function is an important concept in
 signal processing.  If <em>f</em> is a function and <em>d</em><em>x</em> is some small number,
 then the smoothed version of <em>f</em> is the function whose value at a
 point <em>x</em> is the average of <em>f</em>(<em>x</em> - <em>d</em><em>x</em>), <em>f</em>(<em>x</em>), and <em>f</em>(<em>x</em> + <em>d</em><em>x</em>).  Write a
@@ -1009,30 +1009,30 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 the smoothed function, and so on) to obtained the <em><em>n</em>-fold
 smoothed function</em>.  Show how to generate the <em>n</em>-fold smoothed
 function of any given function using <tt>smooth</tt> and <tt>repeated</tt>
-from exercise <a href="#%_thm_1.43">1.43</a>.
+from exercise <a href="#__thm_1.43">1.43</a>.
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.45" id="%_thm_1.45"></a>
-<b>Exercise 1.45.</b>  We saw in section <a href="#%_sec_1.3.3">1.3.3</a>
+</p><p><a id="__thm_1.45"></a>
+<b>Exercise 1.45.</b>  We saw in section <a href="#__sec_1.3.3">1.3.3</a>
 that attempting to compute square roots by naively finding a
 fixed point of <em>y</em> ⟼  <em>x</em>/<em>y</em> does not converge, and that this can be
 fixed by average damping.  The same method works for finding cube
 roots as fixed points of the average-damped <em>y</em> ⟼  <em>x</em>/<em>y</em><sup>2</sup>.
-Unfortunately, the process does not work for <a name="%_idx_1238" id="%_idx_1238"></a><a name="%_idx_1240" id="%_idx_1240"></a>fourth roots – a single
+Unfortunately, the process does not work for <a id="__idx_1238"></a><a id="__idx_1240"></a>fourth roots – a single
 average damp is not enough to make a fixed-point search for <em>y</em> ⟼
 <em>x</em>/<em>y</em><sup>3</sup> converge.  On the other hand, if we average damp twice (i.e.,
 use the average damp of the average damp of <em>y</em> ⟼  <em>x</em>/<em>y</em><sup>3</sup>) the
 fixed-point search does converge.  Do some experiments to determine
-how many average damps are required to compute <a name="%_idx_1242" id="%_idx_1242"></a><a name="%_idx_1244" id="%_idx_1244"></a><em>n</em>th roots as a
+how many average damps are required to compute <a id="__idx_1242"></a><a id="__idx_1244"></a><em>n</em>th roots as a
 fixed-point search based upon repeated average damping of <em>y</em> ⟼
 <em>x</em>/<em>y</em><sup><em>n</em>-1</sup>.  Use this to implement a simple procedure for computing
-<em>n</em>th roots using <tt>fixed-point</tt>, <tt>average-damp</tt>, and the <tt>repeated</tt> procedure of exercise <a href="#%_thm_1.43">1.43</a>.
+<em>n</em>th roots using <tt>fixed-point</tt>, <tt>average-damp</tt>, and the <tt>repeated</tt> procedure of exercise <a href="#__thm_1.43">1.43</a>.
 Assume that any arithmetic operations you need are available as primitives.
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_1.46" id="%_thm_1.46"></a>
-<b>Exercise 1.46.</b>  <a name="%_idx_1246" id="%_idx_1246"></a><a name="%_idx_1248" id="%_idx_1248"></a><a name="%_idx_1250" id="%_idx_1250"></a><a name="%_idx_1252" id="%_idx_1252"></a>Several of the numerical methods described in this chapter are instances
+</p><p><a id="__thm_1.46"></a>
+<b>Exercise 1.46.</b>  <a id="__idx_1246"></a><a id="__idx_1248"></a><a id="__idx_1250"></a><a id="__idx_1252"></a>Several of the numerical methods described in this chapter are instances
 of an extremely general computational strategy known as <em>iterative
 improvement</em>.  Iterative improvement says that, to compute something,
 we start with an initial guess for the answer, test if the guess is
@@ -1042,119 +1042,119 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_1.3">1.3  Formulating Abstractions wi
 a guess.  <tt>Iterative-improve</tt> should return as its value a
 procedure that takes a guess as argument and keeps improving the guess
 until it is good enough.  Rewrite the <tt>sqrt</tt> procedure of
-section <a href="book-Z-H-10.html#%_sec_1.1.7">1.1.7</a> and the <tt>fixed-point</tt> procedure of
-section <a href="#%_sec_1.3.3">1.3.3</a> in terms of <tt>iterative-improve</tt>.
+section <a href="book-Z-H-10.html#__sec_1.1.7">1.1.7</a> and the <tt>fixed-point</tt> procedure of
+section <a href="#__sec_1.3.3">1.3.3</a> in terms of <tt>iterative-improve</tt>.
 </p><p>
 </p><p>
 
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_90" href="#call_footnote_Temp_90" id="footnote_Temp_90"><sup><small>49</small></sup></a> This series,
-<a name="%_idx_974" id="%_idx_974"></a><a name="%_idx_976" id="%_idx_976"></a>usually written in the equivalent form (π/4)  =  1 - (1/3) + (1/5) - (1/7) + <tt>···</tt>, is due to Leibniz.  We'll see how
+</p><div class="footnote"><p><a href="#call_footnote_Temp_90" id="footnote_Temp_90"><sup><small>49</small></sup></a> This series,
+<a id="__idx_974"></a><a id="__idx_976"></a>usually written in the equivalent form (π/4)  =  1 - (1/3) + (1/5) - (1/7) + <tt>···</tt>, is due to Leibniz.  We'll see how
 to use this as the basis for some fancy numerical tricks in
-section <a href="book-Z-H-24.html#%_sec_3.5.3">3.5.3</a>.
+section <a href="book-Z-H-24.html#__sec_3.5.3">3.5.3</a>.
 
-</p><p><a name="footnote_Temp_91" href="#call_footnote_Temp_91" id="footnote_Temp_91"><sup><small>50</small></sup></a> Notice
-that we have used block structure (section <a href="book-Z-H-10.html#%_sec_1.1.8">1.1.8</a>) to
+</p><p><a href="#call_footnote_Temp_91" id="footnote_Temp_91"><sup><small>50</small></sup></a> Notice
+that we have used block structure (section <a href="book-Z-H-10.html#__sec_1.1.8">1.1.8</a>) to
 embed the definitions of <tt>pi-next</tt> and <tt>pi-term</tt> within <tt>pi-sum</tt>, since these procedures are unlikely to be useful for any
 other purpose.  We will see how to get rid of them altogether in
-section <a href="#%_sec_1.3.2">1.3.2</a>.
+section <a href="#__sec_1.3.2">1.3.2</a>.
 
-</p><p><a name="footnote_Temp_95" href="#call_footnote_Temp_95" id="footnote_Temp_95"><sup><small>51</small></sup></a> The intent of
-exercises <a href="#%_thm_1.31">1.31</a>-<a href="#%_thm_1.33">1.33</a> is to
+</p><p><a href="#call_footnote_Temp_95" id="footnote_Temp_95"><sup><small>51</small></sup></a> The intent of
+exercises <a href="#__thm_1.31">1.31</a>-<a href="#__thm_1.33">1.33</a> is to
 demonstrate the expressive power that is attained by using an
 appropriate abstraction to consolidate many seemingly disparate
 operations.  However, though accumulation and filtering are elegant
 ideas, our hands are somewhat tied in using them at this point since
 we do not yet have data structures to provide suitable means of
 combination for these abstractions.  We will return to these ideas in
-section <a href="book-Z-H-15.html#%_sec_2.2.3">2.2.3</a> when we show how
+section <a href="book-Z-H-15.html#__sec_2.2.3">2.2.3</a> when we show how
 to use <em>sequences</em> as interfaces for combining filters and
 accumulators to build even more powerful abstractions.  We will see
 there how these methods really come into their own as a powerful and
 elegant approach to designing programs.
 
-</p><p><a name="footnote_Temp_96" href="#call_footnote_Temp_96" id="footnote_Temp_96"><sup><small>52</small></sup></a> This formula was discovered by the seventeenth-century
-<a name="%_idx_1016" id="%_idx_1016"></a>English mathematician John Wallis.
+</p><p><a href="#call_footnote_Temp_96" id="footnote_Temp_96"><sup><small>52</small></sup></a> This formula was discovered by the seventeenth-century
+<a id="__idx_1016"></a>English mathematician John Wallis.
 
-</p><p><a name="footnote_Temp_99" href="#call_footnote_Temp_99" id="footnote_Temp_99"><sup><small>53</small></sup></a> It would be clearer and less intimidating to
+</p><p><a href="#call_footnote_Temp_99" id="footnote_Temp_99"><sup><small>53</small></sup></a> It would be clearer and less intimidating to
 people learning Lisp if a name more obvious than <tt>lambda</tt>, such as
 <tt>make-procedure</tt>, were used.  But the convention is firmly
-entrenched.  The notation is adopted from the <a name="%_idx_1054" id="%_idx_1054"></a>λ calculus, a
-<a name="%_idx_1056" id="%_idx_1056"></a>mathematical formalism introduced by the mathematical logician Alonzo
+entrenched.  The notation is adopted from the <a id="__idx_1054"></a>λ calculus, a
+<a id="__idx_1056"></a>mathematical formalism introduced by the mathematical logician Alonzo
 Church (1941).  Church developed the λ calculus to provide a
 rigorous foundation for studying the notions of function and function
 application.  The λ calculus has become a basic tool for
 mathematical investigations of the semantics of programming
 languages.
 
-</p><p><a name="footnote_Temp_101" href="#call_footnote_Temp_101" id="footnote_Temp_101"><sup><small>54</small></sup></a> Understanding internal definitions well enough to be sure a
+</p><p><a href="#call_footnote_Temp_101" id="footnote_Temp_101"><sup><small>54</small></sup></a> Understanding internal definitions well enough to be sure a
 program means what we intend it to mean requires a more elaborate
 model of the evaluation process than we have presented in this
 chapter.  The subtleties do not arise with internal definitions of
 procedures, however.  We will return to this issue in
-section <a href="book-Z-H-26.html#%_sec_4.1.6">4.1.6</a>, after we learn more about
+section <a href="book-Z-H-26.html#__sec_4.1.6">4.1.6</a>, after we learn more about
 evaluation.
 
-</p><p><a name="footnote_Temp_104" href="#call_footnote_Temp_104" id="footnote_Temp_104"><sup><small>55</small></sup></a> We have used 0.001 as a representative “small” number to indicate a
+</p><p><a href="#call_footnote_Temp_104" id="footnote_Temp_104"><sup><small>55</small></sup></a> We have used 0.001 as a representative “small” number to indicate a
 tolerance for the acceptable error in a calculation.  The appropriate
 tolerance for a real calculation depends upon the problem to be solved
 and the limitations of the computer and the algorithm.  This is often
-<a name="%_idx_1086" id="%_idx_1086"></a>a very subtle consideration, requiring help from a numerical analyst
+<a id="__idx_1086"></a>a very subtle consideration, requiring help from a numerical analyst
 or some other kind of magician.
 
-</p><p><a name="footnote_Temp_105" href="#call_footnote_Temp_105" id="footnote_Temp_105"><sup><small>56</small></sup></a> This
-<a name="%_idx_1088" id="%_idx_1088"></a><a name="%_idx_1090" id="%_idx_1090"></a>can be accomplished using <tt>error</tt>, which takes as
+</p><p><a href="#call_footnote_Temp_105" id="footnote_Temp_105"><sup><small>56</small></sup></a> This
+<a id="__idx_1088"></a><a id="__idx_1090"></a>can be accomplished using <tt>error</tt>, which takes as
 arguments a number of items that are printed as error
 messages.
 
-</p><p><a name="footnote_Temp_107" href="#call_footnote_Temp_107" id="footnote_Temp_107"><sup><small>57</small></sup></a> Try this during a boring lecture: Set your calculator to
-<a name="%_idx_1106" id="%_idx_1106"></a><a name="%_idx_1108" id="%_idx_1108"></a><a name="%_idx_1110" id="%_idx_1110"></a>radians mode and then repeatedly press the <tt>cos</tt> button until you
+</p><p><a href="#call_footnote_Temp_107" id="footnote_Temp_107"><sup><small>57</small></sup></a> Try this during a boring lecture: Set your calculator to
+<a id="__idx_1106"></a><a id="__idx_1108"></a><a id="__idx_1110"></a>radians mode and then repeatedly press the <tt>cos</tt> button until you
 obtain the fixed point.
 
-</p><p><a name="footnote_Temp_108" href="#call_footnote_Temp_108" id="footnote_Temp_108"><sup><small>58</small></sup></a>  ⟼
-<a name="%_idx_1122" id="%_idx_1122"></a><a name="%_idx_1124" id="%_idx_1124"></a>(pronounced “maps to”) is
+</p><p><a href="#call_footnote_Temp_108" id="footnote_Temp_108"><sup><small>58</small></sup></a>  ⟼
+<a id="__idx_1122"></a><a id="__idx_1124"></a>(pronounced “maps to”) is
 the mathematician's way of writing <tt>lambda</tt>.
 <em>y</em>  ⟼  <em>x</em>/<em>y</em> means <tt>(lambda(y) (/ x y))</tt>, that is, the
 function whose value at <em>y</em> is <em>x</em>/<em>y</em>.
 
-</p><p><a name="footnote_Temp_114" href="#call_footnote_Temp_114" id="footnote_Temp_114"><sup><small>59</small></sup></a> Observe that this is a combination whose operator is itself
-<a name="%_idx_1162" id="%_idx_1162"></a><a name="%_idx_1164" id="%_idx_1164"></a><a name="%_idx_1166" id="%_idx_1166"></a>a combination.  Exercise <a href="book-Z-H-10.html#%_thm_1.4">1.4</a> already demonstrated
+</p><p><a href="#call_footnote_Temp_114" id="footnote_Temp_114"><sup><small>59</small></sup></a> Observe that this is a combination whose operator is itself
+<a id="__idx_1162"></a><a id="__idx_1164"></a><a id="__idx_1166"></a>a combination.  Exercise <a href="book-Z-H-10.html#__thm_1.4">1.4</a> already demonstrated
 the ability to form such combinations, but that was only a toy
 example.  Here we begin to see the real need for such
 combinations – when applying a procedure that is obtained as the value
 returned by a higher-order procedure.
 
-</p><p><a name="footnote_Temp_115" href="#call_footnote_Temp_115" id="footnote_Temp_115"><sup><small>60</small></sup></a> See exercise <a href="#%_thm_1.45">1.45</a> for a further
+</p><p><a href="#call_footnote_Temp_115" id="footnote_Temp_115"><sup><small>60</small></sup></a> See exercise <a href="#__thm_1.45">1.45</a> for a further
 generalization.
 
-</p><p><a name="footnote_Temp_117" href="#call_footnote_Temp_117" id="footnote_Temp_117"><sup><small>61</small></sup></a> Elementary calculus books usually describe Newton's
+</p><p><a href="#call_footnote_Temp_117" id="footnote_Temp_117"><sup><small>61</small></sup></a> Elementary calculus books usually describe Newton's
 method in terms of the sequence of approximations
 <em>x</em><sub><em>n</em>+1</sub> = <em>x</em><sub><em>n</em></sub> - <em>g</em>(<em>x</em><sub><em>n</em></sub>)/<em>D</em><em>g</em>(<em>x</em><sub><em>n</em></sub>).  Having language for talking about
 processes and using the idea of fixed points simplifies the description
 of the method.
 
-</p><p><a name="footnote_Temp_118" href="#call_footnote_Temp_118" id="footnote_Temp_118"><sup><small>62</small></sup></a> Newton's method does not always converge to an answer, but
+</p><p><a href="#call_footnote_Temp_118" id="footnote_Temp_118"><sup><small>62</small></sup></a> Newton's method does not always converge to an answer, but
 it can be shown that in favorable cases each iteration doubles the
 number-of-digits accuracy of the approximation to the solution.
-In such cases, <a name="%_idx_1182" id="%_idx_1182"></a><a name="%_idx_1184" id="%_idx_1184"></a>Newton's method will converge much more
+In such cases, <a id="__idx_1182"></a><a id="__idx_1184"></a>Newton's method will converge much more
 rapidly than the half-interval method.
 
-</p><p><a name="footnote_Temp_119" href="#call_footnote_Temp_119" id="footnote_Temp_119"><sup><small>63</small></sup></a> For finding square roots, Newton's method converges rapidly to the
+</p><p><a href="#call_footnote_Temp_119" id="footnote_Temp_119"><sup><small>63</small></sup></a> For finding square roots, Newton's method converges rapidly to the
 correct solution from any starting point.
 
-</p><p><a name="footnote_Temp_121" href="#call_footnote_Temp_121" id="footnote_Temp_121"><sup><small>64</small></sup></a> The notion of first-class status of programming-language
-<a name="%_idx_1220" id="%_idx_1220"></a>elements is due to the British computer scientist Christopher
+</p><p><a href="#call_footnote_Temp_121" id="footnote_Temp_121"><sup><small>64</small></sup></a> The notion of first-class status of programming-language
+<a id="__idx_1220"></a>elements is due to the British computer scientist Christopher
 Strachey (1916-1975).
 
-</p><p><a name="footnote_Temp_122" href="#call_footnote_Temp_122" id="footnote_Temp_122"><sup><small>65</small></sup></a> We'll see
+</p><p><a href="#call_footnote_Temp_122" id="footnote_Temp_122"><sup><small>65</small></sup></a> We'll see
 examples of this after we introduce data structures in chapter 2.
 
-</p><p><a name="footnote_Temp_123" href="#call_footnote_Temp_123" id="footnote_Temp_123"><sup><small>66</small></sup></a> The major implementation cost of first-class
+</p><p><a href="#call_footnote_Temp_123" id="footnote_Temp_123"><sup><small>66</small></sup></a> The major implementation cost of first-class
 procedures is that allowing procedures to be returned as values
 requires reserving storage for a procedure's free variables even while
 the procedure is not executing.  In the Scheme implementation we will
-study in section <a href="book-Z-H-26.html#%_sec_4.1">4.1</a>, these variables are stored in the
+study in section <a href="book-Z-H-26.html#__sec_4.1">4.1</a>, these variables are stored in the
 procedure's environment.
 
 </p></div>
diff --git a/src/OEBPS/book-Z-H-13.html b/src/OEBPS/book-Z-H-13.html
index e8bdafb..92e2998 100644
--- a/src/OEBPS/book-Z-H-13.html
+++ b/src/OEBPS/book-Z-H-13.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,14 +13,14 @@
 
 
 
-<a name="%_chap_2" id="%_chap_2"></a>
+<a id="__chap_2"></a>
 <h1 class="chapter">
-<div class="chapterheading"><a href="book-Z-H-4.html#%_toc_%_chap_2">Chapter 2</a></div></h1><p>
-<a href="book-Z-H-4.html#%_toc_%_chap_2">Building Abstractions with Data</a></p><p>
+<div class="chapterheading">Chapter 2</div></h1><p>
+Building Abstractions with Data</p><p>
 
 </p><p>
-</p><div align="right">
-<table width="60%"><tr><td>
+</p><div style="text-align: right;">
+<table width="60_"><tr><td>
 <span class="epigraph">
 <p>
 
@@ -30,14 +30,14 @@ <h1 class="chapter">
 with these symbols, without ever having to look at the things they
 stand for.</p><p>
 
-<a name="%_idx_1254" id="%_idx_1254"></a>Hermann Weyl, <em>The Mathematical Way of Thinking</em></p><p>
+<a id="__idx_1254"></a>Hermann Weyl, <em>The Mathematical Way of Thinking</em></p><p>
 
 </p></span>
 </td></tr></table></div>
 
 <p></p><p>
 
-<a name="%_idx_1256" id="%_idx_1256"></a><a name="%_idx_1258" id="%_idx_1258"></a>We concentrated in chapter 1 on computational processes and on the
+<a id="__idx_1256"></a><a id="__idx_1258"></a>We concentrated in chapter 1 on computational processes and on the
 role of procedures in program design.  We saw how to use primitive
 data (numbers) and primitive operations (arithmetic operations), how to
 combine procedures to form compound procedures through composition,
@@ -73,7 +73,7 @@ <h1 class="chapter">
 objects enables us to deal with data at a higher conceptual level than
 that of the primitive data objects of the language.</p><p>
 
-<a name="%_idx_1260" id="%_idx_1260"></a>Consider the task of designing a system to perform arithmetic with
+<a id="__idx_1260"></a>Consider the task of designing a system to perform arithmetic with
 rational numbers.  We could imagine an operation <tt>add-rat</tt> that takes
 two rational numbers and produces their sum.  In terms of
 simple data, a rational number can be thought of as two integers: a
@@ -100,7 +100,7 @@ <h1 class="chapter">
 general technique of isolating the parts of a program that deal with
 how data objects are represented from the parts of a program that deal
 with how data objects are used is a powerful design methodology called
-<a name="%_idx_1262" id="%_idx_1262"></a><em>data abstraction</em>.  We will see how data abstraction makes
+<a id="__idx_1262"></a><em>data abstraction</em>.  We will see how data abstraction makes
 programs much easier to design, maintain, and modify.</p><p>
 
 The use of compound data leads to a real increase in the expressive
@@ -135,14 +135,14 @@ <h1 class="chapter">
 objects directly: Without this, there is no way for a procedure such
 as <tt>linear-combination</tt> to pass its arguments along to <tt>add</tt>
 and <tt>mul</tt> without having to know their detailed
-structure.<a name="call_footnote_Temp_131" href="#footnote_Temp_131" id="call_footnote_Temp_131"><sup><small>1</small></sup></a>
+structure.<a href="#footnote_Temp_131" id="call_footnote_Temp_131"><sup><small>1</small></sup></a>
 
 We begin this chapter by implementing the rational-number arithmetic
 system mentioned above.  This will form the background for our
 discussion of compound data and data abstraction.  As with compound
 procedures, the main issue to be addressed is that of abstraction as a
 technique for coping with complexity, and we will see how data
-abstraction enables us to erect suitable <a name="%_idx_1264" id="%_idx_1264"></a><em>abstraction barriers</em>
+abstraction enables us to erect suitable <a id="__idx_1264"></a><em>abstraction barriers</em>
 between different parts of a program.</p><p>
 
 We will see that the key to forming compound data is that a
@@ -154,15 +154,15 @@ <h1 class="chapter">
 “procedure” and “data,” which was already becoming tenuous toward
 the end of chapter 1.  We will also explore some conventional
 techniques for representing sequences and trees.  One key idea in
-dealing with compound data is the notion of <a name="%_idx_1266" id="%_idx_1266"></a><em>closure</em> – that the
+dealing with compound data is the notion of <a id="__idx_1266"></a><em>closure</em> – that the
 glue we use for combining data objects should allow us to combine not
 only primitive data objects, but compound data objects as well.
-Another key idea is that compound data objects can serve as <a name="%_idx_1268" id="%_idx_1268"></a><em>conventional interfaces</em> for combining program modules in
+Another key idea is that compound data objects can serve as <a id="__idx_1268"></a><em>conventional interfaces</em> for combining program modules in
 mix-and-match ways.  We illustrate some of these ideas by presenting a
 simple graphics language that exploits closure.</p><p>
 
 We will then augment the representational power of our language by
-introducing <a name="%_idx_1270" id="%_idx_1270"></a><a name="%_idx_1272" id="%_idx_1272"></a><em>symbolic expressions</em> – data whose elementary parts
+introducing <a id="__idx_1270"></a><a id="__idx_1272"></a><em>symbolic expressions</em> – data whose elementary parts
 can be arbitrary symbols rather than only numbers.  We explore various
 alternatives for representing sets of objects.  We will find that,
 just as a given numerical function can be computed by many different
@@ -175,13 +175,13 @@ <h1 class="chapter">
 
 Next we will take up the problem of working with data that may be
 represented differently by different parts of a program.  This leads
-to the need to implement <a name="%_idx_1274" id="%_idx_1274"></a><a name="%_idx_1276" id="%_idx_1276"></a><em>generic operations</em>, which must handle
+to the need to implement <a id="__idx_1274"></a><a id="__idx_1276"></a><em>generic operations</em>, which must handle
 many different types of data.  Maintaining modularity in the
 presence of generic operations requires more powerful abstraction
 barriers than can be erected with simple data abstraction alone.  In
 particular, we introduce <em>data-directed programming</em> as a
 technique that allows individual data representations to be designed
-in isolation and then combined <a name="%_idx_1278" id="%_idx_1278"></a><em>additively</em> (i.e., without
+in isolation and then combined <a id="__idx_1278"></a><em>additively</em> (i.e., without
 modification).  To illustrate the power of this approach to system
 design, we close the chapter by applying what we have learned to the
 implementation of a package for performing symbolic arithmetic on
@@ -190,10 +190,10 @@ <h1 class="chapter">
 polynomials.</p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_131" href="#call_footnote_Temp_131" id="footnote_Temp_131"><sup><small>1</small></sup></a> The ability to directly manipulate procedures
+</p><div class="footnote"><p><a href="#call_footnote_Temp_131" id="footnote_Temp_131"><sup><small>1</small></sup></a> The ability to directly manipulate procedures
 provides an analogous increase in the expressive power of a
 programming language.  For example, in
-section <a href="book-Z-H-12.html#%_sec_1.3.1">1.3.1</a> we introduced the <tt>sum</tt>
+section <a href="book-Z-H-12.html#__sec_1.3.1">1.3.1</a> we introduced the <tt>sum</tt>
 procedure, which takes a procedure <tt>term</tt> as an argument and
 computes the sum of the values of <tt>term</tt> over some specified
 interval.  In order to define <tt>sum</tt>, it is crucial that we be able
diff --git a/src/OEBPS/book-Z-H-14.html b/src/OEBPS/book-Z-H-14.html
index da2d53b..f90b2b3 100644
--- a/src/OEBPS/book-Z-H-14.html
+++ b/src/OEBPS/book-Z-H-14.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,10 +13,10 @@
 
 
 
-<a name="%_sec_2.1" id="%_sec_2.1"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstraction</a></h2><p>
+<a id="__sec_2.1"></a>
+<h2>2.1  Introduction to Data Abstraction</h2><p>
 
-In section <a href="book-Z-H-10.html#%_sec_1.1.8">1.1.8</a>, we noted
+In section <a href="book-Z-H-10.html#__sec_1.1.8">1.1.8</a>, we noted
 that a procedure used as an element in creating a more complex
 procedure could be regarded not only as a collection of particular
 operations but also as a procedural abstraction.  That is, the details
@@ -26,28 +26,28 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 abstraction that would separate the way the procedure would be used
 from the details of how the procedure would be implemented in terms of
 more primitive procedures.  The analogous notion for compound data is
-called <a name="%_idx_1280" id="%_idx_1280"></a><em>data abstraction</em>.  Data abstraction is a methodology that
+called <a id="__idx_1280"></a><em>data abstraction</em>.  Data abstraction is a methodology that
 enables us to isolate how a compound data object is used from the
 details of how it is constructed from more primitive data objects.</p><p>
 
 The basic idea of data abstraction is to structure the programs that
-are to use compound data objects so that they operate on <a name="%_idx_1282" id="%_idx_1282"></a><a name="%_idx_1284" id="%_idx_1284"></a>“abstract
+are to use compound data objects so that they operate on <a id="__idx_1282"></a><a id="__idx_1284"></a>“abstract
 data.” That is, our programs should use data in such a way as to make
 no assumptions about the data that are not strictly necessary for
-performing the task at hand.  At the same time, a <a name="%_idx_1286" id="%_idx_1286"></a><a name="%_idx_1288" id="%_idx_1288"></a>“concrete” data
+performing the task at hand.  At the same time, a <a id="__idx_1286"></a><a id="__idx_1288"></a>“concrete” data
 representation is defined independent of the programs that use
 the data.  The interface between these two parts of our system will be
-a set of procedures, called <a name="%_idx_1290" id="%_idx_1290"></a><em>selectors</em> and <a name="%_idx_1292" id="%_idx_1292"></a><em>constructors</em>,
+a set of procedures, called <a id="__idx_1290"></a><em>selectors</em> and <a id="__idx_1292"></a><em>constructors</em>,
 that implement the abstract data in terms of the concrete
 representation.  To illustrate this technique, we will consider how to
 design a set of procedures for manipulating rational numbers.</p><p>
 
-<a name="%_sec_2.1.1" id="%_sec_2.1.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.1.1">2.1.1  Example: Arithmetic Operations for Rational Numbers</a></h3><p>
+<a id="__sec_2.1.1"></a>
+</p><h3>2.1.1  Example: Arithmetic Operations for Rational Numbers</h3><p>
 
 </p><p>
 
-<a name="%_idx_1294" id="%_idx_1294"></a><a name="%_idx_1296" id="%_idx_1296"></a><a name="%_idx_1298" id="%_idx_1298"></a>Suppose we want to do arithmetic with rational numbers.  We want to be
+<a id="__idx_1294"></a><a id="__idx_1296"></a><a id="__idx_1298"></a>Suppose we want to do arithmetic with rational numbers.  We want to be
 able to add, subtract, multiply, and divide them and to test whether
 two rational numbers are equal.</p><p>
 
@@ -57,47 +57,47 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 selecting) its numerator and its denominator.  Let us further assume
 that the constructor and selectors are available as procedures:</p><p>
 
-</p><p></p><ul><a name="%_idx_1300" id="%_idx_1300"></a><li><tt>(make-rat &lt;<em>n</em>&gt; &lt;<em>d</em>&gt;)</tt> returns the
+</p><p></p><ul><a id="__idx_1300"></a><li><tt>(make-rat &lt;<em>n</em>&gt; &lt;<em>d</em>&gt;)</tt> returns the
 rational number whose  numerator is the integer <tt>&lt;<em>n</em>&gt;</tt>
 and whose denominator is the integer <tt>&lt;<em>d</em>&gt;</tt>. <p>
 
-<a name="%_idx_1302" id="%_idx_1302"></a></p></li><li><tt>(numer &lt;<em>x</em>&gt;)</tt> returns the numerator of the rational
+<a id="__idx_1302"></a></p></li><li><tt>(numer &lt;<em>x</em>&gt;)</tt> returns the numerator of the rational
 number <tt>&lt;<em>x</em>&gt;</tt>.<p>
 
-<a name="%_idx_1304" id="%_idx_1304"></a></p></li><li><tt>(denom &lt;<em>x</em>&gt;)</tt> returns the denominator of the
+<a id="__idx_1304"></a></p></li><li><tt>(denom &lt;<em>x</em>&gt;)</tt> returns the denominator of the
 rational number <tt>&lt;<em>x</em>&gt;</tt>.
 </li></ul><p></p><p>
 
-We are using here a powerful strategy of synthesis: <a name="%_idx_1306" id="%_idx_1306"></a><em>wishful thinking</em>.
+We are using here a powerful strategy of synthesis: <a id="__idx_1306"></a><em>wishful thinking</em>.
 We haven't yet said how a rational number is represented, or how the
 procedures <tt>numer</tt>, <tt>denom</tt>, and <tt>make-rat</tt> should be
 implemented.  Even so, if we did have these three procedures, we could
 then add, subtract, multiply, divide, and test equality by using the
 following relations:</p><p>
 
-</p><p></p><div align="left"><img src="images/ch2-Z-G-1.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-1.gif" alt="ch2-Z-G-1" style="border: none;" /></div><p></p><p>
 
-</p><p></p><div align="left"><img src="images/ch2-Z-G-2.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-2.gif" alt="ch2-Z-G-2" style="border: none;" /></div><p></p><p>
 
-</p><p></p><div align="left"><img src="images/ch2-Z-G-3.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-3.gif" alt="ch2-Z-G-3" style="border: none;" /></div><p></p><p>
 
-</p><p></p><div align="left"><img src="images/ch2-Z-G-4.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-4.gif" alt="ch2-Z-G-4" style="border: none;" /></div><p></p><p>
 
-</p><p></p><div align="left"><img src="images/ch2-Z-G-5.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-5.gif" alt="ch2-Z-G-5" style="border: none;" /></div><p></p><p>
 
 We can express these rules as procedures:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1308" id="%_idx_1308"></a>(define (add-rat x y)<br />
+</p><p></p><p><tt><a id="__idx_1308"></a>(define (add-rat x y)<br />
   (make-rat (+ (* (numer x) (denom y))<br />
                (* (numer y) (denom x)))<br />
-            (* (denom x) (denom y))))<br /><a name="%_idx_1310" id="%_idx_1310"></a>(define (sub-rat x y)<br />
+            (* (denom x) (denom y))))<br /><a id="__idx_1310"></a>(define (sub-rat x y)<br />
   (make-rat (- (* (numer x) (denom y))<br />
                (* (numer y) (denom x)))<br />
-            (* (denom x) (denom y))))<br /><a name="%_idx_1312" id="%_idx_1312"></a>(define (mul-rat x y)<br />
+            (* (denom x) (denom y))))<br /><a id="__idx_1312"></a>(define (mul-rat x y)<br />
   (make-rat (* (numer x) (numer y))<br />
-            (* (denom x) (denom y))))<br /><a name="%_idx_1314" id="%_idx_1314"></a>(define (div-rat x y)<br />
+            (* (denom x) (denom y))))<br /><a id="__idx_1314"></a>(define (div-rat x y)<br />
   (make-rat (* (numer x) (denom y))<br />
-            (* (denom x) (numer y))))<br /><a name="%_idx_1316" id="%_idx_1316"></a>(define (equal-rat? x y)<br />
+            (* (denom x) (numer y))))<br /><a id="__idx_1316"></a>(define (equal-rat? x y)<br />
   (= (* (numer x) (denom y))<br />
      (* (numer y) (denom x))))<br /></tt></p><p></p><p></p><p>
 
@@ -109,13 +109,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 denominator to form a rational
 number.</p><p>
 
-<a name="%_sec_Temp_132" id="%_sec_Temp_132"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_132">Pairs</a></h4><p>
+<a id="__sec_Temp_132"></a>
+</p><h4>Pairs</h4><p>
 
 To enable us to implement the concrete level of our data
-abstraction, our language provides a compound structure called a <a name="%_idx_1318" id="%_idx_1318"></a><em>pair</em>, which can be constructed with the primitive procedure <a name="%_idx_1320" id="%_idx_1320"></a><a name="%_idx_1322" id="%_idx_1322"></a><tt>cons</tt>.  This procedure takes two arguments and returns a compound data
+abstraction, our language provides a compound structure called a <a id="__idx_1318"></a><em>pair</em>, which can be constructed with the primitive procedure <a id="__idx_1320"></a><a id="__idx_1322"></a><tt>cons</tt>.  This procedure takes two arguments and returns a compound data
 object that contains the two arguments as parts.  Given a pair, we can
-extract the parts using the primitive procedures <a name="%_idx_1324" id="%_idx_1324"></a><a name="%_idx_1326" id="%_idx_1326"></a><tt>car</tt> and <a name="%_idx_1328" id="%_idx_1328"></a><a name="%_idx_1330" id="%_idx_1330"></a><tt>cdr</tt>.<a name="call_footnote_Temp_133" href="#footnote_Temp_133" id="call_footnote_Temp_133"><sup><small>2</small></sup></a> Thus, we can use <tt>cons</tt>, <tt>car</tt>, and <tt>cdr</tt> as follows:</p><p>
+extract the parts using the primitive procedures <a id="__idx_1324"></a><a id="__idx_1326"></a><tt>car</tt> and <a id="__idx_1328"></a><a id="__idx_1330"></a><tt>cdr</tt>.<a href="#footnote_Temp_133" id="call_footnote_Temp_133"><sup><small>2</small></sup></a> Thus, we can use <tt>cons</tt>, <tt>car</tt>, and <tt>cdr</tt> as follows:</p><p>
 
 
 
@@ -132,27 +132,27 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 (define z (cons x y))<br /><br />
 (car (car z))<br /><i>1</i><br /><br />
 (car (cdr z))<br /><i>3</i><br /></tt></p><p></p><p>
-In section <a href="book-Z-H-15.html#%_sec_2.2">2.2</a> we will see how this ability to
+In section <a href="book-Z-H-15.html#__sec_2.2">2.2</a> we will see how this ability to
 combine pairs means that pairs can be used as general-purpose building
 blocks to create all sorts of complex data structures.  The single
 compound-data primitive <em>pair</em>, implemented by the procedures <tt>cons</tt>, <tt>car</tt>, and <tt>cdr</tt>, is the only glue we need.  Data
-objects constructed from pairs are called <a name="%_idx_1342" id="%_idx_1342"></a><a name="%_idx_1344" id="%_idx_1344"></a><em>list-structured</em> data.</p><p>
+objects constructed from pairs are called <a id="__idx_1342"></a><a id="__idx_1344"></a><em>list-structured</em> data.</p><p>
 
-<a name="%_sec_Temp_134" id="%_sec_Temp_134"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_134">Representing rational numbers</a></h4><p>
+<a id="__sec_Temp_134"></a>
+</p><h4>Representing rational numbers</h4><p>
 
-<a name="%_idx_1346" id="%_idx_1346"></a>Pairs offer a natural way to complete the rational-number system.
+<a id="__idx_1346"></a>Pairs offer a natural way to complete the rational-number system.
 Simply represent a rational number as a pair of two integers: a
 numerator and a denominator.  Then <tt>make-rat</tt>, <tt>numer</tt>, and
-<tt>denom</tt> are readily implemented as follows:<a name="call_footnote_Temp_135" href="#footnote_Temp_135" id="call_footnote_Temp_135"><sup><small>3</small></sup></a></p><p>
+<tt>denom</tt> are readily implemented as follows:<a href="#footnote_Temp_135" id="call_footnote_Temp_135"><sup><small>3</small></sup></a></p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_1348" id="%_idx_1348"></a>(define (make-rat n d) (cons n d))<br /><br /><a name="%_idx_1350" id="%_idx_1350"></a>(define (numer x) (car x))<br /><br /><a name="%_idx_1352" id="%_idx_1352"></a>(define (denom x) (cdr x))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_1348"></a>(define (make-rat n d) (cons n d))<br /><br /><a id="__idx_1350"></a>(define (numer x) (car x))<br /><br /><a id="__idx_1352"></a>(define (denom x) (cdr x))<br /></tt></p><p></p><p>
 Also, in order to display the results of our computations,
-we can <a name="%_idx_1354" id="%_idx_1354"></a>print rational numbers by printing the numerator, a
-slash, and the denominator:<a name="call_footnote_Temp_136" href="#footnote_Temp_136" id="call_footnote_Temp_136"><sup><small>4</small></sup></a></p><p>
+we can <a id="__idx_1354"></a>print rational numbers by printing the numerator, a
+slash, and the denominator:<a href="#footnote_Temp_136" id="call_footnote_Temp_136"><sup><small>4</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_1370" id="%_idx_1370"></a>(define (print-rat x)<br />
+</p><p></p><p><tt><a id="__idx_1370"></a>(define (print-rat x)<br />
   (newline)<br />
   (display (numer x))<br />
   (display "/")<br />
@@ -166,14 +166,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 (print-rat (mul-rat one-half one-third))<br /><i>1/6</i><br /><br />
 (print-rat (add-rat one-third one-third))<br /><i>6/9</i><br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_1372" id="%_idx_1372"></a><a name="%_idx_1374" id="%_idx_1374"></a>As the final example shows, our rational-number implementation does
+<a id="__idx_1372"></a><a id="__idx_1374"></a>As the final example shows, our rational-number implementation does
 not reduce rational numbers to lowest terms.  We can remedy this by
-changing <tt>make-rat</tt>. If we have a <a name="%_idx_1376" id="%_idx_1376"></a><tt>gcd</tt> procedure like the one
-in section <a href="book-Z-H-11.html#%_sec_1.2.5">1.2.5</a> that produces the greatest common divisor of two
+changing <tt>make-rat</tt>. If we have a <a id="__idx_1376"></a><tt>gcd</tt> procedure like the one
+in section <a href="book-Z-H-11.html#__sec_1.2.5">1.2.5</a> that produces the greatest common divisor of two
 integers, we can use <tt>gcd</tt> to reduce the numerator and the
 denominator to lowest terms before constructing the pair:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1378" id="%_idx_1378"></a>(define (make-rat n d)<br />
+</p><p></p><p><tt><a id="__idx_1378"></a>(define (make-rat n d)<br />
   (let ((g (gcd n d)))<br />
     (cons (/ n g) (/ d g))))<br /></tt></p><p></p><p>
 Now we have</p><p>
@@ -184,7 +184,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 (such as <tt>add-rat</tt> and <tt>mul-rat</tt>)
 that implement the actual operations.</p><p>
 
-</p><p><a name="%_thm_2.1" id="%_thm_2.1"></a>
+</p><p><a id="__thm_2.1"></a>
 <b>Exercise 2.1.</b>  Define a better version of <tt>make-rat</tt> that
 handles both positive and negative arguments.  <tt>Make-rat</tt> should
 normalize the sign so that if the rational number is positive, both
@@ -192,12 +192,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 is negative, only the numerator is negative.
 </p><p>
 
-<a name="%_sec_2.1.2" id="%_sec_2.1.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.1.2">2.1.2  Abstraction Barriers</a></h3><p>
+<a id="__sec_2.1.2"></a>
+</p><h3>2.1.2  Abstraction Barriers</h3><p>
 
 </p><p>
 
-<a name="%_idx_1380" id="%_idx_1380"></a>Before continuing with more examples of compound data and data
+<a id="__idx_1380"></a>Before continuing with more examples of compound data and data
 abstraction, let us consider some of the issues raised by the
 rational-number example.  We defined the rational-number operations in
 terms of a constructor <tt>make-rat</tt> and selectors <tt>numer</tt> and
@@ -208,23 +208,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 data.</p><p>
 
 We can envision the structure of the rational-number system as
-shown in figure <a href="#%_fig_2.1">2.1</a>.  The
+shown in figure <a href="#__fig_2.1">2.1</a>.  The
 horizontal lines represent <em>abstraction barriers</em> that isolate
 different “levels” of the system.  At each level, the barrier
 separates the programs (above) that use the data abstraction from the
 programs (below) that implement the data abstraction.  Programs that
 use rational numbers manipulate them solely in terms of the procedures
 supplied “for public use” by the rational-number package: <tt>add-rat</tt>, <tt>sub-rat</tt>, <tt>mul-rat</tt>, <tt>div-rat</tt>, and <tt>equal-rat?</tt>. These, in turn, are implemented solely in terms of the
-<a name="%_idx_1382" id="%_idx_1382"></a><a name="%_idx_1384" id="%_idx_1384"></a>constructor and selectors <tt>make-rat</tt>, <tt>numer</tt>, and <tt>denom</tt>, which themselves are implemented in terms of pairs.  The
+<a id="__idx_1382"></a><a id="__idx_1384"></a>constructor and selectors <tt>make-rat</tt>, <tt>numer</tt>, and <tt>denom</tt>, which themselves are implemented in terms of pairs.  The
 details of how pairs are implemented are irrelevant to the rest of the
 rational-number package so long as pairs can be manipulated by the use
 of <tt>cons</tt>, <tt>car</tt>, and <tt>cdr</tt>.  In effect, procedures at
 each level are the interfaces that define the abstraction barriers and
 connect the different levels.</p><p>
 
-<a name="%_fig_2.1" id="%_fig_2.1"></a></p><p></p><div align="left"><table width="100%"><tr><td><div align="left"><img src="images/ch2-Z-G-6.gif" border="0" /> </div>
+<a id="__fig_2.1"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><div style="text-align: left;"><img src="images/ch2-Z-G-6.gif" alt="ch2-Z-G-6" style="border: none;" /> </div>
 
-</td></tr><caption align="bottom"><div align="left"><b>Figure 2.1:</b>  Data-abstraction barriers in the rational-number package.</div></caption><tr><td>
+</td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.1:</b>  Data-abstraction barriers in the rational-number package.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
@@ -239,15 +239,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 the dependence on the representation were to be confined by design to
 a very few program modules.</p><p>
 
-<a name="%_idx_1386" id="%_idx_1386"></a><a name="%_idx_1388" id="%_idx_1388"></a>For example, an alternate way to address the problem of reducing rational
+<a id="__idx_1386"></a><a id="__idx_1388"></a>For example, an alternate way to address the problem of reducing rational
 numbers to lowest terms is to perform the reduction whenever we
 access the parts of a rational number, rather than when we construct
 it.  This leads to different constructor and selector procedures:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1390" id="%_idx_1390"></a>(define (make-rat n d)<br />
-  (cons n d))<br /><a name="%_idx_1392" id="%_idx_1392"></a>(define (numer x)<br />
+</p><p></p><p><tt><a id="__idx_1390"></a>(define (make-rat n d)<br />
+  (cons n d))<br /><a id="__idx_1392"></a>(define (numer x)<br />
   (let ((g (gcd (car x) (cdr x))))<br />
-    (/ (car x) g)))<br /><a name="%_idx_1394" id="%_idx_1394"></a>(define (denom x)<br />
+    (/ (car x) g)))<br /><a id="__idx_1394"></a>(define (denom x)<br />
   (let ((g (gcd (car x) (cdr x))))<br />
     (/ (cdr x) g)))<br /></tt></p><p></p><p>
 The difference between this implementation and the previous one lies
@@ -271,23 +271,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 decision without losing the ability to make progress on the rest of
 the system.</p><p>
 
-</p><p><a name="%_thm_2.2" id="%_thm_2.2"></a>
+</p><p><a id="__thm_2.2"></a>
 <b>Exercise 2.2.</b>  Consider the problem of representing
-<a name="%_idx_1396" id="%_idx_1396"></a>line segments in a plane.  Each segment is
+<a id="__idx_1396"></a>line segments in a plane.  Each segment is
 represented as a pair of points: a starting point and an ending point.
-Define a constructor <a name="%_idx_1398" id="%_idx_1398"></a><tt>make-segment</tt> and selectors <a name="%_idx_1400" id="%_idx_1400"></a><tt>start-segment</tt>
-and <a name="%_idx_1402" id="%_idx_1402"></a><tt>end-segment</tt> that define the representation of segments in
-terms of points.  Furthermore, a point <a name="%_idx_1404" id="%_idx_1404"></a>can be represented as a pair
+Define a constructor <a id="__idx_1398"></a><tt>make-segment</tt> and selectors <a id="__idx_1400"></a><tt>start-segment</tt>
+and <a id="__idx_1402"></a><tt>end-segment</tt> that define the representation of segments in
+terms of points.  Furthermore, a point <a id="__idx_1404"></a>can be represented as a pair
 of numbers: the <em>x</em> coordinate and the <em>y</em> coordinate.  Accordingly,
-specify a constructor <a name="%_idx_1406" id="%_idx_1406"></a><tt>make-point</tt> and selectors <tt>x-point</tt> and
+specify a constructor <a id="__idx_1406"></a><tt>make-point</tt> and selectors <tt>x-point</tt> and
 <tt>y-point</tt> that define this representation.  Finally, using your
-selectors and constructors, define a procedure <a name="%_idx_1408" id="%_idx_1408"></a><tt>midpoint-segment</tt>
+selectors and constructors, define a procedure <a id="__idx_1408"></a><tt>midpoint-segment</tt>
 that takes a line segment as argument and returns its midpoint (the
 point whose coordinates are the average of the coordinates of the
 endpoints).
 To try your procedures, you'll need a way to print points:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1410" id="%_idx_1410"></a>(define (print-point p)<br />
+</p><p></p><p><tt><a id="__idx_1410"></a>(define (print-point p)<br />
   (newline)<br />
   (display "(")<br />
   (display (x-point p))<br />
@@ -296,9 +296,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
   (display ")"))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.3" id="%_thm_2.3"></a>
-<b>Exercise 2.3.</b>  <a name="%_idx_1412" id="%_idx_1412"></a>Implement a representation for rectangles in a plane.
-(Hint: You may want to make use of exercise <a href="#%_thm_2.2">2.2</a>.)
+</p><p><a id="__thm_2.3"></a>
+<b>Exercise 2.3.</b>  <a id="__idx_1412"></a>Implement a representation for rectangles in a plane.
+(Hint: You may want to make use of exercise <a href="#__thm_2.2">2.2</a>.)
 In terms of
 your constructors and selectors, create procedures that compute the
 perimeter and the area of a given rectangle.  Now implement a
@@ -309,13 +309,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 </p><p>
 </p><p>
 
-<a name="%_sec_2.1.3" id="%_sec_2.1.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.1.3">2.1.3  What Is Meant by Data?</a></h3><p>
+<a id="__sec_2.1.3"></a>
+</p><h3>2.1.3  What Is Meant by Data?</h3><p>
 
 
-<a name="%_idx_1414" id="%_idx_1414"></a>
+<a id="__idx_1414"></a>
 We began the rational-number implementation in
-section <a href="#%_sec_2.1.1">2.1.1</a> by implementing the rational-number
+section <a href="#__sec_2.1.1">2.1.1</a> by implementing the rational-number
 operations <tt>add-rat</tt>, <tt>sub-rat</tt>, and so on in terms of three
 unspecified procedures: <tt>make-rat</tt>, <tt>numer</tt>, and <tt>denom</tt>.
 At that point, we could think of the operations as being defined in
@@ -326,7 +326,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 “whatever is implemented by the given selectors and constructors.”
 Clearly, not every arbitrary set of three procedures can serve as an
 appropriate basis for the rational-number implementation.  We need to
-guarantee that, <a name="%_idx_1416" id="%_idx_1416"></a><a name="%_idx_1418" id="%_idx_1418"></a><a name="%_idx_1420" id="%_idx_1420"></a>if we construct a rational number <tt>x</tt> from a pair
+guarantee that, <a id="__idx_1416"></a><a id="__idx_1418"></a><a id="__idx_1420"></a>if we construct a rational number <tt>x</tt> from a pair
 of integers <tt>n</tt> and <tt>d</tt>, then extracting the <tt>numer</tt> and the
 <tt>denom</tt> of <tt>x</tt> and dividing them should yield the same result
 as dividing <tt>n</tt> by <tt>d</tt>.  In other words, <tt>make-rat</tt>,
@@ -334,23 +334,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 integer <tt>n</tt> and any non-zero integer <tt>d</tt>, if <tt>x</tt> is
 (<tt>make-rat n d</tt>), then</p><p>
 
-</p><p></p><div align="left"><img src="images/ch2-Z-G-7.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-7.gif" alt="ch2-Z-G-7" style="border: none;" /></div><p></p><p>
 
 In fact, this is the only condition <tt>make-rat</tt>, <tt>numer</tt>, and
 <tt>denom</tt> must fulfill in order to form a suitable basis for a
 rational-number representation.  In general, we can think of data as
 defined by some collection of selectors and constructors, together
 with specified conditions that these procedures must fulfill in order
-to be a valid representation.<a name="call_footnote_Temp_140" href="#footnote_Temp_140" id="call_footnote_Temp_140"><sup><small>5</small></sup></a></p><p>
+to be a valid representation.<a href="#footnote_Temp_140" id="call_footnote_Temp_140"><sup><small>5</small></sup></a></p><p>
 
 
-<a name="%_idx_1446" id="%_idx_1446"></a><a name="%_idx_1448" id="%_idx_1448"></a>This point of view can serve to define not only “high-level” data
+<a id="__idx_1446"></a><a id="__idx_1448"></a>This point of view can serve to define not only “high-level” data
 objects, such as rational numbers, but lower-level objects as well.
-<a name="%_idx_1450" id="%_idx_1450"></a>Consider the notion of a pair, which we used in order to define our
+<a id="__idx_1450"></a>Consider the notion of a pair, which we used in order to define our
 rational numbers.  We never actually said what a pair was, only that
 the language supplied procedures <tt>cons</tt>, <tt>car</tt>, and <tt>cdr</tt>
 for operating on pairs.  But the only thing we need to know about
-these three operations <a name="%_idx_1452" id="%_idx_1452"></a><a name="%_idx_1454" id="%_idx_1454"></a><a name="%_idx_1456" id="%_idx_1456"></a><a name="%_idx_1458" id="%_idx_1458"></a>is that if we glue two objects together using
+these three operations <a id="__idx_1452"></a><a id="__idx_1454"></a><a id="__idx_1456"></a><a id="__idx_1458"></a>is that if we glue two objects together using
 <tt>cons</tt> we can retrieve the objects using <tt>car</tt> and <tt>cdr</tt>.
 That is, the operations satisfy the condition that, for any objects
 <tt>x</tt> and <tt>y</tt>, if <tt>z</tt> is <tt>(cons x y)</tt> then <tt>(car z)</tt>
@@ -362,12 +362,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 <tt>car</tt>, and <tt>cdr</tt> without using any data structures at all but
 only using procedures.  Here are the definitions:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1460" id="%_idx_1460"></a>(define (cons x y)<br />
+</p><p></p><p><tt><a id="__idx_1460"></a>(define (cons x y)<br />
   (define (dispatch m)<br />
     (cond ((= m 0) x)<br />
           ((= m 1) y)<br />
           (else (error "Argument not 0 or 1 -- CONS" m))))<br />
-  dispatch)<br /><br /><a name="%_idx_1462" id="%_idx_1462"></a>(define (car z) (z 0))<br /><br /><a name="%_idx_1464" id="%_idx_1464"></a>(define (cdr z) (z 1))<br /></tt></p><p></p><p>
+  dispatch)<br /><br /><a id="__idx_1462"></a>(define (car z) (z 0))<br /><br /><a id="__idx_1464"></a>(define (cdr z) (z 1))<br /></tt></p><p></p><p>
 This use of procedures corresponds to nothing like our intuitive
 notion of what data should be.  Nevertheless, all we need to do to
 show that this is a valid way to represent pairs is to verify that
@@ -393,32 +393,32 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 provides the ability to represent compound data.  This may seem a
 curiosity now, but procedural representations of data will play a
 central role in our programming repertoire.  This style of programming
-is often called <a name="%_idx_1466" id="%_idx_1466"></a><em>message passing</em>, and we will be using it as a
+is often called <a id="__idx_1466"></a><em>message passing</em>, and we will be using it as a
 basic tool in chapter 3 when we address the issues of modeling and
 simulation.</p><p>
 
-</p><p><a name="%_thm_2.4" id="%_thm_2.4"></a>
+</p><p><a id="__thm_2.4"></a>
 <b>Exercise 2.4.</b>  Here is an alternative procedural representation of pairs.  For this
 representation, verify that <tt>(car (cons x y))</tt> yields <tt>x</tt> for
 any objects <tt>x</tt> and <tt>y</tt>.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1468" id="%_idx_1468"></a>(define (cons x y)<br />
-  (lambda (m) (m x y)))<br /><br /><a name="%_idx_1470" id="%_idx_1470"></a>(define (car z)<br />
+</p><p></p><p><tt><a id="__idx_1468"></a>(define (cons x y)<br />
+  (lambda (m) (m x y)))<br /><br /><a id="__idx_1470"></a>(define (car z)<br />
   (z (lambda (p q) p)))<br /></tt></p><p></p><p>
-<a name="%_idx_1472" id="%_idx_1472"></a>What is the corresponding definition of <tt>cdr</tt>? (Hint: To verify
+<a id="__idx_1472"></a>What is the corresponding definition of <tt>cdr</tt>? (Hint: To verify
 that this works, make use of the substitution model of
-section <a href="book-Z-H-10.html#%_sec_1.1.5">1.1.5</a>.)
+section <a href="book-Z-H-10.html#__sec_1.1.5">1.1.5</a>.)
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.5" id="%_thm_2.5"></a>
+</p><p><a id="__thm_2.5"></a>
 <b>Exercise 2.5.</b>  Show that we can represent pairs of nonnegative integers using only
 numbers and arithmetic operations if we represent the pair <em>a</em> and <em>b</em>
 as the integer that is the product 2<sup><em>a</em></sup> 3<sup><em>b</em></sup>.  Give the corresponding
 definitions of the procedures <tt>cons</tt>, <tt>car</tt>, and <tt>cdr</tt>.
 </p><p>
 
-</p><p><a name="%_thm_2.6" id="%_thm_2.6"></a>
+</p><p><a id="__thm_2.6"></a>
 <b>Exercise 2.6.</b>  In case representing pairs as procedures wasn't mind-boggling enough,
 consider that, in a language that can manipulate procedures, we can
 get by without numbers (at least insofar as nonnegative integers are
@@ -427,8 +427,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 </p><p></p><p><tt>(define zero (lambda (f) (lambda (x) x)))<br /><br />
 (define (add-1 n)<br />
   (lambda (f) (lambda (x) (f ((n f) x)))))<br /></tt></p><p></p><p>
-This representation is known as <a name="%_idx_1474" id="%_idx_1474"></a><em>Church numerals</em>, after its
-inventor, <a name="%_idx_1476" id="%_idx_1476"></a>Alonzo Church, the logician who invented the λ
+This representation is known as <a id="__idx_1474"></a><em>Church numerals</em>, after its
+inventor, <a id="__idx_1476"></a>Alonzo Church, the logician who invented the λ
 calculus.</p><p>
 
 Define <tt>one</tt> and <tt>two</tt> directly (not in terms of <tt>zero</tt>
@@ -437,10 +437,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 terms of repeated application of <tt>add-1</tt>).
 </p><p>
 
-<a name="%_sec_2.1.4" id="%_sec_2.1.4"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.1.4">2.1.4  Extended Exercise: Interval Arithmetic</a></h3><p>
+<a id="__sec_2.1.4"></a>
+</p><h3>2.1.4  Extended Exercise: Interval Arithmetic</h3><p>
 
-<a name="%_idx_1478" id="%_idx_1478"></a><a name="%_idx_1480" id="%_idx_1480"></a>
+<a id="__idx_1478"></a><a id="__idx_1480"></a>
 Alyssa P. Hacker is designing a system to help people solve
 engineering problems.  One feature she wants to provide in her system
 is the ability to manipulate inexact quantities (such as measured
@@ -452,10 +452,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 electrical quantities.  It is sometimes necessary for them to compute
 the value of a parallel equivalent resistance <em>R</em><sub><em>p</em></sub> of two
 resistors <em>R</em><sub>1</sub> and <em>R</em><sub>2</sub> using the formula
-<a name="%_idx_1482" id="%_idx_1482"></a>
-</p><p></p><div align="left"><img src="images/ch2-Z-G-8.gif" border="0" /></div><p></p><p>
+<a id="__idx_1482"></a>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-8.gif" alt="ch2-Z-G-8" style="border: none;" /></div><p></p><p>
 
-Resistance values are usually known only up to some <a name="%_idx_1484" id="%_idx_1484"></a>tolerance
+Resistance values are usually known only up to some <a id="__idx_1484"></a>tolerance
 guaranteed by the manufacturer of the resistor.  For example, if you
 buy a resistor labeled “6.8 ohms with 10% tolerance” you can only
 be sure that the resistor has a resistance between 6.8 - 0.68 = 6.12 and
@@ -475,22 +475,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 Alyssa postulates the existence of an abstract object called an
 “interval” that has two endpoints: a lower bound and an upper bound.
 She also presumes that, given the endpoints of an interval, she can
-construct the interval using the data constructor <a name="%_idx_1486" id="%_idx_1486"></a><tt>make-interval</tt>.
+construct the interval using the data constructor <a id="__idx_1486"></a><tt>make-interval</tt>.
 Alyssa first writes a procedure for adding two intervals.  She
 reasons that the minimum value the sum could be is the sum of the two
 lower bounds and the maximum value it could be is the sum of the two
 upper bounds:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1488" id="%_idx_1488"></a>(define (add-interval x y)<br />
+</p><p></p><p><tt><a id="__idx_1488"></a>(define (add-interval x y)<br />
   (make-interval (+ (lower-bound x) (lower-bound y))<br />
                  (+ (upper-bound x) (upper-bound y))))<br /></tt></p><p></p><p>
 Alyssa also works out the product of two intervals by finding the
 minimum and the maximum of the products of the bounds and using them
 as the bounds of the resulting interval.  (<tt>Min</tt> and <tt>max</tt> are
-<a name="%_idx_1490" id="%_idx_1490"></a><a name="%_idx_1492" id="%_idx_1492"></a><a name="%_idx_1494" id="%_idx_1494"></a><a name="%_idx_1496" id="%_idx_1496"></a>primitives that find the minimum or maximum of any number of
+<a id="__idx_1490"></a><a id="__idx_1492"></a><a id="__idx_1494"></a><a id="__idx_1496"></a>primitives that find the minimum or maximum of any number of
 arguments.)</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1498" id="%_idx_1498"></a>(define (mul-interval x y)<br />
+</p><p></p><p><tt><a id="__idx_1498"></a>(define (mul-interval x y)<br />
   (let ((p1 (* (lower-bound x) (lower-bound y)))<br />
         (p2 (* (lower-bound x) (upper-bound y)))<br />
         (p3 (* (upper-bound x) (lower-bound y)))<br />
@@ -502,29 +502,29 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 the reciprocal of the upper bound and the reciprocal of the lower bound, in
 that order.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1500" id="%_idx_1500"></a>(define (div-interval x y)<br />
+</p><p></p><p><tt><a id="__idx_1500"></a>(define (div-interval x y)<br />
   (mul-interval x <br />
                 (make-interval (/ 1.0 (upper-bound y))<br />
                                (/ 1.0 (lower-bound y)))))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_2.7" id="%_thm_2.7"></a>
+</p><p><a id="__thm_2.7"></a>
 <b>Exercise 2.7.</b>  Alyssa's program is incomplete because she has not specified the
 implementation of the interval abstraction.  Here is a definition of
 the interval constructor:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1502" id="%_idx_1502"></a>(define (make-interval a b) (cons a b))<br /></tt></p><p></p><p>
-Define selectors <a name="%_idx_1504" id="%_idx_1504"></a><tt>upper-bound</tt> and <a name="%_idx_1506" id="%_idx_1506"></a><tt>lower-bound</tt> to complete
+</p><p></p><p><tt><a id="__idx_1502"></a>(define (make-interval a b) (cons a b))<br /></tt></p><p></p><p>
+Define selectors <a id="__idx_1504"></a><tt>upper-bound</tt> and <a id="__idx_1506"></a><tt>lower-bound</tt> to complete
 the implementation.
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.8" id="%_thm_2.8"></a>
+</p><p><a id="__thm_2.8"></a>
 <b>Exercise 2.8.</b>  Using reasoning analogous to Alyssa's, describe how the difference
 of two intervals may be computed.  Define a corresponding subtraction
-procedure, called <a name="%_idx_1508" id="%_idx_1508"></a><tt>sub-interval</tt>.
+procedure, called <a id="__idx_1508"></a><tt>sub-interval</tt>.
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.9" id="%_thm_2.9"></a>
-<b>Exercise 2.9.</b>  <a name="%_idx_1510" id="%_idx_1510"></a>The <em>width</em> of an interval is half of the difference between its
+</p><p><a id="__thm_2.9"></a>
+<b>Exercise 2.9.</b>  <a id="__idx_1510"></a>The <em>width</em> of an interval is half of the difference between its
 upper and lower bounds.  The width is a measure of the uncertainty of
 the number specified by the interval.  For some arithmetic operations
 the width of the result of combining two intervals is a function only
@@ -536,15 +536,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 for multiplication or division.
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.10" id="%_thm_2.10"></a>
-<b>Exercise 2.10.</b>  <a name="%_idx_1512" id="%_idx_1512"></a>Ben Bitdiddle, an expert systems programmer, looks over Alyssa's
+</p><p><a id="__thm_2.10"></a>
+<b>Exercise 2.10.</b>  <a id="__idx_1512"></a>Ben Bitdiddle, an expert systems programmer, looks over Alyssa's
 shoulder and comments that it is not clear what it means to
 divide by an interval that spans zero.  Modify Alyssa's code to
 check for this condition and to signal an error if it occurs.
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.11" id="%_thm_2.11"></a>
-<b>Exercise 2.11.</b>  <a name="%_idx_1514" id="%_idx_1514"></a>In passing, Ben also cryptically comments: “By testing the signs of
+</p><p><a id="__thm_2.11"></a>
+<b>Exercise 2.11.</b>  <a id="__idx_1514"></a>In passing, Ben also cryptically comments: “By testing the signs of
 the endpoints of the intervals, it is possible to break <tt>mul-interval</tt> into nine cases, only one of which requires more than
 two multiplications.”  Rewrite this procedure using Ben's
 suggestion.
@@ -559,9 +559,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 returns to her desk and fixes this problem by supplying an alternate
 constructor and alternate selectors:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1516" id="%_idx_1516"></a>(define (make-center-width c w)<br />
-  (make-interval (- c w) (+ c w)))<br /><a name="%_idx_1518" id="%_idx_1518"></a>(define (center i)<br />
-  (/ (+ (lower-bound i) (upper-bound i)) 2))<br /><a name="%_idx_1520" id="%_idx_1520"></a>(define (width i)<br />
+</p><p></p><p><tt><a id="__idx_1516"></a>(define (make-center-width c w)<br />
+  (make-interval (- c w) (+ c w)))<br /><a id="__idx_1518"></a>(define (center i)<br />
+  (/ (+ (lower-bound i) (upper-bound i)) 2))<br /><a id="__idx_1520"></a>(define (width i)<br />
   (/ (- (upper-bound i) (lower-bound i)) 2))<br /></tt></p><p></p><p></p><p>
 
 Unfortunately, most of Alyssa's users are engineers.  Real engineering
@@ -571,8 +571,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 parameters of devices, as in the resistor specifications given
 earlier.</p><p>
 
-</p><p><a name="%_thm_2.12" id="%_thm_2.12"></a>
-<b>Exercise 2.12.</b>  Define a constructor <a name="%_idx_1522" id="%_idx_1522"></a><tt>make-center-percent</tt> that takes a center and
+</p><p><a id="__thm_2.12"></a>
+<b>Exercise 2.12.</b>  Define a constructor <a id="__idx_1522"></a><tt>make-center-percent</tt> that takes a center and
 a percentage tolerance and produces the desired interval.  You must
 also define a selector <tt>percent</tt> that produces the
 percentage tolerance for a given interval.  The <tt>center</tt> selector
@@ -580,7 +580,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.13" id="%_thm_2.13"></a>
+</p><p><a id="__thm_2.13"></a>
 <b>Exercise 2.13.</b>  Show that under the assumption of small percentage tolerances there is
 a simple formula for the approximate percentage tolerance of the
 product of two intervals in terms of the tolerances of the factors.
@@ -593,13 +593,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 gets a frenzied call from an irate user,  Lem E. Tweakit.
 It seems that Lem has
 noticed that the formula for parallel resistors can be written in two
-<a name="%_idx_1524" id="%_idx_1524"></a>algebraically equivalent ways:</p><p>
+<a id="__idx_1524"></a>algebraically equivalent ways:</p><p>
 
-</p><p></p><div align="left"><img src="images/ch2-Z-G-9.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-9.gif" alt="ch2-Z-G-9" style="border: none;" /></div><p></p><p>
 
 and</p><p>
 
-</p><p></p><div align="left"><img src="images/ch2-Z-G-10.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-10.gif" alt="ch2-Z-G-10" style="border: none;" /></div><p></p><p>
 
 He has written the following two programs, each of which computes the
 parallel-resistors formula differently:</p><p>
@@ -615,16 +615,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 Lem complains that Alyssa's program gives different answers for
 the two ways of computing. This is a serious complaint.</p><p>
 
-</p><p><a name="%_thm_2.14" id="%_thm_2.14"></a>
+</p><p><a id="__thm_2.14"></a>
 <b>Exercise 2.14.</b>  Demonstrate that Lem is right. Investigate the behavior of the
 system on a variety of arithmetic expressions. Make some intervals <em>A</em> and <em>B</em>,
 and use them in computing the expressions <em>A</em>/<em>A</em> and <em>A</em>/<em>B</em>.  You will
 get the most insight by using intervals whose width is a small
 percentage of the center value. Examine the results of the computation
-in center-percent form (see exercise <a href="#%_thm_2.12">2.12</a>).
+in center-percent form (see exercise <a href="#__thm_2.12">2.12</a>).
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.15" id="%_thm_2.15"></a>
+</p><p><a id="__thm_2.15"></a>
 <b>Exercise 2.15.</b>  Eva Lu Ator, another user, has also noticed the different intervals
 computed by different but algebraically equivalent expressions. She
 says that a formula to compute with intervals using Alyssa's system
@@ -634,7 +634,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 resistances than <tt>par1</tt>.  Is she right?  Why?
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.16" id="%_thm_2.16"></a>
+</p><p><a id="__thm_2.16"></a>
 <b>Exercise 2.16.</b>  Explain, in general, why equivalent algebraic expressions may lead to
 different answers.  Can you devise an interval-arithmetic package that
 does not have this shortcoming, or is this task impossible?  (Warning:
@@ -643,15 +643,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 </p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_133" href="#call_footnote_Temp_133" id="footnote_Temp_133"><sup><small>2</small></sup></a> The name <a name="%_idx_1332" id="%_idx_1332"></a><tt>cons</tt> stands for “construct.”  The
-names <a name="%_idx_1334" id="%_idx_1334"></a><tt>car</tt> and <a name="%_idx_1336" id="%_idx_1336"></a><tt>cdr</tt> derive from the original implementation of
-Lisp on the <a name="%_idx_1338" id="%_idx_1338"></a><a name="%_idx_1340" id="%_idx_1340"></a>IBM 704.  That machine had an addressing scheme that
+</p><div class="footnote"><p><a href="#call_footnote_Temp_133" id="footnote_Temp_133"><sup><small>2</small></sup></a> The name <a id="__idx_1332"></a><tt>cons</tt> stands for “construct.”  The
+names <a id="__idx_1334"></a><tt>car</tt> and <a id="__idx_1336"></a><tt>cdr</tt> derive from the original implementation of
+Lisp on the <a id="__idx_1338"></a><a id="__idx_1340"></a>IBM 704.  That machine had an addressing scheme that
 allowed one to reference the “address” and “decrement” parts of a
 memory location.  <tt>Car</tt> stands for “Contents of Address part of
 Register” and <tt>cdr</tt> (pronounced “could-er”) stands for
 “Contents of Decrement part of Register.”
 
-</p><p><a name="footnote_Temp_135" href="#call_footnote_Temp_135" id="footnote_Temp_135"><sup><small>3</small></sup></a> Another way to define the selectors and constructor is
+</p><p><a href="#call_footnote_Temp_135" id="footnote_Temp_135"><sup><small>3</small></sup></a> Another way to define the selectors and constructor is
 </p><p></p><p><tt>(define make-rat cons)<br />
 (define numer car)<br />
 (define denom cdr)<br /></tt></p><p></p><p>
@@ -670,17 +670,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 
 We have chosen not to use this style of definition in this book.
 
-</p><p><a name="footnote_Temp_136" href="#call_footnote_Temp_136" id="footnote_Temp_136"><sup><small>4</small></sup></a> <a name="%_idx_1356" id="%_idx_1356"></a><a name="%_idx_1358" id="%_idx_1358"></a><a name="%_idx_1360" id="%_idx_1360"></a><a name="%_idx_1362" id="%_idx_1362"></a><a name="%_idx_1364" id="%_idx_1364"></a><tt>Display</tt> is
+</p><p><a href="#call_footnote_Temp_136" id="footnote_Temp_136"><sup><small>4</small></sup></a> <a id="__idx_1356"></a><a id="__idx_1358"></a><a id="__idx_1360"></a><a id="__idx_1362"></a><a id="__idx_1364"></a><tt>Display</tt> is
 the Scheme primitive for printing data.  The Scheme primitive
 <tt>newline</tt> starts a new line for printing.
-<a name="%_idx_1366" id="%_idx_1366"></a><a name="%_idx_1368" id="%_idx_1368"></a>Neither of these procedures returns a useful value, so in the uses of
+<a id="__idx_1366"></a><a id="__idx_1368"></a>Neither of these procedures returns a useful value, so in the uses of
 <tt>print-rat</tt> below, we show only what <tt>print-rat</tt> prints,
 not what the interpreter prints as the value returned by <tt>print-rat</tt>.
 
-</p><p><a name="footnote_Temp_140" href="#call_footnote_Temp_140" id="footnote_Temp_140"><sup><small>5</small></sup></a> Surprisingly, this idea is very
+</p><p><a href="#call_footnote_Temp_140" id="footnote_Temp_140"><sup><small>5</small></sup></a> Surprisingly, this idea is very
 difficult to formulate rigorously. There are two approaches to giving
-such a formulation.  One, pioneered by <a name="%_idx_1422" id="%_idx_1422"></a>C. A. R. Hoare (1972), is known
-as the method of <a name="%_idx_1424" id="%_idx_1424"></a><a name="%_idx_1426" id="%_idx_1426"></a><em>abstract models</em>.  It formalizes the
+such a formulation.  One, pioneered by <a id="__idx_1422"></a>C. A. R. Hoare (1972), is known
+as the method of <a id="__idx_1424"></a><a id="__idx_1426"></a><em>abstract models</em>.  It formalizes the
 “procedures plus conditions” specification as outlined in the
 rational-number example above.  Note that the condition on the
 rational-number representation was stated in terms of facts about
@@ -688,13 +688,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.1">2.1  Introduction to Data Abstra
 new kinds of data objects in terms of previously defined types of data
 objects.  Assertions about data objects can therefore be checked by
 reducing them to assertions about previously defined data objects.
-Another approach, introduced by <a name="%_idx_1428" id="%_idx_1428"></a>Zilles at MIT, by <a name="%_idx_1430" id="%_idx_1430"></a>Goguen, <a name="%_idx_1432" id="%_idx_1432"></a>Thatcher,
-<a name="%_idx_1434" id="%_idx_1434"></a>Wagner, and <a name="%_idx_1436" id="%_idx_1436"></a>Wright at IBM (see Thatcher, Wagner, and Wright 1978), and by <a name="%_idx_1438" id="%_idx_1438"></a>Guttag at Toronto (see Guttag 1977),
-is called <a name="%_idx_1440" id="%_idx_1440"></a><a name="%_idx_1442" id="%_idx_1442"></a><em>algebraic specification</em>.  It regards the “procedures”
+Another approach, introduced by <a id="__idx_1428"></a>Zilles at MIT, by <a id="__idx_1430"></a>Goguen, <a id="__idx_1432"></a>Thatcher,
+<a id="__idx_1434"></a>Wagner, and <a id="__idx_1436"></a>Wright at IBM (see Thatcher, Wagner, and Wright 1978), and by <a id="__idx_1438"></a>Guttag at Toronto (see Guttag 1977),
+is called <a id="__idx_1440"></a><a id="__idx_1442"></a><em>algebraic specification</em>.  It regards the “procedures”
 as elements of an abstract algebraic system whose behavior is
 specified by axioms that correspond to our “conditions,” and uses
 the techniques of abstract algebra to check assertions about data
-objects.  Both methods are surveyed in the paper by <a name="%_idx_1444" id="%_idx_1444"></a>Liskov and Zilles
+objects.  Both methods are surveyed in the paper by <a id="__idx_1444"></a>Liskov and Zilles
 (1975).
 
 </p></div>
diff --git a/src/OEBPS/book-Z-H-15.html b/src/OEBPS/book-Z-H-15.html
index 8d25020..75b1d41 100644
--- a/src/OEBPS/book-Z-H-15.html
+++ b/src/OEBPS/book-Z-H-15.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,17 +13,17 @@
 
 
 
-<a name="%_sec_2.2" id="%_sec_2.2"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the Closure Property</a></h2><p>
+<a id="__sec_2.2"></a>
+<h2>2.2  Hierarchical Data and the Closure Property</h2><p>
 
 </p><p>
 
 As we have seen, pairs provide a primitive “glue” that we can use to
 construct compound data objects.
-Figure <a href="#%_fig_2.2">2.2</a> shows a standard way to
-visualize a <a name="%_idx_1526" id="%_idx_1526"></a>pair – in this case, the pair formed by <tt>(cons 1 2)</tt>.
-In this representation, which is called <a name="%_idx_1528" id="%_idx_1528"></a><em>box-and-pointer
-notation</em>, each object is shown as a <a name="%_idx_1530" id="%_idx_1530"></a><em>pointer</em> to a box.  The box
+Figure <a href="#__fig_2.2">2.2</a> shows a standard way to
+visualize a <a id="__idx_1526"></a>pair – in this case, the pair formed by <tt>(cons 1 2)</tt>.
+In this representation, which is called <a id="__idx_1528"></a><em>box-and-pointer
+notation</em>, each object is shown as a <a id="__idx_1530"></a><em>pointer</em> to a box.  The box
 for a primitive object contains a representation of the object.  For
 example, the box for a number contains a numeral.  The box for a pair
 is actually a double box, the left part containing (a pointer to) the
@@ -32,28 +32,28 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 We have already seen that <tt>cons</tt> can be used to combine not
 only numbers but pairs as well.  (You made use of this fact, or
-should have, in doing exercises <a href="book-Z-H-14.html#%_thm_2.2">2.2</a>
-and <a href="book-Z-H-14.html#%_thm_2.3">2.3</a>.)  As a consequence, pairs provide a universal
+should have, in doing exercises <a href="book-Z-H-14.html#__thm_2.2">2.2</a>
+and <a href="book-Z-H-14.html#__thm_2.3">2.3</a>.)  As a consequence, pairs provide a universal
 building block from which we can construct all sorts of data
-structures.  Figure <a href="#%_fig_2.3">2.3</a> shows two ways
+structures.  Figure <a href="#__fig_2.3">2.3</a> shows two ways
 to use pairs to combine the numbers 1, 2, 3, and 4.</p><p>
 
-<a name="%_fig_2.2" id="%_fig_2.2"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch2-Z-G-11.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 2.2:</b>  Box-and-pointer representation of <tt>(cons 1 2)</tt>.</div></caption><tr><td>
+<a id="__fig_2.2"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch2-Z-G-11.gif" alt="ch2-Z-G-11" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.2:</b>  Box-and-pointer representation of <tt>(cons 1 2)</tt>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_fig_2.3" id="%_fig_2.3"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch2-Z-G-12.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 2.3:</b>  Two ways to combine 1, 2, 3, and 4 using pairs.</div></caption><tr><td>
+<a id="__fig_2.3"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch2-Z-G-12.gif" alt="ch2-Z-G-12" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.3:</b>  Two ways to combine 1, 2, 3, and 4 using pairs.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
 The ability to create pairs whose elements are pairs is the essence of
 list structure's importance as a representational tool.  We refer to
-this ability as the <a name="%_idx_1532" id="%_idx_1532"></a><a name="%_idx_1534" id="%_idx_1534"></a><em>closure property</em> of <tt>cons</tt>.  In general,
+this ability as the <a id="__idx_1532"></a><a id="__idx_1534"></a><em>closure property</em> of <tt>cons</tt>.  In general,
 an operation for combining data objects satisfies the closure property
 if the results of combining things with that operation can themselves
-be combined using the same operation.<a name="call_footnote_Temp_154" href="#footnote_Temp_154" id="call_footnote_Temp_154"><sup><small>6</small></sup></a>
+be combined using the same operation.<a href="#footnote_Temp_154" id="call_footnote_Temp_154"><sup><small>6</small></sup></a>
 Closure is the key to power in
-any means of combination because it permits us to create <a name="%_idx_1538" id="%_idx_1538"></a><a name="%_idx_1540" id="%_idx_1540"></a><em>hierarchical</em> structures – structures made up of parts, which
+any means of combination because it permits us to create <a id="__idx_1538"></a><a id="__idx_1540"></a><em>hierarchical</em> structures – structures made up of parts, which
 themselves are made up of parts, and so on.</p><p>
 
 From the outset of chapter 1, we've made essential use of closure in
@@ -62,28 +62,28 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 combinations.  In this section, we take up the consequences of closure
 for compound data.  We describe some conventional techniques for using
 pairs to represent sequences and trees, and we exhibit a graphics
-language that illustrates closure in a vivid way.<a name="call_footnote_Temp_155" href="#footnote_Temp_155" id="call_footnote_Temp_155"><sup><small>7</small></sup></a></p><p>
+language that illustrates closure in a vivid way.<a href="#footnote_Temp_155" id="call_footnote_Temp_155"><sup><small>7</small></sup></a></p><p>
 
-<a name="%_sec_2.2.1" id="%_sec_2.2.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.2.1">2.2.1  Representing Sequences</a></h3><p>
+<a id="__sec_2.2.1"></a>
+</p><h3>2.2.1  Representing Sequences</h3><p>
 
 </p><p>
 
-<a name="%_fig_2.4" id="%_fig_2.4"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch2-Z-G-13.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 2.4:</b>  The sequence 1, 2, 3, 4 represented as a chain of pairs.</div></caption><tr><td>
+<a id="__fig_2.4"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch2-Z-G-13.gif" alt="ch2-Z-G-13" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.4:</b>  The sequence 1, 2, 3, 4 represented as a chain of pairs.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-One of the useful structures we can build with pairs is a <a name="%_idx_1554" id="%_idx_1554"></a><a name="%_idx_1556" id="%_idx_1556"></a><a name="%_idx_1558" id="%_idx_1558"></a><em>sequence</em> – an ordered collection of data objects.  There are, of
+One of the useful structures we can build with pairs is a <a id="__idx_1554"></a><a id="__idx_1556"></a><a id="__idx_1558"></a><em>sequence</em> – an ordered collection of data objects.  There are, of
 course, many ways to represent sequences in terms of pairs.  One
 particularly straightforward representation is illustrated in
-figure <a href="#%_fig_2.4">2.4</a>, where the sequence 1, 2, 3, 4 is
+figure <a href="#__fig_2.4">2.4</a>, where the sequence 1, 2, 3, 4 is
 represented as a chain of pairs.  The <tt>car</tt> of each pair is the
 corresponding item in the chain, and the <tt>cdr</tt> of the pair is
 the next pair in the chain.  The <tt>cdr</tt> of the final pair
 signals the end of the sequence by pointing to a distinguished
 value that is not a pair,
 represented in box-and-pointer diagrams as a diagonal line
-<a name="%_idx_1560" id="%_idx_1560"></a>and in programs as the value of the variable <a name="%_idx_1562" id="%_idx_1562"></a><a name="%_idx_1564" id="%_idx_1564"></a><tt>nil</tt>.
+<a id="__idx_1560"></a>and in programs as the value of the variable <a id="__idx_1562"></a><a id="__idx_1564"></a><tt>nil</tt>.
 The entire sequence is constructed by nested <tt>cons</tt> operations:</p><p>
 
 </p><p></p><p><tt>(cons 1<br />
@@ -93,8 +93,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 
 Such a sequence of pairs, formed by nested <tt>cons</tt>es, is called a
-<a name="%_idx_1566" id="%_idx_1566"></a><em>list</em>, and Scheme provides a
-primitive called <a name="%_idx_1568" id="%_idx_1568"></a><a name="%_idx_1570" id="%_idx_1570"></a><tt>list</tt> to help in constructing lists.<a name="call_footnote_Temp_156" href="#footnote_Temp_156" id="call_footnote_Temp_156"><sup><small>8</small></sup></a>
+<a id="__idx_1566"></a><em>list</em>, and Scheme provides a
+primitive called <a id="__idx_1568"></a><a id="__idx_1570"></a><tt>list</tt> to help in constructing lists.<a href="#footnote_Temp_156" id="call_footnote_Temp_156"><sup><small>8</small></sup></a>
 The above sequence could be produced by <tt>(list 1 2 3 4)</tt>.  In
 general,</p><p>
 
@@ -105,8 +105,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 </p><p></p><p><tt>(cons &lt;<em>a<sub>1</sub></em>&gt; (cons &lt;<em>a<sub>2</sub></em>&gt; (cons <tt>...</tt> (cons &lt;<em>a<sub><em>n</em></sub></em>&gt; nil) <tt>...</tt>)))<br /></tt></p><p></p><p>
 Lisp systems conventionally print lists by printing the sequence of
-<a name="%_idx_1576" id="%_idx_1576"></a>elements, enclosed in parentheses.  Thus, the data object in
-figure <a href="#%_fig_2.4">2.4</a> is printed as <tt>(1 2 3 4)</tt>:</p><p>
+<a id="__idx_1576"></a>elements, enclosed in parentheses.  Thus, the data object in
+figure <a href="#__fig_2.4">2.4</a> is printed as <tt>(1 2 3 4)</tt>:</p><p>
 
 
 </p><p></p><p><tt>(define one-through-four (list 1 2 3 4))<br /><br />
@@ -117,12 +117,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 signal an error when the interpreter tries to apply the procedure <tt>1</tt> to arguments <tt>2</tt>, <tt>3</tt>, and <tt>4</tt>.</p><p>
 
 
-We can think of <a name="%_idx_1578" id="%_idx_1578"></a><a name="%_idx_1580" id="%_idx_1580"></a><tt>car</tt> as selecting the first item in the list, and
-of <a name="%_idx_1582" id="%_idx_1582"></a><tt>cdr</tt> as selecting the sublist consisting of all but the first
+We can think of <a id="__idx_1578"></a><a id="__idx_1580"></a><tt>car</tt> as selecting the first item in the list, and
+of <a id="__idx_1582"></a><tt>cdr</tt> as selecting the sublist consisting of all but the first
 item.  Nested applications of <tt>car</tt> and <tt>cdr</tt> can be used to
 extract the second, third, and subsequent items in the
-list.<a name="call_footnote_Temp_157" href="#footnote_Temp_157" id="call_footnote_Temp_157"><sup><small>9</small></sup></a>
-The constructor <a name="%_idx_1592" id="%_idx_1592"></a><tt>cons</tt> makes a list like the original one,
+list.<a href="#footnote_Temp_157" id="call_footnote_Temp_157"><sup><small>9</small></sup></a>
+The constructor <a id="__idx_1592"></a><tt>cons</tt> makes a list like the original one,
 but with an additional item at the beginning.</p><p>
 
 
@@ -132,18 +132,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 (cons 10 one-through-four)<br /><i>(10 1 2 3 4)</i><br /><br />
 (cons 5 one-through-four)<br /><i>(5 1 2 3 4)</i><br /></tt></p><p></p><p>
 The value of <tt>nil</tt>, used to terminate the chain of pairs, can be
-thought of as a sequence of no elements, the <a name="%_idx_1594" id="%_idx_1594"></a><a name="%_idx_1596" id="%_idx_1596"></a><em>empty list</em>.  The
+thought of as a sequence of no elements, the <a id="__idx_1594"></a><a id="__idx_1596"></a><em>empty list</em>.  The
 word <em>nil</em> is a contraction of the Latin word <em>nihil</em>, which
-means “nothing.”<a name="call_footnote_Temp_158" href="#footnote_Temp_158" id="call_footnote_Temp_158"><sup><small>10</small></sup></a></p><p>
+means “nothing.”<a href="#footnote_Temp_158" id="call_footnote_Temp_158"><sup><small>10</small></sup></a></p><p>
 
-<a name="%_sec_Temp_159" id="%_sec_Temp_159"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_159">List operations</a></h4><p>
+<a id="__sec_Temp_159"></a>
+</p><h4>List operations</h4><p>
 
-<a name="%_idx_1602" id="%_idx_1602"></a><a name="%_idx_1604" id="%_idx_1604"></a>
+<a id="__idx_1602"></a><a id="__idx_1604"></a>
 The use of pairs to represent sequences of elements as lists is
 accompanied by conventional programming techniques for manipulating
-lists by successively <a name="%_idx_1606" id="%_idx_1606"></a><a name="%_idx_1608" id="%_idx_1608"></a>“<tt>cdr</tt>ing down” the lists.  For example,
-the procedure <a name="%_idx_1610" id="%_idx_1610"></a><tt>list-ref</tt> takes as arguments a list and a number
+lists by successively <a id="__idx_1606"></a><a id="__idx_1608"></a>“<tt>cdr</tt>ing down” the lists.  For example,
+the procedure <a id="__idx_1610"></a><tt>list-ref</tt> takes as arguments a list and a number
 <em>n</em> and returns the <em>n</em>th item of the list.  It is customary to
 number the elements of the list beginning with 0.  The method for
 computing <tt>list-ref</tt> is the following:</p><p>
@@ -154,7 +154,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 <tt>cdr</tt> of the list.
 </li></ul><p></p><p>
 
-</p><p></p><p><tt><a name="%_idx_1612" id="%_idx_1612"></a>(define (list-ref items n)<br />
+</p><p></p><p><tt><a id="__idx_1612"></a>(define (list-ref items n)<br />
   (if (= n 0)<br />
       (car items)<br />
       (list-ref (cdr items) (- n 1))))<br />
@@ -162,12 +162,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 (list-ref squares 3)<br /><i>16</i><br /></tt></p><p></p><p></p><p>
 
 Often we <tt>cdr</tt> down the whole list.  To aid in this, Scheme includes
-a primitive predicate <a name="%_idx_1614" id="%_idx_1614"></a><a name="%_idx_1616" id="%_idx_1616"></a><a name="%_idx_1618" id="%_idx_1618"></a><tt>null?</tt>, which tests whether its argument is
-the empty list.  The procedure <a name="%_idx_1620" id="%_idx_1620"></a><a name="%_idx_1622" id="%_idx_1622"></a><tt>length</tt>, which
+a primitive predicate <a id="__idx_1614"></a><a id="__idx_1616"></a><a id="__idx_1618"></a><tt>null?</tt>, which tests whether its argument is
+the empty list.  The procedure <a id="__idx_1620"></a><a id="__idx_1622"></a><tt>length</tt>, which
 returns the number of items in a list, illustrates this typical
 pattern of use:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1624" id="%_idx_1624"></a>(define (length items)<br />
+</p><p></p><p><tt><a id="__idx_1624"></a>(define (length items)<br />
   (if (null? items)<br />
       0<br />
       (+ 1 (length (cdr items)))))<br />
@@ -187,15 +187,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 We could also compute <tt>length</tt> in an iterative style:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1626" id="%_idx_1626"></a>(define (length items)<br />
+</p><p></p><p><tt><a id="__idx_1626"></a>(define (length items)<br />
   (define (length-iter a count)<br />
     (if (null? a)<br />
         count<br />
         (length-iter (cdr a) (+ 1 count))))<br />
   (length-iter items 0))<br /></tt></p><p></p><p></p><p>
 
-Another conventional programming technique is to <a name="%_idx_1628" id="%_idx_1628"></a><a name="%_idx_1630" id="%_idx_1630"></a>“<tt>cons</tt> up” an
-answer list while <tt>cdr</tt>ing down a list, as in the procedure <a name="%_idx_1632" id="%_idx_1632"></a><a name="%_idx_1634" id="%_idx_1634"></a><tt>append</tt>, which takes two lists as arguments and combines their
+Another conventional programming technique is to <a id="__idx_1628"></a><a id="__idx_1630"></a>“<tt>cons</tt> up” an
+answer list while <tt>cdr</tt>ing down a list, as in the procedure <a id="__idx_1632"></a><a id="__idx_1634"></a><tt>append</tt>, which takes two lists as arguments and combines their
 elements to make a new list:</p><p>
 
 </p><p></p><p><tt>(append squares odds)<br /><i>(1 4 9 16 25 1 3 5 7)</i><br /><br />
@@ -209,28 +209,28 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 <tt>list2</tt>, and <tt>cons</tt> the <tt>car</tt> of <tt>list1</tt> onto the result:
 </li></ul><p></p><p>
 
-</p><p></p><p><tt><a name="%_idx_1636" id="%_idx_1636"></a>(define (append list1 list2)<br />
+</p><p></p><p><tt><a id="__idx_1636"></a>(define (append list1 list2)<br />
   (if (null? list1)<br />
       list2<br />
       (cons (car list1) (append (cdr list1) list2))))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_2.17" id="%_thm_2.17"></a>
-<b>Exercise 2.17.</b>  Define a procedure <a name="%_idx_1638" id="%_idx_1638"></a><a name="%_idx_1640" id="%_idx_1640"></a><tt>last-pair</tt> that returns the list that contains only
+</p><p><a id="__thm_2.17"></a>
+<b>Exercise 2.17.</b>  Define a procedure <a id="__idx_1638"></a><a id="__idx_1640"></a><tt>last-pair</tt> that returns the list that contains only
 the last element of a given (nonempty) list:</p><p>
 
 </p><p></p><p><tt>(last-pair (list 23 72 149 34))<br /><i>(34)</i><br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.18" id="%_thm_2.18"></a>
-<b>Exercise 2.18.</b>  Define a procedure <a name="%_idx_1642" id="%_idx_1642"></a><a name="%_idx_1644" id="%_idx_1644"></a><tt>reverse</tt> that takes a list as argument and
+</p><p><a id="__thm_2.18"></a>
+<b>Exercise 2.18.</b>  Define a procedure <a id="__idx_1642"></a><a id="__idx_1644"></a><tt>reverse</tt> that takes a list as argument and
 returns a list of the same elements in reverse order:</p><p>
 
 </p><p></p><p><tt>(reverse (list 1 4 9 16 25))<br /><i>(25 16 9 4 1)</i><br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.19" id="%_thm_2.19"></a>
-<b>Exercise 2.19.</b>  Consider the <a name="%_idx_1646" id="%_idx_1646"></a>change-counting program of
-section <a href="book-Z-H-11.html#%_sec_1.2.2">1.2.2</a>.  It would be nice to be able to
+</p><p><a id="__thm_2.19"></a>
+<b>Exercise 2.19.</b>  Consider the <a id="__idx_1646"></a>change-counting program of
+section <a href="book-Z-H-11.html#__sec_1.2.2">1.2.2</a>.  It would be nice to be able to
 easily change the currency used by the program, so that we could
 compute the number of ways to change a British pound, for example.  As
 the program is written, the knowledge of the currency is distributed
@@ -267,8 +267,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 </p><p></p><p>
 
 
-</p><p><a name="%_thm_2.20" id="%_thm_2.20"></a>
-<b>Exercise 2.20.</b>  <a name="%_idx_1648" id="%_idx_1648"></a><a name="%_idx_1650" id="%_idx_1650"></a><a name="%_idx_1652" id="%_idx_1652"></a><a name="%_idx_1654" id="%_idx_1654"></a>The procedures <tt>+</tt>, <tt>*</tt>, and <tt>list</tt> take arbitrary numbers
+</p><p><a id="__thm_2.20"></a>
+<b>Exercise 2.20.</b>  <a id="__idx_1648"></a><a id="__idx_1650"></a><a id="__idx_1652"></a><a id="__idx_1654"></a>The procedures <tt>+</tt>, <tt>*</tt>, and <tt>list</tt> take arbitrary numbers
 of arguments. One way to define such procedures is to use <tt>define</tt>
 with <em>dotted-tail notation</em>.  In a procedure definition, a parameter
 list that has a dot before the last parameter name indicates that, when the
@@ -293,7 +293,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 </p><p></p><p><tt>(g 1 2 3 4 5 6)<br /></tt></p><p></p><p>
 then in the body of <tt>g</tt>, <tt>w</tt> will be the
-list <tt>(1 2 3 4 5 6)</tt>.<a name="call_footnote_Temp_164" href="#footnote_Temp_164" id="call_footnote_Temp_164"><sup><small>11</small></sup></a></p><p>
+list <tt>(1 2 3 4 5 6)</tt>.<a href="#footnote_Temp_164" id="call_footnote_Temp_164"><sup><small>11</small></sup></a></p><p>
 
 Use this notation
 to write a procedure <tt>same-parity</tt> that takes one or more integers
@@ -303,16 +303,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 (same-parity 2 3 4 5 6 7)<br /><i>(2 4 6)</i><br /></tt></p><p></p><p>
 </p><p>
 
-<a name="%_sec_Temp_165" id="%_sec_Temp_165"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_165">Mapping over lists</a></h4><p>
+<a id="__sec_Temp_165"></a>
+</p><h4>Mapping over lists</h4><p>
 
-<a name="%_idx_1658" id="%_idx_1658"></a><a name="%_idx_1660" id="%_idx_1660"></a>
+<a id="__idx_1658"></a><a id="__idx_1660"></a>
 One extremely useful operation is to apply some transformation
 to each element in a list and generate the list of results.
 For instance, the following procedure scales each number in a list by
 a given factor:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1662" id="%_idx_1662"></a>(define (scale-list items factor)<br />
+</p><p></p><p><tt><a id="__idx_1662"></a>(define (scale-list items factor)<br />
   (if (null? items)<br />
       nil<br />
       (cons (* (car items) factor)<br />
@@ -321,13 +321,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 We can abstract this general idea and capture it as a common pattern
 expressed as a higher-order procedure, just as in
-section <a href="book-Z-H-12.html#%_sec_1.3">1.3</a>.  The higher-order procedure
+section <a href="book-Z-H-12.html#__sec_1.3">1.3</a>.  The higher-order procedure
 here is called <tt>map</tt>.  <tt>Map</tt> takes as arguments a procedure
 of one argument
 and a list, and returns a list of the results produced by
-applying the procedure to each element in the list:<a name="call_footnote_Temp_166" href="#footnote_Temp_166" id="call_footnote_Temp_166"><sup><small>12</small></sup></a></p><p>
+applying the procedure to each element in the list:<a href="#footnote_Temp_166" id="call_footnote_Temp_166"><sup><small>12</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_1666" id="%_idx_1666"></a>(define (map proc items)<br />
+</p><p></p><p><tt><a id="__idx_1666"></a>(define (map proc items)<br />
   (if (null? items)<br />
       nil<br />
       (cons (proc (car items))<br />
@@ -336,7 +336,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 (map (lambda (x) (* x x))<br />
      (list 1 2 3 4))<br /><i>(1 4 9 16)</i><br /></tt></p><p></p><p>
 Now we can give a new definition of <tt>scale-list</tt> in terms of <tt>map</tt>:
-</p><p></p><p><tt><a name="%_idx_1668" id="%_idx_1668"></a>(define (scale-list items factor)<br />
+</p><p></p><p><tt><a id="__idx_1668"></a>(define (scale-list items factor)<br />
   (map (lambda (x) (* x factor))<br />
        items))<br /></tt></p><p></p><p>
 </p><p>
@@ -352,14 +352,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 establish an abstraction barrier that isolates the implementation of
 procedures that transform lists from the details of how the
 elements of the list are extracted and combined.  Like the barriers
-shown in figure <a href="book-Z-H-14.html#%_fig_2.1">2.1</a>, this abstraction gives
+shown in figure <a href="book-Z-H-14.html#__fig_2.1">2.1</a>, this abstraction gives
 us the flexibility to change the low-level details of how sequences
 are implemented, while preserving the conceptual framework of
 operations that transform sequences to sequences.
-Section <a href="#%_sec_2.2.3">2.2.3</a> expands on this use
+Section <a href="#__sec_2.2.3">2.2.3</a> expands on this use
 of sequences as a framework for organizing programs.</p><p>
 
-</p><p><a name="%_thm_2.21" id="%_thm_2.21"></a>
+</p><p><a id="__thm_2.21"></a>
 <b>Exercise 2.21.</b>  The procedure <tt>square-list</tt> takes a list of
 numbers as argument and returns a list of the squares of those
 numbers.</p><p>
@@ -376,9 +376,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
   (map &lt;<em>??</em>&gt; &lt;<em>??</em>&gt;))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.22" id="%_thm_2.22"></a>
+</p><p><a id="__thm_2.22"></a>
 <b>Exercise 2.22.</b>  Louis Reasoner tries to rewrite the first <tt>square-list</tt> procedure of
-exercise <a href="#%_thm_2.21">2.21</a> so that it evolves an iterative
+exercise <a href="#__thm_2.21">2.21</a> so that it evolves an iterative
 process:</p><p>
 
 </p><p></p><p><tt>(define (square-list items)<br />
@@ -407,8 +407,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.23" id="%_thm_2.23"></a>
-<b>Exercise 2.23.</b>  The procedure <a name="%_idx_1670" id="%_idx_1670"></a><tt>for-each</tt> is similar to <tt>map</tt>.  It takes as
+</p><p><a id="__thm_2.23"></a>
+<b>Exercise 2.23.</b>  The procedure <a id="__idx_1670"></a><tt>for-each</tt> is similar to <tt>map</tt>.  It takes as
 arguments a procedure and a list of elements.  However, rather than
 forming a list of the  results, <tt>for-each</tt> just applies the procedure
 to each of the elements in turn, from left to right.  The values
@@ -424,11 +424,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 </p><p>
 </p><p>
 
-<a name="%_sec_2.2.2" id="%_sec_2.2.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.2.2">2.2.2  Hierarchical Structures</a></h3><p>
+<a id="__sec_2.2.2"></a>
+</p><h3>2.2.2  Hierarchical Structures</h3><p>
 
 
-<a name="%_idx_1672" id="%_idx_1672"></a><a name="%_idx_1674" id="%_idx_1674"></a><a name="%_idx_1676" id="%_idx_1676"></a><a name="%_idx_1678" id="%_idx_1678"></a>
+<a id="__idx_1672"></a><a id="__idx_1674"></a><a id="__idx_1676"></a><a id="__idx_1678"></a>
 The representation of sequences in terms of lists generalizes
 naturally to represent sequences whose elements may
 themselves be sequences.  For example, we can regard the object
@@ -436,30 +436,30 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 </p><p></p><p><tt>(cons (list 1 2) (list 3 4))<br /></tt></p><p></p><p>
 as a list of three items, the first of which is itself a list, <tt>(1 2)</tt>.  Indeed, this is suggested by the form in which the result is
-printed by the interpreter.  Figure <a href="#%_fig_2.5">2.5</a> shows
+printed by the interpreter.  Figure <a href="#__fig_2.5">2.5</a> shows
 the representation of this structure in terms of pairs.</p><p>
 
-<a name="%_fig_2.5" id="%_fig_2.5"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch2-Z-G-15.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 2.5:</b>  Structure formed by <tt>(cons (list 1 2) (list 3 4))</tt>.</div></caption><tr><td>
+<a id="__fig_2.5"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch2-Z-G-15.gif" alt="ch2-Z-G-15" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.5:</b>  Structure formed by <tt>(cons (list 1 2) (list 3 4))</tt>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
 Another way to think of sequences whose elements are sequences is as
 <em>trees</em>.  The elements of the sequence are the branches of the
 tree, and elements that are themselves sequences are subtrees.
-Figure <a href="#%_fig_2.6">2.6</a> shows the structure in
-figure <a href="#%_fig_2.5">2.5</a> viewed as a tree.</p><p>
+Figure <a href="#__fig_2.6">2.6</a> shows the structure in
+figure <a href="#__fig_2.5">2.5</a> viewed as a tree.</p><p>
 
-<a name="%_fig_2.6" id="%_fig_2.6"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch2-Z-G-16.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 2.6:</b>  The list structure in figure <a href="#%_fig_2.5">2.5</a> viewed as a tree.</div></caption><tr><td>
+<a id="__fig_2.6"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch2-Z-G-16.gif" alt="ch2-Z-G-16" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.6:</b>  The list structure in figure <a href="#__fig_2.5">2.5</a> viewed as a tree.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
 
-<a name="%_idx_1680" id="%_idx_1680"></a>Recursion is a natural tool for dealing with tree structures, since
+<a id="__idx_1680"></a>Recursion is a natural tool for dealing with tree structures, since
 we can often reduce operations on trees to operations on their
 branches, which reduce in turn to operations on the branches of the
 branches, and so on, until we reach the leaves of the tree.
 As an example, compare the <tt>length</tt> procedure of
-section <a href="#%_sec_2.2.1">2.2.1</a> with the <a name="%_idx_1682" id="%_idx_1682"></a><a name="%_idx_1684" id="%_idx_1684"></a><tt>count-leaves</tt> procedure, which
+section <a href="#__sec_2.2.1">2.2.1</a> with the <a id="__idx_1682"></a><a id="__idx_1684"></a><tt>count-leaves</tt> procedure, which
 returns the total number of leaves of a tree:</p><p>
 
 
@@ -506,24 +506,24 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 To aid
 in writing recursive procedures on trees, Scheme provides the primitive
-predicate <a name="%_idx_1686" id="%_idx_1686"></a><a name="%_idx_1688" id="%_idx_1688"></a><tt>pair?</tt>, which tests whether its argument is a pair.
-Here is the complete procedure:<a name="call_footnote_Temp_170" href="#footnote_Temp_170" id="call_footnote_Temp_170"><sup><small>13</small></sup></a></p><p>
+predicate <a id="__idx_1686"></a><a id="__idx_1688"></a><tt>pair?</tt>, which tests whether its argument is a pair.
+Here is the complete procedure:<a href="#footnote_Temp_170" id="call_footnote_Temp_170"><sup><small>13</small></sup></a></p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_1690" id="%_idx_1690"></a>(define (count-leaves x)<br />
+</p><p></p><p><tt><a id="__idx_1690"></a>(define (count-leaves x)<br />
   (cond ((null? x) 0)  <br />
         ((not (pair? x)) 1)<br />
         (else (+ (count-leaves (car x))<br />
                  (count-leaves (cdr x))))))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_2.24" id="%_thm_2.24"></a>
+</p><p><a id="__thm_2.24"></a>
 <b>Exercise 2.24.</b>  Suppose we evaluate the expression <tt>(list 1 (list 2 (list 3 4)))</tt>.
 Give the result printed by the interpreter, the corresponding
 box-and-pointer structure, and the interpretation of this as a tree
-(as in figure <a href="#%_fig_2.6">2.6</a>).
+(as in figure <a href="#__fig_2.6">2.6</a>).
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.25" id="%_thm_2.25"></a>
+</p><p><a id="__thm_2.25"></a>
 <b>Exercise 2.25.</b>  Give combinations of <tt>car</tt>s and <tt>cdr</tt>s that will pick 7 from
 each of the following lists:</p><p>
 
@@ -532,7 +532,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 (1 (2 (3 (4 (5 (6 7))))))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.26" id="%_thm_2.26"></a>
+</p><p><a id="__thm_2.26"></a>
 <b>Exercise 2.26.</b>  Suppose we define <tt>x</tt> and <tt>y</tt> to be two lists:</p><p>
 
 </p><p></p><p><tt>(define x (list 1 2 3))<br />
@@ -545,9 +545,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 (list x y)<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.27" id="%_thm_2.27"></a>
-<b>Exercise 2.27.</b>  Modify your <tt>reverse</tt> procedure of exercise <a href="#%_thm_2.18">2.18</a> to
-produce a <a name="%_idx_1692" id="%_idx_1692"></a><a name="%_idx_1694" id="%_idx_1694"></a><tt>deep-reverse</tt> procedure that takes a list as argument
+</p><p><a id="__thm_2.27"></a>
+<b>Exercise 2.27.</b>  Modify your <tt>reverse</tt> procedure of exercise <a href="#__thm_2.18">2.18</a> to
+produce a <a id="__idx_1692"></a><a id="__idx_1694"></a><tt>deep-reverse</tt> procedure that takes a list as argument
 and returns as its value the list with its elements reversed and with
 all sublists deep-reversed as well.  For example,</p><p>
 
@@ -557,8 +557,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 (deep-reverse x)<br /><i>((4 3) (2 1))</i><br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.28" id="%_thm_2.28"></a>
-<b>Exercise 2.28.</b>  Write a procedure <a name="%_idx_1696" id="%_idx_1696"></a><a name="%_idx_1698" id="%_idx_1698"></a><tt>fringe</tt> that takes as argument a tree
+</p><p><a id="__thm_2.28"></a>
+<b>Exercise 2.28.</b>  Write a procedure <a id="__idx_1696"></a><a id="__idx_1698"></a><tt>fringe</tt> that takes as argument a tree
 (represented as a list) and returns a list whose elements are all the
 leaves of the tree arranged in left-to-right order.  For example,</p><p>
 
@@ -568,8 +568,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 </p><p></p><p>
 
 
-</p><p><a name="%_thm_2.29" id="%_thm_2.29"></a>
-<b>Exercise 2.29.</b>  <a name="%_idx_1700" id="%_idx_1700"></a>A binary mobile consists of two branches, a left branch and a right
+</p><p><a id="__thm_2.29"></a>
+<b>Exercise 2.29.</b>  <a id="__idx_1700"></a>A binary mobile consists of two branches, a left branch and a right
 branch.  Each branch is a rod of a certain length, from which hangs
 either a weight or another binary mobile.  We can represent a binary
 mobile using compound data by constructing it from two branches (for
@@ -594,7 +594,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 b.  Using your selectors, define a procedure <tt>total-weight</tt>
 that returns the total weight of a mobile.</p><p>
 
-c.  A mobile is said to be <a name="%_idx_1702" id="%_idx_1702"></a><em>balanced</em> if the torque applied
+c.  A mobile is said to be <a id="__idx_1702"></a><em>balanced</em> if the torque applied
 by its top-left branch is equal to that applied by its top-right
 branch (that is, if the length of the left rod multiplied by the
 weight hanging from that rod is equal to the corresponding product for
@@ -616,21 +616,21 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 </p><p>
 </p><p>
 
-<a name="%_sec_Temp_177" id="%_sec_Temp_177"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_177">Mapping over trees</a></h4><p>
+<a id="__sec_Temp_177"></a>
+</p><h4>Mapping over trees</h4><p>
 
-<a name="%_idx_1704" id="%_idx_1704"></a><a name="%_idx_1706" id="%_idx_1706"></a>
+<a id="__idx_1704"></a><a id="__idx_1706"></a>
 Just as <tt>map</tt> is a powerful abstraction for dealing with sequences,
 <tt>map</tt> together with recursion is a powerful abstraction for
 dealing with trees.  For instance, the <tt>scale-tree</tt>
 procedure, analogous to <tt>scale-list</tt> of
-section <a href="#%_sec_2.2.1">2.2.1</a>, takes as arguments a numeric factor and a
+section <a href="#__sec_2.2.1">2.2.1</a>, takes as arguments a numeric factor and a
 tree whose leaves are numbers.  It returns a tree of the same shape,
 where each number is multiplied by the factor.
 The recursive plan for <tt>scale-tree</tt> is similar to the one for
 <tt>count-leaves</tt>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1708" id="%_idx_1708"></a>(define (scale-tree tree factor)<br />
+</p><p></p><p><tt><a id="__idx_1708"></a>(define (scale-tree tree factor)<br />
   (cond ((null? tree) nil)<br />
         ((not (pair? tree)) (* tree factor))<br />
         (else (cons (scale-tree (car tree) factor)<br />
@@ -644,7 +644,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 of results.  In the base case, where the tree is a leaf, we simply
 multiply by the factor:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1710" id="%_idx_1710"></a>(define (scale-tree tree factor)<br />
+</p><p></p><p><tt><a id="__idx_1710"></a>(define (scale-tree tree factor)<br />
   (map (lambda (sub-tree)<br />
          (if (pair? sub-tree)<br />
              (scale-tree sub-tree factor)<br />
@@ -653,9 +653,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 Many tree operations can be implemented by similar combinations of
 sequence operations and recursion.</p><p>
 
-</p><p><a name="%_thm_2.30" id="%_thm_2.30"></a>
+</p><p><a id="__thm_2.30"></a>
 <b>Exercise 2.30.</b>  Define a procedure <tt>square-tree</tt> analogous to the <tt>square-list</tt>
-procedure of exercise <a href="#%_thm_2.21">2.21</a>.  That is, <tt>square-list</tt> should behave as follows:</p><p>
+procedure of exercise <a href="#__thm_2.21">2.21</a>.  That is, <tt>square-list</tt> should behave as follows:</p><p>
 
 </p><p></p><p><tt>(square-tree<br />
  (list 1<br />
@@ -666,22 +666,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.31" id="%_thm_2.31"></a>
-<b>Exercise 2.31.</b>  Abstract your answer to exercise <a href="#%_thm_2.30">2.30</a> to produce a
-procedure <a name="%_idx_1712" id="%_idx_1712"></a><tt>tree-map</tt> with the property that <tt>square-tree</tt>
+</p><p><a id="__thm_2.31"></a>
+<b>Exercise 2.31.</b>  Abstract your answer to exercise <a href="#__thm_2.30">2.30</a> to produce a
+procedure <a id="__idx_1712"></a><tt>tree-map</tt> with the property that <tt>square-tree</tt>
 could be defined as</p><p>
 
 </p><p></p><p><tt>(define (square-tree tree) (tree-map square tree))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.32" id="%_thm_2.32"></a>
-<b>Exercise 2.32.</b>  We can represent a <a name="%_idx_1714" id="%_idx_1714"></a>set as a list of distinct elements, and we can
+</p><p><a id="__thm_2.32"></a>
+<b>Exercise 2.32.</b>  We can represent a <a id="__idx_1714"></a>set as a list of distinct elements, and we can
 represent the set of all subsets of the set as a list of lists.  For
 example, if the set is <tt>(1 2 3)</tt>, then the set of all subsets is
 <tt>(() (3) (2) (2 3) (1) (1 3) (1 2) (1 2 3))</tt>.  Complete the
 following definition of a procedure that generates the set of subsets
 of a set and give a clear explanation of why it works:
-</p><p></p><p><tt><a name="%_idx_1716" id="%_idx_1716"></a>(define (subsets s)<br />
+</p><p></p><p><tt><a id="__idx_1716"></a>(define (subsets s)<br />
   (if (null? s)<br />
       (list nil)<br />
       (let ((rest (subsets (cdr s))))<br />
@@ -689,11 +689,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 </p><p>
 </p><p>
 
-<a name="%_sec_2.2.3" id="%_sec_2.2.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.2.3">2.2.3  Sequences as Conventional Interfaces</a></h3><p>
+<a id="__sec_2.2.3"></a>
+</p><h3>2.2.3  Sequences as Conventional Interfaces</h3><p>
 
 
-<a name="%_idx_1718" id="%_idx_1718"></a><a name="%_idx_1720" id="%_idx_1720"></a>
+<a id="__idx_1718"></a><a id="__idx_1720"></a>
 In working with compound data, we've stressed how data abstraction
 permits us to design programs without becoming enmeshed in the details
 of data representations, and how abstraction preserves for us the
@@ -701,16 +701,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 section, we introduce another powerful design principle for working
 with data structures – the use of <em>conventional interfaces</em>.</p><p>
 
-In section <a href="book-Z-H-12.html#%_sec_1.3">1.3</a> we saw how program
+In section <a href="book-Z-H-12.html#__sec_1.3">1.3</a> we saw how program
 abstractions, implemented as higher-order procedures, can capture
 common patterns in programs that deal with numerical data.  Our
 ability to formulate analogous operations for working with compound
 data depends crucially on the style in which we manipulate our data
 structures.  Consider, for example, the following procedure, analogous
-to the <tt>count-leaves</tt> procedure of section <a href="#%_sec_2.2.2">2.2.2</a>, which
+to the <tt>count-leaves</tt> procedure of section <a href="#__sec_2.2.2">2.2.2</a>, which
 takes a tree as argument and computes the sum of the squares of the
 leaves that are odd:
-</p><p></p><p><tt><a name="%_idx_1722" id="%_idx_1722"></a>(define (sum-odd-squares tree)<br />
+</p><p></p><p><tt><a id="__idx_1722"></a>(define (sum-odd-squares tree)<br />
   (cond ((null? tree) 0)  <br />
         ((not (pair? tree))<br />
          (if (odd? tree) (square tree) 0))<br />
@@ -720,7 +720,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 On the surface, this procedure is very different from the following
 one, which constructs a list of all the even Fibonacci numbers
  <em>F</em><em>i</em><em>b</em>(<em>k</em>), where <em>k</em> is less than or equal to a given integer <em>n</em>:
-</p><p></p><p><tt><a name="%_idx_1724" id="%_idx_1724"></a>(define (even-fibs n)<br />
+</p><p></p><p><tt><a id="__idx_1724"></a>(define (even-fibs n)<br />
   (define (next k)<br />
     (if (&gt; k n)<br />
         nil<br />
@@ -747,20 +747,20 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 empty list.
 </li></ul><p></p><p>
 
-<a name="%_idx_1726" id="%_idx_1726"></a><a name="%_idx_1728" id="%_idx_1728"></a>A signal-processing engineer would find it natural to conceptualize
+<a id="__idx_1726"></a><a id="__idx_1728"></a>A signal-processing engineer would find it natural to conceptualize
 these processes in terms of signals flowing through a cascade of
 stages, each of which implements part of the program plan, as shown in
-figure <a href="#%_fig_2.7">2.7</a>.  In <tt>sum-odd-squares</tt>, we
-begin with an <a name="%_idx_1730" id="%_idx_1730"></a><em>enumerator</em>, which generates a “signal”
+figure <a href="#__fig_2.7">2.7</a>.  In <tt>sum-odd-squares</tt>, we
+begin with an <a id="__idx_1730"></a><em>enumerator</em>, which generates a “signal”
 consisting of the leaves of a given tree.  This signal is passed
-through a <a name="%_idx_1732" id="%_idx_1732"></a><em>filter</em>, which eliminates all but the odd elements.
-The resulting signal is in turn passed through a <a name="%_idx_1734" id="%_idx_1734"></a><em>map</em>, which is a
+through a <a id="__idx_1732"></a><em>filter</em>, which eliminates all but the odd elements.
+The resulting signal is in turn passed through a <a id="__idx_1734"></a><em>map</em>, which is a
 “transducer” that applies the <tt>square</tt> procedure to each
-element.  The output of the map is then fed to an <a name="%_idx_1736" id="%_idx_1736"></a><em>accumulator</em>,
+element.  The output of the map is then fed to an <a id="__idx_1736"></a><em>accumulator</em>,
 which combines the elements using <tt>+</tt>, starting from an initial 0.
 The plan for <tt>even-fibs</tt> is analogous.</p><p>
 
-<a name="%_fig_2.7" id="%_fig_2.7"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch2-Z-G-17.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 2.7:</b>  The signal-flow plans for the procedures <tt>sum-odd-squares</tt> (top) and <tt>even-fibs</tt> (bottom) reveal the
+<a id="__fig_2.7"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch2-Z-G-17.gif" alt="ch2-Z-G-17" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.7:</b>  The signal-flow plans for the procedures <tt>sum-odd-squares</tt> (top) and <tt>even-fibs</tt> (bottom) reveal the
 commonality between the two programs.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
@@ -780,25 +780,25 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 we write, this would increase the conceptual clarity of the resulting
 code.</p><p>
 
-<a name="%_sec_Temp_181" id="%_sec_Temp_181"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_181">Sequence Operations</a></h4><p>
+<a id="__sec_Temp_181"></a>
+</p><h4>Sequence Operations</h4><p>
 
 
-<a name="%_idx_1738" id="%_idx_1738"></a>
+<a id="__idx_1738"></a>
 The key to organizing programs so as to more clearly reflect the
 signal-flow structure is to concentrate on the “signals” that flow
 from one stage in the process to the next.  If we represent these
 signals as lists, then we can use list operations to implement the
 processing at each of the stages.  For instance, we can implement the
 mapping stages of the signal-flow diagrams using the <tt>map</tt>
-procedure from section <a href="#%_sec_2.2.1">2.2.1</a>:
+procedure from section <a href="#__sec_2.2.1">2.2.1</a>:
 
 </p><p></p><p><tt>(map square (list 1 2 3 4 5))<br /><i>(1 4 9 16 25)</i><br /></tt></p><p></p><p></p><p>
 
 Filtering a sequence to select only those elements that satisfy a
 given predicate is accomplished by
 
-</p><p></p><p><tt><a name="%_idx_1740" id="%_idx_1740"></a>(define (filter predicate sequence)<br />
+</p><p></p><p><tt><a id="__idx_1740"></a>(define (filter predicate sequence)<br />
   (cond ((null? sequence) nil)<br />
         ((predicate (car sequence))<br />
          (cons (car sequence)<br />
@@ -808,7 +808,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 </p><p></p><p><tt>(filter odd? (list 1 2 3 4 5))<br /><i>(1 3 5)</i><br /></tt></p><p></p><p></p><p>
 
 Accumulations can be implemented by
-</p><p></p><p><tt><a name="%_idx_1742" id="%_idx_1742"></a>(define (accumulate op initial sequence)<br />
+</p><p></p><p><tt><a id="__idx_1742"></a>(define (accumulate op initial sequence)<br />
   (if (null? sequence)<br />
       initial<br />
       (op (car sequence)<br />
@@ -822,13 +822,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 sequence of elements to be processed.  For <tt>even-fibs</tt>, we need to
 generate the sequence of
 integers in a given range, which we can do as follows:
-</p><p></p><p><tt><a name="%_idx_1744" id="%_idx_1744"></a>(define (enumerate-interval low high)<br />
+</p><p></p><p><tt><a id="__idx_1744"></a>(define (enumerate-interval low high)<br />
   (if (&gt; low high)<br />
       nil<br />
       (cons low (enumerate-interval (+ low 1) high))))<br />
 (enumerate-interval 2 7)<br /><i>(2 3 4 5 6 7)</i><br /></tt></p><p></p><p>
-To enumerate the leaves of a tree, we can use<a name="call_footnote_Temp_182" href="#footnote_Temp_182" id="call_footnote_Temp_182"><sup><small>14</small></sup></a>
-</p><p></p><p><tt><a name="%_idx_1748" id="%_idx_1748"></a><a name="%_idx_1750" id="%_idx_1750"></a>(define (enumerate-tree tree)<br />
+To enumerate the leaves of a tree, we can use<a href="#footnote_Temp_182" id="call_footnote_Temp_182"><sup><small>14</small></sup></a>
+</p><p></p><p><tt><a id="__idx_1748"></a><a id="__idx_1750"></a>(define (enumerate-tree tree)<br />
   (cond ((null? tree) nil)<br />
         ((not (pair? tree)) (list tree))<br />
         (else (append (enumerate-tree (car tree))<br />
@@ -840,7 +840,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 sequence of leaves of the tree, filter this to keep only the odd
 numbers in the sequence, square each element, and sum the results:
 
-</p><p></p><p><tt><a name="%_idx_1752" id="%_idx_1752"></a>(define (sum-odd-squares tree)<br />
+</p><p></p><p><tt><a id="__idx_1752"></a>(define (sum-odd-squares tree)<br />
   (accumulate +<br />
               0<br />
               (map square<br />
@@ -851,7 +851,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 sequence to keep only the even elements, and accumulate the results
 into a list:
 
-</p><p></p><p><tt><a name="%_idx_1754" id="%_idx_1754"></a>(define (even-fibs n)<br />
+</p><p></p><p><tt><a id="__idx_1754"></a>(define (even-fibs n)<br />
   (accumulate cons<br />
               nil<br />
               (filter even?<br />
@@ -866,7 +866,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 together with a conventional interface for connecting the components
 in flexible ways.</p><p>
 
-<a name="%_idx_1756" id="%_idx_1756"></a><a name="%_idx_1758" id="%_idx_1758"></a>Modular construction is a powerful strategy for
+<a id="__idx_1756"></a><a id="__idx_1758"></a>Modular construction is a powerful strategy for
 controlling complexity in engineering design.  In real
 signal-processing applications, for example, designers regularly build
 systems by cascading elements selected from standardized families of
@@ -903,7 +903,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
               (map salary<br />
                    (filter programmer? records))))<br /></tt></p><p></p><p>
 These examples give just a hint of the vast range of operations that
-can be expressed as sequence operations.<a name="call_footnote_Temp_183" href="#footnote_Temp_183" id="call_footnote_Temp_183"><sup><small>15</small></sup></a></p><p>
+can be expressed as sequence operations.<a href="#footnote_Temp_183" id="call_footnote_Temp_183"><sup><small>15</small></sup></a></p><p>
 
 Sequences, implemented here as lists, serve
 as a conventional interface that permits us to combine processing
@@ -912,31 +912,31 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 programs to a small number of sequence operations.  By changing these,
 we can experiment with alternative representations of sequences, while
 leaving the overall design of our programs intact.  We will exploit
-this capability in section <a href="book-Z-H-24.html#%_sec_3.5">3.5</a>, when we generalize the
+this capability in section <a href="book-Z-H-24.html#__sec_3.5">3.5</a>, when we generalize the
 sequence-processing paradigm to admit infinite sequences.</p><p>
 
-</p><p><a name="%_thm_2.33" id="%_thm_2.33"></a>
+</p><p><a id="__thm_2.33"></a>
 <b>Exercise 2.33.</b>  Fill in the missing expressions to complete the following definitions
 of some basic list-manipulation operations as accumulations:
-</p><p></p><p><tt><a name="%_idx_1766" id="%_idx_1766"></a>(define (map p sequence)<br />
-  (accumulate (lambda (x y) &lt;<em>??</em>&gt;) nil sequence))<br /><a name="%_idx_1768" id="%_idx_1768"></a>(define (append seq1 seq2)<br />
-  (accumulate cons &lt;<em>??</em>&gt; &lt;<em>??</em>&gt;))<br /><a name="%_idx_1770" id="%_idx_1770"></a>(define (length sequence)<br />
+</p><p></p><p><tt><a id="__idx_1766"></a>(define (map p sequence)<br />
+  (accumulate (lambda (x y) &lt;<em>??</em>&gt;) nil sequence))<br /><a id="__idx_1768"></a>(define (append seq1 seq2)<br />
+  (accumulate cons &lt;<em>??</em>&gt; &lt;<em>??</em>&gt;))<br /><a id="__idx_1770"></a>(define (length sequence)<br />
   (accumulate &lt;<em>??</em>&gt; 0 sequence))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.34" id="%_thm_2.34"></a>
-<b>Exercise 2.34.</b>  <a name="%_idx_1772" id="%_idx_1772"></a>Evaluating a polynomial in <em>x</em> at a given value of <em>x</em> can be
+</p><p><a id="__thm_2.34"></a>
+<b>Exercise 2.34.</b>  <a id="__idx_1772"></a>Evaluating a polynomial in <em>x</em> at a given value of <em>x</em> can be
 formulated as an accumulation.  We evaluate the polynomial</p>
 
 <p><em>a<sub>n</sub>x<sup>n</sup></em> + <em>a</em><sub><em>n</em>-1</sub><em>x</em><sup><em>n</em>-1</sup> + ⋯ + <em>a</em><sub>1</sub><em>x</em> + <em>a</em><sub>0</sub></p>
 
-<p>using a well-known algorithm called <a name="%_idx_1774" id="%_idx_1774"></a><em>Horner's rule</em>, which
+<p>using a well-known algorithm called <a id="__idx_1774"></a><em>Horner's rule</em>, which
 structures the computation as</p>
 
 <p>(⋯ (<em>a<sub>n</sub>x</em> + <em>a</em><sub><em>n</em>-1</sub>)<em>x</em> + ⋯ + <em>a</em><sub>1</sub>) <em>x</em> + <em>a</em><sub>0</sub></p>
 
 <p>In other words, we start with <em>a</em><sub><em>n</em></sub>, multiply by <em>x</em>, add <em>a</em><sub><em>n</em>-1</sub>,
-multiply by <em>x</em>, and so on, until we reach <em>a</em><sub>0</sub>.<a name="call_footnote_Temp_186" href="#footnote_Temp_186" id="call_footnote_Temp_186"><sup><small>16</small></sup></a>
+multiply by <em>x</em>, and so on, until we reach <em>a</em><sub>0</sub>.<a href="#footnote_Temp_186" id="call_footnote_Temp_186"><sup><small>16</small></sup></a>
 Fill in the following template to produce a procedure that evaluates a
 polynomial using Horner's rule.
 Assume that the coefficients of the
@@ -949,14 +949,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 </p><p></p><p><tt>(horner-eval 2 (list 1 3 0 5 0 1))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.35" id="%_thm_2.35"></a>
-<b>Exercise 2.35.</b>  Redefine <tt>count-leaves</tt> from section <a href="#%_sec_2.2.2">2.2.2</a> as an
+</p><p><a id="__thm_2.35"></a>
+<b>Exercise 2.35.</b>  Redefine <tt>count-leaves</tt> from section <a href="#__sec_2.2.2">2.2.2</a> as an
 accumulation:
-</p><p></p><p><tt><a name="%_idx_1792" id="%_idx_1792"></a>(define (count-leaves t)<br />
+</p><p></p><p><tt><a id="__idx_1792"></a>(define (count-leaves t)<br />
   (accumulate &lt;<em>??</em>&gt; &lt;<em>??</em>&gt; (map &lt;<em>??</em>&gt; &lt;<em>??</em>&gt;)))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.36" id="%_thm_2.36"></a>
+</p><p><a id="__thm_2.36"></a>
 <b>Exercise 2.36.</b>  The procedure <tt>accumulate-n</tt> is similar to <tt>accumulate</tt> except
 that it takes as its third argument a sequence of sequences, which are all
 assumed to have the same number of elements.  It applies the
@@ -966,14 +966,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 containing four sequences, <tt>((1 2 3) (4 5 6) (7 8 9) (10 11 12)),</tt>
 then the value of <tt>(accumulate-n + 0 s)</tt> should be the sequence <tt>(22 26 30)</tt>.  Fill in the missing expressions
 in the following definition of <tt>accumulate-n</tt>:
-</p><p></p><p><tt><a name="%_idx_1794" id="%_idx_1794"></a>(define (accumulate-n op init seqs)<br />
+</p><p></p><p><tt><a id="__idx_1794"></a>(define (accumulate-n op init seqs)<br />
   (if (null? (car seqs))<br />
       nil<br />
       (cons (accumulate op init &lt;<em>??</em>&gt;)<br />
             (accumulate-n op init &lt;<em>??</em>&gt;))))<br /></tt></p><p></p><p>
 </p><p>
-</p><p><a name="%_thm_2.37" id="%_thm_2.37"></a>
-<b>Exercise 2.37.</b>  <a name="%_idx_1796" id="%_idx_1796"></a><a name="%_idx_1798" id="%_idx_1798"></a><a name="%_idx_1800" id="%_idx_1800"></a>Suppose we represent vectors <em>v</em> = (<em>v</em><sub><em>i</em></sub>) as sequences of numbers, and
+</p><p><a id="__thm_2.37"></a>
+<b>Exercise 2.37.</b>  <a id="__idx_1796"></a><a id="__idx_1798"></a><a id="__idx_1800"></a>Suppose we represent vectors <em>v</em> = (<em>v</em><sub><em>i</em></sub>) as sequences of numbers, and
 matrices <em>m</em> = (<em>m</em><sub><em>i</em><em>j</em></sub>) as sequences of vectors (the rows of the matrix).
 For example, the matrix</p>
 
@@ -1023,25 +1023,25 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
     <code>(transpose <em>m</em>)          </code>returns the matrix <em>n</em>, where <em>n<sub>ij</sub></em> = <em>m<sub>ji</sub></em>.
 </p>
 
-<p>We can define the dot product as<a name="call_footnote_Temp_190" href="#footnote_Temp_190" id="call_footnote_Temp_190"><sup><small>17</small></sup></a>
-</p><p></p><p><tt><a name="%_idx_1802" id="%_idx_1802"></a>(define (dot-product v w)<br />
+<p>We can define the dot product as<a href="#footnote_Temp_190" id="call_footnote_Temp_190"><sup><small>17</small></sup></a>
+</p><p></p><p><tt><a id="__idx_1802"></a>(define (dot-product v w)<br />
   (accumulate + 0 (map * v w)))<br /></tt></p><p></p><p>
 Fill in the missing expressions in the following procedures for
 computing the other matrix operations.  (The procedure <tt>accumulate-n</tt> is
-defined in exercise <a href="#%_thm_2.36">2.36</a>.)
-</p><p></p><p><tt><a name="%_idx_1804" id="%_idx_1804"></a>(define (matrix-*-vector m v)<br />
-  (map &lt;<em>??</em>&gt; m))<br /><a name="%_idx_1806" id="%_idx_1806"></a>(define (transpose mat)<br />
-  (accumulate-n &lt;<em>??</em>&gt; &lt;<em>??</em>&gt; mat))<br /><a name="%_idx_1808" id="%_idx_1808"></a>(define (matrix-*-matrix m n)<br />
+defined in exercise <a href="#__thm_2.36">2.36</a>.)
+</p><p></p><p><tt><a id="__idx_1804"></a>(define (matrix-*-vector m v)<br />
+  (map &lt;<em>??</em>&gt; m))<br /><a id="__idx_1806"></a>(define (transpose mat)<br />
+  (accumulate-n &lt;<em>??</em>&gt; &lt;<em>??</em>&gt; mat))<br /><a id="__idx_1808"></a>(define (matrix-*-matrix m n)<br />
   (let ((cols (transpose n)))<br />
     (map &lt;<em>??</em>&gt; m)))<br /></tt></p><p></p><p>
 </p><p>
-</p><p><a name="%_thm_2.38" id="%_thm_2.38"></a>
-<b>Exercise 2.38.</b>  <a name="%_idx_1810" id="%_idx_1810"></a><a name="%_idx_1812" id="%_idx_1812"></a>The <tt>accumulate</tt> procedure is also known as <tt>fold-right</tt>,
+</p><p><a id="__thm_2.38"></a>
+<b>Exercise 2.38.</b>  <a id="__idx_1810"></a><a id="__idx_1812"></a>The <tt>accumulate</tt> procedure is also known as <tt>fold-right</tt>,
 because it combines the first element of the sequence with the result
 of combining all the elements to the right.  There is also a <tt>fold-left</tt>, which is
 similar to <tt>fold-right</tt>, except
 that it combines elements working in the opposite direction:
-</p><p></p><p><tt><a name="%_idx_1814" id="%_idx_1814"></a>(define (fold-left op initial sequence)<br />
+</p><p></p><p><tt><a id="__idx_1814"></a>(define (fold-left op initial sequence)<br />
   (define (iter result rest)<br />
     (if (null? rest)<br />
         result<br />
@@ -1058,23 +1058,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.39" id="%_thm_2.39"></a>
+</p><p><a id="__thm_2.39"></a>
 <b>Exercise 2.39.</b>  
 Complete the following definitions of <tt>reverse</tt>
-<a name="%_idx_1816" id="%_idx_1816"></a>(exercise <a href="#%_thm_2.18">2.18</a>) in terms of <tt>fold-right</tt> and <tt>fold-left</tt> from exercise <a href="#%_thm_2.38">2.38</a>:
+<a id="__idx_1816"></a>(exercise <a href="#__thm_2.18">2.18</a>) in terms of <tt>fold-right</tt> and <tt>fold-left</tt> from exercise <a href="#__thm_2.38">2.38</a>:
 </p><p></p><p><tt>(define (reverse sequence)<br />
   (fold-right (lambda (x y) &lt;<em>??</em>&gt;) nil sequence))<br />
 (define (reverse sequence)<br />
   (fold-left (lambda (x y) &lt;<em>??</em>&gt;) nil sequence))<br /></tt></p><p></p><p>
 </p><p>
 
-<a name="%_sec_Temp_193" id="%_sec_Temp_193"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_193">Nested Mappings</a></h4><p>
+<a id="__sec_Temp_193"></a>
+</p><h4>Nested Mappings</h4><p>
 
 
-<a name="%_idx_1818" id="%_idx_1818"></a>
+<a id="__idx_1818"></a>
 We can extend the sequence paradigm to include many
-computations that are commonly expressed using nested loops.<a name="call_footnote_Temp_194" href="#footnote_Temp_194" id="call_footnote_Temp_194"><sup><small>18</small></sup></a>
+computations that are commonly expressed using nested loops.<a href="#footnote_Temp_194" id="call_footnote_Temp_194"><sup><small>18</small></sup></a>
 Consider
 this problem: Given a positive integer <em>n</em>, find all ordered pairs of
 distinct positive integers <em>i</em> and <em>j</em>, where 1<u>&lt;</u> <em>j</em>&lt; <em>i</em><u>&lt;</u> <em>n</em>, such
@@ -1129,7 +1129,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 this sequence, we map along the sequence <tt>(enumerate-interval 1 (-
 i 1))</tt>.  For each <em>j</em> in this latter sequence, we generate the pair
 <tt>(list i j)</tt>.  This gives us a sequence of pairs for each <em>i</em>.
-Combining all the sequences for all the <em>i</em> (by accumulating with <tt>append</tt>) produces the required sequence of pairs:<a name="call_footnote_Temp_195" href="#footnote_Temp_195" id="call_footnote_Temp_195"><sup><small>19</small></sup></a>
+Combining all the sequences for all the <em>i</em> (by accumulating with <tt>append</tt>) produces the required sequence of pairs:<a href="#footnote_Temp_195" id="call_footnote_Temp_195"><sup><small>19</small></sup></a>
 </p><p></p><p><tt>(accumulate append<br />
             nil<br />
             (map (lambda (i)<br />
@@ -1138,7 +1138,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
                  (enumerate-interval 1 n)))<br /></tt></p><p></p><p>
 The combination of mapping and accumulating with <tt>append</tt> is so common in this
 sort of program that we will isolate it as a separate procedure:
-</p><p></p><p><tt><a name="%_idx_1826" id="%_idx_1826"></a>(define (flatmap proc seq)<br />
+</p><p></p><p><tt><a id="__idx_1826"></a>(define (flatmap proc seq)<br />
   (accumulate append nil (map proc seq)))<br /></tt></p><p></p><p>
 Now filter this sequence of pairs to find those whose sum is prime. The
 filter predicate is called for each element of the sequence; its
@@ -1152,7 +1152,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 </p><p></p><p><tt>(define (make-pair-sum pair)<br />
   (list (car pair) (cadr pair) (+ (car pair) (cadr pair))))<br /></tt></p><p></p><p>
 Combining all these steps yields the complete procedure:
-</p><p></p><p><tt><a name="%_idx_1828" id="%_idx_1828"></a>(define (prime-sum-pairs n)<br />
+</p><p></p><p><tt><a id="__idx_1828"></a>(define (prime-sum-pairs n)<br />
   (map make-pair-sum<br />
        (filter prime-sum?<br />
                (flatmap<br />
@@ -1162,19 +1162,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
                 (enumerate-interval 1 n)))))<br /></tt></p><p></p><p></p><p>
 
 Nested mappings are also useful for sequences other than those that
-enumerate intervals.  Suppose we wish to generate all the <a name="%_idx_1830" id="%_idx_1830"></a><a name="%_idx_1832" id="%_idx_1832"></a>permutations
+enumerate intervals.  Suppose we wish to generate all the <a id="__idx_1830"></a><a id="__idx_1832"></a>permutations
 of a set <em>S</em>; that is, all the ways of ordering the items in
 the set.  For instance, the permutations of {1,2,3} are
 {1,2,3}, { 1,3,2}, {2,1,3}, { 2,3,1}, { 3,1,2}, and
 { 3,2,1}.  Here is a plan for generating the permutations of <em>S</em>:
 For each item <em>x</em> in <em>S</em>, recursively generate the sequence of
-permutations of <em>S</em> - <em>x</em>,<a name="call_footnote_Temp_196" href="#footnote_Temp_196" id="call_footnote_Temp_196"><sup><small>20</small></sup></a> and adjoin
+permutations of <em>S</em> - <em>x</em>,<a href="#footnote_Temp_196" id="call_footnote_Temp_196"><sup><small>20</small></sup></a> and adjoin
 <em>x</em> to the front of each one.  This yields, for each <em>x</em> in <em>S</em>, the sequence
 of permutations of <em>S</em> that begin with <em>x</em>.  Combining these
-sequences for all <em>x</em> gives all the permutations of <em>S</em>:<a name="call_footnote_Temp_197" href="#footnote_Temp_197" id="call_footnote_Temp_197"><sup><small>21</small></sup></a></p><p>
+sequences for all <em>x</em> gives all the permutations of <em>S</em>:<a href="#footnote_Temp_197" id="call_footnote_Temp_197"><sup><small>21</small></sup></a></p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_1840" id="%_idx_1840"></a>(define (permutations s)<br />
+</p><p></p><p><tt><a id="__idx_1840"></a>(define (permutations s)<br />
   (if (null? s)                    <em>; empty set?</em><br />
       (list nil)                   <em>; sequence containing empty set</em><br />
       (flatmap (lambda (x)<br />
@@ -1190,26 +1190,26 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 used in <tt>permutations</tt> returns all the items in a given sequence
 except for a given item.  This can be expressed as a simple filter:
 
-</p><p></p><p><tt><a name="%_idx_1842" id="%_idx_1842"></a>(define (remove item sequence)<br />
+</p><p></p><p><tt><a id="__idx_1842"></a>(define (remove item sequence)<br />
   (filter (lambda (x) (not (= x item)))<br />
           sequence))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_2.40" id="%_thm_2.40"></a>
-<b>Exercise 2.40.</b>  Define a procedure <a name="%_idx_1844" id="%_idx_1844"></a><tt>unique-pairs</tt> that, given an integer <em>n</em>,
+</p><p><a id="__thm_2.40"></a>
+<b>Exercise 2.40.</b>  Define a procedure <a id="__idx_1844"></a><tt>unique-pairs</tt> that, given an integer <em>n</em>,
 generates the sequence of pairs (<em>i</em>,<em>j</em>) with 1<u>&lt;</u> <em>j</em>&lt; <em>i</em><u>&lt;</u> <em>n</em>.  Use <tt>unique-pairs</tt> to simplify the definition of <tt>prime-sum-pairs</tt>
 given above.
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.41" id="%_thm_2.41"></a>
+</p><p><a id="__thm_2.41"></a>
 <b>Exercise 2.41.</b>  Write a procedure to find all ordered
 triples of distinct positive integers <em>i</em>, <em>j</em>, and <em>k</em> less than or
 equal to a given integer <em>n</em> that sum to a given integer <em>s</em>.
 </p><p></p><p>
 
 
-</p><p><a name="%_thm_2.42" id="%_thm_2.42"></a>
+</p><p><a id="__thm_2.42"></a>
 
-<b>Exercise 2.42.</b>  <a name="%_fig_2.8" id="%_fig_2.8"></a></p><p></p><div align="left">
+<b>Exercise 2.42.</b>  <a id="__fig_2.8"></a></p><p></p><div style="text-align: left;">
 
     <table id="ch2-Z-G-23">
         <tr><td></td><td></td><td></td><td></td><td></td><td>♕</td><td></td><td></td></tr>
@@ -1221,14 +1221,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
         <tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr>
         <tr><td></td><td>♕</td><td></td><td></td><td></td><td></td><td></td><td></td></tr>
         <tr><td></td><td></td><td></td><td>♕</td><td></td><td></td><td></td><td></td></tr>
-        <caption align="bottom"><b>Figure 2.8:</b>  A solution to the eight-queens puzzle.</caption>
+        <caption style="caption-side: bottom;"><b>Figure 2.8:</b>  A solution to the eight-queens puzzle.</caption>
     </table>
 </div>
 
-<p>The <a name="%_idx_1846" id="%_idx_1846"></a><a name="%_idx_1848" id="%_idx_1848"></a><a name="%_idx_1850" id="%_idx_1850"></a>“eight-queens puzzle” asks how to place eight queens on a
+<p>The <a id="__idx_1846"></a><a id="__idx_1848"></a><a id="__idx_1850"></a>“eight-queens puzzle” asks how to place eight queens on a
 chessboard so that no queen is in check from any other (i.e., no two
 queens are in the same row, column, or diagonal).  One possible
-solution is shown in figure <a href="#%_fig_2.8">2.8</a>.  One way to solve the
+solution is shown in figure <a href="#__fig_2.8">2.8</a>.  One way to solve the
 puzzle is to work across the board, placing a queen in each column.
 Once we have placed <em>k</em> - 1 queens, we must place the <em>k</em>th queen in a
 position where it does not check any of the queens already on the
@@ -1249,7 +1249,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 <em>n</em>× <em>n</em> chessboard.  <tt>Queens</tt> has an internal procedure <tt>queen-cols</tt> that returns the sequence of all ways to place queens in
 the first <em>k</em> columns of the board.
 
-</p><p></p><p><tt><a name="%_idx_1852" id="%_idx_1852"></a>(define (queens board-size)<br />
+</p><p></p><p><tt><a id="__idx_1852"></a>(define (queens board-size)<br />
   (define (queen-cols k)  <br />
     (if (= k 0)<br />
         (list empty-board)<br />
@@ -1277,8 +1277,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.43" id="%_thm_2.43"></a>
-<b>Exercise 2.43.</b>  Louis Reasoner is having a terrible time doing exercise <a href="#%_thm_2.42">2.42</a>.  His
+</p><p><a id="__thm_2.43"></a>
+<b>Exercise 2.43.</b>  Louis Reasoner is having a terrible time doing exercise <a href="#__thm_2.42">2.42</a>.  His
 <tt>queens</tt> procedure seems to work, but it runs extremely slowly.
 (Louis never does manage to wait long enough for it to solve even the
 6× 6 case.)  When Louis asks Eva Lu Ator for help, she points
@@ -1292,127 +1292,127 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
  (enumerate-interval 1 board-size))<br /></tt></p><p></p><p>
 Explain why this interchange makes the program run slowly.  Estimate
 how long it will take Louis's program to solve the eight-queens
-puzzle, assuming that the program in exercise <a href="#%_thm_2.42">2.42</a> solves
+puzzle, assuming that the program in exercise <a href="#__thm_2.42">2.42</a> solves
 the puzzle in time <em>T</em>.
 </p><p></p><p>
 
-<a name="%_sec_2.2.4" id="%_sec_2.2.4"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.2.4">2.2.4  Example: A Picture Language</a></h3><p>
+<a id="__sec_2.2.4"></a>
+</p><h3>2.2.4  Example: A Picture Language</h3><p>
 
 
-<a name="%_idx_1854" id="%_idx_1854"></a>
+<a id="__idx_1854"></a>
 This section presents a simple language for drawing
 pictures that illustrates the
 power of data abstraction and closure,
 and also exploits higher-order procedures in
 an essential way.  The language
 is designed to make it easy to experiment with patterns
-such as the ones in figure <a href="#%_fig_2.9">2.9</a>, which are
-composed of repeated elements that are shifted and scaled.<a name="call_footnote_Temp_202" href="#footnote_Temp_202" id="call_footnote_Temp_202"><sup><small>22</small></sup></a> In this language,
+such as the ones in figure <a href="#__fig_2.9">2.9</a>, which are
+composed of repeated elements that are shifted and scaled.<a href="#footnote_Temp_202" id="call_footnote_Temp_202"><sup><small>22</small></sup></a> In this language,
 the data objects being combined
 are represented as procedures rather than as list structure.
-Just as <tt>cons</tt>, which satisfies the <a name="%_idx_1860" id="%_idx_1860"></a>closure property,
+Just as <tt>cons</tt>, which satisfies the <a id="__idx_1860"></a>closure property,
 allowed us to easily build arbitrarily complicated
 list structure, the operations in this language, which also
 satisfy the closure property, allow us to easily build
 arbitrarily complicated patterns.</p><p>
 
-<a name="%_fig_2.9" id="%_fig_2.9"></a></p><p></p><div align="left"><table width="100%"><tr><td><div align="left"><img src="images/ch2-Z-G-24.gif" border="0" />
+<a id="__fig_2.9"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><div style="text-align: left;"><img src="images/ch2-Z-G-24.gif" alt="ch2-Z-G-24" style="border: none;" />
           
-<img src="images/ch2-Z-G-25.gif" border="0" /> </div>
+<img src="images/ch2-Z-G-25.gif" alt="ch2-Z-G-25" style="border: none;" /> </div>
 
-</td></tr><caption align="bottom"><div align="left"><b>Figure 2.9:</b>  Designs generated with the picture language.</div></caption><tr><td>
+</td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.9:</b>  Designs generated with the picture language.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_sec_Temp_203" id="%_sec_Temp_203"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_203">The picture language</a></h4><p>
+<a id="__sec_Temp_203"></a>
+</p><h4>The picture language</h4><p>
 
 When we began our study of programming in
-section <a href="book-Z-H-10.html#%_sec_1.1">1.1</a>, we emphasized the
+section <a href="book-Z-H-10.html#__sec_1.1">1.1</a>, we emphasized the
 importance of describing a language by focusing on the language's
 primitives, its means of combination, and its means of abstraction.
 We'll follow that framework here.</p><p>
 
 Part of the elegance of this picture language is that there is
-only one kind of element, called a <a name="%_idx_1862" id="%_idx_1862"></a><em>painter</em>.  A painter
+only one kind of element, called a <a id="__idx_1862"></a><em>painter</em>.  A painter
 draws an image that is shifted and scaled to fit within a designated
-<a name="%_idx_1864" id="%_idx_1864"></a>parallelogram-shaped frame.  For example, there's a primitive painter
+<a id="__idx_1864"></a>parallelogram-shaped frame.  For example, there's a primitive painter
 we'll call <tt>wave</tt> that makes a crude line drawing, as
-shown in figure <a href="#%_fig_2.10">2.10</a>.
+shown in figure <a href="#__fig_2.10">2.10</a>.
 The actual shape of the drawing depends on the frame – all
-four images in figure <a href="#%_fig_2.10">2.10</a> are produced by the same <tt>wave</tt> painter, but with respect to four different frames.  Painters
+four images in figure <a href="#__fig_2.10">2.10</a> are produced by the same <tt>wave</tt> painter, but with respect to four different frames.  Painters
 can be more elaborate than this:
 The primitive
 painter called <tt>rogers</tt> paints a picture of MIT's founder,
-William Barton Rogers, as shown in figure <a href="#%_fig_2.11">2.11</a>.<a name="call_footnote_Temp_204" href="#footnote_Temp_204" id="call_footnote_Temp_204"><sup><small>23</small></sup></a>
-The four images in figure <a href="#%_fig_2.11">2.11</a>
+William Barton Rogers, as shown in figure <a href="#__fig_2.11">2.11</a>.<a href="#footnote_Temp_204" id="call_footnote_Temp_204"><sup><small>23</small></sup></a>
+The four images in figure <a href="#__fig_2.11">2.11</a>
 are drawn with respect to the same four frames
-as the <tt>wave</tt> images in figure <a href="#%_fig_2.10">2.10</a>.</p><p>
+as the <tt>wave</tt> images in figure <a href="#__fig_2.10">2.10</a>.</p><p>
 
 
-<a name="%_idx_1876" id="%_idx_1876"></a>To combine images,
+<a id="__idx_1876"></a>To combine images,
 we use various operations that construct new painters
 from given painters.
-For example, the <a name="%_idx_1878" id="%_idx_1878"></a><tt>beside</tt> operation takes two painters and produces a new,
+For example, the <a id="__idx_1878"></a><tt>beside</tt> operation takes two painters and produces a new,
 compound painter that draws the first painter's image in the left half
 of the frame and the second painter's image in the right half of the frame.
-Similarly, <a name="%_idx_1880" id="%_idx_1880"></a><tt>below</tt> takes two painters and produces a compound
+Similarly, <a id="__idx_1880"></a><tt>below</tt> takes two painters and produces a compound
 painter that draws the first painter's image below the second
 painter's image.
 Some operations transform a single painter to produce
-a new painter.  For example, <a name="%_idx_1882" id="%_idx_1882"></a><tt>flip-vert</tt> takes a painter and
+a new painter.  For example, <a id="__idx_1882"></a><tt>flip-vert</tt> takes a painter and
 produces a painter that draws its image upside-down, and
-<a name="%_idx_1884" id="%_idx_1884"></a><tt>flip-horiz</tt> produces a painter that draws the original
+<a id="__idx_1884"></a><tt>flip-horiz</tt> produces a painter that draws the original
 painter's image left-to-right reversed.</p><p>
 
-<a name="%_fig_2.10" id="%_fig_2.10"></a></p><p></p><div align="left"><table width="100%"><tr><td><div align="left"><img src="images/ch2-Z-G-26.gif" border="0" />
+<a id="__fig_2.10"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><div style="text-align: left;"><img src="images/ch2-Z-G-26.gif" alt="ch2-Z-G-26" style="border: none;" />
           
-<img src="images/ch2-Z-G-27.gif" border="0" /> </div>
+<img src="images/ch2-Z-G-27.gif" alt="ch2-Z-G-27" style="border: none;" /> </div>
 
-<div align="left"><img src="images/ch2-Z-G-28.gif" border="0" />
+<div style="text-align: left;"><img src="images/ch2-Z-G-28.gif" alt="ch2-Z-G-28" style="border: none;" />
           
-<img src="images/ch2-Z-G-29.gif" border="0" /> </div>
+<img src="images/ch2-Z-G-29.gif" alt="ch2-Z-G-29" style="border: none;" /> </div>
 
-</td></tr><caption align="bottom"><div align="left"><b>Figure 2.10:</b>  Images produced by the <tt>wave</tt> painter, with respect
+</td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.10:</b>  Images produced by the <tt>wave</tt> painter, with respect
 to four different frames.  The frames, shown with dotted lines, are not
 part of the images.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_fig_2.11" id="%_fig_2.11"></a></p><p></p><div align="left"><table width="100%"><tr><td><div align="left"><img src="images/ch2-Z-G-30.gif" border="0" />
+<a id="__fig_2.11"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><div style="text-align: left;"><img src="images/ch2-Z-G-30.gif" alt="ch2-Z-G-30" style="border: none;" />
           
-<img src="images/ch2-Z-G-31.gif" border="0" /> </div>
+<img src="images/ch2-Z-G-31.gif" alt="ch2-Z-G-31" style="border: none;" /> </div>
 
-<div align="left"><img src="images/ch2-Z-G-32.gif" border="0" />
+<div style="text-align: left;"><img src="images/ch2-Z-G-32.gif" alt="ch2-Z-G-32" style="border: none;" />
           
-<img src="images/ch2-Z-G-33.gif" border="0" /> </div>
+<img src="images/ch2-Z-G-33.gif" alt="ch2-Z-G-33" style="border: none;" /> </div>
 
-</td></tr><caption align="bottom"><div align="left"><b>Figure 2.11:</b>  Images of William Barton Rogers, founder and first
+</td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.11:</b>  Images of William Barton Rogers, founder and first
 president of MIT, painted with respect to the same four frames as in
-figure <a href="#%_fig_2.10">2.10</a> (original image reprinted with the permission
+figure <a href="#__fig_2.10">2.10</a> (original image reprinted with the permission
 of the MIT Museum).</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
 
-Figure <a href="#%_fig_2.12">2.12</a> shows the drawing of a painter called
+Figure <a href="#__fig_2.12">2.12</a> shows the drawing of a painter called
 <tt>wave4</tt> that is built up in two stages starting from <tt>wave</tt>:
 </p><p></p><p><tt>(define wave2 (beside wave (flip-vert wave)))<br />
 (define wave4 (below wave2 wave2))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_fig_2.12" id="%_fig_2.12"></a></p><p></p><div align="left"><table width="100%"><tr><td><div align="left"><img src="images/ch2-Z-G-34.gif" border="0" />
+<a id="__fig_2.12"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><div style="text-align: left;"><img src="images/ch2-Z-G-34.gif" alt="ch2-Z-G-34" style="border: none;" />
           
-<img src="images/ch2-Z-G-35.gif" border="0" /> </div>
+<img src="images/ch2-Z-G-35.gif" alt="ch2-Z-G-35" style="border: none;" /> </div>
 
 <p></p><p><tt>(define wave2                         (define wave4<br />
   (beside wave (flip-vert wave)))       (below wave2 wave2))<br /></tt></p><p></p><p>
-</p><p></p><p></p></td></tr><caption align="bottom"><div align="left"><b>Figure 2.12:</b>  Creating a complex figure,
-starting from the <tt>wave</tt> painter of figure <a href="#%_fig_2.10">2.10</a>.</div></caption><tr><td>
+</p><p></p><p></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.12:</b>  Creating a complex figure,
+starting from the <tt>wave</tt> painter of figure <a href="#__fig_2.10">2.10</a>.</div></caption><tr><td>
 
 </td></tr></table></div><p> </p><p>
 
-<a name="%_idx_1886" id="%_idx_1886"></a>In building up a complex image in this manner we are exploiting the
+<a id="__idx_1886"></a>In building up a complex image in this manner we are exploiting the
 fact that painters are closed under the language's means of
 combination.  The <tt>beside</tt> or <tt>below</tt> of two painters is
 itself a painter; therefore, we can use it as an element in making
@@ -1433,7 +1433,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 For example, we can abstract the pattern in <tt>wave4</tt> as</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_1888" id="%_idx_1888"></a>(define (flipped-pairs painter)<br />
+</p><p></p><p><tt><a id="__idx_1888"></a>(define (flipped-pairs painter)<br />
   (let ((painter2 (beside painter (flip-vert painter))))<br />
     (below painter2 painter2)))<br /></tt></p><p></p><p>
 and define <tt>wave4</tt> as an instance of this pattern:</p><p>
@@ -1443,28 +1443,28 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 We can also define recursive operations.
 Here's one that makes painters split and branch
-towards the right as shown in figures <a href="#%_fig_2.13">2.13</a>
-and  <a href="#%_fig_2.14">2.14</a>:
-</p><p></p><p><tt><a name="%_idx_1890" id="%_idx_1890"></a>(define (right-split painter n)<br />
+towards the right as shown in figures <a href="#__fig_2.13">2.13</a>
+and  <a href="#__fig_2.14">2.14</a>:
+</p><p></p><p><tt><a id="__idx_1890"></a>(define (right-split painter n)<br />
   (if (= n 0)<br />
       painter<br />
       (let ((smaller (right-split painter (- n 1))))<br />
         (beside painter (below smaller smaller)))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_fig_2.13" id="%_fig_2.13"></a></p><p></p><div align="left"><table width="100%"><tr><td><div align="left"><img src="images/ch2-Z-G-36.gif" border="0" />
+<a id="__fig_2.13"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><div style="text-align: left;"><img src="images/ch2-Z-G-36.gif" alt="ch2-Z-G-36" style="border: none;" />
                    
-<img src="images/ch2-Z-G-37.gif" border="0" /> </div>
+<img src="images/ch2-Z-G-37.gif" alt="ch2-Z-G-37" style="border: none;" /> </div>
 
 <p></p><p><tt>     right-split <em>n</em>                   corner-split <em>n</em><br /></tt></p><p></p><p>
-</p><p></p><p></p></td></tr><caption align="bottom"><div align="left"><b>Figure 2.13:</b>  Recursive plans for <tt>right-split</tt> and <tt>corner-split</tt>.</div></caption><tr><td>
+</p><p></p><p></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.13:</b>  Recursive plans for <tt>right-split</tt> and <tt>corner-split</tt>.</div></caption><tr><td>
 
 </td></tr></table></div><p> </p><p>
 
 We can produce balanced patterns by branching upwards
-as well as towards the right (see exercise <a href="#%_thm_2.44">2.44</a>
-and figures <a href="#%_fig_2.13">2.13</a> and  <a href="#%_fig_2.14">2.14</a>):</p><p>
+as well as towards the right (see exercise <a href="#__thm_2.44">2.44</a>
+and figures <a href="#__fig_2.13">2.13</a> and  <a href="#__fig_2.14">2.14</a>):</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1892" id="%_idx_1892"></a>(define (corner-split painter n)<br />
+</p><p></p><p><tt><a id="__idx_1892"></a>(define (corner-split painter n)<br />
   (if (= n 0)<br />
       painter<br />
       (let ((up (up-split painter (- n 1)))<br />
@@ -1475,44 +1475,44 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
           (beside (below painter top-left)<br />
                   (below bottom-right corner))))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_fig_2.14" id="%_fig_2.14"></a></p><p></p><div align="left"><table width="100%"><tr><td><div align="left"><img src="images/ch2-Z-G-38.gif" border="0" />
+<a id="__fig_2.14"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><div style="text-align: left;"><img src="images/ch2-Z-G-38.gif" alt="ch2-Z-G-38" style="border: none;" />
           
-<img src="images/ch2-Z-G-39.gif" border="0" /> </div>
+<img src="images/ch2-Z-G-39.gif" alt="ch2-Z-G-39" style="border: none;" /> </div>
 
 <p></p><p><tt>     (right-split wave 4)         (right-split rogers 4)<br /></tt></p><p></p><p>
-</p><p></p><p></p><div align="left"><img src="images/ch2-Z-G-40.gif" border="0" />
+</p><p></p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-40.gif" alt="ch2-Z-G-40" style="border: none;" />
           
-<img src="images/ch2-Z-G-41.gif" border="0" /> </div>
+<img src="images/ch2-Z-G-41.gif" alt="ch2-Z-G-41" style="border: none;" /> </div>
 
 <p></p><p><tt>    (corner-split wave 4)         (corner-split rogers 4)<br /></tt></p><p></p><p>
-</p><p></p><p></p></td></tr><caption align="bottom"><div align="left"><b>Figure 2.14:</b>  The recursive operations <tt>right-split</tt> and <tt>corner-split</tt> applied to the painters <tt>wave</tt> and <tt>rogers</tt>.
+</p><p></p><p></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.14:</b>  The recursive operations <tt>right-split</tt> and <tt>corner-split</tt> applied to the painters <tt>wave</tt> and <tt>rogers</tt>.
 Combining four <tt>corner-split</tt> figures produces
 symmetric <tt>square-limit</tt> designs as shown
-in figure <a href="#%_fig_2.9">2.9</a>.</div></caption><tr><td>
+in figure <a href="#__fig_2.9">2.9</a>.</div></caption><tr><td>
 
 </td></tr></table></div><p> </p><p>
 
 By placing four copies of a <tt>corner-split</tt>
 appropriately, we obtain a pattern called <tt>square-limit</tt>, whose
 application to <tt>wave</tt> and <tt>rogers</tt> is shown in
-figure <a href="#%_fig_2.9">2.9</a>:
-</p><p></p><p><tt><a name="%_idx_1894" id="%_idx_1894"></a>(define (square-limit painter n)<br />
+figure <a href="#__fig_2.9">2.9</a>:
+</p><p></p><p><tt><a id="__idx_1894"></a>(define (square-limit painter n)<br />
   (let ((quarter (corner-split painter n)))<br />
     (let ((half (beside (flip-horiz quarter) quarter)))<br />
       (below (flip-vert half) half))))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_2.44" id="%_thm_2.44"></a>
-<b>Exercise 2.44.</b>  Define the procedure <a name="%_idx_1896" id="%_idx_1896"></a><tt>up-split</tt> used by <tt>corner-split</tt>.
+</p><p><a id="__thm_2.44"></a>
+<b>Exercise 2.44.</b>  Define the procedure <a id="__idx_1896"></a><tt>up-split</tt> used by <tt>corner-split</tt>.
 It is similar to <tt>right-split</tt>, except that it switches the
 roles of <tt>below</tt> and <tt>beside</tt>.
 
 </p><p></p><p>
 
 
-<a name="%_sec_Temp_206" id="%_sec_Temp_206"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_206">Higher-order operations</a></h4><p>
+<a id="__sec_Temp_206"></a>
+</p><h4>Higher-order operations</h4><p>
 
-<a name="%_idx_1898" id="%_idx_1898"></a>
+<a id="__idx_1898"></a>
 In addition to abstracting patterns of combining painters, we can work
 at a higher level, abstracting patterns of combining painter operations.
 That is, we can view the painter operations as elements to manipulate
@@ -1530,29 +1530,29 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 transformations to apply to the top left copy, the top right copy,
 the bottom left copy, and the bottom right copy, respectively.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1900" id="%_idx_1900"></a>(define (square-of-four tl tr bl br)<br />
+</p><p></p><p><tt><a id="__idx_1900"></a>(define (square-of-four tl tr bl br)<br />
   (lambda (painter)<br />
     (let ((top (beside (tl painter) (tr painter)))<br />
           (bottom (beside (bl painter) (br painter))))<br />
       (below bottom top))))<br /></tt></p><p></p><p>
 Then <tt>flipped-pairs</tt> can be defined in terms
-of <tt>square-of-four</tt> as follows:<a name="call_footnote_Temp_207" href="#footnote_Temp_207" id="call_footnote_Temp_207"><sup><small>24</small></sup></a></p><p>
+of <tt>square-of-four</tt> as follows:<a href="#footnote_Temp_207" id="call_footnote_Temp_207"><sup><small>24</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_1904" id="%_idx_1904"></a>(define (flipped-pairs painter)<br />
+</p><p></p><p><tt><a id="__idx_1904"></a>(define (flipped-pairs painter)<br />
   (let ((combine4 (square-of-four identity flip-vert<br />
                                   identity flip-vert)))<br />
     (combine4 painter)))<br /></tt></p><p></p><p>
-and <tt>square-limit</tt> can be expressed as<a name="call_footnote_Temp_208" href="#footnote_Temp_208" id="call_footnote_Temp_208"><sup><small>25</small></sup></a></p><p>
+and <tt>square-limit</tt> can be expressed as<a href="#footnote_Temp_208" id="call_footnote_Temp_208"><sup><small>25</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_1906" id="%_idx_1906"></a>(define (square-limit painter n)<br />
+</p><p></p><p><tt><a id="__idx_1906"></a>(define (square-limit painter n)<br />
   (let ((combine4 (square-of-four flip-horiz identity<br />
                                   rotate180 flip-vert)))<br />
     (combine4 (corner-split painter n))))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_2.45" id="%_thm_2.45"></a>
+</p><p><a id="__thm_2.45"></a>
 <b>Exercise 2.45.</b>  <tt>Right-split</tt> and <tt>up-split</tt> can be expressed as
 instances of a general splitting operation.
-Define a procedure <a name="%_idx_1908" id="%_idx_1908"></a><tt>split</tt> with the property that evaluating
+Define a procedure <a id="__idx_1908"></a><tt>split</tt> with the property that evaluating
 </p><p></p><p><tt>(define right-split (split beside below))<br />
 (define up-split (split below beside))<br /></tt></p><p></p><p>
 produces procedures <tt>right-split</tt> and <tt>up-split</tt> with the same
@@ -1560,44 +1560,44 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 </p><p></p><p>
 
-<a name="%_sec_Temp_210" id="%_sec_Temp_210"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_210">Frames</a></h4><p>
+<a id="__sec_Temp_210"></a>
+</p><h4>Frames</h4><p>
 
-<a name="%_idx_1910" id="%_idx_1910"></a>
+<a id="__idx_1910"></a>
 Before we can show how to implement painters and their
 means of combination, we must first consider
-<a name="%_idx_1912" id="%_idx_1912"></a>frames.  A frame can be described by three vectors – an origin vector
+<a id="__idx_1912"></a>frames.  A frame can be described by three vectors – an origin vector
 and two edge vectors.  The origin vector specifies the offset of the
 frame's origin from some absolute origin in the plane, and the edge
 vectors specify the offsets of the frame's corners from its origin.
 If the edges are perpendicular, the frame will be rectangular.
 Otherwise the frame will be a more general parallelogram.</p><p>
 
-Figure <a href="#%_fig_2.15">2.15</a> shows a frame and its associated vectors.  In
+Figure <a href="#__fig_2.15">2.15</a> shows a frame and its associated vectors.  In
 accordance with data abstraction, we need not be
 specific yet about how frames are represented, other than to say that
-there is a constructor <a name="%_idx_1914" id="%_idx_1914"></a><tt>make-frame</tt>, which takes three vectors and
-produces a frame, and three corresponding selectors <a name="%_idx_1916" id="%_idx_1916"></a><tt>origin-frame</tt>, <a name="%_idx_1918" id="%_idx_1918"></a><tt>edge1-frame</tt>, and <a name="%_idx_1920" id="%_idx_1920"></a><tt>edge2-frame</tt> (see
-exercise <a href="#%_thm_2.47">2.47</a>).</p><p>
+there is a constructor <a id="__idx_1914"></a><tt>make-frame</tt>, which takes three vectors and
+produces a frame, and three corresponding selectors <a id="__idx_1916"></a><tt>origin-frame</tt>, <a id="__idx_1918"></a><tt>edge1-frame</tt>, and <a id="__idx_1920"></a><tt>edge2-frame</tt> (see
+exercise <a href="#__thm_2.47">2.47</a>).</p><p>
 
-<a name="%_fig_2.15" id="%_fig_2.15"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch2-Z-G-42.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 2.15:</b>  A frame is described by three vectors – an
+<a id="__fig_2.15"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch2-Z-G-42.gif" alt="ch2-Z-G-42" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.15:</b>  A frame is described by three vectors – an
 origin and two edges.</div></caption><tr><td>
 
 </td></tr></table></div><p> </p><p>
 
-<a name="%_idx_1922" id="%_idx_1922"></a>We will use coordinates in the unit square (0<u>&lt;</u> <em>x</em>,<em>y</em><u>&lt;</u> 1)
+<a id="__idx_1922"></a>We will use coordinates in the unit square (0<u>&lt;</u> <em>x</em>,<em>y</em><u>&lt;</u> 1)
 to specify images.
-With each frame, we associate a <a name="%_idx_1924" id="%_idx_1924"></a><em>frame coordinate map</em>, which
+With each frame, we associate a <a id="__idx_1924"></a><em>frame coordinate map</em>, which
 will be used to shift and scale images to fit the frame.  The map
 transforms the unit square into the frame by
 mapping the vector <strong><em>v</em></strong> = (<em>x</em>,<em>y</em>) to the vector sum
-</p><p></p><div align="left"><img src="images/ch2-Z-G-43.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-43.gif" alt="ch2-Z-G-43" style="border: none;" /></div><p>
 For example, (0,0) is mapped to the origin of the frame, (1,1) to
 the vertex diagonally opposite the origin, and (0.5,0.5) to the
 center of the frame.  We can create a frame's coordinate map with the
-following procedure:<a name="call_footnote_Temp_211" href="#footnote_Temp_211" id="call_footnote_Temp_211"><sup><small>26</small></sup></a></p><p>
+following procedure:<a href="#footnote_Temp_211" id="call_footnote_Temp_211"><sup><small>26</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_1926" id="%_idx_1926"></a>(define (frame-coord-map frame)<br />
+</p><p></p><p><tt><a id="__idx_1926"></a>(define (frame-coord-map frame)<br />
   (lambda (v)<br />
     (add-vect<br />
      (origin-frame frame)<br />
@@ -1613,13 +1613,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 returns the same vector as
 </p><p></p><p><tt>(origin-frame a-frame)<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_2.46" id="%_thm_2.46"></a>
-<b>Exercise 2.46.</b>  <a name="%_idx_1928" id="%_idx_1928"></a><a name="%_idx_1930" id="%_idx_1930"></a>A two-dimensional vector <strong>v</strong> running from the origin to a point
+</p><p><a id="__thm_2.46"></a>
+<b>Exercise 2.46.</b>  <a id="__idx_1928"></a><a id="__idx_1930"></a>A two-dimensional vector <strong>v</strong> running from the origin to a point
 can be represented as a pair
 consisting of an <em>x</em>-coordinate and a <em>y</em>-coordinate.  Implement a data
-abstraction for vectors by giving a constructor <a name="%_idx_1932" id="%_idx_1932"></a><tt>make-vect</tt> and
-corresponding selectors <a name="%_idx_1934" id="%_idx_1934"></a><tt>xcor-vect</tt> and <a name="%_idx_1936" id="%_idx_1936"></a><tt>ycor-vect</tt>.  In
-terms of your selectors and constructor, implement procedures <a name="%_idx_1938" id="%_idx_1938"></a><tt>add-vect</tt>, <a name="%_idx_1940" id="%_idx_1940"></a><tt>sub-vect</tt>, and <a name="%_idx_1942" id="%_idx_1942"></a><tt>scale-vect</tt> that perform
+abstraction for vectors by giving a constructor <a id="__idx_1932"></a><tt>make-vect</tt> and
+corresponding selectors <a id="__idx_1934"></a><tt>xcor-vect</tt> and <a id="__idx_1936"></a><tt>ycor-vect</tt>.  In
+terms of your selectors and constructor, implement procedures <a id="__idx_1938"></a><tt>add-vect</tt>, <a id="__idx_1940"></a><tt>sub-vect</tt>, and <a id="__idx_1942"></a><tt>scale-vect</tt> that perform
 the operations vector addition, vector subtraction, and multiplying a
 vector by a scalar:</p>
 
@@ -1629,9 +1629,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
     <em>s</em> · (<em>x</em>, <em>y</em>) = (<em>sx</em>, <em>sy</em>)
 </p>
 
-<p><a name="%_thm_2.47" id="%_thm_2.47"></a>
+<p><a id="__thm_2.47"></a>
 <b>Exercise 2.47.</b>  Here are two possible constructors for frames:
-</p><p></p><p><tt><a name="%_idx_1944" id="%_idx_1944"></a>(define (make-frame origin edge1 edge2)<br />
+</p><p></p><p><tt><a id="__idx_1944"></a>(define (make-frame origin edge1 edge2)<br />
   (list origin edge1 edge2))<br /><br />
 (define (make-frame origin edge1 edge2)<br />
   (cons origin (cons edge1 edge2)))<br /></tt></p><p></p><p>
@@ -1640,10 +1640,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 </p><p></p><p>
 
-<a name="%_sec_Temp_214" id="%_sec_Temp_214"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_214">Painters</a></h4><p>
+<a id="__sec_Temp_214"></a>
+</p><h4>Painters</h4><p>
 
-<a name="%_idx_1946" id="%_idx_1946"></a>
+<a id="__idx_1946"></a>
 A painter is represented as a procedure that, given a frame
 as argument, draws a particular image shifted and scaled to fit the frame.
 That is to say, if <tt>p</tt> is a painter and <tt>f</tt> is a frame, then we
@@ -1652,10 +1652,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 The details of how primitive painters are implemented depend on the
 particular characteristics of the graphics system and the type of
-image to be drawn.  For instance, suppose we have a procedure <a name="%_idx_1948" id="%_idx_1948"></a><tt>draw-line</tt> that draws a line on the screen between two specified
+image to be drawn.  For instance, suppose we have a procedure <a id="__idx_1948"></a><tt>draw-line</tt> that draws a line on the screen between two specified
 points.  Then we can create painters for line drawings, such as the
-<tt>wave</tt> painter in figure <a href="#%_fig_2.10">2.10</a>, from lists of line
-segments as follows:<a name="call_footnote_Temp_215" href="#footnote_Temp_215" id="call_footnote_Temp_215"><sup><small>27</small></sup></a></p><p></p><p><tt><a name="%_idx_1950" id="%_idx_1950"></a>(define (segments-&gt;painter segment-list)<br />
+<tt>wave</tt> painter in figure <a href="#__fig_2.10">2.10</a>, from lists of line
+segments as follows:<a href="#footnote_Temp_215" id="call_footnote_Temp_215"><sup><small>27</small></sup></a></p><p></p><p><tt><a id="__idx_1950"></a>(define (segments-&gt;painter segment-list)<br />
   (lambda (frame)<br />
     (for-each<br />
      (lambda (segment)<br />
@@ -1673,19 +1673,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 all sorts of primitive painters, based on a variety of graphics
 capabilities. The details of their implementation do not matter.  Any
 procedure can serve as a painter, provided that it takes a frame as
-argument and draws something scaled to fit the frame.<a name="call_footnote_Temp_216" href="#footnote_Temp_216" id="call_footnote_Temp_216"><sup><small>28</small></sup></a>
+argument and draws something scaled to fit the frame.<a href="#footnote_Temp_216" id="call_footnote_Temp_216"><sup><small>28</small></sup></a>
 
-</p><p><a name="%_thm_2.48" id="%_thm_2.48"></a>
-<b>Exercise 2.48.</b>  <a name="%_idx_1952" id="%_idx_1952"></a>A directed line segment in the
+</p><p><a id="__thm_2.48"></a>
+<b>Exercise 2.48.</b>  <a id="__idx_1952"></a>A directed line segment in the
 plane can be represented as a pair of vectors – the
 vector running from the origin to the start-point of the segment, and
 the vector running from the origin to the end-point of the segment.
-Use your vector representation from exercise <a href="#%_thm_2.46">2.46</a> to
-define a representation for segments with a constructor <a name="%_idx_1954" id="%_idx_1954"></a><tt>make-segment</tt> and selectors <a name="%_idx_1956" id="%_idx_1956"></a><tt>start-segment</tt> and <a name="%_idx_1958" id="%_idx_1958"></a><tt>end-segment</tt>.
+Use your vector representation from exercise <a href="#__thm_2.46">2.46</a> to
+define a representation for segments with a constructor <a id="__idx_1954"></a><tt>make-segment</tt> and selectors <a id="__idx_1956"></a><tt>start-segment</tt> and <a id="__idx_1958"></a><tt>end-segment</tt>.
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.49" id="%_thm_2.49"></a>
+</p><p><a id="__thm_2.49"></a>
 <b>Exercise 2.49.</b>  Use <tt>segments-&gt;painter</tt> to define the following primitive painters:</p><p>
 
 a.  The painter that draws the outline of the designated frame.</p><p>
@@ -1700,10 +1700,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 </p><p></p><p>
 
-<a name="%_sec_Temp_219" id="%_sec_Temp_219"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_219">Transforming and combining painters</a></h4><p>
+<a id="__sec_Temp_219"></a>
+</p><h4>Transforming and combining painters</h4><p>
 
-<a name="%_idx_1960" id="%_idx_1960"></a>
+<a id="__idx_1960"></a>
 An operation on painters (such as <tt>flip-vert</tt> or <tt>beside</tt>)
 works by creating a painter that invokes the original painters
 with respect to frames derived from the argument frame.
@@ -1727,7 +1727,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 Thus, arguments within the
 unit square specify a frame contained within the original frame.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1962" id="%_idx_1962"></a>(define (transform-painter painter origin corner1 corner2)<br />
+</p><p></p><p><tt><a id="__idx_1962"></a>(define (transform-painter painter origin corner1 corner2)<br />
   (lambda (frame)<br />
     (let ((m (frame-coord-map frame)))<br />
       (let ((new-origin (m origin)))<br />
@@ -1737,7 +1737,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
                      (sub-vect (m corner2) new-origin)))))))<br /></tt></p><p></p><p></p><p>
 
 Here's how to flip painter images vertically:
-</p><p></p><p><tt><a name="%_idx_1964" id="%_idx_1964"></a>(define (flip-vert painter)<br />
+</p><p></p><p><tt><a id="__idx_1964"></a>(define (flip-vert painter)<br />
   (transform-painter painter<br />
                      (make-vect 0.0 1.0)   <em>; new <tt>origin</tt></em><br />
                      (make-vect 1.0 1.0)   <em>; new end of <tt>edge1</tt></em><br />
@@ -1745,19 +1745,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 Using <tt>transform-painter</tt>, we can easily define new transformations.
 For example, we can define a painter that shrinks its image to the
 upper-right quarter of the frame it is given:
-</p><p></p><p><tt><a name="%_idx_1966" id="%_idx_1966"></a>(define (shrink-to-upper-right painter)<br />
+</p><p></p><p><tt><a id="__idx_1966"></a>(define (shrink-to-upper-right painter)<br />
   (transform-painter painter<br />
                      (make-vect 0.5 0.5)<br />
                      (make-vect 1.0 0.5)<br />
                      (make-vect 0.5 1.0)))<br /></tt></p><p></p><p>
-Other transformations rotate images counterclockwise by 90 degrees<a name="call_footnote_Temp_220" href="#footnote_Temp_220" id="call_footnote_Temp_220"><sup><small>29</small></sup></a>
-</p><p></p><p><tt><a name="%_idx_1968" id="%_idx_1968"></a>(define (rotate90 painter)<br />
+Other transformations rotate images counterclockwise by 90 degrees<a href="#footnote_Temp_220" id="call_footnote_Temp_220"><sup><small>29</small></sup></a>
+</p><p></p><p><tt><a id="__idx_1968"></a>(define (rotate90 painter)<br />
   (transform-painter painter<br />
                      (make-vect 1.0 0.0)<br />
                      (make-vect 1.0 1.0)<br />
                      (make-vect 0.0 0.0)))<br /></tt></p><p></p><p>
-or squash images towards the center of the frame:<a name="call_footnote_Temp_221" href="#footnote_Temp_221" id="call_footnote_Temp_221"><sup><small>30</small></sup></a>
-</p><p></p><p><tt><a name="%_idx_1970" id="%_idx_1970"></a>(define (squash-inwards painter)<br />
+or squash images towards the center of the frame:<a href="#footnote_Temp_221" id="call_footnote_Temp_221"><sup><small>30</small></sup></a>
+</p><p></p><p><tt><a id="__idx_1970"></a>(define (squash-inwards painter)<br />
   (transform-painter painter<br />
                      (make-vect 0.0 0.0)<br />
                      (make-vect 0.65 0.35)<br />
@@ -1773,7 +1773,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 calls the first transformed painter to paint in the left half of
 the frame and calls the second transformed painter to paint in the
 right half of the frame:
-</p><p></p><p><tt><a name="%_idx_1972" id="%_idx_1972"></a>(define (beside painter1 painter2)<br />
+</p><p></p><p><tt><a id="__idx_1972"></a>(define (beside painter1 painter2)<br />
   (let ((split-point (make-vect 0.5 0.0)))<br />
     (let ((paint-left<br />
            (transform-painter painter1<br />
@@ -1795,26 +1795,26 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 about the details of the component painters other than that each
 painter will draw something in its designated frame.</p><p>
 
-</p><p><a name="%_thm_2.50" id="%_thm_2.50"></a>
-<b>Exercise 2.50.</b>  Define the transformation <a name="%_idx_1974" id="%_idx_1974"></a><tt>flip-horiz</tt>, which flips
+</p><p><a id="__thm_2.50"></a>
+<b>Exercise 2.50.</b>  Define the transformation <a id="__idx_1974"></a><tt>flip-horiz</tt>, which flips
 painters horizontally, and transformations that rotate
 painters counterclockwise by 180 degrees and 270 degrees.
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.51" id="%_thm_2.51"></a>
-<b>Exercise 2.51.</b>  Define the <a name="%_idx_1976" id="%_idx_1976"></a><tt>below</tt> operation for painters.  <tt>Below</tt> takes two
+</p><p><a id="__thm_2.51"></a>
+<b>Exercise 2.51.</b>  Define the <a id="__idx_1976"></a><tt>below</tt> operation for painters.  <tt>Below</tt> takes two
 painters as arguments.  The resulting painter, given a frame,
 draws with the first painter in the
 bottom of the frame and with the second painter in the top.  Define <tt>below</tt> in two different ways – first by writing a procedure that is
 analogous to the <tt>beside</tt> procedure given above, and
 again in terms of <tt>beside</tt> and suitable
-rotation operations (from exercise <a href="#%_thm_2.50">2.50</a>).
+rotation operations (from exercise <a href="#__thm_2.50">2.50</a>).
 
 </p><p></p><p>
 
-<a name="%_sec_Temp_224" id="%_sec_Temp_224"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_224">Levels of language for robust design</a></h4><p>
+<a id="__sec_Temp_224"></a>
+</p><h4>Levels of language for robust design</h4><p>
 
 The picture language exercises some of the critical ideas
 we've introduced about abstraction with procedures and data.  The
@@ -1828,7 +1828,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 
 We have also obtained a glimpse of another crucial idea about
-languages and program design.  This is the approach of <a name="%_idx_1978" id="%_idx_1978"></a><a name="%_idx_1980" id="%_idx_1980"></a><em>stratified
+languages and program design.  This is the approach of <a id="__idx_1978"></a><a id="__idx_1980"></a><em>stratified
 design</em>, the notion that a complex system should be structured as a
 sequence of levels that are described using a sequence of languages.
 Each level is constructed by combining parts that are regarded as
@@ -1841,7 +1841,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 example, in computer engineering, resistors and transistors are
 combined (and described using a language of analog circuits) to
 produce parts such as and-gates and or-gates, which form the
-primitives of a language for digital-circuit design.<a name="call_footnote_Temp_225" href="#footnote_Temp_225" id="call_footnote_Temp_225"><sup><small>31</small></sup></a>
+primitives of a language for digital-circuit design.<a href="#footnote_Temp_225" id="call_footnote_Temp_225"><sup><small>31</small></sup></a>
 These parts are combined to build
 processors, bus structures, and memory systems, which are in turn
 combined to form computers, using languages appropriate to computer
@@ -1860,11 +1860,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 operations, such as <tt>square-of-four</tt>, capture common patterns of
 combining geometric combiners.</p><p>
 
-<a name="%_idx_1982" id="%_idx_1982"></a>Stratified design helps make programs <em>robust</em>, that is, it makes
+<a id="__idx_1982"></a>Stratified design helps make programs <em>robust</em>, that is, it makes
 it likely that small changes in a specification will require
 correspondingly small changes in the program.  For instance, suppose
 we wanted to change the image based on <tt>wave</tt> shown in
-figure <a href="#%_fig_2.9">2.9</a>.  We could work at the lowest level
+figure <a href="#__fig_2.9">2.9</a>.  We could work at the lowest level
 to change the detailed appearance of the <tt>wave</tt> element; we could
 work at the middle level to change the way <tt>corner-split</tt>
 replicates the <tt>wave</tt>; we could work at the highest level to
@@ -1873,13 +1873,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 vocabulary for expressing the characteristics of the system, and a
 different kind of ability to change it.</p><p>
 
-</p><p><a name="%_thm_2.52" id="%_thm_2.52"></a>
+</p><p><a id="__thm_2.52"></a>
 <b>Exercise 2.52.</b>  Make changes to the square limit of <tt>wave</tt> shown in
-figure <a href="#%_fig_2.9">2.9</a> by working at each of the levels
+figure <a href="#__fig_2.9">2.9</a> by working at each of the levels
 described above.  In particular:</p><p>
 
 a.  Add some segments to the primitive <tt>wave</tt> painter
-of exercise  <a href="#%_thm_2.49">2.49</a> (to add a smile, for example).</p><p>
+of exercise  <a href="#__thm_2.49">2.49</a> (to add a smile, for example).</p><p>
 
 b.  Change the pattern constructed by <tt>corner-split</tt>
 (for example, by using only one copy of the
@@ -1891,7 +1891,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 </p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_154" href="#call_footnote_Temp_154" id="footnote_Temp_154"><sup><small>6</small></sup></a> The use of the word <a name="%_idx_1536" id="%_idx_1536"></a>“closure” here comes from abstract algebra,
+</p><div class="footnote"><p><a href="#call_footnote_Temp_154" id="footnote_Temp_154"><sup><small>6</small></sup></a> The use of the word <a id="__idx_1536"></a>“closure” here comes from abstract algebra,
 where a set of elements is said to be closed under an operation if
 applying the operation to elements in the set produces an element that
 is again an element of the set.  The Lisp community
@@ -1900,66 +1900,66 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 procedures with free variables.  We do not use the word “closure” in
 this second sense in this book.
 
-</p><p><a name="footnote_Temp_155" href="#call_footnote_Temp_155" id="footnote_Temp_155"><sup><small>7</small></sup></a> The notion that a means of
-<a name="%_idx_1542" id="%_idx_1542"></a>combination should satisfy closure is a straightforward idea.
+</p><p><a href="#call_footnote_Temp_155" id="footnote_Temp_155"><sup><small>7</small></sup></a> The notion that a means of
+<a id="__idx_1542"></a>combination should satisfy closure is a straightforward idea.
 Unfortunately, the data combiners provided in many popular programming
 languages do not satisfy closure, or make closure cumbersome to
-exploit.  In <a name="%_idx_1544" id="%_idx_1544"></a>Fortran or <a name="%_idx_1546" id="%_idx_1546"></a>Basic, one typically combines data elements by
+exploit.  In <a id="__idx_1544"></a>Fortran or <a id="__idx_1546"></a>Basic, one typically combines data elements by
 assembling them into arrays – but one cannot form arrays whose
-elements are themselves arrays.  <a name="%_idx_1548" id="%_idx_1548"></a>Pascal and <a name="%_idx_1550" id="%_idx_1550"></a>C admit structures whose
+elements are themselves arrays.  <a id="__idx_1548"></a>Pascal and <a id="__idx_1550"></a>C admit structures whose
 elements are structures.  However, this requires that the programmer
 manipulate pointers explicitly, and adhere to the restriction that
 each field of a structure can contain only elements of a prespecified form.
 Unlike
 Lisp with its pairs, these languages have no built-in general-purpose
 glue that makes it easy to manipulate compound data in a uniform way.
-This limitation lies behind Alan <a name="%_idx_1552" id="%_idx_1552"></a>Perlis's comment in his foreword to
+This limitation lies behind Alan <a id="__idx_1552"></a>Perlis's comment in his foreword to
 this book: “In Pascal the plethora of declarable data structures
 induces a specialization within functions that inhibits and penalizes
 casual cooperation.  It is better to have 100 functions operate on one
 data structure than to have 10 functions operate on 10 data
 structures.”
 
-</p><p><a name="footnote_Temp_156" href="#call_footnote_Temp_156" id="footnote_Temp_156"><sup><small>8</small></sup></a> In this book, we use <em>list</em> to mean a chain of
+</p><p><a href="#call_footnote_Temp_156" id="footnote_Temp_156"><sup><small>8</small></sup></a> In this book, we use <em>list</em> to mean a chain of
 pairs terminated by the end-of-list marker.  In contrast, the term
-<a name="%_idx_1572" id="%_idx_1572"></a><a name="%_idx_1574" id="%_idx_1574"></a><em>list structure</em> refers to any data structure made out of pairs,
+<a id="__idx_1572"></a><a id="__idx_1574"></a><em>list structure</em> refers to any data structure made out of pairs,
 not just to lists.
 
-</p><p><a name="footnote_Temp_157" href="#call_footnote_Temp_157" id="footnote_Temp_157"><sup><small>9</small></sup></a> Since nested applications of <tt>car</tt> and <tt>cdr</tt>
+</p><p><a href="#call_footnote_Temp_157" id="footnote_Temp_157"><sup><small>9</small></sup></a> Since nested applications of <tt>car</tt> and <tt>cdr</tt>
 are cumbersome to write, Lisp dialects provide abbreviations for
 them – for instance,
-<a name="%_idx_1584" id="%_idx_1584"></a><a name="%_idx_1586" id="%_idx_1586"></a></p>
+<a id="__idx_1584"></a><a id="__idx_1586"></a></p>
 
-<p><code>(cadr ⟨arg⟩) = (car (cdr ⟨arg⟩))</p>
+<p><code>(cadr ⟨arg⟩) = (car (cdr ⟨arg⟩))</code></p>
 
-<p>The names of all such procedures start with <tt>c</tt> and end with <tt>r</tt>.  Each <tt>a</tt> between them stands for a <a name="%_idx_1588" id="%_idx_1588"></a><a name="%_idx_1590" id="%_idx_1590"></a><tt>car</tt> operation and
+<p>The names of all such procedures start with <tt>c</tt> and end with <tt>r</tt>.  Each <tt>a</tt> between them stands for a <a id="__idx_1588"></a><a id="__idx_1590"></a><tt>car</tt> operation and
 each <tt>d</tt> for a <tt>cdr</tt> operation, to be applied in the same order
 in which they appear in the name.  The names <tt>car</tt> and <tt>cdr</tt>
 persist because simple combinations like <tt>cadr</tt> are
 pronounceable.
 
-</p><p><a name="footnote_Temp_158" href="#call_footnote_Temp_158" id="footnote_Temp_158"><sup><small>10</small></sup></a> It's remarkable how much energy in the
+</p><p><a href="#call_footnote_Temp_158" id="footnote_Temp_158"><sup><small>10</small></sup></a> It's remarkable how much energy in the
 standardization of Lisp dialects has been dissipated in arguments that
 are literally over nothing: Should <tt>nil</tt> be an ordinary name?
 Should the value of <tt>nil</tt> be a symbol?  Should it be a list?
-Should it be a pair?  <a name="%_idx_1598" id="%_idx_1598"></a>In Scheme, <tt>nil</tt> is an ordinary name,
+Should it be a pair?  <a id="__idx_1598"></a>In Scheme, <tt>nil</tt> is an ordinary name,
 which we use in this section as a variable whose value is
 the end-of-list marker (just as <tt>true</tt> is an ordinary variable
 that has a true value).  Other dialects of
 Lisp, including Common Lisp, treat <tt>nil</tt> as a special symbol.  The
-<a name="%_idx_1600" id="%_idx_1600"></a>authors of this book, who have endured too many language
+<a id="__idx_1600"></a>authors of this book, who have endured too many language
 standardization brawls, would like to avoid the entire issue.  Once we
-have introduced quotation in section <a href="book-Z-H-16.html#%_sec_2.3">2.3</a>, we will
+have introduced quotation in section <a href="book-Z-H-16.html#__sec_2.3">2.3</a>, we will
 denote the empty list as <tt>'()</tt> and dispense with the
 variable <tt>nil</tt> entirely.
 
-</p><p><a name="footnote_Temp_164" href="#call_footnote_Temp_164" id="footnote_Temp_164"><sup><small>11</small></sup></a> To define <tt>f</tt> and <tt>g</tt> using
-<a name="%_idx_1656" id="%_idx_1656"></a><tt>lambda</tt> we would write
+</p><p><a href="#call_footnote_Temp_164" id="footnote_Temp_164"><sup><small>11</small></sup></a> To define <tt>f</tt> and <tt>g</tt> using
+<a id="__idx_1656"></a><tt>lambda</tt> we would write
 </p><p></p><p><tt>(define f (lambda (x y . z) &lt;<em>body</em>&gt;))<br />
 (define g (lambda w &lt;<em>body</em>&gt;))<br /></tt></p><p></p><p>
 
-</p><p><a name="footnote_Temp_166" href="#call_footnote_Temp_166" id="footnote_Temp_166"><sup><small>12</small></sup></a> Scheme
-standardly provides a <a name="%_idx_1664" id="%_idx_1664"></a><tt>map</tt> procedure that is more general
+</p><p><a href="#call_footnote_Temp_166" id="footnote_Temp_166"><sup><small>12</small></sup></a> Scheme
+standardly provides a <a id="__idx_1664"></a><tt>map</tt> procedure that is more general
 than the one described here.
 This more general <tt>map</tt>
 takes a procedure of <em>n</em> arguments, together with <em>n</em> lists, and
@@ -1973,75 +1973,75 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 
 
 
-</p><p><a name="footnote_Temp_170" href="#call_footnote_Temp_170" id="footnote_Temp_170"><sup><small>13</small></sup></a> The order of the
+</p><p><a href="#call_footnote_Temp_170" id="footnote_Temp_170"><sup><small>13</small></sup></a> The order of the
 first two clauses in the <tt>cond</tt> matters, since the empty list
 satisfies <tt>null?</tt> and also is not a pair.
 
-</p><p><a name="footnote_Temp_182" href="#call_footnote_Temp_182" id="footnote_Temp_182"><sup><small>14</small></sup></a> This is, in fact, precisely the <a name="%_idx_1746" id="%_idx_1746"></a><tt>fringe</tt> procedure from
-exercise <a href="#%_thm_2.28">2.28</a>.  Here we've renamed it to emphasize that
+</p><p><a href="#call_footnote_Temp_182" id="footnote_Temp_182"><sup><small>14</small></sup></a> This is, in fact, precisely the <a id="__idx_1746"></a><tt>fringe</tt> procedure from
+exercise <a href="#__thm_2.28">2.28</a>.  Here we've renamed it to emphasize that
 it is part of a family of general sequence-manipulation procedures.
 
-</p><p><a name="footnote_Temp_183" href="#call_footnote_Temp_183" id="footnote_Temp_183"><sup><small>15</small></sup></a> <a name="%_idx_1760" id="%_idx_1760"></a>Richard Waters (1979)
-developed a program that automatically analyzes traditional <a name="%_idx_1762" id="%_idx_1762"></a>Fortran
+</p><p><a href="#call_footnote_Temp_183" id="footnote_Temp_183"><sup><small>15</small></sup></a> <a id="__idx_1760"></a>Richard Waters (1979)
+developed a program that automatically analyzes traditional <a id="__idx_1762"></a>Fortran
 programs, viewing them in terms of maps, filters, and accumulations.
 He found that fully 90 percent of the code in the Fortran Scientific
 Subroutine Package fits neatly into this paradigm.  One of the reasons
 for the success of Lisp as a programming language is that lists
 provide a standard medium for expressing ordered collections so that
 they can be manipulated using higher-order operations.  The
-programming language <a name="%_idx_1764" id="%_idx_1764"></a>APL owes much of its power and appeal to a
+programming language <a id="__idx_1764"></a>APL owes much of its power and appeal to a
 similar choice. In APL all data are represented as arrays, and there is a
 universal and convenient set of generic operators for all sorts of
 array operations.
 
-</p><p><a name="footnote_Temp_186" href="#call_footnote_Temp_186" id="footnote_Temp_186"><sup><small>16</small></sup></a> According to <a name="%_idx_1776" id="%_idx_1776"></a>Knuth (1981), this rule was formulated by
-<a name="%_idx_1778" id="%_idx_1778"></a>W. G. Horner early in the nineteenth century, but the method was
+</p><p><a href="#call_footnote_Temp_186" id="footnote_Temp_186"><sup><small>16</small></sup></a> According to <a id="__idx_1776"></a>Knuth (1981), this rule was formulated by
+<a id="__idx_1778"></a>W. G. Horner early in the nineteenth century, but the method was
 actually used by Newton over a hundred years earlier.  Horner's rule
 evaluates the polynomial using fewer additions and multiplications
 than does the straightforward method of first computing <em>a</em><sub><em>n</em></sub><em>x</em><sup><em>n</em></sup>,
 then adding <em>a</em><sub><em>n</em>-1</sub><em>x</em><sup><em>n</em>-1</sup>, and so on.  In fact, it is possible to
 prove that any algorithm for evaluating arbitrary polynomials must use
 at least as many additions and multiplications as does Horner's rule,
-and thus Horner's rule is an <a name="%_idx_1780" id="%_idx_1780"></a><a name="%_idx_1782" id="%_idx_1782"></a>optimal algorithm for polynomial
+and thus Horner's rule is an <a id="__idx_1780"></a><a id="__idx_1782"></a>optimal algorithm for polynomial
 evaluation.  This was proved (for the number of additions) by
-<a name="%_idx_1784" id="%_idx_1784"></a>A. M. Ostrowski in a 1954 paper that essentially founded the modern
+<a id="__idx_1784"></a>A. M. Ostrowski in a 1954 paper that essentially founded the modern
 study of optimal algorithms.  The analogous statement for
-multiplications was proved by <a name="%_idx_1786" id="%_idx_1786"></a>V. Y. Pan in 1966.  The book by <a name="%_idx_1788" id="%_idx_1788"></a>Borodin
-and <a name="%_idx_1790" id="%_idx_1790"></a>Munro (1975) provides an overview of these and other results about
+multiplications was proved by <a id="__idx_1786"></a>V. Y. Pan in 1966.  The book by <a id="__idx_1788"></a>Borodin
+and <a id="__idx_1790"></a>Munro (1975) provides an overview of these and other results about
 optimal algorithms.
 
-</p><p><a name="footnote_Temp_190" href="#call_footnote_Temp_190" id="footnote_Temp_190"><sup><small>17</small></sup></a> This definition uses the
+</p><p><a href="#call_footnote_Temp_190" id="footnote_Temp_190"><sup><small>17</small></sup></a> This definition uses the
 extended version of <tt>map</tt> described in footnote <a href="#footnote_Temp_166">12</a>.
 
-</p><p><a name="footnote_Temp_194" href="#call_footnote_Temp_194" id="footnote_Temp_194"><sup><small>18</small></sup></a> This approach to nested mappings was shown
-to us by <a name="%_idx_1820" id="%_idx_1820"></a>David Turner, whose languages <a name="%_idx_1822" id="%_idx_1822"></a>KRC and <a name="%_idx_1824" id="%_idx_1824"></a>Miranda provide elegant
+</p><p><a href="#call_footnote_Temp_194" id="footnote_Temp_194"><sup><small>18</small></sup></a> This approach to nested mappings was shown
+to us by <a id="__idx_1820"></a>David Turner, whose languages <a id="__idx_1822"></a>KRC and <a id="__idx_1824"></a>Miranda provide elegant
 formalisms for dealing with these constructs.  The examples in this
-section (see also exercise <a href="#%_thm_2.42">2.42</a>) are adapted from Turner
-1981.  In section <a href="book-Z-H-24.html#%_sec_3.5.3">3.5.3</a>, we'll see how this
+section (see also exercise <a href="#__thm_2.42">2.42</a>) are adapted from Turner
+1981.  In section <a href="book-Z-H-24.html#__sec_3.5.3">3.5.3</a>, we'll see how this
 approach generalizes to infinite sequences.
 
-</p><p><a name="footnote_Temp_195" href="#call_footnote_Temp_195" id="footnote_Temp_195"><sup><small>19</small></sup></a> We're
+</p><p><a href="#call_footnote_Temp_195" id="footnote_Temp_195"><sup><small>19</small></sup></a> We're
 representing a pair here as a list of two elements rather than as a
 Lisp pair.  Thus, the “pair” (<em>i</em>,<em>j</em>) is represented as <tt>(list i
 j)</tt>, not <tt>(cons i j)</tt>.
 
-</p><p><a name="footnote_Temp_196" href="#call_footnote_Temp_196" id="footnote_Temp_196"><sup><small>20</small></sup></a> The set <em>S</em> - <em>x</em> is the set of all elements
+</p><p><a href="#call_footnote_Temp_196" id="footnote_Temp_196"><sup><small>20</small></sup></a> The set <em>S</em> - <em>x</em> is the set of all elements
 of <em>S</em>, excluding <em>x</em>.
 
-</p><p><a name="footnote_Temp_197" href="#call_footnote_Temp_197" id="footnote_Temp_197"><sup><small>21</small></sup></a> <a name="%_idx_1834" id="%_idx_1834"></a><a name="%_idx_1836" id="%_idx_1836"></a><a name="%_idx_1838" id="%_idx_1838"></a>Semicolons in Scheme code are used to
+</p><p><a href="#call_footnote_Temp_197" id="footnote_Temp_197"><sup><small>21</small></sup></a> <a id="__idx_1834"></a><a id="__idx_1836"></a><a id="__idx_1838"></a>Semicolons in Scheme code are used to
 introduce <em>comments</em>.  Everything from the semicolon to the end of
 the line is ignored by the interpreter.  In this book we don't use
 many comments; we try to make our programs self-documenting by using
 descriptive names.
 
-</p><p><a name="footnote_Temp_202" href="#call_footnote_Temp_202" id="footnote_Temp_202"><sup><small>22</small></sup></a> The picture language is based on the language
-<a name="%_idx_1856" id="%_idx_1856"></a>Peter Henderson created to construct
-images like <a name="%_idx_1858" id="%_idx_1858"></a>M.C. Escher's “Square Limit” woodcut (see Henderson 1982).
+</p><p><a href="#call_footnote_Temp_202" id="footnote_Temp_202"><sup><small>22</small></sup></a> The picture language is based on the language
+<a id="__idx_1856"></a>Peter Henderson created to construct
+images like <a id="__idx_1858"></a>M.C. Escher's “Square Limit” woodcut (see Henderson 1982).
 The woodcut incorporates a
 repeated scaled pattern, similar to the arrangements drawn using
 the <tt>square-limit</tt> procedure in this section.
 
-</p><p><a name="footnote_Temp_204" href="#call_footnote_Temp_204" id="footnote_Temp_204"><sup><small>23</small></sup></a> <a name="%_idx_1866" id="%_idx_1866"></a><a name="%_idx_1868" id="%_idx_1868"></a>William Barton Rogers (1804-1882) was the founder and first president
+</p><p><a href="#call_footnote_Temp_204" id="footnote_Temp_204"><sup><small>23</small></sup></a> <a id="__idx_1866"></a><a id="__idx_1868"></a>William Barton Rogers (1804-1882) was the founder and first president
 of MIT.  A geologist and talented teacher, he taught at William and
 Mary College and at the University of Virginia.  In 1859 he moved to
 Boston, where he had more time for research, worked on a plan
@@ -2062,7 +2062,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 </p></blockquote><p>
 
 Rogers served as president of MIT until 1870, when he resigned due to
-ill health.  In 1878 the second president of MIT, <a name="%_idx_1870" id="%_idx_1870"></a>John Runkle,
+ill health.  In 1878 the second president of MIT, <a id="__idx_1870"></a>John Runkle,
 resigned under the pressure of a financial crisis brought on by the
 Panic of 1873 and strain of fighting off attempts by Harvard to take
 over MIT.  Rogers returned to hold the office of president until
@@ -2077,7 +2077,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 years ago Stephen Hales published a pamphlet on the subject of
 illuminating gas, in which he stated that his researches had
 demonstrated that 128 grains of bituminous coal – ”
-<a name="%_idx_1872" id="%_idx_1872"></a></p><p>“Bituminous coal,” these were his last words on earth.  Here he bent
+<a id="__idx_1872"></a></p><p>“Bituminous coal,” these were his last words on earth.  Here he bent
 forward, as if consulting some notes on the table before him, then
 slowly regaining an erect position, threw up his hands, and was
 translated from the scene of his earthly labors and triumphs to “the
@@ -2086,57 +2086,57 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.2">2.2  Hierarchical Data and the C
 new and still unfathomable mysteries of the infinite future.
 </p></blockquote>
 In the words of  Francis A. Walker
-<a name="%_idx_1874" id="%_idx_1874"></a>(MIT's third president):
+<a id="__idx_1874"></a>(MIT's third president):
 <blockquote>
 <p>All his life he had borne himself most faithfully and heroically, and
 he died as so good a knight would surely have wished, in harness, at
 his post, and in the very part and act of public duty.
 </p></blockquote>
 
-<p><a name="footnote_Temp_207" href="#call_footnote_Temp_207" id="footnote_Temp_207"><sup><small>24</small></sup></a> Equivalently, we could
+<p><a href="#call_footnote_Temp_207" id="footnote_Temp_207"><sup><small>24</small></sup></a> Equivalently, we could
 write
-</p><p></p><p><tt><a name="%_idx_1902" id="%_idx_1902"></a>(define flipped-pairs<br />
+</p><p></p><p><tt><a id="__idx_1902"></a>(define flipped-pairs<br />
   (square-of-four identity flip-vert identity flip-vert))<br /></tt></p><p></p><p>
 
 
-</p><p><a name="footnote_Temp_208" href="#call_footnote_Temp_208" id="footnote_Temp_208"><sup><small>25</small></sup></a> <tt>Rotate180</tt>
-rotates a painter by 180 degrees (see exercise <a href="#%_thm_2.50">2.50</a>).
+</p><p><a href="#call_footnote_Temp_208" id="footnote_Temp_208"><sup><small>25</small></sup></a> <tt>Rotate180</tt>
+rotates a painter by 180 degrees (see exercise <a href="#__thm_2.50">2.50</a>).
 Instead of <tt>rotate180</tt> we could say <tt>(compose flip-vert flip-horiz)</tt>, using
-the <tt>compose</tt> procedure from exercise <a href="book-Z-H-12.html#%_thm_1.42">1.42</a>.
+the <tt>compose</tt> procedure from exercise <a href="book-Z-H-12.html#__thm_1.42">1.42</a>.
 
-</p><p><a name="footnote_Temp_211" href="#call_footnote_Temp_211" id="footnote_Temp_211"><sup><small>26</small></sup></a> <tt>Frame-coord-map</tt> uses
-the vector operations described in exercise <a href="#%_thm_2.46">2.46</a> below, which we
+</p><p><a href="#call_footnote_Temp_211" id="footnote_Temp_211"><sup><small>26</small></sup></a> <tt>Frame-coord-map</tt> uses
+the vector operations described in exercise <a href="#__thm_2.46">2.46</a> below, which we
 assume have been implemented using some representation for vectors.
 Because of data abstraction, it doesn't matter what this vector
 representation is, so long as the vector operations behave correctly.
 
-</p><p><a name="footnote_Temp_215" href="#call_footnote_Temp_215" id="footnote_Temp_215"><sup><small>27</small></sup></a> <tt>Segments-&gt;painter</tt> uses the representation for line
-segments described in exercise <a href="#%_thm_2.48">2.48</a> below.
-It also uses the <tt>for-each</tt> procedure described in exercise <a href="#%_thm_2.23">2.23</a>.
+</p><p><a href="#call_footnote_Temp_215" id="footnote_Temp_215"><sup><small>27</small></sup></a> <tt>Segments-&gt;painter</tt> uses the representation for line
+segments described in exercise <a href="#__thm_2.48">2.48</a> below.
+It also uses the <tt>for-each</tt> procedure described in exercise <a href="#__thm_2.23">2.23</a>.
 
-</p><p><a name="footnote_Temp_216" href="#call_footnote_Temp_216" id="footnote_Temp_216"><sup><small>28</small></sup></a> For example, the <tt>rogers</tt> painter of
-figure <a href="#%_fig_2.11">2.11</a> was constructed from a gray-level image.
+</p><p><a href="#call_footnote_Temp_216" id="footnote_Temp_216"><sup><small>28</small></sup></a> For example, the <tt>rogers</tt> painter of
+figure <a href="#__fig_2.11">2.11</a> was constructed from a gray-level image.
 For each point in a given frame,
 the <tt>rogers</tt> painter determines the point in the image that is mapped to it
 under the frame coordinate map, and shades it
 accordingly.  By allowing different types of painters, we are capitalizing on the
-abstract data idea discussed in section <a href="book-Z-H-14.html#%_sec_2.1.3">2.1.3</a>, where we
+abstract data idea discussed in section <a href="book-Z-H-14.html#__sec_2.1.3">2.1.3</a>, where we
 argued that a rational-number representation could be anything at all that
 satisfies an appropriate condition.  Here we're using the fact that a
 painter can be implemented in any way at all, so long as it draws
-something in the designated frame.  Section <a href="book-Z-H-14.html#%_sec_2.1.3">2.1.3</a> also
+something in the designated frame.  Section <a href="book-Z-H-14.html#__sec_2.1.3">2.1.3</a> also
 showed how pairs could be implemented as procedures.  Painters are our
 second example of a procedural representation for data.
 
-</p><p><a name="footnote_Temp_220" href="#call_footnote_Temp_220" id="footnote_Temp_220"><sup><small>29</small></sup></a> <tt>Rotate90</tt> is a pure rotation only for square
+</p><p><a href="#call_footnote_Temp_220" id="footnote_Temp_220"><sup><small>29</small></sup></a> <tt>Rotate90</tt> is a pure rotation only for square
 frames, because it also stretches and shrinks the image to fit into
 the rotated frame.
 
-</p><p><a name="footnote_Temp_221" href="#call_footnote_Temp_221" id="footnote_Temp_221"><sup><small>30</small></sup></a> The diamond-shaped images in figures <a href="#%_fig_2.10">2.10</a>
-and <a href="#%_fig_2.11">2.11</a> were created with <tt>squash-inwards</tt> applied to
+</p><p><a href="#call_footnote_Temp_221" id="footnote_Temp_221"><sup><small>30</small></sup></a> The diamond-shaped images in figures <a href="#__fig_2.10">2.10</a>
+and <a href="#__fig_2.11">2.11</a> were created with <tt>squash-inwards</tt> applied to
 <tt>wave</tt> and <tt>rogers</tt>.
 
-</p><p><a name="footnote_Temp_225" href="#call_footnote_Temp_225" id="footnote_Temp_225"><sup><small>31</small></sup></a> Section <a href="book-Z-H-22.html#%_sec_3.3.4">3.3.4</a> describes one such language.
+</p><p><a href="#call_footnote_Temp_225" id="footnote_Temp_225"><sup><small>31</small></sup></a> Section <a href="book-Z-H-22.html#__sec_3.3.4">3.3.4</a> describes one such language.
 
 </p></div>
 
diff --git a/src/OEBPS/book-Z-H-16.html b/src/OEBPS/book-Z-H-16.html
index 89cca5c..dbf5179 100644
--- a/src/OEBPS/book-Z-H-16.html
+++ b/src/OEBPS/book-Z-H-16.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,24 +13,24 @@
 
 
 
-<a name="%_sec_2.3" id="%_sec_2.3"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
+<a id="__sec_2.3"></a>
+<h2>2.3  Symbolic Data</h2><p>
 
 
-<a name="%_idx_1984" id="%_idx_1984"></a>
-<a name="%_idx_1986" id="%_idx_1986"></a>All the compound data objects we have used so far were constructed
+<a id="__idx_1984"></a>
+<a id="__idx_1986"></a>All the compound data objects we have used so far were constructed
 ultimately from numbers.  In this section we extend the representational
 capability of our language by introducing the ability to work with
 arbitrary symbols as data.</p><p>
 
-<a name="%_sec_2.3.1" id="%_sec_2.3.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.3.1">2.3.1  Quotation</a></h3><p>
+<a id="__sec_2.3.1"></a>
+</p><h3>2.3.1  Quotation</h3><p>
 
 
-<a name="%_idx_1988" id="%_idx_1988"></a>
+<a id="__idx_1988"></a>
 If we can form compound data using symbols, we can have lists such as</p><p>
 
-</p><p></p><p><tt><a name="%_idx_1990" id="%_idx_1990"></a>(a b c d)<br />
+</p><p></p><p><tt><a id="__idx_1990"></a>(a b c d)<br />
 (23 45 17)<br />
 ((Norah 12) (Molly 9) (Anna 7) (Lauren 6) (Charlotte 4))<br /></tt></p><p></p><p>
 Lists containing symbols can look just like the expressions of our
@@ -44,7 +44,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 construct the list <tt>(a b)</tt>.  We can't accomplish this with <tt>(list a b)</tt>, because this expression constructs
 a list of the <em>values</em> of <tt>a</tt> and <tt>b</tt> rather than
 the symbols themselves.  This issue is well known in the context of
-<a name="%_idx_1992" id="%_idx_1992"></a><a name="%_idx_1994" id="%_idx_1994"></a>natural languages, where words and sentences may be regarded either as
+<a id="__idx_1992"></a><a id="__idx_1994"></a>natural languages, where words and sentences may be regarded either as
 semantic entities or as character strings (syntactic entities).  The
 common practice in natural languages is to use quotation marks to
 indicate that a word or a sentence is to be treated literally as a
@@ -53,18 +53,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 to hear that person's name.  However, if we tell somebody “say `your
 name' aloud,” we expect to hear the words “your name.”  Note that
 we are forced to nest quotation marks to describe what somebody else
-might say.<a name="call_footnote_Temp_227" href="#footnote_Temp_227" id="call_footnote_Temp_227"><sup><small>32</small></sup></a></p><p>
+might say.<a href="#footnote_Temp_227" id="call_footnote_Temp_227"><sup><small>32</small></sup></a></p><p>
 
-<a name="%_idx_1998" id="%_idx_1998"></a>We can follow this same practice to identify lists and symbols that are
+<a id="__idx_1998"></a>We can follow this same practice to identify lists and symbols that are
 to be treated as data objects rather than as expressions to be
 evaluated.  However, our format for quoting differs from that of
 natural languages in that we place a quotation mark (traditionally,
-the single <a name="%_idx_2000" id="%_idx_2000"></a>quote symbol <tt>'</tt>) only at the beginning of the object
+the single <a id="__idx_2000"></a>quote symbol <tt>'</tt>) only at the beginning of the object
 to be quoted.  We can get away with this in Scheme syntax because we
 rely on blanks and parentheses to delimit objects.  Thus, the meaning
-of the single quote character is to quote the next object.<a name="call_footnote_Temp_228" href="#footnote_Temp_228" id="call_footnote_Temp_228"><sup><small>33</small></sup></a></p><p>
+of the single quote character is to quote the next object.<a href="#footnote_Temp_228" id="call_footnote_Temp_228"><sup><small>33</small></sup></a></p><p>
 
-<a name="%_idx_2010" id="%_idx_2010"></a>Now we can distinguish between symbols and their values:</p><p>
+<a id="__idx_2010"></a>Now we can distinguish between symbols and their values:</p><p>
 
 </p><p></p><p><tt>(define a 1)<br /><br />
 (define b 2)<br /><br />
@@ -72,22 +72,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 (list 'a 'b)<br /><i>(a b)</i><br /><br />
 (list 'a b)<br /><i>(a 2)</i><br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_2012" id="%_idx_2012"></a>Quotation also allows us to type in compound objects, using the
-conventional printed representation for lists:<a name="call_footnote_Temp_229" href="#footnote_Temp_229" id="call_footnote_Temp_229"><sup><small>34</small></sup></a></p><p>
+<a id="__idx_2012"></a>Quotation also allows us to type in compound objects, using the
+conventional printed representation for lists:<a href="#footnote_Temp_229" id="call_footnote_Temp_229"><sup><small>34</small></sup></a></p><p>
 
 </p><p></p><p><tt>(car '(a b c))<br /><i>a</i><br /><br />
 (cdr '(a b c))<br /><i>(b c)</i><br /></tt></p><p></p><p>
-<a name="%_idx_2018" id="%_idx_2018"></a><a name="%_idx_2020" id="%_idx_2020"></a>In keeping with this, we can obtain the empty list by evaluating <tt>'()</tt>, and thus dispense with the variable <tt>nil</tt>.</p><p>
+<a id="__idx_2018"></a><a id="__idx_2020"></a>In keeping with this, we can obtain the empty list by evaluating <tt>'()</tt>, and thus dispense with the variable <tt>nil</tt>.</p><p>
 
-One additional primitive used in manipulating symbols is <a name="%_idx_2022" id="%_idx_2022"></a><a name="%_idx_2024" id="%_idx_2024"></a><a name="%_idx_2026" id="%_idx_2026"></a><a name="%_idx_2028" id="%_idx_2028"></a><tt>eq?</tt>,
+One additional primitive used in manipulating symbols is <a id="__idx_2022"></a><a id="__idx_2024"></a><a id="__idx_2026"></a><a id="__idx_2028"></a><tt>eq?</tt>,
 which takes two symbols as arguments and tests whether they are the
-same.<a name="call_footnote_Temp_230" href="#footnote_Temp_230" id="call_footnote_Temp_230"><sup><small>35</small></sup></a> Using <tt>eq?</tt>,
+same.<a href="#footnote_Temp_230" id="call_footnote_Temp_230"><sup><small>35</small></sup></a> Using <tt>eq?</tt>,
 we can implement a useful procedure called <tt>memq</tt>.  This takes two
 arguments, a symbol and a list.  If the symbol is not contained in the
 list (i.e., is not <tt>eq?</tt> to any item in the list), then <tt>memq</tt> returns false.  Otherwise, it returns the sublist of
 the list beginning with the first occurrence of the symbol:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2030" id="%_idx_2030"></a>(define (memq item x)<br />
+</p><p></p><p><tt><a id="__idx_2030"></a>(define (memq item x)<br />
   (cond ((null? x) false)<br />
         ((eq? item (car x)) x)<br />
         (else (memq item (cdr x)))))<br /></tt></p><p></p><p>
@@ -99,7 +99,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 </p><p></p><p><tt>(memq 'apple '(x (apple sauce) y apple pear))<br /></tt></p><p></p><p>
 is <tt>(apple pear)</tt>.</p><p>
 
-</p><p><a name="%_thm_2.53" id="%_thm_2.53"></a>
+</p><p><a id="__thm_2.53"></a>
 <b>Exercise 2.53.</b>  What would the interpreter print in response to evaluating each of the
 following expressions?</p><p>
 
@@ -112,8 +112,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 (memq 'red '(red shoes blue socks))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.54" id="%_thm_2.54"></a>
-<b>Exercise 2.54.</b>  Two lists are said to be <a name="%_idx_2032" id="%_idx_2032"></a><a name="%_idx_2034" id="%_idx_2034"></a><a name="%_idx_2036" id="%_idx_2036"></a><tt>equal?</tt> if they contain equal elements
+</p><p><a id="__thm_2.54"></a>
+<b>Exercise 2.54.</b>  Two lists are said to be <a id="__idx_2032"></a><a id="__idx_2034"></a><a id="__idx_2036"></a><tt>equal?</tt> if they contain equal elements
 arranged in the same order.  For example,</p><p>
 
 </p><p></p><p><tt>(equal? '(this is a list) '(this is a list))<br /></tt></p><p></p><p>
@@ -126,21 +126,21 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 symbols and the symbols are <tt>eq?</tt>, or if they are both lists such
 that <tt>(car a)</tt> is <tt>equal?</tt> to <tt>(car b)</tt> and <tt>(cdr
 a)</tt> is <tt>equal?</tt> to <tt>(cdr b)</tt>.  Using this idea, implement
-<tt>equal?</tt> as a procedure.<a name="call_footnote_Temp_233" href="#footnote_Temp_233" id="call_footnote_Temp_233"><sup><small>36</small></sup></a>
+<tt>equal?</tt> as a procedure.<a href="#footnote_Temp_233" id="call_footnote_Temp_233"><sup><small>36</small></sup></a>
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.55" id="%_thm_2.55"></a>
+</p><p><a id="__thm_2.55"></a>
 <b>Exercise 2.55.</b>  Eva Lu Ator types to the interpreter the expression
 </p><p></p><p><tt>(car ''abracadabra)<br /></tt></p><p></p><p>
 To her surprise, the interpreter prints back <tt>quote</tt>.  Explain.
 
 </p><p>
 
-<a name="%_sec_2.3.2" id="%_sec_2.3.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.3.2">2.3.2  Example: Symbolic Differentiation</a></h3><p>
+<a id="__sec_2.3.2"></a>
+</p><h3>2.3.2  Example: Symbolic Differentiation</h3><p>
 
 
-<a name="%_idx_2042" id="%_idx_2042"></a><a name="%_idx_2044" id="%_idx_2044"></a><a name="%_idx_2046" id="%_idx_2046"></a>
+<a id="__idx_2042"></a><a id="__idx_2044"></a><a id="__idx_2046"></a>
 As an illustration of symbol manipulation and a further illustration
 of data abstraction, consider the design of a procedure that performs
 symbolic differentiation of algebraic expressions.  We would like the
@@ -158,29 +158,29 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 
 In developing the symbolic-differentiation program, we will follow the
 same strategy of data abstraction that we followed in developing the
-rational-number system of section <a href="book-Z-H-14.html#%_sec_2.1.1">2.1.1</a>.  That is, we will first
+rational-number system of section <a href="book-Z-H-14.html#__sec_2.1.1">2.1.1</a>.  That is, we will first
 define a differentiation algorithm that operates on abstract
 objects such as “sums,” “products,” and “variables” without
 worrying about how these are to be represented.  Only afterward will
 we address the representation problem.</p><p>
 
-<a name="%_sec_Temp_235" id="%_sec_Temp_235"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_235">The differentiation program with abstract data</a></h4><p>
+<a id="__sec_Temp_235"></a>
+</p><h4>The differentiation program with abstract data</h4><p>
 
-<a name="%_idx_2048" id="%_idx_2048"></a>
+<a id="__idx_2048"></a>
 In order to keep things simple, we will consider a very simple
 symbolic-differentiation program that handles expressions that are
 built up using only the operations of addition and multiplication with
 two arguments.  Differentiation of any such expression can be carried
 out by applying the following reduction rules:</p><p>
 
-</p><p></p><div align="left"><img src="images/ch2-Z-G-45.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-45.gif" alt="ch2-Z-G-45" style="border: none;" /></div><p></p><p>
 
-</p><p></p><div align="left"><img src="images/ch2-Z-G-46.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-46.gif" alt="ch2-Z-G-46" style="border: none;" /></div><p></p><p>
 
-</p><p></p><div align="left"><img src="images/ch2-Z-G-47.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-47.gif" alt="ch2-Z-G-47" style="border: none;" /></div><p></p><p>
 
-</p><p></p><div align="left"><img src="images/ch2-Z-G-48.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-48.gif" alt="ch2-Z-G-48" style="border: none;" /></div><p></p><p>
 
 Observe that the latter two rules are recursive in nature.  That is,
 to obtain the derivative of a sum we first find the derivatives of the
@@ -189,7 +189,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 smaller pieces will eventually produce pieces that are either
 constants or variables, whose derivatives will be either 0 or 1.</p><p>
 
-To embody these rules in a procedure we indulge in a little <a name="%_idx_2050" id="%_idx_2050"></a>wishful
+To embody these rules in a procedure we indulge in a little <a id="__idx_2050"></a>wishful
 thinking, as we did in designing the rational-number implementation.
 If we had a means for representing algebraic expressions, we should be
 able to tell whether an expression is a sum, a product, a constant, or
@@ -200,17 +200,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 procedures to implement the following selectors, constructors, and
 predicates:</p><p>
 
-</p><table border="0"><tr><td valign="top"><tt>(variable? e)</tt> </td><td valign="top">Is <tt>e</tt> a variable?</td></tr><tr><td valign="top"><tt>(same-variable? v1 v2)</tt> </td><td valign="top">Are <tt>v1</tt> and <tt>v2</tt> the same variable?</td></tr><tr><td valign="top"><p>
+</p><table style="border: none;"><tr><td style="text-align: top;"><tt>(variable? e)</tt> </td><td style="text-align: top;">Is <tt>e</tt> a variable?</td></tr><tr><td style="text-align: top;"><tt>(same-variable? v1 v2)</tt> </td><td style="text-align: top;">Are <tt>v1</tt> and <tt>v2</tt> the same variable?</td></tr><tr><td style="text-align: top;"><p>
 
-<tt>(sum? e)</tt> </p></td><td valign="top">Is <tt>e</tt> a sum?</td></tr><tr><td valign="top"><tt>(addend e)</tt> </td><td valign="top">Addend of the sum <tt>e</tt>.</td></tr><tr><td valign="top"><tt>(augend e)</tt> </td><td valign="top">Augend of the sum <tt>e</tt>.</td></tr><tr><td valign="top"><tt>(make-sum a1 a2)</tt> </td><td valign="top">Construct the sum of <tt>a1</tt> and <tt>a2</tt>.</td></tr><tr><td valign="top"><p>
+<tt>(sum? e)</tt> </p></td><td style="text-align: top;">Is <tt>e</tt> a sum?</td></tr><tr><td style="text-align: top;"><tt>(addend e)</tt> </td><td style="text-align: top;">Addend of the sum <tt>e</tt>.</td></tr><tr><td style="text-align: top;"><tt>(augend e)</tt> </td><td style="text-align: top;">Augend of the sum <tt>e</tt>.</td></tr><tr><td style="text-align: top;"><tt>(make-sum a1 a2)</tt> </td><td style="text-align: top;">Construct the sum of <tt>a1</tt> and <tt>a2</tt>.</td></tr><tr><td style="text-align: top;"><p>
 
-<tt>(product? e)</tt> </p></td><td valign="top">Is <tt>e</tt> a product?</td></tr><tr><td valign="top"><tt>(multiplier e)</tt> </td><td valign="top">Multiplier of the product <tt>e</tt>.</td></tr><tr><td valign="top"><tt>(multiplicand e)</tt> </td><td valign="top">Multiplicand of the product <tt>e</tt>.</td></tr><tr><td valign="top"><tt>(make-product m1 m2)</tt> </td><td valign="top">Construct the product of <tt>m1</tt> and <tt>m2</tt>.
+<tt>(product? e)</tt> </p></td><td style="text-align: top;">Is <tt>e</tt> a product?</td></tr><tr><td style="text-align: top;"><tt>(multiplier e)</tt> </td><td style="text-align: top;">Multiplier of the product <tt>e</tt>.</td></tr><tr><td style="text-align: top;"><tt>(multiplicand e)</tt> </td><td style="text-align: top;">Multiplicand of the product <tt>e</tt>.</td></tr><tr><td style="text-align: top;"><tt>(make-product m1 m2)</tt> </td><td style="text-align: top;">Construct the product of <tt>m1</tt> and <tt>m2</tt>.
 </td></tr></table>
 Using these, and the primitive predicate <tt>number?</tt>,
-<a name="%_idx_2052" id="%_idx_2052"></a><a name="%_idx_2054" id="%_idx_2054"></a>which identifies numbers, we can express the differentiation rules as the
+<a id="__idx_2052"></a><a id="__idx_2054"></a>which identifies numbers, we can express the differentiation rules as the
 following procedure:<p>
 
-</p><p></p><p><tt><a name="%_idx_2056" id="%_idx_2056"></a>(define (deriv exp var)<br />
+</p><p></p><p><tt><a id="__idx_2056"></a>(define (deriv exp var)<br />
   (cond ((number? exp) 0)<br />
         ((variable? exp)<br />
          (if (same-variable? exp var) 1 0))<br />
@@ -231,10 +231,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 design a proper set of selectors and constructors.  This is the issue
 we must address next.</p><p>
 
-<a name="%_sec_Temp_236" id="%_sec_Temp_236"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_236">Representing algebraic expressions</a></h4><p>
+<a id="__sec_Temp_236"></a>
+</p><h4>Representing algebraic expressions</h4><p>
 
-<a name="%_idx_2058" id="%_idx_2058"></a>
+<a id="__idx_2058"></a>
 We can imagine many ways to use list structure to represent algebraic
 expressions.  For example, we could use lists of symbols that mirror
 the usual algebraic notation, representing <em>a</em><em>x</em> + <em>b</em> as the list <tt>(a
@@ -245,53 +245,53 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 follows:</p><p>
 
 </p><p></p><ul><li>The variables are symbols.  They are identified by the primitive predicate
-<a name="%_idx_2060" id="%_idx_2060"></a><a name="%_idx_2062" id="%_idx_2062"></a><tt>symbol?</tt>:<p>
+<a id="__idx_2060"></a><a id="__idx_2062"></a><tt>symbol?</tt>:<p>
 
-</p><p></p><p><tt><a name="%_idx_2064" id="%_idx_2064"></a>(define (variable? x) (symbol? x))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_2064"></a>(define (variable? x) (symbol? x))<br /></tt></p><p></p><p>
 </p><p>
 
 </p></li><li>Two variables are the same if the symbols representing them are
 <tt>eq?</tt>:<p>
 
-</p><p></p><p><tt><a name="%_idx_2066" id="%_idx_2066"></a>(define (same-variable? v1 v2)<br />
+</p><p></p><p><tt><a id="__idx_2066"></a>(define (same-variable? v1 v2)<br />
   (and (variable? v1) (variable? v2) (eq? v1 v2)))<br /></tt></p><p></p><p>
 </p><p>
 
 </p></li><li>Sums and products are constructed as lists:<p>
 
-</p><p></p><p><tt><a name="%_idx_2068" id="%_idx_2068"></a>(define (make-sum a1 a2) (list '+ a1 a2))<br /><br /><a name="%_idx_2070" id="%_idx_2070"></a>(define (make-product m1 m2) (list '* m1 m2))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_2068"></a>(define (make-sum a1 a2) (list '+ a1 a2))<br /><br /><a id="__idx_2070"></a>(define (make-product m1 m2) (list '* m1 m2))<br /></tt></p><p></p><p>
 </p><p>
 
 </p></li><li>A sum is a list whose first element is the symbol <tt>+</tt>:<p>
 
-</p><p></p><p><tt><a name="%_idx_2072" id="%_idx_2072"></a>(define (sum? x)<br />
+</p><p></p><p><tt><a id="__idx_2072"></a>(define (sum? x)<br />
   (and (pair? x) (eq? (car x) '+)))<br /></tt></p><p></p><p>
 </p><p>
 
 </p></li><li>The addend is the second item of the sum list:<p>
 
-</p><p></p><p><tt><a name="%_idx_2074" id="%_idx_2074"></a>(define (addend s) (cadr s))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_2074"></a>(define (addend s) (cadr s))<br /></tt></p><p></p><p>
 </p><p>
 
 </p></li><li>The augend is the third item of the sum list:<p>
 
-</p><p></p><p><tt><a name="%_idx_2076" id="%_idx_2076"></a>(define (augend s) (caddr s))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_2076"></a>(define (augend s) (caddr s))<br /></tt></p><p></p><p>
 </p><p>
 
 </p></li><li>A product is a list whose first element is the symbol <tt>*</tt>:<p>
 
-</p><p></p><p><tt><a name="%_idx_2078" id="%_idx_2078"></a>(define (product? x)<br />
+</p><p></p><p><tt><a id="__idx_2078"></a>(define (product? x)<br />
   (and (pair? x) (eq? (car x) '*)))<br /></tt></p><p></p><p>
 </p><p>
 
 </p></li><li>The multiplier is the second item of the product list:<p>
 
-</p><p></p><p><tt><a name="%_idx_2080" id="%_idx_2080"></a>(define (multiplier p) (cadr p))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_2080"></a>(define (multiplier p) (cadr p))<br /></tt></p><p></p><p>
 </p><p>
 
 </p></li><li>The multiplicand is the third item of the product list:<p>
 
-</p><p></p><p><tt><a name="%_idx_2082" id="%_idx_2082"></a>(define (multiplicand p) (caddr p))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_2082"></a>(define (multiplicand p) (caddr p))<br /></tt></p><p></p><p>
 </p></li></ul><p></p><p>
 
 Thus, we need only combine these with the algorithm as embodied by
@@ -306,14 +306,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 The program produces answers that are correct; however, they are
 unsimplified.  It is true that</p><p>
 
-</p><p></p><div align="left"><img src="images/ch2-Z-G-49.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-49.gif" alt="ch2-Z-G-49" style="border: none;" /></div><p></p><p>
 
 but we would like the program to know that <em>x</em> ·  0  =  0, 1 ·  <em>y</em>  =
 <em>y</em>, and 0 + <em>y</em> = <em>y</em>.  The answer for the second example should have been
 simply <tt>y</tt>.  As the third example shows, this becomes a serious
 issue when the expressions are complex.</p><p>
 
-<a name="%_idx_2084" id="%_idx_2084"></a><a name="%_idx_2086" id="%_idx_2086"></a>Our difficulty is much like the one we encountered with the
+<a id="__idx_2084"></a><a id="__idx_2086"></a>Our difficulty is much like the one we encountered with the
 rational-number implementation: we haven't reduced answers to simplest
 form.  To accomplish the rational-number reduction, we needed to
 change only the constructors and the selectors of the implementation.
@@ -323,7 +323,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 if one of the summands is 0, then <tt>make-sum</tt> will return the other
 summand.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2088" id="%_idx_2088"></a>(define (make-sum a1 a2)<br />
+</p><p></p><p><tt><a id="__idx_2088"></a>(define (make-sum a1 a2)<br />
   (cond ((=number? a1 0) a2)<br />
         ((=number? a2 0) a1)<br />
         ((and (number? a1) (number? a2)) (+ a1 a2))<br />
@@ -331,12 +331,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 This uses the procedure <tt>=number?</tt>, which checks whether an
 expression is equal to a given number:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2090" id="%_idx_2090"></a>(define (=number? exp num)<br />
+</p><p></p><p><tt><a id="__idx_2090"></a>(define (=number? exp num)<br />
   (and (number? exp) (= exp num)))<br /></tt></p><p></p><p>
 Similarly, we will change <tt>make-product</tt> to build in the rules that 0
 times anything is 0 and 1 times anything is the thing itself:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2092" id="%_idx_2092"></a>(define (make-product m1 m2)<br />
+</p><p></p><p><tt><a id="__idx_2092"></a>(define (make-product m1 m2)<br />
   (cond ((or (=number? m1 0) (=number? m2 0)) 0)<br />
         ((=number? m1 1) m2)<br />
         ((=number? m2 1) m1)<br />
@@ -354,11 +354,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 reasons, a form that may be simplest for one purpose may not be for
 another.
 
-</p><p><a name="%_thm_2.56" id="%_thm_2.56"></a>
-<b>Exercise 2.56.</b>  <a name="%_idx_2094" id="%_idx_2094"></a>Show how to extend the basic differentiator to handle more kinds of
+</p><p><a id="__thm_2.56"></a>
+<b>Exercise 2.56.</b>  <a id="__idx_2094"></a>Show how to extend the basic differentiator to handle more kinds of
 expressions.  For instance, implement the differentiation rule</p><p>
 
-</p><p></p><div align="left"><img src="images/ch2-Z-G-50.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-50.gif" alt="ch2-Z-G-50" style="border: none;" /></div><p></p><p>
 
 by adding a new clause to the <tt>deriv</tt> program
 and defining
@@ -370,7 +370,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.57" id="%_thm_2.57"></a>
+</p><p><a id="__thm_2.57"></a>
 <b>Exercise 2.57.</b>  Extend the differentiation program to handle sums and products of
 arbitrary numbers of (two or more) terms.
 Then the last example above could be expressed as
@@ -381,8 +381,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 of the terms.
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.58" id="%_thm_2.58"></a>
-<b>Exercise 2.58.</b>  <a name="%_idx_2096" id="%_idx_2096"></a><a name="%_idx_2098" id="%_idx_2098"></a>Suppose we want to modify the differentiation program so that it works
+</p><p><a id="__thm_2.58"></a>
+<b>Exercise 2.58.</b>  <a id="__idx_2096"></a><a id="__idx_2098"></a>Suppose we want to modify the differentiation program so that it works
 with ordinary mathematical notation, in which <tt>+</tt> and <tt>*</tt> are
 infix rather than prefix operators.  Since the differentiation program
 is defined in terms of abstract data, we can modify it to work with
@@ -404,11 +404,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 works?
 </p><p>
 
-<a name="%_sec_2.3.3" id="%_sec_2.3.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.3.3">2.3.3  Example: Representing Sets</a></h3><p>
+<a id="__sec_2.3.3"></a>
+</p><h3>2.3.3  Example: Representing Sets</h3><p>
 
 
-<a name="%_idx_2100" id="%_idx_2100"></a>
+<a id="__idx_2100"></a>
 In the previous examples we built representations for two kinds of
 compound data objects: rational numbers and algebraic expressions.  In
 one of these examples we had the choice of simplifying (reducing) the
@@ -420,35 +420,35 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 significantly from one another in several ways.</p><p>
 
 
-<a name="%_idx_2102" id="%_idx_2102"></a>Informally, a set is simply a collection of distinct objects.  To give
+<a id="__idx_2102"></a>Informally, a set is simply a collection of distinct objects.  To give
 a more precise definition we can employ the method of data
 abstraction.  That is, we define “set” by specifying the operations
 that are to be used on sets.  These are <tt>union-set</tt>,
 <tt>intersection-set</tt>, <tt>element-of-set?</tt>, and <tt>adjoin-set</tt>.
-<a name="%_idx_2104" id="%_idx_2104"></a><tt>Element-of-set?</tt> is a predicate that determines whether a given
-element is a member of a set.  <a name="%_idx_2106" id="%_idx_2106"></a><tt>Adjoin-set</tt> takes an object and a
+<a id="__idx_2104"></a><tt>Element-of-set?</tt> is a predicate that determines whether a given
+element is a member of a set.  <a id="__idx_2106"></a><tt>Adjoin-set</tt> takes an object and a
 set as arguments and returns a set that contains the elements of the
-original set and also the adjoined element.  <a name="%_idx_2108" id="%_idx_2108"></a><tt>Union-set</tt> computes
+original set and also the adjoined element.  <a id="__idx_2108"></a><tt>Union-set</tt> computes
 the union of two sets, which is the set containing each element that
-appears in either argument.  <a name="%_idx_2110" id="%_idx_2110"></a><tt>Intersection-set</tt> computes the
+appears in either argument.  <a id="__idx_2110"></a><tt>Intersection-set</tt> computes the
 intersection of two sets, which is the set containing only elements
 that appear in both arguments.  From the viewpoint of data abstraction, we
 are free to design any representation that implements these operations
-in a way consistent with the interpretations given above.<a name="call_footnote_Temp_240" href="#footnote_Temp_240" id="call_footnote_Temp_240"><sup><small>37</small></sup></a>
+in a way consistent with the interpretations given above.<a href="#footnote_Temp_240" id="call_footnote_Temp_240"><sup><small>37</small></sup></a>
 </p><p>
 
 
-<a name="%_sec_Temp_241" id="%_sec_Temp_241"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_241">Sets as unordered lists</a></h4><p>
+<a id="__sec_Temp_241"></a>
+</p><h4>Sets as unordered lists</h4><p>
 
-<a name="%_idx_2112" id="%_idx_2112"></a><a name="%_idx_2114" id="%_idx_2114"></a>
+<a id="__idx_2112"></a><a id="__idx_2114"></a>
 One way to represent a set is as a list of its elements in which no
 element appears more than once.  The empty set is represented by the
 empty list.  In this representation, <tt>element-of-set?</tt> is similar
-to the procedure <tt>memq</tt> of section <a href="#%_sec_2.3.1">2.3.1</a>.  It uses <tt>equal?</tt>
+to the procedure <tt>memq</tt> of section <a href="#__sec_2.3.1">2.3.1</a>.  It uses <tt>equal?</tt>
 instead of <tt>eq?</tt> so that the set elements need not be symbols:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2116" id="%_idx_2116"></a>(define (element-of-set? x set)<br />
+</p><p></p><p><tt><a id="__idx_2116"></a>(define (element-of-set? x set)<br />
   (cond ((null? set) false)<br />
         ((equal? x (car set)) true)<br />
         (else (element-of-set? x (cdr set)))))<br /></tt></p><p></p><p>
@@ -456,7 +456,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 is already in the set, we just return the set.  Otherwise, we use
 <tt>cons</tt> to add the object to the list that represents the set:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2118" id="%_idx_2118"></a>(define (adjoin-set x set)<br />
+</p><p></p><p><tt><a id="__idx_2118"></a>(define (adjoin-set x set)<br />
   (if (element-of-set? x set)<br />
       set<br />
       (cons x set)))<br /></tt></p><p></p><p>
@@ -466,7 +466,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 the <tt>car</tt> of <tt>set1</tt> in this.  But this depends on whether <tt>(car
 set1)</tt> is also in <tt>set2</tt>.  Here is the resulting procedure:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2120" id="%_idx_2120"></a>(define (intersection-set set1 set2)<br />
+</p><p></p><p><tt><a id="__idx_2120"></a>(define (intersection-set set1 set2)<br />
   (cond ((or (null? set1) (null? set2)) '())<br />
         ((element-of-set? (car set1) set2)        <br />
          (cons (car set1)<br />
@@ -488,12 +488,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 required grows as the product of the sizes of the sets involved, or
 θ(<em>n</em><sup>2</sup>) for two sets of size <em>n</em>.  The same will be true of <tt>union-set</tt>.</p><p>
 
-</p><p><a name="%_thm_2.59" id="%_thm_2.59"></a>
-<b>Exercise 2.59.</b>  Implement the <a name="%_idx_2122" id="%_idx_2122"></a><tt>union-set</tt> operation for the unordered-list
+</p><p><a id="__thm_2.59"></a>
+<b>Exercise 2.59.</b>  Implement the <a id="__idx_2122"></a><tt>union-set</tt> operation for the unordered-list
 representation of sets.
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.60" id="%_thm_2.60"></a>
+</p><p><a id="__thm_2.60"></a>
 <b>Exercise 2.60.</b>  We specified that a set would be represented as a list with no
 duplicates.  Now suppose we allow duplicates.  For instance,
 the set {1,2,3} could be represented as the list <tt>(2 3 2 1 3 2
@@ -505,10 +505,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 </p><p>
 
 
-<a name="%_sec_Temp_244" id="%_sec_Temp_244"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_244">Sets as ordered lists</a></h4><p>
+<a id="__sec_Temp_244"></a>
+</p><h4>Sets as ordered lists</h4><p>
 
-<a name="%_idx_2124" id="%_idx_2124"></a><a name="%_idx_2126" id="%_idx_2126"></a>
+<a id="__idx_2124"></a><a id="__idx_2126"></a>
 One way to speed up our set operations is to change the representation
 so that the set elements are listed in increasing order.  To do this,
 we need some way to compare two objects so that we can say which is
@@ -528,7 +528,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 entire set.  If we reach a set element that is larger than the item we
 are looking for, then we know that the item is not in the set:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2128" id="%_idx_2128"></a>(define (element-of-set? x set)<br />
+</p><p></p><p><tt><a id="__idx_2128"></a>(define (element-of-set? x set)<br />
   (cond ((null? set) false)<br />
         ((= x (car set)) true)<br />
         ((&lt; x (car set)) false)<br />
@@ -560,7 +560,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 is equal to the intersection of <tt>set2</tt> with the <tt>cdr</tt> of <tt>set1</tt>.  Similarly, if <tt>x2</tt> is less than <tt>x1</tt>, then the
 intersection is given by the intersection of <tt>set1</tt> with the <tt>cdr</tt> of <tt>set2</tt>.  Here is the procedure:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2130" id="%_idx_2130"></a>(define (intersection-set set1 set2)<br />
+</p><p></p><p><tt><a id="__idx_2130"></a>(define (intersection-set set1 set2)<br />
   (if (or (null? set1) (null? set2))<br />
       '()    <br />
       (let ((x1 (car set1)) (x2 (car set2)))<br />
@@ -580,8 +580,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 rather than θ(<em>n</em><sup>2</sup>) – a considerable speedup, even for sets of
 moderate size.</p><p>
 
-</p><p><a name="%_thm_2.61" id="%_thm_2.61"></a>
-<b>Exercise 2.61.</b>  Give an implementation of <a name="%_idx_2132" id="%_idx_2132"></a><tt>adjoin-set</tt> using the ordered
+</p><p><a id="__thm_2.61"></a>
+<b>Exercise 2.61.</b>  Give an implementation of <a id="__idx_2132"></a><tt>adjoin-set</tt> using the ordered
 representation.  By analogy with <tt>element-of-set?</tt> show how to
 take advantage of the ordering to produce a procedure that requires on
 the average about half as many steps as with the unordered
@@ -589,30 +589,30 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.62" id="%_thm_2.62"></a>
-<b>Exercise 2.62.</b>  Give a θ(<em>n</em>) implementation of <a name="%_idx_2134" id="%_idx_2134"></a><tt>union-set</tt> for sets
+</p><p><a id="__thm_2.62"></a>
+<b>Exercise 2.62.</b>  Give a θ(<em>n</em>) implementation of <a id="__idx_2134"></a><tt>union-set</tt> for sets
 represented as ordered lists.
 </p><p>
 </p><p>
 
-<a name="%_sec_Temp_247" id="%_sec_Temp_247"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_247">Sets as binary trees</a></h4><p>
+<a id="__sec_Temp_247"></a>
+</p><h4>Sets as binary trees</h4><p>
 
-<a name="%_idx_2136" id="%_idx_2136"></a><a name="%_idx_2138" id="%_idx_2138"></a><a name="%_idx_2140" id="%_idx_2140"></a><a name="%_idx_2142" id="%_idx_2142"></a><a name="%_idx_2144" id="%_idx_2144"></a><a name="%_idx_2146" id="%_idx_2146"></a>
+<a id="__idx_2136"></a><a id="__idx_2138"></a><a id="__idx_2140"></a><a id="__idx_2142"></a><a id="__idx_2144"></a><a id="__idx_2146"></a>
 We can do better than the ordered-list representation by arranging the
 set elements in the form of a tree.  Each node of the tree holds one
 element of the set, called the “entry” at that node, and a link to
 each of two other (possibly empty) nodes.  The “left” link points to
 elements smaller than the one at the node, and the “right” link to
 elements greater than the one at the node.
-Figure <a href="#%_fig_2.16">2.16</a> shows some trees that represent the set
+Figure <a href="#__fig_2.16">2.16</a> shows some trees that represent the set
 {1,3,5,7,9,11}.  The same set may be represented by a tree in a
 number of different ways.  The only thing we require for a valid
 representation is that all elements in the left subtree be smaller
 than the node entry and that all elements in the right subtree be
 larger.</p><p>
 
-<a name="%_fig_2.16" id="%_fig_2.16"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch2-Z-G-51.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 2.16:</b>  Various binary trees that represent the set { 1,3,5,7,9,11 }.</div></caption><tr><td>
+<a id="__fig_2.16"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch2-Z-G-51.gif" alt="ch2-Z-G-51" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.16:</b>  Various binary trees that represent the set { 1,3,5,7,9,11 }.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
@@ -626,22 +626,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 searching a tree of size <em>n</em> to searching a tree of size <em>n</em>/2.  Since
 the size of the tree is halved at each step, we should expect that the
 number of steps needed to search a tree of size <em>n</em> grows as θ(<tt>log</tt>
-<em>n</em>).<a name="call_footnote_Temp_248" href="#footnote_Temp_248" id="call_footnote_Temp_248"><sup><small>38</small></sup></a> For large sets, this will
+<em>n</em>).<a href="#footnote_Temp_248" id="call_footnote_Temp_248"><sup><small>38</small></sup></a> For large sets, this will
 be a significant speedup over the previous representations.</p><p>
 
-<a name="%_idx_2150" id="%_idx_2150"></a>We can represent trees by using lists.  Each node will be a list of
+<a id="__idx_2150"></a>We can represent trees by using lists.  Each node will be a list of
 three items: the entry at the node, the left subtree, and the right
 subtree.  A left or a right subtree of the empty list will indicate
 that there is no subtree connected there.  We can describe this
-representation by the following procedures:<a name="call_footnote_Temp_249" href="#footnote_Temp_249" id="call_footnote_Temp_249"><sup><small>39</small></sup></a></p><p>
+representation by the following procedures:<a href="#footnote_Temp_249" id="call_footnote_Temp_249"><sup><small>39</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_2152" id="%_idx_2152"></a>(define (entry tree) (car tree))<br /><a name="%_idx_2154" id="%_idx_2154"></a>(define (left-branch tree) (cadr tree))<br /><a name="%_idx_2156" id="%_idx_2156"></a>(define (right-branch tree) (caddr tree))<br /><a name="%_idx_2158" id="%_idx_2158"></a>(define (make-tree entry left right)<br />
+</p><p></p><p><tt><a id="__idx_2152"></a>(define (entry tree) (car tree))<br /><a id="__idx_2154"></a>(define (left-branch tree) (cadr tree))<br /><a id="__idx_2156"></a>(define (right-branch tree) (caddr tree))<br /><a id="__idx_2158"></a>(define (make-tree entry left right)<br />
   (list entry left right))<br /></tt></p><p></p><p></p><p>
 
 Now we can write the <tt>element-of-set?</tt> procedure using the strategy
 described above:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2160" id="%_idx_2160"></a>(define (element-of-set? x set)<br />
+</p><p></p><p><tt><a id="__idx_2160"></a>(define (element-of-set? x set)<br />
   (cond ((null? set) false)<br />
         ((= x (entry set)) true)<br />
         ((&lt; x (entry set))<br />
@@ -659,7 +659,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 <tt>x</tt> to an empty tree, we generate a tree that has <tt>x</tt> as the
 entry and empty right and left branches.  Here is the procedure:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2162" id="%_idx_2162"></a>(define (adjoin-set x set)<br />
+</p><p></p><p><tt><a id="__idx_2162"></a>(define (adjoin-set x set)<br />
   (cond ((null? set) (make-tree x '() '()))<br />
         ((= x (entry set)) set)<br />
         ((&lt; x (entry set))<br />
@@ -673,7 +673,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 
 The above claim that searching the tree can be performed in a logarithmic
 number of steps
-rests on the assumption that the tree is <a name="%_idx_2164" id="%_idx_2164"></a><a name="%_idx_2166" id="%_idx_2166"></a>“balanced,” i.e., that the
+rests on the assumption that the tree is <a id="__idx_2164"></a><a id="__idx_2166"></a>“balanced,” i.e., that the
 left and the right subtree of every tree have approximately the same
 number of elements, so that each subtree contains about half the
 elements of its parent.  But how can we be certain that the trees we
@@ -685,7 +685,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 on the average.  But this is not a guarantee.  For example, if we
 start with an empty set and adjoin the numbers 1 through 7 in sequence
 we end up with the highly unbalanced tree shown in
-figure <a href="#%_fig_2.17">2.17</a>.  In this tree all the left subtrees
+figure <a href="#__fig_2.17">2.17</a>.  In this tree all the left subtrees
 are empty, so it has no advantage over a simple ordered list.  One
 way to solve this problem is to define an operation that transforms an
 arbitrary tree into a balanced tree with the same elements.  Then we
@@ -693,15 +693,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 operations to keep our set in balance.  There are also other ways to
 solve this problem, most of which involve designing new data
 structures for which searching and insertion both can be done in
-θ(<tt>log</tt> <em>n</em>) steps.<a name="call_footnote_Temp_250" href="#footnote_Temp_250" id="call_footnote_Temp_250"><sup><small>40</small></sup></a></p><p>
+θ(<tt>log</tt> <em>n</em>) steps.<a href="#footnote_Temp_250" id="call_footnote_Temp_250"><sup><small>40</small></sup></a></p><p>
 
-<a name="%_fig_2.17" id="%_fig_2.17"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch2-Z-G-52.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 2.17:</b>  Unbalanced tree produced by adjoining 1 through 7 in sequence.</div></caption><tr><td>
+<a id="__fig_2.17"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch2-Z-G-52.gif" alt="ch2-Z-G-52" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.17:</b>  Unbalanced tree produced by adjoining 1 through 7 in sequence.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-</p><p><a name="%_thm_2.63" id="%_thm_2.63"></a>
-<b>Exercise 2.63.</b>  Each of the following two procedures converts a <a name="%_idx_2182" id="%_idx_2182"></a><a name="%_idx_2184" id="%_idx_2184"></a>binary tree to a list.
-<a name="%_idx_2186" id="%_idx_2186"></a></p><p></p><p><tt>(define (tree-&gt;list-1 tree)<br />
+</p><p><a id="__thm_2.63"></a>
+<b>Exercise 2.63.</b>  Each of the following two procedures converts a <a id="__idx_2182"></a><a id="__idx_2184"></a>binary tree to a list.
+<a id="__idx_2186"></a></p><p></p><p><tt>(define (tree-&gt;list-1 tree)<br />
   (if (null? tree)<br />
       '()<br />
       (append (tree-&gt;list-1 (left-branch tree))<br />
@@ -718,7 +718,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
   (copy-to-list tree '()))<br /></tt></p><p></p><p>
 </p><p></p><p>a. Do the two procedures produce the same result for every tree?  If
 not, how do the results differ?  What lists do the two procedures
-produce for the trees in figure <a href="#%_fig_2.16">2.16</a>?
+produce for the trees in figure <a href="#__fig_2.16">2.16</a>?
 
 </p><p></p><p>b. Do the two procedures have the same order of growth in the number
 of steps required to convert a balanced tree with <em>n</em> elements to a list?
@@ -726,8 +726,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.64" id="%_thm_2.64"></a>
-<b>Exercise 2.64.</b>  <a name="%_idx_2188" id="%_idx_2188"></a><a name="%_idx_2190" id="%_idx_2190"></a>The following procedure <tt>list-&gt;tree</tt> converts an ordered list to a
+</p><p><a id="__thm_2.64"></a>
+<b>Exercise 2.64.</b>  <a id="__idx_2188"></a><a id="__idx_2190"></a>The following procedure <tt>list-&gt;tree</tt> converts an ordered list to a
 balanced binary tree.  The helper procedure <tt>partial-tree</tt> takes
 as arguments an integer <em>n</em> and list of at least <em>n</em> elements and
 constructs a balanced tree containing the first <em>n</em> elements of the
@@ -735,7 +735,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 with <tt>cons</tt>) whose <tt>car</tt> is the constructed tree and whose
 <tt>cdr</tt> is the list of elements not included in the tree.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2192" id="%_idx_2192"></a>(define (list-&gt;tree elements)<br />
+</p><p></p><p><tt><a id="__idx_2192"></a>(define (list-&gt;tree elements)<br />
   (car (partial-tree elements (length elements))))<br /><br />
 (define (partial-tree elts n)<br />
   (if (= n 0)<br />
@@ -760,17 +760,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.65" id="%_thm_2.65"></a>
-<b>Exercise 2.65.</b>  <a name="%_idx_2194" id="%_idx_2194"></a><a name="%_idx_2196" id="%_idx_2196"></a>Use the results of exercises <a href="#%_thm_2.63">2.63</a> and
- <a href="#%_thm_2.64">2.64</a> to give θ(<em>n</em>) implementations of <tt>union-set</tt> and <tt>intersection-set</tt> for sets implemented as
-(balanced) binary trees.<a name="call_footnote_Temp_254" href="#footnote_Temp_254" id="call_footnote_Temp_254"><sup><small>41</small></sup></a>
+</p><p><a id="__thm_2.65"></a>
+<b>Exercise 2.65.</b>  <a id="__idx_2194"></a><a id="__idx_2196"></a>Use the results of exercises <a href="#__thm_2.63">2.63</a> and
+ <a href="#__thm_2.64">2.64</a> to give θ(<em>n</em>) implementations of <tt>union-set</tt> and <tt>intersection-set</tt> for sets implemented as
+(balanced) binary trees.<a href="#footnote_Temp_254" id="call_footnote_Temp_254"><sup><small>41</small></sup></a>
 
 </p><p>
 
-<a name="%_sec_Temp_255" id="%_sec_Temp_255"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_255">Sets and information retrieval</a></h4><p>
+<a id="__sec_Temp_255"></a>
+</p><h4>Sets and information retrieval</h4><p>
 
-<a name="%_idx_2200" id="%_idx_2200"></a>
+<a id="__idx_2200"></a>
 We have examined options for using lists to represent sets and have
 seen how the choice of representation for a data object can have a
 large impact on the performance of the programs that use the data.
@@ -778,17 +778,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 discussed here appear again and again in applications involving
 information retrieval.</p><p>
 
-<a name="%_idx_2202" id="%_idx_2202"></a>Consider a data base containing a large number of individual records,
-<a name="%_idx_2204" id="%_idx_2204"></a>such as the personnel files for a company or the transactions in an
+<a id="__idx_2202"></a>Consider a data base containing a large number of individual records,
+<a id="__idx_2204"></a>such as the personnel files for a company or the transactions in an
 accounting system.  A typical data-management system spends a large
 amount of time accessing or modifying the data in the records and
 therefore requires an efficient method for accessing records.  This is
 done by identifying a part of each record to serve as an identifying
-<a name="%_idx_2206" id="%_idx_2206"></a><em>key</em>.  A key can be anything that uniquely identifies the
+<a id="__idx_2206"></a><em>key</em>.  A key can be anything that uniquely identifies the
 record.  For a personnel file, it might be an employee's ID number.
 For an accounting system, it might be a transaction number.  Whatever
 the key is, when we define the record as a data structure we should
-include a <a name="%_idx_2208" id="%_idx_2208"></a><tt>key</tt> selector procedure that retrieves the key
+include a <a id="__idx_2208"></a><tt>key</tt> selector procedure that retrieves the key
 associated with a given record.</p><p>
 
 Now we represent the data base as a set of records. To locate the
@@ -799,7 +799,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 example, if the set of records is implemented as an unordered list, we
 could use</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2210" id="%_idx_2210"></a>(define (lookup given-key set-of-records)<br />
+</p><p></p><p><tt><a id="__idx_2210"></a>(define (lookup given-key set-of-records)<br />
   (cond ((null? set-of-records) false)<br />
         ((equal? given-key (key (car set-of-records)))<br />
          (car set-of-records))<br />
@@ -820,28 +820,28 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 change in representation will not require any changes to the rest of
 the system.</p><p>
 
-</p><p><a name="%_thm_2.66" id="%_thm_2.66"></a>
+</p><p><a id="__thm_2.66"></a>
 <b>Exercise 2.66.</b>  Implement the <tt>lookup</tt> procedure for the case
 where the set of records is structured as a binary tree, ordered by
 the numerical values of the keys.
 
 </p><p></p><p>
 
-<a name="%_sec_2.3.4" id="%_sec_2.3.4"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.3.4">2.3.4  Example: Huffman Encoding Trees</a></h3><p>
+<a id="__sec_2.3.4"></a>
+</p><h3>2.3.4  Example: Huffman Encoding Trees</h3><p>
 
-<a name="%_idx_2212" id="%_idx_2212"></a>
+<a id="__idx_2212"></a>
 This section provides practice in the use of list structure and data
 abstraction to manipulate sets and trees.  The application is to
 methods for representing data as sequences of ones and zeros (bits).
-For example, the <a name="%_idx_2214" id="%_idx_2214"></a><a name="%_idx_2216" id="%_idx_2216"></a>ASCII standard code used to represent text in
-computers encodes each <a name="%_idx_2218" id="%_idx_2218"></a>character as a sequence of seven bits.  Using
+For example, the <a id="__idx_2214"></a><a id="__idx_2216"></a>ASCII standard code used to represent text in
+computers encodes each <a id="__idx_2218"></a>character as a sequence of seven bits.  Using
 seven bits allows us to distinguish 2<sup>7</sup>, or 128, possible different
 characters.  In general, if we want to distinguish <em>n</em> different
 symbols, we will need to use <tt>log</tt><sub>2</sub><em>n</em> bits per symbol.  If all our
 messages are made up of the eight symbols A, B, C, D, E, F, G, and H,
 we can choose a code with three bits per character, for example
-</p><table border="0"><tr><td valign="top">A 000 </td><td valign="top">C 010 </td><td valign="top">E 100 </td><td valign="top">G 110</td></tr><tr><td valign="top">B 001 </td><td valign="top">D 011 </td><td valign="top">F 101 </td><td valign="top">H 111
+</p><table style="border: none;"><tr><td style="text-align: top;">A 000 </td><td style="text-align: top;">C 010 </td><td style="text-align: top;">E 100 </td><td style="text-align: top;">G 110</td></tr><tr><td style="text-align: top;">B 001 </td><td style="text-align: top;">D 011 </td><td style="text-align: top;">F 101 </td><td style="text-align: top;">H 111
 </td></tr></table>
 With this code, the message<p>
 
@@ -851,10 +851,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 
 </p><p></p><p>001000010000011000100000101000001001000000000110000111</p><p>
 
-</p><p></p><p>Codes such as ASCII and the A-through-H code above are known as <a name="%_idx_2220" id="%_idx_2220"></a><a name="%_idx_2222" id="%_idx_2222"></a><em>fixed-length</em> codes, because they represent each symbol in the message
+</p><p></p><p>Codes such as ASCII and the A-through-H code above are known as <a id="__idx_2220"></a><a id="__idx_2222"></a><em>fixed-length</em> codes, because they represent each symbol in the message
 with the same number of bits.  It is sometimes advantageous to use
-<a name="%_idx_2224" id="%_idx_2224"></a><a name="%_idx_2226" id="%_idx_2226"></a><em>variable-length</em> codes, in which different symbols may be
-represented by different numbers of bits.  For example, <a name="%_idx_2228" id="%_idx_2228"></a><a name="%_idx_2230" id="%_idx_2230"></a>Morse code
+<a id="__idx_2224"></a><a id="__idx_2226"></a><em>variable-length</em> codes, in which different symbols may be
+represented by different numbers of bits.  For example, <a id="__idx_2228"></a><a id="__idx_2230"></a>Morse code
 does not use the same number of dots and dashes for each letter of the
 alphabet.  In particular, E, the most frequent letter, is represented
 by a single dot.  In general, if our messages are such that some
@@ -862,7 +862,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 data more efficiently (i.e., using fewer bits per message) if we
 assign shorter codes to the frequent symbols.  Consider the following
 alternative code for the letters A through H:
-</p><table border="0"><tr><td valign="top">A 0 </td><td valign="top">C 1010 </td><td valign="top">E 1100 </td><td valign="top">G 1110</td></tr><tr><td valign="top">B 100 </td><td valign="top">D 1011 </td><td valign="top">F 1101 </td><td valign="top">H 1111
+</p><table style="border: none;"><tr><td style="text-align: top;">A 0 </td><td style="text-align: top;">C 1010 </td><td style="text-align: top;">E 1100 </td><td style="text-align: top;">G 1110</td></tr><tr><td style="text-align: top;">B 100 </td><td style="text-align: top;">D 1011 </td><td style="text-align: top;">F 1101 </td><td style="text-align: top;">H 1111
 </td></tr></table>
 With this code, the same message as above is encoded as the string<p>
 
@@ -874,11 +874,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 One of the difficulties of using a variable-length code is knowing
 when you have reached the end of a symbol in reading a sequence of
 zeros and ones.  Morse code solves this problem by using a special
-<a name="%_idx_2232" id="%_idx_2232"></a><em>separator code</em> (in this case, a pause) after the sequence of
+<a id="__idx_2232"></a><em>separator code</em> (in this case, a pause) after the sequence of
 dots and dashes for each letter.  Another solution is to design the
 code in such a way that no complete code for any symbol is the
 beginning (or <em>prefix</em>) of the code for another symbol.  Such a
-code is called a <a name="%_idx_2234" id="%_idx_2234"></a><a name="%_idx_2236" id="%_idx_2236"></a><em>prefix code</em>.  In the example above, A is
+code is called a <a id="__idx_2234"></a><a id="__idx_2236"></a><em>prefix code</em>.  In the example above, A is
 encoded by 0 and B is encoded by 100, so no other symbol can have a
 code that begins with 0 or with 100.</p><p>
 
@@ -886,8 +886,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 variable-length prefix codes that take advantage of the relative
 frequencies of the symbols in the messages to be encoded.  One
 particular scheme for doing this is called the Huffman encoding
-method, after its discoverer, <a name="%_idx_2238" id="%_idx_2238"></a>David Huffman.  A Huffman code can be
-represented as a <a name="%_idx_2240" id="%_idx_2240"></a><a name="%_idx_2242" id="%_idx_2242"></a>binary tree whose leaves are the symbols that are
+method, after its discoverer, <a id="__idx_2238"></a>David Huffman.  A Huffman code can be
+represented as a <a id="__idx_2240"></a><a id="__idx_2242"></a>binary tree whose leaves are the symbols that are
 encoded.  At each non-leaf node of the tree there is a set containing
 all the symbols in the leaves that lie below the node.  In addition,
 each symbol at a leaf is assigned a weight (which is its
@@ -897,11 +897,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 the decoding process.  We will see below how they are used to help
 construct the tree.</p><p>
 
-<a name="%_fig_2.18" id="%_fig_2.18"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch2-Z-G-53.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 2.18:</b>  A Huffman encoding tree.</div></caption><tr><td>
+<a id="__fig_2.18"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch2-Z-G-53.gif" alt="ch2-Z-G-53" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.18:</b>  A Huffman encoding tree.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-Figure <a href="#%_fig_2.18">2.18</a> shows the Huffman tree for the A-through-H
+Figure <a href="#__fig_2.18">2.18</a> shows the Huffman tree for the A-through-H
 code given above.  The weights at the leaves
 indicate that the tree was designed for messages in which A appears
 with relative frequency 8, B with relative frequency 3, and the
@@ -914,7 +914,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 decide which branch to follow by testing to see which branch either is
 the leaf node for the symbol or contains the symbol in its set.)  For
 example, starting from the root of the tree in
-figure <a href="#%_fig_2.18">2.18</a>, we arrive at the leaf for D by following a
+figure <a href="#__fig_2.18">2.18</a>, we arrive at the leaf for D by following a
 right branch, then a left branch, then a right branch, then a right
 branch; hence, the code for D is 1011.</p><p>
 
@@ -934,8 +934,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 the string 1010, so we move right, left, right, left and reach C.
 Thus, the entire message is BAC.</p><p>
 
-<a name="%_sec_Temp_257" id="%_sec_Temp_257"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_257">Generating Huffman trees</a></h4><p>
+<a id="__sec_Temp_257"></a>
+</p><h4>Generating Huffman trees</h4><p>
 
 Given an “alphabet” of symbols and their relative frequencies, how
 do we construct the “best” code?  (In other words, which tree will
@@ -943,8 +943,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 doing this and showed that the resulting code is indeed the best
 variable-length code for messages where the relative frequency of the
 symbols matches the frequencies with which the code was constructed.
-<a name="%_idx_2244" id="%_idx_2244"></a><a name="%_idx_2246" id="%_idx_2246"></a>We will not prove this optimality of Huffman codes here, but we will
-show how Huffman trees are constructed.<a name="call_footnote_Temp_258" href="#footnote_Temp_258" id="call_footnote_Temp_258"><sup><small>42</small></sup></a></p><p>
+<a id="__idx_2244"></a><a id="__idx_2246"></a>We will not prove this optimality of Huffman codes here, but we will
+show how Huffman trees are constructed.<a href="#footnote_Temp_258" id="call_footnote_Temp_258"><sup><small>42</small></sup></a></p><p>
 
 The algorithm for generating a Huffman tree is very simple. The idea
 is to arrange the tree so that the symbols with the lowest frequency
@@ -959,34 +959,34 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 removing them from the set and replacing them with a node that has
 these two as its left and right branches. The process stops when
 there is only one node left, which is the root of the entire tree.
-Here is how the Huffman tree of figure <a href="#%_fig_2.18">2.18</a> was generated:</p><p>
+Here is how the Huffman tree of figure <a href="#__fig_2.18">2.18</a> was generated:</p><p>
 
-</p><table border="0"><tr><td valign="top">Initial leaves </td><td valign="top">{(A 8)  (B 3)  (C 1)
- (D 1)  (E 1)  (F 1)  (G 1)  (H 1)}</td></tr><tr><td valign="top"><p>
+</p><table style="border: none;"><tr><td style="text-align: top;">Initial leaves </td><td style="text-align: top;">{(A 8)  (B 3)  (C 1)
+ (D 1)  (E 1)  (F 1)  (G 1)  (H 1)}</td></tr><tr><td style="text-align: top;"><p>
 
-Merge </p></td><td valign="top">{(A 8)  (B 3)  ({C D} 2)  (E
-1)  (F 1)  (G 1)  (H 1)}</td></tr><tr><td valign="top"><p>
+Merge </p></td><td style="text-align: top;">{(A 8)  (B 3)  ({C D} 2)  (E
+1)  (F 1)  (G 1)  (H 1)}</td></tr><tr><td style="text-align: top;"><p>
 
-Merge </p></td><td valign="top">{(A 8)  (B 3)  ({C D} 2)
-({E F} 2)  (G 1)  (H 1)}</td></tr><tr><td valign="top"><p>
+Merge </p></td><td style="text-align: top;">{(A 8)  (B 3)  ({C D} 2)
+({E F} 2)  (G 1)  (H 1)}</td></tr><tr><td style="text-align: top;"><p>
 
-Merge </p></td><td valign="top">{(A 8)  (B 3)  ({C D} 2)
-({E F} 2)   ({G H} 2)}</td></tr><tr><td valign="top"><p>
+Merge </p></td><td style="text-align: top;">{(A 8)  (B 3)  ({C D} 2)
+({E F} 2)   ({G H} 2)}</td></tr><tr><td style="text-align: top;"><p>
 
-Merge </p></td><td valign="top">{(A 8)   (B 3)  ({C D} 2)  ({E F G H} 4)}</td></tr><tr><td valign="top"><p>
+Merge </p></td><td style="text-align: top;">{(A 8)   (B 3)  ({C D} 2)  ({E F G H} 4)}</td></tr><tr><td style="text-align: top;"><p>
 
-Merge </p></td><td valign="top">{(A 8)  ({B C D} 5)  ({E F G H} 4)}</td></tr><tr><td valign="top"><p>
+Merge </p></td><td style="text-align: top;">{(A 8)  ({B C D} 5)  ({E F G H} 4)}</td></tr><tr><td style="text-align: top;"><p>
 
-Merge </p></td><td valign="top">{(A 8)  ({B C D E F G H} 9)}</td></tr><tr><td valign="top"><p>
+Merge </p></td><td style="text-align: top;">{(A 8)  ({B C D E F G H} 9)}</td></tr><tr><td style="text-align: top;"><p>
 
-Final merge </p></td><td valign="top">{({A B C D E F G H} 17)}</td></tr><tr><td valign="top"></td></tr></table>
+Final merge </p></td><td style="text-align: top;">{({A B C D E F G H} 17)}</td></tr><tr><td style="text-align: top;"></td></tr></table>
 The algorithm does not always specify a unique tree, because there may
 not be unique smallest-weight nodes at each step.  Also, the choice of
 the order in which the two nodes are merged (i.e., which will be the
 right branch and which will be the left branch) is arbitrary.<p>
 
-<a name="%_sec_Temp_259" id="%_sec_Temp_259"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_259">Representing Huffman trees</a></h4><p>
+<a id="__sec_Temp_259"></a>
+</p><h4>Representing Huffman trees</h4><p>
 
 In the exercises below we will work with a system that uses
 Huffman trees to encode and decode messages and generates Huffman
@@ -996,9 +996,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 Leaves of the tree are represented by a list consisting of the
 symbol <tt>leaf</tt>, the symbol at the leaf, and the weight:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2250" id="%_idx_2250"></a>(define (make-leaf symbol weight)<br />
-  (list 'leaf symbol weight))<br /><a name="%_idx_2252" id="%_idx_2252"></a>(define (leaf? object)<br />
-  (eq? (car object) 'leaf))<br /><a name="%_idx_2254" id="%_idx_2254"></a>(define (symbol-leaf x) (cadr x))<br /><a name="%_idx_2256" id="%_idx_2256"></a>(define (weight-leaf x) (caddr x))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_2250"></a>(define (make-leaf symbol weight)<br />
+  (list 'leaf symbol weight))<br /><a id="__idx_2252"></a>(define (leaf? object)<br />
+  (eq? (car object) 'leaf))<br /><a id="__idx_2254"></a>(define (symbol-leaf x) (cadr x))<br /><a id="__idx_2256"></a>(define (weight-leaf x) (caddr x))<br /></tt></p><p></p><p>
 A general tree will be a list of a left branch, a right branch, a set
 of symbols, and a weight.  The set of symbols will be simply a list of
 the symbols, rather than some more sophisticated set representation.
@@ -1006,37 +1006,37 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 tree as the sum of the weights of the nodes, and the set of symbols as
 the union of the sets of symbols for the nodes.  Since our symbol sets are
 represented as lists, we can form the union by using the <tt>append</tt>
-procedure we defined in section <a href="book-Z-H-15.html#%_sec_2.2.1">2.2.1</a>:</p><p>
+procedure we defined in section <a href="book-Z-H-15.html#__sec_2.2.1">2.2.1</a>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2258" id="%_idx_2258"></a>(define (make-code-tree left right)<br />
+</p><p></p><p><tt><a id="__idx_2258"></a>(define (make-code-tree left right)<br />
   (list left<br />
         right<br />
         (append (symbols left) (symbols right))<br />
         (+ (weight left) (weight right))))<br /></tt></p><p></p><p>
 If we make a tree in this way, we have the following selectors:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2260" id="%_idx_2260"></a>(define (left-branch tree) (car tree))<br /><br /><a name="%_idx_2262" id="%_idx_2262"></a>(define (right-branch tree) (cadr tree))<br /><a name="%_idx_2264" id="%_idx_2264"></a>(define (symbols tree)<br />
+</p><p></p><p><tt><a id="__idx_2260"></a>(define (left-branch tree) (car tree))<br /><br /><a id="__idx_2262"></a>(define (right-branch tree) (cadr tree))<br /><a id="__idx_2264"></a>(define (symbols tree)<br />
   (if (leaf? tree)<br />
       (list (symbol-leaf tree))<br />
-      (caddr tree)))<br /><a name="%_idx_2266" id="%_idx_2266"></a>(define (weight tree)<br />
+      (caddr tree)))<br /><a id="__idx_2266"></a>(define (weight tree)<br />
   (if (leaf? tree)<br />
       (weight-leaf tree)<br />
       (cadddr tree)))<br /></tt></p><p></p><p>
 The procedures <tt>symbols</tt> and <tt>weight</tt> must do something
 slightly different depending on whether they are called with a leaf or
-a general tree.  These are simple examples of <a name="%_idx_2268" id="%_idx_2268"></a><a name="%_idx_2270" id="%_idx_2270"></a><em>generic
+a general tree.  These are simple examples of <a id="__idx_2268"></a><a id="__idx_2270"></a><em>generic
 procedures</em> (procedures that can handle more than one kind of data),
 which we will have much more to say about in
-sections <a href="book-Z-H-17.html#%_sec_2.4">2.4</a> and <a href="book-Z-H-18.html#%_sec_2.5">2.5</a>.</p><p>
+sections <a href="book-Z-H-17.html#__sec_2.4">2.4</a> and <a href="book-Z-H-18.html#__sec_2.5">2.5</a>.</p><p>
 
-<a name="%_sec_Temp_260" id="%_sec_Temp_260"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_260">The decoding procedure</a></h4><p>
+<a id="__sec_Temp_260"></a>
+</p><h4>The decoding procedure</h4><p>
 
 The following procedure implements the decoding algorithm.
 It takes as arguments a list of zeros and ones, together with
 a Huffman tree.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2272" id="%_idx_2272"></a>(define (decode bits tree)<br />
+</p><p></p><p><tt><a id="__idx_2272"></a>(define (decode bits tree)<br />
   (define (decode-1 bits current-branch)<br />
     (if (null? bits)<br />
         '()<br />
@@ -1063,8 +1063,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 complains if the procedure finds something other than a zero or a one in the
 input data.</p><p>
 
-<a name="%_sec_Temp_261" id="%_sec_Temp_261"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_261">Sets of weighted elements</a></h4><p>
+<a id="__sec_Temp_261"></a>
+</p><h4>Sets of weighted elements</h4><p>
 
 In our representation of trees, each non-leaf node contains a set of
 symbols, which we have represented as a simple list.  However, the
@@ -1076,11 +1076,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 
 We will represent a set of leaves and trees as a list of elements,
 arranged in increasing order of weight.  The following <tt>adjoin-set</tt> procedure for constructing sets is similar to the one
-described in exercise <a href="#%_thm_2.61">2.61</a>; however, items are compared
+described in exercise <a href="#__thm_2.61">2.61</a>; however, items are compared
 by their weights, and the element being added to the set is
 never already in it.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2274" id="%_idx_2274"></a>(define (adjoin-set x set)<br />
+</p><p></p><p><tt><a id="__idx_2274"></a>(define (adjoin-set x set)<br />
   (cond ((null? set) (list x))<br />
         ((&lt; (weight x) (weight (car set))) (cons x set))<br />
         (else (cons (car set)<br />
@@ -1091,7 +1091,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 constructs an initial ordered set of leaves, ready to be merged
 according to the Huffman algorithm:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2276" id="%_idx_2276"></a>(define (make-leaf-set pairs)<br />
+</p><p></p><p><tt><a id="__idx_2276"></a>(define (make-leaf-set pairs)<br />
   (if (null? pairs)<br />
       '()<br />
       (let ((pair (car pairs)))<br />
@@ -1099,7 +1099,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
                                (cadr pair))  <em>; frequency</em><br />
                     (make-leaf-set (cdr pairs))))))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_2.67" id="%_thm_2.67"></a>
+</p><p><a id="__thm_2.67"></a>
 <b>Exercise 2.67.</b>  Define an encoding tree and a sample message:</p><p>
 
 
@@ -1116,12 +1116,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 </p><p></p><p>
 
 
-</p><p><a name="%_thm_2.68" id="%_thm_2.68"></a>
+</p><p><a id="__thm_2.68"></a>
 <b>Exercise 2.68.</b>  The <tt>encode</tt> procedure takes as arguments a message and a tree and
 produces the list of bits that gives the encoded message.</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_2278" id="%_idx_2278"></a>(define (encode message tree)<br />
+</p><p></p><p><tt><a id="__idx_2278"></a>(define (encode message tree)<br />
   (if (null? message)<br />
       '()<br />
       (append (encode-symbol (car message) tree)<br />
@@ -1130,18 +1130,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 the list of bits that encodes a given symbol according to a given
 tree.  You should design <tt>encode-symbol</tt> so that it signals an
 error if the symbol is not in the tree at all.  Test your procedure by
-encoding the result you obtained in exercise <a href="#%_thm_2.67">2.67</a> with
+encoding the result you obtained in exercise <a href="#__thm_2.67">2.67</a> with
 the sample tree and seeing whether it is the same as the original
 sample message.
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.69" id="%_thm_2.69"></a>
+</p><p><a id="__thm_2.69"></a>
 <b>Exercise 2.69.</b>  The following procedure takes as its argument a list of
 symbol-frequency pairs (where no symbol appears in more than one pair)
 and generates a Huffman encoding tree according to the Huffman
 algorithm.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2280" id="%_idx_2280"></a>(define (generate-huffman-tree pairs)<br />
+</p><p></p><p><tt><a id="__idx_2280"></a>(define (generate-huffman-tree pairs)<br />
   (successive-merge (make-leaf-set pairs)))<br /></tt></p><p></p><p>
 <tt>Make-leaf-set</tt> is the procedure given above that transforms the
 list of pairs into an ordered set of leaves.  <tt>Successive-merge</tt>
@@ -1155,17 +1155,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.70" id="%_thm_2.70"></a>
-<b>Exercise 2.70.</b>  <a name="%_idx_2282" id="%_idx_2282"></a>The following eight-symbol alphabet with associated relative
+</p><p><a id="__thm_2.70"></a>
+<b>Exercise 2.70.</b>  <a id="__idx_2282"></a>The following eight-symbol alphabet with associated relative
 frequencies was designed to efficiently encode the lyrics of 1950s
 rock songs.  (Note that the “symbols” of an “alphabet” need not be
 individual letters.)</p><p>
 
-</p><table border="0"><tr><td valign="top">A    </td><td valign="top">2 </td><td valign="top">NA  </td><td valign="top">16</td></tr><tr><td valign="top">BOOM </td><td valign="top">1 </td><td valign="top">SHA </td><td valign="top">3</td></tr><tr><td valign="top">GET  </td><td valign="top">2 </td><td valign="top">YIP </td><td valign="top">9</td></tr><tr><td valign="top">JOB  </td><td valign="top">2 </td><td valign="top">WAH </td><td valign="top">1
+</p><table style="border: none;"><tr><td style="text-align: top;">A    </td><td style="text-align: top;">2 </td><td style="text-align: top;">NA  </td><td style="text-align: top;">16</td></tr><tr><td style="text-align: top;">BOOM </td><td style="text-align: top;">1 </td><td style="text-align: top;">SHA </td><td style="text-align: top;">3</td></tr><tr><td style="text-align: top;">GET  </td><td style="text-align: top;">2 </td><td style="text-align: top;">YIP </td><td style="text-align: top;">9</td></tr><tr><td style="text-align: top;">JOB  </td><td style="text-align: top;">2 </td><td style="text-align: top;">WAH </td><td style="text-align: top;">1
 </td></tr></table>
-Use <tt>generate-huffman-tree</tt> (exercise <a href="#%_thm_2.69">2.69</a>)
+Use <tt>generate-huffman-tree</tt> (exercise <a href="#__thm_2.69">2.69</a>)
 to generate a corresponding Huffman tree, and use
-<tt>encode</tt> (exercise <a href="#%_thm_2.68">2.68</a>)
+<tt>encode</tt> (exercise <a href="#__thm_2.68">2.68</a>)
 to encode the following message:<p>
 
 </p><p></p><p>Get a job</p><p>
@@ -1185,7 +1185,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 used a fixed-length code for the eight-symbol alphabet?
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.71" id="%_thm_2.71"></a>
+</p><p><a id="__thm_2.71"></a>
 <b>Exercise 2.71.</b>  Suppose we have a Huffman tree for an alphabet of <em>n</em> symbols, and
 that the relative frequencies of the symbols are 1, 2, 4, <tt>...</tt>,
 2<sup><em>n</em>-1</sup>.  Sketch the tree for <em>n</em>=5; for <em>n</em>=10.  In such a tree
@@ -1194,21 +1194,21 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.72" id="%_thm_2.72"></a>
-<b>Exercise 2.72.</b>  <a name="%_idx_2284" id="%_idx_2284"></a>Consider the encoding procedure that you designed in
-exercise <a href="#%_thm_2.68">2.68</a>.  What is the order of growth in the
+</p><p><a id="__thm_2.72"></a>
+<b>Exercise 2.72.</b>  <a id="__idx_2284"></a>Consider the encoding procedure that you designed in
+exercise <a href="#__thm_2.68">2.68</a>.  What is the order of growth in the
 number of steps needed to encode a symbol?  Be sure to include the
 number of steps needed to search the symbol list at each node
 encountered.  To answer this question in general is difficult.
 Consider the special case where the relative frequencies of the <em>n</em>
-symbols are as described in exercise <a href="#%_thm_2.71">2.71</a>, and give
+symbols are as described in exercise <a href="#__thm_2.71">2.71</a>, and give
 the order of growth (as a function of <em>n</em>) of the number of steps
 needed to encode the most frequent and least frequent symbols in the
 alphabet.
 </p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_227" href="#call_footnote_Temp_227" id="footnote_Temp_227"><sup><small>32</small></sup></a> Allowing quotation in a language wreaks havoc
+</p><div class="footnote"><p><a href="#call_footnote_Temp_227" id="footnote_Temp_227"><sup><small>32</small></sup></a> Allowing quotation in a language wreaks havoc
 with the ability to reason about the language in simple terms, because
 it destroys the notion that equals can be substituted for equals.  For
 example, three is one plus two, but the word “three” is not the
@@ -1218,22 +1218,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 a language that talk about other statements in that language makes it
 very difficult to maintain any coherent principle of what “equals can
 be substituted for equals” should mean.  For example, if we know that
-<a name="%_idx_1996" id="%_idx_1996"></a>the evening star is the morning star, then from the statement “the
+<a id="__idx_1996"></a>the evening star is the morning star, then from the statement “the
 evening star is Venus” we can deduce “the morning star is Venus.”
 However, given that “John knows that the evening star is Venus” we
 cannot infer that “John knows that the morning star is Venus.”
 
-</p><p><a name="footnote_Temp_228" href="#call_footnote_Temp_228" id="footnote_Temp_228"><sup><small>33</small></sup></a> The single quote is different <a name="%_idx_2002" id="%_idx_2002"></a><a name="%_idx_2004" id="%_idx_2004"></a><a name="%_idx_2006" id="%_idx_2006"></a><a name="%_idx_2008" id="%_idx_2008"></a>from the double quote we have
+</p><p><a href="#call_footnote_Temp_228" id="footnote_Temp_228"><sup><small>33</small></sup></a> The single quote is different <a id="__idx_2002"></a><a id="__idx_2004"></a><a id="__idx_2006"></a><a id="__idx_2008"></a>from the double quote we have
 been using to enclose character strings to be printed.  Whereas the
 single quote can be used to denote lists or symbols, the double quote
 is used only with character strings.  In this book, the only use for
 character strings is as items to be printed.
 
-</p><p><a name="footnote_Temp_229" href="#call_footnote_Temp_229" id="footnote_Temp_229"><sup><small>34</small></sup></a> Strictly, our
+</p><p><a href="#call_footnote_Temp_229" id="footnote_Temp_229"><sup><small>34</small></sup></a> Strictly, our
 use of the quotation mark violates the general rule that all compound
 expressions in our language should be delimited by parentheses
 and look like lists.  We
-<a name="%_idx_2014" id="%_idx_2014"></a><a name="%_idx_2016" id="%_idx_2016"></a>can recover this consistency by introducing a special form <tt>quote</tt>, which serves the same purpose as the quotation mark.  Thus, we
+<a id="__idx_2014"></a><a id="__idx_2016"></a>can recover this consistency by introducing a special form <tt>quote</tt>, which serves the same purpose as the quotation mark.  Thus, we
 would type <tt>(quote a)</tt> instead of <tt>'a</tt>, and we would type <tt>(quote (a b c))</tt> instead of <tt>'(a b c)</tt>.  This is precisely how the
 interpreter works.  The quotation mark is just a single-character
 abbreviation for wrapping the next complete expression with <tt>quote</tt> to form <tt>(quote &lt;<em>expression</em>&gt;)</tt>.  This is important
@@ -1243,23 +1243,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 <tt>(car '(a b c))</tt>, which is the same as <tt>(car (quote (a b c)))</tt>,
 by evaluating <tt>(list 'car (list 'quote '(a b c)))</tt>.
 
-</p><p><a name="footnote_Temp_230" href="#call_footnote_Temp_230" id="footnote_Temp_230"><sup><small>35</small></sup></a> We can consider two symbols to be “the same” if they
+</p><p><a href="#call_footnote_Temp_230" id="footnote_Temp_230"><sup><small>35</small></sup></a> We can consider two symbols to be “the same” if they
 consist of the same characters in the same order.  Such a definition
 skirts a deep issue that we are not yet ready to address: the meaning
 of “sameness” in a programming language.  We will return to this in
-chapter 3 (section <a href="book-Z-H-20.html#%_sec_3.1.3">3.1.3</a>).
+chapter 3 (section <a href="book-Z-H-20.html#__sec_3.1.3">3.1.3</a>).
 
-</p><p><a name="footnote_Temp_233" href="#call_footnote_Temp_233" id="footnote_Temp_233"><sup><small>36</small></sup></a> In practice, programmers
+</p><p><a href="#call_footnote_Temp_233" id="footnote_Temp_233"><sup><small>36</small></sup></a> In practice, programmers
 use <tt>equal?</tt> to compare lists that contain numbers as well as
 symbols.  Numbers are not considered to be symbols.  The question
-<a name="%_idx_2038" id="%_idx_2038"></a><a name="%_idx_2040" id="%_idx_2040"></a>of whether two numerically equal numbers (as tested by <tt>=</tt>) are also
+<a id="__idx_2038"></a><a id="__idx_2040"></a>of whether two numerically equal numbers (as tested by <tt>=</tt>) are also
 <tt>eq?</tt> is highly implementation-dependent.  A better definition
 of <tt>equal?</tt> (such as the one that comes as a primitive in Scheme)
 would also stipulate that if <tt>a</tt> and <tt>b</tt> are
 both numbers, then <tt>a</tt> and <tt>b</tt> are <tt>equal?</tt> if they are
 numerically equal.
 
-</p><p><a name="footnote_Temp_240" href="#call_footnote_Temp_240" id="footnote_Temp_240"><sup><small>37</small></sup></a> If
+</p><p><a href="#call_footnote_Temp_240" id="footnote_Temp_240"><sup><small>37</small></sup></a> If
 we want to be more formal, we can specify “consistent with the
 interpretations given above” to mean that the operations satisfy a
 collection of rules such as these:</p><p>
@@ -1282,29 +1282,29 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.3">2.3  Symbolic Data</a></h2><p>
 </li></ul><p>
 
 
-</p><p><a name="footnote_Temp_248" href="#call_footnote_Temp_248" id="footnote_Temp_248"><sup><small>38</small></sup></a> Halving the size of the problem at each step is the
-distinguishing characteristic of <a name="%_idx_2148" id="%_idx_2148"></a>logarithmic growth, as we saw with
-the fast-exponentiation algorithm of section <a href="book-Z-H-11.html#%_sec_1.2.4">1.2.4</a>
+</p><p><a href="#call_footnote_Temp_248" id="footnote_Temp_248"><sup><small>38</small></sup></a> Halving the size of the problem at each step is the
+distinguishing characteristic of <a id="__idx_2148"></a>logarithmic growth, as we saw with
+the fast-exponentiation algorithm of section <a href="book-Z-H-11.html#__sec_1.2.4">1.2.4</a>
 and the half-interval search method of
-section <a href="book-Z-H-12.html#%_sec_1.3.3">1.3.3</a>.
+section <a href="book-Z-H-12.html#__sec_1.3.3">1.3.3</a>.
 
-</p><p><a name="footnote_Temp_249" href="#call_footnote_Temp_249" id="footnote_Temp_249"><sup><small>39</small></sup></a> We are
+</p><p><a href="#call_footnote_Temp_249" id="footnote_Temp_249"><sup><small>39</small></sup></a> We are
 representing sets in terms of trees, and trees in terms of lists – in
 effect, a data abstraction built upon a data abstraction.  We can
 regard the procedures <tt>entry</tt>, <tt>left-branch</tt>, <tt>right-branch</tt>, and <tt>make-tree</tt> as a way of isolating the
 abstraction of a “binary tree” from the particular way we might wish
 to represent such a tree in terms of list structure.
 
-</p><p><a name="footnote_Temp_250" href="#call_footnote_Temp_250" id="footnote_Temp_250"><sup><small>40</small></sup></a> Examples of such structures include
-<a name="%_idx_2168" id="%_idx_2168"></a><a name="%_idx_2170" id="%_idx_2170"></a><a name="%_idx_2172" id="%_idx_2172"></a><a name="%_idx_2174" id="%_idx_2174"></a><em>B-trees</em> and <em>red-black trees</em>.  There is a large literature on
+</p><p><a href="#call_footnote_Temp_250" id="footnote_Temp_250"><sup><small>40</small></sup></a> Examples of such structures include
+<a id="__idx_2168"></a><a id="__idx_2170"></a><a id="__idx_2172"></a><a id="__idx_2174"></a><em>B-trees</em> and <em>red-black trees</em>.  There is a large literature on
 data structures devoted to this problem.  See Cormen,
-<a name="%_idx_2176" id="%_idx_2176"></a><a name="%_idx_2178" id="%_idx_2178"></a><a name="%_idx_2180" id="%_idx_2180"></a>Leiserson, and Rivest 1990.
+<a id="__idx_2176"></a><a id="__idx_2178"></a><a id="__idx_2180"></a>Leiserson, and Rivest 1990.
 
-</p><p><a name="footnote_Temp_254" href="#call_footnote_Temp_254" id="footnote_Temp_254"><sup><small>41</small></sup></a> Exercises <a href="#%_thm_2.63">2.63</a>-<a href="#%_thm_2.65">2.65</a>
-<a name="%_idx_2198" id="%_idx_2198"></a>are due to Paul Hilfinger.
+</p><p><a href="#call_footnote_Temp_254" id="footnote_Temp_254"><sup><small>41</small></sup></a> Exercises <a href="#__thm_2.63">2.63</a>-<a href="#__thm_2.65">2.65</a>
+<a id="__idx_2198"></a>are due to Paul Hilfinger.
 
-</p><p><a name="footnote_Temp_258" href="#call_footnote_Temp_258" id="footnote_Temp_258"><sup><small>42</small></sup></a> See Hamming 1980
-<a name="%_idx_2248" id="%_idx_2248"></a>for a discussion of the mathematical properties of Huffman codes.
+</p><p><a href="#call_footnote_Temp_258" id="footnote_Temp_258"><sup><small>42</small></sup></a> See Hamming 1980
+<a id="__idx_2248"></a>for a discussion of the mathematical properties of Huffman codes.
 
 </p></div>
 
diff --git a/src/OEBPS/book-Z-H-17.html b/src/OEBPS/book-Z-H-17.html
index 3d6d067..2c0c94a 100644
--- a/src/OEBPS/book-Z-H-17.html
+++ b/src/OEBPS/book-Z-H-17.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,16 +13,16 @@
 
 
 
-<a name="%_sec_2.4" id="%_sec_2.4"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations for Abstract Data</a></h2><p>
+<a id="__sec_2.4"></a>
+<h2>2.4  Multiple Representations for Abstract Data</h2><p>
 
 
-<a name="%_idx_2286" id="%_idx_2286"></a><a name="%_idx_2288" id="%_idx_2288"></a>
+<a id="__idx_2286"></a><a id="__idx_2288"></a>
 We have introduced data abstraction, a methodology for structuring
 systems in such a way that much of a program can be specified
 independent of the choices involved in implementing the data objects
 that the program manipulates.  For example, we saw in
-section <a href="book-Z-H-14.html#%_sec_2.1.1">2.1.1</a> how to separate the task of designing a
+section <a href="book-Z-H-14.html#__sec_2.1.1">2.1.1</a> how to separate the task of designing a
 program that uses rational numbers from the task of implementing
 rational numbers in terms of the computer language's primitive
 mechanisms for constructing compound data.  The key idea was to erect
@@ -33,7 +33,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 barrier isolates the details of the procedures that perform rational
 arithmetic (<tt>add-rat</tt>, <tt>sub-rat</tt>, <tt>mul-rat</tt>, and <tt>div-rat</tt>) from the “higher-level” procedures that use rational
 numbers.  The resulting program has the structure shown in
-figure <a href="book-Z-H-14.html#%_fig_2.1">2.1</a>.</p><p>
+figure <a href="book-Z-H-14.html#__fig_2.1">2.1</a>.</p><p>
 
 These data-abstraction barriers are powerful tools for controlling
 complexity.  By isolating the underlying representations of data
@@ -64,17 +64,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 choices to coexist in a single program.  Furthermore, since large
 programs are often created by combining pre-existing modules that were
 designed in isolation, we need conventions that permit programmers to
-incorporate modules into larger systems <a name="%_idx_2290" id="%_idx_2290"></a><em>additively</em>, that is,
+incorporate modules into larger systems <a id="__idx_2290"></a><em>additively</em>, that is,
 without having to redesign or reimplement these modules.</p><p>
 
 In this section, we will learn how to cope with data that may be
 represented in different ways by different parts of a program.  This
-requires constructing <a name="%_idx_2292" id="%_idx_2292"></a><a name="%_idx_2294" id="%_idx_2294"></a><em>generic procedures</em> – procedures that can
+requires constructing <a id="__idx_2292"></a><a id="__idx_2294"></a><em>generic procedures</em> – procedures that can
 operate on data that may be represented in more than one way.  Our
 main technique for building generic procedures will be to work in terms
-of data objects that have <a name="%_idx_2296" id="%_idx_2296"></a><em>type tags</em>, that is, data objects
+of data objects that have <a id="__idx_2296"></a><em>type tags</em>, that is, data objects
 that include explicit information about how they are to be processed.
-We will also discuss <a name="%_idx_2298" id="%_idx_2298"></a><em>data-directed</em> programming, a powerful and
+We will also discuss <a id="__idx_2298"></a><em>data-directed</em> programming, a powerful and
 convenient implementation strategy for additively assembling systems
 with generic operations.</p><p>
 
@@ -82,50 +82,50 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 type tags and data-directed style enable us to design separate
 rectangular and polar representations for complex numbers while
 maintaining the notion of an abstract “complex-number” data object.
-<a name="%_idx_2300" id="%_idx_2300"></a><a name="%_idx_2302" id="%_idx_2302"></a>We will accomplish this by defining arithmetic procedures for complex
+<a id="__idx_2300"></a><a id="__idx_2302"></a>We will accomplish this by defining arithmetic procedures for complex
 numbers (<tt>add-complex</tt>, <tt>sub-complex</tt>, <tt>mul-complex</tt>, and
 <tt>div-complex</tt>) in terms of generic selectors that access parts of
 a complex number independent of how the number is represented.  The
 resulting complex-number system, as shown in
-figure <a href="#%_fig_2.19">2.19</a>, contains two different kinds of
-<a name="%_idx_2304" id="%_idx_2304"></a>abstraction barriers.  The “horizontal” abstraction barriers play
+figure <a href="#__fig_2.19">2.19</a>, contains two different kinds of
+<a id="__idx_2304"></a>abstraction barriers.  The “horizontal” abstraction barriers play
 the same role as the ones in
-figure <a href="book-Z-H-14.html#%_fig_2.1">2.1</a>.  They isolate “higher-level”
+figure <a href="book-Z-H-14.html#__fig_2.1">2.1</a>.  They isolate “higher-level”
 operations from “lower-level” representations.  In addition, there
 is a “vertical” barrier that gives us the ability to separately
 design and install alternative representations.</p><p>
 
-<a name="%_fig_2.19" id="%_fig_2.19"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch2-Z-G-54.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 2.19:</b>  Data-abstraction barriers in the complex-number system.</div></caption><tr><td>
+<a id="__fig_2.19"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch2-Z-G-54.gif" alt="ch2-Z-G-54" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.19:</b>  Data-abstraction barriers in the complex-number system.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
 
-In section <a href="book-Z-H-18.html#%_sec_2.5">2.5</a> we will show how to use
+In section <a href="book-Z-H-18.html#__sec_2.5">2.5</a> we will show how to use
 type tags and data-directed style to develop a generic arithmetic
 package.  This provides procedures (<tt>add</tt>, <tt>mul</tt>, and so on)
 that can be used to manipulate all sorts of “numbers” and can be
 easily extended when a new kind of number is needed.
-In section <a href="book-Z-H-18.html#%_sec_2.5.3">2.5.3</a>, we'll show how to use generic
+In section <a href="book-Z-H-18.html#__sec_2.5.3">2.5.3</a>, we'll show how to use generic
 arithmetic in a system that performs symbolic algebra.</p><p>
 
-<a name="%_sec_2.4.1" id="%_sec_2.4.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.4.1">2.4.1  Representations for Complex Numbers</a></h3><p>
+<a id="__sec_2.4.1"></a>
+</p><h3>2.4.1  Representations for Complex Numbers</h3><p>
 
 </p><p>
 
-<a name="%_idx_2306" id="%_idx_2306"></a>We will develop a system that performs arithmetic operations on
+<a id="__idx_2306"></a>We will develop a system that performs arithmetic operations on
 complex numbers as a simple but unrealistic example of a program that
 uses generic operations.  We begin by discussing two plausible
 representations for complex numbers as ordered pairs: rectangular form
 (real part and imaginary part) and polar form (magnitude and
-angle).<a name="call_footnote_Temp_268" href="#footnote_Temp_268" id="call_footnote_Temp_268"><sup><small>43</small></sup></a>  Section <a href="#%_sec_2.4.2">2.4.2</a>
+angle).<a href="#footnote_Temp_268" id="call_footnote_Temp_268"><sup><small>43</small></sup></a>  Section <a href="#__sec_2.4.2">2.4.2</a>
 will show how both representations can be made to coexist in a single
 system through the use of type tags and generic operations.</p><p>
 
 Like rational numbers, complex numbers are naturally represented as
 ordered pairs.  The set of complex numbers can be thought of as a
 two-dimensional space with two orthogonal axes, the “real” axis and
-the “imaginary” axis. (See figure <a href="#%_fig_2.20">2.20</a>.)  From
+the “imaginary” axis. (See figure <a href="#__fig_2.20">2.20</a>.)  From
 this point of view, the complex number <em>z</em> = <em>x</em> + <em>i</em><em>y</em> (where <em>i</em><sup>2</sup>  =  - 1)
 can be thought of as the point in the plane whose real coordinate is <em>x</em> and whose
 imaginary coordinate is <em>y</em>.  Addition of complex numbers reduces in
@@ -136,7 +136,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 
 <p>When multiplying complex numbers, it is more natural to think in terms
 of representing a complex number in polar form, as a magnitude and an
-angle (<em>r</em> and <em>A</em> in figure <a href="#%_fig_2.20">2.20</a>).
+angle (<em>r</em> and <em>A</em> in figure <a href="#__fig_2.20">2.20</a>).
 The product of two complex numbers is the vector obtained by
 stretching one complex number by the length of the other and then
 rotating it through the angle of the other:</p>
@@ -155,13 +155,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 to be able to determine the real part of a complex number that is
 specified by polar coordinates.</p><p>
 
-<a name="%_fig_2.20" id="%_fig_2.20"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch2-Z-G-59.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 2.20:</b>  Complex numbers as points in the plane.</div></caption><tr><td>
+<a id="__fig_2.20"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch2-Z-G-59.gif" alt="ch2-Z-G-59" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.20:</b>  Complex numbers as points in the plane.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-To design such a system, we can follow the same <a name="%_idx_2310" id="%_idx_2310"></a>data-abstraction
+To design such a system, we can follow the same <a id="__idx_2310"></a>data-abstraction
 strategy we followed in designing the rational-number package in
-section <a href="book-Z-H-14.html#%_sec_2.1.1">2.1.1</a>.  Assume that the operations on complex numbers are
+section <a href="book-Z-H-14.html#__sec_2.1.1">2.1.1</a>.  Assume that the operations on complex numbers are
 implemented in terms of four selectors: <tt>real-part</tt>,
 <tt>imag-part</tt>, <tt>magnitude</tt>, and <tt>angle</tt>.  Also assume that
 we have two procedures for constructing complex numbers: <tt>make-from-real-imag</tt> returns a complex number with specified real and
@@ -180,18 +180,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 Using these constructors and selectors, we can implement
 arithmetic on complex numbers using the “abstract data” specified by
 the constructors and selectors, just as we did for rational numbers in
-section <a href="book-Z-H-14.html#%_sec_2.1.1">2.1.1</a>.  As shown in the formulas above, we can add and
+section <a href="book-Z-H-14.html#__sec_2.1.1">2.1.1</a>.  As shown in the formulas above, we can add and
 subtract complex numbers in terms of real and imaginary parts while
 multiplying and dividing complex numbers in terms of magnitudes and
 angles:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2312" id="%_idx_2312"></a>(define (add-complex z1 z2)<br />
+</p><p></p><p><tt><a id="__idx_2312"></a>(define (add-complex z1 z2)<br />
   (make-from-real-imag (+ (real-part z1) (real-part z2))<br />
-                       (+ (imag-part z1) (imag-part z2))))<br /><a name="%_idx_2314" id="%_idx_2314"></a>(define (sub-complex z1 z2)<br />
+                       (+ (imag-part z1) (imag-part z2))))<br /><a id="__idx_2314"></a>(define (sub-complex z1 z2)<br />
   (make-from-real-imag (- (real-part z1) (real-part z2))<br />
-                       (- (imag-part z1) (imag-part z2))))<br /><a name="%_idx_2316" id="%_idx_2316"></a>(define (mul-complex z1 z2)<br />
+                       (- (imag-part z1) (imag-part z2))))<br /><a id="__idx_2316"></a>(define (mul-complex z1 z2)<br />
   (make-from-mag-ang (* (magnitude z1) (magnitude z2))<br />
-                     (+ (angle z1) (angle z2))))<br /><a name="%_idx_2318" id="%_idx_2318"></a>(define (div-complex z1 z2)<br />
+                     (+ (angle z1) (angle z2))))<br /><a id="__idx_2318"></a>(define (div-complex z1 z2)<br />
   (make-from-mag-ang (/ (magnitude z1) (magnitude z2))<br />
                      (- (angle z1) (angle z2))))<br /></tt></p><p></p><p></p><p>
 
@@ -207,48 +207,48 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 In order to make the different choices concrete, imagine that there
 are two programmers, Ben Bitdiddle and Alyssa P. Hacker, who are
 independently designing representations for the complex-number system.
-<a name="%_idx_2320" id="%_idx_2320"></a>Ben chooses to represent complex numbers in rectangular form.  With
+<a id="__idx_2320"></a>Ben chooses to represent complex numbers in rectangular form.  With
 this choice, selecting the real and imaginary parts of a complex
 number is straightforward, as is constructing a complex number with
 given real and imaginary parts.  To find the magnitude and the angle,
 or to construct a complex number with a given magnitude and angle, he
 uses the trigonometric relations</p><p>
 
-</p><p></p><div align="left"><img src="images/ch2-Z-G-60.gif" border="0" /></div><p>
-</p><p></p><div align="left"><img src="images/ch2-Z-G-61.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-60.gif" alt="ch2-Z-G-60" style="border: none;" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-61.gif" alt="ch2-Z-G-61" style="border: none;" /></div><p></p><p>
 
 which relate the real and imaginary parts (<em>x</em>, <em>y</em>) to the magnitude
-and the angle (<em>r</em>, <em>A</em>).<a name="call_footnote_Temp_269" href="#footnote_Temp_269" id="call_footnote_Temp_269"><sup><small>44</small></sup></a>  Ben's representation is
+and the angle (<em>r</em>, <em>A</em>).<a href="#footnote_Temp_269" id="call_footnote_Temp_269"><sup><small>44</small></sup></a>  Ben's representation is
 therefore given by the following selectors and constructors:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2328" id="%_idx_2328"></a>(define (real-part z) (car z))<br /><a name="%_idx_2330" id="%_idx_2330"></a>(define (imag-part z) (cdr z))<br /><a name="%_idx_2332" id="%_idx_2332"></a>(define (magnitude z)<br />
-  (sqrt (+ (square (real-part z)) (square (imag-part z)))))<br /><a name="%_idx_2334" id="%_idx_2334"></a>(define (angle z)<br />
-  (atan (imag-part z) (real-part z)))<br /><a name="%_idx_2336" id="%_idx_2336"></a>(define (make-from-real-imag x y) (cons x y))<br /><a name="%_idx_2338" id="%_idx_2338"></a>(define (make-from-mag-ang r a) <br />
+</p><p></p><p><tt><a id="__idx_2328"></a>(define (real-part z) (car z))<br /><a id="__idx_2330"></a>(define (imag-part z) (cdr z))<br /><a id="__idx_2332"></a>(define (magnitude z)<br />
+  (sqrt (+ (square (real-part z)) (square (imag-part z)))))<br /><a id="__idx_2334"></a>(define (angle z)<br />
+  (atan (imag-part z) (real-part z)))<br /><a id="__idx_2336"></a>(define (make-from-real-imag x y) (cons x y))<br /><a id="__idx_2338"></a>(define (make-from-mag-ang r a) <br />
   (cons (* r (cos a)) (* r (sin a))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_2340" id="%_idx_2340"></a>Alyssa, in contrast, chooses to represent complex numbers in polar
+<a id="__idx_2340"></a>Alyssa, in contrast, chooses to represent complex numbers in polar
 form.  For her, selecting the magnitude and angle is straightforward,
-but she has to use the <a name="%_idx_2342" id="%_idx_2342"></a>trigonometric relations to obtain the real and
+but she has to use the <a id="__idx_2342"></a>trigonometric relations to obtain the real and
 imaginary parts.  Alyssa's representation is:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2344" id="%_idx_2344"></a>(define (real-part z)<br />
-  (* (magnitude z) (cos (angle z))))<br /><a name="%_idx_2346" id="%_idx_2346"></a>(define (imag-part z)<br />
-  (* (magnitude z) (sin (angle z))))<br /><a name="%_idx_2348" id="%_idx_2348"></a>(define (magnitude z) (car z))<br /><a name="%_idx_2350" id="%_idx_2350"></a>(define (angle z) (cdr z))<br /><a name="%_idx_2352" id="%_idx_2352"></a>(define (make-from-real-imag x y) <br />
+</p><p></p><p><tt><a id="__idx_2344"></a>(define (real-part z)<br />
+  (* (magnitude z) (cos (angle z))))<br /><a id="__idx_2346"></a>(define (imag-part z)<br />
+  (* (magnitude z) (sin (angle z))))<br /><a id="__idx_2348"></a>(define (magnitude z) (car z))<br /><a id="__idx_2350"></a>(define (angle z) (cdr z))<br /><a id="__idx_2352"></a>(define (make-from-real-imag x y) <br />
   (cons (sqrt (+ (square x) (square y)))<br />
-        (atan y x)))<br /><a name="%_idx_2354" id="%_idx_2354"></a>(define (make-from-mag-ang r a) (cons r a))<br /></tt></p><p></p><p></p><p>
+        (atan y x)))<br /><a id="__idx_2354"></a>(define (make-from-mag-ang r a) (cons r a))<br /></tt></p><p></p><p></p><p>
 
 The discipline of data abstraction ensures that the same implementation of
 <tt>add-complex</tt>, <tt>sub-complex</tt>, <tt>mul-complex</tt>, and <tt>div-complex</tt> will work with either Ben's representation or Alyssa's
 representation. </p><p>
 
-<a name="%_sec_2.4.2" id="%_sec_2.4.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.4.2">2.4.2  Tagged data</a></h3><p>
+<a id="__sec_2.4.2"></a>
+</p><h3>2.4.2  Tagged data</h3><p>
 
 
-<a name="%_idx_2356" id="%_idx_2356"></a><a name="%_idx_2358" id="%_idx_2358"></a><a name="%_idx_2360" id="%_idx_2360"></a>
+<a id="__idx_2356"></a><a id="__idx_2358"></a><a id="__idx_2360"></a>
 One way to view data abstraction is as an application of the
-<a name="%_idx_2362" id="%_idx_2362"></a><a name="%_idx_2364" id="%_idx_2364"></a>“principle of least commitment.”  In implementing the complex-number
-system in section <a href="#%_sec_2.4.1">2.4.1</a>, we can
+<a id="__idx_2362"></a><a id="__idx_2364"></a>“principle of least commitment.”  In implementing the complex-number
+system in section <a href="#__sec_2.4.1">2.4.1</a>, we can
 use either Ben's rectangular representation or Alyssa's polar
 representation.  The abstraction barrier formed by the selectors and
 constructors permits us to defer to the last possible moment the
@@ -266,7 +266,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 we wouldn't know whether to answer 5 (interpreting the number in
 rectangular form) or 3 (interpreting the number in polar form).  A
 straightforward way to accomplish this distinction is to include a
-<a name="%_idx_2366" id="%_idx_2366"></a><em>type tag</em> – the symbol <tt>rectangular</tt> or <tt>polar</tt> – as
+<a id="__idx_2366"></a><em>type tag</em> – the symbol <tt>rectangular</tt> or <tt>polar</tt> – as
 part of each complex number.  Then when we need to manipulate a
 complex number we can use the tag to decide which selector to apply.</p><p>
 
@@ -277,11 +277,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 object.  A straightforward way to implement this is to use ordinary
 list structure:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2368" id="%_idx_2368"></a>(define (attach-tag type-tag contents)<br />
-  (cons type-tag contents))<br /><a name="%_idx_2370" id="%_idx_2370"></a>(define (type-tag datum)<br />
+</p><p></p><p><tt><a id="__idx_2368"></a>(define (attach-tag type-tag contents)<br />
+  (cons type-tag contents))<br /><a id="__idx_2370"></a>(define (type-tag datum)<br />
   (if (pair? datum)<br />
       (car datum)<br />
-      (error "Bad tagged datum -- TYPE-TAG" datum)))<br /><a name="%_idx_2372" id="%_idx_2372"></a>(define (contents datum)<br />
+      (error "Bad tagged datum -- TYPE-TAG" datum)))<br /><a id="__idx_2372"></a>(define (contents datum)<br />
   (if (pair? datum)<br />
       (cdr datum)<br />
       (error "Bad tagged datum -- CONTENTS" datum)))<br /></tt></p><p></p><p></p><p>
@@ -290,8 +290,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 and <tt>polar?</tt>, which recognize polar and rectangular numbers,
 respectively:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2374" id="%_idx_2374"></a>(define (rectangular? z)<br />
-  (eq? (type-tag z) 'rectangular))<br /><a name="%_idx_2376" id="%_idx_2376"></a>(define (polar? z)<br />
+</p><p></p><p><tt><a id="__idx_2374"></a>(define (rectangular? z)<br />
+  (eq? (type-tag z) 'rectangular))<br /><a id="__idx_2376"></a>(define (polar? z)<br />
   (eq? (type-tag z) 'polar))<br /></tt></p><p></p><p></p><p>
 
 With type tags, Ben and Alyssa can now modify their code so that
@@ -303,28 +303,28 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 the suffix <tt>rectangular</tt> to the name of each of his representation
 procedures and for Alyssa to append <tt>polar</tt> to the names of hers.
 Here is Ben's revised rectangular representation from
-section <a href="#%_sec_2.4.1">2.4.1</a>:</p><p>
+section <a href="#__sec_2.4.1">2.4.1</a>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2378" id="%_idx_2378"></a>(define (real-part-rectangular z) (car z))<br /><a name="%_idx_2380" id="%_idx_2380"></a>(define (imag-part-rectangular z) (cdr z))<br /><a name="%_idx_2382" id="%_idx_2382"></a>(define (magnitude-rectangular z)<br />
+</p><p></p><p><tt><a id="__idx_2378"></a>(define (real-part-rectangular z) (car z))<br /><a id="__idx_2380"></a>(define (imag-part-rectangular z) (cdr z))<br /><a id="__idx_2382"></a>(define (magnitude-rectangular z)<br />
   (sqrt (+ (square (real-part-rectangular z))<br />
-           (square (imag-part-rectangular z)))))<br /><a name="%_idx_2384" id="%_idx_2384"></a>(define (angle-rectangular z)<br />
+           (square (imag-part-rectangular z)))))<br /><a id="__idx_2384"></a>(define (angle-rectangular z)<br />
   (atan (imag-part-rectangular z)<br />
-        (real-part-rectangular z)))<br /><a name="%_idx_2386" id="%_idx_2386"></a>(define (make-from-real-imag-rectangular x y)<br />
-  (attach-tag 'rectangular (cons x y)))<br /><a name="%_idx_2388" id="%_idx_2388"></a>(define (make-from-mag-ang-rectangular r a) <br />
+        (real-part-rectangular z)))<br /><a id="__idx_2386"></a>(define (make-from-real-imag-rectangular x y)<br />
+  (attach-tag 'rectangular (cons x y)))<br /><a id="__idx_2388"></a>(define (make-from-mag-ang-rectangular r a) <br />
   (attach-tag 'rectangular<br />
               (cons (* r (cos a)) (* r (sin a)))))<br /></tt></p><p></p><p>
 and here is Alyssa's revised polar representation:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2390" id="%_idx_2390"></a>(define (real-part-polar z)<br />
-  (* (magnitude-polar z) (cos (angle-polar z))))<br /><a name="%_idx_2392" id="%_idx_2392"></a>(define (imag-part-polar z)<br />
-  (* (magnitude-polar z) (sin (angle-polar z))))<br /><a name="%_idx_2394" id="%_idx_2394"></a>(define (magnitude-polar z) (car z))<br /><a name="%_idx_2396" id="%_idx_2396"></a>(define (angle-polar z) (cdr z))<br /><a name="%_idx_2398" id="%_idx_2398"></a>(define (make-from-real-imag-polar x y) <br />
+</p><p></p><p><tt><a id="__idx_2390"></a>(define (real-part-polar z)<br />
+  (* (magnitude-polar z) (cos (angle-polar z))))<br /><a id="__idx_2392"></a>(define (imag-part-polar z)<br />
+  (* (magnitude-polar z) (sin (angle-polar z))))<br /><a id="__idx_2394"></a>(define (magnitude-polar z) (car z))<br /><a id="__idx_2396"></a>(define (angle-polar z) (cdr z))<br /><a id="__idx_2398"></a>(define (make-from-real-imag-polar x y) <br />
   (attach-tag 'polar<br />
                (cons (sqrt (+ (square x) (square y)))<br />
-                     (atan y x))))<br /><a name="%_idx_2400" id="%_idx_2400"></a>(define (make-from-mag-ang-polar r a)<br />
+                     (atan y x))))<br /><a id="__idx_2400"></a>(define (make-from-mag-ang-polar r a)<br />
   (attach-tag 'polar (cons r a)))<br /></tt></p><p></p><p></p><p>
 
 
-<a name="%_idx_2402" id="%_idx_2402"></a><a name="%_idx_2404" id="%_idx_2404"></a>Each generic selector is implemented as a procedure that checks the
+<a id="__idx_2402"></a><a id="__idx_2404"></a>Each generic selector is implemented as a procedure that checks the
 tag of its argument and calls the appropriate procedure for handling
 data of that type.  For example, to obtain the real part of a complex
 number, <tt>real-part</tt> examines the tag to determine whether to use
@@ -332,22 +332,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 In either case, we use <tt>contents</tt> to extract the bare, untagged
 datum and send this to the rectangular or polar procedure as required:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2406" id="%_idx_2406"></a>(define (real-part z)<br />
+</p><p></p><p><tt><a id="__idx_2406"></a>(define (real-part z)<br />
   (cond ((rectangular? z) <br />
          (real-part-rectangular (contents z)))<br />
         ((polar? z)<br />
          (real-part-polar (contents z)))<br />
-        (else (error "Unknown type -- REAL-PART" z))))<br /><a name="%_idx_2408" id="%_idx_2408"></a>(define (imag-part z)<br />
+        (else (error "Unknown type -- REAL-PART" z))))<br /><a id="__idx_2408"></a>(define (imag-part z)<br />
   (cond ((rectangular? z)<br />
          (imag-part-rectangular (contents z)))<br />
         ((polar? z)<br />
          (imag-part-polar (contents z)))<br />
-        (else (error "Unknown type -- IMAG-PART" z))))<br /><a name="%_idx_2410" id="%_idx_2410"></a>(define (magnitude z)<br />
+        (else (error "Unknown type -- IMAG-PART" z))))<br /><a id="__idx_2410"></a>(define (magnitude z)<br />
   (cond ((rectangular? z)<br />
          (magnitude-rectangular (contents z)))<br />
         ((polar? z)<br />
          (magnitude-polar (contents z)))<br />
-        (else (error "Unknown type -- MAGNITUDE" z))))<br /><a name="%_idx_2412" id="%_idx_2412"></a>(define (angle z)<br />
+        (else (error "Unknown type -- MAGNITUDE" z))))<br /><a id="__idx_2412"></a>(define (angle z)<br />
   (cond ((rectangular? z)<br />
          (angle-rectangular (contents z)))<br />
         ((polar? z)<br />
@@ -356,7 +356,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 
 To implement the complex-number arithmetic operations, we can use the
 same procedures <tt>add-complex</tt>, <tt>sub-complex</tt>, <tt>mul-complex</tt>, and <tt>div-complex</tt> from
-section <a href="#%_sec_2.4.1">2.4.1</a>, because the
+section <a href="#__sec_2.4.1">2.4.1</a>, because the
 selectors they call are generic, and so will work with either
 representation.  For example, the procedure <tt>add-complex</tt> is still</p><p>
 
@@ -370,16 +370,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 imaginary parts and to construct polar numbers whenever we have
 magnitudes and angles:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2414" id="%_idx_2414"></a>(define (make-from-real-imag x y)<br />
-  (make-from-real-imag-rectangular x y))<br /><a name="%_idx_2416" id="%_idx_2416"></a>(define (make-from-mag-ang r a)<br />
+</p><p></p><p><tt><a id="__idx_2414"></a>(define (make-from-real-imag x y)<br />
+  (make-from-real-imag-rectangular x y))<br /><a id="__idx_2416"></a>(define (make-from-mag-ang r a)<br />
   (make-from-mag-ang-polar r a))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_fig_2.21" id="%_fig_2.21"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch2-Z-G-62.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 2.21:</b>  Structure of the generic complex-arithmetic system.</div></caption><tr><td>
-<a name="%_idx_2418" id="%_idx_2418"></a>
+<a id="__fig_2.21"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch2-Z-G-62.gif" alt="ch2-Z-G-62" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.21:</b>  Structure of the generic complex-arithmetic system.</div></caption><tr><td>
+<a id="__idx_2418"></a>
 </td></tr></table></div><p></p><p>
 
 The resulting complex-number system has the structure shown in
-figure <a href="#%_fig_2.21">2.21</a>.  The system has been
+figure <a href="#__fig_2.21">2.21</a>.  The system has been
 decomposed into three relatively independent parts: the
 complex-number-arithmetic operations, Alyssa's polar
 implementation, and Ben's rectangular implementation.  The polar and
@@ -389,7 +389,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 complex-arithmetic procedures in terms of the abstract
 constructor/selector interface.</p><p>
 
-<a name="%_idx_2420" id="%_idx_2420"></a><a name="%_idx_2422" id="%_idx_2422"></a>Since each data object is tagged with its type, the selectors operate
+<a id="__idx_2420"></a><a id="__idx_2422"></a>Since each data object is tagged with its type, the selectors operate
 on the data in a generic manner.  That is, each selector is defined to
 have a behavior that depends upon the particular type of data it is
 applied to.  Notice the general mechanism for interfacing the separate
@@ -402,20 +402,20 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 recognized by the higher-level procedures.  This discipline of
 stripping off and attaching tags as data objects are passed from level
 to level can be an important organizational strategy, as we shall see
-in section <a href="book-Z-H-18.html#%_sec_2.5">2.5</a>.
+in section <a href="book-Z-H-18.html#__sec_2.5">2.5</a>.
 
 </p><p>
 
-<a name="%_sec_2.4.3" id="%_sec_2.4.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.4.3">2.4.3  Data-Directed Programming and Additivity</a></h3><p>
+<a id="__sec_2.4.3"></a>
+</p><h3>2.4.3  Data-Directed Programming and Additivity</h3><p>
 
 
-<a name="%_idx_2424" id="%_idx_2424"></a><a name="%_idx_2426" id="%_idx_2426"></a>
-<a name="%_idx_2428" id="%_idx_2428"></a>The general strategy of checking the type of a datum and calling an
-appropriate procedure is called <a name="%_idx_2430" id="%_idx_2430"></a><a name="%_idx_2432" id="%_idx_2432"></a><em>dispatching on type</em>.  This is a
+<a id="__idx_2424"></a><a id="__idx_2426"></a>
+<a id="__idx_2428"></a>The general strategy of checking the type of a datum and calling an
+appropriate procedure is called <a id="__idx_2430"></a><a id="__idx_2432"></a><em>dispatching on type</em>.  This is a
 powerful strategy for obtaining modularity in system design.  On
 the other hand, implementing the dispatch as in
-section <a href="#%_sec_2.4.2">2.4.2</a> has two significant weaknesses.  One
+section <a href="#__sec_2.4.2">2.4.2</a> has two significant weaknesses.  One
 weakness is that the generic interface procedures (<tt>real-part</tt>,
 <tt>imag-part</tt>, <tt>magnitude</tt>, and <tt>angle</tt>) must know about all
 the different representations.  For instance, suppose we wanted to
@@ -429,7 +429,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 representations can be designed separately, we must guarantee that
 no two procedures in the entire system have the same name.  This is
 why Ben and Alyssa had to change the names of their original
-procedures from section <a href="#%_sec_2.4.1">2.4.1</a>.</p><p>
+procedures from section <a href="#__sec_2.4.1">2.4.1</a>.</p><p>
 
 The issue underlying both of these weaknesses is that the technique
 for implementing generic interfaces is not <em>additive</em>.  The person
@@ -461,10 +461,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 actual procedure was spread out among the various conditional clauses
 in the generic interface procedures.  But the same information could
 have been organized in a table, as shown in
-figure <a href="#%_fig_2.22">2.22</a>.</p><p>
+figure <a href="#__fig_2.22">2.22</a>.</p><p>
 
 
-<a name="%_idx_2434" id="%_idx_2434"></a>Data-directed programming is the technique of designing programs to
+<a id="__idx_2434"></a>Data-directed programming is the technique of designing programs to
 work with such a table directly.  Previously, we implemented the
 mechanism that interfaces the complex-arithmetic code with the two
 representation packages as a set of procedures that each perform an
@@ -476,19 +476,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 representation package to the system we need not change any existing
 procedures; we need only add new entries to the table.</p><p>
 
-<a name="%_fig_2.22" id="%_fig_2.22"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch2-Z-G-63.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 2.22:</b>  Table of operations for the complex-number system.</div></caption><tr><td>
+<a id="__fig_2.22"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch2-Z-G-63.gif" alt="ch2-Z-G-63" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.22:</b>  Table of operations for the complex-number system.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
 To implement this plan, assume that we have two procedures,
 <tt>put</tt> and <tt>get</tt>, for manipulating the
 operation-and-type table:
-<a name="%_idx_2436" id="%_idx_2436"></a>
-</p><p></p><ul><a name="%_idx_2438" id="%_idx_2438"></a><li><tt>(put &lt;<em>op</em>&gt; &lt;<em>type</em>&gt; &lt;<em>item</em>&gt;)</tt><br />
+<a id="__idx_2436"></a>
+</p><p></p><ul><a id="__idx_2438"></a><li><tt>(put &lt;<em>op</em>&gt; &lt;<em>type</em>&gt; &lt;<em>item</em>&gt;)</tt><br />
 installs the <tt>&lt;<em>item</em>&gt;</tt> in the table, indexed by the
 <tt>&lt;<em>op</em>&gt;</tt> and the <tt>&lt;<em>type</em>&gt;</tt>.<p>
 
-<a name="%_idx_2440" id="%_idx_2440"></a></p></li><li><tt>(get &lt;<em>op</em>&gt; &lt;<em>type</em>&gt;)</tt><br />
+<a id="__idx_2440"></a></p></li><li><tt>(get &lt;<em>op</em>&gt; &lt;<em>type</em>&gt;)</tt><br />
 looks up the <tt>&lt;<em>op</em>&gt;</tt>, <tt>&lt;<em>type</em>&gt;</tt> entry in the table
 and returns the item found there.  If no item is found, <tt>get</tt>
 returns false.
@@ -496,7 +496,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 
 For now, we can assume that <tt>put</tt> and <tt>get</tt> are
 included in our language.  In chapter 3
-(section <a href="book-Z-H-22.html#%_sec_3.3.3">3.3.3</a>, exercise <a href="book-Z-H-22.html#%_thm_3.24">3.24</a>)
+(section <a href="book-Z-H-22.html#__sec_3.3.3">3.3.3</a>, exercise <a href="book-Z-H-22.html#__thm_3.24">3.24</a>)
 we will see how to implement these and
 other operations for manipulating tables.</p><p>
 
@@ -504,12 +504,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 Here is how data-directed programming can be used in the
 complex-number system.  Ben, who developed the rectangular
 representation, implements his code just as he did originally.  He
-defines a collection of procedures, or a <a name="%_idx_2442" id="%_idx_2442"></a><em>package</em>, and interfaces
+defines a collection of procedures, or a <a id="__idx_2442"></a><em>package</em>, and interfaces
 these to the rest of the system by adding entries to the table that
 tell the system how to operate on rectangular numbers.
 This is accomplished by calling the following procedure:
-<a name="%_idx_2444" id="%_idx_2444"></a><a name="%_idx_2446" id="%_idx_2446"></a>
-</p><p></p><p><tt><a name="%_idx_2448" id="%_idx_2448"></a>(define (install-rectangular-package)<br />
+<a id="__idx_2444"></a><a id="__idx_2446"></a>
+</p><p></p><p><tt><a id="__idx_2448"></a>(define (install-rectangular-package)<br />
   <em>;; internal procedures</em><br />
   (define (real-part z) (car z))<br />
   (define (imag-part z) (cdr z))<br />
@@ -534,7 +534,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
   'done)<br /></tt></p><p></p><p></p><p>
 
 Notice that the internal procedures here are the same procedures from
-section <a href="#%_sec_2.4.1">2.4.1</a> that Ben wrote when
+section <a href="#__sec_2.4.1">2.4.1</a> that Ben wrote when
 he was working in isolation.  No changes are necessary in order to
 interface them to the rest of the system.  Moreover, since these
 procedure definitions are internal to the installation procedure, Ben
@@ -542,14 +542,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 rectangular package.  To interface these to the rest of the system,
 Ben installs his <tt>real-part</tt> procedure under the operation name
 <tt>real-part</tt> and the type <tt>(rectangular)</tt>, and similarly
-for the other selectors.<a name="call_footnote_Temp_270" href="#footnote_Temp_270" id="call_footnote_Temp_270"><sup><small>45</small></sup></a>  The interface also defines
-the constructors to be used by the external system.<a name="call_footnote_Temp_271" href="#footnote_Temp_271" id="call_footnote_Temp_271"><sup><small>46</small></sup></a>
+for the other selectors.<a href="#footnote_Temp_270" id="call_footnote_Temp_270"><sup><small>45</small></sup></a>  The interface also defines
+the constructors to be used by the external system.<a href="#footnote_Temp_271" id="call_footnote_Temp_271"><sup><small>46</small></sup></a>
 These are
 identical to Ben's internally defined constructors, except that they
 attach the tag.</p><p>
 
-<a name="%_idx_2450" id="%_idx_2450"></a><a name="%_idx_2452" id="%_idx_2452"></a>Alyssa's polar package is analogous:
-</p><p></p><p><tt><a name="%_idx_2454" id="%_idx_2454"></a>(define (install-polar-package)<br />
+<a id="__idx_2450"></a><a id="__idx_2452"></a>Alyssa's polar package is analogous:
+</p><p></p><p><tt><a id="__idx_2454"></a>(define (install-polar-package)<br />
   <em>;; internal procedures</em><br />
   (define (magnitude z) (car z))<br />
   (define (angle z) (cdr z))<br />
@@ -577,16 +577,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 Even though Ben and Alyssa both still use their original procedures
 defined with the same names as each other's (e.g., <tt>real-part</tt>), these
 definitions are now internal to different procedures (see
-section <a href="book-Z-H-10.html#%_sec_1.1.8">1.1.8</a>), so there is no name
+section <a href="book-Z-H-10.html#__sec_1.1.8">1.1.8</a>), so there is no name
 conflict.</p><p>
 
 The complex-arithmetic selectors access the table by means of a
 general “operation” procedure called <tt>apply-generic</tt>, which
 applies a generic operation to some arguments.  <tt>Apply-generic</tt>
 looks in the table under the name of the operation and the types of the
-arguments and applies the resulting procedure if one is present:<a name="call_footnote_Temp_272" href="#footnote_Temp_272" id="call_footnote_Temp_272"><sup><small>47</small></sup></a></p><p>
+arguments and applies the resulting procedure if one is present:<a href="#footnote_Temp_272" id="call_footnote_Temp_272"><sup><small>47</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_2462" id="%_idx_2462"></a>(define (apply-generic op . args)<br />
+</p><p></p><p><tt><a id="__idx_2462"></a>(define (apply-generic op . args)<br />
   (let ((type-tags (map type-tag args)))<br />
     (let ((proc (get op type-tags)))<br />
       (if proc<br />
@@ -596,7 +596,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
             (list op type-tags))))))<br /></tt></p><p></p><p>
 Using <tt>apply-generic</tt>, we can define our generic selectors as follows:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2464" id="%_idx_2464"></a>(define (real-part z) (apply-generic 'real-part z))<br /><a name="%_idx_2466" id="%_idx_2466"></a>(define (imag-part z) (apply-generic 'imag-part z))<br /><a name="%_idx_2468" id="%_idx_2468"></a>(define (magnitude z) (apply-generic 'magnitude z))<br /><a name="%_idx_2470" id="%_idx_2470"></a>(define (angle z) (apply-generic 'angle z))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_2464"></a>(define (real-part z) (apply-generic 'real-part z))<br /><a id="__idx_2466"></a>(define (imag-part z) (apply-generic 'imag-part z))<br /><a id="__idx_2468"></a>(define (magnitude z) (apply-generic 'magnitude z))<br /><a id="__idx_2470"></a>(define (angle z) (apply-generic 'angle z))<br /></tt></p><p></p><p>
 Observe that these do not change at all if a new representation is
 added to the system.</p><p>
 
@@ -604,18 +604,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 constructors to be used by the programs external to the packages in
 making complex numbers from real and imaginary parts and from
 magnitudes and angles.
-As in section <a href="#%_sec_2.4.2">2.4.2</a>, we
+As in section <a href="#__sec_2.4.2">2.4.2</a>, we
 construct rectangular numbers whenever we have real and
 imaginary parts, and polar numbers whenever we have magnitudes and angles:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2472" id="%_idx_2472"></a>(define (make-from-real-imag x y)<br />
-  ((get 'make-from-real-imag 'rectangular) x y))<br /><a name="%_idx_2474" id="%_idx_2474"></a>(define (make-from-mag-ang r a)<br />
+</p><p></p><p><tt><a id="__idx_2472"></a>(define (make-from-real-imag x y)<br />
+  ((get 'make-from-real-imag 'rectangular) x y))<br /><a id="__idx_2474"></a>(define (make-from-mag-ang r a)<br />
   ((get 'make-from-mag-ang 'polar) r a))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_2.73" id="%_thm_2.73"></a>
-<b>Exercise 2.73.</b>  Section <a href="book-Z-H-16.html#%_sec_2.3.2">2.3.2</a> described a program that
+</p><p><a id="__thm_2.73"></a>
+<b>Exercise 2.73.</b>  Section <a href="book-Z-H-16.html#__sec_2.3.2">2.3.2</a> described a program that
 performs symbolic differentiation:
-<a name="%_idx_2476" id="%_idx_2476"></a><a name="%_idx_2478" id="%_idx_2478"></a></p><p></p><p><tt>(define (deriv exp var)<br />
+<a id="__idx_2476"></a><a id="__idx_2478"></a></p><p></p><p><tt>(define (deriv exp var)<br />
   (cond ((number? exp) 0)<br />
         ((variable? exp) (if (same-variable? exp var) 1 0))<br />
         ((sum? exp)<br />
@@ -635,7 +635,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 operation being performed is <tt>deriv</tt>.  We can transform this
 program into data-directed style by rewriting the basic derivative
 procedure as
-</p><p></p><p><tt><a name="%_idx_2480" id="%_idx_2480"></a>(define (deriv exp var)<br />
+</p><p></p><p><tt><a id="__idx_2480"></a>(define (deriv exp var)<br />
    (cond ((number? exp) 0)<br />
          ((variable? exp) (if (same-variable? exp var) 1 0))<br />
          (else ((get 'deriv (operator exp)) (operands exp)<br />
@@ -651,7 +651,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 program above.</p><p>
 
 c.  Choose any additional differentiation rule that you like, such as
-the one for exponents (exercise <a href="book-Z-H-16.html#%_thm_2.56">2.56</a>),
+the one for exponents (exercise <a href="book-Z-H-16.html#__thm_2.56">2.56</a>),
 and install it in this data-directed system.</p><p>
 
 d.  In this simple algebraic manipulator the type of an expression is
@@ -665,8 +665,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 </p><p></p><p>
 
 
-</p><p><a name="%_thm_2.74" id="%_thm_2.74"></a>
-<b>Exercise 2.74.</b>  <a name="%_idx_2482" id="%_idx_2482"></a><a name="%_idx_2484" id="%_idx_2484"></a>Insatiable Enterprises, Inc., is a highly decentralized conglomerate
+</p><p><a id="__thm_2.74"></a>
+<b>Exercise 2.74.</b>  <a id="__idx_2482"></a><a id="__idx_2484"></a>Insatiable Enterprises, Inc., is a highly decentralized conglomerate
 company consisting of a large number of independent divisions located
 all over the world.  The company's computer facilities have just been
 interconnected by means of a clever network-interfacing scheme that
@@ -709,14 +709,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 central system?
 </p><p>
 
-<a name="%_sec_Temp_275" id="%_sec_Temp_275"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_275">Message passing</a></h4><p>
+<a id="__sec_Temp_275"></a>
+</p><h4>Message passing</h4><p>
 
-<a name="%_idx_2486" id="%_idx_2486"></a>
+<a id="__idx_2486"></a>
 The key idea of data-directed programming is to handle generic
 operations in programs by dealing explicitly with operation-and-type
-tables, such as the table in figure <a href="#%_fig_2.22">2.22</a>.  The
-style of programming we used in section <a href="#%_sec_2.4.2">2.4.2</a>
+tables, such as the table in figure <a href="#__fig_2.22">2.22</a>.  The
+style of programming we used in section <a href="#__sec_2.4.2">2.4.2</a>
 organized the required dispatching on type by having each operation
 take care of its own dispatching.  In effect, this decomposes the
 operation-and-type table into rows, with each generic operation
@@ -731,7 +731,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 operation indicated.  In such a discipline, <tt>make-from-real-imag</tt>
 could be written as</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2488" id="%_idx_2488"></a>(define (make-from-real-imag x y)<br />
+</p><p></p><p><tt><a id="__idx_2488"></a>(define (make-from-real-imag x y)<br />
   (define (dispatch op)<br />
     (cond ((eq? op 'real-part) x)<br />
           ((eq? op 'imag-part) y)<br />
@@ -743,9 +743,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
   dispatch)<br /></tt></p><p></p><p>
 The corresponding <tt>apply-generic</tt> procedure, which applies a
 generic operation to an argument, now simply feeds the operation's
-name to the data object and lets the object do the work:<a name="call_footnote_Temp_276" href="#footnote_Temp_276" id="call_footnote_Temp_276"><sup><small>48</small></sup></a></p><p>
+name to the data object and lets the object do the work:<a href="#footnote_Temp_276" id="call_footnote_Temp_276"><sup><small>48</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_2490" id="%_idx_2490"></a>(define (apply-generic op arg) (arg op))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_2490"></a>(define (apply-generic op arg) (arg op))<br /></tt></p><p></p><p>
 Note that the value returned by <tt>make-from-real-imag</tt> is a
 procedure – the internal <tt>dispatch</tt> procedure.  This is the
 procedure that is invoked when <tt>apply-generic</tt> requests an operation to
@@ -754,7 +754,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 This style of programming is called <em>message passing</em>.  The name
 comes from the image that a data object is an entity that receives the
 requested operation name as a “message.”  We have already seen an
-example of message passing in section <a href="book-Z-H-14.html#%_sec_2.1.3">2.1.3</a>, where we saw
+example of message passing in section <a href="book-Z-H-14.html#__sec_2.1.3">2.1.3</a>, where we saw
 how <tt>cons</tt>, <tt>car</tt>, and <tt>cdr</tt> could be defined with no data
 objects but only procedures.  Here we see that message passing is not
 a mathematical trick but a useful technique for organizing systems
@@ -764,14 +764,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 will return to message passing, and we will see that it can be a
 powerful tool for structuring simulation programs.</p><p>
 
-</p><p><a name="%_thm_2.75" id="%_thm_2.75"></a>
-<b>Exercise 2.75.</b>  <a name="%_idx_2492" id="%_idx_2492"></a>Implement the constructor <tt>make-from-mag-ang</tt> in message-passing style.
+</p><p><a id="__thm_2.75"></a>
+<b>Exercise 2.75.</b>  <a id="__idx_2492"></a>Implement the constructor <tt>make-from-mag-ang</tt> in message-passing style.
 This procedure should be analogous to the <tt>make-from-real-imag</tt>
 procedure given above.
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.76" id="%_thm_2.76"></a>
-<b>Exercise 2.76.</b>  <a name="%_idx_2494" id="%_idx_2494"></a>As a large system with generic operations evolves, new types of data
+</p><p><a id="__thm_2.76"></a>
+<b>Exercise 2.76.</b>  <a id="__idx_2494"></a>As a large system with generic operations evolves, new types of data
 objects or new operations may be needed.  For each of the three
 strategies – generic operations with explicit dispatch, data-directed
 style, and message-passing-style – describe the changes that must be
@@ -782,43 +782,43 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.4">2.4  Multiple Representations fo
 </p><p></p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_268" href="#call_footnote_Temp_268" id="footnote_Temp_268"><sup><small>43</small></sup></a> In actual computational systems, rectangular form is
-preferable to polar form most of the time because of <a name="%_idx_2308" id="%_idx_2308"></a>roundoff errors
+</p><div class="footnote"><p><a href="#call_footnote_Temp_268" id="footnote_Temp_268"><sup><small>43</small></sup></a> In actual computational systems, rectangular form is
+preferable to polar form most of the time because of <a id="__idx_2308"></a>roundoff errors
 in conversion between rectangular and polar form.  This is why the
 complex-number example is unrealistic.  Nevertheless, it provides a
 clear illustration of the design of a system using generic operations
 and a good introduction to the more substantial systems to be
 developed later in this chapter.
 
-</p><p><a name="footnote_Temp_269" href="#call_footnote_Temp_269" id="footnote_Temp_269"><sup><small>44</small></sup></a> The arctangent function referred to
-<a name="%_idx_2322" id="%_idx_2322"></a><a name="%_idx_2324" id="%_idx_2324"></a><a name="%_idx_2326" id="%_idx_2326"></a>here, computed by Scheme's <tt>atan</tt> procedure,
+</p><p><a href="#call_footnote_Temp_269" id="footnote_Temp_269"><sup><small>44</small></sup></a> The arctangent function referred to
+<a id="__idx_2322"></a><a id="__idx_2324"></a><a id="__idx_2326"></a>here, computed by Scheme's <tt>atan</tt> procedure,
 is defined so as to take two arguments <em>y</em> and <em>x</em> and to return
 the angle whose tangent is <em>y</em>/<em>x</em>.  The signs of the arguments
 determine the quadrant of the angle.
 
-</p><p><a name="footnote_Temp_270" href="#call_footnote_Temp_270" id="footnote_Temp_270"><sup><small>45</small></sup></a> We use the list <tt>(rectangular)</tt>
+</p><p><a href="#call_footnote_Temp_270" id="footnote_Temp_270"><sup><small>45</small></sup></a> We use the list <tt>(rectangular)</tt>
 rather than the symbol <tt>rectangular</tt> to allow for the possibility
 of operations with multiple arguments, not all of the same
 type.
 
-</p><p><a name="footnote_Temp_271" href="#call_footnote_Temp_271" id="footnote_Temp_271"><sup><small>46</small></sup></a> The
+</p><p><a href="#call_footnote_Temp_271" id="footnote_Temp_271"><sup><small>46</small></sup></a> The
 type the constructors are installed under needn't be a list because
 a constructor is always used to make an object of one particular
 type.
 
-</p><p><a name="footnote_Temp_272" href="#call_footnote_Temp_272" id="footnote_Temp_272"><sup><small>47</small></sup></a> <tt>Apply-generic</tt> uses the <a name="%_idx_2456" id="%_idx_2456"></a>dotted-tail notation described in
-exercise <a href="book-Z-H-15.html#%_thm_2.20">2.20</a>, because different generic operations
+</p><p><a href="#call_footnote_Temp_272" id="footnote_Temp_272"><sup><small>47</small></sup></a> <tt>Apply-generic</tt> uses the <a id="__idx_2456"></a>dotted-tail notation described in
+exercise <a href="book-Z-H-15.html#__thm_2.20">2.20</a>, because different generic operations
 may take different numbers of arguments.  In <tt>apply-generic</tt>, <tt>op</tt> has as its value the first argument to <tt>apply-generic</tt> and
 <tt>args</tt> has as its value a list of the remaining arguments.</p><p>
 
-<tt>Apply-generic</tt> also uses the primitive procedure <a name="%_idx_2458" id="%_idx_2458"></a><a name="%_idx_2460" id="%_idx_2460"></a><tt>apply</tt>,
+<tt>Apply-generic</tt> also uses the primitive procedure <a id="__idx_2458"></a><a id="__idx_2460"></a><tt>apply</tt>,
 which takes two arguments, a procedure and a list.  <tt>Apply</tt>
 applies the procedure, using the elements in the list as arguments.
 For example,
 </p><p></p><p><tt>(apply + (list 1 2 3 4))<br /></tt></p><p></p><p>
 returns 10.
 
-</p><p><a name="footnote_Temp_276" href="#call_footnote_Temp_276" id="footnote_Temp_276"><sup><small>48</small></sup></a> One
+</p><p><a href="#call_footnote_Temp_276" id="footnote_Temp_276"><sup><small>48</small></sup></a> One
 limitation of this organization is it permits only generic procedures
 of one argument.
 
diff --git a/src/OEBPS/book-Z-H-18.html b/src/OEBPS/book-Z-H-18.html
index 9f9931c..0eb4ecd 100644
--- a/src/OEBPS/book-Z-H-18.html
+++ b/src/OEBPS/book-Z-H-18.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,12 +13,12 @@
 
 
 
-<a name="%_sec_2.5" id="%_sec_2.5"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operations</a></h2><p>
+<a id="__sec_2.5"></a>
+<h2>2.5  Systems with Generic Operations</h2><p>
 
 </p><p>
 
-<a name="%_idx_2496" id="%_idx_2496"></a>In the previous section, we saw how to design systems in which data
+<a id="__idx_2496"></a>In the previous section, we saw how to design systems in which data
 objects can be represented in more than one way.  The key idea is to
 link the code that specifies the data operations to the several
 representations by means of generic interface procedures.  Now we will
@@ -28,14 +28,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 seen several different packages of arithmetic operations: the primitive
 arithmetic (<tt>+</tt>, <tt>-</tt>, <tt>*</tt>, <tt>/</tt>) built into our
 language, the rational-number arithmetic (<tt>add-rat</tt>, <tt>sub-rat</tt>, <tt>mul-rat</tt>, <tt>div-rat</tt>) of
-section <a href="book-Z-H-14.html#%_sec_2.1.1">2.1.1</a>, and the complex-number arithmetic that we
-implemented in section <a href="book-Z-H-17.html#%_sec_2.4.3">2.4.3</a>.  We will now use
+section <a href="book-Z-H-14.html#__sec_2.1.1">2.1.1</a>, and the complex-number arithmetic that we
+implemented in section <a href="book-Z-H-17.html#__sec_2.4.3">2.4.3</a>.  We will now use
 data-directed techniques to construct a package of arithmetic
 operations that incorporates all the arithmetic packages we have already
 constructed.</p><p>
 
-Figure <a href="#%_fig_2.23">2.23</a> shows the structure of the system we
-shall build.  Notice the <a name="%_idx_2498" id="%_idx_2498"></a>abstraction barriers.  From the perspective
+Figure <a href="#__fig_2.23">2.23</a> shows the structure of the system we
+shall build.  Notice the <a id="__idx_2498"></a>abstraction barriers.  From the perspective
 of someone using “numbers,” there is a single procedure <tt>add</tt>
 that operates on whatever numbers are supplied.  <tt>Add</tt> is part of
 a generic interface that allows the separate ordinary-arithmetic,
@@ -48,15 +48,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 that one can design the individual arithmetic packages separately and
 combine them to produce a generic arithmetic system.
 
-<a name="%_fig_2.23" id="%_fig_2.23"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch2-Z-G-64.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 2.23:</b>  Generic arithmetic system.</div></caption><tr><td>
-<a name="%_idx_2500" id="%_idx_2500"></a>
+<a id="__fig_2.23"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch2-Z-G-64.gif" alt="ch2-Z-G-64" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.23:</b>  Generic arithmetic system.</div></caption><tr><td>
+<a id="__idx_2500"></a>
 </td></tr></table></div><p></p><p>
 
-<a name="%_sec_2.5.1" id="%_sec_2.5.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.5.1">2.5.1  Generic Arithmetic Operations</a></h3><p>
+<a id="__sec_2.5.1"></a>
+</p><h3>2.5.1  Generic Arithmetic Operations</h3><p>
 
 
-<a name="%_idx_2502" id="%_idx_2502"></a>
+<a id="__idx_2502"></a>
 The task of designing generic arithmetic operations is analogous to
 that of designing the generic complex-number operations.  We would
 like, for instance, to have a generic addition procedure <tt>add</tt> that
@@ -64,7 +64,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 like <tt>add-rat</tt> on rational numbers, and like <tt>add-complex</tt> on
 complex numbers.  We can implement <tt>add</tt>, and the other generic
 arithmetic operations, by following the same strategy we used in
-section <a href="book-Z-H-17.html#%_sec_2.4.3">2.4.3</a> to implement the generic selectors for
+section <a href="book-Z-H-17.html#__sec_2.4.3">2.4.3</a> to implement the generic selectors for
 complex numbers.  We will attach a type tag to each kind of
 number and cause the generic procedure to dispatch to an appropriate
 package according to the data type of its arguments.</p><p>
@@ -72,18 +72,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 The generic arithmetic procedures are defined as follows:</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_2504" id="%_idx_2504"></a>(define (add x y) (apply-generic 'add x y))<br /><a name="%_idx_2506" id="%_idx_2506"></a>(define (sub x y) (apply-generic 'sub x y))<br /><a name="%_idx_2508" id="%_idx_2508"></a>(define (mul x y) (apply-generic 'mul x y))<br /><a name="%_idx_2510" id="%_idx_2510"></a>(define (div x y) (apply-generic 'div x y))<br /></tt></p><p></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_2504"></a>(define (add x y) (apply-generic 'add x y))<br /><a id="__idx_2506"></a>(define (sub x y) (apply-generic 'sub x y))<br /><a id="__idx_2508"></a>(define (mul x y) (apply-generic 'mul x y))<br /><a id="__idx_2510"></a>(define (div x y) (apply-generic 'div x y))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_2512" id="%_idx_2512"></a><a name="%_idx_2514" id="%_idx_2514"></a>We begin by installing a package for handling <em>ordinary</em> numbers,
+<a id="__idx_2512"></a><a id="__idx_2514"></a>We begin by installing a package for handling <em>ordinary</em> numbers,
 that is, the primitive numbers of our language.  We will tag these
 with the symbol <tt>scheme-number</tt>.  The arithmetic operations in this
 package are the primitive arithmetic procedures (so there is no need to
 define extra procedures to handle the untagged numbers).  Since
 these operations each take two arguments, they are installed in the
 table keyed by the list <tt>(scheme-number scheme-number)</tt>:
-<a name="%_idx_2516" id="%_idx_2516"></a><a name="%_idx_2518" id="%_idx_2518"></a>
+<a id="__idx_2516"></a><a id="__idx_2518"></a>
 
-</p><p></p><p><tt><a name="%_idx_2520" id="%_idx_2520"></a>(define (install-scheme-number-package)<br />
+</p><p></p><p><tt><a id="__idx_2520"></a>(define (install-scheme-number-package)<br />
   (define (tag x)<br />
     (attach-tag 'scheme-number x))    <br />
   (put 'add '(scheme-number scheme-number)<br />
@@ -103,17 +103,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 will create (tagged) ordinary numbers by means of the procedure:</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_2522" id="%_idx_2522"></a>(define (make-scheme-number n)<br />
+</p><p></p><p><tt><a id="__idx_2522"></a>(define (make-scheme-number n)<br />
   ((get 'make 'scheme-number) n))<br /></tt></p><p></p><p></p><p>
 
 Now that the framework of the generic arithmetic system is in place,
 we can readily include new kinds of numbers.  Here is a package that
 performs rational arithmetic.  Notice that, as a benefit of
 additivity, we can use without modification the rational-number code
-from section <a href="book-Z-H-14.html#%_sec_2.1.1">2.1.1</a> as the internal procedures in the
+from section <a href="book-Z-H-14.html#__sec_2.1.1">2.1.1</a> as the internal procedures in the
 package:
-<a name="%_idx_2524" id="%_idx_2524"></a><a name="%_idx_2526" id="%_idx_2526"></a><a name="%_idx_2528" id="%_idx_2528"></a>
-</p><p></p><p><tt><a name="%_idx_2530" id="%_idx_2530"></a>(define (install-rational-package)<br />
+<a id="__idx_2524"></a><a id="__idx_2526"></a><a id="__idx_2528"></a>
+</p><p></p><p><tt><a id="__idx_2530"></a>(define (install-rational-package)<br />
   <em>;; internal procedures</em><br />
   (define (numer x) (car x))<br />
   (define (denom x) (cdr x))<br />
@@ -146,17 +146,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
        (lambda (x y) (tag (div-rat x y))))<br /><br />
   (put 'make 'rational<br />
        (lambda (n d) (tag (make-rat n d))))<br />
-  'done)<br /><a name="%_idx_2532" id="%_idx_2532"></a>(define (make-rational n d)<br />
+  'done)<br /><a id="__idx_2532"></a>(define (make-rational n d)<br />
   ((get 'make 'rational) n d))<br /></tt></p><p></p><p></p><p>
 
 We can install a similar package to handle complex numbers, using the
 tag <tt>complex</tt>.  In creating the package, we extract from the table
 the operations <tt>make-from-real-imag</tt> and <tt>make-from-mag-ang</tt>
-that were defined by the rectangular and polar packages.  <a name="%_idx_2534" id="%_idx_2534"></a>Additivity
+that were defined by the rectangular and polar packages.  <a id="__idx_2534"></a>Additivity
 permits us to use, as the internal operations, the same <tt>add-complex</tt>, <tt>sub-complex</tt>, <tt>mul-complex</tt>, and <tt>div-complex</tt> procedures from
-section <a href="book-Z-H-17.html#%_sec_2.4.1">2.4.1</a>.
-<a name="%_idx_2536" id="%_idx_2536"></a><a name="%_idx_2538" id="%_idx_2538"></a><a name="%_idx_2540" id="%_idx_2540"></a>
-</p><p></p><p><tt><a name="%_idx_2542" id="%_idx_2542"></a>(define (install-complex-package)<br />
+section <a href="book-Z-H-17.html#__sec_2.4.1">2.4.1</a>.
+<a id="__idx_2536"></a><a id="__idx_2538"></a><a id="__idx_2540"></a>
+</p><p></p><p><tt><a id="__idx_2542"></a>(define (install-complex-package)<br />
   <em>;; imported procedures from rectangular and polar packages</em><br />
   (define (make-from-real-imag x y)<br />
     ((get 'make-from-real-imag 'rectangular) x y))<br />
@@ -198,13 +198,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 the rectangular and polar packages, are exported to the complex
 package, and exported from there to the outside world.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2544" id="%_idx_2544"></a>(define (make-complex-from-real-imag x y)<br />
-  ((get 'make-from-real-imag 'complex) x y))<br /><a name="%_idx_2546" id="%_idx_2546"></a>(define (make-complex-from-mag-ang r a)<br />
+</p><p></p><p><tt><a id="__idx_2544"></a>(define (make-complex-from-real-imag x y)<br />
+  ((get 'make-from-real-imag 'complex) x y))<br /><a id="__idx_2546"></a>(define (make-complex-from-mag-ang r a)<br />
   ((get 'make-from-mag-ang 'complex) r a))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_2548" id="%_idx_2548"></a>What we have here is a two-level tag system.  A typical complex number,
+<a id="__idx_2548"></a>What we have here is a two-level tag system.  A typical complex number,
 such as 3 + 4<em>i</em> in rectangular form, would be
-represented as shown in figure <a href="#%_fig_2.24">2.24</a>.
+represented as shown in figure <a href="#__fig_2.24">2.24</a>.
 The outer tag (<tt>complex</tt>) is used to direct the number to the
 complex package.  Once within the complex package, the next tag (<tt>rectangular</tt>) is used to direct the number to the rectangular package.
 In a large and complicated system there might be many levels, each
@@ -213,7 +213,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 it to the appropriate package is stripped off (by applying <tt>contents</tt>) and the next level of tag (if any) becomes visible to be used for
 further dispatching.</p><p>
 
-<a name="%_fig_2.24" id="%_fig_2.24"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch2-Z-G-65.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 2.24:</b>  Representation of 3 + 4<em>i</em> in rectangular form.</div></caption><tr><td>
+<a id="__fig_2.24"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch2-Z-G-65.gif" alt="ch2-Z-G-65" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.24:</b>  Representation of 3 + 4<em>i</em> in rectangular form.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
@@ -224,10 +224,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 we could simply name them <tt>add</tt>, <tt>sub</tt>, <tt>mul</tt>, and <tt>div</tt>
 in both packages.</p><p>
 
-</p><p><a name="%_thm_2.77" id="%_thm_2.77"></a>
+</p><p><a id="__thm_2.77"></a>
 <b>Exercise 2.77.</b>  Louis Reasoner tries to evaluate the
 expression <tt>(magnitude z)</tt> where <tt>z</tt> is the object
-shown in figure <a href="#%_fig_2.24">2.24</a>.  To his
+shown in figure <a href="#__fig_2.24">2.24</a>.  To his
 surprise, instead of the answer 5
 he gets an error message from <tt>apply-generic</tt>,
 saying there is no method for the operation <tt>magnitude</tt>
@@ -245,13 +245,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 Describe in detail why this works.  As an example, trace through all
 the procedures called in evaluating the expression <tt>(magnitude z)</tt>
 where <tt>z</tt> is the object shown in
-figure <a href="#%_fig_2.24">2.24</a>.  In particular, how many
+figure <a href="#__fig_2.24">2.24</a>.  In particular, how many
 times is <tt>apply-generic</tt> invoked?  What procedure is dispatched to
 in each case?
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.78" id="%_thm_2.78"></a>
-<b>Exercise 2.78.</b>  <a name="%_idx_2550" id="%_idx_2550"></a><a name="%_idx_2552" id="%_idx_2552"></a><a name="%_idx_2554" id="%_idx_2554"></a><a name="%_idx_2556" id="%_idx_2556"></a><a name="%_idx_2558" id="%_idx_2558"></a><a name="%_idx_2560" id="%_idx_2560"></a><a name="%_idx_2562" id="%_idx_2562"></a>The internal procedures in the <tt>scheme-number</tt> package are essentially
+</p><p><a id="__thm_2.78"></a>
+<b>Exercise 2.78.</b>  <a id="__idx_2550"></a><a id="__idx_2552"></a><a id="__idx_2554"></a><a id="__idx_2556"></a><a id="__idx_2558"></a><a id="__idx_2560"></a><a id="__idx_2562"></a>The internal procedures in the <tt>scheme-number</tt> package are essentially
 nothing more than calls to the primitive procedures <tt>+</tt>, <tt>-</tt>,
 etc.  It was not possible to use the primitives of the language
 directly because our type-tag system requires that each data
@@ -260,7 +260,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 Primitive predicates such as <tt>symbol?</tt> and <tt>number?</tt>
 determine whether data objects have particular types.  Modify the
 definitions of <tt>type-tag</tt>, <tt>contents</tt>, and <tt>attach-tag</tt>
-from section <a href="book-Z-H-17.html#%_sec_2.4.2">2.4.2</a> so that our generic system takes
+from section <a href="book-Z-H-17.html#__sec_2.4.2">2.4.2</a> so that our generic system takes
 advantage of Scheme's internal type system.  That is to say, the system
 should work as before except that ordinary numbers should be
 represented simply as Scheme numbers rather than as pairs whose <tt>car</tt> is
@@ -268,16 +268,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.79" id="%_thm_2.79"></a>
-<b>Exercise 2.79.</b>  <a name="%_idx_2564" id="%_idx_2564"></a><a name="%_idx_2566" id="%_idx_2566"></a>Define a generic equality predicate <tt>equ?</tt> that tests the equality
+</p><p><a id="__thm_2.79"></a>
+<b>Exercise 2.79.</b>  <a id="__idx_2564"></a><a id="__idx_2566"></a>Define a generic equality predicate <tt>equ?</tt> that tests the equality
 of two numbers, and install it in the generic arithmetic
 package.  This operation should work for ordinary numbers, rational numbers, and
 complex numbers.
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.80" id="%_thm_2.80"></a>
-<b>Exercise 2.80.</b>  <a name="%_idx_2568" id="%_idx_2568"></a><a name="%_idx_2570" id="%_idx_2570"></a>Define a generic
+</p><p><a id="__thm_2.80"></a>
+<b>Exercise 2.80.</b>  <a id="__idx_2568"></a><a id="__idx_2570"></a>Define a generic
 predicate <tt>=zero?</tt> that tests if its argument is zero,
 and install it in the generic arithmetic package.  This
 operation should work for ordinary numbers, rational numbers, and
@@ -285,8 +285,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 
 </p><p>
 
-<a name="%_sec_2.5.2" id="%_sec_2.5.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.5.2">2.5.2  Combining Data of Different Types</a></h3><p>
+<a id="__sec_2.5.2"></a>
+</p><h3>2.5.2  Combining Data of Different Types</h3><p>
 
 </p><p>
 
@@ -305,12 +305,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 controlled way, so that we can support them
 without seriously violating our module boundaries.</p><p>
 
-<a name="%_idx_2572" id="%_idx_2572"></a><a name="%_idx_2574" id="%_idx_2574"></a><a name="%_idx_2576" id="%_idx_2576"></a>One way to handle cross-type operations is to design a different
+<a id="__idx_2572"></a><a id="__idx_2574"></a><a id="__idx_2576"></a>One way to handle cross-type operations is to design a different
 procedure for each possible combination of types for which the
 operation is valid.  For example, we could extend the complex-number
 package so that it provides a procedure for adding complex numbers to
-ordinary numbers and installs this in the table using the tag <tt>(complex scheme-number)</tt>:<a name="call_footnote_Temp_283" href="#footnote_Temp_283" id="call_footnote_Temp_283"><sup><small>49</small></sup></a>
-</p><p></p><p><tt><em>;; to be included in the complex package</em><br /><a name="%_idx_2578" id="%_idx_2578"></a>(define (add-complex-to-schemenum z x)<br />
+ordinary numbers and installs this in the table using the tag <tt>(complex scheme-number)</tt>:<a href="#footnote_Temp_283" id="call_footnote_Temp_283"><sup><small>49</small></sup></a>
+</p><p></p><p><tt><em>;; to be included in the complex package</em><br /><a id="__idx_2578"></a>(define (add-complex-to-schemenum z x)<br />
   (make-from-real-imag (+ (real-part z) x)<br />
                        (imag-part z)))<br />
 (put 'add '(complex scheme-number)<br />
@@ -335,10 +335,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 in designing systems with many packages and many cross-type
 operations.</p><p>
 
-<a name="%_sec_Temp_284" id="%_sec_Temp_284"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_284">Coercion</a></h4><p>
+<a id="__sec_Temp_284"></a>
+</p><h4>Coercion</h4><p>
 
-<a name="%_idx_2580" id="%_idx_2580"></a>
+<a id="__idx_2580"></a>
 In the general situation of completely unrelated operations acting on
 completely unrelated types, implementing explicit cross-type
 operations, cumbersome though it may be, is the best that one can hope
@@ -353,15 +353,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 combining two complex numbers, which can be handled in the ordinary
 way by the complex-arithmetic package.</p><p>
 
-<a name="%_idx_2582" id="%_idx_2582"></a>In general, we can implement this idea by designing coercion
+<a id="__idx_2582"></a>In general, we can implement this idea by designing coercion
 procedures that transform an object of one type into an equivalent
 object of another type.  Here is a typical coercion procedure, which
 transforms a given ordinary number to a complex number with that real
 part and zero imaginary part:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2584" id="%_idx_2584"></a>(define (scheme-number-&gt;complex n)<br />
+</p><p></p><p><tt><a id="__idx_2584"></a>(define (scheme-number-&gt;complex n)<br />
   (make-complex-from-real-imag (contents n) 0))<br /></tt></p><p></p><p>
-<a name="%_idx_2586" id="%_idx_2586"></a><a name="%_idx_2588" id="%_idx_2588"></a>We install these coercion procedures in a special coercion table,
+<a id="__idx_2586"></a><a id="__idx_2588"></a>We install these coercion procedures in a special coercion table,
 indexed under the names of the two types:</p><p>
 
 </p><p></p><p><tt>(put-coercion 'scheme-number 'complex scheme-number-&gt;complex)<br /></tt></p><p></p><p>
@@ -374,12 +374,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 
 Once the coercion table has been set up, we can handle coercion in a
 uniform manner by modifying the <tt>apply-generic</tt> procedure of
-section <a href="book-Z-H-17.html#%_sec_2.4.3">2.4.3</a>.  When asked to apply an operation, we
+section <a href="book-Z-H-17.html#__sec_2.4.3">2.4.3</a>.  When asked to apply an operation, we
 first check whether the operation is defined for the arguments' types,
 just as before.  If so, we dispatch to the procedure found in the
 operation-and-type table.
 Otherwise, we try coercion.  For simplicity, we consider only the case
-where there are two arguments.<a name="call_footnote_Temp_285" href="#footnote_Temp_285" id="call_footnote_Temp_285"><sup><small>50</small></sup></a>  We
+where there are two arguments.<a href="#footnote_Temp_285" id="call_footnote_Temp_285"><sup><small>50</small></sup></a>  We
 check the coercion table to see if objects of the first type can
 be coerced to the second type.  If so, we coerce the first argument and try the
 operation again.  If objects of the first type cannot in general be coerced to
@@ -389,7 +389,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 is no known way to coerce either type to the other type, we give up.
 Here is the procedure:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2590" id="%_idx_2590"></a>(define (apply-generic op . args)<br />
+</p><p></p><p><tt><a id="__idx_2590"></a>(define (apply-generic op . args)<br />
   (let ((type-tags (map type-tag args)))<br />
     (let ((proc (get op type-tags)))<br />
       (if proc<br />
@@ -416,7 +416,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 need to write coercion procedures to relate the types (possibly <em>n</em><sup>2</sup>
 procedures for a system with <em>n</em> types), we need to write only one
 procedure for each pair of types rather than a different procedure for
-each collection of types and each generic operation.<a name="call_footnote_Temp_286" href="#footnote_Temp_286" id="call_footnote_Temp_286"><sup><small>51</small></sup></a>  What we are counting on here is the fact that the
+each collection of types and each generic operation.<a href="#footnote_Temp_286" id="call_footnote_Temp_286"><sup><small>51</small></sup></a>  What we are counting on here is the fact that the
 appropriate transformation between types depends only on the types
 themselves, not on the operation to be applied.</p><p>
 
@@ -429,10 +429,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 that take advantage of still further structure in the relations among
 types, as we discuss next.</p><p>
 
-<a name="%_sec_Temp_287" id="%_sec_Temp_287"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_287">Hierarchies of types</a></h4><p>
+<a id="__sec_Temp_287"></a>
+</p><h4>Hierarchies of types</h4><p>
 
-<a name="%_idx_2592" id="%_idx_2592"></a><a name="%_idx_2594" id="%_idx_2594"></a>
+<a id="__idx_2592"></a><a id="__idx_2594"></a>
 The coercion scheme presented above relied on the existence of natural
 relations between pairs of types.  Often there is more “global”
 structure in how the different types relate to each other.  For
@@ -442,15 +442,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 special kind of rational number, which is in turn a special kind of
 real number, which is in turn a special kind of complex number.  What
 we actually have is a so-called <em>hierarchy of types</em>, in which,
-for example, integers are a <a name="%_idx_2596" id="%_idx_2596"></a><a name="%_idx_2598" id="%_idx_2598"></a><em>subtype</em> of rational numbers (i.e.,
+for example, integers are a <a id="__idx_2596"></a><a id="__idx_2598"></a><em>subtype</em> of rational numbers (i.e.,
 any operation that can be applied to a rational number can
 automatically be applied to an integer).  Conversely, we say that
-rational numbers form a <a name="%_idx_2600" id="%_idx_2600"></a><a name="%_idx_2602" id="%_idx_2602"></a><em>supertype</em> of integers.  The particular
+rational numbers form a <a id="__idx_2600"></a><a id="__idx_2602"></a><em>supertype</em> of integers.  The particular
 hierarchy we have here is of a very simple kind, in which each type
 has at most one supertype and at most one subtype.  Such a structure,
-called a <em>tower</em>, is illustrated in figure <a href="#%_fig_2.25">2.25</a>.</p>
+called a <em>tower</em>, is illustrated in figure <a href="#__fig_2.25">2.25</a>.</p>
 
-<p><a name="%_fig_2.25" id="%_fig_2.25"></a>
+<p><a id="__fig_2.25"></a>
 <p class="centered">
     complex<br/>
     ↑<br/>
@@ -462,7 +462,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 </p>
 
 <div><b>Figure 2.25:</b>  A tower of types.</div>
-<a name="%_idx_2604" id="%_idx_2604"></a><a name="%_idx_2606" id="%_idx_2606"></a>
+<a id="__idx_2604"></a><a id="__idx_2606"></a>
 </p>
 
 <p>If we have a tower structure, then we can greatly simplify the problem
@@ -477,13 +477,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 transform the integer into a complex number through these steps and
 then add the two complex numbers.</p><p>
 
-<a name="%_idx_2608" id="%_idx_2608"></a><a name="%_idx_2610" id="%_idx_2610"></a>We can redesign our <tt>apply-generic</tt> procedure in the following
+<a id="__idx_2608"></a><a id="__idx_2610"></a>We can redesign our <tt>apply-generic</tt> procedure in the following
 way: For each type, we need to supply a <tt>raise</tt> procedure, which
 “raises” objects of that type one level in the tower.  Then when the
 system is required to operate on objects of different types it can
 successively raise the lower types until all the objects are at
-the same level in the tower.  (Exercises <a href="#%_thm_2.83">2.83</a>
-and  <a href="#%_thm_2.84">2.84</a>
+the same level in the tower.  (Exercises <a href="#__thm_2.83">2.83</a>
+and  <a href="#__thm_2.84">2.84</a>
 concern the details of implementing such a strategy.)</p><p>
 
 Another advantage of a tower is that we can easily implement the
@@ -498,31 +498,31 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 go, until we either find a level at which the desired operation can be
 performed or hit the top (in which case we give up).</p><p>
 
-<a name="%_idx_2612" id="%_idx_2612"></a>Yet another advantage of a tower over a more general hierarchy is that
+<a id="__idx_2612"></a>Yet another advantage of a tower over a more general hierarchy is that
 it gives us a simple way to “lower” a data object to the simplest
 representation.  For example, if we add 2 + 3<em>i</em> to 4 - 3<em>i</em>, it would be
 nice to obtain the answer as the integer 6 rather than as the complex
-number 6 + 0<em>i</em>.  Exercise <a href="#%_thm_2.85">2.85</a> discusses a way to implement
+number 6 + 0<em>i</em>.  Exercise <a href="#__thm_2.85">2.85</a> discusses a way to implement
 such a lowering operation.  (The trick is that we need a general way
 to distinguish those objects that can be lowered, such as 6 + 0<em>i</em>, from
 those that cannot, such as 6 + 2<em>i</em>.)</p><p>
 
-<a name="%_fig_2.26" id="%_fig_2.26"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch2-Z-G-67.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 2.26:</b>  Relations among types of geometric figures.</div></caption><tr><td>
+<a id="__fig_2.26"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch2-Z-G-67.gif" alt="ch2-Z-G-67" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 2.26:</b>  Relations among types of geometric figures.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_sec_Temp_288" id="%_sec_Temp_288"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_288">Inadequacies of hierarchies</a></h4><p>
+<a id="__sec_Temp_288"></a>
+</p><h4>Inadequacies of hierarchies</h4><p>
 
-<a name="%_idx_2614" id="%_idx_2614"></a>
+<a id="__idx_2614"></a>
 
 If the data types in our system can be naturally arranged in a tower,
 this greatly simplifies the problems of dealing with generic operations
 on different types, as we have seen.  Unfortunately, this is usually
-not the case.  Figure <a href="#%_fig_2.26">2.26</a> illustrates a
+not the case.  Figure <a href="#__fig_2.26">2.26</a> illustrates a
 more complex arrangement of mixed types, this one showing relations
 among different types of geometric figures.  We see that, in general,
-<a name="%_idx_2616" id="%_idx_2616"></a><a name="%_idx_2618" id="%_idx_2618"></a><a name="%_idx_2620" id="%_idx_2620"></a>a type may have more than one subtype.  Triangles and quadrilaterals,
+<a id="__idx_2616"></a><a id="__idx_2618"></a><a id="__idx_2620"></a>a type may have more than one subtype.  Triangles and quadrilaterals,
 for instance, are both subtypes of polygons.  In addition, a type may
 have more than one supertype.  For example, an isosceles right
 triangle may be regarded either as an isosceles triangle or as a right
@@ -534,11 +534,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 type, there is a similar problem in coercing a value “down” the type
 hierarchy.  Dealing with large numbers of interrelated types while
 still preserving modularity in the design of large systems is very
-difficult, and is an area of much current research.<a name="call_footnote_Temp_289" href="#footnote_Temp_289" id="call_footnote_Temp_289"><sup><small>52</small></sup></a></p><p>
+difficult, and is an area of much current research.<a href="#footnote_Temp_289" id="call_footnote_Temp_289"><sup><small>52</small></sup></a></p><p>
 
 
-</p><p><a name="%_thm_2.81" id="%_thm_2.81"></a>
-<b>Exercise 2.81.</b>  <a name="%_idx_2626" id="%_idx_2626"></a>Louis Reasoner has noticed that <tt>apply-generic</tt> may try to
+</p><p><a id="__thm_2.81"></a>
+<b>Exercise 2.81.</b>  <a id="__idx_2626"></a>Louis Reasoner has noticed that <tt>apply-generic</tt> may try to
 coerce the arguments to each other's type even if they already have
 the same type.  Therefore, he reasons, we need to put procedures
 in the coercion table to "coerce" arguments of each type to their
@@ -547,7 +547,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 
 
 
-</p><p></p><p><tt><a name="%_idx_2628" id="%_idx_2628"></a>(define (scheme-number-&gt;scheme-number n) n)<br /><a name="%_idx_2630" id="%_idx_2630"></a>(define (complex-&gt;complex z) z)<br />
+</p><p></p><p><tt><a id="__idx_2628"></a>(define (scheme-number-&gt;scheme-number n) n)<br /><a id="__idx_2630"></a>(define (complex-&gt;complex z) z)<br />
 (put-coercion 'scheme-number 'scheme-number<br />
               scheme-number-&gt;scheme-number)<br />
 (put-coercion 'complex 'complex complex-&gt;complex)<br /></tt></p><p></p><p></p><p>
@@ -577,8 +577,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 the two arguments have the same type.
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.82" id="%_thm_2.82"></a>
-<b>Exercise 2.82.</b>  <a name="%_idx_2632" id="%_idx_2632"></a>Show how to generalize <tt>apply-generic</tt> to handle
+</p><p><a id="__thm_2.82"></a>
+<b>Exercise 2.82.</b>  <a id="__idx_2632"></a>Show how to generalize <tt>apply-generic</tt> to handle
 coercion in the general case of multiple arguments.  One strategy is
 to attempt to coerce all the arguments to the type of the first argument, then
 to the type of the second argument, and so on.  Give an example of a situation
@@ -589,17 +589,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.83" id="%_thm_2.83"></a>
-<b>Exercise 2.83.</b>  <a name="%_idx_2634" id="%_idx_2634"></a>Suppose you are designing a generic arithmetic system for dealing with
-the tower of types shown in figure <a href="#%_fig_2.25">2.25</a>:
+</p><p><a id="__thm_2.83"></a>
+<b>Exercise 2.83.</b>  <a id="__idx_2634"></a>Suppose you are designing a generic arithmetic system for dealing with
+the tower of types shown in figure <a href="#__fig_2.25">2.25</a>:
 integer, rational, real, complex.  For
 each type (except complex), design a procedure that raises objects of
 that type one level in the tower.  Show how to install a generic <tt>raise</tt> operation that will work for each type (except complex).
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.84" id="%_thm_2.84"></a>
-<b>Exercise 2.84.</b>  <a name="%_idx_2636" id="%_idx_2636"></a>Using the <tt>raise</tt> operation of exercise <a href="#%_thm_2.83">2.83</a>, modify the <tt>apply-generic</tt> procedure so that it coerces its arguments to have the
+</p><p><a id="__thm_2.84"></a>
+<b>Exercise 2.84.</b>  <a id="__idx_2636"></a>Using the <tt>raise</tt> operation of exercise <a href="#__thm_2.83">2.83</a>, modify the <tt>apply-generic</tt> procedure so that it coerces its arguments to have the
 same type by the method of successive raising, as discussed in this
 section.  You will need to devise a way to test which of two types is
 higher in the tower.  Do this in a manner that is “compatible” with
@@ -608,11 +608,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_2.85" id="%_thm_2.85"></a>
-<b>Exercise 2.85.</b>  <a name="%_idx_2638" id="%_idx_2638"></a><a name="%_idx_2640" id="%_idx_2640"></a>This section mentioned a method for “simplifying” a data object
+</p><p><a id="__thm_2.85"></a>
+<b>Exercise 2.85.</b>  <a id="__idx_2638"></a><a id="__idx_2640"></a>This section mentioned a method for “simplifying” a data object
 by lowering it in the tower of types as far as possible.  Design
 a procedure <tt>drop</tt> that accomplishes this for the tower described
-in exercise <a href="#%_thm_2.83">2.83</a>.  The key is to decide, in some general way, whether
+in exercise <a href="#__thm_2.83">2.83</a>.  The key is to decide, in some general way, whether
 an object can be lowered.  For example, the complex number 1.5 + 0<em>i</em>
 can be lowered as far as <tt>real</tt>, the complex number 1 + 0<em>i</em> can be
 lowered as far as <tt>integer</tt>, and the complex number 2 + 3<em>i</em> cannot
@@ -625,15 +625,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 equal to what we started with.  Show how to implement this idea in
 detail, by writing a <tt>drop</tt> procedure that drops an object as far
 as possible.  You will need to design the various projection
-operations<a name="call_footnote_Temp_295" href="#footnote_Temp_295" id="call_footnote_Temp_295"><sup><small>53</small></sup></a> and install <tt>project</tt> as a generic operation in
+operations<a href="#footnote_Temp_295" id="call_footnote_Temp_295"><sup><small>53</small></sup></a> and install <tt>project</tt> as a generic operation in
 the system.  You will also need to make use of a generic equality
-predicate, such as described in exercise <a href="#%_thm_2.79">2.79</a>.  Finally, use <tt>drop</tt>
-to rewrite <tt>apply-generic</tt> from exercise <a href="#%_thm_2.84">2.84</a> so that it
+predicate, such as described in exercise <a href="#__thm_2.79">2.79</a>.  Finally, use <tt>drop</tt>
+to rewrite <tt>apply-generic</tt> from exercise <a href="#__thm_2.84">2.84</a> so that it
 “simplifies” its answers.
 
 </p><p> </p><p>
 
-</p><p><a name="%_thm_2.86" id="%_thm_2.86"></a>
+</p><p><a id="__thm_2.86"></a>
 <b>Exercise 2.86.</b>  Suppose we want to handle complex numbers whose real
 parts, imaginary parts, magnitudes, and angles can be either ordinary
 numbers, rational numbers, or other numbers we might wish to add to
@@ -643,15 +643,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 </p><p>
 </p><p>
 
-<a name="%_sec_2.5.3" id="%_sec_2.5.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_2.5.3">2.5.3  Example: Symbolic Algebra</a></h3><p>
+<a id="__sec_2.5.3"></a>
+</p><h3>2.5.3  Example: Symbolic Algebra</h3><p>
 
 
-<a name="%_idx_2646" id="%_idx_2646"></a>
+<a id="__idx_2646"></a>
 The manipulation of symbolic algebraic expressions is a complex
 process that illustrates many of the hardest problems that occur in
 the design of large-scale systems.  An algebraic expression, in
-<a name="%_idx_2648" id="%_idx_2648"></a>general, can be viewed as a hierarchical structure, a tree of
+<a id="__idx_2648"></a>general, can be viewed as a hierarchical structure, a tree of
 operators applied to operands.  We can construct algebraic expressions
 by starting with a set of primitive objects, such as constants and
 variables, and combining these by means of algebraic operators, such
@@ -676,14 +676,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 the designer of such a system faces, and how to apply the ideas of
 abstract data and generic operations to help organize this effort.</p><p>
 
-<a name="%_sec_Temp_297" id="%_sec_Temp_297"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_297">Arithmetic on polynomials</a></h4><p>
+<a id="__sec_Temp_297"></a>
+</p><h4>Arithmetic on polynomials</h4><p>
 
-<a name="%_idx_2650" id="%_idx_2650"></a><a name="%_idx_2652" id="%_idx_2652"></a>
+<a id="__idx_2650"></a><a id="__idx_2652"></a>
 Our first task in designing a system for performing arithmetic on
 polynomials is to decide just what a polynomial is.  Polynomials are
-normally defined relative to certain variables (the <a name="%_idx_2654" id="%_idx_2654"></a><a name="%_idx_2656" id="%_idx_2656"></a><em>indeterminates</em> of the polynomial).  For simplicity, we will restrict
-ourselves to polynomials having just one indeterminate (<a name="%_idx_2658" id="%_idx_2658"></a><a name="%_idx_2660" id="%_idx_2660"></a><em>univariate polynomials</em>).<a name="call_footnote_Temp_298" href="#footnote_Temp_298" id="call_footnote_Temp_298"><sup><small>54</small></sup></a> We will define a polynomial to be a
+normally defined relative to certain variables (the <a id="__idx_2654"></a><a id="__idx_2656"></a><em>indeterminates</em> of the polynomial).  For simplicity, we will restrict
+ourselves to polynomials having just one indeterminate (<a id="__idx_2658"></a><a id="__idx_2660"></a><em>univariate polynomials</em>).<a href="#footnote_Temp_298" id="call_footnote_Temp_298"><sup><small>54</small></sup></a> We will define a polynomial to be a
 sum of terms, each of which is either a coefficient, a power of the
 indeterminate, or a product of a coefficient and a power of the
 indeterminate.  A coefficient is defined as an algebraic expression
@@ -708,7 +708,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 Furthermore, there are other ways to represent a polynomial – for
 example, as a product of factors, or (for a univariate polynomial) as
 the set of roots, or as a listing of the values of the polynomial at a
-specified set of points.<a name="call_footnote_Temp_299" href="#footnote_Temp_299" id="call_footnote_Temp_299"><sup><small>55</small></sup></a>
+specified set of points.<a href="#footnote_Temp_299" id="call_footnote_Temp_299"><sup><small>55</small></sup></a>
 We can finesse these questions by deciding that in our
 algebraic-manipulation system a “polynomial” will be a
 particular syntactic form, not its underlying mathematical meaning.</p><p>
@@ -721,22 +721,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 
 We will approach the design of our system by following the familiar
 discipline of data abstraction.  We will represent polynomials using a
-data structure called a <a name="%_idx_2664" id="%_idx_2664"></a><em>poly</em>, which consists of a variable and a
-<a name="%_idx_2666" id="%_idx_2666"></a>collection of terms.  We assume that we have selectors <tt>variable</tt>
+data structure called a <a id="__idx_2664"></a><em>poly</em>, which consists of a variable and a
+<a id="__idx_2666"></a>collection of terms.  We assume that we have selectors <tt>variable</tt>
 and <tt>term-list</tt> that extract those parts from a poly and
 a constructor <tt>make-poly</tt> that assembles a
 poly from a given variable and a term list.
-A variable will be just a symbol, so we can use the <a name="%_idx_2668" id="%_idx_2668"></a><tt>same-variable?</tt>
-procedure of section <a href="book-Z-H-16.html#%_sec_2.3.2">2.3.2</a> to compare variables.
-<a name="%_idx_2670" id="%_idx_2670"></a><a name="%_idx_2672" id="%_idx_2672"></a>The following procedures define addition and multiplication of polys:</p><p>
+A variable will be just a symbol, so we can use the <a id="__idx_2668"></a><tt>same-variable?</tt>
+procedure of section <a href="book-Z-H-16.html#__sec_2.3.2">2.3.2</a> to compare variables.
+<a id="__idx_2670"></a><a id="__idx_2672"></a>The following procedures define addition and multiplication of polys:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2674" id="%_idx_2674"></a>(define (add-poly p1 p2)<br />
+</p><p></p><p><tt><a id="__idx_2674"></a>(define (add-poly p1 p2)<br />
   (if (same-variable? (variable p1) (variable p2))<br />
       (make-poly (variable p1)<br />
                  (add-terms (term-list p1)<br />
                             (term-list p2)))<br />
       (error "Polys not in same var -- ADD-POLY"<br />
-             (list p1 p2))))<br /><a name="%_idx_2676" id="%_idx_2676"></a>(define (mul-poly p1 p2)<br />
+             (list p1 p2))))<br /><a id="__idx_2676"></a>(define (mul-poly p1 p2)<br />
   (if (same-variable? (variable p1) (variable p2))<br />
       (make-poly (variable p1)<br />
                  (mul-terms (term-list p1)<br />
@@ -750,16 +750,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 the operation table.  We'll embed all our code
 in an installation procedure for the polynomial package,
 similar to the ones in
-section <a href="#%_sec_2.5.1">2.5.1</a>:
-<a name="%_idx_2678" id="%_idx_2678"></a><a name="%_idx_2680" id="%_idx_2680"></a><a name="%_idx_2682" id="%_idx_2682"></a>
-</p><p></p><p><tt><a name="%_idx_2684" id="%_idx_2684"></a><a name="%_idx_2686" id="%_idx_2686"></a><a name="%_idx_2688" id="%_idx_2688"></a><a name="%_idx_2690" id="%_idx_2690"></a>(define (install-polynomial-package)<br />
+section <a href="#__sec_2.5.1">2.5.1</a>:
+<a id="__idx_2678"></a><a id="__idx_2680"></a><a id="__idx_2682"></a>
+</p><p></p><p><tt><a id="__idx_2684"></a><a id="__idx_2686"></a><a id="__idx_2688"></a><a id="__idx_2690"></a>(define (install-polynomial-package)<br />
   <em>;; internal procedures</em><br />
   <em>;; representation of poly</em><br />
   (define (make-poly variable term-list)<br />
     (cons variable term-list))<br />
   (define (variable p) (car p))<br />
   (define (term-list p) (cdr p))<br />
-  &lt;<em>procedures <tt>same-variable?</tt> and <tt>variable?</tt> from section <a href="book-Z-H-16.html#%_sec_2.3.2">2.3.2</a></em>&gt;<br />
+  &lt;<em>procedures <tt>same-variable?</tt> and <tt>variable?</tt> from section <a href="book-Z-H-16.html#__sec_2.3.2">2.3.2</a></em>&gt;<br />
   <em>;; representation of terms and term lists</em><br />
   &lt;<em>procedures <tt>adjoin-term <tt>...</tt><tt>coeff</tt></tt> from text below</em>&gt;<br /><br />
   <em>;; continued on next page</em><br /><br />
@@ -785,22 +785,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 simply accumulated into the sum polynomial being constructed.</p><p>
 
 In order to manipulate term lists, we will assume that we have a
-constructor <a name="%_idx_2692" id="%_idx_2692"></a><tt>the-empty-termlist</tt> that returns an empty term list
-and a constructor <a name="%_idx_2694" id="%_idx_2694"></a><tt>adjoin-term</tt> that adjoins a new term to a term
-list.  We will also assume that we have a predicate <a name="%_idx_2696" id="%_idx_2696"></a><tt>empty-termlist?</tt> that tells if a given term list is empty, a selector
-<a name="%_idx_2698" id="%_idx_2698"></a><tt>first-term</tt> that extracts the highest-order term from a term
-list, and a selector <a name="%_idx_2700" id="%_idx_2700"></a><tt>rest-terms</tt> that returns all but the highest-order
+constructor <a id="__idx_2692"></a><tt>the-empty-termlist</tt> that returns an empty term list
+and a constructor <a id="__idx_2694"></a><tt>adjoin-term</tt> that adjoins a new term to a term
+list.  We will also assume that we have a predicate <a id="__idx_2696"></a><tt>empty-termlist?</tt> that tells if a given term list is empty, a selector
+<a id="__idx_2698"></a><tt>first-term</tt> that extracts the highest-order term from a term
+list, and a selector <a id="__idx_2700"></a><tt>rest-terms</tt> that returns all but the highest-order
 term.  To manipulate terms, we will suppose that we have a
-constructor <a name="%_idx_2702" id="%_idx_2702"></a><tt>make-term</tt> that constructs a term with given
-order and coefficient, and selectors <a name="%_idx_2704" id="%_idx_2704"></a><tt>order</tt> and <a name="%_idx_2706" id="%_idx_2706"></a><tt>coeff</tt> that return, respectively, the order and the
+constructor <a id="__idx_2702"></a><tt>make-term</tt> that constructs a term with given
+order and coefficient, and selectors <a id="__idx_2704"></a><tt>order</tt> and <a id="__idx_2706"></a><tt>coeff</tt> that return, respectively, the order and the
 coefficient of the term.  These operations allow us to consider both
 terms and term lists as data abstractions, whose concrete
 representations we can worry about separately.</p><p>
 
 Here is the procedure that constructs the term list for the sum of two
-polynomials:<a name="call_footnote_Temp_300" href="#footnote_Temp_300" id="call_footnote_Temp_300"><sup><small>56</small></sup></a></p><p>
+polynomials:<a href="#footnote_Temp_300" id="call_footnote_Temp_300"><sup><small>56</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_2708" id="%_idx_2708"></a>(define (add-terms L1 L2)<br />
+</p><p></p><p><tt><a id="__idx_2708"></a>(define (add-terms L1 L2)<br />
   (cond ((empty-termlist? L1) L2)<br />
         ((empty-termlist? L2) L1)<br />
         (else<br />
@@ -818,7 +818,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
                    (add-terms (rest-terms L1)<br />
                               (rest-terms L2)))))))))<br /></tt></p><p></p><p>
 The most important point to note here is that we used the generic
-addition procedure <a name="%_idx_2710" id="%_idx_2710"></a><tt>add</tt> to add together the coefficients of the
+addition procedure <a id="__idx_2710"></a><tt>add</tt> to add together the coefficients of the
 terms being combined.  This has powerful consequences, as we will see
 below.</p><p>
 
@@ -831,7 +831,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 factors and whose coefficient is the product of the coefficients of
 the factors:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2712" id="%_idx_2712"></a>(define (mul-terms L1 L2)<br />
+</p><p></p><p><tt><a id="__idx_2712"></a>(define (mul-terms L1 L2)<br />
   (if (empty-termlist? L1)<br />
       (the-empty-termlist)<br />
       (add-terms (mul-term-by-all-terms (first-term L1) L2)<br />
@@ -846,15 +846,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
          (mul-term-by-all-terms t1 (rest-terms L))))))<br /></tt></p><p></p><p></p><p>
 
 This is really all there is to polynomial addition and multiplication.
-<a name="%_idx_2714" id="%_idx_2714"></a><a name="%_idx_2716" id="%_idx_2716"></a>Notice that, since we operate on terms using the generic procedures
+<a id="__idx_2714"></a><a id="__idx_2716"></a>Notice that, since we operate on terms using the generic procedures
 <tt>add</tt> and <tt>mul</tt>, our polynomial package is automatically able
 to handle any type of coefficient that is known about by the generic
-arithmetic package.  If we include a <a name="%_idx_2718" id="%_idx_2718"></a>coercion mechanism such as one of
-those discussed in section <a href="#%_sec_2.5.2">2.5.2</a>,
+arithmetic package.  If we include a <a id="__idx_2718"></a>coercion mechanism such as one of
+those discussed in section <a href="#__sec_2.5.2">2.5.2</a>,
 then we also are automatically able to handle operations on
 polynomials of different coefficient types, such as</p>
 
-<div align="left"><img src="images/ch2-Z-G-71.gif" border="0" /></div>
+<div style="text-align: left;"><img src="images/ch2-Z-G-71.gif" alt="ch2-Z-G-71" style="border: none;" /></div>
 
 <p>Because we installed the polynomial addition and
 multiplication procedures <tt>add-poly</tt> and <tt>mul-poly</tt> in the generic
@@ -866,33 +866,33 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 
 <p>The reason is that when the system tries to combine coefficients, it
 will dispatch through <tt>add</tt> and <tt>mul</tt>.  Since the coefficients
-are themselves polynomials (in <em>y</em>), these will be combined using <tt>add-poly</tt> and <tt>mul-poly</tt>.  The result is a kind of <a name="%_idx_2720" id="%_idx_2720"></a><a name="%_idx_2722" id="%_idx_2722"></a>“data-directed
+are themselves polynomials (in <em>y</em>), these will be combined using <tt>add-poly</tt> and <tt>mul-poly</tt>.  The result is a kind of <a id="__idx_2720"></a><a id="__idx_2722"></a>“data-directed
 recursion” in which, for example, a call to <tt>mul-poly</tt> will result
 in recursive calls to <tt>mul-poly</tt> in order to multiply the
 coefficients.  If the coefficients of the coefficients were themselves
 polynomials (as might be used to represent polynomials in three
 variables), the data direction would ensure that the system would
 follow through another level of recursive calls, and so on through as
-many levels as the structure of the data dictates.<a name="call_footnote_Temp_301" href="#footnote_Temp_301" id="call_footnote_Temp_301"><sup><small>57</small></sup></a>
+many levels as the structure of the data dictates.<a href="#footnote_Temp_301" id="call_footnote_Temp_301"><sup><small>57</small></sup></a>
 
-<a name="%_sec_Temp_302" id="%_sec_Temp_302"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_302">Representing term lists</a></h4><p>
+<a id="__sec_Temp_302"></a>
+</p><h4>Representing term lists</h4><p>
 
-<a name="%_idx_2724" id="%_idx_2724"></a>
+<a id="__idx_2724"></a>
 Finally, we must confront the job of implementing a good
 representation for term lists.  A term list is, in effect, a set of
 coefficients keyed by the order of the term.  Hence, any of the
 methods for representing sets, as discussed in
-section <a href="book-Z-H-16.html#%_sec_2.3.3">2.3.3</a>, can be applied to this task.  On
+section <a href="book-Z-H-16.html#__sec_2.3.3">2.3.3</a>, can be applied to this task.  On
 the other hand, our procedures <tt>add-terms</tt> and <tt>mul-terms</tt> always
 access term lists sequentially from highest to lowest order.  Thus, we
 will use some kind of ordered list representation.</p><p>
 
 How should we structure the list that represents a term list?  One
 consideration is the “density” of the polynomials we intend to
-manipulate.  A polynomial is said to be <a name="%_idx_2726" id="%_idx_2726"></a><a name="%_idx_2728" id="%_idx_2728"></a><em>dense</em> if it has nonzero
+manipulate.  A polynomial is said to be <a id="__idx_2726"></a><a id="__idx_2728"></a><em>dense</em> if it has nonzero
 coefficients in terms of most orders.  If it has many zero terms it
-is said to be <a name="%_idx_2730" id="%_idx_2730"></a><a name="%_idx_2732" id="%_idx_2732"></a><em>sparse</em>.  For example,</p>
+is said to be <a id="__idx_2730"></a><a id="__idx_2732"></a><em>sparse</em>.  For example,</p>
 
 <p>A:     <em>x</em><sup>5</sup> + 2<em>x</em><sup>4</sup> + 3<em>x</em><sup>2</sup> - 2<em>x</em> - 5</p>
 
@@ -906,7 +906,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 as lists of the coefficients.  For example, <em>A</em> above would be nicely
 represented as <tt>(1 2 0 3 -2 -5)</tt>.  The order of a term in this
 representation is the length of the sublist beginning with that term's
-coefficient, decremented by 1.<a name="call_footnote_Temp_303" href="#footnote_Temp_303" id="call_footnote_Temp_303"><sup><small>58</small></sup></a>  This would be a terrible representation for a
+coefficient, decremented by 1.<a href="#footnote_Temp_303" id="call_footnote_Temp_303"><sup><small>58</small></sup></a>  This would be a terrible representation for a
 sparse polynomial such as <em>B</em>: There would be a giant list of zeros
 punctuated by a few lonely nonzero terms.  A more reasonable
 representation of the term list of a sparse polynomial is as a list of
@@ -917,44 +917,44 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 will use this method.  We will assume that term lists are represented
 as lists of terms, arranged from highest-order to lowest-order term.
 Once we have made this decision, implementing the selectors and
-constructors for terms and term lists is straightforward:<a name="call_footnote_Temp_304" href="#footnote_Temp_304" id="call_footnote_Temp_304"><sup><small>59</small></sup></a></p><p>
+constructors for terms and term lists is straightforward:<a href="#footnote_Temp_304" id="call_footnote_Temp_304"><sup><small>59</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_2734" id="%_idx_2734"></a>(define (adjoin-term term term-list)<br />
+</p><p></p><p><tt><a id="__idx_2734"></a>(define (adjoin-term term term-list)<br />
   (if (=zero? (coeff term))<br />
       term-list<br />
-      (cons term term-list)))<br /><a name="%_idx_2736" id="%_idx_2736"></a>(define (the-empty-termlist) '())<br /><a name="%_idx_2738" id="%_idx_2738"></a>(define (first-term term-list) (car term-list))<br /><a name="%_idx_2740" id="%_idx_2740"></a>(define (rest-terms term-list) (cdr term-list))<br /><a name="%_idx_2742" id="%_idx_2742"></a>(define (empty-termlist? term-list) (null? term-list))<br /><a name="%_idx_2744" id="%_idx_2744"></a>(define (make-term order coeff) (list order coeff))<br /><a name="%_idx_2746" id="%_idx_2746"></a>(define (order term) (car term))<br /><a name="%_idx_2748" id="%_idx_2748"></a>(define (coeff term) (cadr term))<br /></tt></p><p></p><p>
+      (cons term term-list)))<br /><a id="__idx_2736"></a>(define (the-empty-termlist) '())<br /><a id="__idx_2738"></a>(define (first-term term-list) (car term-list))<br /><a id="__idx_2740"></a>(define (rest-terms term-list) (cdr term-list))<br /><a id="__idx_2742"></a>(define (empty-termlist? term-list) (null? term-list))<br /><a id="__idx_2744"></a>(define (make-term order coeff) (list order coeff))<br /><a id="__idx_2746"></a>(define (order term) (car term))<br /><a id="__idx_2748"></a>(define (coeff term) (cadr term))<br /></tt></p><p></p><p>
 where <tt>=zero?</tt> is as defined in
-exercise <a href="#%_thm_2.80">2.80</a>.  (See also exercise <a href="#%_thm_2.87">2.87</a> below.)</p><p>
+exercise <a href="#__thm_2.80">2.80</a>.  (See also exercise <a href="#__thm_2.87">2.87</a> below.)</p><p>
 
 Users of the polynomial package
 will create (tagged) polynomials by means of the procedure:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2750" id="%_idx_2750"></a>(define (make-polynomial var terms)<br />
+</p><p></p><p><tt><a id="__idx_2750"></a>(define (make-polynomial var terms)<br />
   ((get 'make 'polynomial) var terms))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_2.87" id="%_thm_2.87"></a>
-<b>Exercise 2.87.</b>  <a name="%_idx_2752" id="%_idx_2752"></a><a name="%_idx_2754" id="%_idx_2754"></a>Install <tt>=zero?</tt> for polynomials in the generic arithmetic
+</p><p><a id="__thm_2.87"></a>
+<b>Exercise 2.87.</b>  <a id="__idx_2752"></a><a id="__idx_2754"></a>Install <tt>=zero?</tt> for polynomials in the generic arithmetic
 package.  This will allow <tt>adjoin-term</tt> to work for polynomials
 with coefficients that are themselves polynomials.
 
 </p><p> </p><p>
 
-</p><p><a name="%_thm_2.88" id="%_thm_2.88"></a>
-<b>Exercise 2.88.</b>  <a name="%_idx_2756" id="%_idx_2756"></a>Extend the polynomial system to include subtraction of polynomials.
+</p><p><a id="__thm_2.88"></a>
+<b>Exercise 2.88.</b>  <a id="__idx_2756"></a>Extend the polynomial system to include subtraction of polynomials.
 (Hint: You may find it helpful to define a generic negation operation.)
 
 </p><p> </p><p>
 
-</p><p><a name="%_thm_2.89" id="%_thm_2.89"></a>
+</p><p><a id="__thm_2.89"></a>
 <b>Exercise 2.89.</b>  Define procedures that implement the term-list representation
 described above as appropriate for dense polynomials.
 </p><p> </p><p>
 
-</p><p><a name="%_thm_2.90" id="%_thm_2.90"></a>
+</p><p><a id="__thm_2.90"></a>
 <b>Exercise 2.90.</b>  Suppose we want to have a polynomial system that is efficient for both
 sparse and dense polynomials.  One way to do this is to allow both
 kinds of term-list representations in our system.  The situation is
-analogous to the complex-number example of section <a href="book-Z-H-17.html#%_sec_2.4">2.4</a>,
+analogous to the complex-number example of section <a href="book-Z-H-17.html#__sec_2.4">2.4</a>,
 where we allowed both rectangular and polar representations.
 To do this we must distinguish different types of term lists and make
 the operations on term lists generic.  Redesign the polynomial system
@@ -962,11 +962,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 change.
 </p><p>
 
-</p><p><a name="%_thm_2.91" id="%_thm_2.91"></a>
-<b>Exercise 2.91.</b>  <a name="%_idx_2758" id="%_idx_2758"></a>A univariate polynomial can be divided by another one to produce a
+</p><p><a id="__thm_2.91"></a>
+<b>Exercise 2.91.</b>  <a id="__idx_2758"></a>A univariate polynomial can be divided by another one to produce a
 polynomial quotient and a polynomial remainder.  For example,</p><p>
 
-</p><p></p><div align="left"><img src="images/ch2-Z-G-76.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-76.gif" alt="ch2-Z-G-76" style="border: none;" /></div><p></p><p>
 
 Division can be performed via long division.
 That is, divide the highest-order term of the dividend by
@@ -978,7 +978,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 be the remainder.  Also, if the dividend ever becomes zero, return
 zero as both quotient and remainder.</p><p>
 
-<a name="%_idx_2760" id="%_idx_2760"></a>We can design a <tt>div-poly</tt> procedure on the model of <tt>add-poly</tt> and
+<a id="__idx_2760"></a>We can design a <tt>div-poly</tt> procedure on the model of <tt>add-poly</tt> and
 <tt>mul-poly</tt>. The procedure checks to see if the two polys have
 the same variable.  If so, <tt>div-poly</tt> strips off the variable and
 passes the problem to <tt>div-terms</tt>, which performs the division
@@ -993,7 +993,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 two polys as arguments and returns a list of the quotient and
 remainder polys.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2762" id="%_idx_2762"></a>(define (div-terms L1 L2)<br />
+</p><p></p><p><tt><a id="__idx_2762"></a>(define (div-terms L1 L2)<br />
   (if (empty-termlist? L1)<br />
       (list (the-empty-termlist) (the-empty-termlist))<br />
       (let ((t1 (first-term L1))<br />
@@ -1009,10 +1009,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
                 ))))))<br /></tt></p><p></p><p>
 </p><p> </p><p>
 
-<a name="%_sec_Temp_310" id="%_sec_Temp_310"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_310">Hierarchies of types in symbolic algebra</a></h4><p>
+<a id="__sec_Temp_310"></a>
+</p><h4>Hierarchies of types in symbolic algebra</h4><p>
 
-<a name="%_idx_2764" id="%_idx_2764"></a><a name="%_idx_2766" id="%_idx_2766"></a><a name="%_idx_2768" id="%_idx_2768"></a>
+<a id="__idx_2764"></a><a id="__idx_2766"></a><a id="__idx_2768"></a>
 Our polynomial system illustrates how objects of one type
 (polynomials) may in fact be complex objects that have objects of many
 different types as parts.  This poses no real difficulty in defining
@@ -1035,7 +1035,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 other by expanding and rearranging terms so that both polynomials have
 the same principal variable.  One can impose a towerlike structure on
 this by ordering the variables and thus always converting any
-polynomial to a <a name="%_idx_2770" id="%_idx_2770"></a><a name="%_idx_2772" id="%_idx_2772"></a>“canonical form” with the highest-priority variable
+polynomial to a <a id="__idx_2770"></a><a id="__idx_2772"></a>“canonical form” with the highest-priority variable
 dominant and the lower-priority variables buried in the coefficients.
 This strategy works fairly well, except that the conversion may expand
 a polynomial unnecessarily, making it hard to read and perhaps less
@@ -1044,7 +1044,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 dynamically using old types in various combining forms, such as
 trigonometric functions, power series, and integrals.</p><p>
 
-It should not be surprising that controlling <a name="%_idx_2774" id="%_idx_2774"></a>coercion is a serious
+It should not be surprising that controlling <a id="__idx_2774"></a>coercion is a serious
 problem in the design of large-scale algebraic-manipulation systems.
 Much of the complexity of such systems is concerned with relationships
 among diverse types.  Indeed, it is fair to say that we do not yet
@@ -1053,23 +1053,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 provides us with powerful structuring and modularity principles to
 support the design of large systems.</p><p>
 
-</p><p><a name="%_thm_2.92" id="%_thm_2.92"></a>
+</p><p><a id="__thm_2.92"></a>
 <b>Exercise 2.92.</b>  By imposing an ordering on variables, extend the polynomial package so
 that addition and multiplication of polynomials works for polynomials
 in different variables.  (This is not easy!)
 </p><p>
 
-<a name="%_sec_Temp_312" id="%_sec_Temp_312"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_312">Extended exercise: Rational functions</a></h4><p>
+<a id="__sec_Temp_312"></a>
+</p><h4>Extended exercise: Rational functions</h4><p>
 
-<a name="%_idx_2776" id="%_idx_2776"></a><a name="%_idx_2778" id="%_idx_2778"></a><a name="%_idx_2780" id="%_idx_2780"></a>We can extend our generic arithmetic system to include <em>rational
+<a id="__idx_2776"></a><a id="__idx_2778"></a><a id="__idx_2780"></a>We can extend our generic arithmetic system to include <em>rational
 functions</em>.  These are “fractions” whose numerator and denominator
 are polynomials, such as</p><p>
 
-</p><p></p><div align="left"><img src="images/ch2-Z-G-77.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-77.gif" alt="ch2-Z-G-77" style="border: none;" /></div><p>
 The system should be able to add, subtract, multiply, and divide
 rational functions, and to perform such computations as
-</p><p></p><div align="left"><img src="images/ch2-Z-G-78.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch2-Z-G-78.gif" alt="ch2-Z-G-78" style="border: none;" /></div><p>
 (Here the sum has been simplified by removing common factors.
 Ordinary “cross multiplication” would have produced a
 fourth-degree polynomial over a fifth-degree polynomial.)</p><p>
@@ -1078,7 +1078,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 operations, then it will do what we want, except for the problem
 of reducing fractions to lowest terms.</p><p>
 
-</p><p><a name="%_thm_2.93" id="%_thm_2.93"></a>
+</p><p><a id="__thm_2.93"></a>
 <b>Exercise 2.93.</b>  Modify the rational-arithmetic package to use generic operations, but
 change <tt>make-rat</tt> so that it does not attempt to reduce fractions
 to lowest terms.  Test your system by calling <tt>make-rational</tt> on
@@ -1096,9 +1096,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 We can reduce polynomial fractions to lowest terms using the same idea
 we used with integers: modifying <tt>make-rat</tt> to divide both the
 numerator and the denominator by their greatest common divisor.  The
-notion of <a name="%_idx_2782" id="%_idx_2782"></a><a name="%_idx_2784" id="%_idx_2784"></a>“greatest common divisor” makes sense for polynomials.  In
+notion of <a id="__idx_2782"></a><a id="__idx_2784"></a>“greatest common divisor” makes sense for polynomials.  In
 fact, we can compute the GCD of two polynomials using essentially the
-same Euclid's Algorithm that works for integers.<a name="call_footnote_Temp_314" href="#footnote_Temp_314" id="call_footnote_Temp_314"><sup><small>60</small></sup></a>  The
+same Euclid's Algorithm that works for integers.<a href="#footnote_Temp_314" id="call_footnote_Temp_314"><sup><small>60</small></sup></a>  The
 integer version is</p><p>
 
 
@@ -1109,16 +1109,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 Using this, we could make the obvious modification to define a GCD
 operation that works on term lists:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2794" id="%_idx_2794"></a>(define (gcd-terms a b)<br />
+</p><p></p><p><tt><a id="__idx_2794"></a>(define (gcd-terms a b)<br />
   (if (empty-termlist? b)<br />
       a<br />
       (gcd-terms b (remainder-terms a b))))<br /></tt></p><p></p><p>
 where <tt>remainder-terms</tt> picks out the remainder component of the
 list returned by the term-list division operation <tt>div-terms</tt> that
-was implemented in exercise <a href="#%_thm_2.91">2.91</a>.</p><p>
+was implemented in exercise <a href="#__thm_2.91">2.91</a>.</p><p>
 
-</p><p><a name="%_thm_2.94" id="%_thm_2.94"></a>
-<b>Exercise 2.94.</b>  <a name="%_idx_2796" id="%_idx_2796"></a><a name="%_idx_2798" id="%_idx_2798"></a>Using <tt>div-terms</tt>, implement the procedure <tt>remainder-terms</tt> and
+</p><p><a id="__thm_2.94"></a>
+<b>Exercise 2.94.</b>  <a id="__idx_2796"></a><a id="__idx_2798"></a>Using <tt>div-terms</tt>, implement the procedure <tt>remainder-terms</tt> and
 use this to define <tt>gcd-terms</tt> as above.  Now write a procedure
 <tt>gcd-poly</tt> that computes the polynomial GCD of two polys.
 (The procedure should signal an error if the two polys are not
@@ -1132,7 +1132,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 
 </p><p> </p><p>
 
-</p><p><a name="%_thm_2.95" id="%_thm_2.95"></a>
+</p><p><a id="__thm_2.95"></a>
 <b>Exercise 2.95.</b>  Define <em>P</em><sub>1</sub>, <em>P</em><sub>2</sub>, and <em>P</em><sub>3</sub> to be the polynomials</p>
 
 <p><em>P</em><sub>1</sub>:    <em>x</em><sup>2</sup> - 2<em>x</em> + 1</p>
@@ -1141,19 +1141,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 
 <p>Now define <em>Q</em><sub>1</sub> to be the product of <em>P</em><sub>1</sub> and <em>P</em><sub>2</sub> and <em>Q</em><sub>2</sub> to
 be the product of <em>P</em><sub>1</sub> and <em>P</em><sub>3</sub>, and use <tt>greatest-common-divisor</tt>
-(exercise <a href="#%_thm_2.94">2.94</a>) to
+(exercise <a href="#__thm_2.94">2.94</a>) to
 compute the GCD of <em>Q</em><sub>1</sub> and <em>Q</em><sub>2</sub>.
 Note that the answer is not the same as <em>P</em><sub>1</sub>.
 This example introduces noninteger
 operations into the computation, causing difficulties with the GCD
-algorithm.<a name="call_footnote_Temp_317" href="#footnote_Temp_317" id="call_footnote_Temp_317"><sup><small>61</small></sup></a>
+algorithm.<a href="#footnote_Temp_317" id="call_footnote_Temp_317"><sup><small>61</small></sup></a>
 To understand what is happening,
 try tracing <tt>gcd-terms</tt> while computing the GCD or
 try performing the division by hand.
 
 </p><p> </p><p>
 
-</p><p></p><p>We can solve the problem exhibited in exercise <a href="#%_thm_2.95">2.95</a> if
+</p><p></p><p>We can solve the problem exhibited in exercise <a href="#__thm_2.95">2.95</a> if
 we use the following modification of the GCD algorithm (which really
 works only in the case of polynomials with integer coefficients).
 Before performing any polynomial division in the GCD computation, we
@@ -1168,19 +1168,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 More precisely, if <em>P</em> and <em>Q</em> are polynomials, let <em>O</em><sub>1</sub> be the
 order of <em>P</em> (i.e., the order of the largest term of <em>P</em>) and let
 <em>O</em><sub>2</sub> be the order of <em>Q</em>.  Let <em>c</em> be the leading coefficient of
-<em>Q</em>.  Then it can be shown that, if we multiply <em>P</em> by the <a name="%_idx_2800" id="%_idx_2800"></a><em>integerizing factor</em> <em>c</em><sup>1+<em>O</em><sub>1</sub> -<em>O</em><sub>2</sub></sup>, the resulting polynomial can
+<em>Q</em>.  Then it can be shown that, if we multiply <em>P</em> by the <a id="__idx_2800"></a><em>integerizing factor</em> <em>c</em><sup>1+<em>O</em><sub>1</sub> -<em>O</em><sub>2</sub></sup>, the resulting polynomial can
 be divided by <em>Q</em> by using the <tt>div-terms</tt> algorithm without
 introducing any fractions.  The operation of multiplying the dividend
-by this constant and then dividing is sometimes called the <a name="%_idx_2802" id="%_idx_2802"></a><a name="%_idx_2804" id="%_idx_2804"></a><em>pseudodivision</em> of <em>P</em> by <em>Q</em>.  The remainder of the division is
+by this constant and then dividing is sometimes called the <a id="__idx_2802"></a><a id="__idx_2804"></a><em>pseudodivision</em> of <em>P</em> by <em>Q</em>.  The remainder of the division is
 called the <em>pseudoremainder</em>.</p><p>
 
-</p><p><a name="%_thm_2.96" id="%_thm_2.96"></a>
+</p><p><a id="__thm_2.96"></a>
 <b>Exercise 2.96.</b>  a.    Implement the procedure <tt>pseudoremainder-terms</tt>, which is just like
 <tt>remainder-terms</tt> except that it multiplies the dividend by
 the integerizing factor described above before calling <tt>div-terms</tt>.
 Modify <tt>gcd-terms</tt> to use <tt>pseudoremainder-terms</tt>, and verify
 that <tt>greatest-common-divisor</tt> now produces an answer with integer
-coefficients on the example in exercise <a href="#%_thm_2.95">2.95</a>.</p><p>
+coefficients on the example in exercise <a href="#__thm_2.95">2.95</a>.</p><p>
 
 </p><p></p><p>b.    The GCD now has integer coefficients, but they are larger than those
 of <em>P</em><sub>1</sub>.  Modify <tt>gcd-terms</tt> so that it removes common factors from
@@ -1189,10 +1189,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 
 </p><p>
 
-</p><p></p><p><a name="%_idx_2806" id="%_idx_2806"></a><a name="%_idx_2808" id="%_idx_2808"></a>Thus, here is how to reduce a rational function to lowest terms:</p><p>
+</p><p></p><p><a id="__idx_2806"></a><a id="__idx_2808"></a>Thus, here is how to reduce a rational function to lowest terms:</p><p>
 
 </p><p></p><ul><li>Compute the GCD of the numerator and denominator, using
-the version of <tt>gcd-terms</tt> from exercise <a href="#%_thm_2.96">2.96</a>.<p>
+the version of <tt>gcd-terms</tt> from exercise <a href="#__thm_2.96">2.96</a>.<p>
 
 </p></li><li>When you obtain the GCD, multiply both numerator and
 denominator by the same integerizing factor before dividing through by
@@ -1211,7 +1211,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 denominator and dividing through by this factor.
 </li></ul><p></p><p>
 
-</p><p><a name="%_thm_2.97" id="%_thm_2.97"></a>
+</p><p><a id="__thm_2.97"></a>
 <b>Exercise 2.97.</b>  a. Implement this algorithm as a procedure <tt>reduce-terms</tt> that takes two
 term lists <tt>n</tt> and <tt>d</tt> as arguments and returns a list <tt>nn</tt>, <tt>dd</tt>, which are <tt>n</tt> and <tt>d</tt> reduced to lowest terms
 via the algorithm given above.
@@ -1258,19 +1258,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 the enormous size of the intermediate coefficients generated by the
 pseudodivisions.  One of the active areas in the development of
 algebraic-manipulation systems is the design of better algorithms for
-computing polynomial GCDs.<a name="call_footnote_Temp_320" href="#footnote_Temp_320" id="call_footnote_Temp_320"><sup><small>62</small></sup></a>
+computing polynomial GCDs.<a href="#footnote_Temp_320" id="call_footnote_Temp_320"><sup><small>62</small></sup></a>
 
 </p><p>
 
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_283" href="#call_footnote_Temp_283" id="footnote_Temp_283"><sup><small>49</small></sup></a> We also have to supply an almost identical
+</p><div class="footnote"><p><a href="#call_footnote_Temp_283" id="footnote_Temp_283"><sup><small>49</small></sup></a> We also have to supply an almost identical
 procedure to handle the types <tt>(scheme-number complex)</tt>.
 
-</p><p><a name="footnote_Temp_285" href="#call_footnote_Temp_285" id="footnote_Temp_285"><sup><small>50</small></sup></a> See
-exercise <a href="#%_thm_2.82">2.82</a> for generalizations.
+</p><p><a href="#call_footnote_Temp_285" id="footnote_Temp_285"><sup><small>50</small></sup></a> See
+exercise <a href="#__thm_2.82">2.82</a> for generalizations.
 
-</p><p><a name="footnote_Temp_286" href="#call_footnote_Temp_286" id="footnote_Temp_286"><sup><small>51</small></sup></a> If we are
+</p><p><a href="#call_footnote_Temp_286" id="footnote_Temp_286"><sup><small>51</small></sup></a> If we are
 clever, we can usually get by with fewer than <em>n</em><sup>2</sup> coercion
 procedures.  For instance, if we know how to convert from type 1 to
 type 2 and from type 2 to type 3, then we can use this knowledge to
@@ -1282,7 +1282,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 procedures that can be inferred from the ones that are supplied
 explicitly.
 
-</p><p><a name="footnote_Temp_289" href="#call_footnote_Temp_289" id="footnote_Temp_289"><sup><small>52</small></sup></a> This statement, which also appears in the first edition of this book,
+</p><p><a href="#call_footnote_Temp_289" id="footnote_Temp_289"><sup><small>52</small></sup></a> This statement, which also appears in the first edition of this book,
 is just as true now as it was when we wrote it twelve years ago.
 Developing a useful, general framework for expressing the relations
 among different types of entities (what philosophers call
@@ -1291,7 +1291,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 that exists now is that now a variety of inadequate ontological
 theories have been embodied in a plethora of correspondingly
 inadequate programming languages.  For example, much of the complexity
-of <a name="%_idx_2622" id="%_idx_2622"></a><a name="%_idx_2624" id="%_idx_2624"></a>object-oriented programming languages – and the subtle and
+of <a id="__idx_2622"></a><a id="__idx_2624"></a>object-oriented programming languages – and the subtle and
 confusing differences among contemporary object-oriented
 languages – centers on the treatment of generic operations on
 interrelated types.  Our own discussion of computational objects in
@@ -1303,33 +1303,33 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 without also drawing on work in knowledge representation and automated
 reasoning.
 
-</p><p><a name="footnote_Temp_295" href="#call_footnote_Temp_295" id="footnote_Temp_295"><sup><small>53</small></sup></a> A real number can be projected to an integer
-using the <a name="%_idx_2642" id="%_idx_2642"></a><a name="%_idx_2644" id="%_idx_2644"></a><tt>round</tt> primitive, which returns the closest integer
+</p><p><a href="#call_footnote_Temp_295" id="footnote_Temp_295"><sup><small>53</small></sup></a> A real number can be projected to an integer
+using the <a id="__idx_2642"></a><a id="__idx_2644"></a><tt>round</tt> primitive, which returns the closest integer
 to its argument.
 
-</p><p><a name="footnote_Temp_298" href="#call_footnote_Temp_298" id="footnote_Temp_298"><sup><small>54</small></sup></a> On the other hand, we will allow
+</p><p><a href="#call_footnote_Temp_298" id="footnote_Temp_298"><sup><small>54</small></sup></a> On the other hand, we will allow
 polynomials whose coefficients are themselves polynomials in other
 variables.  This will give us essentially the same representational
 power as a full multivariate system, although it does lead to coercion
 problems, as discussed below.
 
-</p><p><a name="footnote_Temp_299" href="#call_footnote_Temp_299" id="footnote_Temp_299"><sup><small>55</small></sup></a> For univariate polynomials, giving
+</p><p><a href="#call_footnote_Temp_299" id="footnote_Temp_299"><sup><small>55</small></sup></a> For univariate polynomials, giving
 the value of a polynomial at a given set of points can be a
 particularly good representation.  This makes polynomial arithmetic
 extremely simple.  To obtain, for example, the sum of two polynomials
 represented in this way, we need only add the values of the
 polynomials at corresponding points.  To transform back to a more
-familiar representation, we can use the <a name="%_idx_2662" id="%_idx_2662"></a>Lagrange interpolation
+familiar representation, we can use the <a id="__idx_2662"></a>Lagrange interpolation
 formula, which shows how to recover the coefficients of a polynomial
 of degree <em>n</em> given the values of the polynomial at <em>n</em> + 1 points.
 
-</p><p><a name="footnote_Temp_300" href="#call_footnote_Temp_300" id="footnote_Temp_300"><sup><small>56</small></sup></a> This operation is very much like the ordered
-<tt>union-set</tt> operation we developed in exercise  <a href="book-Z-H-16.html#%_thm_2.62">2.62</a>.
+</p><p><a href="#call_footnote_Temp_300" id="footnote_Temp_300"><sup><small>56</small></sup></a> This operation is very much like the ordered
+<tt>union-set</tt> operation we developed in exercise  <a href="book-Z-H-16.html#__thm_2.62">2.62</a>.
 In fact, if we think of the terms of the polynomial as a set ordered
 according to the power of the indeterminate, then the program that
 produces the term list for a sum is almost identical to <tt>union-set</tt>.
 
-</p><p><a name="footnote_Temp_301" href="#call_footnote_Temp_301" id="footnote_Temp_301"><sup><small>57</small></sup></a> To make
+</p><p><a href="#call_footnote_Temp_301" id="footnote_Temp_301"><sup><small>57</small></sup></a> To make
 this work completely smoothly, we should also add to our generic
 arithmetic system the ability to coerce a “number” to a polynomial
 by regarding it as a polynomial of degree zero whose coefficient is
@@ -1340,14 +1340,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 
 <p>which requires adding the coefficient <em>y</em> + 1 to the coefficient 2.
 
-</p><p><a name="footnote_Temp_303" href="#call_footnote_Temp_303" id="footnote_Temp_303"><sup><small>58</small></sup></a> In these polynomial examples,
+</p><p><a href="#call_footnote_Temp_303" id="footnote_Temp_303"><sup><small>58</small></sup></a> In these polynomial examples,
 we assume that we have implemented the generic arithmetic system using
-the type mechanism suggested in exercise <a href="#%_thm_2.78">2.78</a>.
+the type mechanism suggested in exercise <a href="#__thm_2.78">2.78</a>.
 Thus, coefficients that are ordinary numbers will be represented as
 the numbers themselves rather than as pairs whose <tt>car</tt> is the
 symbol <tt>scheme-number</tt>.
 
-</p><p><a name="footnote_Temp_304" href="#call_footnote_Temp_304" id="footnote_Temp_304"><sup><small>59</small></sup></a> Although
+</p><p><a href="#call_footnote_Temp_304" id="footnote_Temp_304"><sup><small>59</small></sup></a> Although
 we are assuming that term
 lists are ordered, we have implemented <tt>adjoin-term</tt> to simply
 <tt>cons</tt> the new term onto the existing term list.  We can get away
@@ -1355,12 +1355,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 term than appears in the list.  If we did not want to make such a
 guarantee, we could have implemented <tt>adjoin-term</tt> to be similar
 to the <tt>adjoin-set</tt> constructor for the ordered-list
-representation of sets (exercise <a href="book-Z-H-16.html#%_thm_2.61">2.61</a>).
+representation of sets (exercise <a href="book-Z-H-16.html#__thm_2.61">2.61</a>).
 
-</p><p><a name="footnote_Temp_314" href="#call_footnote_Temp_314" id="footnote_Temp_314"><sup><small>60</small></sup></a> The fact
-that <a name="%_idx_2786" id="%_idx_2786"></a><a name="%_idx_2788" id="%_idx_2788"></a>Euclid's Algorithm works for polynomials is formalized in algebra
+</p><p><a href="#call_footnote_Temp_314" id="footnote_Temp_314"><sup><small>60</small></sup></a> The fact
+that <a id="__idx_2786"></a><a id="__idx_2788"></a>Euclid's Algorithm works for polynomials is formalized in algebra
 by saying that polynomials form a kind of algebraic domain called a
-<a name="%_idx_2790" id="%_idx_2790"></a><a name="%_idx_2792" id="%_idx_2792"></a><em>Euclidean ring</em>.  A Euclidean ring is a domain that admits
+<a id="__idx_2790"></a><a id="__idx_2792"></a><em>Euclidean ring</em>.  A Euclidean ring is a domain that admits
 addition, subtraction, and commutative multiplication, together with a
 way of assigning to each element <em>x</em> of the ring a positive integer
 “measure” <em>m</em>(<em>x</em>) with the properties that <em>m</em>(<em>x</em><em>y</em>)<u>&gt;</u> <em>m</em>(<em>x</em>) for
@@ -1371,13 +1371,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_2.5">2.5  Systems with Generic Operat
 integer is the absolute value of the integer itself.  For the domain
 of polynomials, the measure of a polynomial is its degree.
 
-</p><p><a name="footnote_Temp_317" href="#call_footnote_Temp_317" id="footnote_Temp_317"><sup><small>61</small></sup></a> In an implementation like MIT Scheme, this produces a polynomial
+</p><p><a href="#call_footnote_Temp_317" id="footnote_Temp_317"><sup><small>61</small></sup></a> In an implementation like MIT Scheme, this produces a polynomial
 that is indeed a divisor of <em>Q</em><sub>1</sub> and <em>Q</em><sub>2</sub>, but with rational coefficients.
 In many other Scheme systems, in which division of integers can produce
 limited-precision decimal numbers, we may fail to get a valid divisor.
 
-</p><p><a name="footnote_Temp_320" href="#call_footnote_Temp_320" id="footnote_Temp_320"><sup><small>62</small></sup></a> One extremely efficient and
-elegant method for computing <a name="%_idx_2810" id="%_idx_2810"></a><a name="%_idx_2812" id="%_idx_2812"></a><a name="%_idx_2814" id="%_idx_2814"></a><a name="%_idx_2816" id="%_idx_2816"></a>polynomial GCDs was discovered by <a name="%_idx_2818" id="%_idx_2818"></a>Richard
+</p><p><a href="#call_footnote_Temp_320" id="footnote_Temp_320"><sup><small>62</small></sup></a> One extremely efficient and
+elegant method for computing <a id="__idx_2810"></a><a id="__idx_2812"></a><a id="__idx_2814"></a><a id="__idx_2816"></a>polynomial GCDs was discovered by <a id="__idx_2818"></a>Richard
 Zippel (1979).  The method is a probabilistic algorithm, as is the
 fast test for primality that we discussed in chapter 1.  Zippel's book
 (1993) describes this method, together with other ways to compute
diff --git a/src/OEBPS/book-Z-H-19.html b/src/OEBPS/book-Z-H-19.html
index 67eedc7..c1d3ef5 100644
--- a/src/OEBPS/book-Z-H-19.html
+++ b/src/OEBPS/book-Z-H-19.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,30 +13,30 @@
 
 
 
-<a name="%_chap_3" id="%_chap_3"></a>
+<a id="__chap_3"></a>
 <h1 class="chapter">
-<div class="chapterheading"><a href="book-Z-H-4.html#%_toc_%_chap_3">Chapter 3</a></div></h1><p>
-<a href="book-Z-H-4.html#%_toc_%_chap_3">Modularity, Objects, and State</a></p><p>
+<div class="chapterheading">Chapter 3</div></h1><p>
+Modularity, Objects, and State</p><p>
 
 </p><p>
 
 </p><p>
-</p><div align="right">
-<table width="60%"><tr><td>
+</p><div style="text-align: right;">
+<table width="60_"><tr><td>
 <span class="epigraph">
 <p>
 
-M<img src="images/ch3-Z-G-1.gif" border="0" /></p><p>
+M<img src="images/ch3-Z-G-1.gif" alt="ch3-Z-G-1" style="border: none;" /></p><p>
 
 </p><p></p><p></p><p>
 
 (Even while it changes, it stands still.)</p><p>
 
-<a name="%_idx_2820" id="%_idx_2820"></a>Heraclitus</p><p>
+<a id="__idx_2820"></a>Heraclitus</p><p>
 
 Plus ça change, plus c'est la même chose.</p><p>
 
-<a name="%_idx_2822" id="%_idx_2822"></a>Alphonse Karr</p><p>
+<a id="__idx_2822"></a>Alphonse Karr</p><p>
 
 </p></span>
 </td></tr></table></div>
@@ -55,7 +55,7 @@ <h1 class="chapter">
 be divided “naturally” into coherent parts that can be separately
 developed and maintained.</p><p>
 
-<a name="%_idx_2824" id="%_idx_2824"></a><a name="%_idx_2826" id="%_idx_2826"></a>One powerful design strategy, which is particularly appropriate to the
+<a id="__idx_2824"></a><a id="__idx_2826"></a>One powerful design strategy, which is particularly appropriate to the
 construction of programs for modeling physical systems, is to base the
 structure of our programs on the structure of the system being
 modeled.  For each object in the system, we construct a corresponding
@@ -73,9 +73,9 @@ <h1 class="chapter">
 dictated by our perception of the system to be modeled.  In this
 chapter we will investigate two prominent organizational strategies
 arising from two rather different “world views” of the structure of
-systems.  The first organizational strategy concentrates on <a name="%_idx_2828" id="%_idx_2828"></a><em>objects</em>, viewing a large system as a collection of distinct objects
+systems.  The first organizational strategy concentrates on <a id="__idx_2828"></a><em>objects</em>, viewing a large system as a collection of distinct objects
 whose behaviors may change over time.  An alternative organizational
-strategy concentrates on the <a name="%_idx_2830" id="%_idx_2830"></a><em>streams</em> of information that flow in
+strategy concentrates on the <a id="__idx_2830"></a><em>streams</em> of information that flow in
 the system, much as an electrical engineer views a signal-processing
 system.</p><p>
 
@@ -84,8 +84,8 @@ <h1 class="chapter">
 With objects, we must be concerned with how a computational object can
 change and yet maintain its identity.  This will force us to abandon
 our old substitution model of computation
-(section <a href="book-Z-H-10.html#%_sec_1.1.5">1.1.5</a>) in favor of a more mechanistic
-but less theoretically tractable <a name="%_idx_2832" id="%_idx_2832"></a><em>environment model</em> of
+(section <a href="book-Z-H-10.html#__sec_1.1.5">1.1.5</a>) in favor of a more mechanistic
+but less theoretically tractable <a id="__idx_2832"></a><em>environment model</em> of
 computation.  The difficulties of dealing with objects, change, and
 identity are a fundamental consequence of the need to grapple with
 time in our computational models.  These difficulties become even
@@ -93,7 +93,7 @@ <h1 class="chapter">
 programs.  The stream approach can be most fully exploited when we
 decouple simulated time in our model from the order of the events that
 take place in the computer during evaluation.  We will accomplish this
-using a technique known as <a name="%_idx_2834" id="%_idx_2834"></a><em>delayed evaluation</em>.</p><p>
+using a technique known as <a id="__idx_2834"></a><em>delayed evaluation</em>.</p><p>
 
 
 
diff --git a/src/OEBPS/book-Z-H-2.html b/src/OEBPS/book-Z-H-2.html
index 1979fbe..6898751 100644
--- a/src/OEBPS/book-Z-H-2.html
+++ b/src/OEBPS/book-Z-H-2.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -15,7 +15,7 @@
 
 <p>
 
-</p><p></p><div align="left"><table><tr><td>
+</p><p></p><div style="text-align: left;"><table><tr><td>
 
 <p>
 
@@ -38,7 +38,7 @@
 
 </p><p></p><p>
       </p><p>
-<a rel="license" href="http://creativecommons.org/licenses/by-nc/3.0/"><img alt="Creative Commons License" style="border-width:0" src="http://i.creativecommons.org/l/by-nc/3.0/88x31.png" /></a><br />This work is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc/3.0/">Creative Commons Attribution-Noncommercial 3.0 Unported License</a>.
+<a rel="license" href="http://creativecommons.org/licenses/by-nc/3.0/"><img alt="Creative Commons License" style="border-width:0" src="images/cc-88x31.png" /></a><br />This work is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc/3.0/">Creative Commons Attribution-Noncommercial 3.0 Unported License</a>.
 
 </p><p></p><p>This book was set by the authors using the L<small>A</small>T<small>E</small>X typesetting
 system and was printed and bound in the United States of America.
diff --git a/src/OEBPS/book-Z-H-20.html b/src/OEBPS/book-Z-H-20.html
index 04b2f85..d71da55 100644
--- a/src/OEBPS/book-Z-H-20.html
+++ b/src/OEBPS/book-Z-H-20.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,17 +13,17 @@
 
 
 
-<a name="%_sec_3.1" id="%_sec_3.1"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State</a></h2><p>
+<a id="__sec_3.1"></a>
+<h2>3.1  Assignment and Local State</h2><p>
 
-<a name="%_idx_2836" id="%_idx_2836"></a><a name="%_idx_2838" id="%_idx_2838"></a>
+<a id="__idx_2836"></a><a id="__idx_2838"></a>
 We ordinarily view the world as populated by independent objects, each
 of which has a state that changes over time.  An object is said to
 “have state” if its behavior is influenced by its history.  A bank
 account, for example, has state in that the answer to the question
 “Can I withdraw $100?”  depends upon the history of deposit and
 withdrawal transactions.  We can characterize an object's state by one
-or more <a name="%_idx_2840" id="%_idx_2840"></a><em>state variables</em>, which among them maintain enough
+or more <a id="__idx_2840"></a><em>state variables</em>, which among them maintain enough
 information about history to determine the object's current behavior.
 In a simple banking system, we could characterize the state of an
 account by a current balance rather than by remembering the entire
@@ -50,15 +50,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 construct computational objects whose behaviors change as our programs
 run.  In particular, if we wish to model state variables by ordinary
 symbolic names in the programming language, then the language must
-provide an <a name="%_idx_2842" id="%_idx_2842"></a><em>assignment operator</em> to enable us to change the value
+provide an <a id="__idx_2842"></a><em>assignment operator</em> to enable us to change the value
 associated with a name.</p><p>
 
-<a name="%_sec_3.1.1" id="%_sec_3.1.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.1.1">3.1.1  Local State Variables</a></h3><p>
+<a id="__sec_3.1.1"></a>
+</p><h3>3.1.1  Local State Variables</h3><p>
 
 
-<a name="%_idx_2844" id="%_idx_2844"></a><a name="%_idx_2846" id="%_idx_2846"></a>
-<a name="%_idx_2848" id="%_idx_2848"></a><a name="%_idx_2850" id="%_idx_2850"></a>To illustrate what we mean by having a computational object with
+<a id="__idx_2844"></a><a id="__idx_2846"></a>
+<a id="__idx_2848"></a><a id="__idx_2850"></a>To illustrate what we mean by having a computational object with
 time-varying state, let us model the situation of withdrawing money
 from a bank account.  We will do this using a procedure <tt>withdraw</tt>, which takes as argument an <tt>amount</tt> to be withdrawn.
 If there is enough money in the account to accommodate the withdrawal,
@@ -77,7 +77,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 specifications for computing mathematical functions.  A call to a
 procedure computed the value of the function applied to the given
 arguments, and two calls to the same procedure with the
-same arguments always produced the same result.<a name="call_footnote_Temp_321" href="#footnote_Temp_321" id="call_footnote_Temp_321"><sup><small>1</small></sup></a></p><p>
+same arguments always produced the same result.<a href="#footnote_Temp_321" id="call_footnote_Temp_321"><sup><small>1</small></sup></a></p><p>
 
 To implement <tt>withdraw</tt>, we can use a variable <tt>balance</tt> to
 indicate the balance of money in the account and define <tt>withdraw</tt>
@@ -87,7 +87,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 Otherwise, <tt>withdraw</tt> returns the <em>Insufficient funds</em>
 message.  Here are the definitions of <tt>balance</tt> and <tt>withdraw</tt>:</p><p>
 
-</p><p></p><p><tt>(define balance 100)<br /><br /><a name="%_idx_2858" id="%_idx_2858"></a>(define (withdraw amount)<br />
+</p><p></p><p><tt>(define balance 100)<br /><br /><a id="__idx_2858"></a>(define (withdraw amount)<br />
   (if (&gt;= balance amount)<br />
       (begin (set! balance (- balance amount))<br />
              balance)<br />
@@ -95,13 +95,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 Decrementing <tt>balance</tt> is accomplished by the expression</p><p>
 
 </p><p></p><p><tt>(set! balance (- balance amount))<br /></tt></p><p></p><p>
-<a name="%_idx_2860" id="%_idx_2860"></a><a name="%_idx_2862" id="%_idx_2862"></a>This uses the <tt>set!</tt> special form, whose syntax is</p><p>
+<a id="__idx_2860"></a><a id="__idx_2862"></a>This uses the <tt>set!</tt> special form, whose syntax is</p><p>
 
 </p><p></p><p><tt>(set! &lt;<em>name</em>&gt; &lt;<em>new-value</em>&gt;)<br /></tt></p><p></p><p>
 Here &lt;<em>name</em>&gt; is a symbol and &lt;<em>new-value</em>&gt; is any expression.  <tt>Set!</tt> changes &lt;<em>name</em>&gt; so that its value is the result obtained by
-evaluating &lt;<em>new-value</em>&gt;.  In the case at hand, we are changing <tt>balance</tt> so that its new value will be the result of subtracting <tt>amount</tt> from the previous value of <tt>balance</tt>.<a name="call_footnote_Temp_322" href="#footnote_Temp_322" id="call_footnote_Temp_322"><sup><small>2</small></sup></a></p><p>
+evaluating &lt;<em>new-value</em>&gt;.  In the case at hand, we are changing <tt>balance</tt> so that its new value will be the result of subtracting <tt>amount</tt> from the previous value of <tt>balance</tt>.<a href="#footnote_Temp_322" id="call_footnote_Temp_322"><sup><small>2</small></sup></a></p><p>
 
-<a name="%_idx_2874" id="%_idx_2874"></a><a name="%_idx_2876" id="%_idx_2876"></a><tt>Withdraw</tt> also uses the <tt>begin</tt> special form to cause
+<a id="__idx_2874"></a><a id="__idx_2876"></a><tt>Withdraw</tt> also uses the <tt>begin</tt> special form to cause
 two expressions to be evaluated
 in the case where the <tt>if</tt> test is true: first decrementing <tt>balance</tt> and then returning the value of <tt>balance</tt>.  In general,
 evaluating the expression</p><p>
@@ -110,7 +110,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 causes the expressions &lt;<em>exp<sub>1</sub></em>&gt; through &lt;<em>exp<sub><em>k</em></sub></em>&gt; to be
 evaluated in sequence and the value of the final expression
 &lt;<em>exp<sub><em>k</em></sub></em>&gt; to be returned as the value of the entire <tt>begin</tt>
-form.<a name="call_footnote_Temp_323" href="#footnote_Temp_323" id="call_footnote_Temp_323"><sup><small>3</small></sup></a></p><p>
+form.<a href="#footnote_Temp_323" id="call_footnote_Temp_323"><sup><small>3</small></sup></a></p><p>
 
 Although <tt>withdraw</tt> works as desired, the variable
 <tt>balance</tt> presents a problem.  As specified above, <tt>balance</tt>
@@ -126,7 +126,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 We can make <tt>balance</tt> internal to <tt>withdraw</tt> by rewriting the
 definition as follows:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2884" id="%_idx_2884"></a>(define new-withdraw<br />
+</p><p></p><p><tt><a id="__idx_2884"></a>(define new-withdraw<br />
   (let ((balance 100))<br />
     (lambda (amount)<br />
       (if (&gt;= balance amount)<br />
@@ -141,34 +141,34 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 result of evaluating the <tt>let</tt> expression – is <tt>new-withdraw</tt>,
 which behaves in precisely the same way as <tt>withdraw</tt> but whose
 variable <tt>balance</tt> is not accessible by any other
-procedure.<a name="call_footnote_Temp_324" href="#footnote_Temp_324" id="call_footnote_Temp_324"><sup><small>4</small></sup></a></p><p>
+procedure.<a href="#footnote_Temp_324" id="call_footnote_Temp_324"><sup><small>4</small></sup></a></p><p>
 
 Combining <tt>set!</tt> with local variables is the general programming
 technique we will use for constructing computational objects with
 local state.  Unfortunately, using this technique raises a serious
 problem: When we first introduced procedures, we also introduced the
 substitution model of evaluation
-(section <a href="book-Z-H-10.html#%_sec_1.1.5">1.1.5</a>) to provide an interpretation of
+(section <a href="book-Z-H-10.html#__sec_1.1.5">1.1.5</a>) to provide an interpretation of
 what procedure application means.  We said that applying a procedure
 should be interpreted as evaluating the body of the procedure with the
 formal parameters replaced by their values.  The trouble is that, as
 soon as we introduce assignment into our language, substitution is no
 longer an adequate model of procedure application.  (We will see why
-this is so in section <a href="#%_sec_3.1.3">3.1.3</a>.)  As a
+this is so in section <a href="#__sec_3.1.3">3.1.3</a>.)  As a
 consequence, we technically have at this point no way to understand
 why the <tt>new-withdraw</tt> procedure behaves as claimed above.  In
 order to really understand a procedure such as <tt>new-withdraw</tt>, we
 will need to develop a new model of procedure application.  In
-section <a href="book-Z-H-21.html#%_sec_3.2">3.2</a> we will introduce such a model,
+section <a href="book-Z-H-21.html#__sec_3.2">3.2</a> we will introduce such a model,
 together with an explanation of <tt>set!</tt> and local variables.
 First, however, we examine some variations on the theme established by
 <tt>new-withdraw</tt>.</p><p>
 
 The following procedure, <tt>make-withdraw</tt>, creates “withdrawal
 processors.”  The formal parameter <tt>balance</tt> in <tt>make-withdraw</tt> specifies the initial amount of money in the
-account.<a name="call_footnote_Temp_325" href="#footnote_Temp_325" id="call_footnote_Temp_325"><sup><small>5</small></sup></a></p><p>
+account.<a href="#footnote_Temp_325" id="call_footnote_Temp_325"><sup><small>5</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_2894" id="%_idx_2894"></a>(define (make-withdraw balance)<br />
+</p><p></p><p><tt><a id="__idx_2894"></a>(define (make-withdraw balance)<br />
   (lambda (amount)<br />
     (if (&gt;= balance amount)<br />
         (begin (set! balance (- balance amount))<br />
@@ -192,7 +192,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 a procedure that returns a “bank-account object” with
 a specified initial balance:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2896" id="%_idx_2896"></a><a name="%_idx_2898" id="%_idx_2898"></a>(define (make-account balance)<br />
+</p><p></p><p><tt><a id="__idx_2896"></a><a id="__idx_2898"></a>(define (make-account balance)<br />
   (define (withdraw amount)<br />
     (if (&gt;= balance amount)<br />
         (begin (set! balance (- balance amount))<br />
@@ -213,8 +213,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 that takes a “message” as input and returns one of the two local
 procedures.  The <tt>dispatch</tt> procedure itself is returned as the
 value that represents the bank-account object.
-This is precisely the <a name="%_idx_2900" id="%_idx_2900"></a><em>message-passing</em>
-style of programming that we saw in section <a href="book-Z-H-17.html#%_sec_2.4.3">2.4.3</a>, although
+This is precisely the <a id="__idx_2900"></a><em>message-passing</em>
+style of programming that we saw in section <a href="book-Z-H-17.html#__sec_2.4.3">2.4.3</a>, although
 here we are using it in conjunction with the ability to modify local
 variables.</p><p>
 
@@ -232,11 +232,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 will produce a completely separate account object, which maintains its
 own local <tt>balance</tt>.</p><p>
 
-</p><p><a name="%_thm_3.1" id="%_thm_3.1"></a>
-<b>Exercise 3.1.</b>  An <a name="%_idx_2902" id="%_idx_2902"></a><em>accumulator</em> is a procedure that is called repeatedly with a
+</p><p><a id="__thm_3.1"></a>
+<b>Exercise 3.1.</b>  An <a id="__idx_2902"></a><em>accumulator</em> is a procedure that is called repeatedly with a
 single numeric argument and accumulates its arguments into a sum.
 Each time it is called, it returns the currently accumulated sum.
-Write a procedure <a name="%_idx_2904" id="%_idx_2904"></a><tt>make-accumulator</tt> that generates accumulators,
+Write a procedure <a id="__idx_2904"></a><tt>make-accumulator</tt> that generates accumulators,
 each maintaining an independent sum.  The input to <tt>make-accumulator</tt> should specify the initial value of the sum; for
 example</p><p>
 
@@ -245,10 +245,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 (A 10)<br /><i>25</i><br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.2" id="%_thm_3.2"></a>
+</p><p><a id="__thm_3.2"></a>
 <b>Exercise 3.2.</b>  In software-testing applications, it is useful to be able to count the
 number of times a given procedure is called during the course of a
-computation.  Write a procedure <a name="%_idx_2906" id="%_idx_2906"></a><a name="%_idx_2908" id="%_idx_2908"></a><a name="%_idx_2910" id="%_idx_2910"></a><tt>make-monitored</tt> that takes as
+computation.  Write a procedure <a id="__idx_2906"></a><a id="__idx_2908"></a><a id="__idx_2910"></a><tt>make-monitored</tt> that takes as
 input a procedure, <tt>f</tt>, that itself takes one input.  The result
 returned by <tt>make-monitored</tt> is a third procedure, say <tt>mf</tt>,
 that keeps track of the number of times it has been called by
@@ -264,8 +264,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 (s 'how-many-calls?)<br /><i>1</i><br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.3" id="%_thm_3.3"></a>
-<b>Exercise 3.3.</b>  <a name="%_idx_2912" id="%_idx_2912"></a><a name="%_idx_2914" id="%_idx_2914"></a>Modify the <tt>make-account</tt> procedure so that it creates
+</p><p><a id="__thm_3.3"></a>
+<b>Exercise 3.3.</b>  <a id="__idx_2912"></a><a id="__idx_2914"></a>Modify the <tt>make-account</tt> procedure so that it creates
 password-protected accounts.  That is, <tt>make-account</tt> should take
 a symbol as an additional argument, as in</p><p>
 
@@ -278,28 +278,28 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 ((acc 'some-other-password 'deposit) 50)<br /><i>"Incorrect password"</i><br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.4" id="%_thm_3.4"></a>
+</p><p><a id="__thm_3.4"></a>
 <b>Exercise 3.4.</b>  Modify the <tt>make-account</tt> procedure of
-exercise <a href="#%_thm_3.3">3.3</a> by adding another local state
+exercise <a href="#__thm_3.3">3.3</a> by adding another local state
 variable so that, if an account is accessed more than seven
 consecutive times with an incorrect password, it invokes the procedure
 <tt>call-the-cops</tt>.
 </p><p>
 </p><p>
 
-<a name="%_sec_3.1.2" id="%_sec_3.1.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.1.2">3.1.2  The Benefits of Introducing Assignment</a></h3><p>
+<a id="__sec_3.1.2"></a>
+</p><h3>3.1.2  The Benefits of Introducing Assignment</h3><p>
 
 
-<a name="%_idx_2916" id="%_idx_2916"></a>
-<a name="%_idx_2918" id="%_idx_2918"></a><a name="%_idx_2920" id="%_idx_2920"></a>As we shall see, introducing assignment into our programming language
+<a id="__idx_2916"></a>
+<a id="__idx_2918"></a><a id="__idx_2920"></a>As we shall see, introducing assignment into our programming language
 leads us into a thicket of difficult conceptual issues.  Nevertheless,
 viewing systems as collections of objects with local state is a
 powerful technique for maintaining a modular design.  As a simple
 example, consider the design of a procedure <tt>rand</tt> that, whenever
 it is called, returns an integer chosen at random.</p><p>
 
-<a name="%_idx_2922" id="%_idx_2922"></a>It is not at all clear what is meant by “chosen at random.”  What we
+<a id="__idx_2922"></a>It is not at all clear what is meant by “chosen at random.”  What we
 presumably want is for successive calls to <tt>rand</tt> to produce a
 sequence of numbers that has statistical properties of uniform
 distribution.  We will not discuss methods for generating suitable
@@ -308,7 +308,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 
 </p><p></p><p><tt><em>x</em><sub>2</sub> = (rand-update <em>x</em><sub>1</sub>)<br /><em>x</em><sub>3</sub> = (rand-update <em>x</em><sub>2</sub>)<br /></tt></p><p></p><p>
 then the sequence of values <em>x</em><sub>1</sub>, <em>x</em><sub>2</sub>, <em>x</em><sub>3</sub>, <tt>...</tt>, will have the
-desired statistical properties.<a name="call_footnote_Temp_330" href="#footnote_Temp_330" id="call_footnote_Temp_330"><sup><small>6</small></sup></a></p><p>
+desired statistical properties.<a href="#footnote_Temp_330" id="call_footnote_Temp_330"><sup><small>6</small></sup></a></p><p>
 
 We can implement <tt>rand</tt> as a procedure with a local state variable
 <tt>x</tt> that is initialized to some fixed value <tt>random-init</tt>.
@@ -316,7 +316,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 value of <tt>x</tt>, returns this as the random number, and also stores
 this as the new value of <tt>x</tt>.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2934" id="%_idx_2934"></a>(define rand<br />
+</p><p></p><p><tt><a id="__idx_2934"></a>(define rand<br />
   (let ((x random-init))<br />
     (lambda ()<br />
       (set! x (rand-update x))<br />
@@ -328,18 +328,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 numbers would have to explicitly remember the current value of <tt>x</tt>
 to be passed as an argument to <tt>rand-update</tt>.  To realize what an
 annoyance this would be, consider using random numbers to implement a
-technique called <a name="%_idx_2936" id="%_idx_2936"></a><a name="%_idx_2938" id="%_idx_2938"></a><em>Monte Carlo simulation</em>.</p><p>
+technique called <a id="__idx_2936"></a><a id="__idx_2938"></a><em>Monte Carlo simulation</em>.</p><p>
 
 The Monte Carlo method consists of choosing sample experiments at
 random from a large set and then making deductions on the basis of the
 probabilities estimated from tabulating the results of those
-experiments.  For example, we can approximate <a name="%_idx_2940" id="%_idx_2940"></a>π using the fact
+experiments.  For example, we can approximate <a id="__idx_2940"></a>π using the fact
 that 6/π<sup>2</sup> is the probability that two integers chosen at random
 will have no factors in common; that is, that their greatest common
-divisor will be 1.<a name="call_footnote_Temp_331" href="#footnote_Temp_331" id="call_footnote_Temp_331"><sup><small>7</small></sup></a> To obtain
+divisor will be 1.<a href="#footnote_Temp_331" id="call_footnote_Temp_331"><sup><small>7</small></sup></a> To obtain
 the approximation to π, we perform a large number of experiments.
 In each experiment we choose two integers at random and perform a test
-<a name="%_idx_2946" id="%_idx_2946"></a>to see if their GCD is 1.  The fraction of times that the test is
+<a id="__idx_2946"></a>to see if their GCD is 1.  The fraction of times that the test is
 passed gives us our estimate of 6/π<sup>2</sup>, and from this we obtain our
 approximation to π.</p><p>
 
@@ -351,9 +351,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 number telling the fraction of the trials in which the experiment was
 found to be true.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2948" id="%_idx_2948"></a>(define (estimate-pi trials)<br />
-  (sqrt (/ 6 (monte-carlo trials cesaro-test))))<br /><a name="%_idx_2950" id="%_idx_2950"></a>(define (cesaro-test)<br />
-   (= (gcd (rand) (rand)) 1))<br /><a name="%_idx_2952" id="%_idx_2952"></a>(define (monte-carlo trials experiment)<br />
+</p><p></p><p><tt><a id="__idx_2948"></a>(define (estimate-pi trials)<br />
+  (sqrt (/ 6 (monte-carlo trials cesaro-test))))<br /><a id="__idx_2950"></a>(define (cesaro-test)<br />
+   (= (gcd (rand) (rand)) 1))<br /><a id="__idx_2952"></a>(define (monte-carlo trials experiment)<br />
   (define (iter trials-remaining trials-passed)<br />
     (cond ((= trials-remaining 0)<br />
            (/ trials-passed trials))<br />
@@ -367,7 +367,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 rather than <tt>rand</tt>, the way we would be forced to proceed if we
 did not use assignment to model local state:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2954" id="%_idx_2954"></a>(define (estimate-pi trials)<br />
+</p><p></p><p><tt><a id="__idx_2954"></a>(define (estimate-pi trials)<br />
   (sqrt (/ 6 (random-gcd-test trials random-init))))<br />
 (define (random-gcd-test trials initial-x)<br />
   (define (iter trials-remaining trials-passed x)<br />
@@ -422,8 +422,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 additional parameters.  Unfortunately, as we shall see, the story is
 not so simple.</p><p>
 
-</p><p><a name="%_thm_3.5" id="%_thm_3.5"></a>
-<b>Exercise 3.5.</b>  <a name="%_idx_2956" id="%_idx_2956"></a><a name="%_idx_2958" id="%_idx_2958"></a><a name="%_idx_2960" id="%_idx_2960"></a><em>Monte Carlo integration</em> is a method of estimating definite
+</p><p><a id="__thm_3.5"></a>
+<b>Exercise 3.5.</b>  <a id="__idx_2956"></a><a id="__idx_2958"></a><a id="__idx_2960"></a><em>Monte Carlo integration</em> is a method of estimating definite
 integrals by means of Monte Carlo simulation.  Consider computing the
 area of a region of space described by a predicate <em>P</em>(<em>x</em>, <em>y</em>) that is
 true for points (<em>x</em>, <em>y</em>) in the region and false for points not in the
@@ -443,7 +443,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 by the area of the entire rectangle should produce an estimate of the
 integral.</p><p>
 
-Implement Monte Carlo integration as a procedure <a name="%_idx_2962" id="%_idx_2962"></a><tt>estimate-integral</tt> that takes as arguments a predicate <tt>P</tt>, upper
+Implement Monte Carlo integration as a procedure <a id="__idx_2962"></a><tt>estimate-integral</tt> that takes as arguments a predicate <tt>P</tt>, upper
 and lower bounds <tt>x1</tt>, <tt>x2</tt>, <tt>y1</tt>, and <tt>y2</tt> for the
 rectangle, and the number of trials to perform in order to produce the
 estimate.  Your procedure should use the same <tt>monte-carlo</tt> procedure that was used above to estimate π.  Use
@@ -453,16 +453,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 You will find it useful to have a procedure that returns a number
 chosen at random from a given range.  The following <tt>random-in-range</tt>
 procedure implements this in terms of the <tt>random</tt>
-procedure used in section <a href="book-Z-H-11.html#%_sec_1.2.6">1.2.6</a>, which returns a nonnegative
-number less than its input.<a name="call_footnote_Temp_333" href="#footnote_Temp_333" id="call_footnote_Temp_333"><sup><small>8</small></sup></a></p><p>
+procedure used in section <a href="book-Z-H-11.html#__sec_1.2.6">1.2.6</a>, which returns a nonnegative
+number less than its input.<a href="#footnote_Temp_333" id="call_footnote_Temp_333"><sup><small>8</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_2970" id="%_idx_2970"></a>(define (random-in-range low high)<br />
+</p><p></p><p><tt><a id="__idx_2970"></a>(define (random-in-range low high)<br />
   (let ((range (- high low)))<br />
     (+ low (random range))))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.6" id="%_thm_3.6"></a>
-<b>Exercise 3.6.</b>  <a name="%_idx_2972" id="%_idx_2972"></a><a name="%_idx_2974" id="%_idx_2974"></a>It is useful to be able to reset a random-number generator to produce
+</p><p><a id="__thm_3.6"></a>
+<b>Exercise 3.6.</b>  <a id="__idx_2972"></a><a id="__idx_2974"></a>It is useful to be able to reset a random-number generator to produce
 a sequence starting from a given value.  Design a new <tt>rand</tt>
 procedure that is called with an argument that is either the symbol
 <tt>generate</tt> or the symbol <tt>reset</tt> and behaves as follows: <tt>(rand
@@ -475,16 +475,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 </p><p>
 </p><p>
 
-<a name="%_sec_3.1.3" id="%_sec_3.1.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.1.3">3.1.3  The Costs of Introducing Assignment</a></h3><p>
+<a id="__sec_3.1.3"></a>
+</p><h3>3.1.3  The Costs of Introducing Assignment</h3><p>
 
 
-<a name="%_idx_2976" id="%_idx_2976"></a>
+<a id="__idx_2976"></a>
 As we have seen, the <tt>set!</tt> operation enables us to model objects
 that have local state.  However, this advantage comes at a price.  Our
 programming language can no longer be interpreted in terms of the
 substitution model of procedure application that we introduced in
-section <a href="book-Z-H-10.html#%_sec_1.1.5">1.1.5</a>.  Moreover, no simple model with
+section <a href="book-Z-H-10.html#__sec_1.1.5">1.1.5</a>.  Moreover, no simple model with
 “nice” mathematical properties can be an adequate framework for
 dealing with objects and assignment in programming languages.</p><p>
 
@@ -492,14 +492,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 procedure with the same arguments will produce the same result, so
 that procedures can be viewed as computing mathematical functions.
 Programming without any use of assignments, as we did throughout the
-first two chapters of this book, is accordingly known as <a name="%_idx_2978" id="%_idx_2978"></a><em>functional programming</em>.</p><p>
+first two chapters of this book, is accordingly known as <a id="__idx_2978"></a><em>functional programming</em>.</p><p>
 
-<a name="%_idx_2980" id="%_idx_2980"></a>To understand how assignment complicates matters, consider a
+<a id="__idx_2980"></a>To understand how assignment complicates matters, consider a
 simplified version of the <tt>make-withdraw</tt> procedure of
-section <a href="#%_sec_3.1.1">3.1.1</a> that does not bother to check
+section <a href="#__sec_3.1.1">3.1.1</a> that does not bother to check
 for an insufficient amount:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2982" id="%_idx_2982"></a>(define (make-simplified-withdraw balance)<br />
+</p><p></p><p><tt><a id="__idx_2982"></a>(define (make-simplified-withdraw balance)<br />
   (lambda (amount)<br />
     (set! balance (- balance amount))<br />
     balance))<br />
@@ -509,7 +509,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 Compare this procedure with the following <tt>make-decrementer</tt>
 procedure, which does not use <tt>set!</tt>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_2984" id="%_idx_2984"></a>(define (make-decrementer balance)<br />
+</p><p></p><p><tt><a id="__idx_2984"></a>(define (make-decrementer balance)<br />
   (lambda (amount)<br />
     (- balance amount)))<br /></tt></p><p></p><p>
 <tt>Make-decrementer</tt> returns a procedure that subtracts its input
@@ -543,7 +543,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 </p><p></p><p><tt>((make-simplified-withdraw 25) 20)<br /></tt></p><p></p><p>
 We first simplify the operator by substituting 25 for <tt>balance</tt> in
 the body of <tt>make-simplified-withdraw</tt>.
-This reduces the expression to<a name="call_footnote_Temp_335" href="#footnote_Temp_335" id="call_footnote_Temp_335"><sup><small>9</small></sup></a></p><p>
+This reduces the expression to<a href="#footnote_Temp_335" id="call_footnote_Temp_335"><sup><small>9</small></sup></a></p><p>
 
 
 </p><p></p><p><tt>((lambda (amount) (set! balance (- 25 amount)) 25) 20)<br /></tt></p><p></p><p>
@@ -568,15 +568,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 value of a variable can change, a variable can no longer be simply a
 name.  Now a variable somehow refers to a place where a value can be
 stored, and the value stored at this place can change.  In
-section <a href="book-Z-H-21.html#%_sec_3.2">3.2</a>
+section <a href="book-Z-H-21.html#__sec_3.2">3.2</a>
 we will see how environments play this role of “place” in our
 computational model.
 </p><p>
 
-<a name="%_sec_Temp_336" id="%_sec_Temp_336"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_336">Sameness and change</a></h4><p>
+<a id="__sec_Temp_336"></a>
+</p><h4>Sameness and change</h4><p>
 
-<a name="%_idx_2986" id="%_idx_2986"></a><a name="%_idx_2988" id="%_idx_2988"></a>
+<a id="__idx_2986"></a><a id="__idx_2988"></a>
 The issue surfacing here is more profound than the mere breakdown of a
 particular model of computation.  As soon as we introduce change into
 our computational models, many notions that were previously
@@ -612,7 +612,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 A language that supports the concept that “equals can be substituted
 for equals” in an expresssion
 without changing the value of the expression is said to be
-<a name="%_idx_2990" id="%_idx_2990"></a><a name="%_idx_2992" id="%_idx_2992"></a><a name="%_idx_2994" id="%_idx_2994"></a><em>referentially transparent</em>.  Referential transparency is violated
+<a id="__idx_2990"></a><a id="__idx_2992"></a><a id="__idx_2994"></a><em>referentially transparent</em>.  Referential transparency is violated
 when we include <tt>set!</tt> in our computer language.  This makes it
 tricky to determine when we can simplify expressions by substituting
 equivalent expressions.  Consequently, reasoning about programs that
@@ -631,7 +631,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 “change” without some <em>a priori</em> notion of “sameness,” and we
 cannot determine sameness without observing the effects of change.</p><p>
 
-<a name="%_idx_2996" id="%_idx_2996"></a>As an example of how this issue arises in programming, consider the
+<a id="__idx_2996"></a>As an example of how this issue arises in programming, consider the
 situation where Peter and Paul have a bank account with $100 in
 it.  There is a substantial difference between modeling this as</p><p>
 
@@ -651,7 +651,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 (the bank account) that has two different names (<tt>peter-acc</tt> and
 <tt>paul-acc</tt>); if we are searching for all the places in our program
 where <tt>paul-acc</tt> can be changed, we must remember to look also at
-things that change <tt>peter-acc</tt>.<a name="call_footnote_Temp_337" href="#footnote_Temp_337" id="call_footnote_Temp_337"><sup><small>10</small></sup></a></p><p>
+things that change <tt>peter-acc</tt>.<a href="#footnote_Temp_337" id="call_footnote_Temp_337"><sup><small>10</small></sup></a></p><p>
 
 
 With reference to the above remarks on “sameness” and “change,”
@@ -673,16 +673,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 with identity, such that we could change the numerator and still have
 “the same” rational number.
 
-<a name="%_sec_Temp_338" id="%_sec_Temp_338"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_338">Pitfalls of imperative programming</a></h4><p>
+<a id="__sec_Temp_338"></a>
+</p><h4>Pitfalls of imperative programming</h4><p>
 
 In contrast to functional programming, programming that makes
-extensive use of assignment is known as <a name="%_idx_3014" id="%_idx_3014"></a><a name="%_idx_3016" id="%_idx_3016"></a><em>imperative
+extensive use of assignment is known as <a id="__idx_3014"></a><a id="__idx_3016"></a><em>imperative
 programming</em>.  In addition to raising complications about
 computational models, programs written in imperative style are
 susceptible to bugs that cannot occur in functional programs.  For
 example, recall the iterative factorial program from
-section <a href="book-Z-H-11.html#%_sec_1.2.1">1.2.1</a>:
+section <a href="book-Z-H-11.html#__sec_1.2.1">1.2.1</a>:
 
 </p><p></p><p><tt>(define (factorial n)<br />
   (define (iter product counter)<br />
@@ -694,7 +694,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 Instead of passing arguments in the internal iterative loop, we could
 adopt a more imperative style by using explicit assignment
 to update the values of the variables <tt>product</tt> and <tt>counter</tt>:
-</p><p></p><p><tt><a name="%_idx_3018" id="%_idx_3018"></a>(define (factorial n)<br />
+</p><p></p><p><tt><a id="__idx_3018"></a>(define (factorial n)<br />
   (let ((product 1)<br />
         (counter 1))<br />
     (define (iter)<br />
@@ -704,7 +704,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
                  (set! counter (+ counter 1))<br />
                  (iter))))<br />
     (iter)))<br /></tt></p><p></p><p>
-<a name="%_idx_3020" id="%_idx_3020"></a><a name="%_idx_3022" id="%_idx_3022"></a>This does not change the results produced by the program, but it does
+<a id="__idx_3020"></a><a id="__idx_3022"></a>This does not change the results produced by the program, but it does
 introduce a subtle trap.  How do we decide the order of the assignments?
 As it happens, the program is correct as written.  But
 writing the assignments in the opposite order
@@ -715,21 +715,21 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 carefully consider the relative orders of the assignments to make sure
 that each statement is using the correct version of the variables that
 have been changed.  This issue simply does not arise in functional
-programs.<a name="call_footnote_Temp_339" href="#footnote_Temp_339" id="call_footnote_Temp_339"><sup><small>11</small></sup></a>
+programs.<a href="#footnote_Temp_339" id="call_footnote_Temp_339"><sup><small>11</small></sup></a>
 
 The complexity of imperative programs becomes even worse if we
 consider applications in which several processes execute concurrently.  We
-will return to this in section <a href="book-Z-H-23.html#%_sec_3.4">3.4</a>.
+will return to this in section <a href="book-Z-H-23.html#__sec_3.4">3.4</a>.
 First, however, we will address the issue of providing a computational
 model for expressions that involve assignment, and explore the uses of
 objects with local state in designing simulations.</p><p>
 
-</p><p><a name="%_thm_3.7" id="%_thm_3.7"></a>
-<b>Exercise 3.7.</b>  <a name="%_idx_3026" id="%_idx_3026"></a>Consider the bank account objects created by <tt>make-account</tt>, with
+</p><p><a id="__thm_3.7"></a>
+<b>Exercise 3.7.</b>  <a id="__idx_3026"></a>Consider the bank account objects created by <tt>make-account</tt>, with
 the password modification described in
-exercise <a href="#%_thm_3.3">3.3</a>.  Suppose that our banking
+exercise <a href="#__thm_3.3">3.3</a>.  Suppose that our banking
 system requires the ability to make joint accounts.  Define a
-procedure <a name="%_idx_3028" id="%_idx_3028"></a><tt>make-joint</tt> that accomplishes this.  <tt>Make-joint</tt>
+procedure <a id="__idx_3028"></a><tt>make-joint</tt> that accomplishes this.  <tt>Make-joint</tt>
 should take three arguments.  The first is a password-protected
 account.  The second argument must match the password with which the
 account was defined in order for the <tt>make-joint</tt> operation to
@@ -742,13 +742,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
   (make-joint peter-acc 'open-sesame 'rosebud))<br /></tt></p><p></p><p>
 will allow one to make transactions on <tt>peter-acc</tt> using the name
 <tt>paul-acc</tt> and the password <tt>rosebud</tt>.  You may wish to modify
-your solution to exercise <a href="#%_thm_3.3">3.3</a> to accommodate
+your solution to exercise <a href="#__thm_3.3">3.3</a> to accommodate
 this new feature.
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.8" id="%_thm_3.8"></a>
-<b>Exercise 3.8.</b>  <a name="%_idx_3030" id="%_idx_3030"></a><a name="%_idx_3032" id="%_idx_3032"></a>When we defined the evaluation model in
-section <a href="book-Z-H-10.html#%_sec_1.1.3">1.1.3</a>, we said that the first step
+</p><p><a id="__thm_3.8"></a>
+<b>Exercise 3.8.</b>  <a id="__idx_3030"></a><a id="__idx_3032"></a>When we defined the evaluation model in
+section <a href="book-Z-H-10.html#__sec_1.1.3">1.1.3</a>, we said that the first step
 in evaluating an expression is to evaluate its subexpressions.  But we
 never specified the order in which the subexpressions should be
 evaluated (e.g., left to right or right to left).  When we introduce
@@ -762,94 +762,94 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.1">3.1  Assignment and Local State<
 </p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_321" href="#call_footnote_Temp_321" id="footnote_Temp_321"><sup><small>1</small></sup></a> Actually,
-this is not quite true.  One exception was the <a name="%_idx_2852" id="%_idx_2852"></a><a name="%_idx_2854" id="%_idx_2854"></a>random-number generator
-in section <a href="book-Z-H-11.html#%_sec_1.2.6">1.2.6</a>.  Another exception involved the
-<a name="%_idx_2856" id="%_idx_2856"></a>operation/type tables we introduced in section <a href="book-Z-H-17.html#%_sec_2.4.3">2.4.3</a>,
+</p><div class="footnote"><p><a href="#call_footnote_Temp_321" id="footnote_Temp_321"><sup><small>1</small></sup></a> Actually,
+this is not quite true.  One exception was the <a id="__idx_2852"></a><a id="__idx_2854"></a>random-number generator
+in section <a href="book-Z-H-11.html#__sec_1.2.6">1.2.6</a>.  Another exception involved the
+<a id="__idx_2856"></a>operation/type tables we introduced in section <a href="book-Z-H-17.html#__sec_2.4.3">2.4.3</a>,
 where the values of two calls to <tt>get</tt> with the same arguments
 depended on intervening calls to <tt>put</tt>.
 On the other hand, until we introduce
 assignment, we have no way to create such procedures ourselves.
 
-</p><p><a name="footnote_Temp_322" href="#call_footnote_Temp_322" id="footnote_Temp_322"><sup><small>2</small></sup></a> <a name="%_idx_2864" id="%_idx_2864"></a><a name="%_idx_2866" id="%_idx_2866"></a>The value of a <tt>set!</tt> expression is implementation-dependent.
+</p><p><a href="#call_footnote_Temp_322" id="footnote_Temp_322"><sup><small>2</small></sup></a> <a id="__idx_2864"></a><a id="__idx_2866"></a>The value of a <tt>set!</tt> expression is implementation-dependent.
 <tt>Set!</tt> should be used only for its effect, not for its value.</p><p>
 
-<a name="%_idx_2868" id="%_idx_2868"></a><a name="%_idx_2870" id="%_idx_2870"></a><a name="%_idx_2872" id="%_idx_2872"></a>The name
+<a id="__idx_2868"></a><a id="__idx_2870"></a><a id="__idx_2872"></a>The name
 <tt>set!</tt> reflects a naming convention used in Scheme: Operations
 that change the values of variables (or that change data structures,
-as we will see in section <a href="book-Z-H-22.html#%_sec_3.3">3.3</a>) are given names that
+as we will see in section <a href="book-Z-H-22.html#__sec_3.3">3.3</a>) are given names that
 end with an exclamation point.  This is similar to the convention of
 designating predicates by names that end with a question mark.
 
-</p><p><a name="footnote_Temp_323" href="#call_footnote_Temp_323" id="footnote_Temp_323"><sup><small>3</small></sup></a> We have already used <a name="%_idx_2878" id="%_idx_2878"></a><tt>begin</tt> implicitly in our
+</p><p><a href="#call_footnote_Temp_323" id="footnote_Temp_323"><sup><small>3</small></sup></a> We have already used <a id="__idx_2878"></a><tt>begin</tt> implicitly in our
 programs, because in Scheme the body of a procedure can be a sequence
 of expressions.  Also, the &lt;<em>consequent</em>&gt; part of each clause in a
-<a name="%_idx_2880" id="%_idx_2880"></a><a name="%_idx_2882" id="%_idx_2882"></a><tt>cond</tt> expression can be a sequence of expressions rather than a
+<a id="__idx_2880"></a><a id="__idx_2882"></a><tt>cond</tt> expression can be a sequence of expressions rather than a
 single expression.
 
-</p><p><a name="footnote_Temp_324" href="#call_footnote_Temp_324" id="footnote_Temp_324"><sup><small>4</small></sup></a> In programming-language jargon, the variable <tt>balance</tt> is said to be <a name="%_idx_2886" id="%_idx_2886"></a><a name="%_idx_2888" id="%_idx_2888"></a><em>encapsulated</em> within the <tt>new-withdraw</tt> procedure.  Encapsulation reflects the general
-system-design principle known as the <a name="%_idx_2890" id="%_idx_2890"></a><a name="%_idx_2892" id="%_idx_2892"></a><em>hiding principle</em>: One can
+</p><p><a href="#call_footnote_Temp_324" id="footnote_Temp_324"><sup><small>4</small></sup></a> In programming-language jargon, the variable <tt>balance</tt> is said to be <a id="__idx_2886"></a><a id="__idx_2888"></a><em>encapsulated</em> within the <tt>new-withdraw</tt> procedure.  Encapsulation reflects the general
+system-design principle known as the <a id="__idx_2890"></a><a id="__idx_2892"></a><em>hiding principle</em>: One can
 make a system more modular and robust by protecting parts of the
 system from each other; that is, by providing information access only
 to those parts of the system that have a “need to know.”
 
-</p><p><a name="footnote_Temp_325" href="#call_footnote_Temp_325" id="footnote_Temp_325"><sup><small>5</small></sup></a> In contrast with <tt>new-withdraw</tt> above, we do not
+</p><p><a href="#call_footnote_Temp_325" id="footnote_Temp_325"><sup><small>5</small></sup></a> In contrast with <tt>new-withdraw</tt> above, we do not
 have to use <tt>let</tt> to make <tt>balance</tt> a local variable, since
 formal parameters are already local.  This will be clearer after the
-discussion of the environment model of evaluation in section <a href="book-Z-H-21.html#%_sec_3.2">3.2</a>.
-(See also exercise <a href="book-Z-H-21.html#%_thm_3.10">3.10</a>.)
+discussion of the environment model of evaluation in section <a href="book-Z-H-21.html#__sec_3.2">3.2</a>.
+(See also exercise <a href="book-Z-H-21.html#__thm_3.10">3.10</a>.)
 
-</p><p><a name="footnote_Temp_330" href="#call_footnote_Temp_330" id="footnote_Temp_330"><sup><small>6</small></sup></a> One common way to implement
+</p><p><a href="#call_footnote_Temp_330" id="footnote_Temp_330"><sup><small>6</small></sup></a> One common way to implement
 <tt>rand-update</tt> is to use the rule that <em>x</em> is updated to <em>a</em><em>x</em> + <em>b</em>
 modulo <em>m</em>, where <em>a</em>, <em>b</em>, and <em>m</em> are appropriately chosen integers.
-Chapter 3 of <a name="%_idx_2924" id="%_idx_2924"></a>Knuth 1981 includes an extensive discussion of techniques
+Chapter 3 of <a id="__idx_2924"></a>Knuth 1981 includes an extensive discussion of techniques
 for generating sequences of random numbers and establishing their
 statistical properties.  Notice that the <tt>rand-update</tt> procedure
 computes a mathematical function: Given the same input twice, it
 produces the same output.  Therefore, the number sequence produced by
 <tt>rand-update</tt> certainly is not “random,” if by “random” we
 insist that each number in the sequence is unrelated to the preceding
-number.  The relation between “real randomness” and so-called <a name="%_idx_2926" id="%_idx_2926"></a><em>pseudo-random</em> sequences, which are produced by well-determined
+number.  The relation between “real randomness” and so-called <a id="__idx_2926"></a><em>pseudo-random</em> sequences, which are produced by well-determined
 computations and yet have suitable statistical properties, is a
 complex question involving difficult issues in mathematics and
-philosophy.  <a name="%_idx_2928" id="%_idx_2928"></a><a name="%_idx_2930" id="%_idx_2930"></a><a name="%_idx_2932" id="%_idx_2932"></a>Kolmogorov, Solomonoff, and Chaitin have made great
+philosophy.  <a id="__idx_2928"></a><a id="__idx_2930"></a><a id="__idx_2932"></a>Kolmogorov, Solomonoff, and Chaitin have made great
 progress in clarifying these issues; a discussion can be found in
 Chaitin 1975.
 
-</p><p><a name="footnote_Temp_331" href="#call_footnote_Temp_331" id="footnote_Temp_331"><sup><small>7</small></sup></a> This theorem is due to E. <a name="%_idx_2942" id="%_idx_2942"></a>Cesàro.  See
-section 4.5.2 of <a name="%_idx_2944" id="%_idx_2944"></a>Knuth 1981 for a discussion and a proof.
+</p><p><a href="#call_footnote_Temp_331" id="footnote_Temp_331"><sup><small>7</small></sup></a> This theorem is due to E. <a id="__idx_2942"></a>Cesàro.  See
+section 4.5.2 of <a id="__idx_2944"></a>Knuth 1981 for a discussion and a proof.
 
-</p><p><a name="footnote_Temp_333" href="#call_footnote_Temp_333" id="footnote_Temp_333"><sup><small>8</small></sup></a> <a name="%_idx_2964" id="%_idx_2964"></a>MIT Scheme provides such a procedure.  If <a name="%_idx_2966" id="%_idx_2966"></a><a name="%_idx_2968" id="%_idx_2968"></a><tt>random</tt>
+</p><p><a href="#call_footnote_Temp_333" id="footnote_Temp_333"><sup><small>8</small></sup></a> <a id="__idx_2964"></a>MIT Scheme provides such a procedure.  If <a id="__idx_2966"></a><a id="__idx_2968"></a><tt>random</tt>
 is given an exact
-integer (as in section <a href="book-Z-H-11.html#%_sec_1.2.6">1.2.6</a>) it returns an exact integer,
+integer (as in section <a href="book-Z-H-11.html#__sec_1.2.6">1.2.6</a>) it returns an exact integer,
 but if it is given a decimal value (as in this exercise) it returns
 a decimal value.
 
-</p><p><a name="footnote_Temp_335" href="#call_footnote_Temp_335" id="footnote_Temp_335"><sup><small>9</small></sup></a> We don't substitute for
+</p><p><a href="#call_footnote_Temp_335" id="footnote_Temp_335"><sup><small>9</small></sup></a> We don't substitute for
 the occurrence of <tt>balance</tt> in the <tt>set!</tt> expression because
 the &lt;<em>name</em>&gt; in a <tt>set!</tt> is not evaluated.
 If we did substitute for it, we would get
 <tt>(set! 25 (- 25 amount))</tt>, which makes no sense.
 
-</p><p><a name="footnote_Temp_337" href="#call_footnote_Temp_337" id="footnote_Temp_337"><sup><small>10</small></sup></a> The phenomenon of a
+</p><p><a href="#call_footnote_Temp_337" id="footnote_Temp_337"><sup><small>10</small></sup></a> The phenomenon of a
 single computational object being accessed by more than one name is
-known as <a name="%_idx_2998" id="%_idx_2998"></a><em>aliasing</em>.  The joint bank account situation illustrates
-a very simple example of an alias.  In section <a href="book-Z-H-22.html#%_sec_3.3">3.3</a>
+known as <a id="__idx_2998"></a><em>aliasing</em>.  The joint bank account situation illustrates
+a very simple example of an alias.  In section <a href="book-Z-H-22.html#__sec_3.3">3.3</a>
 we will see much more complex examples, such as “distinct” compound
 data structures that share parts.  Bugs can occur in our programs if
-<a name="%_idx_3000" id="%_idx_3000"></a><a name="%_idx_3002" id="%_idx_3002"></a><a name="%_idx_3004" id="%_idx_3004"></a>we forget that a change to an object may also, as a “side effect,”
+<a id="__idx_3000"></a><a id="__idx_3002"></a><a id="__idx_3004"></a>we forget that a change to an object may also, as a “side effect,”
 change a “different” object because the two “different” objects
 are actually a single object appearing under different aliases.  These
 so-called <em>side-effect bugs</em> are so difficult to locate and to
 analyze that some people have proposed that programming languages be
 designed in such a way as to not allow side effects or aliasing
-<a name="%_idx_3006" id="%_idx_3006"></a><a name="%_idx_3008" id="%_idx_3008"></a><a name="%_idx_3010" id="%_idx_3010"></a><a name="%_idx_3012" id="%_idx_3012"></a>(Lampson et al. 1981; Morris, Schmidt, and Wadler 1980).
+<a id="__idx_3006"></a><a id="__idx_3008"></a><a id="__idx_3010"></a><a id="__idx_3012"></a>(Lampson et al. 1981; Morris, Schmidt, and Wadler 1980).
 
-</p><p><a name="footnote_Temp_339" href="#call_footnote_Temp_339" id="footnote_Temp_339"><sup><small>11</small></sup></a> In view of this, it is ironic that introductory programming
+</p><p><a href="#call_footnote_Temp_339" id="footnote_Temp_339"><sup><small>11</small></sup></a> In view of this, it is ironic that introductory programming
 is most often taught in a highly imperative style.  This may be a
 vestige of a belief, common throughout the 1960s and 1970s, that
 programs that call procedures must inherently be less efficient than
-programs that perform assignments.  (Steele (1977) <a name="%_idx_3024" id="%_idx_3024"></a>debunks this
+programs that perform assignments.  (Steele (1977) <a id="__idx_3024"></a>debunks this
 argument.)  Alternatively it may reflect a view that step-by-step
 assignment is easier for beginners to visualize than procedure call.
 Whatever the reason, it often saddles beginning programmers with
diff --git a/src/OEBPS/book-Z-H-21.html b/src/OEBPS/book-Z-H-21.html
index b4771c8..806090a 100644
--- a/src/OEBPS/book-Z-H-21.html
+++ b/src/OEBPS/book-Z-H-21.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,14 +13,14 @@
 
 
 
-<a name="%_sec_3.2" id="%_sec_3.2"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Evaluation</a></h2><p>
+<a id="__sec_3.2"></a>
+<h2>3.2  The Environment Model of Evaluation</h2><p>
 
 
-<a name="%_idx_3034" id="%_idx_3034"></a>
+<a id="__idx_3034"></a>
 When we introduced compound procedures in chapter 1, we used the
-<a name="%_idx_3036" id="%_idx_3036"></a>substitution model of evaluation
-(section <a href="book-Z-H-10.html#%_sec_1.1.5">1.1.5</a>) to define what is meant by
+<a id="__idx_3036"></a>substitution model of evaluation
+(section <a href="book-Z-H-10.html#__sec_1.1.5">1.1.5</a>) to define what is meant by
 applying a procedure to arguments:</p><p>
 
 </p><p></p><ul><li>To apply a compound procedure to arguments, evaluate the body of the
@@ -30,27 +30,27 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 
 Once we admit assignment into our programming language, such a
 definition is no longer adequate.  In particular,
-section <a href="book-Z-H-20.html#%_sec_3.1.3">3.1.3</a> argued that, in the presence of
+section <a href="book-Z-H-20.html#__sec_3.1.3">3.1.3</a> argued that, in the presence of
 assignment, a variable can no longer be considered to be merely a name
 for a value.  Rather, a variable must somehow designate a “place” in
 which values can be stored.  In our new model of evaluation, these
-places will be maintained in structures called <a name="%_idx_3038" id="%_idx_3038"></a><em>environments</em>.</p><p>
+places will be maintained in structures called <a id="__idx_3038"></a><em>environments</em>.</p><p>
 
-An environment is a sequence of <a name="%_idx_3040" id="%_idx_3040"></a><em>frames</em>.  Each frame is a table
-(possibly empty) of <a name="%_idx_3042" id="%_idx_3042"></a><em>bindings</em>, which associate variable names with
+An environment is a sequence of <a id="__idx_3040"></a><em>frames</em>.  Each frame is a table
+(possibly empty) of <a id="__idx_3042"></a><em>bindings</em>, which associate variable names with
 their corresponding values.  (A single frame may contain at most one
-binding for any variable.)  Each frame also has a pointer to its <a name="%_idx_3044" id="%_idx_3044"></a><a name="%_idx_3046" id="%_idx_3046"></a><em>enclosing environment</em>, unless, for the purposes of discussion, the
-frame is considered to be <a name="%_idx_3048" id="%_idx_3048"></a><a name="%_idx_3050" id="%_idx_3050"></a><em>global</em>.  The <a name="%_idx_3052" id="%_idx_3052"></a><em>value of a variable</em>
+binding for any variable.)  Each frame also has a pointer to its <a id="__idx_3044"></a><a id="__idx_3046"></a><em>enclosing environment</em>, unless, for the purposes of discussion, the
+frame is considered to be <a id="__idx_3048"></a><a id="__idx_3050"></a><em>global</em>.  The <a id="__idx_3052"></a><em>value of a variable</em>
 with respect to an environment is the value given by the binding of
 the variable in the first frame in the environment that contains a
 binding for that variable.  If no frame in the sequence specifies a
-binding for the variable, then the variable is said to be <a name="%_idx_3054" id="%_idx_3054"></a><a name="%_idx_3056" id="%_idx_3056"></a><em>unbound</em> in the environment.</p><p>
+binding for the variable, then the variable is said to be <a id="__idx_3054"></a><a id="__idx_3056"></a><em>unbound</em> in the environment.</p><p>
 
-<a name="%_fig_3.1" id="%_fig_3.1"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-2.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.1:</b>  A simple environment structure.</div></caption><tr><td>
+<a id="__fig_3.1"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-2.gif" alt="ch3-Z-G-2" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.1:</b>  A simple environment structure.</div></caption><tr><td>
 
-<a name="%_idx_3058" id="%_idx_3058"></a></td></tr></table></div><p></p><p>
+<a id="__idx_3058"></a></td></tr></table></div><p></p><p>
 
-Figure <a href="#%_fig_3.1">3.1</a> shows a simple environment
+Figure <a href="#__fig_3.1">3.1</a> shows a simple environment
 structure consisting of three frames, labeled I, II, and III.  In the
 diagram, A, B, C, and D are pointers to environments.  C and D point
 to the same environment.  The variables <tt>z</tt> and <tt>x</tt> are bound
@@ -62,7 +62,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 find the binding in frame I.  On the other hand, the value of <tt>x</tt>
 in environment A is 7, because the first frame in the sequence (frame
 II) contains a binding of <tt>x</tt> to 7.  With respect to environment
-A, the binding of <tt>x</tt> to 7 in frame II is said to <a name="%_idx_3060" id="%_idx_3060"></a><em>shadow</em> the
+A, the binding of <tt>x</tt> to 7 in frame II is said to <a id="__idx_3060"></a><em>shadow</em> the
 binding of <tt>x</tt> to 3 in frame I.</p><p>
 
 
@@ -76,27 +76,27 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 is operating in a context in which <tt>+</tt> is the symbol for addition.
 Thus, in our model of evaluation we will always speak of evaluating an
 expression with respect to some environment.  To describe interactions
-with the interpreter, we will suppose that there is a <a name="%_idx_3062" id="%_idx_3062"></a>global
+with the interpreter, we will suppose that there is a <a id="__idx_3062"></a>global
 environment, consisting of a single frame (with no enclosing
 environment) that includes values for the symbols associated with the
 primitive procedures.  For example, the idea that <tt>+</tt> is the
 symbol for addition is captured by saying that the symbol <tt>+</tt> is
 bound in the global environment to the primitive addition procedure.</p><p>
 
-<a name="%_sec_3.2.1" id="%_sec_3.2.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.2.1">3.2.1  The Rules for Evaluation</a></h3><p>
+<a id="__sec_3.2.1"></a>
+</p><h3>3.2.1  The Rules for Evaluation</h3><p>
 
-<a name="%_idx_3064" id="%_idx_3064"></a>
+<a id="__idx_3064"></a>
 The overall specification of how the interpreter evaluates a
 combination remains the same as when we first introduced it in
-section <a href="book-Z-H-10.html#%_sec_1.1.3">1.1.3</a>:</p><p>
+section <a href="book-Z-H-10.html#__sec_1.1.3">1.1.3</a>:</p><p>
 
 </p><p></p><ul><li>To evaluate a combination:
 </li></ul><p></p><p>
 
 </p><blockquote>
 <p>1.  Evaluate the subexpressions of the
-combination.<a name="call_footnote_Temp_342" href="#footnote_Temp_342" id="call_footnote_Temp_342"><sup><small>12</small></sup></a></p><p>
+combination.<a href="#footnote_Temp_342" id="call_footnote_Temp_342"><sup><small>12</small></sup></a></p><p>
 
 </p><p>2.  Apply the value of the operator subexpression to the values of the
 operand subexpressions.
@@ -108,12 +108,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 In the environment model of evaluation, a procedure is always a pair
 consisting of some code and a pointer to an environment.  Procedures
 are created in one way only: by evaluating a <tt>lambda</tt> expression.
-<a name="%_idx_3070" id="%_idx_3070"></a>This produces a procedure whose code is obtained from the text of the
+<a id="__idx_3070"></a>This produces a procedure whose code is obtained from the text of the
 <tt>lambda</tt> expression and whose environment is the environment in
 which the <tt>lambda</tt> expression was evaluated to produce the
 procedure.  For example, consider the procedure definition</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3072" id="%_idx_3072"></a>(define (square x)<br />
+</p><p></p><p><tt><a id="__idx_3072"></a>(define (square x)<br />
   (* x x))<br /></tt></p><p></p><p>
 evaluated in the global environment.  The procedure definition syntax
 is just syntactic sugar for an underlying implicit <tt>lambda</tt>
@@ -123,7 +123,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
   (lambda (x) (* x x)))<br /></tt></p><p></p><p>
 which evaluates <tt>(lambda (x) (* x x))</tt> and binds <tt>square</tt> to the resulting value, all in the global environment.</p><p>
 
-Figure <a href="#%_fig_3.2">3.2</a> shows the result of evaluating this
+Figure <a href="#__fig_3.2">3.2</a> shows the result of evaluating this
 <tt>define</tt> expression.  The procedure object is a pair whose code
 specifies that the procedure has one formal parameter, namely <tt>x</tt>,
 and a procedure body <tt>(* x x)</tt>.  The environment part of the
@@ -134,7 +134,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 frame.  In general, <tt>define</tt> creates definitions by adding
 bindings to frames.</p><p>
 
-<a name="%_fig_3.2" id="%_fig_3.2"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-3.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.2:</b>  Environment structure produced by
+<a id="__fig_3.2"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-3.gif" alt="ch3-Z-G-3" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.2:</b>  Environment structure produced by
 evaluating
 <tt>(define (square x) (* x x))</tt> in the global environment.</div></caption><tr><td>
 
@@ -149,10 +149,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 procedure body.</p><p>
 
 
-To show how this rule is followed, figure <a href="#%_fig_3.3">3.3</a>
+To show how this rule is followed, figure <a href="#__fig_3.3">3.3</a>
 illustrates the environment structure created by evaluating the
 expression <tt>(square 5)</tt> in the global environment, where <tt>square</tt> is the procedure generated in
-figure <a href="#%_fig_3.2">3.2</a>.  Applying the procedure results in
+figure <a href="#__fig_3.2">3.2</a>.  Applying the procedure results in
 the creation of a new environment, labeled E1 in the figure, that
 begins with a frame in which <tt>x</tt>, the formal parameter for the
 procedure, is bound to the argument 5.  The pointer leading upward
@@ -163,7 +163,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 <tt>(* x x)</tt>.  Since the value of <tt>x</tt> in E1 is 5, the result is
 <tt>(* 5 5)</tt>, or 25.
 
-<a name="%_fig_3.3" id="%_fig_3.3"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-4.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.3:</b>  Environment created by evaluating <tt>(square 5)</tt>
+<a id="__fig_3.3"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-4.gif" alt="ch3-Z-G-4" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.3:</b>  Environment created by evaluating <tt>(square 5)</tt>
 in the global environment.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
@@ -178,15 +178,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 new frame has as its enclosing environment the environment part of the
 procedure object being applied.<p>
 
-<a name="%_idx_3074" id="%_idx_3074"></a><a name="%_idx_3076" id="%_idx_3076"></a></p></li><li>A procedure is created by evaluating a <tt>lambda</tt>
+<a id="__idx_3074"></a><a id="__idx_3076"></a></p></li><li>A procedure is created by evaluating a <tt>lambda</tt>
 expression relative to a given environment.  The resulting procedure
 object is a pair consisting of the text of the <tt>lambda</tt> expression
 and a pointer to the environment in which the procedure was created.
 </li></ul><p></p><p>
 
-<a name="%_idx_3078" id="%_idx_3078"></a>We also specify that defining a symbol using <tt>define</tt> creates a
+<a id="__idx_3078"></a>We also specify that defining a symbol using <tt>define</tt> creates a
 binding in the current environment frame and assigns to the symbol the
-indicated value.<a name="call_footnote_Temp_343" href="#footnote_Temp_343" id="call_footnote_Temp_343"><sup><small>13</small></sup></a>  Finally, we specify the behavior of
+indicated value.<a href="#footnote_Temp_343" id="call_footnote_Temp_343"><sup><small>13</small></sup></a>  Finally, we specify the behavior of
 <tt>set!</tt>, the operation that forced us to introduce the environment
 model in the first place.  Evaluating the expression <tt>(set!
 &lt;<em>variable</em>&gt; &lt;<em>value</em>&gt;)</tt> in some environment locates the binding of
@@ -205,12 +205,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 interpreter.  The following sections elaborate the details of the
 model by analyzing some illustrative programs.
 
-<a name="%_sec_3.2.2" id="%_sec_3.2.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.2.2">3.2.2  Applying Simple Procedures</a></h3><p>
+<a id="__sec_3.2.2"></a>
+</p><h3>3.2.2  Applying Simple Procedures</h3><p>
 
-<a name="%_idx_3082" id="%_idx_3082"></a><a name="%_idx_3084" id="%_idx_3084"></a>
-<a name="%_idx_3086" id="%_idx_3086"></a>When we introduced the substitution model in
-section <a href="book-Z-H-10.html#%_sec_1.1.5">1.1.5</a> we showed how the combination
+<a id="__idx_3082"></a><a id="__idx_3084"></a>
+<a id="__idx_3086"></a>When we introduced the substitution model in
+section <a href="book-Z-H-10.html#__sec_1.1.5">1.1.5</a> we showed how the combination
 <tt>(f 5)</tt> evaluates to 136, given the following procedure
 definitions:</p><p>
 
@@ -221,17 +221,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 (define (f a)<br />
   (sum-of-squares (+ a 1) (* a 2)))<br /></tt></p><p></p><p>
 We can analyze the same example using the environment model.
-Figure <a href="#%_fig_3.4">3.4</a> shows the three procedure objects
+Figure <a href="#__fig_3.4">3.4</a> shows the three procedure objects
 created by evaluating the definitions of <tt>f</tt>, <tt>square</tt>, and
 <tt>sum-of-squares</tt> in the global environment.  Each procedure object
 consists of some code, together with a pointer to the global
 environment.</p><p>
 
-<a name="%_fig_3.4" id="%_fig_3.4"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-5.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.4:</b>  Procedure objects in the global frame.</div></caption><tr><td>
+<a id="__fig_3.4"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-5.gif" alt="ch3-Z-G-5" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.4:</b>  Procedure objects in the global frame.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-In figure <a href="#%_fig_3.5">3.5</a> we see the environment structure created
+In figure <a href="#__fig_3.5">3.5</a> we see the environment structure created
 by evaluating the expression <tt>(f 5)</tt>.  The call to <tt>f</tt> creates
 a new environment E1 beginning with a frame in which <tt>a</tt>, the
 formal parameter of <tt>f</tt>, is bound to the argument 5.  In E1, we
@@ -239,8 +239,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 
 </p><p></p><p><tt>(sum-of-squares (+ a 1) (* a 2))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_fig_3.5" id="%_fig_3.5"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-6.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.5:</b>  Environments created by evaluating <tt>(f 5)</tt>
-using the procedures in figure <a href="#%_fig_3.4">3.4</a>.</div></caption><tr><td>
+<a id="__fig_3.5"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-6.gif" alt="ch3-Z-G-6" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.5:</b>  Environments created by evaluating <tt>(f 5)</tt>
+using the procedures in figure <a href="#__fig_3.4">3.4</a>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
@@ -250,7 +250,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 procedure object.  (Notice how this value is found: We first look in
 the first frame of E1, which contains no binding for <tt>sum-of-squares</tt>.  Then we proceed to the enclosing environment,
 i.e. the global environment, and find the binding shown in
-figure <a href="#%_fig_3.4">3.4</a>.)  The other two subexpressions are
+figure <a href="#__fig_3.4">3.4</a>.)  The other two subexpressions are
 evaluated by applying the primitive operations <tt>+</tt> and <tt>*</tt> to
 evaluate the two combinations <tt>(+ a 1)</tt> and <tt>(* a 2)</tt> to
 obtain 6 and 10, respectively.</p><p>
@@ -284,8 +284,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 however, this is also an important aspect of the evaluation process,
 and we will return to it in detail in chapter 5.
 
-</p><p><a name="%_thm_3.9" id="%_thm_3.9"></a>
-<b>Exercise 3.9.</b>  <a name="%_idx_3088" id="%_idx_3088"></a><a name="%_idx_3090" id="%_idx_3090"></a><a name="%_idx_3092" id="%_idx_3092"></a>In section <a href="book-Z-H-11.html#%_sec_1.2.1">1.2.1</a>
+</p><p><a id="__thm_3.9"></a>
+<b>Exercise 3.9.</b>  <a id="__idx_3088"></a><a id="__idx_3090"></a><a id="__idx_3092"></a>In section <a href="book-Z-H-11.html#__sec_1.2.1">1.2.1</a>
 we used the substitution model to analyze two
 procedures for computing factorials, a recursive version</p><p>
 
@@ -304,18 +304,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
                  (+ counter 1)<br />
                  max-count)))<br /></tt></p><p></p><p>
 Show the environment structures created by evaluating <tt>(factorial 6)</tt>
-using each version of the <tt>factorial</tt> procedure.<a name="call_footnote_Temp_345" href="#footnote_Temp_345" id="call_footnote_Temp_345"><sup><small>14</small></sup></a>
+using each version of the <tt>factorial</tt> procedure.<a href="#footnote_Temp_345" id="call_footnote_Temp_345"><sup><small>14</small></sup></a>
 </p><p>
 
-<a name="%_sec_3.2.3" id="%_sec_3.2.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.2.3">3.2.3  Frames as the Repository of Local State</a></h3><p>
+<a id="__sec_3.2.3"></a>
+</p><h3>3.2.3  Frames as the Repository of Local State</h3><p>
 
 
-<a name="%_idx_3098" id="%_idx_3098"></a><a name="%_idx_3100" id="%_idx_3100"></a><a name="%_idx_3102" id="%_idx_3102"></a>
-<a name="%_idx_3104" id="%_idx_3104"></a>We can turn to the environment model to see how procedures and
+<a id="__idx_3098"></a><a id="__idx_3100"></a><a id="__idx_3102"></a>
+<a id="__idx_3104"></a>We can turn to the environment model to see how procedures and
 assignment can be used to represent objects with local state.  As an
 example, consider the “withdrawal processor” from
-section <a href="book-Z-H-20.html#%_sec_3.1.1">3.1.1</a> created by calling the
+section <a href="book-Z-H-20.html#__sec_3.1.1">3.1.1</a> created by calling the
 procedure</p><p>
 
 </p><p></p><p><tt>(define (make-withdraw balance)<br />
@@ -330,13 +330,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 followed by</p><p>
 
 </p><p></p><p><tt>(W1 50)<br /><i>50</i><br /></tt></p><p></p><p>
-Figure <a href="#%_fig_3.6">3.6</a> shows the result of defining the <tt>make-withdraw</tt> procedure in the global environment.  This produces a
+Figure <a href="#__fig_3.6">3.6</a> shows the result of defining the <tt>make-withdraw</tt> procedure in the global environment.  This produces a
 procedure object that contains a pointer to the global environment.
 So far, this is no different from the examples we have already seen,
 except that the body of the procedure is itself a <tt>lambda</tt>
 expression.</p><p>
 
-<a name="%_fig_3.6" id="%_fig_3.6"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-7.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.6:</b>  Result of defining <tt>make-withdraw</tt>
+<a id="__fig_3.6"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-7.gif" alt="ch3-Z-G-7" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.6:</b>  Result of defining <tt>make-withdraw</tt>
 in the global environment.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
@@ -353,10 +353,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 is E1, the environment in which the <tt>lambda</tt> was evaluated to
 produce the procedure.  The resulting procedure object is the value
 returned by the call to <tt>make-withdraw</tt>.  This is bound to <tt>W1</tt> in the global environment, since the <tt>define</tt> itself is being
-evaluated in the global environment.  Figure <a href="#%_fig_3.7">3.7</a> shows the
+evaluated in the global environment.  Figure <a href="#__fig_3.7">3.7</a> shows the
 resulting environment structure.</p><p>
 
-<a name="%_fig_3.7" id="%_fig_3.7"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-8.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.7:</b>  Result of evaluating <tt>(define W1 (make-withdraw 100))</tt>.</div></caption><tr><td>
+<a id="__fig_3.7"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-8.gif" alt="ch3-Z-G-8" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.7:</b>  Result of evaluating <tt>(define W1 (make-withdraw 100))</tt>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
@@ -376,12 +376,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
            balance)<br />
     "Insufficient funds")<br /></tt></p><p></p><p>
 The resulting environment structure is shown in
-figure <a href="#%_fig_3.8">3.8</a>.  The expression being evaluated references
+figure <a href="#__fig_3.8">3.8</a>.  The expression being evaluated references
 both <tt>amount</tt> and <tt>balance</tt>.  <tt>Amount</tt> will be found in
 the first frame in the environment, while <tt>balance</tt> will be found
 by following the enclosing-environment pointer to E1.</p><p>
 
-<a name="%_fig_3.8" id="%_fig_3.8"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-9.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.8:</b>  Environments created by applying the procedure
+<a id="__fig_3.8"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-9.gif" alt="ch3-Z-G-9" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.8:</b>  Environments created by applying the procedure
 object <tt>W1</tt>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
@@ -396,10 +396,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 environment.  The next time <tt>W1</tt> is called, this will build a new
 frame that binds <tt>amount</tt> and whose enclosing environment is E1.
 We see that E1 serves as the “place” that holds the local state
-variable for the procedure object <tt>W1</tt>.  Figure <a href="#%_fig_3.9">3.9</a>
+variable for the procedure object <tt>W1</tt>.  Figure <a href="#__fig_3.9">3.9</a>
 shows the situation after the call to <tt>W1</tt>.</p><p>
 
-<a name="%_fig_3.9" id="%_fig_3.9"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-10.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.9:</b>  Environments after the call to <tt>W1</tt>.</div></caption><tr><td>
+<a id="__fig_3.9"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-10.gif" alt="ch3-Z-G-10" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.9:</b>  Environments after the call to <tt>W1</tt>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
@@ -407,37 +407,37 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 making another call to <tt>make-withdraw</tt>:</p><p>
 
 </p><p></p><p><tt>(define W2 (make-withdraw 100))<br /></tt></p><p></p><p>
-This produces the environment structure of figure <a href="#%_fig_3.10">3.10</a>, which shows
+This produces the environment structure of figure <a href="#__fig_3.10">3.10</a>, which shows
 that <tt>W2</tt> is a procedure object, that is, a pair with some code
 and an environment.  The environment E2 for <tt>W2</tt> was created by
 the call to <tt>make-withdraw</tt>.  It contains a frame with its own
 local binding for <tt>balance</tt>.  On the other hand, <tt>W1</tt> and <tt>W2</tt> have the same code: the code specified by the <tt>lambda</tt>
-expression in the body of <tt>make-withdraw</tt>.<a name="call_footnote_Temp_346" href="#footnote_Temp_346" id="call_footnote_Temp_346"><sup><small>15</small></sup></a> We see here why <tt>W1</tt> and <tt>W2</tt>
+expression in the body of <tt>make-withdraw</tt>.<a href="#footnote_Temp_346" id="call_footnote_Temp_346"><sup><small>15</small></sup></a> We see here why <tt>W1</tt> and <tt>W2</tt>
 behave as independent objects.  Calls to <tt>W1</tt> reference the state
 variable <tt>balance</tt> stored in E1, whereas calls to <tt>W2</tt>
 reference the <tt>balance</tt> stored in E2. Thus, changes to the local
 state of one object do not affect the other object.</p><p>
 
-<a name="%_fig_3.10" id="%_fig_3.10"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-11.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.10:</b>  Using <tt>(define W2 (make-withdraw 100))</tt>
+<a id="__fig_3.10"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-11.gif" alt="ch3-Z-G-11" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.10:</b>  Using <tt>(define W2 (make-withdraw 100))</tt>
 to create a second object.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-</p><p><a name="%_thm_3.10" id="%_thm_3.10"></a>
+</p><p><a id="__thm_3.10"></a>
 <b>Exercise 3.10.</b>  In the <tt>make-withdraw</tt> procedure, the local variable <tt>balance</tt>
 is created as a parameter of <tt>make-withdraw</tt>.  We could also
 create the local state variable explicitly, using <tt>let</tt>, as
 follows:
 </p><p>
 
-</p><p></p><p><tt><a name="%_idx_3106" id="%_idx_3106"></a>(define (make-withdraw initial-amount)<br />
+</p><p></p><p><tt><a id="__idx_3106"></a>(define (make-withdraw initial-amount)<br />
   (let ((balance initial-amount))<br />
     (lambda (amount)<br />
       (if (&gt;= balance amount)<br />
           (begin (set! balance (- balance amount))<br />
                  balance)<br />
           "Insufficient funds"))))<br /></tt></p><p></p><p>
-<a name="%_idx_3108" id="%_idx_3108"></a><a name="%_idx_3110" id="%_idx_3110"></a>Recall from section <a href="book-Z-H-12.html#%_sec_1.3.2">1.3.2</a> that <tt>let</tt> is simply
+<a id="__idx_3108"></a><a id="__idx_3110"></a>Recall from section <a href="book-Z-H-12.html#__sec_1.3.2">1.3.2</a> that <tt>let</tt> is simply
 syntactic sugar for a procedure call:</p><p>
 
 
@@ -460,16 +460,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 </p><p>
 </p><p>
 
-<a name="%_sec_3.2.4" id="%_sec_3.2.4"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.2.4">3.2.4  Internal Definitions</a></h3><p>
+<a id="__sec_3.2.4"></a>
+</p><h3>3.2.4  Internal Definitions</h3><p>
 
-<a name="%_idx_3112" id="%_idx_3112"></a><a name="%_idx_3114" id="%_idx_3114"></a><a name="%_idx_3116" id="%_idx_3116"></a>
-Section <a href="book-Z-H-10.html#%_sec_1.1.8">1.1.8</a> introduced the idea that procedures can have internal
+<a id="__idx_3112"></a><a id="__idx_3114"></a><a id="__idx_3116"></a>
+Section <a href="book-Z-H-10.html#__sec_1.1.8">1.1.8</a> introduced the idea that procedures can have internal
 definitions, thus leading to a block structure as in the
 following procedure to compute square roots:</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_3118" id="%_idx_3118"></a>(define (sqrt x)<br />
+</p><p></p><p><tt><a id="__idx_3118"></a>(define (sqrt x)<br />
   (define (good-enough? guess)<br />
     (&lt; (abs (- (square guess) x)) 0.001))<br />
   (define (improve guess)<br />
@@ -480,12 +480,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
         (sqrt-iter (improve guess))))<br />
   (sqrt-iter 1.0))<br /></tt></p><p></p><p>
 Now we can use the environment model to see why these internal
-definitions behave as desired.  Figure <a href="#%_fig_3.11">3.11</a> shows the point in the
+definitions behave as desired.  Figure <a href="#__fig_3.11">3.11</a> shows the point in the
 evaluation of the expression <tt>(sqrt 2)</tt> where the internal
 procedure <tt>good-enough?</tt> has been called for the first time with
 <tt>guess</tt> equal to 1.</p><p>
 
-<a name="%_fig_3.11" id="%_fig_3.11"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-12.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.11:</b>  <tt>Sqrt</tt> procedure with internal definitions.</div></caption><tr><td>
+<a id="__fig_3.11"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-12.gif" alt="ch3-Z-G-12" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.11:</b>  <tt>Sqrt</tt> procedure with internal definitions.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
@@ -502,7 +502,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 evaluating this expression defined the procedure <tt>good-enough?</tt>
 in the environment E1.  To be more precise, the symbol <tt>good-enough?</tt> was added to the first frame of E1, bound to a
 procedure object whose associated environment is E1.  Similarly, <tt>improve</tt> and <tt>sqrt-iter</tt> were defined as procedures in E1.  For
-conciseness, figure <a href="#%_fig_3.11">3.11</a> shows only the procedure
+conciseness, figure <a href="#__fig_3.11">3.11</a> shows only the procedure
 object for <tt>good-enough?</tt>.</p><p>
 
 After the local procedures were defined, the
@@ -536,15 +536,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 enclosing procedure.
 </li></ul><p></p><p>
 
-</p><p><a name="%_thm_3.11" id="%_thm_3.11"></a>
-<b>Exercise 3.11.</b>  <a name="%_idx_3120" id="%_idx_3120"></a><a name="%_idx_3122" id="%_idx_3122"></a><a name="%_idx_3124" id="%_idx_3124"></a>In section <a href="#%_sec_3.2.3">3.2.3</a>
+</p><p><a id="__thm_3.11"></a>
+<b>Exercise 3.11.</b>  <a id="__idx_3120"></a><a id="__idx_3122"></a><a id="__idx_3124"></a>In section <a href="#__sec_3.2.3">3.2.3</a>
 we saw how the environment model described the
 behavior of procedures with local state.  Now we have seen how
 internal definitions work.  A typical message-passing procedure
 contains both of these aspects.  Consider the bank account procedure
-of section <a href="book-Z-H-20.html#%_sec_3.1.1">3.1.1</a>:</p><p>
+of section <a href="book-Z-H-20.html#__sec_3.1.1">3.1.1</a>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3126" id="%_idx_3126"></a>(define (make-account balance)<br />
+</p><p></p><p><tt><a id="__idx_3126"></a>(define (make-account balance)<br />
   (define (withdraw amount)<br />
     (if (&gt;= balance amount)<br />
         (begin (set! balance (- balance amount))<br />
@@ -576,35 +576,35 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.2">3.2  The Environment Model of Ev
 </p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_342" href="#call_footnote_Temp_342" id="footnote_Temp_342"><sup><small>12</small></sup></a> Assignment introduces a subtlety into step 1 of
+</p><div class="footnote"><p><a href="#call_footnote_Temp_342" id="footnote_Temp_342"><sup><small>12</small></sup></a> Assignment introduces a subtlety into step 1 of
 the evaluation rule.  As shown in
-exercise <a href="book-Z-H-20.html#%_thm_3.8">3.8</a>, the presence of assignment
+exercise <a href="book-Z-H-20.html#__thm_3.8">3.8</a>, the presence of assignment
 allows us to write expressions that will produce different values
 depending on the order in which the subexpressions in a combination
-<a name="%_idx_3066" id="%_idx_3066"></a><a name="%_idx_3068" id="%_idx_3068"></a>are evaluated.  Thus, to be precise, we should specify an evaluation
+<a id="__idx_3066"></a><a id="__idx_3068"></a>are evaluated.  Thus, to be precise, we should specify an evaluation
 order in step 1 (e.g., left to right or right to left).  However, this
 order should always be considered to be an implementation detail, and
 one should never write programs that depend on some particular order.
 For instance, a sophisticated compiler might optimize a program by
 varying the order in which subexpressions are evaluated.
 
-</p><p><a name="footnote_Temp_343" href="#call_footnote_Temp_343" id="footnote_Temp_343"><sup><small>13</small></sup></a> If there is already a binding for the
+</p><p><a href="#call_footnote_Temp_343" id="footnote_Temp_343"><sup><small>13</small></sup></a> If there is already a binding for the
 variable in the current frame, then the binding is changed.  This is
 convenient because it allows redefinition of symbols; however, it also
 means that <tt>define</tt> can be used to change values, and this brings
-up the issues of assignment without explicitly using <a name="%_idx_3080" id="%_idx_3080"></a><tt>set!</tt>.
+up the issues of assignment without explicitly using <a id="__idx_3080"></a><tt>set!</tt>.
 Because of this, some people prefer redefinitions of existing symbols
 to signal errors or warnings.
 
-</p><p><a name="footnote_Temp_345" href="#call_footnote_Temp_345" id="footnote_Temp_345"><sup><small>14</small></sup></a> The
+</p><p><a href="#call_footnote_Temp_345" id="footnote_Temp_345"><sup><small>14</small></sup></a> The
 environment model will not clarify our claim in
-section <a href="book-Z-H-11.html#%_sec_1.2.1">1.2.1</a> that the interpreter can
+section <a href="book-Z-H-11.html#__sec_1.2.1">1.2.1</a> that the interpreter can
 execute a procedure such as <tt>fact-iter</tt> in a constant amount of
 space using tail recursion.  We will discuss tail recursion when we
-<a name="%_idx_3094" id="%_idx_3094"></a><a name="%_idx_3096" id="%_idx_3096"></a>deal with the control structure of the interpreter in
-section <a href="book-Z-H-34.html#%_sec_5.4">5.4</a>.
+<a id="__idx_3094"></a><a id="__idx_3096"></a>deal with the control structure of the interpreter in
+section <a href="book-Z-H-34.html#__sec_5.4">5.4</a>.
 
-</p><p><a name="footnote_Temp_346" href="#call_footnote_Temp_346" id="footnote_Temp_346"><sup><small>15</small></sup></a> Whether
+</p><p><a href="#call_footnote_Temp_346" id="footnote_Temp_346"><sup><small>15</small></sup></a> Whether
 <tt>W1</tt> and <tt>W2</tt> share the same physical code stored in the
 computer, or whether they each keep a copy of the code, is a detail of
 the implementation.  For the interpreter we implement in chapter 4,
diff --git a/src/OEBPS/book-Z-H-22.html b/src/OEBPS/book-Z-H-22.html
index bdb4325..068e0b3 100644
--- a/src/OEBPS/book-Z-H-22.html
+++ b/src/OEBPS/book-Z-H-22.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,11 +13,11 @@
 
 
 
-<a name="%_sec_3.3" id="%_sec_3.3"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data</a></h2><p>
+<a id="__sec_3.3"></a>
+<h2>3.3  Modeling with Mutable Data</h2><p>
 
 
-<a name="%_idx_3128" id="%_idx_3128"></a>
+<a id="__idx_3128"></a>
 Chapter 2 dealt with compound data as a means for constructing
 computational objects that have several parts, in order to model
 real-world objects that have several aspects.  In that chapter we
@@ -30,7 +30,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 compound data objects, as well as to construct and select from them.
 In order to model compound objects with changing state, we will design
 data abstractions to include, in addition to selectors and
-constructors, operations called <a name="%_idx_3130" id="%_idx_3130"></a><em>mutators</em>, which modify data
+constructors, operations called <a id="__idx_3130"></a><em>mutators</em>, which modify data
 objects.  For instance, modeling a banking system requires us to
 change account balances.  Thus, a data structure for representing bank
 accounts might admit an operation</p><p>
@@ -46,16 +46,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 constructing mutable data objects.  These mutators greatly enhance the
 representational power of pairs, enabling us to build data structures
 other than the sequences and trees that we worked with in
-section <a href="book-Z-H-15.html#%_sec_2.2">2.2</a>.  We also present some examples of
+section <a href="book-Z-H-15.html#__sec_2.2">2.2</a>.  We also present some examples of
 simulations in which complex systems are modeled as collections of
 objects with local state.</p><p>
 
-<a name="%_sec_3.3.1" id="%_sec_3.3.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.3.1">3.3.1  Mutable List Structure</a></h3><p>
+<a id="__sec_3.3.1"></a>
+</p><h3>3.3.1  Mutable List Structure</h3><p>
 
 
-<a name="%_idx_3132" id="%_idx_3132"></a><a name="%_idx_3134" id="%_idx_3134"></a>
-<a name="%_idx_3136" id="%_idx_3136"></a><a name="%_idx_3138" id="%_idx_3138"></a>
+<a id="__idx_3132"></a><a id="__idx_3134"></a>
+<a id="__idx_3136"></a><a id="__idx_3138"></a>
 The basic operations on pairs – <tt>cons</tt>, <tt>car</tt>, and <tt>cdr</tt> – can be used to construct list structure and to select parts
 from list structure, but they are incapable of modifying list
 structure.  The same is true of the list operations we have used so
@@ -63,73 +63,73 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 in terms of <tt>cons</tt>, <tt>car</tt>, and <tt>cdr</tt>.  To modify list
 structures we need new operations.</p><p>
 
-<a name="%_fig_3.12" id="%_fig_3.12"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-13.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.12:</b>  Lists <tt>x</tt>: <tt>((a b) c d)</tt> and <tt>y</tt>: <tt>(e
+<a id="__fig_3.12"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-13.gif" alt="ch3-Z-G-13" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.12:</b>  Lists <tt>x</tt>: <tt>((a b) c d)</tt> and <tt>y</tt>: <tt>(e
 f)</tt>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_fig_3.13" id="%_fig_3.13"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-14.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.13:</b>  Effect of <tt>(set-car! x y)</tt> on the lists in
-figure <a href="#%_fig_3.12">3.12</a>.</div></caption><tr><td>
+<a id="__fig_3.13"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-14.gif" alt="ch3-Z-G-14" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.13:</b>  Effect of <tt>(set-car! x y)</tt> on the lists in
+figure <a href="#__fig_3.12">3.12</a>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_fig_3.14" id="%_fig_3.14"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-15.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.14:</b>  Effect of <tt>(define z (cons y (cdr x)))</tt> on
-the lists in figure <a href="#%_fig_3.12">3.12</a>.</div></caption><tr><td>
+<a id="__fig_3.14"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-15.gif" alt="ch3-Z-G-15" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.14:</b>  Effect of <tt>(define z (cons y (cdr x)))</tt> on
+the lists in figure <a href="#__fig_3.12">3.12</a>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_fig_3.15" id="%_fig_3.15"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-16.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.15:</b>  Effect of <tt>(set-cdr! x y)</tt> on the lists in
-figure <a href="#%_fig_3.12">3.12</a>.</div></caption><tr><td>
+<a id="__fig_3.15"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-16.gif" alt="ch3-Z-G-16" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.15:</b>  Effect of <tt>(set-cdr! x y)</tt> on the lists in
+figure <a href="#__fig_3.12">3.12</a>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_idx_3140" id="%_idx_3140"></a><a name="%_idx_3142" id="%_idx_3142"></a><a name="%_idx_3144" id="%_idx_3144"></a><a name="%_idx_3146" id="%_idx_3146"></a>The primitive mutators for pairs are <tt>set-car!</tt> and <tt>set-cdr!</tt>. <tt>Set-car!</tt> takes two arguments, the first of which
+<a id="__idx_3140"></a><a id="__idx_3142"></a><a id="__idx_3144"></a><a id="__idx_3146"></a>The primitive mutators for pairs are <tt>set-car!</tt> and <tt>set-cdr!</tt>. <tt>Set-car!</tt> takes two arguments, the first of which
 must be a pair.  It modifies this pair, replacing the <tt>car</tt>
-pointer by a pointer to the second argument of <tt>set-car!</tt>.<a name="call_footnote_Temp_349" href="#footnote_Temp_349" id="call_footnote_Temp_349"><sup><small>16</small></sup></a></p><p>
+pointer by a pointer to the second argument of <tt>set-car!</tt>.<a href="#footnote_Temp_349" id="call_footnote_Temp_349"><sup><small>16</small></sup></a></p><p>
 
 As an example, suppose that <tt>x</tt> is bound to the list <tt>((a b) c
 d)</tt> and <tt>y</tt> to the list <tt>(e f)</tt> as illustrated in
-figure <a href="#%_fig_3.12">3.12</a>.  Evaluating the expression <tt>(set-car!
+figure <a href="#__fig_3.12">3.12</a>.  Evaluating the expression <tt>(set-car!
 x y)</tt> modifies the pair to which <tt>x</tt> is bound, replacing its <tt>car</tt> by the value of <tt>y</tt>.  The result of the operation is shown in
-figure <a href="#%_fig_3.13">3.13</a>.  The structure <tt>x</tt> has been modified and
+figure <a href="#__fig_3.13">3.13</a>.  The structure <tt>x</tt> has been modified and
 would now be printed
 as <tt>((e f) c d)</tt>.  The
 pairs representing the list <tt>(a b)</tt>, identified by the pointer
 that was replaced, are now detached from the original
-structure.<a name="call_footnote_Temp_350" href="#footnote_Temp_350" id="call_footnote_Temp_350"><sup><small>17</small></sup></a></p><p>
+structure.<a href="#footnote_Temp_350" id="call_footnote_Temp_350"><sup><small>17</small></sup></a></p><p>
 
-Compare figure <a href="#%_fig_3.13">3.13</a> with figure <a href="#%_fig_3.14">3.14</a>,
+Compare figure <a href="#__fig_3.13">3.13</a> with figure <a href="#__fig_3.14">3.14</a>,
 which illustrates the result of executing <tt>(define z (cons y (cdr
 x)))</tt> with <tt>x</tt> and <tt>y</tt> bound to the original lists of
-figure <a href="#%_fig_3.12">3.12</a>.  The variable <tt>z</tt> is now bound to a
+figure <a href="#__fig_3.12">3.12</a>.  The variable <tt>z</tt> is now bound to a
 new pair created by the <tt>cons</tt> operation; the list to which <tt>x</tt> is bound is unchanged.</p><p>
 
 The <tt>set-cdr!</tt> operation is similar to <tt>set-car!</tt>.  The
 only difference is that the <tt>cdr</tt> pointer of the pair, rather than
-the <tt>car</tt> pointer, is replaced.  The effect of executing <tt>(set-cdr! x y)</tt> on the lists of figure <a href="#%_fig_3.12">3.12</a> is shown
-in figure <a href="#%_fig_3.15">3.15</a>.
+the <tt>car</tt> pointer, is replaced.  The effect of executing <tt>(set-cdr! x y)</tt> on the lists of figure <a href="#__fig_3.12">3.12</a> is shown
+in figure <a href="#__fig_3.15">3.15</a>.
 Here the <tt>cdr</tt> pointer of <tt>x</tt> has been replaced by the pointer
 to <tt>(e f)</tt>.  Also, the list <tt>(c d)</tt>, which used to be the <tt>cdr</tt> of <tt>x</tt>, is now detached from the structure.</p><p>
 
-<a name="%_idx_3158" id="%_idx_3158"></a><tt>Cons</tt> builds new list structure by creating new pairs, while
+<a id="__idx_3158"></a><tt>Cons</tt> builds new list structure by creating new pairs, while
 <tt>set-car!</tt> and <tt>set-cdr!</tt> modify existing pairs.  Indeed, we
 could implement <tt>cons</tt> in terms of the two mutators, together with
 a procedure <tt>get-new-pair</tt>, which returns a new pair that is not
 part of any existing list structure.  We obtain the new pair, set its
 <tt>car</tt> and <tt>cdr</tt> pointers to the designated objects, and return
-the new pair as the result of the <tt>cons</tt>.<a name="call_footnote_Temp_351" href="#footnote_Temp_351" id="call_footnote_Temp_351"><sup><small>18</small></sup></a></p><p>
+the new pair as the result of the <tt>cons</tt>.<a href="#footnote_Temp_351" id="call_footnote_Temp_351"><sup><small>18</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_3160" id="%_idx_3160"></a>(define (cons x y)<br />
+</p><p></p><p><tt><a id="__idx_3160"></a>(define (cons x y)<br />
   (let ((new (get-new-pair)))<br />
     (set-car! new x)<br />
     (set-cdr! new y)<br />
     new))<br /></tt></p><p></p><p>
 
-</p><p><a name="%_thm_3.12" id="%_thm_3.12"></a>
-<b>Exercise 3.12.</b>  <a name="%_idx_3162" id="%_idx_3162"></a>The following procedure for appending lists was introduced in
-section <a href="book-Z-H-15.html#%_sec_2.2.1">2.2.1</a>:</p><p>
+</p><p><a id="__thm_3.12"></a>
+<b>Exercise 3.12.</b>  <a id="__idx_3162"></a>The following procedure for appending lists was introduced in
+section <a href="book-Z-H-15.html#__sec_2.2.1">2.2.1</a>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3164" id="%_idx_3164"></a>(define (append x y)<br />
+</p><p></p><p><tt><a id="__idx_3164"></a>(define (append x y)<br />
   (if (null? x)<br />
       y<br />
       (cons (car x) (append (cdr x) y))))<br /></tt></p><p></p><p>
@@ -140,13 +140,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 pair of <tt>x</tt> so that its <tt>cdr</tt> is now <tt>y</tt>.
 (It is an error to call <tt>append!</tt> with an empty <tt>x</tt>.)</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3166" id="%_idx_3166"></a>(define (append! x y)<br />
+</p><p></p><p><tt><a id="__idx_3166"></a>(define (append! x y)<br />
   (set-cdr! (last-pair x) y)<br />
   x)<br /></tt></p><p></p><p>
 Here <tt>last-pair</tt> is a procedure that returns the last pair in its
 argument:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3168" id="%_idx_3168"></a>(define (last-pair x)<br />
+</p><p></p><p><tt><a id="__idx_3168"></a>(define (last-pair x)<br />
   (if (null? (cdr x))<br />
       x<br />
       (last-pair (cdr x))))<br /></tt></p><p></p><p>
@@ -167,10 +167,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.13" id="%_thm_3.13"></a>
-<b>Exercise 3.13.</b>  <a name="%_idx_3170" id="%_idx_3170"></a>Consider the following <tt>make-cycle</tt> procedure, which uses the <tt>last-pair</tt> procedure defined in exercise <a href="#%_thm_3.12">3.12</a>:</p><p>
+</p><p><a id="__thm_3.13"></a>
+<b>Exercise 3.13.</b>  <a id="__idx_3170"></a>Consider the following <tt>make-cycle</tt> procedure, which uses the <tt>last-pair</tt> procedure defined in exercise <a href="#__thm_3.12">3.12</a>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3172" id="%_idx_3172"></a>(define (make-cycle x)<br />
+</p><p></p><p><tt><a id="__idx_3172"></a>(define (make-cycle x)<br />
   (set-cdr! (last-pair x) x)<br />
   x)<br /></tt></p><p></p><p>
 Draw a box-and-pointer diagram that shows the structure <tt>z</tt>
@@ -181,10 +181,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.14" id="%_thm_3.14"></a>
+</p><p><a id="__thm_3.14"></a>
 <b>Exercise 3.14.</b>  The following procedure is quite useful, although obscure:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3174" id="%_idx_3174"></a>(define (mystery x)<br />
+</p><p></p><p><tt><a id="__idx_3174"></a>(define (mystery x)<br />
   (define (loop x y)<br />
     (if (null? x)<br />
         y<br />
@@ -204,11 +204,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 </p><p>
 
 
-<a name="%_sec_Temp_355" id="%_sec_Temp_355"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_355">Sharing and identity</a></h4><p>
+<a id="__sec_Temp_355"></a>
+</p><h4>Sharing and identity</h4><p>
 
-<a name="%_idx_3176" id="%_idx_3176"></a><a name="%_idx_3178" id="%_idx_3178"></a>
-<a name="%_idx_3180" id="%_idx_3180"></a><a name="%_idx_3182" id="%_idx_3182"></a>We mentioned in section <a href="book-Z-H-20.html#%_sec_3.1.3">3.1.3</a> the theoretical
+<a id="__idx_3176"></a><a id="__idx_3178"></a>
+<a id="__idx_3180"></a><a id="__idx_3182"></a>We mentioned in section <a href="book-Z-H-20.html#__sec_3.1.3">3.1.3</a> the theoretical
 issues of “sameness” and “change” raised by the introduction of
 assignment.  These issues arise in practice when individual pairs are
 <em>shared</em> among different data objects.  For example, consider the
@@ -217,30 +217,30 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 
 </p><p></p><p><tt>(define x (list 'a 'b))<br />
 (define z1 (cons x x))<br /></tt></p><p></p><p>
-As shown in figure <a href="#%_fig_3.16">3.16</a>, <tt>z1</tt> is a pair whose <tt>car</tt> and <tt>cdr</tt> both point to the same pair <tt>x</tt>.  This sharing
+As shown in figure <a href="#__fig_3.16">3.16</a>, <tt>z1</tt> is a pair whose <tt>car</tt> and <tt>cdr</tt> both point to the same pair <tt>x</tt>.  This sharing
 of <tt>x</tt> by the <tt>car</tt> and <tt>cdr</tt> of <tt>z1</tt> is a consequence
 of the straightforward way in which <tt>cons</tt> is implemented.  In
 general, using <tt>cons</tt> to construct lists will result in an
 interlinked structure of pairs in which many individual pairs are
 shared by many different structures.</p><p>
 
-<a name="%_fig_3.16" id="%_fig_3.16"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-17.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.16:</b>  The list <tt>z1</tt> formed by <tt>(cons x x)</tt>.</div></caption><tr><td>
+<a id="__fig_3.16"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-17.gif" alt="ch3-Z-G-17" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.16:</b>  The list <tt>z1</tt> formed by <tt>(cons x x)</tt>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_fig_3.17" id="%_fig_3.17"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-18.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.17:</b>  The list <tt>z2</tt> formed by
+<a id="__fig_3.17"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-18.gif" alt="ch3-Z-G-18" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.17:</b>  The list <tt>z2</tt> formed by
 <tt>(cons (list 'a 'b) (list 'a 'b))</tt>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
 
-In contrast to figure <a href="#%_fig_3.16">3.16</a>, figure <a href="#%_fig_3.17">3.17</a> shows
+In contrast to figure <a href="#__fig_3.16">3.16</a>, figure <a href="#__fig_3.17">3.17</a> shows
 the structure created by</p><p>
 
 
 </p><p></p><p><tt>(define z2 (cons (list 'a 'b) (list 'a 'b)))<br /></tt></p><p></p><p>
 In this structure, the pairs in the two <tt>(a b)</tt> lists are
-distinct, although the actual symbols are shared.<a name="call_footnote_Temp_356" href="#footnote_Temp_356" id="call_footnote_Temp_356"><sup><small>19</small></sup></a></p><p>
+distinct, although the actual symbols are shared.<a href="#footnote_Temp_356" id="call_footnote_Temp_356"><sup><small>19</small></sup></a></p><p>
 
 When thought of as a list, <tt>z1</tt> and <tt>z2</tt> both represent “the
 same” list, <tt>((a b) a b)</tt>.  In general, sharing is completely
@@ -265,34 +265,34 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 (set-to-wow! z2)<br /><i>((wow b) a b)</i><br /></tt></p><p></p><p></p><p>
 
 One way to detect sharing in list structures is to use the predicate
-<a name="%_idx_3186" id="%_idx_3186"></a><a name="%_idx_3188" id="%_idx_3188"></a><tt>eq?</tt>, which we introduced in section <a href="book-Z-H-16.html#%_sec_2.3.1">2.3.1</a> as a
+<a id="__idx_3186"></a><a id="__idx_3188"></a><tt>eq?</tt>, which we introduced in section <a href="book-Z-H-16.html#__sec_2.3.1">2.3.1</a> as a
 way to test whether two symbols are equal.  More generally, <tt>(eq?
 x y)</tt> tests whether <tt>x</tt> and <tt>y</tt> are the same object (that is,
-whether <tt>x</tt> and <tt>y</tt> are equal as pointers).  Thus, with <tt>z1</tt> and <tt>z2</tt> as defined in figures <a href="#%_fig_3.16">3.16</a>
-and <a href="#%_fig_3.17">3.17</a>, <tt>(eq? (car z1) (cdr z1))</tt> is true and
+whether <tt>x</tt> and <tt>y</tt> are equal as pointers).  Thus, with <tt>z1</tt> and <tt>z2</tt> as defined in figures <a href="#__fig_3.16">3.16</a>
+and <a href="#__fig_3.17">3.17</a>, <tt>(eq? (car z1) (cdr z1))</tt> is true and
 <tt>(eq? (car z2) (cdr z2))</tt> is false.</p><p>
 
-<a name="%_idx_3190" id="%_idx_3190"></a>As will be seen in the following sections, we can exploit sharing to
+<a id="__idx_3190"></a>As will be seen in the following sections, we can exploit sharing to
 greatly extend the repertoire of data structures that can be
 represented by pairs.  On the other hand, sharing can also be
 dangerous, since modifications made to structures will also affect
 other structures that happen to share the modified parts.  The
 mutation operations <tt>set-car!</tt> and <tt>set-cdr!</tt> should be used
 with care; unless we have a good understanding of how our data objects
-are shared, mutation can have unanticipated results.<a name="call_footnote_Temp_357" href="#footnote_Temp_357" id="call_footnote_Temp_357"><sup><small>20</small></sup></a></p><p>
+are shared, mutation can have unanticipated results.<a href="#footnote_Temp_357" id="call_footnote_Temp_357"><sup><small>20</small></sup></a></p><p>
 
-</p><p><a name="%_thm_3.15" id="%_thm_3.15"></a>
+</p><p><a id="__thm_3.15"></a>
 <b>Exercise 3.15.</b>  Draw box-and-pointer diagrams to explain the effect of <tt>set-to-wow!</tt> on the structures <tt>z1</tt> and <tt>z2</tt> above.
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.16" id="%_thm_3.16"></a>
+</p><p><a id="__thm_3.16"></a>
 <b>Exercise 3.16.</b>  Ben Bitdiddle decides to write a procedure to count the number of
 pairs in any list structure.  “It's easy,” he reasons.  “The number
 of pairs in any structure is the number in the <tt>car</tt> plus the
 number in the <tt>cdr</tt> plus one more to count the current pair.”
 So Ben writes the following procedure:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3192" id="%_idx_3192"></a>(define (count-pairs x)<br />
+</p><p></p><p><tt><a id="__idx_3192"></a>(define (count-pairs x)<br />
   (if (not (pair? x))<br />
       0<br />
       (+ (count-pairs (car x))<br />
@@ -305,9 +305,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.17" id="%_thm_3.17"></a>
+</p><p><a id="__thm_3.17"></a>
 <b>Exercise 3.17.</b>  Devise a correct version of the <tt>count-pairs</tt> procedure of
-exercise <a href="#%_thm_3.16">3.16</a> that returns the number of distinct
+exercise <a href="#__thm_3.16">3.16</a> that returns the number of distinct
 pairs in any structure.  (Hint: Traverse the structure, maintaining an
 auxiliary data structure that is used to keep track of which pairs
 have already been counted.)
@@ -315,41 +315,41 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 
 </p><p>
 
-</p><p><a name="%_thm_3.18" id="%_thm_3.18"></a>
-<b>Exercise 3.18.</b>  <a name="%_idx_3194" id="%_idx_3194"></a>Write a procedure that examines a list and determines whether it
+</p><p><a id="__thm_3.18"></a>
+<b>Exercise 3.18.</b>  <a id="__idx_3194"></a>Write a procedure that examines a list and determines whether it
 contains a cycle, that is, whether a program that tried to find the
 end of the list by taking successive <tt>cdr</tt>s would go into an
-infinite loop.  Exercise <a href="#%_thm_3.13">3.13</a> constructed such lists.
+infinite loop.  Exercise <a href="#__thm_3.13">3.13</a> constructed such lists.
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.19" id="%_thm_3.19"></a>
-<b>Exercise 3.19.</b>  Redo exercise <a href="#%_thm_3.18">3.18</a> using an algorithm that takes only a
+</p><p><a id="__thm_3.19"></a>
+<b>Exercise 3.19.</b>  Redo exercise <a href="#__thm_3.18">3.18</a> using an algorithm that takes only a
 constant amount of space.  (This requires a very clever idea.)
 </p><p>
 
-<a name="%_sec_Temp_363" id="%_sec_Temp_363"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_363">Mutation is just assignment</a></h4><p>
+<a id="__sec_Temp_363"></a>
+</p><h4>Mutation is just assignment</h4><p>
 
-<a name="%_idx_3196" id="%_idx_3196"></a><a name="%_idx_3198" id="%_idx_3198"></a><a name="%_idx_3200" id="%_idx_3200"></a><a name="%_idx_3202" id="%_idx_3202"></a>
+<a id="__idx_3196"></a><a id="__idx_3198"></a><a id="__idx_3200"></a><a id="__idx_3202"></a>
 When we introduced compound data, we observed in
-section <a href="book-Z-H-14.html#%_sec_2.1.3">2.1.3</a> that pairs can be represented purely in terms
+section <a href="book-Z-H-14.html#__sec_2.1.3">2.1.3</a> that pairs can be represented purely in terms
 of procedures:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3204" id="%_idx_3204"></a>(define (cons x y)<br />
+</p><p></p><p><tt><a id="__idx_3204"></a>(define (cons x y)<br />
   (define (dispatch m)<br />
     (cond ((eq? m 'car) x)<br />
           ((eq? m 'cdr) y)<br />
           (else (error "Undefined operation -- CONS" m))))<br />
-  dispatch)<br /><a name="%_idx_3206" id="%_idx_3206"></a>(define (car z) (z 'car))<br /><a name="%_idx_3208" id="%_idx_3208"></a>(define (cdr z) (z 'cdr))<br /></tt></p><p></p><p>
+  dispatch)<br /><a id="__idx_3206"></a>(define (car z) (z 'car))<br /><a id="__idx_3208"></a>(define (cdr z) (z 'cdr))<br /></tt></p><p></p><p>
 The same observation is true for mutable data.  We can implement
 mutable data objects as procedures using assignment and local state.
 For instance, we can extend the above pair implementation to handle
 <tt>set-car!</tt> and <tt>set-cdr!</tt> in a manner analogous to the way
 we implemented bank accounts using <tt>make-account</tt> in
-section <a href="book-Z-H-20.html#%_sec_3.1.1">3.1.1</a>:</p><p>
+section <a href="book-Z-H-20.html#__sec_3.1.1">3.1.1</a>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3210" id="%_idx_3210"></a>(define (cons x y)<br />
+</p><p></p><p><tt><a id="__idx_3210"></a>(define (cons x y)<br />
   (define (set-x! v) (set! x v))<br />
   (define (set-y! v) (set! y v))<br />
   (define (dispatch m)<br />
@@ -358,18 +358,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
           ((eq? m 'set-car!) set-x!)<br />
           ((eq? m 'set-cdr!) set-y!)<br />
           (else (error "Undefined operation -- CONS" m))))<br />
-  dispatch)<br /><a name="%_idx_3212" id="%_idx_3212"></a>(define (car z) (z 'car))<br /><a name="%_idx_3214" id="%_idx_3214"></a>(define (cdr z) (z 'cdr))<br /><a name="%_idx_3216" id="%_idx_3216"></a>(define (set-car! z new-value)<br />
+  dispatch)<br /><a id="__idx_3212"></a>(define (car z) (z 'car))<br /><a id="__idx_3214"></a>(define (cdr z) (z 'cdr))<br /><a id="__idx_3216"></a>(define (set-car! z new-value)<br />
   ((z 'set-car!) new-value)<br />
-  z)<br /><a name="%_idx_3218" id="%_idx_3218"></a>(define (set-cdr! z new-value)<br />
+  z)<br /><a id="__idx_3218"></a>(define (set-cdr! z new-value)<br />
   ((z 'set-cdr!) new-value)<br />
   z)<br /></tt></p><p></p><p></p><p>
 
 Assignment is all that is needed, theoretically, to account for the
 behavior of mutable data.  As soon as we admit <tt>set!</tt> to our
 language, we raise all the issues, not only of assignment, but of
-mutable data in general.<a name="call_footnote_Temp_364" href="#footnote_Temp_364" id="call_footnote_Temp_364"><sup><small>21</small></sup></a></p><p>
+mutable data in general.<a href="#footnote_Temp_364" id="call_footnote_Temp_364"><sup><small>21</small></sup></a></p><p>
 
-</p><p><a name="%_thm_3.20" id="%_thm_3.20"></a>
+</p><p><a id="__thm_3.20"></a>
 <b>Exercise 3.20.</b>  Draw environment diagrams to illustrate the evaluation of the sequence
 of expressions</p><p>
 
@@ -378,46 +378,46 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 (set-car! (cdr z) 17)<br />
 (car x)<br /><i>17</i><br /></tt></p><p></p><p>
 using the procedural implementation of pairs given above.  (Compare
-exercise <a href="book-Z-H-21.html#%_thm_3.11">3.11</a>.)
+exercise <a href="book-Z-H-21.html#__thm_3.11">3.11</a>.)
 </p><p>
 
-<a name="%_sec_3.3.2" id="%_sec_3.3.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.3.2">3.3.2  Representing Queues</a></h3><p>
+<a id="__sec_3.3.2"></a>
+</p><h3>3.3.2  Representing Queues</h3><p>
 
 
-<a name="%_idx_3220" id="%_idx_3220"></a>
+<a id="__idx_3220"></a>
 The mutators <tt>set-car!</tt> and <tt>set-cdr!</tt> enable us to use
 pairs to construct data structures that cannot be built with <tt>cons</tt>, <tt>car</tt>, and <tt>cdr</tt> alone.  This section shows how to use
-pairs to represent a data structure called a queue.  Section <a href="#%_sec_3.3.3">3.3.3</a>
+pairs to represent a data structure called a queue.  Section <a href="#__sec_3.3.3">3.3.3</a>
 will show how to represent data structures called tables.</p><p>
 
 A <em>queue</em> is a sequence in which items are inserted at one end
-(called the <a name="%_idx_3222" id="%_idx_3222"></a><em>rear</em> of the queue) and deleted from the other end
-(the <a name="%_idx_3224" id="%_idx_3224"></a><em>front</em>).  Figure <a href="#%_fig_3.18">3.18</a> shows an initially empty
+(called the <a id="__idx_3222"></a><em>rear</em> of the queue) and deleted from the other end
+(the <a id="__idx_3224"></a><em>front</em>).  Figure <a href="#__fig_3.18">3.18</a> shows an initially empty
 queue in which the items <tt>a</tt> and <tt>b</tt> are inserted.  Then <tt>a</tt> is removed, <tt>c</tt> and <tt>d</tt> are inserted, and <tt>b</tt> is
 removed.  Because items are always removed in the order in which they
-are inserted, a queue is sometimes called a <a name="%_idx_3226" id="%_idx_3226"></a><em>FIFO</em> (first in,
+are inserted, a queue is sometimes called a <a id="__idx_3226"></a><em>FIFO</em> (first in,
 first out) buffer.</p><p>
 
-<a name="%_fig_3.18" id="%_fig_3.18"></a></p><p></p><div align="left"><table width="100%"><tr><td><table border="0"><tr><td valign="top">Operation </td><td valign="top">Resulting Queue  </td></tr><tr><td valign="top"><tt>(define q (make-queue))</tt> </td><td valign="top"></td></tr><tr><td valign="top"><tt>(insert-queue! q 'a)</tt> </td><td valign="top"><tt>a</tt></td></tr><tr><td valign="top"><tt>(insert-queue! q 'b)</tt> </td><td valign="top"><tt>a b</tt></td></tr><tr><td valign="top"><tt>(delete-queue! q)</tt> </td><td valign="top"><tt>b</tt></td></tr><tr><td valign="top"><tt>(insert-queue! q 'c)</tt> </td><td valign="top"><tt>b c</tt></td></tr><tr><td valign="top"><tt>(insert-queue! q 'd)</tt> </td><td valign="top"><tt>b c d</tt></td></tr><tr><td valign="top"><tt>(delete-queue! q)</tt> </td><td valign="top"><tt>c d</tt>
-</td></tr></table></td></tr><caption align="bottom"><div align="left"><b>Figure 3.18:</b>  Queue operations.</div></caption><tr><td>
+<a id="__fig_3.18"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><table style="border: none;"><tr><td style="text-align: top;">Operation </td><td style="text-align: top;">Resulting Queue  </td></tr><tr><td style="text-align: top;"><tt>(define q (make-queue))</tt> </td><td style="text-align: top;"></td></tr><tr><td style="text-align: top;"><tt>(insert-queue! q 'a)</tt> </td><td style="text-align: top;"><tt>a</tt></td></tr><tr><td style="text-align: top;"><tt>(insert-queue! q 'b)</tt> </td><td style="text-align: top;"><tt>a b</tt></td></tr><tr><td style="text-align: top;"><tt>(delete-queue! q)</tt> </td><td style="text-align: top;"><tt>b</tt></td></tr><tr><td style="text-align: top;"><tt>(insert-queue! q 'c)</tt> </td><td style="text-align: top;"><tt>b c</tt></td></tr><tr><td style="text-align: top;"><tt>(insert-queue! q 'd)</tt> </td><td style="text-align: top;"><tt>b c d</tt></td></tr><tr><td style="text-align: top;"><tt>(delete-queue! q)</tt> </td><td style="text-align: top;"><tt>c d</tt>
+</td></tr></table></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.18:</b>  Queue operations.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_idx_3228" id="%_idx_3228"></a><a name="%_idx_3230" id="%_idx_3230"></a>In terms of data abstraction, we can regard a queue as defined by the
+<a id="__idx_3228"></a><a id="__idx_3230"></a>In terms of data abstraction, we can regard a queue as defined by the
 following set of operations:
-</p><p></p><ul><li>a constructor:<br /><a name="%_idx_3232" id="%_idx_3232"></a><tt>(make-queue)</tt><br />
+</p><p></p><ul><li>a constructor:<br /><a id="__idx_3232"></a><tt>(make-queue)</tt><br />
 returns an empty queue (a queue containing no items).<p>
 
-</p></li><li>two selectors:<br /><a name="%_idx_3234" id="%_idx_3234"></a><tt>(empty-queue? &lt;<em>queue</em>&gt;)</tt><br />
-tests if the queue is empty.<br /><a name="%_idx_3236" id="%_idx_3236"></a><tt>(front-queue &lt;<em>queue</em>&gt;)</tt><br />
+</p></li><li>two selectors:<br /><a id="__idx_3234"></a><tt>(empty-queue? &lt;<em>queue</em>&gt;)</tt><br />
+tests if the queue is empty.<br /><a id="__idx_3236"></a><tt>(front-queue &lt;<em>queue</em>&gt;)</tt><br />
 returns the object at the front of
 the queue, signaling an error if the queue is empty; it does not
 modify the queue.<p>
 
-</p></li><li>two mutators:<br /><a name="%_idx_3238" id="%_idx_3238"></a><tt>(insert-queue! &lt;<em>queue</em>&gt; &lt;<em>item</em>&gt;)</tt><br />
+</p></li><li>two mutators:<br /><a id="__idx_3238"></a><tt>(insert-queue! &lt;<em>queue</em>&gt; &lt;<em>item</em>&gt;)</tt><br />
 inserts the item at the rear of the queue and returns the modified
-queue as its value.<br /><a name="%_idx_3240" id="%_idx_3240"></a><tt>(delete-queue! &lt;<em>queue</em>&gt;)</tt><br />
+queue as its value.<br /><a id="__idx_3240"></a><tt>(delete-queue! &lt;<em>queue</em>&gt;)</tt><br />
 removes the item at the
 front of the queue and returns the modified queue as its value,
 signaling an error if the queue is empty before the deletion.
@@ -452,10 +452,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 pairs in an ordinary list.  Since we would like the queue to be an
 identifiable object, we can use <tt>cons</tt> to combine the two
 pointers.  Thus, the queue itself will be the <tt>cons</tt> of the two
-pointers.  Figure <a href="#%_fig_3.19">3.19</a> illustrates this
+pointers.  Figure <a href="#__fig_3.19">3.19</a> illustrates this
 representation.</p><p>
 
-<a name="%_fig_3.19" id="%_fig_3.19"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-19.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.19:</b>  Implementation of a queue as a list with front and rear
+<a id="__fig_3.19"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-19.gif" alt="ch3-Z-G-19" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.19:</b>  Implementation of a queue as a list with front and rear
 pointers.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
@@ -464,43 +464,43 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 enable us to select and to modify the front and rear pointers of a
 queue:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3242" id="%_idx_3242"></a>(define (front-ptr queue) (car queue))<br /><a name="%_idx_3244" id="%_idx_3244"></a>(define (rear-ptr queue) (cdr queue))<br /><a name="%_idx_3246" id="%_idx_3246"></a>(define (set-front-ptr! queue item) (set-car! queue item))<br /><a name="%_idx_3248" id="%_idx_3248"></a>(define (set-rear-ptr! queue item) (set-cdr! queue item))<br /></tt></p><p></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_3242"></a>(define (front-ptr queue) (car queue))<br /><a id="__idx_3244"></a>(define (rear-ptr queue) (cdr queue))<br /><a id="__idx_3246"></a>(define (set-front-ptr! queue item) (set-car! queue item))<br /><a id="__idx_3248"></a>(define (set-rear-ptr! queue item) (set-cdr! queue item))<br /></tt></p><p></p><p></p><p>
 
 Now we can implement the actual queue operations.  We will consider a
 queue to be empty if its front pointer is the empty list:</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_3250" id="%_idx_3250"></a>(define (empty-queue? queue) (null? (front-ptr queue)))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_3250"></a>(define (empty-queue? queue) (null? (front-ptr queue)))<br /></tt></p><p></p><p>
 The <tt>make-queue</tt> constructor returns, as an initially empty queue,
 a pair whose <tt>car</tt> and <tt>cdr</tt> are both the empty list:</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_3252" id="%_idx_3252"></a>(define (make-queue) (cons '() '()))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_3252"></a>(define (make-queue) (cons '() '()))<br /></tt></p><p></p><p>
 To select the item at the front of the queue, we return the <tt>car</tt>
 of the pair indicated by the front pointer:</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_3254" id="%_idx_3254"></a>(define (front-queue queue)<br />
+</p><p></p><p><tt><a id="__idx_3254"></a>(define (front-queue queue)<br />
   (if (empty-queue? queue)<br />
       (error "FRONT called with an empty queue" queue)<br />
       (car (front-ptr queue))))<br /></tt></p><p></p><p></p><p>
 
 
 To insert an item in a queue, we follow the method whose result is
-indicated in figure <a href="#%_fig_3.20">3.20</a>.  We first create a new
+indicated in figure <a href="#__fig_3.20">3.20</a>.  We first create a new
 pair whose <tt>car</tt> is the item to be inserted and whose <tt>cdr</tt> is
 the empty list.  If the queue was initially empty, we set the front and
 rear pointers of the queue to this new pair.  Otherwise, we modify the
 final pair in the queue to point to the new pair, and also set the
 rear pointer to the new pair.</p><p>
 
-<a name="%_fig_3.20" id="%_fig_3.20"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-20.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.20:</b>  Result of using <tt>(insert-queue! q 'd)</tt>
-on the queue of figure <a href="#%_fig_3.19">3.19</a>.</div></caption><tr><td>
+<a id="__fig_3.20"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-20.gif" alt="ch3-Z-G-20" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.20:</b>  Result of using <tt>(insert-queue! q 'd)</tt>
+on the queue of figure <a href="#__fig_3.19">3.19</a>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_3256" id="%_idx_3256"></a>(define (insert-queue! queue item)<br />
+</p><p></p><p><tt><a id="__idx_3256"></a>(define (insert-queue! queue item)<br />
   (let ((new-pair (cons item '())))<br />
     (cond ((empty-queue? queue)<br />
            (set-front-ptr! queue new-pair)<br />
@@ -514,21 +514,21 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 To delete the item at the front of the queue, we merely modify the
 front pointer so that it now points at the second item in the queue,
 which can be found by following the <tt>cdr</tt> pointer of the first
-item (see figure <a href="#%_fig_3.21">3.21</a>):<a name="call_footnote_Temp_366" href="#footnote_Temp_366" id="call_footnote_Temp_366"><sup><small>22</small></sup></a></p><p>
+item (see figure <a href="#__fig_3.21">3.21</a>):<a href="#footnote_Temp_366" id="call_footnote_Temp_366"><sup><small>22</small></sup></a></p><p>
 
-<a name="%_fig_3.21" id="%_fig_3.21"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-21.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.21:</b>  Result of using <tt>(delete-queue! q)</tt> on
-the queue of figure <a href="#%_fig_3.20">3.20</a>.</div></caption><tr><td>
+<a id="__fig_3.21"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-21.gif" alt="ch3-Z-G-21" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.21:</b>  Result of using <tt>(delete-queue! q)</tt> on
+the queue of figure <a href="#__fig_3.20">3.20</a>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-</p><p></p><p><tt><a name="%_idx_3258" id="%_idx_3258"></a>(define (delete-queue! queue)<br />
+</p><p></p><p><tt><a id="__idx_3258"></a>(define (delete-queue! queue)<br />
   (cond ((empty-queue? queue)<br />
          (error "DELETE! called with an empty queue" queue))<br />
         (else<br />
          (set-front-ptr! queue (cdr (front-ptr queue)))<br />
          queue))) <br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_3.21" id="%_thm_3.21"></a>
+</p><p><a id="__thm_3.21"></a>
 <b>Exercise 3.21.</b>  Ben Bitdiddle decides to test the queue implementation described
 above.  He types in the procedures to the Lisp interpreter and
 proceeds to try them out:</p><p>
@@ -548,12 +548,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 queue representation.  If you want to see the queue printed correctly,
 you'll have to define your own print procedure for queues.” Explain
 what Eva Lu is talking about.  In particular, show why Ben's examples
-produce the printed results that they do.  Define a procedure <a name="%_idx_3260" id="%_idx_3260"></a><tt>print-queue</tt> that takes a queue as input and prints the sequence of
+produce the printed results that they do.  Define a procedure <a id="__idx_3260"></a><tt>print-queue</tt> that takes a queue as input and prints the sequence of
 items in the queue.
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.22" id="%_thm_3.22"></a>
-<b>Exercise 3.22.</b>  <a name="%_idx_3262" id="%_idx_3262"></a>Instead of representing a queue as a pair of pointers, we can build a
+</p><p><a id="__thm_3.22"></a>
+<b>Exercise 3.22.</b>  <a id="__idx_3262"></a>Instead of representing a queue as a pair of pointers, we can build a
 queue as a procedure with local state.  The local state will consist
 of pointers to the beginning and the end of an ordinary list.  Thus,
 the <tt>make-queue</tt> procedure will have the form</p><p>
@@ -568,45 +568,45 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 implementations of the queue operations using this representation.
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.23" id="%_thm_3.23"></a>
-<b>Exercise 3.23.</b>  <a name="%_idx_3264" id="%_idx_3264"></a><a name="%_idx_3266" id="%_idx_3266"></a>A <em>deque</em> (“double-ended queue”) is a sequence in which items
+</p><p><a id="__thm_3.23"></a>
+<b>Exercise 3.23.</b>  <a id="__idx_3264"></a><a id="__idx_3266"></a>A <em>deque</em> (“double-ended queue”) is a sequence in which items
 can be inserted and deleted at either the front or the rear.
 Operations on deques are the constructor <tt>make-deque</tt>, the predicate <tt>empty-deque?</tt>, selectors <tt>front-deque</tt> and <tt>rear-deque</tt>, and mutators <tt>front-insert-deque!</tt>, <tt>rear-insert-deque!</tt>, <tt>front-delete-deque!</tt>, and <tt>rear-delete-deque!</tt>.  Show how to represent deques using pairs, and
-give implementations of the operations.<a name="call_footnote_Temp_370" href="#footnote_Temp_370" id="call_footnote_Temp_370"><sup><small>23</small></sup></a>
+give implementations of the operations.<a href="#footnote_Temp_370" id="call_footnote_Temp_370"><sup><small>23</small></sup></a>
 All operations should be accomplished in θ(1) steps.
 </p><p>
 
-<a name="%_sec_3.3.3" id="%_sec_3.3.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.3.3">3.3.3  Representing Tables</a></h3><p>
+<a id="__sec_3.3.3"></a>
+</p><h3>3.3.3  Representing Tables</h3><p>
 
 
-<a name="%_idx_3268" id="%_idx_3268"></a>
-<a name="%_idx_3270" id="%_idx_3270"></a>When we studied various ways of representing sets in chapter 2, we
-mentioned in section <a href="book-Z-H-16.html#%_sec_2.3.3">2.3.3</a> the task of
+<a id="__idx_3268"></a>
+<a id="__idx_3270"></a>When we studied various ways of representing sets in chapter 2, we
+mentioned in section <a href="book-Z-H-16.html#__sec_2.3.3">2.3.3</a> the task of
 maintaining a table of records indexed by identifying keys.  In the
 implementation of data-directed programming in
-section <a href="book-Z-H-17.html#%_sec_2.4.3">2.4.3</a>, we made extensive use of
+section <a href="book-Z-H-17.html#__sec_2.4.3">2.4.3</a>, we made extensive use of
 two-dimensional tables, in which information is stored and retrieved
 using two keys.  Here we see how to build tables as mutable list
 structures.</p><p>
 
-<a name="%_idx_3272" id="%_idx_3272"></a>We first consider a one-dimensional table, in which each value is
+<a id="__idx_3272"></a>We first consider a one-dimensional table, in which each value is
 stored under a single key.  We implement the table as a list of
 records, each of which is implemented as a pair consisting of a key
 and the associated value. The records are glued together to form a
 list by pairs whose <tt>car</tt>s point to successive records.  These
-gluing pairs are called the <a name="%_idx_3274" id="%_idx_3274"></a><em>backbone</em> of the table.  In order to
+gluing pairs are called the <a id="__idx_3274"></a><em>backbone</em> of the table.  In order to
 have a place that we can change when we add a new record to the table,
-we build the table as a <a name="%_idx_3276" id="%_idx_3276"></a><a name="%_idx_3278" id="%_idx_3278"></a><em>headed list</em>.  A headed list has a
+we build the table as a <a id="__idx_3276"></a><a id="__idx_3278"></a><em>headed list</em>.  A headed list has a
 special backbone pair at the beginning, which holds a dummy
 “record” – in this case the arbitrarily chosen symbol <tt>*table*</tt>.
-Figure <a href="#%_fig_3.22">3.22</a> shows the box-and-pointer diagram for the table</p><p>
+Figure <a href="#__fig_3.22">3.22</a> shows the box-and-pointer diagram for the table</p><p>
 
 </p><p></p><p><tt>a:  1<br />
 b:  2<br />
 c:  3<br /></tt></p><p></p><p></p><p>
 
-<a name="%_fig_3.22" id="%_fig_3.22"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-22.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.22:</b>  A table represented as a headed list.</div></caption><tr><td>
+<a id="__fig_3.22"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-22.gif" alt="ch3-Z-G-22" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.22:</b>  A table represented as a headed list.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
@@ -615,16 +615,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 value (or false if there is no value stored under that key).
 <tt>Lookup</tt> is defined in terms of the <tt>assoc</tt> operation, which
 expects a key and a list of records as arguments.  Note that <tt>assoc</tt> never sees the dummy record.  <tt>Assoc</tt> returns the record
-that has the given key as its <tt>car</tt>.<a name="call_footnote_Temp_371" href="#footnote_Temp_371" id="call_footnote_Temp_371"><sup><small>24</small></sup></a>
+that has the given key as its <tt>car</tt>.<a href="#footnote_Temp_371" id="call_footnote_Temp_371"><sup><small>24</small></sup></a>
 <tt>Lookup</tt> then
 checks to see that the resulting record returned by <tt>assoc</tt> is not
 false, and returns the value (the <tt>cdr</tt>) of the record.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3280" id="%_idx_3280"></a>(define (lookup key table)<br />
+</p><p></p><p><tt><a id="__idx_3280"></a>(define (lookup key table)<br />
   (let ((record (assoc key (cdr table))))<br />
     (if record<br />
         (cdr record)<br />
-        false)))<br /><a name="%_idx_3282" id="%_idx_3282"></a>(define (assoc key records)<br />
+        false)))<br /><a id="__idx_3282"></a>(define (assoc key records)<br />
   (cond ((null? records) false)<br />
         ((equal? key (caar records)) (car records))<br />
         (else (assoc key (cdr records)))))<br /></tt></p><p></p><p></p><p>
@@ -635,9 +635,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 dummy record.  If there already is a record with this key, we set the
 <tt>cdr</tt> of this record to the designated new value.  The header of
 the table provides us with a fixed location to modify in order to
-insert the new record.<a name="call_footnote_Temp_372" href="#footnote_Temp_372" id="call_footnote_Temp_372"><sup><small>25</small></sup></a></p><p>
+insert the new record.<a href="#footnote_Temp_372" id="call_footnote_Temp_372"><sup><small>25</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_3284" id="%_idx_3284"></a>(define (insert! key value table)<br />
+</p><p></p><p><tt><a id="__idx_3284"></a>(define (insert! key value table)<br />
   (let ((record (assoc key (cdr table))))<br />
     (if record<br />
         (set-cdr! record value)<br />
@@ -648,17 +648,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 To construct a new table, we simply create a list containing the
 symbol <tt>*table*</tt>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3286" id="%_idx_3286"></a>(define (make-table)<br />
+</p><p></p><p><tt><a id="__idx_3286"></a>(define (make-table)<br />
   (list '*table*))<br /></tt></p><p></p><p>
 
-<a name="%_sec_Temp_373" id="%_sec_Temp_373"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_373">Two-dimensional tables</a></h4><p>
+<a id="__sec_Temp_373"></a>
+</p><h4>Two-dimensional tables</h4><p>
 
-<a name="%_idx_3288" id="%_idx_3288"></a>
+<a id="__idx_3288"></a>
 In a two-dimensional table, each value is indexed by two keys.  We can
 construct such a table as a one-dimensional table in which each key
 identifies a subtable.
-Figure <a href="#%_fig_3.23">3.23</a> shows the box-and-pointer diagram for the table
+Figure <a href="#__fig_3.23">3.23</a> shows the box-and-pointer diagram for the table
 </p><p></p><p><tt>math:<br />
     +:  43<br />
     -:  45<br />
@@ -670,7 +670,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 special header symbol, since the key that identifies the subtable
 serves this purpose.)</p><p>
 
-<a name="%_fig_3.23" id="%_fig_3.23"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-23.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.23:</b>  A two-dimensional table.</div></caption><tr><td>
+<a id="__fig_3.23"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-23.gif" alt="ch3-Z-G-23" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.23:</b>  A two-dimensional table.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
@@ -678,7 +678,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 to identify the correct subtable.  Then we use the second key to
 identify the record within the subtable.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3290" id="%_idx_3290"></a>(define (lookup key-1 key-2 table)<br />
+</p><p></p><p><tt><a id="__idx_3290"></a>(define (lookup key-1 key-2 table)<br />
   (let ((subtable (assoc key-1 (cdr table))))<br />
     (if subtable<br />
         (let ((record (assoc key-2 (cdr subtable))))<br />
@@ -695,7 +695,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 subtable, using the insertion method for one-dimensional tables
 described above:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3292" id="%_idx_3292"></a>(define (insert! key-1 key-2 value table)<br />
+</p><p></p><p><tt><a id="__idx_3292"></a>(define (insert! key-1 key-2 value table)<br />
   (let ((subtable (assoc key-1 (cdr table))))<br />
     (if subtable<br />
         (let ((record (assoc key-2 (cdr subtable))))<br />
@@ -710,10 +710,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
                         (cdr table)))))<br />
   'ok)<br /></tt></p><p></p><p>
 
-<a name="%_sec_Temp_374" id="%_sec_Temp_374"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_374">Creating local tables</a></h4><p>
+<a id="__sec_Temp_374"></a>
+</p><h4>Creating local tables</h4><p>
 
-<a name="%_idx_3294" id="%_idx_3294"></a>
+<a id="__idx_3294"></a>
 The <tt>lookup</tt> and <tt>insert!</tt> operations defined above take the
 table as an argument.  This enables us to use programs that access
 more than one table.  Another way to deal with multiple tables is to
@@ -724,7 +724,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 procedure with which to operate on the internal table.  Here is a
 generator for two-dimensional tables represented in this fashion:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3296" id="%_idx_3296"></a>(define (make-table)<br />
+</p><p></p><p><tt><a id="__idx_3296"></a>(define (make-table)<br />
   (let ((local-table (list '*table*)))<br />
     (define (lookup key-1 key-2)<br />
       (let ((subtable (assoc key-1 (cdr local-table))))<br />
@@ -755,18 +755,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
     dispatch))<br /></tt></p><p></p><p></p><p>
 
 Using <tt>make-table</tt>, we could implement the <tt>get</tt> and <tt>put</tt>
-operations used in section <a href="book-Z-H-17.html#%_sec_2.4.3">2.4.3</a> for data-directed
+operations used in section <a href="book-Z-H-17.html#__sec_2.4.3">2.4.3</a> for data-directed
 programming, as follows:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3298" id="%_idx_3298"></a>(define operation-table (make-table))<br /><a name="%_idx_3300" id="%_idx_3300"></a>(define get (operation-table 'lookup-proc))<br /><a name="%_idx_3302" id="%_idx_3302"></a>(define put (operation-table 'insert-proc!))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_3298"></a>(define operation-table (make-table))<br /><a id="__idx_3300"></a>(define get (operation-table 'lookup-proc))<br /><a id="__idx_3302"></a>(define put (operation-table 'insert-proc!))<br /></tt></p><p></p><p>
 <tt>Get</tt> takes as arguments two keys, and <tt>put</tt> takes
 as arguments two keys and a value.  Both operations access the same
 local table, which is encapsulated within the object created by the
 call to <tt>make-table</tt>.
 
 
-</p><p><a name="%_thm_3.24" id="%_thm_3.24"></a>
-<b>Exercise 3.24.</b>  <a name="%_idx_3304" id="%_idx_3304"></a><a name="%_idx_3306" id="%_idx_3306"></a>In the table implementations above, the keys are tested for equality
+</p><p><a id="__thm_3.24"></a>
+<b>Exercise 3.24.</b>  <a id="__idx_3304"></a><a id="__idx_3306"></a>In the table implementations above, the keys are tested for equality
 using <tt>equal?</tt> (called by <tt>assoc</tt>).  This is not always the appropriate test.  For
 instance, we might have a table with numeric keys in which we don't
 need an exact match to the number we're looking up,
@@ -779,28 +779,28 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.25" id="%_thm_3.25"></a>
-<b>Exercise 3.25.</b>  <a name="%_idx_3308" id="%_idx_3308"></a>Generalizing one- and two-dimensional tables, show how to implement a
+</p><p><a id="__thm_3.25"></a>
+<b>Exercise 3.25.</b>  <a id="__idx_3308"></a>Generalizing one- and two-dimensional tables, show how to implement a
 table in which values are stored under an arbitrary number of keys and
 different values may be stored under different numbers of keys.  The
 <tt>lookup</tt> and <tt>insert!</tt> procedures should take as input a list
 of keys used to access the table.
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.26" id="%_thm_3.26"></a>
-<b>Exercise 3.26.</b>  <a name="%_idx_3310" id="%_idx_3310"></a><a name="%_idx_3312" id="%_idx_3312"></a>To search a table as implemented above, one needs to scan through the
+</p><p><a id="__thm_3.26"></a>
+<b>Exercise 3.26.</b>  <a id="__idx_3310"></a><a id="__idx_3312"></a>To search a table as implemented above, one needs to scan through the
 list of records.  This is basically the unordered list representation of
-section <a href="book-Z-H-16.html#%_sec_2.3.3">2.3.3</a>.  For large tables, it may be more
+section <a href="book-Z-H-16.html#__sec_2.3.3">2.3.3</a>.  For large tables, it may be more
 efficient to structure the table in a different manner.  Describe a
 table implementation where the (key, value) records are organized
 using a binary tree, assuming that keys can be ordered in some way
 (e.g., numerically or alphabetically).  (Compare
-exercise <a href="book-Z-H-16.html#%_thm_2.66">2.66</a> of chapter 2.)
+exercise <a href="book-Z-H-16.html#__thm_2.66">2.66</a> of chapter 2.)
 </p><p></p><p>
 
 
-</p><p><a name="%_thm_3.27" id="%_thm_3.27"></a>
-<b>Exercise 3.27.</b>  <a name="%_idx_3314" id="%_idx_3314"></a><a name="%_idx_3316" id="%_idx_3316"></a><a name="%_idx_3318" id="%_idx_3318"></a><a name="%_idx_3320" id="%_idx_3320"></a><em>Memoization</em> (also called <em>tabulation</em>) is a technique that
+</p><p><a id="__thm_3.27"></a>
+<b>Exercise 3.27.</b>  <a id="__idx_3314"></a><a id="__idx_3316"></a><a id="__idx_3318"></a><a id="__idx_3320"></a><em>Memoization</em> (also called <em>tabulation</em>) is a technique that
 enables a procedure to record, in a local table, values that have
 previously been computed.  This technique can make a vast difference
 in the performance of a program.  A memoized procedure maintains a
@@ -810,11 +810,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 table to see if the value is already there and, if so, just returns
 that value.  Otherwise, it computes the new value in the ordinary way
 and stores this in the table.  As an example of memoization, recall
-from section <a href="book-Z-H-11.html#%_sec_1.2.2">1.2.2</a> the exponential process for
+from section <a href="book-Z-H-11.html#__sec_1.2.2">1.2.2</a> the exponential process for
 computing Fibonacci numbers:</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_3322" id="%_idx_3322"></a>(define (fib n)<br />
+</p><p></p><p><tt><a id="__idx_3322"></a>(define (fib n)<br />
   (cond ((= n 0) 0)<br />
         ((= n 1) 1)<br />
         (else (+ (fib (- n 1))<br />
@@ -822,14 +822,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 The memoized version of the same procedure is</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_3324" id="%_idx_3324"></a>(define memo-fib<br />
+</p><p></p><p><tt><a id="__idx_3324"></a>(define memo-fib<br />
   (memoize (lambda (n)<br />
              (cond ((= n 0) 0)<br />
                    ((= n 1) 1)<br />
                    (else (+ (memo-fib (- n 1))<br />
                             (memo-fib (- n 2))))))))<br /></tt></p><p></p><p>
 where the memoizer is defined as
-</p><p></p><p><tt><a name="%_idx_3326" id="%_idx_3326"></a>(define (memoize f)<br />
+</p><p></p><p><tt><a id="__idx_3326"></a>(define (memoize f)<br />
   (let ((table (make-table)))<br />
     (lambda (x)<br />
       (let ((previously-computed-result (lookup x table)))<br />
@@ -845,11 +845,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 
 </p><p>
 
-<a name="%_sec_3.3.4" id="%_sec_3.3.4"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.3.4">3.3.4  A Simulator for Digital Circuits</a></h3><p>
+<a id="__sec_3.3.4"></a>
+</p><h3>3.3.4  A Simulator for Digital Circuits</h3><p>
 
 
-<a name="%_idx_3328" id="%_idx_3328"></a>
+<a id="__idx_3328"></a>
 Designing complex digital systems, such as computers, is an important
 engineering activity.  Digital systems are constructed by
 interconnecting simple elements.  Although the behavior of these
@@ -857,44 +857,44 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 behavior.  Computer simulation of proposed circuit designs is an
 important tool used by digital systems engineers.  In this section we
 design a system for performing digital logic simulations.  This system
-typifies a kind of program called an <a name="%_idx_3330" id="%_idx_3330"></a><a name="%_idx_3332" id="%_idx_3332"></a><em>event-driven simulation</em>, in
+typifies a kind of program called an <a id="__idx_3330"></a><a id="__idx_3332"></a><em>event-driven simulation</em>, in
 which actions (“events”) trigger further events that happen at a
 later time, which in turn trigger more events, and so so.</p><p>
 
 
 Our computational model of a circuit will be composed of objects that
 correspond to the elementary components from which the circuit is
-constructed.  There are <a name="%_idx_3334" id="%_idx_3334"></a><em>wires</em>, which carry <a name="%_idx_3336" id="%_idx_3336"></a><a name="%_idx_3338" id="%_idx_3338"></a><em>digital signals</em>.  A
+constructed.  There are <a id="__idx_3334"></a><em>wires</em>, which carry <a id="__idx_3336"></a><a id="__idx_3338"></a><em>digital signals</em>.  A
 digital signal may at any moment have only one of two possible values,
-0 and 1.  There are also various types of digital <a name="%_idx_3340" id="%_idx_3340"></a><em>function
+0 and 1.  There are also various types of digital <a id="__idx_3340"></a><em>function
 boxes</em>, which connect wires carrying input signals to other output
 wires.  Such boxes produce output signals computed from their input
-signals.  The output signal is <a name="%_idx_3342" id="%_idx_3342"></a>delayed by a time that depends on the
-type of the function box.  For example, an <a name="%_idx_3344" id="%_idx_3344"></a><em>inverter</em> is a
+signals.  The output signal is <a id="__idx_3342"></a>delayed by a time that depends on the
+type of the function box.  For example, an <a id="__idx_3344"></a><em>inverter</em> is a
 primitive function box that inverts its input.  If the
 input signal to an inverter changes to 0, then one inverter-delay
 later the inverter will change its output signal to 1.  If the input
 signal to an inverter changes to 1, then one inverter-delay later the
 inverter will change its output signal to 0.  We draw an inverter
-symbolically as in figure <a href="#%_fig_3.24">3.24</a>.  An <a name="%_idx_3346" id="%_idx_3346"></a><em>and-gate</em>,
-also shown in figure <a href="#%_fig_3.24">3.24</a>, is a primitive function
+symbolically as in figure <a href="#__fig_3.24">3.24</a>.  An <a id="__idx_3346"></a><em>and-gate</em>,
+also shown in figure <a href="#__fig_3.24">3.24</a>, is a primitive function
 box with two inputs and one output.  It drives its output signal to a
-value that is the <a name="%_idx_3348" id="%_idx_3348"></a><em>logical and</em> of the inputs.  That is, if both
+value that is the <a id="__idx_3348"></a><em>logical and</em> of the inputs.  That is, if both
 of its input signals become 1, then one and-gate-delay time later the
 and-gate will force its output signal to be 1; otherwise the output
-will be 0.  An <a name="%_idx_3350" id="%_idx_3350"></a><em>or-gate</em> is a similar two-input primitive function
-box that drives its output signal to a value that is the <a name="%_idx_3352" id="%_idx_3352"></a><em>logical
+will be 0.  An <a id="__idx_3350"></a><em>or-gate</em> is a similar two-input primitive function
+box that drives its output signal to a value that is the <a id="__idx_3352"></a><em>logical
 or</em> of the inputs.  That is, the output will become 1 if at least one
 of the input signals is 1; otherwise the output will become 0.</p><p>
 
-<a name="%_fig_3.24" id="%_fig_3.24"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-24.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.24:</b>  Primitive functions in the digital logic simulator.</div></caption><tr><td>
+<a id="__fig_3.24"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-24.gif" alt="ch3-Z-G-24" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.24:</b>  Primitive functions in the digital logic simulator.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
 We can connect primitive functions together to construct more complex
 functions.  To accomplish this we wire the outputs of some
 function boxes to the inputs of other function boxes.  For example,
-the <a name="%_idx_3354" id="%_idx_3354"></a><a name="%_idx_3356" id="%_idx_3356"></a><em>half-adder</em> circuit shown in figure <a href="#%_fig_3.25">3.25</a> consists of an
+the <a id="__idx_3354"></a><a id="__idx_3356"></a><em>half-adder</em> circuit shown in figure <a href="#__fig_3.25">3.25</a> consists of an
 or-gate, two and-gates, and an inverter.  It takes two input signals,
 A and B, and has two output signals, S and C.  S will become 1
 whenever precisely one of A and B is 1, and C will become 1 whenever A
@@ -903,7 +903,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 Many of the difficulties in the design of digital circuits arise from
 this fact.</p><p>
 
-<a name="%_fig_3.25" id="%_fig_3.25"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-25.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.25:</b>  A half-adder circuit.</div></caption><tr><td>
+<a id="__fig_3.25"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-25.gif" alt="ch3-Z-G-25" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.25:</b>  A half-adder circuit.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
@@ -913,7 +913,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 will be modeled by procedures that enforce the correct relationships
 among the signals.</p><p>
 
-<a name="%_idx_3358" id="%_idx_3358"></a>One basic element of our simulation will be a procedure <tt>make-wire</tt>, which constructs wires.  For example, we can construct six
+<a id="__idx_3358"></a>One basic element of our simulation will be a procedure <tt>make-wire</tt>, which constructs wires.  For example, we can construct six
 wires as follows:</p><p>
 
 </p><p></p><p><tt>(define a (make-wire))<br />
@@ -926,7 +926,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 constructs that kind of box.  The arguments to the constructor
 procedure are the wires to be attached to the box.  For example, given
 that we can construct and-gates, or-gates, and inverters, we can wire
-together the half-adder shown in figure <a href="#%_fig_3.25">3.25</a>:</p><p>
+together the half-adder shown in figure <a href="#__fig_3.25">3.25</a>:</p><p>
 
 </p><p></p><p><tt>(or-gate a b d)<br /><i>ok</i><br /><br />
 (and-gate a b c)<br /><i>ok</i><br /><br />
@@ -936,7 +936,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 Better yet, we can explicitly name this operation by defining a procedure <tt>half-adder</tt> that constructs this circuit, given the four
 external wires to be attached to the half-adder:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3360" id="%_idx_3360"></a>(define (half-adder a b s c)<br />
+</p><p></p><p><tt><a id="__idx_3360"></a>(define (half-adder a b s c)<br />
   (let ((d (make-wire)) (e (make-wire)))<br />
     (or-gate a b d)<br />
     (and-gate a b c)<br />
@@ -945,10 +945,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
     'ok))<br /></tt></p><p></p><p>
 The advantage of making this definition is that we can use
 <tt>half-adder</tt> itself as a building block in creating more complex
-circuits.  Figure <a href="#%_fig_3.26">3.26</a>, for example, shows a <a name="%_idx_3362" id="%_idx_3362"></a><a name="%_idx_3364" id="%_idx_3364"></a><em>full-adder</em> composed of two half-adders and an or-gate.<a name="call_footnote_Temp_379" href="#footnote_Temp_379" id="call_footnote_Temp_379"><sup><small>26</small></sup></a> We can construct a full-adder
+circuits.  Figure <a href="#__fig_3.26">3.26</a>, for example, shows a <a id="__idx_3362"></a><a id="__idx_3364"></a><em>full-adder</em> composed of two half-adders and an or-gate.<a href="#footnote_Temp_379" id="call_footnote_Temp_379"><sup><small>26</small></sup></a> We can construct a full-adder
 as follows:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3366" id="%_idx_3366"></a>(define (full-adder a b c-in sum c-out)<br />
+</p><p></p><p><tt><a id="__idx_3366"></a>(define (full-adder a b c-in sum c-out)<br />
   (let ((s (make-wire))<br />
         (c1 (make-wire))<br />
         (c2 (make-wire)))<br />
@@ -958,40 +958,40 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
     'ok))<br /></tt></p><p></p><p>
 Having defined <tt>full-adder</tt> as a procedure, we can now use it as a
 building block for creating still more complex circuits.  (For
-example, see exercise <a href="#%_thm_3.30">3.30</a>.)</p><p>
+example, see exercise <a href="#__thm_3.30">3.30</a>.)</p><p>
 
-<a name="%_fig_3.26" id="%_fig_3.26"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-26.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.26:</b>  A full-adder circuit.</div></caption><tr><td>
+<a id="__fig_3.26"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-26.gif" alt="ch3-Z-G-26" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.26:</b>  A full-adder circuit.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
 In essence, our simulator provides us with the tools to construct a
 language of circuits.  If we adopt the general perspective on
 languages with which we approached the study of Lisp in
-section <a href="book-Z-H-10.html#%_sec_1.1">1.1</a>,
+section <a href="book-Z-H-10.html#__sec_1.1">1.1</a>,
 we can say that the primitive function boxes form the primitive
 elements of the language, that wiring boxes together provides a means
 of combination, and that specifying wiring patterns as procedures
 serves as a means of abstraction.</p><p>
 
-<a name="%_sec_Temp_380" id="%_sec_Temp_380"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_380">Primitive function boxes</a></h4><p>
+<a id="__sec_Temp_380"></a>
+</p><h4>Primitive function boxes</h4><p>
 
-<a name="%_idx_3368" id="%_idx_3368"></a>
+<a id="__idx_3368"></a>
 The primitive function boxes implement the “forces” by which a
 change in the signal on one wire influences the signals on other
 wires.  To build function boxes, we use the following operations on
 wires:</p><p>
 
-</p><p></p><ul><li><tt>(get-signal &lt;<em>wire</em>&gt;)</tt><br /><a name="%_idx_3370" id="%_idx_3370"></a>returns the current value of the signal on the wire.<p>
+</p><p></p><ul><li><tt>(get-signal &lt;<em>wire</em>&gt;)</tt><br /><a id="__idx_3370"></a>returns the current value of the signal on the wire.<p>
 
-</p></li><li><tt>(set-signal! &lt;<em>wire</em>&gt; &lt;<em>new value</em>&gt;)</tt><br /><a name="%_idx_3372" id="%_idx_3372"></a>changes the value of the signal on the wire to the new value.<p>
+</p></li><li><tt>(set-signal! &lt;<em>wire</em>&gt; &lt;<em>new value</em>&gt;)</tt><br /><a id="__idx_3372"></a>changes the value of the signal on the wire to the new value.<p>
 
-</p></li><li><tt>(add-action! &lt;<em>wire</em>&gt; &lt;<em>procedure of no arguments</em>&gt;)</tt><br /><a name="%_idx_3374" id="%_idx_3374"></a>asserts that the designated procedure should be run whenever the
+</p></li><li><tt>(add-action! &lt;<em>wire</em>&gt; &lt;<em>procedure of no arguments</em>&gt;)</tt><br /><a id="__idx_3374"></a>asserts that the designated procedure should be run whenever the
 signal on the wire changes value.  Such procedures are the vehicles by
 which changes in the signal value on the wire are communicated to
 other wires.
 </li></ul><p>
-<a name="%_idx_3376" id="%_idx_3376"></a>In addition, we will make use of a procedure <tt>after-delay</tt> that
+<a id="__idx_3376"></a>In addition, we will make use of a procedure <tt>after-delay</tt> that
 takes a time delay and a procedure to be run and executes the
 given procedure after the given delay.</p><p>
 
@@ -1003,14 +1003,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 then, after one <tt>inverter-delay</tt>, sets the output signal to be
 this new value:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3378" id="%_idx_3378"></a>(define (inverter input output)<br />
+</p><p></p><p><tt><a id="__idx_3378"></a>(define (inverter input output)<br />
   (define (invert-input)<br />
     (let ((new-value (logical-not (get-signal input))))<br />
       (after-delay inverter-delay<br />
                    (lambda ()<br />
                      (set-signal! output new-value)))))<br />
   (add-action! input invert-input)<br />
-  'ok)<br /><a name="%_idx_3380" id="%_idx_3380"></a>(define (logical-not s)<br />
+  'ok)<br /><a id="__idx_3380"></a>(define (logical-not s)<br />
   (cond ((= s 0) 1)<br />
         ((= s 1) 0)<br />
         (else (error "Invalid signal" s))))<br /></tt></p><p></p><p></p><p>
@@ -1020,7 +1020,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 values of the signals on the input wires and sets up a change to the
 new value to occur on the output wire after one <tt>and-gate-delay</tt>.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3382" id="%_idx_3382"></a>(define (and-gate a1 a2 output)<br />
+</p><p></p><p><tt><a id="__idx_3382"></a>(define (and-gate a1 a2 output)<br />
   (define (and-action-procedure)<br />
     (let ((new-value<br />
            (logical-and (get-signal a1) (get-signal a2))))<br />
@@ -1031,19 +1031,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
   (add-action! a2 and-action-procedure)<br />
   'ok)<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_3.28" id="%_thm_3.28"></a>
-<b>Exercise 3.28.</b>  <a name="%_idx_3384" id="%_idx_3384"></a>Define an or-gate as a primitive function box.  Your <tt>or-gate</tt>
+</p><p><a id="__thm_3.28"></a>
+<b>Exercise 3.28.</b>  <a id="__idx_3384"></a>Define an or-gate as a primitive function box.  Your <tt>or-gate</tt>
 constructor should be similar to <tt>and-gate</tt>.
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.29" id="%_thm_3.29"></a>
-<b>Exercise 3.29.</b>  <a name="%_idx_3386" id="%_idx_3386"></a>Another way to construct an or-gate is as a compound digital logic
+</p><p><a id="__thm_3.29"></a>
+<b>Exercise 3.29.</b>  <a id="__idx_3386"></a>Another way to construct an or-gate is as a compound digital logic
 device, built from and-gates and inverters.  Define a procedure <tt>or-gate</tt> that accomplishes this.  What is the delay time of the
 or-gate in terms of <tt>and-gate-delay</tt> and <tt>inverter-delay</tt>?
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.30" id="%_thm_3.30"></a>
-<b>Exercise 3.30.</b>  Figure <a href="#%_fig_3.27">3.27</a> shows a <a name="%_idx_3388" id="%_idx_3388"></a><a name="%_idx_3390" id="%_idx_3390"></a><em>ripple-carry adder</em> formed by stringing
+</p><p><a id="__thm_3.30"></a>
+<b>Exercise 3.30.</b>  Figure <a href="#__fig_3.27">3.27</a> shows a <a id="__idx_3388"></a><a id="__idx_3390"></a><em>ripple-carry adder</em> formed by stringing
 together <em>n</em> full-adders.  This is the simplest form of parallel adder
 for adding two <em>n</em>-bit binary numbers.  The inputs A<sub>1</sub>, A<sub>2</sub>,
 A<sub>3</sub>, <tt>...</tt>, A<sub><em>n</em></sub> and B<sub>1</sub>, B<sub>2</sub>, B<sub>3</sub>, <tt>...</tt>,
@@ -1061,24 +1061,24 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 
 </p><p></p><p>
 
-<a name="%_fig_3.27" id="%_fig_3.27"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-27.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.27:</b>  A ripple-carry adder for <em>n</em>-bit numbers.</div></caption><tr><td>
+<a id="__fig_3.27"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-27.gif" alt="ch3-Z-G-27" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.27:</b>  A ripple-carry adder for <em>n</em>-bit numbers.</div></caption><tr><td>
 
 </td></tr></table></div><p>
 
-<a name="%_sec_Temp_384" id="%_sec_Temp_384"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_384">Representing wires</a></h4><p>
+<a id="__sec_Temp_384"></a>
+</p><h4>Representing wires</h4><p>
 
-<a name="%_idx_3392" id="%_idx_3392"></a>
+<a id="__idx_3392"></a>
 A wire in our simulation will be a computational object with two local
 state variables: a <tt>signal-value</tt> (initially taken to be 0) and a
 collection of <tt>action-procedures</tt> to be run when the signal
 changes value.  We implement the wire, using message-passing style, as
-<a name="%_idx_3394" id="%_idx_3394"></a>a collection of local procedures together with a <tt>dispatch</tt>
+<a id="__idx_3394"></a>a collection of local procedures together with a <tt>dispatch</tt>
 procedure that selects the appropriate local operation, just as we did
 with the simple bank-account object in section
- <a href="book-Z-H-20.html#%_sec_3.1.1">3.1.1</a>:</p><p>
+ <a href="book-Z-H-20.html#__sec_3.1.1">3.1.1</a>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3396" id="%_idx_3396"></a>(define (make-wire)<br />
+</p><p></p><p><tt><a id="__idx_3396"></a>(define (make-wire)<br />
   (let ((signal-value 0) (action-procedures '()))<br />
     (define (set-my-signal! new-value)<br />
       (if (not (= signal-value new-value))<br />
@@ -1099,7 +1099,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 action procedures, using the following procedure <tt>call-each</tt>,
 which calls each of the items in a list of no-argument procedures:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3398" id="%_idx_3398"></a>(define (call-each procedures)<br />
+</p><p></p><p><tt><a id="__idx_3398"></a>(define (call-each procedures)<br />
   (if (null? procedures)<br />
       'done<br />
       (begin<br />
@@ -1107,15 +1107,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
         (call-each (cdr procedures)))))<br /></tt></p><p></p><p>
 The local procedure <tt>accept-action-procedure!</tt> adds the given
 procedure to the list of procedures to be run, and then runs the new
-procedure once.  (See exercise <a href="#%_thm_3.31">3.31</a>.)</p><p>
+procedure once.  (See exercise <a href="#__thm_3.31">3.31</a>.)</p><p>
 
 With the local <tt>dispatch</tt> procedure set up as specified, we can
 provide the following procedures to access the local operations on
-wires:<a name="call_footnote_Temp_385" href="#footnote_Temp_385" id="call_footnote_Temp_385"><sup><small>27</small></sup></a></p><p>
+wires:<a href="#footnote_Temp_385" id="call_footnote_Temp_385"><sup><small>27</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_3404" id="%_idx_3404"></a>(define (get-signal wire)<br />
-  (wire 'get-signal))<br /><a name="%_idx_3406" id="%_idx_3406"></a>(define (set-signal! wire new-value)<br />
-  ((wire 'set-signal!) new-value))<br /><a name="%_idx_3408" id="%_idx_3408"></a>(define (add-action! wire action-procedure)<br />
+</p><p></p><p><tt><a id="__idx_3404"></a>(define (get-signal wire)<br />
+  (wire 'get-signal))<br /><a id="__idx_3406"></a>(define (set-signal! wire new-value)<br />
+  ((wire 'set-signal!) new-value))<br /><a id="__idx_3408"></a>(define (add-action! wire action-procedure)<br />
   ((wire 'add-action!) action-procedure))<br /></tt></p><p></p><p></p><p>
 
 Wires, which have time-varying signals and may be incrementally
@@ -1132,31 +1132,31 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 wire communicates the change to its neighbors by calling the action
 procedures provided to it when the connections were established.
 
-<a name="%_sec_Temp_386" id="%_sec_Temp_386"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_386">The agenda</a></h4><p>
+<a id="__sec_Temp_386"></a>
+</p><h4>The agenda</h4><p>
 
-<a name="%_idx_3410" id="%_idx_3410"></a>
+<a id="__idx_3410"></a>
 The only thing needed to complete the simulator is <tt>after-delay</tt>.
 The idea here is that we maintain a data structure, called an <em>agenda</em>, that contains a schedule of things to do.  The following
 operations are defined for agendas:</p><p>
 
-</p><p></p><ul><li><a name="%_idx_3412" id="%_idx_3412"></a><tt>(make-agenda)</tt><br />
+</p><p></p><ul><li><a id="__idx_3412"></a><tt>(make-agenda)</tt><br />
 returns a new empty agenda.<p>
 
-</p></li><li><a name="%_idx_3414" id="%_idx_3414"></a><tt>(empty-agenda? &lt;<em>agenda</em>&gt;)</tt><br />
+</p></li><li><a id="__idx_3414"></a><tt>(empty-agenda? &lt;<em>agenda</em>&gt;)</tt><br />
 is true if the specified agenda is empty.<p>
 
-</p></li><li><a name="%_idx_3416" id="%_idx_3416"></a><tt>(first-agenda-item &lt;<em>agenda</em>&gt;)</tt><br />
+</p></li><li><a id="__idx_3416"></a><tt>(first-agenda-item &lt;<em>agenda</em>&gt;)</tt><br />
 returns the first item on the agenda.<p>
 
-</p></li><li><a name="%_idx_3418" id="%_idx_3418"></a><tt>(remove-first-agenda-item! &lt;<em>agenda</em>&gt;)</tt><br />
+</p></li><li><a id="__idx_3418"></a><tt>(remove-first-agenda-item! &lt;<em>agenda</em>&gt;)</tt><br />
 modifies the agenda by removing the first item.<p>
 
-</p></li><li><a name="%_idx_3420" id="%_idx_3420"></a><tt>(add-to-agenda! &lt;<em>time</em>&gt; &lt;<em>action</em>&gt; &lt;<em>agenda</em>&gt;)</tt><br />
+</p></li><li><a id="__idx_3420"></a><tt>(add-to-agenda! &lt;<em>time</em>&gt; &lt;<em>action</em>&gt; &lt;<em>agenda</em>&gt;)</tt><br />
 modifies the agenda by adding the given action procedure to be run at
 the specified time.<p>
 
-</p></li><li><a name="%_idx_3422" id="%_idx_3422"></a><tt>(current-time &lt;<em>agenda</em>&gt;)</tt><br />
+</p></li><li><a id="__idx_3422"></a><tt>(current-time &lt;<em>agenda</em>&gt;)</tt><br />
 returns the current simulation time.
 </li></ul><p></p><p>
 
@@ -1164,7 +1164,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 <tt>the-agenda</tt>.  The procedure <tt>after-delay</tt> adds new
 elements to <tt>the-agenda</tt>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3424" id="%_idx_3424"></a>(define (after-delay delay action)<br />
+</p><p></p><p><tt><a id="__idx_3424"></a>(define (after-delay delay action)<br />
   (add-to-agenda! (+ delay (current-time the-agenda))<br />
                   action<br />
                   the-agenda))<br /></tt></p><p></p><p></p><p>
@@ -1175,7 +1175,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 added to the agenda, and <tt>propagate</tt> will continue the simulation
 as long as there are items on the agenda:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3426" id="%_idx_3426"></a>(define (propagate)<br />
+</p><p></p><p><tt><a id="__idx_3426"></a>(define (propagate)<br />
   (if (empty-agenda? the-agenda)<br />
       'done<br />
       (let ((first-item (first-agenda-item the-agenda)))<br />
@@ -1184,16 +1184,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
         (propagate))))<br /></tt></p><p></p><p>
 </p><p>
 
-<a name="%_sec_Temp_387" id="%_sec_Temp_387"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_387">A sample simulation</a></h4><p>
+<a id="__sec_Temp_387"></a>
+</p><h4>A sample simulation</h4><p>
 
-<a name="%_idx_3428" id="%_idx_3428"></a><a name="%_idx_3430" id="%_idx_3430"></a>
+<a id="__idx_3428"></a><a id="__idx_3430"></a>
 The following procedure, which places a “probe” on a wire, shows the
 simulator in action.  The probe tells the wire that, whenever its
 signal changes value, it should print the new signal value, together
 with the current time and a name that identifies the wire:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3432" id="%_idx_3432"></a>(define (probe name wire)<br />
+</p><p></p><p><tt><a id="__idx_3432"></a>(define (probe name wire)<br />
   (add-action! wire<br />
                (lambda ()        <br />
                  (newline)<br />
@@ -1220,7 +1220,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 (probe 'sum sum)<br /><i>sum 0  New-value = 0</i><br />
 (probe 'carry carry)<br /><i>carry 0  New-value = 0</i><br /></tt></p><p></p><p>
 Next we connect the wires in a half-adder circuit (as in
-figure <a href="#%_fig_3.25">3.25</a>), set the signal on <tt>input-1</tt> to 1,
+figure <a href="#__fig_3.25">3.25</a>), set the signal on <tt>input-1</tt> to 1,
 and run the simulation:</p><p>
 
 
@@ -1238,9 +1238,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 at time 16.
 
 
-</p><p><a name="%_thm_3.31" id="%_thm_3.31"></a>
+</p><p><a id="__thm_3.31"></a>
 <b>Exercise 3.31.</b>  
-<a name="%_idx_3434" id="%_idx_3434"></a>The internal procedure <tt>accept-action-procedure!</tt> defined in <tt>make-wire</tt> specifies that when a new action procedure is added to
+<a id="__idx_3434"></a>The internal procedure <tt>accept-action-procedure!</tt> defined in <tt>make-wire</tt> specifies that when a new action procedure is added to
 a wire, the procedure is immediately run.  Explain why this initialization
 is necessary.  In particular, trace through the half-adder example in
 the paragraphs above and say how the system's response would differ if
@@ -1251,37 +1251,37 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
   (set! action-procedures (cons proc action-procedures)))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-<a name="%_sec_Temp_389" id="%_sec_Temp_389"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_389">Implementing the agenda</a></h4><p>
+<a id="__sec_Temp_389"></a>
+</p><h4>Implementing the agenda</h4><p>
 
-<a name="%_idx_3436" id="%_idx_3436"></a>
+<a id="__idx_3436"></a>
 Finally, we give details of the agenda data structure, which holds the
 procedures that are scheduled for future execution.</p><p>
 
-The agenda is made up of <a name="%_idx_3438" id="%_idx_3438"></a><em>time segments</em>.  Each time segment is a
-pair consisting of a number (the time) and a <a name="%_idx_3440" id="%_idx_3440"></a>queue (see
-exercise <a href="#%_thm_3.32">3.32</a>) that holds the procedures that are
+The agenda is made up of <a id="__idx_3438"></a><em>time segments</em>.  Each time segment is a
+pair consisting of a number (the time) and a <a id="__idx_3440"></a>queue (see
+exercise <a href="#__thm_3.32">3.32</a>) that holds the procedures that are
 scheduled to be run during that time segment.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3442" id="%_idx_3442"></a>(define (make-time-segment time queue)<br />
-  (cons time queue))<br /><a name="%_idx_3444" id="%_idx_3444"></a>(define (segment-time s) (car s))<br /><a name="%_idx_3446" id="%_idx_3446"></a>(define (segment-queue s) (cdr s))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_3442"></a>(define (make-time-segment time queue)<br />
+  (cons time queue))<br /><a id="__idx_3444"></a>(define (segment-time s) (car s))<br /><a id="__idx_3446"></a>(define (segment-queue s) (cdr s))<br /></tt></p><p></p><p>
 We will operate on the time-segment queues using the queue operations
-described in section <a href="#%_sec_3.3.2">3.3.2</a>.</p><p>
+described in section <a href="#__sec_3.3.2">3.3.2</a>.</p><p>
 
-<a name="%_idx_3448" id="%_idx_3448"></a>The agenda itself is a one-dimensional table of time segments.  It
-differs from the tables described in section <a href="#%_sec_3.3.3">3.3.3</a> in that
+<a id="__idx_3448"></a>The agenda itself is a one-dimensional table of time segments.  It
+differs from the tables described in section <a href="#__sec_3.3.3">3.3.3</a> in that
 the segments will be sorted in order of increasing time.  In addition,
-we store the <a name="%_idx_3450" id="%_idx_3450"></a><em>current time</em> (i.e., the time of the last action
+we store the <a id="__idx_3450"></a><em>current time</em> (i.e., the time of the last action
 that was processed) at the head of the agenda.  A newly constructed
-agenda has no time segments and has a current time of 0:<a name="call_footnote_Temp_390" href="#footnote_Temp_390" id="call_footnote_Temp_390"><sup><small>28</small></sup></a></p><p>
+agenda has no time segments and has a current time of 0:<a href="#footnote_Temp_390" id="call_footnote_Temp_390"><sup><small>28</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_3456" id="%_idx_3456"></a>(define (make-agenda) (list 0))<br /><a name="%_idx_3458" id="%_idx_3458"></a>(define (current-time agenda) (car agenda))<br /><a name="%_idx_3460" id="%_idx_3460"></a>(define (set-current-time! agenda time)<br />
-  (set-car! agenda time))<br /><a name="%_idx_3462" id="%_idx_3462"></a>(define (segments agenda) (cdr agenda))<br /><a name="%_idx_3464" id="%_idx_3464"></a>(define (set-segments! agenda segments)<br />
-  (set-cdr! agenda segments))<br /><a name="%_idx_3466" id="%_idx_3466"></a>(define (first-segment agenda) (car (segments agenda)))<br /><a name="%_idx_3468" id="%_idx_3468"></a>(define (rest-segments agenda) (cdr (segments agenda)))<br /></tt></p><p></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_3456"></a>(define (make-agenda) (list 0))<br /><a id="__idx_3458"></a>(define (current-time agenda) (car agenda))<br /><a id="__idx_3460"></a>(define (set-current-time! agenda time)<br />
+  (set-car! agenda time))<br /><a id="__idx_3462"></a>(define (segments agenda) (cdr agenda))<br /><a id="__idx_3464"></a>(define (set-segments! agenda segments)<br />
+  (set-cdr! agenda segments))<br /><a id="__idx_3466"></a>(define (first-segment agenda) (car (segments agenda)))<br /><a id="__idx_3468"></a>(define (rest-segments agenda) (cdr (segments agenda)))<br /></tt></p><p></p><p></p><p>
 
 An agenda is empty if it has no time segments:
 
-</p><p></p><p><tt><a name="%_idx_3470" id="%_idx_3470"></a>(define (empty-agenda? agenda)<br />
+</p><p></p><p><tt><a id="__idx_3470"></a>(define (empty-agenda? agenda)<br />
   (null? (segments agenda)))<br /></tt></p><p></p><p>
 </p><p>
 
@@ -1296,7 +1296,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 create a new time segment at the end.</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_3472" id="%_idx_3472"></a>(define (add-to-agenda! time action agenda)<br />
+</p><p></p><p><tt><a id="__idx_3472"></a>(define (add-to-agenda! time action agenda)<br />
   (define (belongs-before? segments)<br />
     (or (null? segments)<br />
         (&lt; time (segment-time (car segments)))))<br />
@@ -1326,9 +1326,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 The procedure that removes the first item from the agenda deletes the
 item at the front of the queue in the first time segment.  If this
 deletion makes the time segment empty, we remove it from the list of
-segments:<a name="call_footnote_Temp_391" href="#footnote_Temp_391" id="call_footnote_Temp_391"><sup><small>29</small></sup></a></p><p>
+segments:<a href="#footnote_Temp_391" id="call_footnote_Temp_391"><sup><small>29</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_3478" id="%_idx_3478"></a>(define (remove-first-agenda-item! agenda)<br />
+</p><p></p><p><tt><a id="__idx_3478"></a>(define (remove-first-agenda-item! agenda)<br />
   (let ((q (segment-queue (first-segment agenda))))<br />
     (delete-queue! q)<br />
     (if (empty-queue? q)<br />
@@ -1336,16 +1336,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 
 The first agenda item is found at the head of the queue in the first
 time segment.  Whenever we extract an item, we also update the current
-time:<a name="call_footnote_Temp_392" href="#footnote_Temp_392" id="call_footnote_Temp_392"><sup><small>30</small></sup></a></p><p>
+time:<a href="#footnote_Temp_392" id="call_footnote_Temp_392"><sup><small>30</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_3480" id="%_idx_3480"></a>(define (first-agenda-item agenda)<br />
+</p><p></p><p><tt><a id="__idx_3480"></a>(define (first-agenda-item agenda)<br />
   (if (empty-agenda? agenda)<br />
       (error "Agenda is empty -- FIRST-AGENDA-ITEM")<br />
       (let ((first-seg (first-segment agenda)))<br />
         (set-current-time! agenda (segment-time first-seg))<br />
         (front-queue (segment-queue first-seg)))))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_3.32" id="%_thm_3.32"></a>
+</p><p><a id="__thm_3.32"></a>
 <b>Exercise 3.32.</b>  The procedures to be run during each time segment of the agenda are
 kept in a queue.  Thus, the procedures for each segment are called in
 the order in which they were added to the agenda (first in, first
@@ -1357,11 +1357,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 
 </p><p>
 
-<a name="%_sec_3.3.5" id="%_sec_3.3.5"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.3.5">3.3.5  Propagation of Constraints</a></h3><p>
+<a id="__sec_3.3.5"></a>
+</p><h3>3.3.5  Propagation of Constraints</h3><p>
 
 
-<a name="%_idx_3482" id="%_idx_3482"></a><a name="%_idx_3484" id="%_idx_3484"></a>
+<a id="__idx_3482"></a><a id="__idx_3484"></a>
 Computer programs are traditionally organized as
 one-directional computations, which perform operations on prespecified
 arguments to produce desired outputs.  On the other hand, we often
@@ -1379,11 +1379,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 one of the quantities to be computed in terms of the other four.
 Thus, a procedure for computing the area <em>A</em> could not be used to
 compute the deflection <em>d</em>, even though the computations of <em>A</em> and
-<em>d</em> arise from the same equation.<a name="call_footnote_Temp_394" href="#footnote_Temp_394" id="call_footnote_Temp_394"><sup><small>31</small></sup></a></p><p>
+<em>d</em> arise from the same equation.<a href="#footnote_Temp_394" id="call_footnote_Temp_394"><sup><small>31</small></sup></a></p><p>
 
-<a name="%_idx_3508" id="%_idx_3508"></a>In this section, we sketch the design of a language that enables us to
+<a id="__idx_3508"></a>In this section, we sketch the design of a language that enables us to
 work in terms of relations themselves.  The primitive elements of the
-language are <a name="%_idx_3510" id="%_idx_3510"></a><a name="%_idx_3512" id="%_idx_3512"></a><em>primitive constraints</em>, which state that certain
+language are <a id="__idx_3510"></a><a id="__idx_3512"></a><em>primitive constraints</em>, which state that certain
 relations hold between quantities.  For example, <tt>(adder a b c)</tt>
 specifies that the quantities <em>a</em>, <em>b</em>, and <em>c</em> must be related by the
 equation <em>a</em> + <em>b</em> = <em>c</em>, <tt>(multiplier x y z)</tt> expresses the constraint
@@ -1393,8 +1393,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 
 Our language provides a means of combining primitive constraints in
 order to express more complex relations.  We combine constraints by
-constructing <a name="%_idx_3514" id="%_idx_3514"></a><em>constraint networks</em>, in which constraints are
-joined by <a name="%_idx_3516" id="%_idx_3516"></a><em>connectors</em>.  A connector is an object that “holds” a
+constructing <a id="__idx_3514"></a><em>constraint networks</em>, in which constraints are
+joined by <a id="__idx_3516"></a><em>connectors</em>.  A connector is an object that “holds” a
 value that may participate in one or more constraints.  For example,
 we know that the relationship between Fahrenheit and Celsius
 temperatures is</p>
@@ -1403,7 +1403,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 
 <p>Such a constraint can be thought of as a network consisting of
 primitive adder, multiplier, and constant constraints
-(figure <a href="#%_fig_3.28">3.28</a>).  In the figure, we see on the left a
+(figure <a href="#__fig_3.28">3.28</a>).  In the figure, we see on the left a
 multiplier box with three terminals, labeled <em>m</em>1, <em>m</em>2, and <em>p</em>.
 These connect the multiplier to the rest of the network as follows:
 The <em>m</em>1 terminal is linked to a connector <em>C</em>, which will hold the
@@ -1414,7 +1414,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 of another multiplier box, whose <em>m</em>2 is connected to a constant 5 and
 whose <em>m</em>1 is connected to one of the terms in a sum.</p><p>
 
-<a name="%_fig_3.28" id="%_fig_3.28"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-30.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.28:</b>  The relation 9<em>C</em>  =  5(<em>F</em>  -  32)
+<a id="__fig_3.28"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-30.gif" alt="ch3-Z-G-30" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.28:</b>  The relation 9<em>C</em>  =  5(<em>F</em>  -  32)
 expressed as a constraint network.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
@@ -1437,8 +1437,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 the adder, which sets <em>F</em> to 77.</p><p>
 
 
-<a name="%_sec_Temp_395" id="%_sec_Temp_395"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_395">Using the constraint system</a></h4><p>
+<a id="__sec_Temp_395"></a>
+</p><h4>Using the constraint system</h4><p>
 
 To use the constraint system to carry out the temperature computation
 outlined above, we first create two connectors, <tt>C</tt> and <tt>F</tt>,
@@ -1450,7 +1450,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 (celsius-fahrenheit-converter C F)<br /><i>ok</i><br /></tt></p><p></p><p>
 The procedure that creates the network is defined as follows:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3518" id="%_idx_3518"></a>(define (celsius-fahrenheit-converter c f)<br />
+</p><p></p><p><tt><a id="__idx_3518"></a>(define (celsius-fahrenheit-converter c f)<br />
   (let ((u (make-connector))<br />
         (v (make-connector))<br />
         (w (make-connector))<br />
@@ -1464,16 +1464,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
     (constant 32 y)<br />
     'ok))<br /></tt></p><p></p><p>
 This procedure creates the internal connectors <tt>u</tt>, <tt>v</tt>, <tt>w</tt>, <tt>x</tt>, and <tt>y</tt>, and links them as shown in
-figure <a href="#%_fig_3.28">3.28</a> using the primitive constraint
+figure <a href="#__fig_3.28">3.28</a> using the primitive constraint
 constructors <tt>adder</tt>, <tt>multiplier</tt>, and <tt>constant</tt>.  Just
 as with the digital-circuit simulator of
-section <a href="#%_sec_3.3.4">3.3.4</a>, expressing these combinations of
+section <a href="#__sec_3.3.4">3.3.4</a>, expressing these combinations of
 primitive elements in terms of procedures automatically provides our
 language with a means of abstraction for compound objects.</p><p>
 
 To watch the network in action, we can place probes on the connectors
 <tt>C</tt> and <tt>F</tt>, using a <tt>probe</tt> procedure similar to the one
-we used to monitor wires in section <a href="#%_sec_3.3.4">3.3.4</a>.
+we used to monitor wires in section <a href="#__sec_3.3.4">3.3.4</a>.
 Placing a probe on a connector will cause a message to be printed
 whenever the connector is given a value:</p><p>
 
@@ -1516,30 +1516,30 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 nondirectionality of computation is the distinguishing feature of
 constraint-based systems.</p><p>
 
-<a name="%_sec_Temp_396" id="%_sec_Temp_396"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_396">Implementing the constraint system</a></h4><p>
+<a id="__sec_Temp_396"></a>
+</p><h4>Implementing the constraint system</h4><p>
 
 The constraint system is implemented via procedural objects with local
 state, in a manner very similar to the digital-circuit simulator of
-section <a href="#%_sec_3.3.4">3.3.4</a>.  Although the primitive objects
+section <a href="#__sec_3.3.4">3.3.4</a>.  Although the primitive objects
 of the constraint system are somewhat more complex, the overall system
 is simpler, since there is no concern about agendas and logic delays.</p><p>
 
-<a name="%_idx_3520" id="%_idx_3520"></a>The basic operations on connectors are the following:
-</p><p></p><ul><li><a name="%_idx_3522" id="%_idx_3522"></a><tt>(has-value? &lt;<em>connector</em>&gt;)</tt><br />
+<a id="__idx_3520"></a>The basic operations on connectors are the following:
+</p><p></p><ul><li><a id="__idx_3522"></a><tt>(has-value? &lt;<em>connector</em>&gt;)</tt><br />
 tells whether the connector has a value.<p>
 
-</p></li><li><a name="%_idx_3524" id="%_idx_3524"></a><tt>(get-value &lt;<em>connector</em>&gt;)</tt><br />
+</p></li><li><a id="__idx_3524"></a><tt>(get-value &lt;<em>connector</em>&gt;)</tt><br />
 returns the connector's current value.<p>
 
-</p></li><li><a name="%_idx_3526" id="%_idx_3526"></a><tt>(set-value! &lt;<em>connector</em>&gt; &lt;<em>new-value</em>&gt; &lt;<em>informant</em>&gt;)</tt><br />
+</p></li><li><a id="__idx_3526"></a><tt>(set-value! &lt;<em>connector</em>&gt; &lt;<em>new-value</em>&gt; &lt;<em>informant</em>&gt;)</tt><br />
 indicates that the informant is requesting the connector to set its
 value to the new value.<p>
 
-</p></li><li><a name="%_idx_3528" id="%_idx_3528"></a><tt>(forget-value! &lt;<em>connector</em>&gt; &lt;<em>retractor</em>&gt;)</tt><br />
+</p></li><li><a id="__idx_3528"></a><tt>(forget-value! &lt;<em>connector</em>&gt; &lt;<em>retractor</em>&gt;)</tt><br />
 tells the connector that the retractor is requesting it to forget its value.<p>
 
-</p></li><li><a name="%_idx_3530" id="%_idx_3530"></a><tt>(connect &lt;<em>connector</em>&gt; &lt;<em>new-constraint</em>&gt;)</tt><br />
+</p></li><li><a id="__idx_3530"></a><tt>(connect &lt;<em>connector</em>&gt; &lt;<em>new-constraint</em>&gt;)</tt><br />
 tells the connector to participate in the new constraint.
 </li></ul><p></p><p>
 
@@ -1553,7 +1553,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 implemented as a procedure with local state (the procedure <tt>me</tt>
 below):</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3532" id="%_idx_3532"></a>(define (adder a1 a2 sum)<br />
+</p><p></p><p><tt><a id="__idx_3532"></a>(define (adder a1 a2 sum)<br />
   (define (process-new-value)<br />
     (cond ((and (has-value? a1) (has-value? a2))<br />
            (set-value! sum<br />
@@ -1587,11 +1587,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 returns it as its value.  The procedure <tt>me</tt>, which represents the
 adder, acts as a dispatch to the local procedures.  The following
 “syntax interfaces” (see footnote <a href="#footnote_Temp_385">27</a> in
-section <a href="#%_sec_3.3.4">3.3.4</a>) are used in conjunction with the
+section <a href="#__sec_3.3.4">3.3.4</a>) are used in conjunction with the
 dispatch:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3534" id="%_idx_3534"></a>(define (inform-about-value constraint)<br />
-  (constraint 'I-have-a-value))<br /><a name="%_idx_3536" id="%_idx_3536"></a>(define (inform-about-no-value constraint)<br />
+</p><p></p><p><tt><a id="__idx_3534"></a>(define (inform-about-value constraint)<br />
+  (constraint 'I-have-a-value))<br /><a id="__idx_3536"></a>(define (inform-about-no-value constraint)<br />
   (constraint 'I-lost-my-value))<br /></tt></p><p></p><p>
 The adder's local procedure <tt>process-new-value</tt> is called when the
 adder is informed that one of its connectors has a value. The adder
@@ -1614,7 +1614,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 A multiplier is very similar to an adder. It will set its <tt>product</tt> to 0 if either of the factors is 0, even if the other factor
 is not known.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3538" id="%_idx_3538"></a>(define (multiplier m1 m2 product)<br />
+</p><p></p><p><tt><a id="__idx_3538"></a>(define (multiplier m1 m2 product)<br />
   (define (process-new-value)<br />
     (cond ((or (and (has-value? m1) (= (get-value m1) 0))<br />
                (and (has-value? m2) (= (get-value m2) 0)))<br />
@@ -1651,7 +1651,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 connector.  Any <tt>I-have-a-value</tt> or <tt>I-lost-my-value</tt> message
 sent to the constant box will produce an error.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3540" id="%_idx_3540"></a>(define (constant value connector)<br />
+</p><p></p><p><tt><a id="__idx_3540"></a>(define (constant value connector)<br />
   (define (me request)<br />
     (error "Unknown request -- CONSTANT" request))<br />
   (connect connector me)<br />
@@ -1660,7 +1660,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 Finally, a probe prints a message about the setting or unsetting of
 the designated connector:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3542" id="%_idx_3542"></a>(define (probe name connector)<br />
+</p><p></p><p><tt><a id="__idx_3542"></a>(define (probe name connector)<br />
   (define (print-probe value)<br />
     (newline)<br />
     (display "Probe: ")<br />
@@ -1681,15 +1681,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
   (connect connector me)<br />
   me)<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_397" id="%_sec_Temp_397"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_397">Representing connectors</a></h4><p>
+<a id="__sec_Temp_397"></a>
+</p><h4>Representing connectors</h4><p>
 
-<a name="%_idx_3544" id="%_idx_3544"></a>
+<a id="__idx_3544"></a>
 A connector is represented as a procedural object with local state
 variables <tt>value</tt>, the current value of the connector; <tt>informant</tt>, the object that set the connector's value; and <tt>constraints</tt>, a list of the constraints in which the connector
 participates.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3546" id="%_idx_3546"></a>(define (make-connector)<br />
+</p><p></p><p><tt><a id="__idx_3546"></a>(define (make-connector)<br />
   (let ((value false) (informant false) (constraints '()))<br />
     (define (set-my-value newval setter)<br />
       (cond ((not (has-value? me))<br />
@@ -1731,13 +1731,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 there is a request to set the connector's value.  If the connector
 does not currently have a value, it will set its value and remember as
 <tt>informant</tt> the constraint that requested the value to be
-set.<a name="call_footnote_Temp_398" href="#footnote_Temp_398" id="call_footnote_Temp_398"><sup><small>32</small></sup></a>
+set.<a href="#footnote_Temp_398" id="call_footnote_Temp_398"><sup><small>32</small></sup></a>
 Then the connector will notify all of its participating
 constraints except the constraint that requested the value to be set.
 This is accomplished using the following iterator, which applies a
 designated procedure to all items in a list except a given one:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3548" id="%_idx_3548"></a>(define (for-each-except exception procedure list)<br />
+</p><p></p><p><tt><a id="__idx_3548"></a>(define (for-each-except exception procedure list)<br />
   (define (loop items)<br />
     (cond ((null? items) 'done)<br />
           ((eq? (car items) exception) (loop (cdr items)))<br />
@@ -1760,22 +1760,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 internal procedures and also represents the connector as an object.
 The following procedures provide a syntax interface for the dispatch:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3550" id="%_idx_3550"></a>(define (has-value? connector)<br />
-  (connector 'has-value?))<br /><a name="%_idx_3552" id="%_idx_3552"></a>(define (get-value connector)<br />
-  (connector 'value))<br /><a name="%_idx_3554" id="%_idx_3554"></a>(define (set-value! connector new-value informant)<br />
-  ((connector 'set-value!) new-value informant))<br /><a name="%_idx_3556" id="%_idx_3556"></a>(define (forget-value! connector retractor)<br />
-  ((connector 'forget) retractor))<br /><a name="%_idx_3558" id="%_idx_3558"></a>(define (connect connector new-constraint)<br />
+</p><p></p><p><tt><a id="__idx_3550"></a>(define (has-value? connector)<br />
+  (connector 'has-value?))<br /><a id="__idx_3552"></a>(define (get-value connector)<br />
+  (connector 'value))<br /><a id="__idx_3554"></a>(define (set-value! connector new-value informant)<br />
+  ((connector 'set-value!) new-value informant))<br /><a id="__idx_3556"></a>(define (forget-value! connector retractor)<br />
+  ((connector 'forget) retractor))<br /><a id="__idx_3558"></a>(define (connect connector new-constraint)<br />
   ((connector 'connect) new-constraint))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_3.33" id="%_thm_3.33"></a>
+</p><p><a id="__thm_3.33"></a>
 <b>Exercise 3.33.</b>  Using primitive multiplier, adder, and constant constraints, define a
-procedure <a name="%_idx_3560" id="%_idx_3560"></a><tt>averager</tt> that takes three connectors <tt>a</tt>, <tt>b</tt>,
+procedure <a id="__idx_3560"></a><tt>averager</tt> that takes three connectors <tt>a</tt>, <tt>b</tt>,
 and <tt>c</tt> as inputs and establishes the constraint that the value of
 <tt>c</tt> is the average of the values of <tt>a</tt> and <tt>b</tt>.
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.34" id="%_thm_3.34"></a>
-<b>Exercise 3.34.</b>  <a name="%_idx_3562" id="%_idx_3562"></a>Louis Reasoner wants to build a squarer, a constraint device with two
+</p><p><a id="__thm_3.34"></a>
+<b>Exercise 3.34.</b>  <a id="__idx_3562"></a>Louis Reasoner wants to build a squarer, a constraint device with two
 terminals such that the value of connector <tt>b</tt> on the second
 terminal will always be the square of the value <tt>a</tt> on the first
 terminal.  He proposes the following simple device made from a
@@ -1788,9 +1788,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.35" id="%_thm_3.35"></a>
-<b>Exercise 3.35.</b>  <a name="%_idx_3564" id="%_idx_3564"></a>Ben Bitdiddle tells Louis that one way to avoid the trouble in
-exercise <a href="#%_thm_3.34">3.34</a> is to define a squarer as a new
+</p><p><a id="__thm_3.35"></a>
+<b>Exercise 3.35.</b>  <a id="__idx_3564"></a>Ben Bitdiddle tells Louis that one way to avoid the trouble in
+exercise <a href="#__thm_3.34">3.34</a> is to define a squarer as a new
 primitive constraint.  Fill in the missing portions in Ben's outline
 for a procedure to implement such a constraint:</p><p>
 
@@ -1808,7 +1808,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
   me)<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.36" id="%_thm_3.36"></a>
+</p><p><a id="__thm_3.36"></a>
 <b>Exercise 3.36.</b>  Suppose we evaluate the following sequence of expressions in the
 global environment:</p><p>
 
@@ -1826,12 +1826,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 </p><p></p><p>
 
 
-</p><p><a name="%_thm_3.37" id="%_thm_3.37"></a>
+</p><p><a id="__thm_3.37"></a>
 <b>Exercise 3.37.</b>  The <tt>celsius-fahrenheit-converter</tt> procedure is cumbersome when
 compared with a more expression-oriented style of definition, such as</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_3566" id="%_idx_3566"></a>(define (celsius-fahrenheit-converter x)<br />
+</p><p></p><p><tt><a id="__idx_3566"></a>(define (celsius-fahrenheit-converter x)<br />
   (c+ (c* (c/ (cv 9) (cv 5))<br />
           x)<br />
       (cv 32)))<br />
@@ -1850,34 +1850,34 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
     z))<br /></tt></p><p></p><p>
 Define analogous procedures <tt>c-</tt>, <tt>c*</tt>, <tt>c/</tt>, and <tt>cv</tt>
 (constant value) that enable us to define compound constraints as in
-the converter example above.<a name="call_footnote_Temp_404" href="#footnote_Temp_404" id="call_footnote_Temp_404"><sup><small>33</small></sup></a>
+the converter example above.<a href="#footnote_Temp_404" id="call_footnote_Temp_404"><sup><small>33</small></sup></a>
 </p><p>
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_349" href="#call_footnote_Temp_349" id="footnote_Temp_349"><sup><small>16</small></sup></a> <tt>Set-car!</tt> and <tt>set-cdr!</tt> return implementation-dependent
-<a name="%_idx_3148" id="%_idx_3148"></a><a name="%_idx_3150" id="%_idx_3150"></a><a name="%_idx_3152" id="%_idx_3152"></a><a name="%_idx_3154" id="%_idx_3154"></a>values.  Like <tt>set!</tt>, they should be used only for their effect.
+</p><div class="footnote"><p><a href="#call_footnote_Temp_349" id="footnote_Temp_349"><sup><small>16</small></sup></a> <tt>Set-car!</tt> and <tt>set-cdr!</tt> return implementation-dependent
+<a id="__idx_3148"></a><a id="__idx_3150"></a><a id="__idx_3152"></a><a id="__idx_3154"></a>values.  Like <tt>set!</tt>, they should be used only for their effect.
 
-</p><p><a name="footnote_Temp_350" href="#call_footnote_Temp_350" id="footnote_Temp_350"><sup><small>17</small></sup></a> We see from this that mutation operations on lists
+</p><p><a href="#call_footnote_Temp_350" id="footnote_Temp_350"><sup><small>17</small></sup></a> We see from this that mutation operations on lists
 can create “garbage” that is not part of any accessible structure.
-We will see in section <a href="book-Z-H-33.html#%_sec_5.3.2">5.3.2</a> that Lisp memory-management
-systems include a <a name="%_idx_3156" id="%_idx_3156"></a><em>garbage collector</em>, which identifies and
+We will see in section <a href="book-Z-H-33.html#__sec_5.3.2">5.3.2</a> that Lisp memory-management
+systems include a <a id="__idx_3156"></a><em>garbage collector</em>, which identifies and
 recycles the memory space used by unneeded pairs.
 
-</p><p><a name="footnote_Temp_351" href="#call_footnote_Temp_351" id="footnote_Temp_351"><sup><small>18</small></sup></a> <tt>Get-new-pair</tt> is one of the operations that must be implemented as
+</p><p><a href="#call_footnote_Temp_351" id="footnote_Temp_351"><sup><small>18</small></sup></a> <tt>Get-new-pair</tt> is one of the operations that must be implemented as
 part of the memory management required by a Lisp implementation.  We
-will discuss this in section <a href="book-Z-H-33.html#%_sec_5.3.1">5.3.1</a>.
+will discuss this in section <a href="book-Z-H-33.html#__sec_5.3.1">5.3.1</a>.
 
-</p><p><a name="footnote_Temp_356" href="#call_footnote_Temp_356" id="footnote_Temp_356"><sup><small>19</small></sup></a> The two pairs
+</p><p><a href="#call_footnote_Temp_356" id="footnote_Temp_356"><sup><small>19</small></sup></a> The two pairs
 are distinct because each call to <tt>cons</tt> returns a new pair.  The
 symbols are shared; in Scheme there is a unique symbol with any given
-<a name="%_idx_3184" id="%_idx_3184"></a>name.  Since Scheme provides no way to mutate a symbol, this sharing is
+<a id="__idx_3184"></a>name.  Since Scheme provides no way to mutate a symbol, this sharing is
 undetectable.  Note also that the sharing is what enables us to
 compare symbols using <tt>eq?</tt>, which simply checks equality of
 pointers.
 
-</p><p><a name="footnote_Temp_357" href="#call_footnote_Temp_357" id="footnote_Temp_357"><sup><small>20</small></sup></a> The
+</p><p><a href="#call_footnote_Temp_357" id="footnote_Temp_357"><sup><small>20</small></sup></a> The
 subtleties of dealing with sharing of mutable data objects reflect the
 underlying issues of “sameness” and “change” that were raised in
-section <a href="book-Z-H-20.html#%_sec_3.1.3">3.1.3</a>.  We mentioned there that
+section <a href="book-Z-H-20.html#__sec_3.1.3">3.1.3</a>.  We mentioned there that
 admitting change to our language requires that a compound object must
 have an “identity” that is something different from the pieces from
 which it is composed.  In Lisp, we consider this “identity” to be
@@ -1890,33 +1890,33 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 but is hardly a general way to resolve the issue of “sameness” in
 computational models.
 
-</p><p><a name="footnote_Temp_364" href="#call_footnote_Temp_364" id="footnote_Temp_364"><sup><small>21</small></sup></a> On the other hand, from the
+</p><p><a href="#call_footnote_Temp_364" id="footnote_Temp_364"><sup><small>21</small></sup></a> On the other hand, from the
 viewpoint of implementation, assignment requires us to modify the
 environment, which is itself a mutable data structure.  Thus,
 assignment and mutation are equipotent: Each can be implemented in
 terms of the other.
 
-</p><p><a name="footnote_Temp_366" href="#call_footnote_Temp_366" id="footnote_Temp_366"><sup><small>22</small></sup></a> If the first item is
+</p><p><a href="#call_footnote_Temp_366" id="footnote_Temp_366"><sup><small>22</small></sup></a> If the first item is
 the final item in the queue, the front pointer will be the empty list after
 the deletion, which will mark the queue as empty; we needn't worry
 about updating the rear pointer, which will still point to the deleted
 item, because <tt>empty-queue?</tt> looks only at the front pointer.
 
-</p><p><a name="footnote_Temp_370" href="#call_footnote_Temp_370" id="footnote_Temp_370"><sup><small>23</small></sup></a> Be careful not to
+</p><p><a href="#call_footnote_Temp_370" id="footnote_Temp_370"><sup><small>23</small></sup></a> Be careful not to
 make the interpreter try to print a structure that contains cycles.
-(See exercise <a href="#%_thm_3.13">3.13</a>.)
+(See exercise <a href="#__thm_3.13">3.13</a>.)
 
-</p><p><a name="footnote_Temp_371" href="#call_footnote_Temp_371" id="footnote_Temp_371"><sup><small>24</small></sup></a> Because <tt>assoc</tt>
+</p><p><a href="#call_footnote_Temp_371" id="footnote_Temp_371"><sup><small>24</small></sup></a> Because <tt>assoc</tt>
 uses <tt>equal?</tt>, it can recognize keys that are symbols, numbers,
 or list structure.
 
-</p><p><a name="footnote_Temp_372" href="#call_footnote_Temp_372" id="footnote_Temp_372"><sup><small>25</small></sup></a> Thus, the first backbone pair is the
+</p><p><a href="#call_footnote_Temp_372" id="footnote_Temp_372"><sup><small>25</small></sup></a> Thus, the first backbone pair is the
 object that represents the table “itself”; that is, a pointer to the
 table is a pointer to this pair.  This same backbone pair always
 starts the table.  If we did not arrange things in this way, <tt>insert!</tt> would have to return a new value for the start of the table
 when it added a new record.
 
-</p><p><a name="footnote_Temp_379" href="#call_footnote_Temp_379" id="footnote_Temp_379"><sup><small>26</small></sup></a> A
+</p><p><a href="#call_footnote_Temp_379" id="footnote_Temp_379"><sup><small>26</small></sup></a> A
 full-adder is a basic circuit element used in adding two binary
 numbers.  Here A and B are the bits at corresponding positions in the
 two numbers to be added, and C<sub><em>i</em><em>n</em></sub> is the carry bit from the
@@ -1924,8 +1924,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 the sum bit in the corresponding position, and C<sub><em>o</em><em>u</em><em>t</em></sub>, which is the
 carry bit to be propagated to the left.
 
-</p><p><a name="footnote_Temp_385" href="#call_footnote_Temp_385" id="footnote_Temp_385"><sup><small>27</small></sup></a> These procedures are simply syntactic sugar that allow
-<a name="%_idx_3400" id="%_idx_3400"></a><a name="%_idx_3402" id="%_idx_3402"></a>us to use ordinary procedural syntax to access the local procedures of
+</p><p><a href="#call_footnote_Temp_385" id="footnote_Temp_385"><sup><small>27</small></sup></a> These procedures are simply syntactic sugar that allow
+<a id="__idx_3400"></a><a id="__idx_3402"></a>us to use ordinary procedural syntax to access the local procedures of
 objects.  It is striking that we can interchange the role of
 “procedures” and “data” in such a simple way.  For example, if we
 write <tt>(wire 'get-signal)</tt> we think of <tt>wire</tt> as a procedure
@@ -1937,41 +1937,41 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.3">3.3  Modeling with Mutable Data<
 syntactic sugar to allow us to program in whatever style we choose.
 
 
-</p><p><a name="footnote_Temp_390" href="#call_footnote_Temp_390" id="footnote_Temp_390"><sup><small>28</small></sup></a> The
-agenda is a <a name="%_idx_3452" id="%_idx_3452"></a><a name="%_idx_3454" id="%_idx_3454"></a>headed list, like the tables in section <a href="#%_sec_3.3.3">3.3.3</a>,
+</p><p><a href="#call_footnote_Temp_390" id="footnote_Temp_390"><sup><small>28</small></sup></a> The
+agenda is a <a id="__idx_3452"></a><a id="__idx_3454"></a>headed list, like the tables in section <a href="#__sec_3.3.3">3.3.3</a>,
 but since the list is headed by the time, we do not need an additional
 dummy header (such as the <tt>*table*</tt> symbol used with tables).
 
-</p><p><a name="footnote_Temp_391" href="#call_footnote_Temp_391" id="footnote_Temp_391"><sup><small>29</small></sup></a> Observe that the <tt>if</tt> expression in
+</p><p><a href="#call_footnote_Temp_391" id="footnote_Temp_391"><sup><small>29</small></sup></a> Observe that the <tt>if</tt> expression in
 this procedure has no
 &lt;<em>alternative</em>&gt; expression.  Such a “one-armed <tt>if</tt> statement”
-<a name="%_idx_3474" id="%_idx_3474"></a><a name="%_idx_3476" id="%_idx_3476"></a>is used to decide whether to do something, rather than to select
+<a id="__idx_3474"></a><a id="__idx_3476"></a>is used to decide whether to do something, rather than to select
 between two expressions.  An <tt>if</tt> expression returns an
 unspecified value if the predicate is false and there is no
 &lt;<em>alternative</em>&gt;.
 
-</p><p><a name="footnote_Temp_392" href="#call_footnote_Temp_392" id="footnote_Temp_392"><sup><small>30</small></sup></a> In this way, the current time will always be the time
+</p><p><a href="#call_footnote_Temp_392" id="footnote_Temp_392"><sup><small>30</small></sup></a> In this way, the current time will always be the time
 of the action most recently processed.  Storing this time at the head
 of the agenda ensures that it will still be available even if the
 associated time segment has been deleted.
 
-</p><p><a name="footnote_Temp_394" href="#call_footnote_Temp_394" id="footnote_Temp_394"><sup><small>31</small></sup></a> Constraint propagation
-first appeared in the incredibly forward-looking <a name="%_idx_3486" id="%_idx_3486"></a>SKETCHPAD system of
-<a name="%_idx_3488" id="%_idx_3488"></a>Ivan Sutherland (1963).  A beautiful constraint-propagation system
-based on the <a name="%_idx_3490" id="%_idx_3490"></a>Smalltalk language was developed by <a name="%_idx_3492" id="%_idx_3492"></a>Alan Borning (1977)
-at <a name="%_idx_3494" id="%_idx_3494"></a>Xerox Palo Alto Research Center.  Sussman, Stallman, and Steele
-<a name="%_idx_3496" id="%_idx_3496"></a><a name="%_idx_3498" id="%_idx_3498"></a><a name="%_idx_3500" id="%_idx_3500"></a><a name="%_idx_3502" id="%_idx_3502"></a><a name="%_idx_3504" id="%_idx_3504"></a><a name="%_idx_3506" id="%_idx_3506"></a>applied constraint propagation to electrical circuit analysis (Sussman
+</p><p><a href="#call_footnote_Temp_394" id="footnote_Temp_394"><sup><small>31</small></sup></a> Constraint propagation
+first appeared in the incredibly forward-looking <a id="__idx_3486"></a>SKETCHPAD system of
+<a id="__idx_3488"></a>Ivan Sutherland (1963).  A beautiful constraint-propagation system
+based on the <a id="__idx_3490"></a>Smalltalk language was developed by <a id="__idx_3492"></a>Alan Borning (1977)
+at <a id="__idx_3494"></a>Xerox Palo Alto Research Center.  Sussman, Stallman, and Steele
+<a id="__idx_3496"></a><a id="__idx_3498"></a><a id="__idx_3500"></a><a id="__idx_3502"></a><a id="__idx_3504"></a><a id="__idx_3506"></a>applied constraint propagation to electrical circuit analysis (Sussman
 and Stallman 1975; Sussman and Steele 1980). TK!Solver (Konopasek and
 Jayaraman 1984) is an extensive modeling environment based on
 constraints.
 
-</p><p><a name="footnote_Temp_398" href="#call_footnote_Temp_398" id="footnote_Temp_398"><sup><small>32</small></sup></a> The <tt>setter</tt> might not be a constraint.  In our
+</p><p><a href="#call_footnote_Temp_398" id="footnote_Temp_398"><sup><small>32</small></sup></a> The <tt>setter</tt> might not be a constraint.  In our
 temperature example, we used <tt>user</tt> as the <tt>setter</tt>.
 
-</p><p><a name="footnote_Temp_404" href="#call_footnote_Temp_404" id="footnote_Temp_404"><sup><small>33</small></sup></a> The expression-oriented format
+</p><p><a href="#call_footnote_Temp_404" id="footnote_Temp_404"><sup><small>33</small></sup></a> The expression-oriented format
 is convenient because it avoids the need to name the intermediate
 expressions in a computation.  Our original formulation of the
-<a name="%_idx_3568" id="%_idx_3568"></a><a name="%_idx_3570" id="%_idx_3570"></a><a name="%_idx_3572" id="%_idx_3572"></a><a name="%_idx_3574" id="%_idx_3574"></a><a name="%_idx_3576" id="%_idx_3576"></a>constraint language is cumbersome in the same way that many languages
+<a id="__idx_3568"></a><a id="__idx_3570"></a><a id="__idx_3572"></a><a id="__idx_3574"></a><a id="__idx_3576"></a>constraint language is cumbersome in the same way that many languages
 are cumbersome when dealing with operations on compound data.  For
 example, if we wanted to compute the product (<em>a</em> + <em>b</em>) · (<em>c</em> + <em>d</em>), where the
 variables represent vectors, we could work in “imperative style,”
diff --git a/src/OEBPS/book-Z-H-23.html b/src/OEBPS/book-Z-H-23.html
index b1682be..fc2a62f 100644
--- a/src/OEBPS/book-Z-H-23.html
+++ b/src/OEBPS/book-Z-H-23.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,19 +13,19 @@
 
 
 
-<a name="%_sec_3.4" id="%_sec_3.4"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the Essence</a></h2><p>
+<a id="__sec_3.4"></a>
+<h2>3.4  Concurrency: Time Is of the Essence</h2><p>
 
 
-<a name="%_idx_3578" id="%_idx_3578"></a>
+<a id="__idx_3578"></a>
 We've seen the power of computational objects with local state as
-tools for modeling.  Yet, as section <a href="book-Z-H-20.html#%_sec_3.1.3">3.1.3</a>
+tools for modeling.  Yet, as section <a href="book-Z-H-20.html#__sec_3.1.3">3.1.3</a>
 warned, this power extracts a price: the loss of referential
 transparency, giving rise to a thicket of questions about sameness and
 change, and the need to abandon the substitution model of evaluation in
 favor of the more intricate environment model.</p><p>
 
-<a name="%_idx_3580" id="%_idx_3580"></a>The central issue lurking beneath the complexity of state, sameness,
+<a id="__idx_3580"></a>The central issue lurking beneath the complexity of state, sameness,
 and change is that by introducing assignment we are forced to admit
 <em>time</em> into our computational models.  Before we introduced
 assignment, all our programs were timeless, in the sense that any
@@ -33,7 +33,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 recall the example of modeling withdrawals from a bank account
 and returning the resulting balance,
 introduced at the beginning of
-section <a href="book-Z-H-20.html#%_sec_3.1.1">3.1.1</a>:</p><p>
+section <a href="book-Z-H-20.html#__sec_3.1.1">3.1.1</a>:</p><p>
 
 </p><p></p><p><tt>(withdraw 25)<br /><i>75</i><br />
 (withdraw 25)<br /><i>50</i><br /></tt></p><p></p><p>
@@ -62,7 +62,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 can provide a speed advantage over sequential computation.  Sequential
 computers execute only one operation at a time, so the amount of time
 it takes to perform a task is proportional to the total number of
-operations performed.<a name="call_footnote_Temp_405" href="#footnote_Temp_405" id="call_footnote_Temp_405"><sup><small>34</small></sup></a>
+operations performed.<a href="#footnote_Temp_405" id="call_footnote_Temp_405"><sup><small>34</small></sup></a>
 However, if it is possible to decompose a problem into pieces that are
 relatively independent and need to communicate only rarely, it may be
 possible to allocate pieces to separate computing processors,
@@ -75,17 +75,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 because our computers do, entails additional complexity in our
 understanding of time.</p><p>
 
-<a name="%_sec_3.4.1" id="%_sec_3.4.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.4.1">3.4.1  The Nature of Time in Concurrent Systems</a></h3><p>
+<a id="__sec_3.4.1"></a>
+</p><h3>3.4.1  The Nature of Time in Concurrent Systems</h3><p>
 
 
-<a name="%_idx_3584" id="%_idx_3584"></a>
+<a id="__idx_3584"></a>
 On the surface, time seems straightforward.  It
-is an ordering imposed on events.<a name="call_footnote_Temp_406" href="#footnote_Temp_406" id="call_footnote_Temp_406"><sup><small>35</small></sup></a>
+is an ordering imposed on events.<a href="#footnote_Temp_406" id="call_footnote_Temp_406"><sup><small>35</small></sup></a>
 For any events <em>A</em> and <em>B</em>, either <em>A</em> occurs before <em>B</em>, <em>A</em> and <em>B</em>
 are simultaneous, or <em>A</em> occurs after <em>B</em>.  For instance,
 returning to the bank account example, suppose that Peter withdraws
-$10 and Paul withdraws $25 from a <a name="%_idx_3588" id="%_idx_3588"></a>joint account that initially
+$10 and Paul withdraws $25 from a <a id="__idx_3588"></a>joint account that initially
 contains $100, leaving $65 in the account.  Depending on the order
 of the two withdrawals, the sequence of balances in the account is
 either $100 ⟶ $90 ⟶ $65 or
@@ -100,14 +100,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 the account will depend critically on the detailed timing of the
 accesses and the details of the communication among the machines.</p><p>
 
-<a name="%_idx_3590" id="%_idx_3590"></a>This indeterminacy in the order of events can pose serious problems in
+<a id="__idx_3590"></a>This indeterminacy in the order of events can pose serious problems in
 the design of concurrent systems.  For instance, suppose that the
 withdrawals made by Peter and Paul are implemented as two separate
 processes sharing a common variable <tt>balance</tt>, each process
 specified by the procedure given in
-section <a href="book-Z-H-20.html#%_sec_3.1.1">3.1.1</a>:
+section <a href="book-Z-H-20.html#__sec_3.1.1">3.1.1</a>:
 
-</p><p></p><p><tt><a name="%_idx_3592" id="%_idx_3592"></a>(define (withdraw amount)<br />
+</p><p></p><p><tt><a id="__idx_3592"></a>(define (withdraw amount)<br />
   (if (&gt;= balance amount)<br />
       (begin (set! balance (- balance amount))<br />
              balance)<br />
@@ -129,7 +129,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 which they access <tt>balance</tt> and set it to the new value.</p><p>
 
 
-The timing diagram in figure <a href="#%_fig_3.29">3.29</a> depicts an order of
+The timing diagram in figure <a href="#__fig_3.29">3.29</a> depicts an order of
 events where <tt>balance</tt> starts at 100, Peter withdraws 10,
 Paul withdraws 25, and yet the final value of <tt>balance</tt> is 75.  As
 shown in the diagram, the reason for this anomaly is that Paul's
@@ -139,10 +139,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 is a catastrophic failure for the banking system, because the total
 amount of money in the system is not conserved.  Before the transactions,
 the total amount of money was $100.  Afterwards, Peter has $10, Paul
-has $25, and the bank has $75.<a name="call_footnote_Temp_407" href="#footnote_Temp_407" id="call_footnote_Temp_407"><sup><small>36</small></sup></a></p><p>
+has $25, and the bank has $75.<a href="#footnote_Temp_407" id="call_footnote_Temp_407"><sup><small>36</small></sup></a></p><p>
 
 
-<a name="%_idx_3596" id="%_idx_3596"></a><a name="%_idx_3598" id="%_idx_3598"></a>The general phenomenon illustrated
+<a id="__idx_3596"></a><a id="__idx_3598"></a>The general phenomenon illustrated
 here is that several processes may share  a
 common state variable.  What makes this complicated is that more than
 one process may be trying to manipulate the shared state at the same
@@ -153,16 +153,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 change, the balance is still what he thought it was.</p><p>
 
 
-<a name="%_sec_Temp_408" id="%_sec_Temp_408"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_408">Correct behavior of concurrent programs</a></h4><p>
+<a id="__sec_Temp_408"></a>
+</p><h4>Correct behavior of concurrent programs</h4><p>
 
-<a name="%_idx_3600" id="%_idx_3600"></a>
+<a id="__idx_3600"></a>
 The above example typifies the subtle bugs that can creep into
 concurrent programs.  The root of this complexity lies in the
 assignments to variables that are shared among the different
 processes.  We already know that we must be careful in writing
 programs that use <tt>set!</tt>, because the results of a computation
-depend on the order in which the assignments occur.<a name="call_footnote_Temp_409" href="#footnote_Temp_409" id="call_footnote_Temp_409"><sup><small>37</small></sup></a>
+depend on the order in which the assignments occur.<a href="#footnote_Temp_409" id="call_footnote_Temp_409"><sup><small>37</small></sup></a>
 With concurrent processes we must be especially careful about
 assignments, because we may not be able to control the order of the
 assignments made by the different processes.  If several such changes
@@ -173,9 +173,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 To make concurrent programs behave correctly, we may have to
 place some restrictions on concurrent execution.</p><p>
 
-<a name="%_fig_3.29" id="%_fig_3.29"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-31.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.29:</b>  Timing diagram showing how interleaving the order of events
+<a id="__fig_3.29"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-31.gif" alt="ch3-Z-G-31" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.29:</b>  Timing diagram showing how interleaving the order of events
 in two banking withdrawals can lead to an incorrect final balance.</div></caption><tr><td>
-<a name="%_idx_3602" id="%_idx_3602"></a>
+<a id="__idx_3602"></a>
 </td></tr></table></div><p>
 
 One possible restriction on concurrency would
@@ -184,10 +184,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 extremely stringent requirement.  For distributed banking, it would
 require the system designer to ensure that only one transaction could
 proceed at a time.  This would be both inefficient and overly
-conservative.  Figure <a href="#%_fig_3.30">3.30</a> shows Peter and
+conservative.  Figure <a href="#__fig_3.30">3.30</a> shows Peter and
 Paul sharing a bank account, where Paul has a private account as well.
 The diagram illustrates two withdrawals from the shared account
-(one by Peter and one by Paul) and a deposit to Paul's private account.<a name="call_footnote_Temp_410" href="#footnote_Temp_410" id="call_footnote_Temp_410"><sup><small>38</small></sup></a>
+(one by Peter and one by Paul) and a deposit to Paul's private account.<a href="#footnote_Temp_410" id="call_footnote_Temp_410"><sup><small>38</small></sup></a>
 The two withdrawals from the shared account must not be
 concurrent (since both access and update the same account), and Paul's
 deposit and withdrawal must not be concurrent (since both access and
@@ -196,7 +196,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 permitting Paul's deposit to his private account to proceed
 concurrently with Peter's withdrawal from the shared account.</p><p>
 
-<a name="%_fig_3.30" id="%_fig_3.30"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-32.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.30:</b>  Concurrent deposits and withdrawals from a joint account
+<a id="__fig_3.30"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-32.gif" alt="ch3-Z-G-32" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.30:</b>  Concurrent deposits and withdrawals from a joint account
 in Bank1 and a private account in Bank2.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
@@ -208,7 +208,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 First, it does not require the processes to actually run sequentially,
 but only to produce results that are the same <em>as if</em> they had run
 sequentially.  For the example in
-figure <a href="#%_fig_3.30">3.30</a>, the designer of the bank account
+figure <a href="#__fig_3.30">3.30</a>, the designer of the bank account
 system can safely allow Paul's deposit and Peter's withdrawal to
 happen concurrently, because the net result will be the same as if the
 two operations had happened sequentially.  Second, there may be more
@@ -219,10 +219,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 with $100, and Peter deposits $40 while Paul concurrently withdraws
 half the money in the account.
 Then sequential execution could result in the account balance being
-either $70 or $90 (see exercise <a href="#%_thm_3.38">3.38</a>).<a name="call_footnote_Temp_411" href="#footnote_Temp_411" id="call_footnote_Temp_411"><sup><small>39</small></sup></a></p><p>
+either $70 or $90 (see exercise <a href="#__thm_3.38">3.38</a>).<a href="#footnote_Temp_411" id="call_footnote_Temp_411"><sup><small>39</small></sup></a></p><p>
 
 There are still weaker requirements for correct execution of
-concurrent programs.  A program for simulating <a name="%_idx_3606" id="%_idx_3606"></a>diffusion (say, the
+concurrent programs.  A program for simulating <a id="__idx_3606"></a>diffusion (say, the
 flow of heat in an object) might consist of a large number of
 processes, each one representing a small volume of space, that update
 their values concurrently.  Each process repeatedly changes its
@@ -232,12 +232,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 operations are done; there is no need for any restrictions on
 concurrent use of the shared values.</p><p>
 
-</p><p><a name="%_thm_3.38" id="%_thm_3.38"></a>
+</p><p><a id="__thm_3.38"></a>
 <b>Exercise 3.38.</b>  Suppose that Peter, Paul, and Mary share a joint bank account that
 initially contains $100.  Concurrently, Peter deposits $10, Paul
 withdraws $20, and Mary withdraws half the money in the account, by
 executing the following commands:
-</p><table border="0"><tr><td valign="top">Peter: </td><td valign="top"><tt>(set! balance (+ balance 10))</tt></td></tr><tr><td valign="top">Paul: </td><td valign="top"><tt>(set! balance (- balance 20))</tt></td></tr><tr><td valign="top">Mary: </td><td valign="top"><tt>(set! balance (- balance (/ balance 2)))</tt>
+</p><table style="border: none;"><tr><td style="text-align: top;">Peter: </td><td style="text-align: top;"><tt>(set! balance (+ balance 10))</tt></td></tr><tr><td style="text-align: top;">Paul: </td><td style="text-align: top;"><tt>(set! balance (- balance 20))</tt></td></tr><tr><td style="text-align: top;">Mary: </td><td style="text-align: top;"><tt>(set! balance (- balance (/ balance 2)))</tt>
 </td></tr></table><p>
 
 </p><p></p><p>a. List all the different possible values for <tt>balance</tt> after these
@@ -246,15 +246,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 
 </p><p></p><p>b. What are some other values
 that could be produced if the system allows the processes to be interleaved?
-Draw timing diagrams like the one in figure <a href="#%_fig_3.29">3.29</a> to
+Draw timing diagrams like the one in figure <a href="#__fig_3.29">3.29</a> to
 explain how these values can occur.
 
 </p><p>
 
-<a name="%_sec_3.4.2" id="%_sec_3.4.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.4.2">3.4.2  Mechanisms for Controlling Concurrency</a></h3><p>
+<a id="__sec_3.4.2"></a>
+</p><h3>3.4.2  Mechanisms for Controlling Concurrency</h3><p>
 
-<a name="%_idx_3608" id="%_idx_3608"></a>
+<a id="__idx_3608"></a>
 We've seen that the difficulty in dealing with concurrent processes is
 rooted in the need to consider the interleaving of the order of events
 in the different processes.  For example, suppose we have two
@@ -283,10 +283,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 behavior is correct.  Many mechanisms have been developed for this
 purpose.  In this section, we describe one of them, the <em>serializer</em>.</p><p>
 
-<a name="%_sec_Temp_413" id="%_sec_Temp_413"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_413">Serializing access to shared state</a></h4><p>
+<a id="__sec_Temp_413"></a>
+</p><h4>Serializing access to shared state</h4><p>
 
-<a name="%_idx_3610" id="%_idx_3610"></a>
+<a id="__idx_3610"></a>
 Serialization implements the following idea: Processes will execute
 concurrently, but there will be certain collections of procedures that
 cannot be executed concurrently.  More precisely, serialization creates
@@ -306,17 +306,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 serializer.  This guarantees that the value of the variable cannot be
 changed between an access and the corresponding assignment.</p><p>
 
-<a name="%_sec_Temp_414" id="%_sec_Temp_414"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_414">Serializers in Scheme</a></h4><p>
+<a id="__sec_Temp_414"></a>
+</p><h4>Serializers in Scheme</h4><p>
 
 To make the above mechanism more concrete, suppose that we have
-extended Scheme to include a procedure called <a name="%_idx_3612" id="%_idx_3612"></a><tt>parallel-execute</tt>:</p><p>
+extended Scheme to include a procedure called <a id="__idx_3612"></a><tt>parallel-execute</tt>:</p><p>
 
 </p><p></p><p><tt>(parallel-execute &lt;<em>p<sub>1</sub></em>&gt; &lt;<em>p<sub>2</sub></em>&gt; <tt>...</tt> &lt;<em>p<sub><em>k</em></sub></em>&gt;)<br /></tt></p><p></p><p>
 Each &lt;<em>p</em>&gt; must be a procedure of no arguments.  <tt>Parallel-execute</tt>
 creates a separate process for each
 &lt;<em>p</em>&gt;, which applies &lt;<em>p</em>&gt; (to no arguments).  These processes all
-run concurrently.<a name="call_footnote_Temp_415" href="#footnote_Temp_415" id="call_footnote_Temp_415"><sup><small>40</small></sup></a></p><p>
+run concurrently.<a href="#footnote_Temp_415" id="call_footnote_Temp_415"><sup><small>40</small></sup></a></p><p>
 
 As an example of how this is used, consider</p><p>
 
@@ -328,11 +328,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 execution is complete, <tt>x</tt> will be left with one of five possible
 values, depending on the interleaving of the events of <em>P</em><sub>1</sub> and
 <em>P</em><sub>2</sub>:
-</p><table border="0"><tr><td valign="top">101: </td><td valign="top"><em>P</em><sub>1</sub> sets <tt>x</tt> to 100 and then <em>P</em><sub>2</sub> increments <tt>x</tt> to 101.</td></tr><tr><td valign="top">121: </td><td valign="top"><em>P</em><sub>2</sub> increments <tt>x</tt> to 11 and then <em>P</em><sub>1</sub> sets <tt>x</tt> to
-<tt>x</tt> times <tt>x</tt>.</td></tr><tr><td valign="top">110: </td><td valign="top"><em>P</em><sub>2</sub> changes <tt>x</tt> from 10 to 11 between the two times that
-<em>P</em><sub>1</sub> accesses the value of <tt>x</tt> during the evaluation of <tt>(* x x)</tt>.</td></tr><tr><td valign="top">11:  </td><td valign="top"><em>P</em><sub>2</sub> accesses <tt>x</tt>, then <em>P</em><sub>1</sub> sets <tt>x</tt> to 100,
-then <em>P</em><sub>2</sub> sets <tt>x</tt>.</td></tr><tr><td valign="top">100: </td><td valign="top"><em>P</em><sub>1</sub> accesses <tt>x</tt> (twice), then <em>P</em><sub>2</sub> sets <tt>x</tt> to 11,
-then <em>P</em><sub>1</sub> sets <tt>x</tt>.</td></tr><tr><td valign="top"></td></tr></table><p>
+</p><table style="border: none;"><tr><td style="text-align: top;">101: </td><td style="text-align: top;"><em>P</em><sub>1</sub> sets <tt>x</tt> to 100 and then <em>P</em><sub>2</sub> increments <tt>x</tt> to 101.</td></tr><tr><td style="text-align: top;">121: </td><td style="text-align: top;"><em>P</em><sub>2</sub> increments <tt>x</tt> to 11 and then <em>P</em><sub>1</sub> sets <tt>x</tt> to
+<tt>x</tt> times <tt>x</tt>.</td></tr><tr><td style="text-align: top;">110: </td><td style="text-align: top;"><em>P</em><sub>2</sub> changes <tt>x</tt> from 10 to 11 between the two times that
+<em>P</em><sub>1</sub> accesses the value of <tt>x</tt> during the evaluation of <tt>(* x x)</tt>.</td></tr><tr><td style="text-align: top;">11:  </td><td style="text-align: top;"><em>P</em><sub>2</sub> accesses <tt>x</tt>, then <em>P</em><sub>1</sub> sets <tt>x</tt> to 100,
+then <em>P</em><sub>2</sub> sets <tt>x</tt>.</td></tr><tr><td style="text-align: top;">100: </td><td style="text-align: top;"><em>P</em><sub>1</sub> accesses <tt>x</tt> (twice), then <em>P</em><sub>2</sub> sets <tt>x</tt> to 11,
+then <em>P</em><sub>1</sub> sets <tt>x</tt>.</td></tr><tr><td style="text-align: top;"></td></tr></table><p>
 
 
 We can constrain the concurrency by using serialized procedures,
@@ -353,11 +353,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 <em>P</em><sub>2</sub> cannot be interleaved.</p><p>
 
 Here is a version of the <tt>make-account</tt> procedure from
-section <a href="book-Z-H-20.html#%_sec_3.1.1">3.1.1</a>, where the deposits and
+section <a href="book-Z-H-20.html#__sec_3.1.1">3.1.1</a>, where the deposits and
 withdrawals have been serialized:</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_3614" id="%_idx_3614"></a><a name="%_idx_3616" id="%_idx_3616"></a>(define (make-account balance)<br />
+</p><p></p><p><tt><a id="__idx_3614"></a><a id="__idx_3616"></a>(define (make-account balance)<br />
   (define (withdraw amount)<br />
     (if (&gt;= balance amount)<br />
         (begin (set! balance (- balance amount))<br />
@@ -376,7 +376,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
     dispatch))<br /></tt></p><p></p><p>
 With this implementation, two processes cannot be withdrawing from or
 depositing into a single account concurrently.  This eliminates the source
-of the error illustrated in figure <a href="#%_fig_3.29">3.29</a>, where Peter
+of the error illustrated in figure <a href="#__fig_3.29">3.29</a>, where Peter
 changes the account balance between the times when Paul accesses the
 balance to compute the new value and when Paul actually performs the
 assignment.  On the other hand, each account has its own serializer,
@@ -384,7 +384,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 concurrently.</p><p>
 
 
-</p><p><a name="%_thm_3.39" id="%_thm_3.39"></a>
+</p><p><a id="__thm_3.39"></a>
 <b>Exercise 3.39.</b>  Which of the five possibilities in the parallel execution shown above
 remain if we instead serialize execution as follows:</p><p>
 
@@ -395,7 +395,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
                   (s (lambda () (set! x (+ x 1)))))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.40" id="%_thm_3.40"></a>
+</p><p><a id="__thm_3.40"></a>
 <b>Exercise 3.40.</b>  Give all possible values of <tt>x</tt> that can result from executing</p><p>
 
 
@@ -412,12 +412,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
                   (s (lambda () (set! x (* x x x)))))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.41" id="%_thm_3.41"></a>
+</p><p><a id="__thm_3.41"></a>
 <b>Exercise 3.41.</b>  Ben Bitdiddle worries that it would be better to implement the bank
 account as follows (where the commented line has been changed):</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_3618" id="%_idx_3618"></a>(define (make-account balance)<br />
+</p><p></p><p><tt><a id="__idx_3618"></a>(define (make-account balance)<br />
   (define (withdraw amount)<br />
     (if (&gt;= balance amount)<br />
         (begin (set! balance (- balance amount))<br />
@@ -441,14 +441,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 demonstrates Ben's concern?
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.42" id="%_thm_3.42"></a>
+</p><p><a id="__thm_3.42"></a>
 <b>Exercise 3.42.</b>  Ben Bitdiddle suggests that it's a waste of time to create a new
 serialized procedure in response to every <tt>withdraw</tt> and <tt>deposit</tt> message.  He says that <tt>make-account</tt> could be changed so
 that the calls to <tt>protected</tt> are done outside the <tt>dispatch</tt>
 procedure.  That is, an account would return the same serialized
 procedure (which was created at the same time as the account) each time
 it is asked for a withdrawal procedure.
-</p><p></p><p><tt><a name="%_idx_3620" id="%_idx_3620"></a>(define (make-account balance)<br />
+</p><p></p><p><tt><a id="__idx_3620"></a>(define (make-account balance)<br />
   (define (withdraw amount)<br />
     (if (&gt;= balance amount)<br />
         (begin (set! balance (- balance amount))<br />
@@ -471,10 +471,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 what concurrency is allowed by these two versions of <tt>make-account</tt> ?
 </p><p>
 
-<a name="%_sec_Temp_420" id="%_sec_Temp_420"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_420">Complexity of using multiple shared resources</a></h4><p>
+<a id="__sec_Temp_420"></a>
+</p><h4>Complexity of using multiple shared resources</h4><p>
 
-<a name="%_idx_3622" id="%_idx_3622"></a><a name="%_idx_3624" id="%_idx_3624"></a>
+<a id="__idx_3622"></a><a id="__idx_3624"></a>
 Serializers provide a powerful abstraction that helps isolate the
 complexities of concurrent programs so that they can be dealt with
 carefully and (hopefully) correctly.  However, while using serializers
@@ -486,9 +486,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 the balances in two bank accounts.  We access each account to find the
 balance, compute the difference between the balances, withdraw this
 difference from one account, and deposit it in the other account.  We
-could implement this as follows:<a name="call_footnote_Temp_421" href="#footnote_Temp_421" id="call_footnote_Temp_421"><sup><small>41</small></sup></a></p><p>
+could implement this as follows:<a href="#footnote_Temp_421" id="call_footnote_Temp_421"><sup><small>41</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_3626" id="%_idx_3626"></a><a name="%_idx_3628" id="%_idx_3628"></a>(define (exchange account1 account2)<br />
+</p><p></p><p><tt><a id="__idx_3626"></a><a id="__idx_3628"></a>(define (exchange account1 account2)<br />
   (let ((difference (- (account1 'balance)<br />
                        (account2 'balance))))<br />
     ((account1 'withdraw) difference)<br />
@@ -505,7 +505,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 produce incorrect results.  For example, Peter might compute the
 difference in the balances for <em>a</em>1 and <em>a</em>2, but then Paul
 might change the balance in <em>a</em>1 before Peter is able to complete
-the exchange.<a name="call_footnote_Temp_422" href="#footnote_Temp_422" id="call_footnote_Temp_422"><sup><small>42</small></sup></a>
+the exchange.<a href="#footnote_Temp_422" id="call_footnote_Temp_422"><sup><small>42</small></sup></a>
 For correct behavior, we must arrange for the <tt>exchange</tt> procedure
 to lock out any other concurrent accesses to the accounts during the
 entire time of the exchange.</p><p>
@@ -517,11 +517,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 breaking the modularity of the bank-account object by exposing the
 serializer.  The following version of <tt>make-account</tt> is identical
 to the original version given in
-section <a href="book-Z-H-20.html#%_sec_3.1.1">3.1.1</a>, except that a serializer is
+section <a href="book-Z-H-20.html#__sec_3.1.1">3.1.1</a>, except that a serializer is
 provided to protect the balance variable, and the serializer is
 exported via message passing:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3630" id="%_idx_3630"></a>(define (make-account-and-serializer balance)<br />
+</p><p></p><p><tt><a id="__idx_3630"></a>(define (make-account-and-serializer balance)<br />
   (define (withdraw amount)<br />
     (if (&gt;= balance amount)<br />
         (begin (set! balance (- balance amount))<br />
@@ -544,9 +544,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 We can use this to do serialized deposits and withdrawals.  However,
 unlike our earlier serialized account, it is now the responsibility of
 each user of bank-account objects to explicitly manage the
-serialization, for example as follows:<a name="call_footnote_Temp_423" href="#footnote_Temp_423" id="call_footnote_Temp_423"><sup><small>43</small></sup></a></p><p>
+serialization, for example as follows:<a href="#footnote_Temp_423" id="call_footnote_Temp_423"><sup><small>43</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_3632" id="%_idx_3632"></a>(define (deposit account amount)<br />
+</p><p></p><p><tt><a id="__idx_3632"></a>(define (deposit account amount)<br />
   (let ((s (account 'serializer))<br />
         (d (account 'deposit)))<br />
     ((s d) amount)))<br /></tt></p><p></p><p></p><p>
@@ -556,20 +556,20 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 serialize the original
 <tt>exchange</tt> procedure with the serializers for both accounts:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3634" id="%_idx_3634"></a>(define (serialized-exchange account1 account2)<br />
+</p><p></p><p><tt><a id="__idx_3634"></a>(define (serialized-exchange account1 account2)<br />
   (let ((serializer1 (account1 'serializer))<br />
         (serializer2 (account2 'serializer)))<br />
     ((serializer1 (serializer2 exchange))<br />
      account1<br />
      account2)))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_3.43" id="%_thm_3.43"></a>
+</p><p><a id="__thm_3.43"></a>
 <b>Exercise 3.43.</b>  Suppose that the balances in three accounts start out as $10, $20,
 and $30, and that multiple processes run, exchanging the balances in
 the accounts.  Argue that if the processes are run sequentially,
 after any number of concurrent exchanges, the account balances should be
 $10, $20, and $30 in some order.
-Draw a timing diagram like the one in figure <a href="#%_fig_3.29">3.29</a> to
+Draw a timing diagram like the one in figure <a href="#__fig_3.29">3.29</a> to
 show how this condition can be violated if the exchanges are
 implemented using the first version of the account-exchange program in
 this section.  On the other hand, argue that even with this <tt>exchange</tt> program, the sum of the balances in the accounts will be
@@ -579,8 +579,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.44" id="%_thm_3.44"></a>
-<b>Exercise 3.44.</b>  <a name="%_idx_3636" id="%_idx_3636"></a>Consider the problem of transferring an amount from one account to
+</p><p><a id="__thm_3.44"></a>
+<b>Exercise 3.44.</b>  <a id="__idx_3636"></a>Consider the problem of transferring an amount from one account to
 another.  Ben Bitdiddle claims that this can be accomplished with the
 following procedure, even if there are multiple people concurrently
 transferring money among multiple accounts, using any account
@@ -600,7 +600,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 </p><p></p><p>
 
 
-</p><p><a name="%_thm_3.45" id="%_thm_3.45"></a>
+</p><p><a id="__thm_3.45"></a>
 <b>Exercise 3.45.</b>  Louis Reasoner thinks our bank-account system is unnecessarily complex and
 error-prone now that deposits and withdrawals aren't automatically serialized.
 He suggests that <tt>make-account-and-serializer</tt> should have
@@ -636,22 +636,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 
 </p><p>
 
-<a name="%_sec_Temp_427" id="%_sec_Temp_427"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_427">Implementing serializers</a></h4><p>
+<a id="__sec_Temp_427"></a>
+</p><h4>Implementing serializers</h4><p>
 
-<a name="%_idx_3638" id="%_idx_3638"></a>
+<a id="__idx_3638"></a>
 We implement serializers in terms of a more primitive synchronization
-mechanism called a <a name="%_idx_3640" id="%_idx_3640"></a><em>mutex</em>.  A mutex is an object that supports
-two operations – the mutex can be <a name="%_idx_3642" id="%_idx_3642"></a><em>acquired</em>, and the mutex can be
-<a name="%_idx_3644" id="%_idx_3644"></a><em>released</em>.  Once a mutex has been acquired, no other acquire
-operations on that mutex may proceed until the mutex is released.<a name="call_footnote_Temp_428" href="#footnote_Temp_428" id="call_footnote_Temp_428"><sup><small>44</small></sup></a> In our implementation, each
+mechanism called a <a id="__idx_3640"></a><em>mutex</em>.  A mutex is an object that supports
+two operations – the mutex can be <a id="__idx_3642"></a><em>acquired</em>, and the mutex can be
+<a id="__idx_3644"></a><em>released</em>.  Once a mutex has been acquired, no other acquire
+operations on that mutex may proceed until the mutex is released.<a href="#footnote_Temp_428" id="call_footnote_Temp_428"><sup><small>44</small></sup></a> In our implementation, each
 serializer has an associated mutex.  Given a procedure <tt>p</tt>, the
 serializer returns a procedure that acquires the mutex, runs <tt>p</tt>,
 and then releases the mutex.  This ensures that only one of the
 procedures produced by the serializer can be running at once, which is
 precisely the serialization property that we need to guarantee.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3660" id="%_idx_3660"></a>(define (make-serializer)<br />
+</p><p></p><p><tt><a id="__idx_3660"></a>(define (make-serializer)<br />
   (let ((mutex (make-mutex)))<br />
     (lambda (p)<br />
       (define (serialized-p . args)<br />
@@ -662,7 +662,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
       serialized-p)))<br /></tt></p><p></p><p></p><p>
 
 The mutex is a mutable object (here we'll use a one-element
-list, which we'll refer to as a <a name="%_idx_3662" id="%_idx_3662"></a><em>cell</em>) that can hold the value
+list, which we'll refer to as a <a id="__idx_3662"></a><em>cell</em>) that can hold the value
 true or false.  When the value is false, the mutex is available to be
 acquired.  When the value is true, the mutex is unavailable, and any
 process that attempts to acquire the mutex must wait.</p><p>
@@ -671,10 +671,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 contents to false.  To acquire the mutex, we test the cell.  If the
 mutex is available, we set the cell contents to true and proceed.
 Otherwise, we wait in a loop, attempting to acquire over and over
-again, until we find that the mutex is available.<a name="call_footnote_Temp_429" href="#footnote_Temp_429" id="call_footnote_Temp_429"><sup><small>45</small></sup></a>  To release the
+again, until we find that the mutex is available.<a href="#footnote_Temp_429" id="call_footnote_Temp_429"><sup><small>45</small></sup></a>  To release the
 mutex, we set the cell contents to false.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3668" id="%_idx_3668"></a>(define (make-mutex)<br />
+</p><p></p><p><tt><a id="__idx_3668"></a>(define (make-mutex)<br />
   (let ((cell (list false)))            <br />
     (define (the-mutex m)<br />
       (cond ((eq? m 'acquire)<br />
@@ -690,7 +690,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 the cell contents to true before returning false.  We can express this
 behavior as the following procedure:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3670" id="%_idx_3670"></a>(define (test-and-set! cell)<br />
+</p><p></p><p><tt><a id="__idx_3670"></a>(define (test-and-set! cell)<br />
   (if (car cell)<br />
       true<br />
       (begin (set-car! cell true)<br />
@@ -698,36 +698,36 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 
 However, this implementation of <tt>test-and-set!</tt> does not suffice
 as it stands.  There is a crucial subtlety here, which is the
-essential place where concurrency control enters the system: The <tt>test-and-set!</tt> operation must be performed <a name="%_idx_3672" id="%_idx_3672"></a><em>atomically</em>.  That
+essential place where concurrency control enters the system: The <tt>test-and-set!</tt> operation must be performed <a id="__idx_3672"></a><em>atomically</em>.  That
 is, we must guarantee that, once a process has tested the cell and
 found it to be false, the cell contents will actually be set to true
 before any other process can test the cell.  If we do not make this
 guarantee, then the mutex can fail in a way similar to the
-bank-account failure in figure <a href="#%_fig_3.29">3.29</a>.  (See
-exercise <a href="#%_thm_3.46">3.46</a>.)</p><p>
+bank-account failure in figure <a href="#__fig_3.29">3.29</a>.  (See
+exercise <a href="#__thm_3.46">3.46</a>.)</p><p>
 
 The actual implementation of <tt>test-and-set!</tt> depends on the
 details of how our system runs concurrent processes.  For example, we
 might be executing concurrent processes on a sequential processor
-using a <a name="%_idx_3674" id="%_idx_3674"></a>time-slicing mechanism that cycles through the processes,
+using a <a id="__idx_3674"></a>time-slicing mechanism that cycles through the processes,
 permitting each process to run for a short time before interrupting it
 and moving on to the next process.  In that case, <tt>test-and-set!</tt>
-can work by disabling time slicing during the testing and setting.<a name="call_footnote_Temp_430" href="#footnote_Temp_430" id="call_footnote_Temp_430"><sup><small>46</small></sup></a>
+can work by disabling time slicing during the testing and setting.<a href="#footnote_Temp_430" id="call_footnote_Temp_430"><sup><small>46</small></sup></a>
 Alternatively, multiprocessing computers provide instructions that
-support atomic operations directly in hardware.<a name="call_footnote_Temp_431" href="#footnote_Temp_431" id="call_footnote_Temp_431"><sup><small>47</small></sup></a></p><p>
+support atomic operations directly in hardware.<a href="#footnote_Temp_431" id="call_footnote_Temp_431"><sup><small>47</small></sup></a></p><p>
 
-</p><p><a name="%_thm_3.46" id="%_thm_3.46"></a>
+</p><p><a id="__thm_3.46"></a>
 <b>Exercise 3.46.</b>  Suppose that we implement <tt>test-and-set!</tt>  using an ordinary
 procedure as shown in the text, without attempting to make the operation
 atomic.  Draw a timing diagram like the one in
-figure <a href="#%_fig_3.29">3.29</a> to demonstrate how the mutex
+figure <a href="#__fig_3.29">3.29</a> to demonstrate how the mutex
 implementation can fail by allowing two processes to acquire the mutex
 at the same time.
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.47" id="%_thm_3.47"></a>
-<b>Exercise 3.47.</b>  <a name="%_idx_3692" id="%_idx_3692"></a>A semaphore (of size <em>n</em>) is a generalization of a mutex.  Like a
+</p><p><a id="__thm_3.47"></a>
+<b>Exercise 3.47.</b>  <a id="__idx_3692"></a>A semaphore (of size <em>n</em>) is a generalization of a mutex.  Like a
 mutex, a semaphore supports acquire and release operations, but it is
 more general in that up to <em>n</em> processes can acquire it
 concurrently.  Additional processes that attempt to acquire the
@@ -740,10 +740,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 
 </p><p>
 
-<a name="%_sec_Temp_434" id="%_sec_Temp_434"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_434">Deadlock</a></h4><p>
+<a id="__sec_Temp_434"></a>
+</p><h4>Deadlock</h4><p>
 
-<a name="%_idx_3694" id="%_idx_3694"></a><a name="%_idx_3696" id="%_idx_3696"></a>
+<a id="__idx_3694"></a><a id="__idx_3696"></a>
 Now that we have seen how to implement serializers, we can see
 that account exchanging still has a problem, even with the
 <tt>serialized-exchange</tt> procedure above.
@@ -759,17 +759,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 forever, waiting for the other.  This situation is called a <em>deadlock</em>.  Deadlock is always a danger in systems that provide
 concurrent access to multiple shared resources.</p><p>
 
-<a name="%_idx_3698" id="%_idx_3698"></a>One way to avoid the deadlock in this situation is to give each
+<a id="__idx_3698"></a>One way to avoid the deadlock in this situation is to give each
 account a unique identification number and rewrite <tt>serialized-exchange</tt> so
 that a process will always attempt to enter a procedure protecting the
 lowest-numbered account first.  Although this method works well for
 the exchange problem, there are other situations that require more
 sophisticated deadlock-avoidance techniques, or where deadlock cannot
-be avoided at all.  (See exercises <a href="#%_thm_3.48">3.48</a>
-and <a href="#%_thm_3.49">3.49</a>.)<a name="call_footnote_Temp_435" href="#footnote_Temp_435" id="call_footnote_Temp_435"><sup><small>48</small></sup></a></p><p>
+be avoided at all.  (See exercises <a href="#__thm_3.48">3.48</a>
+and <a href="#__thm_3.49">3.49</a>.)<a href="#footnote_Temp_435" id="call_footnote_Temp_435"><sup><small>48</small></sup></a></p><p>
 
-</p><p><a name="%_thm_3.48" id="%_thm_3.48"></a>
-<b>Exercise 3.48.</b>  <a name="%_idx_3708" id="%_idx_3708"></a>Explain in detail why the deadlock-avoidance method described above,
+</p><p><a id="__thm_3.48"></a>
+<b>Exercise 3.48.</b>  <a id="__idx_3708"></a>Explain in detail why the deadlock-avoidance method described above,
 (i.e., the accounts are numbered, and each process attempts to acquire
 the smaller-numbered account first) avoids deadlock in the exchange
 problem.  Rewrite <tt>serialized-exchange</tt> to incorporate this idea.
@@ -780,7 +780,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.49" id="%_thm_3.49"></a>
+</p><p><a id="__thm_3.49"></a>
 <b>Exercise 3.49.</b>  Give a scenario where the deadlock-avoidance mechanism described
 above does not work.  (Hint: In the exchange problem, each process
 knows in advance which accounts it will need to get access to.  Consider a
@@ -790,8 +790,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 </p><p>
 </p><p>
 
-<a name="%_sec_Temp_438" id="%_sec_Temp_438"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_438">Concurrency, time, and communication</a></h4><p>
+<a id="__sec_Temp_438"></a>
+</p><h4>Concurrency, time, and communication</h4><p>
 
 We've seen how programming concurrent systems requires controlling the
 ordering of events when different processes access shared
@@ -807,7 +807,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 the contents of memory
 may not be in a consistent state at every instant.  In contemporary
 multiprocessing systems, therefore, the serializer paradigm is being
-supplanted by new approaches to concurrency control.<a name="call_footnote_Temp_439" href="#footnote_Temp_439" id="call_footnote_Temp_439"><sup><small>49</small></sup></a></p><p>
+supplanted by new approaches to concurrency control.<a href="#footnote_Temp_439" id="call_footnote_Temp_439"><sup><small>49</small></sup></a></p><p>
 
 
 The problematic aspects of shared state also arise
@@ -830,15 +830,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 and the “state” of the account immediately after synchronization.
 Questions about the
 “real” account balance or the order of events between synchronizations
-may be irrelevant or meaningless.<a name="call_footnote_Temp_440" href="#footnote_Temp_440" id="call_footnote_Temp_440"><sup><small>50</small></sup></a></p><p>
+may be irrelevant or meaningless.<a href="#footnote_Temp_440" id="call_footnote_Temp_440"><sup><small>50</small></sup></a></p><p>
 
 
-<a name="%_idx_3720" id="%_idx_3720"></a>The basic phenomenon here is that synchronizing different processes,
+<a id="__idx_3720"></a>The basic phenomenon here is that synchronizing different processes,
 establishing shared state, or imposing an order on events requires
 communication among the processes.  In essence, any notion of time in
-concurrency control must be intimately tied to communication.<a name="call_footnote_Temp_441" href="#footnote_Temp_441" id="call_footnote_Temp_441"><sup><small>51</small></sup></a>  It is
+concurrency control must be intimately tied to communication.<a href="#footnote_Temp_441" id="call_footnote_Temp_441"><sup><small>51</small></sup></a>  It is
 intriguing that a similar connection between time and communication
-also arises in the <a name="%_idx_3724" id="%_idx_3724"></a>Theory of Relativity, where the speed of light (the
+also arises in the <a id="__idx_3724"></a>Theory of Relativity, where the speed of light (the
 fastest signal that can be used to synchronize events) is a
 fundamental constant relating time and space.  The
 complexities we encounter in dealing with time and state in our
@@ -847,17 +847,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 </p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_405" href="#call_footnote_Temp_405" id="footnote_Temp_405"><sup><small>34</small></sup></a> Most real processors actually execute a few
-operations at a time, following a strategy called <a name="%_idx_3582" id="%_idx_3582"></a><em>pipelining</em>.  Although this technique greatly improves the effective
+</p><div class="footnote"><p><a href="#call_footnote_Temp_405" id="footnote_Temp_405"><sup><small>34</small></sup></a> Most real processors actually execute a few
+operations at a time, following a strategy called <a id="__idx_3582"></a><em>pipelining</em>.  Although this technique greatly improves the effective
 utilization of the hardware, it is used only to speed up the execution
 of a sequential instruction stream, while retaining the behavior of
 the sequential program.
 
-</p><p><a name="footnote_Temp_406" href="#call_footnote_Temp_406" id="footnote_Temp_406"><sup><small>35</small></sup></a> To quote some graffiti seen on a Cambridge
-<a name="%_idx_3586" id="%_idx_3586"></a>building wall: “Time is a device that was invented to keep everything
+</p><p><a href="#call_footnote_Temp_406" id="footnote_Temp_406"><sup><small>35</small></sup></a> To quote some graffiti seen on a Cambridge
+<a id="__idx_3586"></a>building wall: “Time is a device that was invented to keep everything
 from happening at once.”
 
-</p><p><a name="footnote_Temp_407" href="#call_footnote_Temp_407" id="footnote_Temp_407"><sup><small>36</small></sup></a> An even worse failure for this system
+</p><p><a href="#call_footnote_Temp_407" id="footnote_Temp_407"><sup><small>36</small></sup></a> An even worse failure for this system
 could occur if the two <tt>set!</tt> operations attempt to change the
 balance simultaneously, in which case the actual data appearing in
 memory might end up being a random combination of the information
@@ -865,74 +865,74 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 the primitive memory-write operations, which protect against such
 simultaneous access.  Even this seemingly simple kind of protection,
 however, raises implementation challenges in the design of
-multiprocessing computers, where elaborate <a name="%_idx_3594" id="%_idx_3594"></a><em>cache-coherence</em>
+multiprocessing computers, where elaborate <a id="__idx_3594"></a><em>cache-coherence</em>
 protocols are required to ensure that the various processors will
 maintain a consistent view of memory contents, despite the fact that
 data may be replicated (“cached”) among the different processors to
 increase the speed of memory access.
 
-</p><p><a name="footnote_Temp_409" href="#call_footnote_Temp_409" id="footnote_Temp_409"><sup><small>37</small></sup></a> The factorial program in
-section <a href="book-Z-H-20.html#%_sec_3.1.3">3.1.3</a> illustrates this for a single
+</p><p><a href="#call_footnote_Temp_409" id="footnote_Temp_409"><sup><small>37</small></sup></a> The factorial program in
+section <a href="book-Z-H-20.html#__sec_3.1.3">3.1.3</a> illustrates this for a single
 sequential process.
 
-</p><p><a name="footnote_Temp_410" href="#call_footnote_Temp_410" id="footnote_Temp_410"><sup><small>38</small></sup></a> The columns show the contents of Peter's wallet,
+</p><p><a href="#call_footnote_Temp_410" id="footnote_Temp_410"><sup><small>38</small></sup></a> The columns show the contents of Peter's wallet,
 the joint account (in Bank1), Paul's wallet, and Paul's private account
 (in Bank2), before and after each withdrawal (W) and deposit (D).
 Peter withdraws $10 from Bank1; Paul deposits $5 in Bank2,
 then withdraws $25 from Bank1.
 
-</p><p><a name="footnote_Temp_411" href="#call_footnote_Temp_411" id="footnote_Temp_411"><sup><small>39</small></sup></a> A more formal way to express this idea is to say that
-concurrent programs are inherently <a name="%_idx_3604" id="%_idx_3604"></a><em>nondeterministic</em>. That
+</p><p><a href="#call_footnote_Temp_411" id="footnote_Temp_411"><sup><small>39</small></sup></a> A more formal way to express this idea is to say that
+concurrent programs are inherently <a id="__idx_3604"></a><em>nondeterministic</em>. That
 is, they are described not by single-valued functions, but by
 functions whose results are sets of possible values.  In
-section <a href="book-Z-H-28.html#%_sec_4.3">4.3</a> we will study a
+section <a href="book-Z-H-28.html#__sec_4.3">4.3</a> we will study a
 language for expressing nondeterministic
 computations.
 
-</p><p><a name="footnote_Temp_415" href="#call_footnote_Temp_415" id="footnote_Temp_415"><sup><small>40</small></sup></a> <tt>Parallel-execute</tt> is not part of standard Scheme, but
+</p><p><a href="#call_footnote_Temp_415" id="footnote_Temp_415"><sup><small>40</small></sup></a> <tt>Parallel-execute</tt> is not part of standard Scheme, but
 it can be implemented in MIT Scheme.  In our implementation, the
 new concurrent processes also run concurrently with the original
 Scheme process.  Also, in our implementation, the value returned
 by <tt>parallel-execute</tt> is a special control object that can be used
 to halt the newly created processes.
 
-</p><p><a name="footnote_Temp_421" href="#call_footnote_Temp_421" id="footnote_Temp_421"><sup><small>41</small></sup></a> We have simplified <tt>exchange</tt> by exploiting the fact
+</p><p><a href="#call_footnote_Temp_421" id="footnote_Temp_421"><sup><small>41</small></sup></a> We have simplified <tt>exchange</tt> by exploiting the fact
 that our <tt>deposit</tt> message accepts negative amounts.  (This is a
 serious bug in our banking system!)
 
-</p><p><a name="footnote_Temp_422" href="#call_footnote_Temp_422" id="footnote_Temp_422"><sup><small>42</small></sup></a> If the account balances start out as $10,
+</p><p><a href="#call_footnote_Temp_422" id="footnote_Temp_422"><sup><small>42</small></sup></a> If the account balances start out as $10,
 $20, and $30, then after any number of concurrent exchanges, the
 balances should still be $10, $20, and
 $30 in some order.  Serializing the deposits to individual accounts is not
-sufficient to guarantee this.  See exercise <a href="#%_thm_3.43">3.43</a>.
+sufficient to guarantee this.  See exercise <a href="#__thm_3.43">3.43</a>.
 
-</p><p><a name="footnote_Temp_423" href="#call_footnote_Temp_423" id="footnote_Temp_423"><sup><small>43</small></sup></a> Exercise <a href="#%_thm_3.45">3.45</a> investigates why
+</p><p><a href="#call_footnote_Temp_423" id="footnote_Temp_423"><sup><small>43</small></sup></a> Exercise <a href="#__thm_3.45">3.45</a> investigates why
 deposits and withdrawals are no longer automatically serialized
 by the account.
 
-</p><p><a name="footnote_Temp_428" href="#call_footnote_Temp_428" id="footnote_Temp_428"><sup><small>44</small></sup></a> The term “mutex” is an abbreviation for <a name="%_idx_3646" id="%_idx_3646"></a><em>mutual
+</p><p><a href="#call_footnote_Temp_428" id="footnote_Temp_428"><sup><small>44</small></sup></a> The term “mutex” is an abbreviation for <a id="__idx_3646"></a><em>mutual
 exclusion</em>.  The general problem of arranging a mechanism that permits
 concurrent processes to safely share resources is called the mutual
-exclusion problem.  Our mutex is a simple variant of the <a name="%_idx_3648" id="%_idx_3648"></a><em>semaphore</em> mechanism (see exercise <a href="#%_thm_3.47">3.47</a>), which was
-introduced in the <a name="%_idx_3650" id="%_idx_3650"></a>“THE” Multiprogramming System developed at the
-<a name="%_idx_3652" id="%_idx_3652"></a>Technological University of Eindhoven and named for the university's
+exclusion problem.  Our mutex is a simple variant of the <a id="__idx_3648"></a><em>semaphore</em> mechanism (see exercise <a href="#__thm_3.47">3.47</a>), which was
+introduced in the <a id="__idx_3650"></a>“THE” Multiprogramming System developed at the
+<a id="__idx_3652"></a>Technological University of Eindhoven and named for the university's
 initials in Dutch (Dijkstra 1968a).  The acquire and
-release operations were originally called <a name="%_idx_3654" id="%_idx_3654"></a><a name="%_idx_3656" id="%_idx_3656"></a><a name="%_idx_3658" id="%_idx_3658"></a>P and V, from the Dutch
+release operations were originally called <a id="__idx_3654"></a><a id="__idx_3656"></a><a id="__idx_3658"></a>P and V, from the Dutch
 words <em>passeren</em> (to pass) and <em>vrijgeven</em> (to release), in
 reference to the semaphores used on railroad systems.  Dijkstra's
 classic exposition (1968b) was one of the first to clearly present the
 issues of concurrency control, and showed how to use semaphores to
 handle a variety of concurrency problems.
 
-</p><p><a name="footnote_Temp_429" href="#call_footnote_Temp_429" id="footnote_Temp_429"><sup><small>45</small></sup></a> In most
-time-shared operating systems, processes that are <a name="%_idx_3664" id="%_idx_3664"></a>blocked by a mutex do
-<a name="%_idx_3666" id="%_idx_3666"></a>not waste time “busy-waiting” as above.  Instead, the system
+</p><p><a href="#call_footnote_Temp_429" id="footnote_Temp_429"><sup><small>45</small></sup></a> In most
+time-shared operating systems, processes that are <a id="__idx_3664"></a>blocked by a mutex do
+<a id="__idx_3666"></a>not waste time “busy-waiting” as above.  Instead, the system
 schedules another process to run while the first is waiting, and the blocked
 process is awakened when the mutex becomes available.
 
-</p><p><a name="footnote_Temp_430" href="#call_footnote_Temp_430" id="footnote_Temp_430"><sup><small>46</small></sup></a> In MIT Scheme for a single processor, which uses a time-slicing
+</p><p><a href="#call_footnote_Temp_430" id="footnote_Temp_430"><sup><small>46</small></sup></a> In MIT Scheme for a single processor, which uses a time-slicing
 model, <tt>test-and-set!</tt> can be implemented as follows:
-<a name="%_idx_3676" id="%_idx_3676"></a><a name="%_idx_3678" id="%_idx_3678"></a></p><p></p><p><tt><a name="%_idx_3680" id="%_idx_3680"></a>(define (test-and-set! cell)<br />
+<a id="__idx_3676"></a><a id="__idx_3678"></a></p><p></p><p><tt><a id="__idx_3680"></a>(define (test-and-set! cell)<br />
   (without-interrupts<br />
    (lambda ()<br />
      (if (car cell)<br />
@@ -942,8 +942,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 <tt>Without-interrupts</tt> disables
 time-slicing interrupts while its procedure argument is being executed.
 
-</p><p><a name="footnote_Temp_431" href="#call_footnote_Temp_431" id="footnote_Temp_431"><sup><small>47</small></sup></a> There are many variants of such
-<a name="%_idx_3682" id="%_idx_3682"></a>instructions – including test-and-set, test-and-clear, swap,
+</p><p><a href="#call_footnote_Temp_431" id="footnote_Temp_431"><sup><small>47</small></sup></a> There are many variants of such
+<a id="__idx_3682"></a>instructions – including test-and-set, test-and-clear, swap,
 compare-and-exchange, load-reserve, and store-conditional – whose
 design must be carefully matched to the machine's processor-memory
 interface.
@@ -952,42 +952,42 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the
 at exactly the same time by using such an instruction.
 This requires some mechanism
 for making a decision about which process gets control.  Such a
-mechanism is called an <a name="%_idx_3684" id="%_idx_3684"></a><em>arbiter</em>.  Arbiters usually boil down to
+mechanism is called an <a id="__idx_3684"></a><em>arbiter</em>.  Arbiters usually boil down to
 some sort of hardware device.
 Unfortunately, it is possible to prove that one cannot physically
 construct a fair arbiter that works 100% of the time unless one
 allows the arbiter an arbitrarily long time to make its decision.  The
 fundamental phenomenon here was originally observed by the fourteenth-century
-French philosopher <a name="%_idx_3686" id="%_idx_3686"></a>Jean Buridan in his commentary on
-<a name="%_idx_3688" id="%_idx_3688"></a>Aristotle's <i>De caelo</i>.  Buridan argued that a perfectly rational
-<a name="%_idx_3690" id="%_idx_3690"></a>dog placed between two equally attractive sources of food will starve
+French philosopher <a id="__idx_3686"></a>Jean Buridan in his commentary on
+<a id="__idx_3688"></a>Aristotle's <i>De caelo</i>.  Buridan argued that a perfectly rational
+<a id="__idx_3690"></a>dog placed between two equally attractive sources of food will starve
 to death, because it is incapable of deciding which to go to first.
 
-</p><p><a name="footnote_Temp_435" href="#call_footnote_Temp_435" id="footnote_Temp_435"><sup><small>48</small></sup></a> The general technique for avoiding deadlock by numbering the
-<a name="%_idx_3700" id="%_idx_3700"></a>shared resources and acquiring them in order is due to <a name="%_idx_3702" id="%_idx_3702"></a><a name="%_idx_3704" id="%_idx_3704"></a><a name="%_idx_3706" id="%_idx_3706"></a>Havender
+</p><p><a href="#call_footnote_Temp_435" id="footnote_Temp_435"><sup><small>48</small></sup></a> The general technique for avoiding deadlock by numbering the
+<a id="__idx_3700"></a>shared resources and acquiring them in order is due to <a id="__idx_3702"></a><a id="__idx_3704"></a><a id="__idx_3706"></a>Havender
 (1968).  Situations where deadlock cannot be avoided require <em>deadlock-recovery</em> methods, which entail having processes “back out”
 of the deadlocked state and try again.  Deadlock-recovery
 mechanisms are widely used in database management systems, a topic that
 is treated in detail in Gray and Reuter 1993.
 
-</p><p><a name="footnote_Temp_439" href="#call_footnote_Temp_439" id="footnote_Temp_439"><sup><small>49</small></sup></a> One such alternative to serialization is called <a name="%_idx_3710" id="%_idx_3710"></a><em>barrier
+</p><p><a href="#call_footnote_Temp_439" id="footnote_Temp_439"><sup><small>49</small></sup></a> One such alternative to serialization is called <a id="__idx_3710"></a><em>barrier
 synchronization</em>.  The programmer permits concurrent processes to
 execute as they please, but establishes certain synchronization points
 (“barriers”) through which no process can proceed until all the
 processes have reached the barrier.  Modern processors provide machine
 instructions that permit programmers to establish synchronization
-points at places where consistency is required.  The <a name="%_idx_3712" id="%_idx_3712"></a>PowerPC<sup><em>T</em><em>M</em></sup>, for example, includes for this purpose two instructions called
-<a name="%_idx_3714" id="%_idx_3714"></a>SYNC and <a name="%_idx_3716" id="%_idx_3716"></a>EIEIO (Enforced In-order Execution of Input/Output).
+points at places where consistency is required.  The <a id="__idx_3712"></a>PowerPC<sup><em>T</em><em>M</em></sup>, for example, includes for this purpose two instructions called
+<a id="__idx_3714"></a>SYNC and <a id="__idx_3716"></a>EIEIO (Enforced In-order Execution of Input/Output).
 
-</p><p><a name="footnote_Temp_440" href="#call_footnote_Temp_440" id="footnote_Temp_440"><sup><small>50</small></sup></a> This may seem like a strange point of view, but there are
-<a name="%_idx_3718" id="%_idx_3718"></a>systems that work this way.  International charges to credit-card
+</p><p><a href="#call_footnote_Temp_440" id="footnote_Temp_440"><sup><small>50</small></sup></a> This may seem like a strange point of view, but there are
+<a id="__idx_3718"></a>systems that work this way.  International charges to credit-card
 accounts, for example, are normally cleared on a per-country basis,
 and the charges made in different countries are periodically
 reconciled.  Thus the account balance may be different in
 different countries.
 
-</p><p><a name="footnote_Temp_441" href="#call_footnote_Temp_441" id="footnote_Temp_441"><sup><small>51</small></sup></a> For distributed
-systems, this perspective was pursued by <a name="%_idx_3722" id="%_idx_3722"></a>Lamport (1978), who showed how
+</p><p><a href="#call_footnote_Temp_441" id="footnote_Temp_441"><sup><small>51</small></sup></a> For distributed
+systems, this perspective was pursued by <a id="__idx_3722"></a>Lamport (1978), who showed how
 to use communication to establish “global clocks” that can be used
 to establish orderings on events in distributed systems.
 
diff --git a/src/OEBPS/book-Z-H-24.html b/src/OEBPS/book-Z-H-24.html
index dbccd1b..f1b79aa 100644
--- a/src/OEBPS/book-Z-H-24.html
+++ b/src/OEBPS/book-Z-H-24.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,11 +13,11 @@
 
 
 
-<a name="%_sec_3.5" id="%_sec_3.5"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
+<a id="__sec_3.5"></a>
+<h2>3.5  Streams</h2><p>
 
 
-<a name="%_idx_3726" id="%_idx_3726"></a>
+<a id="__idx_3726"></a>
 We've gained a good understanding of assignment as a tool in modeling,
 as well as an appreciation of the complex problems that assignment
 raises. It is time to ask whether we could have gone about things in a
@@ -43,7 +43,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 time <em>x</em>(<em>t</em>).  If we concentrate on <em>x</em> instant by instant, we think of
 it as a changing quantity.  Yet if we concentrate on the entire
 time history of values, we do not emphasize change – the function
-itself does not change.<a name="call_footnote_Temp_442" href="#footnote_Temp_442" id="call_footnote_Temp_442"><sup><small>52</small></sup></a></p><p>
+itself does not change.<a href="#footnote_Temp_442" id="call_footnote_Temp_442"><sup><small>52</small></sup></a></p><p>
 
 If time is measured in discrete steps, then we can model a time function as
 a (possibly infinite) sequence.  In this section, we will see how to
@@ -52,9 +52,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 data structures called <em>streams</em>.  From an abstract point of view,
 a stream is simply a sequence.  However, we will find that the
 straightforward implementation of streams as lists (as in
-section <a href="book-Z-H-15.html#%_sec_2.2.1">2.2.1</a>) doesn't fully reveal
+section <a href="book-Z-H-15.html#__sec_2.2.1">2.2.1</a>) doesn't fully reveal
 the power of stream processing.  As an alternative, we introduce the
-technique of <a name="%_idx_3730" id="%_idx_3730"></a><em>delayed evaluation</em>, which enables us to represent
+technique of <a id="__idx_3730"></a><em>delayed evaluation</em>, which enables us to represent
 very large (even infinite) sequences as streams.</p><p>
 
 Stream processing lets us model systems that have state without ever
@@ -65,12 +65,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 of which modeling technique leads to more modular and more easily
 maintained systems remains open.</p><p>
 
-<a name="%_sec_3.5.1" id="%_sec_3.5.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.5.1">3.5.1  Streams Are Delayed Lists</a></h3><p>
+<a id="__sec_3.5.1"></a>
+</p><h3>3.5.1  Streams Are Delayed Lists</h3><p>
 
 
-<a name="%_idx_3732" id="%_idx_3732"></a>
-As we saw in section <a href="book-Z-H-15.html#%_sec_2.2.3">2.2.3</a>,
+<a id="__idx_3732"></a>
+As we saw in section <a href="book-Z-H-15.html#__sec_2.2.3">2.2.3</a>,
 sequences can serve as standard interfaces for combining program
 modules.  We formulated powerful abstractions for manipulating
 sequences, such as <tt>map</tt>, <tt>filter</tt>, and <tt>accumulate</tt>, that
@@ -86,18 +86,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 
 To see why this is true, let us compare two programs for computing the
 sum of all the prime numbers in an interval.  The first program is
-written in standard iterative style:<a name="call_footnote_Temp_443" href="#footnote_Temp_443" id="call_footnote_Temp_443"><sup><small>53</small></sup></a></p><p>
+written in standard iterative style:<a href="#footnote_Temp_443" id="call_footnote_Temp_443"><sup><small>53</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_3734" id="%_idx_3734"></a>(define (sum-primes a b)<br />
+</p><p></p><p><tt><a id="__idx_3734"></a>(define (sum-primes a b)<br />
   (define (iter count accum)<br />
     (cond ((&gt; count b) accum)<br />
           ((prime? count) (iter (+ count 1) (+ count accum)))<br />
           (else (iter (+ count 1) accum))))<br />
   (iter a 0))<br /></tt></p><p></p><p>
 The second program performs the same computation using the sequence
-operations of section <a href="book-Z-H-15.html#%_sec_2.2.3">2.2.3</a>:</p><p>
+operations of section <a href="book-Z-H-15.html#__sec_2.2.3">2.2.3</a>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3736" id="%_idx_3736"></a>(define (sum-primes a b)<br />
+</p><p></p><p><tt><a id="__idx_3736"></a>(define (sum-primes a b)<br />
   (accumulate +<br />
               0<br />
               (filter prime? (enumerate-interval a b))))<br /></tt></p><p></p><p></p><p>
@@ -143,35 +143,35 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 
 On the surface, streams are just lists with different names for the
 procedures that manipulate them.  There is a constructor,
-<a name="%_idx_3738" id="%_idx_3738"></a><tt>cons-stream</tt>, and two selectors, <a name="%_idx_3740" id="%_idx_3740"></a><tt>stream-car</tt> and <a name="%_idx_3742" id="%_idx_3742"></a><tt>stream-cdr</tt>, which satisfy the constraints</p>
+<a id="__idx_3738"></a><tt>cons-stream</tt>, and two selectors, <a id="__idx_3740"></a><tt>stream-car</tt> and <a id="__idx_3742"></a><tt>stream-cdr</tt>, which satisfy the constraints</p>
 
 <p>
     <code>(stream-car (cons-stream x y)) = x</code><br/>
     <code>(stream-cdr (cons-stream x y)) = y</code>
 </p>
 
-<p>There is a distinguishable object, <a name="%_idx_3744" id="%_idx_3744"></a><a name="%_idx_3746" id="%_idx_3746"></a><a name="%_idx_3748" id="%_idx_3748"></a><tt>the-empty-stream</tt>, which
+<p>There is a distinguishable object, <a id="__idx_3744"></a><a id="__idx_3746"></a><a id="__idx_3748"></a><tt>the-empty-stream</tt>, which
 cannot be the result of any <tt>cons-stream</tt> operation, and which can
-be identified with the predicate <a name="%_idx_3750" id="%_idx_3750"></a><tt>stream-null?</tt>.<a name="call_footnote_Temp_444" href="#footnote_Temp_444" id="call_footnote_Temp_444"><sup><small>54</small></sup></a>
+be identified with the predicate <a id="__idx_3750"></a><tt>stream-null?</tt>.<a href="#footnote_Temp_444" id="call_footnote_Temp_444"><sup><small>54</small></sup></a>
 Thus we can make and use streams, in just the same way as we can make
 and use lists, to represent aggregate data arranged in a sequence.  In
 particular, we can build stream analogs of the list operations from
-chapter 2, such as <tt>list-ref</tt>, <tt>map</tt>, and <tt>for-each</tt>:<a name="call_footnote_Temp_445" href="#footnote_Temp_445" id="call_footnote_Temp_445"><sup><small>55</small></sup></a>
-</p><p></p><p><tt><a name="%_idx_3758" id="%_idx_3758"></a>(define (stream-ref s n)<br />
+chapter 2, such as <tt>list-ref</tt>, <tt>map</tt>, and <tt>for-each</tt>:<a href="#footnote_Temp_445" id="call_footnote_Temp_445"><sup><small>55</small></sup></a>
+</p><p></p><p><tt><a id="__idx_3758"></a>(define (stream-ref s n)<br />
   (if (= n 0)<br />
       (stream-car s)<br />
-      (stream-ref (stream-cdr s) (- n 1))))<br /><a name="%_idx_3760" id="%_idx_3760"></a>(define (stream-map proc s)<br />
+      (stream-ref (stream-cdr s) (- n 1))))<br /><a id="__idx_3760"></a>(define (stream-map proc s)<br />
   (if (stream-null? s)<br />
       the-empty-stream<br />
       (cons-stream (proc (stream-car s))<br />
-                   (stream-map proc (stream-cdr s)))))<br /><a name="%_idx_3762" id="%_idx_3762"></a>(define (stream-for-each proc s)<br />
+                   (stream-map proc (stream-cdr s)))))<br /><a id="__idx_3762"></a>(define (stream-for-each proc s)<br />
   (if (stream-null? s)<br />
       'done<br />
       (begin (proc (stream-car s))<br />
              (stream-for-each proc (stream-cdr s)))))<br /></tt></p><p></p><p>
 <tt>Stream-for-each</tt> is useful for viewing streams:
-</p><p></p><p><tt><a name="%_idx_3764" id="%_idx_3764"></a>(define (display-stream s)<br />
-  (stream-for-each display-line s))<br /><br /><a name="%_idx_3766" id="%_idx_3766"></a>(define (display-line x)<br />
+</p><p></p><p><tt><a id="__idx_3764"></a>(define (display-stream s)<br />
+  (stream-for-each display-line s))<br /><br /><a id="__idx_3766"></a>(define (display-line x)<br />
   (newline)<br />
   (display x))<br /></tt></p><p></p><p></p><p>
 
@@ -181,7 +181,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 the <tt>stream-cdr</tt> procedure rather than when the stream is
 constructed by <tt>cons-stream</tt>.  This implementation choice is
 reminiscent of our discussion of rational numbers in
-section <a href="book-Z-H-14.html#%_sec_2.1.2">2.1.2</a>, where we saw that we can
+section <a href="book-Z-H-14.html#__sec_2.1.2">2.1.2</a>, where we saw that we can
 choose to implement rational numbers so that the reduction of
 numerator and denominator to lowest terms is performed either at
 construction time or at selection time.  The two rational-number
@@ -193,17 +193,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 are evaluated at construction time.  With streams, the <tt>cdr</tt> is
 evaluated at selection time.</p><p>
 
-<a name="%_idx_3768" id="%_idx_3768"></a><a name="%_idx_3770" id="%_idx_3770"></a>Our implementation of streams will be based on a special form called
+<a id="__idx_3768"></a><a id="__idx_3770"></a>Our implementation of streams will be based on a special form called
 <tt>delay</tt>.  Evaluating <tt>(delay &lt;<em>exp</em>&gt;)</tt> does not
-evaluate the expression &lt;<em>exp</em>&gt;, but rather returns a so-called <a name="%_idx_3772" id="%_idx_3772"></a><em>delayed object</em>, which we can think of as a “promise” to evaluate
+evaluate the expression &lt;<em>exp</em>&gt;, but rather returns a so-called <a id="__idx_3772"></a><em>delayed object</em>, which we can think of as a “promise” to evaluate
 &lt;<em>exp</em>&gt; at some future time.  As a companion to <tt>delay</tt>, there is
-a procedure called <a name="%_idx_3774" id="%_idx_3774"></a><tt>force</tt> that takes a delayed object as
+a procedure called <a id="__idx_3774"></a><tt>force</tt> that takes a delayed object as
 argument and performs the evaluation – in effect, forcing the
 <tt>delay</tt> to fulfill its promise.  We will see below how <tt>delay</tt>
 and <tt>force</tt> can be implemented, but first let us use these to
 construct streams.</p><p>
 
-<a name="%_idx_3776" id="%_idx_3776"></a><a name="%_idx_3778" id="%_idx_3778"></a><tt>Cons-stream</tt> is a special form defined so that</p><p>
+<a id="__idx_3776"></a><a id="__idx_3778"></a><tt>Cons-stream</tt> is a special form defined so that</p><p>
 
 
 </p><p></p><p><tt>(cons-stream &lt;<em>a</em>&gt; &lt;<em>b</em>&gt;)<br /></tt></p><p></p><p>
@@ -218,13 +218,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 requested.  <tt>Stream-car</tt> and <tt>stream-cdr</tt> can now be defined as
 procedures:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3780" id="%_idx_3780"></a>(define (stream-car stream) (car stream))<br /><br /><a name="%_idx_3782" id="%_idx_3782"></a>(define (stream-cdr stream) (force (cdr stream)))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_3780"></a>(define (stream-car stream) (car stream))<br /><br /><a id="__idx_3782"></a>(define (stream-cdr stream) (force (cdr stream)))<br /></tt></p><p></p><p>
 <tt>Stream-car</tt> selects the <tt>car</tt> of the pair; <tt>stream-cdr</tt>
 selects the <tt>cdr</tt> of the pair and evaluates the delayed expression
-found there to obtain the rest of the stream.<a name="call_footnote_Temp_446" href="#footnote_Temp_446" id="call_footnote_Temp_446"><sup><small>56</small></sup></a>
+found there to obtain the rest of the stream.<a href="#footnote_Temp_446" id="call_footnote_Temp_446"><sup><small>56</small></sup></a>
 
-<a name="%_sec_Temp_447" id="%_sec_Temp_447"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_447">The stream implementation in action</a></h4><p>
+<a id="__sec_Temp_447"></a>
+</p><h4>The stream implementation in action</h4><p>
 
 To see how this implementation behaves, let us analyze the
 “outrageous” prime computation we saw above, reformulated in terms
@@ -240,16 +240,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 We begin by calling <tt>stream-enumerate-interval</tt> with
 the arguments 10,000 and 1,000,000.  <tt>Stream-enumerate-interval</tt>
 is the stream analog of <tt>enumerate-interval</tt>
-(section <a href="book-Z-H-15.html#%_sec_2.2.3">2.2.3</a>):</p><p>
+(section <a href="book-Z-H-15.html#__sec_2.2.3">2.2.3</a>):</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3788" id="%_idx_3788"></a>(define (stream-enumerate-interval low high)<br />
+</p><p></p><p><tt><a id="__idx_3788"></a>(define (stream-enumerate-interval low high)<br />
   (if (&gt; low high)<br />
       the-empty-stream<br />
       (cons-stream<br />
        low<br />
        (stream-enumerate-interval (+ low 1) high))))<br /></tt></p><p></p><p>
 and thus the result returned by <tt>stream-enumerate-interval</tt>,
-formed by the <tt>cons-stream</tt>, is<a name="call_footnote_Temp_448" href="#footnote_Temp_448" id="call_footnote_Temp_448"><sup><small>57</small></sup></a></p><p>
+formed by the <tt>cons-stream</tt>, is<a href="#footnote_Temp_448" id="call_footnote_Temp_448"><sup><small>57</small></sup></a></p><p>
 
 
 </p><p></p><p><tt>(cons 10000<br />
@@ -260,10 +260,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 is 10,000 and whose <tt>cdr</tt> is a promise to enumerate more of the
 interval if so requested.  This stream is now filtered for primes,
 using the stream analog of the <tt>filter</tt> procedure
-(section <a href="book-Z-H-15.html#%_sec_2.2.3">2.2.3</a>):</p><p>
+(section <a href="book-Z-H-15.html#__sec_2.2.3">2.2.3</a>):</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_3790" id="%_idx_3790"></a>(define (stream-filter pred stream)<br />
+</p><p></p><p><tt><a id="__idx_3790"></a>(define (stream-filter pred stream)<br />
   (cond ((stream-null? stream) the-empty-stream)<br />
         ((pred (stream-car stream))<br />
          (cons-stream (stream-car stream)<br />
@@ -315,18 +315,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 second prime, and the interval was enumerated only as far as was
 necessary to feed the prime filter.</p><p>
 
-In general, we can think of delayed evaluation as <a name="%_idx_3792" id="%_idx_3792"></a>“demand-driven”
+In general, we can think of delayed evaluation as <a id="__idx_3792"></a>“demand-driven”
 programming, whereby each stage in the stream process is activated
 only enough to satisfy the next stage.  What we have done is to
-<a name="%_idx_3794" id="%_idx_3794"></a>decouple the actual order of events in the computation from the
+<a id="__idx_3794"></a>decouple the actual order of events in the computation from the
 apparent structure of our procedures.  We write procedures as if the
 streams existed “all at once” when, in reality, the computation is
 performed incrementally, as in traditional programming styles.</p><p>
 
-<a name="%_sec_Temp_449" id="%_sec_Temp_449"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_449">Implementing <tt>delay</tt> and <tt>force</tt></a></h4><p>
+<a id="__sec_Temp_449"></a>
+</p><h4>Implementing <tt>delay</tt> and <tt>force</tt></h4><p>
 
-<a name="%_idx_3796" id="%_idx_3796"></a>Although <tt>delay</tt> and <tt>force</tt> may seem like mysterious
+<a id="__idx_3796"></a>Although <tt>delay</tt> and <tt>force</tt> may seem like mysterious
 operations, their implementation is really quite straightforward.
 <tt>Delay</tt> must package an expression so that it can be evaluated
 later on demand, and we can accomplish this simply by treating the
@@ -341,27 +341,27 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 arguments) produced by <tt>delay</tt>, so we can implement <tt>force</tt> as
 a procedure:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3798" id="%_idx_3798"></a>(define (force delayed-object)<br />
+</p><p></p><p><tt><a id="__idx_3798"></a>(define (force delayed-object)<br />
   (delayed-object))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_3800" id="%_idx_3800"></a><a name="%_idx_3802" id="%_idx_3802"></a>This implementation suffices for <tt>delay</tt> and <tt>force</tt> to work
+<a id="__idx_3800"></a><a id="__idx_3802"></a>This implementation suffices for <tt>delay</tt> and <tt>force</tt> to work
 as advertised, but there is an important optimization that we can
 include.  In many applications, we end up forcing the same delayed object
 many times.  This can lead to serious inefficiency in recursive
 programs involving streams.  (See
-exercise <a href="#%_thm_3.57">3.57</a>.)  The solution is to build
+exercise <a href="#__thm_3.57">3.57</a>.)  The solution is to build
 delayed objects so that the first time they are forced, they store the
 value that is computed.  Subsequent forcings will simply return the
 stored value without repeating the computation.  In other words, we
 implement <tt>delay</tt> as a special-purpose memoized procedure similar
-to the one described in exercise <a href="book-Z-H-22.html#%_thm_3.27">3.27</a>.  One way to
+to the one described in exercise <a href="book-Z-H-22.html#__thm_3.27">3.27</a>.  One way to
 accomplish this is to use the following procedure, which takes as
 argument a procedure (of no arguments) and returns a memoized version
 of the procedure.  The first time the memoized procedure is run, it
 saves the computed result.  On subsequent evaluations, it simply
 returns the result.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3804" id="%_idx_3804"></a>(define (memo-proc proc)<br />
+</p><p></p><p><tt><a id="__idx_3804"></a>(define (memo-proc proc)<br />
   (let ((already-run? false) (result false))<br />
     (lambda ()<br />
       (if (not already-run?)<br />
@@ -373,15 +373,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 equivalent to</p><p>
 
 </p><p></p><p><tt>(memo-proc (lambda () &lt;<em>exp</em>&gt;))<br /></tt></p><p></p><p>
-and <tt>force</tt> is as defined previously.<a name="call_footnote_Temp_450" href="#footnote_Temp_450" id="call_footnote_Temp_450"><sup><small>58</small></sup></a></p><p>
+and <tt>force</tt> is as defined previously.<a href="#footnote_Temp_450" id="call_footnote_Temp_450"><sup><small>58</small></sup></a></p><p>
 
-</p><p><a name="%_thm_3.50" id="%_thm_3.50"></a>
+</p><p><a id="__thm_3.50"></a>
 <b>Exercise 3.50.</b>  Complete the following definition, which
 generalizes <tt>stream-map</tt> to allow procedures that
 take multiple arguments, analogous to <tt>map</tt> in
-section <a href="book-Z-H-15.html#%_sec_2.2.3">2.2.3</a>, footnote <a href="book-Z-H-15.html#footnote_Temp_166">12</a>.</p><p>
+section <a href="book-Z-H-15.html#__sec_2.2.3">2.2.3</a>, footnote <a href="book-Z-H-15.html#footnote_Temp_166">12</a>.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3824" id="%_idx_3824"></a>(define (stream-map proc . argstreams)<br />
+</p><p></p><p><tt><a id="__idx_3824"></a>(define (stream-map proc . argstreams)<br />
   (if (&lt;<em>??</em>&gt; (car argstreams))<br />
       the-empty-stream<br />
       (&lt;<em>??</em>&gt;<br />
@@ -390,8 +390,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
               (cons proc (map &lt;<em>??</em>&gt; argstreams))))))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.51" id="%_thm_3.51"></a>
-<b>Exercise 3.51.</b>  <a name="%_idx_3826" id="%_idx_3826"></a>In order to take a closer look at delayed evaluation, we will use the
+</p><p><a id="__thm_3.51"></a>
+<b>Exercise 3.51.</b>  <a id="__idx_3826"></a>In order to take a closer look at delayed evaluation, we will use the
 following procedure, which simply returns its argument after printing it:</p><p>
 
 
@@ -399,7 +399,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
   (display-line x)<br />
   x)<br /></tt></p><p></p><p>
 What does the interpreter print in response to evaluating each
-expression in the following sequence?<a name="call_footnote_Temp_453" href="#footnote_Temp_453" id="call_footnote_Temp_453"><sup><small>59</small></sup></a></p><p>
+expression in the following sequence?<a href="#footnote_Temp_453" id="call_footnote_Temp_453"><sup><small>59</small></sup></a></p><p>
 
 
 </p><p></p><p><tt>(define x (stream-map show (stream-enumerate-interval 0 10)))<br />
@@ -407,8 +407,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 (stream-ref x 7)<br /></tt></p><p></p><p>
 </p><p>
 
-</p><p><a name="%_thm_3.52" id="%_thm_3.52"></a>
-<b>Exercise 3.52.</b>  <a name="%_idx_3830" id="%_idx_3830"></a>Consider the sequence of expressions</p><p>
+</p><p><a id="__thm_3.52"></a>
+<b>Exercise 3.52.</b>  <a id="__idx_3830"></a>Consider the sequence of expressions</p><p>
 
 
 </p><p></p><p><tt>(define sum 0)<br />
@@ -429,11 +429,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 
 </p><p></p><p>
 
-<a name="%_sec_3.5.2" id="%_sec_3.5.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.5.2">3.5.2  Infinite Streams</a></h3><p>
+<a id="__sec_3.5.2"></a>
+</p><h3>3.5.2  Infinite Streams</h3><p>
 
 
-<a name="%_idx_3832" id="%_idx_3832"></a>
+<a id="__idx_3832"></a>
 We have seen how to support the illusion of manipulating streams
 as complete entities even though, in actuality, we compute only
 as much of the stream as we need to access.  We can exploit this
@@ -442,8 +442,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 represent sequences that are infinitely long.  For instance, consider
 the following definition of the stream of positive integers:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3834" id="%_idx_3834"></a>(define (integers-starting-from n)<br />
-  (cons-stream n (integers-starting-from (+ n 1))))<br /><br /><a name="%_idx_3836" id="%_idx_3836"></a>(define integers (integers-starting-from 1))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_3834"></a>(define (integers-starting-from n)<br />
+  (cons-stream n (integers-starting-from (+ n 1))))<br /><br /><a id="__idx_3836"></a>(define integers (integers-starting-from 1))<br /></tt></p><p></p><p>
 This makes sense because <tt>integers</tt> will be a pair whose <tt>car</tt>
 is 1 and whose <tt>cdr</tt> is a promise to produce the integers
 beginning with 2.  This is an infinitely long stream, but in any given
@@ -453,7 +453,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 Using <tt>integers</tt> we can define other infinite streams, such as
 the stream of integers that are not divisible by 7:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3838" id="%_idx_3838"></a>(define (divisible? x y) (= (remainder x y) 0))<br />
+</p><p></p><p><tt><a id="__idx_3838"></a>(define (divisible? x y) (= (remainder x y) 0))<br />
 (define no-sevens<br />
   (stream-filter (lambda (x) (not (divisible? x 7)))<br />
                  integers))<br /></tt></p><p></p><p>
@@ -467,17 +467,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 Fibonacci numbers:</p><p>
 
 </p><p></p><p><tt>(define (fibgen a b)<br />
-  (cons-stream a (fibgen b (+ a b))))<br /><a name="%_idx_3840" id="%_idx_3840"></a>(define fibs (fibgen 0 1))<br /></tt></p><p></p><p>
+  (cons-stream a (fibgen b (+ a b))))<br /><a id="__idx_3840"></a>(define fibs (fibgen 0 1))<br /></tt></p><p></p><p>
 <tt>Fibs</tt> is a pair whose <tt>car</tt> is 0 and whose <tt>cdr</tt> is a
 promise to evaluate <tt>(fibgen 1 1)</tt>.  When we evaluate this delayed
 <tt>(fibgen 1 1)</tt>, it
 will produce a pair whose <tt>car</tt> is 1 and whose <tt>cdr</tt> is a
 promise to evaluate <tt>(fibgen 1 2)</tt>, and so on.</p><p>
 
-<a name="%_idx_3842" id="%_idx_3842"></a>For a look at a more exciting infinite stream, we can generalize the
+<a id="__idx_3842"></a>For a look at a more exciting infinite stream, we can generalize the
 <tt>no-sevens</tt> example to construct the infinite stream of prime
-numbers, using a method known as the <a name="%_idx_3844" id="%_idx_3844"></a><em>sieve of
-Eratosthenes</em>.<a name="call_footnote_Temp_455" href="#footnote_Temp_455" id="call_footnote_Temp_455"><sup><small>60</small></sup></a> We
+numbers, using a method known as the <a id="__idx_3844"></a><em>sieve of
+Eratosthenes</em>.<a href="#footnote_Temp_455" id="call_footnote_Temp_455"><sup><small>60</small></sup></a> We
 start with the integers beginning with 2, which is the first prime.
 To get the rest of the primes, we start by filtering the multiples of
 2 from the rest of the integers.  This leaves a stream beginning with
@@ -490,20 +490,20 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 of <tt>S</tt> out of the rest of <tt>S</tt> and sieving the result. This
 process is readily described in terms of stream operations:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3852" id="%_idx_3852"></a>(define (sieve stream)<br />
+</p><p></p><p><tt><a id="__idx_3852"></a>(define (sieve stream)<br />
   (cons-stream<br />
    (stream-car stream)<br />
    (sieve (stream-filter<br />
            (lambda (x)<br />
              (not (divisible? x (stream-car stream))))<br />
-           (stream-cdr stream)))))<br /><br /><a name="%_idx_3854" id="%_idx_3854"></a>(define primes (sieve (integers-starting-from 2)))<br /></tt></p><p></p><p>
+           (stream-cdr stream)))))<br /><br /><a id="__idx_3854"></a>(define primes (sieve (integers-starting-from 2)))<br /></tt></p><p></p><p>
 Now to find a particular prime we need only ask for it:</p><p>
 
 </p><p></p><p><tt>(stream-ref primes 50)<br /><i>233</i><br /></tt></p><p></p><p></p><p>
 
 It is interesting to contemplate the signal-processing system set up
-by <tt>sieve</tt>, shown in the <a name="%_idx_3856" id="%_idx_3856"></a>“Henderson diagram” in
-figure <a href="#%_fig_3.31">3.31</a>.<a name="call_footnote_Temp_456" href="#footnote_Temp_456" id="call_footnote_Temp_456"><sup><small>61</small></sup></a>
+by <tt>sieve</tt>, shown in the <a id="__idx_3856"></a>“Henderson diagram” in
+figure <a href="#__fig_3.31">3.31</a>.<a href="#footnote_Temp_456" id="call_footnote_Temp_456"><sup><small>61</small></sup></a>
 The input stream feeds into an
 “un<tt>cons</tt>er” that separates the first element of the stream from the
 rest of the stream.
@@ -514,14 +514,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 only is the stream infinite, but the signal processor is also
 infinite, because the sieve contains a sieve within it.</p><p>
 
-<a name="%_fig_3.31" id="%_fig_3.31"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-35.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.31:</b>  The prime sieve viewed as a signal-processing system.</div></caption><tr><td>
+<a id="__fig_3.31"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-35.gif" alt="ch3-Z-G-35" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.31:</b>  The prime sieve viewed as a signal-processing system.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_sec_Temp_457" id="%_sec_Temp_457"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_457">Defining streams implicitly</a></h4><p>
+<a id="__sec_Temp_457"></a>
+</p><h4>Defining streams implicitly</h4><p>
 
-<a name="%_idx_3860" id="%_idx_3860"></a>
+<a id="__idx_3860"></a>
 The <tt>integers</tt> and <tt>fibs</tt> streams above were defined by
 specifying “generating” procedures that explicitly compute the
 stream elements one by one. An alternative way to specify streams is
@@ -529,20 +529,20 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 For example, the following expression defines the stream <tt>ones</tt> to
 be an infinite stream of ones:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3862" id="%_idx_3862"></a>(define ones (cons-stream 1 ones))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_3862"></a>(define ones (cons-stream 1 ones))<br /></tt></p><p></p><p>
 This works much like the definition of a recursive procedure: <tt>ones</tt> is a pair whose <tt>car</tt> is 1 and whose <tt>cdr</tt> is a promise
 to evaluate <tt>ones</tt>.  Evaluating the <tt>cdr</tt> gives us again a 1
 and a promise to evaluate <tt>ones</tt>, and so on.</p><p>
 
 We can do more interesting things by manipulating streams with
 operations such as <tt>add-streams</tt>, which produces the elementwise
-sum of two given streams:<a name="call_footnote_Temp_458" href="#footnote_Temp_458" id="call_footnote_Temp_458"><sup><small>62</small></sup></a></p><p>
+sum of two given streams:<a href="#footnote_Temp_458" id="call_footnote_Temp_458"><sup><small>62</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_3864" id="%_idx_3864"></a>(define (add-streams s1 s2)<br />
+</p><p></p><p><tt><a id="__idx_3864"></a>(define (add-streams s1 s2)<br />
   (stream-map + s1 s2))<br /></tt></p><p></p><p>
 Now we can define the integers as follows:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3866" id="%_idx_3866"></a>(define integers (cons-stream 1 (add-streams ones integers)))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_3866"></a>(define integers (cons-stream 1 (add-streams ones integers)))<br /></tt></p><p></p><p>
 This defines <tt>integers</tt> to be a stream whose first element is 1
 and the rest of which is the sum of <tt>ones</tt> and <tt>integers</tt>.  Thus, the
 second element of <tt>integers</tt> is 1 plus the first element of <tt>integers</tt>,
@@ -554,7 +554,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 
 We can define the Fibonacci numbers in the same style:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3868" id="%_idx_3868"></a>(define fibs<br />
+</p><p></p><p><tt><a id="__idx_3868"></a>(define fibs<br />
   (cons-stream 0<br />
                (cons-stream 1<br />
                             (add-streams (stream-cdr fibs)<br />
@@ -563,13 +563,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 1, such that the rest of the stream can be generated by adding <tt>fibs</tt>
 to itself shifted by one place:</p><p>
 
-</p><table border="0"><tr><td valign="top"></td><td valign="top"></td><td valign="top">1 </td><td valign="top">1 </td><td valign="top">2 </td><td valign="top">3 </td><td valign="top">5 </td><td valign="top">8 </td><td valign="top">13 </td><td valign="top">21 </td><td valign="top"><tt>...</tt> = <tt>(stream-cdr fibs)</tt></td></tr><tr><td valign="top"></td><td valign="top"></td><td valign="top">0 </td><td valign="top">1 </td><td valign="top">1 </td><td valign="top">2 </td><td valign="top">3 </td><td valign="top">5 </td><td valign="top"> 8 </td><td valign="top">13 </td><td valign="top"><tt>...</tt> = <tt>fibs</tt></td></tr><tr><td valign="top">0 </td><td valign="top">1 </td><td valign="top">1 </td><td valign="top">2 </td><td valign="top">3 </td><td valign="top">5 </td><td valign="top">8 </td><td valign="top">13 </td><td valign="top">21 </td><td valign="top">34 </td><td valign="top"><tt>...</tt> = <tt>fibs</tt></td></tr><tr><td valign="top"></td></tr></table><p>
+</p><table style="border: none;"><tr><td style="text-align: top;"></td><td style="text-align: top;"></td><td style="text-align: top;">1 </td><td style="text-align: top;">1 </td><td style="text-align: top;">2 </td><td style="text-align: top;">3 </td><td style="text-align: top;">5 </td><td style="text-align: top;">8 </td><td style="text-align: top;">13 </td><td style="text-align: top;">21 </td><td style="text-align: top;"><tt>...</tt> = <tt>(stream-cdr fibs)</tt></td></tr><tr><td style="text-align: top;"></td><td style="text-align: top;"></td><td style="text-align: top;">0 </td><td style="text-align: top;">1 </td><td style="text-align: top;">1 </td><td style="text-align: top;">2 </td><td style="text-align: top;">3 </td><td style="text-align: top;">5 </td><td style="text-align: top;"> 8 </td><td style="text-align: top;">13 </td><td style="text-align: top;"><tt>...</tt> = <tt>fibs</tt></td></tr><tr><td style="text-align: top;">0 </td><td style="text-align: top;">1 </td><td style="text-align: top;">1 </td><td style="text-align: top;">2 </td><td style="text-align: top;">3 </td><td style="text-align: top;">5 </td><td style="text-align: top;">8 </td><td style="text-align: top;">13 </td><td style="text-align: top;">21 </td><td style="text-align: top;">34 </td><td style="text-align: top;"><tt>...</tt> = <tt>fibs</tt></td></tr><tr><td style="text-align: top;"></td></tr></table><p>
 
 <tt>Scale-stream</tt> is another useful procedure in formulating such stream definitions.
 This multiplies each item in a stream by a given
 constant:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3870" id="%_idx_3870"></a>(define (scale-stream stream factor)<br />
+</p><p></p><p><tt><a id="__idx_3870"></a>(define (scale-stream stream factor)<br />
   (stream-map (lambda (x) (* x factor)) stream))<br /></tt></p><p></p><p>
 For example,</p><p>
 
@@ -580,7 +580,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 starting with the integers and filtering them by testing for
 primality.  We will need the first prime, 2, to get started:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3872" id="%_idx_3872"></a>(define primes<br />
+</p><p></p><p><tt><a id="__idx_3872"></a>(define primes<br />
   (cons-stream<br />
    2<br />
    (stream-filter prime? (integers-starting-from 3))))<br /></tt></p><p></p><p>
@@ -589,7 +589,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 divisible by a prime (not by just any integer) less than or equal to
 √<em>n</em>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3874" id="%_idx_3874"></a>(define (prime? n)<br />
+</p><p></p><p><tt><a id="__idx_3874"></a>(define (prime? n)<br />
   (define (iter ps)<br />
     (cond ((&gt; (square (stream-car ps)) n) true)<br />
           ((divisible? n (stream-car ps)) false)<br />
@@ -603,16 +603,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 primality, either <em>n</em> is not prime (in which case there is a prime
 already generated that divides it) or <em>n</em> is prime (in which case
 there is a prime already generated – i.e., a prime less than
-<em>n</em> – that is greater than √<em>n</em>).<a name="call_footnote_Temp_459" href="#footnote_Temp_459" id="call_footnote_Temp_459"><sup><small>63</small></sup></a>
+<em>n</em> – that is greater than √<em>n</em>).<a href="#footnote_Temp_459" id="call_footnote_Temp_459"><sup><small>63</small></sup></a>
 
-</p><p><a name="%_thm_3.53" id="%_thm_3.53"></a>
+</p><p><a id="__thm_3.53"></a>
 <b>Exercise 3.53.</b>  Without running the program, describe the elements of the
 stream defined by
 </p><p></p><p><tt>(define s (cons-stream 1 (add-streams s s)))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.54" id="%_thm_3.54"></a>
-<b>Exercise 3.54.</b>  Define a procedure <a name="%_idx_3886" id="%_idx_3886"></a><a name="%_idx_3888" id="%_idx_3888"></a><a name="%_idx_3890" id="%_idx_3890"></a><tt>mul-streams</tt>, analogous to <tt>add-streams</tt>,
+</p><p><a id="__thm_3.54"></a>
+<b>Exercise 3.54.</b>  Define a procedure <a id="__idx_3886"></a><a id="__idx_3888"></a><a id="__idx_3890"></a><tt>mul-streams</tt>, analogous to <tt>add-streams</tt>,
 that produces the elementwise product of its two input streams.
 Use this together with the stream of <tt>integers</tt> to complete the
 following definition of the stream whose <em>n</em>th element (counting from 0)
@@ -621,8 +621,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 </p><p></p><p><tt>(define factorials (cons-stream 1 (mul-streams &lt;<em>??</em>&gt; &lt;<em>??</em>&gt;)))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.55" id="%_thm_3.55"></a>
-<b>Exercise 3.55.</b>  Define a procedure <a name="%_idx_3892" id="%_idx_3892"></a><tt>partial-sums</tt> that takes as argument a
+</p><p><a id="__thm_3.55"></a>
+<b>Exercise 3.55.</b>  Define a procedure <a id="__idx_3892"></a><tt>partial-sums</tt> that takes as argument a
 stream <em>S</em> and returns the stream whose
 elements are <em>S</em><sub>0</sub>, <em>S</em><sub>0</sub> + <em>S</em><sub>1</sub>, <em>S</em><sub>0</sub> + <em>S</em><sub>1</sub> + <em>S</em><sub>2</sub>, <tt>...</tt>.  For example, <tt>(partial-sums integers)</tt> should be the stream
 1, 3, 6, 10, 15, <tt>...</tt>.
@@ -630,8 +630,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 </p><p></p><p>
 
 
-</p><p><a name="%_thm_3.56" id="%_thm_3.56"></a>
-<b>Exercise 3.56.</b>  A famous problem, first raised by <a name="%_idx_3894" id="%_idx_3894"></a>R. Hamming, is to enumerate, in
+</p><p><a id="__thm_3.56"></a>
+<b>Exercise 3.56.</b>  A famous problem, first raised by <a id="__idx_3894"></a>R. Hamming, is to enumerate, in
 ascending order with no repetitions, all positive integers with no
 prime factors other than 2, 3, or 5.  One obvious way to do this is to
 simply test each integer in turn to see whether it has any factors
@@ -650,12 +650,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 </p></li><li>These are all the elements of <tt>S</tt>.
 </li></ul><p></p><p>
 
-<a name="%_idx_3896" id="%_idx_3896"></a>Now all we have to do is combine elements from these sources.
+<a id="__idx_3896"></a>Now all we have to do is combine elements from these sources.
 For this we define a procedure <tt>merge</tt> that combines two ordered
 streams into one ordered result stream, eliminating repetitions:</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_3898" id="%_idx_3898"></a>(define (merge s1 s2)<br />
+</p><p></p><p><tt><a id="__idx_3898"></a>(define (merge s1 s2)<br />
   (cond ((stream-null? s1) s2)<br />
         ((stream-null? s2) s1)<br />
         (else<br />
@@ -678,17 +678,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.57" id="%_thm_3.57"></a>
-<b>Exercise 3.57.</b>  <a name="%_idx_3900" id="%_idx_3900"></a>How many additions are performed when we compute the <em>n</em>th Fibonacci
+</p><p><a id="__thm_3.57"></a>
+<b>Exercise 3.57.</b>  <a id="__idx_3900"></a>How many additions are performed when we compute the <em>n</em>th Fibonacci
 number using the definition of <tt>fibs</tt> based on the <tt>add-streams</tt> procedure?  Show that the number of additions would be
 exponentially greater if we had implemented
 <tt>(delay &lt;<em>exp</em>&gt;)</tt> simply as <tt>(lambda () &lt;<em>exp</em>&gt;)</tt>,
 without using the optimization provided by the <tt>memo-proc</tt>
-procedure described in section <a href="#%_sec_3.5.1">3.5.1</a>.<a name="call_footnote_Temp_465" href="#footnote_Temp_465" id="call_footnote_Temp_465"><sup><small>64</small></sup></a>
+procedure described in section <a href="#__sec_3.5.1">3.5.1</a>.<a href="#footnote_Temp_465" id="call_footnote_Temp_465"><sup><small>64</small></sup></a>
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.58" id="%_thm_3.58"></a>
+</p><p><a id="__thm_3.58"></a>
 <b>Exercise 3.58.</b>  Give an interpretation of the stream computed by the following
 procedure:</p><p>
 
@@ -696,32 +696,32 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
   (cons-stream<br />
    (quotient (* num radix) den)<br />
    (expand (remainder (* num radix) den) den radix)))<br /></tt></p><p></p><p>
-<a name="%_idx_3906" id="%_idx_3906"></a><a name="%_idx_3908" id="%_idx_3908"></a>(<tt>Quotient</tt> is a primitive that returns the integer quotient of
+<a id="__idx_3906"></a><a id="__idx_3908"></a>(<tt>Quotient</tt> is a primitive that returns the integer quotient of
 two integers.)  What are the successive elements produced by <tt>(expand 1 7 10)</tt> ?  What is produced by <tt>(expand 3 8 10)</tt> ?
 </p><p></p><p>
 
 
-</p><p><a name="%_thm_3.59" id="%_thm_3.59"></a>
-<b>Exercise 3.59.</b>  <a name="%_idx_3910" id="%_idx_3910"></a><a name="%_idx_3912" id="%_idx_3912"></a>In section <a href="book-Z-H-18.html#%_sec_2.5.3">2.5.3</a> we saw how to implement a
+</p><p><a id="__thm_3.59"></a>
+<b>Exercise 3.59.</b>  <a id="__idx_3910"></a><a id="__idx_3912"></a>In section <a href="book-Z-H-18.html#__sec_2.5.3">2.5.3</a> we saw how to implement a
 polynomial arithmetic system representing polynomials as lists of
 terms.  In a similar way, we can work with <em>power series</em>, such as</p><p>
 
-<a name="%_idx_3914" id="%_idx_3914"></a></p><p></p><div align="left"><img src="images/ch3-Z-G-36.gif" border="0" /></div><p></p><p>
+<a id="__idx_3914"></a></p><p></p><div style="text-align: left;"><img src="images/ch3-Z-G-36.gif" alt="ch3-Z-G-36" style="border: none;" /></div><p></p><p>
 
-<a name="%_idx_3916" id="%_idx_3916"></a></p><p></p><div align="left"><img src="images/ch3-Z-G-37.gif" border="0" /></div><p></p><p>
+<a id="__idx_3916"></a></p><p></p><div style="text-align: left;"><img src="images/ch3-Z-G-37.gif" alt="ch3-Z-G-37" style="border: none;" /></div><p></p><p>
 
-<a name="%_idx_3918" id="%_idx_3918"></a></p><p></p><div align="left"><img src="images/ch3-Z-G-38.gif" border="0" /></div><p></p><p>
+<a id="__idx_3918"></a></p><p></p><div style="text-align: left;"><img src="images/ch3-Z-G-38.gif" alt="ch3-Z-G-38" style="border: none;" /></div><p></p><p>
 
 represented as infinite streams.
 We will represent the series
 <em>a</em><sub>0</sub>  +  <em>a</em><sub>1</sub><em>x</em>  +  <em>a</em><sub>2</sub><em>x</em><sup>2</sup>  +  <em>a</em><sub>3</sub><em>x</em><sup>3</sup>  +  <tt>···</tt>
 as the stream whose elements are the coefficients <em>a</em><sub>0</sub>, <em>a</em><sub>1</sub>, <em>a</em><sub>2</sub>, <em>a</em><sub>3</sub>, <tt>...</tt>.</p><p>
 
-</p><p></p><p><a name="%_idx_3920" id="%_idx_3920"></a><a name="%_idx_3922" id="%_idx_3922"></a>a. The integral of the series <em>a</em><sub>0</sub>  +  <em>a</em><sub>1</sub><em>x</em>  +  <em>a</em><sub>2</sub><em>x</em><sup>2</sup>  +  <em>a</em><sub>3</sub><em>x</em><sup>3</sup>  +  <tt>···</tt>
+</p><p></p><p><a id="__idx_3920"></a><a id="__idx_3922"></a>a. The integral of the series <em>a</em><sub>0</sub>  +  <em>a</em><sub>1</sub><em>x</em>  +  <em>a</em><sub>2</sub><em>x</em><sup>2</sup>  +  <em>a</em><sub>3</sub><em>x</em><sup>3</sup>  +  <tt>···</tt>
 is the series
-</p><p></p><div align="left"><img src="images/ch3-Z-G-39.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch3-Z-G-39.gif" alt="ch3-Z-G-39" style="border: none;" /></div><p>
 where <em>c</em> is any constant.
-Define a procedure <a name="%_idx_3924" id="%_idx_3924"></a><tt>integrate-series</tt> that takes as input a stream
+Define a procedure <a id="__idx_3924"></a><tt>integrate-series</tt> that takes as input a stream
 <em>a</em><sub>0</sub>, <em>a</em><sub>1</sub>, <em>a</em><sub>2</sub>, <tt>...</tt> representing a power series and returns the stream
 <em>a</em><sub>0</sub>, (1/2)<em>a</em><sub>1</sub>, (1/3)<em>a</em><sub>2</sub>, <tt>...</tt> of coefficients of
 the non-constant terms of the integral of the series.
@@ -745,47 +745,47 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
   (cons-stream 0 &lt;<em>??</em>&gt;))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.60" id="%_thm_3.60"></a>
-<b>Exercise 3.60.</b>  <a name="%_idx_3926" id="%_idx_3926"></a><a name="%_idx_3928" id="%_idx_3928"></a><a name="%_idx_3930" id="%_idx_3930"></a><a name="%_idx_3932" id="%_idx_3932"></a>With power series represented as streams of coefficients as in
-exercise <a href="#%_thm_3.59">3.59</a>, adding series is implemented by <tt>add-streams</tt>.  Complete the definition of the following procedure for
+</p><p><a id="__thm_3.60"></a>
+<b>Exercise 3.60.</b>  <a id="__idx_3926"></a><a id="__idx_3928"></a><a id="__idx_3930"></a><a id="__idx_3932"></a>With power series represented as streams of coefficients as in
+exercise <a href="#__thm_3.59">3.59</a>, adding series is implemented by <tt>add-streams</tt>.  Complete the definition of the following procedure for
 multiplying series:
 </p><p></p><p><tt>(define (mul-series s1 s2)<br />
   (cons-stream &lt;<em>??</em>&gt; (add-streams &lt;<em>??</em>&gt; &lt;<em>??</em>&gt;)))<br /></tt></p><p></p><p>
 You can test your procedure by verifying that
-<em>s</em><em>i</em><em>n</em><sup>2</sup><em>x</em>  +  <em>c</em><em>o</em><em>s</em><sup>2</sup><em>x</em>  =  1, using the series from exercise <a href="#%_thm_3.59">3.59</a>.
+<em>s</em><em>i</em><em>n</em><sup>2</sup><em>x</em>  +  <em>c</em><em>o</em><em>s</em><sup>2</sup><em>x</em>  =  1, using the series from exercise <a href="#__thm_3.59">3.59</a>.
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.61" id="%_thm_3.61"></a>
-<b>Exercise 3.61.</b>  Let <em>S</em> be a power series (exercise <a href="#%_thm_3.59">3.59</a>)
+</p><p><a id="__thm_3.61"></a>
+<b>Exercise 3.61.</b>  Let <em>S</em> be a power series (exercise <a href="#__thm_3.59">3.59</a>)
 whose constant term is 1.  Suppose we want
 to find the power series 1/<em>S</em>, that is, the series <em>X</em> such that
 <em>S</em> ·  <em>X</em> =  1.  Write <em>S</em> = 1 + <em>S</em><sub><em>R</em></sub> where <em>S</em><sub><em>R</em></sub> is the part of <em>S</em> after
 the constant term.  Then we can solve for <em>X</em> as follows:
-</p><p></p><div align="left"><img src="images/ch3-Z-G-40.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch3-Z-G-40.gif" alt="ch3-Z-G-40" style="border: none;" /></div><p>
 In other words, <em>X</em> is the power series whose constant term is 1 and
 whose higher-order terms are given by the negative of <em>S</em><sub><em>R</em></sub> times <em>X</em>.
 Use this idea to write a procedure <tt>invert-unit-series</tt> that computes 1/<em>S</em> for a power series <em>S</em> with
 constant term 1.
-You will need to use <tt>mul-series</tt> from exercise <a href="#%_thm_3.60">3.60</a>.
+You will need to use <tt>mul-series</tt> from exercise <a href="#__thm_3.60">3.60</a>.
 
 </p><p></p><p>
 
 
-</p><p><a name="%_thm_3.62" id="%_thm_3.62"></a>
-<b>Exercise 3.62.</b>  <a name="%_idx_3934" id="%_idx_3934"></a><a name="%_idx_3936" id="%_idx_3936"></a><a name="%_idx_3938" id="%_idx_3938"></a>Use the results of exercises <a href="#%_thm_3.60">3.60</a>
-and <a href="#%_thm_3.61">3.61</a> to define a procedure <tt>div-series</tt>
+</p><p><a id="__thm_3.62"></a>
+<b>Exercise 3.62.</b>  <a id="__idx_3934"></a><a id="__idx_3936"></a><a id="__idx_3938"></a>Use the results of exercises <a href="#__thm_3.60">3.60</a>
+and <a href="#__thm_3.61">3.61</a> to define a procedure <tt>div-series</tt>
 that divides two power series.  <tt>Div-series</tt> should work for any
 two series, provided that the denominator series begins with a
 nonzero constant term.  (If the denominator has a zero constant term,
 then <tt>div-series</tt> should signal an error.)
 Show how to use <tt>div-series</tt>
-together with the result of exercise <a href="#%_thm_3.59">3.59</a> to generate
-<a name="%_idx_3940" id="%_idx_3940"></a>the power series for tangent.
+together with the result of exercise <a href="#__thm_3.59">3.59</a> to generate
+<a id="__idx_3940"></a>the power series for tangent.
 </p><p>
 
-<a name="%_sec_3.5.3" id="%_sec_3.5.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.5.3">3.5.3  Exploiting the Stream Paradigm</a></h3><p>
+<a id="__sec_3.5.3"></a>
+</p><h3>3.5.3  Exploiting the Stream Paradigm</h3><p>
 
 </p><p>
 
@@ -794,7 +794,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 Moreover, they avoid some of the theoretical tangles that accompany
 the introduction of assignment into a programming language.</p><p>
 
-<a name="%_idx_3942" id="%_idx_3942"></a>The stream approach can be illuminating because it allows us to build
+<a id="__idx_3942"></a>The stream approach can be illuminating because it allows us to build
 systems with different module boundaries than systems organized around
 assignment to state variables.  For example, we can think of an entire
 time series (or signal) as a focus of interest, rather than the values
@@ -802,27 +802,27 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 convenient to combine and compare components of state from different
 moments.</p><p>
 
-<a name="%_sec_Temp_471" id="%_sec_Temp_471"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_471">Formulating iterations as stream processes</a></h4><p>
+<a id="__sec_Temp_471"></a>
+</p><h4>Formulating iterations as stream processes</h4><p>
 
-<a name="%_idx_3944" id="%_idx_3944"></a>
-In section <a href="book-Z-H-11.html#%_sec_1.2.1">1.2.1</a>, we introduced iterative
+<a id="__idx_3944"></a>
+In section <a href="book-Z-H-11.html#__sec_1.2.1">1.2.1</a>, we introduced iterative
 processes, which proceed by updating state variables.  We know now
 that we can represent state as a “timeless” stream of values rather
 than as a set of variables to be updated.  Let's adopt this
 perspective in revisiting the square-root procedure from
-section <a href="book-Z-H-10.html#%_sec_1.1.7">1.1.7</a>.  Recall that the idea is to generate a
+section <a href="book-Z-H-10.html#__sec_1.1.7">1.1.7</a>.  Recall that the idea is to generate a
 sequence of better and better guesses for the square root of <em>x</em> by
 applying over and over again the procedure that improves guesses:</p><p>
 
 </p><p></p><p><tt>(define (sqrt-improve guess x)<br />
   (average guess (/ x guess)))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_3946" id="%_idx_3946"></a>In our original <tt>sqrt</tt> procedure, we made these guesses be the
+<a id="__idx_3946"></a>In our original <tt>sqrt</tt> procedure, we made these guesses be the
 successive values of a state variable. Instead we can generate the
-infinite stream of guesses, starting with an initial guess of 1:<a name="call_footnote_Temp_472" href="#footnote_Temp_472" id="call_footnote_Temp_472"><sup><small>65</small></sup></a></p><p>
+infinite stream of guesses, starting with an initial guess of 1:<a href="#footnote_Temp_472" id="call_footnote_Temp_472"><sup><small>65</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_3948" id="%_idx_3948"></a>(define (sqrt-stream x)<br />
+</p><p></p><p><tt><a id="__idx_3948"></a>(define (sqrt-stream x)<br />
   (define guesses<br />
     (cons-stream 1.0<br />
                  (stream-map (lambda (guess)<br />
@@ -833,46 +833,46 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 We can generate more and more terms of the stream to get better and
 better guesses.  If we like, we can write a procedure that keeps
 generating terms until the answer is good enough.  (See
-exercise <a href="#%_thm_3.64">3.64</a>.)</p><p>
+exercise <a href="#__thm_3.64">3.64</a>.)</p><p>
 
-<a name="%_idx_3950" id="%_idx_3950"></a><a name="%_idx_3952" id="%_idx_3952"></a><a name="%_idx_3954" id="%_idx_3954"></a><a name="%_idx_3956" id="%_idx_3956"></a><a name="%_idx_3958" id="%_idx_3958"></a><a name="%_idx_3960" id="%_idx_3960"></a>Another iteration that we can treat in the same way is to generate an
+<a id="__idx_3950"></a><a id="__idx_3952"></a><a id="__idx_3954"></a><a id="__idx_3956"></a><a id="__idx_3958"></a><a id="__idx_3960"></a>Another iteration that we can treat in the same way is to generate an
 approximation to π, based upon the alternating series that we saw
-in section <a href="book-Z-H-12.html#%_sec_1.3.1">1.3.1</a>:</p><p>
+in section <a href="book-Z-H-12.html#__sec_1.3.1">1.3.1</a>:</p><p>
 
-</p><p></p><div align="left"><img src="images/ch3-Z-G-41.gif" border="0" /></div><p></p><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch3-Z-G-41.gif" alt="ch3-Z-G-41" style="border: none;" /></div><p></p><p>
 
 
 We first generate the stream of summands of the series (the reciprocals
 of the odd integers, with alternating signs).  Then we take the stream
 of sums of more and more terms (using the <tt>partial-sums</tt> procedure
-of exercise <a href="#%_thm_3.55">3.55</a>) and scale the result by 4:
+of exercise <a href="#__thm_3.55">3.55</a>) and scale the result by 4:
 
 </p><p></p><p><tt>(define (pi-summands n)<br />
   (cons-stream (/ 1.0 n)<br />
-               (stream-map - (pi-summands (+ n 2)))))<br /><a name="%_idx_3962" id="%_idx_3962"></a>(define pi-stream<br />
+               (stream-map - (pi-summands (+ n 2)))))<br /><a id="__idx_3962"></a>(define pi-stream<br />
   (scale-stream (partial-sums (pi-summands 1)) 4))<br />
 (display-stream pi-stream)<br /><i>4.</i><br /><i>2.666666666666667</i><br /><i>3.466666666666667</i><br /><i>2.8952380952380956</i><br /><i>3.3396825396825403</i><br /><i>2.9760461760461765</i><br /><i>3.2837384837384844</i><br /><i>3.017071817071818</i><br /><tt>...</tt></tt></p><p></p><p>
 This gives us a stream of better and better approximations to π,
 although the approximations converge rather slowly.  Eight terms of
 the sequence bound the value of π between 3.284 and 3.017.</p><p>
 
-<a name="%_idx_3964" id="%_idx_3964"></a>So far, our use of the stream of states approach is not much different
+<a id="__idx_3964"></a>So far, our use of the stream of states approach is not much different
 from updating state variables.  But streams give us an opportunity to
 do some interesting tricks.  For example, we can transform a stream
-with a <a name="%_idx_3966" id="%_idx_3966"></a><em>sequence accelerator</em> that converts a sequence of
+with a <a id="__idx_3966"></a><em>sequence accelerator</em> that converts a sequence of
 approximations to a new sequence that converges to the same value as
 the original, only faster.</p><p>
 
 One such accelerator, due to the eighteenth-century Swiss mathematician
-<a name="%_idx_3968" id="%_idx_3968"></a>Leonhard Euler, works well with sequences that are partial sums of
+<a id="__idx_3968"></a>Leonhard Euler, works well with sequences that are partial sums of
 alternating series (series of terms with alternating signs).
 In Euler's technique, if <em>S</em><sub><em>n</em></sub> is the <em>n</em>th term
 of the original sum sequence, then the accelerated sequence has terms
-</p><p></p><div align="left"><img src="images/ch3-Z-G-42.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch3-Z-G-42.gif" alt="ch3-Z-G-42" style="border: none;" /></div><p>
 Thus, if the original sequence is represented as a stream of values,
 the transformed sequence is given by</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3970" id="%_idx_3970"></a>(define (euler-transform s)<br />
+</p><p></p><p><tt><a id="__idx_3970"></a>(define (euler-transform s)<br />
   (let ((s0 (stream-ref s 0))           <em>; <em>S</em><sub><em>n</em>-1</sub></em><br />
         (s1 (stream-ref s 1))           <em>; <em>S</em><sub><em>n</em></sub></em><br />
         (s2 (stream-ref s 2)))          <em>; <em>S</em><sub><em>n</em>+1</sub></em><br />
@@ -887,20 +887,20 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 
 Even better, we can accelerate the accelerated sequence, and
 recursively accelerate that, and so on.  Namely, we create a stream of
-streams (a structure we'll call a <a name="%_idx_3972" id="%_idx_3972"></a><em>tableau</em>) in which each stream
+streams (a structure we'll call a <a id="__idx_3972"></a><em>tableau</em>) in which each stream
 is the transform of the preceding one:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3974" id="%_idx_3974"></a>(define (make-tableau transform s)<br />
+</p><p></p><p><tt><a id="__idx_3974"></a>(define (make-tableau transform s)<br />
   (cons-stream s<br />
                (make-tableau transform<br />
                              (transform s))))<br /></tt></p><p></p><p>
 The tableau has the form</p><p>
 
-</p><p></p><div align="left"><img src="images/ch3-Z-G-43.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch3-Z-G-43.gif" alt="ch3-Z-G-43" style="border: none;" /></div><p>
 Finally, we form a sequence by taking the first term in each row of
 the tableau:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3976" id="%_idx_3976"></a>(define (accelerated-sequence transform s)<br />
+</p><p></p><p><tt><a id="__idx_3976"></a>(define (accelerated-sequence transform s)<br />
   (stream-map stream-car<br />
               (make-tableau transform s)))<br /></tt></p><p></p><p></p><p>
 
@@ -921,7 +921,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 data structure that can be manipulated with a uniform set of
 operations.</p><p>
 
-</p><p><a name="%_thm_3.63" id="%_thm_3.63"></a>
+</p><p><a id="__thm_3.63"></a>
 <b>Exercise 3.63.</b>  Louis Reasoner asks why the <tt>sqrt-stream</tt> procedure was not
 written in the following more straightforward way, without
 the local variable <tt>guesses</tt>:
@@ -934,43 +934,43 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 considerably less efficient because it performs redundant computation.
 Explain Alyssa's answer.  Would the two versions still differ in
 efficiency if our implementation of <tt>delay</tt> used only <tt>(lambda
-() &lt;<em>exp</em>&gt;)</tt> without using the optimization provided by <tt>memo-proc</tt> (section <a href="#%_sec_3.5.1">3.5.1</a>)?
+() &lt;<em>exp</em>&gt;)</tt> without using the optimization provided by <tt>memo-proc</tt> (section <a href="#__sec_3.5.1">3.5.1</a>)?
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.64" id="%_thm_3.64"></a>
-<b>Exercise 3.64.</b>  Write a procedure <a name="%_idx_3978" id="%_idx_3978"></a><tt>stream-limit</tt> that takes as arguments a stream
+</p><p><a id="__thm_3.64"></a>
+<b>Exercise 3.64.</b>  Write a procedure <a id="__idx_3978"></a><tt>stream-limit</tt> that takes as arguments a stream
 and a number (the tolerance).  It should examine the stream until it
 finds two successive elements that differ in absolute value by less
 than the tolerance, and return the second of the two elements.  Using
 this, we could compute square roots up to a given tolerance by
-</p><p></p><p><tt><a name="%_idx_3980" id="%_idx_3980"></a>(define (sqrt x tolerance)<br />
+</p><p></p><p><tt><a id="__idx_3980"></a>(define (sqrt x tolerance)<br />
   (stream-limit (sqrt-stream x) tolerance))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.65" id="%_thm_3.65"></a>
-<b>Exercise 3.65.</b>  <a name="%_idx_3982" id="%_idx_3982"></a>Use the series
-</p><p></p><div align="left"><img src="images/ch3-Z-G-44.gif" border="0" /></div><p>
+</p><p><a id="__thm_3.65"></a>
+<b>Exercise 3.65.</b>  <a id="__idx_3982"></a>Use the series
+</p><p></p><div style="text-align: left;"><img src="images/ch3-Z-G-44.gif" alt="ch3-Z-G-44" style="border: none;" /></div><p>
 to compute three sequences of approximations to the natural logarithm of 2,
 in the same way we did above for π.
 How rapidly do these sequences converge?
 </p><p>
 
-<a name="%_sec_Temp_476" id="%_sec_Temp_476"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_476">Infinite streams of pairs</a></h4><p>
+<a id="__sec_Temp_476"></a>
+</p><h4>Infinite streams of pairs</h4><p>
 
-<a name="%_idx_3984" id="%_idx_3984"></a><a name="%_idx_3986" id="%_idx_3986"></a><a name="%_idx_3988" id="%_idx_3988"></a>
-In section <a href="book-Z-H-15.html#%_sec_2.2.3">2.2.3</a>, we saw how the sequence paradigm
+<a id="__idx_3984"></a><a id="__idx_3986"></a><a id="__idx_3988"></a>
+In section <a href="book-Z-H-15.html#__sec_2.2.3">2.2.3</a>, we saw how the sequence paradigm
 handles traditional nested loops as processes defined on sequences of
 pairs.  If we generalize this technique to infinite streams, then we
 can write programs that are not easily represented as loops, because
 the “looping” must range over an infinite set.</p><p>
 
-<a name="%_idx_3990" id="%_idx_3990"></a>For example, suppose we want to generalize the <tt>prime-sum-pairs</tt>
-procedure of section <a href="book-Z-H-15.html#%_sec_2.2.3">2.2.3</a> to produce the stream
+<a id="__idx_3990"></a>For example, suppose we want to generalize the <tt>prime-sum-pairs</tt>
+procedure of section <a href="book-Z-H-15.html#__sec_2.2.3">2.2.3</a> to produce the stream
 of pairs of <em>all</em> integers (<em>i</em>,<em>j</em>) with <em>i</em> <u>&lt;</u> <em>j</em> such that <em>i</em> + <em>j</em>
 is prime.  If <tt>int-pairs</tt> is the sequence of all pairs of integers (<em>i</em>,<em>j</em>)
-with <em>i</em> <u>&lt;</u> <em>j</em>, then our required stream is simply<a name="call_footnote_Temp_477" href="#footnote_Temp_477" id="call_footnote_Temp_477"><sup><small>66</small></sup></a></p><p>
+with <em>i</em> <u>&lt;</u> <em>j</em>, then our required stream is simply<a href="#footnote_Temp_477" id="call_footnote_Temp_477"><sup><small>66</small></sup></a></p><p>
 
 </p><p></p><p><tt>(stream-filter (lambda (pair)<br />
                  (prime? (+ (car pair) (cadr pair))))<br />
@@ -979,17 +979,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 Our problem, then, is to produce the stream <tt>int-pairs</tt>.  More
 generally, suppose we have two streams <em>S</em>  =  (<em>S</em><sub><em>i</em></sub>) and <em>T</em>  =  (<em>T</em><sub><em>j</em></sub>),
 and imagine the infinite rectangular array
-</p><p></p><div align="left"><img src="images/ch3-Z-G-45.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch3-Z-G-45.gif" alt="ch3-Z-G-45" style="border: none;" /></div><p>
 We wish to generate a stream that contains all the pairs in the array
 that lie on or above the diagonal, i.e., the pairs
-</p><p></p><div align="left"><img src="images/ch3-Z-G-46.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch3-Z-G-46.gif" alt="ch3-Z-G-46" style="border: none;" /></div><p>
 (If we take both <em>S</em> and <em>T</em> to be the stream of integers, then this
 will be our desired stream <tt>int-pairs</tt>.)  </p><p>
 
 Call the general stream of pairs <tt>(pairs S T)</tt>, and consider it to
 be composed of three parts: the pair (<em>S</em><sub>0</sub>,<em>T</em><sub>0</sub>), the
-rest of the pairs in the first row, and the remaining pairs:<a name="call_footnote_Temp_478" href="#footnote_Temp_478" id="call_footnote_Temp_478"><sup><small>67</small></sup></a>
-</p><p></p><div align="left"><img src="images/ch3-Z-G-47.gif" border="0" /></div><p>
+rest of the pairs in the first row, and the remaining pairs:<a href="#footnote_Temp_478" id="call_footnote_Temp_478"><sup><small>67</small></sup></a>
+</p><p></p><div style="text-align: left;"><img src="images/ch3-Z-G-47.gif" alt="ch3-Z-G-47" style="border: none;" /></div><p>
 Observe that the third piece in this decomposition (pairs that are not in the
 first row) is (recursively) the pairs formed from <tt>(stream-cdr S)</tt>
 and <tt>(stream-cdr T)</tt>.  Also note that the second piece (the rest
@@ -1005,11 +1005,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
                    (stream-cdr t))<br />
        (pairs (stream-cdr s) (stream-cdr t)))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_3992" id="%_idx_3992"></a>In order to complete the procedure, we must choose some way to combine
+<a id="__idx_3992"></a>In order to complete the procedure, we must choose some way to combine
 the two inner streams.  One idea is to use the stream analog of the
-<tt>append</tt> procedure from section <a href="book-Z-H-15.html#%_sec_2.2.1">2.2.1</a>:</p><p>
+<tt>append</tt> procedure from section <a href="book-Z-H-15.html#__sec_2.2.1">2.2.1</a>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_3994" id="%_idx_3994"></a>(define (stream-append s1 s2)<br />
+</p><p></p><p><tt><a id="__idx_3994"></a>(define (stream-append s1 s2)<br />
   (if (stream-null? s1)<br />
       s2<br />
       (cons-stream (stream-car s1)<br />
@@ -1027,9 +1027,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 To handle infinite streams, we need to devise an order of combination
 that ensures that every element will eventually be reached if we let
 our program run long enough.  An elegant way to accomplish this is
-with the following <tt>interleave</tt> procedure:<a name="call_footnote_Temp_479" href="#footnote_Temp_479" id="call_footnote_Temp_479"><sup><small>68</small></sup></a></p><p>
+with the following <tt>interleave</tt> procedure:<a href="#footnote_Temp_479" id="call_footnote_Temp_479"><sup><small>68</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_4000" id="%_idx_4000"></a>(define (interleave s1 s2)<br />
+</p><p></p><p><tt><a id="__idx_4000"></a>(define (interleave s1 s2)<br />
   (if (stream-null? s1)<br />
       s2<br />
       (cons-stream (stream-car s1)<br />
@@ -1039,7 +1039,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 the interleaved stream, even if the first stream is infinite.</p><p>
 
 We can thus generate the required stream of pairs as
-</p><p></p><p><tt><a name="%_idx_4002" id="%_idx_4002"></a>(define (pairs s t)<br />
+</p><p></p><p><tt><a id="__idx_4002"></a>(define (pairs s t)<br />
   (cons-stream<br />
    (list (stream-car s) (stream-car t))<br />
    (interleave<br />
@@ -1047,7 +1047,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
                 (stream-cdr t))<br />
     (pairs (stream-cdr s) (stream-cdr t)))))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_3.66" id="%_thm_3.66"></a>
+</p><p><a id="__thm_3.66"></a>
 <b>Exercise 3.66.</b>  Examine the stream <tt>(pairs integers integers)</tt>. Can you make any general
 comments about the order in which the pairs are placed into the
 stream? For example, about how many pairs precede the pair (1,100)?
@@ -1056,14 +1056,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 more qualitative answers if you find yourself getting bogged down.)
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.67" id="%_thm_3.67"></a>
+</p><p><a id="__thm_3.67"></a>
 <b>Exercise 3.67.</b>  Modify the <tt>pairs</tt> procedure so that <tt>(pairs integers
 integers)</tt> will produce the stream of <em>all</em> pairs of integers
 (<em>i</em>,<em>j</em>) (without the condition <em>i</em> <u>&lt;</u> <em>j</em>).  Hint: You will need to
 mix in an additional stream.
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.68" id="%_thm_3.68"></a>
+</p><p><a id="__thm_3.68"></a>
 <b>Exercise 3.68.</b>  Louis Reasoner thinks that building a stream of pairs from three
 parts is unnecessarily complicated.  Instead of separating the
 pair (<em>S</em><sub>0</sub>,<em>T</em><sub>0</sub>) from the rest of the pairs in the first row,
@@ -1078,21 +1078,21 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.69" id="%_thm_3.69"></a>
+</p><p><a id="__thm_3.69"></a>
 <b>Exercise 3.69.</b>  Write a procedure <tt>triples</tt> that takes three infinite
 streams, <em>S</em>, <em>T</em>, and <em>U</em>, and produces the stream of triples
 (<em>S</em><sub><em>i</em></sub>,<em>T</em><sub><em>j</em></sub>,<em>U</em><sub><em>k</em></sub>) such that <em>i</em> <u>&lt;</u> <em>j</em> <u>&lt;</u> <em>k</em>.
 Use <tt>triples</tt> to
-generate the stream of all <a name="%_idx_4004" id="%_idx_4004"></a>Pythagorean triples of positive integers,
+generate the stream of all <a id="__idx_4004"></a>Pythagorean triples of positive integers,
 i.e., the triples (<em>i</em>,<em>j</em>,<em>k</em>) such that <em>i</em> <u>&lt;</u> <em>j</em> and <em>i</em><sup>2</sup>  +  <em>j</em><sup>2</sup>  = <em>k</em><sup>2</sup>.
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.70" id="%_thm_3.70"></a>
-<b>Exercise 3.70.</b>  <a name="%_idx_4006" id="%_idx_4006"></a><a name="%_idx_4008" id="%_idx_4008"></a>It would be nice to be able to generate streams in which the pairs
+</p><p><a id="__thm_3.70"></a>
+<b>Exercise 3.70.</b>  <a id="__idx_4006"></a><a id="__idx_4008"></a>It would be nice to be able to generate streams in which the pairs
 appear in some useful order, rather than in the order that results
 from an <em>ad hoc</em> interleaving process.  We can use a technique
-similar to the <tt>merge</tt> procedure of exercise <a href="#%_thm_3.56">3.56</a>, if we
+similar to the <tt>merge</tt> procedure of exercise <a href="#__thm_3.56">3.56</a>, if we
 define a way to say that one pair of integers is “less than”
 another.  One way to do this is to define a “weighting function”
 <em>W</em>(<em>i</em>,<em>j</em>) and stipulate that (<em>i</em><sub>1</sub>,<em>j</em><sub>1</sub>) is less than (<em>i</em><sub>2</sub>,<em>j</em><sub>2</sub>) if
@@ -1100,7 +1100,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 that is like <tt>merge</tt>, except that <tt>merge-weighted</tt> takes an
 additional argument <tt>weight</tt>, which is a procedure that computes
 the weight of a pair, and is used to determine the order in which
-elements should appear in the resulting merged stream.<a name="call_footnote_Temp_485" href="#footnote_Temp_485" id="call_footnote_Temp_485"><sup><small>69</small></sup></a>
+elements should appear in the resulting merged stream.<a href="#footnote_Temp_485" id="call_footnote_Temp_485"><sup><small>69</small></sup></a>
 Using this,
 generalize <tt>pairs</tt> to a procedure <tt>weighted-pairs</tt> that
 takes two streams, together with a procedure that computes a weighting
@@ -1117,81 +1117,81 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 </p><p></p><p>
 
 
-</p><p><a name="%_thm_3.71" id="%_thm_3.71"></a>
-<b>Exercise 3.71.</b>  <a name="%_idx_4010" id="%_idx_4010"></a>Numbers that can be expressed as the sum of two cubes in more than one
+</p><p><a id="__thm_3.71"></a>
+<b>Exercise 3.71.</b>  <a id="__idx_4010"></a>Numbers that can be expressed as the sum of two cubes in more than one
 way are sometimes called <em>Ramanujan numbers</em>, in honor of the
-mathematician Srinivasa Ramanujan.<a name="call_footnote_Temp_487" href="#footnote_Temp_487" id="call_footnote_Temp_487"><sup><small>70</small></sup></a>
+mathematician Srinivasa Ramanujan.<a href="#footnote_Temp_487" id="call_footnote_Temp_487"><sup><small>70</small></sup></a>
 Ordered streams of pairs provide an elegant solution to the problem of
 computing these numbers.  To find a number that can be written as the
 sum of two cubes in two different ways, we need only generate the
 stream of pairs of integers (<em>i</em>,<em>j</em>) weighted according to the sum <em>i</em><sup>3</sup>
- +  <em>j</em><sup>3</sup> (see exercise <a href="#%_thm_3.70">3.70</a>),
+ +  <em>j</em><sup>3</sup> (see exercise <a href="#__thm_3.70">3.70</a>),
 then search the stream for two consecutive pairs with the same
 weight.  Write a procedure to generate the Ramanujan numbers.  The first
 such number is 1,729.  What are the next five?
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.72" id="%_thm_3.72"></a>
-<b>Exercise 3.72.</b>  In a similar way to exercise <a href="#%_thm_3.71">3.71</a> generate
+</p><p><a id="__thm_3.72"></a>
+<b>Exercise 3.72.</b>  In a similar way to exercise <a href="#__thm_3.71">3.71</a> generate
 a stream of
 all numbers that can be written as the sum of two squares in three
 different ways (showing how they can be so written).
 </p><p>
 
-<a name="%_sec_Temp_489" id="%_sec_Temp_489"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_489">Streams as signals</a></h4><p>
+<a id="__sec_Temp_489"></a>
+</p><h4>Streams as signals</h4><p>
 
-<a name="%_idx_4018" id="%_idx_4018"></a><a name="%_idx_4020" id="%_idx_4020"></a>
+<a id="__idx_4018"></a><a id="__idx_4020"></a>
 We began our discussion of streams by describing them as computational
 analogs of the “signals” in signal-processing systems.  In fact, we
 can use streams to model signal-processing systems in a very direct
 way, representing the values of a signal at successive time intervals
 as consecutive elements of a stream.  For instance, we can implement
-an <a name="%_idx_4022" id="%_idx_4022"></a><em>integrator</em> or <em>summer</em> that, for an input stream
+an <a id="__idx_4022"></a><em>integrator</em> or <em>summer</em> that, for an input stream
 <em>x</em> = (<em>x</em><sub><em>i</em></sub>), an initial value <em>C</em>, and a small increment <em>d</em><em>t</em>,
 accumulates the sum
-</p><p></p><div align="left"><img src="images/ch3-Z-G-48.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch3-Z-G-48.gif" alt="ch3-Z-G-48" style="border: none;" /></div><p>
 and returns the stream of values <em>S</em> = (<em>S</em><sub><em>i</em></sub>).  The following <tt>integral</tt>
 procedure is reminiscent of the “implicit style” definition of the
-stream of integers (section <a href="#%_sec_3.5.2">3.5.2</a>):</p><p>
+stream of integers (section <a href="#__sec_3.5.2">3.5.2</a>):</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4024" id="%_idx_4024"></a>(define (integral integrand initial-value dt)<br />
+</p><p></p><p><tt><a id="__idx_4024"></a>(define (integral integrand initial-value dt)<br />
   (define int<br />
     (cons-stream initial-value<br />
                  (add-streams (scale-stream integrand dt)<br />
                               int)))<br />
   int)<br /></tt></p><p></p><p></p><p>
 
-<a name="%_fig_3.32" id="%_fig_3.32"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-49.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.32:</b>  The <tt>integral</tt> procedure viewed as a
+<a id="__fig_3.32"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-49.gif" alt="ch3-Z-G-49" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.32:</b>  The <tt>integral</tt> procedure viewed as a
 signal-processing system.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-Figure <a href="#%_fig_3.32">3.32</a> is a picture of a signal-processing system that
+Figure <a href="#__fig_3.32">3.32</a> is a picture of a signal-processing system that
 corresponds to the <tt>integral</tt> procedure.  The input stream is
 scaled by <em>d</em><em>t</em> and passed through an adder, whose output is passed
 back through the same adder.  The self-reference in the definition of
 <tt>int</tt> is reflected in the figure by the feedback loop that
 connects the output of the adder to one of the inputs.</p><p>
 
-</p><p><a name="%_thm_3.73" id="%_thm_3.73"></a>
-<b>Exercise 3.73.</b>  <a name="%_fig_3.33" id="%_fig_3.33"></a></p><p></p><div align="left"><table width="100%"><tr><td><div align="center"> <img src="images/ch3-Z-G-50.gif" border="0" />
+</p><p><a id="__thm_3.73"></a>
+<b>Exercise 3.73.</b>  <a id="__fig_3.33"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><div style="text-align: center;"> <img src="images/ch3-Z-G-50.gif" alt="ch3-Z-G-50" style="border: none;" />
       
 
 
 <em>v</em>  =  <em>v</em><sub>0</sub>  +  (1/<em>C</em>)∫<sub>0</sub><sup><em>t</em></sup><em>i</em> <em>d</em><em>t</em>  +  <em>R</em> <em>i</em>
      </div>
 
-<p></p><p><img src="images/ch3-Z-G-51.gif" border="0" /></p></td></tr><caption align="bottom"><div align="left"><b>Figure 3.33:</b>  An RC circuit and the associated signal-flow diagram.</div></caption><tr><td>
-<a name="%_idx_4026" id="%_idx_4026"></a>
+<p></p><p><img src="images/ch3-Z-G-51.gif" alt="ch3-Z-G-51" style="border: none;" /></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.33:</b>  An RC circuit and the associated signal-flow diagram.</div></caption><tr><td>
+<a id="__idx_4026"></a>
 </td></tr></table></div><p>
-<a name="%_idx_4028" id="%_idx_4028"></a><a name="%_idx_4030" id="%_idx_4030"></a><a name="%_idx_4032" id="%_idx_4032"></a>We can model electrical circuits using streams to represent the values
+<a id="__idx_4028"></a><a id="__idx_4030"></a><a id="__idx_4032"></a>We can model electrical circuits using streams to represent the values
 of currents or voltages at a sequence of times.  For instance, suppose
 we have an <em>RC circuit</em> consisting of a resistor of resistance <em>R</em>
 and a capacitor of capacitance <em>C</em> in series.  The voltage response
 <em>v</em> of the circuit to an injected current <em>i</em> is determined by the
-formula in figure <a href="#%_fig_3.33">3.33</a>, whose structure is shown by the accompanying
+formula in figure <a href="#__fig_3.33">3.33</a>, whose structure is shown by the accompanying
 signal-flow diagram.</p><p>
 
 Write a procedure <tt>RC</tt> that models this circuit.  <tt>RC</tt> should
@@ -1206,8 +1206,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 voltage and produces the output stream of voltages.
 
 </p><p>
-</p><p><a name="%_thm_3.74" id="%_thm_3.74"></a>
-<b>Exercise 3.74.</b>  <a name="%_idx_4034" id="%_idx_4034"></a><a name="%_idx_4036" id="%_idx_4036"></a>Alyssa P. Hacker is designing a system to process signals coming from
+</p><p><a id="__thm_3.74"></a>
+<b>Exercise 3.74.</b>  <a id="__idx_4034"></a><a id="__idx_4036"></a>Alyssa P. Hacker is designing a system to process signals coming from
 physical sensors.  One important feature she wishes to produce is a
 signal that describes the <em>zero crossings</em> of the input signal.
 That is, the resulting signal should be  + 1 whenever the input signal
@@ -1233,16 +1233,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 Alyssa's boss, Eva Lu Ator, walks by and suggests that this program is
 approximately equivalent to the following one, which
 uses the generalized version
-of <tt>stream-map</tt> from exercise <a href="#%_thm_3.50">3.50</a>:</p><p>
+of <tt>stream-map</tt> from exercise <a href="#__thm_3.50">3.50</a>:</p><p>
 
 </p><p></p><p><tt>(define zero-crossings<br />
   (stream-map sign-change-detector sense-data &lt;<em>expression</em>&gt;))<br /></tt></p><p></p><p>
 Complete the program by supplying the indicated &lt;<em>expression</em>&gt;.
 
 </p><p>
-</p><p><a name="%_thm_3.75" id="%_thm_3.75"></a>
-<b>Exercise 3.75.</b>  <a name="%_idx_4038" id="%_idx_4038"></a><a name="%_idx_4040" id="%_idx_4040"></a><a name="%_idx_4042" id="%_idx_4042"></a><a name="%_idx_4044" id="%_idx_4044"></a>Unfortunately, Alyssa's zero-crossing detector in
-exercise <a href="#%_thm_3.74">3.74</a> proves to be insufficient, because the
+</p><p><a id="__thm_3.75"></a>
+<b>Exercise 3.75.</b>  <a id="__idx_4038"></a><a id="__idx_4040"></a><a id="__idx_4042"></a><a id="__idx_4044"></a>Unfortunately, Alyssa's zero-crossing detector in
+exercise <a href="#__thm_3.74">3.74</a> proves to be insufficient, because the
 noisy signal from the sensor leads to spurious zero crossings.  Lem E.
 Tweakit, a hardware specialist, suggests that Alyssa smooth the signal
 to filter out the noise before extracting the zero crossings.  Alyssa
@@ -1263,9 +1263,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 will need to increase the number of arguments to <tt>make-zero-crossings</tt>.)
 
 </p><p>
-</p><p><a name="%_thm_3.76" id="%_thm_3.76"></a>
-<b>Exercise 3.76.</b>  <a name="%_idx_4046" id="%_idx_4046"></a><a name="%_idx_4048" id="%_idx_4048"></a><a name="%_idx_4050" id="%_idx_4050"></a><a name="%_idx_4052" id="%_idx_4052"></a>Eva Lu Ator has a criticism of Louis's approach in
-exercise <a href="#%_thm_3.75">3.75</a>.  The program he wrote is not modular,
+</p><p><a id="__thm_3.76"></a>
+<b>Exercise 3.76.</b>  <a id="__idx_4046"></a><a id="__idx_4048"></a><a id="__idx_4050"></a><a id="__idx_4052"></a>Eva Lu Ator has a criticism of Louis's approach in
+exercise <a href="#__thm_3.75">3.75</a>.  The program he wrote is not modular,
 because it intermixes the operation of smoothing with the
 zero-crossing extraction.  For example, the extractor should not have
 to be changed if Alyssa finds a better way to condition her input
@@ -1274,16 +1274,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 average of two successive input stream elements.  Then use <tt>smooth</tt> as a component to implement the zero-crossing detector in a
 more modular style.
 </p><p>
-<a name="%_sec_3.5.4" id="%_sec_3.5.4"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.5.4">3.5.4  Streams and Delayed Evaluation</a></h3><p>
+<a id="__sec_3.5.4"></a>
+</p><h3>3.5.4  Streams and Delayed Evaluation</h3><p>
 
 
-<a name="%_idx_4054" id="%_idx_4054"></a><a name="%_idx_4056" id="%_idx_4056"></a>
+<a id="__idx_4054"></a><a id="__idx_4056"></a>
 The <tt>integral</tt> procedure at the end of the preceding section shows
 how we can use streams to model signal-processing systems that contain
-<a name="%_idx_4058" id="%_idx_4058"></a>feedback loops.  The feedback loop for the adder shown in
-figure <a href="#%_fig_3.32">3.32</a> is modeled by the fact that <tt>integral</tt>'s
-<a name="%_idx_4060" id="%_idx_4060"></a>internal stream <tt>int</tt> is defined in terms of itself:</p><p>
+<a id="__idx_4058"></a>feedback loops.  The feedback loop for the adder shown in
+figure <a href="#__fig_3.32">3.32</a> is modeled by the fact that <tt>integral</tt>'s
+<a id="__idx_4060"></a>internal stream <tt>int</tt> is defined in terms of itself:</p><p>
 
 </p><p></p><p><tt>(define int<br />
   (cons-stream initial-value<br />
@@ -1301,23 +1301,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 Unfortunately, stream models of systems with loops
 may require uses of <tt>delay</tt> beyond the “hidden” <tt>delay</tt>
 supplied by <tt>cons-stream</tt>.  For instance,
-figure <a href="#%_fig_3.34">3.34</a> shows a signal-processing system for
-solving the <a name="%_idx_4062" id="%_idx_4062"></a>differential equation <em>d</em><em>y</em>/<em>d</em><em>t</em> = <em>f</em>(<em>y</em>) where <em>f</em> is a given
+figure <a href="#__fig_3.34">3.34</a> shows a signal-processing system for
+solving the <a id="__idx_4062"></a>differential equation <em>d</em><em>y</em>/<em>d</em><em>t</em> = <em>f</em>(<em>y</em>) where <em>f</em> is a given
 function.  The figure shows a mapping component, which
 applies <em>f</em> to its input signal, linked in a feedback loop to an
 integrator in a manner very similar to that of the analog computer
 circuits that are actually used to solve such equations.</p><p>
 
-<a name="%_fig_3.34" id="%_fig_3.34"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-52.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.34:</b>  An “analog computer circuit” that solves the
+<a id="__fig_3.34"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-52.gif" alt="ch3-Z-G-52" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.34:</b>  An “analog computer circuit” that solves the
 equation
 <em>d</em><em>y</em>/<em>d</em><em>t</em> = <em>f</em>(<em>y</em>).</div></caption><tr><td>
-<a name="%_idx_4064" id="%_idx_4064"></a>
+<a id="__idx_4064"></a>
 </td></tr></table></div><p></p><p>
 
 Assuming we are given an initial value <em>y</em><sub>0</sub> for <em>y</em>, we
 could try to model this system using the procedure</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4066" id="%_idx_4066"></a>(define (solve f y0 dt)<br />
+</p><p></p><p><tt><a id="__idx_4066"></a>(define (solve f y0 dt)<br />
   (define y (integral dy y0 dt))<br />
   (define dy (stream-map f y))<br />
   y)<br /></tt></p><p></p><p>
@@ -1336,10 +1336,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 <tt>solve</tt> can begin working to generate the first element of <tt>dy</tt>, which will produce the next element of <tt>y</tt>, and so on.</p><p>
 
 To take advantage of this idea, we will redefine <tt>integral</tt> to
-expect the integrand stream to be a <a name="%_idx_4068" id="%_idx_4068"></a><a name="%_idx_4070" id="%_idx_4070"></a><a name="%_idx_4072" id="%_idx_4072"></a><em>delayed argument</em>.  <tt>Integral</tt> will <tt>force</tt> the integrand to be evaluated only when it
+expect the integrand stream to be a <a id="__idx_4068"></a><a id="__idx_4070"></a><a id="__idx_4072"></a><em>delayed argument</em>.  <tt>Integral</tt> will <tt>force</tt> the integrand to be evaluated only when it
 is required to generate more than the first element of the output stream:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4074" id="%_idx_4074"></a>(define (integral delayed-integrand initial-value dt)<br />
+</p><p></p><p><tt><a id="__idx_4074"></a>(define (integral delayed-integrand initial-value dt)<br />
   (define int<br />
     (cons-stream initial-value<br />
                  (let ((integrand (force delayed-integrand)))<br />
@@ -1347,27 +1347,27 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
                                 int))))<br />
   int)<br /></tt></p><p></p><p>
 Now we can implement our <tt>solve</tt> procedure by delaying the
-evaluation of <tt>dy</tt> in the definition of <tt>y</tt>:<a name="call_footnote_Temp_494" href="#footnote_Temp_494" id="call_footnote_Temp_494"><sup><small>71</small></sup></a></p><p>
+evaluation of <tt>dy</tt> in the definition of <tt>y</tt>:<a href="#footnote_Temp_494" id="call_footnote_Temp_494"><sup><small>71</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_4076" id="%_idx_4076"></a>(define (solve f y0 dt)<br />
+</p><p></p><p><tt><a id="__idx_4076"></a>(define (solve f y0 dt)<br />
   (define y (integral (delay dy) y0 dt))<br />
   (define dy (stream-map f y))<br />
   y)<br /></tt></p><p></p><p>
 In general, every caller of <tt>integral</tt> must now <tt>delay</tt> the
 integrand argument.  We can demonstrate that the <tt>solve</tt> procedure
-works by approximating <a name="%_idx_4078" id="%_idx_4078"></a><em>e</em> ≈  2.718 by computing the value at
+works by approximating <a id="__idx_4078"></a><em>e</em> ≈  2.718 by computing the value at
 <em>y</em> = 1 of the solution to the differential equation <em>d</em><em>y</em>/<em>d</em><em>t</em> = <em>y</em> with
 initial condition <em>y</em>(0) = 1:</p><p>
 
 </p><p></p><p><tt>(stream-ref (solve (lambda (y) y) 1 0.001) 1000)<br /><i>2.716924</i></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_3.77" id="%_thm_3.77"></a>
+</p><p><a id="__thm_3.77"></a>
 <b>Exercise 3.77.</b>  The <tt>integral</tt> procedure used above was analogous to the
 “implicit” definition of the infinite stream of integers in
-section <a href="#%_sec_3.5.2">3.5.2</a>.  Alternatively, we can give a
-definition of <tt>integral</tt> that is more like <tt>integers-starting-from</tt> (also in section <a href="#%_sec_3.5.2">3.5.2</a>):</p><p>
+section <a href="#__sec_3.5.2">3.5.2</a>.  Alternatively, we can give a
+definition of <tt>integral</tt> that is more like <tt>integers-starting-from</tt> (also in section <a href="#__sec_3.5.2">3.5.2</a>):</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4080" id="%_idx_4080"></a>(define (integral integrand initial-value dt)<br />
+</p><p></p><p><tt><a id="__idx_4080"></a>(define (integral integrand initial-value dt)<br />
   (cons-stream initial-value<br />
                (if (stream-null? integrand)<br />
                    the-empty-stream<br />
@@ -1381,53 +1381,53 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 can be used in the <tt>solve</tt> procedure shown above.
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.78" id="%_thm_3.78"></a>
-<b>Exercise 3.78.</b>  <a name="%_fig_3.35" id="%_fig_3.35"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-53.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.35:</b>  Signal-flow diagram for the solution to a second-order
+</p><p><a id="__thm_3.78"></a>
+<b>Exercise 3.78.</b>  <a id="__fig_3.35"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-53.gif" alt="ch3-Z-G-53" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.35:</b>  Signal-flow diagram for the solution to a second-order
 linear differential equation.</div></caption><tr><td>
 
 </td></tr></table></div><p>
-<a name="%_idx_4082" id="%_idx_4082"></a>Consider the problem of designing a signal-processing system to study
+<a id="__idx_4082"></a>Consider the problem of designing a signal-processing system to study
 the homogeneous second-order linear differential equation
-</p><p></p><div align="left"><img src="images/ch3-Z-G-54.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch3-Z-G-54.gif" alt="ch3-Z-G-54" style="border: none;" /></div><p>
 The output stream, modeling <em>y</em>, is generated by a network that
 contains a loop. This is because the value of <em>d</em><sup>2</sup><em>y</em>/<em>d</em><em>t</em><sup>2</sup> depends
 upon the values of <em>y</em> and <em>d</em><em>y</em>/<em>d</em><em>t</em> and both of these are determined by
 integrating <em>d</em><sup>2</sup><em>y</em>/<em>d</em><em>t</em><sup>2</sup>.  The diagram we would like to encode is
-shown in figure <a href="#%_fig_3.35">3.35</a>.  Write a procedure <tt>solve-2nd</tt> that
+shown in figure <a href="#__fig_3.35">3.35</a>.  Write a procedure <tt>solve-2nd</tt> that
 takes as arguments the constants <em>a</em>, <em>b</em>, and <em>d</em><em>t</em> and the initial
 values <em>y</em><sub>0</sub> and <em>d</em><em>y</em><sub>0</sub> for <em>y</em> and <em>d</em><em>y</em>/<em>d</em><em>t</em> and generates the
 stream of successive values of <em>y</em>.
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.79" id="%_thm_3.79"></a>
-<b>Exercise 3.79.</b>  <a name="%_idx_4084" id="%_idx_4084"></a>Generalize the <tt>solve-2nd</tt> procedure of exercise <a href="#%_thm_3.78">3.78</a> so
+</p><p><a id="__thm_3.79"></a>
+<b>Exercise 3.79.</b>  <a id="__idx_4084"></a>Generalize the <tt>solve-2nd</tt> procedure of exercise <a href="#__thm_3.78">3.78</a> so
 that it can be used to solve general second-order differential
 equations <em>d</em><sup>2</sup><em>y</em>/<em>d</em><em>t</em><sup>2</sup> = <em>f</em>(<em>d</em><em>y</em>/<em>d</em><em>t</em>,  <em>y</em>).
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.80" id="%_thm_3.80"></a>
-<b>Exercise 3.80.</b>  <a name="%_idx_4086" id="%_idx_4086"></a><a name="%_idx_4088" id="%_idx_4088"></a><a name="%_idx_4090" id="%_idx_4090"></a>A <em>series RLC circuit</em> consists of a resistor, a capacitor, and an
-inductor connected in series, as shown in figure <a href="#%_fig_3.36">3.36</a>.
+</p><p><a id="__thm_3.80"></a>
+<b>Exercise 3.80.</b>  <a id="__idx_4086"></a><a id="__idx_4088"></a><a id="__idx_4090"></a>A <em>series RLC circuit</em> consists of a resistor, a capacitor, and an
+inductor connected in series, as shown in figure <a href="#__fig_3.36">3.36</a>.
 If <em>R</em>, <em>L</em>, and <em>C</em> are the resistance, inductance, and capacitance,
 then the relations between voltage (<em>v</em>) and current (<em>i</em>)
 for the three components are described by the equations
-</p><p></p><div align="left"><img src="images/ch3-Z-G-55.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch3-Z-G-55.gif" alt="ch3-Z-G-55" style="border: none;" /></div><p>
 </p><p>
 
 and the circuit connections dictate the relations
-</p><p></p><div align="left"><img src="images/ch3-Z-G-56.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch3-Z-G-56.gif" alt="ch3-Z-G-56" style="border: none;" /></div><p>
 Combining these equations shows that the state of the circuit
 (summarized by <em>v</em><sub><em>C</em></sub>, the voltage across the capacitor, and <em>i</em><sub><em>L</em></sub>, the
 current in the inductor)
 is described by the pair of differential equations
-</p><p></p><div align="left"><img src="images/ch3-Z-G-57.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch3-Z-G-57.gif" alt="ch3-Z-G-57" style="border: none;" /></div><p>
 The signal-flow diagram representing this system of differential
-equations is shown in figure <a href="#%_fig_3.37">3.37</a>.
-<a name="%_fig_3.36" id="%_fig_3.36"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-58.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.36:</b>  A series RLC circuit.</div></caption><tr><td>
+equations is shown in figure <a href="#__fig_3.37">3.37</a>.
+<a id="__fig_3.36"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-58.gif" alt="ch3-Z-G-58" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.36:</b>  A series RLC circuit.</div></caption><tr><td>
 
 </td></tr></table></div><p>
-<a name="%_fig_3.37" id="%_fig_3.37"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-59.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.37:</b>  A signal-flow diagram for the solution
+<a id="__fig_3.37"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-59.gif" alt="ch3-Z-G-59" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.37:</b>  A signal-flow diagram for the solution
 to a series RLC circuit.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
@@ -1435,7 +1435,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 Write a procedure <tt>RLC</tt> that takes as arguments the parameters
 <em>R</em>, <em>L</em>, and <em>C</em> of the circuit and the time increment <em>d</em><em>t</em>.  In a
 manner similar to that of the <tt>RC</tt> procedure of
-exercise <a href="#%_thm_3.73">3.73</a>, <tt>RLC</tt> should produce a procedure
+exercise <a href="#__thm_3.73">3.73</a>, <tt>RLC</tt> should produce a procedure
 that takes the initial values of the state variables, <em>v</em><sub><em>C</em><sub>0</sub></sub> and
 <em>i</em><sub><em>L</em><sub>0</sub></sub>, and produces a pair (using <tt>cons</tt>) of the streams of
 states <em>v</em><sub><em>C</em></sub> and <em>i</em><sub><em>L</em></sub>.  Using <tt>RLC</tt>, generate the pair of
@@ -1445,10 +1445,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 </p><p>
 </p><p>
 
-<a name="%_sec_Temp_499" id="%_sec_Temp_499"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_499">Normal-order evaluation</a></h4><p>
+<a id="__sec_Temp_499"></a>
+</p><h4>Normal-order evaluation</h4><p>
 
-<a name="%_idx_4092" id="%_idx_4092"></a><a name="%_idx_4094" id="%_idx_4094"></a>
+<a id="__idx_4092"></a><a id="__idx_4094"></a>
 The examples in this section illustrate how the explicit use of <tt>delay</tt> and <tt>force</tt> provides great programming flexibility, but the
 same examples also show how this can make our programs more complex.
 Our new <tt>integral</tt> procedure, for instance, gives us the power to
@@ -1458,7 +1458,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 two classes of procedures: ordinary procedures and procedures that
 take delayed arguments.  In general, creating separate classes of
 procedures forces us to create separate classes of higher-order
-procedures as well.<a name="call_footnote_Temp_500" href="#footnote_Temp_500" id="call_footnote_Temp_500"><sup><small>72</small></sup></a></p><p>
+procedures as well.<a href="#footnote_Temp_500" id="call_footnote_Temp_500"><sup><small>72</small></sup></a></p><p>
 
 One way to avoid the need for two different classes of procedures is
 to make all procedures take delayed arguments.  We could adopt a model
@@ -1467,33 +1467,33 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 (for example, when they are required by a primitive operation).  This
 would transform our language to use normal-order evaluation, which we
 first described when we introduced the substitution model for
-evaluation in section <a href="book-Z-H-10.html#%_sec_1.1.5">1.1.5</a>.  Converting to
+evaluation in section <a href="book-Z-H-10.html#__sec_1.1.5">1.1.5</a>.  Converting to
 normal-order evaluation provides a uniform and elegant way to simplify
 the use of delayed evaluation, and this would be a natural strategy to
 adopt if we were concerned only with stream processing.  In
-section <a href="book-Z-H-27.html#%_sec_4.2">4.2</a>, after we have studied the evaluator, we
+section <a href="book-Z-H-27.html#__sec_4.2">4.2</a>, after we have studied the evaluator, we
 will see how to transform our language in just this way.
 Unfortunately, including delays in procedure calls wreaks havoc with
 our ability to design programs that depend on the order of events,
 such as programs that use assignment, mutate data, or perform input or
 output.  Even the single <tt>delay</tt> in <tt>cons-stream</tt> can cause
-great confusion, as illustrated by exercises <a href="#%_thm_3.51">3.51</a>
-and <a href="#%_thm_3.52">3.52</a>.  As far as anyone knows, mutability and delayed
+great confusion, as illustrated by exercises <a href="#__thm_3.51">3.51</a>
+and <a href="#__thm_3.52">3.52</a>.  As far as anyone knows, mutability and delayed
 evaluation do not mix well in programming languages, and devising ways
 to deal with both of these at once is an active area of research.
 
-<a name="%_sec_3.5.5" id="%_sec_3.5.5"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_3.5.5">3.5.5  Modularity of Functional Programs and Modularity of Objects</a></h3><p>
+<a id="__sec_3.5.5"></a>
+</p><h3>3.5.5  Modularity of Functional Programs and Modularity of Objects</h3><p>
 
 
-<a name="%_idx_4116" id="%_idx_4116"></a><a name="%_idx_4118" id="%_idx_4118"></a>
-As we saw in section <a href="book-Z-H-20.html#%_sec_3.1.2">3.1.2</a>, one of the
+<a id="__idx_4116"></a><a id="__idx_4118"></a>
+As we saw in section <a href="book-Z-H-20.html#__sec_3.1.2">3.1.2</a>, one of the
 major benefits of introducing assignment is that we can increase the
 modularity of our systems by encapsulating, or “hiding,” parts of
 the state of a large system within local variables.  Stream models can
 provide an equivalent modularity without the use of assignment.  As an
-<a name="%_idx_4120" id="%_idx_4120"></a><a name="%_idx_4122" id="%_idx_4122"></a>illustration, we can reimplement the Monte Carlo estimation of π,
-which we examined in section <a href="book-Z-H-20.html#%_sec_3.1.2">3.1.2</a>, from a
+<a id="__idx_4120"></a><a id="__idx_4122"></a>illustration, we can reimplement the Monte Carlo estimation of π,
+which we examined in section <a href="book-Z-H-20.html#__sec_3.1.2">3.1.2</a>, from a
 stream-processing point of view.</p><p>
 
 
@@ -1515,16 +1515,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 <tt>rand-update</tt>:</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_4124" id="%_idx_4124"></a><a name="%_idx_4126" id="%_idx_4126"></a>(define random-numbers<br />
+</p><p></p><p><tt><a id="__idx_4124"></a><a id="__idx_4126"></a>(define random-numbers<br />
   (cons-stream random-init<br />
                (stream-map rand-update random-numbers)))<br /></tt></p><p></p><p>
 We use this to construct the stream of outcomes of the Cesàro
 experiment performed on consecutive pairs in the <tt>random-numbers</tt>
 stream:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4128" id="%_idx_4128"></a>(define cesaro-stream<br />
+</p><p></p><p><tt><a id="__idx_4128"></a>(define cesaro-stream<br />
   (map-successive-pairs (lambda (r1 r2) (= (gcd r1 r2) 1))<br />
-                        random-numbers))<br /><br /><a name="%_idx_4130" id="%_idx_4130"></a>(define (map-successive-pairs f s)<br />
+                        random-numbers))<br /><br /><a id="__idx_4130"></a>(define (map-successive-pairs f s)<br />
   (cons-stream<br />
    (f (stream-car s) (stream-car (stream-cdr s)))<br />
    (map-successive-pairs f (stream-cdr (stream-cdr s)))))<br /></tt></p><p></p><p>
@@ -1535,7 +1535,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 perform.  Better estimates of π (from performing more experiments)
 are obtained by looking farther into the <tt>pi</tt> stream:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4132" id="%_idx_4132"></a>(define (monte-carlo experiment-stream passed failed)<br />
+</p><p></p><p><tt><a id="__idx_4132"></a>(define (monte-carlo experiment-stream passed failed)<br />
   (define (next passed failed)<br />
     (cons-stream<br />
      (/ passed (+ passed failed))<br />
@@ -1547,12 +1547,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 (define pi<br />
   (stream-map (lambda (p) (sqrt (/ 6 p)))<br />
               (monte-carlo cesaro-stream 0 0)))<br /></tt></p><p></p><p>
-<a name="%_idx_4134" id="%_idx_4134"></a>There is considerable modularity in this approach, because we still
+<a id="__idx_4134"></a>There is considerable modularity in this approach, because we still
 can formulate a general <tt>monte-carlo</tt> procedure that can deal with
 arbitrary experiments.  Yet there is no assignment or local state.</p><p>
 
-</p><p><a name="%_thm_3.81" id="%_thm_3.81"></a>
-<b>Exercise 3.81.</b>  <a name="%_idx_4136" id="%_idx_4136"></a>Exercise <a href="book-Z-H-20.html#%_thm_3.6">3.6</a>
+</p><p><a id="__thm_3.81"></a>
+<b>Exercise 3.81.</b>  <a id="__idx_4136"></a>Exercise <a href="book-Z-H-20.html#__thm_3.6">3.6</a>
 discussed generalizing the random-number generator to
 allow one to reset the random-number sequence so as to produce
 repeatable sequences of “random” numbers.  Produce a stream
@@ -1562,17 +1562,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 random numbers.  Don't use assignment in your solution.
 </p><p></p><p>
 
-</p><p><a name="%_thm_3.82" id="%_thm_3.82"></a>
-<b>Exercise 3.82.</b>  <a name="%_idx_4138" id="%_idx_4138"></a><a name="%_idx_4140" id="%_idx_4140"></a><a name="%_idx_4142" id="%_idx_4142"></a>Redo exercise <a href="book-Z-H-20.html#%_thm_3.5">3.5</a> on Monte Carlo
+</p><p><a id="__thm_3.82"></a>
+<b>Exercise 3.82.</b>  <a id="__idx_4138"></a><a id="__idx_4140"></a><a id="__idx_4142"></a>Redo exercise <a href="book-Z-H-20.html#__thm_3.5">3.5</a> on Monte Carlo
 integration in terms of streams.  The stream version of <tt>estimate-integral</tt> will not have an argument telling how many trials
 to perform.  Instead, it will produce a stream of estimates based on
 successively more trials.
 </p><p></p><p>
 
-<a name="%_sec_Temp_503" id="%_sec_Temp_503"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_503">A functional-programming view of time</a></h4><p>
+<a id="__sec_Temp_503"></a>
+</p><h4>A functional-programming view of time</h4><p>
 
-<a name="%_idx_4144" id="%_idx_4144"></a><a name="%_idx_4146" id="%_idx_4146"></a>
+<a id="__idx_4144"></a><a id="__idx_4146"></a>
 Let us now return to the issues of objects and state that were raised
 at the beginning of this chapter and examine them in a new light.  We
 introduced assignment and mutable objects to provide a mechanism for
@@ -1595,11 +1595,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 
 In order to contrast these two approaches to modeling, let us
 reconsider the implementation of a “withdrawal processor” that
-<a name="%_idx_4148" id="%_idx_4148"></a>monitors the balance in a bank account.  In
-section <a href="book-Z-H-20.html#%_sec_3.1.3">3.1.3</a> we implemented a simplified
+<a id="__idx_4148"></a>monitors the balance in a bank account.  In
+section <a href="book-Z-H-20.html#__sec_3.1.3">3.1.3</a> we implemented a simplified
 version of such a processor:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4150" id="%_idx_4150"></a>(define (make-simplified-withdraw balance)<br />
+</p><p></p><p><tt><a id="__idx_4150"></a>(define (make-simplified-withdraw balance)<br />
   (lambda (amount)<br />
     (set! balance (- balance amount))<br />
     balance))<br /></tt></p><p></p><p>
@@ -1614,7 +1614,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 takes as input a balance and a stream of amounts to withdraw and
 produces the stream of successive balances in the account:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4152" id="%_idx_4152"></a>(define (stream-withdraw balance amount-stream)<br />
+</p><p></p><p><tt><a id="__idx_4152"></a>(define (stream-withdraw balance amount-stream)<br />
   (cons-stream<br />
    balance<br />
    (stream-withdraw (- balance (stream-car amount-stream))<br />
@@ -1628,7 +1628,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 object created by <tt>make-simplified-withdraw</tt>.  However, with the
 stream version, there is no assignment, no local state variable, and
 consequently none of the theoretical difficulties that we encountered
-<a name="%_idx_4154" id="%_idx_4154"></a>in section <a href="book-Z-H-20.html#%_sec_3.1.3">3.1.3</a>.  Yet the system has state!</p><p>
+<a id="__idx_4154"></a>in section <a href="book-Z-H-20.html#__sec_3.1.3">3.1.3</a>.  Yet the system has state!</p><p>
 
 This is really remarkable.  Even though <tt>stream-withdraw</tt> implements a
 well-defined mathematical function whose behavior does not change, the
@@ -1637,7 +1637,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 is the user's temporal existence that imposes state on the system.  If
 the user could step back from the interaction and think in terms of
 streams of balances rather than individual transactions, the system
-would appear stateless.<a name="call_footnote_Temp_504" href="#footnote_Temp_504" id="call_footnote_Temp_504"><sup><small>73</small></sup></a></p><p>
+would appear stateless.<a href="#footnote_Temp_504" id="call_footnote_Temp_504"><sup><small>73</small></sup></a></p><p>
 
 From the point of view of one part of a complex process, the other
 parts appear to change with time.  They have hidden time-varying local
@@ -1656,12 +1656,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 part.  However, as we've seen repeatedly throughout this chapter,
 these models raise thorny problems of constraining the order of events
 and of synchronizing multiple processes.  The possibility of avoiding
-these problems has stimulated the development of <a name="%_idx_4158" id="%_idx_4158"></a><a name="%_idx_4160" id="%_idx_4160"></a><em>functional
+these problems has stimulated the development of <a id="__idx_4158"></a><a id="__idx_4160"></a><em>functional
 programming languages</em>, which do not include any provision for
 assignment or mutable data.  In such a language, all procedures
 implement well-defined mathematical functions of their arguments,
 whose behavior does not change.  The functional approach is extremely
-<a name="%_idx_4162" id="%_idx_4162"></a><a name="%_idx_4164" id="%_idx_4164"></a>attractive for dealing with concurrent systems.<a name="call_footnote_Temp_505" href="#footnote_Temp_505" id="call_footnote_Temp_505"><sup><small>74</small></sup></a></p><p>
+<a id="__idx_4162"></a><a id="__idx_4164"></a>attractive for dealing with concurrent systems.<a href="#footnote_Temp_505" id="call_footnote_Temp_505"><sup><small>74</small></sup></a></p><p>
 
 On the other hand, if we look closely, we can see time-related
 problems creeping into functional models as well.  One particularly
@@ -1672,7 +1672,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 assignment and objects, we would model the fact that Peter and Paul
 share an account by having both Peter and Paul send their transaction
 requests to the same bank-account object, as we saw in
-section <a href="book-Z-H-20.html#%_sec_3.1.3">3.1.3</a>.
+section <a href="book-Z-H-20.html#__sec_3.1.3">3.1.3</a>.
 From the stream point of view, where there are no “objects” <em>per
 se</em>, we have already indicated that a bank account can be modeled as a
 process that operates on a stream of transaction requests to produce a
@@ -1680,14 +1680,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 and Paul have a joint bank account by merging Peter's stream of
 transaction requests with Paul's stream of requests and feeding the
 result to the bank-account stream process, as shown in
-figure <a href="#%_fig_3.38">3.38</a>.</p><p>
+figure <a href="#__fig_3.38">3.38</a>.</p><p>
 
-<a name="%_fig_3.38" id="%_fig_3.38"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch3-Z-G-60.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 3.38:</b>  A joint bank account, modeled by merging two streams of
+<a id="__fig_3.38"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch3-Z-G-60.gif" alt="ch3-Z-G-60" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 3.38:</b>  A joint bank account, modeled by merging two streams of
 transaction requests.</div></caption><tr><td>
 
-<a name="%_idx_4176" id="%_idx_4176"></a></td></tr></table></div><p></p><p>
+<a id="__idx_4176"></a></td></tr></table></div><p></p><p>
 
-<a name="%_idx_4178" id="%_idx_4178"></a>The trouble with this formulation is in the notion of <em>merge</em>.  It
+<a id="__idx_4178"></a>The trouble with this formulation is in the notion of <em>merge</em>.  It
 will not do to merge the two streams by simply taking alternately one
 request from Peter and one request from Paul. Suppose Paul accesses
 the account only very rarely.  We could hardly force Peter to wait for
@@ -1697,9 +1697,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 time” as perceived by Peter and Paul, in the sense that, if Peter and
 Paul meet, they can agree that certain transactions were processed
 before the meeting, and other transactions were processed after the
-meeting.<a name="call_footnote_Temp_506" href="#footnote_Temp_506" id="call_footnote_Temp_506"><sup><small>75</small></sup></a>
+meeting.<a href="#footnote_Temp_506" id="call_footnote_Temp_506"><sup><small>75</small></sup></a>
 This is precisely the same constraint that we had to deal with in
-section <a href="book-Z-H-23.html#%_sec_3.4.1">3.4.1</a>, where we found the need to introduce
+section <a href="book-Z-H-23.html#__sec_3.4.1">3.4.1</a>, where we found the need to introduce
 explicit synchronization to ensure a “correct” order of events in
 concurrent processing of objects with state.  Thus, in an attempt to
 support the functional style, the need to merge inputs from different
@@ -1712,139 +1712,139 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 time-bound, interacting objects with state, or we can model the world
 as a single, timeless, stateless unity.  Each view has powerful
 advantages, but neither view alone is completely satisfactory.  A
-grand unification has yet to emerge.<a name="call_footnote_Temp_507" href="#footnote_Temp_507" id="call_footnote_Temp_507"><sup><small>76</small></sup></a>
+grand unification has yet to emerge.<a href="#footnote_Temp_507" id="call_footnote_Temp_507"><sup><small>76</small></sup></a>
 </p><p>
 
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_442" href="#call_footnote_Temp_442" id="footnote_Temp_442"><sup><small>52</small></sup></a> Physicists sometimes adopt this view by introducing the
-<a name="%_idx_3728" id="%_idx_3728"></a>“world lines” of particles as a device for reasoning about motion.
+</p><div class="footnote"><p><a href="#call_footnote_Temp_442" id="footnote_Temp_442"><sup><small>52</small></sup></a> Physicists sometimes adopt this view by introducing the
+<a id="__idx_3728"></a>“world lines” of particles as a device for reasoning about motion.
 We've also already mentioned
-(section <a href="book-Z-H-15.html#%_sec_2.2.3">2.2.3</a>) that this is the
+(section <a href="book-Z-H-15.html#__sec_2.2.3">2.2.3</a>) that this is the
 natural way to think about signal-processing systems.  We will explore
 applications of streams to signal processing in
-section <a href="#%_sec_3.5.3">3.5.3</a>.
+section <a href="#__sec_3.5.3">3.5.3</a>.
 
-</p><p><a name="footnote_Temp_443" href="#call_footnote_Temp_443" id="footnote_Temp_443"><sup><small>53</small></sup></a> Assume that we have a
-predicate <tt>prime?</tt> (e.g., as in section <a href="book-Z-H-11.html#%_sec_1.2.6">1.2.6</a>) that
+</p><p><a href="#call_footnote_Temp_443" id="footnote_Temp_443"><sup><small>53</small></sup></a> Assume that we have a
+predicate <tt>prime?</tt> (e.g., as in section <a href="book-Z-H-11.html#__sec_1.2.6">1.2.6</a>) that
 tests for primality.
 
-</p><p><a name="footnote_Temp_444" href="#call_footnote_Temp_444" id="footnote_Temp_444"><sup><small>54</small></sup></a> In the MIT implementation, <a name="%_idx_3752" id="%_idx_3752"></a><a name="%_idx_3754" id="%_idx_3754"></a><a name="%_idx_3756" id="%_idx_3756"></a><tt>the-empty-stream</tt> is the
+</p><p><a href="#call_footnote_Temp_444" id="footnote_Temp_444"><sup><small>54</small></sup></a> In the MIT implementation, <a id="__idx_3752"></a><a id="__idx_3754"></a><a id="__idx_3756"></a><tt>the-empty-stream</tt> is the
 same as the empty list <tt>'()</tt>, and <tt>stream-null?</tt> is the same
 as <tt>null?</tt>.
 
-</p><p><a name="footnote_Temp_445" href="#call_footnote_Temp_445" id="footnote_Temp_445"><sup><small>55</small></sup></a> This should bother you.  The fact that we are defining such
+</p><p><a href="#call_footnote_Temp_445" id="footnote_Temp_445"><sup><small>55</small></sup></a> This should bother you.  The fact that we are defining such
 similar procedures for streams and lists indicates that we are missing some
 underlying abstraction.  Unfortunately, in order to exploit this
 abstraction, we will need to exert finer control over the process of
 evaluation than we can at present.  We will discuss this point further
-at the end of section <a href="#%_sec_3.5.4">3.5.4</a>.
-In section <a href="book-Z-H-27.html#%_sec_4.2">4.2</a>, we'll develop a framework that
+at the end of section <a href="#__sec_3.5.4">3.5.4</a>.
+In section <a href="book-Z-H-27.html#__sec_4.2">4.2</a>, we'll develop a framework that
 unifies lists and streams.
 
-</p><p><a name="footnote_Temp_446" href="#call_footnote_Temp_446" id="footnote_Temp_446"><sup><small>56</small></sup></a> Although <tt>stream-car</tt> and
-<a name="%_idx_3784" id="%_idx_3784"></a><a name="%_idx_3786" id="%_idx_3786"></a><tt>stream-cdr</tt> can be defined as procedures, <tt>cons-stream</tt> must
+</p><p><a href="#call_footnote_Temp_446" id="footnote_Temp_446"><sup><small>56</small></sup></a> Although <tt>stream-car</tt> and
+<a id="__idx_3784"></a><a id="__idx_3786"></a><tt>stream-cdr</tt> can be defined as procedures, <tt>cons-stream</tt> must
 be a special form.  If <tt>cons-stream</tt> were a procedure, then,
 according to our model of evaluation, evaluating <tt>(cons-stream
 &lt;<em>a</em>&gt; &lt;<em>b</em>&gt;)</tt> would automatically cause &lt;<em>b</em>&gt; to be evaluated, which is
 precisely what we do not want to happen.  For the same reason, <tt>delay</tt> must be a special form, though <tt>force</tt> can be an ordinary
 procedure.
 
-</p><p><a name="footnote_Temp_448" href="#call_footnote_Temp_448" id="footnote_Temp_448"><sup><small>57</small></sup></a> The numbers shown here do
+</p><p><a href="#call_footnote_Temp_448" id="footnote_Temp_448"><sup><small>57</small></sup></a> The numbers shown here do
 not really appear in the delayed expression.  What actually appears is
 the original expression, in an environment in which the variables are
 bound to the appropriate numbers.  For example, <tt>(+ low 1)</tt> with
 <tt>low</tt> bound to 10,000 actually appears where <tt>10001</tt> is
 shown.
 
-</p><p><a name="footnote_Temp_450" href="#call_footnote_Temp_450" id="footnote_Temp_450"><sup><small>58</small></sup></a> There are many
+</p><p><a href="#call_footnote_Temp_450" id="footnote_Temp_450"><sup><small>58</small></sup></a> There are many
 possible implementations of streams other than the one described in
 this section.  Delayed evaluation, which is the key to making streams
-practical, was inherent in <a name="%_idx_3806" id="%_idx_3806"></a><a name="%_idx_3808" id="%_idx_3808"></a>Algol 60's <em>call-by-name</em>
+practical, was inherent in <a id="__idx_3806"></a><a id="__idx_3808"></a>Algol 60's <em>call-by-name</em>
 parameter-passing method.  The use of this mechanism to implement
-streams was first described by <a name="%_idx_3810" id="%_idx_3810"></a>Landin (1965).  Delayed evaluation for
-streams was introduced into Lisp by <a name="%_idx_3812" id="%_idx_3812"></a><a name="%_idx_3814" id="%_idx_3814"></a>Friedman and Wise (1976). In their
+streams was first described by <a id="__idx_3810"></a>Landin (1965).  Delayed evaluation for
+streams was introduced into Lisp by <a id="__idx_3812"></a><a id="__idx_3814"></a>Friedman and Wise (1976). In their
 implementation, <tt>cons</tt> always delays evaluating its arguments, so
 that lists automatically behave as streams.  The memoizing
-optimization is also known as <a name="%_idx_3816" id="%_idx_3816"></a><a name="%_idx_3818" id="%_idx_3818"></a><a name="%_idx_3820" id="%_idx_3820"></a><a name="%_idx_3822" id="%_idx_3822"></a><em>call-by-need</em>.  The Algol community
+optimization is also known as <a id="__idx_3816"></a><a id="__idx_3818"></a><a id="__idx_3820"></a><a id="__idx_3822"></a><em>call-by-need</em>.  The Algol community
 would refer to our original delayed objects as <em>call-by-name
 thunks</em> and to the optimized versions as <em>call-by-need thunks</em>.
 
-</p><p><a name="footnote_Temp_453" href="#call_footnote_Temp_453" id="footnote_Temp_453"><sup><small>59</small></sup></a> Exercises such as <a href="#%_thm_3.51">3.51</a> and <a href="#%_thm_3.52">3.52</a>
+</p><p><a href="#call_footnote_Temp_453" id="footnote_Temp_453"><sup><small>59</small></sup></a> Exercises such as <a href="#__thm_3.51">3.51</a> and <a href="#__thm_3.52">3.52</a>
 are valuable for testing our understanding of how <tt>delay</tt> works.
 On the other hand, intermixing delayed evaluation with printing – and,
 even worse, with assignment – is extremely confusing, and instructors
 of courses on computer languages have traditionally tormented their
 students with examination questions such as the ones in this section.
 Needless to say, writing programs that depend on such subtleties is
-<a name="%_idx_3828" id="%_idx_3828"></a>odious programming style.  Part of the power of stream processing is
+<a id="__idx_3828"></a>odious programming style.  Part of the power of stream processing is
 that it lets us ignore the order in which events actually happen in
 our programs.  Unfortunately, this is precisely what we cannot afford
 to do in the presence of assignment, which forces us to be concerned
 with time and change.
 
-</p><p><a name="footnote_Temp_455" href="#call_footnote_Temp_455" id="footnote_Temp_455"><sup><small>60</small></sup></a> Eratosthenes, a third-century <font size="-2">B</font>.<font size="-2">C</font>.
-<a name="%_idx_3846" id="%_idx_3846"></a><a name="%_idx_3848" id="%_idx_3848"></a>Alexandrian Greek philosopher, is famous for giving the first accurate
+</p><p><a href="#call_footnote_Temp_455" id="footnote_Temp_455"><sup><small>60</small></sup></a> Eratosthenes, a third-century <font size="-2">B</font>.<font size="-2">C</font>.
+<a id="__idx_3846"></a><a id="__idx_3848"></a>Alexandrian Greek philosopher, is famous for giving the first accurate
 estimate of the circumference of the Earth, which he computed by
 observing shadows cast at noon on the day of the summer solstice.
 Eratosthenes's sieve method, although ancient, has formed the basis
 for special-purpose hardware “sieves” that, until recently, were the
 most powerful tools in existence for locating large primes.  Since the
 70s, however, these methods have been superseded by outgrowths of the
-<a name="%_idx_3850" id="%_idx_3850"></a>probabilistic techniques discussed in section <a href="book-Z-H-11.html#%_sec_1.2.6">1.2.6</a>.
+<a id="__idx_3850"></a>probabilistic techniques discussed in section <a href="book-Z-H-11.html#__sec_1.2.6">1.2.6</a>.
 
-</p><p><a name="footnote_Temp_456" href="#call_footnote_Temp_456" id="footnote_Temp_456"><sup><small>61</small></sup></a> We have named these figures after <a name="%_idx_3858" id="%_idx_3858"></a>Peter Henderson, who
+</p><p><a href="#call_footnote_Temp_456" id="footnote_Temp_456"><sup><small>61</small></sup></a> We have named these figures after <a id="__idx_3858"></a>Peter Henderson, who
 was the first person to show us diagrams of this sort as a way of
 thinking about stream processing.  Each solid line represents a stream
 of values being transmitted.  The dashed line from the <tt>car</tt> to
 the <tt>cons</tt> and the <tt>filter</tt> indicates that this is a single
 value rather than a stream.
 
-</p><p><a name="footnote_Temp_458" href="#call_footnote_Temp_458" id="footnote_Temp_458"><sup><small>62</small></sup></a> This uses the generalized version
-of <tt>stream-map</tt> from exercise <a href="#%_thm_3.50">3.50</a>.
+</p><p><a href="#call_footnote_Temp_458" id="footnote_Temp_458"><sup><small>62</small></sup></a> This uses the generalized version
+of <tt>stream-map</tt> from exercise <a href="#__thm_3.50">3.50</a>.
 
-</p><p><a name="footnote_Temp_459" href="#call_footnote_Temp_459" id="footnote_Temp_459"><sup><small>63</small></sup></a> This last point is
+</p><p><a href="#call_footnote_Temp_459" id="footnote_Temp_459"><sup><small>63</small></sup></a> This last point is
 very subtle and relies on the fact that <em>p</em><sub><em>n</em>+1</sub><u>&lt;</u> <em>p</em><sub><em>n</em></sub><sup>2</sup>.
 (Here, <em>p</em><sub><em>k</em></sub> denotes the <em>k</em>th prime.)  Estimates such as these are
-very difficult to establish.  The ancient proof by <a name="%_idx_3876" id="%_idx_3876"></a>Euclid that there
+very difficult to establish.  The ancient proof by <a id="__idx_3876"></a>Euclid that there
 are an infinite number of primes shows that <em>p</em><sub><em>n</em>+1</sub><u>&lt;</u> <em>p</em><sub>1</sub><em>p</em><sub>2</sub><tt>···</tt>   <em>p</em><sub><em>n</em></sub>  + 1, and no substantially better result was proved
 until 1851, when the Russian mathematician P. L. Chebyshev established
-<a name="%_idx_3878" id="%_idx_3878"></a><a name="%_idx_3880" id="%_idx_3880"></a><a name="%_idx_3882" id="%_idx_3882"></a><a name="%_idx_3884" id="%_idx_3884"></a>that <em>p</em><sub><em>n</em>+1</sub><u>&lt;</u> 2<em>p</em><sub><em>n</em></sub> for all <em>n</em>.  This result, originally
+<a id="__idx_3878"></a><a id="__idx_3880"></a><a id="__idx_3882"></a><a id="__idx_3884"></a>that <em>p</em><sub><em>n</em>+1</sub><u>&lt;</u> 2<em>p</em><sub><em>n</em></sub> for all <em>n</em>.  This result, originally
 conjectured in 1845, is known as <em>Bertrand's hypothesis</em>.  A proof
 can be found in section 22.3 of Hardy and Wright 1960.
 
-</p><p><a name="footnote_Temp_465" href="#call_footnote_Temp_465" id="footnote_Temp_465"><sup><small>64</small></sup></a> This exercise shows how call-by-need is closely related to
-<a name="%_idx_3902" id="%_idx_3902"></a><a name="%_idx_3904" id="%_idx_3904"></a>ordinary memoization as described in exercise <a href="book-Z-H-22.html#%_thm_3.27">3.27</a>.
+</p><p><a href="#call_footnote_Temp_465" id="footnote_Temp_465"><sup><small>64</small></sup></a> This exercise shows how call-by-need is closely related to
+<a id="__idx_3902"></a><a id="__idx_3904"></a>ordinary memoization as described in exercise <a href="book-Z-H-22.html#__thm_3.27">3.27</a>.
 In that exercise, we used assignment to explicitly construct a local
 table.  Our call-by-need stream optimization effectively constructs
 such a table automatically, storing values in the previously forced
 parts of the stream.
 
-</p><p><a name="footnote_Temp_472" href="#call_footnote_Temp_472" id="footnote_Temp_472"><sup><small>65</small></sup></a> We can't use <tt>let</tt> to bind the local variable
-<tt>guesses</tt>, because the value of <tt>guesses</tt> depends on <tt>guesses</tt> itself.  Exercise <a href="#%_thm_3.63">3.63</a> addresses why
+</p><p><a href="#call_footnote_Temp_472" id="footnote_Temp_472"><sup><small>65</small></sup></a> We can't use <tt>let</tt> to bind the local variable
+<tt>guesses</tt>, because the value of <tt>guesses</tt> depends on <tt>guesses</tt> itself.  Exercise <a href="#__thm_3.63">3.63</a> addresses why
 we want a local variable here.
 
-</p><p><a name="footnote_Temp_477" href="#call_footnote_Temp_477" id="footnote_Temp_477"><sup><small>66</small></sup></a> As in section <a href="book-Z-H-15.html#%_sec_2.2.3">2.2.3</a>,
+</p><p><a href="#call_footnote_Temp_477" id="footnote_Temp_477"><sup><small>66</small></sup></a> As in section <a href="book-Z-H-15.html#__sec_2.2.3">2.2.3</a>,
 we represent a pair of integers as a list rather than a Lisp pair.
 
-</p><p><a name="footnote_Temp_478" href="#call_footnote_Temp_478" id="footnote_Temp_478"><sup><small>67</small></sup></a> See exercise <a href="#%_thm_3.68">3.68</a> for some insight
+</p><p><a href="#call_footnote_Temp_478" id="footnote_Temp_478"><sup><small>67</small></sup></a> See exercise <a href="#__thm_3.68">3.68</a> for some insight
 into why we chose this decomposition.
 
-</p><p><a name="footnote_Temp_479" href="#call_footnote_Temp_479" id="footnote_Temp_479"><sup><small>68</small></sup></a> The precise statement of the
+</p><p><a href="#call_footnote_Temp_479" id="footnote_Temp_479"><sup><small>68</small></sup></a> The precise statement of the
 required property on the order of combination is as follows: There
 should be a function <em>f</em> of two arguments such that the pair
 corresponding to element <em>i</em> of the first stream and element <em>j</em> of
 the second stream will appear as element number <em>f</em>(<em>i</em>,<em>j</em>) of the output
 stream.  The trick of using <tt>interleave</tt> to accomplish this was
-shown to us by <a name="%_idx_3996" id="%_idx_3996"></a>David Turner, who employed it in the language <a name="%_idx_3998" id="%_idx_3998"></a>KRC
+shown to us by <a id="__idx_3996"></a>David Turner, who employed it in the language <a id="__idx_3998"></a>KRC
 (Turner 1981).
 
-</p><p><a name="footnote_Temp_485" href="#call_footnote_Temp_485" id="footnote_Temp_485"><sup><small>69</small></sup></a> We will require that the weighting function be such that
+</p><p><a href="#call_footnote_Temp_485" id="footnote_Temp_485"><sup><small>69</small></sup></a> We will require that the weighting function be such that
 the weight of a pair increases as we move out along a row or down
 along a column of the array of pairs.
 
-</p><p><a name="footnote_Temp_487" href="#call_footnote_Temp_487" id="footnote_Temp_487"><sup><small>70</small></sup></a> To quote from G. H. Hardy's obituary of
-<a name="%_idx_4012" id="%_idx_4012"></a><a name="%_idx_4014" id="%_idx_4014"></a><a name="%_idx_4016" id="%_idx_4016"></a>Ramanujan (Hardy 1921): “It was Mr. Littlewood (I believe) who remarked that
+</p><p><a href="#call_footnote_Temp_487" id="footnote_Temp_487"><sup><small>70</small></sup></a> To quote from G. H. Hardy's obituary of
+<a id="__idx_4012"></a><a id="__idx_4014"></a><a id="__idx_4016"></a>Ramanujan (Hardy 1921): “It was Mr. Littlewood (I believe) who remarked that
 `every positive integer was one of his friends.'  I remember once
 going to see him when he was lying ill at Putney.  I had ridden in
 taxi-cab No. 1729, and remarked that the number seemed to me a rather
@@ -1854,14 +1854,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 The trick of using weighted pairs to generate the Ramanujan numbers
 was shown to us by Charles Leiserson.
 
-</p><p><a name="footnote_Temp_494" href="#call_footnote_Temp_494" id="footnote_Temp_494"><sup><small>71</small></sup></a> This procedure is not guaranteed to work in all Scheme
+</p><p><a href="#call_footnote_Temp_494" id="footnote_Temp_494"><sup><small>71</small></sup></a> This procedure is not guaranteed to work in all Scheme
 implementations, although for any implementation there is a simple
 variation that will work.  The problem has to do with subtle
 differences in the ways that Scheme implementations handle internal
-definitions.  (See section <a href="book-Z-H-26.html#%_sec_4.1.6">4.1.6</a>.)
+definitions.  (See section <a href="book-Z-H-26.html#__sec_4.1.6">4.1.6</a>.)
 
-</p><p><a name="footnote_Temp_500" href="#call_footnote_Temp_500" id="footnote_Temp_500"><sup><small>72</small></sup></a> This is a small reflection, in Lisp, of the difficulties
-that conventional strongly typed languages such as <a name="%_idx_4096" id="%_idx_4096"></a><a name="%_idx_4098" id="%_idx_4098"></a><a name="%_idx_4100" id="%_idx_4100"></a><a name="%_idx_4102" id="%_idx_4102"></a><a name="%_idx_4104" id="%_idx_4104"></a>Pascal have in
+</p><p><a href="#call_footnote_Temp_500" id="footnote_Temp_500"><sup><small>72</small></sup></a> This is a small reflection, in Lisp, of the difficulties
+that conventional strongly typed languages such as <a id="__idx_4096"></a><a id="__idx_4098"></a><a id="__idx_4100"></a><a id="__idx_4102"></a><a id="__idx_4104"></a>Pascal have in
 coping with higher-order procedures.  In such languages, the
 programmer must specify the data types of the arguments and the result
 of each procedure: number, logical value, sequence, and so on.
@@ -1873,40 +1873,40 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_3.5">3.5  Streams</a></h2><p>
 for a <tt>proc</tt>.  Maintaining a practical notion of “data type” in
 the presence of higher-order procedures raises many difficult issues.
 One way of dealing with this problem is illustrated by the language ML
-<a name="%_idx_4106" id="%_idx_4106"></a><a name="%_idx_4108" id="%_idx_4108"></a><a name="%_idx_4110" id="%_idx_4110"></a><a name="%_idx_4112" id="%_idx_4112"></a>(Gordon, Milner, and Wadsworth 1979), whose “polymorphic data types”
+<a id="__idx_4106"></a><a id="__idx_4108"></a><a id="__idx_4110"></a><a id="__idx_4112"></a>(Gordon, Milner, and Wadsworth 1979), whose “polymorphic data types”
 include templates for higher-order transformations between data types.
 Moreover, data types for most procedures in ML are never explicitly
-declared by the programmer.  Instead, ML includes a <a name="%_idx_4114" id="%_idx_4114"></a><em>type-inferencing</em> mechanism that uses information in the environment
+declared by the programmer.  Instead, ML includes a <a id="__idx_4114"></a><em>type-inferencing</em> mechanism that uses information in the environment
 to deduce the data types for newly defined procedures.
 
-</p><p><a name="footnote_Temp_504" href="#call_footnote_Temp_504" id="footnote_Temp_504"><sup><small>73</small></sup></a> Similarly in physics, when we observe a moving particle, we
+</p><p><a href="#call_footnote_Temp_504" id="footnote_Temp_504"><sup><small>73</small></sup></a> Similarly in physics, when we observe a moving particle, we
 say that the position (state) of the particle is changing.  However,
-from the perspective of the particle's <a name="%_idx_4156" id="%_idx_4156"></a>world line in space-time there
+from the perspective of the particle's <a id="__idx_4156"></a>world line in space-time there
 is no change involved.
 
-</p><p><a name="footnote_Temp_505" href="#call_footnote_Temp_505" id="footnote_Temp_505"><sup><small>74</small></sup></a> John Backus, the inventor of Fortran, gave high
-<a name="%_idx_4166" id="%_idx_4166"></a><a name="%_idx_4168" id="%_idx_4168"></a><a name="%_idx_4170" id="%_idx_4170"></a><a name="%_idx_4172" id="%_idx_4172"></a><a name="%_idx_4174" id="%_idx_4174"></a>visibility to functional programming when he was awarded
+</p><p><a href="#call_footnote_Temp_505" id="footnote_Temp_505"><sup><small>74</small></sup></a> John Backus, the inventor of Fortran, gave high
+<a id="__idx_4166"></a><a id="__idx_4168"></a><a id="__idx_4170"></a><a id="__idx_4172"></a><a id="__idx_4174"></a>visibility to functional programming when he was awarded
 the ACM Turing award in 1978.  His acceptance speech (Backus 1978)
 strongly advocated the functional approach.  A good overview of
 functional programming is given in Henderson 1980 and in Darlington,
 Henderson, and Turner 1982.
 
-</p><p><a name="footnote_Temp_506" href="#call_footnote_Temp_506" id="footnote_Temp_506"><sup><small>75</small></sup></a> Observe that, for any two streams, there is in general more than one
-<a name="%_idx_4180" id="%_idx_4180"></a><a name="%_idx_4182" id="%_idx_4182"></a>acceptable order of interleaving.  Thus, technically, “merge” is a
+</p><p><a href="#call_footnote_Temp_506" id="footnote_Temp_506"><sup><small>75</small></sup></a> Observe that, for any two streams, there is in general more than one
+<a id="__idx_4180"></a><a id="__idx_4182"></a>acceptable order of interleaving.  Thus, technically, “merge” is a
 relation rather than a function – the answer is not a deterministic
 function of the inputs.  We already mentioned
 (footnote <a href="book-Z-H-23.html#footnote_Temp_411">39</a>) that nondeterminism is
 essential when dealing with concurrency.  The merge relation
 illustrates the same essential nondeterminism, from the functional
-perspective.  In section <a href="book-Z-H-28.html#%_sec_4.3">4.3</a>, we
+perspective.  In section <a href="book-Z-H-28.html#__sec_4.3">4.3</a>, we
 will look at nondeterminism from yet another point of view.
 
-</p><p><a name="footnote_Temp_507" href="#call_footnote_Temp_507" id="footnote_Temp_507"><sup><small>76</small></sup></a> The object model approximates the world by
+</p><p><a href="#call_footnote_Temp_507" id="footnote_Temp_507"><sup><small>76</small></sup></a> The object model approximates the world by
 dividing it into separate pieces.  The functional model does not
 modularize along object boundaries.  The object model is useful when
-<a name="%_idx_4184" id="%_idx_4184"></a>the unshared state of the “objects” is much larger than the state
+<a id="__idx_4184"></a>the unshared state of the “objects” is much larger than the state
 that they share.  An example of a place where the object viewpoint
-fails is <a name="%_idx_4186" id="%_idx_4186"></a>quantum
+fails is <a id="__idx_4186"></a>quantum
 mechanics, where thinking of things as individual particles leads to
 paradoxes and confusions.  Unifying the object view with the
 functional view may have little to do with programming, but rather
diff --git a/src/OEBPS/book-Z-H-25.html b/src/OEBPS/book-Z-H-25.html
index e7c77f0..0c13c61 100644
--- a/src/OEBPS/book-Z-H-25.html
+++ b/src/OEBPS/book-Z-H-25.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,14 +13,14 @@
 
 
 
-<a name="%_chap_4" id="%_chap_4"></a>
+<a id="__chap_4"></a>
 <h1 class="chapter">
-<div class="chapterheading"><a href="book-Z-H-4.html#%_toc_%_chap_4">Chapter 4</a></div></h1><p>
-<a href="book-Z-H-4.html#%_toc_%_chap_4">Metalinguistic Abstraction</a></p><p>
+<div class="chapterheading">Chapter 4</div></h1><p>
+Metalinguistic Abstraction</p><p>
 
 </p><p>
-</p><div align="right">
-<table width="60%"><tr><td>
+</p><div style="text-align: right;">
+<table width="60_"><tr><td>
 <span class="epigraph">
 <p>
 
@@ -33,7 +33,7 @@ <h1 class="chapter">
 the key!  And the treasure, too, if we can only get our hands on it!
 It's as if – as if the key to the treasure <em>is</em> the treasure!</p><p>
 
-<a name="%_idx_4188" id="%_idx_4188"></a>John Barth, <em>Chimera</em></p><p>
+<a id="__idx_4188"></a>John Barth, <em>Chimera</em></p><p>
 
 </p></span>
 </td></tr></table></div>
@@ -58,9 +58,9 @@ <h1 class="chapter">
 complex problem by adopting a new language that enables us to describe
 (and hence to think about) the problem in a different way, using
 primitives, means of combination, and means of abstraction that are
-particularly well suited to the problem at hand.<a name="call_footnote_Temp_508" href="#footnote_Temp_508" id="call_footnote_Temp_508"><sup><small>1</small></sup></a></p><p>
+particularly well suited to the problem at hand.<a href="#footnote_Temp_508" id="call_footnote_Temp_508"><sup><small>1</small></sup></a></p><p>
 
-<a name="%_idx_4190" id="%_idx_4190"></a><a name="%_idx_4192" id="%_idx_4192"></a>Programming is endowed with a multitude of languages.  There are
+<a id="__idx_4190"></a><a id="__idx_4192"></a>Programming is endowed with a multitude of languages.  There are
 physical languages, such as the machine languages for particular
 computers.  These languages are concerned with the representation of
 data and control in terms of individual bits of storage and primitive
@@ -74,11 +74,11 @@ <h1 class="chapter">
 procedure definition, that are appropriate to the larger-scale
 organization of systems.</p><p>
 
-<a name="%_idx_4194" id="%_idx_4194"></a><a name="%_idx_4196" id="%_idx_4196"></a><em>Metalinguistic abstraction</em> – establishing new
+<a id="__idx_4194"></a><a id="__idx_4196"></a><em>Metalinguistic abstraction</em> – establishing new
 languages – plays an important role in all branches of engineering
 design.  It is particularly important to computer programming, because
 in programming not only can we formulate new languages but we can also
-implement these languages by constructing evaluators.  An <a name="%_idx_4198" id="%_idx_4198"></a><em>evaluator</em> (or <em>interpreter</em>) for a programming language is a procedure
+implement these languages by constructing evaluators.  An <a id="__idx_4198"></a><em>evaluator</em> (or <em>interpreter</em>) for a programming language is a procedure
 that, when applied to an expression of the language, performs the
 actions required to evaluate that expression.</p><p>
 
@@ -95,24 +95,24 @@ <h1 class="chapter">
 
 In fact, we can regard almost any program as the evaluator for some
 language.  For instance, the polynomial manipulation system of
-section <a href="book-Z-H-18.html#%_sec_2.5.3">2.5.3</a> embodies the rules of polynomial
+section <a href="book-Z-H-18.html#__sec_2.5.3">2.5.3</a> embodies the rules of polynomial
 arithmetic and implements them in terms of operations on
 list-structured data.  If we augment this system with procedures to
 read and print polynomial expressions, we have the core of a
 special-purpose language for dealing with problems in symbolic
 mathematics.  The digital-logic simulator of
-section <a href="book-Z-H-22.html#%_sec_3.3.4">3.3.4</a> and the constraint propagator of
-section <a href="book-Z-H-22.html#%_sec_3.3.5">3.3.5</a> are legitimate languages in their own
+section <a href="book-Z-H-22.html#__sec_3.3.4">3.3.4</a> and the constraint propagator of
+section <a href="book-Z-H-22.html#__sec_3.3.5">3.3.5</a> are legitimate languages in their own
 right, each with its own primitives, means of combination, and means
 of abstraction.  Seen from this perspective, the technology for coping
 with large-scale computer systems merges with the technology for
-building new computer languages, and <a name="%_idx_4200" id="%_idx_4200"></a>computer science itself becomes
+building new computer languages, and <a id="__idx_4200"></a>computer science itself becomes
 no more (and no less) than the discipline of constructing appropriate
 descriptive languages.</p><p>
 
 We now embark on a tour of the technology by which languages are
 established in terms of other languages.  In this chapter we shall use
-Lisp as a base, implementing evaluators as Lisp procedures.  <a name="%_idx_4202" id="%_idx_4202"></a>Lisp is
+Lisp as a base, implementing evaluators as Lisp procedures.  <a id="__idx_4202"></a>Lisp is
 particularly well suited to this task, because of its ability to
 represent and manipulate symbolic expressions.  We will take the first
 step in understanding how languages are implemented by building an
@@ -127,7 +127,7 @@ <h1 class="chapter">
 discussion, and some features have been left out that would be
 important to include in a production-quality Lisp system.
 Nevertheless, this simple evaluator is adequate to execute most of the
-programs in this book.<a name="call_footnote_Temp_509" href="#footnote_Temp_509" id="call_footnote_Temp_509"><sup><small>2</small></sup></a></p><p>
+programs in this book.<a href="#footnote_Temp_509" id="call_footnote_Temp_509"><sup><small>2</small></sup></a></p><p>
 
 
 An important advantage of making the evaluator accessible as a Lisp
@@ -141,11 +141,11 @@ <h1 class="chapter">
 in the computer.  Our stream programs, however, were
 sometimes cumbersome, because they were constrained by
 the applicative-order evaluation of Scheme.
-In section <a href="book-Z-H-27.html#%_sec_4.2">4.2</a>, we'll change
+In section <a href="book-Z-H-27.html#__sec_4.2">4.2</a>, we'll change
 the underlying language to provide for a more elegant approach, by modifying
 the evaluator to provide for <em>normal-order evaluation</em>.</p><p>
 
-Section <a href="book-Z-H-28.html#%_sec_4.3">4.3</a> implements a more
+Section <a href="book-Z-H-28.html#__sec_4.3">4.3</a> implements a more
 ambitious linguistic change, whereby expressions have many values,
 rather than just a single value.  In this language of <em>nondeterministic computing</em>, it is natural to express processes that
 generate all possible values for expressions and then search for those
@@ -156,7 +156,7 @@ <h1 class="chapter">
 and performing searches are handled automatically by the underlying
 mechanism of the language.</p><p>
 
-In section <a href="book-Z-H-29.html#%_sec_4.4">4.4</a> we implement a <em>logic-programming</em> language in which knowledge is expressed in terms
+In section <a href="book-Z-H-29.html#__sec_4.4">4.4</a> we implement a <em>logic-programming</em> language in which knowledge is expressed in terms
 of relations, rather than in terms of computations with inputs and
 outputs.  Even though this makes the language drastically different
 from Lisp, or indeed from any conventional language, we will see that
@@ -164,7 +164,7 @@ <h1 class="chapter">
 Lisp evaluator.</p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_508" href="#call_footnote_Temp_508" id="footnote_Temp_508"><sup><small>1</small></sup></a> The same idea
+</p><div class="footnote"><p><a href="#call_footnote_Temp_508" id="footnote_Temp_508"><sup><small>1</small></sup></a> The same idea
 is pervasive throughout all of engineering.  For example, electrical
 engineers use many different languages for describing circuits.  Two
 of these are the language of electrical <em>networks</em> and the
@@ -186,11 +186,11 @@ <h1 class="chapter">
 given application problem; the physical feasibility of the parts is
 assumed.  This layered collection of languages is another example of
 the stratified design technique illustrated by the picture
-language of section <a href="book-Z-H-15.html#%_sec_2.2.4">2.2.4</a>.
+language of section <a href="book-Z-H-15.html#__sec_2.2.4">2.2.4</a>.
 
-</p><p><a name="footnote_Temp_509" href="#call_footnote_Temp_509" id="footnote_Temp_509"><sup><small>2</small></sup></a> The most important features that our evaluator leaves out
+</p><p><a href="#call_footnote_Temp_509" id="footnote_Temp_509"><sup><small>2</small></sup></a> The most important features that our evaluator leaves out
 are mechanisms for handling errors and supporting debugging.  For a
-more extensive discussion of evaluators, see <a name="%_idx_4204" id="%_idx_4204"></a><a name="%_idx_4206" id="%_idx_4206"></a><a name="%_idx_4208" id="%_idx_4208"></a>Friedman, Wand, and Haynes
+more extensive discussion of evaluators, see <a id="__idx_4204"></a><a id="__idx_4206"></a><a id="__idx_4208"></a>Friedman, Wand, and Haynes
 1992, which gives an exposition of programming languages that proceeds
 via a sequence of evaluators written in Scheme.
 
diff --git a/src/OEBPS/book-Z-H-26.html b/src/OEBPS/book-Z-H-26.html
index 58b113c..9e2eb73 100644
--- a/src/OEBPS/book-Z-H-26.html
+++ b/src/OEBPS/book-Z-H-26.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,23 +13,23 @@
 
 
 
-<a name="%_sec_4.1" id="%_sec_4.1"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator</a></h2><p>
+<a id="__sec_4.1"></a>
+<h2>4.1  The Metacircular Evaluator</h2><p>
 
 
-<a name="%_idx_4210" id="%_idx_4210"></a>
+<a id="__idx_4210"></a>
 Our evaluator for Lisp will be implemented as a Lisp program.  It may
 seem circular to think about evaluating Lisp programs using an
 evaluator that is itself implemented in Lisp.  However, evaluation is
 a process, so it is appropriate to describe the evaluation process
 using Lisp, which, after all, is our tool for describing
-processes.<a name="call_footnote_Temp_510" href="#footnote_Temp_510" id="call_footnote_Temp_510"><sup><small>3</small></sup></a>  An evaluator that is written in the same language
-<a name="%_idx_4212" id="%_idx_4212"></a><a name="%_idx_4214" id="%_idx_4214"></a>that it evaluates is said to be <em>metacircular</em>.</p><p>
+processes.<a href="#footnote_Temp_510" id="call_footnote_Temp_510"><sup><small>3</small></sup></a>  An evaluator that is written in the same language
+<a id="__idx_4212"></a><a id="__idx_4214"></a>that it evaluates is said to be <em>metacircular</em>.</p><p>
 
 
-<a name="%_idx_4216" id="%_idx_4216"></a><a name="%_idx_4218" id="%_idx_4218"></a>The metacircular evaluator is essentially a Scheme formulation of the
+<a id="__idx_4216"></a><a id="__idx_4218"></a>The metacircular evaluator is essentially a Scheme formulation of the
 environment model of evaluation described in
-section <a href="book-Z-H-21.html#%_sec_3.2">3.2</a>.  Recall that the model has two
+section <a href="book-Z-H-21.html#__sec_3.2">3.2</a>.  Recall that the model has two
 basic parts:</p><p>
 
 </p><blockquote>
@@ -45,72 +45,72 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 arguments to which the procedure is applied.
 </p></blockquote><p>
 
-<a name="%_idx_4220" id="%_idx_4220"></a>These two rules describe the essence of the evaluation process, a
+<a id="__idx_4220"></a>These two rules describe the essence of the evaluation process, a
 basic cycle in which expressions to be evaluated in environments are
 reduced to procedures to be applied to arguments, which in turn are
 reduced to new expressions to be evaluated in new environments, and so
 on, until we get down to symbols, whose values are looked
 up in the environment, and to primitive procedures, which are applied
-directly (see figure <a href="#%_fig_4.1">4.1</a>).<a name="call_footnote_Temp_511" href="#footnote_Temp_511" id="call_footnote_Temp_511"><sup><small>4</small></sup></a>
+directly (see figure <a href="#__fig_4.1">4.1</a>).<a href="#footnote_Temp_511" id="call_footnote_Temp_511"><sup><small>4</small></sup></a>
 This evaluation cycle will be embodied by the interplay between the two
 critical procedures in the evaluator, <tt>eval</tt> and <tt>apply</tt>,
-which are described in section <a href="#%_sec_4.1.1">4.1.1</a>
-(see figure <a href="#%_fig_4.1">4.1</a>).</p><p>
+which are described in section <a href="#__sec_4.1.1">4.1.1</a>
+(see figure <a href="#__fig_4.1">4.1</a>).</p><p>
 
 The implementation of the evaluator will depend upon procedures that
 define the <em>syntax</em> of the expressions to be evaluated.  We will
-use <a name="%_idx_4224" id="%_idx_4224"></a>data abstraction to make the evaluator independent of the
+use <a id="__idx_4224"></a>data abstraction to make the evaluator independent of the
 representation of the language.  For example, rather than committing
 to a choice that an assignment is to be represented by a list
 beginning with the symbol <tt>set!</tt> we use an abstract predicate
 <tt>assignment?</tt> to test for an assignment, and we use abstract
 selectors <tt>assignment-variable</tt> and <tt>assignment-value</tt> to
 access the parts of an assignment.  Implementation of expressions will
-be described in detail in section <a href="#%_sec_4.1.2">4.1.2</a>.
+be described in detail in section <a href="#__sec_4.1.2">4.1.2</a>.
 There are also operations, described in
-section <a href="#%_sec_4.1.3">4.1.3</a>, that specify the
+section <a href="#__sec_4.1.3">4.1.3</a>, that specify the
 representation of procedures and environments.  For example, <tt>make-procedure</tt> constructs compound procedures, <tt>lookup-variable-value</tt> accesses the values of variables, and <tt>apply-primitive-procedure</tt> applies a primitive procedure to a given list
 of arguments.</p><p>
 
-<a name="%_sec_4.1.1" id="%_sec_4.1.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_4.1.1">4.1.1  The Core of the Evaluator</a></h3><p>
+<a id="__sec_4.1.1"></a>
+</p><h3>4.1.1  The Core of the Evaluator</h3><p>
 
 
-<a name="%_idx_4226" id="%_idx_4226"></a>
-<a name="%_fig_4.1" id="%_fig_4.1"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch4-Z-G-1.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 4.1:</b>  The <tt>eval</tt>-<tt>apply</tt> cycle exposes the essence
+<a id="__idx_4226"></a>
+<a id="__fig_4.1"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch4-Z-G-1.gif" alt="ch4-Z-G-1" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 4.1:</b>  The <tt>eval</tt>-<tt>apply</tt> cycle exposes the essence
 of a computer language.</div></caption><tr><td>
-<a name="%_idx_4228" id="%_idx_4228"></a>
+<a id="__idx_4228"></a>
 </td></tr></table></div><p></p><p>
 
 The evaluation process can be described as the interplay between two
 procedures: <tt>eval</tt> and <tt>apply</tt>.</p><p>
 
-<a name="%_sec_Temp_512" id="%_sec_Temp_512"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_512">Eval</a></h4><p>
+<a id="__sec_Temp_512"></a>
+</p><h4>Eval</h4><p>
 
-<a name="%_idx_4230" id="%_idx_4230"></a><tt>Eval</tt> takes as arguments an expression and an environment.  It
+<a id="__idx_4230"></a><tt>Eval</tt> takes as arguments an expression and an environment.  It
 classifies the expression and directs its evaluation.  <tt>Eval</tt> is
 structured as a case analysis of the syntactic type of the expression
 to be evaluated.  In order to keep the procedure general, we express
 the determination of the type of an expression abstractly, making no
-commitment to any particular <a name="%_idx_4232" id="%_idx_4232"></a>representation for the various types of
+commitment to any particular <a id="__idx_4232"></a>representation for the various types of
 expressions.  Each type of expression has a predicate that tests for
-it and an abstract means for selecting its parts.  This <a name="%_idx_4234" id="%_idx_4234"></a><a name="%_idx_4236" id="%_idx_4236"></a><em>abstract
+it and an abstract means for selecting its parts.  This <a id="__idx_4234"></a><a id="__idx_4236"></a><em>abstract
 syntax</em> makes it easy to see how we can change the syntax of the
 language by using the same evaluator, but with a different collection of
 syntax procedures.</p><p>
 
-<a name="%_sec_Temp_513" id="%_sec_Temp_513"></a>
-</p><h5><a href="book-Z-H-4.html#%_toc_%_sec_Temp_513">Primitive expressions</a></h5><p>
+<a id="__sec_Temp_513"></a>
+</p><h5>Primitive expressions</h5><p>
 
-</p><p></p><ul><li><a name="%_idx_4238" id="%_idx_4238"></a><a name="%_idx_4240" id="%_idx_4240"></a>For self-evaluating expressions, such as numbers, <tt>eval</tt> returns
+</p><p></p><ul><li><a id="__idx_4238"></a><a id="__idx_4240"></a>For self-evaluating expressions, such as numbers, <tt>eval</tt> returns
 the expression itself.<p>
 
 </p></li><li><tt>Eval</tt> must look up variables in the environment to find their values.
 </li></ul><p></p><p>
 
-<a name="%_sec_Temp_514" id="%_sec_Temp_514"></a>
-</p><h5><a href="book-Z-H-4.html#%_toc_%_sec_Temp_514">Special forms</a></h5><p>
+<a id="__sec_Temp_514"></a>
+</p><h5>Special forms</h5><p>
 
 </p><p></p><ul><p>
 
@@ -139,8 +139,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 </li></ul><p></p><p>
 
 
-<a name="%_sec_Temp_515" id="%_sec_Temp_515"></a>
-</p><h5><a href="book-Z-H-4.html#%_toc_%_sec_Temp_515">Combinations</a></h5><p>
+<a id="__sec_Temp_515"></a>
+</p><h5>Combinations</h5><p>
 
 </p><p></p><ul><li>For a procedure application, <tt>eval</tt> must recursively
 evaluate the operator part and the operands of the combination.  The
@@ -148,7 +148,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 handles the actual procedure application.
 </li></ul><p></p><p>
 
-</p><p></p><p><a name="%_idx_4242" id="%_idx_4242"></a>Here is the definition of <tt>eval</tt>:</p><p>
+</p><p></p><p><a id="__idx_4242"></a>Here is the definition of <tt>eval</tt>:</p><p>
 
 
 </p><p></p><p><tt>(define (eval exp env)<br />
@@ -172,7 +172,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
          (error "Unknown expression type -- EVAL" exp))))<br /></tt></p><p></p><p>
 </p><p>
 
-<a name="%_idx_4244" id="%_idx_4244"></a><a name="%_idx_4246" id="%_idx_4246"></a>For clarity, <tt>eval</tt> has been implemented as a case analysis using
+<a id="__idx_4244"></a><a id="__idx_4246"></a>For clarity, <tt>eval</tt> has been implemented as a case analysis using
 <tt>cond</tt>.  The disadvantage of this is that our procedure handles
 only a few distinguishable types of expressions, and no new ones can
 be defined without editing the definition of <tt>eval</tt>.  In most Lisp
@@ -180,14 +180,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 data-directed style.  This allows a user to add new types of
 expressions that <tt>eval</tt> can distinguish, without modifying the
 definition of <tt>eval</tt> itself.
-(See exercise <a href="#%_thm_4.3">4.3</a>.)</p><p>
+(See exercise <a href="#__thm_4.3">4.3</a>.)</p><p>
 
-<a name="%_sec_Temp_516" id="%_sec_Temp_516"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_516">Apply</a></h4><p>
+<a id="__sec_Temp_516"></a>
+</p><h4>Apply</h4><p>
 
 <tt>Apply</tt> takes two arguments, a procedure and a list of arguments
 to which the procedure should be applied.  <tt>Apply</tt> classifies
-procedures into two kinds: It calls <a name="%_idx_4248" id="%_idx_4248"></a><tt>apply-primitive-procedure</tt> to apply primitives; it applies compound
+procedures into two kinds: It calls <a id="__idx_4248"></a><tt>apply-primitive-procedure</tt> to apply primitives; it applies compound
 procedures by sequentially evaluating the expressions that
 make up the body of the procedure.  The environment for the
 evaluation of the body of a compound procedure
@@ -196,7 +196,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 procedure to the arguments to which the procedure is to be applied.
 Here is the definition of <tt>apply</tt>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4250" id="%_idx_4250"></a>(define (apply procedure arguments)<br />
+</p><p></p><p><tt><a id="__idx_4250"></a>(define (apply procedure arguments)<br />
   (cond ((primitive-procedure? procedure)<br />
          (apply-primitive-procedure procedure arguments))<br />
         ((compound-procedure? procedure)<br />
@@ -211,45 +211,45 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
           "Unknown procedure type -- APPLY" procedure))))<br /></tt></p><p></p><p></p><p>
 
 
-<a name="%_sec_Temp_517" id="%_sec_Temp_517"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_517">Procedure arguments</a></h4><p>
+<a id="__sec_Temp_517"></a>
+</p><h4>Procedure arguments</h4><p>
 
 When <tt>eval</tt> processes a
 procedure application, it uses <tt>list-of-values</tt> to produce the
 list of arguments to which the procedure is to be applied. <tt>List-of-values</tt> takes as an argument the operands of the combination.
 It evaluates each operand and returns a list of the corresponding
-values:<a name="call_footnote_Temp_518" href="#footnote_Temp_518" id="call_footnote_Temp_518"><sup><small>5</small></sup></a></p><p>
+values:<a href="#footnote_Temp_518" id="call_footnote_Temp_518"><sup><small>5</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_4256" id="%_idx_4256"></a>(define (list-of-values exps env)<br />
+</p><p></p><p><tt><a id="__idx_4256"></a>(define (list-of-values exps env)<br />
   (if (no-operands? exps)<br />
       '()<br />
       (cons (eval (first-operand exps) env)<br />
             (list-of-values (rest-operands exps) env))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_519" id="%_sec_Temp_519"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_519">Conditionals</a></h4><p>
+<a id="__sec_Temp_519"></a>
+</p><h4>Conditionals</h4><p>
 
 <tt>Eval-if</tt> evaluates the predicate part of an <tt>if</tt> expression
 in the given environment.  If
 the result is true, <tt>eval-if</tt> evaluates the consequent, otherwise
 it evaluates the alternative:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4258" id="%_idx_4258"></a>(define (eval-if exp env)<br />
+</p><p></p><p><tt><a id="__idx_4258"></a>(define (eval-if exp env)<br />
   (if (true? (eval (if-predicate exp) env))<br />
       (eval (if-consequent exp) env)<br />
       (eval (if-alternative exp) env)))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_4260" id="%_idx_4260"></a>The use of <tt>true?</tt> in <tt>eval-if</tt> highlights the issue of the
+<a id="__idx_4260"></a>The use of <tt>true?</tt> in <tt>eval-if</tt> highlights the issue of the
 connection between an implemented language and an implementation
 language.  The <tt>if-predicate</tt> is evaluated in the language being
 implemented and thus yields a value in that language.  The interpreter
 predicate <tt>true?</tt> translates that value into a value that can be
 tested by the <tt>if</tt> in the implementation language: The
 metacircular representation of truth might not be the same as that of
-the underlying Scheme.<a name="call_footnote_Temp_520" href="#footnote_Temp_520" id="call_footnote_Temp_520"><sup><small>6</small></sup></a></p><p>
+the underlying Scheme.<a href="#footnote_Temp_520" id="call_footnote_Temp_520"><sup><small>6</small></sup></a></p><p>
 
-<a name="%_sec_Temp_521" id="%_sec_Temp_521"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_521">Sequences</a></h4><p>
+<a id="__sec_Temp_521"></a>
+</p><h4>Sequences</h4><p>
 
 <tt>Eval-sequence</tt> is used by <tt>apply</tt> to evaluate the sequence of
 expressions in a procedure body and by <tt>eval</tt> to evaluate the
@@ -258,37 +258,37 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 environment, and evaluates the expressions in the order in which they
 occur.  The value returned is the value of the final expression.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4264" id="%_idx_4264"></a>(define (eval-sequence exps env)<br />
+</p><p></p><p><tt><a id="__idx_4264"></a>(define (eval-sequence exps env)<br />
   (cond ((last-exp? exps) (eval (first-exp exps) env))<br />
         (else (eval (first-exp exps) env)<br />
               (eval-sequence (rest-exps exps) env))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_522" id="%_sec_Temp_522"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_522">Assignments and definitions</a></h4><p>
+<a id="__sec_Temp_522"></a>
+</p><h4>Assignments and definitions</h4><p>
 
 The following procedure handles assignments to variables.  It calls
 <tt>eval</tt> to find the value to be assigned and transmits the variable
 and the resulting value to <tt>set-variable-value!</tt> to be installed
 in the designated environment.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4266" id="%_idx_4266"></a>(define (eval-assignment exp env)<br />
+</p><p></p><p><tt><a id="__idx_4266"></a>(define (eval-assignment exp env)<br />
   (set-variable-value! (assignment-variable exp)<br />
                        (eval (assignment-value exp) env)<br />
                        env)<br />
   'ok)<br /></tt></p><p></p><p>
 Definitions of variables are handled in a similar
-manner.<a name="call_footnote_Temp_523" href="#footnote_Temp_523" id="call_footnote_Temp_523"><sup><small>7</small></sup></a></p><p>
+manner.<a href="#footnote_Temp_523" id="call_footnote_Temp_523"><sup><small>7</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_4268" id="%_idx_4268"></a>(define (eval-definition exp env)<br />
+</p><p></p><p><tt><a id="__idx_4268"></a>(define (eval-definition exp env)<br />
   (define-variable! (definition-variable exp)<br />
                     (eval (definition-value exp) env)<br />
                     env)<br />
   'ok)<br /></tt></p><p></p><p>
 We have chosen here to return the symbol <tt>ok</tt> as the value
-of an assignment or a definition.<a name="call_footnote_Temp_524" href="#footnote_Temp_524" id="call_footnote_Temp_524"><sup><small>8</small></sup></a></p><p>
+of an assignment or a definition.<a href="#footnote_Temp_524" id="call_footnote_Temp_524"><sup><small>8</small></sup></a></p><p>
 
-</p><p><a name="%_thm_4.1" id="%_thm_4.1"></a>
-<b>Exercise 4.1.</b>  <a name="%_idx_4270" id="%_idx_4270"></a><a name="%_idx_4272" id="%_idx_4272"></a>Notice that we cannot tell whether the metacircular evaluator
+</p><p><a id="__thm_4.1"></a>
+<b>Exercise 4.1.</b>  <a id="__idx_4270"></a><a id="__idx_4272"></a>Notice that we cannot tell whether the metacircular evaluator
 evaluates operands from left to right or from right to left.  Its evaluation
 order is inherited from the underlying Lisp:
 If the arguments to <tt>cons</tt> in <tt>list-of-values</tt>
@@ -305,18 +305,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 
 </p><p></p><p>
 
-<a name="%_sec_4.1.2" id="%_sec_4.1.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_4.1.2">4.1.2  Representing Expressions</a></h3><p>
+<a id="__sec_4.1.2"></a>
+</p><h3>4.1.2  Representing Expressions</h3><p>
 
 
-<a name="%_idx_4274" id="%_idx_4274"></a><a name="%_idx_4276" id="%_idx_4276"></a>
-<a name="%_idx_4278" id="%_idx_4278"></a>The evaluator is reminiscent of the symbolic differentiation program
-discussed in section <a href="book-Z-H-16.html#%_sec_2.3.2">2.3.2</a>.  Both
+<a id="__idx_4274"></a><a id="__idx_4276"></a>
+<a id="__idx_4278"></a>The evaluator is reminiscent of the symbolic differentiation program
+discussed in section <a href="book-Z-H-16.html#__sec_2.3.2">2.3.2</a>.  Both
 programs operate on symbolic expressions.  In both programs, the
 result of operating on a compound expression is determined by
 operating recursively on the pieces of the expression and combining
 the results in a way that depends on the type of the expression.  In
-both programs we used <a name="%_idx_4280" id="%_idx_4280"></a>data abstraction to decouple the general rules
+both programs we used <a id="__idx_4280"></a>data abstraction to decouple the general rules
 of operation from the details of how expressions are represented.  In
 the differentiation program this meant that the same differentiation
 procedure could deal with algebraic expressions in prefix form, in
@@ -330,30 +330,30 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 ¤ The only self-evaluating items are numbers and
 strings:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4282" id="%_idx_4282"></a>(define (self-evaluating? exp)<br />
+</p><p></p><p><tt><a id="__idx_4282"></a>(define (self-evaluating? exp)<br />
   (cond ((number? exp) true)<br />
         ((string? exp) true)<br />
         (else false)))<br /></tt></p><p></p><p>
 ¤ Variables are represented by symbols:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4284" id="%_idx_4284"></a>(define (variable? exp) (symbol? exp))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_4284"></a>(define (variable? exp) (symbol? exp))<br /></tt></p><p></p><p>
 ¤ Quotations have the form <tt>(quote
-&lt;<em>text-of-quotation</em>&gt;)</tt>:<a name="call_footnote_Temp_526" href="#footnote_Temp_526" id="call_footnote_Temp_526"><sup><small>9</small></sup></a></p><p>
+&lt;<em>text-of-quotation</em>&gt;)</tt>:<a href="#footnote_Temp_526" id="call_footnote_Temp_526"><sup><small>9</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_4286" id="%_idx_4286"></a>(define (quoted? exp)<br />
-  (tagged-list? exp 'quote))<br /><br /><a name="%_idx_4288" id="%_idx_4288"></a>(define (text-of-quotation exp) (cadr exp))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_4286"></a>(define (quoted? exp)<br />
+  (tagged-list? exp 'quote))<br /><br /><a id="__idx_4288"></a>(define (text-of-quotation exp) (cadr exp))<br /></tt></p><p></p><p>
 <tt>Quoted?</tt> is defined in terms of the procedure <tt>tagged-list?</tt>, which identifies lists beginning with a designated
 symbol:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4290" id="%_idx_4290"></a>(define (tagged-list? exp tag)<br />
+</p><p></p><p><tt><a id="__idx_4290"></a>(define (tagged-list? exp tag)<br />
   (if (pair? exp)<br />
       (eq? (car exp) tag)<br />
       false))<br /></tt></p><p></p><p>
 ¤ Assignments have the form <tt>(set!
 &lt;<em>var</em>&gt; &lt;<em>value</em>&gt;)</tt>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4292" id="%_idx_4292"></a>(define (assignment? exp)<br />
-  (tagged-list? exp 'set!))<br /><a name="%_idx_4294" id="%_idx_4294"></a>(define (assignment-variable exp) (cadr exp))<br /><a name="%_idx_4296" id="%_idx_4296"></a>(define (assignment-value exp) (caddr exp))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_4292"></a>(define (assignment? exp)<br />
+  (tagged-list? exp 'set!))<br /><a id="__idx_4294"></a>(define (assignment-variable exp) (cadr exp))<br /><a id="__idx_4296"></a>(define (assignment-value exp) (caddr exp))<br /></tt></p><p></p><p>
 ¤ Definitions have the form</p><p>
 
 </p><p></p><p><tt>(define &lt;<em>var</em>&gt; &lt;<em>value</em>&gt;)<br /></tt></p><p></p><p>
@@ -361,18 +361,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 
 </p><p></p><p><tt>(define (&lt;<em>var</em>&gt; &lt;<em>parameter<sub>1</sub></em>&gt; <tt>...</tt> &lt;<em>parameter<sub><em>n</em></sub></em>&gt;)<br />
   &lt;<em>body</em>&gt;)<br /></tt></p><p></p><p>
-<a name="%_idx_4298" id="%_idx_4298"></a><a name="%_idx_4300" id="%_idx_4300"></a>The latter form (standard procedure definition) is syntactic sugar for</p><p>
+<a id="__idx_4298"></a><a id="__idx_4300"></a>The latter form (standard procedure definition) is syntactic sugar for</p><p>
 
 </p><p></p><p><tt>(define &lt;<em>var</em>&gt;<br />
   (lambda (&lt;<em>parameter<sub>1</sub></em>&gt; <tt>...</tt> &lt;<em>parameter<sub><em>n</em></sub></em>&gt;)<br />
     &lt;<em>body</em>&gt;))<br /></tt></p><p></p><p>
 The corresponding syntax procedures are the following:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4302" id="%_idx_4302"></a>(define (definition? exp)<br />
-  (tagged-list? exp 'define))<br /><a name="%_idx_4304" id="%_idx_4304"></a>(define (definition-variable exp)<br />
+</p><p></p><p><tt><a id="__idx_4302"></a>(define (definition? exp)<br />
+  (tagged-list? exp 'define))<br /><a id="__idx_4304"></a>(define (definition-variable exp)<br />
   (if (symbol? (cadr exp))<br />
       (cadr exp)<br />
-      (caadr exp)))<br /><a name="%_idx_4306" id="%_idx_4306"></a>(define (definition-value exp)<br />
+      (caadr exp)))<br /><a id="__idx_4306"></a>(define (definition-value exp)<br />
   (if (symbol? (cadr exp))<br />
       (caddr exp)<br />
       (make-lambda (cdadr exp)   <em>; formal parameters</em><br />
@@ -380,50 +380,50 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 ¤ <tt>Lambda</tt> expressions are lists that begin with the
 symbol <tt>lambda</tt>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4308" id="%_idx_4308"></a>(define (lambda? exp) (tagged-list? exp 'lambda))<br /><a name="%_idx_4310" id="%_idx_4310"></a>(define (lambda-parameters exp) (cadr exp))<br /><a name="%_idx_4312" id="%_idx_4312"></a>(define (lambda-body exp) (cddr exp))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_4308"></a>(define (lambda? exp) (tagged-list? exp 'lambda))<br /><a id="__idx_4310"></a>(define (lambda-parameters exp) (cadr exp))<br /><a id="__idx_4312"></a>(define (lambda-body exp) (cddr exp))<br /></tt></p><p></p><p>
 We also provide a constructor for <tt>lambda</tt> expressions,
 which is used by <tt>definition-value</tt>, above:
-</p><p></p><p><tt><a name="%_idx_4314" id="%_idx_4314"></a>(define (make-lambda parameters body)<br />
+</p><p></p><p><tt><a id="__idx_4314"></a>(define (make-lambda parameters body)<br />
   (cons 'lambda (cons parameters body)))<br /></tt></p><p></p><p>
 ¤ Conditionals begin with <tt>if</tt> and have a predicate, a
 consequent, and an (optional) alternative.  If the expression has no
-alternative part, we provide <tt>false</tt> as the alternative.<a name="call_footnote_Temp_527" href="#footnote_Temp_527" id="call_footnote_Temp_527"><sup><small>10</small></sup></a></p><p>
+alternative part, we provide <tt>false</tt> as the alternative.<a href="#footnote_Temp_527" id="call_footnote_Temp_527"><sup><small>10</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_4316" id="%_idx_4316"></a>(define (if? exp) (tagged-list? exp 'if))<br /><a name="%_idx_4318" id="%_idx_4318"></a>(define (if-predicate exp) (cadr exp))<br /><a name="%_idx_4320" id="%_idx_4320"></a>(define (if-consequent exp) (caddr exp))<br /><a name="%_idx_4322" id="%_idx_4322"></a>(define (if-alternative exp)<br />
+</p><p></p><p><tt><a id="__idx_4316"></a>(define (if? exp) (tagged-list? exp 'if))<br /><a id="__idx_4318"></a>(define (if-predicate exp) (cadr exp))<br /><a id="__idx_4320"></a>(define (if-consequent exp) (caddr exp))<br /><a id="__idx_4322"></a>(define (if-alternative exp)<br />
   (if (not (null? (cdddr exp)))<br />
       (cadddr exp)<br />
       'false))<br /></tt></p><p></p><p>
 We also provide a constructor for <tt>if</tt> expressions,
 to be used by <tt>cond-&gt;if</tt> to transform <tt>cond</tt> expressions
 into <tt>if</tt> expressions:
-</p><p></p><p><tt><a name="%_idx_4324" id="%_idx_4324"></a>(define (make-if predicate consequent alternative)<br />
+</p><p></p><p><tt><a id="__idx_4324"></a>(define (make-if predicate consequent alternative)<br />
   (list 'if predicate consequent alternative))<br /></tt></p><p></p><p>
 ¤ <tt>Begin</tt> packages a sequence of expressions into a single
 expression.  We include syntax operations on <tt>begin</tt> expressions
 to extract the actual sequence from the <tt>begin</tt> expression, as
 well as selectors that return the first expression and the rest of the
-expressions in the sequence.<a name="call_footnote_Temp_528" href="#footnote_Temp_528" id="call_footnote_Temp_528"><sup><small>11</small></sup></a></p><p>
+expressions in the sequence.<a href="#footnote_Temp_528" id="call_footnote_Temp_528"><sup><small>11</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_4326" id="%_idx_4326"></a>(define (begin? exp) (tagged-list? exp 'begin))<br /><a name="%_idx_4328" id="%_idx_4328"></a>(define (begin-actions exp) (cdr exp))<br /><a name="%_idx_4330" id="%_idx_4330"></a>(define (last-exp? seq) (null? (cdr seq)))<br /><a name="%_idx_4332" id="%_idx_4332"></a>(define (first-exp seq) (car seq))<br /><a name="%_idx_4334" id="%_idx_4334"></a>(define (rest-exps seq) (cdr seq))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_4326"></a>(define (begin? exp) (tagged-list? exp 'begin))<br /><a id="__idx_4328"></a>(define (begin-actions exp) (cdr exp))<br /><a id="__idx_4330"></a>(define (last-exp? seq) (null? (cdr seq)))<br /><a id="__idx_4332"></a>(define (first-exp seq) (car seq))<br /><a id="__idx_4334"></a>(define (rest-exps seq) (cdr seq))<br /></tt></p><p></p><p>
 We also include a constructor <tt>sequence-&gt;exp</tt> (for use by
 <tt>cond-&gt;if</tt>) that transforms a sequence into a single expression,
 using <tt>begin</tt> if necessary:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4336" id="%_idx_4336"></a>(define (sequence-&gt;exp seq)<br />
+</p><p></p><p><tt><a id="__idx_4336"></a>(define (sequence-&gt;exp seq)<br />
   (cond ((null? seq) seq)<br />
         ((last-exp? seq) (first-exp seq))<br />
-        (else (make-begin seq))))<br /><a name="%_idx_4338" id="%_idx_4338"></a>(define (make-begin seq) (cons 'begin seq))<br /></tt></p><p></p><p>
+        (else (make-begin seq))))<br /><a id="__idx_4338"></a>(define (make-begin seq) (cons 'begin seq))<br /></tt></p><p></p><p>
 ¤ A procedure application is any compound expression
 that is not one of the above expression types.  The <tt>car</tt> of the
 expression is the operator, and the <tt>cdr</tt> is the list of operands:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4340" id="%_idx_4340"></a>(define (application? exp) (pair? exp))<br /><a name="%_idx_4342" id="%_idx_4342"></a>(define (operator exp) (car exp))<br /><a name="%_idx_4344" id="%_idx_4344"></a>(define (operands exp) (cdr exp))<br /><a name="%_idx_4346" id="%_idx_4346"></a>(define (no-operands? ops) (null? ops))<br /><a name="%_idx_4348" id="%_idx_4348"></a>(define (first-operand ops) (car ops))<br /><a name="%_idx_4350" id="%_idx_4350"></a>(define (rest-operands ops) (cdr ops))<br /></tt></p><p></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_4340"></a>(define (application? exp) (pair? exp))<br /><a id="__idx_4342"></a>(define (operator exp) (car exp))<br /><a id="__idx_4344"></a>(define (operands exp) (cdr exp))<br /><a id="__idx_4346"></a>(define (no-operands? ops) (null? ops))<br /><a id="__idx_4348"></a>(define (first-operand ops) (car ops))<br /><a id="__idx_4350"></a>(define (rest-operands ops) (cdr ops))<br /></tt></p><p></p><p></p><p>
 
 
-<a name="%_sec_Temp_529" id="%_sec_Temp_529"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_529">Derived expressions</a></h4><p>
+<a id="__sec_Temp_529"></a>
+</p><h4>Derived expressions</h4><p>
 
-<a name="%_idx_4352" id="%_idx_4352"></a><a name="%_idx_4354" id="%_idx_4354"></a><a name="%_idx_4356" id="%_idx_4356"></a><a name="%_idx_4358" id="%_idx_4358"></a>
+<a id="__idx_4352"></a><a id="__idx_4354"></a><a id="__idx_4356"></a><a id="__idx_4358"></a>
 Some special forms in our language can be defined in terms of
 expressions involving other special forms, rather than being
 implemented directly.  One example is <tt>cond</tt>, which can be
@@ -449,11 +449,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 
 We include syntax procedures that extract the parts of a <tt>cond</tt>
 expression, and a procedure <tt>cond-&gt;if</tt> that transforms <tt>cond</tt>
-expressions into <tt>if</tt> expressions.  A case analysis begins with <tt>cond</tt> and has a list of predicate-action clauses.  A clause is an <tt>else</tt> clause if its predicate is the symbol <tt>else</tt>.<a name="call_footnote_Temp_530" href="#footnote_Temp_530" id="call_footnote_Temp_530"><sup><small>12</small></sup></a></p><p>
+expressions into <tt>if</tt> expressions.  A case analysis begins with <tt>cond</tt> and has a list of predicate-action clauses.  A clause is an <tt>else</tt> clause if its predicate is the symbol <tt>else</tt>.<a href="#footnote_Temp_530" id="call_footnote_Temp_530"><sup><small>12</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_4360" id="%_idx_4360"></a>(define (cond? exp) (tagged-list? exp 'cond))<br /><a name="%_idx_4362" id="%_idx_4362"></a>(define (cond-clauses exp) (cdr exp))<br /><a name="%_idx_4364" id="%_idx_4364"></a>(define (cond-else-clause? clause)<br />
-  (eq? (cond-predicate clause) 'else))<br /><a name="%_idx_4366" id="%_idx_4366"></a>(define (cond-predicate clause) (car clause))<br /><a name="%_idx_4368" id="%_idx_4368"></a>(define (cond-actions clause) (cdr clause))<br /><a name="%_idx_4370" id="%_idx_4370"></a>(define (cond-&gt;if exp)<br />
-  (expand-clauses (cond-clauses exp)))<br /><br /><a name="%_idx_4372" id="%_idx_4372"></a>(define (expand-clauses clauses)<br />
+</p><p></p><p><tt><a id="__idx_4360"></a>(define (cond? exp) (tagged-list? exp 'cond))<br /><a id="__idx_4362"></a>(define (cond-clauses exp) (cdr exp))<br /><a id="__idx_4364"></a>(define (cond-else-clause? clause)<br />
+  (eq? (cond-predicate clause) 'else))<br /><a id="__idx_4366"></a>(define (cond-predicate clause) (car clause))<br /><a id="__idx_4368"></a>(define (cond-actions clause) (cdr clause))<br /><a id="__idx_4370"></a>(define (cond-&gt;if exp)<br />
+  (expand-clauses (cond-clauses exp)))<br /><br /><a id="__idx_4372"></a>(define (expand-clauses clauses)<br />
   (if (null? clauses)<br />
       'false                          <em>; no <tt>else</tt> clause</em><br />
       (let ((first (car clauses))<br />
@@ -470,10 +470,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 Expressions (such as <tt>cond</tt>) that we choose to implement as syntactic
 transformations are called <em>derived expressions</em>.
 <tt>Let</tt> expressions are also derived expressions
-(see exercise <a href="#%_thm_4.6">4.6</a>).<a name="call_footnote_Temp_531" href="#footnote_Temp_531" id="call_footnote_Temp_531"><sup><small>13</small></sup></a></p><p>
+(see exercise <a href="#__thm_4.6">4.6</a>).<a href="#footnote_Temp_531" id="call_footnote_Temp_531"><sup><small>13</small></sup></a></p><p>
 
-</p><p><a name="%_thm_4.2" id="%_thm_4.2"></a>
-<b>Exercise 4.2.</b>  <a name="%_idx_4384" id="%_idx_4384"></a>Louis Reasoner plans to reorder the <tt>cond</tt> clauses
+</p><p><a id="__thm_4.2"></a>
+<b>Exercise 4.2.</b>  <a id="__idx_4384"></a>Louis Reasoner plans to reorder the <tt>cond</tt> clauses
 in <tt>eval</tt> so that the clause for procedure applications appears
 before the clause for assignments.  He argues that this will make the
 interpreter more efficient:  Since programs usually contain more
@@ -485,7 +485,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 </p><p></p><p>a. What is wrong with Louis's plan?  (Hint: What will
 Louis's evaluator do with the expression <tt>(define x 3)</tt>?)</p><p>
 
-</p><p></p><p><a name="%_idx_4386" id="%_idx_4386"></a>b. Louis is upset that his plan didn't work.
+</p><p></p><p><a id="__idx_4386"></a>b. Louis is upset that his plan didn't work.
 He is willing to go to any lengths to make his evaluator
 recognize procedure applications before it checks for most other
 kinds of expressions.
@@ -496,19 +496,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.3" id="%_thm_4.3"></a>
-<b>Exercise 4.3.</b>  <a name="%_idx_4388" id="%_idx_4388"></a><a name="%_idx_4390" id="%_idx_4390"></a><a name="%_idx_4392" id="%_idx_4392"></a>Rewrite <tt>eval</tt> so that the dispatch is done in data-directed
+</p><p><a id="__thm_4.3"></a>
+<b>Exercise 4.3.</b>  <a id="__idx_4388"></a><a id="__idx_4390"></a><a id="__idx_4392"></a>Rewrite <tt>eval</tt> so that the dispatch is done in data-directed
 style.  Compare this with the data-directed
 differentiation procedure of
-exercise <a href="book-Z-H-17.html#%_thm_2.73">2.73</a>.
+exercise <a href="book-Z-H-17.html#__thm_2.73">2.73</a>.
 (You may use the <tt>car</tt> of a compound expression as the
 type of the expression, as is appropriate for the syntax implemented
 in this section.)
 .
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.4" id="%_thm_4.4"></a>
-<b>Exercise 4.4.</b>  <a name="%_idx_4394" id="%_idx_4394"></a><a name="%_idx_4396" id="%_idx_4396"></a><a name="%_idx_4398" id="%_idx_4398"></a>Recall the definitions of the special forms <tt>and</tt> and <tt>or</tt>
+</p><p><a id="__thm_4.4"></a>
+<b>Exercise 4.4.</b>  <a id="__idx_4394"></a><a id="__idx_4396"></a><a id="__idx_4398"></a>Recall the definitions of the special forms <tt>and</tt> and <tt>or</tt>
 from chapter 1:
 </p><p></p><ul><li><tt>and</tt>: The expressions are evaluated from
 left to right.  If any expression evaluates to
@@ -530,8 +530,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 </p><p></p><p>
 
 
-</p><p><a name="%_thm_4.5" id="%_thm_4.5"></a>
-<b>Exercise 4.5.</b>  <a name="%_idx_4400" id="%_idx_4400"></a><a name="%_idx_4402" id="%_idx_4402"></a><a name="%_idx_4404" id="%_idx_4404"></a>Scheme allows an additional syntax for <tt>cond</tt> clauses, <tt>(&lt;<em>test</em>&gt; =&gt; &lt;<em>recipient</em>&gt;)</tt>.  If &lt;<em>test</em>&gt;
+</p><p><a id="__thm_4.5"></a>
+<b>Exercise 4.5.</b>  <a id="__idx_4400"></a><a id="__idx_4402"></a><a id="__idx_4404"></a>Scheme allows an additional syntax for <tt>cond</tt> clauses, <tt>(&lt;<em>test</em>&gt; =&gt; &lt;<em>recipient</em>&gt;)</tt>.  If &lt;<em>test</em>&gt;
 evaluates to a true value, then &lt;<em>recipient</em>&gt; is evaluated.  Its
 value must be a procedure of one argument; this procedure is then
 invoked on the value of the &lt;<em>test</em>&gt;, and the result is returned as
@@ -544,8 +544,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 syntax.
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.6" id="%_thm_4.6"></a>
-<b>Exercise 4.6.</b>  <a name="%_idx_4406" id="%_idx_4406"></a><tt>Let</tt> expressions are derived expressions, because</p><p>
+</p><p><a id="__thm_4.6"></a>
+<b>Exercise 4.6.</b>  <a id="__idx_4406"></a><tt>Let</tt> expressions are derived expressions, because</p><p>
 
 </p><p></p><p><tt>(let ((&lt;<em>var<sub>1</sub></em>&gt; &lt;<em>exp<sub>1</sub></em>&gt;) <tt>...</tt> (&lt;<em>var<sub><em>n</em></sub></em>&gt; &lt;<em>exp<sub><em>n</em></sub></em>&gt;))<br />
   &lt;<em>body</em>&gt;)<br /></tt></p><p></p><p>
@@ -563,8 +563,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.7" id="%_thm_4.7"></a>
-<b>Exercise 4.7.</b>  <a name="%_idx_4408" id="%_idx_4408"></a><a name="%_idx_4410" id="%_idx_4410"></a><a name="%_idx_4412" id="%_idx_4412"></a><tt>Let*</tt> is similar to <tt>let</tt>, except that the bindings of the <tt>let</tt> variables are performed sequentially from left to right, and each
+</p><p><a id="__thm_4.7"></a>
+<b>Exercise 4.7.</b>  <a id="__idx_4408"></a><a id="__idx_4410"></a><a id="__idx_4412"></a><tt>Let*</tt> is similar to <tt>let</tt>, except that the bindings of the <tt>let</tt> variables are performed sequentially from left to right, and each
 binding is made in an environment in which all of the preceding
 bindings are visible.  For example
 </p><p></p><p><tt>(let* ((x 3)<br />
@@ -573,7 +573,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
   (* x z))<br /></tt></p><p></p><p>
 returns 39.  Explain how a <tt>let*</tt> expression can be rewritten as a
 set of nested <tt>let</tt> expressions, and write a procedure <tt>let*-&gt;nested-lets</tt> that performs this transformation.  If we
-have already implemented <tt>let</tt> (exercise <a href="#%_thm_4.6">4.6</a>)
+have already implemented <tt>let</tt> (exercise <a href="#__thm_4.6">4.6</a>)
 and we want to
 extend the evaluator to handle <tt>let*</tt>, is it sufficient to add
 a clause to <tt>eval</tt> whose action is
@@ -582,28 +582,28 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 explicitly expand <tt>let*</tt> in terms of non-derived expressions?
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.8" id="%_thm_4.8"></a>
-<b>Exercise 4.8.</b>  <a name="%_idx_4414" id="%_idx_4414"></a><a name="%_idx_4416" id="%_idx_4416"></a><a name="%_idx_4418" id="%_idx_4418"></a><a name="%_idx_4420" id="%_idx_4420"></a>“Named <tt>let</tt>” is a variant of <tt>let</tt> that has the form
+</p><p><a id="__thm_4.8"></a>
+<b>Exercise 4.8.</b>  <a id="__idx_4414"></a><a id="__idx_4416"></a><a id="__idx_4418"></a><a id="__idx_4420"></a>“Named <tt>let</tt>” is a variant of <tt>let</tt> that has the form
 </p><p></p><p><tt>(let &lt;<em>var</em>&gt; &lt;<em>bindings</em>&gt; &lt;<em>body</em>&gt;)<br /></tt></p><p></p><p>
 The &lt;<em>bindings</em>&gt; and &lt;<em>body</em>&gt; are just as in ordinary <tt>let</tt>, except that &lt;<em>var</em>&gt; is bound within &lt;<em>body</em>&gt; to a
 procedure whose body is &lt;<em>body</em>&gt; and whose parameters are the
 variables in the &lt;<em>bindings</em>&gt;.  Thus, one can repeatedly execute the
 &lt;<em>body</em>&gt; by invoking the procedure named &lt;<em>var</em>&gt;.  For example,
-the iterative Fibonacci procedure (section <a href="book-Z-H-11.html#%_sec_1.2.2">1.2.2</a>)
+the iterative Fibonacci procedure (section <a href="book-Z-H-11.html#__sec_1.2.2">1.2.2</a>)
 can be rewritten using named <tt>let</tt> as follows:
-</p><p></p><p><tt><a name="%_idx_4422" id="%_idx_4422"></a>(define (fib n)<br />
+</p><p></p><p><tt><a id="__idx_4422"></a>(define (fib n)<br />
   (let fib-iter ((a 1)<br />
                  (b 0)<br />
                  (count n))<br />
     (if (= count 0)<br />
         b<br />
         (fib-iter (+ a b) a (- count 1)))))<br /></tt></p><p></p><p>
-Modify <tt>let-&gt;combination</tt> of exercise <a href="#%_thm_4.6">4.6</a> to
+Modify <tt>let-&gt;combination</tt> of exercise <a href="#__thm_4.6">4.6</a> to
 also support named <tt>let</tt>.
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.9" id="%_thm_4.9"></a>
-<b>Exercise 4.9.</b>  <a name="%_idx_4424" id="%_idx_4424"></a><a name="%_idx_4426" id="%_idx_4426"></a>Many languages support a variety of iteration constructs, such as <tt>do</tt>, <tt>for</tt>, <tt>while</tt>, and <tt>until</tt>.  In Scheme,
+</p><p><a id="__thm_4.9"></a>
+<b>Exercise 4.9.</b>  <a id="__idx_4424"></a><a id="__idx_4426"></a>Many languages support a variety of iteration constructs, such as <tt>do</tt>, <tt>for</tt>, <tt>while</tt>, and <tt>until</tt>.  In Scheme,
 iterative processes can be expressed in terms of ordinary procedure
 calls, so special iteration constructs provide no essential gain in
 computational power.  On the other hand, such constructs are often
@@ -611,16 +611,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 use, and show how to implement them as derived expressions.
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.10" id="%_thm_4.10"></a>
-<b>Exercise 4.10.</b>  <a name="%_idx_4428" id="%_idx_4428"></a><a name="%_idx_4430" id="%_idx_4430"></a>By using data abstraction, we were able to write an <tt>eval</tt>
+</p><p><a id="__thm_4.10"></a>
+<b>Exercise 4.10.</b>  <a id="__idx_4428"></a><a id="__idx_4430"></a>By using data abstraction, we were able to write an <tt>eval</tt>
 procedure that is independent of the particular syntax of the language
 to be evaluated.  To illustrate this, design and implement a new
 syntax for Scheme by modifying the procedures in this section, without
 changing <tt>eval</tt> or <tt>apply</tt>.
 </p><p></p><p>
 
-<a name="%_sec_4.1.3" id="%_sec_4.1.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_4.1.3">4.1.3  Evaluator Data Structures</a></h3><p>
+<a id="__sec_4.1.3"></a>
+</p><h3>4.1.3  Evaluator Data Structures</h3><p>
 
 </p><p>
 
@@ -630,82 +630,82 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 program, such as the representation of procedures and environments and
 the representation of true and false.</p><p>
 
-<a name="%_sec_Temp_541" id="%_sec_Temp_541"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_541">Testing of predicates</a></h4><p>
+<a id="__sec_Temp_541"></a>
+</p><h4>Testing of predicates</h4><p>
 
-<a name="%_idx_4432" id="%_idx_4432"></a>For conditionals, we accept anything to be true that is not
+<a id="__idx_4432"></a>For conditionals, we accept anything to be true that is not
 the explicit <tt>false</tt> object.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4434" id="%_idx_4434"></a>(define (true? x)<br />
-  (not (eq? x false)))<br /><a name="%_idx_4436" id="%_idx_4436"></a>(define (false? x)<br />
+</p><p></p><p><tt><a id="__idx_4434"></a>(define (true? x)<br />
+  (not (eq? x false)))<br /><a id="__idx_4436"></a>(define (false? x)<br />
   (eq? x false))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_542" id="%_sec_Temp_542"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_542">Representing procedures</a></h4><p>
+<a id="__sec_Temp_542"></a>
+</p><h4>Representing procedures</h4><p>
 
-<a name="%_idx_4438" id="%_idx_4438"></a>
+<a id="__idx_4438"></a>
 To handle primitives, we assume that we have available the
 following procedures:</p><p>
 
-</p><p></p><ul><li><a name="%_idx_4440" id="%_idx_4440"></a><tt>(apply-primitive-procedure &lt;<em>proc</em>&gt; &lt;<em>args</em>&gt;)</tt><br />
+</p><p></p><ul><li><a id="__idx_4440"></a><tt>(apply-primitive-procedure &lt;<em>proc</em>&gt; &lt;<em>args</em>&gt;)</tt><br />
 applies the given primitive procedure to the argument values in the
 list &lt;<em>args</em>&gt; and returns the result of the application.<p>
 
-</p></li><li><a name="%_idx_4442" id="%_idx_4442"></a><tt>(primitive-procedure? &lt;<em>proc</em>&gt;)</tt><br />
+</p></li><li><a id="__idx_4442"></a><tt>(primitive-procedure? &lt;<em>proc</em>&gt;)</tt><br />
 tests whether &lt;<em>proc</em>&gt; is a primitive procedure.
 </li></ul><p></p><p>
 
 These mechanisms for handling primitives are further described in
-section <a href="#%_sec_4.1.4">4.1.4</a>.</p><p>
+section <a href="#__sec_4.1.4">4.1.4</a>.</p><p>
 
 Compound procedures are constructed from parameters, procedure
 bodies, and environments using the constructor <tt>make-procedure</tt>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4444" id="%_idx_4444"></a>(define (make-procedure parameters body env)<br />
-  (list 'procedure parameters body env))<br /><a name="%_idx_4446" id="%_idx_4446"></a>(define (compound-procedure? p)<br />
-  (tagged-list? p 'procedure))<br /><a name="%_idx_4448" id="%_idx_4448"></a>(define (procedure-parameters p) (cadr p))<br /><a name="%_idx_4450" id="%_idx_4450"></a>(define (procedure-body p) (caddr p))<br /><a name="%_idx_4452" id="%_idx_4452"></a>(define (procedure-environment p) (cadddr p))<br /></tt></p><p></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_4444"></a>(define (make-procedure parameters body env)<br />
+  (list 'procedure parameters body env))<br /><a id="__idx_4446"></a>(define (compound-procedure? p)<br />
+  (tagged-list? p 'procedure))<br /><a id="__idx_4448"></a>(define (procedure-parameters p) (cadr p))<br /><a id="__idx_4450"></a>(define (procedure-body p) (caddr p))<br /><a id="__idx_4452"></a>(define (procedure-environment p) (cadddr p))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_543" id="%_sec_Temp_543"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_543">Operations on Environments</a></h4><p>
+<a id="__sec_Temp_543"></a>
+</p><h4>Operations on Environments</h4><p>
 
 
-<a name="%_idx_4454" id="%_idx_4454"></a>
+<a id="__idx_4454"></a>
 The evaluator needs operations for manipulating environments.  As
-explained in section <a href="book-Z-H-21.html#%_sec_3.2">3.2</a>, an environment is a
+explained in section <a href="book-Z-H-21.html#__sec_3.2">3.2</a>, an environment is a
 sequence of frames, where each frame is a table of bindings that
 associate variables with their corresponding values.  We use
 the following operations for manipulating environments:</p><p>
 
-</p><p></p><ul><a name="%_idx_4456" id="%_idx_4456"></a><li><tt>(lookup-variable-value &lt;<em>var</em>&gt; &lt;<em>env</em>&gt;)</tt><br />
+</p><p></p><ul><a id="__idx_4456"></a><li><tt>(lookup-variable-value &lt;<em>var</em>&gt; &lt;<em>env</em>&gt;)</tt><br />
 returns the value that is bound to the symbol &lt;<em>var</em>&gt; in the
 environment &lt;<em>env</em>&gt;, or signals an error if the variable is unbound.<p>
 
-</p></li><li><a name="%_idx_4458" id="%_idx_4458"></a><tt>(extend-environment &lt;<em>variables</em>&gt; &lt;<em>values</em>&gt; &lt;<em>base-env</em>&gt;)</tt><br />
+</p></li><li><a id="__idx_4458"></a><tt>(extend-environment &lt;<em>variables</em>&gt; &lt;<em>values</em>&gt; &lt;<em>base-env</em>&gt;)</tt><br />
 returns a new environment, consisting of a new frame in which the
 symbols in the list &lt;<em>variables</em>&gt; are bound to the corresponding
 elements in the list &lt;<em>values</em>&gt;, where the enclosing environment is
 the environment &lt;<em>base-env</em>&gt;.<p>
 
-</p></li><li><a name="%_idx_4460" id="%_idx_4460"></a><tt>(define-variable! &lt;<em>var</em>&gt; &lt;<em>value</em>&gt; &lt;<em>env</em>&gt;)</tt><br />
+</p></li><li><a id="__idx_4460"></a><tt>(define-variable! &lt;<em>var</em>&gt; &lt;<em>value</em>&gt; &lt;<em>env</em>&gt;)</tt><br />
 adds to the first frame in the environment &lt;<em>env</em>&gt; a new binding that
 associates the variable &lt;<em>var</em>&gt; with the value &lt;<em>value</em>&gt;.<p>
 
-</p></li><li><a name="%_idx_4462" id="%_idx_4462"></a><tt>(set-variable-value! &lt;<em>var</em>&gt; &lt;<em>value</em>&gt; &lt;<em>env</em>&gt;)</tt><br />
+</p></li><li><a id="__idx_4462"></a><tt>(set-variable-value! &lt;<em>var</em>&gt; &lt;<em>value</em>&gt; &lt;<em>env</em>&gt;)</tt><br />
 changes the binding of the variable &lt;<em>var</em>&gt; in the environment &lt;<em>env</em>&gt;
 so that the variable is now bound to the value &lt;<em>value</em>&gt;, or signals
 an error if the variable is unbound.
 </li></ul><p></p><p>
 
-<a name="%_idx_4464" id="%_idx_4464"></a>To implement these operations we represent an environment as a list of
+<a id="__idx_4464"></a>To implement these operations we represent an environment as a list of
 frames.  The enclosing environment of an environment is the <tt>cdr</tt> of
 the list.  The empty environment is simply the empty list.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4466" id="%_idx_4466"></a>(define (enclosing-environment env) (cdr env))<br /><a name="%_idx_4468" id="%_idx_4468"></a>(define (first-frame env) (car env))<br />
+</p><p></p><p><tt><a id="__idx_4466"></a>(define (enclosing-environment env) (cdr env))<br /><a id="__idx_4468"></a>(define (first-frame env) (car env))<br />
 (define the-empty-environment '())<br /></tt></p><p></p><p>
 Each frame of an environment is represented as a pair of lists: a list
-of the variables bound in that frame and a list of the associated values.<a name="call_footnote_Temp_544" href="#footnote_Temp_544" id="call_footnote_Temp_544"><sup><small>14</small></sup></a>
-</p><p></p><p><tt><a name="%_idx_4470" id="%_idx_4470"></a>(define (make-frame variables values)<br />
-  (cons variables values))<br /><a name="%_idx_4472" id="%_idx_4472"></a>(define (frame-variables frame) (car frame))<br /><a name="%_idx_4474" id="%_idx_4474"></a>(define (frame-values frame) (cdr frame))<br /><a name="%_idx_4476" id="%_idx_4476"></a>(define (add-binding-to-frame! var val frame)<br />
+of the variables bound in that frame and a list of the associated values.<a href="#footnote_Temp_544" id="call_footnote_Temp_544"><sup><small>14</small></sup></a>
+</p><p></p><p><tt><a id="__idx_4470"></a>(define (make-frame variables values)<br />
+  (cons variables values))<br /><a id="__idx_4472"></a>(define (frame-variables frame) (car frame))<br /><a id="__idx_4474"></a>(define (frame-values frame) (cdr frame))<br /><a id="__idx_4476"></a>(define (add-binding-to-frame! var val frame)<br />
   (set-car! frame (cons var (car frame)))<br />
   (set-cdr! frame (cons val (cdr frame))))<br /></tt></p><p></p><p></p><p>
 
@@ -715,7 +715,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 an error if the number of variables does not match the number of values.</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_4478" id="%_idx_4478"></a>(define (extend-environment vars vals base-env)<br />
+</p><p></p><p><tt><a id="__idx_4478"></a>(define (extend-environment vars vals base-env)<br />
   (if (= (length vars) (length vals))<br />
       (cons (make-frame vars vals) base-env)<br />
       (if (&lt; (length vars) (length vals))<br />
@@ -731,7 +731,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 variable” error.</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_4480" id="%_idx_4480"></a>(define (lookup-variable-value var env)<br />
+</p><p></p><p><tt><a id="__idx_4480"></a>(define (lookup-variable-value var env)<br />
   (define (env-loop env)<br />
     (define (scan vars vals)<br />
       (cond ((null? vars)<br />
@@ -751,7 +751,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 the corresponding value when we find it.</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_4482" id="%_idx_4482"></a>(define (set-variable-value! var val env)<br />
+</p><p></p><p><tt><a id="__idx_4482"></a>(define (set-variable-value! var val env)<br />
   (define (env-loop env)<br />
     (define (scan vars vals)<br />
       (cond ((null? vars)<br />
@@ -771,7 +771,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 (just as in <tt>set-variable-value!</tt>).  If no such binding
 exists, we adjoin one to the first frame.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4484" id="%_idx_4484"></a>(define (define-variable! var val env)<br />
+</p><p></p><p><tt><a id="__idx_4484"></a>(define (define-variable! var val env)<br />
   (let ((frame (first-frame env)))<br />
     (define (scan vars vals)<br />
       (cond ((null? vars)<br />
@@ -782,18 +782,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
     (scan (frame-variables frame)<br />
           (frame-values frame))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_4486" id="%_idx_4486"></a>The method described here is only one of many plausible ways to
+<a id="__idx_4486"></a>The method described here is only one of many plausible ways to
 represent environments.  Since we used data abstraction to isolate the
 rest of the evaluator from the detailed choice of representation, we
 could change the environment representation if we wanted to.  (See
-exercise <a href="#%_thm_4.11">4.11</a>.)  In a
+exercise <a href="#__thm_4.11">4.11</a>.)  In a
 production-quality Lisp system, the speed of the evaluator's
 environment operations – especially that of variable lookup – has a
 major impact on the performance of the system.  The representation
 described here, although conceptually simple, is not efficient and
-would not ordinarily be used in a production system.<a name="call_footnote_Temp_545" href="#footnote_Temp_545" id="call_footnote_Temp_545"><sup><small>15</small></sup></a></p><p>
+would not ordinarily be used in a production system.<a href="#footnote_Temp_545" id="call_footnote_Temp_545"><sup><small>15</small></sup></a></p><p>
 
-</p><p><a name="%_thm_4.11" id="%_thm_4.11"></a>
+</p><p><a id="__thm_4.11"></a>
 <b>Exercise 4.11.</b>  Instead of representing a frame as a pair of lists, we can represent a
 frame as a list of bindings, where each binding is a name-value pair.
 Rewrite the environment operations to use this alternative
@@ -801,7 +801,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.12" id="%_thm_4.12"></a>
+</p><p><a id="__thm_4.12"></a>
 <b>Exercise 4.12.</b>  The procedures <tt>set-variable-value!</tt>, <tt>define-variable!</tt>,
 and <tt>lookup-variable-value</tt> can be expressed in terms of
 more abstract procedures for traversing the environment structure.
@@ -809,7 +809,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 the three procedures in terms of these abstractions.
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.13" id="%_thm_4.13"></a>
+</p><p><a id="__thm_4.13"></a>
 <b>Exercise 4.13.</b>  Scheme allows us to create new bindings for variables by means of <tt>define</tt>, but provides no way to get rid of bindings.  Implement for
 the evaluator a special form <tt>make-unbound!</tt> that removes the
 binding of a given symbol from the environment in which the
@@ -820,11 +820,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 make.
 </p><p></p><p>
 
-<a name="%_sec_4.1.4" id="%_sec_4.1.4"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_4.1.4">4.1.4  Running the Evaluator as a Program</a></h3><p>
+<a id="__sec_4.1.4"></a>
+</p><h3>4.1.4  Running the Evaluator as a Program</h3><p>
 
 
-<a name="%_idx_4492" id="%_idx_4492"></a>
+<a id="__idx_4492"></a>
 Given the evaluator, we have in our hands a description
 (expressed in Lisp) of the process
 by which Lisp expressions are evaluated.  One advantage of expressing the
@@ -833,29 +833,29 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 expressions.  This can serve as a framework for experimenting with
 evaluation rules, as we shall do later in this chapter.</p><p>
 
-<a name="%_idx_4494" id="%_idx_4494"></a>Our evaluator program reduces expressions ultimately to the
+<a id="__idx_4494"></a>Our evaluator program reduces expressions ultimately to the
 application of primitive procedures.  Therefore, all that we need to
 run the evaluator is to create a mechanism that calls on the underlying
 Lisp system to model the application of primitive procedures.</p><p>
 
 There must be a binding for each primitive procedure name, so that when
 <tt>eval</tt> evaluates the operator of an application of a primitive, it
-will find an object to pass to <tt>apply</tt>.  We thus set up a <a name="%_idx_4496" id="%_idx_4496"></a><a name="%_idx_4498" id="%_idx_4498"></a>global
+will find an object to pass to <tt>apply</tt>.  We thus set up a <a id="__idx_4496"></a><a id="__idx_4498"></a>global
 environment that associates unique objects with the names of the
 primitive procedures that can appear
 in the expressions we will be evaluating.  The
-global environment also includes bindings for the symbols <a name="%_idx_4500" id="%_idx_4500"></a><tt>true</tt> and
+global environment also includes bindings for the symbols <a id="__idx_4500"></a><tt>true</tt> and
 <tt>false</tt>, so that they can be used as variables in expressions
 to be evaluated.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4502" id="%_idx_4502"></a>(define (setup-environment)<br />
+</p><p></p><p><tt><a id="__idx_4502"></a>(define (setup-environment)<br />
   (let ((initial-env<br />
          (extend-environment (primitive-procedure-names)<br />
                              (primitive-procedure-objects)<br />
                              the-empty-environment)))<br />
     (define-variable! 'true true initial-env)<br />
     (define-variable! 'false false initial-env)<br />
-    initial-env))<br /><a name="%_idx_4504" id="%_idx_4504"></a>(define the-global-environment (setup-environment))<br /></tt></p><p></p><p></p><p>
+    initial-env))<br /><a id="__idx_4504"></a>(define the-global-environment (setup-environment))<br /></tt></p><p></p><p></p><p>
 
 It does not matter how we represent the primitive procedure objects,
 so long as <tt>apply</tt> can identify and apply them by using the
@@ -863,11 +863,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 procedure as a list beginning with the symbol <tt>primitive</tt> and
 containing a procedure in the underlying Lisp that implements that primitive.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4506" id="%_idx_4506"></a>(define (primitive-procedure? proc)<br />
-  (tagged-list? proc 'primitive))<br /><br /><a name="%_idx_4508" id="%_idx_4508"></a>(define (primitive-implementation proc) (cadr proc))<br /></tt></p><p></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_4506"></a>(define (primitive-procedure? proc)<br />
+  (tagged-list? proc 'primitive))<br /><br /><a id="__idx_4508"></a>(define (primitive-implementation proc) (cadr proc))<br /></tt></p><p></p><p></p><p>
 
 <tt>Setup-environment</tt> will get the primitive names and implementation
-procedures from a list:<a name="call_footnote_Temp_549" href="#footnote_Temp_549" id="call_footnote_Temp_549"><sup><small>16</small></sup></a></p><p>
+procedures from a list:<a href="#footnote_Temp_549" id="call_footnote_Temp_549"><sup><small>16</small></sup></a></p><p>
 
 </p><p></p><p><tt>(define primitive-procedures<br />
   (list (list 'car car)<br />
@@ -875,41 +875,41 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
         (list 'cons cons)<br />
         (list 'null? null?)<br />
         &lt;<em>more primitives</em>&gt;<br />
-        ))<br /><a name="%_idx_4510" id="%_idx_4510"></a>(define (primitive-procedure-names)<br />
+        ))<br /><a id="__idx_4510"></a>(define (primitive-procedure-names)<br />
   (map car<br />
        primitive-procedures))<br /><br />
-(define (primitive-procedure-objects)<br /><a name="%_idx_4512" id="%_idx_4512"></a>  (map (lambda (proc) (list 'primitive (cadr proc)))<br />
+(define (primitive-procedure-objects)<br /><a id="__idx_4512"></a>  (map (lambda (proc) (list 'primitive (cadr proc)))<br />
        primitive-procedures))<br /></tt></p><p></p><p></p><p>
 
 To apply a primitive procedure, we simply apply the implementation
-procedure to the arguments, using the underlying Lisp system:<a name="call_footnote_Temp_550" href="#footnote_Temp_550" id="call_footnote_Temp_550"><sup><small>17</small></sup></a></p><p>
+procedure to the arguments, using the underlying Lisp system:<a href="#footnote_Temp_550" id="call_footnote_Temp_550"><sup><small>17</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_4514" id="%_idx_4514"></a>(define (apply-primitive-procedure proc args)<br />
+</p><p></p><p><tt><a id="__idx_4514"></a>(define (apply-primitive-procedure proc args)<br />
   (apply-in-underlying-scheme<br />
    (primitive-implementation proc) args))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_4516" id="%_idx_4516"></a><a name="%_idx_4518" id="%_idx_4518"></a>For convenience in running the metacircular evaluator, we provide a <em>driver loop</em> that models the read-eval-print loop of the underlying
-Lisp system.  It prints a <a name="%_idx_4520" id="%_idx_4520"></a><em>prompt</em>, reads an input expression,
+<a id="__idx_4516"></a><a id="__idx_4518"></a>For convenience in running the metacircular evaluator, we provide a <em>driver loop</em> that models the read-eval-print loop of the underlying
+Lisp system.  It prints a <a id="__idx_4520"></a><em>prompt</em>, reads an input expression,
 evaluates this expression in the global environment, and prints the
 result.  We precede each printed result by an <em>output prompt</em> so
 as to distinguish the value of the expression from other
-output that may be printed.<a name="call_footnote_Temp_551" href="#footnote_Temp_551" id="call_footnote_Temp_551"><sup><small>18</small></sup></a></p><p>
+output that may be printed.<a href="#footnote_Temp_551" id="call_footnote_Temp_551"><sup><small>18</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_4530" id="%_idx_4530"></a>(define input-prompt ";;; M-Eval input:")<br />
-(define output-prompt ";;; M-Eval value:")<br /><a name="%_idx_4532" id="%_idx_4532"></a>(define (driver-loop)<br />
+</p><p></p><p><tt><a id="__idx_4530"></a>(define input-prompt ";;; M-Eval input:")<br />
+(define output-prompt ";;; M-Eval value:")<br /><a id="__idx_4532"></a>(define (driver-loop)<br />
   (prompt-for-input input-prompt)<br />
   (let ((input (read)))<br />
     (let ((output (eval input the-global-environment)))<br />
       (announce-output output-prompt)<br />
       (user-print output)))<br />
-  (driver-loop))<br /><a name="%_idx_4534" id="%_idx_4534"></a>(define (prompt-for-input string)<br />
-  (newline) (newline) (display string) (newline))<br /><br /><a name="%_idx_4536" id="%_idx_4536"></a>(define (announce-output string)<br />
+  (driver-loop))<br /><a id="__idx_4534"></a>(define (prompt-for-input string)<br />
+  (newline) (newline) (display string) (newline))<br /><br /><a id="__idx_4536"></a>(define (announce-output string)<br />
   (newline) (display string) (newline))<br /></tt></p><p></p><p>
 We use a special printing procedure, <tt>user-print</tt>, to avoid printing the
 environment part of a compound procedure, which may be a very long list
 (or may even contain cycles).</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4538" id="%_idx_4538"></a>(define (user-print object)<br />
+</p><p></p><p><tt><a id="__idx_4538"></a>(define (user-print object)<br />
   (if (compound-procedure? object)<br />
       (display (list 'compound-procedure<br />
                      (procedure-parameters object)<br />
@@ -930,7 +930,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
             (append (cdr x) y))))<br /><i>;;; M-Eval value:</i><br /><i>ok</i><br /><i>;;; M-Eval input:</i><br />
 (append '(a b c) '(d e f))<br /><i>;;; M-Eval value:</i><br /><i>(a b c d e f)</i><br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_4.14" id="%_thm_4.14"></a>
+</p><p><a id="__thm_4.14"></a>
 <b>Exercise 4.14.</b>  Eva Lu Ator and Louis Reasoner are each experimenting with the
 metacircular evaluator.  Eva types in the definition of <tt>map</tt>, and
 runs some test programs that use it.  They work fine.  Louis, in contrast,
@@ -939,14 +939,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 wrong.  Explain why Louis's <tt>map</tt> fails even though Eva's works.
 </p><p></p><p>
 
-<a name="%_sec_4.1.5" id="%_sec_4.1.5"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_4.1.5">4.1.5  Data as Programs</a></h3><p>
+<a id="__sec_4.1.5"></a>
+</p><h3>4.1.5  Data as Programs</h3><p>
 
 
-<a name="%_idx_4540" id="%_idx_4540"></a><a name="%_idx_4542" id="%_idx_4542"></a>
+<a id="__idx_4540"></a><a id="__idx_4542"></a>
 In thinking about a Lisp program that evaluates Lisp expressions, an
 analogy might be helpful.  One operational view of the meaning of a
-program is that a <a name="%_idx_4544" id="%_idx_4544"></a>program is a description of an abstract (perhaps
+program is that a <a id="__idx_4544"></a>program is a description of an abstract (perhaps
 infinitely large) machine.  For example, consider the familiar
 program to compute factorials:</p><p>
 
@@ -954,38 +954,38 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
   (if (= n 1)<br />
       1<br />
       (* (factorial (- n 1)) n)))<br /></tt></p><p></p><p>
-<a name="%_idx_4546" id="%_idx_4546"></a>We may regard this program as the description of a machine containing
+<a id="__idx_4546"></a>We may regard this program as the description of a machine containing
 parts that decrement, multiply, and test for equality, together with a
 two-position switch and another factorial machine. (The factorial
 machine is infinite because it contains another factorial machine
-within it.)  Figure <a href="#%_fig_4.2">4.2</a> is a flow diagram for the
+within it.)  Figure <a href="#__fig_4.2">4.2</a> is a flow diagram for the
 factorial machine, showing how the parts are wired together.</p><p>
 
-<a name="%_fig_4.2" id="%_fig_4.2"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch4-Z-G-2.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 4.2:</b>  The factorial program, viewed as an abstract machine.</div></caption><tr><td>
+<a id="__fig_4.2"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch4-Z-G-2.gif" alt="ch4-Z-G-2" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 4.2:</b>  The factorial program, viewed as an abstract machine.</div></caption><tr><td>
 
 </td></tr></table></div><p>              </p><p>
 
 
-<a name="%_idx_4548" id="%_idx_4548"></a>In a similar way, we can regard the evaluator as a very special
+<a id="__idx_4548"></a>In a similar way, we can regard the evaluator as a very special
 machine that takes as input a description of a machine.  Given this
 input, the evaluator configures itself to emulate the machine
 described.  For example, if we feed our evaluator the definition of
-<tt>factorial</tt>, as shown in figure <a href="#%_fig_4.3">4.3</a>, the
+<tt>factorial</tt>, as shown in figure <a href="#__fig_4.3">4.3</a>, the
 evaluator will be able to compute factorials.</p><p>
 
-<a name="%_fig_4.3" id="%_fig_4.3"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch4-Z-G-3.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 4.3:</b>  The evaluator emulating a factorial machine.</div></caption><tr><td>
+<a id="__fig_4.3"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch4-Z-G-3.gif" alt="ch4-Z-G-3" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 4.3:</b>  The evaluator emulating a factorial machine.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_idx_4550" id="%_idx_4550"></a><a name="%_idx_4552" id="%_idx_4552"></a>From this perspective, our evaluator is seen to be a <em>universal machine</em>.
-It mimics other machines when these are described as Lisp programs.<a name="call_footnote_Temp_553" href="#footnote_Temp_553" id="call_footnote_Temp_553"><sup><small>19</small></sup></a>
+<a id="__idx_4550"></a><a id="__idx_4552"></a>From this perspective, our evaluator is seen to be a <em>universal machine</em>.
+It mimics other machines when these are described as Lisp programs.<a href="#footnote_Temp_553" id="call_footnote_Temp_553"><sup><small>19</small></sup></a>
 This is striking. Try to imagine an analogous evaluator for electrical
 circuits.  This would be a circuit that takes as input a signal
 encoding the plans for some other circuit, such as a filter.  Given
 this input, the circuit evaluator would then behave like a filter with
 the same description.  Such a universal electrical circuit is
 almost unimaginably complex.  It is remarkable that the program
-evaluator is a rather simple program.<a name="call_footnote_Temp_554" href="#footnote_Temp_554" id="call_footnote_Temp_554"><sup><small>20</small></sup></a></p><p>
+evaluator is a rather simple program.<a href="#footnote_Temp_554" id="call_footnote_Temp_554"><sup><small>20</small></sup></a></p><p>
 
 Another striking aspect of the evaluator is that it acts as a bridge
 between the data objects that are manipulated by our programming
@@ -1003,19 +1003,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 of confusion.  In fact, it is sometimes convenient to ignore this
 distinction, and to give the user the ability to explicitly evaluate a
 data object as a Lisp expression, by making <tt>eval</tt> available for
-use in programs.  Many Lisp dialects provide a <a name="%_idx_4572" id="%_idx_4572"></a><a name="%_idx_4574" id="%_idx_4574"></a>primitive <tt>eval</tt>
+use in programs.  Many Lisp dialects provide a <a id="__idx_4572"></a><a id="__idx_4574"></a>primitive <tt>eval</tt>
 procedure that takes as arguments an expression and an environment and
-evaluates the expression relative to the environment.<a name="call_footnote_Temp_555" href="#footnote_Temp_555" id="call_footnote_Temp_555"><sup><small>21</small></sup></a>
+evaluates the expression relative to the environment.<a href="#footnote_Temp_555" id="call_footnote_Temp_555"><sup><small>21</small></sup></a>
 Thus,</p><p>
 
 </p><p></p><p><tt>(eval '(* 5 5) user-initial-environment)<br /></tt></p><p></p><p>
 and
 </p><p></p><p><tt>(eval (cons '* (list 5 5)) user-initial-environment)<br /></tt></p><p></p><p>
-will both return 25.<a name="call_footnote_Temp_556" href="#footnote_Temp_556" id="call_footnote_Temp_556"><sup><small>22</small></sup></a></p><p>
+will both return 25.<a href="#footnote_Temp_556" id="call_footnote_Temp_556"><sup><small>22</small></sup></a></p><p>
 
 
-</p><p><a name="%_thm_4.15" id="%_thm_4.15"></a>
-<b>Exercise 4.15.</b>  <a name="%_idx_4588" id="%_idx_4588"></a>Given a one-argument procedure <tt>p</tt> and an object <tt>a</tt>, <tt>p</tt>
+</p><p><a id="__thm_4.15"></a>
+<b>Exercise 4.15.</b>  <a id="__idx_4588"></a>Given a one-argument procedure <tt>p</tt> and an object <tt>a</tt>, <tt>p</tt>
 is said to “halt” on <tt>a</tt> if evaluating the expression <tt>(p
 a)</tt> returns a value (as opposed to terminating with an error message
 or running forever).  Show that it is impossible to write a procedure
@@ -1029,23 +1029,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
       'halted))<br /></tt></p><p></p><p>
 Now consider evaluating the expression <tt>(try try)</tt> and show that
 any possible outcome (either halting or running forever) violates the
-intended behavior of <tt>halts?</tt>.<a name="call_footnote_Temp_558" href="#footnote_Temp_558" id="call_footnote_Temp_558"><sup><small>23</small></sup></a>
+intended behavior of <tt>halts?</tt>.<a href="#footnote_Temp_558" id="call_footnote_Temp_558"><sup><small>23</small></sup></a>
 
 </p><p></p><p>
 
-<a name="%_sec_4.1.6" id="%_sec_4.1.6"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_4.1.6">4.1.6  Internal Definitions</a></h3><p>
+<a id="__sec_4.1.6"></a>
+</p><h3>4.1.6  Internal Definitions</h3><p>
 
 
-<a name="%_idx_4598" id="%_idx_4598"></a><a name="%_idx_4600" id="%_idx_4600"></a>
-<a name="%_idx_4602" id="%_idx_4602"></a>Our environment model of evaluation and our metacircular evaluator execute
+<a id="__idx_4598"></a><a id="__idx_4600"></a>
+<a id="__idx_4602"></a>Our environment model of evaluation and our metacircular evaluator execute
 definitions in sequence, extending the environment frame one
 definition at a time.  This is particularly convenient for interactive
 program development, in which the programmer needs to freely mix the
 application of procedures with the definition of new procedures.
 However, if we think carefully about the internal definitions
 used to implement block structure (introduced in
-section <a href="book-Z-H-10.html#%_sec_1.1.8">1.1.8</a>), we will find that name-by-name extension
+section <a href="book-Z-H-10.html#__sec_1.1.8">1.1.8</a>), we will find that name-by-name extension
 of the environment may not be the best way to define local variables.</p><p>
 
 Consider a procedure with internal definitions, such as</p><p>
@@ -1082,19 +1082,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 will have been defined by the time <tt>even?</tt> is executed.  In fact,
 our sequential evaluation mechanism will give the same result as a
 mechanism that directly implements simultaneous definition for any
-procedure in which the <a name="%_idx_4604" id="%_idx_4604"></a>internal definitions come first in a body and
+procedure in which the <a id="__idx_4604"></a>internal definitions come first in a body and
 evaluation of the value expressions for the defined variables doesn't
 actually use any of the defined variables.
 (For an example of a procedure that doesn't obey these restrictions,
 so that sequential definition isn't equivalent to simultaneous definition,
-see exercise <a href="#%_thm_4.19">4.19</a>.)<a name="call_footnote_Temp_559" href="#footnote_Temp_559" id="call_footnote_Temp_559"><sup><small>24</small></sup></a></p><p>
+see exercise <a href="#__thm_4.19">4.19</a>.)<a href="#footnote_Temp_559" id="call_footnote_Temp_559"><sup><small>24</small></sup></a></p><p>
 
 There is, however, a simple way to treat definitions so that
 internally defined names have truly simultaneous scope – just create
 all local variables that will be in the current environment before
 evaluating any of the value expressions.  One way to do this is by a
 syntax transformation on <tt>lambda</tt> expressions.  Before evaluating
-the body of a <tt>lambda</tt> expression, we <a name="%_idx_4606" id="%_idx_4606"></a><a name="%_idx_4608" id="%_idx_4608"></a>“scan out” and eliminate
+the body of a <tt>lambda</tt> expression, we <a id="__idx_4606"></a><a id="__idx_4608"></a>“scan out” and eliminate
 all the internal definitions in the body.  The internally defined
 variables will be created with a <tt>let</tt> and then set to their
 values by assignment.  For example, the procedure</p><p>
@@ -1116,31 +1116,31 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 the not-yet-assigned variable.</p><p>
 
 An alternative strategy for scanning out internal definitions is shown
-in exercise <a href="#%_thm_4.18">4.18</a>.  Unlike the transformation
+in exercise <a href="#__thm_4.18">4.18</a>.  Unlike the transformation
 shown above, this enforces the restriction that the defined variables'
-values can be evaluated without using any of the variables' values.<a name="call_footnote_Temp_560" href="#footnote_Temp_560" id="call_footnote_Temp_560"><sup><small>25</small></sup></a></p><p>
+values can be evaluated without using any of the variables' values.<a href="#footnote_Temp_560" id="call_footnote_Temp_560"><sup><small>25</small></sup></a></p><p>
 
-</p><p><a name="%_thm_4.16" id="%_thm_4.16"></a>
+</p><p><a id="__thm_4.16"></a>
 <b>Exercise 4.16.</b>  In this exercise we implement the method just described for
 interpreting internal definitions.
 We assume that the evaluator supports <tt>let</tt>
-(see exercise <a href="#%_thm_4.6">4.6</a>).</p><p>
+(see exercise <a href="#__thm_4.6">4.6</a>).</p><p>
 
-<a name="%_idx_4612" id="%_idx_4612"></a>a.  Change <tt>lookup-variable-value</tt>
-(section <a href="#%_sec_4.1.3">4.1.3</a>) to signal an error if
+<a id="__idx_4612"></a>a.  Change <tt>lookup-variable-value</tt>
+(section <a href="#__sec_4.1.3">4.1.3</a>) to signal an error if
 the value it finds is the symbol <tt>*unassigned*</tt>.</p><p>
 
-<a name="%_idx_4614" id="%_idx_4614"></a>b.  Write a procedure <tt>scan-out-defines</tt> that takes a
+<a id="__idx_4614"></a>b.  Write a procedure <tt>scan-out-defines</tt> that takes a
 procedure body and returns an equivalent one that has no internal
 definitions, by making the transformation described above.</p><p>
 
 c.  Install <tt>scan-out-defines</tt> in the interpreter, either in <tt>make-procedure</tt> or in <tt>procedure-body</tt> (see
-section <a href="#%_sec_4.1.3">4.1.3</a>).  Which place is better?
+section <a href="#__sec_4.1.3">4.1.3</a>).  Which place is better?
 Why?
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.17" id="%_thm_4.17"></a>
+</p><p><a id="__thm_4.17"></a>
 <b>Exercise 4.17.</b>  Draw diagrams of the environment in effect when evaluating the
 expression &lt;<em>e3</em>&gt; in the procedure in the text, comparing how this
 will be structured when definitions are interpreted sequentially with
@@ -1152,7 +1152,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 definitions without constructing the extra frame.
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.18" id="%_thm_4.18"></a>
+</p><p><a id="__thm_4.18"></a>
 <b>Exercise 4.18.</b>  Consider an alternative strategy for scanning out definitions that
 translates the example in the text to
 </p><p></p><p><tt>(lambda &lt;<em>vars</em>&gt;<br />
@@ -1167,9 +1167,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 created by the interpreter, that do not appear in the user's
 program.
 Consider the <tt>solve</tt> procedure from
-section <a href="book-Z-H-24.html#%_sec_3.5.4">3.5.4</a>:</p><p>
+section <a href="book-Z-H-24.html#__sec_3.5.4">3.5.4</a>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4616" id="%_idx_4616"></a>(define (solve f y0 dt)<br />
+</p><p></p><p><tt><a id="__idx_4616"></a>(define (solve f y0 dt)<br />
   (define y (integral (delay dy) y0 dt))<br />
   (define dy (stream-map f y))<br />
   y)<br /></tt></p><p></p><p>
@@ -1179,7 +1179,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.19" id="%_thm_4.19"></a>
+</p><p><a id="__thm_4.19"></a>
 <b>Exercise 4.19.</b>  Ben Bitdiddle, Alyssa P. Hacker, and Eva Lu Ator are arguing about
 the desired result of evaluating the expression</p><p>
 
@@ -1195,7 +1195,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 recursion requires the simultaneous scope rule for internal procedure
 definitions, and that it is unreasonable to treat procedure names
 differently from other names.  Thus, she argues for the mechanism
-implemented in exercise <a href="#%_thm_4.16">4.16</a>.  This would lead to
+implemented in exercise <a href="#__thm_4.16">4.16</a>.  This would lead to
 <tt>a</tt> being unassigned at the time that the value for <tt>b</tt> is to
 be computed.  Hence, in Alyssa's view the procedure should produce an
 error.  Eva has a third opinion.  She says that if the definitions of
@@ -1204,12 +1204,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 view <tt>a</tt> should be 5, <tt>b</tt> should be 15, and the result should
 be 20.  Which (if any) of these viewpoints do you support?  Can you
 devise a way to implement internal definitions so that they behave as
-Eva prefers?<a name="call_footnote_Temp_565" href="#footnote_Temp_565" id="call_footnote_Temp_565"><sup><small>26</small></sup></a>
+Eva prefers?<a href="#footnote_Temp_565" id="call_footnote_Temp_565"><sup><small>26</small></sup></a>
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.20" id="%_thm_4.20"></a>
-<b>Exercise 4.20.</b>  <a name="%_idx_4618" id="%_idx_4618"></a><a name="%_idx_4620" id="%_idx_4620"></a>Because internal definitions look sequential but are actually
+</p><p><a id="__thm_4.20"></a>
+<b>Exercise 4.20.</b>  <a id="__idx_4618"></a><a id="__idx_4620"></a>Because internal definitions look sequential but are actually
 simultaneous, some people prefer to avoid them entirely, and use the
 special form <tt>letrec</tt> instead.  <tt>Letrec</tt> looks like <tt>let</tt>,
 so it is not surprising that the variables it binds are bound
@@ -1237,7 +1237,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 are evaluated in an environment that includes all the <tt>letrec</tt>
 bindings.  This permits recursion in the bindings, such as the mutual
 recursion of <tt>even?</tt> and <tt>odd?</tt> in the example above, or
-<a name="%_idx_4622" id="%_idx_4622"></a>the evaluation of 10 factorial with</p><p>
+<a id="__idx_4622"></a>the evaluation of 10 factorial with</p><p>
 
 </p><p></p><p><tt>(letrec ((fact<br />
           (lambda (n)<br />
@@ -1248,7 +1248,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 
 </p><p></p><p>a. Implement <tt>letrec</tt> as a derived expression, by transforming
 a <tt>letrec</tt> expression into a <tt>let</tt> expression as shown in
-the text above or in exercise <a href="#%_thm_4.18">4.18</a>.
+the text above or in exercise <a href="#__thm_4.18">4.18</a>.
 That is, the <tt>letrec</tt> variables should be created with a <tt>let</tt>
 and then be assigned their values with <tt>set!</tt>.</p><p>
 
@@ -1263,13 +1263,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.21" id="%_thm_4.21"></a>
-<b>Exercise 4.21.</b>  <a name="%_idx_4624" id="%_idx_4624"></a>Amazingly, Louis's intuition in exercise <a href="#%_thm_4.20">4.20</a>
+</p><p><a id="__thm_4.21"></a>
+<b>Exercise 4.21.</b>  <a id="__idx_4624"></a>Amazingly, Louis's intuition in exercise <a href="#__thm_4.20">4.20</a>
 is correct.  It is indeed possible to specify recursive procedures
 without using <tt>letrec</tt> (or even <tt>define</tt>), although the method
 for accomplishing this is much more subtle than Louis imagined.  The
 following expression computes 10 factorial by applying a recursive
-<a name="%_idx_4626" id="%_idx_4626"></a>factorial procedure:<a name="call_footnote_Temp_568" href="#footnote_Temp_568" id="call_footnote_Temp_568"><sup><small>27</small></sup></a>
+<a id="__idx_4626"></a>factorial procedure:<a href="#footnote_Temp_568" id="call_footnote_Temp_568"><sup><small>27</small></sup></a>
 </p><p></p><p><tt>((lambda (n)<br />
    ((lambda (fact)<br />
       (fact fact n))<br />
@@ -1305,12 +1305,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
      (if (= n 0) false (ev? &lt;??&gt; &lt;??&gt; &lt;??&gt;)))))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-<a name="%_sec_4.1.7" id="%_sec_4.1.7"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_4.1.7">4.1.7  Separating Syntactic Analysis from Execution</a></h3><p>
+<a id="__sec_4.1.7"></a>
+</p><h3>4.1.7  Separating Syntactic Analysis from Execution</h3><p>
 
 
-<a name="%_idx_4634" id="%_idx_4634"></a><a name="%_idx_4636" id="%_idx_4636"></a><a name="%_idx_4638" id="%_idx_4638"></a>
-<a name="%_idx_4640" id="%_idx_4640"></a><a name="%_idx_4642" id="%_idx_4642"></a>The evaluator implemented above is simple, but it is very
+<a id="__idx_4634"></a><a id="__idx_4636"></a><a id="__idx_4638"></a>
+<a id="__idx_4640"></a><a id="__idx_4642"></a>The evaluator implemented above is simple, but it is very
 inefficient, because the syntactic analysis of expressions is interleaved
 with their execution.  Thus if a program is executed many times, its
 syntax is analyzed many times.  Consider, for example, evaluating <tt>(factorial 4)</tt> using the following definition of <tt>factorial</tt>:</p><p>
@@ -1333,9 +1333,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 
 We can transform the evaluator to be significantly more efficient by
 arranging things so that syntactic analysis is performed only
-once.<a name="call_footnote_Temp_569" href="#footnote_Temp_569" id="call_footnote_Temp_569"><sup><small>28</small></sup></a> We split <tt>eval</tt>, which takes an
+once.<a href="#footnote_Temp_569" id="call_footnote_Temp_569"><sup><small>28</small></sup></a> We split <tt>eval</tt>, which takes an
 expression and an environment, into two parts.  The procedure <tt>analyze</tt> takes only the expression.  It performs the syntactic
-analysis and returns a new procedure, the <a name="%_idx_4652" id="%_idx_4652"></a><em>execution procedure</em>, that
+analysis and returns a new procedure, the <a id="__idx_4652"></a><em>execution procedure</em>, that
 encapsulates the work to be done in executing the analyzed
 expression.  The execution procedure takes an environment as its
 argument and completes the evaluation.  This saves work because <tt>analyze</tt> will be called only once on an expression, while the
@@ -1343,16 +1343,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 
 With the separation into analysis and execution, <tt>eval</tt> now becomes</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4654" id="%_idx_4654"></a>(define (eval exp env)<br />
+</p><p></p><p><tt><a id="__idx_4654"></a>(define (eval exp env)<br />
   ((analyze exp) env))<br /></tt></p><p></p><p></p><p>
 
 The result of calling <tt>analyze</tt> is the execution procedure to
 be applied to the environment.  The <tt>analyze</tt> procedure is
 the same case analysis as performed by the original <tt>eval</tt> of
-section <a href="#%_sec_4.1.1">4.1.1</a>, except that the procedures to
+section <a href="#__sec_4.1.1">4.1.1</a>, except that the procedures to
 which we dispatch perform only analysis, not full evaluation:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4656" id="%_idx_4656"></a>(define (analyze exp)<br />
+</p><p></p><p><tt><a id="__idx_4656"></a>(define (analyze exp)<br />
   (cond ((self-evaluating? exp) <br />
          (analyze-self-evaluating exp))<br />
         ((quoted? exp) (analyze-quoted exp))<br />
@@ -1371,7 +1371,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 self-evaluating expressions.  It returns an execution procedure that
 ignores its environment argument and just returns the expression:</p><p>
 
-<a name="%_idx_4658" id="%_idx_4658"></a></p><p></p><p><tt>(define (analyze-self-evaluating exp)<br />
+<a id="__idx_4658"></a></p><p></p><p><tt>(define (analyze-self-evaluating exp)<br />
   (lambda (env) exp))<br /></tt></p><p></p><p></p><p>
 
 For a quoted expression, we can gain a little efficiency by
@@ -1383,7 +1383,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
     (lambda (env) qval)))<br /></tt></p><p></p><p></p><p>
 
 Looking up a variable value must still be done in the execution phase,
-since this depends upon knowing the environment.<a name="call_footnote_Temp_570" href="#footnote_Temp_570" id="call_footnote_Temp_570"><sup><small>29</small></sup></a></p><p>
+since this depends upon knowing the environment.<a href="#footnote_Temp_570" id="call_footnote_Temp_570"><sup><small>29</small></sup></a></p><p>
 
 </p><p></p><p><tt>(define (analyze-variable exp)<br />
   (lambda (env) (lookup-variable-value exp env)))<br /></tt></p><p></p><p></p><p>
@@ -1431,7 +1431,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
     (lambda (env) (make-procedure vars bproc env))))<br /></tt></p><p></p><p></p><p>
 
 Analysis of a sequence of expressions (as in a <tt>begin</tt> or the body
-of a <tt>lambda</tt> expression) is more involved.<a name="call_footnote_Temp_571" href="#footnote_Temp_571" id="call_footnote_Temp_571"><sup><small>30</small></sup></a>
+of a <tt>lambda</tt> expression) is more involved.<a href="#footnote_Temp_571" id="call_footnote_Temp_571"><sup><small>30</small></sup></a>
 Each expression
 in the sequence is analyzed, yielding an execution
 procedure.  These execution procedures are combined to produce an
@@ -1457,7 +1457,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 calls the operator execution procedure (to obtain the
 actual procedure to be applied) and the operand execution
 procedures (to obtain the actual arguments).  We then pass these to <tt>execute-application</tt>, which is the analog of <tt>apply</tt> in
-section <a href="#%_sec_4.1.1">4.1.1</a>.
+section <a href="#__sec_4.1.1">4.1.1</a>.
 <tt>Execute-application</tt> differs from <tt>apply</tt> in that the procedure body for a compound procedure has already
 been analyzed, so there is no need to do further analysis.  Instead,
 we just call the execution procedure for the body on the extended
@@ -1468,7 +1468,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
     (lambda (env)<br />
       (execute-application (fproc env)<br />
                            (map (lambda (aproc) (aproc env))<br />
-                                aprocs)))))<br /><a name="%_idx_4660" id="%_idx_4660"></a>(define (execute-application proc args)<br />
+                                aprocs)))))<br /><a id="__idx_4660"></a>(define (execute-application proc args)<br />
   (cond ((primitive-procedure? proc)<br />
          (apply-primitive-procedure proc args))<br />
         ((compound-procedure? proc)<br />
@@ -1483,20 +1483,20 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 
 Our new evaluator uses the same data structures, syntax
 procedures, and run-time support procedures as in
-sections <a href="#%_sec_4.1.2">4.1.2</a>,
- <a href="#%_sec_4.1.3">4.1.3</a>, and <a href="#%_sec_4.1.4">4.1.4</a>.</p><p>
+sections <a href="#__sec_4.1.2">4.1.2</a>,
+ <a href="#__sec_4.1.3">4.1.3</a>, and <a href="#__sec_4.1.4">4.1.4</a>.</p><p>
 
-</p><p><a name="%_thm_4.22" id="%_thm_4.22"></a>
-<b>Exercise 4.22.</b>  <a name="%_idx_4662" id="%_idx_4662"></a>Extend the evaluator in this section to support the special form <tt>let</tt>.
-(See exercise <a href="#%_thm_4.6">4.6</a>.)
+</p><p><a id="__thm_4.22"></a>
+<b>Exercise 4.22.</b>  <a id="__idx_4662"></a>Extend the evaluator in this section to support the special form <tt>let</tt>.
+(See exercise <a href="#__thm_4.6">4.6</a>.)
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.23" id="%_thm_4.23"></a>
-<b>Exercise 4.23.</b>  <a name="%_idx_4664" id="%_idx_4664"></a>Alyssa P. Hacker doesn't understand why <tt>analyze-sequence</tt> needs to be
+</p><p><a id="__thm_4.23"></a>
+<b>Exercise 4.23.</b>  <a id="__idx_4664"></a>Alyssa P. Hacker doesn't understand why <tt>analyze-sequence</tt> needs to be
 so complicated.  All the other analysis procedures
 are straightforward transformations of the corresponding evaluation
-procedures (or <tt>eval</tt> clauses) in section <a href="#%_sec_4.1.1">4.1.1</a>.
+procedures (or <tt>eval</tt> clauses) in section <a href="#__sec_4.1.1">4.1.1</a>.
 She expected <tt>analyze-sequence</tt> to look like this:</p><p>
 
 
@@ -1525,7 +1525,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.24" id="%_thm_4.24"></a>
+</p><p><a id="__thm_4.24"></a>
 <b>Exercise 4.24.</b>  Design and carry out some experiments to
 compare the speed of the original metacircular evaluator
 with the version in this section.  Use your results to estimate the fraction
@@ -1534,7 +1534,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 </p><p></p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_510" href="#call_footnote_Temp_510" id="footnote_Temp_510"><sup><small>3</small></sup></a> Even so, there will remain important aspects of
+</p><div class="footnote"><p><a href="#call_footnote_Temp_510" id="footnote_Temp_510"><sup><small>3</small></sup></a> Even so, there will remain important aspects of
 the evaluation process that are not elucidated by our evaluator.  The
 most important of these are the detailed mechanisms by which
 procedures call other procedures and return values to their callers.
@@ -1542,8 +1542,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 at the evaluation process by implementing the evaluator as a simple
 register machine.
 
-</p><p><a name="footnote_Temp_511" href="#call_footnote_Temp_511" id="footnote_Temp_511"><sup><small>4</small></sup></a> If we grant ourselves the ability to apply primitives,
-<a name="%_idx_4222" id="%_idx_4222"></a>then what remains for us to implement in the evaluator?  The job of
+</p><p><a href="#call_footnote_Temp_511" id="footnote_Temp_511"><sup><small>4</small></sup></a> If we grant ourselves the ability to apply primitives,
+<a id="__idx_4222"></a>then what remains for us to implement in the evaluator?  The job of
 the evaluator is not to specify the primitives of the language, but rather
 to provide the connective tissue – the means of combination and the
 means of abstraction – that binds a collection of primitives to form a
@@ -1573,82 +1573,82 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 evaluated differently from procedure calls.
 </li></ul><p>
 
-</p><p><a name="footnote_Temp_518" href="#call_footnote_Temp_518" id="footnote_Temp_518"><sup><small>5</small></sup></a> We could have simplified the <tt>application?</tt> clause in <tt>eval</tt> by using <tt>map</tt>
+</p><p><a href="#call_footnote_Temp_518" id="footnote_Temp_518"><sup><small>5</small></sup></a> We could have simplified the <tt>application?</tt> clause in <tt>eval</tt> by using <tt>map</tt>
 (and stipulating that <tt>operands</tt> returns a list) rather than
 writing an explicit <tt>list-of-values</tt> procedure.  We chose not to
-use <tt>map</tt> here to emphasize the fact that the <a name="%_idx_4252" id="%_idx_4252"></a><a name="%_idx_4254" id="%_idx_4254"></a>evaluator can be
+use <tt>map</tt> here to emphasize the fact that the <a id="__idx_4252"></a><a id="__idx_4254"></a>evaluator can be
 implemented without any use of higher-order procedures
 (and thus could be written in a language that doesn't have
 higher-order procedures), even though
 the language that it supports will include higher-order procedures.
 
-</p><p><a name="footnote_Temp_520" href="#call_footnote_Temp_520" id="footnote_Temp_520"><sup><small>6</small></sup></a> In this case, the language being implemented and the
+</p><p><a href="#call_footnote_Temp_520" id="footnote_Temp_520"><sup><small>6</small></sup></a> In this case, the language being implemented and the
 implementation language are the same.  Contemplation of the meaning of
-<a name="%_idx_4262" id="%_idx_4262"></a><tt>true?</tt> here yields expansion of consciousness without the abuse
+<a id="__idx_4262"></a><tt>true?</tt> here yields expansion of consciousness without the abuse
 of substance.
 
-</p><p><a name="footnote_Temp_523" href="#call_footnote_Temp_523" id="footnote_Temp_523"><sup><small>7</small></sup></a> This implementation of <tt>define</tt> ignores a subtle
+</p><p><a href="#call_footnote_Temp_523" id="footnote_Temp_523"><sup><small>7</small></sup></a> This implementation of <tt>define</tt> ignores a subtle
 issue in the handling of internal definitions, although it works
 correctly in most cases.  We will see what the problem is and how to
-solve it in section <a href="#%_sec_4.1.6">4.1.6</a>.
+solve it in section <a href="#__sec_4.1.6">4.1.6</a>.
 
-</p><p><a name="footnote_Temp_524" href="#call_footnote_Temp_524" id="footnote_Temp_524"><sup><small>8</small></sup></a> As we said when we
+</p><p><a href="#call_footnote_Temp_524" id="footnote_Temp_524"><sup><small>8</small></sup></a> As we said when we
 introduced <tt>define</tt> and <tt>set!</tt>, these values
 are implementation-dependent in Scheme – that is, the implementor
 can choose what value to return.
 
-</p><p><a name="footnote_Temp_526" href="#call_footnote_Temp_526" id="footnote_Temp_526"><sup><small>9</small></sup></a> As mentioned in
-section <a href="book-Z-H-16.html#%_sec_2.3.1">2.3.1</a>, the evaluator sees a quoted expression as
+</p><p><a href="#call_footnote_Temp_526" id="footnote_Temp_526"><sup><small>9</small></sup></a> As mentioned in
+section <a href="book-Z-H-16.html#__sec_2.3.1">2.3.1</a>, the evaluator sees a quoted expression as
 a list beginning with <tt>quote</tt>, even if the
 expression is typed with the quotation mark.  For example, the
 expression <tt>'a</tt> would be seen by the evaluator as <tt>(quote a)</tt>.
-See exercise <a href="book-Z-H-16.html#%_thm_2.55">2.55</a>.
+See exercise <a href="book-Z-H-16.html#__thm_2.55">2.55</a>.
 
-</p><p><a name="footnote_Temp_527" href="#call_footnote_Temp_527" id="footnote_Temp_527"><sup><small>10</small></sup></a> The value of an <tt>if</tt> expression when the predicate
+</p><p><a href="#call_footnote_Temp_527" id="footnote_Temp_527"><sup><small>10</small></sup></a> The value of an <tt>if</tt> expression when the predicate
 is false and there is no alternative
 is unspecified in Scheme; we have chosen here to make it false.
 We will support the use of the variables <tt>true</tt> and <tt>false</tt>
 in expressions to be evaluated by binding them in the global
-environment.  See section <a href="#%_sec_4.1.4">4.1.4</a>.
+environment.  See section <a href="#__sec_4.1.4">4.1.4</a>.
 
 
-</p><p><a name="footnote_Temp_528" href="#call_footnote_Temp_528" id="footnote_Temp_528"><sup><small>11</small></sup></a> These selectors for a list of expressions – and the
+</p><p><a href="#call_footnote_Temp_528" id="footnote_Temp_528"><sup><small>11</small></sup></a> These selectors for a list of expressions – and the
 corresponding ones for a list of operands – are not intended as a data
 abstraction.  They are introduced as mnemonic names for the basic list
 operations in order to make it easier to understand the explicit-control
-evaluator in section <a href="book-Z-H-34.html#%_sec_5.4">5.4</a>.
+evaluator in section <a href="book-Z-H-34.html#__sec_5.4">5.4</a>.
 
-</p><p><a name="footnote_Temp_530" href="#call_footnote_Temp_530" id="footnote_Temp_530"><sup><small>12</small></sup></a> The value of a <tt>cond</tt> expression when all the predicates
+</p><p><a href="#call_footnote_Temp_530" id="footnote_Temp_530"><sup><small>12</small></sup></a> The value of a <tt>cond</tt> expression when all the predicates
 are false and there is no <tt>else</tt> clause
 is unspecified in Scheme; we have chosen here to make it false.
 
-</p><p><a name="footnote_Temp_531" href="#call_footnote_Temp_531" id="footnote_Temp_531"><sup><small>13</small></sup></a> Practical Lisp systems provide a
+</p><p><a href="#call_footnote_Temp_531" id="footnote_Temp_531"><sup><small>13</small></sup></a> Practical Lisp systems provide a
 mechanism that allows a user to add new derived expressions and
 specify their implementation as syntactic transformations without
 modifying the evaluator.  Such a user-defined transformation is called a
-<a name="%_idx_4374" id="%_idx_4374"></a><em>macro</em>.
+<a id="__idx_4374"></a><em>macro</em>.
 Although it is easy to add an elementary mechanism for defining macros,
 the resulting language has subtle name-conflict problems.
 There has been much research on mechanisms for macro definition
 that do not cause these difficulties.  See,
-<a name="%_idx_4376" id="%_idx_4376"></a><a name="%_idx_4378" id="%_idx_4378"></a><a name="%_idx_4380" id="%_idx_4380"></a><a name="%_idx_4382" id="%_idx_4382"></a>for example, Kohlbecker 1986, Clinger and Rees 1991, and Hanson 1991.
+<a id="__idx_4376"></a><a id="__idx_4378"></a><a id="__idx_4380"></a><a id="__idx_4382"></a>for example, Kohlbecker 1986, Clinger and Rees 1991, and Hanson 1991.
 
-</p><p><a name="footnote_Temp_544" href="#call_footnote_Temp_544" id="footnote_Temp_544"><sup><small>14</small></sup></a> Frames are not really a data abstraction in the following code:
+</p><p><a href="#call_footnote_Temp_544" id="footnote_Temp_544"><sup><small>14</small></sup></a> Frames are not really a data abstraction in the following code:
 <tt>Set-variable-value!</tt> and <tt>define-variable!</tt> use <tt>set-car!</tt>
 to directly modify the values in a frame.  The purpose of the frame
 procedures is to make the environment-manipulation procedures easy to read.
 
-</p><p><a name="footnote_Temp_545" href="#call_footnote_Temp_545" id="footnote_Temp_545"><sup><small>15</small></sup></a> The drawback of this representation (as well as the variant in
-exercise <a href="#%_thm_4.11">4.11</a>) is that the evaluator
+</p><p><a href="#call_footnote_Temp_545" id="footnote_Temp_545"><sup><small>15</small></sup></a> The drawback of this representation (as well as the variant in
+exercise <a href="#__thm_4.11">4.11</a>) is that the evaluator
 may have to search through many frames in order to find the binding
 for a given variable.
-<a name="%_idx_4488" id="%_idx_4488"></a><a name="%_idx_4490" id="%_idx_4490"></a>(Such an approach is referred to as <em>deep binding</em>.)
+<a id="__idx_4488"></a><a id="__idx_4490"></a>(Such an approach is referred to as <em>deep binding</em>.)
 One way to avoid
 this inefficiency is to make use of a strategy called <em>lexical
 addressing</em>, which will be discussed in
-section <a href="book-Z-H-35.html#%_sec_5.5.6">5.5.6</a>.
+section <a href="book-Z-H-35.html#__sec_5.5.6">5.5.6</a>.
 
-</p><p><a name="footnote_Temp_549" href="#call_footnote_Temp_549" id="footnote_Temp_549"><sup><small>16</small></sup></a> Any procedure defined in the underlying Lisp can be used as
+</p><p><a href="#call_footnote_Temp_549" id="footnote_Temp_549"><sup><small>16</small></sup></a> Any procedure defined in the underlying Lisp can be used as
 a primitive for the metacircular evaluator.  The name of a
 primitive installed in the evaluator need not be the same as the name
 of its implementation in the underlying Lisp; the names are the same
@@ -1656,8 +1656,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 Thus, for example, we could put <tt>(list 'first car)</tt> or <tt>(list
 'square (lambda (x) (* x x)))</tt> in the list of <tt>primitive-procedures</tt>.
 
-</p><p><a name="footnote_Temp_550" href="#call_footnote_Temp_550" id="footnote_Temp_550"><sup><small>17</small></sup></a> <tt>Apply-in-underlying-scheme</tt> is the <tt>apply</tt> procedure
-we have used in earlier chapters.  The metacircular evaluator's <tt>apply</tt> procedure (section <a href="#%_sec_4.1.1">4.1.1</a>) models the
+</p><p><a href="#call_footnote_Temp_550" id="footnote_Temp_550"><sup><small>17</small></sup></a> <tt>Apply-in-underlying-scheme</tt> is the <tt>apply</tt> procedure
+we have used in earlier chapters.  The metacircular evaluator's <tt>apply</tt> procedure (section <a href="#__sec_4.1.1">4.1.1</a>) models the
 working of this primitive.  Having two different things called <tt>apply</tt> leads to a technical problem in running the metacircular
 evaluator, because defining the metacircular evaluator's <tt>apply</tt>
 will mask the definition of the primitive.  One way around this is to
@@ -1668,15 +1668,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 before defining the metacircular <tt>apply</tt>.  This allows us to
 access the original version of <tt>apply</tt> under a different name.
 
-</p><p><a name="footnote_Temp_551" href="#call_footnote_Temp_551" id="footnote_Temp_551"><sup><small>18</small></sup></a> The primitive procedure <a name="%_idx_4522" id="%_idx_4522"></a><a name="%_idx_4524" id="%_idx_4524"></a><tt>read</tt> waits for input from the user,
+</p><p><a href="#call_footnote_Temp_551" id="footnote_Temp_551"><sup><small>18</small></sup></a> The primitive procedure <a id="__idx_4522"></a><a id="__idx_4524"></a><tt>read</tt> waits for input from the user,
 and returns the next complete expression that is typed.
 For example, if the user types <tt>(+ 23 x)</tt>, <tt>read</tt> returns
 a three-element list containing the symbol <tt>+</tt>, the number 23,
 and the symbol <tt>x</tt>.
-<a name="%_idx_4526" id="%_idx_4526"></a><a name="%_idx_4528" id="%_idx_4528"></a>If the user types <tt>'x</tt>, <tt>read</tt> returns a two-element list
+<a id="__idx_4526"></a><a id="__idx_4528"></a>If the user types <tt>'x</tt>, <tt>read</tt> returns a two-element list
 containing the symbol <tt>quote</tt> and the symbol <tt>x</tt>.
 
-</p><p><a name="footnote_Temp_553" href="#call_footnote_Temp_553" id="footnote_Temp_553"><sup><small>19</small></sup></a> The fact that the machines are described in Lisp is
+</p><p><a href="#call_footnote_Temp_553" id="footnote_Temp_553"><sup><small>19</small></sup></a> The fact that the machines are described in Lisp is
 inessential.  If we give our evaluator a Lisp program
 that behaves as an evaluator for
 some other language, say C, the Lisp evaluator will emulate the C
@@ -1686,59 +1686,59 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 any evaluator can emulate any other.  Thus, the notion of “what can
 in principle be computed” (ignoring practicalities of time and
 memory required) is independent of the language or the computer, and
-instead reflects an underlying notion of <a name="%_idx_4554" id="%_idx_4554"></a><em>computability</em>.  This
-was first demonstrated in a clear way by <a name="%_idx_4556" id="%_idx_4556"></a>Alan M. Turing (1912-1954),
-whose 1936 paper laid the foundations for theoretical <a name="%_idx_4558" id="%_idx_4558"></a>computer
+instead reflects an underlying notion of <a id="__idx_4554"></a><em>computability</em>.  This
+was first demonstrated in a clear way by <a id="__idx_4556"></a>Alan M. Turing (1912-1954),
+whose 1936 paper laid the foundations for theoretical <a id="__idx_4558"></a>computer
 science.  In the paper, Turing presented a simple computational
-model – now known as a <a name="%_idx_4560" id="%_idx_4560"></a><em>Turing machine</em> – and argued that any
+model – now known as a <a id="__idx_4560"></a><em>Turing machine</em> – and argued that any
 “effective process” can be formulated as a program for such a
-machine.  (This argument is known as the <a name="%_idx_4562" id="%_idx_4562"></a><em>Church-Turing thesis</em>.)
+machine.  (This argument is known as the <a id="__idx_4562"></a><em>Church-Turing thesis</em>.)
 Turing then implemented a universal machine, i.e., a Turing machine
 that behaves as an evaluator for Turing-machine programs.  He used
 this framework to demonstrate that there are well-posed problems that
 cannot be computed by Turing machines (see
-exercise <a href="#%_thm_4.15">4.15</a>), and so by implication cannot be
+exercise <a href="#__thm_4.15">4.15</a>), and so by implication cannot be
 formulated as “effective processes.”  Turing went on to make
 fundamental contributions to practical computer science as well.  For
-example, he invented the idea of <a name="%_idx_4564" id="%_idx_4564"></a>structuring programs using
-general-purpose subroutines.  See <a name="%_idx_4566" id="%_idx_4566"></a>Hodges 1983 for a biography of
+example, he invented the idea of <a id="__idx_4564"></a>structuring programs using
+general-purpose subroutines.  See <a id="__idx_4566"></a>Hodges 1983 for a biography of
 Turing.
 
-</p><p><a name="footnote_Temp_554" href="#call_footnote_Temp_554" id="footnote_Temp_554"><sup><small>20</small></sup></a> Some people find it
+</p><p><a href="#call_footnote_Temp_554" id="footnote_Temp_554"><sup><small>20</small></sup></a> Some people find it
 counterintuitive that an evaluator, which is implemented by a
 relatively simple procedure, can emulate programs that are more
 complex than the evaluator itself.  The existence of a universal
 evaluator machine is a deep and wonderful property of computation.
-<a name="%_idx_4568" id="%_idx_4568"></a><em>Recursion theory</em>, a branch of mathematical logic, is concerned
-with logical limits of computation.  <a name="%_idx_4570" id="%_idx_4570"></a>Douglas Hofstadter's beautiful
+<a id="__idx_4568"></a><em>Recursion theory</em>, a branch of mathematical logic, is concerned
+with logical limits of computation.  <a id="__idx_4570"></a>Douglas Hofstadter's beautiful
 book <em>Gödel, Escher, Bach</em> (1979) explores some of these ideas.
 
-</p><p><a name="footnote_Temp_555" href="#call_footnote_Temp_555" id="footnote_Temp_555"><sup><small>21</small></sup></a> Warning:
-<a name="%_idx_4576" id="%_idx_4576"></a>This <tt>eval</tt> primitive is not
+</p><p><a href="#call_footnote_Temp_555" id="footnote_Temp_555"><sup><small>21</small></sup></a> Warning:
+<a id="__idx_4576"></a>This <tt>eval</tt> primitive is not
 identical to the <tt>eval</tt> procedure we implemented in
-section <a href="#%_sec_4.1.1">4.1.1</a>, because it uses <em>actual</em>
+section <a href="#__sec_4.1.1">4.1.1</a>, because it uses <em>actual</em>
 Scheme environments rather than the sample environment structures we
-built in section <a href="#%_sec_4.1.3">4.1.3</a>.  These actual
+built in section <a href="#__sec_4.1.3">4.1.3</a>.  These actual
 environments cannot be manipulated by the user as ordinary lists; they
 must be accessed via <tt>eval</tt> or other special operations.
-<a name="%_idx_4578" id="%_idx_4578"></a>Similarly, the <tt>apply</tt> primitive we saw earlier is not identical
+<a id="__idx_4578"></a>Similarly, the <tt>apply</tt> primitive we saw earlier is not identical
 to the metacircular <tt>apply</tt>, because it uses actual Scheme procedures
 rather than the procedure objects we constructed in
-sections <a href="#%_sec_4.1.3">4.1.3</a> and <a href="#%_sec_4.1.4">4.1.4</a>.
+sections <a href="#__sec_4.1.3">4.1.3</a> and <a href="#__sec_4.1.4">4.1.4</a>.
 
-</p><p><a name="footnote_Temp_556" href="#call_footnote_Temp_556" id="footnote_Temp_556"><sup><small>22</small></sup></a> The MIT
-<a name="%_idx_4580" id="%_idx_4580"></a><a name="%_idx_4582" id="%_idx_4582"></a><a name="%_idx_4584" id="%_idx_4584"></a><a name="%_idx_4586" id="%_idx_4586"></a>implementation of Scheme includes <tt>eval</tt>, as well as a symbol <tt>user-initial-environment</tt> that is bound to the initial environment in
+</p><p><a href="#call_footnote_Temp_556" id="footnote_Temp_556"><sup><small>22</small></sup></a> The MIT
+<a id="__idx_4580"></a><a id="__idx_4582"></a><a id="__idx_4584"></a><a id="__idx_4586"></a>implementation of Scheme includes <tt>eval</tt>, as well as a symbol <tt>user-initial-environment</tt> that is bound to the initial environment in
 which the user's input expressions are evaluated.
 
-</p><p><a name="footnote_Temp_558" href="#call_footnote_Temp_558" id="footnote_Temp_558"><sup><small>23</small></sup></a> Although we stipulated that <tt>halts?</tt> is given a procedure object,
+</p><p><a href="#call_footnote_Temp_558" id="footnote_Temp_558"><sup><small>23</small></sup></a> Although we stipulated that <tt>halts?</tt> is given a procedure object,
 notice that this reasoning still applies even if <tt>halts?</tt> can gain
 access to the procedure's text and its environment.
-<a name="%_idx_4590" id="%_idx_4590"></a><a name="%_idx_4592" id="%_idx_4592"></a><a name="%_idx_4594" id="%_idx_4594"></a><a name="%_idx_4596" id="%_idx_4596"></a>This is Turing's celebrated <em>Halting Theorem</em>, which gave
+<a id="__idx_4590"></a><a id="__idx_4592"></a><a id="__idx_4594"></a><a id="__idx_4596"></a>This is Turing's celebrated <em>Halting Theorem</em>, which gave
 the first clear example of a <em>non-computable</em> problem, i.e., a
 well-posed task that cannot be carried out as a computational
 procedure.
 
-</p><p><a name="footnote_Temp_559" href="#call_footnote_Temp_559" id="footnote_Temp_559"><sup><small>24</small></sup></a> Wanting programs to not depend on this evaluation
+</p><p><a href="#call_footnote_Temp_559" id="footnote_Temp_559"><sup><small>24</small></sup></a> Wanting programs to not depend on this evaluation
 mechanism is the reason for the “management is not
 responsible” remark in footnote <a href="book-Z-H-10.html#footnote_Temp_45">28</a> of chapter 1.
 By insisting that internal definitions come first and do not use each
@@ -1747,18 +1747,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 evaluate these definitions.  The choice of one evaluation rule rather
 than another here may seem like a small issue, affecting only the
 interpretation of “badly formed” programs.  However, we will see in
-section <a href="book-Z-H-35.html#%_sec_5.5.6">5.5.6</a> that moving to a model of
+section <a href="book-Z-H-35.html#__sec_5.5.6">5.5.6</a> that moving to a model of
 simultaneous scoping for internal definitions avoids some nasty
 difficulties that would otherwise arise in implementing a compiler.
 
-</p><p><a name="footnote_Temp_560" href="#call_footnote_Temp_560" id="footnote_Temp_560"><sup><small>25</small></sup></a> The IEEE standard for Scheme
+</p><p><a href="#call_footnote_Temp_560" id="footnote_Temp_560"><sup><small>25</small></sup></a> The IEEE standard for Scheme
 allows for different implementation strategies by specifying that it
 is up to the programmer to obey this restriction, not up to the
 implementation to enforce it.  Some Scheme implementations, including
-<a name="%_idx_4610" id="%_idx_4610"></a>MIT Scheme, use the transformation shown above.  Thus, some programs
+<a id="__idx_4610"></a>MIT Scheme, use the transformation shown above.  Thus, some programs
 that don't obey this restriction will in fact run in such implementations.
 
-</p><p><a name="footnote_Temp_565" href="#call_footnote_Temp_565" id="footnote_Temp_565"><sup><small>26</small></sup></a> The MIT implementors of Scheme support Alyssa on
+</p><p><a href="#call_footnote_Temp_565" id="footnote_Temp_565"><sup><small>26</small></sup></a> The MIT implementors of Scheme support Alyssa on
 the following grounds: Eva is in principle correct – the definitions
 should be regarded as simultaneous.  But it seems difficult to
 implement a general, efficient mechanism that does what Eva requires.
@@ -1766,29 +1766,29 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.1">4.1  The Metacircular Evaluator<
 in the difficult cases of simultaneous definitions (Alyssa's notion)
 than to produce an incorrect answer (as Ben would have it).
 
-</p><p><a name="footnote_Temp_568" href="#call_footnote_Temp_568" id="footnote_Temp_568"><sup><small>27</small></sup></a> This example illustrates a programming trick for
+</p><p><a href="#call_footnote_Temp_568" id="footnote_Temp_568"><sup><small>27</small></sup></a> This example illustrates a programming trick for
 formulating recursive procedures without using <tt>define</tt>.  The
-<a name="%_idx_4628" id="%_idx_4628"></a>most general trick of this sort is the <em>Y</em> <em>operator</em>, which can
+<a id="__idx_4628"></a>most general trick of this sort is the <em>Y</em> <em>operator</em>, which can
 be used to give a “pure λ-calculus” implementation of
-<a name="%_idx_4630" id="%_idx_4630"></a><a name="%_idx_4632" id="%_idx_4632"></a>recursion.  (See Stoy 1977 for details on the lambda calculus, and
+<a id="__idx_4630"></a><a id="__idx_4632"></a>recursion.  (See Stoy 1977 for details on the lambda calculus, and
 Gabriel 1988 for an exposition of the <em>Y</em> operator in Scheme.)
 
-</p><p><a name="footnote_Temp_569" href="#call_footnote_Temp_569" id="footnote_Temp_569"><sup><small>28</small></sup></a> This technique is an integral part of the compilation
+</p><p><a href="#call_footnote_Temp_569" id="footnote_Temp_569"><sup><small>28</small></sup></a> This technique is an integral part of the compilation
 process, which we shall discuss in chapter 5.  Jonathan Rees wrote a Scheme
-<a name="%_idx_4644" id="%_idx_4644"></a><a name="%_idx_4646" id="%_idx_4646"></a><a name="%_idx_4648" id="%_idx_4648"></a><a name="%_idx_4650" id="%_idx_4650"></a>interpreter like this in about 1982 for the T project (Rees and Adams
+<a id="__idx_4644"></a><a id="__idx_4646"></a><a id="__idx_4648"></a><a id="__idx_4650"></a>interpreter like this in about 1982 for the T project (Rees and Adams
 1982).  Marc Feeley (1986) (see also Feeley and Lapalme 1987)
 independently invented this technique
 in his master's thesis.
 
-</p><p><a name="footnote_Temp_570" href="#call_footnote_Temp_570" id="footnote_Temp_570"><sup><small>29</small></sup></a> There is,
+</p><p><a href="#call_footnote_Temp_570" id="footnote_Temp_570"><sup><small>29</small></sup></a> There is,
 however, an important part of the variable search that <em>can</em> be
 done as part of the syntactic analysis.  As we will show in
-section <a href="book-Z-H-35.html#%_sec_5.5.6">5.5.6</a>, one can determine the position
+section <a href="book-Z-H-35.html#__sec_5.5.6">5.5.6</a>, one can determine the position
 in the environment structure where the value of the variable will be
 found, thus obviating the need to scan the environment for the entry
 that matches the variable.
 
-</p><p><a name="footnote_Temp_571" href="#call_footnote_Temp_571" id="footnote_Temp_571"><sup><small>30</small></sup></a> See exercise <a href="#%_thm_4.23">4.23</a> for some insight
+</p><p><a href="#call_footnote_Temp_571" id="footnote_Temp_571"><sup><small>30</small></sup></a> See exercise <a href="#__thm_4.23">4.23</a> for some insight
 into the processing of sequences.
 
 </p></div>
diff --git a/src/OEBPS/book-Z-H-27.html b/src/OEBPS/book-Z-H-27.html
index d893585..e318b4d 100644
--- a/src/OEBPS/book-Z-H-27.html
+++ b/src/OEBPS/book-Z-H-27.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,12 +13,12 @@
 
 
 
-<a name="%_sec_4.2" id="%_sec_4.2"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme – Lazy Evaluation</a></h2><p>
+<a id="__sec_4.2"></a>
+<h2>4.2  Variations on a Scheme – Lazy Evaluation</h2><p>
 
 
-<a name="%_idx_4666" id="%_idx_4666"></a><a name="%_idx_4668" id="%_idx_4668"></a>
-<a name="%_idx_4670" id="%_idx_4670"></a><a name="%_idx_4672" id="%_idx_4672"></a>Now that we have an evaluator expressed as a Lisp program, we can
+<a id="__idx_4666"></a><a id="__idx_4668"></a>
+<a id="__idx_4670"></a><a id="__idx_4672"></a>Now that we have an evaluator expressed as a Lisp program, we can
 experiment with alternative choices in language design simply by
 modifying the evaluator.  Indeed, new languages are often invented by
 first writing an evaluator that embeds the new language within an
@@ -29,7 +29,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 evaluator and send back comments as further modifications.  Not only
 does the high-level implementation base make it easier to test and
 debug the evaluator; in addition, the embedding enables the designer
-to snarf<a name="call_footnote_Temp_575" href="#footnote_Temp_575" id="call_footnote_Temp_575"><sup><small>31</small></sup></a> features
+to snarf<a href="#footnote_Temp_575" id="call_footnote_Temp_575"><sup><small>31</small></sup></a> features
 from the underlying language, just as our embedded Lisp evaluator
 uses primitives and control structure from the underlying Lisp.  Only
 later (if ever) need the designer go to the trouble of building a
@@ -37,19 +37,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 this section and the next we explore some variations on Scheme that
 provide significant additional expressive power.</p><p>
 
-<a name="%_sec_4.2.1" id="%_sec_4.2.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_4.2.1">4.2.1  Normal Order and Applicative Order</a></h3><p>
+<a id="__sec_4.2.1"></a>
+</p><h3>4.2.1  Normal Order and Applicative Order</h3><p>
 
 </p><p>
 
-<a name="%_idx_4680" id="%_idx_4680"></a><a name="%_idx_4682" id="%_idx_4682"></a>In section <a href="book-Z-H-10.html#%_sec_1.1">1.1</a>, where we began our discussion
+<a id="__idx_4680"></a><a id="__idx_4682"></a>In section <a href="book-Z-H-10.html#__sec_1.1">1.1</a>, where we began our discussion
 of models of evaluation, we noted that Scheme is an <em>applicative-order</em> language, namely, that all the arguments to Scheme
 procedures are evaluated when the procedure is applied.  In
 contrast, <em>normal-order</em> languages delay evaluation of procedure arguments
 until the actual argument values are needed.
 Delaying evaluation of procedure arguments until the
 last possible moment (e.g., until they are required by a primitive
-operation) is called <a name="%_idx_4684" id="%_idx_4684"></a><em>lazy evaluation</em>.<a name="call_footnote_Temp_576" href="#footnote_Temp_576" id="call_footnote_Temp_576"><sup><small>32</small></sup></a>
+operation) is called <a id="__idx_4684"></a><em>lazy evaluation</em>.<a href="#footnote_Temp_576" id="call_footnote_Temp_576"><sup><small>32</small></sup></a>
 Consider the procedure</p><p>
 
 </p><p></p><p><tt>(define (try a b)<br />
@@ -72,20 +72,20 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
                0))<br /></tt></p><p></p><p>
 This won't work in an applicative-order language because both the
 usual value and the exceptional value will be evaluated before
-<tt>unless</tt> is called (compare exercise <a href="book-Z-H-10.html#%_thm_1.6">1.6</a>).  An
+<tt>unless</tt> is called (compare exercise <a href="book-Z-H-10.html#__thm_1.6">1.6</a>).  An
 advantage of lazy evaluation is that some procedures, such as <tt>unless</tt>, can do useful computation even if evaluation of some of their
 arguments would produce errors or would not terminate.</p><p>
 
 If the body of a procedure is entered before an argument has been
-evaluated we say that the procedure is <a name="%_idx_4686" id="%_idx_4686"></a><em>non-strict</em> in that
+evaluated we say that the procedure is <a id="__idx_4686"></a><em>non-strict</em> in that
 argument.  If the argument is evaluated before the body of the
-procedure is entered we say that the procedure is <a name="%_idx_4688" id="%_idx_4688"></a><em>strict</em> in that
-argument.<a name="call_footnote_Temp_577" href="#footnote_Temp_577" id="call_footnote_Temp_577"><sup><small>33</small></sup></a>
+procedure is entered we say that the procedure is <a id="__idx_4688"></a><em>strict</em> in that
+argument.<a href="#footnote_Temp_577" id="call_footnote_Temp_577"><sup><small>33</small></sup></a>
 In a purely applicative-order language, all procedures are strict in
 each argument.  In a purely normal-order language, all compound
 procedures are non-strict in each argument, and primitive procedures may be
 either strict or non-strict.  There are also languages (see
-exercise <a href="#%_thm_4.31">4.31</a>) that give programmers
+exercise <a href="#__thm_4.31">4.31</a>) that give programmers
 detailed control over the strictness of the procedures they define.</p><p>
 
 A striking example of a procedure that can usefully be made non-strict
@@ -95,11 +95,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 even if the values of the elements are not known.  It makes perfect
 sense, for instance, to compute the length of a list without knowing
 the values of the individual elements in the list.  We will exploit
-this idea in section <a href="#%_sec_4.2.3">4.2.3</a> to implement the
+this idea in section <a href="#__sec_4.2.3">4.2.3</a> to implement the
 streams of chapter 3 as lists formed of non-strict <tt>cons</tt>
 pairs.</p><p>
 
-</p><p><a name="%_thm_4.25" id="%_thm_4.25"></a>
+</p><p><a id="__thm_4.25"></a>
 <b>Exercise 4.25.</b>  Suppose that (in ordinary applicative-order Scheme) we define <tt>unless</tt>
 as shown above and then define <tt>factorial</tt> in terms of <tt>unless</tt> as</p><p>
 
@@ -111,8 +111,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 definitions work in a normal-order language?
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.26" id="%_thm_4.26"></a>
-<b>Exercise 4.26.</b>  <a name="%_idx_4692" id="%_idx_4692"></a><a name="%_idx_4694" id="%_idx_4694"></a>Ben Bitdiddle and Alyssa P. Hacker disagree over the importance of
+</p><p><a id="__thm_4.26"></a>
+<b>Exercise 4.26.</b>  <a id="__idx_4692"></a><a id="__idx_4694"></a>Ben Bitdiddle and Alyssa P. Hacker disagree over the importance of
 lazy evaluation for implementing things such as <tt>unless</tt>.  Ben
 points out that it's possible to implement <tt>unless</tt> in applicative
 order as a special form.
@@ -126,14 +126,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 
 </p><p></p><p>
 
-<a name="%_sec_4.2.2" id="%_sec_4.2.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_4.2.2">4.2.2  An Interpreter with Lazy Evaluation</a></h3><p>
+<a id="__sec_4.2.2"></a>
+</p><h3>4.2.2  An Interpreter with Lazy Evaluation</h3><p>
 
 In this section we will implement a normal-order language that is
 the same as Scheme except that compound procedures are non-strict
 in each argument.  Primitive procedures will still be strict.
 It is not difficult to modify the evaluator of
-section <a href="book-Z-H-26.html#%_sec_4.1.1">4.1.1</a> so that the language it interprets behaves
+section <a href="book-Z-H-26.html#__sec_4.1.1">4.1.1</a> so that the language it interprets behaves
 this way.  Almost all the required changes center around procedure
 application.</p><p>
 
@@ -141,42 +141,42 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 must determine which arguments are to be
 evaluated and which are to be
 delayed.  The delayed arguments are not
-evaluated; instead, they are transformed into objects called <a name="%_idx_4696" id="%_idx_4696"></a><em>thunk</em>s.<a name="call_footnote_Temp_580" href="#footnote_Temp_580" id="call_footnote_Temp_580"><sup><small>34</small></sup></a>
+evaluated; instead, they are transformed into objects called <a id="__idx_4696"></a><em>thunk</em>s.<a href="#footnote_Temp_580" id="call_footnote_Temp_580"><sup><small>34</small></sup></a>
 The thunk must contain the information required to produce the value
 of the argument when it is needed, as if it had been evaluated at
 the time of the application.  Thus, the thunk must contain the
 argument expression and the environment in
 which the procedure application is being evaluated.</p><p>
 
-<a name="%_idx_4704" id="%_idx_4704"></a><a name="%_idx_4706" id="%_idx_4706"></a>The process of evaluating the expression in a thunk is called <em>forcing</em>.<a name="call_footnote_Temp_581" href="#footnote_Temp_581" id="call_footnote_Temp_581"><sup><small>35</small></sup></a>
+<a id="__idx_4704"></a><a id="__idx_4706"></a>The process of evaluating the expression in a thunk is called <em>forcing</em>.<a href="#footnote_Temp_581" id="call_footnote_Temp_581"><sup><small>35</small></sup></a>
 In general, a thunk will be forced only when its value is needed:
 when it is passed to a primitive procedure that
 will use the value of the thunk; when it is the
 value of a predicate of a conditional; and when it
 is the value of an operator that is about to be applied as a procedure.
-One design choice we have available is whether or not to <a name="%_idx_4710" id="%_idx_4710"></a><em>memoize</em> thunks, as we did with delayed objects in
-section <a href="book-Z-H-24.html#%_sec_3.5.1">3.5.1</a>.  With memoization, the first time a
+One design choice we have available is whether or not to <a id="__idx_4710"></a><em>memoize</em> thunks, as we did with delayed objects in
+section <a href="book-Z-H-24.html#__sec_3.5.1">3.5.1</a>.  With memoization, the first time a
 thunk is forced, it stores the value that is computed.  Subsequent
 forcings simply return the stored value without repeating the
 computation.  We'll make our interpreter memoize, because this is
 more efficient for many applications.  There are tricky
-considerations here, however.<a name="call_footnote_Temp_582" href="#footnote_Temp_582" id="call_footnote_Temp_582"><sup><small>36</small></sup></a></p><p>
+considerations here, however.<a href="#footnote_Temp_582" id="call_footnote_Temp_582"><sup><small>36</small></sup></a></p><p>
 
-<a name="%_sec_Temp_583" id="%_sec_Temp_583"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_583">Modifying the evaluator</a></h4><p>
+<a id="__sec_Temp_583"></a>
+</p><h4>Modifying the evaluator</h4><p>
 
 The main difference between the lazy evaluator and the one in
-section <a href="book-Z-H-26.html#%_sec_4.1">4.1</a> is in the handling of procedure
+section <a href="book-Z-H-26.html#__sec_4.1">4.1</a> is in the handling of procedure
 applications in <tt>eval</tt> and <tt>apply</tt>.</p><p>
 
-<a name="%_idx_4720" id="%_idx_4720"></a>The <tt>application?</tt> clause of <tt>eval</tt> becomes</p><p>
+<a id="__idx_4720"></a>The <tt>application?</tt> clause of <tt>eval</tt> becomes</p><p>
 
 </p><p></p><p><tt>((application? exp)<br />
  (apply (actual-value (operator exp) env)<br />
         (operands exp)<br />
         env))<br /></tt></p><p></p><p>
 This is almost the same as the <tt>application?</tt> clause of <tt>eval</tt>
-in section <a href="book-Z-H-26.html#%_sec_4.1.1">4.1.1</a>.  For lazy evaluation, however,
+in section <a href="book-Z-H-26.html#__sec_4.1.1">4.1.1</a>.  For lazy evaluation, however,
 we call <tt>apply</tt> with the operand expressions, rather than the
 arguments produced by evaluating them.  Since we will need the environment to
 construct thunks if the arguments are to be delayed, we must pass this as well.
@@ -185,20 +185,20 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 in order to dispatch on its type (primitive versus compound) and apply it.</p><p>
 
 Whenever we need the actual value of an expression, we use
-</p><p></p><p><tt><a name="%_idx_4722" id="%_idx_4722"></a>(define (actual-value exp env)<br />
+</p><p></p><p><tt><a id="__idx_4722"></a>(define (actual-value exp env)<br />
   (force-it (eval exp env)))<br /></tt></p><p></p><p>
 instead of just <tt>eval</tt>, so that if the expression's value
 is a thunk, it will be forced.</p><p>
 
 Our new version of <tt>apply</tt> is also almost the same as the
-version in section <a href="book-Z-H-26.html#%_sec_4.1.1">4.1.1</a>.  The difference is
+version in section <a href="book-Z-H-26.html#__sec_4.1.1">4.1.1</a>.  The difference is
 that <tt>eval</tt> has passed in unevaluated operand expressions:
 For primitive procedures (which are strict), we evaluate all the
 arguments before applying the primitive;
 for compound procedures (which are non-strict) we delay all the
 arguments before applying the procedure.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4724" id="%_idx_4724"></a>(define (apply procedure arguments env)<br />
+</p><p></p><p><tt><a id="__idx_4724"></a>(define (apply procedure arguments env)<br />
   (cond ((primitive-procedure? procedure)<br />
          (apply-primitive-procedure<br />
           procedure<br />
@@ -213,17 +213,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
         (else<br />
          (error<br />
           "Unknown procedure type -- APPLY" procedure))))<br /></tt></p><p></p><p>
-The procedures that process the arguments are just like <tt>list-of-values</tt> from section <a href="book-Z-H-26.html#%_sec_4.1.1">4.1.1</a>, except that
+The procedures that process the arguments are just like <tt>list-of-values</tt> from section <a href="book-Z-H-26.html#__sec_4.1.1">4.1.1</a>, except that
 <tt>list-of-delayed-args</tt> delays the arguments instead of evaluating
 them, and <tt>list-of-arg-values</tt> uses <tt>actual-value</tt> instead
 of <tt>eval</tt>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4726" id="%_idx_4726"></a>(define (list-of-arg-values exps env)<br />
+</p><p></p><p><tt><a id="__idx_4726"></a>(define (list-of-arg-values exps env)<br />
   (if (no-operands? exps)<br />
       '()<br />
       (cons (actual-value (first-operand exps) env)<br />
             (list-of-arg-values (rest-operands exps)<br />
-                                env))))<br /><a name="%_idx_4728" id="%_idx_4728"></a>(define (list-of-delayed-args exps env)<br />
+                                env))))<br /><a id="__idx_4728"></a>(define (list-of-delayed-args exps env)<br />
   (if (no-operands? exps)<br />
       '()<br />
       (cons (delay-it (first-operand exps) env)<br />
@@ -235,20 +235,20 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 of <tt>eval</tt> to get the value of the predicate expression
 before testing whether it is true or false:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4730" id="%_idx_4730"></a>(define (eval-if exp env)<br />
+</p><p></p><p><tt><a id="__idx_4730"></a>(define (eval-if exp env)<br />
   (if (true? (actual-value (if-predicate exp) env))<br />
       (eval (if-consequent exp) env)<br />
       (eval (if-alternative exp) env)))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_4732" id="%_idx_4732"></a>Finally, we must change the <tt>driver-loop</tt>
-procedure (section <a href="book-Z-H-26.html#%_sec_4.1.4">4.1.4</a>) to use <tt>actual-value</tt> instead
+<a id="__idx_4732"></a>Finally, we must change the <tt>driver-loop</tt>
+procedure (section <a href="book-Z-H-26.html#__sec_4.1.4">4.1.4</a>) to use <tt>actual-value</tt> instead
 of <tt>eval</tt>, so that if a delayed value
 is propagated back to the read-eval-print loop, it will be forced
 before being printed.  We also change the prompts to indicate that
 this is the lazy evaluator:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4734" id="%_idx_4734"></a>(define input-prompt ";;; L-Eval input:")<br />
-(define output-prompt ";;; L-Eval value:")<br /><a name="%_idx_4736" id="%_idx_4736"></a>(define (driver-loop)<br />
+</p><p></p><p><tt><a id="__idx_4734"></a>(define input-prompt ";;; L-Eval input:")<br />
+(define output-prompt ";;; L-Eval value:")<br /><a id="__idx_4736"></a>(define (driver-loop)<br />
   (prompt-for-input input-prompt)<br />
   (let ((input (read)))<br />
     (let ((output<br />
@@ -259,7 +259,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 
 With these changes made, we can start the evaluator and test it.  The
 successful evaluation of the <tt>try</tt> expression discussed in
-section <a href="#%_sec_4.2.1">4.2.1</a> indicates that the interpreter is
+section <a href="#__sec_4.2.1">4.2.1</a> indicates that the interpreter is
 performing lazy evaluation:</p><p>
 
 </p><p></p><p><tt>(define the-global-environment (setup-environment))<br />
@@ -269,10 +269,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 (try 0 (/ 1 0))<br /><i>;;; L-Eval value:</i><br /><i>1</i><br /></tt></p><p></p><p></p><p>
 
 
-<a name="%_sec_Temp_584" id="%_sec_Temp_584"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_584">Representing thunks</a></h4><p>
+<a id="__sec_Temp_584"></a>
+</p><h4>Representing thunks</h4><p>
 
-<a name="%_idx_4738" id="%_idx_4738"></a>
+<a id="__idx_4738"></a>
 Our evaluator must arrange to create thunks when procedures are
 applied to arguments and to force these thunks later.  A thunk must
 package an expression together with the environment, so that the
@@ -283,7 +283,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 value of the expression is itself a thunk, we will force that, and so
 on, until we reach something that is not a thunk:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4740" id="%_idx_4740"></a>(define (force-it obj)<br />
+</p><p></p><p><tt><a id="__idx_4740"></a>(define (force-it obj)<br />
   (if (thunk? obj)<br />
       (actual-value (thunk-exp obj) (thunk-env obj))<br />
       obj))<br /></tt></p><p></p><p></p><p>
@@ -292,7 +292,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 list containing the expression and the environment.
 Thus, we create a thunk as follows:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4742" id="%_idx_4742"></a>(define (delay-it exp env)<br />
+</p><p></p><p><tt><a id="__idx_4742"></a>(define (delay-it exp env)<br />
   (list 'thunk exp env))<br /><br />
 (define (thunk? obj)<br />
   (tagged-list? obj 'thunk))<br /><br />
@@ -304,11 +304,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 When a thunk is forced, we will turn it into an evaluated thunk
 by replacing the stored expression with its value and
 changing the <tt>thunk</tt> tag so that it can be recognized as
-already evaluated.<a name="call_footnote_Temp_585" href="#footnote_Temp_585" id="call_footnote_Temp_585"><sup><small>37</small></sup></a></p><p>
+already evaluated.<a href="#footnote_Temp_585" id="call_footnote_Temp_585"><sup><small>37</small></sup></a></p><p>
 
 </p><p></p><p><tt>(define (evaluated-thunk? obj)<br />
   (tagged-list? obj 'evaluated-thunk))<br /><br />
-(define (thunk-value evaluated-thunk) (cadr evaluated-thunk))<br /><a name="%_idx_4748" id="%_idx_4748"></a>(define (force-it obj)<br />
+(define (thunk-value evaluated-thunk) (cadr evaluated-thunk))<br /><a id="__idx_4748"></a>(define (force-it obj)<br />
   (cond ((thunk? obj)<br />
          (let ((result (actual-value<br />
                         (thunk-exp obj)<br />
@@ -323,14 +323,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 Notice that the same <tt>delay-it</tt> procedure works both with and
 without memoization.</p><p>
 
-</p><p><a name="%_thm_4.27" id="%_thm_4.27"></a>
+</p><p><a id="__thm_4.27"></a>
 <b>Exercise 4.27.</b>  Suppose we type in the following definitions to the lazy evaluator:
 </p><p></p><p><tt>(define count 0)<br />
 (define (id x)<br />
   (set! count (+ count 1))<br />
   x)<br /></tt></p><p></p><p>
 Give the missing values in the following sequence of
-interactions, and explain your answers.<a name="call_footnote_Temp_587" href="#footnote_Temp_587" id="call_footnote_Temp_587"><sup><small>38</small></sup></a>
+interactions, and explain your answers.<a href="#footnote_Temp_587" id="call_footnote_Temp_587"><sup><small>38</small></sup></a>
 </p><p></p><p><tt>(define w (id (id 10)))<br /><i>;;; L-Eval input:</i><br />
 count<br /><i>;;; L-Eval value:</i><br />
 &lt;<em>response</em>&gt;<br /><i>;;; L-Eval input:</i><br />
@@ -340,18 +340,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 &lt;<em>response</em>&gt;<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.28" id="%_thm_4.28"></a>
+</p><p><a id="__thm_4.28"></a>
 <b>Exercise 4.28.</b>  <tt>Eval</tt> uses <tt>actual-value</tt> rather than <tt>eval</tt>
 to evaluate the operator before passing it to <tt>apply</tt>,
 in order to force the value of the operator.
 Give an example that demonstrates the need for this forcing.
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.29" id="%_thm_4.29"></a>
+</p><p><a id="__thm_4.29"></a>
 <b>Exercise 4.29.</b>  Exhibit a program that you would expect to run much more slowly
 without memoization than with memoization.  Also, consider the
 following interaction, where the <tt>id</tt> procedure is defined as in
-exercise <a href="#%_thm_4.27">4.27</a> and <tt>count</tt> starts at 0:
+exercise <a href="#__thm_4.27">4.27</a> and <tt>count</tt> starts at 0:
 </p><p></p><p><tt>(define (square x)<br />
   (* x x))<br /><i>;;; L-Eval input:</i><br />
 (square (id 10))<br /><i>;;; L-Eval value:</i><br />
@@ -362,7 +362,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.30" id="%_thm_4.30"></a>
+</p><p><a id="__thm_4.30"></a>
 <b>Exercise 4.30.</b>  Cy D. Fect, a reformed C programmer, is worried that some side effects
 may never take place, because the lazy evaluator doesn't force the
 expressions in a sequence.
@@ -373,7 +373,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 will cause it to be forced.  Cy thus thinks that when evaluating
 sequences, we must force all expressions in the sequence except the
 final one.  He proposes to modify <tt>eval-sequence</tt> from
-section <a href="book-Z-H-26.html#%_sec_4.1.1">4.1.1</a> to use <tt>actual-value</tt> rather
+section <a href="book-Z-H-26.html#__sec_4.1.1">4.1.1</a> to use <tt>actual-value</tt> rather
 than <tt>eval</tt>:</p><p>
 
 </p><p></p><p><tt>(define (eval-sequence exps env)<br />
@@ -383,10 +383,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 
 </p><p></p><p>a. Ben Bitdiddle thinks Cy is wrong.
 He shows Cy the <tt>for-each</tt> procedure described in
-exercise <a href="book-Z-H-15.html#%_thm_2.23">2.23</a>, which gives an important example of
+exercise <a href="book-Z-H-15.html#__thm_2.23">2.23</a>, which gives an important example of
 a sequence with side effects:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4750" id="%_idx_4750"></a>(define (for-each proc items)<br />
+</p><p></p><p><tt><a id="__idx_4750"></a>(define (for-each proc items)<br />
   (if (null? items)<br />
       'done<br />
       (begin (proc (car items))<br />
@@ -424,8 +424,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.31" id="%_thm_4.31"></a>
-<b>Exercise 4.31.</b>  <a name="%_idx_4752" id="%_idx_4752"></a>The approach taken in this section is somewhat unpleasant, because it
+</p><p><a id="__thm_4.31"></a>
+<b>Exercise 4.31.</b>  <a id="__idx_4752"></a>The approach taken in this section is somewhat unpleasant, because it
 makes an incompatible change to Scheme.  It might be nicer to
 implement lazy evaluation as an <em>upward-compatible extension</em>,
 that is, so that ordinary Scheme programs will work as before.  We can
@@ -450,19 +450,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 
 </p><p></p><p>
 
-<a name="%_sec_4.2.3" id="%_sec_4.2.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_4.2.3">4.2.3  Streams as Lazy Lists</a></h3><p>
+<a id="__sec_4.2.3"></a>
+</p><h3>4.2.3  Streams as Lazy Lists</h3><p>
 
 
-<a name="%_idx_4754" id="%_idx_4754"></a><a name="%_idx_4756" id="%_idx_4756"></a><a name="%_idx_4758" id="%_idx_4758"></a><a name="%_idx_4760" id="%_idx_4760"></a><a name="%_idx_4762" id="%_idx_4762"></a>
-<a name="%_idx_4764" id="%_idx_4764"></a><a name="%_idx_4766" id="%_idx_4766"></a><a name="%_idx_4768" id="%_idx_4768"></a><a name="%_idx_4770" id="%_idx_4770"></a>In section <a href="book-Z-H-24.html#%_sec_3.5.1">3.5.1</a>, we showed how to implement streams
+<a id="__idx_4754"></a><a id="__idx_4756"></a><a id="__idx_4758"></a><a id="__idx_4760"></a><a id="__idx_4762"></a>
+<a id="__idx_4764"></a><a id="__idx_4766"></a><a id="__idx_4768"></a><a id="__idx_4770"></a>In section <a href="book-Z-H-24.html#__sec_3.5.1">3.5.1</a>, we showed how to implement streams
 as delayed lists.  We introduced special forms <tt>delay</tt> and <tt>cons-stream</tt>, which allowed us to construct a “promise” to compute
 the <tt>cdr</tt> of a stream, without actually fulfilling that promise
 until later.  We could use this general technique of introducing
 special forms whenever we need more control over the evaluation process,
 but this is awkward.  For one thing, a special form is not a
 first-class object like a procedure, so we cannot use it together with
-higher-order procedures.<a name="call_footnote_Temp_592" href="#footnote_Temp_592" id="call_footnote_Temp_592"><sup><small>39</small></sup></a>  Additionally,
+higher-order procedures.<a href="#footnote_Temp_592" id="call_footnote_Temp_592"><sup><small>39</small></sup></a>  Additionally,
 we were forced to create streams as a new kind of data object
 similar but not identical to lists, and this required us to
 reimplement many ordinary list operations (<tt>map</tt>, <tt>append</tt>, and
@@ -474,13 +474,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 All we need to do is to arrange matters so that <tt>cons</tt> is
 non-strict.  One way to accomplish this is to extend the lazy
 evaluator to allow for non-strict primitives, and to implement <tt>cons</tt> as one of these.  An easier way is to recall
-(section <a href="book-Z-H-14.html#%_sec_2.1.3">2.1.3</a>) that there is no fundamental need to
+(section <a href="book-Z-H-14.html#__sec_2.1.3">2.1.3</a>) that there is no fundamental need to
 implement <tt>cons</tt> as a primitive at all.  Instead, we can represent
-<a name="%_idx_4772" id="%_idx_4772"></a>pairs as procedures:<a name="call_footnote_Temp_593" href="#footnote_Temp_593" id="call_footnote_Temp_593"><sup><small>40</small></sup></a></p><p>
+<a id="__idx_4772"></a>pairs as procedures:<a href="#footnote_Temp_593" id="call_footnote_Temp_593"><sup><small>40</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_4774" id="%_idx_4774"></a>(define (cons x y)<br />
-  (lambda (m) (m x y)))<br /><a name="%_idx_4776" id="%_idx_4776"></a>(define (car z)<br />
-  (z (lambda (p q) p)))<br /><a name="%_idx_4778" id="%_idx_4778"></a>(define (cdr z)<br />
+</p><p></p><p><tt><a id="__idx_4774"></a>(define (cons x y)<br />
+  (lambda (m) (m x y)))<br /><a id="__idx_4776"></a>(define (car z)<br />
+  (z (lambda (p q) p)))<br /><a id="__idx_4778"></a>(define (cdr z)<br />
   (z (lambda (p q) q)))<br /></tt></p><p></p><p></p><p>
 
 In terms of these basic operations, the standard definitions of the
@@ -488,59 +488,59 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 finite ones, and the stream operations can be implemented as list operations.
 Here are some examples:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4780" id="%_idx_4780"></a>(define (list-ref items n)<br />
+</p><p></p><p><tt><a id="__idx_4780"></a>(define (list-ref items n)<br />
   (if (= n 0)<br />
       (car items)<br />
-      (list-ref (cdr items) (- n 1))))<br /><a name="%_idx_4782" id="%_idx_4782"></a>(define (map proc items)<br />
+      (list-ref (cdr items) (- n 1))))<br /><a id="__idx_4782"></a>(define (map proc items)<br />
   (if (null? items)<br />
       '()<br />
       (cons (proc (car items))<br />
-            (map proc (cdr items)))))<br /><a name="%_idx_4784" id="%_idx_4784"></a>(define (scale-list items factor)<br />
+            (map proc (cdr items)))))<br /><a id="__idx_4784"></a>(define (scale-list items factor)<br />
   (map (lambda (x) (* x factor))<br />
-       items))<br /><a name="%_idx_4786" id="%_idx_4786"></a>(define (add-lists list1 list2)<br />
+       items))<br /><a id="__idx_4786"></a>(define (add-lists list1 list2)<br />
   (cond ((null? list1) list2)<br />
         ((null? list2) list1)<br />
         (else (cons (+ (car list1) (car list2))<br />
-                    (add-lists (cdr list1) (cdr list2))))))<br /><a name="%_idx_4788" id="%_idx_4788"></a>(define ones (cons 1 ones))<br /><a name="%_idx_4790" id="%_idx_4790"></a>(define integers (cons 1 (add-lists ones integers)))<br /><i>;;; L-Eval input:</i><br />
+                    (add-lists (cdr list1) (cdr list2))))))<br /><a id="__idx_4788"></a>(define ones (cons 1 ones))<br /><a id="__idx_4790"></a>(define integers (cons 1 (add-lists ones integers)))<br /><i>;;; L-Eval input:</i><br />
 (list-ref integers 17)<br /><i>;;; L-Eval value:</i><br /><i>18</i><br /></tt></p><p></p><p></p><p>
 
 
 Note that these lazy lists are even lazier than the streams of
 chapter 3:  The <tt>car</tt> of the list, as well as the <tt>cdr</tt>, is
-delayed.<a name="call_footnote_Temp_594" href="#footnote_Temp_594" id="call_footnote_Temp_594"><sup><small>41</small></sup></a>
+delayed.<a href="#footnote_Temp_594" id="call_footnote_Temp_594"><sup><small>41</small></sup></a>
 In fact, even accessing the <tt>car</tt> or <tt>cdr</tt> of a lazy
 pair need not force the value of a list element.  The value will be
 forced only when it is really needed – e.g., for use as the
 argument of a primitive, or to be printed as an answer.</p><p>
 
 Lazy pairs also help with the problem that arose with streams in
-section <a href="book-Z-H-24.html#%_sec_3.5.4">3.5.4</a>, where we found that
+section <a href="book-Z-H-24.html#__sec_3.5.4">3.5.4</a>, where we found that
 formulating stream models of systems with loops may require us to
-sprinkle our programs with <a name="%_idx_4798" id="%_idx_4798"></a><a name="%_idx_4800" id="%_idx_4800"></a>explicit <tt>delay</tt> operations, beyond the
+sprinkle our programs with <a id="__idx_4798"></a><a id="__idx_4800"></a>explicit <tt>delay</tt> operations, beyond the
 ones supplied by <tt>cons-stream</tt>.  With lazy evaluation, all
 arguments to procedures are delayed uniformly.  For instance, we can
 implement procedures to integrate lists and solve differential
 equations as we originally intended in
-section <a href="book-Z-H-24.html#%_sec_3.5.4">3.5.4</a>:</p><p>
+section <a href="book-Z-H-24.html#__sec_3.5.4">3.5.4</a>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4802" id="%_idx_4802"></a>(define (integral integrand initial-value dt)<br />
+</p><p></p><p><tt><a id="__idx_4802"></a>(define (integral integrand initial-value dt)<br />
   (define int<br />
     (cons initial-value<br />
           (add-lists (scale-list integrand dt)<br />
                     int)))<br />
-  int)<br /><a name="%_idx_4804" id="%_idx_4804"></a>(define (solve f y0 dt)<br />
+  int)<br /><a id="__idx_4804"></a>(define (solve f y0 dt)<br />
   (define y (integral dy y0 dt))<br />
   (define dy (map f y))<br />
   y)<br /><i>;;; L-Eval input:</i><br />
 (list-ref (solve (lambda (x) x) 1 0.001) 1000)<br /><i>;;; L-Eval value:</i><br /><i>2.716924</i></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_4.32" id="%_thm_4.32"></a>
+</p><p><a id="__thm_4.32"></a>
 <b>Exercise 4.32.</b>  Give some examples that illustrate the difference between the streams
 of chapter 3 and the “lazier” lazy lists described in this section.
 How can you take advantage of this extra laziness?
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.33" id="%_thm_4.33"></a>
+</p><p><a id="__thm_4.33"></a>
 <b>Exercise 4.33.</b>  Ben Bitdiddle tests the lazy list implementation given above by
 evaluating the expression
 </p><p></p><p><tt>(car '(a b c))<br /></tt></p><p></p><p>
@@ -553,7 +553,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.34" id="%_thm_4.34"></a>
+</p><p><a id="__thm_4.34"></a>
 <b>Exercise 4.34.</b>  Modify the driver loop for the evaluator so that lazy pairs and lists
 will print in some reasonable way.  (What are you going to do about
 infinite lists?)  You may also need to modify the representation of
@@ -563,87 +563,87 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.2">4.2  Variations on a Scheme –
 </p><p></p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_575" href="#call_footnote_Temp_575" id="footnote_Temp_575"><sup><small>31</small></sup></a> Snarf: “To grab, especially a large document or
-<a name="%_idx_4674" id="%_idx_4674"></a><a name="%_idx_4676" id="%_idx_4676"></a><a name="%_idx_4678" id="%_idx_4678"></a>file for the purpose of using it either with or without the owner's
+</p><div class="footnote"><p><a href="#call_footnote_Temp_575" id="footnote_Temp_575"><sup><small>31</small></sup></a> Snarf: “To grab, especially a large document or
+<a id="__idx_4674"></a><a id="__idx_4676"></a><a id="__idx_4678"></a>file for the purpose of using it either with or without the owner's
 permission.”  Snarf down: “To snarf, sometimes with the connotation
 of absorbing, processing, or understanding.”  (These definitions were
 snarfed from Steele et al. 1983.  See also Raymond 1993.)
 
-</p><p><a name="footnote_Temp_576" href="#call_footnote_Temp_576" id="footnote_Temp_576"><sup><small>32</small></sup></a> The difference between the “lazy” terminology and
+</p><p><a href="#call_footnote_Temp_576" id="footnote_Temp_576"><sup><small>32</small></sup></a> The difference between the “lazy” terminology and
 the “normal-order” terminology is somewhat fuzzy.  Generally, “lazy”
 refers to the mechanisms of particular evaluators, while “normal-order”
 refers to the semantics of languages, independent of any particular
 evaluation strategy.  But this is not a hard-and-fast distinction, and
 the two terminologies are often used interchangeably.
 
-</p><p><a name="footnote_Temp_577" href="#call_footnote_Temp_577" id="footnote_Temp_577"><sup><small>33</small></sup></a> The “strict” versus “non-strict” terminology means essentially the
+</p><p><a href="#call_footnote_Temp_577" id="footnote_Temp_577"><sup><small>33</small></sup></a> The “strict” versus “non-strict” terminology means essentially the
 same thing as “applicative-order” versus “normal-order,” except that
 it refers to individual procedures and arguments rather than to the
 language as a whole.  At a conference on programming languages you
-might hear someone say, “The normal-order language <a name="%_idx_4690" id="%_idx_4690"></a>Hassle has certain
+might hear someone say, “The normal-order language <a id="__idx_4690"></a>Hassle has certain
 strict primitives.  Other procedures take their arguments by lazy
 evaluation.”
 
-</p><p><a name="footnote_Temp_580" href="#call_footnote_Temp_580" id="footnote_Temp_580"><sup><small>34</small></sup></a> The word <em>thunk</em> was invented by an informal
-<a name="%_idx_4698" id="%_idx_4698"></a><a name="%_idx_4700" id="%_idx_4700"></a><a name="%_idx_4702" id="%_idx_4702"></a>working group that was discussing the implementation of call-by-name
+</p><p><a href="#call_footnote_Temp_580" id="footnote_Temp_580"><sup><small>34</small></sup></a> The word <em>thunk</em> was invented by an informal
+<a id="__idx_4698"></a><a id="__idx_4700"></a><a id="__idx_4702"></a>working group that was discussing the implementation of call-by-name
 in Algol 60.  They observed that most of the analysis of (“thinking
 about”) the expression could be done at compile time; thus, at run
 time, the expression would already have been “thunk” about (Ingerman
 et al. 1960).
 
-</p><p><a name="footnote_Temp_581" href="#call_footnote_Temp_581" id="footnote_Temp_581"><sup><small>35</small></sup></a> This is analogous to the use of <tt>force</tt>
-<a name="%_idx_4708" id="%_idx_4708"></a>on the delayed objects that were introduced in chapter 3 to represent
+</p><p><a href="#call_footnote_Temp_581" id="footnote_Temp_581"><sup><small>35</small></sup></a> This is analogous to the use of <tt>force</tt>
+<a id="__idx_4708"></a>on the delayed objects that were introduced in chapter 3 to represent
 streams.  The critical difference between what we are
 doing here and what we did in chapter 3 is that we are building
 delaying and forcing into the evaluator, and thus making this uniform
 and automatic throughout the language.
 
-</p><p><a name="footnote_Temp_582" href="#call_footnote_Temp_582" id="footnote_Temp_582"><sup><small>36</small></sup></a> Lazy evaluation combined with memoization is sometimes
-<a name="%_idx_4712" id="%_idx_4712"></a>referred to as <em>call-by-need</em> argument passing, in contrast to
-<em>call-by-name</em> argument passing.  <a name="%_idx_4714" id="%_idx_4714"></a><a name="%_idx_4716" id="%_idx_4716"></a>(Call-by-name, introduced in
+</p><p><a href="#call_footnote_Temp_582" id="footnote_Temp_582"><sup><small>36</small></sup></a> Lazy evaluation combined with memoization is sometimes
+<a id="__idx_4712"></a>referred to as <em>call-by-need</em> argument passing, in contrast to
+<em>call-by-name</em> argument passing.  <a id="__idx_4714"></a><a id="__idx_4716"></a>(Call-by-name, introduced in
 Algol 60, is similar to non-memoized lazy evaluation.)
 As language designers, we can build our evaluator to memoize,
 not to memoize, or leave this an option for programmers
-(exercise <a href="#%_thm_4.31">4.31</a>).  As you might expect
+(exercise <a href="#__thm_4.31">4.31</a>).  As you might expect
 from chapter 3, these choices raise issues that become both subtle and
 confusing in the presence of assignments.  (See
-exercises <a href="#%_thm_4.27">4.27</a> and <a href="#%_thm_4.29">4.29</a>.)
-<a name="%_idx_4718" id="%_idx_4718"></a>An excellent article by Clinger (1982) attempts to clarify the
+exercises <a href="#__thm_4.27">4.27</a> and <a href="#__thm_4.29">4.29</a>.)
+<a id="__idx_4718"></a>An excellent article by Clinger (1982) attempts to clarify the
 multiple dimensions of confusion that arise here.
 
-</p><p><a name="footnote_Temp_585" href="#call_footnote_Temp_585" id="footnote_Temp_585"><sup><small>37</small></sup></a> Notice that we also erase the <tt>env</tt> from the thunk once the
+</p><p><a href="#call_footnote_Temp_585" id="footnote_Temp_585"><sup><small>37</small></sup></a> Notice that we also erase the <tt>env</tt> from the thunk once the
 expression's value has been computed.  This makes no difference in the
 values returned by the interpreter.  It does help save space,
 however, because removing the reference from the thunk to the <tt>env</tt>
 once it is no longer needed allows this structure to be
-<a name="%_idx_4744" id="%_idx_4744"></a><a name="%_idx_4746" id="%_idx_4746"></a><em>garbage-collected</em> and its
-space recycled, as we will discuss in section <a href="book-Z-H-33.html#%_sec_5.3">5.3</a>.</p><p>
+<a id="__idx_4744"></a><a id="__idx_4746"></a><em>garbage-collected</em> and its
+space recycled, as we will discuss in section <a href="book-Z-H-33.html#__sec_5.3">5.3</a>.</p><p>
 
 Similarly, we could have allowed unneeded environments in the memoized
-delayed objects of section <a href="book-Z-H-24.html#%_sec_3.5.1">3.5.1</a> to be garbage-collected,
+delayed objects of section <a href="book-Z-H-24.html#__sec_3.5.1">3.5.1</a> to be garbage-collected,
 by having <tt>memo-proc</tt> do something like <tt>(set! proc '())</tt>
 to discard the procedure <tt>proc</tt> (which includes the environment
 in which the <tt>delay</tt> was evaluated) after storing its value.
 
-</p><p><a name="footnote_Temp_587" href="#call_footnote_Temp_587" id="footnote_Temp_587"><sup><small>38</small></sup></a> This exercise
+</p><p><a href="#call_footnote_Temp_587" id="footnote_Temp_587"><sup><small>38</small></sup></a> This exercise
 demonstrates that the interaction between lazy evaluation and side
 effects can be very confusing.  This is just what you might expect
 from the discussion in chapter 3.
 
-</p><p><a name="footnote_Temp_592" href="#call_footnote_Temp_592" id="footnote_Temp_592"><sup><small>39</small></sup></a> This is precisely the issue with the <tt>unless</tt> procedure,
-as in exercise <a href="#%_thm_4.26">4.26</a>.
+</p><p><a href="#call_footnote_Temp_592" id="footnote_Temp_592"><sup><small>39</small></sup></a> This is precisely the issue with the <tt>unless</tt> procedure,
+as in exercise <a href="#__thm_4.26">4.26</a>.
 
-</p><p><a name="footnote_Temp_593" href="#call_footnote_Temp_593" id="footnote_Temp_593"><sup><small>40</small></sup></a> This is the procedural representation described in
-exercise <a href="book-Z-H-14.html#%_thm_2.4">2.4</a>.  Essentially any procedural representation
+</p><p><a href="#call_footnote_Temp_593" id="footnote_Temp_593"><sup><small>40</small></sup></a> This is the procedural representation described in
+exercise <a href="book-Z-H-14.html#__thm_2.4">2.4</a>.  Essentially any procedural representation
 (e.g., a message-passing implementation) would do as well.  Notice
 that we can install these definitions in the lazy evaluator simply by
 typing them at the driver loop.  If we had originally included <tt>cons</tt>, <tt>car</tt>, and <tt>cdr</tt> as primitives in the global
 environment, they will be redefined.  (Also see
-exercises <a href="#%_thm_4.33">4.33</a> and <a href="#%_thm_4.34">4.34</a>.)
+exercises <a href="#__thm_4.33">4.33</a> and <a href="#__thm_4.34">4.34</a>.)
 
-</p><p><a name="footnote_Temp_594" href="#call_footnote_Temp_594" id="footnote_Temp_594"><sup><small>41</small></sup></a> This permits us to create delayed versions of more general kinds of
-<a name="%_idx_4792" id="%_idx_4792"></a>list structures, not just sequences.  Hughes 1990 discusses some
-<a name="%_idx_4794" id="%_idx_4794"></a><a name="%_idx_4796" id="%_idx_4796"></a>applications of “lazy trees.”
+</p><p><a href="#call_footnote_Temp_594" id="footnote_Temp_594"><sup><small>41</small></sup></a> This permits us to create delayed versions of more general kinds of
+<a id="__idx_4792"></a>list structures, not just sequences.  Hughes 1990 discusses some
+<a id="__idx_4794"></a><a id="__idx_4796"></a>applications of “lazy trees.”
 
 </p></div>
 
diff --git a/src/OEBPS/book-Z-H-28.html b/src/OEBPS/book-Z-H-28.html
index df38aac..d32f873 100644
--- a/src/OEBPS/book-Z-H-28.html
+++ b/src/OEBPS/book-Z-H-28.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,43 +13,43 @@
 
 
 
-<a name="%_sec_4.3" id="%_sec_4.3"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme – Nondeterministic Computing</a></h2><p>
+<a id="__sec_4.3"></a>
+<h2>4.3  Variations on a Scheme – Nondeterministic Computing</h2><p>
 
 
-<a name="%_idx_4806" id="%_idx_4806"></a>
-<a name="%_idx_4808" id="%_idx_4808"></a>In this section, we extend the Scheme evaluator to support a
+<a id="__idx_4806"></a>
+<a id="__idx_4808"></a>In this section, we extend the Scheme evaluator to support a
 programming paradigm called <em>nondeterministic computing</em> by
 building into the evaluator a facility to support automatic search.
 This is a much more profound change to the language than the
-introduction of lazy evaluation in section <a href="book-Z-H-27.html#%_sec_4.2">4.2</a>.</p><p>
+introduction of lazy evaluation in section <a href="book-Z-H-27.html#__sec_4.2">4.2</a>.</p><p>
 
-<a name="%_idx_4810" id="%_idx_4810"></a>Nondeterministic computing, like stream processing, is useful for
+<a id="__idx_4810"></a>Nondeterministic computing, like stream processing, is useful for
 “generate and test” applications.  Consider the task of starting with
 two lists of positive integers and finding a pair of integers – one
 from the first list and one from the second list – whose sum is prime.
 We saw how to handle this with finite sequence operations in
-section <a href="book-Z-H-15.html#%_sec_2.2.3">2.2.3</a> and with infinite streams in
-section <a href="book-Z-H-24.html#%_sec_3.5.3">3.5.3</a>.  Our approach was to generate
+section <a href="book-Z-H-15.html#__sec_2.2.3">2.2.3</a> and with infinite streams in
+section <a href="book-Z-H-24.html#__sec_3.5.3">3.5.3</a>.  Our approach was to generate
 the sequence of all possible pairs and filter these to select the
 pairs whose sum is prime.  Whether we actually generate the entire
 sequence of pairs first as in chapter 2, or interleave the generating
 and filtering as in chapter 3, is immaterial to the essential image of
 how the computation is organized.</p><p>
 
-<a name="%_idx_4812" id="%_idx_4812"></a>The nondeterministic approach evokes a different image.  Imagine simply
+<a id="__idx_4812"></a>The nondeterministic approach evokes a different image.  Imagine simply
 that we choose (in some way) a number from the first list and a number
 from the second list and require (using some mechanism) that their sum
 be prime.  This is expressed by following procedure:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4814" id="%_idx_4814"></a>(define (prime-sum-pair list1 list2)<br />
+</p><p></p><p><tt><a id="__idx_4814"></a>(define (prime-sum-pair list1 list2)<br />
   (let ((a (an-element-of list1))<br />
         (b (an-element-of list2)))<br />
     (require (prime? (+ a b)))<br />
     (list a b)))<br /></tt></p><p></p><p>
 It might seem as if this procedure merely restates the problem,
 rather than specifying a way to solve it.  Nevertheless, this is
-a legitimate nondeterministic program.<a name="call_footnote_Temp_598" href="#footnote_Temp_598" id="call_footnote_Temp_598"><sup><small>42</small></sup></a></p><p>
+a legitimate nondeterministic program.<a href="#footnote_Temp_598" id="call_footnote_Temp_598"><sup><small>42</small></sup></a></p><p>
 
 
 The key idea here is that expressions in a nondeterministic language
@@ -64,7 +64,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 nondeterministic program evaluator will free the programmer from the
 details of how choices are made.</p><p>
 
-<a name="%_idx_4820" id="%_idx_4820"></a>It is instructive to contrast the different images of time evoked by
+<a id="__idx_4820"></a>It is instructive to contrast the different images of time evoked by
 nondeterministic evaluation and stream processing.  Stream processing
 uses lazy evaluation to decouple the time when the stream of possible
 answers is assembled from the time when the actual stream elements are
@@ -89,42 +89,42 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 The value returned was obtained after the evaluator repeatedly chose
 elements from each of the lists, until a successful choice was made.</p><p>
 
-Section <a href="#%_sec_4.3.1">4.3.1</a> introduces <tt>amb</tt> and explains how it
+Section <a href="#__sec_4.3.1">4.3.1</a> introduces <tt>amb</tt> and explains how it
 supports nondeterminism through the evaluator's automatic search
-mechanism.  Section <a href="#%_sec_4.3.2">4.3.2</a> presents examples of
-nondeterministic programs, and section <a href="#%_sec_4.3.3">4.3.3</a>
+mechanism.  Section <a href="#__sec_4.3.2">4.3.2</a> presents examples of
+nondeterministic programs, and section <a href="#__sec_4.3.3">4.3.3</a>
 gives the details of how to implement the <tt>amb</tt> evaluator by
 modifying the ordinary Scheme evaluator.</p><p>
 
-<a name="%_sec_4.3.1" id="%_sec_4.3.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_4.3.1">4.3.1  Amb and Search</a></h3><p>
+<a id="__sec_4.3.1"></a>
+</p><h3>4.3.1  Amb and Search</h3><p>
 
 </p><p>
 
-<a name="%_idx_4822" id="%_idx_4822"></a>To extend Scheme to support nondeterminism, we introduce a new special
-form called <tt>amb</tt>.<a name="call_footnote_Temp_599" href="#footnote_Temp_599" id="call_footnote_Temp_599"><sup><small>43</small></sup></a>
+<a id="__idx_4822"></a>To extend Scheme to support nondeterminism, we introduce a new special
+form called <tt>amb</tt>.<a href="#footnote_Temp_599" id="call_footnote_Temp_599"><sup><small>43</small></sup></a>
 The expression <tt>(amb &lt;<em><em>e</em><sub>1</sub></em>&gt; &lt;<em><em>e</em><sub>2</sub></em>&gt; <tt>...</tt> &lt;<em><em>e</em><sub><em>n</em></sub></em>&gt;)</tt>
 returns the value of one of the <em>n</em> expressions &lt;<em><em>e</em><sub><em>i</em></sub></em>&gt; “ambiguously.”
 For example, the expression</p><p>
 
 </p><p></p><p><tt>(list (amb 1 2 3) (amb 'a 'b))<br /></tt></p><p></p><p>
 can have six possible values:
-</p><table border="0"><tr><td valign="top"><tt>(1 a) </tt></td><td valign="top"><tt>(1 b) </tt></td><td valign="top"><tt>(2 a) </tt></td><td valign="top"><tt>(2 b) </tt></td><td valign="top"><tt>(3 a) </tt></td><td valign="top"><tt>(3 b)
+</p><table style="border: none;"><tr><td style="text-align: top;"><tt>(1 a) </tt></td><td style="text-align: top;"><tt>(1 b) </tt></td><td style="text-align: top;"><tt>(2 a) </tt></td><td style="text-align: top;"><tt>(2 b) </tt></td><td style="text-align: top;"><tt>(3 a) </tt></td><td style="text-align: top;"><tt>(3 b)
 </tt></td></tr></table><tt>Amb</tt> with a single choice produces an ordinary (single) value.<p>
 
-<a name="%_idx_4826" id="%_idx_4826"></a><tt>Amb</tt> with no choices – the expression <tt>(amb)</tt> – is an
+<a id="__idx_4826"></a><tt>Amb</tt> with no choices – the expression <tt>(amb)</tt> – is an
 expression with no acceptable values.  Operationally, we can think of
 <tt>(amb)</tt> as an expression that when evaluated causes the
 computation to “fail”: The computation aborts and no value is
 produced.  Using this idea, we can express the requirement that a
 particular predicate expression <tt>p</tt> must be true as follows:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4828" id="%_idx_4828"></a>(define (require p)<br />
+</p><p></p><p><tt><a id="__idx_4828"></a>(define (require p)<br />
   (if (not p) (amb)))<br /></tt></p><p></p><p></p><p>
 
 With <tt>amb</tt> and <tt>require</tt>, we can implement the <tt>an-element-of</tt> procedure used above:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4830" id="%_idx_4830"></a>(define (an-element-of items)<br />
+</p><p></p><p><tt><a id="__idx_4830"></a>(define (an-element-of items)<br />
   (require (not (null? items)))<br />
   (amb (car items) (an-element-of (cdr items))))<br /></tt></p><p></p><p>
 <tt>An-element-of</tt> fails if the list is empty.  Otherwise it
@@ -135,18 +135,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 procedure potentially returns any integer greater than or equal to
 some given <em>n</em>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4832" id="%_idx_4832"></a>(define (an-integer-starting-from n)<br />
+</p><p></p><p><tt><a id="__idx_4832"></a>(define (an-integer-starting-from n)<br />
   (amb n (an-integer-starting-from (+ n 1))))<br /></tt></p><p></p><p>
 This is like the stream procedure <tt>integers-starting-from</tt>
-described in section <a href="book-Z-H-24.html#%_sec_3.5.2">3.5.2</a>, but with an important
+described in section <a href="book-Z-H-24.html#__sec_3.5.2">3.5.2</a>, but with an important
 difference: The stream procedure returns an object that represents the
 sequence of all integers beginning with <em>n</em>, whereas the <tt>amb</tt>
-procedure returns a single integer.<a name="call_footnote_Temp_600" href="#footnote_Temp_600" id="call_footnote_Temp_600"><sup><small>44</small></sup></a></p><p>
+procedure returns a single integer.<a href="#footnote_Temp_600" id="call_footnote_Temp_600"><sup><small>44</small></sup></a></p><p>
 
-<a name="%_idx_4834" id="%_idx_4834"></a>Abstractly, we can imagine that evaluating an <tt>amb</tt> expression
+<a id="__idx_4834"></a>Abstractly, we can imagine that evaluating an <tt>amb</tt> expression
 causes time to split into branches, where the computation continues on
 each branch with one of the possible values of the expression.  We say
-that <tt>amb</tt> represents a <a name="%_idx_4836" id="%_idx_4836"></a><em>nondeterministic choice point</em>.
+that <tt>amb</tt> represents a <a id="__idx_4836"></a><em>nondeterministic choice point</em>.
 If we had a machine with a sufficient number of processors that could
 be dynamically allocated, we could implement the search in a
 straightforward way.  Execution would proceed as in a sequential
@@ -155,38 +155,38 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 the parallel executions implied by the choice.  Each processor would
 proceed sequentially as if it were the only choice, until it either
 terminates by encountering a failure, or it further subdivides, or
-it finishes.<a name="call_footnote_Temp_601" href="#footnote_Temp_601" id="call_footnote_Temp_601"><sup><small>45</small></sup></a></p><p>
+it finishes.<a href="#footnote_Temp_601" id="call_footnote_Temp_601"><sup><small>45</small></sup></a></p><p>
 
-<a name="%_idx_4840" id="%_idx_4840"></a>On the other hand, if we have a machine that can execute
+<a id="__idx_4840"></a>On the other hand, if we have a machine that can execute
 only one process (or a few concurrent processes),
 we must consider the alternatives sequentially.
 One could imagine modifying an evaluator
 to pick at random a branch to follow whenever it encounters a choice
 point.  Random choice, however, can easily lead to failing values.
 We might try running the evaluator over and over, making random
-choices and hoping to find a non-failing value, but it is better to <a name="%_idx_4842" id="%_idx_4842"></a><a name="%_idx_4844" id="%_idx_4844"></a><em>systematically search</em> all possible execution paths.
+choices and hoping to find a non-failing value, but it is better to <a id="__idx_4842"></a><a id="__idx_4844"></a><em>systematically search</em> all possible execution paths.
 The <tt>amb</tt> evaluator that we will develop and work with in this section
 implements a systematic search as follows: When the evaluator
 encounters an application of <tt>amb</tt>, it initially selects the first
 alternative.  This selection may itself lead to a further choice.  The
 evaluator will always initially choose the first alternative at each
 choice point.  If a choice results in a failure, then the evaluator
-<a name="%_idx_4846" id="%_idx_4846"></a><a name="%_idx_4848" id="%_idx_4848"></a><a name="%_idx_4850" id="%_idx_4850"></a>automagically<a name="call_footnote_Temp_602" href="#footnote_Temp_602" id="call_footnote_Temp_602"><sup><small>46</small></sup></a> <a name="%_idx_4852" id="%_idx_4852"></a><em>backtracks</em>
+<a id="__idx_4846"></a><a id="__idx_4848"></a><a id="__idx_4850"></a>automagically<a href="#footnote_Temp_602" id="call_footnote_Temp_602"><sup><small>46</small></sup></a> <a id="__idx_4852"></a><em>backtracks</em>
 to the most recent choice point and tries the next
 alternative.  If it runs out of alternatives at any choice point, the
 evaluator will back up to the previous choice point and resume from
-there.  This process leads to a search strategy known as <a name="%_idx_4854" id="%_idx_4854"></a><a name="%_idx_4856" id="%_idx_4856"></a><a name="%_idx_4858" id="%_idx_4858"></a><em>depth-first search</em> or <em>chronological backtracking</em>.<a name="call_footnote_Temp_603" href="#footnote_Temp_603" id="call_footnote_Temp_603"><sup><small>47</small></sup></a></p><p>
+there.  This process leads to a search strategy known as <a id="__idx_4854"></a><a id="__idx_4856"></a><a id="__idx_4858"></a><em>depth-first search</em> or <em>chronological backtracking</em>.<a href="#footnote_Temp_603" id="call_footnote_Temp_603"><sup><small>47</small></sup></a></p><p>
 
-<a name="%_sec_Temp_604" id="%_sec_Temp_604"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_604">Driver loop</a></h4><p>
+<a id="__sec_Temp_604"></a>
+</p><h4>Driver loop</h4><p>
 
-<a name="%_idx_4908" id="%_idx_4908"></a>The driver loop for the <tt>amb</tt> evaluator
+<a id="__idx_4908"></a>The driver loop for the <tt>amb</tt> evaluator
 has some unusual properties.  It reads an
 expression and prints the value of the first non-failing execution, as
 in the <tt>prime-sum-pair</tt> example shown above.  If we
 want to see the value of the next successful execution, we can
 ask the interpreter to backtrack and attempt to generate a second
-non-failing execution.  This is signaled by typing the symbol <a name="%_idx_4910" id="%_idx_4910"></a><tt>try-again</tt>.  If any expression except <tt>try-again</tt> is given, the
+non-failing execution.  This is signaled by typing the symbol <a id="__idx_4910"></a><tt>try-again</tt>.  If any expression except <tt>try-again</tt> is given, the
 interpreter will start a new problem, discarding the unexplored
 alternatives in the previous problem.  Here is a sample
 interaction:</p><p>
@@ -198,8 +198,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 try-again<br /><i>;;; There are no more values of</i><br /><i>(prime-sum-pair (quote (1 3 5 8)) (quote (20 35 110)))</i><br /><i>;;; Amb-Eval input:</i><br />
 (prime-sum-pair '(19 27 30) '(11 36 58))<br /><i>;;; Starting a new problem</i><br /><i>;;; Amb-Eval value:</i><br /><i>(30 11)</i><br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_4.35" id="%_thm_4.35"></a>
-<b>Exercise 4.35.</b>  <a name="%_idx_4912" id="%_idx_4912"></a><a name="%_idx_4914" id="%_idx_4914"></a>Write a procedure <tt>an-integer-between</tt> that returns an integer
+</p><p><a id="__thm_4.35"></a>
+<b>Exercise 4.35.</b>  <a id="__idx_4912"></a><a id="__idx_4914"></a>Write a procedure <tt>an-integer-between</tt> that returns an integer
 between two given bounds.  This can be used to implement a
 procedure that finds Pythagorean triples,
 i.e., triples of integers (<em>i</em>,<em>j</em>,<em>k</em>) between the given bounds such
@@ -212,22 +212,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
         (list i j k)))))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.36" id="%_thm_4.36"></a>
-<b>Exercise 4.36.</b>  <a name="%_idx_4916" id="%_idx_4916"></a><a name="%_idx_4918" id="%_idx_4918"></a>Exercise <a href="book-Z-H-24.html#%_thm_3.69">3.69</a> discussed how to generate
+</p><p><a id="__thm_4.36"></a>
+<b>Exercise 4.36.</b>  <a id="__idx_4916"></a><a id="__idx_4918"></a>Exercise <a href="book-Z-H-24.html#__thm_3.69">3.69</a> discussed how to generate
 the stream of <em>all</em> Pythagorean triples, with no upper bound on the
 size of the integers to be searched.  Explain why simply replacing
 <tt>an-integer-between</tt> by <tt>an-integer-starting-from</tt> in the procedure in
-exercise <a href="#%_thm_4.35">4.35</a> is not an adequate way to
+exercise <a href="#__thm_4.35">4.35</a> is not an adequate way to
 generate arbitrary Pythagorean triples.  Write a procedure that
 actually will accomplish this.  (That is, write a procedure for which
 repeatedly typing <tt>try-again</tt> would in principle eventually
 generate all Pythagorean triples.)
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.37" id="%_thm_4.37"></a>
-<b>Exercise 4.37.</b>  <a name="%_idx_4920" id="%_idx_4920"></a><a name="%_idx_4922" id="%_idx_4922"></a>Ben Bitdiddle claims that the following method for generating
+</p><p><a id="__thm_4.37"></a>
+<b>Exercise 4.37.</b>  <a id="__idx_4920"></a><a id="__idx_4922"></a>Ben Bitdiddle claims that the following method for generating
 Pythagorean triples is more efficient than the one in
-exercise <a href="#%_thm_4.35">4.35</a>.  Is he correct?  (Hint: Consider
+exercise <a href="#__thm_4.35">4.35</a>.  Is he correct?  (Hint: Consider
 the number of possibilities that must be explored.)</p><p>
 
 </p><p></p><p><tt>(define (a-pythagorean-triple-between low high)<br />
@@ -241,22 +241,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
           (list i j k))))))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-<a name="%_sec_4.3.2" id="%_sec_4.3.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_4.3.2">4.3.2  Examples of Nondeterministic Programs</a></h3><p>
+<a id="__sec_4.3.2"></a>
+</p><h3>4.3.2  Examples of Nondeterministic Programs</h3><p>
 
 </p><p>
 
-Section <a href="#%_sec_4.3.3">4.3.3</a> describes the implementation of
+Section <a href="#__sec_4.3.3">4.3.3</a> describes the implementation of
 the <tt>amb</tt> evaluator.  First, however, we give some examples of how
 it can be used.  The advantage of nondeterministic programming is that
 we can suppress the details of how search is carried out, thereby
-<a name="%_idx_4924" id="%_idx_4924"></a>expressing our programs at a higher level of abstraction.</p><p>
+<a id="__idx_4924"></a>expressing our programs at a higher level of abstraction.</p><p>
 
-<a name="%_sec_Temp_608" id="%_sec_Temp_608"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_608">Logic Puzzles</a></h4><p>
+<a id="__sec_Temp_608"></a>
+</p><h4>Logic Puzzles</h4><p>
 
-<a name="%_idx_4926" id="%_idx_4926"></a><a name="%_idx_4928" id="%_idx_4928"></a><a name="%_idx_4930" id="%_idx_4930"></a>
-<a name="%_idx_4932" id="%_idx_4932"></a>The following puzzle (taken from Dinesman 1968) is typical of a large
+<a id="__idx_4926"></a><a id="__idx_4928"></a><a id="__idx_4930"></a>
+<a id="__idx_4932"></a>The following puzzle (taken from Dinesman 1968) is typical of a large
 class of simple logic puzzles:</p><p>
 
 </p><blockquote>
@@ -271,10 +271,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 
 We can determine who lives on each floor in a straightforward way by
 enumerating all the possibilities and imposing the given
-restrictions:<a name="call_footnote_Temp_609" href="#footnote_Temp_609" id="call_footnote_Temp_609"><sup><small>48</small></sup></a></p><p>
+restrictions:<a href="#footnote_Temp_609" id="call_footnote_Temp_609"><sup><small>48</small></sup></a></p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_4938" id="%_idx_4938"></a>(define (multiple-dwelling)<br />
+</p><p></p><p><tt><a id="__idx_4938"></a>(define (multiple-dwelling)<br />
   (let ((baker (amb 1 2 3 4 5))<br />
         (cooper (amb 1 2 3 4 5))<br />
         (fletcher (amb 1 2 3 4 5))<br />
@@ -301,17 +301,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 
 </p><p></p><p><tt>((baker 3) (cooper 2) (fletcher 4) (miller 5) (smith 1))<br /></tt></p><p></p><p>
 Although this simple procedure works, it is very slow.
-Exercises <a href="#%_thm_4.39">4.39</a>
-and <a href="#%_thm_4.40">4.40</a> discuss some possible
+Exercises <a href="#__thm_4.39">4.39</a>
+and <a href="#__thm_4.40">4.40</a> discuss some possible
 improvements.</p><p>
 
-</p><p><a name="%_thm_4.38" id="%_thm_4.38"></a>
+</p><p><a id="__thm_4.38"></a>
 <b>Exercise 4.38.</b>  Modify the multiple-dwelling procedure to omit the requirement that
 Smith and Fletcher do not live on adjacent floors.  How many solutions
 are there to this modified puzzle?
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.39" id="%_thm_4.39"></a>
+</p><p><a id="__thm_4.39"></a>
 <b>Exercise 4.39.</b>  Does the order of the restrictions in the multiple-dwelling procedure
 affect the answer? Does it affect the time to find an answer?  If you
 think it matters, demonstrate a faster program obtained from the given
@@ -320,7 +320,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.40" id="%_thm_4.40"></a>
+</p><p><a id="__thm_4.40"></a>
 <b>Exercise 4.40.</b>  In the multiple dwelling problem, how many sets of assignments are
 there of people to floors, both before and after the requirement that
 floor assignments be distinct?  It is very inefficient to generate all
@@ -336,12 +336,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.41" id="%_thm_4.41"></a>
-<b>Exercise 4.41.</b>  <a name="%_idx_4940" id="%_idx_4940"></a>Write an ordinary Scheme program to solve the multiple dwelling puzzle.
+</p><p><a id="__thm_4.41"></a>
+<b>Exercise 4.41.</b>  <a id="__idx_4940"></a>Write an ordinary Scheme program to solve the multiple dwelling puzzle.
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.42" id="%_thm_4.42"></a>
-<b>Exercise 4.42.</b>  <a name="%_idx_4942" id="%_idx_4942"></a>Solve the following “Liars” puzzle (from Phillips 1934):
+</p><p><a id="__thm_4.42"></a>
+<b>Exercise 4.42.</b>  <a id="__idx_4942"></a>Solve the following “Liars” puzzle (from Phillips 1934):
 </p><blockquote>
 Five schoolgirls sat for an examination.  Their parents – so they
 thought – showed an undue degree of interest in the result.  They
@@ -358,8 +358,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 </p></blockquote>
 <p></p><p>
 
-</p><p><a name="%_thm_4.43" id="%_thm_4.43"></a>
-<b>Exercise 4.43.</b>  Use the <tt>amb</tt> evaluator to solve the following puzzle:<a name="call_footnote_Temp_616" href="#footnote_Temp_616" id="call_footnote_Temp_616"><sup><small>49</small></sup></a>
+</p><p><a id="__thm_4.43"></a>
+<b>Exercise 4.43.</b>  Use the <tt>amb</tt> evaluator to solve the following puzzle:<a href="#footnote_Temp_616" id="call_footnote_Temp_616"><sup><small>49</small></sup></a>
 </p><blockquote>
 Mary Ann Moore's father has a yacht and so has each of his four
 friends:  Colonel Downing, Mr. Hall, Sir Barnacle Hood, and Dr.
@@ -371,21 +371,21 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 Parker's daughter.  Who is Lorna's father?
 </blockquote>
 Try to write the program so that it runs efficiently (see
-exercise <a href="#%_thm_4.40">4.40</a>).  Also determine how many
+exercise <a href="#__thm_4.40">4.40</a>).  Also determine how many
 solutions there are if we are not told that Mary Ann's last name is
 Moore.
 <p></p><p>
 
-</p><p><a name="%_thm_4.44" id="%_thm_4.44"></a>
-<b>Exercise 4.44.</b>  <a name="%_idx_4944" id="%_idx_4944"></a><a name="%_idx_4946" id="%_idx_4946"></a><a name="%_idx_4948" id="%_idx_4948"></a><a name="%_idx_4950" id="%_idx_4950"></a>Exercise <a href="book-Z-H-15.html#%_thm_2.42">2.42</a> described the “eight-queens puzzle” of
+</p><p><a id="__thm_4.44"></a>
+<b>Exercise 4.44.</b>  <a id="__idx_4944"></a><a id="__idx_4946"></a><a id="__idx_4948"></a><a id="__idx_4950"></a>Exercise <a href="book-Z-H-15.html#__thm_2.42">2.42</a> described the “eight-queens puzzle” of
 placing queens on a chessboard so that no two attack each other.
 Write a nondeterministic program to solve this puzzle.
 </p><p></p><p>
 
-<a name="%_sec_Temp_618" id="%_sec_Temp_618"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_618">Parsing natural language</a></h4><p>
+<a id="__sec_Temp_618"></a>
+</p><h4>Parsing natural language</h4><p>
 
-<a name="%_idx_4952" id="%_idx_4952"></a><a name="%_idx_4954" id="%_idx_4954"></a>
+<a id="__idx_4952"></a><a id="__idx_4954"></a>
 Programs designed to accept natural language as input usually start by
 attempting to <em>parse</em> the input, that is, to match the input
 against some grammatical structure.  For example, we might try to
@@ -393,10 +393,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 followed by a verb, such as “The cat eats.”  To accomplish such an
 analysis, we must be able to identify the parts of speech of
 individual words.  We could start with some lists that classify
-various words:<a name="call_footnote_Temp_619" href="#footnote_Temp_619" id="call_footnote_Temp_619"><sup><small>50</small></sup></a></p><p>
+various words:<a href="#footnote_Temp_619" id="call_footnote_Temp_619"><sup><small>50</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_4956" id="%_idx_4956"></a>(define nouns '(noun student professor cat class))<br /><a name="%_idx_4958" id="%_idx_4958"></a>(define verbs '(verb studies lectures eats sleeps))<br /><a name="%_idx_4960" id="%_idx_4960"></a>(define articles '(article the a))<br /></tt></p><p></p><p>
-<a name="%_idx_4962" id="%_idx_4962"></a>We also need a <em>grammar</em>, that is, a set of rules describing how
+</p><p></p><p><tt><a id="__idx_4956"></a>(define nouns '(noun student professor cat class))<br /><a id="__idx_4958"></a>(define verbs '(verb studies lectures eats sleeps))<br /><a id="__idx_4960"></a>(define articles '(article the a))<br /></tt></p><p></p><p>
+<a id="__idx_4962"></a>We also need a <em>grammar</em>, that is, a set of rules describing how
 grammatical elements are composed from simpler elements.  A very
 simple grammar might stipulate that a sentence always consists of two
 pieces – a noun phrase followed by a verb – and that a noun phrase
@@ -411,7 +411,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 identify its two constituent pieces and return a list of
 these two elements, tagged with the symbol <tt>sentence</tt>:</p><p>
 
-<a name="%_idx_4964" id="%_idx_4964"></a></p><p></p><p><tt>(define (parse-sentence)<br />
+<a id="__idx_4964"></a></p><p></p><p><tt>(define (parse-sentence)<br />
   (list 'sentence<br />
          (parse-noun-phrase)<br />
          (parse-word verbs)))<br /></tt></p><p></p><p>
@@ -430,7 +430,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 must be non-empty and that it should begin with a word from the
 designated list.  If so, we remove that word from <tt>*unparsed*</tt> and
 return the word together with its part of speech (which is found at
-the head of the list):<a name="call_footnote_Temp_620" href="#footnote_Temp_620" id="call_footnote_Temp_620"><sup><small>51</small></sup></a></p><p>
+the head of the list):<a href="#footnote_Temp_620" id="call_footnote_Temp_620"><sup><small>51</small></sup></a></p><p>
 
 </p><p></p><p><tt>(define (parse-word word-list)<br />
   (require (not (null? *unparsed*)))<br />
@@ -443,7 +443,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 the entire input, try to parse a sentence, and check that nothing is
 left over:</p><p>
 
-</p><p></p><p><tt>(define *unparsed* '())<br /><a name="%_idx_4966" id="%_idx_4966"></a>(define (parse input)<br />
+</p><p></p><p><tt>(define *unparsed* '())<br /><a id="__idx_4966"></a>(define (parse input)<br />
   (set! *unparsed* input)<br />
   (let ((sent (parse-sentence)))<br />
     (require (null? *unparsed*))<br />
@@ -464,7 +464,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 
 Let's add to our grammar a list of prepositions:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4968" id="%_idx_4968"></a>(define prepositions '(prep for to in by with))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_4968"></a>(define prepositions '(prep for to in by with))<br /></tt></p><p></p><p>
 
 and define a prepositional phrase (e.g., “for the cat”) to be
 a preposition followed by a noun phrase:</p><p>
@@ -475,7 +475,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
         (parse-noun-phrase)))<br /></tt></p><p></p><p>
 Now we can define a sentence to be a noun phrase followed by a verb
 phrase, where a verb phrase can be either a verb or a verb phrase
-extended by a prepositional phrase:<a name="call_footnote_Temp_621" href="#footnote_Temp_621" id="call_footnote_Temp_621"><sup><small>52</small></sup></a></p><p>
+extended by a prepositional phrase:<a href="#footnote_Temp_621" id="call_footnote_Temp_621"><sup><small>52</small></sup></a></p><p>
 
 </p><p></p><p><tt>(define (parse-sentence)<br />
   (list 'sentence<br />
@@ -557,7 +557,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
                               (article the) (noun cat)))))))<br /></tt></p><p></p><p>
 </p><p>
 
-</p><p><a name="%_thm_4.45" id="%_thm_4.45"></a>
+</p><p><a id="__thm_4.45"></a>
 <b>Exercise 4.45.</b>  With the grammar given above, the following sentence can be parsed in
 five different ways:
 “The professor lectures to the student in the class with the cat.”
@@ -565,15 +565,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 meaning among them.
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.46" id="%_thm_4.46"></a>
-<b>Exercise 4.46.</b>  <a name="%_idx_4970" id="%_idx_4970"></a>The evaluators in sections <a href="book-Z-H-26.html#%_sec_4.1">4.1</a> and <a href="book-Z-H-27.html#%_sec_4.2">4.2</a>
+</p><p><a id="__thm_4.46"></a>
+<b>Exercise 4.46.</b>  <a id="__idx_4970"></a>The evaluators in sections <a href="book-Z-H-26.html#__sec_4.1">4.1</a> and <a href="book-Z-H-27.html#__sec_4.2">4.2</a>
 do not determine what order operands are evaluated in.
 We will see that the <tt>amb</tt> evaluator evaluates them from left to right.
 Explain why our parsing program wouldn't work if the operands were evaluated
 in some other order.
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.47" id="%_thm_4.47"></a>
+</p><p><a id="__thm_4.47"></a>
 <b>Exercise 4.47.</b>  Louis Reasoner suggests that, since a verb phrase is either a verb or
 a verb phrase followed by a prepositional phrase, it would be much more
 straightforward to define the procedure <tt>parse-verb-phrase</tt> as
@@ -587,28 +587,28 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 the order of expressions in the <tt>amb</tt>?
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.48" id="%_thm_4.48"></a>
+</p><p><a id="__thm_4.48"></a>
 <b>Exercise 4.48.</b>  Extend the grammar given above to handle more complex sentences.  For
 example, you could extend noun phrases and verb phrases to include
-adjectives and adverbs, or you could handle compound sentences.<a name="call_footnote_Temp_626" href="#footnote_Temp_626" id="call_footnote_Temp_626"><sup><small>53</small></sup></a>
+adjectives and adverbs, or you could handle compound sentences.<a href="#footnote_Temp_626" id="call_footnote_Temp_626"><sup><small>53</small></sup></a>
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.49" id="%_thm_4.49"></a>
-<b>Exercise 4.49.</b>  <a name="%_idx_4976" id="%_idx_4976"></a>Alyssa P. Hacker is more interested in generating interesting
+</p><p><a id="__thm_4.49"></a>
+<b>Exercise 4.49.</b>  <a id="__idx_4976"></a>Alyssa P. Hacker is more interested in generating interesting
 sentences than in parsing them.  She reasons that by simply changing
 the procedure <tt>parse-word</tt> so that it ignores the “input
 sentence” and instead always succeeds and generates an appropriate
 word, we can use the programs we had built for parsing to do
 generation instead.  Implement Alyssa's idea, and show the first
-half-dozen or so sentences generated.<a name="call_footnote_Temp_628" href="#footnote_Temp_628" id="call_footnote_Temp_628"><sup><small>54</small></sup></a>
+half-dozen or so sentences generated.<a href="#footnote_Temp_628" id="call_footnote_Temp_628"><sup><small>54</small></sup></a>
 
 </p><p></p><p>
 
-<a name="%_sec_4.3.3" id="%_sec_4.3.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_4.3.3">4.3.3  Implementing the <tt>Amb</tt> Evaluator</a></h3><p>
+<a id="__sec_4.3.3"></a>
+</p><h3>4.3.3  Implementing the <tt>Amb</tt> Evaluator</h3><p>
 
 
-<a name="%_idx_4978" id="%_idx_4978"></a>
+<a id="__idx_4978"></a>
 The evaluation of an ordinary Scheme expression may return a value,
 may never terminate, or may signal an error.  In nondeterministic
 Scheme the evaluation of an expression may in addition result in the
@@ -616,26 +616,26 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 choice point.  The interpretation of nondeterministic Scheme is
 complicated by this extra case.</p><p>
 
-<a name="%_idx_4980" id="%_idx_4980"></a>We will construct the <tt>amb</tt> evaluator for nondeterministic Scheme
-by modifying the analyzing evaluator of section <a href="book-Z-H-26.html#%_sec_4.1.7">4.1.7</a>.<a name="call_footnote_Temp_629" href="#footnote_Temp_629" id="call_footnote_Temp_629"><sup><small>55</small></sup></a>
+<a id="__idx_4980"></a>We will construct the <tt>amb</tt> evaluator for nondeterministic Scheme
+by modifying the analyzing evaluator of section <a href="book-Z-H-26.html#__sec_4.1.7">4.1.7</a>.<a href="#footnote_Temp_629" id="call_footnote_Temp_629"><sup><small>55</small></sup></a>
 As in the analyzing evaluator, evaluation of an expression is
-accomplished by calling an <a name="%_idx_4982" id="%_idx_4982"></a>execution procedure produced by analysis of
+accomplished by calling an <a id="__idx_4982"></a>execution procedure produced by analysis of
 that expression.  The difference between the interpretation of ordinary
 Scheme and the interpretation of nondeterministic Scheme will be entirely
 in the execution procedures.</p><p>
 
-<a name="%_sec_Temp_630" id="%_sec_Temp_630"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_630">Execution procedures and continuations</a></h4><p>
+<a id="__sec_Temp_630"></a>
+</p><h4>Execution procedures and continuations</h4><p>
 
-<a name="%_idx_4984" id="%_idx_4984"></a>
-<a name="%_idx_4986" id="%_idx_4986"></a>Recall that the execution procedures for the ordinary evaluator take
+<a id="__idx_4984"></a>
+<a id="__idx_4986"></a>Recall that the execution procedures for the ordinary evaluator take
 one argument: the environment of execution.  In contrast, the
 execution procedures in the <tt>amb</tt> evaluator take three arguments:
 the environment, and two procedures called <em>continuation
 procedures</em>.  The evaluation of an expression will finish by calling
 one of these two continuations: If the evaluation results in a value,
-the <a name="%_idx_4988" id="%_idx_4988"></a><em>success continuation</em> is called with that value; if the
-evaluation results in the discovery of a dead end, the <a name="%_idx_4990" id="%_idx_4990"></a><em>failure
+the <a id="__idx_4988"></a><em>success continuation</em> is called with that value; if the
+evaluation results in the discovery of a dead end, the <a id="__idx_4990"></a><em>failure
 continuation</em> is called.  Constructing and calling appropriate
 continuations is the mechanism by which the nondeterministic evaluator
 implements backtracking.</p><p>
@@ -660,7 +660,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 continuation is called) when a user program explicitly rejects the
 current line of attack (for example, a call to <tt>require</tt> may
 result in execution of <tt>(amb)</tt>, an expression that always
-fails – see section <a href="#%_sec_4.3.1">4.3.1</a>).  The failure continuation in hand
+fails – see section <a href="#__sec_4.3.1">4.3.1</a>).  The failure continuation in hand
 at that point will cause the most recent choice point to choose
 another alternative.  If there are no more alternatives to be
 considered at that choice point, a failure at an earlier choice point
@@ -709,14 +709,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 </p><p>
 
 
-<a name="%_sec_Temp_631" id="%_sec_Temp_631"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_631">Structure of the evaluator</a></h4><p>
+<a id="__sec_Temp_631"></a>
+</p><h4>Structure of the evaluator</h4><p>
 
-<a name="%_idx_4992" id="%_idx_4992"></a>The syntax- and data-representation procedures for the <tt>amb</tt>
+<a id="__idx_4992"></a>The syntax- and data-representation procedures for the <tt>amb</tt>
 evaluator, and also the basic <tt>analyze</tt> procedure, are identical
-to those in the evaluator of section <a href="book-Z-H-26.html#%_sec_4.1.7">4.1.7</a>,
+to those in the evaluator of section <a href="book-Z-H-26.html#__sec_4.1.7">4.1.7</a>,
 except for the fact that we need additional syntax procedures to
-recognize the <tt>amb</tt> special form:<a name="call_footnote_Temp_632" href="#footnote_Temp_632" id="call_footnote_Temp_632"><sup><small>56</small></sup></a>
+recognize the <tt>amb</tt> special form:<a href="#footnote_Temp_632" id="call_footnote_Temp_632"><sup><small>56</small></sup></a>
 </p><p></p><p><tt>(define (amb? exp) (tagged-list? exp 'amb))<br />
 (define (amb-choices exp) (cdr exp))<br /></tt></p><p></p><p>
 We must also add to the dispatch in <tt>analyze</tt> a clause that will
@@ -724,17 +724,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 
 </p><p></p><p><tt>((amb? exp) (analyze-amb exp))<br /></tt></p><p></p><p></p><p>
 
-The top-level procedure <tt>ambeval</tt> (similar to the version of <tt>eval</tt> given in section <a href="book-Z-H-26.html#%_sec_4.1.7">4.1.7</a>) analyzes the
+The top-level procedure <tt>ambeval</tt> (similar to the version of <tt>eval</tt> given in section <a href="book-Z-H-26.html#__sec_4.1.7">4.1.7</a>) analyzes the
 given expression and applies the resulting execution procedure to the
 given environment, together with two given continuations:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_4994" id="%_idx_4994"></a>(define (ambeval exp env succeed fail)<br />
+</p><p></p><p><tt><a id="__idx_4994"></a>(define (ambeval exp env succeed fail)<br />
   ((analyze exp) env succeed fail))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_4996" id="%_idx_4996"></a><a name="%_idx_4998" id="%_idx_4998"></a><a name="%_idx_5000" id="%_idx_5000"></a>A success continuation is a procedure of two arguments: the value just
+<a id="__idx_4996"></a><a id="__idx_4998"></a><a id="__idx_5000"></a>A success continuation is a procedure of two arguments: the value just
 obtained and another failure continuation to be used if that value leads
 to a subsequent failure. A failure continuation is a procedure of no
-arguments.  So <a name="%_idx_5002" id="%_idx_5002"></a>the general form of an execution procedure is</p><p>
+arguments.  So <a id="__idx_5002"></a>the general form of an execution procedure is</p><p>
 
 </p><p></p><p><tt>(lambda (env succeed fail)<br />
   <em>;; <tt>succeed</tt> is <tt>(lambda (value fail) <tt>...</tt>)</tt></em><br />
@@ -759,10 +759,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 execution procedures call each other.  In going through the following code,
 you should compare each of the execution procedures with the
 corresponding procedure for the ordinary evaluator given in
-section <a href="book-Z-H-26.html#%_sec_4.1.7">4.1.7</a>.</p><p>
+section <a href="book-Z-H-26.html#__sec_4.1.7">4.1.7</a>.</p><p>
 
-<a name="%_sec_Temp_633" id="%_sec_Temp_633"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_633">Simple expressions</a></h4><p>
+<a id="__sec_Temp_633"></a>
+</p><h4>Simple expressions</h4><p>
 
 The execution procedures for the simplest kinds of expressions are
 essentially the same as those for the ordinary evaluator, except for the
@@ -770,7 +770,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 succeed with the value of the expression, passing along the failure
 continuation that was passed to them.</p><p>
 
-<a name="%_idx_5004" id="%_idx_5004"></a>
+<a id="__idx_5004"></a>
 </p><p></p><p><tt>(define (analyze-self-evaluating exp)<br />
   (lambda (env succeed fail)<br />
     (succeed exp fail)))<br />
@@ -790,14 +790,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
                fail))))<br /></tt></p><p></p><p></p><p>
 
 
-<a name="%_idx_5006" id="%_idx_5006"></a>Notice that looking up a variable always “succeeds.”  If <tt>lookup-variable-value</tt> fails to find the variable, it signals an
+<a id="__idx_5006"></a>Notice that looking up a variable always “succeeds.”  If <tt>lookup-variable-value</tt> fails to find the variable, it signals an
 error, as usual.  Such a “failure” indicates a program bug – a
 reference to an unbound variable; it is not an indication that we
 should try another nondeterministic choice instead of the one that is
 currently being tried.</p><p>
 
-<a name="%_sec_Temp_634" id="%_sec_Temp_634"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_634">Conditionals and sequences</a></h4><p>
+<a id="__sec_Temp_634"></a>
+</p><h4>Conditionals and sequences</h4><p>
 
 Conditionals are also handled in a similar way as in the ordinary
 evaluator.  The execution procedure generated by <tt>analyze-if</tt>
@@ -846,8 +846,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
         (error "Empty sequence -- ANALYZE"))<br />
     (loop (car procs) (cdr procs))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_635" id="%_sec_Temp_635"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_635">Definitions and assignments</a></h4><p>
+<a id="__sec_Temp_635"></a>
+</p><h4>Definitions and assignments</h4><p>
 
 Definitions are another case where we must go to some trouble to
 manage the continuations, because it is necessary to evaluate the
@@ -868,7 +868,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
              fail))))<br /></tt></p><p></p><p></p><p>
 
 
-<a name="%_idx_5008" id="%_idx_5008"></a>Assignments are more interesting.  This is the first place where we
+<a id="__idx_5008"></a>Assignments are more interesting.  This is the first place where we
 really use the continuations, rather than just passing them around.
 The execution procedure for assignments starts out like the one for
 definitions.  It first attempts to obtain the new value to be assigned
@@ -879,7 +879,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 we must consider the possibility that this branch of the computation
 might later fail, which will require us to backtrack out of the
 assignment.  Thus, we must arrange to undo the assignment as
-part of the backtracking process.<a name="call_footnote_Temp_636" href="#footnote_Temp_636" id="call_footnote_Temp_636"><sup><small>57</small></sup></a></p><p>
+part of the backtracking process.<a href="#footnote_Temp_636" id="call_footnote_Temp_636"><sup><small>57</small></sup></a></p><p>
 
 This is accomplished by giving <tt>vproc</tt> a success continuation
 (marked with the comment “*1*” below) that saves the old value of
@@ -910,8 +910,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
                             (fail2)))))<br />
              fail))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_637" id="%_sec_Temp_637"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_637">Procedure applications</a></h4><p>
+<a id="__sec_Temp_637"></a>
+</p><h4>Procedure applications</h4><p>
 
 The execution procedure for applications contains no new ideas except
 for the technical complexity of managing the continuations.  This
@@ -962,7 +962,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 accomplished in the same way as for the ordinary evaluator, except for
 the need to manage the continuations.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5012" id="%_idx_5012"></a>(define (execute-application proc args succeed fail)<br />
+</p><p></p><p><tt><a id="__idx_5012"></a>(define (execute-application proc args succeed fail)<br />
   (cond ((primitive-procedure? proc)<br />
          (succeed (apply-primitive-procedure proc args)<br />
                   fail))<br />
@@ -978,11 +978,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
           "Unknown procedure type -- EXECUTE-APPLICATION"<br />
           proc))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_638" id="%_sec_Temp_638"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_638">Evaluating <tt>amb</tt> expressions</a></h4><p>
+<a id="__sec_Temp_638"></a>
+</p><h4>Evaluating <tt>amb</tt> expressions</h4><p>
 
 
-<a name="%_idx_5014" id="%_idx_5014"></a>The <tt>amb</tt> special form is the key element in the nondeterministic
+<a id="__idx_5014"></a>The <tt>amb</tt> special form is the key element in the nondeterministic
 language.  Here we see the essence of the interpretation process and
 the reason for keeping track of the continuations.  The execution
 procedure for <tt>amb</tt> defines a loop <tt>try-next</tt> that cycles
@@ -991,7 +991,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 failure continuation that will try the next one.  When there are no
 more alternatives to try, the entire <tt>amb</tt> expression fails.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5016" id="%_idx_5016"></a>(define (analyze-amb exp)<br />
+</p><p></p><p><tt><a id="__idx_5016"></a>(define (analyze-amb exp)<br />
   (let ((cprocs (map analyze (amb-choices exp))))<br />
     (lambda (env succeed fail)<br />
       (define (try-next choices)<br />
@@ -1003,11 +1003,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
                              (try-next (cdr choices))))))<br />
       (try-next cprocs))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_639" id="%_sec_Temp_639"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_639">Driver loop</a></h4><p>
+<a id="__sec_Temp_639"></a>
+</p><h4>Driver loop</h4><p>
 
-<a name="%_idx_5018" id="%_idx_5018"></a>
-<a name="%_idx_5020" id="%_idx_5020"></a>The driver loop for the <tt>amb</tt> evaluator is complex, due to
+<a id="__idx_5018"></a>
+<a id="__idx_5020"></a>The driver loop for the <tt>amb</tt> evaluator is complex, due to
 the mechanism that permits the user to try again in evaluating an
 expression.  The driver uses a procedure called <tt>internal-loop</tt>,
 which takes as argument a procedure <tt>try-again</tt>.  The intent is
@@ -1031,8 +1031,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 evaluation, so we can invoke the “failure” alternative branch in
 order to search for additional successful evaluations.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5022" id="%_idx_5022"></a>(define input-prompt ";;; Amb-Eval input:")<br />
-(define output-prompt ";;; Amb-Eval value:")<br /><a name="%_idx_5024" id="%_idx_5024"></a>(define (driver-loop)<br />
+</p><p></p><p><tt><a id="__idx_5022"></a>(define input-prompt ";;; Amb-Eval input:")<br />
+(define output-prompt ";;; Amb-Eval value:")<br /><a id="__idx_5024"></a>(define (driver-loop)<br />
   (define (internal-loop try-again)<br />
     (prompt-for-input input-prompt)<br />
     (let ((input (read)))<br />
@@ -1064,14 +1064,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 happen if the user types <tt>try-again</tt> when there is no evaluation
 in progress.</p><p>
 
-</p><p><a name="%_thm_4.50" id="%_thm_4.50"></a>
+</p><p><a id="__thm_4.50"></a>
 <b>Exercise 4.50.</b>  Implement a new special form <tt>ramb</tt> that is like <tt>amb</tt> except that it searches alternatives in a random order, rather
 than from left to right.  Show how this can help with Alyssa's problem
-in exercise <a href="#%_thm_4.49">4.49</a>.
+in exercise <a href="#__thm_4.49">4.49</a>.
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.51" id="%_thm_4.51"></a>
+</p><p><a id="__thm_4.51"></a>
 <b>Exercise 4.51.</b>  Implement a new kind of assignment called <tt>permanent-set!</tt> that
 is not undone upon failure.  For example, we can choose two distinct
 elements from a list and count the number of trials required to make a
@@ -1089,7 +1089,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.52" id="%_thm_4.52"></a>
+</p><p><a id="__thm_4.52"></a>
 <b>Exercise 4.52.</b>  Implement a new construct called <tt>if-fail</tt> that permits the user to
 catch the failure of an expression.  <tt>If-fail</tt> takes two
 expressions.  It evaluates the first expression as usual and returns
@@ -1107,10 +1107,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
          'all-odd)<br /><i>;;; Starting a new problem</i><br /><i>;;; Amb-Eval value:</i><br /><i>8</i><br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.53" id="%_thm_4.53"></a>
+</p><p><a id="__thm_4.53"></a>
 <b>Exercise 4.53.</b>  With <tt>permanent-set!</tt> as described in
-exercise <a href="#%_thm_4.51">4.51</a> and <tt>if-fail</tt> as in
-exercise <a href="#%_thm_4.52">4.52</a>, what will be the result of evaluating
+exercise <a href="#__thm_4.51">4.51</a> and <tt>if-fail</tt> as in
+exercise <a href="#__thm_4.52">4.52</a>, what will be the result of evaluating
 </p><p></p><p><tt>(let ((pairs '()))<br />
   (if-fail (let ((p (prime-sum-pair '(1 3 5 8) '(20 35 110))))<br />
              (permanent-set! pairs (cons p pairs))<br />
@@ -1118,8 +1118,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
            pairs))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.54" id="%_thm_4.54"></a>
-<b>Exercise 4.54.</b>  <a name="%_idx_5026" id="%_idx_5026"></a>If we had not realized that <tt>require</tt> could be implemented as an
+</p><p><a id="__thm_4.54"></a>
+<b>Exercise 4.54.</b>  <a id="__idx_5026"></a>If we had not realized that <tt>require</tt> could be implemented as an
 ordinary procedure that uses <tt>amb</tt>, to be defined by the user as
 part of a nondeterministic program, we would have had to implement it
 as a special form.  This would require syntax procedures</p><p>
@@ -1145,23 +1145,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 </p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_598" href="#call_footnote_Temp_598" id="footnote_Temp_598"><sup><small>42</small></sup></a> We assume that we have previously defined a
+</p><div class="footnote"><p><a href="#call_footnote_Temp_598" id="footnote_Temp_598"><sup><small>42</small></sup></a> We assume that we have previously defined a
 procedure <tt>prime?</tt> that tests whether numbers are prime.  Even with
 <tt>prime?</tt> defined, the <tt>prime-sum-pair</tt> procedure may look
 suspiciously like the unhelpful “pseudo-Lisp” attempt to define the
 square-root function, which we described at the beginning of
-section <a href="book-Z-H-10.html#%_sec_1.1.7">1.1.7</a>.  In fact, a square-root procedure along those
+section <a href="book-Z-H-10.html#__sec_1.1.7">1.1.7</a>.  In fact, a square-root procedure along those
 lines can actually be formulated as a nondeterministic program.
 By incorporating a search mechanism into the evaluator, we
-are eroding the <a name="%_idx_4816" id="%_idx_4816"></a><a name="%_idx_4818" id="%_idx_4818"></a>distinction between purely declarative descriptions
+are eroding the <a id="__idx_4816"></a><a id="__idx_4818"></a>distinction between purely declarative descriptions
 and imperative specifications of how to compute answers.  We'll go
 even farther in this direction in
-section <a href="book-Z-H-29.html#%_sec_4.4">4.4</a>.
+section <a href="book-Z-H-29.html#__sec_4.4">4.4</a>.
 
-</p><p><a name="footnote_Temp_599" href="#call_footnote_Temp_599" id="footnote_Temp_599"><sup><small>43</small></sup></a> The idea of <tt>amb</tt> for nondeterministic programming was
-<a name="%_idx_4824" id="%_idx_4824"></a>first described in 1961 by John McCarthy (see McCarthy 1967).
+</p><p><a href="#call_footnote_Temp_599" id="footnote_Temp_599"><sup><small>43</small></sup></a> The idea of <tt>amb</tt> for nondeterministic programming was
+<a id="__idx_4824"></a>first described in 1961 by John McCarthy (see McCarthy 1967).
 
-</p><p><a name="footnote_Temp_600" href="#call_footnote_Temp_600" id="footnote_Temp_600"><sup><small>44</small></sup></a> In actuality, the distinction between nondeterministically
+</p><p><a href="#call_footnote_Temp_600" id="footnote_Temp_600"><sup><small>44</small></sup></a> In actuality, the distinction between nondeterministically
 returning a single choice and returning all choices depends somewhat
 on our point of view.  From the perspective of the code that uses the
 value, the nondeterministic choice returns a single value.  From the
@@ -1169,117 +1169,117 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.3">4.3  Variations on a Scheme –
 choice potentially returns all possible values, and the computation
 branches so that each value is investigated separately.
 
-</p><p><a name="footnote_Temp_601" href="#call_footnote_Temp_601" id="footnote_Temp_601"><sup><small>45</small></sup></a> One might object that this is a hopelessly
+</p><p><a href="#call_footnote_Temp_601" id="footnote_Temp_601"><sup><small>45</small></sup></a> One might object that this is a hopelessly
 inefficient mechanism.  It might require millions of processors to
 solve some easily stated problem this way, and most of the time most
 of those processors would be idle.  This objection should be taken in
 the context of history.  Memory used to be considered just such an
-expensive commodity.  <a name="%_idx_4838" id="%_idx_4838"></a>In 1964 a megabyte of RAM cost about $400,000.
+expensive commodity.  <a id="__idx_4838"></a>In 1964 a megabyte of RAM cost about $400,000.
 Now every personal computer has many megabytes of RAM, and most of the
 time most of that RAM is unused.  It is hard to underestimate the cost
 of mass-produced electronics.
 
-</p><p><a name="footnote_Temp_602" href="#call_footnote_Temp_602" id="footnote_Temp_602"><sup><small>46</small></sup></a> Automagically: “Automatically, but in a way
+</p><p><a href="#call_footnote_Temp_602" id="footnote_Temp_602"><sup><small>46</small></sup></a> Automagically: “Automatically, but in a way
 which, for some reason (typically because it is too complicated, or
 too ugly, or perhaps even too trivial), the speaker doesn't feel like
 explaining.”  (Steele 1983, Raymond 1993)
 
-</p><p><a name="footnote_Temp_603" href="#call_footnote_Temp_603" id="footnote_Temp_603"><sup><small>47</small></sup></a> The integration of automatic search strategies
-<a name="%_idx_4860" id="%_idx_4860"></a>into programming languages has had a long and checkered history.  The
+</p><p><a href="#call_footnote_Temp_603" id="footnote_Temp_603"><sup><small>47</small></sup></a> The integration of automatic search strategies
+<a id="__idx_4860"></a>into programming languages has had a long and checkered history.  The
 first suggestions that nondeterministic algorithms might be elegantly
 encoded in a programming language with search and automatic
-backtracking came from <a name="%_idx_4862" id="%_idx_4862"></a>Robert Floyd (1967).  <a name="%_idx_4864" id="%_idx_4864"></a>Carl Hewitt
-(1969) invented a programming language called <a name="%_idx_4866" id="%_idx_4866"></a>Planner that explicitly
+backtracking came from <a id="__idx_4862"></a>Robert Floyd (1967).  <a id="__idx_4864"></a>Carl Hewitt
+(1969) invented a programming language called <a id="__idx_4866"></a>Planner that explicitly
 supported automatic chronological backtracking, providing for a
-built-in depth-first search strategy.  <a name="%_idx_4868" id="%_idx_4868"></a><a name="%_idx_4870" id="%_idx_4870"></a><a name="%_idx_4872" id="%_idx_4872"></a>Sussman, Winograd, and Charniak
-(1971) implemented a subset of this language, called <a name="%_idx_4874" id="%_idx_4874"></a>MicroPlanner,
+built-in depth-first search strategy.  <a id="__idx_4868"></a><a id="__idx_4870"></a><a id="__idx_4872"></a>Sussman, Winograd, and Charniak
+(1971) implemented a subset of this language, called <a id="__idx_4874"></a>MicroPlanner,
 which was used to support work in problem solving and robot planning.
 Similar ideas, arising from logic and theorem proving, led to the
-genesis in Edinburgh and Marseille of the elegant language <a name="%_idx_4876" id="%_idx_4876"></a>Prolog
-(which we will discuss in section <a href="book-Z-H-29.html#%_sec_4.4">4.4</a>).  After
-sufficient frustration with automatic search, <a name="%_idx_4878" id="%_idx_4878"></a><a name="%_idx_4880" id="%_idx_4880"></a>McDermott and Sussman
-(1972) developed a language called <a name="%_idx_4882" id="%_idx_4882"></a>Conniver, which included mechanisms
+genesis in Edinburgh and Marseille of the elegant language <a id="__idx_4876"></a>Prolog
+(which we will discuss in section <a href="book-Z-H-29.html#__sec_4.4">4.4</a>).  After
+sufficient frustration with automatic search, <a id="__idx_4878"></a><a id="__idx_4880"></a>McDermott and Sussman
+(1972) developed a language called <a id="__idx_4882"></a>Conniver, which included mechanisms
 for placing the search strategy under programmer control.  This proved
-unwieldy, however, and <a name="%_idx_4884" id="%_idx_4884"></a><a name="%_idx_4886" id="%_idx_4886"></a>Sussman and Stallman (1975) found a more
+unwieldy, however, and <a id="__idx_4884"></a><a id="__idx_4886"></a>Sussman and Stallman (1975) found a more
 tractable approach while investigating methods of symbolic analysis
 for electrical circuits.  They developed a non-chronological
 backtracking scheme that was based on tracing out the logical
 dependencies connecting facts, a technique that has come to be known
-as <a name="%_idx_4888" id="%_idx_4888"></a><em>dependency-directed backtracking</em>.  Although their method was
+as <a id="__idx_4888"></a><em>dependency-directed backtracking</em>.  Although their method was
 complex, it produced reasonably efficient programs because it did
-little redundant search.  <a name="%_idx_4890" id="%_idx_4890"></a><a name="%_idx_4892" id="%_idx_4892"></a>Doyle (1979) and McAllester (1978, 1980)
+little redundant search.  <a id="__idx_4890"></a><a id="__idx_4892"></a>Doyle (1979) and McAllester (1978, 1980)
 generalized and clarified the methods of Stallman and Sussman,
 developing a new paradigm for formulating search that is now called
-<a name="%_idx_4894" id="%_idx_4894"></a><em>truth maintenance</em>.  Modern problem-solving systems all
-use some form of truth-maintenance system as a substrate.  See <a name="%_idx_4896" id="%_idx_4896"></a><a name="%_idx_4898" id="%_idx_4898"></a>Forbus
+<a id="__idx_4894"></a><em>truth maintenance</em>.  Modern problem-solving systems all
+use some form of truth-maintenance system as a substrate.  See <a id="__idx_4896"></a><a id="__idx_4898"></a>Forbus
 and deKleer 1993 for a discussion of elegant ways to build
 truth-maintenance systems and applications using truth maintenance.
-<a name="%_idx_4900" id="%_idx_4900"></a><a name="%_idx_4902" id="%_idx_4902"></a><a name="%_idx_4904" id="%_idx_4904"></a>Zabih, McAllester, and
+<a id="__idx_4900"></a><a id="__idx_4902"></a><a id="__idx_4904"></a>Zabih, McAllester, and
 Chapman 1987 describes a nondeterministic extension to Scheme that
 is based on <tt>amb</tt>; it is similar to the interpreter described in
 this section, but more sophisticated, because it uses
 dependency-directed backtracking rather than chronological
-<a name="%_idx_4906" id="%_idx_4906"></a>backtracking.  Winston 1992 gives an introduction to both kinds of
+<a id="__idx_4906"></a>backtracking.  Winston 1992 gives an introduction to both kinds of
 backtracking.
 
-</p><p><a name="footnote_Temp_609" href="#call_footnote_Temp_609" id="footnote_Temp_609"><sup><small>48</small></sup></a> Our program uses the following procedure to determine
+</p><p><a href="#call_footnote_Temp_609" id="footnote_Temp_609"><sup><small>48</small></sup></a> Our program uses the following procedure to determine
 if the elements of a list are distinct:
-</p><p></p><p><tt><a name="%_idx_4934" id="%_idx_4934"></a>(define (distinct? items)<br />
+</p><p></p><p><tt><a id="__idx_4934"></a>(define (distinct? items)<br />
   (cond ((null? items) true)<br />
         ((null? (cdr items)) true)<br />
         ((member (car items) (cdr items)) false)<br />
         (else (distinct? (cdr items)))))<br /></tt></p><p></p><p>
-<a name="%_idx_4936" id="%_idx_4936"></a><tt>Member</tt> is like <tt>memq</tt> except that it uses <tt>equal?</tt> instead
+<a id="__idx_4936"></a><tt>Member</tt> is like <tt>memq</tt> except that it uses <tt>equal?</tt> instead
 of <tt>eq?</tt> to test for equality.
 
 
-</p><p><a name="footnote_Temp_616" href="#call_footnote_Temp_616" id="footnote_Temp_616"><sup><small>49</small></sup></a> This is taken from a booklet called “Problematical
+</p><p><a href="#call_footnote_Temp_616" id="footnote_Temp_616"><sup><small>49</small></sup></a> This is taken from a booklet called “Problematical
 Recreations,” published in the 1960s by Litton Industries, where it
 is attributed to the <em>Kansas State Engineer</em>.
 
-</p><p><a name="footnote_Temp_619" href="#call_footnote_Temp_619" id="footnote_Temp_619"><sup><small>50</small></sup></a> Here we use the convention that the first element of each list
+</p><p><a href="#call_footnote_Temp_619" id="footnote_Temp_619"><sup><small>50</small></sup></a> Here we use the convention that the first element of each list
 designates the part of speech for the rest of the words in the list.
 
-</p><p><a name="footnote_Temp_620" href="#call_footnote_Temp_620" id="footnote_Temp_620"><sup><small>51</small></sup></a> Notice that <tt>parse-word</tt> uses <tt>set!</tt> to modify the
+</p><p><a href="#call_footnote_Temp_620" id="footnote_Temp_620"><sup><small>51</small></sup></a> Notice that <tt>parse-word</tt> uses <tt>set!</tt> to modify the
 unparsed input list.  For this to work, our <tt>amb</tt> evaluator must
 undo the effects of <tt>set!</tt> operations when it backtracks.
 
-</p><p><a name="footnote_Temp_621" href="#call_footnote_Temp_621" id="footnote_Temp_621"><sup><small>52</small></sup></a> Observe that this
+</p><p><a href="#call_footnote_Temp_621" id="footnote_Temp_621"><sup><small>52</small></sup></a> Observe that this
 definition is recursive – a verb may be followed by any number
 of prepositional phrases.
 
-</p><p><a name="footnote_Temp_626" href="#call_footnote_Temp_626" id="footnote_Temp_626"><sup><small>53</small></sup></a> This kind of grammar can become arbitrarily complex, but it
-<a name="%_idx_4972" id="%_idx_4972"></a>is only a toy as far as real language understanding is concerned.
+</p><p><a href="#call_footnote_Temp_626" id="footnote_Temp_626"><sup><small>53</small></sup></a> This kind of grammar can become arbitrarily complex, but it
+<a id="__idx_4972"></a>is only a toy as far as real language understanding is concerned.
 Real natural-language understanding by computer requires an elaborate
 mixture of syntactic analysis and interpretation of meaning.  On the
 other hand, even toy parsers can be useful in supporting flexible
 command languages for programs such as information-retrieval systems.
-<a name="%_idx_4974" id="%_idx_4974"></a>Winston 1992 discusses computational approaches to real
+<a id="__idx_4974"></a>Winston 1992 discusses computational approaches to real
 language understanding and also the applications of simple grammars to
 command languages.
 
-</p><p><a name="footnote_Temp_628" href="#call_footnote_Temp_628" id="footnote_Temp_628"><sup><small>54</small></sup></a> Although Alyssa's idea works just fine (and is
+</p><p><a href="#call_footnote_Temp_628" id="footnote_Temp_628"><sup><small>54</small></sup></a> Although Alyssa's idea works just fine (and is
 surprisingly simple), the sentences that it generates are a bit
 boring – they don't sample the possible sentences of this language in
 a very interesting way.  In fact, the grammar is highly recursive in
 many places, and Alyssa's technique “falls into” one of these recursions and
-gets stuck.  See exercise <a href="#%_thm_4.50">4.50</a> for a way to deal with this.
+gets stuck.  See exercise <a href="#__thm_4.50">4.50</a> for a way to deal with this.
 
-</p><p><a name="footnote_Temp_629" href="#call_footnote_Temp_629" id="footnote_Temp_629"><sup><small>55</small></sup></a> We chose to implement the lazy evaluator in
-section <a href="book-Z-H-27.html#%_sec_4.2">4.2</a> as a modification of the ordinary
-metacircular evaluator of section <a href="book-Z-H-26.html#%_sec_4.1.1">4.1.1</a>.  In
+</p><p><a href="#call_footnote_Temp_629" id="footnote_Temp_629"><sup><small>55</small></sup></a> We chose to implement the lazy evaluator in
+section <a href="book-Z-H-27.html#__sec_4.2">4.2</a> as a modification of the ordinary
+metacircular evaluator of section <a href="book-Z-H-26.html#__sec_4.1.1">4.1.1</a>.  In
 contrast, we will base the <tt>amb</tt> evaluator on the analyzing evaluator
-of section <a href="book-Z-H-26.html#%_sec_4.1.7">4.1.7</a>, because the execution procedures
+of section <a href="book-Z-H-26.html#__sec_4.1.7">4.1.7</a>, because the execution procedures
 in that evaluator provide a convenient framework for implementing
 backtracking.
 
-</p><p><a name="footnote_Temp_632" href="#call_footnote_Temp_632" id="footnote_Temp_632"><sup><small>56</small></sup></a> We assume that the evaluator supports <tt>let</tt>
-(see exercise <a href="book-Z-H-26.html#%_thm_4.22">4.22</a>),
+</p><p><a href="#call_footnote_Temp_632" id="footnote_Temp_632"><sup><small>56</small></sup></a> We assume that the evaluator supports <tt>let</tt>
+(see exercise <a href="book-Z-H-26.html#__thm_4.22">4.22</a>),
 which we have used in our nondeterministic programs.
 
-</p><p><a name="footnote_Temp_636" href="#call_footnote_Temp_636" id="footnote_Temp_636"><sup><small>57</small></sup></a> We didn't worry about undoing definitions, since we can
-<a name="%_idx_5010" id="%_idx_5010"></a>assume that internal definitions are scanned out
-(section <a href="book-Z-H-26.html#%_sec_4.1.6">4.1.6</a>).
+</p><p><a href="#call_footnote_Temp_636" id="footnote_Temp_636"><sup><small>57</small></sup></a> We didn't worry about undoing definitions, since we can
+<a id="__idx_5010"></a>assume that internal definitions are scanned out
+(section <a href="book-Z-H-26.html#__sec_4.1.6">4.1.6</a>).
 
 </p></div>
 
diff --git a/src/OEBPS/book-Z-H-29.html b/src/OEBPS/book-Z-H-29.html
index d5d7fb5..b613e6f 100644
--- a/src/OEBPS/book-Z-H-29.html
+++ b/src/OEBPS/book-Z-H-29.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,12 +13,12 @@
 
 
 
-<a name="%_sec_4.4" id="%_sec_4.4"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><p>
+<a id="__sec_4.4"></a>
+<h2>4.4  Logic Programming</h2><p>
 
 
-<a name="%_idx_5028" id="%_idx_5028"></a>
-<a name="%_idx_5030" id="%_idx_5030"></a><a name="%_idx_5032" id="%_idx_5032"></a><a name="%_idx_5034" id="%_idx_5034"></a><a name="%_idx_5036" id="%_idx_5036"></a>In chapter 1 we stressed that computer science deals with imperative
+<a id="__idx_5028"></a>
+<a id="__idx_5030"></a><a id="__idx_5032"></a><a id="__idx_5034"></a><a id="__idx_5036"></a>In chapter 1 we stressed that computer science deals with imperative
 (how to) knowledge, whereas mathematics deals with declarative (what
 is) knowledge.  Indeed, programming languages require that the
 programmer express knowledge in a form that indicates the step-by-step
@@ -37,7 +37,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 computations (computations with well-defined inputs and outputs).
 There are, however, radically different programming languages that
 relax this bias.  We saw one such example in
-section <a href="book-Z-H-22.html#%_sec_3.3.5">3.3.5</a>, where the objects of computation were
+section <a href="book-Z-H-22.html#__sec_3.3.5">3.3.5</a>, where the objects of computation were
 arithmetic constraints.  In a constraint system the direction and the
 order of computation are not so well specified; in carrying out a
 computation the system must therefore provide more detailed “how to”
@@ -51,24 +51,24 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 
 
 The nondeterministic program evaluator of
-section <a href="book-Z-H-28.html#%_sec_4.3">4.3</a> also moves away from the
+section <a href="book-Z-H-28.html#__sec_4.3">4.3</a> also moves away from the
 view that programming is about constructing algorithms for computing
 unidirectional functions.  In a nondeterministic language, expressions
 can have more than one value, and, as a result, the computation is
-<a name="%_idx_5038" id="%_idx_5038"></a>dealing with relations rather than with
+<a id="__idx_5038"></a>dealing with relations rather than with
 single-valued functions.  Logic programming extends this idea by
 combining a relational vision of programming with a powerful kind of
-symbolic pattern matching called <em>unification</em>.<a name="call_footnote_Temp_645" href="#footnote_Temp_645" id="call_footnote_Temp_645"><sup><small>58</small></sup></a></p><p>
+symbolic pattern matching called <em>unification</em>.<a href="#footnote_Temp_645" id="call_footnote_Temp_645"><sup><small>58</small></sup></a></p><p>
 
-<a name="%_idx_5070" id="%_idx_5070"></a><a name="%_idx_5072" id="%_idx_5072"></a>This approach, when it works, can be a very powerful way to write
+<a id="__idx_5070"></a><a id="__idx_5072"></a>This approach, when it works, can be a very powerful way to write
 programs.  Part of the power comes from the fact that a single “what
 is” fact can be used to solve a number of different problems that
 would have different “how to” components.  As an example, consider
-the <a name="%_idx_5074" id="%_idx_5074"></a><tt>append</tt> operation, which takes two lists as arguments and
+the <a id="__idx_5074"></a><tt>append</tt> operation, which takes two lists as arguments and
 combines their elements to form a single list.  In a procedural
 language such as Lisp, we could define <tt>append</tt> in terms of the
 basic list constructor <tt>cons</tt>, as we did in
-section <a href="book-Z-H-15.html#%_sec_2.2.1">2.2.1</a>:</p><p>
+section <a href="book-Z-H-15.html#__sec_2.2.1">2.2.1</a>:</p><p>
 
 </p><p></p><p><tt>(define (append x y)<br />
   (if (null? x)<br />
@@ -83,7 +83,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 
 </p></li><li>For any <tt>u</tt>,  <tt>v</tt>,  <tt>y</tt>, and <tt>z</tt>,
  <tt>(cons u v)</tt> and <tt>y</tt> <tt>append</tt> to form <tt>(cons u z)</tt>
-if <tt>v</tt> and <tt>y</tt> <tt>append</tt> to form <tt>z</tt>.<a name="call_footnote_Temp_646" href="#footnote_Temp_646" id="call_footnote_Temp_646"><sup><small>59</small></sup></a>
+if <tt>v</tt> and <tt>y</tt> <tt>append</tt> to form <tt>z</tt>.<a href="#footnote_Temp_646" id="call_footnote_Temp_646"><sup><small>59</small></sup></a>
 </li></ul><p></p><p>
 
 Using the <tt>append</tt> procedure, we can answer questions such as
@@ -103,25 +103,25 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 d)</tt>.
 </p></blockquote><p>
 
-<a name="%_idx_5076" id="%_idx_5076"></a><a name="%_idx_5078" id="%_idx_5078"></a>In a logic programming language, the programmer writes an <tt>append</tt>
+<a id="__idx_5076"></a><a id="__idx_5078"></a>In a logic programming language, the programmer writes an <tt>append</tt>
 “procedure” by stating the two rules about <tt>append</tt> given above.
 “How to” knowledge is provided automatically by the interpreter to
 allow this single pair of rules to be used to answer all three types
-of questions about <tt>append</tt>.<a name="call_footnote_Temp_647" href="#footnote_Temp_647" id="call_footnote_Temp_647"><sup><small>60</small></sup></a></p><p>
+of questions about <tt>append</tt>.<a href="#footnote_Temp_647" id="call_footnote_Temp_647"><sup><small>60</small></sup></a></p><p>
 
 Contemporary logic programming languages (including the one we
 implement here) have substantial deficiencies, in that their general
 “how to” methods can lead them into spurious infinite loops or other
 undesirable behavior.
-Logic programming is an active field of research in computer science.<a name="call_footnote_Temp_648" href="#footnote_Temp_648" id="call_footnote_Temp_648"><sup><small>61</small></sup></a></p><p>
+Logic programming is an active field of research in computer science.<a href="#footnote_Temp_648" id="call_footnote_Temp_648"><sup><small>61</small></sup></a></p><p>
 
 Earlier in this chapter we explored the technology of implementing
 interpreters and described the elements that are essential to an
 interpreter for a Lisp-like language (indeed, to an interpreter for
 any conventional language).  Now we will apply these ideas to discuss
 an interpreter for a logic programming language.  We call this
-<a name="%_idx_5090" id="%_idx_5090"></a>language the <em>query language</em>, because it is very useful for
-retrieving information from data bases by formulating <a name="%_idx_5092" id="%_idx_5092"></a><em>queries</em>,
+<a id="__idx_5090"></a>language the <em>query language</em>, because it is very useful for
+retrieving information from data bases by formulating <a id="__idx_5092"></a><em>queries</em>,
 or questions, expressed in the language.  Even though the query
 language is very different from Lisp, we will find it convenient to
 describe the language in terms of the same general framework we have
@@ -131,8 +131,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 to regard complex elements as single conceptual units.  An interpreter
 for a logic programming language is considerably more complex than an
 interpreter for a language like Lisp.  Nevertheless, we will see
-<a name="%_idx_5094" id="%_idx_5094"></a>that our query-language interpreter contains many of the same elements
-found in the interpreter of section <a href="book-Z-H-26.html#%_sec_4.1">4.1</a>.  In particular,
+<a id="__idx_5094"></a>that our query-language interpreter contains many of the same elements
+found in the interpreter of section <a href="book-Z-H-26.html#__sec_4.1">4.1</a>.  In particular,
 there will be an “eval” part that classifies expressions according
 to type and an “apply” part that implements the language's
 abstraction mechanism (procedures in the case of Lisp, and <em>rules</em>
@@ -143,27 +143,27 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 that we make substantial use of streams, which were introduced in
 chapter 3.
 
-<a name="%_sec_4.4.1" id="%_sec_4.4.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_4.4.1">4.4.1  Deductive Information Retrieval</a></h3><p>
+<a id="__sec_4.4.1"></a>
+</p><h3>4.4.1  Deductive Information Retrieval</h3><p>
 
 
-<a name="%_idx_5096" id="%_idx_5096"></a>
-<a name="%_idx_5098" id="%_idx_5098"></a>Logic programming excels in providing interfaces to data bases for
+<a id="__idx_5096"></a>
+<a id="__idx_5098"></a>Logic programming excels in providing interfaces to data bases for
 information retrieval.  The query language we shall implement in this
 chapter is designed to be used in this way.</p><p>
 
 In order to illustrate what the query system does, we will show how it
 can be used to manage the data base of personnel records for
-<a name="%_idx_5100" id="%_idx_5100"></a>Microshaft, a thriving high-technology company in the
+<a id="__idx_5100"></a>Microshaft, a thriving high-technology company in the
 Boston area.  The language provides pattern-directed access to
 personnel information and can also take advantage of general rules in
 order to make logical deductions.</p><p>
 
-<a name="%_sec_Temp_649" id="%_sec_Temp_649"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_649">A sample data base</a></h4><p>
+<a id="__sec_Temp_649"></a>
+</p><h4>A sample data base</h4><p>
 
-<a name="%_idx_5102" id="%_idx_5102"></a>
-<a name="%_idx_5104" id="%_idx_5104"></a><a name="%_idx_5106" id="%_idx_5106"></a>The personnel data base for Microshaft
+<a id="__idx_5102"></a>
+<a id="__idx_5104"></a><a id="__idx_5106"></a>The personnel data base for Microshaft
 contains <em>assertions</em> about company personnel.  Here is the
 information about Ben Bitdiddle, the resident computer wizard:</p><p>
 
@@ -234,14 +234,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 A computer programmer could fill in for a trainee:
 </p><p></p><p><tt>(can-do-job (computer programmer)<br />
             (computer programmer trainee))<br /></tt></p><p></p><p>
-<a name="%_idx_5108" id="%_idx_5108"></a>Also, as is well known,
+<a id="__idx_5108"></a>Also, as is well known,
 </p><p></p><p><tt>(can-do-job (administration secretary)<br />
             (administration big wheel))<br /></tt></p><p></p><p>
 
-<a name="%_sec_Temp_650" id="%_sec_Temp_650"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_650">Simple queries</a></h4><p>
+<a id="__sec_Temp_650"></a>
+</p><h4>Simple queries</h4><p>
 
-<a name="%_idx_5110" id="%_idx_5110"></a>
+<a id="__idx_5110"></a>
 The query language allows users to retrieve information from the data
 base by posing queries in response to the system's prompt.  For
 example, to find all computer programmers one can say</p><p>
@@ -255,12 +255,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 (job (Fect Cy D) (computer programmer))<br /></tt></p><p></p><p></p><p>
 
 
-<a name="%_idx_5112" id="%_idx_5112"></a>The input query specifies that we are looking for entries in the data
+<a id="__idx_5112"></a>The input query specifies that we are looking for entries in the data
 base that match a certain <em>pattern</em>.  In this example, the pattern
 specifies entries consisting of three items, of which the first is the
 literal symbol <tt>job</tt>, the second can be anything, and the third is
 the literal list <tt>(computer programmer)</tt>.  The “anything” that
-can be the second item in the matching list is specified by a <a name="%_idx_5114" id="%_idx_5114"></a><em>pattern variable</em>, <tt>?x</tt>.  The general form of a pattern variable
+can be the second item in the matching list is specified by a <a id="__idx_5114"></a><em>pattern variable</em>, <tt>?x</tt>.  The general form of a pattern variable
 is a symbol, taken to be the name of the variable, preceded by a
 question mark.  We will see below why it is useful to specify names
 for pattern variables rather than just putting <tt>?</tt> into patterns
@@ -297,7 +297,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 because the third item in the entry is a list of three elements, and
 the pattern's third item specifies that there should be two elements.
 If we wanted to change the pattern so that the third item could be any
-list beginning with <tt>computer</tt>, we could specify<a name="%_idx_5116" id="%_idx_5116"></a><a name="call_footnote_Temp_651" href="#footnote_Temp_651" id="call_footnote_Temp_651"><sup><small>62</small></sup></a></p><p>
+list beginning with <tt>computer</tt>, we could specify<a id="__idx_5116"></a><a href="#footnote_Temp_651" id="call_footnote_Temp_651"><sup><small>62</small></sup></a></p><p>
 
 </p><p></p><p><tt>(job ?x (computer . ?type))<br /></tt></p><p></p><p>
 For example,
@@ -318,8 +318,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 follows:</p><p>
 
 </p><p></p><ul><li>The system finds all assignments to variables in the query
-<a name="%_idx_5118" id="%_idx_5118"></a>pattern that <em>satisfy</em> the pattern – that is, all sets of values
-for the variables such that if the pattern variables are <a name="%_idx_5120" id="%_idx_5120"></a><em>instantiated with</em> (replaced by) the values, the result is in the data
+<a id="__idx_5118"></a>pattern that <em>satisfy</em> the pattern – that is, all sets of values
+for the variables such that if the pattern variables are <a id="__idx_5120"></a><em>instantiated with</em> (replaced by) the values, the result is in the data
 base.<p>
 
 </p></li><li>The system responds to the query by listing all instantiations of the
@@ -332,7 +332,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 pattern for that data base.</p><p>
 
 
-</p><p><a name="%_thm_4.55" id="%_thm_4.55"></a>
+</p><p><a id="__thm_4.55"></a>
 <b>Exercise 4.55.</b>  Give simple queries that retrieve the following information from the
 data base:</p><p>
 
@@ -344,10 +344,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 in Slumerville.
 </p><p>
 
-<a name="%_sec_Temp_653" id="%_sec_Temp_653"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_653">Compound queries</a></h4><p>
+<a id="__sec_Temp_653"></a>
+</p><h4>Compound queries</h4><p>
 
-<a name="%_idx_5122" id="%_idx_5122"></a>
+<a id="__idx_5122"></a>
 Simple queries form the primitive operations of the query language.
 In order to form compound operations, the query language provides
 means of combination.  One thing that makes the query language a logic
@@ -356,7 +356,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 the Lisp primitives, but rather operations built into the query
 language.)</p><p>
 
-<a name="%_idx_5124" id="%_idx_5124"></a>We can use <tt>and</tt> as follows to find the addresses of all the
+<a id="__idx_5124"></a>We can use <tt>and</tt> as follows to find the addresses of all the
 computer programmers:</p><p>
 
 </p><p></p><p><tt>(and (job ?person (computer programmer))<br />
@@ -366,7 +366,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
      (address (Hacker Alyssa P) (Cambridge (Mass Ave) 78)))<br />
 (and (job (Fect Cy D) (computer programmer))<br />
      (address (Fect Cy D) (Cambridge (Ames Street) 3)))<br /></tt></p><p></p><p>
-<a name="%_idx_5126" id="%_idx_5126"></a>In general,
+<a id="__idx_5126"></a>In general,
 </p><p></p><p><tt>(and &lt;<em>query<sub>1</sub></em>&gt; &lt;<em>query<sub>2</sub></em>&gt; <tt>...</tt> &lt;<em>query<sub><em>n</em></sub></em>&gt;)<br /></tt></p><p></p><p>
 is satisfied by all sets of values for the pattern variables that
 simultaneously satisfy &lt;<em>query<sub>1</sub></em>&gt; <tt>...</tt> &lt;<em>query<sub><em>n</em></sub></em>&gt;.</p><p>
@@ -375,7 +375,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 finding all assignments to the pattern variables that satisfy the
 query, then displaying instantiations of the query with those values.</p><p>
 
-<a name="%_idx_5128" id="%_idx_5128"></a>Another means of constructing compound queries is through <tt>or</tt>.
+<a id="__idx_5128"></a>Another means of constructing compound queries is through <tt>or</tt>.
 For example,</p><p>
 
 </p><p></p><p><tt>(or (supervisor ?x (Bitdiddle Ben))<br />
@@ -397,7 +397,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 is satisfied by all sets of values for the pattern variables that
 satisfy at least one of &lt;<em>query<sub>1</sub></em>&gt; <tt>...</tt> &lt;<em>query<sub><em>n</em></sub></em>&gt;.</p><p>
 
-<a name="%_idx_5130" id="%_idx_5130"></a>Compound queries can also be formed with <tt>not</tt>. For example,
+<a id="__idx_5130"></a>Compound queries can also be formed with <tt>not</tt>. For example,
 </p><p></p><p><tt>(and (supervisor ?x (Bitdiddle Ben))<br />
      (not (job ?x (computer programmer))))<br /></tt></p><p></p><p>
 finds all people supervised by Ben Bitdiddle who are not computer
@@ -405,9 +405,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 
 </p><p></p><p><tt>(not &lt;<em>query<sub>1</sub></em>&gt;)<br /></tt></p><p></p><p>
 is satisfied by all assignments to the pattern variables that do not
-satisfy &lt;<em>query<sub>1</sub></em>&gt;.<a name="call_footnote_Temp_654" href="#footnote_Temp_654" id="call_footnote_Temp_654"><sup><small>63</small></sup></a></p><p>
+satisfy &lt;<em>query<sub>1</sub></em>&gt;.<a href="#footnote_Temp_654" id="call_footnote_Temp_654"><sup><small>63</small></sup></a></p><p>
 
-<a name="%_idx_5132" id="%_idx_5132"></a>The final combining form is called <tt>lisp-value</tt>.  When <tt>lisp-value</tt> is the first element of a pattern, it specifies that the
+<a id="__idx_5132"></a>The final combining form is called <tt>lisp-value</tt>.  When <tt>lisp-value</tt> is the first element of a pattern, it specifies that the
 next element is a Lisp predicate to be applied to the rest of the
 (instantiated) elements as arguments.  In general,</p><p>
 
@@ -416,12 +416,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 &lt;<em>predicate</em>&gt; applied to the instantiated
 &lt;<em>arg<sub>1</sub></em>&gt; <tt>...</tt> &lt;<em>arg<sub><em>n</em></sub></em>&gt;
 is true.  For example, to find all people whose salary is greater than
-$30,000 we could write<a name="call_footnote_Temp_655" href="#footnote_Temp_655" id="call_footnote_Temp_655"><sup><small>64</small></sup></a></p><p>
+$30,000 we could write<a href="#footnote_Temp_655" id="call_footnote_Temp_655"><sup><small>64</small></sup></a></p><p>
 
 </p><p></p><p><tt>(and (salary ?person ?amount)<br />
      (lisp-value &gt; ?amount 30000))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_4.56" id="%_thm_4.56"></a>
+</p><p><a id="__thm_4.56"></a>
 <b>Exercise 4.56.</b>  Formulate compound queries that retrieve the following information:</p><p>
 
 </p><p></p><p>a. the names of all people who are supervised by Ben Bitdiddle, together
@@ -435,29 +435,29 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 </p><p>
 </p><p>
 
-<a name="%_sec_Temp_657" id="%_sec_Temp_657"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_657">Rules</a></h4><p>
+<a id="__sec_Temp_657"></a>
+</p><h4>Rules</h4><p>
 
-<a name="%_idx_5136" id="%_idx_5136"></a>
-<a name="%_idx_5138" id="%_idx_5138"></a>In addition to primitive queries and compound queries, the query
+<a id="__idx_5136"></a>
+<a id="__idx_5138"></a>In addition to primitive queries and compound queries, the query
 language provides means for abstracting queries.  These are given by
 <em>rules</em>.  The rule</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5140" id="%_idx_5140"></a>(rule (lives-near ?person-1 ?person-2)<br />
+</p><p></p><p><tt><a id="__idx_5140"></a>(rule (lives-near ?person-1 ?person-2)<br />
       (and (address ?person-1 (?town . ?rest-1))<br />
            (address ?person-2 (?town . ?rest-2))<br />
            (not (same ?person-1 ?person-2))))<br /></tt></p><p></p><p>
 specifies that two people live near each other if they live in the
 same town.  The final <tt>not</tt> clause prevents the rule from saying
 that all people live near themselves.  The <tt>same</tt> relation is
-defined by a very simple rule:<a name="call_footnote_Temp_658" href="#footnote_Temp_658" id="call_footnote_Temp_658"><sup><small>65</small></sup></a></p><p>
+defined by a very simple rule:<a href="#footnote_Temp_658" id="call_footnote_Temp_658"><sup><small>65</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_5142" id="%_idx_5142"></a>(rule (same ?x ?x))<br /></tt></p><p></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_5142"></a>(rule (same ?x ?x))<br /></tt></p><p></p><p></p><p>
 
 The following rule declares that a person is a “wheel” in an
 organization if he supervises someone who is in turn a supervisor:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5144" id="%_idx_5144"></a>(rule (wheel ?person)<br />
+</p><p></p><p><tt><a id="__idx_5144"></a>(rule (wheel ?person)<br />
       (and (supervisor ?middle-manager ?person)<br />
            (supervisor ?x ?middle-manager)))<br /></tt></p><p></p><p></p><p>
 
@@ -465,14 +465,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 
 </p><p></p><p><tt>(rule &lt;<em>conclusion</em>&gt; &lt;<em>body</em>&gt;)<br /></tt></p><p></p><p>
 where &lt;<em>conclusion</em>&gt; is a pattern and &lt;<em>body</em>&gt; is any
-query.<a name="call_footnote_Temp_659" href="#footnote_Temp_659" id="call_footnote_Temp_659"><sup><small>66</small></sup></a> We can think
+query.<a href="#footnote_Temp_659" id="call_footnote_Temp_659"><sup><small>66</small></sup></a> We can think
 of a rule as representing a large (even infinite) set of assertions,
 namely all instantiations of the rule conclusion with variable
 assignments that satisfy the rule body.  When we described simple
 queries (patterns), we said that an assignment to variables satisfies
 a pattern if the instantiated pattern is in the data base.  But the
 pattern needn't be explicitly in the data base as an assertion.  It
-<a name="%_idx_5148" id="%_idx_5148"></a>can be an implicit assertion implied by a rule.  For example, the
+<a id="__idx_5148"></a>can be an implicit assertion implied by a rule.  For example, the
 query
 
 </p><p></p><p><tt>(lives-near ?x (Bitdiddle Ben))<br /></tt></p><p></p><p>
@@ -487,11 +487,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
      (lives-near ?x (Bitdiddle Ben)))<br /></tt></p><p></p><p></p><p>
 
 
-<a name="%_idx_5150" id="%_idx_5150"></a>As in the case of compound procedures, rules can be used as parts of
+<a id="__idx_5150"></a>As in the case of compound procedures, rules can be used as parts of
 other rules (as we saw with the <tt>lives-near</tt> rule above)
 or even be defined recursively.  For instance, the rule
 
-</p><p></p><p><tt><a name="%_idx_5152" id="%_idx_5152"></a>(rule (outranked-by ?staff-person ?boss)<br />
+</p><p></p><p><tt><a id="__idx_5152"></a>(rule (outranked-by ?staff-person ?boss)<br />
       (or (supervisor ?staff-person ?boss)<br />
           (and (supervisor ?staff-person ?middle-manager)<br />
                (outranked-by ?middle-manager ?boss))))<br /></tt></p><p></p><p>
@@ -499,7 +499,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 the boss is the person's supervisor or (recursively) if the person's
 supervisor is outranked by the boss.</p><p>
 
-</p><p><a name="%_thm_4.57" id="%_thm_4.57"></a>
+</p><p><a id="__thm_4.57"></a>
 <b>Exercise 4.57.</b>  Define a rule that says that person 1 can replace person 2 if either
 person 1 does the same job as person 2 or someone who does person 1's
 job can also do person 2's job, and if person 1 and person 2 are not
@@ -512,13 +512,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 are, together with the two salaries.
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.58" id="%_thm_4.58"></a>
+</p><p><a id="__thm_4.58"></a>
 <b>Exercise 4.58.</b>  Define a rule that says that a person is a “big shot” in a division
 if the person works in the division but does not have a supervisor who
 works in the division.
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.59" id="%_thm_4.59"></a>
+</p><p><a id="__thm_4.59"></a>
 <b>Exercise 4.59.</b>  Ben Bitdiddle has missed one meeting too many.
 Fearing that his habit of forgetting meetings could cost him his
 job, Ben decides to do something about it.  He adds all the weekly
@@ -549,8 +549,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 what query should she make to find this out?
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.60" id="%_thm_4.60"></a>
-<b>Exercise 4.60.</b>  <a name="%_idx_5154" id="%_idx_5154"></a>By giving the query
+</p><p><a id="__thm_4.60"></a>
+<b>Exercise 4.60.</b>  <a id="__idx_5154"></a>By giving the query
 </p><p></p><p><tt>(lives-near ?person (Hacker Alyssa P))<br /></tt></p><p></p><p>
 Alyssa P. Hacker is able to find people who live near her, with whom
 she can ride to work.  On the other hand, when she tries to find all
@@ -567,15 +567,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 which each pair appears only once?  Explain.
 </p><p></p><p>
 
-<a name="%_sec_Temp_664" id="%_sec_Temp_664"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_664">Logic as programs</a></h4><p>
+<a id="__sec_Temp_664"></a>
+</p><h4>Logic as programs</h4><p>
 
-<a name="%_idx_5156" id="%_idx_5156"></a>
+<a id="__idx_5156"></a>
 We can regard a rule as a kind of logical implication: <em>If</em> an
 assignment of values to pattern variables satisfies the body, <em>then</em> it satisfies the conclusion.  Consequently, we can regard the
 query language as having the ability to perform <em>logical
 deductions</em> based upon the rules.  As an example, consider the <tt>append</tt> operation described at the beginning of
-section <a href="#%_sec_4.4">4.4</a>.  As we said, <tt>append</tt> can be
+section <a href="#__sec_4.4">4.4</a>.  As we said, <tt>append</tt> can be
 characterized by the following two rules:</p><p>
 
 </p><p></p><ul><li>For any list <tt>y</tt>, the empty list and <tt>y</tt> <tt>append</tt> to form <tt>y</tt>.<p>
@@ -592,12 +592,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 which we can interpret to mean “<tt>x</tt> and <tt>y</tt> <tt>append</tt> to
 form <tt>z</tt>”:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5158" id="%_idx_5158"></a>(rule (append-to-form () ?y ?y))<br />
+</p><p></p><p><tt><a id="__idx_5158"></a>(rule (append-to-form () ?y ?y))<br />
 (rule (append-to-form (?u . ?v) ?y (?u . ?z))<br />
       (append-to-form ?v ?y ?z))<br /></tt></p><p></p><p>
-<a name="%_idx_5160" id="%_idx_5160"></a>The first rule has no body, which means that the conclusion holds for
+<a id="__idx_5160"></a>The first rule has no body, which means that the conclusion holds for
 any value of <tt>?y</tt>.  Note how the second rule makes use of
-<a name="%_idx_5162" id="%_idx_5162"></a>dotted-tail notation to name the <tt>car</tt> and <tt>cdr</tt> of a list.</p><p>
+<a id="__idx_5162"></a>dotted-tail notation to name the <tt>car</tt> and <tt>cdr</tt> of a list.</p><p>
 
 Given these two rules, we can formulate queries that compute the <tt>append</tt> of two lists:
 
@@ -628,13 +628,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 well-determined algorithm in unraveling the rules.  Unfortunately,
 although the system works impressively in the <tt>append</tt> case, the
 general methods may break down in more complex cases, as we will see
-in section <a href="#%_sec_4.4.3">4.4.3</a>.</p><p>
+in section <a href="#__sec_4.4.3">4.4.3</a>.</p><p>
 
-</p><p><a name="%_thm_4.61" id="%_thm_4.61"></a>
+</p><p><a id="__thm_4.61"></a>
 <b>Exercise 4.61.</b>  The following rules implement a <tt>next-to</tt> relation that finds
 adjacent elements of a list:
 
-</p><p></p><p><tt><a name="%_idx_5164" id="%_idx_5164"></a>(rule (?x next-to ?y in (?x ?y . ?u)))<br /><br />
+</p><p></p><p><tt><a id="__idx_5164"></a>(rule (?x next-to ?y in (?x ?y . ?u)))<br /><br />
 (rule (?x next-to ?y in (?v . ?z))<br />
       (?x next-to ?y in ?z))<br /></tt></p><p></p><p>
 What will the response be to the following queries?
@@ -643,16 +643,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 (?x next-to 1 in (2 1 3 1))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.62" id="%_thm_4.62"></a>
-<b>Exercise 4.62.</b>  <a name="%_idx_5166" id="%_idx_5166"></a>Define rules to implement the <tt>last-pair</tt> operation of
-exercise <a href="book-Z-H-15.html#%_thm_2.17">2.17</a>, which returns a list containing the last
+</p><p><a id="__thm_4.62"></a>
+<b>Exercise 4.62.</b>  <a id="__idx_5166"></a>Define rules to implement the <tt>last-pair</tt> operation of
+exercise <a href="book-Z-H-15.html#__thm_2.17">2.17</a>, which returns a list containing the last
 element of a nonempty list.  Check your rules on queries such as
 <tt>(last-pair (3) ?x)</tt>, <tt>(last-pair (1 2 3) ?x)</tt>, and <tt>(last-pair (2 ?x) (3))</tt>.
 Do your rules work correctly on queries such as <tt>(last-pair ?x (3))</tt> ?
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.63" id="%_thm_4.63"></a>
-<b>Exercise 4.63.</b>  <a name="%_idx_5168" id="%_idx_5168"></a><a name="%_idx_5170" id="%_idx_5170"></a>The following data base (see Genesis 4) traces the genealogy of the
+</p><p><a id="__thm_4.63"></a>
+<b>Exercise 4.63.</b>  <a id="__idx_5168"></a><a id="__idx_5170"></a>The following data base (see Genesis 4) traces the genealogy of the
 descendants of Ada back to Adam, by way of Cain:</p><p>
 
 </p><p></p><p><tt>(son Adam Cain)<br />
@@ -670,17 +670,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 more true in biblical times than today) that will enable the query
 system to find the grandson of Cain; the sons of Lamech; the grandsons
 of Methushael.
-(See exercise <a href="#%_thm_4.69">4.69</a> for some rules to
+(See exercise <a href="#__thm_4.69">4.69</a> for some rules to
 deduce more complicated relationships.)
 
 </p><p>
 
-<a name="%_sec_4.4.2" id="%_sec_4.4.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_4.4.2">4.4.2  How the Query System Works</a></h3><p>
+<a id="__sec_4.4.2"></a>
+</p><h3>4.4.2  How the Query System Works</h3><p>
 
 
-<a name="%_idx_5172" id="%_idx_5172"></a>
-In section <a href="#%_sec_4.4.4">4.4.4</a> we will present an
+<a id="__idx_5172"></a>
+In section <a href="#__sec_4.4.4">4.4.4</a> we will present an
 implementation of the query interpreter as a collection of procedures.
 In this section we give an overview that explains the general
 structure of the system independent of low-level implementation
@@ -693,8 +693,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 of search in order to match queries against facts and rules in the
 data base.  One way to do this would be to implement the query system
 as a nondeterministic program, using the <tt>amb</tt> evaluator of
-section <a href="book-Z-H-28.html#%_sec_4.3">4.3</a> (see
-exercise <a href="#%_thm_4.78">4.78</a>).  Another possibility is to manage
+section <a href="book-Z-H-28.html#__sec_4.3">4.3</a> (see
+exercise <a href="#__thm_4.78">4.78</a>).  Another possibility is to manage
 the search with the aid of streams.  Our implementation follows this
 second approach.</p><p>
 
@@ -707,12 +707,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 rules.  Finally, we show how the entire query interpreter fits
 together through a procedure that classifies expressions in a manner
 analogous to the way <tt>eval</tt> classifies expressions for the
-interpreter described in section <a href="book-Z-H-26.html#%_sec_4.1">4.1</a>.</p><p>
+interpreter described in section <a href="book-Z-H-26.html#__sec_4.1">4.1</a>.</p><p>
 
-<a name="%_sec_Temp_668" id="%_sec_Temp_668"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_668">Pattern matching</a></h4><p>
+<a id="__sec_Temp_668"></a>
+</p><h4>Pattern matching</h4><p>
 
-<a name="%_idx_5174" id="%_idx_5174"></a><a name="%_idx_5176" id="%_idx_5176"></a>
+<a id="__idx_5174"></a><a id="__idx_5176"></a>
 A <em>pattern matcher</em> is a program that tests whether some datum
 fits a specified pattern.  For example, the data list <tt>((a b) c (a
 b))</tt> matches the pattern <tt>(?x c ?x)</tt> with the pattern variable
@@ -723,7 +723,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 since that pattern specifies a list whose second element is the symbol
 <tt>a</tt>.</p><p>
 
-<a name="%_idx_5178" id="%_idx_5178"></a><a name="%_idx_5180" id="%_idx_5180"></a>The pattern matcher used by the query system takes as inputs a
+<a id="__idx_5178"></a><a id="__idx_5180"></a>The pattern matcher used by the query system takes as inputs a
 pattern, a datum, and a <em>frame</em> that specifies bindings for
 various pattern variables.  It checks whether the datum matches the
 pattern in a way that is consistent with the bindings already in the
@@ -740,7 +740,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 to <tt>b</tt> and <tt>?x</tt> is unbound will return the given frame
 augmented by a binding of <tt>?x</tt> to <tt>a</tt>.</p><p>
 
-<a name="%_idx_5182" id="%_idx_5182"></a>The pattern matcher is all the mechanism that is needed to process
+<a id="__idx_5182"></a>The pattern matcher is all the mechanism that is needed to process
 simple queries that don't involve rules.  For instance, to process the
 query</p><p>
 
@@ -750,10 +750,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 match we find, we use the frame returned by the match to instantiate
 the pattern with a value for <tt>?x</tt>.
 
-<a name="%_sec_Temp_669" id="%_sec_Temp_669"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_669">Streams of frames</a></h4><p>
+<a id="__sec_Temp_669"></a>
+</p><h4>Streams of frames</h4><p>
 
-<a name="%_idx_5184" id="%_idx_5184"></a><a name="%_idx_5186" id="%_idx_5186"></a>
+<a id="__idx_5184"></a><a id="__idx_5186"></a>
 The testing of patterns against frames is organized through the use of
 streams.  Given a single frame, the matching process runs through the
 data-base entries one by one.  For each data-base entry, the matcher
@@ -762,22 +762,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 entries are collected into a stream, which is passed through a filter
 to weed out the failures.  The result is a stream of all the frames
 that extend the given frame via a match to some assertion in the data
-base.<a name="call_footnote_Temp_670" href="#footnote_Temp_670" id="call_footnote_Temp_670"><sup><small>67</small></sup></a></p><p>
+base.<a href="#footnote_Temp_670" id="call_footnote_Temp_670"><sup><small>67</small></sup></a></p><p>
 
 In our system, a query takes an input stream of frames and performs
 the above matching operation for every frame in the stream, as
-indicated in figure <a href="#%_fig_4.4">4.4</a>.  That is, for each frame in
+indicated in figure <a href="#__fig_4.4">4.4</a>.  That is, for each frame in
 the input stream, the query generates a new stream consisting of all
 extensions to that frame by matches to assertions in the data base.
 All these streams are then combined to form one huge stream, which
 contains all possible extensions of every frame in the input stream.
 This stream is the output of the query.</p><p>
 
-<a name="%_fig_4.4" id="%_fig_4.4"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch4-Z-G-4.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 4.4:</b>  A query processes a stream of frames.</div></caption><tr><td>
+<a id="__fig_4.4"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch4-Z-G-4.gif" alt="ch4-Z-G-4" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 4.4:</b>  A query processes a stream of frames.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_idx_5194" id="%_idx_5194"></a>To answer a simple query, we use the query with an input stream
+<a id="__idx_5194"></a>To answer a simple query, we use the query with an input stream
 consisting of a single empty frame.  The resulting output stream
 contains all extensions to the empty frame (that is, all answers to
 our query).  This stream of frames is then used to generate a stream
@@ -785,14 +785,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 instantiated by the values in each frame, and this is the stream that
 is finally printed.</p><p>
 
-<a name="%_sec_Temp_671" id="%_sec_Temp_671"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_671">Compound queries</a></h4><p>
+<a id="__sec_Temp_671"></a>
+</p><h4>Compound queries</h4><p>
 
-<a name="%_idx_5196" id="%_idx_5196"></a>
+<a id="__idx_5196"></a>
 The real elegance of the stream-of-frames implementation is evident
 when we deal with compound queries.  The processing of compound
 queries makes use of the ability of our matcher to demand that a match
-<a name="%_idx_5198" id="%_idx_5198"></a>be consistent with a specified frame.  For example, to handle the <tt>and</tt> of two queries, such as</p><p>
+<a id="__idx_5198"></a>be consistent with a specified frame.  For example, to handle the <tt>and</tt> of two queries, such as</p><p>
 
 </p><p></p><p><tt>(and (can-do-job ?x (computer programmer trainee))<br />
      (job ?person ?x))<br /></tt></p><p></p><p>
@@ -810,37 +810,37 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 such match will produce a frame containing bindings for <tt>?x</tt> and
 <tt>?person</tt>.  The <tt>and</tt> of two queries can be viewed as a series
 combination of the two component queries, as shown in
-figure <a href="#%_fig_4.5">4.5</a>.  The frames that pass through the first
+figure <a href="#__fig_4.5">4.5</a>.  The frames that pass through the first
 query filter are filtered and further extended by the second query.</p><p>
 
-<a name="%_fig_4.5" id="%_fig_4.5"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch4-Z-G-5.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 4.5:</b>  The <tt>and</tt> combination of two queries is
+<a id="__fig_4.5"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch4-Z-G-5.gif" alt="ch4-Z-G-5" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 4.5:</b>  The <tt>and</tt> combination of two queries is
 produced by operating on the stream of frames in series.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_idx_5200" id="%_idx_5200"></a>Figure <a href="#%_fig_4.6">4.6</a> shows the analogous method for computing the
+<a id="__idx_5200"></a>Figure <a href="#__fig_4.6">4.6</a> shows the analogous method for computing the
 <tt>or</tt> of two queries as a parallel combination of the two component
 queries.  The input stream of frames is extended separately by each
 query.  The two resulting streams are then merged to produce the final
 output stream.</p><p>
 
-<a name="%_fig_4.6" id="%_fig_4.6"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch4-Z-G-6.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 4.6:</b>  The <tt>or</tt> combination of two queries is produced by
+<a id="__fig_4.6"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch4-Z-G-6.gif" alt="ch4-Z-G-6" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 4.6:</b>  The <tt>or</tt> combination of two queries is produced by
 operating on the stream of frames in parallel and merging the
 results.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_idx_5202" id="%_idx_5202"></a>Even from this high-level description, it is apparent that the
+<a id="__idx_5202"></a>Even from this high-level description, it is apparent that the
 processing of compound queries can be slow.
 For example, since a query may produce more than one output frame for
 each input frame, and each query in an <tt>and</tt> gets its input frames
 from the previous query, an <tt>and</tt> query could, in the worst case,
 have to perform a number of matches that is exponential in the number
-of queries (see exercise <a href="#%_thm_4.76">4.76</a>).<a name="call_footnote_Temp_672" href="#footnote_Temp_672" id="call_footnote_Temp_672"><sup><small>68</small></sup></a>
+of queries (see exercise <a href="#__thm_4.76">4.76</a>).<a href="#footnote_Temp_672" id="call_footnote_Temp_672"><sup><small>68</small></sup></a>
 Though systems for handling only simple queries are quite practical,
-dealing with complex queries is extremely difficult.<a name="call_footnote_Temp_673" href="#footnote_Temp_673" id="call_footnote_Temp_673"><sup><small>69</small></sup></a></p><p>
+dealing with complex queries is extremely difficult.<a href="#footnote_Temp_673" id="call_footnote_Temp_673"><sup><small>69</small></sup></a></p><p>
 
-<a name="%_idx_5204" id="%_idx_5204"></a>From the stream-of-frames viewpoint, the <tt>not</tt> of some query acts
+<a id="__idx_5204"></a>From the stream-of-frames viewpoint, the <tt>not</tt> of some query acts
 as a filter that removes all frames for which the query can be
 satisfied.  For instance, given the pattern</p><p>
 
@@ -858,17 +858,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 <tt>?y</tt>.  The <tt>not</tt> clause will then filter
 these by removing all frames in which the binding for <tt>?x</tt>
 satisfies the restriction that <tt>?x</tt> is a computer
-programmer.<a name="call_footnote_Temp_674" href="#footnote_Temp_674" id="call_footnote_Temp_674"><sup><small>70</small></sup></a></p><p>
+programmer.<a href="#footnote_Temp_674" id="call_footnote_Temp_674"><sup><small>70</small></sup></a></p><p>
 
-<a name="%_idx_5206" id="%_idx_5206"></a>The <tt>lisp-value</tt> special form is implemented as a similar filter
+<a id="__idx_5206"></a>The <tt>lisp-value</tt> special form is implemented as a similar filter
 on frame streams.  We use each frame in the stream to instantiate any
 variables in the pattern, then apply the Lisp predicate.  We remove
 from the input stream all frames for which the predicate fails.
 
-<a name="%_sec_Temp_675" id="%_sec_Temp_675"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_675">Unification</a></h4><p>
+<a id="__sec_Temp_675"></a>
+</p><h4>Unification</h4><p>
 
-<a name="%_idx_5208" id="%_idx_5208"></a><a name="%_idx_5210" id="%_idx_5210"></a>
+<a id="__idx_5208"></a><a id="__idx_5210"></a>
 In order to handle rules in the query language, we must be able to
 find the rules whose conclusions match a given query pattern.  Rule
 conclusions are like assertions except that they can contain
@@ -897,7 +897,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 be <tt>c</tt>.  We may think of this process as solving a set of
 equations among the pattern components.  In general, these are
 simultaneous equations, which may require substantial manipulation to
-solve.<a name="call_footnote_Temp_676" href="#footnote_Temp_676" id="call_footnote_Temp_676"><sup><small>71</small></sup></a>  For example, unifying <tt>(?x
+solve.<a href="#footnote_Temp_676" id="call_footnote_Temp_676"><sup><small>71</small></sup></a>  For example, unifying <tt>(?x
 ?x)</tt> and <tt>((a ?y c) (a b ?z))</tt> may be thought of as specifying the
 simultaneous equations</p><p>
 
@@ -913,7 +913,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 
 </p><p></p><p><tt>?x  =  (a b c)<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_5212" id="%_idx_5212"></a><a name="%_idx_5214" id="%_idx_5214"></a>In a successful pattern match, all pattern variables become bound, and
+<a id="__idx_5212"></a><a id="__idx_5214"></a>In a successful pattern match, all pattern variables become bound, and
 the values to which they are bound contain only constants.  This is
 also true of all the examples of unification we have seen so far.  In
 general, however, a successful unification may not completely
@@ -931,12 +931,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 put into the frame.  If a value for <tt>?y</tt> is later determined and
 added to the frame (by a pattern match or unification that is required
 to be consistent with this frame), the previously bound <tt>?x</tt> will
-refer to this value.<a name="call_footnote_Temp_677" href="#footnote_Temp_677" id="call_footnote_Temp_677"><sup><small>72</small></sup></a>
+refer to this value.<a href="#footnote_Temp_677" id="call_footnote_Temp_677"><sup><small>72</small></sup></a>
 
-<a name="%_sec_Temp_678" id="%_sec_Temp_678"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_678">Applying rules</a></h4><p>
+<a id="__sec_Temp_678"></a>
+</p><h4>Applying rules</h4><p>
 
-<a name="%_idx_5216" id="%_idx_5216"></a>
+<a id="__idx_5216"></a>
 Unification is the key to the component of the query system that makes
 inferences from rules. To see how this is accomplished, consider
 processing a query that involves applying a rule, such as</p><p>
@@ -972,7 +972,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 the body of the rule.
 </li></ul><p></p><p>
 
-<a name="%_idx_5218" id="%_idx_5218"></a>Notice how similar this is to the method for applying a procedure in
+<a id="__idx_5218"></a>Notice how similar this is to the method for applying a procedure in
 the <tt>eval</tt>/<tt>apply</tt> evaluator for Lisp:
 </p><p></p><ul><p>
 
@@ -990,10 +990,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 bindings and evaluating the rule or procedure body relative to these.
 </p><p>
 
-<a name="%_sec_Temp_679" id="%_sec_Temp_679"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_679">Simple queries</a></h4><p>
+<a id="__sec_Temp_679"></a>
+</p><h4>Simple queries</h4><p>
 
-<a name="%_idx_5220" id="%_idx_5220"></a>
+<a id="__idx_5220"></a>
 We saw earlier in this section how to evaluate simple queries in the
 absence of rules.  Now that we have seen how to apply rules, we can
 describe how to evaluate simple queries by using both rules and
@@ -1007,7 +1007,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 and<p>
 
 </p></li><li>a stream of extended frames obtained by applying all
-possible rules (using the unifier).<a name="call_footnote_Temp_680" href="#footnote_Temp_680" id="call_footnote_Temp_680"><sup><small>73</small></sup></a>
+possible rules (using the unifier).<a href="#footnote_Temp_680" id="call_footnote_Temp_680"><sup><small>73</small></sup></a>
 </li></ul><p></p><p>
 
 Appending these two streams produces a stream that consists of all the
@@ -1017,32 +1017,32 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 consists of all the ways that any of the frames in the original input
 stream can be extended to produce a match with the given pattern.
 
-<a name="%_sec_Temp_681" id="%_sec_Temp_681"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_681">The query evaluator and the driver loop</a></h4><p>
+<a id="__sec_Temp_681"></a>
+</p><h4>The query evaluator and the driver loop</h4><p>
 
-<a name="%_idx_5226" id="%_idx_5226"></a>
+<a id="__idx_5226"></a>
 Despite the complexity of the underlying matching operations, the
 system is organized much like an evaluator for any language.  The
-procedure that coordinates the matching operations is called <a name="%_idx_5228" id="%_idx_5228"></a><a name="%_idx_5230" id="%_idx_5230"></a><tt>qeval</tt>, and it plays a role analogous to that of the <tt>eval</tt>
+procedure that coordinates the matching operations is called <a id="__idx_5228"></a><a id="__idx_5230"></a><tt>qeval</tt>, and it plays a role analogous to that of the <tt>eval</tt>
 procedure for Lisp.  <tt>Qeval</tt> takes as inputs a query and a stream
 of frames.  Its output is a stream of frames, corresponding to
 successful matches to the query pattern, that extend some frame in the
-input stream, as indicated in figure <a href="#%_fig_4.4">4.4</a>.  Like
+input stream, as indicated in figure <a href="#__fig_4.4">4.4</a>.  Like
 <tt>eval</tt>, <tt>qeval</tt> classifies the different types of expressions
 (queries) and dispatches to an appropriate procedure for each.  There
 is a procedure for each special form (<tt>and</tt>, <tt>or</tt>, <tt>not</tt>,
 and <tt>lisp-value</tt>) and one for simple queries.</p><p>
 
-<a name="%_idx_5232" id="%_idx_5232"></a><a name="%_idx_5234" id="%_idx_5234"></a>The driver loop, which is analogous to the <tt>driver-loop</tt> procedure
+<a id="__idx_5232"></a><a id="__idx_5234"></a>The driver loop, which is analogous to the <tt>driver-loop</tt> procedure
 for the other evaluators in this chapter, reads queries from the
 terminal.  For each query, it calls <tt>qeval</tt> with the query and a
 stream that consists of a single empty frame.  This will produce the
 stream of all possible matches (all possible extensions to the empty
 frame).  For each frame in the resulting stream, it instantiates the
 original query using the values of the variables found in the frame.
-This stream of instantiated queries is then printed.<a name="call_footnote_Temp_682" href="#footnote_Temp_682" id="call_footnote_Temp_682"><sup><small>74</small></sup></a></p><p>
+This stream of instantiated queries is then printed.<a href="#footnote_Temp_682" id="call_footnote_Temp_682"><sup><small>74</small></sup></a></p><p>
 
-<a name="%_idx_5240" id="%_idx_5240"></a><a name="%_idx_5242" id="%_idx_5242"></a>The driver also checks for the special command <tt>assert!</tt>, which
+<a id="__idx_5240"></a><a id="__idx_5242"></a>The driver also checks for the special command <tt>assert!</tt>, which
 signals that the input is not a query but rather an assertion or rule
 to be added to the data base.  For instance,</p><p>
 
@@ -1051,18 +1051,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
                (and (supervisor ?middle-manager ?person)<br />
                     (supervisor ?x ?middle-manager))))<br /></tt></p><p></p><p>
 
-<a name="%_sec_4.4.3" id="%_sec_4.4.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_4.4.3">4.4.3  Is Logic Programming Mathematical Logic?</a></h3><p>
+<a id="__sec_4.4.3"></a>
+</p><h3>4.4.3  Is Logic Programming Mathematical Logic?</h3><p>
 
 
-<a name="%_idx_5244" id="%_idx_5244"></a><a name="%_idx_5246" id="%_idx_5246"></a>
+<a id="__idx_5244"></a><a id="__idx_5246"></a>
 The means of combination used in the query language may at first seem
 identical to the operations <tt>and</tt>, <tt>or</tt>, and <tt>not</tt> of
 mathematical logic, and the application of query-language rules is in
 fact accomplished through a legitimate method of
-<a name="%_idx_5248" id="%_idx_5248"></a>inference.<a name="call_footnote_Temp_683" href="#footnote_Temp_683" id="call_footnote_Temp_683"><sup><small>75</small></sup></a> This identification of the query language with mathematical
+<a id="__idx_5248"></a>inference.<a href="#footnote_Temp_683" id="call_footnote_Temp_683"><sup><small>75</small></sup></a> This identification of the query language with mathematical
 logic is not really valid, though, because the query language provides
-a <a name="%_idx_5252" id="%_idx_5252"></a><em>control structure</em> that interprets the logical statements
+a <a id="__idx_5252"></a><em>control structure</em> that interprets the logical statements
 procedurally.  We can often take advantage of this control structure.
 For example, to find all of the supervisors of programmers we could
 formulate a query in either of two logically equivalent forms:</p><p>
@@ -1073,12 +1073,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 or
 </p><p></p><p><tt>(and (supervisor ?x ?y)<br />
      (job ?x (computer programmer)))<br /></tt></p><p></p><p>
-<a name="%_idx_5254" id="%_idx_5254"></a>If a company has many more supervisors than programmers (the usual
+<a id="__idx_5254"></a>If a company has many more supervisors than programmers (the usual
 case), it is better to use the first form rather than the second
 because the data base must be scanned for each intermediate result
 (frame) produced by the first clause of the <tt>and</tt>.</p><p>
 
-<a name="%_idx_5256" id="%_idx_5256"></a><a name="%_idx_5258" id="%_idx_5258"></a>The aim of logic programming is to provide the programmer with
+<a id="__idx_5256"></a><a id="__idx_5258"></a>The aim of logic programming is to provide the programmer with
 techniques for decomposing a computational problem into two separate
 problems: “what” is to be computed, and “how” this should be
 computed.  This is accomplished by selecting a subset of the
@@ -1105,12 +1105,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 also be regarded as statements of mathematical logic, we can justify
 any “inference” accomplished by a logic program by asserting that
 the same result could be obtained by working entirely within
-mathematical logic.<a name="call_footnote_Temp_684" href="#footnote_Temp_684" id="call_footnote_Temp_684"><sup><small>76</small></sup></a></p><p>
+mathematical logic.<a href="#footnote_Temp_684" id="call_footnote_Temp_684"><sup><small>76</small></sup></a></p><p>
 
-<a name="%_sec_Temp_685" id="%_sec_Temp_685"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_685">Infinite loops</a></h4><p>
+<a id="__sec_Temp_685"></a>
+</p><h4>Infinite loops</h4><p>
 
-<a name="%_idx_5260" id="%_idx_5260"></a>
+<a id="__idx_5260"></a>
 A consequence of the procedural interpretation of logic programs is
 that it is possible to construct hopelessly inefficient programs for
 solving certain problems.  An extreme case of inefficiency occurs when
@@ -1118,7 +1118,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 simple example, suppose we are setting up a data base of famous
 marriages, including</p><p>
 
-<a name="%_idx_5262" id="%_idx_5262"></a></p><p></p><p><tt>(assert! (married Minnie Mickey))<br /></tt></p><p></p><p>
+<a id="__idx_5262"></a></p><p></p><p><tt>(assert! (married Minnie Mickey))<br /></tt></p><p></p><p>
 If we now ask</p><p>
 
 </p><p></p><p><tt>(married Mickey ?who)<br /></tt></p><p></p><p>
@@ -1157,16 +1157,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 a very simple example of the kinds of loops that can occur.
 Collections of interrelated rules can lead to loops that are much
 harder to anticipate, and the appearance of a loop can depend on the order
-of clauses in an <tt>and</tt> (see exercise <a href="#%_thm_4.64">4.64</a>)
+of clauses in an <tt>and</tt> (see exercise <a href="#__thm_4.64">4.64</a>)
 or on low-level details concerning the order in which the system
-processes queries.<a name="call_footnote_Temp_686" href="#footnote_Temp_686" id="call_footnote_Temp_686"><sup><small>77</small></sup></a>
+processes queries.<a href="#footnote_Temp_686" id="call_footnote_Temp_686"><sup><small>77</small></sup></a>
 
-<a name="%_sec_Temp_687" id="%_sec_Temp_687"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_687">Problems with <tt>not</tt></a></h4><p>
+<a id="__sec_Temp_687"></a>
+</p><h4>Problems with <tt>not</tt></h4><p>
 
-<a name="%_idx_5266" id="%_idx_5266"></a>
-<a name="%_idx_5268" id="%_idx_5268"></a>Another quirk in the query system concerns <tt>not</tt>.  Given the data
-base of section <a href="#%_sec_4.4.1">4.4.1</a>, consider the
+<a id="__idx_5266"></a>
+<a id="__idx_5268"></a>Another quirk in the query system concerns <tt>not</tt>.  Given the data
+base of section <a href="#__sec_4.4.1">4.4.1</a>, consider the
 following two queries:</p><p>
 
 </p><p></p><p><tt>(and (supervisor ?x ?y)<br />
@@ -1190,25 +1190,25 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 is processed with a frame in which some of the variables remain
 unbound (as does <tt>?x</tt> in the example above), the system will
 produce unexpected results. Similar problems occur with the use of
-<a name="%_idx_5270" id="%_idx_5270"></a><tt>lisp-value</tt> – the Lisp predicate can't work if some of its
-arguments are unbound.  See exercise <a href="#%_thm_4.77">4.77</a>.</p><p>
+<a id="__idx_5270"></a><tt>lisp-value</tt> – the Lisp predicate can't work if some of its
+arguments are unbound.  See exercise <a href="#__thm_4.77">4.77</a>.</p><p>
 
 There is also a much more serious way in which the <tt>not</tt> of the
 query language differs from the <tt>not</tt> of mathematical logic.  In
 logic, we interpret the statement “not <em>P</em>” to mean that <em>P</em> is not
 true.  In the query system, however, “not <em>P</em>” means that <em>P</em> is not
 deducible from the knowledge in the data base.  For example, given the
-personnel data base of section <a href="#%_sec_4.4.1">4.4.1</a>, the
+personnel data base of section <a href="#__sec_4.4.1">4.4.1</a>, the
 system would happily deduce all sorts of <tt>not</tt> statements, such as
 that Ben Bitdiddle is not a baseball fan, that it is not raining
-outside, and that 2 + 2 is not 4.<a name="call_footnote_Temp_688" href="#footnote_Temp_688" id="call_footnote_Temp_688"><sup><small>78</small></sup></a> In other words, the <tt>not</tt>
-of logic programming languages reflects the so-called <a name="%_idx_5272" id="%_idx_5272"></a><em>closed
+outside, and that 2 + 2 is not 4.<a href="#footnote_Temp_688" id="call_footnote_Temp_688"><sup><small>78</small></sup></a> In other words, the <tt>not</tt>
+of logic programming languages reflects the so-called <a id="__idx_5272"></a><em>closed
 world assumption</em> that all relevant information has been included in
-the data base.<a name="call_footnote_Temp_689" href="#footnote_Temp_689" id="call_footnote_Temp_689"><sup><small>79</small></sup></a>
+the data base.<a href="#footnote_Temp_689" id="call_footnote_Temp_689"><sup><small>79</small></sup></a>
 
-</p><p><a name="%_thm_4.64" id="%_thm_4.64"></a>
-<b>Exercise 4.64.</b>  <a name="%_idx_5276" id="%_idx_5276"></a>Louis Reasoner mistakenly deletes the <tt>outranked-by</tt> rule
-(section <a href="#%_sec_4.4.1">4.4.1</a>) from the data base.  When
+</p><p><a id="__thm_4.64"></a>
+<b>Exercise 4.64.</b>  <a id="__idx_5276"></a>Louis Reasoner mistakenly deletes the <tt>outranked-by</tt> rule
+(section <a href="#__sec_4.4.1">4.4.1</a>) from the data base.  When
 he realizes this, he quickly reinstalls it.  Unfortunately, he makes a
 slight change in the rule, and types it in as</p><p>
 
@@ -1225,10 +1225,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.65" id="%_thm_4.65"></a>
-<b>Exercise 4.65.</b>  <a name="%_idx_5278" id="%_idx_5278"></a>Cy D. Fect, looking forward to the day when he will rise in the
+</p><p><a id="__thm_4.65"></a>
+<b>Exercise 4.65.</b>  <a id="__idx_5278"></a>Cy D. Fect, looking forward to the day when he will rise in the
 organization, gives a query to find all the wheels
-(using the <tt>wheel</tt> rule of section <a href="#%_sec_4.4.1">4.4.1</a>):</p><p>
+(using the <tt>wheel</tt> rule of section <a href="#__sec_4.4.1">4.4.1</a>):</p><p>
 
 </p><p></p><p><tt>(wheel ?who)<br /></tt></p><p></p><p>
 To his surprise, the system responds</p><p>
@@ -1243,8 +1243,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.66" id="%_thm_4.66"></a>
-<b>Exercise 4.66.</b>  <a name="%_idx_5280" id="%_idx_5280"></a>Ben has been generalizing the query system to provide statistics
+</p><p><a id="__thm_4.66"></a>
+<b>Exercise 4.66.</b>  <a id="__idx_5280"></a>Ben has been generalizing the query system to provide statistics
 about the company.  For example, to find the total salaries of all the
 computer programmers one will be able to say</p><p>
 
@@ -1264,7 +1264,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 resulting stream of values to the accumulation function.  Just as Ben
 completes the implementation and is about to try it out, Cy walks by,
 still puzzling over the <tt>wheel</tt> query result in
-exercise <a href="#%_thm_4.65">4.65</a>.  When Cy shows Ben the system's
+exercise <a href="#__thm_4.65">4.65</a>.  When Cy shows Ben the system's
 response, Ben groans, “Oh, no, my simple accumulation scheme won't
 work!”</p><p>
 
@@ -1272,31 +1272,31 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 salvage the situation.
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.67" id="%_thm_4.67"></a>
-<b>Exercise 4.67.</b>  <a name="%_idx_5282" id="%_idx_5282"></a><a name="%_idx_5284" id="%_idx_5284"></a>Devise a way to install a loop detector in the query system so as to
+</p><p><a id="__thm_4.67"></a>
+<b>Exercise 4.67.</b>  <a id="__idx_5282"></a><a id="__idx_5284"></a>Devise a way to install a loop detector in the query system so as to
 avoid the kinds of simple loops illustrated in the text and in
-exercise <a href="#%_thm_4.64">4.64</a>.  The general idea is that the
+exercise <a href="#__thm_4.64">4.64</a>.  The general idea is that the
 system should maintain some sort of history of its current chain of
 deductions and should not begin processing a query that it is already
 working on.  Describe what kind of information (patterns and frames)
 is included in this history, and how the check should be made.  (After
 you study the details of the query-system implementation in
-section <a href="#%_sec_4.4.4">4.4.4</a>, you may want to
+section <a href="#__sec_4.4.4">4.4.4</a>, you may want to
 modify the system to include your loop detector.)
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.68" id="%_thm_4.68"></a>
-<b>Exercise 4.68.</b>  <a name="%_idx_5286" id="%_idx_5286"></a>Define rules to implement the <tt>reverse</tt> operation of
-exercise <a href="book-Z-H-15.html#%_thm_2.18">2.18</a>, which returns a list containing the same
+</p><p><a id="__thm_4.68"></a>
+<b>Exercise 4.68.</b>  <a id="__idx_5286"></a>Define rules to implement the <tt>reverse</tt> operation of
+exercise <a href="book-Z-H-15.html#__thm_2.18">2.18</a>, which returns a list containing the same
 elements as a given list in reverse order.  (Hint: Use <tt>append-to-form</tt>.)
 Can your rules answer both
 <tt>(reverse (1 2 3) ?x)</tt> and <tt>(reverse ?x (1 2 3))</tt> ?
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.69" id="%_thm_4.69"></a>
+</p><p><a id="__thm_4.69"></a>
 <b>Exercise 4.69.</b>  Beginning with the data base and the rules you formulated in
-exercise <a href="#%_thm_4.63">4.63</a>, devise a rule for adding “greats” to
+exercise <a href="#__thm_4.63">4.63</a>, devise a rule for adding “greats” to
 a grandson relationship. This should enable the system to deduce that
 Irad is the great-grandson of Adam, or that Jabal and Jubal are
 the great-great-great-great-great-grandsons of Adam.  (Hint: Represent
@@ -1310,21 +1310,21 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 
 </p><p>
 
-<a name="%_sec_4.4.4" id="%_sec_4.4.4"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_4.4.4">4.4.4  Implementing the Query System</a></h3><p>
+<a id="__sec_4.4.4"></a>
+</p><h3>4.4.4  Implementing the Query System</h3><p>
 
 </p><p>
 
-Section <a href="#%_sec_4.4.2">4.4.2</a> described how the query system
+Section <a href="#__sec_4.4.2">4.4.2</a> described how the query system
 works. Now we fill in the details by presenting a complete
 implementation of the system.</p><p>
 
-<a name="%_sec_4.4.4.1" id="%_sec_4.4.4.1"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_4.4.4.1">4.4.4.1  The Driver Loop and Instantiation</a></h4><p>
+<a id="__sec_4.4.4.1"></a>
+</p><h4>4.4.4.1  The Driver Loop and Instantiation</h4><p>
 
 </p><p>
 
-<a name="%_idx_5288" id="%_idx_5288"></a><a name="%_idx_5290" id="%_idx_5290"></a>The driver loop for the query system repeatedly reads input
+<a id="__idx_5288"></a><a id="__idx_5290"></a>The driver loop for the query system repeatedly reads input
 expressions.  If the expression is a rule or assertion to be added to
 the data base, then the information is added.  Otherwise the
 expression is assumed to be a query.  The driver passes this query to
@@ -1336,8 +1336,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 variables are instantiated with values supplied by the stream of
 frames, and this final stream is printed at the terminal:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5292" id="%_idx_5292"></a>(define input-prompt ";;; Query input:")<br />
-(define output-prompt ";;; Query results:")<br /><a name="%_idx_5294" id="%_idx_5294"></a>(define (query-driver-loop)<br />
+</p><p></p><p><tt><a id="__idx_5292"></a>(define input-prompt ";;; Query input:")<br />
+(define output-prompt ";;; Query results:")<br /><a id="__idx_5294"></a>(define (query-driver-loop)<br />
   (prompt-for-input input-prompt)<br />
   (let ((q (query-syntax-process (read))))<br />
     (cond ((assertion-to-be-added? q)<br />
@@ -1357,23 +1357,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
                               (contract-question-mark v))))<br />
              (qeval q (singleton-stream '()))))<br />
            (query-driver-loop)))))<br /></tt></p><p></p><p>
-<a name="%_idx_5296" id="%_idx_5296"></a>Here, as in the other evaluators in this chapter, we use an abstract
+<a id="__idx_5296"></a>Here, as in the other evaluators in this chapter, we use an abstract
 syntax for the expressions of the query language.
 The implementation of the expression syntax, including the predicate
 <tt>assertion-to-be-added?</tt> and the selector <tt>add-assertion-body</tt>,
-is given in section <a href="#%_sec_4.4.4.7">4.4.4.7</a>.
-<tt>Add-rule-or-assertion!</tt> is defined in section <a href="#%_sec_4.4.4.5">4.4.4.5</a>.</p><p>
+is given in section <a href="#__sec_4.4.4.7">4.4.4.7</a>.
+<tt>Add-rule-or-assertion!</tt> is defined in section <a href="#__sec_4.4.4.5">4.4.4.5</a>.</p><p>
 
 Before doing any processing on an input expression, the driver loop
 transforms it syntactically into a form that makes the processing more
-efficient.  This involves changing the <a name="%_idx_5298" id="%_idx_5298"></a><a name="%_idx_5300" id="%_idx_5300"></a>representation of pattern
+efficient.  This involves changing the <a id="__idx_5298"></a><a id="__idx_5300"></a>representation of pattern
 variables.  When the query is instantiated, any variables that remain
 unbound are transformed back to the input representation before being
 printed.  These transformations are performed by the two procedures
 <tt>query-syntax-process</tt> and <tt>contract-question-mark</tt>
-(section  <a href="#%_sec_4.4.4.7">4.4.4.7</a>).</p><p>
+(section  <a href="#__sec_4.4.4.7">4.4.4.7</a>).</p><p>
 
-<a name="%_idx_5302" id="%_idx_5302"></a>To instantiate an expression, we copy it, replacing any variables in
+<a id="__idx_5302"></a>To instantiate an expression, we copy it, replacing any variables in
 the expression by their values in a given frame.  The values are
 themselves instantiated, since they could contain variables (for
 example, if <tt>?x</tt> in <tt>exp</tt> is bound to <tt>?y</tt> as the result
@@ -1381,7 +1381,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 take if a variable cannot be instantiated is given by a procedural
 argument to <tt>instantiate</tt>.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5304" id="%_idx_5304"></a>(define (instantiate exp frame unbound-var-handler)<br />
+</p><p></p><p><tt><a id="__idx_5304"></a>(define (instantiate exp frame unbound-var-handler)<br />
   (define (copy exp)<br />
     (cond ((var? exp)<br />
            (let ((binding (binding-in-frame exp frame)))<br />
@@ -1393,39 +1393,39 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
           (else exp)))<br />
   (copy exp))<br /></tt></p><p></p><p>
 The procedures that manipulate bindings are defined in
-section <a href="#%_sec_4.4.4.8">4.4.4.8</a>.
+section <a href="#__sec_4.4.4.8">4.4.4.8</a>.
 </p><p>
 
-<a name="%_sec_4.4.4.2" id="%_sec_4.4.4.2"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_4.4.4.2">4.4.4.2  The Evaluator</a></h4><p>
+<a id="__sec_4.4.4.2"></a>
+</p><h4>4.4.4.2  The Evaluator</h4><p>
 
 </p><p>
 
-<a name="%_idx_5306" id="%_idx_5306"></a>The <tt>qeval</tt> procedure, called by the <tt>query-driver-loop</tt>, is
+<a id="__idx_5306"></a>The <tt>qeval</tt> procedure, called by the <tt>query-driver-loop</tt>, is
 the basic evaluator of the query system.  It takes as inputs a query
 and a stream of frames, and it returns a stream of extended frames.
-It identifies special forms by a <a name="%_idx_5308" id="%_idx_5308"></a>data-directed dispatch using <tt>get</tt> and <tt>put</tt>, just as we did in implementing generic operations
+It identifies special forms by a <a id="__idx_5308"></a>data-directed dispatch using <tt>get</tt> and <tt>put</tt>, just as we did in implementing generic operations
 in chapter 2.  Any query that is not identified as a special form is
 assumed to be a simple query, to be processed by <tt>simple-query</tt>.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5310" id="%_idx_5310"></a>(define (qeval query frame-stream)<br />
+</p><p></p><p><tt><a id="__idx_5310"></a>(define (qeval query frame-stream)<br />
   (let ((qproc (get (type query) 'qeval)))<br />
     (if qproc<br />
         (qproc (contents query) frame-stream)<br />
         (simple-query query frame-stream))))<br /></tt></p><p></p><p>
-<tt>Type</tt> and <tt>contents</tt>, defined in section <a href="#%_sec_4.4.4.7">4.4.4.7</a>,
+<tt>Type</tt> and <tt>contents</tt>, defined in section <a href="#__sec_4.4.4.7">4.4.4.7</a>,
 implement the abstract syntax of the special forms.</p><p>
 
-<a name="%_sec_Temp_696" id="%_sec_Temp_696"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_696">Simple queries</a></h4><p>
+<a id="__sec_Temp_696"></a>
+</p><h4>Simple queries</h4><p>
 
-<a name="%_idx_5312" id="%_idx_5312"></a>
+<a id="__idx_5312"></a>
 The <tt>simple-query</tt> procedure handles simple queries.  It takes as
 arguments a simple query (a pattern) together with a stream of frames,
 and it returns the stream formed by extending each frame by all
 data-base matches of the query.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5314" id="%_idx_5314"></a>(define (simple-query query-pattern frame-stream)<br />
+</p><p></p><p><tt><a id="__idx_5314"></a>(define (simple-query query-pattern frame-stream)<br />
   (stream-flatmap<br />
    (lambda (frame)<br />
      (stream-append-delayed<br />
@@ -1434,25 +1434,25 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
    frame-stream))<br /></tt></p><p></p><p></p><p>
 
 For each frame in the input stream, we use <tt>find-assertions</tt>
-(section <a href="#%_sec_4.4.4.3">4.4.4.3</a>) to match the pattern against all
+(section <a href="#__sec_4.4.4.3">4.4.4.3</a>) to match the pattern against all
 assertions in the data base, producing a stream of extended frames,
-and we use <tt>apply-rules</tt> (section <a href="#%_sec_4.4.4.4">4.4.4.4</a>) to apply
+and we use <tt>apply-rules</tt> (section <a href="#__sec_4.4.4.4">4.4.4.4</a>) to apply
 all possible rules, producing another stream of extended frames.
 These two streams are combined (using <tt>stream-append-delayed</tt>,
-section <a href="#%_sec_4.4.4.6">4.4.4.6</a>) to make a stream of all the ways that
+section <a href="#__sec_4.4.4.6">4.4.4.6</a>) to make a stream of all the ways that
 the given pattern can be satisfied consistent with the original frame
-(see exercise <a href="#%_thm_4.71">4.71</a>).  The streams for the
+(see exercise <a href="#__thm_4.71">4.71</a>).  The streams for the
 individual input frames are combined using <tt>stream-flatmap</tt>
-(section <a href="#%_sec_4.4.4.6">4.4.4.6</a>) to form one large stream of all the
+(section <a href="#__sec_4.4.4.6">4.4.4.6</a>) to form one large stream of all the
 ways that any of the frames in the original input stream can be
 extended to produce a match with the given pattern.
 
-<a name="%_sec_Temp_697" id="%_sec_Temp_697"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_697">Compound queries</a></h4><p>
+<a id="__sec_Temp_697"></a>
+</p><h4>Compound queries</h4><p>
 
-<a name="%_idx_5316" id="%_idx_5316"></a>
-<a name="%_idx_5318" id="%_idx_5318"></a><tt>And</tt> queries are handled as illustrated in
-figure <a href="#%_fig_4.5">4.5</a> by the <tt>conjoin</tt> procedure.  <tt>Conjoin</tt> takes as inputs the conjuncts and the frame stream and
+<a id="__idx_5316"></a>
+<a id="__idx_5318"></a><tt>And</tt> queries are handled as illustrated in
+figure <a href="#__fig_4.5">4.5</a> by the <tt>conjoin</tt> procedure.  <tt>Conjoin</tt> takes as inputs the conjuncts and the frame stream and
 returns the stream of extended frames.  First, <tt>conjoin</tt> processes
 the stream of frames to find the stream of all possible frame extensions
 that satisfy the first query in the conjunction.  Then, using this as the new
@@ -1460,7 +1460,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 queries.</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_5320" id="%_idx_5320"></a>(define (conjoin conjuncts frame-stream)<br />
+</p><p></p><p><tt><a id="__idx_5320"></a>(define (conjoin conjuncts frame-stream)<br />
   (if (empty-conjunction? conjuncts)<br />
       frame-stream<br />
       (conjoin (rest-conjuncts conjuncts)<br />
@@ -1473,14 +1473,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 form is encountered.</p><p>
 
 
-<a name="%_idx_5322" id="%_idx_5322"></a><tt>Or</tt> queries are handled similarly, as shown in
-figure <a href="#%_fig_4.6">4.6</a>.  The output streams for the various
+<a id="__idx_5322"></a><tt>Or</tt> queries are handled similarly, as shown in
+figure <a href="#__fig_4.6">4.6</a>.  The output streams for the various
 disjuncts of the <tt>or</tt> are computed separately and merged using the
-<tt>interleave-delayed</tt> procedure from section <a href="#%_sec_4.4.4.6">4.4.4.6</a>.
-(See exercises <a href="#%_thm_4.71">4.71</a> and <a href="#%_thm_4.72">4.72</a>.)</p><p>
+<tt>interleave-delayed</tt> procedure from section <a href="#__sec_4.4.4.6">4.4.4.6</a>.
+(See exercises <a href="#__thm_4.71">4.71</a> and <a href="#__thm_4.72">4.72</a>.)</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_5324" id="%_idx_5324"></a>(define (disjoin disjuncts frame-stream)<br />
+</p><p></p><p><tt><a id="__idx_5324"></a>(define (disjoin disjuncts frame-stream)<br />
   (if (empty-disjunction? disjuncts)<br />
       the-empty-stream<br />
       (interleave-delayed<br />
@@ -1489,17 +1489,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
                        frame-stream)))))<br />
 (put 'or 'qeval disjoin)<br /></tt></p><p></p><p>
 The predicates and selectors for the syntax of conjuncts and disjuncts
-are given in section <a href="#%_sec_4.4.4.7">4.4.4.7</a>.</p><p>
+are given in section <a href="#__sec_4.4.4.7">4.4.4.7</a>.</p><p>
 
-<a name="%_sec_Temp_698" id="%_sec_Temp_698"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_698">Filters</a></h4><p>
+<a id="__sec_Temp_698"></a>
+</p><h4>Filters</h4><p>
 
-<a name="%_idx_5326" id="%_idx_5326"></a><tt>Not</tt> is handled by the method outlined in
-section <a href="#%_sec_4.4.2">4.4.2</a>.  We attempt to extend each frame in
+<a id="__idx_5326"></a><tt>Not</tt> is handled by the method outlined in
+section <a href="#__sec_4.4.2">4.4.2</a>.  We attempt to extend each frame in
 the input stream to satisfy the query being negated, and we include a
 given frame in the output stream only if it cannot be extended.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5328" id="%_idx_5328"></a>(define (negate operands frame-stream)<br />
+</p><p></p><p><tt><a id="__idx_5328"></a>(define (negate operands frame-stream)<br />
   (stream-flatmap<br />
    (lambda (frame)<br />
      (if (stream-null? (qeval (negated-query operands)<br />
@@ -1509,13 +1509,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
    frame-stream))<br />
 (put 'not 'qeval negate)<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_5330" id="%_idx_5330"></a><tt>Lisp-value</tt> is a filter similar to <tt>not</tt>.  Each frame in the
+<a id="__idx_5330"></a><tt>Lisp-value</tt> is a filter similar to <tt>not</tt>.  Each frame in the
 stream is used to instantiate the variables in the pattern, the
 indicated predicate is applied, and the frames for which the predicate
 returns false are filtered out of the input stream.  An error results
 if there are unbound pattern variables.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5332" id="%_idx_5332"></a>(define (lisp-value call frame-stream)<br />
+</p><p></p><p><tt><a id="__idx_5332"></a>(define (lisp-value call frame-stream)<br />
   (stream-flatmap<br />
    (lambda (frame)<br />
      (if (execute<br />
@@ -1533,7 +1533,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 However, it must not evaluate the arguments, since they are already
 the actual arguments, not expressions whose evaluation (in Lisp) will
 produce the arguments.  Note that <tt>execute</tt> is implemented using
-<a name="%_idx_5334" id="%_idx_5334"></a><tt>eval</tt> and <tt>apply</tt> from the underlying Lisp system.</p><p>
+<a id="__idx_5334"></a><tt>eval</tt> and <tt>apply</tt> from the underlying Lisp system.</p><p>
 
 </p><p></p><p><tt>(define (execute exp)<br />
   (apply (eval (predicate exp) user-initial-environment)<br />
@@ -1542,27 +1542,27 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 The <tt>always-true</tt> special form provides for a query that is always
 satisfied.  It ignores its contents (normally empty) and simply passes
 through all the frames in the input stream.  <tt>Always-true</tt> is used
-by the <tt>rule-body</tt> selector (section <a href="#%_sec_4.4.4.7">4.4.4.7</a>)
-<a name="%_idx_5336" id="%_idx_5336"></a>to provide bodies for rules that were
+by the <tt>rule-body</tt> selector (section <a href="#__sec_4.4.4.7">4.4.4.7</a>)
+<a id="__idx_5336"></a>to provide bodies for rules that were
 defined without bodies (that is, rules whose conclusions are always
 satisfied).</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5338" id="%_idx_5338"></a>(define (always-true ignore frame-stream) frame-stream)<br />
+</p><p></p><p><tt><a id="__idx_5338"></a>(define (always-true ignore frame-stream) frame-stream)<br />
 (put 'always-true 'qeval always-true)<br /></tt></p><p></p><p>
 The selectors that define the syntax of <tt>not</tt> and <tt>lisp-value</tt>
-are given in section <a href="#%_sec_4.4.4.7">4.4.4.7</a>.
+are given in section <a href="#__sec_4.4.4.7">4.4.4.7</a>.
 </p><p>
 
-<a name="%_sec_4.4.4.3" id="%_sec_4.4.4.3"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_4.4.4.3">4.4.4.3  Finding Assertions by Pattern Matching</a></h4><p>
+<a id="__sec_4.4.4.3"></a>
+</p><h4>4.4.4.3  Finding Assertions by Pattern Matching</h4><p>
 
 </p><p>
 
-<a name="%_idx_5340" id="%_idx_5340"></a><a name="%_idx_5342" id="%_idx_5342"></a><tt>Find-assertions</tt>, called by <tt>simple-query</tt>
-(section <a href="#%_sec_4.4.4.2">4.4.4.2</a>), takes as input a pattern and a frame.
+<a id="__idx_5340"></a><a id="__idx_5342"></a><tt>Find-assertions</tt>, called by <tt>simple-query</tt>
+(section <a href="#__sec_4.4.4.2">4.4.4.2</a>), takes as input a pattern and a frame.
 It returns a stream of frames, each extending the given one by a
 data-base match of the given pattern.  It uses <tt>fetch-assertions</tt>
-(section <a href="#%_sec_4.4.4.5">4.4.4.5</a>) to get a stream of all the assertions in
+(section <a href="#__sec_4.4.4.5">4.4.4.5</a>) to get a stream of all the assertions in
 the data base that should be checked for a match against the pattern
 and the frame.  The reason for <tt>fetch-assertions</tt> here is that we
 can often apply simple tests that will eliminate many of the entries
@@ -1572,7 +1572,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 the computation would be less efficient because we would need to make
 many more calls to the matcher.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5344" id="%_idx_5344"></a>(define (find-assertions pattern frame)<br />
+</p><p></p><p><tt><a id="__idx_5344"></a>(define (find-assertions pattern frame)<br />
   (stream-flatmap (lambda (datum)<br />
                     (check-an-assertion datum pattern frame))<br />
                   (fetch-assertions pattern frame)))<br /></tt></p><p></p><p></p><p>
@@ -1602,7 +1602,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 against the <tt>cdr</tt> of the data.  If none of these cases are
 applicable, the match fails and we return the symbol <tt>failed</tt>.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5346" id="%_idx_5346"></a>(define (pattern-match pat dat frame)<br />
+</p><p></p><p><tt><a id="__idx_5346"></a>(define (pattern-match pat dat frame)<br />
   (cond ((eq? frame 'failed) 'failed)<br />
         ((equal? pat dat) frame)<br />
         ((var? pat) (extend-if-consistent pat dat frame))<br />
@@ -1617,7 +1617,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 Here is the procedure that extends a frame by adding a new binding, if
 this is consistent with the bindings already in the frame:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5348" id="%_idx_5348"></a>(define (extend-if-consistent var dat frame)<br />
+</p><p></p><p><tt><a id="__idx_5348"></a>(define (extend-if-consistent var dat frame)<br />
   (let ((binding (binding-in-frame var frame)))<br />
     (if binding<br />
         (pattern-match (binding-value binding) dat frame)<br />
@@ -1630,7 +1630,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 simply tests whether the stored and new values are the same.  If so,
 it returns the unmodified frame; if not, it returns a failure
 indication.  The stored value may, however, contain pattern variables
-if it was stored during unification (see section <a href="#%_sec_4.4.4.4">4.4.4.4</a>).
+if it was stored during unification (see section <a href="#__sec_4.4.4.4">4.4.4.4</a>).
 The recursive match of the stored pattern against the new data will add or
 check bindings for the variables in this pattern.  For example,
 suppose we have a frame in which <tt>?x</tt> is bound to <tt>(f ?y)</tt> and
@@ -1642,23 +1642,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 binding and we never store more than one binding for a given variable.</p><p>
 
 The procedures used by <tt>extend-if-consistent</tt> to manipulate
-bindings are defined in section <a href="#%_sec_4.4.4.8">4.4.4.8</a>.</p><p>
+bindings are defined in section <a href="#__sec_4.4.4.8">4.4.4.8</a>.</p><p>
 
-<a name="%_sec_Temp_699" id="%_sec_Temp_699"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_699">Patterns with dotted tails</a></h4><p>
+<a id="__sec_Temp_699"></a>
+</p><h4>Patterns with dotted tails</h4><p>
 
-<a name="%_idx_5350" id="%_idx_5350"></a>
+<a id="__idx_5350"></a>
 
 If a pattern contains a dot followed by a pattern variable, the
 pattern variable matches the rest of the data list (rather than the
 next element of the data list), just as one would expect with the
-dotted-tail notation described in exercise <a href="book-Z-H-15.html#%_thm_2.20">2.20</a>.
+dotted-tail notation described in exercise <a href="book-Z-H-15.html#__thm_2.20">2.20</a>.
 Although the pattern matcher we have just implemented doesn't look for
 dots, it does behave as we want.  This is because the Lisp <tt>read</tt>
 primitive, which is used by <tt>query-driver-loop</tt> to read the query
 and represent it as a list structure, treats dots in a special way.</p><p>
 
-<a name="%_idx_5352" id="%_idx_5352"></a><a name="%_idx_5354" id="%_idx_5354"></a>When <tt>read</tt> sees a dot, instead of making the next item be the
+<a id="__idx_5352"></a><a id="__idx_5354"></a>When <tt>read</tt> sees a dot, instead of making the next item be the
 next element of a list (the <tt>car</tt> of a <tt>cons</tt> whose <tt>cdr</tt>
 will be the rest of the list) it makes the next item be the <tt>cdr</tt>
 of the list structure.  For example, the list structure produced by
@@ -1675,25 +1675,25 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 <tt>(computer programmer trainee)</tt> will match <tt>?type</tt> against the
 list <tt>(programmer trainee)</tt>.
 
-<a name="%_sec_4.4.4.4" id="%_sec_4.4.4.4"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_4.4.4.4">4.4.4.4  Rules and Unification</a></h4><p>
+<a id="__sec_4.4.4.4"></a>
+</p><h4>4.4.4.4  Rules and Unification</h4><p>
 
 </p><p>
 
-<a name="%_idx_5356" id="%_idx_5356"></a><tt>Apply-rules</tt> is the rule analog of <tt>find-assertions</tt>
-(section <a href="#%_sec_4.4.4.3">4.4.4.3</a>).  It
+<a id="__idx_5356"></a><tt>Apply-rules</tt> is the rule analog of <tt>find-assertions</tt>
+(section <a href="#__sec_4.4.4.3">4.4.4.3</a>).  It
 takes as input a pattern and a frame, and it forms a stream of
 extension frames by applying rules from the data base.  <tt>Stream-flatmap</tt> maps <tt>apply-a-rule</tt> down the stream of possibly
-applicable rules (selected by <tt>fetch-rules</tt>, section <a href="#%_sec_4.4.4.5">4.4.4.5</a>)
+applicable rules (selected by <tt>fetch-rules</tt>, section <a href="#__sec_4.4.4.5">4.4.4.5</a>)
 and combines the resulting streams of frames.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5358" id="%_idx_5358"></a>(define (apply-rules pattern frame)<br />
+</p><p></p><p><tt><a id="__idx_5358"></a>(define (apply-rules pattern frame)<br />
   (stream-flatmap (lambda (rule)<br />
                     (apply-a-rule rule pattern frame))<br />
                   (fetch-rules pattern frame)))<br /></tt></p><p></p><p></p><p>
 
 <tt>Apply-a-rule</tt> applies rules using the method outlined in
-section <a href="#%_sec_4.4.2">4.4.2</a>.  It first augments its argument
+section <a href="#__sec_4.4.2">4.4.2</a>.  It first augments its argument
 frame by unifying the rule conclusion with the pattern in the given
 frame.  If this succeeds, it evaluates the rule body in this new
 frame.</p><p>
@@ -1709,7 +1709,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 could devise a more clever environment structure; however, the
 renaming approach we have chosen here is the most straightforward,
 even if not the most efficient.  (See
-exercise <a href="#%_thm_4.79">4.79</a>.)  Here is the <tt>apply-a-rule</tt>
+exercise <a href="#__thm_4.79">4.79</a>.)  Here is the <tt>apply-a-rule</tt>
 procedure:</p><p>
 
 </p><p></p><p><tt>(define (apply-a-rule rule query-pattern query-frame)<br />
@@ -1723,7 +1723,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
           (qeval (rule-body clean-rule)<br />
                  (singleton-stream unify-result))))))<br /></tt></p><p></p><p>
 The selectors <tt>rule-body</tt> and <tt>conclusion</tt> that extract parts
-of a rule are defined in section <a href="#%_sec_4.4.4.7">4.4.4.7</a>.</p><p>
+of a rule are defined in section <a href="#__sec_4.4.4.7">4.4.4.7</a>.</p><p>
 
 We generate unique variable names by associating a unique identifier
 (such as a number) with each rule application and combining this
@@ -1731,7 +1731,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 rule-application identifier is 7, we might change each <tt>?x</tt> in
 the rule to <tt>?x-7</tt> and each <tt>?y</tt> in the rule to <tt>?y-7</tt>.
 (<tt>Make-new-variable</tt> and <tt>new-rule-application-id</tt> are
-included with the syntax procedures in section <a href="#%_sec_4.4.4.7">4.4.4.7</a>.)</p><p>
+included with the syntax procedures in section <a href="#__sec_4.4.4.7">4.4.4.7</a>.)</p><p>
 
 </p><p></p><p><tt>(define (rename-variables-in rule)<br />
   (let ((rule-application-id (new-rule-application-id)))<br />
@@ -1744,7 +1744,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
             (else exp)))<br />
     (tree-walk rule)))<br /></tt></p><p></p><p>
 
-<a name="%_idx_5360" id="%_idx_5360"></a><a name="%_idx_5362" id="%_idx_5362"></a>The unification algorithm is implemented as a procedure that takes as
+<a id="__idx_5360"></a><a id="__idx_5362"></a>The unification algorithm is implemented as a procedure that takes as
 inputs two patterns and a frame and returns either the extended frame
 or the symbol <tt>failed</tt>.
 The unifier is like the pattern matcher except that it is
@@ -1753,7 +1753,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 except that there is extra code (marked “<tt>***</tt>” below) to handle
 the case where the object on the right side of the match is a variable.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5364" id="%_idx_5364"></a>(define (unify-match p1 p2 frame)<br />
+</p><p></p><p><tt><a id="__idx_5364"></a>(define (unify-match p1 p2 frame)<br />
   (cond ((eq? frame 'failed) 'failed)<br />
         ((equal? p1 p2) frame)<br />
         ((var? p1) (extend-if-possible p1 p2 frame))<br />
@@ -1794,14 +1794,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 a <tt>?y</tt> such that <tt>?y</tt> is equal to the expression involving <tt>?y</tt>.
 There is no general method for solving such
 equations, so we reject such bindings; these cases are recognized by
-the predicate <tt>depends-on?</tt>.<a name="call_footnote_Temp_700" href="#footnote_Temp_700" id="call_footnote_Temp_700"><sup><small>80</small></sup></a>
+the predicate <tt>depends-on?</tt>.<a href="#footnote_Temp_700" id="call_footnote_Temp_700"><sup><small>80</small></sup></a>
 On the other hand, we do not want to reject attempts
 to bind a variable to itself.  For example, consider unifying <tt>(?x ?x)</tt>
 and <tt>(?y ?y)</tt>.  The second attempt to bind <tt>?x</tt> to <tt>?y</tt> matches <tt>?y</tt> (the stored value of <tt>?x</tt>) against <tt>?y</tt>
 (the new value of <tt>?x</tt>).  This is taken care of by the <tt>equal?</tt> clause
 of <tt>unify-match</tt>.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5370" id="%_idx_5370"></a>(define (extend-if-possible var val frame)<br />
+</p><p></p><p><tt><a id="__idx_5370"></a>(define (extend-if-possible var val frame)<br />
   (let ((binding (binding-in-frame var frame)))<br />
     (cond (binding<br />
            (unify-match<br />
@@ -1839,12 +1839,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
           (else false)))<br />
   (tree-walk exp))<br /></tt></p><p></p><p>
 
-<a name="%_sec_4.4.4.5" id="%_sec_4.4.4.5"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_4.4.4.5">4.4.4.5  Maintaining the Data Base</a></h4><p>
+<a id="__sec_4.4.4.5"></a>
+</p><h4>4.4.4.5  Maintaining the Data Base</h4><p>
 
 
-<a name="%_idx_5372" id="%_idx_5372"></a>
-<a name="%_idx_5374" id="%_idx_5374"></a><a name="%_idx_5376" id="%_idx_5376"></a>One important problem in designing logic programming languages is that
+<a id="__idx_5372"></a>
+<a id="__idx_5374"></a><a id="__idx_5376"></a>One important problem in designing logic programming languages is that
 of arranging things so that as few irrelevant data-base entries as
 possible will be examined in checking a given pattern.  In our
 system, in addition to storing all assertions in one big stream,
@@ -1860,7 +1860,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 handling only the case of constant symbols) into the program; instead
 we call on predicates and selectors that embody our criteria.</p><p>
 
-</p><p></p><p><tt>(define THE-ASSERTIONS the-empty-stream)<br /><a name="%_idx_5378" id="%_idx_5378"></a>(define (fetch-assertions pattern frame)<br />
+</p><p></p><p><tt>(define THE-ASSERTIONS the-empty-stream)<br /><a id="__idx_5378"></a>(define (fetch-assertions pattern frame)<br />
   (if (use-index? pattern)<br />
       (get-indexed-assertions pattern)<br />
       (get-all-assertions)))<br />
@@ -1886,7 +1886,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 conclusions start with a variable in a separate stream in our table,
 indexed by the symbol <tt>?</tt>.</p><p>
 
-</p><p></p><p><tt>(define THE-RULES the-empty-stream)<br /><a name="%_idx_5380" id="%_idx_5380"></a>(define (fetch-rules pattern frame)<br />
+</p><p></p><p><tt>(define THE-RULES the-empty-stream)<br /><a id="__idx_5380"></a>(define (fetch-rules pattern frame)<br />
   (if (use-index? pattern)<br />
       (get-indexed-rules pattern)<br />
       (get-all-rules)))<br />
@@ -1903,7 +1903,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 the data base.</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_5382" id="%_idx_5382"></a>(define (add-rule-or-assertion! assertion)<br />
+</p><p></p><p><tt><a id="__idx_5382"></a>(define (add-rule-or-assertion! assertion)<br />
   (if (rule? assertion)<br />
       (add-rule! assertion)<br />
       (add-assertion! assertion)))<br />
@@ -1965,11 +1965,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 </p><p></p><p><tt>(define (use-index? pat)<br />
   (constant-symbol? (car pat)))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_4.70" id="%_thm_4.70"></a>
+</p><p><a id="__thm_4.70"></a>
 <b>Exercise 4.70.</b>  What is the purpose of the <tt>let</tt> bindings in the procedures <tt>add-assertion!</tt> and <tt>add-rule!</tt> ?  What would be wrong with the
 following implementation of <tt>add-assertion!</tt> ?
 Hint: Recall the definition of the infinite stream of ones in
-section <a href="book-Z-H-24.html#%_sec_3.5.2">3.5.2</a>: <tt>(define ones (cons-stream 1 ones))</tt>.</p><p>
+section <a href="book-Z-H-24.html#__sec_3.5.2">3.5.2</a>: <tt>(define ones (cons-stream 1 ones))</tt>.</p><p>
 
 </p><p></p><p><tt>(define (add-assertion! assertion)<br />
   (store-assertion-in-index assertion)<br />
@@ -1978,28 +1978,28 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
   'ok)<br /></tt></p><p></p><p>
 </p><p>
 
-<a name="%_sec_4.4.4.6" id="%_sec_4.4.4.6"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_4.4.4.6">4.4.4.6  Stream Operations</a></h4><p>
+<a id="__sec_4.4.4.6"></a>
+</p><h4>4.4.4.6  Stream Operations</h4><p>
 
 
-<a name="%_idx_5384" id="%_idx_5384"></a>
+<a id="__idx_5384"></a>
 The query system uses a few stream operations that were not presented
 in chapter 3.</p><p>
 
 
 <tt>Stream-append-delayed</tt> and <tt>interleave-delayed</tt>
 are just like <tt>stream-append</tt> and <tt>interleave</tt>
-(section <a href="book-Z-H-24.html#%_sec_3.5.3">3.5.3</a>),
+(section <a href="book-Z-H-24.html#__sec_3.5.3">3.5.3</a>),
 except that they take a delayed argument (like the <tt>integral</tt>
-procedure in section <a href="book-Z-H-24.html#%_sec_3.5.4">3.5.4</a>).
-This postpones looping in some cases (see exercise <a href="#%_thm_4.71">4.71</a>).</p><p>
+procedure in section <a href="book-Z-H-24.html#__sec_3.5.4">3.5.4</a>).
+This postpones looping in some cases (see exercise <a href="#__thm_4.71">4.71</a>).</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5386" id="%_idx_5386"></a>(define (stream-append-delayed s1 delayed-s2)<br />
+</p><p></p><p><tt><a id="__idx_5386"></a>(define (stream-append-delayed s1 delayed-s2)<br />
   (if (stream-null? s1)<br />
       (force delayed-s2)<br />
       (cons-stream<br />
        (stream-car s1)<br />
-       (stream-append-delayed (stream-cdr s1) delayed-s2))))<br /><a name="%_idx_5388" id="%_idx_5388"></a>(define (interleave-delayed s1 delayed-s2)<br />
+       (stream-append-delayed (stream-cdr s1) delayed-s2))))<br /><a id="__idx_5388"></a>(define (interleave-delayed s1 delayed-s2)<br />
   (if (stream-null? s1)<br />
       (force delayed-s2)<br />
       (cons-stream<br />
@@ -2010,13 +2010,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 <tt>Stream-flatmap</tt>, which is used throughout the query evaluator to
 map a procedure over a stream of frames and combine the resulting
 streams of frames, is the stream analog of the <tt>flatmap</tt> procedure
-introduced for ordinary lists in section <a href="book-Z-H-15.html#%_sec_2.2.3">2.2.3</a>.
+introduced for ordinary lists in section <a href="book-Z-H-15.html#__sec_2.2.3">2.2.3</a>.
 Unlike ordinary <tt>flatmap</tt>, however, we accumulate the streams with
 an interleaving process, rather than simply appending them (see
-exercises <a href="#%_thm_4.72">4.72</a> and  <a href="#%_thm_4.73">4.73</a>).</p><p>
+exercises <a href="#__thm_4.72">4.72</a> and  <a href="#__thm_4.73">4.73</a>).</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5390" id="%_idx_5390"></a>(define (stream-flatmap proc s)<br />
-  (flatten-stream (stream-map proc s)))<br /><a name="%_idx_5392" id="%_idx_5392"></a>(define (flatten-stream stream)<br />
+</p><p></p><p><tt><a id="__idx_5390"></a>(define (stream-flatmap proc s)<br />
+  (flatten-stream (stream-map proc s)))<br /><a id="__idx_5392"></a>(define (flatten-stream stream)<br />
   (if (stream-null? stream)<br />
       the-empty-stream<br />
       (interleave-delayed<br />
@@ -2026,19 +2026,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 The evaluator also uses the following simple procedure
 to generate a stream consisting of a single element:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5394" id="%_idx_5394"></a>(define (singleton-stream x)<br />
+</p><p></p><p><tt><a id="__idx_5394"></a>(define (singleton-stream x)<br />
   (cons-stream x the-empty-stream))<br /></tt></p><p></p><p>
 
-<a name="%_sec_4.4.4.7" id="%_sec_4.4.4.7"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_4.4.4.7">4.4.4.7  Query Syntax Procedures</a></h4><p>
+<a id="__sec_4.4.4.7"></a>
+</p><h4>4.4.4.7  Query Syntax Procedures</h4><p>
 
 
-<a name="%_idx_5396" id="%_idx_5396"></a>
+<a id="__idx_5396"></a>
 <tt>Type</tt> and <tt>contents</tt>, used by <tt>qeval</tt>
-(section <a href="#%_sec_4.4.4.2">4.4.4.2</a>), specify that a
+(section <a href="#__sec_4.4.4.2">4.4.4.2</a>), specify that a
 special form is identified by the symbol in its <tt>car</tt>.
 They are the same as the <tt>type-tag</tt> and <tt>contents</tt> procedures in
-section <a href="book-Z-H-17.html#%_sec_2.4.2">2.4.2</a>, except for the error message.</p><p>
+section <a href="book-Z-H-17.html#__sec_2.4.2">2.4.2</a>, except for the error message.</p><p>
 
 </p><p></p><p><tt>(define (type exp)<br />
   (if (pair? exp)<br />
@@ -2050,7 +2050,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
       (error "Unknown expression CONTENTS" exp)))<br /></tt></p><p></p><p></p><p>
 
 The following procedures, used by <tt>query-driver-loop</tt>
-(in section <a href="#%_sec_4.4.4.1">4.4.4.1</a>), specify
+(in section <a href="#__sec_4.4.4.1">4.4.4.1</a>), specify
 that rules and assertions are added to the data base by expressions of
 the form <tt>(assert! &lt;<em>rule-or-assertion</em>&gt;):</tt></p><p>
 
@@ -2060,7 +2060,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
   (car (contents exp)))<br /></tt></p><p></p><p></p><p>
 
 Here are the syntax definitions for the <tt>and</tt>,  <tt>or</tt>,  <tt>not</tt>, and <tt>lisp-value</tt> special forms
-(section <a href="#%_sec_4.4.4.2">4.4.4.2</a>):</p><p>
+(section <a href="#__sec_4.4.4.2">4.4.4.2</a>):</p><p>
 
 </p><p></p><p><tt>(define (empty-conjunction? exps) (null? exps))<br />
 (define (first-conjunct exps) (car exps))<br />
@@ -2082,7 +2082,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
       '(always-true)<br />
       (caddr rule)))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_5398" id="%_idx_5398"></a><a name="%_idx_5400" id="%_idx_5400"></a><tt>Query-driver-loop</tt> (section <a href="#%_sec_4.4.4.1">4.4.4.1</a>)
+<a id="__idx_5398"></a><a id="__idx_5400"></a><tt>Query-driver-loop</tt> (section <a href="#__sec_4.4.4.1">4.4.4.1</a>)
 calls <tt>query-syntax-process</tt> to
 transform pattern variables in the expression, which have the form
 <tt>?symbol</tt>, into the internal format <tt>(? symbol)</tt>.  That is to
@@ -2093,10 +2093,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 whether the <tt>car</tt> of the expression is the symbol <tt>?</tt>, rather
 than having to extract characters from the symbol.  The syntax
 transformation is accomplished by the following
-procedure:<a name="call_footnote_Temp_702" href="#footnote_Temp_702" id="call_footnote_Temp_702"><sup><small>81</small></sup></a></p><p>
+procedure:<a href="#footnote_Temp_702" id="call_footnote_Temp_702"><sup><small>81</small></sup></a></p><p>
 
 </p><p></p><p><tt>(define (query-syntax-process exp)<br />
-  (map-over-symbols expand-question-mark exp))<br /><a name="%_idx_5412" id="%_idx_5412"></a>(define (map-over-symbols proc exp)<br />
+  (map-over-symbols expand-question-mark exp))<br /><a id="__idx_5412"></a>(define (map-over-symbols proc exp)<br />
   (cond ((pair? exp)<br />
          (cons (map-over-symbols proc (car exp))<br />
                (map-over-symbols proc (cdr exp))))<br />
@@ -2113,14 +2113,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 Once the variables are transformed in this way, the variables in a
 pattern are lists starting with <tt>?</tt>,
 and the constant symbols (which need to be recognized for
-data-base indexing, section <a href="#%_sec_4.4.4.5">4.4.4.5</a>) are just the symbols.</p><p>
+data-base indexing, section <a href="#__sec_4.4.4.5">4.4.4.5</a>) are just the symbols.</p><p>
 
 </p><p></p><p><tt>(define (var? exp)<br />
   (tagged-list? exp '?))<br />
 (define (constant-symbol? exp) (symbol? exp))<br /></tt></p><p></p><p></p><p>
 
 Unique variables are constructed during rule application
-(in section <a href="#%_sec_4.4.4.4">4.4.4.4</a>) by means of
+(in section <a href="#__sec_4.4.4.4">4.4.4.4</a>) by means of
 the following procedures.  The unique identifier for a rule
 application is a number, which is incremented each time a rule is
 applied.</p><p>
@@ -2146,12 +2146,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
                         (number-&gt;string (cadr variable)))<br />
          (symbol-&gt;string (cadr variable))))))<br /></tt></p><p></p><p>
 
-<a name="%_sec_4.4.4.8" id="%_sec_4.4.4.8"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_4.4.4.8">4.4.4.8  Frames and Bindings</a></h4><p>
+<a id="__sec_4.4.4.8"></a>
+</p><h4>4.4.4.8  Frames and Bindings</h4><p>
 
 </p><p>
 
-<a name="%_idx_5414" id="%_idx_5414"></a><a name="%_idx_5416" id="%_idx_5416"></a>Frames are represented as lists of bindings, which are
+<a id="__idx_5414"></a><a id="__idx_5416"></a>Frames are represented as lists of bindings, which are
 variable-value pairs:</p><p>
 
 </p><p></p><p><tt>(define (make-binding variable value)<br />
@@ -2165,9 +2165,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 (define (extend variable value frame)<br />
   (cons (make-binding variable value) frame))<br /></tt></p><p></p><p>
 
-</p><p><a name="%_thm_4.71" id="%_thm_4.71"></a>
+</p><p><a id="__thm_4.71"></a>
 <b>Exercise 4.71.</b>  Louis Reasoner wonders why the <tt>simple-query</tt> and <tt>disjoin</tt>
-procedures (section <a href="#%_sec_4.4.4.2">4.4.4.2</a>) are implemented using
+procedures (section <a href="#__sec_4.4.4.2">4.4.4.2</a>) are implemented using
 explicit <tt>delay</tt> operations, rather than being defined as follows:</p><p>
 
 </p><p></p><p><tt>(define (simple-query query-pattern frame-stream)<br />
@@ -2187,15 +2187,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.72" id="%_thm_4.72"></a>
+</p><p><a id="__thm_4.72"></a>
 <b>Exercise 4.72.</b>  Why do <tt>disjoin</tt> and <tt>stream-flatmap</tt> interleave the
 streams rather than simply append them?  Give examples that illustrate
 why interleaving works better.  (Hint: Why did we use <tt>interleave</tt> in
-section <a href="book-Z-H-24.html#%_sec_3.5.3">3.5.3</a>?)
+section <a href="book-Z-H-24.html#__sec_3.5.3">3.5.3</a>?)
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.73" id="%_thm_4.73"></a>
+</p><p><a id="__thm_4.73"></a>
 <b>Exercise 4.73.</b>  Why does <tt>flatten-stream</tt> use <tt>delay</tt> explicitly?
 What would be wrong with defining it as follows:
 </p><p></p><p><tt>(define (flatten-stream stream)<br />
@@ -2206,8 +2206,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
        (flatten-stream (stream-cdr stream)))))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.74" id="%_thm_4.74"></a>
-<b>Exercise 4.74.</b>  <a name="%_idx_5418" id="%_idx_5418"></a>Alyssa P. Hacker proposes to use a simpler version of <tt>stream-flatmap</tt>
+</p><p><a id="__thm_4.74"></a>
+<b>Exercise 4.74.</b>  <a id="__idx_5418"></a>Alyssa P. Hacker proposes to use a simpler version of <tt>stream-flatmap</tt>
 in <tt>negate</tt>, <tt>lisp-value</tt>, and <tt>find-assertions</tt>.
 She observes that the procedure that is mapped over the frame stream
 in these cases always produces either the empty stream or a singleton
@@ -2222,8 +2222,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 </p><p></p><p>b. Does the query system's behavior change if we change it in this way?
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.75" id="%_thm_4.75"></a>
-<b>Exercise 4.75.</b>  <a name="%_idx_5420" id="%_idx_5420"></a><a name="%_idx_5422" id="%_idx_5422"></a><a name="%_idx_5424" id="%_idx_5424"></a>Implement for the query language a new special form called <tt>unique</tt>.  <tt>Unique</tt> should succeed if there is precisely one item
+</p><p><a id="__thm_4.75"></a>
+<b>Exercise 4.75.</b>  <a id="__idx_5420"></a><a id="__idx_5422"></a><a id="__idx_5424"></a>Implement for the query language a new special form called <tt>unique</tt>.  <tt>Unique</tt> should succeed if there is precisely one item
 in the data base satisfying a specified query.  For example,</p><p>
 
 </p><p></p><p><tt>(unique (job ?x (computer wizard)))<br /></tt></p><p></p><p>
@@ -2264,9 +2264,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 supervise precisely one person.
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.76" id="%_thm_4.76"></a>
-<b>Exercise 4.76.</b>  <a name="%_idx_5426" id="%_idx_5426"></a><a name="%_idx_5428" id="%_idx_5428"></a><a name="%_idx_5430" id="%_idx_5430"></a>Our implementation of <tt>and</tt> as a series combination of queries
-(figure <a href="#%_fig_4.5">4.5</a>) is elegant, but it is inefficient because in
+</p><p><a id="__thm_4.76"></a>
+<b>Exercise 4.76.</b>  <a id="__idx_5426"></a><a id="__idx_5428"></a><a id="__idx_5430"></a>Our implementation of <tt>and</tt> as a series combination of queries
+(figure <a href="#__fig_4.5">4.5</a>) is elegant, but it is inefficient because in
 processing the second query of the <tt>and</tt> we must scan the data
 base for each frame produced by the first query.  If the data base has
 <em>N</em> elements, and a typical query produces a number of output frames
@@ -2287,8 +2287,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.77" id="%_thm_4.77"></a>
-<b>Exercise 4.77.</b>  <a name="%_idx_5432" id="%_idx_5432"></a><a name="%_idx_5434" id="%_idx_5434"></a><a name="%_idx_5436" id="%_idx_5436"></a><a name="%_idx_5438" id="%_idx_5438"></a><a name="%_idx_5440" id="%_idx_5440"></a>In section <a href="#%_sec_4.4.3">4.4.3</a> we saw that <tt>not</tt> and <tt>lisp-value</tt> can cause the query language to give “wrong” answers if
+</p><p><a id="__thm_4.77"></a>
+<b>Exercise 4.77.</b>  <a id="__idx_5432"></a><a id="__idx_5434"></a><a id="__idx_5436"></a><a id="__idx_5438"></a><a id="__idx_5440"></a>In section <a href="#__sec_4.4.3">4.4.3</a> we saw that <tt>not</tt> and <tt>lisp-value</tt> can cause the query language to give “wrong” answers if
 these filtering operations are applied to frames in which variables
 are unbound.  Devise a way to fix this shortcoming.  One idea is to
 perform the filtering in a “delayed” manner by appending to the
@@ -2301,10 +2301,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.78" id="%_thm_4.78"></a>
-<b>Exercise 4.78.</b>  <a name="%_idx_5442" id="%_idx_5442"></a>Redesign the query language as a nondeterministic program to be
+</p><p><a id="__thm_4.78"></a>
+<b>Exercise 4.78.</b>  <a id="__idx_5442"></a>Redesign the query language as a nondeterministic program to be
 implemented using the evaluator of
-section <a href="book-Z-H-28.html#%_sec_4.3">4.3</a>, rather than as a stream
+section <a href="book-Z-H-28.html#__sec_4.3">4.3</a>, rather than as a stream
 process.  In this approach, each query will produce a single answer
 (rather than the stream of all answers) and the user can type <tt>try-again</tt> to see more answers.  You should find that much of the
 mechanism we built in this section is subsumed by nondeterministic
@@ -2315,8 +2315,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_4.79" id="%_thm_4.79"></a>
-<b>Exercise 4.79.</b>  <a name="%_idx_5444" id="%_idx_5444"></a><a name="%_idx_5446" id="%_idx_5446"></a>When we implemented the Lisp evaluator in section <a href="book-Z-H-26.html#%_sec_4.1">4.1</a>,
+</p><p><a id="__thm_4.79"></a>
+<b>Exercise 4.79.</b>  <a id="__idx_5444"></a><a id="__idx_5446"></a>When we implemented the Lisp evaluator in section <a href="book-Z-H-26.html#__sec_4.1">4.1</a>,
 we saw how to use local environments to avoid name conflicts between
 the parameters of procedures.  For example, in evaluating</p><p>
 
@@ -2336,7 +2336,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 rename the variables in the body of a procedure each time we apply the
 procedure.</p><p>
 
-<a name="%_idx_5448" id="%_idx_5448"></a><a name="%_idx_5450" id="%_idx_5450"></a><a name="%_idx_5452" id="%_idx_5452"></a><a name="%_idx_5454" id="%_idx_5454"></a>Implement for the query language a rule-application method that uses
+<a id="__idx_5448"></a><a id="__idx_5450"></a><a id="__idx_5452"></a><a id="__idx_5454"></a>Implement for the query language a rule-application method that uses
 environments rather than renaming.  See if you can build on your
 environment structure to create constructs in the query language for
 dealing with large systems, such as the rule analog of
@@ -2351,41 +2351,41 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_645" href="#call_footnote_Temp_645" id="footnote_Temp_645"><sup><small>58</small></sup></a> Logic programming has grown out of a long
-<a name="%_idx_5040" id="%_idx_5040"></a><a name="%_idx_5042" id="%_idx_5042"></a>history of research in automatic theorem proving.  Early
+</p><div class="footnote"><p><a href="#call_footnote_Temp_645" id="footnote_Temp_645"><sup><small>58</small></sup></a> Logic programming has grown out of a long
+<a id="__idx_5040"></a><a id="__idx_5042"></a>history of research in automatic theorem proving.  Early
 theorem-proving programs could accomplish very little, because they
 exhaustively searched the space of possible proofs.  The major
 breakthrough that made such a search plausible was the discovery in
-the early 1960s of the <a name="%_idx_5044" id="%_idx_5044"></a><em>unification algorithm</em> and the <a name="%_idx_5046" id="%_idx_5046"></a><em>resolution principle</em> (Robinson 1965).  Resolution was used, for
-example, by <a name="%_idx_5048" id="%_idx_5048"></a><a name="%_idx_5050" id="%_idx_5050"></a>Green and Raphael (1968) (see also Green 1969) as the
+the early 1960s of the <a id="__idx_5044"></a><em>unification algorithm</em> and the <a id="__idx_5046"></a><em>resolution principle</em> (Robinson 1965).  Resolution was used, for
+example, by <a id="__idx_5048"></a><a id="__idx_5050"></a>Green and Raphael (1968) (see also Green 1969) as the
 basis for a deductive question-answering system.  During most of this
 period, researchers concentrated on algorithms that are guaranteed to
 find a proof if one exists.  Such algorithms were difficult to control
-and to direct toward a proof.  <a name="%_idx_5052" id="%_idx_5052"></a>Hewitt (1969) recognized the
+and to direct toward a proof.  <a id="__idx_5052"></a>Hewitt (1969) recognized the
 possibility of merging the control structure of a programming language
 with the operations of a logic-manipulation system, leading to the
-work in automatic search mentioned in section <a href="book-Z-H-28.html#%_sec_4.3.1">4.3.1</a>
+work in automatic search mentioned in section <a href="book-Z-H-28.html#__sec_4.3.1">4.3.1</a>
 (footnote <a href="book-Z-H-28.html#footnote_Temp_603">47</a>).  At the same time that this was being done,
-<a name="%_idx_5054" id="%_idx_5054"></a>Colmerauer, in Marseille, was developing rule-based systems for
+<a id="__idx_5054"></a>Colmerauer, in Marseille, was developing rule-based systems for
 manipulating natural language (see Colmerauer et al. 1973).  He
-invented a programming language called <a name="%_idx_5056" id="%_idx_5056"></a>Prolog for representing those
-rules.  <a name="%_idx_5058" id="%_idx_5058"></a>Kowalski (1973; 1979), in Edinburgh, recognized that execution
+invented a programming language called <a id="__idx_5056"></a>Prolog for representing those
+rules.  <a id="__idx_5058"></a>Kowalski (1973; 1979), in Edinburgh, recognized that execution
 of a Prolog program could be interpreted as proving theorems (using a
-proof technique called linear <a name="%_idx_5060" id="%_idx_5060"></a>Horn-clause resolution).  The merging of
+proof technique called linear <a id="__idx_5060"></a>Horn-clause resolution).  The merging of
 the last two strands led to the logic-programming movement.  Thus, in
 assigning credit for the development of logic programming, the French
-can point to Prolog's genesis at the <a name="%_idx_5062" id="%_idx_5062"></a>University of Marseille, while
-the British can highlight the work at the <a name="%_idx_5064" id="%_idx_5064"></a>University of Edinburgh.
-According to people at <a name="%_idx_5066" id="%_idx_5066"></a>MIT, logic programming was developed by these
+can point to Prolog's genesis at the <a id="__idx_5062"></a>University of Marseille, while
+the British can highlight the work at the <a id="__idx_5064"></a>University of Edinburgh.
+According to people at <a id="__idx_5066"></a>MIT, logic programming was developed by these
 groups in an attempt to figure out what Hewitt was talking about in
 his brilliant but impenetrable Ph.D. thesis.  For a history of logic
-<a name="%_idx_5068" id="%_idx_5068"></a>programming, see Robinson 1983.
+<a id="__idx_5068"></a>programming, see Robinson 1983.
 
-</p><p><a name="footnote_Temp_646" href="#call_footnote_Temp_646" id="footnote_Temp_646"><sup><small>59</small></sup></a> To
+</p><p><a href="#call_footnote_Temp_646" id="footnote_Temp_646"><sup><small>59</small></sup></a> To
 see the correspondence between the rules and the procedure, let <tt>x</tt> in the procedure (where <tt>x</tt> is nonempty) correspond to <tt>(cons u v)</tt> in the rule.  Then <tt>z</tt> in the rule corresponds to the
 <tt>append</tt> of <tt>(cdr x)</tt> and <tt>y</tt>.
 
-</p><p><a name="footnote_Temp_647" href="#call_footnote_Temp_647" id="footnote_Temp_647"><sup><small>60</small></sup></a> This certainly does not
+</p><p><a href="#call_footnote_Temp_647" id="footnote_Temp_647"><sup><small>60</small></sup></a> This certainly does not
 relieve the user of the entire problem of how to compute the answer.
 There are many different mathematically equivalent sets of rules for
 formulating the <tt>append</tt> relation, only some of which can be
@@ -2394,35 +2394,35 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 compute an answer.  For example, consider the problem of computing the
 <em>y</em> such that <em>y</em><sup>2</sup>  =  <em>x</em>.
 
-</p><p><a name="footnote_Temp_648" href="#call_footnote_Temp_648" id="footnote_Temp_648"><sup><small>61</small></sup></a> Interest in logic programming peaked
-<a name="%_idx_5080" id="%_idx_5080"></a><a name="%_idx_5082" id="%_idx_5082"></a><a name="%_idx_5084" id="%_idx_5084"></a>during the early 80s when the Japanese government began an ambitious
+</p><p><a href="#call_footnote_Temp_648" id="footnote_Temp_648"><sup><small>61</small></sup></a> Interest in logic programming peaked
+<a id="__idx_5080"></a><a id="__idx_5082"></a><a id="__idx_5084"></a>during the early 80s when the Japanese government began an ambitious
 project aimed at building superfast computers optimized to run logic
 programming languages.  The speed of such computers was to be measured
 in LIPS (Logical Inferences Per Second) rather than the usual FLOPS
 (FLoating-point Operations Per Second).  Although the project
 succeeded in developing hardware and software as originally planned,
 the international computer industry moved in a different direction.
-See <a name="%_idx_5086" id="%_idx_5086"></a><a name="%_idx_5088" id="%_idx_5088"></a>Feigenbaum and Shrobe 1993 for an overview evaluation of the
+See <a id="__idx_5086"></a><a id="__idx_5088"></a>Feigenbaum and Shrobe 1993 for an overview evaluation of the
 Japanese project.  The logic programming community has also moved on
 to consider relational programming based on techniques other than
 simple pattern matching, such as the ability to deal with numerical
 constraints such as the ones illustrated in the constraint-propagation
-system of section <a href="book-Z-H-22.html#%_sec_3.3.5">3.3.5</a>.
+system of section <a href="book-Z-H-22.html#__sec_3.3.5">3.3.5</a>.
 
-</p><p><a name="footnote_Temp_651" href="#call_footnote_Temp_651" id="footnote_Temp_651"><sup><small>62</small></sup></a> This uses the dotted-tail notation introduced in
-exercise <a href="book-Z-H-15.html#%_thm_2.20">2.20</a>.
+</p><p><a href="#call_footnote_Temp_651" id="footnote_Temp_651"><sup><small>62</small></sup></a> This uses the dotted-tail notation introduced in
+exercise <a href="book-Z-H-15.html#__thm_2.20">2.20</a>.
 
-</p><p><a name="footnote_Temp_654" href="#call_footnote_Temp_654" id="footnote_Temp_654"><sup><small>63</small></sup></a> Actually, this description of <tt>not</tt> is valid only for simple cases.  The real behavior of <tt>not</tt>
+</p><p><a href="#call_footnote_Temp_654" id="footnote_Temp_654"><sup><small>63</small></sup></a> Actually, this description of <tt>not</tt> is valid only for simple cases.  The real behavior of <tt>not</tt>
 is more complex.  We will examine <tt>not</tt>'s peculiarities in
-sections <a href="#%_sec_4.4.2">4.4.2</a> and <a href="#%_sec_4.4.3">4.4.3</a>.
+sections <a href="#__sec_4.4.2">4.4.2</a> and <a href="#__sec_4.4.3">4.4.3</a>.
 
-</p><p><a name="footnote_Temp_655" href="#call_footnote_Temp_655" id="footnote_Temp_655"><sup><small>64</small></sup></a> <tt>Lisp-value</tt> should be used only to perform an operation not
-<a name="%_idx_5134" id="%_idx_5134"></a>provided in the query language.  In particular, it should not
+</p><p><a href="#call_footnote_Temp_655" id="footnote_Temp_655"><sup><small>64</small></sup></a> <tt>Lisp-value</tt> should be used only to perform an operation not
+<a id="__idx_5134"></a>provided in the query language.  In particular, it should not
 be used to test equality (since that is what the matching in the
 query language is designed to do) or inequality (since that can
 be done with the <tt>same</tt> rule shown below).
 
-</p><p><a name="footnote_Temp_658" href="#call_footnote_Temp_658" id="footnote_Temp_658"><sup><small>65</small></sup></a> Notice that we do not need <tt>same</tt> in order to make two things be
+</p><p><a href="#call_footnote_Temp_658" id="footnote_Temp_658"><sup><small>65</small></sup></a> Notice that we do not need <tt>same</tt> in order to make two things be
 the same: We just use the same pattern variable for each – in effect,
 we have one thing instead of two things in the first place.  For
 example, see <tt>?town</tt> in the <tt>lives-near</tt> rule and <tt>?middle-manager</tt> in the <tt>wheel</tt> rule below.
@@ -2433,66 +2433,66 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 (The values assigned to different pattern variables may be the same or
 different.)
 
-</p><p><a name="footnote_Temp_659" href="#call_footnote_Temp_659" id="footnote_Temp_659"><sup><small>66</small></sup></a> We will also allow rules without bodies, as in <tt><a name="%_idx_5146" id="%_idx_5146"></a>same</tt>, and we will interpret such a rule to mean that the rule
+</p><p><a href="#call_footnote_Temp_659" id="footnote_Temp_659"><sup><small>66</small></sup></a> We will also allow rules without bodies, as in <tt><a id="__idx_5146"></a>same</tt>, and we will interpret such a rule to mean that the rule
 conclusion is satisfied by any values of the variables.
 
-</p><p><a name="footnote_Temp_670" href="#call_footnote_Temp_670" id="footnote_Temp_670"><sup><small>67</small></sup></a> Because matching is generally very expensive, we would
-<a name="%_idx_5188" id="%_idx_5188"></a>like to avoid applying the full matcher to every element of the data
+</p><p><a href="#call_footnote_Temp_670" id="footnote_Temp_670"><sup><small>67</small></sup></a> Because matching is generally very expensive, we would
+<a id="__idx_5188"></a>like to avoid applying the full matcher to every element of the data
 base.  This is usually arranged by breaking up the process into a
 fast, coarse match and the final match.  The coarse match filters the
 data base to produce a small set of candidates for the final match.
 With care, we can arrange our data base so that some of the work of
 coarse matching can be done when the data base is constructed rather
-<a name="%_idx_5190" id="%_idx_5190"></a><a name="%_idx_5192" id="%_idx_5192"></a>then when we want to select the candidates.  This is called <em>indexing</em> the data base.  There is a vast technology built around
+<a id="__idx_5190"></a><a id="__idx_5192"></a>then when we want to select the candidates.  This is called <em>indexing</em> the data base.  There is a vast technology built around
 data-base-indexing schemes.  Our implementation, described in
-section <a href="#%_sec_4.4.4">4.4.4</a>, contains a
+section <a href="#__sec_4.4.4">4.4.4</a>, contains a
 simple-minded form of such an optimization.
 
-</p><p><a name="footnote_Temp_672" href="#call_footnote_Temp_672" id="footnote_Temp_672"><sup><small>68</small></sup></a> But this kind of exponential explosion is not common in <tt>and</tt>
+</p><p><a href="#call_footnote_Temp_672" id="footnote_Temp_672"><sup><small>68</small></sup></a> But this kind of exponential explosion is not common in <tt>and</tt>
 queries because the added conditions tend to reduce rather than expand
 the number of frames produced.
 
-</p><p><a name="footnote_Temp_673" href="#call_footnote_Temp_673" id="footnote_Temp_673"><sup><small>69</small></sup></a> There is a large literature on data-base-management
+</p><p><a href="#call_footnote_Temp_673" id="footnote_Temp_673"><sup><small>69</small></sup></a> There is a large literature on data-base-management
 systems that is concerned with how to handle complex queries
 efficiently.
 
-</p><p><a name="footnote_Temp_674" href="#call_footnote_Temp_674" id="footnote_Temp_674"><sup><small>70</small></sup></a> There is a subtle difference between this filter
+</p><p><a href="#call_footnote_Temp_674" id="footnote_Temp_674"><sup><small>70</small></sup></a> There is a subtle difference between this filter
 implementation of <tt>not</tt> and the usual meaning of <tt>not</tt> in
-mathematical logic.  See section <a href="#%_sec_4.4.3">4.4.3</a>.
+mathematical logic.  See section <a href="#__sec_4.4.3">4.4.3</a>.
 
-</p><p><a name="footnote_Temp_676" href="#call_footnote_Temp_676" id="footnote_Temp_676"><sup><small>71</small></sup></a> In one-sided pattern matching, all the equations that
+</p><p><a href="#call_footnote_Temp_676" id="footnote_Temp_676"><sup><small>71</small></sup></a> In one-sided pattern matching, all the equations that
 contain pattern variables are explicit and already solved for the
 unknown (the pattern variable).
 
-</p><p><a name="footnote_Temp_677" href="#call_footnote_Temp_677" id="footnote_Temp_677"><sup><small>72</small></sup></a> Another way to think of unification is that it generates the most
+</p><p><a href="#call_footnote_Temp_677" id="footnote_Temp_677"><sup><small>72</small></sup></a> Another way to think of unification is that it generates the most
 general pattern that is a specialization of the two input patterns.
 That is, the unification of <tt>(?x a)</tt> and <tt>((b ?y) ?z)</tt> is <tt>((b ?y) a)</tt>, and the unification of <tt>(?x a ?y)</tt> and <tt>(?y ?z
 a)</tt>, discussed above, is <tt>(a a a)</tt>.
 For our implementation, it is more convenient to think of the result
 of unification as a frame rather than a pattern.
 
-</p><p><a name="footnote_Temp_680" href="#call_footnote_Temp_680" id="footnote_Temp_680"><sup><small>73</small></sup></a> Since unification is a
-<a name="%_idx_5222" id="%_idx_5222"></a><a name="%_idx_5224" id="%_idx_5224"></a>generalization of matching, we could simplify the system by using the
+</p><p><a href="#call_footnote_Temp_680" id="footnote_Temp_680"><sup><small>73</small></sup></a> Since unification is a
+<a id="__idx_5222"></a><a id="__idx_5224"></a>generalization of matching, we could simplify the system by using the
 unifier to produce both streams.  Treating the easy case with the
 simple matcher, however, illustrates how matching (as opposed to
 full-blown unification) can be useful in its own right.
 
-</p><p><a name="footnote_Temp_682" href="#call_footnote_Temp_682" id="footnote_Temp_682"><sup><small>74</small></sup></a> The reason we use streams (rather than lists) of frames is that the
-<a name="%_idx_5236" id="%_idx_5236"></a><a name="%_idx_5238" id="%_idx_5238"></a>recursive application of rules can generate
+</p><p><a href="#call_footnote_Temp_682" id="footnote_Temp_682"><sup><small>74</small></sup></a> The reason we use streams (rather than lists) of frames is that the
+<a id="__idx_5236"></a><a id="__idx_5238"></a>recursive application of rules can generate
 infinite numbers of values that satisfy a query.  The delayed
 evaluation embodied in streams is crucial here: The system will print
 responses one by one as they are generated, regardless of whether
 there are a finite or infinite number of responses.
 
-</p><p><a name="footnote_Temp_683" href="#call_footnote_Temp_683" id="footnote_Temp_683"><sup><small>75</small></sup></a> That a particular method of inference is
+</p><p><a href="#call_footnote_Temp_683" id="footnote_Temp_683"><sup><small>75</small></sup></a> That a particular method of inference is
 legitimate is not a trivial assertion.  One must prove that if one
 starts with true premises, only true conclusions can be derived.  The
-method of inference represented by rule applications is <a name="%_idx_5250" id="%_idx_5250"></a><em>modus
+method of inference represented by rule applications is <a id="__idx_5250"></a><em>modus
 ponens</em>, the familiar method of inference that says that if <em>A</em> is
 true and <em>A implies B</em> is true, then we may conclude that <em>B</em>
 is true.
 
-</p><p><a name="footnote_Temp_684" href="#call_footnote_Temp_684" id="footnote_Temp_684"><sup><small>76</small></sup></a> We must qualify this statement by
+</p><p><a href="#call_footnote_Temp_684" id="footnote_Temp_684"><sup><small>76</small></sup></a> We must qualify this statement by
 agreeing that, in speaking of the “inference” accomplished by a
 logic program, we assume that the computation terminates.
 Unfortunately, even this qualified statement is false for our
@@ -2508,7 +2508,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 to achieve more consistency with mathematical logic without unduly
 sacrificing expressive power.
 
-</p><p><a name="footnote_Temp_686" href="#call_footnote_Temp_686" id="footnote_Temp_686"><sup><small>77</small></sup></a> This is not a problem of the logic but one of the
+</p><p><a href="#call_footnote_Temp_686" id="footnote_Temp_686"><sup><small>77</small></sup></a> This is not a problem of the logic but one of the
 procedural interpretation of the logic provided by our interpreter.
 We could write an interpreter that would not fall into a loop here.
 For example, we could enumerate all the proofs derivable from our
@@ -2516,25 +2516,25 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 order.  However, such a system makes it more difficult to take
 advantage of the order of deductions in our programs.  One attempt to
 build sophisticated control into such a program is described in
-<a name="%_idx_5264" id="%_idx_5264"></a>deKleer et al. 1977.  Another technique, which does not lead to such
+<a id="__idx_5264"></a>deKleer et al. 1977.  Another technique, which does not lead to such
 serious control problems, is to put in special knowledge, such as
 detectors for particular kinds of loops
-(exercise <a href="#%_thm_4.67">4.67</a>).  However, there can be no
+(exercise <a href="#__thm_4.67">4.67</a>).  However, there can be no
 general scheme for reliably preventing a system from going down
 infinite paths in performing deductions.  Imagine a diabolical rule of
 the form “To show <em>P</em>(<em>x</em>) is true, show that <em>P</em>(<em>f</em>(<em>x</em>)) is true,” for
 some suitably chosen function <em>f</em>.
 
-</p><p><a name="footnote_Temp_688" href="#call_footnote_Temp_688" id="footnote_Temp_688"><sup><small>78</small></sup></a> Consider the query <tt>(not (baseball-fan (Bitdiddle Ben)))</tt>.  The system finds that <tt>(baseball-fan (Bitdiddle Ben))</tt> is not in the data base, so the empty
+</p><p><a href="#call_footnote_Temp_688" id="footnote_Temp_688"><sup><small>78</small></sup></a> Consider the query <tt>(not (baseball-fan (Bitdiddle Ben)))</tt>.  The system finds that <tt>(baseball-fan (Bitdiddle Ben))</tt> is not in the data base, so the empty
 frame does not satisfy the pattern and is not filtered out of the
 initial stream of frames.  The result of the query is thus the empty
 frame, which is used to instantiate the input query to produce <tt>(not (baseball-fan (Bitdiddle Ben)))</tt>.
 
-</p><p><a name="footnote_Temp_689" href="#call_footnote_Temp_689" id="footnote_Temp_689"><sup><small>79</small></sup></a> A discussion and justification of this
-<a name="%_idx_5274" id="%_idx_5274"></a>treatment of <tt>not</tt> can be found in the article by Clark (1978).
+</p><p><a href="#call_footnote_Temp_689" id="footnote_Temp_689"><sup><small>79</small></sup></a> A discussion and justification of this
+<a id="__idx_5274"></a>treatment of <tt>not</tt> can be found in the article by Clark (1978).
 
-</p><p><a name="footnote_Temp_700" href="#call_footnote_Temp_700" id="footnote_Temp_700"><sup><small>80</small></sup></a> In general, unifying <tt>?y</tt> with an expression involving
-<a name="%_idx_5366" id="%_idx_5366"></a><tt>?y</tt> would require our being able to find a fixed point of the
+</p><p><a href="#call_footnote_Temp_700" id="footnote_Temp_700"><sup><small>80</small></sup></a> In general, unifying <tt>?y</tt> with an expression involving
+<a id="__idx_5366"></a><tt>?y</tt> would require our being able to find a fixed point of the
 equation <tt>?y</tt>  =  &lt;<em>expression involving <tt>?y</tt></em>&gt;.  It is
 sometimes possible to syntactically form an expression that appears to
 be the solution.  For example, <tt>?y</tt>  =  <tt>(f ?y)</tt> seems to have
@@ -2542,28 +2542,28 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 beginning with the expression <tt>(f ?y)</tt> and repeatedly substituting
 <tt>(f ?y)</tt> for <tt>?y</tt>.  Unfortunately, not every such equation has
 a meaningful fixed point.  The issues that arise here are similar to
-the issues of manipulating <a name="%_idx_5368" id="%_idx_5368"></a>infinite series in mathematics.  For
+the issues of manipulating <a id="__idx_5368"></a>infinite series in mathematics.  For
 example, we know that 2 is the solution to the equation <em>y</em>  =  1  +  <em>y</em>/2.
 Beginning with the expression 1  +  <em>y</em>/2 and repeatedly substituting 1
  +  <em>y</em>/2 for <em>y</em> gives
-</p><p></p><div align="left"><img src="images/ch4-Z-G-7.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch4-Z-G-7.gif" alt="ch4-Z-G-7" style="border: none;" /></div><p>
 which leads to
-</p><p></p><div align="left"><img src="images/ch4-Z-G-8.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch4-Z-G-8.gif" alt="ch4-Z-G-8" style="border: none;" /></div><p>
 However, if we try the same manipulation beginning with the
 observation that  - 1 is the solution to the equation <em>y</em>  =  1  +  2<em>y</em>, we
 obtain
-</p><p></p><div align="left"><img src="images/ch4-Z-G-9.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch4-Z-G-9.gif" alt="ch4-Z-G-9" style="border: none;" /></div><p>
 which leads to
-</p><p></p><div align="left"><img src="images/ch4-Z-G-10.gif" border="0" /></div><p>
+</p><p></p><div style="text-align: left;"><img src="images/ch4-Z-G-10.gif" alt="ch4-Z-G-10" style="border: none;" /></div><p>
 Although the formal manipulations used in deriving these two equations
 are identical, the first result is a valid assertion about infinite
 series but the second is not.  Similarly, for our unification results,
 reasoning with an arbitrary syntactically constructed expression may
 lead to errors.
 
-</p><p><a name="footnote_Temp_702" href="#call_footnote_Temp_702" id="footnote_Temp_702"><sup><small>81</small></sup></a> Most Lisp systems give the user the ability to
+</p><p><a href="#call_footnote_Temp_702" id="footnote_Temp_702"><sup><small>81</small></sup></a> Most Lisp systems give the user the ability to
 modify the ordinary <tt>read</tt> procedure to perform such
-transformations by defining <a name="%_idx_5402" id="%_idx_5402"></a><a name="%_idx_5404" id="%_idx_5404"></a><a name="%_idx_5406" id="%_idx_5406"></a><a name="%_idx_5408" id="%_idx_5408"></a><em>reader macro characters</em>.  Quoted
+transformations by defining <a id="__idx_5402"></a><a id="__idx_5404"></a><a id="__idx_5406"></a><a id="__idx_5408"></a><em>reader macro characters</em>.  Quoted
 expressions are already handled in this way: The reader automatically
 translates <tt>'expression</tt> into <tt>(quote expression)</tt> before the
 evaluator sees it.  We could arrange for <tt>?expression</tt> to be
@@ -2571,7 +2571,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_4.4">4.4  Logic Programming</a></h2><
 the sake of clarity we have included the transformation procedure here
 explicitly.</p><p>
 
-<a name="%_idx_5410" id="%_idx_5410"></a><tt>Expand-question-mark</tt> and <tt>contract-question-mark</tt> use
+<a id="__idx_5410"></a><tt>Expand-question-mark</tt> and <tt>contract-question-mark</tt> use
 several procedures with <tt>string</tt> in their names.
 These are Scheme primitives.
 
diff --git a/src/OEBPS/book-Z-H-3.html b/src/OEBPS/book-Z-H-3.html
index 4f83bc1..9d58739 100644
--- a/src/OEBPS/book-Z-H-3.html
+++ b/src/OEBPS/book-Z-H-3.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
diff --git a/src/OEBPS/book-Z-H-30.html b/src/OEBPS/book-Z-H-30.html
index 4593ee0..bc0d05a 100644
--- a/src/OEBPS/book-Z-H-30.html
+++ b/src/OEBPS/book-Z-H-30.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,14 +13,14 @@
 
 
 
-<a name="%_chap_5" id="%_chap_5"></a>
+<a id="__chap_5"></a>
 <h1 class="chapter">
-<div class="chapterheading"><a href="book-Z-H-4.html#%_toc_%_chap_5">Chapter 5</a></div></h1><p>
-<a href="book-Z-H-4.html#%_toc_%_chap_5">Computing with Register Machines</a></p><p>
+<div class="chapterheading">Chapter 5</div></h1><p>
+Computing with Register Machines</p><p>
 
 </p><p>
-</p><div align="right">
-<table width="60%"><tr><td>
+</p><div style="text-align: right;">
+<table width="60_"><tr><td>
 <span class="epigraph">
 <p>
 
@@ -30,7 +30,7 @@ <h1 class="chapter">
 all the manifold motions are caused by a most simple and material
 force, just as all motions of the clock are caused by a single weight.</p><p>
 
-<a name="%_idx_5456" id="%_idx_5456"></a>Johannes Kepler (letter to Herwart von Hohenburg, 1605)</p><p>
+<a id="__idx_5456"></a>Johannes Kepler (letter to Herwart von Hohenburg, 1605)</p><p>
 
 </p></span>
 </td></tr></table></div>
@@ -59,9 +59,9 @@ <h1 class="chapter">
 we must work at a more primitive level than Lisp itself.</p><p>
 
 In this chapter we will describe processes in terms of the step-by-step
-operation of a traditional computer.  Such a computer, or <a name="%_idx_5458" id="%_idx_5458"></a><em>register
+operation of a traditional computer.  Such a computer, or <a id="__idx_5458"></a><em>register
 machine</em>, sequentially executes <em>instructions</em> that
-manipulate the contents of a fixed set of storage elements called <a name="%_idx_5460" id="%_idx_5460"></a><em>registers</em>.  A typical register-machine instruction applies a
+manipulate the contents of a fixed set of storage elements called <a id="__idx_5460"></a><em>registers</em>.  A typical register-machine instruction applies a
 primitive operation to the contents of some registers and assigns the
 result to another register.  Our descriptions of processes executed by
 register machines will look very much like “machine-language”
@@ -74,7 +74,7 @@ <h1 class="chapter">
 we will develop mechanisms for implementing important programming
 constructs such as recursion.  We will also present a language for
 describing designs for register machines.  In
-section <a href="book-Z-H-32.html#%_sec_5.2">5.2</a> we will
+section <a href="book-Z-H-32.html#__sec_5.2">5.2</a> we will
 implement a Lisp program that
 uses these descriptions to simulate the machines we design.</p><p>
 
@@ -85,17 +85,17 @@ <h1 class="chapter">
 order to deal with list structure, however, we will also use the
 memory operations <tt>car</tt>, <tt>cdr</tt>, and <tt>cons</tt>, which require
 an elaborate storage-allocation mechanism.  In
-section <a href="book-Z-H-33.html#%_sec_5.3">5.3</a> we study their implementation in
+section <a href="book-Z-H-33.html#__sec_5.3">5.3</a> we study their implementation in
 terms of more elementary operations.</p><p>
 
-In section <a href="book-Z-H-34.html#%_sec_5.4">5.4</a>, after we have accumulated experience
+In section <a href="book-Z-H-34.html#__sec_5.4">5.4</a>, after we have accumulated experience
 formulating simple procedures as register machines, we will design a
 machine that carries out the algorithm described by the metacircular
-evaluator of section <a href="book-Z-H-26.html#%_sec_4.1">4.1</a>.  This will fill in the gap in
+evaluator of section <a href="book-Z-H-26.html#__sec_4.1">4.1</a>.  This will fill in the gap in
 our understanding of how Scheme expressions are interpreted, by
 providing an explicit model for the mechanisms of control in the
 evaluator.
-In section <a href="book-Z-H-35.html#%_sec_5.5">5.5</a> we will study a simple compiler that
+In section <a href="book-Z-H-35.html#__sec_5.5">5.5</a> we will study a simple compiler that
 translates Scheme programs into sequences of instructions that can be
 executed directly with the registers and operations of the evaluator
 register machine.</p><p>
diff --git a/src/OEBPS/book-Z-H-31.html b/src/OEBPS/book-Z-H-31.html
index b1c4cd5..1af36ea 100644
--- a/src/OEBPS/book-Z-H-31.html
+++ b/src/OEBPS/book-Z-H-31.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,18 +13,18 @@
 
 
 
-<a name="%_sec_5.1" id="%_sec_5.1"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines</a></h2><p>
+<a id="__sec_5.1"></a>
+<h2>5.1  Designing Register Machines</h2><p>
 
 
-<a name="%_idx_5462" id="%_idx_5462"></a><a name="%_idx_5464" id="%_idx_5464"></a><a name="%_idx_5466" id="%_idx_5466"></a><a name="%_idx_5468" id="%_idx_5468"></a><a name="%_idx_5470" id="%_idx_5470"></a><a name="%_idx_5472" id="%_idx_5472"></a>
+<a id="__idx_5462"></a><a id="__idx_5464"></a><a id="__idx_5466"></a><a id="__idx_5468"></a><a id="__idx_5470"></a><a id="__idx_5472"></a>
 
 To design a register machine, we must design its <em>data paths</em>
 (registers and operations) and the <em>controller</em> that sequences
 these operations.  To illustrate the design of a simple register
 machine, let us examine Euclid's Algorithm, which is used to compute
-<a name="%_idx_5474" id="%_idx_5474"></a>the greatest common divisor (GCD) of two integers.  As we saw in
-<a name="%_idx_5476" id="%_idx_5476"></a>section <a href="book-Z-H-11.html#%_sec_1.2.5">1.2.5</a>, Euclid's Algorithm can be carried out by an iterative
+<a id="__idx_5474"></a>the greatest common divisor (GCD) of two integers.  As we saw in
+<a id="__idx_5476"></a>section <a href="book-Z-H-11.html#__sec_1.2.5">1.2.5</a>, Euclid's Algorithm can be carried out by an iterative
 process, as specified by the following procedure:</p><p>
 
 
@@ -52,9 +52,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 in <tt>a</tt>, and finally the remainder stored in <tt>t</tt> will be placed
 in <tt>b</tt>.)</p><p>
 
-<a name="%_idx_5478" id="%_idx_5478"></a><a name="%_idx_5480" id="%_idx_5480"></a>We can illustrate the registers and operations required for this
+<a id="__idx_5478"></a><a id="__idx_5480"></a>We can illustrate the registers and operations required for this
 machine by using the data-path diagram shown in
-figure <a href="#%_fig_5.1">5.1</a>.  In this
+figure <a href="#__fig_5.1">5.1</a>.  In this
 diagram, the registers (<tt>a</tt>, <tt>b</tt>, and <tt>t</tt>) are represented
 by rectangles.  Each way to assign a value to a register is
 indicated by an arrow with an <tt>X</tt> behind the head, pointing from
@@ -72,7 +72,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 
 An operation that computes a value from constants and the contents
 of registers is represented in a data-path diagram by a trapezoid
-containing a name for the operation.  For example, the box marked <tt>rem</tt> in figure <a href="#%_fig_5.1">5.1</a> represents an
+containing a name for the operation.  For example, the box marked <tt>rem</tt> in figure <a href="#__fig_5.1">5.1</a> represents an
 operation that computes the remainder of the contents of the
 registers <tt>a</tt> and <tt>b</tt> to which it is attached.  Arrows
 (without buttons) point from the input registers and constants to the
@@ -81,7 +81,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 example, our GCD machine has an operation that
 tests whether the contents of register
 <tt>b</tt> is zero.  A test also has arrows from its input
-<a name="%_idx_5482" id="%_idx_5482"></a><a name="%_idx_5484" id="%_idx_5484"></a>registers and constants, but it has no output
+<a id="__idx_5482"></a><a id="__idx_5484"></a>registers and constants, but it has no output
 arrows; its value is used by the controller rather than by the data
 paths.  Overall, the data-path diagram shows the registers and
 operations that are required for the machine and how they must be
@@ -91,14 +91,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 
 </p><p>
 
-<a name="%_fig_5.1" id="%_fig_5.1"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch5-Z-G-1.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 5.1:</b>  Data paths for a GCD machine.</div></caption><tr><td>
+<a id="__fig_5.1"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch5-Z-G-1.gif" alt="ch5-Z-G-1" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.1:</b>  Data paths for a GCD machine.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_idx_5486" id="%_idx_5486"></a><a name="%_idx_5488" id="%_idx_5488"></a>In order for the data paths to actually compute GCDs, the buttons must
+<a id="__idx_5486"></a><a id="__idx_5488"></a>In order for the data paths to actually compute GCDs, the buttons must
 be pushed in the correct sequence.  We will describe this sequence in
 terms of a controller diagram, as illustrated in
-figure <a href="#%_fig_5.2">5.2</a>.  The elements of the controller
+figure <a href="#__fig_5.2">5.2</a>.  The elements of the controller
 diagram indicate how the
 data-path components should be operated.  The rectangular boxes in the
 controller diagram identify data-path buttons to be pushed, and the
@@ -116,13 +116,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 marble) at the place marked <tt>start</tt>, after placing numbers in
 registers <tt>a</tt> and <tt>b</tt>.  When the controller reaches <tt>done</tt>, we will find the value of the GCD in register <tt>a</tt>.
 
-<a name="%_fig_5.2" id="%_fig_5.2"></a></p><p></p><div align="left"><table width="100%"><tr><td>
-<img src="images/ch5-Z-G-2.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 5.2:</b>  Controller for a GCD machine.</div></caption><tr><td>
+<a id="__fig_5.2"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td>
+<img src="images/ch5-Z-G-2.gif" alt="ch5-Z-G-2" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.2:</b>  Controller for a GCD machine.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-</p><p><a name="%_thm_5.1" id="%_thm_5.1"></a>
-<b>Exercise 5.1.</b>  <a name="%_idx_5490" id="%_idx_5490"></a>Design a register machine to compute factorials using the iterative
+</p><p><a id="__thm_5.1"></a>
+<b>Exercise 5.1.</b>  <a id="__idx_5490"></a>Design a register machine to compute factorials using the iterative
 algorithm specified by the following procedure.  Draw data-path and
 controller diagrams for this machine.</p><p>
 
@@ -136,11 +136,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 </p><p>
 </p><p>
 
-<a name="%_sec_5.1.1" id="%_sec_5.1.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.1.1">5.1.1  A Language for Describing Register Machines</a></h3><p>
+<a id="__sec_5.1.1"></a>
+</p><h3>5.1.1  A Language for Describing Register Machines</h3><p>
 
 
-<a name="%_idx_5492" id="%_idx_5492"></a>
+<a id="__idx_5492"></a>
 Data-path and controller diagrams are adequate for representing simple
 machines such as GCD, but they are unwieldy for describing large
 machines such as a Lisp interpreter.  To make it possible to deal with
@@ -159,21 +159,21 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 To describe an operation, we give
 it a name and specify its inputs (registers or constants).</p><p>
 
-We define the controller of a machine as a sequence of <a name="%_idx_5494" id="%_idx_5494"></a><em>instructions</em> together with <a name="%_idx_5496" id="%_idx_5496"></a><a name="%_idx_5498" id="%_idx_5498"></a><em>labels</em> that identify <em>entry
+We define the controller of a machine as a sequence of <a id="__idx_5494"></a><em>instructions</em> together with <a id="__idx_5496"></a><a id="__idx_5498"></a><em>labels</em> that identify <em>entry
 points</em> in the sequence. An instruction is one of the following:
 </p><p></p><ul><li>The name of a data-path button to push to assign a value to
 a register.  (This corresponds to a box in the controller diagram.)<p>
 
-<a name="%_idx_5500" id="%_idx_5500"></a><a name="%_idx_5502" id="%_idx_5502"></a></p></li><li>A <tt>test</tt> instruction, that performs a specified test.<p>
+<a id="__idx_5500"></a><a id="__idx_5502"></a></p></li><li>A <tt>test</tt> instruction, that performs a specified test.<p>
 
-<a name="%_idx_5504" id="%_idx_5504"></a><a name="%_idx_5506" id="%_idx_5506"></a><a name="%_idx_5508" id="%_idx_5508"></a><a name="%_idx_5510" id="%_idx_5510"></a></p></li><li>A conditional branch (<tt>branch</tt> instruction) to a
+<a id="__idx_5504"></a><a id="__idx_5506"></a><a id="__idx_5508"></a><a id="__idx_5510"></a></p></li><li>A conditional branch (<tt>branch</tt> instruction) to a
 location indicated by a controller label, based on the result of the
 previous test.  (The test and branch together correspond to a diamond
 in the controller diagram.)  If the test is false, the controller
 should continue with the next instruction in the sequence.  Otherwise,
 the controller should continue with the instruction after the label.<p>
 
-<a name="%_idx_5512" id="%_idx_5512"></a><a name="%_idx_5514" id="%_idx_5514"></a></p></li><li>An unconditional branch (<tt>goto</tt> instruction) naming a
+<a id="__idx_5512"></a><a id="__idx_5514"></a></p></li><li>An unconditional branch (<tt>goto</tt> instruction) naming a
 controller label at which to continue execution.
 </li></ul><p>
 The machine starts at the beginning of the controller instruction
@@ -181,7 +181,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 Except when a branch changes the flow of control, instructions are
 executed in the order in which they are listed.</p><p>
 
-<a name="%_fig_5.3" id="%_fig_5.3"></a></p><p></p><div align="left"><table width="100%"><tr><td><p></p><p><tt>(data-paths<br />
+<a id="__fig_5.3"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><p></p><p><tt>(data-paths<br />
  (registers<br />
   ((name a)<br />
    (buttons ((name a&lt;-b) (source (register b)))))<br />
@@ -203,11 +203,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
    (b&lt;-t)                         <em>; button push</em><br />
    (goto (label test-b))          <em>; unconditional branch</em><br />
  gcd-done)                        <em>; label</em><br /></tt></p><p></p><p>
-</p><p></p><p></p></td></tr><caption align="bottom"><div align="left"><b>Figure 5.3:</b>  A specification of the GCD machine.</div></caption><tr><td>
+</p><p></p><p></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.3:</b>  A specification of the GCD machine.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-Figure <a href="#%_fig_5.3">5.3</a> shows the GCD machine described in
+Figure <a href="#__fig_5.3">5.3</a> shows the GCD machine described in
 this way.  This example only hints at the generality of these
 descriptions, since the GCD machine is a very simple case: Each
 register has only one button, and each button and test is used only
@@ -227,12 +227,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 and separately saying (in the data paths) “Button <tt>t&lt;-r</tt> assigns
 the value of the <tt>rem</tt> operation to register <tt>t</tt>” and “The
 <tt>rem</tt> operation's inputs are the contents of registers
-<a name="%_idx_5516" id="%_idx_5516"></a><a name="%_idx_5518" id="%_idx_5518"></a><a name="%_idx_5520" id="%_idx_5520"></a><a name="%_idx_5522" id="%_idx_5522"></a><a name="%_idx_5524" id="%_idx_5524"></a><a name="%_idx_5526" id="%_idx_5526"></a><tt>a</tt> and <tt>b</tt>,” we will say (in the controller) “Push the
+<a id="__idx_5516"></a><a id="__idx_5518"></a><a id="__idx_5520"></a><a id="__idx_5522"></a><a id="__idx_5524"></a><a id="__idx_5526"></a><tt>a</tt> and <tt>b</tt>,” we will say (in the controller) “Push the
 button that assigns to register <tt>t</tt> the value of the <tt>rem</tt>
 operation on the contents of registers <tt>a</tt> and <tt>b</tt>.”
 Similarly, instead of saying (in the controller) “Perform the <tt>=</tt> test” and separately saying (in the data paths) “The <tt>=</tt> test operates on the contents of register <tt>b</tt> and the
 constant 0,” we will say “Perform the <tt>=</tt> test on the
-<a name="%_idx_5528" id="%_idx_5528"></a><a name="%_idx_5530" id="%_idx_5530"></a>contents of register <tt>b</tt> and the constant 0.”  We will omit the
+<a id="__idx_5528"></a><a id="__idx_5530"></a>contents of register <tt>b</tt> and the constant 0.”  We will omit the
 data-path description, leaving only the controller sequence.  Thus,
 the GCD machine is described as follows:</p><p>
 
@@ -247,7 +247,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
  gcd-done)<br /></tt></p><p></p><p></p><p>
 
 This form of description is easier to read than the kind illustrated
-in figure <a href="#%_fig_5.3">5.3</a>, but it also has disadvantages:
+in figure <a href="#__fig_5.3">5.3</a>, but it also has disadvantages:
 
 </p><p></p><ul><p>
 
@@ -273,23 +273,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 connections in data paths.  We should keep in mind,
 however, that data-path design is crucial in designing real machines.</p><p>
 
-</p><p><a name="%_thm_5.2" id="%_thm_5.2"></a>
-<b>Exercise 5.2.</b>  <a name="%_idx_5532" id="%_idx_5532"></a>Use the register-machine language to describe
-the iterative factorial machine of exercise <a href="#%_thm_5.1">5.1</a>.
+</p><p><a id="__thm_5.2"></a>
+<b>Exercise 5.2.</b>  <a id="__idx_5532"></a>Use the register-machine language to describe
+the iterative factorial machine of exercise <a href="#__thm_5.1">5.1</a>.
 </p><p></p><p>
 
 
-<a name="%_sec_Temp_714" id="%_sec_Temp_714"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_714">Actions</a></h4><p>
+<a id="__sec_Temp_714"></a>
+</p><h4>Actions</h4><p>
 
-<a name="%_idx_5534" id="%_idx_5534"></a><a name="%_idx_5536" id="%_idx_5536"></a>
+<a id="__idx_5534"></a><a id="__idx_5536"></a>
 Let us modify the GCD machine so that we can type in the numbers
 whose GCD we want and get the answer printed at our terminal.  We will
 not discuss how to make a machine that can read and print, but will
 assume (as we do when we use <tt>read</tt> and <tt>display</tt> in Scheme) that
-they are available as primitive operations.<a name="call_footnote_Temp_715" href="#footnote_Temp_715" id="call_footnote_Temp_715"><sup><small>1</small></sup></a></p><p>
+they are available as primitive operations.<a href="#footnote_Temp_715" id="call_footnote_Temp_715"><sup><small>1</small></sup></a></p><p>
 
-<a name="%_idx_5538" id="%_idx_5538"></a><tt>Read</tt> is like the operations we have been using in that it
+<a id="__idx_5538"></a><tt>Read</tt> is like the operations we have been using in that it
 produces a value that can be stored in a register.  But <tt>read</tt>
 does not take inputs from any registers; its value depends on
 something that happens outside the parts of the machine we are
@@ -297,7 +297,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 behavior, and thus will draw and notate the use of <tt>read</tt> just as
 we do any other operation that computes a value.</p><p>
 
-<a name="%_idx_5540" id="%_idx_5540"></a><tt>Print</tt>, on the other hand, differs from the operations we have
+<a id="__idx_5540"></a><tt>Print</tt>, on the other hand, differs from the operations we have
 been using in a fundamental way: It does not produce an output value
 to be stored in a register.  Though it has an effect, this effect is
 not on a part of the machine we are designing.  We will refer to this
@@ -307,20 +307,20 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 Arrows point to the action box from any inputs (registers or
 constants).  We also associate a button with the action.  Pushing the
 button makes the action happen.  To make a controller push an action
-<a name="%_idx_5542" id="%_idx_5542"></a><a name="%_idx_5544" id="%_idx_5544"></a>button we use a new kind of instruction called <tt>perform</tt>.  Thus,
+<a id="__idx_5542"></a><a id="__idx_5544"></a>button we use a new kind of instruction called <tt>perform</tt>.  Thus,
 the action of printing the contents of register <tt>a</tt> is represented
 in a controller sequence by the instruction</p><p>
 
 </p><p></p><p><tt>(perform (op print) (reg a))<br /></tt></p><p></p><p></p><p>
 
-Figure <a href="#%_fig_5.4">5.4</a> shows the data paths and controller for
+Figure <a href="#__fig_5.4">5.4</a> shows the data paths and controller for
 the new GCD machine.  Instead of having the machine stop after
 printing the answer, we have made it start over, so that it repeatedly
 reads a pair of numbers, computes their GCD, and prints the result.
 This structure is like the driver loops we used in the interpreters of
 chapter 4.</p><p>
 
-<a name="%_fig_5.4" id="%_fig_5.4"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch5-Z-G-3.gif" border="0" /><p></p><p><tt> (controller<br />
+<a id="__fig_5.4"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch5-Z-G-3.gif" alt="ch5-Z-G-3" style="border: none;" /><p></p><p><tt> (controller<br />
   gcd-loop<br />
     (assign a (op read))<br />
     (assign b (op read))<br />
@@ -334,17 +334,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
   gcd-done<br />
     (perform (op print) (reg a))<br />
     (goto (label gcd-loop)))<br /></tt></p><p></p><p>
-</p><p></p><p></p></td></tr><caption align="bottom"><div align="left"><b>Figure 5.4:</b>  A GCD machine that reads inputs and prints results.</div></caption><tr><td>
+</p><p></p><p></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.4:</b>  A GCD machine that reads inputs and prints results.</div></caption><tr><td>
 
 </td></tr></table></div><p>
 
-<a name="%_sec_5.1.2" id="%_sec_5.1.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.1.2">5.1.2  Abstraction in Machine Design</a></h3><p>
+<a id="__sec_5.1.2"></a>
+</p><h3>5.1.2  Abstraction in Machine Design</h3><p>
 
-<a name="%_idx_5546" id="%_idx_5546"></a>
+<a id="__idx_5546"></a>
 We will often define a machine to include “primitive” operations that are
-actually very complex.  For example, in sections <a href="book-Z-H-34.html#%_sec_5.4">5.4</a> and
-<a href="book-Z-H-35.html#%_sec_5.5">5.5</a> we will treat Scheme's environment
+actually very complex.  For example, in sections <a href="book-Z-H-34.html#__sec_5.4">5.4</a> and
+<a href="book-Z-H-35.html#__sec_5.5">5.5</a> we will treat Scheme's environment
 manipulations as primitive.  Such abstraction is valuable because it
 allows us to ignore the details of parts of a machine so that we can
 concentrate on other aspects of the design.  The fact that we have
@@ -366,11 +366,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
       (remainder (- n d) d)))<br /></tt></p><p></p><p>
 We can thus replace the remainder operation in the GCD machine's
 data paths with a subtraction operation and a comparison test.
-Figure <a href="#%_fig_5.5">5.5</a> shows the data paths and controller
+Figure <a href="#__fig_5.5">5.5</a> shows the data paths and controller
 for the elaborated machine.
 The instruction</p><p>
 
-<a name="%_fig_5.5" id="%_fig_5.5"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch5-Z-G-4.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 5.5:</b>  Data paths and controller for the elaborated GCD  machine.</div></caption><tr><td>
+<a id="__fig_5.5"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch5-Z-G-4.gif" alt="ch5-Z-G-4" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.5:</b>  Data paths and controller for the elaborated GCD  machine.</div></caption><tr><td>
 
 
 </td></tr></table></div><p>                                </p><p>
@@ -378,9 +378,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 </p><p></p><p><tt>(assign t (op rem) (reg a) (reg b))<br /></tt></p><p></p><p>
 in the GCD controller definition is replaced by a sequence of
 instructions that contains a loop, as shown in
-figure <a href="#%_fig_5.6">5.6</a>.</p><p>
+figure <a href="#__fig_5.6">5.6</a>.</p><p>
 
-<a name="%_fig_5.6" id="%_fig_5.6"></a></p><p></p><div align="left"><table width="100%"><tr><td><p></p><p><tt>(controller<br />
+<a id="__fig_5.6"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><p></p><p><tt>(controller<br />
  test-b<br />
    (test (op =) (reg b) (const 0))<br />
    (branch (label gcd-done))<br />
@@ -395,14 +395,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
    (assign b (reg t))<br />
    (goto (label test-b))<br />
  gcd-done)<br /></tt></p><p></p><p>
-</p><p></p><p></p></td></tr><caption align="bottom"><div align="left"><b>Figure 5.6:</b>  Controller instruction sequence for the GCD machine in
-figure <a href="#%_fig_5.5">5.5</a>.</div></caption><tr><td>
+</p><p></p><p></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.6:</b>  Controller instruction sequence for the GCD machine in
+figure <a href="#__fig_5.5">5.5</a>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-</p><p><a name="%_thm_5.3" id="%_thm_5.3"></a>
-<b>Exercise 5.3.</b>  <a name="%_idx_5548" id="%_idx_5548"></a>Design a machine to compute square roots using Newton's method, as
-described in section <a href="book-Z-H-10.html#%_sec_1.1.7">1.1.7</a>:</p><p>
+</p><p><a id="__thm_5.3"></a>
+<b>Exercise 5.3.</b>  <a id="__idx_5548"></a>Design a machine to compute square roots using Newton's method, as
+described in section <a href="book-Z-H-10.html#__sec_1.1.7">1.1.7</a>:</p><p>
 
 </p><p></p><p><tt>(define (sqrt x)<br />
   (define (good-enough? guess)<br />
@@ -422,11 +422,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 </p><p>
 </p><p>
 
-<a name="%_sec_5.1.3" id="%_sec_5.1.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.1.3">5.1.3  Subroutines</a></h3><p>
+<a id="__sec_5.1.3"></a>
+</p><h3>5.1.3  Subroutines</h3><p>
 
 
-<a name="%_idx_5550" id="%_idx_5550"></a><a name="%_idx_5552" id="%_idx_5552"></a>
+<a id="__idx_5550"></a><a id="__idx_5552"></a>
 When designing a machine to perform a computation, we would often
 prefer to arrange for components to be shared by different parts of
 the computation rather than duplicate the components.  Consider a
@@ -435,12 +435,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 GCD of the contents of registers <tt>c</tt> and <tt>d</tt>.  We might start
 by assuming we have a primitive <tt>gcd</tt> operation, then expand the
 two instances of <tt>gcd</tt> in terms of more primitive operations.
-Figure <a href="#%_fig_5.7">5.7</a> shows just the GCD portions of the
+Figure <a href="#__fig_5.7">5.7</a> shows just the GCD portions of the
 resulting machine's data paths, without showing how they connect to
 the rest of the machine.  The figure also shows the corresponding
 portions of the machine's controller sequence.</p><p>
 
-<a name="%_fig_5.7" id="%_fig_5.7"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch5-Z-G-5.gif" border="0" /><p></p><p><tt>gcd-1<br />
+<a id="__fig_5.7"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch5-Z-G-5.gif" alt="ch5-Z-G-5" style="border: none;" /><p></p><p><tt>gcd-1<br />
  (test (op =) (reg b) (const 0))<br />
  (branch (label after-gcd-1))<br />
  (assign t (op rem) (reg a) (reg b))<br />
@@ -457,7 +457,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
  (assign d (reg s))<br />
  (goto (label gcd-2))<br />
 after-gcd-2<br /></tt></p><p></p><p>
-</p><p></p><p></p></td></tr><caption align="bottom"><div align="left"><b>Figure 5.7:</b>  Portions of the data paths and controller sequence for
+</p><p></p><p></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.7:</b>  Portions of the data paths and controller sequence for
 a machine with two GCD computations.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
@@ -474,24 +474,24 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 it uses registers <tt>a</tt> and <tt>b</tt>, rather than registers <tt>c</tt>
 and <tt>d</tt>, in computing the second GCD as well as the first.  If we
 do this, we obtain the controller sequence shown in
-figure <a href="#%_fig_5.8">5.8</a>.</p><p>
+figure <a href="#__fig_5.8">5.8</a>.</p><p>
 
 We have removed the duplicate data-path components
-(so that the data paths are again as in figure <a href="#%_fig_5.1">5.1</a>),
+(so that the data paths are again as in figure <a href="#__fig_5.1">5.1</a>),
 but the controller
 now has two GCD sequences that differ only in their entry-point
 labels.  It would be better to replace these two sequences by branches
 to a single sequence – a <tt>gcd</tt> <em>subroutine</em> – at the end of
 which we branch back to the correct place in the main instruction
 sequence.  We can accomplish this as follows: Before branching to <tt>gcd</tt>, we place a distinguishing value (such as 0 or 1) into a special
-register, <a name="%_idx_5554" id="%_idx_5554"></a><tt>continue</tt>.  At the end of the <tt>gcd</tt> subroutine we
+register, <a id="__idx_5554"></a><tt>continue</tt>.  At the end of the <tt>gcd</tt> subroutine we
 return either to <tt>after-gcd-1</tt> or to <tt>after-gcd-2</tt>, depending
 on the value of the <tt>continue</tt> register.
-Figure <a href="#%_fig_5.9">5.9</a> shows the relevant portion of the
+Figure <a href="#__fig_5.9">5.9</a> shows the relevant portion of the
 resulting controller sequence, which includes only a single copy of the
 <tt>gcd</tt> instructions.</p><p>
 
-<a name="%_fig_5.8" id="%_fig_5.8"></a></p><p></p><div align="left"><table width="100%"><tr><td><p></p><p><tt>gcd-1<br />
+<a id="__fig_5.8"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><p></p><p><tt>gcd-1<br />
  (test (op =) (reg b) (const 0))<br />
  (branch (label after-gcd-1))<br />
  (assign t (op rem) (reg a) (reg b))<br />
@@ -508,13 +508,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
  (assign b (reg t))<br />
  (goto (label gcd-2))<br />
 after-gcd-2<br /></tt></p><p></p><p>
-</p><p></p><p></p></td></tr><caption align="bottom"><div align="left"><b>Figure 5.8:</b>  Portions of the controller sequence for a machine that
+</p><p></p><p></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.8:</b>  Portions of the controller sequence for a machine that
 uses the same data-path components for two different GCD
 computations.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_fig_5.9" id="%_fig_5.9"></a></p><p></p><div align="left"><table width="100%"><tr><td><p></p><p><tt>gcd<br />
+<a id="__fig_5.9"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><p></p><p><tt>gcd<br />
  (test (op =) (reg b) (const 0))<br />
  (branch (label gcd-done))<br />
  (assign t (op rem) (reg a) (reg b))<br />
@@ -533,12 +533,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
  (assign continue (const 1))<br />
  (goto (label gcd))<br />
 after-gcd-2<br /></tt></p><p></p><p>
-</p><p></p><p></p></td></tr><caption align="bottom"><div align="left"><b>Figure 5.9:</b>  Using a <tt>continue</tt> register to avoid
-the duplicate controller sequence in figure <a href="#%_fig_5.8">5.8</a>.</div></caption><tr><td>
+</p><p></p><p></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.9:</b>  Using a <tt>continue</tt> register to avoid
+the duplicate controller sequence in figure <a href="#__fig_5.8">5.8</a>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_fig_5.10" id="%_fig_5.10"></a></p><p></p><div align="left"><table width="100%"><tr><td><p></p><p>
+<a id="__fig_5.10"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><p></p><p>
 </p><p></p><p><tt>gcd<br />
  (test (op =) (reg b) (const 0))<br />
  (branch (label gcd-done))<br />
@@ -556,8 +556,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
  (assign continue (label after-gcd-2))<br />
  (goto (label gcd))<br />
 after-gcd-2<br /></tt></p><p></p><p>
-</p><p></p><p></p></td></tr><caption align="bottom"><div align="left"><b>Figure 5.10:</b>  Assigning labels to the <tt>continue</tt> register simplifies
-and generalizes the strategy shown in figure <a href="#%_fig_5.9">5.9</a>.</div></caption><tr><td>
+</p><p></p><p></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.10:</b>  Assigning labels to the <tt>continue</tt> register simplifies
+and generalizes the strategy shown in figure <a href="#__fig_5.9">5.9</a>.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
@@ -575,7 +575,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 from the register and used to continue execution at the designated
 entry point.</p><p>
 
-<a name="%_idx_5556" id="%_idx_5556"></a><a name="%_idx_5558" id="%_idx_5558"></a>To reflect this ability, we will extend the <tt>assign</tt>
+<a id="__idx_5556"></a><a id="__idx_5558"></a>To reflect this ability, we will extend the <tt>assign</tt>
 instruction of the register-machine language to allow a register to be
 assigned as value a label from the controller sequence (as a special
 kind of constant).  We will also extend the <tt>goto</tt> instruction to
@@ -583,7 +583,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 contents of a register rather than only at an entry point described by
 a constant label.  Using these new constructs we can terminate the
 <tt>gcd</tt> subroutine with a branch to the location stored in the <tt>continue</tt> register.  This leads to the controller sequence shown in
-figure <a href="#%_fig_5.10">5.10</a>.</p><p>
+figure <a href="#__fig_5.10">5.10</a>.</p><p>
 
 A machine with more than one subroutine could use multiple
 continuation registers (e.g., <tt>gcd-continue</tt>, <tt>factorial-continue</tt>) or we could have all subroutines share a single
@@ -596,12 +596,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 subroutine calls.
 </p><p>
 
-<a name="%_sec_5.1.4" id="%_sec_5.1.4"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.1.4">5.1.4  Using a Stack to Implement Recursion</a></h3><p>
+<a id="__sec_5.1.4"></a>
+</p><h3>5.1.4  Using a Stack to Implement Recursion</h3><p>
 
 
-<a name="%_idx_5560" id="%_idx_5560"></a><a name="%_idx_5562" id="%_idx_5562"></a><a name="%_idx_5564" id="%_idx_5564"></a>
-<a name="%_idx_5566" id="%_idx_5566"></a>With the ideas illustrated so far, we can implement any iterative
+<a id="__idx_5560"></a><a id="__idx_5562"></a><a id="__idx_5564"></a>
+<a id="__idx_5566"></a>With the ideas illustrated so far, we can implement any iterative
 process by specifying a register machine that has a register
 corresponding to each state variable of the process.  The machine
 repeatedly executes a controller loop, changing the contents
@@ -612,10 +612,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 variables).</p><p>
 
 
-<a name="%_idx_5568" id="%_idx_5568"></a><a name="%_idx_5570" id="%_idx_5570"></a><a name="%_idx_5572" id="%_idx_5572"></a>Implementing recursive processes, however, requires an additional
+<a id="__idx_5568"></a><a id="__idx_5570"></a><a id="__idx_5572"></a>Implementing recursive processes, however, requires an additional
 mechanism.  Consider the following recursive method for computing
 factorials, which we first examined in
-section <a href="book-Z-H-11.html#%_sec_1.2.1">1.2.1</a>:</p><p>
+section <a href="book-Z-H-11.html#__sec_1.2.1">1.2.1</a>:</p><p>
 
 </p><p></p><p><tt>(define (factorial n)<br />
   (if (= n 1)<br />
@@ -673,7 +673,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 restored to continue the suspended computation.  In the case of
 factorial, we will save the old value of <tt>n</tt>, to be restored when
 we are finished computing the factorial of the decremented <tt>n</tt>
-register.<a name="call_footnote_Temp_717" href="#footnote_Temp_717" id="call_footnote_Temp_717"><sup><small>2</small></sup></a></p><p>
+register.<a href="#footnote_Temp_717" id="call_footnote_Temp_717"><sup><small>2</small></sup></a></p><p>
 
 Since there is no <em>a priori</em> limit on the depth of nested
 recursive calls, we may need to save an arbitrary number of register
@@ -683,10 +683,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 the use of a <em>stack</em>, or “last in, first out” data structure, to
 save register values.  We can extend the register-machine language to
 include a stack by adding two kinds of instructions: Values are placed
-<a name="%_idx_5574" id="%_idx_5574"></a><a name="%_idx_5576" id="%_idx_5576"></a><a name="%_idx_5578" id="%_idx_5578"></a><a name="%_idx_5580" id="%_idx_5580"></a>on the stack using a <tt>save</tt> instruction and restored from the
+<a id="__idx_5574"></a><a id="__idx_5576"></a><a id="__idx_5578"></a><a id="__idx_5580"></a>on the stack using a <tt>save</tt> instruction and restored from the
 stack using a <tt>restore</tt> instruction.  After a sequence of values
 has been <tt>save</tt>d on the stack, a sequence of <tt>restore</tt>s will
-retrieve these values in reverse order.<a name="call_footnote_Temp_718" href="#footnote_Temp_718" id="call_footnote_Temp_718"><sup><small>3</small></sup></a></p><p>
+retrieve these values in reverse order.<a href="#footnote_Temp_718" id="call_footnote_Temp_718"><sup><small>3</small></sup></a></p><p>
 
 
 With the aid of the stack, we can reuse a single copy of the factorial
@@ -699,8 +699,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 must suspend its computation of <em>n</em>!, solve the (<em>n</em> - 1)! subproblem,
 then continue its computation of <em>n</em>!.  This view of the factorial
 computation suggests the use of the subroutine mechanism described in
-section <a href="#%_sec_5.1.3">5.1.3</a>, which has the controller use a
-<a name="%_idx_5582" id="%_idx_5582"></a><tt>continue</tt> register to transfer to the part of the sequence that
+section <a href="#__sec_5.1.3">5.1.3</a>, which has the controller use a
+<a id="__idx_5582"></a><tt>continue</tt> register to transfer to the part of the sequence that
 solves a subproblem and then continue where it left off on the main
 problem.  We can thus make a factorial subroutine that returns to the
 entry point stored in the <tt>continue</tt> register.  Around each subroutine
@@ -712,7 +712,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 place that called it to solve a subproblem.</p><p>
 
 
-Figure <a href="#%_fig_5.11">5.11</a> shows the data paths and controller for
+Figure <a href="#__fig_5.11">5.11</a> shows the data paths and controller for
 a machine that implements the recursive <tt>factorial</tt> procedure.
 The machine has a stack and three registers, called <tt>n</tt>, <tt>val</tt>, and <tt>continue</tt>.  To simplify the data-path diagram, we have
 not named the register-assignment buttons, only the stack-operation
@@ -731,7 +731,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 is the value produced by the subcomputation, is needed.
 
 Although in principle the factorial computation requires an infinite
-machine, the machine in figure <a href="#%_fig_5.11">5.11</a> is actually
+machine, the machine in figure <a href="#__fig_5.11">5.11</a> is actually
 finite except for the stack, which is potentially unbounded.  Any
 particular physical implementation of a stack, however, will be of
 finite size, and this will limit the depth of recursive calls that can
@@ -745,14 +745,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 must always be saved.  Whether there are other registers that need to
 be saved depends on the particular machine, since not all recursive
 computations need the original values of registers that are modified
-during solution of the subproblem (see exercise <a href="#%_thm_5.4">5.4</a>).</p><p>
+during solution of the subproblem (see exercise <a href="#__thm_5.4">5.4</a>).</p><p>
 
-<a name="%_sec_Temp_719" id="%_sec_Temp_719"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_719">A double recursion</a></h4><p>
+<a id="__sec_Temp_719"></a>
+</p><h4>A double recursion</h4><p>
 
-<a name="%_idx_5584" id="%_idx_5584"></a>Let us examine a more complex recursive process, the tree-recursive
+<a id="__idx_5584"></a>Let us examine a more complex recursive process, the tree-recursive
 computation of the Fibonacci numbers, which we introduced in
-section <a href="book-Z-H-11.html#%_sec_1.2.2">1.2.2</a>:
+section <a href="book-Z-H-11.html#__sec_1.2.2">1.2.2</a>:
 </p><p></p><p><tt>(define (fib n)<br />
   (if (&lt; n 2)<br />
       n<br />
@@ -769,10 +769,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 to which to return (<tt>afterfib-n-1</tt> or <tt>afterfib-n-2</tt>,
 respectively).  We then go to <tt>fib-loop</tt>.  When we return from the
 recursive call, the answer is in <tt>val</tt>.
-Figure <a href="#%_fig_5.12">5.12</a> shows the controller sequence for this
+Figure <a href="#__fig_5.12">5.12</a> shows the controller sequence for this
 machine.</p><p>
 
-<a name="%_fig_5.11" id="%_fig_5.11"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch5-Z-G-6.gif" border="0" /><p></p><p><tt>(controller<br />
+<a id="__fig_5.11"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch5-Z-G-6.gif" alt="ch5-Z-G-6" style="border: none;" /><p></p><p><tt>(controller<br />
    (assign continue (label fact-done))     <em>; set up final return address</em><br />
  fact-loop<br />
    (test (op =) (reg n) (const 1))<br />
@@ -794,11 +794,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
    (assign val (const 1))                  <em>; base case: </em>1! = 1<br />
    (goto (reg continue))                   <em>; return to caller</em><br />
  fact-done)<br /></tt></p><p></p><p>
-</p><p></p><p></p></td></tr><caption align="bottom"><div align="left"><b>Figure 5.11:</b>  A recursive factorial machine.</div></caption><tr><td>
-<a name="%_idx_5586" id="%_idx_5586"></a>
+</p><p></p><p></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.11:</b>  A recursive factorial machine.</div></caption><tr><td>
+<a id="__idx_5586"></a>
 </td></tr></table></div><p></p><p>
 
-<a name="%_fig_5.12" id="%_fig_5.12"></a></p><p></p><div align="left"><table width="100%"><tr><td><p></p><p><tt>(controller<br />
+<a id="__fig_5.12"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><p></p><p><tt>(controller<br />
    (assign continue (label fib-done))<br />
  fib-loop<br />
    (test (op &lt;) (reg n) (const 2))<br />
@@ -829,19 +829,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
    (assign val (reg n))               <em>; base case:  <em>F</em><em>i</em><em>b</em>(<em>n</em>) = <em>n</em></em><br />
    (goto (reg continue))<br />
  fib-done)<br /></tt></p><p></p><p>
-</p><p></p><p></p></td></tr><caption align="bottom"><div align="left"><b>Figure 5.12:</b>  Controller for a machine to compute Fibonacci
+</p><p></p><p></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.12:</b>  Controller for a machine to compute Fibonacci
 numbers.</div></caption><tr><td>
-<a name="%_idx_5588" id="%_idx_5588"></a>
+<a id="__idx_5588"></a>
 </td></tr></table></div><p></p><p>
 
-</p><p><a name="%_thm_5.4" id="%_thm_5.4"></a>
+</p><p><a id="__thm_5.4"></a>
 <b>Exercise 5.4.</b>  Specify register machines that implement each of the following
 procedures.  For each machine, write a controller instruction sequence
 and draw a diagram showing the data paths.</p><p>
 
 </p><p></p><p>a. Recursive exponentiation:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5590" id="%_idx_5590"></a>(define (expt b n)<br />
+</p><p></p><p><tt><a id="__idx_5590"></a>(define (expt b n)<br />
   (if (= n 0)<br />
       1<br />
       (* b (expt b (- n 1)))))<br /></tt></p><p></p><p>
@@ -855,7 +855,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
   (expt-iter n 1))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.5" id="%_thm_5.5"></a>
+</p><p><a id="__thm_5.5"></a>
 <b>Exercise 5.5.</b>  Hand-simulate the factorial and Fibonacci machines, using some
 nontrivial input (requiring execution of at least one recursive call).
 Show the contents of the stack at each significant point in the
@@ -863,38 +863,38 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.6" id="%_thm_5.6"></a>
+</p><p><a id="__thm_5.6"></a>
 <b>Exercise 5.6.</b>  Ben Bitdiddle observes that the Fibonacci machine's controller sequence
 has an extra <tt>save</tt> and an extra <tt>restore</tt>, which can be
 removed to make a faster machine.  Where are these instructions?
 </p><p>
 
-<a name="%_sec_5.1.5" id="%_sec_5.1.5"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.1.5">5.1.5  Instruction Summary</a></h3><p>
+<a id="__sec_5.1.5"></a>
+</p><h3>5.1.5  Instruction Summary</h3><p>
 
-<a name="%_idx_5592" id="%_idx_5592"></a>
-<a name="%_idx_5594" id="%_idx_5594"></a><a name="%_idx_5596" id="%_idx_5596"></a>A controller instruction in our register-machine language
+<a id="__idx_5592"></a>
+<a id="__idx_5594"></a><a id="__idx_5596"></a>A controller instruction in our register-machine language
 has one of the following forms, where each
 &lt;<em>input<sub><em>i</em></sub></em>&gt; is either <tt>(reg &lt;<em>register-name</em>&gt;)</tt>
 or <tt>(const &lt;<em>constant-value</em>&gt;)</tt>.
 </p><p>
 
 These instructions were introduced in
-section <a href="#%_sec_5.1.1">5.1.1</a>:
-</p><p></p><p><tt><a name="%_idx_5598" id="%_idx_5598"></a>(assign &lt;<em>register-name</em>&gt; (reg &lt;<em>register-name</em>&gt;))<br /><br />
-(assign &lt;<em>register-name</em>&gt; (const &lt;<em>constant-value</em>&gt;))<br /><br /><a name="%_idx_5600" id="%_idx_5600"></a>(assign &lt;<em>register-name</em>&gt; (op &lt;<em>operation-name</em>&gt;) &lt;<em>input<sub>1</sub></em>&gt; <tt>...</tt> &lt;<em>input<sub><em>n</em></sub></em>&gt;)<br /><br /><a name="%_idx_5602" id="%_idx_5602"></a>(perform (op &lt;<em>operation-name</em>&gt;) &lt;<em>input<sub>1</sub></em>&gt; <tt>...</tt> &lt;<em>input<sub><em>n</em></sub></em>&gt;)<br /><br /><a name="%_idx_5604" id="%_idx_5604"></a>(test (op &lt;<em>operation-name</em>&gt;) &lt;<em>input<sub>1</sub></em>&gt; <tt>...</tt> &lt;<em>input<sub><em>n</em></sub></em>&gt;)<br /><br /><a name="%_idx_5606" id="%_idx_5606"></a><a name="%_idx_5608" id="%_idx_5608"></a>(branch (label &lt;<em>label-name</em>&gt;))<br /><br /><a name="%_idx_5610" id="%_idx_5610"></a>(goto (label &lt;<em>label-name</em>&gt;))<br /></tt></p><p></p><p>
+section <a href="#__sec_5.1.1">5.1.1</a>:
+</p><p></p><p><tt><a id="__idx_5598"></a>(assign &lt;<em>register-name</em>&gt; (reg &lt;<em>register-name</em>&gt;))<br /><br />
+(assign &lt;<em>register-name</em>&gt; (const &lt;<em>constant-value</em>&gt;))<br /><br /><a id="__idx_5600"></a>(assign &lt;<em>register-name</em>&gt; (op &lt;<em>operation-name</em>&gt;) &lt;<em>input<sub>1</sub></em>&gt; <tt>...</tt> &lt;<em>input<sub><em>n</em></sub></em>&gt;)<br /><br /><a id="__idx_5602"></a>(perform (op &lt;<em>operation-name</em>&gt;) &lt;<em>input<sub>1</sub></em>&gt; <tt>...</tt> &lt;<em>input<sub><em>n</em></sub></em>&gt;)<br /><br /><a id="__idx_5604"></a>(test (op &lt;<em>operation-name</em>&gt;) &lt;<em>input<sub>1</sub></em>&gt; <tt>...</tt> &lt;<em>input<sub><em>n</em></sub></em>&gt;)<br /><br /><a id="__idx_5606"></a><a id="__idx_5608"></a>(branch (label &lt;<em>label-name</em>&gt;))<br /><br /><a id="__idx_5610"></a>(goto (label &lt;<em>label-name</em>&gt;))<br /></tt></p><p></p><p>
 </p><p>
 
 The use of registers to hold labels was introduced in
-section <a href="#%_sec_5.1.3">5.1.3</a>:
+section <a href="#__sec_5.1.3">5.1.3</a>:
 </p><p></p><p><tt>(assign &lt;<em>register-name</em>&gt; (label &lt;<em>label-name</em>&gt;))<br /><br />
 (goto (reg &lt;<em>register-name</em>&gt;))<br /></tt></p><p></p><p></p><p>
 
 Instructions to use the stack were introduced in
-section <a href="#%_sec_5.1.4">5.1.4</a>:
-</p><p></p><p><tt><a name="%_idx_5612" id="%_idx_5612"></a>(save &lt;<em>register-name</em>&gt;)<br /><br /><a name="%_idx_5614" id="%_idx_5614"></a>(restore &lt;<em>register-name</em>&gt;)<br /></tt></p><p></p><p></p><p>
+section <a href="#__sec_5.1.4">5.1.4</a>:
+</p><p></p><p><tt><a id="__idx_5612"></a>(save &lt;<em>register-name</em>&gt;)<br /><br /><a id="__idx_5614"></a>(restore &lt;<em>register-name</em>&gt;)<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_5616" id="%_idx_5616"></a><a name="%_idx_5618" id="%_idx_5618"></a><a name="%_idx_5620" id="%_idx_5620"></a>The only kind of &lt;<em>constant-value</em>&gt; we have seen so far is a number,
+<a id="__idx_5616"></a><a id="__idx_5618"></a><a id="__idx_5620"></a>The only kind of &lt;<em>constant-value</em>&gt; we have seen so far is a number,
 but later we will use strings, symbols, and lists.
 For example,
 <tt>(const "abc")</tt> is the string <tt>"abc"</tt>,
@@ -904,19 +904,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.1">5.1  Designing Register Machines
 </p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_715" href="#call_footnote_Temp_715" id="footnote_Temp_715"><sup><small>1</small></sup></a> This assumption
+</p><div class="footnote"><p><a href="#call_footnote_Temp_715" id="footnote_Temp_715"><sup><small>1</small></sup></a> This assumption
 glosses over a great deal of complexity.  Usually a large portion of
 the implementation of a Lisp system is dedicated to making reading
 and printing work.
 
-</p><p><a name="footnote_Temp_717" href="#call_footnote_Temp_717" id="footnote_Temp_717"><sup><small>2</small></sup></a> One might argue that we don't need to save the old
+</p><p><a href="#call_footnote_Temp_717" id="footnote_Temp_717"><sup><small>2</small></sup></a> One might argue that we don't need to save the old
 <tt>n</tt>; after we decrement it and solve the subproblem, we could
 simply increment it to recover the old value.  Although this strategy
 works for factorial, it cannot work in general, since the old value of
 a register cannot always be computed from the new one.
 
-</p><p><a name="footnote_Temp_718" href="#call_footnote_Temp_718" id="footnote_Temp_718"><sup><small>3</small></sup></a> In
-section <a href="book-Z-H-33.html#%_sec_5.3">5.3</a> we will see how to implement a
+</p><p><a href="#call_footnote_Temp_718" id="footnote_Temp_718"><sup><small>3</small></sup></a> In
+section <a href="book-Z-H-33.html#__sec_5.3">5.3</a> we will see how to implement a
 stack in terms of more primitive operations.
 
 </p></div>
diff --git a/src/OEBPS/book-Z-H-32.html b/src/OEBPS/book-Z-H-32.html
index c40cd44..8062216 100644
--- a/src/OEBPS/book-Z-H-32.html
+++ b/src/OEBPS/book-Z-H-32.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,15 +13,15 @@
 
 
 
-<a name="%_sec_5.2" id="%_sec_5.2"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulator</a></h2><p>
+<a id="__sec_5.2"></a>
+<h2>5.2  A Register-Machine Simulator</h2><p>
 
 
-<a name="%_idx_5622" id="%_idx_5622"></a><a name="%_idx_5624" id="%_idx_5624"></a>
+<a id="__idx_5622"></a><a id="__idx_5624"></a>
 In order to gain a good understanding of the design of register
 machines, we must test the machines we design to see if they perform
 as expected.  One way to test a design is to hand-simulate the
-operation of the controller, as in exercise <a href="book-Z-H-31.html#%_thm_5.5">5.5</a>.  But this is
+operation of the controller, as in exercise <a href="book-Z-H-31.html#__thm_5.5">5.5</a>.  But this is
 extremely tedious for all but the simplest machines.  In this section
 we construct a simulator for machines described in the
 register-machine language.  The simulator is a Scheme program with
@@ -32,18 +32,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 model:</p><p>
 
 </p><blockquote>
-<p><a name="%_idx_5626" id="%_idx_5626"></a><tt>(make-machine &lt;<em>register-names</em>&gt; &lt;<em>operations</em>&gt; &lt;<em>controller</em>&gt;)</tt><br />
+<p><a id="__idx_5626"></a><tt>(make-machine &lt;<em>register-names</em>&gt; &lt;<em>operations</em>&gt; &lt;<em>controller</em>&gt;)</tt><br />
 constructs and returns a model of the machine with the given
 registers, operations, and controller.</p><p>
 
-</p><p><a name="%_idx_5628" id="%_idx_5628"></a><tt>(set-register-contents! &lt;<em>machine-model</em>&gt; &lt;<em>register-name</em>&gt; &lt;<em>value</em>&gt;)</tt><br />
+</p><p><a id="__idx_5628"></a><tt>(set-register-contents! &lt;<em>machine-model</em>&gt; &lt;<em>register-name</em>&gt; &lt;<em>value</em>&gt;)</tt><br />
 stores a value in a simulated register in the given
 machine.</p><p>
 
-<a name="%_idx_5630" id="%_idx_5630"></a></p><p><tt>(get-register-contents &lt;<em>machine-model</em>&gt; &lt;<em>register-name</em>&gt;)</tt><br />
+<a id="__idx_5630"></a></p><p><tt>(get-register-contents &lt;<em>machine-model</em>&gt; &lt;<em>register-name</em>&gt;)</tt><br />
 returns the contents of a simulated register in the given machine.</p><p>
 
-<a name="%_idx_5632" id="%_idx_5632"></a></p><p><tt>(start &lt;<em>machine-model</em>&gt;)</tt><br />
+<a id="__idx_5632"></a></p><p><tt>(start &lt;<em>machine-model</em>&gt;)</tt><br />
 simulates the execution of the given
 machine, starting from the beginning of the controller sequence and
 stopping when it reaches the end of the sequence.
@@ -51,9 +51,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 
 As an example of how these procedures are used, we can define
 <tt>gcd-machine</tt> to be a model of the GCD machine
-of section <a href="book-Z-H-31.html#%_sec_5.1.1">5.1.1</a> as follows:</p><p>
+of section <a href="book-Z-H-31.html#__sec_5.1.1">5.1.1</a> as follows:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5634" id="%_idx_5634"></a>(define gcd-machine<br />
+</p><p></p><p><tt><a id="__idx_5634"></a>(define gcd-machine<br />
   (make-machine<br />
    '(a b t)<br />
    (list (list 'rem remainder) (list '= =))<br />
@@ -70,7 +70,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 each operation name with a Scheme procedure that implements the operation
 (that is, produces the same output value given the same input values).
 The last argument specifies the controller as a list of labels and
-machine instructions, as in section <a href="book-Z-H-31.html#%_sec_5.1">5.1</a>.</p><p>
+machine instructions, as in section <a href="book-Z-H-31.html#__sec_5.1">5.1</a>.</p><p>
 
 
 To compute GCDs with this machine, we set the
@@ -84,13 +84,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 written in Scheme, because we will simulate low-level machine
 instructions, such as <tt>assign</tt>, by much more complex operations.</p><p>
 
-</p><p><a name="%_thm_5.7" id="%_thm_5.7"></a>
+</p><p><a id="__thm_5.7"></a>
 <b>Exercise 5.7.</b>  Use the simulator to test the machines you designed in
-exercise <a href="book-Z-H-31.html#%_thm_5.4">5.4</a>.
+exercise <a href="book-Z-H-31.html#__thm_5.4">5.4</a>.
 </p><p></p><p>
 
-<a name="%_sec_5.2.1" id="%_sec_5.2.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.2.1">5.2.1  The Machine Model</a></h3><p>
+<a id="__sec_5.2.1"></a>
+</p><h3>5.2.1  The Machine Model</h3><p>
 
 </p><p>
 
@@ -107,11 +107,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 messages) to include the registers, operations, and controller of the
 particular machine being defined.  First it allocates a register in
 the new machine for each of the supplied register names and installs
-the designated operations in the machine.  Then it uses an <a name="%_idx_5636" id="%_idx_5636"></a><em>assembler</em> (described below in section <a href="#%_sec_5.2.2">5.2.2</a>) to
+the designated operations in the machine.  Then it uses an <a id="__idx_5636"></a><em>assembler</em> (described below in section <a href="#__sec_5.2.2">5.2.2</a>) to
 transform the controller list into instructions for the new machine
 and installs these as the machine's instruction sequence.  <tt>Make-machine</tt> returns as its value the modified machine model.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5638" id="%_idx_5638"></a>(define (make-machine register-names ops controller-text)<br />
+</p><p></p><p><tt><a id="__idx_5638"></a>(define (make-machine register-names ops controller-text)<br />
   (let ((machine (make-new-machine)))<br />
     (for-each (lambda (register-name)<br />
                 ((machine 'allocate-register) register-name))<br />
@@ -121,15 +121,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
      (assemble controller-text machine))<br />
     machine))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_724" id="%_sec_Temp_724"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_724">Registers</a></h4><p>
+<a id="__sec_Temp_724"></a>
+</p><h4>Registers</h4><p>
 
-<a name="%_idx_5640" id="%_idx_5640"></a>
+<a id="__idx_5640"></a>
 We will represent a register as a procedure with local state, as in
 chapter 3.  The procedure <tt>make-register</tt> creates a register that
 holds a value that can be accessed or changed:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5642" id="%_idx_5642"></a>(define (make-register name)<br />
+</p><p></p><p><tt><a id="__idx_5642"></a>(define (make-register name)<br />
   (let ((contents '*unassigned*))<br />
     (define (dispatch message)<br />
       (cond ((eq? message 'get) contents)<br />
@@ -140,20 +140,20 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
     dispatch))<br /></tt></p><p></p><p>
 The following procedures are used to access registers:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5644" id="%_idx_5644"></a>(define (get-contents register)<br />
-  (register 'get))<br /><br /><a name="%_idx_5646" id="%_idx_5646"></a>(define (set-contents! register value)<br />
+</p><p></p><p><tt><a id="__idx_5644"></a>(define (get-contents register)<br />
+  (register 'get))<br /><br /><a id="__idx_5646"></a>(define (set-contents! register value)<br />
   ((register 'set) value))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_725" id="%_sec_Temp_725"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_725">The stack</a></h4><p>
+<a id="__sec_Temp_725"></a>
+</p><h4>The stack</h4><p>
 
-<a name="%_idx_5648" id="%_idx_5648"></a>
+<a id="__idx_5648"></a>
 We can also represent a stack as a procedure with local state.  The
 procedure <tt>make-stack</tt> creates a stack whose local state consists
 of a list of the items on the stack.  A stack accepts requests to <tt>push</tt> an item onto the stack, to <tt>pop</tt> the top item off the stack
 and return it, and to <tt>initialize</tt> the stack to empty.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5650" id="%_idx_5650"></a>(define (make-stack)<br />
+</p><p></p><p><tt><a id="__idx_5650"></a>(define (make-stack)<br />
   (let ((s '()))<br />
     (define (push x)<br />
       (set! s (cons x s)))<br />
@@ -175,19 +175,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
     dispatch))<br /></tt></p><p></p><p>
 The following procedures are used to access stacks:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5652" id="%_idx_5652"></a>(define (pop stack)<br />
-  (stack 'pop))<br /><br /><a name="%_idx_5654" id="%_idx_5654"></a>(define (push stack value)<br />
+</p><p></p><p><tt><a id="__idx_5652"></a>(define (pop stack)<br />
+  (stack 'pop))<br /><br /><a id="__idx_5654"></a>(define (push stack value)<br />
   ((stack 'push) value))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_726" id="%_sec_Temp_726"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_726">The basic machine</a></h4><p>
+<a id="__sec_Temp_726"></a>
+</p><h4>The basic machine</h4><p>
 
 The <tt>make-new-machine</tt> procedure, shown in
-figure <a href="#%_fig_5.13">5.13</a>, constructs an object whose local
+figure <a href="#__fig_5.13">5.13</a>, constructs an object whose local
 state consists of a stack, an initially empty instruction sequence, a
-list of operations that initially contains an operation to <a name="%_idx_5656" id="%_idx_5656"></a>initialize
-the stack, and a <a name="%_idx_5658" id="%_idx_5658"></a><em>register table</em> that initially contains two
-<a name="%_idx_5660" id="%_idx_5660"></a><a name="%_idx_5662" id="%_idx_5662"></a>registers, named <tt>flag</tt> and <tt>pc</tt> <a name="%_idx_5664" id="%_idx_5664"></a>(for “program counter”).
+list of operations that initially contains an operation to <a id="__idx_5656"></a>initialize
+the stack, and a <a id="__idx_5658"></a><em>register table</em> that initially contains two
+<a id="__idx_5660"></a><a id="__idx_5662"></a>registers, named <tt>flag</tt> and <tt>pc</tt> <a id="__idx_5664"></a>(for “program counter”).
 The internal procedure <tt>allocate-register</tt> adds new entries to the
 register table, and the internal procedure <tt>lookup-register</tt> looks
 up registers in the table.</p><p>
@@ -202,16 +202,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 the machine runs.  This sequencing is implemented by the internal
 procedure <tt>execute</tt>.
 In the simulation model, each machine instruction is a data structure
-that includes a procedure of no arguments, called the <a name="%_idx_5666" id="%_idx_5666"></a><a name="%_idx_5668" id="%_idx_5668"></a><em>instruction
+that includes a procedure of no arguments, called the <a id="__idx_5666"></a><a id="__idx_5668"></a><em>instruction
 execution procedure</em>, such that calling this procedure simulates
 executing the instruction.  As the simulation runs, <tt>pc</tt> points to
 the place in the instruction sequence beginning with the next
-instruction to be executed.  <a name="%_idx_5670" id="%_idx_5670"></a><tt>Execute</tt> gets that instruction,
+instruction to be executed.  <a id="__idx_5670"></a><tt>Execute</tt> gets that instruction,
 executes it by calling the instruction execution procedure, and
 repeats this cycle until there are no more instructions to execute
 (i.e., until <tt>pc</tt> points to the end of the instruction sequence).</p><p>
 
-<a name="%_fig_5.13" id="%_fig_5.13"></a></p><p></p><div align="left"><table width="100%"><tr><td><p></p><p><tt><a name="%_idx_5672" id="%_idx_5672"></a>(define (make-new-machine)<br />
+<a id="__fig_5.13"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><p></p><p><tt><a id="__idx_5672"></a>(define (make-new-machine)<br />
   (let ((pc (make-register 'pc))<br />
         (flag (make-register 'flag))<br />
         (stack (make-stack))<br />
@@ -254,7 +254,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
               ((eq? message 'operations) the-ops)<br />
               (else (error "Unknown request -- MACHINE" message))))<br />
       dispatch)))<br /></tt></p><p></p><p>
-</p><p></p><p></p></td></tr><caption align="bottom"><div align="left"><b>Figure 5.13:</b>  The <tt>make-new-machine</tt> procedure, which implements
+</p><p></p><p></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.13:</b>  The <tt>make-new-machine</tt> procedure, which implements
 the basic machine model.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
@@ -277,26 +277,26 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 For convenience, we provide an alternate procedural interface to a
 machine's <tt>start</tt> operation,
 as well as procedures to set and examine register contents,
-as specified at the beginning of section <a href="#%_sec_5.2">5.2</a>:</p><p>
+as specified at the beginning of section <a href="#__sec_5.2">5.2</a>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5674" id="%_idx_5674"></a>(define (start machine)<br />
-  (machine 'start))<br /><a name="%_idx_5676" id="%_idx_5676"></a>(define (get-register-contents machine register-name)<br />
-  (get-contents (get-register machine register-name)))<br /><a name="%_idx_5678" id="%_idx_5678"></a>(define (set-register-contents! machine register-name value)<br />
+</p><p></p><p><tt><a id="__idx_5674"></a>(define (start machine)<br />
+  (machine 'start))<br /><a id="__idx_5676"></a>(define (get-register-contents machine register-name)<br />
+  (get-contents (get-register machine register-name)))<br /><a id="__idx_5678"></a>(define (set-register-contents! machine register-name value)<br />
   (set-contents! (get-register machine register-name) value)<br />
   'done)<br /></tt></p><p></p><p>
-These procedures (and many procedures in sections <a href="#%_sec_5.2.2">5.2.2</a>
-and <a href="#%_sec_5.2.3">5.2.3</a>) use the following to look up the register with a
+These procedures (and many procedures in sections <a href="#__sec_5.2.2">5.2.2</a>
+and <a href="#__sec_5.2.3">5.2.3</a>) use the following to look up the register with a
 given name in a given machine:
-</p><p></p><p><tt><a name="%_idx_5680" id="%_idx_5680"></a>(define (get-register machine reg-name)<br />
+</p><p></p><p><tt><a id="__idx_5680"></a>(define (get-register machine reg-name)<br />
   ((machine 'get-register) reg-name))<br /></tt></p><p></p><p></p><p>
 
 </p><p>
 
-<a name="%_sec_5.2.2" id="%_sec_5.2.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.2.2">5.2.2  The Assembler</a></h3><p>
+<a id="__sec_5.2.2"></a>
+</p><h3>5.2.2  The Assembler</h3><p>
 
 
-<a name="%_idx_5682" id="%_idx_5682"></a>
+<a id="__idx_5682"></a>
 The assembler transforms the sequence of controller expressions for a
 machine into a corresponding list of machine instructions, each with
 its execution procedure.  Overall, the assembler is much like the
@@ -304,8 +304,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 this case, the register-machine language) and we must perform an
 appropriate action for each type of expression in the language.</p><p>
 
-<a name="%_idx_5684" id="%_idx_5684"></a>The technique of producing an execution procedure for each instruction
-is just what we used in section <a href="book-Z-H-26.html#%_sec_4.1.7">4.1.7</a> to speed
+<a id="__idx_5684"></a>The technique of producing an execution procedure for each instruction
+is just what we used in section <a href="book-Z-H-26.html#__sec_4.1.7">4.1.7</a> to speed
 up the evaluator by separating analysis from runtime execution.  As we
 saw in chapter 4, much useful analysis of Scheme expressions could be
 performed without knowing the actual values of variables.  Here,
@@ -333,7 +333,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 This procedure uses <tt>update-insts!</tt> to generate the instruction execution
 procedures and insert them into the instruction list,
 and returns the modified list.
-</p><p></p><p><tt><a name="%_idx_5686" id="%_idx_5686"></a>(define (assemble controller-text machine)<br />
+</p><p></p><p><tt><a id="__idx_5686"></a>(define (assemble controller-text machine)<br />
   (extract-labels controller-text<br />
     (lambda (insts labels)<br />
       (update-insts! insts labels machine)<br />
@@ -347,7 +347,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 (2) a table called <tt>labels</tt>, which associates each label from <tt>text</tt>
 with the position in the list <tt>insts</tt> that the label designates.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5688" id="%_idx_5688"></a>(define (extract-labels text receive)<br />
+</p><p></p><p><tt><a id="__idx_5688"></a>(define (extract-labels text receive)<br />
   (if (null? text)<br />
       (receive '() '())<br />
       (extract-labels (cdr text)<br />
@@ -365,14 +365,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 the <tt>text</tt> and accumulating the <tt>insts</tt> and the <tt>labels</tt>.
 If an element is a symbol (and thus a label) an appropriate entry is
 added to the <tt>labels</tt> table.  Otherwise the element is accumulated
-onto the <tt>insts</tt> list.<a name="call_footnote_Temp_727" href="#footnote_Temp_727" id="call_footnote_Temp_727"><sup><small>4</small></sup></a></p><p>
+onto the <tt>insts</tt> list.<a href="#footnote_Temp_727" id="call_footnote_Temp_727"><sup><small>4</small></sup></a></p><p>
 
 <tt>Update-insts!</tt> modifies the instruction list, which initially
 contains only the text of the instructions, to include the
 corresponding execution procedures:</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_5702" id="%_idx_5702"></a>(define (update-insts! insts labels machine)<br />
+</p><p></p><p><tt><a id="__idx_5702"></a>(define (update-insts! insts labels machine)<br />
   (let ((pc (get-register machine 'pc))<br />
         (flag (get-register machine 'flag))<br />
         (stack (machine 'stack))<br />
@@ -392,27 +392,27 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 The execution procedure is not yet available when <tt>extract-labels</tt>
 constructs the instruction, and is inserted later by <tt>update-insts!</tt>.
 
-</p><p></p><p><tt><a name="%_idx_5704" id="%_idx_5704"></a>(define (make-instruction text)<br />
-  (cons text '()))<br /><a name="%_idx_5706" id="%_idx_5706"></a>(define (instruction-text inst)<br />
-  (car inst))<br /><a name="%_idx_5708" id="%_idx_5708"></a>(define (instruction-execution-proc inst)<br />
-  (cdr inst))<br /><a name="%_idx_5710" id="%_idx_5710"></a>(define (set-instruction-execution-proc! inst proc)<br />
+</p><p></p><p><tt><a id="__idx_5704"></a>(define (make-instruction text)<br />
+  (cons text '()))<br /><a id="__idx_5706"></a>(define (instruction-text inst)<br />
+  (car inst))<br /><a id="__idx_5708"></a>(define (instruction-execution-proc inst)<br />
+  (cdr inst))<br /><a id="__idx_5710"></a>(define (set-instruction-execution-proc! inst proc)<br />
   (set-cdr! inst proc))<br /></tt></p><p></p><p>
 The instruction text is not used by our simulator, but it is handy to keep
-around for debugging (see exercise <a href="#%_thm_5.16">5.16</a>).</p><p>
+around for debugging (see exercise <a href="#__thm_5.16">5.16</a>).</p><p>
 
 Elements of the label table are pairs:
 
-</p><p></p><p><tt><a name="%_idx_5712" id="%_idx_5712"></a>(define (make-label-entry label-name insts)<br />
+</p><p></p><p><tt><a id="__idx_5712"></a>(define (make-label-entry label-name insts)<br />
   (cons label-name insts))<br /></tt></p><p></p><p>
 Entries will be looked up in the table with
 
-</p><p></p><p><tt><a name="%_idx_5714" id="%_idx_5714"></a>(define (lookup-label labels label-name)<br />
+</p><p></p><p><tt><a id="__idx_5714"></a>(define (lookup-label labels label-name)<br />
   (let ((val (assoc label-name labels)))<br />
     (if val<br />
         (cdr val)<br />
         (error "Undefined label -- ASSEMBLE" label-name))))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_5.8" id="%_thm_5.8"></a>
+</p><p><a id="__thm_5.8"></a>
 <b>Exercise 5.8.</b>  The following register-machine code is ambiguous, because the label
 <tt>here</tt> is defined more than once:
 </p><p></p><p><tt>start<br />
@@ -431,17 +431,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 </p><p>
 </p><p>
 
-<a name="%_sec_5.2.3" id="%_sec_5.2.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.2.3">5.2.3  Generating Execution Procedures for Instructions</a></h3><p>
+<a id="__sec_5.2.3"></a>
+</p><h3>5.2.3  Generating Execution Procedures for Instructions</h3><p>
 
 
-<a name="%_idx_5716" id="%_idx_5716"></a>
+<a id="__idx_5716"></a>
 The assembler calls <tt>make-execution-procedure</tt> to
 generate the execution procedure for an instruction.
 Like the <tt>analyze</tt> procedure in the evaluator of
-section <a href="book-Z-H-26.html#%_sec_4.1.7">4.1.7</a>, this dispatches on the type of
+section <a href="book-Z-H-26.html#__sec_4.1.7">4.1.7</a>, this dispatches on the type of
 instruction to generate the appropriate execution procedure.
-</p><p></p><p><tt><a name="%_idx_5718" id="%_idx_5718"></a>(define (make-execution-procedure inst labels machine<br />
+</p><p></p><p><tt><a id="__idx_5718"></a>(define (make-execution-procedure inst labels machine<br />
                                   pc flag stack ops)<br />
   (cond ((eq? (car inst) 'assign)<br />
          (make-assign inst machine labels ops pc))<br />
@@ -466,16 +466,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 the individual instructions in the register-machine language.
 We use data abstraction to isolate the detailed syntax of
 register-machine expressions from the general execution mechanism, as
-we did for evaluators in section <a href="book-Z-H-26.html#%_sec_4.1.2">4.1.2</a>,
+we did for evaluators in section <a href="book-Z-H-26.html#__sec_4.1.2">4.1.2</a>,
 by using syntax procedures to extract and classify the parts of an instruction.</p><p>
 
 
-<a name="%_sec_Temp_729" id="%_sec_Temp_729"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_729"><tt>Assign</tt> instructions</a></h4><p>
+<a id="__sec_Temp_729"></a>
+</p><h4><tt>Assign</tt> instructions</h4><p>
 
-<a name="%_idx_5720" id="%_idx_5720"></a>
+<a id="__idx_5720"></a>
 The <tt>make-assign</tt> procedure handles <tt>assign</tt> instructions:
-</p><p></p><p><tt><a name="%_idx_5722" id="%_idx_5722"></a>(define (make-assign inst machine labels operations pc)<br />
+</p><p></p><p><tt><a id="__idx_5722"></a>(define (make-assign inst machine labels operations pc)<br />
   (let ((target<br />
          (get-register machine (assign-reg-name inst)))<br />
         (value-exp (assign-value-exp inst)))<br />
@@ -492,22 +492,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 second element of the instruction) and the value expression
 (the rest of the list that forms the instruction)
 from the <tt>assign</tt> instruction using the selectors
-</p><p></p><p><tt><a name="%_idx_5724" id="%_idx_5724"></a>(define (assign-reg-name assign-instruction)<br />
-  (cadr assign-instruction))<br /><a name="%_idx_5726" id="%_idx_5726"></a>(define (assign-value-exp assign-instruction)<br />
+</p><p></p><p><tt><a id="__idx_5724"></a>(define (assign-reg-name assign-instruction)<br />
+  (cadr assign-instruction))<br /><a id="__idx_5726"></a>(define (assign-value-exp assign-instruction)<br />
   (cddr assign-instruction))<br /></tt></p><p></p><p>
 The register name is looked up with <tt>get-register</tt> to produce the
 target register object.  The value expression is passed to <tt>make-operation-exp</tt> if the value is the result of an operation, and to
 <tt>make-primitive-exp</tt> otherwise.  These procedures (shown below)
 parse the value expression and produce an execution procedure for the
-value.  This is a procedure of no arguments, called <a name="%_idx_5728" id="%_idx_5728"></a><tt>value-proc</tt>,
+value.  This is a procedure of no arguments, called <a id="__idx_5728"></a><tt>value-proc</tt>,
 which will be evaluated during the simulation to produce the actual
 value to be assigned to the register.  Notice that the work of looking
 up the register name and parsing the value expression is performed
 just once, at assembly time, not every time the instruction is
 simulated.  This saving of work is the reason we use execution
-<a name="%_idx_5730" id="%_idx_5730"></a>procedures, and corresponds directly to the saving in work we obtained
+<a id="__idx_5730"></a>procedures, and corresponds directly to the saving in work we obtained
 by separating program analysis from execution in the evaluator of
-section <a href="book-Z-H-26.html#%_sec_4.1.7">4.1.7</a>.</p><p>
+section <a href="book-Z-H-26.html#__sec_4.1.7">4.1.7</a>.</p><p>
 
 The result returned by <tt>make-assign</tt> is the execution
 procedure for the <tt>assign</tt> instruction.  When this procedure is
@@ -515,20 +515,20 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 it sets the contents of the target register to the result
 obtained by executing <tt>value-proc</tt>.  Then it advances
 the <tt>pc</tt> to the next instruction by running the procedure
-</p><p></p><p><tt><a name="%_idx_5732" id="%_idx_5732"></a>(define (advance-pc pc)<br />
+</p><p></p><p><tt><a id="__idx_5732"></a>(define (advance-pc pc)<br />
   (set-contents! pc (cdr (get-contents pc))))<br /></tt></p><p></p><p>
 <tt>Advance-pc</tt> is the normal termination for all instructions except
 <tt>branch</tt> and <tt>goto</tt>.</p><p>
 
-<a name="%_sec_Temp_730" id="%_sec_Temp_730"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_730"><tt>Test</tt>, <tt>branch</tt>, and <tt>goto</tt> instructions</a></h4><p>
+<a id="__sec_Temp_730"></a>
+</p><h4><tt>Test</tt>, <tt>branch</tt>, and <tt>goto</tt> instructions</h4><p>
 
-<a name="%_idx_5734" id="%_idx_5734"></a><tt>Make-test</tt> handles <tt>test</tt> instructions in a similar way.  It
+<a id="__idx_5734"></a><tt>Make-test</tt> handles <tt>test</tt> instructions in a similar way.  It
 extracts the expression that specifies the condition to be tested and
 generates an execution procedure for it.  At simulation time, the
 procedure for the condition is called, the result is assigned to the
 <tt>flag</tt> register, and the <tt>pc</tt> is advanced:
-</p><p></p><p><tt><a name="%_idx_5736" id="%_idx_5736"></a>(define (make-test inst machine labels operations flag pc)<br />
+</p><p></p><p><tt><a id="__idx_5736"></a>(define (make-test inst machine labels operations flag pc)<br />
   (let ((condition (test-condition inst)))<br />
     (if (operation-exp? condition)<br />
         (let ((condition-proc<br />
@@ -537,10 +537,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
           (lambda ()<br />
             (set-contents! flag (condition-proc))<br />
             (advance-pc pc)))<br />
-        (error "Bad TEST instruction -- ASSEMBLE" inst))))<br /><a name="%_idx_5738" id="%_idx_5738"></a>(define (test-condition test-instruction)<br />
+        (error "Bad TEST instruction -- ASSEMBLE" inst))))<br /><a id="__idx_5738"></a>(define (test-condition test-instruction)<br />
   (cdr test-instruction))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_5740" id="%_idx_5740"></a>The execution procedure for a <tt>branch</tt> instruction checks the
+<a id="__idx_5740"></a>The execution procedure for a <tt>branch</tt> instruction checks the
 contents of the <tt>flag</tt> register and either sets the contents of
 the <tt>pc</tt> to the branch destination (if the branch is taken) or
 else just advances the <tt>pc</tt> (if the branch is not taken).  Notice
@@ -549,7 +549,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 also that the label is looked up at assembly time, not each time the
 <tt>branch</tt> instruction is simulated.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_5742" id="%_idx_5742"></a>(define (make-branch inst machine labels flag pc)<br />
+</p><p></p><p><tt><a id="__idx_5742"></a>(define (make-branch inst machine labels flag pc)<br />
   (let ((dest (branch-dest inst)))<br />
     (if (label-exp? dest)<br />
         (let ((insts<br />
@@ -558,14 +558,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
             (if (get-contents flag)<br />
                 (set-contents! pc insts)<br />
                 (advance-pc pc))))<br />
-        (error "Bad BRANCH instruction -- ASSEMBLE" inst))))<br /><a name="%_idx_5744" id="%_idx_5744"></a>(define (branch-dest branch-instruction)<br />
+        (error "Bad BRANCH instruction -- ASSEMBLE" inst))))<br /><a id="__idx_5744"></a>(define (branch-dest branch-instruction)<br />
   (cadr branch-instruction))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_5746" id="%_idx_5746"></a>A <tt>goto</tt> instruction is similar to a branch, except that the
+<a id="__idx_5746"></a>A <tt>goto</tt> instruction is similar to a branch, except that the
 destination may be specified either as a label or as a register, and
 there is no condition to check – the <tt>pc</tt> is always set to the
 new destination.
-</p><p></p><p><tt><a name="%_idx_5748" id="%_idx_5748"></a>(define (make-goto inst machine labels pc)<br />
+</p><p></p><p><tt><a id="__idx_5748"></a>(define (make-goto inst machine labels pc)<br />
   (let ((dest (goto-dest inst)))<br />
     (cond ((label-exp? dest)<br />
            (let ((insts<br />
@@ -579,33 +579,33 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
              (lambda ()<br />
                (set-contents! pc (get-contents reg)))))<br />
           (else (error "Bad GOTO instruction -- ASSEMBLE"<br />
-                       inst)))))<br /><a name="%_idx_5750" id="%_idx_5750"></a>(define (goto-dest goto-instruction)<br />
+                       inst)))))<br /><a id="__idx_5750"></a>(define (goto-dest goto-instruction)<br />
   (cadr goto-instruction))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_731" id="%_sec_Temp_731"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_731">Other instructions</a></h4><p>
+<a id="__sec_Temp_731"></a>
+</p><h4>Other instructions</h4><p>
 
 The stack instructions <tt>save</tt> and <tt>restore</tt> simply use the
 stack with the designated register and advance the <tt>pc</tt>:
 
-</p><p></p><p><tt><a name="%_idx_5752" id="%_idx_5752"></a><a name="%_idx_5754" id="%_idx_5754"></a>(define (make-save inst machine stack pc)<br />
+</p><p></p><p><tt><a id="__idx_5752"></a><a id="__idx_5754"></a>(define (make-save inst machine stack pc)<br />
   (let ((reg (get-register machine<br />
                            (stack-inst-reg-name inst))))<br />
     (lambda ()<br />
       (push stack (get-contents reg))<br />
-      (advance-pc pc))))<br /><a name="%_idx_5756" id="%_idx_5756"></a><a name="%_idx_5758" id="%_idx_5758"></a>(define (make-restore inst machine stack pc)<br />
+      (advance-pc pc))))<br /><a id="__idx_5756"></a><a id="__idx_5758"></a>(define (make-restore inst machine stack pc)<br />
   (let ((reg (get-register machine<br />
                            (stack-inst-reg-name inst))))<br />
     (lambda ()<br />
       (set-contents! reg (pop stack))    <br />
-      (advance-pc pc))))<br /><a name="%_idx_5760" id="%_idx_5760"></a>(define (stack-inst-reg-name stack-instruction)<br />
+      (advance-pc pc))))<br /><a id="__idx_5760"></a>(define (stack-inst-reg-name stack-instruction)<br />
   (cadr stack-instruction))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_5762" id="%_idx_5762"></a>The final instruction type, handled by <tt>make-perform</tt>, generates
+<a id="__idx_5762"></a>The final instruction type, handled by <tt>make-perform</tt>, generates
 an execution procedure for the action to be performed.  At simulation
 time, the action procedure is executed and the <tt>pc</tt> advanced.
 
-</p><p></p><p><tt><a name="%_idx_5764" id="%_idx_5764"></a>(define (make-perform inst machine labels operations pc)<br />
+</p><p></p><p><tt><a id="__idx_5764"></a>(define (make-perform inst machine labels operations pc)<br />
   (let ((action (perform-action inst)))<br />
     (if (operation-exp? action)<br />
         (let ((action-proc<br />
@@ -614,19 +614,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
           (lambda ()<br />
             (action-proc)<br />
             (advance-pc pc)))<br />
-        (error "Bad PERFORM instruction -- ASSEMBLE" inst))))<br /><a name="%_idx_5766" id="%_idx_5766"></a>(define (perform-action inst) (cdr inst))<br /></tt></p><p></p><p></p><p>
+        (error "Bad PERFORM instruction -- ASSEMBLE" inst))))<br /><a id="__idx_5766"></a>(define (perform-action inst) (cdr inst))<br /></tt></p><p></p><p></p><p>
 
 
-<a name="%_sec_Temp_732" id="%_sec_Temp_732"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_732">Execution procedures for subexpressions</a></h4><p>
+<a id="__sec_Temp_732"></a>
+</p><h4>Execution procedures for subexpressions</h4><p>
 
-<a name="%_idx_5768" id="%_idx_5768"></a><a name="%_idx_5770" id="%_idx_5770"></a><a name="%_idx_5772" id="%_idx_5772"></a>The value of a <tt>reg</tt>, <tt>label</tt>, or <tt>const</tt> expression
+<a id="__idx_5768"></a><a id="__idx_5770"></a><a id="__idx_5772"></a>The value of a <tt>reg</tt>, <tt>label</tt>, or <tt>const</tt> expression
 may be needed for assignment to a register (<tt>make-assign</tt>) or for input to
 an operation (<tt>make-operation-exp</tt>, below).  The following procedure
 generates execution procedures to produce values for these expressions
 during the simulation:
 
-</p><p></p><p><tt><a name="%_idx_5774" id="%_idx_5774"></a>(define (make-primitive-exp exp machine labels)<br />
+</p><p></p><p><tt><a id="__idx_5774"></a>(define (make-primitive-exp exp machine labels)<br />
   (cond ((constant-exp? exp)<br />
          (let ((c (constant-exp-value exp)))<br />
            (lambda () c)))<br />
@@ -643,18 +643,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
          (error "Unknown expression type -- ASSEMBLE" exp))))<br /></tt></p><p></p><p>
 The syntax of <tt>reg</tt>, <tt>label</tt>, and <tt>const</tt> expressions
 is determined by
-</p><p></p><p><tt><a name="%_idx_5776" id="%_idx_5776"></a>(define (register-exp? exp) (tagged-list? exp 'reg))<br /><a name="%_idx_5778" id="%_idx_5778"></a>(define (register-exp-reg exp) (cadr exp))<br /><a name="%_idx_5780" id="%_idx_5780"></a>(define (constant-exp? exp) (tagged-list? exp 'const))<br /><a name="%_idx_5782" id="%_idx_5782"></a>(define (constant-exp-value exp) (cadr exp))<br /><a name="%_idx_5784" id="%_idx_5784"></a>(define (label-exp? exp) (tagged-list? exp 'label))<br /><a name="%_idx_5786" id="%_idx_5786"></a>(define (label-exp-label exp) (cadr exp))<br /></tt></p><p></p><p>
+</p><p></p><p><tt><a id="__idx_5776"></a>(define (register-exp? exp) (tagged-list? exp 'reg))<br /><a id="__idx_5778"></a>(define (register-exp-reg exp) (cadr exp))<br /><a id="__idx_5780"></a>(define (constant-exp? exp) (tagged-list? exp 'const))<br /><a id="__idx_5782"></a>(define (constant-exp-value exp) (cadr exp))<br /><a id="__idx_5784"></a>(define (label-exp? exp) (tagged-list? exp 'label))<br /><a id="__idx_5786"></a>(define (label-exp-label exp) (cadr exp))<br /></tt></p><p></p><p>
 </p><p>
 
 
-<a name="%_idx_5788" id="%_idx_5788"></a><tt>Assign</tt>, <tt>perform</tt>, and <tt>test</tt> instructions
+<a id="__idx_5788"></a><tt>Assign</tt>, <tt>perform</tt>, and <tt>test</tt> instructions
 may include the application of a machine operation (specified by
 an <tt>op</tt> expression) to some operands (specified by <tt>reg</tt>
 and <tt>const</tt> expressions).
 The following procedure produces an execution procedure
 for an “operation expression” – a list containing the operation and
 operand expressions from the instruction:
-</p><p></p><p><tt><a name="%_idx_5790" id="%_idx_5790"></a>(define (make-operation-exp exp machine labels operations)<br />
+</p><p></p><p><tt><a id="__idx_5790"></a>(define (make-operation-exp exp machine labels operations)<br />
   (let ((op (lookup-prim (operation-exp-op exp) operations))<br />
         (aprocs<br />
          (map (lambda (e)<br />
@@ -663,41 +663,41 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
     (lambda ()<br />
       (apply op (map (lambda (p) (p)) aprocs)))))<br /></tt></p><p></p><p>
 The syntax of operation expressions is determined by
-</p><p></p><p><tt><a name="%_idx_5792" id="%_idx_5792"></a>(define (operation-exp? exp)<br />
-  (and (pair? exp) (tagged-list? (car exp) 'op)))<br /><a name="%_idx_5794" id="%_idx_5794"></a>(define (operation-exp-op operation-exp)<br />
-  (cadr (car operation-exp)))<br /><a name="%_idx_5796" id="%_idx_5796"></a>(define (operation-exp-operands operation-exp)<br />
+</p><p></p><p><tt><a id="__idx_5792"></a>(define (operation-exp? exp)<br />
+  (and (pair? exp) (tagged-list? (car exp) 'op)))<br /><a id="__idx_5794"></a>(define (operation-exp-op operation-exp)<br />
+  (cadr (car operation-exp)))<br /><a id="__idx_5796"></a>(define (operation-exp-operands operation-exp)<br />
   (cdr operation-exp))<br /></tt></p><p></p><p>
 Observe that the treatment of operation expressions is very much like
 the treatment of procedure applications by the <tt>analyze-application</tt> procedure in the evaluator of
-section <a href="book-Z-H-26.html#%_sec_4.1.7">4.1.7</a> in that we generate an execution
+section <a href="book-Z-H-26.html#__sec_4.1.7">4.1.7</a> in that we generate an execution
 procedure for each operand.  At simulation time, we call the
 operand procedures and apply the Scheme procedure that simulates
 the operation to the resulting values.
 The simulation procedure is found by looking up the operation name in
 the operation table for the machine:
-</p><p></p><p><tt><a name="%_idx_5798" id="%_idx_5798"></a>(define (lookup-prim symbol operations)<br />
+</p><p></p><p><tt><a id="__idx_5798"></a>(define (lookup-prim symbol operations)<br />
   (let ((val (assoc symbol operations)))<br />
     (if val<br />
         (cadr val)<br />
         (error "Unknown operation -- ASSEMBLE" symbol))))<br /></tt></p><p></p><p></p><p>
 
-</p><p><a name="%_thm_5.9" id="%_thm_5.9"></a>
+</p><p><a id="__thm_5.9"></a>
 <b>Exercise 5.9.</b>  The treatment of machine operations above permits them to operate
 on labels as well as on constants and the contents of registers.
 Modify the expression-processing procedures to enforce the condition
 that operations can be used only with registers and constants.
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.10" id="%_thm_5.10"></a>
+</p><p><a id="__thm_5.10"></a>
 <b>Exercise 5.10.</b>  Design a new syntax for register-machine instructions and modify the
 simulator to use your new syntax.  Can you implement your new
 syntax without changing any part of the simulator except the
 syntax procedures in this section?
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.11" id="%_thm_5.11"></a>
-<b>Exercise 5.11.</b>  <a name="%_idx_5800" id="%_idx_5800"></a><a name="%_idx_5802" id="%_idx_5802"></a>When we introduced <tt>save</tt> and <tt>restore</tt> in
-section <a href="book-Z-H-31.html#%_sec_5.1.4">5.1.4</a>, we didn't specify what would happen
+</p><p><a id="__thm_5.11"></a>
+<b>Exercise 5.11.</b>  <a id="__idx_5800"></a><a id="__idx_5802"></a>When we introduced <tt>save</tt> and <tt>restore</tt> in
+section <a href="book-Z-H-31.html#__sec_5.1.4">5.1.4</a>, we didn't specify what would happen
 if you tried to restore a register that was not the last one saved, as
 in the sequence</p><p>
 
@@ -710,7 +710,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 stack, regardless of what register that value came from.  This is the
 way our simulator behaves.  Show how to take advantage of this
 behavior to eliminate one instruction from the Fibonacci machine of
-section <a href="book-Z-H-31.html#%_sec_5.1.4">5.1.4</a> (figure <a href="book-Z-H-31.html#%_fig_5.12">5.12</a>).</p><p>
+section <a href="book-Z-H-31.html#__sec_5.1.4">5.1.4</a> (figure <a href="book-Z-H-31.html#__fig_5.12">5.12</a>).</p><p>
 
 b.  <tt>(restore y)</tt> puts into <tt>y</tt> the last value saved on the
 stack, but only if that value was saved from <tt>y</tt>; otherwise, it
@@ -724,7 +724,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 <tt>initialize-stack</tt> operation initialize all the register stacks.
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.12" id="%_thm_5.12"></a>
+</p><p><a id="__thm_5.12"></a>
 <b>Exercise 5.12.</b>  The simulator can be used to help determine the data paths required
 for implementing a machine with a given controller.  Extend
 the assembler to store the following information in the machine model:
@@ -740,16 +740,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 
 </p></li><li>for each register, a list (without duplicates) of the sources from
 which it is assigned (for example, the sources for register <tt>val</tt>
-in the factorial machine of figure <a href="book-Z-H-31.html#%_fig_5.11">5.11</a> are
+in the factorial machine of figure <a href="book-Z-H-31.html#__fig_5.11">5.11</a> are
 <tt>(const 1)</tt> and <tt>((op *) (reg n) (reg val))</tt>).
 </li></ul><p>
 Extend the
 message-passing interface to the machine to provide access to this new
 information.  To test your analyzer, define the Fibonacci machine from
-figure <a href="book-Z-H-31.html#%_fig_5.12">5.12</a> and examine the lists you constructed.
+figure <a href="book-Z-H-31.html#__fig_5.12">5.12</a> and examine the lists you constructed.
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.13" id="%_thm_5.13"></a>
+</p><p><a id="__thm_5.13"></a>
 <b>Exercise 5.13.</b>  Modify the simulator so that it uses the controller sequence to
 determine what registers the machine has rather than requiring a list
 of registers as an argument to <tt>make-machine</tt>.  Instead of
@@ -758,12 +758,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 instructions.
 </p><p>
 
-<a name="%_sec_5.2.4" id="%_sec_5.2.4"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.2.4">5.2.4  Monitoring Machine Performance</a></h3><p>
+<a id="__sec_5.2.4"></a>
+</p><h3>5.2.4  Monitoring Machine Performance</h3><p>
 
 
-<a name="%_idx_5804" id="%_idx_5804"></a>
-<a name="%_idx_5806" id="%_idx_5806"></a>Simulation is useful not only for verifying the correctness of a
+<a id="__idx_5804"></a>
+<a id="__idx_5806"></a>Simulation is useful not only for verifying the correctness of a
 proposed machine design but also for measuring the machine's
 performance.  For example, we can install in our simulation program a
 “meter” that measures the number of stack operations used in a
@@ -773,12 +773,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 interface that prints the statistics, as shown below.
 We also add an operation to the basic machine model to print the
 stack statistics, by initializing <tt>the-ops</tt> in <tt>make-new-machine</tt> to
-</p><p></p><p><tt><a name="%_idx_5808" id="%_idx_5808"></a><a name="%_idx_5810" id="%_idx_5810"></a>(list (list 'initialize-stack<br />
+</p><p></p><p><tt><a id="__idx_5808"></a><a id="__idx_5810"></a>(list (list 'initialize-stack<br />
             (lambda () (stack 'initialize)))<br />
       (list 'print-stack-statistics<br />
             (lambda () (stack 'print-statistics))))<br /></tt></p><p></p><p>
 Here is the new version of <tt>make-stack</tt>:
-</p><p></p><p><tt><a name="%_idx_5812" id="%_idx_5812"></a>(define (make-stack)<br />
+</p><p></p><p><tt><a id="__idx_5812"></a>(define (make-stack)<br />
   (let ((s '())<br />
         (number-pushes 0)<br />
         (max-depth 0)<br />
@@ -816,16 +816,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
     dispatch))<br /></tt></p><p></p><p>
 </p><p>
 
-Exercises <a href="#%_thm_5.15">5.15</a> through <a href="#%_thm_5.19">5.19</a>
+Exercises <a href="#__thm_5.15">5.15</a> through <a href="#__thm_5.19">5.19</a>
 describe other useful monitoring and debugging features that can be
 added to the register-machine simulator.</p><p>
 
 </p><p>
 
-</p><p><a name="%_thm_5.14" id="%_thm_5.14"></a>
-<b>Exercise 5.14.</b>  <a name="%_idx_5814" id="%_idx_5814"></a>Measure the number of pushes and the maximum stack depth required to
+</p><p><a id="__thm_5.14"></a>
+<b>Exercise 5.14.</b>  <a id="__idx_5814"></a>Measure the number of pushes and the maximum stack depth required to
 compute <em>n</em>! for various small values of <em>n</em> using the factorial
-machine shown in figure <a href="book-Z-H-31.html#%_fig_5.11">5.11</a>.  From your data
+machine shown in figure <a href="book-Z-H-31.html#__fig_5.11">5.11</a>.  From your data
 determine formulas in terms of <em>n</em> for the total number of push
 operations and the maximum stack depth used in computing <em>n</em>! for any
 <em>n</em> &gt; 1. Note that each of these is a linear function of <em>n</em> and is
@@ -835,40 +835,40 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 You may want to also modify the
 machine so that it repeatedly reads a value for <em>n</em>, computes the
 factorial, and prints the result (as we did for the GCD machine in
-figure <a href="book-Z-H-31.html#%_fig_5.4">5.4</a>), so that you will not have to repeatedly
+figure <a href="book-Z-H-31.html#__fig_5.4">5.4</a>), so that you will not have to repeatedly
 invoke <tt>get-register-contents</tt>, <tt>set-register-contents!</tt>, and
 <tt>start</tt>.
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.15" id="%_thm_5.15"></a>
-<b>Exercise 5.15.</b>  Add <a name="%_idx_5816" id="%_idx_5816"></a><em>instruction counting</em> to the register machine simulation.
+</p><p><a id="__thm_5.15"></a>
+<b>Exercise 5.15.</b>  Add <a id="__idx_5816"></a><em>instruction counting</em> to the register machine simulation.
 That is, have the machine model keep track of the number of
 instructions executed.  Extend the machine model's interface to accept
 a new message that prints the value of the instruction count and
 resets the count to zero.
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.16" id="%_thm_5.16"></a>
-<b>Exercise 5.16.</b>  Augment the simulator to provide for <a name="%_idx_5818" id="%_idx_5818"></a><a name="%_idx_5820" id="%_idx_5820"></a><em>instruction tracing</em>.
+</p><p><a id="__thm_5.16"></a>
+<b>Exercise 5.16.</b>  Augment the simulator to provide for <a id="__idx_5818"></a><a id="__idx_5820"></a><em>instruction tracing</em>.
 That is, before each instruction is executed, the simulator should print
 the text of the instruction.  Make the machine model accept <tt>trace-on</tt> and
 <tt>trace-off</tt> messages to turn tracing on and off.
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.17" id="%_thm_5.17"></a>
+</p><p><a id="__thm_5.17"></a>
 <b>Exercise 5.17.</b>  Extend the instruction tracing of
-exercise <a href="#%_thm_5.16">5.16</a> so that before
+exercise <a href="#__thm_5.16">5.16</a> so that before
 printing an instruction, the simulator prints any labels that
 immediately precede that instruction in the controller sequence.  Be
 careful to do this in a way that does not interfere with instruction
-counting (exercise <a href="#%_thm_5.15">5.15</a>).
+counting (exercise <a href="#__thm_5.15">5.15</a>).
 You will have to make the simulator retain the necessary label information.
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.18" id="%_thm_5.18"></a>
-<b>Exercise 5.18.</b>  <a name="%_idx_5822" id="%_idx_5822"></a><a name="%_idx_5824" id="%_idx_5824"></a>Modify the <tt>make-register</tt> procedure of
-section <a href="#%_sec_5.2.1">5.2.1</a> so that registers can be traced.
+</p><p><a id="__thm_5.18"></a>
+<b>Exercise 5.18.</b>  <a id="__idx_5822"></a><a id="__idx_5824"></a>Modify the <tt>make-register</tt> procedure of
+section <a href="#__sec_5.2.1">5.2.1</a> so that registers can be traced.
 Registers should accept messages that turn tracing on and off.  When a
 register is traced, assigning a value to the register should print the
 name of the register, the old contents of the register, and the new
@@ -876,8 +876,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 to permit you to turn tracing on and off for designated machine registers.
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.19" id="%_thm_5.19"></a>
-<b>Exercise 5.19.</b>  Alyssa P. Hacker wants a <a name="%_idx_5826" id="%_idx_5826"></a><em>breakpoint</em> feature in the simulator to
+</p><p><a id="__thm_5.19"></a>
+<b>Exercise 5.19.</b>  Alyssa P. Hacker wants a <a id="__idx_5826"></a><em>breakpoint</em> feature in the simulator to
 help her debug her machine designs.  You have been hired to install
 this feature for her.  She wants to be able to specify a place in the
 controller sequence where the simulator will stop and allow her to
@@ -908,11 +908,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
 </p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_727" href="#call_footnote_Temp_727" id="footnote_Temp_727"><sup><small>4</small></sup></a> <a name="%_idx_5690" id="%_idx_5690"></a>Using the <tt>receive</tt> procedure here is a way to get <tt>extract-labels</tt> to effectively return two values – <tt>labels</tt> and
+</p><div class="footnote"><p><a href="#call_footnote_Temp_727" id="footnote_Temp_727"><sup><small>4</small></sup></a> <a id="__idx_5690"></a>Using the <tt>receive</tt> procedure here is a way to get <tt>extract-labels</tt> to effectively return two values – <tt>labels</tt> and
 <tt>insts</tt> – without explicitly making a compound data structure to
 hold them.  An alternative implementation, which returns an explicit
 pair of values, is
-</p><p></p><p><tt><a name="%_idx_5692" id="%_idx_5692"></a>(define (extract-labels text)<br />
+</p><p></p><p><tt><a id="__idx_5692"></a>(define (extract-labels text)<br />
   (if (null? text)<br />
       (cons '() '())<br />
       (let ((result (extract-labels (cdr text))))<br />
@@ -924,17 +924,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.2">5.2  A Register-Machine Simulato
                 (cons (cons (make-instruction next-inst) insts)<br />
                       labels)))))))<br /></tt></p><p></p><p>
 which would be called by <tt>assemble</tt> as follows:
-</p><p></p><p><tt><a name="%_idx_5694" id="%_idx_5694"></a>(define (assemble controller-text machine)<br />
+</p><p></p><p><tt><a id="__idx_5694"></a>(define (assemble controller-text machine)<br />
   (let ((result (extract-labels controller-text)))<br />
     (let ((insts (car result)) (labels (cdr result)))<br />
       (update-insts! insts labels machine)<br />
       insts)))<br /></tt></p><p></p><p>
-<a name="%_idx_5696" id="%_idx_5696"></a><a name="%_idx_5698" id="%_idx_5698"></a><a name="%_idx_5700" id="%_idx_5700"></a>You can consider our use of <tt>receive</tt> as demonstrating an elegant
+<a id="__idx_5696"></a><a id="__idx_5698"></a><a id="__idx_5700"></a>You can consider our use of <tt>receive</tt> as demonstrating an elegant
 way to return multiple values, or simply an excuse to show off a
 programming trick.  An argument like <tt>receive</tt> that is the next
 procedure to be invoked is called a “continuation.”  Recall that we
 also used continuations to implement the backtracking control
-structure in the <tt>amb</tt> evaluator in section <a href="book-Z-H-28.html#%_sec_4.3.3">4.3.3</a>.
+structure in the <tt>amb</tt> evaluator in section <a href="book-Z-H-28.html#__sec_4.3.3">4.3.3</a>.
 
 </p></div>
 
diff --git a/src/OEBPS/book-Z-H-33.html b/src/OEBPS/book-Z-H-33.html
index 691638b..0590b30 100644
--- a/src/OEBPS/book-Z-H-33.html
+++ b/src/OEBPS/book-Z-H-33.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,12 +13,12 @@
 
 
 
-<a name="%_sec_5.3" id="%_sec_5.3"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garbage Collection</a></h2><p>
+<a id="__sec_5.3"></a>
+<h2>5.3  Storage Allocation and Garbage Collection</h2><p>
 
 
-<a name="%_idx_5828" id="%_idx_5828"></a><a name="%_idx_5830" id="%_idx_5830"></a>
-In section <a href="book-Z-H-34.html#%_sec_5.4">5.4</a>, we will show how to implement a Scheme
+<a id="__idx_5828"></a><a id="__idx_5830"></a>
+In section <a href="book-Z-H-34.html#__sec_5.4">5.4</a>, we will show how to implement a Scheme
 evaluator as a register machine.  In order to simplify the discussion,
 we will assume that our register machines can be equipped with a <em>list-structured memory</em>, in which the basic operations for
 manipulating list-structured data are primitive.  Postulating the
@@ -43,7 +43,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 objects would pose no problem on a computer with an infinite amount of
 rapidly addressable memory, computer memories are available only in
 finite sizes (more's the pity).  Lisp systems
-thus provide an <a name="%_idx_5832" id="%_idx_5832"></a><em>automatic storage allocation</em> facility to
+thus provide an <a id="__idx_5832"></a><em>automatic storage allocation</em> facility to
 support the illusion of an infinite memory.  When a data object is no
 longer needed, the memory allocated to it is automatically recycled
 and used to construct new data objects.  There are various
@@ -51,64 +51,64 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 method we shall discuss in this section is called <em>garbage
 collection</em>.</p><p>
 
-<a name="%_sec_5.3.1" id="%_sec_5.3.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.3.1">5.3.1  Memory as Vectors</a></h3><p>
+<a id="__sec_5.3.1"></a>
+</p><h3>5.3.1  Memory as Vectors</h3><p>
 
 </p><p>
 
 A conventional computer memory can be thought of as an array of
 cubbyholes, each of which can contain a piece of information.  Each
-cubbyhole has a unique name, called its <a name="%_idx_5834" id="%_idx_5834"></a><em>address</em> or <a name="%_idx_5836" id="%_idx_5836"></a><em>location</em>.  Typical memory systems provide two primitive operations:
+cubbyhole has a unique name, called its <a id="__idx_5834"></a><em>address</em> or <a id="__idx_5836"></a><em>location</em>.  Typical memory systems provide two primitive operations:
 one that fetches the data stored in a specified location and one that
 assigns new data to a specified location.  Memory addresses can be
 incremented to support sequential access to some set of the
 cubbyholes.  More generally, many important data operations require
 that memory addresses be treated as data, which can be stored in
 memory locations and manipulated in machine registers.  The
-representation of list structure is one application of such <a name="%_idx_5838" id="%_idx_5838"></a><a name="%_idx_5840" id="%_idx_5840"></a><em>address arithmetic</em>.</p><p>
+representation of list structure is one application of such <a id="__idx_5838"></a><a id="__idx_5840"></a><em>address arithmetic</em>.</p><p>
 
 To model computer memory, we use a new kind of data
-structure called a <a name="%_idx_5842" id="%_idx_5842"></a><em>vector</em>.  Abstractly, a vector is a compound
+structure called a <a id="__idx_5842"></a><em>vector</em>.  Abstractly, a vector is a compound
 data object whose individual elements can be accessed by means of an
 integer index in an amount of time that is independent of the
-index.<a name="call_footnote_Temp_744" href="#footnote_Temp_744" id="call_footnote_Temp_744"><sup><small>5</small></sup></a> In order to describe memory operations, we use two
+index.<a href="#footnote_Temp_744" id="call_footnote_Temp_744"><sup><small>5</small></sup></a> In order to describe memory operations, we use two
 primitive Scheme procedures for manipulating vectors:</p><p>
 
-</p><p></p><ul><a name="%_idx_5844" id="%_idx_5844"></a><a name="%_idx_5846" id="%_idx_5846"></a><li><tt>(vector-ref &lt;<em>vector</em>&gt; &lt;<em>n</em>&gt;)</tt> returns the <em>n</em>th
+</p><p></p><ul><a id="__idx_5844"></a><a id="__idx_5846"></a><li><tt>(vector-ref &lt;<em>vector</em>&gt; &lt;<em>n</em>&gt;)</tt> returns the <em>n</em>th
 element of the vector.<p>
 
-<a name="%_idx_5848" id="%_idx_5848"></a><a name="%_idx_5850" id="%_idx_5850"></a></p></li><li><tt>(vector-set! &lt;<em>vector</em>&gt; &lt;<em>n</em>&gt; &lt;<em>value</em>&gt;)</tt> sets
+<a id="__idx_5848"></a><a id="__idx_5850"></a></p></li><li><tt>(vector-set! &lt;<em>vector</em>&gt; &lt;<em>n</em>&gt; &lt;<em>value</em>&gt;)</tt> sets
 the <em>n</em>th element of the vector to the designated value.
 </li></ul><p>
 For example, if <tt>v</tt> is a vector, then <tt>(vector-ref v 5)</tt> gets
 the fifth entry in the vector <tt>v</tt> and <tt>(vector-set! v 5 7)</tt>
-changes the value of the fifth entry of the vector <tt>v</tt> to 7.<a name="call_footnote_Temp_745" href="#footnote_Temp_745" id="call_footnote_Temp_745"><sup><small>6</small></sup></a>
+changes the value of the fifth entry of the vector <tt>v</tt> to 7.<a href="#footnote_Temp_745" id="call_footnote_Temp_745"><sup><small>6</small></sup></a>
 For computer memory, this access can be implemented
 through the use of address arithmetic to combine a <em>base address</em>
 that specifies the beginning location of a vector in memory with an
 <em>index</em> that specifies the offset of a particular element of the vector.</p><p>
 
-<a name="%_sec_Temp_746" id="%_sec_Temp_746"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_746">Representing Lisp data</a></h4><p>
+<a id="__sec_Temp_746"></a>
+</p><h4>Representing Lisp data</h4><p>
 
-<a name="%_idx_5852" id="%_idx_5852"></a><a name="%_idx_5854" id="%_idx_5854"></a>
+<a id="__idx_5852"></a><a id="__idx_5854"></a>
 We can use vectors to implement the basic pair structures required for
 a list-structured memory.  Let us imagine that computer memory is
-divided into two vectors: <a name="%_idx_5856" id="%_idx_5856"></a><tt>the-cars</tt> and <a name="%_idx_5858" id="%_idx_5858"></a><tt>the-cdrs</tt>.  We will
+divided into two vectors: <a id="__idx_5856"></a><tt>the-cars</tt> and <a id="__idx_5858"></a><tt>the-cdrs</tt>.  We will
 represent list structure as follows: A pointer to a pair is an index
 into the two vectors.  The <tt>car</tt> of the pair is the entry in <tt>the-cars</tt> with the designated index, and the <tt>cdr</tt> of the pair is
 the entry in <tt>the-cdrs</tt> with the designated index.  We also need a
 representation for objects other than pairs (such as numbers and
 symbols) and a way to distinguish one kind of data from another.
 There are many methods of accomplishing this, but they all reduce to
-using <a name="%_idx_5860" id="%_idx_5860"></a><a name="%_idx_5862" id="%_idx_5862"></a><em>typed pointers</em>, that is, to extending the notion of
-“pointer” to include information on data type.<a name="call_footnote_Temp_747" href="#footnote_Temp_747" id="call_footnote_Temp_747"><sup><small>7</small></sup></a> The data type enables the system to
+using <a id="__idx_5860"></a><a id="__idx_5862"></a><em>typed pointers</em>, that is, to extending the notion of
+“pointer” to include information on data type.<a href="#footnote_Temp_747" id="call_footnote_Temp_747"><sup><small>7</small></sup></a> The data type enables the system to
 distinguish a pointer to a pair (which consists of the “pair” data
 type and an index into the memory vectors) from pointers to other
 kinds of data (which consist of some other data type and whatever is
 being used to represent data of that type).  Two data objects are
-<a name="%_idx_5868" id="%_idx_5868"></a>considered to be the same (<tt>eq?</tt>) if their pointers are
-identical.<a name="call_footnote_Temp_748" href="#footnote_Temp_748" id="call_footnote_Temp_748"><sup><small>8</small></sup></a> Figure <a href="#%_fig_5.14">5.14</a>
+<a id="__idx_5868"></a>considered to be the same (<tt>eq?</tt>) if their pointers are
+identical.<a href="#footnote_Temp_748" id="call_footnote_Temp_748"><sup><small>8</small></sup></a> Figure <a href="#__fig_5.14">5.14</a>
 illustrates the use of this method to represent the list <tt>((1 2) 3
 4)</tt>, whose box-and-pointer diagram is also shown.  We use letter
 prefixes to denote the data-type information.  Thus, a pointer to the
@@ -118,31 +118,31 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 and <tt>cdr</tt> of the pair are stored.  The blank locations in <tt>the-cars</tt> and <tt>the-cdrs</tt> may contain parts of other list
 structures (not of interest here).</p><p>
 
-<a name="%_fig_5.14" id="%_fig_5.14"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch5-Z-G-7.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 5.14:</b>  Box-and-pointer and memory-vector representations
+<a id="__fig_5.14"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch5-Z-G-7.gif" alt="ch5-Z-G-7" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.14:</b>  Box-and-pointer and memory-vector representations
 of the list <tt>((1 2) 3 4)</tt>.</div></caption><tr><td>
 
 </td></tr></table></div><p>                                                         </p><p>
 
 A pointer to a number, such as <tt>n4</tt>,
 might consist of a type indicating numeric data together with the
-actual representation of the number 4.<a name="call_footnote_Temp_749" href="#footnote_Temp_749" id="call_footnote_Temp_749"><sup><small>9</small></sup></a>
+actual representation of the number 4.<a href="#footnote_Temp_749" id="call_footnote_Temp_749"><sup><small>9</small></sup></a>
 To deal with numbers that are too large to
 be represented in the fixed amount of space allocated for a single
-pointer, we could use a distinct <a name="%_idx_5880" id="%_idx_5880"></a><em>bignum</em> data type, for which the
+pointer, we could use a distinct <a id="__idx_5880"></a><em>bignum</em> data type, for which the
 pointer designates a list in which the parts of the number are
-stored.<a name="call_footnote_Temp_750" href="#footnote_Temp_750" id="call_footnote_Temp_750"><sup><small>10</small></sup></a></p><p>
+stored.<a href="#footnote_Temp_750" id="call_footnote_Temp_750"><sup><small>10</small></sup></a></p><p>
 
 
-<a name="%_idx_5882" id="%_idx_5882"></a>A symbol might be represented as a typed pointer that designates a
+<a id="__idx_5882"></a>A symbol might be represented as a typed pointer that designates a
 sequence of the characters that form the symbol's printed representation.
 This sequence is constructed by the Lisp reader when the character string
 is initially encountered in input.  Since we want two instances of a
 symbol to be recognized as the “same” symbol by <tt>eq?</tt> and we
-<a name="%_idx_5884" id="%_idx_5884"></a>want <tt>eq?</tt> to be a simple test for equality of pointers, we must
+<a id="__idx_5884"></a>want <tt>eq?</tt> to be a simple test for equality of pointers, we must
 ensure that if the reader sees the same character string twice, it
 will use the same pointer (to the same sequence of characters) to
 represent both occurrences.  To accomplish this, the reader maintains
-a table, traditionally called the <a name="%_idx_5886" id="%_idx_5886"></a><em>obarray</em>, of all the symbols it
+a table, traditionally called the <a id="__idx_5886"></a><em>obarray</em>, of all the symbols it
 has ever encountered.  When the reader encounters a character string
 and is about to construct a symbol, it checks the obarray to see if it
 has ever before seen the same character string.  If it has not, it
@@ -150,15 +150,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 new character sequence) and enters this pointer in the obarray.  If the
 reader has seen the string before, it returns the symbol pointer
 stored in the obarray.  This process of replacing character strings by
-unique pointers is called <a name="%_idx_5888" id="%_idx_5888"></a><a name="%_idx_5890" id="%_idx_5890"></a><em>interning</em> symbols.</p><p>
+unique pointers is called <a id="__idx_5888"></a><a id="__idx_5890"></a><em>interning</em> symbols.</p><p>
 
 
-<a name="%_sec_Temp_751" id="%_sec_Temp_751"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_751">Implementing the primitive list operations</a></h4><p>
+<a id="__sec_Temp_751"></a>
+</p><h4>Implementing the primitive list operations</h4><p>
 
 </p><p>
 
-<a name="%_idx_5892" id="%_idx_5892"></a><a name="%_idx_5894" id="%_idx_5894"></a>Given the above representation scheme, we can replace each
+<a id="__idx_5892"></a><a id="__idx_5894"></a>Given the above representation scheme, we can replace each
 “primitive” list operation of a register machine with one or more
 primitive vector operations.  We will use two registers, <tt>the-cars</tt> and <tt>the-cdrs</tt>, to identify the memory vectors, and will
 assume that <tt>vector-ref</tt> and <tt>vector-set!</tt> are available as
@@ -169,7 +169,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 
 For example, we can make a register machine support the instructions</p><p>
 
-<a name="%_idx_5896" id="%_idx_5896"></a><a name="%_idx_5898" id="%_idx_5898"></a>
+<a id="__idx_5896"></a><a id="__idx_5898"></a>
 </p><p></p><p><tt>(assign &lt;<em>reg<sub>1</sub></em>&gt; (op car) (reg &lt;<em>reg<sub>2</sub></em>&gt;))<br /><br />
 (assign &lt;<em>reg<sub>1</sub></em>&gt; (op cdr) (reg &lt;<em>reg<sub>2</sub></em>&gt;))<br /></tt></p><p></p><p>
 if we implement these, respectively, as</p><p>
@@ -179,7 +179,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 (assign &lt;<em>reg<sub>1</sub></em>&gt; (op vector-ref) (reg the-cdrs) (reg &lt;<em>reg<sub>2</sub></em>&gt;))<br /></tt></p><p></p><p>
 The instructions</p><p>
 
-<a name="%_idx_5900" id="%_idx_5900"></a><a name="%_idx_5902" id="%_idx_5902"></a>
+<a id="__idx_5900"></a><a id="__idx_5902"></a>
 </p><p></p><p><tt>(perform (op set-car!) (reg &lt;<em>reg<sub>1</sub></em>&gt;) (reg &lt;<em>reg<sub>2</sub></em>&gt;))<br /><br />
 (perform (op set-cdr!) (reg &lt;<em>reg<sub>1</sub></em>&gt;) (reg &lt;<em>reg<sub>2</sub></em>&gt;))<br /></tt></p><p></p><p>
 are implemented as
@@ -190,17 +190,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
  (op vector-set!) (reg the-cdrs) (reg &lt;<em>reg<sub>1</sub></em>&gt;) (reg &lt;<em>reg<sub>2</sub></em>&gt;))<br /></tt></p><p></p><p>
 </p><p>
 
-<a name="%_idx_5904" id="%_idx_5904"></a><tt>Cons</tt> is performed by allocating an unused index and storing the
+<a id="__idx_5904"></a><tt>Cons</tt> is performed by allocating an unused index and storing the
 arguments to <tt>cons</tt> in <tt>the-cars</tt> and <tt>the-cdrs</tt> at that
 indexed vector position.  We presume that there is a special register,
-<a name="%_idx_5906" id="%_idx_5906"></a><tt>free</tt>, that always holds a pair pointer containing the next
+<a id="__idx_5906"></a><tt>free</tt>, that always holds a pair pointer containing the next
 available index, and that we can increment the index part of that
-pointer to find the next free location.<a name="call_footnote_Temp_752" href="#footnote_Temp_752" id="call_footnote_Temp_752"><sup><small>11</small></sup></a>
+pointer to find the next free location.<a href="#footnote_Temp_752" id="call_footnote_Temp_752"><sup><small>11</small></sup></a>
 For example, the instruction</p><p>
 
 </p><p></p><p><tt>(assign &lt;<em>reg<sub>1</sub></em>&gt; (op cons) (reg &lt;<em>reg<sub>2</sub></em>&gt;) (reg &lt;<em>reg<sub>3</sub></em>&gt;))<br /></tt></p><p></p><p>
 is implemented as the following sequence of vector
-operations:<a name="call_footnote_Temp_753" href="#footnote_Temp_753" id="call_footnote_Temp_753"><sup><small>12</small></sup></a></p><p>
+operations:<a href="#footnote_Temp_753" id="call_footnote_Temp_753"><sup><small>12</small></sup></a></p><p>
 
 </p><p></p><p><tt>(perform<br />
  (op vector-set!) (reg the-cars) (reg free) (reg &lt;<em>reg<sub>2</sub></em>&gt;))<br />
@@ -212,18 +212,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 
 </p><p></p><p><tt>(op eq?) (reg &lt;<em>reg<sub>1</sub></em>&gt;) (reg &lt;<em>reg<sub>2</sub></em>&gt;)<br /></tt></p><p></p><p>
 simply tests the equality of all fields in the registers, and
-<a name="%_idx_5910" id="%_idx_5910"></a><a name="%_idx_5912" id="%_idx_5912"></a><a name="%_idx_5914" id="%_idx_5914"></a><a name="%_idx_5916" id="%_idx_5916"></a>predicates such as <tt>pair?</tt>, <tt>null?</tt>, <tt>symbol?</tt>, and <tt>number?</tt> need only check the type field.</p><p>
+<a id="__idx_5910"></a><a id="__idx_5912"></a><a id="__idx_5914"></a><a id="__idx_5916"></a>predicates such as <tt>pair?</tt>, <tt>null?</tt>, <tt>symbol?</tt>, and <tt>number?</tt> need only check the type field.</p><p>
 
-<a name="%_sec_Temp_754" id="%_sec_Temp_754"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_754">Implementing stacks</a></h4><p>
+<a id="__sec_Temp_754"></a>
+</p><h4>Implementing stacks</h4><p>
 
-<a name="%_idx_5918" id="%_idx_5918"></a>
+<a id="__idx_5918"></a>
 Although our register machines use stacks, we need do nothing special
 here, since stacks can be modeled in terms of lists.  The stack can be
 a list of the saved values, pointed to by a special register <tt>the-stack</tt>.  Thus, <tt>(save &lt;<em>reg</em>&gt;)</tt> can be implemented as</p><p>
 
-<a name="%_idx_5920" id="%_idx_5920"></a></p><p></p><p><tt>(assign the-stack (op cons) (reg &lt;<em>reg</em>&gt;) (reg the-stack))<br /></tt></p><p></p><p>
-<a name="%_idx_5922" id="%_idx_5922"></a>Similarly, <tt>(restore &lt;<em>reg</em>&gt;)</tt> can be implemented as
+<a id="__idx_5920"></a></p><p></p><p><tt>(assign the-stack (op cons) (reg &lt;<em>reg</em>&gt;) (reg the-stack))<br /></tt></p><p></p><p>
+<a id="__idx_5922"></a>Similarly, <tt>(restore &lt;<em>reg</em>&gt;)</tt> can be implemented as
 </p><p></p><p><tt>(assign &lt;<em>reg</em>&gt; (op car) (reg the-stack))<br />
 (assign the-stack (op cdr) (reg the-stack))<br /></tt></p><p></p><p>
 and <tt>(perform (op initialize-stack))</tt> can be implemented as
@@ -235,9 +235,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 accomplished by incrementing or decrementing an index into that
 vector.</p><p>
 
-</p><p><a name="%_thm_5.20" id="%_thm_5.20"></a>
+</p><p><a id="__thm_5.20"></a>
 <b>Exercise 5.20.</b>  Draw the box-and-pointer representation and the memory-vector
-representation (as in figure <a href="#%_fig_5.14">5.14</a>) of the
+representation (as in figure <a href="#__fig_5.14">5.14</a>) of the
 list structure produced by</p><p>
 
 </p><p></p><p><tt>(define x (cons 1 2))<br />
@@ -246,8 +246,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 value of <tt>free</tt> ?  What pointers represent the values of <tt>x</tt> and <tt>y</tt> ?
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.21" id="%_thm_5.21"></a>
-<b>Exercise 5.21.</b>  <a name="%_idx_5924" id="%_idx_5924"></a>Implement register machines for the following procedures.
+</p><p><a id="__thm_5.21"></a>
+<b>Exercise 5.21.</b>  <a id="__idx_5924"></a>Implement register machines for the following procedures.
 Assume that the list-structure memory operations are available as
 machine primitives.</p><p>
 
@@ -269,8 +269,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
   (count-iter tree 0))<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.22" id="%_thm_5.22"></a>
-<b>Exercise 5.22.</b>  <a name="%_idx_5926" id="%_idx_5926"></a><a name="%_idx_5928" id="%_idx_5928"></a>Exercise <a href="book-Z-H-22.html#%_thm_3.12">3.12</a> of section <a href="book-Z-H-22.html#%_sec_3.3.1">3.3.1</a>
+</p><p><a id="__thm_5.22"></a>
+<b>Exercise 5.22.</b>  <a id="__idx_5926"></a><a id="__idx_5928"></a>Exercise <a href="book-Z-H-22.html#__thm_3.12">3.12</a> of section <a href="book-Z-H-22.html#__sec_3.3.1">3.3.1</a>
 presented an <tt>append</tt> procedure that appends two lists to form a
 new list and an <tt>append!</tt> procedure that splices two lists
 together.  Design a register machine to implement each of these
@@ -278,16 +278,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 available as primitive operations.
 </p><p>
 
-<a name="%_sec_5.3.2" id="%_sec_5.3.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.3.2">5.3.2  Maintaining the Illusion of Infinite Memory</a></h3><p>
+<a id="__sec_5.3.2"></a>
+</p><h3>5.3.2  Maintaining the Illusion of Infinite Memory</h3><p>
 
-<a name="%_idx_5930" id="%_idx_5930"></a></p><p>
+<a id="__idx_5930"></a></p><p>
 
 The representation method outlined in
-section <a href="#%_sec_5.3.1">5.3.1</a> solves the problem of implementing
+section <a href="#__sec_5.3.1">5.3.1</a> solves the problem of implementing
 list structure, provided that we have an infinite amount of memory.
 With a real computer we will eventually run out of free space in which
-to construct new pairs.<a name="call_footnote_Temp_758" href="#footnote_Temp_758" id="call_footnote_Temp_758"><sup><small>13</small></sup></a>
+to construct new pairs.<a href="#footnote_Temp_758" id="call_footnote_Temp_758"><sup><small>13</small></sup></a>
 However, most of the pairs generated in a typical
 computation are used only to hold intermediate results.  After these
 results are accessed, the pairs are no longer needed – they are <em>garbage</em>.  For instance, the computation</p><p>
@@ -309,11 +309,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 any moment in a Lisp interpretation, the only objects that can
 affect the future of the computation are those that can be reached by
 some succession of <tt>car</tt> and <tt>cdr</tt> operations starting from
-the pointers that are currently in the machine registers.<a name="call_footnote_Temp_759" href="#footnote_Temp_759" id="call_footnote_Temp_759"><sup><small>14</small></sup></a>  Any memory cell
+the pointers that are currently in the machine registers.<a href="#footnote_Temp_759" id="call_footnote_Temp_759"><sup><small>14</small></sup></a>  Any memory cell
 that is not so accessible may be recycled.</p><p>
 
 There are many ways to perform garbage collection.  The method we
-shall examine here is called <a name="%_idx_5932" id="%_idx_5932"></a><a name="%_idx_5934" id="%_idx_5934"></a><em>stop-and-copy</em>.  The basic idea is
+shall examine here is called <a id="__idx_5932"></a><a id="__idx_5934"></a><em>stop-and-copy</em>.  The basic idea is
 to divide memory into two halves: “working memory” and “free
 memory.”  When <tt>cons</tt> constructs pairs, it allocates these in
 working memory.  When working memory is full, we perform garbage
@@ -328,22 +328,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 continue processing; new pairs will be allocated in the new working
 memory (which was the old free memory).  When this is full, we can
 copy the useful pairs into the new free memory (which was the old
-working memory).<a name="call_footnote_Temp_760" href="#footnote_Temp_760" id="call_footnote_Temp_760"><sup><small>15</small></sup></a></p><p>
+working memory).<a href="#footnote_Temp_760" id="call_footnote_Temp_760"><sup><small>15</small></sup></a></p><p>
 
-<a name="%_sec_Temp_761" id="%_sec_Temp_761"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_761">Implementation of a stop-and-copy garbage collector</a></h4><p>
+<a id="__sec_Temp_761"></a>
+</p><h4>Implementation of a stop-and-copy garbage collector</h4><p>
 
 We now use our register-machine language to describe the stop-and-copy
 algorithm in more detail.  We will assume that there is a register
-called <a name="%_idx_5966" id="%_idx_5966"></a><tt>root</tt> that contains a pointer to a structure that
+called <a id="__idx_5966"></a><tt>root</tt> that contains a pointer to a structure that
 eventually points at all accessible data.  This can be arranged by
 storing the contents of all the machine registers in a
 pre-allocated list pointed at by <tt>root</tt> just before starting
-garbage collection.<a name="call_footnote_Temp_762" href="#footnote_Temp_762" id="call_footnote_Temp_762"><sup><small>16</small></sup></a> We also assume that, in addition to the
+garbage collection.<a href="#footnote_Temp_762" id="call_footnote_Temp_762"><sup><small>16</small></sup></a> We also assume that, in addition to the
 current working memory, there is free memory available into which we
 can copy the useful data.  The current working memory consists of
-vectors whose base addresses are in <a name="%_idx_5968" id="%_idx_5968"></a><a name="%_idx_5970" id="%_idx_5970"></a>registers called <tt>the-cars</tt>
-and <tt>the-cdrs</tt>, and the free memory is in registers called <a name="%_idx_5972" id="%_idx_5972"></a><a name="%_idx_5974" id="%_idx_5974"></a><tt>new-cars</tt> and <tt>new-cdrs</tt>.</p><p>
+vectors whose base addresses are in <a id="__idx_5968"></a><a id="__idx_5970"></a>registers called <tt>the-cars</tt>
+and <tt>the-cdrs</tt>, and the free memory is in registers called <a id="__idx_5972"></a><a id="__idx_5974"></a><tt>new-cars</tt> and <tt>new-cdrs</tt>.</p><p>
 
 Garbage collection is triggered when we exhaust the free cells in the
 current working memory, that is, when a <tt>cons</tt> operation attempts
@@ -356,15 +356,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 constructed in the new memory, beginning at the place indicated by
 <tt>free</tt>, and the (previous) working memory will be available as the
 new memory for the next garbage collection.
-Figure <a href="#%_fig_5.15">5.15</a> shows the arrangement of memory just
+Figure <a href="#__fig_5.15">5.15</a> shows the arrangement of memory just
 before and just after garbage collection.</p><p>
 
-<a name="%_fig_5.15" id="%_fig_5.15"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/ch5-Z-G-8.gif" border="0" /></td></tr><caption align="bottom"><div align="left"><b>Figure 5.15:</b>  Reconfiguration of memory by the garbage-collection
+<a id="__fig_5.15"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/ch5-Z-G-8.gif" alt="ch5-Z-G-8" style="border: none;" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.15:</b>  Reconfiguration of memory by the garbage-collection
 process.</div></caption><tr><td>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_idx_5976" id="%_idx_5976"></a><a name="%_idx_5978" id="%_idx_5978"></a>The state of the garbage-collection process is controlled by
+<a id="__idx_5976"></a><a id="__idx_5978"></a>The state of the garbage-collection process is controlled by
 maintaining two pointers: <tt>free</tt> and <tt>scan</tt>.  These are
 initialized to point to the beginning of the new memory.  The
 algorithm begins by relocating the pair pointed at by <tt>root</tt> to
@@ -374,7 +374,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 marked to show that its contents have been moved.  This marking is
 done as follows: In the <tt>car</tt> position, we place a special tag
 that signals that this is an already-moved object.  (Such an object is
-traditionally called a <a name="%_idx_5980" id="%_idx_5980"></a><em>broken heart</em>.)<a name="call_footnote_Temp_763" href="#footnote_Temp_763" id="call_footnote_Temp_763"><sup><small>17</small></sup></a>  In the <tt>cdr</tt> position we place a <a name="%_idx_5988" id="%_idx_5988"></a><em>forwarding
+traditionally called a <a id="__idx_5980"></a><em>broken heart</em>.)<a href="#footnote_Temp_763" id="call_footnote_Temp_763"><sup><small>17</small></sup></a>  In the <tt>cdr</tt> position we place a <a id="__idx_5988"></a><em>forwarding
 address</em> that points at the location to which the object has been
 moved.</p><p>
 
@@ -407,9 +407,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 machine.  The basic step of relocating an object is accomplished by a
 subroutine called <tt>relocate-old-result-in-new</tt>.  This
 subroutine gets its argument, a pointer to the object to be relocated,
-from a register named <a name="%_idx_5990" id="%_idx_5990"></a><tt>old</tt>.  It relocates the designated object
+from a register named <a id="__idx_5990"></a><tt>old</tt>.  It relocates the designated object
 (incrementing <tt>free</tt> in the process),
-puts a pointer to the relocated object into a register called <a name="%_idx_5992" id="%_idx_5992"></a><tt>new</tt>, and returns by branching to the entry point stored in the register
+puts a pointer to the relocated object into a register called <a id="__idx_5992"></a><tt>new</tt>, and returns by branching to the entry point stored in the register
 <tt>relocate-continue</tt>.  To begin garbage collection, we invoke this
 subroutine to relocate the <tt>root</tt> pointer, after initializing <tt>free</tt> and <tt>scan</tt>.  When the relocation of <tt>root</tt> has been
 accomplished, we install the new pointer as the new <tt>root</tt> and
@@ -466,7 +466,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 follows: If the object to be relocated (pointed at by <tt>old</tt>) is
 not a pair, then we return the same pointer to the object unchanged
 (in <tt>new</tt>).  (For example, we may be scanning a pair whose <tt>car</tt> is the number 4.  If we represent the <tt>car</tt> by <tt>n4</tt>, as
-described in section <a href="#%_sec_5.3.1">5.3.1</a>, then we want the
+described in section <a href="#__sec_5.3.1">5.3.1</a>, then we want the
 “relocated” <tt>car</tt> pointer to still be <tt>n4</tt>.)  Otherwise, we
 must perform the relocation.  If the <tt>car</tt> position of the pair to
 be relocated contains a broken-heart tag, then the pair has in fact
@@ -475,9 +475,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 If the pointer in <tt>old</tt> points at a yet-unmoved pair, then we move
 the pair to the first free cell in new memory (pointed at by <tt>free</tt>) and set up the broken heart by storing a broken-heart tag and
 forwarding address at the old location.
-<tt>Relocate-old-result-in-new</tt> uses a register <a name="%_idx_5994" id="%_idx_5994"></a><tt>oldcr</tt>
+<tt>Relocate-old-result-in-new</tt> uses a register <a id="__idx_5994"></a><tt>oldcr</tt>
 to hold the <tt>car</tt> or the <tt>cdr</tt> of the object pointed at by
-<tt>old</tt>.<a name="call_footnote_Temp_764" href="#footnote_Temp_764" id="call_footnote_Temp_764"><sup><small>18</small></sup></a></p><p>
+<tt>old</tt>.<a href="#footnote_Temp_764" id="call_footnote_Temp_764"><sup><small>18</small></sup></a></p><p>
 
 </p><p></p><p><tt>relocate-old-result-in-new<br />
   (test (op pointer-to-pair?) (reg old))<br />
@@ -523,39 +523,39 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 </p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_744" href="#call_footnote_Temp_744" id="footnote_Temp_744"><sup><small>5</small></sup></a> We could represent memory as lists of items.
+</p><div class="footnote"><p><a href="#call_footnote_Temp_744" id="footnote_Temp_744"><sup><small>5</small></sup></a> We could represent memory as lists of items.
 However, the access time would then not be independent of the index,
 since accessing the <em>n</em>th element of a list requires <em>n</em> - 1 <tt>cdr</tt>
 operations.
 
-</p><p><a name="footnote_Temp_745" href="#call_footnote_Temp_745" id="footnote_Temp_745"><sup><small>6</small></sup></a> For completeness, we should specify a <tt>make-vector</tt>
+</p><p><a href="#call_footnote_Temp_745" id="footnote_Temp_745"><sup><small>6</small></sup></a> For completeness, we should specify a <tt>make-vector</tt>
 operation that constructs vectors.  However, in the present
 application we will use vectors only to model fixed divisions of the
 computer memory.
 
-</p><p><a name="footnote_Temp_747" href="#call_footnote_Temp_747" id="footnote_Temp_747"><sup><small>7</small></sup></a> This is
-precisely the same <a name="%_idx_5864" id="%_idx_5864"></a><a name="%_idx_5866" id="%_idx_5866"></a>“tagged data” idea we introduced in chapter 2 for
+</p><p><a href="#call_footnote_Temp_747" id="footnote_Temp_747"><sup><small>7</small></sup></a> This is
+precisely the same <a id="__idx_5864"></a><a id="__idx_5866"></a>“tagged data” idea we introduced in chapter 2 for
 dealing with generic operations.  Here, however, the data types are
 included at the primitive machine level rather than constructed
 through the use of lists.
 
-</p><p><a name="footnote_Temp_748" href="#call_footnote_Temp_748" id="footnote_Temp_748"><sup><small>8</small></sup></a> Type information may be encoded in a variety of
+</p><p><a href="#call_footnote_Temp_748" id="footnote_Temp_748"><sup><small>8</small></sup></a> Type information may be encoded in a variety of
 ways, depending on the details of the machine on which the Lisp
 system is to be implemented.  The execution efficiency of Lisp
 programs will be strongly dependent on how cleverly this choice is
 made, but it is difficult to formulate general design rules for good
 choices.  The most straightforward way to implement typed pointers is
-to allocate a fixed set of bits in each pointer to be a <a name="%_idx_5870" id="%_idx_5870"></a><em>type
+to allocate a fixed set of bits in each pointer to be a <a id="__idx_5870"></a><em>type
 field</em> that encodes the data type.  Important questions to be
 addressed in designing such a representation include the following:
 How many type bits are required?  How large must the vector indices
 be?  How efficiently can the primitive machine instructions be used to
 manipulate the type fields of pointers?  Machines that include special
 hardware for the efficient handling of type fields are said to have
-<a name="%_idx_5872" id="%_idx_5872"></a><em>tagged architectures</em>.
+<a id="__idx_5872"></a><em>tagged architectures</em>.
 
-</p><p><a name="footnote_Temp_749" href="#call_footnote_Temp_749" id="footnote_Temp_749"><sup><small>9</small></sup></a> This decision on the
-<a name="%_idx_5874" id="%_idx_5874"></a><a name="%_idx_5876" id="%_idx_5876"></a><a name="%_idx_5878" id="%_idx_5878"></a>representation of numbers determines whether <tt>eq?</tt>, which tests
+</p><p><a href="#call_footnote_Temp_749" id="footnote_Temp_749"><sup><small>9</small></sup></a> This decision on the
+<a id="__idx_5874"></a><a id="__idx_5876"></a><a id="__idx_5878"></a>representation of numbers determines whether <tt>eq?</tt>, which tests
 equality of pointers, can be used to test for equality of numbers.  If
 the pointer contains the number itself, then equal numbers will have
 the same pointer.  But if the pointer contains the index of a location
@@ -563,21 +563,21 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 equal pointers only if we are careful never to store the same number
 in more than one location.
 
-</p><p><a name="footnote_Temp_750" href="#call_footnote_Temp_750" id="footnote_Temp_750"><sup><small>10</small></sup></a> This is just like writing a number as a sequence of
+</p><p><a href="#call_footnote_Temp_750" id="footnote_Temp_750"><sup><small>10</small></sup></a> This is just like writing a number as a sequence of
 digits, except that each “digit” is a number between 0 and the
 largest number that can be stored in a single pointer.
 
-</p><p><a name="footnote_Temp_752" href="#call_footnote_Temp_752" id="footnote_Temp_752"><sup><small>11</small></sup></a> There are other ways
+</p><p><a href="#call_footnote_Temp_752" id="footnote_Temp_752"><sup><small>11</small></sup></a> There are other ways
 of finding free storage.  For example, we could link together all the
-unused pairs into a <a name="%_idx_5908" id="%_idx_5908"></a><em>free list</em>.  Our free locations are
+unused pairs into a <a id="__idx_5908"></a><em>free list</em>.  Our free locations are
 consecutive (and hence can be accessed by incrementing a pointer)
 because we are using a compacting garbage collector, as we will see in
-section <a href="#%_sec_5.3.2">5.3.2</a>.
+section <a href="#__sec_5.3.2">5.3.2</a>.
 
-</p><p><a name="footnote_Temp_753" href="#call_footnote_Temp_753" id="footnote_Temp_753"><sup><small>12</small></sup></a> This is essentially the implementation of <tt>cons</tt> in terms of <tt>set-car!</tt> and <tt>set-cdr!</tt>, as described in
-section <a href="book-Z-H-22.html#%_sec_3.3.1">3.3.1</a>.  The operation <tt>get-new-pair</tt> used in that implementation is realized here by the <tt>free</tt> pointer.
+</p><p><a href="#call_footnote_Temp_753" id="footnote_Temp_753"><sup><small>12</small></sup></a> This is essentially the implementation of <tt>cons</tt> in terms of <tt>set-car!</tt> and <tt>set-cdr!</tt>, as described in
+section <a href="book-Z-H-22.html#__sec_3.3.1">3.3.1</a>.  The operation <tt>get-new-pair</tt> used in that implementation is realized here by the <tt>free</tt> pointer.
 
-</p><p><a name="footnote_Temp_758" href="#call_footnote_Temp_758" id="footnote_Temp_758"><sup><small>13</small></sup></a> This may not be true eventually,
+</p><p><a href="#call_footnote_Temp_758" id="footnote_Temp_758"><sup><small>13</small></sup></a> This may not be true eventually,
 because memories may get large enough so that it would be impossible
 to run out of free memory in the lifetime of the computer.  For
 example, there are about 3× 10<sup>13</sup>, microseconds in a year, so
@@ -590,33 +590,33 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 memory, so it may be possible to use up memory much faster than we
 have postulated.
 
-</p><p><a name="footnote_Temp_759" href="#call_footnote_Temp_759" id="footnote_Temp_759"><sup><small>14</small></sup></a> We
+</p><p><a href="#call_footnote_Temp_759" id="footnote_Temp_759"><sup><small>14</small></sup></a> We
 assume here that the stack is represented as a list as described in
-section <a href="#%_sec_5.3.1">5.3.1</a>, so that items on the stack are
+section <a href="#__sec_5.3.1">5.3.1</a>, so that items on the stack are
 accessible via the pointer in the stack register.
 
-</p><p><a name="footnote_Temp_760" href="#call_footnote_Temp_760" id="footnote_Temp_760"><sup><small>15</small></sup></a> This idea was invented and first implemented
-<a name="%_idx_5936" id="%_idx_5936"></a>by Minsky, as part of the implementation of <a name="%_idx_5938" id="%_idx_5938"></a>Lisp for the PDP-1 at the
-<a name="%_idx_5940" id="%_idx_5940"></a>MIT Research Laboratory of Electronics.  It was further developed by
-<a name="%_idx_5942" id="%_idx_5942"></a><a name="%_idx_5944" id="%_idx_5944"></a>Fenichel and Yochelson (1969) for use in the Lisp implementation for
-<a name="%_idx_5946" id="%_idx_5946"></a>the Multics time-sharing system.  Later, <a name="%_idx_5948" id="%_idx_5948"></a>Baker (1978) developed a
+</p><p><a href="#call_footnote_Temp_760" id="footnote_Temp_760"><sup><small>15</small></sup></a> This idea was invented and first implemented
+<a id="__idx_5936"></a>by Minsky, as part of the implementation of <a id="__idx_5938"></a>Lisp for the PDP-1 at the
+<a id="__idx_5940"></a>MIT Research Laboratory of Electronics.  It was further developed by
+<a id="__idx_5942"></a><a id="__idx_5944"></a>Fenichel and Yochelson (1969) for use in the Lisp implementation for
+<a id="__idx_5946"></a>the Multics time-sharing system.  Later, <a id="__idx_5948"></a>Baker (1978) developed a
 “real-time” version of the method, which does not require the
 computation to stop during garbage collection.  Baker's idea was
-extended by <a name="%_idx_5950" id="%_idx_5950"></a><a name="%_idx_5952" id="%_idx_5952"></a><a name="%_idx_5954" id="%_idx_5954"></a>Hewitt, Lieberman, and Moon (see Lieberman and Hewitt
+extended by <a id="__idx_5950"></a><a id="__idx_5952"></a><a id="__idx_5954"></a>Hewitt, Lieberman, and Moon (see Lieberman and Hewitt
 1983) to take advantage of the fact that some structure is more volatile
 and other structure is more permanent.  </p><p>
 
-An alternative commonly used garbage-collection technique is the <a name="%_idx_5956" id="%_idx_5956"></a><a name="%_idx_5958" id="%_idx_5958"></a><em>mark-sweep</em> method.  This consists of tracing all the structure
+An alternative commonly used garbage-collection technique is the <a id="__idx_5956"></a><a id="__idx_5958"></a><em>mark-sweep</em> method.  This consists of tracing all the structure
 accessible from the machine registers and marking each pair we reach.
 We then scan all of memory, and any location that is unmarked is
 “swept up” as garbage and made available for reuse.  A full
-<a name="%_idx_5960" id="%_idx_5960"></a>discussion of the mark-sweep method can be found in Allen 1978.</p><p>
+<a id="__idx_5960"></a>discussion of the mark-sweep method can be found in Allen 1978.</p><p>
 
 The Minsky-Fenichel-Yochelson algorithm is the dominant algorithm in
 use for large-memory systems because it examines only the useful part
 of memory.  This is in contrast to mark-sweep, in which the sweep
 phase must check all of memory.  A second advantage of stop-and-copy
-is that it is a <a name="%_idx_5962" id="%_idx_5962"></a><a name="%_idx_5964" id="%_idx_5964"></a><em>compacting</em> garbage collector.  That is, at the
+is that it is a <a id="__idx_5962"></a><a id="__idx_5964"></a><em>compacting</em> garbage collector.  That is, at the
 end of the garbage-collection phase the useful data will have been
 moved to consecutive memory locations, with all garbage pairs
 compressed out.  This can be an extremely important performance
@@ -624,15 +624,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.3">5.3  Storage Allocation and Garb
 widely separated memory addresses may require extra paging
 operations.
 
-</p><p><a name="footnote_Temp_762" href="#call_footnote_Temp_762" id="footnote_Temp_762"><sup><small>16</small></sup></a> This list of registers does not include
+</p><p><a href="#call_footnote_Temp_762" id="footnote_Temp_762"><sup><small>16</small></sup></a> This list of registers does not include
 the registers used by the storage-allocation system – <tt>root</tt>, <tt>the-cars</tt>, <tt>the-cdrs</tt>, and the other registers that will be
 introduced in this section.
 
-</p><p><a name="footnote_Temp_763" href="#call_footnote_Temp_763" id="footnote_Temp_763"><sup><small>17</small></sup></a> The term <em><a name="%_idx_5982" id="%_idx_5982"></a>broken heart</em> was coined by David Cressey, who wrote a garbage
-collector for <a name="%_idx_5984" id="%_idx_5984"></a><a name="%_idx_5986" id="%_idx_5986"></a>MDL, a dialect of Lisp developed at MIT during the early
+</p><p><a href="#call_footnote_Temp_763" id="footnote_Temp_763"><sup><small>17</small></sup></a> The term <em><a id="__idx_5982"></a>broken heart</em> was coined by David Cressey, who wrote a garbage
+collector for <a id="__idx_5984"></a><a id="__idx_5986"></a>MDL, a dialect of Lisp developed at MIT during the early
 1970s.
 
-</p><p><a name="footnote_Temp_764" href="#call_footnote_Temp_764" id="footnote_Temp_764"><sup><small>18</small></sup></a> The garbage collector uses the low-level predicate
+</p><p><a href="#call_footnote_Temp_764" id="footnote_Temp_764"><sup><small>18</small></sup></a> The garbage collector uses the low-level predicate
 <tt>pointer-to-pair?</tt> instead of the list-structure <tt>pair?</tt>
 operation because in a real system there might be various things
 that are treated as pairs for garbage-collection purposes.
diff --git a/src/OEBPS/book-Z-H-34.html b/src/OEBPS/book-Z-H-34.html
index a2e8d1a..f6db6b9 100644
--- a/src/OEBPS/book-Z-H-34.html
+++ b/src/OEBPS/book-Z-H-34.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,16 +13,16 @@
 
 
 
-<a name="%_sec_5.4" id="%_sec_5.4"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evaluator</a></h2><p>
+<a id="__sec_5.4"></a>
+<h2>5.4  The Explicit-Control Evaluator</h2><p>
 
 
-<a name="%_idx_5996" id="%_idx_5996"></a>
-In section <a href="book-Z-H-31.html#%_sec_5.1">5.1</a> we saw how to
+<a id="__idx_5996"></a>
+In section <a href="book-Z-H-31.html#__sec_5.1">5.1</a> we saw how to
 transform simple Scheme programs into descriptions of register
 machines.  We will now perform this transformation on a more complex
 program, the metacircular evaluator of
-sections <a href="book-Z-H-26.html#%_sec_4.1.1">4.1.1</a>-<a href="book-Z-H-26.html#%_sec_4.1.4">4.1.4</a>,
+sections <a href="book-Z-H-26.html#__sec_4.1.1">4.1.1</a>-<a href="book-Z-H-26.html#__sec_4.1.4">4.1.4</a>,
 which shows how
 the behavior of a Scheme interpreter can be described in terms of the
 procedures <tt>eval</tt> and <tt>apply</tt>.
@@ -34,24 +34,24 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 serve as an implementation of a Scheme interpreter, written in a
 language that is very similar to the native machine language of
 conventional computers.  The evaluator can be executed by the
-register-machine simulator of section <a href="book-Z-H-32.html#%_sec_5.2">5.2</a>.
+register-machine simulator of section <a href="book-Z-H-32.html#__sec_5.2">5.2</a>.
 Alternatively, it can be used as a starting point for building a
 machine-language implementation of a Scheme evaluator, or even a
-<a name="%_idx_5998" id="%_idx_5998"></a><a name="%_idx_6000" id="%_idx_6000"></a><a name="%_idx_6002" id="%_idx_6002"></a>special-purpose machine for evaluating Scheme expressions.
-Figure <a href="#%_fig_5.16">5.16</a> shows such a hardware implementation: a
+<a id="__idx_5998"></a><a id="__idx_6000"></a><a id="__idx_6002"></a>special-purpose machine for evaluating Scheme expressions.
+Figure <a href="#__fig_5.16">5.16</a> shows such a hardware implementation: a
 silicon chip that acts as an evaluator for Scheme.  The chip designers
 started with the data-path and controller specifications for a
 register machine similar to the evaluator described in this section
 and used design automation programs to construct the
-integrated-circuit layout.<a name="call_footnote_Temp_765" href="#footnote_Temp_765" id="call_footnote_Temp_765"><sup><small>19</small></sup></a></p><p>
+integrated-circuit layout.<a href="#footnote_Temp_765" id="call_footnote_Temp_765"><sup><small>19</small></sup></a></p><p>
 
 </p><p>
 
-<a name="%_sec_Temp_766" id="%_sec_Temp_766"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_766">Registers and operations</a></h4><p>
+<a id="__sec_Temp_766"></a>
+</p><h4>Registers and operations</h4><p>
 
-<a name="%_idx_6006" id="%_idx_6006"></a>
-<a name="%_idx_6008" id="%_idx_6008"></a>In designing the explicit-control evaluator, we must specify the
+<a id="__idx_6006"></a>
+<a id="__idx_6008"></a>In designing the explicit-control evaluator, we must specify the
 operations to be used in our register machine.  We described the
 metacircular evaluator in terms of abstract syntax, using procedures
 such as <tt>quoted?</tt> and <tt>make-procedure</tt>.  In implementing the
@@ -61,21 +61,21 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 evaluator very long, obscuring the basic structure with
 details.  To clarify the presentation, we will include as primitive
 operations of the register machine the syntax procedures given in
-section <a href="book-Z-H-26.html#%_sec_4.1.2">4.1.2</a> and the procedures for
+section <a href="book-Z-H-26.html#__sec_4.1.2">4.1.2</a> and the procedures for
 representing environments and other run-time data given in
-sections <a href="book-Z-H-26.html#%_sec_4.1.3">4.1.3</a> and <a href="book-Z-H-26.html#%_sec_4.1.4">4.1.4</a>.
+sections <a href="book-Z-H-26.html#__sec_4.1.3">4.1.3</a> and <a href="book-Z-H-26.html#__sec_4.1.4">4.1.4</a>.
 In order to completely specify an evaluator that could be programmed
 in a low-level machine language or implemented in hardware, we would
 replace these operations by more elementary operations, using the
 list-structure implementation we described in
-section <a href="book-Z-H-33.html#%_sec_5.3">5.3</a>.</p><p>
+section <a href="book-Z-H-33.html#__sec_5.3">5.3</a>.</p><p>
 
-<a name="%_fig_5.16" id="%_fig_5.16"></a></p><p></p><div align="left"><table width="100%"><tr><td><img src="images/chip.jpg" border="0" height="310" /></td></tr><caption align="bottom"><div align="left"><b>Figure 5.16:</b>  A silicon-chip implementation of an evaluator for
+<a id="__fig_5.16"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><img src="images/chip.jpg" alt="chip" style="border: none;" height="310" /></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.16:</b>  A silicon-chip implementation of an evaluator for
 Scheme.</div></caption><tr><td>
-<a name="%_idx_6010" id="%_idx_6010"></a><a name="%_idx_6012" id="%_idx_6012"></a><a name="%_idx_6014" id="%_idx_6014"></a>
+<a id="__idx_6010"></a><a id="__idx_6012"></a><a id="__idx_6014"></a>
 </td></tr></table></div><p></p><p>
 
-<a name="%_idx_6016" id="%_idx_6016"></a><a name="%_idx_6018" id="%_idx_6018"></a><a name="%_idx_6020" id="%_idx_6020"></a><a name="%_idx_6022" id="%_idx_6022"></a><a name="%_idx_6024" id="%_idx_6024"></a><a name="%_idx_6026" id="%_idx_6026"></a><a name="%_idx_6028" id="%_idx_6028"></a><a name="%_idx_6030" id="%_idx_6030"></a>Our Scheme evaluator register machine includes a stack and seven
+<a id="__idx_6016"></a><a id="__idx_6018"></a><a id="__idx_6020"></a><a id="__idx_6022"></a><a id="__idx_6024"></a><a id="__idx_6026"></a><a id="__idx_6028"></a><a id="__idx_6030"></a>Our Scheme evaluator register machine includes a stack and seven
 registers: <tt>exp</tt>, <tt>env</tt>, <tt>val</tt>, <tt>continue</tt>, <tt>proc</tt>,
 <tt>argl</tt>, and <tt>unev</tt>.  <tt>Exp</tt> is used to hold the expression
 to be evaluated, and <tt>env</tt> contains the environment in which the
@@ -83,7 +83,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 contains the value obtained by evaluating the expression in the
 designated environment.  The <tt>continue</tt> register is used to
 implement recursion, as explained in
-section <a href="book-Z-H-31.html#%_sec_5.1.4">5.1.4</a>.  (The evaluator needs to call
+section <a href="book-Z-H-31.html#__sec_5.1.4">5.1.4</a>.  (The evaluator needs to call
 itself recursively, since evaluating an expression requires evaluating
 its subexpressions.)  The registers <tt>proc</tt>, <tt>argl</tt>, and <tt>unev</tt> are used in evaluating combinations.</p><p>
 
@@ -93,23 +93,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 complete list of machine operations.  These are implicit in the
 evaluator's controller, which will be presented in detail.</p><p>
 
-<a name="%_sec_5.4.1" id="%_sec_5.4.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.4.1">5.4.1  The Core of the Explicit-Control Evaluator</a></h3><p>
+<a id="__sec_5.4.1"></a>
+</p><h3>5.4.1  The Core of the Explicit-Control Evaluator</h3><p>
 
 
-<a name="%_idx_6032" id="%_idx_6032"></a>
+<a id="__idx_6032"></a>
 The central element in the evaluator is the sequence of instructions
 beginning at <tt>eval-dispatch</tt>.  This corresponds to the <tt>eval</tt>
 procedure of the metacircular evaluator described in
-section <a href="book-Z-H-26.html#%_sec_4.1.1">4.1.1</a>.  When the controller starts at <tt>eval-dispatch</tt>, it evaluates the expression specified by <tt>exp</tt> in
+section <a href="book-Z-H-26.html#__sec_4.1.1">4.1.1</a>.  When the controller starts at <tt>eval-dispatch</tt>, it evaluates the expression specified by <tt>exp</tt> in
 the environment specified by <tt>env</tt>.  When evaluation is complete,
 the controller will go to the entry point stored in <tt>continue</tt>, and the
 <tt>val</tt> register will hold the value of the expression.  As with the
 metacircular <tt>eval</tt>, the structure of <tt>eval-dispatch</tt> is a
 case analysis on the syntactic type of the expression to be
-evaluated.<a name="call_footnote_Temp_767" href="#footnote_Temp_767" id="call_footnote_Temp_767"><sup><small>20</small></sup></a></p><p>
+evaluated.<a href="#footnote_Temp_767" id="call_footnote_Temp_767"><sup><small>20</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_6034" id="%_idx_6034"></a>eval-dispatch<br />
+</p><p></p><p><tt><a id="__idx_6034"></a>eval-dispatch<br />
   (test (op self-evaluating?) (reg exp))<br />
   (branch (label ev-self-eval))<br />
   (test (op variable?) (reg exp))<br />
@@ -130,10 +130,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
   (branch (label ev-application))<br />
   (goto (label unknown-expression-type))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_768" id="%_sec_Temp_768"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_768">Evaluating simple expressions</a></h4><p>
+<a id="__sec_Temp_768"></a>
+</p><h4>Evaluating simple expressions</h4><p>
 
-<a name="%_idx_6036" id="%_idx_6036"></a>
+<a id="__idx_6036"></a>
 Numbers and strings (which are self-evaluating),
 variables, quotations, and <tt>lambda</tt> expressions have no
 subexpressions to be evaluated.  For these, the evaluator simply
@@ -141,13 +141,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 execution at the entry point specified by <tt>continue</tt>.  Evaluation
 of simple expressions is performed by the following controller code:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6038" id="%_idx_6038"></a>ev-self-eval<br />
+</p><p></p><p><tt><a id="__idx_6038"></a>ev-self-eval<br />
   (assign val (reg exp))<br />
-  (goto (reg continue))<br /><a name="%_idx_6040" id="%_idx_6040"></a>ev-variable<br />
+  (goto (reg continue))<br /><a id="__idx_6040"></a>ev-variable<br />
   (assign val (op lookup-variable-value) (reg exp) (reg env))<br />
-  (goto (reg continue))<br /><a name="%_idx_6042" id="%_idx_6042"></a>ev-quoted<br />
+  (goto (reg continue))<br /><a id="__idx_6042"></a>ev-quoted<br />
   (assign val (op text-of-quotation) (reg exp))<br />
-  (goto (reg continue))<br /><a name="%_idx_6044" id="%_idx_6044"></a>ev-lambda<br />
+  (goto (reg continue))<br /><a id="__idx_6044"></a>ev-lambda<br />
   (assign unev (op lambda-parameters) (reg exp))<br />
   (assign exp (op lambda-body) (reg exp))<br />
   (assign val (op make-procedure)<br />
@@ -158,10 +158,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 that they can be passed to the <tt>make-procedure</tt> operation, along
 with the environment in <tt>env</tt>.</p><p>
 
-<a name="%_sec_Temp_769" id="%_sec_Temp_769"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_769">Evaluating procedure applications</a></h4><p>
+<a id="__sec_Temp_769"></a>
+</p><h4>Evaluating procedure applications</h4><p>
 
-<a name="%_idx_6046" id="%_idx_6046"></a><a name="%_idx_6048" id="%_idx_6048"></a>
+<a id="__idx_6046"></a><a id="__idx_6048"></a>
 A procedure application is specified by a combination containing an
 operator and operands.  The operator is a subexpression whose value is
 a procedure, and the operands are subexpressions whose values are the
@@ -170,11 +170,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 evaluate each element of the combination, and then passing the results
 to <tt>apply</tt>, which performs the actual procedure application.  The
 explicit-control evaluator does the same thing; these recursive calls
-are implemented by <tt>goto</tt> instructions, together with <a name="%_idx_6050" id="%_idx_6050"></a>use of the
+are implemented by <tt>goto</tt> instructions, together with <a id="__idx_6050"></a>use of the
 stack to save registers that will be restored after the recursive call
 returns.  Before each call we will be careful to identify which
 registers must be saved (because their values will be needed
-later).<a name="call_footnote_Temp_770" href="#footnote_Temp_770" id="call_footnote_Temp_770"><sup><small>21</small></sup></a></p><p>
+later).<a href="#footnote_Temp_770" id="call_footnote_Temp_770"><sup><small>21</small></sup></a></p><p>
 
 We begin the evaluation of an application by evaluating the operator
 to produce a procedure, which will later be applied to the evaluated
@@ -187,7 +187,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 <tt>continue</tt>, which tells the controller where to continue after the
 application.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6056" id="%_idx_6056"></a>ev-application<br />
+</p><p></p><p><tt><a id="__idx_6056"></a>ev-application<br />
   (save continue)<br />
   (save env)<br />
   (assign unev (op operands) (reg exp))<br />
@@ -196,14 +196,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
   (assign continue (label ev-appl-did-operator))<br />
   (goto (label eval-dispatch))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_6058" id="%_idx_6058"></a>Upon returning from evaluating the operator subexpression, we proceed
+<a id="__idx_6058"></a>Upon returning from evaluating the operator subexpression, we proceed
 to evaluate the operands of the combination and to accumulate the
 resulting arguments in a list, held in <tt>argl</tt>.  First we restore
 the unevaluated operands and the environment.  We initialize <tt>argl</tt> to an empty list.  Then we assign to the <tt>proc</tt> register the
 procedure that was produced by evaluating the operator.  If there are
 no operands, we go directly to <tt>apply-dispatch</tt>.  Otherwise we
 save <tt>proc</tt> on the stack and start the argument-evaluation
-loop:<a name="call_footnote_Temp_771" href="#footnote_Temp_771" id="call_footnote_Temp_771"><sup><small>22</small></sup></a></p><p>
+loop:<a href="#footnote_Temp_771" id="call_footnote_Temp_771"><sup><small>22</small></sup></a></p><p>
 
 </p><p></p><p><tt>ev-appl-did-operator<br />
   (restore unev)                  <em>; the operands</em><br />
@@ -252,7 +252,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 since they will not be required after the last operand is evaluated.
 Thus, we return from the evaluation to a special entry point <tt>ev-appl-accum-last-arg</tt>, which restores the argument list, accumulates
 the new argument, restores the saved procedure, and goes off to
-perform the application.<a name="call_footnote_Temp_772" href="#footnote_Temp_772" id="call_footnote_Temp_772"><sup><small>23</small></sup></a></p><p>
+perform the application.<a href="#footnote_Temp_772" id="call_footnote_Temp_772"><sup><small>23</small></sup></a></p><p>
 
 </p><p></p><p><tt>ev-appl-last-arg<br />
   (assign continue (label ev-appl-accum-last-arg))<br />
@@ -263,19 +263,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
   (restore proc)<br />
   (goto (label apply-dispatch))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_6070" id="%_idx_6070"></a>The details of the argument-evaluation loop determine the order in
+<a id="__idx_6070"></a>The details of the argument-evaluation loop determine the order in
 which the interpreter evaluates the operands of a combination (e.g.,
 left to right or right to left – see
-exercise <a href="book-Z-H-20.html#%_thm_3.8">3.8</a>).  This order is not determined
+exercise <a href="book-Z-H-20.html#__thm_3.8">3.8</a>).  This order is not determined
 by the metacircular evaluator, which inherits its control structure
-from the underlying Scheme in which it is implemented.<a name="call_footnote_Temp_773" href="#footnote_Temp_773" id="call_footnote_Temp_773"><sup><small>24</small></sup></a> Because the <tt>first-operand</tt>
+from the underlying Scheme in which it is implemented.<a href="#footnote_Temp_773" id="call_footnote_Temp_773"><sup><small>24</small></sup></a> Because the <tt>first-operand</tt>
 selector (used in <tt>ev-appl-operand-loop</tt> to extract successive operands
 from <tt>unev</tt>) is implemented as <tt>car</tt> and the <tt>rest-operands</tt> selector is implemented as <tt>cdr</tt>, the
 explicit-control evaluator will evaluate the operands of a combination
 in left-to-right order.</p><p>
 
-<a name="%_sec_Temp_774" id="%_sec_Temp_774"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_774">Procedure application</a></h4><p>
+<a id="__sec_Temp_774"></a>
+</p><h4>Procedure application</h4><p>
 
 </p><p>
 
@@ -291,14 +291,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 the procedure to be applied is a primitive or it is a compound
 procedure.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6072" id="%_idx_6072"></a>apply-dispatch<br />
+</p><p></p><p><tt><a id="__idx_6072"></a>apply-dispatch<br />
   (test (op primitive-procedure?) (reg proc))<br />
   (branch (label primitive-apply))<br />
   (test (op compound-procedure?) (reg proc))  <br />
   (branch (label compound-apply))<br />
   (goto (label unknown-procedure-type))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_6074" id="%_idx_6074"></a>We assume that each primitive is implemented so as to obtain its
+<a id="__idx_6074"></a>We assume that each primitive is implemented so as to obtain its
 arguments from <tt>argl</tt> and place its result in <tt>val</tt>.  To
 specify how the machine handles primitives, we would have to provide a
 sequence of controller instructions to implement each primitive and
@@ -308,29 +308,29 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 the evaluation process rather than the details of the primitives, we
 will instead just use an <tt>apply-primitive-procedure</tt> operation
 that applies the procedure in <tt>proc</tt> to the arguments in <tt>argl</tt>.  For the purpose of simulating the evaluator with the simulator
-of section <a href="book-Z-H-32.html#%_sec_5.2">5.2</a> we use the procedure <tt>apply-primitive-procedure</tt>, which calls on the underlying Scheme
+of section <a href="book-Z-H-32.html#__sec_5.2">5.2</a> we use the procedure <tt>apply-primitive-procedure</tt>, which calls on the underlying Scheme
 system to perform the application, just as we did for the metacircular
-evaluator in section <a href="book-Z-H-26.html#%_sec_4.1.4">4.1.4</a>.  After computing the
+evaluator in section <a href="book-Z-H-26.html#__sec_4.1.4">4.1.4</a>.  After computing the
 value of the primitive application, we restore <tt>continue</tt> and go
 to the designated entry point.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6076" id="%_idx_6076"></a>primitive-apply<br />
+</p><p></p><p><tt><a id="__idx_6076"></a>primitive-apply<br />
   (assign val (op apply-primitive-procedure)<br />
               (reg proc)<br />
               (reg argl))<br />
   (restore continue)<br />
   (goto (reg continue))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_6078" id="%_idx_6078"></a>To apply a compound procedure, we proceed just as with the
+<a id="__idx_6078"></a>To apply a compound procedure, we proceed just as with the
 metacircular evaluator.  We construct a frame that binds the
 procedure's parameters to the arguments, use this frame to
 extend the environment carried by the procedure, and evaluate in this
 extended environment the sequence of expressions that forms the body
 of the procedure.  <tt>Ev-sequence</tt>, described below in
-section <a href="#%_sec_5.4.2">5.4.2</a>, handles the evaluation
+section <a href="#__sec_5.4.2">5.4.2</a>, handles the evaluation
 of the sequence.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6080" id="%_idx_6080"></a>compound-apply<br />
+</p><p></p><p><tt><a id="__idx_6080"></a>compound-apply<br />
   (assign unev (op procedure-parameters) (reg proc))<br />
   (assign env (op procedure-environment) (reg proc))<br />
   (assign env (op extend-environment)<br />
@@ -344,11 +344,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 environment carried by the procedure, together with the argument list
 and the corresponding list of variables to be bound.</p><p>
 
-<a name="%_sec_5.4.2" id="%_sec_5.4.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.4.2">5.4.2  Sequence Evaluation and Tail Recursion</a></h3><p>
+<a id="__sec_5.4.2"></a>
+</p><h3>5.4.2  Sequence Evaluation and Tail Recursion</h3><p>
 
 
-<a name="%_idx_6082" id="%_idx_6082"></a>
+<a id="__idx_6082"></a>
 The portion of the explicit-control evaluator at <tt>ev-sequence</tt> is
 analogous to the metacircular evaluator's <tt>eval-sequence</tt> procedure.  It
 handles sequences of expressions in procedure bodies or in explicit
@@ -357,7 +357,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 Explicit <tt>begin</tt> expressions are evaluated by placing the sequence
 of expressions to be evaluated in <tt>unev</tt>, saving <tt>continue</tt> on the
 stack, and jumping to <tt>ev-sequence</tt>.
-</p><p></p><p><tt><a name="%_idx_6084" id="%_idx_6084"></a>ev-begin<br />
+</p><p></p><p><tt><a id="__idx_6084"></a>ev-begin<br />
   (assign unev (op begin-actions) (reg exp))<br />
   (save continue)<br />
   (goto (label ev-sequence))<br /></tt></p><p></p><p>
@@ -388,7 +388,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 the stack before going to <tt>eval-dispatch</tt>, so that <tt>eval-dispatch</tt> will continue at that entry point after evaluating the
 expression.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6086" id="%_idx_6086"></a>ev-sequence<br />
+</p><p></p><p><tt><a id="__idx_6086"></a>ev-sequence<br />
   (assign exp (op first-exp) (reg unev))<br />
   (test (op last-exp?) (reg unev))<br />
   (branch (label ev-sequence-last-exp))<br />
@@ -405,10 +405,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
   (restore continue)<br />
   (goto (label eval-dispatch))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_775" id="%_sec_Temp_775"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_775">Tail recursion</a></h4><p>
+<a id="__sec_Temp_775"></a>
+</p><h4>Tail recursion</h4><p>
 
-<a name="%_idx_6088" id="%_idx_6088"></a><a name="%_idx_6090" id="%_idx_6090"></a>
+<a id="__idx_6088"></a><a id="__idx_6090"></a>
 In chapter 1 we said that the process described by a procedure such as</p><p>
 
 </p><p></p><p><tt>(define (sqrt-iter guess x)<br />
@@ -418,10 +418,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
                  x)))<br /></tt></p><p></p><p>
 is an iterative process.  Even though the procedure is syntactically
 recursive (defined in terms of itself), it is not logically necessary
-for an evaluator to save information in passing from one call to <tt>sqrt-iter</tt> to the next.<a name="call_footnote_Temp_776" href="#footnote_Temp_776" id="call_footnote_Temp_776"><sup><small>25</small></sup></a> An evaluator that can
+for an evaluator to save information in passing from one call to <tt>sqrt-iter</tt> to the next.<a href="#footnote_Temp_776" id="call_footnote_Temp_776"><sup><small>25</small></sup></a> An evaluator that can
 execute a procedure such as <tt>sqrt-iter</tt> without requiring
 increasing storage as the procedure continues to call itself is called
-a <a name="%_idx_6092" id="%_idx_6092"></a><em>tail-recursive</em> evaluator.  <a name="%_idx_6094" id="%_idx_6094"></a><a name="%_idx_6096" id="%_idx_6096"></a>The metacircular implementation of
+a <a id="__idx_6092"></a><em>tail-recursive</em> evaluator.  <a id="__idx_6094"></a><a id="__idx_6096"></a>The metacircular implementation of
 the evaluator in chapter 4 does not specify whether the evaluator is
 tail-recursive, because that evaluator inherits its mechanism for
 saving state from the underlying Scheme.  With the explicit-control
@@ -436,16 +436,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 in a sequence – even if it is a procedure call (as in <tt>sqrt-iter</tt>, where
 the <tt>if</tt> expression, which is the last expression in the procedure body,
 reduces to a call to <tt>sqrt-iter</tt>) – will not cause any information to be
-accumulated on the stack.<a name="call_footnote_Temp_777" href="#footnote_Temp_777" id="call_footnote_Temp_777"><sup><small>26</small></sup></a></p><p>
+accumulated on the stack.<a href="#footnote_Temp_777" id="call_footnote_Temp_777"><sup><small>26</small></sup></a></p><p>
 
 If we did not think to take advantage of the fact that it was
 unnecessary to save information in this case, we might have
 implemented <tt>eval-sequence</tt> by treating all the expressions in a
 sequence in the same way – saving the registers, evaluating the expression,
 returning to restore the registers, and repeating this until all the
-expressions have been evaluated:<a name="call_footnote_Temp_778" href="#footnote_Temp_778" id="call_footnote_Temp_778"><sup><small>27</small></sup></a></p><p>
+expressions have been evaluated:<a href="#footnote_Temp_778" id="call_footnote_Temp_778"><sup><small>27</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_6100" id="%_idx_6100"></a>ev-sequence<br />
+</p><p></p><p><tt><a id="__idx_6100"></a>ev-sequence<br />
   (test (op no-more-exps?) (reg unev))<br />
   (branch (label ev-sequence-end))<br />
   (assign exp (op first-exp) (reg unev))<br />
@@ -475,7 +475,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 calls.  Consequently, processes such as <tt>sqrt-iter</tt> will require
 space proportional to the number of iterations rather than requiring
 constant space.  This difference can be significant.  For example,
-<a name="%_idx_6102" id="%_idx_6102"></a>with tail recursion, an infinite loop can be expressed using only the
+<a id="__idx_6102"></a>with tail recursion, an infinite loop can be expressed using only the
 procedure-call mechanism:</p><p>
 
 </p><p></p><p><tt>(define (count n)<br />
@@ -486,10 +486,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 stack space, and expressing a true iteration would require some
 control mechanism other than procedure call.</p><p>
 
-<a name="%_sec_5.4.3" id="%_sec_5.4.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.4.3">5.4.3  Conditionals, Assignments, and Definitions</a></h3><p>
+<a id="__sec_5.4.3"></a>
+</p><h3>5.4.3  Conditionals, Assignments, and Definitions</h3><p>
 
-<a name="%_idx_6104" id="%_idx_6104"></a>As with the metacircular evaluator, special forms are handled by
+<a id="__idx_6104"></a>As with the metacircular evaluator, special forms are handled by
 selectively evaluating fragments of the expression.  For an <tt>if</tt>
 expression, we must evaluate the predicate and decide, based on the
 value of predicate, whether to evaluate the consequent or the
@@ -502,7 +502,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 evaluation of the expression that is waiting for the value of the <tt>if</tt>.</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_6106" id="%_idx_6106"></a>ev-if<br />
+</p><p></p><p><tt><a id="__idx_6106"></a>ev-if<br />
   (save exp)                    <em>; save expression for later</em><br />
   (save env)<br />
   (save continue)<br />
@@ -532,16 +532,16 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
   (assign exp (op if-consequent) (reg exp))<br />
   (goto (label eval-dispatch))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_779" id="%_sec_Temp_779"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_779">Assignments and definitions</a></h4><p>
+<a id="__sec_Temp_779"></a>
+</p><h4>Assignments and definitions</h4><p>
 
-<a name="%_idx_6108" id="%_idx_6108"></a>Assignments are handled by <tt>ev-assignment</tt>, which is reached from
+<a id="__idx_6108"></a>Assignments are handled by <tt>ev-assignment</tt>, which is reached from
 <tt>eval-dispatch</tt> with the assignment expression in <tt>exp</tt>.  The code at <tt>ev-assignment</tt> first evaluates the value part of the expression and
 then installs the new value in the environment.  <tt>Set-variable-value!</tt> is assumed to be available as a machine
 operation.</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_6110" id="%_idx_6110"></a>ev-assignment<br />
+</p><p></p><p><tt><a id="__idx_6110"></a>ev-assignment<br />
   (assign unev (op assignment-variable) (reg exp))<br />
   (save unev)                   <em>; save variable for later</em><br />
   (assign exp (op assignment-value) (reg exp))<br />
@@ -559,9 +559,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
   (goto (reg continue))<br /></tt></p><p></p><p></p><p>
 
 
-<a name="%_idx_6112" id="%_idx_6112"></a>Definitions are handled in a similar way:
+<a id="__idx_6112"></a>Definitions are handled in a similar way:
 
-</p><p></p><p><tt><a name="%_idx_6114" id="%_idx_6114"></a>ev-definition<br />
+</p><p></p><p><tt><a id="__idx_6114"></a>ev-definition<br />
   (assign unev (op definition-variable) (reg exp))<br />
   (save unev)                   <em>; save variable for later</em><br />
   (assign exp (op definition-value) (reg exp))<br />
@@ -579,17 +579,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
   (goto (reg continue))<br /></tt></p><p></p><p>
 </p><p>
 
-</p><p><a name="%_thm_5.23" id="%_thm_5.23"></a>
-<b>Exercise 5.23.</b>  <a name="%_idx_6116" id="%_idx_6116"></a><a name="%_idx_6118" id="%_idx_6118"></a><a name="%_idx_6120" id="%_idx_6120"></a>Extend the evaluator to handle derived expressions such as <tt>cond</tt>,
-<tt>let</tt>, and so on (section <a href="book-Z-H-26.html#%_sec_4.1.2">4.1.2</a>).
+</p><p><a id="__thm_5.23"></a>
+<b>Exercise 5.23.</b>  <a id="__idx_6116"></a><a id="__idx_6118"></a><a id="__idx_6120"></a>Extend the evaluator to handle derived expressions such as <tt>cond</tt>,
+<tt>let</tt>, and so on (section <a href="book-Z-H-26.html#__sec_4.1.2">4.1.2</a>).
 You may “cheat” and assume that the syntax
 transformers such as <tt>cond-&gt;if</tt> are available as machine
-operations.<a name="call_footnote_Temp_781" href="#footnote_Temp_781" id="call_footnote_Temp_781"><sup><small>28</small></sup></a>
+operations.<a href="#footnote_Temp_781" id="call_footnote_Temp_781"><sup><small>28</small></sup></a>
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.24" id="%_thm_5.24"></a>
-<b>Exercise 5.24.</b>  <a name="%_idx_6122" id="%_idx_6122"></a>Implement <tt>cond</tt> as a new basic special form without
+</p><p><a id="__thm_5.24"></a>
+<b>Exercise 5.24.</b>  <a id="__idx_6122"></a>Implement <tt>cond</tt> as a new basic special form without
 reducing it to <tt>if</tt>.  You will have to construct a loop that tests
 the predicates of successive <tt>cond</tt> clauses until you find one
 that is true, and then use <tt>ev-sequence</tt> to evaluate the actions
@@ -597,17 +597,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.25" id="%_thm_5.25"></a>
-<b>Exercise 5.25.</b>  <a name="%_idx_6124" id="%_idx_6124"></a><a name="%_idx_6126" id="%_idx_6126"></a>Modify the evaluator so that it uses normal-order evaluation,
-based on the lazy evaluator of section <a href="book-Z-H-27.html#%_sec_4.2">4.2</a>.
+</p><p><a id="__thm_5.25"></a>
+<b>Exercise 5.25.</b>  <a id="__idx_6124"></a><a id="__idx_6126"></a>Modify the evaluator so that it uses normal-order evaluation,
+based on the lazy evaluator of section <a href="book-Z-H-27.html#__sec_4.2">4.2</a>.
 </p><p></p><p>
 
-<a name="%_sec_5.4.4" id="%_sec_5.4.4"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.4.4">5.4.4  Running the Evaluator</a></h3><p>
+<a id="__sec_5.4.4"></a>
+</p><h3>5.4.4  Running the Evaluator</h3><p>
 
 
-<a name="%_idx_6128" id="%_idx_6128"></a>
-<a name="%_idx_6130" id="%_idx_6130"></a><a name="%_idx_6132" id="%_idx_6132"></a>With the implementation of the explicit-control evaluator we come to
+<a id="__idx_6128"></a>
+<a id="__idx_6130"></a><a id="__idx_6132"></a>With the implementation of the explicit-control evaluator we come to
 the end of a development, begun in chapter 1, in which we have
 explored successively more precise models of the evaluation process.
 We started with the relatively informal substitution model, then
@@ -625,47 +625,47 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 performance.</p><p>
 
 
-<a name="%_idx_6134" id="%_idx_6134"></a><a name="%_idx_6136" id="%_idx_6136"></a>We will install a driver loop in our evaluator machine.  This plays
+<a id="__idx_6134"></a><a id="__idx_6136"></a>We will install a driver loop in our evaluator machine.  This plays
 the role of the <tt>driver-loop</tt> procedure of
-section <a href="book-Z-H-26.html#%_sec_4.1.4">4.1.4</a>.  The evaluator will repeatedly print a
+section <a href="book-Z-H-26.html#__sec_4.1.4">4.1.4</a>.  The evaluator will repeatedly print a
 prompt, read an expression, evaluate the expression by going to <tt>eval-dispatch</tt>, and print the result.  The following instructions form
 the beginning of the explicit-control evaluator's controller
-sequence:<a name="call_footnote_Temp_784" href="#footnote_Temp_784" id="call_footnote_Temp_784"><sup><small>29</small></sup></a></p><p>
+sequence:<a href="#footnote_Temp_784" id="call_footnote_Temp_784"><sup><small>29</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_6142" id="%_idx_6142"></a><a name="%_idx_6144" id="%_idx_6144"></a>read-eval-print-loop<br />
+</p><p></p><p><tt><a id="__idx_6142"></a><a id="__idx_6144"></a>read-eval-print-loop<br />
   (perform (op initialize-stack))<br />
   (perform<br />
    (op prompt-for-input) (const ";;; EC-Eval input:"))<br />
   (assign exp (op read))<br />
   (assign env (op get-global-environment))<br />
   (assign continue (label print-result))<br />
-  (goto (label eval-dispatch))<br /><a name="%_idx_6146" id="%_idx_6146"></a>print-result<br />
+  (goto (label eval-dispatch))<br /><a id="__idx_6146"></a>print-result<br />
   (perform<br />
    (op announce-output) (const ";;; EC-Eval value:"))<br />
   (perform (op user-print) (reg val))<br />
   (goto (label read-eval-print-loop))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_6148" id="%_idx_6148"></a><a name="%_idx_6150" id="%_idx_6150"></a>When we encounter an error in a procedure (such as the “unknown
+<a id="__idx_6148"></a><a id="__idx_6150"></a>When we encounter an error in a procedure (such as the “unknown
 procedure type error” indicated at <tt>apply-dispatch</tt>), we print an
-error message and return to the driver loop.<a name="call_footnote_Temp_785" href="#footnote_Temp_785" id="call_footnote_Temp_785"><sup><small>30</small></sup></a></p><p>
+error message and return to the driver loop.<a href="#footnote_Temp_785" id="call_footnote_Temp_785"><sup><small>30</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_6152" id="%_idx_6152"></a>unknown-expression-type<br />
+</p><p></p><p><tt><a id="__idx_6152"></a>unknown-expression-type<br />
   (assign val (const unknown-expression-type-error))<br />
-  (goto (label signal-error))<br /><a name="%_idx_6154" id="%_idx_6154"></a>unknown-procedure-type<br />
+  (goto (label signal-error))<br /><a id="__idx_6154"></a>unknown-procedure-type<br />
   (restore continue)    <em>; clean up stack (from <tt>apply-dispatch</tt>)</em><br />
   (assign val (const unknown-procedure-type-error))<br />
-  (goto (label signal-error))<br /><a name="%_idx_6156" id="%_idx_6156"></a>signal-error<br />
+  (goto (label signal-error))<br /><a id="__idx_6156"></a>signal-error<br />
   (perform (op user-print) (reg val))<br />
   (goto (label read-eval-print-loop))<br /></tt></p><p></p><p></p><p>
 
 For the purposes of the simulation, we initialize the stack each time
 through the driver loop, since it might not be empty after an error
-(such as an undefined variable) interrupts an evaluation.<a name="call_footnote_Temp_786" href="#footnote_Temp_786" id="call_footnote_Temp_786"><sup><small>31</small></sup></a></p><p>
+(such as an undefined variable) interrupts an evaluation.<a href="#footnote_Temp_786" id="call_footnote_Temp_786"><sup><small>31</small></sup></a></p><p>
 
-<a name="%_idx_6158" id="%_idx_6158"></a>If we combine all the code fragments presented in sections
-<a href="#%_sec_5.4.1">5.4.1</a>-<a href="#%_sec_5.4.4">5.4.4</a>, we can create an
+<a id="__idx_6158"></a>If we combine all the code fragments presented in sections
+<a href="#__sec_5.4.1">5.4.1</a>-<a href="#__sec_5.4.4">5.4.4</a>, we can create an
 evaluator machine model that we can run using the register-machine simulator
-of section <a href="book-Z-H-32.html#%_sec_5.2">5.2</a>.</p><p>
+of section <a href="book-Z-H-32.html#__sec_5.2">5.2</a>.</p><p>
 
 </p><p></p><p><tt>(define eceval<br />
   (make-machine<br />
@@ -678,8 +678,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 We must define Scheme procedures to simulate the
 operations used as primitives by the evaluator.  These are
 the same procedures we used for the metacircular evaluator in
-section <a href="book-Z-H-26.html#%_sec_4.1">4.1</a>, together with the few additional ones
-defined in footnotes throughout section <a href="#%_sec_5.4">5.4</a>.
+section <a href="book-Z-H-26.html#__sec_4.1">4.1</a>, together with the few additional ones
+defined in footnotes throughout section <a href="#__sec_5.4">5.4</a>.
 </p><p></p><p><tt>(define eceval-operations<br />
   (list (list 'self-evaluating? self-evaluating)<br />
         <em>&lt;complete list of operations for eceval machine&gt;</em>))<br /></tt></p><p></p><p></p><p>
@@ -702,11 +702,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 a Scheme program, which is itself being evaluated by the Scheme
 interpreter.</p><p>
 
-<a name="%_sec_Temp_787" id="%_sec_Temp_787"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_787">Monitoring the performance of the evaluator</a></h4><p>
+<a id="__sec_Temp_787"></a>
+</p><h4>Monitoring the performance of the evaluator</h4><p>
 
-<a name="%_idx_6160" id="%_idx_6160"></a>
-<a name="%_idx_6162" id="%_idx_6162"></a>Simulation can be a powerful tool to guide the implementation of
+<a id="__idx_6160"></a>
+<a id="__idx_6162"></a>Simulation can be a powerful tool to guide the implementation of
 evaluators.  Simulations make it easy not only to explore variations
 of the register-machine design but also to monitor the performance of
 the simulated evaluator.  For example, one important factor in
@@ -714,11 +714,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 observe the number of stack operations required to evaluate various
 expressions by defining the evaluator register machine with the
 version of the simulator that collects statistics on stack use
-(section <a href="book-Z-H-32.html#%_sec_5.2.4">5.2.4</a>), and adding an instruction at the
+(section <a href="book-Z-H-32.html#__sec_5.2.4">5.2.4</a>), and adding an instruction at the
 evaluator's <tt>print-result</tt> entry point to print the
 statistics:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6164" id="%_idx_6164"></a>print-result<br />
+</p><p></p><p><tt><a id="__idx_6164"></a>print-result<br />
   (perform (op print-stack-statistics))<em>; added instruction</em><br />
   (perform<br />
    (op announce-output) (const ";;; EC-Eval value:"))<br />
@@ -735,11 +735,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 each interaction, so that the statistics printed will refer only to
 stack operations used to evaluate the previous expression.</p><p>
 
-</p><p><a name="%_thm_5.26" id="%_thm_5.26"></a>
-<b>Exercise 5.26.</b>  <a name="%_idx_6166" id="%_idx_6166"></a><a name="%_idx_6168" id="%_idx_6168"></a><a name="%_idx_6170" id="%_idx_6170"></a>Use the monitored stack to explore the tail-recursive property of the
-evaluator (section <a href="#%_sec_5.4.2">5.4.2</a>).  Start the
+</p><p><a id="__thm_5.26"></a>
+<b>Exercise 5.26.</b>  <a id="__idx_6166"></a><a id="__idx_6168"></a><a id="__idx_6170"></a>Use the monitored stack to explore the tail-recursive property of the
+evaluator (section <a href="#__sec_5.4.2">5.4.2</a>).  Start the
 evaluator and define the iterative <tt>factorial</tt> procedure from
-section <a href="book-Z-H-11.html#%_sec_1.2.1">1.2.1</a>:</p><p>
+section <a href="book-Z-H-11.html#__sec_1.2.1">1.2.1</a>:</p><p>
 
 </p><p></p><p><tt>(define (factorial n)<br />
   (define (iter product counter)<br />
@@ -761,8 +761,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 and is thus determined by two constants.
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.27" id="%_thm_5.27"></a>
-<b>Exercise 5.27.</b>  <a name="%_idx_6172" id="%_idx_6172"></a>For comparison with exercise <a href="#%_thm_5.26">5.26</a>, explore the
+</p><p><a id="__thm_5.27"></a>
+<b>Exercise 5.27.</b>  <a id="__idx_6172"></a>For comparison with exercise <a href="#__thm_5.26">5.26</a>, explore the
 behavior of the following procedure for computing factorials
 recursively:
 </p><p></p><p><tt>(define (factorial n)<br />
@@ -775,7 +775,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 will be linear.)  Summarize your experiments by filling in the
 following table with the appropriate expressions in terms of <em>n</em>:</p><p>
 
-</p><table border="1"><tr><td valign="top"></td><td valign="top">Maximum depth </td><td valign="top">Number of pushes</td></tr><tr><td valign="top">Recursive </td><td valign="top"></td><td valign="top"></td></tr><tr><td valign="top">factorial </td><td valign="top"></td><td valign="top"></td></tr><tr><td valign="top">Iterative </td><td valign="top"></td><td valign="top"></td></tr><tr><td valign="top">factorial </td><td valign="top"></td><td valign="top"></td></tr><tr><td valign="top"></td></tr></table><p>
+</p><table style="border: 1px solid;"><tr><td style="text-align: top;"></td><td style="text-align: top;">Maximum depth </td><td style="text-align: top;">Number of pushes</td></tr><tr><td style="text-align: top;">Recursive </td><td style="text-align: top;"></td><td style="text-align: top;"></td></tr><tr><td style="text-align: top;">factorial </td><td style="text-align: top;"></td><td style="text-align: top;"></td></tr><tr><td style="text-align: top;">Iterative </td><td style="text-align: top;"></td><td style="text-align: top;"></td></tr><tr><td style="text-align: top;">factorial </td><td style="text-align: top;"></td><td style="text-align: top;"></td></tr><tr><td style="text-align: top;"></td></tr></table><p>
 
 The maximum depth is a measure of the amount of space used by the
 evaluator in carrying out the computation, and the number of pushes
@@ -785,26 +785,26 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 
 </p><p>
 
-</p><p><a name="%_thm_5.28" id="%_thm_5.28"></a>
-<b>Exercise 5.28.</b>  <a name="%_idx_6174" id="%_idx_6174"></a><a name="%_idx_6176" id="%_idx_6176"></a>Modify the definition of the evaluator by changing
+</p><p><a id="__thm_5.28"></a>
+<b>Exercise 5.28.</b>  <a id="__idx_6174"></a><a id="__idx_6176"></a>Modify the definition of the evaluator by changing
 <tt>eval-sequence</tt> as described in
-section <a href="#%_sec_5.4.2">5.4.2</a> so that the evaluator is no
+section <a href="#__sec_5.4.2">5.4.2</a> so that the evaluator is no
 longer tail-recursive.  Rerun your experiments from
-exercises <a href="#%_thm_5.26">5.26</a> and <a href="#%_thm_5.27">5.27</a> to demonstrate
+exercises <a href="#__thm_5.26">5.26</a> and <a href="#__thm_5.27">5.27</a> to demonstrate
 that both versions of the <tt>factorial</tt> procedure now require space
 that grows linearly with their input.
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.29" id="%_thm_5.29"></a>
-<b>Exercise 5.29.</b>  <a name="%_idx_6178" id="%_idx_6178"></a>Monitor the stack operations in the tree-recursive Fibonacci computation:</p><p>
+</p><p><a id="__thm_5.29"></a>
+<b>Exercise 5.29.</b>  <a id="__idx_6178"></a>Monitor the stack operations in the tree-recursive Fibonacci computation:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6180" id="%_idx_6180"></a>(define (fib n)<br />
+</p><p></p><p><tt><a id="__idx_6180"></a>(define (fib n)<br />
   (if (&lt; n 2)<br />
       n<br />
       (+ (fib (- n 1)) (fib (- n 2)))))<br /></tt></p><p></p><p>
 a.  Give a formula in terms of <em>n</em> for the maximum depth of the stack
 required to compute  <em>F</em><em>i</em><em>b</em>(<em>n</em>) for <em>n</em> <u>&gt;</u> 2.  Hint: In
-section <a href="book-Z-H-11.html#%_sec_1.2.2">1.2.2</a> we argued that the space used by this
+section <a href="book-Z-H-11.html#__sec_1.2.2">1.2.2</a> we argued that the space used by this
 process grows linearly with <em>n</em>.</p><p>
 
 </p><p></p><p>b.  Give a formula for the total number of pushes used to compute
@@ -819,14 +819,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.30" id="%_thm_5.30"></a>
-<b>Exercise 5.30.</b>  <a name="%_idx_6182" id="%_idx_6182"></a><a name="%_idx_6184" id="%_idx_6184"></a>Our evaluator currently catches and signals only two kinds of
+</p><p><a id="__thm_5.30"></a>
+<b>Exercise 5.30.</b>  <a id="__idx_6182"></a><a id="__idx_6184"></a>Our evaluator currently catches and signals only two kinds of
 errors – unknown expression types and unknown procedure types.  Other
 errors will take us out of the evaluator read-eval-print loop.  When
 we run the evaluator using the register-machine simulator, these
 errors are caught by the underlying Scheme system.  This is analogous
 to the computer crashing when a user program makes an
-error.<a name="call_footnote_Temp_793" href="#footnote_Temp_793" id="call_footnote_Temp_793"><sup><small>32</small></sup></a>  It is a large project to make a real
+error.<a href="#footnote_Temp_793" id="call_footnote_Temp_793"><sup><small>32</small></sup></a>  It is a large project to make a real
 error system work, but it is well worth the effort to understand what
 is involved here.</p><p>
 
@@ -855,10 +855,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 </p><p></p><p>
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_765" href="#call_footnote_Temp_765" id="footnote_Temp_765"><sup><small>19</small></sup></a> See Batali et al. 1982 for more
-<a name="%_idx_6004" id="%_idx_6004"></a>information on the chip and the method by which it was designed.
+</p><div class="footnote"><p><a href="#call_footnote_Temp_765" id="footnote_Temp_765"><sup><small>19</small></sup></a> See Batali et al. 1982 for more
+<a id="__idx_6004"></a>information on the chip and the method by which it was designed.
 
-</p><p><a name="footnote_Temp_767" href="#call_footnote_Temp_767" id="footnote_Temp_767"><sup><small>20</small></sup></a> In our controller, the dispatch is written as a
+</p><p><a href="#call_footnote_Temp_767" id="footnote_Temp_767"><sup><small>20</small></sup></a> In our controller, the dispatch is written as a
 sequence of <tt>test</tt> and <tt>branch</tt> instructions.  Alternatively,
 it could have been written in a data-directed style (and in a real
 system it probably would have been) to avoid the need to perform
@@ -866,68 +866,68 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 types.  A machine designed to run Lisp would probably include a <tt>dispatch-on-type</tt> instruction that would efficiently execute such
 data-directed dispatches.
 
-</p><p><a name="footnote_Temp_770" href="#call_footnote_Temp_770" id="footnote_Temp_770"><sup><small>21</small></sup></a> This is an important but subtle point in translating
+</p><p><a href="#call_footnote_Temp_770" id="footnote_Temp_770"><sup><small>21</small></sup></a> This is an important but subtle point in translating
 algorithms from a procedural language, such as Lisp, to a
 register-machine language.  As an alternative to saving only what is
 needed, we could save all the registers (except <tt>val</tt>) before each
-recursive call. This is called a <a name="%_idx_6052" id="%_idx_6052"></a><a name="%_idx_6054" id="%_idx_6054"></a><em>framed-stack</em> discipline.  This
+recursive call. This is called a <a id="__idx_6052"></a><a id="__idx_6054"></a><em>framed-stack</em> discipline.  This
 would work but might save more registers than necessary; this could be
 an important consideration in a system where stack operations are
 expensive.  Saving registers whose contents will not be needed later
 may also hold onto useless data that could otherwise be
 garbage-collected, freeing space to be reused.
 
-</p><p><a name="footnote_Temp_771" href="#call_footnote_Temp_771" id="footnote_Temp_771"><sup><small>22</small></sup></a> We add to the evaluator data-structure procedures in
-section <a href="book-Z-H-26.html#%_sec_4.1.3">4.1.3</a> the following two procedures
+</p><p><a href="#call_footnote_Temp_771" id="footnote_Temp_771"><sup><small>22</small></sup></a> We add to the evaluator data-structure procedures in
+section <a href="book-Z-H-26.html#__sec_4.1.3">4.1.3</a> the following two procedures
 for manipulating argument lists:
-</p><p></p><p><tt><a name="%_idx_6060" id="%_idx_6060"></a>(define (empty-arglist) '())<br /><br /><a name="%_idx_6062" id="%_idx_6062"></a>(define (adjoin-arg arg arglist)<br />
+</p><p></p><p><tt><a id="__idx_6060"></a>(define (empty-arglist) '())<br /><br /><a id="__idx_6062"></a>(define (adjoin-arg arg arglist)<br />
   (append arglist (list arg)))<br /></tt></p><p></p><p>
 We also use an additional syntax procedure to test for the
 last operand in a combination:
-</p><p></p><p><tt><a name="%_idx_6064" id="%_idx_6064"></a>(define (last-operand? ops)<br />
+</p><p></p><p><tt><a id="__idx_6064"></a>(define (last-operand? ops)<br />
   (null? (cdr ops)))<br /></tt></p><p></p><p>
 
 
-</p><p><a name="footnote_Temp_772" href="#call_footnote_Temp_772" id="footnote_Temp_772"><sup><small>23</small></sup></a> The optimization of treating the last operand
-<a name="%_idx_6066" id="%_idx_6066"></a>specially is known as <i>evlis tail recursion</i> (see <a name="%_idx_6068" id="%_idx_6068"></a>Wand 1980).
+</p><p><a href="#call_footnote_Temp_772" id="footnote_Temp_772"><sup><small>23</small></sup></a> The optimization of treating the last operand
+<a id="__idx_6066"></a>specially is known as <i>evlis tail recursion</i> (see <a id="__idx_6068"></a>Wand 1980).
 We could be somewhat more efficient
 in the argument evaluation loop if we made evaluation of the first
 operand a special case too.  This would permit us to postpone
 initializing <tt>argl</tt> until after evaluating the first operand, so
 as to avoid saving <tt>argl</tt> in this case.  The compiler in
-section <a href="book-Z-H-35.html#%_sec_5.5">5.5</a> performs this optimization.  (Compare
+section <a href="book-Z-H-35.html#__sec_5.5">5.5</a> performs this optimization.  (Compare
 the <tt>construct-arglist</tt> procedure of
-section <a href="book-Z-H-35.html#%_sec_5.5.3">5.5.3</a>.)
+section <a href="book-Z-H-35.html#__sec_5.5.3">5.5.3</a>.)
 
-</p><p><a name="footnote_Temp_773" href="#call_footnote_Temp_773" id="footnote_Temp_773"><sup><small>24</small></sup></a> The
+</p><p><a href="#call_footnote_Temp_773" id="footnote_Temp_773"><sup><small>24</small></sup></a> The
 order of operand evaluation in the metacircular evaluator is
 determined by the order of evaluation of the arguments to <tt>cons</tt>
-in the procedure <tt>list-of-values</tt> of section <a href="book-Z-H-26.html#%_sec_4.1.1">4.1.1</a>
-(see exercise <a href="book-Z-H-26.html#%_thm_4.1">4.1</a>).
+in the procedure <tt>list-of-values</tt> of section <a href="book-Z-H-26.html#__sec_4.1.1">4.1.1</a>
+(see exercise <a href="book-Z-H-26.html#__thm_4.1">4.1</a>).
 
-</p><p><a name="footnote_Temp_776" href="#call_footnote_Temp_776" id="footnote_Temp_776"><sup><small>25</small></sup></a> We saw in
-section <a href="book-Z-H-31.html#%_sec_5.1">5.1</a> how to implement such a
+</p><p><a href="#call_footnote_Temp_776" id="footnote_Temp_776"><sup><small>25</small></sup></a> We saw in
+section <a href="book-Z-H-31.html#__sec_5.1">5.1</a> how to implement such a
 process with a register machine that had no stack; the state of the
 process was stored in a fixed set of registers.
 
-</p><p><a name="footnote_Temp_777" href="#call_footnote_Temp_777" id="footnote_Temp_777"><sup><small>26</small></sup></a> This implementation of tail recursion in
+</p><p><a href="#call_footnote_Temp_777" id="footnote_Temp_777"><sup><small>26</small></sup></a> This implementation of tail recursion in
 <tt>ev-sequence</tt> is one variety of a well-known optimization technique used
 by many compilers.  In compiling a procedure that ends with a procedure call,
 one can replace the call by a jump to the called procedure's entry point.
 Building this strategy into the interpreter, as we have done in this section,
 provides the optimization uniformly throughout the language.
 
-</p><p><a name="footnote_Temp_778" href="#call_footnote_Temp_778" id="footnote_Temp_778"><sup><small>27</small></sup></a> We can define <tt>no-more-exps?</tt> as follows:
-</p><p></p><p><tt><a name="%_idx_6098" id="%_idx_6098"></a>(define (no-more-exps? seq) (null? seq))<br /></tt></p><p></p><p>
+</p><p><a href="#call_footnote_Temp_778" id="footnote_Temp_778"><sup><small>27</small></sup></a> We can define <tt>no-more-exps?</tt> as follows:
+</p><p></p><p><tt><a id="__idx_6098"></a>(define (no-more-exps? seq) (null? seq))<br /></tt></p><p></p><p>
 
 
-</p><p><a name="footnote_Temp_781" href="#call_footnote_Temp_781" id="footnote_Temp_781"><sup><small>28</small></sup></a> This isn't really cheating.  In an actual
+</p><p><a href="#call_footnote_Temp_781" id="footnote_Temp_781"><sup><small>28</small></sup></a> This isn't really cheating.  In an actual
 implementation built from scratch, we would use our explicit-control
 evaluator to interpret a Scheme program that performs source-level
 transformations like <tt>cond-&gt;if</tt> in a syntax phase that runs before
 execution.
 
-</p><p><a name="footnote_Temp_784" href="#call_footnote_Temp_784" id="footnote_Temp_784"><sup><small>29</small></sup></a> We assume here that <tt>read</tt> and the
+</p><p><a href="#call_footnote_Temp_784" id="footnote_Temp_784"><sup><small>29</small></sup></a> We assume here that <tt>read</tt> and the
 various printing operations are
 available as primitive machine operations, which is useful for our
 simulation, but completely unrealistic in practice.  These
@@ -936,22 +936,22 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.4">5.4  The Explicit-Control Evalua
 such as transferring single characters to and from a device.</p><p>
 
 To support the <tt>get-global-environment</tt> operation we define
-</p><p></p><p><tt><a name="%_idx_6138" id="%_idx_6138"></a>(define the-global-environment (setup-environment))<br /><br /><a name="%_idx_6140" id="%_idx_6140"></a>(define (get-global-environment)<br />
+</p><p></p><p><tt><a id="__idx_6138"></a>(define the-global-environment (setup-environment))<br /><br /><a id="__idx_6140"></a>(define (get-global-environment)<br />
   the-global-environment)<br /></tt></p><p></p><p>
 
 
-</p><p><a name="footnote_Temp_785" href="#call_footnote_Temp_785" id="footnote_Temp_785"><sup><small>30</small></sup></a> There are other
+</p><p><a href="#call_footnote_Temp_785" id="footnote_Temp_785"><sup><small>30</small></sup></a> There are other
 errors that we would like the interpreter to handle, but these are not
-so simple.  See exercise <a href="#%_thm_5.30">5.30</a>.
+so simple.  See exercise <a href="#__thm_5.30">5.30</a>.
 
-</p><p><a name="footnote_Temp_786" href="#call_footnote_Temp_786" id="footnote_Temp_786"><sup><small>31</small></sup></a> We
+</p><p><a href="#call_footnote_Temp_786" id="footnote_Temp_786"><sup><small>31</small></sup></a> We
 could perform the stack initialization only after errors, but doing it in
 the driver loop will be convenient for monitoring the evaluator's
 performance, as described below.
 
-</p><p><a name="footnote_Temp_793" href="#call_footnote_Temp_793" id="footnote_Temp_793"><sup><small>32</small></sup></a> Regrettably, this is the normal state of affairs in
-<a name="%_idx_6186" id="%_idx_6186"></a>conventional compiler-based language systems such as C.
-<a name="%_idx_6188" id="%_idx_6188"></a><a name="%_idx_6190" id="%_idx_6190"></a><a name="%_idx_6192" id="%_idx_6192"></a>In UNIX<sup><em>T</em><em>M</em></sup> the system “dumps core,” and in
+</p><p><a href="#call_footnote_Temp_793" id="footnote_Temp_793"><sup><small>32</small></sup></a> Regrettably, this is the normal state of affairs in
+<a id="__idx_6186"></a>conventional compiler-based language systems such as C.
+<a id="__idx_6188"></a><a id="__idx_6190"></a><a id="__idx_6192"></a>In UNIX<sup><em>T</em><em>M</em></sup> the system “dumps core,” and in
 DOS/Windows<sup><em>T</em><em>M</em></sup> it becomes catatonic.
 The Macintosh<sup><em>T</em><em>M</em></sup> displays a
 picture of an exploding bomb and offers you the opportunity to reboot
diff --git a/src/OEBPS/book-Z-H-35.html b/src/OEBPS/book-Z-H-35.html
index d37c8cb..8e2327a 100644
--- a/src/OEBPS/book-Z-H-35.html
+++ b/src/OEBPS/book-Z-H-35.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,46 +13,46 @@
 
 
 
-<a name="%_sec_5.5" id="%_sec_5.5"></a>
-<h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
+<a id="__sec_5.5"></a>
+<h2>5.5  Compilation</h2><p>
 
 
-<a name="%_idx_6194" id="%_idx_6194"></a>
-The explicit-control evaluator of section <a href="book-Z-H-34.html#%_sec_5.4">5.4</a> is a
+<a id="__idx_6194"></a>
+The explicit-control evaluator of section <a href="book-Z-H-34.html#__sec_5.4">5.4</a> is a
 register machine whose controller interprets Scheme programs.  In this
 section we will see how to run Scheme programs on a register machine
 whose controller is not a Scheme interpreter.</p><p>
 
-<a name="%_idx_6196" id="%_idx_6196"></a><a name="%_idx_6198" id="%_idx_6198"></a>The explicit-control evaluator machine is universal – it can carry out
+<a id="__idx_6196"></a><a id="__idx_6198"></a>The explicit-control evaluator machine is universal – it can carry out
 any computational process that can be described in Scheme.  The
 evaluator's controller orchestrates the use of its data paths to
 perform the desired computation.  Thus, the evaluator's data paths are
 universal: They are sufficient to perform any computation we desire,
-given an appropriate controller.<a name="call_footnote_Temp_794" href="#footnote_Temp_794" id="call_footnote_Temp_794"><sup><small>33</small></sup></a></p><p>
+given an appropriate controller.<a href="#footnote_Temp_794" id="call_footnote_Temp_794"><sup><small>33</small></sup></a></p><p>
 
-<a name="%_idx_6200" id="%_idx_6200"></a><a name="%_idx_6202" id="%_idx_6202"></a>Commercial general-purpose computers are register machines organized
+<a id="__idx_6200"></a><a id="__idx_6202"></a>Commercial general-purpose computers are register machines organized
 around a collection of registers and operations that constitute
 an efficient and convenient universal set of data paths.
 The controller for a general-purpose machine is an interpreter for
 a register-machine language like the one we have been using.  This
-language is called the <a name="%_idx_6204" id="%_idx_6204"></a><em>native language</em> of the machine, or simply
-<a name="%_idx_6206" id="%_idx_6206"></a><em>machine language</em>.  Programs written in machine language are
+language is called the <a id="__idx_6204"></a><em>native language</em> of the machine, or simply
+<a id="__idx_6206"></a><em>machine language</em>.  Programs written in machine language are
 sequences of instructions that use the machine's data paths.
-For example, the <a name="%_idx_6208" id="%_idx_6208"></a>explicit-control evaluator's instruction sequence
+For example, the <a id="__idx_6208"></a>explicit-control evaluator's instruction sequence
 can be thought of as a machine-language program for a general-purpose
 computer rather than as the controller for a specialized interpreter
 machine.</p><p>
 
-<a name="%_idx_6210" id="%_idx_6210"></a><a name="%_idx_6212" id="%_idx_6212"></a>There are two common strategies for bridging the gap between
+<a id="__idx_6210"></a><a id="__idx_6212"></a>There are two common strategies for bridging the gap between
 higher-level languages and register-machine languages.  The
 explicit-control evaluator illustrates the
 strategy of interpretation.  An interpreter written in the native
 language of a machine configures the machine to execute programs
-written in a language (called the <a name="%_idx_6214" id="%_idx_6214"></a><em>source language</em>) that may
+written in a language (called the <a id="__idx_6214"></a><em>source language</em>) that may
 differ from the native language of the machine performing the
 evaluation.  The primitive procedures of the source language are
 implemented as a library of subroutines written in the native language
-of the given machine.  A program to be interpreted (called the <a name="%_idx_6216" id="%_idx_6216"></a><em>source program</em>) is represented as a data structure.  The interpreter
+of the given machine.  A program to be interpreted (called the <a id="__idx_6216"></a><em>source program</em>) is represented as a data structure.  The interpreter
 traverses this data structure, analyzing the source program.  As it
 does so, it simulates the intended behavior of the source program by
 calling appropriate primitive subroutines from the library.</p><p>
@@ -60,10 +60,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 
 In this section, we explore the alternative strategy of <em>compilation</em>.  A compiler for a given source language and machine
 translates a source program into an equivalent program (called the
-<a name="%_idx_6218" id="%_idx_6218"></a><em>object program</em>) written in the machine's native language.  The
+<a id="__idx_6218"></a><em>object program</em>) written in the machine's native language.  The
 compiler that we implement in this section translates programs written
 in Scheme into sequences of instructions to be executed using
-the explicit-control evaluator machine's data paths.<a name="call_footnote_Temp_795" href="#footnote_Temp_795" id="call_footnote_Temp_795"><sup><small>34</small></sup></a></p><p>
+the explicit-control evaluator machine's data paths.<a href="#footnote_Temp_795" id="call_footnote_Temp_795"><sup><small>34</small></sup></a></p><p>
 
 Compared with interpretation, compilation can provide a great increase
 in the efficiency of program execution, as we will explain below in
@@ -83,20 +83,20 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 compilation, while retaining the interpretive mode of execution for
 those parts of the program that are in the flux of interactive
 development and debugging.  In
-section <a href="#%_sec_5.5.7">5.5.7</a>, after we have implemented
+section <a href="#__sec_5.5.7">5.5.7</a>, after we have implemented
 the compiler, we will show how to interface it with our interpreter to
 produce an integrated interpreter-compiler development system.</p><p>
 
-<a name="%_sec_Temp_796" id="%_sec_Temp_796"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_796">An overview of the compiler</a></h4><p>
+<a id="__sec_Temp_796"></a>
+</p><h4>An overview of the compiler</h4><p>
 
-<a name="%_idx_6224" id="%_idx_6224"></a><a name="%_idx_6226" id="%_idx_6226"></a>
+<a id="__idx_6224"></a><a id="__idx_6226"></a>
 Our compiler is much like our interpreter, both in its structure and in
 the function it performs.  Accordingly, the mechanisms used by the
 compiler for analyzing expressions will be similar to those used by
 the interpreter.  Moreover, to make it easy to interface compiled and
 interpreted code, we will design the compiler to generate code that
-obeys the same conventions of <a name="%_idx_6228" id="%_idx_6228"></a>register usage as the interpreter: The
+obeys the same conventions of <a id="__idx_6228"></a>register usage as the interpreter: The
 environment will be kept in the <tt>env</tt> register, argument lists
 will be accumulated in <tt>argl</tt>, a procedure to be applied will be
 in <tt>proc</tt>, procedures will return their answers in <tt>val</tt>,
@@ -112,7 +112,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 interpreter would perform in evaluating the expression, we do not
 execute the instruction but instead accumulate it into a sequence.  The
 resulting sequence of instructions will be the object code.  Observe
-the <a name="%_idx_6230" id="%_idx_6230"></a><a name="%_idx_6232" id="%_idx_6232"></a>efficiency advantage of compilation over interpretation.  Each
+the <a id="__idx_6230"></a><a id="__idx_6232"></a>efficiency advantage of compilation over interpretation.  Each
 time the interpreter evaluates an expression – for example,
 <tt>(f 84 96)</tt> – it performs the work of
 classifying the expression (discovering that this
@@ -125,8 +125,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 and apply the procedure (in <tt>proc</tt>) to the arguments (in <tt>argl</tt>).</p><p>
 
 
-<a name="%_idx_6234" id="%_idx_6234"></a>This is the same kind of optimization we implemented in the
-analyzing evaluator of section <a href="book-Z-H-26.html#%_sec_4.1.7">4.1.7</a>.
+<a id="__idx_6234"></a>This is the same kind of optimization we implemented in the
+analyzing evaluator of section <a href="book-Z-H-26.html#__sec_4.1.7">4.1.7</a>.
 But there are further opportunities to gain efficiency in compiled code.
 As the interpreter runs, it follows a process that must be applicable
 to any expression in the language.  In contrast, a given segment of
@@ -164,21 +164,21 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 a particular variable will be located and access that frame directly,
 rather than performing the <tt>lookup-variable-value</tt> search.  We
 will discuss how to implement such variable access in
-section <a href="#%_sec_5.5.6">5.5.6</a>.  Until then, however, we will
+section <a href="#__sec_5.5.6">5.5.6</a>.  Until then, however, we will
 focus on the kind of register and stack optimizations described above.
 There are many other optimizations that can be performed by a
 compiler, such as coding primitive operations “in line” instead of
 using a general <tt>apply</tt> mechanism (see
-exercise <a href="#%_thm_5.38">5.38</a>); but we will not emphasize these here.
+exercise <a href="#__thm_5.38">5.38</a>); but we will not emphasize these here.
 Our main goal in this section is to illustrate the compilation process
 in a simplified (but still interesting) context.</p><p>
 
-<a name="%_sec_5.5.1" id="%_sec_5.5.1"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.5.1">5.5.1  Structure of the Compiler</a></h3><p>
+<a id="__sec_5.5.1"></a>
+</p><h3>5.5.1  Structure of the Compiler</h3><p>
 
 
-<a name="%_idx_6236" id="%_idx_6236"></a>
-<a name="%_idx_6238" id="%_idx_6238"></a>In section <a href="book-Z-H-26.html#%_sec_4.1.7">4.1.7</a> we modified our original
+<a id="__idx_6236"></a>
+<a id="__idx_6238"></a>In section <a href="book-Z-H-26.html#__sec_4.1.7">4.1.7</a> we modified our original
 metacircular interpreter to separate analysis from execution.  We
 analyzed each expression to produce an execution procedure that took
 an environment as argument and performed the required operations.  In
@@ -189,18 +189,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 
 The procedure <tt>compile</tt> is the top-level dispatch in the compiler.
 It corresponds to the <tt>eval</tt> procedure of
-section <a href="book-Z-H-26.html#%_sec_4.1.1">4.1.1</a>, the <tt>analyze</tt> procedure of
-section <a href="book-Z-H-26.html#%_sec_4.1.7">4.1.7</a>, and the <tt>eval-dispatch</tt>
+section <a href="book-Z-H-26.html#__sec_4.1.1">4.1.1</a>, the <tt>analyze</tt> procedure of
+section <a href="book-Z-H-26.html#__sec_4.1.7">4.1.7</a>, and the <tt>eval-dispatch</tt>
 entry point of the explicit-control-evaluator in
-section <a href="book-Z-H-34.html#%_sec_5.4.1">5.4.1</a>.
-The compiler, like the interpreters, uses the <a name="%_idx_6240" id="%_idx_6240"></a>expression-syntax
-procedures defined in section <a href="book-Z-H-26.html#%_sec_4.1.2">4.1.2</a>.<a name="call_footnote_Temp_797" href="#footnote_Temp_797" id="call_footnote_Temp_797"><sup><small>35</small></sup></a>
+section <a href="book-Z-H-34.html#__sec_5.4.1">5.4.1</a>.
+The compiler, like the interpreters, uses the <a id="__idx_6240"></a>expression-syntax
+procedures defined in section <a href="book-Z-H-26.html#__sec_4.1.2">4.1.2</a>.<a href="#footnote_Temp_797" id="call_footnote_Temp_797"><sup><small>35</small></sup></a>
 <tt>Compile</tt> performs a case
 analysis on the syntactic type of the expression to be compiled.  For
-each type of expression, it dispatches to a specialized <a name="%_idx_6242" id="%_idx_6242"></a><em>code
+each type of expression, it dispatches to a specialized <a id="__idx_6242"></a><em>code
 generator</em>:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6244" id="%_idx_6244"></a>(define (compile exp target linkage)<br />
+</p><p></p><p><tt><a id="__idx_6244"></a>(define (compile exp target linkage)<br />
   (cond ((self-evaluating? exp)<br />
          (compile-self-evaluating exp target linkage))<br />
         ((quoted? exp) (compile-quoted exp target linkage))<br />
@@ -223,23 +223,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
          (error "Unknown expression type -- COMPILE" exp))))<br /></tt></p><p></p><p></p><p>
 
 
-<a name="%_sec_Temp_798" id="%_sec_Temp_798"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_798">Targets and linkages</a></h4><p>
+<a id="__sec_Temp_798"></a>
+</p><h4>Targets and linkages</h4><p>
 
-<a name="%_idx_6246" id="%_idx_6246"></a><tt>Compile</tt> and the code generators that it calls take two arguments
-in addition to the expression to compile.  There is a <a name="%_idx_6248" id="%_idx_6248"></a><em>target</em>,
+<a id="__idx_6246"></a><tt>Compile</tt> and the code generators that it calls take two arguments
+in addition to the expression to compile.  There is a <a id="__idx_6248"></a><em>target</em>,
 which specifies the register in which the compiled code is to return
-the value of the expression.  There is also a <a name="%_idx_6250" id="%_idx_6250"></a><em>linkage
+the value of the expression.  There is also a <a id="__idx_6250"></a><em>linkage
 descriptor</em>, which describes how the code resulting from the
 compilation of the expression should proceed when it has finished its
 execution.  The linkage descriptor can require that the code do one of
 the following three things:</p><p>
 
 </p><p></p><ul><li>continue at the next instruction in sequence (this is
-<a name="%_idx_6252" id="%_idx_6252"></a>specified by the linkage descriptor <tt>next</tt>),<p>
+<a id="__idx_6252"></a>specified by the linkage descriptor <tt>next</tt>),<p>
 
 </p></li><li>return from the procedure being compiled (this is specified
-<a name="%_idx_6254" id="%_idx_6254"></a>by the linkage descriptor <tt>return</tt>), or<p>
+<a id="__idx_6254"></a>by the linkage descriptor <tt>return</tt>), or<p>
 
 </p></li><li>jump to a named entry point (this is specified by using the
 designated label as the linkage descriptor).
@@ -260,12 +260,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 call.  In both cases, the value of the expression will be placed into
 the target <tt>val</tt> register.</p><p>
 
-<a name="%_sec_Temp_799" id="%_sec_Temp_799"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_799">Instruction sequences and stack usage</a></h4><p>
+<a id="__sec_Temp_799"></a>
+</p><h4>Instruction sequences and stack usage</h4><p>
 
 </p><p>
 
-<a name="%_idx_6256" id="%_idx_6256"></a><a name="%_idx_6258" id="%_idx_6258"></a>Each code generator returns an <em>instruction sequence</em> containing
+<a id="__idx_6256"></a><a id="__idx_6258"></a>Each code generator returns an <em>instruction sequence</em> containing
 the object code it has generated for the expression.  Code generation
 for a compound expression is accomplished by combining the output from
 simpler code generators for component expressions, just as
@@ -274,7 +274,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 
 
 The simplest method for combining instruction sequences is a procedure
-<a name="%_idx_6260" id="%_idx_6260"></a>called <tt>append-instruction-sequences</tt>.  It takes as arguments any
+<a id="__idx_6260"></a>called <tt>append-instruction-sequences</tt>.  It takes as arguments any
 number of instruction sequences that are to be executed sequentially;
 it appends them and returns the combined sequence.  That is, if
 &lt;<em><em>s</em><em>e</em><em>q</em><sub>1</sub></em>&gt; and &lt;<em><em>s</em><em>e</em><em>q</em><sub>2</sub></em>&gt; are sequences of instructions, then
@@ -284,8 +284,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 </p><p></p><p><tt>&lt;<em><em>s</em><em>e</em><em>q</em><sub>1</sub></em>&gt;<br />
 &lt;<em><em>s</em><em>e</em><em>q</em><sub>2</sub></em>&gt;<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_6262" id="%_idx_6262"></a>Whenever registers might need to be saved, the compiler's code generators use
-<a name="%_idx_6264" id="%_idx_6264"></a><tt>preserving</tt>, which is a more subtle method for combining
+<a id="__idx_6262"></a>Whenever registers might need to be saved, the compiler's code generators use
+<a id="__idx_6264"></a><tt>preserving</tt>, which is a more subtle method for combining
 instruction sequences.  <tt>Preserving</tt> takes three arguments: a set
 of registers and two instruction sequences that are to be executed
 sequentially.  It appends the sequences in such a way that the
@@ -301,7 +301,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 produces one of the following four sequences of instructions, depending on how
 &lt;<em><em>s</em><em>e</em><em>q</em><sub>1</sub></em>&gt; and &lt;<em><em>s</em><em>e</em><em>q</em><sub>2</sub></em>&gt; use &lt;<em><em>r</em><em>e</em><em>g</em><sub>1</sub></em>&gt; and &lt;<em><em>r</em><em>e</em><em>g</em><sub>2</sub></em>&gt;:</p><p>
 
-</p><p></p><p></p><p></p><div align="left"><img src="images/ch5-Z-G-9.gif" border="0" /></div><p></p><p>
+</p><p></p><p></p><p></p><div style="text-align: left;"><img src="images/ch5-Z-G-9.gif" alt="ch5-Z-G-9" style="border: none;" /></div><p></p><p>
 
 By using <tt>preserving</tt> to combine instruction sequences the
 compiler avoids unnecessary stack operations.  This also isolates the
@@ -343,7 +343,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 We will represent an instruction sequence as a list of its three
 parts.  The constructor for instruction sequences is thus</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6266" id="%_idx_6266"></a>(define (make-instruction-sequence needs modifies statements)<br />
+</p><p></p><p><tt><a id="__idx_6266"></a>(define (make-instruction-sequence needs modifies statements)<br />
   (list needs modifies statements))<br /></tt></p><p></p><p></p><p>
 
 For example, the two-instruction sequence that looks up the value of
@@ -357,15 +357,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
    (goto (reg continue))))<br /></tt></p><p></p><p></p><p>
 
 We sometimes need to construct an instruction sequence with no statements:
-</p><p></p><p><tt><a name="%_idx_6268" id="%_idx_6268"></a>(define (empty-instruction-sequence)<br />
+</p><p></p><p><tt><a id="__idx_6268"></a>(define (empty-instruction-sequence)<br />
   (make-instruction-sequence '() '() '()))<br /></tt></p><p></p><p>
 </p><p>
 
 The procedures for combining instruction sequences are shown in
-section <a href="#%_sec_5.5.4">5.5.4</a>.</p><p>
+section <a href="#__sec_5.5.4">5.5.4</a>.</p><p>
 
-</p><p><a name="%_thm_5.31" id="%_thm_5.31"></a>
-<b>Exercise 5.31.</b>  <a name="%_idx_6270" id="%_idx_6270"></a><a name="%_idx_6272" id="%_idx_6272"></a>In evaluating a procedure application, the explicit-control evaluator
+</p><p><a id="__thm_5.31"></a>
+<b>Exercise 5.31.</b>  <a id="__idx_6270"></a><a id="__idx_6272"></a>In evaluating a procedure application, the explicit-control evaluator
 always saves and restores
 the <tt>env</tt> register around the evaluation of the operator, saves and
 restores <tt>env</tt> around the evaluation of each operand (except the
@@ -381,12 +381,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 (f (g 'x) 'y)<br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.32" id="%_thm_5.32"></a>
-<b>Exercise 5.32.</b>  <a name="%_idx_6274" id="%_idx_6274"></a><a name="%_idx_6276" id="%_idx_6276"></a>Using the <tt>preserving</tt> mechanism, the compiler will avoid saving
+</p><p><a id="__thm_5.32"></a>
+<b>Exercise 5.32.</b>  <a id="__idx_6274"></a><a id="__idx_6276"></a>Using the <tt>preserving</tt> mechanism, the compiler will avoid saving
 and restoring <tt>env</tt> around the evaluation of the operator of a
 combination in the case where the operator is a symbol.  We could also
 build such optimizations into the evaluator.  Indeed, the
-explicit-control evaluator of section <a href="book-Z-H-34.html#%_sec_5.4">5.4</a> already
+explicit-control evaluator of section <a href="book-Z-H-34.html#__sec_5.4">5.4</a> already
 performs a similar optimization, by treating combinations with no
 operands as a special case.</p><p>
 
@@ -400,15 +400,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 altogether.  What do you think of this idea?
 </p><p></p><p>
 
-<a name="%_sec_5.5.2" id="%_sec_5.5.2"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.5.2">5.5.2  Compiling Expressions</a></h3><p>
+<a id="__sec_5.5.2"></a>
+</p><h3>5.5.2  Compiling Expressions</h3><p>
 
 In this section and the next we implement the code generators to which the <tt>compile</tt> procedure dispatches.</p><p>
 
-<a name="%_sec_Temp_802" id="%_sec_Temp_802"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_802">Compiling linkage code</a></h4><p>
+<a id="__sec_Temp_802"></a>
+</p><h4>Compiling linkage code</h4><p>
 
-<a name="%_idx_6278" id="%_idx_6278"></a>In general, the output of each code generator will end with
+<a id="__idx_6278"></a>In general, the output of each code generator will end with
 instructions – generated by the procedure <tt>compile-linkage</tt> – that
 implement the required linkage.  If the linkage is <tt>return</tt> then
 we must generate the instruction <tt>(goto (reg continue))</tt>.  This
@@ -416,10 +416,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 If the linkage is <tt>next</tt>, then we needn't include any additional
 instructions.  Otherwise, the linkage is a label, and we generate a
 <tt>goto</tt> to that label, an instruction that does not need or modify
-any registers.<a name="call_footnote_Temp_803" href="#footnote_Temp_803" id="call_footnote_Temp_803"><sup><small>36</small></sup></a></p><p>
+any registers.<a href="#footnote_Temp_803" id="call_footnote_Temp_803"><sup><small>36</small></sup></a></p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_6292" id="%_idx_6292"></a>(define (compile-linkage linkage)<br />
+</p><p></p><p><tt><a id="__idx_6292"></a>(define (compile-linkage linkage)<br />
   (cond ((eq? linkage 'return)<br />
          (make-instruction-sequence '(continue) '()<br />
           '((goto (reg continue)))))<br />
@@ -435,29 +435,29 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 linkage code needs it, <tt>continue</tt> will be saved and restored.</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_6294" id="%_idx_6294"></a>(define (end-with-linkage linkage instruction-sequence)<br />
+</p><p></p><p><tt><a id="__idx_6294"></a>(define (end-with-linkage linkage instruction-sequence)<br />
   (preserving '(continue)<br />
    instruction-sequence<br />
    (compile-linkage linkage)))<br /></tt></p><p></p><p></p><p>
 
 </p><p>
 
-<a name="%_sec_Temp_804" id="%_sec_Temp_804"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_804">Compiling simple expressions</a></h4><p>
+<a id="__sec_Temp_804"></a>
+</p><h4>Compiling simple expressions</h4><p>
 
-<a name="%_idx_6296" id="%_idx_6296"></a><a name="%_idx_6298" id="%_idx_6298"></a><a name="%_idx_6300" id="%_idx_6300"></a>The code generators for self-evaluating expressions,
+<a id="__idx_6296"></a><a id="__idx_6298"></a><a id="__idx_6300"></a>The code generators for self-evaluating expressions,
 quotations, and variables construct instruction
 sequences that assign the required value to the target register
 and then proceed as specified by the linkage descriptor.</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_6302" id="%_idx_6302"></a>(define (compile-self-evaluating exp target linkage)<br />
+</p><p></p><p><tt><a id="__idx_6302"></a>(define (compile-self-evaluating exp target linkage)<br />
   (end-with-linkage linkage<br />
    (make-instruction-sequence '() (list target)<br />
-    `((assign ,target (const ,exp))))))<br /><a name="%_idx_6304" id="%_idx_6304"></a>(define (compile-quoted exp target linkage)<br />
+    `((assign ,target (const ,exp))))))<br /><a id="__idx_6304"></a>(define (compile-quoted exp target linkage)<br />
   (end-with-linkage linkage<br />
    (make-instruction-sequence '() (list target)<br />
-    `((assign ,target (const ,(text-of-quotation exp)))))))<br /><a name="%_idx_6306" id="%_idx_6306"></a>(define (compile-variable exp target linkage)<br />
+    `((assign ,target (const ,(text-of-quotation exp)))))))<br /><a id="__idx_6306"></a>(define (compile-variable exp target linkage)<br />
   (end-with-linkage linkage<br />
    (make-instruction-sequence '(env) (list target)<br />
     `((assign ,target<br />
@@ -467,7 +467,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 All these assignment instructions modify the target register,
 and the one that looks up a variable needs the <tt>env</tt> register.</p><p>
 
-<a name="%_idx_6308" id="%_idx_6308"></a><a name="%_idx_6310" id="%_idx_6310"></a>Assignments and definitions are handled much as they are in the
+<a id="__idx_6308"></a><a id="__idx_6310"></a>Assignments and definitions are handled much as they are in the
 interpreter.  We recursively generate code that computes the value to
 be assigned to the variable, and append to it a two-instruction
 sequence that actually sets or defines the variable and assigns the
@@ -480,7 +480,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 the compilation of a complex expression that might modify the
 registers in arbitrary ways.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6312" id="%_idx_6312"></a>(define (compile-assignment exp target linkage)<br />
+</p><p></p><p><tt><a id="__idx_6312"></a>(define (compile-assignment exp target linkage)<br />
   (let ((var (assignment-variable exp))<br />
         (get-value-code<br />
          (compile (assignment-value exp) 'val 'next)))<br />
@@ -492,7 +492,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
                   (const ,var)<br />
                   (reg val)<br />
                   (reg env))<br />
-         (assign ,target (const ok))))))))<br /><a name="%_idx_6314" id="%_idx_6314"></a>(define (compile-definition exp target linkage)<br />
+         (assign ,target (const ok))))))))<br /><a id="__idx_6314"></a>(define (compile-definition exp target linkage)<br />
   (let ((var (definition-variable exp))<br />
         (get-value-code<br />
          (compile (definition-value exp) 'val 'next)))<br />
@@ -511,10 +511,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 (In fact, if we did preserve <tt>val</tt>, we would
 have a bug, because this would cause the previous contents of <tt>val</tt> to be restored right after the <tt>get-value-code</tt> is run.)</p><p>
 
-<a name="%_sec_Temp_805" id="%_sec_Temp_805"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_805">Compiling conditional expressions</a></h4><p>
+<a id="__sec_Temp_805"></a>
+</p><h4>Compiling conditional expressions</h4><p>
 
-<a name="%_idx_6316" id="%_idx_6316"></a>The code for an <tt>if</tt> expression
+<a id="__idx_6316"></a>The code for an <tt>if</tt> expression
 compiled with a given target and linkage has the form</p><p>
 
 </p><p></p><p><tt> &lt;<em>compilation of predicate, target <tt>val</tt>, linkage <tt>next</tt></em>&gt;<br />
@@ -529,7 +529,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 To generate this code, we compile the predicate, consequent,
 and alternative, and combine the resulting code with instructions
 to test the predicate result and with newly generated labels
-to mark the true and false branches and the end of the conditional.<a name="call_footnote_Temp_806" href="#footnote_Temp_806" id="call_footnote_Temp_806"><sup><small>37</small></sup></a>
+to mark the true and false branches and the end of the conditional.<a href="#footnote_Temp_806" id="call_footnote_Temp_806"><sup><small>37</small></sup></a>
 In this arrangement of code, we must branch around the true branch
 if the test is false.  The only slight complication is in how the
 linkage for the true branch should be handled.  If the linkage for the
@@ -539,7 +539,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 
 
 
-</p><p></p><p><tt><a name="%_idx_6324" id="%_idx_6324"></a>(define (compile-if exp target linkage)<br />
+</p><p></p><p><tt><a id="__idx_6324"></a>(define (compile-if exp target linkage)<br />
   (let ((t-branch (make-label 'true-branch))<br />
         (f-branch (make-label 'false-branch))                    <br />
         (after-if (make-label 'after-if)))<br />
@@ -566,18 +566,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 be needed by the linkage code in those branches.  The code for the true and
 false branches (which are not executed sequentially) is appended using a
 special combiner <tt>parallel-instruction-sequences</tt> described in
-section <a href="#%_sec_5.5.4">5.5.4</a>.</p><p>
+section <a href="#__sec_5.5.4">5.5.4</a>.</p><p>
 
 
 Note that <tt>cond</tt> is a derived expression, so all that the
 compiler needs to do handle it is to apply the <tt>cond-&gt;if</tt>
-transformer (from section <a href="book-Z-H-26.html#%_sec_4.1.2">4.1.2</a>) and
+transformer (from section <a href="book-Z-H-26.html#__sec_4.1.2">4.1.2</a>) and
 compile the resulting <tt>if</tt> expression.</p><p>
 
-<a name="%_sec_Temp_807" id="%_sec_Temp_807"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_807">Compiling sequences</a></h4><p>
+<a id="__sec_Temp_807"></a>
+</p><h4>Compiling sequences</h4><p>
 
-<a name="%_idx_6326" id="%_idx_6326"></a>The compilation of sequences (from procedure bodies or explicit <tt>begin</tt> expressions) parallels their evaluation.  Each expression of the
+<a id="__idx_6326"></a>The compilation of sequences (from procedure bodies or explicit <tt>begin</tt> expressions) parallels their evaluation.  Each expression of the
 sequence is compiled – the last expression with the linkage specified
 for the sequence, and the other expressions with linkage <tt>next</tt>
 (to execute the rest of the sequence).
@@ -586,17 +586,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 the rest of the sequence) and <tt>continue</tt> (possibly needed for the
 linkage at the end of the sequence) are preserved.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6328" id="%_idx_6328"></a>(define (compile-sequence seq target linkage)<br />
+</p><p></p><p><tt><a id="__idx_6328"></a>(define (compile-sequence seq target linkage)<br />
   (if (last-exp? seq)<br />
       (compile (first-exp seq) target linkage)<br />
       (preserving '(env continue)<br />
        (compile (first-exp seq) target 'next)<br />
        (compile-sequence (rest-exps seq) target linkage))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_808" id="%_sec_Temp_808"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_808">Compiling <tt>lambda</tt> expressions</a></h4><p>
+<a id="__sec_Temp_808"></a>
+</p><h4>Compiling <tt>lambda</tt> expressions</h4><p>
 
-<a name="%_idx_6330" id="%_idx_6330"></a><tt>Lambda</tt> expressions construct procedures.
+<a id="__idx_6330"></a><tt>Lambda</tt> expressions construct procedures.
 The object code for a <tt>lambda</tt> expression must have the form</p><p>
 
 </p><p></p><p><tt>&lt;<em>construct procedure object and assign it to target register</em>&gt;<br />
@@ -620,9 +620,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 The procedure object will be constructed at run time by combining
 the current environment (the environment at the point of definition)
 with the entry point to the compiled procedure body (a newly generated
-label).<a name="call_footnote_Temp_809" href="#footnote_Temp_809" id="call_footnote_Temp_809"><sup><small>38</small></sup></a></p><p>
+label).<a href="#footnote_Temp_809" id="call_footnote_Temp_809"><sup><small>38</small></sup></a></p><p>
 
-</p><p></p><p><tt><a name="%_idx_6340" id="%_idx_6340"></a>(define (compile-lambda exp target linkage)<br />
+</p><p></p><p><tt><a id="__idx_6340"></a>(define (compile-lambda exp target linkage)<br />
   (let ((proc-entry (make-label 'entry))<br />
         (after-lambda (make-label 'after-lambda)))<br />
     (let ((lambda-linkage<br />
@@ -638,7 +638,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
         (compile-lambda-body exp proc-entry))<br />
        after-lambda))))<br /></tt></p><p></p><p>
 <tt>Compile-lambda</tt> uses the special combiner <tt>tack-on-instruction-sequence</tt>
-(section <a href="#%_sec_5.5.4">5.5.4</a>) rather than <tt>append-instruction-sequences</tt> to append the procedure body to the <tt>lambda</tt>
+(section <a href="#__sec_5.5.4">5.5.4</a>) rather than <tt>append-instruction-sequences</tt> to append the procedure body to the <tt>lambda</tt>
 expression code, because the body is not part of the sequence of instructions
 that will be executed when the combined sequence is entered; rather, it is in
 the sequence only because that was a convenient place to put it.</p><p>
@@ -669,11 +669,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
                 (reg env))))<br />
      (compile-sequence (lambda-body exp) 'val 'return))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_5.5.3" id="%_sec_5.5.3"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.5.3">5.5.3  Compiling Combinations</a></h3><p>
+<a id="__sec_5.5.3"></a>
+</p><h3>5.5.3  Compiling Combinations</h3><p>
 
 
-<a name="%_idx_6342" id="%_idx_6342"></a><a name="%_idx_6344" id="%_idx_6344"></a>
+<a id="__idx_6342"></a><a id="__idx_6344"></a>
 The essence of the compilation process is the compilation of procedure
 applications.
 The code for a combination compiled with a given target and linkage
@@ -704,7 +704,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 application).  <tt>Continue</tt> must also be preserved throughout, since
 it is needed for the linkage in the procedure call.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6346" id="%_idx_6346"></a>(define (compile-application exp target linkage)<br />
+</p><p></p><p><tt><a id="__idx_6346"></a>(define (compile-application exp target linkage)<br />
   (let ((proc-code (compile (operator exp) 'proc 'next))<br />
         (operand-codes<br />
          (map (lambda (operand) (compile operand 'val 'next))<br />
@@ -750,7 +750,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 first, we must reverse the list of operand code sequences from the order
 supplied by <tt>compile-application</tt>.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6348" id="%_idx_6348"></a>(define (construct-arglist operand-codes)<br />
+</p><p></p><p><tt><a id="__idx_6348"></a>(define (construct-arglist operand-codes)<br />
   (let ((operand-codes (reverse operand-codes)))<br />
     (if (null? operand-codes)<br />
         (make-instruction-sequence '() '(argl)<br />
@@ -779,15 +779,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
          code-for-next-arg<br />
          (code-to-get-rest-args (cdr operand-codes))))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_Temp_810" id="%_sec_Temp_810"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_810">Applying procedures</a></h4><p>
+<a id="__sec_Temp_810"></a>
+</p><h4>Applying procedures</h4><p>
 
 After evaluating the elements of a combination, the compiled code must
 apply the procedure in <tt>proc</tt> to the arguments in <tt>argl</tt>.  The
 code performs essentially the same dispatch as the <tt>apply</tt> procedure in the
-metacircular evaluator of section <a href="book-Z-H-26.html#%_sec_4.1.1">4.1.1</a> or the
+metacircular evaluator of section <a href="book-Z-H-26.html#__sec_4.1.1">4.1.1</a> or the
 <tt>apply-dispatch</tt> entry point in the explicit-control evaluator of
-section <a href="book-Z-H-34.html#%_sec_5.4.1">5.4.1</a>.  It checks whether the
+section <a href="book-Z-H-34.html#__sec_5.4.1">5.4.1</a>.  It checks whether the
 procedure to be applied is a primitive procedure or a compiled
 procedure.  For a primitive procedure, it uses <tt>apply-primitive-procedure</tt>; we will see shortly how it handles
 compiled procedures.  The procedure-application code has the following
@@ -810,7 +810,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 label that is inserted after the primitive branch.  (This is similar
 to the linkage used for the true branch in <tt>compile-if</tt>.)</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6350" id="%_idx_6350"></a>(define (compile-procedure-call target linkage)<br />
+</p><p></p><p><tt><a id="__idx_6350"></a>(define (compile-procedure-call target linkage)<br />
   (let ((primitive-branch (make-label 'primitive-branch))<br />
         (compiled-branch (make-label 'compiled-branch))<br />
         (after-call (make-label 'after-call)))<br />
@@ -839,8 +839,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 <tt>parallel-instruction-sequences</tt> rather than the ordinary <tt>append-instruction-sequences</tt>, because they will
 not be executed sequentially.</p><p>
 
-<a name="%_sec_Temp_811" id="%_sec_Temp_811"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_811">Applying compiled procedures</a></h4><p>
+<a id="__sec_Temp_811"></a>
+</p><h4>Applying compiled procedures</h4><p>
 
 The code that handles procedure application is the most subtle part of
 the compiler, even though the instruction sequences it generates are
@@ -878,7 +878,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 
 
 In fact, if the target is not <tt>val</tt>, that is exactly the code our
-compiler will generate.<a name="call_footnote_Temp_812" href="#footnote_Temp_812" id="call_footnote_Temp_812"><sup><small>39</small></sup></a>
+compiler will generate.<a href="#footnote_Temp_812" id="call_footnote_Temp_812"><sup><small>39</small></sup></a>
 Usually, however, the target is <tt>val</tt> (the only time the compiler
 specifies a different register is when targeting the evaluation of an
 operator to <tt>proc</tt>), so the procedure result is put directly into
@@ -905,7 +905,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 
 </p><p></p><p><tt>(assign val (op compiled-procedure-entry) (reg proc))<br />
 (goto (reg val))<br /></tt></p><p></p><p>
-<a name="%_idx_6352" id="%_idx_6352"></a><a name="%_idx_6354" id="%_idx_6354"></a>With this implementation of the <tt>return</tt> linkage, the compiler
+<a id="__idx_6352"></a><a id="__idx_6354"></a>With this implementation of the <tt>return</tt> linkage, the compiler
 generates tail-recursive code.  Calling a procedure as the final step
 in a procedure body does a direct transfer, without saving any
 information on the stack.</p><p>
@@ -917,14 +917,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 system would still give the same value for any expression.  But each
 time we called a procedure, we would save <tt>continue</tt> and return
 after the call to undo the (useless) save.  These extra saves would
-accumulate during a nest of procedure calls.<a name="call_footnote_Temp_813" href="#footnote_Temp_813" id="call_footnote_Temp_813"><sup><small>40</small></sup></a></p><p>
+accumulate during a nest of procedure calls.<a href="#footnote_Temp_813" id="call_footnote_Temp_813"><sup><small>40</small></sup></a></p><p>
 
 <tt>Compile-proc-appl</tt> generates the above procedure-application code by
 considering four cases, depending on whether the target for the call
 is <tt>val</tt> and whether the linkage is <tt>return</tt>.
 Observe that the instruction sequences are
 declared to modify all the registers, since executing the procedure
-body can change the registers in arbitrary ways.<a name="call_footnote_Temp_814" href="#footnote_Temp_814" id="call_footnote_Temp_814"><sup><small>41</small></sup></a>
+body can change the registers in arbitrary ways.<a href="#footnote_Temp_814" id="call_footnote_Temp_814"><sup><small>41</small></sup></a>
 Also note that the code sequence for the case with target <tt>val</tt>
 and linkage <tt>return</tt> is declared to need <tt>continue</tt>:  Even
 though <tt>continue</tt> is not explicitly used in the two-instruction
@@ -932,7 +932,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 value when we enter the compiled procedure.</p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_6376" id="%_idx_6376"></a>(define (compile-proc-appl target linkage)<br />
+</p><p></p><p><tt><a id="__idx_6376"></a>(define (compile-proc-appl target linkage)<br />
   (cond ((and (eq? target 'val) (not (eq? linkage 'return)))<br />
          (make-instruction-sequence '(proc) all-regs<br />
            `((assign continue (label ,linkage))<br />
@@ -960,28 +960,28 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
                 target))))<br /></tt></p><p></p><p>
 </p><p>
 
-<a name="%_sec_5.5.4" id="%_sec_5.5.4"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.5.4">5.5.4  Combining Instruction Sequences</a></h3><p>
+<a id="__sec_5.5.4"></a>
+</p><h3>5.5.4  Combining Instruction Sequences</h3><p>
 
 
-<a name="%_idx_6378" id="%_idx_6378"></a>
+<a id="__idx_6378"></a>
 This section describes the details on how instruction sequences are
 represented and combined.  Recall from
-section <a href="#%_sec_5.5.1">5.5.1</a> that an instruction sequence
+section <a href="#__sec_5.5.1">5.5.1</a> that an instruction sequence
 is represented as a list of the registers needed, the registers
 modified, and the actual instructions.  We will also consider a label
 (symbol) to be a degenerate case of an instruction sequence, which doesn't
 need or modify any registers.
 So to determine the registers needed
 and modified by instruction sequences we use the selectors
-</p><p></p><p><tt><a name="%_idx_6380" id="%_idx_6380"></a>(define (registers-needed s)<br />
-  (if (symbol? s) '() (car s)))<br /><a name="%_idx_6382" id="%_idx_6382"></a>(define (registers-modified s)<br />
-  (if (symbol? s) '() (cadr s)))<br /><a name="%_idx_6384" id="%_idx_6384"></a>(define (statements s)<br />
+</p><p></p><p><tt><a id="__idx_6380"></a>(define (registers-needed s)<br />
+  (if (symbol? s) '() (car s)))<br /><a id="__idx_6382"></a>(define (registers-modified s)<br />
+  (if (symbol? s) '() (cadr s)))<br /><a id="__idx_6384"></a>(define (statements s)<br />
   (if (symbol? s) (list s) (caddr s)))<br /></tt></p><p></p><p>
 and to determine whether a given
 sequence needs or modifies a given register we use the predicates
-</p><p></p><p><tt><a name="%_idx_6386" id="%_idx_6386"></a>(define (needs-register? seq reg)<br />
-  (memq reg (registers-needed seq)))<br /><a name="%_idx_6388" id="%_idx_6388"></a>(define (modifies-register? seq reg)<br />
+</p><p></p><p><tt><a id="__idx_6386"></a>(define (needs-register? seq reg)<br />
+  (memq reg (registers-needed seq)))<br /><a id="__idx_6388"></a>(define (modifies-register? seq reg)<br />
   (memq reg (registers-modified seq)))<br /></tt></p><p></p><p>
 In terms of these predicates and selectors, we can implement the
 various instruction sequence combiners used throughout the compiler.</p><p>
@@ -1008,7 +1008,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 registers needed by <tt>seq1</tt> with the set difference of the registers needed
 by <tt>seq2</tt> and the registers modified by <tt>seq1</tt>.)  Thus, <tt>append-instruction-sequences</tt> is implemented as follows:</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6390" id="%_idx_6390"></a>(define (append-instruction-sequences . seqs)<br />
+</p><p></p><p><tt><a id="__idx_6390"></a>(define (append-instruction-sequences . seqs)<br />
   (define (append-2-sequences seq1 seq2)<br />
     (make-instruction-sequence<br />
      (list-union (registers-needed seq1)<br />
@@ -1026,11 +1026,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 
 This procedure uses some simple operations for manipulating sets
 represented as lists, similar to the (unordered) set representation
-described in section <a href="book-Z-H-16.html#%_sec_2.3.3">2.3.3</a>:
-</p><p></p><p><tt><a name="%_idx_6392" id="%_idx_6392"></a>(define (list-union s1 s2)<br />
+described in section <a href="book-Z-H-16.html#__sec_2.3.3">2.3.3</a>:
+</p><p></p><p><tt><a id="__idx_6392"></a>(define (list-union s1 s2)<br />
   (cond ((null? s1) s2)<br />
         ((memq (car s1) s2) (list-union (cdr s1) s2))<br />
-        (else (cons (car s1) (list-union (cdr s1) s2)))))<br /><a name="%_idx_6394" id="%_idx_6394"></a>(define (list-difference s1 s2)<br />
+        (else (cons (car s1) (list-union (cdr s1) s2)))))<br /><a id="__idx_6394"></a>(define (list-difference s1 s2)<br />
   (cond ((null? s1) '())<br />
         ((memq (car s1) s2) (list-difference (cdr s1) s2))<br />
         (else (cons (car s1)<br />
@@ -1048,8 +1048,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 modified by <tt>seq1</tt> except for the ones being saved and restored.  This
 augmented sequence and <tt>seq2</tt> are then appended in the usual way.  The
 following procedure implements this strategy recursively, walking down the
-list of registers to be preserved:<a name="call_footnote_Temp_815" href="#footnote_Temp_815" id="call_footnote_Temp_815"><sup><small>42</small></sup></a>
-</p><p></p><p><tt><a name="%_idx_6398" id="%_idx_6398"></a>(define (preserving regs seq1 seq2)<br />
+list of registers to be preserved:<a href="#footnote_Temp_815" id="call_footnote_Temp_815"><sup><small>42</small></sup></a>
+</p><p></p><p><tt><a id="__idx_6398"></a>(define (preserving regs seq1 seq2)<br />
   (if (null? regs)<br />
       (append-instruction-sequences seq1 seq2)<br />
       (let ((first-reg (car regs)))<br />
@@ -1075,7 +1075,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 We thus ignore the procedure body's sets of needed and modified
 registers when we tack it onto the other sequence.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6400" id="%_idx_6400"></a>(define (tack-on-instruction-sequence seq body-seq)<br />
+</p><p></p><p><tt><a id="__idx_6400"></a>(define (tack-on-instruction-sequence seq body-seq)<br />
   (make-instruction-sequence<br />
    (registers-needed seq)<br />
    (registers-modified seq)<br />
@@ -1089,7 +1089,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 needed by the second branch are still needed by the combined sequence,
 even if these are modified by the first branch.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6402" id="%_idx_6402"></a>(define (parallel-instruction-sequences seq1 seq2)<br />
+</p><p></p><p><tt><a id="__idx_6402"></a>(define (parallel-instruction-sequences seq1 seq2)<br />
   (make-instruction-sequence<br />
    (list-union (registers-needed seq1)<br />
                (registers-needed seq2))<br />
@@ -1097,10 +1097,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
                (registers-modified seq2))<br />
    (append (statements seq1) (statements seq2))))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_sec_5.5.5" id="%_sec_5.5.5"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.5.5">5.5.5  An Example of Compiled Code</a></h3><p>
+<a id="__sec_5.5.5"></a>
+</p><h3>5.5.5  An Example of Compiled Code</h3><p>
 
-<a name="%_idx_6404" id="%_idx_6404"></a><a name="%_idx_6406" id="%_idx_6406"></a>
+<a id="__idx_6404"></a><a id="__idx_6406"></a>
 Now that we have seen all the elements of the compiler, let us examine
 an example of compiled code to see how things fit together.  We will
 compile the definition of a recursive <tt>factorial</tt> procedure by
@@ -1235,7 +1235,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 procedure is the value of the symbol <tt>*</tt>, and the arguments are
 <tt>n</tt> and the result of another procedure call (a call to <tt>factorial</tt>).
 Each of these calls sets up <tt>proc</tt> and <tt>argl</tt> and its own primitive
-and compound branches.  Figure <a href="#%_fig_5.17">5.17</a>
+and compound branches.  Figure <a href="#__fig_5.17">5.17</a>
 shows the complete compilation of the
 definition of the <tt>factorial</tt> procedure.
 Notice that the possible <tt>save</tt> and <tt>restore</tt> of
@@ -1245,7 +1245,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 <tt>return</tt> linkage in the branches.
 
 
-</p><p><a name="%_thm_5.33" id="%_thm_5.33"></a>
+</p><p><a id="__thm_5.33"></a>
 <b>Exercise 5.33.</b>  Consider the following definition of a factorial procedure, which is
 slightly different from the one given above:
 </p><p></p><p><tt>(define (factorial-alt n)<br />
@@ -1257,8 +1257,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 program execute more efficiently than the other?
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.34" id="%_thm_5.34"></a>
-<b>Exercise 5.34.</b>  <a name="%_idx_6408" id="%_idx_6408"></a><a name="%_idx_6410" id="%_idx_6410"></a>Compile the iterative factorial procedure
+</p><p><a id="__thm_5.34"></a>
+<b>Exercise 5.34.</b>  <a id="__idx_6408"></a><a id="__idx_6410"></a>Compile the iterative factorial procedure
 </p><p></p><p><tt>(define (factorial n)<br />
   (define (iter product counter)<br />
     (if (&gt; counter n)<br />
@@ -1275,7 +1275,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 
 </p><p>
 
-<a name="%_fig_5.17" id="%_fig_5.17"></a></p><p></p><div align="left"><table width="100%"><tr><td><p></p><p><tt><em>;; construct the procedure and skip over code for the procedure body</em><br />
+<a id="__fig_5.17"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><p></p><p><tt><em>;; construct the procedure and skip over code for the procedure body</em><br />
   (assign val<br />
           (op make-compiled-procedure) (label entry2) (reg env))<br />
   (goto (label after-lambda1))<br /><br />
@@ -1316,13 +1316,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
   (assign proc<br />
           (op lookup-variable-value) (const factorial) (reg env))<br />
   (save proc)  <em>; save <tt>factorial</tt> procedure</em><br /></tt></p><p></p><p>
-</p><p></p><p></p></td></tr><caption align="bottom"><div align="left"><b>Figure 5.17:</b>  Compilation of the definition of the <tt>factorial</tt>
+</p><p></p><p></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.17:</b>  Compilation of the definition of the <tt>factorial</tt>
 procedure (continued on next page).</div></caption><tr><td>
-<a name="%_idx_6412" id="%_idx_6412"></a>
+<a id="__idx_6412"></a>
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_fig_5.17" id="%_fig_5.17"></a></p><p></p><div align="left"><table width="100%"><tr><td><p></p><p><tt><em>;; compute <tt>(- n 1)</tt>, which is the argument for <tt>factorial</tt></em><br />
+<a id="__fig_5.17a"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><p></p><p><tt><em>;; compute <tt>(- n 1)</tt>, which is the argument for <tt>factorial</tt></em><br />
   (assign proc (op lookup-variable-value) (const -) (reg env))<br />
   (assign val (const 1))<br />
   (assign argl (op list) (reg val))<br />
@@ -1366,13 +1366,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
   (perform<br />
    (op define-variable!) (const factorial) (reg val) (reg env))<br />
   (assign val (const ok))<br /></tt></p><p></p><p>
-</p><p></p><p></p></td></tr><caption align="bottom"><div align="left"><b>Figure 5.17:</b>  (continued)</div></caption><tr><td>
+</p><p></p><p></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.17:</b>  (continued)</div></caption><tr><td>
 </td></tr></table></div><p></p><p>
 
-</p><p><a name="%_thm_5.35" id="%_thm_5.35"></a>
+</p><p><a id="__thm_5.35"></a>
 <b>Exercise 5.35.</b>  What expression was compiled to produce the code shown in
-figure <a href="#%_fig_5.18">5.18</a>?
-<a name="%_fig_5.18" id="%_fig_5.18"></a></p><p></p><div align="left"><table width="100%"><tr><td><p></p><p><tt>  (assign val (op make-compiled-procedure) (label entry16)<br />
+figure <a href="#__fig_5.18">5.18</a>?
+<a id="__fig_5.18"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><p></p><p><tt>  (assign val (op make-compiled-procedure) (label entry16)<br />
                                            (reg env))<br />
   (goto (label after-lambda15))<br />
 entry16<br />
@@ -1409,13 +1409,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
   (goto (reg val))<br />
 primitive-branch22<br />
   (assign val (op apply-primitive-procedure) (reg proc) (reg argl))<br /></tt></p><p></p><p>
-</p><p></p><p></p></td></tr><caption align="bottom"><div align="left"><b>Figure 5.18:</b>  An example of compiler output (continued on next page).
-See exercise <a href="#%_thm_5.35">5.35</a>.</div></caption><tr><td>
+</p><p></p><p></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.18:</b>  An example of compiler output (continued on next page).
+See exercise <a href="#__thm_5.35">5.35</a>.</div></caption><tr><td>
 
 
 </td></tr></table></div><p></p><p>
 
-<a name="%_fig_5.18" id="%_fig_5.18"></a></p><p></p><div align="left"><table width="100%"><tr><td><p></p><p><tt>after-call20<br />
+<a id="__fig_5.18a"></a></p><p></p><div style="text-align: left;"><table width="100_"><tr><td><p></p><p><tt>after-call20<br />
   (assign argl (op list) (reg val))<br />
   (restore env)<br />
   (assign val (op lookup-variable-value) (const x) (reg env))<br />
@@ -1434,23 +1434,23 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 after-lambda15<br />
   (perform (op define-variable!) (const f) (reg val) (reg env))<br />
   (assign val (const ok))<br /></tt></p><p></p><p>
-</p><p></p><p></p></td></tr><caption align="bottom"><div align="left"><b>Figure 5.18:</b>  (continued)</div></caption><tr><td>
+</p><p></p><p></p></td></tr><caption style="caption-side: bottom;"><div style="text-align: left;"><b>Figure 5.18:</b>  (continued)</div></caption><tr><td>
 </td></tr></table></div><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.36" id="%_thm_5.36"></a>
-<b>Exercise 5.36.</b>  <a name="%_idx_6414" id="%_idx_6414"></a><a name="%_idx_6416" id="%_idx_6416"></a>What order of evaluation does our compiler produce for operands of a
+</p><p><a id="__thm_5.36"></a>
+<b>Exercise 5.36.</b>  <a id="__idx_6414"></a><a id="__idx_6416"></a>What order of evaluation does our compiler produce for operands of a
 combination?  Is it left-to-right, right-to-left, or some other order?
 Where in the compiler is this order determined?  Modify the compiler
 so that it produces some other order of evaluation.  (See the
 discussion of order of evaluation for the explicit-control evaluator
-in section <a href="book-Z-H-34.html#%_sec_5.4.1">5.4.1</a>.)  How does changing the order of
+in section <a href="book-Z-H-34.html#__sec_5.4.1">5.4.1</a>.)  How does changing the order of
 operand evaluation affect the efficiency of the code that constructs
 the argument list?
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.37" id="%_thm_5.37"></a>
-<b>Exercise 5.37.</b>  <a name="%_idx_6418" id="%_idx_6418"></a><a name="%_idx_6420" id="%_idx_6420"></a>One way to understand the compiler's <tt>preserving</tt> mechanism for
+</p><p><a id="__thm_5.37"></a>
+<b>Exercise 5.37.</b>  <a id="__idx_6418"></a><a id="__idx_6420"></a>One way to understand the compiler's <tt>preserving</tt> mechanism for
 optimizing stack usage is to see what extra operations would
 be generated if we did not use this idea.  Modify <tt>preserving</tt> so
 that it always generates the <tt>save</tt> and <tt>restore</tt> operations.
@@ -1459,8 +1459,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 Compare the code to that generated with the <tt>preserving</tt> mechanism intact.
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.38" id="%_thm_5.38"></a>
-<b>Exercise 5.38.</b>  <a name="%_idx_6422" id="%_idx_6422"></a><a name="%_idx_6424" id="%_idx_6424"></a>Our compiler is clever about avoiding unnecessary stack operations,
+</p><p><a id="__thm_5.38"></a>
+<b>Exercise 5.38.</b>  <a id="__idx_6422"></a><a id="__idx_6424"></a>Our compiler is clever about avoiding unnecessary stack operations,
 but it is not clever at all when it comes to compiling calls to the primitive
 procedures of the language in terms of the primitive operations
 supplied by the machine.  For example, consider how much code is
@@ -1475,7 +1475,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 primitive arithmetic operations in the machine's data paths.  Consider
 how much less code would be generated if the compiler could <em>open-code</em> primitives – that is, if it could generate code to directly
 use these primitive machine operations.  The expression <tt>(+ a 1)</tt>
-might be compiled into something as simple as <a name="call_footnote_Temp_822" href="#footnote_Temp_822" id="call_footnote_Temp_822"><sup><small>43</small></sup></a>
+might be compiled into something as simple as <a href="#footnote_Temp_822" id="call_footnote_Temp_822"><sup><small>43</small></sup></a>
 </p><p></p><p><tt>(assign val (op lookup-variable-value) (const a) (reg env))<br />
 (assign val (op +) (reg val) (const 1))<br /></tt></p><p></p><p>
 In this exercise we will extend our compiler to support open coding of
@@ -1490,8 +1490,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 The compiler must be able to recognize the application of an
 open-coded primitive in the source program.  We will augment the
 dispatch in the <tt>compile</tt> procedure to recognize the names of
-these primitives in addition to the <a name="%_idx_6426" id="%_idx_6426"></a>reserved words (the special forms)
-it currently recognizes.<a name="call_footnote_Temp_823" href="#footnote_Temp_823" id="call_footnote_Temp_823"><sup><small>44</small></sup></a> For each special form our compiler has a code generator.  In
+these primitives in addition to the <a id="__idx_6426"></a>reserved words (the special forms)
+it currently recognizes.<a href="#footnote_Temp_823" id="call_footnote_Temp_823"><sup><small>44</small></sup></a> For each special form our compiler has a code generator.  In
 this exercise we will construct a family of code generators for the
 open-coded primitives.</p><p>
 
@@ -1522,11 +1522,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 
 </p><p></p><p>
 
-<a name="%_sec_5.5.6" id="%_sec_5.5.6"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.5.6">5.5.6  Lexical Addressing</a></h3><p>
+<a id="__sec_5.5.6"></a>
+</p><h3>5.5.6  Lexical Addressing</h3><p>
 
 
-<a name="%_idx_6428" id="%_idx_6428"></a><a name="%_idx_6430" id="%_idx_6430"></a>
+<a id="__idx_6428"></a><a id="__idx_6430"></a>
 
 One of the most common optimizations performed by compilers is the
 optimization of variable lookup.  Our compiler, as we have implemented
@@ -1557,26 +1557,26 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 determine that the symbol <tt>x</tt> is not <tt>eq?</tt> to <tt>y</tt> or <tt>z</tt> (in the first frame), nor to <tt>a</tt>, <tt>b</tt>, <tt>c</tt>, <tt>d</tt>, or
 <tt>e</tt> (in the second frame).  We will assume, for the moment, that
 our programs do not use <tt>define</tt> – that variables are
-bound only with <tt>lambda</tt>.  Because our language is <a name="%_idx_6432" id="%_idx_6432"></a>lexically
+bound only with <tt>lambda</tt>.  Because our language is <a id="__idx_6432"></a>lexically
 scoped, the run-time environment for any expression will have a
 structure that parallels the lexical structure of the program in which
-the expression appears.<a name="call_footnote_Temp_824" href="#footnote_Temp_824" id="call_footnote_Temp_824"><sup><small>45</small></sup></a>
+the expression appears.<a href="#footnote_Temp_824" id="call_footnote_Temp_824"><sup><small>45</small></sup></a>
 Thus, the compiler can know, when it analyzes the
 above expression, that each time the procedure is applied the variable
 <tt>x</tt> in <tt>(* x y z)</tt> will be found two frames out from the
 current frame and will be the first variable in that frame.</p><p>
 
-<a name="%_idx_6434" id="%_idx_6434"></a>We can exploit this fact by inventing a new kind of variable-lookup
+<a id="__idx_6434"></a>We can exploit this fact by inventing a new kind of variable-lookup
 operation, <tt>lexical-address-lookup</tt>, that takes as arguments an
 environment and a <em>lexical address</em> that consists of two numbers:
 a <em>frame number</em>, which specifies how many frames to pass over,
 and a <em>displacement number</em>, which specifies how many variables to
-pass over in that frame.  <a name="%_idx_6436" id="%_idx_6436"></a><tt>Lexical-address-lookup</tt> will produce
+pass over in that frame.  <a id="__idx_6436"></a><tt>Lexical-address-lookup</tt> will produce
 the value of the variable stored at that lexical address relative to
 the current environment.  If we add the <tt>lexical-address-lookup</tt>
 operation to our machine, we can make the compiler generate code that
 references variables using this operation, rather than <tt>lookup-variable-value</tt>.  Similarly, our compiled code can use a new
-<a name="%_idx_6438" id="%_idx_6438"></a><tt>lexical-address-set!</tt>  operation instead of <tt>set-variable-value!</tt>.</p><p>
+<a id="__idx_6438"></a><tt>lexical-address-set!</tt>  operation instead of <tt>set-variable-value!</tt>.</p><p>
 
 In order to generate such code, the compiler must be able to determine
 the lexical address of a variable it is about to compile a reference
@@ -1595,7 +1595,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
  3<br />
  4)<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_6440" id="%_idx_6440"></a>One way for the compiler to produce code that uses lexical addressing
+<a id="__idx_6440"></a>One way for the compiler to produce code that uses lexical addressing
 is to maintain a data structure called a <em>compile-time
 environment</em>.  This keeps track of which variables will be at which
 positions in which frames in the run-time environment when a
@@ -1612,34 +1612,34 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 At each point in the compilation, <tt>compile-variable</tt> and <tt>compile-assignment</tt> use the compile-time
 environment in order to generate the appropriate lexical addresses.</p><p>
 
-Exercises <a href="#%_thm_5.39">5.39</a>
-through <a href="#%_thm_5.43">5.43</a> describe how to complete this sketch of
+Exercises <a href="#__thm_5.39">5.39</a>
+through <a href="#__thm_5.43">5.43</a> describe how to complete this sketch of
 the lexical-addressing strategy in order to incorporate lexical lookup
 into the compiler.
-Exercise <a href="#%_thm_5.44">5.44</a> describes another use for the
+Exercise <a href="#__thm_5.44">5.44</a> describes another use for the
 compile-time environment.</p><p>
 
-</p><p><a name="%_thm_5.39" id="%_thm_5.39"></a>
-<b>Exercise 5.39.</b>  <a name="%_idx_6442" id="%_idx_6442"></a><a name="%_idx_6444" id="%_idx_6444"></a>Write a procedure <tt>lexical-address-lookup</tt> that implements the new
+</p><p><a id="__thm_5.39"></a>
+<b>Exercise 5.39.</b>  <a id="__idx_6442"></a><a id="__idx_6444"></a>Write a procedure <tt>lexical-address-lookup</tt> that implements the new
 lookup operation.  It should take two arguments – a lexical address
 and a run-time environment – and return the value of the variable
 stored at the specified lexical address.  <tt>Lexical-address-lookup</tt>
-should signal an error if the value of the variable is the symbol <tt>*unassigned*</tt>.<a name="call_footnote_Temp_826" href="#footnote_Temp_826" id="call_footnote_Temp_826"><sup><small>46</small></sup></a> Also write a procedure <tt>lexical-address-set!</tt> that
+should signal an error if the value of the variable is the symbol <tt>*unassigned*</tt>.<a href="#footnote_Temp_826" id="call_footnote_Temp_826"><sup><small>46</small></sup></a> Also write a procedure <tt>lexical-address-set!</tt> that
 implements the operation that changes the value of the variable at a
 specified lexical address.
 
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.40" id="%_thm_5.40"></a>
-<b>Exercise 5.40.</b>  <a name="%_idx_6450" id="%_idx_6450"></a>Modify the compiler to maintain the compile-time environment as
+</p><p><a id="__thm_5.40"></a>
+<b>Exercise 5.40.</b>  <a id="__idx_6450"></a>Modify the compiler to maintain the compile-time environment as
 described above.  That is, add a compile-time-environment argument to
 <tt>compile</tt> and the various code generators, and extend it in
 <tt>compile-lambda-body</tt>.
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.41" id="%_thm_5.41"></a>
-<b>Exercise 5.41.</b>  <a name="%_idx_6452" id="%_idx_6452"></a>Write a procedure <tt>find-variable</tt> that takes as arguments a
+</p><p><a id="__thm_5.41"></a>
+<b>Exercise 5.41.</b>  <a id="__idx_6452"></a>Write a procedure <tt>find-variable</tt> that takes as arguments a
 variable and a compile-time environment and returns the lexical
 address of the variable with respect to that environment.  For
 example, in the program fragment that is shown above, the compile-time
@@ -1651,8 +1651,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 (find-variable 'w '((y z) (a b c d e) (x y)))<br /><i>not-found</i><br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.42" id="%_thm_5.42"></a>
-<b>Exercise 5.42.</b>  Using <tt>find-variable</tt> from exercise <a href="#%_thm_5.41">5.41</a>,
+</p><p><a id="__thm_5.42"></a>
+<b>Exercise 5.42.</b>  Using <tt>find-variable</tt> from exercise <a href="#__thm_5.41">5.41</a>,
 rewrite <tt>compile-variable</tt> and <tt>compile-assignment</tt> to output
 lexical-address instructions.  In cases where <tt>find-variable</tt>
 returns <tt>not-found</tt> (that is, where the variable is not in the
@@ -1660,7 +1660,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 evaluator operations, as before, to search for the binding.
 (The only place a variable that is not found at compile time can be is in
 the global environment, which is part of the run-time environment but
-is not part of the compile-time environment.<a name="call_footnote_Temp_830" href="#footnote_Temp_830" id="call_footnote_Temp_830"><sup><small>47</small></sup></a>
+is not part of the compile-time environment.<a href="#footnote_Temp_830" id="call_footnote_Temp_830"><sup><small>47</small></sup></a>
 Thus, if you wish, you may have the evaluator operations look directly in
 the global environment, which can be obtained with the operation <tt>(op get-global-environment)</tt>, instead of having them search the whole run-time
 environment found in <tt>env</tt>.)
@@ -1669,13 +1669,13 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.43" id="%_thm_5.43"></a>
-<b>Exercise 5.43.</b>  <a name="%_idx_6454" id="%_idx_6454"></a><a name="%_idx_6456" id="%_idx_6456"></a>We argued in section <a href="book-Z-H-26.html#%_sec_4.1.6">4.1.6</a> that internal definitions
+</p><p><a id="__thm_5.43"></a>
+<b>Exercise 5.43.</b>  <a id="__idx_6454"></a><a id="__idx_6456"></a>We argued in section <a href="book-Z-H-26.html#__sec_4.1.6">4.1.6</a> that internal definitions
 for block structure should not be considered “real” <tt>define</tt>s.  Rather,
 a procedure body should be interpreted as if the internal variables being
 defined were installed as ordinary <tt>lambda</tt> variables initialized to their
-correct values using <tt>set!</tt>.  Section <a href="book-Z-H-26.html#%_sec_4.1.6">4.1.6</a> and
-exercise <a href="book-Z-H-26.html#%_thm_4.16">4.16</a> showed how to modify the metacircular
+correct values using <tt>set!</tt>.  Section <a href="book-Z-H-26.html#__sec_4.1.6">4.1.6</a> and
+exercise <a href="book-Z-H-26.html#__thm_4.16">4.16</a> showed how to modify the metacircular
 interpreter to accomplish this by scanning out internal definitions.  Modify
 the compiler to perform the same transformation before it compiles a procedure
 body.
@@ -1683,15 +1683,15 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.44" id="%_thm_5.44"></a>
-<b>Exercise 5.44.</b>  <a name="%_idx_6458" id="%_idx_6458"></a><a name="%_idx_6460" id="%_idx_6460"></a><a name="%_idx_6462" id="%_idx_6462"></a><a name="%_idx_6464" id="%_idx_6464"></a>In this section we have focused on the use of the compile-time
+</p><p><a id="__thm_5.44"></a>
+<b>Exercise 5.44.</b>  <a id="__idx_6458"></a><a id="__idx_6460"></a><a id="__idx_6462"></a><a id="__idx_6464"></a>In this section we have focused on the use of the compile-time
 environment to produce lexical addresses.  But there are other uses
 for compile-time environments.  For instance, in
-exercise <a href="#%_thm_5.38">5.38</a> we increased the efficiency of compiled
+exercise <a href="#__thm_5.38">5.38</a> we increased the efficiency of compiled
 code by open-coding primitive procedures.  Our implementation treated
 the names of open-coded procedures as reserved words.  If a program
 were to rebind such a name, the mechanism described in
-exercise <a href="#%_thm_5.38">5.38</a> would still open-code it as a primitive,
+exercise <a href="#__thm_5.38">5.38</a> would still open-code it as a primitive,
 ignoring the new binding.  For example, consider the procedure</p><p>
 
 </p><p></p><p><tt>(lambda (+ * a b x y)<br />
@@ -1706,17 +1706,17 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 
 </p><p></p><p>
 
-<a name="%_sec_5.5.7" id="%_sec_5.5.7"></a>
-</p><h3><a href="book-Z-H-4.html#%_toc_%_sec_5.5.7">5.5.7  Interfacing Compiled Code to the Evaluator</a></h3><p>
+<a id="__sec_5.5.7"></a>
+</p><h3>5.5.7  Interfacing Compiled Code to the Evaluator</h3><p>
 
 
-<a name="%_idx_6466" id="%_idx_6466"></a><a name="%_idx_6468" id="%_idx_6468"></a><a name="%_idx_6470" id="%_idx_6470"></a>
+<a id="__idx_6466"></a><a id="__idx_6468"></a><a id="__idx_6470"></a>
 We have not yet explained how to load compiled code into the evaluator machine
 or how to run it.  We will assume that the explicit-control-evaluator machine
-has been defined as in section <a href="book-Z-H-34.html#%_sec_5.4.4">5.4.4</a>, with the
+has been defined as in section <a href="book-Z-H-34.html#__sec_5.4.4">5.4.4</a>, with the
 additional operations specified in footnote <a href="#footnote_Temp_809">38</a>.
 We will implement
-a procedure <a name="%_idx_6472" id="%_idx_6472"></a><tt>compile-and-go</tt> that compiles a Scheme expression, loads the
+a procedure <a id="__idx_6472"></a><tt>compile-and-go</tt> that compiles a Scheme expression, loads the
 resulting object code into the evaluator machine,
 and causes the machine to run the code in the
 evaluator global environment, print the result, and
@@ -1736,18 +1736,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 To allow the evaluator to handle compiled procedures (for example,
 to evaluate the call to <tt>factorial</tt> above),
 we need to change the code at <tt>apply-dispatch</tt>
-(section <a href="book-Z-H-34.html#%_sec_5.4.1">5.4.1</a>) so that it recognizes
+(section <a href="book-Z-H-34.html#__sec_5.4.1">5.4.1</a>) so that it recognizes
 compiled procedures (as distinct from compound or primitive
 procedures) and transfers control directly to the entry point of the
-compiled code:<a name="call_footnote_Temp_833" href="#footnote_Temp_833" id="call_footnote_Temp_833"><sup><small>48</small></sup></a>
-</p><p></p><p><tt><a name="%_idx_6474" id="%_idx_6474"></a>apply-dispatch<br />
+compiled code:<a href="#footnote_Temp_833" id="call_footnote_Temp_833"><sup><small>48</small></sup></a>
+</p><p></p><p><tt><a id="__idx_6474"></a>apply-dispatch<br />
   (test (op primitive-procedure?) (reg proc))<br />
   (branch (label primitive-apply))<br />
   (test (op compound-procedure?) (reg proc))  <br />
   (branch (label compound-apply))<br />
   (test (op compiled-procedure?) (reg proc))  <br />
   (branch (label compiled-apply))<br />
-  (goto (label unknown-procedure-type))<br /><a name="%_idx_6476" id="%_idx_6476"></a>compiled-apply<br />
+  (goto (label unknown-procedure-type))<br /><a id="__idx_6476"></a>compiled-apply<br />
   (restore continue)<br />
   (assign val (op compiled-procedure-entry) (reg proc))<br />
   (goto (reg val))<br /></tt></p><p></p><p>
@@ -1761,7 +1761,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 To enable us to run some compiled code when we start the evaluator
 machine, we add a <tt>branch</tt> instruction at
 the beginning of the evaluator machine, which causes the machine to
-go to a new entry point if the <tt>flag</tt> register is set.<a name="call_footnote_Temp_834" href="#footnote_Temp_834" id="call_footnote_Temp_834"><sup><small>49</small></sup></a></p><p>
+go to a new entry point if the <tt>flag</tt> register is set.<a href="#footnote_Temp_834" id="call_footnote_Temp_834"><sup><small>49</small></sup></a></p><p>
 
 
 </p><p></p><p><tt>  (branch (label external-entry))      <em>; branches if <tt>flag</tt> is set</em><br />
@@ -1774,10 +1774,10 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 continue))</tt>.  Starting at this entry point jumps to the location designated
 by <tt>val</tt>, but first assigns <tt>continue</tt> so that execution will return
 to <tt>print-result</tt>, which prints the value in <tt>val</tt> and then goes to
-the beginning of the evaluator's read-eval-print loop.<a name="call_footnote_Temp_835" href="#footnote_Temp_835" id="call_footnote_Temp_835"><sup><small>50</small></sup></a></p><p>
+the beginning of the evaluator's read-eval-print loop.<a href="#footnote_Temp_835" id="call_footnote_Temp_835"><sup><small>50</small></sup></a></p><p>
 
 
-</p><p></p><p><tt><a name="%_idx_6482" id="%_idx_6482"></a>external-entry<br />
+</p><p></p><p><tt><a id="__idx_6482"></a>external-entry<br />
   (perform (op initialize-stack))<br />
   (assign env (op get-global-environment))<br />
   (assign continue (label print-result))<br />
@@ -1790,12 +1790,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 target of <tt>val</tt> and a linkage of <tt>return</tt>.  In order to transform the
 object code produced by the compiler into executable instructions for the
 evaluator register machine, we use the procedure <tt>assemble</tt> from the
-register-machine simulator (section <a href="book-Z-H-32.html#%_sec_5.2.2">5.2.2</a>).  We then initialize
+register-machine simulator (section <a href="book-Z-H-32.html#__sec_5.2.2">5.2.2</a>).  We then initialize
 the <tt>val</tt> register to point to the list of instructions, set the
 <tt>flag</tt> so that the evaluator will go to <tt>external-entry</tt>, and start
 the evaluator.</p><p>
 
-</p><p></p><p><tt><a name="%_idx_6484" id="%_idx_6484"></a>(define (compile-and-go expression)<br />
+</p><p></p><p><tt><a id="__idx_6484"></a>(define (compile-and-go expression)<br />
   (let ((instructions<br />
          (assemble (statements<br />
                     (compile expression 'val 'return))<br />
@@ -1805,8 +1805,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
     (set-register-contents! eceval 'flag true)<br />
     (start eceval)))<br /></tt></p><p></p><p></p><p>
 
-<a name="%_idx_6486" id="%_idx_6486"></a>If we have set up stack monitoring, as at the end of
-section <a href="book-Z-H-34.html#%_sec_5.4.4">5.4.4</a>, we can examine the
+<a id="__idx_6486"></a>If we have set up stack monitoring, as at the end of
+section <a href="book-Z-H-34.html#__sec_5.4.4">5.4.4</a>, we can examine the
 stack usage of compiled code:</p><p>
 
 </p><p></p><p><tt>(compile-and-go<br />
@@ -1815,19 +1815,19 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
         1<br />
         (* (factorial (- n 1)) n))))<br /><br /><i>(total-pushes = 0 maximum-depth = 0)</i><br /><i> ;;; EC-Eval value:</i><br /><i>ok</i><br /><i> ;;; EC-Eval input:</i><br />
 (factorial 5)<br /><i>(total-pushes = 31 maximum-depth = 14)</i><br /><i>;;; EC-Eval value:</i><br /><i>120</i><br /></tt></p><p></p><p>
-<a name="%_idx_6488" id="%_idx_6488"></a>Compare this example with the evaluation of <tt>(factorial 5)</tt> using
+<a id="__idx_6488"></a>Compare this example with the evaluation of <tt>(factorial 5)</tt> using
 the interpreted version of the same procedure, shown at the end of
-section <a href="book-Z-H-34.html#%_sec_5.4.4">5.4.4</a>.  The interpreted version required
+section <a href="book-Z-H-34.html#__sec_5.4.4">5.4.4</a>.  The interpreted version required
 144 pushes and a maximum stack depth of 28.  This illustrates the
 optimization that results from our compilation strategy.</p><p>
 
-<a name="%_sec_Temp_836" id="%_sec_Temp_836"></a>
-</p><h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_836">Interpretation and compilation</a></h4><p>
+<a id="__sec_Temp_836"></a>
+</p><h4>Interpretation and compilation</h4><p>
 
-<a name="%_idx_6490" id="%_idx_6490"></a><a name="%_idx_6492" id="%_idx_6492"></a>
+<a id="__idx_6490"></a><a id="__idx_6492"></a>
 With the programs in this section, we can now experiment with the
 alternative execution strategies of interpretation and
-compilation.<a name="call_footnote_Temp_837" href="#footnote_Temp_837" id="call_footnote_Temp_837"><sup><small>51</small></sup></a>  An interpreter raises
+compilation.<a href="#footnote_Temp_837" id="call_footnote_Temp_837"><sup><small>51</small></sup></a>  An interpreter raises
 the machine to the level of the user program; a compiler lowers the
 user program to the level of the machine language.  We can regard the
 Scheme language (or any programming language) as a coherent family of
@@ -1838,26 +1838,26 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 execute faster, because the steps of program execution are organized
 in terms of the machine language, and the compiler is free to make
 optimizations that cut across the higher-level
-abstractions.<a name="call_footnote_Temp_838" href="#footnote_Temp_838" id="call_footnote_Temp_838"><sup><small>52</small></sup></a></p><p>
+abstractions.<a href="#footnote_Temp_838" id="call_footnote_Temp_838"><sup><small>52</small></sup></a></p><p>
 
 
 The alternatives of interpretation and compilation also lead to
-<a name="%_idx_6504" id="%_idx_6504"></a>different strategies for porting languages to new computers. Suppose
+<a id="__idx_6504"></a>different strategies for porting languages to new computers. Suppose
 that we wish to implement Lisp for a new machine.  One strategy is
-to begin with the explicit-control evaluator of section <a href="book-Z-H-34.html#%_sec_5.4">5.4</a>
+to begin with the explicit-control evaluator of section <a href="book-Z-H-34.html#__sec_5.4">5.4</a>
 and translate its instructions to instructions for the
 new machine.  A different strategy is to begin with the compiler and
 change the code generators so that they generate code for the new
 machine.  The second strategy allows us to run any Lisp program on
 the new machine by first compiling it with the compiler running on our
 original Lisp system, and linking it with a compiled version of the
-run-time library.<a name="call_footnote_Temp_839" href="#footnote_Temp_839" id="call_footnote_Temp_839"><sup><small>53</small></sup></a>  Better yet, we can compile the compiler itself, and run
-this on the new machine to compile other Lisp programs.<a name="call_footnote_Temp_840" href="#footnote_Temp_840" id="call_footnote_Temp_840"><sup><small>54</small></sup></a>  Or we can
-compile one of the interpreters of section <a href="book-Z-H-26.html#%_sec_4.1">4.1</a> to
+run-time library.<a href="#footnote_Temp_839" id="call_footnote_Temp_839"><sup><small>53</small></sup></a>  Better yet, we can compile the compiler itself, and run
+this on the new machine to compile other Lisp programs.<a href="#footnote_Temp_840" id="call_footnote_Temp_840"><sup><small>54</small></sup></a>  Or we can
+compile one of the interpreters of section <a href="book-Z-H-26.html#__sec_4.1">4.1</a> to
 produce an interpreter that runs on the new machine.</p><p>
 
-</p><p><a name="%_thm_5.45" id="%_thm_5.45"></a>
-<b>Exercise 5.45.</b>  <a name="%_idx_6506" id="%_idx_6506"></a><a name="%_idx_6508" id="%_idx_6508"></a>By comparing the stack operations used by compiled code to the stack
+</p><p><a id="__thm_5.45"></a>
+<b>Exercise 5.45.</b>  <a id="__idx_6506"></a><a id="__idx_6508"></a>By comparing the stack operations used by compiled code to the stack
 operations used by the evaluator for the same computation, we can
 determine the extent to which the compiler optimizes use of the stack,
 both in speed (reducing the total number of stack operations) and in
@@ -1865,12 +1865,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 stack use to the performance of a special-purpose machine for the same
 computation gives some indication of the quality of the compiler.</p><p>
 
-</p><p></p><p>a. Exercise <a href="book-Z-H-34.html#%_thm_5.27">5.27</a> asked you to determine, as a function of
+</p><p></p><p>a. Exercise <a href="book-Z-H-34.html#__thm_5.27">5.27</a> asked you to determine, as a function of
 <em>n</em>, the number of pushes and the maximum stack depth needed by the
 evaluator to compute <em>n</em>! using the recursive factorial procedure
-given above.  Exercise <a href="book-Z-H-32.html#%_thm_5.14">5.14</a> asked you to do the same
+given above.  Exercise <a href="book-Z-H-32.html#__thm_5.14">5.14</a> asked you to do the same
 measurements for the special-purpose factorial machine shown in
-figure <a href="book-Z-H-31.html#%_fig_5.11">5.11</a>. Now perform the same analysis using the
+figure <a href="book-Z-H-31.html#__fig_5.11">5.11</a>. Now perform the same analysis using the
 compiled <tt>factorial</tt> procedure.</p><p>
 
 Take the ratio of the number of pushes in the compiled version to the
@@ -1893,9 +1893,9 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.46" id="%_thm_5.46"></a>
-<b>Exercise 5.46.</b>  <a name="%_idx_6510" id="%_idx_6510"></a><a name="%_idx_6512" id="%_idx_6512"></a>Carry out an analysis like the one in
-exercise <a href="#%_thm_5.45">5.45</a> to determine the effectiveness of
+</p><p><a id="__thm_5.46"></a>
+<b>Exercise 5.46.</b>  <a id="__idx_6510"></a><a id="__idx_6512"></a>Carry out an analysis like the one in
+exercise <a href="#__thm_5.45">5.45</a> to determine the effectiveness of
 compiling the tree-recursive Fibonacci procedure</p><p>
 
 </p><p></p><p><tt>(define (fib n)<br />
@@ -1903,14 +1903,14 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
       n<br />
       (+ (fib (- n 1)) (fib (- n 2)))))<br /></tt></p><p></p><p>
 compared to the effectiveness of using the special-purpose Fibonacci machine of
-figure <a href="book-Z-H-31.html#%_fig_5.12">5.12</a>.  (For measurement of the interpreted
-performance, see exercise <a href="book-Z-H-34.html#%_thm_5.29">5.29</a>.)
+figure <a href="book-Z-H-31.html#__fig_5.12">5.12</a>.  (For measurement of the interpreted
+performance, see exercise <a href="book-Z-H-34.html#__thm_5.29">5.29</a>.)
 For Fibonacci, the time resource used is not linear in <em>n</em>; hence the
 ratios of stack operations will not approach a limiting value that is
 independent of <em>n</em>.
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.47" id="%_thm_5.47"></a>
+</p><p><a id="__thm_5.47"></a>
 <b>Exercise 5.47.</b>  This section described how to modify the explicit-control evaluator so
 that interpreted code can call compiled procedures.  Show how to
 modify the compiler so that compiled procedures can call not only
@@ -1936,8 +1936,8 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.48" id="%_thm_5.48"></a>
-<b>Exercise 5.48.</b>  <a name="%_idx_6514" id="%_idx_6514"></a>The <tt>compile-and-go</tt> interface implemented in this section is
+</p><p><a id="__thm_5.48"></a>
+<b>Exercise 5.48.</b>  <a id="__idx_6514"></a>The <tt>compile-and-go</tt> interface implemented in this section is
 awkward, since the compiler can be called only once (when the
 evaluator machine is started).  Augment the compiler-interpreter
 interface by providing a <tt>compile-and-run</tt> primitive that can be
@@ -1952,7 +1952,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 (factorial 5)<br /><i>;;; EC-Eval value:</i><br /><i>120</i><br /></tt></p><p></p><p>
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.49" id="%_thm_5.49"></a>
+</p><p><a id="__thm_5.49"></a>
 <b>Exercise 5.49.</b>  As an alternative to using the explicit-control evaluator's
 read-eval-print loop, design a register machine that performs a
 read-compile-execute-print loop.  That is, the machine should run a
@@ -1964,30 +1964,30 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.50" id="%_thm_5.50"></a>
-<b>Exercise 5.50.</b>  <a name="%_idx_6516" id="%_idx_6516"></a>Use the compiler to compile the metacircular evaluator of
-section <a href="book-Z-H-26.html#%_sec_4.1">4.1</a> and run this program using the register-machine
+</p><p><a id="__thm_5.50"></a>
+<b>Exercise 5.50.</b>  <a id="__idx_6516"></a>Use the compiler to compile the metacircular evaluator of
+section <a href="book-Z-H-26.html#__sec_4.1">4.1</a> and run this program using the register-machine
 simulator.  (To compile more than one definition at a time, you can
 package the definitions in a <tt>begin</tt>.)  The resulting interpreter
 will run very slowly because of the multiple levels of interpretation,
 but getting all the details to work is an instructive exercise.
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.51" id="%_thm_5.51"></a>
-<b>Exercise 5.51.</b>  <a name="%_idx_6518" id="%_idx_6518"></a>Develop a rudimentary implementation of Scheme in C (or some other
+</p><p><a id="__thm_5.51"></a>
+<b>Exercise 5.51.</b>  <a id="__idx_6518"></a>Develop a rudimentary implementation of Scheme in C (or some other
 low-level language of your choice) by translating the explicit-control
-evaluator of section <a href="book-Z-H-34.html#%_sec_5.4">5.4</a> into C.  In order to run this code
+evaluator of section <a href="book-Z-H-34.html#__sec_5.4">5.4</a> into C.  In order to run this code
 you will need to also
 provide appropriate storage-allocation routines and other run-time
 support.
 
 </p><p></p><p>
 
-</p><p><a name="%_thm_5.52" id="%_thm_5.52"></a>
-<b>Exercise 5.52.</b>  <a name="%_idx_6520" id="%_idx_6520"></a><a name="%_idx_6522" id="%_idx_6522"></a><a name="%_idx_6524" id="%_idx_6524"></a>As a counterpoint to exercise <a href="#%_thm_5.51">5.51</a>, modify the compiler
+</p><p><a id="__thm_5.52"></a>
+<b>Exercise 5.52.</b>  <a id="__idx_6520"></a><a id="__idx_6522"></a><a id="__idx_6524"></a>As a counterpoint to exercise <a href="#__thm_5.51">5.51</a>, modify the compiler
 so that it compiles Scheme procedures into sequences of C
 instructions.  Compile the metacircular evaluator of
-section <a href="book-Z-H-26.html#%_sec_4.1">4.1</a> to produce a Scheme interpreter written in C.
+section <a href="book-Z-H-26.html#__sec_4.1">4.1</a> to produce a Scheme interpreter written in C.
 
 </p><p>
 </p><p>
@@ -1995,24 +1995,24 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 
 
 </p><p></p><div class="smallprint"><hr /></div><p>
-</p><div class="footnote"><p><a name="footnote_Temp_794" href="#call_footnote_Temp_794" id="footnote_Temp_794"><sup><small>33</small></sup></a> This is a theoretical statement.  We are not claiming
+</p><div class="footnote"><p><a href="#call_footnote_Temp_794" id="footnote_Temp_794"><sup><small>33</small></sup></a> This is a theoretical statement.  We are not claiming
 that the evaluator's data paths are a particularly convenient or
 efficient set of data paths for a general-purpose computer.  For example,
 they are not very good for implementing high-performance floating-point
 calculations or calculations that intensively manipulate bit vectors.
 
-</p><p><a name="footnote_Temp_795" href="#call_footnote_Temp_795" id="footnote_Temp_795"><sup><small>34</small></sup></a> Actually, the machine that runs
+</p><p><a href="#call_footnote_Temp_795" id="footnote_Temp_795"><sup><small>34</small></sup></a> Actually, the machine that runs
 compiled code can be simpler than the interpreter machine, because we
-<a name="%_idx_6220" id="%_idx_6220"></a>won't use the <tt>exp</tt> and <tt>unev</tt> registers.  The interpreter
+<a id="__idx_6220"></a>won't use the <tt>exp</tt> and <tt>unev</tt> registers.  The interpreter
 used these to hold pieces of unevaluated expressions.  With the
 compiler, however, these expressions get built into the
 compiled code that the register machine will run.  For the same
-reason, <a name="%_idx_6222" id="%_idx_6222"></a>we don't need the machine operations that deal with expression
+reason, <a id="__idx_6222"></a>we don't need the machine operations that deal with expression
 syntax.  But compiled code will use a few additional machine
 operations (to represent compiled procedure objects) that didn't
 appear in the explicit-control evaluator machine.
 
-</p><p><a name="footnote_Temp_797" href="#call_footnote_Temp_797" id="footnote_Temp_797"><sup><small>35</small></sup></a> Notice, however, that our
+</p><p><a href="#call_footnote_Temp_797" id="footnote_Temp_797"><sup><small>35</small></sup></a> Notice, however, that our
 compiler is a Scheme program, and the syntax procedures that it uses
 to manipulate expressions are the actual Scheme procedures used with
 the metacircular evaluator.  For the explicit-control evaluator, in
@@ -2021,7 +2021,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 the register machine in Scheme, we used the actual Scheme procedures
 in our register machine simulation.)
 
-</p><p><a name="footnote_Temp_803" href="#call_footnote_Temp_803" id="footnote_Temp_803"><sup><small>36</small></sup></a> This procedure uses a feature of Lisp called <em><a name="%_idx_6280" id="%_idx_6280"></a><a name="%_idx_6282" id="%_idx_6282"></a><a name="%_idx_6284" id="%_idx_6284"></a><a name="%_idx_6286" id="%_idx_6286"></a><a name="%_idx_6288" id="%_idx_6288"></a><a name="%_idx_6290" id="%_idx_6290"></a>backquote</em> (or <em>quasiquote</em>) that is handy for constructing lists.
+</p><p><a href="#call_footnote_Temp_803" id="footnote_Temp_803"><sup><small>36</small></sup></a> This procedure uses a feature of Lisp called <em><a id="__idx_6280"></a><a id="__idx_6282"></a><a id="__idx_6284"></a><a id="__idx_6286"></a><a id="__idx_6288"></a><a id="__idx_6290"></a>backquote</em> (or <em>quasiquote</em>) that is handy for constructing lists.
 Preceding a list with a backquote symbol is much like quoting it,
 except that anything in the list that is flagged with a comma is evaluated.</p><p>
 
@@ -2035,11 +2035,11 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 evaluates to the list
 <tt>(1 2 a)</tt>.
 
-</p><p><a name="footnote_Temp_806" href="#call_footnote_Temp_806" id="footnote_Temp_806"><sup><small>37</small></sup></a> We can't just
+</p><p><a href="#call_footnote_Temp_806" id="footnote_Temp_806"><sup><small>37</small></sup></a> We can't just
 use the labels <tt>true-branch</tt>, <tt>false-branch</tt>, and
 <tt>after-if</tt> as shown above,
 because there might be more than one <tt>if</tt> in the program.
-<a name="%_idx_6318" id="%_idx_6318"></a>The compiler uses the procedure <tt>make-label</tt> to generate labels.
+<a id="__idx_6318"></a>The compiler uses the procedure <tt>make-label</tt> to generate labels.
 <tt>Make-label</tt> takes a symbol as argument and returns a new symbol
 that begins with the given symbol.  For example, successive calls to
 <tt>(make-label 'a)</tt> would return <tt>a1</tt>, <tt>a2</tt>, and so on.
@@ -2048,32 +2048,32 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 </p><p></p><p><tt>(define label-counter 0)<br /><br />
 (define (new-label-number)<br />
   (set! label-counter (+ 1 label-counter))<br />
-  label-counter)<br /><br /><a name="%_idx_6320" id="%_idx_6320"></a><a name="%_idx_6322" id="%_idx_6322"></a>(define (make-label name)<br />
+  label-counter)<br /><br /><a id="__idx_6320"></a><a id="__idx_6322"></a>(define (make-label name)<br />
   (string-&gt;symbol<br />
     (string-append (symbol-&gt;string name)<br />
                    (number-&gt;string (new-label-number)))))<br /></tt></p><p></p><p>
 
 
-</p><p><a name="footnote_Temp_809" href="#call_footnote_Temp_809" id="footnote_Temp_809"><sup><small>38</small></sup></a> We need machine operations to implement a data
+</p><p><a href="#call_footnote_Temp_809" id="footnote_Temp_809"><sup><small>38</small></sup></a> We need machine operations to implement a data
 structure for representing compiled procedures, analogous to the structure for
-compound procedures described in section <a href="book-Z-H-26.html#%_sec_4.1.3">4.1.3</a>:
-</p><p></p><p><tt><a name="%_idx_6332" id="%_idx_6332"></a>(define (make-compiled-procedure entry env)<br />
-  (list 'compiled-procedure entry env))<br /><br /><a name="%_idx_6334" id="%_idx_6334"></a>(define (compiled-procedure? proc)<br />
-  (tagged-list? proc 'compiled-procedure))<br /><br /><a name="%_idx_6336" id="%_idx_6336"></a>(define (compiled-procedure-entry c-proc) (cadr c-proc))<br /><br /><a name="%_idx_6338" id="%_idx_6338"></a>(define (compiled-procedure-env c-proc) (caddr c-proc))<br /></tt></p><p></p><p>
+compound procedures described in section <a href="book-Z-H-26.html#__sec_4.1.3">4.1.3</a>:
+</p><p></p><p><tt><a id="__idx_6332"></a>(define (make-compiled-procedure entry env)<br />
+  (list 'compiled-procedure entry env))<br /><br /><a id="__idx_6334"></a>(define (compiled-procedure? proc)<br />
+  (tagged-list? proc 'compiled-procedure))<br /><br /><a id="__idx_6336"></a>(define (compiled-procedure-entry c-proc) (cadr c-proc))<br /><br /><a id="__idx_6338"></a>(define (compiled-procedure-env c-proc) (caddr c-proc))<br /></tt></p><p></p><p>
 
 
-</p><p><a name="footnote_Temp_812" href="#call_footnote_Temp_812" id="footnote_Temp_812"><sup><small>39</small></sup></a> Actually, we signal an error when the target is not <tt>val</tt>
+</p><p><a href="#call_footnote_Temp_812" id="footnote_Temp_812"><sup><small>39</small></sup></a> Actually, we signal an error when the target is not <tt>val</tt>
 and the linkage is <tt>return</tt>, since
 the only place we request <tt>return</tt> linkages is in compiling
 procedures, and our convention is that procedures return their
 values in <tt>val</tt>.
 
-</p><p><a name="footnote_Temp_813" href="#call_footnote_Temp_813" id="footnote_Temp_813"><sup><small>40</small></sup></a> Making a
-<a name="%_idx_6356" id="%_idx_6356"></a>compiler generate tail-recursive code might seem like a
+</p><p><a href="#call_footnote_Temp_813" id="footnote_Temp_813"><sup><small>40</small></sup></a> Making a
+<a id="__idx_6356"></a>compiler generate tail-recursive code might seem like a
 straightforward idea.  But most compilers for common languages,
 including C and Pascal, do not do this, and therefore these languages
 cannot represent iterative processes in terms of procedure call alone.
-The difficulty with <a name="%_idx_6358" id="%_idx_6358"></a><a name="%_idx_6360" id="%_idx_6360"></a><a name="%_idx_6362" id="%_idx_6362"></a>tail recursion in these languages is that their
+The difficulty with <a id="__idx_6358"></a><a id="__idx_6360"></a><a id="__idx_6362"></a>tail recursion in these languages is that their
 implementations use the stack to store procedure arguments and local
 variables as well as return addresses.  The Scheme implementations
 described in this book store arguments and variables in memory to be
@@ -2082,75 +2082,75 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 languages that would not otherwise require it, and is generally
 believed to be more efficient.  Sophisticated Lisp compilers can, in
 fact, use the stack for arguments without destroying tail recursion.
-(See <a name="%_idx_6364" id="%_idx_6364"></a>Hanson 1990 for a description.)  There is also some debate about
+(See <a id="__idx_6364"></a>Hanson 1990 for a description.)  There is also some debate about
 whether stack allocation is actually more efficient than garbage
 collection in the first place, but the details seem to hinge on fine
-points of computer architecture.  (See <a name="%_idx_6366" id="%_idx_6366"></a>Appel 1987 and <a name="%_idx_6368" id="%_idx_6368"></a><a name="%_idx_6370" id="%_idx_6370"></a>Miller and Rozas
+points of computer architecture.  (See <a id="__idx_6366"></a>Appel 1987 and <a id="__idx_6368"></a><a id="__idx_6370"></a>Miller and Rozas
 1994 for opposing views on this issue.)
 
-</p><p><a name="footnote_Temp_814" href="#call_footnote_Temp_814" id="footnote_Temp_814"><sup><small>41</small></sup></a> The variable
-<a name="%_idx_6372" id="%_idx_6372"></a><tt>all-regs</tt> is bound to the list of names of all the registers:
-</p><p></p><p><tt><a name="%_idx_6374" id="%_idx_6374"></a>(define all-regs '(env proc val argl continue))<br /></tt></p><p></p><p>
+</p><p><a href="#call_footnote_Temp_814" id="footnote_Temp_814"><sup><small>41</small></sup></a> The variable
+<a id="__idx_6372"></a><tt>all-regs</tt> is bound to the list of names of all the registers:
+</p><p></p><p><tt><a id="__idx_6374"></a>(define all-regs '(env proc val argl continue))<br /></tt></p><p></p><p>
 
 
-</p><p><a name="footnote_Temp_815" href="#call_footnote_Temp_815" id="footnote_Temp_815"><sup><small>42</small></sup></a> Note that <tt>preserving</tt> calls <tt>append</tt> with three
-<a name="%_idx_6396" id="%_idx_6396"></a>arguments.  Though the definition of <tt>append</tt> shown in this book
+</p><p><a href="#call_footnote_Temp_815" id="footnote_Temp_815"><sup><small>42</small></sup></a> Note that <tt>preserving</tt> calls <tt>append</tt> with three
+<a id="__idx_6396"></a>arguments.  Though the definition of <tt>append</tt> shown in this book
 accepts only two arguments, Scheme standardly provides an <tt>append</tt>
 procedure that takes an arbitrary number of arguments.
 
-</p><p><a name="footnote_Temp_822" href="#call_footnote_Temp_822" id="footnote_Temp_822"><sup><small>43</small></sup></a> We have used
+</p><p><a href="#call_footnote_Temp_822" id="footnote_Temp_822"><sup><small>43</small></sup></a> We have used
 the same symbol <tt>+</tt> here to denote both the source-language
 procedure and the machine operation.  In general there will not be a
 one-to-one correspondence between primitives of the source language
 and primitives of the machine.
 
-</p><p><a name="footnote_Temp_823" href="#call_footnote_Temp_823" id="footnote_Temp_823"><sup><small>44</small></sup></a> Making the primitives into reserved
+</p><p><a href="#call_footnote_Temp_823" id="footnote_Temp_823"><sup><small>44</small></sup></a> Making the primitives into reserved
 words is in general a bad idea, since a user cannot then rebind these
 names to different procedures.  Moreover, if we add reserved words to
 a compiler that is in use, existing programs that define procedures
 with these names will stop working.  See
-exercise <a href="#%_thm_5.44">5.44</a> for ideas on how to avoid this
+exercise <a href="#__thm_5.44">5.44</a> for ideas on how to avoid this
 problem.
 
-</p><p><a name="footnote_Temp_824" href="#call_footnote_Temp_824" id="footnote_Temp_824"><sup><small>45</small></sup></a> This is not true if we allow
+</p><p><a href="#call_footnote_Temp_824" id="footnote_Temp_824"><sup><small>45</small></sup></a> This is not true if we allow
 internal definitions, unless we scan them out.
-See exercise <a href="#%_thm_5.43">5.43</a>.
+See exercise <a href="#__thm_5.43">5.43</a>.
 
-</p><p><a name="footnote_Temp_826" href="#call_footnote_Temp_826" id="footnote_Temp_826"><sup><small>46</small></sup></a> This is the modification to variable lookup
-<a name="%_idx_6446" id="%_idx_6446"></a><a name="%_idx_6448" id="%_idx_6448"></a>required if we implement the scanning method to eliminate internal
-definitions (exercise <a href="#%_thm_5.43">5.43</a>).  We will need
+</p><p><a href="#call_footnote_Temp_826" id="footnote_Temp_826"><sup><small>46</small></sup></a> This is the modification to variable lookup
+<a id="__idx_6446"></a><a id="__idx_6448"></a>required if we implement the scanning method to eliminate internal
+definitions (exercise <a href="#__thm_5.43">5.43</a>).  We will need
 to eliminate these definitions in order for lexical addressing to
 work.
 
-</p><p><a name="footnote_Temp_830" href="#call_footnote_Temp_830" id="footnote_Temp_830"><sup><small>47</small></sup></a> Lexical addresses cannot be used to access variables in the global
+</p><p><a href="#call_footnote_Temp_830" id="footnote_Temp_830"><sup><small>47</small></sup></a> Lexical addresses cannot be used to access variables in the global
 environment, because these names can be defined and redefined
 interactively at any time.  With internal definitions scanned out, as
-in exercise <a href="#%_thm_5.43">5.43</a>, the only definitions the
+in exercise <a href="#__thm_5.43">5.43</a>, the only definitions the
 compiler sees are those at top level, which act on the global
 environment.  Compilation of a definition does not cause the defined
 name to be entered in the compile-time environment.
 
-</p><p><a name="footnote_Temp_833" href="#call_footnote_Temp_833" id="footnote_Temp_833"><sup><small>48</small></sup></a> Of course, compiled procedures as well as interpreted
+</p><p><a href="#call_footnote_Temp_833" id="footnote_Temp_833"><sup><small>48</small></sup></a> Of course, compiled procedures as well as interpreted
 procedures are compound (nonprimitive).  For compatibility with
 the terminology used in the explicit-control evaluator, in this
 section we will use “compound” to mean interpreted (as opposed
 to compiled).
 
-</p><p><a name="footnote_Temp_834" href="#call_footnote_Temp_834" id="footnote_Temp_834"><sup><small>49</small></sup></a> Now that the evaluator machine starts
+</p><p><a href="#call_footnote_Temp_834" id="footnote_Temp_834"><sup><small>49</small></sup></a> Now that the evaluator machine starts
 with a <tt>branch</tt>, we must always initialize the <tt>flag</tt> register
 before starting the evaluator machine.  To start the machine at
 its ordinary read-eval-print loop, we could use
-</p><p></p><p><tt><a name="%_idx_6478" id="%_idx_6478"></a>(define (start-eceval)<br />
+</p><p></p><p><tt><a id="__idx_6478"></a>(define (start-eceval)<br />
   (set! the-global-environment (setup-environment))<br />
   (set-register-contents! eceval 'flag false)<br />
   (start eceval))<br /></tt></p><p></p><p>
 
-</p><p><a name="footnote_Temp_835" href="#call_footnote_Temp_835" id="footnote_Temp_835"><sup><small>50</small></sup></a> Since a compiled procedure is an
+</p><p><a href="#call_footnote_Temp_835" id="footnote_Temp_835"><sup><small>50</small></sup></a> Since a compiled procedure is an
 object that the system may try to print, we also modify the system
-print operation <tt>user-print</tt> (from section <a href="book-Z-H-26.html#%_sec_4.1.4">4.1.4</a>)
+print operation <tt>user-print</tt> (from section <a href="book-Z-H-26.html#__sec_4.1.4">4.1.4</a>)
 so that it will not attempt to print the
 components of a compiled procedure:
-</p><p></p><p><tt><a name="%_idx_6480" id="%_idx_6480"></a>(define (user-print object)<br />
+</p><p></p><p><tt><a id="__idx_6480"></a>(define (user-print object)<br />
   (cond ((compound-procedure? object)<br />
          (display (list 'compound-procedure<br />
                         (procedure-parameters object)<br />
@@ -2161,12 +2161,12 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
         (else (display object))))<br /></tt></p><p></p><p>
 
 
-</p><p><a name="footnote_Temp_837" href="#call_footnote_Temp_837" id="footnote_Temp_837"><sup><small>51</small></sup></a> We can do even better by extending the compiler
+</p><p><a href="#call_footnote_Temp_837" id="footnote_Temp_837"><sup><small>51</small></sup></a> We can do even better by extending the compiler
 to allow compiled code to call interpreted procedures.  See
-exercise <a href="#%_thm_5.47">5.47</a>.
+exercise <a href="#__thm_5.47">5.47</a>.
 
-</p><p><a name="footnote_Temp_838" href="#call_footnote_Temp_838" id="footnote_Temp_838"><sup><small>52</small></sup></a> Independent of the strategy of execution, we
-<a name="%_idx_6494" id="%_idx_6494"></a>incur significant overhead if we insist that errors encountered in
+</p><p><a href="#call_footnote_Temp_838" id="footnote_Temp_838"><sup><small>52</small></sup></a> Independent of the strategy of execution, we
+<a id="__idx_6494"></a>incur significant overhead if we insist that errors encountered in
 execution of a user program be detected and signaled, rather than being
 allowed to kill the system or produce wrong answers.  For example, an
 out-of-bounds array reference can be detected by checking the validity
@@ -2178,18 +2178,18 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 programmers to control the extent and type of error checking in the
 compiled code.</p><p>
 
-<a name="%_idx_6496" id="%_idx_6496"></a>Compilers for popular languages, such as C and C++,
+<a id="__idx_6496"></a>Compilers for popular languages, such as C and C++,
 put hardly any error-checking operations into
 running code, so as to make things run as fast as possible.  As a
 result, it falls to programmers to explicitly provide error checking.
 Unfortunately, people often neglect to do this, even in
 critical applications where speed is not a constraint.  Their programs
-lead fast and dangerous lives.  For example, the notorious <a name="%_idx_6498" id="%_idx_6498"></a>“Worm”
-that paralyzed the Internet in 1988 exploited the <a name="%_idx_6500" id="%_idx_6500"></a>UNIX<sup><em>T</em><em>M</em></sup>
+lead fast and dangerous lives.  For example, the notorious <a id="__idx_6498"></a>“Worm”
+that paralyzed the Internet in 1988 exploited the <a id="__idx_6500"></a>UNIX<sup><em>T</em><em>M</em></sup>
 operating system's failure to check whether the input buffer has
-<a name="%_idx_6502" id="%_idx_6502"></a>overflowed in the finger daemon. (See Spafford 1989.)
+<a id="__idx_6502"></a>overflowed in the finger daemon. (See Spafford 1989.)
 
-</p><p><a name="footnote_Temp_839" href="#call_footnote_Temp_839" id="footnote_Temp_839"><sup><small>53</small></sup></a> Of course, with either the
+</p><p><a href="#call_footnote_Temp_839" id="footnote_Temp_839"><sup><small>53</small></sup></a> Of course, with either the
 interpretation or the compilation strategy we must also implement for
 the new machine storage allocation, input and output, and all the
 various operations that we took as “primitive” in our discussion of
@@ -2200,7 +2200,7 @@ <h2><a href="book-Z-H-4.html#%_toc_%_sec_5.5">5.5  Compilation</a></h2><p>
 applying actual machine primitives) that is hand-coded for the new
 machine.
 
-</p><p><a name="footnote_Temp_840" href="#call_footnote_Temp_840" id="footnote_Temp_840"><sup><small>54</small></sup></a>
+</p><p><a href="#call_footnote_Temp_840" id="footnote_Temp_840"><sup><small>54</small></sup></a>
 This strategy leads to amusing tests of correctness of
 the compiler, such as checking
 whether the compilation of a program on the new machine, using the
diff --git a/src/OEBPS/book-Z-H-36.html b/src/OEBPS/book-Z-H-36.html
index caf89f0..511a0ec 100644
--- a/src/OEBPS/book-Z-H-36.html
+++ b/src/OEBPS/book-Z-H-36.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,10 +13,10 @@
 
 
 
-<a name="%_chap_Temp_849" id="%_chap_Temp_849"></a>
+<a id="__chap_Temp_849"></a>
 <h1 class="chapter">
 <div class="chapterheading"> </div></h1><p>
-<a href="book-Z-H-4.html#%_toc_%_chap_Temp_849">References</a></p><p>
+References</p><p>
 
 </p><p>
 
diff --git a/src/OEBPS/book-Z-H-37.html b/src/OEBPS/book-Z-H-37.html
index 18b5839..23a9c3e 100644
--- a/src/OEBPS/book-Z-H-37.html
+++ b/src/OEBPS/book-Z-H-37.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,204 +13,204 @@
 
 
 
-<a name="%_chap_Temp_850" id="%_chap_Temp_850"></a>
+<a id="__chap_Temp_850"></a>
 <h1 class="chapter">
 <div class="chapterheading"> </div></h1><p>
-<a href="book-Z-H-4.html#%_toc_%_chap_Temp_850">List of Exercises</a></p><p>
+List of Exercises</p><p>
 
-<a href="book-Z-H-10.html#%_thm_1.1">1.1</a><br /><a href="book-Z-H-10.html#%_thm_1.2">1.2</a><br /><a href="book-Z-H-10.html#%_thm_1.3">1.3</a><br /><a href="book-Z-H-10.html#%_thm_1.4">1.4</a><br /><a href="book-Z-H-10.html#%_thm_1.5">1.5</a><br /><a href="book-Z-H-10.html#%_thm_1.6">1.6</a><br /><a href="book-Z-H-10.html#%_thm_1.7">1.7</a><br /><a href="book-Z-H-10.html#%_thm_1.8">1.8</a><br /><a href="book-Z-H-11.html#%_thm_1.9">1.9</a><br /><a href="book-Z-H-11.html#%_thm_1.10">1.10</a><br /><a href="book-Z-H-11.html#%_thm_1.11">1.11</a><br /><a href="book-Z-H-11.html#%_thm_1.12">1.12</a><br /><a href="book-Z-H-11.html#%_thm_1.13">1.13</a><br /><a href="book-Z-H-11.html#%_thm_1.14">1.14</a><br /><a href="book-Z-H-11.html#%_thm_1.15">1.15</a><br /><a href="book-Z-H-11.html#%_thm_1.16">1.16</a><br /><a href="book-Z-H-11.html#%_thm_1.17">1.17</a><br /><a href="book-Z-H-11.html#%_thm_1.18">1.18</a><br /><a href="book-Z-H-11.html#%_thm_1.19">1.19</a><br /><a href="book-Z-H-11.html#%_thm_1.20">1.20</a><br /><a href="book-Z-H-11.html#%_thm_1.21">1.21</a><br /><a href="book-Z-H-11.html#%_thm_1.22">1.22</a><br /><a href="book-Z-H-11.html#%_thm_1.23">1.23</a><br /><a href="book-Z-H-11.html#%_thm_1.24">1.24</a><br /><a href="book-Z-H-11.html#%_thm_1.25">1.25</a><br /><a href="book-Z-H-11.html#%_thm_1.26">1.26</a><br /><a href="book-Z-H-11.html#%_thm_1.27">1.27</a><br /><a href="book-Z-H-11.html#%_thm_1.28">1.28</a><br /><a href="book-Z-H-12.html#%_thm_1.29">1.29</a><br /><a href="book-Z-H-12.html#%_thm_1.30">1.30</a><br /><a href="book-Z-H-12.html#%_thm_1.31">1.31</a><br /><a href="book-Z-H-12.html#%_thm_1.32">1.32</a><br /><a href="book-Z-H-12.html#%_thm_1.33">1.33</a><br /><a href="book-Z-H-12.html#%_thm_1.34">1.34</a><br /><a href="book-Z-H-12.html#%_thm_1.35">1.35</a><br /><a href="book-Z-H-12.html#%_thm_1.36">1.36</a><br /><a href="book-Z-H-12.html#%_thm_1.37">1.37</a><br /><a href="book-Z-H-12.html#%_thm_1.38">1.38</a><br /><a href="book-Z-H-12.html#%_thm_1.39">1.39</a><br /><a href="book-Z-H-12.html#%_thm_1.40">1.40</a><br /><a href="book-Z-H-12.html#%_thm_1.41">1.41</a><br /><a href="book-Z-H-12.html#%_thm_1.42">1.42</a><br /><a href="book-Z-H-12.html#%_thm_1.43">1.43</a><br /><a href="book-Z-H-12.html#%_thm_1.44">1.44</a><br /><a href="book-Z-H-12.html#%_thm_1.45">1.45</a><br /><a href="book-Z-H-12.html#%_thm_1.46">1.46</a><br /><a href="book-Z-H-14.html#%_thm_2.1">2.1</a><br /><a href="book-Z-H-14.html#%_thm_2.2">2.2</a><br /><a href="book-Z-H-14.html#%_thm_2.3">2.3</a><br /><a href="book-Z-H-14.html#%_thm_2.4">2.4</a><br /><a href="book-Z-H-14.html#%_thm_2.5">2.5</a><br /><a href="book-Z-H-14.html#%_thm_2.6">2.6</a><br /><a href="book-Z-H-14.html#%_thm_2.7">2.7</a><br /><a href="book-Z-H-14.html#%_thm_2.8">2.8</a><br /><a href="book-Z-H-14.html#%_thm_2.9">2.9</a><br /><a href="book-Z-H-14.html#%_thm_2.10">2.10</a><br /><a href="book-Z-H-14.html#%_thm_2.11">2.11</a><br /><a href="book-Z-H-14.html#%_thm_2.12">2.12</a><br /><a href="book-Z-H-14.html#%_thm_2.13">2.13</a><br /><a href="book-Z-H-14.html#%_thm_2.14">2.14</a><br /><a href="book-Z-H-14.html#%_thm_2.15">2.15</a><br /><a href="book-Z-H-14.html#%_thm_2.16">2.16</a><br /><a href="book-Z-H-15.html#%_thm_2.17">2.17</a><br /><a href="book-Z-H-15.html#%_thm_2.18">2.18</a><br /><a href="book-Z-H-15.html#%_thm_2.19">2.19</a><br /><a href="book-Z-H-15.html#%_thm_2.20">2.20</a><br /><a href="book-Z-H-15.html#%_thm_2.21">2.21</a><br /><a href="book-Z-H-15.html#%_thm_2.22">2.22</a><br /><a href="book-Z-H-15.html#%_thm_2.23">2.23</a><br /><a href="book-Z-H-15.html#%_thm_2.24">2.24</a><br /><a href="book-Z-H-15.html#%_thm_2.25">2.25</a><br /><a href="book-Z-H-15.html#%_thm_2.26">2.26</a><br /><a href="book-Z-H-15.html#%_thm_2.27">2.27</a><br /><a href="book-Z-H-15.html#%_thm_2.28">2.28</a><br /><a href="book-Z-H-15.html#%_thm_2.29">2.29</a><br /><a href="book-Z-H-15.html#%_thm_2.30">2.30</a><br /><a href="book-Z-H-15.html#%_thm_2.31">2.31</a><br /><a href="book-Z-H-15.html#%_thm_2.32">2.32</a><br /><a href="book-Z-H-15.html#%_thm_2.33">2.33</a><br /><a href="book-Z-H-15.html#%_thm_2.34">2.34</a><br /><a href="book-Z-H-15.html#%_thm_2.35">2.35</a><br /><a href="book-Z-H-15.html#%_thm_2.36">2.36</a><br /><a href="book-Z-H-15.html#%_thm_2.37">2.37</a><br /><a href="book-Z-H-15.html#%_thm_2.38">2.38</a><br /><a href="book-Z-H-15.html#%_thm_2.39">2.39</a><br /><a href="book-Z-H-15.html#%_thm_2.40">2.40</a><br /><a href="book-Z-H-15.html#%_thm_2.41">2.41</a><br /><a href="book-Z-H-15.html#%_thm_2.42">2.42</a><br /><a href="book-Z-H-15.html#%_thm_2.43">2.43</a><br /><a href="book-Z-H-15.html#%_thm_2.44">2.44</a><br /><a href="book-Z-H-15.html#%_thm_2.45">2.45</a><br /><a href="book-Z-H-15.html#%_thm_2.46">2.46</a><br /><a href="book-Z-H-15.html#%_thm_2.47">2.47</a><br /><a href="book-Z-H-15.html#%_thm_2.48">2.48</a><br /><a href="book-Z-H-15.html#%_thm_2.49">2.49</a><br /><a href="book-Z-H-15.html#%_thm_2.50">2.50</a><br /><a href="book-Z-H-15.html#%_thm_2.51">2.51</a><br /><a href="book-Z-H-15.html#%_thm_2.52">2.52</a><br /><a href="book-Z-H-16.html#%_thm_2.53">2.53</a><br /><a href="book-Z-H-16.html#%_thm_2.54">2.54</a><br /><a href="book-Z-H-16.html#%_thm_2.55">2.55</a><br /><a href="book-Z-H-16.html#%_thm_2.56">2.56</a><br /><a href="book-Z-H-16.html#%_thm_2.57">2.57</a><br /><a href="book-Z-H-16.html#%_thm_2.58">2.58</a><br /><a href="book-Z-H-16.html#%_thm_2.59">2.59</a><br /><a href="book-Z-H-16.html#%_thm_2.60">2.60</a><br /><a href="book-Z-H-16.html#%_thm_2.61">2.61</a><br /><a href="book-Z-H-16.html#%_thm_2.62">2.62</a><br /><a href="book-Z-H-16.html#%_thm_2.63">2.63</a><br /><a href="book-Z-H-16.html#%_thm_2.64">2.64</a><br /><a href="book-Z-H-16.html#%_thm_2.65">2.65</a><br /><a href="book-Z-H-16.html#%_thm_2.66">2.66</a><br /><a href="book-Z-H-16.html#%_thm_2.67">2.67</a><br /><a href="book-Z-H-16.html#%_thm_2.68">2.68</a><br /><a href="book-Z-H-16.html#%_thm_2.69">2.69</a><br /><a href="book-Z-H-16.html#%_thm_2.70">2.70</a><br /><a href="book-Z-H-16.html#%_thm_2.71">2.71</a><br /><a href="book-Z-H-16.html#%_thm_2.72">2.72</a><br /><a href="book-Z-H-17.html#%_thm_2.73">2.73</a><br /><a href="book-Z-H-17.html#%_thm_2.74">2.74</a><br /><a href="book-Z-H-17.html#%_thm_2.75">2.75</a><br /><a href="book-Z-H-17.html#%_thm_2.76">2.76</a><br /><a href="book-Z-H-18.html#%_thm_2.77">2.77</a><br /><a href="book-Z-H-18.html#%_thm_2.78">2.78</a><br /><a href="book-Z-H-18.html#%_thm_2.79">2.79</a><br /><a href="book-Z-H-18.html#%_thm_2.80">2.80</a><br /><a href="book-Z-H-18.html#%_thm_2.81">2.81</a><br /><a href="book-Z-H-18.html#%_thm_2.82">2.82</a><br /><a href="book-Z-H-18.html#%_thm_2.83">2.83</a><br /><a href="book-Z-H-18.html#%_thm_2.84">2.84</a><br /><a href="book-Z-H-18.html#%_thm_2.85">2.85</a><br /><a href="book-Z-H-18.html#%_thm_2.86">2.86</a><br /><a href="book-Z-H-18.html#%_thm_2.87">2.87</a><br /><a href="book-Z-H-18.html#%_thm_2.88">2.88</a><br /><a href="book-Z-H-18.html#%_thm_2.89">2.89</a><br /><a href="book-Z-H-18.html#%_thm_2.90">2.90</a><br /><a href="book-Z-H-18.html#%_thm_2.91">2.91</a><br /><a href="book-Z-H-18.html#%_thm_2.92">2.92</a><br /><a href="book-Z-H-18.html#%_thm_2.93">2.93</a><br /><a href="book-Z-H-18.html#%_thm_2.94">2.94</a><br /><a href="book-Z-H-18.html#%_thm_2.95">2.95</a><br /><a href="book-Z-H-18.html#%_thm_2.96">2.96</a><br /><a href="book-Z-H-18.html#%_thm_2.97">2.97</a><br /><a href="book-Z-H-20.html#%_thm_3.1">3.1</a><br /><a href="book-Z-H-20.html#%_thm_3.2">3.2</a><br /><a href="book-Z-H-20.html#%_thm_3.3">3.3</a><br /><a href="book-Z-H-20.html#%_thm_3.4">3.4</a><br /><a href="book-Z-H-20.html#%_thm_3.5">3.5</a><br /><a href="book-Z-H-20.html#%_thm_3.6">3.6</a><br /><a href="book-Z-H-20.html#%_thm_3.7">3.7</a><br /><a href="book-Z-H-20.html#%_thm_3.8">3.8</a><br /><a href="book-Z-H-21.html#%_thm_3.9">3.9</a><br /><a href="book-Z-H-21.html#%_thm_3.10">3.10</a><br /><a href="book-Z-H-21.html#%_thm_3.11">3.11</a><br /><a href="book-Z-H-22.html#%_thm_3.12">3.12</a><br /><a href="book-Z-H-22.html#%_thm_3.13">3.13</a><br /><a href="book-Z-H-22.html#%_thm_3.14">3.14</a><br /><a href="book-Z-H-22.html#%_thm_3.15">3.15</a><br /><a href="book-Z-H-22.html#%_thm_3.16">3.16</a><br /><a href="book-Z-H-22.html#%_thm_3.17">3.17</a><br /><a href="book-Z-H-22.html#%_thm_3.18">3.18</a><br /><a href="book-Z-H-22.html#%_thm_3.19">3.19</a><br /><a href="book-Z-H-22.html#%_thm_3.20">3.20</a><br /><a href="book-Z-H-22.html#%_thm_3.21">3.21</a><br /><a href="book-Z-H-22.html#%_thm_3.22">3.22</a><br /><a href="book-Z-H-22.html#%_thm_3.23">3.23</a><br /><a href="book-Z-H-22.html#%_thm_3.24">3.24</a><br /><a href="book-Z-H-22.html#%_thm_3.25">3.25</a><br /><a href="book-Z-H-22.html#%_thm_3.26">3.26</a><br /><a href="book-Z-H-22.html#%_thm_3.27">3.27</a><br /><a href="book-Z-H-22.html#%_thm_3.28">3.28</a><br /><a href="book-Z-H-22.html#%_thm_3.29">3.29</a><br /><a href="book-Z-H-22.html#%_thm_3.30">3.30</a><br /><a href="book-Z-H-22.html#%_thm_3.31">3.31</a><br /><a href="book-Z-H-22.html#%_thm_3.32">3.32</a><br /><a href="book-Z-H-22.html#%_thm_3.33">3.33</a><br /><a href="book-Z-H-22.html#%_thm_3.34">3.34</a><br /><a href="book-Z-H-22.html#%_thm_3.35">3.35</a><br /><a href="book-Z-H-22.html#%_thm_3.36">3.36</a><br /><a href="book-Z-H-22.html#%_thm_3.37">3.37</a><br /><a href="book-Z-H-23.html#%_thm_3.38">3.38</a><br /><a href="book-Z-H-23.html#%_thm_3.39">3.39</a><br /><a href="book-Z-H-23.html#%_thm_3.40">3.40</a><br /><a href="book-Z-H-23.html#%_thm_3.41">3.41</a><br /><a href="book-Z-H-23.html#%_thm_3.42">3.42</a><br /><a href="book-Z-H-23.html#%_thm_3.43">3.43</a><br /><a href="book-Z-H-23.html#%_thm_3.44">3.44</a><br /><a href="book-Z-H-23.html#%_thm_3.45">3.45</a><br /><a href="book-Z-H-23.html#%_thm_3.46">3.46</a><br /><a href="book-Z-H-23.html#%_thm_3.47">3.47</a><br /><a href="book-Z-H-23.html#%_thm_3.48">3.48</a><br /><a href="book-Z-H-23.html#%_thm_3.49">3.49</a><br /><a href="book-Z-H-24.html#%_thm_3.50">3.50</a><br /><a href="book-Z-H-24.html#%_thm_3.51">3.51</a><br /><a href="book-Z-H-24.html#%_thm_3.52">3.52</a><br /><a href="book-Z-H-24.html#%_thm_3.53">3.53</a><br /><a href="book-Z-H-24.html#%_thm_3.54">3.54</a><br /><a href="book-Z-H-24.html#%_thm_3.55">3.55</a><br /><a href="book-Z-H-24.html#%_thm_3.56">3.56</a><br /><a href="book-Z-H-24.html#%_thm_3.57">3.57</a><br /><a href="book-Z-H-24.html#%_thm_3.58">3.58</a><br /><a href="book-Z-H-24.html#%_thm_3.59">3.59</a><br /><a href="book-Z-H-24.html#%_thm_3.60">3.60</a><br /><a href="book-Z-H-24.html#%_thm_3.61">3.61</a><br /><a href="book-Z-H-24.html#%_thm_3.62">3.62</a><br /><a href="book-Z-H-24.html#%_thm_3.63">3.63</a><br /><a href="book-Z-H-24.html#%_thm_3.64">3.64</a><br /><a href="book-Z-H-24.html#%_thm_3.65">3.65</a><br /><a href="book-Z-H-24.html#%_thm_3.66">3.66</a><br /><a href="book-Z-H-24.html#%_thm_3.67">3.67</a><br /><a href="book-Z-H-24.html#%_thm_3.68">3.68</a><br /><a href="book-Z-H-24.html#%_thm_3.69">3.69</a><br /><a href="book-Z-H-24.html#%_thm_3.70">3.70</a><br /><a href="book-Z-H-24.html#%_thm_3.71">3.71</a><br /><a href="book-Z-H-24.html#%_thm_3.72">3.72</a><br /><a href="book-Z-H-24.html#%_thm_3.73">3.73</a><br /><a href="book-Z-H-24.html#%_thm_3.74">3.74</a><br /><a href="book-Z-H-24.html#%_thm_3.75">3.75</a><br /><a href="book-Z-H-24.html#%_thm_3.76">3.76</a><br /><a href="book-Z-H-24.html#%_thm_3.77">3.77</a><br /><a href="book-Z-H-24.html#%_thm_3.78">3.78</a><br /><a href="book-Z-H-24.html#%_thm_3.79">3.79</a><br /><a href="book-Z-H-24.html#%_thm_3.80">3.80</a><br /><a href="book-Z-H-24.html#%_thm_3.81">3.81</a><br /><a href="book-Z-H-24.html#%_thm_3.82">3.82</a><br /><a href="book-Z-H-26.html#%_thm_4.1">4.1</a><br /><a href="book-Z-H-26.html#%_thm_4.2">4.2</a><br /><a href="book-Z-H-26.html#%_thm_4.3">4.3</a><br /><a href="book-Z-H-26.html#%_thm_4.4">4.4</a><br /><a href="book-Z-H-26.html#%_thm_4.5">4.5</a><br /><a href="book-Z-H-26.html#%_thm_4.6">4.6</a><br /><a href="book-Z-H-26.html#%_thm_4.7">4.7</a><br /><a href="book-Z-H-26.html#%_thm_4.8">4.8</a><br /><a href="book-Z-H-26.html#%_thm_4.9">4.9</a><br /><a href="book-Z-H-26.html#%_thm_4.10">4.10</a><br /><a href="book-Z-H-26.html#%_thm_4.11">4.11</a><br /><a href="book-Z-H-26.html#%_thm_4.12">4.12</a><br /><a href="book-Z-H-26.html#%_thm_4.13">4.13</a><br /><a href="book-Z-H-26.html#%_thm_4.14">4.14</a><br /><a href="book-Z-H-26.html#%_thm_4.15">4.15</a><br /><a href="book-Z-H-26.html#%_thm_4.16">4.16</a><br /><a href="book-Z-H-26.html#%_thm_4.17">4.17</a><br /><a href="book-Z-H-26.html#%_thm_4.18">4.18</a><br /><a href="book-Z-H-26.html#%_thm_4.19">4.19</a><br /><a href="book-Z-H-26.html#%_thm_4.20">4.20</a><br /><a href="book-Z-H-26.html#%_thm_4.21">4.21</a><br /><a href="book-Z-H-26.html#%_thm_4.22">4.22</a><br /><a href="book-Z-H-26.html#%_thm_4.23">4.23</a><br /><a href="book-Z-H-26.html#%_thm_4.24">4.24</a><br /><a href="book-Z-H-27.html#%_thm_4.25">4.25</a><br /><a href="book-Z-H-27.html#%_thm_4.26">4.26</a><br /><a href="book-Z-H-27.html#%_thm_4.27">4.27</a><br /><a href="book-Z-H-27.html#%_thm_4.28">4.28</a><br /><a href="book-Z-H-27.html#%_thm_4.29">4.29</a><br /><a href="book-Z-H-27.html#%_thm_4.30">4.30</a><br /><a href="book-Z-H-27.html#%_thm_4.31">4.31</a><br /><a href="book-Z-H-27.html#%_thm_4.32">4.32</a><br /><a href="book-Z-H-27.html#%_thm_4.33">4.33</a><br /><a href="book-Z-H-27.html#%_thm_4.34">4.34</a><br /><a href="book-Z-H-28.html#%_thm_4.35">4.35</a><br /><a href="book-Z-H-28.html#%_thm_4.36">4.36</a><br /><a href="book-Z-H-28.html#%_thm_4.37">4.37</a><br /><a href="book-Z-H-28.html#%_thm_4.38">4.38</a><br /><a href="book-Z-H-28.html#%_thm_4.39">4.39</a><br /><a href="book-Z-H-28.html#%_thm_4.40">4.40</a><br /><a href="book-Z-H-28.html#%_thm_4.41">4.41</a><br /><a href="book-Z-H-28.html#%_thm_4.42">4.42</a><br /><a href="book-Z-H-28.html#%_thm_4.43">4.43</a><br /><a href="book-Z-H-28.html#%_thm_4.44">4.44</a><br /><a href="book-Z-H-28.html#%_thm_4.45">4.45</a><br /><a href="book-Z-H-28.html#%_thm_4.46">4.46</a><br /><a href="book-Z-H-28.html#%_thm_4.47">4.47</a><br /><a href="book-Z-H-28.html#%_thm_4.48">4.48</a><br /><a href="book-Z-H-28.html#%_thm_4.49">4.49</a><br /><a href="book-Z-H-28.html#%_thm_4.50">4.50</a><br /><a href="book-Z-H-28.html#%_thm_4.51">4.51</a><br /><a href="book-Z-H-28.html#%_thm_4.52">4.52</a><br /><a href="book-Z-H-28.html#%_thm_4.53">4.53</a><br /><a href="book-Z-H-28.html#%_thm_4.54">4.54</a><br /><a href="book-Z-H-29.html#%_thm_4.55">4.55</a><br /><a href="book-Z-H-29.html#%_thm_4.56">4.56</a><br /><a href="book-Z-H-29.html#%_thm_4.57">4.57</a><br /><a href="book-Z-H-29.html#%_thm_4.58">4.58</a><br /><a href="book-Z-H-29.html#%_thm_4.59">4.59</a><br /><a href="book-Z-H-29.html#%_thm_4.60">4.60</a><br /><a href="book-Z-H-29.html#%_thm_4.61">4.61</a><br /><a href="book-Z-H-29.html#%_thm_4.62">4.62</a><br /><a href="book-Z-H-29.html#%_thm_4.63">4.63</a><br /><a href="book-Z-H-29.html#%_thm_4.64">4.64</a><br /><a href="book-Z-H-29.html#%_thm_4.65">4.65</a><br /><a href="book-Z-H-29.html#%_thm_4.66">4.66</a><br /><a href="book-Z-H-29.html#%_thm_4.67">4.67</a><br /><a href="book-Z-H-29.html#%_thm_4.68">4.68</a><br /><a href="book-Z-H-29.html#%_thm_4.69">4.69</a><br /><a href="book-Z-H-29.html#%_thm_4.70">4.70</a><br /><a href="book-Z-H-29.html#%_thm_4.71">4.71</a><br /><a href="book-Z-H-29.html#%_thm_4.72">4.72</a><br /><a href="book-Z-H-29.html#%_thm_4.73">4.73</a><br /><a href="book-Z-H-29.html#%_thm_4.74">4.74</a><br /><a href="book-Z-H-29.html#%_thm_4.75">4.75</a><br /><a href="book-Z-H-29.html#%_thm_4.76">4.76</a><br /><a href="book-Z-H-29.html#%_thm_4.77">4.77</a><br /><a href="book-Z-H-29.html#%_thm_4.78">4.78</a><br /><a href="book-Z-H-29.html#%_thm_4.79">4.79</a><br /><a href="book-Z-H-31.html#%_thm_5.1">5.1</a><br /><a href="book-Z-H-31.html#%_thm_5.2">5.2</a><br /><a href="book-Z-H-31.html#%_thm_5.3">5.3</a><br /><a href="book-Z-H-31.html#%_thm_5.4">5.4</a><br /><a href="book-Z-H-31.html#%_thm_5.5">5.5</a><br /><a href="book-Z-H-31.html#%_thm_5.6">5.6</a><br /><a href="book-Z-H-32.html#%_thm_5.7">5.7</a><br /><a href="book-Z-H-32.html#%_thm_5.8">5.8</a><br /><a href="book-Z-H-32.html#%_thm_5.9">5.9</a><br /><a href="book-Z-H-32.html#%_thm_5.10">5.10</a><br /><a href="book-Z-H-32.html#%_thm_5.11">5.11</a><br /><a href="book-Z-H-32.html#%_thm_5.12">5.12</a><br /><a href="book-Z-H-32.html#%_thm_5.13">5.13</a><br /><a href="book-Z-H-32.html#%_thm_5.14">5.14</a><br /><a href="book-Z-H-32.html#%_thm_5.15">5.15</a><br /><a href="book-Z-H-32.html#%_thm_5.16">5.16</a><br /><a href="book-Z-H-32.html#%_thm_5.17">5.17</a><br /><a href="book-Z-H-32.html#%_thm_5.18">5.18</a><br /><a href="book-Z-H-32.html#%_thm_5.19">5.19</a><br /><a href="book-Z-H-33.html#%_thm_5.20">5.20</a><br /><a href="book-Z-H-33.html#%_thm_5.21">5.21</a><br /><a href="book-Z-H-33.html#%_thm_5.22">5.22</a><br /><a href="book-Z-H-34.html#%_thm_5.23">5.23</a><br /><a href="book-Z-H-34.html#%_thm_5.24">5.24</a><br /><a href="book-Z-H-34.html#%_thm_5.25">5.25</a><br /><a href="book-Z-H-34.html#%_thm_5.26">5.26</a><br /><a href="book-Z-H-34.html#%_thm_5.27">5.27</a><br /><a href="book-Z-H-34.html#%_thm_5.28">5.28</a><br /><a href="book-Z-H-34.html#%_thm_5.29">5.29</a><br /><a href="book-Z-H-34.html#%_thm_5.30">5.30</a><br /><a href="book-Z-H-35.html#%_thm_5.31">5.31</a><br /><a href="book-Z-H-35.html#%_thm_5.32">5.32</a><br /><a href="book-Z-H-35.html#%_thm_5.33">5.33</a><br /><a href="book-Z-H-35.html#%_thm_5.34">5.34</a><br /><a href="book-Z-H-35.html#%_thm_5.35">5.35</a><br /><a href="book-Z-H-35.html#%_thm_5.36">5.36</a><br /><a href="book-Z-H-35.html#%_thm_5.37">5.37</a><br /><a href="book-Z-H-35.html#%_thm_5.38">5.38</a><br /><a href="book-Z-H-35.html#%_thm_5.39">5.39</a><br /><a href="book-Z-H-35.html#%_thm_5.40">5.40</a><br /><a href="book-Z-H-35.html#%_thm_5.41">5.41</a><br /><a href="book-Z-H-35.html#%_thm_5.42">5.42</a><br /><a href="book-Z-H-35.html#%_thm_5.43">5.43</a><br /><a href="book-Z-H-35.html#%_thm_5.44">5.44</a><br /><a href="book-Z-H-35.html#%_thm_5.45">5.45</a><br /><a href="book-Z-H-35.html#%_thm_5.46">5.46</a><br /><a href="book-Z-H-35.html#%_thm_5.47">5.47</a><br /><a href="book-Z-H-35.html#%_thm_5.48">5.48</a><br /><a href="book-Z-H-35.html#%_thm_5.49">5.49</a><br /><a href="book-Z-H-35.html#%_thm_5.50">5.50</a><br /><a href="book-Z-H-35.html#%_thm_5.51">5.51</a><br /><a href="book-Z-H-35.html#%_thm_5.52">5.52</a><br /><a name="%_idx_6526" id="%_idx_6526"></a>
-<a name="%_idx_6528" id="%_idx_6528"></a>
-<a name="%_idx_6530" id="%_idx_6530"></a>
-<a name="%_idx_6532" id="%_idx_6532"></a></p><p>
+<a href="book-Z-H-10.html#__thm_1.1">1.1</a><br /><a href="book-Z-H-10.html#__thm_1.2">1.2</a><br /><a href="book-Z-H-10.html#__thm_1.3">1.3</a><br /><a href="book-Z-H-10.html#__thm_1.4">1.4</a><br /><a href="book-Z-H-10.html#__thm_1.5">1.5</a><br /><a href="book-Z-H-10.html#__thm_1.6">1.6</a><br /><a href="book-Z-H-10.html#__thm_1.7">1.7</a><br /><a href="book-Z-H-10.html#__thm_1.8">1.8</a><br /><a href="book-Z-H-11.html#__thm_1.9">1.9</a><br /><a href="book-Z-H-11.html#__thm_1.10">1.10</a><br /><a href="book-Z-H-11.html#__thm_1.11">1.11</a><br /><a href="book-Z-H-11.html#__thm_1.12">1.12</a><br /><a href="book-Z-H-11.html#__thm_1.13">1.13</a><br /><a href="book-Z-H-11.html#__thm_1.14">1.14</a><br /><a href="book-Z-H-11.html#__thm_1.15">1.15</a><br /><a href="book-Z-H-11.html#__thm_1.16">1.16</a><br /><a href="book-Z-H-11.html#__thm_1.17">1.17</a><br /><a href="book-Z-H-11.html#__thm_1.18">1.18</a><br /><a href="book-Z-H-11.html#__thm_1.19">1.19</a><br /><a href="book-Z-H-11.html#__thm_1.20">1.20</a><br /><a href="book-Z-H-11.html#__thm_1.21">1.21</a><br /><a href="book-Z-H-11.html#__thm_1.22">1.22</a><br /><a href="book-Z-H-11.html#__thm_1.23">1.23</a><br /><a href="book-Z-H-11.html#__thm_1.24">1.24</a><br /><a href="book-Z-H-11.html#__thm_1.25">1.25</a><br /><a href="book-Z-H-11.html#__thm_1.26">1.26</a><br /><a href="book-Z-H-11.html#__thm_1.27">1.27</a><br /><a href="book-Z-H-11.html#__thm_1.28">1.28</a><br /><a href="book-Z-H-12.html#__thm_1.29">1.29</a><br /><a href="book-Z-H-12.html#__thm_1.30">1.30</a><br /><a href="book-Z-H-12.html#__thm_1.31">1.31</a><br /><a href="book-Z-H-12.html#__thm_1.32">1.32</a><br /><a href="book-Z-H-12.html#__thm_1.33">1.33</a><br /><a href="book-Z-H-12.html#__thm_1.34">1.34</a><br /><a href="book-Z-H-12.html#__thm_1.35">1.35</a><br /><a href="book-Z-H-12.html#__thm_1.36">1.36</a><br /><a href="book-Z-H-12.html#__thm_1.37">1.37</a><br /><a href="book-Z-H-12.html#__thm_1.38">1.38</a><br /><a href="book-Z-H-12.html#__thm_1.39">1.39</a><br /><a href="book-Z-H-12.html#__thm_1.40">1.40</a><br /><a href="book-Z-H-12.html#__thm_1.41">1.41</a><br /><a href="book-Z-H-12.html#__thm_1.42">1.42</a><br /><a href="book-Z-H-12.html#__thm_1.43">1.43</a><br /><a href="book-Z-H-12.html#__thm_1.44">1.44</a><br /><a href="book-Z-H-12.html#__thm_1.45">1.45</a><br /><a href="book-Z-H-12.html#__thm_1.46">1.46</a><br /><a href="book-Z-H-14.html#__thm_2.1">2.1</a><br /><a href="book-Z-H-14.html#__thm_2.2">2.2</a><br /><a href="book-Z-H-14.html#__thm_2.3">2.3</a><br /><a href="book-Z-H-14.html#__thm_2.4">2.4</a><br /><a href="book-Z-H-14.html#__thm_2.5">2.5</a><br /><a href="book-Z-H-14.html#__thm_2.6">2.6</a><br /><a href="book-Z-H-14.html#__thm_2.7">2.7</a><br /><a href="book-Z-H-14.html#__thm_2.8">2.8</a><br /><a href="book-Z-H-14.html#__thm_2.9">2.9</a><br /><a href="book-Z-H-14.html#__thm_2.10">2.10</a><br /><a href="book-Z-H-14.html#__thm_2.11">2.11</a><br /><a href="book-Z-H-14.html#__thm_2.12">2.12</a><br /><a href="book-Z-H-14.html#__thm_2.13">2.13</a><br /><a href="book-Z-H-14.html#__thm_2.14">2.14</a><br /><a href="book-Z-H-14.html#__thm_2.15">2.15</a><br /><a href="book-Z-H-14.html#__thm_2.16">2.16</a><br /><a href="book-Z-H-15.html#__thm_2.17">2.17</a><br /><a href="book-Z-H-15.html#__thm_2.18">2.18</a><br /><a href="book-Z-H-15.html#__thm_2.19">2.19</a><br /><a href="book-Z-H-15.html#__thm_2.20">2.20</a><br /><a href="book-Z-H-15.html#__thm_2.21">2.21</a><br /><a href="book-Z-H-15.html#__thm_2.22">2.22</a><br /><a href="book-Z-H-15.html#__thm_2.23">2.23</a><br /><a href="book-Z-H-15.html#__thm_2.24">2.24</a><br /><a href="book-Z-H-15.html#__thm_2.25">2.25</a><br /><a href="book-Z-H-15.html#__thm_2.26">2.26</a><br /><a href="book-Z-H-15.html#__thm_2.27">2.27</a><br /><a href="book-Z-H-15.html#__thm_2.28">2.28</a><br /><a href="book-Z-H-15.html#__thm_2.29">2.29</a><br /><a href="book-Z-H-15.html#__thm_2.30">2.30</a><br /><a href="book-Z-H-15.html#__thm_2.31">2.31</a><br /><a href="book-Z-H-15.html#__thm_2.32">2.32</a><br /><a href="book-Z-H-15.html#__thm_2.33">2.33</a><br /><a href="book-Z-H-15.html#__thm_2.34">2.34</a><br /><a href="book-Z-H-15.html#__thm_2.35">2.35</a><br /><a href="book-Z-H-15.html#__thm_2.36">2.36</a><br /><a href="book-Z-H-15.html#__thm_2.37">2.37</a><br /><a href="book-Z-H-15.html#__thm_2.38">2.38</a><br /><a href="book-Z-H-15.html#__thm_2.39">2.39</a><br /><a href="book-Z-H-15.html#__thm_2.40">2.40</a><br /><a href="book-Z-H-15.html#__thm_2.41">2.41</a><br /><a href="book-Z-H-15.html#__thm_2.42">2.42</a><br /><a href="book-Z-H-15.html#__thm_2.43">2.43</a><br /><a href="book-Z-H-15.html#__thm_2.44">2.44</a><br /><a href="book-Z-H-15.html#__thm_2.45">2.45</a><br /><a href="book-Z-H-15.html#__thm_2.46">2.46</a><br /><a href="book-Z-H-15.html#__thm_2.47">2.47</a><br /><a href="book-Z-H-15.html#__thm_2.48">2.48</a><br /><a href="book-Z-H-15.html#__thm_2.49">2.49</a><br /><a href="book-Z-H-15.html#__thm_2.50">2.50</a><br /><a href="book-Z-H-15.html#__thm_2.51">2.51</a><br /><a href="book-Z-H-15.html#__thm_2.52">2.52</a><br /><a href="book-Z-H-16.html#__thm_2.53">2.53</a><br /><a href="book-Z-H-16.html#__thm_2.54">2.54</a><br /><a href="book-Z-H-16.html#__thm_2.55">2.55</a><br /><a href="book-Z-H-16.html#__thm_2.56">2.56</a><br /><a href="book-Z-H-16.html#__thm_2.57">2.57</a><br /><a href="book-Z-H-16.html#__thm_2.58">2.58</a><br /><a href="book-Z-H-16.html#__thm_2.59">2.59</a><br /><a href="book-Z-H-16.html#__thm_2.60">2.60</a><br /><a href="book-Z-H-16.html#__thm_2.61">2.61</a><br /><a href="book-Z-H-16.html#__thm_2.62">2.62</a><br /><a href="book-Z-H-16.html#__thm_2.63">2.63</a><br /><a href="book-Z-H-16.html#__thm_2.64">2.64</a><br /><a href="book-Z-H-16.html#__thm_2.65">2.65</a><br /><a href="book-Z-H-16.html#__thm_2.66">2.66</a><br /><a href="book-Z-H-16.html#__thm_2.67">2.67</a><br /><a href="book-Z-H-16.html#__thm_2.68">2.68</a><br /><a href="book-Z-H-16.html#__thm_2.69">2.69</a><br /><a href="book-Z-H-16.html#__thm_2.70">2.70</a><br /><a href="book-Z-H-16.html#__thm_2.71">2.71</a><br /><a href="book-Z-H-16.html#__thm_2.72">2.72</a><br /><a href="book-Z-H-17.html#__thm_2.73">2.73</a><br /><a href="book-Z-H-17.html#__thm_2.74">2.74</a><br /><a href="book-Z-H-17.html#__thm_2.75">2.75</a><br /><a href="book-Z-H-17.html#__thm_2.76">2.76</a><br /><a href="book-Z-H-18.html#__thm_2.77">2.77</a><br /><a href="book-Z-H-18.html#__thm_2.78">2.78</a><br /><a href="book-Z-H-18.html#__thm_2.79">2.79</a><br /><a href="book-Z-H-18.html#__thm_2.80">2.80</a><br /><a href="book-Z-H-18.html#__thm_2.81">2.81</a><br /><a href="book-Z-H-18.html#__thm_2.82">2.82</a><br /><a href="book-Z-H-18.html#__thm_2.83">2.83</a><br /><a href="book-Z-H-18.html#__thm_2.84">2.84</a><br /><a href="book-Z-H-18.html#__thm_2.85">2.85</a><br /><a href="book-Z-H-18.html#__thm_2.86">2.86</a><br /><a href="book-Z-H-18.html#__thm_2.87">2.87</a><br /><a href="book-Z-H-18.html#__thm_2.88">2.88</a><br /><a href="book-Z-H-18.html#__thm_2.89">2.89</a><br /><a href="book-Z-H-18.html#__thm_2.90">2.90</a><br /><a href="book-Z-H-18.html#__thm_2.91">2.91</a><br /><a href="book-Z-H-18.html#__thm_2.92">2.92</a><br /><a href="book-Z-H-18.html#__thm_2.93">2.93</a><br /><a href="book-Z-H-18.html#__thm_2.94">2.94</a><br /><a href="book-Z-H-18.html#__thm_2.95">2.95</a><br /><a href="book-Z-H-18.html#__thm_2.96">2.96</a><br /><a href="book-Z-H-18.html#__thm_2.97">2.97</a><br /><a href="book-Z-H-20.html#__thm_3.1">3.1</a><br /><a href="book-Z-H-20.html#__thm_3.2">3.2</a><br /><a href="book-Z-H-20.html#__thm_3.3">3.3</a><br /><a href="book-Z-H-20.html#__thm_3.4">3.4</a><br /><a href="book-Z-H-20.html#__thm_3.5">3.5</a><br /><a href="book-Z-H-20.html#__thm_3.6">3.6</a><br /><a href="book-Z-H-20.html#__thm_3.7">3.7</a><br /><a href="book-Z-H-20.html#__thm_3.8">3.8</a><br /><a href="book-Z-H-21.html#__thm_3.9">3.9</a><br /><a href="book-Z-H-21.html#__thm_3.10">3.10</a><br /><a href="book-Z-H-21.html#__thm_3.11">3.11</a><br /><a href="book-Z-H-22.html#__thm_3.12">3.12</a><br /><a href="book-Z-H-22.html#__thm_3.13">3.13</a><br /><a href="book-Z-H-22.html#__thm_3.14">3.14</a><br /><a href="book-Z-H-22.html#__thm_3.15">3.15</a><br /><a href="book-Z-H-22.html#__thm_3.16">3.16</a><br /><a href="book-Z-H-22.html#__thm_3.17">3.17</a><br /><a href="book-Z-H-22.html#__thm_3.18">3.18</a><br /><a href="book-Z-H-22.html#__thm_3.19">3.19</a><br /><a href="book-Z-H-22.html#__thm_3.20">3.20</a><br /><a href="book-Z-H-22.html#__thm_3.21">3.21</a><br /><a href="book-Z-H-22.html#__thm_3.22">3.22</a><br /><a href="book-Z-H-22.html#__thm_3.23">3.23</a><br /><a href="book-Z-H-22.html#__thm_3.24">3.24</a><br /><a href="book-Z-H-22.html#__thm_3.25">3.25</a><br /><a href="book-Z-H-22.html#__thm_3.26">3.26</a><br /><a href="book-Z-H-22.html#__thm_3.27">3.27</a><br /><a href="book-Z-H-22.html#__thm_3.28">3.28</a><br /><a href="book-Z-H-22.html#__thm_3.29">3.29</a><br /><a href="book-Z-H-22.html#__thm_3.30">3.30</a><br /><a href="book-Z-H-22.html#__thm_3.31">3.31</a><br /><a href="book-Z-H-22.html#__thm_3.32">3.32</a><br /><a href="book-Z-H-22.html#__thm_3.33">3.33</a><br /><a href="book-Z-H-22.html#__thm_3.34">3.34</a><br /><a href="book-Z-H-22.html#__thm_3.35">3.35</a><br /><a href="book-Z-H-22.html#__thm_3.36">3.36</a><br /><a href="book-Z-H-22.html#__thm_3.37">3.37</a><br /><a href="book-Z-H-23.html#__thm_3.38">3.38</a><br /><a href="book-Z-H-23.html#__thm_3.39">3.39</a><br /><a href="book-Z-H-23.html#__thm_3.40">3.40</a><br /><a href="book-Z-H-23.html#__thm_3.41">3.41</a><br /><a href="book-Z-H-23.html#__thm_3.42">3.42</a><br /><a href="book-Z-H-23.html#__thm_3.43">3.43</a><br /><a href="book-Z-H-23.html#__thm_3.44">3.44</a><br /><a href="book-Z-H-23.html#__thm_3.45">3.45</a><br /><a href="book-Z-H-23.html#__thm_3.46">3.46</a><br /><a href="book-Z-H-23.html#__thm_3.47">3.47</a><br /><a href="book-Z-H-23.html#__thm_3.48">3.48</a><br /><a href="book-Z-H-23.html#__thm_3.49">3.49</a><br /><a href="book-Z-H-24.html#__thm_3.50">3.50</a><br /><a href="book-Z-H-24.html#__thm_3.51">3.51</a><br /><a href="book-Z-H-24.html#__thm_3.52">3.52</a><br /><a href="book-Z-H-24.html#__thm_3.53">3.53</a><br /><a href="book-Z-H-24.html#__thm_3.54">3.54</a><br /><a href="book-Z-H-24.html#__thm_3.55">3.55</a><br /><a href="book-Z-H-24.html#__thm_3.56">3.56</a><br /><a href="book-Z-H-24.html#__thm_3.57">3.57</a><br /><a href="book-Z-H-24.html#__thm_3.58">3.58</a><br /><a href="book-Z-H-24.html#__thm_3.59">3.59</a><br /><a href="book-Z-H-24.html#__thm_3.60">3.60</a><br /><a href="book-Z-H-24.html#__thm_3.61">3.61</a><br /><a href="book-Z-H-24.html#__thm_3.62">3.62</a><br /><a href="book-Z-H-24.html#__thm_3.63">3.63</a><br /><a href="book-Z-H-24.html#__thm_3.64">3.64</a><br /><a href="book-Z-H-24.html#__thm_3.65">3.65</a><br /><a href="book-Z-H-24.html#__thm_3.66">3.66</a><br /><a href="book-Z-H-24.html#__thm_3.67">3.67</a><br /><a href="book-Z-H-24.html#__thm_3.68">3.68</a><br /><a href="book-Z-H-24.html#__thm_3.69">3.69</a><br /><a href="book-Z-H-24.html#__thm_3.70">3.70</a><br /><a href="book-Z-H-24.html#__thm_3.71">3.71</a><br /><a href="book-Z-H-24.html#__thm_3.72">3.72</a><br /><a href="book-Z-H-24.html#__thm_3.73">3.73</a><br /><a href="book-Z-H-24.html#__thm_3.74">3.74</a><br /><a href="book-Z-H-24.html#__thm_3.75">3.75</a><br /><a href="book-Z-H-24.html#__thm_3.76">3.76</a><br /><a href="book-Z-H-24.html#__thm_3.77">3.77</a><br /><a href="book-Z-H-24.html#__thm_3.78">3.78</a><br /><a href="book-Z-H-24.html#__thm_3.79">3.79</a><br /><a href="book-Z-H-24.html#__thm_3.80">3.80</a><br /><a href="book-Z-H-24.html#__thm_3.81">3.81</a><br /><a href="book-Z-H-24.html#__thm_3.82">3.82</a><br /><a href="book-Z-H-26.html#__thm_4.1">4.1</a><br /><a href="book-Z-H-26.html#__thm_4.2">4.2</a><br /><a href="book-Z-H-26.html#__thm_4.3">4.3</a><br /><a href="book-Z-H-26.html#__thm_4.4">4.4</a><br /><a href="book-Z-H-26.html#__thm_4.5">4.5</a><br /><a href="book-Z-H-26.html#__thm_4.6">4.6</a><br /><a href="book-Z-H-26.html#__thm_4.7">4.7</a><br /><a href="book-Z-H-26.html#__thm_4.8">4.8</a><br /><a href="book-Z-H-26.html#__thm_4.9">4.9</a><br /><a href="book-Z-H-26.html#__thm_4.10">4.10</a><br /><a href="book-Z-H-26.html#__thm_4.11">4.11</a><br /><a href="book-Z-H-26.html#__thm_4.12">4.12</a><br /><a href="book-Z-H-26.html#__thm_4.13">4.13</a><br /><a href="book-Z-H-26.html#__thm_4.14">4.14</a><br /><a href="book-Z-H-26.html#__thm_4.15">4.15</a><br /><a href="book-Z-H-26.html#__thm_4.16">4.16</a><br /><a href="book-Z-H-26.html#__thm_4.17">4.17</a><br /><a href="book-Z-H-26.html#__thm_4.18">4.18</a><br /><a href="book-Z-H-26.html#__thm_4.19">4.19</a><br /><a href="book-Z-H-26.html#__thm_4.20">4.20</a><br /><a href="book-Z-H-26.html#__thm_4.21">4.21</a><br /><a href="book-Z-H-26.html#__thm_4.22">4.22</a><br /><a href="book-Z-H-26.html#__thm_4.23">4.23</a><br /><a href="book-Z-H-26.html#__thm_4.24">4.24</a><br /><a href="book-Z-H-27.html#__thm_4.25">4.25</a><br /><a href="book-Z-H-27.html#__thm_4.26">4.26</a><br /><a href="book-Z-H-27.html#__thm_4.27">4.27</a><br /><a href="book-Z-H-27.html#__thm_4.28">4.28</a><br /><a href="book-Z-H-27.html#__thm_4.29">4.29</a><br /><a href="book-Z-H-27.html#__thm_4.30">4.30</a><br /><a href="book-Z-H-27.html#__thm_4.31">4.31</a><br /><a href="book-Z-H-27.html#__thm_4.32">4.32</a><br /><a href="book-Z-H-27.html#__thm_4.33">4.33</a><br /><a href="book-Z-H-27.html#__thm_4.34">4.34</a><br /><a href="book-Z-H-28.html#__thm_4.35">4.35</a><br /><a href="book-Z-H-28.html#__thm_4.36">4.36</a><br /><a href="book-Z-H-28.html#__thm_4.37">4.37</a><br /><a href="book-Z-H-28.html#__thm_4.38">4.38</a><br /><a href="book-Z-H-28.html#__thm_4.39">4.39</a><br /><a href="book-Z-H-28.html#__thm_4.40">4.40</a><br /><a href="book-Z-H-28.html#__thm_4.41">4.41</a><br /><a href="book-Z-H-28.html#__thm_4.42">4.42</a><br /><a href="book-Z-H-28.html#__thm_4.43">4.43</a><br /><a href="book-Z-H-28.html#__thm_4.44">4.44</a><br /><a href="book-Z-H-28.html#__thm_4.45">4.45</a><br /><a href="book-Z-H-28.html#__thm_4.46">4.46</a><br /><a href="book-Z-H-28.html#__thm_4.47">4.47</a><br /><a href="book-Z-H-28.html#__thm_4.48">4.48</a><br /><a href="book-Z-H-28.html#__thm_4.49">4.49</a><br /><a href="book-Z-H-28.html#__thm_4.50">4.50</a><br /><a href="book-Z-H-28.html#__thm_4.51">4.51</a><br /><a href="book-Z-H-28.html#__thm_4.52">4.52</a><br /><a href="book-Z-H-28.html#__thm_4.53">4.53</a><br /><a href="book-Z-H-28.html#__thm_4.54">4.54</a><br /><a href="book-Z-H-29.html#__thm_4.55">4.55</a><br /><a href="book-Z-H-29.html#__thm_4.56">4.56</a><br /><a href="book-Z-H-29.html#__thm_4.57">4.57</a><br /><a href="book-Z-H-29.html#__thm_4.58">4.58</a><br /><a href="book-Z-H-29.html#__thm_4.59">4.59</a><br /><a href="book-Z-H-29.html#__thm_4.60">4.60</a><br /><a href="book-Z-H-29.html#__thm_4.61">4.61</a><br /><a href="book-Z-H-29.html#__thm_4.62">4.62</a><br /><a href="book-Z-H-29.html#__thm_4.63">4.63</a><br /><a href="book-Z-H-29.html#__thm_4.64">4.64</a><br /><a href="book-Z-H-29.html#__thm_4.65">4.65</a><br /><a href="book-Z-H-29.html#__thm_4.66">4.66</a><br /><a href="book-Z-H-29.html#__thm_4.67">4.67</a><br /><a href="book-Z-H-29.html#__thm_4.68">4.68</a><br /><a href="book-Z-H-29.html#__thm_4.69">4.69</a><br /><a href="book-Z-H-29.html#__thm_4.70">4.70</a><br /><a href="book-Z-H-29.html#__thm_4.71">4.71</a><br /><a href="book-Z-H-29.html#__thm_4.72">4.72</a><br /><a href="book-Z-H-29.html#__thm_4.73">4.73</a><br /><a href="book-Z-H-29.html#__thm_4.74">4.74</a><br /><a href="book-Z-H-29.html#__thm_4.75">4.75</a><br /><a href="book-Z-H-29.html#__thm_4.76">4.76</a><br /><a href="book-Z-H-29.html#__thm_4.77">4.77</a><br /><a href="book-Z-H-29.html#__thm_4.78">4.78</a><br /><a href="book-Z-H-29.html#__thm_4.79">4.79</a><br /><a href="book-Z-H-31.html#__thm_5.1">5.1</a><br /><a href="book-Z-H-31.html#__thm_5.2">5.2</a><br /><a href="book-Z-H-31.html#__thm_5.3">5.3</a><br /><a href="book-Z-H-31.html#__thm_5.4">5.4</a><br /><a href="book-Z-H-31.html#__thm_5.5">5.5</a><br /><a href="book-Z-H-31.html#__thm_5.6">5.6</a><br /><a href="book-Z-H-32.html#__thm_5.7">5.7</a><br /><a href="book-Z-H-32.html#__thm_5.8">5.8</a><br /><a href="book-Z-H-32.html#__thm_5.9">5.9</a><br /><a href="book-Z-H-32.html#__thm_5.10">5.10</a><br /><a href="book-Z-H-32.html#__thm_5.11">5.11</a><br /><a href="book-Z-H-32.html#__thm_5.12">5.12</a><br /><a href="book-Z-H-32.html#__thm_5.13">5.13</a><br /><a href="book-Z-H-32.html#__thm_5.14">5.14</a><br /><a href="book-Z-H-32.html#__thm_5.15">5.15</a><br /><a href="book-Z-H-32.html#__thm_5.16">5.16</a><br /><a href="book-Z-H-32.html#__thm_5.17">5.17</a><br /><a href="book-Z-H-32.html#__thm_5.18">5.18</a><br /><a href="book-Z-H-32.html#__thm_5.19">5.19</a><br /><a href="book-Z-H-33.html#__thm_5.20">5.20</a><br /><a href="book-Z-H-33.html#__thm_5.21">5.21</a><br /><a href="book-Z-H-33.html#__thm_5.22">5.22</a><br /><a href="book-Z-H-34.html#__thm_5.23">5.23</a><br /><a href="book-Z-H-34.html#__thm_5.24">5.24</a><br /><a href="book-Z-H-34.html#__thm_5.25">5.25</a><br /><a href="book-Z-H-34.html#__thm_5.26">5.26</a><br /><a href="book-Z-H-34.html#__thm_5.27">5.27</a><br /><a href="book-Z-H-34.html#__thm_5.28">5.28</a><br /><a href="book-Z-H-34.html#__thm_5.29">5.29</a><br /><a href="book-Z-H-34.html#__thm_5.30">5.30</a><br /><a href="book-Z-H-35.html#__thm_5.31">5.31</a><br /><a href="book-Z-H-35.html#__thm_5.32">5.32</a><br /><a href="book-Z-H-35.html#__thm_5.33">5.33</a><br /><a href="book-Z-H-35.html#__thm_5.34">5.34</a><br /><a href="book-Z-H-35.html#__thm_5.35">5.35</a><br /><a href="book-Z-H-35.html#__thm_5.36">5.36</a><br /><a href="book-Z-H-35.html#__thm_5.37">5.37</a><br /><a href="book-Z-H-35.html#__thm_5.38">5.38</a><br /><a href="book-Z-H-35.html#__thm_5.39">5.39</a><br /><a href="book-Z-H-35.html#__thm_5.40">5.40</a><br /><a href="book-Z-H-35.html#__thm_5.41">5.41</a><br /><a href="book-Z-H-35.html#__thm_5.42">5.42</a><br /><a href="book-Z-H-35.html#__thm_5.43">5.43</a><br /><a href="book-Z-H-35.html#__thm_5.44">5.44</a><br /><a href="book-Z-H-35.html#__thm_5.45">5.45</a><br /><a href="book-Z-H-35.html#__thm_5.46">5.46</a><br /><a href="book-Z-H-35.html#__thm_5.47">5.47</a><br /><a href="book-Z-H-35.html#__thm_5.48">5.48</a><br /><a href="book-Z-H-35.html#__thm_5.49">5.49</a><br /><a href="book-Z-H-35.html#__thm_5.50">5.50</a><br /><a href="book-Z-H-35.html#__thm_5.51">5.51</a><br /><a href="book-Z-H-35.html#__thm_5.52">5.52</a><br /><a id="__idx_6526"></a>
+<a id="__idx_6528"></a>
+<a id="__idx_6530"></a>
+<a id="__idx_6532"></a></p><p>
 
-<a name="%_idx_6534" id="%_idx_6534"></a>  <a name="%_idx_6536" id="%_idx_6536"></a>
-<a name="%_idx_6538" id="%_idx_6538"></a></p><p>
+<a id="__idx_6534"></a>  <a id="__idx_6536"></a>
+<a id="__idx_6538"></a></p><p>
 
 
-<a name="%_idx_6540" id="%_idx_6540"></a>
-<a name="%_idx_6542" id="%_idx_6542"></a></p><p>
+<a id="__idx_6540"></a>
+<a id="__idx_6542"></a></p><p>
 
-<a name="%_idx_6544" id="%_idx_6544"></a>
-<a name="%_idx_6546" id="%_idx_6546"></a></p><p>
+<a id="__idx_6544"></a>
+<a id="__idx_6546"></a></p><p>
 
-<a name="%_idx_6548" id="%_idx_6548"></a>
-<a name="%_idx_6550" id="%_idx_6550"></a></p><p>
+<a id="__idx_6548"></a>
+<a id="__idx_6550"></a></p><p>
 
-<a name="%_idx_6552" id="%_idx_6552"></a>
-<a name="%_idx_6554" id="%_idx_6554"></a></p><p>
+<a id="__idx_6552"></a>
+<a id="__idx_6554"></a></p><p>
 
-<a name="%_idx_6556" id="%_idx_6556"></a>
-<a name="%_idx_6558" id="%_idx_6558"></a></p><p>
+<a id="__idx_6556"></a>
+<a id="__idx_6558"></a></p><p>
 
-<a name="%_idx_6560" id="%_idx_6560"></a></p><p>
+<a id="__idx_6560"></a></p><p>
 
-<a name="%_idx_6562" id="%_idx_6562"></a>
-<a name="%_idx_6564" id="%_idx_6564"></a>
-<a name="%_idx_6566" id="%_idx_6566"></a></p><p>
+<a id="__idx_6562"></a>
+<a id="__idx_6564"></a>
+<a id="__idx_6566"></a></p><p>
 
-<a name="%_idx_6568" id="%_idx_6568"></a></p><p>
+<a id="__idx_6568"></a></p><p>
 
-<a name="%_idx_6570" id="%_idx_6570"></a></p><p>
+<a id="__idx_6570"></a></p><p>
 
-<a name="%_idx_6572" id="%_idx_6572"></a></p><p>
+<a id="__idx_6572"></a></p><p>
 
-<a name="%_idx_6574" id="%_idx_6574"></a></p><p>
+<a id="__idx_6574"></a></p><p>
 
-<a name="%_idx_6576" id="%_idx_6576"></a>
-<a name="%_idx_6578" id="%_idx_6578"></a></p><p>
+<a id="__idx_6576"></a>
+<a id="__idx_6578"></a></p><p>
 
-<a name="%_idx_6580" id="%_idx_6580"></a>
-<a name="%_idx_6582" id="%_idx_6582"></a></p><p>
+<a id="__idx_6580"></a>
+<a id="__idx_6582"></a></p><p>
 
-<a name="%_idx_6584" id="%_idx_6584"></a>
-<a name="%_idx_6586" id="%_idx_6586"></a>
-<a name="%_idx_6588" id="%_idx_6588"></a></p><p>
+<a id="__idx_6584"></a>
+<a id="__idx_6586"></a>
+<a id="__idx_6588"></a></p><p>
 
-<a name="%_idx_6590" id="%_idx_6590"></a>
-<a name="%_idx_6592" id="%_idx_6592"></a>
-<a name="%_idx_6594" id="%_idx_6594"></a>
-<a name="%_idx_6596" id="%_idx_6596"></a>
-<a name="%_idx_6598" id="%_idx_6598"></a>
-<a name="%_idx_6600" id="%_idx_6600"></a>
-<a name="%_idx_6602" id="%_idx_6602"></a></p><p>
+<a id="__idx_6590"></a>
+<a id="__idx_6592"></a>
+<a id="__idx_6594"></a>
+<a id="__idx_6596"></a>
+<a id="__idx_6598"></a>
+<a id="__idx_6600"></a>
+<a id="__idx_6602"></a></p><p>
 
-<a name="%_idx_6604" id="%_idx_6604"></a></p><p>
+<a id="__idx_6604"></a></p><p>
 
-<a name="%_idx_6606" id="%_idx_6606"></a></p><p>
+<a id="__idx_6606"></a></p><p>
 
-<a name="%_idx_6608" id="%_idx_6608"></a></p><p>
+<a id="__idx_6608"></a></p><p>
 
-<a name="%_idx_6610" id="%_idx_6610"></a></p><p>
+<a id="__idx_6610"></a></p><p>
 
-<a name="%_idx_6612" id="%_idx_6612"></a></p><p>
+<a id="__idx_6612"></a></p><p>
 
-<a name="%_idx_6614" id="%_idx_6614"></a></p><p>
+<a id="__idx_6614"></a></p><p>
 
-<a name="%_idx_6616" id="%_idx_6616"></a>
-<a name="%_idx_6618" id="%_idx_6618"></a>
-<a name="%_idx_6620" id="%_idx_6620"></a></p><p>
+<a id="__idx_6616"></a>
+<a id="__idx_6618"></a>
+<a id="__idx_6620"></a></p><p>
 
-<a name="%_idx_6622" id="%_idx_6622"></a></p><p>
+<a id="__idx_6622"></a></p><p>
 
-<a name="%_idx_6624" id="%_idx_6624"></a>
-<a name="%_idx_6626" id="%_idx_6626"></a></p><p>
+<a id="__idx_6624"></a>
+<a id="__idx_6626"></a></p><p>
 
-<a name="%_idx_6628" id="%_idx_6628"></a>
-<a name="%_idx_6630" id="%_idx_6630"></a>
-<a name="%_idx_6632" id="%_idx_6632"></a></p><p>
+<a id="__idx_6628"></a>
+<a id="__idx_6630"></a>
+<a id="__idx_6632"></a></p><p>
 
-<a name="%_idx_6634" id="%_idx_6634"></a></p><p>
+<a id="__idx_6634"></a></p><p>
 
-<a name="%_idx_6636" id="%_idx_6636"></a>
-<a name="%_idx_6638" id="%_idx_6638"></a></p><p>
+<a id="__idx_6636"></a>
+<a id="__idx_6638"></a></p><p>
 
-<a name="%_idx_6640" id="%_idx_6640"></a>
-<a name="%_idx_6642" id="%_idx_6642"></a></p><p>
+<a id="__idx_6640"></a>
+<a id="__idx_6642"></a></p><p>
 
-<a name="%_idx_6644" id="%_idx_6644"></a></p><p>
+<a id="__idx_6644"></a></p><p>
 
-<a name="%_idx_6646" id="%_idx_6646"></a></p><p>
+<a id="__idx_6646"></a></p><p>
 
-<a name="%_idx_6648" id="%_idx_6648"></a>
-<a name="%_idx_6650" id="%_idx_6650"></a></p><p>
+<a id="__idx_6648"></a>
+<a id="__idx_6650"></a></p><p>
 
-<a name="%_idx_6652" id="%_idx_6652"></a>
-<a name="%_idx_6654" id="%_idx_6654"></a>
-<a name="%_idx_6656" id="%_idx_6656"></a></p><p>
+<a id="__idx_6652"></a>
+<a id="__idx_6654"></a>
+<a id="__idx_6656"></a></p><p>
 
-<a name="%_idx_6658" id="%_idx_6658"></a><a name="%_idx_6660" id="%_idx_6660"></a></p><p>
+<a id="__idx_6658"></a><a id="__idx_6660"></a></p><p>
 
-<a name="%_idx_6662" id="%_idx_6662"></a>
-<a name="%_idx_6664" id="%_idx_6664"></a>
-<a name="%_idx_6666" id="%_idx_6666"></a></p><p>
+<a id="__idx_6662"></a>
+<a id="__idx_6664"></a>
+<a id="__idx_6666"></a></p><p>
 
-<a name="%_idx_6668" id="%_idx_6668"></a>
-<a name="%_idx_6670" id="%_idx_6670"></a>
-<a name="%_idx_6672" id="%_idx_6672"></a>
-<a name="%_idx_6674" id="%_idx_6674"></a>
-<a name="%_idx_6676" id="%_idx_6676"></a>
-<a name="%_idx_6678" id="%_idx_6678"></a></p><p>
+<a id="__idx_6668"></a>
+<a id="__idx_6670"></a>
+<a id="__idx_6672"></a>
+<a id="__idx_6674"></a>
+<a id="__idx_6676"></a>
+<a id="__idx_6678"></a></p><p>
 
-<a name="%_idx_6680" id="%_idx_6680"></a>
-<a name="%_idx_6682" id="%_idx_6682"></a>
-<a name="%_idx_6684" id="%_idx_6684"></a>
-<a name="%_idx_6686" id="%_idx_6686"></a>
-<a name="%_idx_6688" id="%_idx_6688"></a>
-<a name="%_idx_6690" id="%_idx_6690"></a>
-<a name="%_idx_6692" id="%_idx_6692"></a></p><p>
+<a id="__idx_6680"></a>
+<a id="__idx_6682"></a>
+<a id="__idx_6684"></a>
+<a id="__idx_6686"></a>
+<a id="__idx_6688"></a>
+<a id="__idx_6690"></a>
+<a id="__idx_6692"></a></p><p>
 
-<a name="%_idx_6694" id="%_idx_6694"></a>
-<a name="%_idx_6696" id="%_idx_6696"></a>
-<a name="%_idx_6698" id="%_idx_6698"></a></p><p>
+<a id="__idx_6694"></a>
+<a id="__idx_6696"></a>
+<a id="__idx_6698"></a></p><p>
 
-<a name="%_idx_6700" id="%_idx_6700"></a>
-<a name="%_idx_6702" id="%_idx_6702"></a>
-<a name="%_idx_6704" id="%_idx_6704"></a></p><p>
+<a id="__idx_6700"></a>
+<a id="__idx_6702"></a>
+<a id="__idx_6704"></a></p><p>
 
-<a name="%_idx_6706" id="%_idx_6706"></a>
-<a name="%_idx_6708" id="%_idx_6708"></a>
-<a name="%_idx_6710" id="%_idx_6710"></a>
-<a name="%_idx_6712" id="%_idx_6712"></a></p><p>
+<a id="__idx_6706"></a>
+<a id="__idx_6708"></a>
+<a id="__idx_6710"></a>
+<a id="__idx_6712"></a></p><p>
 
-<a name="%_idx_6714" id="%_idx_6714"></a>
-<a name="%_idx_6716" id="%_idx_6716"></a>
-<a name="%_idx_6718" id="%_idx_6718"></a></p><p>
+<a id="__idx_6714"></a>
+<a id="__idx_6716"></a>
+<a id="__idx_6718"></a></p><p>
 
-<a name="%_idx_6720" id="%_idx_6720"></a>
-<a name="%_idx_6722" id="%_idx_6722"></a>
+<a id="__idx_6720"></a>
+<a id="__idx_6722"></a>
 
-<a name="%_idx_6724" id="%_idx_6724"></a>
-<a name="%_idx_6726" id="%_idx_6726"></a></p><p>
+<a id="__idx_6724"></a>
+<a id="__idx_6726"></a></p><p>
 
-<a name="%_idx_6728" id="%_idx_6728"></a></p><p>
+<a id="__idx_6728"></a></p><p>
 
-<a name="%_idx_6730" id="%_idx_6730"></a></p><p>
+<a id="__idx_6730"></a></p><p>
 
-<a name="%_idx_6732" id="%_idx_6732"></a>
-<a name="%_idx_6734" id="%_idx_6734"></a></p><p>
+<a id="__idx_6732"></a>
+<a id="__idx_6734"></a></p><p>
 
-<a name="%_idx_6736" id="%_idx_6736"></a></p><p>
+<a id="__idx_6736"></a></p><p>
 
-<a name="%_idx_6738" id="%_idx_6738"></a></p><p>
+<a id="__idx_6738"></a></p><p>
 
-<a name="%_idx_6740" id="%_idx_6740"></a></p><p>
+<a id="__idx_6740"></a></p><p>
 
-<a name="%_idx_6742" id="%_idx_6742"></a></p><p>
+<a id="__idx_6742"></a></p><p>
 
-<a name="%_idx_6744" id="%_idx_6744"></a>
-<a name="%_idx_6746" id="%_idx_6746"></a></p><p>
+<a id="__idx_6744"></a>
+<a id="__idx_6746"></a></p><p>
 
-<a name="%_idx_6748" id="%_idx_6748"></a>
-<a name="%_idx_6750" id="%_idx_6750"></a>
-<a name="%_idx_6752" id="%_idx_6752"></a>
-<a name="%_idx_6754" id="%_idx_6754"></a>
-<a name="%_idx_6756" id="%_idx_6756"></a>
-<a name="%_idx_6758" id="%_idx_6758"></a>
-<a name="%_idx_6760" id="%_idx_6760"></a>
-<a name="%_idx_6762" id="%_idx_6762"></a>
-<a name="%_idx_6764" id="%_idx_6764"></a></p><p>
+<a id="__idx_6748"></a>
+<a id="__idx_6750"></a>
+<a id="__idx_6752"></a>
+<a id="__idx_6754"></a>
+<a id="__idx_6756"></a>
+<a id="__idx_6758"></a>
+<a id="__idx_6760"></a>
+<a id="__idx_6762"></a>
+<a id="__idx_6764"></a></p><p>
 
-<a name="%_idx_6766" id="%_idx_6766"></a>
+<a id="__idx_6766"></a>
 
-<a name="%_idx_6768" id="%_idx_6768"></a>
-<a name="%_idx_6770" id="%_idx_6770"></a>
-<a name="%_idx_6772" id="%_idx_6772"></a>
-<a name="%_idx_6774" id="%_idx_6774"></a></p><p>
+<a id="__idx_6768"></a>
+<a id="__idx_6770"></a>
+<a id="__idx_6772"></a>
+<a id="__idx_6774"></a></p><p>
 
-<a name="%_idx_6776" id="%_idx_6776"></a></p><p>
+<a id="__idx_6776"></a></p><p>
 
-<a name="%_idx_6778" id="%_idx_6778"></a></p><p>
+<a id="__idx_6778"></a></p><p>
 
-<a name="%_idx_6780" id="%_idx_6780"></a></p><p>
+<a id="__idx_6780"></a></p><p>
 
-<a name="%_idx_6782" id="%_idx_6782"></a></p><p>
+<a id="__idx_6782"></a></p><p>
 
-<a name="%_idx_6784" id="%_idx_6784"></a></p><p>
+<a id="__idx_6784"></a></p><p>
 
-<a name="%_idx_6786" id="%_idx_6786"></a>
-<a name="%_idx_6788" id="%_idx_6788"></a>
-<a name="%_idx_6790" id="%_idx_6790"></a>
-<a name="%_idx_6792" id="%_idx_6792"></a></p><p>
+<a id="__idx_6786"></a>
+<a id="__idx_6788"></a>
+<a id="__idx_6790"></a>
+<a id="__idx_6792"></a></p><p>
 
 
 
diff --git a/src/OEBPS/book-Z-H-38.html b/src/OEBPS/book-Z-H-38.html
index 1163670..3e04e1d 100644
--- a/src/OEBPS/book-Z-H-38.html
+++ b/src/OEBPS/book-Z-H-38.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,642 +13,642 @@
 
 
 
-<a name="%_chap_Temp_851" id="%_chap_Temp_851"></a>
+<a id="__chap_Temp_851"></a>
 <h1 class="chapter">
 <div class="chapterheading"> </div></h1><p>
-<a href="book-Z-H-4.html#%_toc_%_chap_Temp_851">Index</a></p><p>
+Index</p><p>
 
 </p><p>
-</p><div align="right">
-<table width="60%"><tr><td>
+</p><div style="text-align: right;">
+<table width="60_"><tr><td>
 <span class="epigraph">
 
 Any inaccuracies in this index may be explained by the fact that it
 has been prepared with the help of a computer.
-<p><a name="%_idx_6794" id="%_idx_6794"></a>Donald E. Knuth,
+<p><a id="__idx_6794"></a>Donald E. Knuth,
 <em>Fundamental Algorithms</em> (Volume 1 of
 <em>The Art of Computer Programming</em>)
 </p></span>
 </td></tr></table></div>
 
 <p>
-</p><p><a name="%_index_start" id="%_index_start"><p>
+</p><p><a id="__index_start"><p>
 
-<br /><a href="book-Z-H-20.html#%_idx_2872"><tt>!</tt> in names</a><br /><a href="book-Z-H-16.html#%_idx_2008"><tt>"</tt> (double quote)</a><br />
+<br /><a href="book-Z-H-20.html#__idx_2872"><tt>!</tt> in names</a><br /><a href="book-Z-H-16.html#__idx_2008"><tt>"</tt> (double quote)</a><br />
 λ  calculus, <em>see</em> lambda calculus
-<br /><a href="book-Z-H-12.html#%_idx_1122"> ⟼   notation for mathematical function</a><br />
+<br /><a href="book-Z-H-12.html#__idx_1122"> ⟼   notation for mathematical function</a><br />
 π , <em>see</em> pi
-<br /><a href="book-Z-H-12.html#%_idx_986">Σ (sigma) notation</a><br /><em>θ</em>, <em>see</em> theta
-<br /><a href="book-Z-H-16.html#%_idx_2000"><tt>'</tt> (single quote)</a><br />
-    <a href="book-Z-H-26.html#%_idx_4526"><tt>read</tt> and</a>,
-<a href="book-Z-H-29.html#%_idx_5406">[2]</a><br /><a href="book-Z-H-10.html#%_idx_168"><tt>*</tt> (primitive multiplication procedure)</a><br /><a href="book-Z-H-10.html#%_idx_162"><tt>+</tt> (primitive addition procedure)</a><br /><a href="book-Z-H-35.html#%_idx_6288"><tt>,</tt> (comma, used with backquote)</a><br /><a href="book-Z-H-10.html#%_idx_170"><tt>-</tt> (primitive subtraction procedure)</a><br />
-    <a href="book-Z-H-10.html#%_idx_410">as negation</a><br /><a href="book-Z-H-10.html#%_idx_176"><tt>/</tt> (primitive division procedure)</a><br /><a href="book-Z-H-10.html#%_idx_394"><tt>&lt;</tt> (primitive numeric comparison predicate)</a><br /><a href="book-Z-H-10.html#%_idx_396"><tt>=</tt> (primitive numeric equality predicate)</a><br /><a href="book-Z-H-16.html#%_idx_2090"><tt>=number?</tt></a><br /><a href="book-Z-H-18.html#%_idx_2568"><tt>=zero?</tt> (generic)</a><br />
-    <a href="book-Z-H-18.html#%_idx_2752">for polynomials</a><br /><a href="book-Z-H-10.html#%_idx_392"><tt>&gt;</tt> (primitive numeric comparison predicate)</a><br /><a href="book-Z-H-10.html#%_idx_470"><tt>&gt;=</tt></a>, <a href="book-Z-H-10.html#%_idx_472">[2]</a><br /><a href="book-Z-H-10.html#%_idx_524"><tt>?</tt> , in predicate names</a><br /><a href="book-Z-H-10.html#%_idx_378"><tt>#f</tt></a><br /><a href="book-Z-H-10.html#%_idx_372"><tt>#t</tt></a><br /><a href="book-Z-H-35.html#%_idx_6286"><tt>`</tt> (backquote)</a><br /><tt>;</tt>, <em>see</em> semicolon</p><p>
+<br /><a href="book-Z-H-12.html#__idx_986">Σ (sigma) notation</a><br /><em>θ</em>, <em>see</em> theta
+<br /><a href="book-Z-H-16.html#__idx_2000"><tt>'</tt> (single quote)</a><br />
+    <a href="book-Z-H-26.html#__idx_4526"><tt>read</tt> and</a>,
+<a href="book-Z-H-29.html#__idx_5406">[2]</a><br /><a href="book-Z-H-10.html#__idx_168"><tt>*</tt> (primitive multiplication procedure)</a><br /><a href="book-Z-H-10.html#__idx_162"><tt>+</tt> (primitive addition procedure)</a><br /><a href="book-Z-H-35.html#__idx_6288"><tt>,</tt> (comma, used with backquote)</a><br /><a href="book-Z-H-10.html#__idx_170"><tt>-</tt> (primitive subtraction procedure)</a><br />
+    <a href="book-Z-H-10.html#__idx_410">as negation</a><br /><a href="book-Z-H-10.html#__idx_176"><tt>/</tt> (primitive division procedure)</a><br /><a href="book-Z-H-10.html#__idx_394"><tt>&lt;</tt> (primitive numeric comparison predicate)</a><br /><a href="book-Z-H-10.html#__idx_396"><tt>=</tt> (primitive numeric equality predicate)</a><br /><a href="book-Z-H-16.html#__idx_2090"><tt>=number?</tt></a><br /><a href="book-Z-H-18.html#__idx_2568"><tt>=zero?</tt> (generic)</a><br />
+    <a href="book-Z-H-18.html#__idx_2752">for polynomials</a><br /><a href="book-Z-H-10.html#__idx_392"><tt>&gt;</tt> (primitive numeric comparison predicate)</a><br /><a href="book-Z-H-10.html#__idx_470"><tt>&gt;=</tt></a>, <a href="book-Z-H-10.html#__idx_472">[2]</a><br /><a href="book-Z-H-10.html#__idx_524"><tt>?</tt> , in predicate names</a><br /><a href="book-Z-H-10.html#__idx_378"><tt>#f</tt></a><br /><a href="book-Z-H-10.html#__idx_372"><tt>#t</tt></a><br /><a href="book-Z-H-35.html#__idx_6286"><tt>`</tt> (backquote)</a><br /><tt>;</tt>, <em>see</em> semicolon</p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-9.html#%_idx_106">Abelson, Harold</a><br /><a href="book-Z-H-10.html#%_idx_358"><tt>abs</tt></a>, <a href="book-Z-H-10.html#%_idx_414">[2]</a>,
-<a href="book-Z-H-10.html#%_idx_418">[3]</a><br /><a href="book-Z-H-10.html#%_idx_348">absolute value</a><br /><a href="book-Z-H-14.html#%_idx_1282">abstract data</a>,
+<br /><a href="book-Z-H-9.html#__idx_106">Abelson, Harold</a><br /><a href="book-Z-H-10.html#__idx_358"><tt>abs</tt></a>, <a href="book-Z-H-10.html#__idx_414">[2]</a>,
+<a href="book-Z-H-10.html#__idx_418">[3]</a><br /><a href="book-Z-H-10.html#__idx_348">absolute value</a><br /><a href="book-Z-H-14.html#__idx_1282">abstract data</a>,
 <em>see also</em> data abstraction
-<br /><a href="book-Z-H-14.html#%_idx_1426">abstract models for data</a><br />
+<br /><a href="book-Z-H-14.html#__idx_1426">abstract models for data</a><br />
 abstract syntax
 <br />
-    <a href="book-Z-H-26.html#%_idx_4236">in metacircular evaluator</a><br />
-    <a href="book-Z-H-29.html#%_idx_5296">in query interpreter</a><br />
+    <a href="book-Z-H-26.html#__idx_4236">in metacircular evaluator</a><br />
+    <a href="book-Z-H-29.html#__idx_5296">in query interpreter</a><br />
 abstraction, <em>see also</em> means of abstraction; data abstraction; higher-order procedures
 <br />
-    <a href="book-Z-H-12.html#%_idx_980">common pattern and</a><br />
-    <a href="book-Z-H-25.html#%_idx_4196">metalinguistic</a><br />
-    <a href="book-Z-H-10.html#%_idx_576">procedural</a><br />
-    <a href="book-Z-H-31.html#%_idx_5546">in register-machine design</a><br />
-    <a href="book-Z-H-28.html#%_idx_4924">of search in nondeterministic programming</a><br /><a href="book-Z-H-13.html#%_idx_1264">abstraction barriers</a>,
-<a href="book-Z-H-14.html#%_idx_1380">[2]</a>, <a href="book-Z-H-17.html#%_idx_2286">[3]</a><br />
-    <a href="book-Z-H-17.html#%_idx_2304">in complex-number system</a><br />
-    <a href="book-Z-H-18.html#%_idx_2498">in generic arithmetic system</a><br /><a href="book-Z-H-24.html#%_idx_3976"><tt>accelerated-sequence</tt></a><br /><a href="book-Z-H-12.html#%_idx_1018"><tt>accumulate</tt></a>,
-<a href="book-Z-H-15.html#%_idx_1742">[2]</a><br />
-    <a href="book-Z-H-15.html#%_idx_1810">same as <tt>fold-right</tt></a><br /><a href="book-Z-H-15.html#%_idx_1794"><tt>accumulate-n</tt></a><br /><a href="book-Z-H-15.html#%_idx_1736">accumulator</a>, <a href="book-Z-H-20.html#%_idx_2902">[2]</a><br /><a href="book-Z-H-11.html#%_idx_748">Áchárya, Bháscara</a><br /><a href="book-Z-H-11.html#%_idx_708">Ackermann's function</a><br /><a href="book-Z-H-23.html#%_idx_3642">acquire a mutex</a><br /><a href="book-Z-H-31.html#%_idx_5534">actions, in register machine</a><br /><a href="book-Z-H-27.html#%_idx_4722"><tt>actual-value</tt></a><br /><a href="book-Z-H-29.html#%_idx_5168">Ada</a><br />
-    <a href="book-Z-H-11.html#%_idx_684">recursive procedures</a><br /><a href="book-Z-H-26.html#%_idx_4646">Adams, Norman I., IV</a><br /><a href="book-Z-H-18.html#%_idx_2504"><tt>add</tt> (generic)</a><br />
-    <a href="book-Z-H-18.html#%_idx_2710">used for polynomial coefficients</a>,
-<a href="book-Z-H-18.html#%_idx_2714">[2]</a><br /><a href="book-Z-H-22.html#%_idx_3374"><tt>add-action!</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3408">[2]</a><br /><a href="book-Z-H-26.html#%_idx_4476"><tt>add-binding-to-frame!</tt></a><br /><a href="book-Z-H-17.html#%_idx_2312"><tt>add-complex</tt></a><br /><a href="book-Z-H-18.html#%_idx_2578"><tt>add-complex-to-schemenum</tt></a><br /><a href="book-Z-H-14.html#%_idx_1488"><tt>add-interval</tt></a><br /><a href="book-Z-H-27.html#%_idx_4786"><tt>add-lists</tt></a><br /><a href="book-Z-H-18.html#%_idx_2674"><tt>add-poly</tt></a><br /><a href="book-Z-H-14.html#%_idx_1308"><tt>add-rat</tt></a><br /><a href="book-Z-H-29.html#%_idx_5382"><tt>add-rule-or-assertion!</tt></a><br /><a href="book-Z-H-24.html#%_idx_3864"><tt>add-streams</tt></a><br /><a href="book-Z-H-18.html#%_idx_2708"><tt>add-terms</tt></a><br /><a href="book-Z-H-22.html#%_idx_3420"><tt>add-to-agenda!</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3472">[2]</a><br /><a href="book-Z-H-15.html#%_idx_1938"><tt>add-vect</tt></a><br /><a href="book-Z-H-16.html#%_idx_2074"><tt>addend</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_980">common pattern and</a><br />
+    <a href="book-Z-H-25.html#__idx_4196">metalinguistic</a><br />
+    <a href="book-Z-H-10.html#__idx_576">procedural</a><br />
+    <a href="book-Z-H-31.html#__idx_5546">in register-machine design</a><br />
+    <a href="book-Z-H-28.html#__idx_4924">of search in nondeterministic programming</a><br /><a href="book-Z-H-13.html#__idx_1264">abstraction barriers</a>,
+<a href="book-Z-H-14.html#__idx_1380">[2]</a>, <a href="book-Z-H-17.html#__idx_2286">[3]</a><br />
+    <a href="book-Z-H-17.html#__idx_2304">in complex-number system</a><br />
+    <a href="book-Z-H-18.html#__idx_2498">in generic arithmetic system</a><br /><a href="book-Z-H-24.html#__idx_3976"><tt>accelerated-sequence</tt></a><br /><a href="book-Z-H-12.html#__idx_1018"><tt>accumulate</tt></a>,
+<a href="book-Z-H-15.html#__idx_1742">[2]</a><br />
+    <a href="book-Z-H-15.html#__idx_1810">same as <tt>fold-right</tt></a><br /><a href="book-Z-H-15.html#__idx_1794"><tt>accumulate-n</tt></a><br /><a href="book-Z-H-15.html#__idx_1736">accumulator</a>, <a href="book-Z-H-20.html#__idx_2902">[2]</a><br /><a href="book-Z-H-11.html#__idx_748">Áchárya, Bháscara</a><br /><a href="book-Z-H-11.html#__idx_708">Ackermann's function</a><br /><a href="book-Z-H-23.html#__idx_3642">acquire a mutex</a><br /><a href="book-Z-H-31.html#__idx_5534">actions, in register machine</a><br /><a href="book-Z-H-27.html#__idx_4722"><tt>actual-value</tt></a><br /><a href="book-Z-H-29.html#__idx_5168">Ada</a><br />
+    <a href="book-Z-H-11.html#__idx_684">recursive procedures</a><br /><a href="book-Z-H-26.html#__idx_4646">Adams, Norman I., IV</a><br /><a href="book-Z-H-18.html#__idx_2504"><tt>add</tt> (generic)</a><br />
+    <a href="book-Z-H-18.html#__idx_2710">used for polynomial coefficients</a>,
+<a href="book-Z-H-18.html#__idx_2714">[2]</a><br /><a href="book-Z-H-22.html#__idx_3374"><tt>add-action!</tt></a>,
+<a href="book-Z-H-22.html#__idx_3408">[2]</a><br /><a href="book-Z-H-26.html#__idx_4476"><tt>add-binding-to-frame!</tt></a><br /><a href="book-Z-H-17.html#__idx_2312"><tt>add-complex</tt></a><br /><a href="book-Z-H-18.html#__idx_2578"><tt>add-complex-to-schemenum</tt></a><br /><a href="book-Z-H-14.html#__idx_1488"><tt>add-interval</tt></a><br /><a href="book-Z-H-27.html#__idx_4786"><tt>add-lists</tt></a><br /><a href="book-Z-H-18.html#__idx_2674"><tt>add-poly</tt></a><br /><a href="book-Z-H-14.html#__idx_1308"><tt>add-rat</tt></a><br /><a href="book-Z-H-29.html#__idx_5382"><tt>add-rule-or-assertion!</tt></a><br /><a href="book-Z-H-24.html#__idx_3864"><tt>add-streams</tt></a><br /><a href="book-Z-H-18.html#__idx_2708"><tt>add-terms</tt></a><br /><a href="book-Z-H-22.html#__idx_3420"><tt>add-to-agenda!</tt></a>,
+<a href="book-Z-H-22.html#__idx_3472">[2]</a><br /><a href="book-Z-H-15.html#__idx_1938"><tt>add-vect</tt></a><br /><a href="book-Z-H-16.html#__idx_2074"><tt>addend</tt></a><br />
 adder
 <br />
-    <a href="book-Z-H-22.html#%_idx_3364">full</a><br />
-    <a href="book-Z-H-22.html#%_idx_3356">half</a><br />
-    <a href="book-Z-H-22.html#%_idx_3390">ripple-carry</a><br /><a href="book-Z-H-22.html#%_idx_3532"><tt>adder</tt> (primitive constraint)</a><br /><a href="book-Z-H-13.html#%_idx_1278">additivity</a>, <a href="book-Z-H-17.html#%_idx_2290">[2]</a>,
-<a href="book-Z-H-17.html#%_idx_2426">[3]</a>, <a href="book-Z-H-18.html#%_idx_2534">[4]</a><br /><a href="book-Z-H-33.html#%_idx_5834">address</a><br /><a href="book-Z-H-33.html#%_idx_5838">address arithmetic</a><br /><a href="book-Z-H-11.html#%_idx_926">Adelman, Leonard</a><br /><a href="book-Z-H-34.html#%_idx_6062"><tt>adjoin-arg</tt></a><br /><a href="book-Z-H-16.html#%_idx_2106"><tt>adjoin-set</tt></a><br />
-    <a href="book-Z-H-16.html#%_idx_2162">binary-tree representation</a><br />
-    <a href="book-Z-H-16.html#%_idx_2132">ordered-list representation</a><br />
-    <a href="book-Z-H-16.html#%_idx_2118">unordered-list representation</a><br />
-    <a href="book-Z-H-16.html#%_idx_2274">for weighted sets</a><br /><a href="book-Z-H-18.html#%_idx_2694"><tt>adjoin-term</tt></a>,
-<a href="book-Z-H-18.html#%_idx_2734">[2]</a><br /><a href="book-Z-H-32.html#%_idx_5732"><tt>advance-pc</tt></a><br /><a href="book-Z-H-22.html#%_idx_3376"><tt>after-delay</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3424">[2]</a><br />
+    <a href="book-Z-H-22.html#__idx_3364">full</a><br />
+    <a href="book-Z-H-22.html#__idx_3356">half</a><br />
+    <a href="book-Z-H-22.html#__idx_3390">ripple-carry</a><br /><a href="book-Z-H-22.html#__idx_3532"><tt>adder</tt> (primitive constraint)</a><br /><a href="book-Z-H-13.html#__idx_1278">additivity</a>, <a href="book-Z-H-17.html#__idx_2290">[2]</a>,
+<a href="book-Z-H-17.html#__idx_2426">[3]</a>, <a href="book-Z-H-18.html#__idx_2534">[4]</a><br /><a href="book-Z-H-33.html#__idx_5834">address</a><br /><a href="book-Z-H-33.html#__idx_5838">address arithmetic</a><br /><a href="book-Z-H-11.html#__idx_926">Adelman, Leonard</a><br /><a href="book-Z-H-34.html#__idx_6062"><tt>adjoin-arg</tt></a><br /><a href="book-Z-H-16.html#__idx_2106"><tt>adjoin-set</tt></a><br />
+    <a href="book-Z-H-16.html#__idx_2162">binary-tree representation</a><br />
+    <a href="book-Z-H-16.html#__idx_2132">ordered-list representation</a><br />
+    <a href="book-Z-H-16.html#__idx_2118">unordered-list representation</a><br />
+    <a href="book-Z-H-16.html#__idx_2274">for weighted sets</a><br /><a href="book-Z-H-18.html#__idx_2694"><tt>adjoin-term</tt></a>,
+<a href="book-Z-H-18.html#__idx_2734">[2]</a><br /><a href="book-Z-H-32.html#__idx_5732"><tt>advance-pc</tt></a><br /><a href="book-Z-H-22.html#__idx_3376"><tt>after-delay</tt></a>,
+<a href="book-Z-H-22.html#__idx_3424">[2]</a><br />
 agenda, <em>see</em> digital-circuit simulation
-<br /><a href="book-Z-H-11.html#%_idx_826">A'h-mose</a><br />
+<br /><a href="book-Z-H-11.html#__idx_826">A'h-mose</a><br />
 algebra, symbolic, <em>see</em> symbolic algebra
-<br /><a href="book-Z-H-18.html#%_idx_2648">algebraic expression</a><br />
-    <a href="book-Z-H-16.html#%_idx_2046">differentiating</a><br />
-    <a href="book-Z-H-16.html#%_idx_2058">representing</a><br />
-    <a href="book-Z-H-16.html#%_idx_2084">simplifying</a><br /><a href="book-Z-H-14.html#%_idx_1442">algebraic specification for data</a><br />
+<br /><a href="book-Z-H-18.html#__idx_2648">algebraic expression</a><br />
+    <a href="book-Z-H-16.html#__idx_2046">differentiating</a><br />
+    <a href="book-Z-H-16.html#__idx_2058">representing</a><br />
+    <a href="book-Z-H-16.html#__idx_2084">simplifying</a><br /><a href="book-Z-H-14.html#__idx_1442">algebraic specification for data</a><br />
 Algol
 <br />
-    <a href="book-Z-H-10.html#%_idx_628">block structure</a><br />
-    <a href="book-Z-H-24.html#%_idx_3806">call-by-name argument passing</a>,
-<a href="book-Z-H-27.html#%_idx_4716">[2]</a><br />
-    <a href="book-Z-H-24.html#%_idx_3822">thunks</a>, <a href="book-Z-H-27.html#%_idx_4700">[2]</a><br />
-    <a href="book-Z-H-22.html#%_idx_3568">weakness in handling compound objects</a><br />
+    <a href="book-Z-H-10.html#__idx_628">block structure</a><br />
+    <a href="book-Z-H-24.html#__idx_3806">call-by-name argument passing</a>,
+<a href="book-Z-H-27.html#__idx_4716">[2]</a><br />
+    <a href="book-Z-H-24.html#__idx_3822">thunks</a>, <a href="book-Z-H-27.html#__idx_4700">[2]</a><br />
+    <a href="book-Z-H-22.html#__idx_3568">weakness in handling compound objects</a><br />
 algorithm
 <br />
-    <a href="book-Z-H-15.html#%_idx_1780">optimal</a><br />
-    <a href="book-Z-H-11.html#%_idx_910">probabilistic</a>,
-<a href="book-Z-H-18.html#%_idx_2816">[2]</a><br /><a href="book-Z-H-20.html#%_idx_2998">aliasing</a><br /><a href="book-Z-H-35.html#%_idx_6374"><tt>all-regs</tt> (compiler)</a><br /><a href="book-Z-H-33.html#%_idx_5960">Allen, John</a><br /><a href="book-Z-H-10.html#%_idx_438">alternative of <tt>if</tt></a><br /><a href="book-Z-H-29.html#%_idx_5338"><tt>always-true</tt></a><br /><a href="book-Z-H-28.html#%_idx_4822"><tt>amb</tt></a><br /><tt>amb</tt> evaluator, <em>see</em> nondeterministic evaluator
-<br /><a href="book-Z-H-28.html#%_idx_4994"><tt>ambeval</tt></a><br /><a href="book-Z-H-28.html#%_idx_4830"><tt>an-element-of</tt></a><br /><a href="book-Z-H-28.html#%_idx_4832"><tt>an-integer-starting-from</tt></a><br /><a href="book-Z-H-24.html#%_idx_4064">analog computer</a><br /><tt>analyze</tt>
-<br />
-    <a href="book-Z-H-26.html#%_idx_4656">metacircular</a><br />
-    <a href="book-Z-H-28.html#%_idx_4992">nondeterministic</a><br /><tt>analyze-...</tt>
-<br />
-    <a href="book-Z-H-26.html#%_idx_4658">metacircular</a>,
-<a href="book-Z-H-26.html#%_idx_4664">[2]</a><br />
-    <a href="book-Z-H-28.html#%_idx_5004">nondeterministic</a><br /><a href="book-Z-H-28.html#%_idx_5016"><tt>analyze-amb</tt></a><br /><a href="book-Z-H-26.html#%_idx_4636">analyzing evaluator</a><br />
-    <a href="book-Z-H-28.html#%_idx_4980">as basis for nondeterministic evaluator</a><br />
-    <a href="book-Z-H-26.html#%_idx_4662"><tt>let</tt></a><br /><a href="book-Z-H-29.html#%_idx_5124"><tt>and</tt> (query language)</a><br />
-    <a href="book-Z-H-29.html#%_idx_5198">evaluation of</a>,
-<a href="book-Z-H-29.html#%_idx_5318">[2]</a>, <a href="book-Z-H-29.html#%_idx_5428">[3]</a><br /><a href="book-Z-H-10.html#%_idx_446"><tt>and</tt> (special form)</a><br />
-    <a href="book-Z-H-10.html#%_idx_450">evaluation of</a><br />
-    <a href="book-Z-H-10.html#%_idx_466">why a special form</a><br />
-    <a href="book-Z-H-26.html#%_idx_4396">with no subexpressions</a><br /><a href="book-Z-H-22.html#%_idx_3346">and-gate</a><br />
-    <a href="book-Z-H-22.html#%_idx_3382"><tt>and-gate</tt></a><br /><tt>angle</tt>
-<br />
-    <a href="book-Z-H-17.html#%_idx_2470">data-directed</a><br />
-    <a href="book-Z-H-17.html#%_idx_2350">polar representation</a><br />
-    <a href="book-Z-H-17.html#%_idx_2334">rectangular representation</a><br />
-    <a href="book-Z-H-17.html#%_idx_2412">with tagged data</a><br /><a href="book-Z-H-17.html#%_idx_2396"><tt>angle-polar</tt></a><br /><a href="book-Z-H-17.html#%_idx_2384"><tt>angle-rectangular</tt></a><br /><a href="book-Z-H-26.html#%_idx_4536"><tt>announce-output</tt></a><br /><a href="book-Z-H-15.html#%_idx_1764">APL</a><br /><a href="book-Z-H-35.html#%_idx_6366">Appel, Andrew W.</a><br /><a href="book-Z-H-15.html#%_idx_1632"><tt>append</tt></a>, <a href="book-Z-H-15.html#%_idx_1636">[2]</a>,
-<a href="book-Z-H-22.html#%_idx_3164">[3]</a><br />
-    <a href="book-Z-H-15.html#%_idx_1768">as accumulation</a><br />
-    <a href="book-Z-H-22.html#%_idx_3162"><tt>append!</tt> vs.</a><br />
-    <a href="book-Z-H-35.html#%_idx_6396">with arbitrary number of arguments</a><br />
-    <a href="book-Z-H-33.html#%_idx_5926">as register machine</a><br />
-    <a href="book-Z-H-29.html#%_idx_5074">“what is” (rules) vs. “how to” (procedure)</a><br /><a href="book-Z-H-22.html#%_idx_3166"><tt>append!</tt></a><br />
-    <a href="book-Z-H-33.html#%_idx_5928">as register machine</a><br /><a href="book-Z-H-35.html#%_idx_6260"><tt>append-instruction-sequences</tt></a>,
-<a href="book-Z-H-35.html#%_idx_6390">[2]</a><br /><a href="book-Z-H-29.html#%_idx_5158"><tt>append-to-form</tt> (rules)</a><br /><a href="book-Z-H-26.html#%_idx_4340"><tt>application?</tt></a><br /><a href="book-Z-H-10.html#%_idx_342">applicative-order evaluation</a><br />
-    <a href="book-Z-H-10.html#%_idx_344">in Lisp</a><br />
-    <a href="book-Z-H-10.html#%_idx_482">normal order vs.</a>,
-<a href="book-Z-H-11.html#%_idx_854">[2]</a>, <a href="book-Z-H-27.html#%_idx_4682">[3]</a><br /><a href="book-Z-H-27.html#%_idx_4724"><tt>apply</tt> (lazy)</a><br /><a href="book-Z-H-26.html#%_idx_4250"><tt>apply</tt> (metacircular)</a><br />
-    <a href="book-Z-H-26.html#%_idx_4578">primitive <tt>apply</tt> vs.</a><br /><a href="book-Z-H-17.html#%_idx_2458"><tt>apply</tt> (primitive procedure)</a><br /><a href="book-Z-H-34.html#%_idx_6072"><tt>apply-dispatch</tt></a><br />
-    <a href="book-Z-H-35.html#%_idx_6474">modified for compiled code</a><br /><a href="book-Z-H-17.html#%_idx_2462"><tt>apply-generic</tt></a><br />
-    <a href="book-Z-H-18.html#%_idx_2590">with coercion</a>,
-<a href="book-Z-H-18.html#%_idx_2626">[2]</a><br />
-    <a href="book-Z-H-18.html#%_idx_2636">with coercion by raising</a><br />
-    <a href="book-Z-H-18.html#%_idx_2632">with coercion of multiple arguments</a><br />
-    <a href="book-Z-H-18.html#%_idx_2638">with coercion to simplify</a><br />
-    <a href="book-Z-H-17.html#%_idx_2490">with message passing</a><br />
-    <a href="book-Z-H-18.html#%_idx_2610">with tower of types</a><br /><a href="book-Z-H-26.html#%_idx_4248"><tt>apply-primitive-procedure</tt></a>,
-<a href="book-Z-H-26.html#%_idx_4440">[2]</a>, <a href="book-Z-H-26.html#%_idx_4514">[3]</a><br /><a href="book-Z-H-29.html#%_idx_5358"><tt>apply-rules</tt></a><br /><a href="book-Z-H-23.html#%_idx_3684">arbiter</a><br /><a href="book-Z-H-17.html#%_idx_2322">arctangent</a><br /><a href="book-Z-H-34.html#%_idx_6028"><tt>argl</tt> register</a><br />
+    <a href="book-Z-H-15.html#__idx_1780">optimal</a><br />
+    <a href="book-Z-H-11.html#__idx_910">probabilistic</a>,
+<a href="book-Z-H-18.html#__idx_2816">[2]</a><br /><a href="book-Z-H-20.html#__idx_2998">aliasing</a><br /><a href="book-Z-H-35.html#__idx_6374"><tt>all-regs</tt> (compiler)</a><br /><a href="book-Z-H-33.html#__idx_5960">Allen, John</a><br /><a href="book-Z-H-10.html#__idx_438">alternative of <tt>if</tt></a><br /><a href="book-Z-H-29.html#__idx_5338"><tt>always-true</tt></a><br /><a href="book-Z-H-28.html#__idx_4822"><tt>amb</tt></a><br /><tt>amb</tt> evaluator, <em>see</em> nondeterministic evaluator
+<br /><a href="book-Z-H-28.html#__idx_4994"><tt>ambeval</tt></a><br /><a href="book-Z-H-28.html#__idx_4830"><tt>an-element-of</tt></a><br /><a href="book-Z-H-28.html#__idx_4832"><tt>an-integer-starting-from</tt></a><br /><a href="book-Z-H-24.html#__idx_4064">analog computer</a><br /><tt>analyze</tt>
+<br />
+    <a href="book-Z-H-26.html#__idx_4656">metacircular</a><br />
+    <a href="book-Z-H-28.html#__idx_4992">nondeterministic</a><br /><tt>analyze-...</tt>
+<br />
+    <a href="book-Z-H-26.html#__idx_4658">metacircular</a>,
+<a href="book-Z-H-26.html#__idx_4664">[2]</a><br />
+    <a href="book-Z-H-28.html#__idx_5004">nondeterministic</a><br /><a href="book-Z-H-28.html#__idx_5016"><tt>analyze-amb</tt></a><br /><a href="book-Z-H-26.html#__idx_4636">analyzing evaluator</a><br />
+    <a href="book-Z-H-28.html#__idx_4980">as basis for nondeterministic evaluator</a><br />
+    <a href="book-Z-H-26.html#__idx_4662"><tt>let</tt></a><br /><a href="book-Z-H-29.html#__idx_5124"><tt>and</tt> (query language)</a><br />
+    <a href="book-Z-H-29.html#__idx_5198">evaluation of</a>,
+<a href="book-Z-H-29.html#__idx_5318">[2]</a>, <a href="book-Z-H-29.html#__idx_5428">[3]</a><br /><a href="book-Z-H-10.html#__idx_446"><tt>and</tt> (special form)</a><br />
+    <a href="book-Z-H-10.html#__idx_450">evaluation of</a><br />
+    <a href="book-Z-H-10.html#__idx_466">why a special form</a><br />
+    <a href="book-Z-H-26.html#__idx_4396">with no subexpressions</a><br /><a href="book-Z-H-22.html#__idx_3346">and-gate</a><br />
+    <a href="book-Z-H-22.html#__idx_3382"><tt>and-gate</tt></a><br /><tt>angle</tt>
+<br />
+    <a href="book-Z-H-17.html#__idx_2470">data-directed</a><br />
+    <a href="book-Z-H-17.html#__idx_2350">polar representation</a><br />
+    <a href="book-Z-H-17.html#__idx_2334">rectangular representation</a><br />
+    <a href="book-Z-H-17.html#__idx_2412">with tagged data</a><br /><a href="book-Z-H-17.html#__idx_2396"><tt>angle-polar</tt></a><br /><a href="book-Z-H-17.html#__idx_2384"><tt>angle-rectangular</tt></a><br /><a href="book-Z-H-26.html#__idx_4536"><tt>announce-output</tt></a><br /><a href="book-Z-H-15.html#__idx_1764">APL</a><br /><a href="book-Z-H-35.html#__idx_6366">Appel, Andrew W.</a><br /><a href="book-Z-H-15.html#__idx_1632"><tt>append</tt></a>, <a href="book-Z-H-15.html#__idx_1636">[2]</a>,
+<a href="book-Z-H-22.html#__idx_3164">[3]</a><br />
+    <a href="book-Z-H-15.html#__idx_1768">as accumulation</a><br />
+    <a href="book-Z-H-22.html#__idx_3162"><tt>append!</tt> vs.</a><br />
+    <a href="book-Z-H-35.html#__idx_6396">with arbitrary number of arguments</a><br />
+    <a href="book-Z-H-33.html#__idx_5926">as register machine</a><br />
+    <a href="book-Z-H-29.html#__idx_5074">“what is” (rules) vs. “how to” (procedure)</a><br /><a href="book-Z-H-22.html#__idx_3166"><tt>append!</tt></a><br />
+    <a href="book-Z-H-33.html#__idx_5928">as register machine</a><br /><a href="book-Z-H-35.html#__idx_6260"><tt>append-instruction-sequences</tt></a>,
+<a href="book-Z-H-35.html#__idx_6390">[2]</a><br /><a href="book-Z-H-29.html#__idx_5158"><tt>append-to-form</tt> (rules)</a><br /><a href="book-Z-H-26.html#__idx_4340"><tt>application?</tt></a><br /><a href="book-Z-H-10.html#__idx_342">applicative-order evaluation</a><br />
+    <a href="book-Z-H-10.html#__idx_344">in Lisp</a><br />
+    <a href="book-Z-H-10.html#__idx_482">normal order vs.</a>,
+<a href="book-Z-H-11.html#__idx_854">[2]</a>, <a href="book-Z-H-27.html#__idx_4682">[3]</a><br /><a href="book-Z-H-27.html#__idx_4724"><tt>apply</tt> (lazy)</a><br /><a href="book-Z-H-26.html#__idx_4250"><tt>apply</tt> (metacircular)</a><br />
+    <a href="book-Z-H-26.html#__idx_4578">primitive <tt>apply</tt> vs.</a><br /><a href="book-Z-H-17.html#__idx_2458"><tt>apply</tt> (primitive procedure)</a><br /><a href="book-Z-H-34.html#__idx_6072"><tt>apply-dispatch</tt></a><br />
+    <a href="book-Z-H-35.html#__idx_6474">modified for compiled code</a><br /><a href="book-Z-H-17.html#__idx_2462"><tt>apply-generic</tt></a><br />
+    <a href="book-Z-H-18.html#__idx_2590">with coercion</a>,
+<a href="book-Z-H-18.html#__idx_2626">[2]</a><br />
+    <a href="book-Z-H-18.html#__idx_2636">with coercion by raising</a><br />
+    <a href="book-Z-H-18.html#__idx_2632">with coercion of multiple arguments</a><br />
+    <a href="book-Z-H-18.html#__idx_2638">with coercion to simplify</a><br />
+    <a href="book-Z-H-17.html#__idx_2490">with message passing</a><br />
+    <a href="book-Z-H-18.html#__idx_2610">with tower of types</a><br /><a href="book-Z-H-26.html#__idx_4248"><tt>apply-primitive-procedure</tt></a>,
+<a href="book-Z-H-26.html#__idx_4440">[2]</a>, <a href="book-Z-H-26.html#__idx_4514">[3]</a><br /><a href="book-Z-H-29.html#__idx_5358"><tt>apply-rules</tt></a><br /><a href="book-Z-H-23.html#__idx_3684">arbiter</a><br /><a href="book-Z-H-17.html#__idx_2322">arctangent</a><br /><a href="book-Z-H-34.html#__idx_6028"><tt>argl</tt> register</a><br />
 argument passing, <em>see</em> call-by-name argument passing; call-by-need argument passing
-<br /><a href="book-Z-H-10.html#%_idx_188">argument(s)</a><br />
-    <a href="book-Z-H-10.html#%_idx_194">arbitrary number of</a>,
-<a href="book-Z-H-15.html#%_idx_1652">[2]</a><br />
-    <a href="book-Z-H-24.html#%_idx_4070">delayed</a><br /><a href="book-Z-H-23.html#%_idx_3688">Aristotle's <i>De caelo</i> (Buridan's commentary on)</a><br />
+<br /><a href="book-Z-H-10.html#__idx_188">argument(s)</a><br />
+    <a href="book-Z-H-10.html#__idx_194">arbitrary number of</a>,
+<a href="book-Z-H-15.html#__idx_1652">[2]</a><br />
+    <a href="book-Z-H-24.html#__idx_4070">delayed</a><br /><a href="book-Z-H-23.html#__idx_3688">Aristotle's <i>De caelo</i> (Buridan's commentary on)</a><br />
 arithmetic
 <br />
-    <a href="book-Z-H-33.html#%_idx_5840">address arithmetic</a><br />
-    <a href="book-Z-H-18.html#%_idx_2496">generic</a>,
+    <a href="book-Z-H-33.html#__idx_5840">address arithmetic</a><br />
+    <a href="book-Z-H-18.html#__idx_2496">generic</a>,
 <em>see also</em> generic arithmetic operations
 <br />
-    <a href="book-Z-H-17.html#%_idx_2302">on complex numbers</a><br />
-    <a href="book-Z-H-14.html#%_idx_1480">on intervals</a><br />
+    <a href="book-Z-H-17.html#__idx_2302">on complex numbers</a><br />
+    <a href="book-Z-H-14.html#__idx_1480">on intervals</a><br />
     on polynomials, <em>see</em> polynomial arithmetic
 <br />
-    <a href="book-Z-H-24.html#%_idx_3930">on power series</a>,
-<a href="book-Z-H-24.html#%_idx_3936">[2]</a><br />
-    <a href="book-Z-H-14.html#%_idx_1294">on rational numbers</a><br />
-    <a href="book-Z-H-10.html#%_idx_160">primitive procedures for</a><br /><a href="book-Z-H-28.html#%_idx_4960"><tt>articles</tt></a><br /><a href="book-Z-H-16.html#%_idx_2214">ASCII code</a><br /><a href="book-Z-H-32.html#%_idx_5686"><tt>assemble</tt></a>, <a href="book-Z-H-32.html#%_idx_5694">[2]</a><br /><a href="book-Z-H-32.html#%_idx_5636">assembler</a>, <a href="book-Z-H-32.html#%_idx_5682">[2]</a><br /><a href="book-Z-H-29.html#%_idx_5240"><tt>assert!</tt> (query interpreter)</a><br /><a href="book-Z-H-29.html#%_idx_5104">assertion</a><br />
-    <a href="book-Z-H-29.html#%_idx_5148">implicit</a><br /><a href="book-Z-H-31.html#%_idx_5518"><tt>assign</tt> (in register machine)</a><br />
-    <a href="book-Z-H-32.html#%_idx_5720">simulating</a><br />
-    <a href="book-Z-H-31.html#%_idx_5556">storing label in register</a><br /><a href="book-Z-H-32.html#%_idx_5724"><tt>assign-reg-name</tt></a><br /><a href="book-Z-H-32.html#%_idx_5726"><tt>assign-value-exp</tt></a><br /><a href="book-Z-H-20.html#%_idx_2836">assignment</a>, <em>see also</em> <tt>set!</tt>
-<br />
-    <a href="book-Z-H-20.html#%_idx_2916">benefits of</a><br />
-    <a href="book-Z-H-20.html#%_idx_3004">bugs associated with</a>,
-<a href="book-Z-H-20.html#%_idx_3022">[2]</a><br />
-    <a href="book-Z-H-20.html#%_idx_2976">costs of</a><br /><a href="book-Z-H-20.html#%_idx_2842">assignment operator</a>,
+    <a href="book-Z-H-24.html#__idx_3930">on power series</a>,
+<a href="book-Z-H-24.html#__idx_3936">[2]</a><br />
+    <a href="book-Z-H-14.html#__idx_1294">on rational numbers</a><br />
+    <a href="book-Z-H-10.html#__idx_160">primitive procedures for</a><br /><a href="book-Z-H-28.html#__idx_4960"><tt>articles</tt></a><br /><a href="book-Z-H-16.html#__idx_2214">ASCII code</a><br /><a href="book-Z-H-32.html#__idx_5686"><tt>assemble</tt></a>, <a href="book-Z-H-32.html#__idx_5694">[2]</a><br /><a href="book-Z-H-32.html#__idx_5636">assembler</a>, <a href="book-Z-H-32.html#__idx_5682">[2]</a><br /><a href="book-Z-H-29.html#__idx_5240"><tt>assert!</tt> (query interpreter)</a><br /><a href="book-Z-H-29.html#__idx_5104">assertion</a><br />
+    <a href="book-Z-H-29.html#__idx_5148">implicit</a><br /><a href="book-Z-H-31.html#__idx_5518"><tt>assign</tt> (in register machine)</a><br />
+    <a href="book-Z-H-32.html#__idx_5720">simulating</a><br />
+    <a href="book-Z-H-31.html#__idx_5556">storing label in register</a><br /><a href="book-Z-H-32.html#__idx_5724"><tt>assign-reg-name</tt></a><br /><a href="book-Z-H-32.html#__idx_5726"><tt>assign-value-exp</tt></a><br /><a href="book-Z-H-20.html#__idx_2836">assignment</a>, <em>see also</em> <tt>set!</tt>
+<br />
+    <a href="book-Z-H-20.html#__idx_2916">benefits of</a><br />
+    <a href="book-Z-H-20.html#__idx_3004">bugs associated with</a>,
+<a href="book-Z-H-20.html#__idx_3022">[2]</a><br />
+    <a href="book-Z-H-20.html#__idx_2976">costs of</a><br /><a href="book-Z-H-20.html#__idx_2842">assignment operator</a>,
 <em>see also</em> <tt>set!</tt>
-<br /><a href="book-Z-H-26.html#%_idx_4296"><tt>assignment-value</tt></a><br /><a href="book-Z-H-26.html#%_idx_4294"><tt>assignment-variable</tt></a><br /><a href="book-Z-H-26.html#%_idx_4292"><tt>assignment?</tt></a><br /><a href="book-Z-H-22.html#%_idx_3282"><tt>assoc</tt></a><br /><a href="book-Z-H-17.html#%_idx_2324"><tt>atan</tt> (primitive procedure)</a><br /><a href="book-Z-H-23.html#%_idx_3682">atomic operations supported in hardware</a><br /><a href="book-Z-H-23.html#%_idx_3672">atomic requirement for <tt>test-and-set!</tt></a><br /><a href="book-Z-H-17.html#%_idx_2368"><tt>attach-tag</tt></a><br />
-    <a href="book-Z-H-18.html#%_idx_2558">using Scheme data types</a><br /><a href="book-Z-H-16.html#%_idx_2076"><tt>augend</tt></a><br /><a href="book-Z-H-28.html#%_idx_4846">automagically</a><br /><a href="book-Z-H-28.html#%_idx_4808">automatic search</a>,
+<br /><a href="book-Z-H-26.html#__idx_4296"><tt>assignment-value</tt></a><br /><a href="book-Z-H-26.html#__idx_4294"><tt>assignment-variable</tt></a><br /><a href="book-Z-H-26.html#__idx_4292"><tt>assignment?</tt></a><br /><a href="book-Z-H-22.html#__idx_3282"><tt>assoc</tt></a><br /><a href="book-Z-H-17.html#__idx_2324"><tt>atan</tt> (primitive procedure)</a><br /><a href="book-Z-H-23.html#__idx_3682">atomic operations supported in hardware</a><br /><a href="book-Z-H-23.html#__idx_3672">atomic requirement for <tt>test-and-set!</tt></a><br /><a href="book-Z-H-17.html#__idx_2368"><tt>attach-tag</tt></a><br />
+    <a href="book-Z-H-18.html#__idx_2558">using Scheme data types</a><br /><a href="book-Z-H-16.html#__idx_2076"><tt>augend</tt></a><br /><a href="book-Z-H-28.html#__idx_4846">automagically</a><br /><a href="book-Z-H-28.html#__idx_4808">automatic search</a>,
 <em>see also</em> search
 <br />
-    <a href="book-Z-H-28.html#%_idx_4860">history of</a><br /><a href="book-Z-H-33.html#%_idx_5832">automatic storage allocation</a><br /><a href="book-Z-H-10.html#%_idx_516"><tt>average</tt></a><br /><a href="book-Z-H-12.html#%_idx_1128">average damping</a><br /><a href="book-Z-H-12.html#%_idx_1160"><tt>average-damp</tt></a><br /><a href="book-Z-H-22.html#%_idx_3560"><tt>averager</tt> (constraint)</a></p><p>
+    <a href="book-Z-H-28.html#__idx_4860">history of</a><br /><a href="book-Z-H-33.html#__idx_5832">automatic storage allocation</a><br /><a href="book-Z-H-10.html#__idx_516"><tt>average</tt></a><br /><a href="book-Z-H-12.html#__idx_1128">average damping</a><br /><a href="book-Z-H-12.html#__idx_1160"><tt>average-damp</tt></a><br /><a href="book-Z-H-22.html#__idx_3560"><tt>averager</tt> (constraint)</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-16.html#%_idx_2172">B-tree</a><br /><a href="book-Z-H-35.html#%_idx_6282">backquote</a><br /><a href="book-Z-H-28.html#%_idx_4852">backtracking</a>,
+<br /><a href="book-Z-H-16.html#__idx_2172">B-tree</a><br /><a href="book-Z-H-35.html#__idx_6282">backquote</a><br /><a href="book-Z-H-28.html#__idx_4852">backtracking</a>,
 <em>see also</em> nondeterministic computing
-<br /><a href="book-Z-H-24.html#%_idx_4166">Backus, John</a><br /><a href="book-Z-H-33.html#%_idx_5948">Baker, Henry G., Jr.</a><br /><a href="book-Z-H-16.html#%_idx_2164">balanced binary tree</a>,
+<br /><a href="book-Z-H-24.html#__idx_4166">Backus, John</a><br /><a href="book-Z-H-33.html#__idx_5948">Baker, Henry G., Jr.</a><br /><a href="book-Z-H-16.html#__idx_2164">balanced binary tree</a>,
 <em>see also</em> binary tree
-<br /><a href="book-Z-H-15.html#%_idx_1702">balanced mobile</a><br /><a href="book-Z-H-20.html#%_idx_2848">bank account</a>, <a href="book-Z-H-21.html#%_idx_3124">[2]</a><br />
-    <a href="book-Z-H-23.html#%_idx_3626">exchanging balances</a><br />
-    <a href="book-Z-H-20.html#%_idx_2996">joint</a>, <a href="book-Z-H-20.html#%_idx_3026">[2]</a><br />
-    <a href="book-Z-H-24.html#%_idx_4176">joint, modeled with streams</a><br />
-    <a href="book-Z-H-23.html#%_idx_3588">joint, with concurrent access</a><br />
-    <a href="book-Z-H-20.html#%_idx_2912">password-protected</a><br />
-    <a href="book-Z-H-23.html#%_idx_3614">serialized</a><br />
-    <a href="book-Z-H-24.html#%_idx_4148">stream model</a><br />
-    <a href="book-Z-H-23.html#%_idx_3636">transferring money</a><br /><a href="book-Z-H-23.html#%_idx_3710">barrier synchronization</a><br /><a href="book-Z-H-25.html#%_idx_4188">Barth, John</a><br />
+<br /><a href="book-Z-H-15.html#__idx_1702">balanced mobile</a><br /><a href="book-Z-H-20.html#__idx_2848">bank account</a>, <a href="book-Z-H-21.html#__idx_3124">[2]</a><br />
+    <a href="book-Z-H-23.html#__idx_3626">exchanging balances</a><br />
+    <a href="book-Z-H-20.html#__idx_2996">joint</a>, <a href="book-Z-H-20.html#__idx_3026">[2]</a><br />
+    <a href="book-Z-H-24.html#__idx_4176">joint, modeled with streams</a><br />
+    <a href="book-Z-H-23.html#__idx_3588">joint, with concurrent access</a><br />
+    <a href="book-Z-H-20.html#__idx_2912">password-protected</a><br />
+    <a href="book-Z-H-23.html#__idx_3614">serialized</a><br />
+    <a href="book-Z-H-24.html#__idx_4148">stream model</a><br />
+    <a href="book-Z-H-23.html#__idx_3636">transferring money</a><br /><a href="book-Z-H-23.html#__idx_3710">barrier synchronization</a><br /><a href="book-Z-H-25.html#__idx_4188">Barth, John</a><br />
 Basic
 <br />
-    <a href="book-Z-H-15.html#%_idx_1546">restrictions on compound data</a><br />
-    <a href="book-Z-H-22.html#%_idx_3570">weakness in handling compound objects</a><br /><a href="book-Z-H-34.html#%_idx_6004">Batali, John Dean</a><br /><a href="book-Z-H-20.html#%_idx_2874"><tt>begin</tt> (special form)</a><br />
-    <a href="book-Z-H-20.html#%_idx_2878">implicit in consequent of <tt>cond</tt> and in procedure body</a><br /><a href="book-Z-H-26.html#%_idx_4328"><tt>begin-actions</tt></a><br /><a href="book-Z-H-26.html#%_idx_4326"><tt>begin?</tt></a><br /><a href="book-Z-H-15.html#%_idx_1880"><tt>below</tt></a>, <a href="book-Z-H-15.html#%_idx_1976">[2]</a><br /><a href="book-Z-H-24.html#%_idx_3880">Bertrand's Hypothesis</a><br /><a href="book-Z-H-15.html#%_idx_1878"><tt>beside</tt></a>, <a href="book-Z-H-15.html#%_idx_1972">[2]</a><br /><a href="book-Z-H-33.html#%_idx_5880">bignum</a><br />
+    <a href="book-Z-H-15.html#__idx_1546">restrictions on compound data</a><br />
+    <a href="book-Z-H-22.html#__idx_3570">weakness in handling compound objects</a><br /><a href="book-Z-H-34.html#__idx_6004">Batali, John Dean</a><br /><a href="book-Z-H-20.html#__idx_2874"><tt>begin</tt> (special form)</a><br />
+    <a href="book-Z-H-20.html#__idx_2878">implicit in consequent of <tt>cond</tt> and in procedure body</a><br /><a href="book-Z-H-26.html#__idx_4328"><tt>begin-actions</tt></a><br /><a href="book-Z-H-26.html#__idx_4326"><tt>begin?</tt></a><br /><a href="book-Z-H-15.html#__idx_1880"><tt>below</tt></a>, <a href="book-Z-H-15.html#__idx_1976">[2]</a><br /><a href="book-Z-H-24.html#__idx_3880">Bertrand's Hypothesis</a><br /><a href="book-Z-H-15.html#__idx_1878"><tt>beside</tt></a>, <a href="book-Z-H-15.html#__idx_1972">[2]</a><br /><a href="book-Z-H-33.html#__idx_5880">bignum</a><br />
 binary numbers, addition of, <em>see</em> adder
-<br /><a href="book-Z-H-16.html#%_idx_2144">binary search</a><br /><a href="book-Z-H-16.html#%_idx_2142">binary tree</a><br />
-    <a href="book-Z-H-16.html#%_idx_2166">balanced</a><br />
-    <a href="book-Z-H-16.html#%_idx_2188">converting a list to a</a><br />
-    <a href="book-Z-H-16.html#%_idx_2182">converting to a list</a><br />
-    <a href="book-Z-H-16.html#%_idx_2240">for Huffman encoding</a><br />
-    <a href="book-Z-H-16.html#%_idx_2150">represented with lists</a><br />
-    <a href="book-Z-H-16.html#%_idx_2138">sets represented as</a><br />
-    <a href="book-Z-H-22.html#%_idx_3310">table structured as</a><br /><a href="book-Z-H-10.html#%_idx_588">bind</a><br /><a href="book-Z-H-21.html#%_idx_3042">binding</a><br />
-    <a href="book-Z-H-26.html#%_idx_4490">deep</a><br /><a href="book-Z-H-11.html#%_idx_740">binomial coefficients</a><br /><a href="book-Z-H-10.html#%_idx_572">black box</a><br /><a href="book-Z-H-10.html#%_idx_612">block structure</a>, <a href="book-Z-H-26.html#%_idx_4600">[2]</a><br />
-    <a href="book-Z-H-21.html#%_idx_3112">in environment model</a><br />
-    <a href="book-Z-H-29.html#%_idx_5448">in query language</a><br /><a href="book-Z-H-23.html#%_idx_3664">blocked process</a><br /><a href="book-Z-H-10.html#%_idx_324">body of a procedure</a><br /><a href="book-Z-H-9.html#%_idx_62">Bolt Beranek and Newman Inc.</a><br /><a href="book-Z-H-22.html#%_idx_3492">Borning, Alan</a><br /><a href="book-Z-H-15.html#%_idx_1788">Borodin, Alan</a><br /><a href="book-Z-H-10.html#%_idx_584">bound variable</a><br /><a href="book-Z-H-15.html#%_idx_1528">box-and-pointer notation</a><br />
-    <a href="book-Z-H-15.html#%_idx_1560">end-of-list marker</a><br /><a href="book-Z-H-31.html#%_idx_5506"><tt>branch</tt> (in register machine)</a><br />
-    <a href="book-Z-H-32.html#%_idx_5740">simulating</a><br /><a href="book-Z-H-10.html#%_idx_258">branch of a tree</a><br /><a href="book-Z-H-32.html#%_idx_5744"><tt>branch-dest</tt></a><br /><a href="book-Z-H-32.html#%_idx_5826">breakpoint</a><br /><a href="book-Z-H-33.html#%_idx_5980">broken heart</a><br /><a href="book-Z-H-9.html#%_idx_18">bug</a><br />
-    <a href="book-Z-H-10.html#%_idx_606">capturing a free variable</a><br />
-    <a href="book-Z-H-20.html#%_idx_3020">order of assignments</a><br />
-    <a href="book-Z-H-20.html#%_idx_3002">side effect with aliasing</a><br /><a href="book-Z-H-29.html#%_idx_5254">bureaucracy</a><br /><a href="book-Z-H-23.html#%_idx_3686">Buridan, Jean</a><br /><a href="book-Z-H-23.html#%_idx_3666">busy-waiting</a></p><p>
+<br /><a href="book-Z-H-16.html#__idx_2144">binary search</a><br /><a href="book-Z-H-16.html#__idx_2142">binary tree</a><br />
+    <a href="book-Z-H-16.html#__idx_2166">balanced</a><br />
+    <a href="book-Z-H-16.html#__idx_2188">converting a list to a</a><br />
+    <a href="book-Z-H-16.html#__idx_2182">converting to a list</a><br />
+    <a href="book-Z-H-16.html#__idx_2240">for Huffman encoding</a><br />
+    <a href="book-Z-H-16.html#__idx_2150">represented with lists</a><br />
+    <a href="book-Z-H-16.html#__idx_2138">sets represented as</a><br />
+    <a href="book-Z-H-22.html#__idx_3310">table structured as</a><br /><a href="book-Z-H-10.html#__idx_588">bind</a><br /><a href="book-Z-H-21.html#__idx_3042">binding</a><br />
+    <a href="book-Z-H-26.html#__idx_4490">deep</a><br /><a href="book-Z-H-11.html#__idx_740">binomial coefficients</a><br /><a href="book-Z-H-10.html#__idx_572">black box</a><br /><a href="book-Z-H-10.html#__idx_612">block structure</a>, <a href="book-Z-H-26.html#__idx_4600">[2]</a><br />
+    <a href="book-Z-H-21.html#__idx_3112">in environment model</a><br />
+    <a href="book-Z-H-29.html#__idx_5448">in query language</a><br /><a href="book-Z-H-23.html#__idx_3664">blocked process</a><br /><a href="book-Z-H-10.html#__idx_324">body of a procedure</a><br /><a href="book-Z-H-9.html#__idx_62">Bolt Beranek and Newman Inc.</a><br /><a href="book-Z-H-22.html#__idx_3492">Borning, Alan</a><br /><a href="book-Z-H-15.html#__idx_1788">Borodin, Alan</a><br /><a href="book-Z-H-10.html#__idx_584">bound variable</a><br /><a href="book-Z-H-15.html#__idx_1528">box-and-pointer notation</a><br />
+    <a href="book-Z-H-15.html#__idx_1560">end-of-list marker</a><br /><a href="book-Z-H-31.html#__idx_5506"><tt>branch</tt> (in register machine)</a><br />
+    <a href="book-Z-H-32.html#__idx_5740">simulating</a><br /><a href="book-Z-H-10.html#__idx_258">branch of a tree</a><br /><a href="book-Z-H-32.html#__idx_5744"><tt>branch-dest</tt></a><br /><a href="book-Z-H-32.html#__idx_5826">breakpoint</a><br /><a href="book-Z-H-33.html#__idx_5980">broken heart</a><br /><a href="book-Z-H-9.html#__idx_18">bug</a><br />
+    <a href="book-Z-H-10.html#__idx_606">capturing a free variable</a><br />
+    <a href="book-Z-H-20.html#__idx_3020">order of assignments</a><br />
+    <a href="book-Z-H-20.html#__idx_3002">side effect with aliasing</a><br /><a href="book-Z-H-29.html#__idx_5254">bureaucracy</a><br /><a href="book-Z-H-23.html#__idx_3686">Buridan, Jean</a><br /><a href="book-Z-H-23.html#__idx_3666">busy-waiting</a></p><p>
 
 </p><p></p><p>
 
 <br />
 C
 <br />
-    <a href="book-Z-H-35.html#%_idx_6520">compiling Scheme into</a><br />
-    <a href="book-Z-H-34.html#%_idx_6186">error handling</a>,
-<a href="book-Z-H-35.html#%_idx_6496">[2]</a><br />
-    <a href="book-Z-H-11.html#%_idx_688">recursive procedures</a><br />
-    <a href="book-Z-H-15.html#%_idx_1550">restrictions on compound data</a><br />
-    <a href="book-Z-H-35.html#%_idx_6518">Scheme interpreter written in</a>,
-<a href="book-Z-H-35.html#%_idx_6522">[2]</a><br /><a href="book-Z-H-15.html#%_idx_1588"><tt>ca<tt>...</tt>r</tt></a><br /><a href="book-Z-H-23.html#%_idx_3594">cache-coherence protocols</a><br /><a href="book-Z-H-15.html#%_idx_1586"><tt>cadr</tt></a><br /><a href="book-Z-H-12.html#%_idx_1108">calculator, fixed points with</a><br /><a href="book-Z-H-24.html#%_idx_3808">call-by-name argument passing</a>,
-<a href="book-Z-H-27.html#%_idx_4714">[2]</a><br /><a href="book-Z-H-24.html#%_idx_3816">call-by-need argument passing</a>,
-<a href="book-Z-H-27.html#%_idx_4712">[2]</a><br />
-    <a href="book-Z-H-24.html#%_idx_3902">memoization and</a><br /><a href="book-Z-H-22.html#%_idx_3398"><tt>call-each</tt></a><br /><a href="book-Z-H-10.html#%_idx_286">cancer of the semicolon</a><br /><a href="book-Z-H-18.html#%_idx_2770">canonical form, for polynomials</a><br /><a href="book-Z-H-10.html#%_idx_604">capturing a free variable</a><br /><a href="book-Z-H-14.html#%_idx_1324"><tt>car</tt> (primitive procedure)</a><br />
-    <a href="book-Z-H-14.html#%_idx_1454">axiom for</a><br />
-    <a href="book-Z-H-33.html#%_idx_5896">implemented with vectors</a><br />
-    <a href="book-Z-H-15.html#%_idx_1580">as list operation</a><br />
-    <a href="book-Z-H-14.html#%_idx_1334">origin of the name</a><br />
-    <a href="book-Z-H-14.html#%_idx_1462">procedural implementation of</a>,
-<a href="book-Z-H-14.html#%_idx_1470">[2]</a>, <a href="book-Z-H-22.html#%_idx_3206">[3]</a>,
-<a href="book-Z-H-22.html#%_idx_3212">[4]</a>, <a href="book-Z-H-27.html#%_idx_4776">[5]</a><br /><a href="book-Z-H-11.html#%_idx_912">Carmichael numbers</a>,
-<a href="book-Z-H-11.html#%_idx_948">[2]</a><br />
+    <a href="book-Z-H-35.html#__idx_6520">compiling Scheme into</a><br />
+    <a href="book-Z-H-34.html#__idx_6186">error handling</a>,
+<a href="book-Z-H-35.html#__idx_6496">[2]</a><br />
+    <a href="book-Z-H-11.html#__idx_688">recursive procedures</a><br />
+    <a href="book-Z-H-15.html#__idx_1550">restrictions on compound data</a><br />
+    <a href="book-Z-H-35.html#__idx_6518">Scheme interpreter written in</a>,
+<a href="book-Z-H-35.html#__idx_6522">[2]</a><br /><a href="book-Z-H-15.html#__idx_1588"><tt>ca<tt>...</tt>r</tt></a><br /><a href="book-Z-H-23.html#__idx_3594">cache-coherence protocols</a><br /><a href="book-Z-H-15.html#__idx_1586"><tt>cadr</tt></a><br /><a href="book-Z-H-12.html#__idx_1108">calculator, fixed points with</a><br /><a href="book-Z-H-24.html#__idx_3808">call-by-name argument passing</a>,
+<a href="book-Z-H-27.html#__idx_4714">[2]</a><br /><a href="book-Z-H-24.html#__idx_3816">call-by-need argument passing</a>,
+<a href="book-Z-H-27.html#__idx_4712">[2]</a><br />
+    <a href="book-Z-H-24.html#__idx_3902">memoization and</a><br /><a href="book-Z-H-22.html#__idx_3398"><tt>call-each</tt></a><br /><a href="book-Z-H-10.html#__idx_286">cancer of the semicolon</a><br /><a href="book-Z-H-18.html#__idx_2770">canonical form, for polynomials</a><br /><a href="book-Z-H-10.html#__idx_604">capturing a free variable</a><br /><a href="book-Z-H-14.html#__idx_1324"><tt>car</tt> (primitive procedure)</a><br />
+    <a href="book-Z-H-14.html#__idx_1454">axiom for</a><br />
+    <a href="book-Z-H-33.html#__idx_5896">implemented with vectors</a><br />
+    <a href="book-Z-H-15.html#__idx_1580">as list operation</a><br />
+    <a href="book-Z-H-14.html#__idx_1334">origin of the name</a><br />
+    <a href="book-Z-H-14.html#__idx_1462">procedural implementation of</a>,
+<a href="book-Z-H-14.html#__idx_1470">[2]</a>, <a href="book-Z-H-22.html#__idx_3206">[3]</a>,
+<a href="book-Z-H-22.html#__idx_3212">[4]</a>, <a href="book-Z-H-27.html#__idx_4776">[5]</a><br /><a href="book-Z-H-11.html#__idx_912">Carmichael numbers</a>,
+<a href="book-Z-H-11.html#__idx_948">[2]</a><br />
 case analysis
 <br />
-    <a href="book-Z-H-26.html#%_idx_4246">data-directed programming vs.</a><br />
-    <a href="book-Z-H-10.html#%_idx_350">general</a>, <em>see also</em> <tt>cond</tt>
-<br />
-    <a href="book-Z-H-10.html#%_idx_426">with two cases (<tt>if</tt>)</a><br /><a href="book-Z-H-15.html#%_idx_1590"><tt>cd<tt>...</tt>r</tt></a><br /><a href="book-Z-H-14.html#%_idx_1328"><tt>cdr</tt> (primitive procedure)</a><br />
-    <a href="book-Z-H-14.html#%_idx_1456">axiom for</a><br />
-    <a href="book-Z-H-33.html#%_idx_5898">implemented with vectors</a><br />
-    <a href="book-Z-H-15.html#%_idx_1582">as list operation</a><br />
-    <a href="book-Z-H-14.html#%_idx_1336">origin of the name</a><br />
-    <a href="book-Z-H-14.html#%_idx_1464">procedural implementation of</a>,
-<a href="book-Z-H-14.html#%_idx_1472">[2]</a>, <a href="book-Z-H-22.html#%_idx_3208">[3]</a>,
-<a href="book-Z-H-22.html#%_idx_3214">[4]</a>, <a href="book-Z-H-27.html#%_idx_4778">[5]</a><br /><a href="book-Z-H-15.html#%_idx_1606"><tt>cdr</tt> down a list</a><br /><a href="book-Z-H-23.html#%_idx_3662">cell, in serializer implementation</a><br /><a href="book-Z-H-22.html#%_idx_3518"><tt>celsius-fahrenheit-converter</tt></a><br />
-    <a href="book-Z-H-22.html#%_idx_3566">expression-oriented</a><br /><a href="book-Z-H-14.html#%_idx_1518"><tt>center</tt></a><br /><a href="book-Z-H-20.html#%_idx_2942">Cesàro, Ernesto</a><br /><a href="book-Z-H-24.html#%_idx_4128"><tt>cesaro-stream</tt></a><br /><a href="book-Z-H-20.html#%_idx_2950"><tt>cesaro-test</tt></a><br /><a href="book-Z-H-20.html#%_idx_2932">Chaitin, Gregory</a><br /><a href="book-Z-H-11.html#%_idx_810">Chandah-sutra</a><br />
+    <a href="book-Z-H-26.html#__idx_4246">data-directed programming vs.</a><br />
+    <a href="book-Z-H-10.html#__idx_350">general</a>, <em>see also</em> <tt>cond</tt>
+<br />
+    <a href="book-Z-H-10.html#__idx_426">with two cases (<tt>if</tt>)</a><br /><a href="book-Z-H-15.html#__idx_1590"><tt>cd<tt>...</tt>r</tt></a><br /><a href="book-Z-H-14.html#__idx_1328"><tt>cdr</tt> (primitive procedure)</a><br />
+    <a href="book-Z-H-14.html#__idx_1456">axiom for</a><br />
+    <a href="book-Z-H-33.html#__idx_5898">implemented with vectors</a><br />
+    <a href="book-Z-H-15.html#__idx_1582">as list operation</a><br />
+    <a href="book-Z-H-14.html#__idx_1336">origin of the name</a><br />
+    <a href="book-Z-H-14.html#__idx_1464">procedural implementation of</a>,
+<a href="book-Z-H-14.html#__idx_1472">[2]</a>, <a href="book-Z-H-22.html#__idx_3208">[3]</a>,
+<a href="book-Z-H-22.html#__idx_3214">[4]</a>, <a href="book-Z-H-27.html#__idx_4778">[5]</a><br /><a href="book-Z-H-15.html#__idx_1606"><tt>cdr</tt> down a list</a><br /><a href="book-Z-H-23.html#__idx_3662">cell, in serializer implementation</a><br /><a href="book-Z-H-22.html#__idx_3518"><tt>celsius-fahrenheit-converter</tt></a><br />
+    <a href="book-Z-H-22.html#__idx_3566">expression-oriented</a><br /><a href="book-Z-H-14.html#__idx_1518"><tt>center</tt></a><br /><a href="book-Z-H-20.html#__idx_2942">Cesàro, Ernesto</a><br /><a href="book-Z-H-24.html#__idx_4128"><tt>cesaro-stream</tt></a><br /><a href="book-Z-H-20.html#__idx_2950"><tt>cesaro-test</tt></a><br /><a href="book-Z-H-20.html#__idx_2932">Chaitin, Gregory</a><br /><a href="book-Z-H-11.html#__idx_810">Chandah-sutra</a><br />
 change and sameness
 <br />
-    <a href="book-Z-H-20.html#%_idx_2988">meaning of</a><br />
-    <a href="book-Z-H-22.html#%_idx_3182">shared data and</a><br />
+    <a href="book-Z-H-20.html#__idx_2988">meaning of</a><br />
+    <a href="book-Z-H-22.html#__idx_3182">shared data and</a><br />
 changing money, <em>see</em> counting change
-<br /><a href="book-Z-H-9.html#%_idx_104">chaos in the Solar System</a><br /><a href="book-Z-H-28.html#%_idx_4904">Chapman, David</a><br />
+<br /><a href="book-Z-H-9.html#__idx_104">chaos in the Solar System</a><br /><a href="book-Z-H-28.html#__idx_4904">Chapman, David</a><br />
 character strings
 <br />
-    <a href="book-Z-H-29.html#%_idx_5410">primitive procedures for</a>,
-<a href="book-Z-H-35.html#%_idx_6320">[2]</a><br />
-    <a href="book-Z-H-16.html#%_idx_2006">quotation of</a><br /><a href="book-Z-H-16.html#%_idx_2218">character, ASCII encoding</a><br /><a href="book-Z-H-28.html#%_idx_4872">Charniak, Eugene</a><br /><a href="book-Z-H-24.html#%_idx_3878">Chebyshev, Pafnutii L'vovich</a><br /><a href="book-Z-H-15.html#%_idx_1848">chess, eight-queens puzzle</a>,
-<a href="book-Z-H-28.html#%_idx_4944">[2]</a><br /><a href="book-Z-H-34.html#%_idx_6002">chip implementation of Scheme</a>,
-<a href="book-Z-H-34.html#%_idx_6014">[2]</a><br /><a href="book-Z-H-28.html#%_idx_4858">chronological backtracking</a><br /><a href="book-Z-H-11.html#%_idx_750">Chu Shih-chieh</a><br /><a href="book-Z-H-14.html#%_idx_1474">Church numerals</a><br /><a href="book-Z-H-12.html#%_idx_1056">Church, Alonzo</a>, <a href="book-Z-H-14.html#%_idx_1476">[2]</a><br /><a href="book-Z-H-26.html#%_idx_4562">Church-Turing thesis</a><br />
+    <a href="book-Z-H-29.html#__idx_5410">primitive procedures for</a>,
+<a href="book-Z-H-35.html#__idx_6320">[2]</a><br />
+    <a href="book-Z-H-16.html#__idx_2006">quotation of</a><br /><a href="book-Z-H-16.html#__idx_2218">character, ASCII encoding</a><br /><a href="book-Z-H-28.html#__idx_4872">Charniak, Eugene</a><br /><a href="book-Z-H-24.html#__idx_3878">Chebyshev, Pafnutii L'vovich</a><br /><a href="book-Z-H-15.html#__idx_1848">chess, eight-queens puzzle</a>,
+<a href="book-Z-H-28.html#__idx_4944">[2]</a><br /><a href="book-Z-H-34.html#__idx_6002">chip implementation of Scheme</a>,
+<a href="book-Z-H-34.html#__idx_6014">[2]</a><br /><a href="book-Z-H-28.html#__idx_4858">chronological backtracking</a><br /><a href="book-Z-H-11.html#__idx_750">Chu Shih-chieh</a><br /><a href="book-Z-H-14.html#__idx_1474">Church numerals</a><br /><a href="book-Z-H-12.html#__idx_1056">Church, Alonzo</a>, <a href="book-Z-H-14.html#__idx_1476">[2]</a><br /><a href="book-Z-H-26.html#__idx_4562">Church-Turing thesis</a><br />
 circuit
 <br />
     digital, <em>see</em> digital-circuit simulation
 <br />
-    <a href="book-Z-H-24.html#%_idx_4030">modeled with streams</a>,
-<a href="book-Z-H-24.html#%_idx_4088">[2]</a><br /><a href="book-Z-H-29.html#%_idx_5274">Clark, Keith L.</a><br /><a href="book-Z-H-10.html#%_idx_362">clause, of a <tt>cond</tt></a><br />
-    <a href="book-Z-H-26.html#%_idx_4402">additional syntax</a><br /><a href="book-Z-H-26.html#%_idx_4378">Clinger, William</a>,
-<a href="book-Z-H-27.html#%_idx_4718">[2]</a><br /><a href="book-Z-H-29.html#%_idx_5272">closed world assumption</a><br /><a href="book-Z-H-13.html#%_idx_1266">closure</a><br />
-    <a href="book-Z-H-15.html#%_idx_1536">in abstract algebra</a><br />
-    <a href="book-Z-H-15.html#%_idx_1532">closure property of <tt>cons</tt></a><br />
-    <a href="book-Z-H-15.html#%_idx_1860">closure property of picture-language operations</a>, <a href="book-Z-H-15.html#%_idx_1886">[2]</a><br />
-    <a href="book-Z-H-15.html#%_idx_1542">lack of in many languages</a><br /><a href="book-Z-H-15.html#%_idx_1872">coal, bituminous</a><br />
+    <a href="book-Z-H-24.html#__idx_4030">modeled with streams</a>,
+<a href="book-Z-H-24.html#__idx_4088">[2]</a><br /><a href="book-Z-H-29.html#__idx_5274">Clark, Keith L.</a><br /><a href="book-Z-H-10.html#__idx_362">clause, of a <tt>cond</tt></a><br />
+    <a href="book-Z-H-26.html#__idx_4402">additional syntax</a><br /><a href="book-Z-H-26.html#__idx_4378">Clinger, William</a>,
+<a href="book-Z-H-27.html#__idx_4718">[2]</a><br /><a href="book-Z-H-29.html#__idx_5272">closed world assumption</a><br /><a href="book-Z-H-13.html#__idx_1266">closure</a><br />
+    <a href="book-Z-H-15.html#__idx_1536">in abstract algebra</a><br />
+    <a href="book-Z-H-15.html#__idx_1532">closure property of <tt>cons</tt></a><br />
+    <a href="book-Z-H-15.html#__idx_1860">closure property of picture-language operations</a>, <a href="book-Z-H-15.html#__idx_1886">[2]</a><br />
+    <a href="book-Z-H-15.html#__idx_1542">lack of in many languages</a><br /><a href="book-Z-H-15.html#__idx_1872">coal, bituminous</a><br />
 code
 <br />
-    <a href="book-Z-H-16.html#%_idx_2216">ASCII</a><br />
-    <a href="book-Z-H-16.html#%_idx_2222">fixed-length</a><br />
+    <a href="book-Z-H-16.html#__idx_2216">ASCII</a><br />
+    <a href="book-Z-H-16.html#__idx_2222">fixed-length</a><br />
     Huffman, <em>see</em> Huffman code
 <br />
-    <a href="book-Z-H-16.html#%_idx_2230">Morse</a><br />
-    <a href="book-Z-H-16.html#%_idx_2236">prefix</a><br />
-    <a href="book-Z-H-16.html#%_idx_2226">variable-length</a><br /><a href="book-Z-H-35.html#%_idx_6242">code generator</a><br />
-    <a href="book-Z-H-35.html#%_idx_6246">arguments of</a><br />
-    <a href="book-Z-H-35.html#%_idx_6258">value of</a><br /><a href="book-Z-H-18.html#%_idx_2706"><tt>coeff</tt></a>, <a href="book-Z-H-18.html#%_idx_2748">[2]</a><br /><a href="book-Z-H-18.html#%_idx_2580">coercion</a><br />
-    <a href="book-Z-H-18.html#%_idx_2774">in algebraic manipulation</a><br />
-    <a href="book-Z-H-18.html#%_idx_2718">in polynomial arithmetic</a><br />
-    <a href="book-Z-H-18.html#%_idx_2582">procedure</a><br />
-    <a href="book-Z-H-18.html#%_idx_2588">table</a><br /><a href="book-Z-H-29.html#%_idx_5054">Colmerauer, Alain</a><br /><a href="book-Z-H-10.html#%_idx_156">combination</a><br />
-    <a href="book-Z-H-12.html#%_idx_1162">combination as operator of</a><br />
-    <a href="book-Z-H-10.html#%_idx_474">compound expression as operator of</a><br />
-    <a href="book-Z-H-10.html#%_idx_244">evaluation of</a><br />
-    <a href="book-Z-H-12.html#%_idx_1048"><tt>lambda</tt> expression as operator of</a><br />
-    <a href="book-Z-H-12.html#%_idx_1164">as operator of combination</a><br />
-    <a href="book-Z-H-10.html#%_idx_252">as a tree</a><br /><a href="book-Z-H-10.html#%_idx_124">combination, means of</a>,
+    <a href="book-Z-H-16.html#__idx_2230">Morse</a><br />
+    <a href="book-Z-H-16.html#__idx_2236">prefix</a><br />
+    <a href="book-Z-H-16.html#__idx_2226">variable-length</a><br /><a href="book-Z-H-35.html#__idx_6242">code generator</a><br />
+    <a href="book-Z-H-35.html#__idx_6246">arguments of</a><br />
+    <a href="book-Z-H-35.html#__idx_6258">value of</a><br /><a href="book-Z-H-18.html#__idx_2706"><tt>coeff</tt></a>, <a href="book-Z-H-18.html#__idx_2748">[2]</a><br /><a href="book-Z-H-18.html#__idx_2580">coercion</a><br />
+    <a href="book-Z-H-18.html#__idx_2774">in algebraic manipulation</a><br />
+    <a href="book-Z-H-18.html#__idx_2718">in polynomial arithmetic</a><br />
+    <a href="book-Z-H-18.html#__idx_2582">procedure</a><br />
+    <a href="book-Z-H-18.html#__idx_2588">table</a><br /><a href="book-Z-H-29.html#__idx_5054">Colmerauer, Alain</a><br /><a href="book-Z-H-10.html#__idx_156">combination</a><br />
+    <a href="book-Z-H-12.html#__idx_1162">combination as operator of</a><br />
+    <a href="book-Z-H-10.html#__idx_474">compound expression as operator of</a><br />
+    <a href="book-Z-H-10.html#__idx_244">evaluation of</a><br />
+    <a href="book-Z-H-12.html#__idx_1048"><tt>lambda</tt> expression as operator of</a><br />
+    <a href="book-Z-H-12.html#__idx_1164">as operator of combination</a><br />
+    <a href="book-Z-H-10.html#__idx_252">as a tree</a><br /><a href="book-Z-H-10.html#__idx_124">combination, means of</a>,
 <em>see also</em> closure
-<br /><a href="book-Z-H-35.html#%_idx_6290">comma, used with backquote</a><br /><a href="book-Z-H-15.html#%_idx_1836">comments in programs</a><br /><a href="book-Z-H-9.html#%_idx_92">Common Lisp</a><br />
-    <a href="book-Z-H-15.html#%_idx_1600">treatment of <tt>nil</tt></a><br /><a href="book-Z-H-33.html#%_idx_5962">compacting garbage collector</a><br />
+<br /><a href="book-Z-H-35.html#__idx_6290">comma, used with backquote</a><br /><a href="book-Z-H-15.html#__idx_1836">comments in programs</a><br /><a href="book-Z-H-9.html#__idx_92">Common Lisp</a><br />
+    <a href="book-Z-H-15.html#__idx_1600">treatment of <tt>nil</tt></a><br /><a href="book-Z-H-33.html#__idx_5962">compacting garbage collector</a><br />
 compilation, <em>see</em> compiler
-<br /><a href="book-Z-H-35.html#%_idx_6244"><tt>compile</tt></a><br /><a href="book-Z-H-35.html#%_idx_6472"><tt>compile-and-go</tt></a>,
-<a href="book-Z-H-35.html#%_idx_6484">[2]</a><br /><a href="book-Z-H-35.html#%_idx_6514"><tt>compile-and-run</tt></a><br /><a href="book-Z-H-35.html#%_idx_6346"><tt>compile-application</tt></a><br /><a href="book-Z-H-35.html#%_idx_6312"><tt>compile-assignment</tt></a><br /><a href="book-Z-H-35.html#%_idx_6314"><tt>compile-definition</tt></a><br /><a href="book-Z-H-35.html#%_idx_6324"><tt>compile-if</tt></a><br /><a href="book-Z-H-35.html#%_idx_6340"><tt>compile-lambda</tt></a><br /><a href="book-Z-H-35.html#%_idx_6292"><tt>compile-linkage</tt></a><br /><a href="book-Z-H-35.html#%_idx_6376"><tt>compile-proc-appl</tt></a><br /><a href="book-Z-H-35.html#%_idx_6350"><tt>compile-procedure-call</tt></a><br /><a href="book-Z-H-35.html#%_idx_6304"><tt>compile-quoted</tt></a><br /><a href="book-Z-H-35.html#%_idx_6302"><tt>compile-self-evaluating</tt></a><br /><a href="book-Z-H-35.html#%_idx_6328"><tt>compile-sequence</tt></a><br /><a href="book-Z-H-35.html#%_idx_6440">compile-time environment</a>,
-<a href="book-Z-H-35.html#%_idx_6450">[2]</a>, <a href="book-Z-H-35.html#%_idx_6452">[3]</a><br />
-    <a href="book-Z-H-35.html#%_idx_6464">open coding and</a><br /><a href="book-Z-H-35.html#%_idx_6306"><tt>compile-variable</tt></a><br /><a href="book-Z-H-35.html#%_idx_6476"><tt>compiled-apply</tt></a><br /><a href="book-Z-H-35.html#%_idx_6336"><tt>compiled-procedure-entry</tt></a><br /><a href="book-Z-H-35.html#%_idx_6338"><tt>compiled-procedure-env</tt></a><br /><a href="book-Z-H-35.html#%_idx_6334"><tt>compiled-procedure?</tt></a><br /><a href="book-Z-H-35.html#%_idx_6194">compiler</a><br />
-    <a href="book-Z-H-35.html#%_idx_6210">interpreter vs.</a>,
-<a href="book-Z-H-35.html#%_idx_6492">[2]</a><br />
-    <a href="book-Z-H-35.html#%_idx_6356">tail recursion, stack allocation, and garbage-collection</a><br /><a href="book-Z-H-35.html#%_idx_6224">compiler for Scheme</a>,
+<br /><a href="book-Z-H-35.html#__idx_6244"><tt>compile</tt></a><br /><a href="book-Z-H-35.html#__idx_6472"><tt>compile-and-go</tt></a>,
+<a href="book-Z-H-35.html#__idx_6484">[2]</a><br /><a href="book-Z-H-35.html#__idx_6514"><tt>compile-and-run</tt></a><br /><a href="book-Z-H-35.html#__idx_6346"><tt>compile-application</tt></a><br /><a href="book-Z-H-35.html#__idx_6312"><tt>compile-assignment</tt></a><br /><a href="book-Z-H-35.html#__idx_6314"><tt>compile-definition</tt></a><br /><a href="book-Z-H-35.html#__idx_6324"><tt>compile-if</tt></a><br /><a href="book-Z-H-35.html#__idx_6340"><tt>compile-lambda</tt></a><br /><a href="book-Z-H-35.html#__idx_6292"><tt>compile-linkage</tt></a><br /><a href="book-Z-H-35.html#__idx_6376"><tt>compile-proc-appl</tt></a><br /><a href="book-Z-H-35.html#__idx_6350"><tt>compile-procedure-call</tt></a><br /><a href="book-Z-H-35.html#__idx_6304"><tt>compile-quoted</tt></a><br /><a href="book-Z-H-35.html#__idx_6302"><tt>compile-self-evaluating</tt></a><br /><a href="book-Z-H-35.html#__idx_6328"><tt>compile-sequence</tt></a><br /><a href="book-Z-H-35.html#__idx_6440">compile-time environment</a>,
+<a href="book-Z-H-35.html#__idx_6450">[2]</a>, <a href="book-Z-H-35.html#__idx_6452">[3]</a><br />
+    <a href="book-Z-H-35.html#__idx_6464">open coding and</a><br /><a href="book-Z-H-35.html#__idx_6306"><tt>compile-variable</tt></a><br /><a href="book-Z-H-35.html#__idx_6476"><tt>compiled-apply</tt></a><br /><a href="book-Z-H-35.html#__idx_6336"><tt>compiled-procedure-entry</tt></a><br /><a href="book-Z-H-35.html#__idx_6338"><tt>compiled-procedure-env</tt></a><br /><a href="book-Z-H-35.html#__idx_6334"><tt>compiled-procedure?</tt></a><br /><a href="book-Z-H-35.html#__idx_6194">compiler</a><br />
+    <a href="book-Z-H-35.html#__idx_6210">interpreter vs.</a>,
+<a href="book-Z-H-35.html#__idx_6492">[2]</a><br />
+    <a href="book-Z-H-35.html#__idx_6356">tail recursion, stack allocation, and garbage-collection</a><br /><a href="book-Z-H-35.html#__idx_6224">compiler for Scheme</a>,
 <em>see also</em> code generator; compile-time environment; instruction sequence; linkage descriptor; target register
 <br />
-    <a href="book-Z-H-35.html#%_idx_6234">analyzing evaluator vs.</a>,
-<a href="book-Z-H-35.html#%_idx_6238">[2]</a><br />
-    <a href="book-Z-H-35.html#%_idx_6308">assignments</a><br />
+    <a href="book-Z-H-35.html#__idx_6234">analyzing evaluator vs.</a>,
+<a href="book-Z-H-35.html#__idx_6238">[2]</a><br />
+    <a href="book-Z-H-35.html#__idx_6308">assignments</a><br />
     code generators, <em>see</em> <tt>compile-...</tt>
 <br />
-    <a href="book-Z-H-35.html#%_idx_6344">combinations</a><br />
-    <a href="book-Z-H-35.html#%_idx_6316">conditionals</a><br />
-    <a href="book-Z-H-35.html#%_idx_6310">definitions</a><br />
-    <a href="book-Z-H-35.html#%_idx_6232">efficiency</a><br />
-    <a href="book-Z-H-35.html#%_idx_6404">example compilation</a><br />
-    <a href="book-Z-H-35.html#%_idx_6226">explicit-control evaluator vs.</a>,
-<a href="book-Z-H-35.html#%_idx_6274">[2]</a>, <a href="book-Z-H-35.html#%_idx_6488">[3]</a><br />
-    <a href="book-Z-H-35.html#%_idx_6240">expression-syntax procedures</a><br />
-    <a href="book-Z-H-35.html#%_idx_6466">interfacing to evaluator</a><br />
-    <a href="book-Z-H-35.html#%_idx_6318">label generation</a><br />
-    <a href="book-Z-H-35.html#%_idx_6330"><tt>lambda</tt> expressions</a><br />
-    <a href="book-Z-H-35.html#%_idx_6428">lexical addressing</a><br />
-    <a href="book-Z-H-35.html#%_idx_6278">linkage code</a><br />
-    <a href="book-Z-H-35.html#%_idx_6222">machine-operation use</a><br />
-    <a href="book-Z-H-35.html#%_idx_6486">monitoring performance (stack use) of compiled code</a>, <a href="book-Z-H-35.html#%_idx_6506">[2]</a>,
-<a href="book-Z-H-35.html#%_idx_6510">[3]</a><br />
-    <a href="book-Z-H-35.html#%_idx_6422">open coding of primitives</a>,
-<a href="book-Z-H-35.html#%_idx_6458">[2]</a><br />
-    <a href="book-Z-H-35.html#%_idx_6416">order of operand evaluation</a><br />
-    <a href="book-Z-H-35.html#%_idx_6342">procedure applications</a><br />
-    <a href="book-Z-H-35.html#%_idx_6298">quotations</a><br />
-    <a href="book-Z-H-35.html#%_idx_6220">register use</a>,
-<a href="book-Z-H-35.html#%_idx_6228">[2]</a>, <a href="book-Z-H-35.html#%_idx_6372">[3]</a><br />
-    <a href="book-Z-H-35.html#%_idx_6468">running compiled code</a><br />
-    <a href="book-Z-H-35.html#%_idx_6448">scanning out internal definitions</a>,
-<a href="book-Z-H-35.html#%_idx_6456">[2]</a><br />
-    <a href="book-Z-H-35.html#%_idx_6296">self-evaluating expressions</a><br />
-    <a href="book-Z-H-35.html#%_idx_6326">sequences of expressions</a><br />
-    <a href="book-Z-H-35.html#%_idx_6262">stack usage</a>,
-<a href="book-Z-H-35.html#%_idx_6270">[2]</a>, <a href="book-Z-H-35.html#%_idx_6418">[3]</a><br />
-    <a href="book-Z-H-35.html#%_idx_6236">structure of</a><br />
-    <a href="book-Z-H-35.html#%_idx_6352">tail-recursive code generated by</a><br />
-    <a href="book-Z-H-35.html#%_idx_6300">variables</a><br /><a href="book-Z-H-18.html#%_idx_2538"><tt>complex</tt> package</a><br />
+    <a href="book-Z-H-35.html#__idx_6344">combinations</a><br />
+    <a href="book-Z-H-35.html#__idx_6316">conditionals</a><br />
+    <a href="book-Z-H-35.html#__idx_6310">definitions</a><br />
+    <a href="book-Z-H-35.html#__idx_6232">efficiency</a><br />
+    <a href="book-Z-H-35.html#__idx_6404">example compilation</a><br />
+    <a href="book-Z-H-35.html#__idx_6226">explicit-control evaluator vs.</a>,
+<a href="book-Z-H-35.html#__idx_6274">[2]</a>, <a href="book-Z-H-35.html#__idx_6488">[3]</a><br />
+    <a href="book-Z-H-35.html#__idx_6240">expression-syntax procedures</a><br />
+    <a href="book-Z-H-35.html#__idx_6466">interfacing to evaluator</a><br />
+    <a href="book-Z-H-35.html#__idx_6318">label generation</a><br />
+    <a href="book-Z-H-35.html#__idx_6330"><tt>lambda</tt> expressions</a><br />
+    <a href="book-Z-H-35.html#__idx_6428">lexical addressing</a><br />
+    <a href="book-Z-H-35.html#__idx_6278">linkage code</a><br />
+    <a href="book-Z-H-35.html#__idx_6222">machine-operation use</a><br />
+    <a href="book-Z-H-35.html#__idx_6486">monitoring performance (stack use) of compiled code</a>, <a href="book-Z-H-35.html#__idx_6506">[2]</a>,
+<a href="book-Z-H-35.html#__idx_6510">[3]</a><br />
+    <a href="book-Z-H-35.html#__idx_6422">open coding of primitives</a>,
+<a href="book-Z-H-35.html#__idx_6458">[2]</a><br />
+    <a href="book-Z-H-35.html#__idx_6416">order of operand evaluation</a><br />
+    <a href="book-Z-H-35.html#__idx_6342">procedure applications</a><br />
+    <a href="book-Z-H-35.html#__idx_6298">quotations</a><br />
+    <a href="book-Z-H-35.html#__idx_6220">register use</a>,
+<a href="book-Z-H-35.html#__idx_6228">[2]</a>, <a href="book-Z-H-35.html#__idx_6372">[3]</a><br />
+    <a href="book-Z-H-35.html#__idx_6468">running compiled code</a><br />
+    <a href="book-Z-H-35.html#__idx_6448">scanning out internal definitions</a>,
+<a href="book-Z-H-35.html#__idx_6456">[2]</a><br />
+    <a href="book-Z-H-35.html#__idx_6296">self-evaluating expressions</a><br />
+    <a href="book-Z-H-35.html#__idx_6326">sequences of expressions</a><br />
+    <a href="book-Z-H-35.html#__idx_6262">stack usage</a>,
+<a href="book-Z-H-35.html#__idx_6270">[2]</a>, <a href="book-Z-H-35.html#__idx_6418">[3]</a><br />
+    <a href="book-Z-H-35.html#__idx_6236">structure of</a><br />
+    <a href="book-Z-H-35.html#__idx_6352">tail-recursive code generated by</a><br />
+    <a href="book-Z-H-35.html#__idx_6300">variables</a><br /><a href="book-Z-H-18.html#__idx_2538"><tt>complex</tt> package</a><br />
 complex numbers
 <br />
-    <a href="book-Z-H-17.html#%_idx_2340">polar representation</a><br />
-    <a href="book-Z-H-17.html#%_idx_2320">rectangular representation</a><br />
-    <a href="book-Z-H-17.html#%_idx_2306">rectangular vs. polar form</a><br />
-    <a href="book-Z-H-17.html#%_idx_2356">represented as tagged data</a><br /><a href="book-Z-H-18.html#%_idx_2630"><tt>complex-&gt;complex</tt></a><br /><a href="book-Z-H-17.html#%_idx_2300">complex-number arithmetic</a><br />
-    <a href="book-Z-H-18.html#%_idx_2540">interfaced to generic arithmetic system</a><br />
-    <a href="book-Z-H-17.html#%_idx_2418">structure of system</a><br /><a href="book-Z-H-12.html#%_idx_1226">composition of functions</a><br /><a href="book-Z-H-13.html#%_idx_1256">compound data, need for</a><br /><a href="book-Z-H-10.html#%_idx_154">compound expression</a>,
+    <a href="book-Z-H-17.html#__idx_2340">polar representation</a><br />
+    <a href="book-Z-H-17.html#__idx_2320">rectangular representation</a><br />
+    <a href="book-Z-H-17.html#__idx_2306">rectangular vs. polar form</a><br />
+    <a href="book-Z-H-17.html#__idx_2356">represented as tagged data</a><br /><a href="book-Z-H-18.html#__idx_2630"><tt>complex-&gt;complex</tt></a><br /><a href="book-Z-H-17.html#__idx_2300">complex-number arithmetic</a><br />
+    <a href="book-Z-H-18.html#__idx_2540">interfaced to generic arithmetic system</a><br />
+    <a href="book-Z-H-17.html#__idx_2418">structure of system</a><br /><a href="book-Z-H-12.html#__idx_1226">composition of functions</a><br /><a href="book-Z-H-13.html#__idx_1256">compound data, need for</a><br /><a href="book-Z-H-10.html#__idx_154">compound expression</a>,
 <em>see also</em> combination; special form
 <br />
-    <a href="book-Z-H-10.html#%_idx_476">as operator of combination</a><br /><a href="book-Z-H-10.html#%_idx_296">compound procedure</a>,
+    <a href="book-Z-H-10.html#__idx_476">as operator of combination</a><br /><a href="book-Z-H-10.html#__idx_296">compound procedure</a>,
 <em>see also</em> procedure
 <br />
-    <a href="book-Z-H-10.html#%_idx_332">used like primitive procedure</a><br /><a href="book-Z-H-29.html#%_idx_5122">compound query</a><br />
-    <a href="book-Z-H-29.html#%_idx_5196">processing</a>, <a href="book-Z-H-29.html#%_idx_5316">[2]</a>,
-<a href="book-Z-H-29.html#%_idx_5422">[3]</a>, <a href="book-Z-H-29.html#%_idx_5430">[4]</a>,
-<a href="book-Z-H-29.html#%_idx_5436">[5]</a><br /><a href="book-Z-H-34.html#%_idx_6080"><tt>compound-apply</tt></a><br /><a href="book-Z-H-26.html#%_idx_4446"><tt>compound-procedure?</tt></a><br /><a href="book-Z-H-26.html#%_idx_4554">computability</a>, <a href="book-Z-H-26.html#%_idx_4596">[2]</a><br /><a href="book-Z-H-9.html#%_idx_8">computational process</a>,
+    <a href="book-Z-H-10.html#__idx_332">used like primitive procedure</a><br /><a href="book-Z-H-29.html#__idx_5122">compound query</a><br />
+    <a href="book-Z-H-29.html#__idx_5196">processing</a>, <a href="book-Z-H-29.html#__idx_5316">[2]</a>,
+<a href="book-Z-H-29.html#__idx_5422">[3]</a>, <a href="book-Z-H-29.html#__idx_5430">[4]</a>,
+<a href="book-Z-H-29.html#__idx_5436">[5]</a><br /><a href="book-Z-H-34.html#__idx_6080"><tt>compound-apply</tt></a><br /><a href="book-Z-H-26.html#__idx_4446"><tt>compound-procedure?</tt></a><br /><a href="book-Z-H-26.html#__idx_4554">computability</a>, <a href="book-Z-H-26.html#__idx_4596">[2]</a><br /><a href="book-Z-H-9.html#__idx_8">computational process</a>,
 <em>see also</em> process
-<br /><a href="book-Z-H-25.html#%_idx_4200">computer science</a>,
-<a href="book-Z-H-26.html#%_idx_4558">[2]</a><br />
-    <a href="book-Z-H-10.html#%_idx_498">mathematics vs.</a>,
-<a href="book-Z-H-29.html#%_idx_5036">[2]</a><br /><a href="book-Z-H-14.html#%_idx_1286">concrete data representation</a><br /><a href="book-Z-H-23.html#%_idx_3578">concurrency</a><br />
-    <a href="book-Z-H-23.html#%_idx_3600">correctness of concurrent programs</a><br />
-    <a href="book-Z-H-23.html#%_idx_3694">deadlock</a><br />
-    <a href="book-Z-H-24.html#%_idx_4162">functional programming and</a><br />
-    <a href="book-Z-H-23.html#%_idx_3608">mechanisms for controlling</a><br /><a href="book-Z-H-10.html#%_idx_352"><tt>cond</tt> (special form)</a><br />
-    <a href="book-Z-H-26.html#%_idx_4400">additional clause syntax</a><br />
-    <a href="book-Z-H-10.html#%_idx_364">clause</a><br />
-    <a href="book-Z-H-10.html#%_idx_384">evaluation of</a><br />
-    <a href="book-Z-H-10.html#%_idx_442"><tt>if</tt> vs.</a><br />
-    <a href="book-Z-H-20.html#%_idx_2880">implicit <tt>begin</tt> in consequent</a><br /><a href="book-Z-H-26.html#%_idx_4370"><tt>cond-&gt;if</tt></a><br /><a href="book-Z-H-26.html#%_idx_4368"><tt>cond-actions</tt></a><br /><a href="book-Z-H-26.html#%_idx_4362"><tt>cond-clauses</tt></a><br /><a href="book-Z-H-26.html#%_idx_4364"><tt>cond-else-clause?</tt></a><br /><a href="book-Z-H-26.html#%_idx_4366"><tt>cond-predicate</tt></a><br /><a href="book-Z-H-26.html#%_idx_4360"><tt>cond?</tt></a><br />
+<br /><a href="book-Z-H-25.html#__idx_4200">computer science</a>,
+<a href="book-Z-H-26.html#__idx_4558">[2]</a><br />
+    <a href="book-Z-H-10.html#__idx_498">mathematics vs.</a>,
+<a href="book-Z-H-29.html#__idx_5036">[2]</a><br /><a href="book-Z-H-14.html#__idx_1286">concrete data representation</a><br /><a href="book-Z-H-23.html#__idx_3578">concurrency</a><br />
+    <a href="book-Z-H-23.html#__idx_3600">correctness of concurrent programs</a><br />
+    <a href="book-Z-H-23.html#__idx_3694">deadlock</a><br />
+    <a href="book-Z-H-24.html#__idx_4162">functional programming and</a><br />
+    <a href="book-Z-H-23.html#__idx_3608">mechanisms for controlling</a><br /><a href="book-Z-H-10.html#__idx_352"><tt>cond</tt> (special form)</a><br />
+    <a href="book-Z-H-26.html#__idx_4400">additional clause syntax</a><br />
+    <a href="book-Z-H-10.html#__idx_364">clause</a><br />
+    <a href="book-Z-H-10.html#__idx_384">evaluation of</a><br />
+    <a href="book-Z-H-10.html#__idx_442"><tt>if</tt> vs.</a><br />
+    <a href="book-Z-H-20.html#__idx_2880">implicit <tt>begin</tt> in consequent</a><br /><a href="book-Z-H-26.html#__idx_4370"><tt>cond-&gt;if</tt></a><br /><a href="book-Z-H-26.html#__idx_4368"><tt>cond-actions</tt></a><br /><a href="book-Z-H-26.html#__idx_4362"><tt>cond-clauses</tt></a><br /><a href="book-Z-H-26.html#__idx_4364"><tt>cond-else-clause?</tt></a><br /><a href="book-Z-H-26.html#__idx_4366"><tt>cond-predicate</tt></a><br /><a href="book-Z-H-26.html#__idx_4360"><tt>cond?</tt></a><br />
 conditional expression
 <br />
-    <a href="book-Z-H-10.html#%_idx_356"><tt>cond</tt></a><br />
-    <a href="book-Z-H-10.html#%_idx_424"><tt>if</tt></a><br /><a href="book-Z-H-11.html#%_idx_888">congruent modulo <em>n</em></a><br /><a href="book-Z-H-29.html#%_idx_5320"><tt>conjoin</tt></a><br /><a href="book-Z-H-22.html#%_idx_3530"><tt>connect</tt></a>, <a href="book-Z-H-22.html#%_idx_3558">[2]</a><br /><a href="book-Z-H-22.html#%_idx_3516">connector(s), in constraint system</a><br />
-    <a href="book-Z-H-22.html#%_idx_3520">operations on</a><br />
-    <a href="book-Z-H-22.html#%_idx_3544">representing</a><br /><a href="book-Z-H-28.html#%_idx_4882">Conniver</a><br /><a href="book-Z-H-14.html#%_idx_1320"><tt>cons</tt> (primitive procedure)</a><br />
-    <a href="book-Z-H-14.html#%_idx_1452">axiom for</a><br />
-    <a href="book-Z-H-15.html#%_idx_1534">closure property of</a><br />
-    <a href="book-Z-H-22.html#%_idx_3158">implemented with mutators</a><br />
-    <a href="book-Z-H-33.html#%_idx_5904">implemented with vectors</a><br />
-    <a href="book-Z-H-15.html#%_idx_1592">as list operation</a><br />
-    <a href="book-Z-H-14.html#%_idx_1332">meaning of the name</a><br />
-    <a href="book-Z-H-14.html#%_idx_1460">procedural implementation of</a>,
-<a href="book-Z-H-14.html#%_idx_1468">[2]</a>, <a href="book-Z-H-22.html#%_idx_3160">[3]</a>,
-<a href="book-Z-H-22.html#%_idx_3204">[4]</a>, <a href="book-Z-H-22.html#%_idx_3210">[5]</a>,
-<a href="book-Z-H-27.html#%_idx_4774">[6]</a><br /><a href="book-Z-H-15.html#%_idx_1628"><tt>cons</tt> up a list</a><br /><a href="book-Z-H-24.html#%_idx_3738"><tt>cons-stream</tt> (special form)</a>,
-<a href="book-Z-H-24.html#%_idx_3778">[2]</a><br />
-    <a href="book-Z-H-27.html#%_idx_4770">lazy evaluation and</a><br />
-    <a href="book-Z-H-24.html#%_idx_3784">why a special form</a><br /><a href="book-Z-H-26.html#%_idx_4262">consciousness, expansion of</a><br />
+    <a href="book-Z-H-10.html#__idx_356"><tt>cond</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_424"><tt>if</tt></a><br /><a href="book-Z-H-11.html#__idx_888">congruent modulo <em>n</em></a><br /><a href="book-Z-H-29.html#__idx_5320"><tt>conjoin</tt></a><br /><a href="book-Z-H-22.html#__idx_3530"><tt>connect</tt></a>, <a href="book-Z-H-22.html#__idx_3558">[2]</a><br /><a href="book-Z-H-22.html#__idx_3516">connector(s), in constraint system</a><br />
+    <a href="book-Z-H-22.html#__idx_3520">operations on</a><br />
+    <a href="book-Z-H-22.html#__idx_3544">representing</a><br /><a href="book-Z-H-28.html#__idx_4882">Conniver</a><br /><a href="book-Z-H-14.html#__idx_1320"><tt>cons</tt> (primitive procedure)</a><br />
+    <a href="book-Z-H-14.html#__idx_1452">axiom for</a><br />
+    <a href="book-Z-H-15.html#__idx_1534">closure property of</a><br />
+    <a href="book-Z-H-22.html#__idx_3158">implemented with mutators</a><br />
+    <a href="book-Z-H-33.html#__idx_5904">implemented with vectors</a><br />
+    <a href="book-Z-H-15.html#__idx_1592">as list operation</a><br />
+    <a href="book-Z-H-14.html#__idx_1332">meaning of the name</a><br />
+    <a href="book-Z-H-14.html#__idx_1460">procedural implementation of</a>,
+<a href="book-Z-H-14.html#__idx_1468">[2]</a>, <a href="book-Z-H-22.html#__idx_3160">[3]</a>,
+<a href="book-Z-H-22.html#__idx_3204">[4]</a>, <a href="book-Z-H-22.html#__idx_3210">[5]</a>,
+<a href="book-Z-H-27.html#__idx_4774">[6]</a><br /><a href="book-Z-H-15.html#__idx_1628"><tt>cons</tt> up a list</a><br /><a href="book-Z-H-24.html#__idx_3738"><tt>cons-stream</tt> (special form)</a>,
+<a href="book-Z-H-24.html#__idx_3778">[2]</a><br />
+    <a href="book-Z-H-27.html#__idx_4770">lazy evaluation and</a><br />
+    <a href="book-Z-H-24.html#__idx_3784">why a special form</a><br /><a href="book-Z-H-26.html#__idx_4262">consciousness, expansion of</a><br />
 consequent
 <br />
-    <a href="book-Z-H-10.html#%_idx_388">of <tt>cond</tt> clause</a><br />
-    <a href="book-Z-H-10.html#%_idx_436">of <tt>if</tt></a><br /><a href="book-Z-H-31.html#%_idx_5530"><tt>const</tt> (in register machine)</a><br />
-    <a href="book-Z-H-32.html#%_idx_5772">simulating</a><br />
-    <a href="book-Z-H-31.html#%_idx_5618">syntax of</a><br /><a href="book-Z-H-22.html#%_idx_3540"><tt>constant</tt> (primitive constraint)</a><br /><a href="book-Z-H-31.html#%_idx_5620">constant, specifying in register machine</a><br /><a href="book-Z-H-32.html#%_idx_5780"><tt>constant-exp</tt></a><br /><a href="book-Z-H-32.html#%_idx_5782"><tt>constant-exp-value</tt></a><br /><a href="book-Z-H-22.html#%_idx_3514">constraint network</a><br />
+    <a href="book-Z-H-10.html#__idx_388">of <tt>cond</tt> clause</a><br />
+    <a href="book-Z-H-10.html#__idx_436">of <tt>if</tt></a><br /><a href="book-Z-H-31.html#__idx_5530"><tt>const</tt> (in register machine)</a><br />
+    <a href="book-Z-H-32.html#__idx_5772">simulating</a><br />
+    <a href="book-Z-H-31.html#__idx_5618">syntax of</a><br /><a href="book-Z-H-22.html#__idx_3540"><tt>constant</tt> (primitive constraint)</a><br /><a href="book-Z-H-31.html#__idx_5620">constant, specifying in register machine</a><br /><a href="book-Z-H-32.html#__idx_5780"><tt>constant-exp</tt></a><br /><a href="book-Z-H-32.html#__idx_5782"><tt>constant-exp-value</tt></a><br /><a href="book-Z-H-22.html#__idx_3514">constraint network</a><br />
 constraint(s)
 <br />
-    <a href="book-Z-H-22.html#%_idx_3512">primitive</a><br />
-    <a href="book-Z-H-22.html#%_idx_3484">propagation of</a><br /><a href="book-Z-H-35.html#%_idx_6348"><tt>construct-arglist</tt></a><br /><a href="book-Z-H-14.html#%_idx_1292">constructor</a><br />
-    <a href="book-Z-H-14.html#%_idx_1382">as abstraction barrier</a><br /><a href="book-Z-H-17.html#%_idx_2372"><tt>contents</tt></a><br />
-    <a href="book-Z-H-18.html#%_idx_2562">using Scheme data types</a><br />
+    <a href="book-Z-H-22.html#__idx_3512">primitive</a><br />
+    <a href="book-Z-H-22.html#__idx_3484">propagation of</a><br /><a href="book-Z-H-35.html#__idx_6348"><tt>construct-arglist</tt></a><br /><a href="book-Z-H-14.html#__idx_1292">constructor</a><br />
+    <a href="book-Z-H-14.html#__idx_1382">as abstraction barrier</a><br /><a href="book-Z-H-17.html#__idx_2372"><tt>contents</tt></a><br />
+    <a href="book-Z-H-18.html#__idx_2562">using Scheme data types</a><br />
 continuation
 <br />
-    <a href="book-Z-H-28.html#%_idx_4984">in nondeterministic evaluator</a>,
-<a href="book-Z-H-28.html#%_idx_5000">[2]</a>,
+    <a href="book-Z-H-28.html#__idx_4984">in nondeterministic evaluator</a>,
+<a href="book-Z-H-28.html#__idx_5000">[2]</a>,
 <em>see also</em> failure continuation; success continuation
 <br />
-    <a href="book-Z-H-32.html#%_idx_5700">in register-machine simulator</a><br /><a href="book-Z-H-31.html#%_idx_5554"><tt>continue</tt> register</a><br />
-    <a href="book-Z-H-34.html#%_idx_6024">in explicit-control evaluator</a><br />
-    <a href="book-Z-H-31.html#%_idx_5582">recursion and</a><br /><a href="book-Z-H-12.html#%_idx_1138">continued fraction</a><br />
-    <a href="book-Z-H-12.html#%_idx_1146"><em>e</em> as</a><br />
-    <a href="book-Z-H-12.html#%_idx_1140">golden ratio as</a><br />
-    <a href="book-Z-H-12.html#%_idx_1152">tangent as</a><br /><a href="book-Z-H-29.html#%_idx_5252">control structure</a><br /><a href="book-Z-H-31.html#%_idx_5470">controller for register machine</a><br />
-    <a href="book-Z-H-31.html#%_idx_5488">controller diagram</a><br /><a href="book-Z-H-13.html#%_idx_1268">conventional interface</a><br />
-    <a href="book-Z-H-15.html#%_idx_1720">sequence as</a><br /><a href="book-Z-H-16.html#%_idx_2176">Cormen, Thomas H.</a><br /><a href="book-Z-H-15.html#%_idx_1892"><tt>corner-split</tt></a><br /><a href="book-Z-H-10.html#%_idx_500">correctness of a program</a><br /><a href="book-Z-H-12.html#%_idx_1112"><tt>cos</tt> (primitive procedure)</a><br />
+    <a href="book-Z-H-32.html#__idx_5700">in register-machine simulator</a><br /><a href="book-Z-H-31.html#__idx_5554"><tt>continue</tt> register</a><br />
+    <a href="book-Z-H-34.html#__idx_6024">in explicit-control evaluator</a><br />
+    <a href="book-Z-H-31.html#__idx_5582">recursion and</a><br /><a href="book-Z-H-12.html#__idx_1138">continued fraction</a><br />
+    <a href="book-Z-H-12.html#__idx_1146"><em>e</em> as</a><br />
+    <a href="book-Z-H-12.html#__idx_1140">golden ratio as</a><br />
+    <a href="book-Z-H-12.html#__idx_1152">tangent as</a><br /><a href="book-Z-H-29.html#__idx_5252">control structure</a><br /><a href="book-Z-H-31.html#__idx_5470">controller for register machine</a><br />
+    <a href="book-Z-H-31.html#__idx_5488">controller diagram</a><br /><a href="book-Z-H-13.html#__idx_1268">conventional interface</a><br />
+    <a href="book-Z-H-15.html#__idx_1720">sequence as</a><br /><a href="book-Z-H-16.html#__idx_2176">Cormen, Thomas H.</a><br /><a href="book-Z-H-15.html#__idx_1892"><tt>corner-split</tt></a><br /><a href="book-Z-H-10.html#__idx_500">correctness of a program</a><br /><a href="book-Z-H-12.html#__idx_1112"><tt>cos</tt> (primitive procedure)</a><br />
 cosine
 <br />
-    <a href="book-Z-H-12.html#%_idx_1104">fixed point of</a><br />
-    <a href="book-Z-H-24.html#%_idx_3916">power series for</a><br /><a href="book-Z-H-11.html#%_idx_914">cosmic radiation</a><br /><a href="book-Z-H-11.html#%_idx_730"><tt>count-change</tt></a><br /><a href="book-Z-H-15.html#%_idx_1682"><tt>count-leaves</tt></a>,
-<a href="book-Z-H-15.html#%_idx_1690">[2]</a><br />
-    <a href="book-Z-H-15.html#%_idx_1792">as accumulation</a><br />
-    <a href="book-Z-H-33.html#%_idx_5924">as register machine</a><br /><a href="book-Z-H-22.html#%_idx_3192"><tt>count-pairs</tt></a><br /><a href="book-Z-H-11.html#%_idx_728">counting change</a>, <a href="book-Z-H-15.html#%_idx_1646">[2]</a><br /><a href="book-Z-H-23.html#%_idx_3718">credit-card accounts, international</a><br /><a href="book-Z-H-33.html#%_idx_5982">Cressey, David</a><br /><a href="book-Z-H-18.html#%_idx_2574">cross-type operations</a><br /><a href="book-Z-H-11.html#%_idx_920">cryptography</a><br /><a href="book-Z-H-11.html#%_idx_788"><tt>cube</tt></a>, <a href="book-Z-H-12.html#%_idx_962">[2]</a>,
-<a href="book-Z-H-12.html#%_idx_1194">[3]</a><br />
+    <a href="book-Z-H-12.html#__idx_1104">fixed point of</a><br />
+    <a href="book-Z-H-24.html#__idx_3916">power series for</a><br /><a href="book-Z-H-11.html#__idx_914">cosmic radiation</a><br /><a href="book-Z-H-11.html#__idx_730"><tt>count-change</tt></a><br /><a href="book-Z-H-15.html#__idx_1682"><tt>count-leaves</tt></a>,
+<a href="book-Z-H-15.html#__idx_1690">[2]</a><br />
+    <a href="book-Z-H-15.html#__idx_1792">as accumulation</a><br />
+    <a href="book-Z-H-33.html#__idx_5924">as register machine</a><br /><a href="book-Z-H-22.html#__idx_3192"><tt>count-pairs</tt></a><br /><a href="book-Z-H-11.html#__idx_728">counting change</a>, <a href="book-Z-H-15.html#__idx_1646">[2]</a><br /><a href="book-Z-H-23.html#__idx_3718">credit-card accounts, international</a><br /><a href="book-Z-H-33.html#__idx_5982">Cressey, David</a><br /><a href="book-Z-H-18.html#__idx_2574">cross-type operations</a><br /><a href="book-Z-H-11.html#__idx_920">cryptography</a><br /><a href="book-Z-H-11.html#__idx_788"><tt>cube</tt></a>, <a href="book-Z-H-12.html#__idx_962">[2]</a>,
+<a href="book-Z-H-12.html#__idx_1194">[3]</a><br />
 cube root
 <br />
-    <a href="book-Z-H-12.html#%_idx_1172">as fixed point</a><br />
-    <a href="book-Z-H-10.html#%_idx_560">by Newton's method</a><br /><a href="book-Z-H-12.html#%_idx_1176"><tt>cube-root</tt></a><br /><a href="book-Z-H-22.html#%_idx_3450">current time, for simulation agenda</a><br /><a href="book-Z-H-22.html#%_idx_3422"><tt>current-time</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3458">[2]</a><br /><a href="book-Z-H-22.html#%_idx_3170">cycle in list</a><br />
-    <a href="book-Z-H-22.html#%_idx_3194">detecting</a></p><p>
+    <a href="book-Z-H-12.html#__idx_1172">as fixed point</a><br />
+    <a href="book-Z-H-10.html#__idx_560">by Newton's method</a><br /><a href="book-Z-H-12.html#__idx_1176"><tt>cube-root</tt></a><br /><a href="book-Z-H-22.html#__idx_3450">current time, for simulation agenda</a><br /><a href="book-Z-H-22.html#__idx_3422"><tt>current-time</tt></a>,
+<a href="book-Z-H-22.html#__idx_3458">[2]</a><br /><a href="book-Z-H-22.html#__idx_3170">cycle in list</a><br />
+    <a href="book-Z-H-22.html#__idx_3194">detecting</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-24.html#%_idx_4170">Darlington, John</a><br /><a href="book-Z-H-9.html#%_idx_12">data</a>, <a href="book-Z-H-10.html#%_idx_130">[2]</a><br />
-    <a href="book-Z-H-14.html#%_idx_1284">abstract</a>,
+<br /><a href="book-Z-H-24.html#__idx_4170">Darlington, John</a><br /><a href="book-Z-H-9.html#__idx_12">data</a>, <a href="book-Z-H-10.html#__idx_130">[2]</a><br />
+    <a href="book-Z-H-14.html#__idx_1284">abstract</a>,
 <em>see also</em> data abstraction
 <br />
-    <a href="book-Z-H-14.html#%_idx_1424">abstract models for</a><br />
-    <a href="book-Z-H-14.html#%_idx_1440">algebraic specification for</a><br />
-    <a href="book-Z-H-13.html#%_idx_1258">compound</a><br />
-    <a href="book-Z-H-14.html#%_idx_1288">concrete representation of</a><br />
-    <a href="book-Z-H-15.html#%_idx_1540">hierarchical</a>,
-<a href="book-Z-H-15.html#%_idx_1672">[2]</a><br />
-    <a href="book-Z-H-14.html#%_idx_1344">list-structured</a><br />
-    <a href="book-Z-H-14.html#%_idx_1414">meaning of</a><br />
+    <a href="book-Z-H-14.html#__idx_1424">abstract models for</a><br />
+    <a href="book-Z-H-14.html#__idx_1440">algebraic specification for</a><br />
+    <a href="book-Z-H-13.html#__idx_1258">compound</a><br />
+    <a href="book-Z-H-14.html#__idx_1288">concrete representation of</a><br />
+    <a href="book-Z-H-15.html#__idx_1540">hierarchical</a>,
+<a href="book-Z-H-15.html#__idx_1672">[2]</a><br />
+    <a href="book-Z-H-14.html#__idx_1344">list-structured</a><br />
+    <a href="book-Z-H-14.html#__idx_1414">meaning of</a><br />
     mutable, <em>see</em> mutable data objects
 <br />
-    <a href="book-Z-H-10.html#%_idx_134">numerical</a><br />
-    <a href="book-Z-H-14.html#%_idx_1446">procedural representation of</a><br />
-    <a href="book-Z-H-26.html#%_idx_4542">as program</a><br />
-    <a href="book-Z-H-22.html#%_idx_3176">shared</a><br />
-    <a href="book-Z-H-16.html#%_idx_1984">symbolic</a><br />
-    <a href="book-Z-H-17.html#%_idx_2360">tagged</a>, <a href="book-Z-H-33.html#%_idx_5866">[2]</a><br /><a href="book-Z-H-13.html#%_idx_1262">data abstraction</a>,
-<a href="book-Z-H-14.html#%_idx_1280">[2]</a>, <a href="book-Z-H-17.html#%_idx_2288">[3]</a>,
-<a href="book-Z-H-17.html#%_idx_2310">[4]</a>, <a href="book-Z-H-26.html#%_idx_4280">[5]</a>,
+    <a href="book-Z-H-10.html#__idx_134">numerical</a><br />
+    <a href="book-Z-H-14.html#__idx_1446">procedural representation of</a><br />
+    <a href="book-Z-H-26.html#__idx_4542">as program</a><br />
+    <a href="book-Z-H-22.html#__idx_3176">shared</a><br />
+    <a href="book-Z-H-16.html#__idx_1984">symbolic</a><br />
+    <a href="book-Z-H-17.html#__idx_2360">tagged</a>, <a href="book-Z-H-33.html#__idx_5866">[2]</a><br /><a href="book-Z-H-13.html#__idx_1262">data abstraction</a>,
+<a href="book-Z-H-14.html#__idx_1280">[2]</a>, <a href="book-Z-H-17.html#__idx_2288">[3]</a>,
+<a href="book-Z-H-17.html#__idx_2310">[4]</a>, <a href="book-Z-H-26.html#__idx_4280">[5]</a>,
 <em>see also</em> metacircular evaluator
 <br />
-    <a href="book-Z-H-22.html#%_idx_3228">for queue</a><br />
+    <a href="book-Z-H-22.html#__idx_3228">for queue</a><br />
 data base
 <br />
-    <a href="book-Z-H-17.html#%_idx_2482">data-directed programming and</a><br />
-    <a href="book-Z-H-29.html#%_idx_5190">indexing</a>, <a href="book-Z-H-29.html#%_idx_5374">[2]</a><br />
-    <a href="book-Z-H-17.html#%_idx_2484">Insatiable Enterprises personnel</a><br />
-    <a href="book-Z-H-29.html#%_idx_5098">logic programming and</a><br />
-    <a href="book-Z-H-29.html#%_idx_5106">Microshaft personnel</a><br />
-    <a href="book-Z-H-16.html#%_idx_2202">as set of records</a><br /><a href="book-Z-H-31.html#%_idx_5468">data paths for register machine</a><br />
-    <a href="book-Z-H-31.html#%_idx_5478">data-path diagram</a><br />
+    <a href="book-Z-H-17.html#__idx_2482">data-directed programming and</a><br />
+    <a href="book-Z-H-29.html#__idx_5190">indexing</a>, <a href="book-Z-H-29.html#__idx_5374">[2]</a><br />
+    <a href="book-Z-H-17.html#__idx_2484">Insatiable Enterprises personnel</a><br />
+    <a href="book-Z-H-29.html#__idx_5098">logic programming and</a><br />
+    <a href="book-Z-H-29.html#__idx_5106">Microshaft personnel</a><br />
+    <a href="book-Z-H-16.html#__idx_2202">as set of records</a><br /><a href="book-Z-H-31.html#__idx_5468">data paths for register machine</a><br />
+    <a href="book-Z-H-31.html#__idx_5478">data-path diagram</a><br />
 data types
 <br />
-    <a href="book-Z-H-18.html#%_idx_2552">in Lisp</a><br />
-    <a href="book-Z-H-24.html#%_idx_4098">in strongly typed languages</a><br /><a href="book-Z-H-17.html#%_idx_2298">data-directed programming</a>,
-<a href="book-Z-H-17.html#%_idx_2424">[2]</a><br />
-    <a href="book-Z-H-26.html#%_idx_4244">case analysis vs.</a><br />
-    <a href="book-Z-H-26.html#%_idx_4388">in metacircular evaluator</a><br />
-    <a href="book-Z-H-29.html#%_idx_5308">in query interpreter</a><br /><a href="book-Z-H-18.html#%_idx_2720">data-directed recursion</a><br /><a href="book-Z-H-23.html#%_idx_3696">deadlock</a><br />
-    <a href="book-Z-H-23.html#%_idx_3698">avoidance</a><br />
-    <a href="book-Z-H-23.html#%_idx_3700">recovery</a><br /><a href="book-Z-H-9.html#%_idx_22">debug</a><br /><a href="book-Z-H-10.html#%_idx_542">decimal point in numbers</a><br /><a href="book-Z-H-10.html#%_idx_492">declarative vs. imperative knowledge</a>,
-<a href="book-Z-H-29.html#%_idx_5030">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5070">logic programming and</a>,
-<a href="book-Z-H-29.html#%_idx_5256">[2]</a><br />
-    <a href="book-Z-H-28.html#%_idx_4816">nondeterministic computing and</a><br /><a href="book-Z-H-16.html#%_idx_2272"><tt>decode</tt></a><br /><a href="book-Z-H-10.html#%_idx_568">decomposition of program into parts</a><br /><a href="book-Z-H-26.html#%_idx_4488">deep binding</a><br /><a href="book-Z-H-15.html#%_idx_1692"><tt>deep-reverse</tt></a><br /><a href="book-Z-H-11.html#%_idx_652">deferred operations</a><br /><a href="book-Z-H-10.html#%_idx_224"><tt>define</tt> (special form)</a><br />
-    <a href="book-Z-H-15.html#%_idx_1650">with dotted-tail notation</a><br />
-    <a href="book-Z-H-21.html#%_idx_3078">environment model of</a><br />
-    <a href="book-Z-H-12.html#%_idx_1042"><tt>lambda</tt> vs.</a><br />
-    <a href="book-Z-H-10.html#%_idx_306">for procedures</a>,
-<a href="book-Z-H-12.html#%_idx_1046">[2]</a><br />
-    <a href="book-Z-H-26.html#%_idx_4300">syntactic sugar</a><br />
-    <a href="book-Z-H-10.html#%_idx_228">value of</a><br />
-    <a href="book-Z-H-10.html#%_idx_270">why a special form</a><br /><tt>define</tt> (special form)
+    <a href="book-Z-H-18.html#__idx_2552">in Lisp</a><br />
+    <a href="book-Z-H-24.html#__idx_4098">in strongly typed languages</a><br /><a href="book-Z-H-17.html#__idx_2298">data-directed programming</a>,
+<a href="book-Z-H-17.html#__idx_2424">[2]</a><br />
+    <a href="book-Z-H-26.html#__idx_4244">case analysis vs.</a><br />
+    <a href="book-Z-H-26.html#__idx_4388">in metacircular evaluator</a><br />
+    <a href="book-Z-H-29.html#__idx_5308">in query interpreter</a><br /><a href="book-Z-H-18.html#__idx_2720">data-directed recursion</a><br /><a href="book-Z-H-23.html#__idx_3696">deadlock</a><br />
+    <a href="book-Z-H-23.html#__idx_3698">avoidance</a><br />
+    <a href="book-Z-H-23.html#__idx_3700">recovery</a><br /><a href="book-Z-H-9.html#__idx_22">debug</a><br /><a href="book-Z-H-10.html#__idx_542">decimal point in numbers</a><br /><a href="book-Z-H-10.html#__idx_492">declarative vs. imperative knowledge</a>,
+<a href="book-Z-H-29.html#__idx_5030">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5070">logic programming and</a>,
+<a href="book-Z-H-29.html#__idx_5256">[2]</a><br />
+    <a href="book-Z-H-28.html#__idx_4816">nondeterministic computing and</a><br /><a href="book-Z-H-16.html#__idx_2272"><tt>decode</tt></a><br /><a href="book-Z-H-10.html#__idx_568">decomposition of program into parts</a><br /><a href="book-Z-H-26.html#__idx_4488">deep binding</a><br /><a href="book-Z-H-15.html#__idx_1692"><tt>deep-reverse</tt></a><br /><a href="book-Z-H-11.html#__idx_652">deferred operations</a><br /><a href="book-Z-H-10.html#__idx_224"><tt>define</tt> (special form)</a><br />
+    <a href="book-Z-H-15.html#__idx_1650">with dotted-tail notation</a><br />
+    <a href="book-Z-H-21.html#__idx_3078">environment model of</a><br />
+    <a href="book-Z-H-12.html#__idx_1042"><tt>lambda</tt> vs.</a><br />
+    <a href="book-Z-H-10.html#__idx_306">for procedures</a>,
+<a href="book-Z-H-12.html#__idx_1046">[2]</a><br />
+    <a href="book-Z-H-26.html#__idx_4300">syntactic sugar</a><br />
+    <a href="book-Z-H-10.html#__idx_228">value of</a><br />
+    <a href="book-Z-H-10.html#__idx_270">why a special form</a><br /><tt>define</tt> (special form)
 <br />
     internal, <em>see</em> internal definition
-<br /><a href="book-Z-H-26.html#%_idx_4460"><tt>define-variable!</tt></a>,
-<a href="book-Z-H-26.html#%_idx_4484">[2]</a><br /><a href="book-Z-H-12.html#%_idx_1002">definite integral</a><br />
-    <a href="book-Z-H-20.html#%_idx_2960">estimated with Monte Carlo simulation</a>, <a href="book-Z-H-24.html#%_idx_4142">[2]</a><br />
+<br /><a href="book-Z-H-26.html#__idx_4460"><tt>define-variable!</tt></a>,
+<a href="book-Z-H-26.html#__idx_4484">[2]</a><br /><a href="book-Z-H-12.html#__idx_1002">definite integral</a><br />
+    <a href="book-Z-H-20.html#__idx_2960">estimated with Monte Carlo simulation</a>, <a href="book-Z-H-24.html#__idx_4142">[2]</a><br />
 definition, <em>see</em> <tt>define</tt>; internal definition
-<br /><a href="book-Z-H-26.html#%_idx_4306"><tt>definition-value</tt></a><br /><a href="book-Z-H-26.html#%_idx_4304"><tt>definition-variable</tt></a><br /><a href="book-Z-H-26.html#%_idx_4302"><tt>definition?</tt></a><br /><a href="book-Z-H-28.html#%_idx_4898">deKleer, Johan</a>, <a href="book-Z-H-29.html#%_idx_5264">[2]</a><br /><a href="book-Z-H-24.html#%_idx_3768"><tt>delay</tt> (special form)</a><br />
-    <a href="book-Z-H-24.html#%_idx_4072">explicit</a><br />
-    <a href="book-Z-H-27.html#%_idx_4798">explicit vs. automatic</a><br />
-    <a href="book-Z-H-24.html#%_idx_3796">implementation using <tt>lambda</tt></a><br />
-    <a href="book-Z-H-27.html#%_idx_4768">lazy evaluation and</a><br />
-    <a href="book-Z-H-24.html#%_idx_3800">memoized</a>, <a href="book-Z-H-24.html#%_idx_3900">[2]</a><br />
-    <a href="book-Z-H-24.html#%_idx_3786">why a special form</a><br /><a href="book-Z-H-22.html#%_idx_3342">delay, in digital circuit</a><br /><a href="book-Z-H-27.html#%_idx_4742"><tt>delay-it</tt></a><br /><a href="book-Z-H-24.html#%_idx_4068">delayed argument</a><br /><a href="book-Z-H-19.html#%_idx_2834">delayed evaluation</a>,
-<a href="book-Z-H-24.html#%_idx_3730">[2]</a><br />
-    <a href="book-Z-H-24.html#%_idx_3830">assignment and</a><br />
-    <a href="book-Z-H-27.html#%_idx_4800">explicit vs. automatic</a><br />
-    <a href="book-Z-H-27.html#%_idx_4668">in lazy evaluator</a><br />
-    <a href="book-Z-H-24.html#%_idx_4094">normal-order evaluation and</a><br />
-    <a href="book-Z-H-24.html#%_idx_3826">printing and</a><br />
-    <a href="book-Z-H-24.html#%_idx_4056">streams and</a><br /><a href="book-Z-H-24.html#%_idx_3772">delayed object</a><br /><a href="book-Z-H-22.html#%_idx_3240"><tt>delete-queue!</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3258">[2]</a><br /><a href="book-Z-H-14.html#%_idx_1304"><tt>denom</tt></a>, <a href="book-Z-H-14.html#%_idx_1352">[2]</a><br />
-    <a href="book-Z-H-14.html#%_idx_1420">axiom for</a><br />
-    <a href="book-Z-H-14.html#%_idx_1394">reducing to lowest terms</a><br /><a href="book-Z-H-18.html#%_idx_2726">dense polynomial</a><br /><a href="book-Z-H-28.html#%_idx_4888">dependency-directed backtracking</a><br /><a href="book-Z-H-23.html#%_idx_3632"><tt>deposit</tt> , with external serializer</a><br /><a href="book-Z-H-20.html#%_idx_2898"><tt>deposit</tt> message for bank account</a><br /><a href="book-Z-H-28.html#%_idx_4854">depth-first search</a><br /><a href="book-Z-H-22.html#%_idx_3266">deque</a><br /><a href="book-Z-H-12.html#%_idx_1192"><tt>deriv</tt> (numerical)</a><br /><a href="book-Z-H-16.html#%_idx_2056"><tt>deriv</tt> (symbolic)</a><br />
-    <a href="book-Z-H-17.html#%_idx_2480">data-directed</a><br /><a href="book-Z-H-12.html#%_idx_1186">derivative of a function</a><br /><a href="book-Z-H-26.html#%_idx_4356">derived expressions in evaluator</a><br />
-    <a href="book-Z-H-34.html#%_idx_6116">adding to explicit-control evaluator</a><br /><a href="book-Z-H-15.html#%_idx_1980">design, stratified</a><br /><a href="book-Z-H-24.html#%_idx_4062">differential equation</a>,
+<br /><a href="book-Z-H-26.html#__idx_4306"><tt>definition-value</tt></a><br /><a href="book-Z-H-26.html#__idx_4304"><tt>definition-variable</tt></a><br /><a href="book-Z-H-26.html#__idx_4302"><tt>definition?</tt></a><br /><a href="book-Z-H-28.html#__idx_4898">deKleer, Johan</a>, <a href="book-Z-H-29.html#__idx_5264">[2]</a><br /><a href="book-Z-H-24.html#__idx_3768"><tt>delay</tt> (special form)</a><br />
+    <a href="book-Z-H-24.html#__idx_4072">explicit</a><br />
+    <a href="book-Z-H-27.html#__idx_4798">explicit vs. automatic</a><br />
+    <a href="book-Z-H-24.html#__idx_3796">implementation using <tt>lambda</tt></a><br />
+    <a href="book-Z-H-27.html#__idx_4768">lazy evaluation and</a><br />
+    <a href="book-Z-H-24.html#__idx_3800">memoized</a>, <a href="book-Z-H-24.html#__idx_3900">[2]</a><br />
+    <a href="book-Z-H-24.html#__idx_3786">why a special form</a><br /><a href="book-Z-H-22.html#__idx_3342">delay, in digital circuit</a><br /><a href="book-Z-H-27.html#__idx_4742"><tt>delay-it</tt></a><br /><a href="book-Z-H-24.html#__idx_4068">delayed argument</a><br /><a href="book-Z-H-19.html#__idx_2834">delayed evaluation</a>,
+<a href="book-Z-H-24.html#__idx_3730">[2]</a><br />
+    <a href="book-Z-H-24.html#__idx_3830">assignment and</a><br />
+    <a href="book-Z-H-27.html#__idx_4800">explicit vs. automatic</a><br />
+    <a href="book-Z-H-27.html#__idx_4668">in lazy evaluator</a><br />
+    <a href="book-Z-H-24.html#__idx_4094">normal-order evaluation and</a><br />
+    <a href="book-Z-H-24.html#__idx_3826">printing and</a><br />
+    <a href="book-Z-H-24.html#__idx_4056">streams and</a><br /><a href="book-Z-H-24.html#__idx_3772">delayed object</a><br /><a href="book-Z-H-22.html#__idx_3240"><tt>delete-queue!</tt></a>,
+<a href="book-Z-H-22.html#__idx_3258">[2]</a><br /><a href="book-Z-H-14.html#__idx_1304"><tt>denom</tt></a>, <a href="book-Z-H-14.html#__idx_1352">[2]</a><br />
+    <a href="book-Z-H-14.html#__idx_1420">axiom for</a><br />
+    <a href="book-Z-H-14.html#__idx_1394">reducing to lowest terms</a><br /><a href="book-Z-H-18.html#__idx_2726">dense polynomial</a><br /><a href="book-Z-H-28.html#__idx_4888">dependency-directed backtracking</a><br /><a href="book-Z-H-23.html#__idx_3632"><tt>deposit</tt> , with external serializer</a><br /><a href="book-Z-H-20.html#__idx_2898"><tt>deposit</tt> message for bank account</a><br /><a href="book-Z-H-28.html#__idx_4854">depth-first search</a><br /><a href="book-Z-H-22.html#__idx_3266">deque</a><br /><a href="book-Z-H-12.html#__idx_1192"><tt>deriv</tt> (numerical)</a><br /><a href="book-Z-H-16.html#__idx_2056"><tt>deriv</tt> (symbolic)</a><br />
+    <a href="book-Z-H-17.html#__idx_2480">data-directed</a><br /><a href="book-Z-H-12.html#__idx_1186">derivative of a function</a><br /><a href="book-Z-H-26.html#__idx_4356">derived expressions in evaluator</a><br />
+    <a href="book-Z-H-34.html#__idx_6116">adding to explicit-control evaluator</a><br /><a href="book-Z-H-15.html#__idx_1980">design, stratified</a><br /><a href="book-Z-H-24.html#__idx_4062">differential equation</a>,
 <em>see also</em> <tt>solve</tt>
 <br />
-    <a href="book-Z-H-24.html#%_idx_4082">second-order</a>,
-<a href="book-Z-H-24.html#%_idx_4084">[2]</a><br />
+    <a href="book-Z-H-24.html#__idx_4082">second-order</a>,
+<a href="book-Z-H-24.html#__idx_4084">[2]</a><br />
 differentiation
 <br />
-    <a href="book-Z-H-12.html#%_idx_1190">numerical</a><br />
-    <a href="book-Z-H-16.html#%_idx_2048">rules for</a>, <a href="book-Z-H-16.html#%_idx_2094">[2]</a><br />
-    <a href="book-Z-H-16.html#%_idx_2042">symbolic</a>, <a href="book-Z-H-17.html#%_idx_2478">[2]</a><br /><a href="book-Z-H-23.html#%_idx_3606">diffusion, simulation of</a><br /><a href="book-Z-H-22.html#%_idx_3338">digital signal</a><br /><a href="book-Z-H-22.html#%_idx_3328">digital-circuit simulation</a><br />
-    <a href="book-Z-H-22.html#%_idx_3410">agenda</a><br />
-    <a href="book-Z-H-22.html#%_idx_3436">agenda implementation</a><br />
-    <a href="book-Z-H-22.html#%_idx_3368">primitive function boxes</a><br />
-    <a href="book-Z-H-22.html#%_idx_3392">representing wires</a><br />
-    <a href="book-Z-H-22.html#%_idx_3428">sample simulation</a><br /><a href="book-Z-H-23.html#%_idx_3658">Dijkstra, Edsger Wybe</a><br /><a href="book-Z-H-28.html#%_idx_4932">Dinesman, Howard P.</a><br /><a href="book-Z-H-11.html#%_idx_882">Diophantus's <em>Arithmetic</em>, Fermat's copy of</a><br /><a href="book-Z-H-29.html#%_idx_5324"><tt>disjoin</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_1190">numerical</a><br />
+    <a href="book-Z-H-16.html#__idx_2048">rules for</a>, <a href="book-Z-H-16.html#__idx_2094">[2]</a><br />
+    <a href="book-Z-H-16.html#__idx_2042">symbolic</a>, <a href="book-Z-H-17.html#__idx_2478">[2]</a><br /><a href="book-Z-H-23.html#__idx_3606">diffusion, simulation of</a><br /><a href="book-Z-H-22.html#__idx_3338">digital signal</a><br /><a href="book-Z-H-22.html#__idx_3328">digital-circuit simulation</a><br />
+    <a href="book-Z-H-22.html#__idx_3410">agenda</a><br />
+    <a href="book-Z-H-22.html#__idx_3436">agenda implementation</a><br />
+    <a href="book-Z-H-22.html#__idx_3368">primitive function boxes</a><br />
+    <a href="book-Z-H-22.html#__idx_3392">representing wires</a><br />
+    <a href="book-Z-H-22.html#__idx_3428">sample simulation</a><br /><a href="book-Z-H-23.html#__idx_3658">Dijkstra, Edsger Wybe</a><br /><a href="book-Z-H-28.html#__idx_4932">Dinesman, Howard P.</a><br /><a href="book-Z-H-11.html#__idx_882">Diophantus's <em>Arithmetic</em>, Fermat's copy of</a><br /><a href="book-Z-H-29.html#__idx_5324"><tt>disjoin</tt></a><br />
 dispatching
 <br />
-    <a href="book-Z-H-17.html#%_idx_2494">comparing different styles</a><br />
-    <a href="book-Z-H-17.html#%_idx_2430">on type</a>,
+    <a href="book-Z-H-17.html#__idx_2494">comparing different styles</a><br />
+    <a href="book-Z-H-17.html#__idx_2430">on type</a>,
 <em>see also</em> data-directed programming
-<br /><a href="book-Z-H-11.html#%_idx_940"><tt>display</tt> (primitive procedure)</a>,
-<a href="book-Z-H-14.html#%_idx_1358">[2]</a><br /><a href="book-Z-H-24.html#%_idx_3766"><tt>display-line</tt></a><br /><a href="book-Z-H-24.html#%_idx_3764"><tt>display-stream</tt></a><br /><a href="book-Z-H-28.html#%_idx_4934"><tt>distinct?</tt></a><br /><a href="book-Z-H-18.html#%_idx_2510"><tt>div</tt> (generic)</a><br /><a href="book-Z-H-17.html#%_idx_2318"><tt>div-complex</tt></a><br /><a href="book-Z-H-14.html#%_idx_1500"><tt>div-interval</tt></a><br />
-    <a href="book-Z-H-14.html#%_idx_1512">division by zero</a><br /><a href="book-Z-H-18.html#%_idx_2760"><tt>div-poly</tt></a><br /><a href="book-Z-H-14.html#%_idx_1314"><tt>div-rat</tt></a><br /><a href="book-Z-H-24.html#%_idx_3938"><tt>div-series</tt></a><br /><a href="book-Z-H-18.html#%_idx_2762"><tt>div-terms</tt></a><br /><a href="book-Z-H-11.html#%_idx_864"><tt>divides?</tt></a><br /><a href="book-Z-H-24.html#%_idx_3838"><tt>divisible?</tt></a><br /><a href="book-Z-H-10.html#%_idx_532">division of integers</a><br /><a href="book-Z-H-23.html#%_idx_3690">dog, perfectly rational, behavior of</a><br /><a href="book-Z-H-34.html#%_idx_6190">DOS/Windows</a><br /><a href="book-Z-H-15.html#%_idx_1802"><tt>dot-product</tt></a><br />
+<br /><a href="book-Z-H-11.html#__idx_940"><tt>display</tt> (primitive procedure)</a>,
+<a href="book-Z-H-14.html#__idx_1358">[2]</a><br /><a href="book-Z-H-24.html#__idx_3766"><tt>display-line</tt></a><br /><a href="book-Z-H-24.html#__idx_3764"><tt>display-stream</tt></a><br /><a href="book-Z-H-28.html#__idx_4934"><tt>distinct?</tt></a><br /><a href="book-Z-H-18.html#__idx_2510"><tt>div</tt> (generic)</a><br /><a href="book-Z-H-17.html#__idx_2318"><tt>div-complex</tt></a><br /><a href="book-Z-H-14.html#__idx_1500"><tt>div-interval</tt></a><br />
+    <a href="book-Z-H-14.html#__idx_1512">division by zero</a><br /><a href="book-Z-H-18.html#__idx_2760"><tt>div-poly</tt></a><br /><a href="book-Z-H-14.html#__idx_1314"><tt>div-rat</tt></a><br /><a href="book-Z-H-24.html#__idx_3938"><tt>div-series</tt></a><br /><a href="book-Z-H-18.html#__idx_2762"><tt>div-terms</tt></a><br /><a href="book-Z-H-11.html#__idx_864"><tt>divides?</tt></a><br /><a href="book-Z-H-24.html#__idx_3838"><tt>divisible?</tt></a><br /><a href="book-Z-H-10.html#__idx_532">division of integers</a><br /><a href="book-Z-H-23.html#__idx_3690">dog, perfectly rational, behavior of</a><br /><a href="book-Z-H-34.html#__idx_6190">DOS/Windows</a><br /><a href="book-Z-H-15.html#__idx_1802"><tt>dot-product</tt></a><br />
 dotted-tail notation
 <br />
-    <a href="book-Z-H-15.html#%_idx_1648">for procedure parameters</a>,
-<a href="book-Z-H-17.html#%_idx_2456">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5116">in query pattern</a>,
-<a href="book-Z-H-29.html#%_idx_5350">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5162">in query-language rule</a><br />
-    <a href="book-Z-H-29.html#%_idx_5354"><tt>read</tt> and</a><br /><a href="book-Z-H-28.html#%_idx_4890">Doyle, Jon</a><br /><a href="book-Z-H-15.html#%_idx_1948"><tt>draw-line</tt></a><br />
+    <a href="book-Z-H-15.html#__idx_1648">for procedure parameters</a>,
+<a href="book-Z-H-17.html#__idx_2456">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5116">in query pattern</a>,
+<a href="book-Z-H-29.html#__idx_5350">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5162">in query-language rule</a><br />
+    <a href="book-Z-H-29.html#__idx_5354"><tt>read</tt> and</a><br /><a href="book-Z-H-28.html#__idx_4890">Doyle, Jon</a><br /><a href="book-Z-H-15.html#__idx_1948"><tt>draw-line</tt></a><br />
 driver loop
 <br />
-    <a href="book-Z-H-34.html#%_idx_6136">in explicit-control evaluator</a><br />
-    <a href="book-Z-H-27.html#%_idx_4732">in lazy evaluator</a><br />
-    <a href="book-Z-H-26.html#%_idx_4518">in metacircular evaluator</a><br />
-    <a href="book-Z-H-28.html#%_idx_4908">in nondeterministic evaluator</a>,
-<a href="book-Z-H-28.html#%_idx_5018">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5232">in query interpreter</a>,
-<a href="book-Z-H-29.html#%_idx_5288">[2]</a><br /><tt>driver-loop</tt>
+    <a href="book-Z-H-34.html#__idx_6136">in explicit-control evaluator</a><br />
+    <a href="book-Z-H-27.html#__idx_4732">in lazy evaluator</a><br />
+    <a href="book-Z-H-26.html#__idx_4518">in metacircular evaluator</a><br />
+    <a href="book-Z-H-28.html#__idx_4908">in nondeterministic evaluator</a>,
+<a href="book-Z-H-28.html#__idx_5018">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5232">in query interpreter</a>,
+<a href="book-Z-H-29.html#__idx_5288">[2]</a><br /><tt>driver-loop</tt>
 <br />
-    <a href="book-Z-H-27.html#%_idx_4736">for lazy evaluator</a><br />
-    <a href="book-Z-H-26.html#%_idx_4532">for metacircular evaluator</a><br />
-    <a href="book-Z-H-28.html#%_idx_5024">for nondeterministic evaluator</a></p><p>
+    <a href="book-Z-H-27.html#__idx_4736">for lazy evaluator</a><br />
+    <a href="book-Z-H-26.html#__idx_4532">for metacircular evaluator</a><br />
+    <a href="book-Z-H-28.html#__idx_5024">for nondeterministic evaluator</a></p><p>
 
 </p><p></p><p>
 
 <br /><em>e</em>
 <br />
-    <a href="book-Z-H-12.html#%_idx_1148">as continued fraction</a><br />
-    <a href="book-Z-H-24.html#%_idx_4078">as solution to differential equation</a><br /><a href="book-Z-H-24.html#%_idx_3914"><em>e</em><sup><em>x</em></sup>, power series for</a><br /><a href="book-Z-H-24.html#%_idx_3848">Earth, measuring circumference of</a><br /><a href="book-Z-H-15.html#%_idx_1918"><tt>edge1-frame</tt></a><br /><a href="book-Z-H-15.html#%_idx_1920"><tt>edge2-frame</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_1148">as continued fraction</a><br />
+    <a href="book-Z-H-24.html#__idx_4078">as solution to differential equation</a><br /><a href="book-Z-H-24.html#__idx_3914"><em>e</em><sup><em>x</em></sup>, power series for</a><br /><a href="book-Z-H-24.html#__idx_3848">Earth, measuring circumference of</a><br /><a href="book-Z-H-15.html#__idx_1918"><tt>edge1-frame</tt></a><br /><a href="book-Z-H-15.html#__idx_1920"><tt>edge2-frame</tt></a><br />
 efficiency, <em>see also</em> order of growth,
 <em>see also</em> order of growth
 <br />
-    <a href="book-Z-H-35.html#%_idx_6230">of compilation</a><br />
-    <a href="book-Z-H-29.html#%_idx_5188">of data-base access</a><br />
-    <a href="book-Z-H-26.html#%_idx_4642">of evaluation</a><br />
-    <a href="book-Z-H-9.html#%_idx_100">of Lisp</a><br />
-    <a href="book-Z-H-29.html#%_idx_5202">of query processing</a><br />
-    <a href="book-Z-H-11.html#%_idx_732">of tree-recursive process</a><br /><a href="book-Z-H-23.html#%_idx_3716">EIEIO</a><br /><a href="book-Z-H-15.html#%_idx_1846">eight-queens puzzle</a>,
-<a href="book-Z-H-28.html#%_idx_4946">[2]</a><br /><a href="book-Z-H-24.html#%_idx_4032">electrical circuits, modeled with streams</a>, <a href="book-Z-H-24.html#%_idx_4090">[2]</a><br /><a href="book-Z-H-16.html#%_idx_2104"><tt>element-of-set?</tt></a><br />
-    <a href="book-Z-H-16.html#%_idx_2160">binary-tree representation</a><br />
-    <a href="book-Z-H-16.html#%_idx_2128">ordered-list representation</a><br />
-    <a href="book-Z-H-16.html#%_idx_2116">unordered-list representation</a><br /><a href="book-Z-H-10.html#%_idx_416"><tt>else</tt> (special symbol in <tt>cond</tt>)</a><br /><a href="book-Z-H-27.html#%_idx_4672">embedded language, language design using</a><br /><a href="book-Z-H-15.html#%_idx_1594">empty list</a><br />
-    <a href="book-Z-H-16.html#%_idx_2018">denoted as <tt>'()</tt></a><br />
-    <a href="book-Z-H-15.html#%_idx_1618">recognizing with <tt>null?</tt></a><br /><a href="book-Z-H-24.html#%_idx_3744">empty stream</a><br /><a href="book-Z-H-22.html#%_idx_3414"><tt>empty-agenda?</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3470">[2]</a><br /><a href="book-Z-H-34.html#%_idx_6060"><tt>empty-arglist</tt></a><br /><a href="book-Z-H-35.html#%_idx_6268"><tt>empty-instruction-sequence</tt></a><br /><a href="book-Z-H-22.html#%_idx_3234"><tt>empty-queue?</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3250">[2]</a><br /><a href="book-Z-H-18.html#%_idx_2696"><tt>empty-termlist?</tt></a>,
-<a href="book-Z-H-18.html#%_idx_2742">[2]</a><br /><a href="book-Z-H-20.html#%_idx_2886">encapsulated name</a><br /><a href="book-Z-H-21.html#%_idx_3044">enclosing environment</a><br /><a href="book-Z-H-26.html#%_idx_4466"><tt>enclosing-environment</tt></a><br /><a href="book-Z-H-16.html#%_idx_2278"><tt>encode</tt></a><br /><a href="book-Z-H-15.html#%_idx_1564">end-of-list marker</a><br /><a href="book-Z-H-14.html#%_idx_1402"><tt>end-segment</tt></a>,
-<a href="book-Z-H-15.html#%_idx_1958">[2]</a><br /><a href="book-Z-H-35.html#%_idx_6294"><tt>end-with-linkage</tt></a><br /><a href="book-Z-H-11.html#%_idx_916">engineering vs. mathematics</a><br /><a href="book-Z-H-16.html#%_idx_2152"><tt>entry</tt></a><br /><a href="book-Z-H-15.html#%_idx_1744"><tt>enumerate-interval</tt></a><br /><a href="book-Z-H-15.html#%_idx_1750"><tt>enumerate-tree</tt></a><br /><a href="book-Z-H-15.html#%_idx_1730">enumerator</a><br /><a href="book-Z-H-34.html#%_idx_6020"><tt>env</tt> register</a><br /><a href="book-Z-H-10.html#%_idx_240">environment</a>, <a href="book-Z-H-21.html#%_idx_3038">[2]</a><br />
+    <a href="book-Z-H-35.html#__idx_6230">of compilation</a><br />
+    <a href="book-Z-H-29.html#__idx_5188">of data-base access</a><br />
+    <a href="book-Z-H-26.html#__idx_4642">of evaluation</a><br />
+    <a href="book-Z-H-9.html#__idx_100">of Lisp</a><br />
+    <a href="book-Z-H-29.html#__idx_5202">of query processing</a><br />
+    <a href="book-Z-H-11.html#__idx_732">of tree-recursive process</a><br /><a href="book-Z-H-23.html#__idx_3716">EIEIO</a><br /><a href="book-Z-H-15.html#__idx_1846">eight-queens puzzle</a>,
+<a href="book-Z-H-28.html#__idx_4946">[2]</a><br /><a href="book-Z-H-24.html#__idx_4032">electrical circuits, modeled with streams</a>, <a href="book-Z-H-24.html#__idx_4090">[2]</a><br /><a href="book-Z-H-16.html#__idx_2104"><tt>element-of-set?</tt></a><br />
+    <a href="book-Z-H-16.html#__idx_2160">binary-tree representation</a><br />
+    <a href="book-Z-H-16.html#__idx_2128">ordered-list representation</a><br />
+    <a href="book-Z-H-16.html#__idx_2116">unordered-list representation</a><br /><a href="book-Z-H-10.html#__idx_416"><tt>else</tt> (special symbol in <tt>cond</tt>)</a><br /><a href="book-Z-H-27.html#__idx_4672">embedded language, language design using</a><br /><a href="book-Z-H-15.html#__idx_1594">empty list</a><br />
+    <a href="book-Z-H-16.html#__idx_2018">denoted as <tt>'()</tt></a><br />
+    <a href="book-Z-H-15.html#__idx_1618">recognizing with <tt>null?</tt></a><br /><a href="book-Z-H-24.html#__idx_3744">empty stream</a><br /><a href="book-Z-H-22.html#__idx_3414"><tt>empty-agenda?</tt></a>,
+<a href="book-Z-H-22.html#__idx_3470">[2]</a><br /><a href="book-Z-H-34.html#__idx_6060"><tt>empty-arglist</tt></a><br /><a href="book-Z-H-35.html#__idx_6268"><tt>empty-instruction-sequence</tt></a><br /><a href="book-Z-H-22.html#__idx_3234"><tt>empty-queue?</tt></a>,
+<a href="book-Z-H-22.html#__idx_3250">[2]</a><br /><a href="book-Z-H-18.html#__idx_2696"><tt>empty-termlist?</tt></a>,
+<a href="book-Z-H-18.html#__idx_2742">[2]</a><br /><a href="book-Z-H-20.html#__idx_2886">encapsulated name</a><br /><a href="book-Z-H-21.html#__idx_3044">enclosing environment</a><br /><a href="book-Z-H-26.html#__idx_4466"><tt>enclosing-environment</tt></a><br /><a href="book-Z-H-16.html#__idx_2278"><tt>encode</tt></a><br /><a href="book-Z-H-15.html#__idx_1564">end-of-list marker</a><br /><a href="book-Z-H-14.html#__idx_1402"><tt>end-segment</tt></a>,
+<a href="book-Z-H-15.html#__idx_1958">[2]</a><br /><a href="book-Z-H-35.html#__idx_6294"><tt>end-with-linkage</tt></a><br /><a href="book-Z-H-11.html#__idx_916">engineering vs. mathematics</a><br /><a href="book-Z-H-16.html#__idx_2152"><tt>entry</tt></a><br /><a href="book-Z-H-15.html#__idx_1744"><tt>enumerate-interval</tt></a><br /><a href="book-Z-H-15.html#__idx_1750"><tt>enumerate-tree</tt></a><br /><a href="book-Z-H-15.html#__idx_1730">enumerator</a><br /><a href="book-Z-H-34.html#__idx_6020"><tt>env</tt> register</a><br /><a href="book-Z-H-10.html#__idx_240">environment</a>, <a href="book-Z-H-21.html#__idx_3038">[2]</a><br />
     compile-time, <em>see</em> compile-time environment
 <br />
-    <a href="book-Z-H-10.html#%_idx_268">as context for evaluation</a><br />
-    <a href="book-Z-H-21.html#%_idx_3046">enclosing</a><br />
+    <a href="book-Z-H-10.html#__idx_268">as context for evaluation</a><br />
+    <a href="book-Z-H-21.html#__idx_3046">enclosing</a><br />
     global, <em>see</em> global environment
 <br />
-    <a href="book-Z-H-10.html#%_idx_622">lexical scoping and</a><br />
-    <a href="book-Z-H-29.html#%_idx_5450">in query interpreter</a><br />
-    <a href="book-Z-H-29.html#%_idx_5444">renaming vs.</a><br /><a href="book-Z-H-19.html#%_idx_2832">environment model of evaluation</a>,
-<a href="book-Z-H-21.html#%_idx_3034">[2]</a><br />
-    <a href="book-Z-H-21.html#%_idx_3058">environment structure</a><br />
-    <a href="book-Z-H-21.html#%_idx_3114">internal definitions</a><br />
-    <a href="book-Z-H-21.html#%_idx_3102">local state</a><br />
-    <a href="book-Z-H-21.html#%_idx_3120">message passing</a><br />
-    <a href="book-Z-H-26.html#%_idx_4216">metacircular evaluator and</a><br />
-    <a href="book-Z-H-21.html#%_idx_3082">procedure-application example</a><br />
-    <a href="book-Z-H-21.html#%_idx_3064">rules for evaluation</a><br />
-    <a href="book-Z-H-21.html#%_idx_3094">tail recursion and</a><br /><a href="book-Z-H-16.html#%_idx_2026"><tt>eq?</tt> (primitive procedure)</a><br />
-    <a href="book-Z-H-22.html#%_idx_3188">for arbitrary objects</a><br />
-    <a href="book-Z-H-22.html#%_idx_3186">as equality of pointers</a>,
-<a href="book-Z-H-33.html#%_idx_5868">[2]</a><br />
-    <a href="book-Z-H-33.html#%_idx_5884">implementation for symbols</a><br />
-    <a href="book-Z-H-33.html#%_idx_5874">numerical equality and</a><br /><a href="book-Z-H-18.html#%_idx_2564"><tt>equ?</tt> (generic predicate)</a><br /><a href="book-Z-H-14.html#%_idx_1316"><tt>equal-rat?</tt></a><br /><a href="book-Z-H-16.html#%_idx_2032"><tt>equal?</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_622">lexical scoping and</a><br />
+    <a href="book-Z-H-29.html#__idx_5450">in query interpreter</a><br />
+    <a href="book-Z-H-29.html#__idx_5444">renaming vs.</a><br /><a href="book-Z-H-19.html#__idx_2832">environment model of evaluation</a>,
+<a href="book-Z-H-21.html#__idx_3034">[2]</a><br />
+    <a href="book-Z-H-21.html#__idx_3058">environment structure</a><br />
+    <a href="book-Z-H-21.html#__idx_3114">internal definitions</a><br />
+    <a href="book-Z-H-21.html#__idx_3102">local state</a><br />
+    <a href="book-Z-H-21.html#__idx_3120">message passing</a><br />
+    <a href="book-Z-H-26.html#__idx_4216">metacircular evaluator and</a><br />
+    <a href="book-Z-H-21.html#__idx_3082">procedure-application example</a><br />
+    <a href="book-Z-H-21.html#__idx_3064">rules for evaluation</a><br />
+    <a href="book-Z-H-21.html#__idx_3094">tail recursion and</a><br /><a href="book-Z-H-16.html#__idx_2026"><tt>eq?</tt> (primitive procedure)</a><br />
+    <a href="book-Z-H-22.html#__idx_3188">for arbitrary objects</a><br />
+    <a href="book-Z-H-22.html#__idx_3186">as equality of pointers</a>,
+<a href="book-Z-H-33.html#__idx_5868">[2]</a><br />
+    <a href="book-Z-H-33.html#__idx_5884">implementation for symbols</a><br />
+    <a href="book-Z-H-33.html#__idx_5874">numerical equality and</a><br /><a href="book-Z-H-18.html#__idx_2564"><tt>equ?</tt> (generic predicate)</a><br /><a href="book-Z-H-14.html#__idx_1316"><tt>equal-rat?</tt></a><br /><a href="book-Z-H-16.html#__idx_2032"><tt>equal?</tt></a><br />
 equality
 <br />
-    <a href="book-Z-H-18.html#%_idx_2566">in generic arithmetic system</a><br />
-    <a href="book-Z-H-16.html#%_idx_2034">of lists</a><br />
-    <a href="book-Z-H-10.html#%_idx_408">of numbers</a>, <a href="book-Z-H-16.html#%_idx_2040">[2]</a>,
-<a href="book-Z-H-33.html#%_idx_5876">[3]</a><br />
-    <a href="book-Z-H-20.html#%_idx_2994">referential transparency and</a><br />
-    <a href="book-Z-H-16.html#%_idx_2022">of symbols</a><br />
+    <a href="book-Z-H-18.html#__idx_2566">in generic arithmetic system</a><br />
+    <a href="book-Z-H-16.html#__idx_2034">of lists</a><br />
+    <a href="book-Z-H-10.html#__idx_408">of numbers</a>, <a href="book-Z-H-16.html#__idx_2040">[2]</a>,
+<a href="book-Z-H-33.html#__idx_5876">[3]</a><br />
+    <a href="book-Z-H-20.html#__idx_2994">referential transparency and</a><br />
+    <a href="book-Z-H-16.html#__idx_2022">of symbols</a><br />
 equation, solving, <em>see</em> half-interval method; Newton's method; <tt>solve</tt>
-<br /><a href="book-Z-H-24.html#%_idx_3846">Eratosthenes</a><br /><a href="book-Z-H-12.html#%_idx_1088"><tt>error</tt> (primitive procedure)</a><br />
+<br /><a href="book-Z-H-24.html#__idx_3846">Eratosthenes</a><br /><a href="book-Z-H-12.html#__idx_1088"><tt>error</tt> (primitive procedure)</a><br />
 error handling
 <br />
-    <a href="book-Z-H-35.html#%_idx_6494">in compiled code</a><br />
-    <a href="book-Z-H-34.html#%_idx_6148">in explicit-control evaluator</a>,
-<a href="book-Z-H-34.html#%_idx_6182">[2]</a><br /><a href="book-Z-H-15.html#%_idx_1858">Escher, Maurits Cornelis</a><br /><a href="book-Z-H-20.html#%_idx_2962"><tt>estimate-integral</tt></a><br /><a href="book-Z-H-20.html#%_idx_2948"><tt>estimate-pi</tt></a>,
-<a href="book-Z-H-20.html#%_idx_2954">[2]</a><br /><a href="book-Z-H-11.html#%_idx_836">Euclid's Algorithm</a>,
-<a href="book-Z-H-31.html#%_idx_5476">[2]</a>,
+    <a href="book-Z-H-35.html#__idx_6494">in compiled code</a><br />
+    <a href="book-Z-H-34.html#__idx_6148">in explicit-control evaluator</a>,
+<a href="book-Z-H-34.html#__idx_6182">[2]</a><br /><a href="book-Z-H-15.html#__idx_1858">Escher, Maurits Cornelis</a><br /><a href="book-Z-H-20.html#__idx_2962"><tt>estimate-integral</tt></a><br /><a href="book-Z-H-20.html#__idx_2948"><tt>estimate-pi</tt></a>,
+<a href="book-Z-H-20.html#__idx_2954">[2]</a><br /><a href="book-Z-H-11.html#__idx_836">Euclid's Algorithm</a>,
+<a href="book-Z-H-31.html#__idx_5476">[2]</a>,
 <em>see also</em> greatest common divisor
 <br />
-    <a href="book-Z-H-11.html#%_idx_844">order of growth</a><br />
-    <a href="book-Z-H-18.html#%_idx_2786">for polynomials</a><br /><a href="book-Z-H-11.html#%_idx_838">Euclid's <em>Elements</em></a><br /><a href="book-Z-H-24.html#%_idx_3876">Euclid's proof of infinite number of primes</a><br /><a href="book-Z-H-18.html#%_idx_2790">Euclidean ring</a><br /><a href="book-Z-H-12.html#%_idx_1144">Euler, Leonhard</a><br />
-    <a href="book-Z-H-11.html#%_idx_878">proof of Fermat's Little Theorem</a><br />
-    <a href="book-Z-H-24.html#%_idx_3968">series accelerator</a><br /><a href="book-Z-H-24.html#%_idx_3970"><tt>euler-transform</tt></a><br /><a href="book-Z-H-34.html#%_idx_6056"><tt>ev-application</tt></a><br /><a href="book-Z-H-34.html#%_idx_6110"><tt>ev-assignment</tt></a><br /><a href="book-Z-H-34.html#%_idx_6084"><tt>ev-begin</tt></a><br /><a href="book-Z-H-34.html#%_idx_6114"><tt>ev-definition</tt></a><br /><a href="book-Z-H-34.html#%_idx_6106"><tt>ev-if</tt></a><br /><a href="book-Z-H-34.html#%_idx_6044"><tt>ev-lambda</tt></a><br /><a href="book-Z-H-34.html#%_idx_6042"><tt>ev-quoted</tt></a><br /><a href="book-Z-H-34.html#%_idx_6038"><tt>ev-self-eval</tt></a><br /><tt>ev-sequence</tt>
-<br />
-    <a href="book-Z-H-34.html#%_idx_6086">with tail recursion</a><br />
-    <a href="book-Z-H-34.html#%_idx_6100">without tail recursion</a><br /><a href="book-Z-H-34.html#%_idx_6040"><tt>ev-variable</tt></a><br /><a href="book-Z-H-27.html#%_idx_4720"><tt>eval</tt> (lazy)</a><br /><a href="book-Z-H-26.html#%_idx_4230"><tt>eval</tt> (metacircular)</a>,
-<a href="book-Z-H-26.html#%_idx_4242">[2]</a><br />
-    <a href="book-Z-H-26.html#%_idx_4654">analyzing version</a><br />
-    <a href="book-Z-H-26.html#%_idx_4392">data-directed</a><br />
-    <a href="book-Z-H-26.html#%_idx_4576">primitive <tt>eval</tt> vs.</a><br /><a href="book-Z-H-26.html#%_idx_4572"><tt>eval</tt> (primitive procedure)</a><br />
-    <a href="book-Z-H-26.html#%_idx_4584">MIT Scheme</a><br />
-    <a href="book-Z-H-29.html#%_idx_5334">used in query interpreter</a><br /><a href="book-Z-H-26.html#%_idx_4266"><tt>eval-assignment</tt></a><br /><a href="book-Z-H-26.html#%_idx_4268"><tt>eval-definition</tt></a><br /><a href="book-Z-H-34.html#%_idx_6034"><tt>eval-dispatch</tt></a><br /><a href="book-Z-H-27.html#%_idx_4730"><tt>eval-if</tt> (lazy)</a><br /><a href="book-Z-H-26.html#%_idx_4258"><tt>eval-if</tt> (metacircular)</a><br /><a href="book-Z-H-26.html#%_idx_4264"><tt>eval-sequence</tt></a><br />
+    <a href="book-Z-H-11.html#__idx_844">order of growth</a><br />
+    <a href="book-Z-H-18.html#__idx_2786">for polynomials</a><br /><a href="book-Z-H-11.html#__idx_838">Euclid's <em>Elements</em></a><br /><a href="book-Z-H-24.html#__idx_3876">Euclid's proof of infinite number of primes</a><br /><a href="book-Z-H-18.html#__idx_2790">Euclidean ring</a><br /><a href="book-Z-H-12.html#__idx_1144">Euler, Leonhard</a><br />
+    <a href="book-Z-H-11.html#__idx_878">proof of Fermat's Little Theorem</a><br />
+    <a href="book-Z-H-24.html#__idx_3968">series accelerator</a><br /><a href="book-Z-H-24.html#__idx_3970"><tt>euler-transform</tt></a><br /><a href="book-Z-H-34.html#__idx_6056"><tt>ev-application</tt></a><br /><a href="book-Z-H-34.html#__idx_6110"><tt>ev-assignment</tt></a><br /><a href="book-Z-H-34.html#__idx_6084"><tt>ev-begin</tt></a><br /><a href="book-Z-H-34.html#__idx_6114"><tt>ev-definition</tt></a><br /><a href="book-Z-H-34.html#__idx_6106"><tt>ev-if</tt></a><br /><a href="book-Z-H-34.html#__idx_6044"><tt>ev-lambda</tt></a><br /><a href="book-Z-H-34.html#__idx_6042"><tt>ev-quoted</tt></a><br /><a href="book-Z-H-34.html#__idx_6038"><tt>ev-self-eval</tt></a><br /><tt>ev-sequence</tt>
+<br />
+    <a href="book-Z-H-34.html#__idx_6086">with tail recursion</a><br />
+    <a href="book-Z-H-34.html#__idx_6100">without tail recursion</a><br /><a href="book-Z-H-34.html#__idx_6040"><tt>ev-variable</tt></a><br /><a href="book-Z-H-27.html#__idx_4720"><tt>eval</tt> (lazy)</a><br /><a href="book-Z-H-26.html#__idx_4230"><tt>eval</tt> (metacircular)</a>,
+<a href="book-Z-H-26.html#__idx_4242">[2]</a><br />
+    <a href="book-Z-H-26.html#__idx_4654">analyzing version</a><br />
+    <a href="book-Z-H-26.html#__idx_4392">data-directed</a><br />
+    <a href="book-Z-H-26.html#__idx_4576">primitive <tt>eval</tt> vs.</a><br /><a href="book-Z-H-26.html#__idx_4572"><tt>eval</tt> (primitive procedure)</a><br />
+    <a href="book-Z-H-26.html#__idx_4584">MIT Scheme</a><br />
+    <a href="book-Z-H-29.html#__idx_5334">used in query interpreter</a><br /><a href="book-Z-H-26.html#__idx_4266"><tt>eval-assignment</tt></a><br /><a href="book-Z-H-26.html#__idx_4268"><tt>eval-definition</tt></a><br /><a href="book-Z-H-34.html#__idx_6034"><tt>eval-dispatch</tt></a><br /><a href="book-Z-H-27.html#__idx_4730"><tt>eval-if</tt> (lazy)</a><br /><a href="book-Z-H-26.html#__idx_4258"><tt>eval-if</tt> (metacircular)</a><br /><a href="book-Z-H-26.html#__idx_4264"><tt>eval-sequence</tt></a><br />
 evaluation
 <br />
     applicative-order, <em>see</em> applicative-order evaluation
@@ -657,787 +657,787 @@ <h1 class="chapter">
 <br />
     environment model of, <em>see</em> environment model of evaluation
 <br />
-    <a href="book-Z-H-34.html#%_idx_6132">models of</a><br />
+    <a href="book-Z-H-34.html#__idx_6132">models of</a><br />
     normal-order, <em>see</em> normal-order evaluation
 <br />
-    <a href="book-Z-H-10.html#%_idx_246">of a combination</a><br />
-    <a href="book-Z-H-10.html#%_idx_452">of <tt>and</tt></a><br />
-    <a href="book-Z-H-10.html#%_idx_386">of <tt>cond</tt></a><br />
-    <a href="book-Z-H-10.html#%_idx_430">of <tt>if</tt></a><br />
-    <a href="book-Z-H-10.html#%_idx_460">of <tt>or</tt></a><br />
-    <a href="book-Z-H-10.html#%_idx_266">of primitive expressions</a><br />
-    <a href="book-Z-H-10.html#%_idx_274">of special forms</a><br />
+    <a href="book-Z-H-10.html#__idx_246">of a combination</a><br />
+    <a href="book-Z-H-10.html#__idx_452">of <tt>and</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_386">of <tt>cond</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_430">of <tt>if</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_460">of <tt>or</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_266">of primitive expressions</a><br />
+    <a href="book-Z-H-10.html#__idx_274">of special forms</a><br />
     order of subexpression evaluation, <em>see</em> order of evaluation
 <br />
     substitution model of, <em>see</em> substitution model of procedure application
-<br /><a href="book-Z-H-25.html#%_idx_4198">evaluator</a>, <em>see also</em> interpreter
+<br /><a href="book-Z-H-25.html#__idx_4198">evaluator</a>, <em>see also</em> interpreter
 <br />
-    <a href="book-Z-H-26.html#%_idx_4548">as abstract machine</a><br />
-    <a href="book-Z-H-26.html#%_idx_4214">metacircular</a><br />
-    <a href="book-Z-H-26.html#%_idx_4550">as universal machine</a><br />
+    <a href="book-Z-H-26.html#__idx_4548">as abstract machine</a><br />
+    <a href="book-Z-H-26.html#__idx_4214">metacircular</a><br />
+    <a href="book-Z-H-26.html#__idx_4550">as universal machine</a><br />
 evaluators, <em>see</em> metacircular evaluator; analyzing evaluator; lazy evaluator; nondeterministic evaluator; query interpreter; explicit-control evaluator
-<br /><a href="book-Z-H-15.html#%_idx_1724"><tt>even-fibs</tt></a>, <a href="book-Z-H-15.html#%_idx_1754">[2]</a><br /><a href="book-Z-H-11.html#%_idx_804"><tt>even?</tt></a><br />
+<br /><a href="book-Z-H-15.html#__idx_1724"><tt>even-fibs</tt></a>, <a href="book-Z-H-15.html#__idx_1754">[2]</a><br /><a href="book-Z-H-11.html#__idx_804"><tt>even?</tt></a><br />
 evening star, <em>see</em> Venus
-<br /><a href="book-Z-H-22.html#%_idx_3330">event-driven simulation</a><br /><a href="book-Z-H-34.html#%_idx_6066">evlis tail recursion</a><br /><a href="book-Z-H-10.html#%_idx_528">exact integer</a><br /><a href="book-Z-H-23.html#%_idx_3628"><tt>exchange</tt></a><br /><a href="book-Z-H-20.html#%_idx_2870">exclamation point in names</a><br /><a href="book-Z-H-32.html#%_idx_5670"><tt>execute</tt></a><br /><tt>execute-application</tt>
+<br /><a href="book-Z-H-22.html#__idx_3330">event-driven simulation</a><br /><a href="book-Z-H-34.html#__idx_6066">evlis tail recursion</a><br /><a href="book-Z-H-10.html#__idx_528">exact integer</a><br /><a href="book-Z-H-23.html#__idx_3628"><tt>exchange</tt></a><br /><a href="book-Z-H-20.html#__idx_2870">exclamation point in names</a><br /><a href="book-Z-H-32.html#__idx_5670"><tt>execute</tt></a><br /><tt>execute-application</tt>
 <br />
-    <a href="book-Z-H-26.html#%_idx_4660">metacircular</a><br />
-    <a href="book-Z-H-28.html#%_idx_5012">nondeterministic</a><br />
+    <a href="book-Z-H-26.html#__idx_4660">metacircular</a><br />
+    <a href="book-Z-H-28.html#__idx_5012">nondeterministic</a><br />
 execution procedure
 <br />
-    <a href="book-Z-H-26.html#%_idx_4652">in analyzing evaluator</a><br />
-    <a href="book-Z-H-28.html#%_idx_4982">in nondeterministic evaluator</a>,
-<a href="book-Z-H-28.html#%_idx_4986">[2]</a>, <a href="book-Z-H-28.html#%_idx_5002">[3]</a><br />
-    <a href="book-Z-H-32.html#%_idx_5668">in register-machine simulator</a>,
-<a href="book-Z-H-32.html#%_idx_5716">[2]</a><br /><a href="book-Z-H-34.html#%_idx_6018"><tt>exp</tt> register</a><br /><a href="book-Z-H-26.html#%_idx_4372"><tt>expand-clauses</tt></a><br /><a href="book-Z-H-34.html#%_idx_5996">explicit-control evaluator for Scheme</a><br />
-    <a href="book-Z-H-34.html#%_idx_6108">assignments</a><br />
-    <a href="book-Z-H-34.html#%_idx_6048">combinations</a><br />
-    <a href="book-Z-H-34.html#%_idx_6078">compound procedures</a><br />
-    <a href="book-Z-H-34.html#%_idx_6104">conditionals</a><br />
-    <a href="book-Z-H-34.html#%_idx_6032">controller</a><br />
-    <a href="book-Z-H-34.html#%_idx_6006">data paths</a><br />
-    <a href="book-Z-H-34.html#%_idx_6112">definitions</a><br />
-    <a href="book-Z-H-34.html#%_idx_6118">derived expressions</a><br />
-    <a href="book-Z-H-34.html#%_idx_6134">driver loop</a><br />
-    <a href="book-Z-H-34.html#%_idx_6150">error handling</a>,
-<a href="book-Z-H-34.html#%_idx_6184">[2]</a><br />
-    <a href="book-Z-H-34.html#%_idx_6036">expressions with no subexpressions to evaluate</a><br />
-    <a href="book-Z-H-35.html#%_idx_6208">as machine-language program</a><br />
-    <a href="book-Z-H-34.html#%_idx_6158">machine model</a><br />
-    <a href="book-Z-H-35.html#%_idx_6470">modified for compiled code</a><br />
-    <a href="book-Z-H-34.html#%_idx_6160">monitoring performance (stack use)</a><br />
-    <a href="book-Z-H-34.html#%_idx_6124">normal-order evaluation</a><br />
-    <a href="book-Z-H-34.html#%_idx_6058">operand evaluation</a><br />
-    <a href="book-Z-H-34.html#%_idx_6008">operations</a><br />
-    <a href="book-Z-H-35.html#%_idx_6276">optimizations (additional)</a><br />
-    <a href="book-Z-H-34.html#%_idx_6074">primitive procedures</a><br />
-    <a href="book-Z-H-34.html#%_idx_6046">procedure application</a><br />
-    <a href="book-Z-H-34.html#%_idx_6016">registers</a><br />
-    <a href="book-Z-H-34.html#%_idx_6128">running</a><br />
-    <a href="book-Z-H-34.html#%_idx_6082">sequences of expressions</a><br />
-    <a href="book-Z-H-34.html#%_idx_6120">special forms (additional)</a>,
-<a href="book-Z-H-34.html#%_idx_6122">[2]</a><br />
-    <a href="book-Z-H-34.html#%_idx_6050">stack usage</a><br />
-    <a href="book-Z-H-34.html#%_idx_6088">tail recursion</a>,
-<a href="book-Z-H-34.html#%_idx_6166">[2]</a>, <a href="book-Z-H-34.html#%_idx_6174">[3]</a><br />
-    <a href="book-Z-H-35.html#%_idx_6198">as universal machine</a><br /><a href="book-Z-H-11.html#%_idx_898"><tt>expmod</tt></a>, <a href="book-Z-H-11.html#%_idx_944">[2]</a>,
-<a href="book-Z-H-11.html#%_idx_946">[3]</a><br /><a href="book-Z-H-11.html#%_idx_782">exponential growth</a><br />
-    <a href="book-Z-H-11.html#%_idx_722">of tree-recursive Fibonacci-number computation</a><br /><a href="book-Z-H-11.html#%_idx_790">exponentiation</a><br />
-    <a href="book-Z-H-11.html#%_idx_896">modulo <em>n</em></a><br />
+    <a href="book-Z-H-26.html#__idx_4652">in analyzing evaluator</a><br />
+    <a href="book-Z-H-28.html#__idx_4982">in nondeterministic evaluator</a>,
+<a href="book-Z-H-28.html#__idx_4986">[2]</a>, <a href="book-Z-H-28.html#__idx_5002">[3]</a><br />
+    <a href="book-Z-H-32.html#__idx_5668">in register-machine simulator</a>,
+<a href="book-Z-H-32.html#__idx_5716">[2]</a><br /><a href="book-Z-H-34.html#__idx_6018"><tt>exp</tt> register</a><br /><a href="book-Z-H-26.html#__idx_4372"><tt>expand-clauses</tt></a><br /><a href="book-Z-H-34.html#__idx_5996">explicit-control evaluator for Scheme</a><br />
+    <a href="book-Z-H-34.html#__idx_6108">assignments</a><br />
+    <a href="book-Z-H-34.html#__idx_6048">combinations</a><br />
+    <a href="book-Z-H-34.html#__idx_6078">compound procedures</a><br />
+    <a href="book-Z-H-34.html#__idx_6104">conditionals</a><br />
+    <a href="book-Z-H-34.html#__idx_6032">controller</a><br />
+    <a href="book-Z-H-34.html#__idx_6006">data paths</a><br />
+    <a href="book-Z-H-34.html#__idx_6112">definitions</a><br />
+    <a href="book-Z-H-34.html#__idx_6118">derived expressions</a><br />
+    <a href="book-Z-H-34.html#__idx_6134">driver loop</a><br />
+    <a href="book-Z-H-34.html#__idx_6150">error handling</a>,
+<a href="book-Z-H-34.html#__idx_6184">[2]</a><br />
+    <a href="book-Z-H-34.html#__idx_6036">expressions with no subexpressions to evaluate</a><br />
+    <a href="book-Z-H-35.html#__idx_6208">as machine-language program</a><br />
+    <a href="book-Z-H-34.html#__idx_6158">machine model</a><br />
+    <a href="book-Z-H-35.html#__idx_6470">modified for compiled code</a><br />
+    <a href="book-Z-H-34.html#__idx_6160">monitoring performance (stack use)</a><br />
+    <a href="book-Z-H-34.html#__idx_6124">normal-order evaluation</a><br />
+    <a href="book-Z-H-34.html#__idx_6058">operand evaluation</a><br />
+    <a href="book-Z-H-34.html#__idx_6008">operations</a><br />
+    <a href="book-Z-H-35.html#__idx_6276">optimizations (additional)</a><br />
+    <a href="book-Z-H-34.html#__idx_6074">primitive procedures</a><br />
+    <a href="book-Z-H-34.html#__idx_6046">procedure application</a><br />
+    <a href="book-Z-H-34.html#__idx_6016">registers</a><br />
+    <a href="book-Z-H-34.html#__idx_6128">running</a><br />
+    <a href="book-Z-H-34.html#__idx_6082">sequences of expressions</a><br />
+    <a href="book-Z-H-34.html#__idx_6120">special forms (additional)</a>,
+<a href="book-Z-H-34.html#__idx_6122">[2]</a><br />
+    <a href="book-Z-H-34.html#__idx_6050">stack usage</a><br />
+    <a href="book-Z-H-34.html#__idx_6088">tail recursion</a>,
+<a href="book-Z-H-34.html#__idx_6166">[2]</a>, <a href="book-Z-H-34.html#__idx_6174">[3]</a><br />
+    <a href="book-Z-H-35.html#__idx_6198">as universal machine</a><br /><a href="book-Z-H-11.html#__idx_898"><tt>expmod</tt></a>, <a href="book-Z-H-11.html#__idx_944">[2]</a>,
+<a href="book-Z-H-11.html#__idx_946">[3]</a><br /><a href="book-Z-H-11.html#__idx_782">exponential growth</a><br />
+    <a href="book-Z-H-11.html#__idx_722">of tree-recursive Fibonacci-number computation</a><br /><a href="book-Z-H-11.html#__idx_790">exponentiation</a><br />
+    <a href="book-Z-H-11.html#__idx_896">modulo <em>n</em></a><br />
 expression, <em>see also</em> compound expression; primitive expression
 <br />
     algebraic, <em>see</em> algebraic expressions
 <br />
-    <a href="book-Z-H-26.html#%_idx_4238">self-evaluating</a><br />
-    <a href="book-Z-H-13.html#%_idx_1272">symbolic</a>,
+    <a href="book-Z-H-26.html#__idx_4238">self-evaluating</a><br />
+    <a href="book-Z-H-13.html#__idx_1272">symbolic</a>,
 <em>see also</em> symbol(s)
-<br /><a href="book-Z-H-22.html#%_idx_3574">expression-oriented vs. imperative programming style</a><br /><tt>expt</tt>
+<br /><a href="book-Z-H-22.html#__idx_3574">expression-oriented vs. imperative programming style</a><br /><tt>expt</tt>
 <br />
-    <a href="book-Z-H-11.html#%_idx_794">linear iterative version</a><br />
-    <a href="book-Z-H-11.html#%_idx_792">linear recursive version</a><br />
-    <a href="book-Z-H-31.html#%_idx_5590">register machine for</a><br /><a href="book-Z-H-26.html#%_idx_4458"><tt>extend-environment</tt></a>,
-<a href="book-Z-H-26.html#%_idx_4478">[2]</a><br /><a href="book-Z-H-29.html#%_idx_5348"><tt>extend-if-consistent</tt></a><br /><a href="book-Z-H-29.html#%_idx_5370"><tt>extend-if-possible</tt></a><br /><a href="book-Z-H-35.html#%_idx_6482"><tt>external-entry</tt></a><br /><a href="book-Z-H-32.html#%_idx_5688"><tt>extract-labels</tt></a>,
-<a href="book-Z-H-32.html#%_idx_5692">[2]</a></p><p>
+    <a href="book-Z-H-11.html#__idx_794">linear iterative version</a><br />
+    <a href="book-Z-H-11.html#__idx_792">linear recursive version</a><br />
+    <a href="book-Z-H-31.html#__idx_5590">register machine for</a><br /><a href="book-Z-H-26.html#__idx_4458"><tt>extend-environment</tt></a>,
+<a href="book-Z-H-26.html#__idx_4478">[2]</a><br /><a href="book-Z-H-29.html#__idx_5348"><tt>extend-if-consistent</tt></a><br /><a href="book-Z-H-29.html#__idx_5370"><tt>extend-if-possible</tt></a><br /><a href="book-Z-H-35.html#__idx_6482"><tt>external-entry</tt></a><br /><a href="book-Z-H-32.html#__idx_5688"><tt>extract-labels</tt></a>,
+<a href="book-Z-H-32.html#__idx_5692">[2]</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-10.html#%_idx_380"><tt>#f</tt></a><br /><a href="book-Z-H-11.html#%_idx_640">factorial</a>,
+<br /><a href="book-Z-H-10.html#__idx_380"><tt>#f</tt></a><br /><a href="book-Z-H-11.html#__idx_640">factorial</a>,
 <em>see also</em> <tt>factorial</tt>
 <br />
-    <a href="book-Z-H-24.html#%_idx_3890">infinite stream</a><br />
-    <a href="book-Z-H-26.html#%_idx_4622">with <tt>letrec</tt></a><br />
-    <a href="book-Z-H-26.html#%_idx_4626">without <tt>letrec</tt> or <tt>define</tt></a><br /><tt>factorial</tt>
-<br />
-    <a href="book-Z-H-26.html#%_idx_4546">as an abstract machine</a><br />
-    <a href="book-Z-H-35.html#%_idx_6406">compilation of</a>,
-<a href="book-Z-H-35.html#%_idx_6412">[2]</a><br />
-    <a href="book-Z-H-21.html#%_idx_3088">environment structure in evaluating</a><br />
-    <a href="book-Z-H-11.html#%_idx_646">linear iterative version</a><br />
-    <a href="book-Z-H-11.html#%_idx_642">linear recursive version</a><br />
-    <a href="book-Z-H-31.html#%_idx_5490">register machine for (iterative)</a>,
-<a href="book-Z-H-31.html#%_idx_5532">[2]</a><br />
-    <a href="book-Z-H-31.html#%_idx_5572">register machine for (recursive)</a>,
-<a href="book-Z-H-31.html#%_idx_5586">[2]</a><br />
-    <a href="book-Z-H-35.html#%_idx_6508">stack usage, compiled</a><br />
-    <a href="book-Z-H-34.html#%_idx_6170">stack usage, interpreted</a>,
-<a href="book-Z-H-34.html#%_idx_6172">[2]</a><br />
-    <a href="book-Z-H-32.html#%_idx_5814">stack usage, register machine</a><br />
-    <a href="book-Z-H-20.html#%_idx_3018">with assignment</a><br />
-    <a href="book-Z-H-12.html#%_idx_1012">with higher-order procedures</a><br /><a href="book-Z-H-28.html#%_idx_4990">failure continuation (nondeterministic evaluator)</a>, <a href="book-Z-H-28.html#%_idx_4998">[2]</a><br />
-    <a href="book-Z-H-28.html#%_idx_5014">constructed by <tt>amb</tt></a><br />
-    <a href="book-Z-H-28.html#%_idx_5008">constructed by assignment</a><br />
-    <a href="book-Z-H-28.html#%_idx_5020">constructed by driver loop</a><br /><a href="book-Z-H-28.html#%_idx_4826">failure, in nondeterministic computation</a><br />
-    <a href="book-Z-H-28.html#%_idx_5006">bug vs.</a><br />
-    <a href="book-Z-H-28.html#%_idx_4840">searching and</a><br /><a href="book-Z-H-10.html#%_idx_370">false</a><br /><a href="book-Z-H-10.html#%_idx_382"><tt>false</tt></a><br /><a href="book-Z-H-26.html#%_idx_4436"><tt>false?</tt></a><br /><a href="book-Z-H-11.html#%_idx_798"><tt>fast-expt</tt></a><br /><a href="book-Z-H-11.html#%_idx_906"><tt>fast-prime?</tt></a><br /><a href="book-Z-H-24.html#%_idx_4058">feedback loop, modeled with streams</a><br /><a href="book-Z-H-26.html#%_idx_4648">Feeley, Marc</a><br /><a href="book-Z-H-29.html#%_idx_5086">Feigenbaum, Edward</a><br /><a href="book-Z-H-33.html#%_idx_5942">Fenichel, Robert</a><br /><a href="book-Z-H-11.html#%_idx_872">Fermat, Pierre de</a><br /><a href="book-Z-H-11.html#%_idx_868">Fermat test for primality</a><br />
-    <a href="book-Z-H-11.html#%_idx_952">variant of</a><br /><a href="book-Z-H-11.html#%_idx_886">Fermat's Little Theorem</a><br />
-    <a href="book-Z-H-11.html#%_idx_960">alternate form</a><br />
-    <a href="book-Z-H-11.html#%_idx_876">proof</a><br /><a href="book-Z-H-11.html#%_idx_904"><tt>fermat-test</tt></a><br /><a href="book-Z-H-29.html#%_idx_5378"><tt>fetch-assertions</tt></a><br /><a href="book-Z-H-29.html#%_idx_5380"><tt>fetch-rules</tt></a><br /><tt>fib</tt>
-<br />
-    <a href="book-Z-H-11.html#%_idx_726">linear iterative version</a><br />
-    <a href="book-Z-H-11.html#%_idx_828">logarithmic version</a><br />
-    <a href="book-Z-H-31.html#%_idx_5584">register machine for (tree-recursive)</a>, <a href="book-Z-H-31.html#%_idx_5588">[2]</a><br />
-    <a href="book-Z-H-35.html#%_idx_6512">stack usage, compiled</a><br />
-    <a href="book-Z-H-34.html#%_idx_6178">stack usage, interpreted</a><br />
-    <a href="book-Z-H-11.html#%_idx_720">tree-recursive version</a>,
-<a href="book-Z-H-34.html#%_idx_6180">[2]</a><br />
-    <a href="book-Z-H-22.html#%_idx_3322">with memoization</a><br />
-    <a href="book-Z-H-26.html#%_idx_4422">with named <tt>let</tt></a><br /><a href="book-Z-H-11.html#%_idx_718">Fibonacci numbers</a>,
+    <a href="book-Z-H-24.html#__idx_3890">infinite stream</a><br />
+    <a href="book-Z-H-26.html#__idx_4622">with <tt>letrec</tt></a><br />
+    <a href="book-Z-H-26.html#__idx_4626">without <tt>letrec</tt> or <tt>define</tt></a><br /><tt>factorial</tt>
+<br />
+    <a href="book-Z-H-26.html#__idx_4546">as an abstract machine</a><br />
+    <a href="book-Z-H-35.html#__idx_6406">compilation of</a>,
+<a href="book-Z-H-35.html#__idx_6412">[2]</a><br />
+    <a href="book-Z-H-21.html#__idx_3088">environment structure in evaluating</a><br />
+    <a href="book-Z-H-11.html#__idx_646">linear iterative version</a><br />
+    <a href="book-Z-H-11.html#__idx_642">linear recursive version</a><br />
+    <a href="book-Z-H-31.html#__idx_5490">register machine for (iterative)</a>,
+<a href="book-Z-H-31.html#__idx_5532">[2]</a><br />
+    <a href="book-Z-H-31.html#__idx_5572">register machine for (recursive)</a>,
+<a href="book-Z-H-31.html#__idx_5586">[2]</a><br />
+    <a href="book-Z-H-35.html#__idx_6508">stack usage, compiled</a><br />
+    <a href="book-Z-H-34.html#__idx_6170">stack usage, interpreted</a>,
+<a href="book-Z-H-34.html#__idx_6172">[2]</a><br />
+    <a href="book-Z-H-32.html#__idx_5814">stack usage, register machine</a><br />
+    <a href="book-Z-H-20.html#__idx_3018">with assignment</a><br />
+    <a href="book-Z-H-12.html#__idx_1012">with higher-order procedures</a><br /><a href="book-Z-H-28.html#__idx_4990">failure continuation (nondeterministic evaluator)</a>, <a href="book-Z-H-28.html#__idx_4998">[2]</a><br />
+    <a href="book-Z-H-28.html#__idx_5014">constructed by <tt>amb</tt></a><br />
+    <a href="book-Z-H-28.html#__idx_5008">constructed by assignment</a><br />
+    <a href="book-Z-H-28.html#__idx_5020">constructed by driver loop</a><br /><a href="book-Z-H-28.html#__idx_4826">failure, in nondeterministic computation</a><br />
+    <a href="book-Z-H-28.html#__idx_5006">bug vs.</a><br />
+    <a href="book-Z-H-28.html#__idx_4840">searching and</a><br /><a href="book-Z-H-10.html#__idx_370">false</a><br /><a href="book-Z-H-10.html#__idx_382"><tt>false</tt></a><br /><a href="book-Z-H-26.html#__idx_4436"><tt>false?</tt></a><br /><a href="book-Z-H-11.html#__idx_798"><tt>fast-expt</tt></a><br /><a href="book-Z-H-11.html#__idx_906"><tt>fast-prime?</tt></a><br /><a href="book-Z-H-24.html#__idx_4058">feedback loop, modeled with streams</a><br /><a href="book-Z-H-26.html#__idx_4648">Feeley, Marc</a><br /><a href="book-Z-H-29.html#__idx_5086">Feigenbaum, Edward</a><br /><a href="book-Z-H-33.html#__idx_5942">Fenichel, Robert</a><br /><a href="book-Z-H-11.html#__idx_872">Fermat, Pierre de</a><br /><a href="book-Z-H-11.html#__idx_868">Fermat test for primality</a><br />
+    <a href="book-Z-H-11.html#__idx_952">variant of</a><br /><a href="book-Z-H-11.html#__idx_886">Fermat's Little Theorem</a><br />
+    <a href="book-Z-H-11.html#__idx_960">alternate form</a><br />
+    <a href="book-Z-H-11.html#__idx_876">proof</a><br /><a href="book-Z-H-11.html#__idx_904"><tt>fermat-test</tt></a><br /><a href="book-Z-H-29.html#__idx_5378"><tt>fetch-assertions</tt></a><br /><a href="book-Z-H-29.html#__idx_5380"><tt>fetch-rules</tt></a><br /><tt>fib</tt>
+<br />
+    <a href="book-Z-H-11.html#__idx_726">linear iterative version</a><br />
+    <a href="book-Z-H-11.html#__idx_828">logarithmic version</a><br />
+    <a href="book-Z-H-31.html#__idx_5584">register machine for (tree-recursive)</a>, <a href="book-Z-H-31.html#__idx_5588">[2]</a><br />
+    <a href="book-Z-H-35.html#__idx_6512">stack usage, compiled</a><br />
+    <a href="book-Z-H-34.html#__idx_6178">stack usage, interpreted</a><br />
+    <a href="book-Z-H-11.html#__idx_720">tree-recursive version</a>,
+<a href="book-Z-H-34.html#__idx_6180">[2]</a><br />
+    <a href="book-Z-H-22.html#__idx_3322">with memoization</a><br />
+    <a href="book-Z-H-26.html#__idx_4422">with named <tt>let</tt></a><br /><a href="book-Z-H-11.html#__idx_718">Fibonacci numbers</a>,
 <em>see also</em> <tt>fib</tt>
 <br />
-    <a href="book-Z-H-11.html#%_idx_846">Euclid's GCD algorithm and</a><br />
+    <a href="book-Z-H-11.html#__idx_846">Euclid's GCD algorithm and</a><br />
     infinite stream of, <em>see</em> <tt>fibs</tt>
-<br /><a href="book-Z-H-24.html#%_idx_3840"><tt>fibs</tt> (infinite stream)</a><br />
-    <a href="book-Z-H-24.html#%_idx_3868">implicit definition</a><br /><a href="book-Z-H-22.html#%_idx_3226">FIFO buffer</a><br /><a href="book-Z-H-12.html#%_idx_1026">filter</a>, <a href="book-Z-H-15.html#%_idx_1732">[2]</a><br /><a href="book-Z-H-15.html#%_idx_1740"><tt>filter</tt></a><br /><a href="book-Z-H-12.html#%_idx_1024"><tt>filtered-accumulate</tt></a><br /><a href="book-Z-H-29.html#%_idx_5344"><tt>find-assertions</tt></a><br /><a href="book-Z-H-11.html#%_idx_862"><tt>find-divisor</tt></a><br /><a href="book-Z-H-22.html#%_idx_3416"><tt>first-agenda-item</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3480">[2]</a><br /><a href="book-Z-H-12.html#%_idx_1218">first-class elements in language</a><br /><a href="book-Z-H-26.html#%_idx_4332"><tt>first-exp</tt></a><br /><a href="book-Z-H-26.html#%_idx_4468"><tt>first-frame</tt></a><br /><a href="book-Z-H-26.html#%_idx_4348"><tt>first-operand</tt></a><br /><a href="book-Z-H-22.html#%_idx_3466"><tt>first-segment</tt></a><br /><a href="book-Z-H-18.html#%_idx_2698"><tt>first-term</tt></a>,
-<a href="book-Z-H-18.html#%_idx_2738">[2]</a><br /><a href="book-Z-H-12.html#%_idx_1096">fixed point</a><br />
-    <a href="book-Z-H-12.html#%_idx_1106">computing with calculator</a><br />
-    <a href="book-Z-H-12.html#%_idx_1102">of cosine</a><br />
-    <a href="book-Z-H-12.html#%_idx_1174">cube root as</a><br />
-    <a href="book-Z-H-12.html#%_idx_1240">fourth root as</a><br />
-    <a href="book-Z-H-12.html#%_idx_1132">golden ratio as</a><br />
-    <a href="book-Z-H-12.html#%_idx_1252">as iterative improvement</a><br />
-    <a href="book-Z-H-12.html#%_idx_1180">in Newton's method</a><br />
-    <a href="book-Z-H-12.html#%_idx_1244"><em>n</em>th root as</a><br />
-    <a href="book-Z-H-12.html#%_idx_1120">square root as</a>,
-<a href="book-Z-H-12.html#%_idx_1168">[2]</a>, <a href="book-Z-H-12.html#%_idx_1208">[3]</a><br />
-    <a href="book-Z-H-12.html#%_idx_1204">of transformed function</a><br />
-    <a href="book-Z-H-29.html#%_idx_5366">unification and</a><br /><a href="book-Z-H-16.html#%_idx_2220">fixed-length code</a><br /><a href="book-Z-H-12.html#%_idx_1100"><tt>fixed-point</tt></a><br />
-    <a href="book-Z-H-12.html#%_idx_1250">as iterative improvement</a><br /><a href="book-Z-H-12.html#%_idx_1206"><tt>fixed-point-of-transform</tt></a><br /><a href="book-Z-H-32.html#%_idx_5660"><tt>flag</tt> register</a><br /><a href="book-Z-H-15.html#%_idx_1826"><tt>flatmap</tt></a><br /><a href="book-Z-H-29.html#%_idx_5392"><tt>flatten-stream</tt></a><br /><a href="book-Z-H-15.html#%_idx_1884"><tt>flip-horiz</tt></a>,
-<a href="book-Z-H-15.html#%_idx_1974">[2]</a><br /><a href="book-Z-H-15.html#%_idx_1882"><tt>flip-vert</tt></a>, <a href="book-Z-H-15.html#%_idx_1964">[2]</a><br /><a href="book-Z-H-15.html#%_idx_1888"><tt>flipped-pairs</tt></a>,
-<a href="book-Z-H-15.html#%_idx_1902">[2]</a>, <a href="book-Z-H-15.html#%_idx_1904">[3]</a><br /><a href="book-Z-H-28.html#%_idx_4862">Floyd, Robert</a><br /><a href="book-Z-H-15.html#%_idx_1814"><tt>fold-left</tt></a><br /><a href="book-Z-H-15.html#%_idx_1812"><tt>fold-right</tt></a><br /><a href="book-Z-H-15.html#%_idx_1670"><tt>for-each</tt></a>, <a href="book-Z-H-27.html#%_idx_4750">[2]</a><br /><a href="book-Z-H-22.html#%_idx_3548"><tt>for-each-except</tt></a><br /><a href="book-Z-H-28.html#%_idx_4896">Forbus, Kenneth D.</a><br /><a href="book-Z-H-24.html#%_idx_3774"><tt>force</tt></a>, <a href="book-Z-H-24.html#%_idx_3798">[2]</a><br />
-    <a href="book-Z-H-27.html#%_idx_4708">forcing a thunk vs.</a><br /><a href="book-Z-H-27.html#%_idx_4704">force a thunk</a><br /><a href="book-Z-H-27.html#%_idx_4740"><tt>force-it</tt></a><br />
-    <a href="book-Z-H-27.html#%_idx_4748">memoized version</a><br /><a href="book-Z-H-22.html#%_idx_3528"><tt>forget-value!</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3556">[2]</a><br /><a href="book-Z-H-10.html#%_idx_320">formal parameters</a><br />
-    <a href="book-Z-H-10.html#%_idx_580">names of</a><br />
-    <a href="book-Z-H-10.html#%_idx_598">scope of</a><br /><a href="book-Z-H-10.html#%_idx_200">formatting input expressions</a><br /><a href="book-Z-H-9.html#%_idx_40">Fortran</a>, <a href="book-Z-H-15.html#%_idx_1762">[2]</a><br />
-    <a href="book-Z-H-24.html#%_idx_4168">inventor of</a><br />
-    <a href="book-Z-H-15.html#%_idx_1544">restrictions on compound data</a><br /><a href="book-Z-H-33.html#%_idx_5988">forwarding address</a><br /><a href="book-Z-H-12.html#%_idx_1238">fourth root, as fixed point</a><br />
+<br /><a href="book-Z-H-24.html#__idx_3840"><tt>fibs</tt> (infinite stream)</a><br />
+    <a href="book-Z-H-24.html#__idx_3868">implicit definition</a><br /><a href="book-Z-H-22.html#__idx_3226">FIFO buffer</a><br /><a href="book-Z-H-12.html#__idx_1026">filter</a>, <a href="book-Z-H-15.html#__idx_1732">[2]</a><br /><a href="book-Z-H-15.html#__idx_1740"><tt>filter</tt></a><br /><a href="book-Z-H-12.html#__idx_1024"><tt>filtered-accumulate</tt></a><br /><a href="book-Z-H-29.html#__idx_5344"><tt>find-assertions</tt></a><br /><a href="book-Z-H-11.html#__idx_862"><tt>find-divisor</tt></a><br /><a href="book-Z-H-22.html#__idx_3416"><tt>first-agenda-item</tt></a>,
+<a href="book-Z-H-22.html#__idx_3480">[2]</a><br /><a href="book-Z-H-12.html#__idx_1218">first-class elements in language</a><br /><a href="book-Z-H-26.html#__idx_4332"><tt>first-exp</tt></a><br /><a href="book-Z-H-26.html#__idx_4468"><tt>first-frame</tt></a><br /><a href="book-Z-H-26.html#__idx_4348"><tt>first-operand</tt></a><br /><a href="book-Z-H-22.html#__idx_3466"><tt>first-segment</tt></a><br /><a href="book-Z-H-18.html#__idx_2698"><tt>first-term</tt></a>,
+<a href="book-Z-H-18.html#__idx_2738">[2]</a><br /><a href="book-Z-H-12.html#__idx_1096">fixed point</a><br />
+    <a href="book-Z-H-12.html#__idx_1106">computing with calculator</a><br />
+    <a href="book-Z-H-12.html#__idx_1102">of cosine</a><br />
+    <a href="book-Z-H-12.html#__idx_1174">cube root as</a><br />
+    <a href="book-Z-H-12.html#__idx_1240">fourth root as</a><br />
+    <a href="book-Z-H-12.html#__idx_1132">golden ratio as</a><br />
+    <a href="book-Z-H-12.html#__idx_1252">as iterative improvement</a><br />
+    <a href="book-Z-H-12.html#__idx_1180">in Newton's method</a><br />
+    <a href="book-Z-H-12.html#__idx_1244"><em>n</em>th root as</a><br />
+    <a href="book-Z-H-12.html#__idx_1120">square root as</a>,
+<a href="book-Z-H-12.html#__idx_1168">[2]</a>, <a href="book-Z-H-12.html#__idx_1208">[3]</a><br />
+    <a href="book-Z-H-12.html#__idx_1204">of transformed function</a><br />
+    <a href="book-Z-H-29.html#__idx_5366">unification and</a><br /><a href="book-Z-H-16.html#__idx_2220">fixed-length code</a><br /><a href="book-Z-H-12.html#__idx_1100"><tt>fixed-point</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_1250">as iterative improvement</a><br /><a href="book-Z-H-12.html#__idx_1206"><tt>fixed-point-of-transform</tt></a><br /><a href="book-Z-H-32.html#__idx_5660"><tt>flag</tt> register</a><br /><a href="book-Z-H-15.html#__idx_1826"><tt>flatmap</tt></a><br /><a href="book-Z-H-29.html#__idx_5392"><tt>flatten-stream</tt></a><br /><a href="book-Z-H-15.html#__idx_1884"><tt>flip-horiz</tt></a>,
+<a href="book-Z-H-15.html#__idx_1974">[2]</a><br /><a href="book-Z-H-15.html#__idx_1882"><tt>flip-vert</tt></a>, <a href="book-Z-H-15.html#__idx_1964">[2]</a><br /><a href="book-Z-H-15.html#__idx_1888"><tt>flipped-pairs</tt></a>,
+<a href="book-Z-H-15.html#__idx_1902">[2]</a>, <a href="book-Z-H-15.html#__idx_1904">[3]</a><br /><a href="book-Z-H-28.html#__idx_4862">Floyd, Robert</a><br /><a href="book-Z-H-15.html#__idx_1814"><tt>fold-left</tt></a><br /><a href="book-Z-H-15.html#__idx_1812"><tt>fold-right</tt></a><br /><a href="book-Z-H-15.html#__idx_1670"><tt>for-each</tt></a>, <a href="book-Z-H-27.html#__idx_4750">[2]</a><br /><a href="book-Z-H-22.html#__idx_3548"><tt>for-each-except</tt></a><br /><a href="book-Z-H-28.html#__idx_4896">Forbus, Kenneth D.</a><br /><a href="book-Z-H-24.html#__idx_3774"><tt>force</tt></a>, <a href="book-Z-H-24.html#__idx_3798">[2]</a><br />
+    <a href="book-Z-H-27.html#__idx_4708">forcing a thunk vs.</a><br /><a href="book-Z-H-27.html#__idx_4704">force a thunk</a><br /><a href="book-Z-H-27.html#__idx_4740"><tt>force-it</tt></a><br />
+    <a href="book-Z-H-27.html#__idx_4748">memoized version</a><br /><a href="book-Z-H-22.html#__idx_3528"><tt>forget-value!</tt></a>,
+<a href="book-Z-H-22.html#__idx_3556">[2]</a><br /><a href="book-Z-H-10.html#__idx_320">formal parameters</a><br />
+    <a href="book-Z-H-10.html#__idx_580">names of</a><br />
+    <a href="book-Z-H-10.html#__idx_598">scope of</a><br /><a href="book-Z-H-10.html#__idx_200">formatting input expressions</a><br /><a href="book-Z-H-9.html#__idx_40">Fortran</a>, <a href="book-Z-H-15.html#__idx_1762">[2]</a><br />
+    <a href="book-Z-H-24.html#__idx_4168">inventor of</a><br />
+    <a href="book-Z-H-15.html#__idx_1544">restrictions on compound data</a><br /><a href="book-Z-H-33.html#__idx_5988">forwarding address</a><br /><a href="book-Z-H-12.html#__idx_1238">fourth root, as fixed point</a><br />
 fraction, <em>see</em> rational number(s)
-<br /><a href="book-Z-H-21.html#%_idx_3040">frame (environment model)</a><br />
-    <a href="book-Z-H-21.html#%_idx_3098">as repository of local state</a><br />
-    <a href="book-Z-H-21.html#%_idx_3050">global</a><br /><a href="book-Z-H-15.html#%_idx_1864">frame (picture language)</a>,
-<a href="book-Z-H-15.html#%_idx_1910">[2]</a><br />
-    <a href="book-Z-H-15.html#%_idx_1924">coordinate map</a><br /><a href="book-Z-H-29.html#%_idx_5180">frame (query interpreter)</a>,
+<br /><a href="book-Z-H-21.html#__idx_3040">frame (environment model)</a><br />
+    <a href="book-Z-H-21.html#__idx_3098">as repository of local state</a><br />
+    <a href="book-Z-H-21.html#__idx_3050">global</a><br /><a href="book-Z-H-15.html#__idx_1864">frame (picture language)</a>,
+<a href="book-Z-H-15.html#__idx_1910">[2]</a><br />
+    <a href="book-Z-H-15.html#__idx_1924">coordinate map</a><br /><a href="book-Z-H-29.html#__idx_5180">frame (query interpreter)</a>,
 <em>see also</em> pattern matching; unification
 <br />
-    <a href="book-Z-H-29.html#%_idx_5416">representation</a><br /><a href="book-Z-H-15.html#%_idx_1926"><tt>frame-coord-map</tt></a><br /><a href="book-Z-H-26.html#%_idx_4474"><tt>frame-values</tt></a><br /><a href="book-Z-H-26.html#%_idx_4472"><tt>frame-variables</tt></a><br /><a href="book-Z-H-34.html#%_idx_6052">framed-stack discipline</a><br /><a href="book-Z-H-9.html#%_idx_74">Franz Lisp</a><br /><a href="book-Z-H-33.html#%_idx_5906"><tt>free</tt> register</a>,
-<a href="book-Z-H-33.html#%_idx_5976">[2]</a><br /><a href="book-Z-H-33.html#%_idx_5908">free list</a><br /><a href="book-Z-H-10.html#%_idx_590">free variable</a><br />
-    <a href="book-Z-H-10.html#%_idx_608">capturing</a><br />
-    <a href="book-Z-H-10.html#%_idx_618">in internal definition</a><br /><a href="book-Z-H-24.html#%_idx_3812">Friedman, Daniel P.</a>,
-<a href="book-Z-H-25.html#%_idx_4204">[2]</a><br /><a href="book-Z-H-15.html#%_idx_1696"><tt>fringe</tt></a><br />
-    <a href="book-Z-H-15.html#%_idx_1746">as a tree enumeration</a><br /><a href="book-Z-H-22.html#%_idx_3242"><tt>front-ptr</tt></a><br /><a href="book-Z-H-22.html#%_idx_3236"><tt>front-queue</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3254">[2]</a><br /><a href="book-Z-H-22.html#%_idx_3362">full-adder</a><br />
-    <a href="book-Z-H-22.html#%_idx_3366"><tt>full-adder</tt></a><br />
+    <a href="book-Z-H-29.html#__idx_5416">representation</a><br /><a href="book-Z-H-15.html#__idx_1926"><tt>frame-coord-map</tt></a><br /><a href="book-Z-H-26.html#__idx_4474"><tt>frame-values</tt></a><br /><a href="book-Z-H-26.html#__idx_4472"><tt>frame-variables</tt></a><br /><a href="book-Z-H-34.html#__idx_6052">framed-stack discipline</a><br /><a href="book-Z-H-9.html#__idx_74">Franz Lisp</a><br /><a href="book-Z-H-33.html#__idx_5906"><tt>free</tt> register</a>,
+<a href="book-Z-H-33.html#__idx_5976">[2]</a><br /><a href="book-Z-H-33.html#__idx_5908">free list</a><br /><a href="book-Z-H-10.html#__idx_590">free variable</a><br />
+    <a href="book-Z-H-10.html#__idx_608">capturing</a><br />
+    <a href="book-Z-H-10.html#__idx_618">in internal definition</a><br /><a href="book-Z-H-24.html#__idx_3812">Friedman, Daniel P.</a>,
+<a href="book-Z-H-25.html#__idx_4204">[2]</a><br /><a href="book-Z-H-15.html#__idx_1696"><tt>fringe</tt></a><br />
+    <a href="book-Z-H-15.html#__idx_1746">as a tree enumeration</a><br /><a href="book-Z-H-22.html#__idx_3242"><tt>front-ptr</tt></a><br /><a href="book-Z-H-22.html#__idx_3236"><tt>front-queue</tt></a>,
+<a href="book-Z-H-22.html#__idx_3254">[2]</a><br /><a href="book-Z-H-22.html#__idx_3362">full-adder</a><br />
+    <a href="book-Z-H-22.html#__idx_3366"><tt>full-adder</tt></a><br />
 function (mathematical)
 <br />
-    <a href="book-Z-H-12.html#%_idx_1124"> ⟼   notation for</a><br />
-    <a href="book-Z-H-11.html#%_idx_710">Ackermann's</a><br />
-    <a href="book-Z-H-12.html#%_idx_1228">composition of</a><br />
-    <a href="book-Z-H-12.html#%_idx_1188">derivative of</a><br />
-    <a href="book-Z-H-12.html#%_idx_1098">fixed point of</a><br />
-    <a href="book-Z-H-10.html#%_idx_490">procedure vs.</a><br />
-    <a href="book-Z-H-18.html#%_idx_2778">rational</a><br />
-    <a href="book-Z-H-12.html#%_idx_1230">repeated application of</a><br />
-    <a href="book-Z-H-12.html#%_idx_1232">smoothing of</a><br /><a href="book-Z-H-22.html#%_idx_3340">function box, in digital circuit</a><br /><a href="book-Z-H-20.html#%_idx_2978">functional programming</a>,
-<a href="book-Z-H-24.html#%_idx_4118">[2]</a><br />
-    <a href="book-Z-H-24.html#%_idx_4164">concurrency and</a><br />
-    <a href="book-Z-H-24.html#%_idx_4160">functional programming languages</a><br />
-    <a href="book-Z-H-24.html#%_idx_4146">time and</a></p><p>
+    <a href="book-Z-H-12.html#__idx_1124"> ⟼   notation for</a><br />
+    <a href="book-Z-H-11.html#__idx_710">Ackermann's</a><br />
+    <a href="book-Z-H-12.html#__idx_1228">composition of</a><br />
+    <a href="book-Z-H-12.html#__idx_1188">derivative of</a><br />
+    <a href="book-Z-H-12.html#__idx_1098">fixed point of</a><br />
+    <a href="book-Z-H-10.html#__idx_490">procedure vs.</a><br />
+    <a href="book-Z-H-18.html#__idx_2778">rational</a><br />
+    <a href="book-Z-H-12.html#__idx_1230">repeated application of</a><br />
+    <a href="book-Z-H-12.html#__idx_1232">smoothing of</a><br /><a href="book-Z-H-22.html#__idx_3340">function box, in digital circuit</a><br /><a href="book-Z-H-20.html#__idx_2978">functional programming</a>,
+<a href="book-Z-H-24.html#__idx_4118">[2]</a><br />
+    <a href="book-Z-H-24.html#__idx_4164">concurrency and</a><br />
+    <a href="book-Z-H-24.html#__idx_4160">functional programming languages</a><br />
+    <a href="book-Z-H-24.html#__idx_4146">time and</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-26.html#%_idx_4632">Gabriel, Richard P.</a><br /><a href="book-Z-H-33.html#%_idx_5930">garbage collection</a><br />
-    <a href="book-Z-H-27.html#%_idx_4744">memoization and</a><br />
-    <a href="book-Z-H-22.html#%_idx_3156">mutation and</a><br />
-    <a href="book-Z-H-35.html#%_idx_6360">tail recursion and</a><br />
+<br /><a href="book-Z-H-26.html#__idx_4632">Gabriel, Richard P.</a><br /><a href="book-Z-H-33.html#__idx_5930">garbage collection</a><br />
+    <a href="book-Z-H-27.html#__idx_4744">memoization and</a><br />
+    <a href="book-Z-H-22.html#__idx_3156">mutation and</a><br />
+    <a href="book-Z-H-35.html#__idx_6360">tail recursion and</a><br />
 garbage collector
 <br />
-    <a href="book-Z-H-33.html#%_idx_5964">compacting</a><br />
-    <a href="book-Z-H-33.html#%_idx_5958">mark-sweep</a><br />
-    <a href="book-Z-H-33.html#%_idx_5934">stop-and-copy</a><br />
+    <a href="book-Z-H-33.html#__idx_5964">compacting</a><br />
+    <a href="book-Z-H-33.html#__idx_5958">mark-sweep</a><br />
+    <a href="book-Z-H-33.html#__idx_5934">stop-and-copy</a><br />
 GCD, <em>see</em> greatest common divisor
-<br /><a href="book-Z-H-11.html#%_idx_842"><tt>gcd</tt></a><br />
-    <a href="book-Z-H-31.html#%_idx_5474">register machine for</a>,
-<a href="book-Z-H-32.html#%_idx_5634">[2]</a><br /><a href="book-Z-H-18.html#%_idx_2794"><tt>gcd-terms</tt></a><br /><a href="book-Z-H-35.html#%_idx_6202">general-purpose computer, as universal machine</a><br /><a href="book-Z-H-16.html#%_idx_2280"><tt>generate-huffman-tree</tt></a><br /><a href="book-Z-H-28.html#%_idx_4976">generating sentences</a><br /><a href="book-Z-H-18.html#%_idx_2502">generic arithmetic operations</a><br />
-    <a href="book-Z-H-18.html#%_idx_2500">structure of system</a><br /><a href="book-Z-H-13.html#%_idx_1274">generic operation</a><br /><a href="book-Z-H-16.html#%_idx_2268">generic procedure</a>,
-<a href="book-Z-H-17.html#%_idx_2292">[2]</a><br />
-    <a href="book-Z-H-17.html#%_idx_2404">generic selector</a>,
-<a href="book-Z-H-17.html#%_idx_2422">[2]</a><br /><a href="book-Z-H-29.html#%_idx_5170">Genesis</a><br /><a href="book-Z-H-17.html#%_idx_2440"><tt>get</tt></a>, <a href="book-Z-H-22.html#%_idx_3300">[2]</a><br /><a href="book-Z-H-32.html#%_idx_5644"><tt>get-contents</tt></a><br /><a href="book-Z-H-34.html#%_idx_6140"><tt>get-global-environment</tt></a><br /><a href="book-Z-H-32.html#%_idx_5680"><tt>get-register</tt></a><br /><a href="book-Z-H-32.html#%_idx_5630"><tt>get-register-contents</tt></a>,
-<a href="book-Z-H-32.html#%_idx_5676">[2]</a><br /><a href="book-Z-H-22.html#%_idx_3370"><tt>get-signal</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3404">[2]</a><br /><a href="book-Z-H-22.html#%_idx_3524"><tt>get-value</tt></a>, <a href="book-Z-H-22.html#%_idx_3552">[2]</a><br /><a href="book-Z-H-9.html#%_idx_20">glitch</a><br /><a href="book-Z-H-10.html#%_idx_242">global environment</a>,
-<a href="book-Z-H-21.html#%_idx_3062">[2]</a><br />
-    <a href="book-Z-H-26.html#%_idx_4498">in metacircular evaluator</a><br /><a href="book-Z-H-21.html#%_idx_3048">global frame</a><br /><a href="book-Z-H-14.html#%_idx_1430">Goguen, Joseph</a><br /><a href="book-Z-H-11.html#%_idx_724">golden ratio</a><br />
-    <a href="book-Z-H-12.html#%_idx_1142">as continued fraction</a><br />
-    <a href="book-Z-H-12.html#%_idx_1130">as fixed point</a><br /><a href="book-Z-H-24.html#%_idx_4108">Gordon, Michael</a><br /><a href="book-Z-H-31.html#%_idx_5514"><tt>goto</tt> (in register machine)</a><br />
-    <a href="book-Z-H-31.html#%_idx_5558">label as destination</a><br />
-    <a href="book-Z-H-32.html#%_idx_5746">simulating</a><br /><a href="book-Z-H-32.html#%_idx_5750"><tt>goto-dest</tt></a><br /><a href="book-Z-H-28.html#%_idx_4962">grammar</a><br />
+<br /><a href="book-Z-H-11.html#__idx_842"><tt>gcd</tt></a><br />
+    <a href="book-Z-H-31.html#__idx_5474">register machine for</a>,
+<a href="book-Z-H-32.html#__idx_5634">[2]</a><br /><a href="book-Z-H-18.html#__idx_2794"><tt>gcd-terms</tt></a><br /><a href="book-Z-H-35.html#__idx_6202">general-purpose computer, as universal machine</a><br /><a href="book-Z-H-16.html#__idx_2280"><tt>generate-huffman-tree</tt></a><br /><a href="book-Z-H-28.html#__idx_4976">generating sentences</a><br /><a href="book-Z-H-18.html#__idx_2502">generic arithmetic operations</a><br />
+    <a href="book-Z-H-18.html#__idx_2500">structure of system</a><br /><a href="book-Z-H-13.html#__idx_1274">generic operation</a><br /><a href="book-Z-H-16.html#__idx_2268">generic procedure</a>,
+<a href="book-Z-H-17.html#__idx_2292">[2]</a><br />
+    <a href="book-Z-H-17.html#__idx_2404">generic selector</a>,
+<a href="book-Z-H-17.html#__idx_2422">[2]</a><br /><a href="book-Z-H-29.html#__idx_5170">Genesis</a><br /><a href="book-Z-H-17.html#__idx_2440"><tt>get</tt></a>, <a href="book-Z-H-22.html#__idx_3300">[2]</a><br /><a href="book-Z-H-32.html#__idx_5644"><tt>get-contents</tt></a><br /><a href="book-Z-H-34.html#__idx_6140"><tt>get-global-environment</tt></a><br /><a href="book-Z-H-32.html#__idx_5680"><tt>get-register</tt></a><br /><a href="book-Z-H-32.html#__idx_5630"><tt>get-register-contents</tt></a>,
+<a href="book-Z-H-32.html#__idx_5676">[2]</a><br /><a href="book-Z-H-22.html#__idx_3370"><tt>get-signal</tt></a>,
+<a href="book-Z-H-22.html#__idx_3404">[2]</a><br /><a href="book-Z-H-22.html#__idx_3524"><tt>get-value</tt></a>, <a href="book-Z-H-22.html#__idx_3552">[2]</a><br /><a href="book-Z-H-9.html#__idx_20">glitch</a><br /><a href="book-Z-H-10.html#__idx_242">global environment</a>,
+<a href="book-Z-H-21.html#__idx_3062">[2]</a><br />
+    <a href="book-Z-H-26.html#__idx_4498">in metacircular evaluator</a><br /><a href="book-Z-H-21.html#__idx_3048">global frame</a><br /><a href="book-Z-H-14.html#__idx_1430">Goguen, Joseph</a><br /><a href="book-Z-H-11.html#__idx_724">golden ratio</a><br />
+    <a href="book-Z-H-12.html#__idx_1142">as continued fraction</a><br />
+    <a href="book-Z-H-12.html#__idx_1130">as fixed point</a><br /><a href="book-Z-H-24.html#__idx_4108">Gordon, Michael</a><br /><a href="book-Z-H-31.html#__idx_5514"><tt>goto</tt> (in register machine)</a><br />
+    <a href="book-Z-H-31.html#__idx_5558">label as destination</a><br />
+    <a href="book-Z-H-32.html#__idx_5746">simulating</a><br /><a href="book-Z-H-32.html#__idx_5750"><tt>goto-dest</tt></a><br /><a href="book-Z-H-28.html#__idx_4962">grammar</a><br />
 graphics, <em>see</em> picture language
-<br /><a href="book-Z-H-23.html#%_idx_3704">Gray, Jim</a><br /><a href="book-Z-H-11.html#%_idx_834">greatest common divisor</a>,
+<br /><a href="book-Z-H-23.html#__idx_3704">Gray, Jim</a><br /><a href="book-Z-H-11.html#__idx_834">greatest common divisor</a>,
 <em>see also</em> <tt>gcd</tt>
 <br />
-    <a href="book-Z-H-18.html#%_idx_2798">generic</a><br />
-    <a href="book-Z-H-18.html#%_idx_2782">of polynomials</a><br />
-    <a href="book-Z-H-20.html#%_idx_2946">used to estimate π </a><br />
-    <a href="book-Z-H-14.html#%_idx_1376">used in rational-number arithmetic</a><br /><a href="book-Z-H-29.html#%_idx_5050">Green, Cordell</a><br /><a href="book-Z-H-9.html#%_idx_72">Griss, Martin Lewis</a><br /><a href="book-Z-H-14.html#%_idx_1438">Guttag, John Vogel</a></p><p>
+    <a href="book-Z-H-18.html#__idx_2798">generic</a><br />
+    <a href="book-Z-H-18.html#__idx_2782">of polynomials</a><br />
+    <a href="book-Z-H-20.html#__idx_2946">used to estimate π </a><br />
+    <a href="book-Z-H-14.html#__idx_1376">used in rational-number arithmetic</a><br /><a href="book-Z-H-29.html#__idx_5050">Green, Cordell</a><br /><a href="book-Z-H-9.html#__idx_72">Griss, Martin Lewis</a><br /><a href="book-Z-H-14.html#__idx_1438">Guttag, John Vogel</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-22.html#%_idx_3354">half-adder</a><br />
-    <a href="book-Z-H-22.html#%_idx_3360"><tt>half-adder</tt></a><br />
-    <a href="book-Z-H-22.html#%_idx_3430">simulation of</a><br /><a href="book-Z-H-12.html#%_idx_1082">half-interval method</a><br />
-    <a href="book-Z-H-12.html#%_idx_1092"><tt>half-interval-method</tt></a><br />
-    <a href="book-Z-H-12.html#%_idx_1184">Newton's method vs.</a><br /><a href="book-Z-H-26.html#%_idx_4588">halting problem</a><br /><a href="book-Z-H-26.html#%_idx_4592">Halting Theorem</a><br /><a href="book-Z-H-16.html#%_idx_2248">Hamming, Richard Wesley</a>,
-<a href="book-Z-H-24.html#%_idx_3894">[2]</a><br /><a href="book-Z-H-26.html#%_idx_4382">Hanson, Christopher P.</a>,
-<a href="book-Z-H-35.html#%_idx_6364">[2]</a><br /><a href="book-Z-H-24.html#%_idx_3882">Hardy, Godfrey Harold</a>,
-<a href="book-Z-H-24.html#%_idx_4012">[2]</a><br /><a href="book-Z-H-22.html#%_idx_3522"><tt>has-value?</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3550">[2]</a><br /><a href="book-Z-H-27.html#%_idx_4690">Hassle</a><br /><a href="book-Z-H-23.html#%_idx_3702">Havender, J.</a><br /><a href="book-Z-H-25.html#%_idx_4208">Haynes, Christopher T.</a><br /><a href="book-Z-H-22.html#%_idx_3276">headed list</a>, <a href="book-Z-H-22.html#%_idx_3452">[2]</a><br /><a href="book-Z-H-9.html#%_idx_70">Hearn, Anthony C.</a><br /><a href="book-Z-H-15.html#%_idx_1856">Henderson, Peter</a>,
-<a href="book-Z-H-24.html#%_idx_3858">[2]</a>, <a href="book-Z-H-24.html#%_idx_4172">[3]</a><br />
-    <a href="book-Z-H-24.html#%_idx_3856">Henderson diagram</a><br /><a href="book-Z-H-19.html#%_idx_2820">Heraclitus</a><br /><a href="book-Z-H-10.html#%_idx_512">Heron of Alexandria</a><br /><a href="book-Z-H-11.html#%_idx_698">Hewitt, Carl Eddie</a>,
-<a href="book-Z-H-28.html#%_idx_4864">[2]</a>, <a href="book-Z-H-29.html#%_idx_5052">[3]</a>,
-<a href="book-Z-H-33.html#%_idx_5950">[4]</a><br /><a href="book-Z-H-20.html#%_idx_2890">hiding principle</a><br /><a href="book-Z-H-15.html#%_idx_1538">hierarchical data structures</a>,
-<a href="book-Z-H-15.html#%_idx_1674">[2]</a><br /><a href="book-Z-H-18.html#%_idx_2594">hierarchy of types</a><br />
-    <a href="book-Z-H-18.html#%_idx_2764">in symbolic algebra</a><br />
-    <a href="book-Z-H-18.html#%_idx_2614">inadequacy of</a><br /><a href="book-Z-H-25.html#%_idx_4190">high-level language, machine language vs.</a><br /><a href="book-Z-H-12.html#%_idx_964">higher-order procedures</a><br />
-    <a href="book-Z-H-26.html#%_idx_4254">in metacircular evaluator</a><br />
-    <a href="book-Z-H-12.html#%_idx_966">procedure as argument</a><br />
-    <a href="book-Z-H-12.html#%_idx_1078">procedure as general method</a><br />
-    <a href="book-Z-H-12.html#%_idx_1156">procedure as returned value</a><br />
-    <a href="book-Z-H-24.html#%_idx_4096">strong typing and</a><br /><a href="book-Z-H-16.html#%_idx_2198">Hilfinger, Paul</a><br /><a href="book-Z-H-14.html#%_idx_1422">Hoare, Charles Antony Richard</a><br /><a href="book-Z-H-26.html#%_idx_4566">Hodges, Andrew</a><br /><a href="book-Z-H-26.html#%_idx_4570">Hofstadter, Douglas R.</a><br /><a href="book-Z-H-15.html#%_idx_1778">Horner, W. G.</a><br /><a href="book-Z-H-15.html#%_idx_1774">Horner's rule</a><br />
+<br /><a href="book-Z-H-22.html#__idx_3354">half-adder</a><br />
+    <a href="book-Z-H-22.html#__idx_3360"><tt>half-adder</tt></a><br />
+    <a href="book-Z-H-22.html#__idx_3430">simulation of</a><br /><a href="book-Z-H-12.html#__idx_1082">half-interval method</a><br />
+    <a href="book-Z-H-12.html#__idx_1092"><tt>half-interval-method</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_1184">Newton's method vs.</a><br /><a href="book-Z-H-26.html#__idx_4588">halting problem</a><br /><a href="book-Z-H-26.html#__idx_4592">Halting Theorem</a><br /><a href="book-Z-H-16.html#__idx_2248">Hamming, Richard Wesley</a>,
+<a href="book-Z-H-24.html#__idx_3894">[2]</a><br /><a href="book-Z-H-26.html#__idx_4382">Hanson, Christopher P.</a>,
+<a href="book-Z-H-35.html#__idx_6364">[2]</a><br /><a href="book-Z-H-24.html#__idx_3882">Hardy, Godfrey Harold</a>,
+<a href="book-Z-H-24.html#__idx_4012">[2]</a><br /><a href="book-Z-H-22.html#__idx_3522"><tt>has-value?</tt></a>,
+<a href="book-Z-H-22.html#__idx_3550">[2]</a><br /><a href="book-Z-H-27.html#__idx_4690">Hassle</a><br /><a href="book-Z-H-23.html#__idx_3702">Havender, J.</a><br /><a href="book-Z-H-25.html#__idx_4208">Haynes, Christopher T.</a><br /><a href="book-Z-H-22.html#__idx_3276">headed list</a>, <a href="book-Z-H-22.html#__idx_3452">[2]</a><br /><a href="book-Z-H-9.html#__idx_70">Hearn, Anthony C.</a><br /><a href="book-Z-H-15.html#__idx_1856">Henderson, Peter</a>,
+<a href="book-Z-H-24.html#__idx_3858">[2]</a>, <a href="book-Z-H-24.html#__idx_4172">[3]</a><br />
+    <a href="book-Z-H-24.html#__idx_3856">Henderson diagram</a><br /><a href="book-Z-H-19.html#__idx_2820">Heraclitus</a><br /><a href="book-Z-H-10.html#__idx_512">Heron of Alexandria</a><br /><a href="book-Z-H-11.html#__idx_698">Hewitt, Carl Eddie</a>,
+<a href="book-Z-H-28.html#__idx_4864">[2]</a>, <a href="book-Z-H-29.html#__idx_5052">[3]</a>,
+<a href="book-Z-H-33.html#__idx_5950">[4]</a><br /><a href="book-Z-H-20.html#__idx_2890">hiding principle</a><br /><a href="book-Z-H-15.html#__idx_1538">hierarchical data structures</a>,
+<a href="book-Z-H-15.html#__idx_1674">[2]</a><br /><a href="book-Z-H-18.html#__idx_2594">hierarchy of types</a><br />
+    <a href="book-Z-H-18.html#__idx_2764">in symbolic algebra</a><br />
+    <a href="book-Z-H-18.html#__idx_2614">inadequacy of</a><br /><a href="book-Z-H-25.html#__idx_4190">high-level language, machine language vs.</a><br /><a href="book-Z-H-12.html#__idx_964">higher-order procedures</a><br />
+    <a href="book-Z-H-26.html#__idx_4254">in metacircular evaluator</a><br />
+    <a href="book-Z-H-12.html#__idx_966">procedure as argument</a><br />
+    <a href="book-Z-H-12.html#__idx_1078">procedure as general method</a><br />
+    <a href="book-Z-H-12.html#__idx_1156">procedure as returned value</a><br />
+    <a href="book-Z-H-24.html#__idx_4096">strong typing and</a><br /><a href="book-Z-H-16.html#__idx_2198">Hilfinger, Paul</a><br /><a href="book-Z-H-14.html#__idx_1422">Hoare, Charles Antony Richard</a><br /><a href="book-Z-H-26.html#__idx_4566">Hodges, Andrew</a><br /><a href="book-Z-H-26.html#__idx_4570">Hofstadter, Douglas R.</a><br /><a href="book-Z-H-15.html#__idx_1778">Horner, W. G.</a><br /><a href="book-Z-H-15.html#__idx_1774">Horner's rule</a><br />
 “how to” vs. “what is” description, <em>see</em> imperative vs. declarative knowledge
-<br /><a href="book-Z-H-16.html#%_idx_2212">Huffman code</a><br />
-    <a href="book-Z-H-16.html#%_idx_2246">optimality of</a><br />
-    <a href="book-Z-H-16.html#%_idx_2284">order of growth of encoding</a><br /><a href="book-Z-H-16.html#%_idx_2238">Huffman, David</a><br /><a href="book-Z-H-27.html#%_idx_4792">Hughes, R. J. M.</a></p><p>
+<br /><a href="book-Z-H-16.html#__idx_2212">Huffman code</a><br />
+    <a href="book-Z-H-16.html#__idx_2246">optimality of</a><br />
+    <a href="book-Z-H-16.html#__idx_2284">order of growth of encoding</a><br /><a href="book-Z-H-16.html#__idx_2238">Huffman, David</a><br /><a href="book-Z-H-27.html#__idx_4792">Hughes, R. J. M.</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-14.html#%_idx_1338">IBM 704</a><br /><a href="book-Z-H-12.html#%_idx_996"><tt>identity</tt></a><br /><a href="book-Z-H-10.html#%_idx_420"><tt>if</tt> (special form)</a><br />
-    <a href="book-Z-H-10.html#%_idx_440"><tt>cond</tt> vs.</a><br />
-    <a href="book-Z-H-10.html#%_idx_428">evaluation of</a><br />
-    <a href="book-Z-H-10.html#%_idx_486">normal-order evaluation of</a><br />
-    <a href="book-Z-H-22.html#%_idx_3474">one-armed (without alternative)</a><br />
-    <a href="book-Z-H-10.html#%_idx_432">predicate, consequent, and alternative of</a><br />
-    <a href="book-Z-H-10.html#%_idx_556">why a special form</a><br /><a href="book-Z-H-26.html#%_idx_4322"><tt>if-alternative</tt></a><br /><a href="book-Z-H-26.html#%_idx_4320"><tt>if-consequent</tt></a><br /><a href="book-Z-H-26.html#%_idx_4318"><tt>if-predicate</tt></a><br /><a href="book-Z-H-26.html#%_idx_4316"><tt>if?</tt></a><br /><tt>imag-part</tt>
-<br />
-    <a href="book-Z-H-17.html#%_idx_2466">data-directed</a><br />
-    <a href="book-Z-H-17.html#%_idx_2346">polar representation</a><br />
-    <a href="book-Z-H-17.html#%_idx_2330">rectangular representation</a><br />
-    <a href="book-Z-H-17.html#%_idx_2408">with tagged data</a><br /><a href="book-Z-H-17.html#%_idx_2392"><tt>imag-part-polar</tt></a><br /><a href="book-Z-H-17.html#%_idx_2380"><tt>imag-part-rectangular</tt></a><br /><a href="book-Z-H-20.html#%_idx_3014">imperative programming</a><br /><a href="book-Z-H-10.html#%_idx_494">imperative vs. declarative knowledge</a>,
-<a href="book-Z-H-29.html#%_idx_5032">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5072">logic programming and</a>,
-<a href="book-Z-H-29.html#%_idx_5258">[2]</a><br />
-    <a href="book-Z-H-28.html#%_idx_4818">nondeterministic computing and</a><br /><a href="book-Z-H-22.html#%_idx_3576">imperative vs. expression-oriented programming style</a><br />
+<br /><a href="book-Z-H-14.html#__idx_1338">IBM 704</a><br /><a href="book-Z-H-12.html#__idx_996"><tt>identity</tt></a><br /><a href="book-Z-H-10.html#__idx_420"><tt>if</tt> (special form)</a><br />
+    <a href="book-Z-H-10.html#__idx_440"><tt>cond</tt> vs.</a><br />
+    <a href="book-Z-H-10.html#__idx_428">evaluation of</a><br />
+    <a href="book-Z-H-10.html#__idx_486">normal-order evaluation of</a><br />
+    <a href="book-Z-H-22.html#__idx_3474">one-armed (without alternative)</a><br />
+    <a href="book-Z-H-10.html#__idx_432">predicate, consequent, and alternative of</a><br />
+    <a href="book-Z-H-10.html#__idx_556">why a special form</a><br /><a href="book-Z-H-26.html#__idx_4322"><tt>if-alternative</tt></a><br /><a href="book-Z-H-26.html#__idx_4320"><tt>if-consequent</tt></a><br /><a href="book-Z-H-26.html#__idx_4318"><tt>if-predicate</tt></a><br /><a href="book-Z-H-26.html#__idx_4316"><tt>if?</tt></a><br /><tt>imag-part</tt>
+<br />
+    <a href="book-Z-H-17.html#__idx_2466">data-directed</a><br />
+    <a href="book-Z-H-17.html#__idx_2346">polar representation</a><br />
+    <a href="book-Z-H-17.html#__idx_2330">rectangular representation</a><br />
+    <a href="book-Z-H-17.html#__idx_2408">with tagged data</a><br /><a href="book-Z-H-17.html#__idx_2392"><tt>imag-part-polar</tt></a><br /><a href="book-Z-H-17.html#__idx_2380"><tt>imag-part-rectangular</tt></a><br /><a href="book-Z-H-20.html#__idx_3014">imperative programming</a><br /><a href="book-Z-H-10.html#__idx_494">imperative vs. declarative knowledge</a>,
+<a href="book-Z-H-29.html#__idx_5032">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5072">logic programming and</a>,
+<a href="book-Z-H-29.html#__idx_5258">[2]</a><br />
+    <a href="book-Z-H-28.html#__idx_4818">nondeterministic computing and</a><br /><a href="book-Z-H-22.html#__idx_3576">imperative vs. expression-oriented programming style</a><br />
 implementation dependencies, <em>see also</em> unspecified values
 <br />
-    <a href="book-Z-H-10.html#%_idx_546">numbers</a><br />
-    <a href="book-Z-H-21.html#%_idx_3068">order of subexpression evaluation</a><br /><a href="book-Z-H-12.html#%_idx_992"><tt>inc</tt></a><br /><a href="book-Z-H-10.html#%_idx_234">incremental development of programs</a><br /><a href="book-Z-H-18.html#%_idx_2654">indeterminate of a polynomial</a><br /><a href="book-Z-H-29.html#%_idx_5192">indexing a data base</a>,
-<a href="book-Z-H-29.html#%_idx_5376">[2]</a><br /><a href="book-Z-H-29.html#%_idx_5248">inference, method of</a><br /><a href="book-Z-H-29.html#%_idx_5368">infinite series</a><br /><a href="book-Z-H-24.html#%_idx_3832">infinite stream(s)</a><br />
-    <a href="book-Z-H-24.html#%_idx_3896">merging</a>, <a href="book-Z-H-24.html#%_idx_3992">[2]</a>,
-<a href="book-Z-H-24.html#%_idx_4006">[3]</a>, <a href="book-Z-H-24.html#%_idx_4178">[4]</a><br />
-    <a href="book-Z-H-24.html#%_idx_4182">merging as a relation</a><br />
-    <a href="book-Z-H-24.html#%_idx_3888">of factorials</a><br />
+    <a href="book-Z-H-10.html#__idx_546">numbers</a><br />
+    <a href="book-Z-H-21.html#__idx_3068">order of subexpression evaluation</a><br /><a href="book-Z-H-12.html#__idx_992"><tt>inc</tt></a><br /><a href="book-Z-H-10.html#__idx_234">incremental development of programs</a><br /><a href="book-Z-H-18.html#__idx_2654">indeterminate of a polynomial</a><br /><a href="book-Z-H-29.html#__idx_5192">indexing a data base</a>,
+<a href="book-Z-H-29.html#__idx_5376">[2]</a><br /><a href="book-Z-H-29.html#__idx_5248">inference, method of</a><br /><a href="book-Z-H-29.html#__idx_5368">infinite series</a><br /><a href="book-Z-H-24.html#__idx_3832">infinite stream(s)</a><br />
+    <a href="book-Z-H-24.html#__idx_3896">merging</a>, <a href="book-Z-H-24.html#__idx_3992">[2]</a>,
+<a href="book-Z-H-24.html#__idx_4006">[3]</a>, <a href="book-Z-H-24.html#__idx_4178">[4]</a><br />
+    <a href="book-Z-H-24.html#__idx_4182">merging as a relation</a><br />
+    <a href="book-Z-H-24.html#__idx_3888">of factorials</a><br />
     of Fibonacci numbers, <em>see</em> <tt>fibs</tt>
 <br />
     of integers, <em>see</em> <tt>integers</tt>
 <br />
-    <a href="book-Z-H-24.html#%_idx_3986">of pairs</a><br />
+    <a href="book-Z-H-24.html#__idx_3986">of pairs</a><br />
     of prime numbers, <em>see</em> <tt>primes</tt>
 <br />
-    <a href="book-Z-H-24.html#%_idx_4126">of random numbers</a><br />
-    <a href="book-Z-H-24.html#%_idx_3912">representing power series</a><br />
-    <a href="book-Z-H-24.html#%_idx_4020">to model signals</a><br />
-    <a href="book-Z-H-24.html#%_idx_3960">to sum a series</a><br /><a href="book-Z-H-16.html#%_idx_2096">infix notation, prefix notation vs.</a><br /><a href="book-Z-H-22.html#%_idx_3536"><tt>inform-about-no-value</tt></a><br /><a href="book-Z-H-22.html#%_idx_3534"><tt>inform-about-value</tt></a><br />
+    <a href="book-Z-H-24.html#__idx_4126">of random numbers</a><br />
+    <a href="book-Z-H-24.html#__idx_3912">representing power series</a><br />
+    <a href="book-Z-H-24.html#__idx_4020">to model signals</a><br />
+    <a href="book-Z-H-24.html#__idx_3960">to sum a series</a><br /><a href="book-Z-H-16.html#__idx_2096">infix notation, prefix notation vs.</a><br /><a href="book-Z-H-22.html#__idx_3536"><tt>inform-about-no-value</tt></a><br /><a href="book-Z-H-22.html#__idx_3534"><tt>inform-about-value</tt></a><br />
 information retrieval, <em>see</em> data base
-<br /><a href="book-Z-H-27.html#%_idx_4702">Ingerman, Peter</a><br /><a href="book-Z-H-32.html#%_idx_5656"><tt>initialize-stack</tt> operation in register machine</a>, <a href="book-Z-H-32.html#%_idx_5808">[2]</a><br /><tt>insert!</tt>
-<br />
-    <a href="book-Z-H-22.html#%_idx_3284">in one-dimensional table</a><br />
-    <a href="book-Z-H-22.html#%_idx_3292">in two-dimensional table</a><br /><a href="book-Z-H-22.html#%_idx_3238"><tt>insert-queue!</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3256">[2]</a><br /><a href="book-Z-H-18.html#%_idx_2542"><tt>install-complex-package</tt></a><br /><a href="book-Z-H-17.html#%_idx_2454"><tt>install-polar-package</tt></a><br /><a href="book-Z-H-18.html#%_idx_2684"><tt>install-polynomial-package</tt></a><br /><a href="book-Z-H-18.html#%_idx_2530"><tt>install-rational-package</tt></a><br /><a href="book-Z-H-17.html#%_idx_2448"><tt>install-rectangular-package</tt></a><br /><a href="book-Z-H-18.html#%_idx_2520"><tt>install-scheme-number-package</tt></a><br /><a href="book-Z-H-29.html#%_idx_5304"><tt>instantiate</tt></a><br /><a href="book-Z-H-29.html#%_idx_5120">instantiate a pattern</a><br /><a href="book-Z-H-32.html#%_idx_5816">instruction counting</a><br /><a href="book-Z-H-32.html#%_idx_5666">instruction execution procedure</a><br /><a href="book-Z-H-35.html#%_idx_6256">instruction sequence</a>,
-<a href="book-Z-H-35.html#%_idx_6378">[2]</a><br /><a href="book-Z-H-32.html#%_idx_5818">instruction tracing</a><br /><a href="book-Z-H-32.html#%_idx_5708"><tt>instruction-execution-proc</tt></a><br /><a href="book-Z-H-32.html#%_idx_5706"><tt>instruction-text</tt></a><br /><a href="book-Z-H-10.html#%_idx_136">integer(s)</a><br />
-    <a href="book-Z-H-10.html#%_idx_534">dividing</a><br />
-    <a href="book-Z-H-10.html#%_idx_530">exact</a><br /><a href="book-Z-H-18.html#%_idx_2800">integerizing factor</a><br /><a href="book-Z-H-24.html#%_idx_3836"><tt>integers</tt> (infinite stream)</a><br />
-    <a href="book-Z-H-24.html#%_idx_3866">implicit definition</a><br />
-    <a href="book-Z-H-27.html#%_idx_4790">lazy-list version</a><br /><a href="book-Z-H-24.html#%_idx_3834"><tt>integers-starting-from</tt></a><br />
+<br /><a href="book-Z-H-27.html#__idx_4702">Ingerman, Peter</a><br /><a href="book-Z-H-32.html#__idx_5656"><tt>initialize-stack</tt> operation in register machine</a>, <a href="book-Z-H-32.html#__idx_5808">[2]</a><br /><tt>insert!</tt>
+<br />
+    <a href="book-Z-H-22.html#__idx_3284">in one-dimensional table</a><br />
+    <a href="book-Z-H-22.html#__idx_3292">in two-dimensional table</a><br /><a href="book-Z-H-22.html#__idx_3238"><tt>insert-queue!</tt></a>,
+<a href="book-Z-H-22.html#__idx_3256">[2]</a><br /><a href="book-Z-H-18.html#__idx_2542"><tt>install-complex-package</tt></a><br /><a href="book-Z-H-17.html#__idx_2454"><tt>install-polar-package</tt></a><br /><a href="book-Z-H-18.html#__idx_2684"><tt>install-polynomial-package</tt></a><br /><a href="book-Z-H-18.html#__idx_2530"><tt>install-rational-package</tt></a><br /><a href="book-Z-H-17.html#__idx_2448"><tt>install-rectangular-package</tt></a><br /><a href="book-Z-H-18.html#__idx_2520"><tt>install-scheme-number-package</tt></a><br /><a href="book-Z-H-29.html#__idx_5304"><tt>instantiate</tt></a><br /><a href="book-Z-H-29.html#__idx_5120">instantiate a pattern</a><br /><a href="book-Z-H-32.html#__idx_5816">instruction counting</a><br /><a href="book-Z-H-32.html#__idx_5666">instruction execution procedure</a><br /><a href="book-Z-H-35.html#__idx_6256">instruction sequence</a>,
+<a href="book-Z-H-35.html#__idx_6378">[2]</a><br /><a href="book-Z-H-32.html#__idx_5818">instruction tracing</a><br /><a href="book-Z-H-32.html#__idx_5708"><tt>instruction-execution-proc</tt></a><br /><a href="book-Z-H-32.html#__idx_5706"><tt>instruction-text</tt></a><br /><a href="book-Z-H-10.html#__idx_136">integer(s)</a><br />
+    <a href="book-Z-H-10.html#__idx_534">dividing</a><br />
+    <a href="book-Z-H-10.html#__idx_530">exact</a><br /><a href="book-Z-H-18.html#__idx_2800">integerizing factor</a><br /><a href="book-Z-H-24.html#__idx_3836"><tt>integers</tt> (infinite stream)</a><br />
+    <a href="book-Z-H-24.html#__idx_3866">implicit definition</a><br />
+    <a href="book-Z-H-27.html#__idx_4790">lazy-list version</a><br /><a href="book-Z-H-24.html#__idx_3834"><tt>integers-starting-from</tt></a><br />
 integral, <em>see also</em> definite integral; Monte Carlo integration
 <br />
-    <a href="book-Z-H-24.html#%_idx_3920">of a power series</a><br /><a href="book-Z-H-12.html#%_idx_1004"><tt>integral</tt></a>, <a href="book-Z-H-24.html#%_idx_4024">[2]</a>,
-<a href="book-Z-H-24.html#%_idx_4080">[3]</a><br />
-    <a href="book-Z-H-24.html#%_idx_4074">with delayed argument</a><br />
-    <a href="book-Z-H-12.html#%_idx_1032">with <tt>lambda</tt></a><br />
-    <a href="book-Z-H-27.html#%_idx_4802">lazy-list version</a><br />
-    <a href="book-Z-H-24.html#%_idx_4060">need for delayed evaluation</a><br /><a href="book-Z-H-24.html#%_idx_3924"><tt>integrate-series</tt></a><br /><a href="book-Z-H-34.html#%_idx_6000">integrated-circuit implementation of Scheme</a>, <a href="book-Z-H-34.html#%_idx_6012">[2]</a><br /><a href="book-Z-H-24.html#%_idx_4022">integrator, for signals</a><br /><a href="book-Z-H-24.html#%_idx_4000"><tt>interleave</tt></a><br /><a href="book-Z-H-29.html#%_idx_5388"><tt>interleave-delayed</tt></a><br /><a href="book-Z-H-9.html#%_idx_56">Interlisp</a><br /><a href="book-Z-H-10.html#%_idx_614">internal definition</a><br />
-    <a href="book-Z-H-21.html#%_idx_3116">in environment model</a><br />
-    <a href="book-Z-H-10.html#%_idx_616">free variable in</a><br />
-    <a href="book-Z-H-12.html#%_idx_1074"><tt>let</tt> vs.</a><br />
-    <a href="book-Z-H-28.html#%_idx_5010">in nondeterministic evaluator</a><br />
-    <a href="book-Z-H-10.html#%_idx_626">position of</a><br />
-    <a href="book-Z-H-26.html#%_idx_4604">restrictions on</a><br />
-    <a href="book-Z-H-26.html#%_idx_4608">scanning out</a><br />
-    <a href="book-Z-H-26.html#%_idx_4598">scope of name</a><br /><a href="book-Z-H-35.html#%_idx_6498">Internet “Worm”</a><br /><a href="book-Z-H-33.html#%_idx_5888">interning symbols</a><br /><a href="book-Z-H-9.html#%_idx_30">interpreter</a>, <em>see also</em> evaluator
-<br />
-    <a href="book-Z-H-35.html#%_idx_6212">compiler vs.</a>,
-<a href="book-Z-H-35.html#%_idx_6490">[2]</a><br />
-    <a href="book-Z-H-10.html#%_idx_206">read-eval-print loop</a><br /><a href="book-Z-H-16.html#%_idx_2110"><tt>intersection-set</tt></a><br />
-    <a href="book-Z-H-16.html#%_idx_2196">binary-tree representation</a><br />
-    <a href="book-Z-H-16.html#%_idx_2130">ordered-list representation</a><br />
-    <a href="book-Z-H-16.html#%_idx_2120">unordered-list representation</a><br /><a href="book-Z-H-14.html#%_idx_1478">interval arithmetic</a><br /><a href="book-Z-H-11.html#%_idx_816">invariant quantity of an iterative process</a><br /><a href="book-Z-H-22.html#%_idx_3344">inverter</a><br />
-    <a href="book-Z-H-22.html#%_idx_3378"><tt>inverter</tt></a><br />
+    <a href="book-Z-H-24.html#__idx_3920">of a power series</a><br /><a href="book-Z-H-12.html#__idx_1004"><tt>integral</tt></a>, <a href="book-Z-H-24.html#__idx_4024">[2]</a>,
+<a href="book-Z-H-24.html#__idx_4080">[3]</a><br />
+    <a href="book-Z-H-24.html#__idx_4074">with delayed argument</a><br />
+    <a href="book-Z-H-12.html#__idx_1032">with <tt>lambda</tt></a><br />
+    <a href="book-Z-H-27.html#__idx_4802">lazy-list version</a><br />
+    <a href="book-Z-H-24.html#__idx_4060">need for delayed evaluation</a><br /><a href="book-Z-H-24.html#__idx_3924"><tt>integrate-series</tt></a><br /><a href="book-Z-H-34.html#__idx_6000">integrated-circuit implementation of Scheme</a>, <a href="book-Z-H-34.html#__idx_6012">[2]</a><br /><a href="book-Z-H-24.html#__idx_4022">integrator, for signals</a><br /><a href="book-Z-H-24.html#__idx_4000"><tt>interleave</tt></a><br /><a href="book-Z-H-29.html#__idx_5388"><tt>interleave-delayed</tt></a><br /><a href="book-Z-H-9.html#__idx_56">Interlisp</a><br /><a href="book-Z-H-10.html#__idx_614">internal definition</a><br />
+    <a href="book-Z-H-21.html#__idx_3116">in environment model</a><br />
+    <a href="book-Z-H-10.html#__idx_616">free variable in</a><br />
+    <a href="book-Z-H-12.html#__idx_1074"><tt>let</tt> vs.</a><br />
+    <a href="book-Z-H-28.html#__idx_5010">in nondeterministic evaluator</a><br />
+    <a href="book-Z-H-10.html#__idx_626">position of</a><br />
+    <a href="book-Z-H-26.html#__idx_4604">restrictions on</a><br />
+    <a href="book-Z-H-26.html#__idx_4608">scanning out</a><br />
+    <a href="book-Z-H-26.html#__idx_4598">scope of name</a><br /><a href="book-Z-H-35.html#__idx_6498">Internet “Worm”</a><br /><a href="book-Z-H-33.html#__idx_5888">interning symbols</a><br /><a href="book-Z-H-9.html#__idx_30">interpreter</a>, <em>see also</em> evaluator
+<br />
+    <a href="book-Z-H-35.html#__idx_6212">compiler vs.</a>,
+<a href="book-Z-H-35.html#__idx_6490">[2]</a><br />
+    <a href="book-Z-H-10.html#__idx_206">read-eval-print loop</a><br /><a href="book-Z-H-16.html#__idx_2110"><tt>intersection-set</tt></a><br />
+    <a href="book-Z-H-16.html#__idx_2196">binary-tree representation</a><br />
+    <a href="book-Z-H-16.html#__idx_2130">ordered-list representation</a><br />
+    <a href="book-Z-H-16.html#__idx_2120">unordered-list representation</a><br /><a href="book-Z-H-14.html#__idx_1478">interval arithmetic</a><br /><a href="book-Z-H-11.html#__idx_816">invariant quantity of an iterative process</a><br /><a href="book-Z-H-22.html#__idx_3344">inverter</a><br />
+    <a href="book-Z-H-22.html#__idx_3378"><tt>inverter</tt></a><br />
 iteration contructs, <em>see</em> looping constructs
-<br /><a href="book-Z-H-12.html#%_idx_1246">iterative improvement</a><br /><a href="book-Z-H-11.html#%_idx_666">iterative process</a><br />
-    <a href="book-Z-H-24.html#%_idx_3944">as a stream process</a><br />
-    <a href="book-Z-H-11.html#%_idx_818">design of algorithm</a><br />
-    <a href="book-Z-H-10.html#%_idx_552">implemented by procedure call</a>,
-<a href="book-Z-H-11.html#%_idx_694">[2]</a>, <a href="book-Z-H-34.html#%_idx_6102">[3]</a>,
+<br /><a href="book-Z-H-12.html#__idx_1246">iterative improvement</a><br /><a href="book-Z-H-11.html#__idx_666">iterative process</a><br />
+    <a href="book-Z-H-24.html#__idx_3944">as a stream process</a><br />
+    <a href="book-Z-H-11.html#__idx_818">design of algorithm</a><br />
+    <a href="book-Z-H-10.html#__idx_552">implemented by procedure call</a>,
+<a href="book-Z-H-11.html#__idx_694">[2]</a>, <a href="book-Z-H-34.html#__idx_6102">[3]</a>,
 <em>see also</em> tail recursion
 <br />
-    <a href="book-Z-H-11.html#%_idx_672">linear</a>, <a href="book-Z-H-11.html#%_idx_772">[2]</a><br />
-    <a href="book-Z-H-11.html#%_idx_636">recursive process vs.</a>,
-<a href="book-Z-H-21.html#%_idx_3092">[2]</a>, <a href="book-Z-H-31.html#%_idx_5570">[3]</a>,
-<a href="book-Z-H-35.html#%_idx_6408">[4]</a><br />
-    <a href="book-Z-H-31.html#%_idx_5566">register machine for</a></p><p>
+    <a href="book-Z-H-11.html#__idx_672">linear</a>, <a href="book-Z-H-11.html#__idx_772">[2]</a><br />
+    <a href="book-Z-H-11.html#__idx_636">recursive process vs.</a>,
+<a href="book-Z-H-21.html#__idx_3092">[2]</a>, <a href="book-Z-H-31.html#__idx_5570">[3]</a>,
+<a href="book-Z-H-35.html#__idx_6408">[4]</a><br />
+    <a href="book-Z-H-31.html#__idx_5566">register machine for</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-22.html#%_idx_3506">Jayaraman, Sundaresan</a></p><p>
+<br /><a href="book-Z-H-22.html#__idx_3506">Jayaraman, Sundaresan</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-11.html#%_idx_832">Kaldewaij, Anne</a><br /><a href="book-Z-H-19.html#%_idx_2822">Karr, Alphonse</a><br /><a href="book-Z-H-30.html#%_idx_5456">Kepler, Johannes</a><br /><a href="book-Z-H-16.html#%_idx_2208"><tt>key</tt></a><br />
+<br /><a href="book-Z-H-11.html#__idx_832">Kaldewaij, Anne</a><br /><a href="book-Z-H-19.html#__idx_2822">Karr, Alphonse</a><br /><a href="book-Z-H-30.html#__idx_5456">Kepler, Johannes</a><br /><a href="book-Z-H-16.html#__idx_2208"><tt>key</tt></a><br />
 key of a record
 <br />
-    <a href="book-Z-H-16.html#%_idx_2206">in a data base</a><br />
-    <a href="book-Z-H-22.html#%_idx_3270">in a table</a><br />
-    <a href="book-Z-H-22.html#%_idx_3306">testing equality of</a><br /><a href="book-Z-H-11.html#%_idx_746">Khayyam, Omar</a><br /><a href="book-Z-H-11.html#%_idx_744">Knuth, Donald E.</a>, <a href="book-Z-H-11.html#%_idx_814">[2]</a>,
-<a href="book-Z-H-11.html#%_idx_840">[3]</a>, <a href="book-Z-H-15.html#%_idx_1776">[4]</a>,
-<a href="book-Z-H-20.html#%_idx_2924">[5]</a>, <a href="book-Z-H-20.html#%_idx_2944">[6]</a>,
-<a href="#%_idx_6794">[7]</a><br /><a href="book-Z-H-26.html#%_idx_4376">Kohlbecker, Eugene Edmund, Jr.</a><br /><a href="book-Z-H-20.html#%_idx_2928">Kolmogorov, A. N.</a><br /><a href="book-Z-H-22.html#%_idx_3504">Konopasek, Milos</a><br /><a href="book-Z-H-29.html#%_idx_5058">Kowalski, Robert</a><br /><a href="book-Z-H-15.html#%_idx_1822">KRC</a>, <a href="book-Z-H-24.html#%_idx_3998">[2]</a></p><p>
+    <a href="book-Z-H-16.html#__idx_2206">in a data base</a><br />
+    <a href="book-Z-H-22.html#__idx_3270">in a table</a><br />
+    <a href="book-Z-H-22.html#__idx_3306">testing equality of</a><br /><a href="book-Z-H-11.html#__idx_746">Khayyam, Omar</a><br /><a href="book-Z-H-11.html#__idx_744">Knuth, Donald E.</a>, <a href="book-Z-H-11.html#__idx_814">[2]</a>,
+<a href="book-Z-H-11.html#__idx_840">[3]</a>, <a href="book-Z-H-15.html#__idx_1776">[4]</a>,
+<a href="book-Z-H-20.html#__idx_2924">[5]</a>, <a href="book-Z-H-20.html#__idx_2944">[6]</a>,
+<a href="#__idx_6794">[7]</a><br /><a href="book-Z-H-26.html#__idx_4376">Kohlbecker, Eugene Edmund, Jr.</a><br /><a href="book-Z-H-20.html#__idx_2928">Kolmogorov, A. N.</a><br /><a href="book-Z-H-22.html#__idx_3504">Konopasek, Milos</a><br /><a href="book-Z-H-29.html#__idx_5058">Kowalski, Robert</a><br /><a href="book-Z-H-15.html#__idx_1822">KRC</a>, <a href="book-Z-H-24.html#__idx_3998">[2]</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-31.html#%_idx_5510"><tt>label</tt> (in register machine)</a><br />
-    <a href="book-Z-H-32.html#%_idx_5770">simulating</a><br /><a href="book-Z-H-32.html#%_idx_5784"><tt>label-exp</tt></a><br /><a href="book-Z-H-32.html#%_idx_5786"><tt>label-exp-label</tt></a><br /><a href="book-Z-H-18.html#%_idx_2662">Lagrange interpolation formula</a><br /><a href="book-Z-H-12.html#%_idx_1054">λ  calculus (lambda calculus)</a><br /><a href="book-Z-H-12.html#%_idx_1034"><tt>lambda</tt> (special form)</a><br />
-    <a href="book-Z-H-12.html#%_idx_1040"><tt>define</tt> vs.</a><br />
-    <a href="book-Z-H-15.html#%_idx_1656">with dotted-tail notation</a><br /><tt>lambda</tt> expression
+<br /><a href="book-Z-H-31.html#__idx_5510"><tt>label</tt> (in register machine)</a><br />
+    <a href="book-Z-H-32.html#__idx_5770">simulating</a><br /><a href="book-Z-H-32.html#__idx_5784"><tt>label-exp</tt></a><br /><a href="book-Z-H-32.html#__idx_5786"><tt>label-exp-label</tt></a><br /><a href="book-Z-H-18.html#__idx_2662">Lagrange interpolation formula</a><br /><a href="book-Z-H-12.html#__idx_1054">λ  calculus (lambda calculus)</a><br /><a href="book-Z-H-12.html#__idx_1034"><tt>lambda</tt> (special form)</a><br />
+    <a href="book-Z-H-12.html#__idx_1040"><tt>define</tt> vs.</a><br />
+    <a href="book-Z-H-15.html#__idx_1656">with dotted-tail notation</a><br /><tt>lambda</tt> expression
 <br />
-    <a href="book-Z-H-12.html#%_idx_1050">as operator of combination</a><br />
-    <a href="book-Z-H-21.html#%_idx_3076">value of</a><br /><a href="book-Z-H-26.html#%_idx_4312"><tt>lambda-body</tt></a><br /><a href="book-Z-H-26.html#%_idx_4310"><tt>lambda-parameters</tt></a><br /><a href="book-Z-H-26.html#%_idx_4308"><tt>lambda?</tt></a><br /><a href="book-Z-H-12.html#%_idx_1150">Lambert, J.H.</a><br /><a href="book-Z-H-11.html#%_idx_850">Lamé, Gabriel</a><br /><a href="book-Z-H-11.html#%_idx_848">Lamé's Theorem</a><br /><a href="book-Z-H-23.html#%_idx_3722">Lamport, Leslie</a><br /><a href="book-Z-H-20.html#%_idx_3006">Lampson, Butler</a><br /><a href="book-Z-H-10.html#%_idx_280">Landin, Peter</a>, <a href="book-Z-H-24.html#%_idx_3810">[2]</a><br />
+    <a href="book-Z-H-12.html#__idx_1050">as operator of combination</a><br />
+    <a href="book-Z-H-21.html#__idx_3076">value of</a><br /><a href="book-Z-H-26.html#__idx_4312"><tt>lambda-body</tt></a><br /><a href="book-Z-H-26.html#__idx_4310"><tt>lambda-parameters</tt></a><br /><a href="book-Z-H-26.html#__idx_4308"><tt>lambda?</tt></a><br /><a href="book-Z-H-12.html#__idx_1150">Lambert, J.H.</a><br /><a href="book-Z-H-11.html#__idx_850">Lamé, Gabriel</a><br /><a href="book-Z-H-11.html#__idx_848">Lamé's Theorem</a><br /><a href="book-Z-H-23.html#__idx_3722">Lamport, Leslie</a><br /><a href="book-Z-H-20.html#__idx_3006">Lampson, Butler</a><br /><a href="book-Z-H-10.html#__idx_280">Landin, Peter</a>, <a href="book-Z-H-24.html#__idx_3810">[2]</a><br />
 language, <em>see</em> natural language; programming language
-<br /><a href="book-Z-H-26.html#%_idx_4650">Lapalme, Guy</a><br /><a href="book-Z-H-26.html#%_idx_4330"><tt>last-exp?</tt></a><br /><a href="book-Z-H-34.html#%_idx_6064"><tt>last-operand?</tt></a><br /><a href="book-Z-H-15.html#%_idx_1638"><tt>last-pair</tt></a>, <a href="book-Z-H-22.html#%_idx_3168">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5166">rules</a><br /><a href="book-Z-H-27.html#%_idx_4684">lazy evaluation</a><br /><a href="book-Z-H-27.html#%_idx_4666">lazy evaluator</a><br /><a href="book-Z-H-27.html#%_idx_4756">lazy list</a><br /><a href="book-Z-H-27.html#%_idx_4760">lazy pair</a><br /><a href="book-Z-H-27.html#%_idx_4794">lazy tree</a><br /><a href="book-Z-H-16.html#%_idx_2252"><tt>leaf?</tt></a><br /><a href="book-Z-H-17.html#%_idx_2364">least commitment, principle of</a><br /><a href="book-Z-H-12.html#%_idx_1110">lecture, something to do during</a><br /><a href="book-Z-H-16.html#%_idx_2154"><tt>left-branch</tt></a>,
-<a href="book-Z-H-16.html#%_idx_2260">[2]</a><br />
+<br /><a href="book-Z-H-26.html#__idx_4650">Lapalme, Guy</a><br /><a href="book-Z-H-26.html#__idx_4330"><tt>last-exp?</tt></a><br /><a href="book-Z-H-34.html#__idx_6064"><tt>last-operand?</tt></a><br /><a href="book-Z-H-15.html#__idx_1638"><tt>last-pair</tt></a>, <a href="book-Z-H-22.html#__idx_3168">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5166">rules</a><br /><a href="book-Z-H-27.html#__idx_4684">lazy evaluation</a><br /><a href="book-Z-H-27.html#__idx_4666">lazy evaluator</a><br /><a href="book-Z-H-27.html#__idx_4756">lazy list</a><br /><a href="book-Z-H-27.html#__idx_4760">lazy pair</a><br /><a href="book-Z-H-27.html#__idx_4794">lazy tree</a><br /><a href="book-Z-H-16.html#__idx_2252"><tt>leaf?</tt></a><br /><a href="book-Z-H-17.html#__idx_2364">least commitment, principle of</a><br /><a href="book-Z-H-12.html#__idx_1110">lecture, something to do during</a><br /><a href="book-Z-H-16.html#__idx_2154"><tt>left-branch</tt></a>,
+<a href="book-Z-H-16.html#__idx_2260">[2]</a><br />
 Leibniz, Baron Gottfried Wilhelm von
 <br />
-    <a href="book-Z-H-11.html#%_idx_880">proof of Fermat's Little Theorem</a><br />
-    <a href="book-Z-H-12.html#%_idx_976">series for π </a>,
-<a href="book-Z-H-24.html#%_idx_3952">[2]</a><br /><a href="book-Z-H-16.html#%_idx_2178">Leiserson, Charles E.</a>,
-<a href="book-Z-H-24.html#%_idx_4016">[2]</a><br /><a href="book-Z-H-15.html#%_idx_1620"><tt>length</tt></a><br />
-    <a href="book-Z-H-15.html#%_idx_1770">as accumulation</a><br />
-    <a href="book-Z-H-15.html#%_idx_1626">iterative version</a><br />
-    <a href="book-Z-H-15.html#%_idx_1624">recursive version</a><br /><a href="book-Z-H-12.html#%_idx_1062"><tt>let</tt> (special form)</a><br />
-    <a href="book-Z-H-21.html#%_idx_3110">evaluation model</a><br />
-    <a href="book-Z-H-12.html#%_idx_1076">internal definition vs.</a><br />
-    <a href="book-Z-H-26.html#%_idx_4414">named</a><br />
-    <a href="book-Z-H-12.html#%_idx_1070">scope of variables</a><br />
-    <a href="book-Z-H-12.html#%_idx_1068">as syntactic sugar</a>,
-<a href="book-Z-H-21.html#%_idx_3108">[2]</a><br /><a href="book-Z-H-26.html#%_idx_4408"><tt>let*</tt> (special form)</a><br /><a href="book-Z-H-26.html#%_idx_4618"><tt>letrec</tt> (special form)</a><br /><a href="book-Z-H-35.html#%_idx_6430">lexical addressing</a><br />
-    <a href="book-Z-H-35.html#%_idx_6434">lexical address</a><br /><a href="book-Z-H-10.html#%_idx_620">lexical scoping</a><br />
-    <a href="book-Z-H-35.html#%_idx_6432">environment structure and</a><br /><a href="book-Z-H-35.html#%_idx_6436"><tt>lexical-address-lookup</tt></a>,
-<a href="book-Z-H-35.html#%_idx_6442">[2]</a><br /><a href="book-Z-H-35.html#%_idx_6438"><tt>lexical-address-set!</tt></a>,
-<a href="book-Z-H-35.html#%_idx_6444">[2]</a><br /><a href="book-Z-H-33.html#%_idx_5952">Lieberman, Henry</a><br />
+    <a href="book-Z-H-11.html#__idx_880">proof of Fermat's Little Theorem</a><br />
+    <a href="book-Z-H-12.html#__idx_976">series for π </a>,
+<a href="book-Z-H-24.html#__idx_3952">[2]</a><br /><a href="book-Z-H-16.html#__idx_2178">Leiserson, Charles E.</a>,
+<a href="book-Z-H-24.html#__idx_4016">[2]</a><br /><a href="book-Z-H-15.html#__idx_1620"><tt>length</tt></a><br />
+    <a href="book-Z-H-15.html#__idx_1770">as accumulation</a><br />
+    <a href="book-Z-H-15.html#__idx_1626">iterative version</a><br />
+    <a href="book-Z-H-15.html#__idx_1624">recursive version</a><br /><a href="book-Z-H-12.html#__idx_1062"><tt>let</tt> (special form)</a><br />
+    <a href="book-Z-H-21.html#__idx_3110">evaluation model</a><br />
+    <a href="book-Z-H-12.html#__idx_1076">internal definition vs.</a><br />
+    <a href="book-Z-H-26.html#__idx_4414">named</a><br />
+    <a href="book-Z-H-12.html#__idx_1070">scope of variables</a><br />
+    <a href="book-Z-H-12.html#__idx_1068">as syntactic sugar</a>,
+<a href="book-Z-H-21.html#__idx_3108">[2]</a><br /><a href="book-Z-H-26.html#__idx_4408"><tt>let*</tt> (special form)</a><br /><a href="book-Z-H-26.html#__idx_4618"><tt>letrec</tt> (special form)</a><br /><a href="book-Z-H-35.html#__idx_6430">lexical addressing</a><br />
+    <a href="book-Z-H-35.html#__idx_6434">lexical address</a><br /><a href="book-Z-H-10.html#__idx_620">lexical scoping</a><br />
+    <a href="book-Z-H-35.html#__idx_6432">environment structure and</a><br /><a href="book-Z-H-35.html#__idx_6436"><tt>lexical-address-lookup</tt></a>,
+<a href="book-Z-H-35.html#__idx_6442">[2]</a><br /><a href="book-Z-H-35.html#__idx_6438"><tt>lexical-address-set!</tt></a>,
+<a href="book-Z-H-35.html#__idx_6444">[2]</a><br /><a href="book-Z-H-33.html#__idx_5952">Lieberman, Henry</a><br />
 LIFO buffer, <em>see</em> stack
 <br />
 line segment
 <br />
-    <a href="book-Z-H-14.html#%_idx_1396">represented as pair of points</a><br />
-    <a href="book-Z-H-15.html#%_idx_1952">represented as pair of vectors</a><br /><a href="book-Z-H-11.html#%_idx_658">linear growth</a>, <a href="book-Z-H-11.html#%_idx_780">[2]</a><br /><a href="book-Z-H-11.html#%_idx_674">linear iterative process</a><br />
-    <a href="book-Z-H-11.html#%_idx_770">order of growth</a><br /><a href="book-Z-H-11.html#%_idx_662">linear recursive process</a><br />
-    <a href="book-Z-H-11.html#%_idx_764">order of growth</a><br /><a href="book-Z-H-35.html#%_idx_6250">linkage descriptor</a><br /><a href="book-Z-H-14.html#%_idx_1444">Liskov, Barbara Huberman</a><br />
+    <a href="book-Z-H-14.html#__idx_1396">represented as pair of points</a><br />
+    <a href="book-Z-H-15.html#__idx_1952">represented as pair of vectors</a><br /><a href="book-Z-H-11.html#__idx_658">linear growth</a>, <a href="book-Z-H-11.html#__idx_780">[2]</a><br /><a href="book-Z-H-11.html#__idx_674">linear iterative process</a><br />
+    <a href="book-Z-H-11.html#__idx_770">order of growth</a><br /><a href="book-Z-H-11.html#__idx_662">linear recursive process</a><br />
+    <a href="book-Z-H-11.html#__idx_764">order of growth</a><br /><a href="book-Z-H-35.html#__idx_6250">linkage descriptor</a><br /><a href="book-Z-H-14.html#__idx_1444">Liskov, Barbara Huberman</a><br />
 Lisp
 <br />
-    <a href="book-Z-H-9.html#%_idx_38">acronym for LISt Processing</a><br />
-    <a href="book-Z-H-10.html#%_idx_346">applicative-order evaluation in</a><br />
-    <a href="book-Z-H-33.html#%_idx_5938">on DEC PDP-1</a><br />
-    <a href="book-Z-H-9.html#%_idx_98">efficiency of</a>, <a href="book-Z-H-10.html#%_idx_214">[2]</a><br />
-    <a href="book-Z-H-12.html#%_idx_1222">first-class procedures in</a><br />
-    <a href="book-Z-H-9.html#%_idx_96">Fortran vs.</a><br />
-    <a href="book-Z-H-9.html#%_idx_24">history of</a><br />
-    <a href="book-Z-H-18.html#%_idx_2550">internal type system</a><br />
-    <a href="book-Z-H-14.html#%_idx_1340">original implementation on IBM 704</a><br />
-    <a href="book-Z-H-10.html#%_idx_290">Pascal vs.</a><br />
-    <a href="book-Z-H-25.html#%_idx_4202">suitability for writing evaluators</a><br />
-    <a href="book-Z-H-9.html#%_idx_112">unique features of</a><br />
+    <a href="book-Z-H-9.html#__idx_38">acronym for LISt Processing</a><br />
+    <a href="book-Z-H-10.html#__idx_346">applicative-order evaluation in</a><br />
+    <a href="book-Z-H-33.html#__idx_5938">on DEC PDP-1</a><br />
+    <a href="book-Z-H-9.html#__idx_98">efficiency of</a>, <a href="book-Z-H-10.html#__idx_214">[2]</a><br />
+    <a href="book-Z-H-12.html#__idx_1222">first-class procedures in</a><br />
+    <a href="book-Z-H-9.html#__idx_96">Fortran vs.</a><br />
+    <a href="book-Z-H-9.html#__idx_24">history of</a><br />
+    <a href="book-Z-H-18.html#__idx_2550">internal type system</a><br />
+    <a href="book-Z-H-14.html#__idx_1340">original implementation on IBM 704</a><br />
+    <a href="book-Z-H-10.html#__idx_290">Pascal vs.</a><br />
+    <a href="book-Z-H-25.html#__idx_4202">suitability for writing evaluators</a><br />
+    <a href="book-Z-H-9.html#__idx_112">unique features of</a><br />
 Lisp dialects
 <br />
-    <a href="book-Z-H-9.html#%_idx_94">Common Lisp</a><br />
-    <a href="book-Z-H-9.html#%_idx_76">Franz Lisp</a><br />
-    <a href="book-Z-H-9.html#%_idx_58">Interlisp</a><br />
-    <a href="book-Z-H-9.html#%_idx_48">MacLisp</a><br />
-    <a href="book-Z-H-33.html#%_idx_5986">MDL</a><br />
-    <a href="book-Z-H-9.html#%_idx_68">Portable Standard Lisp</a><br />
-    <a href="book-Z-H-9.html#%_idx_44">Scheme</a><br />
-    <a href="book-Z-H-9.html#%_idx_82">Zetalisp</a><br /><a href="book-Z-H-29.html#%_idx_5332"><tt>lisp-value</tt> (query interpreter)</a><br /><a href="book-Z-H-29.html#%_idx_5132"><tt>lisp-value</tt> (query language)</a>,
-<a href="book-Z-H-29.html#%_idx_5270">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5206">evaluation of</a>,
-<a href="book-Z-H-29.html#%_idx_5330">[2]</a>, <a href="book-Z-H-29.html#%_idx_5440">[3]</a><br /><a href="book-Z-H-15.html#%_idx_1568"><tt>list</tt> (primitive procedure)</a><br /><a href="book-Z-H-14.html#%_idx_1342">list structure</a><br />
-    <a href="book-Z-H-15.html#%_idx_1572">list vs.</a><br />
-    <a href="book-Z-H-22.html#%_idx_3134">mutable</a><br />
-    <a href="book-Z-H-33.html#%_idx_5854">represented using vectors</a><br /><a href="book-Z-H-15.html#%_idx_1566">list(s)</a><br />
-    <a href="book-Z-H-35.html#%_idx_6280">backquote with</a><br />
-    <a href="book-Z-H-15.html#%_idx_1608"><tt>cdr</tt>ing down</a><br />
-    <a href="book-Z-H-15.html#%_idx_1634">combining with <tt>append</tt></a><br />
-    <a href="book-Z-H-15.html#%_idx_1630"><tt>cons</tt>ing up</a><br />
-    <a href="book-Z-H-16.html#%_idx_2184">converting a binary tree to a</a><br />
-    <a href="book-Z-H-16.html#%_idx_2190">converting to a binary tree</a><br />
+    <a href="book-Z-H-9.html#__idx_94">Common Lisp</a><br />
+    <a href="book-Z-H-9.html#__idx_76">Franz Lisp</a><br />
+    <a href="book-Z-H-9.html#__idx_58">Interlisp</a><br />
+    <a href="book-Z-H-9.html#__idx_48">MacLisp</a><br />
+    <a href="book-Z-H-33.html#__idx_5986">MDL</a><br />
+    <a href="book-Z-H-9.html#__idx_68">Portable Standard Lisp</a><br />
+    <a href="book-Z-H-9.html#__idx_44">Scheme</a><br />
+    <a href="book-Z-H-9.html#__idx_82">Zetalisp</a><br /><a href="book-Z-H-29.html#__idx_5332"><tt>lisp-value</tt> (query interpreter)</a><br /><a href="book-Z-H-29.html#__idx_5132"><tt>lisp-value</tt> (query language)</a>,
+<a href="book-Z-H-29.html#__idx_5270">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5206">evaluation of</a>,
+<a href="book-Z-H-29.html#__idx_5330">[2]</a>, <a href="book-Z-H-29.html#__idx_5440">[3]</a><br /><a href="book-Z-H-15.html#__idx_1568"><tt>list</tt> (primitive procedure)</a><br /><a href="book-Z-H-14.html#__idx_1342">list structure</a><br />
+    <a href="book-Z-H-15.html#__idx_1572">list vs.</a><br />
+    <a href="book-Z-H-22.html#__idx_3134">mutable</a><br />
+    <a href="book-Z-H-33.html#__idx_5854">represented using vectors</a><br /><a href="book-Z-H-15.html#__idx_1566">list(s)</a><br />
+    <a href="book-Z-H-35.html#__idx_6280">backquote with</a><br />
+    <a href="book-Z-H-15.html#__idx_1608"><tt>cdr</tt>ing down</a><br />
+    <a href="book-Z-H-15.html#__idx_1634">combining with <tt>append</tt></a><br />
+    <a href="book-Z-H-15.html#__idx_1630"><tt>cons</tt>ing up</a><br />
+    <a href="book-Z-H-16.html#__idx_2184">converting a binary tree to a</a><br />
+    <a href="book-Z-H-16.html#__idx_2190">converting to a binary tree</a><br />
     empty, <em>see</em> empty list
 <br />
-    <a href="book-Z-H-16.html#%_idx_2036">equality of</a><br />
-    <a href="book-Z-H-22.html#%_idx_3278">headed</a>, <a href="book-Z-H-22.html#%_idx_3454">[2]</a><br />
-    <a href="book-Z-H-15.html#%_idx_1640">last pair of</a><br />
-    <a href="book-Z-H-27.html#%_idx_4758">lazy</a><br />
-    <a href="book-Z-H-15.html#%_idx_1622">length of</a><br />
-    <a href="book-Z-H-15.html#%_idx_1574">list structure vs.</a><br />
-    <a href="book-Z-H-15.html#%_idx_1578">manipulation with <tt>car</tt>, <tt>cdr</tt>, and <tt>cons</tt></a><br />
-    <a href="book-Z-H-15.html#%_idx_1658">mapping over</a><br />
-    <a href="book-Z-H-15.html#%_idx_1610"><em>n</em>th element of</a><br />
-    <a href="book-Z-H-15.html#%_idx_1602">operations on</a><br />
-    <a href="book-Z-H-15.html#%_idx_1576">printed representation of</a><br />
-    <a href="book-Z-H-16.html#%_idx_2012">quotation of</a><br />
-    <a href="book-Z-H-15.html#%_idx_1644">reversing</a><br />
-    <a href="book-Z-H-15.html#%_idx_1604">techniques for manipulating</a><br /><a href="book-Z-H-16.html#%_idx_2192"><tt>list-&gt;tree</tt></a><br /><a href="book-Z-H-35.html#%_idx_6394"><tt>list-difference</tt></a><br /><a href="book-Z-H-27.html#%_idx_4726"><tt>list-of-arg-values</tt></a><br /><a href="book-Z-H-27.html#%_idx_4728"><tt>list-of-delayed-args</tt></a><br /><a href="book-Z-H-26.html#%_idx_4256"><tt>list-of-values</tt></a><br /><a href="book-Z-H-15.html#%_idx_1612"><tt>list-ref</tt></a>, <a href="book-Z-H-27.html#%_idx_4780">[2]</a><br /><a href="book-Z-H-33.html#%_idx_5828">list-structured memory</a><br /><a href="book-Z-H-35.html#%_idx_6392"><tt>list-union</tt></a><br /><a href="book-Z-H-29.html#%_idx_5140"><tt>lives-near</tt> (rule)</a>,
-<a href="book-Z-H-29.html#%_idx_5154">[2]</a><br /><a href="book-Z-H-11.html#%_idx_632">local evolution of a process</a><br /><a href="book-Z-H-10.html#%_idx_578">local name</a>, <a href="book-Z-H-12.html#%_idx_1060">[2]</a><br /><a href="book-Z-H-20.html#%_idx_2838">local state</a><br />
-    <a href="book-Z-H-21.html#%_idx_3100">maintained in frames</a><br /><a href="book-Z-H-20.html#%_idx_2844">local state variable</a><br /><a href="book-Z-H-12.html#%_idx_1058">local variable</a><br /><a href="book-Z-H-33.html#%_idx_5836">location</a><br /><a href="book-Z-H-9.html#%_idx_6">Locke, John</a><br /><a href="book-Z-H-12.html#%_idx_1134"><tt>log</tt> (primitive procedure)</a><br /><a href="book-Z-H-24.html#%_idx_3982">logarithm, approximating <tt>ln</tt> 2</a><br /><a href="book-Z-H-11.html#%_idx_784">logarithmic growth</a>,
-<a href="book-Z-H-11.html#%_idx_808">[2]</a>, <a href="book-Z-H-16.html#%_idx_2148">[3]</a><br /><a href="book-Z-H-29.html#%_idx_5028">logic programming</a>,
+    <a href="book-Z-H-16.html#__idx_2036">equality of</a><br />
+    <a href="book-Z-H-22.html#__idx_3278">headed</a>, <a href="book-Z-H-22.html#__idx_3454">[2]</a><br />
+    <a href="book-Z-H-15.html#__idx_1640">last pair of</a><br />
+    <a href="book-Z-H-27.html#__idx_4758">lazy</a><br />
+    <a href="book-Z-H-15.html#__idx_1622">length of</a><br />
+    <a href="book-Z-H-15.html#__idx_1574">list structure vs.</a><br />
+    <a href="book-Z-H-15.html#__idx_1578">manipulation with <tt>car</tt>, <tt>cdr</tt>, and <tt>cons</tt></a><br />
+    <a href="book-Z-H-15.html#__idx_1658">mapping over</a><br />
+    <a href="book-Z-H-15.html#__idx_1610"><em>n</em>th element of</a><br />
+    <a href="book-Z-H-15.html#__idx_1602">operations on</a><br />
+    <a href="book-Z-H-15.html#__idx_1576">printed representation of</a><br />
+    <a href="book-Z-H-16.html#__idx_2012">quotation of</a><br />
+    <a href="book-Z-H-15.html#__idx_1644">reversing</a><br />
+    <a href="book-Z-H-15.html#__idx_1604">techniques for manipulating</a><br /><a href="book-Z-H-16.html#__idx_2192"><tt>list-&gt;tree</tt></a><br /><a href="book-Z-H-35.html#__idx_6394"><tt>list-difference</tt></a><br /><a href="book-Z-H-27.html#__idx_4726"><tt>list-of-arg-values</tt></a><br /><a href="book-Z-H-27.html#__idx_4728"><tt>list-of-delayed-args</tt></a><br /><a href="book-Z-H-26.html#__idx_4256"><tt>list-of-values</tt></a><br /><a href="book-Z-H-15.html#__idx_1612"><tt>list-ref</tt></a>, <a href="book-Z-H-27.html#__idx_4780">[2]</a><br /><a href="book-Z-H-33.html#__idx_5828">list-structured memory</a><br /><a href="book-Z-H-35.html#__idx_6392"><tt>list-union</tt></a><br /><a href="book-Z-H-29.html#__idx_5140"><tt>lives-near</tt> (rule)</a>,
+<a href="book-Z-H-29.html#__idx_5154">[2]</a><br /><a href="book-Z-H-11.html#__idx_632">local evolution of a process</a><br /><a href="book-Z-H-10.html#__idx_578">local name</a>, <a href="book-Z-H-12.html#__idx_1060">[2]</a><br /><a href="book-Z-H-20.html#__idx_2838">local state</a><br />
+    <a href="book-Z-H-21.html#__idx_3100">maintained in frames</a><br /><a href="book-Z-H-20.html#__idx_2844">local state variable</a><br /><a href="book-Z-H-12.html#__idx_1058">local variable</a><br /><a href="book-Z-H-33.html#__idx_5836">location</a><br /><a href="book-Z-H-9.html#__idx_6">Locke, John</a><br /><a href="book-Z-H-12.html#__idx_1134"><tt>log</tt> (primitive procedure)</a><br /><a href="book-Z-H-24.html#__idx_3982">logarithm, approximating <tt>ln</tt> 2</a><br /><a href="book-Z-H-11.html#__idx_784">logarithmic growth</a>,
+<a href="book-Z-H-11.html#__idx_808">[2]</a>, <a href="book-Z-H-16.html#__idx_2148">[3]</a><br /><a href="book-Z-H-29.html#__idx_5028">logic programming</a>,
 <em>see also</em> query language; query interpreter
 <br />
-    <a href="book-Z-H-29.html#%_idx_5084">computers for</a><br />
-    <a href="book-Z-H-29.html#%_idx_5040">history of</a>, <a href="book-Z-H-29.html#%_idx_5080">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5082">in Japan</a><br />
-    <a href="book-Z-H-29.html#%_idx_5076">logic programming languages</a><br />
-    <a href="book-Z-H-29.html#%_idx_5246">mathematical logic vs.</a><br /><a href="book-Z-H-28.html#%_idx_4928">logic puzzles</a><br /><a href="book-Z-H-22.html#%_idx_3348">logical and</a><br /><a href="book-Z-H-22.html#%_idx_3352">logical or</a><br /><a href="book-Z-H-22.html#%_idx_3380"><tt>logical-not</tt></a><br /><tt>lookup</tt>
+    <a href="book-Z-H-29.html#__idx_5084">computers for</a><br />
+    <a href="book-Z-H-29.html#__idx_5040">history of</a>, <a href="book-Z-H-29.html#__idx_5080">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5082">in Japan</a><br />
+    <a href="book-Z-H-29.html#__idx_5076">logic programming languages</a><br />
+    <a href="book-Z-H-29.html#__idx_5246">mathematical logic vs.</a><br /><a href="book-Z-H-28.html#__idx_4928">logic puzzles</a><br /><a href="book-Z-H-22.html#__idx_3348">logical and</a><br /><a href="book-Z-H-22.html#__idx_3352">logical or</a><br /><a href="book-Z-H-22.html#__idx_3380"><tt>logical-not</tt></a><br /><tt>lookup</tt>
 <br />
-    <a href="book-Z-H-22.html#%_idx_3280">in one-dimensional table</a><br />
-    <a href="book-Z-H-16.html#%_idx_2210">in set of records</a><br />
-    <a href="book-Z-H-22.html#%_idx_3290">in two-dimensional table</a><br /><a href="book-Z-H-32.html#%_idx_5714"><tt>lookup-label</tt></a><br /><a href="book-Z-H-32.html#%_idx_5798"><tt>lookup-prim</tt></a><br /><a href="book-Z-H-26.html#%_idx_4456"><tt>lookup-variable-value</tt></a>,
-<a href="book-Z-H-26.html#%_idx_4480">[2]</a><br />
-    <a href="book-Z-H-26.html#%_idx_4612">for scanned-out definitions</a><br /><a href="book-Z-H-10.html#%_idx_554">looping constructs</a>,
-<a href="book-Z-H-11.html#%_idx_690">[2]</a><br />
-    <a href="book-Z-H-26.html#%_idx_4426">implementing in metacircular evaluator</a><br /><a href="book-Z-H-14.html#%_idx_1506"><tt>lower-bound</tt></a></p><p>
+    <a href="book-Z-H-22.html#__idx_3280">in one-dimensional table</a><br />
+    <a href="book-Z-H-16.html#__idx_2210">in set of records</a><br />
+    <a href="book-Z-H-22.html#__idx_3290">in two-dimensional table</a><br /><a href="book-Z-H-32.html#__idx_5714"><tt>lookup-label</tt></a><br /><a href="book-Z-H-32.html#__idx_5798"><tt>lookup-prim</tt></a><br /><a href="book-Z-H-26.html#__idx_4456"><tt>lookup-variable-value</tt></a>,
+<a href="book-Z-H-26.html#__idx_4480">[2]</a><br />
+    <a href="book-Z-H-26.html#__idx_4612">for scanned-out definitions</a><br /><a href="book-Z-H-10.html#__idx_554">looping constructs</a>,
+<a href="book-Z-H-11.html#__idx_690">[2]</a><br />
+    <a href="book-Z-H-26.html#__idx_4426">implementing in metacircular evaluator</a><br /><a href="book-Z-H-14.html#__idx_1506"><tt>lower-bound</tt></a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-35.html#%_idx_6206">machine language</a><br />
-    <a href="book-Z-H-25.html#%_idx_4192">high-level language vs.</a><br /><a href="book-Z-H-34.html#%_idx_6192">Macintosh</a><br /><a href="book-Z-H-9.html#%_idx_46">MacLisp</a><br /><a href="book-Z-H-26.html#%_idx_4374">macro</a>,
+<br /><a href="book-Z-H-35.html#__idx_6206">machine language</a><br />
+    <a href="book-Z-H-25.html#__idx_4192">high-level language vs.</a><br /><a href="book-Z-H-34.html#__idx_6192">Macintosh</a><br /><a href="book-Z-H-9.html#__idx_46">MacLisp</a><br /><a href="book-Z-H-26.html#__idx_4374">macro</a>,
 <em>see also</em> reader macro character
 <br />
 magician, <em>see</em> numerical analyst
 <br /><tt>magnitude</tt>
 <br />
-    <a href="book-Z-H-17.html#%_idx_2468">data-directed</a><br />
-    <a href="book-Z-H-17.html#%_idx_2348">polar representation</a><br />
-    <a href="book-Z-H-17.html#%_idx_2332">rectangular representation</a><br />
-    <a href="book-Z-H-17.html#%_idx_2410">with tagged data</a><br /><a href="book-Z-H-17.html#%_idx_2394"><tt>magnitude-polar</tt></a><br /><a href="book-Z-H-17.html#%_idx_2382"><tt>magnitude-rectangular</tt></a><br /><a href="book-Z-H-20.html#%_idx_2896"><tt>make-account</tt></a><br />
-    <a href="book-Z-H-21.html#%_idx_3126">in environment model</a><br />
-    <a href="book-Z-H-23.html#%_idx_3616">with serialization</a>,
-<a href="book-Z-H-23.html#%_idx_3618">[2]</a>, <a href="book-Z-H-23.html#%_idx_3620">[3]</a><br /><a href="book-Z-H-23.html#%_idx_3630"><tt>make-account-and-serializer</tt></a><br /><a href="book-Z-H-20.html#%_idx_2904"><tt>make-accumulator</tt></a><br /><a href="book-Z-H-22.html#%_idx_3412"><tt>make-agenda</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3456">[2]</a><br /><a href="book-Z-H-32.html#%_idx_5722"><tt>make-assign</tt></a><br /><a href="book-Z-H-26.html#%_idx_4338"><tt>make-begin</tt></a><br /><a href="book-Z-H-32.html#%_idx_5742"><tt>make-branch</tt></a><br /><a href="book-Z-H-14.html#%_idx_1522"><tt>make-center-percent</tt></a><br /><a href="book-Z-H-14.html#%_idx_1516"><tt>make-center-width</tt></a><br /><a href="book-Z-H-16.html#%_idx_2258"><tt>make-code-tree</tt></a><br /><a href="book-Z-H-35.html#%_idx_6332"><tt>make-compiled-procedure</tt></a><br /><a href="book-Z-H-18.html#%_idx_2546"><tt>make-complex-from-mag-ang</tt></a><br /><a href="book-Z-H-18.html#%_idx_2544"><tt>make-complex-from-real-imag</tt></a><br /><a href="book-Z-H-22.html#%_idx_3546"><tt>make-connector</tt></a><br /><a href="book-Z-H-22.html#%_idx_3172"><tt>make-cycle</tt></a><br /><a href="book-Z-H-20.html#%_idx_2984"><tt>make-decrementer</tt></a><br /><a href="book-Z-H-32.html#%_idx_5718"><tt>make-execution-procedure</tt></a><br /><a href="book-Z-H-15.html#%_idx_1914"><tt>make-frame</tt></a>,
-<a href="book-Z-H-15.html#%_idx_1944">[2]</a>, <a href="book-Z-H-26.html#%_idx_4470">[3]</a><br /><a href="book-Z-H-17.html#%_idx_2416"><tt>make-from-mag-ang</tt></a>,
-<a href="book-Z-H-17.html#%_idx_2474">[2]</a><br />
-    <a href="book-Z-H-17.html#%_idx_2492">message-passing</a><br />
-    <a href="book-Z-H-17.html#%_idx_2354">polar representation</a><br />
-    <a href="book-Z-H-17.html#%_idx_2338">rectangular representation</a><br /><a href="book-Z-H-17.html#%_idx_2400"><tt>make-from-mag-ang-polar</tt></a><br /><a href="book-Z-H-17.html#%_idx_2388"><tt>make-from-mag-ang-rectangular</tt></a><br /><a href="book-Z-H-17.html#%_idx_2414"><tt>make-from-real-imag</tt></a>,
-<a href="book-Z-H-17.html#%_idx_2472">[2]</a><br />
-    <a href="book-Z-H-17.html#%_idx_2488">message-passing</a><br />
-    <a href="book-Z-H-17.html#%_idx_2352">polar representation</a><br />
-    <a href="book-Z-H-17.html#%_idx_2336">rectangular representation</a><br /><a href="book-Z-H-17.html#%_idx_2398"><tt>make-from-real-imag-polar</tt></a><br /><a href="book-Z-H-17.html#%_idx_2386"><tt>make-from-real-imag-rectangular</tt></a><br /><a href="book-Z-H-32.html#%_idx_5748"><tt>make-goto</tt></a><br /><a href="book-Z-H-26.html#%_idx_4324"><tt>make-if</tt></a><br /><a href="book-Z-H-32.html#%_idx_5704"><tt>make-instruction</tt></a><br /><a href="book-Z-H-35.html#%_idx_6266"><tt>make-instruction-sequence</tt></a><br /><a href="book-Z-H-14.html#%_idx_1486"><tt>make-interval</tt></a>,
-<a href="book-Z-H-14.html#%_idx_1502">[2]</a><br /><a href="book-Z-H-20.html#%_idx_3028"><tt>make-joint</tt></a><br /><a href="book-Z-H-35.html#%_idx_6322"><tt>make-label</tt></a><br /><a href="book-Z-H-32.html#%_idx_5712"><tt>make-label-entry</tt></a><br /><a href="book-Z-H-26.html#%_idx_4314"><tt>make-lambda</tt></a><br /><a href="book-Z-H-16.html#%_idx_2250"><tt>make-leaf</tt></a><br /><a href="book-Z-H-16.html#%_idx_2276"><tt>make-leaf-set</tt></a><br /><a href="book-Z-H-32.html#%_idx_5626"><tt>make-machine</tt></a>,
-<a href="book-Z-H-32.html#%_idx_5638">[2]</a><br /><a href="book-Z-H-20.html#%_idx_2906"><tt>make-monitored</tt></a><br /><a href="book-Z-H-23.html#%_idx_3668"><tt>make-mutex</tt></a><br /><a href="book-Z-H-32.html#%_idx_5672"><tt>make-new-machine</tt></a><br /><a href="book-Z-H-32.html#%_idx_5790"><tt>make-operation-exp</tt></a><br /><a href="book-Z-H-32.html#%_idx_5764"><tt>make-perform</tt></a><br /><a href="book-Z-H-14.html#%_idx_1406"><tt>make-point</tt></a><br /><a href="book-Z-H-18.html#%_idx_2686"><tt>make-poly</tt></a><br /><a href="book-Z-H-18.html#%_idx_2750"><tt>make-polynomial</tt></a><br /><a href="book-Z-H-32.html#%_idx_5774"><tt>make-primitive-exp</tt></a><br /><a href="book-Z-H-26.html#%_idx_4444"><tt>make-procedure</tt></a><br /><a href="book-Z-H-16.html#%_idx_2070"><tt>make-product</tt></a>,
-<a href="book-Z-H-16.html#%_idx_2092">[2]</a><br /><a href="book-Z-H-22.html#%_idx_3232"><tt>make-queue</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3252">[2]</a><br /><a href="book-Z-H-14.html#%_idx_1300"><tt>make-rat</tt></a>, <a href="book-Z-H-14.html#%_idx_1348">[2]</a>,
-<a href="book-Z-H-14.html#%_idx_1390">[3]</a><br />
-    <a href="book-Z-H-14.html#%_idx_1416">axiom for</a><br />
-    <a href="book-Z-H-14.html#%_idx_1378">reducing to lowest terms</a><br /><a href="book-Z-H-18.html#%_idx_2532"><tt>make-rational</tt></a><br /><a href="book-Z-H-32.html#%_idx_5642"><tt>make-register</tt></a><br /><a href="book-Z-H-32.html#%_idx_5756"><tt>make-restore</tt></a><br /><a href="book-Z-H-32.html#%_idx_5754"><tt>make-save</tt></a><br /><a href="book-Z-H-18.html#%_idx_2522"><tt>make-scheme-number</tt></a><br /><a href="book-Z-H-14.html#%_idx_1398"><tt>make-segment</tt></a>,
-<a href="book-Z-H-15.html#%_idx_1954">[2]</a><br /><a href="book-Z-H-23.html#%_idx_3660"><tt>make-serializer</tt></a><br /><a href="book-Z-H-20.html#%_idx_2982"><tt>make-simplified-withdraw</tt></a>,
-<a href="book-Z-H-24.html#%_idx_4150">[2]</a><br /><a href="book-Z-H-32.html#%_idx_5650"><tt>make-stack</tt></a><br />
-    <a href="book-Z-H-32.html#%_idx_5812">with monitored stack</a><br /><a href="book-Z-H-16.html#%_idx_2068"><tt>make-sum</tt></a>, <a href="book-Z-H-16.html#%_idx_2088">[2]</a><br /><tt>make-table</tt>
-<br />
-    <a href="book-Z-H-22.html#%_idx_3296">message-passing implementation</a><br />
-    <a href="book-Z-H-22.html#%_idx_3286">one-dimensional table</a><br /><a href="book-Z-H-24.html#%_idx_3974"><tt>make-tableau</tt></a><br /><a href="book-Z-H-18.html#%_idx_2702"><tt>make-term</tt></a>, <a href="book-Z-H-18.html#%_idx_2744">[2]</a><br /><a href="book-Z-H-32.html#%_idx_5736"><tt>make-test</tt></a><br /><a href="book-Z-H-22.html#%_idx_3442"><tt>make-time-segment</tt></a><br /><a href="book-Z-H-16.html#%_idx_2158"><tt>make-tree</tt></a><br /><a href="book-Z-H-15.html#%_idx_1932"><tt>make-vect</tt></a><br /><a href="book-Z-H-22.html#%_idx_3358"><tt>make-wire</tt></a>, <a href="book-Z-H-22.html#%_idx_3396">[2]</a>,
-<a href="book-Z-H-22.html#%_idx_3434">[3]</a><br /><a href="book-Z-H-20.html#%_idx_2894"><tt>make-withdraw</tt></a><br />
-    <a href="book-Z-H-21.html#%_idx_3104">in environment model</a><br />
-    <a href="book-Z-H-21.html#%_idx_3106">using <tt>let</tt></a><br />
+    <a href="book-Z-H-17.html#__idx_2468">data-directed</a><br />
+    <a href="book-Z-H-17.html#__idx_2348">polar representation</a><br />
+    <a href="book-Z-H-17.html#__idx_2332">rectangular representation</a><br />
+    <a href="book-Z-H-17.html#__idx_2410">with tagged data</a><br /><a href="book-Z-H-17.html#__idx_2394"><tt>magnitude-polar</tt></a><br /><a href="book-Z-H-17.html#__idx_2382"><tt>magnitude-rectangular</tt></a><br /><a href="book-Z-H-20.html#__idx_2896"><tt>make-account</tt></a><br />
+    <a href="book-Z-H-21.html#__idx_3126">in environment model</a><br />
+    <a href="book-Z-H-23.html#__idx_3616">with serialization</a>,
+<a href="book-Z-H-23.html#__idx_3618">[2]</a>, <a href="book-Z-H-23.html#__idx_3620">[3]</a><br /><a href="book-Z-H-23.html#__idx_3630"><tt>make-account-and-serializer</tt></a><br /><a href="book-Z-H-20.html#__idx_2904"><tt>make-accumulator</tt></a><br /><a href="book-Z-H-22.html#__idx_3412"><tt>make-agenda</tt></a>,
+<a href="book-Z-H-22.html#__idx_3456">[2]</a><br /><a href="book-Z-H-32.html#__idx_5722"><tt>make-assign</tt></a><br /><a href="book-Z-H-26.html#__idx_4338"><tt>make-begin</tt></a><br /><a href="book-Z-H-32.html#__idx_5742"><tt>make-branch</tt></a><br /><a href="book-Z-H-14.html#__idx_1522"><tt>make-center-percent</tt></a><br /><a href="book-Z-H-14.html#__idx_1516"><tt>make-center-width</tt></a><br /><a href="book-Z-H-16.html#__idx_2258"><tt>make-code-tree</tt></a><br /><a href="book-Z-H-35.html#__idx_6332"><tt>make-compiled-procedure</tt></a><br /><a href="book-Z-H-18.html#__idx_2546"><tt>make-complex-from-mag-ang</tt></a><br /><a href="book-Z-H-18.html#__idx_2544"><tt>make-complex-from-real-imag</tt></a><br /><a href="book-Z-H-22.html#__idx_3546"><tt>make-connector</tt></a><br /><a href="book-Z-H-22.html#__idx_3172"><tt>make-cycle</tt></a><br /><a href="book-Z-H-20.html#__idx_2984"><tt>make-decrementer</tt></a><br /><a href="book-Z-H-32.html#__idx_5718"><tt>make-execution-procedure</tt></a><br /><a href="book-Z-H-15.html#__idx_1914"><tt>make-frame</tt></a>,
+<a href="book-Z-H-15.html#__idx_1944">[2]</a>, <a href="book-Z-H-26.html#__idx_4470">[3]</a><br /><a href="book-Z-H-17.html#__idx_2416"><tt>make-from-mag-ang</tt></a>,
+<a href="book-Z-H-17.html#__idx_2474">[2]</a><br />
+    <a href="book-Z-H-17.html#__idx_2492">message-passing</a><br />
+    <a href="book-Z-H-17.html#__idx_2354">polar representation</a><br />
+    <a href="book-Z-H-17.html#__idx_2338">rectangular representation</a><br /><a href="book-Z-H-17.html#__idx_2400"><tt>make-from-mag-ang-polar</tt></a><br /><a href="book-Z-H-17.html#__idx_2388"><tt>make-from-mag-ang-rectangular</tt></a><br /><a href="book-Z-H-17.html#__idx_2414"><tt>make-from-real-imag</tt></a>,
+<a href="book-Z-H-17.html#__idx_2472">[2]</a><br />
+    <a href="book-Z-H-17.html#__idx_2488">message-passing</a><br />
+    <a href="book-Z-H-17.html#__idx_2352">polar representation</a><br />
+    <a href="book-Z-H-17.html#__idx_2336">rectangular representation</a><br /><a href="book-Z-H-17.html#__idx_2398"><tt>make-from-real-imag-polar</tt></a><br /><a href="book-Z-H-17.html#__idx_2386"><tt>make-from-real-imag-rectangular</tt></a><br /><a href="book-Z-H-32.html#__idx_5748"><tt>make-goto</tt></a><br /><a href="book-Z-H-26.html#__idx_4324"><tt>make-if</tt></a><br /><a href="book-Z-H-32.html#__idx_5704"><tt>make-instruction</tt></a><br /><a href="book-Z-H-35.html#__idx_6266"><tt>make-instruction-sequence</tt></a><br /><a href="book-Z-H-14.html#__idx_1486"><tt>make-interval</tt></a>,
+<a href="book-Z-H-14.html#__idx_1502">[2]</a><br /><a href="book-Z-H-20.html#__idx_3028"><tt>make-joint</tt></a><br /><a href="book-Z-H-35.html#__idx_6322"><tt>make-label</tt></a><br /><a href="book-Z-H-32.html#__idx_5712"><tt>make-label-entry</tt></a><br /><a href="book-Z-H-26.html#__idx_4314"><tt>make-lambda</tt></a><br /><a href="book-Z-H-16.html#__idx_2250"><tt>make-leaf</tt></a><br /><a href="book-Z-H-16.html#__idx_2276"><tt>make-leaf-set</tt></a><br /><a href="book-Z-H-32.html#__idx_5626"><tt>make-machine</tt></a>,
+<a href="book-Z-H-32.html#__idx_5638">[2]</a><br /><a href="book-Z-H-20.html#__idx_2906"><tt>make-monitored</tt></a><br /><a href="book-Z-H-23.html#__idx_3668"><tt>make-mutex</tt></a><br /><a href="book-Z-H-32.html#__idx_5672"><tt>make-new-machine</tt></a><br /><a href="book-Z-H-32.html#__idx_5790"><tt>make-operation-exp</tt></a><br /><a href="book-Z-H-32.html#__idx_5764"><tt>make-perform</tt></a><br /><a href="book-Z-H-14.html#__idx_1406"><tt>make-point</tt></a><br /><a href="book-Z-H-18.html#__idx_2686"><tt>make-poly</tt></a><br /><a href="book-Z-H-18.html#__idx_2750"><tt>make-polynomial</tt></a><br /><a href="book-Z-H-32.html#__idx_5774"><tt>make-primitive-exp</tt></a><br /><a href="book-Z-H-26.html#__idx_4444"><tt>make-procedure</tt></a><br /><a href="book-Z-H-16.html#__idx_2070"><tt>make-product</tt></a>,
+<a href="book-Z-H-16.html#__idx_2092">[2]</a><br /><a href="book-Z-H-22.html#__idx_3232"><tt>make-queue</tt></a>,
+<a href="book-Z-H-22.html#__idx_3252">[2]</a><br /><a href="book-Z-H-14.html#__idx_1300"><tt>make-rat</tt></a>, <a href="book-Z-H-14.html#__idx_1348">[2]</a>,
+<a href="book-Z-H-14.html#__idx_1390">[3]</a><br />
+    <a href="book-Z-H-14.html#__idx_1416">axiom for</a><br />
+    <a href="book-Z-H-14.html#__idx_1378">reducing to lowest terms</a><br /><a href="book-Z-H-18.html#__idx_2532"><tt>make-rational</tt></a><br /><a href="book-Z-H-32.html#__idx_5642"><tt>make-register</tt></a><br /><a href="book-Z-H-32.html#__idx_5756"><tt>make-restore</tt></a><br /><a href="book-Z-H-32.html#__idx_5754"><tt>make-save</tt></a><br /><a href="book-Z-H-18.html#__idx_2522"><tt>make-scheme-number</tt></a><br /><a href="book-Z-H-14.html#__idx_1398"><tt>make-segment</tt></a>,
+<a href="book-Z-H-15.html#__idx_1954">[2]</a><br /><a href="book-Z-H-23.html#__idx_3660"><tt>make-serializer</tt></a><br /><a href="book-Z-H-20.html#__idx_2982"><tt>make-simplified-withdraw</tt></a>,
+<a href="book-Z-H-24.html#__idx_4150">[2]</a><br /><a href="book-Z-H-32.html#__idx_5650"><tt>make-stack</tt></a><br />
+    <a href="book-Z-H-32.html#__idx_5812">with monitored stack</a><br /><a href="book-Z-H-16.html#__idx_2068"><tt>make-sum</tt></a>, <a href="book-Z-H-16.html#__idx_2088">[2]</a><br /><tt>make-table</tt>
+<br />
+    <a href="book-Z-H-22.html#__idx_3296">message-passing implementation</a><br />
+    <a href="book-Z-H-22.html#__idx_3286">one-dimensional table</a><br /><a href="book-Z-H-24.html#__idx_3974"><tt>make-tableau</tt></a><br /><a href="book-Z-H-18.html#__idx_2702"><tt>make-term</tt></a>, <a href="book-Z-H-18.html#__idx_2744">[2]</a><br /><a href="book-Z-H-32.html#__idx_5736"><tt>make-test</tt></a><br /><a href="book-Z-H-22.html#__idx_3442"><tt>make-time-segment</tt></a><br /><a href="book-Z-H-16.html#__idx_2158"><tt>make-tree</tt></a><br /><a href="book-Z-H-15.html#__idx_1932"><tt>make-vect</tt></a><br /><a href="book-Z-H-22.html#__idx_3358"><tt>make-wire</tt></a>, <a href="book-Z-H-22.html#__idx_3396">[2]</a>,
+<a href="book-Z-H-22.html#__idx_3434">[3]</a><br /><a href="book-Z-H-20.html#__idx_2894"><tt>make-withdraw</tt></a><br />
+    <a href="book-Z-H-21.html#__idx_3104">in environment model</a><br />
+    <a href="book-Z-H-21.html#__idx_3106">using <tt>let</tt></a><br />
 making change, <em>see</em> counting change
-<br /><a href="book-Z-H-15.html#%_idx_1666"><tt>map</tt></a>, <a href="book-Z-H-27.html#%_idx_4782">[2]</a><br />
-    <a href="book-Z-H-15.html#%_idx_1766">as accumulation</a><br />
-    <a href="book-Z-H-15.html#%_idx_1664">with multiple arguments</a><br /><a href="book-Z-H-29.html#%_idx_5412"><tt>map-over-symbols</tt></a><br /><a href="book-Z-H-24.html#%_idx_4130"><tt>map-successive-pairs</tt></a><br />
+<br /><a href="book-Z-H-15.html#__idx_1666"><tt>map</tt></a>, <a href="book-Z-H-27.html#__idx_4782">[2]</a><br />
+    <a href="book-Z-H-15.html#__idx_1766">as accumulation</a><br />
+    <a href="book-Z-H-15.html#__idx_1664">with multiple arguments</a><br /><a href="book-Z-H-29.html#__idx_5412"><tt>map-over-symbols</tt></a><br /><a href="book-Z-H-24.html#__idx_4130"><tt>map-successive-pairs</tt></a><br />
 mapping
 <br />
-    <a href="book-Z-H-15.html#%_idx_1660">over lists</a><br />
-    <a href="book-Z-H-15.html#%_idx_1818">nested</a>, <a href="book-Z-H-24.html#%_idx_3988">[2]</a><br />
-    <a href="book-Z-H-15.html#%_idx_1734">as a transducer</a><br />
-    <a href="book-Z-H-15.html#%_idx_1706">over trees</a><br /><a href="book-Z-H-33.html#%_idx_5956">mark-sweep garbage collector</a><br />
+    <a href="book-Z-H-15.html#__idx_1660">over lists</a><br />
+    <a href="book-Z-H-15.html#__idx_1818">nested</a>, <a href="book-Z-H-24.html#__idx_3988">[2]</a><br />
+    <a href="book-Z-H-15.html#__idx_1734">as a transducer</a><br />
+    <a href="book-Z-H-15.html#__idx_1706">over trees</a><br /><a href="book-Z-H-33.html#__idx_5956">mark-sweep garbage collector</a><br />
 mathematical function, <em>see</em> function (mathematical)
 <br />
 mathematics
 <br />
-    <a href="book-Z-H-10.html#%_idx_496">computer science vs.</a>,
-<a href="book-Z-H-29.html#%_idx_5034">[2]</a><br />
-    <a href="book-Z-H-11.html#%_idx_918">engineering vs.</a><br /><a href="book-Z-H-15.html#%_idx_1796">matrix, represented as sequence</a><br /><a href="book-Z-H-15.html#%_idx_1808"><tt>matrix-*-matrix</tt></a><br /><a href="book-Z-H-15.html#%_idx_1804"><tt>matrix-*-vector</tt></a><br /><a href="book-Z-H-14.html#%_idx_1494"><tt>max</tt> (primitive procedure)</a><br /><a href="book-Z-H-28.html#%_idx_4892">McAllester, David Allen</a>,
-<a href="book-Z-H-28.html#%_idx_4902">[2]</a><br /><a href="book-Z-H-9.html#%_idx_28">McCarthy, John</a>, <a href="book-Z-H-9.html#%_idx_32">[2]</a>,
-<a href="book-Z-H-9.html#%_idx_36">[3]</a>, <a href="book-Z-H-28.html#%_idx_4824">[4]</a><br /><a href="book-Z-H-28.html#%_idx_4878">McDermott, Drew</a><br /><a href="book-Z-H-33.html#%_idx_5984">MDL</a><br /><a href="book-Z-H-10.html#%_idx_126">means of abstraction</a><br />
-    <a href="book-Z-H-10.html#%_idx_232"><tt>define</tt></a><br /><a href="book-Z-H-10.html#%_idx_122">means of combination</a>,
+    <a href="book-Z-H-10.html#__idx_496">computer science vs.</a>,
+<a href="book-Z-H-29.html#__idx_5034">[2]</a><br />
+    <a href="book-Z-H-11.html#__idx_918">engineering vs.</a><br /><a href="book-Z-H-15.html#__idx_1796">matrix, represented as sequence</a><br /><a href="book-Z-H-15.html#__idx_1808"><tt>matrix-*-matrix</tt></a><br /><a href="book-Z-H-15.html#__idx_1804"><tt>matrix-*-vector</tt></a><br /><a href="book-Z-H-14.html#__idx_1494"><tt>max</tt> (primitive procedure)</a><br /><a href="book-Z-H-28.html#__idx_4892">McAllester, David Allen</a>,
+<a href="book-Z-H-28.html#__idx_4902">[2]</a><br /><a href="book-Z-H-9.html#__idx_28">McCarthy, John</a>, <a href="book-Z-H-9.html#__idx_32">[2]</a>,
+<a href="book-Z-H-9.html#__idx_36">[3]</a>, <a href="book-Z-H-28.html#__idx_4824">[4]</a><br /><a href="book-Z-H-28.html#__idx_4878">McDermott, Drew</a><br /><a href="book-Z-H-33.html#__idx_5984">MDL</a><br /><a href="book-Z-H-10.html#__idx_126">means of abstraction</a><br />
+    <a href="book-Z-H-10.html#__idx_232"><tt>define</tt></a><br /><a href="book-Z-H-10.html#__idx_122">means of combination</a>,
 <em>see also</em> closure
-<br /><a href="book-Z-H-18.html#%_idx_2792">measure in a Euclidean ring</a><br /><a href="book-Z-H-28.html#%_idx_4936"><tt>member</tt></a><br /><a href="book-Z-H-22.html#%_idx_3324"><tt>memo-fib</tt></a><br /><a href="book-Z-H-24.html#%_idx_3804"><tt>memo-proc</tt></a><br /><a href="book-Z-H-11.html#%_idx_736">memoization</a>, <a href="book-Z-H-22.html#%_idx_3314">[2]</a><br />
-    <a href="book-Z-H-24.html#%_idx_3904">call-by-need and</a><br />
-    <a href="book-Z-H-24.html#%_idx_3802">by <tt>delay</tt></a><br />
-    <a href="book-Z-H-27.html#%_idx_4746">garbage collection and</a><br />
-    <a href="book-Z-H-27.html#%_idx_4710">of thunks</a><br /><a href="book-Z-H-22.html#%_idx_3326"><tt>memoize</tt></a><br />
+<br /><a href="book-Z-H-18.html#__idx_2792">measure in a Euclidean ring</a><br /><a href="book-Z-H-28.html#__idx_4936"><tt>member</tt></a><br /><a href="book-Z-H-22.html#__idx_3324"><tt>memo-fib</tt></a><br /><a href="book-Z-H-24.html#__idx_3804"><tt>memo-proc</tt></a><br /><a href="book-Z-H-11.html#__idx_736">memoization</a>, <a href="book-Z-H-22.html#__idx_3314">[2]</a><br />
+    <a href="book-Z-H-24.html#__idx_3904">call-by-need and</a><br />
+    <a href="book-Z-H-24.html#__idx_3802">by <tt>delay</tt></a><br />
+    <a href="book-Z-H-27.html#__idx_4746">garbage collection and</a><br />
+    <a href="book-Z-H-27.html#__idx_4710">of thunks</a><br /><a href="book-Z-H-22.html#__idx_3326"><tt>memoize</tt></a><br />
 memory
 <br />
-    <a href="book-Z-H-28.html#%_idx_4838">in 1964</a><br />
-    <a href="book-Z-H-33.html#%_idx_5830">list-structured</a><br /><a href="book-Z-H-16.html#%_idx_2030"><tt>memq</tt></a><br /><a href="book-Z-H-24.html#%_idx_3898"><tt>merge</tt></a><br /><a href="book-Z-H-24.html#%_idx_4008"><tt>merge-weighted</tt></a><br />
+    <a href="book-Z-H-28.html#__idx_4838">in 1964</a><br />
+    <a href="book-Z-H-33.html#__idx_5830">list-structured</a><br /><a href="book-Z-H-16.html#__idx_2030"><tt>memq</tt></a><br /><a href="book-Z-H-24.html#__idx_3898"><tt>merge</tt></a><br /><a href="book-Z-H-24.html#__idx_4008"><tt>merge-weighted</tt></a><br />
 merging infinite streams, <em>see</em> infinite stream(s)
-<br /><a href="book-Z-H-14.html#%_idx_1466">message passing</a>, <a href="book-Z-H-17.html#%_idx_2486">[2]</a><br />
-    <a href="book-Z-H-21.html#%_idx_3122">environment model and</a><br />
-    <a href="book-Z-H-20.html#%_idx_2900">in bank account</a><br />
-    <a href="book-Z-H-22.html#%_idx_3394">in digital-circuit simulation</a><br />
-    <a href="book-Z-H-11.html#%_idx_704">tail recursion and</a><br /><a href="book-Z-H-26.html#%_idx_4212">metacircular evaluator</a><br /><a href="book-Z-H-26.html#%_idx_4210">metacircular evaluator for Scheme</a><br />
-    <a href="book-Z-H-26.html#%_idx_4638">analyzing version</a><br />
-    <a href="book-Z-H-26.html#%_idx_4384">combinations (procedure applications)</a><br />
-    <a href="book-Z-H-35.html#%_idx_6516">compilation of</a>,
-<a href="book-Z-H-35.html#%_idx_6524">[2]</a><br />
-    <a href="book-Z-H-26.html#%_idx_4224">data abstraction in</a>,
-<a href="book-Z-H-26.html#%_idx_4234">[2]</a>, <a href="book-Z-H-26.html#%_idx_4430">[3]</a>,
-<a href="book-Z-H-26.html#%_idx_4486">[4]</a><br />
-    <a href="book-Z-H-26.html#%_idx_4390">data-directed <tt>eval</tt></a><br />
-    <a href="book-Z-H-26.html#%_idx_4352">derived expressions</a><br />
-    <a href="book-Z-H-26.html#%_idx_4516">driver loop</a><br />
-    <a href="book-Z-H-26.html#%_idx_4640">efficiency of</a><br />
-    <a href="book-Z-H-26.html#%_idx_4218">environment model of evaluation in</a><br />
-    <a href="book-Z-H-26.html#%_idx_4454">environment operations</a><br />
-    <a href="book-Z-H-26.html#%_idx_4226"><tt>eval</tt> and <tt>apply</tt></a><br />
-    <a href="book-Z-H-26.html#%_idx_4220"><tt>eval</tt>-<tt>apply</tt> cycle</a>,
-<a href="book-Z-H-26.html#%_idx_4228">[2]</a><br />
-    <a href="book-Z-H-26.html#%_idx_4232">expression representation</a>,
-<a href="book-Z-H-26.html#%_idx_4274">[2]</a><br />
-    <a href="book-Z-H-26.html#%_idx_4496">global environment</a><br />
-    <a href="book-Z-H-26.html#%_idx_4252">higher-order procedures in</a><br />
-    <a href="book-Z-H-26.html#%_idx_4260">implemented language vs. implementation language</a><br />
-    <a href="book-Z-H-26.html#%_idx_4222">job of</a><br />
-    <a href="book-Z-H-26.html#%_idx_4272">order of operand evaluation</a><br />
-    <a href="book-Z-H-26.html#%_idx_4494">primitive procedures</a><br />
-    <a href="book-Z-H-26.html#%_idx_4464">representation of environments</a><br />
-    <a href="book-Z-H-26.html#%_idx_4438">representation of procedures</a><br />
-    <a href="book-Z-H-26.html#%_idx_4432">representation of true and false</a><br />
-    <a href="book-Z-H-26.html#%_idx_4492">running</a><br />
-    <a href="book-Z-H-26.html#%_idx_4394">special forms (additional)</a>,
-<a href="book-Z-H-26.html#%_idx_4404">[2]</a>, <a href="book-Z-H-26.html#%_idx_4406">[3]</a>,
-<a href="book-Z-H-26.html#%_idx_4412">[4]</a>, <a href="book-Z-H-26.html#%_idx_4420">[5]</a>,
-<a href="book-Z-H-26.html#%_idx_4424">[6]</a><br />
-    <a href="book-Z-H-26.html#%_idx_4354">special forms as derived expressions</a><br />
-    <a href="book-Z-H-26.html#%_idx_4278">symbolic differentiation and</a><br />
-    <a href="book-Z-H-26.html#%_idx_4276">syntax of evaluated language</a>,
-<a href="book-Z-H-26.html#%_idx_4386">[2]</a>, <a href="book-Z-H-26.html#%_idx_4428">[3]</a><br />
-    <a href="book-Z-H-34.html#%_idx_6094">tail recursiveness unspecified in</a><br />
-    <a href="book-Z-H-26.html#%_idx_4500"><tt>true</tt> and <tt>false</tt></a><br /><a href="book-Z-H-25.html#%_idx_4194">metalinguistic abstraction</a><br /><a href="book-Z-H-28.html#%_idx_4874">MicroPlanner</a><br /><a href="book-Z-H-29.html#%_idx_5100">Microshaft</a><br /><a href="book-Z-H-14.html#%_idx_1408"><tt>midpoint-segment</tt></a><br /><a href="book-Z-H-11.html#%_idx_956">Miller, Gary L.</a><br /><a href="book-Z-H-35.html#%_idx_6368">Miller, James S.</a><br /><a href="book-Z-H-11.html#%_idx_954">Miller-Rabin test for primality</a><br /><a href="book-Z-H-24.html#%_idx_4110">Milner, Robin</a><br /><a href="book-Z-H-14.html#%_idx_1490"><tt>min</tt> (primitive procedure)</a><br /><a href="book-Z-H-7.html#%_idx_4">Minsky, Marvin Lee</a>, <a href="book-Z-H-33.html#%_idx_5936">[2]</a><br /><a href="book-Z-H-15.html#%_idx_1824">Miranda</a><br /><a href="book-Z-H-29.html#%_idx_5066">MIT</a><br />
-    <a href="book-Z-H-9.html#%_idx_84">Artificial Intelligence Laboratory</a><br />
-    <a href="book-Z-H-15.html#%_idx_1866">early history of</a><br />
-    <a href="book-Z-H-9.html#%_idx_54">Project MAC</a><br />
-    <a href="book-Z-H-9.html#%_idx_34">Research Laboratory of Electronics</a>,
-<a href="book-Z-H-33.html#%_idx_5940">[2]</a><br />
+<br /><a href="book-Z-H-14.html#__idx_1466">message passing</a>, <a href="book-Z-H-17.html#__idx_2486">[2]</a><br />
+    <a href="book-Z-H-21.html#__idx_3122">environment model and</a><br />
+    <a href="book-Z-H-20.html#__idx_2900">in bank account</a><br />
+    <a href="book-Z-H-22.html#__idx_3394">in digital-circuit simulation</a><br />
+    <a href="book-Z-H-11.html#__idx_704">tail recursion and</a><br /><a href="book-Z-H-26.html#__idx_4212">metacircular evaluator</a><br /><a href="book-Z-H-26.html#__idx_4210">metacircular evaluator for Scheme</a><br />
+    <a href="book-Z-H-26.html#__idx_4638">analyzing version</a><br />
+    <a href="book-Z-H-26.html#__idx_4384">combinations (procedure applications)</a><br />
+    <a href="book-Z-H-35.html#__idx_6516">compilation of</a>,
+<a href="book-Z-H-35.html#__idx_6524">[2]</a><br />
+    <a href="book-Z-H-26.html#__idx_4224">data abstraction in</a>,
+<a href="book-Z-H-26.html#__idx_4234">[2]</a>, <a href="book-Z-H-26.html#__idx_4430">[3]</a>,
+<a href="book-Z-H-26.html#__idx_4486">[4]</a><br />
+    <a href="book-Z-H-26.html#__idx_4390">data-directed <tt>eval</tt></a><br />
+    <a href="book-Z-H-26.html#__idx_4352">derived expressions</a><br />
+    <a href="book-Z-H-26.html#__idx_4516">driver loop</a><br />
+    <a href="book-Z-H-26.html#__idx_4640">efficiency of</a><br />
+    <a href="book-Z-H-26.html#__idx_4218">environment model of evaluation in</a><br />
+    <a href="book-Z-H-26.html#__idx_4454">environment operations</a><br />
+    <a href="book-Z-H-26.html#__idx_4226"><tt>eval</tt> and <tt>apply</tt></a><br />
+    <a href="book-Z-H-26.html#__idx_4220"><tt>eval</tt>-<tt>apply</tt> cycle</a>,
+<a href="book-Z-H-26.html#__idx_4228">[2]</a><br />
+    <a href="book-Z-H-26.html#__idx_4232">expression representation</a>,
+<a href="book-Z-H-26.html#__idx_4274">[2]</a><br />
+    <a href="book-Z-H-26.html#__idx_4496">global environment</a><br />
+    <a href="book-Z-H-26.html#__idx_4252">higher-order procedures in</a><br />
+    <a href="book-Z-H-26.html#__idx_4260">implemented language vs. implementation language</a><br />
+    <a href="book-Z-H-26.html#__idx_4222">job of</a><br />
+    <a href="book-Z-H-26.html#__idx_4272">order of operand evaluation</a><br />
+    <a href="book-Z-H-26.html#__idx_4494">primitive procedures</a><br />
+    <a href="book-Z-H-26.html#__idx_4464">representation of environments</a><br />
+    <a href="book-Z-H-26.html#__idx_4438">representation of procedures</a><br />
+    <a href="book-Z-H-26.html#__idx_4432">representation of true and false</a><br />
+    <a href="book-Z-H-26.html#__idx_4492">running</a><br />
+    <a href="book-Z-H-26.html#__idx_4394">special forms (additional)</a>,
+<a href="book-Z-H-26.html#__idx_4404">[2]</a>, <a href="book-Z-H-26.html#__idx_4406">[3]</a>,
+<a href="book-Z-H-26.html#__idx_4412">[4]</a>, <a href="book-Z-H-26.html#__idx_4420">[5]</a>,
+<a href="book-Z-H-26.html#__idx_4424">[6]</a><br />
+    <a href="book-Z-H-26.html#__idx_4354">special forms as derived expressions</a><br />
+    <a href="book-Z-H-26.html#__idx_4278">symbolic differentiation and</a><br />
+    <a href="book-Z-H-26.html#__idx_4276">syntax of evaluated language</a>,
+<a href="book-Z-H-26.html#__idx_4386">[2]</a>, <a href="book-Z-H-26.html#__idx_4428">[3]</a><br />
+    <a href="book-Z-H-34.html#__idx_6094">tail recursiveness unspecified in</a><br />
+    <a href="book-Z-H-26.html#__idx_4500"><tt>true</tt> and <tt>false</tt></a><br /><a href="book-Z-H-25.html#__idx_4194">metalinguistic abstraction</a><br /><a href="book-Z-H-28.html#__idx_4874">MicroPlanner</a><br /><a href="book-Z-H-29.html#__idx_5100">Microshaft</a><br /><a href="book-Z-H-14.html#__idx_1408"><tt>midpoint-segment</tt></a><br /><a href="book-Z-H-11.html#__idx_956">Miller, Gary L.</a><br /><a href="book-Z-H-35.html#__idx_6368">Miller, James S.</a><br /><a href="book-Z-H-11.html#__idx_954">Miller-Rabin test for primality</a><br /><a href="book-Z-H-24.html#__idx_4110">Milner, Robin</a><br /><a href="book-Z-H-14.html#__idx_1490"><tt>min</tt> (primitive procedure)</a><br /><a href="book-Z-H-7.html#__idx_4">Minsky, Marvin Lee</a>, <a href="book-Z-H-33.html#__idx_5936">[2]</a><br /><a href="book-Z-H-15.html#__idx_1824">Miranda</a><br /><a href="book-Z-H-29.html#__idx_5066">MIT</a><br />
+    <a href="book-Z-H-9.html#__idx_84">Artificial Intelligence Laboratory</a><br />
+    <a href="book-Z-H-15.html#__idx_1866">early history of</a><br />
+    <a href="book-Z-H-9.html#__idx_54">Project MAC</a><br />
+    <a href="book-Z-H-9.html#__idx_34">Research Laboratory of Electronics</a>,
+<a href="book-Z-H-33.html#__idx_5940">[2]</a><br />
 MIT Scheme
 <br />
-    <a href="book-Z-H-24.html#%_idx_3756">the empty stream</a><br />
-    <a href="book-Z-H-26.html#%_idx_4580"><tt>eval</tt></a><br />
-    <a href="book-Z-H-26.html#%_idx_4610">internal definitions</a><br />
-    <a href="book-Z-H-10.html#%_idx_544">numbers</a><br />
-    <a href="book-Z-H-20.html#%_idx_2964"><tt>random</tt></a><br />
-    <a href="book-Z-H-26.html#%_idx_4582"><tt>user-initial-environment</tt></a><br />
-    <a href="book-Z-H-23.html#%_idx_3678"><tt>without-interrupts</tt></a><br /><a href="book-Z-H-24.html#%_idx_4106">ML</a><br /><a href="book-Z-H-15.html#%_idx_1700">mobile</a><br />
+    <a href="book-Z-H-24.html#__idx_3756">the empty stream</a><br />
+    <a href="book-Z-H-26.html#__idx_4580"><tt>eval</tt></a><br />
+    <a href="book-Z-H-26.html#__idx_4610">internal definitions</a><br />
+    <a href="book-Z-H-10.html#__idx_544">numbers</a><br />
+    <a href="book-Z-H-20.html#__idx_2964"><tt>random</tt></a><br />
+    <a href="book-Z-H-26.html#__idx_4582"><tt>user-initial-environment</tt></a><br />
+    <a href="book-Z-H-23.html#__idx_3678"><tt>without-interrupts</tt></a><br /><a href="book-Z-H-24.html#__idx_4106">ML</a><br /><a href="book-Z-H-15.html#__idx_1700">mobile</a><br />
 modeling
 <br />
-    <a href="book-Z-H-19.html#%_idx_2826">as a design strategy</a><br />
-    <a href="book-Z-H-10.html#%_idx_336">in science and engineering</a><br /><a href="book-Z-H-34.html#%_idx_6130">models of evaluation</a><br />
+    <a href="book-Z-H-19.html#__idx_2826">as a design strategy</a><br />
+    <a href="book-Z-H-10.html#__idx_336">in science and engineering</a><br /><a href="book-Z-H-34.html#__idx_6130">models of evaluation</a><br />
 modified registers, <em>see</em> instruction sequence
-<br /><a href="book-Z-H-35.html#%_idx_6388"><tt>modifies-register?</tt></a><br /><a href="book-Z-H-15.html#%_idx_1756">modularity</a>, <a href="book-Z-H-19.html#%_idx_2824">[2]</a><br />
-    <a href="book-Z-H-24.html#%_idx_4184">along object boundaries</a><br />
-    <a href="book-Z-H-24.html#%_idx_4116">functional programs vs. objects</a><br />
-    <a href="book-Z-H-20.html#%_idx_2892">hiding principle</a><br />
-    <a href="book-Z-H-24.html#%_idx_3942">streams and</a><br />
-    <a href="book-Z-H-17.html#%_idx_2428">through dispatching on type</a><br />
-    <a href="book-Z-H-24.html#%_idx_4134">through infinite streams</a><br />
-    <a href="book-Z-H-20.html#%_idx_2920">through modeling with objects</a><br /><a href="book-Z-H-11.html#%_idx_892">modulo <em>n</em></a><br /><a href="book-Z-H-29.html#%_idx_5250"><em>modus ponens</em></a><br />
+<br /><a href="book-Z-H-35.html#__idx_6388"><tt>modifies-register?</tt></a><br /><a href="book-Z-H-15.html#__idx_1756">modularity</a>, <a href="book-Z-H-19.html#__idx_2824">[2]</a><br />
+    <a href="book-Z-H-24.html#__idx_4184">along object boundaries</a><br />
+    <a href="book-Z-H-24.html#__idx_4116">functional programs vs. objects</a><br />
+    <a href="book-Z-H-20.html#__idx_2892">hiding principle</a><br />
+    <a href="book-Z-H-24.html#__idx_3942">streams and</a><br />
+    <a href="book-Z-H-17.html#__idx_2428">through dispatching on type</a><br />
+    <a href="book-Z-H-24.html#__idx_4134">through infinite streams</a><br />
+    <a href="book-Z-H-20.html#__idx_2920">through modeling with objects</a><br /><a href="book-Z-H-11.html#__idx_892">modulo <em>n</em></a><br /><a href="book-Z-H-29.html#__idx_5250"><em>modus ponens</em></a><br />
 money, changing, <em>see</em> counting change
-<br /><a href="book-Z-H-20.html#%_idx_2908">monitored procedure</a><br /><a href="book-Z-H-20.html#%_idx_2956">Monte Carlo integration</a><br />
-    <a href="book-Z-H-24.html#%_idx_4138">stream formulation</a><br /><a href="book-Z-H-20.html#%_idx_2936">Monte Carlo simulation</a><br />
-    <a href="book-Z-H-24.html#%_idx_4122">stream formulation</a><br /><a href="book-Z-H-20.html#%_idx_2952"><tt>monte-carlo</tt></a><br />
-    <a href="book-Z-H-24.html#%_idx_4132">infinite stream</a><br /><a href="book-Z-H-9.html#%_idx_50">Moon, David A.</a>, <a href="book-Z-H-33.html#%_idx_5954">[2]</a><br />
+<br /><a href="book-Z-H-20.html#__idx_2908">monitored procedure</a><br /><a href="book-Z-H-20.html#__idx_2956">Monte Carlo integration</a><br />
+    <a href="book-Z-H-24.html#__idx_4138">stream formulation</a><br /><a href="book-Z-H-20.html#__idx_2936">Monte Carlo simulation</a><br />
+    <a href="book-Z-H-24.html#__idx_4122">stream formulation</a><br /><a href="book-Z-H-20.html#__idx_2952"><tt>monte-carlo</tt></a><br />
+    <a href="book-Z-H-24.html#__idx_4132">infinite stream</a><br /><a href="book-Z-H-9.html#__idx_50">Moon, David A.</a>, <a href="book-Z-H-33.html#__idx_5954">[2]</a><br />
 morning star, <em>see</em> evening star
-<br /><a href="book-Z-H-20.html#%_idx_3008">Morris, J. H.</a><br /><a href="book-Z-H-16.html#%_idx_2228">Morse code</a><br /><a href="book-Z-H-29.html#%_idx_5262">Mouse, Minnie and Mickey</a><br /><a href="book-Z-H-18.html#%_idx_2508"><tt>mul</tt> (generic)</a><br />
-    <a href="book-Z-H-18.html#%_idx_2716">used for polynomial coefficients</a><br /><a href="book-Z-H-17.html#%_idx_2316"><tt>mul-complex</tt></a><br /><a href="book-Z-H-14.html#%_idx_1498"><tt>mul-interval</tt></a><br />
-    <a href="book-Z-H-14.html#%_idx_1514">more efficient version</a><br /><a href="book-Z-H-18.html#%_idx_2676"><tt>mul-poly</tt></a><br /><a href="book-Z-H-14.html#%_idx_1312"><tt>mul-rat</tt></a><br /><a href="book-Z-H-24.html#%_idx_3932"><tt>mul-series</tt></a><br /><a href="book-Z-H-24.html#%_idx_3886"><tt>mul-streams</tt></a><br /><a href="book-Z-H-18.html#%_idx_2712"><tt>mul-terms</tt></a><br /><a href="book-Z-H-33.html#%_idx_5946">Multics time-sharing system</a><br /><a href="book-Z-H-28.html#%_idx_4938"><tt>multiple-dwelling</tt></a><br /><a href="book-Z-H-16.html#%_idx_2082"><tt>multiplicand</tt></a><br /><a href="book-Z-H-11.html#%_idx_822">multiplication by Russian peasant method</a><br /><tt>multiplier</tt>
+<br /><a href="book-Z-H-20.html#__idx_3008">Morris, J. H.</a><br /><a href="book-Z-H-16.html#__idx_2228">Morse code</a><br /><a href="book-Z-H-29.html#__idx_5262">Mouse, Minnie and Mickey</a><br /><a href="book-Z-H-18.html#__idx_2508"><tt>mul</tt> (generic)</a><br />
+    <a href="book-Z-H-18.html#__idx_2716">used for polynomial coefficients</a><br /><a href="book-Z-H-17.html#__idx_2316"><tt>mul-complex</tt></a><br /><a href="book-Z-H-14.html#__idx_1498"><tt>mul-interval</tt></a><br />
+    <a href="book-Z-H-14.html#__idx_1514">more efficient version</a><br /><a href="book-Z-H-18.html#__idx_2676"><tt>mul-poly</tt></a><br /><a href="book-Z-H-14.html#__idx_1312"><tt>mul-rat</tt></a><br /><a href="book-Z-H-24.html#__idx_3932"><tt>mul-series</tt></a><br /><a href="book-Z-H-24.html#__idx_3886"><tt>mul-streams</tt></a><br /><a href="book-Z-H-18.html#__idx_2712"><tt>mul-terms</tt></a><br /><a href="book-Z-H-33.html#__idx_5946">Multics time-sharing system</a><br /><a href="book-Z-H-28.html#__idx_4938"><tt>multiple-dwelling</tt></a><br /><a href="book-Z-H-16.html#__idx_2082"><tt>multiplicand</tt></a><br /><a href="book-Z-H-11.html#__idx_822">multiplication by Russian peasant method</a><br /><tt>multiplier</tt>
 <br />
-    <a href="book-Z-H-22.html#%_idx_3538">primitive constraint</a><br />
-    <a href="book-Z-H-16.html#%_idx_2080">selector</a><br /><a href="book-Z-H-15.html#%_idx_1790">Munro, Ian</a><br /><a href="book-Z-H-22.html#%_idx_3128">mutable data objects</a>,
+    <a href="book-Z-H-22.html#__idx_3538">primitive constraint</a><br />
+    <a href="book-Z-H-16.html#__idx_2080">selector</a><br /><a href="book-Z-H-15.html#__idx_1790">Munro, Ian</a><br /><a href="book-Z-H-22.html#__idx_3128">mutable data objects</a>,
 <em>see also</em> queue; table
 <br />
-    <a href="book-Z-H-22.html#%_idx_3198">implemented with assignment</a><br />
-    <a href="book-Z-H-22.html#%_idx_3132">list structure</a><br />
-    <a href="book-Z-H-22.html#%_idx_3136">pairs</a><br />
-    <a href="book-Z-H-22.html#%_idx_3196">procedural representation of</a><br />
-    <a href="book-Z-H-22.html#%_idx_3190">shared data</a><br /><a href="book-Z-H-22.html#%_idx_3130">mutator</a><br /><a href="book-Z-H-23.html#%_idx_3640">mutex</a><br /><a href="book-Z-H-23.html#%_idx_3646">mutual exclusion</a><br /><a href="book-Z-H-22.html#%_idx_3174"><tt>mystery</tt></a></p><p>
+    <a href="book-Z-H-22.html#__idx_3198">implemented with assignment</a><br />
+    <a href="book-Z-H-22.html#__idx_3132">list structure</a><br />
+    <a href="book-Z-H-22.html#__idx_3136">pairs</a><br />
+    <a href="book-Z-H-22.html#__idx_3196">procedural representation of</a><br />
+    <a href="book-Z-H-22.html#__idx_3190">shared data</a><br /><a href="book-Z-H-22.html#__idx_3130">mutator</a><br /><a href="book-Z-H-23.html#__idx_3640">mutex</a><br /><a href="book-Z-H-23.html#__idx_3646">mutual exclusion</a><br /><a href="book-Z-H-22.html#__idx_3174"><tt>mystery</tt></a></p><p>
 
 </p><p></p><p>
 
 <br />
 name, <em>see also</em> local name; variable; local variable
 <br />
-    <a href="book-Z-H-20.html#%_idx_2888">encapsulated</a><br />
-    <a href="book-Z-H-10.html#%_idx_582">of a formal parameter</a><br />
-    <a href="book-Z-H-10.html#%_idx_310">of a procedure</a><br /><a href="book-Z-H-26.html#%_idx_4416">named <tt>let</tt> (special form)</a><br />
+    <a href="book-Z-H-20.html#__idx_2888">encapsulated</a><br />
+    <a href="book-Z-H-10.html#__idx_582">of a formal parameter</a><br />
+    <a href="book-Z-H-10.html#__idx_310">of a procedure</a><br /><a href="book-Z-H-26.html#__idx_4416">named <tt>let</tt> (special form)</a><br />
 naming
 <br />
-    <a href="book-Z-H-10.html#%_idx_216">of computational objects</a><br />
-    <a href="book-Z-H-10.html#%_idx_300">of procedures</a><br />
+    <a href="book-Z-H-10.html#__idx_216">of computational objects</a><br />
+    <a href="book-Z-H-10.html#__idx_300">of procedures</a><br />
 naming conventions
 <br />
-    <a href="book-Z-H-20.html#%_idx_2868"><tt>!</tt> for assignment and mutation</a><br />
-    <a href="book-Z-H-10.html#%_idx_520"><tt>?</tt> for predicates</a><br /><a href="book-Z-H-35.html#%_idx_6204">native language of machine</a><br />
+    <a href="book-Z-H-20.html#__idx_2868"><tt>!</tt> for assignment and mutation</a><br />
+    <a href="book-Z-H-10.html#__idx_520"><tt>?</tt> for predicates</a><br /><a href="book-Z-H-35.html#__idx_6204">native language of machine</a><br />
 natural language
 <br />
     parsing, <em>see</em> parsing natural language
 <br />
-    <a href="book-Z-H-16.html#%_idx_1994">quotation in</a><br />
+    <a href="book-Z-H-16.html#__idx_1994">quotation in</a><br />
 needed registers, <em>see</em> instruction sequence
-<br /><a href="book-Z-H-35.html#%_idx_6386"><tt>needs-register?</tt></a><br /><a href="book-Z-H-29.html#%_idx_5328"><tt>negate</tt></a><br /><a href="book-Z-H-15.html#%_idx_1584">nested applications of <tt>car</tt> and <tt>cdr</tt></a><br /><a href="book-Z-H-10.html#%_idx_196">nested combinations</a><br />
+<br /><a href="book-Z-H-35.html#__idx_6386"><tt>needs-register?</tt></a><br /><a href="book-Z-H-29.html#__idx_5328"><tt>negate</tt></a><br /><a href="book-Z-H-15.html#__idx_1584">nested applications of <tt>car</tt> and <tt>cdr</tt></a><br /><a href="book-Z-H-10.html#__idx_196">nested combinations</a><br />
 nested definitions, <em>see</em> internal definition
 <br />
 nested mappings, <em>see</em> mapping
-<br /><a href="book-Z-H-33.html#%_idx_5992"><tt>new</tt> register</a><br /><a href="book-Z-H-33.html#%_idx_5972"><tt>new-cars</tt> register</a><br /><a href="book-Z-H-33.html#%_idx_5974"><tt>new-cdrs</tt> register</a><br /><a href="book-Z-H-20.html#%_idx_2884"><tt>new-withdraw</tt></a><br /><a href="book-Z-H-11.html#%_idx_938"><tt>newline</tt> (primitive procedure)</a>,
-<a href="book-Z-H-14.html#%_idx_1362">[2]</a><br />
+<br /><a href="book-Z-H-33.html#__idx_5992"><tt>new</tt> register</a><br /><a href="book-Z-H-33.html#__idx_5972"><tt>new-cars</tt> register</a><br /><a href="book-Z-H-33.html#__idx_5974"><tt>new-cdrs</tt> register</a><br /><a href="book-Z-H-20.html#__idx_2884"><tt>new-withdraw</tt></a><br /><a href="book-Z-H-11.html#__idx_938"><tt>newline</tt> (primitive procedure)</a>,
+<a href="book-Z-H-14.html#__idx_1362">[2]</a><br />
 Newton's method
 <br />
-    <a href="book-Z-H-10.html#%_idx_562">for cube roots</a><br />
-    <a href="book-Z-H-12.html#%_idx_1178">for differentiable functions</a><br />
-    <a href="book-Z-H-12.html#%_idx_1182">half-interval method vs.</a><br />
-    <a href="book-Z-H-10.html#%_idx_510">for square roots</a>,
-<a href="book-Z-H-12.html#%_idx_1200">[2]</a>, <a href="book-Z-H-12.html#%_idx_1212">[3]</a><br /><a href="book-Z-H-12.html#%_idx_1196"><tt>newton-transform</tt></a><br /><a href="book-Z-H-12.html#%_idx_1198"><tt>newtons-method</tt></a><br /><a href="book-Z-H-35.html#%_idx_6252"><tt>next</tt> (linkage descriptor)</a><br /><a href="book-Z-H-29.html#%_idx_5164"><tt>next-to</tt> (rules)</a><br /><tt>nil</tt>
-<br />
-    <a href="book-Z-H-16.html#%_idx_2020">dispensing with</a><br />
-    <a href="book-Z-H-15.html#%_idx_1596">as empty list</a><br />
-    <a href="book-Z-H-15.html#%_idx_1562">as end-of-list marker</a><br />
-    <a href="book-Z-H-15.html#%_idx_1598">as ordinary variable in Scheme</a><br /><a href="book-Z-H-34.html#%_idx_6098"><tt>no-more-exps?</tt></a><br /><a href="book-Z-H-26.html#%_idx_4346"><tt>no-operands?</tt></a><br /><a href="book-Z-H-10.html#%_idx_256">node of a tree</a><br /><a href="book-Z-H-26.html#%_idx_4594">non-computable</a><br /><a href="book-Z-H-27.html#%_idx_4686">non-strict</a><br /><a href="book-Z-H-23.html#%_idx_3604">nondeterminism, in behavior of concurrent programs</a>, <a href="book-Z-H-24.html#%_idx_4180">[2]</a><br /><a href="book-Z-H-28.html#%_idx_4836">nondeterministic choice point</a><br /><a href="book-Z-H-28.html#%_idx_4806">nondeterministic computing</a><br /><a href="book-Z-H-28.html#%_idx_4978">nondeterministic evaluator</a><br />
-    <a href="book-Z-H-28.html#%_idx_4970">order of operand evaluation</a><br /><a href="book-Z-H-28.html#%_idx_4810">nondeterministic programming vs. Scheme programming</a>, <a href="book-Z-H-28.html#%_idx_4940">[2]</a>,
-<a href="book-Z-H-28.html#%_idx_4950">[3]</a>, <a href="book-Z-H-29.html#%_idx_5442">[4]</a><br />
+    <a href="book-Z-H-10.html#__idx_562">for cube roots</a><br />
+    <a href="book-Z-H-12.html#__idx_1178">for differentiable functions</a><br />
+    <a href="book-Z-H-12.html#__idx_1182">half-interval method vs.</a><br />
+    <a href="book-Z-H-10.html#__idx_510">for square roots</a>,
+<a href="book-Z-H-12.html#__idx_1200">[2]</a>, <a href="book-Z-H-12.html#__idx_1212">[3]</a><br /><a href="book-Z-H-12.html#__idx_1196"><tt>newton-transform</tt></a><br /><a href="book-Z-H-12.html#__idx_1198"><tt>newtons-method</tt></a><br /><a href="book-Z-H-35.html#__idx_6252"><tt>next</tt> (linkage descriptor)</a><br /><a href="book-Z-H-29.html#__idx_5164"><tt>next-to</tt> (rules)</a><br /><tt>nil</tt>
+<br />
+    <a href="book-Z-H-16.html#__idx_2020">dispensing with</a><br />
+    <a href="book-Z-H-15.html#__idx_1596">as empty list</a><br />
+    <a href="book-Z-H-15.html#__idx_1562">as end-of-list marker</a><br />
+    <a href="book-Z-H-15.html#__idx_1598">as ordinary variable in Scheme</a><br /><a href="book-Z-H-34.html#__idx_6098"><tt>no-more-exps?</tt></a><br /><a href="book-Z-H-26.html#__idx_4346"><tt>no-operands?</tt></a><br /><a href="book-Z-H-10.html#__idx_256">node of a tree</a><br /><a href="book-Z-H-26.html#__idx_4594">non-computable</a><br /><a href="book-Z-H-27.html#__idx_4686">non-strict</a><br /><a href="book-Z-H-23.html#__idx_3604">nondeterminism, in behavior of concurrent programs</a>, <a href="book-Z-H-24.html#__idx_4180">[2]</a><br /><a href="book-Z-H-28.html#__idx_4836">nondeterministic choice point</a><br /><a href="book-Z-H-28.html#__idx_4806">nondeterministic computing</a><br /><a href="book-Z-H-28.html#__idx_4978">nondeterministic evaluator</a><br />
+    <a href="book-Z-H-28.html#__idx_4970">order of operand evaluation</a><br /><a href="book-Z-H-28.html#__idx_4810">nondeterministic programming vs. Scheme programming</a>, <a href="book-Z-H-28.html#__idx_4940">[2]</a>,
+<a href="book-Z-H-28.html#__idx_4950">[3]</a>, <a href="book-Z-H-29.html#__idx_5442">[4]</a><br />
 nondeterministic programs
 <br />
-    <a href="book-Z-H-28.html#%_idx_4930">logic puzzles</a><br />
-    <a href="book-Z-H-28.html#%_idx_4812">pairs with prime sums</a><br />
-    <a href="book-Z-H-28.html#%_idx_4954">parsing natural language</a><br />
-    <a href="book-Z-H-28.html#%_idx_4914">Pythagorean triples</a>,
-<a href="book-Z-H-28.html#%_idx_4918">[2]</a>, <a href="book-Z-H-28.html#%_idx_4922">[3]</a><br /><a href="book-Z-H-10.html#%_idx_340">normal-order evaluation</a><br />
-    <a href="book-Z-H-10.html#%_idx_480">applicative order vs.</a>,
-<a href="book-Z-H-11.html#%_idx_852">[2]</a>, <a href="book-Z-H-27.html#%_idx_4680">[3]</a><br />
-    <a href="book-Z-H-24.html#%_idx_4092">delayed evaluation and</a><br />
-    <a href="book-Z-H-34.html#%_idx_6126">in explicit-control evaluator</a><br />
-    <a href="book-Z-H-10.html#%_idx_484">of <tt>if</tt></a><br />
+    <a href="book-Z-H-28.html#__idx_4930">logic puzzles</a><br />
+    <a href="book-Z-H-28.html#__idx_4812">pairs with prime sums</a><br />
+    <a href="book-Z-H-28.html#__idx_4954">parsing natural language</a><br />
+    <a href="book-Z-H-28.html#__idx_4914">Pythagorean triples</a>,
+<a href="book-Z-H-28.html#__idx_4918">[2]</a>, <a href="book-Z-H-28.html#__idx_4922">[3]</a><br /><a href="book-Z-H-10.html#__idx_340">normal-order evaluation</a><br />
+    <a href="book-Z-H-10.html#__idx_480">applicative order vs.</a>,
+<a href="book-Z-H-11.html#__idx_852">[2]</a>, <a href="book-Z-H-27.html#__idx_4680">[3]</a><br />
+    <a href="book-Z-H-24.html#__idx_4092">delayed evaluation and</a><br />
+    <a href="book-Z-H-34.html#__idx_6126">in explicit-control evaluator</a><br />
+    <a href="book-Z-H-10.html#__idx_484">of <tt>if</tt></a><br />
 normal-order evaluator, <em>see</em> lazy evaluator
-<br /><a href="book-Z-H-10.html#%_idx_462"><tt>not</tt> (primitive procedure)</a><br /><a href="book-Z-H-29.html#%_idx_5130"><tt>not</tt> (query language)</a>,
-<a href="book-Z-H-29.html#%_idx_5268">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5204">evaluation of</a>,
-<a href="book-Z-H-29.html#%_idx_5326">[2]</a>, <a href="book-Z-H-29.html#%_idx_5438">[3]</a><br />
+<br /><a href="book-Z-H-10.html#__idx_462"><tt>not</tt> (primitive procedure)</a><br /><a href="book-Z-H-29.html#__idx_5130"><tt>not</tt> (query language)</a>,
+<a href="book-Z-H-29.html#__idx_5268">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5204">evaluation of</a>,
+<a href="book-Z-H-29.html#__idx_5326">[2]</a>, <a href="book-Z-H-29.html#__idx_5438">[3]</a><br />
 notation in this book
 <br />
-    <a href="book-Z-H-10.html#%_idx_314">italic symbols in expression syntax</a><br />
-    <a href="book-Z-H-10.html#%_idx_152">slanted characters for interpreter response</a><br /><a href="book-Z-H-28.html#%_idx_4956"><tt>nouns</tt></a><br /><a href="book-Z-H-12.html#%_idx_1242"><em>n</em>th root, as fixed point</a><br /><a href="book-Z-H-15.html#%_idx_1614"><tt>null?</tt> (primitive procedure)</a><br />
-    <a href="book-Z-H-33.html#%_idx_5912">implemented with typed pointers</a><br /><a href="book-Z-H-11.html#%_idx_874">number theory</a><br />
+    <a href="book-Z-H-10.html#__idx_314">italic symbols in expression syntax</a><br />
+    <a href="book-Z-H-10.html#__idx_152">slanted characters for interpreter response</a><br /><a href="book-Z-H-28.html#__idx_4956"><tt>nouns</tt></a><br /><a href="book-Z-H-12.html#__idx_1242"><em>n</em>th root, as fixed point</a><br /><a href="book-Z-H-15.html#__idx_1614"><tt>null?</tt> (primitive procedure)</a><br />
+    <a href="book-Z-H-33.html#__idx_5912">implemented with typed pointers</a><br /><a href="book-Z-H-11.html#__idx_874">number theory</a><br />
 number(s)
 <br />
-    <a href="book-Z-H-10.html#%_idx_404">comparison of</a><br />
-    <a href="book-Z-H-10.html#%_idx_540">decimal point in</a><br />
-    <a href="book-Z-H-10.html#%_idx_406">equality of</a>, <a href="book-Z-H-16.html#%_idx_2038">[2]</a>,
-<a href="book-Z-H-33.html#%_idx_5878">[3]</a><br />
-    <a href="book-Z-H-18.html#%_idx_2512">in generic arithmetic system</a><br />
-    <a href="book-Z-H-10.html#%_idx_548">implementation dependencies</a><br />
-    <a href="book-Z-H-10.html#%_idx_140">integer vs. real number</a><br />
-    <a href="book-Z-H-10.html#%_idx_538">integer, exact</a><br />
-    <a href="book-Z-H-10.html#%_idx_148">in Lisp</a><br />
-    <a href="book-Z-H-10.html#%_idx_536">rational number</a><br /><a href="book-Z-H-16.html#%_idx_2052"><tt>number?</tt> (primitive procedure)</a><br />
-    <a href="book-Z-H-18.html#%_idx_2554">data types and</a><br />
-    <a href="book-Z-H-33.html#%_idx_5916">implemented with typed pointers</a><br /><a href="book-Z-H-14.html#%_idx_1302"><tt>numer</tt></a>, <a href="book-Z-H-14.html#%_idx_1350">[2]</a><br />
-    <a href="book-Z-H-14.html#%_idx_1418">axiom for</a><br />
-    <a href="book-Z-H-14.html#%_idx_1392">reducing to lowest terms</a><br /><a href="book-Z-H-10.html#%_idx_142">numerical analysis</a><br /><a href="book-Z-H-12.html#%_idx_1086">numerical analyst</a><br /><a href="book-Z-H-10.html#%_idx_132">numerical data</a></p><p>
+    <a href="book-Z-H-10.html#__idx_404">comparison of</a><br />
+    <a href="book-Z-H-10.html#__idx_540">decimal point in</a><br />
+    <a href="book-Z-H-10.html#__idx_406">equality of</a>, <a href="book-Z-H-16.html#__idx_2038">[2]</a>,
+<a href="book-Z-H-33.html#__idx_5878">[3]</a><br />
+    <a href="book-Z-H-18.html#__idx_2512">in generic arithmetic system</a><br />
+    <a href="book-Z-H-10.html#__idx_548">implementation dependencies</a><br />
+    <a href="book-Z-H-10.html#__idx_140">integer vs. real number</a><br />
+    <a href="book-Z-H-10.html#__idx_538">integer, exact</a><br />
+    <a href="book-Z-H-10.html#__idx_148">in Lisp</a><br />
+    <a href="book-Z-H-10.html#__idx_536">rational number</a><br /><a href="book-Z-H-16.html#__idx_2052"><tt>number?</tt> (primitive procedure)</a><br />
+    <a href="book-Z-H-18.html#__idx_2554">data types and</a><br />
+    <a href="book-Z-H-33.html#__idx_5916">implemented with typed pointers</a><br /><a href="book-Z-H-14.html#__idx_1302"><tt>numer</tt></a>, <a href="book-Z-H-14.html#__idx_1350">[2]</a><br />
+    <a href="book-Z-H-14.html#__idx_1418">axiom for</a><br />
+    <a href="book-Z-H-14.html#__idx_1392">reducing to lowest terms</a><br /><a href="book-Z-H-10.html#__idx_142">numerical analysis</a><br /><a href="book-Z-H-12.html#__idx_1086">numerical analyst</a><br /><a href="book-Z-H-10.html#__idx_132">numerical data</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-33.html#%_idx_5886">obarray</a><br /><a href="book-Z-H-35.html#%_idx_6218">object program</a><br /><a href="book-Z-H-19.html#%_idx_2828">object(s)</a><br />
-    <a href="book-Z-H-20.html#%_idx_2918">benefits of modeling with</a><br />
-    <a href="book-Z-H-20.html#%_idx_2850">with time-varying state</a><br /><a href="book-Z-H-18.html#%_idx_2622">object-oriented programming languages</a><br /><a href="book-Z-H-33.html#%_idx_5990"><tt>old</tt> register</a><br /><a href="book-Z-H-33.html#%_idx_5994"><tt>oldcr</tt> register</a><br /><a href="book-Z-H-24.html#%_idx_3862"><tt>ones</tt> (infinite stream)</a><br />
-    <a href="book-Z-H-27.html#%_idx_4788">lazy-list version</a><br /><a href="book-Z-H-31.html#%_idx_5522"><tt>op</tt> (in register machine)</a><br />
-    <a href="book-Z-H-32.html#%_idx_5788">simulating</a><br /><a href="book-Z-H-35.html#%_idx_6424">open coding of primitives</a>,
-<a href="book-Z-H-35.html#%_idx_6460">[2]</a><br /><a href="book-Z-H-26.html#%_idx_4344"><tt>operands</tt></a><br /><a href="book-Z-H-10.html#%_idx_184">operands of a combination</a><br />
+<br /><a href="book-Z-H-33.html#__idx_5886">obarray</a><br /><a href="book-Z-H-35.html#__idx_6218">object program</a><br /><a href="book-Z-H-19.html#__idx_2828">object(s)</a><br />
+    <a href="book-Z-H-20.html#__idx_2918">benefits of modeling with</a><br />
+    <a href="book-Z-H-20.html#__idx_2850">with time-varying state</a><br /><a href="book-Z-H-18.html#__idx_2622">object-oriented programming languages</a><br /><a href="book-Z-H-33.html#__idx_5990"><tt>old</tt> register</a><br /><a href="book-Z-H-33.html#__idx_5994"><tt>oldcr</tt> register</a><br /><a href="book-Z-H-24.html#__idx_3862"><tt>ones</tt> (infinite stream)</a><br />
+    <a href="book-Z-H-27.html#__idx_4788">lazy-list version</a><br /><a href="book-Z-H-31.html#__idx_5522"><tt>op</tt> (in register machine)</a><br />
+    <a href="book-Z-H-32.html#__idx_5788">simulating</a><br /><a href="book-Z-H-35.html#__idx_6424">open coding of primitives</a>,
+<a href="book-Z-H-35.html#__idx_6460">[2]</a><br /><a href="book-Z-H-26.html#__idx_4344"><tt>operands</tt></a><br /><a href="book-Z-H-10.html#__idx_184">operands of a combination</a><br />
 operation
 <br />
-    <a href="book-Z-H-18.html#%_idx_2572">cross-type</a><br />
-    <a href="book-Z-H-13.html#%_idx_1276">generic</a><br />
-    <a href="book-Z-H-31.html#%_idx_5472">in register machine</a><br /><a href="book-Z-H-17.html#%_idx_2436">operation-and-type table</a><br />
-    <a href="book-Z-H-20.html#%_idx_2856">assignment needed for</a><br />
-    <a href="book-Z-H-22.html#%_idx_3298">implementing</a><br /><a href="book-Z-H-32.html#%_idx_5792"><tt>operation-exp</tt></a><br /><a href="book-Z-H-32.html#%_idx_5794"><tt>operation-exp-op</tt></a><br /><a href="book-Z-H-32.html#%_idx_5796"><tt>operation-exp-operands</tt></a><br /><a href="book-Z-H-26.html#%_idx_4342"><tt>operator</tt></a><br /><a href="book-Z-H-10.html#%_idx_182">operator of a combination</a><br />
-    <a href="book-Z-H-12.html#%_idx_1166">combination as</a><br />
-    <a href="book-Z-H-10.html#%_idx_478">compound expression as</a><br />
-    <a href="book-Z-H-12.html#%_idx_1052"><tt>lambda</tt> expression as</a><br />
+    <a href="book-Z-H-18.html#__idx_2572">cross-type</a><br />
+    <a href="book-Z-H-13.html#__idx_1276">generic</a><br />
+    <a href="book-Z-H-31.html#__idx_5472">in register machine</a><br /><a href="book-Z-H-17.html#__idx_2436">operation-and-type table</a><br />
+    <a href="book-Z-H-20.html#__idx_2856">assignment needed for</a><br />
+    <a href="book-Z-H-22.html#__idx_3298">implementing</a><br /><a href="book-Z-H-32.html#__idx_5792"><tt>operation-exp</tt></a><br /><a href="book-Z-H-32.html#__idx_5794"><tt>operation-exp-op</tt></a><br /><a href="book-Z-H-32.html#__idx_5796"><tt>operation-exp-operands</tt></a><br /><a href="book-Z-H-26.html#__idx_4342"><tt>operator</tt></a><br /><a href="book-Z-H-10.html#__idx_182">operator of a combination</a><br />
+    <a href="book-Z-H-12.html#__idx_1166">combination as</a><br />
+    <a href="book-Z-H-10.html#__idx_478">compound expression as</a><br />
+    <a href="book-Z-H-12.html#__idx_1052"><tt>lambda</tt> expression as</a><br />
 optimality
 <br />
-    <a href="book-Z-H-15.html#%_idx_1782">of Horner's rule</a><br />
-    <a href="book-Z-H-16.html#%_idx_2244">of Huffman code</a><br /><a href="book-Z-H-29.html#%_idx_5128"><tt>or</tt> (query language)</a><br />
-    <a href="book-Z-H-29.html#%_idx_5200">evaluation of</a>,
-<a href="book-Z-H-29.html#%_idx_5322">[2]</a><br /><a href="book-Z-H-10.html#%_idx_454"><tt>or</tt> (special form)</a><br />
-    <a href="book-Z-H-10.html#%_idx_458">evaluation of</a><br />
-    <a href="book-Z-H-10.html#%_idx_468">why a special form</a><br />
-    <a href="book-Z-H-26.html#%_idx_4398">with no subexpressions</a><br /><a href="book-Z-H-22.html#%_idx_3350">or-gate</a><br />
-    <a href="book-Z-H-22.html#%_idx_3384"><tt>or-gate</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3386">[2]</a><br /><a href="book-Z-H-18.html#%_idx_2704"><tt>order</tt></a>, <a href="book-Z-H-18.html#%_idx_2746">[2]</a><br /><a href="book-Z-H-11.html#%_idx_760">order notation</a><br />
+    <a href="book-Z-H-15.html#__idx_1782">of Horner's rule</a><br />
+    <a href="book-Z-H-16.html#__idx_2244">of Huffman code</a><br /><a href="book-Z-H-29.html#__idx_5128"><tt>or</tt> (query language)</a><br />
+    <a href="book-Z-H-29.html#__idx_5200">evaluation of</a>,
+<a href="book-Z-H-29.html#__idx_5322">[2]</a><br /><a href="book-Z-H-10.html#__idx_454"><tt>or</tt> (special form)</a><br />
+    <a href="book-Z-H-10.html#__idx_458">evaluation of</a><br />
+    <a href="book-Z-H-10.html#__idx_468">why a special form</a><br />
+    <a href="book-Z-H-26.html#__idx_4398">with no subexpressions</a><br /><a href="book-Z-H-22.html#__idx_3350">or-gate</a><br />
+    <a href="book-Z-H-22.html#__idx_3384"><tt>or-gate</tt></a>,
+<a href="book-Z-H-22.html#__idx_3386">[2]</a><br /><a href="book-Z-H-18.html#__idx_2704"><tt>order</tt></a>, <a href="book-Z-H-18.html#__idx_2746">[2]</a><br /><a href="book-Z-H-11.html#__idx_760">order notation</a><br />
 order of evaluation
 <br />
-    <a href="book-Z-H-20.html#%_idx_3032">assignment and</a><br />
-    <a href="book-Z-H-21.html#%_idx_3066">implementation-dependent</a><br />
-    <a href="book-Z-H-35.html#%_idx_6414">in compiler</a><br />
-    <a href="book-Z-H-34.html#%_idx_6070">in explicit-control evaluator</a><br />
-    <a href="book-Z-H-26.html#%_idx_4270">in metacircular evaluator</a><br />
-    <a href="book-Z-H-20.html#%_idx_3030">in Scheme</a><br />
+    <a href="book-Z-H-20.html#__idx_3032">assignment and</a><br />
+    <a href="book-Z-H-21.html#__idx_3066">implementation-dependent</a><br />
+    <a href="book-Z-H-35.html#__idx_6414">in compiler</a><br />
+    <a href="book-Z-H-34.html#__idx_6070">in explicit-control evaluator</a><br />
+    <a href="book-Z-H-26.html#__idx_4270">in metacircular evaluator</a><br />
+    <a href="book-Z-H-20.html#__idx_3030">in Scheme</a><br />
 order of events
 <br />
-    <a href="book-Z-H-24.html#%_idx_3794">decoupling apparent from actual</a><br />
-    <a href="book-Z-H-23.html#%_idx_3590">indeterminacy in concurrent systems</a><br /><a href="book-Z-H-11.html#%_idx_752">order of growth</a><br />
-    <a href="book-Z-H-11.html#%_idx_768">linear iterative process</a><br />
-    <a href="book-Z-H-11.html#%_idx_762">linear recursive process</a><br />
-    <a href="book-Z-H-11.html#%_idx_806">logarithmic</a><br />
-    <a href="book-Z-H-11.html#%_idx_774">tree-recursive process</a><br />
+    <a href="book-Z-H-24.html#__idx_3794">decoupling apparent from actual</a><br />
+    <a href="book-Z-H-23.html#__idx_3590">indeterminacy in concurrent systems</a><br /><a href="book-Z-H-11.html#__idx_752">order of growth</a><br />
+    <a href="book-Z-H-11.html#__idx_768">linear iterative process</a><br />
+    <a href="book-Z-H-11.html#__idx_762">linear recursive process</a><br />
+    <a href="book-Z-H-11.html#__idx_806">logarithmic</a><br />
+    <a href="book-Z-H-11.html#__idx_774">tree-recursive process</a><br />
 order of subexpression evaluation, <em>see</em> order of evaluation
-<br /><a href="book-Z-H-16.html#%_idx_2126">ordered-list representation of sets</a><br /><a href="book-Z-H-18.html#%_idx_2514">ordinary numbers (in generic arithmetic system)</a><br /><a href="book-Z-H-15.html#%_idx_1916"><tt>origin-frame</tt></a><br /><a href="book-Z-H-15.html#%_idx_1784">Ostrowski, A. M.</a><br /><a href="book-Z-H-29.html#%_idx_5152"><tt>outranked-by</tt> (rule)</a>,
-<a href="book-Z-H-29.html#%_idx_5276">[2]</a></p><p>
+<br /><a href="book-Z-H-16.html#__idx_2126">ordered-list representation of sets</a><br /><a href="book-Z-H-18.html#__idx_2514">ordinary numbers (in generic arithmetic system)</a><br /><a href="book-Z-H-15.html#__idx_1916"><tt>origin-frame</tt></a><br /><a href="book-Z-H-15.html#__idx_1784">Ostrowski, A. M.</a><br /><a href="book-Z-H-29.html#__idx_5152"><tt>outranked-by</tt> (rule)</a>,
+<a href="book-Z-H-29.html#__idx_5276">[2]</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-23.html#%_idx_3654">P operation on semaphore</a><br /><a href="book-Z-H-17.html#%_idx_2442">package</a><br />
-    <a href="book-Z-H-18.html#%_idx_2536">complex-number</a><br />
-    <a href="book-Z-H-17.html#%_idx_2450">polar representation</a><br />
-    <a href="book-Z-H-18.html#%_idx_2678">polynomial</a><br />
-    <a href="book-Z-H-18.html#%_idx_2524">rational-number</a><br />
-    <a href="book-Z-H-17.html#%_idx_2444">rectangular representation</a><br />
-    <a href="book-Z-H-18.html#%_idx_2516">Scheme-number</a><br /><a href="book-Z-H-15.html#%_idx_1862">painter(s)</a><br />
-    <a href="book-Z-H-15.html#%_idx_1898">higher-order operations</a><br />
-    <a href="book-Z-H-15.html#%_idx_1876">operations</a><br />
-    <a href="book-Z-H-15.html#%_idx_1946">represented as procedures</a><br />
-    <a href="book-Z-H-15.html#%_idx_1960">transforming and combining</a><br /><a href="book-Z-H-14.html#%_idx_1318">pair(s)</a><br />
-    <a href="book-Z-H-14.html#%_idx_1458">axiomatic definition of</a><br />
-    <a href="book-Z-H-15.html#%_idx_1526">box-and-pointer notation for</a><br />
-    <a href="book-Z-H-24.html#%_idx_3984">infinite stream of</a><br />
-    <a href="book-Z-H-27.html#%_idx_4762">lazy</a><br />
-    <a href="book-Z-H-22.html#%_idx_3138">mutable</a><br />
-    <a href="book-Z-H-14.html#%_idx_1450">procedural representation of</a>,
-<a href="book-Z-H-22.html#%_idx_3200">[2]</a>, <a href="book-Z-H-27.html#%_idx_4772">[3]</a><br />
-    <a href="book-Z-H-33.html#%_idx_5852">represented using vectors</a><br />
-    <a href="book-Z-H-15.html#%_idx_1558">used to represent sequence</a><br />
-    <a href="book-Z-H-15.html#%_idx_1678">used to represent tree</a><br /><a href="book-Z-H-15.html#%_idx_1686"><tt>pair?</tt> (primitive procedure)</a><br />
-    <a href="book-Z-H-33.html#%_idx_5910">implemented with typed pointers</a><br /><a href="book-Z-H-24.html#%_idx_4002"><tt>pairs</tt></a><br /><a href="book-Z-H-15.html#%_idx_1786">Pan, V. Y.</a><br /><a href="book-Z-H-23.html#%_idx_3612"><tt>parallel-execute</tt></a><br /><a href="book-Z-H-35.html#%_idx_6402"><tt>parallel-instruction-sequences</tt></a><br />
+<br /><a href="book-Z-H-23.html#__idx_3654">P operation on semaphore</a><br /><a href="book-Z-H-17.html#__idx_2442">package</a><br />
+    <a href="book-Z-H-18.html#__idx_2536">complex-number</a><br />
+    <a href="book-Z-H-17.html#__idx_2450">polar representation</a><br />
+    <a href="book-Z-H-18.html#__idx_2678">polynomial</a><br />
+    <a href="book-Z-H-18.html#__idx_2524">rational-number</a><br />
+    <a href="book-Z-H-17.html#__idx_2444">rectangular representation</a><br />
+    <a href="book-Z-H-18.html#__idx_2516">Scheme-number</a><br /><a href="book-Z-H-15.html#__idx_1862">painter(s)</a><br />
+    <a href="book-Z-H-15.html#__idx_1898">higher-order operations</a><br />
+    <a href="book-Z-H-15.html#__idx_1876">operations</a><br />
+    <a href="book-Z-H-15.html#__idx_1946">represented as procedures</a><br />
+    <a href="book-Z-H-15.html#__idx_1960">transforming and combining</a><br /><a href="book-Z-H-14.html#__idx_1318">pair(s)</a><br />
+    <a href="book-Z-H-14.html#__idx_1458">axiomatic definition of</a><br />
+    <a href="book-Z-H-15.html#__idx_1526">box-and-pointer notation for</a><br />
+    <a href="book-Z-H-24.html#__idx_3984">infinite stream of</a><br />
+    <a href="book-Z-H-27.html#__idx_4762">lazy</a><br />
+    <a href="book-Z-H-22.html#__idx_3138">mutable</a><br />
+    <a href="book-Z-H-14.html#__idx_1450">procedural representation of</a>,
+<a href="book-Z-H-22.html#__idx_3200">[2]</a>, <a href="book-Z-H-27.html#__idx_4772">[3]</a><br />
+    <a href="book-Z-H-33.html#__idx_5852">represented using vectors</a><br />
+    <a href="book-Z-H-15.html#__idx_1558">used to represent sequence</a><br />
+    <a href="book-Z-H-15.html#__idx_1678">used to represent tree</a><br /><a href="book-Z-H-15.html#__idx_1686"><tt>pair?</tt> (primitive procedure)</a><br />
+    <a href="book-Z-H-33.html#__idx_5910">implemented with typed pointers</a><br /><a href="book-Z-H-24.html#__idx_4002"><tt>pairs</tt></a><br /><a href="book-Z-H-15.html#__idx_1786">Pan, V. Y.</a><br /><a href="book-Z-H-23.html#__idx_3612"><tt>parallel-execute</tt></a><br /><a href="book-Z-H-35.html#__idx_6402"><tt>parallel-instruction-sequences</tt></a><br />
 parallelism, <em>see</em> concurrency
 <br />
 parameter, <em>see</em> formal parameters
@@ -1446,766 +1446,766 @@ <h1 class="chapter">
 <br />
 parentheses
 <br />
-    <a href="book-Z-H-10.html#%_idx_178">delimiting combination</a><br />
-    <a href="book-Z-H-10.html#%_idx_360">delimiting <tt>cond</tt> clauses</a><br />
-    <a href="book-Z-H-10.html#%_idx_328">in procedure definition</a><br /><a href="book-Z-H-28.html#%_idx_4966"><tt>parse</tt></a><br /><a href="book-Z-H-28.html#%_idx_4964"><tt>parse-...</tt></a><br /><a href="book-Z-H-28.html#%_idx_4952">parsing natural language</a><br />
-    <a href="book-Z-H-28.html#%_idx_4972">real language understanding vs. toy parser</a><br /><a href="book-Z-H-24.html#%_idx_3892"><tt>partial-sums</tt></a><br /><a href="book-Z-H-10.html#%_idx_288">Pascal</a><br />
-    <a href="book-Z-H-24.html#%_idx_4100">lack of higher-order procedures</a><br />
-    <a href="book-Z-H-11.html#%_idx_686">recursive procedures</a><br />
-    <a href="book-Z-H-15.html#%_idx_1548">restrictions on compound data</a><br />
-    <a href="book-Z-H-22.html#%_idx_3572">weakness in handling compound objects</a><br /><a href="book-Z-H-11.html#%_idx_742">Pascal, Blaise</a><br /><a href="book-Z-H-11.html#%_idx_738">Pascal's triangle</a><br /><a href="book-Z-H-20.html#%_idx_2914">password-protected bank account</a><br /><a href="book-Z-H-29.html#%_idx_5112">pattern</a><br /><a href="book-Z-H-29.html#%_idx_5176">pattern matching</a><br />
-    <a href="book-Z-H-29.html#%_idx_5342">implementation</a><br />
-    <a href="book-Z-H-29.html#%_idx_5212">unification vs.</a>,
-<a href="book-Z-H-29.html#%_idx_5222">[2]</a><br /><a href="book-Z-H-29.html#%_idx_5114">pattern variable</a><br />
-    <a href="book-Z-H-29.html#%_idx_5298">representation of</a>,
-<a href="book-Z-H-29.html#%_idx_5400">[2]</a><br /><a href="book-Z-H-29.html#%_idx_5346"><tt>pattern-match</tt></a><br /><a href="book-Z-H-32.html#%_idx_5662"><tt>pc</tt> register</a><br /><a href="book-Z-H-31.html#%_idx_5544"><tt>perform</tt> (in register machine)</a><br />
-    <a href="book-Z-H-32.html#%_idx_5762">simulating</a><br /><a href="book-Z-H-32.html#%_idx_5766"><tt>perform-action</tt></a><br /><a href="book-Z-H-6.html#%_idx_2">Perlis, Alan J.</a>, <a href="book-Z-H-15.html#%_idx_1552">[2]</a><br />
-    <a href="book-Z-H-10.html#%_idx_208">quips</a>, <a href="book-Z-H-10.html#%_idx_278">[2]</a><br /><a href="book-Z-H-15.html#%_idx_1832">permutations of a set</a><br />
-    <a href="book-Z-H-15.html#%_idx_1840"><tt>permutations</tt></a><br /><a href="book-Z-H-28.html#%_idx_4942">Phillips, Hubert</a><br />
+    <a href="book-Z-H-10.html#__idx_178">delimiting combination</a><br />
+    <a href="book-Z-H-10.html#__idx_360">delimiting <tt>cond</tt> clauses</a><br />
+    <a href="book-Z-H-10.html#__idx_328">in procedure definition</a><br /><a href="book-Z-H-28.html#__idx_4966"><tt>parse</tt></a><br /><a href="book-Z-H-28.html#__idx_4964"><tt>parse-...</tt></a><br /><a href="book-Z-H-28.html#__idx_4952">parsing natural language</a><br />
+    <a href="book-Z-H-28.html#__idx_4972">real language understanding vs. toy parser</a><br /><a href="book-Z-H-24.html#__idx_3892"><tt>partial-sums</tt></a><br /><a href="book-Z-H-10.html#__idx_288">Pascal</a><br />
+    <a href="book-Z-H-24.html#__idx_4100">lack of higher-order procedures</a><br />
+    <a href="book-Z-H-11.html#__idx_686">recursive procedures</a><br />
+    <a href="book-Z-H-15.html#__idx_1548">restrictions on compound data</a><br />
+    <a href="book-Z-H-22.html#__idx_3572">weakness in handling compound objects</a><br /><a href="book-Z-H-11.html#__idx_742">Pascal, Blaise</a><br /><a href="book-Z-H-11.html#__idx_738">Pascal's triangle</a><br /><a href="book-Z-H-20.html#__idx_2914">password-protected bank account</a><br /><a href="book-Z-H-29.html#__idx_5112">pattern</a><br /><a href="book-Z-H-29.html#__idx_5176">pattern matching</a><br />
+    <a href="book-Z-H-29.html#__idx_5342">implementation</a><br />
+    <a href="book-Z-H-29.html#__idx_5212">unification vs.</a>,
+<a href="book-Z-H-29.html#__idx_5222">[2]</a><br /><a href="book-Z-H-29.html#__idx_5114">pattern variable</a><br />
+    <a href="book-Z-H-29.html#__idx_5298">representation of</a>,
+<a href="book-Z-H-29.html#__idx_5400">[2]</a><br /><a href="book-Z-H-29.html#__idx_5346"><tt>pattern-match</tt></a><br /><a href="book-Z-H-32.html#__idx_5662"><tt>pc</tt> register</a><br /><a href="book-Z-H-31.html#__idx_5544"><tt>perform</tt> (in register machine)</a><br />
+    <a href="book-Z-H-32.html#__idx_5762">simulating</a><br /><a href="book-Z-H-32.html#__idx_5766"><tt>perform-action</tt></a><br /><a href="book-Z-H-6.html#__idx_2">Perlis, Alan J.</a>, <a href="book-Z-H-15.html#__idx_1552">[2]</a><br />
+    <a href="book-Z-H-10.html#__idx_208">quips</a>, <a href="book-Z-H-10.html#__idx_278">[2]</a><br /><a href="book-Z-H-15.html#__idx_1832">permutations of a set</a><br />
+    <a href="book-Z-H-15.html#__idx_1840"><tt>permutations</tt></a><br /><a href="book-Z-H-28.html#__idx_4942">Phillips, Hubert</a><br />
 π  (pi)
 <br />
-    <a href="book-Z-H-12.html#%_idx_1094">approximation with half-interval method</a><br />
-    <a href="book-Z-H-20.html#%_idx_2958">approximation with Monte Carlo integration</a>, <a href="book-Z-H-24.html#%_idx_4140">[2]</a><br />
-    <a href="book-Z-H-20.html#%_idx_2940">Cesàro estimate for</a>,
-<a href="book-Z-H-24.html#%_idx_4120">[2]</a><br />
-    <a href="book-Z-H-12.html#%_idx_974">Leibniz's series for</a>,
-<a href="book-Z-H-24.html#%_idx_3950">[2]</a><br />
-    <a href="book-Z-H-24.html#%_idx_3954">stream of approximations</a><br />
-    <a href="book-Z-H-12.html#%_idx_1014">Wallis's formula for</a><br /><a href="book-Z-H-24.html#%_idx_3962"><tt>pi-stream</tt></a><br /><a href="book-Z-H-12.html#%_idx_978"><tt>pi-sum</tt></a><br />
-    <a href="book-Z-H-12.html#%_idx_1000">with higher-order procedures</a><br />
-    <a href="book-Z-H-12.html#%_idx_1030">with <tt>lambda</tt></a><br /><a href="book-Z-H-15.html#%_idx_1854">picture language</a><br /><a href="book-Z-H-11.html#%_idx_812">Pingala,  Áchárya</a><br /><a href="book-Z-H-23.html#%_idx_3582">pipelining</a><br /><a href="book-Z-H-9.html#%_idx_52">Pitman, Kent M.</a><br /><a href="book-Z-H-28.html#%_idx_4866">Planner</a><br /><a href="book-Z-H-14.html#%_idx_1404">point, represented as a pair</a><br />
+    <a href="book-Z-H-12.html#__idx_1094">approximation with half-interval method</a><br />
+    <a href="book-Z-H-20.html#__idx_2958">approximation with Monte Carlo integration</a>, <a href="book-Z-H-24.html#__idx_4140">[2]</a><br />
+    <a href="book-Z-H-20.html#__idx_2940">Cesàro estimate for</a>,
+<a href="book-Z-H-24.html#__idx_4120">[2]</a><br />
+    <a href="book-Z-H-12.html#__idx_974">Leibniz's series for</a>,
+<a href="book-Z-H-24.html#__idx_3950">[2]</a><br />
+    <a href="book-Z-H-24.html#__idx_3954">stream of approximations</a><br />
+    <a href="book-Z-H-12.html#__idx_1014">Wallis's formula for</a><br /><a href="book-Z-H-24.html#__idx_3962"><tt>pi-stream</tt></a><br /><a href="book-Z-H-12.html#__idx_978"><tt>pi-sum</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_1000">with higher-order procedures</a><br />
+    <a href="book-Z-H-12.html#__idx_1030">with <tt>lambda</tt></a><br /><a href="book-Z-H-15.html#__idx_1854">picture language</a><br /><a href="book-Z-H-11.html#__idx_812">Pingala,  Áchárya</a><br /><a href="book-Z-H-23.html#__idx_3582">pipelining</a><br /><a href="book-Z-H-9.html#__idx_52">Pitman, Kent M.</a><br /><a href="book-Z-H-28.html#__idx_4866">Planner</a><br /><a href="book-Z-H-14.html#__idx_1404">point, represented as a pair</a><br />
 pointer
 <br />
-    <a href="book-Z-H-15.html#%_idx_1530">in box-and-pointer notation</a><br />
-    <a href="book-Z-H-33.html#%_idx_5862">typed</a><br /><a href="book-Z-H-17.html#%_idx_2452"><tt>polar</tt> package</a><br /><a href="book-Z-H-17.html#%_idx_2376"><tt>polar?</tt></a><br /><a href="book-Z-H-18.html#%_idx_2664">poly</a><br /><a href="book-Z-H-18.html#%_idx_2680"><tt>polynomial</tt> package</a><br /><a href="book-Z-H-18.html#%_idx_2652">polynomial arithmetic</a><br />
-    <a href="book-Z-H-18.html#%_idx_2670">addition</a><br />
-    <a href="book-Z-H-18.html#%_idx_2758">division</a><br />
-    <a href="book-Z-H-18.html#%_idx_2788">Euclid's Algorithm</a><br />
-    <a href="book-Z-H-18.html#%_idx_2784">greatest common divisor</a>,
-<a href="book-Z-H-18.html#%_idx_2810">[2]</a><br />
-    <a href="book-Z-H-18.html#%_idx_2682">interfaced to generic arithmetic system</a><br />
-    <a href="book-Z-H-18.html#%_idx_2672">multiplication</a><br />
-    <a href="book-Z-H-18.html#%_idx_2812">probabilistic algorithm for GCD</a><br />
-    <a href="book-Z-H-18.html#%_idx_2780">rational functions</a><br />
-    <a href="book-Z-H-18.html#%_idx_2756">subtraction</a><br /><a href="book-Z-H-18.html#%_idx_2650">polynomial(s)</a><br />
-    <a href="book-Z-H-18.html#%_idx_2772">canonical form</a><br />
-    <a href="book-Z-H-18.html#%_idx_2728">dense</a><br />
-    <a href="book-Z-H-15.html#%_idx_1772">evaluating with Horner's rule</a><br />
-    <a href="book-Z-H-18.html#%_idx_2766">hierarchy of types</a><br />
-    <a href="book-Z-H-18.html#%_idx_2656">indeterminate of</a><br />
-    <a href="book-Z-H-18.html#%_idx_2732">sparse</a><br />
-    <a href="book-Z-H-18.html#%_idx_2660">univariate</a><br /><a href="book-Z-H-32.html#%_idx_5652"><tt>pop</tt></a><br /><a href="book-Z-H-9.html#%_idx_66">Portable Standard Lisp</a><br /><a href="book-Z-H-35.html#%_idx_6504">porting a language</a><br /><a href="book-Z-H-24.html#%_idx_3910">power series, as stream</a><br />
-    <a href="book-Z-H-24.html#%_idx_3926">adding</a><br />
-    <a href="book-Z-H-24.html#%_idx_3934">dividing</a><br />
-    <a href="book-Z-H-24.html#%_idx_3922">integrating</a><br />
-    <a href="book-Z-H-24.html#%_idx_3928">multiplying</a><br /><a href="book-Z-H-23.html#%_idx_3712">PowerPC</a><br /><a href="book-Z-H-10.html#%_idx_390">predicate</a><br />
-    <a href="book-Z-H-10.html#%_idx_366">of <tt>cond</tt> clause</a><br />
-    <a href="book-Z-H-10.html#%_idx_434">of <tt>if</tt></a><br />
-    <a href="book-Z-H-10.html#%_idx_518">naming convention for</a><br /><a href="book-Z-H-16.html#%_idx_2234">prefix code</a><br /><a href="book-Z-H-10.html#%_idx_190">prefix notation</a><br />
-    <a href="book-Z-H-16.html#%_idx_2098">infix notation vs.</a><br /><a href="book-Z-H-28.html#%_idx_4968"><tt>prepositions</tt></a><br /><a href="book-Z-H-35.html#%_idx_6264"><tt>preserving</tt></a>,
-<a href="book-Z-H-35.html#%_idx_6272">[2]</a>, <a href="book-Z-H-35.html#%_idx_6398">[3]</a>,
-<a href="book-Z-H-35.html#%_idx_6420">[4]</a><br /><a href="book-Z-H-10.html#%_idx_198">pretty-printing</a><br /><a href="book-Z-H-11.html#%_idx_858">prime number(s)</a><br />
-    <a href="book-Z-H-11.html#%_idx_930">cryptography and</a><br />
-    <a href="book-Z-H-24.html#%_idx_3842">Eratosthenes's sieve for</a><br />
-    <a href="book-Z-H-11.html#%_idx_870">Fermat test for</a><br />
+    <a href="book-Z-H-15.html#__idx_1530">in box-and-pointer notation</a><br />
+    <a href="book-Z-H-33.html#__idx_5862">typed</a><br /><a href="book-Z-H-17.html#__idx_2452"><tt>polar</tt> package</a><br /><a href="book-Z-H-17.html#__idx_2376"><tt>polar?</tt></a><br /><a href="book-Z-H-18.html#__idx_2664">poly</a><br /><a href="book-Z-H-18.html#__idx_2680"><tt>polynomial</tt> package</a><br /><a href="book-Z-H-18.html#__idx_2652">polynomial arithmetic</a><br />
+    <a href="book-Z-H-18.html#__idx_2670">addition</a><br />
+    <a href="book-Z-H-18.html#__idx_2758">division</a><br />
+    <a href="book-Z-H-18.html#__idx_2788">Euclid's Algorithm</a><br />
+    <a href="book-Z-H-18.html#__idx_2784">greatest common divisor</a>,
+<a href="book-Z-H-18.html#__idx_2810">[2]</a><br />
+    <a href="book-Z-H-18.html#__idx_2682">interfaced to generic arithmetic system</a><br />
+    <a href="book-Z-H-18.html#__idx_2672">multiplication</a><br />
+    <a href="book-Z-H-18.html#__idx_2812">probabilistic algorithm for GCD</a><br />
+    <a href="book-Z-H-18.html#__idx_2780">rational functions</a><br />
+    <a href="book-Z-H-18.html#__idx_2756">subtraction</a><br /><a href="book-Z-H-18.html#__idx_2650">polynomial(s)</a><br />
+    <a href="book-Z-H-18.html#__idx_2772">canonical form</a><br />
+    <a href="book-Z-H-18.html#__idx_2728">dense</a><br />
+    <a href="book-Z-H-15.html#__idx_1772">evaluating with Horner's rule</a><br />
+    <a href="book-Z-H-18.html#__idx_2766">hierarchy of types</a><br />
+    <a href="book-Z-H-18.html#__idx_2656">indeterminate of</a><br />
+    <a href="book-Z-H-18.html#__idx_2732">sparse</a><br />
+    <a href="book-Z-H-18.html#__idx_2660">univariate</a><br /><a href="book-Z-H-32.html#__idx_5652"><tt>pop</tt></a><br /><a href="book-Z-H-9.html#__idx_66">Portable Standard Lisp</a><br /><a href="book-Z-H-35.html#__idx_6504">porting a language</a><br /><a href="book-Z-H-24.html#__idx_3910">power series, as stream</a><br />
+    <a href="book-Z-H-24.html#__idx_3926">adding</a><br />
+    <a href="book-Z-H-24.html#__idx_3934">dividing</a><br />
+    <a href="book-Z-H-24.html#__idx_3922">integrating</a><br />
+    <a href="book-Z-H-24.html#__idx_3928">multiplying</a><br /><a href="book-Z-H-23.html#__idx_3712">PowerPC</a><br /><a href="book-Z-H-10.html#__idx_390">predicate</a><br />
+    <a href="book-Z-H-10.html#__idx_366">of <tt>cond</tt> clause</a><br />
+    <a href="book-Z-H-10.html#__idx_434">of <tt>if</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_518">naming convention for</a><br /><a href="book-Z-H-16.html#__idx_2234">prefix code</a><br /><a href="book-Z-H-10.html#__idx_190">prefix notation</a><br />
+    <a href="book-Z-H-16.html#__idx_2098">infix notation vs.</a><br /><a href="book-Z-H-28.html#__idx_4968"><tt>prepositions</tt></a><br /><a href="book-Z-H-35.html#__idx_6264"><tt>preserving</tt></a>,
+<a href="book-Z-H-35.html#__idx_6272">[2]</a>, <a href="book-Z-H-35.html#__idx_6398">[3]</a>,
+<a href="book-Z-H-35.html#__idx_6420">[4]</a><br /><a href="book-Z-H-10.html#__idx_198">pretty-printing</a><br /><a href="book-Z-H-11.html#__idx_858">prime number(s)</a><br />
+    <a href="book-Z-H-11.html#__idx_930">cryptography and</a><br />
+    <a href="book-Z-H-24.html#__idx_3842">Eratosthenes's sieve for</a><br />
+    <a href="book-Z-H-11.html#__idx_870">Fermat test for</a><br />
     infinite stream of, <em>see</em> <tt>primes</tt>
 <br />
-    <a href="book-Z-H-11.html#%_idx_950">Miller-Rabin test for</a><br />
-    <a href="book-Z-H-11.html#%_idx_856">testing for</a><br /><a href="book-Z-H-28.html#%_idx_4814"><tt>prime-sum-pair</tt></a><br /><a href="book-Z-H-15.html#%_idx_1828"><tt>prime-sum-pairs</tt></a><br />
-    <a href="book-Z-H-24.html#%_idx_3990">infinite stream</a><br /><a href="book-Z-H-11.html#%_idx_866"><tt>prime?</tt></a>, <a href="book-Z-H-24.html#%_idx_3874">[2]</a><br /><a href="book-Z-H-24.html#%_idx_3854"><tt>primes</tt> (infinite stream)</a><br />
-    <a href="book-Z-H-24.html#%_idx_3872">implicit definition</a><br /><a href="book-Z-H-22.html#%_idx_3510">primitive constraints</a><br /><a href="book-Z-H-10.html#%_idx_120">primitive expression</a><br />
-    <a href="book-Z-H-10.html#%_idx_264">evaluation of</a><br />
-    <a href="book-Z-H-10.html#%_idx_158">name of primitive procedure</a><br />
-    <a href="book-Z-H-10.html#%_idx_218">name of variable</a><br />
-    <a href="book-Z-H-10.html#%_idx_150">number</a><br />
+    <a href="book-Z-H-11.html#__idx_950">Miller-Rabin test for</a><br />
+    <a href="book-Z-H-11.html#__idx_856">testing for</a><br /><a href="book-Z-H-28.html#__idx_4814"><tt>prime-sum-pair</tt></a><br /><a href="book-Z-H-15.html#__idx_1828"><tt>prime-sum-pairs</tt></a><br />
+    <a href="book-Z-H-24.html#__idx_3990">infinite stream</a><br /><a href="book-Z-H-11.html#__idx_866"><tt>prime?</tt></a>, <a href="book-Z-H-24.html#__idx_3874">[2]</a><br /><a href="book-Z-H-24.html#__idx_3854"><tt>primes</tt> (infinite stream)</a><br />
+    <a href="book-Z-H-24.html#__idx_3872">implicit definition</a><br /><a href="book-Z-H-22.html#__idx_3510">primitive constraints</a><br /><a href="book-Z-H-10.html#__idx_120">primitive expression</a><br />
+    <a href="book-Z-H-10.html#__idx_264">evaluation of</a><br />
+    <a href="book-Z-H-10.html#__idx_158">name of primitive procedure</a><br />
+    <a href="book-Z-H-10.html#__idx_218">name of variable</a><br />
+    <a href="book-Z-H-10.html#__idx_150">number</a><br />
 primitive procedures (those marked <em>ns</em> are not in the IEEE Scheme standard)
 <br />
-    <a href="book-Z-H-10.html#%_idx_166"><tt>*</tt></a><br />
-    <a href="book-Z-H-10.html#%_idx_164"><tt>+</tt></a><br />
-    <a href="book-Z-H-10.html#%_idx_172"><tt>-</tt></a>, <a href="book-Z-H-10.html#%_idx_412">[2]</a><br />
-    <a href="book-Z-H-10.html#%_idx_174"><tt>/</tt></a><br />
-    <a href="book-Z-H-10.html#%_idx_400"><tt>&lt;</tt></a><br />
-    <a href="book-Z-H-10.html#%_idx_402"><tt>=</tt></a><br />
-    <a href="book-Z-H-10.html#%_idx_398"><tt>&gt;</tt></a><br />
-    <a href="book-Z-H-17.html#%_idx_2460"><tt>apply</tt></a><br />
-    <a href="book-Z-H-17.html#%_idx_2326"><tt>atan</tt></a><br />
-    <a href="book-Z-H-14.html#%_idx_1326"><tt>car</tt></a><br />
-    <a href="book-Z-H-14.html#%_idx_1330"><tt>cdr</tt></a><br />
-    <a href="book-Z-H-14.html#%_idx_1322"><tt>cons</tt></a><br />
-    <a href="book-Z-H-12.html#%_idx_1114"><tt>cos</tt></a><br />
-    <a href="book-Z-H-14.html#%_idx_1360"><tt>display</tt></a><br />
-    <a href="book-Z-H-16.html#%_idx_2028"><tt>eq?</tt></a><br />
-    <a href="book-Z-H-12.html#%_idx_1090"><tt>error</tt> (<em>ns</em>)</a><br />
-    <a href="book-Z-H-26.html#%_idx_4574"><tt>eval</tt> (<em>ns</em>)</a><br />
-    <a href="book-Z-H-15.html#%_idx_1570"><tt>list</tt></a><br />
-    <a href="book-Z-H-12.html#%_idx_1136"><tt>log</tt></a><br />
-    <a href="book-Z-H-14.html#%_idx_1496"><tt>max</tt></a><br />
-    <a href="book-Z-H-14.html#%_idx_1492"><tt>min</tt></a><br />
-    <a href="book-Z-H-14.html#%_idx_1364"><tt>newline</tt></a><br />
-    <a href="book-Z-H-10.html#%_idx_464"><tt>not</tt></a><br />
-    <a href="book-Z-H-15.html#%_idx_1616"><tt>null?</tt></a><br />
-    <a href="book-Z-H-16.html#%_idx_2054"><tt>number?</tt></a><br />
-    <a href="book-Z-H-15.html#%_idx_1688"><tt>pair?</tt></a><br />
-    <a href="book-Z-H-24.html#%_idx_3908"><tt>quotient</tt></a><br />
-    <a href="book-Z-H-11.html#%_idx_902"><tt>random</tt> (<em>ns</em>)</a>,
-<a href="book-Z-H-20.html#%_idx_2968">[2]</a><br />
-    <a href="book-Z-H-26.html#%_idx_4524"><tt>read</tt></a><br />
-    <a href="book-Z-H-11.html#%_idx_802"><tt>remainder</tt></a><br />
-    <a href="book-Z-H-18.html#%_idx_2644"><tt>round</tt></a><br />
-    <a href="book-Z-H-11.html#%_idx_934"><tt>runtime</tt> (<em>ns</em>)</a><br />
-    <a href="book-Z-H-22.html#%_idx_3142"><tt>set-car!</tt></a><br />
-    <a href="book-Z-H-22.html#%_idx_3146"><tt>set-cdr!</tt></a><br />
-    <a href="book-Z-H-12.html#%_idx_1118"><tt>sin</tt></a><br />
-    <a href="book-Z-H-16.html#%_idx_2062"><tt>symbol?</tt></a><br />
-    <a href="book-Z-H-33.html#%_idx_5846"><tt>vector-ref</tt></a><br />
-    <a href="book-Z-H-33.html#%_idx_5850"><tt>vector-set!</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_166"><tt>*</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_164"><tt>+</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_172"><tt>-</tt></a>, <a href="book-Z-H-10.html#__idx_412">[2]</a><br />
+    <a href="book-Z-H-10.html#__idx_174"><tt>/</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_400"><tt>&lt;</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_402"><tt>=</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_398"><tt>&gt;</tt></a><br />
+    <a href="book-Z-H-17.html#__idx_2460"><tt>apply</tt></a><br />
+    <a href="book-Z-H-17.html#__idx_2326"><tt>atan</tt></a><br />
+    <a href="book-Z-H-14.html#__idx_1326"><tt>car</tt></a><br />
+    <a href="book-Z-H-14.html#__idx_1330"><tt>cdr</tt></a><br />
+    <a href="book-Z-H-14.html#__idx_1322"><tt>cons</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_1114"><tt>cos</tt></a><br />
+    <a href="book-Z-H-14.html#__idx_1360"><tt>display</tt></a><br />
+    <a href="book-Z-H-16.html#__idx_2028"><tt>eq?</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_1090"><tt>error</tt> (<em>ns</em>)</a><br />
+    <a href="book-Z-H-26.html#__idx_4574"><tt>eval</tt> (<em>ns</em>)</a><br />
+    <a href="book-Z-H-15.html#__idx_1570"><tt>list</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_1136"><tt>log</tt></a><br />
+    <a href="book-Z-H-14.html#__idx_1496"><tt>max</tt></a><br />
+    <a href="book-Z-H-14.html#__idx_1492"><tt>min</tt></a><br />
+    <a href="book-Z-H-14.html#__idx_1364"><tt>newline</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_464"><tt>not</tt></a><br />
+    <a href="book-Z-H-15.html#__idx_1616"><tt>null?</tt></a><br />
+    <a href="book-Z-H-16.html#__idx_2054"><tt>number?</tt></a><br />
+    <a href="book-Z-H-15.html#__idx_1688"><tt>pair?</tt></a><br />
+    <a href="book-Z-H-24.html#__idx_3908"><tt>quotient</tt></a><br />
+    <a href="book-Z-H-11.html#__idx_902"><tt>random</tt> (<em>ns</em>)</a>,
+<a href="book-Z-H-20.html#__idx_2968">[2]</a><br />
+    <a href="book-Z-H-26.html#__idx_4524"><tt>read</tt></a><br />
+    <a href="book-Z-H-11.html#__idx_802"><tt>remainder</tt></a><br />
+    <a href="book-Z-H-18.html#__idx_2644"><tt>round</tt></a><br />
+    <a href="book-Z-H-11.html#__idx_934"><tt>runtime</tt> (<em>ns</em>)</a><br />
+    <a href="book-Z-H-22.html#__idx_3142"><tt>set-car!</tt></a><br />
+    <a href="book-Z-H-22.html#__idx_3146"><tt>set-cdr!</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_1118"><tt>sin</tt></a><br />
+    <a href="book-Z-H-16.html#__idx_2062"><tt>symbol?</tt></a><br />
+    <a href="book-Z-H-33.html#__idx_5846"><tt>vector-ref</tt></a><br />
+    <a href="book-Z-H-33.html#__idx_5850"><tt>vector-set!</tt></a><br />
 primitive query, <em>see</em> simple query
-<br /><a href="book-Z-H-34.html#%_idx_6076"><tt>primitive-apply</tt></a><br /><a href="book-Z-H-26.html#%_idx_4508"><tt>primitive-implementation</tt></a><br /><a href="book-Z-H-26.html#%_idx_4510"><tt>primitive-procedure-names</tt></a><br /><a href="book-Z-H-26.html#%_idx_4512"><tt>primitive-procedure-objects</tt></a><br /><a href="book-Z-H-26.html#%_idx_4442"><tt>primitive-procedure?</tt></a>,
-<a href="book-Z-H-26.html#%_idx_4506">[2]</a><br /><a href="book-Z-H-17.html#%_idx_2362">principle of least commitment</a><br /><a href="book-Z-H-31.html#%_idx_5540"><tt>print</tt> operation in register machine</a><br /><a href="book-Z-H-14.html#%_idx_1410"><tt>print-point</tt></a><br /><a href="book-Z-H-22.html#%_idx_3260"><tt>print-queue</tt></a><br /><a href="book-Z-H-14.html#%_idx_1370"><tt>print-rat</tt></a><br /><a href="book-Z-H-34.html#%_idx_6146"><tt>print-result</tt></a><br />
-    <a href="book-Z-H-34.html#%_idx_6164">monitored-stack version</a><br /><a href="book-Z-H-32.html#%_idx_5810"><tt>print-stack-statistics</tt> operation in register machine</a><br /><a href="book-Z-H-14.html#%_idx_1356">printing, primitives for</a><br /><a href="book-Z-H-11.html#%_idx_908">probabilistic algorithm</a>,
-<a href="book-Z-H-18.html#%_idx_2814">[2]</a>, <a href="book-Z-H-24.html#%_idx_3850">[3]</a><br /><tt>probe</tt>
-<br />
-    <a href="book-Z-H-22.html#%_idx_3542">in constraint system</a><br />
-    <a href="book-Z-H-22.html#%_idx_3432">in digital-circuit simulator</a><br /><a href="book-Z-H-34.html#%_idx_6026"><tt>proc</tt> register</a><br /><a href="book-Z-H-10.html#%_idx_574">procedural abstraction</a><br /><a href="book-Z-H-14.html#%_idx_1448">procedural representation of data</a><br />
-    <a href="book-Z-H-22.html#%_idx_3202">mutable data</a><br /><a href="book-Z-H-9.html#%_idx_114">procedure</a>, <a href="book-Z-H-10.html#%_idx_128">[2]</a><br />
-    <a href="book-Z-H-12.html#%_idx_1044">anonymous</a><br />
-    <a href="book-Z-H-10.html#%_idx_192">arbitrary number of arguments</a>,
-<a href="book-Z-H-15.html#%_idx_1654">[2]</a><br />
-    <a href="book-Z-H-12.html#%_idx_968">as argument</a><br />
-    <a href="book-Z-H-10.html#%_idx_570">as black box</a><br />
-    <a href="book-Z-H-10.html#%_idx_322">body of</a><br />
-    <a href="book-Z-H-10.html#%_idx_298">compound</a><br />
-    <a href="book-Z-H-10.html#%_idx_304">creating with <tt>define</tt></a><br />
-    <a href="book-Z-H-12.html#%_idx_1038">creating with <tt>lambda</tt></a>,
-<a href="book-Z-H-21.html#%_idx_3070">[2]</a>, <a href="book-Z-H-21.html#%_idx_3074">[3]</a><br />
-    <a href="book-Z-H-9.html#%_idx_116">as data</a><br />
-    <a href="book-Z-H-10.html#%_idx_292">definition of</a><br />
-    <a href="book-Z-H-12.html#%_idx_1224">first-class in Lisp</a><br />
-    <a href="book-Z-H-10.html#%_idx_318">formal parameters of</a><br />
-    <a href="book-Z-H-12.html#%_idx_1080">as general method</a><br />
-    <a href="book-Z-H-16.html#%_idx_2270">generic</a>, <a href="book-Z-H-17.html#%_idx_2294">[2]</a><br />
+<br /><a href="book-Z-H-34.html#__idx_6076"><tt>primitive-apply</tt></a><br /><a href="book-Z-H-26.html#__idx_4508"><tt>primitive-implementation</tt></a><br /><a href="book-Z-H-26.html#__idx_4510"><tt>primitive-procedure-names</tt></a><br /><a href="book-Z-H-26.html#__idx_4512"><tt>primitive-procedure-objects</tt></a><br /><a href="book-Z-H-26.html#__idx_4442"><tt>primitive-procedure?</tt></a>,
+<a href="book-Z-H-26.html#__idx_4506">[2]</a><br /><a href="book-Z-H-17.html#__idx_2362">principle of least commitment</a><br /><a href="book-Z-H-31.html#__idx_5540"><tt>print</tt> operation in register machine</a><br /><a href="book-Z-H-14.html#__idx_1410"><tt>print-point</tt></a><br /><a href="book-Z-H-22.html#__idx_3260"><tt>print-queue</tt></a><br /><a href="book-Z-H-14.html#__idx_1370"><tt>print-rat</tt></a><br /><a href="book-Z-H-34.html#__idx_6146"><tt>print-result</tt></a><br />
+    <a href="book-Z-H-34.html#__idx_6164">monitored-stack version</a><br /><a href="book-Z-H-32.html#__idx_5810"><tt>print-stack-statistics</tt> operation in register machine</a><br /><a href="book-Z-H-14.html#__idx_1356">printing, primitives for</a><br /><a href="book-Z-H-11.html#__idx_908">probabilistic algorithm</a>,
+<a href="book-Z-H-18.html#__idx_2814">[2]</a>, <a href="book-Z-H-24.html#__idx_3850">[3]</a><br /><tt>probe</tt>
+<br />
+    <a href="book-Z-H-22.html#__idx_3542">in constraint system</a><br />
+    <a href="book-Z-H-22.html#__idx_3432">in digital-circuit simulator</a><br /><a href="book-Z-H-34.html#__idx_6026"><tt>proc</tt> register</a><br /><a href="book-Z-H-10.html#__idx_574">procedural abstraction</a><br /><a href="book-Z-H-14.html#__idx_1448">procedural representation of data</a><br />
+    <a href="book-Z-H-22.html#__idx_3202">mutable data</a><br /><a href="book-Z-H-9.html#__idx_114">procedure</a>, <a href="book-Z-H-10.html#__idx_128">[2]</a><br />
+    <a href="book-Z-H-12.html#__idx_1044">anonymous</a><br />
+    <a href="book-Z-H-10.html#__idx_192">arbitrary number of arguments</a>,
+<a href="book-Z-H-15.html#__idx_1654">[2]</a><br />
+    <a href="book-Z-H-12.html#__idx_968">as argument</a><br />
+    <a href="book-Z-H-10.html#__idx_570">as black box</a><br />
+    <a href="book-Z-H-10.html#__idx_322">body of</a><br />
+    <a href="book-Z-H-10.html#__idx_298">compound</a><br />
+    <a href="book-Z-H-10.html#__idx_304">creating with <tt>define</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_1038">creating with <tt>lambda</tt></a>,
+<a href="book-Z-H-21.html#__idx_3070">[2]</a>, <a href="book-Z-H-21.html#__idx_3074">[3]</a><br />
+    <a href="book-Z-H-9.html#__idx_116">as data</a><br />
+    <a href="book-Z-H-10.html#__idx_292">definition of</a><br />
+    <a href="book-Z-H-12.html#__idx_1224">first-class in Lisp</a><br />
+    <a href="book-Z-H-10.html#__idx_318">formal parameters of</a><br />
+    <a href="book-Z-H-12.html#__idx_1080">as general method</a><br />
+    <a href="book-Z-H-16.html#__idx_2270">generic</a>, <a href="book-Z-H-17.html#__idx_2294">[2]</a><br />
     higher-order, <em>see</em> higher-order procedure
 <br />
-    <a href="book-Z-H-20.html#%_idx_2882">implicit <tt>begin</tt> in body of</a><br />
-    <a href="book-Z-H-10.html#%_idx_488">mathematical function vs.</a><br />
-    <a href="book-Z-H-22.html#%_idx_3320">memoized</a><br />
-    <a href="book-Z-H-20.html#%_idx_2910">monitored</a><br />
-    <a href="book-Z-H-10.html#%_idx_312">name of</a><br />
-    <a href="book-Z-H-10.html#%_idx_302">naming (with <tt>define</tt>)</a><br />
-    <a href="book-Z-H-11.html#%_idx_630">as pattern for local evolution of a process</a><br />
-    <a href="book-Z-H-12.html#%_idx_1158">as returned value</a><br />
-    <a href="book-Z-H-32.html#%_idx_5698">returning multiple values</a><br />
-    <a href="book-Z-H-10.html#%_idx_600">scope of formal parameters</a><br />
-    <a href="book-Z-H-27.html#%_idx_4694">special form vs.</a>,
-<a href="book-Z-H-27.html#%_idx_4766">[2]</a><br />
+    <a href="book-Z-H-20.html#__idx_2882">implicit <tt>begin</tt> in body of</a><br />
+    <a href="book-Z-H-10.html#__idx_488">mathematical function vs.</a><br />
+    <a href="book-Z-H-22.html#__idx_3320">memoized</a><br />
+    <a href="book-Z-H-20.html#__idx_2910">monitored</a><br />
+    <a href="book-Z-H-10.html#__idx_312">name of</a><br />
+    <a href="book-Z-H-10.html#__idx_302">naming (with <tt>define</tt>)</a><br />
+    <a href="book-Z-H-11.html#__idx_630">as pattern for local evolution of a process</a><br />
+    <a href="book-Z-H-12.html#__idx_1158">as returned value</a><br />
+    <a href="book-Z-H-32.html#__idx_5698">returning multiple values</a><br />
+    <a href="book-Z-H-10.html#__idx_600">scope of formal parameters</a><br />
+    <a href="book-Z-H-27.html#__idx_4694">special form vs.</a>,
+<a href="book-Z-H-27.html#__idx_4766">[2]</a><br />
 procedure application
 <br />
-    <a href="book-Z-H-10.html#%_idx_180">combination denoting</a><br />
-    <a href="book-Z-H-21.html#%_idx_3084">environment model of</a><br />
+    <a href="book-Z-H-10.html#__idx_180">combination denoting</a><br />
+    <a href="book-Z-H-21.html#__idx_3084">environment model of</a><br />
     substitution model of, <em>see</em> substitution model of procedure application
-<br /><a href="book-Z-H-26.html#%_idx_4450"><tt>procedure-body</tt></a><br /><a href="book-Z-H-26.html#%_idx_4452"><tt>procedure-environment</tt></a><br /><a href="book-Z-H-26.html#%_idx_4448"><tt>procedure-parameters</tt></a><br /><a href="book-Z-H-9.html#%_idx_10">process</a><br />
-    <a href="book-Z-H-11.html#%_idx_668">iterative</a><br />
-    <a href="book-Z-H-11.html#%_idx_676">linear iterative</a><br />
-    <a href="book-Z-H-11.html#%_idx_664">linear recursive</a><br />
-    <a href="book-Z-H-11.html#%_idx_634">local evolution of</a><br />
-    <a href="book-Z-H-11.html#%_idx_754">order of growth of</a><br />
-    <a href="book-Z-H-11.html#%_idx_656">recursive</a><br />
-    <a href="book-Z-H-11.html#%_idx_756">resources required by</a><br />
-    <a href="book-Z-H-11.html#%_idx_650">shape of</a><br />
-    <a href="book-Z-H-11.html#%_idx_714">tree-recursive</a><br /><a href="book-Z-H-12.html#%_idx_1010"><tt>product</tt></a><br />
-    <a href="book-Z-H-12.html#%_idx_1022">as accumulation</a><br /><a href="book-Z-H-16.html#%_idx_2078"><tt>product?</tt></a><br /><a href="book-Z-H-9.html#%_idx_14">program</a><br />
-    <a href="book-Z-H-26.html#%_idx_4544">as abstract machine</a><br />
-    <a href="book-Z-H-15.html#%_idx_1838">comments in</a><br />
-    <a href="book-Z-H-26.html#%_idx_4540">as data</a><br />
-    <a href="book-Z-H-10.html#%_idx_236">incremental development of</a><br />
-    <a href="book-Z-H-10.html#%_idx_238">structure of</a>, <a href="book-Z-H-10.html#%_idx_566">[2]</a>,
-<a href="book-Z-H-10.html#%_idx_610">[3]</a>,
+<br /><a href="book-Z-H-26.html#__idx_4450"><tt>procedure-body</tt></a><br /><a href="book-Z-H-26.html#__idx_4452"><tt>procedure-environment</tt></a><br /><a href="book-Z-H-26.html#__idx_4448"><tt>procedure-parameters</tt></a><br /><a href="book-Z-H-9.html#__idx_10">process</a><br />
+    <a href="book-Z-H-11.html#__idx_668">iterative</a><br />
+    <a href="book-Z-H-11.html#__idx_676">linear iterative</a><br />
+    <a href="book-Z-H-11.html#__idx_664">linear recursive</a><br />
+    <a href="book-Z-H-11.html#__idx_634">local evolution of</a><br />
+    <a href="book-Z-H-11.html#__idx_754">order of growth of</a><br />
+    <a href="book-Z-H-11.html#__idx_656">recursive</a><br />
+    <a href="book-Z-H-11.html#__idx_756">resources required by</a><br />
+    <a href="book-Z-H-11.html#__idx_650">shape of</a><br />
+    <a href="book-Z-H-11.html#__idx_714">tree-recursive</a><br /><a href="book-Z-H-12.html#__idx_1010"><tt>product</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_1022">as accumulation</a><br /><a href="book-Z-H-16.html#__idx_2078"><tt>product?</tt></a><br /><a href="book-Z-H-9.html#__idx_14">program</a><br />
+    <a href="book-Z-H-26.html#__idx_4544">as abstract machine</a><br />
+    <a href="book-Z-H-15.html#__idx_1838">comments in</a><br />
+    <a href="book-Z-H-26.html#__idx_4540">as data</a><br />
+    <a href="book-Z-H-10.html#__idx_236">incremental development of</a><br />
+    <a href="book-Z-H-10.html#__idx_238">structure of</a>, <a href="book-Z-H-10.html#__idx_566">[2]</a>,
+<a href="book-Z-H-10.html#__idx_610">[3]</a>,
 <em>see also</em> abstraction barriers
 <br />
-    <a href="book-Z-H-26.html#%_idx_4564">structured with subroutines</a><br /><a href="book-Z-H-32.html#%_idx_5664">program counter</a><br />
+    <a href="book-Z-H-26.html#__idx_4564">structured with subroutines</a><br /><a href="book-Z-H-32.html#__idx_5664">program counter</a><br />
 programming
 <br />
     data-directed, <em>see</em> data-directed programming
 <br />
-    <a href="book-Z-H-24.html#%_idx_3792">demand-driven</a><br />
-    <a href="book-Z-H-10.html#%_idx_118">elements of</a><br />
+    <a href="book-Z-H-24.html#__idx_3792">demand-driven</a><br />
+    <a href="book-Z-H-10.html#__idx_118">elements of</a><br />
     functional, <em>see</em> functional programming
 <br />
-    <a href="book-Z-H-20.html#%_idx_3016">imperative</a><br />
-    <a href="book-Z-H-24.html#%_idx_3828">odious style</a><br /><a href="book-Z-H-9.html#%_idx_16">programming language</a><br />
-    <a href="book-Z-H-27.html#%_idx_4670">design of</a><br />
-    <a href="book-Z-H-24.html#%_idx_4158">functional</a><br />
-    <a href="book-Z-H-29.html#%_idx_5078">logic</a><br />
-    <a href="book-Z-H-18.html#%_idx_2624">object-oriented</a><br />
-    <a href="book-Z-H-24.html#%_idx_4104">strongly typed</a><br />
-    <a href="book-Z-H-10.html#%_idx_504">very high-level</a><br /><a href="book-Z-H-28.html#%_idx_4876">Prolog</a>, <a href="book-Z-H-29.html#%_idx_5056">[2]</a><br /><a href="book-Z-H-26.html#%_idx_4534"><tt>prompt-for-input</tt></a><br /><a href="book-Z-H-26.html#%_idx_4520">prompts</a><br />
-    <a href="book-Z-H-34.html#%_idx_6142">explicit-control evaluator</a><br />
-    <a href="book-Z-H-27.html#%_idx_4734">lazy evaluator</a><br />
-    <a href="book-Z-H-26.html#%_idx_4530">metacircular evaluator</a><br />
-    <a href="book-Z-H-28.html#%_idx_5022">nondeterministic evaluator</a><br />
-    <a href="book-Z-H-29.html#%_idx_5292">query interpreter</a><br /><a href="book-Z-H-22.html#%_idx_3426"><tt>propagate</tt></a><br /><a href="book-Z-H-22.html#%_idx_3482">propagation of constraints</a><br /><a href="book-Z-H-10.html#%_idx_502">proving programs correct</a><br /><a href="book-Z-H-20.html#%_idx_2926">pseudo-random sequence</a><br /><a href="book-Z-H-18.html#%_idx_2802">pseudodivision of polynomials</a><br /><a href="book-Z-H-18.html#%_idx_2804">pseudoremainder of polynomials</a><br /><a href="book-Z-H-32.html#%_idx_5654"><tt>push</tt></a><br /><a href="book-Z-H-17.html#%_idx_2438"><tt>put</tt></a>, <a href="book-Z-H-22.html#%_idx_3302">[2]</a><br />
+    <a href="book-Z-H-20.html#__idx_3016">imperative</a><br />
+    <a href="book-Z-H-24.html#__idx_3828">odious style</a><br /><a href="book-Z-H-9.html#__idx_16">programming language</a><br />
+    <a href="book-Z-H-27.html#__idx_4670">design of</a><br />
+    <a href="book-Z-H-24.html#__idx_4158">functional</a><br />
+    <a href="book-Z-H-29.html#__idx_5078">logic</a><br />
+    <a href="book-Z-H-18.html#__idx_2624">object-oriented</a><br />
+    <a href="book-Z-H-24.html#__idx_4104">strongly typed</a><br />
+    <a href="book-Z-H-10.html#__idx_504">very high-level</a><br /><a href="book-Z-H-28.html#__idx_4876">Prolog</a>, <a href="book-Z-H-29.html#__idx_5056">[2]</a><br /><a href="book-Z-H-26.html#__idx_4534"><tt>prompt-for-input</tt></a><br /><a href="book-Z-H-26.html#__idx_4520">prompts</a><br />
+    <a href="book-Z-H-34.html#__idx_6142">explicit-control evaluator</a><br />
+    <a href="book-Z-H-27.html#__idx_4734">lazy evaluator</a><br />
+    <a href="book-Z-H-26.html#__idx_4530">metacircular evaluator</a><br />
+    <a href="book-Z-H-28.html#__idx_5022">nondeterministic evaluator</a><br />
+    <a href="book-Z-H-29.html#__idx_5292">query interpreter</a><br /><a href="book-Z-H-22.html#__idx_3426"><tt>propagate</tt></a><br /><a href="book-Z-H-22.html#__idx_3482">propagation of constraints</a><br /><a href="book-Z-H-10.html#__idx_502">proving programs correct</a><br /><a href="book-Z-H-20.html#__idx_2926">pseudo-random sequence</a><br /><a href="book-Z-H-18.html#__idx_2802">pseudodivision of polynomials</a><br /><a href="book-Z-H-18.html#__idx_2804">pseudoremainder of polynomials</a><br /><a href="book-Z-H-32.html#__idx_5654"><tt>push</tt></a><br /><a href="book-Z-H-17.html#__idx_2438"><tt>put</tt></a>, <a href="book-Z-H-22.html#__idx_3302">[2]</a><br />
 puzzles
 <br />
-    <a href="book-Z-H-15.html#%_idx_1850">eight-queens puzzle</a>,
-<a href="book-Z-H-28.html#%_idx_4948">[2]</a><br />
-    <a href="book-Z-H-28.html#%_idx_4926">logic puzzles</a><br />
+    <a href="book-Z-H-15.html#__idx_1850">eight-queens puzzle</a>,
+<a href="book-Z-H-28.html#__idx_4948">[2]</a><br />
+    <a href="book-Z-H-28.html#__idx_4926">logic puzzles</a><br />
 Pythagorean triples
 <br />
-    <a href="book-Z-H-28.html#%_idx_4912">with nondeterministic programs</a>,
-<a href="book-Z-H-28.html#%_idx_4916">[2]</a>, <a href="book-Z-H-28.html#%_idx_4920">[3]</a><br />
-    <a href="book-Z-H-24.html#%_idx_4004">with streams</a></p><p>
+    <a href="book-Z-H-28.html#__idx_4912">with nondeterministic programs</a>,
+<a href="book-Z-H-28.html#__idx_4916">[2]</a>, <a href="book-Z-H-28.html#__idx_4920">[3]</a><br />
+    <a href="book-Z-H-24.html#__idx_4004">with streams</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-29.html#%_idx_5228"><tt>qeval</tt></a>, <a href="book-Z-H-29.html#%_idx_5310">[2]</a><br /><a href="book-Z-H-24.html#%_idx_4186">quantum mechanics</a><br /><a href="book-Z-H-35.html#%_idx_6284">quasiquote</a><br /><a href="book-Z-H-15.html#%_idx_1852"><tt>queens</tt></a><br /><a href="book-Z-H-29.html#%_idx_5092">query</a>,
+<br /><a href="book-Z-H-29.html#__idx_5228"><tt>qeval</tt></a>, <a href="book-Z-H-29.html#__idx_5310">[2]</a><br /><a href="book-Z-H-24.html#__idx_4186">quantum mechanics</a><br /><a href="book-Z-H-35.html#__idx_6284">quasiquote</a><br /><a href="book-Z-H-15.html#__idx_1852"><tt>queens</tt></a><br /><a href="book-Z-H-29.html#__idx_5092">query</a>,
 <em>see also</em> simple query; compound query
-<br /><a href="book-Z-H-29.html#%_idx_5094">query interpreter</a><br />
-    <a href="book-Z-H-29.html#%_idx_5242">adding rule or assertion</a><br />
+<br /><a href="book-Z-H-29.html#__idx_5094">query interpreter</a><br />
+    <a href="book-Z-H-29.html#__idx_5242">adding rule or assertion</a><br />
     compound query, <em>see</em> compound query
 <br />
-    <a href="book-Z-H-29.html#%_idx_5372">data base</a><br />
-    <a href="book-Z-H-29.html#%_idx_5234">driver loop</a>,
-<a href="book-Z-H-29.html#%_idx_5290">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5452">environment structure in</a><br />
-    <a href="book-Z-H-29.html#%_idx_5178">frame</a>, <a href="book-Z-H-29.html#%_idx_5414">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5282">improvements to</a>,
-<a href="book-Z-H-29.html#%_idx_5426">[2]</a>, <a href="book-Z-H-29.html#%_idx_5432">[3]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5260">infinite loops</a>,
-<a href="book-Z-H-29.html#%_idx_5284">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5302">instantiation</a><br />
-    <a href="book-Z-H-29.html#%_idx_5218">Lisp interpreter vs.</a>,
-<a href="book-Z-H-29.html#%_idx_5230">[2]</a>, <a href="book-Z-H-29.html#%_idx_5446">[3]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5172">overview</a><br />
-    <a href="book-Z-H-29.html#%_idx_5174">pattern matching</a>,
-<a href="book-Z-H-29.html#%_idx_5340">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5300">pattern-variable representation</a>,
-<a href="book-Z-H-29.html#%_idx_5398">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5266">problems with <tt>not</tt> and <tt>lisp-value</tt></a>, <a href="book-Z-H-29.html#%_idx_5434">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5226">query evaluator</a>,
-<a href="book-Z-H-29.html#%_idx_5306">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5372">data base</a><br />
+    <a href="book-Z-H-29.html#__idx_5234">driver loop</a>,
+<a href="book-Z-H-29.html#__idx_5290">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5452">environment structure in</a><br />
+    <a href="book-Z-H-29.html#__idx_5178">frame</a>, <a href="book-Z-H-29.html#__idx_5414">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5282">improvements to</a>,
+<a href="book-Z-H-29.html#__idx_5426">[2]</a>, <a href="book-Z-H-29.html#__idx_5432">[3]</a><br />
+    <a href="book-Z-H-29.html#__idx_5260">infinite loops</a>,
+<a href="book-Z-H-29.html#__idx_5284">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5302">instantiation</a><br />
+    <a href="book-Z-H-29.html#__idx_5218">Lisp interpreter vs.</a>,
+<a href="book-Z-H-29.html#__idx_5230">[2]</a>, <a href="book-Z-H-29.html#__idx_5446">[3]</a><br />
+    <a href="book-Z-H-29.html#__idx_5172">overview</a><br />
+    <a href="book-Z-H-29.html#__idx_5174">pattern matching</a>,
+<a href="book-Z-H-29.html#__idx_5340">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5300">pattern-variable representation</a>,
+<a href="book-Z-H-29.html#__idx_5398">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5266">problems with <tt>not</tt> and <tt>lisp-value</tt></a>, <a href="book-Z-H-29.html#__idx_5434">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5226">query evaluator</a>,
+<a href="book-Z-H-29.html#__idx_5306">[2]</a><br />
     rule, <em>see</em> rule
 <br />
     simple query, <em>see</em> simple query
 <br />
-    <a href="book-Z-H-29.html#%_idx_5384">stream operations</a><br />
-    <a href="book-Z-H-29.html#%_idx_5184">streams of frames</a>,
-<a href="book-Z-H-29.html#%_idx_5238">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5396">syntax of query language</a><br />
-    <a href="book-Z-H-29.html#%_idx_5208">unification</a>,
-<a href="book-Z-H-29.html#%_idx_5360">[2]</a><br /><a href="book-Z-H-29.html#%_idx_5090">query language</a>, <a href="book-Z-H-29.html#%_idx_5096">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5138">abstraction in</a><br />
+    <a href="book-Z-H-29.html#__idx_5384">stream operations</a><br />
+    <a href="book-Z-H-29.html#__idx_5184">streams of frames</a>,
+<a href="book-Z-H-29.html#__idx_5238">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5396">syntax of query language</a><br />
+    <a href="book-Z-H-29.html#__idx_5208">unification</a>,
+<a href="book-Z-H-29.html#__idx_5360">[2]</a><br /><a href="book-Z-H-29.html#__idx_5090">query language</a>, <a href="book-Z-H-29.html#__idx_5096">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5138">abstraction in</a><br />
     compound query, <em>see</em> compound query
 <br />
-    <a href="book-Z-H-29.html#%_idx_5102">data base</a><br />
-    <a href="book-Z-H-29.html#%_idx_5134">equality testing in</a><br />
-    <a href="book-Z-H-29.html#%_idx_5280">extensions to</a>,
-<a href="book-Z-H-29.html#%_idx_5420">[2]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5156">logical deductions</a><br />
-    <a href="book-Z-H-29.html#%_idx_5244">mathematical logic vs.</a><br />
+    <a href="book-Z-H-29.html#__idx_5102">data base</a><br />
+    <a href="book-Z-H-29.html#__idx_5134">equality testing in</a><br />
+    <a href="book-Z-H-29.html#__idx_5280">extensions to</a>,
+<a href="book-Z-H-29.html#__idx_5420">[2]</a><br />
+    <a href="book-Z-H-29.html#__idx_5156">logical deductions</a><br />
+    <a href="book-Z-H-29.html#__idx_5244">mathematical logic vs.</a><br />
     rule, <em>see</em> rule
 <br />
     simple query, <em>see</em> simple query
-<br /><a href="book-Z-H-29.html#%_idx_5294"><tt>query-driver-loop</tt></a><br /><a href="book-Z-H-10.html#%_idx_522">question mark, in predicate names</a><br /><a href="book-Z-H-22.html#%_idx_3220">queue</a><br />
-    <a href="book-Z-H-22.html#%_idx_3264">double-ended</a><br />
-    <a href="book-Z-H-22.html#%_idx_3224">front of</a><br />
-    <a href="book-Z-H-22.html#%_idx_3230">operations on</a><br />
-    <a href="book-Z-H-22.html#%_idx_3262">procedural implementation of</a><br />
-    <a href="book-Z-H-22.html#%_idx_3222">rear of</a><br />
-    <a href="book-Z-H-22.html#%_idx_3440">in simulation agenda</a><br /><a href="book-Z-H-16.html#%_idx_1988">quotation</a><br />
-    <a href="book-Z-H-16.html#%_idx_2004">of character strings</a><br />
-    <a href="book-Z-H-16.html#%_idx_1998">of Lisp data objects</a><br />
-    <a href="book-Z-H-16.html#%_idx_1992">in natural language</a><br /><a href="book-Z-H-16.html#%_idx_2002">quotation mark, single vs. double</a><br /><a href="book-Z-H-16.html#%_idx_2014"><tt>quote</tt> (special form)</a><br />
-    <a href="book-Z-H-26.html#%_idx_4528"><tt>read</tt> and</a>,
-<a href="book-Z-H-29.html#%_idx_5408">[2]</a><br /><a href="book-Z-H-26.html#%_idx_4286"><tt>quoted?</tt></a><br /><a href="book-Z-H-24.html#%_idx_3906"><tt>quotient</tt> (primitive procedure)</a></p><p>
+<br /><a href="book-Z-H-29.html#__idx_5294"><tt>query-driver-loop</tt></a><br /><a href="book-Z-H-10.html#__idx_522">question mark, in predicate names</a><br /><a href="book-Z-H-22.html#__idx_3220">queue</a><br />
+    <a href="book-Z-H-22.html#__idx_3264">double-ended</a><br />
+    <a href="book-Z-H-22.html#__idx_3224">front of</a><br />
+    <a href="book-Z-H-22.html#__idx_3230">operations on</a><br />
+    <a href="book-Z-H-22.html#__idx_3262">procedural implementation of</a><br />
+    <a href="book-Z-H-22.html#__idx_3222">rear of</a><br />
+    <a href="book-Z-H-22.html#__idx_3440">in simulation agenda</a><br /><a href="book-Z-H-16.html#__idx_1988">quotation</a><br />
+    <a href="book-Z-H-16.html#__idx_2004">of character strings</a><br />
+    <a href="book-Z-H-16.html#__idx_1998">of Lisp data objects</a><br />
+    <a href="book-Z-H-16.html#__idx_1992">in natural language</a><br /><a href="book-Z-H-16.html#__idx_2002">quotation mark, single vs. double</a><br /><a href="book-Z-H-16.html#__idx_2014"><tt>quote</tt> (special form)</a><br />
+    <a href="book-Z-H-26.html#__idx_4528"><tt>read</tt> and</a>,
+<a href="book-Z-H-29.html#__idx_5408">[2]</a><br /><a href="book-Z-H-26.html#__idx_4286"><tt>quoted?</tt></a><br /><a href="book-Z-H-24.html#__idx_3906"><tt>quotient</tt> (primitive procedure)</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-11.html#%_idx_958">Rabin, Michael O.</a><br /><a href="book-Z-H-10.html#%_idx_514">radicand</a><br /><a href="book-Z-H-24.html#%_idx_4010">Ramanujan numbers</a><br /><a href="book-Z-H-24.html#%_idx_4014">Ramanujan, Srinivasa</a><br /><a href="book-Z-H-20.html#%_idx_2934"><tt>rand</tt></a><br />
-    <a href="book-Z-H-20.html#%_idx_2974">with reset</a><br /><a href="book-Z-H-11.html#%_idx_900"><tt>random</tt> (primitive procedure)</a><br />
-    <a href="book-Z-H-20.html#%_idx_2852">assignment needed for</a><br />
-    <a href="book-Z-H-20.html#%_idx_2966">MIT Scheme</a><br /><a href="book-Z-H-20.html#%_idx_2970"><tt>random-in-range</tt></a><br /><a href="book-Z-H-20.html#%_idx_2854">random-number generator</a>,
-<a href="book-Z-H-20.html#%_idx_2922">[2]</a><br />
-    <a href="book-Z-H-20.html#%_idx_2938">in Monte Carlo simulation</a><br />
-    <a href="book-Z-H-11.html#%_idx_894">in primality testing</a><br />
-    <a href="book-Z-H-20.html#%_idx_2972">with reset</a><br />
-    <a href="book-Z-H-24.html#%_idx_4136">with reset, stream version</a><br /><a href="book-Z-H-24.html#%_idx_4124"><tt>random-numbers</tt> (infinite stream)</a><br /><a href="book-Z-H-29.html#%_idx_5048">Raphael, Bertram</a><br /><a href="book-Z-H-18.html#%_idx_2526"><tt>rational</tt> package</a><br /><a href="book-Z-H-18.html#%_idx_2776">rational function</a><br />
-    <a href="book-Z-H-18.html#%_idx_2806">reducing to lowest terms</a><br />
+<br /><a href="book-Z-H-11.html#__idx_958">Rabin, Michael O.</a><br /><a href="book-Z-H-10.html#__idx_514">radicand</a><br /><a href="book-Z-H-24.html#__idx_4010">Ramanujan numbers</a><br /><a href="book-Z-H-24.html#__idx_4014">Ramanujan, Srinivasa</a><br /><a href="book-Z-H-20.html#__idx_2934"><tt>rand</tt></a><br />
+    <a href="book-Z-H-20.html#__idx_2974">with reset</a><br /><a href="book-Z-H-11.html#__idx_900"><tt>random</tt> (primitive procedure)</a><br />
+    <a href="book-Z-H-20.html#__idx_2852">assignment needed for</a><br />
+    <a href="book-Z-H-20.html#__idx_2966">MIT Scheme</a><br /><a href="book-Z-H-20.html#__idx_2970"><tt>random-in-range</tt></a><br /><a href="book-Z-H-20.html#__idx_2854">random-number generator</a>,
+<a href="book-Z-H-20.html#__idx_2922">[2]</a><br />
+    <a href="book-Z-H-20.html#__idx_2938">in Monte Carlo simulation</a><br />
+    <a href="book-Z-H-11.html#__idx_894">in primality testing</a><br />
+    <a href="book-Z-H-20.html#__idx_2972">with reset</a><br />
+    <a href="book-Z-H-24.html#__idx_4136">with reset, stream version</a><br /><a href="book-Z-H-24.html#__idx_4124"><tt>random-numbers</tt> (infinite stream)</a><br /><a href="book-Z-H-29.html#__idx_5048">Raphael, Bertram</a><br /><a href="book-Z-H-18.html#__idx_2526"><tt>rational</tt> package</a><br /><a href="book-Z-H-18.html#__idx_2776">rational function</a><br />
+    <a href="book-Z-H-18.html#__idx_2806">reducing to lowest terms</a><br />
 rational number(s)
 <br />
-    <a href="book-Z-H-14.html#%_idx_1296">arithmetic operations on</a><br />
-    <a href="book-Z-H-10.html#%_idx_526">in MIT Scheme</a><br />
-    <a href="book-Z-H-14.html#%_idx_1354">printing</a><br />
-    <a href="book-Z-H-14.html#%_idx_1372">reducing to lowest terms</a>,
-<a href="book-Z-H-14.html#%_idx_1386">[2]</a><br />
-    <a href="book-Z-H-14.html#%_idx_1346">represented as pairs</a><br /><a href="book-Z-H-14.html#%_idx_1298">rational-number arithmetic</a><br />
-    <a href="book-Z-H-18.html#%_idx_2528">interfaced to generic arithmetic system</a><br />
-    <a href="book-Z-H-13.html#%_idx_1260">need for compound data</a><br /><a href="book-Z-H-27.html#%_idx_4678">Raymond, Eric</a>, <a href="book-Z-H-28.html#%_idx_4850">[2]</a><br /><a href="book-Z-H-24.html#%_idx_4028">RC circuit</a><br /><a href="book-Z-H-26.html#%_idx_4522"><tt>read</tt> (primitive procedure)</a><br />
-    <a href="book-Z-H-29.html#%_idx_5352">dotted-tail notation handling by</a><br />
-    <a href="book-Z-H-29.html#%_idx_5404">macro characters</a><br /><a href="book-Z-H-31.html#%_idx_5538"><tt>read</tt> operation in register machine</a><br /><a href="book-Z-H-10.html#%_idx_204">read-eval-print loop</a>,
+    <a href="book-Z-H-14.html#__idx_1296">arithmetic operations on</a><br />
+    <a href="book-Z-H-10.html#__idx_526">in MIT Scheme</a><br />
+    <a href="book-Z-H-14.html#__idx_1354">printing</a><br />
+    <a href="book-Z-H-14.html#__idx_1372">reducing to lowest terms</a>,
+<a href="book-Z-H-14.html#__idx_1386">[2]</a><br />
+    <a href="book-Z-H-14.html#__idx_1346">represented as pairs</a><br /><a href="book-Z-H-14.html#__idx_1298">rational-number arithmetic</a><br />
+    <a href="book-Z-H-18.html#__idx_2528">interfaced to generic arithmetic system</a><br />
+    <a href="book-Z-H-13.html#__idx_1260">need for compound data</a><br /><a href="book-Z-H-27.html#__idx_4678">Raymond, Eric</a>, <a href="book-Z-H-28.html#__idx_4850">[2]</a><br /><a href="book-Z-H-24.html#__idx_4028">RC circuit</a><br /><a href="book-Z-H-26.html#__idx_4522"><tt>read</tt> (primitive procedure)</a><br />
+    <a href="book-Z-H-29.html#__idx_5352">dotted-tail notation handling by</a><br />
+    <a href="book-Z-H-29.html#__idx_5404">macro characters</a><br /><a href="book-Z-H-31.html#__idx_5538"><tt>read</tt> operation in register machine</a><br /><a href="book-Z-H-10.html#__idx_204">read-eval-print loop</a>,
 <em>see also</em> driver loop
-<br /><a href="book-Z-H-34.html#%_idx_6144"><tt>read-eval-print-loop</tt></a><br /><a href="book-Z-H-29.html#%_idx_5402">reader macro character</a><br /><a href="book-Z-H-10.html#%_idx_138">real number</a><br /><tt>real-part</tt>
-<br />
-    <a href="book-Z-H-17.html#%_idx_2464">data-directed</a><br />
-    <a href="book-Z-H-17.html#%_idx_2344">polar representation</a><br />
-    <a href="book-Z-H-17.html#%_idx_2328">rectangular representation</a><br />
-    <a href="book-Z-H-17.html#%_idx_2406">with tagged data</a><br /><a href="book-Z-H-17.html#%_idx_2390"><tt>real-part-polar</tt></a><br /><a href="book-Z-H-17.html#%_idx_2378"><tt>real-part-rectangular</tt></a><br /><a href="book-Z-H-22.html#%_idx_3244"><tt>rear-ptr</tt></a><br /><a href="book-Z-H-32.html#%_idx_5690"><tt>receive</tt> procedure</a><br /><a href="book-Z-H-16.html#%_idx_2204">record, in a data base</a><br /><a href="book-Z-H-14.html#%_idx_1412">rectangle, representing</a><br /><a href="book-Z-H-17.html#%_idx_2446"><tt>rectangular</tt> package</a><br /><a href="book-Z-H-17.html#%_idx_2374"><tt>rectangular?</tt></a><br /><a href="book-Z-H-10.html#%_idx_248">recursion</a><br />
-    <a href="book-Z-H-18.html#%_idx_2722">data-directed</a><br />
-    <a href="book-Z-H-10.html#%_idx_250">expressing complicated process</a><br />
-    <a href="book-Z-H-29.html#%_idx_5150">in rules</a><br />
-    <a href="book-Z-H-15.html#%_idx_1680">in working with trees</a><br /><a href="book-Z-H-9.html#%_idx_26">recursion equations</a><br /><a href="book-Z-H-26.html#%_idx_4568">recursion theory</a><br />
+<br /><a href="book-Z-H-34.html#__idx_6144"><tt>read-eval-print-loop</tt></a><br /><a href="book-Z-H-29.html#__idx_5402">reader macro character</a><br /><a href="book-Z-H-10.html#__idx_138">real number</a><br /><tt>real-part</tt>
+<br />
+    <a href="book-Z-H-17.html#__idx_2464">data-directed</a><br />
+    <a href="book-Z-H-17.html#__idx_2344">polar representation</a><br />
+    <a href="book-Z-H-17.html#__idx_2328">rectangular representation</a><br />
+    <a href="book-Z-H-17.html#__idx_2406">with tagged data</a><br /><a href="book-Z-H-17.html#__idx_2390"><tt>real-part-polar</tt></a><br /><a href="book-Z-H-17.html#__idx_2378"><tt>real-part-rectangular</tt></a><br /><a href="book-Z-H-22.html#__idx_3244"><tt>rear-ptr</tt></a><br /><a href="book-Z-H-32.html#__idx_5690"><tt>receive</tt> procedure</a><br /><a href="book-Z-H-16.html#__idx_2204">record, in a data base</a><br /><a href="book-Z-H-14.html#__idx_1412">rectangle, representing</a><br /><a href="book-Z-H-17.html#__idx_2446"><tt>rectangular</tt> package</a><br /><a href="book-Z-H-17.html#__idx_2374"><tt>rectangular?</tt></a><br /><a href="book-Z-H-10.html#__idx_248">recursion</a><br />
+    <a href="book-Z-H-18.html#__idx_2722">data-directed</a><br />
+    <a href="book-Z-H-10.html#__idx_250">expressing complicated process</a><br />
+    <a href="book-Z-H-29.html#__idx_5150">in rules</a><br />
+    <a href="book-Z-H-15.html#__idx_1680">in working with trees</a><br /><a href="book-Z-H-9.html#__idx_26">recursion equations</a><br /><a href="book-Z-H-26.html#__idx_4568">recursion theory</a><br />
 recursive procedure
 <br />
-    <a href="book-Z-H-10.html#%_idx_564">recursive procedure definition</a><br />
-    <a href="book-Z-H-11.html#%_idx_680">recursive process vs.</a><br />
-    <a href="book-Z-H-26.html#%_idx_4624">specifying without <tt>define</tt></a><br /><a href="book-Z-H-11.html#%_idx_654">recursive process</a><br />
-    <a href="book-Z-H-11.html#%_idx_638">iterative process vs.</a>,
-<a href="book-Z-H-21.html#%_idx_3090">[2]</a>, <a href="book-Z-H-31.html#%_idx_5568">[3]</a>,
-<a href="book-Z-H-35.html#%_idx_6410">[4]</a><br />
-    <a href="book-Z-H-11.html#%_idx_660">linear</a>, <a href="book-Z-H-11.html#%_idx_766">[2]</a><br />
-    <a href="book-Z-H-11.html#%_idx_682">recursive procedure vs.</a><br />
-    <a href="book-Z-H-31.html#%_idx_5564">register machine for</a><br />
-    <a href="book-Z-H-11.html#%_idx_716">tree</a>, <a href="book-Z-H-11.html#%_idx_778">[2]</a><br /><a href="book-Z-H-16.html#%_idx_2174">red-black tree</a><br /><a href="book-Z-H-14.html#%_idx_1374">reducing to lowest terms</a>,
-<a href="book-Z-H-14.html#%_idx_1388">[2]</a>, <a href="book-Z-H-18.html#%_idx_2808">[3]</a><br /><a href="book-Z-H-26.html#%_idx_4380">Rees, Jonathan A.</a>,
-<a href="book-Z-H-26.html#%_idx_4644">[2]</a><br /><a href="book-Z-H-20.html#%_idx_2990">referential transparency</a><br /><a href="book-Z-H-31.html#%_idx_5526"><tt>reg</tt> (in register machine)</a><br />
-    <a href="book-Z-H-32.html#%_idx_5768">simulating</a><br /><a href="book-Z-H-30.html#%_idx_5458">register machine</a><br />
-    <a href="book-Z-H-31.html#%_idx_5536">actions</a><br />
-    <a href="book-Z-H-31.html#%_idx_5466">controller</a><br />
-    <a href="book-Z-H-31.html#%_idx_5486">controller diagram</a><br />
-    <a href="book-Z-H-31.html#%_idx_5464">data paths</a><br />
-    <a href="book-Z-H-31.html#%_idx_5480">data-path diagram</a><br />
-    <a href="book-Z-H-31.html#%_idx_5462">design of</a><br />
-    <a href="book-Z-H-31.html#%_idx_5492">language for describing</a><br />
-    <a href="book-Z-H-32.html#%_idx_5804">monitoring performance</a><br />
-    <a href="book-Z-H-32.html#%_idx_5622">simulator</a><br />
-    <a href="book-Z-H-31.html#%_idx_5562">stack</a><br />
-    <a href="book-Z-H-31.html#%_idx_5550">subroutine</a><br />
-    <a href="book-Z-H-31.html#%_idx_5484">test operation</a><br /><a href="book-Z-H-32.html#%_idx_5658">register table, in simulator</a><br /><a href="book-Z-H-30.html#%_idx_5460">register(s)</a><br />
-    <a href="book-Z-H-32.html#%_idx_5640">representing</a><br />
-    <a href="book-Z-H-32.html#%_idx_5822">tracing</a><br /><a href="book-Z-H-32.html#%_idx_5776"><tt>register-exp</tt></a><br /><a href="book-Z-H-32.html#%_idx_5778"><tt>register-exp-reg</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_564">recursive procedure definition</a><br />
+    <a href="book-Z-H-11.html#__idx_680">recursive process vs.</a><br />
+    <a href="book-Z-H-26.html#__idx_4624">specifying without <tt>define</tt></a><br /><a href="book-Z-H-11.html#__idx_654">recursive process</a><br />
+    <a href="book-Z-H-11.html#__idx_638">iterative process vs.</a>,
+<a href="book-Z-H-21.html#__idx_3090">[2]</a>, <a href="book-Z-H-31.html#__idx_5568">[3]</a>,
+<a href="book-Z-H-35.html#__idx_6410">[4]</a><br />
+    <a href="book-Z-H-11.html#__idx_660">linear</a>, <a href="book-Z-H-11.html#__idx_766">[2]</a><br />
+    <a href="book-Z-H-11.html#__idx_682">recursive procedure vs.</a><br />
+    <a href="book-Z-H-31.html#__idx_5564">register machine for</a><br />
+    <a href="book-Z-H-11.html#__idx_716">tree</a>, <a href="book-Z-H-11.html#__idx_778">[2]</a><br /><a href="book-Z-H-16.html#__idx_2174">red-black tree</a><br /><a href="book-Z-H-14.html#__idx_1374">reducing to lowest terms</a>,
+<a href="book-Z-H-14.html#__idx_1388">[2]</a>, <a href="book-Z-H-18.html#__idx_2808">[3]</a><br /><a href="book-Z-H-26.html#__idx_4380">Rees, Jonathan A.</a>,
+<a href="book-Z-H-26.html#__idx_4644">[2]</a><br /><a href="book-Z-H-20.html#__idx_2990">referential transparency</a><br /><a href="book-Z-H-31.html#__idx_5526"><tt>reg</tt> (in register machine)</a><br />
+    <a href="book-Z-H-32.html#__idx_5768">simulating</a><br /><a href="book-Z-H-30.html#__idx_5458">register machine</a><br />
+    <a href="book-Z-H-31.html#__idx_5536">actions</a><br />
+    <a href="book-Z-H-31.html#__idx_5466">controller</a><br />
+    <a href="book-Z-H-31.html#__idx_5486">controller diagram</a><br />
+    <a href="book-Z-H-31.html#__idx_5464">data paths</a><br />
+    <a href="book-Z-H-31.html#__idx_5480">data-path diagram</a><br />
+    <a href="book-Z-H-31.html#__idx_5462">design of</a><br />
+    <a href="book-Z-H-31.html#__idx_5492">language for describing</a><br />
+    <a href="book-Z-H-32.html#__idx_5804">monitoring performance</a><br />
+    <a href="book-Z-H-32.html#__idx_5622">simulator</a><br />
+    <a href="book-Z-H-31.html#__idx_5562">stack</a><br />
+    <a href="book-Z-H-31.html#__idx_5550">subroutine</a><br />
+    <a href="book-Z-H-31.html#__idx_5484">test operation</a><br /><a href="book-Z-H-32.html#__idx_5658">register table, in simulator</a><br /><a href="book-Z-H-30.html#__idx_5460">register(s)</a><br />
+    <a href="book-Z-H-32.html#__idx_5640">representing</a><br />
+    <a href="book-Z-H-32.html#__idx_5822">tracing</a><br /><a href="book-Z-H-32.html#__idx_5776"><tt>register-exp</tt></a><br /><a href="book-Z-H-32.html#__idx_5778"><tt>register-exp-reg</tt></a><br />
 register-machine language
 <br />
-    <a href="book-Z-H-31.html#%_idx_5516"><tt>assign</tt></a>,
-<a href="book-Z-H-31.html#%_idx_5598">[2]</a><br />
-    <a href="book-Z-H-31.html#%_idx_5504"><tt>branch</tt></a>,
-<a href="book-Z-H-31.html#%_idx_5606">[2]</a><br />
-    <a href="book-Z-H-31.html#%_idx_5528"><tt>const</tt></a>,
-<a href="book-Z-H-31.html#%_idx_5596">[2]</a>, <a href="book-Z-H-31.html#%_idx_5616">[3]</a><br />
-    <a href="book-Z-H-31.html#%_idx_5498">entry point</a><br />
-    <a href="book-Z-H-31.html#%_idx_5512"><tt>goto</tt></a>, <a href="book-Z-H-31.html#%_idx_5610">[2]</a><br />
-    <a href="book-Z-H-31.html#%_idx_5494">instructions</a>,
-<a href="book-Z-H-31.html#%_idx_5592">[2]</a><br />
-    <a href="book-Z-H-31.html#%_idx_5496">label</a><br />
-    <a href="book-Z-H-31.html#%_idx_5508"><tt>label</tt></a>,
-<a href="book-Z-H-31.html#%_idx_5608">[2]</a><br />
-    <a href="book-Z-H-31.html#%_idx_5520"><tt>op</tt></a>, <a href="book-Z-H-31.html#%_idx_5600">[2]</a><br />
-    <a href="book-Z-H-31.html#%_idx_5542"><tt>perform</tt></a>,
-<a href="book-Z-H-31.html#%_idx_5602">[2]</a><br />
-    <a href="book-Z-H-31.html#%_idx_5524"><tt>reg</tt></a>, <a href="book-Z-H-31.html#%_idx_5594">[2]</a><br />
-    <a href="book-Z-H-31.html#%_idx_5578"><tt>restore</tt></a>,
-<a href="book-Z-H-31.html#%_idx_5614">[2]</a><br />
-    <a href="book-Z-H-31.html#%_idx_5574"><tt>save</tt></a>, <a href="book-Z-H-31.html#%_idx_5612">[2]</a><br />
-    <a href="book-Z-H-31.html#%_idx_5500"><tt>test</tt></a>, <a href="book-Z-H-31.html#%_idx_5604">[2]</a><br /><a href="book-Z-H-32.html#%_idx_5624">register-machine simulator</a><br /><a href="book-Z-H-35.html#%_idx_6382"><tt>registers-modified</tt></a><br /><a href="book-Z-H-35.html#%_idx_6380"><tt>registers-needed</tt></a><br /><a href="book-Z-H-22.html#%_idx_3508">relations, computing in terms of</a>,
-<a href="book-Z-H-29.html#%_idx_5038">[2]</a><br /><a href="book-Z-H-12.html#%_idx_1028">relatively prime</a><br /><a href="book-Z-H-23.html#%_idx_3724">relativity, theory of</a><br /><a href="book-Z-H-23.html#%_idx_3644">release a mutex</a><br /><a href="book-Z-H-11.html#%_idx_800"><tt>remainder</tt> (primitive procedure)</a><br /><a href="book-Z-H-11.html#%_idx_890">remainder modulo <em>n</em></a><br /><a href="book-Z-H-18.html#%_idx_2796"><tt>remainder-terms</tt></a><br /><a href="book-Z-H-15.html#%_idx_1842"><tt>remove</tt></a><br /><a href="book-Z-H-22.html#%_idx_3418"><tt>remove-first-agenda-item!</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3478">[2]</a><br /><a href="book-Z-H-28.html#%_idx_4828"><tt>require</tt></a><br />
-    <a href="book-Z-H-28.html#%_idx_5026">as a special form</a><br /><a href="book-Z-H-35.html#%_idx_6426">reserved words</a>, <a href="book-Z-H-35.html#%_idx_6462">[2]</a><br />
+    <a href="book-Z-H-31.html#__idx_5516"><tt>assign</tt></a>,
+<a href="book-Z-H-31.html#__idx_5598">[2]</a><br />
+    <a href="book-Z-H-31.html#__idx_5504"><tt>branch</tt></a>,
+<a href="book-Z-H-31.html#__idx_5606">[2]</a><br />
+    <a href="book-Z-H-31.html#__idx_5528"><tt>const</tt></a>,
+<a href="book-Z-H-31.html#__idx_5596">[2]</a>, <a href="book-Z-H-31.html#__idx_5616">[3]</a><br />
+    <a href="book-Z-H-31.html#__idx_5498">entry point</a><br />
+    <a href="book-Z-H-31.html#__idx_5512"><tt>goto</tt></a>, <a href="book-Z-H-31.html#__idx_5610">[2]</a><br />
+    <a href="book-Z-H-31.html#__idx_5494">instructions</a>,
+<a href="book-Z-H-31.html#__idx_5592">[2]</a><br />
+    <a href="book-Z-H-31.html#__idx_5496">label</a><br />
+    <a href="book-Z-H-31.html#__idx_5508"><tt>label</tt></a>,
+<a href="book-Z-H-31.html#__idx_5608">[2]</a><br />
+    <a href="book-Z-H-31.html#__idx_5520"><tt>op</tt></a>, <a href="book-Z-H-31.html#__idx_5600">[2]</a><br />
+    <a href="book-Z-H-31.html#__idx_5542"><tt>perform</tt></a>,
+<a href="book-Z-H-31.html#__idx_5602">[2]</a><br />
+    <a href="book-Z-H-31.html#__idx_5524"><tt>reg</tt></a>, <a href="book-Z-H-31.html#__idx_5594">[2]</a><br />
+    <a href="book-Z-H-31.html#__idx_5578"><tt>restore</tt></a>,
+<a href="book-Z-H-31.html#__idx_5614">[2]</a><br />
+    <a href="book-Z-H-31.html#__idx_5574"><tt>save</tt></a>, <a href="book-Z-H-31.html#__idx_5612">[2]</a><br />
+    <a href="book-Z-H-31.html#__idx_5500"><tt>test</tt></a>, <a href="book-Z-H-31.html#__idx_5604">[2]</a><br /><a href="book-Z-H-32.html#__idx_5624">register-machine simulator</a><br /><a href="book-Z-H-35.html#__idx_6382"><tt>registers-modified</tt></a><br /><a href="book-Z-H-35.html#__idx_6380"><tt>registers-needed</tt></a><br /><a href="book-Z-H-22.html#__idx_3508">relations, computing in terms of</a>,
+<a href="book-Z-H-29.html#__idx_5038">[2]</a><br /><a href="book-Z-H-12.html#__idx_1028">relatively prime</a><br /><a href="book-Z-H-23.html#__idx_3724">relativity, theory of</a><br /><a href="book-Z-H-23.html#__idx_3644">release a mutex</a><br /><a href="book-Z-H-11.html#__idx_800"><tt>remainder</tt> (primitive procedure)</a><br /><a href="book-Z-H-11.html#__idx_890">remainder modulo <em>n</em></a><br /><a href="book-Z-H-18.html#__idx_2796"><tt>remainder-terms</tt></a><br /><a href="book-Z-H-15.html#__idx_1842"><tt>remove</tt></a><br /><a href="book-Z-H-22.html#__idx_3418"><tt>remove-first-agenda-item!</tt></a>,
+<a href="book-Z-H-22.html#__idx_3478">[2]</a><br /><a href="book-Z-H-28.html#__idx_4828"><tt>require</tt></a><br />
+    <a href="book-Z-H-28.html#__idx_5026">as a special form</a><br /><a href="book-Z-H-35.html#__idx_6426">reserved words</a>, <a href="book-Z-H-35.html#__idx_6462">[2]</a><br />
 resistance
 <br />
-    <a href="book-Z-H-14.html#%_idx_1482">formula for parallel resistors</a>,
-<a href="book-Z-H-14.html#%_idx_1524">[2]</a><br />
-    <a href="book-Z-H-14.html#%_idx_1484">tolerance of resistors</a><br /><a href="book-Z-H-29.html#%_idx_5046">resolution principle</a><br /><a href="book-Z-H-29.html#%_idx_5060">resolution, Horn-clause</a><br /><a href="book-Z-H-26.html#%_idx_4334"><tt>rest-exps</tt></a><br /><a href="book-Z-H-26.html#%_idx_4350"><tt>rest-operands</tt></a><br /><a href="book-Z-H-22.html#%_idx_3468"><tt>rest-segments</tt></a><br /><a href="book-Z-H-18.html#%_idx_2700"><tt>rest-terms</tt></a>,
-<a href="book-Z-H-18.html#%_idx_2740">[2]</a><br /><a href="book-Z-H-31.html#%_idx_5580"><tt>restore</tt> (in register machine)</a>,
-<a href="book-Z-H-32.html#%_idx_5800">[2]</a><br />
-    <a href="book-Z-H-33.html#%_idx_5922">implementing</a><br />
-    <a href="book-Z-H-32.html#%_idx_5758">simulating</a><br /><a href="book-Z-H-35.html#%_idx_6254"><tt>return</tt> (linkage descriptor)</a><br /><a href="book-Z-H-32.html#%_idx_5696">returning multiple values</a><br /><a href="book-Z-H-23.html#%_idx_3706">Reuter, Andreas</a><br /><a href="book-Z-H-15.html#%_idx_1642"><tt>reverse</tt></a><br />
-    <a href="book-Z-H-15.html#%_idx_1816">as folding</a><br />
-    <a href="book-Z-H-29.html#%_idx_5286">rules</a><br /><a href="book-Z-H-11.html#%_idx_824">Rhind Papyrus</a><br /><a href="book-Z-H-16.html#%_idx_2156"><tt>right-branch</tt></a>,
-<a href="book-Z-H-16.html#%_idx_2262">[2]</a><br /><a href="book-Z-H-15.html#%_idx_1890"><tt>right-split</tt></a><br /><a href="book-Z-H-22.html#%_idx_3388">ripple-carry adder</a><br /><a href="book-Z-H-11.html#%_idx_922">Rivest, Ronald L.</a>,
-<a href="book-Z-H-16.html#%_idx_2180">[2]</a><br /><a href="book-Z-H-24.html#%_idx_4086">RLC circuit</a><br /><a href="book-Z-H-29.html#%_idx_5068">Robinson, J. A.</a><br /><a href="book-Z-H-15.html#%_idx_1982">robustness</a><br /><a href="book-Z-H-16.html#%_idx_2282">rock songs, 1950s</a><br /><a href="book-Z-H-15.html#%_idx_1868">Rogers, William Barton</a><br /><a href="book-Z-H-33.html#%_idx_5966"><tt>root</tt> register</a><br />
+    <a href="book-Z-H-14.html#__idx_1482">formula for parallel resistors</a>,
+<a href="book-Z-H-14.html#__idx_1524">[2]</a><br />
+    <a href="book-Z-H-14.html#__idx_1484">tolerance of resistors</a><br /><a href="book-Z-H-29.html#__idx_5046">resolution principle</a><br /><a href="book-Z-H-29.html#__idx_5060">resolution, Horn-clause</a><br /><a href="book-Z-H-26.html#__idx_4334"><tt>rest-exps</tt></a><br /><a href="book-Z-H-26.html#__idx_4350"><tt>rest-operands</tt></a><br /><a href="book-Z-H-22.html#__idx_3468"><tt>rest-segments</tt></a><br /><a href="book-Z-H-18.html#__idx_2700"><tt>rest-terms</tt></a>,
+<a href="book-Z-H-18.html#__idx_2740">[2]</a><br /><a href="book-Z-H-31.html#__idx_5580"><tt>restore</tt> (in register machine)</a>,
+<a href="book-Z-H-32.html#__idx_5800">[2]</a><br />
+    <a href="book-Z-H-33.html#__idx_5922">implementing</a><br />
+    <a href="book-Z-H-32.html#__idx_5758">simulating</a><br /><a href="book-Z-H-35.html#__idx_6254"><tt>return</tt> (linkage descriptor)</a><br /><a href="book-Z-H-32.html#__idx_5696">returning multiple values</a><br /><a href="book-Z-H-23.html#__idx_3706">Reuter, Andreas</a><br /><a href="book-Z-H-15.html#__idx_1642"><tt>reverse</tt></a><br />
+    <a href="book-Z-H-15.html#__idx_1816">as folding</a><br />
+    <a href="book-Z-H-29.html#__idx_5286">rules</a><br /><a href="book-Z-H-11.html#__idx_824">Rhind Papyrus</a><br /><a href="book-Z-H-16.html#__idx_2156"><tt>right-branch</tt></a>,
+<a href="book-Z-H-16.html#__idx_2262">[2]</a><br /><a href="book-Z-H-15.html#__idx_1890"><tt>right-split</tt></a><br /><a href="book-Z-H-22.html#__idx_3388">ripple-carry adder</a><br /><a href="book-Z-H-11.html#__idx_922">Rivest, Ronald L.</a>,
+<a href="book-Z-H-16.html#__idx_2180">[2]</a><br /><a href="book-Z-H-24.html#__idx_4086">RLC circuit</a><br /><a href="book-Z-H-29.html#__idx_5068">Robinson, J. A.</a><br /><a href="book-Z-H-15.html#__idx_1982">robustness</a><br /><a href="book-Z-H-16.html#__idx_2282">rock songs, 1950s</a><br /><a href="book-Z-H-15.html#__idx_1868">Rogers, William Barton</a><br /><a href="book-Z-H-33.html#__idx_5966"><tt>root</tt> register</a><br />
 roots of equation, <em>see</em> half-interval method; Newton's method
-<br /><a href="book-Z-H-15.html#%_idx_1968"><tt>rotate90</tt></a><br /><a href="book-Z-H-18.html#%_idx_2642"><tt>round</tt> (primitive procedure)</a><br /><a href="book-Z-H-10.html#%_idx_144">roundoff error</a>, <a href="book-Z-H-17.html#%_idx_2308">[2]</a><br /><a href="book-Z-H-35.html#%_idx_6370">Rozas, Guillermo Juan</a><br /><a href="book-Z-H-11.html#%_idx_928">RSA algorithm</a><br /><a href="book-Z-H-29.html#%_idx_5136">rule (query language)</a><br />
-    <a href="book-Z-H-29.html#%_idx_5216">applying</a>, <a href="book-Z-H-29.html#%_idx_5356">[2]</a>,
-<a href="book-Z-H-29.html#%_idx_5454">[3]</a><br />
-    <a href="book-Z-H-29.html#%_idx_5146">without body</a>,
-<a href="book-Z-H-29.html#%_idx_5160">[2]</a>, <a href="book-Z-H-29.html#%_idx_5336">[3]</a><br /><a href="book-Z-H-15.html#%_idx_1870">Runkle, John Daniel</a><br /><a href="book-Z-H-11.html#%_idx_932"><tt>runtime</tt> (primitive procedure)</a><br /><a href="book-Z-H-11.html#%_idx_820">Russian peasant method of multiplication</a></p><p>
+<br /><a href="book-Z-H-15.html#__idx_1968"><tt>rotate90</tt></a><br /><a href="book-Z-H-18.html#__idx_2642"><tt>round</tt> (primitive procedure)</a><br /><a href="book-Z-H-10.html#__idx_144">roundoff error</a>, <a href="book-Z-H-17.html#__idx_2308">[2]</a><br /><a href="book-Z-H-35.html#__idx_6370">Rozas, Guillermo Juan</a><br /><a href="book-Z-H-11.html#__idx_928">RSA algorithm</a><br /><a href="book-Z-H-29.html#__idx_5136">rule (query language)</a><br />
+    <a href="book-Z-H-29.html#__idx_5216">applying</a>, <a href="book-Z-H-29.html#__idx_5356">[2]</a>,
+<a href="book-Z-H-29.html#__idx_5454">[3]</a><br />
+    <a href="book-Z-H-29.html#__idx_5146">without body</a>,
+<a href="book-Z-H-29.html#__idx_5160">[2]</a>, <a href="book-Z-H-29.html#__idx_5336">[3]</a><br /><a href="book-Z-H-15.html#__idx_1870">Runkle, John Daniel</a><br /><a href="book-Z-H-11.html#__idx_932"><tt>runtime</tt> (primitive procedure)</a><br /><a href="book-Z-H-11.html#__idx_820">Russian peasant method of multiplication</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-29.html#%_idx_5142"><tt>same</tt> (rule)</a><br /><a href="book-Z-H-16.html#%_idx_2066"><tt>same-variable?</tt></a>,
-<a href="book-Z-H-18.html#%_idx_2668">[2]</a><br />
+<br /><a href="book-Z-H-29.html#__idx_5142"><tt>same</tt> (rule)</a><br /><a href="book-Z-H-16.html#__idx_2066"><tt>same-variable?</tt></a>,
+<a href="book-Z-H-18.html#__idx_2668">[2]</a><br />
 sameness and change
 <br />
-    <a href="book-Z-H-20.html#%_idx_2986">meaning of</a><br />
-    <a href="book-Z-H-22.html#%_idx_3180">shared data and</a><br /><a href="book-Z-H-29.html#%_idx_5126">satisfy a compound query</a><br /><a href="book-Z-H-29.html#%_idx_5118">satisfy a pattern (simple query)</a><br /><a href="book-Z-H-31.html#%_idx_5576"><tt>save</tt> (in register machine)</a>,
-<a href="book-Z-H-32.html#%_idx_5802">[2]</a><br />
-    <a href="book-Z-H-33.html#%_idx_5920">implementing</a><br />
-    <a href="book-Z-H-32.html#%_idx_5752">simulating</a><br /><a href="book-Z-H-15.html#%_idx_1662"><tt>scale-list</tt></a>,
-<a href="book-Z-H-15.html#%_idx_1668">[2]</a>, <a href="book-Z-H-27.html#%_idx_4784">[3]</a><br /><a href="book-Z-H-24.html#%_idx_3870"><tt>scale-stream</tt></a><br /><a href="book-Z-H-15.html#%_idx_1708"><tt>scale-tree</tt></a>,
-<a href="book-Z-H-15.html#%_idx_1710">[2]</a><br /><a href="book-Z-H-15.html#%_idx_1942"><tt>scale-vect</tt></a><br /><a href="book-Z-H-33.html#%_idx_5978"><tt>scan</tt> register</a><br /><a href="book-Z-H-26.html#%_idx_4614"><tt>scan-out-defines</tt></a><br /><a href="book-Z-H-26.html#%_idx_4606">scanning out internal definitions</a><br />
-    <a href="book-Z-H-35.html#%_idx_6446">in compiler</a>,
-<a href="book-Z-H-35.html#%_idx_6454">[2]</a><br /><a href="book-Z-H-9.html#%_idx_42">Scheme</a><br />
-    <a href="book-Z-H-9.html#%_idx_86">history of</a><br /><a href="book-Z-H-34.html#%_idx_5998">Scheme chip</a>, <a href="book-Z-H-34.html#%_idx_6010">[2]</a><br /><a href="book-Z-H-18.html#%_idx_2518"><tt>scheme-number</tt> package</a><br /><a href="book-Z-H-18.html#%_idx_2584"><tt>scheme-number-&gt;complex</tt></a><br /><a href="book-Z-H-18.html#%_idx_2628"><tt>scheme-number-&gt;scheme-number</tt></a><br /><a href="book-Z-H-20.html#%_idx_3010">Schmidt, Eric</a><br /><a href="book-Z-H-10.html#%_idx_594">scope of a variable</a>,
+    <a href="book-Z-H-20.html#__idx_2986">meaning of</a><br />
+    <a href="book-Z-H-22.html#__idx_3180">shared data and</a><br /><a href="book-Z-H-29.html#__idx_5126">satisfy a compound query</a><br /><a href="book-Z-H-29.html#__idx_5118">satisfy a pattern (simple query)</a><br /><a href="book-Z-H-31.html#__idx_5576"><tt>save</tt> (in register machine)</a>,
+<a href="book-Z-H-32.html#__idx_5802">[2]</a><br />
+    <a href="book-Z-H-33.html#__idx_5920">implementing</a><br />
+    <a href="book-Z-H-32.html#__idx_5752">simulating</a><br /><a href="book-Z-H-15.html#__idx_1662"><tt>scale-list</tt></a>,
+<a href="book-Z-H-15.html#__idx_1668">[2]</a>, <a href="book-Z-H-27.html#__idx_4784">[3]</a><br /><a href="book-Z-H-24.html#__idx_3870"><tt>scale-stream</tt></a><br /><a href="book-Z-H-15.html#__idx_1708"><tt>scale-tree</tt></a>,
+<a href="book-Z-H-15.html#__idx_1710">[2]</a><br /><a href="book-Z-H-15.html#__idx_1942"><tt>scale-vect</tt></a><br /><a href="book-Z-H-33.html#__idx_5978"><tt>scan</tt> register</a><br /><a href="book-Z-H-26.html#__idx_4614"><tt>scan-out-defines</tt></a><br /><a href="book-Z-H-26.html#__idx_4606">scanning out internal definitions</a><br />
+    <a href="book-Z-H-35.html#__idx_6446">in compiler</a>,
+<a href="book-Z-H-35.html#__idx_6454">[2]</a><br /><a href="book-Z-H-9.html#__idx_42">Scheme</a><br />
+    <a href="book-Z-H-9.html#__idx_86">history of</a><br /><a href="book-Z-H-34.html#__idx_5998">Scheme chip</a>, <a href="book-Z-H-34.html#__idx_6010">[2]</a><br /><a href="book-Z-H-18.html#__idx_2518"><tt>scheme-number</tt> package</a><br /><a href="book-Z-H-18.html#__idx_2584"><tt>scheme-number-&gt;complex</tt></a><br /><a href="book-Z-H-18.html#__idx_2628"><tt>scheme-number-&gt;scheme-number</tt></a><br /><a href="book-Z-H-20.html#__idx_3010">Schmidt, Eric</a><br /><a href="book-Z-H-10.html#__idx_594">scope of a variable</a>,
 <em>see also</em> lexical scoping
 <br />
-    <a href="book-Z-H-26.html#%_idx_4602">internal <tt>define</tt></a><br />
-    <a href="book-Z-H-12.html#%_idx_1072">in <tt>let</tt></a><br />
-    <a href="book-Z-H-10.html#%_idx_602">procedure's formal parameters</a><br />
+    <a href="book-Z-H-26.html#__idx_4602">internal <tt>define</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_1072">in <tt>let</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_602">procedure's formal parameters</a><br />
 search
 <br />
-    <a href="book-Z-H-16.html#%_idx_2146">of binary tree</a><br />
-    <a href="book-Z-H-28.html#%_idx_4856">depth-first</a><br />
-    <a href="book-Z-H-28.html#%_idx_4844">systematic</a><br /><a href="book-Z-H-12.html#%_idx_1084"><tt>search</tt></a><br /><a href="book-Z-H-29.html#%_idx_5108">secretary, importance of</a><br /><a href="book-Z-H-22.html#%_idx_3446"><tt>segment-queue</tt></a><br /><a href="book-Z-H-22.html#%_idx_3444"><tt>segment-time</tt></a><br /><a href="book-Z-H-22.html#%_idx_3462"><tt>segments</tt></a><br /><a href="book-Z-H-15.html#%_idx_1950"><tt>segments-&gt;painter</tt></a><br /><a href="book-Z-H-14.html#%_idx_1290">selector</a><br />
-    <a href="book-Z-H-14.html#%_idx_1384">as abstraction barrier</a><br />
-    <a href="book-Z-H-17.html#%_idx_2402">generic</a>, <a href="book-Z-H-17.html#%_idx_2420">[2]</a><br /><a href="book-Z-H-26.html#%_idx_4240">self-evaluating expression</a><br /><a href="book-Z-H-26.html#%_idx_4282"><tt>self-evaluating?</tt></a><br /><a href="book-Z-H-23.html#%_idx_3648">semaphore</a><br />
-    <a href="book-Z-H-23.html#%_idx_3692">of size <em>n</em></a><br /><a href="book-Z-H-10.html#%_idx_284">semicolon</a><br />
-    <a href="book-Z-H-15.html#%_idx_1834">comment introduced by</a><br /><a href="book-Z-H-16.html#%_idx_2232">separator code</a><br /><a href="book-Z-H-24.html#%_idx_3966">sequence accelerator</a><br />
+    <a href="book-Z-H-16.html#__idx_2146">of binary tree</a><br />
+    <a href="book-Z-H-28.html#__idx_4856">depth-first</a><br />
+    <a href="book-Z-H-28.html#__idx_4844">systematic</a><br /><a href="book-Z-H-12.html#__idx_1084"><tt>search</tt></a><br /><a href="book-Z-H-29.html#__idx_5108">secretary, importance of</a><br /><a href="book-Z-H-22.html#__idx_3446"><tt>segment-queue</tt></a><br /><a href="book-Z-H-22.html#__idx_3444"><tt>segment-time</tt></a><br /><a href="book-Z-H-22.html#__idx_3462"><tt>segments</tt></a><br /><a href="book-Z-H-15.html#__idx_1950"><tt>segments-&gt;painter</tt></a><br /><a href="book-Z-H-14.html#__idx_1290">selector</a><br />
+    <a href="book-Z-H-14.html#__idx_1384">as abstraction barrier</a><br />
+    <a href="book-Z-H-17.html#__idx_2402">generic</a>, <a href="book-Z-H-17.html#__idx_2420">[2]</a><br /><a href="book-Z-H-26.html#__idx_4240">self-evaluating expression</a><br /><a href="book-Z-H-26.html#__idx_4282"><tt>self-evaluating?</tt></a><br /><a href="book-Z-H-23.html#__idx_3648">semaphore</a><br />
+    <a href="book-Z-H-23.html#__idx_3692">of size <em>n</em></a><br /><a href="book-Z-H-10.html#__idx_284">semicolon</a><br />
+    <a href="book-Z-H-15.html#__idx_1834">comment introduced by</a><br /><a href="book-Z-H-16.html#__idx_2232">separator code</a><br /><a href="book-Z-H-24.html#__idx_3966">sequence accelerator</a><br />
 sequence of expressions
 <br />
-    <a href="book-Z-H-10.html#%_idx_444">in consequent of <tt>cond</tt></a><br />
-    <a href="book-Z-H-10.html#%_idx_326">in procedure body</a><br /><a href="book-Z-H-15.html#%_idx_1554">sequence(s)</a><br />
-    <a href="book-Z-H-15.html#%_idx_1718">as conventional interface</a><br />
-    <a href="book-Z-H-15.html#%_idx_1758">as source of modularity</a><br />
-    <a href="book-Z-H-15.html#%_idx_1738">operations on</a><br />
-    <a href="book-Z-H-15.html#%_idx_1556">represented by pairs</a><br /><a href="book-Z-H-26.html#%_idx_4336"><tt>sequence-&gt;exp</tt></a><br /><a href="book-Z-H-23.html#%_idx_3634"><tt>serialized-exchange</tt></a><br />
-    <a href="book-Z-H-23.html#%_idx_3708">with deadlock avoidance</a><br /><a href="book-Z-H-23.html#%_idx_3610">serializer</a><br />
-    <a href="book-Z-H-23.html#%_idx_3638">implementing</a><br />
-    <a href="book-Z-H-23.html#%_idx_3622">with multiple shared resources</a><br /><a href="book-Z-H-12.html#%_idx_982">series, summation of</a><br />
-    <a href="book-Z-H-24.html#%_idx_3964">accelerating sequence of approximations</a><br />
-    <a href="book-Z-H-24.html#%_idx_3956">with streams</a><br /><a href="book-Z-H-16.html#%_idx_2100">set</a><br />
+    <a href="book-Z-H-10.html#__idx_444">in consequent of <tt>cond</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_326">in procedure body</a><br /><a href="book-Z-H-15.html#__idx_1554">sequence(s)</a><br />
+    <a href="book-Z-H-15.html#__idx_1718">as conventional interface</a><br />
+    <a href="book-Z-H-15.html#__idx_1758">as source of modularity</a><br />
+    <a href="book-Z-H-15.html#__idx_1738">operations on</a><br />
+    <a href="book-Z-H-15.html#__idx_1556">represented by pairs</a><br /><a href="book-Z-H-26.html#__idx_4336"><tt>sequence-&gt;exp</tt></a><br /><a href="book-Z-H-23.html#__idx_3634"><tt>serialized-exchange</tt></a><br />
+    <a href="book-Z-H-23.html#__idx_3708">with deadlock avoidance</a><br /><a href="book-Z-H-23.html#__idx_3610">serializer</a><br />
+    <a href="book-Z-H-23.html#__idx_3638">implementing</a><br />
+    <a href="book-Z-H-23.html#__idx_3622">with multiple shared resources</a><br /><a href="book-Z-H-12.html#__idx_982">series, summation of</a><br />
+    <a href="book-Z-H-24.html#__idx_3964">accelerating sequence of approximations</a><br />
+    <a href="book-Z-H-24.html#__idx_3956">with streams</a><br /><a href="book-Z-H-16.html#__idx_2100">set</a><br />
     <tt>set
 <br />
         </tt> (special form), <em>see also</em> assignment
 <br />
-    <a href="book-Z-H-16.html#%_idx_2200">data base as</a><br />
-    <a href="book-Z-H-16.html#%_idx_2102">operations on</a><br />
-    <a href="book-Z-H-15.html#%_idx_1830">permutations of</a><br />
-    <a href="book-Z-H-16.html#%_idx_2136">represented as binary tree</a><br />
-    <a href="book-Z-H-16.html#%_idx_2124">represented as ordered list</a><br />
-    <a href="book-Z-H-16.html#%_idx_2112">represented as unordered list</a><br />
-    <a href="book-Z-H-15.html#%_idx_1714">subsets of</a><br /><a href="book-Z-H-20.html#%_idx_2860"><tt>set!</tt> (special form)</a><br />
-    <a href="book-Z-H-21.html#%_idx_3080">environment model of</a><br />
-    <a href="book-Z-H-20.html#%_idx_2864">value of</a><br /><a href="book-Z-H-22.html#%_idx_3140"><tt>set-car!</tt> (primitive procedure)</a><br />
-    <a href="book-Z-H-33.html#%_idx_5900">implemented with vectors</a><br />
-    <a href="book-Z-H-22.html#%_idx_3216">procedural implementation of</a><br />
-    <a href="book-Z-H-22.html#%_idx_3148">value of</a><br /><a href="book-Z-H-22.html#%_idx_3144"><tt>set-cdr!</tt> (primitive procedure)</a><br />
-    <a href="book-Z-H-33.html#%_idx_5902">implemented with vectors</a><br />
-    <a href="book-Z-H-22.html#%_idx_3218">procedural implementation of</a><br />
-    <a href="book-Z-H-22.html#%_idx_3152">value of</a><br /><a href="book-Z-H-32.html#%_idx_5646"><tt>set-contents!</tt></a><br /><a href="book-Z-H-22.html#%_idx_3460"><tt>set-current-time!</tt></a><br /><a href="book-Z-H-22.html#%_idx_3246"><tt>set-front-ptr!</tt></a><br /><a href="book-Z-H-32.html#%_idx_5710"><tt>set-instruction-execution-proc!</tt></a><br /><a href="book-Z-H-22.html#%_idx_3248"><tt>set-rear-ptr!</tt></a><br /><a href="book-Z-H-32.html#%_idx_5628"><tt>set-register-contents!</tt></a>,
-<a href="book-Z-H-32.html#%_idx_5678">[2]</a><br /><a href="book-Z-H-22.html#%_idx_3464"><tt>set-segments!</tt></a><br /><a href="book-Z-H-22.html#%_idx_3372"><tt>set-signal!</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3406">[2]</a><br /><a href="book-Z-H-22.html#%_idx_3526"><tt>set-value!</tt></a>,
-<a href="book-Z-H-22.html#%_idx_3554">[2]</a><br /><a href="book-Z-H-26.html#%_idx_4462"><tt>set-variable-value!</tt></a>,
-<a href="book-Z-H-26.html#%_idx_4482">[2]</a><br /><a href="book-Z-H-26.html#%_idx_4502"><tt>setup-environment</tt></a><br /><a href="book-Z-H-21.html#%_idx_3060">shadow a binding</a><br /><a href="book-Z-H-11.html#%_idx_924">Shamir, Adi</a><br /><a href="book-Z-H-11.html#%_idx_648">shape of a process</a><br /><a href="book-Z-H-22.html#%_idx_3178">shared data</a><br /><a href="book-Z-H-23.html#%_idx_3624">shared resources</a><br /><a href="book-Z-H-23.html#%_idx_3598">shared state</a><br /><a href="book-Z-H-15.html#%_idx_1966"><tt>shrink-to-upper-right</tt></a><br /><a href="book-Z-H-29.html#%_idx_5088">Shrobe, Howard E.</a><br /><a href="book-Z-H-20.html#%_idx_3000">side-effect bug</a><br /><a href="book-Z-H-24.html#%_idx_3844">sieve of Eratosthenes</a><br />
-    <a href="book-Z-H-24.html#%_idx_3852"><tt>sieve</tt></a><br /><a href="book-Z-H-12.html#%_idx_988">sum  (sigma) notation</a><br />
+    <a href="book-Z-H-16.html#__idx_2200">data base as</a><br />
+    <a href="book-Z-H-16.html#__idx_2102">operations on</a><br />
+    <a href="book-Z-H-15.html#__idx_1830">permutations of</a><br />
+    <a href="book-Z-H-16.html#__idx_2136">represented as binary tree</a><br />
+    <a href="book-Z-H-16.html#__idx_2124">represented as ordered list</a><br />
+    <a href="book-Z-H-16.html#__idx_2112">represented as unordered list</a><br />
+    <a href="book-Z-H-15.html#__idx_1714">subsets of</a><br /><a href="book-Z-H-20.html#__idx_2860"><tt>set!</tt> (special form)</a><br />
+    <a href="book-Z-H-21.html#__idx_3080">environment model of</a><br />
+    <a href="book-Z-H-20.html#__idx_2864">value of</a><br /><a href="book-Z-H-22.html#__idx_3140"><tt>set-car!</tt> (primitive procedure)</a><br />
+    <a href="book-Z-H-33.html#__idx_5900">implemented with vectors</a><br />
+    <a href="book-Z-H-22.html#__idx_3216">procedural implementation of</a><br />
+    <a href="book-Z-H-22.html#__idx_3148">value of</a><br /><a href="book-Z-H-22.html#__idx_3144"><tt>set-cdr!</tt> (primitive procedure)</a><br />
+    <a href="book-Z-H-33.html#__idx_5902">implemented with vectors</a><br />
+    <a href="book-Z-H-22.html#__idx_3218">procedural implementation of</a><br />
+    <a href="book-Z-H-22.html#__idx_3152">value of</a><br /><a href="book-Z-H-32.html#__idx_5646"><tt>set-contents!</tt></a><br /><a href="book-Z-H-22.html#__idx_3460"><tt>set-current-time!</tt></a><br /><a href="book-Z-H-22.html#__idx_3246"><tt>set-front-ptr!</tt></a><br /><a href="book-Z-H-32.html#__idx_5710"><tt>set-instruction-execution-proc!</tt></a><br /><a href="book-Z-H-22.html#__idx_3248"><tt>set-rear-ptr!</tt></a><br /><a href="book-Z-H-32.html#__idx_5628"><tt>set-register-contents!</tt></a>,
+<a href="book-Z-H-32.html#__idx_5678">[2]</a><br /><a href="book-Z-H-22.html#__idx_3464"><tt>set-segments!</tt></a><br /><a href="book-Z-H-22.html#__idx_3372"><tt>set-signal!</tt></a>,
+<a href="book-Z-H-22.html#__idx_3406">[2]</a><br /><a href="book-Z-H-22.html#__idx_3526"><tt>set-value!</tt></a>,
+<a href="book-Z-H-22.html#__idx_3554">[2]</a><br /><a href="book-Z-H-26.html#__idx_4462"><tt>set-variable-value!</tt></a>,
+<a href="book-Z-H-26.html#__idx_4482">[2]</a><br /><a href="book-Z-H-26.html#__idx_4502"><tt>setup-environment</tt></a><br /><a href="book-Z-H-21.html#__idx_3060">shadow a binding</a><br /><a href="book-Z-H-11.html#__idx_924">Shamir, Adi</a><br /><a href="book-Z-H-11.html#__idx_648">shape of a process</a><br /><a href="book-Z-H-22.html#__idx_3178">shared data</a><br /><a href="book-Z-H-23.html#__idx_3624">shared resources</a><br /><a href="book-Z-H-23.html#__idx_3598">shared state</a><br /><a href="book-Z-H-15.html#__idx_1966"><tt>shrink-to-upper-right</tt></a><br /><a href="book-Z-H-29.html#__idx_5088">Shrobe, Howard E.</a><br /><a href="book-Z-H-20.html#__idx_3000">side-effect bug</a><br /><a href="book-Z-H-24.html#__idx_3844">sieve of Eratosthenes</a><br />
+    <a href="book-Z-H-24.html#__idx_3852"><tt>sieve</tt></a><br /><a href="book-Z-H-12.html#__idx_988">sum  (sigma) notation</a><br />
 signal processing
 <br />
-    <a href="book-Z-H-12.html#%_idx_1236">smoothing a function</a><br />
-    <a href="book-Z-H-24.html#%_idx_4042">smoothing a signal</a>,
-<a href="book-Z-H-24.html#%_idx_4050">[2]</a><br />
-    <a href="book-Z-H-24.html#%_idx_4018">stream model of</a><br />
-    <a href="book-Z-H-24.html#%_idx_4034">zero crossings of a signal</a>,
-<a href="book-Z-H-24.html#%_idx_4038">[2]</a>, <a href="book-Z-H-24.html#%_idx_4046">[3]</a><br /><a href="book-Z-H-22.html#%_idx_3336">signal, digital</a><br /><a href="book-Z-H-34.html#%_idx_6156"><tt>signal-error</tt></a><br /><a href="book-Z-H-15.html#%_idx_1728">signal-flow diagram</a>,
-<a href="book-Z-H-24.html#%_idx_4026">[2]</a><br /><a href="book-Z-H-15.html#%_idx_1726">signal-processing view of computation</a><br /><a href="book-Z-H-29.html#%_idx_5110">simple query</a><br />
-    <a href="book-Z-H-29.html#%_idx_5182">processing</a>, <a href="book-Z-H-29.html#%_idx_5194">[2]</a>,
-<a href="book-Z-H-29.html#%_idx_5220">[3]</a>, <a href="book-Z-H-29.html#%_idx_5312">[4]</a><br /><a href="book-Z-H-29.html#%_idx_5314"><tt>simple-query</tt></a><br /><a href="book-Z-H-16.html#%_idx_2086">simplification of algebraic expressions</a><br /><a href="book-Z-H-12.html#%_idx_1006">Simpson's Rule for numerical integration</a><br />
+    <a href="book-Z-H-12.html#__idx_1236">smoothing a function</a><br />
+    <a href="book-Z-H-24.html#__idx_4042">smoothing a signal</a>,
+<a href="book-Z-H-24.html#__idx_4050">[2]</a><br />
+    <a href="book-Z-H-24.html#__idx_4018">stream model of</a><br />
+    <a href="book-Z-H-24.html#__idx_4034">zero crossings of a signal</a>,
+<a href="book-Z-H-24.html#__idx_4038">[2]</a>, <a href="book-Z-H-24.html#__idx_4046">[3]</a><br /><a href="book-Z-H-22.html#__idx_3336">signal, digital</a><br /><a href="book-Z-H-34.html#__idx_6156"><tt>signal-error</tt></a><br /><a href="book-Z-H-15.html#__idx_1728">signal-flow diagram</a>,
+<a href="book-Z-H-24.html#__idx_4026">[2]</a><br /><a href="book-Z-H-15.html#__idx_1726">signal-processing view of computation</a><br /><a href="book-Z-H-29.html#__idx_5110">simple query</a><br />
+    <a href="book-Z-H-29.html#__idx_5182">processing</a>, <a href="book-Z-H-29.html#__idx_5194">[2]</a>,
+<a href="book-Z-H-29.html#__idx_5220">[3]</a>, <a href="book-Z-H-29.html#__idx_5312">[4]</a><br /><a href="book-Z-H-29.html#__idx_5314"><tt>simple-query</tt></a><br /><a href="book-Z-H-16.html#__idx_2086">simplification of algebraic expressions</a><br /><a href="book-Z-H-12.html#__idx_1006">Simpson's Rule for numerical integration</a><br />
 simulation
 <br />
     of digital circuit, <em>see</em> digital-circuit simulation
 <br />
-    <a href="book-Z-H-22.html#%_idx_3332">event-driven</a><br />
-    <a href="book-Z-H-34.html#%_idx_6162">as machine-design tool</a><br />
-    <a href="book-Z-H-32.html#%_idx_5806">for monitoring performance of register machine</a><br />
+    <a href="book-Z-H-22.html#__idx_3332">event-driven</a><br />
+    <a href="book-Z-H-34.html#__idx_6162">as machine-design tool</a><br />
+    <a href="book-Z-H-32.html#__idx_5806">for monitoring performance of register machine</a><br />
     Monte Carlo, <em>see</em> Monte Carlo simulation
 <br />
     of register machine, <em>see</em> register-machine simulator
-<br /><a href="book-Z-H-12.html#%_idx_1116"><tt>sin</tt> (primitive procedure)</a><br />
+<br /><a href="book-Z-H-12.html#__idx_1116"><tt>sin</tt> (primitive procedure)</a><br />
 sine
 <br />
-    <a href="book-Z-H-11.html#%_idx_786">approximation for small angle</a><br />
-    <a href="book-Z-H-24.html#%_idx_3918">power series for</a><br /><a href="book-Z-H-29.html#%_idx_5394"><tt>singleton-stream</tt></a><br /><a href="book-Z-H-22.html#%_idx_3486">SKETCHPAD</a><br /><a href="book-Z-H-11.html#%_idx_860"><tt>smallest-divisor</tt></a><br />
-    <a href="book-Z-H-11.html#%_idx_942">more efficient version</a><br /><a href="book-Z-H-22.html#%_idx_3490">Smalltalk</a><br /><a href="book-Z-H-12.html#%_idx_1234">smoothing a function</a><br /><a href="book-Z-H-24.html#%_idx_4044">smoothing a signal</a>,
-<a href="book-Z-H-24.html#%_idx_4052">[2]</a><br /><a href="book-Z-H-27.html#%_idx_4674">snarf</a><br /><a href="book-Z-H-9.html#%_idx_102">Solar System's chaotic dynamics</a><br /><a href="book-Z-H-20.html#%_idx_2930">Solomonoff, Ray</a><br /><a href="book-Z-H-24.html#%_idx_4066"><tt>solve</tt> differential equation</a>,
-<a href="book-Z-H-24.html#%_idx_4076">[2]</a><br />
-    <a href="book-Z-H-27.html#%_idx_4804">lazy-list version</a><br />
-    <a href="book-Z-H-26.html#%_idx_4616">with scanned-out definitions</a><br />
+    <a href="book-Z-H-11.html#__idx_786">approximation for small angle</a><br />
+    <a href="book-Z-H-24.html#__idx_3918">power series for</a><br /><a href="book-Z-H-29.html#__idx_5394"><tt>singleton-stream</tt></a><br /><a href="book-Z-H-22.html#__idx_3486">SKETCHPAD</a><br /><a href="book-Z-H-11.html#__idx_860"><tt>smallest-divisor</tt></a><br />
+    <a href="book-Z-H-11.html#__idx_942">more efficient version</a><br /><a href="book-Z-H-22.html#__idx_3490">Smalltalk</a><br /><a href="book-Z-H-12.html#__idx_1234">smoothing a function</a><br /><a href="book-Z-H-24.html#__idx_4044">smoothing a signal</a>,
+<a href="book-Z-H-24.html#__idx_4052">[2]</a><br /><a href="book-Z-H-27.html#__idx_4674">snarf</a><br /><a href="book-Z-H-9.html#__idx_102">Solar System's chaotic dynamics</a><br /><a href="book-Z-H-20.html#__idx_2930">Solomonoff, Ray</a><br /><a href="book-Z-H-24.html#__idx_4066"><tt>solve</tt> differential equation</a>,
+<a href="book-Z-H-24.html#__idx_4076">[2]</a><br />
+    <a href="book-Z-H-27.html#__idx_4804">lazy-list version</a><br />
+    <a href="book-Z-H-26.html#__idx_4616">with scanned-out definitions</a><br />
 solving equation, <em>see</em> half-interval method; Newton's method; <tt>solve</tt>
-<br /><a href="book-Z-H-35.html#%_idx_6214">source language</a><br /><a href="book-Z-H-35.html#%_idx_6216">source program</a><br /><a href="book-Z-H-35.html#%_idx_6502">Spafford, Eugene H.</a><br /><a href="book-Z-H-18.html#%_idx_2730">sparse polynomial</a><br /><a href="book-Z-H-10.html#%_idx_272">special form</a><br />
-    <a href="book-Z-H-26.html#%_idx_4358">as derived expression in evaluator</a><br />
-    <a href="book-Z-H-10.html#%_idx_558">need for</a><br />
-    <a href="book-Z-H-27.html#%_idx_4692">procedure vs.</a>,
-<a href="book-Z-H-27.html#%_idx_4764">[2]</a><br />
+<br /><a href="book-Z-H-35.html#__idx_6214">source language</a><br /><a href="book-Z-H-35.html#__idx_6216">source program</a><br /><a href="book-Z-H-35.html#__idx_6502">Spafford, Eugene H.</a><br /><a href="book-Z-H-18.html#__idx_2730">sparse polynomial</a><br /><a href="book-Z-H-10.html#__idx_272">special form</a><br />
+    <a href="book-Z-H-26.html#__idx_4358">as derived expression in evaluator</a><br />
+    <a href="book-Z-H-10.html#__idx_558">need for</a><br />
+    <a href="book-Z-H-27.html#__idx_4692">procedure vs.</a>,
+<a href="book-Z-H-27.html#__idx_4764">[2]</a><br />
 special forms (those marked <em>ns</em> are not in the IEEE Scheme standard)
 <br />
-    <a href="book-Z-H-10.html#%_idx_448"><tt>and</tt></a><br />
-    <a href="book-Z-H-20.html#%_idx_2876"><tt>begin</tt></a><br />
-    <a href="book-Z-H-10.html#%_idx_354"><tt>cond</tt></a><br />
-    <a href="book-Z-H-24.html#%_idx_3776"><tt>cons-stream</tt> (<em>ns</em>)</a><br />
-    <a href="book-Z-H-10.html#%_idx_226"><tt>define</tt></a>, <a href="book-Z-H-10.html#%_idx_308">[2]</a><br />
-    <a href="book-Z-H-24.html#%_idx_3770"><tt>delay</tt> (<em>ns</em>)</a><br />
-    <a href="book-Z-H-10.html#%_idx_422"><tt>if</tt></a><br />
-    <a href="book-Z-H-12.html#%_idx_1036"><tt>lambda</tt></a><br />
-    <a href="book-Z-H-12.html#%_idx_1064"><tt>let</tt></a><br />
-    <a href="book-Z-H-26.html#%_idx_4410"><tt>let*</tt></a><br />
-    <a href="book-Z-H-26.html#%_idx_4620"><tt>letrec</tt></a><br />
-    <a href="book-Z-H-26.html#%_idx_4418">named <tt>let</tt></a><br />
-    <a href="book-Z-H-10.html#%_idx_456"><tt>or</tt></a><br />
-    <a href="book-Z-H-16.html#%_idx_2016"><tt>quote</tt></a><br />
-    <a href="book-Z-H-20.html#%_idx_2862"><tt>set!</tt></a><br /><a href="book-Z-H-15.html#%_idx_1908"><tt>split</tt></a><br /><a href="book-Z-H-10.html#%_idx_550"><tt>sqrt</tt></a><br />
-    <a href="book-Z-H-10.html#%_idx_624">block structured</a><br />
-    <a href="book-Z-H-21.html#%_idx_3118">in environment model</a><br />
-    <a href="book-Z-H-12.html#%_idx_1126">as fixed point</a>,
-<a href="book-Z-H-12.html#%_idx_1170">[2]</a>, <a href="book-Z-H-12.html#%_idx_1210">[3]</a>,
-<a href="book-Z-H-12.html#%_idx_1214">[4]</a><br />
-    <a href="book-Z-H-12.html#%_idx_1248">as iterative improvement</a><br />
-    <a href="book-Z-H-12.html#%_idx_1202">with Newton's method</a>,
-<a href="book-Z-H-12.html#%_idx_1216">[2]</a><br />
-    <a href="book-Z-H-31.html#%_idx_5548">register machine for</a><br />
-    <a href="book-Z-H-24.html#%_idx_3980">as stream limit</a><br /><a href="book-Z-H-24.html#%_idx_3948"><tt>sqrt-stream</tt></a><br /><a href="book-Z-H-10.html#%_idx_294"><tt>square</tt></a><br />
-    <a href="book-Z-H-21.html#%_idx_3072">in environment model</a><br /><a href="book-Z-H-10.html#%_idx_508">square root</a>, <em>see also</em> <tt>sqrt</tt>
-<br />
-    <a href="book-Z-H-24.html#%_idx_3946">stream of approximations</a><br /><a href="book-Z-H-15.html#%_idx_1894"><tt>square-limit</tt></a>,
-<a href="book-Z-H-15.html#%_idx_1906">[2]</a><br /><a href="book-Z-H-15.html#%_idx_1900"><tt>square-of-four</tt></a><br /><a href="book-Z-H-22.html#%_idx_3562"><tt>squarer</tt> (constraint)</a>,
-<a href="book-Z-H-22.html#%_idx_3564">[2]</a><br /><a href="book-Z-H-15.html#%_idx_1970"><tt>squash-inwards</tt></a><br /><a href="book-Z-H-11.html#%_idx_678">stack</a><br />
-    <a href="book-Z-H-34.html#%_idx_6054">framed</a><br />
-    <a href="book-Z-H-31.html#%_idx_5560">for recursion in register machine</a><br />
-    <a href="book-Z-H-32.html#%_idx_5648">representing</a>,
-<a href="book-Z-H-33.html#%_idx_5918">[2]</a><br /><a href="book-Z-H-35.html#%_idx_6362">stack allocation and tail recursion</a><br /><a href="book-Z-H-32.html#%_idx_5760"><tt>stack-inst-reg-name</tt></a><br /><a href="book-Z-H-22.html#%_idx_3498">Stallman, Richard M.</a>,
-<a href="book-Z-H-28.html#%_idx_4886">[2]</a><br /><a href="book-Z-H-32.html#%_idx_5632"><tt>start</tt> register machine</a>,
-<a href="book-Z-H-32.html#%_idx_5674">[2]</a><br /><a href="book-Z-H-35.html#%_idx_6478"><tt>start-eceval</tt></a><br /><a href="book-Z-H-14.html#%_idx_1400"><tt>start-segment</tt></a>,
-<a href="book-Z-H-15.html#%_idx_1956">[2]</a><br />
+    <a href="book-Z-H-10.html#__idx_448"><tt>and</tt></a><br />
+    <a href="book-Z-H-20.html#__idx_2876"><tt>begin</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_354"><tt>cond</tt></a><br />
+    <a href="book-Z-H-24.html#__idx_3776"><tt>cons-stream</tt> (<em>ns</em>)</a><br />
+    <a href="book-Z-H-10.html#__idx_226"><tt>define</tt></a>, <a href="book-Z-H-10.html#__idx_308">[2]</a><br />
+    <a href="book-Z-H-24.html#__idx_3770"><tt>delay</tt> (<em>ns</em>)</a><br />
+    <a href="book-Z-H-10.html#__idx_422"><tt>if</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_1036"><tt>lambda</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_1064"><tt>let</tt></a><br />
+    <a href="book-Z-H-26.html#__idx_4410"><tt>let*</tt></a><br />
+    <a href="book-Z-H-26.html#__idx_4620"><tt>letrec</tt></a><br />
+    <a href="book-Z-H-26.html#__idx_4418">named <tt>let</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_456"><tt>or</tt></a><br />
+    <a href="book-Z-H-16.html#__idx_2016"><tt>quote</tt></a><br />
+    <a href="book-Z-H-20.html#__idx_2862"><tt>set!</tt></a><br /><a href="book-Z-H-15.html#__idx_1908"><tt>split</tt></a><br /><a href="book-Z-H-10.html#__idx_550"><tt>sqrt</tt></a><br />
+    <a href="book-Z-H-10.html#__idx_624">block structured</a><br />
+    <a href="book-Z-H-21.html#__idx_3118">in environment model</a><br />
+    <a href="book-Z-H-12.html#__idx_1126">as fixed point</a>,
+<a href="book-Z-H-12.html#__idx_1170">[2]</a>, <a href="book-Z-H-12.html#__idx_1210">[3]</a>,
+<a href="book-Z-H-12.html#__idx_1214">[4]</a><br />
+    <a href="book-Z-H-12.html#__idx_1248">as iterative improvement</a><br />
+    <a href="book-Z-H-12.html#__idx_1202">with Newton's method</a>,
+<a href="book-Z-H-12.html#__idx_1216">[2]</a><br />
+    <a href="book-Z-H-31.html#__idx_5548">register machine for</a><br />
+    <a href="book-Z-H-24.html#__idx_3980">as stream limit</a><br /><a href="book-Z-H-24.html#__idx_3948"><tt>sqrt-stream</tt></a><br /><a href="book-Z-H-10.html#__idx_294"><tt>square</tt></a><br />
+    <a href="book-Z-H-21.html#__idx_3072">in environment model</a><br /><a href="book-Z-H-10.html#__idx_508">square root</a>, <em>see also</em> <tt>sqrt</tt>
+<br />
+    <a href="book-Z-H-24.html#__idx_3946">stream of approximations</a><br /><a href="book-Z-H-15.html#__idx_1894"><tt>square-limit</tt></a>,
+<a href="book-Z-H-15.html#__idx_1906">[2]</a><br /><a href="book-Z-H-15.html#__idx_1900"><tt>square-of-four</tt></a><br /><a href="book-Z-H-22.html#__idx_3562"><tt>squarer</tt> (constraint)</a>,
+<a href="book-Z-H-22.html#__idx_3564">[2]</a><br /><a href="book-Z-H-15.html#__idx_1970"><tt>squash-inwards</tt></a><br /><a href="book-Z-H-11.html#__idx_678">stack</a><br />
+    <a href="book-Z-H-34.html#__idx_6054">framed</a><br />
+    <a href="book-Z-H-31.html#__idx_5560">for recursion in register machine</a><br />
+    <a href="book-Z-H-32.html#__idx_5648">representing</a>,
+<a href="book-Z-H-33.html#__idx_5918">[2]</a><br /><a href="book-Z-H-35.html#__idx_6362">stack allocation and tail recursion</a><br /><a href="book-Z-H-32.html#__idx_5760"><tt>stack-inst-reg-name</tt></a><br /><a href="book-Z-H-22.html#__idx_3498">Stallman, Richard M.</a>,
+<a href="book-Z-H-28.html#__idx_4886">[2]</a><br /><a href="book-Z-H-32.html#__idx_5632"><tt>start</tt> register machine</a>,
+<a href="book-Z-H-32.html#__idx_5674">[2]</a><br /><a href="book-Z-H-35.html#__idx_6478"><tt>start-eceval</tt></a><br /><a href="book-Z-H-14.html#__idx_1400"><tt>start-segment</tt></a>,
+<a href="book-Z-H-15.html#__idx_1956">[2]</a><br />
 state
 <br />
     local, <em>see</em> local state
 <br />
-    <a href="book-Z-H-23.html#%_idx_3596">shared</a><br />
-    <a href="book-Z-H-24.html#%_idx_4154">vanishes in stream formulation</a><br /><a href="book-Z-H-11.html#%_idx_670">state variable</a>, <a href="book-Z-H-20.html#%_idx_2840">[2]</a><br />
-    <a href="book-Z-H-20.html#%_idx_2846">local</a><br />
+    <a href="book-Z-H-23.html#__idx_3596">shared</a><br />
+    <a href="book-Z-H-24.html#__idx_4154">vanishes in stream formulation</a><br /><a href="book-Z-H-11.html#__idx_670">state variable</a>, <a href="book-Z-H-20.html#__idx_2840">[2]</a><br />
+    <a href="book-Z-H-20.html#__idx_2846">local</a><br />
 statements, <em>see</em> instruction sequence
-<br /><a href="book-Z-H-35.html#%_idx_6384"><tt>statements</tt></a><br /><a href="book-Z-H-9.html#%_idx_88">Steele, Guy Lewis Jr.</a>,
-<a href="book-Z-H-11.html#%_idx_700">[2]</a>, <a href="book-Z-H-20.html#%_idx_3024">[3]</a>,
-<a href="book-Z-H-22.html#%_idx_3500">[4]</a>, <a href="book-Z-H-27.html#%_idx_4676">[5]</a>,
-<a href="book-Z-H-28.html#%_idx_4848">[6]</a><br /><a href="book-Z-H-33.html#%_idx_5932">stop-and-copy garbage collector</a><br /><a href="book-Z-H-10.html#%_idx_338">Stoy, Joseph E.</a>, <a href="book-Z-H-11.html#%_idx_830">[2]</a>,
-<a href="book-Z-H-26.html#%_idx_4630">[3]</a><br /><a href="book-Z-H-12.html#%_idx_1220">Strachey, Christopher</a><br /><a href="book-Z-H-15.html#%_idx_1978">stratified design</a><br /><a href="book-Z-H-19.html#%_idx_2830">stream(s)</a>, <a href="book-Z-H-24.html#%_idx_3726">[2]</a><br />
-    <a href="book-Z-H-24.html#%_idx_4054">delayed evaluation and</a><br />
-    <a href="book-Z-H-24.html#%_idx_3746">empty</a><br />
-    <a href="book-Z-H-24.html#%_idx_3732">implemented as delayed lists</a><br />
-    <a href="book-Z-H-27.html#%_idx_4754">implemented as lazy lists</a><br />
-    <a href="book-Z-H-24.html#%_idx_3860">implicit definition</a><br />
+<br /><a href="book-Z-H-35.html#__idx_6384"><tt>statements</tt></a><br /><a href="book-Z-H-9.html#__idx_88">Steele, Guy Lewis Jr.</a>,
+<a href="book-Z-H-11.html#__idx_700">[2]</a>, <a href="book-Z-H-20.html#__idx_3024">[3]</a>,
+<a href="book-Z-H-22.html#__idx_3500">[4]</a>, <a href="book-Z-H-27.html#__idx_4676">[5]</a>,
+<a href="book-Z-H-28.html#__idx_4848">[6]</a><br /><a href="book-Z-H-33.html#__idx_5932">stop-and-copy garbage collector</a><br /><a href="book-Z-H-10.html#__idx_338">Stoy, Joseph E.</a>, <a href="book-Z-H-11.html#__idx_830">[2]</a>,
+<a href="book-Z-H-26.html#__idx_4630">[3]</a><br /><a href="book-Z-H-12.html#__idx_1220">Strachey, Christopher</a><br /><a href="book-Z-H-15.html#__idx_1978">stratified design</a><br /><a href="book-Z-H-19.html#__idx_2830">stream(s)</a>, <a href="book-Z-H-24.html#__idx_3726">[2]</a><br />
+    <a href="book-Z-H-24.html#__idx_4054">delayed evaluation and</a><br />
+    <a href="book-Z-H-24.html#__idx_3746">empty</a><br />
+    <a href="book-Z-H-24.html#__idx_3732">implemented as delayed lists</a><br />
+    <a href="book-Z-H-27.html#__idx_4754">implemented as lazy lists</a><br />
+    <a href="book-Z-H-24.html#__idx_3860">implicit definition</a><br />
     infinite, <em>see</em> infinite streams
 <br />
-    <a href="book-Z-H-29.html#%_idx_5186">used in query interpreter</a>,
-<a href="book-Z-H-29.html#%_idx_5236">[2]</a><br /><a href="book-Z-H-24.html#%_idx_3994"><tt>stream-append</tt></a><br /><a href="book-Z-H-29.html#%_idx_5386"><tt>stream-append-delayed</tt></a><br /><a href="book-Z-H-24.html#%_idx_3740"><tt>stream-car</tt></a>,
-<a href="book-Z-H-24.html#%_idx_3780">[2]</a><br /><a href="book-Z-H-24.html#%_idx_3742"><tt>stream-cdr</tt></a>,
-<a href="book-Z-H-24.html#%_idx_3782">[2]</a><br /><a href="book-Z-H-24.html#%_idx_3788"><tt>stream-enumerate-interval</tt></a><br /><a href="book-Z-H-24.html#%_idx_3790"><tt>stream-filter</tt></a><br /><a href="book-Z-H-29.html#%_idx_5390"><tt>stream-flatmap</tt></a>,
-<a href="book-Z-H-29.html#%_idx_5418">[2]</a><br /><a href="book-Z-H-24.html#%_idx_3762"><tt>stream-for-each</tt></a><br /><a href="book-Z-H-24.html#%_idx_3978"><tt>stream-limit</tt></a><br /><a href="book-Z-H-24.html#%_idx_3760"><tt>stream-map</tt></a><br />
-    <a href="book-Z-H-24.html#%_idx_3824">with multiple arguments</a><br /><a href="book-Z-H-24.html#%_idx_3750"><tt>stream-null?</tt></a><br />
-    <a href="book-Z-H-24.html#%_idx_3754">in MIT Scheme</a><br /><a href="book-Z-H-24.html#%_idx_3758"><tt>stream-ref</tt></a><br /><a href="book-Z-H-24.html#%_idx_4152"><tt>stream-withdraw</tt></a><br /><a href="book-Z-H-27.html#%_idx_4688">strict</a><br />
+    <a href="book-Z-H-29.html#__idx_5186">used in query interpreter</a>,
+<a href="book-Z-H-29.html#__idx_5236">[2]</a><br /><a href="book-Z-H-24.html#__idx_3994"><tt>stream-append</tt></a><br /><a href="book-Z-H-29.html#__idx_5386"><tt>stream-append-delayed</tt></a><br /><a href="book-Z-H-24.html#__idx_3740"><tt>stream-car</tt></a>,
+<a href="book-Z-H-24.html#__idx_3780">[2]</a><br /><a href="book-Z-H-24.html#__idx_3742"><tt>stream-cdr</tt></a>,
+<a href="book-Z-H-24.html#__idx_3782">[2]</a><br /><a href="book-Z-H-24.html#__idx_3788"><tt>stream-enumerate-interval</tt></a><br /><a href="book-Z-H-24.html#__idx_3790"><tt>stream-filter</tt></a><br /><a href="book-Z-H-29.html#__idx_5390"><tt>stream-flatmap</tt></a>,
+<a href="book-Z-H-29.html#__idx_5418">[2]</a><br /><a href="book-Z-H-24.html#__idx_3762"><tt>stream-for-each</tt></a><br /><a href="book-Z-H-24.html#__idx_3978"><tt>stream-limit</tt></a><br /><a href="book-Z-H-24.html#__idx_3760"><tt>stream-map</tt></a><br />
+    <a href="book-Z-H-24.html#__idx_3824">with multiple arguments</a><br /><a href="book-Z-H-24.html#__idx_3750"><tt>stream-null?</tt></a><br />
+    <a href="book-Z-H-24.html#__idx_3754">in MIT Scheme</a><br /><a href="book-Z-H-24.html#__idx_3758"><tt>stream-ref</tt></a><br /><a href="book-Z-H-24.html#__idx_4152"><tt>stream-withdraw</tt></a><br /><a href="book-Z-H-27.html#__idx_4688">strict</a><br />
 string, <em>see</em> character string
-<br /><a href="book-Z-H-24.html#%_idx_4102">strongly typed language</a><br /><a href="book-Z-H-18.html#%_idx_2506"><tt>sub</tt> (generic)</a><br /><a href="book-Z-H-17.html#%_idx_2314"><tt>sub-complex</tt></a><br /><a href="book-Z-H-14.html#%_idx_1508"><tt>sub-interval</tt></a><br /><a href="book-Z-H-14.html#%_idx_1310"><tt>sub-rat</tt></a><br /><a href="book-Z-H-15.html#%_idx_1940"><tt>sub-vect</tt></a><br /><a href="book-Z-H-31.html#%_idx_5552">subroutine in register machine</a><br /><a href="book-Z-H-15.html#%_idx_1716"><tt>subsets</tt> of a set</a><br /><a href="book-Z-H-10.html#%_idx_334">substitution model of procedure application</a>, <a href="book-Z-H-21.html#%_idx_3036">[2]</a><br />
-    <a href="book-Z-H-20.html#%_idx_2980">inadequacy of</a><br />
-    <a href="book-Z-H-11.html#%_idx_644">shape of process</a><br /><a href="book-Z-H-18.html#%_idx_2596">subtype</a><br />
-    <a href="book-Z-H-18.html#%_idx_2620">multiple</a><br /><a href="book-Z-H-28.html#%_idx_4988">success continuation (nondeterministic evaluator)</a>, <a href="book-Z-H-28.html#%_idx_4996">[2]</a><br /><a href="book-Z-H-11.html#%_idx_796">successive squaring</a><br /><a href="book-Z-H-12.html#%_idx_990"><tt>sum</tt></a><br />
-    <a href="book-Z-H-12.html#%_idx_1020">as accumulation</a><br />
-    <a href="book-Z-H-12.html#%_idx_1008">iterative version</a><br /><a href="book-Z-H-12.html#%_idx_972"><tt>sum-cubes</tt></a><br />
-    <a href="book-Z-H-12.html#%_idx_994">with higher-order procedures</a><br /><a href="book-Z-H-12.html#%_idx_970"><tt>sum-integers</tt></a><br />
-    <a href="book-Z-H-12.html#%_idx_998">with higher-order procedures</a><br /><a href="book-Z-H-15.html#%_idx_1722"><tt>sum-odd-squares</tt></a>,
-<a href="book-Z-H-15.html#%_idx_1752">[2]</a><br /><a href="book-Z-H-10.html#%_idx_330"><tt>sum-of-squares</tt></a><br />
-    <a href="book-Z-H-21.html#%_idx_3086">in environment model</a><br /><a href="book-Z-H-24.html#%_idx_3734"><tt>sum-primes</tt></a>,
-<a href="book-Z-H-24.html#%_idx_3736">[2]</a><br /><a href="book-Z-H-16.html#%_idx_2072"><tt>sum?</tt></a><br /><a href="book-Z-H-12.html#%_idx_984">summation of a series</a><br />
-    <a href="book-Z-H-24.html#%_idx_3958">with streams</a><br /><a href="book-Z-H-18.html#%_idx_2600">supertype</a><br />
-    <a href="book-Z-H-18.html#%_idx_2618">multiple</a><br /><a href="book-Z-H-9.html#%_idx_90">Sussman, Gerald Jay</a>,
-<a href="book-Z-H-9.html#%_idx_108">[2]</a>, <a href="book-Z-H-11.html#%_idx_702">[3]</a>,
-<a href="book-Z-H-22.html#%_idx_3496">[4]</a>, <a href="book-Z-H-28.html#%_idx_4868">[5]</a>,
-<a href="book-Z-H-28.html#%_idx_4880">[6]</a>, <a href="book-Z-H-28.html#%_idx_4884">[7]</a><br /><a href="book-Z-H-16.html#%_idx_1990">Sussman, Julie Esther Mazel, nieces of</a><br /><a href="book-Z-H-22.html#%_idx_3488">Sutherland, Ivan</a><br /><a href="book-Z-H-16.html#%_idx_1986">symbol(s)</a><br />
-    <a href="book-Z-H-16.html#%_idx_2024">equality of</a><br />
-    <a href="book-Z-H-33.html#%_idx_5890">interning</a><br />
-    <a href="book-Z-H-16.html#%_idx_2010">quotation of</a><br />
-    <a href="book-Z-H-33.html#%_idx_5882">representation of</a><br />
-    <a href="book-Z-H-22.html#%_idx_3184">uniqueness of</a><br /><a href="book-Z-H-16.html#%_idx_2254"><tt>symbol-leaf</tt></a><br /><a href="book-Z-H-16.html#%_idx_2060"><tt>symbol?</tt> (primitive procedure)</a><br />
-    <a href="book-Z-H-18.html#%_idx_2556">data types and</a><br />
-    <a href="book-Z-H-33.html#%_idx_5914">implemented with typed pointers</a><br /><a href="book-Z-H-18.html#%_idx_2646">symbolic algebra</a><br /><a href="book-Z-H-16.html#%_idx_2044">symbolic differentiation</a>,
-<a href="book-Z-H-17.html#%_idx_2476">[2]</a><br /><a href="book-Z-H-13.html#%_idx_1270">symbolic expression</a>,
+<br /><a href="book-Z-H-24.html#__idx_4102">strongly typed language</a><br /><a href="book-Z-H-18.html#__idx_2506"><tt>sub</tt> (generic)</a><br /><a href="book-Z-H-17.html#__idx_2314"><tt>sub-complex</tt></a><br /><a href="book-Z-H-14.html#__idx_1508"><tt>sub-interval</tt></a><br /><a href="book-Z-H-14.html#__idx_1310"><tt>sub-rat</tt></a><br /><a href="book-Z-H-15.html#__idx_1940"><tt>sub-vect</tt></a><br /><a href="book-Z-H-31.html#__idx_5552">subroutine in register machine</a><br /><a href="book-Z-H-15.html#__idx_1716"><tt>subsets</tt> of a set</a><br /><a href="book-Z-H-10.html#__idx_334">substitution model of procedure application</a>, <a href="book-Z-H-21.html#__idx_3036">[2]</a><br />
+    <a href="book-Z-H-20.html#__idx_2980">inadequacy of</a><br />
+    <a href="book-Z-H-11.html#__idx_644">shape of process</a><br /><a href="book-Z-H-18.html#__idx_2596">subtype</a><br />
+    <a href="book-Z-H-18.html#__idx_2620">multiple</a><br /><a href="book-Z-H-28.html#__idx_4988">success continuation (nondeterministic evaluator)</a>, <a href="book-Z-H-28.html#__idx_4996">[2]</a><br /><a href="book-Z-H-11.html#__idx_796">successive squaring</a><br /><a href="book-Z-H-12.html#__idx_990"><tt>sum</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_1020">as accumulation</a><br />
+    <a href="book-Z-H-12.html#__idx_1008">iterative version</a><br /><a href="book-Z-H-12.html#__idx_972"><tt>sum-cubes</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_994">with higher-order procedures</a><br /><a href="book-Z-H-12.html#__idx_970"><tt>sum-integers</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_998">with higher-order procedures</a><br /><a href="book-Z-H-15.html#__idx_1722"><tt>sum-odd-squares</tt></a>,
+<a href="book-Z-H-15.html#__idx_1752">[2]</a><br /><a href="book-Z-H-10.html#__idx_330"><tt>sum-of-squares</tt></a><br />
+    <a href="book-Z-H-21.html#__idx_3086">in environment model</a><br /><a href="book-Z-H-24.html#__idx_3734"><tt>sum-primes</tt></a>,
+<a href="book-Z-H-24.html#__idx_3736">[2]</a><br /><a href="book-Z-H-16.html#__idx_2072"><tt>sum?</tt></a><br /><a href="book-Z-H-12.html#__idx_984">summation of a series</a><br />
+    <a href="book-Z-H-24.html#__idx_3958">with streams</a><br /><a href="book-Z-H-18.html#__idx_2600">supertype</a><br />
+    <a href="book-Z-H-18.html#__idx_2618">multiple</a><br /><a href="book-Z-H-9.html#__idx_90">Sussman, Gerald Jay</a>,
+<a href="book-Z-H-9.html#__idx_108">[2]</a>, <a href="book-Z-H-11.html#__idx_702">[3]</a>,
+<a href="book-Z-H-22.html#__idx_3496">[4]</a>, <a href="book-Z-H-28.html#__idx_4868">[5]</a>,
+<a href="book-Z-H-28.html#__idx_4880">[6]</a>, <a href="book-Z-H-28.html#__idx_4884">[7]</a><br /><a href="book-Z-H-16.html#__idx_1990">Sussman, Julie Esther Mazel, nieces of</a><br /><a href="book-Z-H-22.html#__idx_3488">Sutherland, Ivan</a><br /><a href="book-Z-H-16.html#__idx_1986">symbol(s)</a><br />
+    <a href="book-Z-H-16.html#__idx_2024">equality of</a><br />
+    <a href="book-Z-H-33.html#__idx_5890">interning</a><br />
+    <a href="book-Z-H-16.html#__idx_2010">quotation of</a><br />
+    <a href="book-Z-H-33.html#__idx_5882">representation of</a><br />
+    <a href="book-Z-H-22.html#__idx_3184">uniqueness of</a><br /><a href="book-Z-H-16.html#__idx_2254"><tt>symbol-leaf</tt></a><br /><a href="book-Z-H-16.html#__idx_2060"><tt>symbol?</tt> (primitive procedure)</a><br />
+    <a href="book-Z-H-18.html#__idx_2556">data types and</a><br />
+    <a href="book-Z-H-33.html#__idx_5914">implemented with typed pointers</a><br /><a href="book-Z-H-18.html#__idx_2646">symbolic algebra</a><br /><a href="book-Z-H-16.html#__idx_2044">symbolic differentiation</a>,
+<a href="book-Z-H-17.html#__idx_2476">[2]</a><br /><a href="book-Z-H-13.html#__idx_1270">symbolic expression</a>,
 <em>see also</em> symbol(s)
-<br /><a href="book-Z-H-16.html#%_idx_2264"><tt>symbols</tt></a><br /><a href="book-Z-H-23.html#%_idx_3714">SYNC</a><br />
+<br /><a href="book-Z-H-16.html#__idx_2264"><tt>symbols</tt></a><br /><a href="book-Z-H-23.html#__idx_3714">SYNC</a><br />
 synchronization, <em>see</em> concurrency
 <br />
 syntactic analysis, separated from execution
 <br />
-    <a href="book-Z-H-26.html#%_idx_4634">in metacircular evaluator</a><br />
-    <a href="book-Z-H-32.html#%_idx_5684">in register-machine simulator</a>,
-<a href="book-Z-H-32.html#%_idx_5730">[2]</a><br /><a href="book-Z-H-10.html#%_idx_282">syntactic sugar</a><br />
-    <a href="book-Z-H-26.html#%_idx_4298"><tt>define</tt></a><br />
-    <a href="book-Z-H-12.html#%_idx_1066"><tt>let</tt> as</a><br />
-    <a href="book-Z-H-11.html#%_idx_696">looping constructs as</a><br />
-    <a href="book-Z-H-22.html#%_idx_3400">procedure vs. data as</a><br />
+    <a href="book-Z-H-26.html#__idx_4634">in metacircular evaluator</a><br />
+    <a href="book-Z-H-32.html#__idx_5684">in register-machine simulator</a>,
+<a href="book-Z-H-32.html#__idx_5730">[2]</a><br /><a href="book-Z-H-10.html#__idx_282">syntactic sugar</a><br />
+    <a href="book-Z-H-26.html#__idx_4298"><tt>define</tt></a><br />
+    <a href="book-Z-H-12.html#__idx_1066"><tt>let</tt> as</a><br />
+    <a href="book-Z-H-11.html#__idx_696">looping constructs as</a><br />
+    <a href="book-Z-H-22.html#__idx_3400">procedure vs. data as</a><br />
 syntax, <em>see also</em> special forms
 <br />
     abstract, <em>see</em> abstract syntax
 <br />
-    <a href="book-Z-H-10.html#%_idx_316">of expressions, describing</a><br />
-    <a href="book-Z-H-10.html#%_idx_276">of a programming language</a><br /><a href="book-Z-H-22.html#%_idx_3402">syntax interface</a><br /><a href="book-Z-H-28.html#%_idx_4842">systematic search</a></p><p>
+    <a href="book-Z-H-10.html#__idx_316">of expressions, describing</a><br />
+    <a href="book-Z-H-10.html#__idx_276">of a programming language</a><br /><a href="book-Z-H-22.html#__idx_3402">syntax interface</a><br /><a href="book-Z-H-28.html#__idx_4842">systematic search</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-10.html#%_idx_374"><tt>#t</tt></a><br /><a href="book-Z-H-22.html#%_idx_3268">table</a><br />
-    <a href="book-Z-H-22.html#%_idx_3274">backbone of</a><br />
-    <a href="book-Z-H-18.html#%_idx_2586">for coercion</a><br />
-    <a href="book-Z-H-17.html#%_idx_2434">for data-directed programming</a><br />
-    <a href="book-Z-H-22.html#%_idx_3294">local</a><br />
-    <a href="book-Z-H-22.html#%_idx_3308"><em>n</em>-dimensional</a><br />
-    <a href="book-Z-H-22.html#%_idx_3272">one-dimensional</a><br />
+<br /><a href="book-Z-H-10.html#__idx_374"><tt>#t</tt></a><br /><a href="book-Z-H-22.html#__idx_3268">table</a><br />
+    <a href="book-Z-H-22.html#__idx_3274">backbone of</a><br />
+    <a href="book-Z-H-18.html#__idx_2586">for coercion</a><br />
+    <a href="book-Z-H-17.html#__idx_2434">for data-directed programming</a><br />
+    <a href="book-Z-H-22.html#__idx_3294">local</a><br />
+    <a href="book-Z-H-22.html#__idx_3308"><em>n</em>-dimensional</a><br />
+    <a href="book-Z-H-22.html#__idx_3272">one-dimensional</a><br />
     operation-and-type, <em>see</em> operation-and-type table
 <br />
-    <a href="book-Z-H-22.html#%_idx_3312">represented as binary tree vs. unordered list</a><br />
-    <a href="book-Z-H-22.html#%_idx_3304">testing equality of keys</a><br />
-    <a href="book-Z-H-22.html#%_idx_3288">two-dimensional</a><br />
-    <a href="book-Z-H-22.html#%_idx_3448">used in simulation agenda</a><br />
-    <a href="book-Z-H-22.html#%_idx_3318">used to store computed values</a><br /><a href="book-Z-H-24.html#%_idx_3972">tableau</a><br /><a href="book-Z-H-11.html#%_idx_734">tabulation</a>, <a href="book-Z-H-22.html#%_idx_3316">[2]</a><br /><a href="book-Z-H-35.html#%_idx_6400"><tt>tack-on-instruction-sequence</tt></a><br /><a href="book-Z-H-33.html#%_idx_5872">tagged architecture</a><br /><a href="book-Z-H-17.html#%_idx_2358">tagged data</a>, <a href="book-Z-H-33.html#%_idx_5864">[2]</a><br /><a href="book-Z-H-26.html#%_idx_4290"><tt>tagged-list?</tt></a><br /><a href="book-Z-H-11.html#%_idx_692">tail recursion</a><br />
-    <a href="book-Z-H-35.html#%_idx_6354">compiler and</a><br />
-    <a href="book-Z-H-21.html#%_idx_3096">environment model of evaluation and</a><br />
-    <a href="book-Z-H-34.html#%_idx_6090">explicit-control evaluator and</a>,
-<a href="book-Z-H-34.html#%_idx_6168">[2]</a>, <a href="book-Z-H-34.html#%_idx_6176">[3]</a><br />
-    <a href="book-Z-H-35.html#%_idx_6358">garbage collection and</a><br />
-    <a href="book-Z-H-34.html#%_idx_6096">metacircular evaluator and</a><br />
-    <a href="book-Z-H-11.html#%_idx_706">in Scheme</a><br /><a href="book-Z-H-34.html#%_idx_6092">tail-recursive evaluator</a><br />
+    <a href="book-Z-H-22.html#__idx_3312">represented as binary tree vs. unordered list</a><br />
+    <a href="book-Z-H-22.html#__idx_3304">testing equality of keys</a><br />
+    <a href="book-Z-H-22.html#__idx_3288">two-dimensional</a><br />
+    <a href="book-Z-H-22.html#__idx_3448">used in simulation agenda</a><br />
+    <a href="book-Z-H-22.html#__idx_3318">used to store computed values</a><br /><a href="book-Z-H-24.html#__idx_3972">tableau</a><br /><a href="book-Z-H-11.html#__idx_734">tabulation</a>, <a href="book-Z-H-22.html#__idx_3316">[2]</a><br /><a href="book-Z-H-35.html#__idx_6400"><tt>tack-on-instruction-sequence</tt></a><br /><a href="book-Z-H-33.html#__idx_5872">tagged architecture</a><br /><a href="book-Z-H-17.html#__idx_2358">tagged data</a>, <a href="book-Z-H-33.html#__idx_5864">[2]</a><br /><a href="book-Z-H-26.html#__idx_4290"><tt>tagged-list?</tt></a><br /><a href="book-Z-H-11.html#__idx_692">tail recursion</a><br />
+    <a href="book-Z-H-35.html#__idx_6354">compiler and</a><br />
+    <a href="book-Z-H-21.html#__idx_3096">environment model of evaluation and</a><br />
+    <a href="book-Z-H-34.html#__idx_6090">explicit-control evaluator and</a>,
+<a href="book-Z-H-34.html#__idx_6168">[2]</a>, <a href="book-Z-H-34.html#__idx_6176">[3]</a><br />
+    <a href="book-Z-H-35.html#__idx_6358">garbage collection and</a><br />
+    <a href="book-Z-H-34.html#__idx_6096">metacircular evaluator and</a><br />
+    <a href="book-Z-H-11.html#__idx_706">in Scheme</a><br /><a href="book-Z-H-34.html#__idx_6092">tail-recursive evaluator</a><br />
 tangent
 <br />
-    <a href="book-Z-H-12.html#%_idx_1154">as continued fraction</a><br />
-    <a href="book-Z-H-24.html#%_idx_3940">power series for</a><br /><a href="book-Z-H-35.html#%_idx_6248">target register</a><br /><a href="book-Z-H-23.html#%_idx_3652">Technological University of Eindhoven</a><br /><a href="book-Z-H-9.html#%_idx_60">Teitelman, Warren</a><br /><a href="book-Z-H-18.html#%_idx_2666">term list of polynomial</a><br />
-    <a href="book-Z-H-18.html#%_idx_2724">representing</a><br /><a href="book-Z-H-18.html#%_idx_2690"><tt>term-list</tt></a><br /><a href="book-Z-H-10.html#%_idx_260">terminal node of a tree</a><br /><a href="book-Z-H-31.html#%_idx_5502"><tt>test</tt> (in register machine)</a><br />
-    <a href="book-Z-H-32.html#%_idx_5734">simulating</a><br /><a href="book-Z-H-31.html#%_idx_5482">test operation in register machine</a><br /><a href="book-Z-H-23.html#%_idx_3670"><tt>test-and-set!</tt></a>,
-<a href="book-Z-H-23.html#%_idx_3680">[2]</a><br /><a href="book-Z-H-32.html#%_idx_5738"><tt>test-condition</tt></a><br /><a href="book-Z-H-26.html#%_idx_4288"><tt>text-of-quotation</tt></a><br /><a href="book-Z-H-14.html#%_idx_1432">Thatcher, James W.</a><br /><a href="book-Z-H-23.html#%_idx_3650">THE Multiprogramming System</a><br /><tt>the-cars</tt>
-<br />
-    <a href="book-Z-H-33.html#%_idx_5892">register</a>, <a href="book-Z-H-33.html#%_idx_5968">[2]</a><br />
-    <a href="book-Z-H-33.html#%_idx_5856">vector</a><br /><tt>the-cdrs</tt>
-<br />
-    <a href="book-Z-H-33.html#%_idx_5894">register</a>, <a href="book-Z-H-33.html#%_idx_5970">[2]</a><br />
-    <a href="book-Z-H-33.html#%_idx_5858">vector</a><br /><a href="book-Z-H-24.html#%_idx_3748"><tt>the-empty-stream</tt></a><br />
-    <a href="book-Z-H-24.html#%_idx_3752">in MIT Scheme</a><br /><a href="book-Z-H-18.html#%_idx_2692"><tt>the-empty-termlist</tt></a>,
-<a href="book-Z-H-18.html#%_idx_2736">[2]</a><br /><a href="book-Z-H-26.html#%_idx_4504"><tt>the-global-environment</tt></a>,
-<a href="book-Z-H-34.html#%_idx_6138">[2]</a><br /><a href="book-Z-H-29.html#%_idx_5042">theorem proving (automatic)</a><br /><a href="book-Z-H-11.html#%_idx_758"><em>θ</em> (<em>f</em>(<em>n</em>)) (theta of <em>f</em>(<em>n</em>))</a><br /><a href="book-Z-H-27.html#%_idx_4696">thunk</a><br />
-    <a href="book-Z-H-24.html#%_idx_3818">call-by-name</a><br />
-    <a href="book-Z-H-24.html#%_idx_3820">call-by-need</a><br />
-    <a href="book-Z-H-27.html#%_idx_4706">forcing</a><br />
-    <a href="book-Z-H-27.html#%_idx_4738">implementation of</a><br />
-    <a href="book-Z-H-27.html#%_idx_4698">origin of name</a><br />
+    <a href="book-Z-H-12.html#__idx_1154">as continued fraction</a><br />
+    <a href="book-Z-H-24.html#__idx_3940">power series for</a><br /><a href="book-Z-H-35.html#__idx_6248">target register</a><br /><a href="book-Z-H-23.html#__idx_3652">Technological University of Eindhoven</a><br /><a href="book-Z-H-9.html#__idx_60">Teitelman, Warren</a><br /><a href="book-Z-H-18.html#__idx_2666">term list of polynomial</a><br />
+    <a href="book-Z-H-18.html#__idx_2724">representing</a><br /><a href="book-Z-H-18.html#__idx_2690"><tt>term-list</tt></a><br /><a href="book-Z-H-10.html#__idx_260">terminal node of a tree</a><br /><a href="book-Z-H-31.html#__idx_5502"><tt>test</tt> (in register machine)</a><br />
+    <a href="book-Z-H-32.html#__idx_5734">simulating</a><br /><a href="book-Z-H-31.html#__idx_5482">test operation in register machine</a><br /><a href="book-Z-H-23.html#__idx_3670"><tt>test-and-set!</tt></a>,
+<a href="book-Z-H-23.html#__idx_3680">[2]</a><br /><a href="book-Z-H-32.html#__idx_5738"><tt>test-condition</tt></a><br /><a href="book-Z-H-26.html#__idx_4288"><tt>text-of-quotation</tt></a><br /><a href="book-Z-H-14.html#__idx_1432">Thatcher, James W.</a><br /><a href="book-Z-H-23.html#__idx_3650">THE Multiprogramming System</a><br /><tt>the-cars</tt>
+<br />
+    <a href="book-Z-H-33.html#__idx_5892">register</a>, <a href="book-Z-H-33.html#__idx_5968">[2]</a><br />
+    <a href="book-Z-H-33.html#__idx_5856">vector</a><br /><tt>the-cdrs</tt>
+<br />
+    <a href="book-Z-H-33.html#__idx_5894">register</a>, <a href="book-Z-H-33.html#__idx_5970">[2]</a><br />
+    <a href="book-Z-H-33.html#__idx_5858">vector</a><br /><a href="book-Z-H-24.html#__idx_3748"><tt>the-empty-stream</tt></a><br />
+    <a href="book-Z-H-24.html#__idx_3752">in MIT Scheme</a><br /><a href="book-Z-H-18.html#__idx_2692"><tt>the-empty-termlist</tt></a>,
+<a href="book-Z-H-18.html#__idx_2736">[2]</a><br /><a href="book-Z-H-26.html#__idx_4504"><tt>the-global-environment</tt></a>,
+<a href="book-Z-H-34.html#__idx_6138">[2]</a><br /><a href="book-Z-H-29.html#__idx_5042">theorem proving (automatic)</a><br /><a href="book-Z-H-11.html#__idx_758"><em>θ</em> (<em>f</em>(<em>n</em>)) (theta of <em>f</em>(<em>n</em>))</a><br /><a href="book-Z-H-27.html#__idx_4696">thunk</a><br />
+    <a href="book-Z-H-24.html#__idx_3818">call-by-name</a><br />
+    <a href="book-Z-H-24.html#__idx_3820">call-by-need</a><br />
+    <a href="book-Z-H-27.html#__idx_4706">forcing</a><br />
+    <a href="book-Z-H-27.html#__idx_4738">implementation of</a><br />
+    <a href="book-Z-H-27.html#__idx_4698">origin of name</a><br />
 time
 <br />
-    <a href="book-Z-H-23.html#%_idx_3580">assignment and</a><br />
-    <a href="book-Z-H-23.html#%_idx_3720">communication and</a><br />
-    <a href="book-Z-H-23.html#%_idx_3584">in concurrent systems</a><br />
-    <a href="book-Z-H-24.html#%_idx_4144">functional programming and</a><br />
-    <a href="book-Z-H-28.html#%_idx_4820">in nondeterministic computing</a>,
-<a href="book-Z-H-28.html#%_idx_4834">[2]</a><br />
-    <a href="book-Z-H-23.html#%_idx_3586">purpose of</a><br /><a href="book-Z-H-22.html#%_idx_3438">time segment, in agenda</a><br /><a href="book-Z-H-23.html#%_idx_3674">time slicing</a><br /><a href="book-Z-H-11.html#%_idx_936"><tt>timed-prime-test</tt></a><br /><a href="book-Z-H-23.html#%_idx_3602">timing diagram</a><br /><a href="book-Z-H-22.html#%_idx_3502">TK!Solver</a><br /><a href="book-Z-H-18.html#%_idx_2604">tower of types</a><br />
+    <a href="book-Z-H-23.html#__idx_3580">assignment and</a><br />
+    <a href="book-Z-H-23.html#__idx_3720">communication and</a><br />
+    <a href="book-Z-H-23.html#__idx_3584">in concurrent systems</a><br />
+    <a href="book-Z-H-24.html#__idx_4144">functional programming and</a><br />
+    <a href="book-Z-H-28.html#__idx_4820">in nondeterministic computing</a>,
+<a href="book-Z-H-28.html#__idx_4834">[2]</a><br />
+    <a href="book-Z-H-23.html#__idx_3586">purpose of</a><br /><a href="book-Z-H-22.html#__idx_3438">time segment, in agenda</a><br /><a href="book-Z-H-23.html#__idx_3674">time slicing</a><br /><a href="book-Z-H-11.html#__idx_936"><tt>timed-prime-test</tt></a><br /><a href="book-Z-H-23.html#__idx_3602">timing diagram</a><br /><a href="book-Z-H-22.html#__idx_3502">TK!Solver</a><br /><a href="book-Z-H-18.html#__idx_2604">tower of types</a><br />
 tracing
 <br />
-    <a href="book-Z-H-32.html#%_idx_5820">instruction execution</a><br />
-    <a href="book-Z-H-32.html#%_idx_5824">register assignment</a><br /><a href="book-Z-H-15.html#%_idx_1962"><tt>transform-painter</tt></a><br /><a href="book-Z-H-20.html#%_idx_2992">transparency, referential</a><br /><a href="book-Z-H-15.html#%_idx_1806"><tt>transpose</tt> a matrix</a><br />
+    <a href="book-Z-H-32.html#__idx_5820">instruction execution</a><br />
+    <a href="book-Z-H-32.html#__idx_5824">register assignment</a><br /><a href="book-Z-H-15.html#__idx_1962"><tt>transform-painter</tt></a><br /><a href="book-Z-H-20.html#__idx_2992">transparency, referential</a><br /><a href="book-Z-H-15.html#__idx_1806"><tt>transpose</tt> a matrix</a><br />
 tree
 <br />
-    <a href="book-Z-H-16.html#%_idx_2168">B-tree</a><br />
-    <a href="book-Z-H-16.html#%_idx_2140">binary</a>,
+    <a href="book-Z-H-16.html#__idx_2168">B-tree</a><br />
+    <a href="book-Z-H-16.html#__idx_2140">binary</a>,
 <em>see also</em> binary tree
 <br />
-    <a href="book-Z-H-10.html#%_idx_254">combination viewed as</a><br />
-    <a href="book-Z-H-15.html#%_idx_1684">counting leaves of</a><br />
-    <a href="book-Z-H-15.html#%_idx_1748">enumerating leaves of</a><br />
-    <a href="book-Z-H-15.html#%_idx_1698">fringe of</a><br />
-    <a href="book-Z-H-16.html#%_idx_2242">Huffman</a><br />
-    <a href="book-Z-H-27.html#%_idx_4796">lazy</a><br />
-    <a href="book-Z-H-15.html#%_idx_1704">mapping over</a><br />
-    <a href="book-Z-H-16.html#%_idx_2170">red-black</a><br />
-    <a href="book-Z-H-15.html#%_idx_1676">represented as pairs</a><br />
-    <a href="book-Z-H-15.html#%_idx_1694">reversing at all levels</a><br /><a href="book-Z-H-10.html#%_idx_262">tree accumulation</a><br /><a href="book-Z-H-16.html#%_idx_2186"><tt>tree-&gt;list...</tt></a><br /><a href="book-Z-H-15.html#%_idx_1712"><tt>tree-map</tt></a><br /><a href="book-Z-H-11.html#%_idx_712">tree-recursive process</a><br />
-    <a href="book-Z-H-11.html#%_idx_776">order of growth</a><br /><a href="book-Z-H-17.html#%_idx_2342">trigonometric relations</a><br /><a href="book-Z-H-10.html#%_idx_368">true</a><br /><a href="book-Z-H-10.html#%_idx_376"><tt>true</tt></a><br /><a href="book-Z-H-26.html#%_idx_4434"><tt>true?</tt></a><br /><a href="book-Z-H-10.html#%_idx_146">truncation error</a><br /><a href="book-Z-H-28.html#%_idx_4894">truth maintenance</a><br /><a href="book-Z-H-28.html#%_idx_4910"><tt>try-again</tt></a><br /><a href="book-Z-H-26.html#%_idx_4560">Turing machine</a><br /><a href="book-Z-H-26.html#%_idx_4556">Turing, Alan M.</a>, <a href="book-Z-H-26.html#%_idx_4590">[2]</a><br /><a href="book-Z-H-15.html#%_idx_1820">Turner, David</a>, <a href="book-Z-H-24.html#%_idx_3996">[2]</a>,
-<a href="book-Z-H-24.html#%_idx_4174">[3]</a><br /><a href="book-Z-H-33.html#%_idx_5870">type field</a><br /><a href="book-Z-H-17.html#%_idx_2296">type tag</a>, <a href="book-Z-H-17.html#%_idx_2366">[2]</a><br />
-    <a href="book-Z-H-18.html#%_idx_2548">two-level</a><br />
+    <a href="book-Z-H-10.html#__idx_254">combination viewed as</a><br />
+    <a href="book-Z-H-15.html#__idx_1684">counting leaves of</a><br />
+    <a href="book-Z-H-15.html#__idx_1748">enumerating leaves of</a><br />
+    <a href="book-Z-H-15.html#__idx_1698">fringe of</a><br />
+    <a href="book-Z-H-16.html#__idx_2242">Huffman</a><br />
+    <a href="book-Z-H-27.html#__idx_4796">lazy</a><br />
+    <a href="book-Z-H-15.html#__idx_1704">mapping over</a><br />
+    <a href="book-Z-H-16.html#__idx_2170">red-black</a><br />
+    <a href="book-Z-H-15.html#__idx_1676">represented as pairs</a><br />
+    <a href="book-Z-H-15.html#__idx_1694">reversing at all levels</a><br /><a href="book-Z-H-10.html#__idx_262">tree accumulation</a><br /><a href="book-Z-H-16.html#__idx_2186"><tt>tree-&gt;list...</tt></a><br /><a href="book-Z-H-15.html#__idx_1712"><tt>tree-map</tt></a><br /><a href="book-Z-H-11.html#__idx_712">tree-recursive process</a><br />
+    <a href="book-Z-H-11.html#__idx_776">order of growth</a><br /><a href="book-Z-H-17.html#__idx_2342">trigonometric relations</a><br /><a href="book-Z-H-10.html#__idx_368">true</a><br /><a href="book-Z-H-10.html#__idx_376"><tt>true</tt></a><br /><a href="book-Z-H-26.html#__idx_4434"><tt>true?</tt></a><br /><a href="book-Z-H-10.html#__idx_146">truncation error</a><br /><a href="book-Z-H-28.html#__idx_4894">truth maintenance</a><br /><a href="book-Z-H-28.html#__idx_4910"><tt>try-again</tt></a><br /><a href="book-Z-H-26.html#__idx_4560">Turing machine</a><br /><a href="book-Z-H-26.html#__idx_4556">Turing, Alan M.</a>, <a href="book-Z-H-26.html#__idx_4590">[2]</a><br /><a href="book-Z-H-15.html#__idx_1820">Turner, David</a>, <a href="book-Z-H-24.html#__idx_3996">[2]</a>,
+<a href="book-Z-H-24.html#__idx_4174">[3]</a><br /><a href="book-Z-H-33.html#__idx_5870">type field</a><br /><a href="book-Z-H-17.html#__idx_2296">type tag</a>, <a href="book-Z-H-17.html#__idx_2366">[2]</a><br />
+    <a href="book-Z-H-18.html#__idx_2548">two-level</a><br />
 type(s)
 <br />
-    <a href="book-Z-H-18.html#%_idx_2576">cross-type operations</a><br />
-    <a href="book-Z-H-17.html#%_idx_2432">dispatching on</a><br />
-    <a href="book-Z-H-18.html#%_idx_2768">hierarchy in symbolic algebra</a><br />
-    <a href="book-Z-H-18.html#%_idx_2592">hierarchy of</a><br />
-    <a href="book-Z-H-18.html#%_idx_2612">lowering</a>, <a href="book-Z-H-18.html#%_idx_2640">[2]</a><br />
-    <a href="book-Z-H-18.html#%_idx_2616">multiple subtype and supertype</a><br />
-    <a href="book-Z-H-18.html#%_idx_2608">raising</a>, <a href="book-Z-H-18.html#%_idx_2634">[2]</a><br />
-    <a href="book-Z-H-18.html#%_idx_2598">subtype</a><br />
-    <a href="book-Z-H-18.html#%_idx_2602">supertype</a><br />
-    <a href="book-Z-H-18.html#%_idx_2606">tower of</a><br /><a href="book-Z-H-24.html#%_idx_4114">type-inferencing mechanism</a><br /><a href="book-Z-H-17.html#%_idx_2370"><tt>type-tag</tt></a><br />
-    <a href="book-Z-H-18.html#%_idx_2560">using Scheme data types</a><br /><a href="book-Z-H-33.html#%_idx_5860">typed pointer</a><br /><a href="book-Z-H-10.html#%_idx_202">typing input expressions</a></p><p>
+    <a href="book-Z-H-18.html#__idx_2576">cross-type operations</a><br />
+    <a href="book-Z-H-17.html#__idx_2432">dispatching on</a><br />
+    <a href="book-Z-H-18.html#__idx_2768">hierarchy in symbolic algebra</a><br />
+    <a href="book-Z-H-18.html#__idx_2592">hierarchy of</a><br />
+    <a href="book-Z-H-18.html#__idx_2612">lowering</a>, <a href="book-Z-H-18.html#__idx_2640">[2]</a><br />
+    <a href="book-Z-H-18.html#__idx_2616">multiple subtype and supertype</a><br />
+    <a href="book-Z-H-18.html#__idx_2608">raising</a>, <a href="book-Z-H-18.html#__idx_2634">[2]</a><br />
+    <a href="book-Z-H-18.html#__idx_2598">subtype</a><br />
+    <a href="book-Z-H-18.html#__idx_2602">supertype</a><br />
+    <a href="book-Z-H-18.html#__idx_2606">tower of</a><br /><a href="book-Z-H-24.html#__idx_4114">type-inferencing mechanism</a><br /><a href="book-Z-H-17.html#__idx_2370"><tt>type-tag</tt></a><br />
+    <a href="book-Z-H-18.html#__idx_2560">using Scheme data types</a><br /><a href="book-Z-H-33.html#__idx_5860">typed pointer</a><br /><a href="book-Z-H-10.html#__idx_202">typing input expressions</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-21.html#%_idx_3054">unbound variable</a><br /><a href="book-Z-H-34.html#%_idx_6030"><tt>unev</tt> register</a><br /><a href="book-Z-H-29.html#%_idx_5210">unification</a><br />
-    <a href="book-Z-H-29.html#%_idx_5044">discovery of algorithm</a><br />
-    <a href="book-Z-H-29.html#%_idx_5362">implementation</a><br />
-    <a href="book-Z-H-29.html#%_idx_5214">pattern matching vs.</a>,
-<a href="book-Z-H-29.html#%_idx_5224">[2]</a><br /><a href="book-Z-H-29.html#%_idx_5364"><tt>unify-match</tt></a><br /><a href="book-Z-H-16.html#%_idx_2108"><tt>union-set</tt></a><br />
-    <a href="book-Z-H-16.html#%_idx_2194">binary-tree representation</a><br />
-    <a href="book-Z-H-16.html#%_idx_2134">ordered-list representation</a><br />
-    <a href="book-Z-H-16.html#%_idx_2122">unordered-list representation</a><br /><a href="book-Z-H-29.html#%_idx_5424"><tt>unique</tt> (query language)</a><br /><a href="book-Z-H-15.html#%_idx_1844"><tt>unique-pairs</tt></a><br /><a href="book-Z-H-15.html#%_idx_1922">unit square</a><br /><a href="book-Z-H-18.html#%_idx_2658">univariate polynomial</a><br /><a href="book-Z-H-26.html#%_idx_4552">universal machine</a><br />
-    <a href="book-Z-H-35.html#%_idx_6196">explicit-control evaluator as</a><br />
-    <a href="book-Z-H-35.html#%_idx_6200">general-purpose computer as</a><br /><a href="book-Z-H-9.html#%_idx_78">University of California at Berkeley</a><br /><a href="book-Z-H-29.html#%_idx_5064">University of Edinburgh</a><br /><a href="book-Z-H-29.html#%_idx_5062">University of Marseille</a><br /><a href="book-Z-H-34.html#%_idx_6188">UNIX</a>, <a href="book-Z-H-35.html#%_idx_6500">[2]</a><br /><a href="book-Z-H-34.html#%_idx_6152"><tt>unknown-expression-type</tt></a><br /><a href="book-Z-H-34.html#%_idx_6154"><tt>unknown-procedure-type</tt></a><br /><a href="book-Z-H-16.html#%_idx_2114">unordered-list representation of sets</a><br />
+<br /><a href="book-Z-H-21.html#__idx_3054">unbound variable</a><br /><a href="book-Z-H-34.html#__idx_6030"><tt>unev</tt> register</a><br /><a href="book-Z-H-29.html#__idx_5210">unification</a><br />
+    <a href="book-Z-H-29.html#__idx_5044">discovery of algorithm</a><br />
+    <a href="book-Z-H-29.html#__idx_5362">implementation</a><br />
+    <a href="book-Z-H-29.html#__idx_5214">pattern matching vs.</a>,
+<a href="book-Z-H-29.html#__idx_5224">[2]</a><br /><a href="book-Z-H-29.html#__idx_5364"><tt>unify-match</tt></a><br /><a href="book-Z-H-16.html#__idx_2108"><tt>union-set</tt></a><br />
+    <a href="book-Z-H-16.html#__idx_2194">binary-tree representation</a><br />
+    <a href="book-Z-H-16.html#__idx_2134">ordered-list representation</a><br />
+    <a href="book-Z-H-16.html#__idx_2122">unordered-list representation</a><br /><a href="book-Z-H-29.html#__idx_5424"><tt>unique</tt> (query language)</a><br /><a href="book-Z-H-15.html#__idx_1844"><tt>unique-pairs</tt></a><br /><a href="book-Z-H-15.html#__idx_1922">unit square</a><br /><a href="book-Z-H-18.html#__idx_2658">univariate polynomial</a><br /><a href="book-Z-H-26.html#__idx_4552">universal machine</a><br />
+    <a href="book-Z-H-35.html#__idx_6196">explicit-control evaluator as</a><br />
+    <a href="book-Z-H-35.html#__idx_6200">general-purpose computer as</a><br /><a href="book-Z-H-9.html#__idx_78">University of California at Berkeley</a><br /><a href="book-Z-H-29.html#__idx_5064">University of Edinburgh</a><br /><a href="book-Z-H-29.html#__idx_5062">University of Marseille</a><br /><a href="book-Z-H-34.html#__idx_6188">UNIX</a>, <a href="book-Z-H-35.html#__idx_6500">[2]</a><br /><a href="book-Z-H-34.html#__idx_6152"><tt>unknown-expression-type</tt></a><br /><a href="book-Z-H-34.html#__idx_6154"><tt>unknown-procedure-type</tt></a><br /><a href="book-Z-H-16.html#__idx_2114">unordered-list representation of sets</a><br />
 unspecified values
 <br />
-    <a href="book-Z-H-10.html#%_idx_230"><tt>define</tt></a><br />
-    <a href="book-Z-H-14.html#%_idx_1366"><tt>display</tt></a><br />
-    <a href="book-Z-H-22.html#%_idx_3476"><tt>if</tt> without alternative</a><br />
-    <a href="book-Z-H-14.html#%_idx_1368"><tt>newline</tt></a><br />
-    <a href="book-Z-H-20.html#%_idx_2866"><tt>set!</tt></a><br />
-    <a href="book-Z-H-22.html#%_idx_3150"><tt>set-car!</tt></a><br />
-    <a href="book-Z-H-22.html#%_idx_3154"><tt>set-cdr!</tt></a><br /><a href="book-Z-H-15.html#%_idx_1896"><tt>up-split</tt></a><br /><a href="book-Z-H-32.html#%_idx_5702"><tt>update-insts!</tt></a><br /><a href="book-Z-H-14.html#%_idx_1504"><tt>upper-bound</tt></a><br /><a href="book-Z-H-27.html#%_idx_4752">upward compatibility</a><br /><a href="book-Z-H-26.html#%_idx_4586"><tt>user-initial-environment</tt> (MIT Scheme)</a><br /><a href="book-Z-H-26.html#%_idx_4538"><tt>user-print</tt></a><br />
-    <a href="book-Z-H-35.html#%_idx_6480">modified for compiled code</a></p><p>
+    <a href="book-Z-H-10.html#__idx_230"><tt>define</tt></a><br />
+    <a href="book-Z-H-14.html#__idx_1366"><tt>display</tt></a><br />
+    <a href="book-Z-H-22.html#__idx_3476"><tt>if</tt> without alternative</a><br />
+    <a href="book-Z-H-14.html#__idx_1368"><tt>newline</tt></a><br />
+    <a href="book-Z-H-20.html#__idx_2866"><tt>set!</tt></a><br />
+    <a href="book-Z-H-22.html#__idx_3150"><tt>set-car!</tt></a><br />
+    <a href="book-Z-H-22.html#__idx_3154"><tt>set-cdr!</tt></a><br /><a href="book-Z-H-15.html#__idx_1896"><tt>up-split</tt></a><br /><a href="book-Z-H-32.html#__idx_5702"><tt>update-insts!</tt></a><br /><a href="book-Z-H-14.html#__idx_1504"><tt>upper-bound</tt></a><br /><a href="book-Z-H-27.html#__idx_4752">upward compatibility</a><br /><a href="book-Z-H-26.html#__idx_4586"><tt>user-initial-environment</tt> (MIT Scheme)</a><br /><a href="book-Z-H-26.html#__idx_4538"><tt>user-print</tt></a><br />
+    <a href="book-Z-H-35.html#__idx_6480">modified for compiled code</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-23.html#%_idx_3656">V operation on semaphore</a><br /><a href="book-Z-H-34.html#%_idx_6022"><tt>val</tt> register</a><br />
+<br /><a href="book-Z-H-23.html#__idx_3656">V operation on semaphore</a><br /><a href="book-Z-H-34.html#__idx_6022"><tt>val</tt> register</a><br />
 value
 <br />
-    <a href="book-Z-H-10.html#%_idx_186">of a combination</a><br />
-    <a href="book-Z-H-10.html#%_idx_212">of an expression</a>,
+    <a href="book-Z-H-10.html#__idx_186">of a combination</a><br />
+    <a href="book-Z-H-10.html#__idx_212">of an expression</a>,
 <em>see also</em> unspecified values
-<br /><a href="book-Z-H-32.html#%_idx_5728"><tt>value-proc</tt></a><br /><a href="book-Z-H-10.html#%_idx_220">variable</a>, <em>see also</em> local variable
+<br /><a href="book-Z-H-32.html#__idx_5728"><tt>value-proc</tt></a><br /><a href="book-Z-H-10.html#__idx_220">variable</a>, <em>see also</em> local variable
 <br />
-    <a href="book-Z-H-10.html#%_idx_586">bound</a><br />
-    <a href="book-Z-H-10.html#%_idx_592">free</a><br />
-    <a href="book-Z-H-10.html#%_idx_596">scope of</a>,
+    <a href="book-Z-H-10.html#__idx_586">bound</a><br />
+    <a href="book-Z-H-10.html#__idx_592">free</a><br />
+    <a href="book-Z-H-10.html#__idx_596">scope of</a>,
 <em>see also</em> scope of a variable
 <br />
-    <a href="book-Z-H-21.html#%_idx_3056">unbound</a><br />
-    <a href="book-Z-H-10.html#%_idx_222">value of</a>, <a href="book-Z-H-21.html#%_idx_3052">[2]</a><br /><a href="book-Z-H-18.html#%_idx_2688"><tt>variable</tt></a><br /><a href="book-Z-H-16.html#%_idx_2224">variable-length code</a><br /><a href="book-Z-H-16.html#%_idx_2064"><tt>variable?</tt></a>, <a href="book-Z-H-26.html#%_idx_4284">[2]</a><br /><a href="book-Z-H-33.html#%_idx_5842">vector (data structure)</a><br />
+    <a href="book-Z-H-21.html#__idx_3056">unbound</a><br />
+    <a href="book-Z-H-10.html#__idx_222">value of</a>, <a href="book-Z-H-21.html#__idx_3052">[2]</a><br /><a href="book-Z-H-18.html#__idx_2688"><tt>variable</tt></a><br /><a href="book-Z-H-16.html#__idx_2224">variable-length code</a><br /><a href="book-Z-H-16.html#__idx_2064"><tt>variable?</tt></a>, <a href="book-Z-H-26.html#__idx_4284">[2]</a><br /><a href="book-Z-H-33.html#__idx_5842">vector (data structure)</a><br />
 vector (mathematical)
 <br />
-    <a href="book-Z-H-15.html#%_idx_1800">operations on</a>,
-<a href="book-Z-H-15.html#%_idx_1930">[2]</a><br />
-    <a href="book-Z-H-15.html#%_idx_1912">in picture-language frame</a><br />
-    <a href="book-Z-H-15.html#%_idx_1928">represented as pair</a><br />
-    <a href="book-Z-H-15.html#%_idx_1798">represented as sequence</a><br /><a href="book-Z-H-33.html#%_idx_5844"><tt>vector-ref</tt> (primitive procedure)</a><br /><a href="book-Z-H-33.html#%_idx_5848"><tt>vector-set!</tt> (primitive procedure)</a><br /><a href="book-Z-H-16.html#%_idx_1996">Venus</a><br /><a href="book-Z-H-28.html#%_idx_4958"><tt>verbs</tt></a><br /><a href="book-Z-H-10.html#%_idx_506">very high-level language</a></p><p>
+    <a href="book-Z-H-15.html#__idx_1800">operations on</a>,
+<a href="book-Z-H-15.html#__idx_1930">[2]</a><br />
+    <a href="book-Z-H-15.html#__idx_1912">in picture-language frame</a><br />
+    <a href="book-Z-H-15.html#__idx_1928">represented as pair</a><br />
+    <a href="book-Z-H-15.html#__idx_1798">represented as sequence</a><br /><a href="book-Z-H-33.html#__idx_5844"><tt>vector-ref</tt> (primitive procedure)</a><br /><a href="book-Z-H-33.html#__idx_5848"><tt>vector-set!</tt> (primitive procedure)</a><br /><a href="book-Z-H-16.html#__idx_1996">Venus</a><br /><a href="book-Z-H-28.html#__idx_4958"><tt>verbs</tt></a><br /><a href="book-Z-H-10.html#__idx_506">very high-level language</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-20.html#%_idx_3012">Wadler, Philip</a><br /><a href="book-Z-H-24.html#%_idx_4112">Wadsworth, Christopher</a><br /><a href="book-Z-H-14.html#%_idx_1434">Wagner, Eric G.</a><br /><a href="book-Z-H-15.html#%_idx_1874">Walker, Francis Amasa</a><br /><a href="book-Z-H-12.html#%_idx_1016">Wallis, John</a><br /><a href="book-Z-H-25.html#%_idx_4206">Wand, Mitchell</a>, <a href="book-Z-H-34.html#%_idx_6068">[2]</a><br /><a href="book-Z-H-15.html#%_idx_1760">Waters, Richard C.</a><br /><a href="book-Z-H-16.html#%_idx_2266"><tt>weight</tt></a><br /><a href="book-Z-H-16.html#%_idx_2256"><tt>weight-leaf</tt></a><br /><a href="book-Z-H-13.html#%_idx_1254">Weyl, Hermann</a><br />
+<br /><a href="book-Z-H-20.html#__idx_3012">Wadler, Philip</a><br /><a href="book-Z-H-24.html#__idx_4112">Wadsworth, Christopher</a><br /><a href="book-Z-H-14.html#__idx_1434">Wagner, Eric G.</a><br /><a href="book-Z-H-15.html#__idx_1874">Walker, Francis Amasa</a><br /><a href="book-Z-H-12.html#__idx_1016">Wallis, John</a><br /><a href="book-Z-H-25.html#__idx_4206">Wand, Mitchell</a>, <a href="book-Z-H-34.html#__idx_6068">[2]</a><br /><a href="book-Z-H-15.html#__idx_1760">Waters, Richard C.</a><br /><a href="book-Z-H-16.html#__idx_2266"><tt>weight</tt></a><br /><a href="book-Z-H-16.html#__idx_2256"><tt>weight-leaf</tt></a><br /><a href="book-Z-H-13.html#__idx_1254">Weyl, Hermann</a><br />
 “what is” vs. “how to” description, <em>see</em> declarative vs. imperative knowledge
-<br /><a href="book-Z-H-29.html#%_idx_5144"><tt>wheel</tt> (rule)</a>,
-<a href="book-Z-H-29.html#%_idx_5278">[2]</a><br /><a href="book-Z-H-14.html#%_idx_1520"><tt>width</tt></a><br /><a href="book-Z-H-14.html#%_idx_1510">width of an interval</a><br /><a href="book-Z-H-10.html#%_idx_210">Wilde, Oscar (Perlis's paraphrase of)</a><br /><a href="book-Z-H-11.html#%_idx_884">Wiles, Andrew</a><br /><a href="book-Z-H-28.html#%_idx_4870">Winograd, Terry</a><br /><a href="book-Z-H-28.html#%_idx_4906">Winston, Patrick Henry</a>,
-<a href="book-Z-H-28.html#%_idx_4974">[2]</a><br /><a href="book-Z-H-22.html#%_idx_3334">wire, in digital circuit</a><br /><a href="book-Z-H-9.html#%_idx_110">Wisdom, Jack</a><br /><a href="book-Z-H-24.html#%_idx_3814">Wise, David S.</a><br /><a href="book-Z-H-14.html#%_idx_1306">wishful thinking</a>,
-<a href="book-Z-H-16.html#%_idx_2050">[2]</a><br /><a href="book-Z-H-20.html#%_idx_2858"><tt>withdraw</tt></a><br />
-    <a href="book-Z-H-23.html#%_idx_3592">problems in concurrent system</a><br /><a href="book-Z-H-23.html#%_idx_3676"><tt>without-interrupts</tt></a><br /><a href="book-Z-H-24.html#%_idx_3728">world line of a particle</a>,
-<a href="book-Z-H-24.html#%_idx_4156">[2]</a><br /><a href="book-Z-H-24.html#%_idx_3884">Wright, E. M.</a><br /><a href="book-Z-H-14.html#%_idx_1436">Wright, Jesse B.</a></p><p>
+<br /><a href="book-Z-H-29.html#__idx_5144"><tt>wheel</tt> (rule)</a>,
+<a href="book-Z-H-29.html#__idx_5278">[2]</a><br /><a href="book-Z-H-14.html#__idx_1520"><tt>width</tt></a><br /><a href="book-Z-H-14.html#__idx_1510">width of an interval</a><br /><a href="book-Z-H-10.html#__idx_210">Wilde, Oscar (Perlis's paraphrase of)</a><br /><a href="book-Z-H-11.html#__idx_884">Wiles, Andrew</a><br /><a href="book-Z-H-28.html#__idx_4870">Winograd, Terry</a><br /><a href="book-Z-H-28.html#__idx_4906">Winston, Patrick Henry</a>,
+<a href="book-Z-H-28.html#__idx_4974">[2]</a><br /><a href="book-Z-H-22.html#__idx_3334">wire, in digital circuit</a><br /><a href="book-Z-H-9.html#__idx_110">Wisdom, Jack</a><br /><a href="book-Z-H-24.html#__idx_3814">Wise, David S.</a><br /><a href="book-Z-H-14.html#__idx_1306">wishful thinking</a>,
+<a href="book-Z-H-16.html#__idx_2050">[2]</a><br /><a href="book-Z-H-20.html#__idx_2858"><tt>withdraw</tt></a><br />
+    <a href="book-Z-H-23.html#__idx_3592">problems in concurrent system</a><br /><a href="book-Z-H-23.html#__idx_3676"><tt>without-interrupts</tt></a><br /><a href="book-Z-H-24.html#__idx_3728">world line of a particle</a>,
+<a href="book-Z-H-24.html#__idx_4156">[2]</a><br /><a href="book-Z-H-24.html#__idx_3884">Wright, E. M.</a><br /><a href="book-Z-H-14.html#__idx_1436">Wright, Jesse B.</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-15.html#%_idx_1934"><tt>xcor-vect</tt></a><br /><a href="book-Z-H-9.html#%_idx_64">Xerox Palo Alto Research Center</a>,
-<a href="book-Z-H-22.html#%_idx_3494">[2]</a></p><p>
+<br /><a href="book-Z-H-15.html#__idx_1934"><tt>xcor-vect</tt></a><br /><a href="book-Z-H-9.html#__idx_64">Xerox Palo Alto Research Center</a>,
+<a href="book-Z-H-22.html#__idx_3494">[2]</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-26.html#%_idx_4628"><em>Y</em> operator</a><br /><a href="book-Z-H-15.html#%_idx_1936"><tt>ycor-vect</tt></a><br /><a href="book-Z-H-33.html#%_idx_5944">Yochelson, Jerome C.</a></p><p>
+<br /><a href="book-Z-H-26.html#__idx_4628"><em>Y</em> operator</a><br /><a href="book-Z-H-15.html#__idx_1936"><tt>ycor-vect</tt></a><br /><a href="book-Z-H-33.html#__idx_5944">Yochelson, Jerome C.</a></p><p>
 
 </p><p></p><p>
 
-<br /><a href="book-Z-H-28.html#%_idx_4900">Zabih, Ramin</a><br /><a href="book-Z-H-24.html#%_idx_4036">zero crossings of a signal</a>,
-<a href="book-Z-H-24.html#%_idx_4040">[2]</a>, <a href="book-Z-H-24.html#%_idx_4048">[3]</a><br /><a href="book-Z-H-18.html#%_idx_2570">zero test (generic)</a><br />
-    <a href="book-Z-H-18.html#%_idx_2754">for polynomials</a><br /><a href="book-Z-H-9.html#%_idx_80">Zetalisp</a><br /><a href="book-Z-H-14.html#%_idx_1428">Zilles, Stephen N.</a><br /><a href="book-Z-H-18.html#%_idx_2818">Zippel, Richard E.</a></p><p>
+<br /><a href="book-Z-H-28.html#__idx_4900">Zabih, Ramin</a><br /><a href="book-Z-H-24.html#__idx_4036">zero crossings of a signal</a>,
+<a href="book-Z-H-24.html#__idx_4040">[2]</a>, <a href="book-Z-H-24.html#__idx_4048">[3]</a><br /><a href="book-Z-H-18.html#__idx_2570">zero test (generic)</a><br />
+    <a href="book-Z-H-18.html#__idx_2754">for polynomials</a><br /><a href="book-Z-H-9.html#__idx_80">Zetalisp</a><br /><a href="book-Z-H-14.html#__idx_1428">Zilles, Stephen N.</a><br /><a href="book-Z-H-18.html#__idx_2818">Zippel, Richard E.</a></p><p>
 
 
 </p><p>
diff --git a/src/OEBPS/book-Z-H-4.html b/src/OEBPS/book-Z-H-4.html
index d4f738c..8058973 100644
--- a/src/OEBPS/book-Z-H-4.html
+++ b/src/OEBPS/book-Z-H-4.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,140 +13,140 @@
 
 
 
-<a name="%_chap_Temp_1" id="%_chap_Temp_1"></a>
+<a id="__chap_Temp_1"></a>
 <h1 class="chapter">
 <div class="chapterheading"> </div></h1><p>
 Contents</p><p>
 
-<a name="%_toc_start" id="%_toc_start"><p><b>
-    <a name="%_toc_%_chap_Temp_2" href="book-Z-H-5.html#%_chap_Temp_2" id="%_toc_%_chap_Temp_2">Foreword</a></b><br /></p><p><b>
-    <a name="%_toc_%_chap_Temp_3" href="book-Z-H-6.html#%_chap_Temp_3" id="%_toc_%_chap_Temp_3">Preface to the Second Edition</a></b><br /></p><p><b>
-    <a name="%_toc_%_chap_Temp_4" href="book-Z-H-7.html#%_chap_Temp_4" id="%_toc_%_chap_Temp_4">Preface to the First Edition</a></b><br /></p><p><b>
-    <a name="%_toc_%_chap_Temp_5" href="book-Z-H-8.html#%_chap_Temp_5" id="%_toc_%_chap_Temp_5">Acknowledgments</a></b><br /></p><p><b>
-    <a name="%_toc_%_chap_1" href="book-Z-H-9.html#%_chap_1" id="%_toc_%_chap_1">1  Building Abstractions with Procedures</a></b><br />
-        <a name="%_toc_%_sec_1.1" href="book-Z-H-10.html#%_sec_1.1" id="%_toc_%_sec_1.1">1.1  The Elements of Programming</a><br />
-            <a name="%_toc_%_sec_1.1.1" href="book-Z-H-10.html#%_sec_1.1.1" id="%_toc_%_sec_1.1.1">1.1.1  Expressions</a><br />
-            <a name="%_toc_%_sec_1.1.2" href="book-Z-H-10.html#%_sec_1.1.2" id="%_toc_%_sec_1.1.2">1.1.2  Naming and the Environment</a><br />
-            <a name="%_toc_%_sec_1.1.3" href="book-Z-H-10.html#%_sec_1.1.3" id="%_toc_%_sec_1.1.3">1.1.3  Evaluating Combinations</a><br />
-            <a name="%_toc_%_sec_1.1.4" href="book-Z-H-10.html#%_sec_1.1.4" id="%_toc_%_sec_1.1.4">1.1.4  Compound Procedures</a><br />
-            <a name="%_toc_%_sec_1.1.5" href="book-Z-H-10.html#%_sec_1.1.5" id="%_toc_%_sec_1.1.5">1.1.5  The Substitution Model for Procedure Application</a><br />
-            <a name="%_toc_%_sec_1.1.6" href="book-Z-H-10.html#%_sec_1.1.6" id="%_toc_%_sec_1.1.6">1.1.6  Conditional Expressions and Predicates</a><br />
-            <a name="%_toc_%_sec_1.1.7" href="book-Z-H-10.html#%_sec_1.1.7" id="%_toc_%_sec_1.1.7">1.1.7  Example: Square Roots by Newton's Method</a><br />
-            <a name="%_toc_%_sec_1.1.8" href="book-Z-H-10.html#%_sec_1.1.8" id="%_toc_%_sec_1.1.8">1.1.8  Procedures as Black-Box Abstractions</a><br />
-        <a name="%_toc_%_sec_1.2" href="book-Z-H-11.html#%_sec_1.2" id="%_toc_%_sec_1.2">1.2  Procedures and the Processes They Generate</a><br />
-            <a name="%_toc_%_sec_1.2.1" href="book-Z-H-11.html#%_sec_1.2.1" id="%_toc_%_sec_1.2.1">1.2.1  Linear Recursion and Iteration</a><br />
-            <a name="%_toc_%_sec_1.2.2" href="book-Z-H-11.html#%_sec_1.2.2" id="%_toc_%_sec_1.2.2">1.2.2  Tree Recursion</a><br />
-            <a name="%_toc_%_sec_1.2.3" href="book-Z-H-11.html#%_sec_1.2.3" id="%_toc_%_sec_1.2.3">1.2.3  Orders of Growth</a><br />
-            <a name="%_toc_%_sec_1.2.4" href="book-Z-H-11.html#%_sec_1.2.4" id="%_toc_%_sec_1.2.4">1.2.4  Exponentiation</a><br />
-            <a name="%_toc_%_sec_1.2.5" href="book-Z-H-11.html#%_sec_1.2.5" id="%_toc_%_sec_1.2.5">1.2.5  Greatest Common Divisors</a><br />
-            <a name="%_toc_%_sec_1.2.6" href="book-Z-H-11.html#%_sec_1.2.6" id="%_toc_%_sec_1.2.6">1.2.6  Example: Testing for Primality</a><br />
-        <a name="%_toc_%_sec_1.3" href="book-Z-H-12.html#%_sec_1.3" id="%_toc_%_sec_1.3">1.3  Formulating Abstractions with Higher-Order Procedures</a><br />
-            <a name="%_toc_%_sec_1.3.1" href="book-Z-H-12.html#%_sec_1.3.1" id="%_toc_%_sec_1.3.1">1.3.1  Procedures as Arguments</a><br />
-            <a name="%_toc_%_sec_1.3.2" href="book-Z-H-12.html#%_sec_1.3.2" id="%_toc_%_sec_1.3.2">1.3.2  Constructing Procedures Using <tt>Lambda</tt></a><br />
-            <a name="%_toc_%_sec_1.3.3" href="book-Z-H-12.html#%_sec_1.3.3" id="%_toc_%_sec_1.3.3">1.3.3  Procedures as General Methods</a><br />
-            <a name="%_toc_%_sec_1.3.4" href="book-Z-H-12.html#%_sec_1.3.4" id="%_toc_%_sec_1.3.4">1.3.4  Procedures as Returned Values</a><br /></p><p><b>
-    <a name="%_toc_%_chap_2" href="book-Z-H-13.html#%_chap_2" id="%_toc_%_chap_2">2  Building Abstractions with Data</a></b><br />
-        <a name="%_toc_%_sec_2.1" href="book-Z-H-14.html#%_sec_2.1" id="%_toc_%_sec_2.1">2.1  Introduction to Data Abstraction</a><br />
-            <a name="%_toc_%_sec_2.1.1" href="book-Z-H-14.html#%_sec_2.1.1" id="%_toc_%_sec_2.1.1">2.1.1  Example: Arithmetic Operations for Rational Numbers</a><br />
-            <a name="%_toc_%_sec_2.1.2" href="book-Z-H-14.html#%_sec_2.1.2" id="%_toc_%_sec_2.1.2">2.1.2  Abstraction Barriers</a><br />
-            <a name="%_toc_%_sec_2.1.3" href="book-Z-H-14.html#%_sec_2.1.3" id="%_toc_%_sec_2.1.3">2.1.3  What Is Meant by Data?</a><br />
-            <a name="%_toc_%_sec_2.1.4" href="book-Z-H-14.html#%_sec_2.1.4" id="%_toc_%_sec_2.1.4">2.1.4  Extended Exercise: Interval Arithmetic</a><br />
-        <a name="%_toc_%_sec_2.2" href="book-Z-H-15.html#%_sec_2.2" id="%_toc_%_sec_2.2">2.2  Hierarchical Data and the Closure Property</a><br />
-            <a name="%_toc_%_sec_2.2.1" href="book-Z-H-15.html#%_sec_2.2.1" id="%_toc_%_sec_2.2.1">2.2.1  Representing Sequences</a><br />
-            <a name="%_toc_%_sec_2.2.2" href="book-Z-H-15.html#%_sec_2.2.2" id="%_toc_%_sec_2.2.2">2.2.2  Hierarchical Structures</a><br />
-            <a name="%_toc_%_sec_2.2.3" href="book-Z-H-15.html#%_sec_2.2.3" id="%_toc_%_sec_2.2.3">2.2.3  Sequences as Conventional Interfaces</a><br />
-            <a name="%_toc_%_sec_2.2.4" href="book-Z-H-15.html#%_sec_2.2.4" id="%_toc_%_sec_2.2.4">2.2.4  Example: A Picture Language</a><br />
-        <a name="%_toc_%_sec_2.3" href="book-Z-H-16.html#%_sec_2.3" id="%_toc_%_sec_2.3">2.3  Symbolic Data</a><br />
-            <a name="%_toc_%_sec_2.3.1" href="book-Z-H-16.html#%_sec_2.3.1" id="%_toc_%_sec_2.3.1">2.3.1  Quotation</a><br />
-            <a name="%_toc_%_sec_2.3.2" href="book-Z-H-16.html#%_sec_2.3.2" id="%_toc_%_sec_2.3.2">2.3.2  Example: Symbolic Differentiation</a><br />
-            <a name="%_toc_%_sec_2.3.3" href="book-Z-H-16.html#%_sec_2.3.3" id="%_toc_%_sec_2.3.3">2.3.3  Example: Representing Sets</a><br />
-            <a name="%_toc_%_sec_2.3.4" href="book-Z-H-16.html#%_sec_2.3.4" id="%_toc_%_sec_2.3.4">2.3.4  Example: Huffman Encoding Trees</a><br />
-        <a name="%_toc_%_sec_2.4" href="book-Z-H-17.html#%_sec_2.4" id="%_toc_%_sec_2.4">2.4  Multiple Representations for Abstract Data</a><br />
-            <a name="%_toc_%_sec_2.4.1" href="book-Z-H-17.html#%_sec_2.4.1" id="%_toc_%_sec_2.4.1">2.4.1  Representations for Complex Numbers</a><br />
-            <a name="%_toc_%_sec_2.4.2" href="book-Z-H-17.html#%_sec_2.4.2" id="%_toc_%_sec_2.4.2">2.4.2  Tagged data</a><br />
-            <a name="%_toc_%_sec_2.4.3" href="book-Z-H-17.html#%_sec_2.4.3" id="%_toc_%_sec_2.4.3">2.4.3  Data-Directed Programming and Additivity</a><br />
-        <a name="%_toc_%_sec_2.5" href="book-Z-H-18.html#%_sec_2.5" id="%_toc_%_sec_2.5">2.5  Systems with Generic Operations</a><br />
-            <a name="%_toc_%_sec_2.5.1" href="book-Z-H-18.html#%_sec_2.5.1" id="%_toc_%_sec_2.5.1">2.5.1  Generic Arithmetic Operations</a><br />
-            <a name="%_toc_%_sec_2.5.2" href="book-Z-H-18.html#%_sec_2.5.2" id="%_toc_%_sec_2.5.2">2.5.2  Combining Data of Different Types</a><br />
-            <a name="%_toc_%_sec_2.5.3" href="book-Z-H-18.html#%_sec_2.5.3" id="%_toc_%_sec_2.5.3">2.5.3  Example: Symbolic Algebra</a><br /></p><p><b>
-    <a name="%_toc_%_chap_3" href="book-Z-H-19.html#%_chap_3" id="%_toc_%_chap_3">3  Modularity, Objects, and State</a></b><br />
-        <a name="%_toc_%_sec_3.1" href="book-Z-H-20.html#%_sec_3.1" id="%_toc_%_sec_3.1">3.1  Assignment and Local State</a><br />
-            <a name="%_toc_%_sec_3.1.1" href="book-Z-H-20.html#%_sec_3.1.1" id="%_toc_%_sec_3.1.1">3.1.1  Local State Variables</a><br />
-            <a name="%_toc_%_sec_3.1.2" href="book-Z-H-20.html#%_sec_3.1.2" id="%_toc_%_sec_3.1.2">3.1.2  The Benefits of Introducing Assignment</a><br />
-            <a name="%_toc_%_sec_3.1.3" href="book-Z-H-20.html#%_sec_3.1.3" id="%_toc_%_sec_3.1.3">3.1.3  The Costs of Introducing Assignment</a><br />
-        <a name="%_toc_%_sec_3.2" href="book-Z-H-21.html#%_sec_3.2" id="%_toc_%_sec_3.2">3.2  The Environment Model of Evaluation</a><br />
-            <a name="%_toc_%_sec_3.2.1" href="book-Z-H-21.html#%_sec_3.2.1" id="%_toc_%_sec_3.2.1">3.2.1  The Rules for Evaluation</a><br />
-            <a name="%_toc_%_sec_3.2.2" href="book-Z-H-21.html#%_sec_3.2.2" id="%_toc_%_sec_3.2.2">3.2.2  Applying Simple Procedures</a><br />
-            <a name="%_toc_%_sec_3.2.3" href="book-Z-H-21.html#%_sec_3.2.3" id="%_toc_%_sec_3.2.3">3.2.3  Frames as the Repository of Local State</a><br />
-            <a name="%_toc_%_sec_3.2.4" href="book-Z-H-21.html#%_sec_3.2.4" id="%_toc_%_sec_3.2.4">3.2.4  Internal Definitions</a><br />
-        <a name="%_toc_%_sec_3.3" href="book-Z-H-22.html#%_sec_3.3" id="%_toc_%_sec_3.3">3.3  Modeling with Mutable Data</a><br />
-            <a name="%_toc_%_sec_3.3.1" href="book-Z-H-22.html#%_sec_3.3.1" id="%_toc_%_sec_3.3.1">3.3.1  Mutable List Structure</a><br />
-            <a name="%_toc_%_sec_3.3.2" href="book-Z-H-22.html#%_sec_3.3.2" id="%_toc_%_sec_3.3.2">3.3.2  Representing Queues</a><br />
-            <a name="%_toc_%_sec_3.3.3" href="book-Z-H-22.html#%_sec_3.3.3" id="%_toc_%_sec_3.3.3">3.3.3  Representing Tables</a><br />
-            <a name="%_toc_%_sec_3.3.4" href="book-Z-H-22.html#%_sec_3.3.4" id="%_toc_%_sec_3.3.4">3.3.4  A Simulator for Digital Circuits</a><br />
-            <a name="%_toc_%_sec_3.3.5" href="book-Z-H-22.html#%_sec_3.3.5" id="%_toc_%_sec_3.3.5">3.3.5  Propagation of Constraints</a><br />
-        <a name="%_toc_%_sec_3.4" href="book-Z-H-23.html#%_sec_3.4" id="%_toc_%_sec_3.4">3.4  Concurrency: Time Is of the Essence</a><br />
-            <a name="%_toc_%_sec_3.4.1" href="book-Z-H-23.html#%_sec_3.4.1" id="%_toc_%_sec_3.4.1">3.4.1  The Nature of Time in Concurrent Systems</a><br />
-            <a name="%_toc_%_sec_3.4.2" href="book-Z-H-23.html#%_sec_3.4.2" id="%_toc_%_sec_3.4.2">3.4.2  Mechanisms for Controlling Concurrency</a><br />
-        <a name="%_toc_%_sec_3.5" href="book-Z-H-24.html#%_sec_3.5" id="%_toc_%_sec_3.5">3.5  Streams</a><br />
-            <a name="%_toc_%_sec_3.5.1" href="book-Z-H-24.html#%_sec_3.5.1" id="%_toc_%_sec_3.5.1">3.5.1  Streams Are Delayed Lists</a><br />
-            <a name="%_toc_%_sec_3.5.2" href="book-Z-H-24.html#%_sec_3.5.2" id="%_toc_%_sec_3.5.2">3.5.2  Infinite Streams</a><br />
-            <a name="%_toc_%_sec_3.5.3" href="book-Z-H-24.html#%_sec_3.5.3" id="%_toc_%_sec_3.5.3">3.5.3  Exploiting the Stream Paradigm</a><br />
-            <a name="%_toc_%_sec_3.5.4" href="book-Z-H-24.html#%_sec_3.5.4" id="%_toc_%_sec_3.5.4">3.5.4  Streams and Delayed Evaluation</a><br />
-            <a name="%_toc_%_sec_3.5.5" href="book-Z-H-24.html#%_sec_3.5.5" id="%_toc_%_sec_3.5.5">3.5.5  Modularity of Functional Programs and Modularity of Objects</a><br /></p><p><b>
-    <a name="%_toc_%_chap_4" href="book-Z-H-25.html#%_chap_4" id="%_toc_%_chap_4">4  Metalinguistic Abstraction</a></b><br />
-        <a name="%_toc_%_sec_4.1" href="book-Z-H-26.html#%_sec_4.1" id="%_toc_%_sec_4.1">4.1  The Metacircular Evaluator</a><br />
-            <a name="%_toc_%_sec_4.1.1" href="book-Z-H-26.html#%_sec_4.1.1" id="%_toc_%_sec_4.1.1">4.1.1  The Core of the Evaluator</a><br />
-            <a name="%_toc_%_sec_4.1.2" href="book-Z-H-26.html#%_sec_4.1.2" id="%_toc_%_sec_4.1.2">4.1.2  Representing Expressions</a><br />
-            <a name="%_toc_%_sec_4.1.3" href="book-Z-H-26.html#%_sec_4.1.3" id="%_toc_%_sec_4.1.3">4.1.3  Evaluator Data Structures</a><br />
-            <a name="%_toc_%_sec_4.1.4" href="book-Z-H-26.html#%_sec_4.1.4" id="%_toc_%_sec_4.1.4">4.1.4  Running the Evaluator as a Program</a><br />
-            <a name="%_toc_%_sec_4.1.5" href="book-Z-H-26.html#%_sec_4.1.5" id="%_toc_%_sec_4.1.5">4.1.5  Data as Programs</a><br />
-            <a name="%_toc_%_sec_4.1.6" href="book-Z-H-26.html#%_sec_4.1.6" id="%_toc_%_sec_4.1.6">4.1.6  Internal Definitions</a><br />
-            <a name="%_toc_%_sec_4.1.7" href="book-Z-H-26.html#%_sec_4.1.7" id="%_toc_%_sec_4.1.7">4.1.7  Separating Syntactic Analysis from Execution</a><br />
-        <a name="%_toc_%_sec_4.2" href="book-Z-H-27.html#%_sec_4.2" id="%_toc_%_sec_4.2">4.2  Variations on a Scheme – Lazy Evaluation</a><br />
-            <a name="%_toc_%_sec_4.2.1" href="book-Z-H-27.html#%_sec_4.2.1" id="%_toc_%_sec_4.2.1">4.2.1  Normal Order and Applicative Order</a><br />
-            <a name="%_toc_%_sec_4.2.2" href="book-Z-H-27.html#%_sec_4.2.2" id="%_toc_%_sec_4.2.2">4.2.2  An Interpreter with Lazy Evaluation</a><br />
-            <a name="%_toc_%_sec_4.2.3" href="book-Z-H-27.html#%_sec_4.2.3" id="%_toc_%_sec_4.2.3">4.2.3  Streams as Lazy Lists</a><br />
-        <a name="%_toc_%_sec_4.3" href="book-Z-H-28.html#%_sec_4.3" id="%_toc_%_sec_4.3">4.3  Variations on a Scheme – Nondeterministic Computing</a><br />
-            <a name="%_toc_%_sec_4.3.1" href="book-Z-H-28.html#%_sec_4.3.1" id="%_toc_%_sec_4.3.1">4.3.1  Amb and Search</a><br />
-            <a name="%_toc_%_sec_4.3.2" href="book-Z-H-28.html#%_sec_4.3.2" id="%_toc_%_sec_4.3.2">4.3.2  Examples of Nondeterministic Programs</a><br />
-            <a name="%_toc_%_sec_4.3.3" href="book-Z-H-28.html#%_sec_4.3.3" id="%_toc_%_sec_4.3.3">4.3.3  Implementing the <tt>Amb</tt> Evaluator</a><br />
-        <a name="%_toc_%_sec_4.4" href="book-Z-H-29.html#%_sec_4.4" id="%_toc_%_sec_4.4">4.4  Logic Programming</a><br />
-            <a name="%_toc_%_sec_4.4.1" href="book-Z-H-29.html#%_sec_4.4.1" id="%_toc_%_sec_4.4.1">4.4.1  Deductive Information Retrieval</a><br />
-            <a name="%_toc_%_sec_4.4.2" href="book-Z-H-29.html#%_sec_4.4.2" id="%_toc_%_sec_4.4.2">4.4.2  How the Query System Works</a><br />
-            <a name="%_toc_%_sec_4.4.3" href="book-Z-H-29.html#%_sec_4.4.3" id="%_toc_%_sec_4.4.3">4.4.3  Is Logic Programming Mathematical Logic?</a><br />
-            <a name="%_toc_%_sec_4.4.4" href="book-Z-H-29.html#%_sec_4.4.4" id="%_toc_%_sec_4.4.4">4.4.4  Implementing the Query System</a><br /></p><p><b>
-    <a name="%_toc_%_chap_5" href="book-Z-H-30.html#%_chap_5" id="%_toc_%_chap_5">5  Computing with Register Machines</a></b><br />
-        <a name="%_toc_%_sec_5.1" href="book-Z-H-31.html#%_sec_5.1" id="%_toc_%_sec_5.1">5.1  Designing Register Machines</a><br />
-            <a name="%_toc_%_sec_5.1.1" href="book-Z-H-31.html#%_sec_5.1.1" id="%_toc_%_sec_5.1.1">5.1.1  A Language for Describing Register Machines</a><br />
-            <a name="%_toc_%_sec_5.1.2" href="book-Z-H-31.html#%_sec_5.1.2" id="%_toc_%_sec_5.1.2">5.1.2  Abstraction in Machine Design</a><br />
-            <a name="%_toc_%_sec_5.1.3" href="book-Z-H-31.html#%_sec_5.1.3" id="%_toc_%_sec_5.1.3">5.1.3  Subroutines</a><br />
-            <a name="%_toc_%_sec_5.1.4" href="book-Z-H-31.html#%_sec_5.1.4" id="%_toc_%_sec_5.1.4">5.1.4  Using a Stack to Implement Recursion</a><br />
-            <a name="%_toc_%_sec_5.1.5" href="book-Z-H-31.html#%_sec_5.1.5" id="%_toc_%_sec_5.1.5">5.1.5  Instruction Summary</a><br />
-        <a name="%_toc_%_sec_5.2" href="book-Z-H-32.html#%_sec_5.2" id="%_toc_%_sec_5.2">5.2  A Register-Machine Simulator</a><br />
-            <a name="%_toc_%_sec_5.2.1" href="book-Z-H-32.html#%_sec_5.2.1" id="%_toc_%_sec_5.2.1">5.2.1  The Machine Model</a><br />
-            <a name="%_toc_%_sec_5.2.2" href="book-Z-H-32.html#%_sec_5.2.2" id="%_toc_%_sec_5.2.2">5.2.2  The Assembler</a><br />
-            <a name="%_toc_%_sec_5.2.3" href="book-Z-H-32.html#%_sec_5.2.3" id="%_toc_%_sec_5.2.3">5.2.3  Generating Execution Procedures for Instructions</a><br />
-            <a name="%_toc_%_sec_5.2.4" href="book-Z-H-32.html#%_sec_5.2.4" id="%_toc_%_sec_5.2.4">5.2.4  Monitoring Machine Performance</a><br />
-        <a name="%_toc_%_sec_5.3" href="book-Z-H-33.html#%_sec_5.3" id="%_toc_%_sec_5.3">5.3  Storage Allocation and Garbage Collection</a><br />
-            <a name="%_toc_%_sec_5.3.1" href="book-Z-H-33.html#%_sec_5.3.1" id="%_toc_%_sec_5.3.1">5.3.1  Memory as Vectors</a><br />
-            <a name="%_toc_%_sec_5.3.2" href="book-Z-H-33.html#%_sec_5.3.2" id="%_toc_%_sec_5.3.2">5.3.2  Maintaining the Illusion of Infinite Memory</a><br />
-        <a name="%_toc_%_sec_5.4" href="book-Z-H-34.html#%_sec_5.4" id="%_toc_%_sec_5.4">5.4  The Explicit-Control Evaluator</a><br />
-            <a name="%_toc_%_sec_5.4.1" href="book-Z-H-34.html#%_sec_5.4.1" id="%_toc_%_sec_5.4.1">5.4.1  The Core of the Explicit-Control Evaluator</a><br />
-            <a name="%_toc_%_sec_5.4.2" href="book-Z-H-34.html#%_sec_5.4.2" id="%_toc_%_sec_5.4.2">5.4.2  Sequence Evaluation and Tail Recursion</a><br />
-            <a name="%_toc_%_sec_5.4.3" href="book-Z-H-34.html#%_sec_5.4.3" id="%_toc_%_sec_5.4.3">5.4.3  Conditionals, Assignments, and Definitions</a><br />
-            <a name="%_toc_%_sec_5.4.4" href="book-Z-H-34.html#%_sec_5.4.4" id="%_toc_%_sec_5.4.4">5.4.4  Running the Evaluator</a><br />
-        <a name="%_toc_%_sec_5.5" href="book-Z-H-35.html#%_sec_5.5" id="%_toc_%_sec_5.5">5.5  Compilation</a><br />
-            <a name="%_toc_%_sec_5.5.1" href="book-Z-H-35.html#%_sec_5.5.1" id="%_toc_%_sec_5.5.1">5.5.1  Structure of the Compiler</a><br />
-            <a name="%_toc_%_sec_5.5.2" href="book-Z-H-35.html#%_sec_5.5.2" id="%_toc_%_sec_5.5.2">5.5.2  Compiling Expressions</a><br />
-            <a name="%_toc_%_sec_5.5.3" href="book-Z-H-35.html#%_sec_5.5.3" id="%_toc_%_sec_5.5.3">5.5.3  Compiling Combinations</a><br />
-            <a name="%_toc_%_sec_5.5.4" href="book-Z-H-35.html#%_sec_5.5.4" id="%_toc_%_sec_5.5.4">5.5.4  Combining Instruction Sequences</a><br />
-            <a name="%_toc_%_sec_5.5.5" href="book-Z-H-35.html#%_sec_5.5.5" id="%_toc_%_sec_5.5.5">5.5.5  An Example of Compiled Code</a><br />
-            <a name="%_toc_%_sec_5.5.6" href="book-Z-H-35.html#%_sec_5.5.6" id="%_toc_%_sec_5.5.6">5.5.6  Lexical Addressing</a><br />
-            <a name="%_toc_%_sec_5.5.7" href="book-Z-H-35.html#%_sec_5.5.7" id="%_toc_%_sec_5.5.7">5.5.7  Interfacing Compiled Code to the Evaluator</a><br /></p><p><b>
-    <a name="%_toc_%_chap_Temp_849" href="book-Z-H-36.html#%_chap_Temp_849" id="%_toc_%_chap_Temp_849">References</a></b><br /></p><p><b>
-    <a name="%_toc_%_chap_Temp_850" href="book-Z-H-37.html#%_chap_Temp_850" id="%_toc_%_chap_Temp_850">List of Exercises</a></b><br /></p><p><b>
-    <a name="%_toc_%_chap_Temp_851" href="book-Z-H-38.html#%_chap_Temp_851" id="%_toc_%_chap_Temp_851">Index</a></b><br /></p><p>
+<a id="__toc_start"><p><b>
+    <a href="book-Z-H-5.html#__chap_Temp_2" id="__toc___chap_Temp_2">Foreword</a></b><br /></p><p><b>
+    <a href="book-Z-H-6.html#__chap_Temp_3" id="__toc___chap_Temp_3">Preface to the Second Edition</a></b><br /></p><p><b>
+    <a href="book-Z-H-7.html#__chap_Temp_4" id="__toc___chap_Temp_4">Preface to the First Edition</a></b><br /></p><p><b>
+    <a href="book-Z-H-8.html#__chap_Temp_5" id="__toc___chap_Temp_5">Acknowledgments</a></b><br /></p><p><b>
+    <a href="book-Z-H-9.html#__chap_1" id="__toc___chap_1">1  Building Abstractions with Procedures</a></b><br />
+        <a href="book-Z-H-10.html#__sec_1.1" id="__toc___sec_1.1">1.1  The Elements of Programming</a><br />
+            <a href="book-Z-H-10.html#__sec_1.1.1" id="__toc___sec_1.1.1">1.1.1  Expressions</a><br />
+            <a href="book-Z-H-10.html#__sec_1.1.2" id="__toc___sec_1.1.2">1.1.2  Naming and the Environment</a><br />
+            <a href="book-Z-H-10.html#__sec_1.1.3" id="__toc___sec_1.1.3">1.1.3  Evaluating Combinations</a><br />
+            <a href="book-Z-H-10.html#__sec_1.1.4" id="__toc___sec_1.1.4">1.1.4  Compound Procedures</a><br />
+            <a href="book-Z-H-10.html#__sec_1.1.5" id="__toc___sec_1.1.5">1.1.5  The Substitution Model for Procedure Application</a><br />
+            <a href="book-Z-H-10.html#__sec_1.1.6" id="__toc___sec_1.1.6">1.1.6  Conditional Expressions and Predicates</a><br />
+            <a href="book-Z-H-10.html#__sec_1.1.7" id="__toc___sec_1.1.7">1.1.7  Example: Square Roots by Newton's Method</a><br />
+            <a href="book-Z-H-10.html#__sec_1.1.8" id="__toc___sec_1.1.8">1.1.8  Procedures as Black-Box Abstractions</a><br />
+        <a href="book-Z-H-11.html#__sec_1.2" id="__toc___sec_1.2">1.2  Procedures and the Processes They Generate</a><br />
+            <a href="book-Z-H-11.html#__sec_1.2.1" id="__toc___sec_1.2.1">1.2.1  Linear Recursion and Iteration</a><br />
+            <a href="book-Z-H-11.html#__sec_1.2.2" id="__toc___sec_1.2.2">1.2.2  Tree Recursion</a><br />
+            <a href="book-Z-H-11.html#__sec_1.2.3" id="__toc___sec_1.2.3">1.2.3  Orders of Growth</a><br />
+            <a href="book-Z-H-11.html#__sec_1.2.4" id="__toc___sec_1.2.4">1.2.4  Exponentiation</a><br />
+            <a href="book-Z-H-11.html#__sec_1.2.5" id="__toc___sec_1.2.5">1.2.5  Greatest Common Divisors</a><br />
+            <a href="book-Z-H-11.html#__sec_1.2.6" id="__toc___sec_1.2.6">1.2.6  Example: Testing for Primality</a><br />
+        <a href="book-Z-H-12.html#__sec_1.3" id="__toc___sec_1.3">1.3  Formulating Abstractions with Higher-Order Procedures</a><br />
+            <a href="book-Z-H-12.html#__sec_1.3.1" id="__toc___sec_1.3.1">1.3.1  Procedures as Arguments</a><br />
+            <a href="book-Z-H-12.html#__sec_1.3.2" id="__toc___sec_1.3.2">1.3.2  Constructing Procedures Using <tt>Lambda</tt></a><br />
+            <a href="book-Z-H-12.html#__sec_1.3.3" id="__toc___sec_1.3.3">1.3.3  Procedures as General Methods</a><br />
+            <a href="book-Z-H-12.html#__sec_1.3.4" id="__toc___sec_1.3.4">1.3.4  Procedures as Returned Values</a><br /></p><p><b>
+    <a href="book-Z-H-13.html#__chap_2" id="__toc___chap_2">2  Building Abstractions with Data</a></b><br />
+        <a href="book-Z-H-14.html#__sec_2.1" id="__toc___sec_2.1">2.1  Introduction to Data Abstraction</a><br />
+            <a href="book-Z-H-14.html#__sec_2.1.1" id="__toc___sec_2.1.1">2.1.1  Example: Arithmetic Operations for Rational Numbers</a><br />
+            <a href="book-Z-H-14.html#__sec_2.1.2" id="__toc___sec_2.1.2">2.1.2  Abstraction Barriers</a><br />
+            <a href="book-Z-H-14.html#__sec_2.1.3" id="__toc___sec_2.1.3">2.1.3  What Is Meant by Data?</a><br />
+            <a href="book-Z-H-14.html#__sec_2.1.4" id="__toc___sec_2.1.4">2.1.4  Extended Exercise: Interval Arithmetic</a><br />
+        <a href="book-Z-H-15.html#__sec_2.2" id="__toc___sec_2.2">2.2  Hierarchical Data and the Closure Property</a><br />
+            <a href="book-Z-H-15.html#__sec_2.2.1" id="__toc___sec_2.2.1">2.2.1  Representing Sequences</a><br />
+            <a href="book-Z-H-15.html#__sec_2.2.2" id="__toc___sec_2.2.2">2.2.2  Hierarchical Structures</a><br />
+            <a href="book-Z-H-15.html#__sec_2.2.3" id="__toc___sec_2.2.3">2.2.3  Sequences as Conventional Interfaces</a><br />
+            <a href="book-Z-H-15.html#__sec_2.2.4" id="__toc___sec_2.2.4">2.2.4  Example: A Picture Language</a><br />
+        <a href="book-Z-H-16.html#__sec_2.3" id="__toc___sec_2.3">2.3  Symbolic Data</a><br />
+            <a href="book-Z-H-16.html#__sec_2.3.1" id="__toc___sec_2.3.1">2.3.1  Quotation</a><br />
+            <a href="book-Z-H-16.html#__sec_2.3.2" id="__toc___sec_2.3.2">2.3.2  Example: Symbolic Differentiation</a><br />
+            <a href="book-Z-H-16.html#__sec_2.3.3" id="__toc___sec_2.3.3">2.3.3  Example: Representing Sets</a><br />
+            <a href="book-Z-H-16.html#__sec_2.3.4" id="__toc___sec_2.3.4">2.3.4  Example: Huffman Encoding Trees</a><br />
+        <a href="book-Z-H-17.html#__sec_2.4" id="__toc___sec_2.4">2.4  Multiple Representations for Abstract Data</a><br />
+            <a href="book-Z-H-17.html#__sec_2.4.1" id="__toc___sec_2.4.1">2.4.1  Representations for Complex Numbers</a><br />
+            <a href="book-Z-H-17.html#__sec_2.4.2" id="__toc___sec_2.4.2">2.4.2  Tagged data</a><br />
+            <a href="book-Z-H-17.html#__sec_2.4.3" id="__toc___sec_2.4.3">2.4.3  Data-Directed Programming and Additivity</a><br />
+        <a href="book-Z-H-18.html#__sec_2.5" id="__toc___sec_2.5">2.5  Systems with Generic Operations</a><br />
+            <a href="book-Z-H-18.html#__sec_2.5.1" id="__toc___sec_2.5.1">2.5.1  Generic Arithmetic Operations</a><br />
+            <a href="book-Z-H-18.html#__sec_2.5.2" id="__toc___sec_2.5.2">2.5.2  Combining Data of Different Types</a><br />
+            <a href="book-Z-H-18.html#__sec_2.5.3" id="__toc___sec_2.5.3">2.5.3  Example: Symbolic Algebra</a><br /></p><p><b>
+    <a href="book-Z-H-19.html#__chap_3" id="__toc___chap_3">3  Modularity, Objects, and State</a></b><br />
+        <a href="book-Z-H-20.html#__sec_3.1" id="__toc___sec_3.1">3.1  Assignment and Local State</a><br />
+            <a href="book-Z-H-20.html#__sec_3.1.1" id="__toc___sec_3.1.1">3.1.1  Local State Variables</a><br />
+            <a href="book-Z-H-20.html#__sec_3.1.2" id="__toc___sec_3.1.2">3.1.2  The Benefits of Introducing Assignment</a><br />
+            <a href="book-Z-H-20.html#__sec_3.1.3" id="__toc___sec_3.1.3">3.1.3  The Costs of Introducing Assignment</a><br />
+        <a href="book-Z-H-21.html#__sec_3.2" id="__toc___sec_3.2">3.2  The Environment Model of Evaluation</a><br />
+            <a href="book-Z-H-21.html#__sec_3.2.1" id="__toc___sec_3.2.1">3.2.1  The Rules for Evaluation</a><br />
+            <a href="book-Z-H-21.html#__sec_3.2.2" id="__toc___sec_3.2.2">3.2.2  Applying Simple Procedures</a><br />
+            <a href="book-Z-H-21.html#__sec_3.2.3" id="__toc___sec_3.2.3">3.2.3  Frames as the Repository of Local State</a><br />
+            <a href="book-Z-H-21.html#__sec_3.2.4" id="__toc___sec_3.2.4">3.2.4  Internal Definitions</a><br />
+        <a href="book-Z-H-22.html#__sec_3.3" id="__toc___sec_3.3">3.3  Modeling with Mutable Data</a><br />
+            <a href="book-Z-H-22.html#__sec_3.3.1" id="__toc___sec_3.3.1">3.3.1  Mutable List Structure</a><br />
+            <a href="book-Z-H-22.html#__sec_3.3.2" id="__toc___sec_3.3.2">3.3.2  Representing Queues</a><br />
+            <a href="book-Z-H-22.html#__sec_3.3.3" id="__toc___sec_3.3.3">3.3.3  Representing Tables</a><br />
+            <a href="book-Z-H-22.html#__sec_3.3.4" id="__toc___sec_3.3.4">3.3.4  A Simulator for Digital Circuits</a><br />
+            <a href="book-Z-H-22.html#__sec_3.3.5" id="__toc___sec_3.3.5">3.3.5  Propagation of Constraints</a><br />
+        <a href="book-Z-H-23.html#__sec_3.4" id="__toc___sec_3.4">3.4  Concurrency: Time Is of the Essence</a><br />
+            <a href="book-Z-H-23.html#__sec_3.4.1" id="__toc___sec_3.4.1">3.4.1  The Nature of Time in Concurrent Systems</a><br />
+            <a href="book-Z-H-23.html#__sec_3.4.2" id="__toc___sec_3.4.2">3.4.2  Mechanisms for Controlling Concurrency</a><br />
+        <a href="book-Z-H-24.html#__sec_3.5" id="__toc___sec_3.5">3.5  Streams</a><br />
+            <a href="book-Z-H-24.html#__sec_3.5.1" id="__toc___sec_3.5.1">3.5.1  Streams Are Delayed Lists</a><br />
+            <a href="book-Z-H-24.html#__sec_3.5.2" id="__toc___sec_3.5.2">3.5.2  Infinite Streams</a><br />
+            <a href="book-Z-H-24.html#__sec_3.5.3" id="__toc___sec_3.5.3">3.5.3  Exploiting the Stream Paradigm</a><br />
+            <a href="book-Z-H-24.html#__sec_3.5.4" id="__toc___sec_3.5.4">3.5.4  Streams and Delayed Evaluation</a><br />
+            <a href="book-Z-H-24.html#__sec_3.5.5" id="__toc___sec_3.5.5">3.5.5  Modularity of Functional Programs and Modularity of Objects</a><br /></p><p><b>
+    <a href="book-Z-H-25.html#__chap_4" id="__toc___chap_4">4  Metalinguistic Abstraction</a></b><br />
+        <a href="book-Z-H-26.html#__sec_4.1" id="__toc___sec_4.1">4.1  The Metacircular Evaluator</a><br />
+            <a href="book-Z-H-26.html#__sec_4.1.1" id="__toc___sec_4.1.1">4.1.1  The Core of the Evaluator</a><br />
+            <a href="book-Z-H-26.html#__sec_4.1.2" id="__toc___sec_4.1.2">4.1.2  Representing Expressions</a><br />
+            <a href="book-Z-H-26.html#__sec_4.1.3" id="__toc___sec_4.1.3">4.1.3  Evaluator Data Structures</a><br />
+            <a href="book-Z-H-26.html#__sec_4.1.4" id="__toc___sec_4.1.4">4.1.4  Running the Evaluator as a Program</a><br />
+            <a href="book-Z-H-26.html#__sec_4.1.5" id="__toc___sec_4.1.5">4.1.5  Data as Programs</a><br />
+            <a href="book-Z-H-26.html#__sec_4.1.6" id="__toc___sec_4.1.6">4.1.6  Internal Definitions</a><br />
+            <a href="book-Z-H-26.html#__sec_4.1.7" id="__toc___sec_4.1.7">4.1.7  Separating Syntactic Analysis from Execution</a><br />
+        <a href="book-Z-H-27.html#__sec_4.2" id="__toc___sec_4.2">4.2  Variations on a Scheme – Lazy Evaluation</a><br />
+            <a href="book-Z-H-27.html#__sec_4.2.1" id="__toc___sec_4.2.1">4.2.1  Normal Order and Applicative Order</a><br />
+            <a href="book-Z-H-27.html#__sec_4.2.2" id="__toc___sec_4.2.2">4.2.2  An Interpreter with Lazy Evaluation</a><br />
+            <a href="book-Z-H-27.html#__sec_4.2.3" id="__toc___sec_4.2.3">4.2.3  Streams as Lazy Lists</a><br />
+        <a href="book-Z-H-28.html#__sec_4.3" id="__toc___sec_4.3">4.3  Variations on a Scheme – Nondeterministic Computing</a><br />
+            <a href="book-Z-H-28.html#__sec_4.3.1" id="__toc___sec_4.3.1">4.3.1  Amb and Search</a><br />
+            <a href="book-Z-H-28.html#__sec_4.3.2" id="__toc___sec_4.3.2">4.3.2  Examples of Nondeterministic Programs</a><br />
+            <a href="book-Z-H-28.html#__sec_4.3.3" id="__toc___sec_4.3.3">4.3.3  Implementing the <tt>Amb</tt> Evaluator</a><br />
+        <a href="book-Z-H-29.html#__sec_4.4" id="__toc___sec_4.4">4.4  Logic Programming</a><br />
+            <a href="book-Z-H-29.html#__sec_4.4.1" id="__toc___sec_4.4.1">4.4.1  Deductive Information Retrieval</a><br />
+            <a href="book-Z-H-29.html#__sec_4.4.2" id="__toc___sec_4.4.2">4.4.2  How the Query System Works</a><br />
+            <a href="book-Z-H-29.html#__sec_4.4.3" id="__toc___sec_4.4.3">4.4.3  Is Logic Programming Mathematical Logic?</a><br />
+            <a href="book-Z-H-29.html#__sec_4.4.4" id="__toc___sec_4.4.4">4.4.4  Implementing the Query System</a><br /></p><p><b>
+    <a href="book-Z-H-30.html#__chap_5" id="__toc___chap_5">5  Computing with Register Machines</a></b><br />
+        <a href="book-Z-H-31.html#__sec_5.1" id="__toc___sec_5.1">5.1  Designing Register Machines</a><br />
+            <a href="book-Z-H-31.html#__sec_5.1.1" id="__toc___sec_5.1.1">5.1.1  A Language for Describing Register Machines</a><br />
+            <a href="book-Z-H-31.html#__sec_5.1.2" id="__toc___sec_5.1.2">5.1.2  Abstraction in Machine Design</a><br />
+            <a href="book-Z-H-31.html#__sec_5.1.3" id="__toc___sec_5.1.3">5.1.3  Subroutines</a><br />
+            <a href="book-Z-H-31.html#__sec_5.1.4" id="__toc___sec_5.1.4">5.1.4  Using a Stack to Implement Recursion</a><br />
+            <a href="book-Z-H-31.html#__sec_5.1.5" id="__toc___sec_5.1.5">5.1.5  Instruction Summary</a><br />
+        <a href="book-Z-H-32.html#__sec_5.2" id="__toc___sec_5.2">5.2  A Register-Machine Simulator</a><br />
+            <a href="book-Z-H-32.html#__sec_5.2.1" id="__toc___sec_5.2.1">5.2.1  The Machine Model</a><br />
+            <a href="book-Z-H-32.html#__sec_5.2.2" id="__toc___sec_5.2.2">5.2.2  The Assembler</a><br />
+            <a href="book-Z-H-32.html#__sec_5.2.3" id="__toc___sec_5.2.3">5.2.3  Generating Execution Procedures for Instructions</a><br />
+            <a href="book-Z-H-32.html#__sec_5.2.4" id="__toc___sec_5.2.4">5.2.4  Monitoring Machine Performance</a><br />
+        <a href="book-Z-H-33.html#__sec_5.3" id="__toc___sec_5.3">5.3  Storage Allocation and Garbage Collection</a><br />
+            <a href="book-Z-H-33.html#__sec_5.3.1" id="__toc___sec_5.3.1">5.3.1  Memory as Vectors</a><br />
+            <a href="book-Z-H-33.html#__sec_5.3.2" id="__toc___sec_5.3.2">5.3.2  Maintaining the Illusion of Infinite Memory</a><br />
+        <a href="book-Z-H-34.html#__sec_5.4" id="__toc___sec_5.4">5.4  The Explicit-Control Evaluator</a><br />
+            <a href="book-Z-H-34.html#__sec_5.4.1" id="__toc___sec_5.4.1">5.4.1  The Core of the Explicit-Control Evaluator</a><br />
+            <a href="book-Z-H-34.html#__sec_5.4.2" id="__toc___sec_5.4.2">5.4.2  Sequence Evaluation and Tail Recursion</a><br />
+            <a href="book-Z-H-34.html#__sec_5.4.3" id="__toc___sec_5.4.3">5.4.3  Conditionals, Assignments, and Definitions</a><br />
+            <a href="book-Z-H-34.html#__sec_5.4.4" id="__toc___sec_5.4.4">5.4.4  Running the Evaluator</a><br />
+        <a href="book-Z-H-35.html#__sec_5.5" id="__toc___sec_5.5">5.5  Compilation</a><br />
+            <a href="book-Z-H-35.html#__sec_5.5.1" id="__toc___sec_5.5.1">5.5.1  Structure of the Compiler</a><br />
+            <a href="book-Z-H-35.html#__sec_5.5.2" id="__toc___sec_5.5.2">5.5.2  Compiling Expressions</a><br />
+            <a href="book-Z-H-35.html#__sec_5.5.3" id="__toc___sec_5.5.3">5.5.3  Compiling Combinations</a><br />
+            <a href="book-Z-H-35.html#__sec_5.5.4" id="__toc___sec_5.5.4">5.5.4  Combining Instruction Sequences</a><br />
+            <a href="book-Z-H-35.html#__sec_5.5.5" id="__toc___sec_5.5.5">5.5.5  An Example of Compiled Code</a><br />
+            <a href="book-Z-H-35.html#__sec_5.5.6" id="__toc___sec_5.5.6">5.5.6  Lexical Addressing</a><br />
+            <a href="book-Z-H-35.html#__sec_5.5.7" id="__toc___sec_5.5.7">5.5.7  Interfacing Compiled Code to the Evaluator</a><br /></p><p><b>
+    <a href="book-Z-H-36.html#__chap_Temp_849" id="__toc___chap_Temp_849">References</a></b><br /></p><p><b>
+    <a href="book-Z-H-37.html#__chap_Temp_850" id="__toc___chap_Temp_850">List of Exercises</a></b><br /></p><p><b>
+    <a href="book-Z-H-38.html#__chap_Temp_851" id="__toc___chap_Temp_851">Index</a></b><br /></p><p>
 
 
 
diff --git a/src/OEBPS/book-Z-H-5.html b/src/OEBPS/book-Z-H-5.html
index 0624dba..86e5081 100644
--- a/src/OEBPS/book-Z-H-5.html
+++ b/src/OEBPS/book-Z-H-5.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,8 +13,8 @@
 
 
 
-<a name="%_chap_Temp_2" id="%_chap_Temp_2"></a>
-<h1 class="chapter chapterheading"><a href="book-Z-H-4.html#%_toc_%_chap_Temp_2">Foreword</a></h1>
+<a id="__chap_Temp_2"></a>
+<h1 class="chapter chapterheading">Foreword</h1>
 
 <p>Educators, generals, dieticians, psychologists, and parents program.
 Armies, students, and some societies are programmed.  An assault on
diff --git a/src/OEBPS/book-Z-H-6.html b/src/OEBPS/book-Z-H-6.html
index c509e42..6a4647e 100644
--- a/src/OEBPS/book-Z-H-6.html
+++ b/src/OEBPS/book-Z-H-6.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,13 +13,13 @@
 
 
 
-<a name="%_chap_Temp_3" id="%_chap_Temp_3"></a>
-<h1 class="chapter chapterheading"><a href="book-Z-H-4.html#%_toc_%_chap_Temp_3">Preface to the Second Edition</a> </h1>
+<a id="__chap_Temp_3"></a>
+<h1 class="chapter chapterheading">Preface to the Second Edition </h1>
 <blockquote>Is it possible that software is not like anything else, that it
 is meant to be discarded: that the whole point is to
 always see it as a soap bubble?</blockquote>
 
-<p><cite><a name="%_idx_2" id="%_idx_2"></a>Alan J. Perlis</cite></p>
+<p><cite><a id="__idx_2"></a>Alan J. Perlis</cite></p>
 
 
 
@@ -56,10 +56,10 @@ <h1 class="chapter chapterheading"><a href="book-Z-H-4.html#%_toc_%_chap_Temp_3"
 edition, it will not be possible to cover everything in a single
 semester, so the instructor will have to pick and choose.  In our own
 teaching, we sometimes skip the section on logic programming
-(section <a href="book-Z-H-29.html#%_sec_4.4">4.4</a>), we have students use the
+(section <a href="book-Z-H-29.html#__sec_4.4">4.4</a>), we have students use the
 register-machine simulator but we do not cover its implementation
-(section <a href="book-Z-H-32.html#%_sec_5.2">5.2</a>), and we give only a cursory overview of
-the compiler (section <a href="book-Z-H-35.html#%_sec_5.5">5.5</a>).  Even so, this is still
+(section <a href="book-Z-H-32.html#__sec_5.2">5.2</a>), and we give only a cursory overview of
+the compiler (section <a href="book-Z-H-35.html#__sec_5.5">5.5</a>).  Even so, this is still
 an intense course.  Some instructors may wish to cover only the first
 three or four chapters, leaving the other material for subsequent
 courses.</p>
diff --git a/src/OEBPS/book-Z-H-7.html b/src/OEBPS/book-Z-H-7.html
index fa35053..4925795 100644
--- a/src/OEBPS/book-Z-H-7.html
+++ b/src/OEBPS/book-Z-H-7.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,8 +13,8 @@
 
 
 
-<a name="%_chap_Temp_4" id="%_chap_Temp_4"></a>
-<h1 class="chapter chapterheading"><a href="book-Z-H-4.html#%_toc_%_chap_Temp_4">Preface to the First Edition</a></h1>
+<a id="__chap_Temp_4"></a>
+<h1 class="chapter chapterheading">Preface to the First Edition</h1>
 <blockquote>A computer is like a violin.  You can imagine a novice trying first a
 phonograph and then a violin.  The latter, he says, sounds terrible.
 That is the argument we have heard from our humanists and most of our
@@ -22,7 +22,7 @@ <h1 class="chapter chapterheading"><a href="book-Z-H-4.html#%_toc_%_chap_Temp_4"
 particular purposes, but they aren't flexible.  Neither is a violin,
 or a typewriter, until you learn how to use it.</blockquote>
 
-<p><cite><a name="%_idx_4" id="%_idx_4"></a>Marvin Minsky, “Why Programming Is a Good<br />
+<p><cite><a id="__idx_4"></a>Marvin Minsky, “Why Programming Is a Good<br />
 Medium for Expressing Poorly-Understood and Sloppily-Formulated
 Ideas”</cite></p>
 
diff --git a/src/OEBPS/book-Z-H-8.html b/src/OEBPS/book-Z-H-8.html
index 9a141a4..c75c1c2 100644
--- a/src/OEBPS/book-Z-H-8.html
+++ b/src/OEBPS/book-Z-H-8.html
@@ -5,13 +5,13 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
   <body>
-<a name="%_chap_Temp_5" id="%_chap_Temp_5"></a>
-<h1 class="chapter chapterheading"><a href="book-Z-H-4.html#%_toc_%_chap_Temp_5">Acknowledgments</a></h1>
+<a id="__chap_Temp_5"></a>
+<h1 class="chapter chapterheading">Acknowledgments</h1>
 
 
 
diff --git a/src/OEBPS/book-Z-H-9.html b/src/OEBPS/book-Z-H-9.html
index 4a91cfe..9ed31ea 100644
--- a/src/OEBPS/book-Z-H-9.html
+++ b/src/OEBPS/book-Z-H-9.html
@@ -5,7 +5,7 @@
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
@@ -13,9 +13,9 @@
 
 
 
-<a name="%_chap_1" id="%_chap_1"></a>
-<h1 class="chapter chapterheading"><a href="book-Z-H-4.html#%_toc_%_chap_1">Chapter 1</a></h1>
-<p><a href="book-Z-H-4.html#%_toc_%_chap_1">Building Abstractions with Procedures</a></p>
+<a id="__chap_1"></a>
+<h1 class="chapter chapterheading">Chapter 1</h1>
+<p>Building Abstractions with Procedures</p>
 
 <blockquote>The acts of the mind, wherein it exerts its power over simple ideas,
 are chiefly these three: 1. Combining several simple ideas into one
@@ -27,13 +27,13 @@ <h1 class="chapter chapterheading"><a href="book-Z-H-4.html#%_toc_%_chap_1">Chap
 them in their real existence: this is called abstraction, and thus all
 its general ideas are made.</blockquote>
 
-<p><cite><a name="%_idx_6" id="%_idx_6"></a>John Locke, An Essay Concerning Human Understanding
+<p><cite><a id="__idx_6"></a>John Locke, An Essay Concerning Human Understanding
 (1690)</cite></p>
 
-<p>We are about to study the idea of a <a name="%_idx_8" id="%_idx_8"></a><a name="%_idx_10" id="%_idx_10"></a><em>computational process</em>.
+<p>We are about to study the idea of a <a id="__idx_8"></a><a id="__idx_10"></a><em>computational process</em>.
 Computational processes are abstract beings that inhabit computers.
-As they evolve, processes manipulate other abstract things called <a name="%_idx_12" id="%_idx_12"></a><em>data</em>.  The evolution of a process is directed by a pattern of rules
-called a <a name="%_idx_14" id="%_idx_14"></a><em>program</em>.  People create programs to direct processes.
+As they evolve, processes manipulate other abstract things called <a id="__idx_12"></a><em>data</em>.  The evolution of a process is directed by a pattern of rules
+called a <a id="__idx_14"></a><em>program</em>.  People create programs to direct processes.
 In effect, we conjure the spirits of the computer with our spells.</p>
 
 <p>A computational process is indeed much like a sorcerer's idea of a
@@ -43,14 +43,14 @@ <h1 class="chapter chapterheading"><a href="book-Z-H-4.html#%_toc_%_chap_1">Chap
 at a bank or by controlling a robot arm in a factory.  The programs we
 use to conjure processes are like a sorcerer's spells.  They are
 carefully composed from symbolic expressions in arcane and esoteric
-<a name="%_idx_16" id="%_idx_16"></a><em>programming languages</em> that prescribe the tasks we want our
+<a id="__idx_16"></a><em>programming languages</em> that prescribe the tasks we want our
 processes to perform.</p>
 
 <p>A computational process, in a correctly working computer, executes
 programs precisely and accurately.  Thus, like the sorcerer's
 apprentice, novice programmers must learn to understand and to
 anticipate the consequences of their conjuring.  Even small errors
-(usually called <a name="%_idx_18" id="%_idx_18"></a><em>bugs</em> or <a name="%_idx_20" id="%_idx_20"></a><em>glitches</em>) in programs can have
+(usually called <a id="__idx_18"></a><em>bugs</em> or <a id="__idx_20"></a><em>glitches</em>) in programs can have
 complex and unanticipated consequences.</p>
 
 <p>Fortunately, learning to program is considerably less dangerous than
@@ -65,14 +65,121 @@ <h1 class="chapter chapterheading"><a href="book-Z-H-4.html#%_toc_%_chap_1">Chap
 perform the tasks intended.  They can visualize the behavior of their
 systems in advance.  They know how to structure programs so that
 unanticipated problems do not lead to catastrophic consequences, and
-when problems do arise, they can <a name="%_idx_22" id="%_idx_22"></a><em>debug</em> their programs.  Well-designed
+when problems do arise, they can <a id="__idx_22"></a><em>debug</em> their programs.  Well-designed
 computational systems, like well-designed automobiles or nuclear
 reactors, are designed in a modular manner, so that the parts can be
 constructed, replaced, and debugged separately.</p>
 
-<p><a name="%_sec_Temp_6" id="%_sec_Temp_6"></a></p>
+<p><a id="__sec_Temp_6"></a></p>
+<h4>Programming in Lisp</h4>
 
+<p>We need an appropriate language for describing processes, and we will
+use for this purpose the programming language Lisp.  Just as our
+everyday thoughts are usually expressed in our natural language (such
+as English, French, or Japanese), and descriptions of quantitative
+phenomena are expressed with mathematical notations, our procedural
+thoughts will be expressed in Lisp.  <a id="__idx_24"></a>Lisp was invented in the late
+1950s as a formalism for reasoning about the use of certain kinds of
+logical expressions, called <a id="__idx_26"></a><em>recursion equations</em>, as a model for
+computation.  The language was conceived by <a id="__idx_28"></a>John McCarthy and is based
+on his paper “Recursive Functions of Symbolic Expressions and Their
+Computation by Machine” (McCarthy 1960).</p>
 
+<p>Despite its inception as a mathematical formalism, Lisp is a practical
+programming language.  A Lisp <a id="__idx_30"></a><em>interpreter</em> is a machine that
+carries out processes described in the Lisp language.  The first Lisp
+interpreter was implemented by <a id="__idx_32"></a>McCarthy with the help of colleagues
+and students in the Artificial Intelligence Group of the <a id="__idx_34"></a>MIT Research
+Laboratory of Electronics and in the MIT Computation
+Center.<a href="#footnote_Temp_7" id="call_footnote_Temp_7"><sup><small>1</small></sup></a> <a id="__idx_38"></a>Lisp, whose name is an acronym for LISt Processing,
+was designed to provide symbol-manipulating capabilities for
+attacking programming problems such as the symbolic differentiation
+and integration of algebraic expressions.  It included for this
+purpose new data objects known as atoms and lists, which most
+strikingly set it apart from all other languages of the period.</p>
+
+<p>Lisp was not the product of a concerted design effort.  Instead, it
+evolved informally in an experimental manner in response to users'
+needs and to pragmatic implementation considerations.  Lisp's informal
+evolution has continued through the years, and the community of Lisp
+users has traditionally resisted attempts to promulgate any
+“official” definition of the language.  This evolution, together
+with the flexibility and elegance of the initial conception, has
+enabled Lisp, which is the second oldest language in widespread use
+today (only <a id="__idx_40"></a>Fortran is older), to continually adapt to encompass the
+most modern ideas about program design.  Thus, Lisp is by now a family
+of dialects, which, while sharing most of the original features, may
+differ from one another in significant ways.  The dialect of Lisp used
+in this book is called <a id="__idx_42"></a><a id="__idx_44"></a>Scheme.<a href="#footnote_Temp_8" id="call_footnote_Temp_8"><sup><small>2</small></sup></a></p>
+
+<p>Because of its experimental character and its emphasis on symbol
+manipulation, <a id="__idx_96"></a><a id="__idx_98"></a><a id="__idx_100"></a>Lisp was at first very inefficient for numerical
+computations, at least in comparison with Fortran.  Over the years,
+however, Lisp compilers have been developed that translate programs
+into machine code that can perform numerical computations reasonably
+efficiently.  And for special applications, Lisp has been used with
+great effectiveness.<a href="#footnote_Temp_9" id="call_footnote_Temp_9"><sup><small>3</small></sup></a>  Although Lisp has not yet overcome its old reputation
+as hopelessly inefficient, Lisp is now used in many applications where
+efficiency is not the central concern.  For example, Lisp has become
+a language of choice for operating-system shell languages and for
+extension languages for editors and computer-aided design systems.</p>
+
+<p>If Lisp is not a mainstream language, why are we using it as the
+framework for our discussion of programming?  Because the language
+possesses <a id="__idx_112"></a>unique features that make it an excellent medium for
+studying important programming constructs and data structures and for
+relating them to the linguistic features that support them.  The most
+significant of these features is the fact that Lisp descriptions of
+processes, called <a id="__idx_114"></a><a id="__idx_116"></a><em>procedures</em>, can
+themselves be represented and manipulated as Lisp data.  The
+importance of this is that there are powerful program-design
+techniques that rely on the ability to blur the traditional
+distinction between “passive” data and “active” processes.  As we
+shall discover, Lisp's flexibility in handling procedures as data
+makes it one of the most convenient languages in existence for
+exploring these techniques.  The ability to represent procedures as
+data also makes Lisp an excellent language for writing programs that
+must manipulate other programs as data, such as the interpreters and
+compilers that support computer languages.  Above and beyond these
+considerations, programming in Lisp is great fun.</p>
+
+<div class="smallprint"><hr /></div>
+<div class="footnote">
+<p><a href="#call_footnote_Temp_7" id="footnote_Temp_7"><sup><small>1</small></sup></a> The <em>Lisp 1 Programmer's Manual</em> appeared in
+1960, and the <em>Lisp 1.5 Programmer's Manual</em> <a id="__idx_36"></a>(McCarthy 1965)
+was published in 1962.  The early history of Lisp is described in
+McCarthy 1978.</p>
+
+<p><a href="#call_footnote_Temp_8" id="footnote_Temp_8"><sup><small>2</small></sup></a> The two dialects in which most
+major Lisp programs of the 1970s were written are <a id="__idx_46"></a><a id="__idx_48"></a>MacLisp <a id="__idx_50"></a>(Moon 1978;
+<a id="__idx_52"></a>Pitman 1983), developed at the <a id="__idx_54"></a>MIT Project MAC, and <a id="__idx_56"></a><a id="__idx_58"></a>Interlisp
+<a id="__idx_60"></a>(Teitelman 1974), developed at <a id="__idx_62"></a>Bolt Beranek and Newman Inc. and the
+<a id="__idx_64"></a>Xerox Palo Alto Research Center.  <a id="__idx_66"></a><a id="__idx_68"></a>Portable Standard Lisp <a id="__idx_70"></a>(Hearn 1969;
+<a id="__idx_72"></a>Griss 1981) was a Lisp dialect designed to be easily portable
+between different machines.  MacLisp spawned a number of subdialects,
+such as <a id="__idx_74"></a><a id="__idx_76"></a>Franz Lisp, which was developed at the <a id="__idx_78"></a>University of
+California at Berkeley, and <a id="__idx_80"></a><a id="__idx_82"></a>Zetalisp (Moon 1981), which was based on a
+special-purpose processor designed at the <a id="__idx_84"></a>MIT Artificial Intelligence
+Laboratory to run Lisp very efficiently.  The Lisp dialect used in
+this book, called <a id="__idx_86"></a>Scheme (Steele 1975), was invented in 1975 by <a id="__idx_88"></a><a id="__idx_90"></a>Guy
+Lewis Steele Jr. and Gerald Jay Sussman of the MIT Artificial
+Intelligence Laboratory and later reimplemented for instructional use
+at MIT.  Scheme became an IEEE standard in 1990 (IEEE 1990).  The
+<a id="__idx_92"></a><a id="__idx_94"></a>Common Lisp dialect (Steele 1982, Steele 1990) was developed by the
+Lisp community to combine features from the earlier Lisp dialects
+to make an industrial standard for Lisp.  Common Lisp became an ANSI
+standard in 1994 (ANSI 1994).</p>
+
+<p><a href="#call_footnote_Temp_9" id="footnote_Temp_9"><sup><small>3</small></sup></a> One such special application was a
+breakthrough computation of scientific importance – an integration of
+the motion of the <a id="__idx_102"></a><a id="__idx_104"></a>Solar System that extended previous results by
+nearly two orders of magnitude, and demonstrated that the dynamics of
+the Solar System is chaotic.  This computation was made possible by
+new integration algorithms, a special-purpose compiler, and a
+special-purpose computer all implemented with the aid of software
+tools written in Lisp <a id="__idx_106"></a>(Abelson et al. 1992; <a id="__idx_108"></a><a id="__idx_110"></a>Sussman and
+Wisdom 1992).</p>
+</div>
 </body>
 </html>
 
diff --git a/src/OEBPS/book-Z-H-9a.html b/src/OEBPS/book-Z-H-9a.html
deleted file mode 100644
index a43d554..0000000
--- a/src/OEBPS/book-Z-H-9a.html
+++ /dev/null
@@ -1,129 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xmlns:ops="http://www.idpf.org/2007/ops">
-<!-- Generated from TeX source by tex2page, v 4o,
-     (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
-    <title>Structure and Interpretation of Computer Programs</title>
-    <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
-  </head>
-  <body>
-
-
-
-<a name="%_chap_1" id="%_chap_1"></a>
-<h1 class="chapter chapterheading"><a href="book-Z-H-4.html#%_toc_%_chap_1">Chapter 1</a></h1>
-<h4><a href="book-Z-H-4.html#%_toc_%_sec_Temp_6">Programming in Lisp</a></h4>
-
-<p>We need an appropriate language for describing processes, and we will
-use for this purpose the programming language Lisp.  Just as our
-everyday thoughts are usually expressed in our natural language (such
-as English, French, or Japanese), and descriptions of quantitative
-phenomena are expressed with mathematical notations, our procedural
-thoughts will be expressed in Lisp.  <a name="%_idx_24" id="%_idx_24"></a>Lisp was invented in the late
-1950s as a formalism for reasoning about the use of certain kinds of
-logical expressions, called <a name="%_idx_26" id="%_idx_26"></a><em>recursion equations</em>, as a model for
-computation.  The language was conceived by <a name="%_idx_28" id="%_idx_28"></a>John McCarthy and is based
-on his paper “Recursive Functions of Symbolic Expressions and Their
-Computation by Machine” (McCarthy 1960).</p>
-
-<p>Despite its inception as a mathematical formalism, Lisp is a practical
-programming language.  A Lisp <a name="%_idx_30" id="%_idx_30"></a><em>interpreter</em> is a machine that
-carries out processes described in the Lisp language.  The first Lisp
-interpreter was implemented by <a name="%_idx_32" id="%_idx_32"></a>McCarthy with the help of colleagues
-and students in the Artificial Intelligence Group of the <a name="%_idx_34" id="%_idx_34"></a>MIT Research
-Laboratory of Electronics and in the MIT Computation
-Center.<a name="call_footnote_Temp_7" href="#footnote_Temp_7" id="call_footnote_Temp_7"><sup><small>1</small></sup></a> <a name="%_idx_38" id="%_idx_38"></a>Lisp, whose name is an acronym for LISt Processing,
-was designed to provide symbol-manipulating capabilities for
-attacking programming problems such as the symbolic differentiation
-and integration of algebraic expressions.  It included for this
-purpose new data objects known as atoms and lists, which most
-strikingly set it apart from all other languages of the period.</p>
-
-<p>Lisp was not the product of a concerted design effort.  Instead, it
-evolved informally in an experimental manner in response to users'
-needs and to pragmatic implementation considerations.  Lisp's informal
-evolution has continued through the years, and the community of Lisp
-users has traditionally resisted attempts to promulgate any
-“official” definition of the language.  This evolution, together
-with the flexibility and elegance of the initial conception, has
-enabled Lisp, which is the second oldest language in widespread use
-today (only <a name="%_idx_40" id="%_idx_40"></a>Fortran is older), to continually adapt to encompass the
-most modern ideas about program design.  Thus, Lisp is by now a family
-of dialects, which, while sharing most of the original features, may
-differ from one another in significant ways.  The dialect of Lisp used
-in this book is called <a name="%_idx_42" id="%_idx_42"></a><a name="%_idx_44" id="%_idx_44"></a>Scheme.<a name="call_footnote_Temp_8" href="#footnote_Temp_8" id="call_footnote_Temp_8"><sup><small>2</small></sup></a></p>
-
-<p>Because of its experimental character and its emphasis on symbol
-manipulation, <a name="%_idx_96" id="%_idx_96"></a><a name="%_idx_98" id="%_idx_98"></a><a name="%_idx_100" id="%_idx_100"></a>Lisp was at first very inefficient for numerical
-computations, at least in comparison with Fortran.  Over the years,
-however, Lisp compilers have been developed that translate programs
-into machine code that can perform numerical computations reasonably
-efficiently.  And for special applications, Lisp has been used with
-great effectiveness.<a name="call_footnote_Temp_9" href="#footnote_Temp_9" id="call_footnote_Temp_9"><sup><small>3</small></sup></a>  Although Lisp has not yet overcome its old reputation
-as hopelessly inefficient, Lisp is now used in many applications where
-efficiency is not the central concern.  For example, Lisp has become
-a language of choice for operating-system shell languages and for
-extension languages for editors and computer-aided design systems.</p>
-
-<p>If Lisp is not a mainstream language, why are we using it as the
-framework for our discussion of programming?  Because the language
-possesses <a name="%_idx_112" id="%_idx_112"></a>unique features that make it an excellent medium for
-studying important programming constructs and data structures and for
-relating them to the linguistic features that support them.  The most
-significant of these features is the fact that Lisp descriptions of
-processes, called <a name="%_idx_114" id="%_idx_114"></a><a name="%_idx_116" id="%_idx_116"></a><em>procedures</em>, can
-themselves be represented and manipulated as Lisp data.  The
-importance of this is that there are powerful program-design
-techniques that rely on the ability to blur the traditional
-distinction between “passive” data and “active” processes.  As we
-shall discover, Lisp's flexibility in handling procedures as data
-makes it one of the most convenient languages in existence for
-exploring these techniques.  The ability to represent procedures as
-data also makes Lisp an excellent language for writing programs that
-must manipulate other programs as data, such as the interpreters and
-compilers that support computer languages.  Above and beyond these
-considerations, programming in Lisp is great fun.</p>
-
-<div class="smallprint"><hr /></div>
-<div class="footnote">
-<p><a name="footnote_Temp_7" href="#call_footnote_Temp_7" id="footnote_Temp_7"><sup><small>1</small></sup></a> The <em>Lisp 1 Programmer's Manual</em> appeared in
-1960, and the <em>Lisp 1.5 Programmer's Manual</em> <a name="%_idx_36" id="%_idx_36"></a>(McCarthy 1965)
-was published in 1962.  The early history of Lisp is described in
-McCarthy 1978.</p>
-
-<p><a name="footnote_Temp_8" href="#call_footnote_Temp_8" id="footnote_Temp_8"><sup><small>2</small></sup></a> The two dialects in which most
-major Lisp programs of the 1970s were written are <a name="%_idx_46" id="%_idx_46"></a><a name="%_idx_48" id="%_idx_48"></a>MacLisp <a name="%_idx_50" id="%_idx_50"></a>(Moon 1978;
-<a name="%_idx_52" id="%_idx_52"></a>Pitman 1983), developed at the <a name="%_idx_54" id="%_idx_54"></a>MIT Project MAC, and <a name="%_idx_56" id="%_idx_56"></a><a name="%_idx_58" id="%_idx_58"></a>Interlisp
-<a name="%_idx_60" id="%_idx_60"></a>(Teitelman 1974), developed at <a name="%_idx_62" id="%_idx_62"></a>Bolt Beranek and Newman Inc. and the
-<a name="%_idx_64" id="%_idx_64"></a>Xerox Palo Alto Research Center.  <a name="%_idx_66" id="%_idx_66"></a><a name="%_idx_68" id="%_idx_68"></a>Portable Standard Lisp <a name="%_idx_70" id="%_idx_70"></a>(Hearn 1969;
-<a name="%_idx_72" id="%_idx_72"></a>Griss 1981) was a Lisp dialect designed to be easily portable
-between different machines.  MacLisp spawned a number of subdialects,
-such as <a name="%_idx_74" id="%_idx_74"></a><a name="%_idx_76" id="%_idx_76"></a>Franz Lisp, which was developed at the <a name="%_idx_78" id="%_idx_78"></a>University of
-California at Berkeley, and <a name="%_idx_80" id="%_idx_80"></a><a name="%_idx_82" id="%_idx_82"></a>Zetalisp (Moon 1981), which was based on a
-special-purpose processor designed at the <a name="%_idx_84" id="%_idx_84"></a>MIT Artificial Intelligence
-Laboratory to run Lisp very efficiently.  The Lisp dialect used in
-this book, called <a name="%_idx_86" id="%_idx_86"></a>Scheme (Steele 1975), was invented in 1975 by <a name="%_idx_88" id="%_idx_88"></a><a name="%_idx_90" id="%_idx_90"></a>Guy
-Lewis Steele Jr. and Gerald Jay Sussman of the MIT Artificial
-Intelligence Laboratory and later reimplemented for instructional use
-at MIT.  Scheme became an IEEE standard in 1990 (IEEE 1990).  The
-<a name="%_idx_92" id="%_idx_92"></a><a name="%_idx_94" id="%_idx_94"></a>Common Lisp dialect (Steele 1982, Steele 1990) was developed by the
-Lisp community to combine features from the earlier Lisp dialects
-to make an industrial standard for Lisp.  Common Lisp became an ANSI
-standard in 1994 (ANSI 1994).</p>
-
-<p><a name="footnote_Temp_9" href="#call_footnote_Temp_9" id="footnote_Temp_9"><sup><small>3</small></sup></a> One such special application was a
-breakthrough computation of scientific importance – an integration of
-the motion of the <a name="%_idx_102" id="%_idx_102"></a><a name="%_idx_104" id="%_idx_104"></a>Solar System that extended previous results by
-nearly two orders of magnitude, and demonstrated that the dynamics of
-the Solar System is chaotic.  This computation was made possible by
-new integration algorithms, a special-purpose compiler, and a
-special-purpose computer all implemented with the aid of software
-tools written in Lisp <a name="%_idx_106" id="%_idx_106"></a>(Abelson et al. 1992; <a name="%_idx_108" id="%_idx_108"></a><a name="%_idx_110" id="%_idx_110"></a>Sussman and
-Wisdom 1992).</p>
-</div>
-</body>
-</html>
-
diff --git a/src/OEBPS/book.html b/src/OEBPS/book.html
index 3ddf1d3..2673f59 100644
--- a/src/OEBPS/book.html
+++ b/src/OEBPS/book.html
@@ -1,17 +1,17 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml" xmlns:ops="http://www.idpf.org/2007/ops">
 <!-- Generated from TeX source by tex2page, v 4o,
      (c) Dorai Sitaram, http://www.cs.rice.edu/~dorai/tex2page -->
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <meta http-equiv="Content-Type: text/html; charset=utf-8" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>Structure and Interpretation of Computer Programs</title>
     <link rel="stylesheet" type="text/css" href="book-Z-C.css" title="default" />
   </head>
   <body>
 
-<div align="center"> <a href="book-Z-H-1.html#titlepage"><img src="images/cover.jpg" border="0" /></a> </div>
+<div style="text-align: center" > <a href="book-Z-H-1.html#titlepage"><img src="images/cover.jpg" alt="cover" style="border: none;" /></a> </div>
 
 
 
diff --git a/src/OEBPS/content.opf b/src/OEBPS/content.opf
index f11e4af..5ee411b 100644
--- a/src/OEBPS/content.opf
+++ b/src/OEBPS/content.opf
@@ -6,12 +6,12 @@
     <metadata>
         <dc:title>Structure and Interpretation of Computer Programs</dc:title>
         <dc:creator>Harold Abelson and Gerald Jay Sussman with Julie Sussman</dc:creator>
-        <dc:identifier opf:scheme="ISBN">0-262-01153-0</dc:identifier>
+        <dc:identifier opf:scheme="ISBN" id="ISBN">0-262-01153-0</dc:identifier>
         <dc:rights>Creative Commons Attribution-Noncommercial 3.0 Unported License.</dc:rights>
         <dc:language>en-US</dc:language>
         <dc:source>http://mitpress.mit.edu/sicp/full-text/book/book.html</dc:source>
         <dc:publisher>MIT Press</dc:publisher>
-        <meta name="cover" content="cover.jpg"/>
+        <meta name="cover" content="cover"/>
     </metadata>
     <manifest>
         <item id="ncx" href="toc.ncx" media-type="application/x-dtbncx+xml"/>
@@ -24,7 +24,6 @@
         <item id="book-Z-H-7" href="book-Z-H-7.html" media-type="application/xhtml+xml"/>
         <item id="book-Z-H-8" href="book-Z-H-8.html" media-type="application/xhtml+xml"/>
         <item id="book-Z-H-9" href="book-Z-H-9.html" media-type="application/xhtml+xml"/>
-        <item id="book-Z-H-9a" href="book-Z-H-9a.html" media-type="application/xhtml+xml"/>
         <item id="book-Z-H-10" href="book-Z-H-10.html" media-type="application/xhtml+xml"/>
         <item id="book-Z-H-11" href="book-Z-H-11.html" media-type="application/xhtml+xml"/>
         <item id="book-Z-H-12" href="book-Z-H-12.html" media-type="application/xhtml+xml"/>
@@ -54,165 +53,167 @@
         <item id="book-Z-H-36" href="book-Z-H-36.html" media-type="application/xhtml+xml"/>
         <item id="book-Z-H-37" href="book-Z-H-37.html" media-type="application/xhtml+xml"/>
         <item id="book-Z-H-38" href="book-Z-H-38.html" media-type="application/xhtml+xml"/>
-        <item id="css" href="stylesheet.css" media-type="text/css"/>
+        <item id="css" href="book-Z-C.css" media-type="text/css"/>
 
         <!-- Images -->
-        <item id="ch1-Z-G-1" href="images/ch1-Z-G-1.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-10" href="images/ch1-Z-G-10.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-12" href="images/ch1-Z-G-12.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-13" href="images/ch1-Z-G-13.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-19" href="images/ch1-Z-G-19.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-2" href="images/ch1-Z-G-2.gif" media-type="image/svg+xml"/>
-        <item id="ch1-Z-G-26" href="images/ch1-Z-G-26.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-27" href="images/ch1-Z-G-27.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-28" href="images/ch1-Z-G-28.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-29" href="images/ch1-Z-G-29.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-3" href="images/ch1-Z-G-3.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-30" href="images/ch1-Z-G-30.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-34" href="images/ch1-Z-G-34.gif" media-type="image/svg+xml"/>
-        <item id="ch1-Z-G-35" href="images/ch1-Z-G-35.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-36" href="images/ch1-Z-G-36.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-37" href="images/ch1-Z-G-37.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-38" href="images/ch1-Z-G-38.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-4" href="images/ch1-Z-G-4.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-5" href="images/ch1-Z-G-5.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-6" href="images/ch1-Z-G-6.gif" media-type="image/gif"/>
-        <item id="ch1-Z-G-7" href="images/ch1-Z-G-7.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-1" href="images/ch2-Z-G-1.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-10" href="images/ch2-Z-G-10.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-11" href="images/ch2-Z-G-11.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-12" href="images/ch2-Z-G-12.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-13" href="images/ch2-Z-G-13.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-15" href="images/ch2-Z-G-15.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-16" href="images/ch2-Z-G-16.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-17" href="images/ch2-Z-G-17.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-2" href="images/ch2-Z-G-2.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-24" href="images/ch2-Z-G-24.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-25" href="images/ch2-Z-G-25.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-26" href="images/ch2-Z-G-26.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-27" href="images/ch2-Z-G-27.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-28" href="images/ch2-Z-G-28.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-29" href="images/ch2-Z-G-29.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-3" href="images/ch2-Z-G-3.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-30" href="images/ch2-Z-G-30.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-31" href="images/ch2-Z-G-31.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-32" href="images/ch2-Z-G-32.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-33" href="images/ch2-Z-G-33.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-34" href="images/ch2-Z-G-34.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-35" href="images/ch2-Z-G-35.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-36" href="images/ch2-Z-G-36.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-37" href="images/ch2-Z-G-37.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-38" href="images/ch2-Z-G-38.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-39" href="images/ch2-Z-G-39.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-4" href="images/ch2-Z-G-4.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-40" href="images/ch2-Z-G-40.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-41" href="images/ch2-Z-G-41.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-42" href="images/ch2-Z-G-42.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-43" href="images/ch2-Z-G-43.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-45" href="images/ch2-Z-G-45.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-46" href="images/ch2-Z-G-46.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-47" href="images/ch2-Z-G-47.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-48" href="images/ch2-Z-G-48.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-49" href="images/ch2-Z-G-49.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-5" href="images/ch2-Z-G-5.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-50" href="images/ch2-Z-G-50.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-51" href="images/ch2-Z-G-51.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-52" href="images/ch2-Z-G-52.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-53" href="images/ch2-Z-G-53.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-54" href="images/ch2-Z-G-54.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-59" href="images/ch2-Z-G-59.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-6" href="images/ch2-Z-G-6.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-60" href="images/ch2-Z-G-60.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-61" href="images/ch2-Z-G-61.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-62" href="images/ch2-Z-G-62.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-63" href="images/ch2-Z-G-63.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-64" href="images/ch2-Z-G-64.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-65" href="images/ch2-Z-G-65.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-67" href="images/ch2-Z-G-67.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-7" href="images/ch2-Z-G-7.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-71" href="images/ch2-Z-G-71.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-76" href="images/ch2-Z-G-76.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-77" href="images/ch2-Z-G-77.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-78" href="images/ch2-Z-G-78.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-8" href="images/ch2-Z-G-8.gif" media-type="image/gif"/>
-        <item id="ch2-Z-G-9" href="images/ch2-Z-G-9.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-1" href="images/ch3-Z-G-1.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-10" href="images/ch3-Z-G-10.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-11" href="images/ch3-Z-G-11.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-12" href="images/ch3-Z-G-12.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-13" href="images/ch3-Z-G-13.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-14" href="images/ch3-Z-G-14.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-15" href="images/ch3-Z-G-15.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-16" href="images/ch3-Z-G-16.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-17" href="images/ch3-Z-G-17.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-18" href="images/ch3-Z-G-18.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-19" href="images/ch3-Z-G-19.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-2" href="images/ch3-Z-G-2.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-20" href="images/ch3-Z-G-20.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-21" href="images/ch3-Z-G-21.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-22" href="images/ch3-Z-G-22.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-23" href="images/ch3-Z-G-23.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-24" href="images/ch3-Z-G-24.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-25" href="images/ch3-Z-G-25.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-26" href="images/ch3-Z-G-26.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-27" href="images/ch3-Z-G-27.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-3" href="images/ch3-Z-G-3.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-30" href="images/ch3-Z-G-30.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-31" href="images/ch3-Z-G-31.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-32" href="images/ch3-Z-G-32.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-35" href="images/ch3-Z-G-35.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-36" href="images/ch3-Z-G-36.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-37" href="images/ch3-Z-G-37.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-38" href="images/ch3-Z-G-38.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-39" href="images/ch3-Z-G-39.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-4" href="images/ch3-Z-G-4.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-40" href="images/ch3-Z-G-40.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-41" href="images/ch3-Z-G-41.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-42" href="images/ch3-Z-G-42.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-43" href="images/ch3-Z-G-43.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-44" href="images/ch3-Z-G-44.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-45" href="images/ch3-Z-G-45.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-46" href="images/ch3-Z-G-46.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-47" href="images/ch3-Z-G-47.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-48" href="images/ch3-Z-G-48.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-49" href="images/ch3-Z-G-49.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-5" href="images/ch3-Z-G-5.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-50" href="images/ch3-Z-G-50.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-51" href="images/ch3-Z-G-51.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-52" href="images/ch3-Z-G-52.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-53" href="images/ch3-Z-G-53.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-54" href="images/ch3-Z-G-54.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-55" href="images/ch3-Z-G-55.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-56" href="images/ch3-Z-G-56.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-57" href="images/ch3-Z-G-57.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-58" href="images/ch3-Z-G-58.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-59" href="images/ch3-Z-G-59.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-6" href="images/ch3-Z-G-6.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-60" href="images/ch3-Z-G-60.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-7" href="images/ch3-Z-G-7.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-8" href="images/ch3-Z-G-8.gif" media-type="image/gif"/>
-        <item id="ch3-Z-G-9" href="images/ch3-Z-G-9.gif" media-type="image/gif"/>
-        <item id="ch4-Z-G-1" href="images/ch4-Z-G-1.gif" media-type="image/gif"/>
-        <item id="ch4-Z-G-10" href="images/ch4-Z-G-10.gif" media-type="image/gif"/>
-        <item id="ch4-Z-G-2" href="images/ch4-Z-G-2.gif" media-type="image/gif"/>
-        <item id="ch4-Z-G-3" href="images/ch4-Z-G-3.gif" media-type="image/gif"/>
-        <item id="ch4-Z-G-4" href="images/ch4-Z-G-4.gif" media-type="image/gif"/>
-        <item id="ch4-Z-G-5" href="images/ch4-Z-G-5.gif" media-type="image/gif"/>
-        <item id="ch4-Z-G-6" href="images/ch4-Z-G-6.gif" media-type="image/gif"/>
-        <item id="ch4-Z-G-7" href="images/ch4-Z-G-7.gif" media-type="image/gif"/>
-        <item id="ch4-Z-G-8" href="images/ch4-Z-G-8.gif" media-type="image/gif"/>
-        <item id="ch4-Z-G-9" href="images/ch4-Z-G-9.gif" media-type="image/gif"/>
-        <item id="ch5-Z-G-1" href="images/ch5-Z-G-1.gif" media-type="image/gif"/>
-        <item id="ch5-Z-G-2" href="images/ch5-Z-G-2.gif" media-type="image/gif"/>
-        <item id="ch5-Z-G-3" href="images/ch5-Z-G-3.gif" media-type="image/gif"/>
-        <item id="ch5-Z-G-4" href="images/ch5-Z-G-4.gif" media-type="image/gif"/>
-        <item id="ch5-Z-G-5" href="images/ch5-Z-G-5.gif" media-type="image/gif"/>
-        <item id="ch5-Z-G-6" href="images/ch5-Z-G-6.gif" media-type="image/gif"/>
-        <item id="ch5-Z-G-7" href="images/ch5-Z-G-7.gif" media-type="image/gif"/>
-        <item id="ch5-Z-G-8" href="images/ch5-Z-G-8.gif" media-type="image/gif"/>
-        <item id="ch5-Z-G-9" href="images/ch5-Z-G-9.gif" media-type="image/gif"/>
-        <item id="chip" href="images/chip.jpg" media-type="image/jpeg"/>
-        <item id="cover" href="images/cover.jpg" media-type="image/jpeg"/>
+	<item id="ch1-Z-G-1" href="images/ch1-Z-G-1.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-2" href="images/ch1-Z-G-2.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-3" href="images/ch1-Z-G-3.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-4" href="images/ch1-Z-G-4.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-5" href="images/ch1-Z-G-5.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-6" href="images/ch1-Z-G-6.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-7" href="images/ch1-Z-G-7.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-10" href="images/ch1-Z-G-10.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-12" href="images/ch1-Z-G-12.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-13" href="images/ch1-Z-G-13.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-19" href="images/ch1-Z-G-19.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-26" href="images/ch1-Z-G-26.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-27" href="images/ch1-Z-G-27.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-28" href="images/ch1-Z-G-28.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-29" href="images/ch1-Z-G-29.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-30" href="images/ch1-Z-G-30.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-34" href="images/ch1-Z-G-34.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-35" href="images/ch1-Z-G-35.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-36" href="images/ch1-Z-G-36.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-37" href="images/ch1-Z-G-37.gif" media-type="image/gif"/>
+	<item id="ch1-Z-G-38" href="images/ch1-Z-G-38.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-1" href="images/ch2-Z-G-1.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-2" href="images/ch2-Z-G-2.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-3" href="images/ch2-Z-G-3.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-4" href="images/ch2-Z-G-4.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-5" href="images/ch2-Z-G-5.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-6" href="images/ch2-Z-G-6.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-7" href="images/ch2-Z-G-7.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-8" href="images/ch2-Z-G-8.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-9" href="images/ch2-Z-G-9.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-10" href="images/ch2-Z-G-10.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-11" href="images/ch2-Z-G-11.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-12" href="images/ch2-Z-G-12.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-13" href="images/ch2-Z-G-13.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-15" href="images/ch2-Z-G-15.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-16" href="images/ch2-Z-G-16.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-17" href="images/ch2-Z-G-17.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-24" href="images/ch2-Z-G-24.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-25" href="images/ch2-Z-G-25.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-26" href="images/ch2-Z-G-26.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-27" href="images/ch2-Z-G-27.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-28" href="images/ch2-Z-G-28.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-29" href="images/ch2-Z-G-29.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-30" href="images/ch2-Z-G-30.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-31" href="images/ch2-Z-G-31.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-32" href="images/ch2-Z-G-32.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-33" href="images/ch2-Z-G-33.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-34" href="images/ch2-Z-G-34.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-35" href="images/ch2-Z-G-35.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-36" href="images/ch2-Z-G-36.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-37" href="images/ch2-Z-G-37.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-38" href="images/ch2-Z-G-38.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-39" href="images/ch2-Z-G-39.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-40" href="images/ch2-Z-G-40.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-41" href="images/ch2-Z-G-41.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-42" href="images/ch2-Z-G-42.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-43" href="images/ch2-Z-G-43.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-45" href="images/ch2-Z-G-45.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-46" href="images/ch2-Z-G-46.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-47" href="images/ch2-Z-G-47.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-48" href="images/ch2-Z-G-48.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-49" href="images/ch2-Z-G-49.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-50" href="images/ch2-Z-G-50.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-51" href="images/ch2-Z-G-51.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-52" href="images/ch2-Z-G-52.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-53" href="images/ch2-Z-G-53.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-54" href="images/ch2-Z-G-54.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-59" href="images/ch2-Z-G-59.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-60" href="images/ch2-Z-G-60.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-61" href="images/ch2-Z-G-61.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-62" href="images/ch2-Z-G-62.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-63" href="images/ch2-Z-G-63.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-64" href="images/ch2-Z-G-64.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-65" href="images/ch2-Z-G-65.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-67" href="images/ch2-Z-G-67.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-71" href="images/ch2-Z-G-71.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-76" href="images/ch2-Z-G-76.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-77" href="images/ch2-Z-G-77.gif" media-type="image/gif"/>
+	<item id="ch2-Z-G-78" href="images/ch2-Z-G-78.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-1" href="images/ch3-Z-G-1.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-2" href="images/ch3-Z-G-2.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-3" href="images/ch3-Z-G-3.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-4" href="images/ch3-Z-G-4.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-5" href="images/ch3-Z-G-5.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-6" href="images/ch3-Z-G-6.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-7" href="images/ch3-Z-G-7.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-8" href="images/ch3-Z-G-8.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-9" href="images/ch3-Z-G-9.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-10" href="images/ch3-Z-G-10.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-11" href="images/ch3-Z-G-11.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-12" href="images/ch3-Z-G-12.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-13" href="images/ch3-Z-G-13.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-14" href="images/ch3-Z-G-14.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-15" href="images/ch3-Z-G-15.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-16" href="images/ch3-Z-G-16.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-17" href="images/ch3-Z-G-17.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-18" href="images/ch3-Z-G-18.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-19" href="images/ch3-Z-G-19.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-20" href="images/ch3-Z-G-20.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-21" href="images/ch3-Z-G-21.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-22" href="images/ch3-Z-G-22.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-23" href="images/ch3-Z-G-23.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-24" href="images/ch3-Z-G-24.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-25" href="images/ch3-Z-G-25.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-26" href="images/ch3-Z-G-26.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-27" href="images/ch3-Z-G-27.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-30" href="images/ch3-Z-G-30.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-31" href="images/ch3-Z-G-31.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-32" href="images/ch3-Z-G-32.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-35" href="images/ch3-Z-G-35.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-36" href="images/ch3-Z-G-36.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-37" href="images/ch3-Z-G-37.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-38" href="images/ch3-Z-G-38.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-39" href="images/ch3-Z-G-39.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-40" href="images/ch3-Z-G-40.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-41" href="images/ch3-Z-G-41.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-42" href="images/ch3-Z-G-42.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-43" href="images/ch3-Z-G-43.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-44" href="images/ch3-Z-G-44.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-45" href="images/ch3-Z-G-45.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-46" href="images/ch3-Z-G-46.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-47" href="images/ch3-Z-G-47.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-48" href="images/ch3-Z-G-48.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-49" href="images/ch3-Z-G-49.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-50" href="images/ch3-Z-G-50.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-51" href="images/ch3-Z-G-51.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-52" href="images/ch3-Z-G-52.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-53" href="images/ch3-Z-G-53.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-54" href="images/ch3-Z-G-54.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-55" href="images/ch3-Z-G-55.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-56" href="images/ch3-Z-G-56.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-57" href="images/ch3-Z-G-57.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-58" href="images/ch3-Z-G-58.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-59" href="images/ch3-Z-G-59.gif" media-type="image/gif"/>
+	<item id="ch3-Z-G-60" href="images/ch3-Z-G-60.gif" media-type="image/gif"/>
+	<item id="ch4-Z-G-1" href="images/ch4-Z-G-1.gif" media-type="image/gif"/>
+	<item id="ch4-Z-G-2" href="images/ch4-Z-G-2.gif" media-type="image/gif"/>
+	<item id="ch4-Z-G-3" href="images/ch4-Z-G-3.gif" media-type="image/gif"/>
+	<item id="ch4-Z-G-4" href="images/ch4-Z-G-4.gif" media-type="image/gif"/>
+	<item id="ch4-Z-G-5" href="images/ch4-Z-G-5.gif" media-type="image/gif"/>
+	<item id="ch4-Z-G-6" href="images/ch4-Z-G-6.gif" media-type="image/gif"/>
+	<item id="ch4-Z-G-7" href="images/ch4-Z-G-7.gif" media-type="image/gif"/>
+	<item id="ch4-Z-G-8" href="images/ch4-Z-G-8.gif" media-type="image/gif"/>
+	<item id="ch4-Z-G-9" href="images/ch4-Z-G-9.gif" media-type="image/gif"/>
+	<item id="ch4-Z-G-10" href="images/ch4-Z-G-10.gif" media-type="image/gif"/>
+	<item id="ch5-Z-G-1" href="images/ch5-Z-G-1.gif" media-type="image/gif"/>
+	<item id="ch5-Z-G-2" href="images/ch5-Z-G-2.gif" media-type="image/gif"/>
+	<item id="ch5-Z-G-3" href="images/ch5-Z-G-3.gif" media-type="image/gif"/>
+	<item id="ch5-Z-G-4" href="images/ch5-Z-G-4.gif" media-type="image/gif"/>
+	<item id="ch5-Z-G-5" href="images/ch5-Z-G-5.gif" media-type="image/gif"/>
+	<item id="ch5-Z-G-6" href="images/ch5-Z-G-6.gif" media-type="image/gif"/>
+	<item id="ch5-Z-G-7" href="images/ch5-Z-G-7.gif" media-type="image/gif"/>
+	<item id="ch5-Z-G-8" href="images/ch5-Z-G-8.gif" media-type="image/gif"/>
+	<item id="chip" href="images/chip.jpg" media-type="image/jpeg"/>
+	<item id="ch5-Z-G-9" href="images/ch5-Z-G-9.gif" media-type="image/gif"/>
+	<item id="cover" href="images/cover.jpg" media-type="image/jpeg"/>
+	<item id="cc-88x31" href="images/cc-88x31.png" media-type="image/png"/>
+
     </manifest>
     <spine toc="ncx">
         <itemref idref="book-Z-H-1" linear="yes"/>
@@ -223,7 +224,6 @@
         <itemref idref="book-Z-H-7" linear="yes"/>
         <itemref idref="book-Z-H-8" linear="yes"/>
         <itemref idref="book-Z-H-9" linear="yes"/>
-        <itemref idref="book-Z-H-9a" linear="yes"/>
         <itemref idref="book-Z-H-10" linear="yes"/>
         <itemref idref="book-Z-H-11" linear="yes"/>
         <itemref idref="book-Z-H-12" linear="yes"/>
@@ -257,4 +257,4 @@
     <guide>
         <reference href="book.html" type="cover" title="Cover"/>
     </guide>
-</package>
\ No newline at end of file
+</package>
diff --git a/src/OEBPS/images/cc-88x31.png b/src/OEBPS/images/cc-88x31.png
new file mode 100644
index 0000000..5f98214
Binary files /dev/null and b/src/OEBPS/images/cc-88x31.png differ
diff --git a/src/OEBPS/images/ch1-Z-G-1.gif b/src/OEBPS/images/ch1-Z-G-1.gif
new file mode 100644
index 0000000..4a52e94
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-1.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-10.gif b/src/OEBPS/images/ch1-Z-G-10.gif
new file mode 100644
index 0000000..335c635
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-10.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-12.gif b/src/OEBPS/images/ch1-Z-G-12.gif
new file mode 100644
index 0000000..3669688
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-12.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-13.gif b/src/OEBPS/images/ch1-Z-G-13.gif
new file mode 100644
index 0000000..677e2d9
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-13.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-19.gif b/src/OEBPS/images/ch1-Z-G-19.gif
new file mode 100644
index 0000000..adc13b2
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-19.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-2.gif b/src/OEBPS/images/ch1-Z-G-2.gif
new file mode 100644
index 0000000..515862d
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-2.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-26.gif b/src/OEBPS/images/ch1-Z-G-26.gif
new file mode 100644
index 0000000..5ddaa9b
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-26.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-27.gif b/src/OEBPS/images/ch1-Z-G-27.gif
new file mode 100644
index 0000000..21b95fc
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-27.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-28.gif b/src/OEBPS/images/ch1-Z-G-28.gif
new file mode 100644
index 0000000..f776bc5
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-28.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-29.gif b/src/OEBPS/images/ch1-Z-G-29.gif
new file mode 100644
index 0000000..b9bf099
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-29.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-3.gif b/src/OEBPS/images/ch1-Z-G-3.gif
new file mode 100644
index 0000000..59e6e21
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-3.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-30.gif b/src/OEBPS/images/ch1-Z-G-30.gif
new file mode 100644
index 0000000..d94c22d
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-30.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-34.gif b/src/OEBPS/images/ch1-Z-G-34.gif
new file mode 100644
index 0000000..0df28b1
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-34.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-35.gif b/src/OEBPS/images/ch1-Z-G-35.gif
new file mode 100644
index 0000000..abbfbc8
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-35.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-36.gif b/src/OEBPS/images/ch1-Z-G-36.gif
new file mode 100644
index 0000000..9d55aaa
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-36.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-37.gif b/src/OEBPS/images/ch1-Z-G-37.gif
new file mode 100644
index 0000000..76928a4
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-37.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-38.gif b/src/OEBPS/images/ch1-Z-G-38.gif
new file mode 100644
index 0000000..6bb6c42
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-38.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-4.gif b/src/OEBPS/images/ch1-Z-G-4.gif
new file mode 100644
index 0000000..dbaffae
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-4.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-5.gif b/src/OEBPS/images/ch1-Z-G-5.gif
new file mode 100644
index 0000000..7ba16a2
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-5.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-6.gif b/src/OEBPS/images/ch1-Z-G-6.gif
new file mode 100644
index 0000000..5057314
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-6.gif differ
diff --git a/src/OEBPS/images/ch1-Z-G-7.gif b/src/OEBPS/images/ch1-Z-G-7.gif
new file mode 100644
index 0000000..4cc5be4
Binary files /dev/null and b/src/OEBPS/images/ch1-Z-G-7.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-1.gif b/src/OEBPS/images/ch2-Z-G-1.gif
new file mode 100644
index 0000000..e032b5b
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-1.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-10.gif b/src/OEBPS/images/ch2-Z-G-10.gif
new file mode 100644
index 0000000..e737a33
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-10.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-11.gif b/src/OEBPS/images/ch2-Z-G-11.gif
new file mode 100644
index 0000000..36eb2be
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-11.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-12.gif b/src/OEBPS/images/ch2-Z-G-12.gif
new file mode 100644
index 0000000..0f78d43
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-12.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-13.gif b/src/OEBPS/images/ch2-Z-G-13.gif
new file mode 100644
index 0000000..8a18c51
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-13.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-15.gif b/src/OEBPS/images/ch2-Z-G-15.gif
new file mode 100644
index 0000000..d14510b
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-15.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-16.gif b/src/OEBPS/images/ch2-Z-G-16.gif
new file mode 100644
index 0000000..bda3366
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-16.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-17.gif b/src/OEBPS/images/ch2-Z-G-17.gif
new file mode 100644
index 0000000..ea5a68b
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-17.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-2.gif b/src/OEBPS/images/ch2-Z-G-2.gif
new file mode 100644
index 0000000..cceb775
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-2.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-24.gif b/src/OEBPS/images/ch2-Z-G-24.gif
new file mode 100644
index 0000000..298ea12
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-24.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-25.gif b/src/OEBPS/images/ch2-Z-G-25.gif
new file mode 100644
index 0000000..87f0759
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-25.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-26.gif b/src/OEBPS/images/ch2-Z-G-26.gif
new file mode 100644
index 0000000..171d1da
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-26.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-27.gif b/src/OEBPS/images/ch2-Z-G-27.gif
new file mode 100644
index 0000000..69949a1
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-27.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-28.gif b/src/OEBPS/images/ch2-Z-G-28.gif
new file mode 100644
index 0000000..538ba0b
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-28.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-29.gif b/src/OEBPS/images/ch2-Z-G-29.gif
new file mode 100644
index 0000000..93b0ddf
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-29.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-3.gif b/src/OEBPS/images/ch2-Z-G-3.gif
new file mode 100644
index 0000000..8eb9b25
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-3.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-30.gif b/src/OEBPS/images/ch2-Z-G-30.gif
new file mode 100644
index 0000000..65ccbb1
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-30.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-31.gif b/src/OEBPS/images/ch2-Z-G-31.gif
new file mode 100644
index 0000000..20a1f58
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-31.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-32.gif b/src/OEBPS/images/ch2-Z-G-32.gif
new file mode 100644
index 0000000..28f359a
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-32.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-33.gif b/src/OEBPS/images/ch2-Z-G-33.gif
new file mode 100644
index 0000000..edb5e9c
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-33.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-34.gif b/src/OEBPS/images/ch2-Z-G-34.gif
new file mode 100644
index 0000000..8166ada
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-34.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-35.gif b/src/OEBPS/images/ch2-Z-G-35.gif
new file mode 100644
index 0000000..1d4a4fb
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-35.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-36.gif b/src/OEBPS/images/ch2-Z-G-36.gif
new file mode 100644
index 0000000..15f5346
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-36.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-37.gif b/src/OEBPS/images/ch2-Z-G-37.gif
new file mode 100644
index 0000000..39162d8
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-37.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-38.gif b/src/OEBPS/images/ch2-Z-G-38.gif
new file mode 100644
index 0000000..631b6b3
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-38.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-39.gif b/src/OEBPS/images/ch2-Z-G-39.gif
new file mode 100644
index 0000000..8733855
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-39.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-4.gif b/src/OEBPS/images/ch2-Z-G-4.gif
new file mode 100644
index 0000000..a0da696
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-4.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-40.gif b/src/OEBPS/images/ch2-Z-G-40.gif
new file mode 100644
index 0000000..5cf6206
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-40.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-41.gif b/src/OEBPS/images/ch2-Z-G-41.gif
new file mode 100644
index 0000000..7573a36
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-41.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-42.gif b/src/OEBPS/images/ch2-Z-G-42.gif
new file mode 100644
index 0000000..9679c19
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-42.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-43.gif b/src/OEBPS/images/ch2-Z-G-43.gif
new file mode 100644
index 0000000..983c6af
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-43.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-45.gif b/src/OEBPS/images/ch2-Z-G-45.gif
new file mode 100644
index 0000000..9f7fb3e
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-45.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-46.gif b/src/OEBPS/images/ch2-Z-G-46.gif
new file mode 100644
index 0000000..e6c0633
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-46.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-47.gif b/src/OEBPS/images/ch2-Z-G-47.gif
new file mode 100644
index 0000000..60f0c0d
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-47.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-48.gif b/src/OEBPS/images/ch2-Z-G-48.gif
new file mode 100644
index 0000000..20aa209
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-48.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-49.gif b/src/OEBPS/images/ch2-Z-G-49.gif
new file mode 100644
index 0000000..48e8a8f
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-49.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-5.gif b/src/OEBPS/images/ch2-Z-G-5.gif
new file mode 100644
index 0000000..18994b1
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-5.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-50.gif b/src/OEBPS/images/ch2-Z-G-50.gif
new file mode 100644
index 0000000..cc719f9
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-50.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-51.gif b/src/OEBPS/images/ch2-Z-G-51.gif
new file mode 100644
index 0000000..18d966e
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-51.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-52.gif b/src/OEBPS/images/ch2-Z-G-52.gif
new file mode 100644
index 0000000..6334c13
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-52.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-53.gif b/src/OEBPS/images/ch2-Z-G-53.gif
new file mode 100644
index 0000000..7daba9f
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-53.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-54.gif b/src/OEBPS/images/ch2-Z-G-54.gif
new file mode 100644
index 0000000..474b5b7
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-54.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-59.gif b/src/OEBPS/images/ch2-Z-G-59.gif
new file mode 100644
index 0000000..90e3a7e
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-59.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-6.gif b/src/OEBPS/images/ch2-Z-G-6.gif
new file mode 100644
index 0000000..eb963a4
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-6.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-60.gif b/src/OEBPS/images/ch2-Z-G-60.gif
new file mode 100644
index 0000000..9bd5210
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-60.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-61.gif b/src/OEBPS/images/ch2-Z-G-61.gif
new file mode 100644
index 0000000..976a182
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-61.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-62.gif b/src/OEBPS/images/ch2-Z-G-62.gif
new file mode 100644
index 0000000..5d5fa78
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-62.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-63.gif b/src/OEBPS/images/ch2-Z-G-63.gif
new file mode 100644
index 0000000..6675a77
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-63.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-64.gif b/src/OEBPS/images/ch2-Z-G-64.gif
new file mode 100644
index 0000000..f81a04b
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-64.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-65.gif b/src/OEBPS/images/ch2-Z-G-65.gif
new file mode 100644
index 0000000..a0dac34
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-65.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-67.gif b/src/OEBPS/images/ch2-Z-G-67.gif
new file mode 100644
index 0000000..4a028ff
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-67.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-7.gif b/src/OEBPS/images/ch2-Z-G-7.gif
new file mode 100644
index 0000000..cde17ea
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-7.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-71.gif b/src/OEBPS/images/ch2-Z-G-71.gif
new file mode 100644
index 0000000..0ba8d0c
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-71.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-76.gif b/src/OEBPS/images/ch2-Z-G-76.gif
new file mode 100644
index 0000000..be74855
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-76.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-77.gif b/src/OEBPS/images/ch2-Z-G-77.gif
new file mode 100644
index 0000000..b363216
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-77.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-78.gif b/src/OEBPS/images/ch2-Z-G-78.gif
new file mode 100644
index 0000000..67f23c9
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-78.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-8.gif b/src/OEBPS/images/ch2-Z-G-8.gif
new file mode 100644
index 0000000..a3d8bf3
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-8.gif differ
diff --git a/src/OEBPS/images/ch2-Z-G-9.gif b/src/OEBPS/images/ch2-Z-G-9.gif
new file mode 100644
index 0000000..0eb0a2a
Binary files /dev/null and b/src/OEBPS/images/ch2-Z-G-9.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-1.gif b/src/OEBPS/images/ch3-Z-G-1.gif
new file mode 100644
index 0000000..dddf7f1
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-1.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-10.gif b/src/OEBPS/images/ch3-Z-G-10.gif
new file mode 100644
index 0000000..68a36d5
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-10.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-11.gif b/src/OEBPS/images/ch3-Z-G-11.gif
new file mode 100644
index 0000000..f112b64
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-11.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-12.gif b/src/OEBPS/images/ch3-Z-G-12.gif
new file mode 100644
index 0000000..8622f37
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-12.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-13.gif b/src/OEBPS/images/ch3-Z-G-13.gif
new file mode 100644
index 0000000..2481c23
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-13.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-14.gif b/src/OEBPS/images/ch3-Z-G-14.gif
new file mode 100644
index 0000000..c1b3263
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-14.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-15.gif b/src/OEBPS/images/ch3-Z-G-15.gif
new file mode 100644
index 0000000..5588c46
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-15.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-16.gif b/src/OEBPS/images/ch3-Z-G-16.gif
new file mode 100644
index 0000000..71f3ce7
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-16.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-17.gif b/src/OEBPS/images/ch3-Z-G-17.gif
new file mode 100644
index 0000000..fb1adff
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-17.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-18.gif b/src/OEBPS/images/ch3-Z-G-18.gif
new file mode 100644
index 0000000..99678fd
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-18.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-19.gif b/src/OEBPS/images/ch3-Z-G-19.gif
new file mode 100644
index 0000000..1218312
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-19.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-2.gif b/src/OEBPS/images/ch3-Z-G-2.gif
new file mode 100644
index 0000000..fdc7a15
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-2.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-20.gif b/src/OEBPS/images/ch3-Z-G-20.gif
new file mode 100644
index 0000000..45c5551
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-20.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-21.gif b/src/OEBPS/images/ch3-Z-G-21.gif
new file mode 100644
index 0000000..66ffdf5
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-21.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-22.gif b/src/OEBPS/images/ch3-Z-G-22.gif
new file mode 100644
index 0000000..cc398c7
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-22.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-23.gif b/src/OEBPS/images/ch3-Z-G-23.gif
new file mode 100644
index 0000000..828dfa6
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-23.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-24.gif b/src/OEBPS/images/ch3-Z-G-24.gif
new file mode 100644
index 0000000..92a52ab
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-24.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-25.gif b/src/OEBPS/images/ch3-Z-G-25.gif
new file mode 100644
index 0000000..256ea31
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-25.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-26.gif b/src/OEBPS/images/ch3-Z-G-26.gif
new file mode 100644
index 0000000..2efaa25
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-26.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-27.gif b/src/OEBPS/images/ch3-Z-G-27.gif
new file mode 100644
index 0000000..e2858aa
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-27.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-3.gif b/src/OEBPS/images/ch3-Z-G-3.gif
new file mode 100644
index 0000000..4687ed0
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-3.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-30.gif b/src/OEBPS/images/ch3-Z-G-30.gif
new file mode 100644
index 0000000..5e86c19
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-30.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-31.gif b/src/OEBPS/images/ch3-Z-G-31.gif
new file mode 100644
index 0000000..d49bf5b
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-31.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-32.gif b/src/OEBPS/images/ch3-Z-G-32.gif
new file mode 100644
index 0000000..cb2d54c
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-32.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-35.gif b/src/OEBPS/images/ch3-Z-G-35.gif
new file mode 100644
index 0000000..97b7c21
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-35.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-36.gif b/src/OEBPS/images/ch3-Z-G-36.gif
new file mode 100644
index 0000000..318f7ce
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-36.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-37.gif b/src/OEBPS/images/ch3-Z-G-37.gif
new file mode 100644
index 0000000..785436e
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-37.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-38.gif b/src/OEBPS/images/ch3-Z-G-38.gif
new file mode 100644
index 0000000..1e2eb12
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-38.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-39.gif b/src/OEBPS/images/ch3-Z-G-39.gif
new file mode 100644
index 0000000..32f4aa9
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-39.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-4.gif b/src/OEBPS/images/ch3-Z-G-4.gif
new file mode 100644
index 0000000..48dc775
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-4.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-40.gif b/src/OEBPS/images/ch3-Z-G-40.gif
new file mode 100644
index 0000000..ee8c936
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-40.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-41.gif b/src/OEBPS/images/ch3-Z-G-41.gif
new file mode 100644
index 0000000..3fb595e
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-41.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-42.gif b/src/OEBPS/images/ch3-Z-G-42.gif
new file mode 100644
index 0000000..f393fca
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-42.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-43.gif b/src/OEBPS/images/ch3-Z-G-43.gif
new file mode 100644
index 0000000..6a95f48
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-43.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-44.gif b/src/OEBPS/images/ch3-Z-G-44.gif
new file mode 100644
index 0000000..a602bd4
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-44.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-45.gif b/src/OEBPS/images/ch3-Z-G-45.gif
new file mode 100644
index 0000000..09a2903
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-45.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-46.gif b/src/OEBPS/images/ch3-Z-G-46.gif
new file mode 100644
index 0000000..1158ffe
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-46.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-47.gif b/src/OEBPS/images/ch3-Z-G-47.gif
new file mode 100644
index 0000000..e945657
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-47.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-48.gif b/src/OEBPS/images/ch3-Z-G-48.gif
new file mode 100644
index 0000000..0bbdd09
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-48.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-49.gif b/src/OEBPS/images/ch3-Z-G-49.gif
new file mode 100644
index 0000000..bbddb4e
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-49.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-5.gif b/src/OEBPS/images/ch3-Z-G-5.gif
new file mode 100644
index 0000000..d5b1ee4
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-5.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-50.gif b/src/OEBPS/images/ch3-Z-G-50.gif
new file mode 100644
index 0000000..4559ac7
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-50.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-51.gif b/src/OEBPS/images/ch3-Z-G-51.gif
new file mode 100644
index 0000000..e26abaf
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-51.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-52.gif b/src/OEBPS/images/ch3-Z-G-52.gif
new file mode 100644
index 0000000..e85dc53
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-52.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-53.gif b/src/OEBPS/images/ch3-Z-G-53.gif
new file mode 100644
index 0000000..c9479c9
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-53.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-54.gif b/src/OEBPS/images/ch3-Z-G-54.gif
new file mode 100644
index 0000000..76987af
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-54.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-55.gif b/src/OEBPS/images/ch3-Z-G-55.gif
new file mode 100644
index 0000000..ed5b749
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-55.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-56.gif b/src/OEBPS/images/ch3-Z-G-56.gif
new file mode 100644
index 0000000..4c361a5
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-56.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-57.gif b/src/OEBPS/images/ch3-Z-G-57.gif
new file mode 100644
index 0000000..9bfeeee
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-57.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-58.gif b/src/OEBPS/images/ch3-Z-G-58.gif
new file mode 100644
index 0000000..03fa0f6
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-58.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-59.gif b/src/OEBPS/images/ch3-Z-G-59.gif
new file mode 100644
index 0000000..e0831c0
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-59.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-6.gif b/src/OEBPS/images/ch3-Z-G-6.gif
new file mode 100644
index 0000000..5156166
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-6.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-60.gif b/src/OEBPS/images/ch3-Z-G-60.gif
new file mode 100644
index 0000000..efece06
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-60.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-7.gif b/src/OEBPS/images/ch3-Z-G-7.gif
new file mode 100644
index 0000000..c37b6dc
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-7.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-8.gif b/src/OEBPS/images/ch3-Z-G-8.gif
new file mode 100644
index 0000000..2cc0c6d
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-8.gif differ
diff --git a/src/OEBPS/images/ch3-Z-G-9.gif b/src/OEBPS/images/ch3-Z-G-9.gif
new file mode 100644
index 0000000..082df8a
Binary files /dev/null and b/src/OEBPS/images/ch3-Z-G-9.gif differ
diff --git a/src/OEBPS/images/ch4-Z-G-1.gif b/src/OEBPS/images/ch4-Z-G-1.gif
new file mode 100644
index 0000000..a5ae236
Binary files /dev/null and b/src/OEBPS/images/ch4-Z-G-1.gif differ
diff --git a/src/OEBPS/images/ch4-Z-G-10.gif b/src/OEBPS/images/ch4-Z-G-10.gif
new file mode 100644
index 0000000..345b4f6
Binary files /dev/null and b/src/OEBPS/images/ch4-Z-G-10.gif differ
diff --git a/src/OEBPS/images/ch4-Z-G-2.gif b/src/OEBPS/images/ch4-Z-G-2.gif
new file mode 100644
index 0000000..759d581
Binary files /dev/null and b/src/OEBPS/images/ch4-Z-G-2.gif differ
diff --git a/src/OEBPS/images/ch4-Z-G-3.gif b/src/OEBPS/images/ch4-Z-G-3.gif
new file mode 100644
index 0000000..cb98562
Binary files /dev/null and b/src/OEBPS/images/ch4-Z-G-3.gif differ
diff --git a/src/OEBPS/images/ch4-Z-G-4.gif b/src/OEBPS/images/ch4-Z-G-4.gif
new file mode 100644
index 0000000..cfea36b
Binary files /dev/null and b/src/OEBPS/images/ch4-Z-G-4.gif differ
diff --git a/src/OEBPS/images/ch4-Z-G-5.gif b/src/OEBPS/images/ch4-Z-G-5.gif
new file mode 100644
index 0000000..343bd7f
Binary files /dev/null and b/src/OEBPS/images/ch4-Z-G-5.gif differ
diff --git a/src/OEBPS/images/ch4-Z-G-6.gif b/src/OEBPS/images/ch4-Z-G-6.gif
new file mode 100644
index 0000000..44a7baf
Binary files /dev/null and b/src/OEBPS/images/ch4-Z-G-6.gif differ
diff --git a/src/OEBPS/images/ch4-Z-G-7.gif b/src/OEBPS/images/ch4-Z-G-7.gif
new file mode 100644
index 0000000..f7371ac
Binary files /dev/null and b/src/OEBPS/images/ch4-Z-G-7.gif differ
diff --git a/src/OEBPS/images/ch4-Z-G-8.gif b/src/OEBPS/images/ch4-Z-G-8.gif
new file mode 100644
index 0000000..41d71de
Binary files /dev/null and b/src/OEBPS/images/ch4-Z-G-8.gif differ
diff --git a/src/OEBPS/images/ch4-Z-G-9.gif b/src/OEBPS/images/ch4-Z-G-9.gif
new file mode 100644
index 0000000..5794081
Binary files /dev/null and b/src/OEBPS/images/ch4-Z-G-9.gif differ
diff --git a/src/OEBPS/images/ch5-Z-G-1.gif b/src/OEBPS/images/ch5-Z-G-1.gif
new file mode 100644
index 0000000..8c2f509
Binary files /dev/null and b/src/OEBPS/images/ch5-Z-G-1.gif differ
diff --git a/src/OEBPS/images/ch5-Z-G-2.gif b/src/OEBPS/images/ch5-Z-G-2.gif
new file mode 100644
index 0000000..dee9281
Binary files /dev/null and b/src/OEBPS/images/ch5-Z-G-2.gif differ
diff --git a/src/OEBPS/images/ch5-Z-G-3.gif b/src/OEBPS/images/ch5-Z-G-3.gif
new file mode 100644
index 0000000..caeaadb
Binary files /dev/null and b/src/OEBPS/images/ch5-Z-G-3.gif differ
diff --git a/src/OEBPS/images/ch5-Z-G-4.gif b/src/OEBPS/images/ch5-Z-G-4.gif
new file mode 100644
index 0000000..d8cd5a0
Binary files /dev/null and b/src/OEBPS/images/ch5-Z-G-4.gif differ
diff --git a/src/OEBPS/images/ch5-Z-G-5.gif b/src/OEBPS/images/ch5-Z-G-5.gif
new file mode 100644
index 0000000..045790d
Binary files /dev/null and b/src/OEBPS/images/ch5-Z-G-5.gif differ
diff --git a/src/OEBPS/images/ch5-Z-G-6.gif b/src/OEBPS/images/ch5-Z-G-6.gif
new file mode 100644
index 0000000..3389516
Binary files /dev/null and b/src/OEBPS/images/ch5-Z-G-6.gif differ
diff --git a/src/OEBPS/images/ch5-Z-G-7.gif b/src/OEBPS/images/ch5-Z-G-7.gif
new file mode 100644
index 0000000..25409b2
Binary files /dev/null and b/src/OEBPS/images/ch5-Z-G-7.gif differ
diff --git a/src/OEBPS/images/ch5-Z-G-8.gif b/src/OEBPS/images/ch5-Z-G-8.gif
new file mode 100644
index 0000000..a6c5063
Binary files /dev/null and b/src/OEBPS/images/ch5-Z-G-8.gif differ
diff --git a/src/OEBPS/images/ch5-Z-G-9.gif b/src/OEBPS/images/ch5-Z-G-9.gif
new file mode 100644
index 0000000..82b2f90
Binary files /dev/null and b/src/OEBPS/images/ch5-Z-G-9.gif differ
diff --git a/src/OEBPS/toc.ncx b/src/OEBPS/toc.ncx
index 0ba6a36..6453225 100644
--- a/src/OEBPS/toc.ncx
+++ b/src/OEBPS/toc.ncx
@@ -1,13 +1,10 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE ncx PUBLIC "-//NISO//DTD ncx 2005-1//EN"
-   "http://www.daisy.org/z3986/2005/ncx-2005-1.dtd">
-
+<?xml version='1.0' encoding='UTF-8'?>
 <ncx xmlns="http://www.daisy.org/z3986/2005/ncx/" version="2005-1">
     <head>
-        <meta name="dtb:uid" content="031c9b00-1bda-4c31-8ff5-b4f309c05c56"/>
-        <meta name="dtb:depth" content="5"/>
-        <meta name="dtb:totalPageCount" content="0"/>
-        <meta name="dtb:maxPageNumber" content="0"/>
+        <meta content="031c9b00-1bda-4c31-8ff5-b4f309c05c56" name="dtb:uid" />
+        <meta content="5" name="dtb:depth" />
+        <meta content="0" name="dtb:totalPageCount" />
+        <meta content="0" name="dtb:maxPageNumber" />
     </head>
     <docTitle>
         <text>Structure and Interpretation of Computer Programs</text>
@@ -17,112 +14,112 @@
             <navLabel>
                 <text>Structure and Interpretation of Computer Programs</text>
             </navLabel>
-            <content src="book-Z-H-1.html"/>
+            <content src="book-Z-H-1.html" />
         </navPoint>
         <navPoint id="navPoint-2" playOrder="2">
             <navLabel>
                 <text>Foreword</text>
             </navLabel>
-            <content src="book-Z-H-5.html"/>
+            <content src="book-Z-H-5.html" />
         </navPoint>
         <navPoint id="navPoint-3" playOrder="3">
             <navLabel>
                 <text>Preface to the Second Edition</text>
             </navLabel>
-            <content src="book-Z-H-6.html"/>
+            <content src="book-Z-H-6.html" />
         </navPoint>
         <navPoint id="navPoint-4" playOrder="4">
             <navLabel>
                 <text>Preface to the First Edition</text>
             </navLabel>
-            <content src="book-Z-H-7.html"/>
+            <content src="book-Z-H-7.html" />
         </navPoint>
         <navPoint id="navPoint-5" playOrder="5">
             <navLabel>
                 <text>Acknowledgments</text>
             </navLabel>
-            <content src="book-Z-H-8.html"/>
+            <content src="book-Z-H-8.html" />
         </navPoint>
         <navPoint id="navPoint-6" playOrder="6">
             <navLabel>
                 <text>Chapter 1</text>
             </navLabel>
-            <content src="book-Z-H-9.html"/>
+            <content src="book-Z-H-9.html" />
             <navPoint id="navPoint-7" playOrder="7">
                 <navLabel>
                     <text>Programming in Lisp</text>
                 </navLabel>
-                <content src="book-Z-H-9a.html"/>
+                <content src="book-Z-H-9.html#__sec_Temp_6" />
             </navPoint>
             <navPoint id="navPoint-8" playOrder="8">
                 <navLabel>
                     <text>1.1 The Elements of Programming</text>
                 </navLabel>
-                <content src="book-Z-H-10.html"/>
+                <content src="book-Z-H-10.html" />
                 <navPoint id="navPoint-9" playOrder="9">
                     <navLabel>
                         <text>1.1.1 Expressions</text>
                     </navLabel>
-                    <content src="book-Z-H-10.html#heading_id_3"/>
+                    <content src="book-Z-H-10.html#__sec_1.1.1" />
                 </navPoint>
                 <navPoint id="navPoint-10" playOrder="10">
                     <navLabel>
                         <text>1.1.2 Naming and the Environment</text>
                     </navLabel>
-                    <content src="book-Z-H-10.html#heading_id_4"/>
+                    <content src="book-Z-H-10.html#__sec_1.1.2" />
                 </navPoint>
                 <navPoint id="navPoint-11" playOrder="11">
                     <navLabel>
                         <text>1.1.3 Evaluating Combinations</text>
                     </navLabel>
-                    <content src="book-Z-H-10.html#heading_id_5"/>
+                    <content src="book-Z-H-10.html#__sec_1.1.3" />
                 </navPoint>
                 <navPoint id="navPoint-12" playOrder="12">
                     <navLabel>
                         <text>1.1.4 Compound Procedures</text>
                     </navLabel>
-                    <content src="book-Z-H-10.html#heading_id_6"/>
+                    <content src="book-Z-H-10.html#__sec_1.1.4" />
                 </navPoint>
                 <navPoint id="navPoint-13" playOrder="13">
                     <navLabel>
                         <text>1.1.5 The Substitution Model for Procedure Application</text>
                     </navLabel>
-                    <content src="book-Z-H-10.html#heading_id_7"/>
+                    <content src="book-Z-H-10.html#__sec_1.1.5" />
                     <navPoint id="navPoint-14" playOrder="14">
                         <navLabel>
                             <text>Applicative order versus normal order</text>
                         </navLabel>
-                        <content src="book-Z-H-10.html#heading_id_8"/>
+                        <content src="book-Z-H-10.html#__sec_Temp_22" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-15" playOrder="15">
                     <navLabel>
                         <text>1.1.6 Conditional Expressions and Predicates</text>
                     </navLabel>
-                    <content src="book-Z-H-10.html#heading_id_9"/>
+                    <content src="book-Z-H-10.html#__sec_1.1.6" />
                 </navPoint>
                 <navPoint id="navPoint-16" playOrder="16">
                     <navLabel>
                         <text>1.1.7 Example: Square Roots by Newton's Method</text>
                     </navLabel>
-                    <content src="book-Z-H-10.html#heading_id_10"/>
+                    <content src="book-Z-H-10.html#__sec_1.1.7" />
                 </navPoint>
                 <navPoint id="navPoint-17" playOrder="17">
                     <navLabel>
                         <text>1.1.8 Procedures as Black-Box Abstractions</text>
                     </navLabel>
-                    <content src="book-Z-H-10.html#heading_id_11"/>
+                    <content src="book-Z-H-10.html#__sec_1.1.8" />
                     <navPoint id="navPoint-18" playOrder="18">
                         <navLabel>
                             <text>Local names</text>
                         </navLabel>
-                        <content src="book-Z-H-10.html#heading_id_12"/>
+                        <content src="book-Z-H-10.html#__sec_Temp_41" />
                     </navPoint>
                     <navPoint id="navPoint-19" playOrder="19">
                         <navLabel>
                             <text>Internal definitions and block structure</text>
                         </navLabel>
-                        <content src="book-Z-H-10.html#heading_id_13"/>
+                        <content src="book-Z-H-10.html#__sec_Temp_43" />
                     </navPoint>
                 </navPoint>
             </navPoint>
@@ -130,65 +127,65 @@
                 <navLabel>
                     <text>1.2 Procedures and the Processes They Generate</text>
                 </navLabel>
-                <content src="book-Z-H-11.html"/>
+                <content src="book-Z-H-11.html" />
                 <navPoint id="navPoint-21" playOrder="21">
                     <navLabel>
                         <text>1.2.1 Linear Recursion and Iteration</text>
                     </navLabel>
-                    <content src="book-Z-H-11.html#heading_id_3"/>
+                    <content src="book-Z-H-11.html#__sec_1.2.1" />
                 </navPoint>
                 <navPoint id="navPoint-22" playOrder="22">
                     <navLabel>
                         <text>1.2.2 Tree Recursion</text>
                     </navLabel>
-                    <content src="book-Z-H-11.html#heading_id_4"/>
+                    <content src="book-Z-H-11.html#__sec_1.2.2" />
                     <navPoint id="navPoint-23" playOrder="23">
                         <navLabel>
                             <text>Example: Counting change</text>
                         </navLabel>
-                        <content src="book-Z-H-11.html#heading_id_5"/>
+                        <content src="book-Z-H-11.html#__sec_Temp_52" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-24" playOrder="24">
                     <navLabel>
                         <text>1.2.3 Orders of Growth</text>
                     </navLabel>
-                    <content src="book-Z-H-11.html#heading_id_6"/>
+                    <content src="book-Z-H-11.html#__sec_1.2.3" />
                 </navPoint>
                 <navPoint id="navPoint-25" playOrder="25">
                     <navLabel>
                         <text>1.2.4 Exponentiation</text>
                     </navLabel>
-                    <content src="book-Z-H-11.html#heading_id_7"/>
+                    <content src="book-Z-H-11.html#__sec_1.2.4" />
                 </navPoint>
                 <navPoint id="navPoint-26" playOrder="26">
                     <navLabel>
                         <text>1.2.5 Greatest Common Divisors</text>
                     </navLabel>
-                    <content src="book-Z-H-11.html#heading_id_8"/>
+                    <content src="book-Z-H-11.html#__sec_1.2.5" />
                 </navPoint>
                 <navPoint id="navPoint-27" playOrder="27">
                     <navLabel>
                         <text>1.2.6 Example: Testing for Primality</text>
                     </navLabel>
-                    <content src="book-Z-H-11.html#heading_id_9"/>
+                    <content src="book-Z-H-11.html#__sec_1.2.6" />
                     <navPoint id="navPoint-28" playOrder="28">
                         <navLabel>
                             <text>Searching for divisors</text>
                         </navLabel>
-                        <content src="book-Z-H-11.html#heading_id_10"/>
+                        <content src="book-Z-H-11.html#__sec_Temp_74" />
                     </navPoint>
                     <navPoint id="navPoint-29" playOrder="29">
                         <navLabel>
                             <text>The Fermat test</text>
                         </navLabel>
-                        <content src="book-Z-H-11.html#heading_id_11"/>
+                        <content src="book-Z-H-11.html#__sec_Temp_76" />
                     </navPoint>
                     <navPoint id="navPoint-30" playOrder="30">
                         <navLabel>
                             <text>Probabilistic methods</text>
                         </navLabel>
-                        <content src="book-Z-H-11.html#heading_id_12"/>
+                        <content src="book-Z-H-11.html#__sec_Temp_79" />
                     </navPoint>
                 </navPoint>
             </navPoint>
@@ -196,59 +193,59 @@
                 <navLabel>
                     <text>1.3 Formulating Abstractions with Higher-Order Procedures</text>
                 </navLabel>
-                <content src="book-Z-H-12.html"/>
+                <content src="book-Z-H-12.html" />
                 <navPoint id="navPoint-32" playOrder="32">
                     <navLabel>
                         <text>1.3.1 Procedures as Arguments</text>
                     </navLabel>
-                    <content src="book-Z-H-12.html#heading_id_3"/>
+                    <content src="book-Z-H-12.html#__sec_1.3.1" />
                 </navPoint>
                 <navPoint id="navPoint-33" playOrder="33">
                     <navLabel>
                         <text>1.3.2 Constructing Procedures Using Lambda</text>
                     </navLabel>
-                    <content src="book-Z-H-12.html#heading_id_4"/>
+                    <content src="book-Z-H-12.html#__sec_1.3.2" />
                     <navPoint id="navPoint-34" playOrder="34">
                         <navLabel>
                             <text>Using let to create local variables</text>
                         </navLabel>
-                        <content src="book-Z-H-12.html#heading_id_5"/>
+                        <content src="book-Z-H-12.html#__sec_Temp_100" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-35" playOrder="35">
                     <navLabel>
                         <text>1.3.3 Procedures as General Methods</text>
                     </navLabel>
-                    <content src="book-Z-H-12.html#heading_id_6"/>
+                    <content src="book-Z-H-12.html#__sec_1.3.3" />
                     <navPoint id="navPoint-36" playOrder="36">
                         <navLabel>
                             <text>Finding roots of equations by the half-interval method</text>
                         </navLabel>
-                        <content src="book-Z-H-12.html#heading_id_7"/>
+                        <content src="book-Z-H-12.html#__sec_Temp_103" />
                     </navPoint>
                     <navPoint id="navPoint-37" playOrder="37">
                         <navLabel>
                             <text>Finding fixed points of functions</text>
                         </navLabel>
-                        <content src="book-Z-H-12.html#heading_id_8"/>
+                        <content src="book-Z-H-12.html#__sec_Temp_106" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-38" playOrder="38">
                     <navLabel>
                         <text>1.3.4 Procedures as Returned Values</text>
                     </navLabel>
-                    <content src="book-Z-H-12.html#heading_id_9"/>
+                    <content src="book-Z-H-12.html#__sec_1.3.4" />
                     <navPoint id="navPoint-39" playOrder="39">
                         <navLabel>
                             <text>Newton's method</text>
                         </navLabel>
-                        <content src="book-Z-H-12.html#heading_id_10"/>
+                        <content src="book-Z-H-12.html#__sec_Temp_116" />
                     </navPoint>
                     <navPoint id="navPoint-40" playOrder="40">
                         <navLabel>
                             <text>Abstractions and first-class procedures</text>
                         </navLabel>
-                        <content src="book-Z-H-12.html#heading_id_11"/>
+                        <content src="book-Z-H-12.html#__sec_Temp_120" />
                     </navPoint>
                 </navPoint>
             </navPoint>
@@ -257,142 +254,142 @@
             <navLabel>
                 <text>Chapter 2</text>
             </navLabel>
-            <content src="book-Z-H-13.html"/>
+            <content src="book-Z-H-13.html" />
             <navPoint id="navPoint-42" playOrder="42">
                 <navLabel>
                     <text>2.1 Introduction to Data Abstraction</text>
                 </navLabel>
-                <content src="book-Z-H-14.html"/>
+                <content src="book-Z-H-14.html" />
                 <navPoint id="navPoint-43" playOrder="43">
                     <navLabel>
                         <text>2.1.1 Example: Arithmetic Operations for Rational Numbers</text>
                     </navLabel>
-                    <content src="book-Z-H-14.html#heading_id_3"/>
+                    <content src="book-Z-H-14.html#__sec_2.1.1" />
                     <navPoint id="navPoint-44" playOrder="44">
                         <navLabel>
                             <text>Pairs</text>
                         </navLabel>
-                        <content src="book-Z-H-14.html#heading_id_4"/>
+                        <content src="book-Z-H-14.html#__sec_Temp_132" />
                     </navPoint>
                     <navPoint id="navPoint-45" playOrder="45">
                         <navLabel>
                             <text>Representing rational numbers</text>
                         </navLabel>
-                        <content src="book-Z-H-14.html#heading_id_5"/>
+                        <content src="book-Z-H-14.html#__sec_Temp_134" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-46" playOrder="46">
                     <navLabel>
                         <text>2.1.2 Abstraction Barriers</text>
                     </navLabel>
-                    <content src="book-Z-H-14.html#heading_id_6"/>
+                    <content src="book-Z-H-14.html#__sec_2.1.2" />
                 </navPoint>
                 <navPoint id="navPoint-47" playOrder="47">
                     <navLabel>
                         <text>2.1.3 What Is Meant by Data?</text>
                     </navLabel>
-                    <content src="book-Z-H-14.html#heading_id_7"/>
+                    <content src="book-Z-H-14.html#__sec_2.1.3" />
                 </navPoint>
                 <navPoint id="navPoint-48" playOrder="48">
                     <navLabel>
                         <text>2.1.4 Extended Exercise: Interval Arithmetic</text>
                     </navLabel>
-                    <content src="book-Z-H-14.html#heading_id_8"/>
+                    <content src="book-Z-H-14.html#__sec_2.1.4" />
                 </navPoint>
             </navPoint>
             <navPoint id="navPoint-49" playOrder="49">
                 <navLabel>
                     <text>2.2 Hierarchical Data and the Closure Property</text>
                 </navLabel>
-                <content src="book-Z-H-15.html"/>
+                <content src="book-Z-H-15.html" />
                 <navPoint id="navPoint-50" playOrder="50">
                     <navLabel>
                         <text>2.2.1 Representing Sequences</text>
                     </navLabel>
-                    <content src="book-Z-H-15.html#heading_id_3"/>
+                    <content src="book-Z-H-15.html#__sec_2.2.1" />
                     <navPoint id="navPoint-51" playOrder="51">
                         <navLabel>
                             <text>List operations</text>
                         </navLabel>
-                        <content src="book-Z-H-15.html#heading_id_4"/>
+                        <content src="book-Z-H-15.html#__sec_Temp_159" />
                     </navPoint>
                     <navPoint id="navPoint-52" playOrder="52">
                         <navLabel>
                             <text>Mapping over lists</text>
                         </navLabel>
-                        <content src="book-Z-H-15.html#heading_id_5"/>
+                        <content src="book-Z-H-15.html#__sec_Temp_165" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-53" playOrder="53">
                     <navLabel>
                         <text>2.2.2 Hierarchical Structures</text>
                     </navLabel>
-                    <content src="book-Z-H-15.html#heading_id_6"/>
+                    <content src="book-Z-H-15.html#__sec_2.2.2" />
                     <navPoint id="navPoint-54" playOrder="54">
                         <navLabel>
                             <text>Mapping over trees</text>
                         </navLabel>
-                        <content src="book-Z-H-15.html#heading_id_7"/>
+                        <content src="book-Z-H-15.html#__sec_Temp_177" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-55" playOrder="55">
                     <navLabel>
                         <text>2.2.3 Sequences as Conventional Interfaces</text>
                     </navLabel>
-                    <content src="book-Z-H-15.html#heading_id_8"/>
+                    <content src="book-Z-H-15.html#__sec_2.2.3" />
                     <navPoint id="navPoint-56" playOrder="56">
                         <navLabel>
                             <text>Sequence Operations</text>
                         </navLabel>
-                        <content src="book-Z-H-15.html#heading_id_9"/>
+                        <content src="book-Z-H-15.html#__sec_Temp_181" />
                     </navPoint>
                     <navPoint id="navPoint-57" playOrder="57">
                         <navLabel>
                             <text>Nested Mappings</text>
                         </navLabel>
-                        <content src="book-Z-H-15.html#heading_id_10"/>
+                        <content src="book-Z-H-15.html#__sec_Temp_193" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-58" playOrder="58">
                     <navLabel>
                         <text>2.2.4 Example: A Picture Language</text>
                     </navLabel>
-                    <content src="book-Z-H-15.html#heading_id_11"/>
+                    <content src="book-Z-H-15.html#__sec_2.2.4" />
                     <navPoint id="navPoint-59" playOrder="59">
                         <navLabel>
                             <text>The picture language</text>
                         </navLabel>
-                        <content src="book-Z-H-15.html#heading_id_12"/>
+                        <content src="book-Z-H-15.html#__sec_Temp_203" />
                     </navPoint>
                     <navPoint id="navPoint-60" playOrder="60">
                         <navLabel>
                             <text>Higher-order operations</text>
                         </navLabel>
-                        <content src="book-Z-H-15.html#heading_id_13"/>
+                        <content src="book-Z-H-15.html#__sec_Temp_206" />
                     </navPoint>
                     <navPoint id="navPoint-61" playOrder="61">
                         <navLabel>
                             <text>Frames</text>
                         </navLabel>
-                        <content src="book-Z-H-15.html#heading_id_14"/>
+                        <content src="book-Z-H-15.html#__sec_Temp_210" />
                     </navPoint>
                     <navPoint id="navPoint-62" playOrder="62">
                         <navLabel>
                             <text>Painters</text>
                         </navLabel>
-                        <content src="book-Z-H-15.html#heading_id_15"/>
+                        <content src="book-Z-H-15.html#__sec_Temp_214" />
                     </navPoint>
                     <navPoint id="navPoint-63" playOrder="63">
                         <navLabel>
                             <text>Transforming and combining painters</text>
                         </navLabel>
-                        <content src="book-Z-H-15.html#heading_id_16"/>
+                        <content src="book-Z-H-15.html#__sec_Temp_219" />
                     </navPoint>
                     <navPoint id="navPoint-64" playOrder="64">
                         <navLabel>
                             <text>Levels of language for robust design</text>
                         </navLabel>
-                        <content src="book-Z-H-15.html#heading_id_17"/>
+                        <content src="book-Z-H-15.html#__sec_Temp_224" />
                     </navPoint>
                 </navPoint>
             </navPoint>
@@ -400,89 +397,89 @@
                 <navLabel>
                     <text>2.3 Symbolic Data</text>
                 </navLabel>
-                <content src="book-Z-H-16.html"/>
+                <content src="book-Z-H-16.html" />
                 <navPoint id="navPoint-66" playOrder="66">
                     <navLabel>
                         <text>2.3.1 Quotation</text>
                     </navLabel>
-                    <content src="book-Z-H-16.html#heading_id_3"/>
+                    <content src="book-Z-H-16.html#__sec_2.3.1" />
                 </navPoint>
                 <navPoint id="navPoint-67" playOrder="67">
                     <navLabel>
                         <text>2.3.2 Example: Symbolic Differentiation</text>
                     </navLabel>
-                    <content src="book-Z-H-16.html#heading_id_4"/>
+                    <content src="book-Z-H-16.html#__sec_2.3.2" />
                     <navPoint id="navPoint-68" playOrder="68">
                         <navLabel>
                             <text>The differentiation program with abstract data</text>
                         </navLabel>
-                        <content src="book-Z-H-16.html#heading_id_5"/>
+                        <content src="book-Z-H-16.html#__sec_Temp_235" />
                     </navPoint>
                     <navPoint id="navPoint-69" playOrder="69">
                         <navLabel>
                             <text>Representing algebraic expressions</text>
                         </navLabel>
-                        <content src="book-Z-H-16.html#heading_id_6"/>
+                        <content src="book-Z-H-16.html#__sec_Temp_236" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-70" playOrder="70">
                     <navLabel>
                         <text>2.3.3 Example: Representing Sets</text>
                     </navLabel>
-                    <content src="book-Z-H-16.html#heading_id_7"/>
+                    <content src="book-Z-H-16.html#__sec_2.3.3" />
                     <navPoint id="navPoint-71" playOrder="71">
                         <navLabel>
                             <text>Sets as unordered lists</text>
                         </navLabel>
-                        <content src="book-Z-H-16.html#heading_id_8"/>
+                        <content src="book-Z-H-16.html#__sec_Temp_241" />
                     </navPoint>
                     <navPoint id="navPoint-72" playOrder="72">
                         <navLabel>
                             <text>Sets as ordered lists</text>
                         </navLabel>
-                        <content src="book-Z-H-16.html#heading_id_9"/>
+                        <content src="book-Z-H-16.html#__sec_Temp_244" />
                     </navPoint>
                     <navPoint id="navPoint-73" playOrder="73">
                         <navLabel>
                             <text>Sets as binary trees</text>
                         </navLabel>
-                        <content src="book-Z-H-16.html#heading_id_10"/>
+                        <content src="book-Z-H-16.html#__sec_Temp_247" />
                     </navPoint>
                     <navPoint id="navPoint-74" playOrder="74">
                         <navLabel>
                             <text>Sets and information retrieval</text>
                         </navLabel>
-                        <content src="book-Z-H-16.html#heading_id_11"/>
+                        <content src="book-Z-H-16.html#__sec_Temp_255" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-75" playOrder="75">
                     <navLabel>
                         <text>2.3.4 Example: Huffman Encoding Trees</text>
                     </navLabel>
-                    <content src="book-Z-H-16.html#heading_id_12"/>
+                    <content src="book-Z-H-16.html#__sec_2.3.4" />
                     <navPoint id="navPoint-76" playOrder="76">
                         <navLabel>
                             <text>Generating Huffman trees</text>
                         </navLabel>
-                        <content src="book-Z-H-16.html#heading_id_13"/>
+                        <content src="book-Z-H-16.html#__sec_Temp_257" />
                     </navPoint>
                     <navPoint id="navPoint-77" playOrder="77">
                         <navLabel>
                             <text>Representing Huffman trees</text>
                         </navLabel>
-                        <content src="book-Z-H-16.html#heading_id_14"/>
+                        <content src="book-Z-H-16.html#__sec_Temp_259" />
                     </navPoint>
                     <navPoint id="navPoint-78" playOrder="78">
                         <navLabel>
                             <text>The decoding procedure</text>
                         </navLabel>
-                        <content src="book-Z-H-16.html#heading_id_15"/>
+                        <content src="book-Z-H-16.html#__sec_Temp_260" />
                     </navPoint>
                     <navPoint id="navPoint-79" playOrder="79">
                         <navLabel>
                             <text>Sets of weighted elements</text>
                         </navLabel>
-                        <content src="book-Z-H-16.html#heading_id_16"/>
+                        <content src="book-Z-H-16.html#__sec_Temp_261" />
                     </navPoint>
                 </navPoint>
             </navPoint>
@@ -490,29 +487,29 @@
                 <navLabel>
                     <text>2.4 Multiple Representations for Abstract Data</text>
                 </navLabel>
-                <content src="book-Z-H-17.html"/>
+                <content src="book-Z-H-17.html" />
                 <navPoint id="navPoint-81" playOrder="81">
                     <navLabel>
                         <text>2.4.1 Representations for Complex Numbers</text>
                     </navLabel>
-                    <content src="book-Z-H-17.html#heading_id_3"/>
+                    <content src="book-Z-H-17.html#__sec_2.4.1" />
                 </navPoint>
                 <navPoint id="navPoint-82" playOrder="82">
                     <navLabel>
                         <text>2.4.2 Tagged data</text>
                     </navLabel>
-                    <content src="book-Z-H-17.html#heading_id_4"/>
+                    <content src="book-Z-H-17.html#__sec_2.4.2" />
                 </navPoint>
                 <navPoint id="navPoint-83" playOrder="83">
                     <navLabel>
                         <text>2.4.3 Data-Directed Programming and Additivity</text>
                     </navLabel>
-                    <content src="book-Z-H-17.html#heading_id_5"/>
+                    <content src="book-Z-H-17.html#__sec_2.4.3" />
                     <navPoint id="navPoint-84" playOrder="84">
                         <navLabel>
                             <text>Message passing</text>
                         </navLabel>
-                        <content src="book-Z-H-17.html#heading_id_6"/>
+                        <content src="book-Z-H-17.html#__sec_Temp_275" />
                     </navPoint>
                 </navPoint>
             </navPoint>
@@ -520,65 +517,65 @@
                 <navLabel>
                     <text>2.5 Systems with Generic Operations</text>
                 </navLabel>
-                <content src="book-Z-H-18.html"/>
+                <content src="book-Z-H-18.html" />
                 <navPoint id="navPoint-86" playOrder="86">
                     <navLabel>
                         <text>2.5.1 Generic Arithmetic Operations</text>
                     </navLabel>
-                    <content src="book-Z-H-18.html#heading_id_3"/>
+                    <content src="book-Z-H-18.html#__sec_2.5.1" />
                 </navPoint>
                 <navPoint id="navPoint-87" playOrder="87">
                     <navLabel>
                         <text>2.5.2 Combining Data of Different Types</text>
                     </navLabel>
-                    <content src="book-Z-H-18.html#heading_id_4"/>
+                    <content src="book-Z-H-18.html#__sec_2.5.2" />
                     <navPoint id="navPoint-88" playOrder="88">
                         <navLabel>
                             <text>Coercion</text>
                         </navLabel>
-                        <content src="book-Z-H-18.html#heading_id_5"/>
+                        <content src="book-Z-H-18.html#__sec_Temp_284" />
                     </navPoint>
                     <navPoint id="navPoint-89" playOrder="89">
                         <navLabel>
                             <text>Hierarchies of types</text>
                         </navLabel>
-                        <content src="book-Z-H-18.html#heading_id_6"/>
+                        <content src="book-Z-H-18.html#__sec_Temp_287" />
                     </navPoint>
                     <navPoint id="navPoint-90" playOrder="90">
                         <navLabel>
                             <text>Inadequacies of hierarchies</text>
                         </navLabel>
-                        <content src="book-Z-H-18.html#heading_id_7"/>
+                        <content src="book-Z-H-18.html#__sec_Temp_288" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-91" playOrder="91">
                     <navLabel>
                         <text>2.5.3 Example: Symbolic Algebra</text>
                     </navLabel>
-                    <content src="book-Z-H-18.html#heading_id_8"/>
+                    <content src="book-Z-H-18.html#__sec_2.5.3" />
                     <navPoint id="navPoint-92" playOrder="92">
                         <navLabel>
                             <text>Arithmetic on polynomials</text>
                         </navLabel>
-                        <content src="book-Z-H-18.html#heading_id_9"/>
+                        <content src="book-Z-H-18.html#__sec_Temp_297" />
                     </navPoint>
                     <navPoint id="navPoint-93" playOrder="93">
                         <navLabel>
                             <text>Representing term lists</text>
                         </navLabel>
-                        <content src="book-Z-H-18.html#heading_id_10"/>
+                        <content src="book-Z-H-18.html#__sec_Temp_302" />
                     </navPoint>
                     <navPoint id="navPoint-94" playOrder="94">
                         <navLabel>
                             <text>Hierarchies of types in symbolic algebra</text>
                         </navLabel>
-                        <content src="book-Z-H-18.html#heading_id_11"/>
+                        <content src="book-Z-H-18.html#__sec_Temp_310" />
                     </navPoint>
                     <navPoint id="navPoint-95" playOrder="95">
                         <navLabel>
                             <text>Extended exercise: Rational functions</text>
                         </navLabel>
-                        <content src="book-Z-H-18.html#heading_id_12"/>
+                        <content src="book-Z-H-18.html#__sec_Temp_312" />
                     </navPoint>
                 </navPoint>
             </navPoint>
@@ -587,40 +584,40 @@
             <navLabel>
                 <text>Chapter 3</text>
             </navLabel>
-            <content src="book-Z-H-19.html"/>
+            <content src="book-Z-H-19.html" />
             <navPoint id="navPoint-97" playOrder="97">
                 <navLabel>
                     <text>3.1 Assignment and Local State</text>
                 </navLabel>
-                <content src="book-Z-H-20.html"/>
+                <content src="book-Z-H-20.html" />
                 <navPoint id="navPoint-98" playOrder="98">
                     <navLabel>
                         <text>3.1.1 Local State Variables</text>
                     </navLabel>
-                    <content src="book-Z-H-20.html#heading_id_3"/>
+                    <content src="book-Z-H-20.html#__sec_3.1.1" />
                 </navPoint>
                 <navPoint id="navPoint-99" playOrder="99">
                     <navLabel>
                         <text>3.1.2 The Benefits of Introducing Assignment</text>
                     </navLabel>
-                    <content src="book-Z-H-20.html#heading_id_4"/>
+                    <content src="book-Z-H-20.html#__sec_3.1.2" />
                 </navPoint>
                 <navPoint id="navPoint-100" playOrder="100">
                     <navLabel>
                         <text>3.1.3 The Costs of Introducing Assignment</text>
                     </navLabel>
-                    <content src="book-Z-H-20.html#heading_id_5"/>
+                    <content src="book-Z-H-20.html#__sec_3.1.3" />
                     <navPoint id="navPoint-101" playOrder="101">
                         <navLabel>
                             <text>Sameness and change</text>
                         </navLabel>
-                        <content src="book-Z-H-20.html#heading_id_6"/>
+                        <content src="book-Z-H-20.html#__sec_Temp_336" />
                     </navPoint>
                     <navPoint id="navPoint-102" playOrder="102">
                         <navLabel>
                             <text>Pitfalls of imperative programming</text>
                         </navLabel>
-                        <content src="book-Z-H-20.html#heading_id_7"/>
+                        <content src="book-Z-H-20.html#__sec_Temp_338" />
                     </navPoint>
                 </navPoint>
             </navPoint>
@@ -628,137 +625,137 @@
                 <navLabel>
                     <text>3.2 The Environment Model of Evaluation</text>
                 </navLabel>
-                <content src="book-Z-H-21.html"/>
+                <content src="book-Z-H-21.html" />
                 <navPoint id="navPoint-104" playOrder="104">
                     <navLabel>
                         <text>3.2.1 The Rules for Evaluation</text>
                     </navLabel>
-                    <content src="book-Z-H-21.html#heading_id_3"/>
+                    <content src="book-Z-H-21.html#__sec_3.2.1" />
                 </navPoint>
                 <navPoint id="navPoint-105" playOrder="105">
                     <navLabel>
                         <text>3.2.2 Applying Simple Procedures</text>
                     </navLabel>
-                    <content src="book-Z-H-21.html#heading_id_4"/>
+                    <content src="book-Z-H-21.html#__sec_3.2.2" />
                 </navPoint>
                 <navPoint id="navPoint-106" playOrder="106">
                     <navLabel>
                         <text>3.2.3 Frames as the Repository of Local State</text>
                     </navLabel>
-                    <content src="book-Z-H-21.html#heading_id_5"/>
+                    <content src="book-Z-H-21.html#__sec_3.2.3" />
                 </navPoint>
                 <navPoint id="navPoint-107" playOrder="107">
                     <navLabel>
                         <text>3.2.4 Internal Definitions</text>
                     </navLabel>
-                    <content src="book-Z-H-21.html#heading_id_6"/>
+                    <content src="book-Z-H-21.html#__sec_3.2.4" />
                 </navPoint>
             </navPoint>
             <navPoint id="navPoint-108" playOrder="108">
                 <navLabel>
                     <text>3.3 Modeling with Mutable Data</text>
                 </navLabel>
-                <content src="book-Z-H-22.html"/>
+                <content src="book-Z-H-22.html" />
                 <navPoint id="navPoint-109" playOrder="109">
                     <navLabel>
                         <text>3.3.1 Mutable List Structure</text>
                     </navLabel>
-                    <content src="book-Z-H-22.html#heading_id_3"/>
+                    <content src="book-Z-H-22.html#__sec_3.3.1" />
                     <navPoint id="navPoint-110" playOrder="110">
                         <navLabel>
                             <text>Sharing and identity</text>
                         </navLabel>
-                        <content src="book-Z-H-22.html#heading_id_4"/>
+                        <content src="book-Z-H-22.html#__sec_Temp_355" />
                     </navPoint>
                     <navPoint id="navPoint-111" playOrder="111">
                         <navLabel>
                             <text>Mutation is just assignment</text>
                         </navLabel>
-                        <content src="book-Z-H-22.html#heading_id_5"/>
+                        <content src="book-Z-H-22.html#__sec_Temp_363" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-112" playOrder="112">
                     <navLabel>
                         <text>3.3.2 Representing Queues</text>
                     </navLabel>
-                    <content src="book-Z-H-22.html#heading_id_6"/>
+                    <content src="book-Z-H-22.html#__sec_3.3.2" />
                 </navPoint>
                 <navPoint id="navPoint-113" playOrder="113">
                     <navLabel>
                         <text>3.3.3 Representing Tables</text>
                     </navLabel>
-                    <content src="book-Z-H-22.html#heading_id_7"/>
+                    <content src="book-Z-H-22.html#__sec_3.3.3" />
                     <navPoint id="navPoint-114" playOrder="114">
                         <navLabel>
                             <text>Two-dimensional tables</text>
                         </navLabel>
-                        <content src="book-Z-H-22.html#heading_id_8"/>
+                        <content src="book-Z-H-22.html#__sec_Temp_373" />
                     </navPoint>
                     <navPoint id="navPoint-115" playOrder="115">
                         <navLabel>
                             <text>Creating local tables</text>
                         </navLabel>
-                        <content src="book-Z-H-22.html#heading_id_9"/>
+                        <content src="book-Z-H-22.html#__sec_Temp_374" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-116" playOrder="116">
                     <navLabel>
                         <text>3.3.4 A Simulator for Digital Circuits</text>
                     </navLabel>
-                    <content src="book-Z-H-22.html#heading_id_10"/>
+                    <content src="book-Z-H-22.html#__sec_3.3.4" />
                     <navPoint id="navPoint-117" playOrder="117">
                         <navLabel>
                             <text>Primitive function boxes</text>
                         </navLabel>
-                        <content src="book-Z-H-22.html#heading_id_11"/>
+                        <content src="book-Z-H-22.html#__sec_Temp_380" />
                     </navPoint>
                     <navPoint id="navPoint-118" playOrder="118">
                         <navLabel>
                             <text>Representing wires</text>
                         </navLabel>
-                        <content src="book-Z-H-22.html#heading_id_12"/>
+                        <content src="book-Z-H-22.html#__sec_Temp_384" />
                     </navPoint>
                     <navPoint id="navPoint-119" playOrder="119">
                         <navLabel>
                             <text>The agenda</text>
                         </navLabel>
-                        <content src="book-Z-H-22.html#heading_id_13"/>
+                        <content src="book-Z-H-22.html#__sec_Temp_386" />
                     </navPoint>
                     <navPoint id="navPoint-120" playOrder="120">
                         <navLabel>
                             <text>A sample simulation</text>
                         </navLabel>
-                        <content src="book-Z-H-22.html#heading_id_14"/>
+                        <content src="book-Z-H-22.html#__sec_Temp_387" />
                     </navPoint>
                     <navPoint id="navPoint-121" playOrder="121">
                         <navLabel>
                             <text>Implementing the agenda</text>
                         </navLabel>
-                        <content src="book-Z-H-22.html#heading_id_15"/>
+                        <content src="book-Z-H-22.html#__sec_Temp_389" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-122" playOrder="122">
                     <navLabel>
                         <text>3.3.5 Propagation of Constraints</text>
                     </navLabel>
-                    <content src="book-Z-H-22.html#heading_id_16"/>
+                    <content src="book-Z-H-22.html#__sec_3.3.5" />
                     <navPoint id="navPoint-123" playOrder="123">
                         <navLabel>
                             <text>Using the constraint system</text>
                         </navLabel>
-                        <content src="book-Z-H-22.html#heading_id_17"/>
+                        <content src="book-Z-H-22.html#__sec_Temp_395" />
                     </navPoint>
                     <navPoint id="navPoint-124" playOrder="124">
                         <navLabel>
                             <text>Implementing the constraint system</text>
                         </navLabel>
-                        <content src="book-Z-H-22.html#heading_id_18"/>
+                        <content src="book-Z-H-22.html#__sec_Temp_396" />
                     </navPoint>
                     <navPoint id="navPoint-125" playOrder="125">
                         <navLabel>
                             <text>Representing connectors</text>
                         </navLabel>
-                        <content src="book-Z-H-22.html#heading_id_19"/>
+                        <content src="book-Z-H-22.html#__sec_Temp_397" />
                     </navPoint>
                 </navPoint>
             </navPoint>
@@ -766,59 +763,59 @@
                 <navLabel>
                     <text>3.4 Concurrency: Time Is of the Essence</text>
                 </navLabel>
-                <content src="book-Z-H-23.html"/>
+                <content src="book-Z-H-23.html" />
                 <navPoint id="navPoint-127" playOrder="127">
                     <navLabel>
                         <text>3.4.1 The Nature of Time in Concurrent Systems</text>
                     </navLabel>
-                    <content src="book-Z-H-23.html#heading_id_3"/>
+                    <content src="book-Z-H-23.html#__sec_3.4.1" />
                     <navPoint id="navPoint-128" playOrder="128">
                         <navLabel>
                             <text>Correct behavior of concurrent programs</text>
                         </navLabel>
-                        <content src="book-Z-H-23.html#heading_id_4"/>
+                        <content src="book-Z-H-23.html#__sec_Temp_408" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-129" playOrder="129">
                     <navLabel>
                         <text>3.4.2 Mechanisms for Controlling Concurrency</text>
                     </navLabel>
-                    <content src="book-Z-H-23.html#heading_id_5"/>
+                    <content src="book-Z-H-23.html#__sec_3.4.2" />
                     <navPoint id="navPoint-130" playOrder="130">
                         <navLabel>
                             <text>Serializing access to shared state</text>
                         </navLabel>
-                        <content src="book-Z-H-23.html#heading_id_6"/>
+                        <content src="book-Z-H-23.html#__sec_Temp_413" />
                     </navPoint>
                     <navPoint id="navPoint-131" playOrder="131">
                         <navLabel>
                             <text>Serializers in Scheme</text>
                         </navLabel>
-                        <content src="book-Z-H-23.html#heading_id_7"/>
+                        <content src="book-Z-H-23.html#__sec_Temp_414" />
                     </navPoint>
                     <navPoint id="navPoint-132" playOrder="132">
                         <navLabel>
                             <text>Complexity of using multiple shared resources</text>
                         </navLabel>
-                        <content src="book-Z-H-23.html#heading_id_8"/>
+                        <content src="book-Z-H-23.html#__sec_Temp_420" />
                     </navPoint>
                     <navPoint id="navPoint-133" playOrder="133">
                         <navLabel>
                             <text>Implementing serializers</text>
                         </navLabel>
-                        <content src="book-Z-H-23.html#heading_id_9"/>
+                        <content src="book-Z-H-23.html#__sec_Temp_427" />
                     </navPoint>
                     <navPoint id="navPoint-134" playOrder="134">
                         <navLabel>
                             <text>Deadlock</text>
                         </navLabel>
-                        <content src="book-Z-H-23.html#heading_id_10"/>
+                        <content src="book-Z-H-23.html#__sec_Temp_434" />
                     </navPoint>
                     <navPoint id="navPoint-135" playOrder="135">
                         <navLabel>
                             <text>Concurrency, time, and communication</text>
                         </navLabel>
-                        <content src="book-Z-H-23.html#heading_id_11"/>
+                        <content src="book-Z-H-23.html#__sec_Temp_438" />
                     </navPoint>
                 </navPoint>
             </navPoint>
@@ -826,83 +823,83 @@
                 <navLabel>
                     <text>3.5 Streams</text>
                 </navLabel>
-                <content src="book-Z-H-24.html"/>
+                <content src="book-Z-H-24.html" />
                 <navPoint id="navPoint-137" playOrder="137">
                     <navLabel>
                         <text>3.5.1 Streams Are Delayed Lists</text>
                     </navLabel>
-                    <content src="book-Z-H-24.html#heading_id_3"/>
+                    <content src="book-Z-H-24.html#__sec_3.5.1" />
                     <navPoint id="navPoint-138" playOrder="138">
                         <navLabel>
                             <text>The stream implementation in action</text>
                         </navLabel>
-                        <content src="book-Z-H-24.html#heading_id_4"/>
+                        <content src="book-Z-H-24.html#__sec_Temp_447" />
                     </navPoint>
                     <navPoint id="navPoint-139" playOrder="139">
                         <navLabel>
                             <text>Implementing delay and force</text>
                         </navLabel>
-                        <content src="book-Z-H-24.html#heading_id_5"/>
+                        <content src="book-Z-H-24.html#__sec_Temp_449" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-140" playOrder="140">
                     <navLabel>
                         <text>3.5.2 Infinite Streams</text>
                     </navLabel>
-                    <content src="book-Z-H-24.html#heading_id_6"/>
+                    <content src="book-Z-H-24.html#__sec_3.5.2" />
                     <navPoint id="navPoint-141" playOrder="141">
                         <navLabel>
                             <text>Defining streams implicitly</text>
                         </navLabel>
-                        <content src="book-Z-H-24.html#heading_id_7"/>
+                        <content src="book-Z-H-24.html#__sec_Temp_457" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-142" playOrder="142">
                     <navLabel>
                         <text>3.5.3 Exploiting the Stream Paradigm</text>
                     </navLabel>
-                    <content src="book-Z-H-24.html#heading_id_8"/>
+                    <content src="book-Z-H-24.html#__sec_3.5.3" />
                     <navPoint id="navPoint-143" playOrder="143">
                         <navLabel>
                             <text>Formulating iterations as stream processes</text>
                         </navLabel>
-                        <content src="book-Z-H-24.html#heading_id_9"/>
+                        <content src="book-Z-H-24.html#__sec_Temp_471" />
                     </navPoint>
                     <navPoint id="navPoint-144" playOrder="144">
                         <navLabel>
                             <text>Infinite streams of pairs</text>
                         </navLabel>
-                        <content src="book-Z-H-24.html#heading_id_10"/>
+                        <content src="book-Z-H-24.html#__sec_Temp_476" />
                     </navPoint>
                     <navPoint id="navPoint-145" playOrder="145">
                         <navLabel>
                             <text>Streams as signals</text>
                         </navLabel>
-                        <content src="book-Z-H-24.html#heading_id_11"/>
+                        <content src="book-Z-H-24.html#__sec_Temp_489" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-146" playOrder="146">
                     <navLabel>
                         <text>3.5.4 Streams and Delayed Evaluation</text>
                     </navLabel>
-                    <content src="book-Z-H-24.html#heading_id_12"/>
+                    <content src="book-Z-H-24.html#__sec_3.5.4" />
                     <navPoint id="navPoint-147" playOrder="147">
                         <navLabel>
                             <text>Normal-order evaluation</text>
                         </navLabel>
-                        <content src="book-Z-H-24.html#heading_id_13"/>
+                        <content src="book-Z-H-24.html#__sec_Temp_499" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-148" playOrder="148">
                     <navLabel>
                         <text>3.5.5 Modularity of Functional Programs and Modularity of Objects</text>
                     </navLabel>
-                    <content src="book-Z-H-24.html#heading_id_14"/>
+                    <content src="book-Z-H-24.html#__sec_3.5.5" />
                     <navPoint id="navPoint-149" playOrder="149">
                         <navLabel>
                             <text>A functional-programming view of time</text>
                         </navLabel>
-                        <content src="book-Z-H-24.html#heading_id_15"/>
+                        <content src="book-Z-H-24.html#__sec_Temp_503" />
                     </navPoint>
                 </navPoint>
             </navPoint>
@@ -911,256 +908,256 @@
             <navLabel>
                 <text>Chapter 4</text>
             </navLabel>
-            <content src="book-Z-H-25.html"/>
+            <content src="book-Z-H-25.html" />
             <navPoint id="navPoint-151" playOrder="151">
                 <navLabel>
                     <text>4.1 The Metacircular Evaluator</text>
                 </navLabel>
-                <content src="book-Z-H-26.html"/>
+                <content src="book-Z-H-26.html" />
                 <navPoint id="navPoint-152" playOrder="152">
                     <navLabel>
                         <text>4.1.1 The Core of the Evaluator</text>
                     </navLabel>
-                    <content src="book-Z-H-26.html#heading_id_3"/>
+                    <content src="book-Z-H-26.html#__sec_4.1.1" />
                     <navPoint id="navPoint-153" playOrder="153">
                         <navLabel>
                             <text>Eval</text>
                         </navLabel>
-                        <content src="book-Z-H-26.html#heading_id_4"/>
+                        <content src="book-Z-H-26.html#__sec_Temp_512" />
                         <navPoint id="navPoint-154" playOrder="154">
                             <navLabel>
                                 <text>Primitive expressions</text>
                             </navLabel>
-                            <content src="book-Z-H-26.html#heading_id_5"/>
+                            <content src="book-Z-H-26.html#__sec_Temp_513" />
                         </navPoint>
                         <navPoint id="navPoint-155" playOrder="155">
                             <navLabel>
                                 <text>Special forms</text>
                             </navLabel>
-                            <content src="book-Z-H-26.html#heading_id_6"/>
+                            <content src="book-Z-H-26.html#__sec_Temp_514" />
                         </navPoint>
                         <navPoint id="navPoint-156" playOrder="156">
                             <navLabel>
                                 <text>Combinations</text>
                             </navLabel>
-                            <content src="book-Z-H-26.html#heading_id_7"/>
+                            <content src="book-Z-H-26.html#__sec_Temp_515" />
                         </navPoint>
                     </navPoint>
                     <navPoint id="navPoint-157" playOrder="157">
                         <navLabel>
                             <text>Apply</text>
                         </navLabel>
-                        <content src="book-Z-H-26.html#heading_id_8"/>
+                        <content src="book-Z-H-26.html#__sec_Temp_516" />
                     </navPoint>
                     <navPoint id="navPoint-158" playOrder="158">
                         <navLabel>
                             <text>Procedure arguments</text>
                         </navLabel>
-                        <content src="book-Z-H-26.html#heading_id_9"/>
+                        <content src="book-Z-H-26.html#__sec_Temp_517" />
                     </navPoint>
                     <navPoint id="navPoint-159" playOrder="159">
                         <navLabel>
                             <text>Conditionals</text>
                         </navLabel>
-                        <content src="book-Z-H-26.html#heading_id_10"/>
+                        <content src="book-Z-H-26.html#__sec_Temp_519" />
                     </navPoint>
                     <navPoint id="navPoint-160" playOrder="160">
                         <navLabel>
                             <text>Sequences</text>
                         </navLabel>
-                        <content src="book-Z-H-26.html#heading_id_11"/>
+                        <content src="book-Z-H-26.html#__sec_Temp_521" />
                     </navPoint>
                     <navPoint id="navPoint-161" playOrder="161">
                         <navLabel>
                             <text>Assignments and definitions</text>
                         </navLabel>
-                        <content src="book-Z-H-26.html#heading_id_12"/>
+                        <content src="book-Z-H-26.html#__sec_Temp_522" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-162" playOrder="162">
                     <navLabel>
                         <text>4.1.2 Representing Expressions</text>
                     </navLabel>
-                    <content src="book-Z-H-26.html#heading_id_13"/>
+                    <content src="book-Z-H-26.html#__sec_4.1.2" />
                     <navPoint id="navPoint-163" playOrder="163">
                         <navLabel>
                             <text>Derived expressions</text>
                         </navLabel>
-                        <content src="book-Z-H-26.html#heading_id_14"/>
+                        <content src="book-Z-H-26.html#__sec_Temp_529" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-164" playOrder="164">
                     <navLabel>
                         <text>4.1.3 Evaluator Data Structures</text>
                     </navLabel>
-                    <content src="book-Z-H-26.html#heading_id_15"/>
+                    <content src="book-Z-H-26.html#__sec_4.1.3" />
                     <navPoint id="navPoint-165" playOrder="165">
                         <navLabel>
                             <text>Testing of predicates</text>
                         </navLabel>
-                        <content src="book-Z-H-26.html#heading_id_16"/>
+                        <content src="book-Z-H-26.html#__sec_Temp_541" />
                     </navPoint>
                     <navPoint id="navPoint-166" playOrder="166">
                         <navLabel>
                             <text>Representing procedures</text>
                         </navLabel>
-                        <content src="book-Z-H-26.html#heading_id_17"/>
+                        <content src="book-Z-H-26.html#__sec_Temp_542" />
                     </navPoint>
                     <navPoint id="navPoint-167" playOrder="167">
                         <navLabel>
                             <text>Operations on Environments</text>
                         </navLabel>
-                        <content src="book-Z-H-26.html#heading_id_18"/>
+                        <content src="book-Z-H-26.html#__sec_Temp_543" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-168" playOrder="168">
                     <navLabel>
                         <text>4.1.4 Running the Evaluator as a Program</text>
                     </navLabel>
-                    <content src="book-Z-H-26.html#heading_id_19"/>
+                    <content src="book-Z-H-26.html#__sec_4.1.4" />
                 </navPoint>
                 <navPoint id="navPoint-169" playOrder="169">
                     <navLabel>
                         <text>4.1.5 Data as Programs</text>
                     </navLabel>
-                    <content src="book-Z-H-26.html#heading_id_20"/>
+                    <content src="book-Z-H-26.html#__sec_4.1.5" />
                 </navPoint>
                 <navPoint id="navPoint-170" playOrder="170">
                     <navLabel>
                         <text>4.1.6 Internal Definitions</text>
                     </navLabel>
-                    <content src="book-Z-H-26.html#heading_id_21"/>
+                    <content src="book-Z-H-26.html#__sec_4.1.6" />
                 </navPoint>
                 <navPoint id="navPoint-171" playOrder="171">
                     <navLabel>
                         <text>4.1.7 Separating Syntactic Analysis from Execution</text>
                     </navLabel>
-                    <content src="book-Z-H-26.html#heading_id_22"/>
+                    <content src="book-Z-H-26.html#__sec_4.1.7" />
                 </navPoint>
             </navPoint>
             <navPoint id="navPoint-172" playOrder="172">
                 <navLabel>
                     <text>4.2 Variations on a Scheme – Lazy Evaluation</text>
                 </navLabel>
-                <content src="book-Z-H-27.html"/>
+                <content src="book-Z-H-27.html" />
                 <navPoint id="navPoint-173" playOrder="173">
                     <navLabel>
                         <text>4.2.1 Normal Order and Applicative Order</text>
                     </navLabel>
-                    <content src="book-Z-H-27.html#heading_id_3"/>
+                    <content src="book-Z-H-27.html#__sec_4.2.1" />
                 </navPoint>
                 <navPoint id="navPoint-174" playOrder="174">
                     <navLabel>
                         <text>4.2.2 An Interpreter with Lazy Evaluation</text>
                     </navLabel>
-                    <content src="book-Z-H-27.html#heading_id_4"/>
+                    <content src="book-Z-H-27.html#__sec_4.2.2" />
                     <navPoint id="navPoint-175" playOrder="175">
                         <navLabel>
                             <text>Modifying the evaluator</text>
                         </navLabel>
-                        <content src="book-Z-H-27.html#heading_id_5"/>
+                        <content src="book-Z-H-27.html#__sec_Temp_583" />
                     </navPoint>
                     <navPoint id="navPoint-176" playOrder="176">
                         <navLabel>
                             <text>Representing thunks</text>
                         </navLabel>
-                        <content src="book-Z-H-27.html#heading_id_6"/>
+                        <content src="book-Z-H-27.html#__sec_Temp_584" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-177" playOrder="177">
                     <navLabel>
                         <text>4.2.3 Streams as Lazy Lists</text>
                     </navLabel>
-                    <content src="book-Z-H-27.html#heading_id_7"/>
+                    <content src="book-Z-H-27.html#__sec_4.2.3" />
                 </navPoint>
             </navPoint>
             <navPoint id="navPoint-178" playOrder="178">
                 <navLabel>
                     <text>4.3 Variations on a Scheme – Nondeterministic Computing</text>
                 </navLabel>
-                <content src="book-Z-H-28.html"/>
+                <content src="book-Z-H-28.html" />
                 <navPoint id="navPoint-179" playOrder="179">
                     <navLabel>
                         <text>4.3.1 Amb and Search</text>
                     </navLabel>
-                    <content src="book-Z-H-28.html#heading_id_3"/>
+                    <content src="book-Z-H-28.html#__sec_4.3.1" />
                     <navPoint id="navPoint-180" playOrder="180">
                         <navLabel>
                             <text>Driver loop</text>
                         </navLabel>
-                        <content src="book-Z-H-28.html#heading_id_4"/>
+                        <content src="book-Z-H-28.html#__sec_Temp_604" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-181" playOrder="181">
                     <navLabel>
                         <text>4.3.2 Examples of Nondeterministic Programs</text>
                     </navLabel>
-                    <content src="book-Z-H-28.html#heading_id_5"/>
+                    <content src="book-Z-H-28.html#__sec_4.3.2" />
                     <navPoint id="navPoint-182" playOrder="182">
                         <navLabel>
                             <text>Logic Puzzles</text>
                         </navLabel>
-                        <content src="book-Z-H-28.html#heading_id_6"/>
+                        <content src="book-Z-H-28.html#__sec_Temp_608" />
                     </navPoint>
                     <navPoint id="navPoint-183" playOrder="183">
                         <navLabel>
                             <text>Parsing natural language</text>
                         </navLabel>
-                        <content src="book-Z-H-28.html#heading_id_7"/>
+                        <content src="book-Z-H-28.html#__sec_Temp_618" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-184" playOrder="184">
                     <navLabel>
                         <text>4.3.3 Implementing the Amb Evaluator</text>
                     </navLabel>
-                    <content src="book-Z-H-28.html#heading_id_8"/>
+                    <content src="book-Z-H-28.html#__sec_4.3.3" />
                     <navPoint id="navPoint-185" playOrder="185">
                         <navLabel>
                             <text>Execution procedures and continuations</text>
                         </navLabel>
-                        <content src="book-Z-H-28.html#heading_id_9"/>
+                        <content src="book-Z-H-28.html#__sec_Temp_630" />
                     </navPoint>
                     <navPoint id="navPoint-186" playOrder="186">
                         <navLabel>
                             <text>Structure of the evaluator</text>
                         </navLabel>
-                        <content src="book-Z-H-28.html#heading_id_10"/>
+                        <content src="book-Z-H-28.html#__sec_Temp_631" />
                     </navPoint>
                     <navPoint id="navPoint-187" playOrder="187">
                         <navLabel>
                             <text>Simple expressions</text>
                         </navLabel>
-                        <content src="book-Z-H-28.html#heading_id_11"/>
+                        <content src="book-Z-H-28.html#__sec_Temp_633" />
                     </navPoint>
                     <navPoint id="navPoint-188" playOrder="188">
                         <navLabel>
                             <text>Conditionals and sequences</text>
                         </navLabel>
-                        <content src="book-Z-H-28.html#heading_id_12"/>
+                        <content src="book-Z-H-28.html#__sec_Temp_634" />
                     </navPoint>
                     <navPoint id="navPoint-189" playOrder="189">
                         <navLabel>
                             <text>Definitions and assignments</text>
                         </navLabel>
-                        <content src="book-Z-H-28.html#heading_id_13"/>
+                        <content src="book-Z-H-28.html#__sec_Temp_635" />
                     </navPoint>
                     <navPoint id="navPoint-190" playOrder="190">
                         <navLabel>
                             <text>Procedure applications</text>
                         </navLabel>
-                        <content src="book-Z-H-28.html#heading_id_14"/>
+                        <content src="book-Z-H-28.html#__sec_Temp_637" />
                     </navPoint>
                     <navPoint id="navPoint-191" playOrder="191">
                         <navLabel>
                             <text>Evaluating amb expressions</text>
                         </navLabel>
-                        <content src="book-Z-H-28.html#heading_id_15"/>
+                        <content src="book-Z-H-28.html#__sec_Temp_638" />
                     </navPoint>
                     <navPoint id="navPoint-192" playOrder="192">
                         <navLabel>
                             <text>Driver loop</text>
                         </navLabel>
-                        <content src="book-Z-H-28.html#heading_id_16"/>
+                        <content src="book-Z-H-28.html#__sec_Temp_639" />
                     </navPoint>
                 </navPoint>
             </navPoint>
@@ -1168,185 +1165,185 @@
                 <navLabel>
                     <text>4.4 Logic Programming</text>
                 </navLabel>
-                <content src="book-Z-H-29.html"/>
+                <content src="book-Z-H-29.html" />
                 <navPoint id="navPoint-194" playOrder="194">
                     <navLabel>
                         <text>4.4.1 Deductive Information Retrieval</text>
                     </navLabel>
-                    <content src="book-Z-H-29.html#heading_id_3"/>
+                    <content src="book-Z-H-29.html#__sec_4.4.1" />
                     <navPoint id="navPoint-195" playOrder="195">
                         <navLabel>
                             <text>A sample data base</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_4"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_649" />
                     </navPoint>
                     <navPoint id="navPoint-196" playOrder="196">
                         <navLabel>
                             <text>Simple queries</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_5"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_650" />
                     </navPoint>
                     <navPoint id="navPoint-197" playOrder="197">
                         <navLabel>
                             <text>Compound queries</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_6"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_653" />
                     </navPoint>
                     <navPoint id="navPoint-198" playOrder="198">
                         <navLabel>
                             <text>Rules</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_7"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_657" />
                     </navPoint>
                     <navPoint id="navPoint-199" playOrder="199">
                         <navLabel>
                             <text>Logic as programs</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_8"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_664" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-200" playOrder="200">
                     <navLabel>
                         <text>4.4.2 How the Query System Works</text>
                     </navLabel>
-                    <content src="book-Z-H-29.html#heading_id_9"/>
+                    <content src="book-Z-H-29.html#__sec_4.4.2" />
                     <navPoint id="navPoint-201" playOrder="201">
                         <navLabel>
                             <text>Pattern matching</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_10"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_668" />
                     </navPoint>
                     <navPoint id="navPoint-202" playOrder="202">
                         <navLabel>
                             <text>Streams of frames</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_11"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_669" />
                     </navPoint>
                     <navPoint id="navPoint-203" playOrder="203">
                         <navLabel>
                             <text>Compound queries</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_12"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_671" />
                     </navPoint>
                     <navPoint id="navPoint-204" playOrder="204">
                         <navLabel>
                             <text>Unification</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_13"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_675" />
                     </navPoint>
                     <navPoint id="navPoint-205" playOrder="205">
                         <navLabel>
                             <text>Applying rules</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_14"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_678" />
                     </navPoint>
                     <navPoint id="navPoint-206" playOrder="206">
                         <navLabel>
                             <text>Simple queries</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_15"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_679" />
                     </navPoint>
                     <navPoint id="navPoint-207" playOrder="207">
                         <navLabel>
                             <text>The query evaluator and the driver loop</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_16"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_681" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-208" playOrder="208">
                     <navLabel>
                         <text>4.4.3 Is Logic Programming Mathematical Logic?</text>
                     </navLabel>
-                    <content src="book-Z-H-29.html#heading_id_17"/>
+                    <content src="book-Z-H-29.html#__sec_4.4.3" />
                     <navPoint id="navPoint-209" playOrder="209">
                         <navLabel>
                             <text>Infinite loops</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_18"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_685" />
                     </navPoint>
                     <navPoint id="navPoint-210" playOrder="210">
                         <navLabel>
                             <text>Problems with not</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_19"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_687" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-211" playOrder="211">
                     <navLabel>
                         <text>4.4.4 Implementing the Query System</text>
                     </navLabel>
-                    <content src="book-Z-H-29.html#heading_id_20"/>
+                    <content src="book-Z-H-29.html#__sec_4.4.4" />
                     <navPoint id="navPoint-212" playOrder="212">
                         <navLabel>
                             <text>4.4.4.1 The Driver Loop and Instantiation</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_21"/>
+                        <content src="book-Z-H-29.html#__sec_4.4.4.1" />
                     </navPoint>
                     <navPoint id="navPoint-213" playOrder="213">
                         <navLabel>
                             <text>4.4.4.2 The Evaluator</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_22"/>
+                        <content src="book-Z-H-29.html#__sec_4.4.4.2" />
                     </navPoint>
                     <navPoint id="navPoint-214" playOrder="214">
                         <navLabel>
                             <text>Simple queries</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_23"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_696" />
                     </navPoint>
                     <navPoint id="navPoint-215" playOrder="215">
                         <navLabel>
                             <text>Compound queries</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_24"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_697" />
                     </navPoint>
                     <navPoint id="navPoint-216" playOrder="216">
                         <navLabel>
                             <text>Filters</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_25"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_698" />
                     </navPoint>
                     <navPoint id="navPoint-217" playOrder="217">
                         <navLabel>
                             <text>4.4.4.3 Finding Assertions by Pattern Matching</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_26"/>
+                        <content src="book-Z-H-29.html#__sec_4.4.4.3" />
                     </navPoint>
                     <navPoint id="navPoint-218" playOrder="218">
                         <navLabel>
                             <text>Patterns with dotted tails</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_27"/>
+                        <content src="book-Z-H-29.html#__sec_Temp_699" />
                     </navPoint>
                     <navPoint id="navPoint-219" playOrder="219">
                         <navLabel>
                             <text>4.4.4.4 Rules and Unification</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_28"/>
+                        <content src="book-Z-H-29.html#__sec_4.4.4.4" />
                     </navPoint>
                     <navPoint id="navPoint-220" playOrder="220">
                         <navLabel>
                             <text>4.4.4.5 Maintaining the Data Base</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_29"/>
+                        <content src="book-Z-H-29.html#__sec_4.4.4.5" />
                     </navPoint>
                     <navPoint id="navPoint-221" playOrder="221">
                         <navLabel>
                             <text>4.4.4.6 Stream Operations</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_30"/>
+                        <content src="book-Z-H-29.html#__sec_4.4.4.6" />
                     </navPoint>
                     <navPoint id="navPoint-222" playOrder="222">
                         <navLabel>
                             <text>4.4.4.7 Query Syntax Procedures</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_31"/>
+                        <content src="book-Z-H-29.html#__sec_4.4.4.7" />
                     </navPoint>
                     <navPoint id="navPoint-223" playOrder="223">
                         <navLabel>
                             <text>4.4.4.8 Frames and Bindings</text>
                         </navLabel>
-                        <content src="book-Z-H-29.html#heading_id_32"/>
+                        <content src="book-Z-H-29.html#__sec_4.4.4.8" />
                     </navPoint>
                 </navPoint>
             </navPoint>
@@ -1355,166 +1352,166 @@
             <navLabel>
                 <text>Chapter 5</text>
             </navLabel>
-            <content src="book-Z-H-30.html"/>
+            <content src="book-Z-H-30.html" />
             <navPoint id="navPoint-225" playOrder="225">
                 <navLabel>
                     <text>5.1 Designing Register Machines</text>
                 </navLabel>
-                <content src="book-Z-H-31.html"/>
+                <content src="book-Z-H-31.html" />
                 <navPoint id="navPoint-226" playOrder="226">
                     <navLabel>
                         <text>5.1.1 A Language for Describing Register Machines</text>
                     </navLabel>
-                    <content src="book-Z-H-31.html#heading_id_3"/>
+                    <content src="book-Z-H-31.html#__sec_5.1.1" />
                     <navPoint id="navPoint-227" playOrder="227">
                         <navLabel>
                             <text>Actions</text>
                         </navLabel>
-                        <content src="book-Z-H-31.html#heading_id_4"/>
+                        <content src="book-Z-H-31.html#__sec_Temp_714" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-228" playOrder="228">
                     <navLabel>
                         <text>5.1.2 Abstraction in Machine Design</text>
                     </navLabel>
-                    <content src="book-Z-H-31.html#heading_id_5"/>
+                    <content src="book-Z-H-31.html#__sec_5.1.2" />
                 </navPoint>
                 <navPoint id="navPoint-229" playOrder="229">
                     <navLabel>
                         <text>5.1.3 Subroutines</text>
                     </navLabel>
-                    <content src="book-Z-H-31.html#heading_id_6"/>
+                    <content src="book-Z-H-31.html#__sec_5.1.3" />
                 </navPoint>
                 <navPoint id="navPoint-230" playOrder="230">
                     <navLabel>
                         <text>5.1.4 Using a Stack to Implement Recursion</text>
                     </navLabel>
-                    <content src="book-Z-H-31.html#heading_id_7"/>
+                    <content src="book-Z-H-31.html#__sec_5.1.4" />
                     <navPoint id="navPoint-231" playOrder="231">
                         <navLabel>
                             <text>A double recursion</text>
                         </navLabel>
-                        <content src="book-Z-H-31.html#heading_id_8"/>
+                        <content src="book-Z-H-31.html#__sec_Temp_719" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-232" playOrder="232">
                     <navLabel>
                         <text>5.1.5 Instruction Summary</text>
                     </navLabel>
-                    <content src="book-Z-H-31.html#heading_id_9"/>
+                    <content src="book-Z-H-31.html#__sec_5.1.5" />
                 </navPoint>
             </navPoint>
             <navPoint id="navPoint-233" playOrder="233">
                 <navLabel>
                     <text>5.2 A Register-Machine Simulator</text>
                 </navLabel>
-                <content src="book-Z-H-32.html"/>
+                <content src="book-Z-H-32.html" />
                 <navPoint id="navPoint-234" playOrder="234">
                     <navLabel>
                         <text>5.2.1 The Machine Model</text>
                     </navLabel>
-                    <content src="book-Z-H-32.html#heading_id_3"/>
+                    <content src="book-Z-H-32.html#__sec_5.2.1" />
                     <navPoint id="navPoint-235" playOrder="235">
                         <navLabel>
                             <text>Registers</text>
                         </navLabel>
-                        <content src="book-Z-H-32.html#heading_id_4"/>
+                        <content src="book-Z-H-32.html#__sec_Temp_724" />
                     </navPoint>
                     <navPoint id="navPoint-236" playOrder="236">
                         <navLabel>
                             <text>The stack</text>
                         </navLabel>
-                        <content src="book-Z-H-32.html#heading_id_5"/>
+                        <content src="book-Z-H-32.html#__sec_Temp_725" />
                     </navPoint>
                     <navPoint id="navPoint-237" playOrder="237">
                         <navLabel>
                             <text>The basic machine</text>
                         </navLabel>
-                        <content src="book-Z-H-32.html#heading_id_6"/>
+                        <content src="book-Z-H-32.html#__sec_Temp_726" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-238" playOrder="238">
                     <navLabel>
                         <text>5.2.2 The Assembler</text>
                     </navLabel>
-                    <content src="book-Z-H-32.html#heading_id_7"/>
+                    <content src="book-Z-H-32.html#__sec_5.2.2" />
                 </navPoint>
                 <navPoint id="navPoint-239" playOrder="239">
                     <navLabel>
                         <text>5.2.3 Generating Execution Procedures for Instructions</text>
                     </navLabel>
-                    <content src="book-Z-H-32.html#heading_id_8"/>
+                    <content src="book-Z-H-32.html#__sec_5.2.3" />
                     <navPoint id="navPoint-240" playOrder="240">
                         <navLabel>
                             <text>Assign instructions</text>
                         </navLabel>
-                        <content src="book-Z-H-32.html#heading_id_9"/>
+                        <content src="book-Z-H-32.html#__sec_Temp_729" />
                     </navPoint>
                     <navPoint id="navPoint-241" playOrder="241">
                         <navLabel>
                             <text>Test, branch, and goto instructions</text>
                         </navLabel>
-                        <content src="book-Z-H-32.html#heading_id_10"/>
+                        <content src="book-Z-H-32.html#__sec_Temp_730" />
                     </navPoint>
                     <navPoint id="navPoint-242" playOrder="242">
                         <navLabel>
                             <text>Other instructions</text>
                         </navLabel>
-                        <content src="book-Z-H-32.html#heading_id_11"/>
+                        <content src="book-Z-H-32.html#__sec_Temp_731" />
                     </navPoint>
                     <navPoint id="navPoint-243" playOrder="243">
                         <navLabel>
                             <text>Execution procedures for subexpressions</text>
                         </navLabel>
-                        <content src="book-Z-H-32.html#heading_id_12"/>
+                        <content src="book-Z-H-32.html#__sec_Temp_732" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-244" playOrder="244">
                     <navLabel>
                         <text>5.2.4 Monitoring Machine Performance</text>
                     </navLabel>
-                    <content src="book-Z-H-32.html#heading_id_13"/>
+                    <content src="book-Z-H-32.html#__sec_5.2.4" />
                 </navPoint>
             </navPoint>
             <navPoint id="navPoint-245" playOrder="245">
                 <navLabel>
                     <text>5.3 Storage Allocation and Garbage Collection</text>
                 </navLabel>
-                <content src="book-Z-H-33.html"/>
+                <content src="book-Z-H-33.html" />
                 <navPoint id="navPoint-246" playOrder="246">
                     <navLabel>
                         <text>5.3.1 Memory as Vectors</text>
                     </navLabel>
-                    <content src="book-Z-H-33.html#heading_id_3"/>
+                    <content src="book-Z-H-33.html#__sec_5.3.1" />
                     <navPoint id="navPoint-247" playOrder="247">
                         <navLabel>
                             <text>Representing Lisp data</text>
                         </navLabel>
-                        <content src="book-Z-H-33.html#heading_id_4"/>
+                        <content src="book-Z-H-33.html#__sec_Temp_746" />
                     </navPoint>
                     <navPoint id="navPoint-248" playOrder="248">
                         <navLabel>
                             <text>Implementing the primitive list operations</text>
                         </navLabel>
-                        <content src="book-Z-H-33.html#heading_id_5"/>
+                        <content src="book-Z-H-33.html#__sec_Temp_751" />
                     </navPoint>
                     <navPoint id="navPoint-249" playOrder="249">
                         <navLabel>
                             <text>Implementing stacks</text>
                         </navLabel>
-                        <content src="book-Z-H-33.html#heading_id_6"/>
+                        <content src="book-Z-H-33.html#__sec_Temp_754" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-250" playOrder="250">
                     <navLabel>
                         <text>5.3.2 Maintaining the Illusion of Infinite Memory</text>
                     </navLabel>
-                    <content src="book-Z-H-33.html#heading_id_7"/>
+                    <content src="book-Z-H-33.html#__sec_5.3.2" />
                     <navPoint id="navPoint-251" playOrder="251">
                         <navLabel>
                             <text>Implementation of a stop-and-copy garbage collector</text>
                         </navLabel>
-                        <content src="book-Z-H-33.html#heading_id_8"/>
+                        <content src="book-Z-H-33.html#__sec_Temp_761" />
                     </navPoint>
                 </navPoint>
             </navPoint>
@@ -1522,71 +1519,71 @@
                 <navLabel>
                     <text>5.4 The Explicit-Control Evaluator</text>
                 </navLabel>
-                <content src="book-Z-H-34.html"/>
+                <content src="book-Z-H-34.html" />
                 <navPoint id="navPoint-253" playOrder="253">
                     <navLabel>
                         <text>Registers and operations</text>
                     </navLabel>
-                    <content src="book-Z-H-34.html#heading_id_3"/>
+                    <content src="book-Z-H-34.html#__sec_Temp_766" />
                 </navPoint>
                 <navPoint id="navPoint-254" playOrder="254">
                     <navLabel>
                         <text>5.4.1 The Core of the Explicit-Control Evaluator</text>
                     </navLabel>
-                    <content src="book-Z-H-34.html#heading_id_4"/>
+                    <content src="book-Z-H-34.html#__sec_5.4.1" />
                     <navPoint id="navPoint-255" playOrder="255">
                         <navLabel>
                             <text>Evaluating simple expressions</text>
                         </navLabel>
-                        <content src="book-Z-H-34.html#heading_id_5"/>
+                        <content src="book-Z-H-34.html#__sec_Temp_768" />
                     </navPoint>
                     <navPoint id="navPoint-256" playOrder="256">
                         <navLabel>
                             <text>Evaluating procedure applications</text>
                         </navLabel>
-                        <content src="book-Z-H-34.html#heading_id_6"/>
+                        <content src="book-Z-H-34.html#__sec_Temp_769" />
                     </navPoint>
                     <navPoint id="navPoint-257" playOrder="257">
                         <navLabel>
                             <text>Procedure application</text>
                         </navLabel>
-                        <content src="book-Z-H-34.html#heading_id_7"/>
+                        <content src="book-Z-H-34.html#__sec_Temp_774" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-258" playOrder="258">
                     <navLabel>
                         <text>5.4.2 Sequence Evaluation and Tail Recursion</text>
                     </navLabel>
-                    <content src="book-Z-H-34.html#heading_id_8"/>
+                    <content src="book-Z-H-34.html#__sec_5.4.2" />
                     <navPoint id="navPoint-259" playOrder="259">
                         <navLabel>
                             <text>Tail recursion</text>
                         </navLabel>
-                        <content src="book-Z-H-34.html#heading_id_9"/>
+                        <content src="book-Z-H-34.html#__sec_Temp_775" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-260" playOrder="260">
                     <navLabel>
                         <text>5.4.3 Conditionals, Assignments, and Definitions</text>
                     </navLabel>
-                    <content src="book-Z-H-34.html#heading_id_10"/>
+                    <content src="book-Z-H-34.html#__sec_5.4.3" />
                     <navPoint id="navPoint-261" playOrder="261">
                         <navLabel>
                             <text>Assignments and definitions</text>
                         </navLabel>
-                        <content src="book-Z-H-34.html#heading_id_11"/>
+                        <content src="book-Z-H-34.html#__sec_Temp_779" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-262" playOrder="262">
                     <navLabel>
                         <text>5.4.4 Running the Evaluator</text>
                     </navLabel>
-                    <content src="book-Z-H-34.html#heading_id_12"/>
+                    <content src="book-Z-H-34.html#__sec_5.4.4" />
                     <navPoint id="navPoint-263" playOrder="263">
                         <navLabel>
                             <text>Monitoring the performance of the evaluator</text>
                         </navLabel>
-                        <content src="book-Z-H-34.html#heading_id_13"/>
+                        <content src="book-Z-H-34.html#__sec_Temp_787" />
                     </navPoint>
                 </navPoint>
             </navPoint>
@@ -1594,113 +1591,113 @@
                 <navLabel>
                     <text>5.5 Compilation</text>
                 </navLabel>
-                <content src="book-Z-H-35.html"/>
+                <content src="book-Z-H-35.html" />
                 <navPoint id="navPoint-265" playOrder="265">
                     <navLabel>
                         <text>An overview of the compiler</text>
                     </navLabel>
-                    <content src="book-Z-H-35.html#heading_id_3"/>
+                    <content src="book-Z-H-35.html#__sec_Temp_796" />
                 </navPoint>
                 <navPoint id="navPoint-266" playOrder="266">
                     <navLabel>
                         <text>5.5.1 Structure of the Compiler</text>
                     </navLabel>
-                    <content src="book-Z-H-35.html#heading_id_4"/>
+                    <content src="book-Z-H-35.html#__sec_5.5.1" />
                     <navPoint id="navPoint-267" playOrder="267">
                         <navLabel>
                             <text>Targets and linkages</text>
                         </navLabel>
-                        <content src="book-Z-H-35.html#heading_id_5"/>
+                        <content src="book-Z-H-35.html#__sec_Temp_798" />
                     </navPoint>
                     <navPoint id="navPoint-268" playOrder="268">
                         <navLabel>
                             <text>Instruction sequences and stack usage</text>
                         </navLabel>
-                        <content src="book-Z-H-35.html#heading_id_6"/>
+                        <content src="book-Z-H-35.html#__sec_Temp_799" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-269" playOrder="269">
                     <navLabel>
                         <text>5.5.2 Compiling Expressions</text>
                     </navLabel>
-                    <content src="book-Z-H-35.html#heading_id_7"/>
+                    <content src="book-Z-H-35.html#__sec_5.5.2" />
                     <navPoint id="navPoint-270" playOrder="270">
                         <navLabel>
                             <text>Compiling linkage code</text>
                         </navLabel>
-                        <content src="book-Z-H-35.html#heading_id_8"/>
+                        <content src="book-Z-H-35.html#__sec_Temp_802" />
                     </navPoint>
                     <navPoint id="navPoint-271" playOrder="271">
                         <navLabel>
                             <text>Compiling simple expressions</text>
                         </navLabel>
-                        <content src="book-Z-H-35.html#heading_id_9"/>
+                        <content src="book-Z-H-35.html#__sec_Temp_804" />
                     </navPoint>
                     <navPoint id="navPoint-272" playOrder="272">
                         <navLabel>
                             <text>Compiling conditional expressions</text>
                         </navLabel>
-                        <content src="book-Z-H-35.html#heading_id_10"/>
+                        <content src="book-Z-H-35.html#__sec_Temp_805" />
                     </navPoint>
                     <navPoint id="navPoint-273" playOrder="273">
                         <navLabel>
                             <text>Compiling sequences</text>
                         </navLabel>
-                        <content src="book-Z-H-35.html#heading_id_11"/>
+                        <content src="book-Z-H-35.html#__sec_Temp_807" />
                     </navPoint>
                     <navPoint id="navPoint-274" playOrder="274">
                         <navLabel>
                             <text>Compiling lambda expressions</text>
                         </navLabel>
-                        <content src="book-Z-H-35.html#heading_id_12"/>
+                        <content src="book-Z-H-35.html#__sec_Temp_808" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-275" playOrder="275">
                     <navLabel>
                         <text>5.5.3 Compiling Combinations</text>
                     </navLabel>
-                    <content src="book-Z-H-35.html#heading_id_13"/>
+                    <content src="book-Z-H-35.html#__sec_5.5.3" />
                     <navPoint id="navPoint-276" playOrder="276">
                         <navLabel>
                             <text>Applying procedures</text>
                         </navLabel>
-                        <content src="book-Z-H-35.html#heading_id_14"/>
+                        <content src="book-Z-H-35.html#__sec_Temp_810" />
                     </navPoint>
                     <navPoint id="navPoint-277" playOrder="277">
                         <navLabel>
                             <text>Applying compiled procedures</text>
                         </navLabel>
-                        <content src="book-Z-H-35.html#heading_id_15"/>
+                        <content src="book-Z-H-35.html#__sec_Temp_811" />
                     </navPoint>
                 </navPoint>
                 <navPoint id="navPoint-278" playOrder="278">
                     <navLabel>
                         <text>5.5.4 Combining Instruction Sequences</text>
                     </navLabel>
-                    <content src="book-Z-H-35.html#heading_id_16"/>
+                    <content src="book-Z-H-35.html#__sec_5.5.4" />
                 </navPoint>
                 <navPoint id="navPoint-279" playOrder="279">
                     <navLabel>
                         <text>5.5.5 An Example of Compiled Code</text>
                     </navLabel>
-                    <content src="book-Z-H-35.html#heading_id_17"/>
+                    <content src="book-Z-H-35.html#__sec_5.5.5" />
                 </navPoint>
                 <navPoint id="navPoint-280" playOrder="280">
                     <navLabel>
                         <text>5.5.6 Lexical Addressing</text>
                     </navLabel>
-                    <content src="book-Z-H-35.html#heading_id_18"/>
+                    <content src="book-Z-H-35.html#__sec_5.5.6" />
                 </navPoint>
                 <navPoint id="navPoint-281" playOrder="281">
                     <navLabel>
                         <text>5.5.7 Interfacing Compiled Code to the Evaluator</text>
                     </navLabel>
-                    <content src="book-Z-H-35.html#heading_id_19"/>
+                    <content src="book-Z-H-35.html#__sec_5.5.7" />
                     <navPoint id="navPoint-282" playOrder="282">
                         <navLabel>
                             <text>Interpretation and compilation</text>
                         </navLabel>
-                        <content src="book-Z-H-35.html#heading_id_20"/>
+                        <content src="book-Z-H-35.html#__sec_Temp_836" />
                     </navPoint>
                 </navPoint>
             </navPoint>
@@ -1709,19 +1706,19 @@
             <navLabel>
                 <text>References</text>
             </navLabel>
-            <content src="book-Z-H-36.html"/>
+            <content src="book-Z-H-36.html" />
         </navPoint>
         <navPoint id="navPoint-284" playOrder="284">
             <navLabel>
                 <text>List of Exercises</text>
             </navLabel>
-            <content src="book-Z-H-37.html"/>
+            <content src="book-Z-H-37.html" />
         </navPoint>
         <navPoint id="navPoint-285" playOrder="285">
             <navLabel>
                 <text>Index</text>
             </navLabel>
-            <content src="book-Z-H-38.html"/>
+            <content src="book-Z-H-38.html" />
         </navPoint>
     </navMap>
 </ncx>