ࡱ> :<3456789` 2bjbjss J)Y $ lllPlm\ hqHBsLsss+------$h|Q )Æ.))Qss5f) s s+)+G| /sq @tl@w|0ZAD$/ /H>/,[$QQp)))) bD b  COMP 114 Prasun Dewan 6. Recursion Loops are one mechanism for making a program execute a statement a variable number of times. Recursion offers an alternative mechanism, considered by many to be more elegant and intuitive. It is the primary mechanism for repeating execution in some languages. The repetition is achieved, not by using some special new kind statement, but by simply making a method call itself. Recursion in the non-computer world This concept is not restricted to the computer world. Words in dictionaries are often defined, directly or indirectly, in terms of themselves. If you look up the Oxford dictionary, adequate is defined as satisfactory, and vice versa. One can imagine defining recursion as recursion to illustrate the concept in a very direct manner! The Oxford dictionary actually defines this word as an expression giving successive terms of a series, pointing out the use of recursion in Mathematics. In fact, as we will see here, we many of the recursive methods we will implement simply encode mathematical definitions of various kinds of number series. The Webster dictionary defines it as a procedure repeating itself indefinitely or until condition met, such as grammar rule. Let us look at grammar rules in some depth, as they are the foundation of many computer science concepts you will study in future courses, and perhaps best illustrate the kind of recursion on which we will focus here. Consider noun phrases such as: boy little boy smart little boy naughty smart little boy We can see here a systematic way of creating noun phrases. A noun phrase can be a noun such as a boy. Or it an be an adjective such as little followed by a noun phrase. Thus, we have recursively defined a noun phrase in terms of itself. This is illustrated more formally in the following definitions: ( ( The terms within angle brackets are called non-terminals. These dont actually appear in sentence fragments we are describing. The components of sentence fragments such as smart and boy are called terminals. Think of non-terminals as types such as int and String and think of terminals as values of these types such as 3 and hello. The matching of terminals such as boy with corresponding non terminals such as nouns is described outside the grammar. Each of the above rules describes a non-terminal on the left hand side in terms of non-terminals and terminals on the right hand side. There may be more than one rule describing the same non-terminal. In fact, when one of the rules is recursive, such as the second rule above, there must be another non-recursive rule to ensure the derivation process halts. Alternative definitions of the same non-terminal will correspond to use of conditionals in the recursive methods we will see. Let us see how different sentence fragments can be recognized by the rules above. Consider the fragment boy. Figure 1 (a) shows how it can be derived from the rules above. Similarly, Figure 1 (b), (c), and (d) show how the sentence fragments little boy, and smart litlle boy are derived from these rules.    (a) Deriving boy (b) Deriving little boy (c) Deriving smart little boy Figure  SEQ Figure \* ARABIC 1 Deriving various noun phrases from the rules above The process of writing recursive methods will follow a similar structure, as we see below. Developing a Recursive Solution To illustrate the nature of recursion, consider the function, factorial(), which takes as an argument a positive integer parameter, n, and returns the product of the first n positive integers. We can solve this problem using iteration (loops). Here we will develop a recursive solution to it. Before we look at the steps of the function, let us look at what this function computes for different values, n. factorial (0) = 1 factorial (1) = 1 = 1 * factorial (0) factorial (2) = 2 * 1 = 2 * factorial (1) factorial (3) = 3 * 2 * 1 = 3 * factorial (2) Based on the pattern in these examples, we can say: factorial (n) = 0 if n == 0 factorial (n) = n *sum (n - 1) if n > 0 What we have above, in fact, is a precise definition of the problem we must solve. As it turns out, it also gives us an algorithm for solving the problem: public static int factorial (int n) { if (n == 0) return 1; if (n > 0) return n*factorial(n-1); } Figure  SEQ Figure \* ARABIC 2 Recursive Factorial If we were to try and compile this method, the compiler would complain, saying that the function does not return a value. This is because we have not covered all possible values of n. We are assuming here that n is a positive integer. Though that is the expected value, Java will not prevent a negative integer to be passed as an actual argument. Therefore, we must specify what value should be returned in this case. Let us return the factorial of the absolute value of n, for negative values of n: public static int factorial (int n) { if (n == 0) return 1; else if (n < 0) return factorial (-n); else return n*factorial(n-1); } A method such as factorial that calls itself is called a recursive method. Notice how compact our recursive solution is. It can be considered more elegant than the iterative solution because the algorithm for the problem is also the definition of the problem! As a result, it is easy to convince ourselves that our solution meets the requirements laid out by the definition, and we do need to risk the off-by-one errors of loop iteration. The key to using recursion is to identify a definition that meets the following two requirements: Recursive Reduction Step(s): It defines the result of solving a larger problem in terms of the results of one or more smaller problems. A problem is considered smaller than another problem if we can solve the former without having to solve the latter. In our example, the problem of computing the factorial of positive n is reduced to the problem of computing the factorial of a smaller number, n-1; and the problem of computing the factorial of a negative integer is reduced to the problem of computing the factorial of its positive, absolute value. Base Terminating Case(s): It has terminating condition(s) indicating how the base case(s), that is, the smallest size problem(s), can be solved. In the example, it tells us that factorial(0) = 1. In general, there can be more than one base case, for instance one for negative numbers and another for 0. Once we define the problem in this way, we can use recursion to solve it. The general form of a recursive algorithm is: if (base case 1 ) return solution for base case 1 else if (base case 2) return solution for base case 2 . else if (base case n) return solution for base case n else if (recursive case 1) do some preprocessing recurse on reduced problem do some postprocessing else if (recursive case m) do some preprocessing recurse on reduced problem do some postprocessing Stacking/Unstacking Recursive Calls Before we look at other recursive problems, let us try to better understand factorial by tracing its execution Assume a main method of invokes: factorial (2) When this call is made, we know the value of the formal parameter of the method, but not its return value. This situation can be expressed as: Invocationnreturn valuefactorial(2)2? Once the formal parameter is assigned, the method executes the if statement. The if test fails, so the else part is executed, as shown by the window below:   Figure  SEQ Figure \* ARABIC 3 Recursive Call to factorial The else part contains another call to factorial(), with the parameter this time being 1. Thus, we now have two executions of the same method running concurrently. Each execution has its own copy of the formal parameter and computes its own copy of the return value. The following table identifies the formal parameters and return values of the two invocations when the second call to factorial() is made: Invocationnreturn valuefactorial(1)1?factorial(2)2? In a trace like this, it is usual to stack up the calls, that is, put an invoked method above the invoker. The topmost call with an uncomputed return value is the one the computer is currently executing. The following screen dump creates an alternative view of a call stack, showing in the pull down menu all the calls active at this point, including the call to the main method made by the interpreter:  Figure  SEQ Figure \* ARABIC 4 Call Stack Let us now trace what happens as factorial(1) executes its body. Again the test fails, and another call to factorial() is made, this time with the actual parameter 0: Invocationnreturn valuefactorial(0)0?factorial(1)1?factorial(2)2? When factorial(0) executes the if statement, the test finally succeeds, and the function returns 1 and terminates execution. Invocationnreturn valuefactorial(0)01factorial(1)1?factorial(2)2? At this point control transfers back to factorial(1), which finishes execution of the statement: return n*factorial(n-1); that is, multiplies the value returned by factorial(0) to its copy of n , which is 1 , returns the result, and terminates: Invocationnreturn valuefactorial(0)01factorial(1)11factorial(2)2? Control transfers now to factorial(2), which multiplies the return value of factorial(1) to its value of n, returns the result, and terminates. Invocationnreturn valuefactorial(0)01factorial(1)11factorial(2)22 Figure  SEQ Figure \* ARABIC 5 Values of Formal Parameters and Return Values of Each Call This return value is received by main, which prints it, giving us the output: 2 Thus, as this trace of the recursive function shows, successive calls to reduced versions of the problem get stacked until a base case is reached, after which they get unstacked as reduced versions successively return their results to their callers. Each stacked call get its own copies of the formal parameters and return value. Recursion Pitfalls We must be careful to have a terminating condition in a recursive program. Consider the following definition of factorial(), which does not have a terminating condition: public static int factorial (int n) { return n*factorial(n-1); } Let us trace again the execution of: factorial(2) It computes: 2*factorial (1) factorial(1) computes 1* factorial (0) factorial(0)computes 0*factorial(-1) factorial(-1)computes -1*factorial (-2) and so on. Thus, we make an infinite number of calls to factorial. We must also be careful to make the recursive step compute a reduced version of the problem. Let us say we write the factorial function as follows: public static int factorial (int n) { if (n == 0) return 1; else if (n < 0) return factorial (-n); else return factorial(n+1)/n+1; } Here, the second recursive step solves factorial(n) in terms of a harder problem: factorial (n+1). Consider again the call: factorial(2) It computes: factorial (3) /3 factorial(3) computes: factorial(4)/ 4 factorial(4)computes factorial(5) /5 and so on. Thus, we make an infinite number of calls to factorial again. Even though we have a terminating condition, we never reach it since we do not reduce the problem. In summary, if we do not have a base case or reduce the problem, we can end up making an infinite number of calls. When this happens, the computer gives an error message saying there has been a stack overflow. Each time a function is called, space must be created for its arguments and its return value from an area of memory called the stack. (It is so called because it stacks an invoked methods data over the data of the calling method, as we showed in our tables above). Thus, a non-terminating sequence of recursive calls uses up the complete stack hence the message of stack overflow. Recursive Function with two Parameters The recursive function above took one parameter. Let us consider one with two parameters. Suppose we are to write a power() function that takes as arguments, a base and a positive exponent, and raises the base to the power of the exponent, that is, computes: baseexponent For instance: power (2,3) == 8 When we have two parameters, we need to know which parameter(s) to recurse on, that is, which parameters to reduce in the recursive call(s). Let us try first the base: power (0, 0) = 1 power (0, exponent) = 0 power (1, exponent) = 1 power (2, exponent) = 2*2* 2 (exponent times) power (3, exponent) = 3*3* 3 (exponent times) There seems to be no relation between: power (base, exponent) and power(base-1, exponent) Let us try again, this time recursing on the exponent parameter: power (base, 0) = 1 power (base, 1) = base * 1 = base * power (base, 0) power (base, 2) = base * base = base * power (base, 1) We can use the pattern above to give the general solution: power (base, exp) = 1 if exp <= 0 power (base, exp) = power (base, exp-1) otherwise Our recursive function, again, follows straightforwardly: public static int power (int base, int exp) { if (exp <= 0) return (1); else return base * power(base, exp-1); } In this example, this two-parameter function recurses on only one of its parameters. It is possible to write recursive functions that recurse on both parameters, as you see in an exercise. In general, when a recursive method has multiple parameters, we must carefully choose the parameters whose size we will reduce in the recursive step. Recursive Procedures Like functions, procedures can be recursive. Consider the problem of saying hello world n times. We can write a recursive definition of this problem: greet(0): do nothing greet(1): print hello world = print hello world; greet(0); greet(2): print hello world; print hello world = print hello world; greet(1); The general pattern, thus, is: greet(n): do nothing if n <= 0 greet(n): print hello world; greet(n-1); if n > 0 Our recursive procedure, then, is: public static void greet (int n) { if (n > 0) { System.out.println("hello world"); greet(n-1); } } A recursive function is a mechanism for creating a recursive compound expression - it evaluates part of a compound expression and calls itself to evaluate the remainder. For instance, factorial(n), computes a compound expression that multiplies n with the result returned by factorial(n-1). In contrast, a recursive procedure is a mechanism for creating a recursive compound statement - it performs part of the steps in a statement list, and calls itself recursively to perform the other steps. For instance, greet(n) executes a compound statement that prints one greeting and calls greet(n-1) to print the remaining greetings. Recursive functions are perhaps more intuitive because, from our study of mathematics, we are used to recursive expressions. Like recursive functions, recursive procedures are also very useful, often leading to more succinct implementations than loops. Number-based vs List-based Recursion So far, we have looked at number-based recursion, where the recursive method receives one or more numbers as arguments, does some computation involving the numbers, and reduces the problem in the recursive step by changing one or more of these numbers. In the problems we saw, a number was always reduced in the recursive call but it is possible to define recursive methods in which the number is increased. This corresponds to writing loops in which the loop index is increased or decreased. Another important form of recursion involves list processing. By lists we mean any ordered sequence of items such as an array, vector, enumeration, or input stream. In some of these lists such as enumerations and streams, accessing an item removes it from the list, while in others such as arrays and vectors, that is not the case. In list-based recursion, the recursive method receives one or more lists are arguments does some computation involving some of the list elements, and in the recursive step, reduces the problems by removing one or more elements of the list arguments. We see below several examples of list-based recursion. Stream- based recursion Like loops, we can use recursion for processing input streams that are terminated by sentinels. Consider the problem of multiplying a list of positive integers terminated by a negative sentinel. Let us look at some example cases: multiplyList (inputStream) = 1 if remaining input is -1 multiplyList (inputStream) = 30*1 if remaining input is 30 1 multiplyList (inputStream) = 2*30*1 if remaining input is 2 30 1 Our recursive definition would be: multiplyList (inputStream) = 1 if next input value is < 0 multiplyList (inputStream) = readNextValue(inputStream) otherwise * multiplyList(inputStream) Here the base step returns 1 because the list of remaining items is empty. The reduction step removes one item from a non-empty list, and multiplies it to the product of the items in the remaining list. The recursive function, thus, is: public static int multiplyList(BufferReader inputStream) { int nextValue = readNextValue(inputStream); if (nextValue < 0) // no more items in the list return 1; else return nextValue * multiplyList(); // multiply nextValue to product of remaining items } To complete our solution to the problem, we need a method to start the recursion, providing the argument to the first call to the recursive function: public static int multiplyInputs() { return multiplyList(new BufferReader(new InputStreamReader(System.in))); } Contrast this solution with the ones we have seen before to see the difference between number-based and list-based recursion. As mentioned before, in the previous cases the base cases corresponded to small values of one or more numbers, and reducing the problem amounted to reducing the values of these numbers. On the other hand, in this eample, the base case corresponds to list items, and reducing the problem involves reducing the size of the list. Each call to readNextValue() reduces the size of the list by one. The number at the front of the list in a variable so that it can be used in the multiplication. Each recursive call get is own copy of this variable, since it is local to the method. multiplyList() is an impure function, returning different values depending on how much of the input has been read. For instance, if the remaining input is: 30 1 the call: multiplyList() returns 60; but if the remaining input is: 30 1 the same call returns 30. To better understand this form of list-based recursion, Let us trace the call to multiplyList() when the input is: 2 30 1 The following table shows the input stream when the first call to multiplyList() is made: InvocationRemaining inputreturn valuemultiplyList()2 30 -1??? The method reads the first item, the number 2, of the list of remaining input values, and makes another call to multiplyList(). The list of remaining input values is different for this call, having one less item the value read by the previous call, as shown below: InvocationRemaining inputreturn valuemultiplyList()30 -1???multiplyList()2 30 -1??? Again, the method removes the first item, this time the number 30, from the input list, and makes another call to multiplyList(): InvocationRemaining inputreturn valuemultiplyList()-1???multiplyList()30 -1???multiplyList()2 30 -1??? The input seen by the third call is the base case, hence it simply returns 1: InvocationRemaining inputreturn valuemultiplyList()-11multiplyList()30 -1???multiplyList()2 30 -1??? The second call returns the value returned by the third call multiplied by 30: InvocationRemaining inputreturn valuemultiplyList()-11multiplyList()30 -130multiplyList()2 30 -1??? Finally, the first call returns the value returned by the second call multiplied by 2: InvocationRemaining inputreturn valuemultiplyList()-11multiplyList()30 -130multiplyList()2 30 -160 Thus, each call processes a list with one less item, until we come to the base case of a list containing only 1. Enumeration-based Recursion To illustrate enumeration-based recursion, let us consider the following method we saw earlier: static void print(StringHistory strings) { System.out.println("******************"); StringEnumeration stringEnumeration = strings.elements(); while (stringEnumeration.hasMoreElements()) { System.out.println(stringEnumeration.nextElement()); } System.out.println("******************"); } We need to replace the loop iterating through the enumeration with an equivalent recursive method that takes the enumeration as an argument. The original method, thus becomes: static void print(StringHistory strings) { System.out.println("******************"); print (strings.elements()); System.out.println("******************"); } This method itself is not recursive. Like multiplyInputs, it simply makes the first call to the recursive method (with the same name) that processes the enumeration. This method follows the structure of the previous solution, processing the item in the front of the enumeration, and recursing on the rest of the enumeration: static void print (StringEnumeration stringEnumeration) { if (!stringEnumeration.hasMoreElements()) return; System.out.println(stringEnumeration.nextElement()); print (stringEnumeration); } Index-based Recursion In the above example, the StringHistory provided an elements() method to create an enumeration of its elements. What if such an enumeration was not available? As we saw earlier, it is possible to use the fact that it is indexed by the elementsAt() method to write a loop to iterate over its elements: static void print(StringHistory strings) { System.out.println("******************"); int elementNum = 0; while (elementNum < strings.size()) { System.out.println(strings.elementAt(elementNum)); elementNum++; } How do we replace the index based loop with a recursive method? This method, like the previous list-based recursive methods we have seen, must know how many elements have been processed so far. Enumeration and stream objects store this information implicitly in their state. In this method, we must keep track of this information explicitly through another parameter, which starts of as 0 to indicate that no elements have been processed so far, as shown below: static void print(StringHistory strings) { System.out.println("******************"); print (strings, 0); System.out.println("******************"); } The recursive method uses this extra parameter to access the next element to be printed, and then calls the recursive method with the next value of this parameter to indicate the next element to be printed: static void print (StringHistory strings, int elementNo) { if (elementNo == strings.size()) return; System.out.println(strings.elementAt(elementNo)); print (strings, elementNo + 1); } Var ++ vs. ++ Var What if we had used the incrementing assignment: elementNo++; in our call to the recursive method? static void print (StringHistory strings, int elementNo) { if (elementNo == strings.size()) return; System.out.println(strings.elementAt(elementNo)); print (strings, elementNo++); } As it turns out, this function will recurse indefinitely. The reason is that elementNo is incremented after its use, that is, after the value of the parameter is calculated. As a result, all calls to the method will have the value 0 for this parameter. The incrementing assignment, ++elementNo on the other hand, works: static void print (StringHistory strings, int elementNo) { if (elementNo == strings.size()) return; System.out.println(strings.elementAt(elementNo)); print (strings, ++elementNo); } It is the converse of the previous assignment, as it increments the variable before its use. Single assignment in function calls However, both solutions have the drawback that they increment the value of elementNo, which is not necessary. In loop-based solutions, we are used to incrementing indices as the same variable is used to index multiple elements in a list. However, in recursion-based solutions, each recursive call gets its own copy of the index variable as a parameter, which needs to be assigned once, when the function is called. Thus, in the above solution, the elemenNo of the called function needs to be assigned one plus the value of the elementNo of the calling function. The elementNo of the calling function does not need to be changed! In fact, in functional languages, which have no loops and rely only on recursion to execute a variable number of steps, all variables are final, that is, variables can be assigned values only once. Mathematically impossible statements such as: i = i + 1 are impossible in such languages. As we see in the examples above, in recursive solutions, single assignment is not a restriction. Common aspects of list-based recursion We have seen above three different examples of list based recursion, which are reproduced in Figure 6. They are different because they operate on different kinds of lists: streams, enumerations, and indexed collections respectively. But as the figure shows, they are very similar if we abstract to the common concept of a list.  Figure  SEQ Figure \* ARABIC 6 Elements of list-based recursion Each of these methods receives some representation of an ordered sequence of unprocessed items as one or more parameters. If the list is empty, the method returns, otherwise it processes the first item or head of this list in the base case and recourses on the remainder or tail of the list. We can write the following pseudo code in terms of the head and tail operations to illustrate the common thread in a recursive list-based method, m: m (List l) { if (l.isEmpty() return; process l.head(); m (l.tail()) } In general, the processing of the head and the recursive call can occur in the opposite order and the method can extract more than one item from the list before recursing. In functional languages, there is one data type to describe lists, which provides standard ways to invoke the isEmpty, head and tail operations. As a result, list-based recursive methods are easy to write and understand in these languages. In Java, on the other hand, we must provide our own encoding of lists and implementations of these operations, and hence list-based recursive methods are a bit more awkward to write and implement. However, one can explore the essentials of list-based recursion in these languages, as the examples above show. To gain more practice with list-based recursion, let us convert the following loop-based procedure to a recursive one: public Course matchTitle (String theTitle) { for (int courseIndex = 0; courseIndex < size; courseIndex++) { if (contents[courseIndex].getTitle().equals(theTitle)) return contents[courseIndex]; } return null; } The key here is to check the item at the head of the list. If it matches the title, then return it, else recurse to check the tail of the list, as shown by the pseudo code below: Course matchTitle (title, courses) { if courses.isEmpty() return null; if title equals courses.head().getTitle() return courses.head() else return matchTitle(title, courses.tail()) } The actual code is slightly less intuitive as we must encode the list in two parameters and define a separate function to make the first recursive call: public Course matchTitle (String theTitle) { return matchTitle(theTitle, 0, contents); } public Course matchTitle (String theTitle, int courseIndex, Course[] contents) { if (courseIndex == size) return null; if (contents[courseIndex].getTitle().equals(theTitle)) return contents[courseIndex]; return matchTitle(theTitle, courseIndex + 1, contents); } Perhaps even less intuitive is the following alternative definition of these methods: public Course matchTitle (String theTitle) { return matchTitle(theTitle, 0); } public Course matchTitle (String theTitle, int courseIndex) { if (courseIndex == size) return null; if (contents[courseIndex].getTitle().equals(theTitle)) return contents[courseIndex]; return matchTitle(theTitle, courseIndex + 1); } This implementation relies on the fact that the indexable course list is stored a global variable whose value is not changed by the recursive calls. As a result, it does not have to be explicitly passed as a parameter to the calls, and becomes an implicit parameter to the calls. It is a good idea to pass global lists as parameters for program understanding purposes. Perhaps more compelling, such a recursive method is no restricted to processing only that global variable, it can process other lists of the same type. Recursion vs. Loops and Stacks All of the solutions we have seen so far could have been done using loops. As mentioned before, the recursive solutions have the advantage that the solution to the problem is the same as its definition. Recursive solutions may be a bit cleaner though the awkward representations of lists may be an issue. Moreover, it is amazing that method invocations can take the place of loops, or in other words, it is possible to ban loops from general-purpose programming languages! Are there problems that can be done using recursion but not loops? The answer is no, as a language supporting recursion can be implemented using loops. Thus, indirectly, any recursive solution can have an underlying loop-based implementation. However, there are problems that are easier to do using recursion. Suppose we had to write a method that printed all items in an enumeration in reverse order. The recursive solution simply switches the order of the recursive and base case in the method that prints them in order: static void print (StringEnumeration stringEnumeration) { if (!stringEnumeration.hasMoreElements()) return; String head = stringEnumeration.nextElement()); print (stringEnumeration); // print the tail System.out.println(head); // print the head element after printing the tail } The above method makes sure that the first element is printed after 2nd, 3rd, and other elements; the 2nd element after the 3rd and later elements, and so on. Essentially it prints the tail of a list before the head of the list to ensure reverse printing. The loop approach needs a more elaborate solution in which the enumerated items are stored in some object that allows these items to be then accessed in reverse order. Earlier, we used an indexable collection to store objects to be printed in the reverse order. This solution was not ideal as it gave users the ability to retrieve objects in arbitrary order, violating the principle of least privilege. The ideas candidate for such an object is a stack. We have used this term to describe chains of method calls. It is a more general abstraction stacking items from top to bottom, defined by four operations: isEmpty(): returns true if the stack has no items. push(item): pushes an item on top of existing items in the stack. top(): returns the top item of the stack. pop(): removes the top item from a stack. Figure 7 diagrammatically illustrates the nature of a stack. Figure 7(a) and (b) show the result of pushing items A and B on an empty stack, Figure 7(c) shows that the last item pushed is the one returned by the top operation, and Figure 7(d) shows that the top item is removed by the pop operation.     (a) Push(A) (b) Push(B) (c) Top() (d) Pop() Figure  SEQ Figure \* ARABIC 7 Illustrating semantics of push, top and pop operations As we see above, a stack has the Last In First Out (LIFO) property, that is the last item pushed to the stack if the first one popped. Now we can understand why a method call chain is stored as a stack the last method called is the first one to return. The following loop-based implementation of the problem above shows how a stack is used: static void print(StringHistory strings) { StringStack stringStack = new AStringStack(); System.out.println("******************"); StringEnumeration stringEnumeration = strings.elements(); while (stringEnumeration.hasMoreElements()) { s stringStack.push(stringEnumeration.nextElement()); } while (!stringStack.isEmpty()) { System.out.println(stringStack.top()); stringStack.pop(); } System.out.println("******************"); } In comparison to the recursion-based solution, this one requires the implementation and use of a stack. The recursive solution does not require the programmer to explicitly use and implement a stack because the stack of recursive method calls (automatically created by the programming language implementation) serves the same purpose. There are many problems that require loop-based solutions to create and use stacks in far more complex ways and thus are much easier to code using recursion. We see below one such problem. Print an object array Consider the following array: static Object[] introProg = {new Integer(14), "Intro. Prog.", "COMP"}; For now ignore the fact the array is being used to encode information about a course. Suppose we used println to display it: System.out.println(introProg); The output is a string indicating the type and address of the object: [Ljava.lang.Object;@3f5d07 We might wish to, instead, see the elements of the array following the syntax used above to define array literals: {14, Intro. Prog., COMP} To create such a display, we have to write our own print method. Here is a loop-based implementation of it: static void print (Object[] objArray) { System.out.print("{"); for (int index = 0; index < objArray.length; index++) { System.out.print(objArray[index]); if (index < objArray.length -1) System.out.print(", "); } System.out.print ("}"); } For the example array, it does indeed the desired output. But for a nested array, that is, an array containing arrays, it is behavior is unsatisfactory. For example, given the additional definitions: static Object[] foundProg = {new Integer(114), "Found. Prog.", "COMP"}; static Object[] programming = {introProg, foundProg}; the following call: print(programming) outputs: {[Ljava.lang.Object;@3f5d07, [Ljava.lang.Object;@f4a24a} What we would like is the array elements to be also decomposed as arrays: {{14, Intro. Prog., COMP}, {114, Found. Prog., COMP}} We can write a nested loop to get the desired output for this case. But what if the elements of the nested array are themselves nested? That would require a three-level nested loop. We see the pattern here. A single-level loop is needed to print single-level array, a two-level nested loop is needed to print a two-level nested array, , an N-level nested loop is needed to print an N-level nested array. If N was known at program writing time, we can write such a loop. But when the array elements are determined at execution time, it is not possible to follow the above pattern. The solution is to use a stack in a complex manner, which we will not explore here. Instead, let us abandon the loop-based approach and write a recursive method to print the array. When encountering an array element that is itself an array, the method can call itself recursively. Otherwise, it can call println() as before, relying on the toString() method of a non-array object to do the right thing. Java provides a way to determine if an object is an array, which is used in the implementation below. static void print (Object[] objArray) { System.out.print("{"); for (int index = 0; index < objArray.length; index++) { Object element = objArray[index]; if (element.getClass().isArray()) print ((Object[]) element); else System.out.print(objArray[index]); if (index < objArray.length -1) System.out.print(", "); } System.out.print ("}"); } Now each array nesting level corresponds to a recursive call. Since the chain of recursive calls is not fixed, this solution can handle arbitrarily nested arrays. We see here an example of a method that uses both loops and recursion. This is not uncommon in a non functional language such as Java, where you use recursion only when it is much more convenient than loops. Later we will see how we can create a pure recursive solution to this problem. For now, let us try to better understand the nature of the recursion we use above. Trees The object being processed by the procedure above is more general than a list. It is a list that contain sublists, which in turn can contain sublists, and so on. Such a structure is called a tree. A tree is represented, as shown in Figure 7, as a set of items, called nodes, connected by directed arrows, which describe parent child relationships. The item at the source of an arrow is called the parent of the item at the destination of the arrow. A node can be both a parent and a child, such as item B in the figure. A tree has a special item, called the root, which has no parent. Items with no children are called leaf nodes. A non-leaf node is called a composite or internal node. All tree nodes except leaf nodes are composites. The part of a tree containing a node and all of its descendents is called a subtree rooted by the node. Figure 7(b) shows the subtree rooted by node C. A node that is a child of another node is called a component. All tree nodes except the root node are components. There are no cycles in a tree, that is, if we follow the arrows from a node, we cannot return to the node. This is another way of saying that the structure is hierarchical. Each tree node is associated with a height which is the length of the longest path from it to a leaf node. Thus, the height of node G is 0, the height of node B is 1, and the height of node of node A is 3. The height of the tree is the height of its root. Similarly, a node is associated with a level, which is the length of the (unique) path to the root node. Thus, the levels of nodes A, C, E, and F are 0, 1, 2 and 3, respectively.   (a) (b) Figure  SEQ Figure \* ARABIC 8 Elements of a tree As mentioned before, the object arrays we considered above are trees. Consider the following extended example: static Object[] introProg = {new Integer(14), "Intro. Prog.", "COMP"}; static Object[] foundProg = {new Integer(114), "Found. Prog.", "COMP"}; static Object[] programming = {introProg, foundProg}; static Object[] algorithms = {new Integer(122), "Algorithms", "COMP"}; static Object[] compAnimation = {"Comp. Animation", "COMP"}; static Object[] otherCompSci = {algorithms, compAnimation}; static Object[] compSci = {programming, otherCompSci}; It can be described by the following tree representation:  Figure  SEQ Figure \* ARABIC 9 Object array trees Tree-based recursion Our algorithm for printing all elements of the object array is an example of tree-based recursion. In general, a method implementing such recursion receives a tree node as a parameter. It processes the node, possibly doing different things for leaf and composite nodes. If the parameter node is a leaf node, the method returns. Otherwise, it calls itself recursively on the children of the composite. Figure 9 shows how this general scheme is followed in the print() method above.  Figure  SEQ Figure \* ARABIC 10 The print method as an eample of tree-based recursion Tracing tree-based recursion To better understand tree-based recursion, let us trace the following call: print(compSci) The following table shows the output just before the function is called: InvocationTree nodeOutput created so farprint()compSci The first thing the function does is print a curly brace: InvocationTree nodeOutput created so farprint()compSci{ Next it finds the first child of its parameter node, and calls itself recursively on this node: InvocationTree nodeOutput created so farprint()compSci{print()programming The second recursive call also prints a curly brace and recurses on its first child: InvocationTree nodeOutput created so farprint()compSci{print()programming{print()introProg The third recursive call again prints a curly brace. However, after doing so, it does not make another recursive call. Since the elements of its parameter are leaf nodes, it chooses the non recursive path through the loop, printing these elements with the separator , between them, and finally printing the right curly brace before it returns. InvocationTree nodeOutput created so farprint()compSci{print()programming{print()introProg{14, Intro. Prog., COMP} Together, the three calls have created the following output so far: {{{14, Intro. Prog., COMP} The third call returns to the loop in the second call: InvocationTree nodeOutput created so farprint()compSci{print()programming{ The second call prints a comma followed by a space, and goes to the next loop iteration, which results in a recursive call to the next child of its parameter node. InvocationTree nodeOutput created so farprint()compSci{print()programming{,print()foundProg Again, the third call finds that the children of its parameter are leaf items, prints them: InvocationTree nodeOutput created so farprint()compSci{print()programming{, print()foundProg{114, Found. Prog., COMP} and returns to the loop in the second call: InvocationTree nodeOutput created so farprint()compSci{print()programming{,  Since the second child has visited all of its children, it terminates its loop, prints a right curly brace: InvocationTree nodeOutput created so farprint()compSci{print()programming{, } and returns to the loop in the first call: InvocationTree nodeOutput created so farprint()compSci{ At this point, the output is: {{{14, Intro. Prog.,COMP}, {114,Found. Prog.,COMP}} The first call prints the separator, calls itself recursively on its second child, and this process continues until we get, at the end of the first call, the following output: {{{14, Intro. Prog.,COMP}, {114, Found. Prog., COMP}}, {{122, Algorithms, COMP}, {Comp. Animation, COMP}}} Indirect Recursion In the print method above, we use iteration to go across the nodes at particular tree level, and recursion to go down a level. We could have used recursion to do both tasks the loop would be replaced by method supporting list-based recursion. Thus, in a pure recursive solution, we need two different recursive methods, supporting list-based and tree-based recursion, respectively, as shown in Figure 8.  Figure  SEQ Figure \* ARABIC 11 Mixing Tree and List-based and Direct and Indirect Recursion The method: static void print(Object[] objArray, int elementNo) is the one supporting the, by now familiar, index-based recursion. It returns when the tail of the list represented by its parameters is null. Otherwise, it prints the head and recurses on the tail. The method: static void print(Object[] objArray) is the one supporting tree-based recursion. It is called by the previous method to go down one level in the tree. It is not as clear that it is a recursive method, as it does not call itself directly. As shown in Figure 11, it indirectly calls itself by calling the previous method, which in turn calls it. Methods such as these that indirectly recurse are called mutually recursive methods. Instance Method Recursion and Traces As a second example of tree-based recursion and to learn some important new concepts arising in such recursion, let us revisit our course example.  As shown in Figure 12, we created flat course lists, that is, course lists composed of courses. With this structure we were easily able to map a course title to a course in the list. Let us now create an extension of this example that creates hierarchical course lists or course trees instead of flat lists, as shown in Figure 13. Figure  SEQ Figure \* ARABIC 12 Flat Course List  Figure  SEQ Figure \* ARABIC 13 Course Trees A course tree is composed of courses or course tree themselves. Thus, the leaf nodes of a course tree are courses. The problem now is to map a course title to a leaf node in a course tree. Before we try to solve this problem consider why we might want hierarchical rather than flat course lists. Information may come in hierarchical form from organizations. For example, the programming and other groups submits courses to computer science department, the computer science and other departments submit courses to the school of arts and science, and the arts and science and other schools submit courses to the university. Moreover, a hierarchical course tree easily allows the answering of hierarchical queries such as show me all computing science courses or show me all programming courses. We will not attempt to support such queries here, pointing them out simply to motivate the problem. What makes the new course list a tree is the ability to call addElement() with both courses and course lists as arguments. How should we offer this feature to the users of a course list? One alternative is to provide an addElement() that takes an arbitrary object as an argument: public void addElement(Object element); However, such a method does not prevent illegal objects such as BMISpreadsheet to be added to the course list. Another alternative is to provide two different overloaded addElement() methods: public void addElement(Course element); public void addElement(CourseList element); However, this raises an implementation question?. What should be the type of the array that stores the added elements. In the flat course list solution we declared it as: Course[] contents = new Course[MAX_SIZE]; Ideally a want a single type T that unites both a course and a course list and can be used to declare the array and addElement() method. Such a type does not currently exist, so we must essentially define it as an interface that both objects implement. Let us call it TreeNode as both courses and course lists are nodes in the course tree. We dont currently know what, if any, methods go into this interface, so let us define it currently as an empty interface: package courseTree; public interface TreeNode { } we will now make both Course and CourseList extend this interface so that instances of these two types also become instances of TreeNode: package courses; public interface Course extends TreeNode { public String getTitle(); public String getDepartment(); public int getNumber(); public void init (String theTitle, String the Dept); } package collections; public interface CourseList extends TreeNode { public void addElement(TreeNode element); public int size(); public Course elementAt(int index); public Course matchTitle (String theTitle); } We now know how to type the array and addElement() parameter: TreeNode[] contents = new TreeNode[MAX_SIZE]; public void addElement(TreeNode element); The implementation of the addElement() method simply adds the element to the array in the manner it did before in fact, its body does not change.Our next task is to look at the other methods of CourseList to see if they need re-implementation. The only method that needs to be changed is matchTitle() so let us focus now on it. As a starting point, let us look at the implementation of the method in flat course lists: public Course matchTitle (String theTitle) { for (int courseIndex = 0; courseIndex < size; courseIndex++) { if (contents[courseIndex].getTitle().equals(theTitle)) return contents[courseIndex]; } return null; } If we used this implementation in the hierarchical course lists, we would only match courses in level 1. So the trick is to make it recurse to the next level for list elements that are themselves lists. We can use the instanceof operation to distinguish courses from course lists: public Course matchTitle (String theTitle) { for (int courseIndex = 0; courseIndex < size; courseIndex++) { TreeNode element = contents[courseIndex]; if (element instanceof Course) { if (((Course)element).getTitle().equals(theTitle)) return (Course) element; } else { // instanceof CourseList Course course = ((CourseList) element).matchTitle(theTitle); if (course != null) return course; } } return null; } However, as mentioned before, using instanceof are not a good idea in non user-interface code. Instead of using this operation to execute different pieces of code for different kinds of instances, it is better to put each piece of code in a dynamically dispatched method in the class of the instances that trigger the execution of the code. The method must be declared in an interface common to the classes of the different kinds of instances. In our example, it should be put in TreeNode. Both pieces of code are matching the title in the leaf nodes in the subtree rooted by the node. So the key to removing the use of instanceof is to move matchTitle() to TreeNode and require even a course to implement it. Since this implementation is independent of whether the course is a freshman seminar or a regular course, it belongs to the common abstract class ACourse. Thus, we must now not only change the above implemenation of the method in ACourseList but also provide one in ACourse. The implementation in ACourseList is simpler than the one we had above: public Course matchTitle (String theTitle) { for (int courseIndex = 0; courseIndex < size; courseIndex++) { Course course = contents[courseIndex].matchTitle(theTitle); if ( course != null) return course; } return null; } It goes through each child, looking for a match in the leaf nodes in the subtree rooted by the child. If it gets a match, it returns, otherwise it looks at the next node. It returns null if no match occurred in any of its subtrees. The implementation in ACourse is even simpler: package courseTree; public abstract class ACourse implements Course { public Course matchTitle(String theTitle) { if ( title.equals(theTitle)) return this; else return null; } } In case of a course, the subtree it roots consists only of that node. So all match title has to do is return the node in case of a successful match and return null otherwise. To better understand how this method works, let us trace an execution of it. Assuming the following course tree:  Let us trace the execution of: courses.matchTitle(Comp. Animation) The following picture shows the first three calls to this function:  At this point none of the calls has calculated a result. Unlike traces we have seen before, this one includes, in addition to the function name, arguments, and result, a column for object. This is because, unlike previous methods, this one is an instance method, and the object field indicates the target of the method call. Unlike the case in previous traces, some argument does not get smaller with each recursive call. Instead, the target of the instance method gets smaller. In fact, because the method is dynamically dispatched, it has multiple implementations; the first and second call to the method use the implementation in ACourseList while the third one uses the one in ACourse. Let us continue the trace. The last call to the function calculates null as its result: and returns to the second call.  This call then recurses on the second child of its target node, which also calculates null as its return value:  and returns to the second call. The second call has now explored all of its children, so it completes its for loop, calculates null as its result: and returns to the first call: The first call recurses on the second child of its target, which is a leaf node whose title matches the argument. Hence the node is calculated as the result of this call: When the first call receives the non null value returned by the recursive call, it returns this value, terminating the loop without looking at the third child of its target, thus completing the trace: Visiting/Traversing Tree Nodes A method visits or traverses a tree node when it accesses the (methods or instance variables in the) node. At any point in time, there can be multiple pending executions of the method, each accessing a different node. Only one of them, the last one invoked, is actually executing. It is this the node being accessed by this execution that is said to be visited at that point in time. We can abstract the trace above by simply tracing the different nodes visited during the execution. Initially the root node is visited, as shown below:  Next it is the first child of the root: Then the first child of the first child of the root:  The method then returns to its parent with a null match.  The method then visits the second child of the parent: Again it returns to the parent with a null match. Since there are no more children of the current node, the method returns to revisit the root. It then visits the second child of the root: This time the node returns with a non-null match to the root. The recursion, thus, ends without visiting the last child of the root. When you study data structures, you will learn various strategies for visiting nodes in a tree. For now, it is sufficient to understand the concept of visiting tree nodes. Recursively Creating a Tree In the example above, the tree visited recursively was created by non-recursive code. This was possible because the number of levels in the tree was fixed a program writing time. When this is not the case, we must create the tree also recursively (unless we implement our own stack). Let us look at a variation of the above problem to see how this may be done. Let us assume that we have to convert from the array representation of a course list to the special CourseList object we created for storing the courses. The header of the method we want to write, thus, is: static CourseList courseArrayToCourseList (Object[] courseArray) The following figure illustrates the role of the function.  The top figure is an illustration of the array representation of a course tree. The figure on the bottom depicts the CourseList object we want to create from this tree. Before we consider how the function may be implemented, let us explicitly state the rules used to create an array representation of a course list: A freshman seminar is represented by an object array of exactly two strings defining the course title and department, respectively. A regular course is represented by an object array of exactly three elements: the first one is an Integer object defining the course number and the other two are strings defining the title and department, respectively. A course tree is represented by arrays whose elements are array representations of freshman seminars, regular objects, and course trees. We will assume that the argument to the recursive function is guaranteed to have an array representing a course tree. Thus the argument cannot be a representation of a freshman seminar, regular course, or some other arbitrary object array. The recursive function will recursively visit nodes in the array tree to create nodes in the CourseList tree. The following figures illustrate this process for the example array representation shown above. When the function visits the root node of the representation, it creates a CourseList object with no elements. Since the CourseList object has no chidren, there are no arrays emanating from it. Next the function visits the first child of the top tree, and again creates a CourseList object:  The new CourseList must become a child of the previous CourseList, as its position in the diagram indicates. The currently active recursive function execution, however, cannot perform this task as it does not have a reference to the previous CourseList. Its caller created this object thus has a reference to it. Therefore it is the caller that will perform this task when the recursive call returns. The following figure shows the next array node visited and the object created:  Since the currently visited node represents a regular course rather than a course tree, a RegularCourse rather than CourseList instance is created. Because the visited node has no more chidren, we now go back and revisit its parent, and add the RegularCourse to the CourseList we created when we first visited the parent: The next task is to visit the second child of the array, and repeat the process of creating a RegularCourse:  Revisiting the parent, and making adding the RegularCourse to the second CourseList:  Since the currently visited node has no more children, we return to its parent, and connect the CourseList created for it to the one created for the parent: This next child of the root node is next visited: This time, the function realizes that the array represents a freshman seminar, so it creates a FreshmanSeminar instance. This process continues until the remainder of the course tree is created. Based on the discussion above, we need code to determine if an array encodes a regular course or a freshman seminar and if so to create from it a RegularCourse or FreshmanSeminar object, respectively. Let us write functions to perform these four tasks: static boolean isFreshmanSeminar (Object[] courseArray) { if (courseArray.length != 2) return false; if (courseArray[0] instanceof String) return true; else return false; } static boolean isRegularCourse (Object[] courseArray) { if (courseArray.length != 3) return false; if (courseArray[0] instanceof Integer) return true; else return false; } static FreshmanSeminar courseArrayToFreshmanSeminar (Object[] courseArray) { return (new AFreshmanSeminar((String) courseArray[0], (String) courseArray[1])); } static Course courseArrayToRegularCourse (Object[] courseArray) { return (new ARegularCourse ((String) courseArray[1], (String) courseArray[2], ((Integer) courseArray[0]).intValue())); } The last function shows how to convert between an Integer object and an int value. We can now define our recursive function: // gets an array representing a set of courses rather than an individual course static CourseList courseArrayToCourseList (Object[] courseArray) { if (isFreshmanSeminar(courseArray)) return courseArrayToFreshmanSeminar(courseArray); else (ifRegularCourse(courseArray)) return courseArrayToRegularCourse(courseArray); else { CourseList courseList = new ACourseList(); for (int index =0; index < courseArray.length; index++) courseList.addElement( courseArrayToCourseList(courseArray[index])); return courseList; } } Thu function visits each array node recursively, and when a recursive call returns, the caller adds the value returned to the CourseList node it created. As it turns out, this function does not meet its requirements, which are shown in the comment before its header. The function returns a CourseList and is guaranteed to receive an array representing a course tree rather than an individual course. The Java compiler would complain that the values returned in the base cases are not CourseList objects. This would be the desired function if we were to allow the argument to be a representation of a course tree or an individual node and defined the return type to be TreeNode. The trick to meeting the requirement is stop the recursion when the next node to be visited represents a freshman seminar or regular course, as shown below: // gets an array representing a set of courses rather than an individual course static CourseList courseArrayToCourseList (Object[] courseArray) { CourseList courseList = new ACourseList(); for (int index = 0; index < courseArray.length; index++) { Object[] element = (Object[]) courseArray[index]; if (isFreshmanSeminar(element)) courseList.addElement(courseArrayToFreshmanSeminar(element)); else if (isRegularCourse(element)) courseList.addElement(courseArrayToRegularCourse(element)); else courseList.addElement(courseArrayToCourseList(element)); } return courseList; } Composite Design Pattern The relationships between the nodes in the CourseList tree follow a general pattern, called the Composite design parttern.  As we see from the figure above, a common interface, TreeNode, unites the leaf and composite nodes. The interfaces of these two kinds of nodes extend this interface by adding leaf-specific and composite-specific nodes respectively. This general pattern is shown below:    In general, it is possible for the leaf and/or composite interfaces to be empty as shown above depending on whether the two kinds of nodes need special operations. Moreover, there may be multiple kinds of composites and leaf nodes as shown below:   We have described the pattern so far in terms of interfaces and inheritance relationships among them. It is possible to describe it in terms of classes and interfaces and the inheritance and implementation relationships among them.  Now a composite and leaf node implements two interfaces, one capturing the common operations and another defining the node-specific operations which does not inherit from the common interface. In general, it is always possible to replace inheritance relationships among interfaces with extends relationships among classes and interfaces. We compare these two approaches in the next chapter. In either case, we rely on the ability to define interfaces. The following figure shows how the pattern can be implemented in a language such as C++ that has classes only.  This time, instead the leaf and composite classes implementing a common interface, the two classes subclass from a common abstract class that defines the common operations. In general, an abstract class can always take the place of an interface through interfaces should be the first choice, as we discussed earlier. The common aspect in all these versions of the pattern is that there is a type (extended interface, unextended interface, abstract class) that defines operations common to all nodes, which can be implemented differently in different kinds of nodes to remove the need for performing the instanceof operations on code that operates on the tree. Composite Pattern in Toolkits A version of the class-only pattern appears in most toolkits, which allow us to create trees of widgets( user-interface objects). These trees are defined by containment relationships among the screen representation of these objects. The following figure shows this tree for an example user-interface. Here the boundaries of the various widgets are marked by rectangles. The outermost rectangle defines a frame in which there are two panels. The left panel contains two text fields and two buttons while the right panel is a leaf node. Figure 15 shows the inheritance structure created for the widget classes shown in Figure 14. The methods common to all widget nodes are defined by the class Component. Methods common to composite nodes, that are defined by the class Container, which is a subclass of Component, with its own subclasses defining Panel and Frame-specific methods. Also subclasses of Component are TextField and Button, which implement leaf nodes. Unlike the case in our example, different instances of the same type can be both composites and leaf nodes. In particular, the left instance of a Panel is a non-leaf node while the right instance is a leaf node. We will all a type (class or interface) a composite if any instance of it can be a composite tree node. Such a type must define the functionality of a composite even if some instance of it is not actually a composite.  Figure  SEQ Figure \* ARABIC 14 Example Widget Tree Figure  SEQ Figure \* ARABIC 15 Widget Inheritance Relationships The following code shows how the tree of Figure 14 is created: Frame frame = new Frame("Points Plotter"); Panel control = new Panel(); frame.add(control); frame.add( new Panel()); control.add( new Button(New Point)); control.add(new Button(Quit); control.add(new TextField(0)); control.add(new TextField(0)); The processes of creating this tree is very similar to the one used to create our course trees. Let us try to deduce the class in which the add method we used above is defined and the type of its argument. It is possible to add only to composite nodes, so the method must be defined in the Container class. It should be possible to add any component to a container. Therefore its argument type should be Component. This method is an example of a Container-specific operation not supported by leaf nodes such as a TextField. Conversely, getText() and setText() are examples of methods that apply to a TextField but not to a Containers or a Button. More interesting are dynamically dispatched methods defined in the abstract class Component. An example is the paint() method, which can be implemented differently by each subclass of Component. A Container can recursively implement its paint() method in terms of the paint() methods of its components, without being aware of how these methods are actually implemented. As we add new kinds of component classes, we dont have to change the classes of the containers in which these components are added, as the container classes do not perform the infamous instanceof operation. Yet another example to show the power of dynamic dispatch and the Composite design pattern! Grammars and structure-based Recursion We started this chapter with grammars. Let us end it by tying them to recursive methods that operate on lists and trees. Both lists and trees are structured objects in that these are objects that can contain components. Recall that a grammar creates rules mapping non-terminals to terminals. For example, the grammar: ( ( tells us the sequences of words, which are the terminals in this example, to which the non-terminal can be mapped. There can be multiple, rules defining the same , as shown above, which serve as alternate definitions. Thus, the above grammar say that a noun phrase is either a noun or an adjective followed by a noun phrase. Not all mappings between non-terminals and terminals are provided by the grammar. For example, the grammar does not specify the mapping between the non-terminal and actual terminals such as boy and girl. It is assumed that these mappings are well known, that is, implicitly defined by some mechanism other than the grammar. A non-terminal is mapped to a sequence of terminals if we can derive the sequence from the non-terminals using the explicit and implicit rules of the grammar. We saw earlier how we could derive word sequences such as smart little boy from the non-terminal . What does this have to do with recursive methods? As we see above, both recursive methods and grammars use the concept of recursion to define entities. More important, often the way a recursive method decomposes a structure object on which it operates (such as a list or tree) can be defined by a grammar. Consider a list of items. We informally define it as an ordered list of items. We can define it recursively using the following grammar: ( empty ( The first rule says that the list can be an empty sequence and the second one, recursively, says that it is an item followed by a list. We leave the mapping between and actual list elements undefined, and this mapping would be different from different element types such as int, double and so on. The following figure how the non-terminal can derive various kinds of int lists:  The derivations used here are similar to the one we used for noun phrases earlier. What is interesting here is that they parallel the way our list-based recursive methods decomposed their list arguments.  The two cases of the conditional used in the method correspond to the two rules defining its argument when the argument is empty the method does one thing and when it is an item followed by a list, it does another thing. In general different ways of decomposing a structure in a method, (reflected by a conditional such as if or switch) correspond to different grammar rules defining the structure. A could also have been defined in a non-recursive way: ( * The * above is called Kleene * and denotes an arbitrary number of occurrences (including 0) of the element to which it is attached. Thus, the rule above says a list consists of sequences of zero or more items. Since this way of decomposing is non-recursive, it corresponds to a method that uses a loop to iterate over the elements:  Both implementations work on the same argument, a flat list, but decompose it differently. The corresponding grammar describes the tree of method calls made to process the argument. In one case, a single method call is made while in the second case a sequence of recursive method calls is made which corresponds to the recursive grammar derivation of the argument. There are two advantages of tying a method implementation to a grammar. First, a grammar is a more abstract and hence concise description of the method that applies to all other methods that decompose an object in the same way, even though they may do different things in the base and recursive steps. In particular, the grammar above describes the structure of all list-based recursive methods we have seen here. Thus, it serves as documentation of a method and a high-level step before the method is implemented. More important, sometimes the grammar is given, in which case it can guide the implementation. For example, the grammar of Java programs can be given to us, which can then guide a recursive processing of these programs. Consider now alternate ways of describing tree nodes. One approach is to use a mixed representation combining the Kleene * with recursive rules: ( * ( The first rule says that a tree node is a list of zero or more children nodes, and thus defines a composite node. The second one says that it is an atomic item, and thus defines a leaf node. Figure 16 shows how these rules can be used to derive a tree represented as recursive lists. Figure 17 shows the correspondence between this grammar and the version of the print method we wrote that mixed loops with recursion.  Figure  SEQ Figure \* ARABIC 16 Example derivation Figure  SEQ Figure \* ARABIC 17 Relating method implementation to grammar The following grammar describes the print solution that used only recursion. ( ( ( empty ( It essentially combines the two grammars above, replacing * in the second grammar with rules describing a list of elements.  Figure  SEQ Figure \* ARABIC 18 Pure recursive decomposition of a tree Figure 17 uses this grammar for the example we used in Figure 16. As we see from both the rules and the derivation, the rules describing a tree node list are directly recursive, a tree node list is decomposed directly into another tree node list. The rules describing a tree node, on the other hand, are indirectly recursive. A tree node is defined in terms of a tree node list, which is then defined in terms of a tree node. This was exactly how our purely recursive print solution was structured, and the figure below shows the relationship between the solution and the grammar:  As mentioned before, sometimes a grammar comes before the corresponding methods. Consider a grammar describing simple expressions you evaluated in assignment 3: ( ( The following figure shows how it can be used to derive the expression: 5 + 4 * 5  For extra credit, redo assignment 3 by writing a recursive expression evaluation function that corresponds to this grammar. Nested expressions, that is, expressions containing subexpressions marked by parentheses can be described as follows: ( ( () ( () Grammars are covered in more depth in courses on compilers and theory of computation. Here we have looked at them as a tool for developing recursive methods. Summary Recursion offers an alternative to loops that is considered more elegant and less error-prone, since the solution to the problem is the same as its definition. Each recursive method must have a recursive reduction step, which solves the problem in terms of the same problem of a smaller size; and one or more terminating base cases, which solve it for the smallest-size version(s) of the problems. Successive calls to reduced versions of the problem get stacked until a base case is reached, after which they get unstacked as reduced versions successively return their results to their callers. Each stacked call gets its own copies of the formal parameters and return value from an area of memory called the stack. When a recursive method has multiple parameters, we must carefully choose the parameters whose size we will reduce in the recursive step. Like functions, procedures can also be recursive. While recursive functions create recursive expressions, recursive procedures create recursive statements. Number and list-based problems are particularly amenable for a recursive solution. In the former, the reduced problem involves a smaller number; while in the latter, it involves a smaller list. Exercises Trace the following two calls. The number of rows created for tracing the calls may be less than the number of actual calls: a) f(3) public static int f(int n) { if (n <= 1) return 0; else if (n % 2 == 0) return f(n - 1) + n; else return f(n 1) n Invocationnreturn valuef (3)3 b) g(3,2) public static int g(int n1, int n2) { if (n1 <= 0) return n2; else if (n2 <= 0) return n1; else return f (n1 1, n2 1); } Invocationn1n2return valueg (3, 2)32 Trace the call to each of the following definitions of the recursive procedure, p by showing the output produced by each call. Assume that the user enters the four lines: hello hello goodbye goodbye a) public static void p (){ if (Keyboard.readString().equals(hello)) { System.out.println (ca va); p(); } } InvocationOutput producedp () b) public static void p (){ if (Keyboard.readString().equals(hello)) { p(); System.out.println (ca va); } } InvocationOutput producedp () c) public static void p (){ if (Keyboard.readString().equals(hello)) { System.out.println (ca va); } p(); } InvocationOutput producedp () In this problem, you will solve a famous mathematical problem. The problem is to compute elements of the Fibonacci sequence. The first two elements of the sequence are 1 and 1 and a subsequent element is the sum of the two previous elements. Thus, the element of the sequence are: 1 1 2 3 5 8 13 .... Your program will take as input a number n and output the nth element of the Fibonacci sequence.Thus, if the input is 2, the output should be 1; and if the input is 7, the output should be 13. Do not use a loop; instead write a recursive function.  If the user enters zero or a negative value for n, your program can print an arbitrary number. Extend your solution to Q3 by allowing the user to enter a series of values for n ending with a 0 or a negative number. Output the value of Fibonacci(n) for each user input, as shown below. Do not write a use a loop to process the list; write a recursive procedure instead.   ( Copyright Prasun Dewan, 2000.  It is not clear what the product of the first 0 positive integers is. The convention is to assume it is 1.     Recursion PAGE 1 PAGE 37 Recursion PAGE 1 PAGE 45  & FG^_CLefqrtuwCD+,EF پپٶُننننhq)5OJQJjhq)0JOJQJUhq)mHnHujhq)UjXhq)Ujhq)Uhq)6OJQJ] jhq)OJQJmHnHuhq)OJQJ hq)CJjhq)0J6CJU hq)6CJhq)4 & 7OzDE*+dvw$a$1222/Gs!N3Dgi> ^`^^`)/8:NTipqTUqr%+z_z ##F$O$C%D%U%V%%%%%%&&&&&&7&j*hq)UmHnHuj hq)UmHnHuhq)6OJQJhq)mHnHujhq)Uhq)hq)OJQJhq)5OJQJG>@A^_ !!."@"f"|""""""#<#Z#\#w#### & F^####$$(%)%4%6%C%D%Q%ikd $$IflF~ t" p0    4 la$If`^ Q%S%U%V%W%X%%%%%7&'''ywwwwwwuwwwkdU $$IflF~ t" p0    4 la$If 7&^&i&&&'''''' (()))))))))))*?*J*********i+j+{+|+++++, ,,,,,,,,,---------------..~./K0W000000000hq)5OJQJhq)mHnHujhq)Uj5hq)UmHnHuhq)hq)OJQJP''''''''ykd3$$IflFZ F0    4 la$If'' ( ( (yyy$Ifkd3$$IflFZ F0    4 la ((((()))){*}****}}}}}}{}}uuu$Ifkdq4$$IflFZ F0    4 la *****yyy$Ifkd>$$IflF 0    4 lal*****yyy$Ifkd]?$$IflF 0    4 lal*****yyy$Ifkd @$$IflF 0    4 lal****M+O+Z+\+i+}}}}www$Ifkd@$$IflF 0    4 lali+j+w+y+{+yyy$IfkddA$$IflF 0    4 lal{+|++++yyy$IfkdB$$IflF 0    4 lal+++++yyy$IfkdB$$IflF 0    4 lal+++++,,,,,,,}}}}w}}qqq$If`kdkC$$IflF 0    4 lal ,,,,,yyy$IfkdD$$IflF 0    4 lal,,,,,yyy$IfkdD$$IflF 0    4 lal,,,,,yyy$IfkdrE$$IflF 0    4 lal,,,----}}www$IfkdF$$IflF 0    4 lal-----yyy$IfkdF$$IflF 0    4 lal-----yyy$IfkdyG$$IflF 0    4 lal-----yyy$Ifkd&H$$IflF 0    4 lal---..|.~.//00000}{}usq}kkk}^`kdH$$IflF 0    4 lal 00000,181A1H1Z1f1n1t111112222222222222222333%3d3p333334 44)41474G6L6H777w88:;;;;;;;;;<<<$<*<8<><A<G</=0===?????? hq)H*hq)OJQJhq)6OJQJhq)hq)5OJQJhq)OJQJT00 11,1C1Z1o11111122222 33:3<3=333334 ^`^4424G444H7o7r8888G9X9s99999:*:.:F:G::::^^`: ;E;j;;;;; <!<0<><c<e<f<==f>{>>??/?R??????^???_@|@@@!A"A?ALAAA)B1BC CCFHIIKKKKKKKK'L*LWLYLLLLLLLMMMMMMMMMPPkQ{QRRRRWSfSTT6T7TRTSTTTTUUU0U1ULUMUUUUUUUVVVhq)OJQJ\h hOJQJhq)hq)6OJQJhq)5OJQJhq)OJQJR? @"@)@+@,@CCEEGG.HFH,IpIIII"JtJJJJKKK#L ^`^#LSLLLLLLLMMMMMPPZQaQkQ{QQQQQhM*hM*H*hM*hchcH*hchq)<CJaJhcB*CJph33hzB*CJph33hq)B*CJph33 hq)CJhq) hq)aJ-ق-YZ[}]0234^ p0^p`0^` & Fʄ˄̄]12XYZ|}.g*Ș͘'+OX\i)*@ABCǞ ½·ʷjnshq)Ujlhq)U hq)6] hq)aJ hq)CJ hq)<hq)CJaJhq)<CJaJhq)5B*CJ\ph33hq)B*CJph33hq)jhq)Uhq)mHnHu<4@Vu9YZ/H݌0V|Ŏ$-g`*Rk˔?b~CD`"WXǞW֟O à If£  $If^ ʠˠ 67H¤$OPbcxϥ $%8ҧӧ٨ڨԩթrɪʪ$OPbc{'(hq)OJQJjhq)Uhq)mHnHujhq)Uhq)hq)<CJaJjyhq)UO 67?GHrkd$$IflZF? J0    4 lal$IfHIJxvvppp$Ifkd$$Ifl-F? J0    4 lal¤xrrr$IfkdC$$IflZF- | 0    4 lal¤äĤ$/9Oxvvppp$Ifkd$$Ifl-F- | 0    4 lalOPX`bxrrr$Ifkd$$Ifl_F ] 0    4 lalbckwxxrrr$IfkdV$$Ifl/F ] 0    4 lalxyzϥڥxvvppp$Ifkd$$Ifl/F ] 0    4 lal xrrr$Ifkd$$IflxFC f 0    4 lal "$xrrr$Ifkdi$$Ifl<FC f 0    4 lal$%-78xrrr$Ifkd$$Ifl<FC f 0    4 lal89:xvvppp$Ifkdˑ$$Ifl<FC f 0    4 lalȧЧҧxrrr$Ifkd|$$Ifl6FC f 0    4 lalҧӧۧxrrr$Ifkd-$$IflFC f 0    4 lalxrrr$Ifkdޓ$$IflFC f 0    4 lal[vwè٨xvvvvvppp$Ifkd$$IflFC f 0    4 lal ٨ڨxrrr$Ifkd@$$IflXFC f 0    4 lalxrrr$Ifkd$$Ifl,FC f 0    4 lalԩxvvppp$Ifkd$$Ifl,FC f 0    4 lalԩթݩxrrr$IfkdS$$IflXF k 0    4 lalxrrr$Ifkd$$Ifl,F k 0    4 lalxrrr$Ifkd$$Ifl,F k 0    4 lalqr}xvvvppp$Ifkdf$$Ifl,F k 0    4 lalxrrr$Ifkd$$IflJFC f 0    4 lalŪɪxrrr$IfkdȚ$$Ifl%FC f 0    4 lalɪʪҪܪxrrr$Ifkdy$$Ifl%FC f 0    4 lal$/9Oxvvppp$Ifkd*$$Ifl%FC f 0    4 lalOPX`bxrrr$Ifkdۜ$$IflkFC f 0    4 lalbckw{xrrr$Ifkd$$Ifl6FC f 0    4 lal{|}xvvppp$Ifkd=$$Ifl6FC f 0    4 lal%'xrrr$Ifkd$$IflqFC f 0    4 lal'(0<Axrrr$Ifkd$$Ifl9FC f 0    4 lal(AnůƯίϯ'39:>X[;ABF˲%&./EFHI϶123޻׽ s hq)<hq)CJaJ hq)aJ hq)aJ hq)mHnHujhq)U hq)6] hq)5\hrt{mHnHujhrt{Uhrt{jchrt{Uhq)hq)OJQJ>ABCnyxvvppp$IfkdP$$Ifl9FC f 0    4 lalxrrr$Ifkd$$IflxF- | 0    4 lal̬/ůǯ'3xvvvvvvtvvovgdrt{kd$$Ifl<F- | 0    4 lal 3g:` [\$%'Wٸڸۺ123޻gdrt{`׽ Ѿ &\_tϿ57uw^stpvio39*0TUmt ":;]^"#BCRSXjhq)Uj'hq)Ujhq)U hq)< hq)5\hq)hq)CJaJRBFTVop -g&.@Bf9@^@RTU=>m)19;<]_~^"BQRTX XYQ34)*\]%&-Z\ 46imnt~ #)󶬶hq)5B*CJ\aJph33hq)B*CJph33hq)5B*CJ\ph33hq)<CJaJjhq)CJUaJhq)CJaJhq)B*phhq)5B*\phhq)jhq)U=?@PQ;<S./0 & F`235)\ !Y3h|~!#e 0^0`)jprue)/^bMSFH0478FGHILMOFܼҼҼҼҼҼҼҼҼҼҼҼҼҼҼҼҸҼҸj(hq)Ujhq)Ujhq)Ujhq)Uhq)hq)5B*CJ\ph33hq)<CJaJhq)B*CJph33hq)CJaJhq)5B*CJ\aJph33hq)B*CJaJph3399:e![:QR^_M<^`&679FNOFJK346km  & F^FGHI45klcf#&GJ     \ƾ󶭶󶭶󞎞 jhq)OJQJmHnHuhq)OJQJ hq)5\hq)mHnHujhq)Ujhq)Ujhq)U hq)<jehq)UjZhq)Uhq)CJaJjhq)Uhq)j-hq)U6U9]      , #$``^[\`a-.01acdfE^rs^`\]^_a./  bcdefPQij !78:;WXnoqr)*@A ~!˿˺ײ˿˿˪˚˚˚˚˿˿˿˿ˉ˚˚jhq)Uhq)mHnHujhq)Uj(hq)Ujghq)UjI hq)U hq)< jhq)mHnHuhq)jhq)Uhq)CJaJhq)OJQJjhq)Ujhq)Ujhq)U21[9~!!!"9"i""""":#;###$$$$`gd%=gd%=`^~!!."/"F"G"""#########$ $$)) **'*+*?*H*U*\*j*v********************++++#+0+e+f+t+u+y+z+~+++++++6,¹¹¹¹¹¹¹¹¹hq)5OJQJhq)OJQJ hq)5 jh%=mHnHuh%=jZ-hq)U jhq)mHnHuhq)j#hq)UF$$e%S&''((y)z)))* *'*5*?*U*j*o*****$If ^` ^`^h^h & F & F******ykd 3$$IflF5k 0    4 la.$If*****yyy$Ifkd3$$IflF5k 0    4 la.*****yyy$Ifkdz4$$IflF5k 0    4 la.*****yyy$Ifkd'5$$IflF5k 0    4 la.*****yyy$Ifkd5$$IflF5k 0    4 la.******++#+(+D+}wqqgqg]] ^` ^`^h`hkd6$$IflF5k 0    4 la. D+F+G+R+U+X+e+f+o+q+s+^kd.7$$Ifl\ 8T04 la.$If` s+t+u+v+w+x+y+fkd7$$Ifl\ 8T04 la.$Ify+z+{+|+}+~+lffff$Ifkd8$$Ifl\ 8T04 la.~++++++lffff$Ifkdw9$$Ifl\ 8T04 la.++++++lffff$Ifkd::$$Ifl\ 8T04 la.+++6,=,D,L,T,X,q,lfa[[[[U[h^h^ & F^kd:$$Ifl\ 8T04 la. 6,S,X,^,_,e,f,j,q,s,,,,,,,,,,,,,,,,,,-- - ----g-i-j----------------------- ...,.-.3.4.6.7.9.:.<.=.?.@.A.S.^/////v0hq)OJQJh hq)hhq)OJQJ hq)5hq)hq)OJQJQq,,,,,,,,,,,,jlkd;$$Ifl004 la.$If^ ^` ^`^ ,,,,$IflkdW<$$Ifl004 la.,,,,$Iflkd<$$Ifl004 la.,,,,$Iflkd=$$Ifl004 la.,,,,$Iflkd>$$Ifl004 la.,,,,-B-G-e-g-i-k-v-zzpjhb$If^ ^`p^p^h^h^lkd>$$Ifl004 la. v-----lkdJ?$$Ifl004 la.$If----$Iflkd?$$Ifl004 la.----$Iflkdx@$$Ifl004 la.----$IflkdA$$Ifl004 la.----$IflkdA$$Ifl004 la.-------.. ...vlfd^ h^h` ^`8^8h^h^lkd=B$$Ifl004 la. ..,.-.2.3.lkdB$$Ifl004 la.$If3.4.5.6.$IflkdkC$$Ifl004 la.6.7.8.9.$IflkdD$$Ifl004 la.9.:.;.<.$IflkdD$$Ifl004 la.<.=.>.?.$Iflkd0E$$Ifl004 la.?.@.A.B.^/_/y/u0v0x0z0001ysyh`hh^h & Fh^h^lkdE$$Ifl004 la. v0w00000*1+1111111112222222222222222222222222222222222222ബ࢜࢜࢜࢜h*@0JmHnHuhq)0JmHnHu hq)0Jjhq)0JUjh~Uh~ jhq)jhq)0JUj!Nhq)UmHnHuhq)OJQJhhq) hq)hhq)OJQJhj^Fhq)UmHnHu4111111111222222222222222222h]h&`#$h`h2222222222222222222222222222h]h&`#$2222222h~hq) hq)0Jjhq)0JUh%=0JmHnHu2222222(/ =!'"'#$% (/ =!'"'#$% `!nxdՑ*D H( (xY]h[Uߛs=I]K'ƙj kWW ݋MlC֘d,!i  &Ƞ-c/n{PQ6}a ,1|CJ{nQUpr>9ΟHpT`yVC;@ |[gP>CN1 ! 'F+؇ 0$[u> @rLb$g#X# T&M4@G m,|ءX K|v'yMLT(ΑZ(>ָ vagxӎ%ӿyy^$oygY+đ,̩r7 'X.|$3Si1~CL׿n`V.ZE;a+3Y3n fKrY˶k Jv-g[45E}Wj=KSFM3|e'pDQjPw Լ[#bQs.%` wO7c~^#{>Wb'{i2=5ˆ<ƾ# jl^gF?נT@AXXGQή0;8fV+1ѣ/ 0lr{D Mv,LN>-Pox?2xRt6̓Q$a1o<%<|%y(7(a݌S'1vAP`>&u=CCG̹"͋GQxdnڇ 4,"aH1t3QIfoGTZ<%'9:j2}t25=4"2MᮦjEQh#Ԍ{sH \`wٟt=mI82"AdN[|Z3$q\pG~.Q1U7v B*K%mWbIKR(FOiP[ -zJ[-]AA>qW龾}3HSLs8‹060 K{T{CϠQg Vϼ䢚VP+{'x,)bp:Kkrɳ_+}%_NM_~{5*eZRv<9(ϩ?x[SUd0G2휷I6M:٤M:٤M:٤M:٤M:cM8٤M>lW1la~Dkc/jbYrJ;X wo`Abno߶\,u@`!D /C*P H'xY]h[Uߛqro6kĸuZnC֘d,!I 1* &Ƞ-c{_/{ 2ɗ:tUYs͒6jN=wvz>XSڡ #~7la3D#{؈=pi`X<@5>[cD`, @GƢd61X]% P]\G:nb/0(CfHo?Qd:KsDJ=]XY6^tckWWNaY^}j!{Ĵ"m-(lq#y2BGcq+53nh#Loa֠[@Eh;՜DWfV܄0cJŊcJ; ,X45E-\92Ӹ]i-8jA؁5Ӈh{F̞O=oz d-ϤYk0cXn;ܤfHe2f 1 Am;$V) jdy8ig?>fiydj~EP~Hv"\[j *NA*Aﲿ{ےpoe#CiI/ͫb{a/Ec"z>!FoaK0-R&RڀE]rI%gįVrVHXM,e3uHjҧouׯ6s_d Ru:n#La?3x|Qߔ3ʜ|QIeCkJuHɟs-Γ\ |M.*9e[F|efn6i5 *;m?˥O?@O`!YK4R>Y*P H.)xY[hUgv.gg&MRqMIcc }1Q-ٙe'qBIPMD I(E>h b} H'A&(]sv7Yuof2|||k t}Z<4C;B[mla3D#O : *|]>X~k|f+a, @GƢZM5j-IYup5XD *],|!Xo2 lv<T|aBq}?Ƌv,_ kwsg'~>^bz ;(qcz&ۑ\䔕6\j7`ʬ=0pv N-zXۧ]Z 3[(KZ]KxC[3`9Rq4T)ZozrgJ'p$DQJPsԜ[#5I&Ӎu?hWϞ{ٞ duLsY/Xn;Zf}`gԃQH4$b(gW] 3(j`g{IXD6ǘ=qB[pZN~l$'7[h$tʜFz2<I`&OW[ ֜}(?CP?BíqVoirO /˻Wxԡ8h̚7_n\dhLLP% CIG[AJn0;m7҆0RzqtJg"#f*==LpWs5ub(APnj6A)7H)?]G-ǹ-) VF}ܗMi^x83~|pG|,w*.¤vHHS R7PeVF?䜺NYQ!}[}z뭌A|]ΰn>8C=3_+gяɗA9ȗyISˊ)Y)tT/~D^勁J \?gCV C>S2})E;^ԏrZwȹ:y,dJ,r7m/#M^6e^6e^6e^6e^6e\6&ladQ.'(og9_1 x\< o’@eޞg)'ZaA`!u;|E*{*P H'xY]h[U{5mbЉqKV ݋M-}]!֘d,!i VdЖ1_A7M1 C|C{Y9,i櫎|s~;?  i PA1e7;ԁ`3!bo;FdM3p B>IlT)a,Z@Gbd1Z% ^2k;e^_/;uQq_~R~^Ku*|-{\XY2^tbyɧʭI,O-dv^C1-nڏ'S\p,:j`'c*=8xN N-O߮d2& {P-񊾠dHh9R5T)ZRٚ*5ja+ӈ?% Vm=ϝΎYs\,Qa?=X``{l!7rO23pm2˻Cfaf=E_;r\}wmyds#=PȐnɏ}6Gdz\OұX*Άz2<4SVL26Ǹ/;嗭ry~*DPCïR[RL*aɶy,!eA~ \Ԉk+ UUKYLPo5j)u* 9m؇iRgE=#WA1P2r^qu]Oʞ?g [ʟ18%KdW w' TI0͐޻ZR!;hsEBZ*&9_%sZ)+yd߻٤M٤M٤M٤M٤M>tn6f"tLtYWIY:8h6}l5׌(`! r̗Q@Ly*P H'xY]h[Uߛs=i]C'f3֮ZlC֘d,1i &VdЖ1_m>8At{e ,ʘ 쥯,ϹfI5_u ';n׊@.`O+Tt@?p |[gP>Cv1$! F wab}: ]W9 {>1#X#$[-rR5YH^`2[kۅ%^_/;uYq$/k?*S>be:sd5XY2^t`çʝq,_,d'\;7[/V#YS %nڎ%S\P,>b`c^uh,wygmyds#"TxRx4fΥ_n^dh LLPe CTIG~JV0{}+ҚaD.=AQ3 ٤i w5WX`/pEfZP￧p0dpeZv NcݖT~+#.ɢvikrޑOSk$ n#*>6JnaTHrMRB,)Xn!eR.jT Rޠ'UUKYLW>wؚqi%:zN7AxƱ|}!rN6d#eBXre~IlT[b3V]GRI_dgޘmg)'YD`!݆W( *P H.)xY]h[UߛqroMlZ1nvuо~6D\kސa I+2h˘/݃n>胸́$J_*eUs:s~;{D/g@nO f<>~!]f6C^;F$S #($[56 @MO){|$fI`?2]4k5$Tf{m`5۫KtzKt\`;eDR9"_ @?XWNcY}j!{Ĵ"m9Q.FT2ˆrVjsESfEش/t(PpjуZtƊ0~BaXrZjǛڒ&K4]hbٚUjc+MğGM+A9c'bsqk!%`wOأ^={>= Гճ2mg0"bH.Ej/1ciPjG#8?uafF; PG /l2{DjmiWj9yHN>Qox?6exNRIs6F|(pL?b<p_m3v-i<2j^EQ^hv"\Sj<f *NIJA?¹{ےp2ࡴnJ ꆘ Ğ!|{KdIkW1-p&C_%[j2/R.DԵ2R%guQ͊, oت#[TFecq=NI,zf|g2y_?"_҇72'_Rvz5yBْ.+R3nK z)WyQ/+` ;4@WxQ?,ˁHsj9#g@T*ey;9oOH6&l&l&l&l&l&ϸ٤M>lW2 ёf/&yǛAutqljcQ{|,C޷UaIiov\M-a2}?G`!+~xDR fŤM*P H'xY]h[Uߛs=I֤]C'ƙj kWW ݋M-}]!d,1I VƠ-c//c`A> *sYFM17{?~'\+m*t{XW۠J!# >2v.8~0B _>|W*և ߺY2wUc&FB|/H8"(Xinĩ; (x0N`v~Qَxǣjţqs.GpQ2٨#C-`b`꫊HvLj<*cTҷ?<#*u ? qld4JRfFDi\Mb݋J=kv{Pgp0dp5ZvNcݖT~+.ɢvikrޓRk$Q ȯ*>6*naTHrMR%E,6 eR.jTRަU2uKYLP>3w-94d&}^ ,[ gH |9 )o*Y5W7{ue\]'ՌZ3?scI3tR.y+ o7 0ү|f,A_k@ hs/byz*JiRf & N6dN6dN6dN6dN6dO\6y&lqdQ}}e[({牱Fu,j8c%Y}|!'5X쬶,W>D3Kl@`! gͮlQFم"FoHhZ x\{l}|wv6G8$*1l0EbϜu*zCJ, @ JiBP&#Qk5ilU4EjIr?ķU=;zeIq;g LD<(w`/*D# 0 y-MCVEAtõ(Q=enY !o#y&#ESg<3 w^ wf P%9|^Ά*)7Bf~(AK MBe xLUPkjlQ) {1Gjj_|f^`6|Yhh?h|mOȖn0dcj&_3`YAvvkS(g܂qSTXGLBo .@7~<^asZ h 5ecj]Jꐦf8oN3x+-~|x 5+FeLH)+d Kzkʣ-e~-s; VM6eW}0 w^?ZG G0IV(d0WLe2W<|xlMKQ ڄBԿP&nE@Xm,1rw_h-w!zT k;@x~|gaw"2uȅMѬn~;qDU+ Y;7|bbKbd'4CcuؖƯיRBqQ%7x`dۊ8ɔSI&+a539´zkLʗm\U^VP&]F"\7y[fZ@^_rП'H/ G )&_8e7DSt39unrr>OBT"0OkMX-EIR,;F,;݌eEnX*ُfr MX$:7 'gDE;ZMvZv#]Bd)qq;qO /X>q QBW&#hLJ6#ԁz&YF4"Mr$%}ieLڍ7Jǰ7so7N`].soˇ(|"{_EX0_ܟc%Dzѧyyy0svgγwzڅ.Oݳж;T+ɠ/D7KYԋd׍X ^;HUGYDeFkZqX_|Mn3kWyս1 dAkc¯iy[˷|qJ#߫<]e ^$䋒ؙZgY9^)MsQ(C@秈/%ese)WP+`繯,EϖPBW^sey _sOYlr; yb1f{eMpӶ0P.ɷr/uKG+ ,\J }n Ԉ ?M0JLXhiP|c=wf-lggЙܽs=wLg$!ĝ!`[*^r /f8 z#҃_J Ơ }>ځipwrq*^OnL~ٵҋGB7J {*5 {vMk99MkYLVc*MG˓dj5UgJC3QZq6gnBD|(9XoTO6>-;4:J֋:!e1/Y,:ƭs"ֹU%R,P.ZP.^Կ. hXd"\ٷYu48p shS?.r"%|s]L> 2ˈڃ_&ǡ"f 0AԒ>mF3 *fˬ2(O@9+ęJ) 3 FyC\3Yэr |@Чbn9^ =nwݿ1d&~g=BZ,b!1JUWWo!;,n5-b#8I͈X24ލ-cXL4}IFzI<1,P̘'ъ,AюFDzX >#67W`:(bf7d3m1X8eY;FڅVۚ;򝴩(zQN&\ 9]81N2st1"sD "EC߃_sÕ$f8dO`fW,,f9,G5wNM|8;Rc4nS3ߜMM|.mVmI'fgr[/7epՐKu1Pw5 '9:Mqd{9Q~=͡sy'_nqpX3pӋCγ~S;SSbp~#7zb6 Tw(RYe-y:/C{ j`(vzGsorsL`!v(h3P4KJ::0(;hZDx[[lU>s;gf:{iwJ@"PHh* .zZE BjJjD^}h`<ŨiX33]V`̜9s?3 ƌA'!=(A({B;Pkj F%F˗n!:e %^[Vk!Ģ?298s%nD7RԜw{hgl'`=N2HSǻ3<u.i|+QyT!z)rQtߪo\Wzu4YفkJ2i[z/w˄ԝ./sa- jVkϫZh{ܪ$MfGҬ2WKC +UWnE_Wv^ޏ}d\X sA nyuugT֡pg~[%m HR×8D9YmZt|16d}15٨{G}~Y0BtuFćѕf'liunSu~T-@\4FA5LUjX WXjsOd&`$Dވ~ΚiN]25ܵ^ 1'YmuY>~#/sqy3G!%6R-[/KYg <"LV_3v ;ԑf UևW -BɆQr *"6(]F[pU9 , Ul)3$”,CAf42i ڌe*QGUT7Y eP6r6Yj* ! Dy]@|\-0P>)eWW>E,\Z"g>3a[ncY[p=Mt1yMJ< [$Sˊelח3ˌ{NO ]3% 9^@I9mdG *SNfxHn$E y7W`FH|E3w|8,K^ ]/{4QC z4g <ף$hRMP q!i;^%JZ2"0ny;I LAa MLk.(ꅁ?f UE"ۄ&rX 2GHn-hECJhi4PlEV4pG/YbO9~?\VxbQݾBsCG|}C~s@Mx+gU.9~EJ3U2-cOeMG^%оYXn_?coZtwY ]-I:^)$I 3fb%g=A*X}&[:5T\QewW~Uye0\^]^ f@ԗe8Y;5B(b^P̛u`Lisvw>o8ruO|Q |!W\y89N1s-Qi1([j]`w<tY6$,f0mq;BgQ*f9S,OК"f ',1Kc27>|ŵ_XOgǙg2IsFKC9c@_uדqPr$ 9,sĢLCuYy{X>nsqx\qˇ]FԦL9쾈5[_ݗپSmw2,;p5t;66P؛弁_ZI5zB`!#ujQ X=^=( ehZx[klUwf:hwA"EM,"QJ)! .m)}n BjBФb;PD"D1mQ~Ũ1hLvvfl̝;~̹wfwABat3K&۰ ~XrG{BT[w~dzGymEd8?ya;UZ[j+X37&{.Wm#ERTo:ig&P`cP&AKWX!nC;S 1>_ۣя/nŗW 퍋Jώk !l^Kl^ryˢm?]c ݧծUHzּ%f_Ү+AY k#Myp%_)=eglZ!XpAf"U7EkP>wh6Z `[_įgԒc:!z?&O{CcnOmBcwcw>^Yˠ*w͑bfr FͳU(='أSҙ1.X_ N{<#s|R+2SV/e9Δ\slZoV 3U(]#OFb{#$K &ylv^_ qO ' $d#[׎l]0BGkXI`| 4'ɚ8b MrjU\23;Ri̇P0QbD{^ D1q$l*^M[a wc_CL~ U&+"#Aks6*% FuF.c!ƤCEij0Gi>k5UѥTWjO?: <а !ޠ\tEVPσ|]L)1Dkym(MEL`ZȀ7JQa3 2 (@9 <&Ӡ G;;.ie9-e%/&{7#_9)Wmvؽfwݯ/'CEܾCҙů/ᭋSRplZ[e:o`-1KeլW$Y%Y?JYu:Ng(TE +1ӡhe+m#~X$Mj^pFhhL+NÜ9%>'HOEA҇H5yøʨdPѤvP4)h(dB$ Ӑw@.d sM^O2b$/cl(SQ&xtG9YB?Ux ǹfa8W{) F}{BP^"P /ϐ'6I,Na.{doـ ܠf; +ixlswosx Ϻ'Dn_q#G.݂wr/}pmxǹyΜd!Ycݲ=Ncwy;6;Y#,t.Nrow NaNw] u r)k>:Db'=D(X}_JJ5cUZW]VEqCN:fiҞ/y}gg>ـf"e5'DzJI{VGC9g@6UIPvR 9qC2LJ6s#k9ԗsQOzg( ehZ,x[lUf潙vwk9nK EX~`\^]!ػj! \rDiԨ GKC\r.wgfͼy}ᐌA7"CxP !:!TY8 F -E@КGo 2 {ȭh_|M){W,  V1nyJخQaǶRoBb8Bicq935#H4; Mȧacaz?zu98w+*W;t]įL:1TDCM17(O"r ̋}[gيU&h_H ?ΗKi}TM4,zaԫYe4#! ud.&Bh=0z+LZZFkز=5Mj Y j6n* dQo'ZhkU MA.Ir4 T XGM\GHЅ&GC gj^GyhΗZyDXIO weAyPS e9Nؽawݯ;v氻זݳ^mm_/K>hLǯ$m9!E0i٣vh!b} ,W%Ll()1@fu,nj}*(.1p2=G(ZTMҤRE{GCʀRuE'>F0BKC3gh ]YX>@G m/W4IGM*G*&gU4 ME-(| &P]d|Eii,(EIZQ4#g(\'^ս*z+,)Gœ|8;? D͡M8}D쥱,(a: Dkj jY \ǜՀp|98=^w~`3>O*GYrOFK:9ɿ@.T F0wl},HTt6o*ᗔ?,=cw8w0}0\;tSWRo;tsIfߦU^l@uhn*{㫮%hnkMl3?ud.ZE?/sGy1/S8qR?:/XǾW+1mr߲DuNj5P18LOҿfX`!iR^?^1_k6@( ehZix[klwf<އ@4wMRN`+8I6GNXHlokLQ.B"# ?L+QT(5JZA$?4KT [H 3z ޙـy3~ߙIqkat%S9b/D0!Ӷ2UW V%Q;+-s-<6łhz&&֠ ,W6ѲvB,˷Ԏ⑂V$@)c)*ZSا=3* wmPÑ",/BΆ³8)ۓGblex.MgZ{g۔8YMIϥI6'OPc{'Oz:~>yE糴,6X=ohHtW'z:;QUModjJ28 Q<+'՝E[wzh Zyggj;!d1߈B|zߓ3;ߓ]qU՞ڙ`kEi{:WV`WtS]5tikt3h}+jivmYU sQ km٬lV05bµ |ފ2?"crFgdJ(EL>/}L"䲮λim4:sE'c2k'ZAAr?j^TBX" \ad[ac9~BEyKڞg)f(!.${&WՏ` cevdճ5j+hjKQa 3,߯ƥiP.+dx1y7y -8 +$4"NYZ.FEq=>k_ϒף:t; u>A 1ђHUØ[x6mDanE 12:>2uܩ[(sY\nJZ!`دYTQg&r繩(.sO3=UE(#=l#N}ڕGvg_w3dyfe0.χF1Qr/>Ssk > )Vd70AF@G$dn@y &(I44LP%f2e'\0G!Os/WQE>+?Wfh FktSf8*EkzzYYeYt&wԯ{e^yS<O=iTB`!vu:xzڜGբDA( ehZx\}l}.wi2w2Pma&bZpPTXkC$@8KWM׈eP쏬ӶjTtSK:?" M] iN[:-{޻wg:;{ys=w>AB!0ѩױՠi[:quƖCGt=n}33PwNѲvB,˷Ў⑂V$@`)*ZS'FYI<~ɦ`7k{ҿβMkLQcj*/T_ӗMٛލ Dkl^w/{ 5z,1"d}w辫Z<3~ 4ׁ—i1V7xּ1޷'=ہbB |`5Zo6Zox:>vS=tikt3h}+ijv[lYU rQ/7Λl٬l>fU-5,[t;e 4+`-':ۥdJ(GLW?&cruO_FLF6ZɅ1MZ #Q9ψʯ`5/*!,y\^92}WN8A? _VQ^Ru\yߧaT_ganTz}VF| RTXCA`MZ@w~?<\'ig;jQmOԘ4$`%u"ٮz_y/ȾF ds=zG`= F0B/cSb%L)YfY+54FlqCfu@܅*hOݢ1B#܂Z̭)>JX'gxC氎;ye.k[}؀3$Z5 R0 ܊I!Ô#W0_i >PܰcWbgz;I0J*? !*viv N3$ô*g!G~bCVG/Y@V֐PDQwe8Wkl{'Vr ʣ| y)w5.~u erRq!GG"\#•zsJKQeҲNh1줖} + Lˬل%Hr2J ,h(a3\rFJdr(I E;[!Jʤh7WԆ-iOwt훠F EyVԊN0Eqo C*gZQ*`G1aL̲>`FE-fq{Ӊ.ԿK Ce^yss`N+`!t*q:XoA( e,[x\pWݽݻK&R\%/G&@@2L6$@.TtlQil`0?:Zv0iid*:Nb hdZ!uqR}{G.w{)?~>l !Z!nGt)YAh BUCɨ!j5X88H;ãhp؏=pmvvk٨-kb?Ly3~BžqW=QaM;=e)a; iy&}b4^4.B+i{!YVN*7.+߫]FnMږsl]*Pw7{(W1ޞ׼",ktͳ!X* l6wvDQfnS0ƛlئ{L28 G^<_ߋ C;.13lƞ^t 5s>1>;ן؅ǮjcroZF~t׆7i.Vo7≯a~sw_KLlj !8!%8g ?G@<7jKu5 *keKuN[6+5{j}xGK5|ކu? XI9Nv1 $zL~݈ɰG1Xt2&SV(QAd?*Q)fD%%2ˏLF& NCOWUT/}x֙kv}{??gS/GTcdAG_f7]z=">SmMm)*bP(XSP':j"&]], I+X^d_o \3ěPku +{&t5 c.fz3sD~^eCj^wCpCW9 PM"&j?Bs:Tv-Ь{,#U-[ZD{ѣ:X[Qs|Naw3#Z/\J2F'H9E8Ynp^w =N;|FZ2966#<@ظ!==BgB3l3$4l&la #Lɕ |Q+PqP+J((?`א7Jvsk,(?#Xe+ׄ$c&(G rEv/-"治fZ 8z+o3;)|hΉ-R4i٣Nh 줖U}+s Lˬ٤&Hr2JJ h[3a3BrFZIȅPv?('0)h x8FњV yqt09h5dvuEuqɢIC8P4TDP4 Mh2"ۥXq=B]MP[>H\ t-e. 7BwQ£EzlOs_p;.XkrXC& =d0H"&(SI '*޳`1#f1(fh60P>?Ps<.r)?Y"\/>970\(c%c'l 1g2gO_g2|^r90.9H?ur[_ٟ˿`׺ [LfsA!N -3i(귟IHVx'O)nE2` @#G;f_ngW}%wBwVmx% )"FMyŹ{i"w޳ݵ7u#oe&Ku'0̲QV{\ (kyOLP>YF0gc3@9nIHQ&KS⍟/K@]R)n;,Wn8,\Z(f9 ,/ƅdI\OS>k |]^{\i=*%7lY(WYEyP^rſKa*%lYfdSE0|?1P_|}N~~V _K_ӘZ4¡ا]L(Y_]ǾWkZ2,{ǖo#tw+A N.IzG`!j hJvƒ( ~C( ehZ8 x\}pg}wv.KHu.%H/GH/@-\ a%^r1Գ>&1 LcaR?ь-uqj叆Աyw7eivSnowon6 !eaѥg)Xj{G*:q-ƞCև~t=cSSwe,X.&[c_;G ZRTO+igT&Pza= I~&yb4.ChOI䑤=: ^V[O$zUjk\Uzt[9;\ l[a,(Oӛ۽HӵnMGVFE׳,6t+}:* v6FдM^jƦ`wҥβMkLQcj*9U]]-( /h-ځzq=M݋BBMwdw3SﻐqUuڕm`kFi&Vo5ǸV1Ե'G5B uh=[v,GE][<^ѝ`FmL5Zy75*9(GBs-͇= ޿j#Łe1oF vHrָ=&'Q>ngɘ N7\ aZ9PtV(Q@rd V~ )Z"s^ZgoB ˹`3,3hNS&lEbO6֡6Xv *PV{Y`k]Qiki[A3uj3V,<au8Ë4(xLwqp֋*J͒.=Ikv^C6R#OfP_gV_`7z=N+5*fx}kʿI>NMP^RdTu2Fi~Om6J}RLVY\,yl73*0 ߺ>C:]6jypz($lvae!~foj=ul0>9zA^0 f&qq]76X%qJ 6MXıekjUh+#o+1x5FC氎;9C(sәZVz V ,{544b Vne|`r1=nGZ3T96f# i,'m0M9DWB“fgjHi s0#&A3$S%LG.,\5r%+EAr?2zNGX6q0g{ :_1ʏEWt;yunrZ@lީ:E^96x՛bD FXvXv;J >ٱ Y,0A,)4cD0 k 49іKD 9DD;0QDjq/qNϢX3~U>"_#x'G4QG,F4k"dDhD4FDt)XQi*Ċk;)vՙt5?cDNx=4=5B/\&C\0/ ܀p;&Xۗ8 @{wȃB/l&d@8IV l lWl ܤ@O>g76X4yϱj5j|~ /m~h`.{˧oG܏n.^ ! |_f2|^r~zmSd}Lv[31)gna{?2˞S|FΖ'cAeRϤ#=Nb C}L*X{Cgـj-)sMzqRo|%ތo j My<e?t/Êsl'i>"{޳Bʑ7"su '0r{ɭZEPVaOLP,%o3uռrܔh^9>9ʑr0=?(A)+K\dye)\)Y eyW4" HY~j_YW SB}6>oTSer^,!}-+k>"(\4A [Tcpy)T^9>9ʑ':u8{S>?9oqͬԘʩ%Kβ8tGpC;3Ik:]8˰mG[Q6We(vk_Ș N?`!Yp, ;q.0o9HPJ|xY]lU>33;;;.KBXօnek0Mm)PiPlK+]4!A$hb0>I>h 1&>Jxb$!`RϽsg-l;e6w9=wDr²IlKG;z38fHtGt HӚ"| [𿹹=Є ,2ߎJ H88,XEZ Vfrr*]X\'ؑr[[ y-y8gB0;eG /+X%nM>Yz'MIJ2d33̍o*zz4kfI@٢ΫeI+µdŶ?dljI=5`gohģ~xf#yؾx&LO"4h[׈jEDc^Jr=\t0FOh>dR|Jϰ4Zu$؋C16#.e2f^L6Pj%>HLcdK"CAV_/(?wc2 >/)Gy;PM|daJVq9#b-h5ÑC9O眆eB;Q̸.ba1sQ;,3o+s=#TL?z<^U^Tgx[|* =gYf!町t+sR^obꟾvu?ZS\+ +ĉeX[.ZfRH_*1ɯNa]]Տʴ}T\'nYqn̒ _~ʽX5>x) +x<ې adqU&eSea*uֵ0>sx54\s;RSTXJLИj Zjwf.^i{&>v|t-\~T~&9@`!H3C rv:3?9HLx[olezwm֍1iY6¤:f`?%[$ ?84Da!@ DLBb1&h#^nmw^s=<1Ȏn%Bj@x+qUIr8,B=Y/z1rCK@ K܊H{B,Ò.gJ!1pA.q6>[21 :k9Z3X. 8oG{)w[:(&,ڽxN>,%7-?)S _WDi׻w_=0>+ϑy,nI̮IM[~T3au{;tEb`J&O솆)qT`xEZyp @kQ>Zo&ٛMk뚾-|BO+T&myzf9*rgp!uH]Fz"hluFbィpۋȘɘmE? D=*Hn: L\dz2dFT^?YcHf%;N-1N]n5f?Y'ܰTUG.{fbrzX#t–;Pp-j'85fA`o7:scpRF`6!8XDqp6iϋ 7KXx51:(@-l?j?ҥZX4K)4. eIsJ8+Qq> J5?e% G#3uQp B~=Tc&E&pܝ` -eLtӾAh_'**ʹ.R 2[ˊIM9-.I_}ISˀr|TIlTK}m>Jjzie&>wr23'#M.)dlMB6Y& d!,dl&?)dlr!;қ릟graJgeq61ܳ+lY݊ٳ7 |xRЊ 7D/rfe+Tq{)sno> vTkӢX#9wMzkrG ׉ I]ApMؠi&Jbt=o5_Y'glSYǟ:e6I L_(R۬g&z d z>mиP{WMەT^#CUX 5vR&kFl@G#-'^wZE8}Ű&:̬ jŨuax1j5/Ũ5ɋq^Z:"T,^߇&7S|o le_[N˦jac~46Ê1jk¤n9uQO%`!̘#ZzS,1(?9H'xY_h[UͽIYvuҎֱʠM Zٺ6On$䖤m( aeO>{He@t< IDP *94i_'{s~;=@0 z@Xa'pg {وpb4C W`+B#oV,~bzGBl:8"X4/iK3^+L[@l s {؇%:XGQqnkoՒ^Ku*W|-T{;j2W|ǥS?/>^bz*tH[!dcΖm7lqc<& Lr8fer`&tuLե *lڊ % ZtD}K-ѕy+e>0c*ŚcZ;t^,;s,UO[5E}Vm=[SIM&}lep4DQFPwrԨ [c♹|Zi30h{ưΞ=lσ۾cutn!oE DBwߑ65#|dfs=4,1R1s- E8z\6{@9hcnv<$'/ux' id y8 9 L1cd£|Z()G"Oeσkul@P-闥Vģ{& <ÝG:TBQHϙLj"$ZJ/0*[WԭJ#* p?GVv>jsB4ZiC bms؉P}zjwhFH-?]k8Sa}[2x$X4vQ^_3~{5S=&!Foa~.I%l=ɖ2b=ׂKk%w7C6K01|&IoTgjUyJئ׃A*izv8g>=3R$[ʸ%Oi=o6 k=#'F5[ב;w|Jn*Ȼ Y0#%=GJŃ~4/AmU|3n/w>˝o$\uI7tI7tI7tI7tI757t{MlIpqM]YXb+kOTM `!Kdry@Xl6eGR XHw .xڽOOA.P( & D⁓X(1͂v 6h ^ij&x 1į`(0)oΖiҬLۙ߼7uK:c ZE E0`m V pFj.Fð`ߕ˷ MHO, xMORY*@AvӰRͫ3!!J;~#$a\ >xpgݣnQ^Z\ar-Tpǃ*}uGϋ? Yx^WgB %lٶƽ]ɴ2 w29_=G65w*GG?UҐ-%㧱 ULzJuùE 8g\kUvmiw[njvK%:ʮDƴ =~ʹy~"nG1x*[I%~TX<믑˜^9Ud;fVʀ0]쟄ڸKof.o~qKzu#^0xW *XT55UOw] jS?͉යo&aADVڝ(NGR;i2PYjg3ё;}NW`?O(%`!҅{>T;KX > XHwPxڵOAǿ;[b Gj"ГX(14 i h 3  ` L*$ͦL3;o߾y̛vVu1~7!4a3E4WF0R 3Ѹwk@Yt741i#4F2A%Bҵ>P\[Z&覗#f]Ia}O5̍ Ssl-6$}VR*ELH1n8^80˛:r4x=;ŷ&!%1M8@}&PoʝgŜnn!8iKٙ56ɍ=0jѕ9+S6Z[׉`RWh݃`!Iv40awWs̮zR 0X(v@xڽVOOQ}B 6JƠRrh$V%JBfb6hK완 zǃ`4&u۷E4kkovv73o^4HW^*.>" AB_9)$$ a~. I|Wރw!^ZFz$$AAR|"a r)=݅8 i q?"*4=vYhX嘫5"Bmr qU'_H5ޣ_ O>}+g<=<\HXm.Wm+l7>sCszaA:3yT~P=56ƕ?4-uŤ?OI}fa) + >ΓΉȖ]N,5 ~HolN Q r3Eu; kP`}L捸HuVĕsNh)5ZA'Q,uHqC;tv|ҌGEL,1:Vک*},1ii 3^6Vڈ<۟QLn9b9:C쫨\N1?_wYә39SeM_@,7 qe%jY_狏OIonSC([gvi?vWfꑷk[X5df&Ϛaكw3 Ovz<>K!9SOAN/>3᝙ԞS&8slTF/`!w$?qe"Qu 0X(v04xڽkA̦M~-CiKŏCO֨AmMM6M!HAPrЋx+xB|v6MNo߼{3 l!A6!fw"_t3Ȣ,Vs0d2 fYq 8^,^:@V ~v&JVF!1I |""%/` ozq<`:5;"km>}47}ͽk-imXILOa T|*[Fx\~!8~Pkk~lLk`!%⏻Zr8]0X(v@: sxڵoQǿｅR~X(DIj iLi Fこ7d[-,AK5KٿgĿAc ΛE6o3fggf?;$*Y#B=@`3<[ ̠'WX{u$h woj8'`ʵ$@,𑄤-3圜k:O/!#Mv3ƁQR]qc5s#XcW8KH|wo?ҹGnkG_ 8Oxgrr{N'eL*5Z5;Z/H+~(&N~d)12U_XrX c֝xяCW+UEҫI|0OJ?h7[fYbX_ʖE:vDZƙ]ޮJeUk^۲{Be$6)?iY4_X5x7܊Η14[M+皎ǹ}ʖv9/FtW+57vsȎv|f/SHwgWԕz=!❠;Cݷ#E%e5t>MMϞuL? fSl ݨ `!;͜QjG̙ 0H4 xڽAOAZJa6C@HHngMԍA|0G%s(U*Xse}M0<ݝiSdցQJ"\GI{@d&vRvh%ssG/ZoY9?{1iyq}zke{ωb!t5=ey+[mb?:#C2y귆uI/R2sey^bfأ FcU+s^~>a;ێBi1M$?K2mkrgjep(be'kx֥CMZ;ażTmؒH ?.[B{wkRljZuZ0ک˚TO^hf-GeU㼙tFp%gݰ֝i03.;Kθ4 ZzPD!~뛉&wcM:ޤ1_jyJ}NUnLϑ'At:A{|O;z¸Z^"yrt ӱM_x=n,i/\Zi~l;F /}x-f_^Gƥ&XDd !'J  # A3"2A&BA J/ZD`!A&BA J/Z` hBz$\xڝTAkAfv&dI#4PmыO\Lh &z8HxڵVOHa3Ό.l4LbR`$ՖJS u`SPP:;5m+~Û7@4' 5h] @Q0X pJA#<4ǫzszިia^C u糐ijdEK4 B)W((60|kT%+7_.rp^5+*lOghY>_}1ο*ﬧx6+S{S ʻBO =ݚ5)LͨZ+,y2Z95_}jλ35+53rL3SsROߦCLf(9]˾t WKgÐׯpCf{mp*__@d#Dd d J  # A3"2sIMf7UO`!GIMf7Uv@ @hB>`PxڵW]hU>3sgg2D҇`CZh*ik4X ڮ65 (HKbE_|}KIiC|,PHsvl=sܳߜ{w! @]@GW8LO8xYĘ~f7'ӾE wqHLX @Zف&ɬd F>)zgRנ,Xbh+#M 'zYwiwUZʹ\P\/=WNu0qg=_/zJI̔NT.ߝvNCǸSasСߪ|S%3D:wGa[EQ(ϮF f|7aWl>7 ass =G ci64od%?<*C= c;P!e$A~0aTJXmM ٟ&xwz5=[ "JXDKfvpNOȺ xc~\x'7b|7i59ataܰkj?|#d?H_,"dY.9j~}S^Ĩ,{e̦2M7۫wzu}WW0oc4zuͫ87gY^Oz&[gp{ %s Qĺy?!,ǟ{-2pie,7HQzȰ*o YLV"^kE*geC@4bҊk,"1㟌#$aݖد*>r>ۚ]du Ov`yDno"ÛV'?EraZC4~‹'WEWrmحx~YߞrS0{y aSUڷ:MbN7m$$If!vh5 5p5#v #vp#v:V l05 5p54$$If!vh5 5p5#v #vp#v:V l05 5p54Dd lE<  C Ab-Iඝ5G.@y^ AnIඝ5G.@y^PNG  IHDRk_egAMAPLTE """)))UUUMMMBBB999|PP֭3f333f3333f3ffffff3f̙3ff333f333333333f33333333f33f3ff3f3f3f3333f33̙33333f333333f3333f3ffffff3f33ff3f3f3f3fff3ffffffffff3ffff̙fff3fffff3fff333f3f3ff3ff33f̙̙3̙ff̙̙̙3f̙3f̙333f3̙333f3ffffff3f̙̙3f̙3f3f333f3333f3fff̙fff3f̙3f3f̙fffffffff!___www˲𠠤X"NIDATx ,۹o/9ÉRU.tT6)@ *i2f*Y'W,ձR>UbPJv.28uP%m%=N]A]ؓSuiCte|u7d\Ih]m:?)TU?xR\'_ _`Ji}ӳzxCI?eMLF65B0 @Kxd c^_o#>܅@./Q_}cC30JwHH5ffXn <fO+W Cֲ.c(<<8TY6Bu5pu.٬$d?KP/sf54*y x uauZ섚18%Ś@gq"CԜK_R8di`;OC0>kj.YN KciRJ|YyIqbnjޟ_z1j\#['9U,id8P[ Ҕ"G4ԦԧPϩ|VUc~WM1?7EVQpSXA =N]o2+J](TRYDA*)#ԫ ()TRP{i/g ڽֆ S {P i״, ==SwhrmIt}&ASolXV 0!4׍;S =ȭae?p``C%+HJKkJVe2Pq9cԢ3|P3XW nS:Aʹ;lҌ~¿zpC>;i')h&8,$ݪ酩;pY_Za%U. ?7Ɠ#~iRFtӴ#f0ʭQ>p_T &;SgR\f6ujnj<g(AlfK5Y=8PcY]wP .B`9|gN vX؎11 ڻI;JIφB,ԯvq#J~+gثqKQ瀫Znrqլ(uёB(*P U"Q%FDT( yqˠ!Ppy!u2Fg !ijt~4ڵ/T j:~V!:LNČ<бJpCҠ\p#Wb`'_W<:\c kҠǹÞ+~FSC@&|&e4q ~?@ӌzqM9`|MD;:$QjR?w)OW),A}h0G3P(jRULi%=vx iu4= A-n Tzv wʾ0Bn"1TK*SRKzZ cKM>[=Ar.Njg DRD:vq@5yMwVkP3k&c^MT>1Xd[Ԅ'4AB.jC%NA —\7¯y zT'IրAgƲ3PGȷbR mgԤ jZOsC9=`'Kh .qpBaX*c1(s.kq~AL30 *CC}<>QPǁTtOke,2Pn.@m~) 2?=ԦiR9x6ӏ~YK}<Z"T`yA㧣4>KeFMm˜{\(̜ڥZAUȖ` ]uהR3-CҎv_Z W'P] >iXiSYPaz0Թ\%iNZmT+oԢPC΍h\nd|bn P/Fm`z1ŏ&LzkyS|@%݂A9FP XMt%}I򯆤P P&=I(TKDIWKԠ+I_:dCu] $#i.B:zRW|'<v,Y0H{蟠 Z]_ֆL&,7 r,u^@YlJs3kv#Ԥ6843-X@ӄGLͣ^ǩ5xnlfG'Ơ">rGRz>r V6BSle [୤T@%aBe˲[^ev>Xb1FOE@^Tfv-0,֓3ֲ체B[jDTc@POx>mְ #cyeKu \ʮAYN-uq-MM^j!O0%Jt rR*2u}EGR ۣqY*e- T=SԮAKP ҋqiv-vC[1UԦ@CMl%SPλ '#X`@gfE649n_tP,9Rj˺AGp;eҭmI,AecR}'Pgݥ:'|]PL-%MAR9=>--Vbsx7-@V-;39kS9KePԒK]7Bj]$԰~'eޯ5Lrb937-Mkʎ65}!?ShPE pbbP4R31 eg]o>~Krf Si6._d2g~:P(ԩTHΘXXr2ZV@]&uUO C ; ) Q*&HbmzˮCX~7n`4 3$t>.ħPCݶB)R|.']/Q UljT24@IlUwP%m*B U@Q*AH#PB }(( B(*P UTPijE*B3eAJD&)T!Ҏ@)T:NSk^ ۆ wK6wc-Uc/N}䜧Y_\\"743Ba-|şk`8mO]HZG tpE u낂cm|ovpfW/% "w0$\E5BBWd6^8w p,jc25zTbOI? uo#Z7%R_$_3>p F *kBUoݽ7/_wŽ{ϖtx c GeB&S;Su#&(*P U@)TR=[ a5[y>oAϩx2 mc_ [&j I[#<VksPWm}N~9/˿\>pi.^{?^gZZPX{'lhBz,eOCE. QƸ FCaGś&wpnj+>_d*Yn0n+5 *U&YJR5~sJ~1LECRPJ B(*P Un}X.Δ6c6P)ompqt>VK^ FHf_$YyB`yRYl8R_T5YnyTK*~YXMW]>VdHY}j)T9T'*P U@)TR%Y'd?sz ,mݟzI ?nߟ MwRݑAj6O ;joT|\ Z*8ZoVn`x5r#T~ui'5joL{ړ41UuTRPJ B(*P]@]ݟjRPgJU5|ۅF]AnI؟jՖJ[UMjaIw*#P)TRPJ B*(;Q7RBvP7IvdtݼwٟgׇT ֠&wٟLV۽_ՐE{[S u]QЄدas[-OUv:P$PVEo*Dp;WtO-@ݹ_jկ^Hc*z9pOzW36qGߐ6 媃:(;itF B(Tz{әMLKU6U^$Ty:TZTa B צ% UujU)*P UlReT7n7lH2AEqwp*CWqwRNTzy^Dt T8ر~8TA5zy^D lJ@:w/8Q%P͍^P)Z-6K6M ~ot;" lHrP/ۋ6ArcJvOW!J9/^)fA&α޹7)WkCsb)^/P{ضHգ@h_ϭ 3CV(W{IQ`-Wi=\KsC{1U:뫥nj#@,ž5 iz;0R2aܛno&1 Kks%y WKc@ç̠|ԪKz݊7@YG3jZ`RڻUW;/eLgZETWVSK9ʉmjJaȨMFگVz|C{ (̌s Z," ӧ9Å[ !ﳦJF0_q]ȏRP{)yq U[r'Bm($U$K6"L6B{:!ҕZC-Q[tr[^pd0*X,$ ڮUQ'\͑bAV--=mjWzvȭRTf fY*'o V+Z|Ėo<"j˗UHYXYԒd<+UK (r.ߦs,Q$QkǨ,j=eGIdP=V:j}L ן:ZKrf9?{}-^K}!~fwd7цu`o^zkgzwF#d^GMr>|6ʒh њ5eK\В˒^{\VɡAhc4q*z%6.ﰼ̥ڞTcRJH)~gi -rtpC!W+y(I?,kc4y[HdQeV1_ D9)!>:<ťxmcDG( M1=_R6 RQ_RDt%XɏmS -alki׶y--}J26ڢ-N bc#W(0RlHl5O)SkEwYmUZwYOrfUKhhrRA{U2M6 e }B9S ڥZ\Y5f%o4!muu^s{c:r!ZHʫ8(!ļu73G0 `%+3{{y668'#}w,1kQB<cS5Z.ua ]O) t%H+$?hM*{ VCXm^t׊뭘:٠m@^mO6ڢmh^vU(Bh'Fq4b]$rd_;U7fzdn}6jtNv.絮W~~ڽ+kњ-s~h.ڞTvȴmiBr+wGc:r!ZHU+mV=VZ֞xe^\HL6#| 'vQ?']O)e=S嵕'>]A2`kAS9 :jO戾'~F5嘯'^nN=lThݭt5iܭt9Oњ5+GkV-)w3j^tԢ^uOy3G-֡Y̡vw(˼\ԃI.:*30[U"aXuZaK.48(Kzs3H>w E=´ cuYUͦ%E\'ky:/`쑋zhmd02^yYۢqzixc$!snHn_K>r ٨ DȲLlZgO4Jc {Dlh]_5+@2&*uٓ5ٱݻ"0d|IENDB`$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh5T585#vT#v8#v:V l05T5854al$$Ifl!vh5T585#vT#v8#v:V l05T5854al$$Ifl!vh5T585#vT#v8#v:V l05T5854al$$Ifl!vh5T585#vT#v8#v:V l05T5854al$$Ifl!vh5T585#vT#v8#v:V l05T5854al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh5T585#vT#v8#v:V l05T5854al$$Ifl!vh5T585#vT#v8#v:V l05T5854al$$Ifl!vh5T585#vT#v8#v:V l05T5854al$$Ifl!vh5T585#vT#v8#v:V l05T5854al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh555#v#v#v:V l05554al$$Ifl!vh5T585#vT#v8#v:V l05T5854al$$Ifl!vh5T585#vT#v8#v:V l05T5854al$$Ifl!vh5T585#vT#v8#v:V l05T5854al$$Ifl!vh5T585#vT#v8#v:V l05T5854al Dd ,35%D  # A#" 2= =vvM@ W`! =vvM@A 8~hJ\ x\ lGn:IM 68 %Kk%9SsumAm-DVBC@(?U2qCBӖ4 QUխT -;wTQ|ξy3{}31d-|O<>A  0k, B-Xx,5<[7U-XMOTF iVP&7-W:­x>G\Rٗ{Pg[ǻP^BuXwX!%égR}uxс:&Բ|)%>SxRU;Տ8sxd2zE*,ɑ>H#`nuG֦h;m~ŗ]٫W̐JL ) 'hnJyR iG6 yI=ÒR1DY՗{bPnl/(5{#FgTl:#${mՓq#-afDvй!{p0 ׀;z$=$lKc2ؖW()4SG ̟Bh ipQMtŋhW;7@_@0~ʝmkPiu*i` :Y ed~]wg5'v^Fzyuqdh}Cu]^چ:3]@+ (W$v_"~{՟#gUtKcXZMP42ݍ=}v#N]zך6lԃ0 lbbqi]L6P t3 ^>zskuf[Ql]}DDZeA3u7`oA$iX+5Z ;}W8^v˨&%4 I}tlQS*.gqFXiɦ" ;DAE|l[ƶgۢT.JmhqO݌|`MDpNVvۄ)Q:r&O9:z8!G^^u͔#*Rk @IcjK_$7$9 # sTf/Kfh LH5e ^YgֺkaY* ֛c~5,?zW5DڏU?,ţĩa?DKIRKtRR2e:"_̣ }-LE3ŚG=c=WDEx.s@Ci9L}ĕ<^0Ov_twM^Ht}]vkӱ=H"QqLh˹MԷu hbs4+[x)Qs9gِG# 㝵Ib nI2ouOq "lYd;#] SQW!Qu]շF1=nqߦ>o0Uw)9z`+2=kY'6{8f/YپQղV6X){6_q }e}q=5ij {/?;w &!#B^ګS8NJ)Z; w _˓d"=S \p\S {jJ%'7ٹԹ|q!N컞)nuf#;#]UwWo w~P`5`z=JvrC+6ǟ"Q"1VʘP[ iD塱5U Qp2פd{Rt͗r4EC:V4\Ԝw*]Gj-[Qe1#fԙb"͊ɸ3X*ޗօ A6~tF{: Fv#~|[q^1<+y_Glj+11fS/|__;Wkȗr\3|Q[;JFk@@᜗ǖh3O Lu/% $8hC4&e"wLg?E%87?gor K7'%:*~T +;Zҵ4_c? 1Cl0^,]~иAczZ4Zy9'7 NhnhƑljv urn-pvBѽU,gďKb(YՉb[#}Ң;Zr``5GQA NL v8 0W;$*Y!kylQ2?]9M)iZUi)@[1tG\5[PrPyZ^k)o3y_k}Z3,{~4%)o2Wtvˮ/ w8\CkDd D  # A#" 2kF!-0_6Ҏvb`!kF!-0_6Ҏv  0= iuxmRJA};MBEPE ƠV-8-V`!`a+ Zpޝw̾ynvJ*-jh b407Ϩ "A-Ǖ5[hbދ]`_EO/qV+EiT"in-Q:j$ҪJ,mN~܆++nlZ(9NϮ!gMۮ}v6\&h%'8"r~gKQ8zik<<>CyY3ǩSm}pKqDJ:|%$FEG~*_칊hub<rrSWJ4˚Įߏ^B/Gx 7YDd D   # A #" 27^5| 5e`!7^5|   0= bxڍRJA}Hš`Ejo 1تH AE"~"T8gvΜ(f`ogf߼};7@ `ʡ S`6 Hkh.,BJꡏ+,6Ѿ}h f%9-ra(,H^l$d<^VP4}h}KLAw[0iiBL-kZ"i8wc]}ۡ5l>8NDX{%{f2a97YlntJ׎{G8SS w|7ފ(L\5tCQ2M{gdd|ugR7S(^?RKLZ9pR.lt6O*֙.ߤ~qK:kt aeDd D   # A #"  2B">©mg`!B">©m  0= bxڝS=KA}.?80š`Ejl("`mge`TRٽ;bp`ogf߼}7+փ2 L?Ȁx h&T\9 qQAu\p3h-<-!(@JsZO ze{Y}c$hF}Բ q-R_{XOww/O[+4:-pdLs50,Gwf0TݪBWk877{SzR09A=o(f Q"Fɔ[_+UwQ<(N?j%bvsn 8ꅔcKfo9M~xIKbZmkDd D   # A#"  2kF!-0_6ҎvYj`!kF!-0_6Ҏv  0= iuxmRJA};MBEPE ƠV-8-V`!`a+ Zpޝw̾ynvJ*-jh b407Ϩ "A-Ǖ5[hbދ]`_EO/qV+EiT"in-Q:j$ҪJ,mN~܆++nlZ(9NϮ!gMۮ}v6\&h%'8"r~gKQ8zik<<>CyY3ǩSm}pKqDJ:|%$FEG~*_칊hub<rrSWJ4˚Įߏ^B/Gx 7YDd R$!D   # A #"  2V] g"2l`!*] g" RZX&Txleǟkz[ 2 H@t1-,f!)0$Ep&htD "bө(Ŀ#QHXͶ䒧?s{"@;hT*` @K/XY Z+OLa%2Lpqu##@eЌdk/k RO sf$Z@@3"j.g`/U1VFČ+k=IO;fU _KGFۈka1c {tk:֣ mO}*,={JHuN]b\- ӯ{8G_ׯ{MsIWsaBfs}Мo/lva~7R>dï0=r3ۋIԎbcLR_JdXg_ 4j aVY uuZ,יZM4 Ε/W=ϵ]GR^7;h]gwng[=y=|7/c}.V[{%vqA8 yjI 8zPe?b1L2G ´kiɊqėG,VmlnnA |:ӽ:ԽzNI% /VA i."nE£ e$'Uo'S1nVg] A->35Ra=ڂC4S/5x1;'F; zLڹ4YnhGh1j 8ym6ܥMS8|{l+(IDd 5%D   # A #"  2T'S ?<1Gmqs`!T'S ?<1Gmq0 b$@hJ\SxYoLE{{{;S[6MkTB R'YiTN$M6 i7SM+%?b0TZ11ibz&$Ԉog ˻o7o1 p?( fAG 0(7pS ky" }p`5>z |@~qmjjÚoQ-(GQ&%ջU6K.Foo6B)ŊIvjVI@ԬwMS:l]NV;G9ԞQ~Om-<U ì=B ʕTyPZOtc>_f|hC_c~FTPُbGDY̝10Vb*](v1נR<Ee@8C%OFI/*QNQV ~rZܰLvkeB! 5>u=x _{z7sN|@YxdNŬ=<玗;\z] d5lÜ{Izd.5*:w/EV>Xou)\Ÿ>w>/ZaMTk$]˾cIbm]xѠ?rmv6J/7=uDc䤚)rPF]}{E pu'8 2Leۭd;6Q֓>$;ELtP#z3.Y.}DKsEG%볼,蒏>>q0v8{Smp|69-Hi$_BnI;͜O'Fb+c4BJ1d˻SIIs$&4>[q9c!w$0d;ʟ:&98K>z茯Z q .z[$ <Ϗcjr9 Q Dd 7/  >  # A " 283d;y`!83d;pc0` @-ax]mlۻ߇$]9u k4EClǐ*wȀ \ABN H uD+!$""hTQB,5$Ξ5%kvw}"EB*BvĶ&(kZ,lQd,T{)bO5"v-sJt߶L&EPܛݎⰿSsjkv-3ya2JܮDe-5d"? 7,< r[A(?]{e@eD,Y֧ٹ:Y4=]@_@9=$;g#ğڽSv[mfy+SnEˍ' N&-Q._`^h$8Ci AI4W;Ujj'A:'mE3)x{:, K9{=@yʳJpSg44Yḋ$G>kMfH3P/v"OCvH(O#xU0iJ8a%}0%Uӄg6! B3c~K/T1BHd0^=47^bc@IA\( E@ .I!kHd Hd#IyD0JQIP p2m2)e1K ؒd|{EC(y!Ya<JD # Y*Fq<֫bx*^0|1G_ywCIkz9;8v ·80:AصfT6̘֯P*uRvTSٖ;,~T1+Hy׶h`U?%GޱpI}Rѷ"%v\Cnh3v}h 3}7 xS#[ȏU$oK%-QNMM]@TW}oj r=T7 i?wAyQ@tU[ 0G%etoM \#+g=ױ}'Q {C! |?.(w3 sFmk` DnРyW<_gǂ翣dwR͎ڌ~:<~mN2.+vu1X@ҿyu]VA& -^YQūieF'eddUKSn%ylDؽѱ{sZפQ[3 xWw߀Yyfg=_GsKtZ_Cѽ d29eBoç ֟JN; Zo*G騝kSqH+YNb.ww,u9P%'= 8GhS i5e&m:-2N֮'q?H6r$GL9'w{hyDm62oñenϹ8GׄWeIGn؟&'YČo2=c|\*2f,{1`'vA5d pa{v҃5iR祐\'|G6$|dC#>Rʣ8T8TX"ymyƞ羅C1v}Ua$ $i$.o@7 ^FDA#Fڨz˞S)aǣhu_>Il_>  # A"2G*X"1:e68e#L`!*X"1:e68e\X ;Ч<xڵYKlEwvjKLvnԁ*PIP%ŏu4J= z Z@*${ !AOBTA!Xn&.wf2|v|}@mx>X 8 06Ce3$m#lD]p|$lp++GB=b^&*iah8N<҂Z ڟ8 /sqLOﱇBڨgkz1cIH]K[d1Q.QF4RSI=x.Hijsj7٧\piV3j.5]6Xjkùeye k6ݘwx!filDQ](2qDדZ-U*T*'d?bӕg+|-lu"1c+.rj6 J8dIC־a2W*- 19o:pf |Jӕ.F\c#7܍4 V@a-`K?k9O˸&ST>Eu1sz윐8ke 7~zs.Ɔ0! M [F}}7E$Xauzm~~T^LE"0׷aiy>8IuD, ,vr\7mPPӌ׳}*m\W!]]Src+V|U]tX51^>4W^Χ #tyz]tX FX$d^qz2g05Դ[0+f#dc2O˻Vkj6?ڊ)Z X\KJU4LNqvWQ -mI޶^ua5 cٺ҆*4hjE{"lqwa=fJk2ݧx";k-w<5Qݰ&Vh ><*{w-|)/}m'y>aE >bރ}򐧬Gc Gp ;pӱHc~ՙ+XVKx+ /Y`}QwEA]brhbE)_23]e.?(7I@bkPqsWAyD9GԵ(W- iڣ,ko~vz?ж{?֢lfEς]ֶ kmf~hȾT+soGK)Ư$$Ifl!vh55J5#v#vJ#v:V lZ055J54al$$Ifl!vh55J5#v#vJ#v:V l-055J54al$$Ifl!vh555| #v#v#v| :V lZ0555| 4al$$Ifl!vh555| #v#v#v| :V l-0555| 4al$$Ifl!vh555 #v#v#v :V l_0555 4al$$Ifl!vh555 #v#v#v :V l/0555 4al$$Ifl!vh555 #v#v#v :V l/0555 4al$$Ifl!vh555f #v#v#vf :V lx0555f 4al$$Ifl!vh555f #v#v#vf :V l<0555f 4al$$Ifl!vh555f #v#v#vf :V l<0555f 4al$$Ifl!vh555f #v#v#vf :V l<0555f 4al$$Ifl!vh555f #v#v#vf :V l60555f 4al$$Ifl!vh555f #v#v#vf :V l0555f 4al$$Ifl!vh555f #v#v#vf :V l0555f 4al$$Ifl!vh555f #v#v#vf :V l0555f 4al$$Ifl!vh555f #v#v#vf :V lX0555f 4al$$Ifl!vh555f #v#v#vf :V l,0555f 4al$$Ifl!vh555f #v#v#vf :V l,0555f 4al$$Ifl!vh55k5 #v#vk#v :V lX055k5 4al$$Ifl!vh55k5 #v#vk#v :V l,055k5 4al$$Ifl!vh55k5 #v#vk#v :V l,055k5 4al$$Ifl!vh55k5 #v#vk#v :V l,055k5 4al$$Ifl!vh555f #v#v#vf :V lJ0555f 4al$$Ifl!vh555f #v#v#vf :V l%0555f 4al$$Ifl!vh555f #v#v#vf :V l%0555f 4al$$Ifl!vh555f #v#v#vf :V l%0555f 4al$$Ifl!vh555f #v#v#vf :V lk0555f 4al$$Ifl!vh555f #v#v#vf :V l60555f 4al$$Ifl!vh555f #v#v#vf :V l60555f 4al$$Ifl!vh555f #v#v#vf :V lq0555f 4al$$Ifl!vh555f #v#v#vf :V l90555f 4al$$Ifl!vh555f #v#v#vf :V l90555f 4al$$Ifl!vh555| #v#v#v| :V lx0555| 4al$$Ifl!vh555| #v#v#v| :V l<0555| 4alDd 5%&D ( # A'#" `2,;4 d: bC`!;4 d: bC )O诅@^xZ]lTEwPKYnԶ`B)[[ny)ڲm-]ljbƒ64ՠ|DM )!ƀ'b' A)`RܹL4f̝39g Ȏt! |@٠Q !Bc;a##Dh=HўP>Culv EAG;(Dt_Ĕ=dT,/ x] 5U|z ɂV(c7o>(EgDK1+k=4a+,K>Ia^%qQ2z ӯ2(o>|ʷm,}̎q (_MpOd0;(21v9&S2976U e& XN(ux;C @^TOlb"׋Zsf|LXh /ӥi\^4wk(w/Ix%E MtPu zZLR)tO*x] 7b#M(ڊf`vp fVNذ>p41i&߭XbXZ,UJqЉ_ "V͢8ol|9+,NE-__I%"cܔOgS{<1؆8X.bMfb|,ˤ SG'u"÷aBPvcR,86DM/{yC;0|y{$cDeXWp޾[ƭ`I'Ov F0Lņ'sYFJh;9q+o;8FJ* jvǀog6 55PV+X+>jukcxxx}_ |j}:ĉű'3 9 g6+!;o[S;o&Ü]l>6l=T/XV(|bQk wm+>M??O%2|`Qtgi#ҦհseOfD.iQATpcKo(\k#ø}ҸZwjZ<5<%m}=7|BA}A1b%s8Cyѥ\1̭jGH ۷Z| Q0$sksq%E;ͭnY0afU*G-0E^^Jh mvF*yLkhOCMrS +JOMʊ=ĺ8 ij=, m2B3j~?wapjڷ?Ó([WOF8?|G(^ta. 3bH"FdFRWBN.ӍBc]:i4), J6]7JHx`.iIB` }w,6m:, wXRg1zաN; zc9rr^w;kx}pQ ug*jYkɢ|wc^wDb8OJY) UNɷcxd(JCpo<1<-e5H+հg𿬷"ĝMBP?ե3POiUg^icN];jN6nmPCz5~S=r=dheWAv޿A{i,9))OP=acbQ`,hnv鎇[JRk+=jE+ I=T$ svxL٬ A+r}`E!ݬg-9s0OC̛D׾QDd <2UD  # A#" 2xx} 4;1&k`!xx} 4;1& ) `|n2xZmlE~wvgw{4XCH!Z&6TMLJhZ>94AEIh񣆐+Hb!jI,Z"D㮽ޕpLgnvvwwvW2@d `  ^G7`W*o'f֭+a7%xnll(l\fTV@br\dZUJ V´_&޺Zj!ѺaK!浐>znJF}QkQ`$,`\/qezJ'1]0c](+I}M4??\|ﺺ}",u> GRj+nI]JtSL~؈y / IVɲx!Ylin2|`ab薮x0αh kbif].39'^΢-@"s>nWVV#CXv"|Vh/2;÷2pGbypv[:|ܦvpZqDgzNP6"-.曘;ęWյ($DlyM\kK1y-,51ww^2>rULO25}E-]>͞!YL-1:N%P4[7EB(Ѫm k2-4}]7yFc*utd@Tq,3! 0N~~%vmW1b4ø?=}% Kk>h!q|Q$)U, fZ~J樄 (pT|4G>!:a"]Nbt͚_&K4wr֜TJl_%CXg0G_`z}j/-bB3.iMZNvV=*56u fSkele[ŏDz{0-..hͰ獐27e=ގ4um(ʫP+i yD弶Kޮ vu}fO˟W\ m~ΡStOR(n6Q^*QZ 9Lz}LvwcG*;QRͮ(B{vgӕRr'~[z$,=RvK/mjq_ŕzDu9 u&X!NKצ}\Xwծ)`WK zVٖ7ӧ>|-zƧ6P\ocsC9rYv$O7K̾y]@77c{я D[4o'6ңHJ`&HC1YE'b?W6f+wc8)7a^KʵQZۜe6D' ?n0˵nCwlW_0/ 2e Lk(cnU Ynp4,$qϏ|YϏVOݦvI%8 ,q0|l#vk< CS`rl``!&VDd r8D  # A#" 2A*3\?MB>>]s6qg`!*3\?MB>>]s6qg*P .)xYKlEwn\;ISH& 8DC}dV خ]c'XHUJE B*8J=qDr$_YN Jx;^Ϛ@nO+'?t@6$wla3D#O Q*| ]0 !@5>[cD{1=%A 8"Xtѐj/+% >2k۹ا,Wq{>7E6KzY^QJZS8Gk؃%Oo煵;XhZ^/1=tH[!dcl Qh;LŲᣱ\5|%}wSfoE[%ش/t(Ppjn5+ѕ7` سlص܎״%9M:s,UI[t՚HlM5α&Ov ՠ9aF g3cB&K 0G0F|w@OVʔ9È  # A"2, 6M.˸`!, 6M.,XxZ}hes_r\?bNӭJ6ciY.nm٠`fGinv:(c?с"L無cp+uȜ0p:GNG+iҤ]{3rw>ـ xJ6K3p['9Q[#xwіeEu3o#`웙IN:ډG?\iN L?aTU2tOT.l[Y[-Rs֕19pm#y2=ϡjL!T-+7RNcĻ1'@*yr@y.L]+ΆT UwƮ[+(Ui2D$:)VՊ<(g펬dnbݢ8e-eve-j\5l=W:8# $jEqeGz0L8`]t7DT!~gWֵ*Z~گ'xh1c(ƕ*sɰoCJ"dʣ_CiȲVs5 24FIWg[tVe_XIiT1͈1k4'`!Yj 7C8A ytͱ|ё0$^ĿDYq8펛A±~qLzq^JWs+J\$.R'"Vt/IG\~/cҨԾX.OT.;DP3B*΁؂0o9m0YqPj_ Ů̞[hlZ wWc֋s<է1 Ǔ /znq'G0J@@3h޾%~1☞SyB Roj%/<-g2㣰rjzc._9V.Z#M&1o2>LEM7d$eb 5Ȫ J?{wm-`0x|z{6ıĽTc;W1#[xMXQCΌVGŭZb@xB+ݟ _h>V'ͨtE'R}EtP,~Z'˹\.\~/.mǗj<|[;i!Ax. q#ys0mtӳ)ӈolhVtN_Vobhܯnx/Dd ,$}_^>  # A"2 2tq~W(&^J`!V 2tq~W(&D0b Y8?$xWMh\U>{߼~3$FK 8ѐRR"ѦJ`b33tBA A$(PD-Tt؅EPa^kd 34Nu[IdddxLEFkp3p߆1ю3,1;yLAm FFbGE,[љ#NҨ}Ddo[thӭ5shG%wN{%<+l!?5EHZVMzK[|G _-L/>G1  # A"2|q*)"X^`!Pq*)" [h x 3CxڍS=oA}q绳-;Kt@Dg KT4F \8F8ERQ"R"D@.MZ.D hq]|jnfgμuU.Ne[A1 PEXv5p"tcsy4NYX,֛Xw#HPULE_(:yr HN4[u_b5TX-H[S%F>pڜ!\v)!>^E)E׀PW'w|? =XoNG!,Gͩ1]륛I''w{+OQ`~SGc5'ޒI磝`,iYnёKCz|(3e7PUT;Lt5R5xewʍtc3~: QN[8:Ҹg.zx71yS2+f'엠`>ܑWe\Ub}W5.HHyvq{YyRp vS Ds 7Dd 3 rs>  # A"2GO\<fHD#q`!O\<fHD+h CxڽVKhAQYMЃDJ`NYI`1͊IzDPAē^AM<AAZӳIVzjfH,ԈlPEQ(f-8XmAj4j vu%af!{AH Cxv(|^MR[1A o(5t*LgTR9P:ft8v ӓҾⰑoH 6R!b쩞JP2}G8_{?~ e~㸺V-TT=J=C9w$uSa1bN"&3+cRoV(Jڹ`T=]7?-{ xORUa-ɾN+#R,hIK*U㪓}L'Z`Lǔu< jV3:ϋ]SQeOZmtQwu9nĀbk,47ϔeApFi{ omr-9,y4YxAk ÊkVd9K| w# ^9ٞNYޑiRU~G?ӫZQ~@LU~CkJ]ji 5uyiN^m[ p6!ao,rWV<\qYE.}l [ό9GjQ=ܕUG( %TDd $*{{>  # A"2{A,bJ`!{A,b  h6dxڽVOHQϛ7;[JP BTm*A+5]KEH!!#1@R2K){ʃ],ؾffՍ֭ ߼7}7~:P`VrX)?$x!.LsE `\C"~3|Frh76` f!kEaa]J)W=Z20-Nqte#Y@B9*4TI҇5/$AX0,Ob닼_KdsX>̧6?`pס( ߇7ˎe/)=Y>C ˨J{@ \tdS1gFՂs^FHE|4 Ŷb(S5-ٗҲL 9]SLbwqvfǍAQ2;e7hO_{a9ou;M @ ۰_TUMQRMW;iWbi P)IpPF) 6*y,P0W2K ({AiPyRD IIQka}X-kZ*k>CDWwPW9ފإגZA&vN5EڇC_NjPN֬_#V]e}թv% svF@ Dd 7>  # A"2y\$5k`U`!M\$5k`P0Xb @,xX]hU>3sf7?6bFcJRlQLitؤD0i2IOn %RhFH$HA>4BV ڇ]l-_&nNOE ( /ŭrTQ;F"J >u,"[yv\h`}WY_Ɏs G6XL,=3 q櫢 +!Ͻ4]#?mu,˓ߜ^|[BZR*!gdd~wݐI̥e֓JR.<ҹӶNۧqJ%Rk: }-e5dX$Şw3ѫVhwE{t9- >IXpO}}Vܻ=O%SѴ}.s.oF18)*66&B{79,p9L`i63'if`2}\. 92TLRQe[g} njK`|U[FRXPr<΢X vO-޽$m Oy~!=b-'^rc iz~BjiLE/-DڞD һz۱:rY]%vV}(냆U}7 +~7kGdb4fM#AqKnU#OsOa,zQDd ,$]>  # A"2`/P'`!`/P'0"YCNxW_hEvgvo]5I%k xA/Tz6XL.z+DK|h(C},#H/ K!"Z/HQPffrb/w7gvf77}3+@~ 0,<`ʘP (Z?nC=dk5a:HD|{\~"i|A @{^'N!&{Q0A DRP y+6+Q7 rcV25Q/Uԇ.8Yz:JKU#/nU/TSeԃ]S_P> ~{_D)Ⱦ;b<6lJI茕0%鬛wJ.[:nVzRKĔ@P9`LNrxnօex=2$9揖R! +@V$4+ofG;m &_tS']̪X홠1mN{|{~4Mer.Y\ |>|Ǻ{~ 8OР9ƾaQePxM=ͩ/h; F 7jA/);JF4QI(u2nwvޯ(t[0)tU3hŘlO+< wЧ'mbԼFKFXyik1{}$u؆?NZ]iǒm1m1I}{7UaE$}Xw'/ej3ONf<ǝBE' u5Xs*?f2|k9&[gtmgf\H {(=yʘ`Hΰ^ 'ՂXb %X8W͠iv6s󩌓8(X&nVd=S\8%(;0޲v_$+$޿ pxtZA.Wߥ:锥"nP1~) O\nk(灪R=Qf-_tb\rSdBUԯXI}je_nu,>^supNbRKSZצff®;Dd 1>  # A"28iNj KȀP`!}8iNj KȀ[KЕ{xuNKx]mlG~w|_s%j)RS~_HHҚP%f@TmJP$"U"9T]JM JTiT+,(%" (hDj~>3g?gfwfnv@ yʈ[r}8~x<nٱwxAx֊ulb]L 絅kˀFO;Zef|fLז3k32OkhԆֵA9jVrJi0X9{pR_|t;ՎeA3z ֬Zx gh7+@{#*(Xa+MԁVt@rk!J)Jɵx.,H񚷠׊ډ;s~-ޖs@?mB[Ζ31G r&v$V(-RZɷijQeYQZHv|oo5Xx~r._>WbS)J0'4"! .wMGˍ)@X>Pf!8b ιb'bq8ebز, r ˖-+Wvmv+a ,QDQAa!T#t,3BG P"t,+BG ׯ7͛ax֭[a۶m6skt\ ]Aa! #V:@X.XN0#@r"t:# }os[pwÓO>i+ _dm , t\0 t\+a ,X^0#"t$|0p18? `ي*!H-ʋJPAa!P d|# BH`# h̰Bp ˉBpއz ٳg;sۂ .|pPdp,3@XRAa!PH# BHȀ BG S0™H;-[5bʉ)vj6~Ou0>&7343 H+kU~fo.|u3M8LL{q("HD#(#-_@X:)˟Wcn,80Rk̷jJ7Wd?Nk\?aI/onBi/S/__K*@0h$CNlN}sJٱ9gWFGN1ge_7:X;I)FZa,!ҡҡ8uі;YSO3/B 'K9YVm+\MoiZBk?-h?Nofr7Ge/_cퟙ?[k;Fq#IimDۿψM\_T Gfb|;={?g⾳JJj?e! o݅ Dɑ 0ӥЧWo!o9ԶX|zW/[",tN3*<x,֑gg]?f] $\)W`u>+ajB? PS;IC#nNoОW,?#rO1F6H7Giq?S9FztȰ;lsIVS59ZHH@JZ2?'?I%)PmOtQo#DU!tUi?_9KK- I#nC?єnQ09KѮ͚xO(Q?II9W/_mwಀH'NZt?C61CN?>CZgB`-EN' Y|G_oi?o)_9'rOO)?/_&eOdOj_9+\A9K'__i _rg9C?ݏtz|,+(&B]3P7dU0:f'FgFs! /iLhJr#H:}#[~o2{s,Ƚ 1-A|g('I?߮˼g2Z櫣cdԐH01"%Js=;5?ؘ6Cuݜ1ÕGlwD9 9qM?^\"܃ ڿ*R=N?ߗ?j#bf\/l>;_ȟ!|f6xԂ?<̋zÖrhi\Yv Otn_3{SζKzgn1_/J<^Qbaߑ^}&O`%G{o\- g;2[t\}w0Dd 4wu>  # A"2"8q_"P`!8q_ 0kBxYklU>31eRPTAĆC11Vԍ< G:vK-EH>kTb6@!!X+$ 15ML4֨Hl|{gvݒ$ܹsw7g(`YnaY}0pC[X Fel0ԇB>xml!(*6e/ 6 ܖrًA1,uHIȚ2٢F/jXA`}(ڰT@,eiWRMȷRDV䕤=*]HmQŸos\ ,_>[8qUQ+uc.JDzp6;-sx&u1-j+sݚrXj^O;[Dh : XjJjQ2!$#[ȋwSMOx2S綁/nX8[%7h-#qL?mw=2b75BRJm:1|{2CQ *G>ujDp|>,WwdOc2Zb=s\H-pi:,$>ӻـ~՚=Vsuz(n^H2{iIDd!2h25nNX%)aiox!^a>?Ž3Cu0+M4餣 װ=r^߄%,_EoVV ',~ )]t[)Y55LyՄ+K&⤮횚Szv>mF6҂ {OhRF:Yjo";2&SP,(T\&pJ1S91>AߪR"t^љŝz޹'6 maQ#6w'MK.cwn.Icn&{W[]Ƭ(FcqA/r=15_jBӽ~Lçߘ,w3.i]ҫ]WC[8h{o|nb}o7&_^-NjjU3|h}V_մBx!$GeD{(חC>^]6_+.[wFג~u켋KT'eUym1:6nE*z  # A"2(H:qү/s~P`!v(H:qү/s (Xy zDxUkQm&ٍ`=D-ŃТE5ԪP)~DF rK/7/T<ػŻ yoYX&3oo>x8EyqC ![zPxCEG=$Al>b<P_xH|9   # A"27Pc:1u P`!m7Pc:1 (#t+;xMhA&fnBS[B+zPJ/"X[7jhПCPPs'""Ƀ-$V C!xR!MuKϡJ^{/oy3i@ @A,PYl 5G>-Z{zb1 )lv?XxC )aOG,f7?JPTQz觚OЀ}# "A&"Uxb!qY- >6/S6g#ھk|\bL:D )u eSB",_Ef΀USC=?-h?xZ|?=OV2tɀ>ayVVq~,~IcƤcDrdK1dٻbּ3b͗o9NA72*(zut."砹Il7'"Dd  >  # A"2a} A#3=5P`!5} A#3fP (6*9xY]hTG>fwܽ7k@J`?$ 싈65 Ul6F$uш,  (BBP JJ@0>!-U'33wdfwE8s99o]v?!|((4@Ȅ2"",T5s&3ac?|nЉuZV*(5 jP3a+S]݊UPd1gk DZ$bਗ਼Di c< ӁHڒlF}!?> 0}R/ (zg茶Do9B?(ԸW$c~QNtoH[wwmC!ub~tjTE\kVY XQ>jjYlAq^2|Oq0/ArRQj^ ߒ29ws <00fxV76roFDsmOGلH޲ϐh~a&B( u,{&@#| 4g# -%GvQ{Z0hlu곱vkwvݾ9E34X`j6lo7mi#iFE Q|3|V9fcQxĞ_l܍/֍ً+BfXc(Ys֮F[|⤭4~[F.j0v"ѼNA3Iic(l# EhehɆФ]v]=lbz)oaWy:.o}ָs:̮/ j56|M]M̉![VoFW'9t%u%~(ſbB @eDd 4>  # A"2n%n#zZR(P`!n%n#zZRA5uxW]hU>wfgf7;dхV AZVU֥[fZWNTS "},`m)" AW}Rq=޻jVg3~{s.@!6Ѡ Ihasm< _u9"G( vC|5؋Z'C4hPT͔AjQIQf$  ֭[8Np1߉C1oΌyCxsqmY}gKb0ξxᗅWou;bW|GŖ@P,e?)Wu^׫1majs{߾lXRJ #q{E锜։zy:(+,vz IJsif."~8H=(4|@mj7Mf5k*5\DvOJy/sLcQy֤\Ϧf1TҕZ1?IoaJK:Mz=,_oz>Pvi",Y\ e-ŝ4nRcRVvi3[in͏n+kt2ٕm-Z< s>}(v}(biN5:UwR2;{^N"?_N"ɤDdRn쓎Lȋy{LckHZDNDƭbFPƵc|h64<69-ӹeNhBՊQjҮO'bZj^DͱϷj9Asי妓WSAKKs؛`\鬷6]K(ߙ^N[=S:ήwN XsÝG9r1>[qqϑYe)W/DfduY? N8 /nyn{#,ncy;}OwM׳8Td뱻F첺Sň)9nߩEMk}nxD gźX~&FqŸgyAټ75}at<}oc%_*3$Y2EyDTDP>:%FV-olg}i *2Dd 0n>   # A "25^B h P`!`5^B LP` hy:.xKlWpuvjljH@!4U@/$Fy(qlꡈwĉ#K8j詷z*H[;y'A@РԆhi66 T$9).INxj7wϏ"ܿ:c:@1_uZ4&x1AeFsq3 dOVkc-x6_YxS:wx۷MXQ,¤>HYwޭ3iTj5-(@&T) 6X{֋q!nzE?:nyN3KuGMHJl1Itƒf!fb6GSb9U%O]u\Vl\q؅ۻp {<V!^ŊlŭتˏO~f71SuH E,Ж) A54皘S(:BP) vͮgp\~/) /˺j 1K01+v +!?0wFN:hMn n_o4k4품jZ'2Ti!D3xgn﬉p3=CFfȵgh|9ݏ o]͊Ȅp^D5(deU/+pxx_Uht/[?F"i+xW<ů ( k9ٺ\F5qokԮ\7{ ,r2ec2 ]4QSyyŁ VX6W5MM'S4U+ c[e8;[PF>[ЏxP*f&<?  # A"2/GA=!*iuu P`!GA=!*iuu80JwBxڵX}hEwٙm5RN UmW)_?LSNSYIk@0V)(5?A,M1DQX+RDJEhfv/q]xf޾}͛yPF A5es̅*X aCB[ma`=jhmniC&`k[[W$gGn0VQ`~@aبzܜ W7 Y(]8 ;ohߺxU1/.٘laVr;?v!B>MՋkOEˀnֵvt}A{gsK-zFU3 #c=ph{jϊ[e-.6ZTfx V RE}"VйpL(5(I2Z&#(EHWɐhӨ -gLDQ+%IN-5~~''ݵcs'A$ 93ZBhwӨKCshIQ"5.O،qFX䬸 .) ms;1$4Fd!23ZDlLia| ~[~Zf(QN.8S$)bBK/5m>DP,3"rpOqd \sN]io9}V_rcjT_4/!H&乞0_l~Ͼ>)ͯd+~>Iˏ8FuU *yU8몲:u Wa|J ;OBuvv9̤fAߋ]OΨU~Y\QU@h=R+Ü2S4gd%7Ș5IHK>gt?{쳼|d8k=M[nQ"t#B>-XG`#ҬTOV9w-]gZ ɷC ^A=CbλH>hyǻq{#JgٸTx϶得SW &pDd 1">  # A"2.-kPމrLslP`!.-kPމrLsd@q{8VxڵX_LEݱGp-%isB8))-p./> MCR_/55&" ~gw~3;|;#A@ 08 tb= ^XǞ y=}G|4Q F2zx@!w](T1lR!H`_>A9"s*$?VG*aFv67k;~s0~yO2֗U&abXKR@[J5Xaywjkqtv6ewwˣMi={ez7cw{-6Z?V<\녇~/=< !j-"foB5"\,ѽfl0ݦg]&#B#`H)P<`qxzPYO0򶌌ЪԢbe4f3]aW[r&ʀ(+=TK%퓲QXkKyRݮiS}=d~)[5S[վeJY~HpdxOҳDW3ٽW.5 Dd 7&>   # A " 2 nRKe.P`!w nRKe.=P@_Ex[l;@"d3AAb ԮdnBE.I;dhSXMVLL[U[i-S 4uk1ｳ$>?ݽ{y")jfdm 2Q*P/}b" B-p4?_Xք"ҔJA6ML|ŠlD/ͷBA4LS##_B# am*{ǃ5[{Y6XW*^Scvþ<1&Mnv"mvmJm >;ZǖC>u}ڋɞ>'^le[wgO3?@>dߵҷ^0`unaC[0ۘa凝Mutn֓yFw'R=h=+pZG뿀W 䌂 ޽sbH2[jXVXH'm4ء,pjY.bf^6!4k'bkx~,(!4knkFQDqĵM`VL˳ KV8ˑzt_f:w=oދ?6rGl2Upn&"꛼>'3S2ad:o$']ZpqIW([bպJV׆Xp3<[>>$/ELb? ܯelǟ,KEp ~]k;: lo)B@2>I#41imK +=hF"͞zq&棕cár&Qhh|߬ؾ̛sf.m/QXN+{}EW~ci}&/#PYv)Yďy2e7oW>PzaM,3;Dĸ8&ڕG~(ݲVz {WcY-1bG$i7`$pl[p#Ҋ%sF^UȳfXfYW݈a^E1xwȐE~ңTbt5c FCY+Z~³rz=P:75uksPvmMw 6tv ,Xea`]nlqSdI Dd t6%>   # A " 24@|ޟ[$P`!4@|ޟ[.-H6]xڵZkl^ދQY69LC )'+!p,ǖB8NȶRY>T$R hZ8pmiZ$~M@F:T]TCǮ8|3!H+ίiA,AHBY | zn:zrx0%/k -/?Jj:@kED-Ҕd#tBL"NgLI~O~p[]~xPmIp=(W]&!)awP!lD7tIp \;\o=>N}~yUK)94PJ/9֠}:IӘ)T̕icٳ$Gפ ^&l'?KbPkeԎ=g2Gdgl=Lgd:$I>h/Nc 66 g7{ .w( j&k&zmOǙvrqq0 /nYo #iVB PF2uYb³/l A]'j-lE!ƨy}EJG±l.("=ÊH +[qhJ=CGG+?rwX]䄘T ih9{">h+L V燻antB3R6{!R=i^=/2~Wcdn }$h4!OAoMR6lT%km_ڴ7/&yhB l[}N궎t?Uejx=_GC|k-Z*>˯n'h4TS罹bם>Z}}sn#^5N&m`&Fr61&\6 0i z&< tëTo.|3w2-c$S9+1{4wXyւQhmt{(}NZ,}|/%}(PNuU!{MEQ=QK=ariNPv:P[+ ?ĢB xkօ/xԹS'?ysҀɘ؀*H7ox zId 蚷Y}brԩE6<j(s*f;IuEca4.EodzHF V@%~4;`oG@mqS1[:) VO!7"(C%ģqVyq HqhǍVBN9(5p ۘ\wkh3Ks܉*xn [m}OٹG^qu-> "D% 2d,W\?;2G|(k4_/x kt)ڕ*bXYĊR=~oΩ[_^A+d.xqW챩lΞhN5ScD~6WU)X#&iKĒ'@jr|*Yd\^vDzs?3 3_'ĭf{\52BW'ETX+\4 VA_Vt}u)QM#jRlh]d툹w5Lo,/V9+,=LoŪ]/VD-]B+Ū~Y殅Zp|<@moH֢9F{3mRn?a|^ɋWg˕{Gi:M[ZĎNIp4s@P%H>of;床~|n}$ l%] EGJ\ݧJ-oe5 rZ(8BS} Dp^WR&" b&^RBKXgk M֢B:zHY:ҍ(щ$ yrܯtjs~g[Qe2E?RsR_gRiT*O/q`{ظOO F3Qج P]%CAuoD-rw^nG4G_6# =ʈ>嬯\Z7/_++e,]HRfk ny^__# 2?jDd 2L>   # A " 247 |O*U-P`!7 |O*UP0 }/xYkhU>3;{米mJ[mPhRQR_B!Qt- Idk b"ݠ6E")Hi?R*T%JDA[5j0{g6fDa}왓osF @i6TXE7&<6 @ R aQ*,dqW6D"/9[!voZa JOgV!`4x #\%$>bc|t.A9b NJ&!]BUdLk9ٽX#,SM9W>$C|yKơv[oj%xh{|>â]]W"|tTd;GBPKJ G J iH?bzyo(9jԜ9c`ޯ?Yof .Qgfwwn*Ϙgзp?NUGG1e#I=M1XHT0sOIF I+3e V2}E%-KpŅ~/maηu05=209Z6ٵJe7ʾ}^>%NIbU1TTz*}a9E:Y‹e;K*T8K& u94<ߓEi7VO}NW4}Dmgu]RW?Ynˆ/4#?ko[9-M}C ͒,%'|gfakTqh]Ii=C@'!^ZIYL8-<YԂߵnՂyzG }Zco%'87 ~M`u·~T>x=fn'gI@.fmJ.2gfU)u`h#3jls~6h$YXS>Aje, Ni7)q+˰HgS/r}Φ- ->ΦQ#BE,͉Ax{O0Et.\&}vڇX#s[lΰG3?9iǭkPF(ģ>Q>>֫KɾWDo7:}GpXia fLyY5;¢L2x#\]튵]+vڮXkbmW]e[;ICڲw/׈qNeGۻ-m禈u $$If.!vh55k5 #v#vk#v :V l055k5 4a.$$If.!vh55k5 #v#vk#v :V l055k5 4a.$$If.!vh55k5 #v#vk#v :V l055k5 4a.$$If.!vh55k5 #v#vk#v :V l055k5 4a.$$If.!vh55k5 #v#vk#v :V l055k5 4a.$$If.!vh55k5 #v#vk#v :V l055k5 4a.$$If.!vh55855T#v#v8#v#vT:V l055855T4a.$$If.!vh55855T#v#v8#v#vT:V l055855T4a.$$If.!vh55855T#v#v8#v#vT:V l055855T4a.$$If.!vh55855T#v#v8#v#vT:V l055855T4a.$$If.!vh55855T#v#v8#v#vT:V l055855T4a.$$If.!vh55855T#v#v8#v#vT:V l055855T4a.$$If.!vh55#v#v:V l0554a.$$If.!vh55#v#v:V l0554a.$$If.!vh55#v#v:V l0554a.$$If.!vh55#v#v:V l0554a.$$If.!vh55#v#v:V l0554a.$$If.!vh55#v#v:V l0554a.$$If.!vh55#v#v:V l0554a.$$If.!vh55#v#v:V l0554a.$$If.!vh55#v#v:V l0554a.$$If.!vh55#v#v:V l0554a.$$If.!vh55#v#v:V l0554a.$$If.!vh55#v#v:V l0554a.$$If.!vh55#v#v:V l0554a.$$If.!vh55#v#v:V l0554a.$$If.!vh55#v#v:V l0554a.$$If.!vh55#v#v:V l0554a.$$If.!vh55#v#v:V l0554a.$$If.!vh55#v#v:V l0554a.Dd E< & C A%&b3J'(>01FnJ'(>01PNG  IHDRk{XgAMAPLTE """)))UUUMMMBBB999|PP֭3f333f3333f3ffffff3f̙3ff333f333333333f33333333f33f3ff3f3f3f3333f33̙33333f333333f3333f3ffffff3f33ff3f3f3f3fff3ffffffffff3ffff̙fff3fffff3fff333f3f3ff3ff33f̙̙3̙ff̙̙̙3f̙3f̙333f3̙333f3ffffff3f̙̙3f̙3f3f333f3333f3fff̙fff3f̙3f3f̙fffffffff!___www˲𠠤X"NIDATxْ Ey[ޜrͅST 6&1V6fEmp - ]{ &JuvT? am2Iamڡ%B9gۜ? oRO RA ލ\¡3xixsvwɿ}D Ծy|K;I\&xt67-;nBԡyd}_ܴ@ @q;et$y| hhSC|Ji]:"M"u9Q#Np37_>h&i QyXZ"?QY4-&^f /shЦUag#A.A0FBÁ%$8‰ б&*7I-&Q~ C$MczBh2W9k]ޔ/0#i-RZ|r0J Vڏt%Bnj+7զ%Npnj>Rj0 N'}$nz BלPqmfˠ!^{wt4i_Q0Iy:Ŷ41 -G H"zO#cxJ36*zQzQRE6@y2 ]xXzVУd~)OTA~:16ztB\XZr4[rl tpygur'{6*,@&ǝ61@f'@6睎,@FN0kszYWLoRLO{2tE|qtYӁ[ ziZ2#tτ9ty>h]R )tutv IENDB` Dd | 1 < ' C A&'b4 l]08d/ eNn l]08d/PNG  IHDR[gAMAPLTE """)))UUUMMMBBB999|PP֭3f333f3333f3ffffff3f̙3ff333f333333333f33333333f33f3ff3f3f3f3333f33̙33333f333333f3333f3ffffff3f33ff3f3f3f3fff3ffffffffff3ffff̙fff3fffff3fff333f3f3ff3ff33f̙̙3̙ff̙̙̙3f̙3f̙333f3̙333f3ffffff3f̙̙3f̙3f3f333f3333f3fff̙fff3f̙3f3f̙fffffffff!___www˲𠠤X"NIDATx۶* Ey~KĀ$,^{tl4ANOCۻ UwXwx'-1`}#S Z]R_s3a>IW #:O(o"Ob i(Z1PO| u'f(`$ CL(R{<'Gyb<|oD5&zy,=HP6b;UcpQO D'*U'4q(Hz䇟d ZUz·fɯŠa=B4+ꛘ'RZ~fcocHq R}s/̟W >W^$x]K95?7[æLBwNBT סp X]!B^cKQ}$ԮD t3Ɉyf 'Zl' 6NBgibk%K^bbi=xbCn?Ox1)*5=Twc-X$>Ra;WsߴvHEח?m z-77AP8`ƵkRԼӳyVмVfw v+G'ØPs`Rw?)"!E S(}yPu]ZGgtNnBzE8lt.!tW !*P8hUVr<:DD9\X%y#=D(jwZ)?į 0, 0E S^U.S3k!ݎ%eJKOM z2.'AJ7cgu~6*RzcL4@x6+ z'1 [i Ti0GD0nN%HZr~Gq 9GEOgkeXql,^VT܊w4"[0-O0ߐ+ΩdfD[æ,]Ž u(4V`'NOGBas-%U\XbGz‰iY9e2<1tޗ6: { QtO]A_.tOyU)ڋ ۲'nG`.[rLڿUcXֱmr zOHc+h]{yBNWN|)nΎlc6"O-]P_]ɞ'8؏}rb4V[/BHZUWԐ+TΩ^uТ`6eI8]  3WH r'jTb1d#=DO4Z牡艞̕2F< -.;. E`btߟZ/փ>=Ekӡk wa\C9'M`"e#WiK XAnK1[U?e0˚kos<$x":z D(2L D8.dP Bę??/FAZy O:f.d@?N@!3 xX·naCk6P ,IENDB`<@< NormalCJ_HmH sH tH P@P Heading 1$<@&5CJKHOJQJN@N Heading 2$<@&56CJOJQJH@H Heading 3$<@& CJOJQJDA@D Default Paragraph FontVi@V  Table Normal :V 44 la (k@(No List 8Z@8 Plain TextOJQJ6@6  Footnote Text@&@@ Footnote ReferenceH*4 @"4 Footer  !.)@1. Page Number4@B4 Header  !@Y@R@  Document Map-D OJQJ6"@6 Caption xx54>@r4 Title$a$5CJ6B@6 Body TextCJaJE*% *            )*r*r &7OzD E * + d v  w /Gs!N3Dgi>@A^_.@f|<Z\w()46CDQSUVWX7   !!!!{"}"""""""""""""""""""M#O#Z#\#i#j#w#y#{#|############$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%.&|&~&''(((((( )),)C)Z)o))))))***** ++:+<+=+++++,,2,G,,,H/o/r0000G1X1s111112*2.2F2G2222 3E3j33333 4!404>4c4e4f455f6{6677/7R777777 8"8)8+8,8;;==??.@F@,ApAAAA"BtBBBBCCC#DSDDDDDDDEEEEEHHZIaIkI{IIIIIm)19;<]_~"BQRTX ?@PQ;<S./0235)\ !Y3h|~!#e9:e![:QR^_M<&679FNOFJK346km U9],#$[ \ ` a - . 0 1     acdfE^rs1[9~!9i:;eS  y!z!!!" "'"5"?"U"j"o"""""""""""""""""""""""""""""""####(#D#F#G#R#U#X#e#f#o#q#s#t#u#v#w#x#y#z#{#|#}#~#############6$=$D$L$T$X$q$$$$$$$$$$$$$$$$$$$$$$$$$$$%B%G%e%g%i%k%v%%%%%%%%%%%%%%%%%%%%%%%&& &&&&,&-&2&3&4&5&6&7&8&9&:&;&<&=&>&?&@&A&B&^'_'y'u(v(x(z((()))))))))**************************************************000000000000000000000000000w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w  0w  0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 000000 0 0 0 0 0 0 0 00000000000 0 0 0 0 0 0 0 0 0 0 0 0000000000 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00000 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00000000 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 000 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0000000'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'00H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/005050505050505050505050505050505050500;0;0;0;0;00.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@ 0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@0.@0.@0.@0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@0.@0.@0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@0.@0.@0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@0.@0.@0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@0.@0.@0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@ 0.@0.@0.@00P0P0P0P0P0P0P0P0P0P0P0P0P0P0P0P0P0P0P0P0P0P0P00U0U0U0U0U0U0U0U0U0U0U0U0U0U0U0U0U0U0U0U0U0U0U00-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[00^0^0^0^00b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b00q0q0q0q0q0q0q0q0q0q0q0q0q 0q 0q 0q 0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q00@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@00000000000000000000000000I0I0I0I 0I 0I 0I 0I 0I 0I 0I 0I0I0I 0I 0I 0I 0I 0I 0I 0I 0I0I0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I0I0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I0I0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I0I0I0I0I0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I0I0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I0I0I0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I0I0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I0I0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I 0I0I0I 0I 0I 0I 0I 0I 0I 0I 0I0I0I0I0I0I00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 0 0 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000000 0 0 0 0 0 0000z! 0z!0z!0z!0z!0z!0z!0z!0z!0z!0z!0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z!0z!0z!0z!0z!0z!0z!0z!0z!0z!0z!0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z!0z!0z!0z!0z!0z!0z!0z!0z!0z!0z!0z!0z!0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z!0z!0z!0z!0z!0z!0z!0z!0z!0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z!0z!0z!0z!0z!0z!0z!0z!0z!0z!0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z! 0z!0z! 0z!0z!0z!0z!0z!0z!0z!0z!0z! 0z!0z!0z!0z!0z!0z!0z!0z!0z!@0@0@0@000@0h00@0h00@0h00@0h00@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0h0000000000000000000000` &7OzD E * + d v  w /Gs!N3Dgi>@A^_.@f|<Z\w()46CDQSUVWX7   !!!!{"}"""""""""""""""""""M#O#Z#\#i#j#w#y#{#|############$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%.&|&~&''(((((( )),)C)Z)o))))))***** ++:+<+=+++++,,2,G,,,H/o/r0000G1X1s111112*2.2F2G2222 3E3j33333 4!404>4c4e4f455f6{6677/7R777777 8"8)8+8,8;;==??.@F@,ApAAAA"BtBBBBCCC#DSDDDDDDDEEEEEHHZIaIkI{IIIIIm)19;<]_~"BQRTX ?@PQ;<S./0235)\ !Y3h|~!#e9:e![:QR^_M<&679FNOFJK346km U9],#$[ \ ` a - . 0 1     acdfE^rs1[9~!9i:;eS  y!z!!!" "'"5"?"U"j"o"""""""""""""""""""""""""""""""####(#D#F#G#R#U#X#e#f#o#q#s#t#u#v#w#x#y#z#{#|#}#~#############6$=$D$L$T$X$q$$$$$$$$$$$$$$$$$$$$$$$$$$$%B%G%e%g%i%k%v%%%%%%%%%%%%%%%%%%%%%%%&& &&&&,&-&2&3&4&5&6&7&8&9&:&;&<&=&>&?&@&A&B&^'_'y'u(v(x(z((())))))))*000000000000000000000000000w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w  0w  0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 0w 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'0'00H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/0H/005050505050505050505050505050505050500;0;0;0;0;00.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@ 0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@0.@00P0P0P0P0P0P0P0P0P0P0P0P0P0P0P0P0P0P0P0P0P0P0P00U0U0U0U0U0U0U0U0U0U0U0U0U0U0U0U0U0U0U0U0U0U0U00-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[0-[00^0^0^0^00b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b00q0q0q0q0q0q0q0q0q0q0q0q0q 0q 0q 0q 0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q0q00@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@0@00000000000000000000000000I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I0I00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 0 0 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000000C 0C 0C 0C 0C 0C 0C0C00" 0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0" 0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0"0" 0"0"0"0"0"0"0"0"0" 0"0"0"0"0"0"0"0"0" $2222=JXXX[7&0?Vwʄ(sX)F\~!6,v022 !47>#Q%'' (****i+{+++,,,,----04:?#LRRT6TRTTU0ULUUUUVVVVVVWkWWWYYaeHr0v4 H¤Obx $8ҧ٨ԩɪOb{'A3@$******D+s+y+~+++q,,,,,,v------.3.6.9.<.?.1222     "#$%&'()*+,-./01235682 p!!!%%%Pdgdid|||)@BʘΧ.EH 7:Wnq * t     t t t t t t t t t t t t t $+.=DFJQT[!4!4!4!4  2$nxdՑTr2$D /Crw2$*3\?MB>>]s6qg2$" fK"4c v)z|2$YK4R>Y2$u;|E*{2$ r̗Q@Lyۋ2$݆W( 2$+~xDR fŤM2$gͮlQFم" .2$Dn 2$(h3P4KJ~y2$#ujQ X=2$Dfd a#(f2$iR^?^1_k6z2$vu:xzڜGբ2$t*q:Xo2$hJvƒ( ~r 2$, 6M.2$t&=( >{G'D^2$ 2tq~W(&^2$q*)"X2$/I޺`)EI2$O\<fHD#2$;4 d: bC2${A,b2$Yp, ;q[2$ M%4uIu Z2$H3C rv:2$̘#ZzS,1(2$\$5k`U2$dry@Xl6eGS2$҅{>T;KX K2$v40awWs̮zQH2$w$?qe"Qu2$%⏻Zr8]2$;͜QjG̙ a 2$`/P'2$W&ڲjeufl2$Eϳ| bc&2$;n.gBz!2$TBQc 2$8iNj KȀ2$8q_2$(H:qү/s~2$UK[q[z[[[[[[[[[[[\.\/\8\M\V\\\\\~]]]]]]]]]]]]^,^-^6^M^V^*_3_````aaIbJbMbNbXfafuf{fff1g:gggiiijjjjj#j.j7jBjXjcjejmjwjjjj#k*ktk~kkkkkkkkkl lllllllllmm)m3mCKMYo}"""!"""""""u$$$$%,%_%a%%%&&f'g''')***************tv+ 1 4=LUs| #,)/8:NT%+8B.0FLfj!(CE\`~^h!!?"I"""##$ $$"$%%''K(U((((((),)6)Z)d)v))))))**********+++%+d+n+++++++ ,,,',7,A,G,J,//s0000G1L1X1]1s1x1111122*2-2.242222222E3J3j3o33344$4*484<4A4G4f6l6{6666/757R7X77777778888):/:>>,A8ApA|AAA)B5B{BBBBCC'D*DWDYDDDDDDDEEEEGGHdHHHaIdIkIyI{IIIIJ'JJJPPPP QQ$Q)QQQVR]RlRrRRRRRRRRTXTTTTTTT^UgUV VXV^VVVVVVV$W.WY Y/YBYZY_YqYYmZsZZZZZ[ [d[o[q[z[[[[[[[ \\=\B\]]]]]]^^;^@^^^SbVbbbFfGfTfVfmftfffii j jKjMjjjjjkkkkkkkkkkkkllllm!momqmmmmmmmnnnnnnooAoCo|oooouuvv]v{vvvvvdzlzzzzz{{||*}6}]~c~~~~~#csu{:M/:;A߄3DY[}ņˆ$+Ňڇ8<ai*0TempÌΌЌ-BDfw$ ǖ͖W]֗ܗOUؚޚ[hioCF̤٤ߤĥɥ٥ߥ 39gi;A`b"Ųвܲ bd޳|׵޵ Ҷض'-_ftzзַ ]hvw}!'GMpv 46io׽39qtflEKmt "9O#&%Z\ 46im~#)jp:A)/^bF\MS FH04E[6&}  2;gm#;GwU[,14?#8"" ""("*"5";"@"D"U"["j"n"o"u""""""""## #####'#)#/#6$;$=$B$D$K$L$S$X$^$q$s$$$$$$%%%B%D%_%a%%%%%&&& &p'w'g)q))***************333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333 p!!%%; ;PdjdMv~vvvvvvvwx xx!y"yZ|Z|[|[|h|x|||)Cʘ66IIŧ'$.I ;Wrc)*********************)*************** \-./XNF*$FS Ee -g 88^8`o(h ^`OJQJo(h ^`OJQJo(oh pp^p`OJQJo(h @ @ ^@ `OJQJo(h ^`OJQJo(oh ^`OJQJo(h ^`OJQJo(h ^`OJQJo(oh PP^P`OJQJo(h ^`OJQJo(h ^`OJQJo(oh pp^p`OJQJo(h @ @ ^@ `OJQJo(h ^`OJQJo(oh ^`OJQJo(h ^`OJQJo(h ^`OJQJo(oh PP^P`OJQJo(hh^h`. hh^h`OJQJo(hh^h`.FSEe-g XNF\-                     cg>q)M*%=rt{~z h*@()46CDQSUV  {"}"""""""""""""""""M#O#Z#\#i#j#w#y#{#|#########$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%JJJJJJJJJJKKKLLL,L2L6L7LFLNLRLSLLLLLLMMMMM&M,M0M1M@MHMLMMMMMMMMMMMMMMMMMN NNNaNbNmN}NNNNNNNNNNNNNNN-O.O9OIOVOWOfOiOkOlO{OOOOOOOO  67?GHIœÜ$/9OPX`bckwxyϝڝ "$%-789ȟПҟӟ۟à٠ڠԡաݡr}ŢɢʢҢܢ$/9OPX`bckw{|%'(0<ABnyo"""""""""""""""""""""""""""F#G#R#U#X#e#f#o#q#s#t#u#v#w#x#y#z#{#|#}#~############$$$$$$$$$$$$$$$$$$$$i%k%v%%%%%%%%%%%%%%%%%%&&&,&-&2&3&4&5&6&7&8&9&:&;&<&=&>&?&@&))*********@,$*0@UnknownGz Times New Roman5Symbol3& z Arial;Wingdings?5 z Courier New5& zaTahoma"1h)fCF4 *-x,x,!4d_)_) 2QHP ?rt{2( COMP 14: Class Notes Prasun Dewandewan$      Oh+'0 , L X d p|, COMP 14: Class NotesPrasun Dewan Normal.dotdewan165Microsoft Office Word@fQ b@Z0d@!N@殦x,՜.+,0 hp  UNC-CH_) ) COMP 14: Class Notes Title  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./012345789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"$%&'()*,-./012;Root Entry Fv=Data X1Table6<WordDocumentJSummaryInformation(#DocumentSummaryInformation8+CompObjq  FMicrosoft Office Word Document MSWordDocWord.Document.89q