ۥ-/@ -Qw[Prrrrrrrrfsssss:Hs.svsps~v~v~v~v~v~v~v~vvvvvvvv4v9vrvv)2 Representations of Recursion
Roger K.W. Hui Kenneth E. Iverson
Iverson Software Inc.
33 Major Street, Toronto, Ontario
Canada M5S 2K9
1 INTRODUCTION
Recursive definitions are important tools in mathematics and in programming. They can be represented in a variety of ways, and in this paper we examine the relations and translations between them, using a range of examples for illustration. These examples begin with recursive definitions expressed in conventional mathematical notation, in SHARP APL, and in APL2; most are drawn from published sources.
The APL and J expressions may all be executed on appropriate systems, and may therefore be used to experiment. The J examples are collected in the Appendix.
The factorial function f is commonly defined by the statement that (f n) = n*(f n-1). Such a definition, in which the function being defined recurs in the phrase that defines it, is called a recursive definition.
A recursive definition must be supplemented by a non-recursive statement that specifies the value of the function for some specific argument; in the case of the factorial the supplementary statement is that (f 0) = 1.
A formal executable definition of the factorial in J may be expressed and used as follows:
f=. 1: ` (] * f @ (] - 1:)) @. *
f 5
120
f"0 i. 7
1 1 2 6 24 120 720
Definitions in J can be made to look more like the definitions in conventional notation by assigning the names n and k to the left and right argument functions [ and ] as follows:
n=. [ k=. ] f=. 1:`(n*f@(n-1:))@.*
The conjunctions tie (`) and agenda (@.) perform as follows: the former ties the two functions to form a gerund, from which the agenda chooses one for execution according to the value produced by its right argument * (the signum function, which yields 1 for any positive argument and 0 for the argument 0). The conjunction atop (@) applies its left argument (the function f) to the result of its right argument (the expression n-1:).
The name assigned to a recursively defined function must, of course, agree with the name used to refer to it in the defining phrase. However, the self-reference $: may be used in the defining phrase, in which case an arbitrary name may be used for the resulting function. Thus:
fact=. 1:`(n*$:@(n-1:))@.*
An executable definition has important advantages over an informal one: it is unambiguous, and can be used for significant experimentation. For example, the number of ways of choosing p things from q things may be expressed as follows:
p=. 3 [ q=. 5 (fact q)%((fact p)*(fact q-p))10
A function that is defined recursively is sometimes referred to as a recursive function, but it is better to refer to it as a recursively defined function, since it might well be possible to define an equivalent function non-recursively. For example:
fact=. */@(1:+i.) fact"0 i. 71 1 2 6 24 120 720
More interesting examples of this matter are provided in the discussion of Stirling numbers in Section D.
2 REPRESENTATIONS
Any representation of a recursion must provide for choosing between the main recursion and a non-recursive statement of the terminating condition. This may be achieved by either of:
Conventional branching and control Gerund and agenda
Double recursion, involving recursion on each argument, provides convenient definitions of dyadic functions. However, it is often possible to redefine the function more perspicuously as a single recursion that computes an entire row of the function table at a time. We therefore distinguish two further cases:
Double recursion Single recursion
Certain functions (such as the factorial) can be defined as a tail recursion (Abelson and Sussman [1985]) that can be converted to an equivalent iteration or application of the power conjunction. We therefore discuss two further cases:
Tail recursion Iteration (or Power)
3 BINOMIAL COEFFICIENTS
Binomial coefficients are computed by the dyad b, defined in conventional notation as follows:
0 b k SYMBOL 171 \f "Symbol" k=0n b k SYMBOL 171 \f "Symbol" ((n-1)b k-1) + (n-1) b k
This can be translated into J as a doubly recursive function:
b=.(k=0:)`((n $:&<: k)+(n-1:)$:k)@.(n>0:)
7 b 335
b"0/~i.81 0 0 0 0 0 0 01 1 0 0 0 0 0 01 2 1 0 0 0 0 01 3 3 1 0 0 0 01 4 6 4 1 0 0 01 5 10 10 5 1 0 01 6 15 20 15 6 1 01 7 21 35 35 21 7 1
This double recursion can be converted into a single recursion that computes the function table a row at a time; that is, b can be replaced by bv where bv n SYMBOL 171 \f "Symbol" n b"0 i.1+n; scalar operations in b are replaced by vector operations in bv. The function match (-:) may be used to compare results of the various representations of the binomial coefficients:
bv =. 1:`(bs@$:@<:) @. * bs =. (0:,]) + (],0:)
(bv"0 i.8) -: b"0/~i.81
zbv n;t (n)L z1 0 L:z(0,t)+(tbv n-1),0
An inductive argument shows that bv n is equivalent to n applications of the function bs. For example:
(bs 1);(bs bs 1);(bs bs bs 1);((bs^:3)1)Ŀ1 11 2 11 3 3 11 3 3 1
(bs^:(i.8) 1) -: b"0/~i.81 bp =. [ bs@]^:[ 1: (bp i.8) -: b"0/~i.81
The power conjunction ^: used above is defined as follows. The base case u^:n has a function left argument u and an integer right argument n:
u^:n y SYMBOL 171 \f "Symbol" u u^:(n-1) y if n>0 SYMBOL 171 \f "Symbol" y if n=0 SYMBOL 171 \f "Symbol" ui^:(-n) y if n<0
where ui is the inverse of u. Moreover, u^:_ produces the limit of the application of u (and u^:__ the limit of ui); and for an integer array a, u^:a y SYMBOL 171 \f "Symbol" (<"0 a) u@]^:[&> (0:) s2=.(k=0:)`((n $:&<: k) + k* SYMBOL 191 \f "Symbol" (n-1:)$:k) @. (n>0:) 7 s1 31624 7 s2 3301
s1"0/~i.81 0 0 0 0 0 0 00 1 0 0 0 0 0 00 1 1 0 0 0 0 00 2 3 1 0 0 0 00 6 11 6 1 0 0 00 24 50 35 10 1 0 00 120 274 225 85 15 1 00 720 1764 1624 735 175 21 1 s2"0/~i.81 0 0 0 0 0 0 00 1 0 0 0 0 0 00 1 1 0 0 0 0 00 1 3 1 0 0 0 00 1 7 6 1 0 0 00 1 15 25 10 1 0 00 1 31 90 65 15 1 00 1 63 301 350 140 21 1
The doubly recursive s1 can be converted into single recursion that computes the function table a row at a time; that is, s1 can be replaced by s1v where s1v n SYMBOL 171 \f "Symbol" n s1"0 i.1+n. Vector operations are used in s1v where scalar ones are used in s1. Likewise s2 and s2v.
s1v =. 1:`([ s1r $:@<:) @. * s1r =. (0:,]) + <:@[ * ],0:
s2v =. 1:`(i.@>: s2r $:@<:) @. * s2r =. (0:,]) + [ * ],0:
(s1v"0 i.8) -: s1"0/~i.81 (s2v"0 i.8) -: s2"0/~i.81
zs1v n;t (n)L z1 0 L:z(0,t)+(n-1)(ts1v n-1),0
zs2v n;t (n)L z1 0 L:z(0,t)+(SYMBOL 176 \f "ISIAPL"1+n)(ts2v n-1),0
Observing that the left argument to s1r is a function of the right argument (<:@#) and that the left argument to s2r is also a function of its right argument (i.@>:@#), the recursive part of the definitions can be rewritten as a composition of monads:
s1u =. 1:`(s1s@$:@<:) @. * s1s =. (0:,]) + <:@# * ],0:
s2u =. 1:`(s2s@$:@<:) @. * s2s =. (0:,]) + i.@>:@# * ],0:
(s1u"0 i.8) -: s1"0/~i.81 (s2u"0 i.8) -: s2"0/~i.81
An inductive argument shows that s1u n SYMBOL 171 \f "Symbol" s1s^:n 1 and s2u n SYMBOL 171 \f "Symbol" s2s^:n 1. Thus:
(s1s^:(i.8) 1) -: s1"0/~i.81 (s2s^:(i.8) 1) -: s2"0/~i.81
s1p =. [ s1s@]^:[ 1: s2p =. [ s2s@]^:[ 1: (s1p i.8) -: s1"0/~i.81 (s2p i.8) -: s2"0/~i.81
We will now show that the Stirling numbers may be defined non-recursively. The function ^!._1 is a variant of the power function known as the falling factorial. For example:
ff=. ^!._1 [. x=. 5 [ p=. 3
(x ff p);(x-i.p);(*/x-i.p)Ŀ605 4 360
The expression ^/~@i. yields a Vandermonde matrix for the power function ^, and ^!._1/~@i. yields a corresponding matrix for the falling factorial. One of these matrices divided by the other gives a matrix that defines the transformation between the coefficients of a polynomial (p.) and the coefficients of an equivalent falling factorial polynomial (p.!._1). Its inverse defines the inverse transformation, and together these matrices provide expressions for the Stirling numbers. For example:
vm=. ^/~@i. vmf=. ^!._1/~@i. x=. vm 5 y=. vmf 5
x;yĿ1 0 0 0 01 0 0 0 01 1 1 1 11 1 0 0 01 2 4 8 161 2 2 0 01 3 9 27 811 3 6 6 01 4 16 64 2561 4 12 24 24
r=. %. q=. x%.y
(|:q);(|:r);(||:r)Ŀ1 0 0 0 01 0 0 0 01 0 0 0 00 1 0 0 00 1 0 0 00 1 0 0 00 1 1 0 00 _1 1 0 00 1 1 0 00 1 3 1 00 2 _3 1 00 2 3 1 00 1 7 6 10 _6 11 _6 10 6 11 6 1
5 EULERIAN NUMBERS
Graham et al. [1989 6.2] derive Eulerian numbers as a dyadic function e such that:
0 e k SYMBOL 171 \f "Symbol" k=0n e k SYMBOL 171 \f "Symbol" ((n-k)*(n-1) e k-1) + (k+1)* (n-1) e k
This translates to J as follows:
e=.(k=0:)`(((n-k) * n $:&<: k) + SYMBOL 191 \f "Symbol" (k+1:)*(n-1:)$:k) @. (n>0:)
7 e 21191
e"0/~i.81 0 0 0 0 0 0 01 0 0 0 0 0 0 01 1 0 0 0 0 0 01 4 1 0 0 0 0 01 11 11 1 0 0 0 01 26 66 26 1 0 0 01 57 302 302 57 1 0 01 120 1191 2416 1191 120 1 0
The double recursion can be converted into a single recursion that computes the function table a row at a time; that is, e can be replaced by ev where ev n SYMBOL 171 \f "Symbol" n e"0 i.1+n. Vector operations are used in ev where scalar ones are used in e:
ev =. 1:`(i.@>: er $:@<:)@.* er =.(|.@[ * 0:,]) + (>:@[ * ],0:)
(ev"0 i.8) -: e"0/~i.81
zev n;t (n)L z1 0 L:z((1+n)0,t)+(1+1+n)(tev n-1),0
The tree display of er reveals a pleasing symmetry:
5!:4 <'er' |. @ [ * Ĵ 0: , ] +Ĵ >: @ [ * Ĵ ] , 0:
Observing that the left argument to er is a function of the right argument i.>:#y, the recursive part of the definition can be rewritten as a composition of monads:
eu =. 1: ` (es@$:@<:) @. *
ei =. i.@>:@#
es =. (|.@ei * 0:,]) + (>:@ei * ],0:)
(eu"0 i.8) -: e"0/~i.81
An inductive argument shows that eu n SYMBOL 171 \f "Symbol" es^:n 1. Thus:
(es^:(i.8) 1) -: e"0/~i.81 ep =. [ es@]^:[ 1: (ep i.8) -: e"0/~i.81
Graham et al. [1989 6.2] also derive second-order Eulerian numbers as a dyadic function f such that:
0 f k SYMBOL 171 \f "Symbol" k=0n f k SYMBOL 171 \f "Symbol" (((2*n)-1+k)*(n-1) f k-1) + (k+1)*(n-1) f k
This translates to J as follows:
f=.(k=0:)`(((+:@n-1:+k) * n $:&<: k) SYMBOL 191 \f "Symbol" + (k+1:)*(n-1:)$:k) @. (n>0:)
f"0/~i.81 0 0 0 0 0 0 01 0 0 0 0 0 0 01 2 0 0 0 0 0 01 8 6 0 0 0 0 01 22 58 24 0 0 0 01 52 328 444 120 0 0 01 114 1452 4400 3708 720 0 01 240 5610 32120 58140 33984 5040 0
This double recursion can be converted into a single recursion that computes the function table a row at a time; that is, f can be replaced by fv where fv n SYMBOL 171 \f "Symbol" n f"0 i.1+n. Vector operations are used in fv where scalar ones are used in f.
fv =. 1: ` (>:@i.@>: fr $:@<:) @. * fr =. ((-~ +:@#) * 0:,]) + ([ * ],0:)
(fv"0 i.8) -: f"0/~i.81
zfv n;i;t (n)L z1 0 L:i1+1+n z(((2n)-i)0,t)+i(tfv n-1),0
Observing that the left argument to fr is a function of the right argument (>:i.>:#y), the recursive part of the definition can be rewritten as a composition of monads:
fu =. 1: ` (fs@$:@<:) @. * fi =. >:@i.@>:@# fs =. ((+:@#-fi) * 0:,]) + (fi * ],0:)
(fu"0 i.8) -: f"0/~i.81
An inductive argument shows that fu n SYMBOL 171 \f "Symbol" fs^:n 1. Thus:
(fs^:(i.8) 1) -: f"0/~i.81 fp =. [ fs@]^:[ 1: (fp i.8) -: f"0/~i.81
6 TAIL RECURSION
A tail recursion tr is a recursively defined function:
tr 0 SYMBOL 171 \f "Symbol" b 0tr n SYMBOL 171 \f "Symbol" n f tr n-1
and can be represented as follows:
tr =. b`(f $:@<:)@.*
tr =. 3 : 0 z=.b i=.0 while. y.>:i=.1+i do. z=.i f z end.)
i =. >@{.z =. >@{:tr n SYMBOL 171 \f "Symbol" z ((1:+i); i f z)^:n (1;b 0)
In the ^: formulation, i is the iteration index and z is tr i-1, the result of the previous iteration. Starting on the argument (1;b 0), each iteration applies to (i;z) and yields ((1+i);i f z). If f ignores i, or can determine i from z, the definition can be simplified to tr n SYMBOL 171 \f "Symbol" f1^:n b 0 or tr=.[ f1@]^:[ b@0:.
For example, factorial is a tail recursion:
fact =. 1:`(* $:@<:)@.*fact n SYMBOL 171 \f "Symbol" z ((1:+i);i * z)^:n (1;1)
g=.(>:@i;i * z)
g (1;1)Ŀ21
g g (1;1)Ŀ32
g g g (1;1)Ŀ46
g^:3 (1;1)Ŀ46
7 PERMUTATIONS
A function to generate all permutations of i.n in ascending order can be derived, by observing that the rows of perm n whose first element is k, are formed by prefacing k to the result of indexing (i.n)-.k by perm n-1. Hui [1979, 1981, 1987] have APL implementations of this algorithm; the 1981 version is as follows:
pperm n all permutations of n p(n,n)1 (1n)0 p((!n),n)(((!n-1),n)n),(ɾ(n-1 0) SYMBOL 191 \f "Symbol" (n-1 0)n)[;perm n-1]
The translation to J benefits from observing that prefacing k to (i.n)-.k indexed by perm n-1, is equivalent to indexing row k of \:"1=i.n by 0,.1+perm n-1. Moreover, 1+perm n-1 is perm&.<:n. The set of indexing is therefore:
(0,.perm&.<:n){"2 1\:"1=i.n
This last result x has shape n,(!n-1),n. In APL, x is brought to the required shape by ((!n),n)SYMBOL 114 \f "Symbol"x; in J, the same effect is achieved by ,/x. Putting it all together:
perm =. 3 : 0 if. 0=y. do. 1 0$0 else. ,/(0,.perm&.<:y.){"2 1\:"1=i.y. end.)
zperm n z 1 0 0 (0=n)0 z,[0]/(0,1+perm n-1) fromȤ(n)=n
zx from y zy[x]
perm is a tail recursion:
perm =. 1 0&$`([: ,/ 0&,.@($:&.<:) SYMBOL 191 \f "Symbol" {"2 1 \:"1@=@i.) @. *
seed =. 1 0&$ni =. i.@>:@{:@$grow =. [: ,/ 0&,.@>: {"2 1 \:"1@=@niperm =. [ grow@]^:[ seed
8 COMBINATIONS
APL functions to generate all size m combinations of i.n in ascending order are well-known. The following function appeared in Gilman & Rose [1974, p. 362]:
rm comb n (m=1,n)/L,R r1+(0,(m-1) comb n-1),[1] m comb n-1 0 L:r(SYMBOL 176 \f "ISIAPL"n)SYMBOL 192 \f "ISIAPL".SYMBOL 165 \f "ISIAPL"SYMBOL 176 \f "ISIAPL"1 0 R:r(SYMBOL 176 \f "ISIAPL"1)SYMBOL 192 \f "ISIAPL".SYMBOL 165 \f "ISIAPL"SYMBOL 176 \f "ISIAPL"n
The double recursion can be replaced by a single recursion, by observing that the rows of m comb n whose first element is k, are formed by prefacing k to k+1+(m-1) comb n-k+1, but the latter are just the last (m-1)!n-k+1 rows of 1+(m-1) comb n-1. Hui [1981, 1987 4.1] implement this algorithm in SHARP APL; the following is retouched from the 1981 version (interchanging m and n and replacing v++\SYMBOL 212 \f "ISIAPL"1SYMBOL 185 \f "ISIAPL"0,v by +\v):
zm comb n;i;j;v all size m combinations of n i1+(m)n-m ctij1 z(i,m)i L20 L10:vct+\ct z(v/i),(1+z)[(+/v)+v/(1v)-+\v;] L20:(mj1+j)L10
Recognizing that (1+z)[(SYMBOL 105 \f "Symbol"+/v)+v/(1v)-+\v;] is equivalent to ;(-v){.&.><1+z, we have:
comb =. 3 : 0 : d=.1+(*x.)*y.-x. ct=.d$-j=.1 z=.(d,*x.)$i=.i.d while. x.>:j=.>:j do. z=.;i,.&.>(|.ct=.+/\ct){.&.><1+z end.)
zm comb n;ct;d;i;j d1+(m)n-m ctd-j1 z(d,m)id L20 L10:z,[0]/i,((ct+\ct),j-1)1+z L20:(mj1+j)L10
References
Abelson, Harold, and Gerald Jay Sussman, with Julie Sussman, Structured Interpretation of Computer Programs, The MIT Press, 1985.
Berry, Paul C., SHARP APL Reference Manual, I.P. Sharp Associates, 1979.
Gilman, Leonard, and Allen J. Rose, APLAn Interactive Approach, Second Edition, Wiley, 1974.
Graham, Ronald L., Donald E. Knuth, Oren Patashnik, Concrete Mathematics, Addison-Wesley, 1989.
Hui, Roger K.W., Algorithm 135: Generating the Group Table of S(n), APL Quote-Quad 10.1, 1979 9.
Hui, Roger K.W., The N-Queens Problem, APL Quote-Quad 11.3, 1981 3.
Hui, Roger K.W., Some Uses of { and }, APL87, APL Quote-Quad 17.4, 1987 5.
IBM, APL2 Programming: Language Reference, IBM Corp., 1987.
Iverson, Kenneth E., J Introduction and Dictionary, Iverson Software Inc., 1994 9 1.
Iverson, Kenneth E., Concrete Math Companion, Iverson Software Inc., in preparation, 1995.
Appendix. Collected Examples
n =. [k =. ]
NB. binomial coefficients
b =. (k=0:)`((n $:&<: k) + (n-1:)$:k) SYMBOL 191 \f "Symbol" @. (n>0:)bv =. 1:`(br@$:@<:) @. *br =. (0:,]) + (],0:)bu =. 1:`(bs@$:@<:) @. *bs =. brbp =. [ bs@]^:[ 1:
NB. Stirling numbers of the first kind
s1 =. (k=0:)`((n $:&<: k) + (n-1:)* SYMBOL 191 \f "Symbol" (n-1:)$:k) @. (n>0:) s1v =. 1:`([ s1r $:@<:) @. *s1r =. (0:,]) + <:@[ * ],0:s1u =. 1:`(s1s@$:@<:) @. *s1s =. (0:,]) + <:@# * ],0:s1p =. [ s1s@]^:[ 1:
NB. Stirling numbers of the second kind
s2 =. (k=0:)`((n $:&<: k) + k* SYMBOL 191 \f "Symbol" (n-1:)$:k) @. (n>0:) s2v =. 1:`(i.@>: s2r $:@<:) @. *s2r =. (0:,]) + [ * ],0:s2u =. 1:`(s2s@$:@<:) @. *s2s =. (0:,]) + i.@>:@# * ],0:s2p =. [ s2s@]^:[ 1:
NB. Eulerian numbers
e =. (k=0:)`(((n-k) * n $:&<: k) + SYMBOL 191 \f "Symbol" (k+1:)*(n-1:)$:k) @. (n>0:)ev =. 1: ` (i.@>: er $:@<:) @. *er =. (|.@[ * 0:,]) + (>:@[ * ],0:)eu =. 1: ` (es@$:@<:) @. *ei =. i.@>:@#es =. (|.@ei * 0:,]) + (>:@ei * ],0:)ep =. [ es@]^:[ 1:
NB. double Eulerian numbers
f =. (k=0:)`(((+:@n-1:+k) * n $:&<: k) SYMBOL 191 \f "Symbol" + (k+1:)*(n-1:)$:k) @. (n>0:)fv =. 1: ` (>:@i.@>: fr $:@<:) @. *fr =. ((-~ +:@#) * 0:,]) + ([ * ],0:) fu =. 1: ` (fs@$:@<:) @. *fi =. >:@i.@>:@#fs =. ((+:@#-fi) * 0:,]) + (fi * ],0:)fp =. [ fs@]^:[ 1:
For each set of functions x,
x doubly recursive definitionxv singly recursive using vector operationsxr dyadic subfunction for the recursive part of xvxu like xv, but uses a monadic version of xrxs monadic version of xrxp non-recursive formulation using ^:
The following expressions are equivalent:
x"0/~i.nxv"0 i.nxu"0 i.nxs^:(i.n) 1xp i.n
In addition, non-recursive definitions can be derived using Vandermonde matrices for power ^ and for falling factorial ^!._1 :
vm =. ^/~@i. vmf =. ^!._1/~@i. s1nr =. vmf |@|:@%. vm s2nr =. vm |:@%. vmf
(s1nr 6) -: s1"0/~i.61 (s2nr 6) -: s2"0/~i.61 (s1"0/~i.6) -: | %. s2"0/~i.61 fact =. */\@(1&>.)@i. bnr =. vmf %"1 fact (bnr 6) -: b"0/~i.61
Tail recursion of the form f^:n b 0 can be written explicitly as tr=.3 : 'f^:y. b 0' or tacitly as tr=.[ f@]^:[ b@0:. We illustrate the workings of the latter by proving that tr n SYMBOL 171 \f "Symbol" f^:n b 0.
tr n([ f@]^:[ b@0:) n defn tr([n) f@]^:[ (b@0: n) forkn f@]^:[ b 0 [, @, and 0:n f@]^:(n[b 0) b 0 dyad f^:gn f@]^:n b 0 [n&(f@])^:n b 0 dyad f^:n
n&(f@])^:n b 0 basis0&(f@])^:0 b 0 0=nf^:0 b 0 defn f^:0
n&(f@])^:n b 0 inductionn&(f@]) n&(f@])^:(n-1) b 0 f^:n if 0EJN_ams
].4CHIJK_hiw{~56T)- ,/269gh~
Z 5 < > ? O!o!v!w!!!!!!!!!!!y"""##(########$$$$%''''((((.(/(E(F(Q(R(h(i(((((((************+++"+++++,,--,-2--.!.^!.'.(.>.?.G.Q...... ///&/'/2/3/I/J/{//////.11111111111221232622233D3L334<4B4C4Y4Z4b4l44444455
5#5$5.5/5E5F5S5w555556"6&62656O6R6T6[6\6]6666666^6666666777
777/75767L7M7X7Z7m77777788889
9#9%9&9'9>9A9Z9d9f9o99?:@:V:W:::::::::::;;;;;*;6;8;B;h;;;;;;;;;;;;;;;<$<(<E<<= ==D=E=[=\==]==
>
>>!>>>>>>>>?? ?
? ?"?8?9?F?G?]?^?`?a?w?x?y?z??????@@'@)@*@+@B@E@G@\@]@^@~@@@@"A%A(A+A8A=A>ATAUAVAWAmAnArAtAxA|A,B**JdJeJ{J|JGK`KKKKKtLLLLLLLLLMMMMMMMM8M;MMQMTMUMWMwMzMMM,N1N2N3N "$&(*+<tJ%k
xofx^xxx x xx xxPPPP x`'`'"f
z
1mc*7^U#E_Ⱦڸڧ{ri_YPHPP xxLxx x xPPPx xx xx
Px xTR9y: !O!!"y"(#H##%%&&''(((差差xpe\Sxx
xLxLP xLx x xxx xxxxx Px(()&)*"+i+++,,----.Q.. /{//0.162222334l4445S5w5556¸ퟖ{ퟖsjaxPxPxxxx xx xLxx x xx x&6p7778"8B8d8889:h;;E<<<==v===>?|A,BB Cɿ푈}siaWN x x
x x x
xxxxxxx x xx
xLxx x CCC6DDD@EEE3FpFF"GBGQGlGHFH#ILI(J>JCK`KtLL|MMMXNNZO3P¸zpg^T x
xx xxxx xx`x `x x(x(x xx 3PPQQQQxxJ Code(@ !_PQQ D$/:E_PV!.6=CiNQ)*+,-./01(6 C3PQ2345678pTimes New Roman Symbol&Arial5Courier New
1Courier5MS LineDrawVISIJWingdings VISIAPL#9Pm^u,CZ,9Pz0G5L
" 9 &&&&_'v'7)N),,----G.^.K0b0223333e4|455<6S688e:|:;;V=m=p===========>>(>????@@F+FFGGHHH J JNN_P9999999999999999999999999999999999999999999999999999999JA "Q
J9Greenaway & IversonGreenaway & Iverson**