file no7
file no7
The purpose of a <#64562#><#23110#>local<#23110#>-expression<#64562#> is to define a variable, a
function, or a structure for the evaluation of the <#23111#>body<#23111#>
expression. Outside of the <#64563#><#23112#>local<#23112#>-expression<#64563#> the definitions have
no effect. Consider the following expression:
<#23117#>(local<#23117#> <#23118#>((define<#23118#> <#23119#>(f<#23119#> <#23120#>x)<#23120#> <#23121#>exp-1)))<#23121#> <#23122#>exp)<#23122#>
It defines the function <#64564#><#23126#>f<#23126#><#64564#> during the evaluation of <#64565#><#23127#>exp<#23127#><#64565#>.
The result of <#64566#><#23128#>exp<#23128#><#64566#> is the result of the entire
<#64567#><#23129#>local<#23129#>-expression<#64567#>. Similarly,
<#23134#>(local<#23134#> <#23135#>((define<#23135#> <#23136#>PI<#23136#> <#23137#>3)))<#23137#> <#23138#>exp)<#23138#>
temporarily lets the variable <#64568#><#23142#>PI<#23142#><#64568#> stand for <#64569#><#23143#>3<#23143#><#64569#> during the
evaluation of <#64570#><#23144#>exp<#23144#><#64570#>.
We can describe the evaluation of <#64571#><#23145#>local<#23145#>-expression<#64571#>s with a single rule, but the
rule is extremely complex. More specifically, the rule requires two steps
in a hand-evaluation. First, we must systematically replace all locally
defined variables, functions, and structures so that the names do not
overlap with those used in the <#23146#>Definitions<#23146#> window. Second, we
move the entire sequence of definitions to the top-level and proceed as if
we had just created a new function.
Here is the evaluation rule, stated symbolically:
<#23151#>def-1<#23151#> <#23152#>...<#23152#> <#23153#>def-n<#23153#>
<#23154#>E[<#23154#><#23155#>(local<#23155#> <#23156#>((define<#23156#> <#23157#>(f-1<#23157#> <#23158#>x)<#23158#> <#23159#>exp-1)<#23159#> <#23160#>...<#23160#> <#23161#>(define<#23161#> <#23162#>(f-2<#23162#> <#23163#>x)<#23163#> <#23164#>exp-n))<#23164#> <#23165#>exp)]<#23165#>
<#23166#>=<#23166#>
<#23167#>def-1<#23167#> <#23168#>...<#23168#> <#23169#>def-n<#23169#> <#23170#>(define<#23170#> <#23171#>(f-1<#23171#><#23172#>'<#23172#> <#23173#>x)<#23173#> <#23174#>exp-1<#23174#><#23175#>'<#23175#><#23176#>)<#23176#> <#23177#>...<#23177#> <#23178#>(define<#23178#> <#23179#>(f-n<#23179#><#23180#>'<#23180#> <#23181#>x)<#23181#> <#23182#>exp-n<#23182#><#23183#>'<#23183#><#23184#>)<#23184#>
<#23185#>E[<#23185#><#23186#>exp<#23186#><#23187#>'<#23187#><#23188#>]<#23188#>
For simplicity, the <#64572#><#23192#>local<#23192#>-expression<#64572#> in this rule defines only
one-argument functions, but it is straightforward to generalize from here.
As usual, the sequence <#64573#><#23193#>def-1<#23193#>\ <#23194#>...<#23194#>\ <#23195#>def-n<#23195#><#64573#> represents top-level
definitions.
The unusual part of the rule is the notation <#64574#><#23196#>E[<#23196#><#23197#>exp]<#23197#><#64574#>. It represents
an expression <#64575#><#23198#>exp<#23198#><#64575#> and its context <#64576#><#23199#>E<#23199#><#64576#>. More specifically,
<#64577#><#23200#>exp<#23200#><#64577#> is the next expression that must and can be
evaluated; <#64578#><#23202#>E<#23202#><#64578#> is called its
<#64579#><#23203#>EVALUATION CONTEXT<#23203#><#64579#>.
For example, the expression
<#23208#>(+<#23208#> <#23209#>(local<#23209#> <#23210#>((define<#23210#> <#23211#>(f<#23211#> <#23212#>x)<#23212#> <#23213#>10))<#23213#> <#23214#>(f<#23214#> <#23215#>13))<#23215#> <#23216#>5)<#23216#>
is an addition. Before we can compute its result, we must evaluate the two
subexpressions to numbers. Since the first subexpression is not a number,
we focus on it:
<#23224#>(local<#23224#> <#23225#>((define<#23225#> <#23226#>(f<#23226#> <#23227#>x)<#23227#> <#23228#>10))<#23228#> <#23229#>(f<#23229#> <#23230#>13))<#23230#>
This <#64580#><#23234#>local<#23234#>-expression<#64580#> must and can be evaluated, so
<#23239#>exp<#23239#> <#23240#>=<#23240#> <#23241#>(local<#23241#> <#23242#>((define<#23242#> <#23243#>(f<#23243#> <#23244#>x)<#23244#> <#23245#>10))<#23245#> <#23246#>(f<#23246#> <#23247#>13))<#23247#>
<#23248#>E<#23248#> <#23249#>=<#23249#> <#23250#>(+<#23250#> <#23251#>...<#23251#> <#23252#>5)<#23252#>
for the above expression.
On the right-hand side of the rule for <#64581#><#23256#>local<#23256#><#64581#>, we can see several
primed names and expressions. The primed names <#64582#><#23257#>f-1<#23257#><#23258#>'<#23258#><#64582#>, ...,
<#64583#><#23259#>f-n<#23259#><#23260#>'<#23260#><#64583#> are new function names, distinct from all other names in
top-level definitions; the primes on the expressions <#64584#><#23261#>exp-1<#23261#><#23262#>'<#23262#><#64584#>,
..., <#64585#><#23263#>exp-n<#23263#><#23264#>'<#23264#><#64585#> indicate that these expressions are structurally
identical to <#64586#><#23265#>exp-1<#23265#><#64586#>, ..., <#64587#><#23266#>exp-n<#23266#><#64587#> but contain
<#64588#><#23267#>f-1<#23267#><#23268#>'<#23268#><#64588#> instead of <#64589#><#23269#>f-11<#23269#><#64589#>, and so on.
The evaluation rule for <#64590#><#23270#>local<#23270#>-expression<#64590#>s is the most complex rule
that we have encountered so far, and indeed, it is the most complex rule
that we will ever encounter. Each of the two steps is important and serves
a distinct purpose. Their purpose is best illustrated by a series of simple
examples.
The first part of the rule eliminates name clashes between <#23271#>names<#23271#>
that are already defined in the top-level environment and those that will
be inserted there. Consider the following example:
<#23276#>(define<#23276#> <#23277#>y<#23277#> <#23278#>10)<#23278#>
<#23279#>(+<#23279#> <#23280#>y<#23280#>
<#23281#>(l<#23281#><#23282#>ocal<#23282#> <#23283#>(<#23283#><#23284#>(define<#23284#> <#23285#>y<#23285#> <#23286#>10)<#23286#>
<#23287#>(define<#23287#> <#23288#>z<#23288#> <#23289#>(+<#23289#> <#23290#>y<#23290#> <#23291#>y)))<#23291#>
<#23292#>z))<#23292#>
The expression introduces a local definition for <#64591#><#23296#>y<#23296#><#64591#>, adds
<#64592#><#23297#>y<#23297#><#64592#> to itself to get <#64593#><#23298#>z<#23298#><#64593#> and returns the value of
<#64594#><#23299#>z<#23299#><#64594#>.
The informal description of <#64595#><#23300#>local<#23300#><#64595#> says that the result should be
<#64596#><#23301#>30<#23301#><#64596#>. Let's verify this with our rule. If we simply added the
definitions in <#64597#><#23302#>local<#23302#><#64597#> to the top-level, the two definitions for
<#64598#><#23303#>y<#23303#><#64598#> would clash. The renaming step prevents this clash and clarifies
which of <#64599#><#23304#>y<#23304#><#64599#>'s belong together:
<#23309#>=<#23309#> <#23310#>(define<#23310#> <#23311#>y<#23311#> <#23312#>10)<#23312#>
<#23313#>(+<#23313#> <#23314#>y<#23314#> <#23315#>(local<#23315#> <#23316#>((define<#23316#> <#23317#>y1<#23317#> <#23318#>10)<#23318#> <#23319#>(define<#23319#> <#23320#>z1<#23320#> <#23321#>(+<#23321#> <#23322#>y1<#23322#> <#23323#>y1)))<#23323#> <#23324#>z1))<#23324#>
<#23325#>=<#23325#> <#23326#>(define<#23326#> <#23327#>y<#23327#> <#23328#>10)<#23328#>
<#23329#>(define<#23329#> <#23330#>y1<#23330#> <#23331#>10)<#23331#>
<#23332#>(define<#23332#> <#23333#>z1<#23333#> <#23334#>(+<#23334#> <#23335#>y1<#23335#> <#23336#>y1))<#23336#>
<#23337#>(+<#23337#> <#23338#>y<#23338#> <#23339#>z1)<#23339#>
<#23340#>=<#23340#> <#23341#>(define<#23341#> <#23342#>y<#23342#> <#23343#>10)<#23343#>
<#23344#>(define<#23344#> <#23345#>y1<#23345#> <#23346#>10)<#23346#>
<#23347#>(define<#23347#> <#23348#>z1<#23348#> <#23349#>20)<#23349#>
<#23350#>(+<#23350#> <#23351#>10<#23351#> <#23352#>z1)<#23352#>
<#23353#>=<#23353#> <#23354#>(define<#23354#> <#23355#>y<#23355#> <#23356#>10)<#23356#>
<#23357#>(define<#23357#> <#23358#>y1<#23358#> <#23359#>10)<#23359#>
<#23360#>(define<#23360#> <#23361#>z1<#23361#> <#23362#>20)<#23362#>
<#23363#>(+<#23363#> <#23364#>10<#23364#> <#23365#>z1)<#23365#>
<#23366#>=<#23366#> <#23367#>(define<#23367#> <#23368#>y<#23368#> <#23369#>10)<#23369#>
<#23370#>(define<#23370#> <#23371#>y1<#23371#> <#23372#>10)<#23372#>
<#23373#>(define<#23373#> <#23374#>z1<#23374#> <#23375#>20)<#23375#>
<#23376#>(+<#23376#> <#23377#>10<#23377#> <#23378#>20)<#23378#>
As expected, the result is <#64600#><#23382#>30<#23382#><#64600#>.
Since <#64601#><#23383#>local<#23383#>-expression<#64601#>s may occur inside of function bodies,
renaming is important if such functions are applied more than once. The
following second example illustrates this point:
<#23388#>(d<#23388#><#23389#>efine<#23389#> <#23390#>(D<#23390#> <#23391#>x<#23391#> <#23392#>y)<#23392#>
<#23393#>(l<#23393#><#23394#>ocal<#23394#> <#23395#>(<#23395#><#23396#>(define<#23396#> <#23397#>x2<#23397#> <#23398#>(*<#23398#> <#23399#>x<#23399#> <#23400#>x))<#23400#>
<#23401#>(define<#23401#> <#23402#>y2<#23402#> <#23403#>(*<#23403#> <#23404#>y<#23404#> <#23405#>y)))<#23405#>
<#23406#>(sqrt<#23406#> <#23407#>(+<#23407#> <#23408#>x2<#23408#> <#23409#>y2))))<#23409#>
<#23410#>(+<#23410#> <#23411#>(D<#23411#> <#23412#>0<#23412#> <#23413#>1)<#23413#> <#23414#>(D<#23414#> <#23415#>3<#23415#> <#23416#>4))<#23416#>
The function <#64602#><#23420#>D<#23420#><#64602#> computes the square root of the sum of the squares
of its arguments. Hence the result of <#64603#><#23421#>(+<#23421#>\ <#23422#>(D<#23422#>\ <#23423#>0<#23423#>\ <#23424#>1)<#23424#>\ <#23425#>(D<#23425#>\ <#23426#>3<#23426#>\ <#23427#>4))<#23427#><#64603#> should
be <#64604#><#23428#>6<#23428#><#64604#>.
As <#64605#><#23429#>D<#23429#><#64605#> computes its answer, it introduces two local variables:
<#64606#><#23430#>x2<#23430#><#64606#> and <#64607#><#23431#>y2<#23431#><#64607#>. Since <#64608#><#23432#>D<#23432#><#64608#> is applied twice, a modified
version of its body is evaluated twice and therefore its local definitions
must be added to the top-level twice. The renaming step ensures that no
matter how often we lift such definitions, they never interfere with each
other. Here is how this works:
<#23437#>=<#23437#> <#23438#>(d<#23438#><#23439#>efine<#23439#> <#23440#>(D<#23440#> <#23441#>x<#23441#> <#23442#>y)<#23442#>
<#23443#>(l<#23443#><#23444#>ocal<#23444#> <#23445#>(<#23445#><#23446#>(define<#23446#> <#23447#>x2<#23447#> <#23448#>(*<#23448#> <#23449#>x<#23449#> <#23450#>x))<#23450#>
<#23451#>(define<#23451#> <#23452#>y2<#23452#> <#23453#>(*<#23453#> <#23454#>y<#23454#> <#23455#>y)))<#23455#>
<#23456#>(sqrt<#23456#> <#23457#>(+<#23457#> <#23458#>x2<#23458#> <#23459#>y2))))<#23459#>
<#23460#>(+<#23460#> <#23461#>(l<#23461#><#23462#>ocal<#23462#> <#23463#>(<#23463#><#23464#>(define<#23464#> <#23465#>x2<#23465#> <#23466#>(*<#23466#> <#23467#>0<#23467#> <#23468#>0))<#23468#>
<#23469#>(define<#23469#> <#23470#>y2<#23470#> <#23471#>(*<#23471#> <#23472#>1<#23472#> <#23473#>1)))<#23473#>
<#23474#>(sqrt<#23474#> <#23475#>(+<#23475#> <#23476#>x2<#23476#> <#23477#>y2)))<#23477#>
<#23478#>(D<#23478#> <#23479#>3<#23479#> <#23480#>4))<#23480#>
The expression <#64609#><#23484#>(D<#23484#>\ <#23485#>0<#23485#>\ <#23486#>1)<#23486#><#64609#> is evaluated according to the regular rules.
Now we rename and lift the <#64610#><#23487#>local<#23487#><#64610#> definitions:
<#23492#>=<#23492#> <#23493#>(d<#23493#><#23494#>efine<#23494#> <#23495#>(D<#23495#> <#23496#>x<#23496#> <#23497#>y)<#23497#>
<#23498#>(l<#23498#><#23499#>ocal<#23499#> <#23500#>(<#23500#><#23501#>(define<#23501#> <#23502#>x2<#23502#> <#23503#>(*<#23503#> <#23504#>x<#23504#> <#23505#>x))<#23505#>
<#23506#>(define<#23506#> <#23507#>y2<#23507#> <#23508#>(*<#23508#> <#23509#>y<#23509#> <#23510#>y)))<#23510#>
<#23511#>(sqrt<#23511#> <#23512#>(+<#23512#> <#23513#>x2<#23513#> <#23514#>y2))))<#23514#>
<#23515#>(define<#23515#> <#23516#>x21<#23516#> <#23517#>(*<#23517#> <#23518#>0<#23518#> <#23519#>0))<#23519#>
<#23520#>(define<#23520#> <#23521#>y21<#23521#> <#23522#>(*<#23522#> <#23523#>1<#23523#> <#23524#>1))<#23524#>
<#23525#>(+<#23525#> <#23526#>(sqrt<#23526#> <#23527#>(+<#23527#> <#23528#>x21<#23528#> <#23529#>y21))<#23529#>
<#23530#>(D<#23530#> <#23531#>3<#23531#> <#23532#>4))<#23532#>
From here, the evaluation proceeds according to the standard rules
until we encounter a second nested
<#64611#><#23536#>local<#23536#>-expression<#64611#> in the expression that we are evaluating:
<#23541#>=<#23541#> <#23542#>(d<#23542#><#23543#>efine<#23543#> <#23544#>(D<#23544#> <#23545#>x<#23545#> <#23546#>y)<#23546#>
<#23547#>(l<#23547#><#23548#>ocal<#23548#> <#23549#>(<#23549#><#23550#>(define<#23550#> <#23551#>x2<#23551#> <#23552#>(*<#23552#> <#23553#>x<#23553#> <#23554#>x))<#23554#>
<#23555#>(define<#23555#> <#23556#>y2<#23556#> <#23557#>(*<#23557#> <#23558#>y<#23558#> <#23559#>y)))<#23559#>
<#23560#>(sqrt<#23560#> <#23561#>(+<#23561#> <#23562#>x2<#23562#> <#23563#>y2))))<#23563#>
<#23564#>(define<#23564#> <#23565#>x21<#23565#> <#23566#>0)<#23566#>
<#23567#>(define<#23567#> <#23568#>y21<#23568#> <#23569#>1)<#23569#>
<#23570#>(+<#23570#> <#23571#>1<#23571#> <#23572#>(l<#23572#><#23573#>ocal<#23573#> <#23574#>(<#23574#><#23575#>(define<#23575#> <#23576#>x2<#23576#> <#23577#>(*<#23577#> <#23578#>3<#23578#> <#23579#>3))<#23579#>
<#23580#>(define<#23580#> <#23581#>y2<#23581#> <#23582#>(*<#23582#> <#23583#>4<#23583#> <#23584#>4)))<#23584#>
<#23585#>(sqrt<#23585#> <#23586#>(+<#23586#> <#23587#>x2<#23587#> <#23588#>y2))))<#23588#>
<#23596#>=<#23596#> <#23597#>(d<#23597#><#23598#>efine<#23598#> <#23599#>(D<#23599#> <#23600#>x<#23600#> <#23601#>y)<#23601#>
<#23602#>(l<#23602#><#23603#>ocal<#23603#> <#23604#>(<#23604#><#23605#>(define<#23605#> <#23606#>x2<#23606#> <#23607#>(*<#23607#> <#23608#>x<#23608#> <#23609#>x))<#23609#>
<#23610#>(define<#23610#> <#23611#>y2<#23611#> <#23612#>(*<#23612#> <#23613#>y<#23613#> <#23614#>y)))<#23614#>
<#23615#>(sqrt<#23615#> <#23616#>(+<#23616#> <#23617#>x2<#23617#> <#23618#>y2))))<#23618#>
<#23619#>(define<#23619#> <#23620#>x21<#23620#> <#23621#>0)<#23621#>
<#23622#>(define<#23622#> <#23623#>y21<#23623#> <#23624#>1)<#23624#>
<#23625#>(define<#23625#> <#23626#>x22<#23626#> <#23627#>9)<#23627#>
<#23628#>(define<#23628#> <#23629#>y22<#23629#> <#23630#>16)<#23630#>
<#23631#>(+<#23631#> <#23632#>1<#23632#> <#23633#>(sqrt<#23633#> <#23634#>(+<#23634#> <#23635#>x22<#23635#> <#23636#>y22)))<#23636#>
By renaming <#64612#><#23640#>x2<#23640#><#64612#> and <#64613#><#23641#>y2<#23641#><#64613#> again, we avoided clashes. From
here, the evaluation of the expression is straightforward:
<#23646#>(+<#23646#> <#23647#>1<#23647#> <#23648#>(sqrt<#23648#> <#23649#>(+<#23649#> <#23650#>x22<#23650#> <#23651#>y22)))<#23651#>
<#23652#>=<#23652#> <#23653#>(+<#23653#> <#23654#>1<#23654#> <#23655#>(sqrt<#23655#> <#23656#>(+<#23656#> <#23657#>9<#23657#> <#23658#>y22)))<#23658#>
<#23659#>=<#23659#> <#23660#>(+<#23660#> <#23661#>1<#23661#> <#23662#>(sqrt<#23662#> <#23663#>(+<#23663#> <#23664#>9<#23664#> <#23665#>16)))<#23665#>
<#23666#>=<#23666#> <#23667#>(+<#23667#> <#23668#>1<#23668#> <#23669#>(sqrt<#23669#> <#23670#>25))<#23670#>
<#23671#>=<#23671#> <#23672#>(+<#23672#> <#23673#>1<#23673#> <#23674#>5)<#23674#>
<#23675#>=<#23675#> <#23676#>6<#23676#>
The result is 6, as expected.
<#23683#>Exercise 18.1.4<#23683#>
Since <#64614#><#23685#>local<#23685#><#64614#> definitions are added to the <#23686#>Definitions<#23686#>
window during an evaluation, we might wish to try to see their values by
just typing in the variables into the <#23687#>Interactions<#23687#> window. Is this
possible? Why or why not?~ 
Solution<#64615#><#64615#>
<#23693#>Exercise 18.1.5<#23693#>
Evaluate the following expressions by hand:
<#23699#>1.<#23699#> <#23700#>(local<#23700#> <#23701#>((define<#23701#> <#23702#>(x<#23702#> <#23703#>y)<#23703#> <#23704#>(*<#23704#> <#23705#>3<#23705#> <#23706#>y)))<#23706#>
<#23707#>(*<#23707#> <#23708#>(x<#23708#> <#23709#>2)<#23709#> <#23710#>5))<#23710#>
<#23718#>2.<#23718#> <#23719#>(local<#23719#> <#23720#>((define<#23720#> <#23721#>(f<#23721#> <#23722#>c)<#23722#> <#23723#>(+<#23723#> <#23724#>(*<#23724#> <#23725#>9/5<#23725#> <#23726#>c)<#23726#> <#23727#>32)))<#23727#>
<#23728#>(-<#23728#> <#23729#>(f<#23729#> <#23730#>0)<#23730#> <#23731#>(f<#23731#> <#23732#>10)))<#23732#>
<#23740#>3.<#23740#> <#23741#>(local<#23741#> <#23742#>((def<#23742#><#23743#>in<#23743#><#23744#>e<#23744#> <#23745#>(odd?<#23745#> <#23746#>n)<#23746#>
<#23747#>(c<#23747#><#23748#>ond<#23748#>
<#23749#>[<#23749#><#23750#>(zero?<#23750#> <#23751#>n)<#23751#> <#23752#>false<#23752#><#23753#>]<#23753#>
<#23754#>[<#23754#><#23755#>else<#23755#> <#23756#>(even?<#23756#> <#23757#>(sub1<#23757#> <#23758#>n))]<#23758#><#23759#>))<#23759#>
<#23760#>(d<#23760#><#23761#>efine<#23761#> <#23762#>(even?<#23762#> <#23763#>n)<#23763#>
<#23764#>(c<#23764#><#23765#>ond<#23765#>
<#23766#>[<#23766#><#23767#>(zero?<#23767#> <#23768#>n)<#23768#> <#23769#>true<#23769#><#23770#>]<#23770#>
<#23771#>[<#23771#><#23772#>else<#23772#> <#23773#>(odd?<#23773#> <#23774#>(sub1<#23774#> <#23775#>n))]<#23775#><#23776#>)))<#23776#>
<#23777#>(even?<#23777#> <#23778#>1))<#23778#>
<#23786#>4.<#23786#> <#23787#>(+<#23787#> <#23788#>(loc<#23788#><#23789#>al<#23789#> <#23790#>((def<#23790#><#23791#>ine<#23791#> <#23792#>(f<#23792#> <#23793#>x)<#23793#> <#23794#>(g<#23794#> <#23795#>(+<#23795#> <#23796#>x<#23796#> <#23797#>1)))<#23797#>
<#23798#>(define<#23798#> <#23799#>(g<#23799#> <#23800#>x<#23800#> <#23801#>y)<#23801#> <#23802#>(+<#23802#> <#23803#>x<#23803#> <#23804#>y)))<#23804#>
<#23805#>(f<#23805#> <#23806#>10))<#23806#>
<#23807#>555)<#23807#>
<#23815#>5.<#23815#> <#23816#>(def<#23816#><#23817#>in<#23817#><#23818#>e<#23818#> <#23819#>(h<#23819#> <#23820#>n)<#23820#>
<#23821#>(c<#23821#><#23822#>ond<#23822#>
<#23823#>[<#23823#><#23824#>(=<#23824#> <#23825#>n<#23825#> <#23826#>0)<#23826#> <#23827#>empty]<#23827#>
<#23828#>[<#23828#><#23829#>else<#23829#> <#23830#>(l<#23830#><#23831#>ocal<#23831#> <#23832#>((define<#23832#> <#23833#>r<#23833#> <#23834#>(*<#23834#> <#23835#>n<#23835#> <#23836#>n)))<#23836#>
<#23837#>(cons<#23837#> <#23838#>r<#23838#> <#23839#>(h<#23839#> <#23840#>(-<#23840#> <#23841#>n<#23841#> <#23842#>1))))]<#23842#><#23843#>))<#23843#>
<#23844#>(h<#23844#> <#23845#>2)<#23845#>
The evaluations should show all
<#64616#><#23849#>local<#23849#><#64616#>-reductions.~ Solution<#64617#><#64617#>