{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "4a6a2e38-7d25-4818-9d76-e6fe919df86f", "metadata": {}, "outputs": [], "source": [ "from IPython.display import clear_output, Image as IPImage\n", "from PIL import Image, ImageDraw, ImageMath, ImageChops\n", "from typing import List\n", "import numpy as np\n", "import math\n", "import random" ] }, { "cell_type": "code", "execution_count": 2, "id": "90085e18-30ec-441f-bf5c-0069db3eb99b", "metadata": { "tags": [] }, "outputs": [], "source": [ "def rotation_matrix(axis, theta):\n", " \"\"\"\n", " Return the rotation matrix associated with counterclockwise rotation about\n", " the given axis by theta radians.\n", " \"\"\"\n", " axis = np.asarray(axis)\n", " axis = axis / math.sqrt(np.dot(axis, axis))\n", " a = math.cos(theta / 2.0)\n", " b, c, d = -axis * math.sin(theta / 2.0)\n", " aa, bb, cc, dd = a * a, b * b, c * c, d * d\n", " bc, ad, ac, ab, bd, cd = b * c, a * d, a * c, a * b, b * d, c * d\n", " return np.array([[aa + bb - cc - dd, 2 * (bc + ad), 2 * (bd - ac)],\n", " [2 * (bc - ad), aa + cc - bb - dd, 2 * (cd + ab)],\n", " [2 * (bd + ac), 2 * (cd - ab), aa + dd - bb - cc]])" ] }, { "cell_type": "code", "execution_count": 3, "id": "f8069be0-c494-44e8-bc66-ba08051b83a5", "metadata": { "tags": [] }, "outputs": [], "source": [ "class Point2d:\n", " def __init__(self, x, y):\n", " self.x = x\n", " self.y = y" ] }, { "cell_type": "code", "execution_count": 4, "id": "27f4d619-14d7-4f00-95bb-a4f1a93f0aab", "metadata": { "tags": [] }, "outputs": [], "source": [ "class Point3d:\n", " def __init__(self, x, y, z):\n", " self.x = x\n", " self.y = y\n", " self.z = z" ] }, { "cell_type": "code", "execution_count": 5, "id": "4deac1bf-7c15-4530-acbc-b3a7256725c5", "metadata": { "tags": [] }, "outputs": [], "source": [ "class Face:\n", " def __init__(self, points: List[Point3d], color: str):\n", " self.points = points\n", " self.color = color" ] }, { "cell_type": "code", "execution_count": 6, "id": "41f45d62-074c-4be0-a817-001909cc73d2", "metadata": { "tags": [] }, "outputs": [], "source": [ "class Perspective:\n", " def __init__(self, center: Point2d, strength):\n", " self.center = center\n", " self.strength = strength\n", " \n", " def projectPoint(self, point: Point3d):\n", " return Point2d(\n", " #(point.x + (point.x-self.center.x) * (self.strength/10000) * math.log(point.z)),\n", " #(point.y + (point.y-self.center.y) * (self.strength/10000) * math.log(point.z)),\n", " #(point.x + (point.x-self.center.x) * (self.strength/10000) * point.z),\n", " #(point.y + (point.y-self.center.y) * (self.strength/10000) * point.z),\n", " #self.strength * (point.x + (point.x-self.center.x)) / point.z,\n", " #self.strength * (point.y + (point.y-self.center.y)) / point.z,\n", " \n", " (point.x + (point.x-self.center.x) * (self.strength/10000) * (point.z+1e2)/1e2),\n", " (point.y + (point.y-self.center.y) * (self.strength/10000) * (point.z+1e2)/1e2),\n", " )" ] }, { "cell_type": "code", "execution_count": 7, "id": "5e1d1210-a590-4eab-9c68-80f91d8a7445", "metadata": { "tags": [] }, "outputs": [], "source": [ "class Rotation:\n", " def __init__(self, axis, theta):\n", " self.axis = axis\n", " self.theta = theta\n", " \n", " def rotatePoint(self, point: Point3d):\n", " matrix = [point.x, point.y, point.z]\n", " matrix = np.dot(rotation_matrix(self.axis, self.theta), matrix)\n", " return Point3d(matrix[0], matrix[1], matrix[2])" ] }, { "cell_type": "code", "execution_count": 8, "id": "01659240-e447-46fb-a6d3-53aed9853e45", "metadata": { "tags": [] }, "outputs": [], "source": [ "square = (\n", " # back\n", " Face((\n", " Point3d( 50, 50, -50),\n", " Point3d( 50, 150, -50),\n", " Point3d(150, 150, -50),\n", " Point3d(150, 50, -50),\n", " ), (255, 127, 0, 170)),\n", " \n", " # left\n", " Face((\n", " Point3d( 50, 50, 50),\n", " Point3d( 50, 50, -50),\n", " Point3d( 50, 150, -50),\n", " Point3d( 50, 150, 50),\n", " ), (127, 255, 0, 170)),\n", " \n", " # bottom\n", " Face((\n", " Point3d( 50, 150, 50),\n", " Point3d(150, 150, 50),\n", " Point3d(150, 150, -50),\n", " Point3d( 50, 150, -50),\n", " ), (127, 0, 255, 170)),\n", " \n", " # front\n", " Face((\n", " Point3d( 50, 50, 50),\n", " Point3d( 50, 150, 50),\n", " Point3d(150, 150, 50),\n", " Point3d(150, 50, 50),\n", " ), (255, 127, 0, 170)),\n", " \n", " # right\n", " Face((\n", " Point3d(150, 50, 50),\n", " Point3d(150, 50, -50),\n", " Point3d(150, 150, -50),\n", " Point3d(150, 150, 50),\n", " ), (127, 255, 0, 170)),\n", " \n", " # top\n", " Face((\n", " Point3d( 50, 50, 50),\n", " Point3d(150, 50, 50),\n", " Point3d(150, 50, -50),\n", " Point3d( 50, 50, -50),\n", " ), (127, 0, 255, 170)),\n", ")" ] }, { "cell_type": "code", "execution_count": 9, "id": "fb166b8a-9e51-48e2-8695-a92b86b402e5", "metadata": { "tags": [] }, "outputs": [], "source": [ "letterL = (\n", " # back\n", " Face((\n", " Point3d( 50, 50, -50),\n", " Point3d( 50, 150, -50),\n", " Point3d(150, 150, -50),\n", " Point3d(150, 112, -50),\n", " Point3d(100, 112, -50),\n", " Point3d(100, 50, -50),\n", " ), (255, 127, 0, 170)),\n", " \n", " # left\n", " Face((\n", " Point3d( 50, 50, 50),\n", " Point3d( 50, 50, -50),\n", " Point3d( 50, 150, -50),\n", " Point3d( 50, 150, 50),\n", " ), (127, 255, 0, 170)),\n", " \n", " # bottom\n", " Face((\n", " Point3d( 50, 150, 50),\n", " Point3d(150, 150, 50),\n", " Point3d(150, 150, -50),\n", " Point3d( 50, 150, -50),\n", " ), (127, 0, 255, 170)),\n", " \n", " # front\n", " Face((\n", " Point3d( 50, 50, 50),\n", " Point3d( 50, 150, 50),\n", " Point3d(150, 150, 50),\n", " Point3d(150, 112, 50),\n", " Point3d(100, 112, 50),\n", " Point3d(100, 50, 50),\n", " ), (255, 127, 0, 170)),\n", " \n", " # right\n", " Face((\n", " Point3d(100, 50, 50),\n", " Point3d(100, 50, -50),\n", " Point3d(100, 112, -50),\n", " Point3d(100, 112, 50),\n", " ), (127, 255, 0, 170)),\n", " Face((\n", " Point3d(150, 112, 50),\n", " Point3d(150, 112, -50),\n", " Point3d(150, 150, -50),\n", " Point3d(150, 150, 50),\n", " ), (127, 255, 0, 170)),\n", " \n", " # top\n", " Face((\n", " Point3d( 50, 50, 50),\n", " Point3d(100, 50, 50),\n", " Point3d(100, 50, -50),\n", " Point3d( 50, 50, -50),\n", " ), (127, 0, 255, 170)),\n", " Face((\n", " Point3d(100, 112, 50),\n", " Point3d(150, 112, 50),\n", " Point3d(150, 112, -50),\n", " Point3d(100, 112, -50),\n", " ), (127, 0, 255, 170)),\n", ")" ] }, { "cell_type": "code", "execution_count": 10, "id": "48eb5e60-f650-4f60-a4de-6ae94f59c876", "metadata": { "tags": [] }, "outputs": [], "source": [ "square2 = (\n", " # back\n", " Face((\n", " Point3d(170, 50, -50),\n", " Point3d(170, 150, -50),\n", " Point3d(270, 150, -50),\n", " Point3d(270, 50, -50),\n", " ), (0, 255, 127, 170)),\n", " \n", " # left\n", " Face((\n", " Point3d(170, 50, 50),\n", " Point3d(170, 50, -50),\n", " Point3d(170, 150, -50),\n", " Point3d(170, 150, 50),\n", " ), (255, 0, 127, 170)),\n", " \n", " # bottom\n", " Face((\n", " Point3d(170, 150, 50),\n", " Point3d(270, 150, 50),\n", " Point3d(270, 150, -50),\n", " Point3d(170, 150, -50),\n", " ), (255, 127, 0, 170)),\n", " \n", " # front\n", " Face((\n", " Point3d(170, 50, 50),\n", " Point3d(170, 150, 50),\n", " Point3d(270, 150, 50),\n", " Point3d(270, 50, 50),\n", " ), (0, 255, 127, 170)),\n", " \n", " # right\n", " Face((\n", " Point3d(270, 50, 50),\n", " Point3d(270, 50, -50),\n", " Point3d(270, 150, -50),\n", " Point3d(270, 150, 50),\n", " ), (255, 0, 127, 170)),\n", " \n", " # top\n", " Face((\n", " Point3d(170, 50, 50),\n", " Point3d(270, 50, 50),\n", " Point3d(270, 50, -50),\n", " Point3d(170, 50, -50),\n", " ), (255, 127, 0, 170)),\n", ")" ] }, { "cell_type": "code", "execution_count": 11, "id": "5089b488-0c18-47ca-b9f0-24ff1fb62998", "metadata": { "tags": [] }, "outputs": [], "source": [ "letterF = (\n", " # back\n", " Face((\n", " Point3d(170, 50, -50),\n", " Point3d(170, 150, -50),\n", " Point3d(220, 150, -50),\n", " Point3d(220, 120, -50),\n", " Point3d(245, 120, -50),\n", " Point3d(245, 88, -50),\n", " Point3d(270, 88, -50),\n", " Point3d(270, 50, -50),\n", " ), (0, 255, 127, 170)),\n", " \n", " # left\n", " Face((\n", " Point3d(170, 50, 50),\n", " Point3d(170, 50, -50),\n", " Point3d(170, 150, -50),\n", " Point3d(170, 150, 50),\n", " ), (255, 0, 127, 170)),\n", " \n", " # bottom\n", " Face((\n", " Point3d(170, 150, 50),\n", " Point3d(220, 150, 50),\n", " Point3d(220, 150, -50),\n", " Point3d(170, 150, -50),\n", " ), (255, 127, 0, 170)),\n", " Face((\n", " Point3d(220, 120, 50),\n", " Point3d(245, 120, 50),\n", " Point3d(245, 120, -50),\n", " Point3d(220, 120, -50),\n", " ), (255, 127, 0, 170)),\n", " Face((\n", " Point3d(245, 88, 50),\n", " Point3d(270, 88, 50),\n", " Point3d(270, 88, -50),\n", " Point3d(245, 88, -50),\n", " ), (255, 127, 0, 170)),\n", " \n", " # front\n", " Face((\n", " Point3d(170, 50, 50),\n", " Point3d(170, 150, 50),\n", " Point3d(220, 150, 50),\n", " Point3d(220, 120, 50),\n", " Point3d(245, 120, 50),\n", " Point3d(245, 88, 50),\n", " Point3d(270, 88, 50),\n", " Point3d(270, 50, 50),\n", " ), (0, 255, 127, 170)),\n", " \n", " # right\n", " Face((\n", " Point3d(270, 50, 50),\n", " Point3d(270, 50, -50),\n", " Point3d(270, 88, -50),\n", " Point3d(270, 88, 50),\n", " ), (255, 0, 127, 170)),\n", " Face((\n", " Point3d(245, 88, 50),\n", " Point3d(245, 88, -50),\n", " Point3d(245, 120, -50),\n", " Point3d(245, 120, 50),\n", " ), (255, 0, 127, 170)),\n", " Face((\n", " Point3d(220, 120, 50),\n", " Point3d(220, 120, -50),\n", " Point3d(220, 150, -50),\n", " Point3d(220, 150, 50),\n", " ), (255, 0, 127, 170)),\n", " \n", " # top\n", " Face((\n", " Point3d(170, 50, 50),\n", " Point3d(270, 50, 50),\n", " Point3d(270, 50, -50),\n", " Point3d(170, 50, -50),\n", " ), (255, 127, 0, 170)),\n", ")" ] }, { "cell_type": "code", "execution_count": 12, "id": "cabbc0a8-51eb-43ed-9d63-545f4fdf846b", "metadata": { "tags": [] }, "outputs": [], "source": [ "def drawPoint2d(x, y):\n", " draw.ellipse((x-2, y-2, x+2, y+2), fill = None, outline = 'black')" ] }, { "cell_type": "code", "execution_count": 13, "id": "57cfe910-3417-4957-99bd-00d64cbd613c", "metadata": { "tags": [] }, "outputs": [], "source": [ "def drawPoint3d(x, y, z, perspective):\n", " x = perspective.transformPoint(x)\n", " y = perspective.transformPoint(y)\n", " drawPoint2d(x, y)" ] }, { "cell_type": "code", "execution_count": 14, "id": "8129122a-804c-45d2-b4f7-68264f9e98ce", "metadata": { "tags": [] }, "outputs": [], "source": [ "def drawLine(pointA: Point2d, pointB: Point2d):\n", " draw.line([(pointA.x, pointA.y), (pointB.x, pointB.y)], fill = 'red', width = 0)" ] }, { "cell_type": "code", "execution_count": 15, "id": "2e6a3406-4646-40f6-8092-885b4cb1a25a", "metadata": { "tags": [] }, "outputs": [], "source": [ "def drawFace(face: Face, perspective: Perspective, rotation: Rotation, pivot: Point3d, translation: Point3d, scale: Point3d):\n", " pairs = []\n", " for point in face.points:\n", " movedPoint = Point3d(\n", " (point.x - pivot.x) * scale.x,\n", " (point.y - pivot.y) * scale.y,\n", " (point.z - pivot.z) * scale.z,\n", " )\n", " tilt = Rotation([1, 0, 0], 0.3)\n", " movedPoint = tilt.rotatePoint(movedPoint)\n", " point3d = rotation.rotatePoint(movedPoint)\n", " movedPoint = Point3d(\n", " point3d.x + translation.x,\n", " point3d.y + translation.y,\n", " point3d.z + translation.z,\n", " )\n", " point2d = perspective.projectPoint(movedPoint)\n", " pairs = pairs + [point2d.x, point2d.y]\n", " drawPoint2d(point2d.x, point2d.y)\n", " draw.polygon(pairs, fill = face.color, outline = 'black', width = 2)" ] }, { "cell_type": "code", "execution_count": 16, "id": "8c525323-2ccf-4d52-89b8-3c6458de5532", "metadata": {}, "outputs": [], "source": [ "def drawObject(obj: List[Face], perspective: Perspective, rotation: Rotation, pivot: Point3d, translation: Point3d, scale: Point3d):\n", " zsorted = sorted(obj, key=lambda face: (rotation.rotatePoint(face.points[0]).z + rotation.rotatePoint(face.points[1]).z + rotation.rotatePoint(face.points[2]).z + rotation.rotatePoint(face.points[3]).z))\n", " for face in zsorted:\n", " drawFace(face, perspective, rotation, pivot, translation, scale)" ] }, { "cell_type": "code", "execution_count": 17, "id": "9cd4089c-0d5d-422e-802d-fc3cbeff6c59", "metadata": { "tags": [] }, "outputs": [], "source": [ "def ditherImage(sourceimage, ditherbands):\n", " imagesplit = Image.Image.split(sourceimage)\n", " imagebands = [None, None, None]\n", " for c in range(3):\n", " imagebands[c] = ImageMath.eval(\"convert((a>=b)*255, 'L')\", a = imagesplit[c], b = ditherbands[c])\n", " return Image.merge('RGB', imagebands)" ] }, { "cell_type": "code", "execution_count": 18, "id": "61c21592-61f4-4878-b8f4-e0688ed64169", "metadata": { "tags": [] }, "outputs": [], "source": [ "def shuffleLines(image):\n", " imagecopy = image.copy()\n", " start = int(fixedRandoms[0])\n", " maxend = int(start+fixedRandoms[1])\n", " end = random.randrange(\n", " int(maxend*0.75),\n", " maxend\n", " )\n", " reduction = fixedRandoms[2]/2\n", " for y in range(start, end):\n", " shift = int(\n", " fixedShift[(y*9)%hi]*reduction/5 +\n", " abs(math.sin(y/8)*math.sin(y/22))*1.5 *\n", " max(int(reduction), 0) +\n", " 2\n", " )\n", " reduction = reduction - (reduction * (1/fixedRandoms[2]))*0.75;\n", " for x in range(wi):\n", " pixel = image.getpixel(((x+shift)%wi,y%hi))\n", " imagecopy.putpixel((x,y%hi), pixel)\n", " return imagecopy" ] }, { "cell_type": "code", "execution_count": 19, "id": "707cbf12-e003-448e-bc5a-a87db5d9a0e0", "metadata": { "tags": [] }, "outputs": [], "source": [ "def fuzz(image, shifted, mask):\n", " return Image.composite(image, shifted, mask)" ] }, { "cell_type": "code", "execution_count": 20, "id": "2222a115-c0f9-415b-a3da-574112c73b9e", "metadata": { "tags": [] }, "outputs": [], "source": [ "# easing functions from https://gist.github.com/th0ma5w/9883420\n", "\n", "linearTween = lambda t, b, c, d : c*t/d + b\n", "\n", "def easeInOutQuad(frame, start, change, duration):\n", " frame /= duration/2\n", " if frame < 1:\n", " return change/2*frame*frame + start\n", " frame-=1\n", " return -change/2 * (frame*(frame-2) - 1) + start" ] }, { "cell_type": "code", "execution_count": 21, "id": "21cf5c28-d738-4548-96e5-7fd2ada88d93", "metadata": {}, "outputs": [], "source": [ "dither = Image.open(r'dithertest3.png')\n", "wd, hd = dither.size\n", "wi = 150\n", "hi = 100" ] }, { "cell_type": "code", "execution_count": 22, "id": "7d59e3a8-f09c-49c3-a92a-9d619b43681a", "metadata": { "tags": [] }, "outputs": [], "source": [ "random.seed(7463) #12 #255 #76543\n", "fixedShuffleOrder = random.sample(range(hi), hi)\n", "fixedShift = list(range(hi))\n", "for rand in range(hi):\n", " fixedShift[rand] = random.randrange(6)\n", "fixedStripe = 4\n", "fixedRandoms = [150, 15, 6]" ] }, { "cell_type": "code", "execution_count": 23, "id": "052d8bb9-5a28-474b-adac-85850fd09e62", "metadata": { "tags": [] }, "outputs": [], "source": [ "def postprocessing(sourceimage, cleanimage, ditherbig, fuzzmask, fuzzmask2):\n", " ditherbig = ImageChops.offset(ditherbig, int(wi*random.random()), int(hi*random.random()))\n", " dithersplit = Image.Image.split(ditherbig)\n", " outimage = sourceimage\n", " for n in range(6):\n", " outimage = ditherImage(outimage, dithersplit)\n", " outimage = Image.blend(cleanimage, outimage, 0.15) #0.3\n", "\n", " tempimage = outimage.copy()\n", " fuzzmask = ImageChops.offset(fuzzmask, 0, random.randrange(hi))\n", " tempimage = ImageChops.offset(tempimage, -1, 0)\n", " outimage = fuzz(outimage, tempimage, fuzzmask)\n", " if random.random() < 0.25:\n", " fuzzmask2 = ImageChops.offset(fuzzmask2, 0, random.randrange(hi))\n", " #tempimage = ImageChops.offset(tempimage, -1, 0)\n", " outimage = fuzz(outimage, tempimage, fuzzmask2)\n", "\n", " outimage = shuffleLines(outimage)\n", "\n", " return outimage" ] }, { "cell_type": "code", "execution_count": 24, "id": "e160bf7f-41b8-4869-9dde-ca4df89a5a54", "metadata": {}, "outputs": [ { "data": { "image/png": "R0lGODlhLAHIAIYAAP//////2Nj//9j/2D7/nj7/dxf/nhf/d//Y///Y2P+ePv+eF/93F9jY/9jY2Oe2Ps62Vs62MOe2F27nhm7nYKi2Vqi2MG7Onm7Od27AhueGbueQF+eGSNieF86QMMCQF8CGbsCGSKiQVqiQMNh3F0jnhkjnYEjOnkjOd0jAhkjAYDDObhfYnhfYdzC2hia2bjC2YCa2SAC2bgC2SEionkiodwCQbgCQSOdgbudgSLZuJsBgbsBgSLZWzs5IMLZIJrZuALZIAKhIVqhIMJBIJpBIALYwzrYwqJAwziYmJiYmAG4AtkgAtiYAAAAmJgAmAAAAJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQABgAAACwAAAAALAHIAAAI/wABCBxIsKDBgwgTKlzIsKHDhxAjSpxIsaLFixgzatzIsaPHjyBDihxJsqTJkyhTqlzJsqXLlzBjypxJs6bNmzhz6tzJs6fPn0CDCh1KtKjRo0iTKl3KtKnTp1CjSp1KtarVq1izat3KtavXr2DDih1LtqzZs2jTql3Ltq3bt3Djyp1Lt67du3jz6t3Lt6/fv4ADCx5MuLDhw4gTK17MuLHjx5AjS55MubLlslEya6apOcqTJ047Q4ECt3NmkaajcNb8ObTm0aVNgzxdkLZL2wNxG9UNgLdZ3r4vAlf9crhS42uRc6Sdurnz59CjPxcYXChz6diza9/OvXt26sSXE//3Tr48+OPjy6tfz7595/MZG8hvkBkBAvf4m9uvHvR6/v8ABigffxDNR18U+wWYX4LogafggxB6N2B4HaUWRBAcZKihBhx26OGHHWaYw4g5aGgiByBymCGHmY0GW1OpUUDBBDTWaCONJeSoY440yujjjzPeKOSOO/YI5I9CDkkkjxMciWSSNs4wQ4suombahSeimOKWKnJAYolZagniihpQ+SJTMQYJJY5LlmCkk2qu2aabTcIZJ5RzvunkmjVKaSZpH02YWRFF8MDDiDgkqmiiIILgKAg7RCqpoZQemsOii4KYGlSdzelpmymEKmqOKqgQagYZ2PjpjqKKWmqpp6b/WuOqOrYa6qumpoCqqjrKIMN7IwkaBaGGIoopox8+CqmkkVZa7KXH4qCpbE91SuuqtqZAaq67znpttrjGyiut4L4qrrc5+gqsSZ0RSmizzhp7bKOPMgtvpfLiMOKm1WpWLqy6ysomubaGG/C42BZs7sHoJtwqrqXaYMMNN6w7Urvu3ktpvpkmW6+9zlq66L7UupbZv9wKPMG1JaB87sAOu7pwtzB/inLEE1e8WUmdXXjhl1+GKbSXQBc9tIb8mhyFCUybYKedTUctNdNPwzn11U5XfSTWU/8YtZRSKqFEE02wq5nPQRQ94tFZqg002xwkDaNmUWu9Ndd12+013k3r/70331nL+DXYYpNtdmYXAgGEiVx+aKLRYTbOYslLpcbnp3o+ebmnmfvIZ81Edi7j5yuX4Ku6O5PUcxCKMy55lyK+HbnkcqPX2eZ51nkk6ZjrDiTvnPuuuZymn26xRwIkLwDG7hbhdtGLMhvy88/XXlQC2CeQWtSfTg0xxDlyz3Kb3n//6tTdS23+qxRT7GfqHym/vGbNE0r9l9FPGu/9RVtPVPbaM4345lS+9YWvaeMjn/rWpwL0eaqA5mvfDd5HoIokzwEOyMxnCEWEDhJBCELQ2LOiJS2POcpeO5heDgzlnCQkgSgXzGBzWtWtBGYrRzSUlQ0VlkPQ2YyH2UrBCv9WcDoZUCwzLhRJDDX4BA56EIQiFFm06HVCkO2Phc1J4lCWOENR1XB8N2yZF3UIRiCea4cPy1W2hljEI0ZBi4cbVv3m2Dy02dGOdMyjuy5EKOfAByjJy0wgTSNBCYINbEVsYyEXuchDSimRpzskJH3FyEq2z5EzmKQRLSnB44WEeXqs4x1HGco88rEIfuwNhXwyyEF2ppKY1CQnYelITUpykrNkZCxxmUudVRAjnZGABBRHzGIa85iKG6XPkMlMY6bylzfxj2ZuqUlIYvKaiKymNbF5TW1uk5u19CaVVKcZYTbznMRUZuLQycxnrvIn0swMNb3pK3Dukp71tOc86an/z31Ocpyf1MwHPmBKdd6xlPUz6IXcSZR4RuGeiZRSLyfYzUlKdKIU9Wc+MZrRbG7zBCeApkU6M9CCKtRnCBWlQRk6FIdCtIgXzSU2bTkDjr40kjXF6E3zCVKRTiQAQA1AMIU5TGMu4KhITepRGcBUBij1qVCN6lGhgxTnHOCqWM2qVrVagK4WgAAEMIBYx7rVspbVq18N61jFata2YhWtYF0rW8uKSRTYFQWfEZtHgirUchL1mFJFalOdGtjCPpWqR7GqW9sKV7WudbGM9Wpc5QpZszZWrgYwa13vmlcleAR7GMwM2TZA2g3ccbCoTa1qn6pa1JLgtSRIDRyPElrW/zyhsmXFrG53m1nc5pa3vv0tZiV2yBoYtwZIfGFHQCvD0Zb2tK2N7mBZK10GwDa2ppmtUWrLxOBmlbfgJat3vwvc8WJ1t8QF23GR+0blzsav5jQqVBWggMDS9771NaxSU2k7zYQ3vFv9r4B7S94BgzfA4YUkSHsKP48MNb7FjCp97Yvf/OoXqfxNSmoMrFsEc3i3Hv4wZkO8WwUv2JMaEdZASQvdwFa3ulHtQAcybBRhZUbEOM6xjne8VhMz2KcFOlBmVmxaOzLVxS+Oboxn3Byl2DgKPI6ylKeMWR+HtMEVisJoiFrUYlbYwheW6pcP2+TKvQYKc70qlQl8gDUXWP/KW73lBeZ8ARRvhEpcPuaYw0xh/JLZf0URDZrZ7ObzUvnNUY5zNulcZyyLJzNcnmOSm0rdSaeWxok1DWT/a942A9i8nPYtJhd8ZSBH5MESkLSlK23pwWJ6N5pebKjHO2vv1hqyoz6xozNSWxc+4AEsZh0x+ZzUPV/4tbJ1L21lmBknOGHHal5zb6U9bQOb2Lif0e5Gep2EXwc7wsQ+qrH1i+zsKnu7zI6Cs6Ht6UJTO9oDvnYNsn3ujpAN0kRdp+KmG26p8vvPUSCb4czcmU5flrLmPfhjEy5Zx4pX0Ye8K16foNeQ3DsKXNY3EP7db1ZHtTMCLxvBNWPwho+Y4V3/nezCx6vwh2t1s3btrJXIFt91svrIHVdqa1NT8f5mBrJo7erJyQv0oGM26AUYemUPGYMYoFXpmMQABuzamdZ8RLRNqLmwb07YnAtWtTz37Mh/vlikKz3aRX+6XM2OcNwy3elehbojpU512yJvfkMmaP1ay3V+t9rVZUaKK0nu2wMbOriG7/RVfSVWBQ2SI4Mv6d5Xq3MlL+DvTX31FvFOeNwm3tOIL6/iD8B4Azh+fg7WDGlFmdq+Y77rX9d8Q2Pt1lsX/tO0livqFPTHO6t+A6xHresxT13Zt5T2bbW953Fva93/6kG918hQAavUcXt9z8a3jmnO3m5qt93QUaZg/4Cin5Hpy7fYFfY6+v28gOz3Z/vfh7f3Vw5+HosfQOSnCF/ND27Dclz97Rd4RbF/nvEZT9ByaeZdCMhmwbWAZpUaERCBEjiBFBgBfRQdHEGA+EZ9/kdpAIhhAkgUBGiAB2hy8edbDohyacV9VwWBFfiCEXiBiKURGEQ2YiNMGudxH7hUroVdTKRtRMFd6vZsLteAJkh/RphyDpeAbtUCLdBZMAiDHuABMqgZQLhtDmCDSoCDwqY4OriDqVVuP1hvQZhu61aEKHiEaIhbKQhZTgiFUViBU1iFyRVHXNh/85V+H4hf7gcUG6ZjCCZ/IkZiONYZcQiDigNoqYdvOShmev8IgHwYgpnWGexGdN03iFoVZYZ4iBWYiJQDEgmSGcFmc8T2eh6YVH3YE6HoX/PXigPGAizgRpkxhVMYgRBwi7h4ixWwixVAh+/kEas4iltXiqYIe1MliUSxijfmiswIXrAoi1FAix5gi7mIi7zYi6j0iQGFb3OUVHz3da0HjsInjkyVij7xh82Yjrq1e1FgAe5oARX4ju8YgQu1a+/FjfXjjZTHg+HIj+Poj+WIjIEGf+pYkGPFjvIYj/IIjxFQj6Y2Uhj3V+enftYnVebYE+iIhlNGiDmGYJi0iRNYjRBQgYp4dREJYcO2h49YWBfJExnJhJcIiJkIZzP5kZpRgSL/SZLa6BG15VzCeCHFeIrkGF1iaIVkOBRC+BmdVomgxltOKCVO2Enr4UIYdIU02FxNUFpFhjZBiXP6+GJFWYdJkZS31ZQdqXjg9ZQzEJXtwx5U6QBWWX7w1WUpeWH9mHMtuRN/yHJBJ39IJ4gMWFl/2X3YBAMwwB75l2X4hpJeGGZ32XF5qRN7qYB92X2DyYJlV5lrVZiHuR6JCXmcN1CSRyhAuY9QFZQAZ2c+YR+seR8EaZCtqEku4AJ21prk95APEXmiGXyPWXmmmJr2qIqt6ZqUCJuuKJu0uWu2qUoGgZsQgWocqF+9GW6RmROTmYRe5ZeaeYJpl50xuVmqeRAl//loJ0mXjWmX/4iXAjl7xcmXaKWd7xmT7umdmAWewdmcO9kRujmaRVCaXjmUv+mbDFCd93ifBTF4ZFd7omeWHTZ6pJdIP/aLM7GfekeaQfB/l9eV/+mPBGqS4WkQCBoFm7aguQdiDmpiH7oSBiIsWok25wmgqyZV1/VavuicGSE/mbGiB/KcWgYFy2ic8weLEiMxFEMDNJCiKqGjndGiywQEw5dkgTWjJFCjEmoSOBoFSlql4tmjPwqk1CakQ1qkR2qgLAFAS/pcRtaVX1h5VBoh5fF4C2Gmr4mZy2eiS7mgi2RcSLoSciqKaMqVaiqgUcVUbeqm3gGnCtGnrGinDP9Kp5X1eXnKXjbqEHxFEAMwAHwFVGJzgxKJhzsIkIR1XYQSloYqHS5Eb1p0hRi0qg5wqSSolG+VVkK3drKadNWGdmkIVl1liWblhFnVVVLSdC/wAnPmQnEpEpU6EJeaqQGwqVvYqXX5qaB6VKJaBKRaqtBxqk9grMqlqqzaqgPwqmV5VUo4q2tVrraKqzDpVujKq2Xlq7EarDEwrMVqrCwRQxgEVMxVgwL3kxdqeRrKVNeVWhfSQYQyBEPwLPxDPVGksCvkLCDCrc4mP/LDqpd6sRdLgoC5rs13ck74sS2wVYY0A1vlhGsFshQzrPR6Adx6rPGjPKyqrwnAqiHnr9L/BaqmOLCoVbBEcLAJaykL+zwNC7QPWykRa6wTS7H4Cq4Y66oGuLGBWaIIB7LwmlUjW7ItcLIfm7IqW6/cqhLJQxAxm6nOGl86cLY6MGEqyX7UtX4KgLY60DhH8zpkAiJG+yFfuxAGorTOdobuxp2eRrUtQDFOqB4ulFx567IiMbZ8VbZFBbdqC4krqY9uC7dyOzR0KyYfcrcekrcKsbcU27dE+LdIaGiCS7gtYLhJgLj2CgCKGxLyYyDfmoX9upXD+KQvtmRSKqUX8gM/MC8mtCzSsz8ktCXwwiGe2xCsmjyi+24xiVmwCIun60vtcbjtJRCvC5rJI7vfWrO2+6Jf//l6uru719W7v4spVCS8+oMv0AK8IHK8GpC8DLG8AtC80ga1axW9LDC9+WG9qXqUKDG22OO40VmRHRe5eUhfZ9s6s/M6WyI0a6MlnBu/rTu/qyo/9uulV8W/3DEancGtYom9AHwSApwABDyRBtxvCPxU+LXAi9PADjwmYRLBHDLB8psQ9Mu8feulc8XB2+HBRum/ypa9IVHCIceYTiqtxIhzyRQEPuAD1AM3bbOwhhICVhwCyNuyCMFXFpuxBtiuh8dwuloA7iq4XeWsYiOFHjACbNzGVdiyFfwSRixwSKzES0xYTfzEUSzFj0PFPHDFWEzBNywQXLyqGEuCYIyrfP85xmVMtWeMxmrcxm6cjaw7yC0RtgDAqiSld4D6jTgXsNGVUgl1UkEgyghlvSLMEPvqABpbf446ooy6wR8bctIYyZPMujiByZosUJzsMzeboTgLygxgyntEysQcSqjsuiMsEKvcyvgbtbcXywcAsrRMi7bMxhdoyTjxGRsIBJALZtc3uYXFTk1sUOR8zt6MtkD8mQlBJc7LYSo3Vp0hkrcYhw5JpjPBzRGpON+8gykcVed8UuhMznC7zsx5aj36zgYWz42nGfQ8klF4z5NaEhjUWWaLtiucc/8MVY15TgI90OmkTtmcBFW5zAVRW357aM9rYO/jQg+txiMNFBVNcc//ys8YDc4aLc6B1dHN9NEgDQQGNdIlDREoPboqvWMtnQQv/YJzmI1EvBqZ8Ws2Db4qrNNhVkxny7YUadUAZ3US4SKDxsNjZZOjkYucGIFVBxrvF9UPMNVJHM5aHW5Ynbb35c9cvV92NxFgLdab6UhUYtZnndY0sb062gA9mZXf+9YCSnz+VoxIFqDoJ2PXFcIRgUGjkdIGqb8Sw5bQSB5v+dQjQdg6etjCSNXBPGmPLb6NDdlIRV+SDVuUTdQOcNlGndnRu9mD25ZTSdJwadI2wX/R6rYZfcB3zWcbbdz3ZdAU4c73u9K7hU3dAcQGPdEoAdymvQDHHWbZfWHbrV/4/6XcE8HcpCtg0N3BPsql6YETALTeAbSYEnBKhIKaGSrMhEXfn1xdr3VpBqq0V5qgyUeiTSlB6QUs2EPIAQBABKEcMcHeippxpewu8m3f9W3fp91U+Y1aKcrfylNwsgbguSfgNiB+zJwABo7gufFO1D0StcWp3xbcCVzXawvjkhvX/VZuoC0QRf15hYarh+RGRCyEN74SK/6sLX7dwo3TxE3jSS7jOWfjvn0QOb6gOw56B9DjOvPj6RbkLIFqdyStGOp1X55zYZ5UIScRQCUQiKyGHNudDB2YMUW9WMHlduTlQgmAY95vd35UZR4RZw4Aaa6ErxxZgH6Cb76nVTWX0P8l3+Gr6DDK2IseXYa+pf4Nyx7+qAYASZF+6O6d6I692J3+6Kxd4YBnoxxep5U+opiOz2gyl6qG2p4e6vMdqKBuaZleG53XsafeVrdU67Dm3q0Opa+u2rPu6I2eZLx+4pMezbmuWdl07EKxisJU5IrN6LgLY6st7KfZg8c+eHx9kInk7EEB7RIg7cMO7IP66dkO649elBTB7d1+6d+u6suWGZyKxN1tWPdeWPlOYVH1WvRGEVFuogqdVVYe21Ex5HlmTPvuiEpe1Q0fbsO9AP6+rU9uEAHfoAOPVQV/vVWRGv466+XeatXu6iEfo8dY6y+J8dBsVra3SOOpYabx8TD/WvIkX+wiH+zE/vL4WZyGt+bCBeAun5/o9pbYWvRG/8G87bIlLYRHvx2fXfE/sfTp1vRU/yBPb8FEX/VOn/RQLxQDp/VgD31+rtYM4VBhDx1AleI28fVn3/bugeZkvxBm7/apkfZaCmsJTvd63x0T4hBzv/eChHr9kveAX/jR0fcN8feAj6hNYfcg1wRLEPmSbwSUX/mUfwSYn/maT/k90Pmeb/mgD/qaP/pHwPme3/mhb/mon/qhT/qbbwSnv/qWjwRIoPO2DpJnnfu6/4Ke+PhS4fiaQTaSP/mp7/qZb/qnz/qtb/ylD/uxr/zOD/2Wz/zNH/s9EPq0b/uEf5O7/9/93t/7wS9yca4ZTFD+TED5tJ/+SID96t/+7i/9oO/+8p/+8D/78y//9V/54D7PEHCNuygCACFC4AiCBT0cRBhBYQQIDR1WgBhR4MCCBA8GCRJFYxQAHT1+BBlS5EiSJU2eROlxYxQmLZkYMYJE5kyYNWPOxJmTpk2ePXX+3NlT6E2gOocOXZly5MqGESVOrGgR4cGFDB02dVphooioIy5m3KhU7FiyZUmudPnyaM8ebd2+hdtjLdu4ddvO5WlX7165RpKaBcDUYVXChQ1Xvdrw8GEgQP4ChhxZcke0LvHa5Av3cs3MbzfD7By67+OyghUvRl04MYTUhBuTnhxbdv9KKFA0LlkyNPRnzp15g/b9+66Rtis1kjUepbXq1YOXo9ZYu/Zs6tVJ1r6dW+hu4cF5c//et7hx5MafI25++rzh6NKtv5ftwEFy+vXt38efX/9+/vyTJJHvv5MCBHC+/g5EMLn/CISvwcjkSzBCCSek0L8CBTSJQAgr5LC+BR3A0EERATsusA5PRDFF+ijjCKUSVVSRxRFnHOtFGG/EUUIZXWwxxw53pDFIkRogsoESiUQAgRKFZJLEFgWAUoAlRUoSSJVaZLJII7G8skkvAdDyyAaSnPJLM00qMUopuQypShNDKpPGMNl880wzk7MzT5MSSABPpaD0005AydPzy0BtC0W0Iz4PPWlQ2L50NKxEJ6W0UksvxTRTTTfltFNPPwU1VFFHJbVUU09FNVVVV2W1VVdfhTVWWWeltVZbb8U1V1135bVXX38FNlhhhyW2WGOPRTZZZZdltllnn4U2WmmnpbZaa6/FNlttt/UyIAAh+QQABgAAACwAACYALAGMAIb//////9jY///Y/9g+/54+/3cX/54X/3f/2P//2Nj/nj7/nhf/dz7/dxfY2P/Y2Nhu54Zu52Buzp5uznduwIZI54ZI52BIzp5IzndIwIZIwGDntj7nthfOtlbOtjDYnhfnkBfOkDDnhm7nhkjYdxfAtheotlaotjDAkBeokFaokDDAhm5uqJ5IqJ5IqHcX2J4X2HcwzkgwtoYmtm4mtkgAtm4AtkgwkGAAkG4AkEjnYG7nYEjObjC2bibAYG7AYEi2Vs7OSFbOSDC2SCa2bgC2SACQbgCQSAC2MM62MKiQMM6QMKgmJiYmJgBuALZIALZIAJAmAAAAJiYAJgAAACYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI/wABCBxIsKDBglUSKjzIsKHDhwcVLoRIsaLFixElVsHIsaPHjxg1bgT5UCTJkwg1olzJ0iTLlzBbqowJICHBBAls0qwoQIBOgTh/7hxKMEAAoT2FEl06NOlIgkpRCg36lOlBpzdzVrVK0yhSn1u5ij2JNeXKBw+YMEErsq3bt3DjtlWLVu3YnXXXPpDLt6/fv4AD86WblsnLvGwFKw5M2O7dmIj3Lp5MubLlhI0N05wyReDlzxo5C2zS5PFOnaBTq16tUzRM16wvuyZtmibq2LhzAxbommxPsBKLFNlBvLhxHch1+Fju44fz58ajSy+eXIfz5S5rv8TpVWOF7+AtiP8fr6G8+fPjx4NfHz69hfPwNbi3wL6+/fXz46N3Xz9Hjuws/QacQsJNR11yzDX3nHMGNrhDddf5AKB2KHF3lHfs5adfefPd952GG3bo4Ygfurchh/yx59+EQwU33IPVKafggg4aGKOMCzK4A4sUviSRePfNJ16IQgYpJJEi1ifke/otaaR4K07ElIvE3bhcjj/UOJ2VM0K340w92qYQkPYtiWSKSh7ZZJFlqhmfk21C+Z+UQznggIvC3SjCnnyu4OcKCV6ZY5U36sBnn3/yGKZUCt2XwaOQnvcoBRRAYCkEJIIHaaTmTVrppZl+t+mjkmZA6aWYkkjmdzW0WoNETNn/iWcReh4qwp+ABoolobUeiquii5IkkaOjlnoqqKGOmoGxn1oaagXKMotqpqtW4OqrdOIlWRRREOEtESOMYOu4toYrXbjookuurc5J5FiwZ0mmFqr0plqfpRHkq+++9dZ7H777Btwvvf9CELDAAyPbapTvDpUYt9+CK+665JobXbrpUsxnuwo1DC9Jic2bcMEH85uws/YBXHIEJ6N8r8Ers9wyqzUwrNmUCh2h8xG7ahlddQn2bCCwH1vklERvohkneScmufSQTSudZnonyueeDVjbAKtVEu3M86A+H4cgc0JPR3TRFB2tUNLpjQjimm17+Dbb6sltYtTpZa11ti0q/2TE34D7GWiXOhZqqK24Do7l2Wg/pHZCpGqwKaXPrhet5JAeWzm0xWLuqcvJdq4sDjj4R/rWOCcEeOC5Bg224eMmrmuOjDfe0ONVRD45BZuLKnrmn25++e6gZzr8qKSbjgPqSyUEMRHCCccDDxYbiPH1GDuHPcbEwWX7RW4tOV/MJYsvJPkHmz8++vuaH0MMekcZ1WlVPB99EdNXP93222vPv8Xe+15Fwqc+8bCvfQUczwH1lUAFLjAC7oNf1uQXlpUg4IIImNXqvMbBDh7hfiCM3gY5KJy/6cwtsqrg9+yUwguK5FowdBXpkuefGiqPdDHMoQxnaEMbzhAHOtThD/97WMMfBjGHP2ReTDCYQQKJEHAejOIHQwjCEXqthEY4YVtSKECDsPBOVXChRo7YqiESMQdGJOO1zEjENKqxjDw8oxvfmES+0S8hHOCAcCLGRz5S8Y/R66MgoVcEb7nFMyrsYk1GIhK9OfKRkIykJCdJyUpa8pKWVKKY8KjHQg7Sj4D84ydBaci2IFKRDLmNRDDJyla68pWwhKQmYyKREpRAijsL5R6JYEVcTjGEhwQAFaiAyoKkMIUSmaMa2dhDZZKRmT6c4Rt3SMM2SpOMF7jA/GBSy1v6Upee7CUu/xjMYRaTIMcEYzKvOU1oFpGddIyjNXE4zRq484ZAxKY2Eyn/E07msY8LCOgCFEDQggr0oAhNqEIHWlCCBjSA58yISAxA0Ypa9KIVPYBGD4DRjnq0oxvl6EdH6tGQkrSjMZSABLI5y35WIY//5ONBG+rQhdp0oTRVwEPfEtFUtuWkGDUpUIcq1KGetKhGTelK97nNkySGNDDlQMR60IOa3vSqAs3pQklAApF4rKcESUxCpCCFkQoVqUbN6EbTetS1stWjeqMBDVTqAhdg5mYweWoTojrVquoUq4DVqkK56lW8gjWskhlrWT96Vre+laJofaxFIyvZuM5VAnW96x1fygFbdrABoA2taEcb2puS9rShDeZhjalOhUj2tbCNbVpf8AIi/7bgti1o6UokkkfPchC1wG2AaYM7WtWudiDIdK1sl8tc5tLWtrjVLUrUBoLqgiCEByWudkuLUNIS1pTHLcqFJBLUkJr3vOc1K3rXm17Gsve9GlUv1q6VTZbacboDsu51QZjd7Wo3od7tKnjDK5DukPei8IWvehO83gUzuL0lPcB8XVVfpvITJInhjC1RgIIrFsG/w/UvaL/rLsP29ItirQJZm8viFg+VtrSFAQyiedvMVuGr8UqIhkvAYQ+D2KYiDi2JO2biiKI4sSperIuXzOSKwvgFMqZxC2yMY5BtKwr6vZ+3ghxcAAN3yJolsEBSvGIDPLjB7j2zeR2s5vgmFf+GGMAAlYuMkodh2bpaJgKXgetl1IL5xnQGK5kX2+Y1p7nQIo0wohMN1BjGec6pq4Itfeu1H4dYxMYV80SbzOlOG4CILGCBSqV7km5SemeWBjKXM03gTXv61S0GtaglQGphKaS33qw0ly+tXVavNrkJgbWwl/vcHuI2t/fd7a07m2tU71rV/vX1YYFdhWFb+7XFtuGxa+0RvcY0YoCFNnfD/ecqCxrJpClAAcpbaHW7e90IRvS71c1u9j5So/OGN2Ql7MhH25XIkJEMVKUq03ArlLQGX0C5A93TFKdb32pt97zrreZ8Uxy99z6AxdX6SH+XOCZU4aRwdL3nPq96wAT/xp2a2dxmlhe6VRRlDVW2oxWRF4Hkz+7vnqUNVpWf2eU/P/SiYW4AmWvlMALfK8HBjVDBJnyhoD3owsU8ZiSXOa2UfW3W36pRCoImM0hPyMAB2nSaPl3VUhfwx6k+aK47drlbZ2vX56QasHNz2dg9+8FHG26e99TAVeDMxvc9+Ii3ufD7lvi7sYabU97d5vfT+95F23eUhxfwgp+4WhFvZnlrfrKeX/zeWOP4laitx7n8cAOsKtAuL2DPpPV7RH3+XqA/2PYM9qhIVKCCEPj+98AHvhYhGqABoV5nwgEt6wPqetgX1/LHpT17cZ9g6iu4o7vvffC37/vh8zSv8mJC/x536S3JB9TpgJ062yUzzDK7mcXvb278Ryrju3bg/vi/vwf2z//9d/8IhUUUISN+ncR0kod+WKV+YpYY7UdojMZc8wd3D/hR9Qdo+Zd//dd//xeAzaMQp6YzQcZrmAZ9v9ZawXZt1iYR92cCLNiCKZACvBeDMSgctcMoCfGBRxCC4hZksndO1IaCKagQK9iCLPiCMiiDNAgmHZgQxzdFqIVVzpdQPRhRrgaEndYqEvGCRniE27d/SchtNlgFTZh8pwWFsCeFJHhcVWiFTYaFCqGFMMiFweeFRVCDIHF6HZZ6lNddzsd3fAhaU4hKIadckrVoEQh6i4ZRFCSD3Md93v/HFXjoY+PWen24hzrXAIGoSIN4goVoiNZXexe1iDHYiNv3iGKREFkGQlH3h5UoXKwIiGm4WmtoeCtHUonIVtfCeApBir+XgR5gh4ySivezipdYiSYHi8CoSLOYeC1ni4j2Vrk4elXAi77ni8nYEd7GAdXlLX9Tfq93WgT1Xzs4WgpIYG3Hhs1FW60SZTVUGXanLWKndNvIS0bgjagVjsQlgqJVjuF1juhIbC+wjjPWjpTxjpskaTyWhzj3hOO4cxphTlSHO//IYjokAzJQGaXXNzeYkJ+Vjw15chIBkWImkRPJXBV5kZSRkdoyTGqxARtQXXl2dghocEPGkgwXUf7/aFSHGFs7mVY6dAM3YJMQkReIZW519gA26ZIwGUhEIJNmp3c1SQVGiZNWp2Q6OYGy1ZNvFkNAKZQPQZQDAZY7kVwcxmEhZImTd4YK9QEfkImotIwl+VoxdFtgiEh1+RFkWZZnOYnHmHMIxZZuqYwaEZfNNZfI1lQSlWyPVwUu6ZLeskvmx1ANdXaBuYSB1xkhMZhNFndut5MT1iqjppjBIhGNuQGP6UmROZNYVZlEIRG9YRFwCYFvl5WzWVGfWQOhiZijuWzj50lb5opOGW41BVpfqBCvSSE6YRTdAT4aUXHuRgAEcHEP9m7QKZ3whTVyJVcTMAF3WRu8BVPkp2fA//l0y2dTw9kAxaljmBkmyamcupkSEuGc6lad8aZ4BUCfiHhm2Jmd29mdpsEt3BJV4cl8fBmZ30iMAlVKulEZs1EaFAF4CbFe1BmdFzWh1plgFlqf1+lI2wmgUaBIHiqgvtmUBzqeBlqiCaWgCzoZDVoREFoFEvqcFGpRGZqf8nmfM0qL9sahE+ChAvSd30aPxShiZkhaIIiJK5qSi8ScB0aYsiVr/vkYQLp0QkqJJXdVqHWkSaqk7wkVmumksQWlogkTPSEQF4RYaIETaqqmIUqlv2mMf/kB+8hVdMpVoMUADDAEerqnQRAEvvInivM6hnM4e4IrWDIuapGodIYWaP8hIAJCVlfnpPREdBQlY09WqTI2kDOwqTOgUoo6lfhlpgiApg+wpmvapn3Uiia6AGw5p3Vqpw2Ap3vKp36KKIIzOzQCI7BjqytwqLbyqYvKqI76G5BqlYQ5qTVgUZYKY5jKjpzaqRIArBTCqA+gnAGwpqQxdgV3oty6AKeZLtbzP9hjHPqzIOuiqA5BrQOwruy6rpyRee/WWPapbuelbpl6rwNZgYzBBHclrQAAqtqCFtaKrdkapN7YrSf6regSruLKPcVRrs9xromarozaru36rlOQb/J6ePNWrwWAr5nqH/oKGGrRr58qEABrFdRqFNnaBPNogOT5lKmpAFRFVXv/8j8ak7MiYDHXsyfmKgLoahHU2hPFWpL36nUFya+AhrI3KRYrGwAt+7LfcoAya34EVbM9cLP8o7Maw7MY47MRC7QTK7TCKgBFO5FHS3eWUbJL+69NyxXqOgCkwUmp2of6SFyyOgQ2y6uBmqu7+qe36jrOsSdBCxE9MbRmC6lGG7JqOxlqQVZCkbJMEbdzy1l1G4UfGVx5u7eFCqi46iV/y7efS7hja7gCgLhn+49pexmPKwWR+7ahehA4Qa044aHzOIyq6ooBFlywSpzRIwRCQCjEESFlEzbIMbw/IChY4q9DWbEDgLG12InnBbL32rKk4X8hcITaqwLeZ7KSG7sG/zG7jFq7AHq70ZO7ukuOJMC76xta9wO8wrsDxAs2YRO/87u8J0sRcQu9QSe95kW9mWq9TYC923uE3QtohQsvdpIX3LKUMItVqml+oxQx4DTBn/RHXsO2TFsR1Jq6aBvA2eqLIsx/vKdFCWw7C1wYDbxfD3xVESx5FnyaoRTDgoTBO6PBbsvBjOrBqgvC1zvCIlzCAIjAsBsm2Uh2CGt+4DTDF7zEokSPnKEWOGGU1moUGTYFITWf0JmjzOicW0wA8Te9MBCPQBzE3DvEYaZIR7ytSax3TvzEg/TGVMSNRhDFTDDFDFfFAXDFWYyj+Kmj0+nHYMxoYkzGZZyBQrx2tv8jIHZZBUuJuwSKvqsYYLDKVUeKfFSEySPnSx1kw/fTQVvznkbhpSdoiFh5ledFQcA3wr4ng6YoQIy8SKi4X5BcougbyUJGpyNGApf8SyCkyTfHySSUyb4MyhMhygFAytXWebfovyGlyr0owq0cg698ThLRhEcqjpLMXaLVkVe6zTW4poAHYZ3Xxc0oXzZgQxLBiNToe9fIngqBzTm4Xbh8yyXqzc8GzkroEOI8XjBqaPtmztHrXlijzgrBzu38ztqRGGTVm7iLuUMK0Vbain05p7ucxmnzG3zcvyBliK0yd0i7r2LZRQwtBQ59vnb7iikd0WrJ0rt80W3LExotGZz/MdAXymAffQAG7bh68b3wTLdsPFNVO7OTya0v/HRcFVCc0aUN0aRWGEmKMUyhfGFF851IXHZFfaJHnXBbTZMkoNRTwNQ+xYlPLUuCIdXHTNW7mRClScFFQLVZbaDlKdRxTdQGhVBROhBODYR6cy3DJJIUERVi3SOk2ZhuDdd3rdV/hVNDbbWNndeN/I997Sp/TUywGRaDjZzL5phBrXddLZyNjdhzrVCQLcvL7L+y1Sp645+uuZ5vudmm2dlOWdeOTduivdhXVdp7LXe1CY01sNpjahCtTYXxXJb4jHCZS8/JLY5Q14r+eaamXZIxVNpgdc3G/Vt8ttwe2dwSXdEg/6nWBQHduw2E0x3cVNfIfMVHoz3biW2gCMrY6x2zBKXbhKijshlZk03dPTWlfRTfXB3aevfeCmXbnl1Q9E3W5nzftZnf5r1a4s2bHLA6fwOn3E3RKq2DFe6qagfeY33aKPhkNHQ6DX5cD+5PES7hFJ6WKV7PfunddXrgHn5tIF46aLQ8I37eEiGM0XO3zG1+3a3iRLoAMF6SRKTfxD3Lj7zj2s2Qkfnj3i2OQz6RRX7jh2Wt/C3bKIqwaNnGWFqgN1XaHvrHAs1gNQrIG/VIGHveDmHlEH7Vl5jEW87l4pZwYA6gYs7MHKvFN43m76rmJaERQUpV3frZgQXgwWmeT/95jSFJBcwIf719UdG46H7e4UDtLYJu1IYu3+09szclWIquEMPU6PL36BYV6aBu2ZOu14y0paze6rcxQKvu6oKhkmquSrJ+6423pIEd67juF7S+WgKSENTW68RuGVy0641c7HHx69H3G8Jugsoe7Ypx7BBh69IeTJm931Vx7dy+G7pe7bze7TOR7cUkFOJ+7sv+7X+e7Oi+6qmuzBLxBPI+70hQ7/Z+7/UOBPq+7/ze70CA7wCP7/4+8AQ/8AF/8EhQ8AaP758uEYf88Px3gR0A8SKsokbeRW4x7/SO8Pmu8P3O8QDv8SL/8SB/7yO/7wDf8ApB8Q8v8SyfgRZP5av/Jb7x/gRO4ARKkPM6v/M5vwQ+//NJEPRCP/T3zvNGrwQ/D/RDv/RFf/Q7n/Q+v/RMb+9O//RLgNEynWK8eAInUMZcX8Dt7IsbGNPvzhA0rxDyfvNVr/NQvwRST/RUv/ZID/VvL/RNv/ZtX/dBf/dV7/NYn9FaT4pc7/UnAPbUKPYhYMJF/O4SAQWODwVS3/H8XvL1rvdJIPkoT/mWj/n6TvlIsPkJ3+8w/vKkX/oeUJxlD+sJ8fiQP/X+7vmg//qar/ec/++zX/e1P/qmv/sPj/qpzxDBrhCOH/W0H/d4T/fFX+9yP/dJD/rKL/d5//Y+X+/hrKYi4Ytcn/1dn4Ff/7+9YS/N2asCCj2Szi78UED8uG/8fY/86f/8x9/8yY8Eyx/9Uj/9SFD9m1gF2K/9299/3a+9ABFC4ECCAj0cRHhQoAoVVRw+BBBR4kSKFS1exJhR40aOFB9+BBlS5EiSJU2eRJlSJciIDju6BLBS5kySEalQ6ZhT506eG2n+BBpUqMyWVV4ajTlUaUmbOHs+hRoVI8ylVa1eHenAAUyfSLFiLSpV7NinVL+eRQtUK1eNZtMODUtW7tyMbOPSxZv3aMWbez0i1et3ot3AhcsClkjY8GK6hPtyJKyY8WDEdydfzpggwYMHH5kwwRx6rAABnD2Dzmn64WfRFTWrdsi69Rnsia87r0ZNWzdH0rCryO7oGzht26d3Qw0IACH5BAAGAAAALAIAJgAmAYwAhv//////2Nj//9j/2D7/nj7/dxf/nhf/d//Y///Y2P+ePv+eF/93Pv93F9jY/9jY2M62Vue2Pue2F862MG7nhm7nYMC2F6i2Vqi2MG7Onm7AhueGbueGSOeQF9ieF86QMMCQF8CGbqiQVqiQMNh3Pth3F0jnhkjnYEjOnkjOd0jAhkjAYDDObhfYnhfYdzC2YAC2bgC2SEionkiodwCQbgCQSOdgbudgSM5uVs5uMLZuJsBgbsBgSLZWzrZIJrZuALZIAJBuAKhIVpBIJpBIALYwzrYwqJAwzpAwqCYmJiYmAG4AtkgAtkgAkCYAJiYAAAAmJgAmAAAAJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAj/AAEIHEiwoEEADx5MWTglSZKDECNKnFgwIcOGDylq3MixIwAHIB1YZOjQo8mTKFNyHLmwpMqBLDG+nAlTIcmMNHOeDCnSZkucOoMKfRnTpcqELgUIQAp0KEWmAhMkgOq0KkSqSqla3cpVqlaED4yexLo0bFOuBql6NYsWLdmvbePSXCsWrkcpUgRe3Mu3r9+/gP/iFThY7taFegMrXsy4sePHkBkSzvuycOTLkQsXNlwVMQDMoEOLHr138syESpTEJM0ao13ONAcMcLi6te3bpGmzTYlatU/conWLhZ1Ttm7gyJNHFn52o1SpAQLwBQJkh/UdPLJrv8G9u/fv3W2I/7dxfceGDdzHk7+enS9xodHjS99ror6JE/jzr9jPv3/+/PYFaN9/+PVn4AoEniCggAke6B+BCwbYIH811OBeSs8lEN101bGnXXbghfideuWdl9545bVX2ns6ybchfQMS6CB/CUYY438z7lejjffJmOOONk64X4UXziTVRdSJCJ51H4KopIgklrdDkSwGleFFQEYopINZLrjlgV0y6OOMYdZHAw0XDXUkQ0k+2R2TTboZYpTlUVllTlcyVOaN+v0IIY9fGrhnfYE++J+NZ6bpVExENEqEnODRiV2ckKr4051CrYXlnzx22iOOfh4K6JhccqolqQdWSKRMQjHqKKQjov/o4YewWsoqpnhO9dugnhKKqqCmevmroQCOCuqMqlp4q1AX/eDsD+dFK+2053HAAXjWZpsttdxGayeuOV0UIAUUVGDuueiSq+666tpILrrwVsDuvBS4W26859LLrr3xxuBvDIoO1eyz3XZrLbbablswtd+CO5O49r2Lr7n6rsvvxPJWTO7FE2u8cYQSo/svwJI5hSR1QHCXsMILU3twdytbW222DTuMEl/6coyvx/WCfG/HHi84r84YVzBywMyyibLKMbfM7ctMrzyztTXbbBLO9BINL89apxu0gEP7XLTI/yId1MnP/iCz09FCDXPTLVdtdUdYa9x1vl8L/fPOeYP/vXe8GsMg+OALbZb0QtSlvTbbG7gddcJOyz33RnVXfDfFfY/799aZR7y51/oOTvgUhquEAAIjPfEEykD44AMOOJwXwuy0U0t7CFJOSusN6ql3nq0XDTc5RCDVBgUUvdanwvLM78e8Chpo8HHyJjy/vPPMRz998targP3y2vdsIwssiL6q8KajbpPqrLsOu+y3h2A77bk3ycOJvdvwOw9+oT98QcX7zUKOR73ufQ960hMf96x3wPBRT3kMXMHzHMgj8plPWf47jU1Sk7a0se6DQOigCEfoQRCirFF8Yc7/IsKUmEQhCiOLYQxER8MawkCGOPyXDXd4wxzikIcwOBMQ//0luhyerzlE2aASSGhClJHwiR1sInVQuBcVrvAgLfzNC304QyDSkIsy9OIXwTgyIAqRh0QcnBExiESUjCQ1FrCAo+ZIx0Y5q1FSBEKjghCEOvrRjylMwmuumJDj1SZZFTrTGcUoOEXSAJGqciQjB+dISCZSkTVMYw0raUlHcvJSOnmjEuL4xzrekQh53GMfS8nKQA5yhYWEwiERKclJBlGRlqxBLSfJSUjuUo1d3CQuO+nJMx0xJwFciOo60AEQ8vGZzzzlH/NIHWi2ci9OcMIr/5fFixyvkcP0JSZt2UtajtOWXixnsn4pxjPNYAYZ9Egyp7DMZn4QmtCUph+pCf8Ea5aSL9nc5vC6yZBv3tKYxFwkI9UZyXOik4cMvaRC20mDd8ZzIy6azwslwFEJiHABIA2pSBvQAJGa9KQoTSlJ/fLCK2rELweIqUxnOtMCFIAAOCWAAXbKU5r69KcxtWlOdcrTnQL1qDIVak6LatSk3pQANp2pDFNA1RSYzSMZXchGO/rRlC6ApF4Nq1hX2peWunQiMEWqU4fKVAOo9ahKxWlb3wrUuBK1qDV9alRlOtWqXlUlF4mAYCNQQrGKVQGITaxhReqXs3KEL22NrGR7StPJWjayPr2sZik7U8vWEAWgRcFfUxLYwRZ2sSlNrGJRu4DGOvale9nsZTMr29n/Vra2lqWtZD8b2tF2ZCQvBIFwQTBH6pD0uA1A7EmRy9ySfrW50CVpCUoQyNdOxIVRoOttJatdoOa2u7rF7FFd4AJIUvWdoNSgVqMwXOI6yrjMVa5JowvW59KXudOtrnVZqMXsgvcA3/2vTAMsYABPFqnkNW8K0LuscDGkoxLwZ3MRe9/6hrXCDXDtfiMCWdx6+MMgDvFmEVohGZhYBr49yUUgLOH4KgDDhsWwhjd8kA6L+MY4zrFmSVyDE6O4ZCqRz4olwMw6Yhi5yz2uSvE7Xer2hcYFEXJsOVtgAgvYyv8lMCTfyWDPBDk+Qy4yHY+s5PmWOcnIbbKTJXdWKV8E/68FjimWwTvn7moZkVyeQYrpxpDBEvZZ1GEtSlUrX9TOGMoEsbGIw3tjRuuYu3yNYQYmnYE9e6S0gj2toEVKaAUI+tCITsybcezoEJf60UyVqqQpbemNxKS9xQVCdNFM5grnt4pt3C92r3zgOBsY0nGuM3kTjMjz6rnBvPkNrN8ra+jSutb0vXXwcm3dXWe518HGdpW1PdNhl7fYCz72RTWS1QdztYOotfCmUwpq65Z7vUF9qlxTXWC7zrXe8r4rlcFr034XoK9UbXVE3j0FCHc1xs5dN7ufjGiCvzDebKW3gO0t8f9SHM4T9/e/Y1hVqwKZJhdhJghBOuuQQvu+J/9tN6L5Imfb8rrOb9WsTyHpXaYWMQYdZzPlGCLyD5Lc2SY/eckZy/BQJ3ovLYe5WmW+bSzT/KdtvXnOV3QUJXL04AoHaadRK+2bGL0m3oQCqrU99s6KV3DkvY0V3Wh1j6I76yHd+mK7nl6jx+R4Ywf2r3Vs9nuj3QVqF+RuAGtuPs5R6Agns8qhrOi8Ox7EgktOYh5W+FU2CvFjrfXiadz4x3tetpFHzuTH0nasyx3ucSc0SOmObCiPBC94/7zsmb6qwAv0uqV/u9ZVj/rUq3b1a/b618FSOCnEfvbIF2/tbbN2j0BnPgvhqJFP/uyTb96xSlGKon2993tnW+9A9Tb/XyZA/vJjAAMjSL/6009FwKjk+UOePrSrD+3rnzX7Ati+r5Uec27/VPx7UX7mh37rp37t9xcOthCZpntwd3qLZX/WdRF4gXHdR2oDhmp9N1kXQX4Q0IEe2IECKIDUAYGX1md/lja9twAOaFgk6FgSKAUUWHYX+GgZKFkbOAEf+IEhWH4jWHQ0ER2idHUMmHgJB3esN26OdXdi51b4plTeZ3H9Nm8U+Fbk9UKpsYMcCAE7+AEfcIBIyBFAmHsoyFpI1ntHSG2vpYRNlXFOWHH8FoX6toZ0VYVRcIVYCIIhyIVeiIY3Y25YV32CVmhe1YJnxXIVyIb9lnT7RlcaVwCK/yiHPuUvN4iFlDgBPShwV+OHQ2hmZYhagrhwOvdahviE2tWIj8iEb+hvp4hUksgQlViJl/hxRvIcQwZCJQdjnKh5Phhq2od012Zq++d/MUVsF8GFr3h+63eAakKL5maLQIeLI2V9u4hovXgRLwdi3Cds31aMH3CMBMh+RICJGrEWqcFRYoZHzTZ/uQhtZ/h1WdFf2sV/S0dvkPhfI7Mqx3MBF7CDyFiA6Tdty9gb5tgBsYZ50Sh07Wh073gRD0dX8ohU91aP4HWPypKP+xiC/eiPALkobSeEY3hSn2hSKzh3wVd3oaaGyZeSgrNTgrN8l+EQIPGFrtaRbveRIulpXv81koaVkF+HkimJfCtpAC2pLKABkw4gk49lbhzljCn4c504iNMIZS8CbwfQiKTYXVbphlipcU2VQy/wAqBRGKojMEopAUzZlM3FglFJY1M5BQ2ZlVO4lf52laXIlUzolWCJGWL5BGfDc8xkTzYpaE+5boToUsqkOk9Al4wIh4r5Vv4mhTzViHgpcGNZEF6mEyH3l4nzLFk3mJtWmFd0mKrTmGr1mHGIilDYhkUlmTj0lZTJl5Y5BZ1hbgsYmAqnk1AZii44ZY1WgTl2iqBHQ6AljrpZgtEnAbXJmb2Hm6BIdcPXeR8GnBYYYrxFnM7ZlwuxbIdHXxcmdGfWWmv5HsX/eTrQ+ZOeV52yiCsXoZ2OgnJe5Z3fCZqHcZ0TQZ68aZ6zh56XWSX4l5nCVZDcaV/PGKBp1mQHKI5D0Z+yGZsUoaCjhp+fF1OaBAPDmZ7v4aBTwEz/yWzu2aEEelxqdqAWKhcKahD7eRAYuhAQKnsSGkwUKlojWiVD5pHKCZK8l4KqFYvKoZd4QRknKhHlKZ29CZQ0FHAxyiIzWpM1epO/15Q5CgQ7Kho96qMLunMPSo95J6SoVkNG+qN3kpk9xzpOyVwHCZ/fCV9ROhqjZ6UMoaUS6ZAu94uTtWXH5qUy6pdhijJj+pRmSqYhhaZpGhprClvW6JtaGY9xSmeXRacI/2oVbclMf2hm65aWYlVCOZAD2vIkMbOpMaOpCXMRldkRL/KWdhmXdTmXhxppI5NXqFpUfVWcW/GoHRCp0TipfhpWloqp2eKpnNqr16IkKwOqsCmqGuVfcLmIp9pvpClDrKqsTPWq9FkVCZEQayEbCREdqVFPzuieNkphRVimaqZmJMUA5MoAruM64iEtt5M7cOIk+eM70fIhC+MQ/jOtD4B/+CoAx3N8ydcCLbBT3haw35Z2j+EQP0GvCJsRSMl21Kor1voA2KoE2vpB0MikL/atQSdd4Tpd41qu5+oD6Rot68quu/Ou4yEt8lowCHsV05qv+LevS5iS/gqwAjtsFf9CsI5hsBiRsPQqEAtLE/YqH1KhOuWopM7SnU3JWmnjHY7zNr6aMEz7q9yRstKysriXELKRtQPwQqSqihcYZ6ZIUzW7jaGhszzrs3wYStMqtAlAtEpAo0f7nhibtCm1tG8jIk+7MlHrHVQbLVYrEfaqtbLBtcaqcWYHtoYrtjXrksuRBAfbswDwsyiRIZSbALV4QkQAn/TnnazjHeKRIpQCK567Hu1KKQLnsvnXpnAKfnJaVImCGyUqF5WbJ8fJOpfnnZsrdJ0bHqSrO9shuqMLuvbDHafrsoXaf6yrqG31urcRu3GBfzwxTxMrpiqIk7sXkmVqkNXrAR7QKEMwBEL/IASl667vOj+zUz+hy7u2Ijw8oRQgcToCMRL8CqH+Wr/1i7NTkE14mIMQoI/6CI6AIbkpAb3RmzpPkKeBVr2ctlpLprmpx73eC77i67vkmz/miztSMryxsr5n0b4C8L4IEL82Mb/4ab/2i7/6q4U4mIP+ewEA/BcCnKCpm53utZ2UWl99WoY4fFysVEf8NEU97MOYi46KYqcDkSFtmYEtl40idhHpx4VQHMVSTH46WqVWU41TsKE27Kc7nMPO1cUNEMSxxk9iTEe2y2xFbMUQgcTQNwVKbGBMHGJOPAJSXMdQTMVQGq24ojrHSaupR7cohVysA0U/LEWEPMRozBAv/5KJC5FxOGVTpIlUjTiJWFjH5OcsViixwzo5fFxwRvsDYYW9dCvITvREhdxEhwzEsXYRi2ycbgyFj1wAkQxXGkfJWzjFE4DJdajJK4TFWtyeAbqnXvzFPEwE0xXEhVzGsbbM4VgyRoy6xzuPyWtnkcW8U/DEdmzJlpjHRowpvlzDwDx0AjrMxExSjXLMPZzMyoyOzJzGEgHNqou84vV9TGXN2JzNUYzHjWoYQaikCRzKDLycvEdSgwzKrMWcmzZdeGGSGiG/MYufS3wAFPkT/KuDIfiPwjdQYvgD/5yTAY16ckfQpRyIN2qGJbDQrYd7A/TQ5hnRE40RFe2BO4jRDP99oR9cwOtzwPZEvZ1ppt3pwA18crc2bjwBv8Q3BSRsnv56JsTGuJDRfDYdvT1xmAgMBKjXpz+Nu3KLkE5G1CFh1A69ojy11DTQ1ESJGVDtMCCBFw6Rp3FL0k2KoyUN0nNNkjXd0CPM0itaQ05dsIIXw1yx1lLQ1jsdQgYN1x/dgHWddQidUkOdtmmR12JdVHx91i/515AtF0l6lknrmVf9nSno2SGVrZuMUWDmloWrmpHJmKnqmBsnQ+JoVkc3PJtNsXMLd6Ld0+oW2qBtUqRtElLWtU/VVqY5y3X12jEU21FgompsNRcRR798u9yasTmcu9S3jma6zwCAxddo3Ef/lUbL1xFrot1x8dwWEN2ZW2HWrY7Z69PYDZ/azd2t29p0Bd5nLd6Wq8dV0s+QuonRGNcCDeB0LeBwRwIkwNaZTRBhDdFfK9H/ckzDF9kLUbT9bZv/ndiMvdi3qeHrZuAIznYrDaGH6+D+AuERDhFJmjY6oAOGReAZ7uIbDuPrhlhTSngqKl6OJ52wfaRfl+LPsuItjuExLuQzzuGbRuM9auNTAGk5bqg73s0rV5aR2tgHbeSILcpFrlrkDQBTCmdNrlmCczQ8bnQ+bptU7olWXuUyfuSEtuVdTllffllhXjZjHmogAaaF3dELjOXjfN1Brb3rXWHabZ83PtkG4K+Q/7TlK3TneJrnVj1oRN7n7B3I7v3n0gjlEEHoS27oh94CiV7nUX6ccHvYQ87nV269AR7pKYfaSg6MY/fkzX3inyHl/q3mqm7rpo7rqK6Wsq1iDOHqqAbrsj7ezWjbQE3dWI3dgU5mtMZ6xKp/9DzLZs24w57fl8s6yd7exy7My35kzV6SsT5wbVzoqNnd9D2M35YssHpFlhGo7v7uK9LrQLqg8A4agxpq7V7v+h6lAiHvHEbv+w4Z9250lRnwBo8crUwRnnHwjjHwUFbwDB/xpJHwaAXwEh8YDs95C0rsF9/xjdGLFLEmbenxfEHxoeYZHE/yKu8XID8RIj/uK78QJv9PYynKEE1w8zhvBEZQBDxfBEfw80Af9D+PBERf9Dp/9Ei/8z0v9Ex/BEVv9EmP9D3v800f9E9P9FEv9Uvf9OvOF/6Iz3dciRlZgGAfxSKK6feXfX6B8zmv9Dxf9VZ/9Vl/9FMP90B/9Ugw9zpf93bv9HKv93zP9F2/F19f9t7oj/dc9mcf7l+n6Uzw+Ezw9n3P9FNf+ZU/+ZRv+ZqP+UKv+Zsv9HtP9Vt+ER/YwvooAiKA+HSMyzFt+heA+qofi7IuEY4P+ZLP+T/v+ZaP+0Cv+5fP+0fg+4EP9KH/86PPEKVv+rCP+Nrc+sqf+ogv+7MPuDaRTUtw/UvA8z2w/dz/3/3dL/ya7/3iz/3gb/njP/7lX/nnv/1Ef9dPoURZyL+vOP/lF9OUqIfNDNjVVv1OgP3ZXwQA0UPgQIIEixxEmFAhwoINBy6EqNChw4gVi0wUiATJlClJkgAAGVLkyJEPHnBUomTCBAgtXbZcGVPmTJoyX76sOeHDByJEOHokGVToUKJFjR41KkAAR45NmmjUaETqVKoJj1zFmvUqVKhUvRqxqlUs16hfp4YVm5UsErNGNDJlihRkggRwOebEkFcvTb0YRvwFvFPwYME5d9qdIlfxYsaNQyqF65RrW6lo024lSxkswstqM1O2fHlt27d2FdNFjLcvBr56AQcmHNvw5AfEjm3fxo1Y927evX3/Bh5c+PDEADgiPW6c+HLmppXjhh4deXPq1a1f9w0yudHk2L3z1l5c+njyIQcM8Gjy+3r27VEqMQm0aPwk6t17T/9Afnn+uM/nvy9AAYlLiT6j6LNvQOry268/BxVzIEIHtguJwgcvfBCy4iScULyiKNQQw6EQQCA8kiwUMUWROEQRRRVftC1EAFj0kCgQl6rxRRJNHMlFGFMMIIAEO/roRyOhG7LBAx94osknlHwxSCmFPGmKKKKA8kggqYQrSy2/XLLLIpEyycknx/xxyiDtu9JLMIkKCAAh+QQABgAAACwAACYALAGMAIb//////9jY//8+/54+/3cX/54X/3f/2P//2Nj/nj7/nhf/dz7/dxfY2P/Y2NjOtlbntj7nthfOtjBu54Zu52DAtheotlaotjBuzp5uznduwIbnhm7nkBfnhkjYnhfOkFbOkDDAkBfAhm6okFaokDDYdz7YdxdI54ZI52BIzp5IzndIwIZIwGAX2J4X2HcwzkgwtmAmtm4Atm4AtkhIqJ5IqHcAkG4AkEjnYG7nYEjOblbObjC2bibAYG7AYEi2Vs62SCa2bgC2SACQVs6oSDCQSCaQbgCQSAC2MM62MKiQMM6QMKgmJiYmJgBuALZuAJBIALYmACYmAAAAJiYAJgAAACYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI/wABCBxIsGBBAQgFNGhgpaFDgxAjSpxo8IDFAwIdPqTIsaPHjwYRLlyosSHIkyhTqlwJoGGVKiZZHkxIsqRMmRcxtrR5sydLkSNLWvFJtKjRjFZexjy6dGDTox6f7oRKlaJUqVWzar061ChXrR2/gh0rdqxZqGWJNmmCVKjbt3Djyi1JhYpAKVLObrUSIMDcv4ADCx5M+G9dgWuPJt5ZuPHgwwDw6s3asK/jy5gza3YIeXHRmJtDu0U6uSpo0ahTq+6KVebp1ZtJl0bLGrbt24NlF3XgQCNeIUJy5OhAvDjxDciTKxeunLjw58ONF1eO3IcPjUyYzK7KGzuTCeAnnP8YT348eAro06sPz759+fLn1ctvT1/8e/MT5M+vz/4++PE33OAdVd059Ftw0UnXAXXUMZecc9AlKB2D1g24HVQFNpRdf/edEJ9+6PHHoX/5gRiiiP91+CGIKKYIn30BWkiZQ0EEweCNNx73YAcRSmgcg8Rp9NKFezU04nsr6teifSSaeCKKHXpYoolLRjneDDNoZJZGNeLo5Y7N8RihgjqGKWQVRM5oZHhRJrkflCpOyWKLbcqpJJ1WYqklWQ4BV+OPX1IHIXRkLhioUGma5lCdTlJQZZyNPtqkk5IiOQEKKGCp50ZgaeRnEIAGumOPhYqKaKK0NcQopXhOSmWrlkb/CuuLmGqaJadFWnHEEcAJh8OvwP7KoAgiICcsdcT2oOyy1jXrA3S/noqqVw6xwIIGGtBnJXkrdOutteBem617257g7bfhiqttued2m6665Mogrwx7durQrr3mEGywwxa7wbHKJbusss5aBy0O0k5LlEbWYrvutu2u8K7D5ELc7sTjHhllxBivOy+9uKppBXD5lprjdKJuYBypHSSssGslrTdrrHPCueqdNkNac3sf15sryQiaDCTKoq48Zss8vXyTUDLn7OqbIm7r5pNRWzm1o/X1HHKqIwMtxL44EFxwj2RHCLbYzrqstEpCYYpplG7HjcK71srtNtx2z0133ijg/2033SzwfZ+8WMa4NVWeen12DwU/W/bjizeu9tootX13h3wDLjjmeWuet99ye2734DIULuDhGPZmxYFA77CDgikLKqZwJhNXoVvZUf5Rhg6t9arT5F1NNX8370y8zia+8IKthueuVYGsk+w67LGP+lztHdwulPO6c8R7Q74bX1/xOFf9dPnHny+f8syfzn2uNXot//w17lrj/fgHMf/+JL+lW/cReY1DbEXAAhrwgAhMoAIXyMAGMtBnIosf//ZXvyPkL38T3J//pgJAiQiwIQ4MoQhHSMISGhCCXOMABzIohF258IUwfCELgRPDXb0FAQhoje4SIoCG4FAoASrgx//kZQMbBOiISEwiEoU4xCIq8YlJZOLHnAjFKkpRBkUsIgqZ4hAVsrCGYHThDFtYwxvmsCsdHAgPfXhGjQSRgEPEohGrCMUrEnGOdFSiHeWYxydeMYs22CK1GqJCfI2RjGGE4SHJuEEddvCDVogj4WbQxyXCUZKmq+QN9jhJTb7RVpIsHSWTWIMaONInGikkrw6ZyBgu0oaj4WAaDQLJUGaykpwUpSc3eck43rKPufzlDUp5SpnUhJAqXKHXFMDMZjqTAdCMpjSnSU0GOPOaCjCBCeIyS4kcsyQFCKc4x0nOcprznOhMpzrXyU52xjEF8EyBIG/yzWQqE2jYfGY190n/zXw2U5vc7CZEvqmRdhr0oAhNqELJ+c54zlMmL3kJBCAQgQjIz58YVUACNsrRjGZUKEMSKEeEslADGGCh6TQpStGpUoTGEQMwxcBDbxLRKky0ohf1KDY52lGd5hOkaBKpVcCp0JautJxGPeo4k9rOl8Z0pivpS1usEIKqhuCFNeJnNLGp1a5Oc4NCnQlChGLSspr1pCg9q1rXataUsvWtbWXpWpVYSmKijiVSZQxVrYrVIHiVq14NLFjDqsaEkPWtK4WrYtF6zsXC1a1qpWtdocoSjVS0okbIrBF2Fdhp+lQBXh0sYQtCUqWa9rSoLQAVA0SD1tKAsiux7GU1u9kj/3RWmp8NbSxHS0uipva3wDXoam/g2tfetSeyregFP8vMfjIXm6Ll7VQbslTHmpUA2M0uUwtg3etmF7tJ/S54GSvO7pZVvAQoIDxVoALYss0hl43Acpnr3Oc6M7rSLW04zWtS9G6XvwbwL3kFjFT+ole9KWCve0/yTauGQH64zSdPb+vZn+5Wuk7xbXA3zGGGDjGe8jwuSxpsVQhvVcIcpXCEoXthDOuVuh2OcYcbCs8FVw6+l82pffO5Yo/iV6h9sQxnqNDf7A5gAAUG8HePnGQDGxnJ5FwylKu72AJm4MoZsPFJkmvRZe6YxyfW6Y9FGmS/DLnI2GUyOQGMZgKomf/KTk7zlMUp5SbD1cpY1jJINFKBClQ1hn/FqIq/2mLCjoQhGpaxoo/agka3IECABLGeP8JnP18VhoH256ClOWaBHlq/iw71Qh396BtE2qEihllDcOrlz/J0o1++JlBdTBBQrzOup8W1ac0KShk0dYgwrbFDQsrFVXcZn8x9dQJifd+SEJvWtlanrpU67aPyWlPy+vXHgh1ilwS12FZQbv78qWxmX1PZnQ5rtPdb1tRWO7Ht9nA4VyMQyHwGx/Pd6avN7Ux0Fzq/iS5vvHM98F0XPJzZLgC9AWDvhTmkz4BWMbl7quloAvTfvD2TqDdeAMMtvJg3bgjEMS1xFMNa0Bb/3ybGR6txjofa46r5Hyq7eE+S6XPTFb75NC8+OcL+sCRqhSybhQ5gt8I8NTJHLs11DFqc57yZ++R50jD8c40EXa5sJq+d+Wv0030cjT0pUF3+LEYhDBqwg5a6hrRDa95NYQouD7ULXKCRt1vg7hYggd73zncQgACWb3mfT8ROBbIb8uzXxLnarSB43rod7nFX9NzrPgW8553vmPc74HHHdp/gsOpW8KLXnP705vJTm4sHeQc/30aHbBfORcf60GVvVo34/fYgkIDud697v+t985PmCOtTWXPgkL7Hpo866tM9y+EDXetrzjr0Yc912pfV9rjPPe9373sSAD/VS8Px/6dqhPaSZ3SfzBfpuiO/YY1Y/u4jiP8IME8CvwOn5+BmNf7KT2Gdon/lhLV+7Adc7vd+8jd/mQcC9zd1IoNZtcVZ5odi/hdN6SdQAjiApyUvGvEAHPgA72cBB8h337clOJZZL4R4EzeB0FSB3XSBGKhUGugQHeiBBih/IngE+EcUQoZM4xcEsVZf9sWCs+QbUrB11oVe5YSE0adk4lVOm9IQ2xeFUriAqncTOxh6yrR/XwaEzyWEaUSERuhYSjhOYyhwTPhdTngrUCiFbKh7VAh2BOIAa1FRqnR4EZh8KrZ4jTdaj0d95kV01ddYazV3SgQ+TcCGF5CIF0B/MvI8cv/YBHTIATJkdnfYdGmnco0oXX1ohrMniFkHiCZFiElkiIioiIzoEHuoKC8RX0ynU+XGb7NGa9NlBQf1bml1cAqVcFpzGZBRhbGVFFXAiq3mU69obrEoiy64hNN3i6/nUr5WALvoGL0Ih1wjjMiWW9ZkX0AoFJIhiy9mBXBVhux2htkVhouFXQcEAzBwGd3oi+9lbKx2jT4FTTu2jSXRjcj4fGwljtzFZvyYdehoQOrIjnkhS4oCjxEQcZ3Ff5vmhY+kj2t1a441jstYi2+lRzMwkOBnkEmXf5elkIHFkIPmkAB0WGwlkYtFkdR2kVGUkeu4kWmBODgmbvhTjPxmk83/loPqBpHNmFBXt5K2iCUfI2y+qJMOh5AXhJPMppTMRJLdY5K4WFJnRXBBOQND2W3UOBFGyRKE12eGt0ooCHWbpoeddyELwTupGBGb+IKM5mhxZFdpiSpdaWmTGJZ4SGFkmShnqTprBxJryZYoRWpvaUqMV5ZZwRu8UWaIqTp4YU8mxoUK4AEesFH0eE2SuVELsACot5mot1E8wAPZEZqhaRa8YREEwRsCEQVRYJoD8T6LuRA8hBBvN5uQB5gFQGrhhJu36WjhdGRzN3cxEJzCCVOieRMIERGHNhGLqZiI2RCNmUyPWXqROZkJUJnOdJkJkJmcyZmeCZqiOZpjUZo6/yEQqAkAqsmaAuGaiAmbsUmbb2ebucmbu9lo8UmfBeCbvymcw4kBxSkTxzlQI8GVi8mXe1VV0alP+nRy0rSZC2oCDbqZ34cbgpEdfQkAjcdDA+oAdbGhRIZY1veHH8pm8oJExAmeVJFXAoGiEpGhGuFgByqWCbpslsgADJpyD4p6ESqhgEGhhZmehgkAGDqgHFoXjxWi1gWKIioDJMqfJgoVKqqiBBGki4kXDVFVogc0lXl81WR627krqaejcsGjzuM8sZkQGTqkHWqLFBl7njh7oegCCKekR1SicakXUoqYVLpXV0oyWaqlFQZNXXoEXwqmcCGmbEemZSoAZzqkP/9pTtJXkf34if04d3G6pP2pF4eWE4vJeniBFzR5P9iIc5m5UZtZAqZaAkWQqqpKBERgMPoCNjjQLwIzMI1TNr/SOMiRHW/3bMk5EIvJQ7QparoZTnOnm3F0TqRWrKVmqd9ZGpl6EZv6eZ0qBZ9KfvPodKOaAKV6qqq6qq3qOLAaq8hCLCIwMGjTLLaKA7i6Abo6BbwaoL6KmMA6m8Iqn8TqAsY6RMjqaMqqRHTapGaRE3vJG5zaqdXqgzNql9ekTcoHTZmZmUAQsUAgq+VqrufqK7BKseeqHJdKEbzBnrJJry/4my4QIJOHGYY6pj9KFUAhsA0QrTg0rQd7l5XoTAz/W003+7ALILETO66zaq7OgrFgo7GM0ywcC7Ar6gAgKwDBOrK/abJ0h7JMsHYqaxZA4T2IiRhN8Jz5lmz7xm/M1J2fWShlAibV8yW2Y7TsirTKKa9MK7IYSLJHJ7UVWqdnsZhay7XjZl9M+WViywNkayhhcrZomz1q27FYyxsh+55OK4qiYag+ujYZyjt7anxhBmY4p2/baqqpuiuuGq44Qq7+EjDkarGNYx1Hm4pl+qsJ0bTsR7KOK7WQ25orOxmTS6CVS4nWibmbprmod6qoWgSeC64ZeyOiS7S0erqpW7ur67aLW5uRB7sl63WOIZoVGrkKs5hrMYfytbexdnIT/8dTFcdMNfKZOqADsRO4OKIjOuIg1dEsVFu7yPmyDuC6jesCLyGabbh9v4eDnGe3paG92zuzSymj4UtxiZeN5csD55u+ZLu+htK+OaAcaVOYADwQe2m/cfub+Rua+8t7/Rt4bKswDVEXBFxxyMds+3RBLKw/iyQELXxBLKQRQhZy4CiGTaiMLXWOOWxSpPjBHMh7b+iOaVLCVHDCvLu75rbCMYw/LwzDTXw/M+wQNbxlrofDaKjDaMXDWezDVrAWHywBQbx7Q5yV3ZOn+geqMwq2zyVNQBPFLvzEcCw/hkTDZmbD5PhmnGhe6KURYRyFNWKI+DhLaNxlWpjCbIxy0P/0xlH8xD3YwnS8SnZMxFYXZ242Z2vaXX3sEH+8fYH8xVtbkC2Ib0FAWzTbfypMoybgpSZQQSxUI7TVSmU3QbBcWxpREzYMnx1HvTP4gfFHf5u3k8ZWy5l1yre1xKrMyq6cQcT8gK30yqVsyw6By1YMY7YJc71cg8Dsv0S8HQWyFiNnh6h8fk7XgzqnsOeMs5jYoydRIIzLfo32Mc3DBB9If6d4vbP0zU0QzmBZswmMc+YslpmryKe3zhd8mqrzzpEXz/Myz/Vsz3yXiRYofsOIzBatjdmYyDQ7aVcYjpesx5l8hOKFJSZlKwR5GupH0fJ40T+Y0fTl0olMTRxtZg3/4dFHBtKRaskBWdKactK1kdIm3L0LLL5s3Lc7ZtR8+7Us1s0ZZs0G15PmFEqxAQDP9oVWENT485lEDbZI/Vxd7bVbLWsbGUAO4W5RiU5SrRkCUdVPOZMRYIIuNNAo3LsEjc4C3VWT9k3w3AJFFEewRc21ZsZrw2VwDYF2bcwLWdf+jNiExtR6vdB8bQN+vZGAnWFpBHrCeIJ0nc5E7acwnbBOV35SV1llvceB6KiKJYpItGCgx9Slgdk5hki2tdl3DU2d7aciSdt4ONq/6NSPiqRmpdpHxNqt59qTURdIGQSf+ZmJ/NWuptQ3Cd3+FHx6tZIwOC9PKNjeSBDIHW6X/7XAzF3U0l3AYW1uX03dBWVtkKptokTdLOfWLwq2kNnSiLyF0tmUqyPKJyFkRBpgOUyG/23aIh2QJj3W0Abfo3e5yFzf9Xjf9l3fzqnfIMHfHcqP/+iP2VVA7j1L/0l8ucvY43zXYdtTnp3bpKdlzlfTkPrb1leIBj5aHU5zHw7aci3iGkXiuP3Pns0AKP55lQzcE9nio/jijqc6Y8dXZbdPJl6JkFniOu5VF3fQBUF4R2qkQR6nI+o+8rvdAEB4DlaXW/rkoS3mSx7iIL5zKiflCG3EVd6mbAqNDa3lXC4RsM1qmq2wTp7ONX7mMk3kAjFWV5ySzPhWwg1zcx4Rdf/eZXfO5Dmu57pN43jt50DaQ4GuWPAGV4VOvYcOEd4mURDwKcDxveMt6uVN3gjchQwYFgHnVsDF0wW+4VZdUxMF6kJA6qdu6uAb3aX+WVtJWqsuV61uABqe6rLIG9nxPYSa7Dp67A5gt8bOBMiu7DsK7c2+5XxY7dEu7dqeGszu7NhOoNv+F91u7YT17Nke7ugutc+Otcye7tO+7lxu7uDu7vTeGOPO7tRe72FK7Wo+hGCn7wBfGB3J6bUR8I2k3QAX2Aa/8HIx8L01iwz/05ve1CXhBBZ/8T+Q8Rqf8UjQ8R7/8SDv8Rs/8iMf8iYP8iSf8j9w8iyPBCpP8iHf64H/XVNj3MlROIM4/wA2v3uffCYTT/EacfEYn/Itf/IvX/JFH/JHv/FJr/RLz/EgL/MZRvM6v/Pbl/MzaPUS0PPD9m0/H6/eBgViDwVKUPZmf/Zoj/YdX/Ytn/Zu//ZK0PZwP/dsz/JzvwRLgM9+mdCVd3kQjXsf8AFY34EP/ffZp3n+2+/FrjovMfZkT/dvv/Zxb/eQD/dyX/luf/luj/d6vzt8f3cQrXeAL/iDT4OWF/r1d/h/l/jkPuff5PhNjwRnPwRDIPmR3/SYf/axn/tmn/Rlj94ySPjabM+Hr3uD78sISH9v+PXehGgNAfu4b/a0b/uZH/28v/u8P/lyD/wN/5HNlvfLxJ99xo/1yA/Ry8/8ENEX0CMFT/AEHQ/zTZ8E8j//9P/+SJ/09J//SWD/TB//+j//AIEEyQ+CBQUKXLLEykIrTJgAgBhR4kQADhwslCKlSRMJHT1+BBlS5EiSIEmQwCjFIUWWLV2+hBlT5kyIAQJYTPnkicCCBg/+BIokyVCiRXn2/BFUqdCiTY/2XBq0qdOBSH8mZNjwIU2cVjJuLBlW7NiPJ1OupJlW7Vq2L7O+hRtX7ly6de3exZtXLsSFM6tU4atX8OC9AP62RZxYMUXCjR0/hiw4sF/AACJfrgvx8GLOndP2tYxZ9GjScSfLBF269GnPrV0zthJY9W9s2o1Zw0xd+/Lt170RN2hgES1E4Vt9H0cesThE4MthOifuYHhyis2lbz1wADp17jGtT9/eXbxi59+Nu9weXrx5iNnVj4fPEgECuPHtK7ZZn+Z8/fdhZ/UvwIj4e0tAA2XKr8D96FPwwNAAdFCtgAAAIfkEAAYAAAAsAAAmACwBjACG///////Y2P//Pv+ePv93F/+eF/93/9j//9jY/54+/54X/3cX2Nj/2NjYbueGbudgbs6ebs53bsCGSOeGSOdgSM6eSM53SMCGSMBg57YXzrZWzrYw55AXzpBWzpAw54Zu54ZI2HcXwLYXqLZWwJAXqJAwwIZubqieSKieSKh3F9ieMM5IF9h3JrZuALZuALZIMJBgJpBuAJBuAJBI52BuwGButlbO52BIzm5WwGBIzm4wtm4mtm4AtkgmtkgAkG4mkG4AkEgAtjDOtjCokDDOkDCobiaQJiYmJiYAbgC2bgCQJgAmJgAAACYmACYAAAAmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACP8AAQgcSLCgwYJQEio8yLChw4cHFS6ESLGixYsRJULByLGjx48YNW4E+VAkyZMINaJcydIky5cwW6pk2aDBkSMEa96MeVEnzoE+eQptGBSozZ9DkyoVWJTp0ZdNAURdajDqVKoxrT7FyhXqVqc7WTJgUPPJk5oi06pdy7Zt2ptjw3Z9ObbmkiVo3erdy7ev379uzV71WLeB4AaAEwOGy0Du3JWF7+ZVTLmy5ctQDjtemVAg5s9pPY98HLMzANCoU6s2bfol69WfRZPm+Rq27dt9ZaM8wPvAZChMmPTokSPHhw8mkpuowbx58ec5btygQb069ePYkStv7vy5xM2zSfb/9o1YYZMmE9KrX3+hvfv37SVIWE+/vnr4+C/It8//fv73+/XH33szzPAdUrv19ltwwxV3nHLLcVcDdMVJZ5112T24nYTQHRgeS+P9dp6A/wE4n4D2lehegCjSp2J8J7bInnsFeqiUREEEId2OPPZo4YXMURidj0TySJ1LHwolEQZMNskkBVBGCSV/UkrppJNVRklllhRc2SSXFGyZpZdPVvnCCxJhhaOORRJ5IQ1BUthmm0fOlCRtCpGJAZhiVqknn/aB+SeXfVpJZpZnpnmjQjn64MOPb2aonYQTyrnjm9dliOSdMElEInxeyufAqKS2iF+oEpBaKoqnXimqqg6Y/3qBDDLUONFSazoK6YWSJkepkEZiKummnMqU0KfvoQprrKyC6mqqsMqa7LPLykqrra3BNBZvhSUUnKPD9aqcpBr6yqGlmFZXnI3FejQeb3mNKOOL7snoIr0X2DsjvfpO4IILtoJ30rYHdAscE+D2IG5y5GpnLnfATpcuDesqJHC7Fb1LXkLySvtiv+nhmy/IIvf7b8AIJiWRo46CAEKRLscs88w0ywzzzMRi/JFID/Ts8889Zwn0A2AWTcHQSBNtNJdJD7000w+cmeitiybEsg8u31zz1jVrHXPOOnfEc9NBV+n002aT7TPaaautNNtQ9iw1mlQL9VuOjT56aXUQW/86p4/W9c1u2B39llCWAo6p555VJu7n4oj3p/igUq7377UGQnGxV2vmHSx1fUP3t5t8dzc44RgZDkXkhXYJeeOSP065lrEbOvuU6l1ea+ab01QeEkjwwMMOxO+AAw5Z77h1w8x/kLx0MlcsUu+o51SeRMD/vGy19o1K9vbR0sd9fd43Db6qjq+wwtwoL5UX8MIXbzzyLytfc/MNP39D9DmoRX31ThFJ9nx2vlWRzwHfKyCz1jM+8SHQfApM3/qk1r6qQUF4ORKeBjfIg6t58IMs46AINfhBtegGgAypjULmxsIWuvCFMIyhDGdIwxrSUFG4UggGgzBCEoLwh47qoQj/Sxia04wGhQZRYUJsyMQmOvGJUHQhDoeCAARIhAMc+CHetsjFLgLRg13solqqmC0kCiQAAVAiFArExja6sUD/auG/5jjHudGRjm/MoxvleMeT6fGPfOxjG6cYEzIqBItaDKMi8/ZFRy0Sb2O04hHNCAA0qvGPeYwjC/uoyTNxEmCYzGMg7xhKUW6Sk4OsG0zehwRE+kCIsOxgI2PJwRxN7wiDQaFPRNSET3ZShr70ZQ2DSUxh0rCYKEDB/0DCSlfSsoeNfOUzd3jLXAJwl9eDwnmCOcxi3rGb3gynC8Dpy2Qu8yO8kUgG1pmBHAHhnUBQgAIWQM962vOe+FyAPPfJ/8955jMEIWALJRmSzrQU4KAITahCF8rQhjr0oRCNqEQlqjtaJTOZhATRAdTJTnfCU575DGk++9nPkAJUoAM1SEFFMtGWuvSlMI2pQisqg4uiIKOuUcg6RSCCvAmPpCAVqVCBWtJ6mjClJdGITJfK1KbC9I0niOoJcGosKOy0p0EIIg+IKtShEnWf9jwqUhvCUqea9axoLQBUpUrVk7CSpyQggfCu1tW66rOoQj2pRs6JRF4a4K+ADaxgB2uAhxL2sIQ1LGIX+1fFBpYFLHhjCiabgoTwNXW/QwJc5SpLR9m1qyStq15PN1ajSOQ8jGWsY1ObWIeyFrGr/StkJUtZy/+mrFMK2WwXvcrPz9ZVnmItbRI18trARrS4gj0ucgGr3MO+0QLQtUBbUSIR3XKRt2D1rVeDK1yCiGS5hYUoeBsr3vE2l7DPje50QVJdEcR1t6D9alC1S0/udlc0Ekmrfvf70j5W4L8VWC9J2vve68ZXvvQ1ahHv612l8vfBEGaofwEsYJCM5YpYzKIHEZzgesp3tHZiMH4VEuES85e8E/5vhTty4UNm+IMc7vBdiQriFVOyrCbOsVlRfEcAB1iVOU0IOzMgQvkauZ8JSLKSj2zf++JYoYM9a5R3nFyzthACWIaAjcWmU3YW+chgVvKSjdzk7j45oVN2apqbumamXjn/y1vuSXmc4ATr5u23X5VxjTV3W+HyUseAbqoKVDDbGdAqBjH472Rta7c519m9JNiiZw8MVD0HdK99Lu2fA81pmA660IdOdAUWzWeVdVmESZavmFMN5iMnuczCPTNDjYtWWkuZuQX4qx1dMNFfRuDXEQAbdU/NQVYTddUJaLWrEwDr0sp6obamMnlvTV5dS+1fvR6n1IAd7BCfxJIu1upPld3be5Kbn80eq0SCA+0qp5YA8I73QuMtb9cWl97wXuiZ/roacL8E3AlxpgbPnV17Ehy4CxaxEb3FhHbT+t34nnfE7f1afBNA3y/gt2r8vcrMrvPLBy+4h8G858teM5vA/6O3w5dL7wEMYOXItTjMAYst1NzEmoXzOJE5GPJyG5zklyatn1GOBJVDebwtf/nRwSvzpQu25qC5+Veq6kq6zrjn+ExyXdON1Gd3GsK0ss0Jqa5hq/dc5PTUele5nlKvf52/YYfN2C08FgZg2JFZ9QFXZXz10C4AoHsuY2kJ5va3o3XQgxaJBxbvAQ04/vGQH8EIbNkWutT97j7I295lzGHAB93bg2fASkls+AgjXgWKZzzkV68ByVMepV4JDvAEPu759l3Z9Gx1yTM91k2P1wBJn3nF4+1y4SMWsnQG3gaWz/zmO38Di3+9xXiPkprIvpUa3qDPb9/q3AP9lgqXSv82z3PQ3wff6TEnvtLRXFzkO0H5z4//8qMfBPBb8OM8Byqyz85PZLN9oF43bbUWXmklgAslEc3HepDXfI4ibKVBbNqnf6vGf/vkfwknYgFIgAO4XwaoUAjIfAr4eAzoAw6IEnVnd+G2YZXGd50HeP93YwphFqX3YKdXc4yneiHYepNXf6BneS0WcGXHMpvXYS0YeJPEYBIhgzO4XzWYOQlxg4uXgzoofYKnJCl4NX5nT8bmT3w3ci9oRt9VZbFVXOeFXBFlg1B4g/LXgEA2FJiHhXhVT1vYhT/3hUgUhtHWUL9XhmQIUWiYhou3hiTYhg84ZCCnAPtHgYg4gftkhyj/lIRPwH4dyFR5CGEt9IHyl4CPV4KF6GX5J0+JSIGhqACOCECQKIkaqGa4ZmKXqBCZ6HyQx4m4JWSemEFblWfmpohhdYFISFypmGssh28dyHTC+IuBtW8GMDeYMXd4Qov4Z4sxNnIUuIuy2Ha+aHyLZXHDGIz0to3WZm1TYxnMyDkKEVcFdme5uH2gOGaWZn/3JQAC8Bt09lpjaIYUt1y7RiswAAOUIXUmh1kSYY6RhjeT9nPquIis1o6YJmLwKI9OQI/3CF71yFr5KAP72I+4NHUvYUjO2E4Gpl1ZKI1oV09GGH4AR3rl93u/iIoSGZE0l0cXSYgDAY/ZYkhJwZFW/9VRH+lbIel922dPJalwJ5kQLLlcEwmReoheMMmPMikQNHlENmlBGRaEjtKTLBiH1NiDZuZgLrWH5dWSC6VJBQJdW1aNwwaEVSeEWHmVP6lgZgmD+fVSXnmUqiVh2jaW0tWUKRFnH8FKhjg8xbOFZzeKJLV7xfIbl7Vpt8aBK+lQfTRZZvGPXeGXnig/gtlzhNlPhskpiEl9VTF+TVCAjUmJo2mXdASZTyCZXEGZ+BeBJJWZIcdqVFhqSaIV56SYTieak4hWdNQCLUBqqokVrLlzrolkjCiKyaYAsxmcvuMYOGc9pxWas7aK0laaTtWbv1lZtBk2w4lqx8l/o0hPs/+JG4nhj55pWuYhnaulm9Ypl8koNb4JnOf5Id1ZbN85mN8pnjxInpVhnhWBm0m5mzJViaQ5N/GpnczZFRzFU5KmdyvIebgIUDlihPzZFy12Eae4hIenArRCK/+iYnp5JwuKVZr3oEQYoSEwoZ9XoYBxoRaRoRpqVoPWoTLwoT9WhVxhFmaBf3BIbrB5bvFTPMdzHFwDAs3jMvnTNfsTM8OilRARl6XXgX30UIOWUJ40R9Clo0+Ao8WipTyqlj56nwcXpMQzpM7DNUdqpOSyNdDDpJripElFlDMopXdEpSpgpS9AR1mqo1w6F/AIjwxhFglxjkFAPJ81hDKGbD/wAzn/8ivPsSuRgh0QQilxUiF7Yx1T9KeaKgAnCKgDAaVfd3pNmHh8Iah6MY5UoamBuqVQQKiGaleI2mGKyqhB4KiWOjE0kB2TSqmic6nVkambCo+dKgANJqdvJ6qIVyCkuhem6haomhS8IRAEIxDRip7As07vtKivmmDRmGCOQjzlEiGh86gSE6m6uiHj2iHb2RCaOhYNWR7kF6MIBXWf4Z9KMa0AgK/VGkBQcK0ZkK0/sK301a309a07EK62Sq7psjDi2h1CwmgP0a4M8K4co57ySq+YYa9JMRZohEYOUUXX15oDp4gku0E2MzpLWqQ006ZzUhx0dlkdGwB5MY/AV4xF/zl83aiBzuWElREcwREWz8kSMeuxDQGyTOCvh0iyZ2eyMYOyKauyJ6s/PuKyTgCzHTuzD1mzOXuzrKWNOquUmOGzTAC0GjkURPufmZWWtWdkP0pwYiZPG6QDOiAz+IM/UFukFROZ81kQNUFn8dpph3VQkHUgjrd8ITh/HjCe04c6zRSEa6tqYhqbYxa3c+umdZukd1szeZuae2s9fmuxgRa4BTC401e4G3C40Je4+/kWnasUwaqpb+gDxBNUB+l9dDhSCoB3j+RFLMNIYLS7vLtFiiJ4wSoQVYSTbYZ+RumSGveEUCh/i1cCJTCbYfO6fxq7s+tPtXtXt4tP8qS7wP9LkL2bdx8UvlwEvsN7hMULAMcrSQmRvFyLlNM5WBKRhtDrAdJLvQBYjgOZIwIbUgTLrftkvr5bvkHwTgQsvj+UvhAhsaAqrwUgEdI7wRMMiIynv3DZqv1bqDuAZ7EqwPKUwF/kUQlcwB7EwBH7pz8IBRCcUBJMwRVswar7lkoRswbxlIO6wTkCwEVVbm2JTwAlVJPmuyWcd0RMvplHwCjMENYrEfKLjX2YUHGXENIrw8+7AWzYp7NhwwWBwxoMX97bw9n1w/cUxCI1xEhcxHh3NUdsvkt8EE2sEE+svGCJUFMMBVVsxYy3fFl8hCeXELPnuLe4bG+riIU8V9IkuYX/HHJ6pbccES+gC2iDxT6ZAzyma7gi6HzSmxCOPFCNezWP+1Vte26HLEuh3GqjfGSNzLmPDK+RrGOTTEGVjASXfLqZ3HybnBmsbEbBinlbZJUQSsYgPMa4eLt82b5OLIbza14OhYypZBlPCUC9nIK/vJbBPJLXTLvFTIfHfLzJTKAIpZKl6cxshBnRbEbAExzrJG6DLHJKy4Xch3UiSW4++VV8WawsDIzECG/FR8eE9ULLCAB0llLpzATrLE2hbJC6OM/8p9D0HM/oFqJkRXrmp35QfIxSdBkCMdA6074xS5mEWpXw3IXAfKLCPLBr6XkQ28oVK84TCVkwDdMFQskr/120CFAUaBS0XeHRV6tzIe2g3Xt7QV3Sw2x79KTS6ypnLa2SLx3TMj0DNJ3UB1FFOC2zZYs6HHXQPcq2kXtwqaxsX81kEp1CKLlU8EtRdUQ3WpwR9xweWZ0BMBZmXe22c03Kdd1qbT1iqgjOEUVH4ejHcTrWSeLFAtmgPPzBPLnNRW3NiY1wa+0QD2x4dHTH4dfAAhCQ5mjYuIvYh6rYKM3ZsNqIgj1cxjqDky0Ded2LHblB2Yuciwyedw3WsZ3anByJ4Uyde12afq3WgF3Ze5mTItvasP3a+EncmDnbo50SSpiSAhpTfF0Au53a6sa/hLrDm43NJo3diz3U/tTWXv88x/HLWgl12tLdddStw0Fw2Nr92esNkowtwPWV3E552XIs3swbxdA9R5Tt24E9ZKDczpBr3Io8ZsgZ4ARuz/L9qWU9oO3Z12ld3tbYkf+NyrFN4QLu1cl5bMj92BNd2gx+nQ+e4CnVt++HBP6N0AAOz+/s0A3N0GcHlJemmlibjRbtzxCXs1GdoJ7cAMln4uzEziG54i4uz/U8jSQZ460LnVBAs4d1fuFN4zguyzXN33xLdGp7iyy+bAQXxkae5QcHYomZTUzOWE335IgFb+D4AjWn43+sEIE84Spu11ueji3u5QQH5q3rkDhbb2be5ASQ5mue5GYUs2rEooZeoc//mhI4eeh/cc4m2bGFzuiSvhqJ3mCLPul74egMRrTYhOmerhoaO9U33QDBoTqfrhalftWlxelHYeqn/up/EeoGQdWkzgSuDusKkepsTjjZguu+7hdmUekDwdG/jlIcPt34XOzKnhbBbkQVQezL7hLHbt4ioQTWrgRGYAQ2sO02IATe/u3gDu5DMO7kXu7ezu3cHu7q/u3l3u5DcO7o3u3rru7ubu5CEO/yDu5EsO9EQMMjlhCvGPACP/DPJzwMFxzTHmtpce3Yru3pPu/hXu/kDu/oDvERL/Hvfu/xbvHijvEU//D6zu/+vnCuSPAmf/IFzwMHzwQJX9kMlwQwnwQW/4/xGY/vHM/uHq/xFX/zQkDzH7/tPN/z5E7bJY/yRm/yfUzlGHowMS/zEO/zOg/yHA/1Ns/zVL/xVj/0Ik7yR9/1A5/0Sl8REtH0+F72WB/0Zm/2Qf/zaQ/0a9/22070AA+Cq+f1sFj3mQj2Yf+kCkH2cF/1aP/3Un/zgj/4HP/3cg8FmriAdk/3jC+IEG5GJ2gwdwHz3s7vmJ/5mo/5Fr/5nr/5nf/5or/voe/5RVAEQkcUoCl5rCd5rj8CMAzDN9gBHSCFry95sZ/6YT/5ZFEele/0oz/6pR/8oA/xxP/5w6/5p6/7B8FLrL96tw/7sR/Di0f7tn/7ub+4ey/20ave/W98w9c7Et4v7GHv/eYv/r0NALCL/tFO/kof6ef/6e4P/7Du/lRO//E/6fPP/stu//xtGgAhQKAAKFAAHESYUOFChg0dPoQYUSLEgQQNKiw4MSOAihsnfpSIQCQCjwhLgkSZUmXKjR0vroQZU+ZElwtPOmw58ObMiSNJvjQJlOdQohELHhVaVOlSlkiTGnXKFCZSJkykXmXq9ClWrli1NkXaFSRVq2KXBgQAIfkEAAYAAAAsAAAmACwBjACG///////Y2P//2P/YPv+ePv93F/+eF/93/9j//9jY/54+/54X/3c+/3cX2Nj/2NjYzrZW57Y+57YXzrYwbueGbudgwLYXqLZWqLYwbs6ebs5354Zu54ZI55AX2J4XzpBWzpAwwJAXwIZuqJBWqJAw2Hc+2HcXSOeGSOdgSM6eSM53SMBgMM5uF9ieF9h3MLaGJrZuALZuALZISKieSKh3MJBgJpBIAJBuAJBI52Bu52BIzm5Wtm4mwGBuwGBItlbOzkgwtkgmtm4AtkgAkG4mkG4AqEhWkEgmkEgAtjDOtjCokDDOkDCoJiYmJiYAbgC2SAC2JgAAACYmACYAAAAmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACP8AAQgcSLCgQQAJEjx4UKVhlSZNDkqcSLFiwYUOH0a0yLGjx48DE2J0CBGkyZMoU3IUIGBkw5IqD4pkSHJjzJsAXGrEyTPmzIwwewodqpKlzqA4FyJVapMoR6YEoTqdKlGqQKtUs2rN+WBp16Y3sWLdalDsV7JazSJFyzbp2YFj3ULUmbGu3bt48+qtO/dtW54OAjtYSIUK3b2IEytezLjx4r5rYzI97Ljy4yZx/6YUPPhBYcqWQ4seTVpj5pQNBZZenVd1Fc1TUwNgTbu2bbuuicq+XTs3bN2vZ/MeTtyy79h1kSDxwby5jufQo0uHnqN6jh7YezR3Pl067t9U7aL/GE9+hfnz6MmTP8G+vXv149HLXwEfhfv7J+rPTw8f/3v4+62AAw7fIZeRctsx192C1FmXnXYJMghdgeABl5F+AdLXn3/sYRhgfRx2CGCGIIbooXwDUmhgFUIIER0HMMYI4wY01mjjjTXC+KKMMdIoo4oVDpVRBUQWSSQFSCapJJIcImnkkxUsKSUFTVIApZFTLlnllUU6WaQMMmSEVkYt7sgjBzimeaOO0J054wY/1hVkeA5xmaWSW3IZ5Z1M+uelnXxS6aeVev5ZAZhiUrXQFFM44USLLboZo4TPSWrppNAxBxRYc7rVEKP16alnfaSiICqXpYZ6KpTjuccqqWCm/7hTWg8w6iikQlxKqQ6X6pqpD5t2OtRIoMK36qupknfsk8mqt6yRrbaHLHyxEjjrmA4NMUSkbk7XK48+fsvBc0AKe9OFzT5bQbPGPsuus+6+O161n06BbUPacnumt+K+2S+5cporFLrJqivveAYfnLC89FbB6FYBBHCgckhgtx2bu0Zn3XXZJejDguUKDBJLdn24IYfRojyiyeqFmN/K+5WosnrmDSirbFlFPLFyFjeHccbPbfygxyAHLHJKJNfF8nom2tc0zSSe7N+J88k89Yg2W4uzojQ1RDHFCgLdYHVDR8igpjUdrdJh/LX8dHlRu+2eeSJCvXTKLr8d33lZy/8aGVE6fY3gx2IH7WDHZi+I9kucqu0R2+dZjR/V8kl+At0v2x2z1HlfrXnf1v7tFJm4CrHDDmqmnuO4bbqJY5x4Of4RXngOKmqgguJnKJS45wkon+6xwEIMxMeAqEP3slj66aqr/rOkr8eol+we0Z6k71f2bnuhgWLPe/ftCV+88WEir1VG2qaffunsQ6r++/Cv3z6usQtHPUW71QXm/vz37///AAygAAdIwAIakHj+S9RW0Be/+bEvfhCUnwOFUL+t3a8g+cuIATfIwQ568IP9Q2D/FOiUiOnMIRKQwAQjyMJtTVAI8FOOtvBywgtKxFGu0SAId8jDHvqwfBbsiQn/JYZCFTqwhRF8IQzfJ8Mh0JCINjwIDoWjwx9a8YpY5B8JgVOYCESAhUpcYRIdaJfCCMSMUcRgcOwCpvG58Y3kOyAc58jBOdJxg3Z0YwYyEEQuUsGLYAzj/AI5vzJS4YyHTCNBMuiQNubRjXV85PgiKUkRylGSe+zjUAKTkRB4MgTwa4AoG7CAUprylKNMpSpXmcpTnnJ6iiwIAhCAFwPY8pa4zKUud8nLXvryl8AMZjDfmIJipmCLPeGkQz4Jyve10pWoZKU0VwnNUsIylgOZZS2Fyc1uevOb4MQlMY2JTJ4QawoWsEAHOqCtJj5zmqRcADxLOc8FmMAEdhEdNnUi/wUphPOfAA3oN8dJAxowbirnTOc624kEbb1zmvSEqDwles98Ng6bXMlIPwXK0Y561JYENei1hkUTR6UwhewrpQJWytJquvSlKmXpSktZUb5cdJ9dq8JGb3mAnh7goz796Ud/GdRwjg8GMNhjQQ/qlJGY9KQpXYBMZwrTqp5yqgqgKT5titGD8NOfPPUpUMU6VF8WFZxHTWoGljpSoSQkIyeVAEOV81B42nWU0ExlTUOGzbfWhZdBDaxgB2vWwRpWsIU9rGKFykvQFZStmryJXxsS17kioa53tWteR7lXo3U1JAmwC2AXq9jEkpawvTztYX3p2MeWMyVDdKoT4hpVUf9adbO3dWVnmdrViF2lVoxqlBMIQFwC6FK1gi1AAYpr3FwiN7DKZe5xn+vT6BJAuUH1nwpUwFZ9niS2JZ0tVEsX0dxG07ym3G1bY+lbrgRXuNJ1LnV7al3iTne+9W0uLudL3+VetwDZ7d92u3tTpAlAmQ1hZijx6kqswjSzqqzfZwHAGdGW9cIY9uU4i1mYyBoYwVVQsDMZfNWpPhjCo5TwZyv81wy7+MUG2HAKOhwcoZyQUbQl70TRG9Fn5lbFE85hFRylXOXel7pFLvKRn5tkI8sXv022ZU+1u10VvPYmN55CjnFVXh5T07xADnJGiKzkJyM5ymZmMpr3y98mF0D/ygeg8nav7KkhO4GZX3OoZl2J4mmq17tRNEpOGVXa1PK3p6adb6KRyz/iFZPACA0vnimm53pGs8+r/HOBA92SQU+h0KM99KKfO+rTNjoGjxYpoGMCV7m6sEUltiqmSezKME/YwjDOdS+zdoMbCJN4ve71DIY9A76yuoj5glSsqzpr21bT1p/Fta6njUte+3qYMQj2DYhdbM/yJGkNWWcT9bzZZquy3A1Qr4cVOVmHsBnOov7noRG9S+L1lDdJEwq4qyDuhqbP2Zc2N617nO6tGpvdoW0xnOHNX4DOm7G5tPcB8C2AdZ+kIU+NakwJzmNmR9gh7w2yGjOi2iTbN83I/zW5fsMKZeUejzZRiEL+gJNxHW98ogDveDVXmZGQi3wgdil5kU/O5pb7d8kpL/LLWRPzmfckI/1Wn49NKfBz8znFd/k50OsCakMrmqgNr3cMiHOcpzsk6v8eOM6rHs+AQ7urQV8t2L9eatLyknhkt9/olhkCjZtSpjqvpoNN+XaMZqQwRYe4QM/aUcb30i4QiLzkIz+Bylu+8jPcy4o86feYUjXwJQY84bOudSpWAfEsV3xAHb94svoS8pOX/OUvn/lr4mSW2jw7O18tBPRW3aWFx6a0qQ3jFhi/BRkBAQhiH/sLOP/5ygl+SnBPS90nG9bm/f2zSa/14RPfxcdHvv9DlM/8yT8f+kiQPkpku1DeW3XwoE+vwdP2868Ck/Uvxn83XeACjDth9gAYgNFHf1nBfrvHZVUFf/FnT/PHW0Fmf3Onei6mf9zEf/4XgBhoeQPogAuEbO+zgFRndValfmlkF0lGb7bkZiiYekJ3gqpndNgVZ0BUBRmYgS1ycGZHWa6mPiBIcDkHUyQYRSZYZCuogi94Zi6IdKRlhEtXgxh4g97WVDnlSXk2BF8WcNp3SpqmdTpBaKdVd1/odWFnS7LCKCRwhmiofGq4hmo4gKtmTlMYAlV4hSHIdm0nfxbFhZ6mWmBod2JIdwZQhlOAhmnIhobohpsmJFWwZcoWgqL/B4IKGIQ2dHhUkHhjtYKth4kGkEAOUXmTh4GTh4MDs4jjhYAR9YgLGInc93OUaIkeRYHhhH+c2BCeKHsBGIpRuCIp5EWdJ1Ut1YOqKIoleHqFUYlhVVaa2HoMRzy2pEWlUXa6KAG8aHN/94uQaGKjJ4xCSIyot3BDlYyrJ1RBxYybuD+rAY17p4MoVToKGH/tmI25GG1c53ocBYvgRIGOND4v8AKkIRAPcz5FtI648o6BR5ALIIkXFHfgGIv0mIkSWI5vtI/9CAD/GGkNEXMp1H4IiIroNmvQtIX1l1M79X1lZXy9Bjo1UAMc6FV+wRVvmBIjgZESoJGNyJFXZ24f/9mA69VVEEiSQ2WSN4CSKrmTF9GSpzGK6mhEpnhbBolelIhG3adwwbSQ8vaQ4eQ/GqABdGYQ2nhsSdmLMNWUYOYQxZhIUZkR3USVDPlRWKmV5tMRXYkSJ6SDVCg4ENaRAoeQVLFvFseV8xhvoTaGu0Ra/Jc1YDJnb6k2c0mKdfk1d3mTbKeXU8GXNVY9fymYSohcfXgAhWkzh2lliXk0ssWI2HdzYoleVLWBBAgeapGIv6VRYPVN9iibDelNaQVpsjOapdiIpomN11hKqrmSmtGaHdGT3jSbx1mb3XSbquaaQdJqKQQ/56VzdOhSUFgcrIGO+HOZydVkmgiDAHaEav/mcv1TTFvZKdC5g+kznR1XndV0ndj5jHoHl9wJXd4pnkmXhCi3hEpXnscUmiLTbnElOJeFaXgJYXoWn6WRbxyxmA2ReICYmXz4hz7VmVkDWZV5NAJ6UgTqkZDZZwmqoKPBoBbhoFUAodS1mV2XmRZqMxhKPe3WflLHdgdqV+M2BEAABNMhNIizHYVjOGTTo80RlwCwbxG6n5oZccUDJqrFf/5jnvE4JzG6ezOahXWIYjeaozt6OD3joz/Ko106pFE6EUaaohRKakoqQk3qAk/6n+e5NgsRpwkxpwkQczG3TrVFozvHWffUp/ckSgwQqAwQBIQaBNVhIyKQqCLwIGX/EzYbYzg4whzYoToQERmBEacPwBKauqkC0E8j+WLhZ3z8N6qk6gIDYoGNQWOVuqqVKhAvCRidgakLQacJYadRgKc6ZocupVd+2qeAKqiFaqg5gKiKyqhCCqQ5AKk3Iqk9QKmtWhCXGqecyqmeGpugGqqlWqqn2n+pSgWMw6rP+qo4Ea1REacCMUQxV3NLCU2nqXOihytv4jxokjrfYiPbgSOrahGYOq3V6pM9la2dSRoQ8a3h6pyRthDnakLpKl5gWY02eY1UBa/zKq/yein22hz4+qwUsa/U6qn+ypkAezOhMbAaka8AIK5oIas0EXOetGBfZocvy6d++jU/qgPV//EczEo0GXOvG2CyEkGnEYOpAzAAjPKpaTlvupStIisaq7o1KMs1mHqRUdCyIxazMMtgvDqzFFOzN6sDOZs4lMKzPisTcxq0cTq0RWutRwuYt6S0WjMaTVuZT3uwDzC0ndRMVcpKsiZwK+UBHnBPJVACREAER3AERmAEYeqoG2MdOKKoi8qoOlsdHgOuxSmtneqxPplL2dpPGUGIZ2iIhBicJauxnSK0A3C3Lqu3Hmduffu3JhC4g1u4h5u4hLO4jHsjjmuskZsDk8uqlbsQLNGvmYtLmysFneu5oIuGoku5sNFe5boQEeMo6sqbPXhi7LkAD4REYzRI2vs1PMADTP+1aqb7Xoqlcmd1aEZIqsolvf/nhMoXukjAvHPivHARp9ErvQJJvdW7q3eYc9mrvQ10RN1LMd8bvok4vsFVvkNHAOfbZvepvgXAvk44Ae+rvPHruzYUGLOEqbZKk9/bmzj5UlnbqyykHEVQBASawoJTwkhwwir8NSTrqs6JqcI7vMQ7qtXqfMx3fs4HvwTrOBqMABxspx7MAyDcbCcmSr3apyzswi+swk2Mwk98wbLxkjSMuTbctjjsqTrcfDzsw6N7QWYrtbi6rvvrew2gZ+ojRgAMP2LUIl/DOEfJkg2xU+jrX06GoqplAzawsBN8eWeIiFE0xlVwpx3QsGe8t2r/LEHt08YBzL1wTDFy3JL6ShN27MDElccsiFx87Md/XHmBnH5EKSwswWIJhrdp94MfaqAvtcQdKlH8G8LQRGN9eRBomcUGoG0iu4Yf8AHlJ3nOR8sZqjalLBioW7V3WKOP6VKubJewvKey7ErCjBK3nMW6/La87Mu/DAHB7K0AekG62YvtmlvjzJS+mYosVVNzyxWFYbQZ9p0HIHENw7SYQcm5GV75W5oOa43o/LDues7umM5btc6EQQXujGHwLM8ysLSVARkGGyThDCnf688dV87vB9Cg947q/NDlWsdqS5JvxNCO4dBRFNEtMtH8HNAUzWMWnYAYvdHrZ8kf/X0h//22lkHS97Nvk+ZOqntzPg3NSCzCApfEquSnovSmA8EZ+5bFb9RrSI2OtVwhOv1Jc9jTvrhssRzUWe2hWy2zJnDU3zwRSl1x7mbDTX0DTz2fW7eNSak+dDXUqxzNPgjXWEhrqZTWfvmgSOqHm2mYM2gSRFoh6enWBSrXa2elc23Y0uR2YU2feq3HYdjXnvnXIBHY4HG3VJu3XabMe0bUfQaCfYbXI3eiuHzNon1rfJfZqRxPqpzYmbW3XA16od3YHFHNNmzatF16GWVnKdSY/vbZca3VV4rYh2110gTTJzES/fRwKlqhbLo/fsPRn6Wbvl1prx3cse3a2V3cmMWrwv/5FDLN3Gd6WE4K3aEj3ajdEOmUTq+8zEC93XUN3F19V6dNYQ5g28OL21HNig6x3hbQ3tc93yjm2aws4PBU3yCGy7kcbCKr2xaB2XJIaVZo1eyaVatb4EIN39iNdfud16TN1MXj1Lnt4BBe1e6J1RmO4Qbe2SkuTfUtZAo+PiLe4WIWkEqpv++dzLItggt44jr34qbXgkQIcUYooTLojDSe3qSYz7134a1NnTwefz7ecUBOcqdV5LeE5ZA9ZSM04mfJdwDunlfL2fI93Do+a11JmRMamIAo42g9pl9+ymEe5dwt3Nqt4sVN5qyU5mRt5Xw9mEh7S25u2eD8FaAhooj/Hp84vbGGnlOJ3hiLXnqT4eiPXunEEelV0eiWPtL1vM4JuUabHup5V8uMJOqJoZ38LWSmvurySeqgzuqIgeoitzWwXuuhIetqpOq2/h1JPomVuevAvhi4vkivHuwB0+uFbkhQAAVP0OxPkATQHu3S/gPUXu3Wbu3Snu3aHu3X3u3Vvu3gzu3e3u3hXu5JwARMECyPk1OOAorb/Mnu/svKt7zonUaHURjL7uzPHu7jTu7mru39fu3/DvAB/+0Dr+3oru6VO2btC4DbDAHwfovbPO+irPAObhCmXAX5vu/SvgQe//EgH/IivwT/PvImH/Ilf/LQfvIsT/LZLtoZT37b/8zDF+C5yMuGD0/zoQzkXZXxG6/tLd/yKR/0Ij/0I7/yRF/0L+/l0GrM47d8M//FNl+Ia5jzUq+aF+/YVdDsy97xKJ/tSe/xB4/0ST/2SRD2Lv/vVe4Q5sfDI/D2I2Dzhnh5O+z2cG/ztTfMWT8RGcH1UOD1IA/0YW/2aE/4gz/wa98QbX9+cB/3N7+GdO/FjH/3npv3ew/YDtH10Q7y1C74Jo/uoM8ESjD6pF/6nj/yoY/upb/6SnD6Ip/6os/6pC/tRGoXl4cBuJ/7hGiIc5+Bua/7VK+GhF56GaH5ZL8EnQ/2Jw/7sj/7yv/5qd/8o+/6Ic/80k/7cG7LdXH7v9+PAbvP+5Dv+93//Ws4/BNmosae/lVAohNRQ6YX7O5/+QeB/uof7OwvEe5f//Ev/0XZF/Uf7ADRpMmDBwIBHESY8CBBgQSrPIQYUeJEihUtXoTYsGAThR09fgQZUuRIkiAZDnyAUeVKli1dvoSp0aDIkw5h3sQpk2NJnj19/gTpwIFAoUJPAkWaVKnSowibdizq4CmAqUt5ChBgdCMCBFpnWgUblqRQokWrikWblufUswejst2odiRWr0241pWbN+1EvX39fuTrM/DfkoMJH/5pGPFisYpJOmasEHLkpAEBACH5BAAGAAAALAAAJgAsAYwAhv//////2Nj//z7/nj7/dxf/nhf/d//Y///Y2P+ePv+eF/93F9jY/9jY2Oe2Ps62Vs62MOe2F27nhm7nYMC2F6i2Vqi2MG7Onm7Od27AhueGbueGSOeQF9ieF86QMNh3F8CGbsCGSKiQVqiQMMCQF26onkjnhkjnYEjOnkjOd0jAhkjAYBfYnjDOSBfYdzC2hia2bia2SAC2bgC2SEionkiodzCQYACQbgCQSOdgbudgSM5uMLZuJsBgbsBgSLZWzs5IMLZuALZIAJBuAJBIALYwzrYwqJAwzpAwqCYmJiYmAG4AtkgAtkgAkCYAAAAmJgAmAAAAJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAj/AAEIHEiwoMGBCBBIWcjwoMOHECMWFCCAYUOJGDNq3HjQ4kKOIEOKHKkxoUcpJCGa9Jiy5UCKJ13KnBlzps2bLldaxBklCkEGDD7i5ChUIEyUQ5M6BFp0YFOlUKMeNdiTp8+BTJFGjdh06taoWQ0+/UpWpleCVW8KPcm2rdu3cN0KHFtWLdK4ePPq3cu3r965Wmne9UuYMOC6UNcWXsy4seOdAOi6VPy4MsvIgRHbBWy5s+fPhzdj/lw5tGaclEmrXt3XtF2LRIj06OGjtm0dOnLo3q1bg+/fIIKDmE2ctu3auHnzrnl6aFaLEqJLMEG9unXrKrJrX8F9RfYMGaRP/79Ovnx57du7fw8v3Tx59Nm7e1cBPjsOHMyHnow9+zjy3Mr19ptvwg1XnHHHJRdgDvk1Z9NzDInn3nXwqSDfehJOqCF28F1IH3vRbUhdhR7Wp8J9Db4mRRBBbODiBrjFKGOML9Zo44042ihjig6qeMKPQAY5wZBEFmkkkUEmmeSRTBqp5JMnNCnlBFBWeQKKUkABBVkWsVjjjGDqkOOYZL6442U9JmWRlVM2aaWQbR75JpBxyjlnklhqWRdssRGRYJiAKqhbcf75EGiMPKYpk0XyKTmhkvJFuoKj7kEqaXeUmmfppZM+OcMMWEqGGkN9+nnboWHyRqh/qOqQqKItMf+KaZKPJskpd5mWt+mluZK3q6RQfhpqZjc10MBCSijBIg88DDigi2Dm6Oy0zkIbY20WJZEErMUeK4W25kU3pXjktleeuFKWW264EoyrbobkRfejsPh9u21UxiKrbBDMUquBtTJK6y+1AOuALUPacmtTvvay6+67IZ7bbroQRxzvxE1WbPF18p5A70IJfxVAABYJIYSXZeZ4aMo3vqowSBY54cSddNY5pJJ20mzzzTRHufOnn0IG1cgln9wiyzeujPSLLr+8Ucwz97wzlUs6KfXOPftsM9AzCK2UTlKYLLYQMqpKXKGH+gam2f350LTTEoG9UK/X/Rop3dbZ3Sitldr/emuuMgQuww03eJ0U2GObXPZuq/4JqNozsm3c23CrpJBHeFen96xB1hrkrZ123vfnf/NNneCDF35RUgzLnLgQO+xQ48AEwzijwAMefFLIlWPEsEXJFqnxeBc/DLHDFFeMfMYTt9AC6ljyrlTrTrwe++y0V2t7wDhOq7tH0vcO0e8MBU/k8Mszib7Exr+b/pHoOg99veEPRRH5pcb2+utD9D9E/gDM3/7EViqL9OQJTzBW/cQHAKAYqyfkQyDqJjhBwhHuPhjEoAVvQMFPUTBwG8xgBjf4wRKm7oIivA8JTUjB6N0rKffz1kIAOMCx+e9/AcxhDYVQQIYcMIENWKD4/xzYAAjKUAoSZKHgQphCHKwQdR78IBNT+EQlgtCCTXSiBa04P5C9cCZACWNQGMIBDgwwNv3LoRqJsEM04hCAbQkLAwtygAOE5iQUnKIIq8hFJepxhFvs4wlvkEU+mtBwLhEjhMp4RiKkcY0BbKMj35i/OI5xjnS0I2Y4w5A8YrGJhhSkFD9JxUD28Y8aNKUSETmqhTByhwSEZKlgmTg4ssU1mCRIahYCRVBlsYlci2IJhTlBev1ShMGcwTB9ecwMJrOEKECBqATjSjPSkoey7NM1Y9nDmkyTgbuUQi+bicxgspCY4yQnBp/5QWOqk50UjOY3R5IQ6pXxlWNbgD73yf/PfvpznwoIqED/uYAPGPSgbREiJkdGvoUg0AAQjahEJ0pRAxTgohjNaEU3WtGMerQAHA1pRD9KUo/2sgYorYEXcVJPb8nsntbMJ0Fn6k+BDvSfB0UoWxQ6R4Ye0aFPEKlIS3pRoYaUqCA16kaRWtKTpnSl+mEIBaZKAQDStKY2zSpBE5AAgrYllxiB0EKYStaymvWsaE1rRlnAghSWoAQ0oAErqSkFqlY1f1ftZ1a1+k+uevWWYI2IWKWg1sIa9rCIvShb3QpXua7uJjG0CAkmS4LX8XOvNs0rTfdq0N19MbAFIaJFEJjY0pr2tB+NJwpQClWbRJYhlK1s4i6L2YD/anamnP2AZ0G7FAZE8AmoDa5wData1tpLTQyJgHIjwKLmBqG2AeWqdBMA3epilqtf5S1ETkJWiA7Xu8IFb2lVG82epAW5C1kuc537XOhOl6vWja9AsQtY7TqEu0wVL2r1e1r+Hpa8KDDvVZKyyHuOjUV7vS1Bq8vPztbXvmLxYRSGS+EKM5WCcY3rXFtSYHwaLcEKxmptG6zbB0NYlxK2sIpXfFEMZ3jDKWFYspTrYQTL973UlW9tHZytz574t2iVKIs1OtL9FpnIUYQBDC5wAePylCQyVgKNY/rhG79XxzsucY9PXBAgn1XIQy7qkU0LZiQrUwZKZrKTfWwTi0z5/8DtxTJm9SnngEJNZlyOsEVCSoA+E2AAA/ioUinq5z8H2qODnmihAS3oRBvgUzGIdAwwgIEUpADGsUpuBGoc5zpndgGevrMT8lyQk/DZz4xGtKMhuuhDE3nVrW50oiEtaUpbGtMpcfNyX+fpEevVutklNdEYoiVWF5oAsnb0sZHt0WUnO9HOVrVQk0lpSuOaJLpWLq97DWLaVjfYeR72QoptgGi/WtnH/qi5MbpqYxf62RyldrWvPRKLTNWqIQY1dPO9AHBrlyJixG+YB27SCZaUrQhvqwgz7Fh6w0yqdy0Vvxmcb3/zFuBhFDjBN07Bgydc4RlkOOVCYu+I9+m2FP/ntz4tDuHBbnzjhGMraeTYZojjO68pVznL7evylw885iyY+SVdYk9rOpfb3q4zjxHGZvtST1vwVmqspY3uPqdaolMX87Asoy0FNl0kRTfZ0XuddDkvvbV5fnoSom7UrLO73VPHOqpdndStV6brQfx6rjUN5/jimNt7pe/Iwapxw1K0vxMlrgxWg8vJ8F1sNq7u3wFvU8GjidSjYUhpD0/mxBc2cIzfZCJ9e0QPm4zOWZ28r/l99uPmWbQMIa3Pw+wCF5xkBCPwgO53/4DePwACELCABWLzlidzBPbVtKy+K3/lfau89cbHJPKRCNzZD7n2t8/97nXv+98Hf/hEKL7/3rGt6ZtrttsqX7mJ82xqjna33Zt3tEWAD3zh298CuMf99om//lZKQbnmh3N8lX7qN3i51H5LlV/wl1irNn/0d3/Cl3/ap3v8Z4AioWvs1WnMN12Ut4HStXMQVnhfZlHhRYLB5YD0l4IqmIIsshACxiWaloG1pXodiGMgaF8iaFb+FX/DhYIr+IPA14JS8II3MTJGSDJZAgXKJYMdiHqh1n+8NTICoSVakiyAlmrnBm2GhoVvB2tbSHdiRlHDAoRkCAEV+Fg2cYTDpiVLyF4dqABOWGc3CFZSCABUCAVWeIVsJ1RWp4dUp4VXCIZJJYb1shBlCIRnOE81l14RoHwE/7h8N3Vbc8hbCDho77dq8UeIFqF7ZQiB4OdwjseIjkiA6JdXkwhalahUl+homThRw8KJZOiJZ0gWRwFT+iM2cWhbjwhQA1hQWnZ5XCY3hEVS7TZmYhaGC2hWqEM4FqF/2/eMsAh8FjgStXhPt3h6kKiLu5iNcLhPraeIuSSMJVWM/gVe5GiCZbWMqrMQzgiN25eC0/hw1VRG1ygEZdeN/ARfkUiApxhYqeh5SFWMq5hoLSYDBQl6jtF4/meLbISLvPhp+Zhj2siPUBiCHnFUCoiJGcmKBRA4B7l4CSl6UBFl6pWBNEh5J6kA0Dd+gcUwWiJ7AYmOiBdcEJVMkWYDNv+wGHgXfSNBkstlks33him5kpgHAC4JBTBJVDvIgDLJlDYZAzipk0ngdVuRbY1oNJHnXkFZgwnQj4TnETxYgmpVQi/wAvSmJwVxXkphlWLXXH63lSjZlRWJg2DJlN/VlGRFlmaJhg+BlmgxYGs5hFGgXtumYyn5hAYEmKSWg0ppjEy5lGolb6AYjyQnmISZOHJ2mHLoEWq5mHWpg46JWGWWWJLJl9sFjM4xRgsxWaZnj9wIkSpXXd9ILD0yjYxpfaaljhpmmgoDIaxJZdiYcxMHXbP5Mrb5mbgpXLrZcLTpNBbhANDpACwyNtymmdUlhJQ5KhH2NBcJkI8ZmoXFeR//RUzyxJvGyRDRKZ1BQJ29Zp3QhZ2o2RxjAY6ctBDi+Z2QmVb3mVHkKU3meRN1RBB1FKAPcZRTNVmz5JoCmGUkZlA0lYisIZVU+RIUIQBi9FpAlZxn9XEcinC1dx+os2ZkQaACMaCa5BAGSgEIqk0KelWy+QENCqMzBaERShg7+UUVaqFhhKHUp6Fm1aEd+qE4EKIq5Xq0WKEmKkYmSqBWySI39Ii11QEdkFNUelDYWKOF0RMLkRUEChQmqmea56OGBaSMBYotkaNJGkZLqklNGgRPSoqYJaVVWqVXiqV+oaVSwKWa5KUDCqZjJaaFRaYi9FZmOhNqqIYGkSwy04Zj//eG8XWPGXg9ZkIj23M7S2MtSHMSh1qHp/mnxbhsYPapBCBpMfAp5ihS98E1lKaoMjNqiLGpRpioSrCo69WojppzexWpsjOpuFEw3HOpvcoymrqpEmERyKiFhRaqcDeqkmaqJChUqQo0qzqrrdo7DxQF2tKGbelp7pmZCcAszJIy/uIitKMyYrIB0xICIYB2G8EwSUmTeJmOMoB9jiFgNwo315qt67WtddatWMZV4MoD4lo75YojwZqu62qkHOGu1XeXikevjWGvU5l3mpEQCTEyFosAR2gR9IhXsYmP27hPY4MbtdE2jtMqYVKyCMIqMwJjOfqyAsBJGDmOljiI4P9Zk12jGgoZFRmLsRa7sWTEAQGoYBMZsgswsgbjAyZ7Kiibskq7sieLGy4LsxUqs+7XmKpos0uJs6FHnylBogAAtmB6bw2ZlUWbb1HaAfqUU2t7UPo0NrwxLQVyIFBrKAASIHIrHHRbqEZREWFKcGyFVAjpGSg2oicatoc7tnfFr7A5nHslpW3roL4ouXC7G3kbHHSLNnerHJdrIMXBtwBwFH8KuCwguCBJuE7RnBWbsZeTfLO1i7p4tiE2NkAABGuTAyqruU27OLnrHwaYo3vGkTR7jhl1EimoexKYvCNAo/HpIKzbulLQmtsYuyDLb7Rru5GDu0+ru7urIL17HL//W6HBS5BYS47F6xHH6wHKK4HMC7ow2BPaKjbcCpeA51y0lIH4m7/6a7/7Axley0mA6lE+eIj0B5+dOUcuOJj7Kr/9Sr/cxr87tL8SPMHr2b8X8b+ZF8Dna4gErIIGrJincbEB8LxAW01Di3LVu4v1mE0CtD8rzMIs6r/EQrVVm3kzS4w1O5rJtonu+I4qCKHcIsIkbIQcK7QeO5xGq08vDMMN+TpLDMMmI8MGQcMUYbUJOLxGhYwxCVE83MPRSH9ATIlB23e32oEmE1ADtL/blMb6OzZSzBGt6gTHqLWD1od9NsezNgNVqAQdrIJR/J+9U8RkXMaAd8YKwMb5u8b7/6PGYvPGGxHHeLysgHbHSXWsIvUpe9zHKfjHGHykNCzIr9u4sLuPc3pQJwyJSYzK3viLYyHEGouoGdyFyRieBpBCXbx7QIi8I5CdUkHFoCxTogylpFzKH3DKwQynE9l6BuHKhwrAsqyRhlfLInTLX5y+uMfL8hmDFWzI3ip5Dtye3zy/HIhZ7hvLuPkpH0kYWgIZBwxO2sye3ayV4yyU4dzA85xV5WysyYnOHSk46gwF7AzC7ryaJHDK93jMKIx0yIxZxPyLG5GjEKKhJfQYOxvIsFXQR4xbzpd+lCfMWVbKoAjRqjmMuDnRIdnJp9Gmy8ID3nzPcenSgOevhpkARP94gX87ZBvFNYGDyQCtuh1BLCitGSrNLywtz9J1qzJtZTBdnTRtXuQ3ujhdUTotAzzttfPp09xScisqUx69j10tux+L0KsMuqIrBdCMw8UYRcOyEcKIihC31Q751SnM0b0o13m1dCJR1me9h0al1oWI1QXR1mLMiIzaXEsNzoctzkftqJqZzwyRn0HmnXk5QeWsXUPNIoltz4tNz5ntrYft2PYZr2q1nxdG2YAcbmo4bkr4k27ofIRMvYSciw1cW+UMyX9Yx1/I1zjLNXtclA5xqKpdkq3ta6/djcUt2/G8V7XdqrrNUX3IhZZMUcnU2749Pt4yY6xtq8L5mmT3a2//KGK95mA8aRBH6YXvdtvRPVFc40LVbd36ItzavdEP2YTeTd8HjWXizZIo6i3khqx+Bm/pLVHrTT/67dtWadAafcxiHWKluNBgDdrDKJAKGOARlUyVPdj/t1wIvmB1Pd9G2+B0fcwQTuE3TLMk/mjBdOFuvRAHitES56IdHuJe7eApDOL9hNchodfCi9bt5tcq7o9v7eInB+MLTrQxHtYzbuMkRtZ+G9rki8Wr5uOnXZQnoW2Y+a/17NmbzZWdLV8J3M5cgZwmvmK9hM0H6BFWDs9KveUvzeYxneVeLphg3qk3PeYqVubNS+WDYad83ucJLBB4FhHDJm5+7hfD1t6p/1ufhb7opJEWgQ4Rg46EjM4Xh47oojfpmK6zIhnmip7pb1HR7Lfnnj7qjQHqhZt5pC4Xm16UE9pQqf7qcXGvgsUAeAfrX25esl7drf5Ttt7rnjWhEAEUtW7rAtYTud7eZW0RTLDsTLAES1AE0B7t0n4E1F7t1D7t1p7t2n7t0t7t2L7t4H4E3j7uRRDu4e7tBjhYsNh93VcB7v7uIiAC6zuBuAwB7O577/7uuMe8lk6hbcHszf7s5F7u2/7t5p7tA9/tB1/wCR/tC6/t6J7nB6HuHgB89957+e7u8T7v0GjxF5/xFbDv4TeX/a7szG7w3I7y4q7wCM/y1u7tEO/y1f8O8y2v8jT/8tEO4cK3gp7I8xDo8/cH9PYHfJwM2P3OSQBv8zKf8g5f802P80of9U8/80u/8lKv8xYg9Duvgj3P9T/v9UEPAUV/9BhhEc7u7D+Q9mrf8N2u9m7/9m7P9tIO93Rf93Qv99Fu92oP4Sl475p8iH5PhmNP9mG+EGe/BHCP99Cu94mv+Iz/+G+v+EXw+HxPf4H/90B4+T84+IT/EGDTBE1gBKI/+iqv7Uhw+qg/+qpP+lMP7qif+quv+qWf7a9/+rEv+1NvgIS+EPenvF5c70DY9SnY+/ln5sEIvaAf+7Nv7bWPBLfP+tC+8M3//KK//NU+/dRv8Lov6QzWQfwS+PvVDPZDL/4SaPwn5uvoD1jgGE6wbupHn/7wf8FGf+np7/4lLwXJHv+pDuoBl6cj3esAAQBAlCgCDR5EmFDhQoYNHT6EKFCKFAECJl7EmFHjRo4dPX4EGVKkSIlSGjJAyWAiypEtXYIUSDDiTJo1bS4MEGCiwJw5d94EGlTo0J8HizqEAiXh0aFBf/bUabLpVKoRfUqFyrTqVq41tWpdmHSp1K40n/YEW1Zt04oa176FmxABArcz22aMaxZvXr4272LsG5jr3LoR/14U7LBw4qEBAQAh+QQABgAAACwAACYALAGMAIb//////9jY///Y/9g+/54+/3cX/54X/3f/2P//2Nj/nj7/nhf/dxfY2P/Y2Njntj7OtlbOtjDnthdu54Zu52DAtheotlaotjBuzp5uznduwIbnhm7nhkjnkBfOkFbOkDDYdxfAhm7AkBeokFaokDBuqJ5I54ZI52BIzp5IzndIwIZIwGAwzm4X2J4X2HcwtoYmtm4Atm4AtkhIqJ5IqHcAkG4AkEjnYG7AYG62Vs7nYEjAYEjOSFa2bia2bgDOSDC2SACQbgCQSAC2MM62MKiQMM6QMKhuALZIALYmJiYmJgAmAAAAJiYAJgAAACYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI/wABCBxIsKDBgQIEPFnI8KDDhxAjHmT4xIkTiRgzatxoMCHFhRxDihxJkuPHJyUhevyYsmVBihZdynS5kuLMmzhvnszpwEGSJAR7/sy5USjQgUaJKn2YFKnPo0ujShXYlOrTm1UBZJ1qMOtWrjyvOh0KtixWsVbJ6kQJ4KTbt3DjyoUrEKTZpXbn6t3Lt6/fv3zrsl0rGLBhwILv4mV7uLHjx5BZth08M2/kyzsBxFRM1DLmz6BDJ8bpOXRkgZs5k2ZsurVrw6PPUlyyBAgQHbhz4+bAu7fv38B/694dfMcOimpV4+xJsUmTEycoSJ9Ovfp06Niza7fOvbr279i7i/+nAB589+w2bCCHutzB7Nq3hxMPTr++fPrG1ysnypyhc+jjnVfedgFaNyCBBVJ3YHYCQpeefvy594QSSvjgg3z31achhsP5lt8TtCW3n0wBBNAfhQUuGF6CCp5gwosmGKhidCxeN2OLDtrgnIgRLkShhRzqpuGGQc7HwYchsjeiSyWeqESKN9YoHXQwxuhdlFLOSOOU2KW3o5JSUWRhEEGEEAIOaKZp3Jo76HbDm3C+ucGcdJqZpppstqlDZkvmRNEKgAaqgQYTFGpolYjCqMKijAYqKKGGFpropJQqyuiiLzo6aKSSVvripYum92BDXInpA5l23olDnnriFmecdNb/eaaqrOLGZ59rLeQooJty6umnoO66Qq+R/mqsCaCqkOmjnE5gbLKiqkfqVBSRKYQQd9aa26twxjpnqtnm6eYNt+Iq05/DQlrsr8kKS6yzx7a767udeiqvpuoeakIM/MZgU6kMWYstnmyOy623G4BL8JrjlmtuS+jSC6+9wc6b77HIVoxvs89qzKyv+/b7r1L90WabbUYOKVyROqj84UI8PhxSf86haKOKUnKJc87fybjzeNDJIMOoMbe3kMknp6xybyy3POTLTxQts0Y0N2GzzgvmTB6WNfZ85c/iBT20tFKvttDJJwOH8Np08pah2t7yBtNFU6d00rpVcjxpoeM1/6t3onyL5zfIgE/Qt6HS9RuD0COHyRDatsHNNsJudxgc5RzMXbfdH+EN49+IBt7d4J7nbbjgpNcb+umjI06B4oxPK1V/C12LNg88wOqtmWayzfus4Rasw5tQQ7i5RLR/tOi7GN+7wvIXx+sx9KVX6jz18LLAguJEgxkWRbafjLvusf7uO++qriru8DcUz1DZxzv1FvaqU3ypo/RPzO70KjAv/f2Bwt6LtMc9snlvJiUqEfiuxcAGOpCBkIvgyR5IQQq+JTbxK8hKasKQaHnQBkILoQwUx68a1OCDKPSgCIVGQhKykIQmTKEMQbjCFsZwhtKyi1ISGIAFVrCCEpTgD/+HKIQLTiaDB9mgQj4ywxWOEIYnxOEHndhC2D1RcTeUYrSoCEUpNs5PDJGABNBmoTKa8YxotFAQbZPGNvrAiDpE4ktYQxEnvrCKLrSjHu+Ix37tcY99zOMfudjCL3YmjGM8mRsXWcY1AoGRZ4QjZeQ4kNIsRI+BtOIga5hJfm2SkJn8JCcLKTuSSYhCYoRkA9voyCC28Von+clXkGiU5DlHlLgcpCdzycte9pIGNIBfSpyUSkauMo2tlOAri/gRWaKFklp5ii2b4MtqPtGa2MymCIEpzJEkIAEU6YA4OxBBBpjznOhMpzrPuYB2unOd6QQBCOICzYe85QD4zKc+98n/zwMY4J8ADWg/B9rPgBr0oAglqELzeVArpiAFwDSkTL4ZznGWE54YVac735lRBsiTnvWciFsWulCEApSkCjWpSg2KUoI21I8yeGhES4kTDorgpiJooG3QudF2dvSn7OypOY0Y0oNQ9CP4XGlLB3rQpBpgqQVdqVRb6gIXpEeEKMgqCiRKkyUuBKc5hSAQeCpUoP60pwsYqluK6pCjUsSpJoUqP5vqz6fKVZ9SnSpKq3rVEGp1qzRtSUJsilOdjjWoGyWrAharAJ+adZ1EZatAButVhrRUqXdlqEozq9m4LrSqfKWh0B6aVa6WhLIUAathyZrYoDK2sWl9rDojK1nU/yIVpZjlbG4zu9uBgtaqoo1pCkobWJdQRIzFNGM7X7tYtDr3uT1lLmzbSVvJVvIjeRXoPrOb3blyV694/e4/W4gBDGQgA6Y1LiKTW8blMhe68HWudDdaXetOhiLi9a54PRve/SZ0u/slr3nRW1yZEFMC4iSjD+LrzvkyGLofZYhFuinH5DGBCf7FbIb1umEN/1dxMIBBeWdK4ZmdUgliTLAiF/xgBz/YuRFeyIQPWFQLY7jDdMWxZ3X8X8+CWMQYIDGN1buQBzxAjBF88UZdrGTqrtW+c8RvhvWrYyrj2MoqtWJ5y5teiDHEyEiGXJPd+9oxu7O+1j3JhrG8ZgDzmP/NCNXylrsskoQkD6wXNSd8ZavRnsb4fUOup415TOhCG3q8JMyqkHNiZwl9Fad5ZsCe+cxad/4ZZoGG5qAPzelOi7eFiqYBpqNCESMbmY3tNXOD36tkNEtWxhZxgnY7DVdD17rQ+hQhv7aMgYU4h9RfNjWqLaTqVZe51U+G8nVjLeuT1vXQtyZ0tN+cT13HgNe+boJSKFKBCjyQ0pOWratD2oAGqNnT6N5wC/PaghZ8sAQlmMEMHHYuhnT723wO92PHXc9ynzvdAP/uuqXa7nfHe96SyQkCEFDRYbPYsZTWM3TheekCs/XfAc/4QQtug3abZuFxbAnIGaJi5XI04pL/nvg6Kx5yKGNc4zA3AMc9HpqR5+oJ7CW2yitt5j7zO6QnifZdC0D0ogtdrkU3+rOdPdDYmQaD9V5Izh/u3D4X2+fJVvZ9Lbv0fw496QU4OlTBHvau27XpMnAN1CsTbDWerNhMbvLP6xl0N1fZ7lfGe5z91Zq1e7nID3C7beDOajPPHZp17+/dFZ93xu9d7Uc0G84T2UCUoxXlh6dk4ksKXs473r8tPUkERk/6C5j+9CRIPQlgKZdtI9I2lY/45SOeeTluPqWdx/3n9xv6j5C+9Kc3vepXz0yQymZCSrg3A3U+e8vv3KPzbGamKbnpmFvfAFXFNAS2DwELeP/7IxjB//BTz3rj9Qj5yr8W88vq/Oeis+IlzmD1rw/z7EctCdzv/ve9H/7xEz+W0ycS3+RWT6BiaINyVndy8SRPDFh7SHR7ctVbEdhhA0URH3CBGPh7v3eB5Fd8FtcSAwhOJEdOkIOA6dR8C8iA0UdvaXZburVZnGV2+dVPFoiBF6iBpMeB/5dwjmMRpyZmqhZ3yKY5WlcYXDdtFNhZ0qaEK+V0T5B/24eDOGghzaFtAOODD5BkQVh4Y3YSqaF1mwdtTLh4MohQTgiFECCFGkiF/mGFUaFAiIRvsoWClOaAx8NBC3FZMPiC/MVbADUqC+F/NjiIGFh+k7QUcCh1EiCHj0WHfP9mh5uDh0+gh314VxIIVQEFiE8giIQ4iIYIFooYZmhTbI74YpB4PCeRdGK3VGS3ii3VimaHT05EEWpYixHAgq6HXIk0iqTYWjwHXae4OamodHQ1dmDniigFi3Q1iwxhi2qIizPRaBV1U+GzUynniyZ4jQoIfwEYP980f9rFh1MWg/jEL/90Q4/hTPG3EdI4gtQoBAeojRCXjSjIjcr2jY72BBdWiRPYZuRojgaAjo6hjt1IErBmaln4SD4weFsIX0LoZNBYVLCWh2WYd7RWkQaARy/wAo8hEL/Wg06AkKjGkGbWXND1kAsQjHUzkZOIkW12kSulkRzpGB7phouxEN3/ln4MZFYMhnlZp2wvR3+cZkIttJF0tnYtB0Y4mZOMmFE9SXs/6XLYJZToRpQkZJQfeF0GkZQzcWBTZ5LPhZJmZo9aB47/hYT+6JK8dwAiFGKLhhHJs44i4ZUSgEZgKV9c2ItkqWxmWYxqOYNoOY5tCQNviTz5KJcbkYiT947hk42IpYAUt4I8uB+SGBIQiIl76If8yE+h1VcPdZTKoZhixJjweFiO6YjqxHKHqBqVaRIuqJlnCZt+6VvA5ZkpAJpLclzIZZd5SYpCaBsqSRhztBFhaGtj2HgYCWqA9YXCuF51eUZiOWa/CQTByXZbuZr29JpiGJigd5wApZywFj+i/7mbZ/SUv1hswPkamOF32ekjSpB0s8mKYBefrzifLFVtK/SZWbkf4zl15vmYvZie6nkakZcRFEEh8HmfX5eg4Yh09tmgTqSfXIkruumfY5aATcaQAwoZ7OkQGLegxKigdUVSyghQJfpPEXqb+zkiFfqcJtdkGKpkGrqhNFmgGPGhDqqKsahZJHqMS3eiBpCiuMmirzdBQmCCqKmN8PRAP/ADTeMqr4Im2vKk2/IqEdmeT0CfuMVhZ7dQ1raZB/BBMzWkiqGbaHMtSMp+JwiZ58SkTvqk3CKl60OlUBonV+qhDKGlJJVXTtVSXxqb+iSmojaZ7dETIRiCFEIbBngyzv/3fgyYUfKUUWijG3IqPHSqA3MSJ2hiJmzCNhd2YQLBQ0HREw4wAKY6AJT1qUxAjkhIm7/1qqCVHvb3Fz+BaT9xq0eBmBFBWW2VAKTqAIc6gIm6BItqjeAWW+akgpAKApKaNLlRqQxzqZi6AZqKA5y6Jp76qaGaQKPaE6eKqoOlqqxahq4Kq68qqy5gGLV6f7hKFrqqEoPVq8SJSIIHBCXZm4TXA/raAxoyOf7aNkyTG7wxJ74RK2QaZVlKlVnGd5HBbJsxoUSqiPV6r8fWi+61r/xaH//6r74hJBxAsL1hsCuKpwuhsAuLGQ5LNxCbm0XKixb7su40qUGyNCvTNBr/Qhsr+xCKqVBJRwAEEF6cBYtO5YR9QRs4m3U5qxpmCoQwC7MyyyE027FPerNLkLQHsbME1bM/y6OZJbR1RbR8YbRVi7TYqRo8pJto1LQva05o06RRG7WX6hvDShsQwUN220NP4Bz4RHQ+S3RA27UF0Ldl16cEJXrO+HuGWJ05cbb0Wp5q24tsezJu+7ZLE7e9MbdLULd3m0DZtreBSwB+y7VfJ7h/W4G+d7ikl7hR+TCl9gD6+qJbWLGqxkorFkGQRLvJZEbZ1qEPYREl62m15rPBSwAmxWxRiLqjZyHOcbD70bqvm2qEJ7tmhrsKabu3i0bJ5HC7a6MZ4bsJC5MA/yW8S+ezxRtrx4u8ytsEzMsZtvVoq7VOkBtxsCcEAkNEDuRI11K/9itW/5Kz5fa/5panJotQNBeIqmeDHuAB23eDEbB9rOe9SNS+T0CaxrqmVye/QJC/QbC/97tGGszBhtW/ZTsQAOxvAjzABlXAm3jAGJjAC/wBo+fAzATBdUNZHCRODzSPraXDHMXDjsXDkZpy1vhAZ0pBRUzERorE8/tAIiwRvLp1KKxdThh8poeD/iegI4wrNlxZOOxAPhxbXyxxlSbGQRXE7TTEHbzEaZzBRpzEa1xBTbyr8QrFUex1bJl2DEHFF2DF44fFQNm4sEtmjNW0KOlwDHaXaBWd8P91pyL1uyYriytEi6SHhpQMAYzMuoAMvcY2yDBbyAq5fmE5XXgpvUM4sgiLwpAsQpIcw5UMhZesHJR1Z2HVmBaMrI6ppLcscfN4mpYWfcIUrE0iIfsIqP3YYwBVVfzCcZqorkkwS+YSy/lIwab5mLmsy7bMy7tMj708ahEBzCYizDemp1u6Y8fsAsnsbqKSjs38TA/Ysm8Hs9bctPEMz/IYX+tbkxTis+Qrosaoz1urT2SnR4ZxtJZBd+5MkhY7z2tbzwstd6ZsEDWjBP4szjz7ueIL0GAn0IBB0Kyhec75wUcqe893rO6HgPqWmszKAAcLwFJmsnhEZ+WGlFlsLi3/CtLtV3UmPdL5ptOOqlZWSxAsfcIK+9JZGdPce9TNGYq7yKgMrWoxesHn6dS1jFb3vHU6StH9BKSwyIw/fV1VXabOeVHyPNWk+NRSHdUQOdMQQRFXzc/J6KMBtdWR/NBb19Vmi7eK2MWxx5NqmqbY6NdsKm50TRBvFYOXSFBVxdVqrXXjqdc72Yh9ndN/LdmBvW+D7dUtKY5YrU+JPdd2DWWEJc3wdNI7XdI3naR8ndYl0dIDjEU18NXQFNqzXJqjzdOQbdoijdsknZKXbYR17NqwHcECIMuiDaDXTNlfPNmnfdxmFWG6WjW4B6aUaFBZZEBFCK/EPdsVjNqlrYC6/43czA1Uzl2Qo9q5LpWZlohQ1c3N1x0RLZq28WXWPUfWUG3cxVbVUtajbf1PQNqguebZi12E7+24pD3WaH2h9K1q+C3A+h2i/A3XxJzKIRTciPfRDrTb2bzcuczdGbXgFMlUubdUJrVLmtjeElHTF97dGZ7blY3h4f1THp7ZUXXYe7p3QlPiJk6ymQzKm4zIvomvscvJLytdr2yEFtGg6HZ0iv3ZEvkRFprIQE6xQm6xiqxkRE6oJy5hzWbH3JmEywjgTG57TyCJNFrmZr4SEmFzdW3mf2HCOS4YZM7mcu4aaB4Raj7nhuHmb44aKovnfg55H5nlRvjnesG79vWwhP+e6OsJAIHu3nSk6K2H1GBIGZBe6YdRkwb6BIpp6W4Bh3seR5we6oHB6Da51pqO16L+EZ6+52u+EEjw6rBeBLI+67RuBLZ+60SQ67q+60PQ675O68BeBLeO67te7L7+68E+68Nu68Vu7Mc+BMmu7Lde5GveiRlYi3o8fNZug7aoumFu0CcB67Ee7cK+7M3O689O7uU+7Oeu688O7eS+7EbQ7rn+7uo+7NR+EtsOw9hOxdq+7/yuht4e4NdNEUdw8EeQAwq/8Ar/7g7/7Awf8RH/8BQ/BBJ/8TlQ8Q+P8Ry/8DGOg5WMvId7gfmHg37M6lm+EAif8Bev8Q7f8Qzv8u//DvMLL/MQT/MX//EaGPIib4skz30mT529Pekqj/Adb/O9jvM1j/RK3/BM3/THHuPn2/NSOPVqWPIaePIob+pFf/BH//RKj/QWD/Vgj/NRP/QUYfVU/3tqD/JAn/VC/+0FzxBev/RiH/ZiP/Y0n/d6D/MVn++ny/Nrz/aUbIvUnuMGz/JOf/dmn/d4z/h7T/GAL8mCP/isjIaGj+VbLxAmnOqe/xF1DhF3/vl6vvlAHcCfn/pjvkRpznCPLuqlb/oEgeiqH+p8numDbumILvsGQfu1b+m3f6Ovr/t9zvvDefzGP6/XifvIrxwtJ/f29fwEn/xHbbXSz7LLT/2YDf28FD/5Q6+U30/04S/73s/9N2f+nBEQACH5BAAGAAAALAAAJgAsAYwAhv//////2Nj//9j/2D7/nj7/dxf/nhf/d//Y///Y2P+ePv+eF/93F9jY/9jY2M62Vue2Pue2F862MG7nhm7nYMC2F6i2Vqi2MG7Onm7Od27AhueGbueQF+eGSNieF86QMNh3Pth3F8CGbqiQVqiQMMCQF26onkjnhkjnYEjOnkjOd0jAhkjAYD7YnjDObhfYnhfYdzC2hia2bia2SAC2bgC2SEionkiodzCQYCaQbgCQbgCQSOdgbudgSLZuJsBgbsBgSLZWzs5IVs5IMLZIJrZuALZIAJBuAJBIALYwzrYwqJAwzpAwqCYmJiYmAG4Atm4AkEgAtkgAkCYAJiYAAAAmJgAmAAAAJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAj/AAEIHEiwoEEAAgQ4cIClIZYmTQ5KnEixYsGFDa9cgWixo8ePIAkmxOiQY8iTKFOq9EiyocmVBkcyLBkRpk2BJDW+vMkzpUyHD2v2HErUZsugRRsSbNBAadGQTglqfEp1ItOoA7FW3cpVoFYAX21ivYqlq8WvU81uJWswrNq3YssWdLtyIcSjQPPq3cu3r9+8dx3shDvUbhO8fxMrXsy4sWPGgQfDNIz4sWXIhwULJVxYc+XLoEOLHh3UcFK5pFP39SqX82nWqmPLng2U9WuwtGPbdn07t+/foHefBlqkyIbjyI936NCjufPl0KEnn74BCBDq2Dfo5b1V74nv4CdM/6BAvrx58ejTowfP/oR48/ApqJ8/oX348fHL01dv//t7+DXUsF1VehWX3XLOPReddNlVd12DyQ3I3VPetfdffvLtt15/F+an4Yb2dRjfh+L15x5+5gUoIVEBBEASFVQUt+CMNCZoo4I05tiBdUBJNiFPJFlhBQpEohBfkUgmSSSGTFKg5JNGNpkflEpKOWWRO+zg0mZFtfhijEXoqOONN4qZI480/fhUkEMWeSSVSFr5JpxLymkenW7aWR6SWW5JVQIJfFmcEUYkyMOhPPyg6A/WNYdoootaJykQZFbaA5p+qnkToICyiaSJ3ynJwqiklqokqCeIWuqqp4Kq6qqktv/K3gor6KBDn0hV1elMMA5aqHOPLsoopT0EG+mkxFpqI6a5agoTp4HOJOSnriYJq6lJovrqtbL2ty2s3X5Hq624+kigQ4QSGh2EBzKH44LsaueQkM4OhwV5JNbHIYoekmiiiPDl+y+/I2oYoIpYpNUVUOkasW680yH47sMQAkVvvUMBha+/+zYpcMdMfhwiwQEbfHBGV3RFVkNItIyEo48iSp0INIsgrKLIEhuzzNOtiHFKCCBQIaq0Fr1CqbRqoEF6qM5q9NGkJr00iE1X/TTUo0rN9Ak0dE1DbVytjIXLLxe7Mw8z13zzsJPCvDN1Pv98UtBDg3o10isovbXVT+P/rTfVVRPdd9R5T10i116DvdWXDRNBRNo0r52z2zFDbvOwPXIpd0hHVVFF4ODdTfjfh/NttN+G62t60ajv3Z7XNJSreVGMp+u45ZIjS/mjuGOe5uYpdf456CeInnXhrgt++uipg248C1oDDh7ssm+1a0MwNkzoEEMYi7PuypLpPdtA8GUu8AR5ORNQnoP+LavZVovktbHGb+L72FL7nQsudE2uls16yvWwkD3tcW98kwvfjRAoKfPNDn3pc9H6HNK+wOGvfvrzlrXox4JwteeCo+oW//x3KwCejygM0x6hyMbCFiJBhTBMlwtZyBfhQPAgTtFLlnbIwx5m6WAHgx3s/wLkwyLuEIgBEqLXgKjErhHRiEVEYg2aSIMn4oouKEQXDGc4wxjGkIsuqyFubjiRHOYFilFEIhWtiMYjqrGJTIRjDdrYQymucY47VNyapGWFEpRghsVpmReN0LIjHAGMXdRey/QSmQcCTyaBQZnnbPU/H1JSB1Sk4iWNeMlMNnGTReykJ4UISjRmiips8iMgiyBILxbykIhsoQoXCZjMnFBukMyMJKtQyh6KcpRe6yUPfwlMGghzh8QE5jF9eMqeMEVsfhwkoQxpyFiSTZpGoCYsaakXtpBxIAkhi9gaksxRLnMH5fTkOdOZyXVSEpgpSAEWV/LMpjgkmtLUpjVdhv9NfYZxL978JkIEIE57AoWdmqQkJ99ZTBJW0pcMbag7bQVPebaGK0CJgEYjUJyOFmEBIA0pSBVA0pKK9KQoTalIS6oAvwiUInwxgExnStMDHICmOM2pTndq05369KdArelNgzpTJcYznnq010Y56tGPppSlJFWpVKXKUpe+VCIx9WlPicpVmW61q2DV6lC5atSjJvUmQaObQzjAVg4QyqMiZYBc50rXutqVAVOlawj2GgIxXhWmeQmrYAdL2ML6FHa2soFibXBWm6RVaGtt61s7Gte7WtaueZ0rX/u6l79WRC+GDa1oR/tTxOpgsYx1SHccstTJFmeqI4UqbGcbUr//ehaH87ICaW361dHydqxh7a1XeVtaIR7VogqjEGs36lqnThWqCqAtbW1727nkdrfEJa0BfktY4W43uzstK1ITlrJzNUSjbG3ubKNKW/Zi9qR6gVF1DdIivfz2twXIr35zet/++tem+t0vTv9LYN4GOL/8LTCBgTiDGcRTBSpobE8yGoH0GgGusGXveqO7gPeKNL5UmG9B6puX/x64AAlWsH9PnGIV35fFA3Zxfxns4BRAWMJxOS9ztSfd2XpYqtQVMW6AcuLeFhm4w5UxgA/sXSUbmMlI/q6KpZiBKmcAxzehsEZV2GPY/lilQRaxXo5MUzLH2MlmFiqaodziAlPZ/8pYNgofK1ABVfLTCJeta2bzbNe9MtKRfxWedgdNaMHCAAY8zEEOTGCCG9ygmZ1piJDobOdW8nmue760ZjmbOSEPRNCFDrWod3roRC+60Y8OoL38WGmX5TnTmr6rXpJb3XqCdtS4zrUBxGvRecIEKKz+IwtfLdVY53nW5RWxrQOr62YXmtdx/vVyNdpU5/b4yz0O83xvrWYlp9kA306yt9l85nHnV4rHjfZKtMxUDHcZ29LVdnW5PVMnLznARiZ3t2UcbimbuwDoNqtqzYuFLV+YslSVbZcTTlJ535begu0vdrkbWil6N6fQzgtVKKxehpt04Sqtamc9nRVmd/e+E/8Hb2EtHmWMG1fg6uYcH1tNqEvD2thy9XMtPc0UUDv75wZ4wQtsdejZaMQ0PUmlsC3N55vjXOedFnLPJ+g5oANd6ESHgdGvgHQgTZDmeG76SXGeZ6j/ztNHEdJ/DWtvlIu17VeUTSMjfc+lvzDsxK4s2e9qdkjPN+1WWHth205xnhI+7rGZexZ1XG2UQhfkIefwh0dO8iE7JOJuF63ER4uw3NiQJxRu/EkfD3nHS762lCc5xIm6ec1nvuIC8s3npa1jLpc+pPAGcuo9PWYU67Tt/Qa+vutNYL1I4PjIT77yJUCoxGx8uba/fYf1nO3dC7n3hl8zvqMs/O23+b7GX77/+I/f/L8MBVokcYITLMz0vaN0731X9W1/klsns53wFyd+fw/Nf60TkArjd3wkMIAEOIDcdHY9gX4zoX7sd3d7J1fvR3bxd0vfRH+SFnhKdn/491P/1X9F938BKAEFWIAH6Hf2YmENA4Fj94DYZlcO51m31lsbGFoz+FNA8QE4mIM6iIPLV34xl2NYgILpooJ6x4KYtoJ09YJ/FYPAVYODR3hBdYM7OIU9aARxQ3cNAXY2h4RGmHOchoAiBniCl31Q+HZlmFNCF3dTSIXIh4MHSIFyBmx2V3NiV4RdOIGAdlVi6F8ciH8tp39niFNpCEANsYY7mHxuiARRtzBYICTU/9ZRPuADLCV9K6VwYGZ9YmZyv6dyrpd/J7dVNtV5WDB+D1CKpliK5GeFA6cWF/iIxRGJk0iJsRWLl3iF26aJLTZohedb2RWKsdcQpHiKppiKPzhhBbdj7vZUlkiJ7KWEV7V6YNV6NPh6ZCVEQBGC42eLz9daB/daHqdhzMhhzvhS0NhV0qiBnEhUSnSN2Lh82ph0C+gE6OVW6eKNG0aLt4eHledzQOWJT3h/NNU1MtU1iGcZiodK8TiPDWOPGbaMpaePJMePfVho/hhUvSWQuxY7hAgaB3kT9XQUbUWPDeN0xqZSHuABm/Vn+0h1VWB1uWZatoIDOBAantN1zvRMIP8pWTxWbEZokijJVyoZkSzpkrgGkzogkzRZBTa5Wg0BARBgcCO5cKRXeuMoUPaVjp+IlYN1jjOVREIUAzEQc1/ha0DolFCZLiA3lZBXld90lRVpjtT4hLtIU14JO2Aplhc1exnjEJRmdy2zhSS5hWxJRuVIlNpVVsX4jnvZEH3ZQoDJk+63AIN5Q4VpmKOFmKvYEYq5eMeoUY75gNKXkpjoGgmxmW2Bi5YpWkI3iJc0XmT5I+z2mZH5kEA5mpxRmhoHFaiZmoa1mi+QJa3Za3m5OeymQkQoi9N3nChVHJP5fALRIiQGEm5pbwFGAATwffymX9aJnf71ZjAiX5Q5bRH/YJx4hZwgRVdTxZy2SRhOAZ0B8Jqw4RD4V53XWW7aVwDbaZ8LhkRV9p0htjnpJ48VJpIHJ11qWXolCByh0ZEUIZFy+YdZCVZK5GgmWC8BqpD1aG3P5ZCQl6AKehkMOhEOGqHaNZdANaGpBoebkgAtsisLASgtmgD+GZLkGWvnWVd75YU5ygA7ull71TLx96F9ARFbAhEQ0SI7IRMLsRAD0KQDICRQioHiZpF/6IdauX8e2H9ZIgNcKgMYgAFGmodEkRACAaMB4KIOYKaAMqM6mYIlmZybpqMh4IVy+qNIEKRCuhdEGhRhiqSboaRL6qRPGqVS6m9USoZOuG8HkKVa/7oDXeqlYGqkcEGmABA0S3qpacopbNpxN9qFKHWSPhqqIUAojuM4QiAEvIMcNXM5udMoZrM7aIMc1vE9h5IcEKERUzAFEnGpCdGrveo5Vceb4RVMOuCbWdoCLdCoj/qlYaqiHkGpEkGploqpL6qp32lhydiFyrkAoCqqm0WqpXqqqXocq7o23+OqhwKryTGrw1KryHGrV5Cru7qkvuqrwNqSwqpTpmWsHoisytqlzNqsQwGtB0Gwl7or0MKmvkKH2lqel7ZZltUwynKukqIsrtocy3EchzIp2aF+MAIo9CVBC1GvAtCkUdp2E7mJNnVoK8uoWfKBj7GnzSqpAOCsMP9hsEuKsNYKI2y1sHinrZ16WRB7VxJrKRR7sWSCtBm7ARsrKR3rBB+bACHLq/VqslCKsmJFhiy7qC67AzDrGDI7szVhsytBsA26pAKhfurnighnoBxaeiwViZEIIWICMQ0SHRy7AWEKElOXEPearwbQqKmhE01AuAJBtlVxqWmrtmzLkPf4cbIYt3JLtzpit+2yHHm7tx/RtwLwt/kquKRBuIZbs2LKEzEKLeqzEC3in/jkpjgXtA1LV45DKOyaQApkKDzQHLWbM8SSuTQbEySrEIE6qGo3VCaqqPanU0IHuqMRpliBuCtxupySug6wut/ZukNIdrAbu3I1u0awu23/c7u4q7tAcLQVeylOq7e/WxDBK7xMSryFeryAiLVo+ALMKxrOe1HQu0eqC53+2bgaap60FbHpwj0YayYzIr45kiDWcRwzG7ItIhCCGsEAoH7FK25rZp35RXEq1n9LprZqO344OIIk8IZi6yyX6p7/225tK8DSRcDbMwQHjMDRocA14hwNrL6aG0EUPMEBsLgX7G8ZTAAb3IsK5sEHkF8grH4i/AEkbMIP/CO+ihNLCiMNIYTFoYLce6NB6612ek0ydHeztE93tkJivEUus6eH+0BmSsUL4blUmqj62X/+qYNNTIKKyKelSxhTDACXasVBSKBZ7LCxy8Vw6sUhIEth//xFZNxKZjxIZKPGpCsRbezHSwrH/eiHffhbdPyddix+I0yAtLTDL3WpIPyIciuJpyd9Bwpb1fbKRYBNsDzLHcXILSPJKnqpmCys/QfC7Zh8BpjHpAw8psy4TJXK4MjKbytVtOxRstzMsGzLSIDLe6zLwAq4MtXLIfzLAljCwry+GJPCEgQUQsiwdyV9dIqjc1pXdPhKjezIaFxN1hSJt0yzJ8S5fnvNvNl/A/k1DkHCU1iApRiJw/wz4pyTNXrOt5fOerXOdNXOSCDPjQzJEb1NiETP02zPgIbPnavPqcnPGQkUAL2DAv0ABA3O6FPMMALAkYePyhyLD92NAdzSkP9LiXsFAiBAuDZrzcEKdBx8AE8UIGEqjMOofAVYpHusJipNBSytjC59e6QX08m4oU9Nmzit00ltyW/s0T/300FdA0NN1A+wfEetxxCkgAuxqdrjqdO3vSxoyFvc1oe8zt5a0BQBqCebgWbYdgFiUzy0oE3gFPvbFWjtAGrtuqAp13GtxYWs2HHKo6Jq1xOB11er14hqb319AH/NkYEtF4PtGkLCeEWAzKsM1cuclqctlaldjKfZEMJKRamhl+gT2sf4inKbzKZd1ZDXynC72pl5EkDx2k0U22PUlo1oBUslehGInsiZexsKcs6te/CJW649v/+GYPo5Y1IUe+BpEdH/WRAXQ5jHndxNpVLR/W7U12W47WPpXX3T3dpYgLwuBmPy/Vvbzd3/6d3vOZzhjT7sptxe1t7oLOALTeAgx9rW1RCgqGDfFnzdiUQIbpr18t/lPcAGDnnnfW0X3mUIThBAseAF1uDDh8G8JUURnptkpD4NwYAc0GqD3LDLDbRcyNZ2uGk6t79sAuIutsmYfTDVU3kToeJYwOIuXgRxXeNvPeM9qeRyWqEWkePGa9kq2+NP5ORATsVyqIWXFeM0ruEwzuSQ3eTyd9e9CuUyxuP4x0ZWfuVHEWxgnHe419jo/eVIHuaQfeNZ7atmvuN7TXhqPuZXnuCdOZ4Z+rjrvdup/63eie7ewymdl/egb1lcQNTht6hjZ+m4Tl3TL63puc3pVPnbulndWRnph1VFJwPqgf5p8UijMl16zG2er67a0H2EIrVXQoK4Ql6894af9VnfDK6dvU58QPTjqW4QAcrqU+3l5QnrtC7rCxfrIGXrVoDr43zc+AXs3Kli9Jlgw25CWZ2Jls7CmG7eG+7CcLqtrl7uIEXp8VnE2U5gDq7dk47qxR6f5J3s5A7t5l7jzK7vKMXulufu2f3r3jfwJk7v9Q4UGnGWhILauu3wnr7vC8DbqHfiH66VXCW/QbWOKF7vlrfwhB6Viv7wqk3yLkzx697xHjGd6EhYHA/wj9SrZv+UpzRf82DjFvVEFmpl85ehVlfuqzPP80KvoLKd8/a080PfGD4P5LiJm0n/9LSBm2Qu9ZYH9YlB9T8vAA3h9Fbf9aOB9QUr86jh9Vev9Y0O5FhB9mrvGGnxmkG/9hZjBbLNexcF93b/F21/9qcZn3d/3HOvenshBYI/+EpQ+EqQBIif+Euw+Izf+Ezw+JBv+JJv+Imv+I1/+ZAf+ZMv+ZWP+JeP+ZnPBJvP+Z3f+BLu4XlxAap/Acu3+qtfgIb4yePn+qqPx825hIE/+IJP+pX/+Y4f+qNP+aXv+4sf+qIf/Ic//MRv/Mif/L3P+KdfckDh+q1P+7Af+zwYgLR/Abb/v55XLuQwAgVQ8ARPEATmf/6dn/6J3/yIf/7or/7pz/5J4P7mD//xj/ztT//p//hrLqKGTQUA4cSJBAkXLhBEmFDhQoYNHRL88AEJEixYmjQBkFHjRo4dPX4EGVLkyJEBAjhwUJEKFShQnjwJElNmEpo1bdpUklPnTpoyZ94ESnPnUCU9fQYJGpQozyRHkd5kwqTiRZIeUa4USNDgQ65dvUacOBVjVbJlzZ4lWbFiFLZRlryFmxQoXLp17cq9aVdvXbw29/5dklQtFrQAECAYTPDBYsaLLTy20LgxZMgjRpDAnBlzRM4fFEsOi+XKlcKlTZ/+OLitW759aQLe6/o1/+y7smnXBjq48OHEEiQzpvzbMWULljVr7hzxc+PQo1E/h47W5OCWTmUnWarTqM/r2XNu/+nae9GmR+cuGVzxbHosWg96hR9fIfvo9e2HnK62unnZ48HH7M67/54ST8DyuMsLvfTWS889+R6Mj777JrwPJfYuxDBDDTfksEMPP/xwJZSoEgmlKqqwEEQVV2TvxBHHojDG01JksUYbb8SxQxEdIDEkE1FMKUchMXSRRxhlRPKsBhqoiLchn4QyyguXVC8twgCQUkoqr0yyS7K2dDJLMcesccuqqiRzSDO9ZHOkFzNKIIE326SzsDjnzAhPkOa808g6MxJAAD7l9PNPQ0PzLLTPHg9l9CNFj9Tzo0EjZTPQSQtt9FAJM+XUI5PysyJUKxjUrVMssVhpJVM1XXBVVz8NoCJRRzVrU05VStVVsgICACH5BAAGAAAALAAAJgAqAYwAhv//////2Nj//9j/2D7/nj7/dxf/nhf/d//Y///Y2P+ePv+eF/93Pv93F9jY/9jY2G7nhm7nYG7Onm7Od27AhkjnhkjnYEjOnkjOd0jAhkjAYOe2Pue2F862Vs62MNieF+eQF86QVs6QMOeGbueGSNh3F8C2F6i2Vqi2MMCQF6iQVqiQMMCGbkionkiodzDObhfYnhfYdya2bia2SAC2bgC2SDCQYACQbgCQSOdgbudgSM5uVrZuJsBgbsBgSLZWzs5IVs5IMLZuALZIAJBuJpBuAJBIALYwzrYwqJAwzpAwqCYmJiYmAG4Atm4AkEgAtkgAkCYAJiYAAAAmJgAmAAAAJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAj/AAEIHEiwoMGBAQJYWcjwoMOHECMeZNhQosWLGDMWTEiRChWNIEOKHKmR4kKSDjmaRMmyoEkrLWO2VLnQo8ybOG++1AnTZc+cGU/6BEo0olCCR4sqXTowqUCnKKFCZWpQ6k+qSq1i3QpUq8wHD5YsAfuyrNmzaNOWFQtWLFeibcc+UEu3rt27ePPSZRt2Scy4ZPUKzsvX7ducgOcOXsy4seOFhf22FCBA6OPLZZ9ePRyTsmXMoEOL7jk1pGfSoy9r5ozztObUsGPfXf1V8UImTHjwGMG7t2/fJEjo0BG8ePHfyJPzDu7DB0XDrBHbtiIWgnUIFbJrz249gvfv4K+L/x+/fXt38OjHq8denjsE9OnXi2+/HQeO55JvBr6de7fy38ENZ5xx/xU4AnPOMQRddPpNV9119FVwHnzeyTcffRNSaCGEGL5HYYUbshehffhlxZARRgyn4ooq5uDiiz300NyMPrBo440vvrgTg0VRFKEFQAYJpAZEFkmkkEL+GKSSSFpgpJFNAskkkk8WGaUF2dFAA0VMUYTijSzm6GKMNDYH5pk6iJnDjjx2xdCUQlZ5ZJRTwhmknBpcaeeQcupZgZZcLkXREIQOIeCAiCY6IJiKIspmmzhRBN6VlFrwIXxNYlpplJeitymnl9Ygag2BmrhQoYYS1+iqxjHKanCPQv8qk6TffZppp7UiqamtQeKaK69AdjoqqRWZakURRaAYI5llrqimi8ixwMKyy5ZZY4trriRrpAwRSQEF6kW4XQbkllvlt+GKq+645ZJ7Lrjkrduuu0XaR2KxPTKErLLVNoutmtFOS62M/g7nYqzbskSRt/BeqO68Gbyb7rryzitxvA9bXK+9peZ7aqGHvqoomiKTgHDCIlGE26TA+sqykLva6vKvMuM6bMdEDQqyqiUjSrLIJ6MMkspMvFzzzLca/enM3gFrqc2j4uzmQihWbYSZaOIoJrM0Zq1D0EIHZdKVePrZHtl90kkf2lWaXR7a9nKMb84nWn31tV47uzXBXWf/DXbYF73E9pNubzc4lGqfHWXZib+9uAZx31saSZQ5YLkDXhqBKhBA5BiwtAPzPaPBzwaMFuAQIaD66mZlDHG731Ise3mvzxv77NrVDvF2L7yg5e9bWlFFFTlVfnnmm3f+4ucCU2st6QD/Ju3pqDu0Outlua777bjLrnu53OP+fbu8+w588MMrtZ8VKKLqvvt2xy//+/QPYfVLkVXvUGIvRY7DsKI63+/8R8DIAbAGAtRSARf4PwAmkAYMLOABFXgf6uQHKOtrX/3gJ78OanCDhbqfSfKnP4PwzyT+m2ACI0hAFQqQhSl04AphGDcV3mtBOeEPBzgghB4KAYT186EQ/4fYQyC67yU2AYAUpFBCh3yGIgeMohRHpaUpytCKWMyiFrcoRclthlu42aEQjfg+Iprxh2QkFBI/okQmNrEqqIEiF6VYRS3WcY54zCMXvWisHXrQbmkk1B/j9z6z0OaNSIkjQ2I4rAeKiob2ceH5HglJSQKPkjSU5AUuMLmWUMSPg/wgGUNptUJmBgCdrN4TF2lAGQoQkzC05O9gyUJZ1hGSDWzk7zaZyqgwZIdiHOICFqCAYhpzmMhMpjKXuUxjHhOZ1EPkRMpigGoa4ADYzKY1t8nNbnqTm9jsZja1+c1yfnOc4TSnNwUoAQlMYAJSi8kngUnEYTqzmMzMpz7tef/PZEZTmj55yTbReQB1GtSb6RwoOg96UIIydJvsdCc85zYrhqTgoil4XwM22oB9DpOjIA2pSDeaT0MCFCICfahKz1nQlbr0pes83yZ5SVF5WhSjGuWoRxcw0p6GtKSnPKkTTQJTmCa0qEhVqQBnysmaoiQwYeQACEBQT33eUwE7zeoCSlAC/F1QqANZ3xSmkNRrkrOs1RwnWq2pVnUu9QIucAFkvtoSqDJhh1Otaj6vqtWdctWrYDXhdMZa1rau1bBoRew33xrXuebwl1IFAap62NfKIlOk/jTJEgM7TYoQdJwFCK1oxfnZ0oJWtKElrWlNi9rUgnO1nx3WDGbwTgz/YCCenoTsVCcrBMtaFrPQ1KwbOZtIz7K2taqFLUFbW4DkKve0qHXuc2VL2wnYFrcsOc1C8AqC+Pl0pMv8rngbYFLiAkC7DHluS1mqXoeWs72fNad6YxCDSI6KqdgdCXq5693x6lSZ/vVpeYmL3oWoV77wXeh7E6zY1yqXvvYVFX6dShK7ApOHwiRmP33LTL5utasjpCtYxUrWhzaYoUdN61kTu2Kl/k4GMmhnYy0oHR3SM8Me5rAyPfzXEJtXICRW6Ykbul62tjipQzYo8GAsY7nSeGpWuHBVc6xjZFJ5wOZNqYqTXNQUm5XLQlawi4HXznfmlyTzDKYQ+enMKu94/8PDxDJxtfzlIxe2yFu280vdO+bflXmivUwZZNXswza72cpwVqacOUtn9urZpXxGsphfescavNPMFPbldm8sREMfWsOeVnRQf9xohE4aqZFG9alXWulLA/qLJLEcRS4qSuDmM8A9BerfTlrqtfoarVq6gbBvwNC30vTMGpH1TWv9U33iGrzMXHRge/3rasM02MMutkxnuuuRzPN9laWyjqUNVmo72ssGRbc6U+1WGlRzNIfM7abB3Vdxc5jcQjW3qcFsakiv2pxaerdo4q0whuzWfR99tk/DK15885qodYZvuhmM531Pl1jwRiWsvW1wySKcpwrPNYAbPuosQ5ziFf+X7oHX3V5RwYbgvhzeBjZAb9/aW6svSd+PX8MQoz56zz9XqctTIxCd21TmNP+4zRNd2ZwTb+cap4jP1T31lL906Bk3ekuWuMQdEmrNl/3vpxNOUpDHmSG42SzUX7Ja1BKAACp/rtvh7uAEz32c/FmiB/bO97773QNqLItHcJMTrkvB60MAO9k7OvbFJ/zseR8uqU3SdtG+Pe7KnTvmYXv3bEb+76Dne+DXSPiKLuTgqGJ4yG0ddpE6HKClRvnEGTx72FIk9CjIve77Pnpt0e30Hk/9yFff7GT29PXSjD3Fay9xliv39qDX/e5FPwTkazrKHMgp8ctufFxb/436lr3/8xPMfHRSRAQiCP3epZ97FHW74PN23/bF3nr/fr+J4V/++JuP4NKeP/3qx34o4H6+5zFWgHqFwn3Otno7dX8lpG/WFoHq5EV71wEWeIEnkIEaqAIcqAIEiGzwd4DBl4CMt0/E14AlN2cQJ4Es+FAU6AEXiIEamIEd6IFG8H7XR2iU1WFMV2VX5YD6A4ELxm8o9m8rhXVWoH7q10MgKG/Yp1dvFmpu9oMpyGgruFLsVnVU91BIqIShx4SZll2UURlWcFFTxWyqB23zB1JAKDRjSIbGVVr911L8Z3G0Z00UJGwUsQIrgH5++IeAuHc4KBJvuBBm2F2aQ4JpCFxryFFt/4gyhUh5pjWHeaZcc3iH1ZSHN7CHfQiInoh+gliAv4d9wYQsyLJ4z7ZT4/WIgCOELWhtAWcAwPMYMMcTm1aKpoiKuKaKJDeI+HeFrxiMsuhuwwgojlGLdaUYUYV4X9db9aeAbgZcPVYiPxZkEddezLV5lRdddUdQUmQDNrAYJFRjVrCM2VcoO6iLjSeNIEaN5mWNKJeN3YiNyDWP4/SN4TgY4ygTqjNPB6d4IHeCCyhS0yiKKih1whiMMAADwuY/4IhsrjEQykYU/ahbHgeQ82eCI1WQTQh+wJiQEbiQDRk5DxmG50WGBDGRgjJoGAaQWsV6vsWKYcN2B8BcXsZgNv9ZcTjZWkd1QNdlksUFlDnIaT7kWzBpWTIpNDSZk9r4WUxpj5zHk0Xmk7cllDwXaCFxOZhzUwhIKNA4chpJfEnZEqpzlRtnEFrpiiC5VsAjbC3QAh25FWnJlSPolSXITF/ZfWJZhW9RllEnlHOJkGsZjG15A28Zl4eRZi1ZlIgmhT64Yb2HmPkCR2IjmERGhJcZdAd1QJiGlayhmFB4cxzmYZFplStJmRihlpVodf6GmebEma+mSixJRPg0dqI5TKUpG4uBjENlmQrlmvtHh6yZmdh0QO0kmVwBmkNUm592mwuQm7opGLzZWT1nh8MZZm21heVnnBKAnMnmAGABFgn/kAAJMZ42FkyoIpDJ9AEfwFUgxVXwGZ8lgCIcGZ1nMTxzJRaGgUMAEJ7h+YZjFaAlNphJtZAGCgP0tZAQhgMwxmQSoJ8iBhSUcT0CYTn+OZ7lmQDniWHpyYDKxJ7uyVHyKZ/02Y72iRb4aUEQKhD86Z9gAaACOqAEWlQHqqAxYKP20aAx9qD6iRUTujoE4aIuuhBL1JVDAFK62IgJN6JcVUpDEARBkDc3wjWjkzfW4hsQuiAJkRBAFp4D8KVgKqC/iXJWt1r0daYxcI9URIzbhKZuWl/24qBZGqHFM4ZBKqThSaRSYKRIGpCN+F8bxaTzWTWEAqVSaiNUijVec6W9/zGnBLGlAdClYAGmYRqgYyp+m/emahpAbGpNb4qmcSOnWeqjdhpW4ZkQkzoANqZ9u4iXq8cAsMoAxaQbREAEoBM6ogM9pdMb0nKroUMjyLGiB/GG/vmGlCGmM9qmbmof9CWOS5CfPQoA/IkV/omqD/Clqyp/Cndrrxqrs8oDteqrA9M3z7I8vNqruCo6wRqtBkGs/2msyJqs1fSmzBoDzgqt+0mnVEEZdyqeGmoFRVqXQ5Cka6iLIRqo8LlRqIImLjIczZGoeHOoDasDwDoCwnoRxSoAAkqmw2mmaZpN9FpBjyEWjiWt+koU/Gqq/qqnRkqwGemnCPueCdsAC3smE//7sKKjqBKbAw47I7xxsRaRsRtLppeITvQ1TiGLGST7ZNP6FtWqEDfFquMVlqvHVd8ars3TL+S6q77Rq1kLsRULtARhrAJgoe8ar/I6r2fqRc66tATRtFzxtLOWUdoaYFQbclarALRqq1+bs9dSrszzq9bisxbLrgVBtmb7ohprqWnrqWsrsowBoUkBt9Eht1bgERc1RkfqodwacrCqG7qxAzvgtYK7tdHTteg6roPrqA/hroqLtmn7phA6VjPIh7Z7u7b7gQoyqpBiuZibApqrnq7quQwAujwguqSruqYrJoGrvGXCug7hug9wrIzbuAYgu/pJuxqIu9y7ArqLryf/uxRcCgDWCha4EVVQ2HiVBVJGdEZFFEhl5L5W47Ymi7EPkBAQqmKrqV6h9XaXZ1b7+1lHewDnywReyHfox4cEKLY8Mr7l+wAFrIPOqL6/xVHt677wG79nNL/P2hOUe6f4q5/6e438WwD+S3fpNF8fW8AHvHcJ7L03qKLhexjjOZ7+mXZ7KrACWXaNCEKkBEij9MNGQL+UK70e4RErd27kx01oyomf+IkKHMMM3CY1nAA3zAQBK7WtysNr6MNCLEpe/MNErK9GfMRJbJ11qLbNyhB8+MSeGMXQKjRPu0Tom2HJ5Jzhdk9cbJfua0Yo0seaC0JCZDW6UbIf3J9nW73y/4pNaDpbLMx3MRiDe3e7ujHF2zLHUlDHLglqz9Scesx4Cru5gDxEfzzKaCTIPkTIPGDI4Su0ipysjHymjny+fRfJFzjJtlvJhuuR8Sd8n9anOtaMPQTMY0fM++SLBDF4TNC/dHep9MjMeZaTBwR9Lcx3yMwj36Z0h2bMliXMQsDN0Uh/x2yQF6HM0AyVmWd5KJxN0gxA1FzNHnDNDEIRZ0iom8vN81dMXylyLrutw6dw3slzq1V+Z5yJxEhJtKhxvCyCTnqU+awA+wxt/ZyK//xsAf2XAx2cBT2M1YTQx6jQQcgQM6e5U9iDOobH9YZVVpVoFx2HmlmEXPZACe2Z2P8s0htA0o/pmCdt0qOp0nvF0qYJRwZmhK35czL90TT9mQxhAkxtAv1ltwPJucMr1Ytof0EtkVu5ENaLbSMZl0mhkrK5EE3t1HZD0Z1L1RXtz2cdYN6pbFrduFx9A3yUmlcB1iFtiBjV0BId1WbN1616t3+9AC1dnVv9O3p41fLMGXNLa/bMz34N1YAN2Y/tX5mV1AFlBdZr0NgmmYmdmHSp1/j8p1UtvBMd2JB3lhbhm+gMW9dGAx5t2eX22Y1dfM+4faON1n96l6eNZoSNxs/V2q+N2jtHz1Olw7oNs7ad1qSN3MvNhlcdlE0phxqNTjWEccK9dh3Hp8ed27cdct3/rdb1N9hv7cwb3ZTVfdHSZGGR1UPIsoMvu9Ycpc/iFdmmrdwN0GOHvD+KQViNS1/DJtcVlN/Epd55JQTt7YzvPdUgJd/fRd+Sfdv4PcMHERj8Hbsx8N83JOFWKNYmwNhWM7WT/eD2LeJ6uXpx+YZujdmZLUDojUgUwdQeXjUgDt99/d0zruAAbZoontUqXtiz+NzTZtPMWChLp9M9beRF3slICeQ8h50vTWTTzOSwJ+Tn6MspjeSWhdJapeXRJuWqXbSHdQBRDttTPrfMBs4jPt8etdw2vnBdztkfmaz2IWzG2OJhvWyJaJdoXuI1juMknuYN/uaIHeczOuc3UOdS/w44SXSijN7ol8tGWLlKjk4Xw6NzZF49iz7pmg4bmR44irTpKFrp0wlW48kXoH7qoIEbcSERJ4TqabGP5lXqcuHqtM4Yqt4XrN4X61PrXrXqUCcQSWSWvD7sZ5FEagcRKkETxL4jl446wf6Xyx7tJmHskpcSUKvs0v4Zvx6UFPEE3v7tSRDu4j7u5J4ER3Du6J7u6n4E5d7u4r7u8I7u7u7u8R7v807u1/wSt+uJtRzJM0iDHci9/A7JkYwsY3nn3f7t3n7v5V7v8M7w5O7w6w7x4y7x6k7xSZDvJrHvgUjwMfjvJ1CDAt/xFVjwRXDw+pOyCb/wDG/xGN/wEv/yEf8f8zL/7kcgmYFpBZ5oyx//791ru38YAiFggRloyzOou9seESrPEAoP8S5f8+H+9FAv9TV/7jh/PAyx8zxP9D7/852IfkLP9UavgUif9EbBEFAABU7gBEjQ9khw7j8Q93Jv8efu9nbv9nAv93FP90dw93ef93rP935v94A/9zfv5eVowPC8+IzvAejXe2af2miv9myP90eg93tP94Nv+Zj/A4K/+W9/+Zj/+Ztf+Jk/2LjR+Krfwo9ffYk+4IoRBVHQBE2w7p1/+57P9+iO+52v+7vP+4Hv+6Kv90qgBO4YtNOR+jDI8/2+9Ra4+n3Hh5VeBQKe9IEh+7Rv+8Bv+L7pv/3cr/ven/ndj/nFf/y5TjQlb8vN7/zQz3fSX+nV/2Mpnu3ZPuoAoGzzT+x2HfkpyeP0L+0AAQCAFSsCDR406MABQYUEHT6EGFHiRIoVIzYsiFDjRo4dPX4EGZJjgAAEBVpEmVLlSpYtXRJMkMDkRwECCNZ8mVPnyYwiff4EGlQjyZk6jR5FmtRhzJkecVp5qlQqRJ5CrV7FyrGpwa1ZvX4Fe7ArACpURI4dG9ZnlSoa06qFCxZtz7h17XocW/Ys3ap3RbJ1y9fv4KARCR8+bBioYsQgGTeG7JhqZMpyJ/98XBlhZs1AAwIAIfkEAAYAAAAsAgAmACgBjACG///////Y2P//2P/YPv+ePv93F/+eF/93/9j//9jY/54+/54X/3c+/3cX2Nj/2NjY57Y+zrZWzrYw57YXbueGbudgwLYXqLZWqLYwbs6ebsCG54Zu54ZI55AXwIZuzpAwwJAX2Hc+2HcXqJBWqJAwbqieSOeGSOdgSM6eSM53SMCGSMBgVs5IPtieF9ieF9h3MLZgJrZuJrZIALZuALZISKieSKh3MJBgAJBuAJBI52Bu52BIzm4wtm4mwGBuwGBItlbOzkhWtkgmtm4AtkgAkG4AqEgwkEgAtjDOtjCokDDOkDCoJiYmJiYAbgCQSAC2SACQJgAAACYmACYAAAAmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACP8AAQgcSLCgwYFVEio8yLChw4cHFS6ESLGixYsRJVbByLGjx48YNW4EmVEiyZMFRaJcyVIly5cwW2pcmdBgzZghRxK8ibNnQ54IdfocSjSoTaEggQpUWjTj0aZNmTKFShWlVKQdE2hNkFCryK9gw4odG9Yr1qovEwoQQLat27dw48p9axbkVq5VzM7dO7cu2p5q2fIdTLiwYYl+Pa5N6MDB4ccaqVBZfPbvx7WUG0PezLlz4KkYMzv2bFgyZcssMQvWTLq167inWT54IDFKFCFCdOjwwdvHj9/AdwgfTrz4cN26e/sG/pv4b4lMmKDuOVuiFCkmsms/wb37iu/gw3f/7669/PbxJ8KrX4H+hHnz7deLR/++fPwVOXJAly6btkLbuCXXG3PNGWcgccjtNiCBzv2w33Q4VafQde/dJx979NWXnYXytafhhuhd+J2HH96X34M4SXTEEQUKl2CCG8QoowcecMCBbjLO6IFyvBH4A3EuQQiYQuFpoAEFSCb5oXYqNOnkekYmqeSSJjj5pHpRSkkBlVVaqQKUR2qZ3QwzmOSTiiz+eNyLOOa4AY02tpkjjTwuxxyQMwk5ZEJFhikll15+iaWfUy4ZKJhabknloYMmOmaZE71EWUIrrnjnDmzKqSOdPProYqa6BalnaoIl1GR4TWaJJJfZMfpdqoSy/9qllaiqoKqigHpZq5FNkokDDmbGNGkVlaZZIKhuvknjjp0yiCmoOog6KkrDngoerH+y6uoK2Ba6qK7X2hqrtuC+Km6vM/waLEsBtOtuQlNMMcS8Q9ho770cHGgcvvz2a5y001qlUHsVFGzwwQgj3B7BCTecMMMHL4yewxQb3B4NGNOw7knuvltFvPTW26+N+hY38sn5FgdwwCRJBHHFDUs8HswUv1ywzN3R7PDFGW8ME5qWqlmycWz26OyBBa7MckcicTgfiRUufKHEGko89cJVS61efidGmqJCxbY4NIIvGn0p0moqvXROLofYIdb1Wf021PBpvR7VcdsNHtf6ef/9koS2hdxDD8kWLiPJw41seLLPKRTd2iBJmBCF5iFZcaKO1mc5xZiLqTkFl3fubXbZkklmfpI9HqF/gdM7+OKFIy6c4rDL2HhCqkPekeRVUF7e5g6LPrp2wDcs/Kqfhy78e6WbjjoVucPUrkQhz8sDDyjfW3L2+P5mo1i6VzT9VxXjbDPM5k+s883p56wzCyxk3LPf7AZAffXXcy+7gfrb6z0H4AsfRMYnkvK1jzvrY98BE1iBAyLwffGTn8boRxOwFatSRMigBjfIQSJc8IMX7GAHwbKUygiwhCWUiARpYLoWzgBjfIuhDHOwQheaDoYzlCGZamjDF2ashz7MYQ7/5eeztFjwgyJMogdByEQlapCEAADNCaM4EpHw0IY4FGIMr+jCLGoxBzuUIBDlN0YafHGL85MiSSTUhCZMYAIhc2IGq0fHOs5LjhpckUTiFZ3ZRG+KAmlMH/0DrymQEYiIDOMKD5nIMi7yh4105CNZ2MWMde2PKGGjG+FILzza8ZOdxOMS9ziFQWJyioJkAu/ixchIVnKSlHTlKycpSyzCMpY3tGTfTtkyhYAABMXyJL2KQMwiMDGYclzRvKCoRgHeRCQy/FUt0/UrHGhRmrWspjWFiE1ZavOaOAAiClDQzI9I5JfIdGLIimnMY64Ij8ocAjNNeMJnaiSa4cxmNcE5/81vcjOf3tznP8VJTnqeRCIdSGgHOriAhjr0oQ2IqEQnSlGKPvSiFw0gIH/yFQN49KMgDalIR0rSkpr0pChNaUptOM4a1KCIvUyIQhfKQYxCtKI4rahNbarRjZZEIyoNqlCHStSihpSlKHApTD2ilyrMtIM5jWpUMTrRhirgqgpoKBR9epC7iOQAYD2AScNK1rKalaxjPatazZrWtbpVrB+1YQpSYAMbLDUreJGpQqEq1b5W9aJ/xWpWF7BVrhbEqxpBa0nf+ta2Mvasjn1sWUEqV7ralYIxrcIb38hXv0qVqp4trGF/mhCUSpatJz3tZFOr2rCSNIz5metc7+oRif9sdgKd9WxOQetX0Y42JUBlbWvhGtnTmna4xD1qEHMg2xTQlmkKsYB0LfBB3e70ujatqG9/GxSJGPW74A0vUWVYghJkIAPP5YhEpkvdC1oXu/BtqHa/wl2GiES8+M2vfj1KXvOiF7NJie50q+tZ7Op2vmozLGu8u98GO1ioSB1netlWBfYS2K8GPvBEt/vbBSvkwSAO8WtdOE4JA9icCrktHXcq2KvG98ULECyHuXvf74LVwTducI5VGuGCllO9Kd7sim3a4sHCGLsypm99j8Jgo+5Yv0/Ob5RP2uMJQwQBCLDtBBI6R3rdVMN/3WlFRSCCGRsWyzUWsZpD3MJfuVT/qSfmCJqDzGUihOzLYI5ohidKZjNzdc5NXrOg99tmHLz5pXFGcUJuu8F5xbfIR4avnw2b5vCiVryXtvRqRYqxFpbYxwaF7qI32+ghPLrFkcbupLlaafBm2tWb1rRiOY3LT1vZIrYZdZcdvYAwp1rMEt1pbWwThSUThIAKUWsBll0AAhBApMg9ALOb/eyQopax03Y2rWXAbRk4doXNTUgbbfOSXGsWt3b2cq+D/evr+vqhwya3sQWC7IQom9natjZys11tkF77rfzedre/LcFwV2HcxZaJrjmo53bzlt2qVvK8U5hsgE+7AFMe7sUxnlyPavziZPKoZ1AosIVvsOEO/8czyq+7ap9+1eLTznhrNy5z1W485AYYORVPMizpXrjA7s5zA1q+0VYP+ujqIg3JQdLz9hZLw3sGM9EBafSjCzrpOv/xQ84JTPf2NepQX7dIJDNxAHi4tFZPO5laIxCyl7wK6PT6Z4OeZ/kOPTJUKPvZq5B2tUNK524/iSYTOuRI67TdfdYIL0e7yimQdePQ3vfFI//xaUf+BS+QSBslwPnOe/7zEtBjWBaPkcF3oPBHPvyvE4+ieTf+8ZPXd+WZTfmZx97fB8C85psA+t53XvRgIT2QR416jLr4upBO9dSnWPWgzhq/zwevRHxPfQksE+97OnfxL3p8FqNa+RKfeP/zVRp9WXf8u9Ovfu+vL5HAKxzuXX/61+Er9AZoNfzzHn/fQyyRC/j/AiMQgCNAAgRYgB9wgB+QQQl2UL4Uf5WCYfQndPe3gJQWXPt3dP33fwI4gAVIgAiYgERAgQyYEHEnf3OncvUnUctXT4mFXMWlWi/4WBiTfhhQgxjQgR6IgAQIfIkWYCTogCsCgSiYgncngi7XgsMVg5KlhG81gwrBeTZ4gzj4gTt4BEZYW1UgGZxVU6mWfA43dnlXdlQUaOTnWlBmhvnlhAmhfusnTx8zBUWREFqIbhv0a17YbmAohmP4YUNVfrA2ZeClhlXAhqB3ffESh+e2hXWYcnb3bpL/hn/GJhLLVnOnRXPJZYm1J1kbt0LpR4idd4UoxmhcyIiq92Ir6EwaMYnnN3uqCFKYKHuVeHGc+ISe+Il5shJ3oUlvVGcnJ4GABWas5zj8wV3tohW8cx2Z2FpMyFiOhXkYg3l8UximNIwkkYv+0Ua7SFO9WHe/qGHBiDvUOFrFmADHKAXJCIOLFW3nh3tg5Yw0AI1cI42q9ADCp2hOtVcMZ3/dSIT6iIKnGD4v92ojFW3HlYRxVUk3cAOFsXQ/oxBPlY8PR4QRWYS3KH5IGGskRZDCpYwH2UIYk5ALuXP1Q3G/VIIPOH9DmIL/yDJrQXH2BlnpqJFOtlaYB4/5IT8w/wADz+UXiPUS7UKSJflzu7WP/EiRt6Y7LbmHLymQ7OiCNkaTNck3OKmTicaTW6F1w5eInDQvK4Jk38eIVoVVKwk5+geImoZjYXVI53VroJiVKkYvXYl8XwmWSdaWLEiG+oaWaAlWavlfWKmUoeaDVQABhAkBd5RujHiHMDaWMUFKWYl2M2mWkbmOK0VioKY7ElGYhjkEXZaYc7mYkAghjklhkFlUfviUkklllnmUVKFlioiYL6aY7cZ+FSmaWPGX+idUpzmZELaaPWgZrkmHsHlqggWWC0CbrDkkT2ERuel8aAh9z4lSSJWcl4EZs3GdhHSPvKhBYOeLDUVm4CkCPP/4GnIRHeAoEKqjGo3RGNg5G9fxnuZ4gWw2A3xzXtFRj0OhGu2ZnQ+5iMAmkQ4VnmQ2nuQJF+ZZBaqTnpixng6wn/CJjPIJYqfDNfZ5n9OCne3SRtgoZK7TA8VpnDH2fQ03oEfwjQWKdyJxoAkajgUxGwz6oPEZoWXocWHlbIoVAzFQnxlwnyyKGhgaABq6SW8kOB6KVSAaoh86ouJZomV2omAhGSnKBOcJAKTnousJozLqnDQKVjZqhjiqozz6Fz86juLWBNuZQbrVfdynACsXlgIKnldFZhmEG7gRBEEAI5vCLHVyKdCiA8liNj/QJjwaHVjGENipGmsBn1k6Yr7/ggMu8KiQWpMv8Kgt0AI2mQM4WqFhSipJSRAMKhBjGgBm0UZnSgRpamRr2qYh+qZkFqciMKd0aqd4GiPLoqfNcizQ8qd2Eqh+ugGDygSFehCHiqiKuqgiVWiQGqk1SamW+gJ8k6k7OqiSghkG8akAsJ/YmRC2UaqO2IhCV2Su2lAhMK7kWiyfgix5WieAeq4vwhxz4gHXER0MqhoEMayqUawilqzJinmPKqnwqHt8oaLSSqU9ShTYep3aGgXcCnFECWbgqgBkJq7kOq7m+izoSqvLoq67yq4J4q46Eq9MMK/UOhD2ihn4GmL6qqz96q/5AbB7IbCbip8Ge53tQmxR/zCk1XOkDldRG9Q/2jM2O9A/HrupFYGdAzAA8XId0cZvijVckto1exEvCSuw6FmwUPGjNouzd6azv8azGuSz9gK0Qas/Q2uhFmG0SDsFSit5y9alOea0Udk3UTsFUyulCMofMjsUPxqkODs4g6OmnvmhMHZVfks4i4MytVM791K2eWt2DfoAifqexvq0cksYPOp+jRsTe6uhfeu3gJtysumVhQs7iJu4h+s/wBEjREsR7Am5AnCyEUq5h3G5YVi1VfGTAHAX7YKdCBd32zh/DVeUV+W1uGEERmA0ZPMbgCo2YtsggAqOpIe7oHqd1xEvMjmQp4V5ZCWpIoGD3ouDBP8KvVaLE7iruwHAu01gG76rQe8VvPw4vBQFq8aLvGuivLvKvM0rHPbLHOLrENJ7rdQrBdbrlBmZvS+wvTXZvd+7wOF7t5mLEliGZQyKnTZbZ1vrrdz4UMfHAAxAZhzcqhArAhGVRCtCTO7UREpUwu10wkdwoLbLuo8Lu0f3qB61rzXJoxGQwzr8f//nvaK3uqgRwQgwwddZwTR1wetWf8Y3WB8sAk3sqiMsQirMwkiUwkdgwlTswgRbEa0rw4NGwwZgw5iHwzqcwzzsfz5shQ48vn9hjbMRL9uqjeybgnaHwZ5FZlHsRFW8QVQcQslUKVrMS1rRMdgpw+pImVtaVv7/6q9B6nkHuMAd+MNmOy1u/ABwrLByjKZ0vG527Fd43ADw5Md83McY9McrEsgFO8juUsiSC4sGWcBmtciS2sid98iQXIX9e5fa16Gf63Che128BkqHmUTCLMxOZCZ/SXFSFp1FtXa0WIvW54buh4rEx8uoGrhGemTBbMxKVMygdMwTkcx7uMypyWN/N4jQHM1yWLuQo0kmqclC6FBFuXJR/E6m6p3ynILB+MASMsCvjL3DJT9dEy816L0fSIUk0Hrh484OCM8omc9FeVMZZM9K3LDe2KRTehH97HgEDNCtJdB9Q9BS2IEHrYMJLYziaD8OecTq1rUMa5zdmnIxHV/U/0lxsNe2/fZRS4tvOe1RGMOXaUQYDLk2yGbBLZ1qM91uSe3Sqgqa4rwTFQdWAefKsYjTtAbUgjgYQ02WK81QFo3PndyPScyPE1l/Nb2Hu6nTHU1SOXQYW702CJXJRFDWYD3WvjbPYh3WeXbWEpHWiYyOJtXWhvHWAVNIb1m4vdxuv2yHnwm6jQ1vv2lffIhpiKyaijRBuHmbgTkdhs2hiH3Nji24dPnYik3aE7jZkl2asGZUHhnUF3EV1KyV88JOev3Q/wlm8VXR3blhkf1TxmpDrGmXfxGcs11MtX2CdIfbEZjByY1gqO3biwrcve2Szy2m1yikW3nUGmzaXcjdkf+22N2deA88vZMTo2pdzmcI0hmthyR73W+JxNst2tic2Iwt344t3mzcEBICoU05aFhtRruU3/kXZK/p0LoN0WT91cx93Co43cC1lI9F2WolQ2dddAQunAZe13hN1wtu11HF11Ed4eZnVhTu4KPV2Vo7BH8L2r7s3UcG3t/N3SAuGbW3X6fZaT5U4VT3hu+t4kV6pDD+4i4+uDJu4kFB47Bo48zs05QkiOz9U6LYmTJtUSBaiqRI5U5d3Q/Od1SNbRdHiWo1i09dgaP2mry2s1gOllY+5UudUUauzF0Oc8wG5mcl5lrOVcjW42fe3Hmt5i8dmyy+3H8ubG9ORbaxbOf/+FiQF+f/7YSH+OQDkeccCt/ZleYwPejwRd98nuUBdugFkOhebnmMfgCz+Ohlp5/ZGcelxuDvlZJ/Fc+sDnQo+KYKDRGvt9aj7lbqjdITh+rDtp28tuEKzm6w7uEHbse0zutFm53+zJGw/NG6VOvGZhZN5aTWbu2J0RCUMSzXLhexMW/UnlfdPu6vke0Mse2lQu5w8e0WSd3q/u6PQdjLCe9wIe+/ZU/0nu+DLZIQge/6HkBjjplC8e8EPxf2DtXuXvDhfOcAOfAK//BkcfBGAZgQX0UMH9sSAQUaDwVO4ARJkARIgARAMPIkH/Imf/Io//Eqv/IgL/IkP/IoH/Mm/8/yLB/yLw/zMh/zNL/yNn/zJ2+Xw5bOQl+LB6iAGtFGkE7xVbDxHO/xLX/zQJDzOr/zH9/zLy/1KU/1T+/zWD/zWm/1JW/yQP8fUTD0Zq9+RR+CR98ESc9kVfAEcP8EXY/yUF/3UT/3Jm/3do/3dK/3V8/3SADia0iIZVz4EXD2EmD4tNn2HJUQcS/3gO/3f8/3ks/1gO/ylX/5go/ObGj4ZYz4iu+GAX/vCvH4SnD6qM/3qL/6rN/6qt/6sL/6rx/7sZ/z1Alo6Oz5EXDGAMiBBn3QnKf7vF/GojfNjN9dbx/3ro/3tE/7s9/8rP/80J/6Mn/7WUaLwn/GAbjAJf8d/J4//Dpc/Ox8/C3qH5IB9ydf+yav/iHP/kjg/vAP++kv/+tP/+0P+0uwBNLuEI0XhaAXhQCBAYMEggUFHhxYkCBCgQoXHiRBosrEKkyYAMCYUeNGjh09fgQZUqTIBw8mUqHy5AkSlkiUvIT5sqXLmDBn1rTZEqdMnTtv+uyJ86fQoDWXLKFY8eJIjCWTTpmC0KEEhgkVVp2K1SHCiEktMgUbVuxYkEnNnkWbVu1atm3dvoV7FiXGiUzrAoibV69ajFDJ/gUcmONewoUNH4Y7F28Vu4wXI4bMF4BfwZUtj0yQYGLmyJ09f05L1zFIzlVKg/Zc+vJq1htLn0YdW/ZcXtEiX2ueDVl1a96s72r83Vv48I7Ba480vph448Gjlz9nvjE5dOqWk08v7vx49ezNuX/fKEDAWfDlBTtwQB6sePXmm5+k4t49e7Py7YNF334k/aT3gVNUzD+xAgIAIfkEAAYAAAAsAAAoACwBigCG///////Y2P//2P/YPv+ePv93F/+eF/93/9j//9jY/54+/54X/3cX2Nj/2NjYzrZW57Y+zrYw57YXbueGbudgwLYXqLZWqLYwbs6ebsCG54Zu54ZI55AX2J4XzpAwwJAXwIZuwIZIqJAw2HcXSOeGSOdgSM6eSM53SMCGSMBgF9ieF9h3MM5IMLZgJrZuALZuALZISKieSKh3MJBgAJBuAJBI52Bu52BItm4mwGBuwGBItlbOzkgwtkgmtm4AtkgAkG4AkEgAtjDOtjCokDDOkDCobiaQJiYmJiYAbgCQSAC2JgAAACYmACYAAAAmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACP8AAQgcSLCgQQAOHBw5QjDhwoMQI0qciFAhw4EOL1LcyLGjx4wNLXocSbKkyY8iMaY8WRCkyocsY7oUODOmTZY1a97cydNmzpU8nzwRIECo0aNIkypdyrRpUoFCe0odKTRBAqdYs2rdyrWr16NEo0oVGvarWbNQn0xdu7Hq1bNw48qdC7aoWqlIkKSlyxdpgABi2Qo+uGTJ3r6IE/dt0kRg3qmPAShG/Dfw4MsCCx+ezLnzVsaO9a5N+uPHjdM3bKhenSOHjtewUcueTXs1a9ewXz/FzJtg0hLAgwNPQbw4ceHCSShfrhx5cOPGnQNnzjw59ebSoReXXuI69ho1drP/JW0atW3VrXO/ps1+9nkb6dWL7837d3btKbh7J8Edf37p+1l3XX/46ecdcODNN55RpW3g4IMaRCjhhBRq4CBtD2a4QYUVKkgfZkdNIOKIJIq4n4gUpKjiiiW2OMGJE6woIwUulgjjjCzWOKJyL7wglBNO9HZUgxpyaKSFG2CooYNHSujhh4OFqKOJ3qGIY4pTUnmdlVdm+WKVMV5JY5Y8+vgEkGw10EBCRwURRGnvqVYhCHSC0NqduOV2Wpw2VKibUTBBKZiabJ7pBAooZJCBlvtRh+ijKBAHqaKMNrocpIhK+iilX1rKHKaRpjDpop0u12OCTwS6FqEOtPnmD3zO/1knnvHpmVqcfupwlKqCTsXqj4cmSqqnjmKqKaKcEvupsaJuOqyyyoF6rLCVknBqeKlqVJ9RPviAAw4XzrYkk02WW2G4T/Y6FbBc4ujljWK+C6aYY04J75Uw5AvDUUJy6y24SYo7rrkES4guUuqCaGi7M8q7ZZhdkjlvvBI/TK+++xqFWVlCuelme7XdhueeIucZG3vpJhwTx0b555ylzvl3HHIwIyfzfwIeaLPMwmHM72UsexwEyO6V3BrJ6N2png7tpazySSwL5TLNjcbMM9UB7jx1zgNqXWBwPmu8rVDdlu2DkksWHGG4so27gdNPn5SUw9QxLCPdzNmdo70TR/9cY4+Am4nm2E+Y3S3aRarNNmpuwx13SXNXXDfE7kqeN+UNW76c3ipOGXiPwPZLtg+llcYDD4u37fbqS7bnYFOPx7QUd87RuyLttNuuIu7c6Z4i7yWwwALG+f6s8Oil/3B66oyz7jzzp73OVOwszQ58Cb5TcD1y2W8vXPe8C098xpZNlVBeeSWv/vrsG244+/CX7uZRjC30F6/US5RRoUIxNv7/AAygAAdIwAISsEcGHB+q8Gc+B6APCfGLYOncZzYJsm9+RqnfEe6nrfzpzyL8e4L/EkjCEprwhPlC4AkX2EHBHKUCFRCaDF9lwdLM8IYei+BS0uLBjoglKeAJohD/hzi+zwEuX0NMIhGJZ0QVggeJShRiEZsIxSgmsXhii5JRYIhDN9VQfl2coQ6VwsMetuUuQLSiFJlIRRio8YpsNCIUq2jFKcrRjW9co/HWwrIPfECMNQwjDr+4lLKYcSJlidoT1GjHz+URjhhr4gseucRINpGSa8SYCUxQPqn08Y8y/KIgb0hIpRjykBFJpF2Owsg4OhKTT3Rl4GAZS0sakZY1GN8mO7kuo0jglxJw3wKGSUwFGPOYxEymMpfJzAUc85iwQyVHlmKAalrzmtjMpja3yc1uevOb4ASnETe5yyyOxpfAFKYyn2nMZrrTnexUQDSlSRFqhvOe+MynPvd5/81xknOPPakMOn+pzncOkwEITahBF7qAHdLTI0mpZgEmStFsHuCiGM2oRjVK0Ypic6MgBWlHJ2rRkJr0oiMtwPhOwNITAJQnAhUKMINpOIYuIKEKtak7HfrQaSJFoiMt6UlDmlKhDnWjRf3oUUU60pW29KU9OcpMK/iDZuIUoTo1KE552tN6IuWiRl3qAVIKVqWKFaUjLes1z4pRsh4gm05lKVSDMlCadqs0Vr1qVt+5VTJ29YxHUas12YrWjgq2moQda1rfatazuhWuxGupS83ZS5kCszRme2c89wpPefr1rxOJKD8Hq9HRNrash83nRrvpz3Lykq6W/SVmy6ZZdv9ytpnG5CpoISJa067WtKTNKGIZy8/fbrO1nKRsTNT0qycUhgPQ5UDyurXMq1r3uji16QhGkBQG/hUB4EVACJnABOCa97zozaYRYxADGchAKN41CXPX1CrnLiG60p2gD6qL3f5ml6Hb7W4LQRte8dZXKORNr4IXzM/1tve92VqQUPzoRy+WDrsH7W+GMXzTq243wJ/dLUGIokgGm/jE2syoP+Wq3KgahcKgTB6H/bvh69YYoR/mbohFLBASr9IoKA4yilX8uU2y+LUujq1d/3VbZm7WoEkBDY95+9MUY1TBwk1vltE7Pgx4GQNz3YlU01m2bzV5mU9+Z5QbM+WD9Lb/sVi+spblzGXifRnMLb6JVY6C3/X59885TSagQew40CYlsVu2MqKJu89FpzZw+WKpe8Mckz0bpc/qAzSg+etfQiOszQY5tKO76WhG67PU6j0iDCQNYSTLDp0F1al1z9zQHYNaMlUeLlsfe9ql8hqohjW1ATI6PqI2lXhGniylqwfrmu511mfW7a3fnNhfB9exi72mtXV9gGIztaO6NMGR84yTAz+hwjn8AY3dqWkNL8DT8B3wbsE73vIK+d6sfcEKVpCYhehEJuZGt4XXndd2QxveEb41vc2dYHw7PNX77vcR/i3mZmf22XqNtq1BTW3CbnvYHs+2NT9+USxOpoxJ/34CQZ2dVWg3WdoczzXIdy3ytYY82NquOWlNrhiU3+STM3Q5MQ3+Z/7CnMeWDqyw8Ylqbja9mqiazCl3AnQZCv3GRM+4oBlwdBEn3SipZfqonT52qGNL6nZJOXTXx9esY1WrCe06j9/88LobICkeyLsHIsD3CDzg74C3gAWAAASsSPgJa1df292+0L4W+q90t7vD8a73vvsd8H8XPOENv5avJ17GbrexMget48c/9OtCCfu1E0vqsitao0fRe+UtT3sRiACDpi+J5/ML+tBrfeh/RrirQYv6J6ie26wn+6Jbv9HYy37vtLe87XH/6cPL9gdm+y+tt/72Zsq9q3+JKf/YOUpRAhAgrIw9akfNn831n1/5vi5AYQoT/fpHQPal6R9j2Hw8lUtgtt2ifdtXY2q2cbsVfoDxVeQ3UezXa8j3bQXQgDnHgO+3TTQ3f0tgf9GHfz+gf1ImOojHe6WDde0EfL4ngMP0fbslat+0fN7kgsx3AFH3BM8HffZ3ARdAfcMHWyHIdh2GUyWIdb63TCpoaArYgoiGhMkXgzNYgxoYATiog3eBGYxhWd3yLd8ShNuXZjuFFB94a5vxBJLnW0t3bdXEc3yHeWoIeJaXf+S2FlXof1eIhVpIa1zofV7If2CIa0cxhqN1fDPHWGh4eWuIeW3YgW9oE6zyXNE1Xfv/xUwnyABtl2MCtocVcRQN54enVobXRAOeSANN+HyFCHi2tyvy1hOLeF+NqF8FF3qT+GGVuIf1pomNxonW9ImgeHY0KIqj+AClCCineE5KFmt3eGZcWISQJ3NKSGfAZVz71CNnqC904XPWR2YXN0zF2GTHaIBTFnkxCIhil2j6BI0GEDZyQY1SIX5TxXIMdXW3hYwPJX6MUVgeZXPVFlS9JlZJVXL/0wItcI64NhjqaI20JWu/93LceIAJqH/0SFL5GH8dhX76iI/8OD7+CJA7aBJEUSiM+HnY94hCmFORaF0IF1+7FULzWFrwt4Svx5LV1COeKEQzMAPxRhEusZFA/9ETOCkUHSmC1GWCojeSHlZ6wGiJKNkEziiRZ/WNhJVqMRlEM1mTE3GTAkBxPFEoebGOc1iHxmhb7lSSwQhas/h6cQaOZId+GOMCLjBpCWeT5maSO4GVSKCV/8KV2uiVzQSWRslw9mZUZWmLrYeW+qKWbAmXKmGKCsMY64iFOGCXt5WNyrRm+ZN7YRhnQZZaG5VCgONl+vdQ+reYdKgAA4iNeNmF9KOHcUOZfAhkc3aZwpaZMBA4nClCqIlKYwYBEBBrd/lMNtUt8HgZnfSFXtWHQiaOzciM0aiZs5mRT3ObucmOu4lMDOWbCfkhwVmbEuGNC2acZJhalrScU0g9zf/Vk47Yioz3lR8mhZ5xFkBilQYxlrTIYLjoiYUZlgkznqrokT/Jaa6Intulnuv5Fe2ZkxEBn/GpYPNJA/XZVWO2cte4TqVph8dkZrUWoOwZJAHpQ8pohnNmlhYImAZgROPmmXWlm8UUoV1pTBRqoXAxOMxZmWTZoSD6od8kosoWnmyREFaho1bRoxh4fb13giGZY9uFXetzOu1RKydDNKoTIaqxNEaCgTCBgAmRED5GFAOQpQOwf0i5lC2ZhNrkbfs2pmRapmp5pi7gZQuxpvY5FTjJozzaownwo/+XaSM5pERqpOqDpOyhpOvBpE2qAU+qHlE6f1MaflXqAFcqAFr/uqX7x1Yf+nTYJKZlWqn7hqZqqaZs2qaeVJUOEBIJIRAI+EAOWpALBZmcFU9mkzZIojYUsjjkEiG5USFs6pZWeqXklYl2l1GVCh4R5xRAshQLEW+1CgCGORiJKqrhR6pLtp8Ghap7paplw6qx6qpIEqiyChu0uqa2qqi4mqt+yKtl6qv8BqxOIKxHQKzcaqyc+iFy+hfMaqKjeWZmA6jR8zwaYq838BohEAIRUqwSQaVVmqVcSo/ml2WL5n4Ii1FkOoNyMawJd6y88a4BEK/QOa/0Wjb6iq/5aq/86q8aALARIbAJQbCPqlgUuLD3mLJyJq775rBxAbEwIbE6SWI0/1GlcoqBiXdX6iaUInldOYZjH4ZTyUM0r+GnTKOv7DGorzEhIksQCHizt0oUBduUK2lSljquumgWbCqVAkGzPOFjUusAOTt/O0s6PeuzkviDQ1mkDBC0CVW0IHO0JvOnSls0syohTzsQUVsRUysAVQupVxtSWduwW/sVXduW7Coof0GxifoXOiuCpTGEbKu2pdEDPXA6dLs0d0syp7G5SxO6mypvi5qoJpuSIdWdWFu4+5YXhSEUthe7sju70xcEAra3vdG4PfoXjxsAketn/am2RPsDmKu5OoC0nXsrn3u8dRu6rzG6EFG6A+uoqAtSqku4rLsCrrsEsEu73lu7t/+7rvmTqHkhFDAEgCAJlOeZl0TavhHkJoQ3SoAEP/ALBKMEsV/LqQmhJrnalwdqAGTav4L3vbYne+CbLWCrLuSLBOZbAejLn+vLTO3rvvFTv/IbShUcBPErSPi7uBuxvw3Qv/9rTQGcqwNMwAZ8e7aLwO1KPWOmTtCaVdBKQTT8PhJUwziMtsnzMy86EHFocyN8FGnYi393iKqpMi/sbDGsUzOcwzRsQU78xOrDwzi6ET9MWkFsFENMxEZcfai0ez6othCccTjlJv8pSKJ0wem2PtSHjhLxdYAoqX4Jci+ri3n3hDiIgwfcw3EDxopXuUI6eu5WxkFwxmGUxmpMQ+r/08YZyhFwbItyDGd0vAKhiMd5vMdV/FAh5EfA2323FYnJRHiEF4CBbJ7BR5QJfIlPoKu0iIuhKHuZZwFr+Ite21Ob/AGdvLZNBsrEJMpAQMqUa8qdhsotfLMI5r+t/ImvrHexPMsigJgriE657Mm05o67fJBwh5B8XBBKp34694DenC8TZY5x4ca2Kc12ioJnZs2fjM1tp82ZrKGpB5EUhZkhJ84qJY1zYc7jW195IXCvEsyQWMoDLdBZ1QEdAGKpbMyrjMz4pgIQHdEJCrNe4W8EekhyCdCT25/CbHCLx9F7hdAKXcyH2dCSF9ESPZ8U3RUWvdAJ06DNmr6mPK/s/8xZNb1XyxZa46eUJ0VyIAVAOe0bVbzN6gLT8irI6nzNSd3OS81ZQR0RSsfTJuXTsDk+T42ORN0rfMYBQPqRHb1p7KbLYR3BX110xHTVbsaaB5pEaB2GRigU0NXVzsp9WffOcEfWBV3XZ52IOi0UI8zWfB1qXixNRl1mjSmdA7jENqXYDAWZbc3Nai3J6GWcVh3YlriadJmFiL2FKBqdjpmqnV2h8exTfh2jk42c5Ug8j33Zq4mbuElVEsqbo8nYpxraeJjVh3FiSalNRrTabXYUrv2cPBvbm03cnx2tts1Mvp3bJrbbqRY4yz13W1QBAO0mYF3W153XeE3Xbufb4P9FnLQI0YCN29LdwNUdBNk9xkT30dutvlnn3QgA3poo3kMU3SL2QtQdYxd2p0jN39xN0CGJU56mkT/mkg8pVpo5g6w9nE8AQ+gWpAYNyBEuxv2NXQNeEixj4PaIaAmuiwteoAFHYUKz0TfNy9ht1ie+biNtEoXCynYH0XUsRLX84SFxFDA24mnrzu693mMN0urt0e+mYy7d4g5ddzBOyfWtuDQ+EEnhkSTu4xIO5RT+34CWe4okVkwpuC8JOJ54xNG81dOs11Qu5T774/5l5T82z0eV5V665TBJA17OoEOR5ixa53Y+5zv43Wh052ehJuRN2HjO54JuoVMXEXoehoP/nhV+PtrTtueJ/ug918g6jeiQPj2Szto/VOmaPo2XDtWOvunR9Oeo9IWgXupfIVA+RemmnulLTuqr/upYgepnpOqrzs+3FkLAogS6vutEQARF8OvAPgTCPuzELgTGLgS9nuzKnuzAHuzE/uzHjuzLPu3N/uvPDu3HPu3UXu3E/uvQzBEhVBh3rIF5fAG0W4NOSO6XHLtS6NJdheuGsuu87uvcfu3DHu3avuzVXgT2fu/Znu/MXu/9ju8A3+v73u1F8O0fbG7iboP1V+7nju6yZ8l6zO4rrPBLLthCIe87sAPR/vEgLwQdP/IkX/IdH/IoL/Imv/Inn/Igz/Im3+sw/z/y0X0Ua/iEOE97N5/zEUCdoh5zG7/rLe/y0T7zJk/0H2/0JY/0Ra/0OyDzRl/zRrHzPI/zVI/zPs/oGQ8A4pcESWAERkDyTC8E/S7sxn70TF/2Q3D2S5/2Zc/2Yh/yvS71QlH1dn/39UedmrH1I7uQT+D1YB/3SK/2cD/yY0/4Ki/4RI/4aA/yc2/ZVFb3eD/5d6/3hsH3ELGj5ub1Zv/vBX/wb+/5AA/6nV/soq/sBP/5Aj/szY7xEaH5R5EXN2ju3ivxE6/uBPzMRYn5BwH7RsH5a3/62k769p76o7/6xm76xp7vxp/vxC/srb/7FOH7QiH7D0/7EW/7Dh99Faf/va7P+0wO6+K/G8yZ6eJv61s//uovNuX/6a+O/jRu/utv6vBfRupf//Hv/vO/6fgv/+/f6QABQOBAggUNHkSYUOFChgqfPDH4sOFEihUtXmwosaBGhhwHesQYciPEkSJNnkQpECSAlSldvjS5suVBmSRhXqx5U+dOgQkSPARqk+dQogYFCAg602HSohQDBEgqtOlUiz6jUsW68+hVi1yzInzq9SvKgAAh+QQABgAAACwAACYALAGMAIb//////9jY//8+/54+/3cX/54X/3f/2P//2Nj/nj7/nhf/dxfY2P/Y2Njntj7OtlbOtjDnthdu54Zu52CotlZuzp5uwIbnhm7nkBfnhkjYnhfOkDDAkBfAhm6okDDYdxdI54ZI52BIzp5IzndIwIZIwGAwzm4X2J4X2HcwtoYmtm4Atm4AtkhIqJ5IqHcwkGAAkG4AkEjnYG7nYEjObjC2bibAYG7AYEi2Vs7OSFa2bgC2SACQbgCoSDCQSAC2MM62MKiQMM6QMKgmJiYmJgBuALZuAJBIALZIAJAmACYmAAAAJiYAJgAAACYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI/wABCBxIsKDBgQgQOFnI8KDDhxAjFhQggGFDiRgzatx40OJCjiBDihypkaJHJyQhJjyZsuVAkx5dypzJcqbNmy5hWsTZoMGQIQR7/sS5USjQgUaJKn2YFKnPo0ujShXYlOpTm1UBZJ1qMOtWrjyvOh0KtixWsVbJ2mTCRODJt3Djyp0b1y1Ks0s/AqDLt6/fv4AD+xXIFmfhvYITJ7aLN+9dxZAjS54cE8BhmUZ7Ut7s8efXxi0zN+BMurRpz2hdija9GbVa0JifamZNu3Zg11BpetShI4PvDBeCCx9O/ILvGciT/14OvLjzmrCVngRBvboECROya99+vbv37tXDg/+4vr38hO/oJYi3jt289vTfw2dHH37FCuhET/Je7ry/8QzJKcecb/4Rh190N00nHnnuzQcfeOuN116DD0K4HoMUVqhedQ56V999lU1l0Q47yCBDcR10YMOKLN7g4osBmiijjCiqyOKKLh6IYIIMkeDjjyUEKaQFFtAX4ZFH/gikkEESaSSSICjpI5NNFhkflFGSAAMMO3E1YoknEpfijTi+6GKMM9Iopo035hjijjhZJCUJVJbg5JVYYjlnnXd6qKeUfFrpJ5Q+btllVLMpoQSJ+zFXYHHHBTjDgAQ65+ZCr8EZ20JEENHhg0di6J6GG1444agahnqqefBRZ18MMWD/mptSiS66Q6P8PTpcpAFS2lxxlzqRqaahjeZEp5+2GqGorKa67Krlkapqg8lC+Gqsws7q2EI+dOsDmmmGOdyYZJp5ZnLhmjicjsS2ZFGeec5JHZN9WojknlTWe128gOYraHf22XeoVBZ5+y266dZIpg3m3gBumuu+2a5L78JLqJTzDvnvvn8qGeiT9/ZL78YSBAyiXiIyZHCZZiKXrrjCpUhum+a6LCNy7E4c0kn4BuljvRb3XMLP/wYt8tAkAA2v0EFuCevAURXsLcswzvByjTO3WLPVN8+Qs84c8Xw00YN2vKTPSRe99Nhpl32xx1Q6jS3KBDNE4t07SDqpr3zz/ypp3759DbZGJ4Vg+OGGU1se4ow3frji2zku+eOQZzf55NmxoPnmUG/rBN4k6g0433ojN7rgg2NUuOOVW345662/Dnvlsjee+eaadx4nQ7z1rgMNNOganN++Ci+cXKlvBFeF01Ir7bOKP29q9A+aYILJ9jWhfRNgWeQ7b8AbTzylxgeHfPIZLQ8q9M47O337zLOfIXzWY7/C9txLRdFs3BrsLegAvJv/BkjAAArQBydZwhI+gz6tNEBR/GMI7jRnP7nB6oIYzKB9JsgC+21wcxWEQQZHSEIOhpCEKLyg5p6Wrajsz1j9G6ABAUjAGv5vht1K4AJT00CnQBCGEpzgCf9TOMIP4s6DKzgi9ixIxAyacIkibOIIV4itYe1uIRGIAA+2yAMb3nCGt+odF7voRR/gDS6M6WFHHuOREW4JiUjcktyuhcE3wjGETHQjDO6Ixyii0I720x2PsKhFLpbRjGAMI2/GeMgzviWNaiyIXk6iRz5CcY4rqKQlAyZHP5IQkJvsJBFBaTJBbupYROAABw5psEQekJU3zGFnhsBA9K2mjSUUogelOEVd2k+J9uOlE32JPWG6wAVWnMlsOqVKWHbLlSRyZiwROMtaJu+WFkHhE4MpTBUS02TALGY3YbVNcUrxmMm0iUWymMXv6UAB8IwnPBNAz3rK8574zKc865n/gPNF0iFwKYBAB0rQghq0AAZIqEIPytCGClShC3WoRAkK0YRO1H4iyKgITEkxhrAzAu7UJz/pqc+SlpSf/vynQQI60YZW1AAtbelLYzrRmUoUoxrlKEl04gRVNtN/CwiqUPEp1KIa9ahIXQA+0ajSgyRkJR6BqENfStWqwtSlVs2qRbGqVasSFKcjGIFOR8JTn64SqEYlalLXmtSlPrKpBnmqQqIaUYZ2NatTvWtV86pXmwoUrGK9iE0CQNgArJOdITWpAoqq2Mbek6lwBShd+6pQAliWAAMYgEEpC9HLYlazBeVsZS+b2c1SlYNhDStbOoWTwhrWo4j9XmMZ69ja/0I2siudLGc9W9rQitYAvAUtRX8bXNO+FLWpXS0RlAJVQmYRgGyNrlLvKd2i3ha3BDnJb69KU99ul6+/ZSgdYxDWY45VJM11wkehW922Ure9C7gudu1ike9217vh5Wp+DTre8rrgvCM5bDtlm0+SnnSktZWnfOd7kvvid6sONm5dIzxcqd4UexrdqGDzA9sB+06kCTDpSEOcYHguGLsNpjBCK6riB3O3xSu2sENxmlEAi8QiqsQABtg7W/jSVp8nxm2KYUzkIhv5qxjO6Yav2FMO6JjHivXxj/MZ5MgO+chYzvJ9aaxhup1FVh9154hLLGIEx/MDHzhJOpsaQQU+dP/CRJZxkeUc54riTgUqqEAFzNtCoszmJ2H+3pjJDGJ+yhPNatYWbtu8hDdDeM5whjGdJW3nzeFZz3xe804rAtufGqy9apWyUausUp4upKvgFW2qObvqrKIABRzMsI05wtMsetpboH6vqK371vkKxNROQLV+VT1sVhfb1bCeoKyXPEgnOMABviMRofdp5hKTuqlXdrBfKT1pB3Pw0eJNsp5RF2CGPDvaO5h2PAdt7V77mr4MafG25c1iGH/7xeE2WUbHLTHdEJJRvYPnlNUtz4HH0yKKUtS7s6tbyhbXxXp9eIX7qjnLcka5AlF4s5+ryHcudqgED/V03bqQhCth4QP/0S5xSSvcgW5X4i7nbMUJcHEmsBYAGlenExQ1YICLPKghLzhST3JzlKs8q561rIS32tWkE8CgTl+6VXNnmsMUXTc8B6kOfK5rkAf940cl+nJRjpj6ajXqLna0VdFOULbHvKtUL43Vx37KhdyaRO4VuntFjehZojyCbKEseNUubLtuV6EsLA1uvsyQu+8g7/Fkq8Cl3HeLaPqfgGeC4PVLeK22mrOJJ83iU0KRsp71mY/3euR3fVSRX7uHpee02fF67L5+Xq8MPYkHPLCB3vv+97+XZUpbEnscnx6RBmd967v++gYWv+FUvf1dpV/4guqe98DPfu+FXxfPeTjg92R3/9AH3fxIWkR7Etby4I+cUItA4P3wj7/84c+b8pebkImltqG/rgDyu/vd59cE6ad+hgdulOZ+85eA8Vd//3cTy0QE38cbtbV8IVd5DHF5kZR5btd5EZd0UteBniV1r8YpRKCACrh91CQrU/GAEehxPWZwhGaBKrhwGuiBEHdXGxhju2WDE5dQI4hKJpiAKGh5isZh+Nc70pZPFBh0YdeADOYRH3h2SWeAouV0VKhVcecEQaiAJEJuMnFY6KZPSxhyTeiF/5RtOgiCl3WFDjeF+JaGp8UCCLiF8teF/SYdsJV/BVZt41dP9tdDaNhdFtZtNEWI3SUwDEGH88eA2mMWYP9IYIVmT/yHUk6IYlCoYoMYaYKoiVt2MlqoiAuoAwvRiF7iBDrGcVxHaKxHcndoiRZBgLDYUkxkEb8Xfw9wi7hIAbpIAWb4haaIAagYRuq2io9ViUJ2ibGYjAc1iwxRi/CHi7m4i71IVqV3WDo2QJO3d2uVjUjFjWgmg8wGV8/3ispYjn+1AgmFO5QBE0oxjuoVAdfoP9y4fJIHdt1oj9+YZsb4T+64EOZojvaRjpwzGewoFWzhXFpXAwpZA/zXf3xoUhZxkHdhdAyBfr6lZQZYZxClRJqTAikgGZC0FBIZaAvJkJP4kCUVkUzgZb4WgKaFkW+okQrFkSzgkSCJGCn/sxCnGAHspXyqN49r9YcNdHTGRm/E5lAo9AIvAGAsyZJMtpM96ZMjt3rSJZToQ5SbZ5RF2VBJuZThuEa5FRWEJWBa92GONYYEZ5XJg5V95XYJlYMvx4Mxh1yzNo0iMZYdVpbg94I/mZb7CFdsqYZKF3NwuXIh6Ft0+ZWSNWsgYXqOB3k/J2WsyJh1M2sHcACB+I8EiFOUaRaOeXx4d49iqHyTqZigMY2XmZmaqWWcaZrEgpcIqYcmhZaEZod26RgEgZfKA32C+XSEKZcciIPAuWKJ6ZTtApvv2IITmFZBZ5ut2Bh0o5uEw5vCeZhvVphVOJwCiTth1Zlc4Y5m1Uqp/wd0XeeTasV9tkGQnCYR/Rhsnld7uAeffdWaxgkn4OlT4pl8UkmeQoee6RkZBQkR7Vl9URifBXh49DmRa8kQUHk3EqiEu8aX3RJU/zkZISkRqrmaWMZELdAC3umIDAqMPOmgLlie8CWhPkChFRoZFxoRGaqhRsahHuqaO5JeTwY6+8mfVNmXRTVAPdAD51I6Qso1JkIzLTOkQnqb6UV973mgVfVqGKQ5Gfl2BjBCfPahUmGjO4ajORqZIuejQOowSFo6M2KkVTOmkqKkc+WP8kmgNwhRUOpNU6p2Vvpfz6kpj2iWDfl1vhMpyyGkozMgpvMbgPobGIcRhCUQrjV7wP/lhltlWZllWZkYnFXldFJqAIkhkSbXJfW5I3m6l3sacn0KIHvjN70SqH9aqqQqOoZqc3QXEYkKAIvKEJ3lqFcFqQMgqRHFdG2ZdJeaqSu5cwnHqQo6FRQhoAIQQY8pmvaYo9NVVPloMEGKpqVjptOKpm5yeQnhWoQ1G2zBpLTnpAr1anHKGqMHFsf6EC9kfPnJrM5KW9D6jdIqptRarVpzpPWarUVIENvKrd7KBODqVbVHrigQepxxru0ykgm5kAb2deJXW75TIH1TPs5hqnuDpeSIZXPaUllIGZeBk4OjsLxRkg3bh/tXYhHrHxNLscRhsYFDoxCRsewXkzTVsZP/8bGd6kKlxwA827M+axE3ijejSYz4pAEakI9I+414kwM5MCNYwyb3WjVXsyZZc5sCoT1sqrE0S1An0LVe+7VdexLQCI27uIu7559WmxM767NsC7RbKrQQSrT3ZLRJm7RL27RqMi4yszANYzPh8rQ3krZY6wQwOVFge7gnILZje4tlq4tnm4Ldlzqf+qDzhJLqVrL4RE+84Uru1Lmdy7me2ztdQoq7+a0w+mZql1lzCAGLu7jv55w5qzOTW6IPS3CYG34JsLmJFLq8u3W727ujmz+lC7Cnu2KpOwCr27pj+7o7kLZgwa2vdYR6GqrTBk2gw7vWa0CeqyiTVKyyyq2K/xoAhMEWTIB2vJqdh3m+VrW6oAi73jsx0Du71Etw2Uuinlu/ALS9StC9BgG94Tu+bGG+VxWX6TvAWsW+iui+KsWuaCVdQLmfk9ctaAZL0YRIFYw30oR64kmssecQcoWchgiHWXlQVRV6zjh/vbd7j4ulsMHAn1ZdDyyVEewDE8xKF3xAGJzBFYx6HFx6HvxUIMyJlDp9tWfCvneCG6DCHsB9GdgAyjVgJEtiDmu5ipVYtXu5UryHaDa4GFgQs+FmWXaFw/VmHCQryquAu0eEKtUTT7ywCnm7WHyyCWbFVExocLxuCbDFTTCDRWEsYKy1LxlzZDxBZty6aOwBahxZIv+rA1HckFc8bY9sx3WsABgbb2FMs7wqUJqjyQN5k7E7MYvcyCcpxyEXyWRmypWctTNreKhbAJvsyp3MoiBrfuYGbYxcA5Rru5NcYqbMy7t8cDD7EPhTvAPFQTa7GLOsRhZxbrecy3EsiVNMyroszUAWzA4xzMQMy2VsoclMLGzbs24btHcztBFaUuZpzqSZT3T7jVg6uKf7tSg0VumqFzzbonDyzTwbzm87znFbzuQsarOZzkV7tOxszQfhzjAKzyQkzwKQRvXczQsam5CIu9QMyb9cW72cYPw0uCQxigJ4kZi4tQ21zZ8sSXcKNmQpm3hc0ZLM0qd80Y610Xv8vtP/aZFjHNLeRsgGDW8lDSfp9VEDBNAmKrcxLNR6J2XeyVNu2oNbeY7XwsL/9NPsFNSSOdT+vKPnfNQ+ltSy557hSsKHx18BE3pkpzp5CXDOvIcu7ctrrdEw3Vj409GWzMqXrHbb/LFlvZjJOaLTG4l33NLQbLKBHXJxfX+Ei1WFq4N33RZ5HbNnDTqhCoMEJ9nD2Jf4ZHIgEavkW74sV6BSiKtSR0Vk3dgPQZYAFNmWPdmpXdk6qk+YzRGaTb4wN8RI19kuJtpzQ9ONbdpcmtVYLdC/TdTNGpQ7bdKnZnsSZV+BVNxPiJBRKdzOGpnQXV2p7NVEHLA2tdw9vXDIaWvH/zehMGzVRh3cV13U8MXVjDrCnp1VJK3bed3dEXBr4O3A4l3VWg3c5t1e6E2r+wXWotXepF0Q+ewR4pzWvi3dJ4rOwn3f4LgRwJbNA6XdzP1PA+62eGPg+F3f9P3P9t3PQdXgJdHVqkzMEr7dC8xGK5riKu7R9gyWZbfigHEYJn6GKA7jNl4bpFjS3XvjfiHj7v2EPM3jQs4ZLR6WLz7kdFHkLVnjSN7ksqzjTO7kTDXjJ85wUn7lgKHkDBfkWE6sAU43XR7mfKHlKRflYs5GAc7lToAEbI4ERmAEQBDncv4DP4ADdn7ndJ7ner7nct7nc17nd27ne/4DQVDoQSDog/+e6H7u53Qe6Iie6Hzu57d5EqBY6ZaegGj74wsHF23u5nDO6IAe6JA+6Ive543u6INu6IeOA6Me6aUOBKcu6q2e54s+6R5x6bh+6Zme5mu0EEfw60eg6sIeBLNO6MN+7MNe7Mhe6HS+7M5O7LP+7EHQzjOtxNaOfb+nvIy7i7d47Uqsfb7HxLzuogwB7MG+7Mou7cee7sje7Oqe7NH+7NS+EN6uwtmn7Q9Qtt1e79iufeI+7kxhLEmQBEVQ8EUA6a8e57GO58X+AwkP66HO8JD+6LP+8AtP8XQuBELAxxzxgLn+8YooS13c2LMx8AZ/8Iqe8BfP6g1v8RGP8XsO8wjxr/Ivz/J6rvEc38ckCPI8b4Iiv68A/+K/3u7G/u6qzu5Gz+zxnvRK3+qq7tEzrriNSwH83u+9h+9TX/W957xkZxFDv+5Fz/RIn/Rjb/RID/WanlsWse1lq/XAh/WN6/ZcT5FnXvcXAeVq3uQ+HvS9bvd1T+ZpdOZ7z/cFkeN+H+aADwCGH+akSLqEf7X5c/iID9HXHPli3vjCG/QBCgAD/vggwZKO7xCp6b1UziME0fmev/mo7/nTaRChfxCjb+QIQjerT/j9GkEjn/oN7UCJzJ7JCkS5jyjAD/QBfvvDz/oZka64T/wv8fu9vyPLj1sBAQAh+QQABgAAACwAACYALAGMAIb//////9jY///Y/9g+/54+/3cX/54X/3f/2P//2Nj/nj7/nhf/dz7/dxfY2P/Y2Njntj7OtlbnthfOtjBu54Zu52DAtheotlaotjBuzp5uwIbnhm7nhkjnkBfYnhfOkDDAkBfAhm6okFaokDDYdxdI54ZI52BIzp5IzndIwIZIwGAwzm4X2J4X2Hcmtm4wtmAmtkgAtm4AtkhIqJ5IqHcwkGAAkG4AkEjnYG7nYEjOblbObjC2bibAYG7AYEi2Vs7OSDC2SCa2bgC2SACQbgCQSCaQSAC2MM62MKiQMM6QMKgmJiYmJgBuALZIALZIAJAmAAAAJiYAJgAAACYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI/wABCBxIsKDBglQSKjzIsKHDhwcVLoRIsaLFixElUsHIsaPHjxg1bgT5UCTJkwg1olzJ0iTLlzBbqowJgAkTggIEJKRpMUCAnQWhQOFJtKFQg0CLKlXqM+lAmzGhDszpdKnBpiMJHrW6dCvBqlzDnsRqUOpJBw4QIAAqsq3bt3DjvlULVuzLhFTl6t3Lt6/fv3vpZiWJVrBAwIgTG7bLE6/OxJAjS54scfFJtYdHUt7cNjPjmHnRch5NujTbwSAxAzhtmrLnzy9DO2hNu/bf13c1DhmSo7fv3hyCCx9OvLjw37+NC3cJu7HGCtCjQzdBvbr06dWza9d+vXv07eC5e//vHr68ifEyZDCnKXI3ct/K4xt/Dzz++uYwRY7fTt48+PH9+ScegN8JOOB16d1HlERCCPGechtEKOGEFG4Q3IPGRRicgvjlltB4FIQo4oghlmDiiSaGSCCJLFKAIooqAtgiiS+eGCOIIkKX4ERLMeggchBWKKSGHGBYHJEcdriSRDjOWGKNJdzonZMiQhklBStS6SKUUnY3oo7q8aiURESUSUQIIfSg5po+tOlmbzjEKWecFaKJ5ppsutlmb0kqCZJoCqkgqAoppKCBBiNaWWOhjKYwKKGGIlqloig2WuijhR6aKKUnWurooJlKamIMpMYgEVdkmnknnj3ouWcOc87/WaedrLbqKp8z+ckSoAlhGummnJbgqa+aThrssKD+aiynyAoa6pOlmipmTAlUm4BEu+0WJ56u+kDft77NyW233ubQp64Y5ZTTFFMkZOV2j8arwnaUwivvoPQqau+982pXb3U3BHzDqURZe61C2Q6xbZ56gguuuAzfam6u6IKkrgDsugvlvvfm+652/Arq8cYghzxyjdkJPPC0CyKcbZBDxhzzhUAuR3HFIOkXnZZb1tjldTxb+bN0QXOJpYwtkrpjXey5vBvMMkc9Ic3J2UwwziTpDF3RPh/dpJNCez2llmFnyaLSYTLtIRUJu0effPI5XN9wCQnlFdYY+YQVkwRW/2DgeX0H6F/ggptHeHTpJR6mWWM6ne23cMcndw7F1W033h3p/dNzff99uHSef46dgKIrviPjRVWLbdtAAAGnnOM2PDlyEKvZJlyYQ1Tt3hoFiyLH8p78IvDxCv97yfyGt8IKpAZsgw1XF3xwQm0P0frrC9su8ezhwp4n7rk7tPvmIvl+IvGPGn8+8h37qy/7wYO3fPM3PB89T3klZMT+/Pdf/f9D6J8AB8g/AO7PLXkJH0PyojqNBMx0MoiWBGOQngnST2UYzOANIGjBGGjwgwLjoAVBSMKVqY0l+aMCAQsIwLat8IVGMKAREPgYBR6EgdNTyANN10G0dbCEGhThBP+BmEEhSpCIGrwfS6r1gAckxCYd6EDCYLjCFrqQiv0TiU2auIQl2NAgXFxCE0WCRCOS6nlIVJkZY4DGNO5QcRNsoxsDlpAu8oSJTqQCFKWYLSwO0IpT9OMBNbLFB9jxiwQJ4xgdSMQ1yjGNjrTBHDfIQwk+0o119GLjEiIBCTTok6AMpSitKMpSlnI3bsENIgfCGoVUsIcThKAsEwfLWM5SlrWU4C1xmcsYnOAEJ1ySQjppymJ+kpTGLCYqO7Ma1KyylQl5ZS8puMtKTrOa1uwlNuHYy18GEyXsYhcEINDJ6i3gnOhMpzrRqQAFrDOd7YynO98JvlVmJCEZo8IBDmD/gH76858ADahA+7nPgRr0oP4sKEIXGlCF7nOf0oxBBiaaASW+JJxTGGc52/bOjrJznh2VZzs7Wk97pgSf7dInPxnKUoKutKUMVShMF+rQh0aUohVl2drGOc7dgNKjQP2oPIOqzlSa1CEimalAZapUAzCVpU9takNtSkuJUjQhUpBCUSTCUwj49JNEBapIQRpWox6VIUmVakJf2tSo0pStagXoQw/ATZxiVaswSSEI9goC/w2hAYANLGCBKtjCGvaw6TTrWXHyGInE9bGQjexAWcCC50Xrl97UKUr0yle/HrYBhP2saAWbWGYulrFplaxqV9tUylq2VJgFpmZXskib/3SSmJ/kAQ/CGtbBBrWdJCCBSA552oEsMiFRiMJA57pa5qrWuZCFaOJc4IKJ0oAGmeRJbZlwW0/mdre8DapvxaqA4A5Xk8UVyHGpkNzlPrS5731ufKNL1+lWNwPXzW7LOHlbMxFhf6Md7TnHq84AN0Cx6W2mY1nL4AYz9JEziPAMLCoT/nbSvwA2MGIXQOB0GhjB6U2tg0dM4n5CWMIUPstsFBLFKCasQeFFp4ZFW9pz2VMwCy6xjhs8QQlPeLaEWXFCWszHr8Z4wDPe8DlBvFgcK2THUGZtj1EM5JM8kbu3bZCRC1zYI4eXyaeViE0KQOYCTHWuaE7zQ8tc5jOr+f/N+2Qzmd0MZzXL2cxOra/iUMBnFKQYJVfurpaHAGMuk9bLZTVtghWsRyawmc51RvOdIR3pNcuZ0pU+wKTzDME++7nKH+EqTwddaEQvYKwxBvNiJcKuf0I3sq+mr1vVOte6XpUKWd2qQrpKaiGY+pyo/rKiE8zqKbh6vrBGtqzh+thaV9WuuMbrSwy2XRe3LclKlnGSzasR4qZ3ve1daqbffNBxk9ugb26BulugRhnE2p+UzeB186sQb4OE2nncY/Wwbdh1YpvbErH3acGtXHGbG83lPjjC0a3mdbM7hO5WNrxZIO95Bxy9+WFxkbPV4XfyO7BEVfVZRRzlKAesn6b/UaUwh7zx3XTc3x8HbVBFflSSl3zHJzdAypsZE4lYO2Eejnm/DR3Y4AL8ZmfVnM0TrnCJH7vps3YpHVujckBr3JzaFvqhgy5Yowt32EnX29IZDnVmPx3qCZ/6zr/JEVGL8tcfJe9Q0Ulzk6K01Tcv+dJGk2ueZzwh43w73E9N1nUGe8lgL+7djZ33KO+dM31nO0UMJpGNJkzrMud6kuuOyBQmpOlMRzutG75ukUzg9KhPPQYwMILWj2CQJT0J5YcpgX1rHebY5vwXPa/Sg4ce9KNPs8NNn/rir971r59hXJzDX9u/HNFDJ2niw6yROMs5qk2/M/YVrn223lkixQ+///gbpPuc0d75mR989Ok5/VVXX9PXZ3b244/pOnf/n99XiPj3j3ryt3+zjUUFezVA64dkmNdxgFV+CsR74/Z7CueAvgdQEoF8rfcBFniBGGiBsAdqJ8FZBNhlRId5MKeA4cOAmQaB5oaCDSiBCkGBI5CBMPgBGyh5HrFduPVTQhVPg5eDI7UAR6dfCbZI7BJujVdi+zR1XRQBSriETBh+Gqh8QEgUNuhdOAhsIrWDVjh3P0gFArdYQjgFRFiEI3aEK5OETHiGTiiDUMiFGNcjCmEBFuBXHSWCHuV1W0iDX1RsYjhilNVPakcFTHgBgjiILth6GygWEgGHcuhxt1eHdv9Iggqkh3vYYH1oAH8YiIMoiIWYfH8WE+zSXVjHW4f3ayLBLovGShoBU+8WV6vYVBAEfvyXekxoYzDxibcVimE1iqZWilNwipmRYzHldMFndq5oOrAYi6c3i0jXcxr3c9mCewcIjYIFieFjc2X3VsDngAFDhn8IGVXHjCznjLshjY2oedP4fzWXinIleioYadj4UNt4ACrjGn6naxZGhWDFg4X3a6NIjbmzeMfGYFEnZdSkOC/wAoiBUd/4d1QgaKEET1eIhf2IjnZHBRgVkKw1kKuFNgaJkIChkPVIEz4xhTeYj7z1fKI4T1vYhaukOeuVVdZHADJJAPUXaWQ2kzT/uY7zJ5Nk5mwQVAM1EIUMEUaJZEhtyBIjmW9YVpKl1lvp52U9uJJHaU8umUd3FZMzWZP2VwA4qZVwdpME0JNU9ZNByYYQQZTGZZRuyF/WVoVHVoDCRov2JBFCEVCbdnYHd5drNX9sJl179ml4KJdWx5Z85JYxBpe85Y+YQ5dQYJeXppPc95h4aW7d12mA6UxItYwMSWT7c3kgF4LlmHUHRpGIqJmZCYxeeW7tWGfvWHGd6Cc+12KdyXGfaY6haYCjKZioYpoNMXYulY1k94AINVeuyYEd0kD3+IHYRo7kGFwzaJxuiFqYeRC8kxCTGYHudY3BOVfqVpx4yBjI2ZC3/6WcScacoOmca/iauymdFVGdVHCdKbidwpmdaNadGERv32kXKNVVuBhjuhhW/mcbkhF504lW76eRM9WKUqWgBjBBmWWKkWiRGcVT/Rle/0lUASqgkEGgFyESDKpUH5qgwthPDipbEGpDlXeL1/aUv4aY6FRoGioZZGERHpppevmbkflokHlwigMDMMBn6tkhKWp5tImFHAaCHQWjMQoZM1oRNVppN5pnfNlmO2puPfqjl4miV5ctTWmktpmkobQDO6AcDhM5cSM3YnYTeUM+vWdpOgqfUCqZezmWifNmlWk6QMqbShKbL+ZrXmqe6yRKYkqm4GKmkoOmCoE6FME7af8WpWXnqGgGQXYaf5apmx3RRJqjOTZhWxKgW54KXjt4oUeahSKlWw0SIWhSIcEhM8VRH0OiJ0PSRSypXk30ABdzMckVhg52bg7ncAGjbojRRZkkq7IqELOqFLX6AJmqN5uKZZ+qW0Yqqr41Vu1kqkKAqiGgqhzAqsThqkICq0JCrA6RrLeqLrlacCTGq71qn8AKGMLKhsR6SMdaFE2kFvaKAMlqMNViN1AQRYJ3gCzqAR4QXIDFAAwAWF5XsAbLAEHQsEFAJxJiJ2lSK7byKrESK7MCrhMirg9Brrd6rjpGWZXYT5S1rvYpGe8ar5o0rxaREwukLveqFvmqr/zqrw//eaR0mE4CS7ANYLAIa3QKa7AO+7A4MCESS7EVWy4XKysUgiYaKyEcO661Wq4gW2IiywL/VLIm243uugTDWqwAwLIV4bI3pC5nWasDMAD8uleDNo44K3OHFrefKbe+Jbc8a7AJoz2v8xt6Cys4wLe2sre+0bdx0hvgGrUU4bFVu4f75KsmFBnE6hRiaxXJmrZrCwJtOwS4ublvy7l0C7dz2wB3ywB5G7h+C7gW+7eDa7qFu7qpa7huEiGIe7ZNlBOLK4aNu25cG6yyKrlT+RnJ6hM12wGCF1L7CJFzZ2rV6qk6oANEAjVSo63K0S0qWxGKm6uT6E/r2qw2sX9KeHrI//ec1YsuwRsAw1u879SDxpu8iLa8utW8z5sh0Tsk8kG98Wq9UysAt7uH28u93hsB4Ot64nu/fjKz6yWOfxVguAmwPPuzgjSbgQTBAfTAK6Rb+8Oxh0S2RdlEaZu2WQWTJyifEWiyLTCBLxiDFuiCujW+WGPAVkkFCGxgC3yADSy6JEDB1eNXu0HBFcwDFwy2GSwAYIS2HfzBUrCC9Al8JGzCKJzCFLjCBIw55WsTQmGzhvmn4QVYgNRCxrTFVtQ/uqVfLFu5A2DE4waWMulcj1pmDkdmzYqMqBe+RsDCeDPFTFDFxHuzWPyWDeDF/9PFfvw/YMwDYvy7G/wAHvzBZ//MlTOpxlDHZm1cAG8MxxMgx3QMG4VhrwKBFjN7vjebs4xYwz8rWC7XxxNcJjwcQy20P6jsR0VQBIV8tmhhu9i7Y1dbiVrrcNRFrJiYiZsIxZO7FJmsGpxcq/tqN1acj6AMc6Jsw6ScwDtsBK2Mw6sszf/lyrBslmFryGk5y/pbyyF7yyTLAuu6y7Lay4RYiMDMzRWTrM26UVe8xzGGvvIcVDtLAkIxux1bq2Zso4w8Z3mGo2WXHiozyXB8fCOQz2BrQ+68qfBskvV8ZPQc0R11zwodzACQrP0cpzyJZzVVdtJV0JtKyROA0BfNzs2BR01kMELRfCtKhwCLgKD7uaD/7HXypM/j4xO0ysEDQMthCNLEiKPqlrvs+nC7GxcpC8QoDZ4JMLPH7NKeCdMxDXMzPMNCl042HU84nQCas9OI3NPf/NMgHXpDfQCOa59HDRdJLa9LXcD8LAUJMYCqXMoC5lHLDJrLadf85nX67BA5kaz723jRMo+J8a7G2tb4odFwLYB9NdcJXNdzeJt4XZ56/W9G19cN8de1Gth5N9gCAxmGvc0MXas+YRNxDQIxHI1vG9MzzdqtPcpFZ3TthNkGodk8vdHuKMIKd0E3YM7eVi0CkZQE0UVNNNyIbRd2fNqpLdWu/dpTvdrOHNvBNdsL/RC2/dW4zZq6fXC87dsY/wfcACDcA0HcD2DcmJOUTfTOWabHFN3ee9xOP0vbA6HTaZnINtHRLiXQlPnPHr1Sb5ZB8n3IXxs+6P0A6s2UfureCu6l8G3DAR7eAVCU9s0E+B3QUhqZFf7RaAbg1S21i/Tg+KHSDyAUe7Tc/IZkVh1zKA7dVz2qLH5YfN3h1i0Aig3ClbaaIfxIIH5aIk7iTEBk6JfXdfvcQw6wKz5jMY7R153dcIbjN24AOi7jvpjRpB0AVNyvLTbRyKuDEhmRoerliJbVO+7VPo2uk6gy3j3lQ4ypVn7HWJ7MXapOogqVYA53cx5WYi7lDXG9uiqGaO4CYx5ib2gBct0/MlzZKv+O6B8XWkIXpAJxMbzyntnboBLk6IuWiITe2IauwIp+4p2e15Hd6NAJAJAuZJKevRNk6ac4pPioW+xr53XOj7GuvLO+AKp+UqeebAgaUKk+6sRGeyXp6lz+5a8u68VO68du676O6/C16wDV6/l5VEoXbQ4Zz6L5p1uHhdm+gwm47F+hEIsMlqlpZ2X2it5uUtOeVdUO0dCI7bWp7e/O7blZoBQhEeHOyOPeqOVujOduT+HJckEu2axNji1um11ndJZqgthpcFCnOFyr5gXx7zDcco+t2gaf6Be/6JP9s1t4EQofn0mscA7/uNH+RWhB3kua8irPhmgptSi/8n9B3hj/jUgnL0YvDPM4Xxoyj9KKdPM5j9Q2P/N5qBk/X/SksZBIQfRGrxdIL+i/uPRQ740hmZlPH/VGVfKjfUjrZfVcD/Qtv+dGufVdn0lff4poKfZjn/b1FvQ8H/Y+P/Y7D/HfLhJOUPd2nwR4nwRHsPd83/d9n/eAH/iC7/eEz/eCf/iBX/iFj/iMr/eKfwQJH4AJgXwwmIxnqISZKIgiIAKbWPkTcPlK+JxY/0xtYfd3n/eP7/eNj/ip//erP/itv/evD/uKH/kiQfkZaPmXn/kXsPmdn/ufD/qiT+8Qj1FNcPxNkPo/sPzM3/zNH/uE7/zSz/zQ7/fTP/3VX/vRZn4J/0HS4Qf6S+j94ycEKCX3FmH8yK/81+/82c/368/+7X8E7//88d/3d8X9VCD+sgj+AKz/qed/ADFlCgCCBQ0eRJhQ4UKGDR06FBBRAEEqFak8wfgEyUaORzweSRJS5MiQSkye5Jiy40eSLZOcRKky5UeQLkfCNClzJkuRFqk8LBhAaACKFkccRZr0w1KmTZdOgBoVaoQIF6xelQo1aVIjRnwCBRtW7FiFEicC8JlRo0qaNm/i1LnSo1uROJXE3diW7ku4ePWG/Ap2KFG0RrcqdZo4a1SqV7FmPXy0a2CylS1fdujTiROanTv/AB1a9Ogfnk1/JJ069OnTqlWzNu2z4v9Y2VQW32YcAfdUqr13766NWfhw4Zo5w0btmjTyz8pHM6fp/Dl0j8HF1v69mOrv3r6zL7ZOXPz4hrXNn0efXv169u3dv6cidPbD+fDt3/cpRQpBJkzI/wewKPwGJLBAA9OT7yf6FDywQfP048+/ACe8zKz6HMQwQw0timg+hRIAMYGKEtzQwQ4VpDBFsSxksEQXX7TvRIZCFDG+AGA8UEYVdwzrgQeWWMIgH4HksUjxhgyyICQdWlLJH5M0UsgnpSQySisRapKgLK/kEqgtt1Toyym7FLPKLrt0wIHwzmQTKJ8Eok22NglKc805o6xTzjv3VOjNga7Ts808KePzoYABAAAh+QQABgAAACwAACYALAGMAIb//////9jY///Y/9g+/54+/3cX/54X/3f/2P//2Nj/nj7/nhf/dxfY2P/Y2NjOtlbntj7nthfOtjBu54Zu52DAtheotlaotjBuzp5uznduwIbnhm7nhkjnkBfYnhfOkFbOkDDAkBfAhm6okFaokDDYdxdI54ZI52BIzp5IzndIwIZIwGAX2J4X2Hcwzkgmtm4mtkgAtm4AtkhIqJ5IqHcwkIYwkGAAkG4AkEjOblbnYG7AYG62Vs7nYEjAYEi2bia2bgC2SACQbgCoSDCQSCaQSAC2MM62MKiQMM6QMKgmJiYmJgBIALZIAJAmACYmAAAAJiYAJgAAACYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI/wABCBxIsKDBgQ0aTFnI8KDDhxAjFhQggGFDiRgzatx40OJCjiBDihzJ0eMUkhATmkTJciDFlS1jxoQps6bNmR5vOnCgRAnBnT1vbgTqcyBRoUgfHjXKs2jSp1AFLpXatOZUAFejGryaVavOqkyDeh1rFSxVsTgFmlzLtq3bt23VniSb9CMAuHjz6t3Lt69euTft+h1MGDBdpIIJK17MuLFFw4HnOp68FvJhm4kpa97M2XLau5wpe778ObTp04VBR7YIBAiH17Bj95hNe3bs27hv164dmyZpoSZPCB9OvPgJCsiTK1duvHnx5dCTO59+PDp06sZlyPC9mmHr3LB30/8GTz68+B69c/5G7BH7c+vL3RuHH18+cfrM7Z/Qzr0uwyBBgLfBgAQWaKCBr9mWW4G4WSSFFOs9ZRF0E1Ro4YUVmqDhhhpWSB+GIE7AIYcewhcihiNuWKJ1J/J3UVQWASjggTQemCB6CxLYIEMPRujfQhSeaGGKHU7woZAZErlidEgmmeKSQYLool1P7WRREUUQQYQPXHZ53pe06SCmDjuUuUOXXp7HpUVo+dgSRVYytMKcdBpH5IbG0aknnRoSd+efI+a5p552/inonDgkisNCbSIV50JYaokml2CCOSaZZk7qw5drMtSomyTB6YBFgxZ656GDrtDncIC2agKqpRb/Byiqii46xafdYQlggSL0KoKZmU4626WXHujrr8Ce6UN/oLJkkQrQRqsntBpocKGrGkYbrYZzUmvtkNhqC+20KlR7bbjiDnrDDYk+ptWVRexK4LHJKovmsMSKaayv9XbqbrMyPZsund6e66q4KnC7QsHgHjxwt+V+62SrCKvLrq1UvvsfgEHkW6amlX7psb1pMgtwSMEVl+oKzp3a3MotE+mnzC+nGnOKwtX6L1QxcjwyyCGL97OwPZh8ckntqWxzcy7DWifTNAvXtNKxmhroCTq/yPPGHAehIG412mgebzkOaPTRGpkUpZCAQplckyL+6TZycLdtJJMWaqddDDHs/ywh1xx/fVvYCI49XtkbnI02RmovV7fcd699ot0sNkk53hXqLQPffv84BZagFzHEEJQGvdulwAL9pVuLZ/TSWlWzaijVS888tXArz2k1zrSv7IILmk85F4wMhY7l6KWbHuaYqRO9elytS/S6SbFLPTtxubMs6/XDZb/71dhnv8LvwW+nNVIBBNAzgK217z4QXccv//zvv981lmyln3H06fevvmRTiEIUFlK+AhrwgAhMoAIXyMAGFrBzN9Ef4OrnvvlZkH4UbM39ipC//0WPIP6ToFwESEAHmvCEKEyhCiEYMIZ0oAMXnJ/xZmi8GMovdGwZzQcHkhmG8O2HMdBOrf+GSEQclA+IQNQcEn8oxCI68YhLDKIMnPjE4C2RhTWxyAttGD8aejFeXOQYDiujmh12BIAWWWITqThEKKpRb1GUIhuJ6EYkrnGOiaoj584nlDj1ZIsYzKAgB2k/GXLQIz3pyg6J8qgARkGBcYyjAyMZxUlS0o4N5NsLXkADGuBKJn5UAiDlR8hSEtKC+EOkEhT5QUaOiiEChOQlk5jJWTKxlraUIgM1yUlPOgU4DAmBMEMwQwYY85jIXIAyl8lMZDrzmdA0JuvMCBG2GOCa2MymNrfJzW5685vgDKc4wckCFqxrXXxDgTpRgMWWWGSYxDReNI3JzHouYJ74dOY0qen/EGuO858ADahAB3rNcp7zBulcZztxIsAIODQC9bOnMhVA0YpK9KIYnWhFc8hPiZjkmwcI6QEI2k2RjpSk2zQpSrNZPgxgIAMZWChKFtLQh0ZUohW1aEZ3ysyccrSj1fQISEW6Um2qtKjYPGpRW/rSmPIxiwypgFQrIL985tOeVkXmT4HaT4+Y9Ktg/epQw0pWsXqzrGgl6lnD2oIWELGTKUiBTElikalSNX5ZnSdW88qArXLVICZJa1nHKtiwErawZi0pW906RLjK9aktXMhDIfo+ivL0sgvIqWUx6te/EiSwai0qWJFqgNEi1bTXZKpL5zoSi0y2fpvFbEY1q4CM/3bWs3KxiFJXilreJta3u1UtBlgLkjgtYQmvfd9FnynbnRqzBCUwySe52sjjFqAAKUXsV6/LXewaVbsm7e51swvekIrXu9cMafni2klG/bIsCzluct23XGc2N6PPja4qcVuQ6i5hvN8t7wHOS97yEjjABhZvNtUbPPbSwL3o+59kbapc59r3vhe9LW5BK+ADL9isgvUwNkWcXgEPWLwM1lxc40pcjkhwwg69KX4vjGF7atizHE5wdwsc0hKjlcQGALKJT9zdFOttxY/dn0xePAWHCrOYWd1rNJWJT+je+K8fLe2QT6rYHmsZsYctb5jf2skHQ5YlTHZyPEOXVylDk//K87QyGfn7WaF+2cSE9XFhwwzeMTe2zC3eyDuHCeUp15OvWb0yV3Pc57UOmc/ahXRbycziM7szmISWp14Pjeh8KhqojI60o/E8agFLmrG1cmygUcYQh3atNZilbY0l6iApKJm/FhHgOL1M2l1zmaRL5LU3l7hOdk7hQT0C5oRfDYRYa3bWNuaRrYdH59w60te9/qewCRrsX3eT2Ao9NrLZs5BRBgHW0GbufT9NTSYvhKxCNnG8O6xgLWsnpKHR4UxdCEOOoXvW6m4uu83o7inAu94fpveOEQzeAzMY350pI1QnLOPLBhzaA6emSc677TsjluPe9nhhQV5g4W1G33T/bTVl6Svbi88642bcOIpDrnDudrzm1725SE2uGZS3VuXyw7CsMT7naoNGt6EFrlo7DtDefnOP+ZZ4ZJscgaDfd+gvL3q1c0xa0zJd2799et9M4/OhvHIhwqzqMaF9z07LmU3vxW0joQCFbNsdqW01CQn2TgIQ+P3vEpDAAx7g91SyZbojaWTa8br2dLtdv3A3OlbOPgW63/3yJM27R/je97/7PfCDL/whDx/3iU/hyWAEkKHxCefVbxrmO8wy5mcfUIsE/vYSuIDud4970cOe1WiPZ9dcT/w3t93Qv4+e7GnP/HDaHve5373uew8Cw6vnbxSvMNbZntln1zP5rct1/xR8/XWC7la0X30+9KE/+PY/AECKm3qMte997nc/p9GOf0fFT/6Qo/T8SgdxC7F+6+d+gwd/19dHr/QET7B4XeNmnUZjy/RMb+cppfdXc1d3DCdmJLVl/odN7cIQnjeCgHd7vmeBUREnDOiAHAOBEdh4zeRMFQhhRpeBPMaB5rdl3xSCC0GCJEh91od48DUFx2Vu/1ZjLrdTM3grF0hdlGdd6JVU8oZwWjZvOsZdJRaCx0WAXHh7qSSEoPRKRdhv7NNsjpdMsrWEYEhN/gVgCXeFbliFVKhnDVdvIaWFS9CFXfiFTQhMDiVVhRZlFoZo4Lc4y9d8iGgA6PRDFjF4Fv/wiJA4ApI4Apy3d/rXQn9YAYFoVTwVgYWINoeYiMy3iFA3BY4IiY84iZRYiZfoLCpnhGYIcBKIWZ94NBbBgHFIh9olYuY1hyL3cdwFAzBgZIzBgGV3aRMGi2yXhDxViydzi0+Qi784clTYiwv3hnV4XcJIjIthjFL3FQuxgpmmK0HAiZz2gjIIeShYg5QnQI9WajjITWTVVvSIakakNzZgA4rBgKwUEyrYgOMIRuYYg+iITGrYhx3VSO5Ial3GkPK4WPVYK5qTj/v4BP04dfCkdvQ0iJ1mW1pHZ6EoipcXRzVQA6ylZLeGGZjGgqoHgxiFjh7ZijFnZyJJeyRpkpb/VmeARW0xQRGiEo5P8EIsGQQuCJPnyADQdZD8RRFUIX5kBWlgBo+Nlk201F5MCBHp05TreBM+KQD/KJQhYHUEWZAbOZZJqY406FlMOXlOaVhSKWoNaWraVJVmhnhZyZZbuTXyRWFl6IL213r65BHHBSoFBxKhBlZABmTYmFZWCFbr9ViD+UHxhVx8eW6xOIGzeIaBaRGR6SOFiTRI92O+qJhSCIzXWJph9ZiTGXtRVQGox2ZXdZRkaX2rdhMJkAAZI0Jp41VuGZfxeINTiU10WZt0UVeuuWagM5CYSZbGRJs5qRW3mZsetJuhGXYbGJzACZfCeUtWmZKgYlyUOX8s/7d9bDd0zTl6qMEYiWQWEREnD2J5WkZ7OpdtRiaMVrmGvwGe89U+GoV/f2meDOCc6TkY64mf7ikF8Fl+p0VzH5iDmmOfdYmQv0ERKrGSYcl4ZSlRZHlRQiAESzigfPEgryNoNMl8CpptSzQDM0CcUUGhCmGhGskAM2aU9tShHwqieiGiFcGTERGSl3eivZaiK/qcKbgTDiAQIRQAx7WXFXdR5FljtPUDUvoDrZEDOVAj5UE4r0E4mnIgPfGlF2ikDtCVXUl38FmT4gREm/RNBEAAEYkDm7RJLgWm+OkoRoqkIbSklNmkOFV/0BalU1qlV0ojWRo2Wxo2XWogdBqmRv9Kpj5pphqIpuGkpi/Apm5Kj4kSpy8wp3TqI2KaPrd5mwzIpBX2ly0noxLlPrhBNl9SHuBRG2jipV8qEWI6ALZ6qwK0kIg5c142ZEUmUvU4aTigeQSqBO4FpgJRpwq4E6AaqqO6p6VqqhaHqvakqrpxOK3qqqtKG7GqqLPankZ6q7iaqwf3q706hTkHrMGaKMTqFz1xrN+qrFUSrgMAlObWkkbJnM7UNWIyG1zyMc6jPD3Qrz3wrySTqMgaEV1ZqwOQq1EgWFC5Z9gUrIxFGXRHg/KaFAxrr2TIMRt6fPrKAPyqA/7qAwB7LwKLLyV7spriAwOSsBCxsPTqsBD7llH/eU0Uy4ONcbFXCQAZWxbMGgC3qafiyZ/L9KSztn0ZOqU/QDhYSh4MwgFRe6jd+rLfSquN+qhmmog6l7MYQxhgmpY+K6FFGrRDu6RFe4RIC6V+urRT6rSECrU6IrVzS7VdUiAwC647UaZbi4hdu65fW6zv2rPJSrZj8alKirYrZ7T9qVP2p7TOxLRWCrdTiziUuwGasqgZIaYUAalcy6AhRbF6elwGaICBx3nOqbnNgrhEu7hq66fl2baRO6WTe7kbUKi2i7mTorpYu7cC4Ll+C7oHILqjW7rud7p8l7qdijb66bpAsLZCB7upakoVZEPUWz83dEgFarhaeaaS2k2a/9cTxmu6Jlh96Pmzl9G8sCW9Scu+9XS97cNF8Fu9G+ReF7kVr+S937tN4asE43u85RuE3HsZXVmhwUeO+OqSRclXF+UBHgBdX5R6htShEexFMYQlHdoaC5Fs3vkQFrG/3FRO5WQRe+d5H/ABAOx+WPIgLKoVBfyiByzBzLicL9jAD1wCEXzBRUDBFTxDOpzBQLDBEPKNjMMQILxNIswCJNx5fnfCKdx+KzxtHWyLQBc/zQW9V6cAUkpRMTS/8Wu9hOQuyUaiuha841SKesiFGixui1bFDyhbWHzFWvwDXHxBXqxBYDxIYjzEZDx+ZpymYzeAabx+azzGHxSquMlvMf/6sWOJaGJJw4wMyUh5lmjJo9Kzo+/mkNkJVm1lUuWzxJXIxD4ok+uByFrUsQkcyYDpyFYsmwXpgpRcySAxPQanyde5WJ4cPKBciT74d6QcIUIMARCAxwDSvv75uO4bvccsWy38wUfMN9zIGMcIMME8zPDTgmy7zLGrzX+azJxFpB5sxM8cA9G8GNN8MgzIgGl7mRlqqu38l+9sf9FEU1EAEv5TneFVAG3appvMmDNnQI4hEJ1pRun8BOscg9KKmQkNZwsNslrlSPbcP/gsUte1zwTQz6L5qwDdGAK9BNHTlad8r0QpyTRK0jXsyiUNmGfZzOLsgRH7phJpPlNcEHb/cZvnTBogzW8i3civjNInzdMpDbIrDc5dtRC6iJ23HLqY2kYybcnhLBA2TcSggsj/6FAircoO3dNA/dMmfZb5JbaX/JOVF6moKZe+qdTCmjWI15VaCdYnQ9ULaNARcNVabdIRuMB37dNePcluHbM+GSf6O403+5CcvNRq3YdsjZd93SwuasCnFwJ0PaNcjdeCWF9BrUwOzNJGLalJXE6JclAtvEONDcOPHdkvWdeUrZypHZv2lNlEfUabjaadzQKffU6hDWoqd9B9ys3G7LjcF8dwXFsLQEJOnRHO3HQNSlKf/Npbl9vO66TeLMe8nc2+HbvKRNwpF9tgd3fLPdOS/0fLL/RCCFyO1GrXqBqy5b3KqJ3VnsjcAxGdDPGUo3bUg+VNRHTb1ATe4T3e78x67D3Z/53XW02I7g3ViZzJTodg9C3f3XTfBb5hzt0aHdqh6t1mHIlonQjglK3ZU3DE2wlE+M1PrkVhEy4EFV7Zpy3gKd6RF76ZxV3E2g3CV/TgTti6gMRygJnQaIhh8cyRbCdn6AvYUOCr3MXPSV1WmpMoDIi+Na64N864IKvjCnyqPD7lzQXkA/wT+Tvk6KrPF33kZJXkOLDkWQ5UCeHY5daxR3jiFm7ZGn6qQf3LPpqISezgIX40Z07aac5sq+3fbq7iVR7nCWjcJSrbImznNP8+k9aGo4ze6IlB6Ivu6Hxx07gd6ZJ+6WQn1Wdk6ZgOF5Qu2l7pAA/SSJ1e6pOxvQ6R5zsx6pRn6m7hBE5wv0AlKqzu6rbeGKh+EKou6lJA6rduErAu6zhGbb9e7H4hEIYcVJxu7HYhQJK3k3XG7NL+FsjOxz2KRtPuLs7+7DtpEkzw7eBuBOI+7uRe7kbAA+ie7uq+7jxg7u4+7uwe7+n+7u8u7/JO7+Uu5x4BwIM8yKXb77e3xr/cxt4O7t+O7+Zu7/GO8OWu8OzO8OTu8OsO8Uag743YfgDv7+QL8AI/6Nwezgth8Egw8iRf8hRf8iif8iR/8irf8iPP8i6v8uT/TpyO7XmgZ7yomIqrGMo/KHg4D4mDZ30fD5pTIPIuD/Mxj/JIn/QrD/FMn/Iz/+A1X4Ljm/MWIImhXMIjePOli4pBj55DnxHwvRBNUPZNcARofwTkzvRJ0PZun/Zwn/Zrn/Ru//ZxD/dzH/N13/Z3j/fjnvIcnvWi3Mt6qHuC38ueJ/RhLxFjPwVmf/Zy//d0v/d9H/nizvaUX/lqL/l6n/mVn/ckH/hZj/glyIWGP/qkb753jmUM8e1QT/FG8PRNv/RJD/uxL/tI8O4WzxC41/U5r4o8v/W3N3i6d4qoqIoD//EW4fpKD/u4n/vOj/u2//y67/Ee5RG9b4BWD/y81yz8N1/8D7D9k5j81WbK2X7+FgHfhE7L0v7pdGb+6I/+6l/E7M/s7i95Ohr/0+5zeb4QCIAAADFF4ECCBQ0eRJhQYUEBAgQCgBhR4kSKFS1exJhR40YAUqQ0XBhS5EiSJU2efAggpcUGLRsIRIAA5UyaIKdwxJlT506NKwHY5BlU6NChMX1CPFqxpU+jN4kObeiRYtKnVa1m9An06lauPJtOdYpxaVgAX7vijCoF7Fm2Zw22hRvX4luddOVyFBglypIld/0KtftX8NbAeAsOxjpFL1/EVgMCACH5BAAGAAAALAAAJgAsAYwAhv//////2Nj//9j/2D7/nj7/dxf/nhf/d//Y///Y2P+ePv+eF/93Pv93F9jY/9jY2M62Vue2F862MG7nhm7nYMC2F6i2Vqi2MG7Onm7Od+eGbueGSOeQF9iePtieF86QMNh3F8CGbqiQVqiQMMCQF26onkjnhkjnYEjOnkjOd0jAYDDObhfYnhfYdwC2bgC2SEionkiodzCQYACQbgCQSOdgbudgSMBgbsBgSLZuJrZuAM5IMLZIJrZIAJBuJpBuAKhIMJBIJpBIALYwzrYwqJAwzpAwqCYmJiYmAEgAtkgAkCYAJiYAAAAmJgAmAAAAJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAj/AAEIHEiwoMGBDx5AWQjlyJGDECNKnFgwIcOGDylq3MixY0WFDB16HEmypEmOFkNmPAkx5UKRLGMKdIlRpk2ZNGHe3MkzZs6VJgMIHZpQJ4CiQHsaTMC0KdKhAZAqnVpQgFUBUgFYzUq1K9WmCRIiQQKVK0moQs2a9QoALNOnRB8YZbvzKla5Gbfipcv3JlixZOPOZYmU5sXDiBMrXsz4sMO1fXcWBtm4suXLmDNr3vx4783Jm0OLxgg5sk3Qo1OrXs365ZHSLBcKbE078WwopqnKBlC7t+/fu3fvDA6c9u3cU4kXX84883GliHXo2EC9unUb2LNb3859gwYN3btj/0eM3CviE+jTq0dPob379/AprJ+/Pr599/Tzn7h/X79+GjRc5IQTXUU3XXgbZKcdgtx9x+B1NpBXnm6H+ccef/FZWB+G8GmoHocdeqgegAISqFRKTDDBAw83tHgDDjDiQJ2CNNaYXQ041uDiizHCWCOMFw024WeUQaHCkUgeOZ8JTDbpJHpORmnCfElWqcKSUjZJpZVIYpnllOslSWJNXqGoIosu9jijjWxil6OOafaIw484BJnUkERexOWV633JJJR+brmnl1kKyiWhUho6ppAULiTEo0L02Gabb+4o55yTRngYno0a2WWfgYa5J5/qSXnkn6IOCqqfrIKpnpUAjv8pnHkMQRppjJnaWGmckmYqIac96flpqaG+OiqiJpzqanqjkppeq60aemSsATLEVkpjSZdDDt916+234Hq7JnbhgUsdkFA88QSjwJqUkkMTxDvBl/FiKO+9+NI7gb349qsvv/3e+6ULLix6Z0/YIqEtt+E23PC4NpT77bl1prvuwe26CxK88v7LX8D5ZlnvxyB3LPK+JJc8b5YEG9yVmT3E3AO5DzI4ac3oupYxTkWO9Z6IF4LYHtD7CT000EYf/eQJL7zgcpkgpSjzzBHXjODND+ZM5s4n0eQzfkgnTXTS8oVtNKCoNv00WxdJ5/aBVidoY9zh/cr1Sed5eDbRRYP/OF+GfO/d9OAvXMRX22/DbTWbdHdn990l5a3h3mML/XeIlfvNNOGFW9sX4lPvsAPNDTosbnU1SswY5B4pBjKrI8encrywoyz77LXfN/sEK6xAMMFNG04X6DKLTvp2pp8O8fHWfbc66xy5HnDu9u1O/e0qXw/f7r3/7kLwnnflgAMXPTr1+TJL98P6P9jqvvvoo69++0IoNv6s0BeEAALKMeT9/wAM4AwGOANqUYuAMwigAl2AQAPGCoELFCABHQggCC5wIepiy/1qJYT4nW9+63ufCDvowfTpIIT1S8wG8weR/fVvIRGMIQMnSEELypBgDawhAW/4uxw60IYBxOAT/wrEkApUAH3vQyL8zpdEJi4xZop5DgsP8kIoEE6BVwxgFgG4xf910Xtf/F0YgTc4LJZRi4MTHhEXYkQl2sqNkIKj+Zz4RplFkTe4mSIV84iYMX7vjFwEpBcFCUZCitGQZGyaGRWJRkYGEnz461QEIpC4SlqyhD2wpCYv2YM7RlKPeLzNRRLJuVL68ZGmTGUEHRnDVLryBTxsWgYy8EmeXGSSm9wkJnPJSx1A0TahBGVBqkjKV55ykMbk3CphecNkljKWL5hlLU/yFpCMZZIc4EDM5tiAbjZgAQvwpjjHSc5yfhOc6BQnCECgGHaxsJqIaUITDEDPetLzAPjMpz73yf/PA9jznwbop0D7CVB7DvSg+SyoAVjAAgfG4KEx0BlP4AmFa0Ygm9skoTjBac6OdhSd6fTmOtuJsSlS9CLyVChCEarQe650oC0N6EsFqlCGOhSiEu1JWqyJhEniMnEcPSdIh0rUcHqzqEhdwEgdU1Jh7nQhAxpLAQpAAAIAdKb8nOpUq3pVrOpTq1S16j+9+lWtVlWfpUxBCh6a05s8taI99Wklg5rUpG60rkNdqp2EGZG3RhUJWxWrQcmKT7BydayEPYBhBVvPxCrWrARAK+fUytat8WSDCyGBZkmAvrsSVQGgVUBdPWrOO/IVIphlSExXy9rWuva1sG0tAFFAWxT/qPGy5GPIZjl7Ps8ONbSitStpyWna0xoktQuJrXKXy9zmtnS2tb1tTN5q0Z++ja54Japvs6tXlRi3JSD5a2C7StjFkpes5kVseSErWcJRNqKWtQl142pdt2E3uyDdLl6729bvIiS8TpBqWM/r1fQOdr3jVS962ZvPtK4Vvu70CU93W8fhane4pOVvfL+rlxIdNKaOxSeIQzxiwmaRtpWNsMYWMhYKx7EHFh4qhjPMTqb6lyAdZsiAPtzSEPuzxyQGsonPiGIIN7VrPMUmB+YnHeCOdsblJKqGVQxKmqTUuVjOspafO8MBwgAGKT7yiuGqZCbrwMnChfI4pVzjvd6Y/yBWnueW50xn5+KQgF8O8xqhkE2M9laoIVWzOS/czeK+WZSqbeyPXUrYLDuWtUNmZG1tGz7oMKTP2vwzoQVNzk0b+tCIGeyByeroxEKarCeObqWDRWafxuy6CwBtULuJ31obVZwlGtChh3mYmRpY0QgesIILDFkCD7SUs5Tmqm3Z6km+2r6xDq5+bV1U4up4QCbaNaIX4utiDxurv2b0ghM86oMiO9nS5dlCUqTZOcaM1jLmdJTj3c0pi7nKRdoxTIVsan43uqXUatpMU13Z/qobCuwmgbthDOhZy1u/6myzd7VNE33T1N+kxrhXYxrwFwycyCgo+IaHo1sSzPW3of+ldl2BK2t0fvrNQlSXqOssYpovmsv09I2ug0nyzJocqChvucqLyvLggvPlN475E2ZO55o3/eYKJVjOe7PzaXJkf2byM6xr/XB4g9Te2j5Kka5c57LHlqEtaIGserOEJcBmJFiPGhO0Dm2ud53NiKGyHuNs9r6/Fu1qr5Zv2v722DDE2SbMbtGHjlTQIt2/oV4tP/3+beYSbDlSvMktIzA16Sie5YwnugIe/93IlzihlAc26pV7+eJk3iabR1/o87tmW5PeuBcR8FQBCtbdf7vbYDU28LXqUsRI4PjIT77yJSCdyiTn8Jw/3+wDfVTbAzPsuQcs8f/Z+wII/6Xd//7/SsMvU+Mv//zHb35j6nKXi7T7xZ2md9e9jk6wHzrHUHXCTE//b5UGmZ5pdxEjMIAE+AEGeIAIOICPknf3RhL4BwXvx021R3vzR3/gZH9v9oAWx1Iah1X8l3EA2AICSIADiIAm+AEKmEJutmf15XkhhWbTB06L53LXp21Kx3Rz5nQ5CHUtNSALAQFAGITLB4THB4Tql27PtxAtqAO0B4MxOINHV4O7doOKVnY6uGVX2INO8INBSITK54VGqAOPcyJJRklAB1JOOH0ziIGHxneq93RZ6Fz65H9jMhZF2IVCqHwGuIAT9zJleHJomHIxKIOgp1QSZ3D+5YbiBoc8KIer/4dYdYgEd4iHELB8e6iCI2dpSmiGbwOFT1iIRHV7p4UYk6dlpVhqc7harceFXYh+yXeEeXQ40FdJnqiGoDhUoshXpLhPWMiLpuiLMbWKUECJroh8sNgV++NCfNZnz9Zkt7hpnIZUuchC+7NtUJB62FhPDGVTBnQRBkiJXWgB4jiOY9gTycg/y0h3zpiG8heNRTWN+VONeHQR2ZiN29hQ3cgQ3wiOQDiO5LgpdJEwPsWJdYdftahybPhmithaqdiLcRhbBINPaiN4o9EZelcSAilXZ2iQz4iQh5iJxrWQp/aQzNWQzRWRBzCRq2GRDbgRaBEVPJVNEahRGAaN8paQN/8WZz72gRvXgWmXdg7UNDIgA6mRIoU3Ei+ZMDKpcPBXk+14kx95kSykk/9XUDvpkz8ZlC8wlEXJBEdJGGW4hIFIiOwYei2Hk4k4dnKmXCaJio0oW4PElSD5X0bxlUjGYvRFkC5IiGQpiIN4llHZklOpliX5iG5peXFJlHM5E57BmFIZOdCHeFNDe6EXf9kFj3q0iwLVfVkYbFPVmeNWAKVEW0gYEeWoiVAwkLIXUpU5gXiFmVOkmf3EmTzomQUAmsQ2VaNJaVZnEKdpE0yxeZP0Pu5IgfIGm1RhFb95EEJhejL1aB24f1h5U6XZLsEZmRFAnIJmk2qGnFOhnADpkgH/4JxX6X/QaZ77BJQGJHImlQDCGX1TM3/c2VF8uJx8AZ4EcZ0bAZ4X0X9WWZXi109pt5vVCSzXuYmSKTPy+ZQeVZ/hOSH4ORD6qRH8yRD+GaArxZMDNaCcQ5rLdjfvCUI/4HBqll0e9UvN0RqvNxHOWY/Y6EAlUAIF2i4hekLsQ6JQZqIdhaIpuhorKhEt6qKUB6My+qEZU6NbF3R++Ymg5YI96qM8pxFBKm4kGVuniGX8VEoYgAEzCixIWpCBWJaMB1xO+qSp8aOmeRjoWaWwdaWO2F6Ds6VdWh52kTAz+W7VZ5wLapzr9D5AAAS5UiO70iKXEqg0ojV6VxYgQXZW/wqgiKWeACJwHEhPACRyj+kVdTphTCmBFnhrFbhpfeo+f2qoCjKoPNIrpGoDiNqAiroQjNqmjjpYkEoDkspjlPo/liqYI5EQYCEUTCEUY5EifhafTjmfw8UAyMoAwNUBHeADPhAEQbAjhIorNvAm1loD3hIC2rqt0nqqOGA6DmEUmZoQdlGuAiBPr4plDEVP93iPaReCPxmvgReAmuEQrhGu+JoRl0oR4zM+BHGOCcGrTeGrCQCsSCCsmUasMWaspJWsyhpazOqs0NqtvXKtb5Kt26qtFBsj4BquOHYVAfsA5moX6LqWWrauC9WugAev8qqe9JoZ9ooR+eqxALCvE//Rrw7wr8mYEC+5Uzw7FGNhUYA4iCrXqW8THobaONzRI96CrxsRsgMQtQOAbfo3UIH1majnWGCFTy27dqnhEAPitDWrqyzRszD5swYrtBtJtLZmtG6DtIGqtNvBtN0ithQBtVJLtQd1tbeZtYm1tQfQtRT5tUcQtjRrsz1hFTi7P4uLjgsxrJl0ZkYXbQ/3ZOu0TvV2ud00NRf7LRm7sRVrseDyudI6pwdRoULKriwQjC4AHATRm0qhuP3KuLPruMvYeZIbiJUrXJcLApmLuQ3AuTkyutwqrYVaraLrucW7I6ZrEKibuigbda37G68bi8ACFReRTUPLtq0ZOjsgt0n/q7T2mabJ9ZyheVZ+u14pkiILUYzL56De6RXYe2lLtrbcO3SbWzzfq7Th2zjjCxH0aL65GVapqLUFsL5M0L7um3zwK4UQehU46368pbANx6DbOVQe4AG9O0KY9CgoNEIcXEIeTD/roy7EQRDjI48AnGipW1Aq640neICTCAHiCK3/ixx2EcEl11l5Wm2fisEafLkh7EEjDMIg3MFCgEIl/AQnPBApjABAysIt/E8vrI8xbIAzXMNBcMOckpHbG21iOnSemL/N2EuJg0ll3EvbIh02TBqNqREJoS7pOsX/RK8OQYyueIkrOJh4KZZKKnRMuqRkHLlmfMZoXMgLw8Zb/+zGUhnHTzDHdFxPdnwEeIx+etyHmQkFA1Jf2xLGKneQSOWCvYS78oPIb7MtHiQ8sOubUhzJ/0QwJgwFC5x8Ydi8R6rJTsDJOeDJ1AbKRSXKvETKH2TKboPK8aPK1rsRAezKAAXLTCzLs3yHx6hHD3inDEdOLZfNS8qww1XGenrBRJXBwNu75Cxx7pTD/ZoSkNzC3rN2JHjFWCwBA7jH+VPNm0qT2Bxc2gzI3Exa3kx9xQnE41zOl0vPVQHB6byoJuvK7UyR7wzPxzfPmLwzbuEUMZmwCnp3AP3DOLqnRnWBmntO8LZUjAIWAvGrAcCYrmqy5fmf/BSvADKrK/kab/9snRUdFhfNw7vb0RrN0zv90YYIvNhF0hhj0m1RsCktditdbiDo0umZlTQg06rBkvUsADrsczot0hXs0f3sUdPHabaMs6nFzAZwZwPktZoRy2jaLrKbWpqV1fe10SWaZvL21YIW1mK9zJFs1gU0uGn9zGvNNe+pnXP9zT/t0+As14BWWkaqzIl2ntG5T5HKObYcSavspdhJ2DlqwQGN2IWt2IbdALbMyuUL2Ws6UJNNOJWdzFGaP5tnRJq9sHT92Uh12D48Y6PNa+VL1jmU21yM2ZsI2+5D27ed2LVd13jVnY0tpa0cyb293Cuc27lRoS7Gqa4ZppPb1R8128bN2eP/JN0AMNZkXdY9NAPgbVzUvVkVNm+ftc3eLdvaPWjczdiXfVy5tdvM7D0DdN7f1Zy4PJBf/M1sa5kxSOB2zd/9CX69x3sL/nv7VEp4GXYU4d+brJFJapMDft2zZ+AbLtrQzaIWquDBx30NztRZStlwJeHM7XMz+SjyHdqd7alcLeNbfdcfDhEVKp2n3ZO3emf8jXsl1+JC8OKKHeMV2MM4Gt/eBN45/lIaquPk7eM3LuFfupfo5Mti3JFmqeVjynIIbjGjxoisS0Y/PorY+cVY/slcnuW8bGtF9+Uy94Y7WKWFVOag5N8IqpdMGG/4q+GtOW2Mx+GhOOUrrHve5+Dj/1fiqgenY7JzKg4ReJ6aFg6mQE1tgh7ofo7pgA5SX27oGGq1ik6lDTY4jZ5tjw5nReJz6w1xR17jR67kXp1X5tyAJwUFkNyTbflaZx0rBq3ihgGB94ynrP7q773ZMN7d3aV3tX7rHmi+zLXra4e4LFR1Zlrt1k7tjm2N1u4crS3h1L7t4M4c2M7c2h7uztftYQeeyGXu7F4bgS0QG7Tu7c4Yynjq6n7f857vUAq78Y7v+r4Y9f7oWfHr/17wjUHVE4EaBs+AdnlaA5/qCx/xDF/TB6HwEu8aDW9cB3oYStDxSpAESTAEQ1AEJF/yIn/yI1/yKq/yRtDyLk8EMB/zMv+P8itf80Xg8i8v8zpP8zbP8jhvBDq/8yd/w2Bhfsd3ARdAgg8Nzx9QjEiv9AWIggTYwPX9XRt/ER7/8SGf8iqP8iLf8z6P80E/8ycP9iX/80A/9jDP82aP9mq/9kP/oBJR9IeRfE8P9SPA9PGMfncP9QZIglTP2qeO6kIE8iDf9j//9kTA9mDv9m/P+F1f9mZ/84n/+JLf8ogIxzyF9H0f9Uzv9Jzv9/DMh9KukCChLoafBIgv9pb/9ZPv+GoP+SYv+auf87F/+UaQ+Xe7+aGv9Hrf9K7I+Unv+6OfQqUPagyR+pO/8l7f/F6//JHv/M4P/bMv/c1P/V++EEsvw8j/R4n+KI4iEP4iMIBAWIImSMt4uD52nnTJb/jUT/LWP/3vH//XP//0L/s9n/1QsP17LwHe//0AIUKgiBEjIEAo+EHhQgkNJRyECOHHDygVoQDAmFHjRo4dPX4EGVLkyIwCBFiEkiRJEZZFhryEGTNmS5o1bcrECdPmzpo5c/IE6tLnEJQVSWJEgKAolIgRLTyFKrDg1KkLGT5sehBqVIJTlx4FG1bs2I8mUaqkOVRmUJ5qZ7K96fYl3Lg+vx5NujSr1q0WpFKtavVDw70Q+vrtWvAuWcaNHWt88GDpZMqVLV/GnFnz5s1HjkT2LBL0Z8mcTZ9e6nn0Y9atj0ZGHVv2lGzanUmHDjkadm3elFU/wO1a+HDIwEn3Rp5cOconT5o0WZ3b+O7lvX8HJ569te7S1b1/59z8eXSQ3MHXvn5E+3rXRje6Zx8/PvyM9EHaB4BfPkf8+vf/v++i9wQEsEDW+iMwJAQN7GhBBh/kiDoosIOwwte6m1C9C1GisEIJO7SQwQ81DLFE6TgkcaQRTQRgRRbDCggAIfkEAAYAAAAsAAAmACwBjACG///////Y2P//2P/YPv+ePv93F/+eF/93/9j//9jY/54+/54X/3c+/3cX2Nj/2NjYzrZW57Y+57YXzrYwbueGbudgwLYXqLZWqLYwbs6ebs53bsCG2J4X55AX54Zu54ZI2HcXwIZuzpAwwJAXqJAwbqieSOeGSOdgSM6eSM53SMCGSMBgMM5uF9ieF9h3MLaGJrZuJrZIALZuALZISKieSKh3MJBgAJBuAJBI52Bu52BItm4mwGBuwGBItlbOzkhWzkgwtkgmtm4AtkgAqG5WkG4mkG4AkEgAtjDOkDDOkDCoJiYmJiYAbgC2SAC2JgAmJgAAACYmACYAAAAmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACP8AAQgcSLCgwYJUEio8yLChw4cHFS6ESLGixYsRJVLByLGjx48YNW4E+VAkyZMINaJcydIky5cwW6pkGaBmgIQEBQjAGZNigp8JeBIU2rMoQ546dRI1ytQo0KAjbd4ceVIqUaVUmxp8uhRAV61FkSb9CrYsSK5RbZL16MBBQgQIRMqdS7euXbpt15o9mZcK3LuAAwseTLiw4L4v+/41zJgx4r09FcdtTLmy5csSH79MiBWz55l6IZPkvPOz6dOoR4buSDr1Z4GrRXts7bq2bcKws27WeORIj989dAjXkaO48eIekisPEYKH8+fAgQ8nftx4cpeyjYqkQMGE9+/gvav/GE9+hfnzGzZwX989vHvy5c+bT8+eu/v38FXIn6++/v3wN9yAXU8i9RbddNVZp1xyzD0HXXTBDZcgch4MmF1M27X3n3j57bcCff5tyCF8HoLInogjxiefieuhaEKAFsLUV0JDDJHgggwyFwKOy+nooHMQRjhhDjFeyNKMVJzoogn56XfeeCwuyWSHT6oQ5ZJNygdlf/ZtKIMMEmmFZI034qjjjjx6cOaPPAQp3JBFGokSkkq6mGWVV9pJpXlb1oninXxayaWG930ZZlNQQJGQEIwK8cEH00U63KOUVmrppZJmqkNCUkjBBBNy9lSTRBWUauqpqFZwwqqspsrqq7Cu/5rqrKjGausJtOaq6q224uArDpxKUVaiizb6qKbTXaqssshGGuynocY0qkK6ugqrtby2Wi222eK6ba3dvvorsFR0qlVSpSXUW43C/SbpcQ662WymxbXbQ5zRjqaQfLGKGKuH/MLqL6wAn9fvhv8WvMKtM8zg66FFoSvRukPY+65x8UI4L7052Itvvh9JFPCrA7+q8MICI0ywwgf/l3DBDDtMbmwoSdSoEGl6UKmky+bM487DfQxySBrRWt/RhLrHndFI+7nq0SIuPWvTfipNQcMNQ9yUzY3mDHSyyvqM49ebzjT0SSIxTXXS4Umd6tpdevd0iP+5jSrcbIPHHdYzaP/NVEKJ3szob8su22zhhQt9dkUSJRruq9+a+ri2kU8ua+S7xtzwwxNpBTgUggtBOOKWHk76pYovDlHjUFjubeWWY57547JnyzfnNJ8FFY019g4EEG9i/OCBG0cK74N1qW7RtCKB9zLAcrM6cMmsntzyfc97eCsLLHz5JYydO7U7Fb37Djx1xWVMfPESCg/kvXQpXxHzGjm/csHRrzq9yiaznLLL9wPY9rrnPfDlLmQKKV+NQsfABgpBgQp0oOBEMoUp5EZ+JVGNRrzHwQ5+iW8gDOEMPEhC74nwhCMsoQpXiEIRcjBr4ftbAiMowRpCsHw1bBQFLegV3WAwJbmRyAr/X9hCEA6xg0U04hGX+MEkYo2IftOOQjrQAQj2hlFGyKIResPFLnLxhjTEoha9eIS5XPCHR9GgEJcYoACN6404CBATv9dGOI5LjnNs4w3s+Cs8MtGAPsTQFKuowCsKQYtbJKMXwYjDRiGSjGbsIRrTGESF/LGOfIzjDeYoAz1mUpOc9GQm/chGAcWQQAqRgATEmEWK3eyRiuwiI3v3yjGWUS5nnCQQe7hGDoqSj6Q84i/tGMwhDhOOxVzhMXFAAxoccDapXOUhbblAR9oylhSbZS1beUuXPBNkPBGJB5d5x03mEZPANOcl3ThKdZaSneNq5jcr8pMHPCAhn1LlCEbQ/8Ud7GABC2iAQAdK0IIatKAATWhACwqChoJgLktYgi63kgB7iiQKUTCARg1wgI569KMgDekBNkrSjYr0pCItaUlRylKPqpSkHXWBC+BYg5rWICERjUk970mFfEpgn/3850IPStSiKhSgBnXoQ+WS04kSZKcXzahJW8rSl06Vqie1qkaxilKtcvQAMqWpTXEqUSkmxAIWAKoXizrQow6VrXAVaCSd6hCRcDWrWr1rSvOqV5B69aRirWkUd3PWtPJzrXB1a1wX24C50jWNEumrX/kq2Y7+tbKWpSxIA3vTU55EJ5VEK1rJyFiBulWhpR2oYx8rkLYgKSFeja1sZ0vb2v/adrYeRIFuUVDBeT4EtLykgmgtQNrSnjahqZUrLllLENe6RSO3ja50p0tdreZ2t70NJEl0gqR97hOCBD0uUpMb3tOulrkDEUl118ve9nq1YRzcLQoGu10BdNe74G2reMlbXreeF73Bha17B0zg6sLXe/Kl70okokpV3syfCoiwAsRL4dNKWMLH/S961RvbjxLYwwMGcXWb2DANmFgDCq5ZNB3cKAhjuMIwBuiFI5zh5QJ4KNDtsEtDvGP3ipi6JJ7BiVHsWZJYtKdMQKtaKZZaCqe2oSJp6o0BcOSEYLTAWM6yV1vQgrD28QbNFCwVpAyTI39KyYdlsnH3W1ooa4T/zACuMhWurOU625nLXvZVgMLcWTijMiENlubNZDxh8c640DEWr4aZy2HahtTHk2Xvo2/rwQxkwMQpRtuKBd0oQlP40Imm8KJZ2+jZTlrSkV7vqWtb6UsT2beMiyYVGxnq0xq01qN+rEQ+VYBeF0Clk6aqr32t0mH3+rJcNfavV9pXvsUgBiZOQQoyrS9AS2DWtBRCrRWL0FDnmq67ZsKwgT1ZYRu72OfWrLnHzWy9OhvaGpA2taFp7dBtO8a3VrSNpxxgKnRU2ZmFaV+VbVXJAnyk7T5ACE+q7BDqVt5mgwmDOc2oe8M43zVO3UTteoCDk1uvBH+pwY0d8KsqHIQM/ze2w1EA8XlbhLvPTYhay4dxixM1wkT9NhqdW2o7+9y6MtDoZ7KrmfreN5tDqPm9b66AnO+buTzP8c+n/tIvCd0zRH/uSpwrZ2yX7+L8Ne1pOcABN0vEz07lOk+tLFWqu32juDNNBe2JdoyoXSJe7x3Yw35csptdIXXX5d0VQue3vz3uQ58C3cv6kk751N621u/SGwBjnW+cColK1McH7msCEGDzIO/85xMO2JmhRiDmgonjmcDiQUde7JOv/NNv/DnNk/6uw/Y86HEv+t2HFPGmQb2wZGLtala8wqC2uFsjbHld9lzkPW7vj1Gd2Y6KZALYzz72IcD97nO/RncJS/80ja9t5M9Y+ctXQPMn+fzNfzj61Ee49TWife173/vgt4sME5L3GsGezeQlexrnfFJneG8nESSQgCQgAgzYgPbXfYyyfvRGBf2XdJRXYXxXYRL4Q+1ngD6HgArYgA6Yfd4XgbP3WWMxSEj3f+MldhfWgmGnWidIVxKjEVWlbn2FbJXlVSAogj7og9iXfy7nETXIfx2wgheIWvr1gm8Vg401g05VhApxgwWHWQhXhZjFgwqRgD/YhSIQhEMwgCpWb4JzXMmHfgl1aBuIQR04faoGf3UGQwlRf3RYhyaYEBVUFhMHeenHhGhIaBe2hvLThnBYXW6oZXJIBXW4iNl3h1T/kIdNMS2d0nqdhoHd9ocLJYjKE27sJnAj14kmF3qguFUiFXeMyIi9MYQkIYlSQInH52SX+IfKJYZoxInEdnvJlm6eyHmj+FW/Z3qnuIipWGQvYU+d4l1pdgT+Z1RHVV5M+GRLdXaMd2Ny1imSpYPXiIMnJVMydTvk8ikYgAEKOI4L2IDjKI1lYYxSgIyyZIFExW0u+GLQGGXTGGdrVy5SkI1YuIPaKFLc6ALeiE9MEI7kGILmqIDoCBY/MXGqlF8ZqIT9hVwD9XeqiEELWYC7qI/Ql4Wa5SsdNS6YkUs9cZHW1pAK5ITwKHkSKVAUSYx0RZIKsY8a6Xt3pYMeeQAg/3kZIhkTnUGBVHSEytg7LNiEMZiSLQlrZwOTAhZdVniFG2mFJWQDNmAZOwkTPfmTQElzSbiSTriVMHiU2vVYSkkF09WU2FhZUTmVlVGVglSSFCcEZ/iHcalQmqg6HHeI0rVqhphqGsU3HPQCL+ByXYGUseaWoTOX6IeYAFWXi3OXhZiXfEldemkAfuk9gCmYPkSYFMGQEkB+MKaYFsd8UEhqGPmU71dy7nVdqkiLCOSWnml+fiiX6jeaulaa7sdjqNlequmSBsGaF2FmrNdgfLgAoHlvydeSgQcZcpacBiFnhWdqTglpBPZuYsaccgKcgTacxbltxxmNgFePF7Kc4P/pEM7ZdtCJZblpYFjzbNU5nna5aaxkBIn2kKc1jL6JSr0ZlhkhER7oc3BUAiVQkbLBmfE5n/xFYfYZcUYymPqZn/zZn3X2nwHKm3IiERFwoRHAKF8Xmue3bY54G1QpSRbRgbI1mWUZmbR1YF+iWwIqGhaKoRqqdxwam4n2oSBKGWzZECSqY3jJlCg6WyoqAyxKoUxhT/ZUEwJBLFSwTxcKQTiXWGNXdg5FUEpFpQ7VG2B5oxC1BGTVVGSGLkZqpDqBUWRqnhC6UVwWXTJFUuwEAzBgaRFlnXsRpkgKAErKpBHgpE0HpW7ld1M6kX/Kkld6BFmqpfTYpWX1pUkRpvb/NKZlaqZnagBpeltrulFt+qYZEKfuqRVwARdh+hQ/kXlQcKGQ96T0CVB+KqhK1VACFQSu+qo/8AMUkiMNwiZtIh3oMyE8whxBsiCa+gRPQJ5iii4CUKaRCnQcZFVctqxdNlO/4qZwqqmbapVJ0amd+qmgKqqkWobEuaenugCp2gCr+qevCquymgMLsia2SjxDMqs90qvK8avB2hBhSqzFSqbHalUepKzM2qzjAq2ZKq1lgS5wQRB0KhUB8CmPx62YWGsRCVA3YziTAimZcjqYogPRwSOaChFhOgAe+7GdYo0gdXDVV1kkC1b/6KwyRRkRhaheOq1acbBSobDBOZwN/4tvKgmxxsIsE6spFls6GAscGhunHGukHwuyIRtSJ0uKn+hrH5WyKusCLMulYyawACCnymmkAvEpieKK5Vdr2wm2CuBP/oQ4YnO2OlM4yfEoGesBG2sR9Xqvz9mfMcWNwDe1ZCUQWBuzWgsAXAsFXmucHYqJEUa2O2C2aOsziMu2Quu2RAu3w2qskVq3XvYZLVu1eguzZsGo9/hdJ9kATwqRF1heXXlQNeKq9vI+68M+1JG6t0o8bfu2DIEuAtGxAxCy+dhV/chVKgW1d2sYmkoUe9sUnCsRnquVocuVMAiDpStQpxsErisvrNu6Qau6uBq7jzu7SVG7Rnu7Sau7Mv+ZgyXlu6Y3tZdLEMObjkZaEx47cf6EvN7KjMflhAzAAIW7A0VQBERABLb6ukKiq2biIz8SJNgru/Q6rI46tx4ItZ73qFFQkBCsgAkqrdl7nesbAO0bTe8rlKAbv+8IgPxVv/ebv/vbv+wKwOkqwOpDwMlBwUXbqEkhuWfKwATgwBEcwRNMwZpbFFIhEDURpnd6WFrJVtwGi0kFAkfcUDWCdFaETbG0xEEJRk7cG+d7tTtMZUaKuzOJi331jyBYkD84jsNowKHSwwDww0YaxEhIxM3olW18xEkMAlA8S1OsSHPMSHVcxVgbplosvuErWV68hRAcxhJ8S2QsP2EaUZ//gm2uJ7Y0in43M0vkl0ORLMmh00V6fMVhKsMQ+rTcSLMPuH0QIMrYl4BjXMHKk8hLsMiE1MihFrahVsnaRMmhI8lDcMlclMkVscn4Orke9Y+gTIKjPAHcR8oTYMqGjMogw7ldR0hD3G3NC82A2lBYCgJPXEhfhM3tCMV13Bv+RMWP62fAZbse28d49cc1uVFQW7mYBwVeKILjyH3+dMhDw8z3WIEfHM2kO83WTKj9TEZNzMRDANC9081c9M1H8LbiLADca09Ha857hc68q87rzDmJ8s4HmYDyvAP0LCcIGwAHS7OBe7M2p182S9Lze4Hj6sIU4dADUBOaCmKY1Wue/+d5Mt1S4/JswXyKBcnSQ/PRIa2wI43SDmvSDEvUKQ1QK221ReuxMB2nNz1yNU0AUY1SOR0DO82IPc3UqvMUYfq3jPxAQzBezFuUC1XWGSh20UzWC6VUHW0QdcrLz2mW/fiPvpJn5UsYutzVQPHVTJAoYV0jbL3WZ02UaT26zTvY4upQb10QcW2knEzX6GzXOIDXeDsS6Zu1iwfYrVyJjvxihDu4svnIFObWyvzCD8DJ/clBOckYe41BqszZr/nZNNawsJxot51Qpp3Zcg2pBsjav3LZmQvbF9wpModfn8vGKf2tohuAIBxXShVhjd0WcNEWcavaHvgl/woDBlywAP/gqQ+AvktgT+KdysUtBcd9vBys3K93oM+dXEa8WNGtANPtANXtANfdy2eq3c/K3RXs3eAt3uQ9EJmdHQTaYjtA2jMK2qPN4GgImi2aXjFpeJMWQsbdoPtJpOAEnwiu4ILr4dwp2g8u4gkV4ZVkgBUOQhfOEfc5pzz1KeyYzXGVkij5xl1J4/zlZpmtE0cmsnp1lu6GNZxT4KwFnDGuZuyN1u7d3GbN5OSl41ecEwLQ47n747uLVQGJufx2ES9qkhtK24jW4LUd2p9G4oup4ZDlb9EpmT+qrx1k4qSZEBfq5TIK5jeb258Z5n3o4CWO5hmenpDZo1X35n7OXFaBj9n/edQpidIPK4s56+hwHllYlXujl5G812shBOe6dOiTKJyKbuOM/uho2Oij/oRIKenrVgC6x8WpnumFjl7YeW3OfMtf+1aCO3mkXtK5nmhQ7hFU3rTHxuotleVE/lixnnevaOshjuuiruvNzutLReS/zou3aOlcRexRfmP0o0pUVFxK3uiE7eRLzpXkFelTCL6BjlXdCEKaPlHbLuvebtix+O3wbeM1Lu6MZe4JQYXpTlXrzjftjkGHbrzJ2BuMhePfGu7kHoNiOJYmGop+PFWkCEct/kMDrxBLxkUHb+9NvvAJ37wNPz773ua+yI8CN/FvVPG1qEaG2vKGComQuDos/+/yhZGjUxZONJ/ztwHzPCTzlaTzgmHztDfzQF/0ryGiPt9vRp88SL/lEv7zSx/1ONr0dUX0Ur9cmrk4i8e9V9/1ej3eD2CdiydnXi+NW+/03NtUZF/2bE+PZy+sEbX2bB/3YZ/ttVlBeD8FTbD3fI8Efo8EPhD4gj/4hO8Df3/4iJ/4hb/4hp/4jn/4jF/4jz/5gL/4rHl9xHx/mh+MjKj5m19/QqigaC/heV9BfN/3fx/5i0/5j6/6g8/6ju/6gg/7im/5oi/zEiHKnt99nL+Iu+99dBj6AT9J1s1TFeQETrD3j58EzN/8zv/8zw/70D/90y/91H/9zG/9zK8ESv9QQdLOUxF1AeI//po//uN/w+Uogr8PAeYv/sict6MPEcWPh1OA/Mrv+NiP/dqf/9C///zv/ACBROBAggKTHEyiRMmUKUuWAIAYUeLEiQ8eUKHi8MJGjhA8fuTIkcRIkiVFnET5USXIkBdGHjmC0SFFmjVt3sSZU+dOiAIEYMToRKgThAgJFi16FOlBpUubIn2adOBSplOpRjVq9SBQKjwn+uQ6QewEDGXNjh1r9ixasmoxsG2rFu1JmFy93sWbV2/Pn0CHEoWqNbDBq4KlEnZqOCviwUioJsFalbHdvGCBonX7lm1muJw3u50roi7QvaVNn6bItUkTH61dF4Rd0PX/bNqzY99GUlv3a9ywd+++zRUjXuFU4B5HPnYlhOTNxxZHHV06caCra/f2/fs6doLat3MX6J12cOHUwzpHvxx9c+jT3b+XGCBAcfr17d/Hn1//fv79qVjOSb7hAPCvQAOLE7Ar+BaMLsEDH4QwQgnvAxCnBCGaMEP7LmSww9KkkAJDDUcksUTSCFQwJxBFNHHCFQFgggkPZ9zrxRZvxNFAEXeyMUcIX4yRRiF5cqBIBwZEIEkEBhyyyb2UXDLFiJikycgjFYSSyiZ9qtBKLZ0E00sslfwSTDNxylLKHW0SE6I0z+SyL4jaPLNOidqzM0+e8NyzPD2n9PPPOvkUtNCJCwjVCVE7FTXUpoAAACH5BAAGAAAALAAAJgAsAYoAhv//////2Nj//9j/2D7/nj7/dxf/nhf/d//Y///Y2P+ePv+eF/93F9jY/9jY2M62Vue2Ps62MOe2F27nhm7nYMC2F6i2Vqi2MG7Onm7Od27AhueGbueGSOeQF86QMMCQF6iQMMCGbth3F0jnhkjnYEjOnkjOd0jAhkjAYD7YdzDOSBfYnhfYdzC2hia2bia2SAC2bgC2SEiodyaQSACQbgCQSOdgbsBgbrZWzudgSMBgSM5uMLZuJrZuALZIAJBuAKhIVpBIJpBIALYwzrYwqJAwzpAwqCYmJiYmAG4Atm4AkEgAtkgAkCYAAAAmJgAmAAAAJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAj/AAEIHEiwoMGBDhxEWRjlyJGDECNKnFgwIcOGDylq3MixY0WFDB16HEmypEmOFkNmPAkx5UKRLGMKdIlRpk2ZNGHe3MkzZs6VOB3oBJBwaE+KRYEmPco04lKEQoE2nUr16cyoO60SxUpVolatXZl+5Rq2LM+xRm8uFHixrdu3cOPKncs2ilmqawHM3cu3r9+/gANfrNszr+DDiAnfbWoYsePHkCMP1muXZ2PJmBk+eaJ48dHLmUOLFt1ZbeXRmDeX9rwTNOrXsAGvDnqxSRMfPmzotnGj9w0dwIPnGE68uHHiu3n7Di48B/CLaVnfpLmZBAkU2LNrt86dxIjv4MN3/7euvTyK8d7Dq0dvfvt49evHty9fowZ0qdNBLrSNO7nv38zpcNyAxvm3XIDDPaeSdGLpF0V118133nvwgceehOhVaKF8GFKo4YUSolDffV1dhBuBHKSo4oostqgiii6m6BaDeDFEwY043ojejuPl6KOPPAZJwo9EUiAkj0X+iF4MMUxWIkMnDhjjlC7CGOOMNDJmI5FH7pgkkF32+CWOYYo5ppHjMekkTwIIQJMQQkRJYHEG9haggHMSqOBL+GXJUgIJpAShht+B2F6GhCZaKIfzIfoho4dyx+SINTXV5ptx+pAnnbv9d+emA+5ZqZ82ASroE9Ylaqh5jir6aHchtv8K36rldTepfaOGdVEPvPaw4nExbiDssMSmSOyxx66IJamWMfTdBBMUCe201E6bKLTSVqvttdESqe22hGJLJJNqMlTWrr3+alywyA5rbLvIKtsWs4U5O4K4P35bLbfZ6gstv976+2+43f5IbpPm6soQnHB6imAOySWHbAgUh/CfnQ/rNtyy9MZ0ERRQfHfCyCRrN7IGGlDrqsgkj2zyCSirvHLLLmd3csrWzkyzdvVRmteTCzEshMPMDRfxbhNXfDGARUNsw8bzdizTxyGPQPMJL8ecs6tXZ43zwFzvbDPMX0+wstViY9czrj8flRISSPTaAw88wGt3shwUx26xHCj/CHJ0Unf0k8zw4RuwwBoanq/AZleouI+MNx4eDJTDQCngWYEEt9x03+35Binq7WK8feuw0N99Bo6Sgw4Rrt7jOUaeeMGH+zv7l7KrV7nluGL+GZQ+CA0EEEZHjHHToHJqoKgcq64RXOLt2OiOr0Lqnqwb0oodj9WroMLaPlcGdBS4CU+808s/nDxyxgMol/MdQZ+99dlxXyGP02O/qPYT6j9Cd94DH9vEV6OFyO2ACOwBbhbIQB8k8IEJZCBcZgO/goAGZJQ7mAY3GIPdefCDMOCgCDsIwhKOkIMlNOEJybWmqaALggdsYANhSEMFLnCClKmgRC4IhQyu8GApBOEP/4EYRA8OkVxFNOIQW8iTAATgIhKQQA1lSMUZ1tCGMoSLE9umw4FsMQpfXMhmjkjGMprxjGhcYsKYEsYoRHGKVYzjFbHYQC0+kYBdFMgX2zjGNPrxj4AMJMK4+LuFRJGBc4yjHK+IGxwSMo85pMxFBElJM/qwkkMsQQke2SxDSgCRjFQkFRPpA0fiEZKRdAsmV7nCS7JyhJrkZExMpTkkRLEDHShfphjAy1768pe/XIAwhwlMXwrTlyIQAVx8V0FausUJTjCANKcpzQNY85rYzKY2D0DNbhoAm9Xcpji9SU1xmjOb5DTAClYgQBm4UwZ86okzowC3W+YyeLsspj6NOf/MY+7Tn7xM5jJT18V5XgSa6TynQrmZzm9eM5wLtWZDHRrRbaZzne18ZzyP0kZ7Cg1O+yxmPwEa0n3iEJURaeNCyllRiza0pS5NKEzR+dJrZtSdTLRJRyWAy48KoaTBHClQQ3pSlB5EpVFg6UwfWtOlSrSpTp0oNm8KzzWeBSQOgQAEcAnKkXr1qwoIq1i/StZhCrQtzEQlTRA6Uai29a1wVSpD4/pWcDr0YC5wAQYwgNNcZY5PWuXqAnlV1rKKdayF/epZSWTUljiIrXSdpl0jS9luTray5LSrNfGqV75WNa0ngWIUP9nAxJqWmEEtbFEbaxC3VLQAsI2tN516gNj/ytayTrUtbGcb0Q1m4LcZyKlpPHnI0p7WtMA07WpZSxDXRlS3BeDtUqEr3ZlSF7cL9S1whWsT0RZXbsf1anLDK8zlMrcuF9EmdJ8q19fqlr2Ste575xpfmMJ2g5qMpVXrRVzSgpe8qOUnec17Xudic730hWhLEVxd99oWvgp2L37zy92pMUSrWpUbbgA80sOGdcBvOe9B3NLeBGM2wgyFMGW1eeLqbnCve62wxy6MYQ37gMP99LACQNw8EUuSISVuMXaZquLIsljI9T3Ai2EsY5O06SIfiPIHhIYbfeI4wCUlcGOf3BYke/nLYKbmOmlAg93ld5P7vQmXFyLlKTOs/8oivfIChsoALRt1zUAOs573TNkxl7lyZ25yaBkyWgn4tJ9WxrKA5xxnktq5sSTms6QnPVEiBjrNrSH0aA+t6F4iutGMHq+jQ+zj5naZ0qhOtQEsTWFMD9eNUjwgWXUs5w57+NFGjXRlL+tlXiN5g3H94KUFTRLRInDWHq51jm9N6lKjN8+7ZiqYfS1kYMNV2K0m9kZoEmUq+0DUnaYzuIW52AU5mzpPKHKSlypk2sKXcixggWgcAhaWcNvNcILzokkqblCTW5loJahR0a1uFMO03e6mJrzlHRp6k6WTsJbhvuU87pHiGqXOZfCQHRxb+Gq8xAu1bblQQ0GWiFbinv9WNr8ZoNpmOzvj823wc2M+zY+ve+b3HeRoSj5oT/7g50Dvd8U/DdSL5xHPK1W10r2J0QGSJpKZ9jnQfy701H6VzkbvItKTuvSuS7PpsOG5SU7ewIlfeejDzHoeYf5gE0+X5tK0ucEVCl23RODueM+73iPAq70whewMNDuO0V5el5ea7R13u3zbTk25U3TBurX73id/977TpZARxydIq85yoXJe7V3U9c0rWteotrWiF6H8BVbPehC4HgRwAn2xNa3LzVddvJ83vI9FP/eFlp7dp49o6ifP+ta/Pva6/ytDuv3mb/+zrJxPebk3ytwGNAABCFhrNL3O/XgvBJoWsMD/68f/eg+Y//zIp35T7u3tkBY2+rz8t1tACz/rY1/73O8+w8EvfvKP//zoJwSMxRR4xnxCU3HwZ3X+JHvOs3WkB1XAJ1O0RU3h438AeIEB2GM9UYD4xjAImIAp92kMqDoOGFFSlXAQOFMUOEAWiIEXmH6u1hNftBlvJGuJRXgAxksj6DwGlmJ0p1vedF0SiHO3BXIHED6Ul4QRAINlMYNPUIP/9X4KSHF1lnwF1haa9YO2FYRAmILnJISjd4QDpISUx4RUcSlR4VHNd3ueV3XT51eshYYXsRkPOIQRmFnudjAVSH4ueH6uN4CW4iZpyFMd0H5Ch3tuCHCAyFxyqBnp/2aCXthSJ0hbesiCfNiHHvCH5jY+hXZsYJVsKrcAOraDqsN7STZpKkZt1wYD0uRDkAEyAgGLBQRrUNgryHZYoSiKzKaBV3gRQ4iKildwbUU5rRhCOncYsiiLLrR8UuZT7neDnNdPpBg4prh0wnhiJdQCLQAZYtddzGiAHvh8UsiGhceLzFWNSneNmJWN2/gY3SgTIAMyhSZD5EVryuYWquFsz5Z002ZiveaP5MSO8QgFG0FIsnQTAzmPxnVc9lhr+MgZ+vhj/Phl6hhtwQZC2jiQBXlKB+mN/UWPuXhawDSHmwGR+tiDXxhbBEAAMsdxK9mSvRUDLzCTL2ACJtBkTv9UF5sBN+eiacXFQCEpkr9Ekvl4klhIhC+5cZAHW0lphNklkzRpkzgZADr5BDypMAtRAVpZASiXgIg4VNMIcR05Ykd5cMF3h3aoUBOmbQxyEVvJlWUHgl9ZdFYoHeYYESgJiZOogmcZkwejX2PpJ94Va1Foa7gYiofVSHW5GMo4EIHpmKcWbRWJh9UlZB8klTFIL4PpiV7VkMqWmKW0mHfRmO9oar6IWapYepXZYpd5k5nJLJtpg50Jiip3WJYXG5hRmpB5mjLHZ6lIU5W1O0zyW2xplz5JmLb4iYdZm2J1m7gZGbq5j1zXm3v2m6k5jJUznMH1mqQSm4XpmbVmjxv/tgDPCZ1Q9zyRCVdH9o/XGVfaVZys4Z3JKUzgKWfieWPkWZ7ueJ4UgY5p2Y/tCVfvyZ2CyYzOWFLjGI3DNHVBEATDQzTNcTS6kTQUszSfgj4Rc5cQgX28mX/YSWZkFlnYpqFZAmUdaHvieHXw108M6qBAAKHAUTxHQ6EWczEXKqE2QKIGwaHQ5qETRTkgSgMi6kGASaDrlxAO4ERKqqRwk1UQQDeFyWH1WVj2SDedgzd70y7vAi8pwhzw4hC+Y30J0SZkSqbQBFncZ03xtqZrWh/eJxgOsRlgOqcZQX89gaRJuqRMigROCqXziWNTaligaKV1g6WjYzdbqqWlAxxf/wqmEiGmDlCmZXqm25d/asqmbVoDbxoYcfoEdOqoAGCnLJGTBYGGeEoTghV4KQeCcYZMyfSqsMpA61McwHE8zbE+Xjosc2oQgKKnAYCnAzAAbUKpTqmXeKhNmIqp4eMYDsEnMCGqG0GqBCGtA2Gqp3oRqbpA/MSq4+WqsBqrCzSrxFGrTHOryZOrwrKrBdGregqswioAxBqGdXis2ZSsbLqsiNGsGPGsAlcS1LptSOpEcFNPEkCodJOLgUqlCkCoXDoln3M3oZMDXRoc6QqqADum8HqmPupN9+p0+QqmbQOtR5oQAjuwUWSwPICwtBleYcWwipqlD4s3wzGxjLoB6v96sZGasWi6sQbQsZIxpyHbr03hq3hasgTLmUEJjSQlTHKzAztAJetDJTGSIAHyqTgbrCX5iCGnkgSQhTAVb7aVAinApgM7sHnXh+MHJ7ZhG85qsaxBtAEbAGVbi4SVtMjVefzUtE87JVErtS1CtcxhtRrhrlnrkl1LZDMFtrEltmRbtkhwti6YtkKwtk3QtiLbEf8KANR6qkiKrfekqt3KrdvKAN8qAj51uplSe6mreajbuvnGunQDJ+qaFuzqrlj7BDsrr8YKk2wqtmJLuXtnfv43fnQjuHeRuZvLuQ6SrfoWVKI7uqXrut6mugwkvdKrurErBLOLH7WLpMF6u7n/23u7q5SXGm++mwLAq3fCO7yuV7x0GjiSSqZ4SrmCxSvjKbr+RFKlG73NJ0qsa72v67+oq68CkRakSqp4Gq97iZbkewBsSrnmR3nrK7lt2zHxa630e0/2i5/4y2j6u7+wOr2iBMAf5b+qKzQEHKr4ccBUuRUJocCROK+8u6YQ7AESnInkh3w3myWAYhDuaqJdOYVEt6ILkEz/BifJhLqKBCc/R8IiXL0MQzd8MqxOUKbWZ31tchUYC8NLt05evALJOgMzYBsO8QBmfMZmHH7h53/ue7lN0cMfkRDBCsRxiYOs+m9HLARJfLpLLARN7MQB3EBCI8UYQcVWfMVZ7MI5/8vFSvfF6xTGY9wEZYzGZ6zG/Ue8PLDDFYSncGMb9funCrucn7ljw4S09biy5AWrFbw6L6yxPDtNlLM2ZUuGeDd+q9xFnIwEnqzBoCyoohyepMy0sglgCZtYqryvQksQCezKr2wAsdwzs0zLEWDLyBw4S6rFncuMQZxooxt/ofa8K3fH3xxQr0rOyRRWmhwR1nq7dDi+ciW+4sQk8bY2h6Gv/Nox16zI97bNrbqq/vy8eAvQAe2tImDOIoDObisR6zwAhevOp/h4FSXPLEDPcHoEG+XGnuGWFfC6dTvE5Kii0ZegH/2V5VYSeNbMJSQZ0dmdDKGVHN0Dc3mI0EfEZP/llTNNzvApECf9yiltno9JI070NrY0Wqbchp2Xi4J3txyW1IoFcG6cEGR8BDC5tUzJkg28WRpUH3KazFsBE0H9cNb8q7XUicP8lUHJ1FK41CF4Wmf11A4Q1VOthQXQlLq7QVrtqVz9FF+N0YvhucyLnyItbnc70oOXez9NlhPJswIEnzqqmQyBS3892DId2HSmctGX07s5na+82EZqmp3N0h+5kFSI1uGFg2cdVJj9bOoFd7orTja3QanNWoMJkrVm2qUtxHY7zp0X2+mVTY73dow3TbD92SLGgeDYvEztzTVN0yCtoMtNl4ctEFfcAB3Ks7tDZrGNUsbdgci91rj/R9mCfdPO3dxERdwAMN3VvbHXTQPZjUry2dHKiVjM+cv2icr1LUYmOXuJTVeT6Z4a1N4Yd5xFvWz0fWXFfMoFDqgKgN89p9lGBpAnNtzR/XICboMHzrL2beAZruCizNs9+p8UmU0SfkoRidi0iJx1e+EMueFSyuLEvLIevt/UyZ7XNOIl3p8Vzis/59HhDd5AJdn9BuS9FOMOrt4eBODuneM9sOPhNlRCXtnQSNgxrYPm7dnNXIy7g+QVtHXgiKLK3eSE3cE8HtKe19gCASjo6G4QDtHXNM/gY+ZxKABu0eU/NYViDuaTjedBXuZRsxFonp7F6nuR6OYUreWkgn2I/44ArqGfjN7op0HiAHDIC2F9ju4YlA7pjZXoPCqdld7pr1Fykh4Fl+7pgHHpNx7pch4FW0fqrI4ZXEYRX8TprR4XKw1JXLbqs57rh/HqExHrEqnrpnTqm57ZwF7sfvGOlz7qxk5qpOlswy7ryx7tUTOWyU7d0o4lzS5i9qfob7EE3v7tRRDu4j7u5F4EQ3Du6J7u517u7M7u6v7uQ9Du8i7u8K7u897ujV2mbvF/F0jJlGzJa8y+IICB/o7GMGjoHbPtcPHt4H7v417v6e7w7Q7x6C7x7k7x8W7x4p7vZLrv5dfvBZ/GAC/wAw/yIX/wVU7hC6EESpAESYDx6E4EMv8/8zR/7jhw8zhP8TcP8+dO8z5PBDaP8zvP8z9f80Mg9ENP5NK89EyvhIo54SV+ESzv8jw/BEU/80Ev9DqPA1V/9TKf9TlP9F4P9kmf8s/W9Gif9hHw9Jh+6uuaABfBBEzg7et+70Zw93jv9UBf8XaP93ev9xHf934P+Hw/75iNZ66HieenhMXXgn24envH9m6vEX++EHJP9xk/737/92Nf+PK++UZA+HWv+Zsv+pkv74ef6guR+Ipvw0nY+Jf4+BcQ+aEJ9Td+ES6P9Lof9lW/+77P9VV/9L8v9OE+/EPf+zgP59JJy/6u9pPX/BGg/G6P+0lg/LzP89av9cGf/Ti8UPzGH/zCf/PSL3lKCP3On3fQL/1Rf+3sPxmPuejGXusR2f70/+gbCe26Lv+MKIjQRBP1n+sA0aSJAwdHjgBAmFChAAEEnTghGEXiRIoVLV7EmFHjxIcEDSoEGVLkSJIlTZ5EmZChQ4gONr6EGVPmTJo1BXo8SHKlg44ua/4E2vNjSqJFjR5FKTEkFChInT6FGhUA05BKk0ZZ2lRqVKsKu24FG9bkV4RUxZ5Fe9SsV6xXs6Y1ShaAXLhiAwIAIfkEAAYAAAAsAAAmACwBjACG///////Y2P//Pv+ePv93F/+eF/93/9j//9jY/54+/54X/3cX2Nj/2NjY57Y+zrZWzrYw57YXbueGbudgwLYXqLZWqLYwbs6ebsCG54Zu54ZI55AX2J4XzpBWzpAwwIZuqJBWqJAwwJAX2HcXSOeGSOdgSM6eSM53SMCGSMBgF9ieMM5IF9h3MLaGJrZuJrZIALZuALZISKieSKh3MJBgJpBuAJBuAJBI52Bu52BIzm4wtm4mwGBuwGBItlbOzkhWtm4AtkgAkG4AkEgAtjDOtjCokDDOkDCoJiYmJiYAbgC2SAC2SACQJgAAACYmACYAAAAmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACP8AAQgcSLCgQQAHDkRZyPCgw4cQIxZkwIBhQ4kYM2rceNDiQo4gQ4ocqZGixygkISY8mbLlQJMeXcqcyXKmzZsuYVrESfBjQZ88NQIdODSo0Z8okR5dypRo0p5PaUYVWLSpwapVreLEOlWr15ZcZSJA0KBBkyZlT6pdy7atW7VnyyJB8vXm2LJJkqR9y7ev37+AA7+N22CuWLJm0TYQzFgwYcN1Z95tkHdv48uYM2uO8pjuTZ+bQ6ul2jWyy4UCBIhezbo16NIpX7veTNr01iipZ+veHbg2z5NBguAYjoOHcR49kivPwby58+fNiRc/rrx6D+Y1bd/M7bFEiRTgw4v/906+BInz6NOX9y6+fYr15tPLh+9+/Hr589fXb3/jRvbfHgUn3XHIWQfdgc8NSJ11yWEXk3bbqdbdd/u9dx9+6NFXIXwYZqjfhhd2qGGFKfT3X1AWAQGEBiy26OKLLyII44w0anAihDZZNMGOPO4I34/r9SikkEAWWcKQSE5gJJBJDglfDDHs1FSKK9ZopYxWZnkjjjLpiOSSPzZJJJhBiskjmWWaqeR6UEoZ1FgWBSfgdMYxiOCdOShYp4HNbcklSdwtxB6I5XV43oj1cWgoou4pauijJJTXn4kXHQUnQ3IKR2eB1eGJoJ6cLtfng3/KFGgUg+7nKIaMtrcqfq3a/1copI9KOqmbS+11VnAqspjBr8AGKyywLDpH47DDJmcRZKW6tFdeEkQr7bTRdhitmNRmK4G1EmCr7bTcevvteTDA0B8UUDBrlK5N8FolsvASq4GxM8YLrLIMqdssSc8m8S24GF7b5L/ShjswwdsG3O3B45JQ7rnpesaURUNUPISdeUpH3LAfdPwBgXt2mrHGOPi5L0cnoaAyCuKpjAEGANO68soto/ByzJDOrHLNNxdMKwk6sxzezDbYQGlWAC5k8cV8kjwcxx6DHGqDI2ts8slCeTQzzzD7LLPOXOP8aNBhe50z2EOvXPTRsN32xBMqxg3EsMU2d6y9yNbt3NVYY/90UpIIJ4yfwIAjbHDhBB/eJJSMx/A20m7DLffcwuqdw914Vz7vc3z3HdHfSAau+JCiKyzuv6Mj2TiUj7f9WRRvTw6EDjrQiGeWWe6t1tueZ30Sk2qeieaRwfs4fPHGo7nCCqtHGUVeVi0U++S0234n7leOehLvvfutFvDFD098+McjL/7yzS8E/VKXLpRppkvHL7/F79cv5/zxr3Vp9wcFEIBsDJmUAAdIwOaV64AHJKACB2hABCZwgRBsoANh0LgJPuxWlTJK+6JgvyDg74ND6GD9QFgx/SEAcp7zHwAXAsEIrs6C5mqhAiXoQBnO8IUWrKAFBYgrFDEkAhFwl+z/hjhEEQaBiEgEwloEgi7+OWSFUaAhDBHYvCoyboo5tGIVsThBLW5xigtp4lIsAkQhJhGJRjzjEJcIADE6USkAOIkUuejFOWKxjjjk4gHxqEMYhhEKE/thEOWkxiSmsZAqYiMKewdFK+qxXHzMIx0jecVHUrKSEzSBCRZ5GkFmCpFEPCQiFek6RiZFjl/U4yWh9EgKrrKVq4wBDDXJSbAIEoiyU4Aud5mAXvpyl8AMpjCHqQBf+rItb4TIWgrAzGY685nPNIA0DQDNalqzmtOk5jW3ac1scvOZmdTkJjN4m4UAEZeTE6Yxe0nMdrZznQlAZjKfqJZvdnOa9sxnAbyp/89v8jOf4aQlOWeyl7dRgAIiEMHSgrOAhjr0oQ11J0QnStGGjmAEJ9HXPAtimSg4wQn9DKlIR0rSb7KABf0pWg1qcIELzGAGC9GoTAr6hIMmdKFBqOhDJarTnl40oxLbqEE6+tGSGvWoSDUpSm+gUpa6FKZRkKlUFuKAqjpARe5yp1aLuc6tApONQqXnH535z6SWFalnPWo2ddjSlkrvCUexiFWvCoSsepWY8LyrLsEa1qswBF1kxWdSmZlWoxa2pGutZFsv8NagnGoDkN1A/YTZ08pClLIO/elo+lqQDS7kntkMrWhDa9jRmla02zytag2gQ3GOs5YheWxkJxtMy//adgGYtShGN8vZgXg2CqBdrWlLK9zhXrO4o22tOHtI0MU8LwnnjIDcdrADvWo1r+3U7LKC2tuOvm2w+TwsScUbUmk2zgUuaOlLY8rd5qoPuuecbnWt+86uZne32+0tQbz7BPDak7wiBbA+zcs49KoXqlJtSb+im8t2TpS+9wWqfgfCX+RmkwAYzjA0M6zhaFr4whwmADQ/DGIOE5a1qzvBCdYb1fbO1Ll5YXA6HXxZCA9Tu/lycVgrTOIQi/iZPh4xiaUZZA8PucgEbpyKWZzgTi4koZDF6YNre9vKCpOvEz6JNP05ZG0Sl8RcFm5/Guda5uaIIVDegJRrDMwqWzn/mFjWr5a9fNwuo9XO3ETumBlX5oGeeSGRlez7dOnmnuYWojg2c1h/i9o6d5nOQn50ah89zXCqWNFdYkigaVtonR76oYn286JP6JFGB3fIk5a0oylt6RNgeiQdvSn9cuppGnca1PiNArqazL+EUISoIPWvsAMM6QJM0JoqSLayi4ZATbKYvTiJtUJnbWhb31q3Ftm1jt/oawYAe9jgHnCxj11NZS/bBs02wbNbHFdPDlqv2LXxLrcH1wk7xSL+FXA/9Q1OGDCTNWJ041SjUMZ33zXe8lYAve19b4bkW7CD5bczy/Xv1QQckO59LmTrd+2IUvm2oeZ1Mnn84VTj+dQk/2abaOYil22HpF8bf1/Hcftx24bc5fMkuYVNjupVD1nloWF5YXBeEopURNOCzhQxZ87Ti4Yatm/MNhTCTfWQAl00MJGJ0Y8O6KTLaekdb7rT49xbqVf97Pa8emiy7hL/qRB2T0Cn3NpMc+vulL5k36j/SPO2vGB4AAOIdI8zDHjBf5jDhTfyaE8CgcY7/vGQh0AJ3WITt/8P7nKPG90hfHfr5n2ee48j3P1OgMQH9siED7ziD596w4eW8ZGPfeMnL8+W/Nq5Xed43W187ZtP+PYWKSrah2/Nk1okBMgPgQeWz/wHOP/5FrAA7XMcFOAjXfcJV0Dvcw1t/Vp/IcInvv/4m2l8hiRf+cxf/vOhL/0hSHhK7lZ69r065b165CwMJ41FVFvk0w/exKtnYUhmABYhewYIAYlEKmMUf183f1tVfwp3f02Qf6K3f6fVf830aBh4YqgHgNJUgAcYewn4an9GcBEgBCiYgkxnbT31eRt1Kp81fjJYLn9UARUAAiBwfueXfssXHJ2TaeZ0gimIgisIdpblgvMEg8Alg+NHg7oGBTaIgzqYfDzoAT6ogO0WhGa0VQiXfb2EhBt1Ene2ZeAlcdXkhAsRgiKoRKLmQ1p4RJp3XfblgF/IW/YmhmoFcWalhyKFhlGghpE3gqX0OjI2d7w0h/OHcGA4T3gYXnz/mIdkiFTpwxCACAHr94NSUYhxqEtdmHCKaIdZ5hH79ohfNliTmIaAeIlYOBMJwS6bBocqQnfXxlO45nv29m1MCG7JVjQnxUOYgS4tFxSt6Fxn8YqGSGhhx4IL4HTcx263iHseFWy5KGy7aAO9iEGXAYxDFz1ollDTtjQV9WnJ+FWgKGelVmyuh1xhBmbX1Ecw0AItkBm+kYVR4I3faDHhWHNFOG/lWHbnuI4ll2cnV03uCI/yKHpHsWARcFBDqCL7KI4TZYu9lRq4OI2DlWzXKEBFQwM00H0OQZHbCAC3J3L8AmPwxZAp6JDjOEyWJZGcBZLBJ40WiVQYuVQaaQMc/+mRBwGSkDGSRGdLXRdlISQnnbdLM1eUyNhQi5hMjYhNA4ly6qhP4USCSEGVQBgFgVYxmYKU2neUHieLC7CUUSeKPrdzAtlzAOVAAgV1FdiGLpEQ+meCQDSERLiSEJlZI6CU/WgbmAgV+DaT4GVuNykDMmCVkQGXbRlddCkED6mPiJaXYbmXptGXDReDgJlUgjkpRUOYhmkaKyFIMXeMXTmLynhR09eZRsF2AqGa3vOXl3mRKkBAnOmWOPKZQRiamziat0aLeHmatNkUrMmaEtGUr3lUySabhfmbOEJG54R9DqibXzlMgsgbl4F/CIkRb/dWRBZi6VhcG7hPXfadzf9zacoJIcxZcFu5e9kHgcI0ndTJGNYJW9kJd9sJgP7HevaZgeHJnc80nq5WnnWxQa+Ynl4pjsxomkOgl+95GfPYmgxBaeion6o2XgZAQOvWOwI6WzLnleoJnct4oBWjoAvKGA06nOc4oU6JosRmoVDFltrBnJ8EBHcVneqEiFslO7RjL1YCLy7Co5vDHD2aAZTpl0tYnM7UPJH4TKZnbA7kVqvYLDBKSDJKfx0KTJ3oTjiqAzpaIz7qK3nzo5fTIr8ypA1npP25OknqTEs6QU6KmiRheXAaAA4xFmcRY9I1Y8/5nHLjIkAKptCBPTWCJ8nxNk2WGg5BUx2YYUmqgQT/IE0v8ALlFxhv03dJcBZnIXQkmRJxanlzigB1Cl8NlqcOuKct0qe3A6gzIqg9QKguZ6gHgaj/p6h0xqiOCqkswBiT+gR5YalNgKk/2XZyCgD+MxYCwakNJ2sEyqFJSVHMWFGZAh3DwRzJETKi4ikJggPS2gPUii8oFHoEkRqngpYpWlwn1WhqRxvXyRShN6wIUKxuR6TISpQc6nE+5XTOKifQiq05MK1Tcx3Weq3Zuq098GreOhDgKiELIa7daVrlSloFcK6aUaKl8laZR13GlKfsVF8Xu0uZ4qWZ06VcKi9e6rEZgC4CBxKuKX6m1kxt0hpQ0TcUe6cqYrG/9JwZ/4tXiNixGvCx8YI7wRKkJGuyGCcSKUt8K8tMLcsaL/sVW5cQTnsAcZl5KLisncabt5UpP/ADweIxHwMyGOM0OAA1HSM11eEnrioQB3sqZupMJ+F8Nvi2FTCFyOebZGoTTfu0UJuYMgsEU+uhbma1toW1WgssXEu2TeM0Ytu1BFK2TwoAZ+u4aVu0Rtq2DwC3Nii3IUC3jQulDHFQ8vO3ythpKEhC82NEFTO6pBs/9SMlbKm2a1tx6HK5mIt+6XeFbmqenUsBn1tlgCu6QpC6qitCp/u7wDtrmcK6g/itCFuka1uDcTu7VWi7ABoZoSdta1ZtYDmvDRUcxWu8RuRB3f87P+wVjBgBk/TJjlDJjpEaBVNYhek3t+5HfSkUrNZLbW+WvdrLveH7vfcTvvIzviEpEeb7NgobgD23vu3rvssHv/nlRKcia+BIUchItclIrw5VMQgKQvyrv90LP7OGvBIxFmMxn2lqwGYpUkVzfLSrwMzXeNKbhMsLwfgowV1JwaRpwQ2FwSNAuhsMvh3cv1oZBCAcESKMACQcoRz4lPqUwua3wizsAS4sxNPrFamxdRQRlzEnf0a4m/d1oE4XxAzFZixpl7vEARwQairhtBTxtJI7fpnpiwvRAR2wfnRcuZZbt01RxVaMxV4XHL3Lu13sxTs8lGHMlfgLusJkxmj//BBPu8ZO28bi98bYGAVyXMfrZ7kVgMem0S8JhbqFXGh/fFvrSca6pMi7lalD5VzhF8kqwEzJVi4ntTb+gRm++kacLAKeTGtVG7qALG+NWcpnfMq/msrgJ5PEl2yurAKwzAKynBm1zJSCFKqJaKOeSM3ydqVwNsVVybwUaobMBEmydEDo6qK4G4TS7IXWbGPYDGHrzI/kTKRjSIrcBM4INM7JyyUWYVP3GKL3O8akucW7DNCFdrsCYZvcnIt+NL1h4UT5jFD7nKD9fJeizMsTLdBuRtAIoRAOB5gJzZYLbUpBWLE7sLF0mM7sbNL0hc0YHZfB9XAlfIr3TKTvzJe3/7S3NHuz00zSOV2zJa3T5DjTLD2uLl1sMI2ym+s5lKqJ1HVwCTDBourUT02jNrbSbZnErAd4S2rVq9U4j8qrFCgRSR1fcbPUXpWxUu2AZz1/ae152gzP4Il6WK1697nVjNPVlvrVD/F2byNj+gu4ecqeCQfYvhyZQC16Z7Gwq/WdwjWJ64PXBqHXcSfWfa2Mfy3Go2zIvEfYMd0RnNEEiM1//DnXosXYSeDYE8F1WKmhWuzPXGzRrW2UpLxLOEYSYwWYxzlAVD1POpHaWdyArl3RrN2YvyzbuUbbT3iZtw3Hm91buz2gcCjRthXK0U3R073Fsx1by1ucE/RHpm0Qzf+t2s/tmIgc3KBM3ZbFm9cNEq57mdv9hN39EOc5SKst2JmN2Zxn2YFdY1RtgSUmq87kYyU8ZEX93tscXbRFwZVt3/RF3/d9d/v9oKEF4HQm4Z+dXKuT29DMnPKF0+js09Xs4dfc1Bp7TEctVsctoUg8UuRFRc7D3QR+EiLN4R/O0zst4yHuTvBEpmaH4kO9TSwudaYNRSM65AsqsfQUl0TeG+n61UKe5E7uGkbO2Uj+5H0R5QzX5FSe5RG75Mp0SlruF1ZujlP+5WTeGGG+tGXOF2ceVtwz5mn+5m+x5kyEcXC+FmJU2L3T5m1Z53zOFnLeRnTe50DO5Y59EmehBEr/sASKvgRE0OiOXgSQHumS3ug+UOmW7uiYnumNLumcXgSUbumVrumiTgSdPulEAOqhPuqZXupFYBF6nhGwV4myPuuQp7kEvuedjeiLzuirzuqefuqoruq9zuqfDurCjum+/uuo7gPH/uil7ur1thGxTuvUXom2fusUBo1MsO1MkOyYbgTgHu7iDu5HUO7m7u2OPu7qbgTmfu6+/u3rLu7tXu7oXu46uRH98njRZ4POF3nRF30J/MQHCPCZG7+o/NUdxe3d/u7pHu/hPu9HgO6N7vAPP+8STwQUT+4Wz/D27owgke+Ot+8V0O+Q9+8WEPAsPPAnX/D3ju1xuevqDvEX/5/x7L7xxN7wFC/zDD/xGQ/xHV/YFlGFKg+3/v7vKP/E0+fyJg7z467zN8/zOW/zpQ7vUd/uM9/zPv/gCyH0BijyNlj0BL+DT8x8Sa/0nWoR2w7pVO/wTj/1OM/2Ut/pax/vbS/3by/uOu4RR+++Kh/2VDj2y6fJ9rZBaf/rUA/3Vr/zGI/1if/0i1/17u748Z73Kiz2At/1Rq+DgB/4Jf7igv75UvLq8O3lgv7neA36qJ8Uon/kuA7nps/kpJ/6b/7nWF7mr0+BtS/7T077sc/nt59/H232WeNXsN4VeN5JxC/8Env87x38XZ78L2r8y/2MDaz8+A6NB99RB5+Q2BQ/zI6t/d5v/QAA/tdf/RBC/pwVEAAh+QQABgAAACwAACYALAGMAIb//////9jY//8+/54+/3cX/54X/3f/2P//2Nj/nj7/nhf/dz7/dxfY2P/Y2NjOtlbntj7OtjDnthdu54Zu52DAtheotlaotjBuzp5uznfnhm7nhkjnkBfYnj7YnhfOkDDAkBfAhm6okDDYdz7YdxdI54ZI52BIzp5IzndIwGAwzm4X2J4X2HdWtmAAtm4AtkhIqJ5IqHcwkIYAkG4AkEjnYG7nYEjOblbObjC2bibAYG7AYEi2Vs7OSDC2bgC2SACQbgCQSAC2MM62MKiQMM6QMKgmJiYmJgBuALZIALZIAJAmAAAAJiYAJgAAACYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI/wABCBxIsKDBgk8SKjzIsKHDhwUDBFC4EKLFixgzFkSAgGJCjSBDihyJUYAAj09IQkSpsuVAiSxdymzJMebMmzhbmrSJ8yPClDk1+iTYpEnQow+dODE4FKnTpwObCpTqkipVqEyBEjWKFarSrF3DBrWqdaZPlGjTql3LVu3UsmJv7nzSoEHbu3jz6t3LN+/bnGf7Chb8N27OuXUHK17MuLHHwjIDO578GMBVwy6LvqXMubNnyGaBeuYMGvNMzZZHq15NOPXRmh5//KhBu4aO2zp26N5to7fv38B917aNezdv3zxNyz3psYTz585NSJ+eorr169OnQ99eIrv06+BTeP83wR36+PDYvZd/Pp4GjeQzYVOUPRx3buM7gusHXr84/t/wKefSXBStdx561Y23XnTeIZigegseiKCCEXrnXoA9KeSDDxp06OEGGwQH4ogjemjiiSaCKOKIGAoYmULQTTABBTTWaKOMOOaI43oy2ugjBToGOQGPM/5Yo5A6EmkkBS+8QFFXFG2IoorAkUgiilh+GGKVLFbm4lgwPtfjkkAiuWN5Yy5p5pncpWnkmjIqaWSTTyIlEUwKybahlXz2ud9vfQbaZZ1f5rTEoUuMp6gJZJK56HiNLvmod5EaKR10PzZJZ0VH3TlRnj/sKWigf/o2aqAtFkoSoolOOl2lP7r/+iqsNsoqHa21kvdcppoSipQDDiR0xBEbinrqiCseC2KHfOpGkRFGqHoTsMIekautjOKK7a3abosrBYs2eeET0EJF7RPDFuuDsshyyS6zVjqrULnSynTusNfa+u222dLK776KivseudE+Jd8TssnWW3+3GUdlqcExfJ9xqdabEUoSokehgbpynJ2D4kHoMXUOblyee+NedtPBCf+wcG32ObwlxPzB7B/FXlpMEsYNlixyeZdW+LHP2S3YXc8T/swdygOr7BJHLLf8Q8z/0VwzbVQbB2DOOoNEoELfEa2d0CQnXfR21TE4tNljG220dEynDBdOUHcEastZH2e1cDY3/1x1bxV37dDXCYXNdtAjG66x0iWkffTai5/tdoVxNz33UfOFWiwOOGTp+ecaPGxqn2sJfjFacA6JZpFqwiln62u+/qaQKqjgwu24J/QVVpmryznowJ8oem+oumX6RWmlLvuPyq/eaPNtsj57kLXjnvsTu0OVudTca67u98V2L37C4KdV2vE/4UmRpuy37/778Mcv//z012+//NVCeff4eoLvP//iKx9azoe+qDxBfQq5nwIXyMAGOvB9+ftVsNB1BA5wgHv++x4Ax5fBDckmCEFACbSARa8CCkQiJDTCuYpSlAe68IUwdOC4ShiUe1XwglLrYPg22D0dfjCEHhmhA/9oWEAUDlGFE2RhE2LIxCY6kX0zLJhTKCIBCWSQfzrMog82iBLUOO14u0OJ/KxHxjK6QIFmTOMZ76dGM6KRjCc4wReropAqXpGDWuwgFz3ixcuZMIweGWMbyfjGQeKukIZco/3KGMc5toQiFagACEAAwkoGgQGYzKQmMamATnryk5sMpSg1mZbsmdAgiUFLAVbJyla68pWwjKUsZ0nLWtqSlitYgXtmwMsZYAADjeQUmBISyUlaEoSj1OQnl6mAZDozk6VcyikPkkqU3PKa2MymNrfJylzuspe/DKYjNWKSr1XRgscMQieduc5ktnOU72QACUhgvmkOjjkU4aY+98n/T22y73ZxFKcfSVJOfD7hnBxIZzxDudBNNlSZzczkPOtpT4YQ7gn9zKhGN7rKf7ogoHIUJmDqWEUJ9G9DzPxkAlbK0pS69KWdXClFK8oQa9LSADjNqUZzqlOOypKnOJ0lIwPqq5EmpKQm9Z4PYMrSlsL0qSpNwExpmpV83hSoO8WqT2MJVAMIFY5EFemABHCuQ1nQgi1DaUThudZnuhWTEw2iFKlKkHMlpChdnWVX98pXr/60r4AN6l8DG9ihxiAGCSHiWMu6hLPisH8PzWRk3yrKuD5rrnQViF2fgFetcpWwfdUraPkq2tHy1bCIJVinPnVUCVgQfDDlJFSXydCU/041swhMSFcJwNvevtK0QO2tb10JXJ4Kl7e/LS5Oees+kBZ1JghEKGxfKtvZerK2zLwtXXP7hN0eN7nKPS4BwFtc8ZIXuMxtn3PF+iJiSpKSx3QrUxMA1VFqN7M23ap+9ytLpvHyl7987k0g+d50yvelK62vKO9L1/zy98EP9q8vASxg6LL2CY6drkura92IQjUhh6qwPT2FEu8O4MQDOK9peYviFBNXuQZgMYpVPNr0sm+94wQJAjP8vdgyoMPX/fFTQbwEEU+TxB4x8YxfHF4CtJjGoJXxiaFMWBtrCscDHUndqFjSHyKTsg6lLZgxyeCKXlS5pYVxmtE8WKCy4P/NLKgcCuaMAiOLZMskraKXLzlmyYp5zGW255mLu2ZCt5nNn+0qnOMcNzrXmb2hSQhapcZhZib4qX2G5gAzW1WFQPjTtuQl0245VIHmWCgKmXTLKr3MS/s404GuqINBTWtXihplpAarqbO8M4UYM77u/HOmkxnrUx5Mt55lpWBh3FNuMhunTVrlaAioEor82pLsFPawF7xpTgvk2N1N9iqX/ex9PtsA0S7AtF3jEmAdalh27PFTLw1RIDPTsvPCbGY3ywQmjBvGwp0yk8vbW4G3Erhyc0xRoMURxZLE3UuAtxXlPd942jul+E6svunKb38XgNkBd/HBAV5wkSvbtAn/b8zCjdDwjdMxIdeuZLZBue0wk7nb3h40cAu980MXd1PrPjXyfA1fbAeb5jX3880Dd0qdm5bnT/c5cIH+GXYPmKTgY7WlnXrxrRd7mrOGJU85OvaNlh2nKImA2teu9ge4/e1ul01bMIf172m91VzvelS/fsqwk5fszc7o2Q2QdravHe5wlztb6C7pxybs7kDeNt9N6Pda05oiIsi8CD7A+c6zHe4bmrxIKKLqxwtZ75N9pujRV3nLfxrzmu+85w//9tDjnO5KgQAEuKf3prra3igxpbdTY1Vtlp3Wx7clRRD/AMM7PwK2vytXtIc9J+ie9133PX27HnxpDn8znt5m//I/PX5aLh/xzzd89Dk7/RpOcFiTVle9UY/00y8z46r1thEp0lnjlvyVIUdlgRWAA4dwNPBuR5B+zid7ICR9DocTNhR/xTJ/9GdxGEdPcjV8+6cQ/ZdTBNhKH3hyTSZjAghY7oGACmh4DAhEKycW1lZ0MvdWzJR0pHR73lZi5SZ1UZdooPVmcsN2FxCEF6B5sfcBmdeAkMZ4TxBzX3Zg9Zd0q3c8OMhsUDdaVbhXPmg5QCiERJh5nHeEQCR01XZQXUY+S4VpDNBUFehJMmWDnNZ6Ihh45iZu+gRt7UMRKdh2zbd2TBcaSJVWZ+hjariGCtCGfdh3HlFLeSV4dOhs6P92hwqRhxHgdmx3iGPYWvGmLr/nUoO4hobINTeYiFclWFlFihnVJHZIdYpBbVeHiROnids3X5uIep9oZ7ImimkGeKbYT6j4iKo4GKwYaWSYicXCib5HiIXoe1FoOpVXfnO4i/zEU+5zOy3QAowRjO01jK9YjCmlfciofcsoOM0oh9FIjs/oi5pCjda4GNioEtW0hCBQerJxd52YUlDohlT1jgnhehBWRrwkAzJgi6AxF07xjpMkjz9Aj3k3gzUXjhajjxjFj/zljzMAkAJpdQBAkE/BZXpmhp54jB3mkDoDh7e0iP1kkrY0VBcJfmI4enmWVJBVgd4YkvjYYLhYh43/KH45GUsqmYQHYYkXUTcH84eUVnMMCWg1iRmBI5R2U3wFaGg8iGhiB1SVc1grGRZMyZEwaXrbdpRgJpIZYotZeZMjR4U6aIU+V5Wp1ZJxURdKAS0IBYhQdWkzqXdIeFlfkkJ1dUQX0XES2Y9kBAMw8JYupypu6QRw6VqOp1YVl4z1eHF3mW95yZcDoZcW4Zd/OZGBOZiIWZjSopXYh10e1nWiuX6s0RjtSBBTuGLHBY0j2FuuCVrukwEZcJWmAZpS01A0p3el6QOnSRmpaUAU8Zq8FZvo1Zp+VZaBNZu16ZOqQnpnFZo0yGrO9GW/iZoYuRJJlpxnGViKqGa0pJa2/6mUqRadudlWSeeVoWSd18mO2fkQOPidUhmVO9hfcWOVzqkcJsFYk4R9T2iU2iZP80QCliQbPdADeyMx+JEfe8M3vSEvGgcS59JvyjmfTzlaHgVlWcg0+BmhFrOfE3Qo/Xme/9mVATqgBFpJBoqgVqOgf9OgtPGgO4CXGjGhHvdvZkmfGJqOLqChjMaha5l/R2ESdVEXB3AAjIWQrzZss9gBHTACUDoCKDpPIEQfw1EbKBICWhoC9uE3WmMDV4qlJ7KlISAvNFRQdVFQJrGXCUGhmZlLcLoCb8ZLb9YZQvSAUIGmRXqkSep4srGkmdakTxqlU5qiVhqmWbqlXToxx/8RprSRqFpqpnOlp2oqAGz6BG76l3GaS3M6A3XKGXfqmU6xphjBZR6UMBdXlzKZADnQqjkwKsHjOSQCKBsAL8viIeOpmuGXmR8HVL/YFkqBF8FpGKa6Rahqb6pKfyvlqq8qKLGaJbM6OrZaq7ianw7hlH/ZVb/KFsF6F8MaH1DjKRLRaTG3IZRVogDaTpbkpXrToL+RN7pBM89VqaR6QgFwMChpfIG1aCiZco4hEBrZFXUjrgFArjBorjIYZNPJYZi0rowar+4KHPDKoKUyr/RKEBKBrztpS4TFr8nmr9gZsGFhpAfAEDYUSUAABFWakH2mYNsmG616AzdApou6oC//g6hjqqhduqAQKqQHUa+VOUGZWmtxGkuf2qZMYAFKawFd2IWcF5kiJKpIQbIm+35HgLIqGwTz2LJo+LI/ELMzq7MTe7NXCqlcurM8S6MWZakFYaP8WLSwdLSYmrRL27RE+LRhiBZ4GhcEG13byJjIaG+aBIh3xEM9pEdmaEnr963g95onNnjESQAUEYSSyHaKl6tY0bcXRoyAG7gdNrhmWLiGm0OI2z+K65sVIYbDSXAyBrms21uTewGVu3aXa636WU51sVkjumqZ9HvaZ6LM5AEegKLptLLiA0IpW7zKq6Ljg7xZC0JK0W+WKRBH6hBu63qbugKv9KnQAndLu7TM/weGavuhuNsAugsC3KNJvut7wLtMwku8xcs/zru8yyu/QZC8lRS9TDC9AFC9DXG9lpe928sCGue932sB4SsCkbm3UkhS/um5XfenCrBBPjS6GNRBISYaZaG54zoQRTEsrdtTIFdyrstXm1IUs8t2i3uLrfXAEGxvEkzBpWvBoes/GQwaHFywHtwEIOxkA1DCrBnC5AZYJ9wEKbx2K2xPL2hgzwSow8ZMTDxmToyURlakDWASR3qk2JqZZQR7TSt7YPwBQFkoSwxsM2ePNAjFZgxmU/yVoEgQVozFWbzFf9nFCmG3mxfGnTfGphGBixmI8waSH/mYtCjIXRdXDPy/Dv9QFENredL4AnYIsnoRqqfkx3I5W8layITce4Z8cYgstVXLyDfqeo8cyZYjGJTMwmSoYWzYyZq8kK88i5zcVJgrEEqhFI4cePDzrwCAGojYWqwcU648y7BMzLKcfcpouwxxy06Qy6a4y9jpy4Xiv50WSZEUxW+1vsLcxudKXenqvh6wUiiKuV9Da3DbSrxkx8IHAHVBEFl8AGRRL9T8E+51zWvsVtqcjNycsBv2zZ8kvOI8oORsUOYMp6+UzmSkO943EO08EO8cz9JSqeDnWNI5ne2UelI8mgsrZLKlSYV6kUypsVdIWIVWObZYqXyMFRJNfBhmni2D0Wys0Qt70ej/CaAdLVFTCtIhvboj7Z1pGTcnraYpfZsKUUww2ITBRp3+HKAZfXHvSwILsAAounS8VhAovau8WgB2zJY26V5MyGfZptTtq55c69TDC9VSPaBUnRFXvY9ZvUpbXdXfBwAc0acIadFM/cR5nWlkDVGfnBF1A8AXWp8+atI+O9cGUdch2lguzZVLvdF9rdfoKlt/jRGBLbSjXKFQOZWK9qMo46GIDZ8vuSEpm7IwfcaR3c39PNZ5jW8i8Y5vDdcJrczfp5WkXdqnfXRozNqTzc+7vUmuHRKwHdtxHdpVWy1GXaAsq9qtvMkKK9m/zdfePM6HjRGCzavWE0XGrcjIXWDM/9vUzV3Mzy3dqw3dDEndiXzccxvbWo072r3dDeG3r0Vxnxtmayia9IffNMnVLI2jr4tcrmReAwdFlgPfByHfHBDMs6XfvGnfFcjgs1XL/d2rkQuA3zXgmiI3Bo5nXIbNzJ3bTjjej+1nZE3d47maFqrZfLVo7jPU6MPhJOXhvg3iTbzXZf3c5Q1XAv3Gor26OcrZ+wpnLc7joQ1I7XnkSK7QtrzQ16rBSd4a/A1G0vTkVP6bu7PONeXkVa4XjAt2Wr7lYD4ZqHEoEIEn3BXma4EnBi4ZaN7mijHmS1Dmn3Lmbo4Sam7cTVHnet4Xwcnmex4TUc6MZfHnhO6t75nlLP9Z6IFh4LqKEkiABEkQ6UkgBJRe6ZZ+6ZXOA5q+6ZzO6Zj+6Zfe6aK+6aBe6kIw6qNu6pY+xoV3xMxHiUesgKZJ213tEY8u6ZOu6piO6qKu67vO657u65YO7MGu66zuEbE+ia+e7Ok364FuT+eiFLhOBNROBKZe7die7dqO7bq+7d6e7d3+7ZT+7dteBEUA2iVBVhOUEHcLxq/+dgfMtHicx7L37uJb3YzethMk7ZLO7aVO7gBv7aoe8N4e7gUvBARf7eaO7hcBol5M75337m4X7/MO8Zxn7woMROlt3FZMEZH+6KBO7uOe8OA+8CTv79d+8tWO6ePZ8Qpx8RJP8fP/HsYS/wAyH5n5zhAunxAfjwQhL+4Ir/LUbvAqT/Qnz/K0zs5FShEw/+4yj8c0H/MHfO/PnlkHowRKMARav/WWru2YHvDmHvZFsPVkz/WVDvZiP/ZlT/ZdD/Bpr/Zav/BEfhDgxnkpKIRD6LR6LHt3z4Wa5+LDd/VZX/Ztj/Jn7/Zpv/Zsf/jk/vaKb/Yj3/iJv/Vyf5V1/wF9H4RfvPezl354T4SAT1XgpuiK3o6wMfp6Dhs5T/dNSfqub/p2g/p1rvqr3xB+7vp63udf/uddPte3j/turvuJvue9v2+UqVnHX/sXkbvJz78GAaL0wvwbfxSWKf2gbNz86/zK/xDWK7+Xewv9BdP9ylH95pv820/PSX/+jZ70od+K6Y/nc6/+Pc7+8R8X7Y8ZAQEAIfkEAAYAAAAsAAAmACwBjACG///////Y2P//2P/YPv+ePv93F/+eF/93/9j//9jY/54+/54X/3cX2Nj/2NjY57Y+zrZWzrYw57YXbueGbudgwLYXqLZWqLYwbs6ebs53bsCG54Zu55AX54ZI2J4+2J4XzpAwwJAXwIZuqJBWqJAw2HcXSOeGSOdgSM6eSM53SMCGSMBgVs5IF9ieF9h3MLaGJrZuMLZgJrZIALZuALZISKh3JpBIAJBuAJBIzm5W52BuwGButlbO52BIwGBIzm4wtm4mtm4AtkgAkG4AkEgmkEgAtjDOtjCokDDOkDCoJiYmJiYAbgCQSAC2JgAAACYmACYAAAAmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACP8AAQgcSLCgwYJSEio8yLChw4cHFS6ESLGixYsRJUrByLGjx48YNW4E+VAkyZMINaJcydIky5cwW6pk6cCBEiUEa96MeVEnzoE+eQptGBSozZ9DkyoVWJTp0ZdNAURdajDqVKoxrT7FyhXqVqc7YSYUKLKs2bNo054lO7Kr0LEA1MqdS7eu3bt02caEi7evX71u3470S7iw4cMz4b7ki7ixS8WBxQ52TLmy5cl7J19GDDiyZLabQ4uu25mnxChRgADp0KGH6x6sY8feQLu27du4c9Nm/bqHS8+CUaOmQLy48QnIkytHbqK58+bIjUunsLz6hOfPo08vbn05dufat0v/p0EjIRQokDMnRK2a92vZsnXLn1/bvevfwDMLjyKeeHfl30E3QX/U/cdcgOFtZ+CB3yVIIHnmodfWUBIJIYQOGOqwww4+dOhhbyCG+FqGGW7o4Ycg4pefelKccMIKMMYIo4s00higCTXWKKOMOdoYYI039ujijjEKeUKQQuKAg0RYVXhhiRye6IOIVI5IooZRnhiiiisuptCQRK5gJJI9himmkGQe+aOQZo65Zo9KMqlUTQk54YSFFvYG3558ylYlbH120KFEYXXpVUJLLDGdkUYSuCijPToqXaSTQpqjeC6SF6cUhQ5FpxR24imEnoGWap+IpQ6qUKeGovRpoo9a/0qjpMbJWiOtxVFaq60uYnqCpktyihRPAgggURHIFvGnayRuaKKUy4qI4X0ztbpSsRIR2eONzZVp5plAcuttmzlyi2OO34JLI3kQTpQUtgolq+yyzTor5ZTRgjitb9VaexK8CWlbrrjofrstwToaPHCaYJJbI7vluTunA4guEUQQqs13ap/05eaeqgmx6m9Hn6J2E4ELXofggP2lfKOD0rm8MoGZ0rCpyFlRLEWiF2cs38Z8dozbxz4QOuzIJOtsshIoL/gyy+LJ3CDUCjo9c38133w0hfEWYeHFtIkgtgjO2gttD1dmiNvYZJcdJZdIcySSCnTXLSPdGmgAoLnO1f9td4x4650c3337rcLdKuS9N+GGHx6jkjfcsGl6XCeE7NdBhD2221mimDaGa2/uNsgSx93R3IYjrvjghJvQuOqCM8j364AnHrvKjKf+OA6RTz6hYAmJauEPP8QntJ8gcpwbWqZfZJbsU0dt9dPSG2guzP5N7xwLLMzg/fdyLuWkqMQb3zHypO6pG/PNV/Q87ldPJ3X8MWsffdXWY8f99+CXrtT4whOVvAZIQK8F8IAWKmARzFKa9hmEMRLxHrCURMEKWhBi5OEf/yZowQ4qCYM00OD3OOjBC2JQhBsMIQrbRTngSQGBAlRgAWF4QAUyMC6/cyBBIKgQCdqshB4EIQr/Z0BCIH7whCv8oRErKMQhElGFImRhDlkkAQlc7IpYzOLFaKjFLnoxCKK6YQt1iEPQKASEaESiE0eYxjauMYNrZGMb0RhHOUZsjF5KSBW/2EUu8vGPYSxLA8kIGJHMMY119OEh1ZjERD5xkRBzJMTCB5MAWDIAEtljH2kIwz8CUghinGLzLolJKVgyQueBpCpXycpWuvKVKUgBHklCykxacZOcPKAn+WihUBJSILU0ZSnPk8pXGvOYyEwmCGM5y5OcUiFV1CQWF0DNalrzmgtggDa3ic1uenMB7PtlRkRigHIaoADoTKc5zXmAdrrznfCEZzrVuU4DxPOe95wnOutp/098+rOd8wQhClDATP+t5Jl6jKYWv9nNbXKToRANpzhTQk5z6rMA/PznPy+aUY3ik6P19OhH0ylQgsrSoK7SmZ04wFIOiOpi1nSoTGdKU4dic6YlKIFIcDZRp0jkCU/oqEjvyc91DhWfRWXnUeOZ1HK6wAUdrIFUaxCyra3kUytt6UuDENOaerWmN5VpTndq1Z5KRWcJAapQl+rOpvaTrW1tKlzf6danRnWqVXVhFVlKwK/ONKw2veZXb2jWcSrEqHN1aznnegDFvpWtjn3nXaVKSSpKgK8D9KtMAfvQrtaUsIWl6GGVCtfIJlaxjDVtOydLVZSuxJZVDCBEr6mA2v/adrYMBW1oByISujr2t0z9rWrjKly3BrecIMSAcjFQWckkNLbCw201bXtb6XZTt7vFoUR8W1y5wrO7xv0ueJN6XAMkd7nNtSx0RWXdb/4VtyJJVHZFmxCPghSxcL0vadmq38UeFWIykEEGBpyB9MrkuRKQbXsbuln4akS+8+WtRuyrz7Uutb+PvXCFQ/pfdgWYwAV27UcQKoVo3nKaC2boe72J3cKSuL7uxDBjZTxXGueXpBgcaEGbOeJSInihKXZvg1ksyAi/WArvtDF/N4zfJc/TwkcNaI5NauCr6uwmD3jAeoUA0yBTt7btHatGeNrTT6U1qI8db3jbqWbvsrn/zUWNJ8RgAAPlUlZYQvkUlrWcYDx1OcVfVkCYdTrmspYZrVJQa5rhvFZGN9rRTW7nnOuMgTuTGSW2rEAF+qrZITO40wxo8USL1YAGVBTSqE61o1vQgnKKcKADXU8UkpLpTWcW1J39dKdFLU5Sm1ojqg62sLvLaldrENYokDWtFaLpy+EJrNWENjWlnU2aUpPXZj31sLfdZkXSQLivhjXcMM1sW4uK2ui2drTVje2eapvb8C6ut8F9bHH3y8oVk+YVsQnmbwY6yAsQs9EifNaform73EV1whktaRo8tTI3uQpIXrUEff95uoL295cBLvBVGXqiZk70wYu7cEeXvM0N/384ZSL+FXInBLPOXvG6ce3VsLZ7or3V6HCXuvOj8tN7oRnkSSQCcwPKfNo0r7lgQ11kguf8nz0fatRF+vMZBL2MpoFmn9kL8KUHdrY3F+fT/alkDT+ZwzeW8tV5LDetK7jrM891bpse4bGP9OyRjjKT92t2HK9dlCCx5RCGIK+ky93ru6b7fN8d78a7VSQQiDwELED5yo9gBCTIPAmQpRa9SmDwhTc8A1SM67D/kvGOT309IS/5ylse85rnfFo8/3a4V/vrEVV8du2ez737N+30zPtQL9pOiUTg+MhPvvKRfzHTB97t0bU90nE/93EXlvfxLLve8c737aez+ApZvv/4ld983VuW0zTnrOGdT0Ztpxa1p12zSI2v/AvY//6aJwEIQCD7Kju3xBKAfrimfknHfjrkfvHnZpAFf0NFf8l3f/inefvXfyL2WgoRAiEgLxZCbd4keqN3TQboQKineqkHdApxeZeXf5m3fywIAsfXS/dWOVKAgRooBByoa+kHguYXWiNIgo1nggmBgrCXfy24fy8ISjEYEwAjBUWHLDnoWR7IdNY3asYyYTqngKWFhQu4Tr5DhEX4hRO4QBXIEkvYhEXwhHHngSFoOksIY1CnhTwHhz5XT10ogWD4hRTYFT+WRbN1dF2nTWvYPCKBTm8mfBpFfI2Fdt5HiInYZCD/5IDjJ35TmBkmBmSkR31/KIVJyIMawYhQRmHzVIjdB4rf14j79YjhF4njN4n/Z2ICCGoESHOBaDrYJ17yF4e32GHGBoSFIXStGE2v2GmxWHo7eH1W+Ia5KHUMyFbksYtWdxi+mEcAaHFcRVsbJ30L8G/gVIzZBmzgVV4MZ4vglULkEQMxYBjReGDTeGL7Zo3UhY3ZeI2zGDc9qIWpBo7yZkfmiI5YJxRLiIE0mCwbqG4dGIXYNI/+Umr16IOpNkQv8AL+t0M5xHYf8Y8AWYM3CIWGd5DcKE4K6Y0MCW8OCZFjOEgU6RGwxY6qAY/aCHYdiXMgaXLEpXAz6VjhFpH0/wV4v6hvK4mNLZl7rCh2MRmOoghpJ9dUN1mSEoaT0liJV2QhBYmJADdTCPl/J7mUCkGKnqiIw6dPRZlhIoVOJcWUK5KSWASVOPiB0keVL6mHm+gQtZhkXmmKv7eIBfCVNzaWShkYCZAAFLdXLiU8HjiMNZVTFJhXwFEsRdGXElcQiolo54GLccZYdMmVHQZHlvZx+cGYOpMogBlAg4l4mmWYYjhwiSkAi+mXLccQjykRkTmH5EWZyShSkTQDmXmAWkeN/HaN0tdv1FR+o8EZ/UgRCzmZw/aV3fZINDBgZJkfZsmH7lhdvZlxvxkEwdkY6fhAQwlclWmU3alm3sace/8JEzVRE6RkJ3bilChmTT8Jd7WVU6TZcdfpmhJiNFUVFjxVnuVZLEDVnyMXkt7JT72DA3SmXDdxaYGhn+eJnurZjuzJm7b3nvCJLPI5nxFCVvf5E/mpnw7An/75nwAajgIqOQRKaQeqmSuioAHQl32ZKJ7JjhfXnl3Xb9qETVikGsSjG6yhMR2go4FCG/diGyd6afpZLEYqAP4ZonXZTgRAAM7oPY7VpHZFQQWKAUOKokuhoiyaAC5acTBajdQkowBHo2pZTTcKBDnqMT36M2s6ND+6AUFaG1fqEEV6pEjan0oKlk36pDMQpQQwpUpSpXOaouVpSfpZJ07AUqDpV1H/KXo59QEfUFseMKkeQASWSgRloyVo8zmgUxtswznP0iGucSK4caIQUROlZqd3qmiMVmxw9lSwClU4oHJ9cRMZip9Y2hDFMnGFGgCHCiqJGpjnxqhpSXOPGqkKQKmVeqmZ6jmcqgO28amgqqmkehum+hCo2gCqmqSr1mqvGquySqt4YavCcq0I+hC7ShIq2qUsZYkLJqbvqgCq4TOlIjRsqjzVeq0VUafcmqdOBau+Yxjkiqutsq4u2q7QCWgQOqbyOq+78ab26qb46iG0oa8Uwa946q//OqWOMbAamqv+aKQcWp5EJ6zP9oFRqHQOBZ8sC5/aJCr58hodEqooErOj/0qxcnqgBEFKBMGZNXGk3EqZ3ylc4AqwwUIYNwFUiCkQ5xqyjzmyJbuo05eyDbayLcuyL4snNtsDM9s5orq1XIuzFauzA8GzA+GzHWqkQSub31q0ATuuSqC0eDYQTUsVBvui8woEF8ew7+hlDasaOZADtlGvEeumriEb9zKop7qfqwqiIVq0Vxp547d/+XeY5Uq2BdurXVpFebu3ftu3Cpu3gTu4EFu49dEagMIaiTuk+8q4/eqvkDukkit+lBt7pelxFtsVpGRJOeEAAzAAm/ul8ChdgVWjC+BFueRHyIsnyLJFwiMv5Mq0uaqfxAQFpLin/VROIPVmcPVUXaqKyf9Xu7KXu8CxuwHQu78bvO46vEJmvMa7vMmrS18UQ84bQ8gSvQBQt9RLTNfrpNl7ThvGvWzlvS4KvsgnvmJIvl1ypL+aEAE5rEg3tSkbwbfHAFcrQwaUSxisQAmUwc+bLHIrvT3LoqSEtq+7pFuoZu0Uq+jpBHe4fAicoWwosiR7gRnowe6LslSbw1N7wTIUvxs8Q0LgbAEkLyGcv8OypSWsmjVxwmApmeO1wrDawi+sfDF8uf6Srr1bE33ZworqZ0Gww+9ltTlltdpEmlkbQ/Y7QGscxATUwciiGogJVAzRl4Zanr9bvbOpjLH5TkVrAzbQwpMLAiqoeaqhwKdZFeX/2cXo+cWYI8ZVu01YK8klcMYl4IQMUMQezMHM68acLC9yPLd0fBB27Kt4PAB6LId8PJl+DK6ALMi0S8iFTAKHjLnN87SI9sAnK5VpmHTeBKksS8Q2SKyNupEBB58yXBAIgAAMoZ9OHG+sFs0tEKsddKKS13qVt3+Rl3/J3D64LBG6PJC8LMG+3E3APKE4TMzFOoDHLGbku8zNXJ7PDG/SzGrUbEHWfM2Tl80gsM2a180OpJ+JklWY47m7CboRSp0a55sJjdDYxLKITKfynLF5CqUGUEFIqwRwUbf5IdBLQNBc5qALLZ0JPVsOPaMLe00Qbcut28QUraQWjdF+gb8c/+0Wd1wTAx2swmzMObzDFAzJP02slpxTEX0QuFy9HrXHc+g9HZTRGw2ykXHTDpDTmDWsOdjTVBvUPl1t5DzGFgyfRW0QR82/V9jHbMvUFuTUI1HTnrHMtvTF61nBxlzM5UzXaEiAHecRS6ixQ9Scw5mdhuLWWgfXIj3B7St6l4jYh23Jfk0Qe+2vfT2elHOVXRIhDXoxxttefjiVngZ3mw2UOgkREmGIWolRlolPqGgnF3FkQnkelx3GZUq8nZ2J47xgn119oV0So4XCXcl9vH1Pqe0Eq+1j4+kZpfaRL6dV0Zdihm3X7OzcsljcAADP2iUFeSrNTS3dPXXcv5bcjv+MJ5wdmtAtjIsteo093cxc3dcdzdlN2buXm1sX0uxLgPB427btaectkW54AIj4iYc4l/yEiu69Wym5VfMtmrFN24cX3rmW31gpl6FYmcC3lesk4LlNcGZURc12a3eN4B2ukXW9zp+l3QCA3NatsQbgPZETOQ5ujAm14aH34b0s41393CJOUw5u4iie4jOw4jfQ4jC5h3H9oCfNsAwFrwpb5KD9fAkRxeLIaBaO4cQJ3+uLcUqusEee0nxL0tIF5KP9jU8OZ1Eu5VMu5FeE5PF65fON5u21H0x+4rF5nIn4Tqh4HmSu22Z+MWxuXXvOkloeZG7+EV8e58ImwA03SVL/YOd3blgJhUWDB+KwCFHiXd6Rnthsed7FqXqRwz9B+d625OhDAOnkbek2Pt5f1Yde1en6vdv+uun9A+Tt4xMhZ6G0Pp8sd66yjmi1Xhe3DtWElOu7HuzB2euLy3LCbhfEHmHUzUPH3uyUkY7cnRAm7uxqAS9SvuyaQe3azo+zFO1SMO3bbhbWvuilEe7mjheAXUjnvhZ/jeGQse7wLhfpjnXxXmQDfnpl0QT6vu9I0O/+/u9GEPACP/AEbwT/fvAIjwQFv/ACn/AOr/AMv/AAL/EJr+pYGYQoWMhfmHz6vM+uJ4QaX4TJB4MW7+Iase/8/vART/EPf/ArX/Atj/Av/0/wEw/zFf+WDSESIK+CG498He96lLfzXtiCI4+EJe/pUoDyMe/vMz/wS1/zTf/0TN/0AS/1/e7lCvHxGc/zIu/z+gz0FiD0dtiCJH/h5F7dSv/0VF/1Vr/2Bt/2a2/1SID1CaH1Kcj1RO/11wz2Yr+CRVj2Z3+xiMYEhM8ER3AEAc8Dir/4VH/4jv/4iG8Ei8/4TQ/5kJ/4k88DjW/5jo/5kx/wSZAES4sRNWEniWLAqJ/6kdiC4+vrGB5yhW/4kZ/5ml/5nH/4nk/5M3/7uC/5mb/5t5/7ig/6oj+3HFH6TnD6qr/8y8/6Cez686XExK3vSx/61p8EvB/5bN/y1/8f+tnv9DHf/djP++DP/cVPlkcqEneY9+M3y2O//quI8+Qu/RJB/eHf/d/f8Pd//fm//Q8v/gBxROBAgkYMGkGSUOHChEmSSIEYEcBEihUrCsAoIGJEEB09fuwYQeRIkiRMnkQJUiUIkiQ3QrQYU+ZMmjVt3sSJ8+VOnj19/gQaVOhQokEnwtQp5WhRpk17Ls0ZVepUqjedXsWaVStTqEmXbgXrs2tVsmXNzkQaVu1atk8BILWq9G1btmPP3sU7NS1dvn2x2q251+9WwHkNH86oUe5EjHAPP4acM0ECpJMnO46Z2PHlxZFzItXc2fPoqqEvKiadOjXniZYpi7ZomiI/a9U2QWfEXFv3TQcOovyOokTJbuKPe28ULrU38ODDi888HjH5c+rQfQOfXl371OgQs+Ncjt359ondpXwnXzUgACH5BAAGAAAALAIAJgAoAYwAhv//////2Nj//9j/2D7/nj7/dxf/nhf/d//Y///Y2P+ePv+eF/93F9jY/9jY2G7nhm7nYG7AhkjnhkjnYEjOnkjOd0jAhkjAYOe2Pue2F862Vs62MNieF+eGbueGSOeQF86QMNh3F8C2F6i2Vqi2MMCQF6iQVqiQMMCGbkionkiodxfYnhfYdzC2hia2SAC2bgC2SDCobgCQbgCQSOdgbudgSM5uVrZuJsBgbsBgSLZWzs5IMLZIJrZuALZIAJBuAJBIJpBIALYwzrYwqJAwzpAwqCYmJiYmAG4Atm4AkEgAtkgAkCYAAAAmJgAmAAAAJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAj/AAEIHEiwoMGBUBIqPMiwocOHBQMEUAjFiROIGDNq3MiQYkKOIEOKHMnRIxSSHT2iXDlQIkWLLGPKNCmzps2aNFk6cGDECMGdPW9uBOpzIFGhSBseNcqzaNKnUAUuldp05VQAV6MavJpV602uVb2KrQk2KMoBA3ruNMm2rdu3cNmqDTv2a9O1cfPq3cu3r9+4PdGaJSnYCN6/iPvOHVyX7F0HiSNLnkxZYeC0TkNKdHkSQOXPbDk3RvrRM+jTqFNDET1y88TOqkGzHm2zdOzbuP3ORmnShw8awIPjwJGjuPEayJMr79BBOfLgwonneA6dRk7apD1K2M59+4Tv4L9f/xhPfnz48N27nwdfvvz67+m5v5/Qnvz8+N7Pz5hxfaZH39XRMJxxxzm3XHPOBTjgdDUE2B92tWmH33z1mfcefhJQWOF9E75X4QUcxrfefg9GmFAPPTCn4oosruiBB8i9KKOMLdZYY4kQ4qTQAzz2yCOGPEIg5JBE+mhkj0A+QOSSEBx5ZJJMFumkj/G98MITT5SW3Ykp2ujlizHOSKOXZOKYY0wUTQlllEJOSSV+QbLZpJs/wqmknHTW2Z2VWGopFEW+AVhdiyigMNyh0hGoXIDAEWooDmaeuRJF8Vlg6aX1RRDBkxlOgOGlmLanKacYbgeqpZluamSppVppJUVPAf8aaICOIrqgoskxSkOtkKok6U2UpneqBalyCh9+wxa7KqsSJCuqqm8ym56rL8D6p0K+ochcoYXammiBujrara0ERvprSAIIQBGo5Vk6KpLSxuvseO5C+0C8zZ7argXv6smspTLIQOJCScmqbQfcPooogcVRRyuLCXtbrq/nspTuuqHSy6+9+Eo77wX1RvuvvuSFDK/HFgQ8sJ81JeByArIKujDDBtacYHS3FoicuRVndLFH4n0I4nkddxie0EOjV+p6SK/Hanj7rdxZyy/H/JuAhzLMoM02QzczrjtT3LNIP1MU9IdOF50e00KnjSHbaBO9NHhR80ewXQkxwUQQfAf/AQQQWnPNtddZ0+xccRQxNjZIhykUt9Jvn9e03JEf3TblHT7N3gV1D6y4THjp3bffgBsuuIGE59zw4TkkntniHDWe0OPgaW457cdWvjnuns5tO32cd57Q5yul2/jofO+wQ7gQc+vtcMytzjzicr0O+0ENNCA7FE00oXapzoL6btHhXzp+x+WDGkMM1HpuffECHI+88syvGPHz0TM4fevVX/9Q9tvr3vc+RTLxqYp8BTTfAdGXQPWxz1XuQwoCEGC1bPXgBxj8AfI22LdAefCDKMqgBjnYlgmyzH8DyV5CTOgRarnQhQFTWef2E0MZvPCGrqrhDGkYQxziUIc7rKEP/28YMGvdhIUJ+aAPQphBDnJQiUpkIgadWEIKTg2FBFEhFJCokCFSC4gzFKIXvxjDHc5AjGO0Ehg7h8Y0FvFuJoJCBjKAojra8Y4ogmKg8MjHPvbAg20RyAmxKEjYKARLVoKBIhfJyEbCII2ucqQkFwnJRE5SkpVMoyKNGMc5+pGPerTgJz8JSLYUkpAHsc0hn2DJSzYyk650JCxjychMjnGTcIwJXo5wBBGIwInADEIofcC3KQYTmCZZzPtQuJPubS+MPazkGuvWxjFOM2rVtOUL1xgwFaiAeCjZZS9/ecwNDrOYIyznBpNpGLqgEisOcCZkPALNgGXymjy0pzTLGP/EaGrzh/zkoTfBSRJxztGTd1yAQheqgIY6dKEQjahEJ7oAhyogBCFoC0EJGcAmGOCjIP3oAUZ6gJCa9KQoTalKDUDSkq70pSdtKUxD2r4ZUIAC3hzeMkVi0IPiUaIWbShFhzpUi2JUozvl6Dwp0r2UynSmUIXpU6P60qnOtKY3zSkUNioSihyUjgklakQZQNayijWiQl1oIN8JEZOMtABwjetIY9rSutr1rXGF61xNete+kjSvenVpSP3qV8AWwJE3rUAFOIkmhXz1p2ddaFnNGlmFplWha2WrQ9x6AMPudbCEvatnBQvS0IoWsJ8trWnraljEUkCxjGWJVw8qyh7/VFaikyXrbdVqSs1u1iOpFelqWzrakBaXr8P9K2pJK9zkdvawjbzpTWM7KcfSdol13C1Ec8sA7S4gs75NJXCZy1LnPjevqT0uaJ2rXtWyF7qMlC4FqDuSxpXgviUYnW+4q9uh8ve//FXoUT3CVUJOsHFNpaqCF8zgBqt0BRBegT6tlFUV6NQxFMFvfjvog/8SFcAgpuyAXRfeghx4qdzzqINXzOIWPzjCE35BhS8cRw0rcbJnDTGAKQreEhPEJC4OspCDrMYYpuDIKaAvSTKM3xtT9sM6DvBEe+zjQlJkyFjOsoKLHDAkJzmX4ZwnLx8bVopy17sUHbFlksrWxlnE/7znjStd4WxY0NYZuXQGrHAdqVitFngoYj4Cme0IZRyjWaJqpnGVqfISJ+Q5r3M2752FO2n3SlrP5eVzBfzM5pDMFqGErmhQDw3UUfOWZ5oFclSD62JWt9jVUX1hYhcL5uomZNDZFbVFSY1WU2O2t4tGiEeoCusVF9vBx4aprF9L60GO5NNgZaJlFZDjKJ95ysAOtmmurOVuexulXJaBl5X8bOuC+oI/mHa1rW1oiVK5yqr+try9He5x13okxkPxffXb4dzilt0gRnRGCdxpLLrMzY4m73rhrPBVM5zV1FIkYVlAcRbsh5F9tvCa4WffDfNtv/4eK8B3HNFEb7XgKP88OIrf3PDmMtzYDydvxGEw8YpffJEZJ7F/bh3tOgaV2rxmqK8j+m4fx1uldg1y0ltdV0V+VDWnlK118fjzoAt919hGNVuP7tS6Kt3rTG+p0w0AddM0luco4huKvHvtQxe9xEd/tJxRKvfARpqwuCy7s0Ey27QHYe3abTua3x7euF8a0nQ/vFzJO9y8pybqtobCvpFn7X+PnL+ER2W6yqYQwq405i2f6XArbnG76f2KS1bI5EdXeZFfnruZJ+Tm1TXevn4+5jA3LemlhhrI80YhH/iAEhX6eilvN8Sx3/qwywtnui7cua+uq0lAQH0QbOD62M8+CUjAt7joKCHBH/7/AooveOIjP9vBVvXDnW9p6LPYrtOvfvbnv4Htdx8uJFF53pgQ/j32wNBYR34hB1Em92cplwAId2ygd3vrh3R1RXH7V33yR38bQH0ncAL3p3MxoX9QoDf9Z0EA+FDjJ4BPtlAFiHL+w4EJwXIM+HIO2IBd11IQ2IFMIIHUR4EVCAIXmIEbJxQ9BVm8VnWRdYLaBk8JgSUJJlxZlmwMxoQUZxG8pAFSOIVUSH/Ux4MGyDiBdm6AF4RDR1REqG14gYQqpoRYxoQL5oQsAIVHQIVuqAFWCAJYiIKxs4U914W6JoJWJ4RhGGwIVoaiR1JDZlXRNzC8hIP0J4XXN4dI8YNl/5aHlxV0fDhwGrhof0hsgihkhPh+B2CIR4CI86eIG8CIBTN1jwhRQriHQZV878R17Rd6mLiJDbZ0H+V4oIiDKEJuZydHd2hbE5WKkriK6LdoruhyaBiIstiEYFeLMEARt0iBuXhvK3FiHhh8woddeCiAhVZWGNWHlohiSThv8hZhKzBDEQgCb0iFI7COI3CBlVgT1Mh/1lhbx1d820hW3UiJPeiH4AiI4uht5GiONEh96TiF7NiOJ/COnXRdFnRWwOiFrIhKxahgtMiJyXhSVvJR1FIZvvd9vDhHHoSHFPWQpNZQEUlIExmLmRh9F2lSGWkAG0kZHYkSs8dkk+dB5f/neq/HY8PoWxNkZQrxj/+IQy3QApMxkyRRk6qHXx8XKDlZjzuZdWJTYj+5bUEplPNGlEYpGUgpdQnhS760Qa1nZuR3kliUkljJYuQYY1ZSlOSWPVpkEHv3e18JlmIZZfc4cmaJQmiZlg62ljbkQm4pjQAAlw1wQnOZejwHkh/UX4f2lEO1l/7DWaZVacaYXJbJfObFSC7gArBFmHKpELwUK+aWAU7Ga5DJk1rXirUXWpn5cK/JcJzpmc2Geg9BEaPpg3bIhb5Yalinig3ljRDSOFlohAoRjpi4hLB4VS7EaWPTU7w5kl9Ykg4lnNhBnHR4icqonC32Qs7ZM5ynYXf/2W6SRYKOuVC+IZk2sRtdaRAuw1ktaFoul3uy+UiuMl2gORrhyZSUN4DlaZ4SlZ49WRfsaXYY8Z7jFZ+hNZ/IFnOKRC34mZjYAW3GxDeXt24hJqC5wZEGmhF96Zcutmy6OKGlWaFBcKFiZW0auqFH2aEY8aEgymIimp+0AW3jiZc6eXkgx6ItKqE/1poVGYPmxZJ+VTeK9Jk+Oho22p9j+Z+vt6M8GhntKV4U4XlV5YL02VdGCgNIapu/0nen2Gu/GYwWpUTKMyNkkqZpCiY1ICZu6gEr6ARJGpoJEaNCWksvQFUv1KVzKhZgGmrSOaZeWKYfdKZjoqaIyiJs+qZi/xKnffqjdWqnkYaneupCfOqlLPEymvoyrrEV+uZxwtRvHuak3IVRKDpZGDU6YHM6NvM1psM11GMWszerAiAQriEReMGCL4iliWdXFLcfMwgaylQT6bKpm9qpBdFx/BZwpJpbpjpy5oePIaCqOsOqNeOqq2ozsVoUtDp7tnqruZpwCup+QiqDpResnzGsMpEuGXGrm/GnuWZ1j5lbFsSojKocbGog9rqvMsJJErERVap4gbVXsBlXjucXFsGGeqM3qkQb7soZaBem8npb3FWv/Doj+AojNXOx++qvAQCwnSewBfBUBQtXB9sXCesEvLSwTNCwQuGtAACzxkoRH+iU5v9JWajajdL6rBUbKKhDA8hRHKqzNdZKHUGbA0PrsQTxrwWhlAnRfA3qq6RXemU3pfDDrjG7eQIxs8B3jTh5s/2Vs8+aj//lQT97tENbtIsCtDUgtN9CPX7CtN9qEE4LBVA7i3c1tVT7eMJWMeIUfED4i0AXqHpIaihyAzdgAzbAHPuaqDaSr87xIvkTp8XJaCkmqXSFrof4jBsghX/zFpULFX/7AYFbakRFkt51uIm7uB3QuI7bIpCbsZNbEU4QuniBnJg7Upr7iZzruUAAunR4E7MHQJ/qZOdpeVEpURzAAfloouoUqnqETs/Lb75xf+oqELRqmPmWELgbo+SIrjb/OIHXR4UX+Ln7KCnDqz3F25gliLwoqrzM243Oq07nFATzW04eZL3txBjZC5fbe7mY+1HfywIUEb43iH3kewLmq2jXA6+Ah7poBsEKNUp+NEy1RcF2xAM8YEHW8qgA0CdQEMAphSVYIoqcuwEoYhEjeiYO7IsSrF0vjMGgZMEyjEcazMEE48EgLMIoRcJPYMKcm8JySqN1Qas0+wE3CnDRerN8o1DVO71N2ZRPnL9QHKodbJvdqrVWaaXlyqugJTUGbIP0t6KwY8Rdm8TstsTm2cQL8MRQPMWBIsXEVMVk7KLYm8W1usV+Na5DmnhgHMbii311PJkKgQEYULowPJ2p/9sDiIu4kTiohXtWjoqpbXWVAexIzniLoiiFPuzBNVrIhyyxt/XClaW6jjy4ZBrJYjXJXWXJmIvJCvGMm6wBnUzJBLoZDsGwvIjIE9vLvix0u7XCDRGw70UABDCwLgVnimSyixQZKSsQegMhyMoQuhydv3zN1/zIq0zEKfG0l2bMyHyZprXM8NWMifHMABDN5yK3A7GyTGDN2BzP8gyVZCXMBgGxdltYBQDOBWCGBJvMrglYeHqyiCEQMLHOH1sQ7gzP89zQ1wx73BwRr+HNfQVX/OzPAC3OrCXQlPQCBP0XBn0RixOu4slho0rPIQe27kt+Kw1iAxa6lsty8rmrGv9NWC8UQRhRFsErFiTNn0150s1qaCqdoyxN1C49cDBtnDK9oDStmcN103ZjgDpdxrSXECX90+07ggBq1MnbrC3NbvZMpflse7t6ty75AnUT1kDpyWKxn6sXquSpxkWN0vZI1F9tbWpdEMR8V3w8XCllJWkd0WttyyxcmohMyqOsyBGs2N71c3kNqSH8iv84UrDM1sq3mL3om6p8aIhdWZ0dWY4t2HrtykHqbZTdSI9NSK4BnZkdWccrr69tdbGd2AIWAnqT1GjBhsZszHeHmfu82709UgKZ1P6z2rvZ2tX20N31y7Pt2UCHUbe90wKR2yp7BLtNAMG9WhYN3HhWV8P/Ld3vtBNs+FX0qJO+HNcNjd6V9dLgfbsqVrK/nd19xUj7Ed1FyBDiXd3kjY296aTnndXzrN5DiNTtPU8JBt+83d3jvEj1zQTEzZqYzctXt9mLLajUaeGHNmAH3cqRmoYA3ZIrVdmErW3QJuHThuEVTuGNzdjapeEizeGR7eGX2WAift/D3LWM2ZBoVtd52aRk+b7fJdqQzcMCadkQDgXBl+PYNa9A/uPQmqJdndpASeTCI+RKhZtHEHzLutzM2uUk5+WjCuZSJuY7q48G+L/c6492CthRo5D8iOVabtJc/uV0HuZ1PuZ3fm1kzgD56OYHgeYAHMBsLjUPDjuqFKWI/57ohuShhqToIP3BT2Djh+7olH4bVtu3VlnpeiEQWMKPc6HpoH4a16sUjxHqeTHqVUYU22PqrK4Y+9tpqo5irc5OXZHqDsBLuCrrs77rb8FLtV4QLvPpvM5OhVGEO4HrAbDqw77sCeHr7sQQwd5OzO46xX7f24MlSpDt2i4E3N7t3u7tRBDu4j7u5C7u337u3V7u6k7u6I7u6/7uRNDu3l4EReDn+I1iPaGOBzkCJmACF/jv/x6+45uOB1mQ67iDQcBONm65FIHt2p7t8v7t8L7uEQ/uE1/uFZ/uF8/uFU/v9n4Q2KnvB9nvAA/wAt+5BM+OBo+QPMjACz/aCZEESf+ABEiQ8dw+BDif8zrP7TrQ8z5v80Kg80I/BDzv8z0P9EO/80Jg9Edv81JulSd8wtsX9RQ4yC9/4zE/8zVv80mf80Vv9Ejf9US/9Ewf9l3/9T/v9FYOlFT/jFPf9tln9Vc/EIC+BHa/BGI/9tx+8fTe90WQ9xYP735P74Cv8YI/+IXv8SfHU/OkNyePg9tX8gEPyAeMgwCvv3NPt/GDYneP92If+O8++H//+YYf+ohP+ns/8aKf+PW++CEROjUoxogY+ZJ/ApRf+RR4+Qnv+pkv1hBf+hcP9Km/8fEu/MQf7sIvBPC+mpCdECRf8o+P8iI/Ais/8v3u7yXP/AtPEb//P/wbn/zHX/xAH/7g/+7aP9jPb/KyP/DTX/3seP3YD/DnH17GquzTPuvy9Dn17wB6Y/+h3v8A4cCIEQAFDR5EmFDhQoYNHT4smEDiRAcOoFzEmFHjRo4dPX4EGVLkSJJNmlQcmHAiRQdMmFQkGVPmR5coCULEmVPnzocXC84EGlTo0Jguf0J5GCDARaVEnYo8ylPqVKoNfQJ4mlXrVppMojpsCiUsV65fq55Fm1OAgKsRE7RNG1duWrhr4S6UeBcr0rk78/J1q7fvYKp2AQP4S1jxYquHDT9MjFAwY4SRAx+mnBkiTIwpNX9WzPmiZ5yioZAGvdA06tStEa6+6Vo2DlXYOmvPfm2xc2zcPAMCACH5BAAGAAAALAIAJgAoAYwAhv//////2Nj//9j/2D7/nj7/dxf/nhf/d//Y///Y2P+ePv+eF/93Pv93F9jY/9jY2M62Vue2F862MG7nhm7nYMC2F6i2Vm7Onm7AhueGbueQF+eGSNieF86QVs6QMMCQF8CGbqiQVqiQMNh3Pth3F0jnhkjnYEjOnkjOd0jAhkjAYDDObhfYnhfYdya2bjC2YCa2SAC2bgC2SEionkiodzCQYACQbgCQSOdgbudgSM5uMLZuJsBgbsBgSLZWzs5IMLZIJrZuALZIAJBuAJBIALYwzrYwqJAwzpAwqG4AtkgAtiYmJiYmACYAJiYAAAAmJgAmAAAAJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAj/AAEIHEiwoEEACRJIWcjwoMOHECMeZNhQosWLGDMWTEhxocaPIEOKxChAQEcpIw1y7JiyZcGTLmO6XElRps2bMUvClOlxoE6UODX2JDg0qFGDDhwURYCg6NGnUAVGiUIwqVORRX9GlXj16tabVoEKZOr1q9mWU6sqFZuy58m3cOPKnRtXYNmzMd3S3cu3r9+/gOk6cWKX7Ui9gRMHLoz3KGLFkCNLnjyYcVugkzPXBXC38eXCmkOLHl2Ts2GsmEmHtuz55mPVsGP/Zc1TyuDBQYJs2M17d47fwIP/7k28OHHhwilCgdL66cLbTkxIn06dOoXr2LNrx169+/Tt4LV7//cevjyF8d1v3Nhp8/nt3MY3IEcevz7v+cCVM29u1P1g9NWZFx6A1gm4HYHfGSgegiaox55LTIEmhRBCZGBhBiBkCEIPPVx4oYYg8CDiiByW2MNvOKSoYooeWpjhg/zhRFEJNNZoYwo45qiCCjmmgAEGE0xg45BEltAjjjv2+GOQRTZp5JFJ5rikkE4S2aODFdkUoWkLUeghiBy2iKGGI5Jo4ok5rLiimC+yFGN/DFV5ZApR4jhllVZCyaOUQFKJZ41z1uljn3/emCOWnbVEUW477OChb8LFJ+akF0IaXG8wvlnbQjYGaV6QoIYKapOelifqqX4OWWp4qIpK6gTbyf8gqwylwbkQo45WKl+kxlFKqaXAYeqmpq7FWeOq4LUa6qufKstkkchu5+yzREZLway0ZnnTAw+4RyGFw/Xq66+7hluchbtxSNESSxBrE7cLMcEEq9MyK6Cz9tKLL7SwCiidrOotx65R8NrmxLdCmEvcuOReKm66PazbrrsxFSyvvsrma2rG/Da7b7X9mvevDAFDMbBMJf20EBEsE8Ehimqy2CKIZYp4Jpoxy2whRWlRLBJTZHVU6JM9Cnrn0IUGuqedhCKttJIY2BjD1DHUinLKFLXsMs45s0lmzTfDHLOHPFPlc0hANyV00npCTS3ScrbN59t/Ps2n1FRbjVPBgyH/DAQQZYaN3+ArBn7mb+oydPLZIRW80HLS7Sj55Cp0V2V3lFNuuZOYZy755k12nrl6pK8nxeLbdmuw34CbaeLghKto+Os5JL4Q6oxr5LgUkJvg+efVXV7d7zuCXqTonhtPJPKTl44l7sWuTATCP/ww9swhgn04cDnjIKZcuWcEV9xFUz7lsiVI16TSk58/Kp7sS+4+3UOusALVeWsrI0MsU2+9ml6rGQ8EJzYAtgh84bvI+JwUvx3Nj0rqK1IDVfDAuumpfX1CX5Psh7+p6c0lAQhA1rRGwhL2D2EoRJgJV0hCuNAmgQT5icoY4jznYUtWHaRaDXdowxvmcGo8DOIN/24ogx/GQIg8JOIHYxLCEbLQhCmMohCe+EQXmgaGB5GhSToiRCIaEYk79OIPwVhDMeaQjD3E1hJFkjIB7O4DHzihFFk2hCFQEYpSnCIR6qi1k0yFW9DLHVOSwq0mNGF3T3iCERfZQRs40gY8fKQNGJlDSUbykZRs5CMv6cgvmi6QIGnjG+M4vTzS0Y53JGEe9cjHlvkxCoCcGBYH6YBCHlJ1C0lkJhlpyR1KcpdU62UNfwnMGAjTecQ84ydleTWKwLGEq6RQburYyjtGUwh1hEtYsIiUtQSNIsA8ZumSWUxebtKXmCymOElHzqmd4ASJCuUWF/JMVUZzmtRMZSlXmf/Nt2yTm2pZyDcZEs5zDjOd5TSnIzk5SXUaFJkIpdo74xkSikTgohFIYQMasICOevSjIA2pSEf60Y3CZTkAhQhcDsDSlrr0pS0tgEwLQAACGOCmOIWpTnU6U5raFKc33alQYzrTmgI1qEIlIgqWigLo7G8hGM0oCjdK0qpataomfQtKU+qQlQ6Vp0X9KVC/KtSeGvWoZN2pWcWa06TekKlNvc27VLccONbzhBvNa15Dqte++vWveu0oCUhwElByVSC7Ww5Mj4rWtO6UsWN1rE4h21bJ6jSH76QBDW7HzJYUrK521RqFAMtXwJqWtAsYbGE7e1iCJBYKi6WsASwbW8r/0valsp3tbV+K2RNolrNPlUJUc0PcIFz1uAtQgHKXe1UrtrarHbEtbnNL3ci6tLrY1e11s0tdIl7guxdY42EYMtziGhe5Vl0uc63q3Oca5CTS3S53ZVvb+UK2vvY9qnfBK16NhNBiTChvcZEbWPSOVLUdMexhEfkEpN52rQ4+AIQb++CwMna3Ep4pS7E1taX+9nSsDcl/VScvAROXwHs1sEgRLDH3GoTBEbbshF06YevStsaVvbGGD8DhGHh4syCeq3s0QGQNaPS0SFZuaVHLYsWF+LmvZWluMSxl+lJ5ylc+Kv5k9WPgyoRvTiiykaeK5NMqGaSnFSxhE/zk1kb5/wBYxnCcdzvn2zJ2yzLocpC/TOIAR4DI5j3vSNV7ZhWveM0tdrFrcSmFROb3wi19tJWrLGlIU1q2vf2wgj8C4IsC2rxVJbQCDH1gRDtZ0YumiKMrHWFWWxrOrrZxdTMN5E2DxJl2PTJVrVpm1Ia0vajmEkNiTexiG/umvZ2o/lyCazjqmqO87rVfRwpsVMP32NjO9nyTDc9lhyQpYVmImBGWmyVLu69YbcBgm9zf1pZN2/CON2VzOIN6z6DdGAH3WsRdZHIL2qPn/mu6121qfHP13fJOuLzpbW+DY4QmUiDyswM+bTQjmd3edvFJqAxrSXO8zi2t4WO1TDUuo+DDDv+XCMQlTmaKC9zip8U4RVO68Sx73Ob31anIJ0vyqZkc5RmvKHmlijCXV7yk5662omtu2erKmboYltVNVfNC1ECV6N8yOrph3mula7wjdoY6ncV+W6kbgOpXTMlnoXDXUko73X5VbswLvmdFE5LRq1a43iGLKNGwK5aepSvbSYnXXsO9r3I3LcZtjcW7q7rBe488UPsemr8/gPEF0ffuWF50aI9U67sOKQc4sPg2c1PzeIe85CVPec388fKmhwjqKcL5rHtepKC//UdHX3q7gxvGq2e96UbzesxLpNMRCPSgCU1qkaq398EGAPAhne1LF9v6OG1BCygiLwlIAALgD7//98c/fpbJxfgRQb7ync/85oP0+XRHfwKn39jqd9zY2L+p9rnPBO+HX/zkV35EcH6xJxRDJ00nxnUBd1WA5XXudW3BJ3kUYQEUWIH/B34VWIHm9xa2IlxSNWAKeG4M+FcO+FwQGIF7N4EZaAEXCAEraAEbmCl5cYBCAIKh1n7u51HKVYLuxjtQsBAoKIEMEYBEWIS5IYOb4oEIWG7phYM5mFwKwIOH9Tg/KAVBGHkUUYRaOH5HOCypM2RjZoNPaGhNNhjyxzgjph8wJVM1dVY2JmM+5YY5Bodt+FMuhSXdt4VaGIN194UGw3JiOIYGVoZOcIZnk4YMoVgvxYZt+Gp0/9iIFKZjdRhheNh/eliEfGiIFgFgtceEOVhgyAV9wbZ28sKIjihZOHZTqahdOtZTLFWJl4iJRGCGBTgSnDhmCDiGoHhcoohqpMgEphiJcBiMQLWKGNZTMvWKppOHsUh+LEOLziEFFTCNFVBCb0dSuSeFABVuw3aF2pZDKpiBIRACIlCO5liOHuABSNge0kiN1mh42Ah62nh6+9aN3oht4MgQLziO53iO6biOSWhXhNcyaRaPuddRZTNzCZQUAwWE92hsU8MCLLBQwxcYU7EQ/xRcAvmOvoZ7uQdtCXkarcWQakMRDwmRMSCRFAkZFykFGQlCAYB8F7V+KBZ67teLiv8GfMdoYcKIijxJY2HlUkQkKzVQA5BheZroEIhYYhhFk8e1i82Hky6mk7tljFX5k0TFiEI5lEV5lEsAeEFhUU0JauynXoIIheo1jwB1gvOVf67mltmVQ7LyAi/gcFfRM8FlYp74fk6Yg6KmltzEltwFl5VGmLPWQXNZl0H3EqeBl9ETcf2GQss3gi73UYCJRYJ5kqzWS/WWcsKmkLfGEOMmmexHmRRnmRwYfRLikJpJbJx5b4v5Xl4YXNRYjSRUZuZ2kAtwmVABkNBFEfiVc2HHapZFRMoGmmdBEbXJkaaVm6CHkKlJLL45EWA3XSDnWLFWnDd0nCIJFdzCLQIRQiH/lBAJIS9MOZNk2VGiloMENwLuOQLq1SjsMp/zGRXgWRD3KRDQczJ3xy1t1EaJFKCq15r2JZESWVMukKAK+l302Rjf+QDhKZ7kmQDm6WfoKYbreZPr9p7wuVzySZ/16Z0Qip8jqp+sxZ+19J3/mTICmncEOl8GygIIqqAJyqAh2hjiKZ4PGkIVqpf/dpafp27rxoeysRfy4h7s4mXskqNMGpMPMABQOgAVyi7btZPBWGVW6lNVqlMwAAOlY6NJmRJNuqMB0KNjGYhAWloER6RFOhdHajBJumdL2qQ6+qRROqVLsKUVdqWwlqU1pacv1aVfegENihclIRAJ8aATCh2j/9l5WtdRekVwGyWpQjpYLCNzbUqAnHUyJxNCi/agULocogpbaXWdkkWcB6B9qqqqpVOjhHqjZnGoCJEAikqejBqZjmp0kJpXlNqrQ0oEmJqpcBGnhdqpAfCp3xmqo0qqZGWq2FmYqbqqrEo6rlqoUeGpJPqgDwqGz7arH7l1k0pwv3pC1QM7sGMz22OutXMmHgKizJQQ2AqqUQqlAvqGY4dUMfZS0toCW4k/8QVr2teqLgCmsMpExzoQ2Iqs2qo6g1F7o5Vi31px4SquJCBaQlCu6jof6Eo76noz7QqiBAGvByuv81qvc3ivupWvLrWv/Uo1/6p/LSCwBBumSnmwEf/6Ygv7ndzacrcXd6O2ABErpH6FMBtbIhlrrkX7MusaJi1irT7xnyQbpaM6cqc4nAagfTC7quqxf4pBrCALADQbEQk7EDmrs3+Ii7Znkz7rrR85WEP7LUmLJkeLH3GLOCUiJk4rECsatcqqiMGpsrQFVFh7tdK6tdvXtUuwqSEato3znTlqpsXVKGYpiBlaWurpoY2SK+NiHwzDMCbysZj3oAAaoJK3U/vaeonhtZxai0FBpjxqnhcaBJK7XmNYuRZ3ucqVuZrrK5zbub7yuReStw8huixKupFnuoVbkV6puCbKH2R6q04ZUrbrl7TrUcW1G76bvZMCLL0BvMILEcT/a7L3qLXK2xctORX0WRSMKxLPexufhqYfNb3uN7kfdb0boL34qysOAzFM+73Dq6ICIL7eSL6Jcb5RkL5ssb6Ne5/Qm55NSL9AygAMUFw6oAO9kb8t0rvFcTPuehHha7zBd2n7iqct+H/peI5s2sEx8qAC0cDwW5bVe5YSTMEWzBsY/Cj1gS7EwcFfe3wALMCle38jbJ7sUsLhd8LmmMI97BmoB2YOKwSHV5kkRbGW2jKrdEr6ZLFztEeoVEJx2ryb+J1AHIExuqrQ0QEdYMQYaAEoPIAgpsAu0cQMG2ZoSyFRfJpTTMVaHEVYnMVyxMdcvEJfDLas+6BjHHxlrKpn/5zGakyBbcy8PsPCACAvDasB0Xtc8tt8xXVNgdbJxMUynpwbCKhCLdMoSlqAH+yiV7iqNcUuzHiJbazCFCPJlEzHl3xVmUxqm3xPoRxooBzKo/wtWmPKcorKPwzCA6yqrbwEr6yHsbzExPKgy0FPpJSrHemcC7gAo9dRl1qxVHTFfmxPpMwygwxKacMUhozM4xuzN5BIC9GP5piO8izP5UjOBRvJ3znNUlBP1vxyQfqo2swB3Ays3vxE4BzOVoxCWlPOT3bOCJDOqpzM6uHOUgDP6DjP9CwC9gzHUSGW1IRKAH3H0raEP/qUuspes4kRJvmQ+bgQ+ziO5NiP/5jSuf/j0flEBCFtkBRH0oaW09RG0xax0vfY0lLw0vwo0+oI1LP8AIMhL4CYgFBJalH9iSmWplWFYJq4dnvqU1X7VbKyYSRTvn4hMEsQQhydOk3NBE/NhFOtYm3dfG9t1WrmZZwmeFsth4A7VF/NY2ENGWRt1qzLH2Lpb8iVy4Zm2CqG2Mi1EI75EUINrYaJaYiZLSxpNo3NOIP9LXt5gxBMvZ09v31JaoxtNkLHmpB9f9s22ZLRM5dNMcpZAW3HMrgZgj4NtBGLzUbnmSGrEAzxtyc7VK0mWz3WdxexErKZQK8d2ziNZLgtxUj3rc1Ncbo9EBDn23nNc/IFWcNdkcXN28f/jc9UOI1w9NFs/Zw67dweWdvPXanrRtcWIUqqE9EoiD/PE9jSx2hnLWQ+KN4fQN7npZv/fNIBjt7mRrHuLRHwnUsDeoX0vUwZsTv5fRMQF1UUojW1HbTRnc3rLW3TrbfzJAXP+q9Wiz+O1OEpNeEYVeEEKeAAd9u0zeJsy+Gx+RAzFOLCibIkbgMmDlDI14klvXyf3XyKjV6FBsNFHlJYbd+p1mgL/mjZnV8NfuCqSbZ95mlou9kkNeSFHdpC/rNAHsMgleSNq+DZGWmVFuV9OOWMSc3KPdsbbt5vfuERO90TCpzWeeNWC2k1tOM0xxAbeZvM/eIEbtvQLejSPeMq/0Gedv7kPdl0VrbniD6VfSZmtxxtNqmLVS2IcX3Va5bV8Q15fspW1w1T2KIe0KjmJBoval1klX54abrpbp3pg9jpSk7lZM6Kw8jVje5WAHMDp47qA0F7uPotcQ7jhP6RGS6CL87nK/10qKqMpcPnaymaw27HLV7oxT7oGL7skf6bVojrp/qWIec80g5Du+PUV/7jWe7lRs7ung3mXR7kHtVk6Ed/NxfZuYXmUj6KjIbuhE3k7s6X8n7YXE5qiE3v9m3vTm7mkqbvaR59CzFDwjrxFK8XEhEW3FjxgPGSwRbxH67xIC8bVddNGFmPId8XHG9tqXHyLE8aI0+dq9nyc/8hFaQN8Ssv8zgvGS//3Tm/FzSv5kXR80K/GGnHFTc/9DuBnDAU9Ejf9HSx84wZ806fGsAOF0pw9VhfBFq/9VzP9T7w9WAf9mLvA11f9l0/9mgP9ma/9kWQ9mnP9mY/nbKZhc3ofxdY97H4f10o9yb4Flif9XC/9W6P9oF/9oMv9oXv9Ycf9om/9XxPFB2B999395K/hXofBLzpZqpjSFefBElQ9kYQ+qI/+lo/9o0/+qhvBKWP+Imf+qTf9qyv+Ixv9kiABPsexqpe+bpf+RsY4blTMJyvBJ4P+q4f+qs/+4Vf/MYP+8gf+Mqv+syv9obf/Fxf+7fvw7m/+9ofi73/X+tLxxCeP/xs//zHL/3Jr/zl//Wnj/7Rr/6tL/rMPoTbP/9auPfdCeyQvxDh//njz/6m//4AYUTgQIFFivhAmNDgQoYNCT40YjChwoYVDRKUklEKAI4dPX4ECUCjFAklTZ5EmVLlSpYqgwQZGVLmTJo1bd7EKfPBg4xRoihRcuQIEqJFIRJkKFSp0qRLnQotavRowYVPn0YlOpWqQatKiY5csiQngJ0jM4oQ4UHtWrZqW6KFC7dkW7oeTqIFK3bsXr59+5aV4hMoVKxaI1a12rQr4aiGFS/GisQx4q5fNYYdC3gk2rpt38aVK6Ez27si8vpFnVq1R7OtXb+GHVv2q2zatW3P5pgRp26Rt33/fp1742rixW0CR55c+XLfwncPZx5dtnPj1a135C1d+3burX1StwkFivDu28FfR786e3n27YF/741TPHn3y8+nx793J+aO+/XmBxA//zwasKYCOTowwJASTFBBBxd8gD8EI/zvQQtTY5BCmzKU8MIJO2zQwwtHcsIJEU9UrTW+SDQRRY8CCGCk+VxEkUUab8xJxb1sxBFGGcfDka+AAAAh+QQABgAAACwGACYAJAGMAIb//////9jY///Y/9g+/54+/3cX/54X/3f/2P//2Nj/nj7/nhf/dz7/dxfY2P/Y2NjOtlbntj7nthfOtjBu54Zu52DAtheotlaotjBuzp5uznduwIbnhm7nhkjnkBfYnj7YnhfOkDDAkBfAhm6okDDYdz7YdxdI54ZI52BIzp5IzndIwIZIwGAX2J4X2HdWtmBIqHcmtm4mtkgwqEgwkIYmkEgAtm4AtkgAkG4AkEjnYG7AYG62Vs7nYEjAYEjObjC2bia2bgC2SACQbgCoSDCQSCaQSAC2MM62MKiQMM6QMKhuJrZuJpAmJiYmJgBuALZIALZIAJAmACYmAAAAJiYAJgAAACYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI/wABCBxIsGDBKwgTGlzIsKFDhwkSJFT4sKLFixgdChAwEWHGjyBDihQZseOVkQc7olxZsKRKljBjbjQZs6bNmy4novSY8mZIK1YM8vRJ9GGVKgaBFl3KtKHSniOHDpTa1GlQqFWrHk16NatXok8JUg3J06TZs2jTqkUrcOzXmgEClF1Lt67du3jz1m17MmpfvYAD831bNO7cwIgTK15M0e3DiA8eOHESmbHljpMjN2lC+ObGyFSoVL5MunTpKVM0c/4IWTLlB6YtZ36wubPNzw9Cj47Nuzde1KpR7k5oxIgPHz2SK1/OXLmO5zp2SN9xvDry5tiPT6xtu+jwoyhQsP8YT758+PMoTqhfzx59+PLwWbhPz77+/Pjm3de37x4//Bw5bLeacLB1VNxx2CXoHHTTUWfddQoqp11C3HXn03dVvOeffPrtt959G87n4Yf9hdjhiCBuyAKAAto0URBBjCDjCA1K9+B10OWoAwc89jgjjTXemBxNFhblgAMTlbfCChtsQMGTFIy435JUrqAkk05CKWV9VS55ZZNQRrnlCeGNeUKXVq4YIEUuJgTjjzU6aF1yOkLXo48zxilkD0QW6dORSZK3JJhamnlml19m+aShh1aZaJhmljkmmuOxyCZMLwYBBBB3dtBBc56GGuqdpJbKgaeghtqnnz5NxN6TFcT/KuusYdZa6H6wzqqrrbaOmKuusvJaq68UAHvDsTfodFOmm3b6KXOiimrqtKc+u5yoq7LaJkKvFgtssMLeWt+v34YrbrffgmsuscYiq+xtHBFnhBBCRJhjg3tG2FyOE76rbUyGJYRiif6JKGWK+Bk8MHoqKuwhegBa6phIM8lLr70MTpevvsvx60O2/64UMLcPE5zwiSUzbCJ6WyIcn8P7QRyxvyhtVDFCxR2IY507kgpnkA/SyfNzPE4UVsggHXkkAgiYxCiaaDbJKHtQdyn11OpVXeXVjNrgtQ00j2RzvDjnjGAPQ5f6M75Boz10z0Z3hfRHSjvAtNOGak0l11Pr/z3oBlhn7TffZn4N9qUsjYYavYwLEe3j0R4H+eTWZvcxhQPOLRKG6aY73+fndf4t6KCLDizpn3uOArI3WFohTIpP0Ti9lEMuee3RRtjvFa9rDhLnps+K+nzBCz88esXLejzyo6+OrOuZxzRRzjkTQcTZQtepNpBE+wwk27uD7PtDZzkKH6GQToro+Yqe6yGl7PeqvvnjzTADgDjg4HXYLE1PvRHWw57btOc96XTvTjLSU3XSMr6MlI9K8UGf+6a0vvJIcFHzg2D8hpVBL5HHfvjT3+EmRpaEzO6EKISRClfIQnqxsIUoPEvAGviQyfBlIqzLoQ53yMMe+vCHQAyiEP9/aKmtLMuEKEyiC1/IxCUyMQhJlKFc+kJDhtgQACYZoha3yMUuejGHRURKTQCVEA94QIlCgNEQ1jiE/7kxZ2hcIhvbmLOzkLGKDTlMQgzntfzlL2KAzIEfRcjHQn5tkIGM2CANyUgbIDKRgvRjIw35SEDyLyRkRIgZ0ahGNr7xjXFMYxDmSD07IomKeISKSQpZyUAucpJ8bCUgXwnLQ/oRkpHMXy0NJ8s1kfAio5mMBCQAo1A+8ZgqNKYKi2OSzQQnlQQZwACcWSCghMZrQtwlH7Opza9xs5s28KHXYhADGMCgdyMJphOGWcw4IhOZyoQRMztCTXTiUZrURIg1qYD/zSCCs59A/Gc4/flPcdqAnOa0Z0jUOcxNMg5GC4ioRCc6UQVY9KIUzahGJ2oCE5xFodAcDkKOYgADHOCkByipSlfK0paWFKUpdalMZ6pSmNL0pi61KUtPeqxxxiADGTAnQkCKEYZKwKFL3GhGL4pRpTo1oh39aPSgORCRXoGkJkUpTmmq061utatevSlYX3qAnh70p0GFwVCnCpKNZPIKIoirCE7YgLo2wKl2zate95rXjZ6Fqg1h2g0TEtbCGvawiEVsIVPA2BQA5ZcPcespESLXuc6ur0rlq2b56lezAJYhgsViRxJL2tKa9rCLbexjUQmS1iBEmBKIK/XotVnO/1K0trWNKj3Z+lncTOQoMA1ucLkq3OIal7jGTa5WSXtSF7ggkeYUKu94exHXXgG2soWjEHCr14xyV7O6bdFnDeLbhABXucuVKXrRi9z1Fre0zX1uIKOr1un2r4xmPOPsnrqA79rWqX8dbx5He9oCG/jABkgtYy8JkonkV7+N469/98rfAAt4ISZBsIY3bFgFp4DBH5nIMC1gATf617sT1qyFL5ySiSgXp+59r1hjPFzTChe60QWxAxMy4hL/78S3TTFfV8ziqXTkxTOmcXpnquSxIvbG880x4jDpgOE8+IR4FTJmMwoCEIQXc0UWyJGGExoOm/nMMk2tdIlakTEXSP+T+cVyZrVs1412+ctrDTMA3DyRMqP5z2hWc33ZbJG3VpaudZ4zne+qUSKHOcOAjvSGPazjQk8WrnJFdF2zvOjOio/FkJa0qAtM6SlnxKjDdGIQULxp/ro6onn98lEIHdI3X7UKMS6ArgtAAAK0tMko3TWvfb1TYB9A2L3+tXtZJwMZaEADa6ZuUQsE21SLEqJBbvWrJWxXWVeB1qnEUK53nexiAxvZxF6psY9N7nTXdNnIavazo82S8lJWBLPdbnezvehEc9Sju9WzdUeK65iqd90GzynCUevNGyjXuc4FEOsYK908h8TemM43hfndb0b/u5nShubAb33S9gLb5E3/Zng/Hw5xiSOL4vW1uEgmEoEIvHDbc3YqUy06UUcXOdRZdXJihWtgorv0WCWNzWD8gpCa3xznGtW2RneugJ57Vs9Gnoi6a3xao3ed6yxFugGULlqRBOwo7GQht7cMdRT7HNQJmYywlX1uYReA7k22+93NHVyJmWaGITl7FdK+wrX7u+1BfvuFJyL3XeNdyXp/PI0jz3eY+r00gN8ctZ2AVMZtvONsh3W3AS5ePZOZCgdfN8qVvPoDRNyXpKlnyBuizs7Tdt+gP7zo64pn+2L99Kk3dutj3PrXx0b2v9s84VW4UaojfupVX0DvwY1H4D95yV8veYGdy3gnTOD74A+///gnME+pEui16ySm2qHP1OcvNfrTn32t+4z662u/6NgnLffj7v3x+//75WcW1NcQb2V7+sZpdOZUvQdZgAV0oyZpLdACE0ECFEgCIXCBGPh9ELCBHBiAlXYRBQhhnudxUddvCkh6L4F1oqV1DzhqETiBFYiBGTgBHNiBRqB4H3E3+KVqE9VxCBhrKPiBVOWALfhnL5gQF6iBNciBF9CETuiBrLUSOghnPChRPqhoerWAUfhzBFaEkXaECJGENLiEG+iET3iDKVgTIiYBmmaCHIdbODheRLh1J5dkKWeHlgd7Yvh/GNCHfgiFrcJjbHhZoMdq3xWHnzWH71aHw8deeP+IUn63h/7nh3+IhkJ4ESNzBcNkYkJmiFqGiNB0MwlBfEy2cMyFXsaXEHzohxVYgQHoE5m4iT/WiW+YYqCYSqKIEKQYfIxof8mVigixin3YihT4ijURGUdRWcXRTrX1g7QYf3qGcX7mhWZmOJYSGk1IjMQogxRYesf4AMkoV8sIRfqmWc6YYlAVhL5XZNJYf9TIYda4Jth4AdrYitxIAt4oEnUTgga4UVe4UR0VkOrIgA1UN1NIWO+oYV4TgX8Ee3mxWnc0Evt4aVe2XyXYaUolkFpYZAbZNF2YkAa2kC3QkIgBkae0LZo4TOpXeBLlfO5XUTtndZ+2eB/pdTYGdpP/NlCs8wIvoBhLJz2CuHzYFlEu+ZJEGZMSdYvQBHQ2CV84qZA6iSw86ZNld0QIoZISMEdr9I8XCYdXF41kg5AgeVoRmEj5QwM0UGkRKWYnqYZBmZVayZWeuFlKWUW5eAVjWWBl6Uo4gJZq2ZZsSZAXsYZCuWrs11RGuQBUV5d4pIgwlnD4V1rOVUgqoAKXKFpAcTRAeZUq+XTv136JqZg7x5hV5JgztmH3h1iTyUeVeZn6lJmByJmF2XzRx18811+6p1SkyRQIgRqogYlxMUUEd1LoJnnjpmvlRod5124tpUOtaWoWQpgryXzQ92q3GXq6+ZXa0pu+CZyZeF7FWXmT/8ec4nmcw9acOfScgpkVDhZn12aYbYedrwaF68mbUbie3IkaLRWeygl55Nmf4ylsPJWelgmd3dGeDsWS8Zmb82mJaVgkY4GfV+CbU7Cf/7mIy4mc7kZWdSegZUWgl1kVE6GMs2iOT4WRMOIbpPGTFmGaealyX7NgBmobIyqOJfpfWIiOC5CiKmoZLFoRLvqihZVaIQo7kfEA0iRNVuaejWOic5liGmkCxaGFPSqATbBWm7EZGxEadYMbR/oAYxMaYuqOQopYEfh65EROQJWl8ncTX5qkA7CkBuiktThhUTqlA1mlVoqlWbqlVNClAvClkRGmY0qmZWpYZypfaYpWbP/6Fl8aFxEREagBW54Zms4oeif0Az+AO7mjHKiCHZx6I3fCppsRnAFgEEr6AHEBp6FxXv7poTCldzoVYzokqzX2egCiphlAqm0aE48aAJGaAJOafpVqqf6Iew2QqZvKqaFyLZXjrLUjqj3Cq6aKqnGqqgHAqlTgqgG6a8Jlq9pHqzkErsuFqzmgq7zaGb8arMM6mxRVlEYJmhsFI5viKdRCLbXDI9JCKtZRKo36EF86Nn46jdQIcS2XA/tXF5lpBWvFp9wxgAQSGZAaqe06nUPZkkiZmPKqUfQKBPZ6r6aSr9XysXfSr6Tyrw4RsAI7piBpsK+XsHSxsA07Xf8Ksen/dKSp2p5tKJ9WCHoWJZAf8AElUAJFULRFYCPVkT06sj0JFCdyAiFuY7I8grIFAagqO7CG+oUR2AIue7CMsRl8KhA2G7FIeq06S4gbd6wd97MBGbRDa7RH+7RKmyNM+z1AI0DPIbUcQLUEYbVHSqgEC4Fb27XAmBhgS7OrMbYr8aUjN6e4tXu5t1kdVbQ6I0Ac0xzHgbRzYjnHMapZCkw4m6RHcV5OiXCu57KXpxdsKnMAoLiaFxmNK4K314y4GbmSawKUaxxJe7kJkrlPa7kSUh2eC25vKrqjm5qHZbrxZbCpmxeru46t26vfKLEBMBmUun7w+pK3yV8MwAArpKn7/wqy+MqsH3sj6WoRKsuyRah9vda11mu9ZFiDF9iKUHi+6nqkcfG+7pq97re9T9W937usJCu+IUu+HcAj5kuqoDuoAqC+Lci+BOC+7+sE8cuB8+uKDuqw0uur+BsAFGpGxWqshldXSQRPoaREJkw9m2JxhPalAtGqVcChy9lrvTarNGawuva+/xd+F1yMRmC/fvKrH+wBISzCzljCx3TCKJzEQqDCQMDCs+fCAADDMuyfNEwANhxjOFwAOrzD39fDJFAcQNwdpirEvhlXOzthkJt7xdE4n/TG84JCbcw4cPxJK+x7CrURAlG8o1twx3WKSrbFk4Ea9RiDIaCNYqzAFv9Sxh1MoWiMtrRou3U1x/RSx6Akx3FcyZb8P3f8sLylxwDAx8ebXKV7wxCXw05AyIVsgYdMjInMtxbCuBIxoVPQj7UryWvcAB3FeybAy3iaRJTcxJucbycUzG7UyYkbxX8rAEcRGqZbyl1bAzVAoZLIw63cipsCy0Uiy9xpy5KcaHu1y7rcy+P8y5jsxsOsXcWcycLsxFBcESrbzFTwzIB8ugYrzdQcAv8HxhSYzZ+rLYJqa4/cpLbVarYreqInkGlsogYNelE6xrQXun2MvOVJYzTVtYCEz75ZzeKnjRC9zYJaowvNaA2dewiNmwoNybRb0v320IoMzxI9yo24Xhf/jboRo9GowdHh59Ev7TtGtSlADQSWyr/PR9SIJ3WfqQC6pbiRsU8g6TUD2rx4gXxz89NBLdShadRtp9VQh9TvelFLvcFV9QBOnZBQ/aFSfRdUjTRrGMJcjXP+m9Rx3b8ZC3VFKhZi+VVPmVg8xBg/GjJtvX4wubHaW5uHOddFXdc4d9dZh5dh1ZSk1deL8dcgjX4NRcSCfdiGXdiETded/XwdBRRMXSCB+26oGVMwpUPQA7qv80z/YlQgnNlyvdmejZjxqtjuF9pWMNoIUdpkddoyrNprQry0kTmuHTL8KIIXm8s6qrYJmKO06NxfRjFhCZJ7aUkzahBvVZ9ZkdyN/7Pct6xl56jG0N3cXTndF1fdCXndM5PdVXtp3O0V0ilntonbz+fVST3U9k1RjD1Y2Zd/XmU4x9LfpfmW9P1Ub71t+P3ViI14CU7gLFjKFB3gDUfgmjMcJDrHdPqkz92Dbujc4i19AGezfHYFvl2E8ci6KojhNqrhOMrhIe7hGAnizzjiYl3iJ96CKQ69KrjHm0di2eXiQHbfH96VMV6CAqni09bbWeuFO+66DaROQI5v2mXeCzrjRh7dSB6QSg66TJ6XTy7W1ad8R6Xc8GmUPGvEXSnCYa15w+le/Imh/jmgx7LaPe7jll3m333mL5nmas5vbG7jbk5ycH6hVTyedP/eOsMt5qkknUWMsZ/t4Pu91bQ92LZdYbe2E3ldWBMe2Tlk4Q3k6LLN4Jde2w1O6To36Y2W6Uzn2MkLmaalQ6CONFYV5HFMuzJeiHV65Mzd0igIbiNHuvXci32EA34H5bRua/emcZsF41re67we3g79620a7AUn4XdYUsV+7IyONDo4WHoa7uI+F212Sts97nixlgL27SuI7u6uopT93ghx7u9OF+oOWK0xG/W+76YxG0SFG/nE73Sx1p+V768h8Ai/GP4ubQDfBFaV8Lt13Bd2NBBf8XhhRASpRxZPJPE9NxS/8SCfFhi/hRj2FyHP8STfgGYRBSzf8krw8kqABDL/P/M0fwQ2fwRJkPM6v/M5D/MwT/NAjwQ3j/M8X/Q+//JBX/M3X/RGf/RB7/Mz2RKRahKrWMgyePUzWPWrTJ8pL2Bn0fIu//NJL/NDz/Q8f/QxP/ZCv/Rmr/Nor/Zrb/Nt7/ZOD/RQ/6ANEaxUP4kYYPVYf/VePIxbn8HufWFxETtMwARLsARD3/iND/c2zwOSP/mOX/lHAPlHMPmUb/mPr/aRr/k8wPk3//Jdjr6b58Won/qqP37zhOxVdPgFghqJv/iiP/SYD/qhX/s2f/ugr/u77/mZ3/u1T/o8vuTX1X+rn/zKL36t3+1UlRNXwPJQAAVyP/dJ8PbAX/1zj/1j/1/21s/9Se/9c8/Yohh+lKiNfw/4O3z+24iBPjzrVQT90k/9RL/9dd/9bG//Po/52t/24B/0AHFE4JEkBQ0eLHhF4RUADR0+hAhRgICFVyZcnIBBIwYSHT2GABlSJEiMJTFu5Oixo8iORoxUjBhT5kyaNW3epPnggRUrUqQ8eTJQ6EAeRY0ePTpU6VKkTY0uhUrUadOoVY8oUVKxSROcDXVWdOLEJEYIZc2eHZtW7YSzbSF01Mq161y6de3q5OkTaNWpVK0q7Yv0L+DATwcrxRp37teFYdW6RbtW8kXIZuEu3GpX82bODjw7qBha9GjSpU2fRp1a9WrSDRXS/Az6irNn1rVtl6bNkPNu3rA/3wYeXPjw2q51y4ytMDdx5rhl94YePeJrAM2tX8feuvrxmtSzZzcuXXx079/Nnw8e/mZ59MTVj4dvl3rDifPj38ffMEEC+wEC2JepPu72AzC/iAR8CEEDF6TJPgUZhLA3Arnzr8ADKRqQP+4ipA/DBD3kMESvHlCIp8xERFEzxqqo4kScGFPIxRRHVGxGCBkzUS4bd6xpxRZ1vAnGK2ScUUgiebQpIAAh+QQABgAAACwCACYAKgGMAIb//////9jY///Y/9g+/54+/3cX/54X/3f/2P//2Nj/nj7/nhf/dxfY2P/Y2Njntj7OtlbOtjDnthdu54Zu52DAtheotlaotjBuzp5uznduwIbnhm7nhkjnkBfYnhfOkDDAkBfAhm6okFaokDDYdz7YdxdI54ZI52BIzp5IzndIwIZIwGAwzm4X2J4X2Hcmtm4mtkgAtm4AtkhIqJ5IqHcwkIYwkGAAkG4AkEjnYG7nYEjObjC2bibAYG7AYEi2Vs7OSFa2bgC2SACQbgCQSAC2MM62MKiQMM6QMKhuALZIALYmJiYmJgAmAAAAJiYAJgAAACYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI/wABCBxIsKBBAFESKjzIsKHDhwcVLoRIsaLFixEVQoGCsaPHjyApIhiJQGLCkA5NRkHJsqDKljBjStwYs6ZNliRLmqzpwMGSJQR7/rx5USjQgUaJKm2YdGCDBkOXSp2K1OdRgU1ZZgWwlarBrV293tz6NKrYszHBWr15EqHKt3Djyp0LV2BbtErb0t3Lt6/fv4D72l0pk3Dgw4gH412qF7Hjx5AjS1RceLDkyzvdLs5rGLPnz6A712wcWjLlzTZJl17NWrDm1CaDBOHAQYft27hp697Nuzdt3MB19JbYpAlqpQECqKTAvLlz5ieiS59O/cTz68+rX6/OXTr27xS6d/93Hl2GDOLGiaqU/Tv4bd/wfbt/zxv9caLJl4OHLl77/uzUbddfgP+RN+B0Bppnn3oKyRbCgyFssEEPFPbgw4UY2pbDhhxuKOGHG0AYQoUVYpihDi/dR9RTEq3g4goqqKCBBhPUOIEJOOaoo44x9qjCizDKSKONOxZp5JE+xghkjDPaeOOROyb54wo44DDZVBI5CKGEJJp4oYYdcgiihCKSSKGXPtiWooo2sajQkkI6CWWUScLZJJFz5sljnS8yOWSNeuIopYtVXilVQk88IRt78bU3X6OQ1nbbmmzCltB4BTZ3IIKZ8sepgZta12l43Jmn4ESHRpHoorNBOp9tkTb/ihullRZ2KXejkhpqrv6BuimvpZpqKGMKCWGsEB6O+aCZFnqJW5hiKjuimbTW2pJE0ek5KJAr3ClnntsC6S2ec4b74riAQhlDDDfcMCxnCR2LbA5jhjhtl87eBm2yIC5LbWbW2hpFtuDyKe6f5EJprovoPlmuwecinO6R67b7LlE9JcQEE7LxwEO9EjpKX28gl7yByBdKZFbAIGWs0MbfOSlzwjrWuN/MMx9pM3g4y1xkzkbWWJ4MhUax8lgOaMxxEB6XLDKsvpkMMso+qHwVyx+5rHTMPdOc485cd+3wjmBjJ/bEX/sc9ARDF300gwmxKltw8Eld79PC+VYt1h2p/3T22DVPcPPZOgvOM+FrD97zuozHcDFbDcpNd9R2g4g3fHvzfZHfiP9seNhdF6546IkfvnjjjqPaZgMSyWssEEDUK2LJZZqJJpjQwkWT5hS5yTnaD/toJ8KBmmCun99qCzHyCbPAAuqp37Ui68W6DrvsW4JcO74m4h6m7hzxDpHvJiVfsPB9xuk1ksurD7zC7Y+ro/PQPw53FETkr//++7vuv+v8CyD//FeX14iPIapJiHmqxMAGOrBKpjIV9Na1wAdaEIIRlMEEY1DBCz4wgxqcYAc9WDTpwQt/Agzg/1YohBSmkIBvOc0BDZLAKIyQhBiM4AZviEMQ7pBoOGygD/9FCMQg2o8lEulAB/yXP9kM4YlDcKH+WHgsVkExivwroAlnOJAabhB67WoXCdv1xQmG8QZjvEEZwRjGNK4RdRZTHeQSokQmEsGJUJRi/qhoLCvmMYsxNCAXCeLFN7KrjR4koyErhsgLKnKRZ3TjIg95xJa4LFEgAIEU+XgsPQpwhflTyU/CMkOjaE0hQcyhBCeYSgcOEXqtFGIGNxhLBpqHBjR4G0wu+YRMbpKTLfTkAP8XSpOMci2DrMoxVdLKV6Kulqo0Dy2h6czGQRMHt8zl1WoiAAFIJJO+nKIQGEDOcpJzAehMpzrNyc52ulOdcknmQcgnEQPY8574zKc+98n/z376858ADWhAoTeDgs6gkh/p5jfB2b9xvlOdEHWnRB+KznjKsyD0VIhAN8rRjnr0o/kkqEER6hHyKbGOroNoOhXAUgWodJ0TjSk5C3jReVKvniDNqU532lHooeCnKCBpR0x6Uv+9dAEtdelRFyBTmdK0phi9qUZ5StWqWtUAPgWqUD2SkOJI4KsSkJds0NnOpZr1pWVNp0qKA9WGqOQAcI2rXAtA17rqs652zadc98rXveKVrvrsq2D9+tfA7hWEGchAClKAqCdwxqtgFWsQyMrOs1o2nWmtqEnY2taMSGSwB/hrAe5aWL2CdrCiNexp+5pa08oVsYplrKoc25Ju/ypUISftwB6DqdKm+pYBvS1nCUrw1Lba1psmAa0/V6vcfjJ3sMt97mFXCdSgyhElx03iSXebv+D+NqbeZcBwiwvV7CYXus6VLl+jq165sre9OoxBdbf6EYmAVQJyC0JSL3vZpLL0qOTtrFs+u9eqrveq6XVvTiloqsQmlr4YsS9Y87tf/p7Vv0pVaYA7+9YCU/XACN4niD/KYPM4OAMQ3pxC7suq7loYpuZ8sWYz19YOq1a6ooXrjZ+b4wPsmLk91icIF7vYFFtEwl9tMRFkjNnKynjDNT7vj1cbZNfi+K86tjKPsezjfA6ZyEauiHZRKi/Kfnei4TXneAMpYIHkx/8k+FSvPRUM0vZ6mJ925mtWi3xdmIx5iSll6pnRHFF3rpnGF30zTucsXUZnuc55frSIIx3XPct2i1pJWhQ29lUyC2Gs/fUvk9V5aIXoEqqndIITOErnD8c1xO81rDRj8IIXYAADuEzIqUPiMk5LwNOgtiyGR53OUut6m51N9ao32mqeNhvWcX61aWdd61vn2mjIDslTiOq/cxZ60OU0KzmHa+w+X/QpI1EJtNe90Ra4uwUPFKhIC4roi2xbqp42lrdhDG7gLnXc5IZyMtGtk0Wz++D8fDe8HShv1Bn0oAAT2Fev+ETL9jvcSy03pjkMZ4R7XJ/ubpc9QyNDJK5YAhT/H4LFL+7vo2qcMG3uYsc/TnMDhPwGIwdNyT3SayYocX8e+6+gWY5xfquZuMbMNqo1nRBVRzvS77Vz1PvqAheU0DPH3DVGev5z/QVdqUSP8bfZWW6ty1PZT8/z1OWc4MFW/eqYybrSO+Ky4oRzt79Nc7/LPveLKpvSXcYzpddO9apb3UqgkfsuNW13TYoz72O/ON9jjhWmR0HVgCf8czW/V8MfPjSKt1QUJo7F/IF75b8VeE3VXfPW51wiI4i97D9A+9pH4PYRMBZd5jh6lJeeCKc/65lVf1HWu77mKpH97GtPe9znXgi7jwn5wimvzKKV5QBmM+WNf3yEu1sizY8A/wTGT/7xW+D8Frh9MWcSvptM3/HVd/JRiZ79ehd/5t0/+PcVEv7ylx/96RcB66cR7ZcWmuZrFCZqxAZRwwZRk0d5aPdPkmZggWdVWQZXVac0zud8/kd+tDeAZocSPZdkctOAC7hSCkhqSGc1lMcVlud0EliBFBhiF3gAGbhpTLCBuNeB4/eBRMCCWHJyT7Q/wSdu30V88sR9+bdu6yIR/weAFiACUigCyjeAGzcaQvh7RfhvR6h9MaeESwhrTagQTwiAU0iFsmeFMIcxB8gEJMgq6iR0R2WCo1ZqGxGCgxSBAjWBrkaDB1A0G6ODOjh+zpc/d9h3i6c0b7gocZhhL/9Fh0xmh1CAh1ykhwHFh84mg64GiDkoiBwIAYVIBIeIFglxX0Z1gkNXdJeFhMkkERuDVz/maKhVWvjUWoK3ZXQFQhLhibwYAQtCFaUYWYF2gtZnWaw4SK7IBLCoZV1GZbR4T7Y4abhYALqoEL3oib9oE4rWe4sYbKhoZqpYfxEnYNuYKHAVjbKoXnhFAAQwZUBWWnBlHvEoLJGxczCxjSwmN99odC23VMd4QOX4BOf4jOl4ZXTFju7ojMs4j/N4KpBhj9glAKcETvB3LMUoYxLFUu30gAL2FJYYhlS1QTZgA46haqQUkRPJUEQQf2JHbBmpABu5gqaGiFzkkS+4bCD/WVUiSZKIYZLIVBP3tlD5JgSo129H5QEe8HIxF5T4l5M7xUY1UANbJT235X7bJpSAVmbCh30vhZRK2WZMaXBOqVNQKZXmRkNrWJVBGIzdOFlc2JKXtW/+6IVtZmPMqJB1xYd2VmVp15ANhmJn6VmB6Wcn15ZGCJcrZ4x0KWB22ZfviFd62V58eU98BVsQZn8mx5ZhVUVuaVaQuIAs9Y/AOI4UAYax6GrPBmkgdGthdhZItpl91JlL9ZnEFpqLeRyY6RJNKY3Slomp+VF+aR6sOZh4EZZRkElDKZd6d2ZH6QFqeIV40Rbd5CYqJpZjSZaM0y70RpyLYZzImZUW2Y/L//ldzfmca3gf0ikA1Hlku3mdINU42glx0HkTyREUPXGfKZmc4jl2QhdT5FYCAPefw2WerUEXP3FsUfE23YSfPTEAA5AoECqQ6HWLatd2UGcADVRtGPATlEifAWCfDGp539lt+8lv/TlR/xmgAkqgBSoXB4ptCYpsC8qgDhqh5jihvCl1FlqhGWprG8qhtYKfybExxaFEhvmIKYiKLDWgRPByLdpYorQEowgAWoefDqpqWIqT7slqFchIVXJrHEqTaCGkAUCkTWCk+KWPSFph37ikJZA/TvqkiRKlU1ql93mlWaqlW7qHXXpIX/qjHYofyTGoI5imcLiPLskA/rMDO/8QK7oBNa+SN466Gykzk3TXhpBZgZE2mc8FQj1Wg34JAzBwbcfGJoNKqG14pIjKZOS0qI06qZD6KpPKG5VaqluHqXmpqXnGqczlqVwGqgcQQaJKqth2HwmQAKdKSApxd/rDnE0GcCfqnwDqTvISqbZxJvlira9yIdhqIkZmXglxoQlZeAdWJa/nGRDpofUJAMearDKXEMxqeuT5rOJVAtGKotPaTtVqrd16Ito6H9zaLN7KnQUBrlEgrnfpdi5QrjhwrpiRrto4qA5xrBSbANpFomHXj952dOA4XCRAAkyaP/+6rT7Qr18ysnkjIZXUrgFQsadqnQXJdhQqV573doj/R3KCJBXdxBAVe6wX6zoZK5cbK1wl0LEl8LEhSwQo6x4BezsoSxsqG5gs67KDCrMGkHk7ioE1C3fomrNLsbMWcVy3Ba+Oh3cPFbROdnT/uT9LCya20bTZirJRC51US7VWC1BYK3hcaxoyxyZii1xk21ASBY5oa7Rrqz9tqwMb8rYlK7D+KrcbsLIUmxx2O1UelbeTtrf12LfWImH5hU60OWqhq06swqiVEzLxcbom0x65aRAbkRB7agAbMbtQcI0bKBvgsztY47lqOroy5rvoVLo7oLqNorpOIymtWxCvGwWxS7sbYbvOh7tvQbuaI2GSxV/Aa2FJxUn51b3dy73e/ys3CbE7umsRc8q8YShXCGkATgiKO0h+nigbzluA4mO9nIm9SXqC28tH4du/QQC+/hsE4xs+5VsR5wuS6tuO7EuG7nt75Re/QTC/SXhyn8uA+QuaFyxZAbzBcgPA3XslBVyalnuJmpiJsriLgsiD5Kd7pFm9FKymjcimSprBnMnBNvy//Bu+IEy/Igy7zFbCOwWsKDyIKgwBLNyaSjESApETddcEmVTBRbmF6uSV5AanbypOoEQEQyhMDZXFW2yIUOCTgeoyMOh67mZPCmezx1aG6Kd8VfiDxcoySgwATMx4TgwCULyVF9ech5u0VJQ/X8zFK8lCgPx7GyHGYloVTf+npzR3xjb3bmqMbWx8fm6chnAcqOgZBRvxAA+Qx0yWvZbVMR7DA3I4wzKsmOdbXyO8hNWYEL1IiLgXe1B6ngc0wJzsyb97wUwmyl+HqKCsVrM1n261yvnXylHwyg0cAbIczLQcMGCrrAlRARUQQOSkkTJ1mEb5ltk8f4O2VfdmnCC5LjenuYCxns4sAGgZzdPMP9UMk9eszVIceYOGzalHsN98lcTseuLcAmJ0s49hzrX8wleUVHsMz/Ns0M7KzTHZmuQTzhMkGenWzHzDuwPdUgWt0Nt8fRet0WQnkx/R0GG4QRCtE+KTKL72VbHpjeC4qqnI0oiJiu3UmtvIV+v/qMCOOY3s+FogdB4Eu3PCzCYm7YbCeKj85tLhCNNHTYzsJNPKoRA0XVfre9OPWQA5HVc7zdM/zbnKWkoOcIicDGyyib+njMFjXZu6fFZrhsmKfHmMHF1+GEFuk8iVB4Ti0xNe/QBg/clnrddlLbp7nXFIp9ZzzdZc+tamEtdFYXmCvRlYKbgMYM3jyY8bTbhcKdm+hcQDdrA4OrONtk8MdnUtCBGN/XiP7c6RTa/0J8+TnYrD19OC2VycB9shxUFAhNnIqBDSLM3UXNpNRc8HjdHxbNkx1Zpji74O3TgDHNoPIRG5vc5EyNvvDNy/zdHBjdqX7doEUdxOWT+azMPK/z3YGyPNzKpv0W3d4xnPhavaHW2rl9pYOsrZ6jVriP3dX9GG4l22g9zb8nze003Zq91UaS3XBcFL752j8BVC803frju7nIzSw6i9f/1ivyxsET6XWY1A+Zxehh1Btp1MtNvgsHksfN1SvlzhYk3io4bZdztpG06PF95ZxU2Rjq2crF3Z1v3f8nfjXfji6azZghXbp8VP69JAHT5DMa6SZkvj6S3c/V3j/N1UKu7Um52wm+fZMUDk2M1xvEvUepzUo3aRifrSRiiOPJ7Z4aqJe8ll42rMZT7BW86IcZnjSi3mXy7nW0nmEp0SUkbls5ipa55ByTtDPhsFg/6khn7oEv+hlg7xZpaB6IEBsTU16IXu6JTeGoreEIxu5pXOF5DOcY2+6aDetVldQ6FuUW0e0J9e6qruGJ1OGau+F61+f9D86rTuF53uJhFd63AB0C0oPbr+67DutQaB6wUH7BLB66ENF0mQBErQ7EpQBNAe7dI+7dH+A9Z+7diO7dS+7dOe7d5+7dwe7kXw7d8u7tIe6JregdB7jSq87tKL7m5uEsvu7M9u7tRO7t5u7/eO79qu79LO7/1u7+iuEuq+7rzY7tD77i2s4I1O70dwBEgQ8RJvBBRf8RZP7Q+f8RoP8RIf8Rb/8UaA8Ruv8R3v8SBf8SI/8g9f8kgA8lGeELHHfDL/b3u8eAE2f/PKN/Mzr4NHnOcM/65R4PAc3/Enj/LTrvIZz/JFT/Epr/JKv/RNP/JPb/EvHwUxr/PM14s3j/PLh/Xh53w9//MPsbzLvuz7DvA/4O//jvZpr/bQzvZs7+9Vv+5FDL8G34seQ71i3xBkX/ZnD/Bu//ZxH/hwj/Zyn+WzTvd1n8x3r4N5P7t7v9wKYfbhvvQhP+7Z7u+WL/gBb+6bj/mdL+5Uv/B6PsSNf/rrDu/JPvlJIPpQD/rgru+fn++y//q0b++jb2Qqgfq8D72q/4XGHvwSkemi3Rm/zlmnzpjCv/zEL/mp/urI7/P0TerLr+rNzxBqKfyxrtzUdV/9oX79B5H9wb/9371FyR/5XjvqtHz+hImW6K+b7v/+XLX+0q/V9o8a5l//yn1Kiy3/LkjXAAFA4ECCAx04iJIwypIlBR0+hBhRYsGDChc2nJhR40aOHSVWVMjQ40iSJU1qBJlQJMeUF0++pIgwJEaYNUkGBAAh+QQABgAAACwAACYALAGMAIb//////9jY///Y/9g+/54+/3cX/54X/3f/2P//2Nj/nj7/nhf/dxfY2P/Y2NjOtlbntj7OtjDnthdu54Zu52DAtheotlaotjBuznfnhm7nhkjnkBfYnj7YnhfOkFbOkDDYdxfAhm6okDDAkBduqJ5I54ZI52BIzp5IzndIwGAwzm4X2J4X2HcwtoYmtm4wtmAAtm4AtkhIqJ5IqHcmkEgAkG4AkEjnYG7nYEjObjC2bibAYG7AYEi2Vs62VqjOSDC2bgC2SACQbiaQbgCQSCaQSAC2MM62MKiQMM6QMKgmJiYmJgBuALZuAJBIALZIAJAmAAAAJiYAJgAAACYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI/wABCBxIsKDBglQSKjzIsKHDhwcVLoRIsaLFixElUsHIsaPHjxg1bgT5UCTJkwg1olzJ0iTLlzBbqoSZ0GDNmCFHEryJs2dDngOB+hxKVKBQAEdPHk1aNKVNnU2HLoUatarMpz2nTBEgQKTXr2DDigXLlanVkw0aJESAYKzbt3Djyp0LN63Zj1rL0t27V+9ZnHapsOVLuLDhwxoDx7yJuLFXo1T/XkXquLLlyyPvemSMuTFkyTg5dx5NOu5nmhqBAMnAurVr1xo04JhNO7Zt269z644tUStoqRonCJ9Qorjx4sIpKF/OfLjz58ePJ2dO/bl14tGRT6Be/brz7MdjxP9w2VOkat27ZdOeffs2+vcZeCv0/bt88OHgS0znrtz7d/D78ecffgBux19/A2KXn3jk+RRAABIFEUR7FFZ423oY4mDhhho0WN9iVEABRXEmlGjiiSceeCCKLKKoIn8txmjCi9zJiKINNkhU1IMRTsjhjxmu92OFHn74UkIikmijiTRSt6SLTS73ZIpRKjelCTjq2FSPRRSxww48hClmkGTSdsOZaH4p5phBFmnkShKlIOeccsaYn5L5xUgnnXaCp+eedbaYZ4s4ZjlRUVx6CeaaPJRZJpppLrommW6+qZRCgAbK4p0llDgoi5mm0Gd2fwI6anQxFprjoT4lkECPEmb/COmXajLqKJmz0hpmpZaCFGcKSp4YqqYmcmpspygOKyqKnII67KbRwQBDDTVoOZSrsAYha6S1TnrrtmfSuiivvW6GKbDICvsss8fe6Wyo0H5qorLxGicttdYSJVGXXX4LbqSMNurvbOSWe5FIpx5X6p4JG7cwn4L62SK8ERcnrbT5ApcQv0UMvB6k4UrK5sAFG1wRwhWjOnGmDQebLMspK7yyqSlfDEPGPkmkmmo66MBabBlaCF9uQGN4W8kmQySSdAYemKCC0QXI3dP5Sd3dgFUbWKJ4XI/HqsZU7AxEzz+rJ2SFQ79W9Nny4Zx0ThIx/SLVBc6dYNZ2Y103BVt3/+21ZijpLDYQOeSQ9oVGo/1ebKyF9fbBXnnHqdUI6o23gHffSTkFT6uggs0Yf52zQoMTbvjQiLPdHnyMZ+D44ydHft3kTV/tH+1OZ3751Al6DvrNotuXkISlF288EBImr3wQxx//1WmwMySaQr/b7Pf1flevPQzYdx/D9tx/Dz7o3mMPfkL0IaoQ8c23v/zy7Rf/PGXR/5SZRuCXf/345Ovfdf7i45+0/Pe/7aFvCupLyAY28D6xDeGBQ+CYBPn1vgbuDIIRlOD8APe26SVEgNOiVg1URUIbUAuE9xJhCVV1QhSKcIQrxFELQYiv4KFGgQyE3wUhOMEJVlCHqsHgBP83GJn6nUYkNFRhDE1YAxSGkFpLZKITXxjFGQqwhhz8iAMckJAlLGGBFoxf6X6ovPh1SSRKUMIW02jEgqQljVuUiBSksD8nXsx/dryj/vI4wD1WzwUumMEM2OiTOFLBi2AEohjFRsbkmbEIaFSjAwjZRoG8UZJypGP2+IhHTvoxj538HSAFSUl9KWQEqBwBxyTEgFa6spULiKUsZxnLV9rylrasJQNeV8mMiMQAwAymMIdJzGIa85jITKYyl7lMK57gmSdwm0wSkkpVUjAIuGQALbe5gGx605W65GUvU/JLZprznOhMpzqF6UxoSvNSCZGABCpQgQl+85bczKc+Xzn/v3HaTyLrDKhAB5rOEpLgoCR4Z+AUIk962vOer9SnRGnJz8f4858KIahGN8pRYBoUoQqFJxXkKc/3TfSkssTnRPt50adI5AAwjalMZxrTAtj0psSkqU51elOcDnOnQK1pTwuQU6BeDwMYQAEKkAQFsJFUAiZF6UlVKlGWtnQnGgnqTodK1J9qdatDLepXacpVser0qEldaoiaasp4kpR9qpGoAuZKV6medK5WvSpkADpQmm7UrxoFrDF/B81o2hBODH0r83YmV7rO1a4TxatF9YpVvgpUsH2d6V81e0zCuvOwC6VmKh9K1ZRC9LThnCxlsaURYMr0smPdKTJjK9tj/waVBSwooVKVGlKSSKSapM0lRU8L0dQizYis5etrA0pbnc62uZw15m1zS8LdqjWLFzGkFxtagQd2iZXEFW4+IQoCEESSsgMxZEKiEIWOuve95lzBCtopyISU8iXaXQJ3vVsE8IYXnPu8Z3nPi14AqJcK7IWvghdMTPnSdwb2VcJQeJTYBQa3uMP9b0WPWz+9vHSssIVuTJ8rYpiS+AAlFGR9QQsSCrvVwhL87zY1bMu8ttTDColtiEt8YhGfOMUq7q253CrP0jXWsZBtrI2vWs4dd3S5mzVxMj37zAM6laRG1qdjH5vkfEqWw0ZsMnNHzFEoB5bMyKSyYdM3OtFeWP+8pqWxSlu5ZH8mN8fRLWaJ0aznPR9AmTD9nWuBilvd7hbMkHNzjL05YznPeZeq1eudE4JZs/rYtn4G9AEEbYDpGpq3M1mJi0cqgSxLtbRdjmWdL1rOPZfVqyJ+tTCbKx6YYobCLxl1kQcHWVSnetX+bHWJZR1MV4cV1mOt9QFuDaEi+lYhiVSeLh0d0Qx7E9jjFHOPaavpS/94VZiB3jSpEO3kTZvasLR2NrHdS21j2tvvhm63UQzuy4gbsQmBAARMnepYblkBkGV3Jd2dzkqP2cznDF246XdDKuib3/3+d8AjTVmCo9Pg68T4MhVub4aDSNHK83WX/yvwNlqcwSj/L6ZIRMDyln/g5TCPgMwjIKGxCI8KqPxu8kSeZJJTXK8nT7nQgbnylrMc5jGfec3FcvNdi22WEu83LaOu6p8zmQpa0cqs/+xeKT+Z68qcY0IeQPaym33maKd5EEr+EYk4nbGypLrU/b3lWbK9fgfUerHBXma+b5aZYqeC2Qf/gLQrfe1WF3Wz3fpmDM8S3Xd/HI4pDeJ4w9vS8h6mRIx+dKR7/uVnDLWDFk/qxt+z0Y6O/NsmTwUdWz7z0s205hXCeRF8/vOhF/Kz871vXs99AXI/qeofF3RmIjyzXlcngxQic8KT3fAyX7ruRfpw3889+CtNPKtbi3y/d1+gy09I//OdD321I/rZIiqpI4HweDjPvbQiEVGBg8J9Y/cU87El9qBju3wvlv//5sdiqJF+ULV+7Vdtv9dNcBZ/bDV/whZrx7Z1EHh/yPZV/bcEAFh+0udsIPJUEKdu2pSACkhn2hds9adVXJV8Keh9E3hTybd/MXU9EpGB0Hd+vkJqbxdXAYaAv7dhoodeDwhUKyhMQ1iBY1WEEhiDfjODNJh2Nth2CkFPqPQ+6IZ64TV8JsN6MPhV29ZcXahThWYDMNU1iIFrbUUFUjgCVEhtVkhcWGgwWthp3PZ6XkiHYEhdY8g1ZdhsCYRzo7VovoZuPFh1T9hBWVV5X8iFySRiBSQtLf/QAoZxb6FxSn/IMdnUhmxIS29oMiLheomoVfPGf1xjM48YiR7XZjhYatY3dXUngv+2iQZTfK8XZXzGTL8jHi/wAro3FX3ogasIda2YgK9YgtnGfQWXZzv2ghvXP7m4i5GBXRjxIPnli09nV4OYagOmEfd1UdLIRQoxRzDVUwRAAPh3hDc1juX4VeJIjnKYh12zYtvIEAcWjyzRjV2kX1j2ixN1jV2WjRJBj71kj98oBeF4juyYhM21jumIggYJg9cDjxJGEfMYkVeWg+y3gwAmgrIEi0fygxTRiSwIXUi4dwk5VMpIU2g1fb/hdvlYjePlfiLIkeMGjXuFZwsJVj3/dZIiaZIhKVMpKYCWwpLq55JaFoy/pxoyeSkGMUeJZpMH531Ohk6epZKgIZQFSJReZpRzh5TEGBVHwZQWAZJRSYvpNJVAuZKUmHOAiEsSJYgM8ECl4RiSaBBsMRjGOHRC90LUIgMyQJWS8VuVyC/f1JaCCJdxiRhzWRB12RZ3iZcop5c1wJd+WZVRSE8VsIY8eIlxBmeaCV6HaYrQKIuOuVFmSZN/WZn0hJkZOYKcyZabWW2e+ZmEkZjS05ijqWClyYFvMo2qyDM6gGSuCHBFyWXv8wM/IDRp0xprUxuKgx67ohAA2RCGlGB9poxj2Vmgs21dM0oQBp0UaTC8KTY9/wOcwiicWUmcy2OcyJmc8WE2zEkh8PGcEcYR09le1QmVT6lMnBZ7Psk13PmP3xkTWzSgBDqgIiIi5SYh5+aW6XZL5fWgD/pKyuMxONAtI+Mva4IeaRSdBDoAA8AVICoA7MVex7eFPDZM8gVTuLWiK4ojuLUXaRRhG7qhAhGdQ1GgOOoABwoFCRoEC8qgPwqhECqhyUOhFhomFJqhujGjDtGhHxqiIjqiJdqOsidMKXoALMqiLsoCMKoEMjqjEWmjZ0GgD+IqO2qRGjlyuDShGjIk7TEwHKKkrMGkEjmgD/IgIxoFBTmONrVcxsanBeCnWJqlhmIYMUoFdCqmRUGmAf9gpgeKpmnaa2tapG3qprYBpxsipxlApxDBqHgqpQdgU4AqqBA4qmSmooRab4RxqIkaoL/hpICpmpr5kujWAR1QXhzAAUIgBERABOISMLMBMmiSGyFQrCEgLkcqMLOhpJx6EIuZFgTKFXl6m8akparKFzPKZoraFLBKibLqmrRKbbaKq7rKq76qK7aCA8J6JsRqrMgqMkhKG8xKow3xrA0QrVFKndQ6TNaKGNmKQAOxrYtqpwGwowv0gZE6VbakPOppqZfqL0MSMGDqqvJIsHMEjqFaAOM4jqS6kxtLAB2bpSzgRSSLgf/3ckaXe97ZrEbCqAa7AQibsIRJpBLSsA7/656OErGMMrEVwagXS5AZ+7EdW5JCe6oxJbIl638n+wEpC0naCKaWQqCucmA9imEM6krl9Url1UNc218VpHPK40PJ07X80jNd0qpNOqAe6qE/64n3eWki+6K0Z3u3h7Kc1zM8mzRSmwBUm0Mhd3qs6ZZZi7UgQLZi+z5gO7YSFLaGa7ZFgLbSqbZr27aI+LaZF7dcOrd1a7dGh7dQ+zhpAa0DylQ9OrNyJlFC+qCrREZdwl+Gu7isWwSuK0FacRPbSqDTuq/BJF/yxaI76gEe4HxlZwEW0LRf+jahe6+ju1ali5E0hrqpW7jX9EOtm0Gvu7rUK7vWS7tTYLsUexC4/zuiuru7vOu7Bwq8wkt2xGu8iEqvWSgAe0u6fmtu3FRtV5tNW1sE+Uu22cu412u4XElI0Tm1kku5n6iI/DmoLEoDNLCjL1d+nNtyniuwksEV8cu886ug9Qtg94tL+bu/Xdu/ivu/ZBvAYfq9AkHAW8S2F2udJHmiCSyyDOzAHwDBTHu3OsCy0UOgXkSAMSuzUvXDQLxNEDpHOpy2W8Rec2SiQSWqGztoTJxsMaAqJduEEWB0Ruy+OzygPQwFkDrEXSbEYCxLRSwFRxy5SRwFS0yl6qixTyyHUWyBU1woVdyEWGzGWlw/OBqry2O1HRyCfwzIggihc3XGBqHCDsDCGP97wKBYTFcahmFYqHLBqicMO3vsrX0MuIH8o27JyRpGyApgyAWByIoMtIwcVMb0yNQVydf6FpRcoyjcKzxMsm83nnUVnOT5e9gXcUYJoaJcsWlMovj5XjvVNaqyql46EhQMGrO8Xb05Nr95y+WZy9enlVInd76cx3UazHo6zF13VlxzzNiazLBsycuLQ80brs/rvBpmuutMxA/6y+A7oHnqwinnYDCkKvK8ReVsYA7Qz29DoBKxQOm8wY7mzu3MzjLGTdm8zP7MzfaMcvhcQvv8zwBASPx80bFcH4zaxdQId8B4ZNKsy9bMy9SsT6AszwSBr7m7rzKlKoBU0Vt0SSr//aoE69EtCdJxZ57ctMup5tNdBtS0lNLajMQOIK3iq7svXSgxXdQFQaA07dSGSGQF+LfploA8p6b8mGo8x1QeQWEYq39sTFti3Z/iIcnzFztUrZoamdU9B5P91tVr9dXNFtYR+MIlSYFJaMz1ltYlkVgOtZaDCYIHTdina9g+Z5qV1XrIaLlua0wlNJlX51aBbYmohdgJfYCCiIk0Jtk1qXEIOYfIFNln6ddWKZ7RzGXTPNLVLNKqTdJZB7BDxthFRcz4KYOlXWCnvTO2/NrVfNK87No8Xc2xfYOUV9vfbEy4rdiTnYqlA9w/XdLRDd1BLd2eTRnHbYS0mHzLrZt+/12TH60a1J1kQg1Z5W1XPn3dH4Z528133f3d83yPvtgzPaOR5y1V941Svs2Kc5WNDi0QW6QV+grHyT1l4WMo/31RvLlr9K0D9i3d1T3e5j3c/K0A/r3RkSvg9gnFBZ5mB74qCd5SIlG1IYjQxKWw76zQl11VHqk0trmvpH3dJqcRJI7ima3ijofjgMvifimaQhfjuW2CNSmbRE7ktOkU2F3kdHHkQHc/Sv7kccnk9DfkUP4WUt5GrsJak1blXO4YrOUQIZoQrNflr8Pcb5Plr0IFW07mbM4XX94QYU4FY97mLmHmRsRmdJ7nckEfbOYQHqTnM2HnsIPngF7oYcHnsv/911Ru6PcD34tOBU7gBE/wBE3QBEdw6Zh+6UZgBD3Q6Z6+6aAe6qKe6aR+BJvu6Z8u6qq+6aWe6aeO6j2w6qve6pj+6j7gAxIhfxYxanP0wFb868COdhso42HmFZE+6ZVO66+O6rKu6rSu6ZwO680+6s++7Kk+7axe7dF+67negBTB61Lg68E+7k047EGu2wox6ZEe6kjQ7u7+7kkQ7/L+7KYu6u9+70gg7/Ou7eyO7+6u7/FO76ru7+6u3pq7ueIOfRew8AxvdAif8NGHeIJecen+BOsO6gTf7gCfBAJv7xm/8R3f7wQP8vyO8Rlv8AnReQgPgAzf8C738Ia3gY7//u0BUJORHun4TvLKbvIZn+8AH/JG0PMa//MlT/Aif+8oTwW19/A1/H8LX3sq//AqO/MO8SA2f/M5T/Q7v+lC7/P6DvRdr/OtfvTvTvYFf+6LvfQw7/QXAPV0y/RTT/Wd6o1awQRM0PVGj+147+/YHvR7f+99H/ZJAKDZ5Y2bB/Wfl74PQLyMX7xu//Yw93xXLAKEL/cPYUh1f/d/X/Z6v/nuHvie3+6g3/PxXvk9a/hzq/ZIp/iNv76Pn/iFN/mmb/kuxei2j+ix8+h0fuWObvu+j3UA2+f2o/ttzvsz/+e/X/yn6OdObujG/93In/xkzvvRv/vLT/v+TEgWPEkYgo79iokAa/Sd4e8QoktIbDH+FQy/3G9JyhviV4X+2+/+M3/+659e9c8Q5R+R9C//HxH/EZn/AAFA4ECCBQ0eRJhQ4UKGDQE4cEBFIhUlShxexJhR48aDAQJAnEjR4kWQEytyRJmwpMSTKV2+fLlSJEyaNW16lNnSYc6RNjny9Bk0YUAAIfkEAAYAAAAsAAAoACwBigCG///////Y2P//2P/YPv+ePv93F/+eF/93/9j//9jY/54+/54X/3cX2Nj/2NjYzrZW57Y+zrYw57YXbueGbudgwLYXqLZWqLYwbs6ebs53bsCG54Zu54ZI55AXzpAw2HcXwIZuqJBWqJAwwJAXbqieSOeGSOdgSM6eSM53SMCGSMBgF9ieF9h3MLaGJrZuALZuALZISKh3MKhIMJBgAJBuAJBI52Bu52BIzm5Wtm4mwGBuwGBItlbOzkgwtm4AtkgAkG4AkEgAtjDOkDDOkDCoJiYmJiYAbgC2SAC2JgAAACYmACYAAAAmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACP8AAQgcSLCgQQANGjRpQhABgoUHI0qcSBGAAAEQCzJhUrGjx48gBSbMSJBkyJMoU6qMeNHkSIYrC75s+BBmTJUtbQ7ceLNnzJkFTfocShQnRp1AfTpwUKTI0oVQo0qdSrWq1atRmy5tWrRrx4RaHWAdS7as2bNo0y4My3XoVqdi1cpNy7aI17sSwcKdy7ev379Q63ZdskQg4MNSCQs0YgSv44MZEUueTDmj4qKXKwO+zPix54GRNYsejVbgZaJPoTL24YOD69ewb8ieTVs27Nu4b9e+sWNHVrufg6deSNiEcRMUkitfzlx5iRLHo0tvTp259OvHq2ungB178+g1aiz/TJKkbdfhTVa3zu1692728F/v7v07uPC4xJdE3179eff9/H33H4ABLjcggcqBJ14T5JnnVVRAAAECCDrosMGFGE44YYUccnhhb7LZIOKIImKYoYYdTmXfigBE9dxzKcQoowo0qhCjBhpMoOMEL/boI4wyxlijjSnguCOPPyYZpJA13pjjjkkqueSQ4UUVHIQSUmihiRtoqGWHFX64Q4gkjshllyhyqCKLV0LV45IpDOnkkVH+CKecRT6pY50+3tlknnTy+aKfNFYJ1YpRBaFoEBX25uiYN5RpJpdegqnDoyBGOqJsa7LpWVSEEmkklIICGSSeo+5ZagmhzklqqaHS/0gDDYYKhVeiizaKKZmSnlkpmJhCSiKnUnn6GahT/pkqkrAmS6OrqjZ7qrJ6MitorCrMWqtOdwUQQFQ/hPtDfLj1Rq5u7tn2WlTkGeuYt1EVyN2BCAZIb7383ZtdgTD0C4OVj8ELlbjjnvuauQa3l+4NsLGbhLt4CbyQvPoaJ29yFSN3ccby+vvvocdCxVoOOVyoMG3snakyhifPhltUp0Fc1FTJHWnzqz7quN3NN0eps3Y82+zzBDsHPcELL/S7EE8hLzRyyRu0rC5uK68sNcO3wVyYzF3RTIHROPf4c3VgR5sz0UCXPXTRQSOtdBNMfwrVoosGS5ukJVL6JYd2z/9GYqdcDzUVtsuaHSXh1Rou5bRDFm7t4c6qEF54swIs90J0K9o3r2X6ureuj949IuCB9zR45DQ6Lu2MQ6qg+rWou57444uzXujklYN8eRN0k9xDDyR2uPnCuwXPt6NXlX6StxJL5Z90rbd+HZ/XRT/k9HVWbz2N2Ed5nQwyTD655Y/hqqjvwI8o/K7Eu2c86L5ZpXxIzH9L1fPRbc+9dNRDr3/3SdLe9gD4o++FT3wLshVq4sIYgjlQXKyJoAQnSMEHPpCCippKU/QyP4+8BT2E6RfSRkjCEpLQYyhEoQlXyMIWpvCFMGihC2GIQkM56C6paaAFCUbBHvZwhzycYAb/pbLBBtywgxH5IH6aEMIYynCFNFThE6dowih6jIoltKK/bAic3UlAAkD8gQ8rGEYLjtEHVTEMt5AokdBERYtwjKMc50jHOr6QfHeJyhfDeEYJltGMY0xji9bIRsjAZCp2TKQiF8nIO+rOKwlIQFQ60IEHZi4IrCHYJTeZuT+Ga4hTyUkhJxLJhZRSKiJcIQJXycoUspCVsJycK1UZS1jO0oSrjEEMFDiUUy6EkpbMXCbFxcliBsGTPwClVEQ5yoic0pdQSSUua9lKKU6Tmgi8ZQmxuUptkjCXuyTkzKBCSUoqimAMSCcDFsDOdqpTne105zvnSU96Jq+ZHanKAfbJ/89+7tMAAA2oQAHqz4Ia9J8DTehBF8rPhCqUof5M4QkmegI8jvOX5TynuN4ZT3bSs6MLqKdI63lPfFJEnxB16EAhulCVCpSlB3VpQGHKT4lS1KJE0eMXJXDJkdYTpD4NKgMEaVKPTOWlNPWnTAma1H4u1QBNdepS+wlOXeJUcFDZKU8zJ1SOdrSrIyVqUSty1JlGFaEyPStaXarWAzyVqgjUpVUfucCFMOaLwBRjBEEKUgX49a98DaxgP/ABDXZxrBJBjxKU8FSmrrWxU20oZBsr1cmalYQucMFE53pEpTDQCHitpF5ZI9h2/hWwpU0tOwlrWMRSRLGMpaxkLZvW2f/SVqWVpe0+MavZE3D2sF3LqgQgAAEKqla1p/XrcRcgVtdGpKy3fWhuozvZglL3oSnEgHYxcFWf6JS4xl2uYJOrgOU217kGge51HWvb9b5Vqe5lana3213TCXePDhTvAsirX5CeF70lkcp0r2vd+EIVvvEtMEDnq9363kSn+CWYfvnb33j+F8BqjMqAqatg93Z4vR1mMHfp6pa4EKYCFRjBCOgWLrCWFqzvZC0RgYthAMDWwDjOMY5NuNlwdrYnqTlxile8qBZ39cUwTqeM61NjgtxYx1COsmV57Fsf0zin95UABSlc4b4m179UaXJ6obIR9up4wwZ+7IHVPOUSZuD/zRlwcEwgrOUJcrnL8bwzOy+M4aiUec1uzTGaExxopLJ5siaEc5xJ7BOH6DSvEoxnkj8qWHouuVhiDnBUpMzpTid0BSsQ36xIQIKJyjkljhYupPcqz0nDs9LzvPSpEateT9sayqAWNQ1IbWpGY3UhKn6gV5Hs6tLyGcC1vrWyEzorbdUAslTu9axPEpVgO3DYsC62YI+N3mQv+9sGaDatnt3YaFcU08FdCH4j3WVKV5jbzi3rWQtA73qred71pve9D5BvfRc6oP3aZ2XUmO4mrJvVFXZ3f+HtWnlHtd8F2HdTIb5viv97wTAQOGUIPk7CfFGCJDstnr0s8m2HOdOg/5FKlA8N4os39m0DH2RwPV7np5V85Kb9sslJJ2Zve9jlhL4tzDcu86E0z5yZ86irf/rVkcra131WOaDPWtu2Vh2iLGDBtiYjMKIcvQOXVPrS5wlUpxf25Cgf5KanHtWrU52tMM361iXT9aGkGqNBLPvYia3Op/MSvXeHCrgHbwBQT8UDHohABB7A+MYz3gKQt4AyGR6SwOc1XKRt+t6z3fez8xzDgV8I4cFteKkgXvGOd3zkJR+EsRAFmpff6KslPXaya36oaBczNEUPd6v3Xq1u52fWo4L4C1xA8chPfgSMLwIRTB7qPYG9aNE5+1bXPp16x/3nAbz7JgS/qd9Pav/4hw+V4h9f+clnvvNbn3vH5OfjEQw5anHOTj13lPJjnQrLoztoKQ84KuiHeqnHeIoXLts3c0sAfzY3f/RnfxbWfj0nYEBHYO1la/8HFQG4eAP4AAX4AwdodPaDUT0FY9k3dvhXVA7ne7jVVhPIXgwldwnUBOhnfOrXfDa4fh/oE183gi52eyYIgU2WgsD3e2+3giwFgwCofDR4ATd4g8/XJngHQT6Ac9g3cifYTM2zEAdFbwTQhQQgXQ9XAF74hSulVlxIAP62T0OXgWwYAawxbfYVhZg3hSNXhXh2haOUhU2whWLohWA4cX3YhX+YVGeYhgewhm0YgG8IfcGFYir/xoMjVYLXp33ohnL6Z1DhR1OZCFMJ9U0xiHigGIqgiH45OE6OSGR0I1SSeH142EyX+GFlqIIOxYIu54nEJ4q4SIqVmEdZBnI5cHMNqHOB1Yqj5HNmJmgV2HIBd4j+Ahgc5369GH+/yIA454DtRIyFZIyAdmbJSIHL6DHOWHR34RA5BFoSQEkREiGZd318F2OE5XmBcWUA9mSjl2OglmusNAMzwBcb8RbjiADlGFrpCATrWHvt2HlP92PoRY/1aGD3GGr5uI9z0Y9MIY9Ypm47NYeZF1jWWGGnhY1spI3v1X+WBYsyxUIt0AKzZit/92sGl5GjRYccKYzB6FcgiUQi/xlZJFldCFZuK5SSK7lGLXkT0hd7RsaOPhhUN6k83beJLOWUKfV74DRrOQGHKVGU0yd7SEl7YLWUpdOURNh2YQl+UhlX4TSUA1GVjOiSWuWLwFiNNAlmpYgoZMYRIaGNO1mS3chhNeUvSNNga8k1dOaW1DhyHclcQOgufmaXIIGXe8l/j3lb/XRFLwCYaAkxj5aVG9lu1bdcz3eZ9BMAAuEtHtEuQQET9ZOaojkQhMEY5OFvhhaG+bZWbWVxAlWIBZBCKIACVvkRqrkSmZl3ddiZx/WZ4rQSpAkAyVkRphlgo6mazEMQrWkErxlx/1ab/UabZpid/4abusmbgYkSv/8Zms85mBPkZfQXUuskWAZIGmhBGNNJHqZpK9DJPPlBGPnWhVKFnWe4n9s5m5Klhij0Zr3pGcnZPG15nh2lXPRnh3zVnu5pFvC5BK4pn884EPUpMBOanwTgn/jWnwH6n/YWoilEoOHpGBchECk6EKlBHuWkmXQ4ibYndgzwju+oKH4XoWYhGAAQST6aAPUjEAwJlQxFpC3lUuLTL7/FNSu6okIaFy5aTsIpo9jmjjaKo/Coo2jBoz8aSUFqY0u0WJBFi0YaU0gqSzCwpJ7SpBfRpgLxo5OUlUdJpVXojkpmox+QTiz2A7/TPryxA/CTKX5KGxciIr0BP2vyoxWhlrL/yFQuKHwsoIkGYEIjeQBTuYufwaZtKgBv6qNxKmx0+mp2WqN4qqdFxqc94KeHeinsM6izUag2sKqPkqg+uqhHoYVDiFSPuk9ZJ6mUqpOWapZz6S6EgZFPI3/pWX9xeVwS5BpVEzW58awmwwFWwwFTsy4naki815AOhTQA5RcbEa5MEBqFVKwveazTmKz7tayq1azUWjUpI63OqjIK8zLZOmbbyq0D5a0GAK7iOq6HdJwBE50HIZ9JoIAIp670566xMagJ07B+mh/LY59QwYcgilD8OaIYy4yAsREVOp8C+y4EaxAGi7CbqbAjx7Dy4bAPezXpIrGh2TwW24ceKpsa/xtoAtqxTPCxDyOOHaRTwxQuKJuew+SnLeuyC4MbBjsRGbqaG9qHhrirMIWbjmoAFpez70mhRjAeSQA4oMkmQOsDEja0OFe07XO01uqqWAMbSysRTWsa8ImbNQuIXUhvVXu1HJu1jMG1XhuynhK2EnSYE8aufCVBOIAD0gqt8Zq41Uobw4qv3qevKjUViah8i1gVMYOTwrVlhOuRndtRhou48gofjAuvaUssBap2kSu5CUW5lYt8l0sVmRuSwhUhqThpqjV2GukDA2lMGsVHEdS7vkswAPO1KZevrBtQUbF6IdC8IdCEIhCKEHqvMqNTtrso2naQYLW7wmtMfyRB3f9bTMQLMsabYaubvMoLFczrvNArvR6Iqa4IFY94qj5Fo5RWv+opUkrHSZq0Sf17Sf/bScTkv++7EMzUmIKHvgIVFUs4g0t4ftNbvtUrv6h4TD+AvxgcifnLdKYKwAPswZ9EwCEMwslEwFFxwB+xdgr8rVDRwEr4wB34uIGjUw80uG9pmAogf8DbR2O0w4EEMnGTwky0BGMamQaGNEn4urCLRnDDmLQmXDUsXoIrxTk8jT7Mw2S0QzwMMEFsVENcxPu3Yy+QxErshkzcxShIwZCIv1w5iSA1wkGweW38g70JTWZqhLnqUKt0i7kYgIgnw6VTbRWsKD04xwbZUXAsx9b/R8fUa8eYOJbid6biw8eimIF/DL/FyCAHC0ZSaMjqqnBUOKMNSlJDnBIya1AQN4g0ZXH9gnFDxxcXalJcG2F65cnJCsrDiW2hbE+lLJ4huIeo3G+qPLXc2coGAI5/EctpvBAopo5i+wOBtZV8Jc2rSIKwdmnAmcDcykLhKMGYCRXNTJDPHM2HTM6KXM2FPM2kmrrmK7ncnMw+W0gXUbIwyW40irK6PMoOmp4iBbMgUT8aFsxnOMwsxcqOZLzNmXImNc/yqVW728b4TJy7vJ6fTMqzWxEAXbEC3YcEDVEGnUJwmNDKjERYCaoyis64m5TnvMGWBo8pwah53NEMBdLZ/9p9Y1XS10alKJ1kO23NhuyOqQvTRTiLakXTxmvTT4yRKLbGR8Z52avOK/3TYUW9IqEQ2qyvSCNu7IxswrXUXJXS5rx02uvTUN1VqfsSyNuQWd1sW91tWcbUbLzI5SzXK82KVH28wGySuhVVlNnW8fbWX53O9jvXg13XtbfVAa3XetlUfX3XC/lZL/rQnLnP+kzRtyzRqSVjCvlacSGmZvWhHB2LEOUx4dEgFpl2LArZUhqTeJbPEx3RlK1amn3aE5Eani21BV1vgijaM71FNWDaqO22FItR83u7qqjSYo3cT33P68qgImWjQX2reS2WeMzYKOTXJpXRxD3IcdzUUv+93CxN2BusrM5dT9B910JN3UR9Vkbtt5kmMBvh0PlFxTeMZ1O8XPe9c+7dRl8sW2G81wKKzN4MYPDNBPI9tvj9uTZcmPat4KmF2P1dqdwY4M3o2FxtvelIyMk91sfN4UGVu2aNyRORk8u21rmD3fg0FV8kvFGt3B+eWi3+3fMEyKqb1vVo4jRA4w0XsFra4z4esF5svj9uFkyDxmnnRkOe5KIx0oYk5EqOFUXuxBiWnEr05FYuGU0xAAOw2Z0aFlduFeSxFnDB5YhF5RWJHl+e5mqR5VtO2z2aAF6u5lIR5k3Ao8F9SuUp53p+FigcEXW35/ITzyiH58r5y4B+6FT/0ecH8eeIjmkDvuNTcQSSPulCUOlCwAOYnumavuk8YOme/umezuminumgXuqWPuqjbuqmjuo8QOOum3wDWMaJGOsBGMEWnn9UMemUfuqsvumqXuq97uu//unBrunDTuyo7upSgX60LusZ2OzKZ+uPXmNRoeuhXuzHDurF3unZfu3B3u3eLuoQThgCuIEc6Oywbu7njn7TG9zUBhXWzuvfDu6Vvu30Xu/Yfu+sPu5LUO4biO7pbu4Z2O7u7sULoev2ru/5Tu8Jz/DFvjRSfpdQIfAAH/CpV7mxW/AIfPCT3vDg7vHdDvLZvu0Qn80LQfEV7++Oh/FMPO1plxobgQRI4jAENF/zNn/sNp/zOp/zOL/zPn/zw/7zQj8ElU4ERMBkFZEQ6EEeoajuD7B6kAe9N4iLTr96zYf0Gl8RMM8EMi/0PT/0O//1YM/zQT/2Ol/0Rx+PHqH0S8T0oFj1UC/1Nkj16m71IoD1Wf9cjb735JpPPL7nTOPy1M73e8/kY+bkah74+531SE74am74p4n4cg75eV90jr/nlK/QNY75gl75BIHGgl/5LLnfoL/4t7JGRu75AlH6qp/Nh98RrD/BBpH6qq/jrQ+5Emz7d2GwIn37p4nitS/i/A38PcH7PYthAQEAIfkEAAYAAAAsBgAmACYBjACG///////Y2P//Pv+ePv93F/+eF/93/9j//9jY/54+/54X/3cX2Nj/2NjYzrZW57Y+57YXzrYwbueGbudgwLYXqLZWqLYwbs6ebsCG54Zu54ZI55AX2J4XzpAwwJAXwIZuqJBWqJAw2Hc+2HcXSOeGSOdgSM6eSM53SMCGSMBgF9ieF9h3JrZIALZuALZISKieSKh3MKhIMJBgAJBuAJBI52Bu52BIzm5Wtm4mwGBuwGBItlbOzkgwtkgmtm4AtkgAkG4mkG4AqEgwkEgAtjDOtjCokDDOkDCoJiYmJiYAbgC2SAC2SACQJgAAACYmACYAAAAmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACP8AAQgcSLAgAAQIoihcaLChw4cQIQoQsJBhxIsYM2qEiLCiwo0gQ4ocSRKAxyglCXb0mLLlwIknXcp0ubLizJs4b8Z02aABEiQEe/7MuZEBg6EDhQIlytSh0qA+lzadSlXg06RRS161mrXqQ6NIuYb1ynQrALNk0/LsKlaqSKU9T8qdS7euXbk/0aqdCbfB3b+AAwseTPhvXrZvo8YtzJjw4bF7+Sr227iy5cuYFT52O/Kjycygd3qOnNNz6NOoU5tGmXK16swCR5PWyfq17duEY7MuWXPhjx82gtuoQbxGjuM5dChfLry58+fFjSNX3nzn7Jy9FZYoQaK79+/bw5f/SEG+vHnx27+rJyF+wgTz8FOg577e+/z459HXt1+CBg3rKWUXxW/NRYdccstR99yCBRZ3oILBAXjdTAKmtx976OFX3nwXYridexqSx+GF94U44n7b+SehSAgt1kQTvxk4XYI6MGjjcA7OSONyFUE2IU0ILOaEEyhmaKJ+JBqp4Yn1lbgkkkVuR56KUfjIW5CUvRhjjsfteCODMna5I48LWfnjlUIS2aSS+DG5npNtQrmmeCHKJ+eb4U35X5Wc4VSRDz7ggIMGGjxH6KGHZqDooow2mgGhhiJ66IpnylSRBJhmqimm+2Hq3qegTrDpqBKsN2qnEoQaKqmboqoqqC7E/+qCTUT9GeighTonaaKO9qoopLruqgGllbZ0KauZuvqqe8gmq96p9Xm6rKjNlhptqtPKOqtFMrnYBKAE2ijsuJJ+aQOiyin0opnFjrTYE0/MN+2089VbwrzL2isvvqrqi5574sXqH7zskuQtuMCJS+7C5qKrg7pNFNwuSO/G+y+/ofrbHsagahwexx17fO8EAbsw8BMSt+bbbwkv7HKuDL5MKLETh3QSyCSL/CHIOu/Mcc8jz6straWtHK7M5N6INM01b3Qzzz3jDLTUUeM7NLd+LgQooIL+CrNw4/rqK7DNIcp00xmd9J20y1ZrranYztussm1Xq+x22sZKdNYKbf99q9eR7ip2r2SDPSlLaJektndsv+o23dPOfa3cdk+ec97bykabQkN07rkQQkCIY3TEOfrBB8eV3ujpB4qZLl2JOy0XCrSjEB8GGEDbYe213557qx2SwDvtvut+4fC2lxdDDP7NMEMLLey9eRSefx56jcKRXpzpqOegOqOst55gXbFrNBfvxQO/+/Dpaxq88OzDh7vx+yFv3vLNPx891jLBZPQP1aseywAYwM4NsIAGZBkChzDAueimfA7xn24qoi3oWdCCFbwgBmWlwQ3GqoPQy2AHRahBEl7QhB50AQhbcDXNucR/CjkgAmVYQBoG0IYCZJkDPwPBhkjwMxTkIAj/URhCIY7QiCVE4gmVmMIVEpGFTCyi3vhnMMokIQkb2MBv/MbFLnJxgGBkmRfH6IPOnWQzPTQIWJCwGIXA64krlCLm8hbHOM5xjnV04h3pOEST0QAKUEjZRhZzxSxukYyIDGMYEdlFM3oEjWkkyBrbGIU3RjGPe+RjHpOYyQ9ukpOd1KN/AClIkFSEAhRYYAIVqUhVzpCVP9ihCyPpmoX4B3Oi9I8ud8lLGuCyj548Yi+HqctfCpOYw4zVCU4wS5UpBJWuhGUrXXlDWMpyN5EcSC0VcktNJhGZyfTmEoP5TXDy0pjlNGcxXbDMZrrLikmAAAQMCcYFLEAB+MynPvfJ/89+2tOe/VTACEYwl1ImjpJufIIBFspQAjiUAAMYQAEmSlGGWvSiGF3oQyEq0QJYdKMRpWhFM0rSjz40pCL1aEm1xQIWLBMGMLiiQSNCyHjOU4v1vGdAd8rTf+qUnwMtaJ+yeRbKVAReGAVpR0Va0qYaQKkTNalDUcpUp5IUqiltKktdegKYynSozoyCPOXptyAEQZ8+Tata08pTfK51ATskKkROktK62vWueM2rXvfK177iFXrOc94LBvsC6YV1rBAo61nz+dbG/rOtCnhrXOXqELr69bKYzaxmMwvYwBK2sFRU3EIQG0aAQva0bn3sTivyIndmMwCwDcBJknrSpf+O1Kq0nWpHpcrRuuI2o1itKkkxt8xlXvFF0yNtTlGLWp/ylLVNcG0kYytbj+S2t1n97UWxyluq3la7Gq2tb1eat+Ke4LhNkElvlFs9xzqWn+5d62QpSxAYLuSu4MVoXvN70f3yl6F57SVMYWrYkax3rL9pb3zXCt8F+3S+9BWIfRWC3/8u1L8WxvB/A8zLAcOgwCQ5JQU84IECxheyDlYrhCM8wftu9sUwjjFmd+m8C9j4AiDuzEJQSWITuxfFKX6wXFjcEMvK+MhITjKNZ3BjHIc2MRUhcY8995u3NjjIjg3qI8FKWUoiNb8a5m+YwYxXkq7gzCvo5Us/zKduGTX/ClIuMZV/YOV9Ytm9Wu4Rl+XqZYWSucIZLrOFDTDmhaI5zbxcs2b2nJGaIraLzWUrc4FK0C0TGSoVGVJU+6vSpm7UoXX9NAEKXVJRj5e/G11oBhXd5rUo5IqP5mKknTvpfea5TIzOJiU13WkA9/qqnw51sAX9W1NnF9UPVbUQWT3Ti6TpAQ+gZwLvbFq0pvjWi740Vo7qZ/CS+rffxi2pD63mrrK52Q95drRxOm1qX3nB2G61tvssZmJv2N71BvRFyZ1oc2d7JhWR5yEBBdkEGPzgtd6pwVfMYiPbO8nZPTWhYyzHC+u1gybIuAnOZr7RQmDgPij4wQ2e8IAufMja/9amR/ZqUYhXVeIyrvjE84pxjXP8IiL28Yl3Su1/MpyyRnG4y/1q8aFDb6KqeWBYoRlAB/e053BFubaDvvKhY7boLj96AZLOw5QAEpDQPuRvSq6AkZO85CcBZMpVDkiFYB3Jbz9y3PM6Ra6r3etfD/sPEEZ2syeA7GmHwtp10/YozD3Gh4dx4u1a99QI5O7G8ngYU0trsk/65/SdbX5FHXdkp3rm3/1t41GjdNEqROBgpLxqLc9czFNW8+DlPOg3HftPdz6/oz9N6UUSZTm3G+qrZyyeK33zbML+3vrOt10tfJIIRMAC0LdACKZP/Q50YPqOJJ9Lep9D4Fde+FkmPv/i1n585Uvc/MfOb/OfH33qV//6Icg+7FJSU3r6TeQjZ70+443ug76Z11ZHdLOXZGf2akngfAiYgAqYgPJHSrk2SPBkf1uDfwinf/jEfw+YRrvmBAF4WYsHYwUYBVe0gCSogA0YSBloM5K3dxPYVn5ngfh0csVHS5X0BBTWgX31gTFWESXYgxEAKBUBeXwjVh/HggTngmYHg2WXAK4nVwl1gzjIcgMIcTzogyQIhAshhJbicZDWTy8Ig37XhEQldALYcnLHaTDWeFZ4hT4wg6bEhbLmhUkIhmYnhsZXdZmlX2dohmmYOVGwhguIhTlGf5QBL1P2ez/Gc9SGgWu3gVH/+Ih6RSU/UQGUWIkgAALu537W50j9hxEVc4gMRGcL9nR3xogp54iQmIp1JYlIUImWiImZOH2bOAT/dhM9AWtj1YWs94WQZYrz9n8cqIoVpngXpS0n8xMOkIzKuIwLOH16VhYNgItkFYe7OIe9KH61eGmoKIzjRYwWZYw0QDBIsIzk6ADNGALPWCsLkUVZtEqiWG3g533vZoc0WBHh1lRSiH7j5R8LtUuw0XXTw44b4I7fp3rAN49Sl3JkKFx/hm/aJYX8aAD+iBm752YGGGuCIihnZ4G82E++qI3AyI1RuEIyIAOVAUkWKYI2NY0ZiQMbqX8dSWlnlIIQtI0iaXUk/2mSjYGSrqaSsXZ/baVWSviRREZvmzdsDFl7G3V+5LVVJZmNToEYeqEV8PSTLUiKwcd6RMliRqmUD8WUxYaUodeUstJSTylv6SaViBF5ChFnOidp1uZ9P5VP9JhGmpePDZl8DxmJHcZm0lUQbig7bSllb1mQkSWXc4lPddlDd6lXgXaPJbVXAuaX2IRz4/dCEyEA3iKQA3SEBgl17zZQoomNaDkhlJQy1GWTeKmPY+ltKaUCKgA9u0RgpUkamamZWdIEnClGIRePB2ln/zSaWzkbp5lrqRmSZYh8yzdodQWbsqlLtNmJTNF7oNg576WIwGdWi9kULvSXAnEAB7CQN/8JcYHlWaDlnXtBnb7nOdcZUHKpnQk5Id1ZmQ8BnuI5nkhWnoJ1nvR5Jj3hgPJET4c0aTFZa/KHGyfJRmuZlpkWjHA3hYgHoXfVQTDlgBPznygYoDg1oMxVoJN2oAjKGDwJEaoZoUOngyJFoTBgoZXyiYQ5Z+3pm5IWX6P5G/EWooLxIlPZEF25l/pGe+LmkGaGZpgTnTRZFS4KilXWWO8mlIcZfgNlo6SJo4GhowsaldzGmkAKpFYFmYZGpHljpIkTcBBQQFh5Z083mgXEAzygPd+zKKcTPg9CI8HhpjXAPeETmGwHBfh5cRq0V7AJm+UJPRmnp1NBpmaKne6miGr/GkBsaqd42j1zmiB16qaRehyG+hmA1Kc096d6FagqMKgtUKiXqRbURV1kqotKWGtqdUhIoxwvExyIojTC0lr9CQCneqoEAS9X9HkWZ2Gy96tOFZEnYauVIRDwEhm5ClupSo2rOmmtyoKvqgOxei6HQqu7YqsOsayxtatP0KvJ5mvAanviOqw0sFDFGl2WgaxPEBm3aRSURGKllZXA2XMxWIEcwAEisK8iMFDVoyCQujpxejqXKj50iiOvYybvahQMcJtpwqkUBapUghoj6hULG68eMK/w2KRYdq9nl6/82q8j8K/YE7DgM7AfULCTyhwI+zC1KWGZybANm5kPC7EF/yCxe0KxCiqdQ4h6A/SsFjhA2Io0MiOr1+ocgwgRzLoQnlZbZjiuvjpxuXcX6KV9FXkdZDp5QMt6QqswRFu01lo4EfJkF7G0bldqTluunheuFje1dlG183e1keGi3ZeI7pmY9Zpiv9EDPXADN3CycqojLGuycBqnrYMgrwOVD+GwlAGANjtRsHkSsWh9lFu5HQCihceztliIT6Ck78ikinimC7a3ffu3hRu4rjO4liqwqIu4Lqu4EUSzjeugj3uzKiC5mWi5lou5UAC7WLuCHEqBL1mNBteZPrBIjDRGxstKyasQd5esbwiFtYt0CwGICggoX/d15ZO1vIlaHlpyI/+3vGCUvMrLm8zLSM4reAAAvYIZBdMrUlVovc6HvdmrvhdalYnlrB5bgRxpjYdpvOT7RdJkhAF8K5y4szRZs31qUmfGqweIgMm4gMs4i+nYNI6Wv0CpT9+bcB1pTwBcwAgjTSDMNThwwDuKpVHguOPJwCvgwAkYwQo4wZdLi7h2JjILnjccnuu4oSzIsUHGUwNlT6MpxCOwpGHUOWZFTa/ESkgcBNUDBEBQQLSCnjBrj+8LPelbjsnoipTofvJnwwyLw2GswwohoD2ct2i6U0G8AEPMxkUsikc8BEmsxNXExHLsxJ4DxVJsEVQMAPb1vgWAxVEASFrsAFxcAV5Mw33/7K4UsRDVOQR1ZlqIqVOSHJwj23SjeJifKZcchxCe7MkVsXiDJqG/JpG8VBHWV4LWF4uZShb29ciRTMmImVqq56+YvHOVPMn21MmfDMpMS8qjPGa9hModoMrw536tTBIyaxRiDJ7g2WLTCChmtckpJro/rKhpzE/5anBtvMtk60O32cjSO57+MVEX9I+L7BLLzADN7MzQjME+MM1Puqh3a6/Y3LH9tM0J0M1R18fhLM7uy6nlHMgWhM63OiH/zH0wqlq5LI+aPM+/2dARLctJOxC9jABmG9Bg6aPLiVHEZNATk9COvJ5LWsnUnMYSDZoPPcm0fJgVLRAXndF66Zoz/23Kw0yRAPkjzkzGUZBF8mRW0rxYv1nP9OxPKk3URHxrITERVDfOqoizzjORf2kUSvfMOX0mO10RPg0BQB3PQn3URm3PSI3PYz2aL10QTM0AViySUD0DUn3QA0HVXWfV6VwVMqvV7Gi8PlzN93zNY+3XRm3W3ywRAP24HZS+GXHXpVopil3Ged29aEzWYV3Ue+10jCqaZ20Qf2yzhz3I9hsRjT3Y17GZ7KiqW3vaqC18+pSvX1W2y1ox4RVRDoV14yrbBPC0DAWOvvuLECOQpp3awP2s8MjaSYCar825sT0Asw16ta3ct622BqDbL6uQO2zGYyejYo3dlA3RYE3Nmf9dZC72mEKaUROFOd/9etXNw9d90pLN3oDt3nwdl2l13oAZ3spZ03po3qJNZGTqs2csvH9Hh/kHgxu7TxtMl/v9EGv9Yijqp0VE32Pocf7tmUg44P1r4fpX4BrsvwEF4Srn1HlIyn21RB4eST3xIrgogUdomKzH4pbn4mT3fQMljiEBW7C9XeKVfl6JUt8oK6w4eAVx4k2Q4jgFlDBeckeecEnOqsE34yhzpLgaADfeXbbFpdrFXbnt43uiuRAkYrBst9odZMPL3bTG0pGtVkotEvalpaUMXp40sXCtbV6+ntYJ5vAdX2N+nWYu32+V5ksN0Gw+ym+es3HOZ2+Gi13/dOAEyuGWp+gdGuABNVCZm8DIKZLCKt27TV+UhOhc5Ojey+h9B+rgC+keOQKTDoENusITp2wCQ+hcXixUZ59UOuu0rhCyfhH+09S1ThhUN3VqHQWyvuvCfhu3HhG5/uvDLhi9PnjblOzODtKg/eu6/ux0AUg/JOe1Qe3afhlyWxBUN+3b7hHW3si/iBQIFe7oXhcVaxB9ke54gcDlvhTn7u70jmsnjBWHUe96du9Ede6AxAQAH/BHMPBHUAQGf/AITwQKTwRG0PAO//ANT/AEj/AUXwQLz/AQn/ESP/AVn/ALn/Eav/EVL/EVHBEtcugPvIDQF4uyqLuW64Mrz/LY/6fINTx4/g4FAS/wE9/xBn/xIA/xG1/wPG/xH//zDh/0Q0/0Cm/0Ry/yFE/yNX8RJ18RI0iCMT+5Ll+5MC99Mh9/NJ/pRBbaSjD2SuDzTG/0F5/2RX/2Dr/0RqD2as/2Pw/3ac/0Ja6pUNDFXa+7hbzFXFyOhxyLXwzkDSH2ZG/2cg/xdI/4cu/2i7/2id/2j4/xP3/36av3Ms/3fX/IgM/Fgk/zhK/gC7EEpL8EbD/5dR/5qM/4p7/6bp/4Cm/5C0GJl3iJWK/1EEyOh1z7sKiJLx8Bv3H36K0QpW/6Z+/6r9/4yB/5b7/8qk8Esq8QtF/7t0+5L6z7XMz71Z/KwP8fSwneiJQBSGPv+jtQ/uZ//ueP/AuP/uxv/uqv8O3f/uo/8CXvbCjvg32vjPIbw1rsjFEf+gABQOBAAA0aRIkCBYoSJUQcPoQIccdEihUrRsSY0eJGihk9PuTI8WPGI0cQIkSChOBKlgUPnkySJMJMmjUd3MSZ82ZNnj156sQZIsTJKClbHkWaVOlSpk0FGiQaVepUqlWtXsWaVetWqSkNGlX6FQlUrmXNdh3bAKxTtm3dsiV7Vu5cunWzelWrMmzeuHb9ohX7VvBgwiwRCvybWPFiqoijND0MgDFjx4UtX4b8WPJkzp3nVmYa2fNf0JhNn95sWDNq1q0zq369MrJA69gEZ9PGzfZ26dy9Xe9OHXr1QOC+ZQ/nbVw5UqJNmiyHbjpAAKluq0dnHhX7duInnXMH33b6dd3aw9s2f95tQAAh+QQABgAAACwAACYAKgGMAIb//////9jY///Y/9g+/54+/3cX/54X/3f/2P//2Nj/nj7/nhf/dxfY2P/Y2NjOtlbntj7nthfOtjBu54Zu52DAtheotlaotjBuzp5uznduwIbnhm7nhkjnkBfYnj7YnhfOkFbOkDDAkBfAhm6okFaokDDYdz7YdxdI54ZI52BIzp5IzndIwIZIwGAwzm4X2J4X2HcwtmAmtm4Atm4AtkhIqJ5IqHcwkGAAkG4AkEjnYG7nYEjOblbObjC2bibAYG7AYEi2Vs62SCa2bgC2SACQbgCoSFaQSAC2MM62MKiQMM6QMKhuJrYmJiYmJgBuALZIALYmACYmAAAAJiYAJgAAACYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI/wABCBxIsKDBglYSKjzIsKHDhwcVLoRIsaLFixElWsHIsaPHjxg1bgTZUCTJkwg1olzJ0iTLlzBbqoQpRYrBhDEvBgiAc+DOnjmDlhxJEKjQo0gHUqFisOZLpymTOvxJFABVqVKNCtSKtevKpU1tonTiZKvIs2jTql0rcSlYAFC9BoXKtq7du3jz6q37luxLvwD2Cs7rlilcsXJz0h3MuLHjxwn7lv2YoLJlBw7IYobMWWNNzE2aJH4pQADmKVM2d17NmnVo0KI7Wr6c2Ynq1o8/Owg9mmXp06kd4B5OfO/r3bFX3lZIhMiO59CjP9dBXceP69inV8f+A4j379Kle/+XyLt3zuUJW6hvkaK9exTw48t37369/fX028vfjyJ/ivv3+cfffPkBaJ+A8eWQA3nJsYSeFc2FF1511nH3g3bUcfcdeBI+N55C5ZkH04MH5jdgfP4ZiJ+JJ/ZXoIrssXhiijAiCJ+CDB4l0RBDbODjj0ACyQEH0Q1ppJFBJqnkkM+5JGJQEk0g5QQnSknBlVhmOeWWXFY5QZZgUsDlmFQOaGWYWJLZZYs00CBRUjv2qGSSTEJ35JFz5rlBnU4+GVOUU3qJZppqBmrml4OKWaiUgia6KKNsujmRjlYsxSOPd2ZKZIc7aOopBz562qefLyVEVpb+pepeomiqqiqrYbr/miqsYKraZptvIhUZFZcO8amRnHb6652hajoqqSuZ6gSqsuZHK7PNrvrsldHSNy21qd4qKVfKCWdFTb0OC2ywwop7pIdA5Iisg94uJeu1WFabArzYRksvBfK2pyCOVoR4nrfgXmrupsEOfO4OHybk77okqeauq/fKG3G1E8u774L9NkhpQr3qSSfB5RLr8QgjHHkswx6JpGajgz5aJn9ntvwoy2i6LN8MOM9QRRXcwhQnjx4HWedzngZNsskzoUySymTSHKbNh7IKNcyIyrzozTnv3HOpCh1xRHPNUUhhkiRb2N2GQEQndnVJnqx0SBq1iAILdNcNoAYajCk3fHXb/30f3nrv3Tfdd+e9ptw555zrxlZ4DTYRa1NH9ghmo502dJHr0HbSb6ccd4uDs1B44HKHPvrhoA9++pZ7o5A4zovnVJpEjzdnhBHXeYdhhblfTqGGvm+Hne7QqdX5RWjp16LyM6YgN/MDQs+f9PtRT+Dzzu/nggs4axt7TLMzV/vtve8OvPnDB59h+tEZf3xFyWffPPb0Ly9/9PdPn3/1+1+vPfcz8N6khPKzXhmQR7VLIBEOyEAGJhAtZnmfQ3qSkJ3trHvayqC2XsfBDmrwgzTooAhzBkINjnCEJczg93JSwAYiUIGPc6EMh/DAs0RQggyhoBUsWAUMprBNJxThD/9vFUQPDjGERXzdEbdVlZVURjVk6UAHHue1KlrxilaEYQKxyMUqikQzyMEhQZ7oAN20hQocxAEOLsbGNu7LhK9Toxvn+MYMpnGNdJwjHBMnRzcqTGMoIaOypEjFLhpSi7UzJBe/aJswilEgZDSjQpZyxzzq0Y5xxKMl2bjHnPVxkxfrJM4+ycY/BoUqS4lABBqISBjO8FKtJAIEAfCWRwrkKoGZJBWWyMte+vKXwDziClawNZKgkgqqZGUsa/fKFyJylrW0JS7PGMxqWvOa2GzTMIvpkdI0oAESEYE4RZBABpiTAQtIpzrXec52uvOd7VznOt1ny4F4E5xnMYA+98n/z376858ADahAB0rQghaUgypIqAq01kSS3DOc4yznOeUpT3haFJ4UTSc96wmAh+bToCANqUhHSlJ+IlShDD3JTlbKk0ohU5WrNGBG1WnOmdr0pjRlwCw56pOVCqQwZCGAUAngzwMY9ahITWpSC1CAoRK1n0qNalSZ6tSiSvWqRqUqAZiKVA0Oc5sDBAlLjwnTmPbqpjXFqVopas6d8tQqPqWlW4I6VKtiVapaFapd76rUvD6Vn3zFa1O3WoCuZvCrxAyrbwQgESkSsnZsvahk3xlZc57gBG59qz0ZqxGsCjSwV/0saKMq2tEedYMzUKgKVniS8CXEsVOEbEUnS9u0/7LznJfNrGY7ylmJeDagplVqaYNr1OGaFrWqZe1HEIAAKDpBlVIsgnSLwKN01vaiaHXnZXOrkYXtdjmoKal4x0vekY5SjTioQQ1sYANTsoS5zoVuB6ZL3SFY97oYtek7t4vZ7gJSs+CdQnkHTOAC6/O8alQve927EtdaAbYJrCx+LSph7rqNp5URCUCJi1TjBtfDprWqPtvI3gUrtrW9fbBjIzzbCVO4xQywMOd2C4AMa2TDHC4ucHN8ABCPVsQGIHGJlXsSiZSVxWvFKWVxqlsaiwS0TI1yAfZqWikzlcqjtfKUoRpYDWbgyxkg8tIUcmTZJjm78WSyDWmcEt8GVv/LWIayleP85jlzma9eBrOYu1maFEPYzDl1cX5va9n+XtiWs9HwP3nc4x3neLw5Rq5C94yRPvt5xYC+r6CXTOgYG3rGb030jRfNYx+DFtIclnRCKc0R50IAAqpszlnPTFEF2PrWSZYxg9msmp2Fd586NnCwCzxsAhu2TTKQAQYwYGLvnsTVsI6ArC9F61rf2ta5/vSuadzrKvxan8UecLjLO27yHpsGyV52s//bEeYyt7GxnbWmN41m3G63yRxlrlkkYuB+k/cFAH+BgtCLA4MiOL3qrcGhL+JuBMB72tUNNL31q917r5nG+s4lv/3N8ZEGXOA5ILjBZ0DwhCsc1Mn/IrO0F0htnF4b29Weqa3xrVlFd/zmjj4tDfSJmxumPCGxZnnEb/pyBcRc5gqg+VttjvOmAzapbeJ5a3z+Eec+dtpHhzGtdZ0xNg/EYVQgi1bpzFcp6/XOwTX7X4EdVX65pgmw6dYgY4v1rEt869ruutcBAHaxD5bsd1U74LEqeLQj1e2rOY6zO2JpiGKR0xLf9ERnq/RHitrNpg5s5vkaUsSzJnwodrA4H+9OCUvetjmtvBgvr5Byg7vUOSdu5zGGG9DLJCGvPqDd1QlzpF97nhffu0R29nTXk7TDxD4qQUXygOY7v/kSiL70o98ctvxJIbmX6e4X0PuMFh34C+fo//CrUPxGG1v5yTe+1CXy/OdPf/rVX4vcrUCWZGp/999fK9cXz9Nuf9sA6nd85pd8BAUDMKAs7dd+7ycBIRACXiMS/Ncw3lJ/ZtVy+Pdy2QaB7NZ/3uJrAsZ2/haAIxWABoiACeh8C9iAD+hfScFDr4Zk1ZZ/MScSO7N3A/FkA3h+IZiDBcV+CriA78cjZ9SCFvSCmXZmMlhtNFgFNrhvrceD5AaF5iaFAuWD7geE0yeEuhQTDacaNfFY8rYAp4dOFFdo/KWBGIcAAhFgTteG+/RxBsgvNQECIHCCzmcBeGgBJVACK7htKNGFACMFYGiBYnh69cZf+7eBYpRxbOiGbf8IhzAgh1JAh3bYfHmoh3x4BOoSFPFVgUPHfRi4femUf4log41oUMh3fiIIUkbFL2SBhQsIfRKwghE4fxSoe7wXiqJIinlXi7Z0igWViuKGfufnik4Ai+8ni7SoiN0SRR0welXUHNdleptWimz2G96yK79VUoyWeQYYh6VEf8cofRdwAXt4juh4jpsoFJjhjNDoOEQwjTAmedZIY9h4RtsogI8We0n1jZEYjq9IjuaYjgS5jtcHdDCFi9b2e6IIitemevXEdCEljFG4iv6EMwcWQEwkGDUIAB0JJSpnf2G4Tkl4gQ8ZfF4nkaxIjMNokf2EkQaAQY7RkR9JQCG5co//I4qQp1YQaUsS4XdX1k9wZnhZZmflV2UFAEIxEAOMsRiMU2Y5uX07qWbhF5EKAZRbxk9DeZRFKWWDd1VMpZRMORhOyUI32RxWJHnUeF09+Ug4yHlTKHsDpVRzdAM3wGq5dBMNxTUIGXRpOXGdNmFtKUZveVcV+WFzmVR1eZcnlhF6CScKMU4iQHovFphjeE6D+T4OlhByiWP76JlX5Y8GqEGr1piQNBsJUJVjlhCSSZmDFnmX2VYouVubaQWdSWqfiZuhKZqkuVqmWWOoqZoe0YkVUAH0xSNjWG8WVY/m8U3L4YsCcY8K8X+OGIxU+E8AB44DhwPr1jnEaZzThZyG/1iGF8WcveGc2ah3ECGdCUGd1ZmYIZWd/7id3fk2nSiSQ+ADPtB9F5hkfQgizCgVcfd1jgQRwFh+wsaSh2lU2pJs9ak091mB+smfdkehM/WffpgYA7qGBfoQB8p2LklQFBmXOodsMvCgpGJpyyFF0Pg4qDdvyTlbl4WhxcEYqLGhBzEbH/p6ufmV+bhX2rkvKOonKpqeLDqZXwM2L1qIsRlZM6qJNfoYN9qhBqGj6emePMphm2eYORekCjKkMJFxEAFR71hFkqWcmyZdGhWljmEWlvZN9/RN3+SECfGebXhSKYUUYgoAezpBkTlOrjmVliloaroAbNqmufSmDRCncv9Kp1Zgp06Hpzyzl2GqhhaBGTVxi/fXkGi6TgfUAz3gKUQDMuFhMOPSIQmjnpfaLlRAeFY2bDmmZbB6ABpUdlGGWiaWoSzBUheBqVKgqSPJqRkFeZ8aqpoyqgVjqqQqHukCoK3Gqq4qZbNKXLI6gAyaQbYalkQ0A7mqqjHBqxQBdi3KcmuJXyRpdAvwAR9ghojYTs0hBEIwNkFCMmVjIZYzIWwzr/TqI71TQVXQp+HqLVj6by+gTx/3cQSFMyWYeHBHpQ4lAAIhpw0gEA3nEOKKpHU3qOaai+mkruzKX+5KBPAqr0BCr5Rjr2iDr5KjryTDr2fjrwBroAL7gQYGcAb/e7A2O1AKe4AMi6MoFrGNyqfuxhA7YRADMABkAayEKKxHZ06PM6qmSi52YjAfAp0HoRq/FqtGCaLB5XmNsRRkERqVYbXfGgBGi7RJi5+fyLQx57RgA7UGI7VwKy5VG6AMgbUfqLVeSZSg5bWMAbZOILYJQLay02cSC1EStaQaK48U5QEewF8mYAJWRDyZMzn1CjwbsjskGyR56jl1+p4IawCh67ePURSUihWK+k2IWztpNlMx2riPu12RO7nqIzaWe7KYyyGVqySd2xEbV52hO7q0txqmyzCdqJ/I6wOcaqG5yJC3NW08wANB8zFFM71JkqqEy6EeCKkDtbB/dIXI/0ijBkkqx5u8ytuQzDuKuphT0Cu91vsjv/K+QYK9dlsQmLG93BtQ3psx4AuL4uusb6O6GXN15BqD67t7XtNMNNRKCnxAMLSMPuuhM5u/AQVwyoKMWPif2TsaAhwaBLy2a1WSdpfAzRRLDWxADwylile/HNqeNEvB/WTB4ojBQKjBLCwX7GkFZSqNr1mujCtPT6pIiOQ10qVIXRRLy/hNi6eo0jmwFLy/6NiAUizF0dd85WjDmmka6bnD8djD8+hiMxXEh6RFRFwERsxFSKzCTaDE7MbEWuzCMPxPUHyOUzzFVfwAVwylutobqBmcKldIr8ukp8fDW3TGV1TIhWzIev9sBTbmEJbWeE8Il6DZowagRhIRfQ1IkFEcAnv4n0rTx6wXdGh5BIEcm4ScSIocjaicyIYsEY3cEI/cZ24mybpJyZasEJjMyZq8h5mciXiJLALMmuTEupPnuuNpzIUWqKVHnoEsnG32qHFcyeiFeHUcAnecgHjozCISzDo8zC5azMN6zOGczFd0pswsztp8gwoRzdLcRxJRzdfcftmMcijjXFw8YT4Mxl+slvtcW9y1wS3sUj/Ktz/2kjOQkaSLFyuMQ/aMpPCIz/0saPkM0Ys7Wf98wwQBdgPNlSFm0Ag9vIKx0BJ0uH+auGSIzIA5zindti72ywNB0p9LwQeX0Hn/IcDvA9PdbNJoStEqLdF2J2guDbTcHMczDdKDYdPHsxytqcqV2dP6jNI+DdX6fNEcgZ5wDMMcxC9Wi6MRbLxbDKhM7cUVTVs7vbFSDdFUjRFWbQVO7IhZjTFb3aFdTSpjFQARqpBsm9d6rX/9BdB8B611VlUEbavX2iZafcO+WhN+fRR1fdebuteQHdnqlNbPqo2BXVeDHXiFRau3cti9WkY1IQWLLRcSUZxl6jXmPNZmDZv8rNryGNTPHICULFAcBNs1pxCm7dBmil0R/dSsvdKCHKO2rc6ceZ1Z2tEjlzjDXU8RSsIgLMJZB91HJ90xd22UjRH3620vHKLWmbAa/+nZTXi3E/hcMOXc9iVP1G3Azrt96U1r1t3XGE2g+Pt6O+jdhg3X8c1TVNGXnnjeaiWoTbvMOingZ4Z6y51LWOmjU7W1x12iNMAv0RTeBLHfVlBWeN2pDQngLN26BX7ShvqbYyqOe8vRdTbiXHtuEG4YEr5ZSg3WDw3OMCrOMd7avx3Vkw3fHLETeDvJiMnjRuWl+L3iBJHDS/3iSxqbR47kE73a6XTdFaHjE1zLPS7lPz6f+7LHEm5kCfnY6I2uvodr6HvAFSrmN7UrIPG7IsXdAqVBB26V/H3hXU50ZD7dc17ddZ5RZv4RaD6Rxi1SbA7i15hiwgyPPMzhS57aTv/N04deW+AH6Hq55/lLcF4r5LwlEuNa6DDe22R9zoqu6audzirJvZJu1CsuwNx8qKie6glhew7xbiOh6oxBdV5n6vgE67YepazeEK7uqLdeF7IufIycmr0+7LXHWRBhYxRO7GyBS+GdEDam7ND+GLnOEMjeUtG+Fsy+d6/87Nfe7Xjxyo7MWbXp7bnCTRy17cJO7uq+FuAOy+Iu6OuuQ5SOFlBQ7/auBPiuBEiw7/ze7/6OBPke8AIf8P9e8Pw+8Aif7wZv8AP/7wk/8KCuEZtsx9KHzZdoASSQ8SRAkPBc8e0nXZkpfmdh7/eu8Avv8A/f8Cfv7ymv8it/8AKP8i3/rwQRLxETT8Ue/3wXj/Eaz/F1PH0JCPKzueKqEQVR8ARI/wQyP/Mm//IDnwRJ0O9MH/MvD/BT3/T+vgRLgOUWO952uPMZv8sd//UXH/bnuIyU3vUJYfRJr/Qsf/X4XvVWH/BQL/Vwr+9Vf/d4/+9az/UN4Vxkf4lm7/MUH/h5OPi+7K1pbxBFf/RPwARMEASSP/mSL/f9TvmYj/mWz++Z3/lBsPn77vmZ3+99r/gVkd2hIYs0DPSVGM+V+ADTp4JqvPjivfaOD/meD/pIIPqaD/q8T/m6//uTT/pbb/oBuzOpD/urz/p26PqtL32y7/eLLxH1DvdOr/d7v/DYn/0M/3/3qgnJNk/Hdfz6O2/xl7jLvCzF6dzsClH9V3/9eg//dy//U//9sizx4j/F5H/x5p+H6F8CABFCYAgrBQ0CQJhQ4UKGDR0+hBhRokQHDgxexJhR40aOHT1+BBlSpMEmTSqWpOigZMWRLV1qXKmyyUSaNW3enMjy5U6ePX2GjIky4kmTFn8e3Rh0Jk6mTZ1GLIgQ6VSqVS86cSJFilQrEAN8DVDwq1WrY7s+RZu2aVQAZN2+dYlVK1evYMWGhXvUrFq+fSESBRuAqF/ChW8OTpgggdC/MgMjNpxTJsKvkCNfbgoYrGXMnQ1bVsz4oebKkz2PNl1a9GnWDQW8FpCx9SBsw7Inwo6NkTZU3bt9K8Rt+/dwpsIjBu9NXKFx5TcDAgAh+QQABgAAACwAACYALAGMAIb//////9jY///Y/9g+/54+/3cX/54X/3f/2P//2Nj/nj7/nhf/dxfY2P/Y2NjOtlbntj7nthfOtjBu54Zu52DAtheotlZuzp5uznduwIbnhm7nkBfnhkjYnhfOkFbOkDDYdxfAhm6okFaokDDAkBduqJ5I54ZI52BIzp5IzncX2J4X2HcwzkhIwIZIwGAmtkgAtm4AtkhIqJ5IqHcwkGAmkEgAkG4AkEjnYG7nYEjObjC2bibAYG7AYEi2Vs62VqjOSDC2bgC2SACQbiaQbgCoSDCQSAC2MM62MKiQMM4mJiYmJgBuALZIALYmAAAAJiYAJgAAACYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI/wABCBxIsKDBglISKjzIsKHDhwcVLoRIsaLFixEVRomCsaPHjyAxSkwYEuJIKSVTIhypsqVLiRtdypwp86TMADgDkCwIBQrNjjtz6kT5s6hDJ04M7jTKtCnBoDmXlhQqVWBPpyaJUiWKtSlSpVy7iq2pNWrYljtPql3Ltq1btgKrjp2Z9q3du3jz6t17N+5ZlXX5Cubrd67RwIMTK17MuK5MBw6UKIHcuPJIyZAlG6aZebIDy6BDi8YcWcnj0pRFNyatefNp0qpjy+bL2vTPk0KEcNjNW4Pv38CDC/+9G/juHMhz8F7OQeJV14dHUqAwobr169VNaN+uvfr07+CpY/8fz5279/Dgx5Mv330C+vTqr8eIkXBjzOgSczPnMLy//+LEcZCccvs1p9Bz0N0mnXjxZceeCee9x2CDD0LonoQTxldhhO81aN189dnHVGpLLLHDDscNSOB+/g2X4oAFctBDDxK1liBnn0khmYcbXiihhw6yxyF6QE7QI4YZqsfdDTckZKNRJJqIooAqxtiicC8mF+OMNdp240yp7Ujhg0OGV+SRGJ5Jpo8dArlkkzp62ZRERtRpBA88zKhnD8jh4OeffgoXwqAh9EdoCHgmmieNLH3500YJtSDppJRKmkEGFWZqQqWctnCpphV2WumnoLLHqQuopsokkxJ1RaedeO7/OWOfgP4pKKGGEqporIy26ihNkEohKqWklsrdsJMWa6x2yFqK6bLbnZoqqqvCKRdNEp14om9ZWnklgFcGaNOvdEmxUXtIqikkm0S6uWa67q4r4XwgTuRUttpySyVy3rYIbrga7DYuuS+ZGwW6acZbXpnw8fhuwg7L+x699NnblAACvFqnihznAKiisvLZ8ci0IjcwwSBhfNK0qJ7g8suavvwyyyzL7HLMNtM8rc0n4CyzzqnyTLGvTKmskJ1GkJzcx4mGrPTIfprcKMopZzwSzTz7PDPQLmSdKc9cd22z1i6HLTS9RDfVU0JBtB3EtgHCWCDAwWU54MlUf3SSxD8q/2weu2b6vR3D36n7oMsU13vtT2tL4fbbOxi374rM0S35yHjnDdRIfLcZ8cKANzxm5+1+zh7iiadN01Y9Pd62DjrE+DTl/MbI3N1waf7QVgn11BN6PAd/ApISCs8z8e8ZbzPywJ/AAguJV7x4S6xD4XoQsMv+9HK1284b7mvpvrtZvfvevPIuMx8e+i+rDx776bs/ncvPR686flIgjXRu/Pfvf276C6D+/ve/8AFgeuI7IFFOUq0Grip6MIigBCM4Hwda8IGJm+AEK3hBC0JQgxSMQQc9iDaLMUVjAySgCgXIQiOosH8GRKD4EJOQETLpgyDkoA0xSDEQhnCH1cKhBv91CMShmdAlqekJCUjQQju90H9NZOH/6nSS2iTwIJ1JjUSCmEEfArGBQpzgF7nYQy+O8YZdjCCr4jSiHCmRiVF8Yv+iKMApGqGKnnnSFQWSxRxtkYf08iEMzojGMoKQkDcIowQRKcQ16hF/S5SiHNtGhEoSgY51eiIVR7IRo+0xI0b7owNtQEobCFKQpbTBBVN5Sh+mcpWlbCUIX2lBVkoQBSiQIWAUEsk6TjIIlrwkJjV5R05GwZOfXEkoFQJLUspSg7QcZSyfKcFoNtCW1ISBNauFTRjgUpcpKV8ExhmBx51IAQpYgDrXyc52urOd6IxnOt+pzrUgKJlgOckBDmD/gH76858ADahA97lPgRr0oP8kKD8RytCAKjSgZbyARC9wP7L0hJzldNs550nPjr5Tnuj0qD19gs+M6HOhDU2pAR6q0pSytKUMfak/IzrRipYkAThNgEQw+j8G+PSnPlUnUIf6U3cS9ag/NWBJG3JShTr1qQSFqUOhStWnIrSqWI2qQElZrRl4dQY2DUlOdaoQnvoPqUJFalHbqdajKnWpJlVIVqsqVYDOFatXvStVDcrVVX0VrEdMSQMG2wCJbOCwG/gfPdvaVo+qEwSQBcFb4boSidT1spjNrGb/CUJcykAGYQUJYQurEMQm1n+LZSxaHRtZyaqFsgw5yWZnS9va/wa0syj4bGg/EqVxHrZ/bXOscBdAVOFCFo+wLYgWpdCTAjj3uVPVq0KfC127Sne61C1AQg+QXe1aV68Ue8ELMIABrzpJTqdJSIl8e9rcBHe4Hi0ua13bpeQSZLnNzW50r8td/X6Xv93dboD/O9fwjre8gH0kthRSgQZXIICqDepH4xnhoU4WtoOVrW03zGGpqkAF3LRBCUrwzcAWLCEOfrD+KkxPeVYYqBembIZH0uEa2/igHw7xiEsMTpAkBClmdW8Q2Clf+MbXrSMpkX0rK9esDni7/O0vdfd73Sf708r9VGj0yJuCFJTvhFIAMjmBO+R1FtnIqSXqSZS85IE0tf+qWF5plKVcXSgD2L//jLOWE8dlLzOXpC1BgKAR0NsINDiYbXvxUY8M1NYe9zLohe1yn/CEG1v60v1MJSk/a142umTQhM7Reg1dAUQHQdFnNupQHU1fhSgYrpOuNKZn3WFN24DTCY40WRIyTghA4HpobjFI4Rtj2Gp4tjJFtlZrm2yA4pbHf9m1FHr9a9cFe8LyJPZr2+wXy9K22ZoFd2bF3c9n59LEaClrBBQbbJBy9NoLKDZlj91Sq37bqcw+QPRUiluJZi7dvF43ats9bHjXc9vcprdK7a1sckt1n/tOab8pOrWSjFbQhm2vEN5LZFQDlZ3uDmk75b1HUGOcxrT/nvWHVw7iG3xYNScXLGFPnpDf8o/jZvb4WtUZ8ncf/N/JNDkCFJ5yG7M8xy5XAcyHHm0f8xKOSGssW3V+ZpIv9c1zbeicUXrQrZcbBrIpTLkS0suoq1XVVP/4Oq1eUqxnVetzhnuUvx52BcpE0N2edgQqSUkipDXtO885UVvLdnwSvehGX/kaVSP2lOBdgQHnOzD9TlzAB/7vq45s4ZN5eMR3mOWLF03jS4KxZZbdhUJQe8ctzwC0M2Dz4iu91SSS9a5vnetU5q9BTzKCEXzg98APfvA32RaZyF4ip8+N6gVvedfDXnfHH0ntDXp73BNY9wLlve+Fz/3fEz93C458/zApL1zA07MDHXj+FTvv+c+vXCIPiL/852+B+tu/99/f7S7FH0z4mv+d6Kd+CcR+7bdhLAd/85eA9nd/I5B/6KYSNCcFNidkrudxwiZy7CSAmhOBCVGAtPZyChF8EiABCSh/C+iAThGBE7hxZbZ6OneBPhdvCGdfHCgFHqhySheCwDeCJRh/J1hM+hdO6tZTl2dwlbd87qSBeYMTb6ZncxZnThhlzqU4UjCCVniFWDiCv5cbEsFm9zKEZ1WEBpdqIzeDycWE0kdQUXhnUwZQa1hlBUCFWTiHVriFQtCFSzAWGcdumPd/LqhmZmhfbyZ32JdXcxdTBxB63fcBdDiC3/+nh6Wlcbnxh2lXgRYWiMk1iIh4iIZYiLaniN3XiBLwiGIRcONkTjtghPBUcMKlhJpDgDDlcHUli862SHDSE1fYgw+QhUBXFKaYUW1zIqoIcqzoWK6YN7BYb8t2bwXVUmJ0i1CQiz3IixUHZmI2TmTWh60XbBKGZsdINW6nV28oXeP4VPMBcSW0GFYBaNFxjQJHgUcoho7VjUb2jSgTjndVjvmIZ/5UYDGAjlSYGOv4hTW3AdgYhqxniUhljwSDj9Nne7VHiw11QTRAA+pod3MSiQfZP6xHj9q4kJhobGnIiRD5dnLWjJpFkRapGKOHI+q1BOwFbB3lbsO4Tuj0aPX/1WaxllcdhpK2BZD0Il4VeV4Q0RkEMViv1hKFdlgyCYMYOIw32WpEqZN+JAWUxpMc5pP5Fj1CuZJJORBGORBIqWtjp3en6DaVRIksVnlphmS9CFfJeIOY5UAjFoRuVo34g1GPk5bMp2hp1ZaA+JZXh3JyyWF0WQJ2mXc9JoQB12AQ9mI1GZh4mSCCGVcdWJgc5ky3dG6LCR07RWqPuZaqKJmJiRWVmU8KgZmZaUqbWZqGgXxLBHV2olqux3Px9JE/1VoO2Jk0EX0EgVOd6ZAmSX2314lUtQLIuQKFFANd5pqbAZunVye0OXUSlm3xOHiRtZtN1xW+ORDAuZ2WKQVe/1eSJJl7T5WcyplI9NKcD9iQDFYB0WkEUqeWL7gAXDgbltGSDyGcDEee0kWI4BVI3sSZ4PkrEtFg8TmffVmJ9nmH+FkZ+ukQ/Ilvm+iJxHldZQRt4jNjBbmCk2iEgPehD8oYEXoQHJqaqmlbEZRKutWeN3KipsWH8BaiQvBzIzoYJWoQJ3qZKUpbK1pKLcqbTTFay+WhqbeNgIlq59cBuqk/RVAEtFIrOHArg7Iri7InUVort8IlrkaWDpEaV9mj/gRCCMVyyMkkqdRpU/krRFqVRuqR1Fmf7oR+TYo0T5qlgEKliLIrTuMxUjqlwTEoXLqmFgGmsiamBkCmOLZyZ/96A2kKWIRaFJAhFEJRIqMWjNrylKpIk3HacyfSNv+CJXNTN73hH3vSH5LxlZABGbIne5QWpkXXjOiJnkyCnIIhGeeVqqkqEF/ZRpNKqThhqTCZUdqyA5pqhJzqgp66A6DKH/8xqpITqsFxqsOhq1+6qq1aeq96qCknq7PaqLZKG0qQq7pqG70KJQ7AEKvqADhRpJJ4pNOZpIoGWfI0BPY6BFbKK7Pip1KaK4Oip9TqG9ZKEevqqq+aeCr1raGXGLgaJ61xrh8BakW5qu3qpu8qmu8EePQaT/eKr/mKpfyqpcNxKACrJ8AxsBPLqtp6sDX2YQk7qws7GA07sBDrERL/W6gUGwDCepaPk6xQGYPE6E6PsxyW4yLeU6rLQa0oS7DYKgDbeoMKRavWohi6KhU16xTrGqyWyrNu47ObCrQ2GYNDW6pFG61Hqy+7obS7irMq+7QeGLXJGbO3mqpW66XQkbUBgBRIwZTWVpMgOlT9AwRA0D1Hyz2zQzn7ETLlahs4ca2/Khk90YxbR10EQABZxnUsdZ6zKqwlIo1X+Hu9h39A2KVL+yV4q7dOwLeP47d/C1SBO7iIW7iTozTeo7jlKhCN2xB4C7lQILlP+FyVe7l2drlwi56cuwSeW4cfELoNOLrkerVNIRR4u7PA6Dase21EJUc3dz1uo71PdD1I/3MiU9kaQmEQ6zoAA1AiklG5mfu7lcu+WoVV6OlcwpqF9fe5yxu6dbK4VCO9OUu9TXm9/ge43su93eu9KgS+diK+nka+OWG+q4q+6qsE8Ou7UlgA70sA7XucyUm/lmq/FoC/zLu/t0susjdY67qHYchoctpRkIV+mGQEbZNJL1QnlRTD+8M/SNOwvBppozVYgraubnuDZpqcP+YEv+cBHqCL8TfCxVS6jnLCDZDCkUiELGyB8wXDmDTDqLdCRnDDOEzDAGQnPAwAj/TDDRDEqzrEHljE4YoUSbzETOzE5EowUozC6+oAqLuCOEef8erCjuZTkCWdDODFYBzGxHTI+v/DwA9rt3zUtGxcdG6cnDVQA6jLxA9Qf8zbeycCxQlyx1Ocx3uscX28oBhLT6wmyCBAyIYsTIhcw1/syou8A+PryABQsE7Lsp43ychZyZfMxJq8yZ28tl9SvljkADgFwH0rwKook3DKzO9EeA5ry/e1qj1BaZPrXxYsXfNRyUxSv6IoAaAbunXsKMYMwcm8tdVbytCMZs6MpO2Mypo3zRexrtf8BNnchtscoN58A+AsiuPce+WsOdOrzpjKzgvgtchajF9rnarYWujkyboLybp8ab57ufPRqHJrFzNrrtR8t/9r0JCD0AptcCUNbyeNZhCtABKtrhQNqxa9UL6b0en/udFv0dE9bMelh8brOsrZmLEMKq+Q2VF+2E50GlktPdGQEckpB3oWlBjBktNRvNM/3NN6y8ctGKdYLNSnrNVKCoBMitTEzLYOwNQfqHhPPRhRbcYfPRbZukwxusLXyaDPHLa4icUS1pFJ5aK/OVZklRAOV315dUGluRMYk6PQ8dazJ4GIZcVzTXV/OZPzpNeRrdc+VZp+/dfiuYzm+Z+fmNbBSRSHjZHrp25ci3MpTXAO/bOr3dC3KYNCShD2EQXCm5XWZ1AhVC/3cRHOwY6l/YsBnNpoJtxGRtzwxanOKdv2UdsbppUHldsVs9sW0duac84A4DtQoJfLHM/c3d0d/5fcdwnYTobBBOBcPulcGeyTAUoxqMttBmHd2K3dq+vd9N3dl83XTNVkWIXe5V0A503e8GtnWBU97e3eDGF6sRmaRUjZXm2dDO7HjAXey/SQna1Xt2WL4L1UCJ6gQ6WQLayNDt6RHq5aEr7YFH5913XhajS1Bg4R3/mLCt7VD76gI/7VlIiTBbqfKCrY/snBy5nhJfXiZhkBMR5hNe6XXn3kQ33jrRYS3sbjF5pVjWpEsV1SqbG3jb29EI7kW77kpvzhc/1o0FvNCRGmUH5Z+6TRqxKpLU7mYZa6WQ6Pd23jX77VdU7n2ijmba1cOWLmxTluB6DmjrTnS2Y0F0VOqP94rCbN0Avd2o3+2vQE5N7WcLctcRoE5Phk6NmN6BplrGB7bcY9XKEuXKkt6ShK6ZgFQpjOeSNxkPPtlJ+u2pDO2rPu2qfJZDzajxRK6c5dRreeia0ucK+ObbX+6IqO0oy+6Oj06+F96roukS616zMloMw+mIp5o9g+orON2E+xQNkuGM9R5aV97d9e7qKx7aSt4+Ru7m4R7jmOT49HQ+w+76ExYxUh7/TuFsjEbfHu7fn+75Vh7xSB7wCvFvvu3mG5XAW/8HhhRQ/RRwzPFg5v4AlflRF/8RKfR7YM8RgPaWHZ5juqEEww8iR/BCZ/BEmQ8iqf8ieP8iv/8itv8iz/3/I03/Iwf/MvX/M67/I4j/M7L/NJwOw1WIILWH8iIAKbHLrcx4M9WPQWcPRJr51tfpSkdRIkX/In7/NZ3/Mx7/I/T/Ncr/VfD/Rhn/M/n/JCz3QISH9FD/VJv30iSIJN3/ZIv8lSP/WxpRBNsPdNwPVjD/Yq7wM+4Pd/v/VlP/OFz/OH3/KmnhBxz/Rsv4BH7/bMu/RWSPRFT4p4nxUJwfd93/OJT/ZJIPiEn/iHr/Khr/hlz/j4nfeOv4OXr4B0T/lKL3zSGPn2p/mbz/lS4PlI8PvAH/wmL/jE7wOJH/zIjwTDX/zGX/jJL/xHwPzN//fPD/wm/wM/8JIfgYYJ/xHO3v/94D+C9ynubSYRvl/9yh/9zH/86L/8xc/+1e/+xA//z3/92S8FXogR3F+F4d///m+FACFEiBSCUgAcRJhQ4UKGDR0+hBhRosKCUpgw8ZFR48aNRzx+BBnyI0eSGkWeDFmyJEqWR1SSJBhFZpSJCSsSfJBTZ04JPX3+BBpUwk6iD4QCvWmw5lKmTZ0+rHjxJceWKKd2rCryqsmsKbf6iDmzadKiPI+e/VlWJ9qeSZ++hRt3oQMHSe3exZtX716+ff36VaKEbuCIdJ04oftX8WK7hwcrkRtZcs3EjC1fxpy5b+DHhR04rqtZ9F3QhCefRq1QgACCDRqMhh1b9nHdgzIjIkBA8ODs2a51pwZ+enXr17yNH79cmyZE3L+Rj/atNPj0uL9tSqeenbp1hNyhYt8NXjtD7wDKj0cPsfz59O2frhffEL578uLZ08ff/WZ+/m/D2mbKrf4o2m9AAwU0MEH1pJhpuaUQTBBCBScKCAAh+QQABgAAACwAACYALAGMAIb//////9jY///Y/9g+/54+/3cX/54X/3f/2P//2Nj/nj7/nhf/dxfY2P/Y2Nhu54Zu52Buzp5uznduwIZI54ZI52BIzp5IzndIwIZIwGDntj7nthfOtlbOtjDYnhfnkBfOkDDnhm7nhkjYdxfAtheotlaotjDAkBeokFaokDDAhm5IqJ5IqHcwzm4X2J4X2HcwtoYmtm4mtkgAtm4AtkgwkGAAkG4AkEjOblbnYG7AYG62Vs7nYEjAYEjObjC2bia2bgC2SACQbgCoSDCQSAC2MM62MKiQMM6QMKhuJrYmJiYmJgBuALZuAJBIALYmAAAAJiYAJgAAACYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI/wABCBxIsKDBgVMSKjzIsKHDhwcVLoRIsaLFixElTsHIsaPHjxg1bgT5UCTJkwVNoly5UiXLlzBbaowpMECAhAajRKEZcmTNmz55CjX45AlBAQKWLBnKtCnCoDZxsowaVKBOpyWhAsXatOjRpEu5in0p9WdZllJFql3Ltq1btgLPjoWZ9q3du3jz6t17N25VlHX5Cubrdy7PwIMTK17MuO5Kmw4cKI3cuLLGyQ6UKDEMM0ECzZQtix49GrPmxwEiYyZd2fRmziw9g3bAurZtvq4PayRChIfv38CB5xhOXIeOHsiTB1/OnHgOl7BjisxAvXqF69ivU9jOfXv27NXDZ//4jr17d/LXxVtHb547+grqqb+fMQO69N29mS93Ptx4cuX6BeicfdGhpZF677XnHXrxjceegu81mCCEDMY3X30zCYUAAhIFEUQIIIaowogqGGficf/14Bt/xIUoIokn+tcDgQUaKIUUCpqHwY48hrfjBBM8IOQDObbHY4/V/RjkkEXqeCQGPmIA5JBENsndjjbYIFFTG3b4oYshkFhijCmqyAOLw4EZJoxkzphhjffdaCUFT0KZpJRLCjnndnVGOSWTe/Z55596BopBllsyFVpRHnroXIw6rFiciWUGKGAOyEl0GpwvhaZTk+Q1KN93oH4nqoPZlQqeqOQ1Sd0NsN7/kNCmQy36RKNBPBqjpP1RmqKl+g2XqUK0coqSp1Goit2prRYZKqukOmsqtKkW+Wqss75WK21TMNqofiKEK+645JYrgqXlDputsSyFBgUU5EEg77z01gvBe+/Zq++8+KK37779xstvBTTQAOu6inLrrYfgmutwueiSq+4UxbILkrvwfvevvgFrvHG9HWf3McghX0fvdQUfTLG2QiElEW+8AXvmpDL+J/N+OfhGo8UXeSaSsulRW560q0oYbY7PGl1tkwUXnOhQLisEc36W6lozgDf/NpzOb/Lckc8aAQ2f0NoRvSzZFYjN7NFFNk3D00xJBMTcdI+7nMNq5h2C3cGN/7uz1xb9zJ2Q+1JpOKA5Eq7v4Yc3qbi9jBvu+AP0uu30RE3JTffcfAOHt95gdv6b310DzpHg2z1eb+RUTl4464UmTvnisFcpe+WWwx3Thrbi+sMPOOAgJqSVzsyimsO3uVbFpjMUmkSfWinokX/ueeWT1FG/pPV8Yp+B9rEX2UIL9GWpMvMv8a7wrY3+HnzyJxaPZg7Isxm/myKh33xBzysUfZPT41H1uBdAJYVvTgXE0wEVNL7y2eB8LBuK5jZHwQpacG64ymAQLnjBtRRmfwxBjE7oQ8ISktByKLScCVdowhS6kAYsjOEMXphCGbLQbboTygQ5yMPNaRBXPaSgB/8BIBcQPsUvCRmhDWdIQxUusYRNdOIT6RNFt03xhE3LYae4pZQPfOCHGwwiEMBIxjBekDf5U0Jk9Ne8NaqRW0mMQhXnSMc62vGOdoTgthLSxS/+UIxjLOMfOYhGjcyGjaZzY/90gsdGOvKRkLScHlsmAImc4ARTm5ogG5XJTnpyk2uJmhEzAjaJoDCGsUqlKld5Shau8pWqbOUKYUnLG8iyhTS4wAWK+JKoJeSSniTCJj0UzGIKU5ChrORfRpmQUirkliWsJSyhSUJpvpKa9LEmK6WIS13y0kAJ2cAGNKCBCi7gnOhMpzrXiU4FuPOd7GRnW0bpkLUY4J74PIA+94n/z376858ANcA++RnQggZ0oPo0qEL9qU8URuChEdAiOKcgTnKaM54YXec74ZlRdM6TniFUyz8ReoCFmlSgCD3pQkmqUoU21HIQjSjmaBIapYhTnBftaEc36k6djmAE0IsCIkG6yCiMtKQtNWlCk7pSpDLVoC8tWAxi8FAWsABhManpEm66gZzqFKM8VYBPgeo/oUYQpPyD4xR0ctSnutSpbgXoUuMq1wO4bapVverKJDiFG5GTnBr8KjvDKth0DhGtDZHIje45ULoeda6OZSxBIyvZgVpxBjGVqEz8+tfAFjadhP3sAg6L2IwkZLEohWxkG0vZysJ1tQi9bGZnep9w/97UQ5tbJwN2y9ve+ta3Ov0taUubEo209rjIdWwJs7SC5q5As4BRCFdxSzfd/va6vw2ub4dL3KdIJLngDe9Jl2sD5z6XtnSR7k29GlrRDpan5+Rud4lYVqaqlrL3ha1bV2iB/loAuieRCFfZC1/3vnej8VXLfA0SVPu+Fr8P1u9T+etfAJNEwDftJHaxa90Ne5gB8u2uSEjK0reS+MSTjSuKVxxhhu5zlVa1qoVBgmFxavjDve0wjq8bYuKOmMVNZTGJYSvkEkP1xaqMsV6/eTEubnW9FIxnew0MWgX8NI0LHkj/3nXk/Io3tS12K2sXSmEZ75WmTh5wlA/MUSpX+f/KhjwrcbcMhS6HObxjhrCX/1lmvQ41urYVp2fdvIAcF7bH9LQJVXSSkAI4ugAEIMBjizzQR0Na0v60dKQnTWl9ahrT/ey0XZsmAxlI4NQSmPFHaryBQbvZ0IJF9CgVDRRGT+HTnO40rjP96E27WNSe7jWo89lpt5Ua1alG70q06kViHnPH19UxtOGsKTmXtqiitjOw7xxkFL/gBaks2J4N8G0Yx7jaWXVys4PAGw9BO7vqfDdvqU0sayMW253WNrDpKuRyx0rcd/Z3KpWMbppIhAQkuDGOpS3v7So4y95VyLbH7dpsm7jYNLgnaz5IFoUgXOEfZnjDeStrtP54293/tri+hVwwjZOG4xPFKd2EIIR0jny32sVuyUEqki/7XKX0sQ3MZWLbzdHc5jfPOY8fDnH6fvfnUDdo0Gsz9OjqROZz+x2CCd3OAsdz5/TseUHzTGRuJ5W1LxU6fe9z9a7STett5vqU1wl2Zhp37CkuO3LRPmq1M7kjvpwCMGHmbt6KPOnxJjnTF+zMhKw833if+J1P/G2RgAAEHci85jdvAhOkIAWF/GgvlflLTBI+CLBG582jnfjd1n1/jZ/C4yk9+yI/vvIaufzmd9+Bzn8+9HAxuEIGP7WFd3T1Cf5bacUe9eYDVCKfv7z0Ma95Dlj/+jR/vUcsafrih/z4iNf+//6Y7/zyuzwh0Z8+9TN/fewLQfynU6+rBYtz0er8MmFp+slRbGlH55rS/VcA/1dkAahPEsF7CLh7cyMRXuEUGDZ/X1V/n3V/EqEUTYdEEsdiATiAQraBvwZsBXgAB5iAJLiACtGAe7RWUUB8z/ZuhPZb9IZVC0Zn5md+EGR9JZCDOogCKPB5PuiDwPdnJ4EsLFh40PaCvhWDZ5ZlNFiDzneDHKCDO9iDPwiERFBwmdMtTyBz1MVwXNdR8Gc65Cd5HhhqE1eGxMZyb6OCJEiCHqJqMlEUXBhGXviFGBWGgDOGZ9h/HKiBfPiBK3Y5OtGGCfiGykYTDdAApXdJGpR6h/93hOzkAR6Ah15Dfk6YXC7gAqs0gu3XflKYg5+nfC+RiIt4Ao1oeBi1ehKoTpJIiTxjiZd4XJm4iQrBfp2Ig58YiqWjQ+qFdUDwO3a4AHN3h4uXZYolBZO2d3nnWCTVcgaAQ4xRdbVFUVCWdT8QjMP4dcW4YMeYjMdFdswYWxn3jFkUjWsXN30lBeQkaBnkXtl4aBpxIxfodBnoWvy2jPc4bjEEAzCwGNKYXpzFjrjijl5nYCIhjxf4Y/aoYvjIkPrIQvzoj+fIE/1zSUWIeqwXT6rIAOmkhEJoRE0Yi8kVQzVQAzLoPJnBMm6UgqWoSRgJbxqpih1JVlg4g2rFZSL/OZIsVJIneRArqWUpmYWB1mqcRAQb+Ygb5ooWs39ClnKQV3sndln9BYf0+HcdN5S4whtH2XrvppTswpRAdnEqF3kYVzD0MZWHGFJUuX3DZ5GnuIoxOXIZ5ZUTZZWmpRA5GV4r1FxraRjcx4gZ5IjshHzEKIpjYZgMdnd5iVx7eV52uWwO4BmeERmU6QBF0UfrhiuEiV0/1ZmeOQIb9TuaMZqj2RSRYRCnORDMsymVGRlIgRQDEJsDoBO0GQW0V1eS52Ur9m282Zu8GWlTFZxUFQGkGR2VKZkJ0JqW+QSY6UeaiXic+ZmeGZo/QJrFmTCo6QAEsZqvoZyvKQCyOZu1/2mbtoebuXlQ3uab6gmcwjmc18kZqekQyvmXphiYqBiXqiiJngl8t8EXmoEwzPOdyvkuBFpni8mYM5BKD/WexjKfbQmYzwmXXLl6+tmZ/NmfevGfZxagrzmgBWqgB9pa2RQrC1qa9BR4Ftl9LQiTg7mRHLkAvJF8GJoYAnEjSJGIOJqjDbAhXaKYIXpSmRhQFNaXYoGiFumSHJaKLnpOMTpaM6oYNSoFN6qjOcqjHOKjP7pQQQpQQ5qWTEFrEIFhXhWM9MdbQAQEPuADD0MuWbOmDuM5IoCYdylqjhZpjsZ32xaCKCRqBVNqpfZQcvoSYJoVRbdmZFpYvXWmaeqm4v/SpozKpqMTp7tYERJBp5d2pwRFhv0XVU3DpzTgpzIAqJPaGZJpE8g5qATBfSDnYefkoqzXW1NTPFmjH1eDHFkDN9+ZqwLwE7RWqSllnpKHniQFK7g3Gv/4EqcaAMlqE4lZequ6Ya3qqsBVaLwVq78yq7SKIjZzM7iqq6/Jq4rmq+BYcRMnrAhFrC+wcRPpNbYmc78Dd8EooVW2demEK6BzryGypmoyLvd6I4+ZWOlYg+NKjqNha8daIO3qdu/6Az1lh/LadfSKTvaKr/eqr6EjLv0qBf8aUqhVfgN7OZZhsOsaHbRGFYWaW4dqYInaKI8KqTLTsnxDpBFXpwSAqWb/mKeXWgCQtWIqY6wDcRVwUrJAcbLVlbLutbIeArONejNKGy5cs7F3SbM2m4YgmLM7i2I9KxoEAbSc8Z0CgZwSAVjtSK3RWn/SOq29tZ8wMwRDgK2S4hvIUatmgq3Kh5zJ+nTminJkOVDqKRK8d3lVaIVvUSNeCwBgqxBiO5BkS61me7aomLYWurZt67ZbwwNxq61YM6t1a7eeYbKyt7f7Brr61Lca8bcgELi/d4Vu0TwPaEZAoFPvSJDpxEObBEgVNExhlChQi4FZilIjSIi79zs34q/LJIby57qwW5CE1rDnRLuCZLsUhLsm6Bg94XhZaoC1CLzB+wPDq7HFyylT/6qqx2SE99mihLlOFWpMm0RzNGdMnbS+QgB8B6uWn3ugWyoRt/iJJXCLFwpC4duW7dYoLIqUxoe+HvBT6itI7Bu/7uuSZdS+qku9F4G3i3m/CpG/n8i/EeylnEKlEpGZjYKfcqmku+WZu6WVDABGvAHBDezAP7TCDBxMuvu9DUG8eZmJOKyJsnLBt3h9+pu6MisWHqwQIOwhItxwGQW5P3XCRpnCL0wELNzCAazCUBzDnjTDHGHDOZnDs7jDCdHDPpyLoLfBIOVMRfySSzqh7waBZ4uUSsgRUdOxwBq6eYtkqfS7CNh5vueDgQonZuycAiytBLxhbCzIagy5fSwQcf+MjKL7lHOsT7SYEG2ox57Hx6PKuscboTJ5yIiHdK46yK7HwYQ6BWNZx5TmjCXUGPO7lJkcyFvpyWkMy6+sejsWxPRYyo9cZKhMQqo8suPncQmXSe5UwObbycU8wkcMbX35nRR8iTHUy7tbIAcXzFMzzN+XzC5IwsYMyksXzcyMlzn5zOYYzULcABV5Amf8sGW7zZwMiVQ2cnD2kQShPgmBkyKZJeaDLUv4ED+ZiD8JOP6sVpeUzi+Kze58zEj8ag0Xz/bWEPQ8BfYci/j8QPr8kf1szkFpRKw2phAbd8urvG4Wu6K1UbbczGBGcSplZPh0WX2ZyNLci26HshoF0lT/JtKfZdOFRdKiXE/gfLMN6WDgyNI7XVy2jBU9alvrJtOMy86ynNAGvWNJnIQ0ScMOEXgHukJFTU9HTY1JXbTrjMwILW9Rfb4ITW8eYdWLidVDPY+sRl1zk7wR+9FxHdI0bWDdS2M9/VQoPV5MBLJUPY/0OF3Iu1N1TZBzXdOFLVp3vWp57WAi2tdrSM4iRsRe5EdKLWVi9VUNK5hIqM4qW77ppBMWiBG9moHBRrN9uGK7ZoYolNU8R9ld/daELVibDdpcx9kK/bCinX8WUdoJUWnCltr8F9wu1tprDXFtPbZfOMC5bdvvPK1zedzNems6C1chKNwkdd3kCI2S7WMw/w2Bz43bRwvdt03e2tjd9Di196TdPg2Am4pUxo3eRMUtOoFwF3nQ3JykTy3W7bxhDM0RDx3RIhlNOyzPNhlH9q2i5Muq2gzW+X3NtCxv/40RAQ6i4VxNBd7Q+qcRLIjCDL7fEP7gzN3UIyenVgqL5ZfDkSzdy8fhKurh0NrgTh3W2QziOGbiPIrizqfiquTSiJUQnvukQj7kQL4VFNGARE6jAMC1gF3kSf7kT0oVFYHkUL4XVrETgP1BVb7loiGy/4oYXD64vrzhGBjmZs4XXv7XWn7mYi7fxpuqbB7nVj7mGVHmcp4hbp6HQXHnfG4Xq7zmfY7naj7ZIuEEhn7oSP+Q6IpuBIze6I5eBJAe6Ucw6ZRe6Yq+6I6e6ZEu6ZXe6Zee6Jmu6ZteBJ3u6Z8e6ozu0n5LgpRsfbxHyXucfuqnfoUYBHSJyYV+6Ib+6UiA6o0+6qRe6pTO677O6MAu7MN+6sV+7Mh+BMSO6qpeuqyux66+e7BeybI+69JX67cedgrBBEyQBEmwA+Re7sB+7qNe7uq+7uze7juA7vBeBO7O7vGO7vO+AyXNhtXXw9pLiGDM7SzO1t8e7uO+7vV+7vee8AZ/8Omu8O/O8Jt+7/k+iPt+i/3ehv+OgIaY52jl21PQBCDfBPTO8MVuBJA+8gdf8ie/8Cm/7PLO8pye75L/fPE0X/OaNze7neUQ4fEhL/IwH+8q//LqDvFBj/L1XvQ/H+wyPwU23/QXj/NRMNo6HzgKYejI/uy+zuxXr+xZP+rN7uxcj+paL+y8Hu0Soe3rl8fUzgGvDus/iPbT5+NNXvVOsPWXHvSb/vVYL/Ze3+x7H+pjX+plf8kAe/baPslr3/aU/PZwf3lyb4yBHvlYTBFgfud/rvOSn/kj8eWbH/mXn+VRE3iaz+arDDaxJ+dgM/VVrUyiP/pmXvoJ0EyxH/mpr/o8bRAIafsgkftHRPl/wfucUUQc/+O/LwW6TxLAT+eJifvG/9LLf/x3Ofy6b/YBz4uuzY2ED/1U39LZB3+Y3d88AQEAIfkEAAYAAAAsAAAoACwBigCG///////Y2P//Pv+ePv93F/+eF/93/9j//9jY/54+/54X/3cX2Nj/2NjY57Y+zrZWzrYw57YXbueGbudgwLYXqLZWqLYwbs6ebsCG54Zu55AX54ZI2J4XzpAwwJAXwIZuqJBWqJAw2HcXSOeGSOdgSM6eSM53SMCGSMBgMM5uF9ieF9h3JrZuJrZIALZuALZISKieSKh3MJBgAJBuAJBI52Bu52BIzm5Wtm4mwGBuwGBItlbOtlaotkgmtm4AtkgAkG4mkG4AkEgAtjDOtjCokDDOkDCobgC2bgCQSAC2SACQJiYmJiYAJgAAACYmACYAAAAmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACP8AAQgcSLCgQQBRohhMeLChw4cQBzIsODGixYsYMwqEAmWhQo0gQ4ocGbGixI8kPapMydKkQJcsY4rkuFKmzZsxYcKUOTGhz59AgwodSrRo0JcocSot+dGo06dQo0qdSvUnUqU9q2rVenWp14dZt4odS7asz643w5pdaxVh0q9wTyJlS7euXbQ21dotizduXL17AwuW2jcmAwZBhQixYaOG48eOM0ie/KHyhxyYM+vYzJkxZMiTKX846re0wMNBT5zAgEGCawkjYsuePVu17RMocqNQzfo1bNrAY99WrXv36tavgwcfjls3b+SugbtwQVopaqCKPX+OHDqD5cuZMXP/7tx4e43u3kcDNW36+s/nvpUDZ14cfnL5tYfXPx4fv2z6zvF332zTVYdTAAE00EBCTTTRQw/hjbcZYxRWaGGFkEUo4YWb/bTEEuyxp2BCTjgxGwkopljciiikmCJ+LqLIYnExkgBjjDPqVuONLhZHAw0JfQgXgiNG0eCDGo534ZIWZqjZhhZ26JOQIZZWZIkn4phjizHyqOKWO8pX45ZcuuiljLr9GCSIf/mkmGJJkmfeed19F554UDrGmIFVfuVeFPZF559w+gXY24D+AZhboL8Nqqhxhwoa23QFRkFTaT+9KUScE5a3HXp23imhDtrtuV6fcf3J6KCE3rZfpI0m/1roogJKKqurhkIXK6XUWdpRXEUywUQQQQABRGV35jCqdp/WaVmyo0q5JqrALujrq7qyOsKjq7LKba2x4vftoZO6oGYUVMIV7LDFHgsep6R6+hmoz4oarYdsUutVkRxh25+js0KarbcBdwswrrSSO8J056aLqU8+ROzDBhRXbLHFTF6s8cYam9qWvksFNcHIE9Rocowkp6zyyCe3TMLKMJfssskxr3zyCzi/8HGbCUk8MccXZwz00BjbwCfIeQGV8sw017w00yg7TTLUUUstc40563xWXAIIkKmmizG5pJN4Kin2hUcjnVLXQaGZY5jKjQlml2Jq+Tbdcdu94o98A/+5NVxsuwn22ReSrSyUhFOYttojBf6T2zPCHZzcd5tZd49zW5435iz2fe5OOP3kc8Q33IAeehRfyPHprGdQFOMpDTWba077Zjuisd2uHO013657cLzH7LvtKaTAa6WgYwXx6KW3PlnqFq7ufHevwz6S7LIFD/Pw/2Zv++4S1M69rbOH3/v4EhR/fK/Jh+zTD/DHLz/8o9cv8fz452+/D0MVZj1EgMmaAAdIwAIa8IAITKACF6jAncHlJ/mb3/7qF8EK/mB//XPL/zISQAZ68IMgDKEIB+hAnDguCh7wANiEYEH5rfCFYGth/IYSuA1aBAEISAgOg5K19U2nhz70nBD/hzhAH5priEj8URGDmEQkkvBvSzlhClcoQ/jB8IosrCINvfYWGx5kh1EA40+AuD4yHq+JThSgEdFIRDUykY19e2L7WLKuCEQgYjKcoB59kEeJKSYoH1KQw7x4kMME0loJecITzGjEMiqwkZCM5AIj6cMDTocFLIhBDAaJkzrekY8t3OME+xixPwLlkJwkJEEMuYQiJXKROaOkIxMoy1pSapK2/KEBL5nJTebLhAJwJQpT6AH8LeCYC1CAMpfJTGQ685nQdCYzlSkCEQwllaokSNeESSInFOCb4AynOMdJznKa85zoTKc61bm+EpRAkxzBJkm2ichhptCYyJzmNKPJ/89o6rOa1/xlNg1Cz6CUaJ0ITahCF8pQcbbznTGIp0BtIkViagp+/NRnM/vJUWkq4CccmeNAD3OYAxwgKA1NqUpXutD1weClMCihTCo6xTdh1J8aVWZHd5rMj/okpF0caEFIygCTopSlSE2qUgvgUpjKNCc+SaEGNHDRH0BTnzzlqT4zKNSLBMUABkgnWMdK1rKaVaxmTetZ0anWto51nLzCmQnmaoKn8iSqHphqVa+6z6x2dKtC6SpGvhpWtrq1rWg9bFoTq9iywvWWL6BrXaHolZ/Y0Y4uFIJfcbpRvuoUmVwVLACBcs7GLtawpiUrY1Nb2HLirG9z1aRdoZqQy/9GILOb9ewyM7pb0AZWtEz5SWlZ+1bUEne1qT3na/kW2xjMViQmNapPbEus6gbhs7nNZ04VAM1qAvS3wAULaZdK3vKmUwXoVcGPZsDeGbjTnc8NSXRPOt3LWpdY2M1uT3PaXe+GNrwHOap5B0zgb6ZXvTRor3vfG1+S/IQCFKippna63d5m978Apsh4C8xhc4JVpX1j7wVGfIEGX88nEJbwmyhcYe7qF8MZPolwO0zjcX44pSGeAYlLTNnQ1deO9dNnAoZM5BYbeZlDZiaMY+yWGS90rSyF8kqlfM6HwrfHafnxJ30mZCIn+chG/rIylxxjASuUyilFc0PVTE4rl8D/xBeZr2Xte9/8ZhfMgF1cmTdc4z6zdDoKhmlMsZwSOWv5vtd1sX73i+cxg5fJBDGznyfNUEC3V9BwPnFCHOCAIDdao14W85HJnGFJM1S1SkW1SnWJsxtX+XjvffOplLfpTo/u06AOdaNJDWBTP7m4SVV1Sln9Aleb0816Hsm6piq/iOkW153VLjO/iy9IE0SYijQrAbbN7XFyu9seTu23t21j4oK1BS1YwQrqgsqJkmTZGmi2D54NbTszmprWPKW7M4ztJ2h73N4GeLhNO24ClNvc6FY3u1vZAHmGZM54jB9Wn1nviXuU1+ElrFoLXk5zF9zY3/T4uMGKM8H4L3b1/404/Cwu7Yrb29HJ7jVQ3Mpxcor82yAvwM25TXKt7eXkLUExBegnMZYfc8gsrjA/MQ5cX1OawMi7iwZ9nBAIEz1iRl8A0v/a4qU/2tpN9snT+xz1ugBdI8JU8U15y99F95TaU9o3gIV50LHTWOE+KREIQBCCvvu97x0IvOBNGVClpF2FNrVqP5XudnwDUu7hpbs37d5hvHdz73//u+AHL4SiOJwkCIL4rTV6TFzTO8+ztnbofZJtA9Q8nOYG6+vBGXvXCxz2Zf0JBHbP+977nveET71SVl/bLRed9Pc+8umnyfSuEj8KrZ99yGMvfZ1T//a0z71Pfs993wc/0yL5Cf+nVf6Deoc6AfVuvmCdjtxgOxapuu++/CMW86TVmvzm1zW01d9V9hs352v2fiwVf/LHffQnfEtxeHu1eNvldm+Xb9UGdgAgeZTXYedSIhVQAZiXeYC3eR0QfJ8XEwqYeBzFeIvmePomgRNYT3VXgQR2gU6QgRvIgR74gZ0Xd34hfg6ATw6YdRzFf0Klccn1f0M4XOZWcj5hAUq4hJpXgx0AP+CHcrXGg43XV1kFhAMlhKaFXFtIhKaFhAmxhEzod074hD8Qhe/WcEtgR8wWP1iHZ+fncnA3LRJIgQglbB2Gh8dGKQ2zBA/wAAXYe30XgX4hSGsYAW1IdI0WhxU3h+j/AnnAZYfrpIcFRoltxod+8yF/GIi8N4g4WC0JISxT1YZcBm0ehWuOGIJCRST11Hpk9W0DMAAHR1ywKIviVHs4ZwCtposv8DlV0SDtpi7WIoqjeHU+UG+n+GmpCInOlyCt6G9lVYuzyFrSeIvXt20913O+SBXAyHCqqGlRYFtW9Cai5oDJaG/HhIXZZGq1x4WNhVxIJAMyQBZnd1fFh1k/oCnlaI6lZ4XPpI6qxI6x546KBY9DJI/0OHVKUVBG0gSjGG9ueIwWlnzo6HbLqIL9xmbT144DN5AO5QLs1TcI+YgRYYgCQU/fCBIM2SAPKW/R1nb8eEwXWYfPqJHWx5Ed/1d7rQVOliaS80iSEGGSAICSzEhH9URMiKcYa8dZE8mPMwl2GXlcHWluRthW6naVKzBAsgWUDYFDOCRMKalsR2lRJMiA0eaUEPiJUFmTUpmTOGlzh4WV6qaVzsWVX+SVYFmUtBWOl+VpXeZlLsdM5weQlYWAwSV2cGmJv6aYZ1ZWAzRiaFglcwZko/eXRRaYyjSYX4c09ecRTmaNjJlQNimajilAkEloIZIQHMFp43c/5QdtjNhoBwhSv6I2OhFUDuF/LuiWYxWL4bQ+p3kp6+grrGlrEZd/gPlps/lTtcmZXSRSkcZnu6lOZuWbPHk8wdmcQahlxhhm+oeZyzkYfP8BAIrEQdI5nSv1UJGZmtx5QcdXYbEZmOEpnmMhEOU5WOeJnsMGa7IGnfpSJIqElAvIdsjngBHjiPQ5FcE4EERFVCYlifq5UgrGXlsZln0CoE8goGVJoD6YWwealglKFQt6Gg1aUgcAoRGaUhM6AxWql9TySpQZMTiAA8mJmfGZU/XTPNMzNNOzoxtQIRTTmQGGmNOJXt+0PtM3i7H4mDymSP75otD3BDHqAzNao4F5oxqVo6bjo9LTo6wDPYwRpIZpEZ/pgkbKVMeTpKBpAEtqmk36BE8aF/MVncUXMdZVkVllgs9UTfwkP/SCLPZiNnPyp+/yJNKCmw3RNV3zJyn/Oh3ftBfXoTZzKmN8aafVhada1YDRxKfR5KfOAqjwwizz8qmFWjY6kGmKKgCMGqGOWgCQihiIyjgl+ieJKHGaeoIaxQEc4F286l1K+QODSqrQkifmQaiYsZ5uwRGUd2AHto10IV1qM6uwmhC1unK3ql85pau92qu/GqyhESqhKi+gIaw5gKyqCQXLyqzo5axsAa2MgyDwGgCiV4pG1o+YeZYLQHREEzSJYwP72jH+ugHm6hMERwCxaJ03hosjx4s/NxD3qTbx+nxT+ob1SpGBCU36+q9gSjgaWzRiGqeeGQUFe7C2mLDXyHMMK3X2+QSENGcz+rI4cK8KgKVg5jM6/xoaPOqlX1oxqiOwY3qYKfqoQMGJvTefQgqlxQezMyqzNHtkNrulOAs0OruzGxumPhuZZYqeQUG0vGe0P+ucCVFT8sOPHbpTVZSPWPRCZ5u2N5gVF5GqP0GVU9mW4PQTNFiGnHe0jPMTYhs/ZOuPm7W2bBtDVcS2beGfcEuwdDuNi+uqPnG3eGuDetsnJiUQ65JClvqGPXitZjs/ikEsg0u4EfS5QYBFoPsmayKUF3Elk6efeKeJf/gAGTi7FcCBfQeCLooqlbuCocgEmOsDxKK5VQiTPIU/pBu6VTW6QnC6MMS8NziiFsG6Kfq6fhi7tJuBthsCuEtIXtm9Xjlnmf9VtrmVdduqGMeUvC2EvIknQ5ryEzV0lwgiEPEbdrj3lowLVnIpl764e4GXvRwYfNzrvd0LvvGjGOK7WeTLrZq1AOhrQer7q+yLuj7xvgaBQ/M7v5+pkzt5vwaQv1i5vxDQv/77dwAsWvNKpTF7r01rZPWzwp/mwjCHmqOVEFEGbJUGWT8Ru7HLiZO7tyknMUurwt+pnKMDw3A4xDnVw3MRBTUMgAgVVz4XBTq8iYGoxP85lgNqlk05vBNJvJuLr87Eq3SYEQzpikWYmMS1i8tFFsKiugM1gr+adFuMqy9ZoOYovmJsl28bTNZixl3Im6ylxr3oN2LRxmrYdPXVnab/SHH3unxth4yMrGQyfJiyt7AcTHOWLE4FZBb1uEEETK+f5sihHMnKZ7EVe44+BbIalhCVnIuX3FYft8EFsMnjqcrUcnhqp3j0FpPJx8sHnFvfZaEA8JV9DI1VKbc5qW5INMYOQZTXdshvPJa5zKGKdseAy8WYml3BnLsCQcyv5MQb6ZHJvALLrMcH4cwD4cbDeY/GF8Q2isQVZ8RgZsQDq6zZB86nZsOPpUtRaMVIy5dT6s5XCs/IeZnvbKVJPMmjZc/hvFSMCcX9/LX/M5kR4Lx0bMd3xrnjq9FeZ8sAsKouuD7IKnPsbNHYytF+pacZ7cX9FJkgXYEirdAquMS2/+WXSEbQsInTuCbPRyZqA0vDdyjLNSxHsTrTlFrTlXnTCB3POv3CTb2I6LdMP83EQV1ePZc1Iy1antSGcXzSYOzVcwzWL+eP2ywS0nvP4ozGaqXMnsPMRm0QWw2RXb3SYU3X2ZzS18xyZR0SZx3OyKzWacXWfePWb90QFC2jL8u0T33E8LnY8xxqyMoRDG19Vi3UH4nVMj3Th43CAu1yPO2djb3UBT1kkS3ZuFfZ6URsWb2K8lpfU2XTYCbKjSbbeEbbCe3RS+zX4oZ9uu1WT9Qghd0QEouIGgDbpYzKkIzci6zcRjbVvd1Y1RfIAsQgTRDcBSFMwjKxEpmZUT3bpP/scrZ93C1XYXAXltjNBK+Myd+W3ry4xmoZ3Oet3YLZ3bX93RUX3qc83ttV3rl73uy9cbx9k22VNb4ozJHYAA3CTSG64Aue4ND8EApSIgrO4FFhyAYezQ5O4Roeog4eghHuBBO+4UZh4dxswk0h4ihucgo5Wkuc4k/RyXvW4i4+4wnpn4BB4xmE2wP1sGGH4z4eFfdp4yf+40QB4xnG40Se5E8R5EUtFz2u5Fuj49mk4ByRBEmgBEqABEhABFze5Vw+BEOwA2I+5mBe5mZ+5l6e5kQA5mNO5mf+5mCu5l7O5m2+A3AO53Le5WDOAzxgBEZA3d/Iij8hLFxb6Ibue4H/933mbNRUDgVWjuVanud03uZ3/uZ5/uVhXueVjuaXPuluvulx3ulDwOd+Duh6Keg+QeiHvupcm+ht+97WbbnW0iBaruWeLuagXuaXvuaZTum5PgS7fut2/uvB3uufPgSlvujRi+BNoOqs/uzyd7vPW+IYOetNUOtIIOy/DuyiXufDnuvF7u3bHu6aXubJfuEK0iDODu3sLojaO+2xvuznauVHcATb7u34/u3bbuz5juv7Luz5/u/nTu28GwXr3n1TPMXsnvC7Z0oXvpbzngT1fu/97uv/XvEWv+8Yf+y5PvBmPYxMwIkJr8MLr/AQ4PAED2kMWeVJUAQuXwS5/vIy8j/zNO/yMV/zOC/zN5/zOX/nyU7YicrHQdGEmzfy1nu9I1yDRu+JEhXvD7Hyjt7yL7/zPF/zVF/1M3/1WD/1cP7zyk5QQg8URC94Rv+H11u7/qv0I8/0UPDw1saQUB73cafOB/HhIU7jEv7gTn+SYS/3cg+9DWH39UTkee/2Mf7kfo/iki3ZRs7kcW/khX3jib/hi38p/un4UA75M43Osm74wc2KDkP3BEHMVAL6Kb82fEwlpH/6AMb5K+j5hW36z+xwqy+/zgj7IYHOtb/3Q7ravP8TwI0Rz8fjIPN8Ui6B/sz7dNqQGTH8LPuure371BIQACH5BAAGAAAALAAAJgAsAYwAhv//////2Nj//9j/2D7/nj7/dxf/nhf/d//Y///Y2P+ePv+eF/93Pv93F9jY/9jY2Oe2Ps62Vs62MOe2F27nhm7nYMC2F6i2Vqi2MG7Onm7Od27AhueGbueGSOeQF9ieF86QVs6QMMCQF8CGbqiQVqiQMNh3F0jnhkjnYEjOnkjOd0jAhkjAYD7YnjDOSBfYnhfYdzC2hia2bjC2YCa2SAC2bgC2SEionkiodwCQbgCQSOdgbudgSM5uMLZuJsBgbsBgSLZWzs5IMLZuALZIAJBuJpBuAKhIVpBIALYwzrYwqJAwzpAwqCYmJiYmAG4Atm4AkEgAtiYAJiYAAAAmJgAmAAAAJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAj/AAEIHEiwoMGCVxIqPMiwocOHBQUIULgQosWLGDMWDBCAYkKNIEOKHIlRoscrJCGeTMlyoEmPLWO25LhSps2bLV9SxPngQZMmAiX2/InzIsehQAciLcq04VIACRI8bUq1atSpALCyfCrUZ9KqB496JagVbNGnV8eaXWszLVGlam1+BHCyrt27ePPeFTiXbdO5egMLHky4sOHBfFHeBHy4cePEfqkydky5suXLFfu2nIy58066iiMX5ey5tOnSkBcrPo0atGimpFnLnk04NWyPQ4bw2M27g+/fvjkIH068uPHjvnnzrvn6r8cK0KNDp0C9unXqJ7Jrz05duvcK18NT/9i+vfv36OKvk9du/jz46tBt2GA+Grdu5TyAAz/Ovz/x5PjR1xxOJ7mXnnXrcUeBe9MdiF2C7Z3n4IPrRfiddfHNB5NzCeUmHHD45adfcP4NByJ+Iwo4IIEKTTheggoaOOF2DSII4wkWojfjjTk2KN9nYFHkIQcnKjciiSUS+VuIKW644m0JuXgjjgtKuGN2NVY3ZY/vObhllRdS8GNFQSqExJlIAAGEcju06Wabxo0wwg901qnmnWvy9uabwqn4pEwUsSDooBtsEN6U2a2g6KKDEmqoeoguymijLBR6aKSSrkBppY9SV8OnNQBZFUVoppnnbnu6GeecddKJp5pspv+6Q59O/qlaQptaCumUmWpKqa428ppprp1qiamkxFoHaqhkmiXkED748F8HRh6ZJJ3+7Uacn7ayRFF5YFrpJYThhjluheV6JyW50KGAQoZjaiaZQrlFO221I177Q7Y8bFtrtzF9y1660q2LLoNdHggjl1mmt3CV7sKrobwcXmHExUbI2aqrr6Iqa5tqCienxhu/mie3AId00nq9NqoosC8iekLLg75crMyJDlvzCjDjPHOmOgStg6jzJoRxxqy2arLHH4fMwchJ29kxDyinrNHK5NEsqM3BHjvp1jzfjLPWLHBtrMy9Cj10s0z1lNAUUxAhNxH2Dgc1tsXdXfLUHwv/pyZFb1k9ktsK/eQz2WZT6LWiLofdtbDI7tzzjcsGnVDgTREO99x0S2v3yHgTp7fSfMvqNxCAfyV4SIRf3sThOoM9Odqxl+342Yv7KrvYMFa+NuZFX5Hb8EMIIcSIIe525PLMN2nX6lfXJZ271FdvffUIT3/99thn3y734Hv/vbsuuCDf+ROHNiq9xBd/vH7Ji9j8/EfiBX1GdmkP/vbiV7A/9/37H//EV73yoS9e6gte+4bAuQYSYYEQjCADHTg34j3PNfdzSGw+dcAOenBZIAShB0d4vhCasAYkJOEJQ5hC9BGtYgukYAUlSMPcyFBuFqyLbTJ4kA2isIUdXKEI/4F4QCEui4hFNCIHifjCmKQlIU5wggc8wLlSWfGKaLphA7HIRSScJIpl4WFWvNK6K1ShCiHMQQ7UxsY2Ci2IIFSjG+f4xiQuS450nCMc77hGN7qOKU+8QhSnWMUuclGLhTRkqb7ohDDyECllPGMa+5jHNu4RVHisJBsv+alMarKO6JvkHP94EweY0gFlJCQFz3QxRWJRi6w0AhdPYgUrODKDkHwARahAhUl6Um1qVKMS+fhLoQUzB8PEZDDneMxkKhEHOABeS06JSl0qRJUOjKUrrwhLJLQSi7S0ZVzECJeflJGXvqQkG5vpzGMyM5jOrIE73cjOeJ4QmtJkUUKmiP/NuS3gnwtogEAHStCCGrSgAAXoQRtgP3JqsC4GiKhEJ0pRiR7gohjNqEY1WtGKbvSjH+0oRUFKUoxGNIQpSGkKmgioa/LTgQldqExlmtB/LrShDmWIXUTKUwOUtKQ9jehPSRpUnw41pAZAqUpZ6i2FQOCpECCe3GpK1aomVAEKsOo/scrVrAL0gjl9yEkmutGimtWoGT1rUcuq1p5mtIMZiGsGmLoZp0JVqkTQql4BilW9drWvX9VhWMXqEbJytK08ZStiO6rYxY4Uo3CVK11JEsgoTmACqjyT3GY6U6pytqAmMMFJ8jlYgUSyCkc9rEhTC1LHWpS1jZ3oC17QRmj/QpOUbZGKNS2LWSoSQbNE+OxCPStcgYZ2tKorLVmsmZAzwvaibn1uWl2LVukeQKSzra1tcVufhFz2sg4U6F7Hq1CEahWsyjXISS5agPa6F7qPha1733vd+LJ2vu2Fb0TxWwD9vrakHdSAgDUw2ZRQ5LsTCG8DyEteg+oVveklyHoPwF//CvW5Fa6vYeWLX/9m2KM/DfCACwySMorgxCIo1WYHStzidramx/UIaUt72tRG17oaZiyOcwziocIABkFDX0pve4UZp8TEKFZxcFlcUxdzlqoxTl2EC1Ljo97YuleWbpZJ+uMgn2/IOOCuPq+A4AVu9a8MHu9fvfpPCE8Z/zQU2bBJqStnC1M3tneG7AHlOle23YrM3zXzAtac5r0SOrBVK+1Y/ztnOl94uo6urp1d+9Y9S9bPY7aApi0A3Ny02MlMtqpxQytawb55IBSpZaRXzepVzza7bLyBrG9A4pFQZNOcRgIOh/BpUC9Yq6OO8r/enGortPrYyG7rq2kb61nXusS7dcJl++lp8h660AkVtpgjfE4qtBXSqwZ3pMWt1mXJQAZxJbKRSUI43lKb19ZGM7azXWopn3qMu/S2WslNZ37nedJmNTe6M6Du5P65n1Ntsq8P2uuBunnKi64za9eK5aCm1svyOatSU5poW7sUpgpfuHljetCHRzjijP+GLcW1bPGjYtwGGgehSlc67KZ6dwKCPnNX523Vay/A5OkttpyP7e9kX1g+F2XNDgOmkMvmfNDy5nlNfQ505Qqd0URvtNFBjPQDKB2DMaFJ03HevkI7GNuAbbOp3yz25qKWwvjtMYbjbl8Oz1fuCDSN2G3SdkA/fbxnL3Taf772KffduXC/e93vS3eJp5a/eE+f3juSwJlQfp++JZ7UA4/tqitaIXCrKOQX//jGp5zxip9o3kuzd5n0XZWa5znnC+35wVIk9BQdveOPqvvTlz71El29Z1ofE81N4cTAXXHDRf5pbRfZ4Ont9mp3vGWVJ5bLMLj9FCTA/e57HwPgx0D/CUpwJrysm3XWhBvydT038YZc5KEu76iRe298K4SX08dx9Sd+fZD+WPveF4ASEH7iR35edBfnlxF9d1lX5GsNt3wN4HwUk159lxC7Z2P9V3H591P/pxACyH0EOH4iaIC1RxILOAENCGoP+H4EJYGVR4GXpxAXaGUZyHIbWFIdmBAfOIDhN4LjV36FdxbW9BPgNUNS53MM5nwJSE7dVnSO5YSLBYUS1YE/EQFWeIU76H1AuG08MYRNUIS7doRRl2ZKCH3K1YRaN25p6GhSGFFU2ARXiIVZyH1b+HxlcnMgJ3WfxmDhVH+JQRG/VwAEQAByZ3eCSIikx3vuhUBzuIO5/wFFTgA3a3FgCdZAelhVBMWHHlFLfghnChGIg1iIqHeIohiIjNiIAviIghSJU7AWr5d5w3OJepWJ5wV6UzCBg8URFXgFGzVfoZiIQ+WLiDiDJSWMFxZRp4iK3ic3z5YSr7hr1SaLmBh/VKV9uBhWuhiDCdGL7vWLxEhSxgiMPxWO8JWMysh9zIhpznFZT/V3PIeEe1WCOYVyeEZpqsWG99hBFOF9cWiFO9hxcgFo7Vh2sgiPDxaEEFdYp8dq9fiE+XhA+9h9/RgB/1hz3QVol3U0FwN/vyZqwiWPYqQTMrh1JNlTn3JSoIIZS3eRCKaRRsCRs/iRCKlcImmBJXmTFf91kkmVkpexkmOGYEpmUwwnfyMXUEMplAYFkuSEcjiJk6EEKjEQA5bhk38GlFmUV0bJecNFlLSIlAWllGLElE1Zkk/5KVE5lWBXMWVGkFQ1eG05hrS3iVbQiWJ5Vm24b2sYc0dkAzMwA7VGMZy4PjfndGw5dWxWVQZJXn3oh3VpVndpl3kZcEPUl39ZeYHZNsx1BSiWYlc5e1nJkR0JUGVYf1U2VPuHgTf4XPKxLAV3EWW0hOyWmZupZJ4JmtS4AKN5b6X5U6dJg6kJW6sJKq1pEa9phgE5mJXIOe4njZ5ZjTPZHNoHEhMWjKb3aHMHfNYJnOdDAzSgAirQjNA5dmD/2H6heYnNWVNgKZhXIInRA4iKiJ2SNortVYpHhT7c6Z3gOSCUmJEaCZPAdlCkZgLpCJBNQU1zgQAIigDX2EMKOZYluWzAlAOylp+isZ8T4JL+6ZEGFaADapFrYaCKkaAK+oIN0ZgO2moQakwSSmvqmDIWqmDLKYvnqYq00RlUqVMeEYj5xWPxSZ3zZWfS1UH42aIA86IN1JUyWpQJRaM12pNpqRI5+p70RZ/F2GE8GqQHNKQLGhMSIRECkRY9ERVRATdww0++pZzw55WhFWykxqZn4oJNioBN4Dpv8RZimgBi0RM9MQADwEt+qm/Z+Vy9aZrX92OGaqhqc25x9ROw/5kSXuoSXfqluhWmYkqmU2CmMLpwamoCbLqmEUhqb1pvcRoYP0GnSWGnYpqnesqnf4p/vsd/vwmrOnaoh5qoA8eoxnkTj7pcPZGNaRFFZXqm5PlZGgpqDHCsDIBV0VIEzFoER3AEG/MDeMI0pvM5JBOtJuM0xIGrb7GrY9QTXRquAvCnJ9pWnRRMETVbhzpbLdACtaoD56aoGcCtuZoR3koQ1CQQCGpaeuqrugWslyqsK0as0+hryJqsCrCszfqs2Hon1JoqogM60Sqt2Woc9BoUAsCrDyCuXUqu5Rpzx5SuL7CuL9Cu7xqvt8qtXJqxB5GvAICgqsoRgQQ34zmwaf/6mWy6oW1aUJwTPxwzrfETtNT6s0AwLbgqqRxhEHq6sQLAp3x6RoiHmuKYUYe6UbQKZDqQg4dRqs93tADQqCAhs6kaAFERs2SrW28zBTW7ZP6ps57agjtLUD2bPEQLK0IbtG9CtEbLqEgbAEqrpxLhtAMAtW8ntd94UVWrUVcbNFprGFx7sV9br854tmV7tg5htnDDW+4ojWbHsw80BPSDPL1BLSgSur5BJyTitQaRjdm4tE9bBVHUXoM4XTgmjLT7Ue/qGY97qpILFpg7BZpbmJyLbQa1a6ZbJCLCJMeLuh0gHKq7Eayrqq8bu4d4u9Jlu3Pmf4i6NpixuwIBtjn/wbJg+gB3aqlra5teWVxvO1BzqxxqUrencrfx874UiyfbyrfEuapOS7iGO7VHtbjc6xi4yl3gyxKPOr7lS6bnC5rpK1zrK1Dtyxv0uzTyG7QT/Cr3u4Suu79Q27+Hy4G0ajmVMcB2OBAFLIS9GgCWOkWby1dwqYc7V1PE0wM9kCT+cbxHYjKQCxFLKxEe+7EVdbVRNMROgIojeCa1lDrP+ydLyxEr7AEtrHNcNbwxvKTDQ8M23B84PCI6rLL5C67j6qdA3FFCTMRF3IhHjARJXDheLDhLe0YJsX5o+mLFKnIf8AGhtU1XKUPapMd7PDelwrXfK7ld0RM/PMYUdai8/5QQPiiCIfDIkPzIP3iAS7w6b1wFccyZc0xT/8mRd5zHftxN3+TH7JdISCDIkQsRhfwAh4zIU2ioi3wFjTx+kRzJk2yqYbW0REyY9eIDVVyQL2xVNdQ+iPS5wxxDW4QmqLyEpmTIYuzKFKWuMPATUXSO3HfLXdu7T6LLQ8zL0OLLU8y5iUlVxzw8xVzOyGzKy6zNzczKzwzNEiXN1HzG54jNldwc0ZuNAkG43hyNw9tgTCZQ1ZbOxUxBNGTKNtRAn7GlDLqNUjq72WtdGWaO3hfJqTgElio4+ayL+wy1/Qxv/wzQ7ifQ8EbQBd1ABw3IaJLQnLPQJPpQDu2j1RvR1/9rpRTdfRYdgLmR0Tl1pxSBcGx7syQncnmIs0LNlaBFagSKsSJpgzqGY+gjwozsg7Vc1SGw1E/i0x93pAzMgqBW1LYZow0Mt85nr13qntYXq6kV1QHcyFZdy1j9J5QYxVD3y5foloZp1zAczLV4RiQRZw7JajrpQo6xxje6OnMtvHkdztKI11fF1/M2zlXldn89klHIo6412OdDGYb9pDyU2LHXc5CNdqMteKWdZlhF2R5nk5cNcOb6Q4TN2XPp2RkE2rGoVZJt2nothrv9jgqg2iIB2K2N2Yi1RLFd2LPN0N1ioe6Y26h92gzm2C7c2+NFoahm2Y5J3HQ2Qs14mdf/7VDMrdjOHd3QHW9+Vd7Oqdwlit0Ul2zcTaQG4d2H7aIKoWnrVyoEW8cq2Mmayt++Zt2mJNzQHEL5GddPcmsWcN9okt8F29/67WQxKXIA7gAC7soEDt8NjeH0nRBQFVUT5M+Rjd6GJuLnTd2TbUZVUNkxrd0O6doUdeHy3YkZ3uEJDeKkbeK6zdjAjOPoieIqzouRaY8uPlEwPtsyfhDh+tMvZYlezXxN7uBI7eRD/anW/YdX8MGtlWdtVOU5leQuBdQQ6IBPLuZTnqFEKWw/juVIZY9bruGMKZ5kF9o7ruN3TeK4fdpcXuFG15DB+Slc/nnISdc5Lt0hzuPkzeN5/87ee36PqmcDy/Ln8wjngm7Uw3ue82bpnefmOLriVfqjOfZh4qiPmn5v4S3n+l3pSqqHmB6X6r3pQC7TOzpRoD6Dot7qEdYVFDGbnXmbYV2eRi3lUQ7l/xRjjXqnhOOqVOqbajVbnsSFMo7rCqHrwIWkYy3sv27tvQ5lpVbsYnrsgOq/QIVYzK5Ozn7kJwHmY77fZX7U1b7uTm7gE7ZygtpyF9XmkB6WHoHu7o7tYQ2B+y7m8B6l8p7WGWjvox50V1CTo7rwDJ/wE/HSL5ugsdHwtUHbpO7wFJ/xo/oSDiGiE6/xejHfJ7caIF/yX6feH2/yF2TrYZXyKv/yhiHyqf8B84Eh87anPjSf84dh8y6v8zb/eRKm80IvGDxP8kNfEyzPQ9QU4HURBVHwBE/g9Esw9VRf9VZv9UmQ9Vq/9Vff9V6/BFsf9knw9WRP9WLP9WVf9QFPEbNcApEMAiAwkXF4AXRf921Py5AM99z3yNx3McWW9GK09BTe9E8f9VGQ9l5/9lqP+F+v+FnP+Inv+JC/BGuvEG3/9nEv91ZY93Z/95i/9yHQ90bw9xB/5PyaEFIgBVAP9Y9P9UEQBI4f9kow+7Rf+1n/+rgP+7Gv9bXf+0pw+7mv+7ufBL5v+0kQ/MKfBEzABOX+ED2RufRszdJ/jpF8Jmd0wqdGOKm/+k//0PpT//rDn/XFT/vAn/vhT/zj//vHH/znn/7qj/xbv/zN7xDPD7zRP/34n4XVjwTXr82m74kA8UTgkyQFDRZcklDhQYQKHT5cyFDiQYgVI06caNEixoJXPF4BEFLkSJIlAXy8IkFCBJYtL7yESUImiRI1bYbAmVOlypYuYb6cSbMEEiQoTR5FmlTpUqZNk6IcSDDjQ4kaK3KcatUh1qpat3I06rQkSp49I/wEOtPmzZw4d640i/ZC0JpEw4rFm1fv3pAooUApGETwYKyCuRpUkljx4sCDDR9OsliyksaOIUeerLgjSpB4Oad8G1r0aNKlTav8zFf1atZjP/6tTJjj2ePDmTUncUybq+3EsXVj5U05SWrPnE8fR54cNefWzZ2L/Rxd+nTq1a1fx55de2ePSx048Ph9+3jyn8V3fp5evcjy7d2/h2+9L3qk58/Hxx/9/Hr+67ufzC9AAQe8oooq5mvqPwIFRLA/B1lTcEEJJ9TOwAaXipDC9y58sEPo6OPQQxGd+28kK6xIEEQAR0SqRPZUZDFGklwMUUYbPyzpxBRdu3EkGlfsMUgfmROyyKS+u++jpgQQYL67ekQgSgSIM7JHKqvEMiQkwSNyKSadVFJIKafsMkumAgIAIfkEAAYAAAAsAAAmACwBjACG///////Y2P//2P/YPv+ePv93F/+eF/93/9j//9jY/54+/54X/3c+/3cX2Nj/2NjY57Y+zrZWzrYw57YXbueGbudgwLYXqLZWqLYwbs6ebs53bsCG54Zu54ZI55AX2J4XzpAwwJAXwIZuqJAw2Hc+2HcXSOeGSOdgSM6eSM53SMCGSMBgMM5uF9ieF9h3ALZuALZISKieSKh3MJBgAJBuAJBI52Bu52BIzm5Wtm4mwGBuwGBItlbOtlaotkgmtm4AtkgAkG4AqEgwkEgAtjDOtjCokDDOkDCoJiYmJiYAbgC2bgCQSAC2SACQJgAmJgAAACYmACYAAAAmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACP8AAQgcSLCgwYEPHkxZOAUJkoMQI0qcWDAhw4YPKWrcyLFjRYUMHXocSbKkSY4WQ2Y8CTHlQpEsYwp0iVGmTZk0Yd7cyTNmzpU8FxoU2tMjUYJHiyqFmFRg06VQowJ4+jQm1SlSKV7NmnUr1689vdokerGs2bNo06pd6xQr2KVk18qdS7eu3bt4GbYN6zav37973yqN+7ew4cOI9U51u5Nw4scXAwvm2xay5cuYJd90jBmx5smb+3YeTdrv59ALkyT58aOD69ewXd+YTbt27Nu4YdeebRY01ItPnlSocKK48ePITwxfzrz58OTQjTufvjx6dOrUrRuHAaM3XIaqWef/1r3b9vjzsnd7910UuHDi2pFjnx5f/vzm9Y/fxx+f+/qiAgiQUnA++GCDDTokqMMODDZY3oO7HXigggs2yGBtDF6kE3s3BZhSFFGsIOKIJCZnwokoppgciSyuYGKKMK7Y4ogvwoiijDO6eIKINdTwElA9eQgSgQYiqKCFF0KopIRGJojkDhjuoCGQHMYk5EIg5ihijTaagOOMXNr4ZYthxoicljry6GNNXTHEGmscxCnnnHOSZ95tdOYpp2v/VdkYQxQEKmiXKAZKnaCIJkroiYZOl+ijFCxqQqPOQaoojC9k+kJkbS705g966mknbbmFmiefZfnZHqCXEkppc5Yi/yrpq8zFOuiitC5na6A2arqpYr8xBMSwQNyJ3m1Kkopen6rKBCKIzuWn3H781UdttdJhq11223HXHbBRXURsscoei2yyNxzLbLMsPRtFtPldy5y08lZn37zx0tetf+AqFWCAFw0h8BDo3sAkhU8WnOy67HL0rwBmkYmcpGOyWKaKZ2p58Y0Z55ict99W1eG/AQ9c8MFHIqmwkgw3rNHDEVs88aIVlzgzoTXTeHOXOW+JHMicSnURa+MaC5uponZQ3nktu8zRRVJIMd+ukXaZa627ukrB1FlbvTV2IPMLIldD/1B0ubEhfarSuzGdqtMnQS01dlRrzbWtdtPdtY1XL/8X9rdjR0XTwAMLIYSFszHJZJ4iNC4ChU6qbLANs2V41oZwQ+SAAzQtFPUGG/AqKYwqlG66iKarALroo6OYeumom7561a2f+LoKsZc+e4ossOBrj1FjXtTghA9hOOKTK24D445DXiHyB1Yu5eVUZl7Q5p1P8XnotNd+e+6qc1+766+Dv/v4Jny/Qurnn9j77zUEXz1Pm5cs8Lj4E8taEPwHUfz/A8tf/lgjMLTUjzHWu54DFoIABJjFVxDUFA0mSIMeWdCCFKRBBDcoQQpe8IIZ5KAIR/iCDH4QgxTkYNCWcsCFEE6A+Ntf/wAIQBiOi4BDMOACEZjAgRywgQ8koQn/T1iDEJLQV0M8oRGPyMQSepCIS4TgCgfDEA944IU2zB8NaZjF/KHlND0MjFm4w0HuEPGMNfhbGWGARiKqUYRk3KAZ2/jBN05xVQuxIha7SKwt1pCPxPriYsJ4EM5MIY4RnCMdLfjGRLJxkYwM2wgRCUFFQtKO/eIJwKroAUACwY9cBOT/0JKABIjMeqVcSAACEET4QTKSIOPgKy/YSAjOEpbekiUaZSCDU8pkk3nspChB+T9PjvIsqeRhGJO5ylZq6pY9qqUrZynNZ0KzmplqIy99WZIGNrAyU5iAOCfQv/414JzoTKc619mABbjznfBcZwnmSU+1EFIiaDGAPvfJ/89++vOfAA2oQAdK0IIWNIMTjIFCY3DHk3gTAeAcJznLGQR2WpSd8MzoAuRJz3na855MOYtBR0rSkpr0pP1EKA0WytBMjoUhIYhpCP530XZqNKM1rak7BQlSfJbFoAc4AEqHStSi6rNHE8xUBjKAAhQ0FDVTkOlMi6fTm8Yzpxbd6Vl6OhGzAFWoRg2rWAmKVA2+YKlNfeqfoibR/FnVqgqIq1zfStd3miVqXPXpRUwa1KCO1QB9BatYA2vSCKLVqS4NDVvH6da6wlOuc3XsW+8qhbxGxKslJexYNTvYvhYWgodVK0toElMr5u+cdMVqVTXq0bIIz7I0gQIU/krb2v+WVKUK3SabekLaEJgWf6h9q2ovatXWTsmyBontbG3L3Ob+E7cx0O1rZXIRCFgXAkQjlmRvCtm4bheePEUuUn461MD6NazmFaxzAWvevy11qaK1CkOui12zafe7j+0ufrXaNK5iFqXp7Sxn15te9743viy5SFvxt9+6ptOx4RUvOBeS3gr3tQAYLgABCOBPC3v4whnecIc/7OEMa5jD/STxAf6WghRoQAPBCU6wFrLgcTU4teiE8FYlPN6LqDiwJhZxin+c3iCjmJ9ELnKIj7xPFbPYxTCOsdAYUuP7rvPGN72yXXfM4wlPwcImxvB5kZzkoIa5AGNucpkPcOY0t1n/vfoscNhe/GIEx43KjGXwRtWJZY1qmb9v6/JifFzhN4+4zIYeMqLD7GZGw5m9gf0bnTVgZ5IoeJwy5J87h/tn4V40whL+73pHXdshNlWhlS7JpcWZ6SBsmtMPdvCnudxlUZP61mE1NQpQndiTXAmmU70fELLa5+EaVyU8/vVCZIvrZvczggJtgbRbEMGm6lZ+O1F2VIM9hGERG8vGLoFZpgtSbTPb2eiGdkCnTW0IWruX2pMCuamL59PatM/v7LRVQS1esySazIs2cZrjvOZ/qzmo3AlqZ8CY4HoD99743nOs6cpv5Prb0YdOssEJHvAMDxzSK4aBwjMzSMVKQZyN/8VvdxWAb8oK2st89SyuB0xQfi0cAHgNSrxRrmeV67fPLn+5rQtKcwLL3KA2J3nO+bKQmGLx256GdXDBS2seDx3dzs0UaRh+56Zz29sYlbXUIQ7oVIfx6lhnrtZHw3WPlDKZNJ7AuAQ29qnnu+4VLzfJylJmga7ZvH7/O+ANYJYIREACiE88BjAwgsY7voBsucnbTenwYdG97n7Ge9XzCjO+Jznwgn80wEMP1sIfPvGIX7zjH5/DyP8p7imv68ojvuX+9hTtMS86gAdv0oug/vfATzxr8g5VnttYsrOn/QKI71/yGjXA6OV9SX0f/Oojfvib70kzOfkp1jRY3/tl/v89t09oM4c54x3HMPo1vuSMU9/6wR+W7WNC/ilYsfs/+D6fgZ79vNafwiBmYutHZGc2gD9mZO7HEPBXffIXaEsBd/YnTMdXd2F3VRZ1bGbXQ5hFeqJ3cIIHeiTmAi7QI++neBhwARdgeKgHAiAAeRlIEhD4WxNIgftngeyEgb2WVxtIeiD4dz3oYSJIggr4e4uHgiqYeCzogjnoEyDhdU9XgXdHgzn2Tjg4b4RUSjQBIrrngT4YUBw4YgQXhGsSHCxYhmVYfY0HeVZ4E731hOAnhRO3AFU4PyCFhU04BVp4dP/0hV7Ig0MWhiM4hk9ghmaIhiOghnSoSRCzbU5HVVD/+GpwaFPBJX491Hnl92M/2Hd9+Hd/cxGrt3qESIjz90uLKFU09YgSB4evVnZLGEaWyBCaCFB8KIuC14kM8YmOF4pmOIryFXes1n0alXy0l3yUeE9yk3HNtoUGlSn6BDSGkXPcRG++OAH4F4w/N4w/V4yEdIyK1oHMpYwFxYwG4IyFAY3KxFsPID/WJYNA4H37JYz7dWzY1mVZGAW19XHP5437xEEzMAOF4RADMABreBIJoY4QwI7u6HOQhWXyKG+JCFL1eI/6uHsExY/++BcAKZAPaRIpoRrWxXOfgm/w6FhzKGjKRVT4WFQpWZEb1I8/QhEJsSGbM5AcCRIeCQEg//kmInmNklWS9HiH50aRtLWSA2WRLzkRMQkUM7mRVrKIXteIwgZ1mUeBGqWNCQREzpd2tlVtiBWNPdaKTXkRphhAw4aKNjh2Vdl/XIWVe6WVauduXXmOl+WAVDSN1ah8IzlZajkZvDgQQwd9+QiOJAV9BvaCgrFq1AiMeMmTFLeXh0mXGvGX0oeSk1leg1eYYOkbHZkE4mQBFuCGUodjWKWERwka2PMAMNFASUkR5rZcbvlXYphB0sWUmmmTnDkBngmasCaaOUWauzUZp5maCLCaE9Gar0lbsUlBs2k9LRSBCJl/OEWDvDlPvlkahiEQSzcRbMkQx/lX0jZBF8RrXv/pG81pRc85lZgXdQ1Ana1nnYmBnZWlEdu5EN05Vt9ZQRYknnLJHqvUnwGwmRJ1l8r3Xec0LDjonnehGsQJk7bpEEI2eou2YQ/KhewnoUzGcX31N8vZLP65SgCKaYo5oNtVoEBwoAhaFwqKmrS5mQ56oSAXoRJqgCqGYRa6fhoKbzTJHtVVXyEZcXnpWPiHAziwNkuDG2pDJ+lhNB1wEYEzEm35jXq4jBA0egBFSfDFENnpMjsqoH32o3UVpEOKpGyjpK5xpHUypmiDKlgSBarGnc0lmP+kbhhapTDgK1fqOfEJFkKSEHY4eTH2BPdnX2AXiZB4UR1lUWcDIZGDPCv/Ux4WEiqqMV0emhAP8DABEpDu0oUyal4iKIJB1amgGogi6Beq8SMOcaoZkaMjQ6kP0Kdv96eBOi6RGFxYdajslKgPsqgO0qiO2iCQmgSS+p+UaqkCgKnPoqnd+GGg+qmhKoajmhelihGoChOqWhIB8lAEwaqTV0p/+oufIoXW6E4f8AHntJBySE8kkK7qSjiJozwSMieO8ziQkzDJoziPKieNI1tryKrEKltB2Vzsxk/NCqpC+I9IYKqnKhDVShLX6k3ZSqnbmgDdmpjfKp0Z5V0LMK7lGlkdpa7rajL1qjzw2jzzKjnuagP3Gif5CgX7OqyW6q+uCbDTJrADK4aH/+EQCEuttOkvlqqtlBdM9laosyqJ6DRP59RRRtsAuAoh0XMDDKKrScKr0sMgcYKqBlFKq0QQk5oQAQKzGKpic7qJnFqznVqwhuEQ0UoQC2sTxOqzF8GOYCe0s1qoSYu0JUCiw3IylOO0OwC1UCK1U7sDVZuwBYG1AaC1wsq1AuC1L0piYUuL6UW2ZbsmN4sEaTsQazs8lLpKqqEa4pQDoJsDCdmljPldcRW6OSCkZ1oqZhoq6QEbTzKtK+qyjHuczSq7Rwh8LLh6vim77MKqnNu5nxu6o4tlXupYpxu6qrsn49G6rss2sIskvqsR/Lq4/lqftzutuft7u8t64zatXP9huFn7EQlRf7FKLENLt/R0gevbAMJmed3WR8RUPPA7d/ELv34EukfZsglhrHlIZJn4eQbQrJ6Yi2XYeN3Lu0MwvaAhvodLvg9gvh6QXYOqiqloqxyVtO/7SffLwfNLlhscwqCkv2zCvw/gv1EQi3vohwR8iwbcvQnMegzsNB3KSnjGpVclopLlSTeEf2/CwwLkwz/wp6dRw/4pEO5CowQgZuoVekrMxBBaYSW4gInXgIb5FTV8aTh8dzrsWEA8LEJMwV8Mxj5MxCWHuEb8wEl8YlBMoQTIxmjWxCQ2xVQsAVacmVJxxAehbVAZv1A3tHaXTuzJnn5kv1r0wSBMvxz//CPEGSCIO3mTuqYBDMBiG1gEK4jVZ3irt3hJ2HqZq339CRF8/HVl2WmADHGCXAICQ8hbZMj4g8iJjEWI2MgC8MhvF8l4aI+VvGYBfMkLERyZHAGbjAGdXJrGOF8QgLrFe2PHK1mfArp01cwKGVl9SRBREzX1GUu/EjWGt73wx6RsenvIrMzQuZPmimXPnAPRXLrGm42QuRHXLAXZnEvbLAXdfHpUDM6EtJm5SZZoqZ7/bFXgemPjygAM0FqZmxL/OmrSxk/SJo7ZRLkYiQQLmkD8/Jn+HJoArdECbbENVtAHLW6/2REKHbMM3QIO3W76FNGVW9HbeMMhugDSbLos//dWM71dN62X4xlSIPJVEvk3SVcYbaelMN2j7pTTyFvTcMXOzMzU23XFbdHTRDeRJ4VwQP2eZ+wnEQuBC0Y4A42eckuoqZi+F1wCcWV24wtOX8vLu8ysl0xLIbOfAODIfjkFpTReLrPVPxtOeebVHh2dtHrKRHvK6nvWeAwAaT1oU7DWKmyAzXpCSScRdN0Wd13XLx131sWlSC17Tv2OnT3NGAvVOHfN8+yMWRqZDNGkZ4dnmR3Tm73O5+yjn03T5ira8Vza3oKnTpra4dxD/omYW4xjXbxnw213LXfYQxFvSjyhjH2AJ8bcjWtJok1Iv41n3qqTBEp2ymfc263dWP8m2ni63C7qxM893u31SGb7cl1l3XKnP+V8Y+AHbjUYcfGt03KtFW4axTOKcclaYba407XG3j2Mb/Wtf3FI4POtYwCe3PTZ3/stcI/mZGEz3T3F1Xkmq38d1ul5lvtH1jZ4xfW3qWDb1n0lhhdE4Ve411VWwQEdhRbM4bHm4S4O4jbc4PotwJBbYSZuQSieQHaYGrepRxm9m4D94i7+1UeuWgi9sx+xbMs1iyusrJM7R8as3gTx41PguRMg5FHJ0UlOlUWO5BpeU0teEiXd3JSc4xZ2yVQ+0lbO4FNAX2LczrFtzpGFjXUuWeCd3yMFmEX13/dt5Tva2sfXYK9t07P/jdOJnlF7buN9XpkoBehvHlKXZm/cLd8HXmwJrumZTnVoXeO5XID9JOo3/uAZBugLroNlYXzoO4W0V+D7Bev4Bet9WX8gQur7hOtoTmJnhuqB3m+icaLCPuxALhAyNhHb93/EfhfbN+klt+zQ7p6qYexPQBHJDurRXhfNPumGlO3e/hhDbdmK/e1qkXOnLWjdTu7qbhpZ7VNetu5lYe55+nLEmT3wfu9r4QRO4NIFISRRY+/4Hm/8zmP1focBf/Bnoe8DPxD+LgUAj+//rqLODkxlwQQWf/FEkPFEYAQc3/Ecr/Eb7/EdD/IiP/IaX/Iff/IoT/Irr/Ilz/Iv7/Ii/5/x1TzuU7B4iwd8OI/zOr/zGNDzOw/0jDcCd9zjcEPxF3HxGC/zHg/zM8/0Jp/xKG8ETt/0UJ/yUt/yWR/zW//0NW8WQU+EPi/0OS/2YY96O994RY/cocYQSvD2SsADcj/3dA/ydn/3Gk/3eq/3eN/3eb/3gO/3fg/4gU8Ecg8iqf6VwHfPjI/Pdbz4jd/NqHfHzr4RFwH3cU/4PCD4fa/5fM/5d+/5dQ/6di/6c5/xhx8FiV/XCwH5ke/4j496r7+9lF/5oiwgd9gEut8ER3AERfD7wB/8VY/yvV/8vh/8yD/8JW/8vY/8yX/1Is/8x+/8v9/7Va4RWK4aPY+LCP+si4VofarH/Qp8/bYvENq2+7w//dSv/NHP/NQP/Ozv8dL//r8f/x0///Rv/W5OEdmfBNvP/QABQuBAggIlHESYEAOGEQ0dPmw4ZMiUKUiQAMCYUeNGjh09fgQZUuTIjhQpLllSROVKIkR4vITZUuZMmittsnQJ8yVNnjJv3mypc2dPnj9tBuXRo8dLik+eUCQZQGoAilGsRkmYVetWrl29IjRpkuRYsmXNkg2L8idSnUSLGlXJNqbbmXDj5mxL16ddpEqZTnEKdeRUqlOuYv2aWPFiCWEFn4UcWbJHx5UtX8acWfNmzp09b8b4+KMAARQdOPicWjXm06Inv4aNdvWhbNq1bX8OPUUkadOob//O3Fp3bOLFRQoGnlz58rBOneYGSRg58+VSXRvHXnw6de7dPzt/Av2j9OHegVsfnl09bPQaeadfHz9+ggSi6V/n+F7jffjyO/LnCD//BoyuMPdK649ABSUDMKMGQdLPwfoSXPDBjARcMEMAhAtLQw9hq4wsBBAI8cONOBTLRBUxQhHDFV8M0DERSZQRxhYphJGkgAAAIfkEAAYAAAAsAgAmACYBjACG///////Y2P//2P/YPv+ePv93F/+eF/93/9j//9jY/54+/54X/3c+/3cX2Nj/2NjYzrZW57Y+57YXzrYwbueGbudgwLY+wLYXqLZWqLYwbs6ebsCG54Zu54ZI55AX2J4+2J4XzpAwwJAXwIZuqJBWqJAw2Hc+2HcXSOeGSOdgSM6eSM53SMCGSMBgF9ieF9h3VrZgMLaGJrZIALZuALZISKieSKh3MKhIJpBuAJBuAJBI52Bu52BItm4mwGBuwGBItlbOzkhWtkgmtm4AtkgAkG4AqEgwkEgmkEgAtjDOtjCokDDOkDCoJiYmJiYAbgC2SAC2JgAmJgAAACYmACYAAAAmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACP8AAQgcSLBgwQQIE1hZyNCgw4cQI0oEwLDhxIsYM2ocmFBhRSsbQ4ocSfKigJMCPoIsCaCjSpYwC76MSbOky481c+qEiTIlzpgLDQbduXEoQaNEkz5EKpCp0qdQKa48OpWkU6dRhVZtujVr0qtdvYoF2hVrUSsBAqhcy7at27dtuY59ujAt3Lt48+rdyzevXJZ11fYdPPjvXKKBCStezLjxT7MYHzxo0kSy48sfKUumfJhm2rSbKz/ATLq0ac2Tm5QMbdm0Y9ScO8P8HID1aNe4c/OFrRrwRyJEeAgfvqO4cR8+fihfPry58+fGjyf/IXym7K8fU2jfjqK79+7bw6f/aEG+PHnx3L97D0+Bgnbz5tFrV79ePvzy8lPQ706DhnWyFQEHXXQ7ILccc88l2ByBBU5X3U/XIZadePuhkN9958lXIXvujYdhfhva96GG+/X3n00debSQgDxEh5yBB1Kn4IwuvhjjcidGyFKKKlpRIXjiYYgfhT+iJ2SG4f1oYZBHoqdkeDroUBFNPAYYXIvSwXjgjDRmOd2NOepIUpUMPcmkkE4WeeaISaoZ3pEtpBmidlFOKeFCQwzRQw8ccNBBB8/9KaigfRZq6KF9/hnooB1URAUVYmK3UAUVtGfppZZW2B6lnHZaKaag0hfqfpt62imoo4pKgamU9meiRTtV/5TnnokC6hyjhCKqa62LDuoopJHGyhClqGKq6aqsEltspuql2iyyyS7LrKrJuuofrDpZCdygCuLq7beCditomMH6tlB+4SVrKrroquspu/m52ym88llrp7ArAkcEtwmC6y+j4v5JbrlWMUSvvJzSix7ClCosHsMVOByevdjmpO2Vwv0LLpcZ/zswwWdVBPG8Co+ccMkmR4zyuttZK4UUkJlrhb4Y86Dxtxzb7DGEIJekUsoqH5yyw0ATzerErr4c80iy5qknn4UqOty3u1btp63PfdwzRipRq6607R2LsLRifw22mda+unTBeDpNa9RY64yr1btKnTXPW4vU9bPugv9NQdl9Lws4q36jnfa9d1qBxOKMG2HElsQxuAOiI4yAXHGUW/4ijG7lrRFbLIQu+n0bbOBshaKPDl/pp++Xeuikm26skii8zgJ5N9wQZZQ55IC4xQwx3vjjCAon+eSHVn458oYqv/l0nXvO9Vq2x946fdWvLvultNf+uvWzK5l97rvr0PvvMbW20OI0Cy98++6zr2/88gNHP+MqTTFFaNIbdJJk+lOfFfQ3gxlYq4AIROABE6hAVzGwgf15YAEX+EAKMtCCCcQgBGmQwN71rk5WiE1OBFg/ItwPfvFDoftUGL/87S81/SvI/x4QwNsshIAGdKAENThBHVbQhxcEYgb/hbhBCeYwgjsEogdzAEIR1qQiEpAAzYDjtCpa8YpVnOIUsYhFthgmhjJZiUrSljYj/pCMaCSiEdPIRg6acYhtJOMD0QcTKEpxi1zMYxa1qC89VtGLUgGjQ4YyRja+EY5x5GESE6nIMzISiQmko8xEIIL7vY+PWrSkJe3nPracZG3B6sknxfiR8skRgUssnypXubtTOrKDHmSlLFtZRlTGcpayXMEKQBkyK1BSkyXEJCeBuUITdnItoxSkKH3ClYqYspYFTCUuWenKIEJyBtKcpiqrmU1t7k6XvIzMbZzghCh6wANUdFoD1tmABbjznfCMpzznyc52xvMEJ2CLEwVJ/xABLuRRBwioQANagIIWgAAEMIBCFzrQhjq0oQY9aEINMNCIInShDH2oRitq0ItilKIPtZYMZKBLG9jgUfskSWvIaU50EqGK9ZynTGcKz5jeM59rSSk/AeBPKwD0oRadKEY3StQDBFWhHC2oR4daVI0e9aMaFSlJV2BSlPYGJq15WUvTmaea1vOrYAUrTcGKT5XodKcDEaD+PsrWtrr1rXCNq1znSte3wrIGNTDpQs4akqxKYasvdZpXw0rYr471q2XNzFXRahC1TqGukI2sZCc72bvm1QZ7XSxMlGaFKEbxiuukqWhnGtqZLuRlqJUCYx9il484VaJLzWhTHapUhP8SgLawFapsZ8tR2+oWqSFNmy51+Shy5oSznpUAaO052ua+s7QyPW1qVbtag7S2Iq/1LVt5i1vfdte22+Vub8EL1eBaa7grKK4TUIQQO0ZRi4WNLzvlKd+vArK6WqkIXMXr0P3yd6D+/W9A3frB3ZlUrxUTyU0Wklz41rew9H3wOu+LX6ro960CFmiABbzh/xKYiQY+sCRH0ppHXeACv2QccCR8WAmvM7EV4Ss/HeAAx1L2xjjOMV1d4IIXvKB8OMABXhEsY42UmAonTrH8WExaF78YpzHW7GppbGMdW/nKOuaxj4Es5MtmFngLOfGJ41ffCDuZsBSucDMZkmG5tjn/rm/usEBXaVJwJthnDBHzBcgsXzOfGaxpVrNK4oxhDsPZ0HIOKJ1tYOdwOgQ04yynZ6/oXHdCt9LyhDFDiszPKgMXwCAlam1jq9BR/7a8vDV1eP9b0IAuUAUqILKUQwLphbB00lbE9KUxDU9Nf1nNAvF0qDU87OySF6OqLnSqc7tq/rb6AK+ONWZDOGu2WcECFohABBz8510vwMmBrvCgEd3WDA9Y2eRu9kC3rMo67/LO1sa2trndbT/XN9z4HbeH0b1vt5r7AIk+ALvL5+4RW/u9fRyCcxXA8Ibz2rRrAbaFfUoFup4by+UNr44feHG7MhDWsF5IFUZeBZrYkWZd/21uwx3+8Hniu7q/sjjAMZ7xmuOY4zOH6wNBrgKRkxyrt3mUkpGwYhe32MW+pnaFaUxlGw7wsTSnbMevXEAfl4Y3qwk6FYZedCbL9M9J57T0mF5jp6816pOdupWr/oKri0bsEKmItvfY8neunOEPf/lqVfJpYuu4v1YGvFsLmJsvMo0hc3cacOruzrsrIO8Rl/iaF9J3tUu9oVcWfFsJjxvDkwS5ys0140fvTr0zVt/OZjaqU6/d1fNWbY15lHoF8rLNwqyzoa8i6UlverSiXrzJZiqrVS987sKeMbKngnEBUHuRXNcK54yfpbst1njGN+mOjiHfi83fgPPW+w+1+v9HJkD+CWTg/BkogfrXr/7FwWU2gllI9N03ferbdLBhxX5Y8v2Rynef3//nb9wlfhVRfuaHfuzHfu73FmCGeyincCp3d7tXepEnedv3d34XWWoHapTlcwb4gSBYfnmiEiOHLw6YcAsngRPYezt1gTnGgRqYc7uFYx4YgjZIfiP4ESVYEyvlBOf0gCm4crsXdtXGWMK2YWgHUs1GWeJHGTd4gwv4ayMUaT+IghEohKRHhJJ3hOiWhBuYgZDVhE3whDYYhUqXLQyBcLo3U443gQuwcizITy4oWZqHY3UYWZy3EGQYgjlocHjGYHe0hjLVhhMIhxUocXMYgzBoh5h3Y3n/aAV7CIJ9CG9A909bV0kqRgROdnQSpoVo1RNkx4VJOIpvxW6ZBQEQgAGquIoJmIALCHd9pXVcp4lG12RO5ok7BYpMJ4qk2IsYZYrUhoqryIqtuH6vWIRkkVxVtCduSIijFYeClIiXZ3lzRY1ICFJkZIkGiIrcyI0gqDW+oYxu0wPNqILPeIjAJo1pB4Z1ZY1diI2HQ3Hb2I3e+IHgqBE9URGUNIv391z214/11wDQuDVkcmECSGjqFoDldgBRomi74xieNxL5yBD7iIlLNl/W948YiX8D2TMFyRDg11QhWVT+1ZAM+ZCNEZEyI46z0gNYuHvO6HLoKGiuJYMY6I50/8iOGGVEMRADjKGSf4h7nzWOL0l6MSlPHdk/44Zxi/iCOrlQPOmTiwGUG/F8LClYzVV9u5eU0vN73BVRBZWQyxZRYtlQaQQDMCBd06MVOWGVuCaIoqWVvDeT4laTw0eWrveVYFmWA3WWaWkFzTcRYCEpvrSPfCaXAfmPSEmXq9VedmmTeSleI0lUcLVofhhGl3l4C1GRh2lYGamRzPVOXEmQPbIQTVl8/baQCPlRlkmJg4Q3AAJ95+RSNONtoGmb9sWYsnGPmAmS65iaB6mQCjVEjbZ/EVIRs0mb+oKboGlvAqmbncGbE0d5vymcqmmdxPlu2ZcVR5ZkFkl0tBhfnP94ZmYohdfBP2kFQxfBi75IitHkQbJGMN2JYt/ZdRBmi91WnmcYIegZbOo5EezZnkn4nr0TnyAjdxGAcDTzcEdZaZOoGykZSBmBepnXiDf5lMP5cT3nmruJeAl6RwvKaw3qXA8KoVMpodODXRiqiCsKWXe4kxqamXOhj4bpPmX2mWGVmIiFTyewOBNmoozhmJ/zmJL5jkUanBrlY+x2XtppnNdBo0Pno32Go9V3fTwqpUAapB4xpCoKnKvnf5QJgA6lpD+mA0wqo2NhR3lSBGxaBM5FfaO1TvHjOAsiOZnzPF9SPFjCIJkjnb0poJL1QJBVPr2jARrgp1GhpkPQpm7/mpX1FpcNMKdGUKd8mjyaszk3QqkE0qewmaJWAKh4yECDujuFeqidqhSSIRm00RHkdGuU5oaOemn1RDM3IyjKoTEdYzc8cCC7QhkylqoPMADCOqzCmnxgWQCglmHHmqRkqqRRQoAfwVn61ASZ5au+KhCwyBLAuqoJ0aqS9qqwCqmyyk60WqsdcKv/kqtxw6u6Yq0RAazESqzGCpbJKmDLGn7Nym7QWhHSmlPUSm3WGhvZCnSSIazAKl1VWJs5Sk/2xwAMwHA8egIf8AEmULEmcAQYewSQczy7UjmVgzmF4rEei6nLgSjuChEzJBnLpD9nB6q/mK9lyhiUUa3XCgAD/6utqWqwqYqwymmfAOmP1OewEMujE2uxF5uxG2unuiKyINsnIus8WvIDJluzD5GyD7CyLOuyHwWzMbsYMwuwNXuzMIEQqhoA3jqUcBmuumZPecIiXGKucGurJcsBJytOBTsAyddUQVWvd4msAuesUrIX6iVd1ooUYhsTZPsAaXG2uYeVastrpdW2NRMwcVur7Fq365mzeCt7ettRt0VsympQAUWmIKQXgwuYUlC4VXG4E4EACEAQrttYqfp8lERv4tlkhxWx9YRP9SQEvisEQRAEmQO1NhIjxqO0zfO0NxKwyNhPD0BjJ8GyUKe1bJWv0rsQxVgCIbC9IaCASGBWAf+bFLE7EOPrvGVLo7Z7n18XmhGmu+zEu+z0u8ArvJZKvFGrHMdbqckrsssbvpkLvQIgvdTbVtbLsthbjNzbvcb4vYqFuWMBrAKxuK2Kto57hSznhpKbTlrkR3kkTAmXJ8KzJ4tzsjJGdj0hwAO8UGTqW966h+p3fuq3J8wbLBAMABLsqqIXhBc8gRkcWBvMwVjkwVw1BCHcAyMctshowiiBwilsACtsWy1Mhi+cfiUgw/4rn6lKTlrVuCknTyPaco43q3gExFYkxIFFxhh7xEMBd8DKxE0MUmQaxTaIiuSHiuqHsTTbM8CqxX/FxRDoxeZolHcnxg9IxnvkwYY8BGn/jARfi63Nm54AlLVvDFxx3KpPSMcTYMclgMdgKxu6SHZkh5w9SwTrC6fzBAIg4L4RK6WYtDhsSkwpJEyLA8KMs8hm+BflKxEjR51Rx2M8plC+7Ms6NwMVoYr0yI3DqIokQAK3fB2fDMo0JspaVMqPKk+orMpXigTr1MpI8MqwfEncTMuLY8sMTEgrkcsRscufinbBDMzB7ALDXMwYcMzCmMzL3MyeLAACcRL5VZidWaX2dJsBPdByaqO1WFoC/aMy+pGnuVteWnyrVBEJbIPby36IShT8DAAZPXFRqs33idC3OX0B+c9TCtICzZsMvaL/tmERzRATHYIVvX4XTRM9/+G6ZGfTDuC6rivNZ/zH32Z/47mJ+Pln8IR3C4DKQwu/aDoQE8nLWPbLCwXVUA2jARVJEbqdJVHTCHDTW53TOs3TcKmYQ31mQV2Ljfd4Rw0CSX0CCu2kVYsSBvnU8BzVcz3VUDkDVY1AEImi5dLU/mzQNmXSGinSP92cP62jhn2ZPLJg64yk1omaJ9nSP8nXoQTXFPmdUhrYBD3Yh13YnC3YAk2Ba7PYCRHXfDlbciZLe43VNUFjOL3TDJGcQ4x/RD3WQk3NtS1TERuxS73Plu3UvvjOvqza8JbRNPYXx03ZneHaXQ3b8jebsw201cywpozbZD1Tu82jva3Rv93Y7f8p3DxG3GZh3A6A3OWt3IdxEtAczbEN3VNk3bdN3dPtnPENT9d8Ag673QShzgNs171j1WujizOtE+q93qKcsPoC32Yt37nN4NdtzamM3wyg3wPB39Tr3zkA4G7N3QU+4F5x4C6Vto874iTube40exdBG7TRpUaleucWuggVlkoIjxTD2tHY3lUo4iS+47Bq4guA4hOh4p/B4sn24vYqUTJu5NnIoTT53Ai+eFQK1FFe3dIt1rT9nDYuFU69mqfdl/GY5dqH46NM3/Pt2VZe5VJ+5RS+ZpD9fYfWVEsO5v1DclXQYO9daV/MoIE8ej5+1kW5mFlu2jeGk3E1R0xeYXT/buchqsNGDZN7znh9/oaPDk9rruXezYg3x0CVHuaAOJSLjuZuiJiQ7pm7B2iHHndsBlT0Cpl9+2wKFecbXpedHnqfrqOhTuqkJ+p1Z+qBnuq4FVFfCHyr/upfHuv8N+skfbtX7mQMx5y4HtpTzk6VzuJHKqZFtUCbrpRp6FnJrr5ozuwK4Oz9CO3LLu2nvhS+/tiRee06lO15oxIUnHJ5LqKTDsb1ruc0VRE7yKW+GZxMCbrQVuxy3jPw7sd+vsOjN++YpvB4jtbRxRD7PqH9944VquQCb+xjV3ZREAU9laUen6Ub358QEckd//F4UUOsGylNF/JOZ/Iurxssz2kk/9/yL38XKP/INz55Nb/zpUGVAsHe7M3zeZFMiEhKQn/0l+HzAAD0DoD0eEH01XUT0+n0VK8XrRURE+mYVd8WUN+YpV0VWx/2eXH1KGvZWi/2H9H16bgWUND2bs8EcB/3SjD3dF/3SXD3SbAEer/3fK/3cS/3dR/4eJ/3fV/4fw/3gS/4eF/4hn/4iQ/3fnr2eniD6EfF7JfAmM+9T1j5raifA3+gbO/2bX/4TJD4dr/4jM/3pG/6dD/4qa/6js/6SuD6r+/3sV/3kH+qDyH5kEj5CJiAmZ/5m//73juaLcgQT5D8TzD4zE/4tc/3zR/9qF/7QAAEei/90v/8fY/90f/P99POEMO4zMvcisJffseczPNMj+gv/sxczhhf9Auh/MuP/doP/dzP/Npf/dd//7Rf/0vA/wCRRGCSJQWXWEFoBcBChg0dPgSQ0AoGihhIXCRRQuPGEB09TgA5AcJIkhUrkixp0iJGJEgkQoQZU+ZMmjVtNpQIRScUgz19FhwYVOhPokSFHiVYVClQpEGXLn1586FEkxutcvTYEeVWCCoxXL2atSMRIlGlnkWbVmrOnU8NNnXq1ihcgXLn0rX702xaqhXBWhUbgitKr3+xZiW7V+1ixmkfPEBYpcqTJ3SPAsGcWbNmy0g3f87c+TLoz6KTMGEisUkTqY8lOnESUvbzbJCDSdLGnVskSY2qWTcGHvymayuSKZsWSLo08uTKOTNP4vx5Z9S+W0NOCFv3bNsjt3/fPbJ3wtXCzZ+PKVH9evbt3b+HH1/+fPrtFyKk6cABQgQI6v8H0D398EOvQOECRDBBBRf87z6FZhrQiv4YpBC+CA3EsDECK+SwQw/ti+hBmiRz8MMKSQSACioyZJGvB02EMUYFHbQJRRkZRFHFFne8iUCcROQxyPN8ZIhImYwMUcj0gKRRSSd/nIrJJ6dcS0okYULySiezlJLKICWSQgovxzwrgADWQwtNMn9UbE0ewRTTTTlhMlPNKtsc0845ZQoIADs=\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "ditherbig = Image.new('RGB', (wi,hi))\n", "for x in range(0, wi, wd):\n", " for y in range(0, hi, hd):\n", " ditherbig.paste(dither, (x, y))\n", "for y in range(hi):\n", " for x in range(wi):\n", " pixel = ditherbig.getpixel((x,y))\n", " ditherbig.putpixel(\n", " (\n", " (x+y*fixedShift[y]*2)%wi,\n", " fixedShuffleOrder[y]%hi\n", " ),\n", " pixel\n", " )\n", " pixel = ditherbig.getpixel((x,y))\n", " ditherbig.putpixel(\n", " (\n", " x,\n", " (y+random.randrange(hd))%hi\n", " ),\n", " pixel\n", " )\n", "\n", "fuzzmask = Image.new('L', (wi, hi), 255)\n", "draw = ImageDraw.Draw(fuzzmask, 'L')\n", "for y in range(hi):\n", " if fixedShift[y]==1:\n", " draw.line([(0, y), (wi, y)], fill = 'black', width = 0)\n", "fuzzmask2 = Image.new('L', (wi, hi), 255)\n", "draw = ImageDraw.Draw(fuzzmask2, 'L')\n", "for y in range(hi):\n", " if fixedShift[y]==2:\n", " draw.line([(0, y), (wi, y)], fill = 'black', width = 0)\n", "\n", "frames = []\n", "\n", "filename = \"out/lf-small.gif\"\n", "\n", "frameRange = (0,35)\n", "duration = frameRange[1]-frameRange[0]\n", "#linger = (0,0) # how long to linger on the first and last frame\n", "\n", "for frame in range(0,duration):\n", " image = Image.new('RGB', (wi, hi), (255,255,255,0))\n", " draw = ImageDraw.Draw(image, 'RGBA')\n", " #eased = easeInOutQuad(frame, 0, math.pi, duration)\n", " eased = 0 #easeInOutQuad(frame, 0, 1, duration)\n", " perspective = Perspective(Point2d(wi/2,hi/2), 5000)\n", " #rotation = Rotation([1, 1, -0.005 * eased], 0.01 * eased);\n", " rotation = Rotation([0, 1, 0], eased*2*math.pi);\n", " scalefac = 0.4\n", " fixedRandoms[0] = (56+eased*(hi*4))%hi + random.randrange(5)\n", " drawObject(letterL + letterF, perspective, rotation, Point3d(150, 160, 0), Point3d(74, 76, 0), Point3d(1*scalefac, 1*scalefac, 0.5*scalefac))\n", " \n", " cleanimage = image.copy()\n", " \n", " image = postprocessing(image, cleanimage, ditherbig, fuzzmask, fuzzmask2)\n", " image = image.resize((wi*2,hi*2), Image.Resampling.NEAREST)\n", " frames.append(image)\n", " \n", " #if frame == 0:\n", " # for n in range(linger[0]-1):\n", " # image = postprocessing(image, cleanimage, ditherbig, fuzzmask, fuzzmask2)\n", " # image = image.resize((wi*2,hi*2), Image.Resampling.NEAREST)\n", " # frames.append(image)\n", " #elif frame == duration-1:\n", " # for n in range(linger[1]-1):\n", " # image = postprocessing(image, cleanimage, ditherbig, fuzzmask, fuzzmask2)\n", " # image = image.resize((wi*2,hi*2), Image.Resampling.NEAREST)\n", " # frames.append(image)\n", " \n", " clear_output(wait=True)\n", " print(\"Frame \" + str(frame))\n", " display(image)\n", " #image.save('letter-cubes2' + str(frame) + '.png')\n", "\n", "clear_output(wait=True)\n", "frames[0].save(filename, format='GIF', append_images=frames[1:], save_all=True, duration=60, loop=0)\n", "with open(filename,'rb') as file:\n", " display(IPImage(file.read()))" ] }, { "cell_type": "code", "execution_count": null, "id": "4eb9a257-e683-41f0-a9a7-1009d2cee45e", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.3" } }, "nbformat": 4, "nbformat_minor": 5 }