From 0a00ca34153d7323e0177508197ed8fe16d45761 Mon Sep 17 00:00:00 2001 From: Milky2018 <842376130@qq.com> Date: Wed, 17 Apr 2024 11:41:46 +0800 Subject: [PATCH 1/7] Initialize English course 5. --- course5/course_en.md | 268 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 268 insertions(+) create mode 100644 course5/course_en.md diff --git a/course5/course_en.md b/course5/course_en.md new file mode 100644 index 0000000..bbafe27 --- /dev/null +++ b/course5/course_en.md @@ -0,0 +1,268 @@ +# Modern Programming Ideology: Trees + +Welcome to Modern Programming Ideology brought to you by the IDEA's Digital Infrastructure Innovation. Today, we explore a common data structure: trees, and related algorithms. + +In this lecture, we will start with a simple tree, understand the concept, and then learn about a specialized tree: binary tree. After that, we will explore a specialized binary tree: binary search tree. Further, we will also learn about the balanced binary tree. + +Trees are very common plants in our lives, as shown in the diagram. + +![trees](../pics/trees.drawio.png) + +A tree has a root with multiple branches, each branch having leaves or other small branches. In fact, many data structures in our everyday lives look like a tree. For example, the pedigree chart, a.k.a., a family tree, grows from a pair of ancestors. We also use the phrase "branching out" to describe this process. Another example is file structure, where a folder may contain some files and other folders, just like leaves and branches. Mathematical expressions can also be represented as a tree, where each node is an operator, and each leaf is a number, with operators closer to the root being computed later. + +## Trees + +In data structures, a tree is a finite collection of nodes that have a hierarchical relationship. Each node is a structure that stores data. It is common to describe this hierarch using family relationships, like parents, children, descendants and ancestors. Sometimes, we say there is a parent-child relationship between adjacent nodes, calling them parent nodes and child nodes. A node's descendants are all the nodes that stem from a node, while a node’s ancestors are all the nodes that it stems from. + +If a tree is not empty, it should have exactly one root node, which has only child nodes and no parent nodes. All nodes except the root node should have exact one parent node. Nodes without child nodes, which are the outermost layer of nodes, are called leaf nodes, akin to the leaves of a tree. Additionally, no node can be its own descendant, meaning cycles cannot exist within the tree. + +![](../pics/abstract-tree.drawio.png) + +In a tree, an edge refers to a pair of nodes (u, v), where either u is the parent node of v or v is the parent node of u; simply put, these two nodes should have a parent-child relationship. We use arrows in diagrams to indicate parent-child relationships, with the arrow pointing from an ancestor to its descendant. + +The example below is not a tree. + +![](../pics/not-a-tree.drawio.png) + +Each red mark violates the requirements of a tree. In the upper right, there's another root node without a parent node, implying two root nodes in a tree, which is not allowed. At the bottom, the left leaf node has an extra arrow pointing to the root node, implying it's the parent node of the root, violating the structure requirements. And the right leaf node has two parent nodes, which also doesn't comply with the requirements. + +It's common to place the root node at the top, with child nodes arranged below their parent nodes. We have some terms related to trees. Firstly, the depth of a node corresponds to the length of the path from the root node down to that node. In other words, the number of edges traversed when going from the root node downwards. Therefore, the depth of the root is 0. Then the height of a node corresponds to the length of the longest path from the node to a leaf node. Likewise, the height of a leaf node is 0. Finally, there's the height of a tree, which is equivalent to the height of the root node. If a tree has only one node, it is both the root node and a leaf node, with a height of 0. If a tree is empty, meaning it has no nodes, we define its height as -1. However, some books may define it differently, considering the layers of the tree, with the root being the first layer, and so on. + +Having discussed the logical structure of a tree, let's now consider its storage structure. While the logical structure defines the relationships between data, the storage structure defines the specific representation of data. We'll use a binary tree as an example, where each node has at most two children. Here, we'll represent the tree using a list of tuples. Each tuple defines a parent-child relationship, such as `(0, 1)`, indicating that node 0 is the parent of node 1. + +Another way is to use algebraic data structures we have talked about previously: + +```moonbit no-check +Node(0, + Node(1, + Leaf(3), + Empty), + Leaf(2)) +``` + +We define several cases using an enumeration type: `Node` represents a regular tree node with its own number and two subtrees, `Leaf` represents a tree with only one node, i.e., a leaf node, having only its own number, and `Empty` represents an empty tree. With this representation, we can define a tree structure similar to before. Of course, this is just one possible implementation. + +The final approach is a list where each level's structure is arranged consecutively from left to right: + +![](../pics/list-tree.drawio.png) + +For example, the root node is placed at the beginning of the list, followed by nodes of the second level from left to right, then nodes of the third level from left to right, and so on. Thus, node 3 and the node to its right are children of node 1, while the two nodes after are children of 2. These three nodes are all empty in the example. + +We can see that all three methods define the same tree, but their storage structures are quite different. Hence, we can conclude that the logical structure of data is independent of its storage structure. + +Finally, the tree data structure has many derivatives. For example, a segment tree stores intervals and corresponding data, making it suitable for one-dimensional queries. Binary trees are a special type where each node has at most two branches, namely the left subtree and the right subtree. B-trees are suitable for sequential access, facilitating the storage of data on disks. KD-trees and R-trees, which are derivatives of binary trees and B-trees respectively, are suitable for storing spatial data structures. Apart from these, there are many other tree structures. + +## Binary Trees + +A binary tree is either empty or consist of nodes that have at most two subtrees: a left subtree and a right subtree. For example, both subtrees of a leaf node are empty. Here, we adopt a definition based on recursive enumeration types, with default data storage being integers. + +```moonbit +enum IntTree { + Node(Int, IntTree, IntTree) // data, left subtree, right subtree + Empty +} +``` + +The first algorithm we will discuss is binary tree traversal (or search). Tree traversal refers to the process of visiting all nodes of a tree in a certain order without repetition. Typically, there are two methods of traversal: depth-first and breadth-first. Depth-first traversal always visits one subtree before the other. During the traversal of a subtree, it recursively visits one of its subtrees. Thus, it always reaches the deepest nodes first before returning. For example, + +![](../pics/traversal.drawio.png) + +in the diagram, we first visit the left subtree, then the left subtree again, leading to the visit of 3. Subsequently, we continuously visit the right subtree, resulting in the visit of 5. Finally, we visit the right subtree of the entire tree, which is 2. On the other hand, breadth-first traversal starts from the root node and proceeds layer by layer, visiting nodes at a certain depth before moving deeper. For the same tree, breadth-first traversal will visit the root node first, followed by subtrees 1 and 2, then 3 and 4, and finally the deepest node 5. + +Depth-first traversal usually involves three variations: preorder traversal, inorder traversal, and postorder traversal. The difference lies in when the root node is visited while traversing the entire tree. For example, in preorder traversal, the root node is visited first, followed by the left subtree, and then the right subtree. Taking the tree we just saw as an example, this means we start with 0, then visit the left subtree; when visiting the left subtree, we start from the root node again, which is 1; then 3, 4, 5, and 2. In inorder traversal, the left subtree is visited first, followed by the root node, and then the right subtree. Hence, it first visits the left subtree. At this moment, there is still a left subtree, so we go down to tree 3. Now, it's a leaf node without a left subtree, so we visit the root node 3. Then we return to visit the root node 1 of the subtree and proceed to visit the right subtree. Postorder traversal follows a similar logic, visiting the left subtree first, then the right subtree, and finally the root node. In fact, solving the Fibonacci sequence can be seen as a postorder traversal, as we first visit the (n-1)th and (n-2)th items, which are two subtrees, and then solve the nth item, which is the value of the root node. As for breadth-first traversal, we have already explained it: from left to right, the order is `[0, 1, 2, 3, 4, 5]`. + +Let's take a look at the specific implementation of these two traversals in terms of finding a specific value in the tree's nodes. Firstly, let's consider depth-first traversal. + +```moonbit +fn dfs_search(target: Int, tree: IntTree) -> Bool { + match tree { // check the visited tree + Empty => false // empty tree implies we are getting deepest + Node(value, left, right) => // otherwise, search in subtrees + value == target || dfs_search(target, left) || dfs_search(target, right) + } +} +``` + +As we introduced earlier, this is a traversal based on structured recursion. We first handle the base case, i.e., when the tree is empty, as shown in the third line. In this case, we haven't found the value we're looking for, so we return `false`. Then, we handle the recursive case. For a node, we check if its value is the desired result, as shown in line 5. If we find it, the result is `true`. Otherwise, we continue to traverse the left and right subtrees alternately, if either we find it in left subtree or right subtree will the result be `true`. In the current binary tree, we need to traverse both the left and right subtrees to find the given value. The binary search tree introduced later will optimize this process. The only differences between preorder, inorder, and postorder searches is the order of operations on the current node, the left subtree search, and the right subtree search. + +### Short-circuit Evaluation of Booleans + +Here, we supplement the content not mentioned in the second lesson, the short-circuit evaluation of booleans. The logical `OR` and `AND` operations are short-circuited. This means that if the result of the current evaluation can be determined, the calculation will be terminated, and the result will be returned directly. For example, in the first case, we are evaluating `true ||` some value. It's clear that `true || any value` will always be true, so only the left side of the operation needs to be evaluated, and the right side won't be evaluated. Therefore, even if we write an instruction such as `abort` here to halt the program, the program will still run normally because the right side hasn't been computed at all. Similarly, if we evaluate `false &&` some value, knowing that `false && any value` will always be false, we won't evaluate the right side either. This brings us back to the traversal of the tree we discussed earlier. When using logical OR, traversal will immediately terminate once any condition is met. + +### Queue + +Now let's continue with breadth-first traversal. + +![](../pics/bfs.drawio.png) + +As mentioned earlier, breadth-first traversal involves visiting each subtree layer by layer. In this case, to be able to record all the trees we are going to visit, we need a brand-new data structure: the queue. + +![](../pics/queue.drawio.png) + +A queue is a first-in-first-out (FIFO) data structure. Each time, we dequeue a tree from the queue and check whether its node value is the one we're searching for. If not, we enqueue its non-empty subtrees from left to right and continue the computation until the queue is empty. + +Let's take a closer look. Just like lining up in real life, the person who enters the line first gets served first, so it's important to maintain the order of arrival. The insertion and deletion of data follow the same order, as shown in the diagram. We've added numbers from 0 to 5 in order. After adding 6, it follows 5; and if we delete from the queue, we start from the earliest added 0. + +The queue we're using here is defined through the following interface: + +```moonbit no-check +fn empty[T]() -> Queue[T] // construct an empty queue +fn enqueue[T](q: Queue[T], x: T) -> Queue[T] // add element to the tail +// attempt to dequeue an element, return None if the queue is empty +fn pop[T](q: Queue[T]) -> (Option[T], Queue[T]) +``` + +`empty`: construct an empty queue; `enqueue`: add an element to the queue, i.e., add it to the tail; `pop`: attempt to dequeue an element and return the remaining queue. If the queue is already empty, the returned value will be `None` along with an empty queue. For example, + +```moonbit no-check +let q = enqueue(enqueue(empty(), 1), 2) +let (head, tail) = pop(q) +assert(head == Some(1)) +assert(tail == enqueue(empty(), 2)) +``` + +we've added 1 and 2 to an empty queue. Then, when we try to dequeue an element, we should get `Some(1)`, and what's left should be equivalent to adding 2 to an empty queue. + +Let's return to the implementation of our breadth-first traversal. + +```moonbit no-check +fn bfs_search(target: Int, queue: Queue[IntTree]) -> Bool { + match pop(queue) { + (None, _) => false // If the queue is empty, end the search + (Some(head), tail) => match head { // If the queue is not empty, operate on the extracted tree + Empty => bfs_search(target, tail) // If the tree is empty, operate on the remaining queue + Node(value, left, right) => + if value == target { true } else { + // Otherwise, operate on the root node and add the subtrees to the queue + bfs_search(target, enqueue(enqueue(tail, left), right)) + } + } + } +} +``` + +If we want to search for a specific value in the tree's nodes, we need to maintain a queue containing trees, as indicated by the parameters. Then, we check whether the current queue is empty. By performing a `pop` operation and pattern matching on the head of the queue, if it's empty, we've completed all the searches without finding the value, so we return `false`. If the queue still has elements, we operate on this tree. If the tree is empty, we directly operate on the remaining queue; if the tree is not empty, as before, we check if the current node is the value we're looking for. If it is, we return `true`; otherwise, we enqueue the left and right subtrees `left` and `right` into the queue and continue searching the queue. + +So far, we've concluded our introduction to tree traversal. However, we may notice that this type of search doesn't seem very efficient because every subtree may contain the value we're looking for. Is there a way to reduce the number of searches? The answer lies in the binary search tree, which we'll introduce next. + +## Binary Search Tree + +Previously, we mentioned that searching for elements in a binary tree might require traversing the entire tree. For example, in the diagram below, we attempt to find the element 8 in the tree. + +![](../pics/bst.drawio.png) + +For the left binary tree, we have to search the entire tree, ultimately concluding that 8 is not in the tree. + +To facilitate searching, we impose a rule on the arrangement of data in the tree based on the binary tree: from left to right, the data is arranged in ascending order. This gives rise to the binary search tree. According to the rule, all data in the left subtree should be less than the node's data, and the node's data should be less than the data in the right subtree, as shown in the diagram on the right. + +We notice that if we perform an inorder traversal, we can traverse the sorted data from smallest to largest. Searching on a binary search tree is very simple: determine whether the current value is less than, equal to, or greater than the value we are looking for, then we know which subtree should be searched further. In the example above, when we check if 8 is in the tree, we find that 8 is greater than 5, so we should search on the right subtree next. When we encounter 7, we find that there is no right subtree, meaning there are no numbers greater than 7, so we conclude that 8 is not in the tree. As you can see, our search efficiency has greatly improved. In fact, the maximum number of searches we need to perform, in the worst-case scenario, is the height of the tree plus one, rather than the total number of elements. In some cases, the height of the tree may also equal the total number of elements, as we will see later. + +To maintain such a tree, we need special algorithms for insertion and deletion to ensure that the modified tree still maintains its order. Let's explore these two algorithms. + +![](../pics/bst-insertion.drawio.png) + +For the insertion on a binary search tree, we also use structured recursion. First, we discuss the base case where the tree is empty. In this case, we simply replace the tree with a new tree containing only one node with the value we want to insert. Next, we discuss the recursive case. If a tree is non-empty, we compare the value we want to insert with the node's value. If it's less than the node, we insert the value into the left subtree and replace the left subtree with the subtree after insertion. If it's greater than the node, we replace the right subtree. For example, if we want to insert 3, we need to compare it with each node. For instance, if it's less than 5, we operate on the left subtree. Later, if it's greater than 2, we operate on the right subtree. We focus on this subtree. As we can see, since 3 is less than 4, we should insert it into the left subtree. Then since this is an empty tree, we construct a tree containing only one node and replace the left subtree with a tree only containing 4. + +```moonbit +fn insert(tree: IntTree, value: Int) -> IntTree { + match tree { + Empty => Node(value, Empty, Empty) // construct a new tree if it's empty + Node(v, left, right) => // if not empty, update one subtree by insertion + if value == v { tree } else + if value < v { Node(v, insert(left, value), right) } else + { Node(v, left, insert(right, value)) } + } +} +``` + +Here we can see the complete insertion code. In line 3, if the original tree is empty, we reconstruct a new tree. In lines 6 and 7, if we need to update the subtree, we use the `Node` constructor to build a new tree based on the updated subtree. + +Next, we discuss the delete operation. + +![](../pics/bst-deletion.drawio.png) + +Similarly, we do it with structured recursion. If the tree is empty, it's straightforward because we don't need to do anything. If the tree is non-empty, we need to compare it with the current value and determine whether the current value needs to be deleted. If it needs to be deleted, we delete it. We'll discuss how to delete it later; if it's not the value we want to delete, we still need to compare it and find the subtree where the value might exist, then create an updated tree after deletion. The most crucial part of this process is how to delete the root node of a tree. If the tree has no subtrees or only one subtree, it's straightforward because we just need to replace it with an empty tree or the only subtree. The trickier part is when there are two subtrees. In this case, we need to find a new value to be the root node, and this value needs to be greater than all values in the left subtree and less than all values in the right subtree. There are two values that satisfy this condition: the maximum value in the left subtree and the minimum value in the right subtree. Here, we use the maximum value in the left subtree as an example. Let's take another look at the schematic diagram. If there are no subtrees, we simply replace it with an empty tree; if there's one subtree, we replace it with the subtree. If there are two subtrees, we need to set the maximum value in the left subtree as the value of the new root node and delete this value from the left subtree. The good news is that this value has at most one subtree, so the operation is relatively simple. + +```moonbit +fn remove_largest(tree: IntTree) -> (IntTree, Int) { + match tree { + Node(v, left, Empty) => (left, v) + Node(v, left, right) => { + let (newRight, value) = remove_largest(right) + (Node(v, left, newRight), value) + } } +} +``` + +```moonbit no-check +fn remove(tree: IntTree, value: Int) -> IntTree { + match tree { ... + Node(root, left, right) => if root == value { + let (newLeft, newRoot) => remove_largest(left) + Node(newRoot, newLeft, right) + } else ... } +} +``` + +Here, we demonstrate part of the deletion of a binary search tree. We define a helper function to find and delete the maximum value from the left subtree. We keep traversing to the right until we reach a node with no right subtree because having no right subtree means there are no values greater than it. Based on this, we define the deletion, where when both subtrees are non-empty, we can use this helper function to obtain the new left subtree and the new root node. We omit the specific code implementation here, leaving it as an exercise for you to practice after class. + +### Balanced Binary Trees + +Finally, we delve into the balanced binary trees. When explaining binary search trees, we mentioned that the worst-case number of searches in a binary search tree depends on the height of the tree. Insertion and deletion on a binary search tree may cause the tree to become unbalanced, meaning that one subtree's height is significantly greater than the other's. For example, if we insert elements from 1 to 5 in sequence, we'll get a tree as shown in the lower left diagram. + +![](../pics/worst-bst.drawio.png) + +We can see that for the entire tree, the height of the left subtree is -1 because it's an empty tree, while the height of the right subtree is 3. In this case, the worst-case number of searches equals the number of elements in the tree, which is 5. However, if the tree is more balanced, meaning the heights of the two subtrees are similar, as shown in the right diagram, the maximum depth of a node is at most 2, which is approximately $log_2n$ times, where n is the number of elements in the tree. As you may recall from the curve of the logarithmic function, when the number of elements in the tree is large, there can be a significant difference in the worst-case search time between the two scenarios. Therefore, we hope to avoid this worst-case scenario to ensure that we always have good query performance. To achieve this, we can introduce a class of data structures called balanced binary trees, where the heights of any node's left and right subtrees are approximately equal. Common types of balanced binary trees include AVL trees, 2-3 trees, or red-black trees. Here, we'll discuss AVL trees, which are relatively simple. + +The key to maintaining balance in a binary balanced tree is that when the tree becomes unbalanced, we can rearrange the tree to regain balance. The insertion and deletion of AVL trees are similar to standard binary search trees, except that AVL trees perform adjustments after each insertion or deletion to ensure the tree remains balanced. We add a height attribute to the node definition. + +```moonbit no-check +enum AVLTree { + Empty + // current value, left subtree, right subtree, height + Node(Int, AVLTree, AVLTree, Int) +} +fn create(value: Int, left: AVLTree, right: AVLTree) -> AVLTree +fn height(tree: AVLTree) -> Int +``` + +The creation function creates a new AVL tree without explicitly maintaining its height. Since the insertion and deletion operations of AVL trees are similar to standard binary search trees, we won't go into detail here. + +![](../pics/rotation.drawio.png) + +After inserting or deleting an element, we traverse back from the modified location until we find the first unbalanced position, which we call z. Then, we use y to represent the higher subtree of z, and x is the higher subtree of y. Next, we discuss rebalancing. In the first case, x is between y and z. In this case, we can move x above its parent and grandparent. We can see that the depths of x's two subtrees decrease by 1, thereby reducing the height of the entire tree. Although the depth of T4 increases by 1, it was originally lower than the left subtree, so it remains balanced. The other case is when x is on y and z's same side. In this case, we can reduce the height of the tree by making y the root node. The purpose is still to reduce the depths of the two deepest subtrees to decrease the height of the left subtree. + +```moonbit no-check +fn balance(left: AVLTree, z: Int, right: AVLTree) -> AVLTree { + if height(left) > height(right) + 1 { + match left { + Node(y, left_l, left_r, _) => + if height(left_l) >= height(left_r) { + create(left_l, y, create(lr, z, right)) // x is on y and z's same side + } else { match left_r { + Node(x, left_right_l, left_right_r, _) => // x is between y and z + create(create(left_l, y, left_right_l), x, create(left_right_r, z, right)) + } } + } + } else { ... } +} +``` + +Here is a snippet of code for a balanced tree. You can easily complete the code once you understand what we just discussed. We first determine if a tree is unbalanced, by checking if the height difference between the two subtrees exceeds a specific value and which side is higher. After determining this, we perform a rebalancing operation. At this point, the root node we pass in is z, and the higher side after pattern matching is y. Then, based on the comparison of the heights of y's two subtrees, we further determine whether x is y and z's same side or between y and z, as shown in line 6. Afterwards, we recombine based on the scenarios discussed earlier, as shown in lines 6 and 9. Taking insertion of an element as an example: + +```moonbit no-check +fn add(tree: AVLTree, value: Int) -> AVLTree { + match tree { + Node(v, left, right, _) as t => { + if value < v { balance(add(left, value), v, right) } else { ... } + } + Empty => ... + } +} +``` + +After inserting the element, we directly perform a rebalancing operation on the resulting tree. + +## Summary + +In this chapter, we introduced the trees, including the definition of a tree and its related terminology, the definition of a binary tree, traversal algorithms, the definition of a binary search tree, its insertion and deletion operations, as well as the rebalancing operation of AVL trees, a type of balanced binary tree. We recommend reading Chapters 12 and 13 of "Introduction to Algorithms" for further study. \ No newline at end of file From e277d6b1e97ff7dd94de08cf9067fc779dc4d112 Mon Sep 17 00:00:00 2001 From: Milky2018 <842376130@qq.com> Date: Wed, 24 Apr 2024 17:39:08 +0800 Subject: [PATCH 2/7] Fix some terminology use. --- course5/course_en.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/course5/course_en.md b/course5/course_en.md index bbafe27..a21afe3 100644 --- a/course5/course_en.md +++ b/course5/course_en.md @@ -83,7 +83,7 @@ fn dfs_search(target: Int, tree: IntTree) -> Bool { } ``` -As we introduced earlier, this is a traversal based on structured recursion. We first handle the base case, i.e., when the tree is empty, as shown in the third line. In this case, we haven't found the value we're looking for, so we return `false`. Then, we handle the recursive case. For a node, we check if its value is the desired result, as shown in line 5. If we find it, the result is `true`. Otherwise, we continue to traverse the left and right subtrees alternately, if either we find it in left subtree or right subtree will the result be `true`. In the current binary tree, we need to traverse both the left and right subtrees to find the given value. The binary search tree introduced later will optimize this process. The only differences between preorder, inorder, and postorder searches is the order of operations on the current node, the left subtree search, and the right subtree search. +As we introduced earlier, this is a traversal based on structural recursion. We first handle the base case, i.e., when the tree is empty, as shown in the third line. In this case, we haven't found the value we're looking for, so we return `false`. Then, we handle the recursive case. For a node, we check if its value is the desired result, as shown in line 5. If we find it, the result is `true`. Otherwise, we continue to traverse the left and right subtrees alternately, if either we find it in left subtree or right subtree will the result be `true`. In the current binary tree, we need to traverse both the left and right subtrees to find the given value. The binary search tree introduced later will optimize this process. The only differences between preorder, inorder, and postorder searches is the order of operations on the current node, the left subtree search, and the right subtree search. ### Short-circuit Evaluation of Booleans @@ -103,7 +103,7 @@ A queue is a first-in-first-out (FIFO) data structure. Each time, we dequeue a t Let's take a closer look. Just like lining up in real life, the person who enters the line first gets served first, so it's important to maintain the order of arrival. The insertion and deletion of data follow the same order, as shown in the diagram. We've added numbers from 0 to 5 in order. After adding 6, it follows 5; and if we delete from the queue, we start from the earliest added 0. -The queue we're using here is defined through the following interface: +The queue we're using here is defined by the following interface: ```moonbit no-check fn empty[T]() -> Queue[T] // construct an empty queue @@ -161,7 +161,7 @@ To maintain such a tree, we need special algorithms for insertion and deletion t ![](../pics/bst-insertion.drawio.png) -For the insertion on a binary search tree, we also use structured recursion. First, we discuss the base case where the tree is empty. In this case, we simply replace the tree with a new tree containing only one node with the value we want to insert. Next, we discuss the recursive case. If a tree is non-empty, we compare the value we want to insert with the node's value. If it's less than the node, we insert the value into the left subtree and replace the left subtree with the subtree after insertion. If it's greater than the node, we replace the right subtree. For example, if we want to insert 3, we need to compare it with each node. For instance, if it's less than 5, we operate on the left subtree. Later, if it's greater than 2, we operate on the right subtree. We focus on this subtree. As we can see, since 3 is less than 4, we should insert it into the left subtree. Then since this is an empty tree, we construct a tree containing only one node and replace the left subtree with a tree only containing 4. +For the insertion on a binary search tree, we also use structural recursion. First, we discuss the base case where the tree is empty. In this case, we simply replace the tree with a new tree containing only one node with the value we want to insert. Next, we discuss the recursive case. If a tree is non-empty, we compare the value we want to insert with the node's value. If it's less than the node, we insert the value into the left subtree and replace the left subtree with the subtree after insertion. If it's greater than the node, we replace the right subtree. For example, if we want to insert 3, we need to compare it with each node. For instance, if it's less than 5, we operate on the left subtree. Later, if it's greater than 2, we operate on the right subtree. We focus on this subtree. As we can see, since 3 is less than 4, we should insert it into the left subtree. Then since this is an empty tree, we construct a tree containing only one node and replace the left subtree with a tree only containing 4. ```moonbit fn insert(tree: IntTree, value: Int) -> IntTree { @@ -181,7 +181,7 @@ Next, we discuss the delete operation. ![](../pics/bst-deletion.drawio.png) -Similarly, we do it with structured recursion. If the tree is empty, it's straightforward because we don't need to do anything. If the tree is non-empty, we need to compare it with the current value and determine whether the current value needs to be deleted. If it needs to be deleted, we delete it. We'll discuss how to delete it later; if it's not the value we want to delete, we still need to compare it and find the subtree where the value might exist, then create an updated tree after deletion. The most crucial part of this process is how to delete the root node of a tree. If the tree has no subtrees or only one subtree, it's straightforward because we just need to replace it with an empty tree or the only subtree. The trickier part is when there are two subtrees. In this case, we need to find a new value to be the root node, and this value needs to be greater than all values in the left subtree and less than all values in the right subtree. There are two values that satisfy this condition: the maximum value in the left subtree and the minimum value in the right subtree. Here, we use the maximum value in the left subtree as an example. Let's take another look at the schematic diagram. If there are no subtrees, we simply replace it with an empty tree; if there's one subtree, we replace it with the subtree. If there are two subtrees, we need to set the maximum value in the left subtree as the value of the new root node and delete this value from the left subtree. The good news is that this value has at most one subtree, so the operation is relatively simple. +Similarly, we do it with structural recursion. If the tree is empty, it's straightforward because we don't need to do anything. If the tree is non-empty, we need to compare it with the current value and determine whether the current value needs to be deleted. If it needs to be deleted, we delete it. We'll discuss how to delete it later; if it's not the value we want to delete, we still need to compare it and find the subtree where the value might exist, then create an updated tree after deletion. The most crucial part of this process is how to delete the root node of a tree. If the tree has no subtrees or only one subtree, it's straightforward because we just need to replace it with an empty tree or the only subtree. The trickier part is when there are two subtrees. In this case, we need to find a new value to be the root node, and this value needs to be greater than all values in the left subtree and less than all values in the right subtree. There are two values that satisfy this condition: the maximum value in the left subtree and the minimum value in the right subtree. Here, we use the maximum value in the left subtree as an example. Let's take another look at the schematic diagram. If there are no subtrees, we simply replace it with an empty tree; if there's one subtree, we replace it with the subtree. If there are two subtrees, we need to set the maximum value in the left subtree as the value of the new root node and delete this value from the left subtree. The good news is that this value has at most one subtree, so the operation is relatively simple. ```moonbit fn remove_largest(tree: IntTree) -> (IntTree, Int) { From bbdce790146d96d5ea8a368f90f120d078392de1 Mon Sep 17 00:00:00 2001 From: Milky2018 <842376130@qq.com> Date: Wed, 24 Apr 2024 17:39:23 +0800 Subject: [PATCH 3/7] Update the slides for lecture 5. --- course5/lec5_en.md | 347 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 347 insertions(+) create mode 100644 course5/lec5_en.md diff --git a/course5/lec5_en.md b/course5/lec5_en.md new file mode 100644 index 0000000..14d157e --- /dev/null +++ b/course5/lec5_en.md @@ -0,0 +1,347 @@ +--- +marp: true +math: mathjax +paginate: true +backgroundImage: url('../pics/background_moonbit.png') +headingDivider: 1 +--- + +# Modern Programming Ideology + +## Trees + +### MoonBit Open Course Team + +# Data Structures: Trees + +- Trees +- Binary trees +- Binary search trees +- Binary balanced trees + +# Trees in Everyday Life + +- Many data structures in everyday life resemble a tree + - Pedigree chart (also known as, family tree) + - File structure + - Mathematical expressions + - ... + +![height:300px](../pics/trees.drawio.png) + +# Logical Structure of Trees + +- In data structures, a **tree** is a finite collection of **nodes** that have a hierarchical relationship + - Nodes are structures that store data, and there exists a parent-child relationship between them: parent nodes and child nodes + - If the tree is not empty, it has a **root node**, which has no parent node + - All non-root nodes have a unique parent node + - Nodes without child nodes can be called leaf nodes + - No node can be its own descendant: the tree cannot have cycles + - An edge in a tree refers to a pair of nodes (u, v), where u is v's parent or v is u's parent + +![](../pics/abstract-tree.drawio.png) + +# Logical Structure of Trees + +- This is not a tree + +![](../pics/not-a-tree.drawio.png) + +# Logical Structure of Trees + +- In computers, the root node of a tree is on top, and child nodes are below their parent nodes +- Related terminology: + - **Depth** of a node: the length of the path (number of edges) from the root node down to that node + - The root node's depth is 0 + - **Height** of a node: the length of the longest path from the node down to a leaf node + - Leaf node's height is 0 + - **Height** of a tree: the height of the root node + - A tree with only one node has a height of 0 + - An empty tree (a tree without nodes) has a height of -1 +- Some definitions equate the height of the tree with the maximum level, with the root as the first level + +# Tree Storage Structures + +- There are various ways to store trees (taking binary trees as an example, omitting the data stored in the nodes) + - List of node to child node relationships: `[ (0, 1), (0, 2), (1, 3) ]` + - Algebraic data structure definition + ```moonbit no-check + Node(0, + Node(1, + Leaf(3), + Empty), + Leaf(2)) + ``` + - List definition + ![](../pics/list-tree.drawio.png) +- The logical structure is independent of the storage structure + +# A Variety of Tree Structures + +- Segment Tree: Each node stores a segment and corresponding data, suitable for one-dimensional queries +- Binary Tree: Each node has at most two branches: a left subtree and a right subtree +- KD-Tree: Supports storage and querying of K-dimensional data (such as points on a plane, points in space, etc.) in a binary tree, with each level changing the dimension of the bifurcation criterion +- B-Tree: Suitable for sequential access, beneficial for data storage on hard drives +- R-Tree: Stores spatial geometric structures +- ... + +# Data Structures: Binary Tree + +- A binary tree is either empty or consist of nodes that have at most two subtrees: a left subtree and a right subtree. + - Both subtrees of a leaf node are empty trees +- Based on the **recursive enumeration type** definition (assuming stored data are integers here) + +```moonbit +enum IntTree { + Node(Int, IntTree, IntTree) // data, left subtree, right subtree + Empty +} +``` + +# Traversal of Binary Trees + +- **Tree traversal** refers to the process of visiting all nodes of a tree in a certain order without repetition +- Depth-first traversal: Always visits one subtree before visiting another +- Breadth-first traversal: Starting from the root node, visits nodes of the same depth layer by layer + +![](../pics/traversal.drawio.png) + +# Traversal of Binary Trees + +- Preorder traversal: Visit the root node first, then the left subtree, then the right subtree + - `[0, 1, 3, 4, 5, 2]` +- Inorder traversal: Visit the left subtree first, then the root node, then the right subtree + - `[3, 1, 4, 5, 0, 2]` +- Postorder traversal: Visit the left subtree first, then the right subtree, then the root node + - `[3, 5, 4, 1, 2, 0]` +- Breadth-first traversal: `[0, 1, 2, 3, 4, 5]` + +![height:6em](../pics/traversal.drawio.png) + +# Depth-First Search: Using Search as an Example + +- To find a specific value in a tree's nodes +- Structural recursion + - First, handle the base case: an empty tree + - Then, handle the recursive case and recurse + +```moonbit +fn dfs_search(target: Int, tree: IntTree) -> Bool { + match tree { // check the visited tree + Empty => false // empty tree implies we are getting deepest + Node(value, left, right) => // otherwise, search in subtrees + value == target || dfs_search(target, left) || dfs_search(target, right) + } +} +``` +- The difference between preorder, inorder, and postorder searches is the order of operations on the current node + +# Short-Circuit Logical Operations + +- Short-circuit operation: If the result of the current evaluation can be determined, the calculation will be terminated, and the result will be returned directly + - `let x = true || { abort("Program stops") }`: Because `true || any value` is always true, the expression on the right side of `||` will not be evaluated + - `let y = false && { abort("Program stops") }`: Because `false && any value` is always false, the expression on the right side of `&&` will not be evaluated +- Tree traversal + - `value == target || dfs_search(target, left) || dfs_search(target, right)` will stop traversal as soon as the target is found + +# Breadth-First Search + +- Visit each subtree on the same level one by one and in order, then proceed to visit their subtrees +- The implementation of the algorithm relies on a First-In-First-Out data structure: queue + - For the trees currently in the queue, we dequeue a tree, operate on its root node, then add all of its non-empty subtrees from left to right to the end of the queue, until the queue is empty + +![](../pics/bfs.drawio.png) + +# Data Structure: Queues + +- Similar to queuing in everyday life, the first person to enter the queue gets served first +- The insertion and removal of data follow the First-In-First-Out (FIFO) principle + - Data is inserted at the back of the queue and removed from the front + +![](../pics/queue.drawio.png) + +# Data Structure: Queues + +- The queue we use here is defined by the following interfaces: + +```moonbit no-check +fn empty[T]() -> Queue[T] // construct an empty queue +fn enqueue[T](q: Queue[T], x: T) -> Queue[T] // add element to the tail +// attempt to dequeue an element, return None if the queue is empty +fn pop[T](q: Queue[T]) -> (Option[T], Queue[T]) +``` + +- For example + +```moonbit no-check +let q = enqueue(enqueue(empty(), 1), 2) +let (head, tail) = pop(q) +assert(head == Some(1)) +assert(tail == enqueue(empty(), 2)) +``` + +# Breadth-First Search: Using Search as an Example + +- To find a specific value in a tree's nodes + +```moonbit no-check +fn bfs_search(target: Int, queue: Queue[IntTree]) -> Bool { + match pop(queue) { + (None, _) => false // If the queue is empty, end the search + (Some(head), tail) => match head { // If the queue is not empty, operate on the extracted tree + Empty => bfs_search(target, tail) // If the tree is empty, operate on the remaining queue + Node(value, left, right) => + if value == target { true } else { + // Otherwise, operate on the root node and add the subtrees to the queue + bfs_search(target, enqueue(enqueue(tail, left), right)) + } + } + } +} +``` + +# Data Structure: Binary Search Tree + +- To facilitate searching, we arrange data in ascending order, thus forming a **Binary Search Tree** based on the binary tree: + - Data in the left subtree is less than the data at the root node, which is less than the data in the right subtree. + - An inorder traversal (left, root, right) will visit data in acsending order. + - The worst-case number of searches is the height of the tree + 1, not the total number of elements. +- Insertions and deletions in a binary search tree have to maintain the order. + +![](../pics/bst.drawio.png) + +# Binary Search Tree Insertion + +- For a tree: + - If it's empty, replace it with a subtree containing only the inserted value. + - If it's not empty, compare with the current value and choose the appropriate subtree to replace with the subtree after insertion. +![](../pics/bst-insertion.drawio.png) + +# Binary Search Tree Insertion + +- For a tree: + - If it's empty, replace it with a subtree containing only the inserted value. + - If it's not empty, compare with the current value and choose the appropriate subtree to replace with the subtree after insertion. +```moonbit +fn insert(tree: IntTree, value: Int) -> IntTree { + match tree { + Empty => Node(value, Empty, Empty) // construct a new tree if it's empty + Node(v, left, right) => // if not empty, update one subtree by insertion + if value == v { tree } else + if value < v { Node(v, insert(left, value), right) } else + { Node(v, left, insert(right, value)) } + } +} +``` + +# Binary Search Tree Deletion + +- For a tree: + - If it's empty, do nothing. + - If it's not empty, compare with the current value: + - If the current value is the node to be deleted, then remove that node. + - Otherwise, find the subtree where the value might exist, and update it with the subtree after deletion. +- To delete the root node of a tree: + - If there are no subtrees, replace it with an empty tree. + - If there's only one subtree, replace it with that subtree. + - If there are two subtrees, replace the root node with the maximum value in the left subtree, while also deleting that maximum value in the left subtree (or alternatively, operate on the minimum value of the right subtree). + +# Binary Search Tree Deletion +![](../pics/bst-deletion.drawio.png) + +# Binary Search Tree Deletion + +We use a helper function `fn remove_largest(tree: IntTree) -> (IntTree, Int)` to find and remove the largest value in a subtree. We keep traversing to the right until we reach a node with no right subtree. +```moonbit no-check +match tree { + Node(v, left, Empty) => (left, v) + Node(v, left, right) => { + let (newRight, value) = remove_largest(right) + (Node(v, left, newRight), value) +} } +``` + +We define the deletion operation `fn remove(tree: IntTree, value: Int) -> IntTree` +```moonbit no-check +match tree { ... + Node(root, left, right) => if root == value { + let (newLeft, newRoot) => remove_largest(left) + Node(newRoot, newLeft, right) + } else ... } +``` + +# Data Structure: Binary Balanced Trees + +- Binary search trees can become unbalanced, with some nodes at deeper levels, which causes poor performance: + - The worst-case number of searches is the height of the tree + 1; the height of a binary tree of size $n$ can be as high as $n - 1$. +![](../pics/worst-bst.drawio.png) +- To avoid this, we use balanced trees where the height difference between any node's subtrees is minimal: + - The height of a balanced tree is approximately $\texttt{log}_2{n}$. + - Various implementations of binary balanced trees include AVL Trees, 2-3 Trees, Red-Black Trees, etc. + +# Binary Balanced Tree: AVL Tree + +- When the tree becomes unbalanced, we rotate the trees to regain balance: + - Reorganize the tree by height, to make the taller subtree in a shallower position. +- AVL trees will be adjusted after each insertion or deletion to maintain balance: + - Insertion and deletion operations are similar to those in a standard binary search tree. + - We add a height attribute to the node definition to facilitate height comparison. + +```moonbit no-check +enum AVLTree { + Empty + // current value, left subtree, right subtree, height + Node(Int, AVLTree, AVLTree, Int) +} +fn create(value: Int, left: AVLTree, right: AVLTree) -> AVLTree +fn height(tree: AVLTree) -> Int +``` + +# Binary Balanced Tree: AVL Tree + +![height:20em](../pics/rotation.drawio.png) + +# Binary Balanced Tree: AVL Tree + +We rebalance a tree with the following operation: + +```moonbit no-check +fn balance(left: AVLTree, z: Int, right: AVLTree) -> AVLTree { + if height(left) > height(right) + 1 { + match left { + Node(y, left_l, left_r, _) => + if height(left_l) >= height(left_r) { + create(left_l, y, create(lr, z, right)) // x is on y and z's same side + } else { match left_r { + Node(x, left_right_l, left_right_r, _) => // x is between y and z + create(create(left_l, y, left_right_l), x, create(left_right_r, z, right)) + } } + } + } else { ... } +} +``` + +# Binary Balanced Tree + +We rebalance the tree after adding a new value: + +```moonbit no-check +fn add(tree: AVLTree, value: Int) -> AVLTree { + match tree { + Node(v, left, right, _) as t => { + if value < v { balance(add(left, value), v, right) } else { ... } + } + Empty => ... + } +} +``` + +# Summary + +- In this chapter, we learned about the tree, including: + - Definitions and related terminology of trees + - Definitions and traversals of binary trees + - Definitions and insertion/deletion operations of binary search trees + - Rebalancing AVL trees +- Further reading: + - Chapters 12 and 13 of "Introduction to Algorithms" \ No newline at end of file From 688ca216ef7be0ae97eb49825effea24b7a4b773 Mon Sep 17 00:00:00 2001 From: Milky2018 <37078809+Milky2018@users.noreply.github.com> Date: Mon, 29 Apr 2024 14:06:20 +0800 Subject: [PATCH 4/7] Update course5/course_en.md Co-authored-by: Zihang Ye --- course5/course_en.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/course5/course_en.md b/course5/course_en.md index a21afe3..d51d319 100644 --- a/course5/course_en.md +++ b/course5/course_en.md @@ -197,7 +197,7 @@ fn remove_largest(tree: IntTree) -> (IntTree, Int) { ```moonbit no-check fn remove(tree: IntTree, value: Int) -> IntTree { match tree { ... - Node(root, left, right) => if root == value { + Node(root, left, right) => if root == value { let (newLeft, newRoot) => remove_largest(left) Node(newRoot, newLeft, right) } else ... } From c3f968ecfbc2fda8e22960f06b8cffeff5267fe0 Mon Sep 17 00:00:00 2001 From: Milky2018 <842376130@qq.com> Date: Mon, 29 Apr 2024 14:26:41 +0800 Subject: [PATCH 5/7] Slides layout and formatting. --- course5/lec5_en.md | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/course5/lec5_en.md b/course5/lec5_en.md index 14d157e..c2b2713 100644 --- a/course5/lec5_en.md +++ b/course5/lec5_en.md @@ -39,6 +39,8 @@ headingDivider: 1 - No node can be its own descendant: the tree cannot have cycles - An edge in a tree refers to a pair of nodes (u, v), where u is v's parent or v is u's parent +# Logical Structure of Trees + ![](../pics/abstract-tree.drawio.png) # Logical Structure of Trees @@ -49,7 +51,7 @@ headingDivider: 1 # Logical Structure of Trees -- In computers, the root node of a tree is on top, and child nodes are below their parent nodes +- The root of a tree is on top, and children are below their parents - Related terminology: - **Depth** of a node: the length of the path (number of edges) from the root node down to that node - The root node's depth is 0 @@ -150,7 +152,7 @@ fn dfs_search(target: Int, tree: IntTree) -> Bool { - The implementation of the algorithm relies on a First-In-First-Out data structure: queue - For the trees currently in the queue, we dequeue a tree, operate on its root node, then add all of its non-empty subtrees from left to right to the end of the queue, until the queue is empty -![](../pics/bfs.drawio.png) +![height:8em](../pics/bfs.drawio.png) # Data Structure: Queues @@ -274,10 +276,11 @@ match tree { ... - Binary search trees can become unbalanced, with some nodes at deeper levels, which causes poor performance: - The worst-case number of searches is the height of the tree + 1; the height of a binary tree of size $n$ can be as high as $n - 1$. -![](../pics/worst-bst.drawio.png) -- To avoid this, we use balanced trees where the height difference between any node's subtrees is minimal: + +![height:7em](../pics/worst-bst.drawio.png) +- To avoid this, we use balanced trees where the height difference is minimal: - The height of a balanced tree is approximately $\texttt{log}_2{n}$. - - Various implementations of binary balanced trees include AVL Trees, 2-3 Trees, Red-Black Trees, etc. + - Various binary balanced trees include AVL Trees, 2-3 Trees, Red-Black Trees, etc. # Binary Balanced Tree: AVL Tree From 63161cfd96481f4b1b6c5c308e3d9c95e206f4e4 Mon Sep 17 00:00:00 2001 From: Milky2018 <842376130@qq.com> Date: Mon, 29 Apr 2024 14:28:41 +0800 Subject: [PATCH 6/7] Translations of the drawio pictures of course 5. --- course5/abstract-tree-en.drawio | 43 +++++ course5/bfs-en.drawio | 96 ++++++++++ course5/bst-deletion-en.drawio | 294 +++++++++++++++++++++++++++++++ course5/bst-en.drawio | 122 +++++++++++++ course5/course_en.md | 16 +- course5/lec5_en.md | 18 +- course5/not-a-tree-en.drawio | 61 +++++++ course5/queue-en.drawio | 45 +++++ course5/traversal-en.drawio | 179 +++++++++++++++++++ course5/worst-bst-en.drawio | 94 ++++++++++ pics/abstract-tree-en.drawio.png | Bin 0 -> 19732 bytes pics/bfs-en.drawio.png | Bin 0 -> 32692 bytes pics/bst-deletion-en.drawio.png | Bin 0 -> 99689 bytes pics/bst-en.drawio.png | Bin 0 -> 38929 bytes pics/not-a-tree-en.drawio.png | Bin 0 -> 24251 bytes pics/queue-en.drawio.png | Bin 0 -> 14060 bytes pics/traversal-en.drawio.png | Bin 0 -> 54405 bytes pics/worst-bst-en.drawio.png | Bin 0 -> 49512 bytes 18 files changed, 951 insertions(+), 17 deletions(-) create mode 100644 course5/abstract-tree-en.drawio create mode 100644 course5/bfs-en.drawio create mode 100644 course5/bst-deletion-en.drawio create mode 100644 course5/bst-en.drawio create mode 100644 course5/not-a-tree-en.drawio create mode 100644 course5/queue-en.drawio create mode 100644 course5/traversal-en.drawio create mode 100644 course5/worst-bst-en.drawio create mode 100644 pics/abstract-tree-en.drawio.png create mode 100644 pics/bfs-en.drawio.png create mode 100644 pics/bst-deletion-en.drawio.png create mode 100644 pics/bst-en.drawio.png create mode 100644 pics/not-a-tree-en.drawio.png create mode 100644 pics/queue-en.drawio.png create mode 100644 pics/traversal-en.drawio.png create mode 100644 pics/worst-bst-en.drawio.png diff --git a/course5/abstract-tree-en.drawio b/course5/abstract-tree-en.drawio new file mode 100644 index 0000000..30f95b8 --- /dev/null +++ b/course5/abstract-tree-en.drawio @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/course5/bfs-en.drawio b/course5/bfs-en.drawio new file mode 100644 index 0000000..83c3b59 --- /dev/null +++ b/course5/bfs-en.drawio @@ -0,0 +1,96 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/course5/bst-deletion-en.drawio b/course5/bst-deletion-en.drawio new file mode 100644 index 0000000..84752ce --- /dev/null +++ b/course5/bst-deletion-en.drawio @@ -0,0 +1,294 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/course5/bst-en.drawio b/course5/bst-en.drawio new file mode 100644 index 0000000..7b3f7f9 --- /dev/null +++ b/course5/bst-en.drawio @@ -0,0 +1,122 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/course5/course_en.md b/course5/course_en.md index a21afe3..4c3c1a3 100644 --- a/course5/course_en.md +++ b/course5/course_en.md @@ -16,13 +16,13 @@ In data structures, a tree is a finite collection of nodes that have a hierarchi If a tree is not empty, it should have exactly one root node, which has only child nodes and no parent nodes. All nodes except the root node should have exact one parent node. Nodes without child nodes, which are the outermost layer of nodes, are called leaf nodes, akin to the leaves of a tree. Additionally, no node can be its own descendant, meaning cycles cannot exist within the tree. -![](../pics/abstract-tree.drawio.png) +![](../pics/abstract-tree-en.drawio.png) In a tree, an edge refers to a pair of nodes (u, v), where either u is the parent node of v or v is the parent node of u; simply put, these two nodes should have a parent-child relationship. We use arrows in diagrams to indicate parent-child relationships, with the arrow pointing from an ancestor to its descendant. The example below is not a tree. -![](../pics/not-a-tree.drawio.png) +![](../pics/not-a-tree-en.drawio.png) Each red mark violates the requirements of a tree. In the upper right, there's another root node without a parent node, implying two root nodes in a tree, which is not allowed. At the bottom, the left leaf node has an extra arrow pointing to the root node, implying it's the parent node of the root, violating the structure requirements. And the right leaf node has two parent nodes, which also doesn't comply with the requirements. @@ -65,7 +65,7 @@ enum IntTree { The first algorithm we will discuss is binary tree traversal (or search). Tree traversal refers to the process of visiting all nodes of a tree in a certain order without repetition. Typically, there are two methods of traversal: depth-first and breadth-first. Depth-first traversal always visits one subtree before the other. During the traversal of a subtree, it recursively visits one of its subtrees. Thus, it always reaches the deepest nodes first before returning. For example, -![](../pics/traversal.drawio.png) +![](../pics/traversal-en.drawio.png) in the diagram, we first visit the left subtree, then the left subtree again, leading to the visit of 3. Subsequently, we continuously visit the right subtree, resulting in the visit of 5. Finally, we visit the right subtree of the entire tree, which is 2. On the other hand, breadth-first traversal starts from the root node and proceeds layer by layer, visiting nodes at a certain depth before moving deeper. For the same tree, breadth-first traversal will visit the root node first, followed by subtrees 1 and 2, then 3 and 4, and finally the deepest node 5. @@ -93,11 +93,11 @@ Here, we supplement the content not mentioned in the second lesson, the short-ci Now let's continue with breadth-first traversal. -![](../pics/bfs.drawio.png) +![](../pics/bfs-en.drawio.png) As mentioned earlier, breadth-first traversal involves visiting each subtree layer by layer. In this case, to be able to record all the trees we are going to visit, we need a brand-new data structure: the queue. -![](../pics/queue.drawio.png) +![](../pics/queue-en.drawio.png) A queue is a first-in-first-out (FIFO) data structure. Each time, we dequeue a tree from the queue and check whether its node value is the one we're searching for. If not, we enqueue its non-empty subtrees from left to right and continue the computation until the queue is empty. @@ -149,7 +149,7 @@ So far, we've concluded our introduction to tree traversal. However, we may noti Previously, we mentioned that searching for elements in a binary tree might require traversing the entire tree. For example, in the diagram below, we attempt to find the element 8 in the tree. -![](../pics/bst.drawio.png) +![](../pics/bst-en.drawio.png) For the left binary tree, we have to search the entire tree, ultimately concluding that 8 is not in the tree. @@ -179,7 +179,7 @@ Here we can see the complete insertion code. In line 3, if the original tree is Next, we discuss the delete operation. -![](../pics/bst-deletion.drawio.png) +![](../pics/bst-deletion-en.drawio.png) Similarly, we do it with structural recursion. If the tree is empty, it's straightforward because we don't need to do anything. If the tree is non-empty, we need to compare it with the current value and determine whether the current value needs to be deleted. If it needs to be deleted, we delete it. We'll discuss how to delete it later; if it's not the value we want to delete, we still need to compare it and find the subtree where the value might exist, then create an updated tree after deletion. The most crucial part of this process is how to delete the root node of a tree. If the tree has no subtrees or only one subtree, it's straightforward because we just need to replace it with an empty tree or the only subtree. The trickier part is when there are two subtrees. In this case, we need to find a new value to be the root node, and this value needs to be greater than all values in the left subtree and less than all values in the right subtree. There are two values that satisfy this condition: the maximum value in the left subtree and the minimum value in the right subtree. Here, we use the maximum value in the left subtree as an example. Let's take another look at the schematic diagram. If there are no subtrees, we simply replace it with an empty tree; if there's one subtree, we replace it with the subtree. If there are two subtrees, we need to set the maximum value in the left subtree as the value of the new root node and delete this value from the left subtree. The good news is that this value has at most one subtree, so the operation is relatively simple. @@ -210,7 +210,7 @@ Here, we demonstrate part of the deletion of a binary search tree. We define a h Finally, we delve into the balanced binary trees. When explaining binary search trees, we mentioned that the worst-case number of searches in a binary search tree depends on the height of the tree. Insertion and deletion on a binary search tree may cause the tree to become unbalanced, meaning that one subtree's height is significantly greater than the other's. For example, if we insert elements from 1 to 5 in sequence, we'll get a tree as shown in the lower left diagram. -![](../pics/worst-bst.drawio.png) +![](../pics/worst-bst-en.drawio.png) We can see that for the entire tree, the height of the left subtree is -1 because it's an empty tree, while the height of the right subtree is 3. In this case, the worst-case number of searches equals the number of elements in the tree, which is 5. However, if the tree is more balanced, meaning the heights of the two subtrees are similar, as shown in the right diagram, the maximum depth of a node is at most 2, which is approximately $log_2n$ times, where n is the number of elements in the tree. As you may recall from the curve of the logarithmic function, when the number of elements in the tree is large, there can be a significant difference in the worst-case search time between the two scenarios. Therefore, we hope to avoid this worst-case scenario to ensure that we always have good query performance. To achieve this, we can introduce a class of data structures called balanced binary trees, where the heights of any node's left and right subtrees are approximately equal. Common types of balanced binary trees include AVL trees, 2-3 trees, or red-black trees. Here, we'll discuss AVL trees, which are relatively simple. diff --git a/course5/lec5_en.md b/course5/lec5_en.md index c2b2713..ae881c2 100644 --- a/course5/lec5_en.md +++ b/course5/lec5_en.md @@ -41,13 +41,13 @@ headingDivider: 1 # Logical Structure of Trees -![](../pics/abstract-tree.drawio.png) +![](../pics/abstract-tree-en.drawio.png) # Logical Structure of Trees - This is not a tree -![](../pics/not-a-tree.drawio.png) +![](../pics/not-a-tree-en.drawio.png) # Logical Structure of Trees @@ -106,7 +106,7 @@ enum IntTree { - Depth-first traversal: Always visits one subtree before visiting another - Breadth-first traversal: Starting from the root node, visits nodes of the same depth layer by layer -![](../pics/traversal.drawio.png) +![](../pics/traversal-en.drawio.png) # Traversal of Binary Trees @@ -118,7 +118,7 @@ enum IntTree { - `[3, 5, 4, 1, 2, 0]` - Breadth-first traversal: `[0, 1, 2, 3, 4, 5]` -![height:6em](../pics/traversal.drawio.png) +![height:6em](../pics/traversal-en.drawio.png) # Depth-First Search: Using Search as an Example @@ -152,7 +152,7 @@ fn dfs_search(target: Int, tree: IntTree) -> Bool { - The implementation of the algorithm relies on a First-In-First-Out data structure: queue - For the trees currently in the queue, we dequeue a tree, operate on its root node, then add all of its non-empty subtrees from left to right to the end of the queue, until the queue is empty -![height:8em](../pics/bfs.drawio.png) +![height:8em](../pics/bfs-en.drawio.png) # Data Structure: Queues @@ -160,7 +160,7 @@ fn dfs_search(target: Int, tree: IntTree) -> Bool { - The insertion and removal of data follow the First-In-First-Out (FIFO) principle - Data is inserted at the back of the queue and removed from the front -![](../pics/queue.drawio.png) +![](../pics/queue-en.drawio.png) # Data Structure: Queues @@ -210,7 +210,7 @@ fn bfs_search(target: Int, queue: Queue[IntTree]) -> Bool { - The worst-case number of searches is the height of the tree + 1, not the total number of elements. - Insertions and deletions in a binary search tree have to maintain the order. -![](../pics/bst.drawio.png) +![](../pics/bst-en.drawio.png) # Binary Search Tree Insertion @@ -249,7 +249,7 @@ fn insert(tree: IntTree, value: Int) -> IntTree { - If there are two subtrees, replace the root node with the maximum value in the left subtree, while also deleting that maximum value in the left subtree (or alternatively, operate on the minimum value of the right subtree). # Binary Search Tree Deletion -![](../pics/bst-deletion.drawio.png) +![](../pics/bst-deletion-en.drawio.png) # Binary Search Tree Deletion @@ -277,7 +277,7 @@ match tree { ... - Binary search trees can become unbalanced, with some nodes at deeper levels, which causes poor performance: - The worst-case number of searches is the height of the tree + 1; the height of a binary tree of size $n$ can be as high as $n - 1$. -![height:7em](../pics/worst-bst.drawio.png) +![height:7em](../pics/worst-bst-en.drawio.png) - To avoid this, we use balanced trees where the height difference is minimal: - The height of a balanced tree is approximately $\texttt{log}_2{n}$. - Various binary balanced trees include AVL Trees, 2-3 Trees, Red-Black Trees, etc. diff --git a/course5/not-a-tree-en.drawio b/course5/not-a-tree-en.drawio new file mode 100644 index 0000000..2a990d1 --- /dev/null +++ b/course5/not-a-tree-en.drawio @@ -0,0 +1,61 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/course5/queue-en.drawio b/course5/queue-en.drawio new file mode 100644 index 0000000..fe72ff2 --- /dev/null +++ b/course5/queue-en.drawio @@ -0,0 +1,45 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/course5/traversal-en.drawio b/course5/traversal-en.drawio new file mode 100644 index 0000000..1dc764e --- /dev/null +++ b/course5/traversal-en.drawio @@ -0,0 +1,179 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/course5/worst-bst-en.drawio b/course5/worst-bst-en.drawio new file mode 100644 index 0000000..9ed83be --- /dev/null +++ b/course5/worst-bst-en.drawio @@ -0,0 +1,94 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pics/abstract-tree-en.drawio.png b/pics/abstract-tree-en.drawio.png new file mode 100644 index 0000000000000000000000000000000000000000..28bd71afa710754620024c091b2e1252d3a53cd4 GIT binary patch literal 19732 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 DAsPa0 literal 0 HcmV?d00001 diff --git a/pics/bfs-en.drawio.png b/pics/bfs-en.drawio.png new file mode 100644 index 0000000000000000000000000000000000000000..1aef20bc58a040377ab851dfe8e3b93e4d6ab93b GIT binary patch literal 32692 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 ipacQF;``cZ!5cC@BgEA`(hUDJ@7UAR&mPfOJdO zx36*?)S1`$-kEX!%scaQ6b^^8&)IA3XFcm#YoB{fQC<=YofsVf0Rc-|N=z96;ZP?6 z0+J@`5pZNOu;>u@2hm|(O^mGfE+hwaGqbeRr)HJlU}OfDqLtG(Ftc`m+M80diGc5=tsRUk!N1@z_*+2* z{G|^5XJOW5;n3we3%(S#v9UB#GrBBe<^a128y6!RCpb(iBc&=QOU)_@zP2>8FarNb z8W~tXVZUN%r|-;Y1_h_Hg4<%`0Ea|P?VwiRBncK)W=3X4PG)XyMiypn@RMI2Re}}5 z$nxnfRrHPZ?acNK2b%>W2Yr*zGhoMHV5}kTY$MJpBFf5Y0Oc}}0Ji}<$H~af-V99J zr%8kl4*P+FtBuj;qlQLKW(MF+U`Oo@^ey)evwS{s8ER)}WcT?@Fkh_HY~s|+!r)Zc zA2v}#Gkp^~eJk*dwLW;9Ps31)b5RS6!v27HgPkVMO)bnqEdm}JHip@r*&JmoB~2iT z5F=Nk^RmvuHp0@^tjj0^e@RM;2T|SS*!p_G2`J#rdpO0`ebA3Kw zVh0~*??GS(RLtDqPxt9rSeZ>6%?yp~_pbK&Hyxl*O9wNXuMZkPt*wCves!Y0ogLKq z>(h*(mU~aPH>wSAy{~==c0lF3S%w`|Gc$AmP6+dM2Z59nVFcvM`qy!E&`iH zD}DIMdrx9-s&5E&{`~vj8S3*q!e`SC3I*5OXUF|NhM#2RB5Gs_TM6)a+#3ft;s5{d zewhusFAMRHT#i%G)=k7rLQ)ONEW;toVy7rBZ_mI9rUf=LPWqOPa8LYnz}~?X?$k!s zhQctbfoZaaT7$Dh4E60zKLH5~_{P-1$`bqt_9g7NqP~NJksWODz}%P(9JL1+WbwsP zz*j}=ppMptpDqBF0{{@%9oXpq@|b&1Ze;kCAN=RZ|HTB7MgSxn>|DV`oqur;j=i}v z-RBwbV|GTC`VMAJUpt-to|l?@x!kWUv+up&mm5)p0+0lEvA6KpIrna1Z`rZIhlh`3 z4|TLNFxvYq*qr>>ZT1fjiviyZ$;JHjkeuv$-@}J=(6=)&a`-QXWCK7Y0T2d0Ise%> zduM-I96vhqyEXKyj?2yVuj8^Z{~X8VhCAxdb6gPM|EZq47ku{t?ALGzwR13qnn11f zEoGrln>}PTH*#=r-HXKfjt)=&oBMG0Gs22OEunVcd}>xU=1>29hrKW~{!O&~j6R=! zpY>Ol+#VJA3>p97JV5MV;PuDR`*(Zy??K8xAAeyBQTQ=s`|!iL$mP9-E@3-u>imjiC6Js4+U+q3q8Gw&YJ|4s8U8+?I6 zPFqJ9ZwIgk2SwIj4*gHM0p~x)4Itkw)PGnc-ShLG7)gIm?D!>ue3NZ(vh9ULIKTj9 z=@S)z2ZldC!Qo{7W=M{`7z`is;3hZ+)w$su;)gtuAm}R|lObvcsQg zZ>b+xrU-Y!eYSzK!u^yGs12X_t;K*%B-X@49~_gwv;&_(v2PZ!z$v2>ATk5PPub1>lB=kTD~ z^{IYoY-!}OSJ4sKSKKkM)VH@cGXTl*K56mmMe-R-|M{gF4)~(`lF4wx3ed3mgeMk% zelEko{k8fAD%;-SO?2BICOIUwiW5REm?oXr^Aff%5Tfj4&gGViXO>NmvD*siLKQWG9CmJlwaKppp z6?pD?@El<;l$thj|iENZ@I;R?OlMg<9(|YZsdPS<|lgji`Mh~rUveR zjvxHZvgRM)n7=my!(IKLa7^x>Pcb3?Scb{ACtrSrbKmHh|Mswa#=39*{uP;<`y1l( zEA1rzby4>hy!~bi01GqM*Am~ajCx?@b+$bLcAtMLfc@}ax>!Er9|dW|2}&)_unhjfa4FMarlUJY}fpWnK|wns4kc^3R%sSm+@`Zrm}ueUWA8^ib? zV5VPQy78Hp0(AV@HHqI$kN(7drf)awd}*CNaBVE?f0?rU7h&!ml>QiV|5w@t+4r>5 z1B1E0+k!uz3;sP(ll}Xi!tYn*!D{$q`$i0AhbLzT4LiJua^zLjVXu5rHK zT)JnjeQ0>FR?e3fwZirDgKM0Fmd^cNb)5a@zn$xE3QT)5vM(9wooaHs9{7|FwMWfNZVj*b^N0nf)_o*dOu!eQ*2c*TDb2SK|Jr z)XMb@Sg^ul@gFWL{^pR}@FC#pF8q7=kO#Jhg5!H4{jcMGo&mUR_rJK~4{d;eeB-#^ zI?;b!4*y^D+wXIXfBp6!G5zeM4$|A3b-#9%LKe@Wuu$o}U8F6TE* zp5G05a22wEYu{h+xO) z*Bwj0mX*R^$Gg8(7Jdv4F8gWY-y;-pec!)-&~;drFCUU|;DuPOy^7mG0aQ3n{uogA z-0mOWR|B7seSmt|H|&AZ!*6&`1 z`{%Q12>iXOaA*8}&;!e-;Vk3Nhky9{clW=k@^kzDey06-E&R%>qkr6B`Foi)WG~nK ziGkn`>2nCy)N(*#J#URw){K5|M6Rie#lgQzoGwEHWG0ElCWx;_o{s|H|(1KN{!$ z#4S=R%-^msxDIjPjL7|cb>lmIZ{MeB?R^^2SGL&qX-2T)iuw-V6N+G;RRoqQGi+Dt z*Rl!dTNC-37X7A(^2dYEK6}7bu>I90__5#pQLBF_dExp|S^K|MMm{T#zaluYeA%?U zmoNQuO6lBtVDpt41B-h5w7`Eo*XmDc7UhO76nNGR|NakW-M{I%KU^#aR8={4p!unIQ!_i65TJkP+<&dJE|6LDkv|NIEm?@{J2Q7?WkLdikb&Au28?kRB3*_TDa8+-O=k?>=1|NW^wi>4CB>b4MbW-et(CowJ;+e;QM z&J6!1^#D$OPE!9jw8yi<9qzZXvHu#8|9nvSbVWNT6nyNpI5o2{Fv~B0;G@~;+nCBh z4UH_nI_J|*4bAjT?DVbnez5lo;N!8u2VKK1mmj(wh=6bsL0U{$)kSBz4CD623vYM5 z*-XtFXroOVgcXmRkc!je6Ry-e9WaEkCJ{i4%Jbg$K630y@rVFX335do)HeEDXDTVY zT(KHaQn6#Qh@ymIH|TNu7fl-HcfGrE0{F38^zXgtx0o9%$!fB&F(wmS)tKsE<>`IY zu(Q3nig5@HkHxpZqN_3E!Xv}#0IWRMCFAtW%qZ;=r-uGA_mr$G`Sa(`Ke+V7xb40; zhFRaUg2<>S>9OYcl>7HZ8k?GK+$O!NgNY0gxGvmiNr_e?>a!%n*L%sF71hRrN>u(? zw4ABx85zCDRuE)!b92L?=l*$y4Y)@1_dHkLwx!4rOtdEX<(sujY-i=?tKQ+XI=8tp z6T$DkLM!SHzRELer@2&Q9sgMCsq%IfbfDa>fjXu>QP}T!I;s6B-`i+59yRm`_zFm8 zX)4#LUpzNzM>;;Zh8oOVh-s=?7m#pRQciE`O(v`T2iaI&=PcGl6imXC+Z)R&B`scu zoC*k-bm%eg=@kQ3a`dYo{d_>%ED)sHkpM6q~oFLyNs;ZSyjI&>rQc0Vy`i6&w*rX6?kXh|NsXN2zY!MW~Z}=7th7>Ch07*>DoU!0q`}G*;u6 zghaefkJ+L9y^!R-66dClbQPnXd^5W`GH2T1JHE)4RFw<*$*SsSaHU{Znz%`+sULt) z7f6(4`(d&%ZD(ybY&5H67I&r{vrf}?fL(2^nqucjBX_r?UB1l)P1ss*@s1|vcayp&;3?7&5qnhuVH?_!rZj2o;OJOz zD}F+xKtk|wMuzfg)?E3fH4g_Ja&`w;Uc~6QN$)JiRMf|s zB&2^Jfv9eQZ{ltrXS2b-)-G_HSJ!*naUGn_F!Qb`Mn0aWp;JwlAvMnKJT2cn?;Tgy z53wdA49q_K;aS9b6>^!Y99b$a=F*TU{ zOjABJ%Z-l{i)C}3Oi-Rut@(P&u==iw9mke+$tZ+u`d){2xhpFp7|cEkR){F!!blEW z_}$;yMxPx_v2T#i$Wlvu9x zJror|d)2z{S%dfPs&^CGnYfd@&a;sm7H{h3yjDw&pb4yxMA*F+Cpa9QrkhOc_&k(4 z6nS{qw+hpDVYrSiyC0&|T415Z=D${d!qaxVHK|c%?SXWJ$4Dg=)v-8WFq;6*k@|P;$K-1&h!oQjpA&v^sc6i0n zmFBdybZ-}Ly2e1D3$b=S%zJBCsB_*zb$4q_5UNf%YVjcOIsk)2>xP=MXDSzN*&*Ht zf+iCm;RuZ*bL!R)RJ`7prc-DcyVd2r9dnL?w@xu%UDzq$OoGdOeSd-Aczfc`m80m> zN1$)>#6Ps$qiE11Ssk8y6ebNcUYR_q?1en_dOkI+K;zPpI6bfK2SZs7$12H(i((xqnJ$??Jg zq2wN>r@a%9imNS=+z$i6)VLYOW>c4km>XX293`l*9q-e#9Hf{@9b!P$UeXFCWqq$cFCjhT13_GGZ+)K5mk( zo&Q*ZyS&@#Z01g|ztQyNv39cgBqYxyENw2@t#PV&Cj7A$?lIEkif(PexzeRP{A&gg z8|Z4SDkg7(&8K%Nz&cv=XYx2TW?dc=Z$1*}-_hbZYkz*#_((R-rPP5ZCJH+DIITxc zIFU9p=^r=pGCK{7Ok?%|dc!1{_|b4NWrkX?eto{>+dQSS>%o(rn=9#?-Ri=DDlB9+ zmRLtq$`_-uiyww<=3(>A`&`F996hB@LYg|^ZW6}7qVCszj*#nJ5mar}`Uy8(RU@Pa zrJ8KD5GPK;u_b|j^o=Gos`HT=m&YI`F}u`k>5}~D11!Wwk`mMnLUIAsoufkN6L?``|LnL zUIn-xtda#6CE?U63=GrbS(}yf&6sJsyE}8c=RDB@A89a6@peMqUQHfr_2luvc>i3O z7|Ek(@EtP7tKwS!`4>!HN({=?!laX)ofp*7U!X&7_+`C0gO-DO<%JotAP><*;_AZv z8t~{R=WYGA66%M&Fmzl{zRg(wWhVxdmt^91Nk zM0P}-ibr;r1a~94(r*)>=qb7lY|lDhcrCbAg>Cr0=9(Qq*%F$oeIkTuYf`=ou|yvS z;#U(3l(3TVXBzMm=XJc+jSA>|PGoG(mdxEWRlLdk23oQ0WOTc_TimN>&5^is-ZB(B zNNaRxhX~W&0)Et))5fo!vuGVEy|U|Y9#UE z-VKT}UmweRZhqW}d7kB}`z;3@eEbU^BBXtWDLp;!8`OoG>jWNsE}gA)CO?iL@O7%E ztln$902<5}!(oCt;(qN6M#GWuZ7M#dFr^C)mpq?ZCL0%|mlq9u zKK>F@{a7u;NASe74dr;e`4;az#=2#e9M{!8XM1w4x<2!<3+(i5ysl=+Jz??^+c~BP zl>BOyN5r*wt}e-Jd>|;Kv>0ch=I) zUacCus)Pc)(|!2GYbIn`+Q;Vz&`G$gRTTop5k?_~^~a*{CF}L@#xR6~&EuJz8ecn+ z8r|czH}+dqp2i#;Mxfx|U8@u9$f63qJbinZ5+Q&qSjb9sYRg8A4C6%VJ+Eh#K`$DM z1uhQ+YUmd+l^(#JOPOGQUu_q)=Llyf(=X@f4>Zi>YCQ!_`M5 zrxq3ho(&JEBMVj5kxm+mR@M;;;N`05MX0bAS>~{*Dk&v71=(?L+utP^z9mEh3*yUY zgf<)b$M8qz*(2}zkhQgVd|*2_$yKo~=jhgGraHXZD&5L-J7V4(1z$aPJlN;Bwhd_j z%m$ArvxtY%>9z6SUtS>Ntp+41rd^(wA=|znQG%nf`aMkoI{(Iaa%X5kd0?oD3q&c< zA7du_&@=p@S6lyL|=42u!tmzGT$j`%(En6c1R85L$SU_lsQfV>ER z(q;}XJPV3Z@v`2KO@hSfqT{?DxDgAMw(a?WA|)(;On*dCtm`PDVu?48r@N9oW$ zMxpS?!Lgn0tzv$jYsb{0r58hr4$-WXL`uLR;D|vvi^CH0H$<|_J=#hkyhQjLiTnY~< z5swY7N$CpO5a%=ZT+!lW2hCfZf7HNWaMIC@=s&74z-S=HpdTszU%TEHpsoM=r6OxjJAVxB*&BbSTuNX?pUVGzQBM=e0>fO=VV ztOszh8MYQal@q?Hoi0#78-%5}zlbK)n`GPQk}(m@g-YS ziG1q7dJPI%Xdq>r`|Q)jI>DXXByRP?fgZUeVHb*Cn#h;dQ@<=$_waebMe5sr2J!hz z!O7Ab8NcKe7>rlZVJLNlj8cbz#j|Mmp|G}jEVXo6wOXpfIlE$e2Kwl*ajH^Cyei-7 z7^eIo;#w*v>+MOZqM7!EK_YjMu$d3x9Wnag2^~9|ds4#jp{Sw>zwI<}Ex&xpgc@}( zVW)axz)`0oAc8e_+2CR!<~4s9A{*e^*lcnY8=!+SEpS)3B)uqpA>lKe+)dSAT;>~W zZs=d4R;+RrAsL%)(1tvKvbNbdX_;(Vt0Yw_%w4z#QKLMSqcjK;y?Ns8@m0UvXE(qs zF)}b*pzC}~8a2v$BooVY=GYOV6Ra6SW+!T+*nAL!FBKs+YgE3y@q}|MmxYh($VD6V zXokvbq;U^jTpOFL`pRmmwLR*O^uKS%wb4LONSTk#%$H&>cLKR)oxt_*0>*~X+jN>_ zIZ~OP`h#g~p?tg{la{r-=o70l*#BVm^@nWps@c$YrhJpy8l z+0FaAoXDIRO6Ey6>k1yd)bW2)*Z+e-u30uaKJ`Bl(W^A14lhx~JS16KuT(>Z4LB8&}be@>^ zl{!vWsAW!jaB9io;hGi?0=$xewbn|07SeQQo}0GhOREDjTd6fi`DSB>c3i?sJqgTN z1c+^~AT_V%5WWyX@&d{DT2l05b{nbX=_f52=S|$(ST!wjOam#ep>9Ysq$9tY5L_4fQp^!A-iUgjJUSNs4}z79dE-{1Sh#_c-rJGxUg{ zL_tI{L45GotDO1}ghQJ5a++SCgvzmnX*E; zrsoqgFN(k&ZOtHX>nPmt#zEPY@1QPG%V?JKs%D{O)J5XftZ3i zI*ut%J)wFGqJycB(CkC04CIVB<*oHlL+a^7XSLI##=Py+k0u=@{}jUo_< z8k-f%#J{zREB856YDsQWrgVAwGKej=yc!HnosfK*OLqk!FbVQLj-fKK_A&>)3(jDx z3h(-&f$Cy&+2Gv9b zSrSoa8dASrf`F%+s8yT<2PVs7s_J?_-=NL*9@M&K%1{+i{ZoUcnsfbS7=?}LgRQX( zrTDXg6Pq$?Yd(HBy|%3Zjg3)sB#kdJ!dKL@!YYOci5Gp@2*_ZR-B7W(=j^riT-4Cq z;hn;xJ&;VlFCr5Fg8lAD~#wC?4yEdlM#TO zKzqnZ%;p&qrY&xzVdXW1X_2IR%r|`q037L? zyyNBB+9>i&if!UfF9&6T9tg*%)|&qiHl=dKqma2naiz~ogYKa^_q(QU^b1wuSdn&0 z_+%e1z3)S2o=>uL_9LYTV=}S#Ap*iB^?V6Wo0p`R3$OBwU)>34*J)OhtyHV{IOL&B zwopqw1;j^T1z)P=6&k}DXtHa1Z;Fgy2L_- zkd(r(Jz|ERNk)=rZ3!^+N{eu0B$e7YsFUQx);-NZ?*n3BfQGQX=gO0N7syi!-Y;$R zpAJ6n8K-FyY@j$#etnfJ9ejOD!SDC4|WWf|9l%`+td&--{P&tu)r@xC0&*lg~bx?;`? z^=T4X**rvMaT_SR*!S4yIsDpi%XBDCXLRZq?1 zWJx4}PRfamR}^vJo((XDhLSR2`MT6342cSN1Jb>>Z7>vHat$I;&TospVr z$4N+EL8j0T9WTLwti%)Lh=x>{cxffl_rB|Vw8=w8T6ogy!xHtzFrxFS9slbK#g7h$ z`5rzzO`LDt$KztmXjfTBNjSl!lFXc8i$cDG=7QYo??ae^12UxdQ^#7*Fh4FB&XYxI zt!ho*I9j+gR~&Xj+zOeVSyX|?Z%H6;sT=Zs4Zsl9Re#f7oUW4Bv9=2fK^4giu}7$~ zy!Cy1xuMUC15VvgktimZ`AB$l`-Zj-Wc9g-V3rm4GF2_^2T%GflOu5-HFETXtFx=n zYPlQ)ktS`n7V1o_GSuROW%bkzlmt|ml06}10WX4R6H0>Jyly??!HE-cnM`+!#v$zN zsCdB@7|?mSeVFoY=KIIIS+$kBI9adnpp#PgH#}p_z%UtRI5MkXKtOc;m}LHf1XHNQ zVI@q(IL$&!B?XTvdkEf99-`U)_j1D?h|9tn4@8MOUd$XPq$Qv@RNQp;II5Ne$#1@+7fdr>er_8@rt74Mhk!w87?+x?IWrwybEk$tiBP=MV+>aHEiTu6e&inO907xUi70J^l7c z2zt;!>iRmBA-G4uiaa|#Ji?BOB1)#Ld<1@Az5>!UDo$QUb69n_}@k; zQ+O5GlJeN{*6Hl>bK$P%PhN>Pw@KY8$XtD^OVK`Dz5f0Xepg&7NAAfW6`taUv2)id zb7<{6TGNg`Vq&>Rh*tTQRQ}lQ^7dew_t#EL;|{YQPI%hZ;w)aE60$0tJH>8L8%%iZ z$v71b$S=e5)zxsN@O^2=2-dqQCb7)dYKYh*414n3)NzP_pEOL~X7p5)|70(Np@(ebUUp!*#f$Ka}P&bzr zZ0^Dpcq(jj3zKRPR`wt{A1sPQH5e!qxpYJI;&r~Y#Cn1X+B~~a;jn>EgL=71*`~7a z3k=F2sj1BKUH-7-eKI@5TFc#E%_hQk*iWLMVdq6D)7%@s))h%8l!?VI+2AUz$2JJH*y`Ur#&$E@u^dE+kw zUbFNt)C)iiA+vPZk?;{U?k(aZf(V$Z-ksKc$$J{frXHz|gNE!$Wdl~+hboNeveo`a z{alhkJ!zosR%AyTc<Pp*I;|;(rQ1QozSj?m8#0_#>A-?@igHJLqeEg zyDt9q>(_A;I-h~cOb6RlnnQIcA?6X=H(Vvf5ERk|vx2;GoQH3s@UnlsIKef(g{$?5 z+av`_a@$j>fq2fu!^4z^m=fGxd0fVpY#myE_c7uL%!W7I^HUR-T~P39*%LHbPSD8R zdCO(b%-#L4UH;xux&vCP5` zF0tWgx!a8o0Kc9bc(B~+GDXs`R&V-V6IwQsj3gp988E-AlTzLwYe=%lA@X{`A<8|qfP zw;w+=E!@(1n`cCIj0-Vh=|<`LL-3q*7cQX8sZyv`F7FcaYm6*5i60fzy1KzN%UHEY zh8!G>4icyy$ZLtK8Md{I{Gi-yX8!UCC$#K)LqLAJ0_A1G7>Mt`X^zq#J8zkSTo<4f%bX?tRXTbnl2( z%9)Jhi3Jv$L7_`IdcNlDPD$BMKimoEGD`quMj}?jpz-5TpxD4Qi5Le11MTFnf(7wG zUlj72pvce^$8GPCf*nq4p6s?ZKh&0~S#+fCxbS3i{tF-rB|}DDUJMr^{W99{xPAj; z`^UBJJfj<+RL*hbDzpZaQnIUV*HSEadH~&>$iHDhIJw6Z#o)v1W9lVNnOd%+QF)9U zyzKB^0NdeOQ*?*O`yrDcUs20BZN}p;*&$8tHl7sV&i=5;V5b3=TX_)W9j4Nw^M#DX z97*2jcNb6dwwgIDuANO=TL&g6N#~yMrPw4;$TvqRQMe~iJ6buXLfl!)ON0>=Aanzt z!SK}`4vDZrvG(xZl#VxV&Ua;LcamAdxgSFMBSp4)KE^If8^U) z3ktE9W>neWOrM1j4fbW6ZfWb~-piDg3rd!_E&V#gozp1SPARIWP`Zqe_oK8E+jyjc zx_p^ry%3TPSTrydhw7$0Qc<7NUB1Agd*X&*#U^otFUgqF#wwx1v@yjrfjeT!Jt*un z*TN7&yFZ~Eqh1eE=*N%aul*z|+G)B`-&HT*oU+6hN5aQ7ZF?XsnyII{I@w8=uVLqf zhDFVG{uH2Ic<7x55vHo{$hG4OxW%Ag4C{q>D0dehDvlW`0BZEhvd<&Ws$h;Z)8Fs~ zxf+X9tQD1SFLI7bNGl-yidg0&4eS2=VaRr%ZlX7rsPszUCM^<3Xim6L^ggvu1?7D{ zCC3)Ex3CJo^qKevrFW|%C=UU|1>hS<+z!wI;PCnjEb7{`7eRLP;@rC5%tP2!AV@B6 zGC;dT#-m5a)mF7mWMyQ8gO-W*Bw_XnTd$BucS9l-oeOXh`bHM)ErhWc_VZCz=r_PbsZ&M7V24bOGz4=92qn6&&axWT-xRCR3~^4U za2>&M9r7ojRl`M%0;i@yVu{eyWe}Phtjm_)#4WcsH!Z$c=z%md>0D#+VgZDMmd1?2 zk`CNar29FIGN&1hiJpQ-J-M|l5Bx!uJdMnJi=K%|L1X!nZWC}0b;gqy!;nQzBKWz2 zlGJ2{r3735<5>XC=gf9@wogT>-#a`O)2hgtj0c)Mq>>c1*{?|yU`PdDX7c5>|4{#N zqP_E7r}W~HqtF4D2shwQtR8DN?ubu}uhD=7X}XZRNHuuf=We|DaRp0TFI#GIiF3*@ z)17f4?tF1(siVMUYi%LVZQ1ewM}2So|yaf>clmpMPwi z1uXaeG=;)b_Ke}7W@S+t9}~<$M_W(`J~c+_66TfLBJU4y7b}FXenlMeZWz& zb1_^J{Hs zN5iP?^R6PqiE4Q+cbap#jMU%C?Lu!c){n9SxbJWtzl443LS;<^`;Iv--w9Zw!b@M| z_f*Gf>V-6Bx?k3aoEnRPxJ&RfJ>20qqvmxlpeb6yv6wIRE;aIeTveJ<@&oZ3_{!Sa z3}ieGL8ZobIjxjyJ+-ytdp%eCJUHp>(5|YTjN}oJz?ruUxfb?%-dq!MMzdD(!iA{m zo`M_0$vO3ee#peA>}G9Z+wWSAU)s3F@KV1int@HEGkV>BqbtaTvL$kZ%VT6sAY}*Z z9`L~VSXM~@e5cE&vPuj=k$SI<$CAo9)7IH-vLk&`kg#LTM*10!@ii%fM*%u#B@Zu_ zp^<1F_Qc;>&i2*@MdtMG+B(pULGQh@bkFlmLW5Ky1P!_Gsi+(9C+-yCZOu5(cCkn4 z-qp#ITd;A%9yMQ+a9op(O{PW$mHxh*64Yd;(Z;Ar!WGbt6g;hEFbZ9nemmLinkpaP z!KRB!5xl%Cj~#3=t#O7UQO@+x^MyJJCa@HvK&Qj0@C5)s6r6g)_f?eL zk4?!TJw;R8&2zpg?z6!Kksez;y9~8ScxsoZWEIL_A9~BDT~CO^M%H>?qm{!%n>efr z3zYkaH<_B7S!PyNne;lP>iG2PC&76U`qcr_Mn)-vt7~bkrzVcvh6HF(+r%5QP1F@m`gGQ5t=I5VL+!aQ;c3NorF0Jh)-Aj|Y-k?#&^ZfQy zSn6F>;NXgv<7#kPotqUGERR@$irFG=Ip{TWoZA4R@x=hnS)HP98qHKB>up!id`S!(TRoORLMb)Y0zb@LJfLb6Awf!M{V^_mp?<5ZSS3ys|OMV!^3b9TyJM z9_}t~M_A~g&q8&hHa6K33H5cTz~~vcZ(7zB*6-nn&LdDtxT=(+Pei3?iTvE-@{Nt6 zZZ`$?nUtMZ&9NI?cXq~7@Q6EgOj)v)k>hx)3ke~;nT6%=@E+@(N(sgMSeHJt`q+xq zu$p}y1N|0`)X5}d*@S@Cu7S21fF382y<9X`*}a2vY#F+yWu_VknrdprD&L@;wlC_z zHxQ&@q0Uq1IXezZ)W9xpgc|gONTAc@d{|_)SYmhjsnw-Nd5=R&kmiFQ17I zcs6l(rFP-IN?A?FvlpD9IFkbac0(p@Tv>|<(Yo^w#ayeZZD0>d%TdhnSYJGOiRv6f z&y*2L&q%ZKF&l8c&Mnl_N)M?Kc~QF|MGyj>`1BXo(x`;D@7`ly&fZLr+MY^? zx_kSRACXR>QB|4BwX@jFzX^D_98dWG9V{aiqBqulR;!QW4QdM8am|QHtT$0WC0hek zaaV#)dUD`-X}UKCTN_K7ci)q9co7ngr$n|&mXV)3gOE#GG^!|{8T%U_?mXlMvSOcU(#~?Nbe(*g49%Sx! z33(}vi^%C6Wsb)6eN79t(5D2UR!fW=YE2kTVJuRW7lAXpmI0R_v4`DE+oF|5af-1) zYZ_-$%u^DYn^z4?^E)e*$l_a^)ith$+51vO zI#$ze=3<@am3rvC)SYGd&18cFx| zTa_j5tRi9!yp2kAiJN9S4GW}A@dD=A52Q&crMDDUyGU+dN6tGQw8WUULa#l3Et9I5 z;ST3A)Hak4JfU6c4#P`YT}*I|H5Nx%3Hr9v)E|$6Atm?E?;Yq9B zl-^OtK27(K+V{b+#GMc|<&KK}b(P&`1`^v-p(=}Lw2IhXqi+yKhKn@~e+M5-f zoayg`g&uWcWdKY$j{jqv-d>fD(e|_5(icOe?Y!`!OK)SNb&L6I6zLFmRB$ez_jZI? zE(FX!lZhp9=gwP}6n!MZ?zh1=sYo#74XvFY<-RNS-u0@^FEdg|?jd8E`FQ4N%Ybxm z${W?bP%LL-=eeym^-s5%jfS#wa(fLi0Rg&%3Xe9Pgc}gZetp zc=Ao_u%S9zZyEb~Qc7EwV@E}4v>34cPA{EAoI{Q?z+OT@`XB(DgI?}I;?66Ds0}Wc z?Bt#0x|oixTuo^x|>%O^>ROgObk&O=cC<4+-H?2^Ahd1KC3Sx%M3Njh%G36= zmFD2Hr%&EY?_j%;5Bg_iG2c2JiCa&dp`?*@QX07+l`grS^_Y?ForuhxEiBWgJYz_n z=F}=5Ot}aW?h~TXS5x_VkQd2C-;L#3h8mpis8Cud7i|L94-;I@=2~ITC|kHZ9fUff zGAXanXl4_c;!M8GpJ*AB-a$F(!hO9VwIkUn2&99uhuEx2I^>l`H0guxc$f0uN{R4s z1*;xF|0?S$wc_qG6Qk2K%h~Q30LGqNeu;{Pr*XFBVw6^iI?lxsJ*A$ipe0l1DlwGM z4T<&I+`Bv{RN}PG^B)bQjg`Opv8?+r0(jLnQDp2i`zK3HvP7CDwb_dc4c1qis>a2hd;bGRGA!4wk;Kmf9tF# z%cxsk`kHJjUpvgl@QG`KGb0s%qpsapdt02uofIW2m9W&E5M8i-W(`3LCfS+V>$iP0 zQ?f$tJRm>hY@yYj7FvAB7;j8soWi`Aw1ee$IfoD6@ItcEOz3d~aoNfcWrZ6HgS9yimB?&SUh1n_By%)t zzxLRsW-vG%lfU!|!wl+PO6ikw_oPn*KIe)i>|!(+#y4;Brl|uxANA5vyQm(4&$i} zteZFO)p#^_^Ik)w-$C@;pHn8*O$Z5L2P>}T6Nfk zJ!9LJu1A%FgCoyoNaRwU;WgIi7J*Gm&(XaVsAyJC%Cl!wpN@U+ zQE1(Fj?JVw@~QpUxkGN1K8S7Ex`G9p(_DIL?hEf<#p}d(*6A$s_d`Z-B;0RHLXdlDpRtFKc#>weF3jcYV4$UTF~>Z>4KgTC z-8qr8BR3huq6wWGnD$8bo_Y#An|B8{elwJe*Kl#9q49S4&c>8cO%RT`B+s-D8Bp&{ znm~>oX$y*i3PgM^IZ;Qoo?DmP-TFu+;JxFq?4aDSNXTU!2U74xxeG*RkdXZ2P^mqg zc?h11P_U^^;y4K4;}8MLS+6+85VX;Cl)GCQ1P9{I^^MaZ=9&^2M$0}d{QA$4!RCYD zU^3o|cetR|r2!?*bJ6K4sf}QpMMoA#uw{T7l5Nv)DDUhs!Y<6AW2ojhE_-D)qG{9!oCTS+JcLdN==m9{81bscZIUz&6`(kWggnDM+Ryy z)~nr38*`r=sBN<;KNZ@3PN}K7FrjgHpir7BU_+0~1>~GalIlvm@hd%Iy#)coc`GyT z2ww18)E}Dj5?tvvhz#s%#?{{{CPnLW9`FpWO^y~8OFgma*rhEg=_M@0YBd7*1f^s` zkRVr;(V-N{ z8iJTmi}wciG7TH68C`QYXHjj+o$JnKs7FewKJbgGUKb#&$Wc)t2Mcdj<=RVZ$+(Nz zIt(%~jB>Kun;$1A`<^+b8df-LIVO^yAgmLC>M9^Vg= z-X=Lbs%K_3P)Zm&C>W2TfdEpT0AEQ=829_=KG3i}B)GMj|D0rv|@* z1~~+Y51B>%J;zSHS}I$*mT5`eY&CtxEIKfxbi3o)QW=H$hc-p>r*GRpSetwN>gi`a z>lj_at3?d77AyY6ddkJ;7))!gp5JkZ4CJ_9uYtpZnwV?$z$p85D5LdhVT0upg7W25>` zWFSj^lA&xJN0J^U!|_H+_Q;pCNJz1gN!$aH2z{bBk%1`cEMlV`6o)?Yi7S))j|wM0 zV@~d<@rju$w0hS#m0iII6cQBfgDzKp`vS`3d)Ag`|Mk3#IG$9$6$G^m!1D&h_|7s9v}LgM8fem-wUlP_75S z=!Sbn=S6H@?T?L>6?VP-fP@~}yjr#9AAe`jMj=w7!2RO2(5H@57biN>Bc^+wvMKeK zV+aRw%}2=dNOM~E($4f0(BbvnsZb$*6ZHP(b(rz@^Y>&l;@LsNV02cVOxIo6x`@;&XJ6@+bjkT9y}0xC>tAoyHJUI<@)tdi|KHz zQT-S`b&@&c>#pTRuWc`}G*!FLg>W7o+cb40I2W==E0(q}V5aIm9M#>;ppmZ#RZbmZ zbbNTsrid7-HV1BxWf9yE-U+gjOmi0jlrW>F=o0}1 zO2L<-B*k1j398roxp*ki&SKB0gKL{a7vq7*3fr{?(+Sxf2cAfdj3Uzo#cJA`Sl{?jQ*mT*Uh_4=L^u_8pDa%n+DV&3(r2*`DaNMQBFWuhS27xRzLT6V zH)H^=5Oy)O=sx=T2lsbQ8OhO-s;oBAqT3`W%e6*rx2(5VZQh(b=h~W9C^IWzZa*5O z*7$TR!D2;w^2H5tuVuPhWA_ML$Kp4fBBQQp+4|RGaRrgOKfYBsA-iC`+{9EtkInz_ z=4-p>^?bOlSCw8PxKc@zKZ|wHIxaMLBwU&NNFu9DGIEYg8E6E#PzzR6h8F->CZGv< zEkDw203{!$Inve&BO@cb7bn!f)q79YDerRD1FR;TF=S*--El-bdxh5F0STfZwz$|S zY~oIGmhe#7XQvLtwc} zYlu&h`H+wd?dVW%C(I4F3}bN*`|SAVx{Sp;XMhV9bd3OAF4_cpd|;?Lu*q^#mxTeF zj;GJ}yy9-pDJ-700@0(-@E?LD-oxk`sB;&E+(ifm$Sx+$QZDntw;CHa9v49gY-a=J z-kn+O%)ZXI8i(ri$a$Js`EdMM0n%rVQ#4&V?wPOct{7Ttkqe(AuQ~LItTvIibZnoi%gO&8n zkmz(;a;UQBWuRya-;HGR#2xW%Y_|=`WgMh4XsjmSq{+MKGqFyd+L{9!ji51{exvBw zGYu~rp+JLY>I(NO~LZ(K6@~+oZX3+z{je(YR`3dL*GSa$>E`1ZFN4}2Zp_@;I$60Le z-rJ1=FxON{mS_NQJp$V_w4`p_D&Y*&Lokxu5w0aq(D&Eb?5d?;85@nVoV`k3yWY>s z7IBs~OwYkg6=m4O)4Wus%=GpB@qyF;q`IS=eBP8EbMDKlnOH}PU(O9wR1BtOox%q{J9XJ3B%9iD(a5$zsBF{3l&NwrITt2@2! z7UA_j-0*~n1{58LHd20V_qU8>#~ILN-q`A~ z$#g433FSJByKh@-ke^>$hH9i>y^^-1`bJ&R3iPJR8`ib-0o#3D^X7TbN<<0`vbIt{ zF3JItRjj15DMCV%_l?hCo2F^i%KgYwRo|>(->h894~LExtpzvAwY+}tLo>(nc}ZV! zj>|COE$TZ72W{2}DylT43Ox;nurT3uA3p_jCO)lFho~j!O%k#GwWoZ!iIY#yEeduQpbM;Iz!cH$bEU`6MW%A)-mF_&MwKhv4ES7{SNA>~&-Cre1Ug8iAM@@(v z>RK*|6epkyl0bu-gXZ)^mu1u$Et6r}pivJ&q1S!SD1@~b8f_EW6Id|t_RB|bO`hId zL3NZ0eZO^OH|8Pk3bvH+c-q~y_;u*N$~nHwu5$$ypi|%xpN-%u-no1T(E>?+-hwlK z&=8m!DDHxpsgNdslFYUDdy;X8Pr^yIbx{MLB;5tcTzayDq(Q1wyMCzcUN!Py4C(c| z*=psop}uAdM9A0-Ll*Bw zslb^uC%-?~37RlKPAFeK-V6CeAk%wHrKq-2(L%y8wqPE3**ZLgge$d+V{-ifTvKkQ zQzp%_p)y3l7QJRcZS1)+&qA~UNvkKvs@{J>Z?P?Qe2Y!l!r~k7hLW{AOqroE`MKW} zeWo{VaR&3GFYIdeDH)Q#q zny`BAM!~6oFLpUaxhuw8lM7Fde?d&I^oTo1F#6M|qlbq=K1-4b$uWPvT-bP2TF)>isYc zq!!gXa)(ZNsMb+3?dQ2Lic^JAo^d;N4-2Ne>G;FEJx2yF%q02J>uFRIBRD8wq3e^$ zix?9njX|`gs>cn=?7}IY>w4R|np>-K95oE{)L&~sJqpassK!Wa+!!~?e6qJO8%EM= znk(yK8U?#{y)^H75_bR-%l~F#&L7TVShz%*g(*qsck2r(q`^1*b)4*}2Mu*$r>fG6 z-K$jaCQ!pa=i;qfA&Ae5^tW|6JXSPYqgqhl`<6~Jiu6e{>x=x_HR7L7u{>d|ir$VV(vBCyC0SQkQ>-k1~@d`Z6*;B=2B!a|y z!jz>b3;bSk36CQk+Fv$<`mFg}R%>?10vDca3(DlD{<_qID1Y9;wBA}^`nDGvSK70b zA>;fUoAGcpOla;`GdW$fK6~qs>O<3kd=EgWP){=mIxI4PC#l>hd}I3b{*}5?p{rM~ z8gDQ5bjdcGXSB%*Gof#zUJRyCXC0p(k;%}U91d?Q1a&HYnC9zC`?l6Zlt zRF4^qO($-QV1Wg7CE98xxBfI6tv_aS_On0r%gn+070ILA!WhJ6zOV1x8zblFDPjqk z@Hx@H?zrIGhXR6tM0lSu*^RE)D*n?Og>3}(as@+1b1+u$&}KT&+`=NmVj#bmb+aR9 z{Z$PyzQ0hl25T>oY?zEX=n<~fQ^C{e589q(qB>BLGm#on-%*O&wOKRbG7_(GogPN{ ziV+(^UCd-pt&TF%#ib@u#ReV5d z6*o#nd|3;sRXc=tbV&K_(zhM9wZ-$AYY#Wt%rl37in$EZzrI2-K(XQ0zrVfRX-)~+ zcDmXBt8Ky}5%{jbKFg$@P0ANLc2+Vdo=;zIZLATJZ<%qkjw}3av5K2c?BO=JHwk)&Yh13;GWr7tp zq_e9FV;(JPS`RKgP2sWx;~nUNJuH4k_)^wGFp~aU zug^xI995ozF#2-pzVNH|y|H{fDL7)hj-8*Mp6>INLn`NtNlXldjeaTu3!=9PAi5Nh zlXDdkjv?(aT=Y3~lB~WP*cTq81b#1P!vFB~q8im}`UfvA<4?F*d*f5wfoFxDnRgYO zNwEOK9u5c}gG0i|C;wj{p{pvzVh>pG1f`@~cpN{84?O+7M-(P%+_#Y{Pv=TV;VrB- z-%WQ;55vqiLQe@YR44=Wr&N`agfx*d+#&9W|3vk9y)27LO z?*mB@F;QS7tk&3a|0oaKSYyIdE8-uIr(5FCZ*8RJOHWn#k*s@P&2e>1_r-bASKpm- z*V(t}Lxku!s@Ej$&!(^{x_so25Xkq}$Lb(cK1t``gg}~L=UUk_RJf9*3f0Q2;Z>%2 zS2g3KSvi;8Y3a0K(f3lBKEAd2x>Y%p7Kid$_evfH4Zm*g+}PMizjGYAuS&K4G8B?x z(cUFkNDAjl^Dw5nG%N89kR{h}7E+Xjm`i!IZ+1+=szTUyG{@{@2w*{vM+uYdIuiJ= zLo#dI(cx9KcjE}(SUTjgN+-U3E5&T3_mJ(jRX{>;FNBUw>f|K$7nv2+kN4c;1*kbX zb{w~v;Fnx%K7{CFL1ExQ-Sl`pDHE?RjQMC=?8|)siFbc9Nf_9Y4hXaBkcs@*J7jf} z1@C=&`$wSY4V|O8+b+9|EsqWHy$r1yQu-aH-KbwgG_*b2zz)esPC$(xyne`j0k+Eq zHP}(r@UywkNQ3|-So}fZH^wM@*DXrBJi=F7_2E>PZ4ha`hkb_7;VYv`284^EBd&xv z&(`mW=>3Y#P@@_{f>6Pd-V84~0O-AJPZk|-O`AY%2s^JCm_b`$&IR*t;O#p5l28tO zY!fYc{5w@LNjTv~&EA<(p+Y5&gC*DbH^DgO*PZpVnYFCQcFPO^ztx={QqG2QHBw9eXNNR=cQ#_%gs8Fm}%#bTxopZ+3~ zwCVoK183eA;C&I0Lb}=Q%@T5p(}c}u)BX2bmV>aGJ0%3LU#1|EkKq)DAekNp8U)Sc z^QDO;c@SuSy-ppyKOi)1$p}2|>nhS17aU~Y<^yQlqrRNs33?*{>|JmW0IXpKB$%%o z)S)d56eM3SKf)sEcuC9=b^6@pPmsWvL6QK?+!91P8HfENFCK$5M8@7QxjH=@A!H!0 zarf@+D#ss|rgqB?K!d@XU$ZcNCt@3z#g52DdN}RUp>~-1Ug&SY3McuPTJFKGeG~=R znQ1cCT}aHq5S>?ya=kT6C7mMLq>kmT-`*&YZ&!79tC|g$W-pJtR|2p|+KM#vzv>p! zUpVyyL1Z~Wq<=@R=F9~$21RCua*orDaj!Yi)i$o^z$h9dDQ>Lzn`L#No;$h09Y(%g zfRi({Ipao6X~D;+LN&xnno%F=*}&7B!qiLLi<`L~%}Wj*JOTp$yms-eLQX#Vaz z%^MF)jWnwMRSVQi4B;20E7$%})AO7SZeCj4*->ZWZya_2jC^h{$z<gB9e3=w#}*3DA9q&u6*=MDtvdyOzmCTGG%G>|GxVaC zPrn0iwcJ|*)nlg88%4u+5smkpgzTzH;0B=JG^hh>cy04vEj8P}7x?+8?yQd(BugZ` zNbX;bkn!V;jU<30l`g#ALkCF6G4|KQFNL7?(zklQAZSz3UWave^lfkrc_GFNph1vf z9aTxDkPwE^V|pmu1Q|Sd!|>G)j8>I^RNM@3WB!Lr7FL$`80Q~35 z*xYc+ovxft6fi6iN0wLi!7NQGQHWMPzHDe>41iWlRT(d7hefHl8gWkLXbydL7&Wm( zOEBfpOrMOMkW^=1!`#}pK)3MGk_ma{E<*~j*|c+X-2Oo3*O)-eTV9xiQn0{NpG)aE z`_Je`sycb|UsZj3+cA(&Qymk9`~rL$Xh3|iZqA7#@920D4&}X@#9PY1d3k0k-c{A5 zW)Gev6SXn)V?_8p_!kxz6 zI`)67pfMPstk~Kjd*^fVFq$hsz!c1y%$BD@`PD<;6FOWiVxB@jkRt|nj#ad>-*y{! zN*K>d^nyW&;bNYkW3H{J5Q_tzicfpM?*+W!VAC$eiA**#ze}C%=)RQ_gYz|uoo+!e z^2x)JX`8XB)9!Oz+wG;i9N5lg%+s$<&Nw{;WUBOf6AqsnpG~HK*2=XY%z#+5phdb@ z9wHg}PM$Yxx0Z))bf>8e%bD{Qp`6~BsS~TTJWzu(xK(!sy@n+Ii+E*3 zxJU3;FSDGSRTgcj&+M4r8(Hg8m(ulDfQ|tgZz=q`1!i)JJ1WOasa1uq5T=-jM+-6^ z|Nbia>s!_LlUWqspK#@wsWTUd7B`>p%rzj$%bVSn%y1}0gefYzQm;7DdyC?%)70?h z1^X&K-b}0X6Sy9K8#!GZdN}HWy3*RqZquB|cD!(4I||BW+?{UCW}_`N=V)0=Efmr! z@x^~7{w6p($e(Rk0f)xs`y*{;z1!E|=QP;pWPRe_8LwHfXCx6ZhPM?4x4qVC_}IDl zo7^7(*u}@Rb|zr_j}xwym<>f#vh8Gk3qTJb_+f(#5}@{Y zwDidtc_A^3b$l;9?i%G~8BgV7s%1Qn-KL)Sdsh)YD@R0AIQNqgxS0R9m=2Fy?uoa* zh0v1mdkLMcG?N=Vv@{o8k~op?uQ6VFk1sT4;c9!9cWKIoWyZhr`NF|sc~1$>W{MFW zetl>FqPm9X=N^21#n^gJPNK$K7*k$bNf(M7VU18$Su(I#I`Joslg1e$a!}+LITJJ-W1zs=QebQP zuasXGejYUhD>us}v z{KU_5oYnxFgSW#5dEWPhzO-aYH8?~Nn4m?H2bD%GxUoVm#n-V4YJWW;<+|@P9EK}s za0Xs&$PV%qt#>qZ8K;|r!XYYot}8#Yck_!icv0rIbZm!o#3bh!U}dxxG2}C1}7H+{5b*i|VnwR&g+Q zk+KyfZ%$L2emi)Z3E8YOjyHTr|3HE5J9FH!pstV`k6!Fuw0EYkAss3 zC$#Q0@T<%q>s)&*y@tMf*#t=sIJorJ_+3?gk2Dmq=)XoP;^w@(&7zLJ!HSqhWMflw zUamFR&lAE`JTaGuXNUu-k&UG%12O%Kg**)?Om({r$lX$6n)X2#e`l1DIOqn%VdhgT6Bz)o^5q$$Byg~(}ztBc@ z7DrE-m`%&LJbhwlXLVfP<@Ec{g-o>*b`Nk7SyT>0C?lKr&$H=(!YS3Z#?a?-0!kpc z#yFby2dz*tbp^HiRnC&a#HM&71QEKi&D>B`F<3MVY&Ked9(iS1cPM5$OqN+cKQ!#N^Ni z;C%m_x02=QB|&)wj3#+6=`!?%=^-2xeIt9Bg5u{<-b)>AkoLk9ZEI`$#&nL2YVY}r zSEOM;QZW_4&0#aG+@GEAf9b|q34hNJ`VgVSt@r;1Js1%ZdcTc~q=Z>+6MW~!7e00J z2{0k7?A?3O3q4{9hix&$V2Zic;4mf*I((eL0O4x>3};rlE7*&K=AZawlD|PiPhaqM zx$QI^Yr-L&(2v8A!aG*DJbK&c!>o843M#JtG7cY3;|7f95k0EXIc!}otc3$VH7 zor?hu77j%cl`)S4tJzDVk7-1Ed}2irqA(Y;L+TnD zzA+Znnsu9H)ZLr!)5mA;Wj2lG25h&s=Xum;fu zurIX!m4K{SR9NI5&FGMNTGi)V^#t}n+amMM3l1dALf~kV&YskVOK|bxwLzBzy`&&@Vy-mt(s{H*DL+#hF>yn6^+`53i zOfh%;5%9Zz>>qwdC;W=g^D8lo#=FhGGirbFh~0tqyz~2g$c0AvQa#C1R`2v=7VZ2L zgHRAN;Ds0x4QiKAHf8+6?!WL?+Gvos`H4=Es09fTWNyJnogb|^@7~?5gbe)*HfnE( z(W3tavVtX@7jr58_3@16RYdRt{@F;13Z*JF((h=HK|EH}LpAZI7XF$i@=!wZb0ET8 zDOuPEE%^Sj6vG4qWIE6f8c*Q~(d23rL_r%CX8Y$~Gl1@jM&_cH4d{_;J^0K4xEH^Z z{Rbe&VH=+8>QO!rBG&R?C6z_80;!(ivj1+YhA>V|Ei7 zV(4SaKX+1!9(}xgei1+&6>=Z%A>SZAuUMGAP5tSoP6?BgBT|FV@t5GSzfkP7suwA| z!u#I5@AlCFz#v|Man1FNj*R>a(QAaQ)z!Kx{;^39n0+h3`t-l)QZeuAdIS;ojAEIq zaiHwqCr#@v0;7?-C-46q7}-~G1EHOue1fZOY@s7#Uu3F<; zt*2*wXCcPk^P8{sKomm7o?zGceV&VHACdr>*kJlc9ut6r&Me~r@H85lU(b5Pok#T_ z4H|`H(@}Zs8tzRz!<%_Q{z&;)^iN&(^VFR&1at_!z}d-$r#H^MWZ0xdRL^64FL7bp zDJh3u-f_yi|MMXyLXRuB%((|Rm2_}KXy=}o-u+i~^(|CaX#rxImqPXClw(T>Y6=@> z-zrJ42K+-LnoF3aDv3XI%}q{ag9ya`PtNmd_+3y{4c;r!tadKaaa(T+qBD%HhI(mO zM2G~8x$f=Sgg$jl_V7atdSfg^=_^Md*2Dj=^*|^5^qU{0)LCn?m?9>!Gm~Ms_S)kyUi3+erRIB#9BDvB4mEeE7Y*T~zQ5gLf%7xRlDpD&JsK%=%@d zPm8RNgsK+M0_|RJZK8!fJLUAWb|%h{yhQl9TL#?F82Qhg)S@CqvmxYaVPeCGe!4Pw zrP?GlU@%c+HbPC^3c;+v5ZB=S9a577+Jfqh01B6xFm!EIl#6POXJ)LvVKx`miMk4h zD1x)%RkEjtv-|0>g-!nM&16BuU1A6W3-6_R1pE z8B5v88CkbXfgguw<$|~nd9Cxn7(CiEPfc?(6s2i5JpA`9J!1)Mq1p7eE)Gc{;0rZ zB7NxB#+V+E%F4=8mKJP)sjcZ?dV>NgK%0=?{RvrfR<$?sTq+kLO`z>==Cv=?D@Y%I zZKbJ&)>3+eEv{U}=%udzsNeyOE8wc3AtzdaS8CcN0nLx}AY{1wCa%S~FozwYgjV=R zqJU`cd2j?N;#I*&a>VXEgjZL}Y%UYx&>(JLiL8KCpc%y}M=})4F$X3!BZVPj?24h- zrlXy44vyNx;^Ayu!BG7{saWb0({~0jeRhbLhms}Lm8I2y{yN=xl0RU01-yX&@h7n;)bg-y$Y~cCx*{w@Lx#`-6|T?efjBc_7>IM2?qLIvA312)l#l0S zOQ-np8I&&<0NwBR;*jkP(OdVQ1mp4->pG~a-KWbfzkU;jx9O()M`@kt6Noc%s*P4h zE7SlAO?AIx{b8Bw&LjSX^zaBLd!dmBS3{Foirb?RL0hIrYBq@dF1LgI;J^B3KioNz zE2jqZJ!>L<;~PKmw?qT9ITG;PGO#PdYQh;43a)cV2!d{bZ91=LsP4B?B~&2Fx>#&?^?#^aOO5h0?t79CLaI%_Y!iHO$sy;e)>ep4^@R&<-w;=T7QrCWUH#8e=w^gG!de58!svNPhuc%^%J&} zhS$Q&-urm>q$BqgI9+Av*>5411xFyqF>n2bnIZHdnER3;zAJr!$llH1gwrQ%d-cS$ z)Bn{HO>*$3v_lAn`;Ag^{#d@^D?S_NgXZ{N1l9!rH}X_9l=cQ|yWfeXp^?R$SQiYS zFM`8)a{8Y|WML8UiV(mM{DB_x+`C<_xwFtCgP_^Kl{w32L|qY@vgH>DaT*eLAJ4VUw?(nv8>ioShX6m@gUak2)NEbzcY(-NJaW zUaBy#FWYDS9&o@*kQVHj3r(f}yVmO5^X6=18!uDBi?L5E0xcqT5{S1ON*3G(0j{Fb zM7_%OGlYe4NQm|ES(^I)uEE;>lFSEt|7VAEi&@uB{47;z#QPBY4BBazQ0yK|Qs06R z2KOE!LS(=O{tiI^R)^>bJf0lj@t?5eI`oL3xN&t0iW~PGZqHrD+^b-0`jfCwM1*kv z)ZX5_uLa)V+vfN_Xz{Q&zD-z|i0q2dXa1^m5E&y<6^DovZf%hK$b*mcav(@wP*5`v zmIlubU8@aZ60Mzy2|n?~;t^kL@2_Nsp2W(pR^iHo2miX};9vdGP_>5vL~@^w(v0MwjSYFXLX zBB5B*3ho-xKEC*93p~RDpF^#OOtUtF!zdY&i zU>`dxYdBy)H<^|p*i(WSf)uvmlA zATCyfwwlzVDm^=WI!uP#XV5o{oK6mla81%{zY(wOnOQ(0b)dP>+XwNdY7JD8fCjj7 z`4nPc|Kl?e4#Y{G_?_=XG++uBI*NH3m%{ZlVyYl3NB~(uOF|RZlQ<9j4m5O<-jf1p zS0OK2j3%OBAYqNDl(JOACS(c3wD4mZsMCK1H;%Vr}|bh_aCdD!=7NTCT-6dQf{vy+o25z2chSu);p z&J(~v!2=%tAp|^OO~C-b9UCw84<(-bT+SXF|8jocne|vvWSP36rR9C?krh9b>h*liMD1SFes^stRXvsY%-tl+06+K( zIzryxsZrRT;l&BXZF^+e-b(Lgx%;qS{|KTJx;7q~{U`CoFjycbB5Jy!YK=jz`9Hs-xd{@Jc`L^9?8y&Y;Mwzl0H6|0vF_wbM(uZbbKzyIHN zJ^fKJsSIMmx;pnWRdjVW9$J8MCsZ_mNbWieIeH)uHx+Fov&hQmDIM!@p>R-wbR)Eu zQ~mDNyt;fp<|L*9C6NvZsK+@U7b>~9b9B@0OCdW0y&kxLbCKy2^c)#44;FO;_($mkSe)=CnxX>uaTzPp z8X6ic*J};tD|2#gf2#s0O4UN|H5FmMNTi5|PRJ<>1ZMbVJo7ei5xK{yL-g29pXbGr zlXhbxo@idMOv92@zL(?i&-b;F$h|P$ap<^fIWN~B;gnSs^avyHQ1oyT@2YtSmGBIt ziX6fNZQ=O=K6NlnZ3c$i-)$+B38o-*&4mn)2Twsq9FN=!JZdUe_j`ZUq#tA|9w%)5 zV9_S+E2#Myr(@f6$+vfr!*lQDaHN=5T3lL)NTo_bBd(ylp3CedSFP!+&(z1eGDwn> z+{3={0^cV{^}YFZ49LC+XduXYZN>R8*=3HD9}xU*@0$u#g1%Afa`ckwxt`D+4YN6f zx}f?=XFQ)0lGMC#a?KJrx{=Xqa4CWSJo>kLjwI?R0{BY+F=9@f=>5lf1^5F!xMZtrwBK^)7^X}m@i{gqp(cGA-hT2! z=Jm9~y<2A6+Nkr$tg@21$x+4^o0Ow>w#Z@3v*+=_cwf<)4({{n6?Fuo9--vEsCMB; zTOP+)a+7PRUISd6#8D=PH}=k_MjyBNdCiS z;_6IK!+aO>Ie{Z`ur8oA*D2%kTbmjvBv6?CG6V6Sq}1*6bl(E z#Wb?!hwSsFoOY8j%WI8z(Q1nP8TBcScUO>dfPDwQ%oc&;sFQCG4<$?*Pb&AeO<=9V z?s&{p3XxC6a&enoKSA>$GOBdZ4=%H!z6D`JBZm09VuOSoD9Z8}NrM}Uia<+9GzdGZ zp^@s$&U%e>;tFbx_gX-=i{?G`SiBSG$;%2eE7L06Pk0;0Sbf@*?z|D^a-OM-z+iS$ zm>6Y3RTDC6kOFXPttqbXoW4g_9mR{}UXIs0|N3I>k>)7;YdysC3bXLO9-pHs+$E?9 zh(}rRr<_uThl^gN2-NC@el)x843xmyV`Y@n$Vk(KIpyoqpRuo!F< z<1BD~R-6eNxsmC#;5xRANM?vtS}>}3FN4EfwvS-@xg>)R3@N>{CPmVK+!D6U&W;h2 z+KyasV@^z2H9Tl`443<4IetTQ&mlpbJw*(M&3+Tol&pPf{=q%BMx}YWoRO_SnLmCl z??vDdO@Z|RwosLzgDPbBy7}`Sn-}7I5Iw%==XXjs{65)u4qYa6q|}U_@7v?>QOLF~ zI$77itpN27SR@{6V?h%?E3PhcPGfJq;m~l)$cg+M<$igU;*9b0`TAgi z#jIUd9t*&9FnHw>f$1umf(*j0%>``xr<+EZD0?W#a|Wwr)G5mZCkK~pofQtk(L zoIZ@Hd-08i!rGVO`l*%sORiJY?pt939dAc=pHUyuEFHZ;vs;!yut z&K!*AX(iN%@5>bwx;GQYO3OtEC2@fVPfxSLfF->0v1iZKb~6mX*diam*`y>XJ|p__ zj(y z=hiTAC5fC86L(&IoAO@YIWBV&G0?j-@J;j@S^Qnz`mOqRn4t=osx-9m58TbxbZ^n! z=Tg2$F0YKiUPQ`w(3ZgyM;!YJDLv^=zD6qQ_yw7&z$j$-d$T5#qwO6Xm~wW zy*LUPl+|$x_72w0*yoZfE{ySQU=J34)Xe$FRxfg#ZHt@T%~o=6Jz#m&a60mI{wZ|) zaw)G8x6Lrm!?3RBKAwm2kPD@u6!jQAFbKfFpg}`EycfL^-)TPC-=`YMhVj4Ag5h54 zNm_S>aEa%H9THMN5)8M%;IwPw%(;K0TNnU*=Mv+)Nlvpcw`&6dtkV;r=Wu5qnkY-( z)zRahFUe+BN*a~b&U-^_m*Y|v74BmDIVvkK{JgE_4Y_wkShhJXjESOpyXUBnn{vO1 zpKJ5K`02rtM!tY^0)S~Yf3>@g@E__JU)>pRES|gLyk1XZnruUf?S#_@T*MI{%WM;v=T(D)#qpDB4676qbB;^>W#k zF(&SG5H5(aH+N%C;11Ndcb30Th?mNUJu?no%J1>R$vbw6*XOKRbJUKYI!7otq7zec z&%1+1u_LdeCD|WSqPjCqBX;xBFPaUokL8<$dOzkFE+p6l9Z!eQq!!A%WL#iXTW||C z=h7$4&;1Hvy&@5<3&CzmJK=fDC=mtcT(LBhPeH-|}ct zc+2FcYO=QA=z9)xm&|N?2?eW`KW;ccR_kY0VH(rVvzs2LMOyev)_z%zWwKFxl5pL2 z7QL}rGuOa6@0NEre@c|<<-wPs_eYA`o^X$*6O++J2OCqqf>FEA?^M71*!-~A-Vj@M z(^=3&U|#r>N}{>v+-eXxpCi@!taZ3##UA~c&Drz^ZruF`egmK0AZ=B-++A=h(Rj)aC${i3okXT)sz4?yv8p*bH)B$xesox0oH}-^pxf z&0jo)@_n|8#!~RG7xNEmLhV&?X>wVDRW-r9_8D_Z;i(qdAmlnd`Z1l7)MMQ|_RU(PvHZS?T7qQam+ZNZ_Y-bi+jO%aIJ?@JO4*k^cNB2{ z^!I|}{Q|+332J(3i{_SiThDSzcDfv~W$#YoFPfu!d7A9^x8(!rM`8zl39m2fyi9wq z6GK6A3OkFbPV?tp>|BH1qWs;%_DMF8gmb4(V~U|6A4>)_L94XhR|_RXnQ5izHG0{oN`naUGv7n_bss3o*LxrDEu z87G$<*{vu0>fVyx6~si{nI+(eXdsrr{Di z%GD=;n-ZnmEQ_Yn%ndVVS!#hmRgEShC5=stHx6SH1;&)V++^U~#Pg=?8F^Io);@&2 zAhp=2L&nVZJ0J0{Z?#7wwGY1BOT2K#*UtW(t>$rAEExhXYyi+a}k)ZtAo&oVcRI{J`X)>`VHsBi6^ zVzs^?jt;sF`NU&idEYZ+P`$^bQtKf#-$C&9o;bHfl&W!I&&JxEL(Y-mK!Q&|;yaz^ z;Sv6K`r9wb)jn(UZ~L&{SD>eIVRiO_iO|R|K|R{pf}6k6HO29(e-2xWb?H*zCcQ0u zh62c&^`(K@fG-0Zdggk<#2uOC$t50}t9$fl(UyulzB=|-xP2Y=&%JM=Cb>?j z`PFnQ0ZP?AUaa(i0pcezqfVgwDD#Hk*qGwugCA1F#4HY|J}5N`vdKK#5a_du!`5i? z{59|Sgw%*%jfa_Jy1o3c1PsCC)eYS*x!DwzUyj%Htn))Oe0|T8cDq2gMl1i&08C7% z7Twfaw44{8uZ+HtP-66jcA|P?8857}+V`NzHD-u3_`05++1#C@HZADFuA2bHh;CrEYn$B=c9OkLr z-JPCIy-5+!_*!Zxo`r>WgOW8XmE-XIe5ASUhF1WuGBa2^f1?B&VigS7(StFjW&($iaTu_meY|-cD z?kz=80kX4;^< zK~la+%Q3T=1Gy}@!;AkYW15sv#dFvS3Q|s^UF#ejlia5GVV~$TkcUO3h1ulH+DM(y z9X|$*nP3Lf`}r#ztbESRhU7yZ)7`bh_fAXFTkSWbNM-P(AKhpPGU-fW6wwOxO#K(l zB1X(!*enut)p=94m1vOqH02ijZ=y{YZSR^^K@Ab>19R{5@n1hP^2UzmkMaBZ z2``XJY#sliP7aYNeWWYnkZ^SHoY*hFhF5*tkR3**3F+E@;n{*b*o%q_15Zyl$xG}$ zCOr9_zgr$7b!}VAmdJK*hLv_)qWPd1zd6<)5_)3`ZGDv-8=CH1J4<`}D$d%_&t>_| zqQ|Yb?Qe9wvyxhM!Rs177Ve_{H94!$*GJ%QzX;YQk~;T}y1JBQ=`=-9R^X+pScp6J z64NJW&a*)=Q-iH^aG~j?|6C{YR2J75)pn-m6P)sgnQ`QBeg&&GIny_!F3{k|)PX7y zOk5#+Nq8w#LN^Zw)KZk$RC`wdGzcIdkTIjmKC^iO7O03s$BQ-*| zxWb=>>VL5Srwx?tZ~xe0Ex>o5p{Gon4H>CMr-#W0;C)QPXy)K08$EW&BUF zVm{$)_X^RZ$(~FRD97E|^8A%aU&0sN=@I3(qizEJ5^d#NT<|!%&aF}d@9UpwaxpF=!7<$qrxIL<`Pfi@lJup?_I?*#;bQrgP zJbo?m^44_)8S{EYV!~U6wT;=h%{Us~V%IPzeg=iE-os9;bOFdTw?Q2mAe*D&Z13D5 z5MGy(`L?|+Wk0XidbQG?xocizz}BZF`PijpU^O>iwFi&x35<|gh}6(~9hu-j@mI>O zAyPJPlrnT8RiS@g0Y4T^aFl{BSUxR`K+9zbSDcco|WXb)zX z{S_0+51pzDa#JN7m!kVL?%cTvAjOP@o=jG&Gm+1L-@UG4SZ4BfT`_qsEqexi)^V67 zlgv>oSg|oXs*#|~OUxJp8!sfVW0)L|0wo6E-Zuc7%q4HkEg*ECWtBQU?9_OtqIG*~ zCcL^rTlaw2f(q1t)o6Lx?Ft1V#2j<_dEJt4=2zOdWNX&~9Rt~4%djrs>H3R{y-e)r z6D?8&7@*V*lV*~eh1!Oh&up(gzLc;i;j`w1uPpCX>&3^%*Qm@oXQ{O<{A4QyitcL2 ztQyB4jm*9C@_IENCb3dIj{F79^`> zh%WN-$22HWhzKBcf11cEiTiE~L$QqQm4xV9S}&VN7E+O>GVyV7Sw%%*ptExyzyw2e zU0nqz?C0YWOkH9vEDbM zf2PKEf$=H^x(g=01baw^Kaam3)-RVYJOf`LJubI6R#WA#8`PT#*HAp+piTG&vtk%j zDa&yXQIlt?qyE5OPb%2!Cx1gzwQGOweGjw;@WA~F+J!w`%5Ub_QGMA2JXq!z(Gzs7 z!b_j-^jW7j=~8GpLP}KG-Q9gH;CyXyetz)q@USV=XkP3PeS`4()4fOXnD2~uKOFcQ8DL}AnN(5F{0n?7u>|q^gowkvrs z;}tj8H)u9!HgpkPvCJ|xi{lRF?(5Of(d8gbnKzH}0^;B5sRWjibV1%bD=)8IyJ#-? zT_mu+D{JpzNoi^CyOp$BWKT5Dy_VfaR0W>j7Qm@fY*fsR!?nq|6LzzPh9(w``dfXo zR|(8FpI~$vUs#+XF%yk}(H&hIvu!mcxmK-M9YY`XDz7{R3S~&&}%^rGxg*o@V3?K zIl?^Gi9N-knYO=&M(e~Mm&94S?QrwvX$o`6nNxz_Xt4*)w$I{ZY6%;a!YfRWpkI<6 z4lxCF3HQ^m41aL1TAz7T^@I1xuf6%2nhC!YPCcFPG}urQlPFSSTxr8PC+LoIX1O%U z1uatx&!iN5nF%!XK52oTA`!=B605Q5p-;*-xO+(`Te_Ovsh3;*+SV?*E&Z5hA}A!$ z(0#G}j8mO?`5AgKB)t}SyNm2ac*YP0AWUG+`;phHyHvw!EJ zVwuOBY1e%WCXa1tX&Z;Lkr81(L;S*{zrkHRrFOHo>4Qh6j7m^K?f`R3l>K}t(`MMD zl_-+>5ZFTyhvq!oF=3EdV0=#St>XAb-}y|q*v_;MmSd#l>iYctUTLB(U;V8E{ta7g z5YIO-0sv$RCaR9>3(nEY1S`W3oJ4;67kBgS*)|nv+T@kJ#Jm9J_?{RVX?-6yj^qCA z{K6jd$84r=ZE~KyYH*-|1fpRcfgP(1>J8~ay9%3TvCmv*vJ&(ub33i*u(`fnT9-)Mp1v;_W>3LdV4a zMX8VdhTQBJo1YaWH~=&8b{YyZ72@9*&&Jg{!%X7-bArhN4mtDkFw!HJ#uC+knqU&+ zL`u9vF)d4a6iQ5bG(5KG2Ny!^U|Kh-k5>-Q9jNYivyO>Ak^gId|6OxS%dLbZTFDn* zch{%Q0OQ#U$nj6|ib+DU0GLbxI97N4vopdbm6erofY6rc!)Xy9V%Iqj0u+XJ_c>z& zcgj`PA6t@m>$W7l`!DtD6vIgp9sizhA1-wK$lARuw)(AV;NTlnsA}@Yz$6sS zoNf`gEHVnu#`i|s2$b@A_?@kPcp;45|JTvDV3uC_S6O1mVdb0QgKVfiLc`RnJJ^H! zP2{wbLk?Y9^py9_ZB^qsZ$dKh8f6FD zOEQp7dIOkY)>k3VO?j6xZ1ScFKOTYFFvJN6K~=NdgY%gLXx=!RyP8JQIwb$e3XqCQaC zlF6V=!@8bi(mJ~Ii#fg3X8Pyvf)p0MKK`%4;@+b5id@7E>>n}nEO&bIP|7AJ zTLrQ6d725IFkY{;VD`GAesNMOFKBL98#9jINJ^Kv9v#w4DwxPII)a`_7VNM^3dTu5 za1;lFCX^H1B=B(qg##a6ix!`4=^2bigf?8hepW6zXU(E+I11b z4UsIg6XtW4@sh2oCh2O|2b^O#2U!StUz`Q4d(B&Y*vzw``1!eoo%jQe=z>#h$T-TyfU|Up#!LYx)G*k@ zP;}r_EI*4WCPweAPHq;IpkRJBxJi`+!j> zylHehCW7;6g0DzK10Sm|RJiMtw8YKZsO~SlBjOam=M48^p?>DjEo^v+_$l?%&Tvrk{BB@#BZaEjMqVsLgd-KtL#A-XNO`@+i+%X z3{vc~ot3D2&3|%~iD=7@(Htqde|!(qM3+w9Bph78<%S^D^nX$ImQhu1Z5t>o7E;n8 z(jcWEA>ADUigbsRG}6)~p_GJlgLHRGNq2V&EI^R%I&#xqpJI8kCJFqdbMj-D<%+)|Eu6?8{arO{ z&NE51iN}oWTL@!V>HMTwU(_Ep_qa>6L^_q!_>B= zOGDW~7qDvBArKd7_Q;tpR86O8$~$z5eV8ZZ^9u->Y-38GGMS{M?bm9kBWZ@yN-Ls; zxjCp_VT}S!sBHivcHA5w0!sI!)wQ+CAb185QW#(fiGt!z+CJWP?@uR~rsS?ZO-V^p2Q zJ&xoZ5eB~y9m;gJd_`qtd=OHEIsaMM=IsaVReVe$Hvg;h{kQ*bhX~9pjmOR}oRn7# z1)KakcpkSF5rGiv?vJbS9Q}q9kaOWX8dH5TM^g_^M}WW^PV4EG(?b>(*`9mt5FO zAdHB;OWQMC%SF{4)OxCbit_MiDxVXBs=B%|0Q^oc#4Mpu7e8WQxWDxh%`kdM&Az}- zlAd0u8Q-G7f@7P8uz8tnYE}cwb)g7uWSRGTv-UzI4$o)|WPMNUM?~A@KSqGfSj7mm zsB~y-LA<9`Vf+R5dN`Rk8o-t}i(mCKH~GOG*t7se9Hs+ee?r=NjTts7h1S;FrT z&$#HbRbox3#0(6?_DJdpEYOAOOOhw(%uoO&wY5$Ssvci+D|#)b;^yxK^G5?wDW+Nh z?GUfZ1~a0(1sf2w`S8Kf)3Z4$W?SsUWuu{_WN7|lGa&drml@>2ca8AOv(3SfLGf09 zLm9d{^bql*(_O*)@GH?)I!MWo!;Cpn6;8&ouYZIyKV~jpMB+*&2fjwF4H-Oy)O&IU z-r{+-`+iqH>!=eqQhwQV6aal7M)1cmmf@eqQf4>)}GaKCdAHUl|z~AhaX? zDL;}0DqQ;~B=&pIG9#&3RD+9_%Mlx`!2P<_uvOl%`Q|ZBTIKP&Zvi~~8}iiYT0pUP z(`@_1H)Tj5^6>Q&gUAIMhgR0Hu0jO9c+u94OAG^08*#+3bp-=PlDUC;t44=P2xCdM zFxl}7wx(^(Fb0-iSs>=qWcLU9Orrqfg%RjyTA~Cap-eWn{P{Kf3bjtao5~E7_pl($ z!wv+_e0`BRBb+-L*_)FV%&51qId~;Q`aF|kDo}!Y5ufOk7y3Vvfex9qanDEQE>d(a zKwcULNH=>r77UBL4xVw=31+iqej{7gy9R37P$+Z_7d%~I**J*!Pr`>n8wi+Ft6sE_ zXtrcyjDQ!&)oN%+7t=;Nup>OE>S}*fadc$AmIhFhaf^?CDg@c()Y}{6 zeWHs-s*~Cx zpvE&f;)+xE>K*Vj1ul0q)Zv4{43C6tEJ1Jj1bBDqs!49%73rJ?T}CmTy>r0haqdwR zp_Bo`u}o8+xyOh`DJET_=FcnEzu{WaE{`E2YD&HJ;!IiEC-(kv9DKC5cl^+!X>ht& zP0t*F(!>%vJUx#h_4`%>v=UZ|HNXzxc8Yv?wfBK1)QBm&BM%BS!~-MLCGlyV0Ozxj zhEIJ_G&mFB@{yGu=X>)2rnpVJ z16Vsz;t^wKz8cx!f+UzF{hGIm1JoLw%3xza1Gflj zXyCg7*1Vgv^k0-$bhOf}dc(EU<>lAg?+@-buUx_5rUfI=)3F zbi9V^*yLWSO5VUcus5~DJvFyeo-kIauhd7GNfOa|3hbAW>b*Vb}*3nU0GQcjlW(8z5w%XIKR?PDbQDnA-kqWe~6($g3h# z!GbiP|AEHZg_H1{2d`!qO6keQp^XFqr7BGX%7*FuLSPj}{PrH1m3s|xz9TayF z;2i$V+0U|WH364YAy_=vS>N4kQqtAZDk#EKc?jV{%S&##iL?QASUpIG&ct*3X>-FGIJd>G6tkY6|BC@y(l3}3_L46}gi)KO2Ne=-mi_~Wf zu+n_^Dtt64N?U`g0bCUJ01@iAQ^Wb*m7oNI@WKbGKY#-mZdHlF42ZfLS}9PO7`N z7{RnQQenVy;2Rvg3=f&2${!bS4BXX=Ij!!4+Ap}a$2VSK2+VM$9qW`{=nySiOvdf* z0a0>~+hE3!`E#&{^~^qw_<2r=%IG%8p9%z}V6jB2EUXI4hp=A;#l!Mf@NFXsV5MK+ z(WA<BDORyg&JQ*lx4PlcDdsO!OA;8vXv&>m=(0IF#s&Lg_^tb_xocmc8NCW>ERe z-wITxH|2&o)TMb{nVVQYD&Vn*_sVcPJa@!X5cGCX6a>LHJPy{<*52N~zuRvncs1GS zf2nO2ifYF!k@st#hlJ+|y*jdTs$@A;sUsAC!wT14lT~7riW{Z+?{N*o){Mrx8 zCA%JQ(T!-hAB3xW9)O0pBB#Oux*X2C8vEzF2VR%``f7m@!-bnQ7xd_;bs{3CH-nvK zKwM-g7FYhq5rCDu@#3lwl5Dah@7QWlo)tg9q`+2hOi)L8^Llf?8U7U3IVChpjHJ1= zlF)yK=C7&6_gCJ>9&Hg{)@bGVOE98o?z=sUF*6;hP#@!Z(@tjq`^_1E`x3RoYwGU8 zmw(-#^2_CQblT0&{>|YHpxm1dT$U_E%{y)al*#l6BzioE@x&xCJ>MFpV#t7A*|fRo zANaoXO=e*EJ4h}po)>(QRl$!S=I_&2yJxfyfNmP>ma*R&o<9F-^7>kknVJG3X5yf@9bVO~K$600C zr0jUrWfHFo&*bO?qGp?e!?+-L0*8Jvp2;R%Dw}WbsuD6UL0_TV_jhVb&I~y5%2iPa zW?qR*6ISWp9mVOzZ^5Ub{Oe>pN1!dFb!KFrMOWfTMO_zG*_ABxJF&&^XL3ebmh6Sm z3}}DxM?c)5G+cv^v;NW38-C7kS*UTtChx8zbhXX{1B~q0B&YYAihsRqm``{!xksp~ ztE($)$y{$y>xT!g=ax9dSaAP@U;-QdusL#Y7ao1O(Os~p{U79)rZ7-I#TLFPn>tM5 z^S;F?QzDb6RU(up!Fmgud7c5#*^%l1>U=tf4BVwCe-QAVAY& z<6s7@?Aq;;#y_&qXw2D9_=umRifPl`?ylNwo$r7-nOh5=+sU&IC(sc{gwUnm}no~JOuT}Jss=#mZ#r%39gw~ zEJOf+JMT8zd|sI8mv{(#g%sb~y_fz3rb&;?=?&*7{J6^G%ahpWcaAtohm5L5VSE9)nf4V=8nrlx`pKR;7j3J>2R;C`)@V~W+V&n0F$F9?+%VME}^4Di{xWPET4N4x#hpRX4Hqyi3L?9TM-nA>ptW)h1& z<3UGJdydn+;}fa+pLy`@Uph^sLMT~c-?yEg!tJx!YJ2#D3z#1=I*9{NbUB`u014lm zu4h-z5zdOkd(hQ<9fVC0I|K}V9aMC5Nb8o||I|w-I1Hye`Mc9PI{(Ys9vAemUfE5= z_D0G6_y7((Z%6&>xoN)hAMoQ+@9e{3XY6HRl3dgtvfYz%Z@wS?Dj>&9)l^pf7Zzaq z;>eC`Hg7qf{G}iERya0e04F$rbKraIa}~#j^`8)0D1p&O8nB4odl3ctzySKL3A>!h z!TzSN*6~M`!}Il48Zjik#iA~AsvQc@pSxBE=%*lej*KW`9cog4mkMuRcHm!}d(*Gs z*fQG|bQ~WqM%KW0p4f(!_er2nbP7T$Gr)@C!lwSP4Cok=U;{r?D^L_^r3F`JmKiT8 zUw0@-S+Y#@iDw@@crz}*}}~1 z^SCGVesO+&MrP(ytp>;Z$XkrL=cYeAP{>$IFkT}ZbF(t&Jd5;M&hNT2e>y4s&M;L@ zMK3^=_LMx=>eU^NEwXeY!|z%Hf?RVj23)T%$L3PLs}*Q#Yd7!CfLtI4#3uZo?g8m+ z0-&N<8hO)VtSv>QY_(}~bC=^=+<3BL`q5Bx6TSNjD?PLjOOeq<~cn>hYz>eFE$8|mRzFPcN6fuu{mscJ!%jjbdm{} z>%gFC2QjpAj}cP`<8v^%OBOB2@S+V~fhiwIqmL z>k#)~zi?BZ8pFl-^i@B6Q`eNV&60!0zR(n7Vq$`eD*O)O1h$3@EG)S|U-);oAEJ*4 z4)}8LDi2Os5=bu=k18w9HHu^DYB&b|N-dBHX665t+7=EMZ#v`yo`eLP)U&rHaxY5x z2ytLpq0aUts)h{0@d9)CA-QGvZW$l@5AP3P-b-LSo}q<)a{GM+9>+SOB0HavAv#fF z!v)kJL3QO=t>`k>+T{N379_R6Rz?~qQ`Hn-XI%YOVf&^)-Q8J_TF2(?N*)&*D>g#; zj>Gr6RUP~B&5!H62|NBl^j(PxMSov8_s6{K-k?|nFC!om1W>j1=GNu$O|!k$znL!4 zt_=s$5Pwp1t(CcKht32Yw-nrfU(nWc%U!jdPF5fFyr=vV^8^tEb$Y}k7)#o7VbdW} zu*>;Lh_;$R)}FllvmO8qC$4Zy#U_(=SaJ&~@cNMJ{UJ}ee5aQy3I9q{_oi?%d7I+$ z(bJIeol9-dE6xuudR+IC8BtlC1U8r?{ZEaglPt658W1Hmcqf3Lg`sIuj%Qf}G7_x4 z@9Fk?!I~lcyJt0k8^j&pr^qW!nIB_;I5y{cH>F)QW12g@rlBp2Sf<6K>OVEK41ve- zDx9JwB{(Z5_sPY!;0|5b=70~W7yCg-NUmt@ia+dEUML|I-?Idt;$wBT2P!BKdHgcx z)az({G&HKps>_DpNsD~83g^4c4A9~$2u^2dGbhq&4VfA`whDKWZEq`{>Iu;%YbJTDCinZ{3YwfMeZ|=ay4dhj(1NG<%8jBm0H~1m>r-0`1p)M zi&9`#X|sy>&V0y)X)^Q;A;mqYNMFNPDCjei4TM0&5HSRNA6c(FFgTE zEf-{UzB|8v=X>AZ%^`cP_uv*37G?pNpAjHr1fgh*4)mN_LxNxgoJVB&_@p6F{CWxM zp*tYwcRD7Ff+FIh&XiU39D4x5)k)-6kDotWhr&4t=PQj-RMe(&gM-ocn@1Y_zMIHO zZ2Ez4rC5SfAwSKhSfBP%+(%<$14WqMQZDvI#^o_g8I&U6x*h#`mP`E2Ri5(wP9YLPs2S6uTv=0`2R!K+bB~-Czb(x0EaF2N}mf-hA4w z2DYso-tpuOeha(B^6)<7^Xw2X^SE`D+Rffjzq^uk%JKZgzPt=%3xDrcncGWy+v6OR zs{LB9*tRe%ga>1~1PU2@P_{6K63?FE;$m=aZ4vGL-*z_Y|5rQv>2!i?mN#4Bq9#cuFi;9pSmPZX?URl=^J8O~fa6C%!5ys~U zmk1epIh;}h@4v`SAjHhcQaVsLjr`P0rb@1S2y~Ce=WAVo;FfDR*M9RKpx|`gxVC1v z18fRYguRzA-u!AFrI$~p)QfzN;s&5uOZz|wZ_nhkq^L+G@FnJTQB0e7=Mc_8%V%Jh z8>;7ds>--o$_{B25fOp-zIKmgl+X=Mx$AwqHLyL-aW#Aw+NJBssY)*N!T^d`xZ*iY zKyX7Vu!8BV+hxE0k=61j^Fq9JRfSQRD`^*`KPDDF!PYbp))Y=NcD5DBdbj`G7&jTB zTmrCX5S>nd+Q$Ay%K!AmTYJ0P&z{epqN2o!;yTU9Qcj1|F&$5<{n_G1?V*dXjN#Mg zkA%5Sm#DZcdy=XC#=0h8%nE;xN@#!bp*FghQR%lhYMn~5=#p|LN@dTn`k^~lvc(2N zm*exou6CjgjLJIUzg`A4M5IY0fy*nN1bxMd`i70o?`DJz=~-PFDkgQM5db z#o#3p(AnO^#bK$W^Cta@cg7Up7-i7XRGO%se~WzWn*EtmiPpA&+5p2oIt*SY!0BBh z&PD5)k={e6obG7Tjl}Q5{p#aA1U}hM652lxe7B%8kAcRNORjjlh94ch^4P}~8llJqPH#)#_Z9La5AgI@q%Los`oewuUfyMlE3^=>3PDzOj5R-FV6d^yGp2A1#gsJVxQ1!X?pp=Aa6SC# z_{2jE3c;#xT#y{n4BAbmVNq{;25Re%QPP&#Z$#gamM-Tzb0{WT?3TbcmjccQrCSd+w9{#Q|uSt zSK_G?V94v`fLw+;anX}tRh#2Uc#la@YA+#WIZ(y_D4lD|s=dLW`9l8X^X-HZ`P;uP zqoe|fiI)(0t>As}1Y9OALN1(>WP5XSvj|4qPaj0=gxj-F5>cpY^wn|{8GX;khYHHJ z2gE$T*f~s|;2gZpP2AWO$+KTmBmga*v!AxT@HLzBIIjl^nN2ozj+L;_#B#5|8H$!L znEf$KOw>lp@X0_G`Q?-g`4c)0NBT)$u3^u zVoNnO>cVRhzqZ8~_PJ=~%(yP5JU5&rK3OfBT35*PXFmP%Fe{>*>xfnmR|$Y62Ph*x z306Zf^t zC>QYqrPGKKd{lR4_*UT;CDSGwQ}^vHbPK3J1%gNVHTbs$du4qRc13Td=z}Cuv#-~BvkdBcupp`t$ZwE(Lv>UdqK|pfPYGBiMC9Z?6tm_&ci6{iR@=! z<)ZuzPxfow@d+#Tb!|zm1;mD;vX!gkk@m z9TJO=P^6F{DCU+^yYnQuCjobkU1uRQ6mW_?cfk!uoUHSRlBscna4dCpYFX?A_8*slQAk(NbfHYWt)nN{I_$+cYT&hh4MU ztnXBLQ`Q9d1dWp4qZbzxttJ$1-f`WA3*77J^vmq{l~e^0eWA)l~L;GH1QI6DE1vM~VfL)uRBs`yj=Oxz}6I1FAh zYEn=+`VKD#%)rF;QtOOcR8k#y&AD*>pwXk|T}n^PHC$NoDCdj&@;lA1Y7f#LgAEF{g; zRL~5B;O82g3Snlz7bgY;z4_n2uLm<6n_vd8lc_?E{`A)jCtAV?pDV5vsnHjEAHB*h zr0ZeQJ?b*sqm203G;q^nk+N8`VOE^Zu=UZ!)0yv#Xd1A249=WkJB?e6)3o#3Fk3H0 zorina>DV#?*bvA5I=K}U5_-H!zV&EF53ZKXa6cd^hTZ+y zzZ+VjW?>&@t>J|>MJSV*e5ej3*k-NV$`tr9+syB2)gNo?h8#4f{epetRw#5Py6LgJ zQ`8BQO;R-eK&s&UJc+KpeyOoZ0}i=feMw>A@tH0*F-H%EU=X|RXRRY|7SQFw#wb=x z%JBwrE2uFlEUwRK#*uoM0N|DY8ZS~Z{*aZ0b|;9DY9%0f2TMFfSTP=zXgcQgi=ZdN zcYDjuFD{_E#Y3d-->^~fRAoP^x{yoIV*xB+Sv#GpUhc9;^U$=et#^mcIcWx zJKN7<_NQCE_*u~0rLZryhH-7HQYf#l48LpN^z4c$lt&<(5C zEn`cOWkXeI>NS7ehZy-k_d#E`{Pkm}Z0KYo@TzapLXo2MA$^mqXMq2#`DT>$B;N)W zXDZ5J8VWdc*d0qAIQv)ZrEN~G0Eej2&B3JV-4ra0*mEtQ<{oL&bSU+KfQ;4^@>B-( z++X~-EC=`k~AQ#ZEBCJ)Y@VTnp23n#;Dm`hChqSz@Yc_8o zaGsEb#`bkzwq868CdyMi?8FK9d!#7^0r*}ff8K1Ob!#GkHjmAX27rzHHbD+Dvd+o# z&l(iQ2>28ddORY`Zlal|9-&Po2FSBp^ggcn@%0$j1p(kMZoAD*#Od)Ww&f)ri-)$v z3nU0t*%?V=dbxhV#t=Q%@80_Kymrl%@+}_V*pxeF(%JdPF6VDXL;xj_QNS!KBKif~ z6wE+(7Ztfy!f@@y$!qDP(*sa9_r246D(%gExKO5GwpF1F{pm32os6@Y{Q!6V34|OP zf|@eqSk<{x!$ZyYO80@zvHtz3{)sRDpSqhYUu*YPBm1Anlyt43^8i1%vHjZmDKt6y z@qdFsR{jG9iD()SD}Gcs3o61nK$eN<$~562xbN$CTO|(Ao7@+lKT{0Ig&Cd&`OJG% zsRSER|IkZ{;+a7)$1n3XSf|{=VXxE;V9XFlk%;V+u~qV4MI7 z)#Y9<@abM3s1;dSS{75tX+1!=tyCV1NJ_C6FI}YbaZT{?xRvMR{$OP0NM*Gfs-_bE z(Mm1D%k;Xjm~jucD;OpUHADR1t4xOTtv}9$JflfwJF~uIH@>*o+qE@Rh8=O4-DT;s}-Q^PBTQO3xtlh>~93AAR{gQt=(3S z?L*LTYCrivAqmoE270nS#JT9Zh2i2X3GQUtp6B8}k42hg+w#?hX9^y}g3 zxWX&4@0EZD0J1d+xj1G_d)^WmAA}PY#4Wr;{{vx1_N~V6W=1C9dQ{b#t6eW|$ zhXFq1+&>@kX+%AkYUVy3y36X;2!{E(;96MLA6fBvQc;vRX)R5_v|z8v3CPKz1K|Jf za2VD&tc;B8-#`zO8Ev~}Lx{}wa;euT{1?(E?3K79IgcRjk7?-)0;EvZ(}$b_@U<>@o}3+5+o1zy2RHN{%dOa%AOSGpyDyC3r(55Q|I}bgiiMB&QTF7Iwhsj{wzhCypR4F`SWN?}cj6j~*Xy0U_Kd zD2~DV`c!VDcS?k(Z-W+=JkNEtTD$}g6)BroUVj53KhYe3Qq!_Uuc7ph1CU z2D<7^hFs-p*}TXFXo#d#kE7mX;?tCUk079F|48YVpZ=fB1;4N4>T|C|PMZddA?~Tt zav)+b1))=Pf`7^x4X-_o;K?=kuxvv>m41t;zoSi682eo=|E6%V1xc|r&oDbpY!l^10cLzbupYff)^Y*0!zdpEA?+D!2LE%@sejrTB z<$WDB5rl6u`w7vmD*{m?*c^RUyX$EHgkGN0Tj0qhVDdIr3>HrErJ|I<)2jgo%Y6d* z(*PhmNP<-QWPiT)D=;q1wX#~i=;Gdj>!Y0G?Xona>;OX@0Ko*j@xHF$;11l84DUN~ z!TXzIbq|%%4HfUh5dD)H&AN2&f{imcFzM=S@3&;^K?tTa!A%>*jcD#O*R&Zp1m*U+ zTlnr}*g7GVB=Rt(OOXpiqzBIym9JWnutxyRt28|aXw>|hRLZE%M%~-zK zbC+u z@FY-{YTWjasdizlIoY1;jcR~;-fiK8!{$K7zURLCTt^FUBQL)aTzae^BXcPN>bRA* zg=gvw1eUtDvnXz#fgGWh{Zkcl?i}r{GE*(+-|XwS-W_yZCkEiRUDsX=xTbW{)^D!| z)=c2`R4Wy`=^cH3H!R*aNdfs`n=$3tOXZ$;eG~#LQ%HY<$K!baK;`?DD+0XFionTT zh~dF}3UHy-sc!{=d^F2~&bch7DKTu4MVF|1Fsdq{c{JPm&UO{FzFn_>2V~{+=R3>X ztMu>P-!0$E0jkkicxz#4X>O_a?eCNEw7ZEAww0nik3To+Emx}W1jxSAS;nT%Aj4Mz zw6Ei4AE3DFiL5jG`&il+yeS*M{C>IrqJNpi`1%-+mTwhYCWe*f8*B{8@)T1Rd|B+MwJ#IB<>cxH{$C0bB{U!ua;_{=?ZC z8d~A&(p}#j7$Uqjh<~allV%?fWWwbBU(>Tz;6Zgm=4<>@D z{HEx?Qck=2R=d+{N-PZ8;3=ye4Jm(5tKg6j7KiTuVI_36026{eXX;lHSmwFrhRIx1 z3SYCEpzlR3d=nMxl)_OEWHA_~4xY`?-Slrh9!jbcKcGM)B3Bs3V^C^xWBt@*0)Rb z2VB^G*<8X@64}E{do=hy9Gz@YxLc1wwSwo!p-zx9YrfXw_d>o}3_4agb@0=OA&^)zyXJzV>T}gR%C#dF_^TKQ2nbxw9aV*C3*4 zxjS5XVfXMGQ--k@E5kbzHc@C7Z%_>N=b1sQ%`neN$-TPa{+Jg&)DzuccO*gNNSIP zbmAPpcj9o&2Xph@z9ivbQXbn@Iju9G%PJKm6OnYVfC~6Zc{DgQN1^lT@ULm~YIYN_ zvgC8jo#$wCwN8%_oUg`?5#*ghO|#@`3x=@FqHv`i>mPHdXWt!`YXZSO=^@c$*}P}T zU+x-ymt+y@xrh?cfbA)JK?6ZlsLAfA9*)fbkatPYfC*UmhAYx3gOA#vDskH6FZeYB z%_}!?*kdRPl~HQX;)81Z?K}tnUW(!%?a%rJ0bvL0N)^WVo9ch&k-Sn%n3eV^uQMHy zK{B^xDmq<;w;v=3+u=!h33as&d^ydR86dq$;hV%)b#P!m93{IuS_@$r>lQkDxv&0J z=<1p0ww%6F&H{7q8zLGND<}ZV;GGEs##=9`7qi|p;wUaUHz;_s-4EfKHqF_raWTWU zZBVZ?fQ1}SA0LV#J$RU|S^3_a#4@5(n}M%`Wx2`Q6y)&?1=1ZF2$Ml zn7eZP^zZY`%`nLesU^bUOO#B!z5;NJdkgqET%Pff*WFZ^CMG6J9T)6klp zHk}0d1nEF!qIjRbR*T)LVEKT`~YjX(Oem|u1(|3 zPNHqW8{YRA!$_xdh;ZI`Hd7B4lPi$)%x`W^AtomNcESIfAD5`w{CHdTD$6r|=^&oL8A z*TVTMig3*KKwz?VuAwxs{veq7e3`a8v3q>sH4sLz=%rT^PDQa81qWsSbl)5(R!V|0 z29Qc{>;2L^*%X)fb(!}cV2y0T_x$k@Vg78)ze_@-5Iel+4PxZYY~G{6IsE%kt=)9l z9-dmz4CMp(DjKQj;Ws7uiN6foKvMohYqg|P)`>?izrpPvGRglS zZgdKaVeRiSyq#rn|IWjSpcmQNornDKaqoN1gY{-eAvVv(Mi!%zlV9jx7t~k>lCh_v z7<@r)B!|;V^P6^n4)Q6i1EbcV5v@EpGm6!EF<&6R1KNYdSzUhFh zYM1JibE^4A4a^gw2h%R!HKSIS4QE`)^IXYW^VK?3HH#bQe*ukgv&*B6rP)a?6C{|` zvIpHMpzP!UJ?sPlg>o&Bd*68Qx)KqNv-yeJSiq1iP<)?(3PP5`xb4?HkYe)WjD2t4 zy)^Ra=%PXeCMvHX#y* zzCa7A%30`+RDhWnKT!AVd2XWgu=xeAm$5e(AinU^j2mgW6`@lqP)dEWVm32Sk+%3uY&@TaIl^HNEl?wE8 z=s5?4{%w$o`HSzRFNxjnK4SQLDhNVVXz3Uy+z0x_{5kFyH?ykQ6c42#9Zz$ae`gv{ zEjJY_ljg=vs4)v*uMd2Liv#84JjNoJ1wz=?Gi7ag>n6#eR(;=|bJ#5K_Q11WoHRbEzTB()gRFSAs#n0@FA4ns@r=hA<2=)2t z!F<;A5fif2D}k=&pC8nN;k7N|d_RdrBQvf(ii9b)C9UUqc8SfK;%z`uuyvoea^pWnCpmBsU4&dBCJf54FNSw(3u_U&6 zs_CQKY=z0h$cRYDW2Q{db`e|rxlBeo0xW5OAk&c}_SH0%@et~eJRG9=rP41+<6wbR zkzq@D4(**DT@hjpMR5!UuvS|UoND-5f>*dv6Esf$J=TTX9|b#?Pk`O}#O) z^(#S97#OXtsZlaA%7W=&1KI!(Tz?BZb2FBj-K9$|L7-6ecZ-IROu%KtAqS591j;q` zDRrZmkS19s^wK_1bXgn`#*hqw1qO(T$EAQOae~ihT>-6rim_Dd&iIr+b-1bnZ+H%L z;(8Oh#q$WHQ|w+EFcPMsv_VmF`JT}05JZV6D@VuCdH@>A(vROsHVwTFRj&I^fFIJd zOaRzjfQYmW_@)z6Q=5BXLUwD=!(a~n5zr7h_2PCrF=HwG2!ezjy%l?PG~*H_Q!f|4 zyV>Wie;=dq!#3g{d5g=d7b*5ta7 z>o61ZOm-Dm@bPsqhI*kqC(G)3_6xwEl)B$^#XP=c=cRUer28slA+xMa@IC%YeNX2E zji23?fnHa}$3s2!GgUx|k9_vp&u~Uvk{I5K*c(?qc>-0Eqh#NmuPS?{jBF$>Wve`! zp${jfr^on!aMvWz^Vp)Xt*}_jB%~{u4k34r^046sd7g4$E4UNt@6aRuxlz{oW#EV| zjI{#5$LZC(#X4Fs;TL$vhB$w&dVT#>)gqb`(=+-tf_$}cx?KUj!HDhSHHDweC3w%i zB@ay68R@|P909oBtcao3X%yG2pAc(T^~Yv8TdzKEOtUR8!4FfUP%AKM?I<3?M~zM% zaDDQG5*1M3eS8|BH&iROuNPw+dLj)N)nC0!WC>C(CgMp17(mpw2!#`?39DFuKDv(f z?ziL-TUiB4O^}Z^+G4o;F?;8F=!&y~%D5cQB*0s%0R@CF&@x#j+|AB{g9?D;w16TC zBi?t54EcvZAiijII1qA|vN{~-0wov*OkTrBK)wO-J|uq-)|f~~i7OTOa3@FR!L8jF zgc_%Mnm1uahy0TZFNFHc{J-XiP!b~oQbye>Gq?>V)P*w!bipEiz9n}o`ddW{Xl;q` zA^Q8sN$*$$prUb$SJ)Qde?#KOXgaES*X9Rx_stP))q&ipTJTJ4_Mr)a_X9c|5wBbK zRgQUwJ(k$fQH^nMLa;yc$?0*fsL<0O-J_G9Y0=U^IV?F4Y3SLt1hz>39y3`8*KXma zP({brs3(YrCH?_HKP5(HS(A65Caw4YI}Opi!TW}o$Q6eW6`jCHa`NzRWjG{65XLkq zStlYfUe(%C;bt;(K9e}317yM{SN+6+%GQCTBN*VJC=iR3=yS1HhkDDU`_J%24B4(t z%qCF%b_?Y#sxLBvKF=gPM(&*mRU&hg5(a~Em5?O~z7PbAeM)FBW#|jIP7fwzW@;ml z6a>r}IJSr9G^ASh418(@VM-*9bVLx_g6P$7H6SlykJHNFWM9xGk9Z7Q|B@_$3#4=? zNfC=wf_?=QV&L?AtctzR#=~M#%g<<_v_%GYQ-CX7>_Pp1#TFYBDOnPt5dS4$g2Ngk zQiEgLQd!)W|Gt}dTFAUeDXD-d<+dG7{7Mo86Zj6ej{|o-5`D6Wve3$YCGTCJkY<=v z&5ZEEzXJl|BJ`%PomBMa{pC4Zp?$%u-B2v);4+1(_3!t)8t(0|mCx*6(_*9IU=ffH z!LMh=VT6q6T)<9omSC`afnXBwY*gm&OA$e5G*9Wt3iGyX)7iya+2@sF2$EBF29C?w zJAQ!vRzy=2-;pGg!5k+BFWDkY)~Bd}*dXh<5!yxc(dVfLH5^Z@#w^)ByWmA=WVla z3U0JM?$C-eZ;oPG5WK6`A7bqNwfx5x-aF(x59u7fT5&7?Lbt>X*1f6Mj?93kYj-= z@BS19Iue4f9Qb!}5};C2h1cU)z)sT5P_1SMwRpI??8~~E`3SF7)(JhJ#Ii?})KV8b ztEQ@UgG(kEP$**du%Zk008?UveXj^t2J)y~5(rj4TURmtvq*4Xl9$)|L(eihJRC05 zhX7OzR)pml=LZX-zHP{bcNI=0NZ!cPsAC8!ETkv;+%GcDZ!;FmzZJi=Eg+E5+!gm< zV}OKO6w^i|Z1DGpuzvMZXy^QUw;ICj0oaN@VLam)0sJZklx1FDI&Mm@`*uhG-yQhx za!Gp%P=PK!g|_od@)(Wk*iq9g=**^@f`1Rk?b*;sT2V1-sW$2hT$P|j$mL_;1!Pi6 zoG&5@xx|Izkp~v_XcU;$@1&^Vx3m2sl4DdnmVnuy6gFvY_6*e#&qo>41kAh^3CW7U?AvQ zi5fZ;*$noFU@E^f63aNE8_8Ff;cK=Rw-r|l{)5E&$07`#NxNN+4Tl0%zGIvUXUL6w z*I9BFlHwY!&p(Plrf8sg|!qw zgXbk*G42}xxn>g7WIm^0K+;&_9S7)fxMi~|<5&eo={ukd7OPgGv&}m_EPOAp2zUz@ z3=AZW?Wc#+HeOi4Uun@kq71^;H%0ttK@#R2yLYwszJZ3qJY z_eBKa@f58TPADTWXDm|N78XYZ-p8-+H_fXZR3E~ISyPv2u|hiI_Z zaBl=F`iiJQl0B>dA$dut2*mQVjN<_#$9+z~V77MOtuvUwH9C=?0K=O*1cA*ji5B~W zP6%;b?#nO^r$03UKUp|oN$gvM>!PfefSnRX@&|(W8x?p!hQpH%mWS@}q~qLsvOraD z<`Rg8f)tYB@Gcz*{_P@UM6CA2#3Z)@vA{F&JZy1t@@rZ4>hSrThCDfpKyKNf(Izz;(MsQOk_N zDhoeFG&o`c!fO*>X<$YeDpsvIeQRNx$IuC&&I+juC{ZltBGne z{!!e(MJFfxPIVp_$dA{7|5Vc43n0$Q}}g9+>?z5R~Qf&;lOkc=fI18TLx{x*FW5k+t&PJBm# zICFf1_et40Neaj>D)=B!bhq{PxWvqT2f`Z2-M#$)hxf%hHa7M_Gv+ja?E3gTg50dt zy=#L!cgn!S>5&3gaWf!6#C7eW=!tB7(Ri|=GM_WK#e({XlJ&pv5(JMaYOBr1>D>O* z!!p%;um6(2;y@(LARs2P`7DCq%m?9Eh~feJ42%#ldFQ9^@@FH``dn7^WDEeg)G~F*ca&!CVma04qaD7v<@I-q+@_Dt_3^`;DT@>0E=i_fMnP$ z7tHTC+39}o`im#v#o#(C<6z+L`6l3#r@ik#c7qTru7r!2Eo+- zQ`ectL%Hv9d}i*%$Tm23j_nDINCzFp60(&;>CjP1 zWlK@AZ&^wcZMfeDo!fogdtd$2Kc45A=lT7<+wc2*e@fT@?-|d|$*Ygr=n;2mqaHBc z-va;;)6t(s>_~C7YtWqbgOU1DtH^cRG!in>Q4316c4bVW#vcwvzU7X6zNwNqSO7td z6__j{QUvIgACL-awk#bpt*HetiV3 zKbkHfhswu3pB9%`$8EG55b<4^&%Yzd7Itmz1#4BC&6QyQJ7@# zbT&*p1Lr877zDWM(jG6Rc{vO^o`AA@xEB;f%z&BDe6R!oRJ{p)d+5a1-pjM=%hC6G zT~_W4z-#&qC{fbD_mwoFv_AyvPQD+z>ro&^wlouEL$ZjzqAp#8R&^(LIb3*E4F3XKDoM%}_&Y~MoxSZ$9>lA65<8803x0^8C<@+%IbibF(% zI%ZV-gS5J}u0z|hR}W?H*DLBJD9V{+e5VS!A7(w+eM<5H^w!0RYCp^jpOo7mjk~FTw&mzQ z7Drmup%}xy*>AZ75`3V$7B$%*wOgnH^mq~TTy&6(*1OEYpdfh9z>arg#mA>WfO$e4I|=}xkrw6-#gk$ za)j7#!6A6A*I@Wc4}L5CMB(&>!IQ`FE%{xfBx=~-_7w(LdD{bF$YmrSBolAMQI_OK za~=5k`PI{Jhs{$Xdx$DK&o;lb`*f91HYoxWOJy8Uq%?ek625 zT)hjdyVK#%E%RriKIYld=0VRxDsm;OkQR0CR5u@VB$L{%CER10u}(NWJudhVw^U?3 zkj7x-L3K^JdJdkO1%ahg7O_@y))Oks!vkFF+}Kl3^G$Y6LZxC9z9Mv zrQ^|`w>6*%9AQj_t$!M9jRrKHE}71kMK*dW#}*+-oBow-x=5h(@hxOznY5noK4`)> z_l|KP;H%pOHhRfXtI6Zi1)djGd0^_#Hq3!65i?L>+XutO9uVG}s)YbA2fFFsx(Bif zs%0aLkRY|b??z`fp=Z&um)?>Lcs0Lafm0VU&tT+u#{$gQi|Ns8u)6+`cTL^LhyHN! zbx!IiHK6>%fZElS3Av9rB(IRz9^JQjaR*v8bAj_CH{PgV2D;fzv6`O!d)yaOlIa1} z#DDP2!t0r;7NXMDqJ>4WAFhlH%NK~Z2|WxoySz6gAFf?6V8JA_<&=of+-u7hwhpQV zy-UBC?Jdmu4H4$?wqaZ#diJ6`P~->tJSqv3^!pxxPX#*rSqv ze&?yr1s~I$%^2qXE81T4nbnx}L`6d=2c2f7*-!pH!@d^X0RBFtGXz1RQ%0^c{?1-A zfXnOZn~u6aJuIUc{EbC@@uv5Fg-~pV(F&+3gfKkumVT-}AW|p5xa&lfkJTZXGE)p7 zhR6S&qEEOpFzbaR5YXsHyOrnvyWbY&9@5#Gi?FlPtn>=A2yMLgUs0U^uFKwSbfzz~ z^y;J0ia@vZwlprbE2{nyNQoE#Uk3J#cZ`2AyMIb#RnWv?!GA z(u6@8A!AR>SbIVr;C?E#nyx;(F;Y+F&;*Utq+9wEtL!?4zTxiNjWaLDIWO_tJbV?L zMK8O~w??*6)+q<`4P%zlp#xRA(ZuU0BnmhJGagMRyS07x!YW>~Df@C7oV(8(qiALk zO6n*bgPx0R2O9~#biG_{nyyUQkTWDbbd24(SJs@Xzdl4J3U1m0uP!kk`4}7s$*@1^Q#FW4k(N*-tLwgLwBKeA!tB) zEWN%%S|xoPnFCQ)(9ijYEU7*bHjgkb@_BHFD2sRP3UHB%XHaM}FfsNbdjdGHa_lux zHvj_~z>6(n8?7Amt_RJ)Qb&Y|CvD!rI#PO85Q#ydD(&lXIAvP0#8Gq zUWveP{q$?GI`oJ^_}|R&#Q#5}oy1Sn;Y4q!*jrkP@C<}Y>cZVPT%L>iRWt`neAf&O>AXgxoYLEA7u(_yz#tQQ*!Nfi>-}}Z081SrGNRr zxX$8sBuZd1eHHYG&d z*6S_K_PFdkV4^w7$iu)efq&b2u!}fHd=3URS`8%_N<)~e4lyPwZ(yWzWTWXx?7d(C z1B}*l)+ekQLhmD5@+mc}h-%$jJpY+J9`S(@b8;_}esOpYX@n)n#P}~opL0xb>CUMbBb_G@Ei@V9NcH{@9 z8X|1?q!{CDCX8KeR^7?c@svP2*VK3NY?L>biwErUAlUyq-&+QBXwNoMp9~ZQrHQ!knBL zcw`v3xn*t4Oq?BIcHmbqZVNNDGPg1_J^qfHlbaX9$qV5Yyu-=Iz$3|Z4gBEcVdvu# z&^exOWMO7^@}gTX4=WoRBL;4{YwVohRZO>xOswpjVNR9|JW}BEO*>~Z8}K(620xY6 zzz;3(FBhi)*EIuvX7H<|y}gZ@rkSyVl{4}!JpAlDd|;SK;l`a?iVWP+;CCA!xu%bVX6yrFP>a#u4)Co4d< zA4EJ|9Qm-byS>@*sHvH&l?m7ha@5Jh$mV32>v+T%=4fi>csvu(i<^N*mVr|eOhx|T zkv6q5vT!uA1t08;z;S*o!ywDgASsRf1L%gFCM(Dw$;BWAj*VQy>V$1B3O3g*1a1qM zxtqx=x=Gqg-nmo~FOYQiZUPu2lK_}_o_Z`5%7 znzd@`Mz7koZu zhP~0>&vkNCCzy*P(5fHo{L}58%yTw!v@kp2?w`&B%trFt%=8a}^v}8XcOG6h16Ib_ z(H*?O(agrk*~;~g;%IatzZQR+hg|I6;W3zVA|n5MFGzF#50dn!=j1vOh`$>DfN%J} zgMY{8bTzVZIT5iFd;b$dfk6R=6?`q_W@+VYre<&SLq*(xZU3X<89CV>TU&E0I8uTC zeZ2z?&)MwMJs`LA&!zKEHRa@SKIE53-nsqVGV`4bS^i{{Psjdqbm_!<{6zWxXj2Gi zj3o2FG=)6J^ZxRtP~iBSe>L` zL4IP*X}I?HsPXq=4KME>S;KYejea|)bz&ZV;?2p(@2fVayf{&t-a_2??iI`Wwdu9bAS18;e;MP>DI5|`|stG`2WEtovPY@vP;sq z1ydI^GZ0Wx)UeZWHkQAs3D<=D=W5oUZuca*`B}66blzXEB=M)`{59@Uy0 zUt`2yecSI9BmP5b{M*{a69e*-kNP!e{7pFXJ7vOuYRpfp!B4#S)ocAGyg2P(owlHU zd)}OM=YQhOiB0=$D@fe`kmdds)xAH}oB!a}`=9Uk#Kiu~ME6AK{_^3$X-4>ycKz-( zB%a@}<@D#m`fEFoft$|;Kz@FJ8bIIs?-r2H!3BxT`tb$C=?7R13AN+qwFmwHV2w_{ z2ftY$=c$<)Iht648RjrY@DupI;}-*L4iczzI_;NsGC)WmAO8jEBn`6xFXEB0gV`ZL z8UT-J^AAHtHdYo$G@%K=aUo%WQb@do6~MDeo_t|zWonAVU;Qb<Fdcs`N5A$if8nc%i=*ogyc-hQW@cw9i9{$O zxn*PIZFeJaTfJ;2-dk|B`Y4=Z5wtzMOLIXSSS<{o7c! ze+T{ZcMQ;N7=Qu;MLLbX`2Q$8r@`2%P#k0YP96ek4rc!=Y~=A;|K*COVs{$uor>n^ zipL)B|6oNR5k^Qb;OPtPktcRSGW6f4)PK4AQ|_GX{`4^aU8;cj$J_jOw!{Na#sG-; zH=N@?f97QN4?N<(n)wTC@z2%rB*pm2_5MG#JchlVL}{m@_A|uvpVR(dD9JBc`46`G ze_k!QP9x+K$>u%{PEODEpRJdIe>7v@#=)_O{to)l0|C9xvO2*Gw@afp8tp6NYBYnZYN<#k^vY=mEFaLM5 z_HP-&sYN`EOa22``-A=e#U0QS(fH}M?a!&&k8e+}{2qUC@&NMc_HhY8{>2vs6ciei zn=+Dj;QGs61m)_o6^B?_@n>brB1loCP|0pP2b%0R-d5;mDwp7A>%#Rzr6kjDaPpVI zMWdYw{)U1hb;Y9)7gO%M#tofjzZng2UmwlAt*>zhdt03k>95a@6q-1G zY(8ss_wFNv?U?-D=5o5)E2aKYYt7Gt*$Lklhn4SITc>AaFcx^5)1b-tViTg$J-|TI zoh*__u_eRs<0FB}K1-arA5g!$v1m5a8d+r4NyhNJM|ef#^JHD!_pjs7N|(h9vBkb; z0VUSMN=m6B%#o3i^1heFJhe8L$F4?;tc5Ops8I8AeZ!E@9!f-S`hDT8LuDiP@mdn- zs?xrT(7U&b=;&^fqJ~4127dM&vQ%G(MuCDT^PJ zbUhU}2+PUNuhn5xN`5V(Wpx!^t&yWes}Rqo@;o~)PpQ)R^CMTDoMMG#QHIMTLLd8KUy$@Q?!@l0xe|??qg$bxSG^`*ngZ*HWq#u3@VP(z z?%v1cvPpJgM#c7O@gY+{A^q{nhFD4@pg*PXx_{bLY-g-~D(Rq8q));(3=vgq;evuPy?TXv>J&;qas;tNgM=IN^M z=@t-?c`uKauB|o^wB`EGojlG39&foaAY3;$siCC=cStf)^wsW)Mrk4Y6z~okDaP(4 zd^RJ72Ljh4Dbq!CU0hs-qJz$y$iFF&e}!NJ1uJ;f1D3NK$)6j2zPqNQ!@p%c8)2dP z6hy)G93L=VFBSgr?C0^SvW=OEGT77apWj`_zby3fISKbMGbOl)rgk&J-0XM;&}|B{ z(??kNj+COQjO>M-7iiY!yPeFFH#Ro@+{C?=n4`vFPKa@vzuM$zdP^0(I z5OUW%Joh>G%62&cl?ap9-ew%oR~=F>&QLO$tH3f8iyUsxAayuxX+QN?^DY6CkYpqk z5J*l>LCM%$JI{nznz=8E?^nMuY`}5r)~zD@=|;keO*sSA}-gffLobp^83J7|0C zroZNzv_)ylatJG+|KP(LaQ^s9P0iQtth;h~dK$y^vVkI9lUo-`m6yUf$aQ{`=EFwR zJcKliNL%HyI8^=oVYvZPKySt{zFBztf_S(E=Y*&DfTwf!uZHI(6FutvdfR3$hWy^W zxwBVSu$Xcl<4`)F7rL~NYPP3I29%6v2Ps?;->T?UU;b9_cV;dgYIl}WeQCvEWhm;h zuxWSVwZcV1Nu;o%5EbB}=D`H#vPWz5zB|vw@;Z$_AK?xuy$6ZI$>yZWy2~_0h08HL zS+3Z3bVN(kOcpU-<)$#4rzagB8gIMtWsuu@e>*FPy>fwWr-8tmF!v*NMf4>>x-*z~ zQyPufkGWWX$g?ZhymmcJuZyk0j;zSn{@HOm+t9maENA>!wd#$t6fwHL({L${6zEGPjiKmLu-evI%u zCQHGT1mjLC4-hu&R}xg2{%w_e-&59{Bv zUGjKDmdt77f8I0Zs5mD2y(l887NmrkH0ruHNg-qy7~Bn+oadpG=Yx*XI&m%*@Q>7$j)p` z^^_KQeNMs;=SYuaWaxbXy=M#I0g1$BOo-$(u2veFtZEuEBlP&IFRRD;ooI48B6mMV zaFBhF4zlzTQgw1FuAIU7oKUx)e%{q*r_*4T`e-}kTW1WBEzwq}=xY5Lq2Laoupicg z<~k7HP9ln%m8v(Lrz>!d+{6?DjJ8|W z2b*PeaXl%**%{*NPkP(k>h|;m;j3x8K9_W0 zlM~6b1qTvrg)zJ(rQIzu2^A2&6b`Y-^!j|rvf?G_Cb z`LG2xhMDM`JvD8YCnmtJglq~LPi(+pOt-7 zEnZdEUm}!@7TbND>^}d*&!x57er@)q;KBEIb3x?#p-_y@V}s?(0O(d6__}-?=zN6k z*G?6ixzy)`m+u#e_Mxt*GsxJd;?QMhW-_B&ek-z>tkvVQ`@od%ImbE|e9`U!PmjP% zZ1|VOMYF^GoiD{O&zXy(O?5N-7i2V(_-sF(3r#;J7tI!uJEF3moeBMMd!5s(9+sDK zUiRe43NmJ;pHj2pyWhTs4;7lN$qG*S%I_mtO{;~8Aff~A?^f;ZU_K^k*ny}hwD6h9 z4+ZvhLGC%KX!~+T0;`y-AluEtIBC@^SLPdrf|a72Y_}@6N13}` z{93#Bl~dMuZu&{CRzV@*5B-!!>gP>pk&>D-LleiORwh`tJFUSM-mP;PU~#o<$O5Q8<-k@BVl6Qp!P}h$_UR< zD}Swud#>F53$&Amn`O{%{*9`TzGCZr=Ry7V(st7LB@CA7nv1V59h@bE|^3zVglA@Xapyl@!0u@(13V`fNl0Q!JG{F3$ppp zw1g_D!Z<7)e;Kk~;~;Y@5T&zx*qwayOxUVd_5$k!l{xkvRwFu1(9~u~F*K-?Z z7=h*sZ!C{#f@qW8GUjKE8ryHB)Dvt7N?0F5v}8pEeW#HqOvf6wFV!H{7TLal-^5)Z zCi04V#h@M=Ul>AVEa@%_I?A|@*n8hUd3CrS2;7WU zFS*Blca#n8G6j)%jO9IBj4-xHqNSn>d7t^F-&68hK2UtZ-QxVNbrf3ZoVheoDD93w z<{lvONV@0@fBrk z^+b;L*DHehcvo$H1ndvaAPuu`V6~f{ex5FuOksLblst@L;Z1+|{@=p}soZ5#l^qc5 zsF&{~!Dij21L8p<-QaPmGB$QGtY;Dod3wFhTy0c+=P>2*DtDh{~c zU=|bUjG4A*1rRZ-m$XocdW`g$Z9Y6Ud8#tNqlFuiJ!1*a>(b5`>6esDznzRXop)wA z+~p%$I|#5|cZTTQJPDj4?(5OU&iq)t8R-l0`oeVs{aMvEnGyYgb&vQX61vjE92Y86 zy?3oXPt;V2d}}6FN*-_2&K2|8ZGR>m@=_sz{h5QIoG{TywR`c0dn+|XK1bdzN-L2t z&libppHkdXr=%8#YreX;;^!#lKlNO@sa@roTVnN2&aQkKQ*gQDohro`NDOC%CwHRu zzi8Gy!sV#GEw=Z*H$xTnNIo$sX-?T^H|AqL@WMBOj9p z|9SH68*@wux(0Oyo*Hc{+9x`q{Nv6sp3Bw-FBTj?4w4bn);Yx3UTUr@gR zs%*xWkJTQIxx9S1a&(xl>%B9#R0PCmETD4FN0GO{VMcDJ%x8~(Z~%xd zt3|Sd+(&bM+tDlZa`!DWEk2Yxfc!A4d80KK<)eE~vf$dgr-vo!;cm6-De@?XZ9e;0 zL7KXTxH?gbP{}Z5lacR^>3+s9g?{XnmS=)wD$-BmVLfuqkKtNZhNv_GKDau2mgru8~lG~n2p^r=Ipm4r(uR=@;)`6|Llcl#`` zl*tz}>2H5wOM5}%5~@PmqM@s`qd~*&sM8TwySz^Mtr?r@E*V7U<=2TKW+B?=1Rs@h zt=?s1Itk5@L2=k2YAiAGb!&0?*iw7+NZ%9lPFcLhMqF&?jdDkd+eBvV-ulxcwtTN; zYt~J2RCPioMjMaAolkQ|Kqg{Ss)4h_hbrpBr!g8ly_zmgr1j|U5Z5+Q#PIZrs2y$? z9F?l4#5I$BX^L-@7r3*Sd=()ELT2W%{Mf^9(LU`k@AZp=E1&}Lid)}@0U0hT?5!%! zd`L;arxs(gc&*vL_m;R^7~hQbNA%KI=2d+a+CXa{=Jzh#sG2-b+Bjp8e4FYl9}3Yf(6tpmnW+|> zz}Lf!qrPqz#~>D6kKd|NZ8XKNCQUKGar_o%-^3_4h%Lc8UGSmg4u@YaufRiahSU;8 zdWBoDSA>a)R)GmvmgOz4wL(OwVxgs`AZ*`#uyn|JH4@(Fl1_6W`GLx9MF^~Ktk&@y ztuFgS!OW`X#Jkn$CiQ^^28H<8WtJLUcMDFBBf>t6M$FGZ2C6;k;VrECM45ExM!wsb zv7jdNtoo&XEFPKV|6Hy*8vAJK!PGA|s%inHd*MHG8rE~mTp=Vud)~=`SQSJkU290fe7N;C+WXENfs@=hC=JnDA`aH6 z^u6z|#B;0Fu}h=G8d$ge2t3m;=xw-~hs5?7>tD>flhtjva3Df8>dM*pC+?12I#_PF zxACOcQ!Z$wE#5rzPV!aR#z|lS$K4a7mK5ZG3%^GM&x27Y);lU;h%GWQ`Wv(21*S_y zjA1sVWk3kNc7B5?NJ*iT!?Ew3Z*^SUE z{VeVKZ##mYl3$2uc^A%YRl3jZL(da=y&dz=jC|v0j61fCtn`LIBPclPF9D`AJ~w=< z45mp{k@gL<`}JIBLbj7(-1+8fOGgHWa|ZrdAGf0D!0Ckwf1Fgb4e}5 z@+PaojIBY1*wi`xiM%Eg-?Gia8%8(xE+O`7z4l(#*6NG)8DEUqs=tKrv=XbuxF4Y_ z*4Ypfkn6olMXQry;Au2rjPLgKgSNYg*k)mLrlds9p6IQK_S>6&SX8%MNb0+>YHMvO1U zc7#DfuX0!_rF(Ev<$JGqCK=eoMe)C;K3q3i9c_@tZrB3;Tf=C^{q0m?$uyf)AAHBl z8CZ*;w)=}vc+UAxY~+Md_#s*asy1-}k@qxAZZTdC>h~Vg%#0Qo9BC{3KdNkm=!%sSVac)w*BIl+KYuM=G}yhpXpf?Ork0nGI zGL(;K;~6f4m$$ID^sN>?TgL&%k|A<}7x)mKC7UlXJXR|&+Th9(%5F2+=vo^_ zeD&@(=Z2Ud{`ryGP%LqgE~BxysOB6mqkb_Wx z(C7x?*;Q9{1^VkzcU-3E^lUPvr3NI?Ur7i!+6*>n$cCcBn;XL+M;f9d#OxOM@{$RZ zuNV;fV?;IUTIpU*TGOP`joPf}Oku2uDHrtk8`y6RzOqqOhXi1rQ+4mKeS_B+H8}Bj&oMxf*PbWrKR`m3=GP^K74^L;ny} zU4bu?j-)P2aFmuBF>IHEcKT?hhe079I4zW)Bh(Y0!cb%AEHgx^sVC-|Rxx*)G7}d4 z+}LplR^bn}uG8rjo8Nlxi|4cZ?&-j$BwTY!@*8ZYNu({FukI5DD!qL?t`{!Ya(BZ4 z^hWuZHArA{D}6d4Wv?wg7tZ)=K0Xiird6jbZ(6*f?{BzA|0v;V-pHDhzt2ohZhs(C zC}9PtnrT6FYo9!6*Kh_}2GMh_s7;Ts7#!Wcf9ax4ID|kbYjY%qsoOteauZ|2>tJ`| zizFezeF5r#2i=5*0%Ji=${k7o*`pSUPYPnjF`!A2P+70?3}@VU81% z47@6zT!$Fy&UVE$y}ugj)sM`@0?pbCy^F!c;i24?@-{|` zd2X5)dP*CbbQA5D(VAJG^U$?pEeV4Y-`gR4_7+#^BkUb@=7TZp?)N%m5C^Y!Awt9a zUL&chJQ$j6Y0LBVt8U%Esv6w@dsy9Ng(rm{NUr^5x zbgcSM`;oaZ8Y!sur;!`&k~0!aq6JGbSBaGG4@Jm?xd(EthGH)0+2ARY_%j(MWxLhl z7*C9CVn%1W339E`E})&)N3Tzswf)>AElzcKv^!kaL1B^nY|Su=PKrkAnTZ(vV|0Cd zLvQ-&BD3UWDV+1va6yO9=?PiY<(w3$#_*~>s>Uv9LmKx~dNpHQ+mAgE*rjxGk*1`` z!`gDTYR@vz%Iy|Rtjx?NK*YOTUi*kgw%nkxW0 ziW_mK$WwRn(KLA_FNUV&>+1U?P!gSoS8t7CtZgDVdbU?@&(*CnDP3mlT!p0FEO}8n z=dQ7zUNDYNMHlMn!*b3bYU&)^atr-@k8Z=62+QD9fhLL^Y7kXIpa-j~(f3lTo!`om zXY%OiUw++dP5u#=oG65dT0mi5c2s(tFmkosePfrNG?4^azFMyQR15+)WaSVUgomLi zlbyE@SpAMR7f1nPh@Z~&=l`HU_!j2g3Dsfe*%WJ=>#h%d0|939$)}jbB-E~*rAudL zjUymR@i$@^mb>_>mlf`Hxo1VgP}iGVJH7nKaV*?GU|Sjf7L_)1>RE$!V?TOB&=k7> z{etpp<%E6HImbbD%~E*r>cP{aeTz9;zbR%?`069tDyvgiJ+Gr5}xbxdCMub2V$cu(!qEtlQZ{Y$d?N!1N0ZR-XG!F-xODc!+*p9AZSRf1^j zYEDp~C&)qhgh>s8`kfi-BPN)~yQJ9Rm!ol*t4qjYG>a5%VEB>09yU9?ZDKW;Kk&TJ zVNV17R)oR6RM<82jrz+Pb5eO&_)K$ngpngS_jB)o=xl`~Zx!xtQK@RDq#k0wH%0PL z*@1wvIvD1&H&)?t8*7AO=*Bl z48$YQ>7YXK3T25Do!KVQg``zN5c2c{jw`P*tvw3mYnR_)+J0r3ht_{kX~YLb?KC2gmr^!#YY*y9 zs$O~do#K)@Ij@F)m2m{^gj&ht4)t%gPl+Bo4P#HD%}1Sg4F%oQSR{$L)8g;6Z9rt7 zZ?omqJ8Rm+RdP^#6qQ|k#?R`)3CVo`LxnIzje~k+8VlNYa|eIWEwjSEZ7;}zkngo3 z9k6}!=t)UdFkm{ZwMC65uH{wO(lt;d%LVUl)tFMWKT9`G%U zmQ4o36ITm6QSb)c6bWEk@^iH@!}8j6l-#3GWxv$7_ZZ@Ek^;I%WZl>c{OtZ{D>l;;iP>E5k z!Cdom>J>{&!)53tB&+-J!p7MH*>S}S0o~o*{jD6B#9i;oWxvgEnzj>GpyZADHkWxx zVt?B!z`o*+8;V8ulGBOL#^>W~XTU-0XZ}t?RATJe1~Fj03=?f*k?wasnQ26cm%mwq z*@^wrx@TApo+7&&ayEVjai$P0~Uw#6CyA2cf>=Wv7tgM)$1=oOw(WG2Kzje zo3xt)s;~WddcuP4YcF~E_*hU~w^xncgBGyJT04D_(ZU5Lk3EdRB#Q)}kc06{oY(3c?_PTJx2IMQ7 zVa2hBisb+~$@sJ{#b!h<9s;z0;kV;C4A`?Za#b7e&bB|~wi)4^%MDMO!WcU#VaoeP zQj6;|-b%b8>hV1kI>$U$4Y@xOrT&E>jh~e?RQu))^yk$W-#@izr1L(C+)QdM*Tw?C z1K-F^urOY6mkAos8X^_;_8mx7OZ@b5z`u+AIA29k_bnkDQo9^+jun?thNcTDakS62 z^_)hY+@^Gr$;4Ejj*uJ`3J46T_0p zzUHS&G7kMq%#Y;+O+rHIBi80i^_JN*Zy#-o65Rl`^)lbb35O(uRc2KOj4g3 z!7MfE%wBNW`ujQ3)>!z#6v@|Vx;!zkjcTBXvHbNwC*LP@hE-mHJ2mx{ts9VcR;{fD zQeXyTe|LU$2O``OKbf7*+_eXaYU;5Kpw`pri+aX!J)rR3mK_DZU2?dN0Lb#P4sa@m zBPMb_^mRmS6JqPcHp0tv3k;NS=+bae$(I5alk(m-c(@?-5Jm5LFYG-tg7;qOlxU-< z_SOfd=!eDHD(5a*RJ7iwpclQjc}Ks@k-0rhB^cm2*1BM5evY3w<;QaQ+>Gk5@Gm_8 zU3_ipI!1f*i!Czs7<*H@8eJ8Ojj!KnP1^W~otu5jQGV$x7VPOrzaknLos8LNiIv)v zXS+}nvcMJF=;+V7ko$Dl4Su#dmrOhQD*19#WMqlgUg!8XG1lRRyOZj|A3h)1wLc)Y zc3t4Kyu@CJ?VfNUgxP?dq?&c}qWON8H2QP8scdCT%uV@At}v8E<_kzr-hK&2a}K&VWswSSbU0BZ6Jo zQ}VtbTk~^vsY7y%L*W_2x+>S@N1%S0Xv(Srom=8p31U-3XQBDA<_t;MSwG%ke)3dh zX(vq&@6NS_Kv%FR5w?RC{OxnuwLWQrImbnn^t0iRpifVIY863S6Qdh@=6T+ogyN7e zQKF!o7;;I{UGlaBBL7Zey<&^DOj2N{T1=nwpi`y#ehU$2Zgtghy0s{hQaW z(i2JDF=C}Tlq1qgeau|eoiFk_&MIrj?lWHtlh^mM1&8Ga+oNBbTC1L?ea}Lxb6W&B z3Wrv2>$`Uw6GhjF{BDC7riz9{sY?dkncmk0r0?jlm&27TqeuD|1}R101@|ut^N~-F z(E)!l z&r`U_N>k-o+%T>K4aK++YHtBMQnu^p9Y9DUi36}l{3HaqG`2Tx%@o(Y(KZ50&JHGu z`_!&k+Kv=7T=}XqN(s95YxaYKgI1a1WpTko+Jx$C5U#r5nZ;PNZ;@m}sws)?@i9B`lfpYuXGuMtZ=%b?=p8mq8t9hP2<|p- zVpJ8C!X3}uenop4t>DYX3Nf0ve}@9KA{G}H(+dj=KOR7P@CJ@Dn#7rU1Lm^ovt(%W zZ_vaM>qi+&?YXoj3KE{f?i1tn?O+M>r3HIskbr(2@2Eo_UkJbzzJrcu6qV>*_3sTd z!q=S}0idB1G)mclBf##ko7_r=2~-maurL`D&89$E&s9!8NQl_HXl-6_Taqx%izLtz z|J_aSR#MBsSvVJ0*cu0d*YDoJ#;}5#S`3?Rc^`U@+}L9=ugVhJF%7%g9rG8))|MLJ$X6TsPQdVb`t{>RiXh20H1^SZu7q7YF7-FGk=!L}^~L$uzFf*mop-H=!7p z6v~K4=@F_Q&`P}zJhW>)D{RIq2SXdgfvH-H_St{Iz*ZF|7lMD8C5G|VBjA9OER|pv z(~bQmau(nTO@zjSji#gC#lG##d);XDXk}KTz)z6EiyRg*=?zD{)u<&xafowa@tB?M zWg}}aS{pljNuzQ$ON+!R6zh^BF`)4 za+;pV1!rkbyk>1Y^dQCIT%wI8h6gh$#Ymbh+#Gu6*&QzGiwj0u*8|5 z2%EQjri;s(7rArF&!Y(~pRslHn)yJFwoBM&Ro4T!V|x`)qQ4}_{uFY6l~K}-xo0cB z`!+i3t^@lLXk~t9zV*TVQ_9*KWp7n4S5O>kFCErTawXUKk_13chGQQA3rb6$7geRE+{Kqnz(SG}|gH z`g4A6+^)}SRWb5R-1Fm`(9FrJO34on5B6}`ld7kKFUGnlxD^d~yPRp-Wu;3SLq=L_ zM5tb1Uj|o)`4y_6J0#FV1flWsY5iP)+_9=MSOhJZ8j#OBce!f4 ztjW)rQ%46*9{?c6)I@zDzIJ;qj$XyhRdM2l>F=}sc*x+wx$8Ny>1QKtZ>+wah6tXg zi*otgFPk(+CGM@80%*9^y08giVRLvTrdexWo;~#O#PSLKF|V?0)OL! zxJ_$x3O?1der!uki@3x5JqmOW@W6-Ru#IjsK=tPM`4DlNX=#~4Cfd}PC%q9CWymga z_EB}91jWdsXFNuoA3wi($}Vu#{8m33BDbO8&UHwWFz(&~=smI}@xwHr0Ys3F0ayrF z>Fz{PN)fiH5i%{I2$K*3zt$<`z{ucbYgZAxcC^w93L;GExXZ~=Z>qI$N1I6er^JA`z92Fj`*9I6R1TD(@j_R8pC7Xb?Wuw8oQGnv7hWs8N;W+NTJz8z^J&}d z=duyAxiBy5-68FCxy2sO)#~`SJI^SK6>Xjr7(}BdFMqdj1>hck+>Tp}i%Y{-1Z=X| z&=^55`$HT8e9!K=czAUdy0MBIXWxnAzv4?~zH% z0_8Uu7ZnYjmoN{UEi{tm5bUR{wA=&WUoH4+Q;K zC?i5}NC92Oc??E7RK__0sW#;E9J~b=<=`)tB z2Ud-NXTRj`1G^e?$0U!fC0;P6CZ4THx9q^90NIz-gi$;M;F6X00;8t;P9`Y_l-EPg z#h)0Eo?`1tA-waN|6eO1VEqIEBBCU>e5DwAHu(o1$2f3^fY1RgtFHcwNV*r zp|@o)1MOn-NFix+*`lR}NgTxhAuEb`q2*zMLGrq7*(aj+5W5QmKHCA|a+X3s(lbzv z@8tq7g4D3-P+xs?=TX?Rp)$vb+~qM@fK)NNz}ph^npb+QFtTs;3^i3U65AO z6hq#i5JACdDA9SKPvOeo`7ZdA{%s~J$kkt4aK1xXSsnDzZ7hW}_Vg7^G%qxo4Mn=EXrq z7~`VjIn>b*>-&x(vQoaA7a!Wf3#Uq1Zf$>v5V}#gaULyrGB4ktP9Iqh2;H2!D|Myx z1UJ1*K?g1m^G(VF!40p%*Ibq+ z5Pf-#(on1CT~ElKdk?_%S0M<|&^y^jZYA;0Y-qFDS=F^#;9e}j20M~9EzFilLq{Ej z-Df6Jwye}4B$0T`mW`6L*^+7k0j`UuATj0yAANA$T5 z`@G*tJ=!P_MOki=)ey{hP9w1w`NmnRA*l1dgWR}bhnR$%9Bdd=I$l5DxGd^%N62-_ zlF+f{)@5L}h1|a8JcoSD<5+xjbo&JZ>cyO<3zvJ^zxFqVZzhpF$^lR~OKSF_4lYs* zusgJjZ~aug{DVE#f~<(@Gd6Q*2BzEgk+`#jSzh4s$l1r;ns0Y^k^g(gl23Fqs@vSj z1Uts6POyD_NTBrKrC7N(OUpW;+h!?wV2}1eH=|yJV)uCy7wLC*&gG1tnaA1L_Smz& z1GpT>Nt)0YRtyyY@bjw#mxZqARXX1kP~&0gaf0spaU2kFSGx)3qW1rK{9AsX<^8h> zjd8c#Vf_JAIimbDzHejad!KTEYZ669O_;YJkF#9|UaP1=p{(Gt!aU`zs`NC$hpzWz zb9&bxf!-aKb+XCzmz=b~>5U#5i_tw0N6MbPs*=4RD3JzG!}$gGj*MAj$|lcWn3=>x z2%H1`q}Hg*)*Cg@a!u=#D-^Fdg?aMmq+u4V^!)Ftr?bhN3BotCFB%QOc+g4+lHQw4 zMns`3^9NDfR`R(ZCS=4X5qw0;f#;1GNLE>B(Mtt%!*|VoI^Wi63uGlPg6ghayM}P7 zbMbMvQ=ksPcP|xrU|F}DfoqMR22ylz$q~Ip)^{_BZfl}Aoz`}Gr9!)K&L(*>zU(k07*Hw^dA@f?4g<@nOO~=MSjsPhKOFS99GwQRp=sKghcA{3(iHT zR?*{V>{yxy7JGBM8s3$O_?=N&hKvhfJXqN@U!acY8i@eK1>l!T!vlK zUr!uvcNx~ZT6~Url?NZ?jM>XG?taxeREF+|$uU^nc#0w4=dRmB#uxlV#;zL;@i!$G z3%U`u7aur!bw-RxiFX9~_CC~HY`~(9#r>9cr0TI%H3>n&%({~Jl|k}t`@wh%T!#b5 z&o$ubbi4uNx2&Yjc8ss0ew9}IMSw-x{aJhRzU(;7JyB3AX49`8iCm<3)T=o3fC$aK zG`cYtM)9rJd|8ere>3U*Zm`7$t+al1jHag4_*hwlVTgK{=|pi*RD9}K$HP94!h7U6 zjJ)TY@np`~t)*VGj#qptrf1&u*l3oGyvH1gKtm!AoaVa#)V{LFE8n~s2XrMt1?SIq*gxnE8Tp(pZU0P(L)X(k zJG6)h>K!fHLxnP(TJ!e$u0OhJTt$SUvH4)V5L%R3C^p>R^xfz1|xYGZvE^g7^1 zI_z4X=BqMd?%Q(vlllI3)Lq2~tyg0h!Xz9)mxZD2!8Jm^9K!ah1Im_k-GZ7Dj06Kq z_kalIa7;UAm^?A^SaE#Pg6$xSz4qGmHb7TH!jc`Pq#*1 zGy|>t{!F#2f}rXii_-Ky52!?DuMoI01#DCdK#I$QZo46Dak?o4gNhA1J4M(ns~12- z&y%L(J;V%9E#c{*lE7?$((CbQDEs+BJ+0VTPG#IH22^}ThwQDzlKT8LBv%GHu?hpXf zeICw#IxsZUD#ZI#?rGDrm;l{Fhyw;8K_L;x2Ku~BlHHO628m)5nc`SJJDU~<5tD4a z+}@2By~$@mT@<~)0K;OqtRzTfbfbnBl^JnZ@#1YWv;FDcssQnIJ zN-b2_sSWINRjF$g&W(;0HCAIVXSv~86h7z}H~dPThH-BF zYaIc{Jd8Gi2-O1FwZeIvv>cxPm6w zcF>bg%=`7l;U8(Ivb@TL@;-Lojw+`_Oa8>%9Zf?^`rS)@d^L+XdBk!2%$-nvI@xu* zowBpLX98A}<40Vl#OEeq8rRX4B$2mR(TNJkQHPg@1$g4nNnKHn2u zkQ!0j5VbOSuf#9X_H>4IqTxXHy-AJjE*d->Nn^z(X%GwNl+&E2ZzDQ~+Oup459-jn zX-`3-W7)x67*vKv9*aw}dj56L>Ml0=Uci@U0}4vD2OQ^crX88!N8{Qwq~cWDD`x(( zt8%StGJB=T60QcUXeH6)(~#!f3>U`2H8$V|%>8y1Y%$NWM^Zsx14;mcl}Rfd980Pz zJBD@9wYoio8WsIQ0sD?@Xr~`-mR|63U%6G?kT#954I%1iTc;tpu@{d(*+?uhHr(aP z8S1vFJiLR7>m*o7OD32ey;e#M1k42phQ=Fp>Ri+USdxm zj_T8JnQpI~D?1DDy{|*lA3sgaC243*ZBGzENjFN1s3t&+jvPd&J2^R3nm*3T{l4@l zcjk4V=I8B>xpf4IPHo(SP3sQJk*G-E#C3}2_jk=_WXzs+(n;)fTN9KX6$mN99aVMh5CFaf#uA7)_h|03VuI9|{=JDNIol*UaW=dbou1{Yw2`?|a z!v!39$$SOjB9tqmZ2iT{19J(k7epBZ9)c>RUVE;jl%ontnBmx{W)%m^O!IB6cMInn z3+~_jRNCPXeb5G%R%5uW7|LuSf(ry-)~1gRIP$nRj^19ymZ?SAbD+Ly&dKBd^)1e> z*c`j?%zKuUu2s9~T+O#Z@%-MOzB#&Iyd3$H_}-YpZmB7C|BD1QAR*G8{fbApugd>1uYHyMaDB==w7ynel7 zg5N?>IJX=E2{{vpewa-{CdTO6(2^y}cCk8iczxCVAr`BVsoA#Mk)iIGk{0AnW)Ku3 zn?jL&nSZ45NdWQ+^`;8NJjl-E%qcIv^+Q?K#L6=Ja-TK%V|)Z>j#Ox_s))$9pk9l` zHEs-dhQ9KQ?L%*sxk-5nUXGl|8w=Er6~@jUqzZ*pYt79Ym9{Vu@15f&^HxU30}O^! zEJ@|VFh5;Nk|zLhyN8xW4s&L$^@ltZ6pAV2e;2?|UPsI@^hp>*WaRo2-@#TD%7;vN zxjF%6u^v~d4KXGR4Epd>{5z>p=FyGvWndJ0>y_xA4hfWAMvJ~~t^1E$bv})u6 zrY{m@S$ZYsH3E{Y+6iha9!6%%9JCU9r8X=t8DjghUg3G_v<#(+-h27%ndIizan`-9 zl?0>{1Xqq{o5P6v2L`Ty26P-i#w)y1N_h#|6a9bp2J+x?ttH~c{_0&)?FEO-K9(}Q zf`P^KH%&obWf~a2{C}-n`9IYAzekj{2qWppk|j)K$p}e#+^8FJR5T$-^Jk6E*7`8!y| z>u?`>($HA;+wWW8BGB@kj-M2G1-qMxOEt^I0#L z<}P~)-*Nb?+uoH!t`E3u(68Ct+CIz~Q9&m~@A}*GMsPxvZ1z!blP?uW4doBwl%p}2 zKi@=Uj{TWVH91iWxqY$$7j)Pfg$XA>W|-iYgICw?R9aOdGZn0#>Z0uI@&bYFA6O1< z5EJ7Rs)TSR2I-e0g@YaB;0AkQ!ojnM&9HdMd(H?qOmpKJo@uZkvK zD*h6~wj^hh%93EwaqW~%z{kqSjGU7)^-iKYaqwEP|4C#MltUR?H?3bfL;x1$8Zh@h z(-lhn=}4;YL>@3WZ%!h8c-gszEAdC*o!{!^Zzb(_yRyRF7!$YcRpOVwMf!;2aqM$j z0z1(05Naf35wO4ejZ2g7Z{pRT(<=r}*AK#Mrek;S%NGrpsTZDeYQ!FsYn;#V8lET* zUZ3~)=E7FZX@Uw5f2Te+0ss?2v?71XT#!nsRd5M%KlMMa`)8V{L_56r6J%;&ML~R3akLLi@ZVdPAw@K{n(soot{ljXHT_$Yzw{r zb35RpW>tSuvKVd=+VlOz*4#NhnR;UBK|QW>)er;0!{$ADtvW% zCaQ<}@~8Op%%^M7vk3UAW4EcN4QVW$dVpB}WhFm!rC|5y&P@lMTCr=7$QRJ;R~jBO zb`6CGaxL_CNW$VvS2e4n;}T0w0TXQZ`6$RZY|5F$@#1x(&0Hgz`-%#cHA z?33wird&5pj-h37&y2$6rC209MSxKAb}_5~pvlqEgp`L~BoSJ$rq6a32vs3AFe74n;lUp?5m< z;?@;yHzjmfIq5rD;?qU=`PIiBZKPWLowErDwBZA7z3S-J=Ls-)YK&-zY!*6Mjz{Fb z;~sLRp9q6LYh*4YjKCf21#&PzN_TMRvIpqaVz7r%^gM#c-a2LoER@_LROe|rNs^@_ z-(+2F>;8|@igDzY5o_~%^fyhmR`wpjgHofTqnvxdw;2V8X<-IK31x)zdCNM^<%i@o z^O){zb6F`kX7CD4B>t?MoGjRab#XF83ZkFg{jL^ieTM5}-76=rwV7t6TTA1%QMZ$O zcv^gcUCRpG`Be^6ciAT3wGx{J{=RxQow;-9gc77D6G6&(Wobs^U-P z=)=-XoTFpc+h8s3w-yF2g4*m0H}~I$$Vc{SckCh*4fw`hW;|pZ%^AIjlv~(&^yvgq zF~YeT3H285Ml;0u=!k86xjw}td+jb7fDMrc3bEuS|L+T?9x5uOC$}SxZPPO&mrf{#a377vFUC4rO8Q}Cc>`K@>i>?R?|x!&GIwY(wkjBd({(~U2M zR}5ybqQK;gq>!z+tN&u8>y1@Fw`(OHPOg_$G6_5x1wxNE36ZMBfUN;_0BY!V-PFjI_9@FD53FdjslGQ9!iy(OK z{&#d-7ctZGmNMNI4&PU|J#+ky(DC=)Ky~_Qan4jCIU|`CW zuflDV|2ZrA%G?R3Q_C-p$EfVcUp_hb+ymEqvhU*Ouwq~P^Y#8DY{ivkWD)NfpW{Ux zbJ*g}%@jeRExEThaERd_uH5SN!N$~y8ZZCi;l;@P!f#PrS#Nlbsa=D_Y}YoV53igB z-HNHOu93D6D5`@-NxZkw1NUKr{B!R|JQ*-zouAtiTo;E+zxf@qmQy5(PsQbu?%n8N zB?4dRedylhwGsXz+4z0>M-vL<)|>ixy*F4S-*wvICEv zC7m9t3%tXHPT;^bG)22c(mzW)X@l9WS&6;5wS2TL|MDC-&?TTiiMqx)_7Mk zJbz%Wve5ksQjpAr3aADR6x5i5HMR`!hslF|Hb99VUq8`pwBEBpf`is%&()Mv66h2C zxFSt7prJK(fp9!iW2IiF>3iYn(judH`0E(=gf;Jx;bC2ovb!3`4HoM=>&=oGq6E*W zz5)F(OzP&+gk;gyM$X>kSd;YQosVB^LY$D^QlAl%-t1XZ*Hn=FjBWZcRqsc=IcE*0 zH*4!onkcfu8nc$C>ark$9%8v4w8~t1F}^AC3=X@wkC}gSR@`-Y+f8vqnm)JfhI{&G zCX0#>woe#$!WSB5sjf~E3?WL}hk>DYqbPtYc^V?SE;Hoh1y~Z0I0RUdXGv$v;ZX~& z0}b%7@(PeAO=S z_ZcN2TfYdJWz(WXm8Zw?ov(k9-#>qX@C{j^7XI>+a}O}ae>xMsN&<#eo^J*YjpzKD%`p$iEKYu-7nK0H3$Tu5DFB|VqA=FA5CC%g# zab|p2uOq_^QwUGY=Pm#Itwk^S4SnOy?ov&^Tmb=?rZ1{pUp>lv-AP`R=wTCXB@PZS zZF1mxC~z-#LAdB?u*z&QvbFKcU6ja5ua<%JlYBEQLxMga0j`*9_P z9LR(%xylc16J57#w?MEC;2OROqyBhEZ$P?Zg;bHW1Nvnm3c`e;K$9cnOR??=yiA8Q z*R;0^+<>c{>e>*17Jug>gbAw-IWpQ+HD;_E+PGXhMaf$YD~4ioq|EY8RtqMO*ObN8 zZkRI*p1qqbx-ee{Vyr%y#0W{MAx7qfiRcbmwByB3;p?V$eulDIcpdzt;ES zFx0|;EX)h+#7*?;%&G5-Bjv$EMaGv_$8yweKAo&}pR9@QjJacY{3MIhWz)3owuqNg zO?EDw53l!QGJK_?ZZjWRv~MBuxfB?+yz`LW+Q7<8y}ezfe*DY%NBG0&>Mi5w`n#5g zQEKh*A7;d$^&QBX_=y-J&ktocVD@NPb21m`aWs30$rCG8J1s&@V!%jg$ki3U;nH2T z`JtNmH)u!sht~r62=kj}b>na7tqqb`@m|qiV=C#yHSUdv-0dXxxsTP(`p&KWo{H)? zMm>0u>#QLHX`vZqu{i@9Y_1CL(l~sO-m^pl4p0=c{-J$qtqhOROJcje%+0+cuasg8hfxL>V@$T)k?6qCjRdX)Ca%^04y`KosczqFN&V5HRc--l`IQYk=_*&rvNCR$rfq8ejEt{Y;F6Dm6y z(sS@4?Xq$2wr!&|YF!%Iw?U6>-7ma>HMGO-Gt<~!qf zJoqrW^ zPgtR-UsTiuYDLZP8h~qM07A`qez-(9i6%k_=zVO+8aSn&-)70TtRq8=wkP{Lk<_7M zhCh{SkSBkl>{4LiLu!$93}(r~v!**3F7Tn@3mstoiGfvzMaM-%LI=v0~^e~?uNAG+E9{%owY)_A7nMhc5B!eV`&Q>1u`y)h0jkd4`eeJq%$`xHRay*Ad=aN;Y{O2}m*tKjZ{~dnRcg6|DQ zgg*}rdG!%#rM?9iKQI7QoM}HErr#2o>Ul}(HDCB~nIWC$fNRdE9iVN`3)u?RkCIlw zx#G&$`c|e7?4m+Z-5bS!h=v+XZ@jn-*2LGf8(Qnx&pRy@u<00|XAbSsd;>nvn$UZl ztgyAAb~_|o+2gszRC6b+O;#W;o~61k3-Ze zzYP|G?!zCJ5O}vDGG5N?5uzC1hF#-k?_<8|Cu5T%S~+NGideC4z4bxq3W6Bh!PYO> zLTuHD)0mpxUAbMJFLpwy<(-b7V}k6d^SDn`d!a;h@39Vg(u4`D=MdOPk|s{&v70Gu zMC&*>4ZpX_39cnY*Q7Z<_Zm=>&jYHx)bN3EVMQCP_T21J7q}%OV{-I5e>}0zcpF*X z;@V+v0UjazLku^<5xvg{b}z#wMDr@7KRdoX5M#sJ?AoDLpI8}b|K?v}xOf{r`Us~x zvmCZWro;V|fOK?EDEfhWeX$9le{q<-9H&Aj}JdZg%G#!Y86qa2khzHgUR zgPPaCdr#hZ8Q?vCg~SUz(|!vAN`UZ1i^qo{V1ST)pZ0O(Q2ay$d1GrPWInt1tp0QiRip$0U|qmclf$V zsZS(3bMkUDl!TL!Wq3Q@h4@CJb-NPzK0Vxp!ysijlHqo4{d=8HJlGlA4GR8T2Hwr< zitYnq*-EbQHC8jU5ujX@?YDHGVaK>`o|1dn^jcY)8yRS!_Q&MKsWnx zabmEmbRI5+9O&l)_XVh^Um6N)4)BV}2TYGme4G_k0Ls;cq`k-AHCgw4ULi+fcU&MWysUDQ={12Tv7y$}pJK?{T-lL15b$(T& z;JTihjXBM$l#L%@g#GXXD%SEXHQhZBPIT-wb$q>tK5ZTBB`&`C6 z&;?g1u(-Cv{9l0lmH(Zk(go74E{C$Qf?iyY1o+8m{VZ;v^;Tlg>~k3Nc?B-JlEkhx zXODGua{=^1H?UE-{z6vP&nHZL{^bo&0{8W!vjW9O=s|d||1hv5iE9?#1@i30@v>(C z+@myAbEJ~zxR$NnZ?>;ot|Sh&DS}+d zgvvx)CN@MKSD=aPQ!|Wzh%tzyzd-u!n7@+#UcxS9u{x#R!-5KG#~3 zf>2(V@Vg8kH~4UjP8`ZUxR54loUJ6~!oU4WJWP7p^CNC&nfpNsOD_e%#v5SEMkgtr zTe6u4c#l%Cw%38qD$6^{Rk;ketIQhL*di`Faczh#&7U2!mCREQN(G4ImDTBYN&6bH zWUW%L1wd+K7pP^0r_bww%^&YD|5A>I*D)I}{0PeSP98xUbtI1PJ_m2mh4n3Q&^O?X zRj6&G)pv#dBS|);##RkaaA;<+uJgk1a7R7F~8Dx z(*P#bap`+!isY-{b+?8e)1h-I`l6;1UcVA}$AexuXtH)48MxyF;;-NglPqZ9&|bTX1G1` zu9#ZI_`hS3xf(5aO(8ij(0W1Hp|7!IdyX@An*U+L+yAc9^OCN67UL3APfG=53^_RN x>I_y#;>ElxIur!|coImmO1emTuow6K=K)n(dQ{;Z3W^E*uIOFWeSvhi|6ikT&3XU; literal 0 HcmV?d00001 diff --git a/pics/not-a-tree-en.drawio.png b/pics/not-a-tree-en.drawio.png new file mode 100644 index 0000000000000000000000000000000000000000..d57a5cd66ed023e2f61bf360aecc5d705f3f29de GIT binary patch literal 24251 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 A_W%F@ literal 0 HcmV?d00001 diff --git a/pics/queue-en.drawio.png b/pics/queue-en.drawio.png new file mode 100644 index 0000000000000000000000000000000000000000..f2e4c26d756b9070d3f187dfe73778ea72e041b2 GIT binary patch literal 14060 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�gcAvc8{KE*cGb&OFD2sR)N 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�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 Date: Mon, 29 Apr 2024 15:05:45 +0800 Subject: [PATCH 7/7] Add implementation of Queue as comment. --- course5/course_en.md | 83 +++++++++++++++++++++++++++++++++++++++++++- course5/lec5_en.md | 83 +++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 164 insertions(+), 2 deletions(-) diff --git a/course5/course_en.md b/course5/course_en.md index 87c92f1..4ce8100 100644 --- a/course5/course_en.md +++ b/course5/course_en.md @@ -112,6 +112,87 @@ fn enqueue[T](q: Queue[T], x: T) -> Queue[T] // add element to the tail fn pop[T](q: Queue[T]) -> (Option[T], Queue[T]) ``` + + `empty`: construct an empty queue; `enqueue`: add an element to the queue, i.e., add it to the tail; `pop`: attempt to dequeue an element and return the remaining queue. If the queue is already empty, the returned value will be `None` along with an empty queue. For example, ```moonbit no-check @@ -125,7 +206,7 @@ we've added 1 and 2 to an empty queue. Then, when we try to dequeue an element, Let's return to the implementation of our breadth-first traversal. -```moonbit no-check +```moonbit fn bfs_search(target: Int, queue: Queue[IntTree]) -> Bool { match pop(queue) { (None, _) => false // If the queue is empty, end the search diff --git a/course5/lec5_en.md b/course5/lec5_en.md index ae881c2..a01424c 100644 --- a/course5/lec5_en.md +++ b/course5/lec5_en.md @@ -173,6 +173,87 @@ fn enqueue[T](q: Queue[T], x: T) -> Queue[T] // add element to the tail fn pop[T](q: Queue[T]) -> (Option[T], Queue[T]) ``` + + - For example ```moonbit no-check @@ -186,7 +267,7 @@ assert(tail == enqueue(empty(), 2)) - To find a specific value in a tree's nodes -```moonbit no-check +```moonbit fn bfs_search(target: Int, queue: Queue[IntTree]) -> Bool { match pop(queue) { (None, _) => false // If the queue is empty, end the search