diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8769b30 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +non-vehicles_smallset/ +vehicles_smallset/ +__pycache__/ +.ipynb_checkpoints/ \ No newline at end of file diff --git a/bbox-example-image.jpg b/bbox-example-image.jpg new file mode 100644 index 0000000..bdb278d Binary files /dev/null and b/bbox-example-image.jpg differ diff --git a/bbox_pickle.p b/bbox_pickle.p new file mode 100644 index 0000000..7c2ecfc Binary files /dev/null and b/bbox_pickle.p differ diff --git a/calibration_pickle.p b/calibration_pickle.p new file mode 100644 index 0000000..0a96232 Binary files /dev/null and b/calibration_pickle.p differ diff --git a/car_detection.py b/car_detection.py new file mode 100644 index 0000000..8bc1850 --- /dev/null +++ b/car_detection.py @@ -0,0 +1,182 @@ +import matplotlib.image as mpimg +import matplotlib.pyplot as plt +import numpy as np +import pickle +import cv2 +from scipy.ndimage.measurements import label +from moviepy.editor import VideoFileClip +from IPython.display import HTML +from skimage.feature import hog + + +def convert_color(img, conv='RGB2YCrCb'): + if conv == 'RGB2YCrCb': + return cv2.cvtColor(img, cv2.COLOR_RGB2YCrCb) + if conv == 'BGR2YCrCb': + return cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb) + if conv == 'RGB2LUV': + return cv2.cvtColor(img, cv2.COLOR_RGB2LUV) + +def get_hog_features(img, orient, pix_per_cell, cell_per_block, + vis=False, feature_vec=True): + # Call with two outputs if vis==True + if vis == True: + features, hog_image = hog(img, orientations=orient, + pixels_per_cell=(pix_per_cell, pix_per_cell), + cells_per_block=(cell_per_block, cell_per_block), + block_norm= 'L2-Hys', + transform_sqrt=False, + visualise=vis, feature_vector=feature_vec) + return features, hog_image + # Otherwise call with one output + else: + features = hog(img, orientations=orient, + pixels_per_cell=(pix_per_cell, pix_per_cell), + cells_per_block=(cell_per_block, cell_per_block), + block_norm= 'L2-Hys', + transform_sqrt=False, + visualize=vis, feature_vector=feature_vec) + return features + +def bin_spatial(img, size=(32, 32)): + color1 = cv2.resize(img[:,:,0], size).ravel() + color2 = cv2.resize(img[:,:,1], size).ravel() + color3 = cv2.resize(img[:,:,2], size).ravel() + return np.hstack((color1, color2, color3)) + +def color_hist(img, nbins=32): #bins_range=(0, 256) + # Compute the histogram of the color channels separately + channel1_hist = np.histogram(img[:,:,0], bins=nbins) + channel2_hist = np.histogram(img[:,:,1], bins=nbins) + channel3_hist = np.histogram(img[:,:,2], bins=nbins) + # Concatenate the histograms into a single feature vector + hist_features = np.concatenate((channel1_hist[0], channel2_hist[0], channel3_hist[0])) + # Return the individual histograms, bin_centers and feature vector + return hist_features + +# get attributes of our svc object +svc = pickle.load(open("svc_pickle.p","rb")) +X_scaler = pickle.load(open("X_scaler.p","rb")) +print(X_scaler) +orient = 8 +pix_per_cell = 8 +cell_per_block = 2 +spatial_size = (16,16) +hist_bins = (32,32) + +# Define a single function that can extract features using hog sub-sampling and make predictions +def find_cars(img, ystart, ystop, scale, svc, X_scaler, orient, pix_per_cell, cell_per_block, spatial_size, hist_bins): + + draw_img = np.copy(img) + img = img.astype(np.float32)/255 + + img_tosearch = img[ystart:ystop,:,:] + ctrans_tosearch = convert_color(img_tosearch, conv='RGB2YCrCb') + if scale != 1: + imshape = ctrans_tosearch.shape + ctrans_tosearch = cv2.resize(ctrans_tosearch, (np.int(imshape[1]/scale), np.int(imshape[0]/scale))) + + ch1 = ctrans_tosearch[:,:,0] + ch2 = ctrans_tosearch[:,:,1] + ch3 = ctrans_tosearch[:,:,2] + + # Define blocks and steps as above + nxblocks = (ch1.shape[1] // pix_per_cell) - cell_per_block + 1 + nyblocks = (ch1.shape[0] // pix_per_cell) - cell_per_block + 1 + nfeat_per_block = orient*cell_per_block**2 + + # 64 was the orginal sampling rate, with 8 cells and 8 pix per cell + window = 64 + nblocks_per_window = (window // pix_per_cell) - cell_per_block + 1 + cells_per_step = 2 # Instead of overlap, define how many cells to step + nxsteps = (nxblocks - nblocks_per_window) // cells_per_step + 1 + nysteps = (nyblocks - nblocks_per_window) // cells_per_step + 1 + + # Compute individual channel HOG features for the entire image + hog1 = get_hog_features(ch1, orient, pix_per_cell, cell_per_block, feature_vec=False) + hog2 = get_hog_features(ch2, orient, pix_per_cell, cell_per_block, feature_vec=False) + hog3 = get_hog_features(ch3, orient, pix_per_cell, cell_per_block, feature_vec=False) + + for xb in range(nxsteps): + for yb in range(nysteps): + ypos = yb*cells_per_step + xpos = xb*cells_per_step + # Extract HOG for this patch + hog_feat1 = hog1[ypos:ypos+nblocks_per_window, xpos:xpos+nblocks_per_window].ravel() + hog_feat2 = hog2[ypos:ypos+nblocks_per_window, xpos:xpos+nblocks_per_window].ravel() + hog_feat3 = hog3[ypos:ypos+nblocks_per_window, xpos:xpos+nblocks_per_window].ravel() + hog_features = np.hstack((hog_feat1, hog_feat2, hog_feat3)) + + xleft = xpos*pix_per_cell + ytop = ypos*pix_per_cell + + # Extract the image patch + subimg = cv2.resize(ctrans_tosearch[ytop:ytop+window, xleft:xleft+window], (64,64)) + + # Get color features + spatial_features = bin_spatial(subimg, size=spatial_size) + hist_features = color_hist(subimg, nbins=hist_bins) + + # Scale features and make a prediction + test_features = X_scaler.transform(np.hstack((spatial_features, hist_features, hog_features)).reshape(1, -1)) +# test_features = X_scaler.transform(np.hstack((shape_feat, hist_feat)).reshape(1, -1)) + test_prediction = svc.predict(test_features) + + if test_prediction == 1: + xbox_left = np.int(xleft*scale) + ytop_draw = np.int(ytop*scale) + win_draw = np.int(window*scale) + cv2.rectangle(draw_img,(xbox_left, ytop_draw+ystart),(xbox_left+win_draw,ytop_draw+win_draw+ystart),(0,0,255),6) + + return draw_img + +def add_heat(heatmap, bbox_list): + # Iterate through list of bboxes + for box in bbox_list: + # Add += 1 for all pixels inside each bbox + # Assuming each "box" takes the form ((x1, y1), (x2, y2)) + heatmap[box[0][1]:box[1][1], box[0][0]:box[1][0]] += 1 + + # Return updated heatmap + return heatmap# Iterate through list of bboxes + +def apply_threshold(heatmap, threshold): + # Zero out pixels below the threshold + heatmap[heatmap <= threshold] = 0 + # Return thresholded map + return heatmap + +def draw_labeled_bboxes(img, labels): + # Iterate through all detected cars + for car_number in range(1, labels[1]+1): + # Find pixels with each car_number label value + nonzero = (labels[0] == car_number).nonzero() + # Identify x and y values of those pixels + nonzeroy = np.array(nonzero[0]) + nonzerox = np.array(nonzero[1]) + # Define a bounding box based on min/max x and y + bbox = ((np.min(nonzerox), np.min(nonzeroy)), (np.max(nonzerox), np.max(nonzeroy))) + # Draw the box on the image + cv2.rectangle(img, bbox[0], bbox[1], (0,0,255), 6) + # Return the image + return img + +def process_image(img): + ystart = 400 + ystop = 656 + scale = 1.5 + out_img = find_cars(img, ystart, ystop, scale, svc, X_scaler, orient, pix_per_cell, cell_per_block, spatial_size, hist_bins) + heat = np.zeros_like(img[:,:,0]).astype(np.float) + heat = add_heat(heat,out_img) + heat = apply_threshold(heat,1) + heatmap = np.clip(heat, 0, 255) + labels = label(heatmap) + draw_img = draw_labeled_bboxes(np.copy(img), labels) + return draw_img + +output_vid = 'final_tracker.mp4' +input_vid = 'lane_tracker.mp4' + +clip1 = VideoFileClip(input_vid) +video_clip = clip1.fl_image(process_image) +video_clip.write_videofile(output_vid, audio=False) \ No newline at end of file diff --git a/final_tracker.mp4 b/final_tracker.mp4 new file mode 100644 index 0000000..6dbdb49 Binary files /dev/null and b/final_tracker.mp4 differ diff --git a/lane_tracker.mp4 b/lane_tracker.mp4 new file mode 100644 index 0000000..a7289cd Binary files /dev/null and b/lane_tracker.mp4 differ diff --git a/main.ipynb b/main.ipynb new file mode 100644 index 0000000..2ee433a --- /dev/null +++ b/main.ipynb @@ -0,0 +1,591 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 8, + "id": "motivated-wallpaper", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.image as mpimg\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import cv2\n", + "import os\n", + "import time\n", + "import pickle\n", + "from sklearn.svm import LinearSVC\n", + "from sklearn.preprocessing import StandardScaler\n", + "from skimage.feature import hog\n", + "from sklearn.model_selection import train_test_split\n", + "from scipy.ndimage.measurements import label\n", + "from moviepy.editor import VideoFileClip\n", + "from IPython.display import HTML\n", + "from skimage.feature import hog" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "canadian-science", + "metadata": {}, + "outputs": [], + "source": [ + "# Define a function to extract features from a single image window\n", + "# This function is very similar to extract_features()\n", + "# just for a single image rather than list of images\n", + "def single_img_features(img, color_space='YCrCb', spatial_size=(16, 16),\n", + " hist_bins=32, orient=8, \n", + " pix_per_cell=8, cell_per_block=2, hog_channel=\"ALL\",\n", + " spatial_feat=True, hist_feat=True, hog_feat=True): \n", + " #1) Define an empty list to receive features\n", + " img_features = []\n", + " #2) Apply color conversion if other than 'RGB'\n", + " if color_space != 'RGB':\n", + " if color_space == 'HSV':\n", + " feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2HSV)\n", + " elif color_space == 'LUV':\n", + " feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2LUV)\n", + " elif color_space == 'HLS':\n", + " feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2HLS)\n", + " elif color_space == 'YUV':\n", + " feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2YUV)\n", + " elif color_space == 'YCrCb':\n", + " feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2YCrCb)\n", + " else: feature_image = np.copy(img) \n", + " #3) Compute spatial features if flag is set\n", + " if spatial_feat == True:\n", + " spatial_features = bin_spatial(feature_image, size=spatial_size)\n", + " #4) Append features to list\n", + " img_features.append(spatial_features)\n", + " #5) Compute histogram features if flag is set\n", + " if hist_feat == True:\n", + " hist_features = color_hist(feature_image, nbins=hist_bins)\n", + " #6) Append features to list\n", + " img_features.append(hist_features)\n", + " #7) Compute HOG features if flag is set\n", + " if hog_feat == True:\n", + " if hog_channel == 'ALL':\n", + " hog_features = []\n", + " for channel in range(feature_image.shape[2]):\n", + " hog_features.extend(get_hog_features(feature_image[:,:,channel], \n", + " orient, pix_per_cell, cell_per_block, \n", + " vis=False, feature_vec=True)) \n", + " else:\n", + " hog_features = get_hog_features(feature_image[:,:,hog_channel], orient, \n", + " pix_per_cell, cell_per_block, vis=False, feature_vec=True)\n", + " #8) Append features to list\n", + " img_features.append(hog_features)\n", + "\n", + " #9) Return concatenated array of features\n", + " return np.concatenate(img_features)\n", + "\n", + "# Define a function you will pass an image \n", + "# and the list of windows to be searched (output of slide_windows())\n", + "def search_windows(img, windows, clf, scaler, color_space='YCrCb', \n", + " spatial_size=(16, 16), hist_bins=32, \n", + " hist_range=(0, 256), orient=8, \n", + " pix_per_cell=8, cell_per_block=2, \n", + " hog_channel=\"ALL\", spatial_feat=True, \n", + " hist_feat=True, hog_feat=True):\n", + "\n", + " #1) Create an empty list to receive positive detection windows\n", + " on_windows = []\n", + " #2) Iterate over all windows in the list\n", + " for window in windows:\n", + " #3) Extract the test window from original image\n", + " test_img = cv2.resize(img[window[0][1]:window[1][1], window[0][0]:window[1][0]], (64, 64)) \n", + " #4) Extract features for that window using single_img_features()\n", + " features = single_img_features(test_img, color_space=color_space, \n", + " spatial_size=spatial_size, hist_bins=hist_bins, \n", + " orient=orient, pix_per_cell=pix_per_cell, \n", + " cell_per_block=cell_per_block, \n", + " hog_channel=hog_channel, spatial_feat=spatial_feat, \n", + " hist_feat=hist_feat, hog_feat=hog_feat)\n", + " #5) Scale extracted features to be fed to classifier\n", + " test_features = scaler.transform(np.array(features).reshape(1, -1))\n", + " #6) Predict using your classifier\n", + " prediction = clf.predict(test_features)\n", + " #7) If positive (prediction == 1) then save the window\n", + " if prediction == 1:\n", + " on_windows.append(window)\n", + " #8) Return windows for positive detections\n", + " return on_windows\n", + "\n", + "def get_hog_features(img, orient, pix_per_cell, cell_per_block, \n", + " vis=False, feature_vec=True):\n", + " # Call with two outputs if vis==True\n", + " if vis == True:\n", + " features, hog_image = hog(img, orientations=orient, \n", + " pixels_per_cell=(pix_per_cell, pix_per_cell),\n", + " block_norm= 'L2-Hys',\n", + " cells_per_block=(cell_per_block, cell_per_block), \n", + " transform_sqrt=True, \n", + " visualize=vis, feature_vector=feature_vec)\n", + " return features, hog_image\n", + " # Otherwise call with one output\n", + " else: \n", + " features = hog(img, orientations=orient, \n", + " pixels_per_cell=(pix_per_cell, pix_per_cell),\n", + " cells_per_block=(cell_per_block, cell_per_block), \n", + " block_norm= 'L2-Hys',\n", + " transform_sqrt=True, \n", + " visualize=vis, feature_vector=feature_vec)\n", + " return features\n", + "\n", + "def bin_spatial(img, size=(32, 32)):\n", + " color1 = cv2.resize(img[:,:,0], size).ravel()\n", + " color2 = cv2.resize(img[:,:,1], size).ravel()\n", + " color3 = cv2.resize(img[:,:,2], size).ravel()\n", + " return np.hstack((color1, color2, color3))\n", + "\n", + "def color_hist(img, nbins=32, bins_range=(0, 256)):\n", + " channel1_hist = np.histogram(img[:,:,0], bins=nbins, range=bins_range)\n", + " channel2_hist = np.histogram(img[:,:,1], bins=nbins, range=bins_range)\n", + " channel3_hist = np.histogram(img[:,:,2], bins=nbins, range=bins_range)\n", + " # Concatenate the histograms into a single feature vector\n", + " hist_features = np.concatenate((channel1_hist[0], channel2_hist[0], channel3_hist[0]))\n", + " # Return the individual histograms, bin_centers and feature vector\n", + " return hist_features\n", + "\n", + "def extract_features(imgs, color_space='RGB', spatial_size=(32, 32),\n", + " hist_bins=32, orient=9, \n", + " pix_per_cell=8, cell_per_block=2, hog_channel=\"ALL\",\n", + " spatial_feat=True, hist_feat=True, hog_feat=True):\n", + " # Create a list to append feature vectors to\n", + " features = []\n", + " # Iterate through the list of images\n", + " for file in imgs:\n", + " file_features = []\n", + " # Read in each one by one\n", + " image = mpimg.imread(file)\n", + " # apply color conversion if other than 'RGB'\n", + " if color_space != 'RGB':\n", + " if color_space == 'HSV':\n", + " feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)\n", + " elif color_space == 'LUV':\n", + " feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2LUV)\n", + " elif color_space == 'HLS':\n", + " feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2HLS)\n", + " elif color_space == 'YUV':\n", + " feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2YUV)\n", + " elif color_space == 'YCrCb':\n", + " feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2YCrCb)\n", + " else: feature_image = np.copy(image) \n", + "\n", + " if spatial_feat == True:\n", + " spatial_features = bin_spatial(feature_image, size=spatial_size)\n", + " file_features.append(spatial_features)\n", + " if hist_feat == True:\n", + " hist_features = color_hist(feature_image, nbins=hist_bins)\n", + " file_features.append(hist_features)\n", + " if hog_feat == True:\n", + " # Call get_hog_features() with vis=False, feature_vec=True\n", + " if hog_channel == 'ALL':\n", + " hog_features = []\n", + " for channel in range(feature_image.shape[2]):\n", + " hog_features.append(get_hog_features(feature_image[:,:,channel], \n", + " orient, pix_per_cell, cell_per_block, \n", + " vis=False, feature_vec=True))\n", + " hog_features = np.ravel(hog_features) \n", + " else:\n", + " hog_features = get_hog_features(feature_image[:,:,hog_channel], orient, \n", + " pix_per_cell, cell_per_block, vis=False, feature_vec=True)\n", + " # Append the new feature vector to the features list\n", + " file_features.append(hog_features)\n", + " features.append(np.concatenate(file_features))\n", + " # Return list of feature vectors\n", + " return features\n", + "\n", + "def slide_window(img, x_start_stop=[None, None], y_start_stop=[400,700], \n", + " xy_window=(64, 64), xy_overlap=(0.85, 0.85)):\n", + "\n", + " if x_start_stop[0] == None:\n", + " x_start_stop[0] = 0\n", + " if x_start_stop[1] == None:\n", + " x_start_stop[1] = img.shape[1]\n", + " if y_start_stop[0] == None:\n", + " y_start_stop[0] = 0\n", + " if y_start_stop[1] == None:\n", + " y_start_stop[1] = img.shape[0]\n", + " # Compute the span of the region to be searched \n", + " xspan = x_start_stop[1] - x_start_stop[0]\n", + " yspan = y_start_stop[1] - y_start_stop[0]\n", + " # Compute the number of pixels per step in x/y\n", + " nx_pix_per_step = np.int(xy_window[0]*(1 - xy_overlap[0]))\n", + " ny_pix_per_step = np.int(xy_window[1]*(1 - xy_overlap[1]))\n", + " # Compute the number of windows in x/y\n", + " nx_buffer = np.int(xy_window[0]*(xy_overlap[0]))\n", + " ny_buffer = np.int(xy_window[1]*(xy_overlap[1]))\n", + " nx_windows = np.int((xspan-nx_buffer)/nx_pix_per_step) \n", + " ny_windows = np.int((yspan-ny_buffer)/ny_pix_per_step) \n", + " # Initialize a list to append window positions to\n", + " window_list = []\n", + " # Loop through finding x and y window positions\n", + " # Note: you could vectorize this step, but in practice\n", + " # you'll be considering windows one by one with your\n", + " # classifier, so looping makes sense\n", + " for ys in range(ny_windows):\n", + " for xs in range(nx_windows):\n", + " # Calculate window position\n", + " startx = xs*nx_pix_per_step + x_start_stop[0]\n", + " endx = startx + xy_window[0]\n", + " starty = ys*ny_pix_per_step + y_start_stop[0]\n", + " endy = starty + xy_window[1]\n", + " \n", + " # Append window position to list\n", + " window_list.append(((startx, starty), (endx, endy)))\n", + " # Return the list of windows\n", + " return window_list\n", + "\n", + "# Define a function to draw bounding boxes\n", + "def draw_boxes(img, bboxes, color=(0, 0, 255), thick=6):\n", + " # Make a copy of the image\n", + " imcopy = np.copy(img)\n", + " # Iterate through the bounding boxes\n", + " for bbox in bboxes:\n", + " # Draw a rectangle given bbox coordinates\n", + " cv2.rectangle(imcopy, bbox[0], bbox[1], color, thick)\n", + " # Return the image copy with boxes drawn\n", + " return imcopy" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "large-washer", + "metadata": {}, + "outputs": [], + "source": [ + "cars = []\n", + "notcars = []\n", + "\n", + "for img in os.listdir(\"./vehicles_smallset/\"):\n", + " cars.append(\"./vehicles_smallset/\"+img)\n", + " \n", + "for img in os.listdir(\"./non-vehicles_smallset/\"):\n", + " notcars.append(\"./non-vehicles_smallset/\"+img)\n", + "\n", + "# sample_size = 500\n", + "# cars = cars[0:sample_size]\n", + "# notcars = notcars[0:sample_size]" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "protected-enclosure", + "metadata": {}, + "outputs": [], + "source": [ + "color_space = 'YCrCb' \n", + "orient = 8 \n", + "pix_per_cell = 8 \n", + "cell_per_block = 2 \n", + "hog_channel = 'ALL'\n", + "spatial_size = (16, 16) \n", + "hist_bins = 32\n", + "spatial_feat = True\n", + "hist_feat = True\n", + "hog_feat = True \n", + "y_start_stop = [None, None]\n", + "\n", + "car_features = extract_features(cars, color_space=color_space, \n", + " spatial_size=spatial_size, hist_bins=hist_bins, \n", + " orient=orient, pix_per_cell=pix_per_cell, \n", + " cell_per_block=cell_per_block, \n", + " hog_channel=hog_channel, spatial_feat=spatial_feat, \n", + " hist_feat=hist_feat, hog_feat=hog_feat)\n", + "notcar_features = extract_features(notcars, color_space=color_space, \n", + " spatial_size=spatial_size, hist_bins=hist_bins, \n", + " orient=orient, pix_per_cell=pix_per_cell, \n", + " cell_per_block=cell_per_block, \n", + " hog_channel=hog_channel, spatial_feat=spatial_feat, \n", + " hist_feat=hist_feat, hog_feat=hog_feat)\n", + "\n", + "X = np.vstack((car_features, notcar_features)).astype(np.float64)\n", + "y = np.hstack((np.ones(len(car_features)), np.zeros(len(notcar_features))))\n", + "\n", + "rand_state = np.random.randint(0, 100)\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=rand_state)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "champion-raising", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using: 8 orientations 8 pixels per cell and 2 cells per block\n", + "Feature vector length: 5568\n", + "0.27 Seconds to train SVC...\n", + "Test Accuracy of SVC = 1.0\n" + ] + } + ], + "source": [ + "X_scaler = StandardScaler().fit(X_train)\n", + "X_train = X_scaler.transform(X_train)\n", + "X_test = X_scaler.transform(X_test)\n", + "\n", + "print('Using:',orient,'orientations',pix_per_cell,\n", + " 'pixels per cell and', cell_per_block,'cells per block')\n", + "print('Feature vector length:', len(X_train[0]))\n", + "\n", + "svc = LinearSVC()\n", + "\n", + "t=time.time()\n", + "\n", + "svc.fit(X_train, y_train)\n", + "\n", + "t2 = time.time()\n", + "\n", + "print(round(t2-t, 2), 'Seconds to train SVC...')\n", + "\n", + "print('Test Accuracy of SVC = ', round(svc.score(X_test, y_test), 4))" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "published-textbook", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAADfCAYAAAAN+JPJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9Wax1SZbfh/1W7H3mc88dvzmnyurs6q6emyJbNPVANGGaMgxTMGBNkCAJAhoGJBiG/WBCL/Kb5RcbEizIaEOSSVgwRUiyRcuUZZLioGaL3c3q7qru6qrKqpy++X7fHc+8x/BDxIqIfe7NzFKrG8wmcifyu+fss3cMKyL+679WrIgQay1fXl9eX15fXl9e/2hd5h92Ab68vry+vL68vrz+4K8vwf3L68vry+vL6x/B60tw//L68vry+vL6R/D6Ety/vL68vry+vP4RvL4E9y+vL68vry+vfwSvL8H9y+vL68vry+sfwesPBdxF5M+JyPdE5Aci8hf+MPL48vry+vL68vry+vRL/qDj3EUkA94H/ofAU+A3gH/OWvt7f6AZfXl9eX15fXl9eX3q9YfB3P8E8ANr7YfW2hL4y8Cf/0PI58vry+vL68vry+tTrvwPIc1HwJPk+1PgFz7rheH0yE6PH31mohaLIJ07IFhSy0P8fZAbv33O9RmPWp9X/Ez4Lsn3z8pNOt92Srb7ovinU6tKbnmuk4B0M7qRQbcEn575D3vdltFuHjfTtoCIkFqMAq7O1j2RSvjL9dOffe22wqe1sl6f1RP+u79wa2fbeSIdF7tjh0/55fd36Ti9NY1bOtNt/Ut2P3QKJsn331+JNc/b3rp1JHWgIMUcl9L5k2+fWWvv3JbXHwa4/1CXiPwS8EsAk6OH/E/+jf8n1goiINYmwrUgfsALiBWshRawAmAhqTheCdhw34Jog1usdb8FAVv3u7U2KBB911obQMiKwWKwtnVtbN2zYiUCFh6XLe45XDnBmUiCDa3rUwWgsTebWiwY0ZIS0rLWIiKAYLAI0NoWi/hvriyxvlEtueq22gC+k2gdhc+C05sdzyTpaW0MWIv4jq/lsD6/IHfp1jft8BbX/iq3zkCw0JXI519RXjv5qBx82dKahfc6ZejKRushO3l8Xhk+r6zQlU9oG6ttSwAWo/0+UYoirk/egEuxafU+pQCE+uglIkm3iH3E9XdBjJelL6cRcZ/tTj0A16qxjxqi/LoYKonCt7S+E9/kQLtyim0SIF40GYuxEvuVBRGz0+Ut2JZMTHhX286la2jbFjFRVp1ySCSUrv8YLycbuph4OVqVoxHato3KQyQ0VcAiES8Dg74NYBD+4r/23ie3tiV/OOD+DHgz+f6Gv9e5rLW/DPwywMnbP+XF2zrwFR1vEUa0gfRu5ius+O16ugSyGxRt8t0mHxSEVepOyAl0iP9Ne4NnlsZIohAkNJ4Nfck1SethyKAN45qrbV0jWduS4epqjAKljZ1pF5QsmNCHhNYrFURh3sSBYkGMCQrL4t5NIc7qULO+G0kK7t1hpIOviw02vGfDM1GwRlKVQvgtHRDK4HcB2GfayS02h4Qy7QLmbeConzu/hXetChBrb0k3UZLu8dvRMa3LrlWyW57Pum57Tnw/S2qZ/uhALBkL4uujwKj167wrEfw6ZVUADW2hdTGIkUhW055kbQCs8K+I6+OtDYpIACMGG4aPJ0O2m6dLb8ceF6El6SM2KmkR48FTAiHTegQR+D6OEbCtG6MSe7r2BSc7E+XuXxUEMZ64GMEYwTZtGJAdwmJ3+oNJtJKN6btHLa0nix1FJaqRtAklvBHH6afRsHj9YYD7bwDvichXcKD+zwL//A/7clIPJICEAlLXxLMewd2vrX9fNZ94EGxDI4EDM1UUKdhb6/IK9x1ihU5D6KdR6xrjGzCoBNW08T1X4hbIaMVE8BWh1f6QgtsO2xERaKPm1/ob45VGuBe5rnjlERSbuA6tnVwsWEPobLLD1Nq2SdpBWYK72qB0bRjYIu6+6FMqs1DmCDDa8fXaVWy7oC1JGVL2bLzySsF7F9RT4DJJvq31MgpV7IJy+l5UoKqUd1htpw1uYb3JvZDHTv0+VxlYE0ASie7JKGKJGO4VkpILLaKzpuJzrd11czpQMWldfF9X2allG8aPH2dhHChgJ2VK6+pIm8tB02rFegBVeciNdmzb9oZMTBgQ1mejDFk7GoH9GsloBRrbYkTIxYB1dattgxIkwbr6p2RGEsJok7YJirXbVLf1bddPJCrNhGCE8RzIkAQCgyoGcSxdrQUblNxnw/sfOLhba2sR+deB/wrIgP/AWvvtz3svbZSAuB4aHQPoKsAkPxxgmQgg/rc2uFUkgn0Yj7GTuoT0XfH5Gp+nY+GOeWhjemZuW6eJrfFdQ7VxTEfEkjnCgPXuBjGxAhZw3gyLMirrabpjOa5DKnCKsVjb+C5gfUNH0NPB5gBaHBhYi5BhxQY5iHY279IxARJwICZav512SuSLVxBtqEgbZG0lgp4kzEQBTsH5tn4Q3ErWg5NXFo0qcJURjtUao2X3SoyMqOx2L+c20tJ5He5LTQQjSR1DuDaV1vcF8eCgSjcqBiUIu3VSN48YEywdTT2yUNc5jbV+gGsfUsm7thGcUrWBd7RJShmtdwK6crXOfaeZdIm6bxzXjhLhzdffkiX10ZERSILx/dwmTsGAii0Y5zhUeVvrqKhJ2xhvEXiW6/LqKp4OYIaCSGgLlV18TgKBimMrWl+hT2Kd9bxDG4131wSCJgaxhrRVkCYqr+DCiwrmhhXph5tY50bVMRGaxcbvSBw/xkoEdHHtaFBl+tnxMH8oPndr7V8D/toP/YICt3bixJcSTCOJ/jnXwM5Msno/BeqE/pssC2zJerAIjCr8q5wwKgJrVINrx3VdX4wqHMH37s4AhS7zcAzXdTI3dKTDBrSeWu8brE2MVxb4srTe9x7zd42urhyTCFPVjTI5Qv3ca7YD3sEGSUw/MXTBKpRFsG0cRGFw2OiiQhlLohJcG3jF0RXATcbeMUE9e1MgSmQYm92XBzrppT5dN8qyoIzEtp5hpS4mVecBdkMbZdpU4hWZmGSg+R7kTfjdOnVrS+gHIgZJLE/n+UsAaudtCW3ki2Z9wwAiGQ5D1VdsMLvjyaoS3JG5GJrOfcFgQjukTNOBvAdiY3x/dPNEOtaQOA8ULJyUHewwdJdn7BeqxMVIVCI63tF5rK58gs/dEyj112tTxixVGRPq5orZZdSuz0kgmPhh16mIRPJ424xQ1xq3gSQmtDNYVmKtK5MYP+9GkJvjfIlivKVvpdc/tAnVG5dvgM7AVPCW2DoqKDUf1ZxpIfjlOgPZD5DWJy62myXagZLPyjwcw22jnx1crlYZWuwMhBLaYBm4ewk4eBNQ66euIPecDSSqDZo/GRDgQTEObMfIxE/q2k59U8agEO+hKTBi7SAxp0QeouAQmW1gQCjjMAlL8Z1bWpA2gGzwhaIDLpEjRJ9i2lETJWWte09/tvi0dwaqy884oAxt0zXnI1h6NumVhJrNqvw9xcN2BRObERufJWXWBmubDtO1RMC57XJKwVMH2/r2MH6wRyhNtXAoknhw69ByCbKxtomva1tgsR44bri0hNg3fN8Xg3OLqPr2SkwCQxXPuOnUG2NQHRRcLRaXd1IrDQWIVZJQXkfsJHHBdNsxgH9SD62nWlBpGwTyppjhf0/5b1Dw7otPVy3YxPXk21yniCNRvE0hdzLo9IkOVpG4mzxeGfHWD7bTjz6PtcMXCdxxFdH5YAUlJwxvdnZAU00Vhz5u0tVQ7w5o7dg3FWq44mRIZOY3O6aCp8K1xRrPyokvtPZm2nGSNvqXQ/nUnNc0tPx+ILqs3TAQr9GxUcMHv5u1WEM0VW8FuMbLWd0e7pmWNpiBQSV5dFa24EwPh7aR1UTLRt82IsEn6FJSwPTpIiBZHJT2pp89lZWE9vdDwSrw3s6Qdll8/JySBP9/nM0L/SSVQiQK+q+l9QrKyVhNdVXgAt7QJ0lHax6ng3HsPpZcpefaRN1KO53W9cuo2US/duCS8G7U797Fp5YCcVykssaCMWnkig8y0PwCr3D1VRejY6PgdFN0jyISCUhg8dEC19/V3RCL5NtJwXVHQbRejgawiXsvte5jXE68FDgD4HufdqveAF9mSZ4P7R8U4E3g1rkvI3F+Yrc/a6/ToRBcmV6RhnYFjzGh8WIb6itKlv6oMHfjujbad1QQ4ZLYuGmkl1XfqJeY+qMiNY3D1XVqie8m3Tgwdok+PDfcPNAF5uKZsgc6l6b/3bYufwUWBRNJAGBHX4dLzcFQacdeXdJtqIVY/PyCKhPH9tz4DHYCiJ+F77BrVVAtOqfgfLja3dSnTeL/DA2QPJeWUQGekH7abmr2hvDS8IQbnlask3HCphDjlJoqA7yiEkHnEFxdvSvExnZ0ybSe+Bg/KFL/ZJzQ1olKla0DEa+sArONwGGTfIMyQzxQC41t47wG6QB3QNvaWJ4gVdEIKjcP4fyBnt0Z519X8BCvQKKr0IY27o4WUa8lJO9a4iQfcKN9MzFd950H9DZoicRC9GOrDeRBEGNjKaz1cyFpm3kFgwKxf09DoF22fpyZkIfWO1GBXXXmyxcm/Yng1wmSIAJifM9GbEnSTCfZNZ20zaztKp0wuneeUzkHWmHFt6vij+tPOintiFYklG7+jPC0G5smktvPuL4w4B5NDq2wzhpL0gjKOAKEoWCjWCpJevamD8a9ad0EmVXihtKGXWElnVUSWE5uBlizaYd10SPBfI8lDGVz73SBI9Y86iV3z4SOIx4oLM4Xjw8F046mk5qhvJYO+GmZna841sMNoOg3bq2CjU3Yu88vTW/Xd67tqO4b79ZS2UnSDup/DFIWCU2tQ9TSxLKq3DxY6wRdnGWLddb2jD2gCYMygE7Kp7TzWPeW8ekbyVxdfGhf8GV7WXT6Ylr+pG2DjH0dbvqJbRyo2uV9TQO7DXUyRPgiqUMEf2dludhzMc5nftskr9YJETJfLgmWVBb6egpaUelFAIyAGfMwJotF7KzX0NDcAO2E+TOUnLVqkLvXTZShk0ccL5K0W8qMISGBHpx3o24iMyexzjXNqITCldQ3jNl0LCf30ytEt7jKhDyNEZAMF7ThFZyNz2o4sxFDA2R+pGho9ec5Zr4w4K48TZme+1d9u6lrQwVpPcvxVWzb2FA6kDxr0EZS5mVddu7ZnY6ql3aENjAxdKxpcUNDuc6fDMik7JnvYApVqQKJ2dlwOzUtFYzE+2A18sEZnbpAIpWfRc1xu1O/qEB8x/VMWH2vjj83oV6yY9Z380jqaTJ2XSuBCQPi2aCECnsVFga0s3TU/6kaV0zMuU18nta3a9QvXRasjMpiE/Ya28N6iyf6nKPVJl4RqvVkJOsCsS+/utp0Mj/NX2vu8aHjFjMmWiQKqk7Z+DiloNS80tC+iyR9RSdevVJPwD217DU2PcgYHwUSoSWOAYIdkADarqusGwWi4hD1oackRpWel2mrsvZWosutTRiZKmqv8AMB6YJr1JN+RKpeTn39/rlQGvHzWpad+nTbrPX9tw1x8Mkg8nLJjOnIoNPfPQC0tisnjQyLCam1r4w+mQNIW8OYsNal8X1FwLtjTadsn3Z9IcA91ftxYU3Uwp14dhsZggSwkfAtpJdgUAcE42qjoIlv9fmGhCRRBAlf8omrCR6uABQ2BqQp6OAL1GGNMW2QTqQF/t04Cah1d77+6LfuStJ9Mglb0gKnQOUl6ifuPPwQY4UF5+c3/r4HKR8VYdsmlFsSNu8dPhH/tXxBU0hgWS7kMiqfmKCK3QawdqK1vpQOJEJgojifulWaGaE81DWRaPJclJmL2XdA0KgMrDJ0P7C86WwVkb2i1ImWqMA6kvbV0lkVGyb3ETrmPvgJNG1bHRnGyz0MfxMqpU0ViICvv0bwxPZUZmm82arlksh+iYo8WCcpQ06Ulv8pqXcC9IBtk8nHCLudseIMqNjuqowCAGq6N2QZx3AEyCj/ttPaAUU6RCdNS0OP3RgzoUyRXPk6iXADJxLFkjL6lOGn8tQ6KvsW3MpZnZOwouQNHVxkRt1lttM+n3d9IcAdtB46makmrJuoabTN3S3CxIzGakvg40icbUBwQOCUhmpmUEWQMqrULwY6S80Nb6ZqjeDD9LeUQ2njiYhfHh4bMYQe7rAI1fZ0WIHpdCxFA216a3ATWPjQKRRgxYe+mRgGdpu8E2YT7ySd16elLFXSuosuXIkKK6aTDGdxQKTrDYJ53WEqvmaBcXfN5aCEVHAegEM/SCZeSVswgFeXNQVAxqYZEK09GyecfR21fVPwVvYoqJuHwD5Ta9AEttd2FJUWwzFQB05urlYnpTUqRQUksY39c7E8mrBT+lqe28BM++Yu4N3CDzqKDdQSi78bjWJqbZJGdB2qDJ0iJqTj6hvnoZyC7pK0UEIlSwrknbZLZO1lFNe17NRjZyBE11oX6HVLh2CZ+frdYOlp/jpmk/4T+oH2a98XjITKBIBX5elWs3e3aEj7p65BCPbX55D3Lwa4a0v6Scpg4uBM5FYpijZ0aG1UckAbVrMGENHBnLIgHajJAEwXMomu/JTYHbQt43SjDZravRa1twtp7/CFkEZmnHIxN0J3UjBzvSGFSvdP4mf1bDHN37ZpGZIJ4kTGYZCq/vPZpZZNBHd9to2DoIMAruOn2y7oe9q5nRuoTVYganihnyMwaqbHVNsggu5g1EvnAbRvqOxck8c5DhGNTdlxJ0ioXKxSYk2kudpU3uEXm9THpyXxT9dV5u6HCVElItrddKsNCKAUaUJshq6ElNw24b7G6WvCqV88Zdyh1J4Upf021q5T9M7v3al0zcstdHKuOWWeCtRJaloO4nhO5W19WoJu8RF1mkplF9hj2jcV2W6IZFCkmqdIjDSTOF6jViKm5xdrKVZ0rMyETXeKZCTEszdK9hJmH6wDHzLqh1uY69F+Kd59pn2rFYtuoXBLtp3riwHuiO+gjnHGriw++kD3dUhCCUOjN+79W+I+HeQnezdY3ArPNmnwoAg8TPh0W23wDhFMWK62Br6jJ9inXtO0HDroTYgotEH5RF3UuolYD0DaoYzR9a/aycCKoWnbELqZgkrwvZOCWlJPtVj8v9Ef3x0UTmam+15ILwSthjYRke5iMuPcOZ1FRDpi8UowVVASZ1luG8RaR+tGQXgq3a2js25AGZjWPxYWFxqp+/FocRNlpg0HCUjEsmhkjbWW1kbYCA4uZX1EeViSvrDjettdkBPKlQxg6xJ2v9ubkNLRhx20Vv+1Z/66MK2DvalS3+kz3GwNBVrjljn5Sb+4VjZYTO6Lyz9YG74eNvZYBVdJZR42uesCc0cBJS6QG5PGvv3jMn4hs7EdgkvQSJgD0X1tRLxnwLrSpYRQdgQdfksUqMU6UMf3M+kqMNBJ5S4ZEOIePK1vo8zPP7WR/oQyftb1BQF3f/nGd8v146B0nTqJ0pDIHNIK7vrO4+cuLwlubQ+i2rPUNeBMdHujR982mRIm5brV2Bl4XZaddsagxROLpdN1RMP1rN/AxT1gwLkNPIiJEc/YfeMHNrCTFwo6VgWpGcEusHOzA0XmcXvncqGgnRimwHA6jBI6g1EnQYEbK2cFgjUiHijSBTNxwKft0AVkdS85sZmA9dE91ckteUcCN9N8A5uWWA9LBHytuhG/7jRgy467wMtCLcLWejdgkH1XtqkvWQHvtuGt7i1Jyg2pvGNMlmOU+rsrv9G1HioLb2mZsA9pJEFmR85O78ZAB9ffO6ntKI2ExVpdHCg36t5RfEl9zE6ce3xGIiFJ21q0f+l49AkqJpgoM0MMDU37rtYlWD/Jb0GNhzbM0FZOSdht/UDf71goQrCG2uAT8GTvjwq4OybhwrwaV/4bv6cTiKkAPlODeSaiftwUy2485kYqWMGkCJ323NDfk8lY7XrqbgjPxhjlwLra+C4QQDnd6S5kKUlUSBjXvhaeZSSL3oPG6kykppckcOAprwupdHwrBd6QW6yyB3/8s90GkiRfwfn9O+xItSdRQbTYsHilw0QSABeVTfRlJG0Y5bbLNm8b8FEV4CMR4rYMEhRd8gw77q0baXq/uHTbTovTWhsn6tKfbGSqgc1JFHTqmAl7FlkbIohC30urTWIFpUpUANt29jNSoSmwK5Rbv/OjygWxna4f3Jsi4BdvRcBW5dUtW7oQKHhQPXnSWYtIBPw7iayjUgzCie2/wwCCok7dHqG6NihZVWptLBnetAjKS/BbaYt/PmnHkL6AYEJ8vzF+nguJ8QuhfyeKwVsKuj6i3XEbtUncjPuezuF5V57JPg/bvzjg7gRO8Nu5ARMpRTDLksG7C+rGGL83cvJeYK03WYN+DAAsEgdGwg5AB5n2jti4yYMEgBUJDeqJfTKIiaandkafN7s+PX1fmZYORNEyaJYd6PDvdGXTYY3BN2sDszQh/TACO4CjSaoM04nXdM5CF/GEtDxI36ZuJElHknsqq1DctFwdhkTQtzfqq9932likG4GDWjuhjkJgFtqW4v2nbUuDKizrV1cmmaRugRR3dq0fm5RZ4jPWWmy6qZy1zseayFHEBBemhm06S9ODTwLWsRzRX22TIiv70x6uG2PdkF+HUAESJ/2sKt7EPagERHSBnKTjz5XH/fXrF1Qz6mZznaCIxL2TvGd8u2loqxIhUVmKysTXVZKMRD+lc03EvLTMPvbLpeknM8POrmk0k3uvTdo/jicvTVVQfiJZjE4yCyJtULQhJFS8hWm1p/n0JMr4H8rGYb+fy4g6o+N31aiRtUd/fLpVbCedWxZtGMlobdNlSaQAkXw3eMBSwQsatxufcn78VgeX4Fat2k6wUvKvX3qiuBk3Vw96om27i4HSvUW0o1j8jpN+/NjQ0O437UC2M+N+myK0YT+QkF/ymxeavkxULtH376DB+sVavqaiJbGd1HZdZzfaLACFjVnuvJd+T8HeJr+lvu0EN4Oyjd+TvxbwKwaT7ufzUR+xxO8BL6IVZMH5ajvEIZrfmkawJkxamtt9uUYy7ypoCStWJebrepqNII1zf6jbStzMvWfgfuFMUOqhStHVo0TIaGvfdHdo+3TKqm2R9vvARP28jDVBEYqNdW/D++6D0dXCAQskKFL3XB5YuA1yVFmrVZ/0dQ1lSxs+UVIiSfDETp9zAKwLjm6WXYlklmkEk7pzPLMO6UXLwAZV4Z4zmrHVVnWLyVywgHcJpnsMqaK2Oj95G2WK1xcH3I0HKBuiPB2AWRuBa6dhdmev4wDfCVuz+EUB7c5zyRUYTdKhrQ6EdNBGkh6Gb9oxwiDXwd+GQSVInMwKCSbvki627E6G3thPwg8K10F1oUwE3ljmNrJ/rXfCmL0uC3Vzb/hqeUYby9mBvti9OuDdrY8QlUv6N30m0SyJbLvAHnON/waWv9vevl1SV07IL3VpJHKMWBvrKHiGnwC3WOX1UXv4Vr5BHMJgd6yiI/9d18xun7S0HXHvykPLpsaV8sCObEVC+7o6dgmRRWL5otQ8QSBJL7JE17V320ZIJi0IC6yUkIlGUCnqSVDQbTqBrYv1fJrKrkN9VY1IlK9WzqkjCbLV5tmFv9sJgw0Px3aQIFuNUMFkIW2ALDMJ4fDjyuycj7DzwRLJjMF6L4WCSsz3pnyVfEp42/tpPvX6QoC7gqrsTKSkpqQOHD2SKnXTqJmjv7cK4tZrd/UxEveagMhgTJQrbaKdHamT7qDdSVPD/gBs6yZ4HJtVc1KSjp4MgF3wkptd0TW6N8GTlbLKwj590jOV7M3OnEAx6hpRxm+94CIzipE0El+LOu2G8rtFcXKb9ZD8tlPwlCnelIdm7mWNRr7EeukanV35dKw5lY9EDpTqmi5p4Ebb2fAgkTX6hxXU02aI70T3RYct6uC33UnjwEoxkatY68ZLWuakHzqZWj8n4/uApC2ok5wRsLX+4olJbFeLmIQwqQQ6CllBaad/SxyfTkbafKlPProWRMe1H5it/y5hAVdc7RsXNrrydk+KUrYc048T8IkqMbrQT5VZVIzahtrMAVRVJqF/xLa4oVxdxuE3J+dYAqMHCaXWhW8MV2/d+z5DI+nwfSOzNdiaz7q+EOAOOE+HFt7fUs1tfAdHBJP7aW3rGEJs0OTIqiTYX1mXmkFt66fQbGKqa4f2Csb1rwY6JfHAJW00r8Le6cTfdwBVQ5rEEDpSYM3W7DDPCI4KBqmCSzdYSEdXGJBJWT3nwIsgAQL3bhqS5Xii3VnQRBiMrghxcYZSmnDMIV12HstEiFlP46JDvZTFJt0grNT24KIK+4Z/Ps0rlDpO+KX+z66c8H3BDbTIE2N+oVypjJTJ+v/C8nDASrqCMBnYyQCPyKblFfTELMLjSR3DNhLKmpO5JJWYOPedIz9xtatreas9iNjntG12pGY1LM+lbcTHU/sGdJ/a2Oc7VfPKyEBnFjFKvcPE8f5lHSm69UA4KUqVgCpMrb8YoEE354sgLxjj97DX3aiMcRF3kEigu/4idb9ofeJ4a325HJAaMsJ8gPZjokIWna9wzC/KW62zJKLHuZN9AINXva0PvEgJqyJAK0ImqqhcGXPZMKzPKIsln3V9IcDdmRvJdrUWLxg/UBN91407Jxyq0UVZbbQIpmG3O6PgD3UaR+sB0IobuLYVpI3C1nBEG8BKGXVXSztQcF9b7xKREMPvswuDyykTG8pKyC9OQloy4v4suue3++W2NLUoQmRm6sskyPamJRGZeJelOfdAltBaFXdQukR/b4wp03ZK3DdJ/aJSjRWIKkqCOyTd7Cm0+c5fCfkoeJkY727TJwnKJO71071cH4hAjESrwK20DQIOjLvjOkRi++3KWBWSpueJhm4opmmqtUhIK6hbx+BsBD4lE0nzJFZespWBSFKeRO64/hFAlCSoAO0JcRM59RxrNwx9y3ewcGiJ9en6dQ7peooQq226/S8AfFzZRZzkTAgWxFXKQWn5dxOrwFUh3SsmZeQJCQmvKmCn/TLpPwnxlI7VY9PsY48XOn08tn+cu7DJbwYJYcCx39gwV+eUqKVcX7J8/ncw9c3+m16ft7EYIvIfiMgrEfnd5N6RiPx1Efm+/3vo74uI/Dsi8gMR+ZaI/Pznpe8E5QaIaZ2LJGwEJISKiqQLldzgd34ux4pT90JoQL93iQ0dLy6ZFnFnKWZicNtDqTa1SNvGmXYILEp8Y1k0ftl3pgQIHPPx/0MCdDoIFQz9uyKhns4FEyodPlvPmJwMMoIf05ikE0BHQYBnBgmTCOxJdt6L3VmtElWyhriyLuQgNmHgKtNkkAlRJqRy1HrttL8Cu6+yjT+EXQ0V/G4oCUlkdXvy3fz91RKJphgFBRtAeff50L92ZOHSkagEEhBNLYXdzyICxoa8tb5aF5EMVVsRdNxn3cDKJLIJZTAGyFzf9wCXZbtg/inl8bjqeIGbXO30Mf3NNbrLI+6gdKMtQlc2QBirgl/15Mvun8MAueuvQuhzmRHCdi9+cY903kvqlBlfrpi2EfG3/Lg3Wl8TgjK0zwVO7hWsCYfLdNtXZe9kE8eiTmBbt/d4Um4vg/C/ay91s2ja1kCbbK5mJXPl1QAMsWANg94h603NZjX/9M7ODwHuwP8N+HM79/4C8Dette8Bf9N/B/gngff8/78E/Hs/RPoAgaWL71ihw7of43OqmYGbYCZxw3z3cGhkPaVHgR7PhhT+TNqgqlBSwRLNNhP+z/x7plOOYI6h4Eh4J5RczXFvMqhC0gMbBOPTz7zLpHVKJvTd1FcpNz6LgBHHqA2GTNyRaVYkDBBlNPqO6dTNyVA/W8D6c10R3DGlYklBoiNySceZBJDIjAnglOYdpJcA664CIsnrNuC9eSn8qm7oljewWHGAYxOg3QVzm9zbBTyhW4ZP+9tVxjcjTzqKw+KBIzJE7XuZMZ2+dKO2rvPvyCVVOLbz/bY6xvBhp2jcZm05qZ/e5+JGkfGbwPkZ59BPFUyNitqlp/0vpGUAY+OB2eK260Ccu9CqaybZbE4tcTywKniKTyv4+SGMMwQk879Lq0m6JLIoZ/w7xmPAbWPMgUh0GRpjMJmJ7ez7FZmTiTKYjtxNJDCCIRNLnzWmvsRI5aid1WBIB/q5qRlOJ/RGnw3fnwvu1tq/C1zs3P7zwF/0n/8i8E8l9/+SddffBw5E5MHn5eFRkNb4TcIcMqFMQUG483joKCkBsG5S0KqR7oFixy3StslqsaC1xfu1XZ6tZxphVYd/3mAxtsUEpo83Ad1hByImTLi6sikTJiiJDrCESu0MVnWf4EA9ds7o6BD/XQyYTAKDFl8odRUYIZ73jFoeEsOt1DII3YdQ73SBicEd9m0kWkAhtMu3EmnZbqlX6qTpWgNeuZssbLCUKTtiF0Dj+521OWR4vxtqQbjBe5NJG9GDNhLN3XbL1SljsM7Y+c2lkaW+Vl8fu5NW5z1RZeeBxbi+EjIJr0VSIElfTH1SqQUTLTNC/00tz47yFVC/vHKemGtM20jowb5ttACu9yj/0YNtXNq+vwaxGU+kMn/oc6JURGiNpaGh9YfMBNnFRQEoEhj/m83UYtHh0mJtgzsDwM9z+c6jmGLFuTlQwFbADytTY3vHntoRjftdlQ4psji5OLBO7ngT1ymJ210pgfzQQvGa65f/ANMsECC3Nb1mhaFFaKnJMf23KOXk1rT0+v363O9Za1/4zy+Be/7zI+BJ8txTf+8Fn3clfr5up/CAkKyR1skwvUJ/txbJDLaNa8/wbFDEun2RsR1zLPV3uluxs6S+YyQy2JCyOH903LpU/eKu0fWc1VCR1NIQNd9d/STUR2L9w2Du5Jo83x20YZjuyC+mq6wsDqCYbnwm+PvF1aVNEgrTY946aQM10mXrushjpz5BnDZEOtx+RYAMe7zvgK1z4Qp6JKHCf7pYyoYc/EDbYe0xPcL2tJ9WpmjsJYpey6mT31YPbo95pDv8ufrvWJrpIhQvx9AvwlMWjPEhjUmvNjH/jvTEW1wY7dw+zSYRoxtBYVdOcWUJ/co6ppkldVQSFBh/klekUVG2LQl42mQuTUONO9VOxn0iII0lEZK28e20u5d+3IYgKuhO/HlY5JVO4CbPJf3DWkv3GESfRxizsW93XbIqx50+lnwPu0KiCim2kWNglpweo7ZCinOy4YhMGkz5XcryDnbwgJ4MKYsca5obZUyv/94TqtZaK5+mjj7jEpFfwrlumB4/6jAr94AqVTdzr2AbBxSh4fT5tMeE5TYJusat0qPpKSGNHfYicR9GnfQKKenkkgfeEA2iJEPxTHffk6STCslfG5VK2Cu8TRJI6mbjF0nAqgtYfvhZHXgWbOvcDa2EhFJlqO92J9uS/S9FJ9joPJvSlTCIUb+1r3dMJAGW+Ky2Vaeqt7DmoLgswRrRNIzuqrejpDsdwuo/uj99cqmspCtzXVSWngKUyuumW8iGfER9y1bTvwkUN+psbffEoXCZpOk7HSEok3TwOWVHFxDBnYxEVFDhTFmvwLvtH/uWAqSelyoqM5WTL2/EOwVIVbCpmxTSQ95jHA2hkdO6JtPFIVPxZe/IMrRHlI8rRrKpdKfNuhZgUAw6DnaOIkzb2uyA/i6Ie/E4hZ8SSbrKXZ9zlqlbg2MstJtXDMwV0t/j+vR9jh72IB9gl8/YLr7D5NEv0vRn3H3wFbaXr/is6/cL7qci8sBa+8K7XTSXZ8CbyXNv+Hs3LmvtLwO/DHD33Z+xt5mv0TQDqys4BU+VYw9LxlXoDMrcdrWOtXq2o383NGgEmTTEro29cgdjJdkrwwbz0Jmc0QpwZmebnI9gwvvdzhfHbjy5zobAAR2yFuvNZJWQArr1g8O7Wqw3l5W4hvR3ACpMjArxcG7tnvquD9lDPReSWApR0Da5EV0uNpTVjT+hoy12ZH7r5eOIbVJ+lZvbbSKGNKpUPF2LvC8MZrWuUv+2orBPPpAxr1xwMhGtW2eyXUK9XNCJ+qpd9ImCzm6oqMqhq1g7NQhlTvtdrIvvnzfeJc5VWf0T7ZhEdIl+le5fGzbbcDJJflMd2mXzmm+QVlxHkKYT6f1OTSPAJ+olkC5RBWY1NbnxTowosoTwTV3p6ssWyJ74fmwToiBxDkDLZXbkop93o4+iAoLUHeyy25nnIcozCwJRS1qoyy2r9WMGoxlnT7/NnTtTbNHn8tXv0JMR9fxjZP+ArBUm+WfD9+8X3P8q8C8B/5b/+58n9/91EfnLwC8A14n75jMuP9gjuqKmroJDuvubNoYOGr1EQgt2hJiCtdkRsHYeN9Yi0DkCvcMu9Lf0honjxOIXQRkP3AJxP/PYCXXEiBg3qWPj8HUgFsHPuRwV2DVd75oQx5LVFRMsiqDshHQgtVZXq4ov+u6At3FvmNbl5XA4Ab7kfVefpKz6ryG0n660D+Q5tNtO2yRAe5Pp6uBIlbgEOQRLRXxMfNK+O460kE/YxyMgHHFQ+rTUwmInD00tSZZOTwmuB61TWoebde4Cp1pmSVslm9iZRDmmUTkpfEcw8s+16eStCXLmxvPoIAkhhqpMlIkn3RdisZJW0vEQ4S4qfP09vpi+E/os4sd7282AVM5eHn5cSDCTUgKWyBjtW0laHdbtx6fKUsfsLaSzA9aJQoIYwY5IdwN8COMkzBnoX4l4l43ucPXs18izJ2zOTjl//BtU5QXPP/49ZrO3ObDfZ9ac0HBBL+vdKFt6fS64i8j/A/jTwImIPAX+TRyo/xUR+VeBT4B/2j/+14D/MfADYA38K5+Xvs+l04gdnxYu1lXB94awvVJQkz0MfhNbWUmbIHESxEa/NaSE0P8uUdN2nE7pwKHb0Fj85stxqAV9FPbhhjaZ3Ow0cgDK3QGRHAat4Cg6sN3tzuk71lkQkbGJC7tL5LvrZ3RljVuJujFm/AGYsayOgadAnCg7X/QIQE6QwYIhiV7YkV83fHC3XCmgShBRaP5QMYseE+q6RRKD3alD0pxJmVLXjIRKOYUXF/mYTj3Ep995f9cPnpRpF63S9id1jyRhvylIBUWqoJ4yw262QUmpayDmHxWeJmtMMr6U7aZcylfgBoO/ccV2VRl6tRqAk/BbrHd4W4mBPufHv5O59hH/vFVZkFhLsU1TeYEP8MKvmzERaONwSyxAJX7cjju7std5ErfZl5dVOHPA5+XbsVEAyAQaXx/fkbPBhG3b0l58i7rqU8zPqMtPaIoayKnKZyxO3yenZDCd3NYA4fpccLfW/nOf8tOfueVZC/xrn5fmbZcKN0krDEg1rj/NvxXvCdZ4NpuAO4hz64TJi4hF2kgpA41502GeNnG5dMreaXhL2l/1NJbwazpQleMkkzv6jloRzuxWK0BZ7U0Gkg7Z0FkS9BFfiXSDMo2N1jq7xz0SKbao0tilUHpXtNYud12AEyKV6AKCArtil/omxUZgD4ipMul6r/wA1ROiunJg91745xa/t5Y9gFrScKn8gq8mjbqSzh4i7lbsp52FTYK3YjT23MOlvRm3H8ttkrJbYtRIfDcwxx326NyFO/5mXz71+UVdkeQZFIZWP65l0HbalV1XnhpAYP2uhkI47CU0TQwyMPHFqNxw0Sxuwl6VjI3lT6NnRCfuXX/Vlavx8O20ubwMbNz+O8C3Ty8c5K6iUrUkabt36xuqlipdoqWXmLuhL2RZRtM6H7tpXtPDUNkBVb0i60+Y3v8xXp/+Ld5440fYm014+vHHVHXJ0dERdWNZzxsW82umx39Uth9ImIj7erP33MYYtcE6mjR9VaLw0wMZArskdmrwa+e0g+PBCde0jffhfpqvVAIo7ZTdN3TwPxtfMP/oDYzwZWiSAdyViU36burjVCXk73eAL/7dVQxJMf09g7pkklST0sWOqnfaMBhuazsbBpdNgB0cCMU2uzmAXILJRLpXAOkeQZ1Hb7m/e+8G471NUIGvJm3QJXWddwL4BBnox9gfbGCMzu2XZVmcuPUySA+Hj9on3XXet3qyK2q330tguGE1ZKKUbhtXQSaBMXcw8YZsogLQSu6OAUn+91L0WsJ4ORjE7w0UzxLQ/HWNkzv0w4JuRIaQbpalC550sIr2+aRs4sd668XTmSeQeLZrVDgS0orzbUTrzLfCjvAUzX0eEsawdhZVevj5MmMM0jZsLj/AyCt6vRmXzx+zd//HyKVlOJ7SH56yXFiqUig3cPriYx48+grX1ZSHX/kJyqYE/sqt7QlfEHAXiT71T+t8en0+y0oUO8QBqZsE7Q58HXjpIEmAUS1Af85GbGBJfayRXQSmox2TiKb6hu5DAqrdCYVOvCB++88ujsTQqVg+t3YjMistw66SEZP42YXIqsI7OjhSpZc+oSsxEgVrWxfzbv3h4x3gdEATymO7A8NNbpsbwHvj8iLUQ8tv0583341gmFo8N0BOYokiUU/7WGIxxnFO2tECBofumILdp3xONqS7SRCSL0F4CVjuvPMpNDohQ4T3bfhXH4t9VFl1TLvr876ZZVou25WjL7v7I50ndwMC4sZkDvwzjWXXFtFzjYlWt+YkJCQvDHy3ctYQY/AlKXMgWRL7o4iOJU8yJV1D4X0HiYLXdgg0y7+vuGQ01l2VgoHALrVMYuj3+jz57n/NbDQmW68pzZzp5CGLecHJ3gy4pioMg/49FvM5ef4R+wdvUFVrzi+ub7Z7cn0hwL17JWZMcmcX+HfD+ELs9GewucwDcgQT16m70QQpuEek1U2yUv+mJO8oM4iZ+q5nLTohZq3bbyZsH6ttvbPzZHQ7JJNSSV260opzBCm4CHT2Fw9sP5WhV0odKioeCEOWGpopsXMGkNyJGkjyV6YivqK7IPfDWGhaZrePiA29IrjpdmQd31eRyU56EeDir4SGkB2l5mLDFfi69kvn/bRet9bjNsXj2bcl1kdlqWUK3TL6cbsZJnlGjY76zaOMbVcewc5zp/0arFfMXeBMKxgBVNPKwt1IXLsTu8qS48R9VC3aF8O5DTaWLN3uPrhHJElQvOvFp6ZWeKRMMSLN+v5iifMmNxHCXUHpqBUVxpRXKl3N4sphtX6JFmkjZqVtonsxqTVhpGUwvkO77XMx/4R+bemTcf/4XbLBEWU7oipX3L3/FTZPLjh9/V2KzSXTYY/L1x+zXFWfUhN3fWHAXYWa+rvDB2tvxJfqdXus9i3p7ww01brK7zQmtfW+PgUoHWwiesxVuvVqGz4bSzhdJY6jxJwAUp/sZ7l2XGc3XYIqYG9RXOEllZ/KpSsltAsq6zSiJ8d0Yg1CjrGOgZJ0Uo5+dDfgNMTUycyvUATS5kzdarBrrWnuqbtH50NI5Ka/ENpQFXCMiormeSsxbwVBl057s68k5dPIitvlmb6SuHyk64ffBTtNO7UE3LqA8Kurh2fRnRnSBCTi/IiCnvVjx9feb9iV5mnCfYnjzMFMGANO4ShhUHIhySLtZALd7vQT7Qfi00o6rvawkMcNHeX3dde9dnzeoHupE9pN8VWVe6qgdX6rsRD2UI0d2cnHdGhBt/1IlKuWLAC89gmd87pFcatM9ZQl7YRW/0QcQNz81GJtyfd/gma9T7v8iIvHT7h/8jGP7p1QMeHF5YpJb0VRnnPvaI/18oyz0w8pq4LZ9IjPur444J6yDhsHxS7bTJ+/fRY7fAr3UvM3nVCMHkw/VDoNu1MuLU8yUXUjXh4bOt+nmeg2funcV79k8I76ymvultsVVzrYd8sc+6wvfbiRLA/xDKXDpv3gdmPUG8g2suPdyTWHF7qwK2U8mrV0gDMtt4gO7qhUw+NqKXT844kuQxVMIkdx4GCsG2BGA/2DSANS3CrL7hUV36c9k7JQbvn8aXl0rZekOAEXbeAG4umg558xHYnv2jYILSiFdCyknDW1UMAp8Mhx9b4HT+t9+AlgG4lyjIELCrxWY1uSnTeVIKkMVHY2NEWWmWgdQ8jLav6iLeH3JbJt2FM9JQ3WQl0YmiqghyuNjRmrO9B/CZnplsAicRdZlQV+73U35g1ZDv2x7cbCSxg5Lj2VfdJnUrJosUxPvsLk8D7N/Bm/9yv/IcuLj3n10a/QMGT8xi/Q23vE4vx3efPRMaNeyScfXVFt1kyne2R2N9aye31hwF1tGfEtq02jEzAhliM5Hs5I3Lc7+octuwxXNWhox91R52wo18RpdEhIz70X/do6iEIv9V04Ma8TAO24gTqDloiEHshVAWh6/oCyDrin2+DeKEuneuloaqLSUMASQaMNnHmbKBM9vd4/3+6muaMGdbJQY6qjL9Pl4USsbeUmbMOWP7aNA8EnbRHCIqQoZs8kO5BBiDZSoVoFvpvgr70pCENuTI91ZGu5+bvWftcNo+922fyOrBJA2mX17v0o0aBcw8SoCkFIJ287TDKAYNQYqXvPga9rE+fq0vMN3ElDjSqNsD2u9WccaFpgZSf+XCKwi1es3qFG6g7p7hOjadkg4wCkyZXuUR+sFR1vQuIXd9/PHvf46//OjM31Z22bdZvkb965DS60OXtDyy/+L9a8/bM1OsbDmPf7SWVhbMbJb6OHioi2i2DzITLo8bWf+wWe99Z8+Pg3OJrOWPc+oT99i7x5g/3ZhvXyJUf3TigWK6w1jCfjz6jjFwjcdeA55emPjk3ZH0DYq8NHAGiniXQ4pJEMaffZRjhAfKy5duQAgmlzRp4a8Uy8n1QX9xCOFA7eNIkdNT3M4gabDiVU8NoBAG/atUnXSidh426B0kmTTp56yyZjXRWO+00B1pnuBGC66T/WzmhVFwYrC9E9LmzYflnTtzeiP7Se7kg1xLq981W+/m+cOO76ohPV25WJDn0P2jYBhfBswtLSqMbA0FLgtTYouN3rdqVBd97kNssgyKALHLdZDJpGoAmSynWnbyPRzQzEifIE5EMnMQgtubX0WCH1GtusqTbnyPQdGNzxKkDCWOysWxBByILcXQ4VhpYMS2YbLDmNCCJ9D3bpEJLQf8CHh7aguyu2NB4Ulf/7WkmqZqPbKro6XF97+X6Pi8cZk6OW0ew226kr49/PVW6E65eGx7/d4+2frVHXoOgWgRI3QvbrurXyaFtFxeaPGDE5bU84uveQnnyFzeWSs5ff5/5Xj5k9+El+57f+Kg/uD+gNBtBs2W4rXr5+/pnl/AKBu2NzDpw9K0nASPyAbZWl6EDyn8OETpiRtmikQ5fpeiDL3ABug7Al6ICUqyWLA+OSZUgGcVQFhq4R32HXHTaI9ld/x9BKEwi4buKUDkojWfQ/h+Ld7KBh0sfqAg31nqaRMQreyYQnkVmTAHtQDL6u+OX+3W1QFEJvGTASBWhCW/hSqFumswArWl7pYcI6+evaM5ZfpSCSgU32pbxlfsL5+L0iFkIfiXJLQTDK5dOujiLcAfbPjQDy6d+6de8OA1BG2ybGQFCCEHpdUHwSCYqb+GwwxtKrz8mqBcNsSzG/QKrXFKsXtPUlV6cfMXnrn2L01p+lzgaBwRsMbVj64POxkFlBqDFUtJcfIte/x929IzbFOdvxV1k3I8YnX6OWHmDdfJXfvjoSMN2G2iLkYbyCz5c2rpjW7QK9LFJrTr+YMBMr/Pw/teWn/tyWji70wkvHr92Raerqi+3o+ov2x49/M+f//b+fdtrWGVPSCWxIN8gzSVoE5WnJbEtulzQZXF62tOcXbJYrsuGIg2FL3lxw7+Gf4NXrr7JafsThoMdwmGGymuFkcFuvCtcXA9zFmXrKwTQQym0ypFv44hsmshZr2xhd1GH+Cro2AEHHN+07rm821zfCOZzdwRZMeGVOsPNEYuGnY9LauO90gu2CD3dMWGQbYDaFq0Q8YV/v1CqxfvLyU6KI/FPppk2BfJH4IVVWHr3bUCxlzjs1Db9pJmn+iR/ds0zpdGpVXkkJd2XuAU9DPLUNYpu2bnk8eF+xY6IKcLtsWnNKP3c86bvgqoptB+hDPcTLb8dvfdsE26cB/GeteNz9LUwIs3N1yMJNWWr7Ox1mGJWn9K9+lXb+e7R2weXrc5q6YruZY9uSxbxicPQJvfI5jN9E13Ma33HEuu+tNPTbC8blK7aLC9ryjHF1zvOP/i7D/ft89MljZm/9PPn0IXL4FvQGYKE1qoa6jWL1SDvpIVT02h6t1FhpvUsyArqCuw1RM5b0DFa3ba7/nFl2V+d3LaxdgaalS8jDDpkDyPLY5vHULEjYWuhDWnKjdZBozRqTYaSlWT7Frj/hcCB885MPsMUVpm8YjIY0zQc8zf8OB3sDssmP8PrJbzCwJYdHY/LeZ1sfXwxwx3kC1Y/YWj0YNg5vEb83Sgdw/IAOcyM2DPHWz2xLFjVxR+Nb62fOCdEAomBEml68oncwLTmxIwg3fm9v3LPkosDr/jYpY9bB3ZlL6I5wj6k3gCUFdh3dNmWRCdCG8aJ/bFcJqdms/m31Z8doyC74x0nrRDY+4fR8TGVOoTw+70+9BBTmLd7A9VFKTnHZGKGU5tsh4FEGITwvUdQd97hWj939jGzYVTR1D0Q2eRO00/bZvZ8+e5sS6LiJVFa3zCWJFe9bizt5agVEDNJaMqmQ+Te4ePw3uHz1hKausRaGozEGYbls2S5bthc/4OWHv8rhT/zPwfRdnDgNPVuA9Gnp0dqW8vzbZC/+C0Z5w8XZa2zeo7x+xXnZY3VdML74BGtGGNMi0qBnBRjbuk3oQgO5TpjRYtqCQfuKfjtklc8ozADBnWOcWqOhjiK3bssbO7V0no0y67a0dDpktw2wNiym0uy7K8y7n7VPtYlCcGfaxIEWNwJ05LW1A4qtoXzxCYurjxHZ8vDtrzFfXjNfXpBXa/aW15jBlCa3HBzt8+LDV9jWMh7/UWDuqGAsOnEUB52CvN/NUQeXZ1FWoGk10kIHrg5KE9h63AYg4d6iylZZbGoXQEjQdwjj2ZFeIY7VlylVIykwdHcoja4DvR2iD0QQ6xHEJNHB1rrNxNSCQHxsvJ+bSFNPJpy7nTFhmqnrSsuk8ieCze3RQ7pfdVR0neiD8H4EdGVe6hLRKyxK6gxcBTdlP16l+t8zib+HvBWovRLZtX5s0m6S3FOxpKb1LoDEihOtDg+cqax2ozZuTKwG+e1KlGTvF7nxbOI5inUIlffl8us8gwoUifvZ0CK24tXz3yKbn7NaCmUNw17OeNxns9mwnte0rbBaLJge1ggVkGOAvFlTP/tbTAZj2uFd2P8KTb9ls/iIkpL12vD0fEHeaxhO57z51oTl+orJ6B49K9T+oOncLjDLZ/QmJxQMafIJWGcfZM2cfPEJyyd/m/3+kOmjP0Fv9B5Vb0Klh6CETqHuWENyAk1os8CDrD84J2l/Ybet3HyPdo/QJ4hMW3Def7EWaww27PSpIB0ztWnb4/pqZ+ZKdGWBTkALrWmwwyMuVgM++t4TDib3qbOcqsl4772fx5iK999/n3y4z9HRIVcXZ6zXFdtVw7D/h7yf+x/E5YSU8C8VvPVgL4Gao7genL7azu4BujsK6l2b4nl0F0AEjwBANqzTCOZ5+BN9nO6epNkEV0uATJG0BK7sWG9WWn/knXYUCcpmd88XF25mk2X7sZN22Kd0y2STpe27LmhJR4KN74fqhOe9MhJC/LXzWUtHlqkPs8uOJOTv3Gw7zIdEASVlCIAuEfvDEBKtU5z4dZZXB31DHjcANmmfsL43VMZ20o3PpUZ7cj/U7XY/+6etz/hUP/zNBxXTdqyirtUUc/ELZKx1FqGxWNtjePgui+ffZDqb8erVlrUV6os1ZVGxaTP2JmMWyxWyuORucYUZZwzLVxhqHv/g79Ps5Zi8ZfTu/5R6ec7V5YLalownx8yO91gurmnaFYOJxUqf8xe/jt0/YO+tP0OjW9V++P9ltH/Aqhyx99U/TdM7oV9fUy4+4vX7/w3l2bcpchhdPSGbvM3onV+k2f8qseWjGw7vku1YQan8TUvP1lRmhKEhdd3FHoAjQwriAn4Wzh1KL269htBAuUFkSCsDROK4Sg/k0fnAdMJdOszFkNlIQrBuLq0/fsD9r/0ipZzw1bcekBUf8+1v/BdcX36MbWtePvkQzJBPvl9wcjKlrQ3zxYajg73P7DpfCHAHG04ocaBqE7eJSXp2CpUKcMne0+wOyBhpoL47sdoZ3Hu6QWwLnVhYLVcKsgr2IfySONB9puFje8tADxaEphuA2IO3/+gAL4n51aRTwHKFQiActLsbXXTblg7dyKAkLb/fje5JLigLIZRVozeSCnd9jqGsXUALmzt5xqITm7pmIAVbbX9l/BKssK5vPzwfgFgVeFfuKYuGFOgllCdE0Xil1HGJdN5L4T0qfVUMt+Wn5YiySBTzzju3Xl5pWYnyS2OlndJPZidsqAZGhLxekAMyvsOH1yuGWcbh8ds0DFhefp/K9uhPpxTlOXtHOXuDK5ZPf507D99m9ewbDGdvcjAbc3r620i9ZN+ccDgZoidutfWaXFqkbnn17JLltGAynTIYP6a3/T7LV4+YHr7J9uU3GM4/4PR0Q9X0yUzF6OBNuP417Kakv92yLApW65Z7/WfI4jnMHmIO3gmHRgdiBJ0Jzs6kpipV2yLVa7LhQ/+8RlxFT0CIQsL3RT+GUutR3cDrxRmj2Qyyu7Ettbdpv7mt34UGAd3nJ1XKFkH6hunJQ75+cMTph3+Pp9/8r1m8+gG2LZnuTRCpWK8KmgbO2pa878ZJUZe39xl/fUHAneBO0OnUVtoA8mH+xAtQG4TQYPixav0gM+HAi+CvA8eWibHyIj6GRAR8FIfrBBJwIhJYuXUgxqRjOfVSZaBqSZK0FCzCv9qxAnO1QS7Y2Kk1PWwEf52lDxQvzTd0/GQSENxeO7c4m4Vkpa61nih7cPfnPFobffGEbHfBeJedpgPRgb1I5v/CrtqIA9e92ym/Kkitl09fXRidXHdA8yaIptFXJOC4o8ZugLXzmQbl7//ZBfbd67N88t05E0EtOTFdkFAfsHilFyJKHB/yMjFkTYG5+k36zSXl5QfYckUhPbLsknsPf4bL84+oTc7J0VuMJMO212zPvs/q/DmD9ZvkeUl2vYLmikHegunTqz5gddFSlGsm4yGjQY/lfMnx4QFPFuc8f3HFZFpx/807rE8/ZmS+R9tcsH71K1TFisW2pTcSenbF5vVvUr/8Tbat5eDoR2naGdtVn54puVyu2Vyec9c2NNLHWOsPim+wVrc+SImThcRlYpoFpjjDDA6o6SOS0Yrj72FTMpWZbTBqvRpD3GgyKoOBKTHlc7L+hMxOQ56p0t09xAW0PzrFZGxsM9dOBktD0xSU199j0tuQFb/O6vq3uHMyompy8jzn7bcf8PHHLygLS78nDAYjSqnZFJtP7WfwhQF3CSfKiGcf+GXvu6avgAfi6GN3j4chHhSAskAJg4SgaoMbxiO4DaAjIYQpPB7YnnULOHRJvk0nfaNZZpVN3XAHSARlDx6xUykzISgcSZ5TYqmdqElNwIQB8hnAQgCT5HuiDNRC0kPCxeZk/je7y9DDu90QQL2sR7sbQGejFRWlYn39onxiejZMPO/YGqiSCM8GFnZTudyucGJ6wXxWIiG4+Y/OM44cdMRA8rymtJNHXHIV+3FargBIQbHfLKNbP+Dll1h52md1zklEwwihLwvmp7/G+fMnHBzfYzruU1cVvXxJXX3C/Yd3KOyMPG8Z9AzPPr5gmA/p9VdcPl8ynfUo7TM2ZYNtDU1b8+r59xgNhmzLgqqpWKy30FpMr+b4/iHV6QVlUdFWWxbnH7IuSh6++bNQl1wvX1PUQ+7dPWTWvmJVzfn4asWmFGazBbZZkfdL5utritowbn+Amb/PZPo2q82cweQRlQiN8ecoWwK4Bs3n22Zx+TFXL3+Xg/KKrH+Mmb1Dm41pRYIc3dXSFBdIW9Af7IGMaBgEYubWfhjKzYp6eUnPDpHmHWDsiJfHLN2y2vpzlbVVWjHOP2AtQk2OBanJbEUmPRpraTbPef6d/5TjYUN1/SGjnuHw6JgffPARj+6+gYwb9qYrNnlBL8/ZrAqqqqaq/qjsLRNYsTIXOqyoE+gWGLb7osxPqY4Cuw5Y581vAisTbx5ZPyq1IQPOBUaUjPRQTp228s/sMGXwflZ7E4pCGrFSHYZ4Y+ITNd1SObnX0lOU4kZkN0Gh4wfuFCKCuTtbVPPxIZceKS34IKYkHd9W6vbpWjPtDfYaP+6AnsR0d9m2msPaRoFZ+56Q7isYU5fdLDpp3nYvKsVQoGjxCGHdnCRpxL2+VV4+W+OZs92pX6KdtW6QWjsqz9hfQ5q+s6Q+9mjdRatQG8sfoIVIiy1fsr78PutlwXjvAatNj35mWS8vadsNqzLn3ls/ynZ7xmp5xvx6g52MKbYlTdmwXjaMRj32D09YXJfUNZRFTTvcsL+/z3KxpK4sg2Gfy+srigLqpgGb8+r0kuGoR7taYKuCYnXF8nLF9GDAdr3io1ffxPaFy/mctu1zfv4CsDRtxvXlBYeHRxTn3+Xq/b9GPTukzieMH/0ZmtEdWr9q24neMXCjaO9lU2wr2mLJ1bNv0esPOMg2mP332FQ5pj+FtqGtrukPR5RSUV18DxmP6fWH5NOfpGbgpWrJsBiZY9qGxenv0RQT4Bix4qedLXH306g8XKRc61f7Cs32CrN5n76sacpXrIsRZjRhIGMOBnd5/oO/SyZLNgv43YsXbAthszrj4vQMEPaPTmjqks16SdNYmuaPwIQqxIFm2iQWHV3EjAffCO6fFq3g/Ljqh1UfmgWT+XHWJpMgsTOkLLAT6WLxikAXF2vIplI1Zepx0PqUHSuH5OBj93zMKXaI9D1VFAFAwy9Wk0D3clEdcdsVQVfz7CocUZMmYZOOAXZ99VqWXQBO/8YfiOkl4B2NCokhY6rIOumkyrqrUBTAdKGIRkBJSF9uAGbUol1J6e+x/3TLHtLK5KYsUm5t1cTXdCJLDwQlPTjDCyKFZfCT5i7zyODTfFMllLai7umjzwhk7ZKBXdBuXlAuz2kb+OSjbzEYjpGm5uL8mr26pihbzp99m8HY0vdFW69r8sxSbjcY03LvwT5XVxeUZYWRAdvtluGwx3AwZr3Y0iJkWcZkbwJZTVU1rDaVI1lUmN6QcrMgMy2TyYy22nJ+eU612tCSUaxzWlpevnhFv99jMN5jujehpaReNqwXv0WxPyLrzVitau7+7D9LK8Mwwe/WiCcY4AVksjGL1UtYPuVkb8biScHJYI/XL19y9OYfA5tz/fIbHL71LsiEYvMKaTa8vr7m5OtvQP+uax9poV5TrD+h3+a0q9dk5TvAj2FoMHYLphe2OtOQgzaQHJDWu3b6A9af/Bpt+ZjMbllflchgzEIOmR58je+vM954+C5vj3+CDz9+zvnZJyyra/rZmLJqqesebQNtm1FVRQdvbru+GOAe+rgNPqo4uUZg4mrS4z9jY0SF3sJPlFqJ4Y0a/eJ87d3YZUiZZRJzIHHgdf5PVjQ6l0h0m7gquIVX4uzjyLISa8AiYcMlq6stb3Eb3GC/qRvFC0bUelAZJeJMq5CWkQDUGi8n3ecDJ0yz+rSO5AZYACJxS9OdArJReQTm6srqFin5zwGhY70V9m/oDv98Oqkey65g6AE2Ut9b/qaTmTHfbrv7/EJf9BOWepi6F52YuKAsbJ2r9bKeECgxMJawvYbCkt0ta2IR3ir77qZ1figgFnKpGRUfULz4e4wHWzIaLq+umU4PMabF5FMwOeSGvGk5nPRZlwtWRcvx8RGt3cNQsl2V2MZQVi19DPv7+yzma/r9HvP5gqbZsF4VjIZTXry4ZDwd0NQt28Ky2pY01tAfDGibBtjQ70FbwnK5ocxrDDlt28dkA+pyyaA/8mHNGdtiy2jYp60zqrahma89U/qQg+0SxnsYcSSuFSVwrrHU7T2aHrNZt2xfPWXzesvxvS137v841cVHlHv7jA5+jLIRzs5P2d97h0G7YvvqAw7GBwzbiq13p2BbNucfUV98n/F4n3p+it08BcDUl7TXH8LgETK+54iReh/0UBYrbr96m0E2oMnucvbs22TFik1ZsNy8guwZX/25d3jrvT/OcLLPZPQ2P/NezntnL/ntX/2Pqa4e088Mj954h08++YjGOoVal/89mbuIvAn8JeCe70e/bK39t0XkCPiPgXeAj4F/2lp7Ka4n/tu4s1TXwL9srf3Nz8sHvCYWkl3rtNHwLNV247H1HegM9kjCXKsbxLO9yF/TONYYB31LqJ6yfAUAGyOKHfjcDJtTBRK3+LDhOFItt7I1Pai5O35jhoFhxgLFZ0R8+J9NX+4qC193VQKdsqrloMo07N3jZWJDsPRO2eKfUKSAdl0/NYmcwz3flgrsOnFrw37aXieECYmYhvhJczcvENsvsndIC5zKIshDa+3bNo1NTqu2O3Gu/UgVaVfqxLbxitjN86jrSuIzXv9YXxddcRvWPyRsPXXPBYsCS7rXiojfJFfA1Guun/06m09+lWI6YjgYUhavWLNkf3/AenWFtTlVJWyWBavlhtpWbJaWqm04vnPAdvuaoljTywYUmwqxhqZZ0rQFw1Gfq8uKonCrv09PL8iyHpmxjEZDqurKE6k+q8WayWzKoCesFiuaWijKmoEYqrrGmozecI/15goxQ4ptiZUai1BWLZv1lr2DY4bjmtIc8uzVNV8pVmRTQ9aU9OyWFksrA1ozcO4sL+bx7IjZ7C2efvNvsNeHxfzbbKXH+OBditU1g4OGu2/8FGcf/XVmzRW9rODV+pq+GTHMBbErcpPR2hW99gWsr4AV/WzJ+esfAHB++l2Wr/8BsvfH2J/coRXjtWyLYMgEH+njDvArqpLp3Z+hlXt8/MH7IK95/OT3sMDgwjKZvc3+m29jR2/QmxyRbZfM9rf8+v/v3+eTj5/zu9/5JnfvnDDc9Cg3NTdP4O5ePwxzr4H/jbX2N0VkD/iGiPx14F8G/qa19t8Skb8A/AXgfwv8k8B7/v9fAP49//ezL4mGaifiIXx2HxSkbfKO+6ggGIedshvbih9cBiOti11NSHCq/25lqN50EAk6wMGJdQATzjxNzWg9+Smpg3vVM7YwGdkt/y7g6BxCF3T9O+lkKInM6AJEqp1u+MNJFEG6GVkbVWWi25IMFExd5XSHTjHQtp6xmnS3nahSuuxbGb3KUwUW94d3rq+YlytjVF67sNxx0an8NISOrqoJ4aI7aURunVTZ94Gwk6EkdELZuo2qKJwTqwQhFiMQFkTCHE2aX7cfSjDxtc4OQHw7YDCtk4mxFdXqlKZtOL+8JOtZ7j88pN/Laeqavdwy6A84v9yw3bZcXqwhq9is3ErSy/NT9vd1U7eG0WhIr5eTmYa2sWyLDUhO2+Y0TUO/N2BbVKwvNsz2Z+S9PqMx5FmPtikZjISL8zOqbcl0ckCW9+j3hU1V0jYFVSsc7k9p6obNZkvTGsq6ZDCYYrIpxyf3ePbsu6xpyXvHXF285P7Ru0h5xfLJrzIwDRz+JOb4PWcb6ZAwOW3vkE1haJYb3v7KXc6ev+Rudshw74ymWZFlI9qy5Zu/8l9yfDKiLgQzHLNZPqVtPmQ26LFcnjHLrhiMcp4+ex+b1Zy+PAZgdX1Js77g5E5DJhW1yTBWEMnwU75kCGIzGloG0vDq+e/w4Ks/wf5Xfpxc4CfXl5T1GBkf0JYt3/7ub/Hw7T1OejkU32fQu+bHf+rrjCZTXrx4QVleMx0NeL2ck/c/a+fLH+6A7BfAC/95ISLfAR4Bfx740/6xvwj8bRy4/3ngL1mHGH9fRA5E5IFP59YrMjI/ELpDyq2/E+3kHlg9aLmB5AaG97b7ZyKLjwqidWFQxJtWBNlhdjoxk7o50ohsiw3RI2HhaDoYU2B1ggvsOAXZ6D7oPu9CEVvsDijv+mBF70vcBjhlqbeZ9rvPdMrZuel87x1FhAOpENnkq5OGBAaFpVUPzD+yZWWuQd4EROzAaWCtWIxkoV2jz9tPjPvv8UQrcBO7nQrh7tpg6OzKMnnMhZf6MqeT1xrB1Slnchi7uSHKeDA2hI2X6daUbt9I3xZHTExKBFymIM4abDVfC9TXlJvXXC4u6fcPqcnpDUtyY1kuNkwmA3r9lsODMbmBpmlpaiHLB2S5MJ20HB/uMb/sUTcNq82CYZMxHuXsTUbM5+fUtaWqKgShqBqGownNxrJaFmR5znjUZ7OpEYGm3VKVrTsHNG8xCHdPTpj3FpxfLFhv11S9PtPxmNzkiDQMhn1amzMa73F+cUF/cMR81TA9mDEcj8jqS5rVYxan32WTTTg6/uO+aQoEv6GM6fHO1/8Jnn/vb/H8O3+fs/NL6OUsRu+zvzdl3/5j1GbE5OSnaaoptjrn9Onf4ife+GkuX/4Ob917yOUn/4CqOGPy5nsshobJ7IDTVx9jcFEqbbVie/WE5vibMDxgOHmXq8UTpvtv08oE3f7YeWgsFK9pFs+4+PiK/nRK217R2AF7d/4k2eQt2nGPn/uFX6QvLbL6Lq+e/kc0mysePLrLaPg2o7FwcXZJuWkYTwbkec4LLnc7XLj+O/ncReQd4OeAXwPuJYD9Eue2AQf8T5LXnvp7HXAXkV8CfglgdueNZM+dXWNXAdyPH+vAWXfsNcpk1Y+sDCrwJ/9d/b+e/gcfqc8VIj7dMLdJBpyn7yGcT3ewtGDVUvBg7sqpdE9f9erItrsph3fD/cBSEyDxoNNxJSWHuwaVYXeVxs3JuV1Q311Uo75hbQMF7hCDTpRDmwgwtUZ00ldvRvcSXV9pwro7cg+WRnQHScwgSTCtX7TKQn3VmutYSyq3OIEdmyPtd10LLMjZJmn4dwLxcALtMPEwSY/r5+6otbhIK1is0S/k/hib7Eat/dgVxPi+7lwyS2TzmB4FQsN6vqQ/nNA0lnwyoNi2tE1FVbccHh5gbcbV5ZZt0YKUHIwniNlwflnTijCZTmibiv6gh8ncXIHBMh2PGE2GLJZrFss5eQ62dns/lUXBoN+nLAv6A2dd9Ho9ltdrhDX9Ycvjx88YDQYcH+7z7PSM2sJyU9DPM/SEx22xxZolx6MJdVtx9+4Rg4NjxqMT1pePGaxf0swvaWZH9PdnlNtztusLDF8DhmArmuKCN955i9XlC6rtFe++84jVFi6vr+l/8neYHH6N0WDCwY/9JFJdcH3xe6yuf5daWsz+kvXFP2Aofex2yHZzijVrhqMe9+4dADDq1wzklNx+h155F+yK8yc/YLZ3lzYfIa2AqRGbYVrh+uoJmdnSLK/Zrs/YLl5zsP8m63LF9FFNPvpRqnZL39S8+OT/w6B5ielVrNcLpnt3uP/gmOvrS+anl0ymfbLezs5oO9cPDe4iMgX+U+B/Za2dp4PQWmtFdhy/n3NZa38Z+GWAB+/9rM2SMW13BriLcuqGiIWohAQL08Gx60PVla42DlU3qEUBNR3xnYImgBNHckbqsY5RK8riE6/8bs1T3CZE7SiIembbAbnE+xJcGmpdWND9eNzGe6azB7y6BFSxdFw+aeJ0mazWVgE9VTrxTE5VqLv75aRMV25IKgCtmKAAlQvrk97x0UXq3bZRWe1Mct+64tPL3OiCr0TWQQoJyIuIO3PXRkef3RFZOOUpgLxLW10DiVc8lC897FDph1OOUYEYuuUSZTQ4YHeWpvPviq+LsS1Z8RI7/5im3GBoKLfnzK/nzA732GwqkAxrM3o9oaq31HUBwHA0ZHYwxkhJ3ZRcnF1hG2dBjoc5dVPTtDWZ9NibTri+XpP3DP1+TttY5tcr8l6Psiqpq5rFfAsIe9MxRqCoGqqqYjRqGI37GHpU25bROGdvb8zV1Qab9bGtsD+e0kpOPxcyYzk/e8a9uzOK6iV7w3tM5TGvTr9JUy3YrK5o8wUDlvSaj7m+PGVzvQ/s0W5fU179Nq+evc/9Rz/O/NVj6mbM2z/y09RGyLIFZfGCfO9tbFNSLb/LOw8mrOefcH32nM1BQTFf8frimu3Wsiyu6I/2sLZP6Scyp9Mxbd1y9apiUPyA+eq3mU3exmxP6Y8Lqhps7yEtlh4NuUxYLGoGzRNMfsnQwPzVd3l19Zscv/4BX//p/xmfvPguw72W+fNvMR312K7nGMmY3qm4d2/C6vqE8+cv2GwKpOjzWdcPBe4i0sMB+39krf3P/O1TdbeIyAPglb//DHgzef0Nf+8zMiDYs52B2RlYATrTgmn5wqShYAmLi1obBl/ipPEs3vh1SG2IZ1eeGjbfSiYydyfXHLYpILl/De6g7JT6B864c19/1cGZXqrcDJKAqj/2TlRG/r0A8DFqJ06QKhuO/8cauPdvC7dLff+Cl4vulW0jCHlRExZ08SnKLMiwKwbxDdOVrbpdknsSFXOqeGywDGwnfDVOQu5IO/Sh+JwnzckCokSGvsxuJ8ourZakvuEn/Wvi+9GhF8sd3DxJlEywRiHcizsI6j/sWC7ue1utGDVL2svfRtbPKbbXDEYwGBxj2yOevnhMbipoWybjHmJa+r0eVa/HdDqiqFqElqosaBtoCmgaS5m1iC2Z7R+SZQ112dBUDXkOWQbzqyUiLVVV0LZQ143bgGxVgrWMhsJqWTEc9pnNJvQHOYv5mqIsaSpDUbXMDiYeLDM2m4Kr6xWj0YTJ8JAXZ2cMRkJbWY5mM66ffQfZPkY2WxaN63f16hnli19hO3/KdPQWm/kp8B7L199ncfEJm/UVq6pgdX2K2DF13TDcz5hfzRmMj8h6E0b9PuvrZxxNoK0LpBY++u5zlsuSqsgotrC8LukXwmbTZzmvAViuCpYbKGzJnT3hYDLj5ctvQP2M/sEx09k7ZHu/QGv2qJbfZn9aspg8YHv1CcWq4mpdcXF+zt54n3x9Sr/4Bv31S/JRzsHhAWIfcnHxbaivIH/NdHbAu1894PDgZ3j5YsG3vvV9Puv6YaJlBPj3ge9Ya/+PyU9/FfiXgH/L//3Pk/v/uoj8ZdxE6vVn+dt38uoMdJtMgunv0AUIKzb4UUWfUQBUhYFNRno07wPjDYDp3SXJQI7EMXk/jK2El0k6IZxGQvtVbh4Io9UQzfEYJ0F3QPt03Q86QRsn1iKhTaIofLkiaEeES5/X77qxVTrB22mDG+VIPnuwdTHHiRW1A/AKWGn5YloEX3katbI74azZWptGFIMYE87F7So0zcUkfm4IUSaqDP2xOOowCVAsqmhia6gij4acats4DxFLq7ZKUBMR/FPXm/8T+29X7rvbKbgHnHpoxckir69pr36Dy4//FtXqGpNbWsmhzTnev8Mnjz+mrGqG/Yy2rdw2v/MVdd2wWZc01m2R3csyVsuaXjaiqQqwGXmeMZ3OuJ6fU9cNRVWS9aCxNePxgMPDfR5/fMZ26xYwGTFh5eRyuaXXN4zGPdqmZrvZUjU1w+GYZbFhvd3S3+b0ejllUWNEaJqWvDdisVjTti0H+/u0dUFTCfW65Xp9yWDY4/zqlL29A77yMOfq6Tcp5IQ7b/wsB8dHTk7lEinWHM96bJcLjt/ss7fXY7F5Tr015G3J9dVzxqMxdSZslitkOoN2BNldLlfXrK5L3nvnXZbbmqvLiklTsK1zFmuXRV3B9dU1/aFlvH+fN9/5Y3zyg2/yycvvMdzLePjmT1Gap9z/kf8Rz77/X5EV5xgmvDp9jrE1VdmyWkKzWbE3HXL1+gXjnqVu5vTHLeVmzWA84fWL51QCi+WK0XDGZtvS70/4H/ypP84H3/obfNr1wzD3PwX8i8DviMhv+3v/Bg7U/4qI/KvAJ8A/7X/7a7gwyB/gQiH/lR8ij3CJxI25MOmw2nEN2GQ0BLNY/1rUjyvpoCIOUHWfBAKs4JMgq/VMVbc2sJ6WdRdTpeVKB6/7MfqVo1La3QJ4t/4J2nhl4erpBr7jdxG8o2LQk3KAWzb00oiNrgIN7yYgf+sEq156alIC8sHdExRfVx4B5uwOgmlbdeq+o1ysDRgaftf2Eq3rbWWXIEbxH1w7pG4rk9SBYKnofIlGpGT4IxMTV18qv3QyNM07WppKMpzCkPSxpONmvki2Iz9LdA0mo8G6ye6+rei1F7x+/muUq9dURUUlfS4vVhzODBfnz8gExuMpyBbbwmK1pW3c/vS9Pkgr5FmPzboE2wNpyTLHzvf39yiKkvWqwmQ5Vd0yHPYwmWG1WIKFkzsnPH16juDAWcRgTMPebEqe5/T6NQd39lnMlyAjysrS6/cZDHpUZUM/H7AuK8qiobYttb2mqjNO7hwzmWwwYlisK7Z2zHB2n35vzV57xaCXYeol2Jzz7T73D94m33MrS8vFFdl2TQ4Mhz1m+2MOD8a8+t1njE/uYGxOU2xobEVv0Gd+vYJ2wnQ24/j+WyyePGa1ueLJiwsWpeH0xYqjesp7P/WnOD11m4flWc52W1NVa149/5i7977CO1/5cZ5+sKZYndKsXlIWrxk8ekS2ueD5R7/B+dU1dw+O2awLhv0JZX/K9fUVV9dbvvf+R3zlvTd49uQFp6cXvPHmQ05OeogdYa0ly/tcnM/Z27tPr7fHpnp5ozem1w8TLfMrOz03vf7MLc9b4F/7vHTTS5DkNHJugktKtiUCi4ui0CPprDev3bFdtDaAeNiJERAxzlujYGltSDfNOw1LDo6RhPkmaiZYD6E+HtSDOyZ5NnLEGFVikd1Q9V265t/Y2b86DHjnB1cLJTiLJE1IAoA57FFtkxbwlggO25VBqEcCzGL9WbK39ZLEokm1bGSmMeonzTdaF13BxJDA7vMBSHWCwYfLqmKOUSwmRpYk5QgWA/5IuES7irU+4iE56k594F4jdEgIdMrYqYENt70cozUTrZtUltJN38Zmy2gw2ydsXv8aWXNJVdZs11vojbA25/T1NT0zYDQZszcZUGxhu20otgbb1gxHLQdHEy4v16xXG9arGqgZDjMme2PapuDs/Ap71jCb7XN9tcCIW9TUz3NWC5hfbpjOhDw39Pf22GwK1uuCXg8uLxfs74/ZP5zw+uyCthrS2Bohx2QDBqMR29WaclvQNoJIjrHi4+Nn7B/0MWxoasu22nDw4D0OT97l4vHfZ7tp6WcV88UprRmxNvfYVDWNmQEw35QsK6GxfU5fvmA5H3B9Pmc8mpFlOU0NV2cFRS+jLJZIP+e02nDv7UMevfEWd9/5Kf7er00Aw3snx7TyD1gsC6ZH79IbuY3DtmXFcmWpNtcM+sLq8htczbesNq84HA3JzZLjkx7N4lfYLn+A7ZXkuWUy7dNSUJYbhrOW6eEh2/WSbWVYLi+4PNvw/OmS0eCCva8ecXwyxbSWOstZLJZkecPdBxNeXXwGCeOLskIVZX9dM7z7ABEERNmbDkcb3olRF4QJsd30jIJ64rpIJ+PcC/43G72nmXSXDeiSfAXBNhjxEgi1MtoILjqYtcBxtWWMLomLjZTt2Q57U/eM1l9TTCc7JclPQSYyZ+vL74qaMGm1CiLq0U0tiSIJ8nJRG5+9pELiEnu6k9BBlrdYDLssPkpRrTKVkq9rQtzjvWTuxPrDEsIcj8ooffcWt4noWok2WBFuUVMiO+1rt1o+yh5StRTLpat1TacPutdCiG/Sr0DI2orF6w+oTr9FXl2z3a4pmoLRsI+1DW2bUzU1i8UFudnn4vySssiY7g0ZT6DXc3MVw2GPwWDEanWB86hYynLJbDbh6mJJ3dTY1mAyw/7+jLZZsl6tyfuGotwwGIwYDg1NldHL+1hb0uv1GAx6TPdGbDclbZ2DbWlby2K+8GSkoalq6qohyzLyXg6NpUeOsTXb9QWrdknb5pxfXrKsBlRFy3TvPoY+q+WHLBYVo8N3uP+1n2U42Aubvdn+PRa8w/jOkOX3f5dBv89weMDe/ghrLI3tUdTn9DPBZsJkukdlDeV2weMPf4OiHWGk5Kd/7k/xwbd/k73ZjP2DMd/8tb8LteO0eT5gMJgxP3tGU6zZXH3C4fSY/vExTblGpKYqK5brj5jslxRNn8lkyPnlK9pWGIxzfuyrb3P2+pIXz+b0etA0BYNRn/l8ydNnPbK+cDwdcHw0Y9m2jKYT2ramaRcsFpe39LN4fWHAHeiAa+fgYL0vBADsMGLvFjAdwiOdv7tMUGOTu6CehsnFPbL1aiPt7TBRwW0uJN5SoIMN1imZcCuCtvveBZLgKhLxpncsl5XU/eDjHxXwFTdDBEVakEShgLMAUvcFUTZ65qqKOXURKPgrNU0hzCYyvu3qRhyBh1gg2a6BVMl/djx+KHWSbmpRqeIwtk0r3nHv6OvpNsWfdrn62c4e4kFBpondUu/gWgK6Ukve3+nP2NjeGhmmNEWt10wGDCcP2DaG1XxFWdTs7fVo24bxoM9m1VLWW5q2ANNyfHTMctUyneXs7TXUTc18vkDo0TQtxhjq2tLUDVYqhuMRVQMmcwe41/WKfr9PVVh6wxFzs+TkZI/j4zFX5wWDfIKhZjsoODya0euVjEZCT3L27+8h0uf5qwuWy5J+b0RdtWy3Ftu2DHuGrGdobOWjaDKqekNRthTbEiGn3V5w+eqb5HfvcPrilEf3plwtNvzgySV/9he/Tl9g0K6BGe/8+M/zj//Zn+H82a/y/m/9Tfam+xSlIdtaSjPlrR//J9h/XXNnuuTls6e8ePGCvdkep88/ZDQasphXrOZLqvkRx/sDjg7eoc2nbH7vu1xfuCnEvD9kb/+Y67NzetkAsT1OX75mkA8oioLexoBpELOlqLbUzZbZ3iFFMWaxXDOY9Mn7OcvlkslkjIjl6uqSXj6ilwtPHr9iOISrXsV49lMslgXrbclmteSTjx9zfPhH4rAOd+2a5nE5fAqH3AAWfyt+9n9vG7DRx7kbkXEbQ4wDT+0DiYn7ASvhSecgisFubgtgDwd+gjcO5gjI6QrXFCSNX+2Z1i2WQQ8cILD1OL+gJUil0ZFCuN2J7Radi3D7uSdGQnzTay8F1jCRu/vcDtDdZOYS/neK5Gbkzqex9pvAH9E7jfIBdcf4NDshMe52OgG7W8bd7Rr8TW67blh+O3K46Wq0nX58M3RTggvNf/XEQZe9tjT1nGl/wWVT09TOrVEWFXW5Ie8NeOOtd7g+v0QOcuqywljDYJDR7+dYGuq65N69uzz55DVVJfR6I7JsTVND20JRlGS5YTLNOLkzwdoeZblm0B+yXLrwyLzXY7laUtUFq82SBre1QGu3DEc5QsXx0SHbzYLR2NDr1+wf9tiuK1brhu2mZrY/4P6DE06Oj/jo44+ZTsdkOTRW2BSGxXIBtsf+/oTJGDaL5+zvw3J1yeXlhsnhu+zvWZr6E6qVADP6ecF69YS2FpbXwov1a7JBn5OHb3LvvZ9n797P895PrvmdX/0PWV5uGQ1nmDZjOpwyHPYQyRgMc1588j1Ozy65c+8+j976Ou++M2GWH/O934bFYsHl/BXZAC7nK4YXexwcPcS2K5YXW/Jen7JZ0+sNWF6vEJu5XTVrGPRHGJNzfnnFal1w5+gu43HGeNLj6nrOu1+9x9X1ml4Pjk/u8p3vfMydO/eYDqaUiznT4Yy+jG7ti3p9ccBdQGN4LW6PFxfN4QdZ54i5ZDm6kld0oMbl8jfYun5PHB5xQEZA1AgQwgk4N9lVsCysN5kT6zzsqoj4yBn1/rsXOoCxa1loIpbAaBVAdUJydwL3tvDDzgrdWIMbANxRqNb6vWpiedoOPdfY8ER9BCLfLYOC/83FVFr+rsJOy/JpgCgR4RJZSadagt2JR0/kJ0m/6ShrBdrb879tpW9QGDcsgbTMXeYdS56U25jOIS3hsiDGb4IgSh7AnRvqYtzr+Qe8+uA/pd2+plhvyfKc7aZmcb3g/sOc1eI5eWYwYtk/3qNcl2y2JfPrBbNZj0wylsslg+GA7bYiy9x2DUhGU9fM52t6fcP9h0e4Sdacoqjp5zlX11fcuXtErw/YhqO7E06fF9D06Q8Ng6GQZUJVlWy3azbrhvVmTpbDozdO+PjD1/T6lsl0yHQ2ZG824OLyFbPZkKbdstk29AZ9xpOMvdkB0ma8+eYh/ZFwevqK68sFB3sjTo77ZHuQNT9geXbOdvEu8GP8vf/XPb71d/YR+9OcvfyJMHayXp+9w3tY6WHru8wv/yRihda63SWHwyFZ7ohTWVU0TYPJMjIjmCwnzzPKwvn1RyOhqk+5c38PW1vqtmCzPaOpFrRly+XrNevymvFoBE3GeDCkLEqqbcnl9YLJ5CFXFwvKsqVtDK9OX/PV997i+PiYonjJ1x68RdNWXJ/PWc7XrJdPKYoVR/t3OJwdcXX1R8QtE3icSOLLjewmjaIxoos+bLqRIxFp2jCww+HT+rMVjGSesYbI4s6gbFsfbicmbE3gOLlPJigTX14UfHe8zgng66Zo4aBu6zeTUuDxDxt9PpwW5dNKYuLSeG+9NDomdf/4h4M3JSQTECaVi/9guiRc47i9sROsg8487C3q5TaA3mXH1nbj07uCuw1QCZXp3NuxeNQ4U0VoPeCHANWkXXbUwg3XjyqQ3fqlKdxWN9K2EB/Frmdv6u5j+r/ofIV61lVBOWA3OpvhFZAVaOefMKjPOb9+TLG8oixLxLQMhxPaumW9KjBZQVk2fvOyitEYptMBz59vqMqK8WTAZlNwcHBE01zRHwyYL9aUjSXv5dimoala2hrKbcv8as5sOuPs9RVGMhppaOqCB/fuMBhvWK7XGDukPzzg7t0x5XZDsa7p9wfM5xskyxEGXJwv6PVy5+sf9qmrhrIsWW/XGIF7Dw7Z2x9hjPDy9JyTkymr1Yp8VFDWFaOxsFoKP/ZTb1FWwgePLS8++gbr5WOGgx8wPfg629Uh64VxW3k0P0Jd16HF1kvdVmOKyI+i24QbYyi2LtpHzzkNpM0Ito2ja7p/zte+/rscPzrk8vycR2/c487dA9abFdL2GMiQ+XXDvft3sTTYxiJi2ZsOsbbHpqh5/fKayWTE4qpgff2Mg8Mh5+drnj0/RSRjODI0DRjT8yt3G+7cvc9s74DNuuLF64tbe6VeXxxwV7ZrfOe2Fsl0FxgPjMlgUpAMfFh95kZo27j6MHAm22VI0bURAUHB1GRZBEMfnO584TaYyjZBXi0vAehJfnNpiISs/KksEQhadRP5AW2tKhxNobtvjAlsProOdHtjn0H3c+JPkvjR1yWuHlUBpUAWii34k2cIbo9d68CnGsE+KI0UeONcxqe6LLjtvZvPdO6ILn/Cyy5aZprfrkXn8kkm1UnVipe1b4fWdhyD4R0Q354E2VlIJlW1LdWd4vuN7VoRqfPH9bQkisimK3ghsy3XT38LU71Pvz+gzDLquqEqhCrfUlctfTHktqGfZTRty/x6zsnxFGzFdDLmer5kNBqQmx5V1fDTP/fHePedH+fjT15wcbbg6eMP+MH779PrD6iLlrZsWM1LJqMWpEfet8z2RyxXW+bLS2azMT/5M29ydbHl+nqBZAOmsx6DAQxHPXLJWC2X9CcTqo0w6GWMJ31evryi1xuAtDx8dIfBICPr1QxHQt3WfOVH7jCZ9sjkgLpuef7yJQcnY07uHjHfLihL4Sd+7h9nNuvx7ecfM9v/iD/3Lzyj37vH+uoxR3fucPl6y2/8yjeoiprjO3tMj48YTQ6oy4KiWHH+6iUnhxPu3j/g2ZMzEOHRGzMGgz7GGPrDPvmoYXG9Yjo6oK5q+qOGLDtlvtxysL/HaJxT1s491c8sdx/tMdprMb2W4WjEeGS4ujrHGKGuCnpZjpici4tLtltLJi1ZNuH77z9nsSioqobry4LDowmjoVCVLbPZAc+envFJ9ZqmtZTVf/9dIf/wLwERjf91oygcUpGOOM94IWVKkUGLKBuMgymwwg4jDRDggd+bv524+mRLASXbCrh+Uy10wFvdiliLGC0CcKfEpO6WBEfjOxDq0wUyDzU2DnSv67zsIpAqQHUdALaD6CHu3r+rbDYuyU9yTsqq1bE7imIH8pIyd8G1S85t1yrZuVJAvlGebjJBhmmupqNUXLlSrnx7Xr5coW5RkuLTbIMcknIFN5HOtrg+0hB7Ucg9bP+6U3Bc/9d7LpvEBlPSkLZ7f8jLlwuKhaUpch4+eMQnH71gfr0EoG1zcuMOpsl7GW3rome26xWr9QZjDE3VstlsmM0O+Bf++f8lRT3infcu2J/tsby+4Fu//S3+21/922w2p6xW19R1TlXlZNmApt1weLBP3WyY7k0wBgbDPkVRMBwdMN0bYkzLZHzMdrXh7a894ONPnnJ1uaAoMw4mU/oDw3ias9lsODs7p7ET+oXw9Z94l8urS8QKmclpKuH11Rn9Xs5w2Ge9mXPnzoCqyLharCjm36fK+0xHgqmFq8X3WW/fJ6MGzjm512f/+CV9M8ZyzeGs5v6jnPOLM0ajEdv1K/b2D5hMWmYHFzRtw49//QHvf+97HB4e0tIwGfdoymt6/QV1U1HXhkF/iG03tK2wXm/o9WZcnM15+40HjEY523JN3utxPd9w8WrFyck+o0GP69b50ifTMYdHU35v/oy2sZydnbE3m1DXQlFc0R9OERGWi5K2zbi8WPL69JrBoE9Z12T59Nbxo9cXAtxd12/DaUatJMAKgaUG3wBCiPkWNybaEAAS48cD+IrGgeugVZDy7pfkUA3Au2Ii+0vdFOBXI/pB5xa34GsQWaCbM0jRSJFSAINI41ZWGpOUKmWECVWUFJ7iRG6rC9YlMlDnHvI5JpEYwQpI3AX4nPWA5TQPG/Lt4lBq4ThZBc3naymd1ANAfgqQp9duFEuUW/eeupDCBLVEa8kQDz2/EdaqRfqUqw1a0obTnkQIBxsbE7cCjoVKQDkh66L5+jooGw/K2JKEhuIsV1XEnVwsgvFAZbAYGsk4eftPc9nb49U3/yqL+QWDQUN/lHE5rxj1RmTZCMRSFCUiOZaW87MFk9GAvWlGf9jjydNX2LbPZnPJ//WX/11a02e1KfymX33u3XnEez/y41ydzZB+y3pbMBxMyAxcXZ1SlxnbjdDrWaytWJmGXn/AYj5nT4bUjeX01Wt6vT75SPiJn3+Lp4/PWa9aLs4XXC1rfuwnv8J2s2G12IA0HB7MGA175CfHLOdb5udrqroi6xt64z7rzYZ+b0Sew/KqJGdAs16xbBccHkxoyy29eUPWGmb7B2zXa4bjkuGoT7necni0z/z6kixvOLlzzOHxjGdPMl6fnbLZrDk6OqK1Gx4/fsLiuqQpFxyfTNnOK473D7merxFgOV9QlSXFukRyYTTssV5tybMBi6sN0+ERmfT4+KMXVBUc7O9TbCt60sPIANtsuL684O6D+wyHsLzekGUTxpMBw1GP/YMxi+U1i7nlzskxddVSV0KxfcmduxOy3PLhh2efOZ6+EOAOcYJSXdJAIJ1qlu5CZWDQgDERCU3YgnWXCYufpEzN5pQdRgAIVoEyLz+GW+KBIRH0FSC1ZMnwD4xazQJdKWoQ03o2ZgJYK0vs1NMLJrJmi7o1xAOGAnQnVETaUJqgHI3fJFePB5QI6tH4lw6bx7eBJmw68epJ+QJ3JolM6bqMFMC6MlfrJNZrN4pFP0epeDeK0W/RrRJKLf4pSeRlbSLHyAAUeGMoaeyPcbOuJPpm95AUva9uFp2Y9pJVTWETRRRLGmWe2pchWdvQbl8yFINlQp0PaXsj9t/5E/zCnR/hO7/yf+fiya8APRqbcXmxYD4vmEyHgLBYuWPuZvtjqtpgbUPf5vR7I+bXNW1b8L3v/hbjUZ+i2NC0FXuzMecvvsX3v3uKwTDdH1JWLQ/uvUFv4Fjp1cKCGPrHU+bz17S25vh4xGg8pLWGs7M5bV1TNQWrdUWe5wxGGeO9Pl957wG/+ZvfZrNd8vbbD1gtrpjNZrw+O+P12SuaylJtDeW6YTKdcrl8SX8oGJPTtvD06Sl5tscHHz5hc++EvVmPbDDk2ZPXDHpjLs+XnF+uePjwkKIoyHPLO19/m+fPTmkay9Onz+kPc8Z7cP/RAe+885DVoqJuKh7cO+H09JKyNKxXCzbbJXfvOXfMcrlhMp0wHQ0wWUZpMgbDPr3eAGtbLi6u2GQlq3lBb9Rjs2w5unPMZJKxWq65uFowv9qyf3jAxdUZ52cXvP3OPerS0jQtq/WaLO9T1SVHx4e0tQlzHEVRI2JYLFa8/ZV73LsPH//OFZ92fXHAPd34SdmXAosHWauDkB02nwyGcPxY4kv1L7iUA1hEEOn4ZcPjMe/AjkNOqantoLO9jRLeSle11G4Cp03uKyPXxVFKk7s4KFiMP8ZOC5QyVG9tKHB7ESTeYA80MfZafe9p+WLxA0UPSjYCf7de6bYAHf4eXDNRkdokke5EqLZrMpmVKGcJ9U0AUPe1iZUh2WId3SR6d3sJtVAsURaI9r8kvimZrIltEfsKIpjw3YbfwbhJdolAnwg21EnL0v0evwkgq+dcPf11Dg8fUcmQwZ2fgdEdtoVlNJlyLT02m4yeGTKYjam2W1brkuFgyHpdYi1k/ZzVumS212Mx3zLdG7JYXEObsV5tKeuCYruhP+pRXZ4zm82wlCyXsC1L7t3f52rxkmxjqEpLsSk4Op4wv1wwPZjRtBWTyYi92Qihx5PHZwz6I+pqy4c/OEcwTKcZRbnFZAt+5mffI8uFsl5ydLzHZrPh/oP7lEXJutmw3TYsFyXbbcHXfvKrNLLl7OyCqrbcvfOAuspo7Qsu5ltqI5jlBhgwX5Sstg2D4ZDnzy45uT/m0Rsn3Lmzx+Mnn3B8csJ6DVW9QsyE1paYfEzVbHl4/xjEMhwM6fVaDvYPyPKK7bbk4rzm6nrJ8YnlYH/EYDCgNygZj3tkpmazrtmuWlrTMr++5uGbdzg8OkRM4/bu6Q3cHMVmg82FwXBEVZZMJgPm9cZZASLYVphfL0BgcbVhOd8y29un3x9Q1zXGjNluKopyzWddXxhwT+z6ZFAnP3kwC1sH0D344Aa2JjHN6TZe3GCBn1KOmHJYwq5padkCFw2gJ96ctztFSvNS4HbbIKTRPMqwY8SFr+uOnmmTSUlr3d43kqJTUo3O5KECvMiOuJJ7lmgpJQ+JdW6QXR/6boRJx3AIoBYjgjpx/lqrsKpWq+BPswe6ri0tq9YmAf0klCkYcYn6T5VFesWyxnc650epAiT2O7ChH4aeJSTqQCE57kejxoLgAwNilR1xMWp57YC7QGahqc9Zn36D+vq3Gc3eZbVdsf/VP8vWbrl4/bvUm5dsVrBeF7zz1Xd5+vH7FEXN3qzHncmUJ4/nXF9BZnpMpgPybIttLePRiLrJmC8W9CrB2oayrNkb96lLy8nJAS+KBXUp2BYm04ymrlit3cKi9WpDsR1QnhcMhsLF+SWb7QZjBhiT07TCelUyHIypKmE8OeDi6jV1XTGZTukP+nzywVOWV1uur1c8eNhjODJcXCw5e7llNpsxGLQs55ccHO1TF8KduwdM94cYdKtiYTjIuL5cs1pUYPrce3DAnbtTXj5/hWHAk8dPWS5L3nrrEdNpj0HvmHwA01lO3cyg7dHv9xiOhlxfzanqgs12waCf0+v36PX7LE+XXF2sGY/GHBwMqCrIjKGpatrc0u+NuTpbMRxk9Ic5L19c8vDRHeqqZGVbxoMRTbvg7sNDt5f9k1O264LF9YqL8yV1JWy3K/YP9plMRtRlRVW1tDbn4mJBU13QyzMePryPlYbZ/vhmh06uLxC4C+J94N1Igwh+jq1KMHFvxnXEyybv6RmdRg+tDQAYNUnq/kjBqU1YfhilyeANDDgcAJIe3UYwyduOFeE++qO8/W/+J8/+JIAHwWqISiCdOCX6a5Ny74g2+ZO4OVQDSYy8MUYckFs6u1jeGnO+8zlaCxJZfrCUorZLCC8BrFWc6cYvWuZEaUW2nICpTaJifFbuDAAJdQiwHAhDEj1jOvG0LvpFojJoPTLHNbV+DiexEhL95OvmmHt6hpfn8tGqUKtRTEIKdpm7BSqWqxf0ej3ml69o2pbl81P2D75K31h6+YzRZEZOQbFdcX11yXR/wur5OdOpYTbtIdLj4nzNdlNz9jqnnzeURUlrhe22Jst7kMP+bI/VekNVGp48Puf+gzvcfzDi2dNTVusV9x7co9gaVqamtZa2NVxdrDE57O0P2aw2rDdrJmNhNBphMdx/cIfxeMT5xWvm84LpdJ+HD45Yr+dMxmMePDimWDVcXy+YTCdASV1VrNYrNsWGf+znv8Z4Yjh/fc315ZrDo0NoDJLB3ZM9jo4PqcoNB9MJz55e8/rsimrQMOyPODmesl4VNI2w3VRMR5a6bFjPz7j78JByW/LGo7s8e3pO21hev76mrkuyTOgPDG1bgBWm0ykHR0MA3nz7Pm1Ts9k05PmAzbIi72W8PnXbNxSbJaPxiNWqZX//iPlqwWDQY2EKWrEcH0/JjWW73jC/XtEfjFguKpbLrVM8A6eAL6+WWAtl5RY+jftD3nzTnYnUtEKv90cE3MMEqbFJJ1f/tEQQTny/oB9t4v4MEOaR1qehJrPf5108qKUmelKYxFXwaaDmAcwSfdOiJycm7pCwcZWHZwWBWKWdInjXyo7vNoFjD/zepRCWzmt5/XMd9I9gkgJrOqfg3jZBnl1pxrpHQNV0TQdxO/mj9XF5B8unY010t5pQ5q7K0XbS6T4XSiMke9t4mXUsCBVCtBoE738n7qbZqDUgGoVlA6iHwqhVJuKVapRJKisnHm2X1FpJgwN8WbwF0D3vRpVVQyZuW9yz+YbVvKSsXmObaz755n/G7P5b/OTXf4H/5q9/TN4+Z7rX5+r8jOOTKcNhTrEt2EjNV94+4cH9HmUhPHt6zXrZUJQVYix1ZSlLdypUUVYY02ezKqkrWC23bDcN73zlPoNhQ1PXbruA0QCRAavtmqurLca0VFVFb5BTFBViK4zpYXLDcDBg/zBjvYXNpuDo6C5PH7+mqRsWVyXHRzOsrTg4PGSz2TAc9njr7Tex9orFYoWVjPlyTVnV1HXNy5cXFNWUyXhC2whtI4xHIx7cv8u2KMh7ezx8cJ+6LMjpcbBv+ImfeMhqsaUuC85WJULDm70H2Lbk5bPXGGvYbLZkJgdpmc32aGuLtEKWuaYbjXLGb+xTlxuGwyGnL66wbcPdu4dsVgWLeUldAq3FkLPerFksttSNYNuWtm7p9VrqbU0jhtneIZuVpS57FBtD2wgHh/uAcH21pqksuenRNluw/qSrumaYjXnx9BXbcteq7V5fCHBX4uY+x8nJMJ6AGI/t/m+TgdDxrXfSdU+36IBUdpkAqzI76w1yn8GNbXxTU5sY+hicHVpmSSYWfQXEs0wLiT/aWwQ3FJX+lt7Qk0LdZdKyW+IknZdQ54xYL4cWG10MiY9bQVJ91loqK3FbhESd7ZRVguxDTWT3mdgW6r6iW+ubaar44oQBpPd2CK66S1QxeD0b8pVQr27x0pOUNHvdXrkbYZO4k7KoYMNL4qyd1P3XqmUQJ0ZiOa0qNYOumlVZSnK0IeBcYbaH9N6AySMWLy+p5wvefeurSP2Ky6fn1LO3efedd3j/W8+pyhZoKIuKOyf7iKyxtmE4qKmbDeW2Zv9QaNuGvNf3q1NLLs7XiJ3Q1oaLy2vyrIeRnMvzJXuzMeNpSybCel0Clrot2aw2DIZTiqqkaiqGgz6HRxP6/ZymbmmqmsFwRNMWZPmI8XhItTE8++SM1WrF1dUVb759H9olF5fnvPHmI5brNUUxYLlasdqsaKXherlks7niq++9Q21rBsMeeS48ffqCzapiOm3IjGG1WXD/0Zi79/d48vEL+tkelxdrvvojbzLbK3lt51xcLGlqy+H+IWevFmBqNpsVk8mMzarg4f1HtLbAGMtoPGCQjbiez+n3R8ymLePJgOfPrinLLaPxiMV85dbFZEOsLCnLilwGCJaMjNW8oDWQZYZ+1qOXZZy/WjEaT6hKMKbPfLGlKCx3792jbQqWi4r1umZblJyfzenlI05Ojlkur3j58pwXL15TVmDlD+iYvT/sK1PXgndrpPHYTepT1mDjG64HD5lhUMaJvxRKROLydPVnu+cMjR9UIhBdDdBRPeIOrw55+oGaMv1wuHIKGv7DLhO21mIUmlPrIzBoDZX02xgo4IoaJsoRtSK7PnCXaIZ3GyWMVPfXUT7pa481ur1xG/3MibWQclJILBevHCOI77oqYktoxErHnaQviATlGVmuRgbpDpt+UwcbiUDw7SculTTt3d0aXZdK9+iJz5qYswd8ExYy6QZ1qtBVgYbi47aibnw/jW4qQh1SWbj6+o/pxm/i9hltEQ4e/kmqwrDYCBcf/jrPn37Cg4fHrJYLquU1+7MTJtMTRJasFs85P19w//6Et946ZNBrWa0XtI0l72WIWXLn3oinj6/8xGKNxVJVDYM2J8tysjxns14xGg45vjNkNLYslyXGZJRlxZ27B5y/vma1XIJ1K1qNZJydXjAaD1itKrabgkdv3Ody/or51ZymqjGmz+KqYLWCq8uCw2PLZNrj9aslWb5gMM5YNUsOj2bMDvdp2gpsy8X1mtevTvmxr71FlsPjJ684OpxxVs6xLVxerFjMF/zMz36V6+s5+wf7PH1yzZPHZ9y584Djoymr5SWvX8/dwqSsYLFYMdufMpvdZbOpyE2fl89Puf/wkGF/yHpVU1QtRWlZXK9pmgqL4fJqxXA0piy3NNZCllFTc//hA+rthA/ff0x/uGX/eMpifc1oPHHKVEbM9k54df6c+fzaHWoigDX0+kPKquTevUPmiyXz64LlonALvGi4ujqnaSxVYxFymsbZmp91fTHAXZS1dNmPDpx0Hxf1iauFHJOI4B5iviVJ338M5r774vPxA04pfEy1AxIhbf/ZiGAlxlUElqbxeeo6SWwOo8M/Yd9hRW7C3MOBJeqzVXDzglEo0bInRUYVVCcenajUrIJquj2wiI/fj1AVdECgqgm9lyhDkQis0duQyLZjVKX1vwHtnbo4kMQry8B/k7YSMhJBknpeZEemCZim7ewBWqOzcp8vxsXXOAbuAFYXKYX3fOLRYx+mxMH6Qz6C0rc3JnrD54RMSCKKQGIEMIccvPnHOH38Xcrq72PLFefnWxoL6+UKW1Wc3Dnhgh7bSclydU2v36dpa4racvF6yWAwpq5b9vcPaW3DeNKj2GZs1hX9Xk6WufUi5baiyWE8HjIcC8d33FYCo9GQ9bJiPB5jDOwfDLm8fE1V5uQ9Q1uDbQ12aNhs1owmM+bXV+Smz3q1IcuEw8MpH3z/KZt1S10790PbNiyXlpcvrjk4HmBy6K3ErUzNLffu3aept9w9PnHzHrbhwb1jirWllw+xJme93nB5tuLZR1est3OODu9QbHpcvFpxdXHN3mTM8clDrheNi1GvDdstIG7rg7KqGY0OEWm5uFg5NxVDLi6vqaqas/NL+nnG+fmC7abEmBzIqOstp69OmR0OaRtLUS4gq7marzi6v8f+0ZCq2tDvDbm+uiLLemyKhuVqARb2JkOaumZbFIzGE+bzNWXVUFU1g0Gf0WjE0eE+jz9+To04BWNrmrrFtjWfdX0xwJ0kajxSoThQSYdDZ5gnsGkj4Pon030+gqmNm7CN0W02+modKiUuGdvNJwUKHdgi/qhWCe9ammSUJqF9CMb7RtRV5Irm2WPwnbcYyXxeDcHNY7sAYIIySWUTr+BrDvMMnSPGfU6+zv6+q2fic7iR9q5PJGmTxNoKP3mgDBbObjl91VQf7tYjVCGq56iUbbQ2VGFIkqi2bzJTkChF/a6bs7l0FeR1szcjhk6pfcdJ4q+QjpycHKxxj5qg5FLg1obvyiRGPGlVtc9YMCW9POOdN96i+OSIYd7n/PUprR1gBLbrNa/OX9M2PQaDMYdHByxWTzHZlOVyRd4bs1xtsdYwGPbo9eHoeMTlRUO5zdkWJXkvpyhLMmOoqoLJdMLh0ZSqLrm6XLFa10wmM3q5i4fv9Q3D0ZDtpgaB5XLDoO/GwGAi3Ll3QNNYLl8v6PUyBsMe2/UrHj66S55N+O53P2a13HLv/hFvvPGIs/NTDg/2OH11jpGSXg+yTPjed79PWTQ0NVxfj7g8v2J//4B7d47o9wdsa0vb1IwG7gSqwWjEYl7y7rvvMOpPmV/PaVrLBx9+xLaA1bpiuSyw1lBWBmMqBoMBmZ/MNzWcn50yHPTZbjbsH+wzHGes1gvWmwJrhUFvTFWVTCcT7t6bslhdUNctd+8Pme49ZDGvqLYl42mPwWRErzdkfllwfT1ns93StC22sQwyS11tGY0ylss122LDdDrGthlGhO1mw7PllqJoaVroD/pUVcGgP2Cx2PBZ1w9zhuoQ+LvAwD//n1hr/00R+Qrwl4Fj4BvAv2itLUVkAPwl4I8B58A/Y639+PPyseGoC++LDANhB3yTgZC6BjQCwXbuJvVwlVHiB4Zw2IK19jMGK+pDIIB9ALQkbYUY4x0oieskbgoVY++TMxdiOuGzSVKOwLLr1pBEkelJQQqiwVkgBmsFTAtkQXGpXz4zybGGnbIoiLsIJgmbnAFJFIp7zSSv29vEz65Iowj1B41E2ZmHCMokuR+Uoi9BsmDoZt6JQrRefXkrxITvkY03IQO/TrRjNRLmnDXV7txMLJ/+3wF08WVN8tx1H2k6UTSqyArq9Sm2esw7b+2xXW5ZL/tsNm6vkrLcMsxynr96xd7emDv3H7K3/w5ZvmCzuSLPhvT7Q5bLDRfnK/b2cobDnL2Zody2bEvYbCuapuDk3r4PAYSm3lKVI8oqY9AfcXS0z+XVJQcH+xTFhrxvqCndlgS2ZlvBhDHTyR7rVcXr0zm2tfT7hqKYc3C4x3q9pN8bUWwL1mvL9777AQ8f3eH4ZJ/1uuDqfEU/22c2PuT8/DVtkwGGl6dz+llBta159foZbZtRt5YnT1/y9lv3GB3nvDq9oDgX+oM+1/MF49GYN9++j2Q5s8Mp29MFeb/P1YVzz4wmQ+razSMYMbRNyWDUQ8QwnOQMRhPENAwGffb2j7nsb6hLg60Nq1XBZGrY2xtSFAM2yy2z2YiDgyn2vuGD73/M6jpnMhvRNguOT4b08iF1M2CzLujlA7brgtWqJhfDdrtlLBOqosFaw2K+YTYbUNYNBqEst4hYepmhlxvkD8AtUwC/aK1dikgP+BUR+S+B/zXwf7LW/mUR+b8A/yrw7/m/l9baHxGRfxb4PwD/zOdl0l2U1AVT4wdDJ+ZZwdM/03YO004ZbJzQ1InFMM7QbQI8cIbJrS7BUmDV50IuOzHznRWaiuzoxKRLr7Wt34xKgdIx/dsOBwlQl/i9Q5pGOguBoA1mf2Djlq4bypfLaDL+1WzHRx9O/vGhQBLqH8Mb1V8erZY2Ad1UybiCd6KO7E4LSWy7sFJZgVMkAWQ/2WhF97/tvJ+kyO6V6md1M1lf313XmyuLo95WrSNUblF5pVtFdBS1TkJLqqS1hnSVkRpkiUAigXcUIGNLcf4bTE3DavsEqguqasl4PKCuNozHOevVNb3BMb1en17fslqc0+8NKLZzer0csS2boqQsYdAbsFq1jK0wGPTJezVNbWlw2wnXNVTFlnt3Z4wnIzbbiu2moSjXfOVH3iDrW6CmPxzxo3tTiuoH7B/MEGu5uLhiNOlTlBtenZ7TtD3eeechF2ennL5YcX5eADWjQU2xbZAsoywy2iZnvSy4nl9RFC3VtuWTD1/y4NFdFqsFq+WczAx59eqauyfHXF5d88FHzxj0B1ydLxkNx0xnOfPlhqbKaVowZsRqsaQohWcvTvnooxfUZc6dO/e593CPxWLOtiy4d+eAi/NLMjNgcXVN3jPMjsccnYzYbgq/hYNbdHhyd5+zV0vOrq7YbCrquqQs7lOXljzr08t6SFaR5/DTP/82i/mG5WqDZML+/pSyqLAWpns5m3XBYNRjMD7ixfML8mzAZr3i6OguWENmRxTFmrU/81ZEqIuGvJdRNjW03RDe3euHOUPVAkv/tef/t8AvAv+8v/8Xgf8dDtz/vP8M8J8A/2cREXvbyRnJJeAOCFb+Izf9salfPfziJzCVCQd4FX3OhlSFboibz4aO/zSN7CNhVonVkOa9U8SUzqITtmEiVB9INYem8ynSickKYiIqdtwUgR56VwK6VkDZu3QrZW2MtU7orotzx50/K7GIggmTlGksu5ugtYH9dlf76hxBAmihvGoJpMy1azs5hWBhx5Wk/zu5JgiZbN/caYdU2eLYvpOHzjukgYzWA7KPaBfr+2GMJuoGPsa0474wsXWi2CNhCboiCfeVpNhJI7n9bGwN6+cUZ/8tm9UFg6ZgMNpntdpgWTHdy5jNplz3C548foUxPa4uVtTbFYOhMNnrcffejLLYYq1lPbcOVIY96rpmOs2ZTCYYWdA0lrqG58/m0LYcn5xwdrakqSybVUXT5nz84Uve+7E7LJYXTCYTWtvwx//ke8znK4ptxbs/+uOcnb1iOBmR5zl1DXfvHXD33j7b9fd5/XpOvzdmudgi1tAfZEjb4+pyxXhyxHZb0tSGV6/mPOqf8Pz5GYdH+zTVktOXr1lcbZhNphwfH5HlGXVlWW8rykp4+XKOAAcHU3pZj7JoOX19ydV6xXjc5yd/5qu8erHk8uKcqqgoi5rprI9Iy3A8YLOqqVtLJpZ7D064XszpmT7DwYhXpxf0+kPynmE0GnN0Mubs1RV700PKwq1AHY/GzJcL9oxj23l/yN2Hh2Rnln7fnZB1cmcPYwxZlrNaFdQ1fO87jxHTcHB4SFVZfvRHH7FcbPnogzMuLtY0LcHlXFYtZWWpyor2szeF/OF87iKS4VwvPwL8u8AHwJW1Vj36T4FH/vMj4AmAtbYWkWuc6+ZsJ81fAn4J4ODem/G+gpHv4B3MkzgugBDpEqxeq6AQ2bZLZRewdVI2mQALDEwnUSNIWKPmsTL2ONEa2TxhJWsMw9MVislEcShcUg4SJkfEJaccbGdDK31OAhUNsJEAOjGvFOCDetmFJ80PFFR1cjhaB3rwhHcyhVC/HeDSyc/QhjEKCmX46SWaRqx8UMfJEv8YUqgMPtWi2t7+rk3DH2M0jU818PA2aSyLWike3MXdU2B31kpi7nRkzM5cT1S+us++akrpvGyTeYLufIdYS24rysUL7PXv0i8XPHv8HQamRz/PycwBubFkvYbVYk1TNtw52uM6a3j65Iz9ySEHszH9oWG9XFOVDeW6JTOCWBeTTiVkpmY46vHorQMuzrYslw11UdDS8vrigjuHR3zw0QdkeY5kGfPrkvWyZr2oGPeF2pYcHO/Tts7vvi2W3H9wTFlYNqsr2qbl13/tN5lOZjRtyS/+mZ+lroRv/IPvsLzegG1oKhdyeXSyz2QyY9luWa23PH95zlvv3OP6quT6Yotp+/z/qfvTmO22NL8P+q219niPz/xOZz51aujBqa4ebBO3MdgmiW1hRYqxEysKAilf+BAJEFEkBEgkQoEPYCkRkcFCjvlgEwdj4xBMPLXtdrtd1UN1V1ed8T3vecdnvuc9roEPa0/3c05XlxWDTu9Snfe5p73XXnut/zX9r+uajRKkC9F1RVVqBCGBisizkul0RpZnLBcZzmrefOsB8eSYp8+e8dob76J1xfXtS5wRfP0bbyKk83NTa4QM2GxXCBXipGW7zcl2BdNJjBSOPHPstiVhJClzX3vn0RtzHj54SFGUvHyZg7MkaYSpQ8oMil3GlVgzniaE44jT0xPSdMRqtaKqapy1rBYFcZzy+htT3vva2yxub1mvF6TpmOPTmOOTd/ng/ccYqzDWYOuaqrQ47VDqnwMV0jlngG8KIQ6AvwZ8/Uf53e9wzj8P/HmA177+U71tLHzQ0eK7wojh1mzBR4JyPWjaFg5kr892yT/NhpLS6/Z7Xqo9LvLg7eaSXbZoN7Qe0ffYDd3G7QFA4PaaMPda7HArM8igpCOvuLbNHX3FyVYLHPrdWx9+e0bb+xxalGu+OdR+B0lLX+TOcBYhg/YZ0WrFrske7sVge9We+dIJLYbXboUa3S8HE/f5Q7SC686cD380CFK2Vxhmxg4pnh2ctlMzEBYKOjaLf1s2D9+vPelaF1d7n657SMKKvTHQCYAvuKW9a+x/p33u7D1LcM7iiivs1XfJrn4Zk72kznKuF5e89sZ7jCeHvHx5SRI7nBHEQUykFEo5gvAQgeXq5prZdEKtNcJJsAFKSvK8IopjHBYVCGrtXTvb2JJqRRCm5FXG17/xLqbK+Oa3vsGzpy/YbCvWqzV1fUYYpFxdbEinEbt1SRJP2O4MQgQcn5yy3axZLkKkqnn0xhsYLakrSTIWPHn8gu3ulvFs6vnpu5wwjLi6WHB0MqXIK7Is582332CzqdhtNkgiRiPFfH7A8xdPwFlG4wnOaZQK2O62BIEljlPOX92ia0M6WfK1bzzi7MGcWtfc3uz41s98lbrUhIHi+vqW+dER73//KbutoS4dTtTIQHH+4pooDJG2xllDttYUlSEMJbODhOPjMVm24be+9wmHh8cYLSnLkihOqUqBkinZLieMxuQbH/da3l5Q14Z0FBHHkqOjOUIK7j04YLvdUekNUaS4vd5S15Y33rzHarXBUaJrBUpxfHzEepmxXedUZf3bbCJ//DOxZZxzSyHE3wN+P3AghAga7f014EXztRfA68BzIUQAzPGB1R96tBtP7KnY9CA12OQ9sDZb1/UA1+3lTqFsTWqPPNLZQaenzwN7d9kBOLbgLHpkuPML72/uPGANyOz5jAf3s3/NBiobxozHD6+ZtsDefk022aCe4dH/vg9F2oYJ1BQWawC3z8Oky7YUuDuFZf1/9gKVQwHVzXV/K0MbwHPuG0ht/PbdRO759NuXA3V7aD+4ASB3I2yFZqvJt81UWkE6mNt+JTT/9u6X9v22AQeDmRNdwkOryfdg3dE5W2VBiK4y5qDs0H5ZmFbQDK20O66rYVXOtouXt+IsploRo6mqDYvz90kDi3CaKFbU9Q6XJPjiZZowirBaE8USbS3370/QtiLZBiyutxQFBEHQKUpCKuIkIc83HBzMkcqwuF0QxyGLm4IoTjg4mHF1fcV0EnL/0T3CRPLq1Q0XFws+++wZb7/1Gs+f3TKrUopSEcQaCEjHE9arnDhO+Omf/jpFmRPFMd//3mOWyx3abDh7eIqUMQKBMYbL8y3LZcFi4euq1DVYHfDk0+copdisM45PZjx6eMyuWHH/4RnbzY7rqwXWwsHRIaNpSBRKFjdLsrwgyyr0Y0NRZpyezUA6bm42xFGK0QaJIt8FXJ5fcnudYWtBFPuMWhWEREnE4cGU1WKNM74mT10ZrNVku5oXz65wCLY7zXZ7zenpAbVesd3lHM1npKOU+fSIy8trnr+6oqhzjPMlGx49usfRcYoKdmhTgjBICXVdkyQJo1GMDAKWqxVVWTKbp7x4vsK6EJxESUXviP7tjx+FLXMK1A2wp8AfxQdJ/x7wr+EZM/8W8Nebn/yN5vUvNZ//3R/F397E6DwgdvxzDzRDbywDYG83e8eDb07UBcmakwrb+9qHLpmhg6B3W9zRyIWPBQwLXu2n3nyRgGjApNv4vZ+6uTjDB9MCpcf3/vpOuCaZyJ9PDmbic9d0QwbO0Pzfr1bYli64uzBEK4hk6w658znK31LXwrB9v2V2iC6jlUYr7q/KPpbvfXZHyLZT9AVLpjOc9sbVrhXx2zyTnv7aWVe0T3pIP2zAehhkceydtWVRCWhipaIbq6B9joN6pqJPqmqPfq3edV81z10KpMmQxSXl9oKyWKBNxCZbM5uNmR3ELG6ukE7z2mvHOJuja8tiUaLLnGSc4KxGV5bROGKzdiQolssNs9kcYyzj6ZiizBHCp9zXesvJ6QFRuPFUvTxjNJ3y8P4Zl5eXXF3dku22hJH0Y5iO2e52IBxxMmI2G/P408946623mE2nfPLxY6azEdnaV5isbtaoIOTBg3vUdclolDKa1Oi6JFEB1z+4wNmYfFvx+JOnKKkYjce+zvtuQxRHSCVZrW99sDNNiKI5FsdnT65gmSFUgjMBq9WOMIgYj32rvPW6oKoMo3EMNuH8xZogSMm2W/K8RBCQxmNULIiSgLwoKfKaMFQICaPRCFM71sUOpQLAYowjTWMOjw+5urolz3OWyxVSSooiYy0Fi8UCrKIoaqwArQUqHOOsZrHMkRLSNCIII6IgYTZNqGpNlZco5bvJWRzjyYR7946ZjE94/PgVm82OQIRIJRA/nCzzI2nuD4C/2PjdJfB/c879TSHE94G/LIT494FfA/5C8/2/APwlIcTHwC3wZ36Ea/SBTVptd/BZr8IP1KOGG99qVh3k9v5W0aqig3z9YZp9Xx14yChpGSENF32grLcV/oZ0tn2R0I6s/w2IvpBYB349uIru5P1EuC5pZ5D0RJPQI0Tj8++1v+7emn/vAmNfINP2yVPt/NyxKjqXRyds249tf5+N1txq4cOnNRRbHX+8eVodcA8AvSef9N8Tg2fYa9Mt+A6/7+hVZ9mMebA+9oRQc32xP2dDO6Gfj3aS3L6l1U1Kd4MNgbcbFNL2FEofbB40hxz43NsieK5pzNwX8Tfo/Jz65ldZvfqE7fKce/fe5cVnv4y1jnGacKs1i5sbjo7naO1YLDbo2hFGkiKrSMeKJAnJs5LJZMJ2WaJLyHYVKgjYbnN0XXJ8MvP7QCboWjOdBfzBP/gNqroGoVjcXLFb7ljfZsxmI5I4ZvzwkCiWXFw+5+13H7DZbpHBmEePHnJzvaKuHUmSsrxZUReW2tSMJyOsltSmZDwZsbhdEoQBs4MZh4cph8eH/Nb3PuOjD16QZyX3759xfDLnk8crlBTEkWI6jcmzBUkyY73e4awgzzTWCKrKUFWW3XaDVAlJnJAkIU7UGFtzenrK0dEhF68usdry8tUVVekThSbpqMEJjVES5yS7bU4UJJy/WPpYRVFR1waU7740SicEQcRms2I2jVHS8urlNSenp3z1vUdUleajjx5zenqGUwG3r24oSw255uBwhjMGXTsuz9eMpwEcRNzc3HBztUDXljges9t5DnsQBGzWGdnOsdtWntYcOnz+y3/NJCbn3G8AP/UF7z8Gfu4L3i+AP/U7nffu4de27XsgCDFQcM0eDbEN/PVmucW5vQrcHXS29DU72J/Q92MdcpmHJr2gSdlvwUCIzu3SalwduHXW97AMlx18ewBw/Rn2JUKDms45kK5LsurAH9+4e/8MTeJOZ+n0Volr59C1ZQsYANUgwNsjVfsFBjJtMNeDobpGBDaf7ZNY25G1gLpfE+iuPi66Z9E6jwZVdNo10E5PD413xt3Pn//Z8HuDv0TTRWsgIFqmi3Bf9Ns+sOwDw22jl4ESYd0eLdO2Gn07ntaKGjwjT7F03Rr0/n+Jc5q6XOO2L8lun7NbXqGrHdudIggd2liurjY4JEEYcH11S1WBrgXZrmB+kOCsIVAKISSBFFSuJk4UKii4vFhxeDgnCEHXlsuLFbVxnJ0c+eQjWzGdGFTge65mmSMvfJPtd7/yDh9//DGz2ZTaBMRpwhvvvM5vfPf7PH36GW+++Q6X51vCwJGkjuOTOU+enDMez6jrLdZ6hSQdJ1hrqaoNReEwZkZVaYLAcXIyZ7nYobXm40+eUJWaMAqodYWQjjiOyMuSLCsJZcxmnaN1SUzAZr3l8OCI25s1RVYyn40hqJgdpISRwjpNlmdoralrjXGOUZJSVRVSCWytcSpgV5SY2rC8WRFEETiLNb64eBzFlGXFzc0K5wxBCFEcUpY1KojJs4rtJmexXlNrye1y1dTpCXjz7Qc8+fQJh4cputYsFmsO53MA8t0aqUIuLjLiMGW3LcizgqOjI66v1jx/do3REIaxn4+6IopD5gczPls857c7vhwZqgJfz9qJTsPqwLFzl7imNKvYAzNE69q0tIwGDxJuD1D29uwAsFQHQ+0mtwOcaD3tQxQenEv2kOPoBcpdv6ps6ubsKdTdePaDum0SVHeRVut23v897CA11JD3XUpNIpVoT+O1Wt+KsNdTO5HUcuebgKLtBKh/DkNGkP/pIMjcKs4O+tLDrca6X7Ol/V4vDtqROLq6Ne7uZ732v3+IL3jvjhASw+/1lsO+oOibrfu5aH97x6cpemE4VN7bMtK9NdO2PhTtJZvftM/UCwoaoexruzeZBU6SqJBnzz+iXrzAFGvSMGCcpCwua8I05OLVgiI3PHp0D2trirxity2pS01ZrBhPRtR14UsFZJpsV5GOUs7uH2GsoK5rjHW+lvt4TOB8043dxhHGiourNUeHE5QKODoOyfKK1asdv/4bH1CVhefRu5J0HLPb5nztq1/n1fnzzr1VlBvSscIYODo64N79B3z88afo2s9EGCusqamq3HdeuthQVYZHj17na1894OOPPuP5s3Om4ynLegtOI4SiyEums5GfN+kZK6NpzOFpynQy4dnTS25uluRZSZomVFXFydGMo4MZ5y8vuf/wjChKiJOa2TwkUAHL25UHZqUQQrDLMq8ZC4mxvh+rRGKMoTaayuwQDsrc4SwEoUQFCmM0ZVXhxornzy5xQpDtarSxxEnIV77ykM12wzvvPuTs9IDPnr5EG4c1iturHbWuMA6S0Zzlzcr7+IOQjz95QW0cxgZNPSuBdRbhBLoy5Pa/Zobq//+OOwHEBrW9JTzs0nQ3B7XVjvrN69/2CRntnrKDrw9B0W9G2UF4u//uVoVsbIZOmAzBrnVNeOZLC+L95/3Y+RzYIdqAYTOegXq7Vwah+Xzvvtuv7vHL+zEBex2iPhcaGMwD3Xno/O9D10s7jtZ/PXyvtQj6VoON1u72gbCfK/+ebX0yrftmr7JiX9KrtwxE9/z2ALoFbQd3iJZ3Zmv4RzP2Rni09kbviuqtA3GXvklfMXNIY+3de65zEwGdwuCfrVdiZBMjUaKNB3g3oHCGcWR4tjhnPjri4PB1Lm9uWG+gyGu0DdlmO54+veTBg1Oftr4pWW93BGFIGEcoFbHbVVQlgEIKRRgo4ijEYQgjKAtNXdcIEbDJcgKlSLRit6wZJwYnWlrjIUVdY60kjhOUgihMuDi/ZbnIeP3NR8znR6RpysNHjsk0QkiN04LT02OyIqcocgKVcnR8hLM1VekQImI2O+Sz23Pq2lEUBmu3bLdNDfOyJo4l7733DueXF1hXY53i+GhOFFvUcUoYRpRVTRjEpGlCWRh0KEnThGQUoyvBzfUOKUY8/ewSgfRFCaUv7iyVV0aMAeMscaSwRqM1OGvBaoSzyED1OmazUrKsYDJNKbOCuq6ZTseEoc8dyPKKsjCoQPBTP/Ueq/UV84OxLwu8WbFZlVSVZelWzXhiyiJns11QF5q60s29OV8ywkKoJEbXWCt8KREEpf7hRPcvDbjL1o3AwI0AtMG/FtjaTbKv/TWfDUBqD/zuHO1zGgoM0WQktr9p6ZDQyAnXAJZoAWBfxDjaRiMNKDjJHSQB2Y/zcwHDoQtCeC2unYS2NMNdP3ufGLWvpd5N8kLYzrd9N9GoG7/z7gVHz5DpIHTPNy56dR0veNtr906jFiF790V/nX5c7d054YWQHMztMDEKeqZJC+493ItuSF32Lc19OGjLJ+w5cu5aL6Jpgk3jchmMd1iDaEiHaSuDdrTSLlg7dFJB057Dz0QDDkKa5rKes2Rb37yzZMuXrK8/RqkI4zImR2dUIuT6VYqrfF0TbWC1zgiiNUkcE6VjYEugFOvthuXaMUp8K7YgkERRwGpdoELJbB5zcDgmz2our5aslxmCgJtFTrAxhEpwWo0x1qHCFBkYvva1h+SF5eZiRRh67fzk9IDnzy+IrxOubgwnx4c8eHTiwbu2RGlCmgTI0LtoVsst2uQoJQmDgNE44eWLCy7Ob5jOjnj16gpnLSoIMMZiakuaKOqy5PjokMksJk4Um9WG6SxlOp9Qa8v6VUZRwHicEoXNnFqwRvDy+Q2j8YS6rllvNqSjkEePHpLGPls3TkPyUmGNxJSGqnYEQQhFibMOgwEsUjuMdURxiMBhak0YSKwW7DZVEzfJKYuCOEpZLzOPT0YTBg4pQnabirqqkWjCUGCNLylsrKOuINvV3v1kocp9Lf3KWIwxBEHgA6hO4KyvOxUEwT+fJKb/3x994ozrsjp6holr+1/SatGy84N3DO4O2BuLuAPCdgO6PVAUtDVVBoDYaJH7hcO8mdaa5Xu887bpx8CV0/be6RKa9nCyv16fCSvufN6Iqj1XxBAge6nTia+hFt0BYasle83aDsYh6KmLHfWvEyR3hrT3jER3fv9O857traY98O6EdT92KfbP33WhaurV+CDyQL0f3ls7ZwNBv0/8cR2Q+wv0sYt9CdOPsZ8TN5jVAXlUsPe+F5YtoNOti3ZxuM+VweiFi21KNNANR3SPTwqHk5IgmVLKQ1a7j9G14ZMPfoU3Xn+P1x+d8dH776OEYD6bs1iu2WwzsqzAWYUQIaf3zri4fsUuqzEmoNjljCeCXVY3F6yYzmcslwuUjHjw8IiqvmS9rNHWMgkk6XTENqvIthmT2Yg4cURhyNE8QZcVo/EIFSkePLiPQ5PlJWEosdYgMARhgLWGPN+y2xpuF0uiKOTk5BiHIElCrLUkScx2uyVOIoIQsjzj6GBOoAK2qwBdQ55v+fTJC9LxhPviEClTTs8esNtt+fTjl6TpGKcFdV0hRUBdFtSV5vTkmMvrK6paI/Kcw8MDhNAcHk/QOufq6hohQtI0Zjods93myNqz1Yw2aG380w/9KouTmGmYcHV9hZCSQClm80O265xs60sT1KUhCCXjiY93CCfZbTTf/iefMp2OCAI4PZkQRAHj0YzJZMbFq1uubpaAn7MkjnHOUZQ12kJda8IwZDRKwFp0VYGUCCkxbqiEffHxpQD3jkfcOBGGQb+BctXqSP4tKQbaEp3G32u/bZiu/QUDjbvR1qRoALrf0C1qtMDhtfg+I9JB35atrUBmW/pbDwB7mnSLUp36dlej7Ud6d2b8uO9SL7uRdPffja8F9d6O7LXuwVrwpXT3raQ9LG19xnvup6FKOzih6Mmhd33xrWa/Z23sCdn2VIN7bMY/LCLW17Whf87DGi2DWRiulWGXJyf687VPphdIQ4k2EB7D6zfAPrz9/fsZnLNH/H49tb9tbrSzpkT/b3Jwxle+9adYrzJeffar3J9ecXNpAU2cJkyCyJflrSvK0mc5lkWJQ1CUOSdHc5zZsFysOTs55J33Ttis1v66coKuKvJMEwQBRbljMh5TZiucNSSjKat1znQ8oswcgbKUpaXIM46PJKNxSJZvee30DXbZjgcPT/jk4ydoHYA0XF4uSNOYKFJoo7m5XGKd4vJyQRgkjCZjdEOFXCxWxGnM13/sHVarNaOJQkmHkhUPHk7ZbAvG9Zz1quL2dgNCUlWG09NDzl9dIySkKRzMp9SVY7UsOTy6j3O3vHh1QVX7ptJxrEgSwXh6xMHBnBfPL6kryPMcXYOQDiUlUjlGk4jNaosK/J4+PDyiMgVhEHF9ucQ6icSP4+WLC6zuLVVrBUYrqoqGYimJk4i6ctxcL3l0/x7j9AiLRsWW5XLD06cvsU4RpxBGAUEQUFUGqUKsMb5ktDFURUkUBF4hQ+KMoI2N/bDjSwHu/mhrg/SLvt2WLQ9miIU9tjhaiplrXzYaU7816ffZ0JVBuwld94ZXDEUHJNbZRlsc8Euc6c7gsHs8+7vBV5pRePxoB+FN/M4F4eXUHXdKm+7fw3g7giGQDjns3SVo32uETdc7tpkr0Za2HQi8geUCfUMK61rw8ePuwKyZy75heS8hWgDuZ7/V9gcA3zhKZCeg9uftC3MHmgF399yC5vC3ri3Tu7diekWgAekBQfEOGNtutclBpfbhuH5Y2oYSg/qm3T0MBPEdrj0Ma4AKrAyJj9/jZ//lf4fliw/44J/8FV5dPCUKNUEYEsUJZV5xcDBDa8dqsUbrilrDzc2Shw+OeXD/kCiENFG+XZsOGI8isizDIX02ZV5ircMYzXw+ZrfNyXc7qlKzXOwIVYQzgigeU5c1+c5yeDpvmmBvmB/MqArNu++8w/XihrOzE1arBUIIoiggCmfUBVxcrpiM5+RFSZKklEWG1g5BiNGOKIw4PjrAWnCuRknYBQXpaIpziiJ/iZKGLNNstudEieO11x+w2Ww4PTmiriqkc4xHkpcvrwiDgNOzQy6vLrC24uIi4/Z2wXgScX21ZLXcUdcOXRuKwrNOpHREsSBOIIqm5OsaU0sO5gdcLa5ZLDZYKxtXmcYaS13UBEoRpTF1VWGtwRhDWZUgIFQQBIrJJCXbOS5e3VIVBkvN8fERq/UW5yRhFCIEVFVFkdcY7QPcUgiiUGGc/9fXkhGEQYCpLRaL+R38Ml8acJey6X3TAU1v/osexe5s+gEDvjO/G4DdU2hb90r7haErQ/Qp5qI/q2202o6bLESndHfdnRrtVza1yCV9eQPXOO27rEQAMajz3hWwGo69BTn/Zq9ltnPhX+8nX8HgZvaOVtttPBlNLfnBd+9o1L3G30+elH2Vyf6aPTgLQWfAdNMMg9ILTZEy16F+F5BuzwHDwG3vwx7cSf+Z6AXFUCgJIT0tsft+G/C0WEEfvKTV5vehdR/q6er0CNgbW3v/wzkevmfba7fnv+PiE62W3p6zy5mgEboCKyxqesC9r/0sLhR8+7/6v3IgK4y8YpdtENYH125v1hjtn5e1JdnOcH294969EW+/fcJyueX85SVZZggDyWQy9pmbxhGFMdbW1HXOZBIRRb4aJFaQZSVpFBAEimJbUJYVgQhQYU5el0gVYPSOMIp59eoWbR031xuqqiRwCVtdUhYVYZhyeBASxwkXlxdI6RiPU5aLLdm2xGiH04rRKEJJwWQ6osgLXj5fkO80dVWz3eRgJCp2nJ6d8PD+KQiLs5KyMMRhzOxoBG5DvltQBxHpaMx0PCYMYzbrgkClRGGE1jVKSaTUhKGkKiuUhHgcMEmnOGcJowgxCtgsM548/QxtDbo2OA22+Z8EhJJEaeQN9267uC7UpJ1js8kwokIKSVUYFssdgRRcX2xAOoJQIoTEaosipMwrrLVEQUgQCoJAok2NwyCVQKIwlfG9D4xpyCC//fElAXfXJ/og+g2yx1gZUv+Ge79F5F6z687ZbOZ2I9kGaLyC1qKQ8xmod0bUFWAULf2wAcYvKnzVjkIIhGuSfRrEa3Vm6JOiPI7L3pIQNEGZoXY9BBSx54L3VR/99xpooS+y1QxcSIYJRHJPV3WNBuwYlhrwDI8h+A9nncHY7wSzZXMVMZhHMfinFVyt0O607sF5XG9p9UlBbv9kzSA8OPYMqV5C3uHuD5IFhG0yeLtxtLf4RdfYswVohcX+91xndXWTM/i8dzXeObe4cz43DEM3vn5rsZtzynrLo7d/msm/eszixUd8+ht/h4uP/wEBYKxDCElZ5oxGPpiYjFIuL1aEoWM+PyQdRTx87Ziryw3r1Y4ojrm4WFEWljQ1zA4Ebzw8xhhLUVqKQuNs4DskFSVChCRxiLOKx49fIp5ajs6OiZME0BwcRCRJSFYKwiDl9nrJ5YtnGOPX4mw258HDR1xeXrJYrLzrKC/ZbUturlbgBMv1mtOTObP5lOVyQxAE5EVFnhVs1xnCBQhheXR2n6OjAza3JUf3EybTGXE8JtuuefXqktPTB8zms6bj0Q5dS7JNgbWWxWLBaHSvCa6u0TojkBEi8C0G02TOZrvBGst0FJJnFWVd+5XmHIEEIkFd+2cehAHOOmpTI5zy1m2jWEggjiOscWjt2G4qoigAK6gri5UKJSxJGqJrg7aVb8qRVTjjsNoglGB8MEMoR5rMMVZzebGkNhqs6Aug/u4Ad8AafDCt0cKc5+J6ULANtrbaIHzeFdGojp3i24Jk04TYDpNXoC1+3hrMd+G91aSdo3M9DNkaXRmDzm+9D4S+fK5raIXNJTurwdFlfDZ1cazrch2br8suoNfotv3YaAVfK8BcP2aGdD464dObB0Pttj2b6D/v5ngwPwPA7905rRbbXqu5j+46ew/HX+EOsNJq/bi+9HkLmneeyueZQu1Z+999/rL+5vsg7j5DZ/+448YZHF1w2A2/u3+9z/1mMLy7tNp2kbZCshueXxCYYs35+3+X25cf8OZP/kuMjt7i3d/zhzk6OOVvvXiKy19RVTmvP3qNJ0+fMD8csV5pxuOIw8OIPC+5vCoQwnJ8NKUqa08PTGKkCDGmRgjLT/zk17Fs2W5KD1xWU+SOsjRsNxlZVnF4MEYgUCpltVmwK18ynU+YTqa895WH3C6veHB0gDElB/MjVjevqLXDaMdqfYk2AqMt+a5CiozddofWAikD6lqTBhFOSBaLDTc3S9J0TJ5nvPf1t9FVwVffe5e6qrl375DPnnzKclVTV5YonTKaxOQZ1LXl29/+LkKEOHKEC1gtC7QxvimPDDk/v2U+n6K1o64E2mqElDghOb9YMp+PKeuMPC+pdI11ft2EQYjDYrQlCgPfSkD61anCAKkUm02Gc74oWyBgMhlRFjV5USNwBDKk8D39EEIQRiFSeqGgS0NpDLoyCOedlFII8rxEKSizkqqu0ZXPXBfC5/vss96++PhSgLtAoARYZ5qgASAaHmpHV/QZmqhWuxR3NKfGFeLsHUO7D3ANOdQDO+ALRtSDtRBNpqq1XUBuGJQbbnrBfunX9j6667b+kR7Bu9EMdcWungzCBz3bQOBAS+z0QzGALOcGoDe4Q+c11NYXzgCM/X22YvWOIBmcu5vovbjA590SYvC82r9c87u2dM7wmfaPqQfz1hLoBJWfFVxbifELFvXnGqe0w+7GOmTRDJ/RQBPv5vWLjnYzfYG21CB0L3TbR9z739s12I3F3ZmHZp4UFiEsT549JTv/kN3ihtM33+XtH/ujzI7f5PSNn+XVR/+Yq9vHpHFNGI2o6po4DsjyDfP5mGynWa12jEcpi9scJUcczBNenV8ghEBJia4dV1dLkAWYgPFkTBBYXr26xRlDlCi0tmyygiQNEQqOjuc8fP2I0cTz6K8ulzgkURBxs7rm+mJHqFKKPGe7K5GB4OWLK+qqbu6wQskE7XyjbWs8z94ayeJ2BQ6yfMt0NqK2W07OpqRzxfr8huUOgrHizXv3uLy6pN7uWC23bFYrqsJQFgWn9w44Pjniow8+xWGIooj1dulpg8aQZTlShkgZUtUVEoGSCq0Nm3XGwXyCNZog8k9COdFkxwqEFBjr42uy8cMK5zDaNHvQMUpjwPlgbWU8nVJ76mRbIruyNdutRSnhq79qfw7bav5SeNeQEOR5hdUWqXyyFMZizT654ocdXwpwbyFFCYEVDuf7xjcY1IRTnW2A0zYSTH7u9x2wDc3uwXe+KC3d/6Rlze9rb2LwXaF6t/L+GZoWf81mVdJLZwuDapTNb/bVueYiHmzbNnnWtjVkoK1bLjt63WB8n8vaFB34dEAycKN4eej2SpJ3dzwco3ODc/XA1F3/Dvq1AN9VSxRfPH+NmeOv2SNur9UOnlcPwi34+Qn5oZpy++FQyIhOGf7cuPdCpZ011Qqzwdy69p9W22bv8z5+0M7P8PmKPQF217LYc8e4QVZ1mPDO138/T+sLpvaS1Wf/mG9/+j7RwXu892PvcXIyY/m3/yovry4xZUGSKk5OJkiRopSiqgtkIAgDBU6yWC6YTmcEKkLIAhWAMY7VbUkQOeJIYuuKxXLNvfsHRJFnfzz97LJb8/P5jDzf8fLZNcenU+JRyGaz8ppunSMEbNcZ+W6HdZZQBTgh2G19a7ijo0PKsmS5WBCGIQ6H1obdJsdqmIymvr2dKnjz7XvkecF0fp+///d+nSzLOD07JIwEp6eGi4s1dWWpq5qTkyNGqeCb3/wmYRTy9OkzTk6P2G5foZ3l4GCGUpIoilBKcn29AhxS+ZaTtS7BOeqioi5qVCgJo4iiLBHWEUYhVV33ypUTWAvWWIzx1repDFIKst0OYwzWWoRT3RZ3xnqGXbOvpQqQgaLIK4wBXzrF4suv+IzYstYYbTDaEgQhUaSQKqCytVdyHU0hs9/++JKAe+Ozkv0G85mefU33vQCckI2PutnUzeYdsig6VkLjPN/XWjvD2P93D4Qb/a2jTPaGc+/V6E1q6DXjYRBNMtj0buDe6Db4PiWwu+RQW2516uYeW42+NQAaBXzAXmnPsd8oHPbrt/TcoiGQNWOR/a03o6QLOXS335dMaIuYfXFwZ6iZ0tcN6uamFRZi+PWhgdJ3enLDueu/4AbnG7635wtvrvGFskEM6KDtg9qb//6+exkxPNNwRgc6eHuve26zXtw1srY7k8X1Bd5kyOtf/72Uu1ecf/C3sHrN6uIT0s0Fj3/z/81odJ+Hpw+4qkq2VcVukxEFknQUYW2GkhGHs2OKLCcdjciyglp7hkhVVigVEkcR2a4iqBw2hTBShEFKVRbMD6cYY3jw8IDlIiOQkqOjhNWq5Opqze2N49HohGgkcC5AVxV1XSOlI4gEcZSSpAFV5RpwF1hr2aw2KBlQVRqcV9LKvEZYyXqxwgnH2b0jnn5yy8XFDU68ZLna8JV332azWrNaL9ClQAYJ2myYTKc+k7Msefr0BbPZnA/ff4IxktOzE8IwJApClAxYb7fcXN+SZwWBCn1zETwf3RqDcwKjXRPAbPZ6oDCAkAqnTad86arCCYES3ooPgwgpfGkHnOyWUbsnOuzxSEZVaVzhcwukDOidkBbnLGWpMbZZcc5R1xqrDSB8uQNnCYPwd4dbBkBKh2384lZ6zbwt5tT5y5tkIhpNkSY458QAFVzrk2pgWvQA3btr/Os9P3anRYpOSg/91u0fraY6PEubOt/uWEdv7nfY5fYBoJXi4DrKncX5WjedVjfQgkUXJtgPXA4lTGsBQMNhbwcpmnJcncrsF5TbT6rp5FmnoX7B/dPequh+t/cZ7P/wTgVMN5jf1iE01NQ7Dng3v8NXn69hvQfig/f24wmdTN4H+O7e+3nhjmbOYHz9E91fN/uncz1ot+kQ/Ww1JQYcylmvqbcVlBs/Ks6nxguZ8rVv/UneevebfPCP/yKLy18kiQz3jiTCrVmtSsLAcDAfU5YBdW0YCUUYgNGW7XaDEIqyNBSlIXIB2jriOKGumixHFXNyMud2cUmWVxhTowKDNWPKsiJJApJEsFuX5LucyTjm9Ox1kBDFEbc3K3TlkFEAznFyckBRaqzVzOcJz59dcXiQUJSa9XKNFBIpRAOuzoOcsejKp/zXdc2zJxf+2UlFWdUoJVguVrzz7j1Go4DlaolSMfPDKWGgePr0nCLXSBdg9FOKqkLKgLAGYzacHp/y4vw5eVFQ1xarDbU2jSbd4EyjLGqjEUJQVXXXQat22vPgHYRhgK6t94WXtQd+fGKekH4tSKSv3TNc9c16tDiEFWjjQVxIcNZnK7fuO2tt52oVQqJC2RRd82P0eN8nZP6w40sC7n7jKuV7ETpnEc4hhG/KIBq/RxvQ9BPvN5mXwB502wJQrVY/PEQbgBho4h7+e392RwP0pSI7jdR1KNNoac3f+7jSnMc2TStazbkF9g5ImkYWA8ATLSf/CwGV3o89fG+g7LYiqXdj9A/eNf8d8uZFI/ha33PvC260jYHLq9P3h+6TO26v1pLYx11358O7xwAgB9bDMGv08wvYdu6i7uSuP1Mfb+jP33Pb2/EMtefhdwcCvb3HwTdoNKuh5TT8pKuU2Y69q+rT/tdLZOUc0llCVxFikU2hNK2htn6tORlgna9RHkwfEE6PmR8csl5sEFKTxhXObohjy3x6xAfv31BrgdaW8TgkkIra1FiriWNJnpcYC1q3Lk3la6QHkm2+oTY1tTac3jskjiW1NkgRMBqNuLpcsdsZnj9bcHo6QSrL0WmCw3B6esDN1ZZAhpSFoXSGJFZMpimbzZaHD07Ii4qyFly+WiBCidFQVZq6MjgnCVWENgaLJJBNej9Q1caTDYxgtdhycSF55517bDY7rq93rBYr5vMZdenIdhrpoCwqrLM+didKlBAU23Pq2qCtZ6MFSuGc7pU0JxAywFmNM3432ZYMoTzOaF17imrpn2TrevEWusAIh7DtelG9KJdtpnjLgmvXlSQMY1QAVVn0u8D1edJ+PfsFGSjlC40N9oPW+neH5p6tbvnkl/9fJJNjovEhR4/exiiHFMYnpAgJ0rd/aN01HQvGNan0zcS1/u7PA8sA8Jzdf78D6+ZHQ/NZDMCnBWw78H43AkXc5ZC3Y2Bfu9sP2vWuHi/JvU+ky1hs7qevw/JFgNcoiG4I8u3Nu4EQaBOXmo5Pg/vbY/mIuxZN+8V+Dts56a0j0V1jj9HUfn4HInsXmOjusRUeor+LXkcW+zC895eAvVlvy/F2Zssddb0TgDCAY1qnWnub7s7n/m/XlWkQ3f/7PIahFdEJlfa18237nDEEGGJhiKUjED4RTFtL7hxaBjghWV08ZRyETA7PiCf3CNIpUbHFGkeg4OggRihJVZTMD2IWtzvWi4KqGBHHEYEMqKqK3bbAWcduuwMnqOoKUwtWq5rpwRiCEG0tYRwQJwFhCM+enzMbTRBIkmRCWa6oK0MYlaTTkPWqQiCxztc5d4FgMjkg2xWM4gmBUliTsysyyqryjULmvjH04maLVBKkwxpB7SyIppSycU03r2Y+pfKvnWOc+kDtyckBDx7cQ5uaTz95RpFVBML7ycuiAid9YS0psMZSOUNZ1ThpGY9ScBZrpW+GYTx3XbeBygYWlPW0aafbVeHzPVSjGBjTxAQbZbBzq9oen9qNMoxh9aEth3PGWxLWNi1A6c+DA+swxudoCONVhbY0i2v8m78rwL3YLvi1v/WXKGpDNDnlwds/wY//zO9ndnoPmU4R0WiPqdLp3ANA6LTudqO10rMVmI1/rE+3dy2yse+kbd08X+CjbV1CXY3u9hvtFXuk6Xuj9s4F9sY11CRtP6b2H9FKfP/GUGEWgq6SYA+AXzjifgG0zcNxe+DaSCbahtsNhA3AfOhT7+9FNr9ruUmfpxYOxjD4XX/lQXJXc712WJ3vudscw9nbF25Dimr32rbo3Fgn4otm5s55BnfXX8V1QNM21+jAv1ky4k4lzOHTlngGmLAOaS3OGKRzKOWQ+K4expnmWXqFBeWLUG9vPuNy8YSf/Jk/znvv/hQX73+b2T3N4vY508kYi0WIgE8vr3jjzRPefusRn3x0yatXC7abjCiMCQJPz7PWV1mUUjI/GFPmOVpbst2OsgoJE59AtFzd8uDBCdPpGKelL6IlKu9GMJLF7Y7xJKGuBKPRGGMsVW0oy4zJZISSERfnt5w+OOPmJmM8Tjg8OuDgcEKShhhtSdKYFy9vofbKQW0143GItRUEDqzyrp5mLx2eHHD/3pT7Dw6oqpwsKxmNHUkccXR0xOK6pihq8nyHVA4lFVWpcQac9VmczjmcMeRFQRSGCCd9s+lGpLe04pZ40HeDa6rFSu9kbTNChRCoUHWBzT5Gx8DPLrrzONOfw/vzHcZq/0rKrseAUl7Q43qgF6LxVBg6RbZb2nJ/Dd89vhTgbp3j1fklxW7LbHrN9vo5Tz/8FabH9/nGz/1hvvYzfwCcREjVgJDrtWgGm7It3dppbR3k+kMMfFXiDuw2WmaPz0MA9K/3g3eCYcnvtkxBD6b7mtzwkG44MteBcwtyXWXDgdDpwKa9tts/cy+0BhMyFCrDZKVuOhq31JDe2Gq7Ay1jT7jcuSfZjNkL0N4KEHfOuP9KdOdk8F/RCbQ+KNre90CM3UXibiO1QCtFK8vEXpvC/mjnuRVaPjvaUzUH43e9u68LWmObjNymdn0bPHf+eVkHSvpEJKFNsy68m1FJT/lVAoQUVLpxwwiBkyFGBggVII3ltXuP+Ee//v/g1/MXnJ49QNmMsjLoGq4ub4gjSRB767Usa4rMM1YCBYdHR9wsbtlklU/WAXTtiGPFo0dnFPmO66sVVe0o8oyy1pyczTFWEseKg3nKbu3peUrBZCxRSnF2eoi2NdfXOx48iIjTGLPdkqYx2S7DacV2W2HPVzgbUJUlWgdMJ2PCyCLTgOW6Ik4jhHAEUYR1FW+/85Aocixvlyxv86YhiUU4yXq14uggZnm75XaxYjwd8fTpSx48uMduU1LVFc45kiSmKitwiqo2ONtkk0pPabRW4LTBSUUL2wLQeO+A85LYLxPhhYSv846nKTrXgbtSnj7ZAq1q1puw9CDeKiqyp3N3O9DR5Ow5pJJ7xDelJEHgYdlo0wue9oeyTYxsqOE/5PiRwV34NnvfAV445/6EEOJtfP/UY+BXgH/TOVcJIWLgPwV+Gt8Y+0875578sHNb69jucpJ4hFMSbUvs6gK7W/Pdsubw5IyzN9/D2ZbXPUh0ae7U2IYj3yBuJ+GGIN1122nf7k2bfqIGICB6EBoqkP3vxeA8A+Bpf9O+7LJR+zc9rDZtssRe+JX2gkNqoVesezdG57IB2qBlL8SGED7QlcWQk++6wkP9+70G7YVkq5724x6Cs/+x9z2KZmIccjD30PLCe7Ds79E1FxJdEXsfGxhSLuUgWD2UXV39FlrQpROW3Vy0wNxZII2V4XpLZXgOR2s1tOuil6ACh7AGYY0XAlY0FS29uwXtAUUJUBhiAdJ6c9o4ge7cDf43xkhqJ0H6d61SGBmgREm1+Ijs9tex5RUf/tpvkr/+kIsX52gteHAvwWnDzfWWcpFhTECuDVIoRmPFV947QyrJ/OAhH3z4gqrQGAcOg7Y1nz4+J00jysJiLcwOxwSR4+bqlgevHWKpCENJEBiWqwWz2ZR3vnKPsqh5/Y0TXr16xcnZGXVd+kQfZSiKmrKQYEKsk8RhjLM1ZbXG1op852mDSvn4WFmWCELiWBIlCU7kHJ0dgIpZFRsevnPIOBjx8rMbsqzmsycXXF7GOCFYrgviWHFxsWa3KzBOYqz2rh6gqr2F0u5n5yxSCpRsrBjjd57BFwwTpqdet1x2gUWGAWEUYLSGQdtg55xnxeD3psVh25Lasq1oKsD6mItSAVJ6tpAxGueEj7M0sS0pBDL0e0YpCVJ6XruU1FWJsyCl8nulLViIwErHcJd90fHPorn/O8APgFnz+j8E/vfOub8shPhPgP8h8H9s/l04574ihPgzzff+9A89s3McHo4Iw4Cy1EjhTZ5Sl7x5NGV1/owoGXNw9qjTDLsbHmrTnUgcaNCNIGiBpVWQQXRJNUNM/aKjBQDBPhB2ErTVdj9n3PtfiwG9pa373oLifiRyoEF3oL7PXOliAK3gEY3F4jzk+R+1gDwA5sF422u1/Pyh5BrS80QDwP7uhpr2YGENJ7AFQVzjFxQMgdk1WtGef12InuU46FTSPb3unHsPA4ntwLq7vAMGDKD2Gv0U2IErpe0VZbvb6ErT0K4XOqEsrEVqjdC1r7fTbE4nhf/MOB8slcJXNxQghG2WY1sG1iLQ6GKJrmqC8RnGBdxc/YBoHDOavE0gKj75wV8nf/XrJGHJZByjqxwhJcV2izsNUYFgOh2xeHrDYpExHo159OiUKBbMZ2NenZ8TJ1PeeO0+n3x4iTGAclhjuLne0MYDwkjx+jtn5OWSqtTUVYnR3o0jlePwcEpRlIwnM3a7FecX5xweHSClw5gSay0nJ3NurteUZYl0+HK5wlLVnnK5XG4w1hBFIQjJeptR5b5tXVXXnJzNWa8LTh44wlFAMlWcHU9IZcpsPOF7v/mYYqvJsgKkIC8caZpS5D7DNI5TCuPdUCZ0aF35td0kGhnXJBlJr6uroM1+tyipIPABUhpgdwLCKCKKI7+npAShPaulNyVxjXBQ0vPSHT4eUxuDxBHHIc74wmxCBv41AXlW42xDIUagggAlfBORsiyx+JLDErCmUUCkhKaWjBMDssY/D3AXQrwG/HHgPwD+x8Ijz38b+Dear/xF4H+FB/c/2fwN8FeB/0gIIdwP4e4IKTC6ZrNcU9WWOI2wQpGkE5588jGLtebnz15DNOQjz5ZpiEjSV4ZpaY4tyLc377WxXkPr9fOWC77vntlL6+1YKgONk6GF7wM30n2+rnxXlqC5Wo+sbQ0VQZ8V2unQnTawdy23h1f+ul1zkbsSvNe+W4ZG/5Fpb97rkK6ZK9GLItn9ve/i2rcEhtcczMvwXTFsZtFrud3guu+7bha6WvndldxA9g206Dao6YYT48/7ufZ4zXU8cNsOtOXenDab5s48ClqFwPln5AyBAOkM0nguspUCKaQ3/QU44TV1Y/ydOQRO+jFVu2eU6ye8/OxXsTrnnW/8y6j4lM++919gzJJ7D99jPj/mxce/xurlC+ZHY44OU7JdDq7g7MEJVW2wxiAIGY2m3N5mhKGg1jlxElCbiuOTQ26ufaZnEDSt2ZTAWUutLWkckecFCEe22yGUYz6fIETAeqkp8pwH94+REvKsIs8LTs8O+PD9Z9Sl4969Y6rKIbUHqt22boDIUJYVt8sFeVEQiIBaaxCC6WTsx24DhJBUVYkrBS+e33J45guaJaOYt996DVuWuEqz2eZoY5AqIEkDVKCa/qIVSRoQRp7JAo7drkDXBikVdV02a7Cv/umaZ2NNw3KREq1Nswc9zbAlBBhrmy5VAmOaFogtsLdrT4C1pnPvdLukEfxJGhMoxWqx8cXJ4gBjLTm6CcT6Gvi6dr7GTV13gO+MFypC+BZ+dVVB00XKNffyOwE7/Oia+/8B+J8B0+b1MbB0zrXtt58Dj5q/HwHPAJxzWgixar5/PTyhEOLfBv5tgCAMWC9z6sqQjAOm0zGLTclmmxPIDaf3HHq3JjAGq1QHhM5arPPRZiFEX+O9TUxpJ9611fYaHnmXTeMQjc3VuT86JB2qf65hw7iBktsC/hCoGr+t6wNrnXXQ/6rXAAYZmJ22zBDeBm8ODi8nDX0AdwDGyIHx0Luv9gwLQHTdnfbtDa+0NuDdfrexHjr7xNG5oe4Mbc8y2Pu0AeL+3f15E/1T7b7R4/a+APMZfYNrNH7JYSmBPUnDfpmB9pz9CO7yeXqXV8cd8hEvjJAY049VOF+fREuFk34N9s4X0cyTRdmaZ4//AeeP/yHFakWapLxf7FDRiN35RygMT28/oyggX68oa+/umB+OkTkcHc6pKkde5pSZQ9cabQVn904IAw1Ysl3GdDYiigKOTyaUhePRm3OurtYcHI4wNVxdrfnGT7zJ82fPMA4OjsfgAlbLnNVNzng6RsqESmuqskAFIc5JqkoTRzHL2w0XF0sOD2ccHk5ZLXboyjFKEpzRGK3Y7iqSeMZ2tUPIkMl8xMn9+6Rpwg9+8H0sjjBUGOs55ljnwT0Z4UzJdpWzvC7BJQRBRFnUbDeZT95REWEcESeRb/YRJ0gUURQhhWG323Xsk8rWOOGrgcpA+SdmvIJjjcZZiVLehTNU6pSSSCEJAoVSDqstttbe+moyW7U2WGG8ktkoUtJJxuMpznrrIQgk0+kIU3uAFjIgDANqY5rAv0KpVrAYbwnaAaZ0OqY/V5KkbLKdV5buWPRfdPyO4C6E+BPApXPuV4QQf+h3+v6Pejjn/jzw5wHiNHFCBYxmIaNJyHqbY01IGKS8ennD9e0/5fJmxze+dc5P/t7fx/T0pFOGgabui+g7kzjZMBWgz9ZsfeeN9j/wP7fBMoTopePAFdAlU0EfTW+h3AlEx2luzHlarrv/7dDp0oqcTogIh4/mQAfQbTVHNwTI3k3QvKRrutwOvzlHVzqgcZm4DrDb+wEhpC/14FxXPLHHygEqtvPSjK1juOxJg+GY2nltTRVH6w7pXB3NDLQZnBY7UOjbpnQMnsDeYPbf7Z5FN6v7Y9oDdXfns3YsQ2HSLYpO8OGHiQhUlwPhmjnxrhmFEAqU/0xBk3jnkBhsuaNYP+X22W9x+eQZzoasg4JguURIyfX5gslkxNHxHFvlzOYx984m6Lpms9qyuNlQlTCaTEiTMaFy3N5uCMKAdDbG6orlYk0UJazXFXFifLJQCG9/5ZDTewlCOPJSU+qYqspIx5Lj42PCwJHtjPeJh4r1ZkscBVSVJAhD8iInjBKKvODBg0PqSvPks1u22xyhAuraUtuSR/dOUSiePLnEVIqzs7dQ4goVQFGvyYslKkmobe6JCEJBbajrGusilsuMJE2oihyjFdfXO9JEMpmNUWzJc4urfHciBGw3Fq0lVteEgULJmqqqqWvdNeCxxluP2llkDTJQmNaB7myzVhsXiJA4a5BK+dIJ1qIrh24YMdaCsxrZJlo2iuWQneesJdtsUZFEBZ6REyhBXXhOv1CWQIFUTaaptg3V21FX/iKyTcB0dPVmgkChAoFQBhU4rG0SPO3d/bF//Cia+78I/HeFEH8MSPA+9z8HHAghgkZ7fw140Xz/BfA68FwIEQBzfGD1tz2EEGhbcjg7RinJ2uzQteHw9Ii3vv6TfPTxR6TThDCR5EXGzAqc8JJ0LxptDY4A6wzGVih8R3MVBIzTiQ9CCNVgUh/ok7KlGDlfnXJgevWclm6w/loda4fOTz3EE4/bLRul+bQLkDoPrJ0B0bNgWv+9bM7jOsW0B7CBjeEBrRlnp5QOYxHNkC0MpZO/ZsP0cLKtQ/5F99JYBa679fZW9nTzToB1gqGfw3ZCRCdEB98YWAU09zMUdT10szcA1wbAB0Hl7lntgbfb//tz8mJogQxtmF74tHaRE4ACISUyiJp5aNw5zUT7+K9o2DQ1Jl/z8oO/g9k9Jls8AycoSs00HXN0kFBqTVFq4tRQFhpnNatswejhWVPzRVDkFeu1QeuQdGSYTMdEUUBRaDabiiQegYi5ud0ynY0RMkBgCKOQJBKMJpIoSghzw+FxSRQ5z6IRhrKhSIZhQDxKKcqCuiqwVpDlJek4IVAhRZZjhaW2FbU2jMMpm21JVRXcezDHYvj08XM2K4uIErabDWWVU+0KtMvgpmR29IYnPSjFdJqCteS5Jk4ShAxZLTcU+Y46U5Slw9ocsDx6/ZiLV0tWqwKnLXWlyYuqs9iN8h2SirKkrjVKSLSuMdbHQJA+uB0IQRCE6FrTiOAu8CqhCVj6NSqFxBrrm3BY7/9WjdXWVWSVsmue7ZxoinwJjNMUhd/3Co/BDpDOIjAIaRvrTyIVaGtw0hFHAfP5jPVqjTUWpyGQIVEUEkaKOA4YTWLWq5wi13tJTV90/I7g7pz794B/z+8j8YeA/6lz7s8KIf4z4F/DM2b+LeCvNz/5G83rX2o+/7s/zN8OIJXk9OyA3XrHdlUwmR+STCQn94742jd/EpeEFKXm8vocE8Yc33tIGCucdT7QQQMKDqwpWa4uePHsY15+/CFKONLxjPsP3+Dtb/w0Ip4hRN0E01qfrhtYAgP9rSGdukZT69g2HQOkAeU72m4LMoK2ZojX3rsGIO19D7CmBZAudtC4U1wzmN6SaIFk2LsKhup3q7HvzXFzg11sV+wXz+q15dYl0QiBAX3U0bCRWmDvpEAfW+i/2cxdJxQG49lbDt4vajvKlxh80j2J/Xfcfk/dzoJoBOTdUhK9iGjO0n0++G17v7QCs5375j1Bd81Wc+/sC3dnMqHJqgahM1Yvf5XLZx+yW+9QYUCgS6SoWK00t7drzk6PQNZcX16zuNlydJhgTwXxKOD6ekkYpqggo6hqxtMxy9slUoQIY1lvM27rHWkyZbszaF1iDMxmEeevFtx7eISUAm00ZV5xOJ8Sx5KyDCiKmsPDKcvFmiyriJKYNAkBTa0Ns+kcbWrqusI6gYwSpNWM5zF5mREnAW++/QAVaMqqIAhjVKTJ8oKb23N0lXcNLla3GZ+8/wJTCaS0jMdjVqsVRb3jME4xOmN6coQzNdtljlQQRILpZMJsnvDyZUkYBSAturZI63wIxVm0gcyUGKt9clLLQmseX9vqUdcaKRWyaT7vs2GbGlVN6zFnHbrSCClQgUAhcU7gpC/Z4NkrnukmhUTJACEdUioENUGsUEGMrmqsNSilCILQJz4Jx8HRDBUEnL9aeEu22SCBkkSJBFVzeDxGa8N2nXltPtAIaYmThIPDGWVRYrWkrg0/7Pivw3P/d4G/LIT494FfA/5C8/5fAP6SEOJj4Bb4M7/jmawlRJGtc4rCUOpbjg4PWFyc84t/97/i7OFr/LE/+ac5ffQOOpCIyAOMHJQlcM6h6wJbrfnuP/mbPH/8fYrrG6hrkAHfD0f8fFnw1W/+AYIkZAgCQ2YN+Ei2RHiammuDaTR+dzpB0PKbvWthCG+t0GhDpn0BIZpvteUQesKMwwf2eg5urz22jBzRAe+e24heEIhuDPQg3NxaO3zbCIJOW3aNTSDYCxx3nwtP3ercF632T+8qGmr6raUh2t92c9JbPcOgtLdUhvc0FJSDo/Oj0dlTe4XIulhHH6ru3HF7p9nXNTqB0lpSw/sfDOBuQphr7rfX2vt7FDiwlt3yObeXT7k+v0Vrh3U1SRKRZxnrTcHNdc506rj3YMztzYoydzBPeP7smsOjEVIm4Hbcu3/Es2dXrNeKw4MJVxcLrBaEQYK1mpubJaM0YbvdsdmsSb/6iPEsZrvbMJmOWK9z8l3NdDonjkPGE4uxks02w0k/T1mWMZ2l6NqQWR+gVEqBMBR5jbUrVOg4ezgF610iQWhAGqJUEsTC0y4t7LIVSoBxzrNvhGK9KNHGYmzNalGw2haMJiO+9o23WK5usa5kNE3IMksYKB/AjiFOFW++84CnT6+hUAhhCJSnNQon0XXdpOP7yIq1Ft/+UnpuuvbuFm85ezaQoG3e0wv6tuFG20tCGM+GQYISCpxARd7ycFZ6FlJDg3TOEscRTnkNPFSCUHqcsUWFa1wu2bak0rtGM7MgJaEKUUCceC1dCMn8YMLBQcp6tcUXHYey3KF14uclCtD2nyO4O+f+PvD3m78fAz/3Bd8pgD/1z3JeYx0vX14DAXEUEo8ilHJcvnxFTYStAy4ur7n/7ntNFTXwO7wBSCsoy5yrF59w/fJ9Pv7NfwS6BIsvki8ksan5pb/9n5OMRnz1x38a3ZjOQqhOI3MNyErpvK+C1mUgkM6B9IEXnxMs9oBIWu92cNYinUMGitrhA1K0gsEzKnqGSqu6N0KFgQAQ+8DWBQRbDXfgyvAmn+u1byH2aKLuzvlE18pF7AFY55QYarbN+21lSidaYHadh8crzA39sXnd+auFuyPA3N71/fn3gf0uGA/5CHSj7gWYZ8j4X/UKtNs7Rx/YFvveGf9w6NkQ7QeDBJGBwFPtzd0ZY28nNDfuBNIZHn/0HZY31yxXC5J4jHOO7TYnHcfMZnM2a8PFxS2jUcDh4RF2BrUxrC42KBnirGY6mxAEgocPTimKiiCICMIYKyW3t7cIYoSQnJxNiRLIdxVXV9e+dG6xoyoNRakJwqjxS5dkhaEsDFIZTk5mRJHX0I3xdfPTccp6kzMdJ1jnqEqfEDQax9y7f0y+LdisM7a7Aq1L3n7nDa4vNtR1SRhGOKepjet6NDjh0/KrusZax/nLG9JxyHQ85dNPnzKdjnjj7YesNzturjeMpiHpaEKeFXz88TMODg84OZuyXtWslwW6dGAahouUg7UlkFI1bCVHIBUI58s2RN6/LdvuLU5gTV+w0BccbEohWIdU/ntSOJA+HmeMtw6klKh21TpwpvXPC2zocSCIApQMKYoaKRRGGyqtCYOQOApRoUAGMBqNyLIdZVETBCFFviWJDphNpuAE5+fXhComCCSL2yUYhy1rhB6uwM8fX4oMVa+B14zSgCgIicYhWVYTxgmmcog64/H3f5UHj844uPeQIEmxLgQ8oOoq4/bVR3z8G7/Eiye/hd3k1HVFKH0X9iiKkNJQb5c8+a1f52B+wOGjN0GEtDVq2sPjVOMmaLV05wFPiCaG0SzWdnfXVUm2WmHLktvLl5ydHSPCEUQj5kfHjRnfdlpqzjNI7ml0UK9vDrTHNjDqnI/VtT9oNUbRaarD/zZ/uX03Aq6Hq323Ta/Fe1dQo+IPtNDWfeUGAq0FaCG8hTPMCm4v2fJxZTeSFujvNjbsk6DEnuo8FG/DZ+Ra/Nx/f5ikJFRjPfQisLNgutnqf97faesY6wVlG3zzv+8tKF9MxM/lHo1SWIRQBCrg5PCY1XxCEimWtzuUirm8umF+OCMIBW+/fUqeFyRJQlkY37hBW25uLDfXWx48mDEaRayXG5IoJQwT1ustVV0zSsccHM1Yr0rGkxFJqjAuYDpL2GU5221OHEdI4ZkiYagaDTJitbzCWU8xXC63JMkIkBS5wWjJbleha1gtd0Sxd02UucaOYmxdI9CoIKDalSTxhPWqJIpikiQDJFUpSCeKJE1YLwtaZpa0ftqEU7imKNjNbc50njI7SMnyEnDce3DI4cEhn3z4lKzQTKzvHapNhQqgrvzztraxzmSv7QipkEp5qqLX4XDOecAXIGzTd0H6cr9t4FLhq11qXTeWufIsF+VXcKBCkH2masu6dQ210jqLQFGXmkBKNust4LOknfFZr0EYkCQJVVmTFz6IvF4tqWvjKeGVRTjB9eWS5U3WWBG+3EEURQQqoMwMQpg+p+m3Ob4U4B5I+Llvvsl4FBGGERa4udnx+NmK+SRlom7YPvunfPu/POfdH/s9vPbOV5mevYsmQOuS55/9Fp/81j9ic33LZnHLdrMjTVMwoCuo8oI6URhX8Ju/8otUCP47/+q/6V0g7cbtgKx1T/gKeo0B14D+ftHZFkyjMCI6OmJzfcuHHz5GCsl7P/kWhDHggaLnprZg3Wihe+6E3mXgr9fw9NtrNYKl/Z4S3Rnp8jAHweABHYjuCp0PeaDjuvb/fgO1wq1n3/cA5rrTtufpx95ZB/1lG9nRByXbGEU7r935hexe9yZGf762SYuv/CkHwqe3QERnJTQuIdmMupfD7eTtWSd9UL4XFK2jSwzdUe2tDTKCffxlPwQsMAgswmYoqdmsNpS1QRBwdbUAp9htKsJIslptmUxG3F5vWK8zcBCFIWk6RUhFVQuurrY4I8FWhMkIIUKy3S2mtoxGKUoW5FnG4lYQp5LJLEHbiqIskUpQZDnjNEXXGqM1QaCYz+acny8YjVO0LqiqEq012a5o3EeKdJyQZxUqCJumHjHWQbYtmc1GLBaXzKdjtruaq8sFu+2a49MRWgdcX+ZMJgcEIeyCCodqGj5rwiCgLA1VaYiSAAjABFxe3IJQ1Lljdbtlc5txeX6DjEKidExdG6zI0abGmOYJtZZB+zxaxUF4inXn7mxcgcZY34PU2o5d59kvfu1EceT981VNXRmfhducryoLfAY1iEA25210J+eaImBgjaSsfdVGpXwOj3f5SKgF63LjSwsIX/NHSb/CrDHsdrlfk0JQlhXONO39rCDfVVR15jnxgBnqPl9wfCnAPU1CHh4nbLMNu92GMIg5nivGyZw4HhFKhzE1Ia+4/eCam4//EY++8i1sGFLpiquLz7h5+hhnIpQQXVuwstK+iW5WomSIChzOFbx6+inZesH88LTzCbeBTyEMzpboMieKxohw3PTSbhKH6Dd5pzcLECpgenTI/QcPmcxOIQgZliTo4UE0WZ8DbbcLYNrGIuh+0Nd96dwPLej333ODEfUOAtirpTPQV13DvW7vql2gAts19WizOLtgpOtrzreWTEevdINA6MAo6HhGA4E1EAUDH7UDmiw/189UJ0DaDbSnyLcb0+358EU/dX3Atw1ctNZEKyDbZ9BQhJwd0Dxptf5WK/QZqaL/Qu/KacsJttUArUBiuLn4Pk8//Q5ZVrK4LRBEREHKZrPmYlsxHk9YLgu2S4eQEEcjttsdoYrZrjMWdYGupyilKLIcJUMmM0hGkjCIKHPNcnHJZDIjimC9LDiN56xXWyaThFpXlEVJHCXsdgXj0RRrC8qqIssKst2W+XzE4fGI0XjEbrsligLW6y2Hx2PGE99wu9belYK0yADW64LpdM5kMsJabxFsN1sOD32RsJvbJeIGri43JKlqeAmOsqxxzpGkEdYWRHHMO++8gVSa5WpJoBLKuqQqDNuVZrVYYQwcHE3Jd74HaRRF7GzR7FvvW/c6mGj+7yV5S0W2bpA/LhuKtG0UN9uXHWm14N1uRyAVAtWvVdsoDJJ+rTnvZsI1gqFhWFqN78/arDfX1I9p94o1DqPBWl8ZU9cGgqafqjaAJAiDhpJtMLWhKixVYTsFRhvb1Lvhhx5fCnC3xreTqmvJblMQKA3UTKcTdqtLojAEBXmx8VLLWi6efUoQSSbjlCgIuZ8E5NYSqpBbG1LWhvFkQlnCLIoJA0Olc8I4xuQLfuUX/gu+9o2f5P6bXyUYzxBN1cNqfcn3f/OXeP7kMV/7xk/z3o//N3BRgpYOgfL+t0bvbie7hZNASWbjmKOTU7QzBNohTcPxbupGtA9d0BaNAif8Y+hoj12CTQNQA2ZGqzkOLTJP09t3cwyPNrjrX7TaJ7QqbRuQ7amEfgGrZv14F5XfBEGzgTzFc5DALxrBMATTwTg+F3httKFWie+EUKtBi4FgG4BwG1huzeFOMHbic0/db2+5G8uQ0++nZfD+cHSijSkMrJ32nKK1Y+7MdzPPAu9+ePnkE6psQVVVbNYbonDGbJ4SxxG73ZZstySKA6ytsdqw22YYbVivCnQtODmZIQjZrDOvWVcZFkuczr1ml9VIEVIVnqeutWOzzokSODqJCZ2kyDdoXZPlOdttyfHRAdN5TBBJwkhRlBmIiOvrW3RtGY0TRqOIKJJcXy0RTlFWJXleEUYRVeW1++h6TV7kVJUhCFOEDCgKw3a75fAoxdQJn3xwQRiHvmYKvvVeQsBknIDQhFHI8fGcm8UrjDWMJjPMdklday7Ob6nyinSUUOalb9whQ7Sx0GanK8/3dsY2yUDewmsbWLsuZb9dWv7hycbi89p6L6jbiqLa+lo9TnjBLmhoj8o34rAO6kojFANLWfTLQIhOCVBKgQNjdWOF+4xh1yROge8AZZ3DGUHlfHA4CkPv149CAhVSFTVlUXVjsWZIBPni40sB7rU2fPLsFUkUMEoSTIN6VQ3bvEbmNfPDGVm+BedQgQfXMAhZr7fEQUCaRgTWchSPsbFhaQxC1ESRIooSJI5yUyIQVNsV7//aL/Ps8Sf81B/8l/jJn/0DCCTObnn8vV/ko2//Q+qq5peePSMOZrz1E9+iNl47c8JLVNsAmMSx26xZLRc4XbO8OedlOMIEAp1dYXc3xKHk5OQUEcbcrjJ2Wd6YlA4ZBATJmDBJefMrP4aIUr8I2gVJv2gQncLaaJ+9lt6bh/Sqq2s+da37gA7CO4aAoDuHX599ELnly7fv+xO0fmaJxEfrZXO+FqhFs4A7F0wjCfvF6CsleqHVquS9pdBbSXcYRXj6qG3cZG3t7/ZeW8HXSF0/3D2XF3RF3Lrf9fGAPqLQxx6GdsSwsKY/ve2YWqLzvXsuMxjGyZjHyx3j8YyjY8l6nYNMSNOE45OYy4sVziqCGEajiPFkSp5XZLuKZ8+usE4QxQkqCNB1SrbJ2G1zxuOUPCuIowSE56NLAvJdRq1r5gcTysJrtWEYURXac8IR1FVFpR3TaUqaxtQ68f5oDXmuiWJHEAYoqdgsS8bjKYGMsKaiKqAsCpRSrDYZRVHx6NFDbm5uKYuSUIVMpzOiBLa7VwhpcdahQk89DALlA7hnYxAVVQ1XVxc4WSGUYLPZEAQhAqhrg4piVBixywqKvCZNBbP5lM1q1z8IKXzhtkFQ3NEQG5q13tZM992MXL8muVO1sfFPertWd52SrHDEQYgKIQljdjtPN/WlDARKKaRsatQ43wsafIC1KAq/lhu/fMtfbttZOut3ph+Crz+EFVjTLmVLqWsf6G7X6u+gsbfHlwLcAUpdI51is14TjyImkwnrXcW2NARCcv3pC+azMafHh2hdEsgAYQVhEKMiRWUsprJU+YrDUcJ8NqKsayyO5fqSKJxyOJ+yXOdsljsOT0cIIYiSGIFEOcvy6oKLzz5E6QIs3D89RtmMYnPFzc0F8/kZs+OHGNXUeQacMVhdM5+kKDnj1aeKk0dnBGnKyx+cM0klrz844/DwiKKuMdtLst0F1jiiMKSqanIj2NaGo8NjZg/e6BwCfhW2tWjotEb/p8O1jB4GWmVzDPB9T3Pt3DadBtpnnnZ4Zx1SBNT5mjCKQBqqPEcE3lwUQYQUYRdgFQ2w23blNucaVrDsxtXcSL8RB7GNxiLxX7GDJI32Xx/8HmaA9vfau1T2run6awnZ2Rn9rxqJ2MqDtnTw/g5quf+ujze4gWARzVkbhoygRlpDEjqfnWglozQBFNkuYzKasd1cIYUly0qcE7z25n2UklSm5GiUos0cXRmybMdkMqYua6xzGCO4OF+ghMBUOXHilYGiLL3bTiturtaEkWI0URSFb6hhjCUOI4qipLaGsiwZjVLCyFMOpRIYW1MUBUfHR1RVjdaObFeSFyW6FiyyHVEcMJ6GOOeIIh+Qfe21U46PZyxul+RFhjaK0Sji+ESSF6VfYQ6s1YSRI4odb759n+vbNZqCo6OUXbXD6JJyZz2tUUmiJCIehWxXJa7RftfbjXevqKawlgAVqt66Er4ejHHN/hiym9rgUrcWe823FdLd7nLtCrGkk4T5wZgkidC1YbvL8dnpEonCGYeVzueAWNs0C+nHgjN9pUrXl+ztCRMeuG23l+k6PVlrMVYjmtoyd0sl/LDjSwHuURzyla++gasdF69uKbXm+mZFVWmSUUoUBYgAVByzzkt22w3rVQZOcXQ4I4oVZVlRlIaDgzk3y1sOD2OOj0ZUVcb8NAAF57cb8jzDyZDrq0sOT85I0wSUQ1hDKKDIS4RwzKYplxcvSD/7gIP7x0zDgo++98v83B/8Ezh8+VGsNw/nswOqfEUQhoTphDhJCZOEJAp58/R1JpMpVkqcqKmLjHyzROsaNZ0iHeSrFTWKQInev7wHVg3UNBpi73u+W8+5BbT+wXeLaID9gr4T1VBfBXC2Rucrbl894+knv8Ebbz1iubvhk8c/YD4/ZjI9IEqmvPOVn0aNHoHyrALXXozWVdKaoB4oWw7y0P8O+OBtq20PNHgY1vtpLZW2vvUdE2WwztsM285R07q0OuAeuov6Ugd0Y+sTx1rfjaOpwT8worrP2nhD83eVLVhdvc/xdML1q/eJlOTxy1ccHBxiTE1VGa7zBUGoOJvPefb0mnQ0JtsVXF2tME4wPxgxGsecvHGfujLoWuOcxVjTNHQwVNphtSNfbTyX3LQAKtDW8erFgkevH4IMyLKM+XSO1Q6pFHGoUQrvh2eEMZbxJCVOfBXHV6+umE2mnqK3K9EVGON8kSuhqUrBW++8yWZ9y/XlOUmakKQxjx6dUemCXb4hCBwnZxNubz11cDRKqXTBa6/fJ8tXnIxDzu6PqK3h5N6E2cEI4UI+/MFzgiBC1zVJFBIIukKfzoJ00gcthe2sRN/D1LcZBLom0lqbbv9Y1/cq7q3MhszQKCJ3D4EA6WvMFEVJECiWy1XjXxdgbeO+864hIf3fVoBx1gsX14O3JwTcWUN41g7WdqyytvSwla3a1lizos1z+dGOLwW4CynI6xyhJeP5mLDS3FzeNLzTmrKsCOOEIEop8pLKBETpAcYY1rlGFBWLxQpdKxarHFzOKDkjFBNkIKnqiqoyJDiOpzF5PWZxsyRbrzFliXSGIl9yc/uS2WyG1DkBksODmDRQTFXNe199h6vn51BskCOHFQHN6mK7uOAH3/kF8soxnZ0xkzWV0cSx4MGDe8wPDtlud1xdZahAcXRyRFlU1GWFMY50NMVWFhUGLaT34NIqka3PAzzIM/hcDNwHol2ofamsXmlv3ThiUAXR+yVlwzRZ3d7w/nf/Fpurj3n16Yc8+2DEeBZzc/OKIpnzAijKLc8/+Kf82M/8KxTW8fDB10nSQ6wuCeJRMxJBW+Onv/ae3BmEdKH143dI3p5l6Ica3r+gcYH0AqAD2a6scs9iace0F2BuWTXN3O41Rmi1KkHvj3eDjSX6YTqcp9dZy5PH3+bDX/kbPLp3AqYgDCEIQ7JMgw0p84IoTn0pX+P9zrODGUWZkeeWMA6pKs3RwRxnDVdXV13TiLP7R+T5ljTxCU/b2icFITy321rvCugKW1lvHVojyPOa3aYgiiKm89S31Is01vr6LrvdlpPTY0bjCbtNxWqRA74VXlXVXXxjfjBHmx27zYrJJMWYkMlkymq1Ip7GKCmZTWeEskIgmM3vowLRnMtxenaC4ICiyHnvK6/z4tULRknEJA1ZLXLKovbt8cqKMoipCt8CLw5jdF1jhUEh0O1T7dZ76x7x2q2SAtskIbbWnF867Tq0CGTDDGvzLvYtzJYYK0SAqQ3WSK/P4SWOZ8j4ciWqGUcX3G2UDF+3RnRKQCdY2vUIONv2BvbrXcqmSYjze7Ndn2KwH/YtjS8+vhTgXtWabVaTBDF5VYBxHBz6FFwV+MDG7e2Sql6ha590EMchcewL4ZdlxShRGOmIIsdbb73BZKKoqQkCR+AkTgaM0DwYKUoTELqQe0chN0++Q377IVJojg9mvPX6PQ5//F2ePX3BdrPDlivy5Uuq7ZiXTz7k1fNXnL35Nm+892PEkznOGEZkfPWNQ37wwTOmMuMsqfj48gana3b5jjgJuL4658lnn7Hdbrm9ueH2dkUgArZZThilpPMjRBg1QO16Lbaj+/nDs1V6d0Dvrhnw3IWgDToNtVTRqD8tW8e5AIFF4ZDaUO6umQcZJrtgdfWUbH1NuXW4+oB5HBEFBatNAblhd/kZT7/3t3l5c4X42T+JcZ7p8OPf/AOIIKJpbdNemlYQtcHPztMtm1G2Gr3sO9O0mn7POXcDYG+P/rxt7fkWoGUn/AauqW6jDCwA4TNw22/dBYLOIGnUQOenvjmvQ+OQ1lAtP2Pz/Lvktxf84OIzZvMRxvjElJfPF0hCqlqz2ay5vTVIZalrQ56PsE4TxxEHx57/Do4Xz1+haxDCEMeK3daX8bXOcHw6R6mMV69uCWWManjdxmrmB1PmBylR7KjrHF1rtmWONZLc1L55hAs5Pp4ShJIiz6mrhKIoKIuK9TIjIKKsKowRWCMBg1CWs3sHHB7dZ7tbMp74pKwwCJhMJmijSeKI29WC0WhCIEEFAU4YZrMJUThhvdrx6uVLHjx8AFYQRxFFUTEeR6x3axCOo8MppjLUpca19c3DoHGr+QRBqoatYj0Ix3HUdEjSnuboIJQKY3vlwTgDdpCb0TxcqURDdGoDod4t0pIZsl1OGERsVznCBmCa5tQNfVfKpj5VZ815X74SXhh4d5oXAlL4GECrkPWKhF9vSvmMFmNsUxen0dZt57DpgP13Bbgb41isCg4mgjBWTCcjbq9uGvCG6WREmgZcXy2JoxECiQwFk2lCGCqqKkU4RxhAmqQgNFEiiUYRoYgo85q6sqAs46BkqgTjNCSK1pSLj3jz5D1+/uf/mxwdnfLpp4/5yntfYbvL+f73fov33/8Qq3f8zb/5N3n57AlSBuzWF9y+/JjDw2PiOGaShAhVUOc3qDLmwUHCB5/cUGdrri4Ey+UVzjrm8zlFkXN4cESaTMh3OclojCOgFCAs6HxNGCikjLGShpEiMJjODPVH6+6gMf1EH1AdQl/r1mmciEKAsMI3u7A7dpsrPv34NwgpWF1/yGef/RplVoGB2pWoeMTTVxccTBNef2PO0aGEecBuu+Gj7/0y04MDnn3wbc6v15zef535/JB7r71HlMxowbTTrkU7oNb54Zr6On7gbq+kcnsfg/vtNOihMdMKsNZf2WhrwjUcZTEwcO4mWzWioNXmOrfW0FXTXqsNZrWCRnRlG5SQmHrDd7/z17n49DfJtgW1LgGDttZru1XAzfWK0SigrisQ8PY7r+N5diEvnl2iVOQrRE5H3Lt3ghAZZZFzeHSAEI6qsrx8seTgKEUqjQokURhgdeP2Er4BhdY1o/EBKqxIR2O265Ld1idHAWTbmqrS2NpxcDhFiAglbGPoVGjtqKoSY1zXwCROJKdnc6LQUZc5YRj4jMuqJJpOSdOUy4sLhBgzP5gTBCGjUchumyGFIs9KbnY7truc7a5isdyyzTLO7s0IY4UKJJPZiAePBGkUU1eG25sdSgVNfAXGkxFVqUmThCJfNs/GP/e64ZXvlaCQEusMQeBBXyAabrtn1tim/SE02aiuXQMS2WS2Omua30qM1r4fKr7toHa+s1Rv/vmIkXUWJZoigL6zC+D956LlXDbrSEqJkL5MggNq48so4PD1fJRACIVEoFTTfs/o3xHY4UsC7g7PmFmtc44ORqy2a7QwREmMFH4BHc3H3D89ZLNZ4yyEoxiNIY5DRKYRMiSOBUkSsdtqVlmOK3LGaUQgFYXJkWFIaS0hJbWpyVcFb86n3D+Zc/HqBXmeE8cBz54/wQEPHhwxn/8eHj/5jKIoePnyJTjHa1hMvWN9/ZLtdsePfeMrzOYTXFWwuL5gt17wwXe/w+HJEdvYcX51hQOSZMRisWC3zdhuM+q6IghDDg4eUKOw1Y6PvvtPmU5nfPUnf45aBGA1ztRI4ZBBCChMs3B8go1sANxvxJ4b0gf8vI+wT8RC56yuP+HxD36Zyxef8PGnP0AKwyhWGFOw2+QIETKdj3DWEShFnCRsVgXTsWIy8r5Q36yg5ObVB+xWNeV2w26747/1r5yQxFPfoKPxZ+4lMgFt9XVfNsHTUJ27m5ixD8It88XfYVdijS5I2oJ/+5OO3jJ07QyOwbWGn3SG0VAwDb85kDcSSSBgsbzk+9/7VdxuzeJyydn9I5I4YJdtqeuC49MxUQxaa8ajuW9mERiEkE2bOk1VarSuicOU68slZampa81iscJozXg8xlpFmfuKk5t1xmg0YrPJqWpf7jYMQ8q8ZLNe8/obR9zc3lCWmiiIycocKQLybQ3CUOea1e0WrWuOTg6YzkZku6qhJTt8fXHHaBxy78GUe2dznLE409RIN76G+c3NLdbBeDTBAUGkCCKLCAzpKAICXr24YbetmkqNMZeXa7Tdcnz2NcpNhjOacZywCnLGk4TJdMz1laeGChTjyQjnPJ3QCyGfhOQbzrSWFyRJwm67azR80bTW8zkUUsjGfeWtQO/L94IjipRff8ZiDB5gG60eDBbt68sIiUX4OIhtGnk4cMY34WhdQ8Z6LroSPlvWicaNM7AGO459o83LQCJkU6u9URqU8P1fhZBdK9Ef9fhSgLu1jiwzVBLSCYShpNCObLlllKbYsmCxKEnTFBVYJrOEylkW6w3WQpEZVtucw4OEBw/nBEohwwm1LliuS5QURHGML7dakxc1UiRc3i6pzKdcXl3x9jvv8nu++bOMRlOiOEXKgNurJcLBd779m0TJtGEN1L74Ue3Idmtubhf8Rq358Z/4ce4/eI1f/853+Ie/9MuEQUAoA8qiYj6bN6ZjirWWJEkZT2es11u/mKzBas328lOOx5osWyJMiXIWp3NuXnxELCsevf0Ot1mEiA8RGHS2wSCIx/NG36Bhf3iw9/7GzhuPNBbrYLN4zj/5hb/C00++B1qThKCNJS81oZTMDg9Yb3YgJJFUTMcBVVVTFTWhnLC6vWI2nxHFgm2xRUjLZHzEq8tLaqdYLm6ZHb3RsyYH7JO2JIHFgbXYuiDAYIzBComIx02nmrYUwaAOTQOqw6Bzx4ZprIL+z4FLpdPlaM0Y9mF/yFpvq17u1dzsD+FNYzH8hrOk4wmoCWW+ZHmzZTKegvDxlDTxPvB0FFPmvnvQbDahri0X59cEaoSuHWWpfd1uKcizEpzCWIEpNEoJoiRhMvOukM3GUFWG0vmMRtM0oajrGiEdy9sts9kI4RKs3hLHQQNg3vQvipqiLKDw2uFqsWO12BGlMUGgvWbfVAFTynIwm0HbYcpBFMeUua8fYwwghfft73Zopzi5P8doCIKI7aYkTUesljlxmFKUOc7VfPVrb+NwlIUGU6K1f1bnr67RtQdtrQ2BEOTZGtVUV7TOenqoNk07Pddx1rMs90ApBHHqy/vq0nlLq3HJKAXCkx19ar/wtGpfPdORZQXWWcIw8Pz5Zk2Yyj9x69pMaNGwV/x6CwJFGIRY1yQZySaq1bhhkJ72aBu/e1u0zHYUSsnh4ZzVeo014IxrMpM9G8fhOhfP7xrN3VrH5eUKJRVZVfHw4QF5pVjcLEmTmiAImM+mrFdbZvMxN5crz4MNFdp4qlmQJuxKuFlU7DY7qtoRxQGT6YjdagXacHx0jDESGSqKsiaKR1xeLynzCkOACyIO5kcoGZMmYzarLVGc8O57X6csNb/v9/1esu0OKxxhmJIVFWWteXFxQV7WHB4dcLva8nd/4Rd55+03CQRcX12BUshAMhoZ1us1ZVmx3uTUtX/w2grqXc6LD36NB6/f5+r5OU/jmNl8TBpYpuUtk1Tx3knErzzeocMZwpWU63NW6w2vv/cvgAz6WuwNN9wfDte017POhy+LPGe7uqIsarLNjngUECcRda1JJ2NMbVAyZr3KmE8m7HKf8qykYzxOCMKYShukinwbtyBgcb1DipD7Z/eYpAqhc98pZzL3ftdmNG0QS+Bwdcb3v/OLmN2aIi8onOBbP/9HGR+e0rpaaPzsrVulvzE3qOAouavS9H75gculcbL2hnuvgrdcfYSh9dzsZdN22n9zPTxAeDGlGY2P+CN/9F/n7/zV/wRhQl4+W5BMFadnhwSBoK5LXj6/ARSHh2OyfE1ZWvIMpPQlc0FgjWK9LJBKkCYJaRqhQolAslqtCMOAMFQNd1t1cWbvPvBCMgwUxbbm+nxHmkbezywl4+kYIRxSBrAy4CRShTjryPICRYAQliCQBEpRmZqHr50yPwip6hKImM3HODRGW4rSJxo6F7PabLha3RJFAUf3DnBGIgnABYxHEWkiSOKEm6trTs+OiJKQKFXkWU6apJjacXV5yenZGbiSqpKowPcxtbri0aNHbLOM25s1283OJyoJ0WnPAHWpG3+29LmrzjfUsC2jxXllwcdibKedOwFBGKGEQ5uy0bB9H9jQ+W5NQRBhRd3Znc611mbv2rPWYq0lCFXHEjN1G/vy4x2W/e5Ka+Pdh8pBtt4SOIEIQ3Jd45AEyjNwtDU0/UG63/+w40sB7s46kmiMM5ZAxFxfF2w2OyQJZRmw2RTUWjAZhbw6X6Cdoyg088MZxhqMrhhPJqzXO5wLKDJDrS1RZamNwNYhQod88viK8XhCm0Rzs9hR15BvDKttQV7uCEJFOhqhlKCuamQQMRpNCYMRYew4GScYIwjjMW+/+whjvsZmk6Nrb3adv7wmy0qqWmOBk3tnGAtREhAEIQ5JnhfkeeU7q0uHoEKqnO2qRDyaIaolu/NPWL8sODoYMR0lEKbU2YJv/8Nf4PTNb/HaG6/x8P49dG2xWjZNWVowassbeP2yLSqA9VX0FosdVzc7ilwixJiqtKTJDFOvWS1r6qpsWqFF3N5mntEznhBHkkpDoWvK24w4SYiSEYvFjt1GUhWWF48/5Jf+9l/jp37q59hstrz2zo8zmt+HcIxTgaezoVHOUmzWXH76CTevXrDb7pgdn7I6P2c0PsS2GYKNS901G2pYnlk0AbC2xYkQDIqbAc4hg54T7DrU7kGbdtqaRg2uA/X2GARfGbiWWkHjHE4rwDKePWKdKfI6oM4MyeiA68uMMGxcTjpmtdyR5z5IGkUxq1UJruD07JQir9luSzZr34iiLCzHJ3PCSPrn3AXVvIYYx4oiL5oR+sqDVmhPOhCCm5sN01mKVBHLxZowCqmqkul0SlUYjo4OuHf/Hi+evyTbFdTGYHPDZBZTlQ4hQqzTOCcJogAhoagKhLAIEYB0jMYR17fXaKc5PjshDP2ERmHKauHdLZtNxmq54evfeI9Hj1J2u5WvHGkEk/QQ5wy1LTg7u0cYhZycjJFBxLMnN1irETJGqQStt74LUVPsry0d4hkyDqM9jxwJQjZ9HqT0yVRO4ISv+eP58a5bN8Z4jf/1h/d5OIp5//2PqYwvAiaMpKqbamcds6Zxg5qec9629vMkEOkbbCQhi8WStuyfs14hUa7PBPdxML8WTVPETEqJqUtAEIaBp1w7nxBmG16os33w9bc7vhTgbq0j2+ZIKSmul6ggJMtKAqEIAojTiO1Ok8YJUThGWoMNNVfnKybTEVles1os8Rl4GXGkSNKQIGg6lIcheVmhkgk364zxaOSBKZXs8i1mV6FxiIs1KjQYUzGZpVjtH34QKsJIMRmlOGu9GYlkOhshCRCMcE4hZcD8wOFsxbd//R/zydNjtIEgSHzgdTIhjhKur67Z7raowMcI0jRC6y1BKLm9NuSbF5RxgcHx8twShwmz+QmfvIj5a3/xj7NcHjI/OCCOI4ryNYJo1LuVgZ4vPnhv8FdV/GFubr7hubl4UIzimLLIPX0u3nH02n/I5OADrNFYC2ZTUIQOO0lwxhFHKWHkhUaxLjg6OGQXZFw8f8ry+iXV6gOmkwnF7SfMDt9l/tpPcPDa21gRogvDX/2PD3j/1w7ZLP4HvhmE9ab2r/yDI+J0jGewiM4bMwxmAp0W/sN0FxU4/ui/vuVn/0i+h+Vyb7KaPzsaZAugA7opLeB7f5B/39Mt/95/PuYf/T9Hfu/bIy5e/cfk2x3OOfJlhGuKiHlwtxhjycIQbXQT6PMmud7GGOMa2qG/lJSCYhk3wOGazW990al2OgaaI/S8bdgSjf83zA4/pswLnBUUWYkUks0qQ9eO9WpLmiTMphOKPKcoK6yz1LUmihRaC0IVImWAEL4mTBh5K+z2ZkEUhIwmU6amJFA5Dss2y0lcyG6refH8Buki8rxC64pPgiOefvA/oixHBEEAApRSnRbcatdaW6wL2G2yprKj5HurkKqumvK8stGU3VCf6dwjUp0zOfpfoMSlT/V3omme7dvbWWv882trAUnvXplMxrzx6B66qvngo8e+Qqd0tJm9QojeFSfaEsB9TXVfeVJTVwIVBpTbDCEkSqrGndKGXD+3/KA9d6uZC0jiECWh0t4VbAf7WjUJhT/s+FKAu3PePeFTeiWu1FgrqJ0mjhK2m8JH09MxeZFT1iVxlFLmXmsP45AgkFSVQYqUzXrHeCyIE+87vblaUJYWpQRVpdlkpglcxYCiqCqcEhgy0pHXLosyJ4oDoiii0oZ6lbGNC78wnMJazS5fE8qAIEiQyjIaRZzeG3tebhJxcfmcV+drsp1FqoCD+RH3zu7zwYfvI6RhnMYEoWI0SUlTibMRkdoymzrCeMFquWG52nD/+BTttvzqr36VTz74KYKwZrvSCCAIxmjTJGxAt2HAR9WV8t3mofdLOhfj7Jvt7AOCbNOCREC+GaGi3+L1t58yGsdcX60pcigKg3MFb71xxu3tDcsLjRAFQoEVOUEksNYwHqVk2zVCV5jKUWaOyfwBoX1ELUJePY35O//3A+rKN4Nwg3FsVwIhfLo4UqCkouOn9TDfH1/wlr8PQb71NvfP/KESEQzLLzTfGSrvziGaTKWeijl04XhrqHPfICgLyX/5l6a8eiIJIs8gwb1F0HXmEVSF54u3fGvrIoo6AQp0VXbX3zXE7WEswBjIjMSaEaAQYsOQXtqa9dbaIcaBU8CEunjMavHvEgYhAonqaP8SYyS7bclLfY1UbVAxxAmLrn1DZiUlzvpyv9Zalqs1k8kUbSyrVcZsNueXv/09rK1Jo4h0FHF4ekBdV2xWBdnOsF3fEgQBSRLx2Uc/z+XL34dUGUrZhm7Y5x4MjDIcTUZnE9vY1vuPvE1AuvvsnYsw5ucw1T+gjv7TpqiXF4xSBD4gLLxP3NpBpqezlGXJZDLl4PAAIQSj8Qhda2pjfC0YvGVo8b0TBHQA21oSxnp6a2sBSiEIpPCt+oC22HXrZmz/h/Br1uKDwKEUWG1o20f6/ev3vGzKHXyu/ded40sBopmznQAAq/hJREFU7gCVdig5qDjo/FYqSx+lrivN+fktTjiMs2y3G4RU7LKKsBZMZ2OKskLXO4RwaF0RlxLrCsoCnAupK402suna4qPRSRQSRTFFWVKWBcYmBGFAXRXE2hLVjrqqGI9G5LljlxWM0hHGQFVpokCCy7DGa/NhuGE6SZDCcnY8ZTYd44ipakOazpFS8c5XThqtwSCQ1LYmDEPyPOP58w0nJyMKXZEVJckogFjz4voJt6slIPi9/+L/h6+894sEtuDP/tl/g1/6tQ/4hV/+rnfzUPPw9UeoUPL80+/z4N5rzKb3yHZr1stzSmO5Wdyy3ayR1qeGWxlzs1gwm465Pf8WV5/9b1EqRkhFVuQI5UBY8rxAqYT1tmC3q8m2jjjWpOOQuvI+yulckaaCvCgZjxI2qwWj+JpXT36dWsDrX/kZKD1j4fD4O3ztx/8jdnmGtpowiEjGI9LJlMPTe8zPHvDW1/4FDk7uNSFMgWgKQSmgNIZX5QIjDM76NWMQ1MKR38b81f/JT6A9tZkATxVstf2uW20LEr0vhz61wCEt3QZziK5gZ0vJNBri9Ipv/eH/OX/oD/1+MI7d1nLy5tdJpwn/2V/632HzDYurW8pCsLr5I2xu/teEo/8zKv4/da4i2XTk8fERn0nqWSJTrl78OeryDY5P/wwyvOLgeI51hro2hEHI1dU11liE9A0hbP1T5Jv/C4IIU2lUMzdCQaCUZ180tVDquiZo3Hdh5BWB1lKQyjukbq6WPHztBKu1r/G+2hKoiO0uwzpIkinWGVabHdPDObV2VLXGOUMUKYzRbLc51a4C4N0f/w949NZ3McYQBAGL2yVSSMaThDgKcTal0DM+/fBjrMl8fEG1vm6HUj6/Jc8KpFPeojEWYy1l/qepsv8l1gYYaxD4mjZtRqkQshHiTSDU+mdrBSwXK773Wz/g+PiEsCnVoK1prLXeipT+kXlv3mD9tAlKQtAJXJ/A5bOMlehr0PiwPODaCjgOh+fWSxxhECGVxypj+7LkUuLpoXddi19w/EjgLoR4AmwAA2jn3M8IIY6AvwK8BTwB/nvOuYXwovDPAX8MyID/vnPuV3/Y+b2UE2gH/1/q/jto9/S878M+d/mVp7799L4du9hdLEAAJAE2kBBpyaPiiE4yGhV7TEWWHEuZcaQkiv/wZCaaJH9E4/HIkuXYViSLomiJgkiaJEiKBSTKoi92sf2cPe09b29P+ZW75I/r/j3vWQhYIKPEAz+YxTnnLU/5leu+7u/1LfZbyPk+RHyMuBAJ0cmKTRT82keImraRXMUYFK0Til6W66RwtVRVgw+N4G1p26OUom0c9VzsQ43Nab3m6KTB2hai+HHoYcHJUcPkuCVEwcWaqpYtmXMSyh2i8F9jgVZgzBRtPEofS+7loE+eZ6xv9LFZoG1bcqvRWknyFCaJKgzGKA4OI/NeBJUxnTv2j/fAWEl6Aar2DvPwEs30hDfeXoE4IbovMspzrAq0e2/gQmDUHqOObnFyFHCupWcMsfGMbUMxkIW0dYGdowm9PBC9xujTjn46cTRtTZ5ljEclk0nLyVGDa45pK0eWWy5cXGU6dWw+OGA8HhF8jdKGIu/RuhqtI/t77zCvIydxhZit8+BeQYznMbqGcAejG/IyJ7OQ5YZM96knW+z621y6sUzUBg9J3g17W1tsrKxQ25Y3Dt9iRsNJVWHznO2DA+6d7MNklSY8Lpd47G4lWSK0kgElkNI2uw5QLZg3KrFitFILodVpWy3JXFn06fZqGfe26ZtbtG3DoLDU05rRyjpKvY33U5rmiKqOtG4XAG2maLMpvvlewiecleGZ0ZHke8h8lhNDBUSi3sHaHcZL0LiatnEcHR8yWtKoKBDPfD6nVZeBBElqodB1WI9wtjO5h/IMfKRtZYgafLcTiAyHPaq6Zm9PjO8Odk/waUGparn+bZ6hjef45ITzF85SzRVg8V6cDcejPm0ZqGZzzpw9z83XCqZAXd8nchtUpG49eR5oasdweAZtFG+/8TL9pesYu0O/14h/e3CUZY9qPqepWtooXjNZXtL4SjRzCiKHgJh6KfRC+9GJflrfihhKKSnaKor1b4ST4xn1vMKanKIomNdTBOrqTn4343lIhJfgwZB2EYq42JEoBd7FxLIxyW8Ger0S7wNt4s+zEKOcCqtq3xIdKSdWdhg2O7VPiFGyp9/r8f9N5/7jMcbdh/79N4DfijH+LaXU30j//uvAzwCPpf8+Avyd9Od7Phbk/u4AdlvOSHJtFqaFVknSHkiYmxz0+axGefBegTJED/OpEwOhdICi7lSMihCgaVPOovfYNHjEpyDd6PGNx9BSV5K+YpRBKcMsBGIUSXbbpISWGNAENAatQ1q9NSHkVNMGdE1ZeqDlzt19iiJHEfC+wWiNMhZjJLgkhkhvUNAEKaxKuFvsbs8A2D/YZ7h7h16R84u/8s8wVn6mCjNoPPW0xqAoc8vxJJBlRnI1ez2C9xTGkOWazGa0IVBkGpMXTOYT3ETOQ1s79rYOAShLRZs3DMsBR9UJvtEEFwnasbV5yHQ2xdeava0jBoM+J8cT7EqPkIyVZs2c+dEBZ54YcrB7m9tv7hLjR8lsJIYj2sYT1QgVDD60BO9o2wqqins3X2Vra0vogfMp3jXsbG1y7fo1/NKQeQ9a5XGA8x5jNMoo2uhTZ+04OZ5iTEQb4WcbleAefTog0ymyRxuLNVL8lVZkShEIhDBHhYAxGa6tUMExPz7G+1UAekWP/Z1dgm9poufw/k12d8eMBzmH84oYZdi2GJ45D3nE5Jb1G9dRuiTiMBG59rzHEzBYZpMc50AZKEclzrcp5SeyurbEcNgjhJY8z7h8+Qpf/+o6L+8p1jbGfODDz3C4f8Dm/S1sVnJwNGU+dUQlsFGaCVPXAdVGgcKASRCYSQVFU0f2dqaMl3s4F/EuUgwKiqJkHsBaxe7uIW0zp27FfGzQG9O6htXVVapyxrmz69x5U66t4WCEcxCjxgf509Utr77yDj5CkQ0ospIQFAeHR/QHGePxmLqWiMGpq2haT5bltF6suH14KHLv4bqitISGu4A1hogIvUJSjHYLdoyRpmkIQbO5ucX5s2eZzm/RtmHh2tjt+VRXgdHJBz7ggwgJO769ikbyI7wnz3Ki0njXYm1Onhn6S2MOD44k6kUr6rqlSw8DcZ8t8px6Xi3eX6eYfXi+8l6PfxNY5o8DP5b+/t8h2ap/PX39H0R55c8ppZaVUudjjJvf+alEYr7wZggSSHvqJyXTbY/CBcGcrJZlUCWmg4RHtEQlkuUQDSqp9WKMaLUQimFUxz9FfNZNWslJHNTkxxk8HB/PZCbgI8qk7W3breKiJJNBSVKTEcQLRFtM5CGcO9IrBxwdH9I2iqZuIL1WJ8qInbItOPKponEtxko6klaKkyPBaCcTx4PNKb2yli2mmhEcxOixJpMAYBfo5TmZFSiDqJjWc4xWlD3N5PgErTXLS0sMBwXKGnq9MW425m1gOCx57Po52sYRvGJ/7wjnGs6u9hiM+hTZmHoqrKAzlzao2sjNm7vU9ZyN9SU0cvwOJnOxNfVb3H/rCyyNS+YH8tmtjVw80+Pu1oTdo2PKvE+vpwnGE/FYat74+h8QjQQEZ9YSgyN4z5uHd+DMGbIXnsWgMMrSNJ7RYMTh5JiJzqiUiE12947IMiODcZMM2hL0EkmLchK4aG0wWmG0Ag25imjf8NI3fhfXTLhy6RJvv/0qrp5z861NZtP/B0TolwVVNWVvf4f940PKsuTo4D4nB8fkecbamRWcO6CadJi5wijDeGWDtT/2CbZKg/Vyja4MBozznLae89jZy/zG3zzP1uuRrDCsLI85PDmQLOEY8L5ldX2Dc+dX2DizRpZlPHjQ52UFZU9x5eqAtVXF1etnyIsBn/3s19iqp3gvC3QMScIfAS/OntEqqB2ulX2NDxJRd7A3p5x7XGhpW894SXF0dMxotMx0OiXLDePxgDPnzzA5rgleFrSLFy5x9/Ytqrlw8o3O0GRs7ewSk0Dn5Eh8ZbQ2TMKE4VINCoqiILOK2XSGc4Fq3qaBqgelaVuhgMpcgEVkXle3vfcL6CXLLK2LWGvfZaHboXDyq5rpbM7y6gqPP/ooL7/8zcSkSoVbdVYFp/F94h+vU/cuWwWlZRHJrSHPMrwyTNsW70XxqolcOL/O/c0tlsbLTKcz6io1m1EG5kobWpe8n8wpO6xbkcK3+gZ+y+N7Le4R+A0lqpK/G2P8e8DZhwr2A+Bs+vtF4M5Dv3s3fe1dxV0p9XPAz4F07R0FqINM5Ieg2xatrG9w5vxFVlbWuHz5KqPBGIOFENMN6rEGytJwPDlha2eXnd19tnd3uH/nHXxbiyNbDKi0z84zS+yissIpIyLGsNh2ddN5rUxStJmFV3mMkuputU3baYu1lizLOB1gdtuowLA/YG9vB6OEIRBS1FcIiAw6gkuJP9XcEzGEVuCoCLR1Jx+v0XsV01woWVlWCFsqXQRNW2OjpswdmdXSgSlF8EEGwscVmc1EkBWm9HoFjrmEEKS5bJYrBgNNLDRl1qfUIqAYDAu0CSgCF9fWpPtTcDCbcrBUMByMGZSGpq6onaduRIeQxchs+w3GdgWrzsiLhEhhFEvDnAe7x8yconGwagco46jnJ2LJrHOC8wRnKIuCyWxCraCnI+GbL2OMZak3YDKZEVG8f+kcbXGNzym54eZ1Te00utKJ5SChI9qIoCXPLXmmMMmSFR+IWqx/nXIcbb3BrVf+kKY95o2XGup5g0azv1sTg+wWdPS0VcvhyZS7d/cYDQeMR30Iimk9ETaVOZ3+6gQBBWU4iYo5Gq8cKkRa13JSGEw/w82OmTqHUjlF4Tg+3qepHUpZFJrjoxn9/pDhcESMjpPpEZeuPCfFLTTs7+1Q14Fef5kQGq5cPs/ugzfxLqSCeGpoJXdAxHkFAazVkGxsI4Gmla69HIg4aF7NxTKYBmslkSkvc6w17O3vszJeY3dvj4O9Y/LM0Hb2B/OWeHhMcIGq8uRZQVM7mSFksjtuu4XFOZTuMZvO0cqgEtSUA/N5LYuDJl3bYVHcUdA6h06sFuc9Lpl8OedSupawbkTIJGyVNkZc6ziZzHnqycc4PDrkzv1NieTsenetCcEv4JJT3vnp2RVth2M4HDHq9zk4mWOsfDbXetqmYXV5xKhfUlrN8tkN3rl1D1ROjIq29dTVsQiciKA1eVK/utAusmPf6/G9FvePxRjvKaXOAJ9WSr368DdjjFG9K9n4uz/SAvH3AEyWxRgUMQ29lBZoxQfFeLzCY0+/jw//4A8zHAzxjROMGyQF3AvNYDgoeP65Z5hPjvkv/s5/ye7hCf3RCo8++gE+9oM/zv/wC/+AppktRhBdd96lr3T704XyERBxzKljm2CzsiJneSbHXBnyrMAamYNbKwVeFgkARdsKBpkZg2tawXGVQhuxJiV02aBiFSo3vnSrMUSikuxJH9LuImiaStHUToZ9qhYZtkrT/AgqBmZVg1FQ9kuC8zSNQ4xPIzBH68i89pTTGl0YZnXN/OQYgLryPNg+pswtM+PRRqOC5fCootezWA2H9TG9QkJ7R3mPc6tLKKsx2mO0R1mFUYGmdZiyR4g1x0f7zCYjQLqq2s0YDUuWxiV7e56AYla34BrW1kfEWFNkkA8G1JVQ6nyIzF1DPDig37ZM2gpblBR5iYuKs/kaa2cv82Jn8ep9khqlHZz31FVFr98DpdFaBFqddFyrSJEZMqMpTcVbr3yBMD1iNp+lXEuJR8vNQDbnSoGr2JseMp21NFXk/vEO7uwKN65fIC8sn/nMl6hr2brLBZiEK0Bm4OJ4GRUc1ooaOOAZ9vtoJ9ejMYZHHr3G3t6UunbUdUOe9Vhd3mBn+4BeaVlaKRmNe9ybT9Klqjg5aUS0hEjzr9+4wuH+nHt3d5hMarnnTqW2KQBFrqG2DQs+vzZK5PxGBoIra8tEFZlOa1wz5czZDVAea3OKvE+Rl7zzzl02VtdZGo3ZvH+fLCuZAzs7u1waRXq9Pr6pmc8aQC0ao6ZJDZdWaCULGChcTLCbks/SNBO6IOHwLW1sCIAPaJvJjjrI16w24kfVtsm+4BTvFrpiQIXI3t4BD7a3eOSRaxydHDFNdNIYI1kuQ+fOz8b7NKhPQeTilSTvqygEv693DrDaCoQagwR4x8jy8pjr169w6+YttHb4IHdnh/MLMCHIBD5gbUbQIXHs37vGfk/FPcZ4L/25rZT658CHga0OblFKnQe204/fAy4/9OuX0te+y2vIRW+MEbyTjAtXb7B29ioHJw2/8qufI7eWej5LrJCAd4104niKLLC0/HP84s//Yz73uS8yGK2wfMays3cT88wTPPfcD/CFz/8+KR030ZZS3k8QBo5UUynysQvCDaTEeCuYrDaUZU8ofAmHz2wmYbypuIsZkBR+OfGRGBwo8RbRWqPS70cf0UgUV0ftMkYu8gi46CnyjFwbiAOqI8iKgv5wyHQ2pU2DIxPDwlo0RmFDtD6QWYObtigPjVd4rSF6VAwUmULNPa3XhHlL4zz1VDqm46OW/d2W/iA5AoYgbKFJRb+XofEUpaVf2ARzeEbLY3qDklmiqw7LkjNrI1zr5aayCh00RdEDxMd/OBwQdcbSqOHgoCYEsafFeA6PIsZGnGvJjCUGD2TUTcAHw8y15LYlyyzVvEKT00Z4+5tfZVA8AXwEFQJ5W0HQNCGAtVitsaUhhCZ5acvQsQ1yE+1Wxxy3M4rCsBonPLjzFs2sYT5rhJ54UlPP56yujQghkhnPqjlg5hx1ANXLGa2MsKOMD334eXxTcff2A159dTNR2KA/yFDWY3D44Hl77z5XllfpOzBWeFTzWcX9N24ymfwkGWNGy8vY8hz7u28SnGNWT2mrGdYuU59ZZme74vAQ9nZl8YxB4VpFf1CwtrbClauX6PdHKAVnzq3zB7//ZUzQBNU5/ajTHkaqa+pshWmjtRRY1UYOD44gRtqmJe9nFHlGiIp60vLGKy/hWihtQWwDm3fusZDZA/1BKZa8KV7Ou4BVFjLpsANIapNW9IZjtnd38T4srI+DDwQceZajtWZeVbLIapMclFJxDBrnhMHiXTKyyBS5MsTYSshMFNm/QMIJpooR7xy7O3tYA9euXuH119/ElplE4OWG0XjIvKqp5rXUD5XMq5XBaEP0DZnJaZrATLdYY2hDpG1roZlmlpvv3GHUL5gc7aDaFqOh9V1kR/JwTzOEzBiskvu2l2fMH2r2vtPjuxZ3pdQA0DHGk/T3TwL/GfAp4M8Bfyv9+S/Sr3wK+CtKqZ9HBqlH7423pzeiZftktGZ9ZZWV9UvYwRr7x1M8suK66GiDk2QSJS6P1oh50blz51hZWeZgb4eP/sAHuH1vi36vYFp5dvf3+LEf/Qlee/UVDo/2ExWqm5KHBLN0VwSCqWmVoroQbF9bwWOtlQEJcvEbpVNn1fFdhQWjjF7kJud5hjWKLM8xWUZBwLmAb9vUKSV8MKZ5QpYRtaUcjHjhQy9w44nHiNrw5c8+y6//IvzYT/wkP/nHnuBTn/qXbD7YomczHnv8Ec5duEi/V6IU3Nt8wLmzZ4FAcC1VVbP5YIfbt26ztXWfg4MdAgHnDcpZqrZO9q4dRz4ynXqaZk7TNhhtKYsxVdOk1J+Imbb0cos1luAd+eEh2kLrPU1dk1spqiFGytwyHvUYDHvs78sco6o9u/sVQdcMhiUbZyNK5/joMSaiVMPSsEcvzyhsREdNVUk3FluYTU8oTMVoaUivKKQzRlHPDtl84yvE8CeZTw755oufRutA1Jq8yDGJ94/S5KbEWCkSXmuwlrtZw2HucAcVSyc7ZMc7WJXTNg7fBo4Ojikyu/D4yLRmfWjZrS2Xzz/CxV5BfzxkpS/XxqBQfOzjL7B5/zdRvs/8ED7ygx/k8vWf4Xc+9yVC0+B1YG//gP7Zs/hmTq4iW/e2OJlMF/dI3TYcHO1z4dJ5bt+8y6xu6JV9rDUM+32m8wl7O8cc7snxbRpHpnMyU7C0vETdzrj12lu0IWILCbzweLGDUHpBLjjtglNrqGVH2EEizrX4NjIe9jlqj8mygslkhjGe+XxCUZSAE/ry1jaZMZSlpePoD4YDmsYzPaloW4FBjDY0dYOPHpsVAgnFyM7uITHKgDt4j2vCggU0m9epZhhc4j11D+9iUgx18zzpg5so3jTWaFQUp9UYUoaY0sKeiZHWO2bTGaPBdcbjEZt376ILQ+sss/mc1jtCFP98meWpxW4jhIDVCqutkBhiZLQ0ZjqvmM2n1G1DVLCyusqFsyusLBWcW15BGcXNuwecct8V1liMUlgTWB2N0FpzPK8wVgks/V419bsVXQRL/+cJB7fAfx9j/DWl1IvALyil/n3gHeBn08//KkKDfBOhQv6F7+E1UMpgteGTn/gp/s9/82/yq7/2m7xx8w4ORVBC7O/oXdYYrDUUZc7S0pjRYMBjjz7GzVtv8OOf/EmeeeYZvv6N19g5nLK6fo5HblznzNkNPvlH/wS/8I/+W+FKx0AMnk7eTke8SVPwRY5hx6CwOUqBNfZ0kCta+rQ18wlTFV8LGeLoRSeUFz36/SHG2KRqS4Oh1C2FGOQGMlKAzl+6xPmrj3F/a5fPffEX8SFwvDMHfpSXvv4SH/yY5pEn3s8jT30AFT1Rw95kzoP9E3HBU4oH+1PKfkmv1+fa9Rv8mb/4F7l/b5vf+e1/xVdf/CyvffNlCoTvH1WOLS1uvsThVqLhTVtcbvFeUxQFrokUWcm8EuVgN6AOMRJijq4N0Yj5Et7SyzIMhrZtmKqWk0nEmIrZ9AwRmDWB+xOLNRnROyonLpkhKmxe0Mv6GAyuhlAHUJGN9Q3+D/+nv8rW3jG/8PP/mDt33iIqxROPPsaNG0+weX+L7d0HSfgDmTWcGRcMhwUmt9R1TdvIQFergFUVqCZJ9zXRwY3c0qLwGPaPJ8RswMb5C/Bgn53NBzSNJy9LskJ2cLWLfP1WxTQvyIsea+fP4olUquG4nmFUw/7BNr0y0vbllhsMSi5cOsPZjSWYefIix1Ue5vcpggfXstbMKQlsKTnGs5M5Z9fO8rWvvEpTO7yPtG3LfF4xm825d/8eTdsKrUbJznF60tDUijs3d9g4O6a0fW4/uMXm/RNheCScWMW4YA79a17haRSBVlgV0VHRVpHDUBFiRl1HZrOAc3OWVla4sLHC3dv3ib5laamkLAqqplrAQ0SLx0Imean9YkhbO/o9K1bJxmCLHkVvSDjYTz46ihglpDooYa9hLNpYiD6Jy0BHwc41Gh1EVOSlTspLh4hHJ6uTDoKK0oxF+T5KEyLMqobd3T2Ggx43blzh9r3bArH6yPHxhDYFongBA+RVlUYhNsMhCve+qiqm0xl5v8+Zs2e5d/8e+wcH9PKcpulx+cJV9rfu88f/6A/xD/77X2fvWD5BNCpRwMWZ9fln34fRgS986SUIit5gwN7Od66p37W4xxjfBp77Nl/fAz7xbb4egb/83Z734YdSiqIs+akf/wn+0l/6S1y8eIm/+B/8BTmBvDtMTqkuOvm0262bljt373LXWPJczMCuPfIYTw1GlGWPzfubvPX6EevrZ9lY22A+PUIrsfeMiUUjUA90A1yFmP0ro+mVPXq9XurgZaExaVCDksVGkbIc04XUTc5DAtBGS8v0BwPyvEApjTGZ+DIT8N6LGhCFNpbLFy7yn/yNv85bt2/z9s2bvPD84wyWlnjpxQ/xqZ+HZ9//JB943qBeeZvf+p0/lIix1jGbz3BtS5ZJcIEQayNGReaTx/jEj/04//JXfp23b96h1iNuvO+DTPa3eOzqVc6ePU85MLz92qPcfQO0SqIar9JMIQeUmCgZK7spY8iKHlm5xOr6OVZW1lJKfOQrX/wcRgmXPiTKaRsMjY+0TuYV5XCFYu0G9ayiZzV3H7zO0tKQC1eu0R8PKMoMA/jW01QVbXWCWTqP7Y1x/oBHHnuUP/9n/9e0rmV1ZY0sy/kXv/yr6Czn7v1tQhB+/9kz64yX+rx96xYBz2BQUs2mQtOcTegPeqwsb3Dh8hWi1rgY2dne4s6tW8x3DvjYD/8YH/2hH2F5qc8XPvMZ/u7f+W9433MfosiW+bKRAZg9/0Ga2X2OQk2sTgghcnS4x0k75WIemE2OWVsfEXwBwN27dzl3ZYcLZze49/aMxx9/H++88Sqvf+5T6DBhaWXEYFyy1OuzX9XMvOcbL7/Oh57bYHo8x7WKGA3TmSNuHXFzuInONMsrq+xtyS7S+8hs6phuz5hNoZl5BiPL/oMT7t/ZhWhlwBfFu8QaIw2Hd0SkiIPAx8FHlFXyJ5I81VQR3RsyXL/C+vlL9PolNsvJS8Xl/jW0j2S5xWYSwv3NF29wvA8r555k43KzeG6ttHTPocV5gVrX1y7w/ueHfPOlL2MMeN/QtJXQGlvPrKqpZjX1bEZwgeAb2vpU8atCClPv/IlILJZ0PXodiWkHECPiw5RwbNnEC6x5cHjEY489wtUrl9jZ2aJpoXaBwWjE0eGxzAiVLBBZ0iiEEFDGEkLg6PiYSKQNnnYiAktr7IKls7+9y/HxOufPr7HSL7i8vsLu8TYxCkTtg6hjmzowm025fHGZ5X6Gm88w4SHZ7rd5fF8oVPv9Pi+88AFW11b4jU//Op/+9KeBSIgelaAKk1LKm7ZN9MNA07YyBY8Sqts0La513Lr5DnXb4lq/CBVI9AFuPHINkozXOYePIiaQQFroirs8lPhRJMjFh4BOXFOjFcZmEm3WOrz39HqFwDWJ7xpYcDlRRvH6m2+QZRlFUSS6pML5Fo2i7JVCkxKvT/7Of/Gfo7Tn8PgQ7wKDcsjWvTHwMfJMCujLL3+VC+dWaJIYYnfXUzeQZWJfSpBt4ngw4Gd+6ieZ1S37RxPyrMD5yHi8wmjU4413bvLW22/Q7+WoIHhtr9/j7LlzxES/6gY8CsV4aSzzBmvQxrK0vMZ4eYm6maGiorAFly6cXcjrnXNkWUGelTjXcrA3Zve+DBSXB2NOvMf7lktXH6HIB+zs7BB3d9JNJrhooS2ZznHhiN/+vRepqxPu3r3PN77+Mm++/garZ89y5foNbH/I+cs9go58QSt6/T7ve/b9XLtygbxX8hu/+Wn+V//On+Ltt9/gzLnL7B9PePTxxxgPR6yuLLG/d0DlWq5ev0ZdVbz25uusLJ/hX/7zT7G+VvLOm2/z6PVH2N45wgBt0xKi4s7WEZPZCWU1Y393Bx8idVXhl3JO8la6PBWoa6EDzudzbr/zDpcuX2O/Wefxx59mvr3Fq/NAaBoOZnswHzK60CO0EjRR6pKtzR0yW9CkrT0o5pVnb/+ELHdsrK/K7hLIspymdkynFc4f0rqG0XLOtPIolWEUuETlI6hTDrXqirpORA2Bl3zrCQpMJm6SFy6/jyc/9HF66xcJukQbLdTZ6ClWPL46pmnnrJ+/SJ7l3H1TRnHa/gA2u5LIcGnWleiYRYJHi2wESjFavkpmC2mCQosPLbGtaOuKpqlxzYy2ESvupmrYffAB9h6AC5cJ7oNEJTu+jheuYudNA84rQpKban86X+gINyHA7l7G66+v8+wzT9BUisnxEeVwwPTkAK1fBVqC1qBaiA6jReWrMHg8y6tLRAJ7+8ciaPKB0UicV5dGffrWMZ/O6Z29wGx/ytW1Zb75zibTTkmfirzzLfe3d/joR57mfU8ec39zl83do/esq98Xxd05x4PNe+xuPUj+zCkqVsXEIlELZktnFtRRt0C6+QgQAh7BVkG2mkJXTNWpW8ERdopgbd2WrOOjS5eSnlgERlr+3cmeg0+LBRXBR1wrZk/z2TQVQ52Ke8BqgzGWWTWnrUWwlBeFMEVaYX9YbZjNZ2knAHWAo6MDVEh+JtrQzk44PBImywvPPs+Hn4HH/ubTnMzmOFejlKWpGxrfUPuW0hj6WZHCMGA0GDHH8rGPfJQvf/Wr3H7nde7ducul8xdoXY1qKnw95Wj/FiDHTBsZKneJ6x2jRyvAGITfFDk52uH4SPaHIqEWjFRr+fnCFrL99Q25NQz6fUBRz6bs331H8NI8Y3XpPG+8/hrRO2RMLp1i9AEdIyaCuwumlzPqFWzdvcfO5v2EzR5w7fJ1bly8zKSumB1P6cKwdw92UdSc2Vjl/MYav/fbv8XVq1d5/pkPsFfV/JNf+hS379wDV6FiYLQ8QmeGR69f5RM/9pPM9o544sZ19g/2ePHzX+fKpRtorziZ78mCrw3MG8ysQbdznG25c+cefZtRPXqOeGmFugpkZZ5ostBUFft7+9zf3Gdpo2X7m7/Dyd1voMIxvV5JVuQ08wo3qUQJHSOTyZS23aXXHzFvXKK+KtbXVllbGVP2oalqmloaIOdb+oMSFxTTWcVsbhmu9Gm9aDzyLAPnEwXQpcYiQYQhLoyNhUGkqWMLSqNsn6c+8MOsX3ofh1XNO6+9TLQ5RV6wPF4nK/tAoFeM8R7u3b5HUWQcHlwD4MXf+MCCtfbdHx//Nl97iAT4LZSRjpgR3H9IcP+b7/lVvtOjmcGXv6z4ylcUIfwV+eI+oGry4V/DZv8EFRMMZmWVUiha5+mVJRtn15nPZxydTGXxc43odwJ4N6e/lLO6XPL8+y9Reg3TKW/c3eTlzROCtuBD4uTDrbvbfPON23zwhecZv/0O05e++Z7v/fuiuIPAGM57dAiQaICouLBw7Til3eNh29XkOiJD0CiYt4iDTl3yBDKU7y+eRyt0V/z1aSFThBRSK8+hE64u03pFtPZ06GTS6yst6euqw+DBpMIsnNeY4BKJ6AoxkpEROq/1EGSQ2r3ZmN5feg6MThFhcPDam7z6T1/mzLPv58xjN4jA4fEJmdKcWVqjoUUdnrD7lZeZTY7Zmh5xfDylf+YiVx55gvPnP8H27hN8/etf4WjvmNzmtFVNXlqyXC4JYw29XimFXQkGb9IMQaWFtwsWFmMyk9JnAkWRyzlS6Tx091+QY22NFDitFWUOXuc89vRzPHb9Bn/0p36IlsjRrCYEKHTG2+/cYftgn2oy5fDwmKigHPRY39hgOtnnB3/wIwy15ac/9oNcvXGDafS8/dacf/Sf5ygijz92jXPrK+zt7DDslXzj619jvDTmS1/8LB/70Y/zp37mJ9g/aWi8o65rlA409YRLZzd4+Ytf4td+49MsLS/xwQ+8QFkM6WdDdrbuY7JlrLX0ihJTVdSHhzzyvrPYbM7ZpUuMxkMGyyNmsymESK/sUZQlAE3TYIzh5PiE4F/l8N4r3Lu7T78oqeY13nvWV4eiU7CWtpYBmmsc0zBlaWlIXVfMp3Oa+Zzd7ZazF9cwWqi1INdh7VomkwmujVSmoak8VmeyaKYhakgck5BKptw/3TUoT+djygDNezz+/EfJ1q/isj7NZEbdOs6cu4KravZ3tinLkuWVVVqvGfRHvPPgHg/u3WV69H4AyvHr2PIgvcC3OnuqBVskBst091mUdgzXX5Z6EE/9WwR21N2voYg00zPMDq4wWrtHOdqkrubkxrK/tU2MDpOGwx2dWilDcJ+AWKDMr6N0sxBPkt6JtRnj0YAsz9g/OKBtN/Dtxwnts2TFP6dxYmkhkKVmXgkBoa4dr37zDZaWx8mrZk5eKHq55uL5C2Sh5eM//AzaTfCxomkVZa559PwZXts8IrkPCHsvGupG89u/+2WsWJCysrz8njX1+6a4AwuXvhBjKqRxwUWNPkW1JXyLVLilAOvFAEinLFFtOl+JdMF2fg/x9Guy5VSLLlXWXOHadwVIqYg2esE1XUTGLRYaMXlqmkaGTuliFcqbStTIruO14geRLi5tNTm5ULUS91WhUWlfqJNds9aGoBXGyul65423ean/VU7efJ3y0WvkZY+DoyneB2xpaVVLdfcB7UtvEmcV96pjto+PGFy+yoUnnyHvlygTWB6MefqRpxiVAz7/B59B2wxrpTCT2BFC65TjIrz+xDwIQW6MmLzu5E5Js4RIUCQxWAetaTJrUFZT9CxKQZFbLl/YYGxyPnJ2zA+/7zIbFx8ljAbMbMZcW0yIEBp8cBxt7/LWK2/x4ksv82B/h7XVJR67cYnnn3+Wd956m3ce3OVwPmF/PuXOvYD3P8jJyQn/8p/9EqNBTtu07O3uYKzl+o0brC/1+dI/+ofcuHiJjefex24cUtUNvVzjDhSv/+7vs3n3Dk++73Hu39/kDz7zGc5fuMQ0egZrK6ytXOblL2tm0xlHB0c4IpevXeaTP/J+jvbvcPHKGV556ya/+7kvMRoVlFmfrXfSObWG/rBPuL+HijW5zShyKIqMUb+gqmpikNDsznkwz3IwJSbLQAXKfgbRyU4WQ90EysLStgkOC4GT2ZygNCYDH1r29/aSP7kMm0Kn70jnPITEIEEgC6UVUac8Wp1x7fHnGJ29zvrlxzk6PODw5ITx+UtUxjJcLonBcbJ3wLA/QOUZIcL1a1d5cPcmdSXMn/H5TzFY/6o0TsZQ5HJuiHL3xBQ87dshNw//L5hswtmn/j5ay1xMJbgUBV4Z0W4okRgd3Pk4s4MrrF//Cj/0b90hM4G3Xn2FnTff4tbrX8MQZLEKye+dkmbym0TWMcX/DqX3FuaFKjn89HsDbjx2DZMpis1NtrY+xOzoY2RGmGJN24gKNdTkeU5mDN4FtDX0+gUxSlSocPNPuHzlCo9cv8z9t25xfHjEs++7gS0GvPXGTVoXuHLuPKvDu2yfNEirKTv4GMVjq/WRpqpkh/Yej++L4q4QnFjoWCpZYwotSaWuMaTBBeph257UUT/kEeE7xstDWDl0xeiUCSAduk7+yqf8XpRI2WVxSFYE6XX+9cJ++mhb6Qo6437h9MrF2xXpU4f17uIxmFzgjRjTbgEJGzCohyhokBmbKGbwwp/4t/nZv/gztK1LjnmG4+lcDNaip3ENw7zEN4G2adna3uYPPv8F7m09YDafo7VlXk2ZTY852D5gNBryEz/5Cd549RX2tvzieDnf4mOHQerEMInJ0VK4+nlmyTJLnlnKfo9+r0+/32MwHDIYlPR6JYPBgOGgz2A4pCwLtu+f5cXPGJ584jH+4//tf8Dbn/0S3/i1T2O+9FUGo3XeLnLa82cZP/oETVNz98XPcTFCfX+Lu/cecK+uCWfXuf6BZ/iBD7+ALXNe+uYr/PKv/goXLl7k8PCQydGIun4BYwPVyZTCgvOO1dUVfvqnP8n6+jqPXr1K/+kXaFwD60v0WznfwVU0haV+5Abjcxv4wvKDH/4B2sYxn7f801/8F1iTsbt9n7ZtQSmy5QF1NcWrnFb3OXf2BqPC8Oj5Kxw+ckxTT1lfWqXausSLgK8c+5v7uJOGg+k+Z86uE4IoX69du4qK4ENDUeZy5SgYDgvy3pC6aSl6GXlh0EvCNCGHlbUew76hnou/f11LUljdOrzzrK0vYWxGbGuiEg3FQoKvhYkSY4TQBUarxW4xKsPaxRusXX+KjWtPEIHp8R7GZuTlgGAi3lccHO3Ryy11M8fmGT4ERsMBF86fZ+eNpDptG9r5DGUMWWGIWdKBBBYRi5FA8PLZiRFXz9G6Tc2GOGZ20YxaK3yE6CO+ES+Walbx+qvv8PwLT/PsD/wwX24M/cGQN1/5Ck01TTTmd3v2a/VQLUiVSSmom4aDw0PywmC0pcgLZgh8VTWVQI+5DJMHg4L99gjfRHoGxsMeSmnqWYWrG8bDEf1+n9feeJ3pzgHDEh69eplv7t/l5Zfe4traGk3b8PjVc+x/4xatspIDGyNRBeqm5ctf/yZXL19me+/wPevq90Vx11pTliUdHh6CW4gLpKAbGXSQOonElel8FtSiTJ9OulGnvuadIENOnPyuWKSeJqhImovQI7tuNQTSAiFn26dk8m7wojsoJy7WBYyRrkJpIzeH6jyfT/lYSskkv3uP4lbpF4sOShFTKrosLh7wjEdDAPHHLiz9Up6nqmuOfUNwnn6v5Nq5y7gI06pGGcvKpQvky8t86pc+xdbmJr0yI7dD1ldWaduG+eSY1dUlzqytsjuW1yh7GRfPrdHr9yj6I8r+Er1ezqhnGZSWvCwZL60wHI/o9QvKLCMvCvJMLkatQeuISnh98AHnIz54Jsl+zgfPdDrnpDfkuZ/7i2yUfVzTct0GLly5wZlzV5j7hq8NB+xvb1NfucrK0THV5gN293bxTcXbN9/k0ccf5fHHbrC+usTq+honJyfs7ZR89l8Zev2Sp9//BJcun6UoCoqiIM9z0Irj2YzxxSuoxHNeLyEohY45jAdcunSRr3/jG7z22qs88fjjeC9h1WtrQ1aW11heusRXP5sTUVy+fJYvfOEbZHmfeSipHOxtteQMefaJD0IzoXEV66trADxy5So/+vEfk4IUILiWvf19qqbGe8fe4RHTWUORD1LDoDi7PmYwbFheXaGuJ2glEvzDo0NWz69y9tIq9XxC04rBXJZlrKyucKRnHB2dcHwyp8gDLjhc4mkHpIlXaXdqoiH6iNESlqIRYVBvvMr5J9/P+SeeJmQFJzubzE6OWV4/Cxoyo5gfHdPPbeKYiy2F95HGBa498gjf+GyC4xQoHTEmkOcWa8WozicPpG54732TIIlA3VZoJYEZOsGlSim0tYjzJwkWlObEuYbjw32+8OIXefYD7+e5j3yEr/zh7/HUCx/lla++SD0/kvfwUKOm0nzh1F8+NXgEtra2sVbTK/qiBod0TXvysqCqK3Knicl3ByX3/3wmfk4Ex6g/Yjgo2T84pCwL0JaTacWDrR0Oj464u7nHUt7n+OSAp5+8xq2tI25tn6TaFYl4nNfc35pyPL2zcIn8To/vi+KutBZFZhQBhUEGp8IX9yiTvJF1JxoSBR90HbC4D3YrrnQip0kpWhvxoIkBo8VPRiTV5l0LgDgD2sXcVTp9RWffKZzYQAwSKG3QImfvQnLT/wKymEQSfhkEk1vYgiq9yFtsVQQlF2XH2OnmDSExb7QBayJayYXrQ6DtwjkAjGFjfWOxxa6rGhcjIXhmkxPu3d/mD/7gD9l9sAnesb15n7quWV3fQCXzqaP9PUaDgj/1J/9tvvSH8OEPfYC/8leXyPIswVICpQRXY0hbaJURYpSZRAi46KjaispFdDS4pqEJTthMrRe2QIxs7omZ26xquL27RzssOHv1KitlSRsCg7TAbW/fB+DqU49w/pHrKY0m8MrL3+APfv030AbqtmY6mXD2/FnWNtYIwbGyssTq8hhtDEtLY67fuErZE0FIURa41jObzLl98w7/8B//PE3tePSxR8mKTK6H4NnZ3OT+/fuU/T7nzp3FecdgUFL2Sv7yX/lLHB1O2NutyYucEOCFF57jQx96nKLM2DsQ47BBfxmbW1oLBEeo54RyGYDzly7x/Ec+LHJ6QCXh12w2Z1bV7OztM5tNebC5S5FnVHPFxnqP3Gr6esaHPvgYxMj0ZMbOwS6Pv/9Jtvd32GqOObuxhkI695OjQ5wTKG06b5hXYkTlkreMUkq887IUmqI0ed7DO0frA0EZtC25/MQz3Hj6OWzZo20q6qM9CNDrD6kRw7tqNmFjY42mDpS9ITFKW1I1jrXlVc6cO8vJA1hZX2KwtryYT4XgsTZIM6CkHgz6Q4rsAve/Jven9SFZPqedozpl0eW5NFMhQJ1mRtE7mnoGxvP1r3yVD3zgOT7w0Y/wud//fZ790A/zylf/kLo6xPlTonU3c7PWpsUDnKtx0VEWPcmoDbCIzUtwVtu25EbynG3I00bAS7ylymmahqIoKcqCyXROmLQM+n2BbrTm5PhEqNhKobOCEA1lz/Ls+x/j9m9+RRhKWhZaHwNtVBzPK2zz3mPp74/ijpwo8ZMOoDykDrj7Pioh4on4IkID+b5OnG6tNUaRFKenDBhrNVFF8XJHuseQusnOzChVKyQqK5kCkTxf+BZD/qRKDa59aFqvWLApQyTg0zxKSWqL6ji0Am+4tsG7VvjE2tBNHYVpAhGHMkEw+qgewrfh8PCI2/eOFzipVqKKa1uxOJDhtKN1jrv37nPzrVts3rkNvgHv2N3e5+bNm/zYT/w4Jsvoj4cc7m0TmwP6hbyPMrcs9Q0xpoig0OB8oK2nUrAdgKX10HgnXFzv8Si8l7va+4BLoQViwAbaaqKSm8MYQ7834PY7r/PS7IsSN9gGJlMJ74hRmEkBj1KGvOhhrWV/Z5vBqEftHNvb22ysr6CUNAi9skyJSIPFELzfKyhLI0OtuqFpA/v7R/zdv/v3ODqccPHSJb7x8jc4OjnBOYdrGzKtmByJTfJP/fQnuX7jOkpFev2CpaUe/X5OWXqsMTgCKytjbFbgvcO1Lcf1hJOTGXlmKXoZRV5QlH1UJtYLtjfADlYJQfyBonN4D8VKn8wH1s9dIs8NwQV+//c3mM0y/shP/jhLw218NefS+TW0chweH4O5ztLaEpPZKju7G3z56+Lhl9tMpqFBrp+Ip2obUTZGuZ7ExknReoexGTov6ZV92nlFmFf4aDh7+QZXn3yWYrRCGwLTyRHVZEZvtETQGkMk+pYstwxGS2SZBy+9ZgwR58B5zerqOm8B+/tHzDnEmCxBnA2D0jDsZaAUvd5AskhTC6e0YtgrFhCRSji06IYMWVEmw7CwaPBCcATXorylnVe8+o2XeeG5Z/iRH/kRfv+3fodnnvsIX//aZ5mezBYQb7eD8TEQGk9ZWHq9nHlT0x/3IcLB9gkuzTRiDLI4W4G0XNNSzRtRQKsWpTKOjo7F0LDImE2Ocb7FWmk266qmLHrYLGdpvMr8XJT7zVoq5zl/fo3V1T57BzUxeqLyGK3EzymzCyj6Oz2+L4p7RPifXexVCCklXHZ3WG3oAqpcGqyGtA0TF7twymbRSsRB4ZTb6r0MiTr73W6r54MICtSiqEs3XXdiiJiG8Yk2uejglV4MN10rpkfGiKdEBy2pbmu32AKkIWuUQalYmnSD04ciu4z4OI/HfYbjAYPhgNFwRNnr8eY3L/M54Bf/6S/y+S/+GnmeS5dB8ryPAjW54PHOidnUI4/iQqSaz7CZTlP8GcNhj14hXXnwjqauWRr2qTvMsq7Y3T+galzSAUQcirYzt46KEGpCcLhE1eom+0YblDHS8duMzCS/nWTdLD48Eqoyn015/eWX2dndAQX9YkDd1EQlA9vcWopeD2NlSx9jZD6fc3hwRNt6VteXePaZZ8hyiXIr8lx8POpCFhMlSTydoClGqOY1IcLS8jIrS6usrq/TOMdwPE6dm6Eocva2d/jal77EW2++xSOPPUpklRBbRqMhKE+vn3Y1URSnKI/zihjk9ZqmoWoa6qZCqxnaWo6Oxf99NquYzSpsZshziy4sGXpREIkS2BFMLnMmpVlZv8DyqKAwBqsdKjSMhwVGafzcs1JsUKwt8fmJCIScc1Rzx6xy+CjnHq3wnbQ4HU+iRqPo95bIB2NsbukPAm57m2FvwGi0zvr5S/jgwDkmR/vM5hVnrlwCbSgyw97uESsr55J9hUp3a5RGTYnJVuf0ePXKo5y7LjYeaEukxVChlPgu+eBomob5tI9SiizLuXz1Gsa41JwFaV5iIKpTx9O2FZ8hgP5wwNrqitzXwXO8f8Bnfu93GY76TGcnBKt5/oWP8vWvfIXDE6FSL0gTIVAUBUoLQ6jIC5qmQSvJYG3qU0JG8BGjIeDFJ96lYTWK8XhM28xwrqFpax5/7AZLS0N2d/eJUdHM5wSVs3s4ISvH9PolSnnquqaqWw4mh1y7tM7hwTv4dH9rDDF62kayZt/r8f1R3KMkxMSohKsewwJ/1lrTpmGqQOyJi54YG0DqfoX0H+LDWaEJ2FZdS61TIG+XTJNYKlqm2533u0qa7A5mUV1hRrjeQnkSY6PMiL+ziJ1MmsIneTRxMRTO85yyzOkPeoxHA8ajIb08oyxLjNX0B302NjYoeiXDfo9+v4/NcpQy2CLDmIz/6o4wWe7f32T38KsQI5nN0kKVXk/La8e08N29fZv3Pf0Mmc3Eca9uODw8ZGVlhf29fXx0hBi4f/c+4cIZej0p7pOZ4972CW3wsgfx3Uwg7UcUaKOwmU1OmLn4dai0wAbJfwwJDvPO0evljMdLHC+PF4PpIte89vqrvPb6m4zHI1zj+MEf+iGqek4zrzicz9g/2Ofc+QskDTy3bt3i4OAAaws+8tEPMR4tkeUaYzWZkTQra1ORsZaiKAihwTnHvGqomxpjDD/77/5pXCMOi41zHB5PqKpKaKBFTu+Fgp/+I58kyyxlWdK2LdVcgj6KMk9WyjKXOXNuHeglLroMuvMixzmP88JJDyEsNBTzecXO7h6ZteRZhs7kerKpAGtt8UoToxbqHlDrgiYb4YAYHJYCr3N2Nrc5Ojpi+8Emb926w5tvX0sKR8vy8hJl1dA0Du+cLNDRE1UKmUkeocoYRv0+IcvwWmG0DEovXrrMYHWF2M556QsvMhot0zrJIy3LEdHm9Po9Bv1ldBClt9FyvQipwKE1eNfSNlLcV1ZXuHE9sDTqMR6VjIclw0JRlgWD0YjpdMpsPuPgUPGFXy7o9SMf/9gLKFWnRaIR24XG03poQ8C7lkCA6RrvAOfOrPHEE9fl/k0UyrqaMa8nDItzuPkc5SPPPvscn9vNJYozOEIyFPMuonNDnpdMJhPaeUteZDIb61pmJf5RvvXoXDziF5qaqNjbOxCTOmuAwHA0JvhAlhVsPdhhWjW88tpb9HqW8zuHPPfoder9Q3plzuR4SpEXXDizzM3ebY7nTlhPyuJaWdzCv6lx2P8UjxBIq7paFOXT/zqIRVbRrufo3NsW9MiUjxgiNE27wNQhpBVZtndG6dTtnlIkM5OByWhTJJlSpGDmSNANpMWm00EZscUgzzN6vSF5LqrT8WhMv18w6A/oD3r0BwNGoyHD0ZB+v0+WGYpCtp5FngkP3hh8ojqlTyZBvrCI8AuIp/butgiF2qYmILmtRVFijFgXRCKxFZdBoxV5UXC0t88f/u7vMRqNhYqVktSXlpZ56603OTo5pprPaduGM2dWmVeya6nblslMwq+VFkqnMRZjMoxKCTTCGRNvjiR88dHJRiX4dCwVRVFQFiXD4YA8yzDp3rDW0CsLnnj8CapJxWhpzIPNB7z1+hu0TqCe4AM+Ou7du4vVOURNNZ2jg+SsHB4ccueduzz19COUZbbgGteVGKh5J12gUo55VVHNKxKkL7s9a8hjhg+RLM8lcUtrjM0o+33KXLa/1hqcDxIxp3RKArMLVC63mv5gSNnvMZ/PqauathGrZ5cU0M755JEEJPjKu5amcWIYZw15HrHWoExEeYUPeuFRHkyGHYxEWKfEZ0kBZ5fPslrXXK4bnm0cX//aCl95SfHkU0/wv/wz/x7z6YxmPmc2mzGdzHjt9beoZjNG/QGTk2P29vZkMdI1R7MpqhjhvWEwHBCbwPkLZ/naH/4uhwdHqDOa8cZ5zl25zGBpnawoMFrT1DXRB5rgMd4TQkOe7DWyGMiMlrxh4KM/8CQ/+6dLNpb7hOBoZ3NOjmXGMJtuM58f4yYTpocqXUcth0f3UDT44AUSTE1G09QcHB6RRUWvzLBRrt8sVuTxeJFl6n0kCy3gqXHE2NI0LXXlU4i8WH9EL/egcy3Ot9RVLSEuucI3juAd31pSg/e0DRR5jkpCSmLAtxEHZCHDaNje3iNGz8HBEfNZTVXPGawtM68a7j+4z1NXzzGbz2i9Yn/niGk158L5DX7oh57j13/zc2hdoo3Ct17mkvF/Jp172wherNOUvqNA+QCqM/LUMVEhE4QR4wKX1UZwLxH9iPjGpHCEDhpRKopZkA5yc4RAUB6tJa3cZp5MKbIsYzAYUvYLllcGlL2cfq/HeDxmeXmJXq/H8vIKg+GAXlkuYBprk8dM8MTo8SbhLyCyZ7owktRNgAh7onTbigjOEWkFe1MyqDJI7Fp03UDVsb464qnHHqPs9ZnN53z+xS/ivOfRG9d59MY1SEHiR0fHnBxO2dnaZXN2n8q1XL58mXPnznLlylXu3rnDL/3SP6eXDMayTHYHeZ6ztLSUQpJ94tkm2IBOxSg7IJlfJFpmJ8CiY/UUi87l5OQEIhwfjWS73Irz3k/85I/z0Y9+lKqpxBLCu2SNLDi5NWLfEDwpKUkW66IsGY+XWF4eY2xIdFKhjFZVnYbcJD/9mqqupaAmGElrTfSnTURIcm+ZX7S0bUNmkv9IYkeFKAufUprg7WI2o9L11e/llEWWaJNzqqqiaRqcC2RZlByAdP1qI2lKIUGHPnhaL1YD1mryPEebYnGf+Lahms8SDi0zJmsMNs/IijwxSRRn91YAxcraGs9+4Hnatkb2MbLA/OS8pppVNNMpFo+v5hwfHdMGzUs3H/DSG5u8c+cu/aLg7Lmz7O9sgnOcOXOetQtXOXf9MbAlKIP3FfWspqmE5eNnc0xs0ffv42dHNPWM6OZY5Wk2rwLv5+L0iLOHE8b9C+jMwHiZ86troKHykZMQqF3g3g7k/1nJcJTzoz/97xBiTVNXzOcNTdUSQoO1ntVhSXSaV964x707GwBkvRH5YJ3WNVRNJaEqSpw/jdVkfYPPHFkWJQijKHj/889z663Pc3S0v6A7GyMBMdZoaTgI6IdIKh2zxjvP3DdyrWrJg9ZRY6yi9TIzqipH01SMhssUecv2TkNZFhzNG3rlkOWVFfJW88btbV598zbDpZKPfvT9LA1HvPLaO9x+cEi/V1LrinnVpHnYd358XxR36AqeiBEkaq/jpYulprXJJzk5xHWduESNCZPEJrm8AH7CqTE6YpOlq7WaYa9POejRH5Qsj3qUvR7j0Zil8YiyLFhaWiYvcoqyxNqMLJcEHW0MRDHAOqXVK0Cj0taZbrehbVp0Yke8B5AiGQNEyWhVsUETMEqTK1BRCVfde5yXrVfTNLg20jhPlkmCkbGKn/rpn+CjH/kI+7t73L+/yetvvc7e3j7zesadzbu40OLahuAjISjyXo6pZygXqKs53/jGy7z19lvU8znoyLyZs3uww+T4nfRm44IFFGILJC/7zNIrS8oiZ2dnixgjZVGQFX2ZO5i0OMfOdzssYDfvA8F7mkYKlvOO6XSCCxFlI/0sR2vZiWitybJi4eHd0dKszRYqX2uTilhJYc/yjJWVFSYnk4U+IYbIvKqJoSWmUJuO/Wa0gvRaeZ6lG6eWVDCbgju07PSSZmaxQNdNQwwphV6pxbzIpGvT9sTmuSxzKUhVS103ZDaxP6yhLHMZOqeFcQF7RQkDqWuH1o3MjCK4pknJY0LLDf40XbibOeV5QdOO0z0lVtVZIXYYBOmoTa9kWPbQK2P6mVjKth4mdaRaP2bjactLX/48r73ydSa1o5nMWRqvQlZwdHiIeXCf9TPnFnOr4CLBNcS2YVDk1LM5g5Mj7Mkmt3Yf4OdTCuXxJ8KBvfnLv8EruuLq448xffkNZkrR5D3ccIhZ38CsbZCtr1G1Y2Lo4UNklrgLrVO0zlK7QPSGyeEJfZVz7dIGRdnnM/9KYEVbjMgHZ4hNQ5m1BOfANyjfUtQtsZ0T64Yq1tjEXlvxClf26Dd9pq6lMQrvAo2r6fWGaCuQYzU71b6cBvkIFtAubMJZYOQBMSG7c28TDVgzocgLrLZkSpNlsoOdzmvmrWdz95BZE1gp+rROMhk++IFH2f7NLxJ8w+rKEmjF1vYW1akj9L/2+L4o7lopyqxApt1BZOupQOikojM6iMd3drpyRgW9oqBfjugPSkajMatrqwkiGbKyNKLfK+n1emS5ocwLFJqi10cZDVbw9pCCAKSApYQmuqm8FFySoCGS4BkFrXfCi8eIo1yIKWY7gK+l87aaTCkRJUVFCA1ER1M3tM5TO0fjRJzgnMaT4dKigTIExLrAtzBckmGcm/8JPv3L+/zK/1AznWQ0zSqRpwF45w3xX0bJYE46C306s0Bxf6bYvJ0WqBjI8pyl5SVuvrJCcBcBGXZ61zIY9BkOVxgMemSZQQOz2QzvWpaXRlibLdTCvutAfRKrJJy+K+5tK8Zus5nsDm69vc4//H/9COjkYJ0Gzt1NIxqHbih9ykPuOM4y01CLQZgMw+TczGaaujKLdB0pzgJeaZKAJ0jXLEwsKbjBacgUdFCe4iGVexSILkDUirZtiDFyfJjx//y/3SDLhVsuRTftGJGdgPOetnXcvytWxF/54hUO9ocJi383DCnwn0rsLMX2gxF1bfhv/6un6fW8COO6dB65E1Iyj+wuDg/7hAhVVXN4eISxRuAqq7F5QW50+iiB1jtOGkfVKt7enLI5KwhKc/XJ5yjGq2Q658H9u9RO9B/jpRHDQQHthHo+oegt4aMM5ZWP6EI84o/7lsH9fQb1MfvVhLLX71wR+H+//BH+2Zv3GBYZefOENFS2wIVA4wPzUOPtFqGYcXx4hrrW/Nf/1xGRIcF7vPO0ziGA9wVUjCyNBxTlGq99VVSbs6MDZntbsti2Dn9yTL23RXN4yOT4iObkEF9VtE7Tzv4K3hcc37qJqk8YYMgKza5v8UazuraEax1FkaGMopqfNmwqDbtDSlPLrKFpalARpaEsC4kgLAxEh6scKgb6g5KTkzlRy3VfVY679/Y52DvheNpICHlecufuHQb9nPNnlnjfYxd449YWAt0G3v/+R/ndf/Xl71hXvy+Kuwh9Ako7yjKj1xOL3X5/QFGUDId9RqMB46Uxo1Gffr8QwUxR0Ct79MtCaJAmEzqTAoJbdP+d8OGUtSgdX1jgrgvuAERPCOKHotNAUCHDFvG/ll2CUZHMe8nixKOUgBchuMXwyHvPzMG89rgQcF748SjwWBxC51QmQ0exjg3JVci5lugbQgwL9stweYuyrKnrj3D/ncXR+y5Hd/HJviNzqm5gewLbd+XfWe45f3GXLFeMlwaMxyNhxbRNkowrQlSYLnXeyW4jxCj2q8ETCTgvg9SmbXHOJ6EW9EczVtcn7GyN+J3feurbXBDv+c/v+aFU5NqNYyR8qgtEjsL6SDOUtpXYvg6/XCRppZ2BLObJ0HxBs/MJVnFcunLEV17s8z/+ywtpAfruD63h5lur3Hxz9Vu+kwgA3+FMff4PHv1ePjUAmQ1cuXLAdDIhkJqMzKYdj01mYKKeNlnByaTl9vYcrwoyE2jclP6wj28d5y+cw2YGXRRgckBTz0+oT/bp5SU+GAmfbgOT6QnBt8TlVWarK+TzY5kzWU1IVMb7sx+G2UOfcf+9PouibeE3fmm4+Ep3lL7dozMO29ne5O7tN9lYXaFvFPHem9Rvv8XRwQET5RlfPMv5R64yq+CVA0szixycHDFYLmmbBhs8VlmihXktu6eT6ZR+L18MVJVS2Mwk+29LXTcivkzNZ5Zn5NYyqyb0+mPOnbsox21eM5tOMVbT4GiDp2kDk8pxb/eIBog6cnR8wiOPrlP0cw539nj80Wu8cesB0+mEJ558BFu8Nxfy+6K4b5xZ5a/+tb9AlpWUvYIiz8mLgizPcM5LWpES3DriRcyQxEcoku+08MylzQKsRaUBrSIuGAfElKMZpNvxC3qkdGSCjTsUQSbdymPTVkFEViKVFovhmuO2oWpaGqeoncZ5keuHKEyHkDxmlJKFJyrpmGKEpq0Fp5a39S6V6qKTSzmSRive98w2/8l/+j8yn/eSNkAw6G4nweJ5kg9+on2SBsHdHSE3SPqZEAjBJTZPQZZlLC0brt2YUJbrKKU4Pj5MGLMwP0Iq5DEdsw4zbtsW37bSETqHa8XN0FgJOBE6o2LtjON//59+moODcdIm6IUjptZ60aHrLqDFiI2q1ir9pxcFal7N0NqQFwVdTGGbhqjBN1y9fiTzjyA3ftu2clzQtM6zu3tAlmdktsA1PsErAR1kcTBKE7SI1UjzEjmsiiyL/Id/7UXu3l4m+EDZ65FnNhX5SFkKpz3SKZE53cF4LwHlTpKBugQkee7OejZpLkJSbqb7pfs5IRSwYHAZpdBWine/D08+NSMrhjTeC/4/m+NSdoAxkuepdaRp4Otfu8ukNhwc3CfMT9g/3AcFuSk4s3GO44Mphycn2KLPyvpZMAU+amZ1hYuWpdES+8cSAOK9hICYq0/BcIly5wHV/Jj6SN7/I5f+PqujV2TAXJYYldMv+0QDql+SFRbv5jRhzOd//8+RlY4PfvK3UQZKaxjkkX6R430rmpLgsXlGDIE3X77OF/7gWXqjdcqlC5xEjy4Kzj/3HMvn11na2+VzX3iR6ckUvdSQmZ7cEUqh+j3KZYV1jtnhIcr5BAW1xAB5XuKdI0v+S9poCb2OUk+0SownZVA6oq2iqmdoZdnfOeTo4JizZ5YpewXTqgWrmVQVDYFpO2d/ckw2KCnGA1bOrLK3fZ/haMTJbErMCo52pxTlgNW1ZepmxurG2nvW1e+L4l4WBVeuXEwBE2ox7EIlR8R0IS/2x2nbKnTImIzDgDSl7qyBO08UFVMuondEL8EEIXgRF+ExscWmrisk0/7gxJOjah3zxtH4SJVOtgsal2h5MkwriMpIwQziqOhDxPmW2IqYyQW/6Bg1SLcYxGu6gySM7vDYbnov22+rRaSllOL6I1OUnskCFeW5ZXdxyr2NScEXY0whw2KYZrVBaeGwGyNFOc8zxuMxw6EhzxRaCzshhGLB+5cFrcU7GfqFBGfEGBfh377t5gMSIN2dK2uspNZ3KlctGPqFSxWXrzVSpDn165Ed2KlyWKVVqYMcOsqpMYbJZEKvVwoWqpL/tVLi658wft/KNt77bhHqKLCRumklCNoFYpRYuKqep/dgCd6ioiyuGiUMmWStIBxjxXip4X3v38an11taGlEUOXVdY23GysrSuywuFKLP8F6UwVUl9L6madLCKce8K/YhRnQQWoCPcXErePlAENJ1HSNdrE2eF9IxTg22sZjSMuj3kJRMWRyqqpYFMAS2tg/Z3byHHow43rkL1YzCWh599DGGg2XefPMW8/mU+uSIyeE++zsPGK2d5alnP8SsUUwPJmzPHuBbEfD4EDAx4rIew2tPs/7EkxTGcfR7j3JnD174xDmefLphNpuzdu4s4+VVYrRikhVaZgcPeP21W0zqBvPZSFEGHn92RuMrrIpcWBsR2kPyzLK7u4t3jrIsCcawd3BerhuTyQKkI0eNXI8rF65x9sJlnu0NuXf3Lrv7J8wne5IRAVRRc3h4zLDsMVpbY2d/G+U9bespspyY1O4qifC6RkPmS7Kb89FjkqgJJYPaGAJeG4J3TCYNjfdkZSnq6nkr59Y7ODiCqBkMepxbX+Hs2jWy3HBwXHF8VPPSy7eYTOasrY954YXnmTfH71lXv6firpRaBv4+8IyUD/494DXgnwDXgFvAz8YYD5TcpX8bidqbAX8+xvidgSF5BbTOUksZRd7fXdipZQreL8InYtpGOyewi9XihaEgGQ95tBAIUcFjCJjYJKjDSViuj7QOprWnbgOtj7Qh0LQej5EUcp0RlKj7PDpZ1qaOFenCVZD3FnyDi3JzKiW2CXIjqgVnXinZNWhtRDyVdeIeKboCH5lFse8onNKJJ2wvRhmSEoUeqmUx6pwxxeNbOszgpePrrIuzwjAcDdB6TJZlpxbGCaJo2mZx8y+GqanQyEzhtOg07cM0Py8MD2OwRrpVpe0iNKJjMgnDw6SFTGGMSslU6qH3EdPA/OFibxfY+mDQp65rptMp47Hw5WPqpoHEcpH3JMPksNgp1XW9oMhGH6jn85TGpWnbOW3VpghEEAfCLEGGCq2KpBaOkLgnPp3rDurwoWbzwSYbG2folSWHR0ccHR9y9swZ+v3+YkclG0uhW4ooxmGtXXC4u0VqIcDTSbwnW8/FtdRFPGqT44NfDF7rpqVxTnD21mBas4BkJMhFMxwOFk3Qi1/8Gi9+4bM888IHWF0aw7CPVprpyRGT4wOWlizra2soc46mbplMZwSTQXWIrj3WBSqfvJlii06ZxIrIcGmJD7zwBIMSXntlHQCnYBZaZqElm8+wwzHTaorRGl9VbN/fZLB0ljNLT4iOIoucOXcGVIsGnn7yEfo9SwiON16/ya13btEfj1lbX2bzbQmb6Q9LVs+sSm1RGqM8XjdgHecfvU4FGCJHhzPubZXUc0vv7BmIkb2qpj6YcOpBaSBGSQZTirZONt0xZUG0nsxaGYYbizGRfl92BDFGZvOGvMio5o6qdgQFZS+nmsgOziTBn7E5BwfHVPOaQiueff+jDHp9Hmzd4fXX77Kzuw8qY29vlzt3b7O00n/Pqvq9du5/G/i1GOP/QimVA33g/wj8Vozxbyml/gbwN4C/DvwM8Fj67yPA30l/fsdHR4WMySO8o0L64BfbYWLAxIBRARUDubH0jBL8W3t0bKW4O0frPK5xTGYNJ5WXi70VCKZ2kYhBKUvUOUFJRqs4MkYimYzdUuGORFzwhOASLNN22ArRebH0CiENz8KCpqbSwMtavVCvquRUqTsmByI0QesFHq0xC1imCykNiWevFnCs9OkqDU1VmhWQMH9xtFTkmWY8HlMWhRR/uSKJKiTut04DvHjKtI9qUbQ7/UDTNBAC0UfapqF1jta1ElRh9IKy2Fk1dErh2MEsxix2ISiBKLTqTNtOUVSVdhtdoX54aJjnGesba2il2NqaMxoJnTLEpFhOoQauTU0AajHQhQSFeXHQ7IrmfF7JNYZdQGJyPcox7ha2Tvmoui4teAlwBpnPKAnNKIocSd3ZZ31tneXlZU4mx9y9d4+11TXW1tdYWV6hquY0TS0UWiNOg1LcW+papwXqdKEJIWCTyXhIXbtZGN3JsbPaYHXK703HJSJBz61zVFUtorssE1taa8msvO79u3c5ODygmk44f+4MysjzZZnFWKEat22QgI9+gSbQH48p1RyrauYofOwLpOR9ovkKFujamjIv+MSPfpgv/3bGb/8KPH79KleutOzs7jOb1cyPTwCFVzA9OcQUfTYuXMeHNRZYYgzCboqKt2/doa4mTCcTjM7YOHMB7xpapzg+FvpIv1cyHg9TgyJ2BK6BWR3JswGrG2ts3rtL7ZrEhY9gLegeKHGotQ2gGozKiEjSmzF6kYClFRRZRlBmwcIqegUhKWytFSRCEtekAVNGmpXpyQmDss9oNKauKlwQEV3rJNnt7v0dxuM+j9y4hoq3GY8HHB6cMK8CvV6PtnFYe0qT/XaP71rclVJLwI8Afz4V4gZolFJ/HPix9GP/HfA7SHH/48A/SFmqn1NKLSulzscYN7/Ta8QYaN2MTGsZRqiACoGSltxojJIkHkIUQyPXUk8aTuqWk1lD7aTrbl2gcpqITjBJZ4ZULLoc8RdLaUkgW+0opldCMRNlnWDfkrjUtm2CfyDhHqc4sTZYnaE1GKtPIZVUmLTu4IXE+EjFqsNMffCoxHVWnfw8iqJWbI5ZFODTibA8j/ctSimGwyGZNRRlQZ5b8lxOuuIUc/cxStwgLBZPWQweYmkgFLyuO3+XAKd1hFaGojpR7pQ99YiJUcLDtelglVOxjk2Ye2eZbBOsohNevBgYcFrQO6sHrRW9XsmZM2eYTE6YzaaLTr7r9L33NE2Hs4sKNPkdyveT785pHsCpUVueWazR6Jiho0lsH0+eZcm50KT0pLSTSAueQIcPJ3rJOe/3BmjVcHBwyNr6CqPhmF7Z4+DggLquca3YDhdFztHxYeq8NbnKxDo5z2iaRoK8W5fOQSswYwioeLrL0akpUKi0aIsLJ12Clk87zHSO28bTNAIFZcYmWqZif++ACxfOoYm0TU3Tih5AqKc2OWkWFOm6yjJLwLO3tUMMUBQrVFToNHQOXfA80NQ1N2/f4+atTWK8AsCHn3s/n/jkE+wdHPGlr3yD2w92aYKiblts1uPcxmV6wxWOD+3pvRICUYuwbfPuAw4P9wlobJZBkIG+UrB/ILbYddPQhXvEtMt1ITCf1Wg/Jy96lL2S2bTLXVXorEfRX2N9NEK1NQ/u3cTXcyFHKC3wa4y0KejbaEVhFRvnzzKfV2lIH4kxw3sxoCPZYvsATSPXdJ6J53tsPCbCsNdnOp+QZxlNE/BR0UY4mdZ89asv8egjT1D2NtE65/XXb6IIHB9OOTg8+U4lFfjeOvfrwA7w3yilngO+BPzHwNmHCvYD4Gz6+0XgzkO/fzd97TsWd6s85/MJISQ8u66pqppJ46iahtncU9WB2nnaCD5qosrECU7Jgev4pjoZb0mXFboJo3BxYxRfjY414QN4n0yqxGMphpDYMVJYUaccYmsMOjMJgngIUll0q1KIF4Ei6RFRqeM7TWpa+GgHFvCLSgVJJ7FWNz+IQbpHYwTO6Pd7DIdDemWBMYLrdcZj3dY81fQUPBwkRd1JvppHBE7dzy+shpH3WNc1dV3T+e0swiKKhzoFrRa7k+74CN0uFe7OpyMVoY4yphRihWCSi2cq7l0xDyFguo5fK8qiYDges3+wS0hDrYUfv1I0zj00dKRbNRcKZlTnQ+TJbC6H1QVm8xl1UzMaDGXQmRazbtfUuhZr9aJzt5m4iXq52JJqVKFS1F3wHXQWyfOcGCN7e7uMRysMhwPW1tbZ29vj1q1b1HXNeGmEUpr5fE6WWTIr8FQHm5x28g1NI0VcGEed/1J3rSDXFqeFv4PVfDilSC4CatB4F4i+wbXSuByfnPD88x+RQbaJ9HpjGfg6+ezT6ZTJZEJmxQYjsxl5Ybn59k3efPVNPvhDHycUy6AGssihcG2LihneOabTmpt3dzmenQN6WA3jIqe/sc7qj/wQn/7dz3P34ARMwXC8gi0H4tNuZIVQgNVazAUVLK+vsbS2SnDudMic7KQfLAks052DmGpATDYYrXe4aYXRDb3+AFtUoMVG49kP/ABnL5S0Tc3rL38FraA/zFBR41qXQt4VuJx9oFeWjMcjMmtRvVJmMa1jeWmMUi3jQY8LF86xs7vNnc0H1HWJ0Rl1U6NVjlbQVCesbZxjXh2xvjIm+COmVUsAJtMZm5tbNHXL+555jOlszv7BCufPncUT2d7d+04lVerqe3739GdeAP6jGOPnlVJ/G4FgTotXjFEpFb/tb3+Hh1Lq54CfA9hYX+FLL71D1Sqcz6ijSheJDBKj0ck+MzFPjE5eJyQKW1gMyqLSRB8WYdM+yYlPuzzByE3nC5/wc4myM4nVELF5loI2zILBYRJu3BUNbcTzkdjNeeOioKLSACy51XUdY9d9dx28SgM6wWEN/V7J8vIyZa/kwYMHbD54wHg0ZGN9mfFoSFmWdJx1lRaAiMSgyedR6e0JJgykTjUsBqzRJwVtB2WkAtl52reteOxkWUaWSVG2iX3UPV832JSPoU+FZQ914THGxHTq7AtOB1GYVPgVdKuR0ka23hqU0RRFwf7BAbsH+6yuri6Gpt1zV7VI/L0T50oV0k4EiGhZOUMgeMGfSYlCPsDkZE4Mio5dJe+/6/hPz80iziExg7qwCOTMp5E6cl0uZtqBspfjpy0PHmyyvr6e1M0r7Ozs8MYbb3Lp0kXW1lbp9Xo411LXc4qyFC98o7GZJc9zikJMq+S/00FxRy01iccb1EPn2Mi9Y0KazyzYTfLuIqHLjCYAo/GI9z/zfu7evcNsPkEbRabl9b3P8c6LHN+JwVy/1yd6x9HBIW3rePvtNzl/7UlsmeEaR2Y1rm7JtBHzsqZl/3jCZFYBPTFEUwpjoMwsLzz7FAeffVGEa3mGS/CmsXI9FWXOM888gUTvSqMkofRyx4UQF8dk560lAM5sbPDI9YamqanmFdPJhKOjhnl0NK4hhgqtFBcuXaNX9mjqnKeefpbWb/P6K99gf/+AvMz4oz/5cdaHGU1dsX94xP3tPd65s8rdd2DUz7l2bsyZtVV2trdARVxrePSRc/jouHXrJhujC7zw5NPc2d7g1W/e5sK5i7TBcfv2A86dO8PGxpAYDTv7Zzk6OubS+XW+/LVXKPOS9dVlgpsxnZ5Q5IpP/tiHOT44oMygqiqUm7xnjf1eivtd4G6M8fPp37+IFPetDm5RSp0HttP37wGXH/r9S+lr73rEGP8e8PcArly9ErfroWzdVViEVEQtIb8qSlcbQrL6TIIh5+qEOZO2obJFdw97nactuFId5qsXW0aTGYzOiEg3iRYqkyJitcZklg577ZgOSklSUgff6OSv4rxY93Zm/yHh8B2OjNSzxSPLrARh5CJtXl1eZjAYUBQ5IXjmVcWFc2fYWFvBJLXkYlcR050JiDDqdHgb07BThrjh9E/EOVJHGebpmIaVVkph56YnFskPwx4sjqdOUItRBq1JKlI5RvLznXOmPu3mO8XZAmM/zcI1pjveXfh4Cvkwwn46PDzEWstgMECUyI4YxazJJczfJ9zZB4d3Am8JLi2q1boSS4M8z9NxUiIjjwpjc0JUONdClPmOMZq0+aEbcviH8fg035BdmJVFPciCJPMRvxDCDQdD2qblwdYDvA+sLK9w7tx57t+/x+uvv8mFC+e4eOmiuELqQF1XZFmWDL1SkpgyaC0BIx2zpm0d1socaDFXkJGPnOe0C5NFNKKiZP66rpMFYlr4W+1YWlriueeeY29/j+nsWDIPFrs5scwWfLeP955+v2ByPGMyOWFlfS1J+x3EOW01xamIwqLJ8C3U9Zzj4yOmszmwTO0iLioypchzw9WLG/zJP/KjfO2VV/nm62/R6oKoLW1VSLddt7z1xttYK0yoQGck2A3MO1puYG/nGnCJw/197t66JcW9mlHVM+rZlHZe4V2FD6K6Xl4ZLdh2Ozt7bG2/yt7utsxoApy5dIHn33eVTMsMx/nAZ/9wg9/9PfjQc0/xl/7sv4slcHJ0wO7eDtpYaufZOzhgKb/GYxfWuXhulcvn11g2Ob3BkKJX0hwdoKp9nnv0CXyMHE+XqGrHwdGUUjnu3t2kbwO212d9Y41Qz3n08jrPPX6Rfn/Ivbu3+aEPfZwvf+0XvrW0Lh7ftbjHGB8ope4opZ6IMb4GfAJ4Jf3354C/lf78F+lXPgX8FaXUzyOD1KP3wttBGC6hG2Am453TVJXUeSSVX0f6k4Mv1r4qiIBIOivzEOYN2loKW6R/S9fVFRSdfEOMtalABGySY3cMlRjjuxOdYiragIpd9x8T9urwoaMeiuo1KrnobHLoG4+GYum7tExnb1rN5wTnaduatq0Xu4yOy7147S4MON3M3Q3o/amLZgdXyI8phGopv5fZzp9ehrNBSdDJcDBEKbXoijv75Q6SMCacHoco/PrTLvx06Kl19tCxP50/dItp9z2bFiubgsNl15Kl4IrIbDphMpkyHI2So6MMioWeCLVr8D7QuDR0DKd8+wU2rVTabcniY4xBeRnWu1bmNhJcLgrdthZ1NGkQqJRI/I0RCX8XthKDLPwxRuqmhiJLBnVpyB3lfBhtIUaWl8ZAZGdrG+8ia2srXLhwgTzPuXt3k52dPa5fv8r6+hrWZrjW09SOslewgF0QCKwsS6wNGFPL4ub1v0af7OYaITy8Y0V2J0rstLvrSyVHSO/h937/MzSJTdTNS1zr0NZgjKVtG5q2oSgKtFXUVQNorl69RtQK72qij4TkdW5tRmimmLylOt5i637kYP8R4Dxv3b7PN9/2jMqcIs/IrKWwlg8/+zTPP/0U+9MZ2/uHvHNnKjs5Ak19xGzaUrdNgppIUJVLA1PRYBweSed+eHjA5r07BNdS11LMXd3gmwY09Ac9lpbX2ThzCa0t3jnu3b1LVR2LCRoBHz137tznhz/6IWmMQkA7RzEQ8VneH7J2+SoxOEZnz3K2fZTp5CQ1KFBYsN7ha0dJ5PmnnyQY0Uyc+ekfpZ6fsNTPMTbj3PKQ1ke8h+ceu8rde/eo6obppCIrC3o5rA4zfuaTH0FhePPNksGg915l9Xtmy/xHwD9KTJm3gb+A9Cq/oJT69xHF+8+mn/1VhAb5JkKF/Avf7clj8DTziuDkZLVJLHP6fblgo0qdGtI9qrSCayNWrzKsyxLUcRr2kWUZipSEhFDtbGYXnXgHVxgBzfFRuOfdTdAVTSnGYVGkYpBu1WiNipIvClEu1qJkPBqxtr62oMGdTI7RWlM3NbPpsQiQlHSD1tp3iZeAd/0ZuiFrfCj1qQPWE9vEx5CsdjuoQAp8Z2qllVrAJB0k0kGx3WcMCdqQDlH4vzpx00/52vF08VwMjnWidJn098QMSoutMVLwjT6leXYPQyqW8zmTkyOMtSwtLxFVwrwbWeRjFKpjCCIGCl5cM2MIECImShF0CTZrncc7cQuV2QHENlJXFb51ZNZgdbJaSAuaQDSn0FnXCPggoraHKZrammRTIIwStJE/jSbgsYmCurK0goqG7a0tvG85e3aDjY0N8rzk/r37fP1rL3P12hWuXr0iUEhw1HWFtSYtenKejNbYLJJlirY1OCcDUtmtugTFdbuMlI/QUYmjLD+yqdBoK8dHKUuW9xiMltk/2MN5T1n20VrTNjUnkxlgkmZE0TaOPA/Mm5ai1+fJp97HyXTCva0trFI03kv4d27IjcOqQKiOmOy1zE8OAfjyF79IVd8mz+T42SyTIp/nAqeZHIxmPisJ8SmUUvR7GUqDVrksSokqLSSBFB7tWzbfECXr2sqYq1cuoILMY1xqBmIQcoZWkab1bN9/QNPUhGA42t8itLu0symhadEo7ty5x4PtPYqyR1EWWJOjTBIx5SWhXCZ6hyqk8euP1gnOic9VbGm9w2qhXRaAa0ToN1j2hHYOrqVt5sRQ0ytkxxZixqi8xGw6lZ143TKvZtjoeOqJG+xtbTN63yNCA3qPx/dU3GOMXwU+9G2+9Ylv87MR+Mvfy/N2D+8jh/tHRNUlJMVFwbXaoLUV/rgVSlxEUma6bb/WYtylFEIzVHLyO4xcA1pb6RFVwr3T9l2pbgurF5BKN5Tr4AbpdB8yCyIR+JQ4I4ZE07px9Rorq6uMl4biBtc4jo4PmUxPTql/CoqkplyIT5TAFV2BTcdx0YX5KLuWbznOp5RJeacJgoqyC+J0e75giUCyZNAJo5cuvRMidT8r2Hs361RpPhFSPqxebO27ot+dB5UWj47gKItJ6oKd4/jkBKUUo5GEBMuhFYy8aVr29vbE577fkw47hgXG3MFj3Y7iVM2Zdi4+Ct/fnMJi3rvFItIdD5eKn81sYt0gplIhLCinWouATKVrIaYiIp9fTOG87zDsU7VocK0I0dLw3CuZgWRZzvLyGFTkYH+fGCPnzp1lbXWZLLPcvXOfN994m6OjIx5//BEiEhYhw1aXtABIAwJoJbRMawNZltE2wu1v2gZjumASt7hWJVUy4lJjQLoOtNVEDDYvmcznFP2Cw/1K4uR8K576jWdyciKLm7X0Siu2ydEzXl7mEz/1U9y6dZP2y19mOqnQ0WGzLKlgSfOkgA412klXf/TNu9zee4moLfXKMno0xBpLWfZOG4RU3F3rqaqWl756D5LXOrHz4Dn14ul2XNv3xRVya/OYN17ZknvCtzRtS+OdNGc+QGKC1U2kqWWQfvBgglItbatwoY/SOZ4zzJpVXMiYzUSturMrB7FuHCezWppLa8iyUhhLPgpEpiJ1NWfmXDKRK4hWYKQ2NLLIxBZdTwj1DBc9mYZ+bsHOMFlOYTW5zYTkMK/ZubOJbxtCU2MXLdy3f3xfKFRjDDjfYBNMYlPH1+HcRcrxVEYtbAe0Pg3FBmG66LQV19pIEQiOU7ZGB6tIIVzEvj2EkeuEqxltEgyhF5iu5LE6VGKaxCBFP8aIySxZljGbz8gmOVU9IyILVZuGfcDixlt87gQFhRjRqfvoOnOF4PpSlOOiKJG2o0rrRZHLEh0seBE1BcViq744PiFBR+k5W+cWhl8P0w+zLFv8njUiLLPWCA6dKkMIcSGK6Yq7eGqkuYARS4GOp6/S8HVleVkKfuK5Ky0D0u3tbYIPrK2ukWf2dCFKXv5Kny74nXy/+3vsoBgvPHajBZ5pmiYZhpmEZilikG61qmvatsFmWRJ5xgUEKGwjgcuyLsRFObQyBG/wWpxBQwhgjcwZdMfBFvGaQnYuAfHmd67FWsva2grGWPb3jwjBc+7cGUajPo8+9gj37/XY3tnkpZe+wbXr1xgOx/R6PULwSe2qEyUzieBQOIR+m2cZTdtiG7vgyC9YMz7ShabYRLWVIXxSLVtDnucMRgNWVgruvfUGddVQpwSp/f0jXOMxJpfcgjyjl+U41zAcj8AaLl6+wPbOJl/92jcoytTVKrmvg4+gW0pT0NfSoHzmq38WrVpAEcxpEPzDw3iBHRXVrGQ+6/FP/8s/s7iPFhSZd/1V/uadHKOvf+5jvPLFjzz03W/93bjY9LbNkBgVL33x/043uOh+/u2XM37zlws6IzfZvSREoDSoXDJTZ3WLm9ULK2zVSliL0oa86GOsXBPKgFGaps5QyqN0H5v3UAPPfDajdQ22V6L1gF6vFWhHa4oYyK0itjUxygDYvndt//4o7lprhuNhGrqpxC2W4GHxzZBtvWDuYjeglV7ANVprWQVTwVsM9rqfS51vJxdWSok1fOpIY7IS7II6EicHvEPFZDLloaMmFplhPB7T7/cYjUZkueC6VhuCT3asXUhIh8WCCGzUu2mHYTEcFfqkJEOlAG0S5EDHfhEDMa00VTNfYP9V6yQAQ0m3G9KF+XCSe4yRum3RWjoBSBxz3dnrZnjvhZPenRelTjs9leCtVOxNUp8u7HcXkI3ALiHBGNYaMJKIJDL+mAquwAoPHmyhlGJtdZXMWllMO/uEILbJ3iU6pws0jXsIQmKBsRtrcERckI5autuk3CXRCGNSPoeAMeK/b42RY6rF0tkqRefjEul2PzYNsmW4bExIuHQ43dEZvWDL6PQcqI65JLCQMQI3Oe85PDwkxsj58+cpy5LLVy5S9ix37tzltTfeZjqruXblEmUp+a91Pce7ucwg0ilZML5USEPZ5DFjdIKvElvGeZxOM6yOgJAaocxqNtbXGPT6GNUsglBGwx5LdsB4OBCRVTpexIgysosbjpe5u7lFcDPW1laJQfxy5FqW2ZQtckbG4mPg4lMvc37nMZq6t7im1L9erx+q4ZFe/9t9/d1fWPz/u56EdxXyd/3toXsixkhW7Mm9lAYQMUoanFKKXr/PaDx+FxMsAtcedfzwj2/KPaXkms9tgbI2KeMT5bh1VI3DV47oWkneShkQKCtqcl2glaLISqazGaE/gKwltC2NipKO5VpaYyiHluDmhGbOwqHsOzy+P4q70QzGo+TVnqLw0oDMGiMXpRLL0s5kCXMKWwiGfEoBtFZgHK0NJgVLh4XnjHS3nZBJmBpmwX4xCadvm5oQPUWRURQ5G2c2GA4G9HoiKzbWyCCPJIJKHaXMV2N6n2HRfT+MpfuEA3YLjfDrTyEAuTHld7M8kzmfD9Ldp51LnuWLxcFosRRWWmGNXghx3r0r6SIGBY/Oy0KeP8sWx7BM7ppw6pnRMXU6Hns3WO0462aBsac5R+p5tBKxUhdqjJGuXqMhKqqq4f6DB/QHPVZXV3BtoBPny6LW0dsELuqKOOlnEjD2LhVnh6i1ybxMKYVRUlxDFFrsbD5fzE0gSlpS6/AJ4oEu1UrJgmBAu8T8CQH70HD9YchHLzo7Tt8PiR3kPcbKdWysYWlpiTzLODw45P69Tc6fP8dw1Ofy5cuMx8vc29xic3MH7wKXL52TBsIWaCK+FRprlstC60OyU4garF7MWGSXKGrHoA0meBHHtA0aI1BWECvki5fOcf/eHfqlZev+JufPX2JaN6AUS+MR/bIUUkBmBG0wkbJf4ueWnb1dSutpZxMJN8nMgoKrjCY3BmUUznuW1u/wx/70fy3DZps0KWkn7RfnXfIbQrIYSWMQVOzEYw/53ne7gxSbGYnvYgzF2IkfJXu188rvILtu59y0LSEGrI8iWmobgaGM4vFnHueP/Fs/LbCj7qBK2U1mecB7IyHwUdhysWlS7oQHDZmx5LoAW0rTGSNN2+KD7CwJHmuUwFhZRtkfgTaYMicYh9aKqBURR7SGORpvc6Jdovr/Beb+/++HdMnIjaNUKswWobN3Xtwa59pTg620pQQeKvLp2br2G8G15b5Lq3UQv5XW+1TwWfimhOAYDgYMBgVLF9YpioJev0dmC4qiOMV6SZa8yZGuw66j79RwMRV56UA7Faj8frcokaK8pBDLcFclyCeiUpGfnUhBNMZS9PJFUZLu01Cmjtg5J92j6gqfHBdr7eJ9y8KXyYJgDDbLElPFLrDmU6ZNXBh0aa3TbON0sNp93XYDUnW6KzJWFghhNKUhr5dz6CNMjiccTyasra3S75Wys9Eyo+gUhZ34RryyTxWziz4tnrJiIEFY6brovmes8KxVwsnbFGlX1Q15B2WpBB2EkMLVPa4VJ8uQvhYSTiZFQeY3C0ZOuu5c26ZSjrBnlKJtpHvWWmODlbzbZGUwGPTwzrG7u0/TNFy+ciF55w+5fMly//4Dtra2mRwfc/XaFZaWRvSKgqLIaFtJJMrzPDUjQsVUUaVQG0XMxOvEGYt3nuAdziuMivg0awrBo4Ji0MuZTWrmJzPu398iqC/z6JOPcf78ebSCk5MJVTWjPxiQ93uUWUa/3wclLJcL587xlRe/ICHr4yFKy0KtFMke2olmBYs2LUbLeZVrSHZxaC0aFa3xyeU1Ivem7OKCfI50TXX3iBTx1G13MGbHHApAaMUmJBXb6EUfIHt2T8ChtMcER1ABrz0xA6MUygLWoXWb9A2cQrmAa8EhzYV5aBaF7mInRVPhY8DVQnToZlBKW/LMojVYpdFKBHlNIzWrTTug1sgcMTM5PoogzyDq7gUN7Ts8vi+KO6kDDJ0QJ5BOmHTuwmNNQhSlJAw6re7d1tTHQJYyEJumEaZMorMp5OdCkC7QpYvAqCiOiP0+w+GY0UjyUHXqfh/mejdNtaDCiaRd3AZjGr4qZUQglSL2EiK/8J2JxIVg1qfAZO+9wDCoBabugpeJemK9mASTZDHg5/NUlC2ZlqJtMtl9xKSODU66T3Gu8wtcuoNblDKJ2aMX/iidgVhIQzNrLc45MRezOl1cBm1s2h2Y5JGj0sAsLa4kV0/kgvbey2stGCWBg/0jmqbh3LkzgiFHxAsoJRJ1uL0EfqhFUe86sdPzEtJxf+gCf2hhhGTspPViF+WcZ1bV1I0jyyw2EwGQ89XinCyaoUDKKNWLIBZUXFwTHdsqXb6IDX8UP/7ufCcs33u1UMwWmV10a8NBn7Z1HB0dcfv2Ha5evUy/36dX5lw4fwajYW/3gG++8hrXrl/hwoVz9KzYMmd5RlPXeO/FWliRFMxJWKcUPoK10jz4VmO9pmlUymxFylKEfp7Rs5a3br7OZF7z8jdf5eVXvsnK0jIf/5GPc+3GNUbDMSHAdDLFuYZe2SN6ESHdvHmHO3e3mc3maZCejotRUkBDKtDO4QI0vl6IorowdzHhMqisRPyd5L11LkxyvtUCbj1VP6s0n5P900JIiBJiRdfI+RafFoPQOrQSfUMbvLwHf3rPyv/LfWu0xjtH0GEBsVlrFu8hJIKCwHayQ9Bpl7rw/4mJpCCdQfJDCmk2IrRR+Wwy3NdOkdkMbY24UabFuwki3HP1VGpF+z+DmL3Ui2KtpWldcgw8Zae0Cf6wWryyM20kHCI4YkhCoRCpa4fRRoROLqkxU/o6RjMeDhkvjcgyy9J4TK/fT/j2wwpWv2BNxHiqBBRMtuO/P5QylHYH1pwyajrMvEPTm6aRTnDBH3cJl01e9GnY2wVKZ3mG8fI50NKNFXl2Ch2GiNd+UYQ7bL/rJmM8hQ26Lrs7lqd0RrX47B3nHFhEymXJsVIYRwqj7UOdeRdQoFjQBRWomFg4SQZqlUkXuudg/4C2bRmORqytr0pRTowl0tY7M2YBmRhj0rEPC5ip2610HXzXRXXD8IVS0Ydk9CXvz6WbeT6rmE2qtGuTg9m2bsHf9759V0d0OrPQNK5FGdAWjMpkeJ3OISoSEyy1MJ1T0qvKrCQuYDdrZUcq51kzGg9QOnJ0dMzm5hbnzp0lyyxFkXHt2lVGo2U2N+/yzjtiu3v58mVGo74M2YqSEDxNU2OyDG1swtTl/Rup+BijCUZomlmWk+cO5yS+0TnPYBB5680XeekbX8dFjQ9CHtjaOeALL36Nt2/dIxC4cf06l6+dYzQsmSCeK0Zb1lbOApbj4xMiSQ/hvWQE2IwYA5PJlP3duxwcnjCZTgjOJ+Ws2CaAiOx8VKgoISkLnO2hKiGLpkrmXSTPqA4eS5887SbVYscehdEvmAoGRaZlFhQ1iVGnMMrQy3Oy3GAz2S2XRU/u9XTNGK1pEytJG5PgPzm+XZ8hdSQQbVzsir13aBTB+cU1HhCrkeB9Wog6dhFyvWnNVM0Fvkotv9YWXfZEvZz9GxqH/U/xUEoSTYgqGTaphT9yt71WitTZCVaH7xwjZfqvAGs0RI/WJBOtjOGwz8rKMr1eSWYyUNIVikCnRqmHDn5iyYDc9DGEVLw9MTqssYvvd0KRLmzZRRnYdtQ8pYQ21RXb4Lvi7xdMIO+aVEgUNsshSIdqlMJkGptnC8zapuJK6jhijAv/965QnXbnp5L/rsNZ2B0sirFeLAYPe8F0Hbng5XoBbxsjQzWjOtuF0y72/9Pem8fYll3nfb89nOHemqve6+7HblI9sElxpigiEqNEsi1ZlmRDUgDDkWEgkuPAQQYgwx+JCAEB8p+cBEEcILAsJHHsQJblOB4UwYYiMSSDOBJDkRLJ5tBkk82hhze/mu69Z9hD/lhrn3ubbjZJucn3XqM2UHhVt+pVnXPPOWuv9a1vfV8CTMqg5XEuASYbutXA9WtXMTnx4OuuiL41splnpQqSjEip5vUGOY7DS6iem+dXgm4J9MJyKg2yqBOVoq8vsJkwhVKIWAyNrwSWQd5+GYCJUxyZtLl1Q/GVnzJHspWmqodq2vA0kVD4pryfExMJgRQyInznm1ow3qpiZlr9W4nz83NeeCFx+fIldnc9kDk62iXnB7h27SrXr19ntVrx8MOv44EHHqCpPM4Z5nMv8gTditpX06AexogWfDZgHVmTAXnfDIPRaVoyxgVu374GaZBnyEikefHFq7x49TqZzFOf+jS7u3Pe/L2P89a3vZN+sNy8eZs3Pvkkhwd7hHHk/OSUo6MjTOUJY+DsXPRRbty8CSGDq1R+utYAqQ1shSHPFwvGoaN4xU50A4U5E6z7OOWb5fMpoECZ4haegcCk0zMgtY3Y/smeMb3mjME3nt3dLS4/dJmqqhmGkUyQKrDM3OSI0aRDenaaNCmtORtDCAbnopoDJU0c3EueRTnuIN4U0+vyvayJWwnu8v/kOMIQOE+vYKDKPRLcU5LGVlXVYKQ03hwekslTxTxDhBh1etDRNrXwb7fnKmHq2NvbZa5ZuVFopl+tGN0ozZsUp6Zryr0+4AlrpemWYtGKl6bOOAiVbRzG6ZhlQyi3X9Yko9fx9bUC4RhGVSRcQz2FEjnhtlbbkEaFo4Da11hnhRrl/dokIxVRqIRzEedVijat7+6SxW5i0qWElO9X03FsZvWT6JfR8l77FmXUe+KQyBMjQ0QYbUZGTI7KOrCMY+DGzZvcvn2Hhx56gL29Xa00pEdRyPACUwkLKGeBc4ZhYLlcTsF8UqYMkTKYBkyqiVIW22nTdk4Ce9aSwHnHajFI4yyKqqXBTHTJlMqGHktyJ8EmBMHtY8BYR98PNE2ryUbWTTVNEgvlmpf7Y/0aE9Mk5sQYIlXjp0Z30zQcHR3Sti2r1YrT01Nms3ZiIj340APs7u5w69Ytjo+PuXr1GmMIvO6hK8zaBmsybdNSV5HT0zOqqmI2a4GMGJbLvEuZGi7N8cpnNQ5p+Nmf/bO8/e1v4+nPPcO161f51Cc/yY3rp8SwTp5TNpydLvjYRz/FZz7zRX74R/40j77xcWJcsb+/AzFx+8Ztdrd26Yae5WLJtavXOF+sFD+PoB4E1mqFKjKwxBBZrpYCI6YiKQCT5rfeeimntem8Vs4WacxOT0AJ7tMesL5nJJ4b9S61oMOLgpmvyRGr1YputcJax3K5wnmZdrdW1E+jVoviULYeckyIFLjxTntxqgHkZUDSWpF4XpMhlPptyvlJUliYa87LLIY1a/G92ntGbTy/0rongntOiW45wBzhpkdxn0+aAYoBRqJuJPPwlePw8Ijd3W2OLh0J5ugs4zDIjqwZnwgyieN8yZ4LRpeSWMGJBgyTG46xhsrXxJjpuhVVJTzpmCIpimJiUsxfmoaRfhyUeVIj8rP9mklhDOMYpu+N4zgp1pXA2jQ6pOIMIMe6jJ3qQYPN6DSeYJSVczi92NatZXe/UcZe4Jmvz9RLY7f83wl7zyIdK98romAGctLycT25myMk1VWxCMV0GAe+8rWvcXJyyuNPPMHe3u4UMGXC2MhUatGHV956TqgXa5rK2bKJDrqxxoiydooksTTHrJXgnJTymjTR7nuZaD05O+Xs/Fx7HIKjZgvjKBt5GEfCKIwQYRppleOYrB6bWpqTzlpcLVRc6d94OQZjxM5RPwrd1ntH4eV3gzAxYk5U1Rr2kYAsTKyu67l+/RYHh3vs7u1iTWY+n09CYrdv3+b2rduQ4cEHH2Q+a3Xy17Gzs8tyec7xyQm7OzvTTEE2gv26wj5TLr5PkHJFXTV8/3v3eNe738LZ2TnXr/8Yn37q83z4g7/H889dl0pWq9KULf04cuf0DrNZw/b2jMe+52FSCDz31au88Nw1QooMumHL3SEVNtosNblksiCGMuCrmqryZJ1vkQa+VWaMQDRVCqQo7zuWqZdRMtuiV1R0lZx1CoslocGqeXnOYEsWbhNJ/RaMkVmadtawszPn6PCAnEXP3qaMsZkhj0LXdoqfYwC5d8oz5zQOkbO6rgVtLousg3TehaQwRnGHq7yTZ8M7rJdqrtL+X0ZgzhgTy3Ep2a69D6iQGfCV7GzeCuzQLZdY55nPZtRbDXt7Oxwc7knT0zci9JXXE5wxZZqmFQ1lUKaDxVe14GJJWFKlVA5R+OIJnUwkYayU/lVdYcaogdHjvezyyaZJkjWEQI6yQbTzOXVdSZDQRpFUDEX/fFBXIsFSbfF5RRqclfd64SPjMKimhydECbbn5wsRvtJGnvUOk7KwXaydAvymFIDByGbnRII16zZfAv0mDFOCetFWl1KwMPTX2L00assVU0lkZ/BGQnsYRxZnC5798pdpZy1vf+c7ZSovy4g4WYTLyDD0A2jAkwfK0neDjIhvMGFG9RmVqsdO7+s0tZqFZTWEuG6IZpQvDxhDPwwsVp2wMYgkk0QPZVPL3mSqWvHpVBq2kEKU16KMgTd1IxlWKFCXIQbJEr28EcRxpKlrslZQ1ik8oBusnIuwbsBg9U1pmgrnPDkZlsuOmO6QUmZnd2tqYos6puHmzZs899xzrFYrjo4OOdyXaVeMZXtnjxACt+/coapq9nZ2lIBQmtRraDCZhMOQrMFGqep2drdpZg2XHniAd73znXz8Y5/k937/9/nqV5+nHwRKywZu3LhO33Wcn55x7cWrjN0wedQOygyTe1xM1Y1WhCUxKsywkpEP46hQoCZ1SWYcsAp1OSvHqjTJSdETkdeAzBDlBnBOhrtihogQFcZB/XNTkdKTflfJiAsbpgoO70d+9Mf+Td71zrfSDx3DMLBYregH2eTCEAgKC5fw7oOj0uo3KKSbssw3kLP2FtYMq4T4KJckaghRJt5TomkbDAhSUSqELJAoeu+u+xEvv+6J4G4MhNBjsmNrq2Vna5e6bdnb3+WBy5eo6hqjDYfCkghqWitZqpUHRDG48sAaJJux05TjWmQpg5Y9Ui6nOk2B3/uKVMN8PteHPU2ZQGl81nUlGPx0DmZiR0zZStabEMHHM1mzQKsZ/iDaId5LE9lrNhiilI2aiRcud85i6+WNTICGKHrWxUi5BPaS8XrnJEvw0LYtdpoqXYt5lfMpjUGQYLnGpM00+Zt1Ey3BXZqxjpwNXddx4/oNbt2+w+UHH+ThRx5WYTCB0sYxiDyv6sFMfztKVjyGceI3r+UNyqZSJInzxOgBgUVEnkAs9KrKMZvPKWTnEGVadAyBoVeJhSy+sbPZXNgmITKbzVgsF/IwRaGglVWUEXNOeF+xWq2ATN0ItNU0jXjl5ixuO0YamSFIUzfre7pZNZWG2zjGSVUz6/CaNWK+kg30fcedOyfEGDk6PJgUJ3d3BeI6OTlhsVhOtoNFWtjXLZcv77G/d8DNW7e4ev0Gu7s7wvIwBU4oMsdSBTlrwHgcYhkoTd2apvL8yJ/8Ad77A2/nmc8/yz//fz/K5z7/LKt+ZLE4pe+XvPjCyAd+94NiiE7hp5e5A91ARzU3nwKiZOPlZ4oT1kvYTwqi5JwxCsOaLPCQ3K9xghaLkqZBNlGDYRgzYxiwXqr1dl6zXCwFsivHUCDFyeoyY0nE0fLQA5epK2jqGcZtcxmpIvtOqKin5+d0K1HqzMbQr3oGrOorybOWpaet97M8v9asdZrQTV56cpCzJF3jMJKzIUVJFI1WMdZZ9Sie+v7fcN0Twd0aw5uffIJLR4fM5qJXHikNkKyMhhKYLDlHKXutJWVxe0EfDMt6uCklsVVzxpJjoPENuWZilmxOr6478VkrAjk20QfP2iyVm8ErrIOR4BZDoRwqzps3m5drH9RYmnbWCJOgLeeqx62YeF3XWMXscs40GyYZco7y+1vTio7MxlUueL6Uhtr4tDLinacHeoNNoO9xWcYYHSxZKz9mzXY2M4Ws2dc4Bs7Oznn++edZLlZcefhhMkKZ29qak7JmcAXGykiGZtZldBhkZF6miL1yfMVUIqZM0CzZqtxygXhWyyXGVkp9lYdiGAdtnqHyD5G+G6bNpWlE90T47zCbtdP9NQ79BFUVzDOEoG5ELTGOxGhU1kI2tcJwWgu/ybRzwWUhT8dXGsClJgpBDNqreo3VGwuNrzB2Tl87Vl3P8fEZzlq2tufYJDr7e3t71HXN+fmC5XLBycnJFLC25oEYRna2trly5Qree46Pj2nbRm0f1/dkya4FzhDJjoQOyTGwvb2F95a6cbznve/kbe94G1/68vP87u98iC9+8ct89qnP8NCDV0RCIkWpjqfqbr2MLQN/ZoLQyRrg5cZb38dTxiRfGH3uYg5T01H2hjVVdhhE216M2HUC2XrqxuFrof9ub21zfr6cnunNezkj1X0ZYmzqRiamh04auEHMQ3IyVC7Tbs/Y390hhMRi1bHqViyXwiAKIRJizziKjEaZD6m8wzg2IFCnhBEmYoA15doETWKEoomJmumPkAxVJbIRr7TuieA+n8+4cuVBCgNFHH28ggKqusi6IZiSaoynQMzCWy2XyurF1zBL7SvBQFOaeK455ykbjXnNyMg5T/6jhXtbmDTl+yX4TRNvBnG2yaWLLn/ZTOJlkrFbxQ7LhgPrJqfIDuimgjZ381q3ZsLOtQQtgWyiY5q1NPGm8FhAGUVJrE/E8k/LXrMW9spZg7yRATHhd7CmlpFJRqQTFA0lZ8v5+TnHxyc8++yzXLlyhTe96U2kDKvVUlxm+h6jVmchihUeiPgbGOlfxEhQY25jDcMgmVCMAt10XQ9GPDHbyhKRLD/oBqERA+stKWjDWvXIQxhZLjqWyxVhDLRNIywk57BAH0a8kcx5GEbGUSYdrc5WxBgUhjNT6Vwqw6RqoFEZUVEfTmNkiCmjJiFebA+LIYpcm6RaNQm8p+972rbR2YIaYxJV5bC2JYyBfhg4Pj6h73u2t7fZ2qowJrO1tYVzjrr2nJ6ecHJySs7Q7/bs7+2RY2R7Z4sHLl9ib3dXrtfJCfN5qxWvwLZy+2ewakifLDYbmroR31nrsLZiGDp8lXnL9z7Oo69/hM9//kt8+MP/D1965mnOz48JjCTcBHdtVkAl4Sl495rlsobA9IUJh6ccFxOp5SVfT44j5X4PUdy39Ro4hSxjEgjqzp07wqwK+vfKRmGMFglm+rOXLl0WbfZhUBaeEY0it2bXeScUxrpxNO0OuzvbxBhYLZckDKdnZ6RUKMqoVaXw+aXx7zHG4UaBHLO03BSmyqQkz4VTejJasVdtRYyBYSgWgS+/7ongboxksoV6Z5GGVEjSIItlwgyjGby8Kdkm8ij4oVdefMzqrETJ0CNkM40yZ3RqMjMxZ1Cj6SnjVfZK1GZrmPBDCb4FVolZmDVFBKsMNMiEZcHd01TSW82gQ4jEHKjKBqY3o1Fc2hU8tPx+5dAasw63a5qgVioTJ1uWc04hRa1CJiimsF8gx0SaMsaXDiRNKNd0wxtM9my1W1R1jbVw4/pNbt+6zfd+71vY29sRSl/K1Co+Vja78uyIOueaNWQU5nHeE4ZehkVSYj6bc3JyzrPPfoXr18UD5tFH38Ajj1zRslaublVVxJBVH94pRKTHnESvvO97vbbSdK2rahoPt8qwCUG8VGMY5QHPUd8H1cbBqBSEsLGi2h762UySkDKEY5g2lZIZm1johiIAhW7KMRXoaKSuPTEK5VLOYd3Mns0aYgycn59zcnLK9taSvf2e3d1tmqZma2tOVcn/WSxWnJ6eMfQjQzdwdHQgUOAYODo84qEHrmCS5fT8lN6NzOczKu8hK+8/Q1bZ69L/wsp9WSuzpWTKtXW8+11v4cUXvsrv/s4zdN05MWZ1HwPZBQtMIvIg63u1QHsFXimzvRvF4VRRlgAMTHd/icvTDsGkO6DVYQzi8WBAhOys2mRqhZA3/uf0iSY6MSfe+KY3MwyB09RTWYu34hKVrFARqzLcpM+eK5602TBv98jGcHRpn5Sk0d91HWdnZywWS8I4yHVOCgNWcs+lFKdJcOeMCOE5K0NnmsAZZ8nDK2PtZd0TwR1TRo11SjOvFQCn0XlrCTGBEdbEhOUlaQhFLX1iVhpSzqr3vZYFGMdRs9esQYC13nVcm3BEUNxMGnr9MCi+7yZ2TYxRSy6RG57wZA0uJasuxhRFbwPAKmdcZvIleNq8DqqpWAYqnUBck+TnnJWgXRpMAhcBygISTDdN2Dpo00pBOmOEwijyv3k6Xu8VftFBMXlzsjYoLU0142D/iHk75/jkmA9/8APsHR7wxBufoGnqNWyFzCXEGEV5UrOyMEacNoBziAx9z6BCZn0IGJIMBqUMKTJrG97ylrfwpje9SQKxk2ZoDqLLbTCsVt3ENAJhTMRQRt3lvaqrmmUWidqc5ftDYeNMVNGCqZfKx6ged6JI+hrWHHFnLDFFum5F9JVO8nrdzMMUwKHQd4WvPI4jTJS20nMIxCjXcQxhGoyptJfkVJ8npMTpyTk3b92h6wa6bsXOzg4HB3t4X7O/fyDBNSZOTk85X5yzXK44ONjn0tERXdfT1C2PP/YE/dBx4/YNbt+5zWgHtrZa9UcQI3VrMsZtGMGwHhbzKnfhbaRKiZ/52T/L29/+Vj7xR5/kC1/4IsfHpwx94Pr1m6y6DvLayCSlKLDMJApdqkzW/74ER07TC9IS0srnJaFZYFCZSFXo0CBQjiYuWWWic1RNKamt179DN4pSbVhbc+v2OZ966gu84fUPsr01w5lINQqUV3lPtAK9iWBcFslouzZMN84RERpu03hmsz0OD/YYxygN/uWSs9MFfYqkMJAU4pQ+kwokkvHOKgeeKUmrXKX3xiuD7vdEcE8psTg9U30Qq7t/0kGGjcxUu+OjBgWnU3djiBNsM4ZBFBlVryFNzTvROHH68IQYCWOYRt6tdVROSuRyI4/jgFzsUjrPtKwLQo1UGKfvtXzSgFrG/cvDUIJPwXDbdk6fe6kSvJ+4vHVVTUqMxli5cbCMWUr/ylnqCg3giuFNYhVmClTGmImFYmULkoaVKYM2WaiU6iQlm5FQ5aS5lCZ9doNjZ2uPg/0jrHV8+ctf5A8/8XGOLh1ydPlIM1Sh1gm2jNjYIYqOqOxrjpmEwDJj31OYJiGIuUOOeao2YhgL+IN1MMTE0A9Yb0GlAOSyyhRr4QMrHwrxskx0avQ9jqOYQVSeYeip1bavUk33tThZcZySTDKqDow8U0Yz/kwWbiq+9pOfAKAcfDfdxzIYLfdb09QEg0xUK887FEgnRqqqFQlm5UvHKNAMQDubceTEnHq5WAGG5WKlgQB2d3ex1nF0dERdN8xmM87Ozjg+PWUMgRAjlw6PiDGy6lYc7h7y8EMPM2/nXL91na4Pk+KnRTRV8gYxoJAESjPceacS3KId85a3PcmTb3qMYRjESWoIXL16ja9+5Wt86UvPcvXFG1y7fpPFYkHfj4QA6GYi4Un54VOzXr6TtbrORjatyWlKQdcptJki9cbXbQ6CO5UKFwPF+N7q5gp5PTykyEDTzPmjT3yaT3/2cxwd7PPmJx/j+7//HVy6tItByBfeWYKNyliTLaPMYOQExsl9kohYHFmHkZw1zGc1W7OGS/sHLFcrjk9POD9fEa0gDeXDGkOM4iM9RpkP8NYSbdHSeuUM/p4I7mgpmzKkMBKRYFNYnCIY5sAy0RCnzFgbcpsZcym2bLGlM2stkm7oGMZhGknPObMaA1vzOf2qm35HGUoQR5xKDROsinmdicQBeQrOxhhSCMQgin1h6AUPdY6+7zAK8xSGiClynVk43DKoJEYb1toJ+yeXycwkDB3Vfin9gTK1WpqvwlNPOtik5+GK0bOKXIWIrcz0eyBPGb/QHQVTb5sZ+3sHtHXD0K/4zNOf5YWrz/E9j72edjabaKHF31R+nygnloxP6GwBjMVmHULLmTEG6TMYw2opJsaVc2y1EuSIIghVaKq+cnR9L0Mf3rFadVRVM72fMZWsx2pDVfjiq1U3aQ3FGJm1CkUYqBuZN6jqSn1JLSGkiUbX+IpszZSxm6wyyCnjKqWwWoezjqrypCQNv2nkPCXIIo+bSmJhJXiJrs+m524WnnOSZ6GqKsIYVPrBUteew4N96qpiteyELtz1NE3D2dmCViey9/f3iHGb7e0tFosl4yjDQbePDYk9QhrpuhW7OyLDcenwEmfnZyyWC33/zMaks+gPFaE0a4UVJYOFa3lsSXIMdSOUXmPh0ccf4bEn3sAP/fC/Qt8NLBYdZ2cLTo6POT1dcP3aLW7dus1quWK5WnJ6ekrf9xt6/RBCIkdDzA7vVGUzS1PW5gLLZ3IKGvBLn2gts11w+kKdNIrjZ6PaQzh9fksCr/dzShAMN26dcOfOH/L5LzzNn/xT/ypvfONjhBTwSuBILEUQTpOzrL/TNzWQMMEgEtECBa5nTCQ+zec1860HyVmQieVyyXK5FOrlYjn1L6zJ5BhFYsV7nRL/l8zcjTFvBn5j46XHgf8C+Dv6+qPAl4G/kHO+YyQl++uI1d4S+IWc88df6W+knFn2nQ4ZOcncc6G9yTBT3y8l01KOeun0D92KuqoZ+mE9hKDQwxikAujGAe8to9IQS0O1/I0Yw5ThlQZoztCPg1rmNYQQNesYJfN10nTydUXMibadYXKm70aw0Db1lFFLKWtoVQExqUxraf5KU6zeyADLII3BGlGAs8pzNoZpyEdogyrtC1OFI1mPyBhkrYTQoD/0A01d6URenrINa+ShySmzWvXUvsU2DTdu3OCFF7/Cl559hkde/wYef+IJ6qqeykYRxoqyOWtF5J0X2mkS3LpqGjEliWJIoHf2VIndOT7hS1/8MpePLvHEY28gxTAdW1IOedJqCGMEznEi5eArTwyy0QnjQPDr5Wo1DUfJfWypfI1scPL+lKZsinF6H6tK7x1Qz4BNOM1t3B9ZqwY1KE9rfwEKxFZV03sgujhW+xjyFqxpn5mcB1IO1L4WtcMYqXy10dfJVN6yt7OFBRYL4d3fvnWbre0tlktRmtzd2aGpKqE9Yqbq5fjkhDEMHOzvszWbcevOQNu2XD56gMO9A45PT7h56yarbgWtmWC28iG3ctZNrJAN1raOJRnyXhKzxWIhVGLrmc8dbdtweLhLesNDkweqfGRtDkpAL9PJwzDQ9yNjPxKSUk1HMS7pusDY93T9QNf3DP0oz3AIjMNAUgnfqPMRZNGjSRkVkQsS7LMhaT8ORMAvGRkiqipphFdVze72FjvbYta97FZiz+idyFcb8QiQXpvB5Ew2gTFrII+GYGSaXBKgtY5T8a7I2WCsXLO9nS12duZC8x3Hie11vjij63pSgJD1ucv/ksE9iyn2u+UBMQ54HvhHwC8CH8g5/7Ix5hf16/8c+EngSf34AeBv6L/fcKWUGNT2yjmPzUIZCykQk8fkjMkQx0Aki7mxdYRRR/JDx3K1pAhgjcNIDAGjnFEM9FHeqFEhlNmsFYw0ifNS1/WaMdVaBkq533WdUPTUYKJqaqFDVTVV1YiLesmgU2Y2a7HWUDc13TBgraeaVRjl3VtjcbXcaNKYcVTWqAyv1wxDIQO7lgEoUEtVVVMvoXCmSzXjnCVpCUfOtE0jPqIpqfKcSpOmSE6qphllwwsp0NQ121vbXHrkMnXV8PwLz/N3f/1/4YErl3nyySc5OLq80YDKwoShqD4KBhi1eZnzWmsljOO0qSUjf5eUdMIQDvb3edc73wE5YbwhjQrtJK2+TKZbrYT6pcG6ZLxlU8G4CU4LMXC+OCdnM3nBFqhD5IjlmIVLvMFS0ubnxEFGm+tGKIIuizMXBhJy/MaKSukYRgmIaa3zngvxIydSMvp+ySoTt4WaOlWjMdNUlco0yGbtlfmRtGLY2pmRySwWK0IInJ6esTWfMww9Btjb2cV5y6xtVV4gMQyd4OHDyN7ODtvb2+Ir2r/ApcNLHB0csLu9w/VbN7l95xYZGaoq0HVpkFfqlDX0PSmu2Wal4nXOMWvbaQo7JyExTEyhBH3s8ZX0tCRJszrsljFmi5T3NSBnQgwqP5Fls4sRVIu9BFVpWpnJJKY8E8MocSCMYXo+Ns2/M0yN8KITVdCBUoE6I0Y0zomL1xiDNlIBIs4UlVrD0I+T4B6jaFFZt3aZkphiqesiF12YVYac5fo3TSNNfO/xdU3TGLbnM44O94RyPQycdStu37mjMyffeH27sMyPAl/MOX/FGPMzwJ/Q1/828CEkuP8M8HeypEy/b4zZN8ZcyTm/+I1+6eboe9bmocdiog7haIZdjCXKE5JS1hFwgQT6riOM4zQYNFnNGRmJ99bj2pm+0aNkTTljvU6oGT9lclVV0XUdzspouJTaVm/wmqR/t65rsII3V84T8khVtYSgRhg4+n6JyYnt7W0KDmgQGAfnGMNai4YsfqO4RBwlexU2hGSfIUahwGkAmSRxVWaYlKidl+pGn0xnBesr1EprNkXGPAZD41sO9g7Y293FGsNzzz3LBz/0Ad72trdx+MCDbG1tEcZEXSP9sARZfzdIb6PvenFNioXJo7KsiFZ7H0bFWo2U0pq9QmnYxUkwrKpquq6XHopuZCV4VFWtWfd64zMq72rQJmBGs7xejw8ddpFZCcjaVxmnqsk56QGAzgtMCJ9RuEZwT+dElTSEOAVzaytlN6zF50o2K/tHwqlyaN7YoIAJhvDey9xGiMzmrdjzaVU2Rh2z1xbLbN4QYmS1Ash0/cjWVsvZ+QLrHE1dU9U1s5n8nhjl/Ts7PWdY9SzOl2ztbLO/t8+1m9fph46j/SOuPPQ6dnZ2ePHqiywW58xmDdNQoFlTbpumkXMfHWMSs3JJOgLO1YSQtW/gpyYy2RAR2HJ6iE1eB/mSAOl7RpaRe2FFyfSxMZFsLZW3VFoRWYMaWmTATptN3QjdNKe1bHTRfWrbWvOENX1Z5DQEbgoxUYzcTVaihjEqzCZTojIfs2athSj3sy+CaGnEUYG6sqWc6LsgeY0ViWaC+BB4X0siEaOY92ShT1udTzHIBHXVzKjnLXsHuxtUn5df325w/zng1/XzBzcC9lXgQf38YeBrG//nOX3tGwb3nDNxiFpKJYIRDDrEKNxP3cWHYZBpxiEQjGDuQ99jrNAVu04wWYuU7jlnKu+lnEmJqq2nCz+brZujKYuvobFRjG5rUe2bz+aSIRvJ8uqmnaYja41y2pJh1s4hSxNsteroRhGl2tnew3nHrJ3rxpFYLjo1Oyi8fLlKMQU9R2lExhDY3t6a6FvWV5MGdt+JWUNphIGfGsZFD75papEHzmlqkHnvxatWWRjOeObtFgd7h8yalnHs+MRTf8hHP/57PPS6R3jdI4/TjYGqanSj8/Ig5KzBzCilS4KqGFQkvJPm5dCLr2Tla7rVCqOYozeGoR80k5fmqzWOlMpU6CbdszSR9SGJkLPRmx/GYZyyrRLoq6pm6EechaaudXbCMGuF2bNarRRnryiOVBIA1nrx0kuwuEorBoXRJgNtitqfbqBOuP/z+Xw6du9qUo6aOWZh/OS8NhS3Ml1dNsNiE1kGn4RhYyYZau8k2bDOsa3Y8jAITCUBfk6IERcjjAIRbu9uY87kbw3DQNcNjGNkiGKqffnSJU7Pz+j6jqPDS+xs79B+T8uNm1e5c3xbnI6QKmoyaXEy2e1r0UYJIRCKjk1Wjf5+FCNypQCTpQHLuFYULTIrRpkfBSq1xpLyGkKVSdSMdbVMHMdIDmEaFitcclFkNXq9HV6rqcoLFTqEkVRM4ceoAmpeqjBvpil2Q1bTFZmZ8QjrJinrLaesstdSEUetppPNhJgncTMbZLMoQ5jeCn0Xt44dKQ80WQffYpT3WyHZpBIpNgtDK1sm6rV9tdgyxpga+Gng/S8TnLP5Zq3bf/H3/VXgrwJcunxEjCPjOGCMk3IZGJM4v4/qnLM4P5/46GJaIcMi/TCQowTyrNSzOI4iEmUyW/MtfZCcyPCWhwiHdZVm+5btVrD1nPNkxLG9vY1zjuVyqYYMgtXKDeCIGdp5K3aAUYJqVVe42ouMQTJTE7TyMjAzpkRMMlRTHmbnPKulaMg456m9x7QI/KOUx5gS2TmpEqpq6hHIkJUGwVocloiaVVspGStfiZKd3lQxRmpbc7C7z97OAcYabt2+xoc+/H9yfHbMW9/1bnb3jsA4qrYV5ToycZCAkTKKaZbqITKOAmsY1hKuvY74V7s1s1b0x613YkZgHX1M9P0gmUlVCe9XWRMFZqm0UVUaj2MIeOck4w1Jf5fMD2Ak6IdRYKa0NccgRtLWGlIeMDgNvsU4RTZr770qRWoVlJEMTSsrOSYzBeecJNPESpnvfcvWfHtiIEGh/8kgUJl2Tbo5ujXRCVgP6Y2jZJlNI7aH/SD2dTlFrBfV0JAzde3Z3dui63piTDRVS1EMXSxWtLOGpq2pq4pqf0+v0cjZyRmFRjyOgbPFGW5nl5QDV6+/wGw2o/IO66BpasXERaeoMIlEPsAow8Sp4J6HbBGRLDcN1aWUhC9vZbahGH2nmMhqJJ4VliyONuLGZij2mdMAIZa6qokmEK3Mv8TCD8dOonny+/NUpYYYlVIr1EyvPZysLByvypC+1fcwRIq8r1cIMNtMNGEy1rHSlZ2ybOM2mrxZ+nYpRE0CpEczKPPNe4fxReRPqreoU9MZqUQq56mVGZeSGLsb57GV+kqnV48K+ZPAx3PO1/TrawVuMcZcAa7r688Dr9/4f4/oay9ZOedfBX4V4PEnHs3Hx8cTLued2G4Za+m7jsW56H6cn50za1tOT085PDxkuRzFyKKtqZp66uQfn51hvWd3d5eq9jjrNVMbaZqGumk4PTsTGQAvgly1qUlR5VsNWFvrRgIpR7Z3dpXLPtK2DTGIKXEyYE0iDAMpRrqhZzafi/O5qrjlLBvQsusnDXDvHG3TcHZ+LpmYMdStYKlN2zB0KyYP0VkLoeCIA10/TJROgSokW3XesdKMPiTNFq0XrYwo5WyKmdViyfVr13n44Ud48PIVTs+P+YOPfYQ/+OhHeMc73so7Hn837da+ZiUCHMcxELNq0CSFlXKeYLMwCqYZo/QxiolIyol23pJyxHvHGBKrvqfrBgyWQMY7kXwN46h9BscwSlYZY8RZj/NCOfXeUNcqq6yUiaquJleacQwbA0ISzMTfVDbbcRihtmCkCinS0c45zs8X6w0zFTprsXOLQEWRyzXG4KuK5XIp13w2I0SZPC1QWoiD4r9qT2hECtmpMTdIJrm5UhIT8Lat6ftBtHK0mSi47yia6FkVO6tqonc7KwyeYeixzrJanEOaYdoWp3LYYvzS0A+9nhN0q45z75nPW8iZ5eoMYLr/Ku+Zz+esuo6x63WKVjY7CaqaiZtMNiLB27ZeelIqwxxVnx03jcROuvghhek5yVkopMYY8qjN58J5mWApaVZ7qsnxq1jwkddCd4WYEIZeJ7sNWae0fZnmrmU/GcdBNpsoEtJOB4mMFbOXSe/IOUyS62w02ZAhLRGf2/RJsEr3NehUe1rP7Axjh/VCdS6JxWSso2hFSCNxGKQiiEZ7ApHW1mDcq2qQ/RdZQzIAvwn8PPDL+u8/2Xj9PzTG/D2kkXrySng7SBbZLVfUrWioZGB5fs44jsyaGa1qKKysIcbA7vY2TV0jFD7J2IZxibeSzdVNw2w+p2kaur7DKoQzn8/lDddm43x7m74bEPlYycbbtiWGKE4sleDRrvKsuhWnZ2fMZ1u0dU09E6hmGAahoTUV89k+XS92fMY5hjBSNxXOSLYdw0gzq8WBxRmWqyXzRjS8bV3RzhrCKBfUGFTTWy3vfEXdNFRtS6PQR+W9ZMNZcLsQAmHoSIgejXFe6GPG4K3HO0dTNbz+yhv4vne8F2Pg1skN/u9//iFu37rN+37oR9jd3aFqGshiXjCMoyhnRimBsUxwWEIkBsrkaVZe8tAP9GPPcrkSqQGTVRNd4IzaGhan59SVZPKVd8y2d1ien3F2vmC+tS0PwDBQVzUhjoyhuDBFzdLVE9Z5utWgG5803sIoswvnq5VQTENkuezxXnDWoi9SDL9jCNw+Xyn8pf0T3zAmydK8Vg7SgI20bcs4yrUHcJXQYVOG+dZMmB7aEwCVrY3CjRbf0jTpljsr5bYpODOSpcl91U79phQDVB7vICFY/zj0VE0jTVkscQwMG57BzooMtoijzTFOoBnnHXM/E5njGBnGjtVqiTHiwFVpH8UqBFSgkrquiSHS9x2NQpQSNFW8LkcqV+YNpIeR1QwnJ6ZeTEnirAmMMeCMwh8RgWBT4byvh6dKA33iuhudo7BGoJ+ShY/iW5uV0+6cw9mK4nWMHq/TWJJiJtqMr8SPNmaBL8XPt2DjQoMtk622qHpiyWqwE/MaagKmStMoI8wgsJ0APvK60f6A9IY6MpLYWmupm1qtQWXzCjqJb52jjh5X1+JM9wrrWwruxpgt4E8D/+7Gy78M/H1jzF8BvgL8BX39nyI0yGcQKuRf/ma/Xx40T9dJoOy6Tkr+MbCMC3Z3dwHY39/TGz0SouDys1nLoJrgIQSatsVrA1QCR7XmKRs1O86ZZtayOD/HWMdiscA5J2YJ3QrnHWM/UlcV89l8urmOLh3RNjNWq16hBOFiz2YzGRFfLvBVxWqxkA68McIUUVpbU4vu96yp6Ucx4WjbBuckSAmMYkV7G/l6NmsIwTOOga7raduWtmkYBmk09sMgD76xOKVtpiCDJFUDTTsTGmY1E976zp76X2Y+9dQn+Wcf+KccPXjEu971Hvb2dsv1luDRj/RjL9zlnMlG3nuhoA5gUGaHwBbjGFgul0o/g/nWnLoSxpHBMGRpsvWj9E4qfZ8Xiw4QCMrtONkYh5GDgwMVhRqo64bF+UqyxiLu1DQsFyvOzpbMZnPVTZmDUjRTKnQ3BJZSGYvSNLVWFBj7fuB80eGqGmudVgZabrtiaJInCQKRMjATzdFiMCmTTaTvVjIsk/OEoRbz8FXXE+OIT+KKpG82aLZXec8YInXtMFi6rmMcR9q2lb7GGCXIqPhUVdVSymMYx356Noyxk69qYQOdn51RNzJNmzWAVGr5l4LFJMngY6igliTLxqgzCwU3FopgVXlWy45+1bG1taViXXajmVwG8QwpFdxc9H9yVqpykknmhBAejBGJrDAGUXjMhqiVT6l+sorQCbkBjLqqGVEZnLJ65ywREeMaUzGftxMkkzXbTkmSIgMqVWCm4/N1re/rIBuQlefLafUT1MDaJ2F2eSsVScppgtfW088QUsTEMmhodPaGiSSQsmxUYwyYUcgAViehJR81VE1Fo1PUq1WH6V45rn5LwT3nvACOvu61Wwh75ut/NgP/wbfyezf+D+fnS7Z3twWTtWvpUylTB50cLaVswNee+WzOOErmXcrcfhio6pqguLSvqgmLL1IBt+/c5ujoErPZjGXfc3jpSIZi2kaaRN5pqT8KxU1LLJsyjsys9cTRUNVO4JblUvF1zVCdxWOI2gRu6prZbCZZvBVtlUaZP0LVGrFAjkLxdN4REdx/tVyyWApE07Qtfd/T1A3bO9vSawDQTaT4enoHTVULLTEE2tmcw71DdrZ38daxWq34P37zH/PUZz/D+/7193H0wBGztpHyMkmzKPQDY3Gbx4JOJxqD0EODaKEU6WJrLKtVLxREMns7exM7QwbAirmy8PfrtuX8/BScVTZQJGWrjVoJwrWTBvju7i7Hx8c0Gpz6oZ+odk1b085mJH3IjIHlYjEFhBQ12zMZ5xuIyl9IWVUSvbCAKq/MGZk43N3dZhjlvhOM1E/j3sVztzhkOd9I9p4lw44KMxiFETLiDVvVntQNYsJu3cQPT0n+PoBJiRzFBWzWNPTjQAgDbdUIXS+ITLCYTgh+fXpyRjMTh6gwimfrqh+YK1MmKU98uRhpWplgLc3Hvu8pBs05ZkIaWKi5zNbWnJQizohMbQxJFBYNaj0YOD07pZ3NaGbt1McQ/fqs8xiyCWbN2lNayx5PZjQpkZNnzL3QiieJhrVbmGT79iXvfwg6U1I1ZIpzllYKyDBRGULLORFHOT7vPINOJVtjiTnRdb1Y/xmpMkIWbSJbSZIYgsiQDEGes2JcXXlPivJMGCM9itJryDmrAFhi6AR+q7w890YbvtIHEqbQYrFiezbXuJAYFd4UJydPUNtIWyTxN2YwXm6ZUkbczWWMOQOevtvH8SqvS8DNu30Qr+K6OJ97e73Wzgdee+f0nTif78k5X365b9wb8gPwdM75vXf7IF7NZYz5g9fSOV2cz729XmvnA6+9c/pun88rt1sv1sW6WBfrYt2X6yK4X6yLdbEu1mtw3SvB/Vfv9gF8B9Zr7ZwuzufeXq+184HX3jl9V8/nnmioXqyLdbEu1sV6dde9krlfrIt1sS7WxXoV110P7saYnzDGPG2MeUalg+/5ZYx5vTHmg8aYzxhjPm2M+Y/09UNjzO8YY76g/x7o68YY89/rOX7SGPOeu3sGL7+MMc4Y84fGmN/Srx8zxnxEj/s3VF8IY0yjXz+j33/0rh74yyxVI/0HxpjPGWM+a4x532vg+vwner89ZYz5dWNMez9dI2PM/2yMuW6MeWrjtW/7mhhjfl5//gvGmJ+/G+eycSwvd07/td53nzTG/CNjzP7G996v5/S0MebPbLz+6sfBTUH+7/YH4vX9RcQApAY+Abz1bh7Tt3jcV4D36Oc7wOeBtwL/FfCL+vovAn9NP/8p4J8hqhE/CHzkbp/DNziv/xT4u8Bv6dd/H/g5/fxXgH9PP//3gV/Rz38O+I27fewvcy5/G/h39PMa2L+frw+irPosMNu4Nr9wP10j4IeB9wBPbbz2bV0T4BD4kv57oJ8f3GPn9OOA18//2sY5vVVjXAM8prHPfafi4N2+2O8Dfnvj6/cD77/bN+Ef4zz+CSLP8DRwRV+7gvD3Af4m8Bc3fn76uXvlAxF4+wDwp4Df0ofq5sZNOl0r4LeB9+nnXn/O3O1z2DiXPQ2E5utev5+vT5HSPtT3/LeAP3O/XSPEuW0zEH5b1wTRuPqbG6+/5OfuhXP6uu/9G8Cv6ecviW/lGn2n4uDdhmW+kfb7fbO03P0+4CN8+xr399L674D/jGJJL3ITxznnoF9vHvN0Pvr9E75OnuIur8eAG8DfUpjpfzSij3TfXp+c8/PAfwN8FfFGOAE+xv17jcr6dq/JPX+tvm7920gFAt/lc7rbwf2+XsaYbeB/B/7jnPPp5veybMH3BRXJGPPngOs554/d7WN5lZZHSuW/kXP+PmCBlPzTup+uD4Bi0T+DbFyvA7aAn7irB/Uqr/vtmnyzZYz5JSAAv3Y3/v7dDu7fkvb7vbiMMRUS2H8t5/wP9eVrRrTtMX8Mjfu7uH4I+GljzJeBv4dAM38d2DfGFImKzWOezke/vwfc+m4e8DdZzwHP5Zw/ol//AyTY36/XB+DHgGdzzjdyziPwD5Hrdr9eo7K+3WtyP1wrjDG/APw54C/ppgXf5XO628H9o8CT2vGvkcbPb97lY/qmyxhjgP8J+GzO+b/d+FbRuId/UeP+31IGwA/yLWjcfzdXzvn9OedHcs6PItfg/8o5/yXgg8Cf1x/7+vMp5/nn9efvmYwr53wV+Jox5s360o8Cn+E+vT66vgr8oDFmrvdfOaf78hptrG/3mvw28OPGmAOtZn5cX7tnljHmJxCI86dzzsuNb/0m8HPKZHoMeBL4//hOxcG72YjQe+2nELbJF4FfutvH8y0e87+GlI+fBP5IP34KwTQ/AHwB+F3gUH/eAP+DnuOngPfe7XN4hXP7E6zZMo/rzfcM8L8Bjb7e6tfP6Pcfv9vH/TLn8W7gD/Qa/WOEWXFfXx/gvwQ+BzwF/K8I6+K+uUaI2c+LwIhUV3/lj3NNEBz7Gf34y/fgOT2DYOglNvzKxs//kp7T08BPbrz+qsfBiwnVi3WxLtbFeg2uuw3LXKyLdbEu1sX6DqyL4H6xLtbFulivwXUR3C/WxbpYF+s1uC6C+8W6WBfrYr0G10Vwv1gX62JdrNfgugjuF+tiXayL9RpcF8H9Yl2si3WxXoPrIrhfrIt1sS7Wa3D9/8B3vC7rLFLVAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "image = mpimg.imread('bbox-example-image.jpg')\n", + "draw_image = np.copy(image)\n", + "\n", + "windows = slide_window(image, x_start_stop=[None, None], y_start_stop=y_start_stop, \n", + " xy_window=(96, 96), xy_overlap=(0.5, 0.5))\n", + "\n", + "hot_windows = search_windows(image, windows, svc, X_scaler, color_space=color_space, \n", + " spatial_size=spatial_size, hist_bins=hist_bins, \n", + " orient=orient, pix_per_cell=pix_per_cell, \n", + " cell_per_block=cell_per_block, \n", + " hog_channel=hog_channel, spatial_feat=spatial_feat, \n", + " hist_feat=hist_feat, hog_feat=hog_feat) \n", + "\n", + "window_img = draw_boxes(draw_image, hot_windows, color=(0, 0, 255), thick=6) \n", + "\n", + "plt.imshow(window_img)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "amber-happening", + "metadata": {}, + "outputs": [], + "source": [ + "def add_heat(heatmap, bbox_list):\n", + " # Iterate through list of bboxes\n", + " for box in bbox_list:\n", + " # Add += 1 for all pixels inside each bbox\n", + " # Assuming each \"box\" takes the form ((x1, y1), (x2, y2))\n", + " heatmap[box[0][1]:box[1][1], box[0][0]:box[1][0]] += 1\n", + "\n", + " # Return updated heatmap\n", + " return heatmap# Iterate through list of bboxes\n", + " \n", + "def apply_threshold(heatmap, threshold):\n", + " # Zero out pixels below the threshold\n", + " heatmap[heatmap <= threshold] = 0\n", + " # Return thresholded map\n", + " return heatmap\n", + "\n", + "def draw_labeled_bboxes(img, labels):\n", + " # Iterate through all detected cars\n", + " for car_number in range(1, labels[1]+1):\n", + " # Find pixels with each car_number label value\n", + " nonzero = (labels[0] == car_number).nonzero()\n", + " # Identify x and y values of those pixels\n", + " nonzeroy = np.array(nonzero[0])\n", + " nonzerox = np.array(nonzero[1])\n", + " # Define a bounding box based on min/max x and y\n", + " bbox = ((np.min(nonzerox), np.min(nonzeroy)), (np.max(nonzerox), np.max(nonzeroy)))\n", + " # Draw the box on the image\n", + " cv2.rectangle(img, bbox[0], bbox[1], (0,0,255), 6)\n", + " # Return the image\n", + " return img\n", + "\n", + "def process_image(img):\n", + " draw_image = np.copy(img)\n", + " windows = slide_window(img, xy_window=(84,84))\n", + " hot_windows = search_windows(img, windows, svc, X_scaler) \n", + " heat = np.zeros_like(img[:,:,0]).astype(np.float)\n", + " heat = add_heat(heat,hot_windows)\n", + " heat = apply_threshold(heat,1)\n", + " heatmap = np.clip(heat, 0, 255)\n", + " labels = label(heatmap)\n", + " draw_img = draw_labeled_bboxes(np.copy(img), labels)\n", + " return draw_img" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "single-element", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "img = mpimg.imread(\"bbox-example-image.jpg\")\n", + "draw_image = np.copy(img)\n", + "\n", + "windows = slide_window(img, xy_window=(84,84))\n", + "\n", + "hot_windows = search_windows(img, windows, svc, X_scaler) \n", + " \n", + "heat = np.zeros_like(img[:,:,0]).astype(np.float)\n", + "heat = add_heat(heat,hot_windows)\n", + "heat = apply_threshold(heat,1)\n", + "heatmap = np.clip(heat, 0, 255)\n", + "labels = label(heatmap)\n", + "draw_img = draw_labeled_bboxes(np.copy(img), labels)\n", + "\n", + "f, (ax1, ax2) = plt.subplots(1, 2, figsize=(24, 9))\n", + "ax1.imshow(draw_img)\n", + "ax2.imshow(heatmap, cmap='hot')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "educated-diana", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "t: 0%| | 0/1260 [00:00\n", + " \n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "HTML(\"\"\"\n", + "\n", + "\"\"\".format(output_vid))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "patent-checklist", + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/non-vehicles_smallset.zip b/non-vehicles_smallset.zip new file mode 100644 index 0000000..47bfb7a Binary files /dev/null and b/non-vehicles_smallset.zip differ diff --git a/project_video.mp4 b/project_video.mp4 new file mode 100644 index 0000000..57c0a00 Binary files /dev/null and b/project_video.mp4 differ diff --git a/test_image.jpg b/test_image.jpg new file mode 100644 index 0000000..8774255 Binary files /dev/null and b/test_image.jpg differ diff --git a/tracker.py b/tracker.py new file mode 100644 index 0000000..38c9699 --- /dev/null +++ b/tracker.py @@ -0,0 +1,46 @@ +import numpy as np +import cv2 +class tracker(): + + def __init__(self, Mywindow_width, Mywindow_height, Mymargin, My_ym = 1, My_xm = 1, Mysmooth_factor = 15): + self.recent_centers = [] + self.window_width = Mywindow_width + self.window_height = Mywindow_height + self.margin = Mymargin + self.ym_per_pix = My_ym + self.xm_per_pix = My_xm + self.smooth_factor = Mysmooth_factor + + def find_window_centroids(self, warped): + window_width = self.window_width + window_height = self.window_height + margin = self.margin + + window_centroids = [] + window = np.ones(window_width) + + l_sum = np.sum(warped[int(3*warped.shape[0]/4):,:int(warped.shape[1]/2)],axis=0) + l_center = np.argmax(np.convolve(window,l_sum))-window_width/2 + + r_sum = np.sum(warped[int(3*warped.shape[0]/4):,int(warped.shape[1]/2):],axis=0) + r_center = np.argmax(np.convolve(window,r_sum))-window_width/2+int(warped.shape[1]/2) + + window_centroids.append((l_center,r_center)) + + for level in range(1,(int)(warped.shape[0]/window_height)): + image_layer = np.sum(warped[int(warped.shape[0]-(level+1)*window_height):int(warped.shape[0]-level*window_height),:],axis=0) + conv_signal = np.convolve(window,image_layer) + + offset = window_width/2 + l_min_index = int(max(l_center+offset-margin,0)) + l_max_index = int(min(l_center+offset+margin,warped.shape[1])) + l_center = np.argmax(conv_signal[l_min_index:l_max_index])+l_min_index-offset + + r_min_index = int(max(r_center+offset-margin,0)) + r_max_index = int(min(r_center+offset+margin,warped.shape[1])) + r_center = np.argmax(conv_signal[r_min_index:r_max_index])+r_min_index-offset + + window_centroids.append((l_center,r_center)) + + self.recent_centers.append(window_centroids) + return np.average(self.recent_centers[-self.smooth_factor:],axis=0) \ No newline at end of file diff --git a/vehicles_smallset.zip b/vehicles_smallset.zip new file mode 100644 index 0000000..9ba19c2 Binary files /dev/null and b/vehicles_smallset.zip differ diff --git a/video_gen.py b/video_gen.py new file mode 100644 index 0000000..d99d70b --- /dev/null +++ b/video_gen.py @@ -0,0 +1,176 @@ +import numpy as np +import cv2 +import pickle +import glob +from tracker import tracker +from moviepy.editor import VideoFileClip +from IPython.display import HTML + +dist_pickle = pickle.load(open("calibration_pickle.p", "rb")) +mtx = dist_pickle["mtx"] +dist = dist_pickle["dist"] + +def abs_sobel_thresh(img, orient='x', sobel_kernel=3, thresh=(0,255)): + gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) + if orient == 'x': + abs_sobel = np.absolute(cv2.Sobel(gray, cv2.CV_64F, 1, 0)) + if orient == 'y': + abs_sobel = np.absolute(cv2.Sobel(gray, cv2.CV_64F, 0, 1)) + + scaled_sobel = np.uint8(255*abs_sobel/np.max(abs_sobel)) + binary_output = np.zeros_like(scaled_sobel) + + binary_output[(scaled_sobel >= thresh[0]) & (scaled_sobel <= thresh[1])] = 1 + return binary_output + +def mag_thresh(img, sobel_kernel=3, mag_thresh=(0,255)): + gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) + sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=sobel_kernel) + sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=sobel_kernel) + + gradmag = np.sqrt(sobelx**2+sobely**2) + scale_factor = np.max(gradmag)/255 + gradmag = (gradmag/scale_factor).astype(np.uint8) + + binary_output = np.zeros_like(gradmag) + binary_output[(gradmag >= mag_thresh[0]) & (gradmag <= mag_thresh[1])] = 1 + return binary_output + +def dir_threshold(image, sobel_kernel=3, thresh=(0, np.pi/2)): + gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY) + sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=sobel_kernel) + sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=sobel_kernel) + + with np.errstate(divide='ignore', invalid='ignore'): + absgraddir = np.absolute(np.arctan(sobely/sobelx)) + binary_output = np.zeros_like(absgraddir) + binary_output[(absgraddir >= thresh[0]) & (absgraddir <= thresh[1])] = 1 + return binary_output + +def color_threshold(image, sthresh=(0,255), vthresh=(0,255), lthresh=(0,255)): + hls = cv2.cvtColor(image, cv2.COLOR_RGB2HLS) + s_channel = hls[:,:,2] + s_binary = np.zeros_like(s_channel) + s_binary[(s_channel >= sthresh[0]) & (s_channel <= sthresh[1])] = 1 + + hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV) + v_channel = hsv[:,:,2] + v_binary = np.zeros_like(v_channel) + v_binary[(v_channel >= vthresh[0]) & (v_channel <= vthresh[1])] = 1 + + output = np.zeros_like(s_channel) + output[(s_binary == 1) & (v_binary == 1)] = 1 + return output + +def window_mask(width, height, img_ref, center, level): + output = np.zeros_like(img_ref) + output[int(img_ref.shape[0] - (level + 1) * height):int(img_ref.shape[0] - level * height), + max(0, int(center - width / 2)):min(int(center + width / 2), img_ref.shape[1])] = 1 + return output + +def process_image(image): + + img = cv2.undistort(image, mtx, dist, None, mtx) + + preprocessImage = np.zeros_like(img[:,:,0]) + gradx = abs_sobel_thresh(img, orient='x', thresh=(12,255)) + grady = abs_sobel_thresh(img, orient='x', thresh=(25,255)) + c_binary = color_threshold(img, sthresh=(100,255),vthresh=(50,255)) + preprocessImage[((gradx==1)&(grady==1)|(c_binary==1))] = 255 + + img_size = (img.shape[1], img.shape[0]) + bot_width = .75 #changed from .76 + mid_width = .1 #changed this value - seemed to work a lot better than 0.08 + height_pct = .62 + bottom_trim = .935 + src = np.float32([[img.shape[1]*(.5-mid_width/2),img.shape[0]*height_pct],[img.shape[1]*(.5+mid_width/2),img.shape[0]*height_pct], + [img.shape[1]*(.5+bot_width/2),img.shape[0]*bottom_trim],[img.shape[1]*(.5-bot_width/2),img.shape[0]*bottom_trim]]) + offset = img_size[0]*.25 + dst = np.float32([[offset, 0], [img_size[0]-offset, 0],[img_size[0]-offset, img_size[1]],[offset, img_size[1]]]) + + M = cv2.getPerspectiveTransform(src, dst) + Minv = cv2.getPerspectiveTransform(dst, src) + warped = cv2.warpPerspective(preprocessImage, M, img_size,flags=cv2.INTER_LINEAR) + + window_width = 25 + window_height = 80 + curve_centers = tracker(Mywindow_width=window_width,Mywindow_height=window_height,Mymargin=25,My_ym=10/720,My_xm=4/384,Mysmooth_factor=15) + window_centroids = curve_centers.find_window_centroids(warped) + + l_points = np.zeros_like(warped) + r_points = np.zeros_like(warped) + + rightx = [] + leftx = [] + + for level in range(0,len(window_centroids)): + l_mask = window_mask(window_width,window_height,warped,window_centroids[level][0],level) + r_mask = window_mask(window_width,window_height,warped,window_centroids[level][1],level) + + leftx.append(window_centroids[level][0]) + rightx.append(window_centroids[level][1]) + + l_points[(l_points==255)|((l_mask==1))] = 255 + r_points[(r_points==255)|((r_mask==1))] = 255 + + template = np.array(r_points+l_points,np.uint8) + zero_channel = np.zeros_like(template) + template = np.array(cv2.merge((zero_channel,template,zero_channel)),np.uint8) + warpage = np.array(cv2.merge((warped,warped,warped)),np.uint8) + result = cv2.addWeighted(warpage,1,template,0.5,0.0) + + yvals = range(0,warped.shape[0]) + res_yvals = np.arange(warped.shape[0]-(window_height/2),0,-window_height) + + left_fit = np.polyfit(res_yvals,leftx,2) + left_fitx = left_fit[0]*yvals*yvals + left_fit[1]*yvals + left_fit[2] + left_fitx = np.array(left_fitx,np.int32) + + right_fit = np.polyfit(res_yvals,rightx,2) + right_fitx = right_fit[0]*yvals*yvals + right_fit[1]*yvals + right_fit[2] + right_fitx = np.array(right_fitx,np.int32) + + left_lane = np.array(list(zip(np.concatenate((left_fitx-window_width/2,left_fitx[::-1]+window_width/2),axis=0),np.concatenate((yvals,yvals[::-1]),axis=0))),np.int32) + + right_lane = np.array(list(zip(np.concatenate((right_fitx-window_width/2,right_fitx[::-1]+window_width/2),axis=0),np.concatenate((yvals,yvals[::-1]),axis=0))),np.int32) + + inner_lane = np.array(list(zip(np.concatenate((left_fitx+window_width/2,right_fitx[::-1]+window_width/2),axis=0),np.concatenate((yvals,yvals[::-1]),axis=0))),np.int32) + + road = np.zeros_like(img) + road_bkg = np.zeros_like(img) + cv2.fillPoly(road,[left_lane],color=[255,0,0]) + cv2.fillPoly(road,[inner_lane],color=[0,255,0]) + cv2.fillPoly(road,[right_lane],color=[0,0,255]) + cv2.fillPoly(road_bkg,[left_lane],color=[255,255,255]) + cv2.fillPoly(road_bkg,[right_lane],color=[255,255,255]) + + road_warped = cv2.warpPerspective(road,Minv,img_size,flags=cv2.INTER_LINEAR) + road_warped_bkg = cv2.warpPerspective(road_bkg,Minv,img_size,flags=cv2.INTER_LINEAR) + + base = cv2.addWeighted(img, 1.0, road_warped_bkg, -1.0, 0.0) + result = cv2.addWeighted(base,1.0,road_warped,0.7,0.0) + + #measure pixels in y and x directions + ym_per_pix = curve_centers.ym_per_pix + xm_per_pix = curve_centers.xm_per_pix + + curve_fit_cr = np.polyfit(np.array(res_yvals,np.float32)*ym_per_pix,np.array(leftx,np.float32)*xm_per_pix,2) + curverad = ((1+(2*curve_fit_cr[0]*yvals[-1]*ym_per_pix+curve_fit_cr[1])**2)**1.5)/np.absolute(2*curve_fit_cr[0]) #remember that it's the equation from the lesson (derivatives) - radius of curvature + + camera_center = (left_fitx[-1] + right_fitx[-1])/2 + center_diff = (camera_center-warped.shape[1]/2)*xm_per_pix + side_pos = 'left' + if center_diff <= 0: + side_pos = 'right' + + cv2.putText(result,'Radius of curvature = '+str(round(curverad,3))+'(m)',(50,50),cv2.FONT_HERSHEY_SIMPLEX,1,(255,255,255),2) + cv2.putText(result,'Vehicle is '+str(abs(round(center_diff,3)))+'m '+side_pos+' of center',(50,100), cv2.FONT_HERSHEY_SIMPLEX,1,(255,255,255),2) + + return result + +output_vid = 'lane_tracker.mp4' +input_vid = 'project_video.mp4' + +clip1 = VideoFileClip(input_vid) +video_clip = clip1.fl_image(process_image) +video_clip.write_videofile(output_vid, audio=False) \ No newline at end of file