From 6b3ea33db293e471fb87d52e9a06c66a9b92510d Mon Sep 17 00:00:00 2001 From: tianqiyang Date: Tue, 13 Aug 2019 10:49:21 -0400 Subject: [PATCH] add demo of chapter 18 --- learning4e.py | 51 +- notebook4e.py | 1151 +++++++++++++++++ notebooks/chapter18/Datasets.ipynb | 646 +++++++++ notebooks/chapter18/Decision Tree.ipynb | 511 ++++++++ notebooks/chapter18/Ensemble Learning.ipynb | 389 ++++++ .../Linear and Nonparametric Models.ipynb | 435 +++++++ .../chapter18/images/decisiontree_fruit.jpg | Bin 0 -> 45995 bytes .../chapter18/images/ensemble_learner.jpg | Bin 0 -> 16575 bytes notebooks/chapter18/images/knn_plot.png | Bin 0 -> 45256 bytes notebooks/chapter18/images/random_forest.png | Bin 0 -> 190008 bytes utils4e.py | 3 +- 11 files changed, 3177 insertions(+), 9 deletions(-) create mode 100644 notebook4e.py create mode 100644 notebooks/chapter18/Datasets.ipynb create mode 100644 notebooks/chapter18/Decision Tree.ipynb create mode 100644 notebooks/chapter18/Ensemble Learning.ipynb create mode 100644 notebooks/chapter18/Linear and Nonparametric Models.ipynb create mode 100644 notebooks/chapter18/images/decisiontree_fruit.jpg create mode 100644 notebooks/chapter18/images/ensemble_learner.jpg create mode 100644 notebooks/chapter18/images/knn_plot.png create mode 100644 notebooks/chapter18/images/random_forest.png diff --git a/learning4e.py b/learning4e.py index 68a2d5c48..6b1b7140d 100644 --- a/learning4e.py +++ b/learning4e.py @@ -1,6 +1,6 @@ from utils4e import ( removeall, unique, mode, argmax_random_tie, isclose, dotproduct, weighted_sample_with_replacement, - num_or_str, normalize, clip, print_table, open_data, probability, random_weights + num_or_str, normalize, clip, print_table, open_data, probability, random_weights, euclidean_distance ) import copy @@ -382,8 +382,8 @@ def cross_validation(learner, size, dataset, k=10, trials=1): examples = dataset.examples random.shuffle(dataset.examples) for fold in range(k): - train_data, val_data = train_test_split(dataset, fold * (n / k), - (fold + 1) * (n / k)) + train_data, val_data = train_test_split(dataset, fold * (n // k), + (fold + 1) * (n // k)) dataset.examples = train_data h = learner(dataset, size) fold_errs += err_ratio(h, dataset, train_data) @@ -393,6 +393,37 @@ def cross_validation(learner, size, dataset, k=10, trials=1): return fold_errs/k +def cross_validation_nosize(learner, dataset, k=10, trials=1): + """Do k-fold cross_validate and return their mean. + That is, keep out 1/k of the examples for testing on each of k runs. + Shuffle the examples first; if trials>1, average over several shuffles. + Returns Training error, Validataion error""" + k = k or len(dataset.examples) + if trials > 1: + trial_errs = 0 + for t in range(trials): + errs = cross_validation(learner, dataset, + k=10, trials=1) + trial_errs += errs + return trial_errs/trials + else: + fold_errs = 0 + n = len(dataset.examples) + examples = dataset.examples + random.shuffle(dataset.examples) + for fold in range(k): + train_data, val_data = train_test_split(dataset, fold * (n // k), + (fold + 1) * (n // k)) + dataset.examples = train_data + h = learner(dataset) + fold_errs += err_ratio(h, dataset, train_data) + + # Reverting back to original once test is completed + dataset.examples = examples + return fold_errs/k + + + def err_ratio(predict, dataset, examples=None, verbose=0): """Return the proportion of the examples that are NOT correctly predicted. verbose - 0: No output; 1: Output wrong; 2 (or greater): Output correct""" @@ -521,6 +552,8 @@ def LinearLearner(dataset, learning_rate=0.01, epochs=100): for example in examples: x = [1] + example y = dotproduct(w, x) + # if threshold: + # y = threshold(y) t = example[idx_t] err.append(t - y) @@ -554,17 +587,20 @@ def LogisticLinearLeaner(dataset, learning_rate=0.01, epochs=100): for epoch in range(epochs): err = [] + h= [] # Pass over all examples for example in examples: x = [1] + example y = 1/(1 + math.exp(-dotproduct(w, x))) - h = [y * (1-y)] + h.append(y * (1-y)) t = example[idx_t] err.append(t - y) # update weights for i in range(len(w)): - w[i] = w[i] + learning_rate * (dotproduct(dotproduct(err,h), X_col[i]) / num_examples) + buffer = [x*y for x,y in zip(err, h)] + # w[i] = w[i] + learning_rate * (dotproduct(err, X_col[i]) / num_examples) + w[i] = w[i] + learning_rate * (dotproduct(buffer, X_col[i]) / num_examples) def predict(example): x = [1] + example @@ -580,6 +616,7 @@ def NearestNeighborLearner(dataset, k=1): """k-NearestNeighbor: the k nearest neighbors vote.""" def predict(example): """Find the k closest items, and have them vote for the best.""" + example.pop(dataset.target) best = heapq.nsmallest(k, ((dataset.distance(e, example), e) for e in dataset.examples)) return mode(e[dataset.target] for (d, e) in best) @@ -829,6 +866,6 @@ def compare(algorithms=None, datasets=None, k=10, trials=1): Majority(7, 100), Parity(7, 100), Xor(100)] # of datasets print_table([[a.__name__.replace('Learner', '')] + - [cross_validation(a, d, k, trials) for d in datasets] + [cross_validation_nosize(a, d, k, trials) for d in datasets] for a in algorithms], - header=[''] + [d.name[0:7] for d in datasets], numfmt='%.2f') + header=[''] + [d.name[0:7] for d in datasets], numfmt='{0:.2f}') diff --git a/notebook4e.py b/notebook4e.py new file mode 100644 index 000000000..28f562e41 --- /dev/null +++ b/notebook4e.py @@ -0,0 +1,1151 @@ +from inspect import getsource + +from utils import argmax, argmin +from games import TicTacToe, alphabeta_player, random_player, Fig52Extended, infinity +from logic import parse_definite_clause, standardize_variables, unify, subst +from learning import DataSet +from IPython.display import HTML, display +from collections import Counter, defaultdict + +import matplotlib.pyplot as plt +from matplotlib.colors import ListedColormap +import numpy as np +from PIL import Image + +import os, struct +import array +import time + +# ______________________________________________________________________________ +# Magic Words + + +def pseudocode(algorithm): + """Print the pseudocode for the given algorithm.""" + from urllib.request import urlopen + from IPython.display import Markdown + + algorithm = algorithm.replace(' ', '-') + url = "https://raw.githubusercontent.com/aimacode/aima-pseudocode/master/md/{}.md".format(algorithm) + f = urlopen(url) + md = f.read().decode('utf-8') + md = md.split('\n', 1)[-1].strip() + md = '#' + md + return Markdown(md) + + +def psource(*functions): + """Print the source code for the given function(s).""" + source_code = '\n\n'.join(getsource(fn) for fn in functions) + try: + from pygments.formatters import HtmlFormatter + from pygments.lexers import PythonLexer + from pygments import highlight + + display(HTML(highlight(source_code, PythonLexer(), HtmlFormatter(full=True)))) + + except ImportError: + print(source_code) + + +def plot_model_boundary(dataset, attr1, attr2, model=None): + # prepare data + examples = np.asarray(dataset.examples) + X = np.asarray([examples[:, attr1], examples[:, attr2]]) + y = examples[:, dataset.target] + h = 0.1 + + # create color maps + cmap_light = ListedColormap(['#FFAAAA', '#AAFFAA', '#00AAFF']) + cmap_bold = ListedColormap(['#FF0000', '#00FF00', '#00AAFF']) + + # calculate min, max and limits + x_min, x_max = X[0].min() - 1, X[0].max() + 1 + y_min, y_max = X[1].min() - 1, X[1].max() + 1 + # mesh the grid + xx, yy = np.meshgrid(np.arange(x_min, x_max, h), + np.arange(y_min, y_max, h)) + Z = [] + for grid in zip(xx.ravel(), yy.ravel()): + # put them back to the example + grid = np.round(grid, decimals=1).tolist() + Z.append(model(grid)) + # Put the result into a color plot + Z = np.asarray(Z) + Z = Z.reshape(xx.shape) + plt.figure() + plt.pcolormesh(xx, yy, Z, cmap=cmap_light) + + # Plot also the training points + plt.scatter(X[0], X[1], c=y, cmap=cmap_bold) + plt.xlim(xx.min(), xx.max()) + plt.ylim(yy.min(), yy.max()) + plt.show() + +# ______________________________________________________________________________ +# Iris Visualization + + +def show_iris(i=0, j=1, k=2): + """Plots the iris dataset in a 3D plot. + The three axes are given by i, j and k, + which correspond to three of the four iris features.""" + from mpl_toolkits.mplot3d import Axes3D + + plt.rcParams.update(plt.rcParamsDefault) + + fig = plt.figure() + ax = fig.add_subplot(111, projection='3d') + + iris = DataSet(name="iris") + buckets = iris.split_values_by_classes() + + features = ["Sepal Length", "Sepal Width", "Petal Length", "Petal Width"] + f1, f2, f3 = features[i], features[j], features[k] + + a_setosa = [v[i] for v in buckets["setosa"]] + b_setosa = [v[j] for v in buckets["setosa"]] + c_setosa = [v[k] for v in buckets["setosa"]] + + a_virginica = [v[i] for v in buckets["virginica"]] + b_virginica = [v[j] for v in buckets["virginica"]] + c_virginica = [v[k] for v in buckets["virginica"]] + + a_versicolor = [v[i] for v in buckets["versicolor"]] + b_versicolor = [v[j] for v in buckets["versicolor"]] + c_versicolor = [v[k] for v in buckets["versicolor"]] + + + for c, m, sl, sw, pl in [('b', 's', a_setosa, b_setosa, c_setosa), + ('g', '^', a_virginica, b_virginica, c_virginica), + ('r', 'o', a_versicolor, b_versicolor, c_versicolor)]: + ax.scatter(sl, sw, pl, c=c, marker=m) + + ax.set_xlabel(f1) + ax.set_ylabel(f2) + ax.set_zlabel(f3) + + plt.show() + + +# ______________________________________________________________________________ +# MNIST + + +def load_MNIST(path="aima-data/MNIST/Digits", fashion=False): + import os, struct + import array + import numpy as np + from collections import Counter + + if fashion: + path = "aima-data/MNIST/Fashion" + + plt.rcParams.update(plt.rcParamsDefault) + plt.rcParams['figure.figsize'] = (10.0, 8.0) + plt.rcParams['image.interpolation'] = 'nearest' + plt.rcParams['image.cmap'] = 'gray' + + train_img_file = open(os.path.join(path, "train-images-idx3-ubyte"), "rb") + train_lbl_file = open(os.path.join(path, "train-labels-idx1-ubyte"), "rb") + test_img_file = open(os.path.join(path, "t10k-images-idx3-ubyte"), "rb") + test_lbl_file = open(os.path.join(path, 't10k-labels-idx1-ubyte'), "rb") + + magic_nr, tr_size, tr_rows, tr_cols = struct.unpack(">IIII", train_img_file.read(16)) + tr_img = array.array("B", train_img_file.read()) + train_img_file.close() + magic_nr, tr_size = struct.unpack(">II", train_lbl_file.read(8)) + tr_lbl = array.array("b", train_lbl_file.read()) + train_lbl_file.close() + + magic_nr, te_size, te_rows, te_cols = struct.unpack(">IIII", test_img_file.read(16)) + te_img = array.array("B", test_img_file.read()) + test_img_file.close() + magic_nr, te_size = struct.unpack(">II", test_lbl_file.read(8)) + te_lbl = array.array("b", test_lbl_file.read()) + test_lbl_file.close() + + #print(len(tr_img), len(tr_lbl), tr_size) + #print(len(te_img), len(te_lbl), te_size) + + train_img = np.zeros((tr_size, tr_rows*tr_cols), dtype=np.int16) + train_lbl = np.zeros((tr_size,), dtype=np.int8) + for i in range(tr_size): + train_img[i] = np.array(tr_img[i*tr_rows*tr_cols : (i+1)*tr_rows*tr_cols]).reshape((tr_rows*te_cols)) + train_lbl[i] = tr_lbl[i] + + test_img = np.zeros((te_size, te_rows*te_cols), dtype=np.int16) + test_lbl = np.zeros((te_size,), dtype=np.int8) + for i in range(te_size): + test_img[i] = np.array(te_img[i*te_rows*te_cols : (i+1)*te_rows*te_cols]).reshape((te_rows*te_cols)) + test_lbl[i] = te_lbl[i] + + return(train_img, train_lbl, test_img, test_lbl) + + +digit_classes = [str(i) for i in range(10)] +fashion_classes = ["T-shirt/top", "Trouser", "Pullover", "Dress", "Coat", + "Sandal", "Shirt", "Sneaker", "Bag", "Ankle boot"] + + +def show_MNIST(labels, images, samples=8, fashion=False): + if not fashion: + classes = digit_classes + else: + classes = fashion_classes + + num_classes = len(classes) + + for y, cls in enumerate(classes): + idxs = np.nonzero([i == y for i in labels]) + idxs = np.random.choice(idxs[0], samples, replace=False) + for i , idx in enumerate(idxs): + plt_idx = i * num_classes + y + 1 + plt.subplot(samples, num_classes, plt_idx) + plt.imshow(images[idx].reshape((28, 28))) + plt.axis("off") + if i == 0: + plt.title(cls) + + plt.show() + + +def show_ave_MNIST(labels, images, fashion=False): + if not fashion: + item_type = "Digit" + classes = digit_classes + else: + item_type = "Apparel" + classes = fashion_classes + + num_classes = len(classes) + + for y, cls in enumerate(classes): + idxs = np.nonzero([i == y for i in labels]) + print(item_type, y, ":", len(idxs[0]), "images.") + + ave_img = np.mean(np.vstack([images[i] for i in idxs[0]]), axis = 0) + #print(ave_img.shape) + + plt.subplot(1, num_classes, y+1) + plt.imshow(ave_img.reshape((28, 28))) + plt.axis("off") + plt.title(cls) + + plt.show() + +# ______________________________________________________________________________ +# MDP + + +def make_plot_grid_step_function(columns, rows, U_over_time): + """ipywidgets interactive function supports single parameter as input. + This function creates and return such a function by taking as input + other parameters.""" + + def plot_grid_step(iteration): + data = U_over_time[iteration] + data = defaultdict(lambda: 0, data) + grid = [] + for row in range(rows): + current_row = [] + for column in range(columns): + current_row.append(data[(column, row)]) + grid.append(current_row) + grid.reverse() # output like book + fig = plt.imshow(grid, cmap=plt.cm.bwr, interpolation='nearest') + + plt.axis('off') + fig.axes.get_xaxis().set_visible(False) + fig.axes.get_yaxis().set_visible(False) + + for col in range(len(grid)): + for row in range(len(grid[0])): + magic = grid[col][row] + fig.axes.text(row, col, "{0:.2f}".format(magic), va='center', ha='center') + + plt.show() + + return plot_grid_step + +def make_visualize(slider): + """Takes an input a sliderand returns callback function + for timer and animation.""" + + def visualize_callback(Visualize, time_step): + if Visualize is True: + for i in range(slider.min, slider.max + 1): + slider.value = i + time.sleep(float(time_step)) + + return visualize_callback + +# ______________________________________________________________________________ + + +_canvas = """ + +
+ +
+ + +""" # noqa + + +class Canvas: + """Inherit from this class to manage the HTML canvas element in jupyter notebooks. + To create an object of this class any_name_xyz = Canvas("any_name_xyz") + The first argument given must be the name of the object being created. + IPython must be able to reference the variable name that is being passed.""" + + def __init__(self, varname, width=800, height=600, cid=None): + self.name = varname + self.cid = cid or varname + self.width = width + self.height = height + self.html = _canvas.format(self.cid, self.width, self.height, self.name) + self.exec_list = [] + display_html(self.html) + + def mouse_click(self, x, y): + """Override this method to handle mouse click at position (x, y)""" + raise NotImplementedError + + def mouse_move(self, x, y): + raise NotImplementedError + + def execute(self, exec_str): + """Stores the command to be executed to a list which is used later during update()""" + if not isinstance(exec_str, str): + print("Invalid execution argument:", exec_str) + self.alert("Received invalid execution command format") + prefix = "{0}_canvas_object.".format(self.cid) + self.exec_list.append(prefix + exec_str + ';') + + def fill(self, r, g, b): + """Changes the fill color to a color in rgb format""" + self.execute("fill({0}, {1}, {2})".format(r, g, b)) + + def stroke(self, r, g, b): + """Changes the colors of line/strokes to rgb""" + self.execute("stroke({0}, {1}, {2})".format(r, g, b)) + + def strokeWidth(self, w): + """Changes the width of lines/strokes to 'w' pixels""" + self.execute("strokeWidth({0})".format(w)) + + def rect(self, x, y, w, h): + """Draw a rectangle with 'w' width, 'h' height and (x, y) as the top-left corner""" + self.execute("rect({0}, {1}, {2}, {3})".format(x, y, w, h)) + + def rect_n(self, xn, yn, wn, hn): + """Similar to rect(), but the dimensions are normalized to fall between 0 and 1""" + x = round(xn * self.width) + y = round(yn * self.height) + w = round(wn * self.width) + h = round(hn * self.height) + self.rect(x, y, w, h) + + def line(self, x1, y1, x2, y2): + """Draw a line from (x1, y1) to (x2, y2)""" + self.execute("line({0}, {1}, {2}, {3})".format(x1, y1, x2, y2)) + + def line_n(self, x1n, y1n, x2n, y2n): + """Similar to line(), but the dimensions are normalized to fall between 0 and 1""" + x1 = round(x1n * self.width) + y1 = round(y1n * self.height) + x2 = round(x2n * self.width) + y2 = round(y2n * self.height) + self.line(x1, y1, x2, y2) + + def arc(self, x, y, r, start, stop): + """Draw an arc with (x, y) as centre, 'r' as radius from angles 'start' to 'stop'""" + self.execute("arc({0}, {1}, {2}, {3}, {4})".format(x, y, r, start, stop)) + + def arc_n(self, xn, yn, rn, start, stop): + """Similar to arc(), but the dimensions are normalized to fall between 0 and 1 + The normalizing factor for radius is selected between width and height by + seeing which is smaller.""" + x = round(xn * self.width) + y = round(yn * self.height) + r = round(rn * min(self.width, self.height)) + self.arc(x, y, r, start, stop) + + def clear(self): + """Clear the HTML canvas""" + self.execute("clear()") + + def font(self, font): + """Changes the font of text""" + self.execute('font("{0}")'.format(font)) + + def text(self, txt, x, y, fill=True): + """Display a text at (x, y)""" + if fill: + self.execute('fill_text("{0}", {1}, {2})'.format(txt, x, y)) + else: + self.execute('stroke_text("{0}", {1}, {2})'.format(txt, x, y)) + + def text_n(self, txt, xn, yn, fill=True): + """Similar to text(), but with normalized coordinates""" + x = round(xn * self.width) + y = round(yn * self.height) + self.text(txt, x, y, fill) + + def alert(self, message): + """Immediately display an alert""" + display_html(''.format(message)) + + def update(self): + """Execute the JS code to execute the commands queued by execute()""" + exec_code = "" + self.exec_list = [] + display_html(exec_code) + + +def display_html(html_string): + display(HTML(html_string)) + + +################################################################################ + + +class Canvas_TicTacToe(Canvas): + """Play a 3x3 TicTacToe game on HTML canvas""" + def __init__(self, varname, player_1='human', player_2='random', + width=300, height=350, cid=None): + valid_players = ('human', 'random', 'alphabeta') + if player_1 not in valid_players or player_2 not in valid_players: + raise TypeError("Players must be one of {}".format(valid_players)) + Canvas.__init__(self, varname, width, height, cid) + self.ttt = TicTacToe() + self.state = self.ttt.initial + self.turn = 0 + self.strokeWidth(5) + self.players = (player_1, player_2) + self.font("20px Arial") + self.draw_board() + + def mouse_click(self, x, y): + player = self.players[self.turn] + if self.ttt.terminal_test(self.state): + if 0.55 <= x/self.width <= 0.95 and 6/7 <= y/self.height <= 6/7+1/8: + self.state = self.ttt.initial + self.turn = 0 + self.draw_board() + return + + if player == 'human': + x, y = int(3*x/self.width) + 1, int(3*y/(self.height*6/7)) + 1 + if (x, y) not in self.ttt.actions(self.state): + # Invalid move + return + move = (x, y) + elif player == 'alphabeta': + move = alphabeta_player(self.ttt, self.state) + else: + move = random_player(self.ttt, self.state) + self.state = self.ttt.result(self.state, move) + self.turn ^= 1 + self.draw_board() + + def draw_board(self): + self.clear() + self.stroke(0, 0, 0) + offset = 1/20 + self.line_n(0 + offset, (1/3)*6/7, 1 - offset, (1/3)*6/7) + self.line_n(0 + offset, (2/3)*6/7, 1 - offset, (2/3)*6/7) + self.line_n(1/3, (0 + offset)*6/7, 1/3, (1 - offset)*6/7) + self.line_n(2/3, (0 + offset)*6/7, 2/3, (1 - offset)*6/7) + + board = self.state.board + for mark in board: + if board[mark] == 'X': + self.draw_x(mark) + elif board[mark] == 'O': + self.draw_o(mark) + if self.ttt.terminal_test(self.state): + # End game message + utility = self.ttt.utility(self.state, self.ttt.to_move(self.ttt.initial)) + if utility == 0: + self.text_n('Game Draw!', offset, 6/7 + offset) + else: + self.text_n('Player {} wins!'.format("XO"[utility < 0]), offset, 6/7 + offset) + # Find the 3 and draw a line + self.stroke([255, 0][self.turn], [0, 255][self.turn], 0) + for i in range(3): + if all([(i + 1, j + 1) in self.state.board for j in range(3)]) and \ + len({self.state.board[(i + 1, j + 1)] for j in range(3)}) == 1: + self.line_n(i/3 + 1/6, offset*6/7, i/3 + 1/6, (1 - offset)*6/7) + if all([(j + 1, i + 1) in self.state.board for j in range(3)]) and \ + len({self.state.board[(j + 1, i + 1)] for j in range(3)}) == 1: + self.line_n(offset, (i/3 + 1/6)*6/7, 1 - offset, (i/3 + 1/6)*6/7) + if all([(i + 1, i + 1) in self.state.board for i in range(3)]) and \ + len({self.state.board[(i + 1, i + 1)] for i in range(3)}) == 1: + self.line_n(offset, offset*6/7, 1 - offset, (1 - offset)*6/7) + if all([(i + 1, 3 - i) in self.state.board for i in range(3)]) and \ + len({self.state.board[(i + 1, 3 - i)] for i in range(3)}) == 1: + self.line_n(offset, (1 - offset)*6/7, 1 - offset, offset*6/7) + # restart button + self.fill(0, 0, 255) + self.rect_n(0.5 + offset, 6/7, 0.4, 1/8) + self.fill(0, 0, 0) + self.text_n('Restart', 0.5 + 2*offset, 13/14) + else: # Print which player's turn it is + self.text_n("Player {}'s move({})".format("XO"[self.turn], self.players[self.turn]), + offset, 6/7 + offset) + + self.update() + + def draw_x(self, position): + self.stroke(0, 255, 0) + x, y = [i-1 for i in position] + offset = 1/15 + self.line_n(x/3 + offset, (y/3 + offset)*6/7, x/3 + 1/3 - offset, (y/3 + 1/3 - offset)*6/7) + self.line_n(x/3 + 1/3 - offset, (y/3 + offset)*6/7, x/3 + offset, (y/3 + 1/3 - offset)*6/7) + + def draw_o(self, position): + self.stroke(255, 0, 0) + x, y = [i-1 for i in position] + self.arc_n(x/3 + 1/6, (y/3 + 1/6)*6/7, 1/9, 0, 360) + + +class Canvas_minimax(Canvas): + """Minimax for Fig52Extended on HTML canvas""" + def __init__(self, varname, util_list, width=800, height=600, cid=None): + Canvas.__init__(self, varname, width, height, cid) + self.utils = {node:util for node, util in zip(range(13, 40), util_list)} + self.game = Fig52Extended() + self.game.utils = self.utils + self.nodes = list(range(40)) + self.l = 1/40 + self.node_pos = {} + for i in range(4): + base = len(self.node_pos) + row_size = 3**i + for node in [base + j for j in range(row_size)]: + self.node_pos[node] = ((node - base)/row_size + 1/(2*row_size) - self.l/2, + self.l/2 + (self.l + (1 - 5*self.l)/3)*i) + self.font("12px Arial") + self.node_stack = [] + self.explored = {node for node in self.utils} + self.thick_lines = set() + self.change_list = [] + self.draw_graph() + self.stack_manager = self.stack_manager_gen() + + def minimax(self, node): + game = self.game + player = game.to_move(node) + def max_value(node): + if game.terminal_test(node): + return game.utility(node, player) + self.change_list.append(('a', node)) + self.change_list.append(('h',)) + max_a = argmax(game.actions(node), key=lambda x: min_value(game.result(node, x))) + max_node = game.result(node, max_a) + self.utils[node] = self.utils[max_node] + x1, y1 = self.node_pos[node] + x2, y2 = self.node_pos[max_node] + self.change_list.append(('l', (node, max_node - 3*node - 1))) + self.change_list.append(('e', node)) + self.change_list.append(('p',)) + self.change_list.append(('h',)) + return self.utils[node] + + def min_value(node): + if game.terminal_test(node): + return game.utility(node, player) + self.change_list.append(('a', node)) + self.change_list.append(('h',)) + min_a = argmin(game.actions(node), key=lambda x: max_value(game.result(node, x))) + min_node = game.result(node, min_a) + self.utils[node] = self.utils[min_node] + x1, y1 = self.node_pos[node] + x2, y2 = self.node_pos[min_node] + self.change_list.append(('l', (node, min_node - 3*node - 1))) + self.change_list.append(('e', node)) + self.change_list.append(('p',)) + self.change_list.append(('h',)) + return self.utils[node] + + return max_value(node) + + def stack_manager_gen(self): + self.minimax(0) + for change in self.change_list: + if change[0] == 'a': + self.node_stack.append(change[1]) + elif change[0] == 'e': + self.explored.add(change[1]) + elif change[0] == 'h': + yield + elif change[0] == 'l': + self.thick_lines.add(change[1]) + elif change[0] == 'p': + self.node_stack.pop() + + def mouse_click(self, x, y): + try: + self.stack_manager.send(None) + except StopIteration: + pass + self.draw_graph() + + def draw_graph(self): + self.clear() + # draw nodes + self.stroke(0, 0, 0) + self.strokeWidth(1) + # highlight for nodes in stack + for node in self.node_stack: + x, y = self.node_pos[node] + self.fill(200, 200, 0) + self.rect_n(x - self.l/5, y - self.l/5, self.l*7/5, self.l*7/5) + for node in self.nodes: + x, y = self.node_pos[node] + if node in self.explored: + self.fill(255, 255, 255) + else: + self.fill(200, 200, 200) + self.rect_n(x, y, self.l, self.l) + self.line_n(x, y, x + self.l, y) + self.line_n(x, y, x, y + self.l) + self.line_n(x + self.l, y + self.l, x + self.l, y) + self.line_n(x + self.l, y + self.l, x, y + self.l) + self.fill(0, 0, 0) + if node in self.explored: + self.text_n(self.utils[node], x + self.l/10, y + self.l*9/10) + # draw edges + for i in range(13): + x1, y1 = self.node_pos[i][0] + self.l/2, self.node_pos[i][1] + self.l + for j in range(3): + x2, y2 = self.node_pos[i*3 + j + 1][0] + self.l/2, self.node_pos[i*3 + j + 1][1] + if i in [1, 2, 3]: + self.stroke(200, 0, 0) + else: + self.stroke(0, 200, 0) + if (i, j) in self.thick_lines: + self.strokeWidth(3) + else: + self.strokeWidth(1) + self.line_n(x1, y1, x2, y2) + self.update() + + +class Canvas_alphabeta(Canvas): + """Alpha-beta pruning for Fig52Extended on HTML canvas""" + def __init__(self, varname, util_list, width=800, height=600, cid=None): + Canvas.__init__(self, varname, width, height, cid) + self.utils = {node:util for node, util in zip(range(13, 40), util_list)} + self.game = Fig52Extended() + self.game.utils = self.utils + self.nodes = list(range(40)) + self.l = 1/40 + self.node_pos = {} + for i in range(4): + base = len(self.node_pos) + row_size = 3**i + for node in [base + j for j in range(row_size)]: + self.node_pos[node] = ((node - base)/row_size + 1/(2*row_size) - self.l/2, + 3*self.l/2 + (self.l + (1 - 6*self.l)/3)*i) + self.font("12px Arial") + self.node_stack = [] + self.explored = {node for node in self.utils} + self.pruned = set() + self.ab = {} + self.thick_lines = set() + self.change_list = [] + self.draw_graph() + self.stack_manager = self.stack_manager_gen() + + def alphabeta_search(self, node): + game = self.game + player = game.to_move(node) + + # Functions used by alphabeta + def max_value(node, alpha, beta): + if game.terminal_test(node): + self.change_list.append(('a', node)) + self.change_list.append(('h',)) + self.change_list.append(('p',)) + return game.utility(node, player) + v = -infinity + self.change_list.append(('a', node)) + self.change_list.append(('ab',node, v, beta)) + self.change_list.append(('h',)) + for a in game.actions(node): + min_val = min_value(game.result(node, a), alpha, beta) + if v < min_val: + v = min_val + max_node = game.result(node, a) + self.change_list.append(('ab',node, v, beta)) + if v >= beta: + self.change_list.append(('h',)) + self.pruned.add(node) + break + alpha = max(alpha, v) + self.utils[node] = v + if node not in self.pruned: + self.change_list.append(('l', (node, max_node - 3*node - 1))) + self.change_list.append(('e',node)) + self.change_list.append(('p',)) + self.change_list.append(('h',)) + return v + + def min_value(node, alpha, beta): + if game.terminal_test(node): + self.change_list.append(('a', node)) + self.change_list.append(('h',)) + self.change_list.append(('p',)) + return game.utility(node, player) + v = infinity + self.change_list.append(('a', node)) + self.change_list.append(('ab',node, alpha, v)) + self.change_list.append(('h',)) + for a in game.actions(node): + max_val = max_value(game.result(node, a), alpha, beta) + if v > max_val: + v = max_val + min_node = game.result(node, a) + self.change_list.append(('ab',node, alpha, v)) + if v <= alpha: + self.change_list.append(('h',)) + self.pruned.add(node) + break + beta = min(beta, v) + self.utils[node] = v + if node not in self.pruned: + self.change_list.append(('l', (node, min_node - 3*node - 1))) + self.change_list.append(('e',node)) + self.change_list.append(('p',)) + self.change_list.append(('h',)) + return v + + return max_value(node, -infinity, infinity) + + def stack_manager_gen(self): + self.alphabeta_search(0) + for change in self.change_list: + if change[0] == 'a': + self.node_stack.append(change[1]) + elif change[0] == 'ab': + self.ab[change[1]] = change[2:] + elif change[0] == 'e': + self.explored.add(change[1]) + elif change[0] == 'h': + yield + elif change[0] == 'l': + self.thick_lines.add(change[1]) + elif change[0] == 'p': + self.node_stack.pop() + + def mouse_click(self, x, y): + try: + self.stack_manager.send(None) + except StopIteration: + pass + self.draw_graph() + + def draw_graph(self): + self.clear() + # draw nodes + self.stroke(0, 0, 0) + self.strokeWidth(1) + # highlight for nodes in stack + for node in self.node_stack: + x, y = self.node_pos[node] + # alpha > beta + if node not in self.explored and self.ab[node][0] > self.ab[node][1]: + self.fill(200, 100, 100) + else: + self.fill(200, 200, 0) + self.rect_n(x - self.l/5, y - self.l/5, self.l*7/5, self.l*7/5) + for node in self.nodes: + x, y = self.node_pos[node] + if node in self.explored: + if node in self.pruned: + self.fill(50, 50, 50) + else: + self.fill(255, 255, 255) + else: + self.fill(200, 200, 200) + self.rect_n(x, y, self.l, self.l) + self.line_n(x, y, x + self.l, y) + self.line_n(x, y, x, y + self.l) + self.line_n(x + self.l, y + self.l, x + self.l, y) + self.line_n(x + self.l, y + self.l, x, y + self.l) + self.fill(0, 0, 0) + if node in self.explored and node not in self.pruned: + self.text_n(self.utils[node], x + self.l/10, y + self.l*9/10) + # draw edges + for i in range(13): + x1, y1 = self.node_pos[i][0] + self.l/2, self.node_pos[i][1] + self.l + for j in range(3): + x2, y2 = self.node_pos[i*3 + j + 1][0] + self.l/2, self.node_pos[i*3 + j + 1][1] + if i in [1, 2, 3]: + self.stroke(200, 0, 0) + else: + self.stroke(0, 200, 0) + if (i, j) in self.thick_lines: + self.strokeWidth(3) + else: + self.strokeWidth(1) + self.line_n(x1, y1, x2, y2) + # display alpha and beta + for node in self.node_stack: + if node not in self.explored: + x, y = self.node_pos[node] + alpha, beta = self.ab[node] + self.text_n(alpha, x - self.l/2, y - self.l/10) + self.text_n(beta, x + self.l, y - self.l/10) + self.update() + + +class Canvas_fol_bc_ask(Canvas): + """fol_bc_ask() on HTML canvas""" + def __init__(self, varname, kb, query, width=800, height=600, cid=None): + Canvas.__init__(self, varname, width, height, cid) + self.kb = kb + self.query = query + self.l = 1/20 + self.b = 3*self.l + bc_out = list(self.fol_bc_ask()) + if len(bc_out) is 0: + self.valid = False + else: + self.valid = True + graph = bc_out[0][0][0] + s = bc_out[0][1] + while True: + new_graph = subst(s, graph) + if graph == new_graph: + break + graph = new_graph + self.make_table(graph) + self.context = None + self.draw_table() + + def fol_bc_ask(self): + KB = self.kb + query = self.query + def fol_bc_or(KB, goal, theta): + for rule in KB.fetch_rules_for_goal(goal): + lhs, rhs = parse_definite_clause(standardize_variables(rule)) + for theta1 in fol_bc_and(KB, lhs, unify(rhs, goal, theta)): + yield ([(goal, theta1[0])], theta1[1]) + + def fol_bc_and(KB, goals, theta): + if theta is None: + pass + elif not goals: + yield ([], theta) + else: + first, rest = goals[0], goals[1:] + for theta1 in fol_bc_or(KB, subst(theta, first), theta): + for theta2 in fol_bc_and(KB, rest, theta1[1]): + yield (theta1[0] + theta2[0], theta2[1]) + + return fol_bc_or(KB, query, {}) + + def make_table(self, graph): + table = [] + pos = {} + links = set() + edges = set() + + def dfs(node, depth): + if len(table) <= depth: + table.append([]) + pos = len(table[depth]) + table[depth].append(node[0]) + for child in node[1]: + child_id = dfs(child, depth + 1) + links.add(((depth, pos), child_id)) + return (depth, pos) + + dfs(graph, 0) + y_off = 0.85/len(table) + for i, row in enumerate(table): + x_off = 0.95/len(row) + for j, node in enumerate(row): + pos[(i, j)] = (0.025 + j*x_off + (x_off - self.b)/2, 0.025 + i*y_off + (y_off - self.l)/2) + for p, c in links: + x1, y1 = pos[p] + x2, y2 = pos[c] + edges.add((x1 + self.b/2, y1 + self.l, x2 + self.b/2, y2)) + + self.table = table + self.pos = pos + self.edges = edges + + def mouse_click(self, x, y): + x, y = x/self.width, y/self.height + for node in self.pos: + xs, ys = self.pos[node] + xe, ye = xs + self.b, ys + self.l + if xs <= x <= xe and ys <= y <= ye: + self.context = node + break + self.draw_table() + + def draw_table(self): + self.clear() + self.strokeWidth(3) + self.stroke(0, 0, 0) + self.font("12px Arial") + if self.valid: + # draw nodes + for i, j in self.pos: + x, y = self.pos[(i, j)] + self.fill(200, 200, 200) + self.rect_n(x, y, self.b, self.l) + self.line_n(x, y, x + self.b, y) + self.line_n(x, y, x, y + self.l) + self.line_n(x + self.b, y, x + self.b, y + self.l) + self.line_n(x, y + self.l, x + self.b, y + self.l) + self.fill(0, 0, 0) + self.text_n(self.table[i][j], x + 0.01, y + self.l - 0.01) + #draw edges + for x1, y1, x2, y2 in self.edges: + self.line_n(x1, y1, x2, y2) + else: + self.fill(255, 0, 0) + self.rect_n(0, 0, 1, 1) + # text area + self.fill(255, 255, 255) + self.rect_n(0, 0.9, 1, 0.1) + self.strokeWidth(5) + self.stroke(0, 0, 0) + self.line_n(0, 0.9, 1, 0.9) + self.font("22px Arial") + self.fill(0, 0, 0) + self.text_n(self.table[self.context[0]][self.context[1]] if self.context else "Click for text", 0.025, 0.975) + self.update() + + +############################################################################################################ + +##################### Functions to assist plotting in search.ipynb #################### + +############################################################################################################ +import networkx as nx +import matplotlib.pyplot as plt +from matplotlib import lines + +from ipywidgets import interact +import ipywidgets as widgets +from IPython.display import display +import time +from search import GraphProblem, romania_map + +def show_map(graph_data, node_colors = None): + G = nx.Graph(graph_data['graph_dict']) + node_colors = node_colors or graph_data['node_colors'] + node_positions = graph_data['node_positions'] + node_label_pos = graph_data['node_label_positions'] + edge_weights= graph_data['edge_weights'] + + # set the size of the plot + plt.figure(figsize=(18,13)) + # draw the graph (both nodes and edges) with locations from romania_locations + nx.draw(G, pos={k: node_positions[k] for k in G.nodes()}, + node_color=[node_colors[node] for node in G.nodes()], linewidths=0.3, edgecolors='k') + + # draw labels for nodes + node_label_handles = nx.draw_networkx_labels(G, pos=node_label_pos, font_size=14) + + # add a white bounding box behind the node labels + [label.set_bbox(dict(facecolor='white', edgecolor='none')) for label in node_label_handles.values()] + + # add edge lables to the graph + nx.draw_networkx_edge_labels(G, pos=node_positions, edge_labels=edge_weights, font_size=14) + + # add a legend + white_circle = lines.Line2D([], [], color="white", marker='o', markersize=15, markerfacecolor="white") + orange_circle = lines.Line2D([], [], color="orange", marker='o', markersize=15, markerfacecolor="orange") + red_circle = lines.Line2D([], [], color="red", marker='o', markersize=15, markerfacecolor="red") + gray_circle = lines.Line2D([], [], color="gray", marker='o', markersize=15, markerfacecolor="gray") + green_circle = lines.Line2D([], [], color="green", marker='o', markersize=15, markerfacecolor="green") + plt.legend((white_circle, orange_circle, red_circle, gray_circle, green_circle), + ('Un-explored', 'Frontier', 'Currently Exploring', 'Explored', 'Final Solution'), + numpoints=1, prop={'size':16}, loc=(.8,.75)) + + # show the plot. No need to use in notebooks. nx.draw will show the graph itself. + plt.show() + +## helper functions for visualisations + +def final_path_colors(initial_node_colors, problem, solution): + "Return a node_colors dict of the final path provided the problem and solution." + + # get initial node colors + final_colors = dict(initial_node_colors) + # color all the nodes in solution and starting node to green + final_colors[problem.initial] = "green" + for node in solution: + final_colors[node] = "green" + return final_colors + +def display_visual(graph_data, user_input, algorithm=None, problem=None): + initial_node_colors = graph_data['node_colors'] + if user_input == False: + def slider_callback(iteration): + # don't show graph for the first time running the cell calling this function + try: + show_map(graph_data, node_colors=all_node_colors[iteration]) + except: + pass + def visualize_callback(Visualize): + if Visualize is True: + button.value = False + + global all_node_colors + + iterations, all_node_colors, node = algorithm(problem) + solution = node.solution() + all_node_colors.append(final_path_colors(all_node_colors[0], problem, solution)) + + slider.max = len(all_node_colors) - 1 + + for i in range(slider.max + 1): + slider.value = i + #time.sleep(.5) + + slider = widgets.IntSlider(min=0, max=1, step=1, value=0) + slider_visual = widgets.interactive(slider_callback, iteration=slider) + display(slider_visual) + + button = widgets.ToggleButton(value=False) + button_visual = widgets.interactive(visualize_callback, Visualize=button) + display(button_visual) + + if user_input == True: + node_colors = dict(initial_node_colors) + if isinstance(algorithm, dict): + assert set(algorithm.keys()).issubset({"Breadth First Tree Search", + "Depth First Tree Search", + "Breadth First Search", + "Depth First Graph Search", + "Best First Graph Search", + "Uniform Cost Search", + "Depth Limited Search", + "Iterative Deepening Search", + "Greedy Best First Search", + "A-star Search", + "Recursive Best First Search"}) + + algo_dropdown = widgets.Dropdown(description="Search algorithm: ", + options=sorted(list(algorithm.keys())), + value="Breadth First Tree Search") + display(algo_dropdown) + elif algorithm is None: + print("No algorithm to run.") + return 0 + + def slider_callback(iteration): + # don't show graph for the first time running the cell calling this function + try: + show_map(graph_data, node_colors=all_node_colors[iteration]) + except: + pass + + def visualize_callback(Visualize): + if Visualize is True: + button.value = False + + problem = GraphProblem(start_dropdown.value, end_dropdown.value, romania_map) + global all_node_colors + + user_algorithm = algorithm[algo_dropdown.value] + + iterations, all_node_colors, node = user_algorithm(problem) + solution = node.solution() + all_node_colors.append(final_path_colors(all_node_colors[0], problem, solution)) + + slider.max = len(all_node_colors) - 1 + + for i in range(slider.max + 1): + slider.value = i + #time.sleep(.5) + + start_dropdown = widgets.Dropdown(description="Start city: ", + options=sorted(list(node_colors.keys())), value="Arad") + display(start_dropdown) + + end_dropdown = widgets.Dropdown(description="Goal city: ", + options=sorted(list(node_colors.keys())), value="Fagaras") + display(end_dropdown) + + button = widgets.ToggleButton(value=False) + button_visual = widgets.interactive(visualize_callback, Visualize=button) + display(button_visual) + + slider = widgets.IntSlider(min=0, max=1, step=1, value=0) + slider_visual = widgets.interactive(slider_callback, iteration=slider) + display(slider_visual) + + +# Function to plot NQueensCSP in csp.py and NQueensProblem in search.py +def plot_NQueens(solution): + n = len(solution) + board = np.array([2 * int((i + j) % 2) for j in range(n) for i in range(n)]).reshape((n, n)) + im = Image.open('images/queen_s.png') + height = im.size[1] + im = np.array(im).astype(np.float) / 255 + fig = plt.figure(figsize=(7, 7)) + ax = fig.add_subplot(111) + ax.set_title('{} Queens'.format(n)) + plt.imshow(board, cmap='binary', interpolation='nearest') + # NQueensCSP gives a solution as a dictionary + if isinstance(solution, dict): + for (k, v) in solution.items(): + newax = fig.add_axes([0.064 + (k * 0.112), 0.062 + ((7 - v) * 0.112), 0.1, 0.1], zorder=1) + newax.imshow(im) + newax.axis('off') + # NQueensProblem gives a solution as a list + elif isinstance(solution, list): + for (k, v) in enumerate(solution): + newax = fig.add_axes([0.064 + (k * 0.112), 0.062 + ((7 - v) * 0.112), 0.1, 0.1], zorder=1) + newax.imshow(im) + newax.axis('off') + fig.tight_layout() + plt.show() + +# Function to plot a heatmap, given a grid +def heatmap(grid, cmap='binary', interpolation='nearest'): + fig = plt.figure(figsize=(7, 7)) + ax = fig.add_subplot(111) + ax.set_title('Heatmap') + plt.imshow(grid, cmap=cmap, interpolation=interpolation) + fig.tight_layout() + plt.show() + +# Generates a gaussian kernel +def gaussian_kernel(l=5, sig=1.0): + ax = np.arange(-l // 2 + 1., l // 2 + 1.) + xx, yy = np.meshgrid(ax, ax) + kernel = np.exp(-(xx**2 + yy**2) / (2. * sig**2)) + return kernel + +# Plots utility function for a POMDP +def plot_pomdp_utility(utility): + save = utility['0'][0] + delete = utility['1'][0] + ask_save = utility['2'][0] + ask_delete = utility['2'][-1] + left = (save[0] - ask_save[0]) / (save[0] - ask_save[0] + ask_save[1] - save[1]) + right = (delete[0] - ask_delete[0]) / (delete[0] - ask_delete[0] + ask_delete[1] - delete[1]) + + colors = ['g', 'b', 'k'] + for action in utility: + for value in utility[action]: + plt.plot(value, color=colors[int(action)]) + plt.vlines([left, right], -20, 10, linestyles='dashed', colors='c') + plt.ylim(-20, 13) + plt.xlim(0, 1) + plt.text(left/2 - 0.05, 10, 'Save') + plt.text((right + left)/2 - 0.02, 10, 'Ask') + plt.text((right + 1)/2 - 0.07, 10, 'Delete') + plt.show() diff --git a/notebooks/chapter18/Datasets.ipynb b/notebooks/chapter18/Datasets.ipynb new file mode 100644 index 000000000..9a48debcd --- /dev/null +++ b/notebooks/chapter18/Datasets.ipynb @@ -0,0 +1,646 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DATASETS" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following tutorial is a demonstration of the `DataSet` data structure which is frequently used in the following sections. `DataSet` plays the role of organizing data in different forms to make them able to be used by machine learning algorithms. Here we make the following datasets as examples:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Fisher's Iris: Each item represents a flower, with four measurements: the length and the width of the sepals and petals. Each item/flower is categorized into one of three species: Setosa, Versicolor and Virginica.\n", + "\n", + "- Zoo: The dataset holds different animals and their classification as \"mammal\", \"fish\", etc. The new animal we want to classify has the following measurements: 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 0, 1 (don't concern yourself with what the measurements mean).\n", + "\n", + "- Restaurant: The restaurant example in Fig XX of the book. Each item in the dataset represents a condition of customers to make decisions. The target class of each item can be \"yes\" or \"no\", meaning whether to dine in this restaurant.\n", + "\n", + "- Orings: The dataset holds different conditions of the night before each launch of the space shuttle. It is to predict the number of O-rings that will experience thermal distress for a given flight when the launch temperature is below freezing. The target class can be 0,1 or 2 meaning the number of oring failures." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To make use the datasets easier, we have written a class, DataSet, in learning.py. The tutorials found here make use of this class. Now let's have a look at how it works." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Intro" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A lot of the datasets we will work with are .csv files (although other formats are supported too). We have a collection of sample datasets ready to use on [aima-data](https://github.com/aimacode/aima-data/tree/a21fc108f52ad551344e947b0eb97df82f8d2b2b). Four examples are the datasets mentioned above (iris.csv, zoo.csv, orings.csv, and restaurant.csv). You can find plenty of datasets online, and a good repository of such datasets is [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/datasets.php)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In such files, each line corresponds to one item/measurement. Each individual value in a line represents a feature and usually there is a value denoting the class of the item." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can find the code for the dataset in `learning4e.py` or use the following code:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%psource DataSet" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Importing a Dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are multiple ways to import a dataset from the `learning4e` module. But first the necessary modules need to be imported:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "sys.path = [os.path.abspath(\"../../\")] + sys.path\n", + "from learning4e import *\n", + "from notebook4e import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Importing from aima-data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Dataset uploaded to aima-data can be imported as the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "iris = DataSet(name=\"iris\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To check that we imported the correct dataset, we can do the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[5.1, 3.5, 1.4, 0.2, 'setosa']\n", + "[0, 1, 2, 3]\n" + ] + } + ], + "source": [ + "print(iris.examples[0])\n", + "print(iris.inputs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Which correctly prints the first line in the csv file and the list of attribute indexes.\n", + "\n", + "When importing a dataset, we can specify to exclude an attribute (for example, at index 1) by setting the parameter exclude to the attribute index or name" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 2, 3]\n" + ] + } + ], + "source": [ + "iris2 = DataSet(name=\"iris\",exclude=[1])\n", + "print(iris2.inputs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Constructing your own dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to use self-defined datasets, you need to prepare the csv files for the datasets in the following format of the [iris example](https://github.com/aimacode/aima-data/blob/a21fc108f52ad551344e947b0eb97df82f8d2b2b/iris.csv). Then you can create your own dataset by specifying the correct dataset name, attributes, targets and exclusive attributes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here is how we create restaurant dataset in Figure 18.3 from restaurant.csv:" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "def RestaurantDataSet(examples=None):\n", + " \"\"\"Build a DataSet of Restaurant waiting examples. [Figure 18.3]\"\"\"\n", + " return DataSet(name='restaurant', target='Wait', examples=examples,\n", + " attrnames='Alternate Bar Fri/Sat Hungry Patrons Price ' +\n", + " 'Raining Reservation Type WaitEstimate Wait')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Please note that the dataset name should be the same to the csv file name in order to assist the program finding the correct file." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "restaurant = RestaurantDataSet()\n", + "restaurant.inputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Class Attributes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we will demonstrate the attributes of a `DataSet` object and how they can be utilized. All the attributes can be specified when defining a dataset." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- examples: Holds the items of the dataset. Each item is a list of values. Could be indexed or sliced." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[5.1, 3.5, 1.4, 0.2, 'setosa'],\n", + " [4.9, 3.0, 1.4, 0.2, 'setosa'],\n", + " [4.7, 3.2, 1.3, 0.2, 'setosa']]" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "iris.examples[:3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **attrs**: The indexes of the features (by default in the range of [0,f), where f is the number of features). For example, item[i] returns the feature at index i of item.\n", + "\n", + "- **attrnames**: An optional list with attribute names. For example, item[s], where s is a feature name, returns the feature of name s in item.\n", + "\n", + "- **target**: The attribute a learning algorithm will try to predict. By default the last attribute.\n", + "\n", + "- **inputs**: This is the indexes of attributes without the target." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "attrs: [0, 1, 2, 3, 4]\n", + "attrnames (by default same as attrs): ['sepal-len', 'sepal-width', 'petal-len', 'petal-width', 'class']\n", + "target: 4\n", + "inputs: [0, 1, 2, 3]\n" + ] + } + ], + "source": [ + "print(\"attrs:\", iris.attrs)\n", + "print(\"attrnames (by default same as attrs):\", iris.attrnames)\n", + "print(\"target:\", iris.target)\n", + "print(\"inputs:\", iris.inputs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **values**: A list of lists which holds the set of possible values for the corresponding attribute/feature. If initially None, it gets computed (by the function setproblem) from the examples." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For instance if we want to show the possible values of the first attribute:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[4.7, 5.5, 5.0, 4.9, 5.1, 4.6, 5.4, 4.4, 4.8, 4.3, 5.8, 7.0, 7.1, 4.5, 5.9, 5.6, 6.9, 6.5, 6.4, 6.6, 6.0, 6.1, 7.6, 7.4, 7.9, 5.7, 5.3, 5.2, 6.3, 6.7, 6.2, 6.8, 7.3, 7.2, 7.7]\n" + ] + } + ], + "source": [ + "print(iris.values[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **name**: Name of the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "name: iris\n" + ] + } + ], + "source": [ + "print(\"name:\", iris.name)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **source**: The source of the dataset (url or other). Not used in the code.\n", + "\n", + "- **exclude**: A list of indexes to exclude from inputs. The list can include either attribute indexes (attrs) or names (attrnames)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Helper Functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will now take a look at the auxiliary functions found in the class. These functions help modify a DataSet object to your needs." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **sanitize**: Takes as input an example and returns it with non-input (target) attributes replaced by None. Useful for testing. Keep in mind that the example given is not itself sanitized, but instead a sanitized copy is returned." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the function doesn't actually change the given example; it returns a sanitized copy of it." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sanitized: [5.1, 3.5, 1.4, 0.2, None]\n", + "Original: [5.1, 3.5, 1.4, 0.2, 'setosa']\n" + ] + } + ], + "source": [ + "print(\"Sanitized:\",iris.sanitize(iris.examples[0]))\n", + "print(\"Original:\",iris.examples[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **classes_to_numbers**: Maps the class names of a dataset to numbers. If the class names are not given, they are computed from the dataset values. Useful for classifiers that return a numerical value instead of a string." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For a lot of the classifiers in the book, classes should have numerical values. With this function we are able to map string class names to numbers." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Class of first example: setosa\n", + "Class of first example: 0\n" + ] + } + ], + "source": [ + "print(\"Class of first example:\",iris2.examples[0][iris2.target])\n", + "iris2.classes_to_numbers()\n", + "print(\"Class of first example:\",iris2.examples[0][iris2.target])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **remove_examples**: Removes examples containing a given value. Useful for removing examples with missing values, or for removing classes (needed for binary classifiers)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Currently the iris dataset has three classes, setosa, virginica and versicolor. We want though to convert it to a binary class dataset (a dataset with two classes). The class we want to remove is \"virginica\". To accomplish that we will utilize the helper function remove_examples." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['setosa', 'versicolor']\n" + ] + } + ], + "source": [ + "iris2 = DataSet(name=\"iris\")\n", + "\n", + "iris2.remove_examples(\"virginica\")\n", + "print(iris2.values[iris2.target])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **find_means_and_deviations**: find the mean values and deviations of each class in the dataset." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the iris example we have three classes, thus both means and deviations have the length of 3." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3 3\n" + ] + } + ], + "source": [ + "means, deviations = iris.find_means_and_deviations()\n", + "print(len(means), len(deviations))" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setosa feature means: [5.006, 3.418, 1.464, 0.244]\n", + "Versicolor mean for first feature: 5.936\n", + "Setosa feature deviations: [0.3524896872134513, 0.38102439795469095, 0.17351115943644546, 0.10720950308167838]\n", + "Virginica deviation for second feature: 0.32249663817263746\n" + ] + } + ], + "source": [ + "print(\"Setosa feature means:\", means[\"setosa\"])\n", + "print(\"Versicolor mean for first feature:\", means[\"versicolor\"][0])\n", + "\n", + "print(\"Setosa feature deviations:\", deviations[\"setosa\"])\n", + "print(\"Virginica deviation for second feature:\",deviations[\"virginica\"][1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dataset Visualization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the example datasets are used extensively in the code of the book, below we show the common ways to provide a visualized tool that helps in comprehending the dataset and thus how the algorithms work." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Iris Visualization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We plot the dataset in a 3D space using matplotlib and the function show_iris from notebook.py. The function takes as input three parameters, i, j and k, which are indicises to the iris features, \"Sepal Length\", \"Sepal Width\", \"Petal Length\" and \"Petal Width\" (0 to 3). By default we show the first three features." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "iris = DataSet(name=\"iris\")\n", + "\n", + "show_iris()\n", + "show_iris(0, 1, 3)\n", + "show_iris(1, 2, 3)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/chapter18/Decision Tree.ipynb b/notebooks/chapter18/Decision Tree.ipynb new file mode 100644 index 000000000..832733e5e --- /dev/null +++ b/notebooks/chapter18/Decision Tree.ipynb @@ -0,0 +1,511 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "sys.path = [os.path.abspath(\"../../\")] + sys.path\n", + "from learning4e import *\n", + "from notebook4e import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## DECISION TREE LEARNER\n", + "\n", + "### Overview\n", + "\n", + "#### Decision Trees\n", + "A decision tree is a flowchart that uses a tree of decisions and their possible consequences for classification. At each non-leaf node of the tree an attribute of the input is tested, based on which corresponding branch leading to a child-node is selected. At the leaf node the input is classified based on the class label of this leaf node. The paths from root to leaves represent classification rules based on which leaf nodes are assigned class labels.\n", + "![perceptron](images/decisiontree_fruit.jpg)\n", + "#### Decision Tree Learning\n", + "Decision tree learning is the construction of a decision tree from class-labeled training data. The data is expected to be a tuple in which each record of the tuple is an attribute used for classification. The decision tree is built top-down, by choosing a variable at each step that best splits the set of items. There are different metrics for measuring the \"best split\". These generally measure the homogeneity of the target variable within the subsets.\n", + "\n", + "#### Gini Impurity\n", + "Gini impurity of a set is the probability of a randomly chosen element to be incorrectly labeled if it was randomly labeled according to the distribution of labels in the set.\n", + "\n", + "$$I_G(p) = \\sum{p_i(1 - p_i)} = 1 - \\sum{p_i^2}$$\n", + "\n", + "We select a split which minimizes the Gini impurity in child nodes.\n", + "\n", + "#### Information Gain\n", + "Information gain is based on the concept of entropy from information theory. Entropy is defined as:\n", + "\n", + "$$H(p) = -\\sum{p_i \\log_2{p_i}}$$\n", + "\n", + "Information Gain is difference between entropy of the parent and weighted sum of entropy of children. The feature used for splitting is the one which provides the most information gain.\n", + "\n", + "#### Pseudocode\n", + "\n", + "You can view the pseudocode by running the cell below:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pseudocode(\"Decision Tree Learning\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Implementation\n", + "The nodes of the tree constructed by our learning algorithm are stored using either `DecisionFork` or `DecisionLeaf` based on whether they are a parent node or a leaf node respectively." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "psource(DecisionFork)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "DecisionFork holds the attribute, which is tested at that node, and a dict of branches. The branches store the child nodes, one for each of the attribute's values. Calling an object of this class as a function with input tuple as an argument returns the next node in the classification path based on the result of the attribute test." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "psource(DecisionTreeLearner)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The implementation of DecisionTreeLearner provided in learning.py uses information gain as the metric for selecting which attribute to test for splitting. The function builds the tree top-down in a recursive manner. Based on the input it makes one of the four choices:\n", + "\n", + "
    \n", + "
  1. If the input at the current step has no training data we return the mode of classes of input data received in the parent step (previous level of recursion).
  2. \n", + "
  3. If all values in training data belong to the same class it returns a `DecisionLeaf` whose class label is the class which all the data belongs to.
  4. \n", + "
  5. If the data has no attributes that can be tested we return the class with highest plurality value in the training data.
  6. \n", + "
  7. We choose the attribute which gives the highest amount of entropy gain and return a `DecisionFork` which splits based on this attribute. Each branch recursively calls `decision_tree_learning` to construct the sub-tree.
  8. \n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example\n", + "\n", + "Here we will apply the Decision Tree Learner to classify our previous example datasets. `DecisionTreeLearner` only takes a `DataSet` object as input and will automatically learn the attributes and targets of data. The learner function will return a `DecisionFork` object which can be use to predict further data example.\n", + "\n", + "Decision Tree can be used to simulate the process of human making a decision. It can be applied to either binary or multiple classification. For many complex problems like digit image classification, decision tree can yeild very good results. Thus it can be the first algorithm to in order to investigate a dataset at the beginning of a project." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Iris Example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's try on the algorithm on iris example as it has less attributes which makes it clearer to demonstrate. \n", + "The first step is to load dataset to decision tree learner" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "iris = DataSet(name=\"iris\")\n", + "\n", + "DTL = DecisionTreeLearner(iris)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then you can try a new example on the trained learner:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "setosa\n" + ] + } + ], + "source": [ + "print(DTL([5.1, 3.0, 1.1, 0.1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As expected, the Decision Tree learner classifies the sample as \"setosa\" as seen in the previous section." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Restaurant Example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's try the decision tree algorithm on Figure 18.3 example" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "restaurant = DataSet(name=\"restaurant\", attrnames='Alternate Bar Fri/Sat Hungry Patrons Price ' +\n", + " 'Raining Reservation Type WaitEstimate Wait')\n", + "RT = DecisionTreeLearner(restaurant)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we try to print the object, we can see the trained decision tree in the from of nested decision forks:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DecisionFork(4, 'Patrons', {'Full': DecisionFork(9, 'WaitEstimate', {'10-30': DecisionFork(8, 'Type', {'Italian': 'No', 'French': 'No', 'Burger': 'Yes', 'Thai': 'Yes'}), '>60': 'No', '0-10': 'No', '30-60': DecisionFork(8, 'Type', {'Italian': 'No', 'French': 'Yes', 'Burger': 'Yes', 'Thai': 'No'})}), 'None': 'No', 'Some': 'Yes'})\n" + ] + } + ], + "source": [ + "print(RT)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's try a new example according to the attribute names:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Alternate', 'Bar', 'Fri/Sat', 'Hungry', 'Patrons', 'Price', 'Raining', 'Reservation', 'Type', 'WaitEstimate', 'Wait']\n" + ] + } + ], + "source": [ + "print(restaurant.attrnames)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's try some Thai food with full patron and waiting time between 10 and 30 minites:" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Yes\n" + ] + } + ], + "source": [ + "example = ['Yes', 'No', 'Yes', 'Yes', 'Full', '$', 'No', 'No', 'Thai', '10-30', 'Yes']\n", + "print(RT(example))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we want to try some else like French:" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No\n" + ] + } + ], + "source": [ + "example = ['Yes', 'No', 'Yes', 'Yes', 'Full', '$', 'No', 'No', 'French', '10-30', 'Yes']\n", + "print(RT(example))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Random Forest" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Overview\n", + "\n", + "![random_forest.png](images/random_forest.png) \n", + "Image via [src](https://cdn-images-1.medium.com/max/800/0*tG-IWcxL1jg7RkT0.png)\n", + "\n", + "#### Random Forest\n", + "\n", + "As the name of the algorithm and image above suggest, this algorithm creates the forest with a number of trees. The more number of trees makes the forest robust. In the same way in random forest algorithm, the higher the number of trees in the forest, the higher is the accuray result. The main difference between Random Forest and Decision trees is that, finding the root node and splitting the feature nodes will be random. \n", + "\n", + "Let's see how Rnadom Forest Algorithm work : \n", + "Random Forest Algorithm works in two steps, first is the creation of random forest and then the prediction. Let's first see the creation : \n", + "\n", + "The first step in creation is to randomly select 'm' features out of total 'n' features. From these 'm' features calculate the node d using the best split point and then split the node into further nodes using best split. Repeat these steps until 'i' number of nodes are reached. Repeat the entire whole process to build the forest. \n", + "\n", + "Now, let's see how the prediction works\n", + "Take the test features and predict the outcome for each randomly created decision tree. Calculate the votes for each prediction and the prediction which gets the highest votes would be the final prediction.\n", + "\n", + "\n", + "### Implementation\n", + "\n", + "Below mentioned is the implementation of Random Forest Algorithm." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "psource(RandomForest)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This algorithm creates an ensemble of decision trees using bagging and feature bagging. It takes 'm' examples randomly from the total number of examples and then perform feature bagging with probability p to retain an attribute. All the predictors are predicted from the DecisionTreeLearner and then a final prediction is made." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### MNIST Example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First let's load MNIST data to a `DataSet` object with predefined load function:" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [], + "source": [ + "train_img, train_lbl, test_img, test_lbl = load_MNIST(path=\"../../aima-data/MNIST/Digits\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to use `load_MNIST` correctly, you need to input the correct data directory of MNIST data. Then we compose the training data and labels to a full example." + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "60000\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "examples = [np.append(train_img[i], train_lbl[i]) for i in range(len(train_img))]\n", + "print(len(examples))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have 60000 examples in total, we use the first 100 examples to roughly train the model:" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [], + "source": [ + "MNIST_dataset = DataSet(examples=examples[:100])\n", + "MNIST_RF = RandomForest(MNIST_dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's try a example in the dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAK4AAACuCAYAAACvDDbuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAFGklEQVR4nO3dvyt9cRzH8c+Vya/k94SFQTIYWKQrKaPJoO5qkPwoK5mky2Qw2JSMBoPFoEQoE4v8KBmQMokkut8/4PM+Ou659369judjfHfuuZ/h6VPnHI5EJpPJOEBM0f9eAJANwoUkwoUkwoUkwoUkwoUkwoUkwoUkwoWk4rAHJhKJfK4DcM45F/ZBLjsuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJIV+sfNfU19fb8739/e9WUlJiXlsMpn0Zjc3N5HWFWR6etqcz8/Pe7P19XXz2ImJiVwuKa/YcSGJcCGJcCGJcCGJizPnXFGR//ObSqXMY1taWrzZ9fW1eezX11e0hQXo6uryZrOzs+ax5eXl3mxhYSHnayo0dlxIIlxIIlxIIlxIIlxI4q6Cc25sbMybpdPp0J+fnJw057e3t9kuyTnnXEdHhznf2dnxZpWVleaxx8fH3uzl5SXSun4DdlxIIlxIIlxIIlxI+lMXZ01NTeZ8fHw89Dk+Pz+92cfHR9Zr+k7QuqqqqkKfw7o4e319zXpNvwU7LiQRLiQRLiQRLiQRLiQlMplMJtSBiUS+15JTxcX+DZONjQ3z2OHh4dDn3dvb82b9/f3hFxagt7fXm21tbZnH/uSuQnNzsze7u7sL/flCC5kjOy40ES4kES4kES4kxfaRb21trTf7yUVY0GPcxcXFrNfknHOlpaXmfGVlxZv95CJse3vbnD8/P4c+hxJ2XEgiXEgiXEgiXEgiXEiK7V2Furq6SJ+/uroy57u7u6HPYd1BGBkZMY8N+ovesGZmZsx5HH5p3MKOC0mEC0mEC0mEC0mxvTgbHR2N9PnGxkZzHvQ7spaamhpv1tPTk/WavtPe3m7Ord+9zddfJRcSOy4kES4kES4kES4kES4kxfauwv39faTPW/9myTnnhoaGIp03X4Ludqj9lW9Y7LiQRLiQRLiQRLiQFNtXMFVXV3uz8/Nz89iGhoZ8L+e/Ubs44xVMiDXChSTChSTChSTChaTYPvK13pmVTCbNY9va2ryZ9f99nbMfBXd3d/9scSGdnJyYc+t/8a6urprHPj095XRNvwU7LiQRLiQRLiQRLiTF9pFvvnR2dnqz09PTyOc9PDz0ZoODg+axcX2tknM88kXMES4kES4kES4kES4kxfaRb1QVFRXmfG5uLi/ft7y87M3ifPcgKnZcSCJcSCJcSCJcSOKRb4CgFyWfnZ1FOu/R0ZE5HxgY8GZvb2+RvksRj3wRa4QLSYQLSYQLSYQLSTzydfbj3XQ6nZfvWlpaMud/8Q5CFOy4kES4kES4kES4kMQjX+dca2urN7u4uIh8XusVSn19feax7+/vkb8vDnjki1gjXEgiXEgiXEgiXEjika9zbmpqKi/ntd4Hxt2D3GDHhSTChSTChSTChSQuzpxzZWVlkT7/+PhoztfW1iKdF8HYcSGJcCGJcCGJcCGJcCGJuwo5sLm5ac4vLy8LvJK/gx0XkggXkggXkggXkrg4c84dHBx4s1QqZR778PDgzXi0W3jsuJBEuJBEuJBEuJBEuJDEu8Pwq/DuMMQa4UIS4UIS4UIS4UIS4UIS4UIS4UIS4UIS4UJS6F8kD/soDigEdlxIIlxIIlxIIlxIIlxIIlxIIlxIIlxIIlxI+gegNfU4U/K/dQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(2,2))\n", + "plt.imshow(test_img[-3].reshape((28, 28)))\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The prediction of our random forest model is as following:" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[4, 4, 4, 1, 9]\n", + "4\n" + ] + } + ], + "source": [ + "print(MNIST_RF(test_img[-3]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Which is the same as our own perception of the figure." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Decision List Learner" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Decision list is an algorithm that applys PAC learning to a new hypothesis space. PAC is short for probably approximately correct which means any hypothesis that is consistent with a sufficiently large set of training examples is unlikely to be seriously wrong. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/chapter18/Ensemble Learning.ipynb b/notebooks/chapter18/Ensemble Learning.ipynb new file mode 100644 index 000000000..371569c6e --- /dev/null +++ b/notebooks/chapter18/Ensemble Learning.ipynb @@ -0,0 +1,389 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ENSEMBLE LEARNER\n", + "\n", + "### Overview\n", + "\n", + "Ensemble Learning improves the performance of our model by combining several learners. It improvise the stability and predictive power of the model. Ensemble methods are meta-algorithms that combine several machine learning techniques into one predictive model in order to decrease variance, bias, or improve predictions. \n", + "\n", + "\n", + "\n", + "![ensemble_learner.jpg](images/ensemble_learner.jpg)\n", + "\n", + "\n", + "Some commonly used Ensemble Learning techniques are : \n", + "\n", + "1. Bagging : Bagging tries to implement similar learners on small sample populations and then takes a mean of all the predictions. It helps us to reduce variance error.\n", + "\n", + "2. Boosting : Boosting is an iterative technique which adjust the weight of an observation based on the last classification. If an observation was classified incorrectly, it tries to increase the weight of this observation and vice versa. It helps us to reduce bias error.\n", + "\n", + "3. Stacking : This is a very interesting way of combining models. Here we use a learner to combine output from different learners. It can either decrease bias or variance error depending on the learners we use.\n", + "\n", + "### Implementation\n", + "\n", + "Below mentioned is the implementation of Ensemble Learner." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "psource(EnsembleLearner)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This algorithm takes input as a list of learning algorithms, have them vote and then finally returns the predicted result." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## AdaBoost\n", + "\n", + "### Overview\n", + "\n", + "**AdaBoost** is an algorithm which uses **ensemble learning**. In ensemble learning the hypotheses in the collection, or ensemble, vote for what the output should be and the output with the majority votes is selected as the final answer.\n", + "\n", + "AdaBoost algorithm, as mentioned in the book, works with a **weighted training set** and **weak learners** (classifiers that have about 50%+epsilon accuracy i.e slightly better than random guessing). It manipulates the weights attached to the the examples that are showed to it. Importance is given to the examples with higher weights.\n", + "\n", + "All the examples start with equal weights and a hypothesis is generated using these examples. Examples which are incorrectly classified, their weights are increased so that they can be classified correctly by the next hypothesis. The examples that are correctly classified, their weights are reduced. This process is repeated *K* times (here *K* is an input to the algorithm) and hence, *K* hypotheses are generated.\n", + "\n", + "These *K* hypotheses are also assigned weights according to their performance on the weighted training set. The final ensemble hypothesis is the weighted-majority combination of these *K* hypotheses.\n", + "\n", + "The speciality of AdaBoost is that by using weak learners and a sufficiently large *K*, a highly accurate classifier can be learned irrespective of the complexity of the function being learned or the dullness of the hypothesis space." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Implementation\n", + "\n", + "To view the source code of `AdaBoost`, you need to import the necessities first:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "sys.path = [os.path.abspath(\"../../\")] + sys.path\n", + "from learning4e import *\n", + "from notebook4e import *\n", + "from utils4e import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then use the following command:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

\n", + "\n", + "
def AdaBoost(L, K):\n",
+       "    """[Figure 18.34]"""\n",
+       "\n",
+       "    def train(dataset):\n",
+       "        examples, target = dataset.examples, dataset.target\n",
+       "        N = len(examples)\n",
+       "        epsilon = 1/(2*N)\n",
+       "        w = [1/N]*N\n",
+       "        h, z = [], []\n",
+       "        for k in range(K):\n",
+       "            h_k = L(dataset, w)\n",
+       "            h.append(h_k)\n",
+       "            error = sum(weight for example, weight in zip(examples, w)\n",
+       "                        if example[target] != h_k(example))\n",
+       "\n",
+       "            # Avoid divide-by-0 from either 0% or 100% error rates:\n",
+       "            error = clip(error, epsilon, 1 - epsilon)\n",
+       "            for j, example in enumerate(examples):\n",
+       "                if example[target] == h_k(example):\n",
+       "                    w[j] *= error/(1 - error)\n",
+       "            w = normalize(w)\n",
+       "            z.append(math.log((1 - error)/error))\n",
+       "        return WeightedMajority(h, z)\n",
+       "    return train\n",
+       "
\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "psource(AdaBoost)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "AdaBoost takes as inputs: **L** and *K* where **L** is the learner and *K* is the number of hypotheses to be generated. The learner **L** takes in as inputs: a dataset and the weights associated with the examples in the dataset. But the input learner like `DecisionTreeLearner` doesnot handle weights and only takes a dataset as its input. \n", + "To remedy that we will give as input to the `DecisionTreeLearner` a modified dataset in which the examples will be repeated according to the weights associated to them. Intuitively, what this will do is force the learner to repeatedly learn the same example again and again until it can classify it correctly. \n", + "\n", + "To convert `DecisionTreeLearner` so that it can take weights as input too, we will have to pass it through the **`WeightedLearner`** function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "psource(WeightedLearner)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `WeightedLearner` function will then call the `PerceptronLearner`, during each iteration, with the modified dataset which contains the examples according to the weights associated with them." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example\n", + "\n", + "We will pass the `DecisionTreeLearner` through `WeightedLearner` function. Then we will create an `AdaboostLearner` classifier with number of hypotheses or *K* equal to 5." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "WeightedPerceptron = WeightedLearner(DecisionTreeLearner)\n", + "AdaboostLearner = AdaBoost(WeightedPerceptron, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'virginica'" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "iris2 = DataSet(name=\"iris\")\n", + "iris2.classes_to_numbers()\n", + "\n", + "adaboost = AdaboostLearner(iris2)\n", + "\n", + "adaboost([5, 3, 1, 0.1])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Error ratio for adaboost: 0.0\n" + ] + } + ], + "source": [ + "print(\"Error ratio for adaboost: \", err_ratio(adaboost, iris2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Generally using ensemble learning will increase the accuracy of final result as the weight voting of different learners will average the random error." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluate Learners" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also offer an algorithm evaluating util function: `compare` in the source code. With this function user can compare different algorithms on multiple datasets in order to choose from them.\n", + "\n", + "The default algorithms to compare are `NearestNeighborLearner` and `DecisionTreeLearner`, and the datasets are iris, orings, zoo, restaurant and several other auto-generated test cases.\n", + "\n", + "To use the `compare` function with default settings:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " iris orings zoo restaur restaur majorit parity xor\n", + "NearestNeighbor 0.00 0.27 0.00 0.00 0.00 0.00 0.00 0.00\n", + "DecisionTree 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00\n" + ] + } + ], + "source": [ + "compare()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As the datasets used here are very simple, there is no significant difference between the error rate of two algorithms except `NearestNeighborLearner` are not doing well on `orings` dataset. You can try self-defined datasets by specifying the `dataset` attribute as the list of datasets of interests such as MNIST." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/chapter18/Linear and Nonparametric Models.ipynb b/notebooks/chapter18/Linear and Nonparametric Models.ipynb new file mode 100644 index 000000000..83f9318ed --- /dev/null +++ b/notebooks/chapter18/Linear and Nonparametric Models.ipynb @@ -0,0 +1,435 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Linear Models\n", + "Linear models are already used for hundred of years. It is a class of linear functions of continuous-valued inputs." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Linear Learner\n", + "### Overview\n", + "\n", + "Linear Learner is a model that assumes a linear relationship between the input variables x and the single output variable y. More specifically, that y can be calculated from a linear combination of the input variables x. Linear learner is a quite simple model as the representation of this model is a linear equation. \n", + "\n", + "The linear equation assigns one scaler factor to each input value or column, called a coefficients or weights. One additional coefficient is also added, giving additional degree of freedom and is often called the intercept or the bias coefficient. \n", + "For example : y = ax1 + bx2 + c . \n", + "\n", + "### Implementation\n", + "\n", + "Below mentioned is the implementation of Linear Learner." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "psource(LinearLearner)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This algorithm first assigns some random weights to the input variables and then based on the error calculated updates the weight for each variable. Finally the prediction is made with the updated weights. \n", + "\n", + "### Example\n", + "\n", + "We will now use the Linear Learner to classify a sample with values: 5.1, 3.0, 1.1, 0.1." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "sys.path = [os.path.abspath(\"../../\")] + sys.path\n", + "from learning4e import *\n", + "from notebook4e import *\n", + "from utils4e import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One of the key point when applying a dataset to the linear learner is to convert the class names to numbers before feeding it into the learner:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0863712261312969\n" + ] + } + ], + "source": [ + "iris = DataSet(name=\"iris\")\n", + "iris.classes_to_numbers()\n", + "\n", + "linear_learner = LinearLearner(iris)\n", + "print(linear_learner([5, 3, 1, 0.1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The result is closer to 0 than 1 and 2, thus we can class it as class 0 which represents 'setosa'." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Logistic Linear Learner" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Logistic linear learner is different from common linear learner only in the updating rule of weights. Logistic function is continuous and derivable. Using `LogisticLinearLearner` is similar to using `LinearLearner`:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.16279158793332174\n" + ] + } + ], + "source": [ + "logistic_learner = LogisticLinearLeaner(iris)\n", + "print(logistic_learner([5, 3, 1, 0.1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The prediction can also be treated as class 0." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Nonparametric Models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A nonparametric model is one that cannot be characterized by a bounded set of parameters. This usually happens when the dataset is huge and let the data speak for their own property is ensenstially good. The simplest approach is to put all examples into a lookup table. \n", + "\n", + "Here we will demonstrate a improved version of lookup table: k-nearest neighbors lookup, which finds the k examples that are nearest to the given query.\n", + "\n", + "## K-NEAREST NEIGHBOURS CLASSIFIER\n", + "\n", + "### Overview\n", + "\n", + "In this section we are going to use this to classify Iris flowers. More about kNN on [Scholarpedia](http://www.scholarpedia.org/article/K-nearest_neighbor).\n", + "\n", + "![kNN plot](images/knn_plot.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see how kNN works with a simple plot shown in the above picture.\n", + "\n", + "We have co-ordinates (we call them **features** in Machine Learning) of this red star and we need to predict its class using the kNN algorithm. In this algorithm, the value of **k** is arbitrary. **k** is one of the **hyper parameters** for kNN algorithm. We choose this number based on our dataset and choosing a particular number is known as **hyper parameter tuning/optimising**. We learn more about this in coming topics.\n", + "\n", + "Let's put **k = 3**. It means you need to find 3-Nearest Neighbors of this red star and classify this new point into the majority class. Observe that smaller circle which contains three points other than **test point** (red star). As there are two violet points, which form the majority, we predict the class of red star as **violet- Class B**.\n", + "\n", + "Similarly if we put **k = 5**, you can observe that there are three yellow points, which form the majority. So, we classify our test point as **yellow- Class A**.\n", + "\n", + "In practical tasks, we iterate through a bunch of values for k (like [1, 3, 5, 10, 20, 50, 100]), see how it performs and select the best one. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Implementation\n", + "\n", + "Below follows the implementation of the kNN algorithm:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "psource(NearestNeighborLearner)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It takes as input a dataset and k (default value is 1) and it returns a function, which we can later use to classify a new item.\n", + "\n", + "To accomplish that, the function uses a heap-queue, where the items of the dataset are sorted according to their distance from *example* (the item to classify). We then take the k smallest elements from the heap-queue and we find the majority class. We classify the item to this class." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example\n", + "\n", + "We measured a new flower with the following values: 5.1, 3.0, 1.1, 0.1. We want to classify that item/flower in a class. To do that, we write the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "setosa\n" + ] + } + ], + "source": [ + "iris = DataSet(name=\"iris\")\n", + "\n", + "knn_model = NearestNeighborLearner(iris,k=3)\n", + "print(knn_model([5.1,3.0,1.1,0.1]))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.06000000000000005" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "err_ratio(knn_model, iris)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Which is the same as expected. By altering k, you can change the number of neighbors considering in the lookup procedure. Thus the classification accuracy is directly affected by k.\n", + "\n", + "In order to show the influence of k, we need to fake some data that easier for visualization first. We will use only two dimensions among the attributes of iris dataset.\n", + "\n", + "First, we load the dataset and compose a new dataset with the first two among all the attributes together with the target dimension." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "iris = DataSet(name=\"iris\")\n", + "iris.classes_to_numbers()\n", + "examples = np.asarray(iris.examples)\n", + "reduced_iris = DataSet(examples=examples[:,[0,1,4]].tolist(), distance=euclidean_distance)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we build models with different k and plot the model's decision boundaries with util function `plot_model_boundary`.\n", + "\n", + "Let's try with k=1 and assign the first attribute to x-axis and the second to y-axis." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model = NearestNeighborLearner(reduced_iris, k=1)\n", + "plot_model_boundary(reduced_iris,0,1, model=model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see there are zigzag and rectangle shapes. The class of a point heavily relies on the nearest point type.\n", + "\n", + "Then we increase k to 3:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model = NearestNeighborLearner(reduced_iris, k=3)\n", + "plot_model_boundary(reduced_iris,0,1, model=model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When k=3 we can see there are some areas near blue points are classified as green and the shape of each color chunk is no longer shuttered.\n", + "\n", + "Then we set k=5." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model = NearestNeighborLearner(reduced_iris, k=5)\n", + "plot_model_boundary(reduced_iris,0,1, model=model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The class boundary seems more regular. Then let's double k, making k =14:" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model = NearestNeighborLearner(reduced_iris, k=14)\n", + "plot_model_boundary(reduced_iris,0,1, model=model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The decision boundary is smoother with larger k generally." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/chapter18/images/decisiontree_fruit.jpg b/notebooks/chapter18/images/decisiontree_fruit.jpg new file mode 100644 index 0000000000000000000000000000000000000000..41ac4d6061e06db4d5ee42d2e6fec40c04ae3ef6 GIT binary patch literal 45995 zcma&M19W8H(=Oc6#7-u*ZQHgcp4isJnbu+OPo8}C2gHvve};!@%O5D*Z6gHKj}wp&A0Nh_KECkKkkJ3Z{+|o)eE?)AkXX=MFc4$_C^85b zGRXS?02crP00sMVy8jV~PaxosV4zSRDE0^NSN;P6Kt3)4;?w&I01oWK5(x|m004P? z`7i$ePy*2)L~Oj1b0N#j`Cr+Xp9BF*TyZGQ7PL$nb4y^mrH!HsnbFDKe*dcpV4r-* zxN27UOmi#KmV4lwX>AER@0?GCyM#gTe>Vcjb9gys_||2l!ZYc~JnV+&P#9r3pPC>u zukiJMu>ye+u7L|c-cM{ST~zaeA7%f26lTxg^S`kFs3FiIC}hGAG$N3tl(ix-|92+5 zN_Gy!ZZZJ3;~0Rh+~l1S|M3j{|Hwd?RQL#sIcS^eWWtYZKLAYcg_a*=uNcW>{F{fL z0dnZlyoKQZw1blxuDnSBPM7+4I-c;hea)?KFpx3-U~zq)?*V|R{vaT2b!MXAND;A& z%E@&c^ZTC;26A%f+q5jjF~*ApBJE&3qy#@0Ad=)HuG5hxspmOLQyn&I3D%Q&NX3|Z zBql~|*|`Lk|I-Nw7_?Sd-S1(+>Oa;1z}~loPY1!Znr$^^KJy&%nQaXCX)_?#WKv&a z>h86B{&N10AH?`ziDYKrKN^{*-- zONNBpKMeCkmMycnwSV*e{zH7Nz$y1psQI^Y-%Nr}@NWe~pW0N$ojpzQ-w*&oGDzt( zNrfztZjkI>N`C1$xNfQKHY)N~KIKyzzYjGWn#m0Rj8LWDm23{pR~f;7F+r;uHQCAP z&IO#*v0_Pz%AQ6I5b`|!0gDq`-KwmCtJj|}I5?B>t>Vr7W*QOk7 z*71XPD*|-epZDd;9_Rk;b#HvG;2>=wL`Qg`n{L=H3zm<&s1}DpB00|bk@c^0uw>es znx_FgPx&M>9C8;DH(Bni11y(J`R}$PA5D4XNOs(ssl0kts{`ESJlWCAwc~RMe_CfM zBkL6X=j;H8s2St3wCULo zOt)JJUe}czJgs8oj~WClX|*nk9;)FV&L0hessf4R$$#pAec1WA3h&SM|7gt7b_9R9XWvW0k zR$CH)DX!UQAoxMRjMJI)P`ZPmG9@h-%~1RSfWj2YkcgX#PDJ?Xd;v$yWU4{^*N+kP zXP{RT?S|erE$AAj%oTbMR|bjroax4!I9_;r52>-66N{sdHbNv(z2Qg9D@vg}aMPs% zJaVNuP5Q0njQdOu0^HLj3c||BuiYmnz0s8KZ2X}@Xb;lP$)uagRmVs2F{U6+hEZj$apy4W)bIVIX&pb0+kMsG^vE|HY z0Dw3gxnPCN#8j3bNR`u(hcJ@q4CI6fW2-E^qH?lhkso6cS7oxbL-
yN*;4>2Gf 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 literal 0 HcmV?d00001 diff --git a/notebooks/chapter18/images/ensemble_learner.jpg b/notebooks/chapter18/images/ensemble_learner.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b1edd1ec53d303c4ad30e4c52a67987162df0551 GIT binary patch literal 16575 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 literal 0 HcmV?d00001 diff --git a/notebooks/chapter18/images/knn_plot.png b/notebooks/chapter18/images/knn_plot.png new file mode 100644 index 0000000000000000000000000000000000000000..58b316fdd08a80ee60cc98476a420b14f5d904b7 GIT binary patch literal 45256 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

E$fHB1*xXl0UuWi#=)7h z{3JZyr%vFC5A3=4dm#*h6Eiq#*)>alGH1)sxD_~k`M|7@AO%N+Qu|vZNd(z}P^Szf zlHWjUmL%CB#>{>44)5-Fm)Q!5f;xCDM#jdPU|IqHK|t3=Sktb?f~>5p@agIoQQI{G zEqN@`M|LzQfCx3qksxoVOpjNAo?SRRUf+jITG=b;aj{5VtC1nRM$rJhG@l4(+2}{! zf-!1&J_a3;v=Zj601Cv3dY=}199TiGALPt&ONzKgNs;YlV)rub{%p9-Or1N=+0piq zyMCI_kJY_0bI0nv9-$N1U4iE8GNyaS;0#+v&i^$hOy?m1|I;U{k^=SFcJlJ_#^=ZX zY-ZB2T61!VReM=v2?2HkAw)|))rx-DGjs)!D{&%nQ{CHGr6yV>$a@EUJ}ny?8w=Xv zeuuYr`)}kZ168zi39&y7{k|664+D=l5PopOi_f6@;`HMd1Bc-2e!cH@w1$R;KH*j) z!cv86T3;AaeQ7pQEdxfaYg5@A)7HM4M^3_piKzv&VJk-4o`VUFwLzuXrwEi$;#YcZ^ zz3-KIVjl(72K^oa0N~*h%_A=i)mY-o?kCbiT=68)xd^rAZ~-SSyT6YijFA zhJz7u{KsW{ituTz1Wpit@#hg7TwG+UE}#71J&a&=e1}J!;c4T_Wp@pp4%?0Dp=@RP zO4}(pSfWZeysziCrt52|V~G@Am-l-|isFPepyqI~7>aY*VJ1)2KXbZw{p+KP?TjTm zBLRk=Z07jcgujx_av`#Ne7N13 zuk93o?z&`m@RNymo9GK0M#_da93UY3wuAD_!$X^=vlx>#rG76x(P=W#@Y?L zTQcaB$CwS({=&1tKJO>5m1o+mOLTZm>{SP0$K@F{{w6#j`{s33_1MOT9lapuiOh3p z<`tE`P>K6!6*7F%5}<_1RB`POXAg6 zL~v_;;xax4=xToyRd!H@u< z)AeDJ2cDeI$giXes<67!M>r}}9R;-3bV(OlGEwW{W0WM;dZNFh_w)b8GZWC>E=Y$%4mr(EW0oX1{&;( z^IwF*L9VC!mHA?`Y+NB zNfr|DI(`7g@r{Qw$Ed`?i7*4b}G+sSbqups&m`3qv$FWP1J>*Iv4#Xoj;P<=I2>0 zlef<}!lD;AOcGU1JI{qxINwCtUVpc|678&1)t|`w>NlM7GT=sKwRQm{w<}eQx@zL? zozPG}8Yfh0_e|Ve5b*v1KQBA6e4lXq^2s&;$)@u^Lo!kFYU~cBDy&EzUi-djvXZ4K`%SkLz%VF!g<;t6jl)!zP#JwtQNUR_(mw1av}lO&nOBo=CEpJ z5e@7MIDfiON%Hhm71zT>kY^*(yvWe-ay?Wg?LE0y3f89t(^ z8K1KV`1k&7f#$;W71&Zy?A8bGait)K$VX?6wT+60i4m5)&ljL9#J+C*^Ohc%8j)K# zAOP(O+e8h0#jIEC+;q;uFQf61{Li%fYu8KV?9=Hqcl5veQ^dX{bU%}~7x;bZ0?R`9 z@^}IE38u8qQE)Ie%Hie&$&MWIK>Z#5YM|6kz3(=|&HZba^*l8be3z6W9)rHb8K1AD z_dKbw)jgM#ROWxaF?%V$7q7*rna-uJx+}+h#k2E9<7DnA=VosSL6r zao)OILcy{31B?3F)E?QAvNiFI6?&rjfWC{IeYap8Vgh?Li-K_jk#a{$&H}9pwEeU{ z2I8u!cfcN)J4P6b{9-jvm!lcLevMeA&JMS52@Um`wxAyDfF3I(G<0`BCcepP@yE+^ zi{#n^68UV>PanmDy8~2kJrDWfpI8K7jD69tB$s;fgd1uc=twLG4QOg|>O(x?$N;~) z_^lfFDf%im&dpgkILsE>BFb%sxF4NL4H12Wqx~P)<)fe$9DLB%dz?Udy;6_r_8)zs z>U{A+(J-5cAl{s7%^5ZkCz;krV(3R(mRC(Z3I7=S2G-Kc9M)I5_znXrI`F3 z!g!$a$Fay8-eIQ{bPBHBstE&BCsD50PrROa-@r~iStRduBX=<8EY=t1&(CUIHr;@L zvF!hfGy6eY>_Z>!Hd^JKK0FkApYIE#7yVH!;vodG^Q`{gmkk+i1~;A5GWSp6hX$+< z7t;=$=aNQt%Jh)(gVP9Xlo`2JO;!5v3iW+2_y7|$dVqs1iO)1@^AK^)lRvZ}Rqb7J zsIJQ=6l2kg&X1`n5cny)Ks$X*uE&cr7`O&Nz-y=v_R5FA`H&sv~6t7^4ScF*|e` zF(S6!Yby9bet$QX)!X|Ii%McIMSP|$!x8xLMbF#1F=R!6|42$oO6wcEnO^RBWPADVgRhc`%DlPt@3OeU zpAs!=x5hCBFQ`>cxW=I?d>Id5(CH~*GLE*C6yR1bnGzppvrX%G&>vIH;6H$)?}a*1iE$^L;$=C!^#;0VifIdl7<=VAMa~Pqm7^pNob7+* z-mY`kkhqSa(9fc`EvXp4c96=Xv!}!@7pyZE{o>iP8{oU<;%UP;?N^OqQg~JrI9kax zdo#=;pou{&Yv31D)oU}2Vrj1paZQZk8A9L$zTAy(+yT&QWQ#{OS}(J+pOjn_M|tG& zv=z%aY7*PN>UKiBzb%e`U&yU7b+K4C&Z;P{94tSdEAyTv?bi}zW)EygJ9d{e+lw+4 z87&2Km@DyD-o|T}9o6vsJw3jm$+nNS=I|-#&SuG~Jl`M>IV*X(hQ*N%yLz~lO#eq^ zs*8LtZvNqTM%j4~G;@n+`qw#ke`1DGo%hxFoxCB|pbV&vbGyIRtk5DBQUIEPE#$CB z7_+KCRP507S?lkRM{Rc)G^&VAy87?k_)h7;MS`Prr#L9E;9iXo6=!ARjlgD$n9UT2 z0$h^j@AiG!%Com>B-W|qr>M*s4-VVP$!MOqJ^8rB#DkPdP(#(Ksy>&vD;phYiZiBl==J2~k1&x^uJ^mRyJH}PNfvTuVr6Ab zlkJmP)K|Jw|!8 z_0Z-3Nsps-fCUm{1N=iBadgwjU&sz|cwkE&^@n!<()_jeQ}6fh>tfHWE1^+Gef^5` zEoT#u@T)_4B#QBS+&H?juC4K|gBbh~St8{ZXNChztAjaRT4K(>tGLh;Mn#5fy%*7$ zqSVc^+gn@hht$;Vp&0U0_q$I#RidS#!E()r@4Kwp!EQZ?5L#3`dj%gC+dy%%f@(eL zJy}A~TS3haiJL)Fw)mlk!anDZe*OBjw8cn#w`k4(H3vyQXQNwJkEF#IVZ)W4Yc0PG zsm8`C5leyT^zAEJCZ;xqeQ`B6@tL=-2Se((Cz=Xl_hchoGlS;6m_zAK)|&{^0&Jp! zUz2a0WHcnw+!~+Q4%%|4hP)n`=x~OQ)$e{=YgA1{49rPI1Gmq}%ex=VrSNs*CFz(*Qlp5ho4bq(&aZ!8IoRjl7>Y)qEz8TqCW>0Nm# zyDETZqs)ER{HNnm-;u~dw+@s7)N$Yw_u6Es(D5-UBsn@@aA)by>L{(-nQm8A=c94*n&T<_n0Va0# zXKsRQ^m@Xt%3nWbqSieUvVNNM)u}NtTlC@I5tblbV=nwNzUy=K>>4jjd^{h;VAQ*m zY<;263@_L)Zkrc#|EfI}6%_@#T#-7Uz)r`R-&VY(C~AVPd<-y^El{c^(G(J{y$NgJ4lQEuob;Tj z?}(->maDHacWezMDz_ea4@AT|!Br{Efx~@Ah1ZGo8;X0*sVzag>e$=n(rkbB2^+YV z%xOQ;WTX;RC>ghitYs@kG%RSHE8Nf|;Z z=L5pa%bBDr09HTA^B%P9?nJJssjm$mR*bydvi|c&kc&b^et?Gk#^p(GnD5cFr{UjG z4~gZKW-FZc4D7(dBNTYfi>&pa_e}GO91j|uxO+`ZQy&K%71L=-bdPvFtkkiv%EcgO zxi!EU6mgU)8O?Y)Igz0lQ*(tgRi^F=MQXl&V@lPuM;Oj+roIYm^}>czE6B2PT<)3! ztpkPu$UzY7kipacw}kQ?FjL7w6L#=R$60*ZtRn%PagVJho)dkpSK@r?)*mXKH@T^p z6`6B6zIv%>Od_u=Dw>=8BcsyIea|Ll(!4#3$DH_U{t!oBtFEp|)Q$EUnFh?tB zFMiC=Y-t}=|KQmNYGo4)%(S(garf~?G#pj%x*88w+*@?T>;t{ zrKA;DfvzzgSW$mzWr-hmr`QE^4DSu7k+5VEwVz=7XlchY9D`UJVqNqvSaB?GmF2FZ z+V+ZMnfp$ZVfkF?UY$3gjy6&sZnA0fa29#vQ4jZyHBvh`G|lz>^4hl;tx@w;yK_;s zP787r%?7XP4}JJ1x=LwA+?+kGy8~a1M-%SJyzHYKvf;lui9xP>VPiuYFEQRwMv@Zv z4Tk-BBV6TtX2cE-?9pcCl`<80{Ae%+0lX5O1J2|N-@s6)u@kioHr>}V1OcJ^=( z&8QVj@v0RG<-|4r$x1tZRjh~Oz->obKGj6kceq*v0j~j-k5h3RaEe5zDT3)Xm{!f?Omd8ykxxF(wKLP5&197;qXch*R7#jf_RK$Ff}swpI%7pRqJ) z&Hna-AfD*RNSe_zVXiFNPC|Ecx#Nq?XOiPA7K{n{vHabrl~mWCW-d9JXjisNXjWk= z7ZB9Uc~ohzBbYo=n|%GsAg<33#@m&X+t0p#V&(gciUc_T7;}$D9 zR=oKX<@Gh5qGz-+S4~B|>abKR>E{w{izAmM!s#@}GIt?{R80TmP zKhHN{qlmNY+_ZZ7Io-RKAD}=)ce9XL-T>TQ0n!hIJ<@_j1W8&?6und3>B+j+vchU4 zLLyn(TF3UI1#@oeMMp(OMg0J;X_qgxuv;Y5qg?A&D0xG2Ha6^dPfefXnU5~LdYe(z z)E}$;y5;}00IgwN73&c;_tDuOcHG5cwETps$0u%Rm`+MEJzO(U(0I62K%$R|eY1MU zHJp6c_ZY~D7o56(iP9AkA3jTZRN`eV(nREis?QSol{v!R^3qtK_bm+>PFR6$&%Nr0 zSPAT%CZ?wUfB{DFV0sYNilhqlfV9m@F<0*9?@j^RjoG9qh7hRu2A1^Zy5&nn3Cot< z4t1B0=YBYdTYd9fFKfvDL3!_XE+p790`w(G?j9q!>ex!Yklfz zowi>+1^&WUqtpZk$sw8tfDv;RbcypIrz@(9a~CjuaW^)sje+C-{dx^^x8oyoZ|j6f z@<(e~??tiYgclWp<`?+hd-wwVO(yJS*QfE^r{(luj8NmxV#b z?NYVLkJsTiTU=SeIv-`dch7M0yFC(->|`@VGW0`Y6-DgwnEtu&ziTLfx0nLO7f#0W z)>;II7vAX;2;wSbSI;(GCvpfPUXRGmW?@oDP(ATpg*%EQJR%IMNsX9;Mx`-nIrra? z%|nXNlBYG(iR38?g=1sIRv#}@26D7F3$!0=B~Y=L*D*1lE!**5|2}wTHrO@dzPHR} z-jn3#%k-{A!pZ3d0RcfqAcj?ZUqtr7{=QR+_n{^V(zpe^V|Kd{iiwCk{Xq1?1&K5R zBKj%cY&Fj4c3K7uQ(P=2D({0xJR{2d)j`I~cTuQ4MFL}{O`Dz<>)5&y{a4nV@s9^GPZOZ_vD-;&`1WegOru6sZ2QJ=55{k@;ck6+^)NI<_ozREwHecM|m*tWp;yrl5Pan5VB23fU; zx;kMf(3cta&<7;67wN<#cpxN47_3^H3v*dP%<@0|4RZejtxN|kMCS0lPHyT1CefmiN2uDujLRPtU*7^Yi1b>cq&PUjh}h!T$O056i_4bKp| z6c0mUiB;2A44&iJmXDx%e{r0LD=;axNk5k6lq~n>#-GZaNmL2 zzv!*Y!nOz{U$3|sOCVru2!IEq?%7~LVb$@8`Gs>2<@XgTY<$kL^6nD`fA){xBJK*R zGGDF@7+!i!C2WtDP(3HTXf-P6XvzccX5m7`rig5)8XXGA|l4#HpWx#%9`kX4XdPCtwoM{68Yejgf zmP5H8H7yo_r_ix)C1PM^F0&rtKw>Zjv5?Ul*yrI%^mE zO}DslKXs$D&8ngwxca{?o=q?Jc;bc-Tg=ap+tNE0(z{ZDqiu#xC!T2TiFZ2=$)$c- zrb)>!7CH2LsW9BHX*(U4`C*andAs5WrB-S7t+LRR5J@3}tW2~NU@?jOubKGxh^i(O z6cyiNqX=Y0Fv`*i3nvw5S2;l9WJ2vV4wh^i*_5x`SpE<8C;#$EqxT&KRxoSOP zKp$*S^@MzHZq^?i-pZapQ2GlFEPB-XZA<_4{!zE9dq$@db|e;Rjw&7XBB>KBEP-S}5*4FIkhj-d&W5yi5#OzlZXIM0w>QH#rA)3nM2*(Bcse;ql8F z<)pa`wBL3MZ8JCB2PAMX3Yfy=$onV4wNt<-#KO&XeYo&zQY=G==uxHk zfI-W5r{-dV4caeK@~3j?s_*OP`&o3eR06`5uWq;Yt=)4@>6#-XGS8|0$T`&f`r4&| zGvq^>n=iQ3vN4G)lm#E&y5e}`8W+gdLwj<~L&uM9C&o}h1 z=$M(?@BBVcr5y5#lvAniS+NaI2B8Duuf~wB28;E{zjkWNzyD@~5BB6DYs@vPw!QC@ zmQ~T;*AM<#Ez4-`e9v7>s6%_fGwI@&#GD`r4*nbN^TtgJn>n0m5GY>QucnLIvh{&2`z$3|SA+1p3Ei z0*T52txRVg)*^g8_aDBAoyO@1wcWEq6<B z-siK|#oFw|w%_M4Au@B0kKoM{W+iXQ?ePjW5T}+3=%YnlySXdsynaW>#ogpvhfecR=?}&t2ApfMexF`1Z|CUrgY~*J+!X2!BUpt8bo?ygw;OGWC z3HRF)-3`T(#+x}$%i3>pX!9J=f2N3eqI?GlcnltS$Y%Iv@Q||QM%qBn-CY#}b2Z+1 zdx)t)tNXBT4i4v=RZ}jB)m_V3eIHMsZk67N?S8p}qZ?;hNa3X`UfXGf3tg>_^N`xt zZ{O5()%c`bEeLttug$+*XH@#;xa%VyoxJEG1inMXEV_*SNji>ATmr)c9?@M47I@RS7|utXF+(OGqk{ZM;d2! z(-rMtP?9A3(_loX{19?bgFV$pO)*ax&8AF@r27d8#XC&7M~$@ISi&k{A*m zeq)r&WYSep5fAKEcmT>0qifRG;Y_vjX?)|<8~t?StvH)8=c(`2nLe~!R?8}}>v5T4 zMnAE^{2<}tQaPHjP~^TStDYmscj)c=_P!%`hn8}9co3sn^RPVA&zO(O1N$~w7@m}W zHSFKkn+&*kP)=>xKC{7nF6#7Eu-+#zIk_8@d(Ej==PPNeV)31=VB?d90ZVzz_!t3H zsB=X*a)M)y5x+wV$yVdy{!w1-iCwk8As1j};IglZJpo#?J{E&`*Sb}I@hz2zi0xE^ zq3)*wwT(f2)7LAlO&G$0US79Kf2)<9PK0V({PTCvp-SWxP02`|Eq{CQU>ipj|j{pE4D5?4c*!1>mfr{-#`_YuUAiAwT_qYN)Ik`WID?N zh$H!RvjYaL#g_@c-zC5DK6=!sDAV5mqM7ji7orUzl7mq96(8jfF@tg_B%_{eCa*Y_ zuc-df9SBY`gE}6njQc_F-eE~luRAu`R)vidBh>B-rH$r&@H?0QV=DS_15Hzz>$l{z z%fx?THlUb8dkV*7Pz|=LKA#`1yg)uuQkp=X3r+>8q!!EKh1Tzy`1i_AZJNxoQ%Ww0 zyq1yxca~_dqf!Ub$`Z1@%%6p3jHE>q^aT%YdmL>|Av+FI2Yzs|n3CO$z`HB>02KO? zj~{zqs}LV*3ucgAq~bK}q#)}^MsZ~{qTxiT(4hZXD>?oY*0r+OoIt_c7$3e%9UViS#VjD7vGBRreV4goua;dU*T>sNd6+$8Rou z1&M-@4#GwL?%BK6$-u-^YVZTCtXTGeMk%I5lAv=aQ1FQozCVid?beQUUgynIGQacf zXdRd9A2=Ab3PKW5eliz?R?k`Q%07A}>9;>_g-X1LVMn~Xf7NxvH73p4j{Ont!*JmH;|YA(#-Sg zDmdXj2|BYv6ZvQ9mEY}J0!rpiZU8FT5NLAtN1%kUy{_D1D#wqdzDS$nqP|Fq*h6mf zqu6;w-j|k7+NqCg9^B|M` zY$tid^d~d)g#q_}J7~(bWuvV)R6}$E4@jN# zwz1kreL;DBe7@J)`W?|YQ5!tlRZJHA2e?EjAcJWHR?~5z46>ABK1pyI(oW|3?Z{9N zoA6d$z zTum+iB^wgTH=^Ts6Vb}& z!CI}0XERpw23qD~PUk=mYRa2t1yjpPyE0aI^oi zh5E7y(Y%6J590WV2)2nTKT}26-h5% zC0>fxylkdoGP#pl2Rsj?;f2dqw3nR*WM0Dlw~~6*G&E#@twf4M1=?HBUJ5n^;oL?f zDR5L_=bGm$l&{}@y5LD~_t%d8-QWXpMbv{wP7Qgeh9Se9a=gT0ZxD+YAo$mAu8|#4 z6B0H*rS?XWtbd{q-wN{K+F&FlxP7|?B>q2h)$;c7@aS-d?Y>mnj70+;9tu^oNBHBC zIK7gOg@zx>91iFeuuHV1NsI4{bOOyETrL${1 zc8_@f9xwF18|+(*T+1Ja8zUbC9GC3?+e|Anh%m1{Sx&5mHF97c&q({1bDa+9YGaVBhDy$Hw_Yh;Ma(SLl7g`?6rp3TfZ|fupC<+Skdlt7->={49qP{ z6+PD}+dxh^SX({wXDr{!m(+(Fu z@cr+BSmyI@xne`OHz0IBM{YACmpox4J=b(QCzomY9jtY6hT4t}89lc-jMRLqAF3{c ziBfRdw)^>`gJ1aQp9*%;gqi8rXJ_T|d-~}SH4_1fkwUzD_v^j$D?!O}!PHFwv zj+?D=ag0;iO9Cdm8E#?7-i}u&g=@kGZ{DEEjsRx==6^eMK=DD_@_r=%PXlAOld*y;=t1F`D7s9 zlUG?mQh~5~(8M-Bo`i%18O`;db1j_gg^QTPye;SyfMAC?3pN8SF6pn_mL27lR8|>Y zJ*Nt-@S^D6RF#zrq2p~PSAE4qgDtWOa(b5Qc<%ziL`z3ckM5zr_2v$Vni>v1{tCeR zND1P!F&u&5Kv3NHtBK}Npy}d#l-(jwaQI*mx@|Yd;sR$7xsye?K9drV?sxKe7F|C94^7~q5;v@U{YXHYcFrKHe z2Q)&}!me8r3zdsKq>X%1{((lsCY6BcmjB8#AHy?$DL~4R)~GsmSYWkPUG!rA#b1|N z0nC7$=O{HUo4)~b3=Rpor_QA|MP5p0zwAcaNj>>=+7&Oq<0l@rgrn~4IB~~GajY6O zmGQs<*^R`B_d$zxds@f_TmNnVip6v=Yv0$dw1WwxSQV{;kT?oj{J&+bPc_y)77sIe zKd;HWDoTps*gh>!526xq2!goBzFODUfS@QH7W@-_HD3O&WRz2CS^o7z;6fuS!9~7> z;?1M6>ndkf1{?Qo8>z8e_O$j-96i`AI}8{Myg|pp5sV{p?_LN1=5O$qy$x(Pa4P*s zw=X*8=H`%*5mT-+kj8XBV3Bny*h5IpLE!0Knms@-sXYJoA~(dN}-@Yxoz+@nXg9?iD)Py z8{YI<%*4$EkGU^#L9|WOSI199b$4>A_4!HZb?QTE)6)DXY`^=16)+)4X(UBcP0bNY zQkU-bLc@CV1({p|lo^n=o3HVY@pb(H@x#RXtND(`f2rWkLkvgIO(*fI^Qk?K6Nx)X z_O#!;N599~S}SMzb!+@f>3(5-l7L7S>8cwt2hH%q$g8hM&RM zfjUvohoGJ_hui~5)5cIh`^@nr^%2X?)>PoUMB;hMwI=@Nd~l)~&7yl&i*oHx`(8S^7Kk6@_14gPLbFxT(r zGC@3}W+W6pHP1O(-$j)YOa3si^L%tlDf;wrkq^;7!k;skhWEJ!JY+BF58wz!fhxLq zVpBrQ5KJuUMSA%fB>|~Ery&3k@n{rse76P?#2A?e?6Nhf$;`e7{DWCf(l4MwyhN!* zJa}JZJ!7n}wj#^X4>;pG1#@Z&;x_B+>q}F65@D_f7R0oyR}a};ztl$*m}(PeZWy&} zit%VUTFX#%UcJp4Uu#^VPL!N=*m-Xep!MmihITMYLYiR)PMSW4potsC&4ioi?v zX_H5j*ZZeA9jTAqUwK2*f%tD=xC;8USH+*I`WoS?Jb|Du2^pE-wcL6gTieHWD=RCG zpa4&R1_tag)x&GwzKac9@9A6sOSvg5Xe6ZuSTiI!ThG_~A<#`3)>VbzxvLt6q1;3T za72}WB^Koc>doQ5W^FuKnVGv_e2k2YOv5!>^ZJwIT3-Ir?IqgodqJ<6Ti}(cXLj%_ zca18gMw4gzaN>^d2Ffs!WKA9y-mlgjSgGOk%}0dYg&vjG0$S+Pxd zR{zk@_5~aSa0FVwE+$Ov8$EBY0)IiuYZ3Y3?0f0a3nG<+N*B%`#1@SY6Mmo|{`a@6 zH(}T=oYOOBypYgY>*PV?&_})~LprRhyzqzO zGUW6^oZ7oM0o^pE>5^y0h^ z-Xzf8f;1d0lsIsymqfq(>xF`y z3*caf`fIJNHQeNcgaJcV1w@2gK6?=RIbT@2WdtIcbI_OOM~~1Mym@;KP@ma0ir0(K zG=XX=!&bP=t{PXesMmyp=vfR zH~$F>MZjSZ8wzP&N4NNQP;er7)vD{RFlN_BLb9<>gnY%+#N>f%;nqFS1dpCXjqn9U z(KmT|E`i^A4ak?im}=!oCNZ&8)`~VI4ubuw7wmCxm!oD63%WRi1beK}R}2L_L?|}n&Z0uX&55R5&gOpwv{vJr9caoilFEs(MY|>++;3Gx5!)6Zw;0vhi zix*Dm&GnIDWU&wSogIB=ud&RXI^#YScMEOsdl^XfDpE^I>KY2j`@up771D-ukK^kj zPxwZtKu#cbCQmS@q#@PIZ(m<`@ntI1UeZo^8Cc`o%wzR z)y!~0F$`g;gI{@B)ZGuRGW6our2o?b#3Uyx=;$QP1mD= zefH5+mneuFPZDtS;>j5blpzgd53ev+7>_S=PJKnVq>*q3IF6VFS;rY_PL1x3Z@M&`@5;jld%3nP#fP6$!E%(n{80ZbVm-Xz zJrGgI77*~Y)>3dX%i2D;2!~m6NZ1NeLkq%^FS4Si`1-19!X3QCYk$6Afrw=}ggIpv zQJqgstCiTY8Gkl2F+tgZc6}FM26T_hEjWU}HOG2h5Qf#dX56cz7s;qn^sIiByynP} zHB=I2S2^tlhZ+IXi^%>5Up%)5lNPtp&tP)RB@{OG!v6wPpqBts(eU`o?=_am@e$0m zQ$1ki{Qc_7Uc<`g#3@_ruIa`_ntPWonhvZbszy@rua^@RD;)7Ss!lLbNTH&{M8kU2BybGB*fUar>tno){}hX-}40-5OU zb3BJN?X{<1TYvEKE#6(NoWmnmrKF>?>EWu0%{HTwJ_u?+K?oiYE3!`EO>1Mq*rGKj zusk&bGSC7GZxuj$@d6I}!Ta2t8-Yum@iD-N01vseoW$JjVN`}a-bmj0p1CZzVfd|3 zE#{iOn$kQ&PoYEK$&edi;#0r3G>#Ih{&Fn`j%DBG94fU6ka!7%)B&LjO7$|e+`b`2v!+K=_L67;Sa&o#f<|2q~F+<}dJ3|JjK5D254!^vROQG@xy1-!A;>KDr78r#7qfPBFqYhMEJpDlb4Qv}aGm{*tG4;XVNEMkzF z5x|}XP)^F-u1R^MB33j}AWNy8@O({>zcMdRGff&pKqbQ|8FZPI+#5Q#-6t{9v2q_2 zwc|>^y|oD{QDB{z`1z}*E8oyIsj3~|oO{4jvd`S6*J0FHIz%rGF;P91fdVi=dpO); zt1w3w8H5L&G%{Qe!i%l~Br9qp?3Z+Vg>rtuRzdu6h?E5oDhRwd3y-?Zyf5AhrUYH5 zEw|cjH8oSFXKMy|UazZT=oMc6JjO zwSmm1F^i4^LmAJHUcg19fH`?1;f|^N^6>j7hg%dBVDivK(wlIJ+0(v%CzV!Kx`P3Z zU~smZCVY6AEE!<0~~Dt5U~Fb|L5Eps;wW^>pp;S&)gthffFn!gGG%4 zgY6e#t~Pyx<)bQg>kpgcpW&l+L=mcB6BYGX(!7a{sxHXty5BjmVX{SR!oj{zQ_^K6 zYN(qcmVfMebIPOV!1`%U$=LqtF!Y+Boq=JaD)r9wABR$h5q$xe2aMoSId8l=x`Jv6 zIXi#0x1S}ckNq?G>Rdk`%GR~+iURVFxwjOy29R8UM0n}dd#H_GUNW^HaT|zN8)`2H z0I1*MQ!C2IV86qsUIqvfeV;J^u2>xiEPCv`Tpci&Gc#r0CUgq45M>%l892czh8dputeIbG$8CnNVc6h{m zc%T}H1hD^4fi{2Uv(L?tm1>#711&T{KMsg^ZHc&Nm0dv9dAz#tLF0H# zlAPC~>8|Uf@)Jw)15tD>&^KV=QPR+I{lK68%6)Y9$y9f=Y?)U`^cTZsi{zcfz4<@} zhRJM(DT*EJiUp3a}p|N@JU`>-@3SU5Y3zu z{*uiyqmI6wSusflobIHeUTz-`+c0Y@KnMdpcIF!`9n~&mH-Z(!9rklIyx1<9qFs2Z zf_H^n5SGO3m+EUHO7MgMt6H;oJ@(I)LIUp`^a)E)F~V%=ru|9qDs^;ao3qeNZ!Cg4 z9)X1*%ltM8b-U2(#>c9vv153qo}C+cf6_k7-vXef+;*x)r!`y4n|Z_A5La#0!P|KJ zK#^v%*PUf}cPVHhCpwl;+9IgpFI7;YF0|+Z!Ho*cPLtx;Ae9Xp6CU}eb3}-90H7ET z7?@z0^#FNcIh_AF*yGLKaQUX83sNV;niCqhelbGvdZ(`i-?&1{d%ROIcE7m!r=Yw-s-b5dXa}yIGt~hDiD{5LPz`4@h>O_S8gwLHx>S;p zy6mqiE2fIRVnv_+x#?2diyOopwA+d{#_^HAdCB4P5spF0s-Q1)&T#cELev{0KR=0V zv>T*6K;e3$YSJOBnvynFT>p&?>{Ks6b(TEL&L2KB#Zf?48|tgW8*(J|rFdCQ<7k+U z^)2#{EqV(}wSGURB2bU7K<!W9p}Z^IA2P<$n%qUs62!0j3z$;6;p zzH&#?9^lQ$$T(hz6x(g5^{DQJ>j+6cfvKmysJP5jfD0unnYE0fHFexxt^C3Z)Yz-qY$WYxL=f#`6NFl-i-5iH+G; z>E$HGNa0yPFiK1##N@EY!y{?)rTp&4hYm?A6-hnPFe-|dcu zoQi-xYy0^js+>*_5yu@>!wtWb#3^lYYZ^@np8dr%{}gjeg=XtXlq0_wuve{rQfKB_d<*v2;s07%#sEN>n1f8_=-Co9zyT#`#q* z-yJ4wPWiL(x%RrS+CYzewKazl9Sz+QW#`2%&a=SpfJJqH1DFh^qTUsBnoY1SBq;k9 zy=h*aUgex`Ne+w;z*OA!^HPwTg~V0@NhuqROzoNUUO*;=Ow~9KIMzRvdf@U`L(t_f zBy!AD*z=!GKynUXtlfb9cTcXvJ@Kf>PZ7Fz_#|^sMw&r$DVlm8L{so98&qhK@mk!1 zP%C;?)=(&XAn*&aBpwg&?&;Ol<4zxObY$B{4we!uU~D5ZojsbtbZ6fKBE*3v>`Erw{f%a)~LRD{xw zkWkSeTV-EUDzaot*^9E5oyhMzeZIf`>GkUKnVI+UJomZxoO90wAV(=JE!~2KnMHr5 ztor)d1rj>V2S*#tBi;jKF~N{jqeR1sWn>-Likh=#>kl8Z?zx&8a_!phCYC{yE5rAL z=}_zU_GEdF=;Ikj(weNw^B=m~PjVf(Nt?c)+WEH_By5=S>`*_fmLW~+c+Ur_Yu^>t z=kO!z4+tN_$R>)YZ2x-EY3J=94D0p^cu=Wnbq`&o_VN9%!5x-`pPuQ9@lwU;oQy}6 z*2>Cb8AC7)eP!RY-@4Jj@`@QdQ+jA9uyR?}ixb>DC_K2N^V&0B9#SEpP58U>d$Whj zx1U-Jn$=~Xp}t~5N{jKRpm_NR{=xQhs_#mNyj!WMsUrdA_`vk~+EmRS#%~VGQ0t-f zIL$4hd=Sb96rAy}LSoi&^a_Uq?b{9?P43mZ-Vs$BV;-{tfU||*ZN4ZA!^6gg_o}OP zpDNAmg7yy*h=+S8+1ZP2s6TDK-8j5}Sp326@CU${(zkB|e@o+@=&8r<^4Zm8ZN<8l zc8`9^W6fT?|G#$k^WQ8Sw%9amf|&9kP{YzJT7u%X9OXm0zP(3!TiI>lnuesBEAuPE zvh<~o%9eMFpp(S83drUuO1mHTUJC#&oIWYK!MFDnBmB*$N2>GCPofEc0Vp`_evXRn z(eC+xl)dxxts=QNxft~7jVw(rs9)uw(cD+pa8dVKSp3p`>GOqm zJ+qU_a)|djA_1GGc4%5+fiY6V13T9)=b*Cl61)kfhu*MRZN4zkqI}$fUUbcDbE3ba z57(I zSLwO766pbS&b6XUZtq8(Z1Wv2JI|lby*4Yg_b2DK;&5JWP6;8+C|-Vk-OF2eV)@pv zmGEiNPps{6X`I*_A2@jPGUZ6loj;MaVo|-ly+_;HyoS8myl}}&Hr#oC-jP}?kR+Q} zANc-6C*CSCmL;eu!uP%fFIO{;%LL2yeCg^-V8zl3*_dOziOW1y`cK>zGZ0eQb!EZtmtc!-Q(Nu z%(3p0)2%t}f?!iIfn<&Cb!Ke*(pNfP3l1{)RN~7@uGxzGJk}KSh-+*`{us-zc_GUe-5x(zPF*rHof8*+K-*Nm zCvh~tlly^?w`X=ojeb|=69w;G1E+`6gLJhQ83m1;)$$W?@ldfD%q@yaEBWx@Lj-)M*=bjHcJ>piQ*<-0?|QXyAB%N6G_;Hu!{Hnt-Ybk8 zms?&LtpV8sJMZ(GP7U=M+^8zw(9X7WlktmBzQZh;GjhI}Cv477ph>+j@bjsCmZcBm zs50Z{B$nQ&P^VcpADtK-rMAP>h`wbDN+P0;0D4$B!~Vcmdb1yK0HA%_;~>WT`n>F5K5A z%~x0KcUw`wS@F%LY!+{It>2xIbMFq8tLq6Q>2!M1@a5WdeoQ72NMP3OX_z&UR@1PL zrxxB{W}W7nDeHlZH4cY5dSR+34>H?&#md}Ip7W@6J;=7mgcWCeCSu%-x#!dP$eyxd zp-ry5E-^-$3`0XA&9t%-MFkd%g2`>|m+ajfF&j$F^!PEJz$DFz1L)i-nB{>MDC<}) z&?_S3f6i`?hbzN^Bk4_h&C#y@Lg%d(nPYr1V!AF11D9Dd>I5_`ksm>=LUC|#AjY09 zJ$#VJY)^7!v~zUWUojifGS6|jc5Rthy7Lbm9Nrp$OZ`4`jV%k=Q{Q%9e9;+?cHUFz z2e#=?Ox%3&KrJd@r%z_)4$9t;)$2EGxC$N^b`OV#;$QXjXh!ucm;E5E)A7MX_UrlV zR)x{wVJj5IpqQ4?Xkzx`S3f<=Xt=q-_Q__E;86UpVgYQNGOn@+ZmXG}psxg81wbaWq~XX(DrRc|k2)SU>*#?wmQ5 zapqA&PDsd7GUXcCA)Y;4F&x3F*krZ!mCJ}SGzbJs=AGkiBh~6M($gipvwIbc_^*KW zuR+`7L+{~z*w%JNUOltx)T9h*g^i27@N(FKKvlkQX!}RZEmfW@3d?NxcRGZ`ci9`rz1y=5}=ZLx4mlDYqaJTx2yU+`4X*rXUC)2WuiIBMrDw%1@w( z=H}+yWf$=HF3ye_;}x0?IyEh*Gwd?F_j?LN8oR;1ih=x%m33^*;5_g(r@;CG0c`*F z4b4~D!aM!dUh|*xk%}8qee&XFppnv7*(r(db4Dc>YDItj+SbI%-e?u0=pV1)xZkpo zBMGGK4D2S8OeX|^OYFE7r0mvPA!T@>&4tabo+ZFyS*4jE!~#r|-Zk^vcx%~m>RhX!W% z&eP1@+`PTU|Neyk-M{ypSEZZID{NqL1z>efPEDbCZI^l}d0>D4w9Rev96f`IFH+4> zqHkAk*}0iXCkoTgj}7+$o}ZUSDBqA4fjGOQBe_ra7kVM3J;%YA zn?u1(rDK<)tb!#trwU*?I52hqLvUTxmzU=>+?;3j(6e_V;>skXV<=19_e(Q%Gwt%~ ztq+uc>A2;1qwwbSsXPJw0H)FT1)@ooiJ{NMzw4_-FT8dBe6CPo$Kn9#{f?e`jeZ^d zEBnyE_ViG+&iV85q(0iQqtWtWu5)&$-5)%DqJW{Os;W}Ffw;gYJk7B~O?k3?9*)TJ zkZx%^X~9iqu(w|U$-?tr_u$=)rwcnl%_r>c?L}-9LXq59rBH&%FNBH%o`+;i1PG<( zbxE#kx~G+HhKBClzkd;2ekNsyzk${~4&~L=umehzjt#z&nVNtKY#@%77A75OL{N%%x9?elygk7`m#Rk{S-amNi)OKOQ35%G>#c_(U znZC_Ngq2U0EPy_jNZ$Z|)nWqxMf?CID6u}q>V5t3V{!>aiX-Amiq~5EOnrmZsMQv< zLmPOao@MxU7>+Vz-T*jB0*nJScKj7qH#+rVc2AF9DEAr?_cVh9iR-)5-x&{dfd$8~ z&+aTY$=1DYk2x1hGjjNSLU#YnGD>z*Vk8zc;wD=v6ORcxl&H@V$C+N+o58@#LaK_|cDR9jdKwQkQMR*Kaho4H}b zEmIpGsr;TWN}u50+FpBjYh%CS!%9DspG+HN*lT36V{sD!(A(4S>LhsMf2f9!zrTM} zm+>Fx+hc9Hjvee2?9c7WiYS9|+31^#{d9qK?NQc;>Xy%_?hVt&hsI}?mjr(sYXVG< z1dM1^(XFW9y?4{Oj>=7ADjQC?(5Hfe))n5@{F~Xme`jgC@BWe93wUJ+M~@6Df&C$pj`B4=llzPyUPxS-$K17GGcAO#U$rF4`8a%KrU|Yp3N_?65aG`>hrp zk`zn=xbEtTO|Ymr?9-{j>$$wn7xKOq9KQ#jaG(HH0Ee33j)^bLKPz%F(k#LL07H+T z88Kab`tXQEYi^|g#dt97eV0IQL{{JPpKw~=0xAUZ0~p9Gqk!Ead;RD3X1|?!RGn~C1HWLE7y}N0;`h9V$Gxwr z)pH^+`J$kdbDM0omCL|MNr9T@$j9r?dU+BcOCtQa5dIf3;8Irh9x)=uEAZd;-0B`z zz1_38yUIfirg<_;v|snUF{3gP;*}ihW4h0yNq2Fh6YKzi;5^1>iLwSQ8N1E0&%G(O zHqd1yn`akXM=<~bp$JjT$=!VcolY-$XIh9$fH)^O@0&nij^Xy<C*9BCC|}gVETwc0nIKuUDzekH`$Ag*_;%< z4pJ`-{XigN|Iy(HnBfY}8#Zp-NU+z!x!Iu|9-M=vEzia3z^J)H_(15yNF}fPkhM^- zM)rb1a9T3jw3tb6UcK$ARNdU_Ea}$xFBA%o&^`@SgHCZNlr;o`lw#!k0{gV0WDfJ{ z2x~_)n_za&wB}{27mO)ByZSUG{&axNr^nY`r}`8Y?gplC8tZ<~Nd?9)o5OW3zBfWb z#2~SonekrRqm6t$nEpcXjjfzB3Z|KvnJmvS34kQcpauyp4d#niSeRk28y9?wi^-Wo zZ@z!C=Ue)?=00?I5NedX=x~{{d=Q;(@UU)}-vObezpVdVx_&`?a** zX}1yETX~P+bq}5j>GxZYm{BIDr$1#opY}iQ%+vg-JAcb1Uz0LArJLm)vF{56*Mk~2AZEalc3&X?3Fe;I{FwL_g#T!?IO7t3FR3# zgvXymHc@i8E+Wp2_STo16hLKySwW{Ou7%vVA$PG%*<6)}itv&kw^h={$;-o|1~;+O zeK5GmR*v}@=oDg?GbIcU1<)?BR(@qAaqr-TTEBjmnin)3uMpo0r{iALjC6&z?ERy$ z>r_TK#_*(PWHeSt4gkLd7w&XgKvL3fhI5K z+L#&VymfW`{QMSmzUhlp`o9b5E3udM8JFt(`ST1+Y{@PKd9)+RUAq>$V1dQOsrAPq zZjY0OZKORjv$G0F_29dJ##A1DewVdrA2&1mN4NHV&?wxN;x{{;xuUP?-8=f`&DT*; zlhJIXr-9g1KubyTzjf<|oZQ@}U|2XgIhl%n zZjw@h93{=%XwwtJ>>};jU;ovTnJs!eR8=a2C$iyOX6F8ZWRImwmm5=;3z^LyIhzFY9>xde4z2V41b(fuc-Lh^QbWoM}pb;i%j%~uGyQast_=jD0KZ(Qlt^L_GH%}Kw=`;$>0Gmq{xef z?h2gK&d?m{`_|T}Mk9OajH96Ukq?3SgZmq0mfU%-VPX=tChue+jhD9=Ifdk`9pmPh z_{^{}ZdXiRKC8J(B2Y+Wv7;)FYKohTeW6qKouRt#Zd6_`uRhub{;M5NBWnaSvyH!R z%`#l~N4qeFK2pM=O3i;|T6%O^N85fc&j-%bI8C#cV~IH}!-@ju203C1ME$IobWSzD z*9D?+NW}b&0 z-R7Mij*H<_CCN33lwQ01CR@^9M0VKn*1G^@)WSx}WYHfUKNQ02KieWSIqZ=m2g2P%y{*583cAiYE9(r%>kr&0Y9s*ZdG zbekkWACSLOZ(hiee|xcmU=W87YU&Yy>E8wi?fIj5BJ+0`dD_`nc?Gsyh->L6Xtq9L zcquM#%-;QoU1Z_W?C*Z=-v-(;So}F|*rz4&bHGJQ&_T`JJFq6$?dhb1I zWR?H`LQX_6jk=uv#qoEirj&V}7VhZx*l!Mwh7^k`Jat$DqcL=99gb#@sd8^k^41Kp zn1}Z^z3a_0ZvAY|GKx!2K`)>opVqy1ujE_VL3^7}5A7E$+oiOn4Gs|^37?fCADUBR$?dDO|- zISy8lsjOl-X(fD}j}HYS!BN?@N?#8vidSc?L#22@YmvS%7#eBe++HGSuCAV8y~kDVbX;+E zGae_kxb@KiZEcQr01T(01GGZ^HM zrQF)u$}MVdak#!mapRKBA7=0OHHFj|oeU>YY1_~3QAGOz^b#GX;t)A;-|Eeg9Xw~g zK)c&!A-+;{^trIZ=~P2WsHn^BtuZ zG1~)n)ic|zjO0HzcLRRIz@W=`Rmy*6G8SzffeQt}2-MWon$o`M`#<=|q}Pd*cHwln zsyxt*__zxhEYLKXPuoSs_xTfYW!5jhc=oYAfG8%4P6{d7P|M(O4UjbFDaBb4Qz>%P z@C|%Tz`vMZ7&AORh1vjhqne>1+$mw?NG4T~)dG~?KO`hXo!eTKN28iUH9_4)b+9Qz zj3_Qip@%jT-c-Zeo*2*7l<&2JLVDQ2B)c_T7Gly3Vi-K3x%8|JIeoJ@LWy<&F@;w^ z_|1;o!VXZ%i(%mAvwODZ5RvI<DluWm$_!~2^%&kbN}wyyC4NHCCg>x? zXTh#`C#p1R@xq$qK|s)iS@*9ZGg9Gmqfx;T!$v=pMXy_iQ1uogB7^5>7}bMJ)K1CW zDdS%T&ROXYGmkVVKqh8+_E62O_0GicEdShTkJ$@w69z!fP@HDRuu zMXmW>OSVSK+6W?D=mJ@7iGf`da+sht<=5Pr{;sF3QM2{$`U~Fw?k?tjbzB2rloQ2F z4#H(ab0&RkTR6h&3H(~K^C9Ykr~eGRLqktzwGLcCIf_g|Lr?EknwiFbPcng{+|1Ar zsh30HtYDk>$dY5uxn-rLAn0pk{?%J<13M`Mp#~3YYpYHhCi+j%Xh=fg{j~-97v#T; z|NpYhWNrqkYibdO72?0Au4&kbDYgL}H!fkQ6jTI0YZ}NzTQV^OW5J+4N2kwQR6$=->MKBTJ3#$t624&Ep% zy!52R3m_bx0;(8%_Ae|Je?v~O?R4cTAf%}#Nnr=&cKpSH{5?F}2?a`7ZLL1?5i@FL z&URVK6Yf`W?iP1fv`VWcs7kgpHqtCC+9Ebh1U4*Pyx7G=kVe}J$|P#N!=L9(wnWm8 zle4qCdxMxM7IR|f%7nN9@s}?wn7aBQIts_X-aAr#vN7f7B~3l8{rjx|_w|3xTzcpI zI)!%RRt%oY4+O_@k66rE(A*3S6<||K3T8AuAZKr`8RBH>x@$F>;*1%0u7TVb+|@~l zwuss3TW`=v|LqEn(q`+I!?2=`$jXu@!eGF4@CPrlei;~s)$i$%yjLL9u<_MUx8hOR zp=i4NvoIPze=5A7$c6!bK~!0TgM(Phyw0kQswciYpv$Oig>4|w*kGeLe}Bh|-h2bq zIV1I3T6*|Z_lHJ{ubI=R_Uj^unuKUKz?0BH7^mJUV;tJpH#AfQR>ChOB_;UD|8}5t z%-2xUrmljGr-f|K9qYS@`qP6RHyeD(7kTAJWxPyfX? mNkk{bE|SQ9KZL&xxaO9I<%~69hN=_=fA(qWXgpUt#{54)xnK|g literal 0 HcmV?d00001 diff --git a/notebooks/chapter18/images/random_forest.png b/notebooks/chapter18/images/random_forest.png new file mode 100644 index 0000000000000000000000000000000000000000..e0ab1d65808356f1b80b09fa90ef6a3293aed45f GIT binary patch literal 190008 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%0D={{DWzYen_@dgkU?IW}SI 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

U0Z5*M})PHsDzv}1l5|b8y2IG{-wF+Z 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

l8(D@lnG5GAxA#nq7K|zW>i%Jj1Oo zIx}CH&kr3HskH^=zYE;|xtMzU5k}TsS87kGyau~ldYJJEt>h2)Z2IO?pA2e{ zoEc<>9KC)^n{1SU1lZ^o@k>$O;mjp^>)nV zOQaPOzyEGDw|ByIJ}pD2oNVEK`{P}iZj(lw7>>4UomDjs+jiE?`O) za$Pj{p6ZiGH}5CrS}`l%2+H^gt?d)F8(Gj|XFoXZ;N;Ot=RES(XcLw-RF2xeTk#BN z`6sSff6}5`yN?*9ygwc(i6!2oN6m5h0>gjLK{*FkRKpS9OCgYr9nhmdwX5l{;rV6b zY(XHOd9l!eB{Upfh%*0oASVg5=DF6XlMwcCk((Z-cVxhSx%{Y#g8xRkjBk^4{-rEF zIo*J_Y z&c=`!gs_|&jLs_C7=!0tH~98gZ;3}!4joK)D6Hl3B@^Xhe8Sqa1>bd?PY&APiPdLa z9H)?9pirIw69*G&nGH{_A}~GqH>^${PABEnVMD6RLz&jWtJkMy(yjm zi5YaQ9!p6cO?Ro$G%&fSKJ`4|fpBNmeOT)L(k2e(5oUGV#N34T%sTjJgwQ?E!9~oU znlzfrKvXiBmItL_{Ahg|S%e}sO;ScK`9X?d=eAu>VgcuU5g(W=U@;agYfMAf#Yg;F zwug@t$XT&Z05q%;+Y5Ad$pbwkILzgna#EL-T!?<;<%LhK+Q$1v7>_#c@CjM98UvS> ziqUf?+)wK!8xr{ZHGDZ8a~~@IVBsh$D>`fM;JFHVpS{#Jns@#x9L{^P7~E2O(BI0u z@xT*9foT(Z3sjP7U}n8{`??>Mm1~S;9-bOLGsI@V1P3{STx&GVQ)95UiJ8(uqg(xB zTY=6t`3u{lE~~h6lxcQ2km2~m&}P1L^-7eERcc6^mYnZo%c&&(R)seoLN<5AW06k{ z|6?w((X#1SDjb>Qv7?f<{wwL8=D;O97P$yLNN{-!jnl#RYi7epe%WR~RQ_KFnXsJS zcp5e-2@c^p#nLDN3H_YRpy-gcra8{qT^Ti@j0K?Hu%994Q} ze>=o!=gTfPbislas3Sj#e!gBp!*z`Ni1*v`)SsG>QBpV!n*+2rWeBBA9QgVz-mTW? zq;`tAAFc6bzikxxOy6hG2n_Q#X!~s9NDQZpvA11)6m*$wDMJWS-!k=2aHrU1qzop2 zp1JleS;$0WK3$tErQbybw^&wIf8vWi?!^{ox6jHtpGw5=m%T_}urO#W6VRcEO+;2Ka0UNsB)REM4aS|dgv+C0aeVP%rkM&+??q@ON@>#qIk+KCBH}EGU;7)gw z|HZo}=Sj5Y62pw{ni%Y0_!yO2_+zn$%Z(!=NB;fGBirB&mUF0eJV`%5v*AM0Ux*a3 zU7%Wm2Ba7hVmJGFEweKdCC+xNe1s1aeNU_X#ru-;V-ddGY}k&?q?bdO+gvnArbv$# zgKEXnIqJX$!U$uCdyPR`-W!;l5pCbs(wq;S=RPLN8{oQrv&v)#N)Ubr0Q?-M%uTsevy+avf1H?3jE39Uj`%Yl z<;U&i#>=SB_U%8Q7N^4~Ij3xSf>nq!JbhrYodyb>t) zoWNcrI`8fjf zV|1{sJXM0XpM(Yw;9|94VD2{lt0ND8P9m6A|L0hZ_E}g z=OZsWksF0jbr&8iu_OR+|5WguqRc3$sEZ-i&iPqcEyV(V;-#Ss!NTcNlR%9xci<2B zrR;6eu1kLD7$fx^mll*5cX9RW{PpfWred?=LJM|4QvwKFNI(vpcy?*tMQa8ZPIUdJ zz(CxaDbTOzvzxOHdy8HiN&*7wqE9@n3>~sH-8qLs?7@pVs+pF_|G;QP?*fkXQMtc&^ziwvU@#b55a z*@nofY^cc*otp@1dp;dU6-Gx9KdGM1PfcO0@}T2CS^&ekglIS1DM6wgFRj5YpJ>wRQ)vi=GIA*kI>H;$Zm~+VAn)bDe)iDi1^hzGg z%W*#{PuMU7I@+=W@&w}h@e|D@g`n&b3CE*=WZFN64#DZSXk@Sqv*V*+J_Z*rZ7KwN z_x%jiCU&}Cq3AH)=BlXw-D+++CQ2XNyu1!ec0(vxqMhz^Q|X&8n8`?wwu}5~vpIjA zy;!TB>^+6hMg~g#yYR3ez<`AU>f(l;RMx?jC*-Qt8=LQNC#DCdPaMqWRykYQo6#M;mB zng@ay7UJ^lOoHBG>>147uV0eO2~V8t)Hw}?N~**q8iBS!0Y-a9LeDfv`$(^@qkHVX zt9)K}x+_4@FglI$gs^?p~)fPq|?t9^?$DP{Di z(}{g|W4HP|=a9#!)wu#SSK|@pwb>wNa!58$oh2xfHN^`xRhEkV>*rwU1PYya0{GEx z@&er;{GXa`7=Or-6pfTYOLxCdja-1EoFSap;1ldxIq2@NrFW^w5?q~C8sNTp-*WD?gOWS_7AtaCOFd|xO$}7rU;{)*C_+2rDwgHg~z=(_DL&8<3g{= zzqfTUd!+UH+!b+639_~q6Bm*;d8@k5^G90av_@qah{-+?Ci`67}9RlTsw zR92QDSt{z9U}6lWwLTpDApvc)%yVQ~n5aVlhFS>1L$}tk!Ym%(X5eKgi6ZX!4IHbU zq6OJ(Q*{((W(U;bSNpLj=bOy{J7+6CVOV_nHO^Yn2io7F%E}B6@TbE=%?5;2Hziv%8+r z&Ky;}1=x2f`%;7G@0{S-V$`(6QH<%uT@&G&f!04vsAHnVBW%lq%Ive4r#9)FA$ zo=|xwgDpP8@zU7*;3_Ied~Y4`1JIs?8UOEy2SocXI&Ltjr0}5@c)n$4TQPDZ5BSuW z)5^H9Wmpd3kt9oUx_iLIK^yYR$pty$#IJ^92>;++tL1 z7IU0`Drc<7<;gtBNeuNtx6v4Baz3D>2XTPfzyCFVMQ6xT)_M(~96xCQxQ=*b2hJ<` z2hTKNHyRjz$N%(#t*l?vG;URWH;UrAym=M-zwumtrv6qLpTiw z+QDHjypPAH*~S(zdb$fx7g^4YJb=?PuHr2@{evzjXyoowbXrtktg`15y+7YB@w@?K8gy(-I8jU4Rv0cx#- zJ22nv3pQZ3fErNk;F*;&60p9KT%_vcmBt=|_NU7VgO0kXxsMi9A@sj1ya{XA6O3p= zI`9&WTyzu>SSa6Dt^M6ipja`XB}5h9+MiZi>DFOSc55;ERAMd-Y2iy{ptWp&dO=VQ zVBo^%!w^R20GZ&Ei7KKE`Ut~q;F&d+0^(&M;OlF&8;rF3Zr4hROq%C7ktsnQJVTJ3 z^;5`&E^(Tn>A}}Q+xd?rr@fwG@99X1IB{@+Y8zx;Pa4lk=yMk7q+JA*&=qSAyz0Xx@Uu z{v#Ets4-LT`Xd`*-pF#_ieRllMAjnoyP^wJ1Z}`a-9!(ABjDAub)`@mu&g*4-x|N! z(_KMu0f(mp{pG5RDxe9Y6Q84gI5PCn@9^deRiNgs=|H- z8~wpZmxL7y>Xa@4{s5A1Br&>D014yv$5ILBe0>S<25=9yE8lPac42YIA*W*xE6KGZ z4A@Q0Bl}ZaH^nOHRi(PBIXQ?)44KPxvr_TqygbdPF8)I_{3N!upGQhdCK-b!&3-&s zflrS(bkcBRFZ%=UAAivF^K13v`%iRX&)lhh!D$~W+t@jTH%xtZ$Ti^0lBzTfLDl~CSpx(g97S8H336#>bkn=pnM>hj5%zZf@Uydh zLcr5CCSKBGSAP!+Zoz`aQgO}1Y=yQ_!B`G#sJN?hoOFn4YSC*Q`NJxy{Tp=E!!}Qy zr+Sl`hJbfYuLt zZ1r$gaYj?S9Tx|x82rS#*6W{NhL98rYVJipTf}_qRA+ZEh{)s3TN)ET@VQRX#Uzbs z3OUd@PN5g|I9QMrm&OGBE{@_9AEXkL4!LN~1V{&z)A8DF)5xZ%yL63AE@ zbJ&_}3@KnTi9EV(g2^ciKvCG@pCP=bqsDSkm`UEnA*(VFCAp*z#=>9~LQuVStQ4le zP~GVPRd19$C!ozVv`yrD+%EUi!;YT_NvN+Ur=lDOkq4J1WXmk+r*-%hj6d?q=agNp zo=l?#G^hEW$}ud;{}Tp2Q~g&F2f>%|AwX5S#-@x#F+OIuqA7A2fi0$4yM&0Q7CCGT z#f986t|>`P^q!){!zZ$ZP&a;$k=L3ARaPW@zmG~m_~>P7^2F7+qoG~tcQt%|bvGdn zCsqHJYYQiuyw`>ulxT!6K29{Ki(|xLv$2^$NOA8f3Rni_>alM{8-wq*o$w7{N%cz^ zy&6>)O$Wd5J+!WVXv`sDqJz8NTa}85|3ddk6N4{!=@r*J$T}B4XpGwY49fM?XxZgn6gu9Hi6wo3?WGWcFsJ+FkHzy}~@7 z`RNVJ=ltUTSk(1j&U&0S6V8m*Q_MTsRA@Xcr05$wu2qFiE2Zb3JXmfbn3l;ISg;qL z_a(YjFjhyD6~LZHDujU<5Uz78|5 zdz(F^5-`4`j3Core-APDoJp>Cg_o|b%4=ERF!HHS^S74&k&uarz)0(frX0{rlFDrZ zR)%)ep!yi>2k3Wp`sVee3<#}Ge2XX6=nqtUG;8$EA%^)({2z-dC65ju8Us3V=5h9} zl!5W9PRDC>A8G$@@voPY#*LKRp00BaJ#tzJ6hV5=Ed_0;l_%U^;UMNx4&j>y=~T`Yl=xaTUt%h#xIS98ZvQu=bkZggL+Z0Pf6 z78ric|9I5(UrJql!B9tk^n)oe&`u#dhtJ-wNGjc~%*H+y;X@UwD8~F|%jIm2G&=5D z`%8ogzf5Q{?xJUh&6O*N)9{7#RV2uue;E4YT25&*bWeRZ<*-o#!{M|hp}V7`9G_?E z5STpP)P_aHbNHwnfHqUz>~QSLxfn8&PTxQ#9ivt*y?Q!}lfgsuKs;hO=towvS{nsP za_IF`U#}%iMyf-4?^lMBV;Qn~Gy@kQ`1vnDWORiK@4PyFSLvFHuw=sEF3LhI>YLaS zZHE7iuJO+?6<$m8p=9qldAl2*UmwQV;y>g=DiDn`Jr}V=tqPZC5W;`C)+mSGU`6qr z0^pYFCslT2)M8i2y^-ryElArC^?GLTG z{ZaKo-xrF>`^{U(LOW=a8>%-@8Mb-H$Wf8T%tQ1Si%Uh!(Hf*#4vd8#)$!sJUDr9D zxtXZ}yiMuzy#jUA!fE%aC&z&8Hkydfvx7xx5Z%y6JDF?z``zy1j)dq%=hO54k;UHj zJG>riN`{bjz?@rBhJ4%r#2pdn3F$)vc`#gtXJr|1cLysUep=m9>ZQb=#l2YrzXAAS z=d(B*jGp7Cn7Q1FjdJL_bk=|NQvQW`(o+ zy5Y&_f!Q@maJ`A!tC_KNp>R09qJvmSUeXZ`jR5BJe;OvdJXk3r^V`v1`eG=f;{mI9 z`ABg%f??586{<%SMWgV;jv;65CTvKBXDYJhyfCi=7Hn4cQ+vSa!`Ga&fGc`&GHv}# zOT0xQhaF05dHTUnx~LA=7b*LzZ6Oyh$#eJXhyYl(r&nH7}@R=sYI7gy8+^Q~TrI4(7~<6oq~nwHy*etEQicE7xK-dpTYoGp1> z6JYA4$sf%jvnlKIaj0uup$V$7U|dZzOI_KEK3cWPf%h!7JdPF^m3H5FaoZZ>LG$*D ziekv?Q{hz9H(uBQqenvGG{=c9XwuM8?=bQ=U4l{Jb$yX`BPD9dUaMdj5CMgYHdarM z;lObKX2YT~HmOv^z;L$>++Xws5*Nz6gqu%>Iq-W|`@>&C#fg%K54;S2E z7l+T6uC0HjV>YYrmh9vo~M-$^3O`||K1{0FbHeM zdnTwoCl}T6{8Zj`GZ9RvipS;99>tSFsY=pa71jCcUsD0DCg4z}^0+lzd$5u4PT)K1 z{T7-gZ_`{AF-2V;G89;)hBMz>TO@NN5`OrH{?7e~UK$fM-K*Zxg41vj^y0{VEC-9n z@L*j)d-NWt9X3iz3Oh8k6`bFfF8Q(m^axg_HJ$?qZzQ|bJq3XKD(7^FlNP!G>NZBC zc?0EbWwxaeA>TopIu@yU1E_iHy~u|HRQ|Fc80Sy_ohoxun~SHOgnR+|eb(7_ zyCWl@RblcDDC{&r6jC8*xHo}zbZ;q2bgI$A=)Qeh?z&;~$>HM=-ZB*<2~%kw)$Dt_ z&-!Sw2pElOGZ~CAG0?AJy(~J_*jg!vsI( zzch5%(vAug}xS;soxHZpseB|!*+LVJL^<_ncb3IRkknSka8lJew}J-0Mcd&JyVaT zHRc$0{UmtifORmcOMhV|N7Ef()R-L2_=u(>FS)3ysb zhqV7f-rX@|`1}2!>D|i`QY>tQC*ZyP?^GRKJ1!^ykE8pP zorH>#cLv>=TOC2hu6lyDiSDv6ES>aVYzv>mWJ(W_#omN+R4@W;mSp|iCsAvT?b8ot zWRhM0)rcEGyp6L*^m3`8mxep7i`gKY*MB4@yRH5}9B5h=rL6U=5YorLJeFy7AP)Fd zYnY&rceARkV(8nQ>RY|_c|S`R;=TS7?3_D9g|2nbbtTgm6Z|%1|o;x=rwWB4xd9uoB@MFQi+bp3DRGCVJ8mZTU zZ1PK4vG0>2tHtZ?oF2o&6JmC^*XtdYoGP>ZB|0)sjwx#WEDk7Kzz3|YDv4?d8rwhL zWdS`PtE>k_y6^e}%LFPqkZ$h0LUD7ks3hRPs?H!oRqMomtplW|rRFIes3m9Cl8RJ) zEf(Z3FeN9!Fo1CaZFXM%($=E8HW7)xSp`=)xI2`lvlxFt7nW37w`IQc*kOvjToA&& z`-N*TYi36$W@o$8nJgLx#v4XjOjv2Z&#v2$`=gUZ(^dhsoJIq; zO$>1al>r}gl3 zamCLxL`YBvPBbyQzEGV-pl?oUmyh0?47fb8_$bC>p9tG(kh#unH7cdfy!BL=Z$dnF<#&g@0 z5=m*1^Z+I8#alo}=C)+FnyLAP&Nq${riAk!bq5ywv)NQ&7V=%uIU;wbb9?OI zWgzKm(2xD*hzHklD9eleJ|M+W53hf?+5L$82KoS<&B=b3%~)R`D2O-X3B}CPds3!qc5;TC57oJ{yUILb<2 zUKq^s5I*pP6}f<(vH8Sj$%PMrXe~lZ3aRM2)=7-2m8<$_d#H0)c!wA`-}(KH4j13gz(y6 zhL8|IO$wemOjPG=KeiHZv=%rw>#Uj$exdX9GLujLTe9}_N~0Vg>BwGdkU+{sP)W~x z$_Q1f=r@Z|7plpE_U%{~(q; ztHP6%vgV9`Mn#S8TEseZ-uuDRSN{@6G62}=FR-HXf!TE-^wQZlBivCzCiole&<2&n zCTgGyNF4$Tp!ZYe{Bi=dx(8tcst5P|E%9m2+yv5dI);wtMaYjZ=@5(AuEa*;d`ceS zhtFf(RM{R{3AOmGtzW&lV=~oc8_zAbLIT_^|ou+Xht} z&S!OCrnPgzf<-@>{A(w;-WQU^XeU2Ya}13!0y3=IlGEV*32N#)m=f~;t}kK_cTm+I ztN_z8q#mB21p@^#x62kH$L-7Wo4UBiFK2;P?qSe?QM2` zeCL1mnC}h&>9^ADloIq)OBlix?AI2Z&dr)R7_Lq`pR{=)aqY0f`F7Zy>U)yOWRD=(a)n31fex~6V@O{`2`8a%b%+I_^BnX; zTk7)SDS*f7&Rw_jtiM+Nv@8M;lZzPAF${nYIiu->McpPkE|1aO>wCHR(@^MY=DeRe z424>oHK19h!QBVYBOrjkfo04%1d_EHNx`ry4G%^S+vZ9Ls4QJy4oBsG} z-KrOr1dHcgAcSvI>@7g2QPlu$T4q1en^6}xGna7#;(2gfJXYQpK4W~dVv1BG;P%Epi3Jsyb`+;C zIBK3}AGJnOF8@J0&eiF^EaD38aqOy`N}(wv1C`eL{gpDGn9|VpY{{MFXc0mdN?ZKy zg$h%Q#QhEC45nQS68D9!vPmp{K7odrU7F-7$-RzFURie^h%CC=`PBA;S3(ZQ)HJ|g z|6x_Ck&r^HKpVz$ds!eWdyuzsi}=&CjyerNNl|{Z+pGfahJRm>7aM5MVr;k%$^IK2 zg=dgv2w1?FFM@{ffP#Sv@lRiq_|eFnPJCy<;U%ZYa*->2W(gJ{ieGQCACFi zBL>$$ND9d-%5#P{J8<-e%4@rAbTLPu!>Ih%zSNmhK+E+_vWi-IFpsj@KALPihd{e# zFP=ntYU)l%$g+ehH<&nx=I1<};#w+i2s7Khb2TG zMt_8dHylaqFUHR6&H7*-1++lW^F{fFLMroYEEWGUwu%&6u?AqL?i|f+ov5e-0h$JX7_m`vUE<8nCi?v$?AkP=g9V^ zM#}d@UU+`SauyEwgY)|>UAB~MogG8DAB!uBv>d-Y+#cqwZLbM_$CRvK+B_RmAuWGv zUceUR8S)rAC`NS!@EvoRGlzOH^aBO5P^G?4t`nceB)TcIBdYmfmW~qnC^KUQjnn=c zx@6)=pdDX7?NbtDmnn62nu*_G z)a7SimbcEY2Ym;NQtJ0jK7R2vNmfwAE$B7;3@dwDGyUwq5O#U{yfhKKdd4V26pv;Qb+0Ten-*spc(G*{By0pn z$NzN=6QE2g_=%I4oG9^}EOdzl@WKl*eQaGhg=3?xO1? zI(*gHE8iznOCg%_8r)DK!B66*BY^2Sl$V=)Gru_ExdMwHSGG?$s*s&T8vbZjON>h5Dxhc`Z z#IWx#gtw0LGk*HOP;?#*)W<6&RrPdbYzYOtXo)E^rh%rdqKnYEVRs?4H1dk(BM+hB zN(Ge)dC+_Oo?yyJOi30xYhs)pb;x_0lfdLIHvYk|^euq4DZFQw@X4XbP@ymutV0fg zcxUz}eYYzr8n{dyM`kKwrPrrIPQQAsxc$6h1DVY_HPvC7gvVp|RW8YHFw|7BSWN^r zR(R3APP!c~H-4hBG1ROq6$wr!c@tAG`J)9Q=Z4G%liS6K2)SplgRYLUGBD{?_=kHq z^0}R|UBue|$P`>cW|PB#H=bD|5k=Li4E7;q+Ds#L-ZT(b znOh%nNL!nO2REF5^%t8I)I@)#zO~y<-FI^G1Cm5o`z>x9UZY=QsV!n7fTMIzvki8{$N z1Xe}39ff==F7$+XevZiULzp@n+fz+nyfwPlH+q)YUMi|FK?nA(donX-$JN50FXwmWAM4f; zf*C8*mX{8QQF2_R%j;+tT+h8N@|({{MCB}EPFsUM=hSy$V z&xHw*%NWr-E?$?GSbLXkQOninW@&esR7a<-F(u%J=OdZwGXtF@H0uH*Gaec@?XgiX zmbEwCeb(1cp|_u{fzgJ6wa?Yf7P>gi?}s@tz0+8jhCZJ-N8U6$3YkTcA%2ayWa4y{ z=UW$*! zIx(6cr(K>dWK{D_ToS#_r9@Afranr#r|zaV^5!{kF^7IvDZucCEv^&5mna>>)<+0;TU~GVo>!ec&X^lknG{<(I#S!aC?j)#TpA!}fIsSvC^d zOP>4X=Y(6H4p&Xn<(nhpVCB@8g1>zf2(n^r;aYeox;)+-&jC-3iVq}ZXcoc=7uoy$ z6*$RTUXShVc}|VLzD>1mo^8_C#mRATlhKe#K0A_lZJ%9UOzjNxDc@Yy%o;!J8_ZjWPD*OXf4;?&UG~$m<(m&r$ zLJ+1Xj(8$OftC@$m{|r9T2w1ZMq-rMM{Y4_(1Zs;EAb74etT2+pqNzRAGz1QPVcPg zF`bAfkK!5rB0Ks-GVqm(5T$W*czJxrZ=w74<7$%%PqF?xoWkj?9m?(bYJ}JJ#SqL{9?fGX{?3c7N=PUtS~P z-7jLt4gM5ouP)R#!l-+Y&$mwkwE}a0XB*u-)(0eq>okl}M^)t??C(|O?&Y|i9`vjY zob1O!bK)p@us;1{gwi8#xR*y>Yg^knx$Bia&CK`Q$5)nZY`hfx(v_e=QhWEV+`eRn zkcx}TO-EpFc@>zk&IrfMpo>*wuLLMiaw0qBt2tEHPbmUx^S#g!#lM4m6qYs0| z-c#TizLbu4zB)fN!u!EP*kQ;-rNA7EjC^g;Y41_U>!qH#&o?}&P8>GNwvHr2t(i2G zVRyS;`w;MK56g-WNc{B8>SmiuI*+J?L4yP;mjjgMDLVMzteKaC!%9ew*KBVNK z)Zc8Q{iX59a~!7#DMbhN+=k76Ea9N+<_@@+WEsVbmp-qd-7c8DN`xrS36Aen_?I_wV1aE0B;Um%9 z5%h*<2$bz|t(cThCfgJ~Qyw?l*fIxwc>jlZmyj=qWF$81c_Tf(J0y6wtj1q~^6uS(M>O05D zf+0yKzc~H4K(C{fr$nku!IRZ|`bq36efqjIl}-r#ewi;zBH6%(=aj(N?V}A-e<#&* zxK1Vi=6$d1Y1urmHTEhzokvIL9fYke(y|vKguEDo3UDpfZnk;QgUgfOd&Ywyq=aX&ATsIXbv8BgF zT%Jk1t}taj_2#@Zvq$2H)A7lMs#NLK6-kJbib;Lmwh=n0^YepDg^_3)rZ95t!%=f5A;#Q|+Vg68@#)v|;Fg~ois9uT9Qc;WG6SVJcI$5T((A2n&PTXsN014xP8jceyxSU(bhM zHfzz|m`o3u=bO)ta?Ico?J_SzVcPn8h-+t2TbB=3myS-avztAyh*wYM8!jdfWjRzc zQ;T!^!@qnoTHigk7F>R*K0elmla+Yh=$J#m3 zmA;M>iNB$5T#N!Q5owy^efm@CZ~Dcv+Sl1luhqR3J@!9g0~*^yi=nft=345^MeoPa zVPN}`j2_R|RJ=Be{mMV15qGQqY<*^c&XMorUNksX+uzrG*|Z;AeO{G+d6s)LmNOWn zPA^Myb2~3JpS~=<$ri-_gB`oSzg*x2f}r z;m4}bdh-9AGrz^r9yW!ij-e2rTw+M=W;yf~R` zg;0wOw9}yZ!20e zwb+$9>P=fEbtOSS;C^Uu>$;`abo28sr+ngSv>th(O&;$%VmXf{tGcx#A-OcWKZ|Hy zPKRrex4bmlc|NOZj5-2~e{G8pM+a627 z5T*N@?(fkaokJ-4r=F=$(-_u)Ig#!n?i87w{BrX3`?sh2z~gsydJ>aSXGuLRcfX4~ z%+xAOE8eH@D}d8S!GNlDhZL&~I@*m}<;6U@pzjLzOeg`<+mvVNssx!Sz1_D?pNwzO zoOtV~M?d8_mR{cor9I3`BG0BsOp`->`=Y7Q|KQk-m(-Mq`%Vk*bgRc13kJ4LEs0m< z>9S5L6VhyxNC~x0zHE4Mg%uh_4IWNswpKli1h^I(6A&b);RNLeig)8k>Xc~I3TOKV zAcnJj?5f^5n2yoICS*YZl8|5f+U2N_*V&qIsmf!o*Hf=b@jJP+YZ($!Z#VF*j-!`T zod;XLsG<`SSNZekb!O{qQ>7v2w`>qS4kfy|8Ux);<+Ai90*@+K9hlZ0%-Wk8awZk4bm4A)G6Xb5GW% zC0c65N@@L#wg}n%I{qZGsvl`3>?ZsLk*dfIAVYXq#mEr`MR4uOWeW%-jvXWAj)JX= zFO*qXg^7$@Zm=Gg8%N6SPRQHNKmJ8<*>9OY)% zy^Yo0?~@cGSq3ey{~v3!fHLGTaJihbVUxL>_aSxn!0UD8z;;J zN@{vMInK|9^#hwsZdtU%d;#}E8ad}zE6L^66Ay=CyD$B)izV6+_sdMV=OcI1;qTR^ zhbVEY@%qeSdD-zCb-&|b2~Oc2wYD%oACI~z8Vfh)BUFgBjAeWixIVaV4=wKs=5ETPk8yr->R^uM!vP*GOi18_E*adM+`uV2~min#Dt{xp< z!}_mvPY?83Gd8;z7JXCHL4?VKhAI)g=^+>zbj5(Me%)0(oTq+ z_-b{WZ#~O2eTA9KDLoMUL^<&VJyooHudFP|Z^~S9IgLuG;(DSm1Tt}UgbFXtey{zw z$aLGf_u!V2U9QaZ6nUN5y!cm3!IEDYD$00QW2)w$-1xgbD#~#RkyYqdmc-R$ zE{Eoy9fRGRHP*p<;!}qf_c5Y?trRaVc-Z3n31gAk8`}oo$Ho{`{+CGMsnG4~x>VH}x*v#L zU{-hbrKRu&%pm+S2%_MK@9?-W(}7fwtjeaO>}d;_$CCD8{AK?%bOR4(lf&&ir@Kxr zUcNX4C--IKu0K{+2JCE8mkLG-p)o1$&hO<`~b(6oHCvj`VM7a(&NYrtb<|p532OHR*s2V_YjPYscjD z>1d_8TJ{qCv5sSx`tfTu?{<%?Y9<*}+nqJ)AIgLWv$%O}6gM3Ecb#mV7ymfRP2WWz!>zU0;6^5P#n9x$^$%Y+{2h7HWLlyij2QCfod)a@9Yrl?|5J(ypFn=lxWMU)xF_&=qbE+cia6Ek%J=tp?kokWB5C z7sS{T7;khnOWwp;S`O7+5xE&ki-qcxNIQ=UnceFL|Zsb0xhqXf4Og|sLMv}!=8qPASBk52_r`6eZ6A;kW1>D907OZ}BB z5(V33kfL|0!e$SqPR@ztSyl{T|9vFchQwkAK z6sXdwv^To=wx?4@CtFB!w*UT*FW^-ic&NQPJA!c%# zO|=M@z}4ko_N8esb?y_~y84g(;fLJHc^Gt*jgyF0t|1SWs*e&f=v`N)R0#S|60M?? zM0w>;irprzPS-!Qgp%+UD@!wUY~<^-K;3#WxA5Rb;^1s=<^RLDo?rjG5A!Wy3yDp8 zgYc1dN2aqD<>Kk^)l@T~Xia5UL&qM2-~RZm&~^4VBp!GX{NF2(IV1XRbcO|4*_)W) z=~G_(7ZF3D=hOxb*PLoALS^rM=Kb3kVZlL5Nm9^>n>^V^QkVmY=kNjbP&^pHa_O!4 z5vF&sp}E&7>XKsNCY89Kx5!fUnxiV&LK-*WNKFW~t`rK7O#UBHUmX^8)U>_y(hWOG-;iO5@TU0+LIEfV3dpARQ8Z>+`(t`~APy?>c+Vx#!H>bI;7a zsMxvWU^1Y|dER*zj;J5`T0DS%$r#0zabFvzYF>0VX zo>IrqhYx57=phMoqe5@G@L!0OiA$XEtIj82Di%vStF4fw_Nxi$|i zAjYTPjHg=Ysv$R*`mR$aKX?552FurGee*#A{%oI3cX3*vXk}(V?xklIZf88-hVh}- zta(*7uy5}-M=n_~&1=b4Q+`2tB~iS_8}Mf2Zv?%K7(j%ew>cDZb$CX-13`vA#saHL zij_-liX;xdJ86>XQ4;hC*vRCvQsiKN<3!26`@||T2;g3dyB;}>A|Bo*Q02?0$}VjO zeq>JCk|=>rxjV>mJF-%i2t)$(n`S89>dD+isFq>MRr)oSWD@FB42S>RgHHK$Qw_A! z?SLSvOx4*=M_3}C^yz_>HQGD}AQ^@dx*g@oSA>IP)JgP`<)!DMSjuSFh$IRMW=UxW zZl(T$3ahESu6~|gkTyehGXF5-9l9#7^wld>ifyap2clPc^%+%>+4^D|wN*u8T$M60 zq2Mmt+!@>5(8sjBaG%_I5`d9@o?wvC&|%Y??Z|>b0v^idY;(Aw731wo9*3o1M>MZ#sy#8vK)~sq)vK*fGz@8K!{Abxl$YGDvQ8PeLpswVe(2eh<`p1z z8Hn2Ei3m>%1_{YH**`FGFIs%b>uz#p z0I;covBUkvAj6{4?GXOnm-#QVWf7hGTS-zsr%IuhGYsmh#m7YOlN-UkG0j_P3>j^l z6kY=udSR8u=mF>9RI|IUQ9noN@h{or%|>8i*}Lh+W0TEfd9s)O_@J*x6Wo;XAV;KC z@3p^6KnUT@_TptlPw*yuA>e>R7bU#Nr=eRevPOoEt1gNYOK)pxD_XFctfV1iX)jPJ z5DsvXYt?%#gW5OZa}mda9N(X02()HEEj5xt*fZqeL1x{uc(heXQH56Xs(l*i`D0G)gRIH@ZH1Yh6*n>R5`lWY z|Dt{`O%Tlm>r+(`sxo{gRZ~djRlAb+3&cPe7`wzHw+EgVn#02PM)NDX%WJ&SUM_7)Lv$2 zGtl=CIAe)zNc`qt$BNM_A}ms&2Txg(d3(+nknU`wWyP>SVq|f9VNg<$$|wjUs-Bl4 zCw&CPmNHy4lU3q0H%`DNO%?dLh~Dg9SlAn{O}z|-8sNz?C4Q;ELMFm_^r5!BC?VvG zAzHp9VhgJwUeWS((|{PNPOHM=lKV;*@xO-K24CO`VyZrTA-4-7P%}`MZ3e;tlZPl4 z>^eDt^77fJUTFbI{gQs0%+adtbk|Sg^*vP#`QssZ z2@GlHEmWgmLma>b=jKC;uhqyEN(sZVAkqa321UD zM`DdNv`FN4kW*R%@oAJ2+wX)_i9H~)DpO*qjPBht6lzoiwj?F#bS8YX(pakiwbTGG z#ftAN2^>U&tk9WRhP~IQSb|mwl-9GH=LD%=M_%$$qH)AFI?m}0t^Zp%~An7d66JY*@>=4S?2L0WIR3N!OOzENy>wNjn>$WF5KIu=^DW#|voq5b+5 zmcAE|UB*hykgL%E1{z#@^;cQNT>N;0anjZH7D{wkIMcG#8$P|2Rz}cQrtM;My)gNN zWVpbNZBK)oJnPT8_+|(t02)1mnk;U0Ti80`2%$IjG-jC)y%*~=K#kk4)SuPi0@h~+ zCMhHhwe$3T@Czu-b&qeo?MLZ-nF``^7-8HEc8pXx^Xm8GjO3rDV@>i?wDOvXi)G$R z!hf9PRY;ANB4f|+grc3*);J;8)fiCPld62OUn71~o{BR#l99KQa*Fz(`Q(OIS_D$B zT;pYTM1PomA&jNfTXF2zoKnLEjyZUyKYSR$?D|HIaJU}@96)^y)m&)_MWK3Hyf)|W z7@!E0;F_^qr_}4V0%gpzq?hTWf8K)L$;9_Xx+ZN#2bnvhy+Wn5vnjL|=@7fTu2i-O z|3@e_+WugGTJbM~+}EfjM$tm7KKC=fJN_Ly*F~|%py0SUp*}j9_8$xC5DZj9V}i9GHtAQR-DRJUMG**19Ksr_z+{=O zD=TZ%($_|PrT&RmC20(*wDB#pIJ8*30!0?!>V@lz?O-J<>? zN|NVAUFy1ZGGZNbUxNrvvDs8Qg1Uo8ng9G9QO&NUg+cWx^;hRe(E_wXZ$~`7(Ur3r zcINH6mQ%SOCq9@L(Hr_+r$?2#yj=2;Se?ZOI8rw21%0rL^z0A}?i5_ZbGisd`>5m9 z`?hbgYa`t1$48yzz+b?;UtYbw?;K+h z%}4dSZ9&W)5`<21r5g+85C|O67!s)f>7gDYMx9#Xk90y*&%8F96ubyN{JXJ!G-1ga@?7@;HP8Pp zdUE1qdP@RdaL^RYRVzM5nSTJo_2Kd@-Qd*cVvu>0`*WF6V)^>zO=p)p(R*eaL?-=I zng$<=Bip9is-K5)d z#-Ie@lJFBoYv3*16JKem&e-Kt#f+!RT@#xgaAfSXYE~`Eg?bJ?Ts>ax7XO*++V>}} zU=+3MW#FURZw=u^G~ieJt%T7}+4|XCbaW8KX6_%{y4SJmt|YhL9Dn(*ODbD50jmlE z-|er3iu?q=#%EKQH4iNAbk|TI-0La(0%~@iUoLvx(k!sIlD9r@|E`rv>RZ`JH2D~Tg+%>&PPc^Ms;itbNot_|s>s#G;W5Vq1OHY+CDMgW zx_iDOuwysNnXsQsi7l1+J`j?>_wMiQyLacC@@5N~UP@&{2-lUNlN|rSQ+NUz0~bZL z>#`*lHIdTy64>2%n=-v@hSXKdU%Q9aw;jT>uG{-_9N2H3S4S}f zy97*9#6wxg4hQxJy8M1l7#-S4$qh`qs`BZ|JvZ`+KQfUw6(oK;T)p2()f9hz-E$8K zcCz+P5X zw75MDZMl75Emj9uD%UQ~xDp8MUy3Wmkn?|aWOqQ}!xxHx%sbBgxAO#DB8SEd(V>J#vgUD-?M%KPtk zzS*z>xad&oAsYF6%-$>|Z`v0=<>aAV(@!T8Pt_sPW0A1+qrF2qQ{$@kKj+w6m+Lu# zRUkQ403AGB1V2UMR4ycG5JU)INzKK|@XkJyC{gC237!4+7eQf%H2$3vIkl3@P<1J& zdfGmLvzYMN3v=Z@ixC1^ta;x@rB-)|ss?)27TmX!02yEG6oOIJMH3KSbZ1b1_20#Z z{@*vDzs_5bP)RHAi+AutJ03&TeF^1W!WdGq5Bh%{@T7LkI7|pxO2U%SEfb(+DGv7;DEUzbVJT19fwD+oJN^8C zA^dRruKnrY>9kq^UtmyVq3tSeE@>)VUsoW6=h}CAWQ&%#f>EB;S)3y9Q^9tx2uULVxS$Ch84#F19_6j3!OCabW4%Pd6~csKDgI zKs$w*@nCg~k-CC_PwOBnZjp3}J%KHO+{GKkwVT@8=d+xyDf}01B6gMc=Z8t5GlAt_ zGFf|(b3>}Lo{35e*>s?V1&MuEyo?tO;8L$m6z1f3Rk(a8h@?KOK=LQe-)Hx|+qWwZ z;W3`mFr(iVuAx3o(*kKrrz$x=S1Mv0<&GS-JP#cLcvU*fwcqOel}84S-WT4I3s^1j zUeX3?O0WJsd@KHKh4u}fhKv1HbvnM3QRurt7}I@}qtTHOYJGN|VsodY9@Qi0ATQ+3< z{1M}~ow5^uv+%eyUgw_nuH`XwbcW})+wnoX%j56m$@=vEbZq0YS9YQ^NAfl_q46_~ zZ%cGecw51Y9Md7h={|KX>0Oh5S6ODhna>mq{9+T#c7ridnYM>B{IoF-KKQlxuz7Gd z;^pKvXvFSP6HCevq1pdb@l|^5H0p#GpCB3gbW~B5E~N8f4Ynj=zAjc-luYo7O%KXl zl{TB}t8nfo42m?mvi(jAf7_BfhgQA`X4eKJJHdmtY`;<+-)t2YcyPCo*qM9{?&vTS zB8_Lwqah*@tYYNNKJMuQA=>VU*O|}9FAw-P`bm8zggO?#ozhfnz4^9w+44qrl6$GT z;nY!SLQX1xV1TfHfz=8|S7iJPo$1^m;rgWuZQ5#KR(5mOZ$L$sxo z$&CXe(j<=MR6Yux1h2W76)fwWb1m3b%Ea6(3sx%}|NK4y&tET7rS|I7ExjXPE)F_* z^Uy0(+0?PkIoI5v@MFZft&PU-Ey4phqaQ~G+O8S}yPTiAGyMBi(1B1!!U>Rf!th#s zkX(OMR{AJ01>5>M}z-OI7qrZMGC+#2F<4 zs3oYe-R41CNaKRV2$ThTznF=aruFL zpL5|7#?J+{azhwtW$4|_IwxqQ!pm+W1n0G?ee{d16#7rbgnR^ft1nn z8A2qO;#^p468lM46li7SyJpc=Ms&TfGXJ!;%1qJf^fRs_=>gxT$hzVc{p$=C33Vq< zf4url<2Y%f`~9ub+xfhV*x`~uwB0Wu_>gsD<7V6UP8N)5p}CQmtG^Ya6m+4O3XtL4 z3$Tr{N_!fX!uwafXj@(v_VvN~csXX7!gI+f&LNAPD)f&AB@!T4+k>_fH~ga03@=Tl zY~*^tdo0RX=E8acQHaW_(VvmSq<239_o^C8H0(b)n8}o(SwybeFIBXoBio?br8IVh z{NQo0DR-VjCW_c|rK*TH%^ND<#(;=0krth4bgaoY$5jTEQ$YLz{ zthR0H%r4rst@EOj_tHk};9bV7nli)U50C1yS}w6M-=oiTA)en>=vX~7rj#$|ZlR<= z1{wcB<2&Ue8b#mJ>r+WeH{4V!g)M>07aMG1kNl{F^SE6)f|U-VM{fjcyN$m75Kysg zkhR4d;C~_{fZ%prxIgieUgUROd0bVH-_CH-4u#N{bC@vz2nhA`#-m;vc^dEtuie!J zge>#Ld&b zpMtH_LNlewJ8$SCc;P@AO5(|Of=!l*+l@~U0zKV_z^9_vxia%rkUL&VXj(wANE+l- zOo_xJF=7ArvAFrZ_QQKbR<>4mDnk&1M!NBulAi)oJk4Csw`Pv#6~JV-uXwuH{fDaK zI!o92ZE5*_hPG2y!ezQQ;;)+5BZ=|K-%-OdYG|^bLq)!VD`#m- zYa|x5iKZ14TCeEjkRqb^#PH+kHGhJV5b1PlTJxH0m@u@WYWWRKHhF_ zEDwcJZ-M$2q>9j5#CR+1YhZimLD%4s%Y2`YPyils;XxiTKnFM?f&rMP>93#5y$CDt zQ>-T;(y*}us-tD%G#kB~s?{aI`RiXhdzsRmsleu|R(clrzX{A**=%o~GKw8i#fSA7 zNcWmlcC~7i_)DIE*|h{D&=ix@du7h{4%U)cRE8F)Kq2 zdZ`o6)^YgK%rbf2ipkon=TB9B&9j4}mjpJ0KYn)1B4#**eD7?q=K-bOW+e)L?r$eR zdq4X%aN_A(#xLo;nh;6D6_6WVpGF!^`{xT@<7g0}x;MK%;;;Hu`)xR1S1C7*tmjE& z3`p!_*!3kDrC~;Vk8B=&AkWUhSaat&OiC5lOa1!xJ-r7`^Wh;1G1#&^hUgo~VqoPf#OusFXeyaHOOH>%nf?{IdRee-GdDyv%lTS_2=af7UstVPD0M&H)Goo~YSl3VEQ z)0)U6MZua2JF1>rvk~7f5xsV=4$8q}&y`>b4;(}UOd`r0pE{mS}6Up2IEbz+4w!a^m zaLKdfRT^slJPS*JeyCiIQ>ccuqfhI}(PwQ>UZ$@xQ;5gwdpjT4R$F}w^4ypSbOV*h zzBBI0ZYq+o{G>8C&yi?f;a^K9#14O^KTVh^ED#z)@2%h!N1LTF%q~;MHjJ;&Ddd(|c1Bvc0!(v$;lp?Uk?j_hVRd>}gAUMDq~fXnFiFa|Z5g2>^~pUe zM$Ul7RAM3&p_Za0lj{w%qIn9b96t{lH-S{k-o z!z$ZTB@5F&WV^)UKi<$^6zej*fOu%&AyT>K^d<@?-)ckeHa6$X`Hxw*vdU+#-+&km zn#tph)hj`EE-Slb>rqC+G5CDVsHv8CY^fHw+D z0YtaDVnAK3JuQ6O^(3<&X;dr_o%6n2o)cIYOG?U-Xw7AGZR!yK8XZ>tg3O-0Zx}*0 zJmsm_@1rXx6ALAY%knMG#rEs`jY1E=WMtPLZrriB^cOAIc3pPW^Sy2;K472MJ2oEm zS|u9dh{r<-L?wlum3%hxjvtKm&5RG+D%mSN5^cn7<`u6Moyry{Xm;*CMy`^6z$H~8 zk>eb!axOLHXGlV{PmyD1rqo~eU6VSn=aD#1=b&rWAjjZwrSw@&o&X__+qFTy}nz zKHj~5{1P?nfX_0XG?*VXDxi{8xDg36Z%9w6&gp2FsT-_6S0Jv|0%kuSm(_4CsH^ur zc`nnj#;Zn>=(m2h%mDwVHp88rRIZ)Q0R&ml@kLWFL;qYO^?PwSY6g6O;PL|dnbr0m z?S5?glg%z{7el(EY) z2^zfAMQHTV&2#_xA6skb2P6#HBw~>S(j`&X7S0@E+Pgny!)&Q4oJwMCDI0!vC4J<>9A{hKX^ z52-Lm*_YIh1-Or#la5Xec152*Tk3;fyg;yR+7W5R^l|+5`)!Ag{+sC*$tp6Ahb2Zr z1ke!a>%REQ;+195NuhUl3!N|evVP?RB=TsGPr}H$j>>hn3q%7UBw;-beHs)F7qOCqN;GFC~n*;hR6~;4Eb|`?Q z+mtmCQV5xS%V*1||DLOD)eEGpzBvBL5*sH$14XTTX6zX~9Zy_YCaXRLnfz^2ve0(R zwU;>pTb^*h`<6n=!|gS_zP-Ib0w}Clm>pdXp<$Fs8{4cPp$_K@Z9zFIwP4^x2<15x z<@m?sb7ykB&4x0f^w8)OC8s2Z3AlA90+q);?c)`L9U}7zSR;}{)r#X~fH-E&zGzI3 zMGY_HfJWIfRiIcXhRi(GVA1zjDD=~RQ&8FFMkS(j7!*52yZaNd0ew{VX7bk!r^e1H zGu@eYp86uY(EBJasl*16tqv8_*Pq50Rqp#T&;Um@^PE(muwD_`Xo@ZQyrOkO$=J{e zM2h5tNO5ScDw~;Evk%%DD?|n1J5NL zUi8$Ho2jn-NFs=(bBUgy9yH2)hWj5r8WsN42l%seHKci}M9aY2!Q#dfbKm2LU`}df zY$d0ZEU#7BsQl$ElzSgjcY^t4demgujFwB@3x-Ud+>>Hi<~YwytE*$aMpQsK>6=cH zON<32`B{2S#^E8n@^7M^VqBJCDb>auMFh+iKi{L#LtARNb*o~F6Bs)dl3sLmpm`$` zd+pn4LwwV9scF<{D+6TeB-q{%#yi(I9XRJUJd4;>@m`>zy(BFmWdwu$NxS%o&DFw1 zq6sp%nq809QK=Hk4qCr_gjLD_hqQ(8E*bCHvuv0F6g$QAs{HoOi_N6!pZ+wHzx_@S z&z`tk1xgzUx7waKFUCOQ!Gzx};c-p|FeD?E%4Id$2_`2JNyR<&_bR_F!p0C?s(eq* zuFz3%E`W%J5wDcgC1wCt5QhA^;r~xZ%G~-{qv1aEcuE==fak ztLKn6Evr3?D%5Q{UpIWRtrAyBi6^y-ZI|)j!$MG89kHq{QQwsnzm1fLM7p*~WoM@NWN^cY5rNL~U< zY$~v1Sc7sd_BDro9J0^=c=2X<%R2W}3&_Fbp=xZTWh&IN@~nc(L`=F3%`g{B)FBzM z+_h^mp>K%dy8i;5(FwlNALC`zpf{vzK3WaKGOjRg`SOB-=8tmrbP-R7rTNF%ocjo8 ztS=cjvP`U;l4{=uv_>Fv4L&Ja2uuYxthXjRBYpD7qSqb`C?rKgdneAsga0>HC!4Q~ zeX)fk-hw;8lgqB%U9^lp@!~0zgk*Np8&N*8?+}_s3>|H;KinQ@#Y?q9L#<5IZ@G>i zI~AF@=$k|oh~oT@E@$oq{%PG)s1ikO=2b&=_m5@*XvOZnuR$~s-lGqRZRgo2nzzbi z8{M9a8g7EXSk#xz%s*{~DT6R0U*A!GhphPU&V2*U_y1;}J5d7Y$M{v^d|E%RzX6eq zopi6|I>zV9&AGAhH=!>tbH=dWb_7flK~uHRQ??W_ufI1qABda> zC)uS-ndy>^T85ST*cXfE=)qjYdYz;*bm|oUpg?D3j&ZH0DBnud?#iPaaGX7~5*WJ} zcw73v0Jui@)=Zl%`Q+6X4y9`G|A}rHn%fZqZ4K}B=gWceO7!%b&vbdDs}gd^-L&84 zel!P5Og^u-A|vWm60AivB#ypsG>y8rO^O8pkpOKt2z@Uypv6@qF?+tG)OZaBPto#E zYWQL+IK3Hvj2k}eV6>FanT;ou{=U4in!Z}y{6N7sWmblHu=u3MD`LIJCfra<<%N+X zk1^1q7seD>LJC;v5nE^yt4%vSW(WW2CpN_QHl%eBhJW0?dM?Q=YxbUmSiBqYh1<%T z2pM}&V&r;XDCG&kMKE{T$UPKx10+?cR(nHe0H%0|o;H?8yW0W9_VTMuX4Iph%xL9F ze-y!kU&DFvDN z9Trt&Gn?x%UWEY1EolEwytLL9yeMivdj$A=I@>U{Q+QiH2RgUSK#6t=qX-&vH-!+*p6CcBelS0hD zxaYSbbPJJO8JRgVEfsrO>=%W4mm z+o9*Sz4QbrV_l=t^~CGSHB50uU}0LmdcM^IDS*l@S2eE1NjzzGIJ0uLtMaMw9XKAd zw@d5vDkS#Y$(T+<)rJAwF(77hX}puZ8GmI%h>yTuxr|q(TjMPSg zXm8WgGLfgHebA{Bu^!4CJVLvbq!qvQDxT=qt)c$mmXRLEq8uP!h^%msJ&a`^d@jP0 z^byvB%2G&uEdf0*(z-PD^@t@1?nwDfopz08nX2Zn*RHdSN}Ck&{2BR{X{VNe5fmx) zi!L%{cBE4*D@}{)%Ig~`d}j%KPSDsW>oUxSFzo`EYcrpr1V1|IN3X{(~P8=XHjF5r*d#ZQA0h$e1RsV*UgtJj9Ao>1 zu;PSB@my_`xC&lfX8P|hI!*dNhBRa>LY1 zp>XF(gqxPE{p)umW9{`uldcEpbox+cu6H0Nq8*rPRl)C{5^qfGkPB{+pFs=Z9gShV zo(c-}!ZDIIC(LdaIg$+*J^MNw${_Hxtp>i0dTe^n|L&}NUCrG)$< zl)ht9W5&K21)I?h&_ez1pvy$tz3qx;Aud~+ujG(y@DFvQF2<>ue&7$T^*E4dlFt=6 zlBNX%G*_w+6L=%}Xyy2?Kn$quL$Ixms^8*?k}79Kj+$g1+c&VFwk-UhTEL=ZJ~G#9 zQu%5cNZ5Aa5MN+bBvw4Qx9in$lI-M}t2W(~^P+1|fME5fJ+5AVhjolF|CG=*V%Im@ zsxswHl03_eQgj_5fEKEMt7Dw+kS}ad;e#rM{31S{)himhcR@f64|!y<({V3gr2>yE zqvv(;(a+!|LvXJ$bI1rVbR3jnNgd$&1~kw;47>3#*2gss^eE+nM-Ws}8mh1<*&x*s z!aIs|6J~N#MAm8FjVH8JzTgyDr9$u0N>hI;P?=5k=Y9;PjZb9w6-D~yKJ}5U_aGs! zg8WQ=DZfm;68GvB;41ph!kE=BOT39SzNcNGLx+CEcJ?ifysOKitUgDmfK3kjJ6~7lyZ_KM6w57eNsF~4|0$p4D zkfOBPj9A^A&zT0GZs#9D$oS?bFIy^_-wNg3h!$(!VW1@86XP>UC|3qdzk0@!kW3g{ zta2PHvq_U|>Y(D*epoX33_@TIA~?&Xu0=cF$@y?N3_9+MV6lQ}Ngn=}kwQid{< z7_Z0|&gf87B%t^Bg(F%cnFzAJb@~EBBt8*lQ=_0MG75uz#hZOMfk7ai{S4TDt&gId6ES;0?cLDU2Il3X{`!!v& zV55xe+x(gf%fRFmh}qHD#O$5bQQ!5gq&Gm+;wNZijwo8pEbc)GAKUVpWMeFkvBgdU z@@<{ws3%lV$ln6$R{vv_)jlQ5Rtq^z`@zv^>8>Q;`2xR4R9bTGPz#OL#<424k@I8W z4V|Z-oxe7@^7VCT4TKHcDO0IZkK~2@_7t1QR-T{7I(#tK25rp|_C*WUtusOZLJ;2< zTsJ=(<1uteJ|enHm240 zZ~0p2{omY==RNq68GDE8O%X?INQ++o`~(w6n-@l1;PiD{lAx|v4Xin-Hu1qD@DB^v z0dsz-@@B0xKWmV=CHK@EE_Egv$*d4fv7QW5Sk)~zWSDD``o25F>CjA7HfVp>ui=De zr4iXwrOg=2B4fW#(8`-&pQE4()=c#_?_ryFiX9jK-m4z3 zR8L%;YVT*;-cUFFw(H~D({mfZ8Df#~QO@ z9O+@z2bm|$V0OtdDhE#<0-f*C;deG$BuRnKyeacbPV?L84Fnu0b%Xy7eSUl-!2~aN zIkSllyLZ^@&(&RcMSqqK5r&tSS-5@rB!@c12b2xfmRJ`$ag+M& zz5%3fLO7t()Bwpb6GsjMGN~g8HiiL^P3F$`^-qAh)6nk5fYRlbOBPk+4NO07Jqf0Q z-#CvwTXxl&yS{VIi=RS2h(uhd@L)yq#md&hj{Zgnq5^w8>HRRmNL;lmwv6Up;UWQA zK>ti4Szdiy(HCbLC9-JzH)x^IYk1?|jh^DKA#@A^Q%6k^G=}S6vKB!(`mj0p9_P(q z_+_|elSq;QaSm0nmKXm-w)`4od2^Hqa@VcNrl%sPj*^4;s*<$De8)l6loPdA!RugJ z3Qo;BPae>V?wMT=os#yb#AhPDNxkZt6%DLqY*d!LGY!jlrX({e)G%A8>3q&ZbazH{ z%eeoZv{+91GGk^$1G&=GwlF$(IDhZH`xJig8Yjm9RT~}1G&JFGHy}LuXsC$1;j#lm z^5Xs(jKe&pA~<%a&_AD3Nl8TrVH*Td*>u$WGZikoxh~D>9C{ol0h~9IY>VxWb{fh= z=c@xp@mr&@LsV{JT(*Ml)!38;?X-IT6H9<2*i_Y znY|TdX{^fY?_1m1Nao0H)H0%?dXT_GE56J96D(n94&0*7E_2g%0=FUc+@L$10RfA# zuO<*4S6QibJWh}~4~b?s%F*mm*uh#49X!8z-`2c5vH{Lep@GZYsE{+4fcj+kVxyg< z4hRn$y8R=?a%ZbuFwU_U=q)H&6=s)7zk}cNht2Img=!0u^Z?}^gKo0A##h=lu`WJ~ zP+xU+>Xtj1eZkAVD_y6CQReBZynTUnm-=h|DG2E$t=yW%CbovX)5|fcRT(Vo_grZI z{26Ag#>*;o>_JfqxcPS6&gWpfa8?WZfhfr&O9}O(fN7t90A32`03w_ON;yW%!FxIQ z7`@Qh;Q!3kFjNkA~ zA5fR@pBK*qKUQZ!B`8-xYAc>|Av<3{%Vf|tcba)KOtaB=;$pt1gxb{J&EZ0!HIFd& z212XkhljRB&{qkEjA#(urR=0T^Y#7ia zhomRjDCE|>96ECBPl~j@_wfvwY?v-p=u>GZAA2hR`+#4)fdC*p-!gnSF4(BqzQOUI z@oypf2VG>4;OKZ9+$a;_MBQJQTV8ErCsa18s7!-z&?RfDzNQAu$+Tm5e40~l9X4?> zr5^rHo?9?GV83JtD&Fc|NGkDk&k%Mhr4K-Q{lXszsA``xav4)0PbWiIw0zd3`%vi6 z!5aOUWXEvMto#o3fPChAU-$e<>P5RB+g*>r(hnUAQUlNplc<=E1m@bTT z?MaT29!y%+HS=FXpuDncTkZbDL5}?mysEhY^ihO&wDuWDu{EmT&}^NCXFaub96aTX zsqyASUK#8V;4Q)-zUbynu|LTb+oJaZZ-6%gwO~cSuleT+_TbAPK88D6{k`-k4Z8Oy zsQ+#sy}ox1?5mN!4b<_upWz@=j_j^r+6%he`N`PKAhvRoYNDdMZ( zBSK{j_v45sC9-CzY`uVLdhX>=m7IWXHOu>8kgCGe{qI|drw!{iiDqM9fFw&NF~F7S zpBETl7TusS5f^1CaU2jfMJTm5Vn}^v#VpzzP-<^9+qV?z;gp_`Uz$+gLO!ZzMG|a& zz_HESm-|tM6J;dMIB#49#cfArGnW{`3wOt)1pp@%J84H zH6J!KRGToNohbHgUFEvd%i-hSU~ByONdBk6d3?GG#-N3gsXv?DITydlOa#r_1MgD9 zL4@(qAE<9i=TANKTPZ2WNH_I)dS?#lERj)qmU9@`o%0O1;39bKwm4QzYA*_2_aWOr z>v`^)tq4@Q!9P}KJHu*1zxu+?m8OJtH_dV9r|Z=6{TS@@WPE`}=0}|~X`3SJ z1>Cy1E9NGh$CDI;Uqg5aLjJj1mt>`4`I&fydCV~(^;OCVQ^KGD5bHYSD@ZkSB_pbH5vaCk_jn|hqFbk*6wKtlBbbWQ3KRop@7anCUq`nR5=(I&Ca40zj z!n>>(Wt;xOHXb33aJWXj}%0~YEBf} zak3lftcxM44rsyscgl{*Ez}@{6MC6pDG*c2x_GbXH1_wFWktD@*HXUvg_D^OrPUo; zkDYZM2S=X1+rrX!8&7%>Ci3L=S82&s#|gyWUf!%VaXKdyHk(RTVx4+mGXPxh6Z8e^ zNQ&FYxsTXQt(z(|y-z0M~zA-|MX4%boMSE)pZDT3CMC)idO-xu_q9;*1OIeU17HK^{x?f@C|s z2D*8&;41`0mToQb>%%O2bh@1N&)a69Tg|Z|{p4>QUK@lA5FjLm4{nT&kNW=F_Zm3o zw!qFLf+^|8a9?R>@mm#fr|PH1j5TKviu{5tH^p;`jF*uN?A{39(Ra!i-86J0SWh}86 zkz#*yfz+mYJThJcN%RjDjbYj9WA^#NdG*T7=!HWg^35txPoiO~ZL5eqBQssBeCamR z_~y&b>KyLm;P01U7IL8lkFf16a{}dj(vt&cJ6au(0lS3pDdKPS|GRLMPTzk&Ea`3Pf5AnLV9N)>WyXET0kCm~JWHL94n`~N zptN4Q8RwVkIj|Gtk%y0pBWMU38pJemP{%qH^35ILHsl%9p&U6Erm3*;!Oa$Wxgr2n zeB2QE;?a(NpnU!r^S3(PNLgTXO47qx#ooar?L?(KQqF8^qHIOgSEG5|gd5bjkY2X- zw!XCZ&DBuec)Q98r)Aq_Xh;CSmGmD(5Sn7;dEHStDZ1-mnUO<#>bHC--k_K#E6_c{ zDG;dTK=bzU2!I&w#Tu8(yHq6vKYvEg_!@&B`2CU5!j$R{Nov5feW|gzJnG2~>~k8r z%qyVNiauM`EOK2-+i+Rrs7oYYVsOh(=QtileNSL*6ynagpA4cF2bB*V6h#$SVk`cI zosij8Cd7r%`d`UZ1oIJcA{edMys$mb484`$tZJdpiTQfT82^;Y@HXGO~!-I1-l3U6x!dM|m zr0My4)jA$IH>6O$va~)z2w;9(%w!&>m+^8lh?>~vG}BkYaqCp(Ege?NH)5h#&E0Fx zH|wm65WV6tWA7*oNkXOPx=g9Rt=1IpUn;<#K9hea6TB_c!^KcVT72;jH?q_%WP)zO z%18RXk_EUnBNSZ~n%?e$GeOYP8DSNiq;orSiO>vm@72d0|Cv6VFGhrU0}cACPpJ*=mKX?T2K65q8tXl&uP!`c z;^sy&tUYBDZ~D{rSmrZ)5?PRKsmL+OfpmPLhb4QCGq%NDOtXPG#Wi5<2HFCz(jW|k zo?bmIW+ohJkWVz=kUioVpura}CF1MnJC4K_BhY#Rn?`pN8t|?mOW4f4~eAXcmsP*<{vvN_*Nphr`aqH2IJehR1vZLHET z&}H0Lp5E{LwjG-g%hzA92>FLFl2>5k!^c1o+$fy&rLEp(1}`<~O98qQh+UStbL1lpx{54(tvrlLMJBF;j-4M5L!=G= zqGxukPN}Yg|ETXfI{XfnZVLDYo3Q$qa29C^dW4RRVX+dGseGb z;npv2#5RDhI##!z4bYSJ7NeZFpfSVBVGhK%6S}CUFv99v`yFcqd64a#fGQU1Bp5ea zQvutQ?N;U3UUon*SUbH?Z{XsS&C|*sPnpZ=%B}MUiu~Gk`JJ`DuOS7uNqJaQess;7 zrb=M`Lgk-_N@60n}P*}O@3?9+f!!EWHrwO>xH zV-B}uL3$+aMkT-)nUc#J7GN(s=Q&pa&i*IqO5jIeSEU2uN>*M*l902;AJS z{YFk7?^GWC`0d|YCOaN33N6dF4pnBf0rIpiWAC_N-EKPR=tzv5Umm)QEqbW-{Hqy~ zGvKkXm!%3z4ZPiaPUNXCS(^FD!u-!;W>QrGP^7eqN=4v*Eg!b$8YU^=9d704zwsU?XC77e*R77EDd_wVr zT@OK-%)0Q(7J&VK^qPbkc8d5OOYYyNlfOQMBzZV!4im)rz3`oX7^<&Oh{Y>=_{Ln^ zFjPAF*M|F+}4d5 zyK%KVXy(VU*A+*V5m@49hN6oy{+0g@DoQia1RkKnrs1IVhsXryUg(C%FA(Y}_U>&@0ZJYCfd7=m`n&K@t8KAK*=10fg!u*&NaSo#m#gbG zWCttI7{`9m4r83R2;aj&H^cO`54c2%OqX`-biu+1fpW*XjH`rUCbpLik(P|3e#5k)q?UZvJeO~%NWGtWm3_|NU)IG7 z?g3FKzlYV$?@?Fk!Kn}}uH7{r+3Ors*b)}@FQOM}>)BvMV)j~NjM`BtIs1daa}|!7 zx1^svZ~y?l>M75R-ZH(_l6Y0D`#x-(>e}2vf^gFHqsM-291k~VT^tXDgP6&>DQ2Wb zdOay?EZKE4^G>Sj#AC4Gj-0^c;hZFDHzEK6cst{ybdEYyv%Z^b-6vJDOZ1nMXp%&C z<~d~x=4ix4=%O3@c?{t;PRS0^lhPXg+W5P_EesfhfS%v6=klp2!2*o^C*>3U8jk&0}i-S_(zIG0mgC568(|BVQKy` zEL8n^=c)m43!pAoh!FdGS#~lj-bf@%2~*?q#vDAWfH;R(VtANS=|&tyqtXOx!2IlA z5K$?80!Va^;`it4!0!QivNp-7jMa@B<-UjhlkK_my`ecIv^ljW)`q){MnG*DSBGdxQaQicJ$=3x&;4JH$irn9Qhmi(GG;^9wyH_wvLgZDq=ad-JKZh|%l9 zUpW8fQ*7YAPo~y#ZyDC&)XkQ1Wm|)4S$*)YJTIPdG3!bSroNKymD;Ee0$FKpB|E;j zeFd)_@OW1V0DX5YBk*d6dUmZ#4^=MfxJUJ==ia=iMAsr&q-u=~RK_fthvzYINNi*& zSFddUy{$s7DT-}qX2TWZa(wBsQv_)_CJ6m zOeY_Aw8D&^zlM?8HD*|N%vft%!$Ovf4~yhtJ$2*_d`%U!FkY~!fq61p~{w}d~*DRT8>DkZuHE!85b>jsty@d%hBN=)(J?7a~ViNRV zx&EOLitF0hvto6APUKe7%ce^44ng(HF?avoC|$2=w+PiVM7-hTs3p4DY0MlvH9ywJziK!NFZL{G_b{- znC|w$O$~gS!G9)r4=J&HnWZ|lmglC$_-ZbqrHXZft&jff?uGvNzOLeWG@r#5PWZXV z9gG_%8w(Z?1e#+Zg)9&iwe3Qr5lQI`38M13=`Q!gFy+0O0gEJWbNtRG4=;Qx1QpxJ zwQcVob$RDQR#G7KQ1m{D04UWaj}2wSnAnP&zWfih1KUvOF5_RRF8F=w=-tLVr;h?z z8pW|=y4I{poKrqHk}0!AHp_TuaWKxCCNit;9tDIHE@y1PjUoi1i;jd}n>eo+XofFs z(;6`d9b~QaHOq8nJi(}@OX#~GZ0&M%C~M{kPbz-nZD>)b+eLS#3#eg#qmuV{7SMyP zcSLbLIjiy&+1Q`w>LDZ!D*?-2pnR?_{3Fd<1MyND6_KF|N$8nAiK0iaNu9DVOi_1Y zuBlXyho!CL<1K+`hGK@&i~&;v4{q%M$8qEgCs}hEJlis;xcUZ=Jdg@zfrl@b1*~5( zX9$zE7?~U0=%Xce+~m(5m8m?W#kJjK8(n*+H3CxK#7A$W zDJZ;ic%f>s#Pd!@R*I+J0DW&kHK=LCygL}5DLQP&UCl_++1HF@KqT|m^=OA}WAIua zRYOy(I0Mu_?@NN3FAtVr$H^beA^Mxa7CJa8o0+K#DVx~5J$OLod*~qy7NPdyVOF2F zWv~_%Ajagq6lTK%#$#9GM|GSO>8Oe6kkvT25$!<3Ag4B=g?Ax#%y+8WIntwxs31bS zlLG~9_HB^8Y($?iu_zozbz2H?zag7{R9&_#)Ex6p8tU3`H{--nJZm|<{j$`s3RQ)d zh3<7@mepV8bHj&=+zQ`pAoZcbj%&L@nUX6V$db;D4b*U_r>Kt;%34+M%DU+k;%UTU z#JtCJFcp7cFdO3S51Nn;TL?m?1Kj!w8k2GYL+#PVb^Bf506a^So0xza#i14*@B|)evAa*@ z2RdR|W0Nrc!cgsaKUF(UgFmtP!F3|W<=Toh^!YG$)R9|uV>6{be)jV>w$%=UfS>2-%j zYWCrhFgr#yXlhr&c4g8Qd_lcoB=)NfwB_oWjA1UUSV`O&RI}1X;hY7@%1tm80BUB{O9e2_4t2G%*Db4? z@7j1)Ru$&~k$lej-WiDD*HLzDquWf>BpK>p%bLx=SSUbzUqKc!@Gbkh;Y?r}!(gcP3Hp1p)tQPhJGkw4fJ~S-%H@L>P;aJX zPHC(n8>ddX>W#;0j(&H~golv=#Cj8epty%drEwB`Q&??@`fC2~p*Cu~=S7HhpBKNm zs;dJ55KGC+5(KtDm5D1}>i?*1`618_z``WpDp^TXC_D>=w6%SS18Y7lE<+zuFYHi{h5QBE{7HY>P+oLIt!N6yPT~l6NPCTf64&hx$eS>va(AI9zZOzVY6!CpD_A3LY7DGRj6nGTZrvKj zP6r;@FDu?RkQK|P63wbGq|QaD6uQSu-5(;FEO?yB16s&+A$2pl#7e*UQgF5>l@i&y zcu;N-f@@Elb@$@LiBT4+a_SE7bP5FVADOQ1_qr3^f`4ug#0F^c_$D<;qJ~08@G$qk zBWQqQt3oe+@RKfGY?*c;h0U{EcW}WgKajd!_M^f$8tsm;p!-l^IO9<~772p5YuhqL zed%fagSG6)S`XA$O{esP1mC%8$L6{Q9*^ReL5LMhk7NxPw~-|?o_!fPjFpf=FR_R6 z?t#9I9qj{+^c)mitq~2#J_MUL4iV7gAqq9YeSx{4fsjRPcNsPAt^NA3i@L-4Zc+Xf z1q!TkD~>qma>YSe;^YxCpyPx2*rBoLvdj~8QW@uEg#&k(wXxpvc!jlI0NC&$Z!v;l z(pHmG_GvZnXM=D?x&{=NepK%xsAi!YAb`;DF+9>?5!Ri1{O!?HralMyT*r4KJj(l=N+SM4l_ToOgw+`>o23kD>r4c& zhYyto^hlz5qYrNuxs*xD&f5s{>kya?QN%eol=u0F6uDCwO$*p%%~#nqINFSMpqUAM z0zDptJS^|48V@0^M(|t;x*Ulna{2k6#$4*_v%7Vo$3VSq{1MA+Al##<~=7 z7V*f=fgV5hc^YzgS*l^W2M_b_WijzaV`>xn`WgdQi#Kcl&hdorjw%~2@NT$+)S^vfWUP*gyUciUW3VRn{8(b%?m6hI z1dyf@hYC$e@C4evtXCenFyx}hRirnCAIN(lQbCCw+7@0~s-BW>176FtnC8iuhNA;! zca~$YzOQ-18aMK#g#LIGF-`Wao^*P(Cy261N7mz!MH>D4tEjqm`*QB(dx7G+DcR)p z5#gPs{bZ<%#i5MwD_?g|F<+aouy9E@&FHiHdC=<(-E`Voedu}pX57){V(|r&Y^VvL zKHIjv*>VH3V|t|5MZe$trg>TX>5UxjBDo)x;21hWuAJjq%#9!APFS+XM>?TQYl;OO zPN#ao`Axc|XTi%kC0R3TcTi@~BP7>=b@heZho|G*-l=<<3f&J@jN0#@G9H6th?JBf zj06v`KL^n(ugKwvg$&O8+u9%(6@JjpVWNz?g4_#E{=3cjcPfm(-a>kO<=rz%#B0v% z=V#F#&Ik?b;h28AmOWjBXfqddbkh6%HZv2h9rJkg@ZUO$CpKno0B_jO=Ab@IJi_h6 zHbMRqk%yYcRi}yGY#9sMi+ix2NK@QvJ^JXVa?t(w)v^cHuwy6j6|lZiWsbHpn{2K0 zWK}`QX`!g#*~anZ<)#`P=JD8gf9dZ-V2vAI2D$bXobkuELw*ot#Gzc|Lp`16qIcNrPxYJ8|=(R~KE^^GDB1JX&+q`I;=j%$Ri+v~^JD zZRY5yV%=k@?0A!=<*)=Vk?HKgGeqiIvD0pIGTpQLDefHq=9#@1g^D1xSF$r1tu@*A zX8fSNJEJS;$6AKgT*s$n5QAUx-FC$8{L@*Lr;}v+^i|ID?A@gik&tN8hcEW1wfP=5 z4LVPj=jVcR>#I3I9VNw*dJ7H}A(@T+HlD91Vx)>X>%^;nS0A?S+|~&KOoortBq-uL z|3D!bRR)^Eh9iMWZXs+yPD8WN-Y440t@QfaKtZ3|sjZui44gKbm^@rR#JnN_&g?ue zf$oKV#n0t#%j>r5!SuA~7fHSafQ1N(!SLN8j7^Y3q5vtm#HtMFg< zaEz^$Vi%d++AqsBOAS+sc5aEJYpn5#x#O&ys!*Kgk0>zatY@*)VcmH@3 z*4nbyN+AX>LdYN-EMS(d~1FOnS!jsWJdU52G+?cO^o3nP!BNxKOe5l;KyouhzNfAPYyeL9%U!{ZG&Il11Gd-W7cJZ<40#`kd;G)4c7fs| zV)aNc_#`>uc$lm;nd&?=Xsr85Lx4d4tUadTK!o9>+vVxzDAH+7<}_^*hU!c7FVdm~ z#mX=7Q?r)r)z{g_YpYKi$GO!3&vx6>5nSYKSMQy_ztO1=x}U{T*ZJkm>;1ysb&!NZ zI9qQhJL&1xIa;jWG{1Q}S~|Z7(y@EU^4Rl!DLln6~;ArRo@v)>|tvrF%;%1TET#;xs?WM1w#+;XiK&7Ir z#<^9O7u8B?iqWDMXXNg|`pW%i=CD(a`EB+b(D%#hGCkDgqHEYcwxV%0KSybNG(V@= z;bF!`q#FN{r+?c2w0@M6q@Ua`dQ*vcyuQaH86ae%xlsdp`g`(8wEgzM#&?0@lMmaK zbb)j8{$R-0efh#89nOrjxqOAQ*(wT5=l(X!<3B+B0K>H99 zTh4co^++xH1PRqL?7Us3Znw(53==(*HVZ1=r^`Z&l`n+i3p}NYo!r z=AY^I?|-`3znO}p&u-s-+)M4&5>GTt5WOYw{JX-N%C{q6B{FvUy4txAG! zyWY+HG=VRj`#g45AAqSc(V#KM;}_)e=v99!0t!e>OU}>e@;&8_U&`TKMvZ{!=b+-_ z1-H&wzHEms1O~od>$pfD#y$03Lp_6u15e5ervJgePe2Tl$t!=HKZrc|=cO3r7j!OD zUN-l1))=bw9y9Rup*a_7XKIR_=62GM)9HIrzJL}eP-z95_xZ*vnV2=M`>M6~av?N3 z@g9xeq0Mi8)Grots<I3L@(aJoS*ZHj?sNixOA39Y45Dz&NB?jD+h+zADLp zW)lq9pZBX)xcCz0vXgy%V?+{gJ|2qi^&C7LCdm??+x!3kd;`cxh^ae3&*@D_y_cv^ zfR`>wV_V?s4(||u{5`K%*9b#rl+gFarsG2+`M}5e(A?GR0CUU>Z+C~Y75pKiJJr|l z%+0D{Sl5z2*TaL)>rer8q zdsd;|)k=;+(}pkaf)2`|raf{8x)%F$C(pOnnbk|p>k>;V8ihXp$WpJIaiY_^LU!+~ z@7i|Tb^jg~OLu$kuGw8aA(~)4j$Xf1vc`8`74F=x8gHoCWM`Hhd%D~mjrx%(2J(JV zD&z4x-TAm(L;gg(&B}&i0SjoMf8(@PLO8>+x&qqon_t`fjx!1S440kvM237*}q`^(KQ4;!hxr`;}~HQ@>Lm#xrld2ha!CFD}CuIgW3 zSTuH771!^_6JC6E6%dE|?}o@$?@n@8eSM^F-tVc1e;BfQC3S7yvRfw#IyigqG8BH9 z7hQQC4qb{YUh333eQBWEetp>!ZQVoP-0uP+QUKW*Xw2m8P$gI1c_*QDAA`CD{kMm6 zpPpTO)0OcM1V#OCl!BbMA-tgm2{KZMo>rZmsK-{1(*aJWcomt)tHsPOHx-VArb2Pt};K;Fm| ziK;Au=~O5=GjX*%~SM2Zij^M z--1%AKk)A2+G!PWD2ZuZBkZFT@9_!#!*r0- zZMl=e`s-t8ZkOAY=8~n;x}OF4)3-;XuQ?V!`dCqWB!9jh8a;pVMgn9ZXBIu+i!QvL zuNNeLktcYWz#r_sTkkx5O*HBbF(6nn8t@jgyJZ)BWycf3~aZ`mcq zMDA;7c?qe=!b%yKI*;mUzgcmX+QW!M%HmLb7in|Z0LHV zlykp^?(}jV+es{voZ|1Bh8Og(N`DmX{P&h&vv@M!p3_1%{CDNu(AOJQ(;+zU&#EJ` z=fBe3&;Oj9);jK2PXlk4ta2?-(w+g{S8Hn-?StnDCoenC2d4rBUir`IPMuGoN9*_Y zu9p?kgRoRjHn1W5dG9VC46&kq^7yJM2pVut-9RbE+ep>r1ariM`#!V1`srq8p>Ygh z=0vM1U^}Sg`XXJL^$C9+)ocP0H6wk*kUGE2uJ}5CKK1Yq`3m7|Y1A1E7BO@QQy4~p_t2n(+;UA~Qp#faX{rt*t zWZ&sIaNnu3pj&pV+fp||p&Y_FOPSA&40HU6*YOyXS&k9#i* zuhysK?JwV+cwYj5zqy01I-i{aJx3x zWStFL1&o7IrU$Td&J}T8&38MYS2rl2 ziQTwFs1qla_zIQ~27pw_><_|HHgtW}$pjE~vppQ6J3XDpj-o35btOIuD#SmDJv%C3 zeL8<>mYyLk@;A)!=X$-X0qI&zH#eVF2s1&0us$5A?gK~h;aOkKGSWpwwHo=cs`86ICWU@n*M2Ff zW5DxRyVhu}A33R`BeEGF8H@Ma{PmUocXtdW;xfF0F0~}&SNuo8S|*4q6KlR_^s+*X zU}XOi-=pX4We@*s*mrtcdNob?pl(1s^W;ivhmhN}SGU`g*J1#|_c=)u*#zm7O*dZw z$;#{O)(Tm(*qMulk`!P_ePY~Z+p2CZQpG_@&5d)W43lc(o6z}E2# zO5biiPvDnWDR7eGI?qJ z^xuv4dz60j@loeM77ELTM!&L|^R3o!*G+$hXpHSfI6q-xVrIh#Q$}Qjv`J&;7m7IR z?$P<9wMA>Yd`!Kx%k6^$ZT=74C#+Oq7~^$9)0`*;Wo1m`ZyJV|lUvC~q3@^`atuI^ zZtmazPHY>z;XvhK@&}nvS)ay%F;I^F z?;^UAE11EWkpl~|r9mE^g3RPh$K1Lw#sE=C72x=!Xd41|6GiW5T;zw92GUq#Ngc?@ zuaY#n`aF4lNtH#X%2O97+m1#pl)k@?+2L`#P8D{Ljg_8Scn#cr9l&!UfW>Q0vc5{fofw$`!Kx*zH7|$inknSP>V{2#a!Nn|9+a_Xw$Qs3P=Mh8* zq00!C#L|w*AE`r0hx_*U)2!@Q+J5XMO``;-`0wT48VkCkh8kVgQEhq#o?$g}8;j}- zj^>j;@{?3))qytN3b*eE)zxJc@b_>vOzGR!RM$-%>RhGTTxG{4rFoUoiV~-_7q+aM zG6E21mS)BCvqs7-vO_4k{0v-mG{4mIk>;rr63V-)5x3_hH?0Ify7ao?2QKZuP|ej6 z&bKmX3}vJcf%@%yt-!U0e+HZxR8_}O%n+ADh(9vJ^lL#5U77#xv935>T=5A4vk0kd z#pEO9Tu`Ap79oN+4Uhw=m%B>eppeFd8dv_|3Xrwu4?jcQJ3{eKo?|%wuGtkPar#w3 zvKDi`?A?3lW`w26iLnF}R95!&2o)W*MDdmGp`S;_2#-)aLyiA zXsXK5v_`R8U`&uELq;J7vgzt_qlm~>NT2|rt(u~=U#fj!c zAs$(AeYbqf9Q?>CBX-WPK*JnP6&#JEx_s3LqucbUSp+S5Q<$FpJQYw$TCA$dj7AQ( zw}NAJUcA_qaF>4Sz_)Nt*h$i0USo-9*;aB~u=f*+3S4Ve>V*K9Frt*#r(>wiFX-q~ zXp+$6l23WR@-U@t^0-ASy$zD27}8M=s`%WTO{e})o7B>=yC0nc7x>|5OIv_ILXocU zD1~X$AFupSH-`u;S*V|MQC5T)vSjA|2=q9PallpKO&1pMmixVftNp$xu_Ptd_1%!~ zJMYhLD1olfIc1ne24gydq&Ol)!3Uj6-XrCzmEi9#f%R}p|8ORi1%`Gx8o^(l1te4F zU3F5~io7G-E_m`Ho^wVs>bcBzumuz%r-6bPg2>qu{k%x%DG#Z*3-}5n)h%2&2 z2ap<16Igy{g*Ml5Nt+m`Sm>mJoh?2UIm=)U4xYv;sx?52d29MEJ|UbUnzIkVOlH7g zH{ap*Co$TzA$6a#vKG}5rWM(gmG#Xb0&cN`|E5%wCaHowvQ7A~t(s~g{G_DKYe^L- zJ~{0XybrgQ)WT8Fy`+TCXH0`SKoNynw;R`96cLGw$lq+UbA)KHu}95#=**j=mOCeu z6pC%AVvci!vvUyHG~>@3Mtx*&=nqDX7>w6lsHIl5)5liOQrFOw{AkBCnZci&QI50M zEv+YsQ^W_VMWXd&*Oe+`83&=1$^%F--pmbnzM8-uTEN0SyZUiL!^iAJMBc!}yrR+FWqO`Kw2rlaS~S|PVlzG9|_2s2-!f^NWF z2iGp^V+4cjY-+x~I@bpkoN1yTvgcZ7yY|IV+k6owBPdKQX^e^N6YKY?YeS?{fy1gCHMCntnqb_zCw?q2l)`tM12` zs$i_~wza0_fP@W&u56hvYU3g%W67>E1xqPq-{J(JLx_ii-7G~+or`7hj2M;XeB=F= zctw`30NqQKmoHK*CesTD&Xm z1y?PFC0f@T&1w!OpJ6TP7%gTS+)z0SFIDrwGk%l0HHDrc~7LxrjaQ-}J{Kymg(T!;^Xm&I!5uTl$Uj!2^5tZGggCP?)DC0x?h~<-xh$Fp;_&w*OGh}e#*a&}kD2l@ z2dp;Snnwi+`t95~aa2>c>?wrQfMwd{G)mM*wjEhnqf;Yo^7Z1`GlXodi;eQeGuO1$ z>pPa#igSNTkL4>Gei}EXoe`M{W#{HjOv$Q7i|6xkRoa4Uo& z!}J8ee&xzn$QpIJA>Tx|klS6j(pIkm&-6IUTNH+Fgd zSAvJ>fLj40HeHSCU{qGGFbh6%`q;#{69$0(mjdRED?UpJWe>-|KI6>JPMP^?Qeo6x zktI?!RB-2*AZ%{X$uvrpTiS2sVohWxV8O=z?;~)!8NBYcY~=}GDfZq;O`RWvY!Gjh z%OD}s8QI<`H`f^ULj=E_BOTcWMD098YxkQ1s(XV2Z^(V2NZ7Ei zEg{fy_XsD!8`2*3u4D6}^<~!q8dvZGr{MKMA;w1IgxWY41SF_wKLQHQI5 zR{QGDq!u0A2FR&f>Dvo?b(}wD<3bweW_CDRpfj^Ocq#M;3Vpq}!KBL2(+>T%wW}e{ z;xa7=ADJJRFV&|}l3+G6N?bWic0IAZ7?N<6R~cg(f1J#*j16K=hDn9N@LXFqK3~Y_ zL@`C$-LXQZvck&6ZMZ;k>Lb9PznK4X*SJ%{h;I`XlIEK`I!Se+8SUkqUPWdm!P!s{ z?`T_asE-47wiUa-GP5uZnZ0UXGaJ=*Vq*OG2$)th(GizI{%CC;ATr?M{cqXU;vyw) ze(f)t0E2`y@@4wAmL<~VuIy6WZYZ`qbCU)`5Hr6(28ovXcQe#?_06L@1r*SOKD75~ z13~m#IiP3%B>59Ji4K}v5|6N$1t(wb;4X(n-ET!+2aZ)HZJlgI`4~;vIss1REUe!}O^|Uh#c@GFC`X7#+XKJeh*3kf7cgxN-`6|H7Dc~yTw)8@_ie;J;~5%C1ZY-@x~m}(YmSEDlWm{1o-*i120YjRYPkO#eG z#?sYmOU4zyWX~BF&rF7_?L;V@+z=JUmiaStzl^Sw&J0+U(dwdl_z{t=9-lP0(5hE{ zKtCa6){1b#WfqbiG}Hd>%p!dbS848`6Z~hPZvHN^|c^MtJBOGzA$#br8@&`+~e(gUgzp}c&XFNEc?A+g9B8U4# z?7_qrJuCP%`S^WR^@s!QPKFX_zf)8H)sTqIY0;Ya-BnUyi-1%uszAr{ymWuBRi+J; z|CGN^ts2Y&4lUF_vOwv2dutq&gBkPGnO%(6**jowjVYl zOp;pu8+w0MsU1rd^~>dQLKkJa0{C z2TD^cS4*CCT2~A7gH?(%m6T#(Z9Zb(EZrw)j?6!3jQe^ZOUQ(p_mw>jcP@!>Xp8|> zjcc-Q!qi;Vp&V4TKYyXm9?0(U?{1}(7&*5TG;z7tyAdz_9s)zl+ko&t?Cs}Dog738 zb1oIBWFAh1-PsoPU#>O*o>EH1>_zkuy=_J5vc43>;g*AWN~yQ&Gl~JgZ51HH4%GPV zhM?<4XyJFu9w8+M=U~qnNk8<1;_MW*yB#U9I9tfBVtHKe`^&YlH5jT>ws!v%?);^@ zv{IVRl`-G1sUnWMad>$t*1Nd}qNQ14=7TMZknhUM6jM2BLsFZIQcZOyQg-xJSi+EJ zN>UhXIF#yt^d-^8mi^E`st;cbAFv{u%X@@x>sUVZ82FFfUS_sEZsCOKVLqq{Tli%dsJT2S${rI?av2cBgG*>=8 z^_S52nV8?D8gqh^rw4&`;6GZJ>ep|C=Ry`7+paRX*+cnXcjq3SvPePm3`8y!RW{l< z*ZPXF!zr=&JLvKB!)yI+$=ct)FZH3FVCMM7A06kzkyd)>8Q7z9=?z1YTq#rx6L(Z~ zSO&(T!+xl+Sz;Eb`4-+9*_Y>96h%_*NAy8ANbDq49+y3yX((m3^9n-vLBVN&p7(uy zGyr3Vw$8ETz?l7|8??@Ewz;?xZHYLk z4dd=jJ;dw7bmss(aVbJgFzSJX&VYRlF9T{jQW+msr#eRcsQ6WkE|OJ|V&;m}+61NM z%ub!IVtR6^Y90Bmy8$=xQ4>PbDH;k-hEVfR_D?l~dl~mQxeNcmi?)fm zA=dYM4^i8_8XR%1!x)Vojn?K*&F#i%H^;0Xq56$D3er!)pJvvOPu(F2uZ3>))nwjv z=PJ1~qvY^rcYXfR=R(si`laeg7CH+a|B+)*$<$E9(bnqv7t-lzl)|SiFTeZq^W&u_ zh2Iq})&z5(SG+UptiW+o715F18MBd0C6KcAaC*``dLh+n52igZ>lm`TVhgu67aPj% zVwNnVw~?jhG{ADhj-FP%Uo2dd%y@8IYVDI$$m)w&JT3+FcLmrSX(^jq>|k?;S84_Yr#*T5?*;6ciM z$fe<5Y?{|52UzP}g1Vl5bN%R7Rc3fZ^5Oi_r9_b?Z z2SAJlcgb)1~66i;A)C(vsw=wjmOG3g!jeSuR7z{1s^`XGZPIg1 zf(mwKh7l_05~4h%iI~^QvLyI!VGHp}rXqR!t1nb(Wc+g<60*HvuZdi;bmub|pXFaIl_2m^AN#Uset8 zHOGSO6L~ta&ok6UA0pU;Zf}*TixEew&t#l@QuBdaurgIq8)TsoH%Tg zrHC=%gRj->J>&wzF$F7}R83aJ{~Vp<6gr5b5P5I6#3Vxy>ypWBy(e#&Y)9>5CL)^4 zM8oN-s8T4)zCQRl9Uq0KcaPVP=y)z_e9Pjl}SImnmIh>!zGE&>`{@ZBe?s~@Ym zG}2!(mcm^HKJ8LBc6dAD^r1Ky+e5#~-WmcnF1GuU+dgjQoOp~YG+U85%-n(q@Q)`^ zp$V0wh!AH6e~aeym9MJ(qfJj7pN>VyUT&H(i{EX*WyNt(B+$Fre5d=bQurj!Al~x* zq(*)@4aBO#*}Y%(I?P%kcvKPG&a}lFXFr6PJ(xRB zs?hujvN^R58GGa*8q&Xh%SmPrEnR>f~9Qm^q%*VMphJZ}sVxBJFj&wYROGS88o9a@!nR713I9 za;&ARBRsygG>UD^o7r+h(yYrwm}tD$f5$oO;@|*Wuf9etNya|>>k%L#Awy}yh0{+_ zooi#W-{!Yy{NADQ`@;!(gWq#!ldUWG!!z-}NzU*Q`9Kz3`LDKw$xUNto}pCM9~zbq ziRBFiohUqbjCaWaMgyzwtDv$yEmj#2@`+K?LiT%YS+aqblSp$tlg1J#(NyOOPUJ{a z6p>XV=%}u$OndH1Z`v}I1TT~z&5}QY;!&@klKyN1vNQSewV2G96t}Q zF@`>e$NgMAR>M2JX{+;gOwEb<6I3F9TZlQyvi6TZ&C+^AwL&Gdg@0UQt|ni(4ybYM zHNzoEk(Q@T`T=H;jdy=6fPx_(vTR!@TtWmss~p+!a_|@(8em&S?!gCG8oxUOtoW80 z9uM*1xiDF9t)?+bbwg8GnoMubql+W5<2V?f7{XodA+y7U%53yD%cw%a@-X_Hg$7qE z6_S1@3R(Jpzs$tQw~oQH2IaTs{I{tmrZw6mKws}AsL1$s z;Vc-2F@4E2&KN@(lg~6>lZf$FyFn2G-NB)y=O2bRO8;-JICe0X!h#1Buzsr*l7Irs zZx<~F+y;^_aCKU5Hvn{eXyf0?NmQaWsQkBwK@zpX+y>}BbwU&WQN}{Ad$PTA_W2a& zxMY%k!vD`#`ro3vLCZIbpD~9);xNc>H~+U09AzJv^xxsb{=c=*rU^|Whx|NhqmO}h zjQjuXSPe@2ws+1j!Kaw~va+fpXN9+y0i<~U?E(`%^^Cj6hrFtznwbCTvdNGolx2A< zCla>CCO{~{ckuu9%P|rI3pRM)$6$d*MimDRx}e^E{(nY88-BcQo=6+&bMsccvH8Ep zkYfZ({NfZE?CY)CyXC(lUxN~cQMw)fX(QyV`v3mRoiKq}SYlpCk&T9ig-(RP$$uWB zWBzw+1JQN(M>NU9+zl4EP-#v6zZOU}0>HDcVO;++tY6+d-J#{%ZU{BVk|5$wPuYpM zx1Q#Ih8N&3R!gY=pEiB7czdn`RnizN;QlX~zB``k_W%E&A^VmPLM4O{k`@%jGx>wesKH}CVluIu%BuGe)GBH#*G z!XIj3(MYwEfAZo&lV8@rsyY7e1Bb^vj8a3ikAGkUYaQH-Rokj_;t%t=)lZLoZ0X)z zY^o?NEpq-P)4R{`=SPGDvG`x9u$_3q zRh-ASBR^WtrKSX)PmiODobC2+@G+j9qNb4=c(^?&U{IfM#aG=USm^S$hIAN%Lc-gn zphmNt>}(Cr6u;&N*dh&!JhrT+aR0va1{dmWQ*j_C8; zl9v9m8DeUhgr1^u==1;e+GUBG=p(A6ojqCck z9po-*D#jw3p-xFjX;8L(6rE3mpr(Rr4uXo7f<&0Iv$F^0;Mf_=DJCV+=gh761>e74 z-7{mHl86;?_wZQ#)tgeRnN6$UJ@+O1(xpqgN$q{JK8~222P?HBO-)S}fwQSh=Z(hP zb{2=r9KXEG$jt1U+ssfuWBX%rvMqRbb!==5V%C4@0A^Uj@S9>-!{c zk}!iZPv;<9I34b*jvO8u8gdd*T@B^vkY5c34{>O8aFB-d)Mtmy%n&pF^k&q;*9B~` zfO*rm;bGtT!OP9~*70S=?tq}6{n`B{^grC+4v@;} zwUgI*TULfc+xOSGHkIUWIGk&($(rY( zm1tIr&upKmXUhe$D8IFd7W@9R)Wia36V4RzkiY8!Ff-vK(&Rm(STOWLvsg({QC{aq zlW$qCU7wv$XJ=5xfY)XBS&TVA}vfIt{kifAyivW6ZX?iLI= z`LfbqCw_dB{#0Idb#-yEV}IHWSWnTcmDXaLl2QptNy4MGY=1W`C@Ao2ZYeH~p&MvO zd>07Iiua$)&dgk#pJ!xbT;B`fZBwA@aviB?*%^1eckdoWC(76NCdK`g@msO^0XdVc z4`A!f>h6BH zc6`_-bFf?upQ9{0w6?}UuxU2Ovv+P2w%vo12@{dMRct!nC`JKWKvx*Lbxf<}fO$sRDz+9B&oN z91d58ruN$HERSuLdp>Z5zvkDR{gnQP(#5xndzCMVuVyrOiT%Uo9&LR}y4qp2elU4_ zw26^vd-raAhV594KJL!`d_mT2&()9oN z{zf+FbzDO%F=}8v>VucQm&2mi+S+OsZw}_&J4?-q5@TVUv8npIP@H=-7j`tazAo60 zj<`G39zn9pQs1aoWhC`re@o_Hr;J%^NMmK?TG;X0af|B+e=bI;h^4ZQi?g!wX0U>V zl(_g_O71^9H#awU!IKceWny9yO9=k?gbTLMe{vmGgH9qlTU!lyk7DfJxN9XGn5Wk8 zRDLVtr?YP&5N}_Zkf^2E6Pnp~|4}&eGJ=9$Tk|@`X_AtX$C%?i8PKs9ZIQ^%>Gj0W zt%A)tOxVAT9>szx*pnqC&b2o=jF~sqj*r$V+m0kOu$8U*i~Ry^>IOHSG5k={jt!mc z6VT+KWrP2z%C-k(9=2T7lM}kX(9|T6HLyeYR2LM67Elr_RB85>0n<@MMMeG-fpbs} z4tm1=DLvh|-MSH9%Og&V_$vkd?)#18AJbxAtOTE#C3jB4-XE=XP4Bh4lI`T`>Ut%K zu`&QoR&a2zVOBdx`%qU1%OZXBcc!(qb?w1g@L4Jrb_MRTk~e4fg&nHL`qKrdDJieV zejOPZ!Qs@pD_Ji5@+P-+6Jg5A%Cda0jZEp?x*fK8d+q&Z0^Y;Z#ig{evMtfs27y>d zhX1dHBasR^Z#~w@5QrrqH_oA}8d!(w#`=1HFRyo%m5J}!b1?#ZeB7}1nwyRF7+M#IP0&F(&pTUXt92v;6mA0oD5NPrvp(`tX>9Xf?$5jmWdc zm|S&E;S34|9oEF2xlLrVN@fvB#9cMDxB&;=RMnA6OK4zahtKVV2s`-q=Zlpi2jBFx zR&ezgkNPm{`l?Ii|1 z0UG!Yt`#VHiZC6ncT(F{jaHa9=LGzG5*>Xe%|1Pv82OhTi6oDbXnuSCUW?8l0UKi_vB+5iy<9@Mmu?5Undq z^C(0*w||ySp>Z?(*DdJR_&Rsy?!P~~;-K7Lrz0EG1fXbj?y}LGyw1}u8**~;hwLIE zB0mf~X>DItS{Z*|KvlThywq)!Hrw0VEA05?dH?L4;2o5||K#R2oJ*#7O-;>&garCH zg?ij2iZjg2%y2XwNL$7Wr>OYns1_|$Menr@b zlAPkqJvfi9u1oM=dU|>)Em{`6#H^I$0P~-hdt9zfr;z*_87~4&GCi)yIZ2s=K2C?u zzIyCo$Ez{7iVFUZjF``#ikSCS)$s@jg0A+Ca|CLp?n%EMnrOlR$b-aQUW}0(5pRTP-XN82$$7^ zPDa450~nw++Lo4V6lZ!H1XRAiDGl0Q9L~r9vjeJ`hew?eUoD&2$TqCJZBN3Jd@(Vx z(eZIr1INjXb62jm!l~lYd?^yzT-&_qJlJI=y{$+6I#JNTg?Z)l+dS+{#^szxls4gn?E8~Y&>6<>?B z^vs+)MGQSyM1%a{JAg_F2~-+bbxu8h|JxZe59Y*E&YgZO9J-75*8)tkT#c!#sk!S& zfk61@^9pu1Rdn(Irk7Amqfxx_U)k{Z=%`bzNtrmOZqf{_6f7xKOaTyu%!yJs<}L7= zx3+4q3qNX{Q!sPQI8CLd3d?4{6^6FIT|)&*y=h|@sZEL=@2gj@%Ips%LeqmSXIT40 zR0B&Nca4U0)J+tIM?7k6d#G|TT>a?DwcP+If60r{)&O5|IGhHj9v^)(pwy|US0hVN z--+8hAq?{_r=*nWiM(>WN=&D06WbrdLfwVsvFf&evjUZ7jXzNm{>!5`#l(~ytcJyI zGTOdW=j@yo)WF8a$J?=PqdoPJ+kmEIj`uK_m*Um%hK~0wkC%=P4_YidC9?VH<6!-q zJUk{Eylra(zPGg1^DXTjP_s%oRT*`6cLP@Y;jv4AN`Ndiu#C~(jb{CvkmMZ_!TBTlgZiZT*O02}S-dJVMSnIcQT9XEy0%w$nERYppu$E;~Czb;)|US3YRsszW9 zEB5E_fvj8r426;&BR>DU#H8-rDPL*=G!oRpnc_Tl+a*)<)-B&(pOQLbsOL8KJYn#< z^8FuGSk-v0-r-+b=hn}MUuK#kKLpr*wV?2XMwfbheBxz(kf&+w$IiDjiOf{afU zZN*qPQ^$ofJ_8Mdy=spehI^;n^sH)R*4i*!pYVYIBY z6lm4n-kvf?vO4E~av14@<=wX9LjWbr6w!qja~IRD_4`#Z+UlC<(kWyOH~?c44Fd*F zK}l)e;6-$K>(kXlDS&%+c~`netpvArc8<0!k89aUfj)J!zmk}Uy2)vJktx3W%NI?w z1UjgW*X}2coI`bnJZolAs_Hc)GOv~(EGbj+A(8#FLcjK*gQs$+0I$u(=+UKW7Q@*P zzI_|;2<;PjKnj_e$@YOz-eRaO1uYb&6Gyb;i}-HDxn({daOhoM!Ha5qg$q$JY%-z$ z{_SnT@*c1q&xF;~)ft>u2cj1|dBB>XgFIMNpryY0NO@l+%|5Q{>)04{-t+{PN)}O5 zKKioZ(oz@Bl;h81QDtE-{EGaP{< z*Gh8KURIHIMK)(VTTU%4t%^-cOKWYF&KmH;xf+CWT-EE=M`{%60@R8;k&FJi@X*Hr z?BTM%t(^K)F7Gbq0w^WhySwlV&hS#;*jZGjzYaC1y~uWPx6paqrFO!7SdKsaU@DTD z-?A0jaCbcOZ5U^&VLv1HY1-?XkZ!P})Z3-~(a}*T8kkLht`5~VDXOzbwI$vt~f_~d;XW~cniaQqSIJ}YGS)UFoFCcAd zF;7b)<;p0DKP_PwP<-@y$YGaSc*P?PDOSD_mop6R)+y=Joo0eA@ni2-b)fg7odQ^Zm88h2o&i z@%n8hpl6_1j0hZL-aOZK5*l zaOokt{_T;9qCc)L(I_qrtUl8GvIA${!KY8k64|S(s}t|6JHHYm>s#z=a}#c|vawOe zbn>T{wX{4y9&jbMkgD)#=+MoR{!i`vUT(&JTSCHwC)Fs;*Fccse*J}m($X~5!Z-$j z*5jiCF0GuG85tS5xm=R3f4D!3nF|y;Z8EamyzQ9Gk+i)7SS++{(xtYduE+c`6(bv4 zqGAD^!Z7k%>l5p3B~B7o#e)Cp*iRwCC2!pLS;0*PF+f<%LS1JMj|wyXgOFA$L1m8z z{xBivt$g`@!H{ydy-KX54qd{`Q^gtdb)GbP@dVSrdrwgk*#iz26iUj`=jLx6rIl=8ux#fWl*?DANM35WHxR5lAXpUbjZqh ztv2_s-2(s#y?!5VX};lfwN^%S5Y!Um6=k?}GDLyTe4f&f1o7_3>Zw|xE;pTOF*dVk zFQgSvh-9_l>u-ue87vnsHu|kF^`il^Kr`l$*anKkijWJg3q#P8p~aej)WX-QXx zf27~IiUd@cM^kdeQ;-pqzS6~ym3NWD+T72TIh3#c1?qsj_U==+#+X~0H6t+B@m~xO z{2=UDOb+Aa=a@M_+V;jCuCALwExdF7VhQlh1X{L|@g8gQ^Dkb!fUQ0pPnvEI#nMkQ z;}QI_bPcP8CVmy#?iWub@jHfgQc5(Z((DbhaLM-KOz|M7!fOUW)n}cFS}y1(oG(rV zsG^J-#Ds-4cdKw_0)Ymxq$`n~^Wp_}dOxtSl^u{mB~z3bXJGeF1g{3`x>3Of+TZ1KNGJgnS7C_v3yxI-=IK0P*Z;L+94b!01kDu*) z=uKrk8aaXtkw`j)M>OZM47ahVs)ZXH-smSOozq?*o_Rllo-X)wz+onk73v2;m2cnY zP|-ahpHOF(w!aS#mrF^i&^&_IZ6)X=$VdZ#LXY?T3zj}7k#RTCf}uCgCVARMb;3o? znd*i7sj9D;43W~gY!@$HWM;R-TQ`5IJm9)nHa(zk6DjZWgrER(;-^aG>~I2{Bb2C^tai$K8SlcHXrpPS@x3*Oy^Mfb!)hd zGNu#CAAMY5Wo2b!V<1w-yvpc3D5?DE)h6YTzqC7)U-9IcX>Bx1uzmpwkx?z8z4NqI zxz&SM`6~e3Gt?DFeB-*%D2569ArXxtv&)Z^d0e8B{Jzeh`CRL9=KO|Nk{-)nv6I8P zL%|FVZtk^CbEl%RM+DqWbw0=XGC-%$$$$R}*-#4%$d-t9! z&6zW2OiWFoy~ynSN=Zuk&wQlbZS2oiHG%D|t@)-<_*H;!c~V#3n+CN^fa0Km)h*E% z%HU9=Nox(C+XJ0q_W(o!5Jf=0oc0nsCHraC2aCl5ix>A@{FZYk7_@7H1CrQ$u{(Ew z152@L-MiQ6GJ;ra%F!%N>E-D0h8MUSQUnH&HlZ_WbEY&x6fKIJLA8*!#~Z{9YwHM# z_k5CiB@$%%!FlKZ&_j{7?u=IE@PVh(=NX=u2*ve-)&RU3=z57>vGm@r^Eq?DK|vfU z(3l#0W>u?DP1!nhPt1s(l7!JO$8n(tt{GA!GgQ7BJkWZS24c_Y9g zWTUI2LpHOB@=PQiMNAT8kt8b7=Bj z5sP4rWDbzUp2!1hy(uZlOmQYFGxMe9+}FXDv}S+l+(h{+vp!=hekuD~wQNMTF9#g1 zCMk2K08?QWb@LKqsST4rSPc+r)9uWn2RmbqYrxlM`_tV;nKiH=(E}TX_6#7-RCMS* zTQ<%0rvTL&!Av>NrTH`=;mg1PU>{*XD^6!3^Xlt&q47WGaCUK7goDEtvQBiJYYZ4F zwC1^-;ELMX)S?CCc2t**cTiB18GqKm@BRHC*u=r7{e^A@+u7Oq`F)?+aKqKbKO&fG ztEX-e%GL$r!CitY0PQZH8_IwN7JyX9;<7Ac^!(F&dtru(o%`+FN>v7Oo?|z zHJI4gin&Xxs=POU4{$`Bjz1e71J@;5UHU0j(cIi@Qt;p9Z-ayFoBuKs)4q+2>~3#E z?*aM+@}DxtSLkGirhmNo)0aRf2l)m#=L-VH&TtDygGK?QUFg8M_Nq9b9UmXG5nmJD zBeAE`+ib+dy(}Uq`bpP>AF?}Ta>iac>F6@7iE|r0 zY?F=mxh`tmVx;h=_vQ)=iH2wx#-SPr3wNq22?>W#bB60edSM&TRv2Z9_W2DWa8dqddQwI15X8lUoengYMFoU3JPZG@>3aY;oqB> zz|V$1eDqk60Xv~vqM}V^6^pJ0!>1RUTHn1B6csh#Pd7C&$;`}jF+(Uzb7yM;LkS59 z`QcH&ySocQMoM`?-YoP4A@8r{1MlpNqruA!_oWvG{tO5JKzs6~s+--fpG#icHD@YF z4ujLpng}FVh@#pVTLeVpk#?h5E7W!|mO9)D+`9JqbKtGIx2%^LDF|{rDBnQNFR`*t zz}ta8zIj(Ne%XsK)w|=qkB>_L!NSZrXZkgo!3Q7KA93k)K)d8=bH7jrkWzG)UHf1r zoI@o~dmh|PIG2)s%K>m&%gX3sP^A4H`R6Ix@a;#a(A8M`gN0jcg6Gae0;Kr*_wQeT zzz;jD)YSUF5*03TC7VTnYHV(9}p#EL(2(Ld>sWN(*n~RzCp^E8T+D#y)0GN8CId%l;g^EQ@P)z{D;y0GgngdB20fnbLfN$kN6 z4NY$cxn5NLz^IlChG=2^M9>mYRS+h?oSJ|`;&uiaAg>jV6$2<>`*CSyM2q+jza=LX zcrslxzyJ8*R*&mtgT5p!4O`2Kpxm-wN6Pv&TkIQyERA1v%n5Yx^78WW`2%IJSSuH* zw_42EQk62?hu_WFm_81bD+kHEv1pKE;7?&L+Gq4V>`@VsEpP_GIa#0T-~yfABTJSD z(W<dtX4)zmoK63Ct*faY)ITLR+OW ziHzoKRs|g(cYr?V6bNogOG}IY>ZVV9E-!21@%~8LQGM7!eTeii*qc(jKkfsk{w5io zMuI@}PrNxT%TC^@Ldn-)O^j&mv%b%hnwgzl=-dRS#Dp?(+1!Ya{kWMj-kXF_(;Dz%7Fv`ks2w{U-M#L=-Oa{ zgIfv3tQZT43$1L4+3lbQ(z%_}MiSp^YIqe$1Eq3g_EKa(4ks96VMm*}xiVo#u&|-< ze}U%hYB^b76ItnjGFq{*H_pk;ZG$ZU+vTRPF!scw&pSFg3jXrz3K9o$_&)q5=-^eg zwcFs}{sys+jr7#&Rdxu5RMKS@_3oev*_3c2K2dS;>!csPo=WSmnxCI{a&wakJNic* zx=vDzCA7<(ogK-0X0iD|7eHQg&O8DD@Brp4+WyA1jkW~uMv$DX^T6|vet7Vb_S}o! zb>T)e7;EUYgVr_O83V$VZ`ttvuN1AF-CgGR?qJq(5P+zuj{&rcgIJxX9k9{G(6%?= zxjJ4O_mY_)7N7|79jEyS7bjeQi9>T3{`S3TTSg`)?0Ca`A5&6~de_0AdTd)Bj0g&?TdhVh{w6G!yI!0;RK`s3W zb0nHg|PiwJ@E9%CpiudFT-wEVZE3 z+~q4ST#}G;0!RXHYZN{nIL(x2NZb%mW^VaWzLp&H&32O~y`_ynSQ>+EFuDJ|{uBKp z5b6Hq_1cX$-Y@R8%goIM=n@$j>7Ve|VC@Y@6qL&xa0);K(ks>khz}YL-ZDw{kv2eC z-pcoKqGVvXlS1~WZ&s-Lg3Qiax)UdyuY|`7` z^xo~BMojUlVMPELJA^G%$aDBzi!6dH5{)%~e8x>c2x`ed7(1-kmud}}MO`x$i9Km& zA&yt-BANxi1DK1Q(1w&&LI`Fs{U2SSZV8ic3OftP3`bt=6nuy`F5R(nd%=Dwy!v)r zVg1M-lZ)>c2O+Wt-^t9<6WC&r9AmOSxBHJY&Av=HH$8`I>m%eX$kFHN1JxhKlM=yN z*bz;AMTV-~#&aH+zhx0T4%<0eR!OLN&wS+CUx==I+gI8*o^J7a$mz`Mj`r~By^VKL z|1?=>My(}3aP2%vJe>UdNqXxXQ3Un+pAXD`XCu}+|?nxpX4-Oc+dLd8Ivy)Wvyk{#3f_^i`Fv}l$IpL?mT~;yFj{HKibO}JaYXr;d8|BEj~F#+d+4-HGR!@gIXf)hR+2?TXU1p`uiXd z7GkW4j#+yTFEJq6dt|XKAUC5VYTYGiNae32RZqhYp^hP@Z^zb{l&?;-97MAHW2Yfq zUR!e{NP+;$PZ5iJeAfMHO8X9?J+ zsN4V)+~YpOR@%5OuRO%me|h1j*G1xcX8b1~>=NP=K(;t&&&70Z1W2X#+Y4pXTutfy zIJ2=5lCsiDy3L0O?{}6o^{X|xOhS&BlC8T_niUNFv$S-@uX)x5f|f^r(m{HvHHj?%1?b?g*Y4{{KEa?Y zb!3S$N)FAZcZWAylZyp4D#${0mY7JEMl7N8+G#{Ug1`b!+L)I0;9oFRW@;VGR9O9w7e=I@{udWD;*szWNBE7tc^ zlK)Z3()G7_C%eKQEt(vp)|H?gTAVFw9ABJcExZ8UnQmnkOU)@BR;EGq5NpFh+v`xh7a~0etOqnmNPVq#RFNP8P~28TQnUCkI|HM$K2dUc&{`lp zWSmxOQeK2DDRO>(8n6tED`{$J!H-R?p9njCkc;UNR2O4`xX(!{k}j?bU=|*a*XQZ- zemSyK7!gg1Aw~p<3M@m8_!*y_6;ZpIy=iUnOawSN(z&jge!xHgDWXvNWy2EL2^C9m zT@P3B<8_zFqI?>EKocpJ-Y(HCdG7N#ALNpS+2__Ts{0LVEQ#6+?h%nsoevqAj4mF$ z3XzFyO@VZH)zU0fT;S`T61h}vpoScV{m)3DkGvx#MIruS+Dn9~aGftULJMpZqo-8N z`ys8>!jx6OwF6>*c-(fce-j=Bg|lJYb!6pi)5ZUC=k%NWham7<~=rB#eA(T`1r zL`bY+0f2KeTB$S$UbCh2$T~WD-9k+9G=_OhxzsLh2W1v5Bxn}j^EbMn;4H#KfLYad z+3)Jr*;c*aPzj9T>(5Z<1g|SaC1+0HpNUa6aeL1rI28AdcwauiL3&rNvTif_Y-B{m zQf85RF_nL_x%r4vK~g?9NVR3dKv4%(?vX_T&FQj9lBg+h=4GVtVd+8heSqhYPH-n8 zzi5Q;>N0p;^gRhRBhidxyxGYn?yx2jynP*NqLFojP}jJwZf}pPsxAlb_&0hS8-f9CiUM z3)a?o98xEDXUG@mFH+uqtymr+%@(hCF?wSnQZN9%kgQD`8$juTy!%)Z@&0bzS(5A4 zc=TJ?b}N3)lw%(CTAG^N*w{s5kYKCF9(7u0GQa4xfb8Xz;kf``HNivEmoD+dO&hAx&bBy|HF7w%0CMcUm|@U4)5pvU5|a zHvF>dd4v`2f~zsT&kv$0UGc0BngV*&V-VS+Wcl{G%^l}ikBjVRNAu;(fzn>0pPzSk z%uO_<_t)kgM39v^oKRDZdJ%I>ZxM(ba#%eJ!CfV%Kq=NzM}>kRpGI{hDuy_4v{2p8 zY^LD+6=O3riy@~rH8ph`D1}Sy&p?Z`Sx7gjbEYVBypiEeQhuDzO)AGtmp|Pjol9Lt zj|dR2;!`_c`wZqH()%2$^O|2^7oIo$32w1y#uwFEf}IPcBj|x>mN$!1i#~*-pk6_P z-`sPj59Uezb8xsC%>Nc?eTfv2P6X{zp!951hi4)Shzux+2TR{?U_~6O$GpV8`L>KK z-2$zzfFOa{VnwK_s6vkqCM!o=b1@80VrVw%Gf1R=OO80_%UFZT+)Qn_#!rxo4)U$FcT3fFA?_4C@w) zHSpgpDhR!**EY`iQl6)nJw8vY-zk6oG>In(L@W`GX zCyof%c{2dF;tZ|r-qHYX0p1)CN|>+4E}@3K6?$(exCrDQt__Y!H-;YS$f>rL^SS$Mkd7?wxDLo6t8#~ z+6JIO;*$9Y66s!R5+4l7w@_ek5Wa&nNMes(i9Tn_Sdmj9)|tuUu_`^n?2dlPWWvUW z(?sEp;X>u#m$p$7NV+J^(|!`!5Mu!Gv}FRo3RTQu=%gTp4jt@L$kEV|(Ve~A@ALV; zctx>^w@$6!E6BYaOhY>BPFQ0Zon8&0aOE@Mpzk& zGl4m~2ZztkYPs^geS?@1!mXZxGgWa05%PJK{&cb~(}GRa3w2HaQ4r@Ea?(a4tH%II z*6`Rea$xV_Wt}GF-ys_DVAovrVPcm}G6&=zldtAtpwp#L zE<|50{5&{$YUu`|LCT5jvIMNdxtH-)0Gqx!AOV4~3^?eGYn?1=etR z6pv4}&uAL2mtC&mY4#f1c~*D{$N&{QRKsYaFUHSWzU!@(V8f-k_a^1^ai_c56BQx6 zoH@W*>r_%&${kzeoT}P2w|P3U1A62Wd3hbEcnhe^rkeRrkgo?T52b$=F_rv^f-k+l z){Or~Kj9oGIcEMQlqPd*jbF2d{{h$nqE>*40Lhv#^rBz-YbPT4=+6^u>%GI!Mbox0 zvj$p^_Lrh;G$|3IVB$7E$R9Xu4c5)4hF$kiao%i}C z0H?yj{$3t@H4ld(u8W)GAK-;RFTqTOYq3r?pfjpD?#plq3u!Z*}agQ@#X6z zIkCp3fBk@I8}Z;J<-pC6`$1$Os$XSNIf8mTiheuf^lbqJRT6qNN&aleymE<=UCIulc zU1i1(&DKsRPcR^p%iJHpX0M$MPSke_o)A2-C&goKb=us(bbK0F5_=*$*fE<8e-Z2Y z+Gpukti01`rtEETI{{Lw+d*8rgZNq?AQ|eg5Fyf#=Y*_t*1$yTgM;x}SJ);tQ01Xd zKa5r$NmVI=a3sz;GPrNu9IpOylml#mk%F6~6}KYFM5&--Qf|;T$(GmyK@{Zh z0f-M%pLRi9U z=Gs0iN=qM1>pegV?Gy}ZVZG+)+ibr7>ICMFxqWvM0o%f$>_R^pl5^RbU}HdjeZUwx z0waa)WEwlE@)zQ8C8g@CPNsn5{PGZnZY@<7mDe9;+fYV#UiJ;UouyG~REt~bvXR}i z1FpuCs>(qN>!HsBK*^^OtlRTXPGL4-D&qHNx0De~=#BRt@ObKk$FrA@dta?~=LBX5 zWxNmEEV5?opG`K|zok)d4O+;npzk5l#TSYJ=m)iklw@i$eZASK&vSt)=K8rDdt(@} z*`!Q*311h-m-@xd3M#{vHPQRQ?@P7rIFZ}WbVo~yn@!3=Y1D00)p-sNc%S))hd)H5 ze2|T16L>rj1~i`%tO~~m$c1jweGEMwk*i`xOkJ<+gTc_LKLyv=<6lkWh`i=Q@;D4F zFM{p>r)rpIdyh9(uEm6liwh=Y=g1z?#4DD(fN}}&7t-wx)gshRrrmNk$q}S2f3>sD zbXiSz5luyzD$o#m`h`mrZ%38@w%C-zh*@IK^DgI1&VKY0`G@)E{QUeta{sd@73Fq@ zm?&q?IBi>O)w1km@OFFGSzx<_!ogrm5_sG+IJ5CC0b)*x@UtKR3@T7)n+zjGbZ6dA z?MwQYMU(^}u&F6_+9!|m8Ofr!10YbL<6|I^4cRBwMDmAT70FSl-0l7Uc(z{M;X#=3 zeB*39O#OXE_o+iYu27{XTT^Ld8*DZ&$d@>Ym=I$7>O86W>b%Bjw!1)R((Kue6gFUd zVqFCoJ;LH0e&!y10&61IGQ=VDG5HzMCv5GcmT}9Kt-*8$WMZSOy;xw2{oDwEegkaW z4929mQhJ?4cnAW=hU9$0QX`4H(K})@chFp+}y`#g8wq#wd;BQCYTcuQTH@i_wynMJUl2_e@yck+kNR10BA zoWyx2@9kOz!WeUcHRG}^QH4~rHAJ9-T8f;%Zd{RYeacJXr2=b_8u{TAoU(1BY}j`% zUxGg3Q0UeQfX&7sYww z-t}k*Ny--tneqFBb`QxkBfc|{vMm-PBIVcx5teLCN1+Vpj!WAUp$G1jBmJB2IaJ`4 zrmFU$)r%>_Po`AM;YXAcht1eh`8q^j%p{t1xU z;#D<42<$KQiuPoSb~bP#FcgO$b*RC*C{p~?VFg2tWyASZHvl*xhf84I7N%b|_pT%< zFTfmdHq7LxBy-13d%dtBTCFs?+(QO1=VUil#Lq|Z+M4u#Mah}4Vdge_?ed*XpaxUL zhzvaY!mL~QePg4_-Z)SDG5yDUZq;N6i^0+WJ)XSRN$EXHWML*E@L_4&B<+8A=@wBy znmYD1pPIxUt!#tR(w&0`<|DuvPT+Vl$6^^6I$btk&T!J6TgX{?HC;`PprAa32&j4$ zei|WANxoJaB*p4dO{;J-7lWM&X&O@-=FM!uFQA-;q?qF2EKE=5*&D+yCWxx=q2@`9 z(_o3Ob?CKAtvnh^JH7saFEvCu+8WdnYsNJDvATFy;`QDZ0pO5iZ&~6Y{7rp^q}23Q zmWG0kM7Cx<4v9=%z5FCUV5XZ=hYl8oKb@C8t|S0?e%8>AZ#r zPyZg(Z=l*VM*qTTMeW=w1btseQUD8*VqI#oC>y2%y@iSj;M@g;i}8v8hkyM#iNryi zgM$`Q^$^ht3u^<`u6hlg{U5RWlLyjl*&_cwwJ{>31aNF$w}axZK0>ffj^!4(7o|F9 zf{+0eJf>5#_&y4?b#$->XaZ~^sPeNuDl5;VFi@2teh$eT@OghUct>iI0)lIs44Y=2 zk0e6|)PuBp@^07v;~l?GZkgC~p7a!ORX%zcnDcDipOw$zFuz(h^3!sYm0-k`WOLflkR55{Pd%RKi=4IFL-1)$F?H>e26S`UknH}IXI+f<{Qdb@8S5VAfU;m~TDq7DXp$@14{7JPKoM0D}$oz)W4s>y2jg zAYDIq7>-r3;JJ4dK|aNTtGkYkrM(RHPvuCNJ`afWz$llt4ay3gGp!i`O+2$KMXoF_ z!yJkkzfvzuiNO#s<__ClLiDaAoKs3bzX;3+KlHTU6hK(mG^wf?34rY%7(G9uTQ&?z z$l`WWJ~x1C2+;s*O%NJFa2lt9;RY!m$c@1)o5D>xGVmWSuD@|4lBz9CPKoG3^If78 z)i{5PFQ9kw%NtncG+f8!NOu&>VDj3%H&yKB*n z?7*c~7g@XX2857{9v2kf=i4n5|Ur~S!Jh;ErX_R47!yo}GTSr?fn zyfrU^rG>!s_?d_LwP;4RlSG8`^>5|Qf7v<7bfSK}8*^KPNi&qW49GT`#T1=z!eNsp zT>%0IuEHh4Z4v|-n)K8gnI*St8S?I#oAFojE;ftY zemAlNHE3AFDtiD&>$IF5FD zsmD!6d#Yn?SI_bsLh9p=I)82M)Wh~vrTY-(Sa1^g>T8Z1CJ1}Ou%XL_Vd`2mtI@3D zE;|hsh!H*z!!6W}lDiDkGXikjp*7l%#k@9lryiMk2)=1Sdn?%9w2fXYf5$9tz!>cA z0f;k4N7Az@Sw$sFL9mk{nd*`nediVv<>FT;Yj9sfg}w0!)md9x({u6w-Lg;@^f1~d zUMxLuM+lmt(@KEI%fo*KkWCtd3xOjLKNyTTZMYn$*~Szt8}am;8w?_64*XtNSb#xV z=-H*EOWT16$DfH5cLwG=-dQ&lGn~>oEFz* z(`fc()(7y#OoKb^KT#R-5jG1soMUUxOdc`4Jz~1AJ?_W@O<9wl$=Blj&81eg&?hKp z+{Y;s<~7x^A{3oyJ{>wxBOA?%OxaJo93V#Un|BXR%T5KdUSEb~e?pM_rcUG3EZ22c zH&0)}DXC*$N`kg}^7mr%!HaRJg?Su01#p5(OD9@_!3u?qPZlMw^IDkjQ?oVo9?@qL z!Str&*t(8l7KvFe+uiY<8QperN7E|wr8IjWI-zZq&L$vh)A?mGi@{=(_oGj=U2v;T zD^(eNwi8O`c#_XZ6+;q%z-;b@<&hse2C{vEnh_OK79cQ1T>@XLjvok`1CuV}`-&yh zDC}{tH&qMKX8eIUiQ<6k`REIXATZ4XOn~-W>4WHI^!A1Mj{*VDm+?H-7w`x5O zWZUf^bDifFmBoa+dN%i7ekopCU4^{?h|^#DNCJ;pKRBF|W5%Su(S~cT!nNoKr`NDA z(j#2YE?6QPjAL->>B$FVu@nohFQ?XndF3SHQfpG=?85@Xh5{aFYG0T|~ zyrVO>DNb2c$b5lPsTmKRjLvhA@hmFg+70elh_D6m(Wlspr}snU{)B#sf+=VTsphDD zxOE5f-~T&6}s1N`PK16ok<^XxGv7S^2&U0>=)ll{s@K-!0g1t z{t^;4mXPd&ltN}D;fs|pxG$y~uCY<)oY^oM@m0_f(a@tSG$pAfzre5p(a=r^&F8r}1qWP&38t4Nv0lNpY`Dt}k7O>!0XO59le5`#zDn{GPq z!N}(?6{^eLFoTKiQIA_dagzWi^J~V>`Ydb&K;W|rp%-9q;vgk+41M-3_0wS$IG5*vVyP_mpv7IzQ6U4UO}0=_nOZ5M!EHYE&ifp>OdggCIkW+NDJ%1KcT@1goV zBvd~H|7hoAt}pB-;)rl|(qxX6)m2@_L6Cm#^Fo!t)+iRh%_AuD;-YfcUo)c%^QvFq z*q4ZdpA9m}erj^G*T!@s+yr6y_X9&K1c8qZ+Kvw}kfJ0E=+ZBjnKtcm*5D&G(Fritfe1dgOUMTwNo&y|Jrub zVpC{PP!KFz<%nsy!O7JSb?$mHR^WrO!t@>?_5nz9t`?qm0Q+jaBa!9OF7-5-f3(2CFzy6A9q*ja*oOJ@8p%?I4}+2E&~-{xyP9^8%+`yd!B1J!h`ac>ZQYj`$&6UWrm6JazUDZcF`QFgDg*9hxe1tN^3O~eGP&nF{Y zDMqNJkv4=r>2Y9#>wN6#{0^`y0i6oQJ~F4%EwV5~t$KqUrLao#>*(8ItDk%9C2p|$ zfD*kr5nHV)O7)oYm2>y>NJsT}h$9g1&1y2}dL(Xt&@_bNQzQ=M9+6f6%gYF-A9XuR zlxYkBBAJrY(Ntco);q;|Te9A3UPLXj=*uah zRR!ijw8|h#IIMG{Jm5_rtxS9I-I0w`r6Uv=;3-jZ{?yUrzK`2|&iwA{Or=foMmTlJ zYa|p6zs*aRDMPu2x`y)RD~t#lkbX`|C01xMkGdty+yZV`XaE#lLDR;`jNH5{BB4U) z={Xm=+FMBu{WqpmAem{NDWI5SnE2X># zRpkfX#@~M^Ue%hXj9}sC>+nx8wL#ggvKPVo)r}ZS9Q~@?82r!{jOF`;79dpTdLCV^ zPR`b6o4*k_f-GH#hrC=|E^X^^I4rKQasBntfec%O9B@oVrg^1KYtm5N9J?%ixffId zW@cu@OhUFYY6X#%Z$0|!Z_NwQf(rUxT4&ZZeC^Wy?$cl0@)BF#fHpKb-BQqLx)iP9 z_qXJ%I84lpi3Op2r8w7Mi3y$B`pAwzOm|m;=AaX@$jz_h1^Rn zm;R67ccVYotjSCBORiOnZz~!?=)9|()T8mYV&M;RLCsNb@wy0<7&U2LZ}e}@T-5_^ zqgPUT=-)q);*Nyz55F{GYT|%{CxO#QFw zUh?#0mD087*XKCj6&mk+(ob7@PB4o$Dq}O6MqZ66u;R)VjBUWIuS$B$FfnEVVgvrb zs#xcEW-NPvSrU2cQmp(F3>=n1yo{4gV>9d83)KP~B3u?Yz(B5%wUT6@MxOlvq|UWQ z%CFgTg8IBP6Z0=f4XL~V%&$!E5e82P5$a4;)J=jHD~%av>}_FJ=VZ=%)9`dM-_3as zE5YrqRZsPPvL%`3)IM8zB{X-O)6hqEi}KN?w@qG@NxPR+wSKscoAL{u-0WZ6JKwRm zTm>}T+aMzsU2ntJ1lmJGbe8Q*Xgbu171X z90pN0T}bTyA%k(*VM~tLx&FwMy-|i^4MCZS%;|Fn}b3B=$BNFNJHbj z(F$!`!#^Qhv-&E6Xn_~bU zmiZtKb_`hgu!fFrTvp}hKG$%{G3El7)CXaVcntQkvyQmPZYX8@R9AWlfS-aUfn)7p zx+={;O&1E*MyEYWlE&@mY6G!Ar&lBn6OxiR;nj}T(r%)lnByeJZT&KpalaU9WL-@J zrwn+0-395rPgxwEZ8w!ri?lS9R!82#D<2#|B<l^D$5`~LGjDe9VClo;99&I@{-XH#lRW?k$Fgnp;bS)u~pPL7Z1Un-8;L`o5S zV`H$42{o)@97SE1baj#YfDI6$h|{>z802Te82kiHE30CNlMwW5XXxdGf@d`;)xW=9!mBM$jVuqvH?WpiiJQ`Wet zrs}3ZYm%Vql>!^PNC(F!+vyiPvUbuxiYpW*g^s^ZU9~cNZWu~Cct(W#-(7l*Kp;TV;Z^+PI zPLgx!7cUmOiXV*=gmDc1>*|t|S6$sJN0hGa(#AJa^h3PQ+b-FlGT1@*yc;UjlBHcAlX}7 zSN--4nVU@QqKoT5$K?1@2P&NK!}9A>0^2IMMyO%x*zks5$X@f*rCIl3llwt2nn8=kfjJ#Unm*DN%~KgKdrIo?v@ywStt9L*E@ zHwj!>ytm&_j7*j@CJ*%}r&ybq=R+dCJS@!^Q{KBYMK_zYcU1mD)-DKugqPay#0#|}Kh z(O$P9%YhcXn81^g%o)SmNe#wd9R1mGyBMP&g3-0r-q_w%c5!RQS#Xh>ZFKVV!cb_1 zgL!%Eh3YY{=fK`&4Zl7NMQ!FOc&D_Q-90vS;EKK9si03<;#yn0U!f`X^*Tuvg~sH5s+iOF#v1rl2#du8!di zZ*mQVZZ-4)1Y^Z=_A`axjX@f8VI+SH(@%f@wsap)8j=c~l=_$-t(gOQ`ZH#thNAGW zkE}nb+g9}mZU3%OgmvUKn~VvTJ6LzG`-KN(Pe)*_AbCYCNYomd_yf+b!Uw2VvRvZ_ zBx;6#ySJ^JWxISVcl+DP=w!1Amw%Io2lx3KNU&~M7-RY6`aC=7J$=vBv6z6K(WWtp zP1Uk3p$U(AJ?e{lUHGSdHhvymKFLpK`hu0dswvFJtc=aR(Mpu*_3>7Q>^A-qL)%c0 z2a=n(lv969gQSJ796?k}u~J^hdQp8~&vrd5*x0=UkVO$z8GE#%x`cF5hP720{ks#l zw|9+}X4oPoeFH@(!dk}|i{;vYFLW4B9+fn;iwoppexoL-lOzkc1*jIAQZ|vmi z{9!O1<_xgx0cj`xQN&T5|xLNw`d$Ra~X{B*OhO+gBE9b|iy`DdDujl~|WiN3gaR)61 zPfQIZ_5_~k$B<5}N;(t}Zqh$Cr`BN1`H;^;sN`#E-3LwM{x3CEQVuu(h%QSuOr>NSVy|V z;-6eyxjN+6XWQ|7@5SP9j-?QJ7*Av^Kj7U|$}@L#+#w;P!ScSF8sqAc`fTOi^Nb%< zy%U2rRsAzs@VhFVaA%%TNTgYCWrtCWLgZfFPbvfeg?0pl)TG7K&gOTJ8eEtGyx)9f ziWYdf7Mac%(*Vi?Tj0rG_7IrESVGk6mGEQDcvDVW$r0vXVQJ@1s+(oZG@H<&C3ABT zTfqFWD<(WB8SkWxmEnP`X0Y(I&vQPet(#ea*3`<*_%E;#ylrfN2F zK*inOC?W0F>W3@y0%fAMe7sJ*)~#2Hons6?*1rj{bo^S`d1UkN)y1o2DQX|4Gj{E~ zI;owWVwrG%m{YOO%Q$;3+Zf^_+5rT1gBs4P*N)PMvtF_A^Z409o$ zZEKyGU3Xe><95z55{Vmy&-eBbadBfPxd2Im!efnDbswsOJiRsi5d=4;5HJ^NgvFkn z*>wvs>7Y@kJ+u{wp_~XBDu0ip*?FJ8t9zdmH)QRLD_yQoSzRq}U1-}JWY%SVZLzhZ z)x_tZw$diU_L2Dk|AjR59Z9Pr-2%=`8F@SCt7Y3)#@v}$eEVnYgR=g0^uF_(@#5I? z!}zshU#D0OvSfmV7MEc=?X~>lM;fuyuaM7YGARWU8G|mUZ&EKF$nA9lhZN?|P+dX!hjs-@P83H}DXp5k* z>Li8CXG%n#ZqIkwwRQ%9MMfv?Rs*t)r9Tw7~Al+)*TDJ`D1TZe>^{@ za@!zzR`uWj<9X%Jy1}^E1}xc3iI7yS*rXREc?@a-uK4SniKb z8(8${+v)16wIXjR;o>Kzlyr4js5gOEKtqLDj?MPCn2kp1%-}JZ53r6`;9e+%#0b=a zLMFL!sr0E_7<#uT>VQc`84*Ptn-m!`1YZ)(0x}(JuO$3-pC<0V`RMab7&&}$D{R4S6w_u!{!dUm!Au$ba>pl zI-)=AzN2Ktg3qbyu!-98>M;{uPI=OR^ZAtHv&FlIrwT81p^w4MN`3pp`Hr)pijU-6 zWzYw3DJLfKTG^RG(20;wIo{;7pbN5q>tc0m@na3#$_rvL2w`J~_u}SD<-?L-_Z(7l z^+uU#kGCBe8EI9VHL?I2qQym(8$+JP5uE6~&LXCgGqkMH-~q`P%X}Z!Pj5>Yo9-r8 z_s!3i*(I(#u-2F43Eu z9@=wVK<}jpvzWA#NZhBmPIR5{4;oJpu&(U2D}i6>fTY|m`IIvtqYX_~gklg&iSwl9 z)Z#MDasYwmUyEf7-G$qbxw!MaZzivRH1)5^dC5@F^Fg+R(3@B%a_8)9m1z=_!{ZUJ z{0?HiA~Q2u#s8=*12wAN#t~2jsXR?+RHRW*CJ6Kr3F!toK1YR=_o&gPk=#CjWv-q!5?mWx=pPkCj)n5K(Wf(+x|5D?x z2_KDN&I<;nZm!`MH#!#yD^9lAdQX_;v2D%pF>bP~`q&j#=DGpE6B=`%M|-0<>;s$0 zzKf1hE+P#RQZ4`11vvs=N6%mhgx@>y&?lqt;Up>(3S%X)ZsA`_nXO%QnDr`1fjAvN z2D=iQXZ;9L>Y4Ewm6IQjAovYUf;BT*o_CT%?m`czGPzfMTOMu_Xv_?d{74ECOU+2nr;ZM)sV?JXH$%kpT`FQDPyYmdhHUCx{d+=*fs<~<5 zSH3S}lIhUVQd0233fMIkBH$pjmanIe+czxb%PF zYrA>>d4r93Vn}1X&Z3k)*dRg;0ZvR^waLvJ_Bgl;Gay~XtA!|pQ69K8gK?)gSsQLM|R~s#^BBEObok zRKxu1TsI!~k()Mmwr%~xHShhT<6@1l70{>ckO0GCLfdKTC34JBx9v3#X=ao-W&fFBZ>d^YgplKuDO!$<{3w+nFiRC(wTQSl|e>Pd<_;5quurZ;4qDt4=NDUYc4N$OtSy?@(4pyWKgT=FLqnKk37p zTH9=`rxrqKCPWj4G+R@c1-eS{Xw{HhhSm)j=j-R`9fKe>@--VVF*Sr3tdY{uMyr}4 zdyzQEQ=w^uu_JJF7UmxNhIJ>~`o|!4QFyE;Cj#dTyBz3MKBjKQxuX{Rh#D!41ZxZNIzWVYTi+PUP1lZp`;)&<&O?-jBOI;iu<4zyw}n7UNBrI}$h^NB{7gfeb5% zI=fdzcAgrfeV>W?GL_eOj;CwJXt-%XyT+(XE~)YDhUQ&klSh@^D$E!htCwfcg!SVK zk{=$^>Gph=ncH!(y3d3^dSxMh)yvv?sIcnr)M1(p_WNn2NAKPieRRw)`=-Jn#^=@7 z6skK*M@w&--NzkbHl^{53x9EvRYwKo{*aT3{0td(CG+W##5$CXOnX)IV17$%3a{NT zW^mjCZyZ#FkGbdpL%MJL89@`31Ulf-Ebx&0?a#L*s-_|ZVm&q z1%H>fGrmnwqui5P-NK^r)9P%pDpe}O^8y`fkc-(?{@r%}+pWwU={M`{r!N>QB=gXH zKh;wsf~$D2H18)**X?|;JLXkcI3~-)ZQH85v|UJt$uMRLt{kf>d4tXV7EK@ zIWG-u5@Z2m1AL5l#l8}p;GlVA=|G?~zay&PqceD?Wby?{7Zy-i(EcGcX!Umb57F(m zA%M^(Vq^r#Xhm_`?MwXg6BzX+M;+Znb&slT4D zz{M)v1F{4oF;Lh>8N$I-Mz0olJOTO9L=`%{Ke0nc!Y!JR{ zRXkq_y9}@r{z4o6B4+AJ@_nJQ^FUU+JR~{uny89d<`#5m)x}Rq(>*sJ0j4M6KVype zbow6gPtCvTG4nFJ$agqoK=Q#Z?6zwS6a-R3G3Q86ci?fhg6&{eH&?4zzDaczh6D-q zgdSGqF1libQ(}B<85Bb*j#s8og$HW_M4(Q4vH-H!Q(}H3p{diu1w;= z5hgisCpi#cMs!7&!dAzRVTYp1Q9aA}ad9BswsZIO#_M)g>xq4W0j;|7Qx)eN_)kN# zY#HY1b1Speeh{=82IoQu;`4+Xg>uAG4CM`9C+jU-j7Q%7I}~Yq_HPfFjHg#y#e9#N z0KPhKU8f8duK;6chTrj&ypxUgW5RQJsZGqkA^Ewrc=oByg7KHaWsLwcyeNWT6;CvZ zw8fqg3IW?U-9&S{|2Es#QniDpG1UYX{hq+pu*yX*hso!Yn?f^F-FHzaUpxON?Xmo{ z@j=7El7R^Gx`Yo7ZZlUM-K^cX{f-OHU>^FdZ7A0f!6L4+Pl~+gl>^PkHu|3&d#T;K zRpZ8B_L;PkhEY??=l*=+{1-L(K=<0%(#J7L<{d5U-GDI~t%`o!dt(4XJ~~ZeY68*k zLCX6J8GHuo|hIy(1~{*o!q9?;7ewr%lB7PADt272J0Kw;_&CFlx!TUv4%vKrv;o;#=d z_5sb=p5_$lgiWYZUhcU?fjpUlj=lQ%zrV-AucA1}d;UCr302xX8UI`pm?1$;b$s3j zO^ZK%?&IGT{N?3h7(ro*$iwGFMMYsabd(wxx$BU6j3r}$l=F8&Wm>tY7<`|*?-ce* z$whev9I}g|s|+%Ge5$&lrKJV2G6zC|3E-2%Wk4wx9tUivhFn|}^MZ;Qbz~aSMCE0; z-b6?l#%z>hU}Yr?Rzg{2zqYmMo;|xb0dF11OhNe`qA9Fl8ft3LTLzCFqJ3e|@ed8f zyxlp$OthM$6Fcn%1q1|0B$AL2Pfu>QC^S(v=x@Y*Q;@{B5Gl6lcsM_65xp7lfPO+n z8T!IgQ(~P<4mJUOV>|uj$30$DRxU#X?*@ATDW_xPl0-t+s9>_DrX~)(9W2tIseeq8 zU3|5f4PEuHx~>8{ZQ=NEnkbcerl|+U4Tpj?1)zzMos&aQeBx3cNAhT_z%U8jzuP<6 zxVQJP)j4H(eoY%FHt02zRcM&Ji-HeEw|J-5u$=xY2)4j}xdk zMX->`V+HxW{_?M!AE=~@Foht$g7_dI!@5Ix`qP^?w;Tg7`pzARVgqbAl&s8kP+>_; zglk(1qbFb(kir|FoL+p` z(M{d$!P3-RV7+n}Z%`2l5P_-ieaK!@Z5*!GH8dP{DOVEmxm}aeW~UtNt7R|l{Xx@q z?bxIwj?I6v<<@+=>YU#)rWNY~o71-fgq6i;(bkVEMm546xxeu7X3aJ}K#PaUF z-CXfp@yXrGNi(YIL8)ngvNR!;kB5rQ0$nrcz7-UF0vb=w$T31{cV#7}*^dPmn50bJ zBj1$Y^N@;2qSPna(Jm~Vm~fd`JjnsYL;(!YWttjyDL}5) z3+`4qIS6CG6w_dmA$Y1)tf44P{7A+wT$xPG8L}tn>0nYrxY7^8SgaUg2BF>=!KlStjweybQb zEYE&)Dhv|pF#CYGkiv_Lno-44ntH-9H@**sY&;U%mD>F4N18R*ku#%R=8ByrYFG07;lqbTMJ_P8fS|dTPuBr*6x_WQ1#OW&V>C&|Yw8!|K~ep3Dx+{sO-+6A z;stEOu(D7|^*9vQiu_VL&oVa4bD&6dD-;3u)Ex?r{&7!9DaJC!5?wXu8{R~=q;YI{ z3ieA-I7LGSCtL89h6s5&E`Rn0svs?X&zsHPF4IXT`VS7$La;e6FAuQ>xhJj{;*@EH zzTV!8FJE3$NzcyBCGqk;q(Af={R9dFuU!P>`LczBVA4cz($djM96qd%1+TAZ)6#U^3$~bW9f}vYmwysds+;^BDK+gCW>=VC!{TdMw z(b?0=rl5XLJMICe3QhVqhM-5Z5u{d{+M-;*K1O*E%qQbZI8*`y10nW}OvzN(Kvx%t z%bBa>-7G`i%>_>%>tw@Y0=^0;oL;|{*D?c4t=xCnZc|pscSFU@pEd#Sx8jO8i*M*P zHV4&exbi|%4|C+UVocz?Y*}wB2RbbM;9OkpE;TC!u#($mw^(qdMz>Dj=>`2xjy zQEu6$mdhN8AzVd;7VUOtWJA#g_^H;!-JaY+CLI}#x;=4)Sq35p-|gYkG@>jbp@#?^eH;Ko&_o2S_}iO``#JFalpV(6$0>~Lv65P=W@76vnVr;WZQcF{CWZ$i9 zwNY7*m+sR3{!gDi>6`dM)SS;S1||`{(2>WAiLs>5*`pHmBg^LfKJ{8Hsen{wtGwEW zKMj23i48D!?B6)l#3_DCu+}D*B7ucdD88c3~C+@*xgS#PHEDd*Tx=Dy` z_Cbv-S_PTt6Sx8qz6w)zg?Ebn?Bw!IvEYv!F!*|@BW_BjeJgRv-RsCpM<$Wi)2cx} z@U$)UJe|E{r() zzwKB%qK3J&qh6dAY%AF{Eg&+D4$V&+oO*6CoHNwG0-s!uzq!=2zS+_6L@CBu+ zN?XRYKGb%lqS{WRo)mxAQtu=^&Y={>?CdY+MkN@uM?o!iQ}XGgvdUbvgG) zK{%GM5g}WyzQx--EH3WMT=u0ykf)`*s_@e{3(mOu;m_whQ>vbPPStgtXWmYH{KO{< zGLqpytrmCXy|1(`CL)nU$61)TloM(13qnu1X-*@SWRJ$7{`>!)%n4U z3~sZx%qe>mG@0uPNk>-SV{SI{b^Xls;VdO-o_FdwrR6PF61>B42Og5$rT^z8@Nq+~ z;xLu|^(R>^5`Q&3PSo#qocj4NyY#cY_+y56j?rE=cuicne3==7tT-QTuzwPh6&Igw zJlyvo(YU_oLyPx2#BZC&RgEk4o#c$(P0du5`tFRjxt6o)O6WiGZCR~F z1&uZFrNI{|7JVmgU9c^dGt{;C!E5#R+?@>D;?5UPjeh_B{YC|) zBFw^m${f@{0d$l`LRQUXFNoz-H zv0Mi4d#f{-?D*ePwL}X#N`{XxZclX3*P_ZU`tt73XXg1`ge#jR&=qKRtjl~b90CtM zusfB>8ua)m7I)~S+*C{N^zWHuo71uygnb48!Im}A+ zMoZs&NlNZLl~#G{!&axy=P%{`eDWYZb1_rjMS^FC_XWI!C)0DXuWpe9y4{w)dJU=i z2^uR7xDlVb*^HR7F(*1Q-x!7Wve#2>tSyXEucY@v{(|EUED&wGwPcns0{msvpPN>IV?_V6k->UvN~fdBSU&Rf+Mt&cRW|1@>spm&6&KW9Ur zj>8vv*^d6o_K`5|BI*-{+kanC``9jhyX~=+jZw-yz8}QFNwIS&?Nodiv7lr`-`O2C zjCmAj-=XyDPhS1USEiETnl3o^jI~D$sy^r$+vqq`pU}!x2mwhvhEqyFWyN$tarJXa zZ`N){Qp~&TXnTclXV=r3uKtYy-{RPUm=>$Yrj@cF9H>$XjoMG|SFWiE(jXP?jb zs&zU}+r(7sqAsaUWT)SgxQ#cn?(Vvqaca5nZ?jXMfrrR04J*p{)DK>RLHu3u(x*zg za8B)Nvhk8m=TuX1Yd^*sS-K zPDW3y615(E|Ev;lVK{Eu*Om2w&e{4Rc9pE$`$|LR_1%{xWrZ1s8MlQk4rJvX*QN>y zIw+hqqLMeVk2!ruWyA%gwzdx?{kw_X{egb%i{0v};v%x*cFLsYDrLAvwg$SE$&_tc z-)kzu6GUa0q9d|tyQ8R`O5(x?=6cMb;Ls6k+=Q+wGA_LJ@?F+2$FTt z_sg8J--F%5HhC%5?A0E>%U(!RTkur9c3Av@X6Dm9ZlfEd{kNWn~q;vpIb6sY;BQjTn(L zQh3;`9oLp->>SoS7o8bvOsNa`I$;UvX+-Q@Q;;&OjugUgZX)D&+5RYDVz+ z-^e(5i1A%UB$Zx`?Lq2>Lo~IY#2U`XoErK3z%ajvDQY8kNY3%IHf_=enL>gt#8rT|9dO82 z2>)THM+D`sf^1u9FeuV+~ z?523Rm$PBw4;ydL^8tVpdE~A_0ToKnP&Sk#fey z+}s=rGclG8)H=kd#pD{ohI@&ux1f|WD7EiITaNfDczL6=7@qb*Lig*_e&qD{@K5@ncAXa}UM| zFL6iiR@hyGqPpqef3HL1?v(&eWe8+jSU`b7S4RgUKF2zXtugrsk1v>fMOtDQ7M9f1 z^tjQo|G81dB2r|MUMjD8qbUQ_-m>9rU|tAWFHB#8gfF)XJT__QL%*E7`H_|@I> zp?^SU1Efqt)j2vtE1(Bldt&hnFZ_8hO6ck7DJQp%{5!7O{^uRSj={^@J2N8#bI=zq zJTl6I0#s}Rgj5N|ARkZ9a&+8}<0=0Ce&cyX1qc+4R<8K(pbv4{f?h-*NVaH}I7!;X zqk(TTxC4)X=YJmose#HLa?U%cso$6%g8HI?!MjNr+Yu;T+Qeg!2Jq|}MjftnGJ^B& zKHQDtr#A$EM*-+=(B(Rz7>o`DD$Gh_jn=2UK@-&e^1FB3Mhm*jNm5l)M^kgR=eoD3 z8j=L&OpX%2c#Q{hn9#)?x%@mJAmI0J%uG#}g$;|HH!y&6@mW1RD9XWS1iqt?| zV`FXl5dTT)HYwQ=J{F*Ud$e#+UF#fYg^8Y-|<(H=V%)jACLGlH{!H$FjhE&Niv z{G)bR8H}WQi z&YFb(TeiX6CL7W_Mu2X}3JXIB1B4R=0(kCta$bO!mzSU42s*Xunch>awk2QLmcDI< znH+Gya3#tC;$!%kP7p6dIDu2SlQEUI*D;*lHc8Dm;OYsdCdSupV z0E9WAbI<-^c0VjE?AUjHc^A3>v!LMMj$A`+J-q<4&HsB}*H#Yz_QFC$PscdlJ(Qwh zX!86Ek8!}H*gm@`@9z5$lV6jam*+betv@r?mz-Y)CQ>q-&=$w4kBN(y@LHQOWWcKn zO|p#PQ>t%pkujvTd-gk3wS;cQQvXiBxgLzy!+N`?k~=t+*Dyvq>ob7WtCISNobXgc2NHNPI70A4J-YDsIvF;MjfxT`#5Ksf(t0O98K|I{ zcT!0?LqkW0+0-~oMBgU3bz(m7=Kw`es!crDawfjhZCGXEOlmkrl$Ez;<*s`ML!NTK z)fG$>!?P)3m^yFM$r;hSaJtL7>fXNP=H>=PNj?SiZn9=k$7htU@uwcZLpuxSQf&}zdU`s4 zH2<+=0%iNwd5yf=zxioX_!D}-YTT`$3gTPm=AHp2m1NFTPehB$!QMXi$&(eLDY@_) zk`eQ(D}Afp*zyPIw%I0y6j1yN6)+i94Go?>fd~f%qzt{B3x!`W1}x6h2>rRLiyeYEIOy(}{rYyDmk4!e9KtSV zdYX&S5Dl-l(8{7|nrv%pgTzNh^CRGL-&og9;w7Oy3WGX27w=RQNIIEzqrCw*AGrg%Vv< zmD8sSd9buz_N-lEci=hE zCi&5>1Rh`b*2#JB-PyN5b7bHdPSw~3fB#$fNO#kOCm$Vk zl7y$Vp&?_Pb5qOe2}mlVhmn=Vr%7|s&JG@~Czv@Is6#_SFoBO-{{H>DXG}KOmVqZR zf*FUiub6cDrv-^_KlORXT0A@*m>#$F^gzZL_?-z% z!145O&>u0Lw`g5AK`RR`!NY?XN5n|aF~~`wSEfl*BkXEYKx%+K5VSv#loCFZ<*q~g z0s{C9w(r@La?gAhXMjt>#7vgF?~!eNtKd|o+H?~Xl;p-aV$Z?9TR{KGom2xoy`Qs- ze$zQ7SKQsfXoCFxq>Ngt#)SX{2`XU*YP4hq#;JGgpt^C~jZ>9#kK&`k)KvM*R@wH8 z7!hO&!L);jvXusdNHDt3eN_i#Y(9P%ibGQtDl&+tYyd2g=;-R|qHns>`4zfrr$U*f zJSX6Qgg@ku{(XHCPH)Lg9qsLI6F=&kj;$^s%bkM)gV6csC(S=0*h0=g9|xRF6DWF! z6Hy;|k@u`yi?DwaL_o?%z(h_BBWGOg+qZ9FTlJwh;+J@)d|3FnD87j&^?N+f2FEjL7 zd!9KDpf1$~ZX?kzcP%(+H+p|$4x(RRxV(~zbDOZIfO;)xhbvWk_m z%4vKBnC;M{9hoNoU+)Xg;>^t3mnU4L6F1%L4}Ehg#?oINMc2{AKgC2Ygbi8LH7ZoS zG=VAzOBjLk#5vlmSSjzBKd|$>a%CFO`VjB){W-rC6%|*c4&bQEj@F(%L&G1~~6yFY*ajE;gjwdv+7yON`CA{3P) zGBPtkLFzehDik}T^y$+VNJG%z0*e^*>wc@xNcT=DD#Ex?0Qx3saFUK&Zr}WZUgdh0BC9h0nBA39Jw3SF40+H+$UD5gd z2L%PM;%rCBw#6k*JvOtIa*y?-}4DURXVy$J~_=bO%vwFM1 zS7b0ki6<&X6-@6nPDcrpzqBZDl3Gx6YEWO7do3RAPPhTY*&i^~dE<@QYK zE3yo3wmBKFk)j}tjD=BnP=pQ;PKyX8aGesr?w6&WzlRckg)&q%}G+pSr6@? zK^Ju8A!LJn4A;C*e<)7J4C?R`Yq<|n+mPqPJ@`#F9tHq0?%TW3@b{IOKb^h3z376s zx9hb?!6POATzSMTmLKYTLFl+4h@Q!5gK-a%ZRR>#v3ML4G9l-i>hq#wW2>Q^j`lyC z4G9)KAso3n5OxgotuEyGHR8>F-#l#z)l0-`GlmdF?Xzbq%xX5pHYf3yy}VIP;UABSx1BGW0j6jj)jN9@c_VZhX(WMvsI90h1D7U00 z$J!sp8pJ5E8n-qQ_4-_8?!a&mK!FfN_;(Mry7FU25X226>~XN6I=-7~u00_8u9IrG}=aIVr~%AQ(#sD@fA_XMlMVZZ=)B) zOkJjfG;}|^)-o=cxtx{mYR~VS$`gyrWYafjq_|ZmpMC5@kr^ka_d9(1m{m252qwXf zL|+ce54FrZYu9Xr_8!{6RNfCDqH!uuYJ~sryT{3g@40dXFYk1^R>{++;K93?{kT?q z>L^r^FLf5BmzNtxq#-u~p$cDop4?ZA`YLv2L~V`x~#BKxo@`ATo>k%E_H z(kND!7QtydleWjY`_Sf}qFFRl3et&HKJzZ_?q#*+@WICT&aBMWKSsh8Jylni7us_4 zVL3ZLF_@IZN)(Z&sbYxnF$$S!JRQOk?>Hf1luL7(ZQlK^o@d{8#<=>bFXn%;v+eMO^AXP%FZn5_wxN*4R#a102QUE| zuqb?*0p$HGk324s016es_5zL1V;t({{hn2omFHvNO9AZ^oIKbVETa6!`Z2JE1V{)c z>&nu6dwcuAv!&gR4eH2WSJn_!kLQDX(~q;m+J>K>f1+=u{_vzKx2Tj9U`;q}*xK^( z<Kb}YY;(AckE&tN}`ECK_h zhAa|wo|8wG;mUN|ARcINXTS6Avkrqo&j78xyuJa?0Cw!`+vINt1c2Xg6ORbh_D|P( z1u1ZfFgA}Q2UR@{4GlegQxzzdZ5TF&_Z-fGn{GyM4o@!}?)7-|@FCV^)6iSIciaz-B=5i7 z<*3hH4&dO05F)z7NUgyCh6U;JpLeeS44gh4T+{yxcDo?KF*5QA2qdhA0D-;WzgA`s zW7--B(~ln(yfpA41?{T1K^NbPZR_ahD9J1+M9xLQ3`o>|0J39FPJ=@kXe~{NvdR%+ zGBQ3(bK{_$iP2EuCLMuO49z3wh9|g_jm=|_0TUWOR!fz!Z;4aIxT97ps989y0gsu1 z`KpX!4Pv0P-BtIPlLwv^F(Naxut>wn2W;i&xS=HTQEUKfYirmZ`>~$nFO>{ETWr;c zlrB+yh@<`Ik9|Rh#l&8WzugB1X0S}Mboe9dsi~=7fOh~N7sRGX(#iNR8!;~!zCx?6 z(0~y1PJiErmK1)YyWACkgsHF&=zuypA3n+sVOF;(@d!RsM@y>+(!vvO7ek_XgM58` z3H#!v2T}*N$Rkbh^_8u2#x9U@`(q%+gxsZTNna>}5lUm7Sx^f?1P2!&X$WZ*IMTJ| zaTiXg2AH8BR8Xiz+*w>$fTj1)W$E2O`bldi~Yuu%ot(;DpFOIbaE5fi3hO2 zY@gpMN+420`{&R0eO2c(TN_ti!xB#R&>R*L@#4#L4MEZi_0B6(!p%jQ( zHa-JfQP{R%FT$DxuA562Sa60SO+o~VRuPw$hR!ywf5vfj#u0UGDz6JO7`sEfmpN+B z;NKw`huq%X9bC(KN&~PO2@PDRLn!+<%Y-j}_dFWg5FHiuWpqX=^`8Ixd~{!`cf^>J9Gb`)U;{r^0Dl7fZ5*ite-vaJ z^V%Q?|IyRXeDGVmaao#xF#}Kjar1U{on-c=SBVglm0hmqNnS#%0~~S;updF50aLn2 zbO2(Tn>KAiD&J|JG}OtmqYj4+Sl}2D{PKlCtrZ0rro0w};Dog01|;UPbY>GYf6O6S z2GtUBm@-Ki4P}+_*tPl^p!EN~8x-1QWwE)EkhFu45KS$4R2@~J+mCnQDBVCGM%Sl` zsEPG*&+tdjbD+}47Uc;4WFv-!82a?i)P)6*>2YaD>6eO=mvd86t~0+Gb%VN}F0wU) z!W$ObC(G>(V>%gW6rj6}F)1MaSeOO|HWCR#o?~fOqT1|O_U%i+?y}AbePwD;;dU^K zHs0?dk4qyEJ(Ok6tpXg!98ihD>m17f%^TQc#tfe1I3z6mZFW(BpP#kzPq54~99XBl zMC0zF7b2Z_gB@n4m!%;sH4lev)Y~7%X7ROHLL>QA3%_sZ30a9SwiunxY5R(|%&jXD zCxhw(xeb5A1WKtsc*5h!ixgn7AkBQ7l?A`=`{zX^lNkZ9K#!L{y2vOG#THQX;{5)r zat!tF3}TSzeHy-;merj)whGK|=UT7tW$VFkrS2-<1WE&h01O_j;+*3R3Os3!P*Po; zJT!me_KwlMYCr7ewBvl$^G0?7yg@`=|J6G{gma9&;V;@k4e#H(jls;TVp8FRM8YV- zHCB7xXJI!z`=|57#2e3}dUCradis>N_b`t^5&$T!uD*W9^D85z zj(zyT$*@O{AOAXaYymQp?;RT?lT!}RGX~cxIU5260bnc3)4Tjh3>lzj5x+OSX0s=Ncz@_!_(LkUu zdjjEJQPlcCE9*s{I~eB87)L^erNrq1dL%Ne{ncO2#8@KrH!;yLmRj9p0Cjp+78VF0 zr}9QjUvtfstgyC9X|{ovCg9eS9BAhqb;P9uxEgh9(hL(#9w1Fw(O-7TY*qf9cFDtFU^6(3p{!!YP(Bb^ z_*q>vaUHh`&p~!{9?X!YA))5k`_iFo9|nI2sY+kj6G zCHnz(MSt}C`NSRvYleUa0;_jf%^&X#1P}WpF9w^k3JMBRQ_bbp(W$j^zT~*b53M-% zE!&K&0r`e)T{#F1G71l)aG@E*5ic*Jh_r=;1#ln{^)Qi3@Q&+O`;PR=Uxg!ZoN7cB zP|HX+omrV?RQL$Oh^@A^wx|aG81(Nx@c;!lo^OaEaFCjQz=E!I8ndd*3;{r14-Z^l zr+2jva4Ub%cloo1;osRSjjJD~hi;2#w8A(DK#!L8cFc^U2kwH7cafEAq55v>P3SCe zDr4V*RJt%8<_A|M>!!G+$n!SpXdClKqXjYWOe)F0W26!XIfj<(?LP>yzBq89F>HQG zh@CDtBrFV`1tmu3b##6pTVC)njN$SRy21X#MM{%~d^B&ID?=Bb;+w64rVi&GMkXc{ zwPI?R*NAOEZ*;FqnT ze|h3mcaWRN!L{;s;O99-E-WA|GV}!IAx(rHu`=A{8ZbB3+9`(#aIFeB zDTZA#O;8cWLvZ*lv}bwa;Mf!%{A>(}&6MW&izhQ-;UW&TRFwo zMRm#PN4kk((sI|RS0+Kh?{RkrT;ZSEjTr7oH5l>`?FaAA{P8BjBQgbYJZ7z}PT zT~#4Ybt*?uEeWhH-LiJpBc)>N>GEU3XrUly^f6JI>c)3+D;xXDex5D+M%(@n2l<@v!rwTd|f z!4<4{Z`3I3!7FC0Jbyn%(J%1HM}XZyNj91T)FD$?%FE|WUNpL8XD*HDe!+`suQ1}d z@xIAB+uYhQixK+PQ~-t2QJRt~UoSL2jU2f{i7MdIoh8S_zIyul`n1^+6wH`m|8k$l zQed7bv6qLW$xPGG@TC|mphsaZrK`*jk=M9rMI^c`kMXA5M2^u8Pyu9GG~R($oe&!F z`tl-vkY|*`YhTqB&vY_~OvFglblJkyBSm-$1Jy2_TReAr0x$bF&VV zM`tIXMZ?iLd6r~3O!ndpH<9y_zXIMphmfN_cz|3`SU&B`1N2KWNI7P^%=km+em*&7 z-+G$0>Fq0)Qqyvs;4=@FiH(gSRr{PAH$p>u`&CEJFw&V)h|p<97Yr9)qwu80R)7DT zloa)2B{7``Aqbxs1fS^NcL+BrIYu>I>^{!%lSUdU^)H)#8?6w){D+wvl0y2jr{5w* z^=&*I-_+c!;-pe2lX%wsUn4Hw-h@VIzH~0s9TO9(lE4ng$PnAoC=~SJY1qhXK3IbkFE%ap7rm(DwiY0A}_1(d_wuPypcUQ1{|vp2Vk(BcNjNuU(%M6es zLR0R8vfy48pBOztx%I&xO~HT%yD!jDL=lbeqGyWvu%+YaOQMPcQsCq5-2)ynK~a&^ zgq)AQO0qfHm^&XhIJiuJDfafQcSwkVbw74-f>SRd;&f0R{pA-|H#avIm*3|{_@&8b zYO2de^mftVkLsw>ICd11|jvDo#)XJ=5ruAWm(op8(WdyLQnEMp(c7(Uqy< zJvC1M5d<%zk3iuE#*sJ+HOPJID>Ljc*pe%g2E~@SurZqy&Lk&alfKr7yGgl@T#@dh z%;^X{ND2mhd7!>kf@Tf?l)wY&eE*(O+GMewX8&W!D2N7}zpWZ_AL&+{Vf(wLj?N81 znx&$-6N-H`_%%6Zk4;PL_9+_8ak+fKe(c@v2Oy-Ac=rP!vD> z`KJK#i%VtpLb+|9#f0c5)JIJ8CODWWL;b-(umeJVO7}RJinVo>vN_`p=nI72lb%&W zt1WpjV@OVF#7Zmx*I8o@R%~0B>}RqFI#g5~deE#^q=SOtiDnt_YvNu?S){{s4+oFE zmSRkj)7sisw`UZUJygU6W&&6~-QHm?GTQTE0?4<+!#~TaMkGOD-&36#WA@*kQ9Jo^ zgfL`RZTN18DGCY%Fw8^R?&?~x_3A+0s3#v0JuM~o!kXl=G}~;bNCjD0Sz>Vrtc$Z} zU3SVXyTdS%$_oxj$SxQe<>chxLrh|MF9rFEuShJ?QWtc6~v6bfa*X;?Mvo_TNd*uSU zw zBfWByhX2`e!t&0M-eWzb6eS0y5@Xov>o-9iz2*5;w1Se-%9QdKFJ928)|&EN`IRSb zyvf|Dm4Y_?4f)v12Tf#{kE=%=?U&9nNX$cG&L_Tu+Mn7WIyasVNx%+ z#~Zy`PR+xIj3G$MF-(v+-}&X+4sKvqZ{H_k#^dbR>nkE`KE$?F85A3p&cCyKoe@Ye zSt@bO?%jjmfF<}kI5^BsNJ~r0%UvC*v^3R%ky-`G$x>(r-Bg-^&6pNvG41=l4_%5D zCFBB_j5)1|Cp#vEKf@ESJ6}cb$bCYfaw@u~r?|MeGx1xm`hkfTNZMrbvSkrFT&N9gP3|7b{*CUUDs1SpPJ`NUn%3 zS@6<0qwm+Ok?zcGs4YOkolF-?DemjMK!VKaH3jI zOHKOKy=&-}`{#@r)m9&}OkKLi-+c9$<=aLtts5Hu;o*T1yGB|)TzFvnrk1MiD!f}>ei;ZuSZ1hlK>7i_8bM`7d)BPzRVfeBZQ@V;bw1w7&Z|bz|7m$| zGjv5EWZ6Gf9m85#Rpp0QDRu5XcgkJ}i-i9I1tU!@U~)rXe|N3J)vfpc{Yqt2;r59F zylY$T&;|)$-u6cfnSnb*UC^s^!8}dPb_{k6N+do{et1x#td|&LaqxNA-<{65SYgPE z(0WL+PCOux?H)f4Ea~WadE(}+TV%d{6w_7o1AQSf2>cyk4ug79peJTvg-!Mz?dqtL zFQH=)WL1enLgbbKn04RrDY(o9!E`A;F=?q}=8L*%B4Uc@{9;`t!$Kvi+J#sR8bjiI zA2%+9u)dpC7kR+ad{#Umz?F$8rHKpR0`v=2CM0Y+cgak!%5*9^;AS>=ftw^GC0+(8 z4;r=m69nkUTUSUsKvYz3UC{SX02%w-)Q{Tvog@P>UQRvH*9ku=@n2Y-HDu^AI*zPf z#>{MjnNZtPKM&Bj=brJ*d`uIhoi1za2&ECI-bfR;?omfHKGTdro2nl@IcTcdnLM^p1C8;1g6j=&u;yySj05ZUFXR4k&>E+Vkde8)U zy3L{c5dp~BG^<(HI@ho7K0j%!Yxn$W zV+!ha$)H_?bAoJ#`23q&u$ft05Lz+Lg$zwm+trF1tl^N#x2MjLjRI+%`~G|lkTFLb zTjQl@Y*Km_fKUJJ-6fJl+af0q9x_&v#uEw&-h#Jxxqh4PEg1^{Poq3%l0QiX;Ieh= z(WkCM9Y5F4cz9$qlQzXy49&H)wRchtW0DB3rvCLFHw(|7VHiLp!^N2fHLZz@i(~A& zi;HkI(9?jek&)Yav`hJY%#cLgAIRIzWoP^OU+$QHe(q9pZ=ijFIR>AjO|U7jZ&Z3; z8nS#0$y$_;?gj;2=#(5e&ehRl$71K2NYs98NV)Ej=TZha_{_>F9UeAE>=vZ%3k!oJ zZ3YPGEQx7;Jo2?}hnK5s3l0in?O_C_J3Cn)*+A59xoJeSh&^BXBJT0O>)tk&OJsj3 zI1uVTZ1fbiJ#?G+VZXREVqWLQzGRizv1#o|1~I|+R#o@E&h)X}$QWiq`k<$K$0r7~ zX7ldw*f%HoZ9*yu*z(GQHy+7B$9>v$pKP|Q$xSFdtC*ivczixbN-mz_w`RA4v|qZ& zt@VZ^xqgu?xKfbxz`S>@PXd}MQc+F{A^{1;=55|6Zg*Z^K_MT4_KbKNa+{L$W8K$% znsiOy)c0wr&)F)UG)|Oda+4O1!gOtI?RS-kCVhA&=u$xW_CRBgv(BN375Bx@QnRk^ zB(3Ui4>Je^?}2ILRygR$<}~a`M(GaXzSNY&b(|~L?Lp&~ zl{J>9aJR9*;YH7G-1up|jALS^(BA2m9;h$o_u#saDhZ``p=Q+6V1SV7=56A3ov7Gm z8L3VN0#}UzhJzPg{QDc#!cQ8<&rsI$Z5L*{4wy&4YQfe+-Q47%c!mH%0PJw7kWdE- zoL~Bh>c0?FPu=2x)o@^J0tq{4mRt32uc)fHZ`qPiwC1`;;L|_%5=ob*m==53Vh1G7 zk$R$zNI_;H>n7Sw4t_7Z#ndNE?IJ|uFmm<*@w0vmR*Oq0Z`3)a2W>vZ(Rmx zqXe32KZw+l~7|#DnY> ze3usp9ah*g88=tx8ZPy9ayls%_apmOGQTa4V!pMdB~0Oa7;Br{-yFPh8ar(Xk}Vwv zY0ex0<3f{JMEZVjo~!hKD8?Hch>W!D?XG(Cu}Ml%AA@xBrcvAAPpczTb^#*jykc~q zrG>@g@bA~E_|)LbAYc!Y4ec@%PK))}Vh>^F;P<#RggvU_n|?bk*l64vKdc!ps!w=h zlOOp7s#{U2s>cmNf*l>}V8BWWEV5ozQ1GF4fEA}$<)Kvj+nOPT=~IMvn@%G^pFvhf z9!4lHujgG_*Wl1_H+aRzVf8-FcOQ>S;y|}8g<|4;| zpVQ^#zm)ti2d0JY@ftq$dXPvs zWc5~Z%W#eyP)D5CYiTi|!YkCcfsK|$|MBTFHBjd17Z|0a(=JqkL5#f(4U4g~xSsA2 zgBLCq*6UmOW#*g_7;W7`_W1DPQwoQr`rWQfzE+$u=+lP|mu!N}S%B$cxv`P1+S^`@ z6WN*we<540*n<=!Y4yNXgSw~X4-P%w6{gI&G-k8Q4b-1BHPwm+UQZ-CF?OJ>VffJj zVUdM*h4YKjv9QVu7e3R8I;oKu^EgU#y|c*b#x$Xs?{>PX`GJ)n?|@a^&<7Xbj7u9( zQ6;281Be@WsVYrTZtz9T)9~3<6uC%8Y>J#-gLS#D>SDT9&)=OX1b|pW0uu%u%p=lp zTz^S05%pF|#hBm=7utx51#vCs+2r`u@W+( zd|U}169}Sq_V)TrvYR!FB2y)we)!PkkjU!d%~vu^t@7GdpCqwcJiPEvXJP+upVo=m zI92p}!J$b)7y2ptL51pL{^yd2M5DEY4Ht#}D%=;5XsEE}BGE*b0l7ZWqW`^`|NQDd r%On#0p9}WSk@$Z<65SX=QGfrA$7_Q