{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "bmTf8Nr0ifCU" }, "source": [ "# 머신 러닝 교과서 3판" ] }, { "cell_type": "markdown", "metadata": { "id": "urDF4hh_ifCV" }, "source": [ "# 15장 - 심층 합성곱 신경망으로 이미지 분류 (1/2)" ] }, { "cell_type": "markdown", "metadata": { "id": "R5cTA0rXifCV" }, "source": [ "**아래 링크를 통해 이 노트북을 주피터 노트북 뷰어(nbviewer.jupyter.org)로 보거나 구글 코랩(colab.research.google.com)에서 실행할 수 있습니다.**\n", "\n", "\n", " \n", " \n", "
\n", " 주피터 노트북 뷰어로 보기\n", " \n", " 구글 코랩(Colab)에서 실행하기\n", "
" ] }, { "cell_type": "markdown", "metadata": { "id": "f27nCXbrifCW" }, "source": [ "### 목차" ] }, { "cell_type": "markdown", "metadata": { "id": "2_7fyte5ifCW" }, "source": [ "- 합성곱 신경망의 구성 요소\n", " - CNN과 특성 계층 학습\n", " - 이산 합성곱 수행\n", " - 1차원 이산 합성곱 수행\n", " - 출력 특성 맵의 크기를 조절하기 위해 입력에 패딩하기\n", " - 합성곱 출력 크기 계산\n", " - 2D 이산 합성곱 수행\n", " - 서브샘플링\n", "- 기본 구성 요소를 사용하여 심층 합성곱 신경망 구성\n", " - 여러 개의 입력 또는 컬러 채널 다루기\n", " - 드롭아웃으로 신경망 규제\n", " - 분류를 위한 손실 함수\n", "- 텐서플로를 사용하여 심층 합성곱 신경망 구현\n", " - 다층 CNN 구조\n", " - 데이터 적재와 전처리\n", " - 텐서플로 케라스 API를 사용해 CNN 구현하기\n", " - 케라스에서 CNN 층 설정하기\n", " - 케라스로 CNN 구성하기" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "id": "177002meifCW" }, "outputs": [], "source": [ "from IPython.display import Image" ] }, { "cell_type": "markdown", "metadata": { "id": "QhoWUw-DifCW" }, "source": [ "## 합성곱 신경망의 구성 요소\n", "\n", "### CNN과 특성 계층 학습" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 305 }, "id": "Z1yJcNPqifCW", "outputId": "4af6db10-33a5-4ae7-a345-332a9e1d75ee" }, "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 2 } ], "source": [ "Image(url='https://git.io/JL5O3', width=700)" ] }, { "cell_type": "markdown", "metadata": { "id": "n1CfLNUSifCX" }, "source": [ "### 이산 합성곱 수행\n", "\n", "#### 1차원 이산 합성곱 수행" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 278 }, "id": "GKOpZy2TifCX", "outputId": "1b0e570d-5979-4c4d-b541-e85532338640" }, "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 3 } ], "source": [ "Image(url='https://git.io/JL5On', width=700)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 454 }, "id": "E3J3_NTNifCY", "outputId": "99b78ead-c430-44ee-804f-e8646e13e2c8" }, "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 4 } ], "source": [ "Image(url='https://git.io/JL5O8', width=700)" ] }, { "cell_type": "markdown", "metadata": { "id": "4FylyB5IifCY" }, "source": [ "#### 출력 특성 맵의 크기를 조절하기 위해 입력에 패딩하기" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 212 }, "id": "atIWe4jRifCY", "outputId": "75ec7740-a3a4-4e01-8cbf-e1d36ba0cfb4" }, "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 5 } ], "source": [ "Image(url='https://git.io/JL5Ow', width=700)" ] }, { "cell_type": "markdown", "metadata": { "id": "fjCOUYGWifCY" }, "source": [ "#### 합성곱 출력 크기 계산" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "kLmHMacdifCY", "outputId": "f5e8707b-7c43-4c8b-fbb8-d16ce4662b31" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "텐서플로 버전: 2.14.0\n", "넘파이 버전: 1.23.5\n" ] } ], "source": [ "import tensorflow as tf\n", "import numpy as np\n", "\n", "print('텐서플로 버전:', tf.__version__)\n", "print('넘파이 버전: ', np.__version__)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "15FDd_AMifCZ", "outputId": "c999ad77-6990-4018-97fa-eaa5652899e1" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Conv1d 구현: [ 5. 14. 16. 26. 24. 34. 19. 22.]\n", "넘파이 결과: [ 5 14 16 26 24 34 19 22]\n" ] } ], "source": [ "def conv1d(x, w, p=0, s=1):\n", " w_rot = np.array(w[::-1])\n", " x_padded = np.array(x)\n", " if p > 0:\n", " zero_pad = np.zeros(shape=p)\n", " x_padded = np.concatenate(\n", " [zero_pad, x_padded, zero_pad])\n", " res = []\n", " for i in range(0, int((len(x_padded) - len(w_rot)) / s) + 1, s):\n", " res.append(np.sum(\n", " x_padded[i:i+w_rot.shape[0]] * w_rot))\n", " return np.array(res)\n", "\n", "\n", "## 테스트:\n", "x = [1, 3, 2, 4, 5, 6, 1, 3]\n", "w = [1, 0, 3, 1, 2]\n", "\n", "print('Conv1d 구현:',\n", " conv1d(x, w, p=2, s=1))\n", "\n", "print('넘파이 결과:',\n", " np.convolve(x, w, mode='same'))" ] }, { "cell_type": "markdown", "metadata": { "id": "22WjlUkgifCZ" }, "source": [ "#### 2D 이산 합성곱 수행" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 413 }, "id": "vOAuCO9kifCZ", "outputId": "5061c287-0944-4c74-a957-8ed2d796e745" }, "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 8 } ], "source": [ "Image(url='https://git.io/JL5OP', width=700)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 352 }, "id": "il5jQ-mZifCZ", "outputId": "f082f230-92a7-424f-c86a-5a028d47d5cb", "scrolled": true }, "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 9 } ], "source": [ "Image(url='https://git.io/JL5OD', width=600)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 374 }, "id": "TVLqLnMXifCa", "outputId": "7120254d-01a3-4ba0-9e9e-84f56381b730" }, "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 10 } ], "source": [ "Image(url='https://git.io/JL5OS', width=800)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "I8VBXnCjifCa", "outputId": "145fd0b6-cb95-4355-d4fc-957902f758c3" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Conv2d 구현:\n", " [[11. 25. 32. 13.]\n", " [19. 25. 24. 13.]\n", " [13. 28. 25. 17.]\n", " [11. 17. 14. 9.]]\n", "싸이파이 결과:\n", " [[11 25 32 13]\n", " [19 25 24 13]\n", " [13 28 25 17]\n", " [11 17 14 9]]\n" ] } ], "source": [ "import scipy.signal\n", "\n", "\n", "def conv2d(X, W, p=(0, 0), s=(1, 1)):\n", " W_rot = np.array(W)[::-1,::-1]\n", " X_orig = np.array(X)\n", " n1 = X_orig.shape[0] + 2*p[0]\n", " n2 = X_orig.shape[1] + 2*p[1]\n", " X_padded = np.zeros(shape=(n1, n2))\n", " X_padded[p[0]:p[0]+X_orig.shape[0],\n", " p[1]:p[1]+X_orig.shape[1]] = X_orig\n", "\n", " res = []\n", " for i in range(0, int((X_padded.shape[0] -\n", " W_rot.shape[0])/s[0])+1, s[0]):\n", " res.append([])\n", " for j in range(0, int((X_padded.shape[1] -\n", " W_rot.shape[1])/s[1])+1, s[1]):\n", " X_sub = X_padded[i:i+W_rot.shape[0],\n", " j:j+W_rot.shape[1]]\n", " res[-1].append(np.sum(X_sub * W_rot))\n", " return(np.array(res))\n", "\n", "X = [[1, 3, 2, 4], [5, 6, 1, 3], [1, 2, 0, 2], [3, 4, 3, 2]]\n", "W = [[1, 0, 3], [1, 2, 1], [0, 1, 1]]\n", "\n", "print('Conv2d 구현:\\n',\n", " conv2d(X, W, p=(1, 1), s=(1, 1)))\n", "\n", "\n", "print('싸이파이 결과:\\n',\n", " scipy.signal.convolve2d(X, W, mode='same'))" ] }, { "cell_type": "markdown", "metadata": { "id": "RHePysibifCa" }, "source": [ "### 서브샘플링" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 366 }, "id": "kc1ZMqcLifCa", "outputId": "87802ea2-ea9b-4bd8-a07e-3ef36cdde60a" }, "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 12 } ], "source": [ "Image(url='https://git.io/JL5OH', width=700)" ] }, { "cell_type": "markdown", "metadata": { "id": "57cBF6lxifCb" }, "source": [ "## 기본 구성 요소를 사용하여 심층 합성곱 신경망 구성\n", "\n", "### 여러 개의 입력 또는 컬러 채널 다루기" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 422 }, "id": "VdJuRn5AifCb", "outputId": "3a2d55c3-30cf-4390-9199-1493c99d5942" }, "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 13 } ], "source": [ "Image(url='https://git.io/JL5O5', width=800)" ] }, { "cell_type": "markdown", "metadata": { "id": "ldWAgzDQifCb" }, "source": [ "**팁: 이미지 파일 읽기**" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "U2_UgtcxvuJj", "outputId": "a069ed2b-de06-49df-adb0-1b77a4a13a5d" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "--2023-11-10 05:55:47-- https://git.io/JL5Ob\n", "Resolving git.io (git.io)... 140.82.112.21\n", "Connecting to git.io (git.io)|140.82.112.21|:443... connected.\n", "HTTP request sent, awaiting response... 301 Moved Permanently\n", "Location: https://github.com/rickiepark/python-machine-learning-book-3rd-edition/raw/master/ch15/example-image.png [following]\n", "--2023-11-10 05:55:48-- https://github.com/rickiepark/python-machine-learning-book-3rd-edition/raw/master/ch15/example-image.png\n", "Resolving github.com (github.com)... 140.82.112.3\n", "Connecting to github.com (github.com)|140.82.112.3|:443... connected.\n", "HTTP request sent, awaiting response... 302 Found\n", "Location: https://raw.githubusercontent.com/rickiepark/python-machine-learning-book-3rd-edition/master/ch15/example-image.png [following]\n", "--2023-11-10 05:55:48-- https://raw.githubusercontent.com/rickiepark/python-machine-learning-book-3rd-edition/master/ch15/example-image.png\n", "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.111.133, 185.199.108.133, 185.199.109.133, ...\n", "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.111.133|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 22283 (22K) [image/png]\n", "Saving to: ‘example-image.png’\n", "\n", "example-image.png 100%[===================>] 21.76K --.-KB/s in 0.002s \n", "\n", "2023-11-10 05:55:48 (14.0 MB/s) - ‘example-image.png’ saved [22283/22283]\n", "\n" ] } ], "source": [ "# 코랩에서 실행할 경우 이미지를 먼저 다운로드합니다\n", "!wget https://git.io/JL5Ob -O example-image.png" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "2lQymxAJifCb", "outputId": "e4358781-e621-464f-cb83-41cd26ff2d64" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "이미지 크기: (252, 221, 3)\n", "채널 개수: 3\n", "이미지 데이터 타입: \n", "tf.Tensor(\n", "[[[179 134 110]\n", " [182 136 112]]\n", "\n", " [[180 135 111]\n", " [182 137 113]]], shape=(2, 2, 3), dtype=uint8)\n" ] } ], "source": [ "import tensorflow as tf\n", "\n", "\n", "img_raw = tf.io.read_file('example-image.png')\n", "img = tf.image.decode_image(img_raw)\n", "print('이미지 크기:', img.shape)\n", "print('채널 개수:', img.shape[2])\n", "print('이미지 데이터 타입:', img.dtype)\n", "print(img[100:102, 100:102, :])" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "qo8Ybg9wifCc", "outputId": "a5bd2905-7756-4a5f-bfea-d5102b8ea1e7" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "이미지 크기: (252, 221, 3)\n", "채널 개수: 3\n", "이미지 데이터 타입: uint8\n", "[[[179 134 110]\n", " [182 136 112]]\n", "\n", " [[180 135 111]\n", " [182 137 113]]]\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ ":4: DeprecationWarning: Starting with ImageIO v3 the behavior of this function will switch to that of iio.v3.imread. To keep the current behavior (and make this warning disappear) use `import imageio.v2 as imageio` or call `imageio.v2.imread` directly.\n", " img = imageio.imread('example-image.png')\n" ] } ], "source": [ "import imageio\n", "\n", "\n", "img = imageio.imread('example-image.png')\n", "print('이미지 크기:', img.shape)\n", "print('채널 개수:', img.shape[2])\n", "print('이미지 데이터 타입:', img.dtype)\n", "print(img[100:102, 100:102, :])" ] }, { "cell_type": "markdown", "metadata": { "id": "pRudlk4_ifCd" }, "source": [ "**노트: CNN 입력을 위한 흑백 이미지의 랭크**" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "LeRSnSZEw45S", "outputId": "b19eba7f-611f-425b-d02d-c66c2b5562da" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "--2023-11-10 05:55:52-- https://git.io/JL5Op\n", "Resolving git.io (git.io)... 140.82.112.21\n", "Connecting to git.io (git.io)|140.82.112.21|:443... connected.\n", "HTTP request sent, awaiting response... 301 Moved Permanently\n", "Location: https://github.com/rickiepark/python-machine-learning-book-3rd-edition/raw/master/ch15/example-image-gray.png [following]\n", "--2023-11-10 05:55:52-- https://github.com/rickiepark/python-machine-learning-book-3rd-edition/raw/master/ch15/example-image-gray.png\n", "Resolving github.com (github.com)... 140.82.112.4\n", "Connecting to github.com (github.com)|140.82.112.4|:443... connected.\n", "HTTP request sent, awaiting response... 302 Found\n", "Location: https://raw.githubusercontent.com/rickiepark/python-machine-learning-book-3rd-edition/master/ch15/example-image-gray.png [following]\n", "--2023-11-10 05:55:52-- https://raw.githubusercontent.com/rickiepark/python-machine-learning-book-3rd-edition/master/ch15/example-image-gray.png\n", "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 8501 (8.3K) [image/png]\n", "Saving to: ‘example-image-gray.png’\n", "\n", "example-image-gray. 100%[===================>] 8.30K --.-KB/s in 0s \n", "\n", "2023-11-10 05:55:52 (80.7 MB/s) - ‘example-image-gray.png’ saved [8501/8501]\n", "\n" ] } ], "source": [ "# 코랩에서 실행할 경우 이미지를 먼저 다운로드합니다\n", "!wget https://git.io/JL5Op -O example-image-gray.png" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ZyCzEMJOifCd", "outputId": "f62dfe13-fce4-4643-a527-cd289937140e" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "랭크: 3\n", "크기: TensorShape([252, 221, 1])\n" ] } ], "source": [ "img_raw = tf.io.read_file('example-image-gray.png')\n", "img = tf.image.decode_image(img_raw)\n", "tf.print('랭크:', tf.rank(img))\n", "tf.print('크기:', img.shape)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "OwY7M7mxifCd", "outputId": "2acabf18-971f-494d-a9b1-0f246d0952f7" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "랭크: 2\n", "크기: (252, 221)\n", "새로운 크기: TensorShape([252, 221, 1])\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ ":1: DeprecationWarning: Starting with ImageIO v3 the behavior of this function will switch to that of iio.v3.imread. To keep the current behavior (and make this warning disappear) use `import imageio.v2 as imageio` or call `imageio.v2.imread` directly.\n", " img = imageio.imread('example-image-gray.png')\n" ] } ], "source": [ "img = imageio.imread('example-image-gray.png')\n", "tf.print('랭크:', tf.rank(img))\n", "tf.print('크기:', img.shape)\n", "\n", "img_reshaped = tf.reshape(img, (img.shape[0], img.shape[1], 1))\n", "tf.print('새로운 크기:', img_reshaped.shape)" ] }, { "cell_type": "markdown", "metadata": { "id": "Zy4sB8jVifCd" }, "source": [ "### 드롭아웃으로 신경망 규제" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 380 }, "id": "Lrc2CPzwifCe", "outputId": "d7c6b80b-c0f0-4d9b-ae6a-7ae6bc2d7029" }, "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 20 } ], "source": [ "Image(url='https://git.io/JL5Oh', width=700)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "id": "Mp-rHuGVifCe" }, "outputs": [], "source": [ "from tensorflow import keras\n", "\n", "\n", "conv_layer = keras.layers.Conv2D(\n", " filters=16, kernel_size=(3, 3),\n", " kernel_regularizer=keras.regularizers.l2(0.001))\n", "\n", "fc_layer = keras.layers.Dense(\n", " units=16, kernel_regularizer=keras.regularizers.l2(0.001))" ] }, { "cell_type": "markdown", "metadata": { "id": "Kv1zkQutifCe" }, "source": [ "### 분류를 위한 손실 함수\n", "\n", " * **`BinaryCrossentropy()`**\n", " * `from_logits=False`\n", " * `from_logits=True`\n", "\n", " * **`CategoricalCrossentropy()`**\n", " * `from_logits=False`\n", " * `from_logits=True`\n", " \n", " * **`SparseCategoricalCrossentropy()`**\n", " * `from_logits=False`\n", " * `from_logits=True`" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 358 }, "id": "iOAinQEQifCe", "outputId": "64d22161-ad63-4724-daa6-500b4968947e" }, "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 22 } ], "source": [ "Image(url='https://git.io/JL53f', width=800)" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "B5oj-jDgifCf", "outputId": "f88bbaac-8178-499b-fa39-1b432f001149" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "BCE (확률): 0.3711 (로짓): 0.3711\n", "CCE (확률): 0.5996 (로짓): 0.5996\n", "Sparse CCE (확률): 0.5996 (로짓): 0.5996\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ ":27: DeprecationWarning: distutils Version classes are deprecated. Use packaging.version instead.\n", " if Version(tf.__version__) >= '2.3.0':\n" ] } ], "source": [ "from packaging.version import Version\n", "\n", "\n", "####### 이진 크로스 엔트로피\n", "bce_probas = tf.keras.losses.BinaryCrossentropy(from_logits=False)\n", "bce_logits = tf.keras.losses.BinaryCrossentropy(from_logits=True)\n", "\n", "logits = tf.constant([0.8])\n", "probas = tf.keras.activations.sigmoid(logits)\n", "\n", "tf.print(\n", " 'BCE (확률): {:.4f}'.format(\n", " bce_probas(y_true=[1], y_pred=probas)),\n", " '(로짓): {:.4f}'.format(\n", " bce_logits(y_true=[1], y_pred=logits)))\n", "\n", "\n", "####### 범주형 크로스 엔트로피\n", "cce_probas = tf.keras.losses.CategoricalCrossentropy(\n", " from_logits=False)\n", "cce_logits = tf.keras.losses.CategoricalCrossentropy(\n", " from_logits=True)\n", "\n", "logits = tf.constant([[1.5, 0.8, 2.1]])\n", "probas = tf.keras.activations.softmax(logits)\n", "\n", "if Version(tf.__version__) >= Version('2.3.0'):\n", " tf.print(\n", " 'CCE (확률): {:.4f}'.format(\n", " cce_probas(y_true=[[0, 0, 1]], y_pred=probas)),\n", " '(로짓): {:.4f}'.format(\n", " cce_logits(y_true=[[0, 0, 1]], y_pred=logits)))\n", "else:\n", " tf.print(\n", " 'CCE (확률): {:.4f}'.format(\n", " cce_probas(y_true=[0, 0, 1], y_pred=probas)),\n", " '(로짓): {:.4f}'.format(\n", " cce_logits(y_true=[0, 0, 1], y_pred=logits)))\n", "\n", "####### 희소 범주형 크로스 엔트로피\n", "sp_cce_probas = tf.keras.losses.SparseCategoricalCrossentropy(\n", " from_logits=False)\n", "sp_cce_logits = tf.keras.losses.SparseCategoricalCrossentropy(\n", " from_logits=True)\n", "\n", "tf.print(\n", " 'Sparse CCE (확률): {:.4f}'.format(\n", " sp_cce_probas(y_true=[2], y_pred=probas)),\n", " '(로짓): {:.4f}'.format(\n", " sp_cce_logits(y_true=[2], y_pred=logits)))" ] }, { "cell_type": "markdown", "metadata": { "id": "EcQnpguXifCf" }, "source": [ "## 텐서플로를 사용하여 심층 합성곱 신경망 구현\n", "\n", "### 다층 CNN 구조" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 289 }, "id": "n893uGaEifCf", "outputId": "0da03fb0-cf78-4d4f-e565-3893561c8c10" }, "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 24 } ], "source": [ "Image(url='https://git.io/JL53U', width=800)" ] }, { "cell_type": "markdown", "metadata": { "id": "klgI_t62ifCf" }, "source": [ "### 데이터 적재와 전처리" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "id": "qGT2_kbKifCf" }, "outputs": [], "source": [ "import tensorflow_datasets as tfds\n", "import pandas as pd\n", "\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 123, "referenced_widgets": [ "f5811f7a80374167ab567e6993aa7305", "f14a9a46ed324257ab26fbccf5ed5fa6", "b7a23744985b4457a51e9a9dd5f52b44", "c190d2c40d1045cca1cef4ec4261473d", "4d7074fe24804f2d8af5c1806cde1098", "1297a1c9e5dc4515a8c8cdec783119a1", "cd15ff3ec76947d29c9f2be267ed92c0", "6ed5ab9f93ca400faa09f9ad89ecd8e2", "8ef4468985274fb8a0e7566755228f80", "cc52b2d1cf7c4261a25b9701cbef5fbf", "3698440c0e9a420ab29237955cdd5bb0" ] }, "id": "csMbYS6PifCf", "outputId": "235fd882-c2f7-49f2-8057-92f82dabe7c8" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Downloading and preparing dataset 11.06 MiB (download: 11.06 MiB, generated: 21.00 MiB, total: 32.06 MiB) to /root/tensorflow_datasets/mnist/3.0.1...\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "Dl Completed...: 0%| | 0/5 [00:00" ], "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/gAAAF5CAYAAAArqIHDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAADHJklEQVR4nOzdd3iTVfvA8W/SXTqAbkpp2YgoezkYAoIDAVGGIksRFUSsLwi+CCL6w4nlBRRFQQUEHCxBQCgUQRFkC2VvSieFLjqT5/fH06QNTelKm7S9P9eVq82Tk5OTdCT3c+5zH42iKApCCCGEEEIIIYSo1LTWHoAQQgghhBBCCCHKTgJ8IYQQQgghhBCiCpAAXwghhBBCCCGEqAIkwBdCCCGEEEIIIaoACfCFEEIIIYQQQogqQAJ8IYQQQgghhBCiCpAAXwghhBBCCCGEqAIkwBdCCCGEEEIIIaoAe2sPoDLR6/Vcu3YNd3d3NBqNtYcjhBBCoCgKKSkp1KlTB61WztuXlbzXCyGEsDUlea+XAL8Erl27RlBQkLWHIYQQQhRw5coV6tata+1hVHryXi+EEMJWFee9XgL8EnB3dwfUF9bDw8PKoxFCCCEgOTmZoKAg43tUZfHHH3/w8ccfc+DAAaKjo1mzZg39+/e/430iIiIIDQ3l+PHjBAUFMW3aNEaOHGnSZsGCBXz88cfExMTQsmVL5s2bR4cOHYo9LnmvF0IIYWtK8l4vAX4JGFL1PDw85E1fCCGETals6eRpaWm0bNmS0aNH8+STTxbZ/sKFCzz22GO89NJLLF++nPDwcF544QUCAgLo3bs3AKtWrSI0NJSFCxfSsWNHwsLC6N27N6dOncLX17dY45L3eiGEELaqOO/1GkVRlAoYS5WQnJyMp6cnSUlJ8qYvhBDCJlSF9yaNRlPkDP6bb77Jxo0bOXbsmPHYkCFDuHnzJps3bwagY8eOtG/fnvnz5wPqevqgoCBeffVVpkyZUqyxVIXXUwghRNVSkvcmqcYjhBBCCJu3Z88eevbsaXKsd+/e7NmzB4CsrCwOHDhg0kar1dKzZ09jG3MyMzNJTk42uQghhBCVlQT4QgghhLB5MTEx+Pn5mRzz8/MjOTmZ9PR0EhIS0Ol0ZtvExMQU2u/s2bPx9PQ0XqTAnhBCiMpMAnwhhBBCVFtTp04lKSnJeLly5Yq1hySEEEKUmhTZE0IIIYTN8/f3JzY21uRYbGwsHh4euLi4YGdnh52dndk2/v7+hfbr5OSEk5NTuYxZCCGEqGgygy+EEEIIm9e5c2fCw8NNjm3dupXOnTsD4OjoSNu2bU3a6PV6wsPDjW2EEEKIqk5m8K1Ap1fYdyGRuJQMfN2d6VC/NnbayrW9kaheFEUhOzsbvV5v7aEIUaXZ2dnh4OBg7WFUiNTUVM6ePWu8fuHCBQ4fPkzt2rWpV68eU6dOJSoqiu+//x6Al156ifnz5zN58mRGjx7N9u3b+fHHH9m4caOxj9DQUEaMGEG7du3o0KEDYWFhpKWlMWrUqAp/fkIIUVEktii7qvQaSoBfwTYfi2bmr5FEJ2UYjwV4OjOjb3P6tAiw4siEKCgrK4u4uDhu3bqFTqez9nCEqBacnJzw9vau8lu07d+/n+7duxuvh4aGAjBixAi+/fZboqOjuXz5svH2+vXrs3HjRl5//XXmzp1L3bp1+frrr+ndu7exzeDBg4mPj2f69OnExMTQqlUrNm/eXKDwnhBCVBUSW5RdVXsNNYqiKNYeRGVR1r1xNx+L5uVlB7n9BTecG/piWJtK+UskqqZbt25x5coV7Ozs8PT0NK5x1Wgq59lMIWydIVMmKSmJ1NRUAgMDi/VeI/u2W5a8nkKIyqK8Ygtbn8225PgqS3xWkvcmmcGvIDq9wsxfIwv88gAoqL9EM3+NpFdzf5v6AxLVV0JCAg4ODgQHB2NnZ2ft4QhRLbi4uODu7s7Vq1dJSEiQAFMIIYRZ5RVblMdstqUDckuNT6dXeGd91YvPJMCvIPsuJJr8It5OAaKTMth3IZHODb0qbmBCmJGTk0NaWhoBAQES3AtRwTQaDZ6enkRFRZGdnV1t1uQLIYQovuLGFmsOXqV3C3/cnYt+LylsNjsmKYOXlx0s1Wy2JQPyko4vR6cnPjWT6KQMYpIyiE7KIPpmOtHJ6vVLCWkkpGUV+niVNT6z2QB/wYIFfPzxx8TExNCyZUvmzZtHhw4dzLY9fvw406dP58CBA1y6dInPPvuMiRMnFtr3Bx98wNSpU3nttdcICwsrnydwm7iUwv8AS9NOiPKUk5MDIFtHCWElhqBep9NJgC+EEMKEXq/w59n4YrX9z89H+c/PR3Fzssff05kAT2f8PXK/errkfnXGz92ZdyycEWDJEwZFZSwAvPHjEdYeiiImOZOYpAziUjLQW2Ax+rd/XcTDxZ7mAR6VYqmqTQb4q1atIjQ0lIULF9KxY0fCwsLo3bs3p06dwtfXt0D7W7du0aBBA55++mlef/31O/b9zz//8OWXX3LvvfeW1/DN8nV3tmg7ISpCZfgnJkRVJH97QghhG2xpPXpMUgY/H7jCj/uvcjnxVrHuU8PRjrQsHamZOZyNS+VsXGqpHtswm/3p76e4J9ATZ0c7XBxyL7nfO+d+72yvRaPRFLmEYMb64zTydSctM4ek9GySM7LVr+m3X8/m2o30O2YsAKRl6dh8PNbkmL1Wg5/xhEbeiY06ns4kpGby9rrjRT73Lcdj2HI8hqDaLjzc3J/ed/vTNrjWHX8PrPl7Y5MB/pw5cxgzZoxxW5uFCxeyceNGFi9ezJQpUwq0b9++Pe3btwcwe7tBamoqzz77LIsWLeK9994rn8EXokP92gR4OhOTlGH2F10D+HuqP3whhBBCCCGEddlCdfWsHD3bT8ay6p8r7Dwdb5yRdnO0Qw/cyjK/y5Ehttj95kNk5uiIyZemHpOcwbWb6SbXE++Qqp7f5xHnitXOXqsh5w7T5woQm5xJzzk7i9VfcQ1sE8jDd/sbA3rvGk5oCwmsdXqFzyPO3TE+83RxoF1ILXadSeBKYjrf7L7AN7sv4O3mSM+7/Oh9tz/3NfLCyT5vSau1f29sLsDPysriwIEDTJ061XhMq9XSs2dP9uzZU6a+x40bx2OPPUbPnj2LFeBnZmaSmZlpvJ6cnFzqx7bTapjRtzkvLzuIBkx+iQy/cjP6Nq9UBRyEEEIIIYSoispjPToUf2b3bFwqP+6/wi8HrnI9X/DdIaQ2g9sH8eg9Aew8HcfLyw4Cd44tXB3taeDjRgMft0LHtfN0HCMW/1Pk+O8J9MDZwY70bB3pWToysvVkZOvU69k6DPuz3Sm4z8/JXotXDUc8XBzwdHHI++psuG6Pp4sD126m88nvp4vs76m2QcVeL1+c+OyDgffQp0UAt7Jy+ON0PFuOxxJ+IpaE1CxW/nOFlf9cwc3Jnm5Nfeh9tz85eoXQVYct/ntTEjYX4CckJKDT6QrsWevn58fJkydL3e/KlSs5ePAg//xT9C+uwezZs5k5c2apH/N2fVoE8MWwNgXO6PhX4n0WhRBCCCGEsBWWSI22VoX6tMwcNh6NZtX+Kxy4dMPYxsfdiYFt6jKoXV2TIN2SscUDjXyKlW28dtwDhT5nRVHIzFED/j/PJjDuh0NFPu63ozoUKyDX6RWW771s8Wzo4r6Gro729GkRQJ8WAWTr9Px9/jpbjsfw+/FY4lIy2XA0mg1Howt9nIqsym9zAX55uHLlCq+99hpbt27F2bn4a9ynTp1KaGio8XpycjJBQUFlGkufFgH0au7PD3sv8fa643jXcGT3mw/JzL0QNqyk66GDg4O5ePGiRccQEhLCpUuXUBQLVIspREREBN27d2fEiBF8++235fY4QgghKi9Lry22pS3UMrJ1XEhIY/OxmGJVqH/jx8O0DamNn7uTWqjOwxlvNyez479TRsBLyw5yf0MvDl+5SVpuyr2dVkP3pr4Mbh9Et6Y+ONhpzY7FEFuU9TW0RLaxRqPBOXctfp8WAQR4nrBYQF6e2dAlfQ0d7LQ82NiHBxv78O4TLTh89SZbjsew7tA1YpKtv2uazQX43t7e2NnZERtrWiAhNjYWf3//UvV54MAB4uLiaNOmjfGYTqfjjz/+YP78+WRmZprdCszJyalcqojbaTX0uMuPt9cdJykjG4nthbBtI0aMKHBs9+7dnDt3jpYtW9KqVSuT27y9vStoZEIIIUThLB2MW3ptsTW2UFMUhfjUTM7Hp3EuPpVzcerX8wmpXL2RTknOo689fI21h6+ZHNNq1Bl3Pw/n3IsTvu5OfLP74h0rwP957joA9b1r8HS7ujzVpi6+HsWbmLTTaiwSMFoyI6A8AvLyzIYu7Wuo1WpoU68WberVorm/B6+tOlzkfcp71zSbC/AdHR1p27Yt4eHh9O/fHwC9Xk94eDjjx48vVZ89evTg33//NTk2atQomjVrxptvvmmVfb593NUTB9k6hcS0LLzcZDsyIWyVudnskSNHcu7cOfr3788777xT7mMIDw8nOzu73B9HCCFE1VAewbgl16RX9BZqr686whcR5zifkEZKRk6hfXk42+Pr4cTZuLQiH7fXXX6ggbhktVBdfEomekUtHhebnAkkFWv8BtMfv4tR99e36k4qlsoIMPRl6YDckuOztOKekCnvXdNsLsAHCA0NZcSIEbRr144OHToQFhZGWlqasar+8OHDCQwMZPbs2YBamC8yMtL4fVRUFIcPH8bNzY1GjRrh7u5OixYtTB6jRo0aeHl5FTheURzstHi7OZKQmkVscqYE+KLas6VtaGxRw4YNrT0EIYQQlYSlg/HUjBzeXnf8jgH05J+PcvVGunpMAQUFvQJ6RVGv537VK5Cj17PkzzvPaL++6gibj8WQo1fI0Snk6PVk5/+q05OjV8jWKSSnZxW5hVp6to4jV9WAW6OBoFquNPSpQQMfNxr6uBm/93ZzRK/AAx9uLzK9fOFzbU0+q+j0CgmpmcQmZxCbnElMcgZxyWpK9t4LiXccH4CXm5NNbJNqqYwAKJ+A3JLjsyRb2TXNJgP8wYMHEx8fz/Tp04mJiaFVq1Zs3rzZWHjv8uXLaLV561CuXbtG69atjdc/+eQTPvnkE7p27UpERERFD7/YfN2d1QA/JYPmeFh7OEJYjbW3E7Gkb7/9llGjRjFjxgyeeeYZpk+fzo4dO4iPj2f16tX079+fs2fPsmzZMrZs2cKFCxdITEzE19eXhx56iGnTptGkSZMC/Zpbg3/x4kXq169P165d2bRpEzNnzmTFihXExMQQFBTEmDFjmDx5skU+LOTk5PDFF1/w7bffcurUKQCaN2/OqFGjePHFFwtkQqWmpjJv3jxWrlzJxYsXjcVT27RpwwsvvEDv3r2NbePj4/n0009Zv349ly9fxs7ODj8/Pzp16sT48ePp0KFDmccvhBDVRXELxN3fyJsbadnEp2aSkHuJT8n9PiXLeCwhNYvUzMJnvA2SM3J4b+MJiz2P9GxdgfT3shp1fwhD2tcj2MsVZ4fCM3jtNJQqvdwud891v9tmcvecu87QRX8XOb7yntm1FlsNyC3NVnZNs8kAH2D8+PGFpuTfHrSHhISUuPCULQT+fh5OREaraT1CVFfltQ2NtZ06dYr27dvj5eVF9+7duXHjBg4ODgB8/fXXfPTRR7Ro0YL27dvj5OREZGQkS5cuZd26dezatYt777232I+VlZXFww8/TGRkJN26dSMtLY2dO3cyZcoUUlJSirUt6J3odDr69evHb7/9hoeHB7169UJRFLZv384rr7zC1q1b+fnnn40nXnU6HT179mTv3r14e3vTrVs3nJ2duXr1Kr/99hs1atQwBvgpKSl07NiRCxcuEBQURK9evbC3t+fy5cusXLmSBg0aSIAvhBAlsO9CYrEKxN3zzu8Wf+w29WpSr7YrGo0GjQY0aNBqQGu4rlGvX7yexp9nrxfZX/9WdWgZVBN7Oy0OWo361U6DvVaLvZ3G+P3p2JRinVx4uLk/Tf3di/VcLJlebiszu6L82cKuaTYb4FcHhrN76hodISoPRVFIz9aVuR+dXmHG+sJT/jTAO+vVWYaynO10cbCr8JS3lStXMn78eMLCwgrMbvfv35+xY8dSv359k+NLlixh9OjRTJw4ke3btxf7sfbs2UPXrl25cOECHh5qNtD+/fvp1KkTn332GVOmTMHNrfC9b4sSFhbGb7/9xt133014eLgxmyo6Opru3buzZs0aPv/8c+NJ2T/++IO9e/fSvn17/vjjD5PdS5KTkzlz5ozx+s8//8yFCxd44oknWLNmjUl2Vnx8fIGCq0IIIcxTFIXLibdYfySq2Pdxstfi7eaEj7tT7ldHvN2cTI55uzlyISGN57/bX2R/k3o3K9ZM7Z5z14sV4A9uX69Y/d3fyJtvdl8oly3UbKVCvag8rF0nQAJ8K8oL8GUGX1Qu6dk6mk/fUu6PowAxyWWfZYh8tzeujhX7787Hx4cPP/zQbBHPTp06mb3PqFGj+Oabb4iIiCApKQlPT89iPZZWq+XLL780BvcA7dq145FHHmHDhg3s37+fbt26lep5APzvf/8DYM6cOcbgHiAgIICPP/6YJ554grlz5xoD/Pj4eADuv//+AluTenh40LZtW+N1Q9uHHnrIJLgH9TX08fEp9biFEKKyKWk9miuJt9hz/jp/n7vO3+evc62Idej5LR7Rju7NfIt1AjzYq4ZFZ6AtPaNdngG0LVaoF7bPmssSJMC3IpnBF6Lq6tmzJ66uroXenpqayq+//srhw4dJTEw0VsiPjo5GURTOnTtnsrXnnQQHB9O0adMCxw1r+aOjo0vxDFSXL1/m8uXL+Pj48PDDDxe4/fHHH6dmzZqcPXuWmJgY/P39adWqFVqtliVLltC8eXOefPJJvLzMv8kZgv2PP/4YPz8/HnvsMdzdi5c+KYQQVUlx6tFcvXGLPeeu8/f5RP4+f52om+kmfTjYabg30JNTsSmkZprPtDMEz12bFi+4B8sH0JVtCzVLsfbMrqgeJMC3Ij8PtXJ+ee+FKISluTjYEflu76IbFmHfhURGLvmnyHbfjmpfpnVpLncopFNe6tWrV+ht27dvZ8iQIcbZa3NSUlKK/Vh169Y1e9wQKGdmlv4k4rVraoGj4OBgs7drNBqCg4O5efMmUVFR+Pv706RJEz766COmTp3Kiy++yEsvvUSLFi3o0aMHI0eONKkv0KNHD15//XXCwsIYOnQo9vb2tGnThl69ejF69GgaNGhQ6rELIURlUVg9muikDF5adpDODby4cuOWsUq9gb1Ww711Penc0ItODbxoG1wLV0d7Y39gudlsSwfQ1W0LNYPqUnBOWI8E+FZkmMGPKUE6lRC2QKPRWCTl/cHGPsVK0XuwsY9NvTkXx+2p6QapqakMGjSIxMREpk+fzpAhQwgODsbFxQWNRsMzzzzDihUrSlQ49PbU9opmbgbojTfeYNCgQaxdu5atW7eya9cuPvvsM8LCwvjss8947bXXjG3nzJnD2LFjWbduHdu2bePPP/9k3759fPTRR6xYsYKBAwdW5NMRQohis8QWr3eqem+w57y6Xt0uN6Dv1MCLzrkBfQ2ngu/H5TWbbekAujptoSZERZEA34p8c2fwE1IzydHpsbez7od0ISpadSw6s2vXLq5fv85TTz3FzJkzC9x+/vx5K4yqcHXq1AHg0qVLhbYx3BYYGGhyPCgoiFdffZVXX32VnJwcVq5cyahRo5g8eTLDhw+nVq1axrZNmzZl8uTJTJ48mYyMDObPn8+kSZN4+eWXJcAXQtik0mzxqigKcSmZnIlN5WxcCmfjUzlw8UaRe7gDvNmnKc91DsHNTEBvTnnNZls6gJaAXAjLkgDfirxqOGGn1aDTK1xPyyqwZ6YQ1UFlWDNnSTdu3ADMp9WfPXuWgwcPVvSQ7qhevXrUq1ePy5cvEx4eTo8ePUxu37hxIzdu3KBRo0b4+/sX2o+9vT3Dhg3j888/Z8+ePZw5c6bQ7e+cnZ35z3/+w5w5c4iOjiYuLg5fX1+LPi8hRPVkiRl3KHqL1wXPtKFFoCdn4lI4G5fK2bhUzsSlci4ulZRi7ClvTp2aLsUO7g0keBai+pEA34rstBp83JyISc4gNjlDAnxRbVWGNXOWYih8t3r1at566y1jlfibN2/y/PPPG4vt2ZJXX32VSZMmERoayrZt24xjjomJYdKkSQAmKfc7duxAp9MVqIx/4cIFTpw4gUajMZ7gWLt2Lf7+/gV2Fjhw4ACxsbG4ublRs2bNcn6GQojqoDQz7ubcKaXecOyVHwo/WavVQIhXDRr6utHI1w0N8HnEuSIf19ddPicKIYomAb6V+XkYAnyppC+qt+oyy9CuXTt69erF1q1badKkiXH7uoiICLy9venXrx/r1q2z7iBv8/rrr7N9+3Y2bdpE48aNeeihh1AUhfDwcFJSUujfvz+vvPKKsf2RI0d4/fXX8fHxoW3btnh5eREfH8/OnTvJzMzk1VdfNab+R0REMHfuXAIDA2ndujUeHh5cu3aNXbt2odfrmTlzJo6OjtZ66kKIKqKoGfcvhrUxCfJvZeUQm5xJTFIGcSnqRExMUiaxKRmciU0pVkq9vVZDo9wgvpGvG4193Wnk60aItytO9nnFX3V6hTWHoiy+h7sQonqSAN/K1Fn7JGKTpdCeENXFunXreP/99/nxxx/ZtGkTvr6+DBkyhPfee4833njD2sMrwM7OjvXr1/P555/z7bffsmXLFgCaN2/OqFGjGDt2rMlM/eOPP87169fZsWMHR44c4fr16/j4+PDAAw/wyiuvMGDAAGPbkSNHYm9vzx9//MG+fftISkrC39+fRx99lNdee63AkgAhhCip4sy4v77qCEv3XCI2JZPY5AxSMkqXRp/fx0+3ZEDrwCLbVcd6NEKI8qNRSlKquZpLTk7G09OTpKQkPDw8LNLn22uPsfTvS0x4qBGhDxfcx1oIa8jIyODChQvUr1+/0GrwQojyU5K/wfJ4b6rO5PWsev46m8AzX+8t8f1cHe3w93DG18MJfw9n/HIvSenZzA0/U+T9V4zpVKLMNEstIRBCVD0leW+SGXwr88utpC8p+kIIIYQQlpGepWP32QTCT8Sy8Wh0se4zrFM9HmkRkBvIO+HmZG92G1CdXuHH/VcsnlJfnerRCCHKjwT4VuabW1gvRlL0hRBCCCGMSlrxPi45g/CTcYSfiGXXmQQyc/QlerzH7qlTrBn38kypry71aIQQ5UcCfCszVM6XNfhCCCGEEKripKsrisLJmBTCT8Sy9UQcR67cNOkjsKYLvZr70b2pD2/+8i+xyZabca9uW7wKISoPCfCtzJCiH5ciKfpCCCGEEEVVvJ/QozFJ6dlsjYwl6ma6SZuWQTXp2cyXns39aObvbkyxf+cJy8+4S0q9EMIWSYBvZX65e5ompmWRmaMz2TZFCCGEEKI6KU7F+/wF7pzstTzY2Jsed/nRo5mvcenj7cprxl1S6oUQtkYCfCur6eqAo72WrBw98SmZ1K3lau0hCSGEEEJYxb4LicXaY757Ux+e6RjMA428cXEs3uSIzLgLIaoDCfCtTKPR4OfhxJXEdGKTJcAXQgghRPV19catYrXr3zqQXs39Sty/zLgLIao6CfBtgJ+7M1cS04mTQntCCCGEqIYuX7/F93su8sPeS8Vq7+tuPhVfCCGqOwnwbYBU0hdCCCFEdaMoCrvOJPDdXxfZfioOJXeRvZ1Wg05vbhV+6feYF0KI6kICfBvgm1tJPyZZKukLIYQQompLzczhlwNX+W7PRc7HpxmPd2niw8j7gsnI0jPuh4OAZfeYF0KI6kACfBtgmMGXFH0hhBBCVFY6vXLHAnbn41P5fs8lfj5wldTMHADcnOx5qm1dnuscTEMfN2PbL7Syx7wQQpSGBPg2wC93Bj82RQJ8IYQQQlQ+m49FFwjIAzydefux5rg42vHtXxfZeTreeFsDnxqM6BzCwLZ1cXMq+HFUKt4LIUTpSIBvA/zcDWvwJUVfCCGEEJXL5mPRvLzsYIG966OTMnglN9UeQKOBh5r6MuK+EB5o5I22iGBdKt4LIUTJaa09AAG+UmRPCJv2zDPPoNFomDVrVpFt9+3bp25/6edHTk5OiR9r5MiRaDQaIiIiTI5369YNjUbDxYsXi93Xt99+i0aj4Z133inxOEqqNOOrCBX5GghRHen0CjN/jSwQ3OenAUbfH0LEf7rxzcj2dGniU2RwL4QQonQkwLcB/p5qgJ+SkcOtrJIHBEKI8vXcc88BsHz58iLbLlu2DIChQ4dib191kqQ0Gg0hISHWHoYQwsbsu5BokpZvjgL0au5PsFeNihmUEEJUYxLg2wA3J3tqONoBECdp+kLYnIcffhg/Pz9OnTrFP//8U2i7nJwcVq1aBeSdFLCU77//nhMnThAYGGjRfi3F1scnhCgfccWsH1TcdkIIIcpGAnwb4Sdp+kLYLDs7O4YOHQrkzdCb8/vvvxMXF8ddd91F27ZtLTqGevXq0axZMxwcHCzar6XY+viEEOXDyb54HyV9c+sNCSGEKF8S4NsI39xK+jES4AuRR1EgxzayWoYNGwbAqlWr0Ol0ZtsYUvgNbW/evMm8efPo3bs3wcHBODk54eXlRZ8+fdi6dWuJHv9Oa9z//PNPevbsibu7OzVr1qR3797s3bu30L7Onj3LO++8Q+fOnfH398fR0ZG6desyfPhwTp8+bdLWsIYd4NKlS2g0GuOlW7duxRpfZGQkzz77LAEBATg6OhIYGMjw4cM5depUgbYRERFoNBpGjhxJYmIiL7/8MgEBATg5OdGiRQsWL15cvBesGG7dusWsWbNo0aIFLi4ueHp60qVLF1auXGm2fXx8PFOmTKF58+a4ubnh6elJkyZNGD58OPv27TNpe+nSJV5++WWaNGmCq6srtWvX5u6772bs2LFmn7cQldGBSzeYse74HdtoUKvpd6hfu2IGJYQQ1VzVWSBayRlm8CVFXwjUwP5cOGx/D5Ki4MUd4FnXqkNq27Ytd911FydOnGDr1q306dPH5Pa0tDTWrVuHRqPh2WefBeDvv/9mwoQJhISE0LRpUzp37szly5f5/fff+f333/n6668ZPXp0mca1YcMGBgwYQE5ODh06dKBBgwYcOXKELl26MHLkSLP3+frrr/noo49o0aIF7du3x8nJicjISJYuXcq6devYtWsX9957LwCNGjVixIgRfPfdd9SoUYOnnnrK2E+zZs2KHF94eDh9+/YlPT2d1q1b061bN06ePMnSpUtZs2YNv/32Gw8++GCB+928eZPOnTuTmprKgw8+SEJCAn/88QfPP/88er2eF154oXQvWK6UlBS6d+/OgQMH8PHx4fHHHyctLY3t27eza9cu9uzZw9y5c03ad+zYkQsXLhAUFESvXr2wt7fn8uXLrFy5kgYNGtChQwcArly5Qps2bUhMTKRx48Y8+uij6HQ6Ll26xKJFi+jcuTNNmzYt0/iFsCZFUVj29yXe3RBJtk7Bz8OJ2ORMNGBSbM9QRm9G3+ayvZ0QonwpCuiywN7J2iOxPsVGzZ8/XwkODlacnJyUDh06KHv37i207bFjx5Qnn3xSCQ4OVgDls88+K9Dm//7v/5R27dopbm5uio+Pj9KvXz/l5MmTJRpTUlKSAihJSUklfTpFen9jpBL85gZl1q/HLd63ECWVnp6uREZGKunp6RX7wHq9opzZqihfdlWUGR6KMqOm+jXqUMWOoxD/93//pwDKs88+W+C277//XgGUrl27Go+dP39e2bNnT4G2Bw8eVGrWrKl4eHgoKSkpJreNGDFCAZQdO3aYHO/atasCKBcuXDAeS05OVnx8fBRAWbx4sfG4Xq9X3nzzTQX1s7YyY8YMk7727NmjnD9/vsC4Fi9erABK9+7dC9wGKMHBwQWO32l8qampip+fnwIo8+fPN2k/Z84cBVDq1q1r8nu2Y8cO47iHDBmiZGRkGG9bs2aNAij16tUrdBy3W7JkidnXYPz48cbnmpycbDx+4sQJxdfXVwGUX3/91Xjc8No88cQTik6nM+krLi5O+ffff43Xp0+frgDK+PHjC4zn0qVLytmzZ4scd0n+Bsvzvak6ktfzzm5l5iivrzykBL+5QQl+c4Py8rL9SkpGtrLp32tKp//bZjwe/OYGpdP/bVM2/XvN2kOu/PR6RcnOKLqdqLzkZ1x6+T87ftRIUW5esfaIykVJ3ptsMkV/1apVhIaGMmPGDA4ePEjLli3p3bs3cXFxZtvfunWLBg0a8MEHH+Dv72+2zc6dOxk3bhx///03W7duJTs7m4cffpi0tLTyfCrF5uuunm2KTZEZfFGJZKUVfsnOKH7brFtwdhss6g7LBkL00dw76dUvOen5+k2/rd9bd+7Xgp599lk0Gg1r164t8L/DsDbfkJ4PUL9+fTp16lSgn9atWzNu3DiSk5PZsWNHqcfz888/Ex8fT5cuXRg1apTxuGFLv7p1zWc9dOrUifr16xc4PmrUKO6//34iIiJISkoq9bgMfvzxR2JjY+ncuTPjxo0zue3111+nbdu2XL16lV9++aXAfT08PJg/fz5OTnln4vv370+LFi24fPlymbbjS0tL45tvvkGr1fL555/j7u5uvK1Zs2ZMmzYNwGQGPz4+HoCHHnoIrdb0rdPHx4cWLVoUaNuzZ88Cj12vXj0aNmxY6rELYU2Xrqcx4PM/WX0oCjuthv8+ehcLnmmDm5M9fVoEsPvNh1gxphNzh7RixZhO7H7zIfq0CLD2sCsvRcl7b/ysBSRdtfaIhKXJz7j08r92ywbCtSOQFgdpCdYemdXZZIr+nDlzGDNmjPED68KFC9m4cSOLFy9mypQpBdq3b9+e9u3bA5i9HWDz5s0m17/99lt8fX05cOAAXbp0sfAzKDkpsicqpf+rU/htjR+GZ3/Ku/5xI8guJOB2dIOsVNCou0mg3LbGfXG+dPg6reHFiLzrCzpC0mXz/fo0g3GFr0UvqXr16tGlSxd27tzJ2rVrjan4sbGxhIeH4+zszNNPP21yH51OR3h4OH/99RfR0dFkZqon8c6cOWPytTR27doFwJAhQwrc5uDgwFNPPUVYWJjZ+6ampvLrr79y+PBhEhMTyc7OBiA6OhpFUTh37hxt2rQp9djyj8/wOt1u2LBhHDhwgF27dhVo07ZtW7y8vArcp0mTJhw7dozo6OhSb9t34MAB0tPTadeundllBs899xwTJkzgzz//RK/Xo9VqjUUTP/74Y/z8/HjsscdMTgzcPnaAt956Czs7O3r27ImzsxQYE5Vb+IlYJq46TEpGDt5ujswb2obODU3/Ru20mgLHRCnkX6Z27RBqySy9GrhYebmasBD5GZee4bXbMg3iT4DGcNJdb9Vh2RKbC/CzsrI4cOAAU6dONR7TarX07NmTPXv2WOxxDLNTtWsXXvQlMzPT+GEcIDk52WKPfzt/T8MafAnwRTWUlap+vT2wt0HPPfccO3fuZNmyZcagdMWKFeh0Op588kk8PT2Nba9evcrjjz/OkSNHCu0vJSWl1GO5du0aAMHBwWZvLywA3r59O0OGDDHONFt6XLePr7BxGI5HRUUVuK2w7ANDUJ3/f7Olx1WzZk08PT1JSkrixo0beHl50aNHD15//XXCwsIYOnQo9vb2tGnThl69ejF69GgaNGhgvP/IkSP5/fff+fHHH+nbty/Ozs60b9+ePn36MHr06EIzzYSwRTq9wtxtp/nf9rMAtKlXk8+fbWv83CIsyBC4hL8L0UfyTnpL4FJ2trI++/bAXn7GJXNuB2ybCdGH8o4p8trdzuYC/ISEBHQ6HX5+fibH/fz8OHnypEUeQ6/XM3HiRO6//36TtMrbzZ49m5kzZ1rkMYvi526Ywc9EURRj1WohbNpb1wq/zfimlWvSWfPtLvwBER9A9GH1PuaC/NGbwf/e3H5vW1k0bi+mZZ1MBlH4+ErpqaeeYvz48Wzbto24uDh8fX2N6fnPPfecSdsXXniBI0eOMHDgQCZPnkzTpk1xd3dHq9Xy1VdfMXbsWBSlsLGXj9TUVAYNGkRiYiLTp09nyJAhBAcH4+Ligkaj4ZlnnmHFihUVMq47/Z+7PQ2+opkb25w5cxg7dizr1q1j27Zt/Pnnn+zbt4+PPvqIFStWMHDgQEDdVnHVqlVMmTKFdevWsX37dvbu3cuuXbv44IMP2Lx5M/fdd19FPyUhSuxGWhavrTrMH6fVk4EjOgfz38ea41jMrfHKha0EapZ2bgeEz8ydzc1VCU562zxbKtpr8jPOfY+pTD9jW/jb2/QmJMhONEWxyTX45W3cuHEcO3as0K2QDKZOnUpSUpLxcuXKlXIbk2GbvPRsHSmZOeX2OEJYlGONwi8OzsVr2/QRNeV+2C8QYAjibzs5YO+Sr1+X2/p1vcM4XC3+lD09PXniiSfIyclhxYoVnDx5kgMHDuDt7W1SWT8tLY2tW7fi5+fHqlWr6NChA56ensbA9fz582UeS0CAurb10qVLZm83d3zXrl1cv36dgQMHMnPmTO666y5cXV2NAa0lxmVQp06dO47PsI4+MDDQYo9ZHEWNKykpiZs3b+Li4kKtWrVMbmvatCmTJ0/m999/5/r163z88cdkZ2fz8ssvF+indevWvPPOO/zxxx/Ex8fz+uuvk5KSwsSJEy3+nISwtH+vJvH4vN38cToeZwctnw1uycx+LawX3Ff1tcqb3jQN7s3JKL9M0jKzoW1tgfJfn12a57tuXL6fccWe3C8TW/rbe+RDqJ1bx6aoydAbF+GHwfDvzxavyVRqFfR3YnMBvre3N3Z2dsTGxpocj42NtUha4/jx49mwYQM7duwoNAXUwMnJCQ8PD5NLeXF2sMPTxQGA2CRJ0xfVjEYDjXrCmB2mgb7t/YsC8grpLV++nOXLlwMwePBgHBwcjG2SkpLQ6/UEBARgZ2d6wiI7O5s1a9aUeRyG7eV+/PHHArfl5OSYLV5348YNwHwK/NmzZzl48KDZx3JwcCAnp2QnHw3jW7FihdnbDZkP5rbJK09t27bFxcWFAwcOmK2BYBjX/ffff8dMAmdnZ/7zn/8QEBBAfHx8oYVgQS0aOHv2bDQaDceOHSv7kxDCAnR6hT3nrrPucBR7zl1Hp1eDjh//ucLAhX8RdTOdYC9X1rxyPwNaW2nWs6oX0oo/Daueg25T1BozUPAkt8HygbB/ScWNrTjKK/grbSB0++/L7UV7LTGuwp6vosDNy2pA+dtk+LIrHFmVd/sDE4v/OLHH4Wx4wYLFJR1rWYJJW/nbSzwPp39Xv2/YHV49AIOWQkAr9Vhhfy///gSnN8Mvz6t1oFa/CGe2ga4En2UsFZBX8EkSm0vRd3R0pG3btoSHh9O/f39ATakPDw9n/Pjxpe5XURReffVV1qxZQ0REhNkK0tbm5+FEUno2scmZNPYzX7xJiCrNEOg37JGXUpccBTV8rD0yE3369MHb25t//vmHCxcuAAXT8319ffH09OTYsWP8+eef3H///YBadO/NN9/k9OnTZR7H008/zeTJk4mIiOC7775jxIgRgPr/bsaMGVy+XLD4YJMmTQBYvXo1b731Fj4+6mt78+ZNnn/+eWOxvdvVqVOHqKgobt68Sc2aNYs1vkGDBjF16lR2797NV199xYsvvmi87X//+x/79+8nMDDQmNpeUWrUqMHo0aNZsGAB48aNY82aNdSoUQOA06dP89577wEwYcIE433Wrl2Lv79/gV0RDhw4QGxsLG5ubsbXZenSpbRu3brAErBNmzahKApBQUHl+OyEKJ7Nx6KZ+Wsk0fkmFfw9nGjk68bus9cB6HmXL58OamWcgKhQVX09ekYS7PwI9i4EfQ44e6gnuW9fn50/hVuXBb7N867fSlSz1ayRMl1eReJKk1KflgDxJ+HEr3DsF0jLV1/m9hT4f3+BGxfAzU+9uPurr2FJxpX/+V4/D5Hr4MpeuLIPUqJN73fpT2g5WP2+7Sio00Yd784PzP+MDfYtggNLwMEVGnSDxr3U4sXFeW3LuixBUdTXMvxduH7Gen97ej3s/wa2TgetPbz8F9QMUj8rNn8C7upr/mdi0HyAeoLk35/g5iU4ukq91PCBu5+Erm9CjUKKglpqaYeViinaXIAPEBoayogRI2jXrh0dOnQgLCyMtLQ0Y1X94cOHExgYyOzZswG1MF9kZKTx+6ioKA4fPoybmxuNGjUC1LT8H374gXXr1uHu7k5MTAygptu6uLiYGUXF8/Nw5nRsqlTSFyJ/oG/t9V5mODg4MGTIEObPn09CQgKNGzemY8eOJm3s7e2ZPHky//3vf+natSsPPfQQtWvXZu/evcTGxjJu3DgWLFhQpnG4u7vzzTffMHDgQEaOHMkXX3xBgwYNOHLkCGfOnGHMmDEsWrTI5D7t2rWjV69ebN26lSZNmtCtWzcAIiIi8Pb2pl+/fqxbt67AYz3xxBPMmzePNm3acN999+Hs7EzTpk2ZNGlSoeOrUaMGy5cvp2/fvowdO5avvvqKJk2acPLkSQ4dOoSbmxsrVqywSoX52bNnG7dNbdCgAV27diUtLY3t27eTkZHBhAkT6Nu3r7F9REQEc+fOJTAwkNatW+Ph4cG1a9fYtWsXer2emTNn4ujoCMAvv/zC8OHDadiwIffccw8uLi5cuHCBvXv3otVqjScQhLCWzceieXnZwQJJwjHJmcQkq7NV/3m4Ca90a4RWa4WaQFV5PbpeD4eXqcGTIRBt0gceCDV/kjt/UPDkIgjqkNfXjv+D42ugzXBoN1oNfoqjLGupy6tIXFGBkKKoJ/xvXYeAlnn3m9cWrhdS48ecPf8reMzRHeq2heH53vsOr1B/HjV81VTvA0sg5qiZiu162PJW3v209mrNoKAO6qVe57zb7Bygbjv1+ya97xycunqBe4B6wuDUb+oFwPduNdjv/l+wdzR9HsUNJhUFUmPhxiU18L1xCW5ehKaPqicUbOFv7+YVdUnDhZ3q9ZAHC6bkFzUp5N0IerwND01TT778+xMcX63+3R1aBj1n5PWVmQJO7pYLyK1cTNEmA/zBgwcTHx/P9OnTiYmJoVWrVmzevNlYeO/y5csmaZPXrl2jdevWxuuffPIJn3zyCV27diUiIgKAL774AsD4YdZgyZIljBw5slyfT3H5GgrtpUiALwSg/vO2seDe4LnnnmP+/PlAXsr+7d566y3q1q1LWFgYf/75Jy4uLjzwwAO8++67habCl1S/fv3YsWMHM2bMYN++fZw4cYL27dvz9ddfc+rUqQIBPsC6det4//33+fHHH9m0aRO+vr4MGTKE9957jzfeeMPs48yePRtFUVi3bh2rVq0iJyeHrl273jHAB+jRowf//PMP77//Ptu3b+fo0aN4e3szbNgwpk2bRtOmTS3yOpSUu7s7O3fu5NNPP2XVqlWsX78eR0dH2rVrxyuvvMLQoUNN2o8cORJ7e3v++OMP9u3bR1JSEv7+/jz66KO89tpr9OjRw9g2NDSUunXr8ueff7Jr1y7S0tKoU6cOgwcP5o033qBdu3YV/XSFMNLpFWb+GnnHFcC1azjysrWCeyheIa2og2qgV5mKEl/eC5smq0VlAbwaQ58PoHFP03aFBS7B9+c9X70eLu6CWwmwew78GaYGaO1fUGd8zb0upZmVzEqDhDMQf0qdpb520DRguT34i/gAvBqCsyc8+B8wfF6/fg502eBSU73NUE+nqEBox/+pAVnCaXXHndoNYEK+4NPVSw3wa9ZTA7ubV9Q0co3WfHX1+l3VkxspMWqQm30LslIKpsKHvwspZgoJ396nc01oOxJqBkNQR3WZRXHq/xQVnBoC05h/4czv6uXqPxB3HHLSoVe+IuDnd6oB6J55dw4m40/BqmHqMoIcM7GGc004s7Xov73yrAWhKGrwveUtyExWazD1mgntx+T9Lt2uqEkhjQbqdVQvfWarJxCTLudlbigKLOoJ+mz1dUmOIq9I822vYWYq/PYfyE5XU/dzMvJdMqFRD3UcVj5JolEquoRzJZacnGzcOqk81uN/vOUkC3acY+R9IbzzxN0W71+I4srIyODChQvUr19f9u8WwgpK8jdY3u9N1U1Vfz33nLvO0EV/F9luxZhOFb+nfdQBdWeVgFZ5H5ALC9QAXvoT/AvfDcnmbH4L/l4ATh7qmvsOL6qzukUpbMZdl6PO7P6zSH3dDLwawwOvQ+tn8+5vblbyxZ1Qp5Vpnyd+hct/q8Fgwik1GDTSUOzicHZO8Ha+uiQrhubNQhtud3BRAyVdZuGp6vlp7dXn9vKfoM0NYpOugkst02DtTssc8j9nRVFnblPj1GUSvs3y2q0bB8dWqycA7sTca1gaxcmquJWorstXdNByiHrs9FZYMejOW8UZxpgSA5/mnlTXaMGjLtQKVk9O1ApWTyDpsvL97RXyM9E6wKhNENS+1E/XLL1OPQFh+D2p2wEGLFRPGJWnIythzdg7tzG8hpkpMPsOJ8Wa94e4E0WfJCnF701J3ptscga/uvLzMGyVJzP4QgghqocFCxbw8ccfExMTQ8uWLZk3bx4dOnQw2zY7O5vZs2fz3XffERUVRdOmTfnwww9NdrBISUnh7bffZs2aNcTFxdG6dWvmzp1L+/YW/jBaScUVM0uwuO0sIvECbJ+lrp8G9cNvUevR67Y3De6P/qimRucP0qwtOx3Sb4CHunMHXSergdiDb4BbCWrLFJbNZmevrkVu/gTEnYR/voYjK9R109fPFj07vvszdVb8mZ/yZkf//UldU56fqxd4N1VTmFNj8moimAv+2o9RA3f9bbc5uKiBeEaS+hroMtWLQWHBfbvnoUFX8GkGteoXTEu/PQOhqGUOt7d19lAvt+u3AFo8VXSwaynFyVh0rQ33Pm16bPPk4u8D7+YHz61Vg3nPoMJPLjXodue/PUc302UScSehVkjB3ZNKSmunZmjYOarZC53H553IKU+75hS/rYMr9JoF9s7qz8vBRf1quO4eAMnXineCshxJgG9DjCn6EuALIYSoBlatWkVoaCgLFy6kY8eOhIWF0bt3b06dOoWvr2+B9tOmTWPZsmUsWrSIZs2asWXLFgYMGMBff/1lXKr3wgsvcOzYMZYuXUqdOnVYtmwZPXv2JDIyssK3ZLRFhs8almpXJrcS4Y9PYN9XanosGmg5VE1TLipQe/Rj037Wv6qmyYY8qM6MN31UDYCLw9L7e+v16tr48HfUQGrkRvX5uNSERz6wzGPczrcZPPYJ9JiuFhJz9lQrdhuCDCgYoEauVb8mX1VT3EF93dzrgE8TNaj2bmpaiKyoGfLWw8zPTD61OO/+mSlqoH92K+z5PK+Qm7kAus3w0s2QW6Job8PuRQe71vbYnHzBpEZ9fQuj0ajPqShF/e099U3eiRa9Dn54Wl3K0WZEyWtBJF9TX0/D799Db0Pr5yr2RN0jHxb/RI7WDu6fUPjtAD5Nrf57Iyn6JVDeaXuHLt9gwOd/EVjThT+nPGTx/oUoLknRF8K6qkuKfseOHWnfvr2xnoVerycoKIhXX32VKVOmFGhfp04d/vvf/zJu3DjjsYEDB+Li4sKyZctIT0/H3d2ddevW8dhjjxnbtG3blkceeaRYBQ4r8+tZHDq9wgMfbjepnp+fBvD3dGb3mw9hV15r8LMzYN+X8MenkJmkHmvQHXq9m2+b1NvkDyyTo2BMBHjmnrC5cRG2/FdN7TXMlnkEQrtR0GZk4bPllqqUnb+//YvVqt9ZqXnjeH5r3lgryvwORacJt3wG6j+oBvUuNUvWf0nS/kvSz51S6suirCdxLPV8y0N5v4Z3+ttLvADfPpa7bh31ZFJxa0FsnKTuaOB/r/q3VxGz9YUpr9fQgr83kqJfSRlS9ONSMtDrFesVtxFCCCHKWVZWFgcOHGDq1KnGY1qtlp49e7Jnzx6z98nMzCxwwsPFxYXdu3cDkJOTg06nu2Mbc31mZualCicnl2MBKRtgp9Xw/IP1eW/DiQK3GT51zOjbvPyCe1Bn6//8nxrc+7VQA/tGPe58nzsV0qoVAkOWqwXWDiyBA9+pAcf29yDiQ3X2uPkTee0tvXWVoqiz4Rv/oxa9M2g9XJ2xL842bJZmMitZSJpwx7GlD/wsta1tSVLqy6KsRXtteRvf8n4N7/S3V7s+vHYUTm9St/a7sBNOblAvXo3V30PD37bh727bTHVHAoPMZLUOgkdA2cdaWuX1Glrp90YCfBvi467+wWTrFG7cysLLzTarhwshhBBllZCQgE6nM+6QY+Dn58fJkyfN3qd3797MmTOHLl260LBhQ8LDw1m9ejU6nTrT4u7uTufOnZk1axZ33XUXfn5+rFixgj179hi3zb3d7NmzmTlzptnbqiK9XmHjUXWvbid7LZk5eR9e/T2dmdG3OX1aWPCDtmHm9NphddswjUZdy91ntlrY7N7BJZu5u1OgVjNITVHv+iYcX6um/kcfUaubG8ZyZKW693z0YTPVxm9Lar15GbJuqVXLDRWzs3MrZjvWUD+4nwuHLdMgvuAJE9o/b53gHiouvdxS29racgCdny1v41ver+GdakHc1Ve9xJ9Sa0Eczq0F4eiWF9iHvwfRhwre/8lF1g3u8yuv17CCf28kwLchDnZavN0cSUjNIjY5UwJ8IYQQIp+5c+cyZswYmjVrhkajoWHDhowaNYrFixcb2yxdupTRo0cTGBiInZ0dbdq0YejQoRw4cMBsn1OnTiU0NNR4PTk5maCgYq4hrYSW77vMocs3cXOyZ8vELlxOvEVcSga+7s50qF/bcjP3hg/1W6ZB4jn1Q+1TS6DFk+rt9w6yzOOYY+8ELQerlxuXwN1P3RqrqK2r1r4Cr+TLHvmmt/mt0kBdM+zqdVvxOhtTUbPjhseyRNBiywF0fja8ja9VX0Ofpmp9jB7T4dRmdRcCQy0ICvnfUpydJCpaeb2GFfR7IwG+jfF1d1YD/JQMmlP11v4JIYQQAN7e3tjZ2REbG2tyPDY2Fn9/f7P38fHxYe3atWRkZHD9+nXq1KnDlClTaNCggbFNw4YN2blzJ2lpaSQnJxMQEMDgwYNN2uTn5OSEk5ONflC3sLjkDD7apGZH/OfhJgTWciGwlotlH8QQ2G+dAbHH8o5r7NS18hWtVrD6ddObRa9J12WZXnetrc7Wm1TKzr3EHsvbQs6Wiq6ZU1lmx/Oz5QC6srDma+jkrlb8N6kFUQnLvlXS30MJ8G2Mv6czkdHJxEklfWEDpAanENZRHf72HB0dadu2LeHh4fTv3x9Qi+yFh4czfvz4O97X2dmZwMBAsrOz+eWXXxg0qOBscI0aNahRowY3btxgy5YtfPTRR+XxNCqVmb9GkpKZQ8u6njzXOcSynRe2vtZg0Pdw1+OWfcySKM6a9Mc+M73+8p+F95c/I8DWKqsXprLMjouqozh/d8LiJMC3MX4e6j/b2OTMIloKUX7s7dV/DZmZmbi4WHh2RwhRpOzsbADs7Gw09ddCQkNDGTFiBO3ataNDhw6EhYWRlpbGqFGjABg+fDiBgYHMnj0bgL179xIVFUWrVq2IiorinXfeQa/XM3nyZGOfW7ZsQVEUmjZtytmzZ5k0aRLNmjUz9lldbT8Zy8Z/o7HTavi/J+8pPBW/JNXG9Xp1di4pCna8d+c03LJUp7eE4qxJN7cfeln6s1WVdFZSVEKV+e+kEpMA38YY9p2NlRl8YUX29vbUqFGDxMRE3N3dq3yQIYQtURSFpKQknJyccHCwwbWJFjR48GDi4+OZPn06MTExtGrVis2bNxsL712+fBmtVmtsn5GRwbRp0zh//jxubm48+uijLF26lJo1axrbJCUlMXXqVK5evUrt2rUZOHAg77//ftV9LYsRkN/KyuHttccBeP6B+txdx9N8P0VtGZeZAlEH4Mo+uLIXrvyjVsKvGQw3Lxk6stATKweWXpNekWvchais5O+kwkmAb2MMW+XJDL6wNm9vb65cucKFCxfw9PTExcUFOzs7NOb2NBVClJmiKGRnZ5OUlERqaiqBgRW8b7aVjB8/vtCU/IiICJPrXbt2JTIy8o79DRo0yGzKfpVTgj3cw7adIepmOoE1XZjYs3Hh/RS2Zdzp3yH8XYg7XjDF1sEVWg6BM79Xntk5S69Jr4xr3IWoaPJ3UmEkwLcxeSn6MoMvrMvV1ZX69esTFxfHjRs3SEhIKPpOQogyc3JyIjAwEA8PKbQqzCjhHu7HryXxze4LALzXvwWujvbm+7l9y7gre/P2SLd3hNh/1e9r1lO3navbQd32zq+Fuk1Wt6mVLw3X0mvSZY27EEWTv5NyJwG+jcmbwZcAX1ifo6MjdevWNc4s6vWSSiVEebKzs6u6qeSibIoKyAGy09V933MyICcTXVY6WzYf5SlNMm2DXOju7An4qgXitk7PLYaXm5V1ezB+dT90HKt+X7e9WiSvbofC96uuzGm4ll6TLmvchSia/J2UGwnwbYxv7gx+QmomOTo99nbaIu4hRPnTaDQ4OjpaexhCCFE9FWcPd4Dka7C4t/GqHRAK4ADEA5GZEPLAbVvGFbJmvklePzjWgOb9ijdWScMVQgirkgDfxnjVcMJOq0GnV7ielmWc0RdCCCFENVWcPdxBDcRrNwB7Z7I0jhyNyeCW3oH6/rUJ8qkF/veo7R75ELbNUGf70WA2yPdqVLYxSxquEEJYhQT4NsZOq8HX3YnopAxikzMkwBdCCCGqO8+gfAF+IQE5gLs/TFBn+V9dup8tmbG0rleTX166D/Jvi1eRW1dJGq4QQlQoyf+2Qb5SSV8IIYQQBm2Hg8YeOryYV/hOU/j2pb8fj2HL8VjstRpmP3kPWnN73htm2MfsgGG/QMC9uTfIR0MhhKjMZAbfBvm5SyV9IYQQolrLugWOrur3zfvBxCNqlfzCqujnSs3MYcZ6dc/7MV0a0My/iN0YZM28EEJUKRLg2yCppC+EEEJUU4oCe7+EP+fCC9vAM1A9btgCr4iA/NPfTxGdlEFQbRcmPNS4kAcxQ9bMCyFElSABvg3y85AZfCGEEKLayc6ADa/DkR/U64d/gK6TzLc1E5AfvXqT7/66CMB7/e/BxbHwNP5CyZp5IYSo1CTAt0GyBl8IIYSoZpKiYNUwuHYQNFp4+D3o9ErR98sNyHN0eqau/he9Ak+0rEPXJpJiL4QQ1ZEE+DZIUvSFEEKIauTy37DqOUiLA5da8NQStdJ9CXz710WOX0vGw9metx9vXk4DFUIIYeskwLdBhhT9uBSZwRdCCCGqtHM7YPnToM8G37thyHKoXb9EXUTdTGfO1tMATH30LnzcJcVeCCGqKwnwbZB/7gx+YloWmTk6nOxLsYZOCCGEELYvqAP4NAWvRtD/c3CsUaK7K4rC9LXHuJWlo31ILQa3CyqngQohhKgMJMC3QZ4uDjjaa8nK0ROfkkndWq7WHpIQQgghLOVWopqKr9GoAf2IX/Oul9DmYzGEn4zDwU7D/w0oZM97IYQQ1YbW2gMQBWk0mnyV9CVNXwghhKgyrh6Az++D3XPyjrnWLlVwn5yRbdzz/qWuDWns526pUQohhKikJMC3UX7uUmhPCCGEqDIUBX5/G77uAanRcGi5ui1eGXyy5RRxKZmEeLkyrnsjCw1UCCFEZSYp+jZKKukLIYQQVYCiwJmtsG6cWiXf4In/gYNzqbs9dPkGS/++BMD7A+7B2UHq9QghhJAA32b5Soq+EEIIUXkpCpwLh20zIeZowdsd3UrcpU6vsO9CItFJ6Xy29TSKAk+2CeT+Rt4WGLAQQoiqQAJ8G2WYwY+TGXwhhBCicjm3A8JnwrVDFuty87FoZv4aSXRS3ucCjQY6N/Cy2GMIIYSo/Gx2Df6CBQsICQnB2dmZjh07sm/fvkLbHj9+nIEDBxISEoJGoyEsLKzMfVqbscheigT4QgghRKWy6U2LB/cvLztoEtyDmiQw+eejbD4WbbHHEkIIUbnZZIC/atUqQkNDmTFjBgcPHqRly5b07t2buLg4s+1v3bpFgwYN+OCDD/D397dIn9aWtwZfUvSFEEKISuWRD6FOa/V7TdnWxuv0CjN/jUS5Q5uZv0ai09+phRBCiOrCJgP8OXPmMGbMGEaNGkXz5s1ZuHAhrq6uLF682Gz79u3b8/HHHzNkyBCcnJws0qe1SZE9IYQQopJq2B3G7IBhv0DAveqxUgb66pr7wj8LKEB0Ugb7LiSWqn8hhBBVi80F+FlZWRw4cICePXsaj2m1Wnr27MmePXsqtM/MzEySk5NNLhXFEOCnZORwKyunwh5XCCGEEBag0UCjngUD/RJ+9Ior5lK94rYTQghRtdlcgJ+QkIBOp8PPz8/kuJ+fHzExMRXa5+zZs/H09DRegoKCSvX4peHmZE8NR/Vsv6TpCyGEEJXU7YF+nZbg5gs1fIp1d1/34m2lV9x2QgghqjabC/BtydSpU0lKSjJerly5UqGPL2n6QgghRBWRP9CfeAw8A4t1tw71axPg6YymsG6BAE9nOtSvbbGhCiGEqLxsLsD39vbGzs6O2NhYk+OxsbGFFtArrz6dnJzw8PAwuVQkX0MlfQnwhRBCiKpBowF78/WCzLHTapjRt7n5rnK/zujbHDttYacAhBBCVCc2F+A7OjrStm1bwsPDjcf0ej3h4eF07tzZZvqsCIYZ/DhJ0RdCCCGqrT4tAvhiWBvsbwvi/T2d+WJYG/q0CLDSyIQQQtgae2sPwJzQ0FBGjBhBu3bt6NChA2FhYaSlpTFq1CgAhg8fTmBgILNnzwbUInqRkZHG76Oiojh8+DBubm40atSoWH3aIknRF0IIIQSoQb6nyzGup2UxqXdT2tSrRYf6tWXmXgghhAmbDPAHDx5MfHw806dPJyYmhlatWrF582ZjkbzLly+j1eYlH1y7do3WrVsbr3/yySd88skndO3alYiIiGL1aYuMAX6KzOALIYQQ1Vm2Tk/irSwABrULwse9+Gn+Qgghqg+bDPABxo8fz/jx483eZgjaDUJCQlAUpUx92iI/WYMvhBBCCCA+JRNFAQc7DV41HK09HCGEEDbK5tbgizx5a/AlwBdCCCGqM8PJfl93Z7SSli+EEKIQEuDbML/cPW1jkjOKlaEghBBCiKrJGOB7SGq+EEKIwkmAb8MMb+IZ2XqSM3KsPBohhBDVyXfffUdGhmSQ2YrY3B11/HOz+4QQQghzJMC3Yc4Odni6OACSpi+EEKJijRo1ijp16vDqq69y5MgRaw+n2ovJ/RzgJwG+EEKIO5AA38blFdqTSvpCCCEqzgsvvEBOTg4LFiygTZs2dOrUiW+++Ya0tDRrD61aik2SAF8IIUTRJMC3ccat8mQGXwghRAX66quviI6O5quvvqJ9+/bs27ePF198kTp16vDSSy+xf/9+aw+xWolNMQT4sgZfCCFE4STAt3HGAD9FAnwhhBAVq0aNGrzwwgv8/fffHD16lHHjxmFvb89XX31Fx44dad26NQsXLiQ5OdnaQ63yYnJn8GUNvhBCiDuRAN/GGc7Ux0mKvhBCCCtq0aIF//vf/7h27RrLli2jS5cuHDlyhHHjxlGnTh2ef/55Dhw4YO1hVlmGzwG+EuALIYS4AwnwbZyk6AshhLAl2dnZpKSkkJKSAoCiKGRnZ7NkyRI6dOjAU089xc2bN607yComLTOHlEx1Nx1/TwnwhRBCFE4CfBvn666+kcdIgC+EEMKK/v77b55//nkCAgJ45ZVXOHr0KE8++SS///47ycnJLF++nHvuuYc1a9YwYcIEaw+3SjGc5HdzssfNyd7KoxFCCGHL5F3CxkmKvhBCCGu5ceMGS5cuZdGiRURGRqIoCkFBQbz55pu88MIL+Pv7G9sOHTqUp59+mtatW/Pbb79ZcdRVj+Ekv68U2BNCCFEECfBtnCFFPy4lA71eQavVWHlEQgghqoNhw4axevVqMjMz0Wg0PPLII7z00ks8+uijaLXmEwDt7e1p37493333XQWPtmoznOSXAntCCCGKIgG+jfNxd0KjgWydwo1bWXi5ydl7IYQQ5e+HH37A39+f0aNH8+KLL1KvXr1i3W/AgAEEBweX8+iqF8MMvp8E+EIIIYogAb6Nc7DT4lXDiYTUTGKTMyXAF0IIUSF++ukn+vXrh719yT4q9O3bl759+5bTqKonwxZ5EuALIYQoihTZqwQM6/BjU6TQnhBCiIoxcODAEgf3onzEpRgCfDnJL4QQ4s4kwK8EjOvwpZK+EEKICnLw4EFCQ0P5559/Cm2zb98+QkNDOXz4cMUNrBoyzODLGnwhhBBFkQC/EjDO4EslfSGEEBVk/vz5fP7554SEhBTapn79+nz++ecsWLCg4gZWDRne/30lwBdCCFEECfArAV939Q09RmbwhRBCVJBdu3bRpk0bfHx8Cm3j4+NDmzZt2LlzZwWOrHrR6xVjir6/pwT4Qggh7kwC/EpAUvSFEEJUtKioqDvO3hsEBwdz7dq18h9QNXXjVhbZOgUAX3dZgy+EEOLOJMCvBCRFXwghREVzcnLi5s2bRbZLTk7Gzs6u/AdUTRmy97zdHHGwk49tQggh7kzeKSoBwwx+rMzgCyGEqCB33303u3fvJjExsdA2iYmJ/PHHHzRv3rwCR1a9xOWe3Jct8oQQQhSHBPiVgOFNPSE1kxyd3sqjEUIIUR0MGzaM1NRUnnrqKa5evVrg9qioKAYNGsStW7d49tlnrTDC6sEwgy8BvhBCiOKQDW4rAa8ajthpNej0CtfTsuRNXgghRLl74YUXWLFiBRERETRp0oQ+ffrQsGFDAM6dO8eWLVtIT0/n/vvv56WXXrLyaKsuwxZ58t4vhBCiOCTArwS0Wg2+7k5EJ2UQm5whb/JCCCHKnb29PZs2bWLChAl89913rF271uR2Ozs7Ro0axdy5c7G3l48T5cVQQd9Qj0cIIYS4E3lHriR8PZxzA3wptCeEEKJiuLq68vXXXzNr1iwiIiK4cuUKAEFBQXTr1o2AgAArj7DqM8zg+8vJfSGEEMUga/ArCb/crXFipNCeEEKIChYQEMDQoUOZPHkykydPZujQoRYL7hcsWEBISAjOzs507NiRffv2Fdo2Ozubd999l4YNG+Ls7EzLli3ZvHmzSRudTsfbb79N/fr1cXFxoWHDhsyaNQtFUSwy3ooWK0X2hBBClIAE+JWE4Y09TgJ8IYQQVcSqVasIDQ1lxowZHDx4kJYtW9K7d2/i4uLMtp82bRpffvkl8+bNIzIykpdeeokBAwZw6NAhY5sPP/yQL774gvnz53PixAk+/PBDPvroI+bNm1dRT8uiYqXInhBCiBKQFP1KwrD2TrbKE0IIUZFu3brFjh07OHPmDCkpKWZnwjUaDW+//XaJ+54zZw5jxoxh1KhRACxcuJCNGzeyePFipkyZUqD90qVL+e9//8ujjz4KwMsvv8y2bdv49NNPWbZsGQB//fUX/fr147HHHgMgJCSEFStW3DEzwFZl5ei5npYFgL+nBPhCCCGKVqYA/9atWyQkJODl5UWNGjWMx2/cuMGHH37IsWPHqFevHm+88Yax8q4oHd/cM/eyBl8IIURF+fbbb3n99ddJTk42HlMUBY1GU+B6SQP8rKwsDhw4wNSpU43HtFotPXv2ZM+ePWbvk5mZibOzaaDr4uLC7t27jdfvu+8+vvrqK06fPk2TJk04cuQIu3fvZs6cOYX2mZmZ996a/7lam6HAnqOdllquDlYejRBCiMqgTCn6s2bNon79+pw8edJ4LDMzk06dOvHxxx/z22+/sXDhQjp37kx0dHSJ+i7JmjyAn376iWbNmuHs7Mw999zDb7/9ZnJ7amoq48ePp27duri4uNC8eXMWLlxYojFZk78xwJcZfCGEEOVv27ZtPP/882g0Gt566y06d+4MwJdffsmkSZNo1KgRiqIwfvx4Fi9eXOL+ExIS0Ol0+Pn5mRz38/MjJibG7H169+7NnDlzOHPmDHq9nq1bt7J69WqTzxhTpkxhyJAhNGvWDAcHB1q3bs3EiRN59tlnzfY5e/ZsPD09jZegoKASP5fyYjip7+vhZHJSRQghhChMmQL87du307BhQ9q2bWs8tmzZMs6cOUP37t3ZsmULEyZMICEhgc8++6zY/ZZ0Td5ff/3F0KFDef755zl06BD9+/enf//+HDt2zNgmNDSUzZs3s2zZMk6cOMHEiRMZP34869evL/0LUIGMa/BTZAZfCCFE+fv000/RaDTs2LGDWbNm0bhxYwDGjBnDBx98wPHjx5k4cSKLFy82+RxQnubOnUvjxo1p1qwZjo6OjB8/nlGjRqHV5n2c+fHHH1m+fDk//PADBw8e5LvvvuOTTz7hu+++M9vn1KlTSUpKMl4MOwXYAll/L4QQoqTKFOBfvnzZ+IZvsH79ejQaDUuWLKFXr16EhYXRpEkTNm3aVOx+86/JM8y0u7q6FjpDMHfuXPr06cOkSZO46667mDVrFm3atGH+/PnGNn/99RcjRoygW7duhISE8OKLL9KyZctKsybPsAY/MS2LzBydlUcjhBCiqvvnn3/o1KkTLVu2NHu7vb09n3zyCb6+vsyYMaPE/Xt7e2NnZ0dsbKzJ8djYWPz9/c3ex8fHh7Vr15KWlsalS5c4efIkbm5uNGjQwNhm0qRJxln8e+65h+eee47XX3+d2bNnm+3TyckJDw8Pk4utkC3yhBBClFSZAvwbN25Qs2ZN43VFUdi9ezf33nuvSYpby5Yti31G3LAmr2fPnnmDLGJN3p49e0zag5rGl7/9fffdx/r164mKikJRFHbs2MHp06d5+OGHCx1LZmYmycnJJhdr8XRxwNFe/XHFyyy+EEKIcpaamkq9evWM152c1BPNKSkpxmNarZaOHTuya9euEvfv6OhI27ZtCQ8PNx7T6/WEh4cblwMUxtnZmcDAQHJycvjll1/o16+f8bZbt26ZzOgD2NnZodfrSzxGa4vNXYPvm3uSXwghhChKmQJ8f39/Lly4YLx+4MABbty4QdeuXU3alWTdWGnW5MXExBTZft68eTRv3py6devi6OhInz59WLBgAV26dCl0LLa0Lk+j0UglfSGEEBXG39+fxMRE43XDvvenT582aZeYmEh6enqpHiM0NJRFixbx3XffceLECV5++WXS0tKMVfWHDx9uUoRv7969rF69mvPnz7Nr1y769OmDXq9n8uTJxjZ9+/bl/fffZ+PGjVy8eJE1a9YwZ84cBgwYUKoxWlOszOALIYQooTIF+K1atWLfvn2sXbuWlJQUZs2ahUaj4fHHHzdpd+bMGerUqVOmgZbVvHnz+Pvvv1m/fj0HDhzg008/Zdy4cWzbtq3Q+9jaujw/d6mkL4QQomI0a9aMM2fOGK/fd999KIrCRx99ZNwq76+//mL79u00bdq0VI8xePBgPvnkE6ZPn06rVq04fPgwmzdvNp60v3z5skkBvYyMDKZNm0bz5s0ZMGAAgYGB7N692ySbcN68eTz11FO88sor3HXXXfznP/9h7NixzJo1q1RjtCbD+72swRdCCFFcZdomb/LkyWzYsIGBAwcCaop+q1ateOihh4xtYmNjOXLkCEOHDi1Wn6VZk+fv73/H9unp6bz11lusWbPGuC/uvffey+HDh/nkk08KpPcbODk5GVMSbYGfVNIXQghRQR577DFee+019u3bR4cOHejRowf33nsvP//8M4GBgQQEBHDs2DH0ej0TJ04s9eOMHz+e8ePHm70tIiLC5HrXrl2JjIy8Y3/u7u6EhYURFhZW6jHZCimyJ4QQoqTKNIN/3333sWbNGh544AGaNWvGsGHDWL9+vcnatxUrVuDu7k6fPn2K1Wdp1uR17tzZpD3A1q1bje2zs7PJzs6u9GvyfI0p+jKDL4QQonwNHz6cTZs2GWfTtVotGzdupFevXsTFxXHo0CFcXV157733GDZsmJVHWzUZAnx/TwnwhRBCFE+ZZvBBXevWt2/fQm+fOHFiic/sh4aGMmLECNq1a0eHDh0ICwsrsCYvMDDQWBH3tddeo2vXrnz66ac89thjrFy5kv379/PVV18B4OHhQdeuXZk0aRIuLi4EBwezc+dOvv/+e+bMmVO6J24FhjV4cTKDL4QQopx5enrSu3dvk2OBgYFs3ryZW7dukZSUhK+vL3Z2dlYaYdWWkpFNWpa6a46fFNkTQghRTGUO8MvD4MGDiY+PZ/r06cTExNCqVasCa/Lyz8bfd999/PDDD0ybNo233nqLxo0bs3btWlq0aGFss3LlSqZOncqzzz5LYmIiwcHBvP/++7z00ksV/vxKy5iinyIBvhBCiPIVGhpKrVq1ePvttwvc5urqiqurqxVGVX0YZu/dne1xdbTJj2tCCCFsUJneMWJjYzl16hRNmzY1qWJ/7tw5/vvf/3Ls2DHq1avH22+/XeSWN7cryZo8gKeffpqnn3660P78/f1ZsmRJicZgayRFXwghREWZP3++yfZzomJJgT0hhBClUaY1+B988AHdu3cnKSnJeCw5OZkHHniAn376icjISDZv3kzPnj1NKvGK0pEie0IIISpK3bp1K1WdmqomRrbIE0IIUQplCvAjIiJo3rw5TZo0MR779ttviY2NZejQoZw6dYo5c+aQnp7Op59+WubBVneGAD8lI4dbWTlWHo0QQoiqrH///uzcuZOUlBRrD6VaMizH85X190IIIUqgTAF+VFQUDRo0MDm2ceNG7O3tCQsLo3HjxkycOJGWLVuyc+fOMg1UgJuTPTUc1WJGkqYvhBCiPM2cOZN69erx6KOPcujQIWsPp9qJlRl8IYQQpVCmNfgpKSkmRXZ0Oh179uyhbdu2eHt7G483a9aMDRs2lOWhRC4/D2fOJ6QRm5xBfe8a1h6OEEKIKqpfv344OTnx559/0q5dOwICAqhXrx7OzgUDTo1GU2C7WlE2sgZfCCFEaZQpwK9Tpw4nT540Xt+9ezepqal069bNpF1OTg6Ojo5leSiRy9fDyRjgCyGEEOUlf0FbRVG4du0a165dM9tWo9FU0Kiqj5jc93kJ8IUQQpREmQL8zp07s2LFCsLCwujRowfTpk1Do9HQt29fk3YnTpwgMDCwTAMVKkOqXpyk6AshhChHFy5csPYQqrW43ADf31MCfCGEEMVXpgB/6tSprF69mjfeeANQz/B3796d++67z9jm4sWLREZG8vzzz5dtpAKQSvpCCCEqRnBwsLWHUG3p9QpxKYYUfSmyJ4QQovjKFODffffd7N69m7lz55KQkEDbtm2ZNGmSSZstW7bQsmVL+vfvX5aHErl8DQF+iszgCyGEEFVRQlomOXoFjQZ83CTAF0IIUXxlCvAB2rRpw3fffVfo7WPHjmXs2LFlfRiRy3AmX2bwhRBClKfLly+XqH29evXKaSTVj2EZnrebE/Z2ZdrwSAghRDVT5gBfVCxJ0RdCCFERQkJCil08T6PRkJOTU84jqj5iZIs8IYQQpWSRAD82NpbFixeza9cuoqKiAAgMDKRLly6MGjUKPz8/SzyMAPzc8wJ8RVGkcrEQQohy0aVLF7PvMXq9nitXrnD58mX0ej2dO3eWnXIsLDbFUEFf0vOFEEKUTJkD/F9++YXRo0eTmpqKoijG4//++y9btmzhgw8+4JtvvmHgwIFlfSiBuk0eQEa2nuSMHDxdHKw8IiGEEFVR/m3yzDl9+jQvvPACiqKwadOmihlUNRGbJFvkCSGEKJ0yLezav38/Q4cOJS0tjQEDBrBmzRoOHTrE4cOHWbt2LU8++SSpqak888wz7N+/31JjrtacHeyMQX2cpOkLIYSwkiZNmrB69WoiIyOZMWOGtYdTpcQmGyroS4AvhBCiZMoU4M+ePRudTsdPP/3Ezz//TL9+/WjZsiX33nsvTzzxBD/99BM//fQT2dnZfPDBB5Yac7Xnb1yHL5X0hRBVkKJAjvx/qwy8vb3p2LEjK1eutPZQqpSYZFmDL4QQonTKFODv3r2b++67jwEDBhTaZsCAAdx///3s2rWrLA8l8vGVSvpCiKpIUeDsNljUHT5rAUlXrT0iUQyKohAbG2vtYVQphvd3P08J8IUQQpRMmdbgJyUlFWtbnHr16vHPP/+U5aFEPsZK+ikS4AshqgBFgXPhsP09uHYI9dyzHtISwLOutUcn7uDQoUPs3LmT4OBgaw+lSjEG+FJkTwghRAmVKcD39/fn0KFDRbY7fPgw/v7+ZXkokY/hDT9OUvSFEJXZ7YG9xi73Br1VhyVU7777bqG3paamcvr0aTZt2kROTg5jx46twJFVbRnZOm7cygYkRV8IIUTJlSnA7927N19//TVvvfUWs2bNws7OzuR2RVF4++23OXnyJGPGjCnTQEUewwy+YZ9cIYSodM7tgPCZpoG9orPumISJd955B41GY7JDzu1cXV2ZOnUqoaGhFTiyqi0+RT1572ivlZ1yhBBClFiZAvy3336b1atX8+GHH7JixQoGDRpESEgIAJcuXeKnn37i4sWLeHl5MW3aNEuMVwC+7pKiL4So5Da9CQmn1O8lsLdJS5YsKfQ2R0dHAgICaN++PTVq1KjAUVV9+QvsaTQaK49GCCFEZVOmAL9u3bps376dZ599lmPHjvHxxx8b34wMZ/zvueceli9fTt26so7SUiRFXwhR6T0wEdZPAH22tUdiGxQFdFlgbztrrkeMGGHtIVRLsv5eCCFEWZQpwAc1gD969CgRERHs2rWLa9euAVCnTh0efPBBunXrVtaHELcxpOjHpWSg1ytotXKGXwhRidy4BDv+Tw3uPeuCcy2I/dfao7KO/HUIkqLgxR1SWLCaMyy/85P190IIIUqhzAG+Qbdu3QoN5hcvXszVq1eZPn26pR6uWvNxd0KjgWydwo1bWXi5yVl+IUQlcfMKfPc4JF0Br8YwciO4+apB7raZEHM0r+35HVCnldWGWq4qwc4BBw8eZNmyZQwdOpT27dubbbNv3z5WrlzJ8OHDadWqVcUOsIqKy12DLwG+EEKI0tBWxIMsWrSImTNnVsRDVQsOdlq8aqhBfayk6QshKovka/BdX7h5GWo3hBG/grsfaDTQqCeM/QOGrABnT7X9tnfg7y+sOmSLUxQ4sQEWdYdlAyHacELD9nYOmD9/Pp9//rmxto459evX5/PPP2fBggUVN7AqzjCDLxX0hRBClEaFBPjC8gxr86TQnhCi0tjxf3DjAtQKUYN7jwDT2zUaaPYoTDoPbUerxzZPgd+ngd72AuASO7cDFnSAVc/CtcPqMRsuMLhr1y7atGmDj49PoW18fHxo06YNO3furMCRVW3GNfieEuALIYQoOQnwKynjOvxkCfCFEJXEIx9B62FqcO8ZWHg7O3t4fA70mKFev/KPWoCusls9BhJO514pfOs5WxEVFXXH2XuD4OBgY/0dUXbGAN9dlt8JIYQoOYutwRcVyzCDH5MkKfpCCBuWlQYOrursvKMr9CtmKrdGAw+GglcjCHkAHKrAbGaHF2HH++r3Gjubnr0HcHJy4ubNm0W2S05Oxs7OrvwHVA0oipK3TZ7M4AshhCgFmcGvpHzd1Td+SdEXQtistOvwdS/YPktde14azZ8A19p51/d+BcnRlhlfeVMUdccAg66T4YVwGPYLBNyrHtPYbmB89913s3v3bhITEwttk5iYyB9//EHz5s0rcGRVV3JGDhnZ6nIUKbInhBCiNCTAr6QkRV8IYdNuJcLSfhB3HA4tU6vDl9XB72HTJPimF8SdLHt/5elWIvz4HHzZRd3+zqBuO7Wg4JgdpoG+Db4dDxs2jNTUVJ566imuXr1a4PaoqCgGDRrErVu3ePbZZ60wwqrHkJ7v6eKAs4PtnvwRQghhuyRFv5IyFtmTKvpCCFuTfgOW9oeYf6GGL4zYAG6FF2ortvpd1a31rp+BxQ/D0FUQ3Lns/Vraue2w5mVIjQGtA1zZC55PmrYx7BzQsEfednnJUVDDAq+ThbzwwgusWLGCiIgImjRpQp8+fWjYsCEA586dY8uWLaSnp3P//ffz0ksvWXm0VYNx/b2HrL8XQghROiUK8GWNne0wzODHygy+EMKWZCTB0ich+gi4esOI9eDTxDJ91wqG53+HHwbD1X3wfT8Y+LWaxm8LsjMgfCb8/bl63bsJPLkI6rQq/D75A31dFtjbTmBnb2/Ppk2bmDBhAt999x1r1641ud3Ozo5Ro0Yxd+5c7O1lvsASDFvkSXq+EEKI0ipRTqCiKKW+lNSCBQsICQnB2dmZjh07sm/fvju2/+mnn2jWrBnOzs7cc889/PbbbwXanDhxgieeeAJPT09q1KhB+/btuXz5conHZgsMb/4JqZnk6KrA9lFCiMovI1nd2/3aQXCpBcPXge9dln0M19rqSYNmj4MuE34crq7Lt7bY4+re9obgvv0L8OLOOwf3+Wk0NhXcG7i6uvL1119z+fJlli9fzgcffMAHH3zA8uXLuXz5Mt988w1ubm7WHmaVEZeiZuVJgC+EEKK0SnTKXV9B+xCvWrWK0NBQFi5cSMeOHQkLC6N3796cOnUKX1/fAu3/+usvhg4dyuzZs3n88cf54Ycf6N+/PwcPHqRFixaAmk74wAMP8PzzzzNz5kw8PDw4fvw4zs6V803Uq4YjdloNOr3C9bQs+TAghLC+C3/A1X/AuaYa3Pu3KJ/HcXCBQd/Db5Ng/zfquvx6nfKtZ7+NopT/7PjBpRAXqabY91sATXqX32NZQUBAAEOHDrX2MKo8wwy+v7ynCyGEKCWNUprp9XLWsWNH2rdvz/z58wH1xEJQUBCvvvoqU6ZMKdB+8ODBpKWlsWHDBuOxTp060apVKxYuXAjAkCFDcHBwYOnSpaUeV3JyMp6eniQlJeHh4VHqfiyl8+xwopMyWDfufloG1bT2cIQQAg7/oM7a12ld/o+lKLB7Dmjt4f7XzN9uWN+eFAUv7gDPuuUzlux02Doduky2TL2BEiiv9ya9Xk9qaiouLi44ODiYbZOdnU16ejpubm5otbZXKLA0rPle/+L3+/k9MpZZ/VvwXKfgCn1sIYQQtqsk7002926clZXFgQMH6Nmzp/GYVqulZ8+e7Nmzx+x99uzZY9IeoHfv3sb2er2ejRs30qRJE3r37o2vry8dO3YssJ7wdpmZmSQnJ5tcbImvrMMXQlhbdrpaMd6g1TMVE9yDmtb+4BumwX1KLKQnwdltasr8soFw7QikxVmmkj+oJw7+/RlWDQN97l72Di7w6McVHtyXp88++4xatWqxc+fOQtvs3LmTWrVqMW/evAocWdVlLLLnbnvLNYQQQlQONhfgJyQkoNPp8PPzMznu5+dHTEyM2fvExMTcsX1cXBypqal88MEH9OnTh99//50BAwbw5JNP3vGDy+zZs/H09DRegoKCyvjsLMvwASA2RSrpCyGsIDsDVj4DSx6FmwW3Uatw6UnwzcPwaVM1sI8+mnuDhZaXKQqc+BU+agi/PK9+f3i5Zfq2QWvWrCEoKKjACfT8evbsSd26dfnll18qcGRVV0xugO/vKSn6QgghSsfmAvzyYKgd0K9fP15//XVatWrFlClTePzxx40p/OZMnTqVpKQk4+XKlSsVNeRiMay7j5MZfCFERcvJVGewz22H+JPw5QOQZMUg/9wOWNwbbl6EnHT1mKIzbZNwJu/7jCS4cRGybhXdt6KoGQELOqjPOf26erzVs3DvEEuM3iadOXOGu+++u8h2LVq04MyZM0W2E3em0yvES5E9IYQQZWRz+9p4e3tjZ2dHbGysyfHY2Fj8/f3N3sff3/+O7b29vbG3t6d58+Ymbe666y52795d6FicnJxwcrLdNDnDGX5J0RdCVKjsTPjuMbWgnkH6DTUFvrzWuBdl05uQcOrObdLzLSU4+Ruszd273dFdTa1381OL5Ln5QdsR4NdCXcO/bSbEHC3YX4cXwd7Rcs/BxiQlJeHp6VlkO09PT27cuFEBI6raElIz0Sug1YC3m+1+9hBCCGHbbG4G39HRkbZt2xIeHm48ptfrCQ8Pp3Pnzmbv07lzZ5P2AFu3bjW2d3R0pH379pw6Zfrh7/Tp0wQHV94iNr6GFP1kSdEXQhSToqiz76WRmQZ//g8+aWwa3GMDtVof+TBv7b/GznybWvn+32engX3uLGlWCiSeh8t74MR6+GcRnP49bw1/zL/lO3YbFRAQwNGjZk5s3Obo0aNmd7gRJWM4We/j7oSdVmPl0QghhKisbG4GHyA0NJQRI0bQrl07OnToQFhYGGlpaYwaNQqA4cOHExgYyOzZswF47bXX6Nq1K59++imPPfYYK1euZP/+/Xz1Vd7eyJMmTWLw4MF06dKF7t27s3nzZn799VciIiKs8RQtwk+K7Akhiqs4FeX1ekiOUoNdw6VuO2jeT02B3zIV4k5YZ/xFadgdGnTLe47XDqmBfv40fbd8WWDtX4B2z0NmMqTGq0X4UmPV71Nj4fAy9fkDNnECwwoeeughvv32W1atWsXgwYPNtvnxxx+JjIzkueeeq+DRVT2yRZ4QQghLsMkAf/DgwcTHxzN9+nRiYmJo1aoVmzdvNhbSu3z5ssl2PPfddx8//PAD06ZN46233qJx48asXbuWFi3y9mAeMGAACxcuZPbs2UyYMIGmTZvyyy+/8MADD1T487MU4xp8KbInRNVV1j3c8wf21w4BGkDJS6dPjYdfJ+QG9BdAd9v/k1bD1AC/OCnw1qbRQKOe0LDHbc9Zi9lCexoNOHuqF+9GpreFPADhM82fKKgmJk2axA8//MDw4cPZtWsXL774Ig0bNgTg3LlzfPXVVyxatAhHR0cmTZpk5dFWfoaCub4S4AshhCgDjaIo1XNqohSsuTeuOTdvZdHq3a0AnHqvD072haSlCiEqTlkD8vz9lHYPd70erp+DyLVw8Fvzxe9e3Al1Wqnb3L2fb2Zbaw+1QqB2A/USfF/eDH5RAa+hT1uR/zVMjoIxEeAZWLr7m3veNvJ8y/O96aeffmLEiBFkZhY8kawoCs7OzixZsqTQGf7KyFrv9Z9sOcX8HWd5rlMws/q3KPoOQgghqo2SvDfZ5Ay+KB5PFwcc7bVk5eiJS84kqLartYckRPmzVABtaWUJyAvrJ//s8+0F7LIz1CrwhlR6Nz+492n1tjNbYEUxq7s7uEC/BeBRRw3oPeqCnZm3huKkwNua/DP6pfmdKWlGQBX09NNP07p1a+bMmUN4eLhxNxnD9nkTJ06kcePG6PV6k8w6UXKyRZ4QQghLkAC/EtNoNPh5OHElMZ24lAwJ8EXVZqkAujzHdaeAvKT9GAvF5QaSih7W50ulT47CZG14/S55Af7WGSV7Dq2HFa9dZQ14NZqynRAy97yTo9SK+9VAo0aN+Pzzz83edujQIUJDQ1m5ciXXrl2r4JFVLYZ6OoYCukIIIURpSIBfyfm5O3MlMV0q6Yuqy1IBdHmM68zvsOUtuH62YEB+eDmc3Qp6HeiyQZ+jXjzrQqeX8/rZ9CbERUL0Uci4ma//22bGNVo4tUktBmfg5AG166sz74Ft844/8mH5rh+vrgFvWTMCqogrV66wfPlyli1bxokTJ1AUBY1Gqr6XVazM4AshhLAACfArOT9PqaQvqqiiZrStRZcNf82Dv+ZD+vW847cH0fu+wqzAdqYB/olfc2fji+GhaerWbrUbqIG9q5cadN6uotLpq2vAW9aMgEooJSWFn376iWXLlvHHH3+gKAqKohAYGMjgwYMZOnSotYdY6RlO1PtJkT0hhBBlIAF+JefnbgjwZQZfVCG3F3QD66/1Pr8Tjv2iBuTpiUW3b/IIuPmA1kEtXKe1B60d1Kxn2q7LJHWf9TNbcovh5Va5N6ftiOKPtyLT6athwFsd6HQ6Nm/ezNKlS/n111/JyMjAUJdXo9EQERHBgw8+KLP3FpCRrSMpPRuQAF8IIUTZSIBfyfl5qB+q42QGX1Ql+bdkKyywP7RcXZce0ArKUtyrsKJ9er1pv7s+hQs71e+dPMDOAW5dL3xmvNuU4lVYbzcqbxzlMeNeXdPpRan9888/LF26lFWrVpGQkICiKDg4OPDEE08wbNgwPvroI/bv30+XLl2sPdQqw5CF5+ygxcNZPpoJIYQoPXkXqeQMZ/pjUyTAF1WEXg9ejfICfI1WDeRv989X6sWlFtTvqqavezcu/uOYK9rn5g+X/oTja+DkRnhpF7jnbiHX+jk1Lf7uARD8gDobb8mAvLxn3KtrOr0otvfee4/ly5dz+vRp40z9fffdx7Bhwxg0aBC1a9cGICwszIqjrJpiknLX33s4S0aEEEKIMpEAv5LzzZ3BN3w4EKJS0+vg1wlwaqN6vcNYuLrPfAAdfL9amC79hrrf+8Pv5d124Q/ISIKQB8GlpuljFCjal5sSv3kqXPoLbiXktT25Adq/oH5/79N5VeoNyiMgL+8Zd0mnF4WYPn06Go0Gf39/XnnlFZ599llCQkKsPaxqITZFXWbnK+n5QgghykgC/ErOMIMfJ2vwRWWny4Y1Y9V17hot9P8CWg4pvIp+7/8Dv7sh6oB6qRmU19eeBXB6s9pPYFtokFt0LisVImbfVrQvd737ifXqV5dacFdfdaY+5MGix11eAbnMuAsrUBSFmJgYtmzZgq+vL08//TQ1a9a09rCqvNh8M/hCCCFEWZRh4aqwBYYAPyUzh7TMHCuPRohSys6AH4erwb3WHp5aogb3kBfojtkBw36BOi3BzVcNoO0coF4n6DzOtD/fu8CrsZraf/Uf+OMj+PZR+GEQXDustrk9nb7pozBsNfznDDwxDxo+pPZfXPnHOfEYeAaW+uUo0K8E96IC7N27l3HjxuHl5cXu3bt56aWXCAgIYODAgaxevZrs7OxyedwFCxYQEhKCs7MzHTt2ZN++fYW2zc7O5t1336Vhw4Y4OzvTsmVLNm/ebNImJCQEjUZT4DJu3LhCerW+GNkiTwghhIVIgF/JuTnZU8NRnYmMS5FZfFFJnfkdTv0Gdk4w5Ae4u3/BNiUJoHu+A6/uV9s9MR+c3PPdWEiF+q5vQqMeJQvqzZGAXFRS7du3Z968eVy7do1169bx1FNPodFoWLNmDU8//TQBAQGMHTuW2NhYiz3mqlWrCA0NZcaMGRw8eJCWLVvSu3dv4uLizLafNm0aX375JfPmzSMyMpKXXnqJAQMGcOjQIWObf/75h+joaONl69atADz99NNm+7QFhiJ7vu7yv0MIIUTZSIBfBfh5GrbKk3X4opJq/gT0mgXP/ghNet+5bUkC6JpB0OY5GLQU6rQ2dFCmoQpR1dnb29O3b19WrVpFTEwMixYt4sEHH+TGjRssWrSIc+fOATBlyhQOHz5cpseaM2cOY8aMYdSoUTRv3pyFCxfi6urK4sWLzbZfunQpb731Fo8++igNGjTg5Zdf5tFHH+XTTz81tvHx8cHf39942bBhAw0bNqRr165lGmt5ipUZfCGEEBYiAX4V4OcuAb6ohG4lQvrNvOv3T1DXyZeHht3zpfi3Uo8Z1+ALIQrj4eHB888/T0REBBcvXuT999+nWbNmKIrCxx9/TNu2bbnrrruYNWtWifvOysriwIED9OzZ03hMq9XSs2dP9uzZY/Y+mZmZODubBsEuLi7s3r270MdYtmwZo0ePLrQ6fWZmJsnJySaXihabW0fHT9bgCyGEKCMJ8KsAv9xK+lJoT1QaqfHwXV9Y/hRkplTMY96+lj/g3twb5N+gEMURFBTE1KlTOX78OPv372fChAn4+vpy6tQp3nnnnRL3l5CQgE6nw8/Pz+S4n58fMTExZu/Tu3dv5syZw5kzZ9Dr9WzdupXVq1cTHR1ttv3atWu5efMmI0eOLHQcs2fPxtPT03gJCgoqtG15UBQlbw2+BPhCCCHKSD7Z2gpFgZzSBeiGM/4ygy8qheRrasG72GNw4xKkmP8gX27uVLRPCFEsbdq04bPPPiMqKoqNGzcyZMiQCnncuXPn0rhxY5o1a4ajoyPjx49n1KhRaLXmP8588803PPLII9SpU6fQPqdOnUpSUpLxcuXKlfIavllJ6dlk5ahba/rIGnwhhBBlJNvkWVv+LcCSouDFHeBZt0RdGPbNjZEAX9i6Gxfhuyfg5iXwCITh68G7kXXGItvQCVFmWq2WRx55hEceeaTE9/X29sbOzq5A0b7Y2Fj8/f3N3sfHx4e1a9eSkZHB9evXqVOnDlOmTKFBgwYF2l66dIlt27axevXqO47DyckJJyfr/f0b3rtruTrg7CBLh4QQQpSNzOBbi6LA2W2wqDssGwjXjkBaHKQllLgrSdEXlULCWVjyqBrc1wqBUZusF9znJ1XvhbAKR0dH2rZtS3h4uPGYXq8nPDyczp073/G+zs7OBAYGkpOTwy+//EK/fv0KtFmyZAm+vr489thjFh+7Jcn6eyGEEJYkM/gVLf+M/bVD+Qp96UvdpTFFP0Vm8IWNio2E7/upJ7G8m8DwdeBReMqsEKJ6CA0NZcSIEbRr144OHToQFhZGWloao0aNAmD48OEEBgYye/ZsAPbu3UtUVBStWrUiKiqKd955B71ez+TJk0361ev1LFmyhBEjRmBvb9sfdWKT1PduCfCFEEJYgm2/61U153ZA+EzTwF7Rlbnb/FX0FUUptFKwEFZj5wAo4HcPPLcG3GS9uxACBg8eTHx8PNOnTycmJoZWrVqxefNmY+G9y5cvm6yvz8jIYNq0aZw/fx43NzceffRRli5dSs2aNU363bZtG5cvX2b06NEV+XRKRQrsCSGEsCQJ8CvSpjch4ZT6vQUCewMvN0cAMrL1hJ+Mo3tTX+y0EuQLG6Ao6vp278YwYgO4+4FLLWuPSghhQ8aPH8/48ePN3hYREWFyvWvXrkRGRhbZ58MPP4yiKJYYXrkzFMg1LLcTQgghykLW4FekRz6EOq3V7y20B/fmY9H0nLPTeP2F7/bzwIfb2XzM/JZBQlQIRYFdc2B+O/isBSRdBd9mEtwLIcRtjAG+p8zgCyGEKDsJ8CtSw+4F9+DW3PYjuHaw2N1tPhbNy8sOEp1kuvY+JimDl5cdlCBfVDxD8ch5bdXlKNfPlrp4pBBCVAfGInvuEuALIYQoOwnwK9rte3AHtDS9fUMo7Pq0yG50eoWZv0ZiLgHRcGzmr5Ho9JUjRVFUcrfvCpF4ztojEkKISsG4Bl9m8IUQQliABPjWYi7Qt3cGFEi/WeTd911ILDBzn58CRCdlsO9CosWGLIRZ53bk2+7xsLVHI4QQlUaOTk9CqjqD7ytr8IUQQliAFNmzNkOg37CHWozs7DZo/HDe7Xo9aAueh4kr5pZ4xW0nRKnlLx5pNqdECCGEOfGpmSgK2Gk1eNeQAF8IIUTZyQy+rdBowN4Jmj2Wu6UYkJMF3z8B+xapKdD5+BZzrV5x2wlRao98CJ5B1h6FEEJUOob1977uTmhl9xshhBAWIAG+LTu6Ci7ugt/+A788D5mpxps61K9NgKczd/o4EODpTIf6tct/nKJ6ubofVg2Dg9+r1xt2h3H/QNcpFt8lQgghqrKYJMMWeXIyXgghhGVIgG/LWg+Dh98HrT0c+0Vd5xx3ElDT+Wb0bQ5QaJA/+v762MmMgLAEvR5Ob4Elj8LXPeDEr/Dn//IySxxdoPvUgrtEyL8YIYQolGGLPH8J8IUQQliIfPq2ZRoN3DceRm4E9wBIOK0G+Ud/AqBPiwC+GNamQOVdZ3v1x/rLwatk5egrfNiiCsnJgsMr4Iv74IdBcOlP0DpAq2EweJn6O5rf7cUj67QEN1+o4WOd8QshhA0zBPh+UmBPCCGEhUiRvcqgXicYuwtWvwDnI9SvyVHwwET6tAigV3N/9l1IJC4lA193Zxr41OCRubs4GZPC/8LP8J/eTS0zDkVRCwHayweRKuv2n/H6V+HoSvV7R3doNwo6vQwede7cz+3FI+V3RgghCjBskecnW+QJIYSwEJuewV+wYAEhISE4OzvTsWNH9u3bd8f2P/30E82aNcPZ2Zl77rmH3377rdC2L730EhqNhrCwMAuPupy4+cCw1dD1TXDyhLv6Gm+y02ro3NCLfq0C6dzQCz8PZ97vdzeOZPPFznMcvnKzbI+df4/zz1pA0tWy9Sdsj+FnvPBBmNM872fcehi4+UHPdyD0ODw8q+jgPj9D8UghhBAFxOUW2fOTgrhCCCEsxGYD/FWrVhEaGsqMGTM4ePAgLVu2pHfv3sTFxZlt/9dffzF06FCef/55Dh06RP/+/enfvz/Hjh0r0HbNmjX8/fff1KlTgkDFFmjtoPtbMOEQeDXMO554Pu/73EDtkb+fYX+NifjqE3jjx8NkZOtK/nj5A/tlA+HaEUiLg7SEsj8XYRmKAjmZZbv/2W1qCv6ygRD7L9xKyPsZhzwAE/+FB14HZ0/LjFkIIQSQN4N/+1I7IYQQorRsNsCfM2cOY8aMYdSoUTRv3pyFCxfi6urK4sWLzbafO3cuffr0YdKkSdx1113MmjWLNm3aMH/+fJN2UVFRvPrqqyxfvhwHB4eKeCqWV8Mr7/vzO2FeO/h9Opz+3SQY99DdoKFbBufi0/j091OF93c7RYHj69TZ3GUDIfpo7g2ynt9mlDWrIu26uv3i/9qoP+O4yNsfQP0iM/BCCFFuZA2+EEIIS7PJNfhZWVkcOHCAqVOnGo9ptVp69uzJnj17zN5nz549hIaGmhzr3bs3a9euNV7X6/U899xzTJo0ibvvvrvIcWRmZpKZmTc7mpycXMJnUgEu/QWKDv6aq16MNfXVYHzCQ43YvT6dr3df4OXYmdTWJYAuU531zclU10fnZIJ3Y3j+dzi3A8JnwrVDeY+hlGL2X5QPRYFz4bD9vdyfkRbQqzPunnXV2zOS1BoNSVGQfFX9mhYPT/xP7ePcDvhxOGTe6fdZdl8QQojydCsrh5SMHEC2yRNCCGE5NhngJyQkoNPp8PPzMznu5+fHyZMnzd4nJibGbPuYmBjj9Q8//BB7e3smTJhQrHHMnj2bmTNnlnD0FejcDjiz5baDism1DiG1GdROw4/7r5J55QAo8eb7Sr+hft30JiQUMdu//T0Y9nPpxmwyVBsv2lce4yttn4bAPvxdiD4CGkPyTb6sig2vw9EfISvVfB8Pz1LT7De9WURwL4QQorzFJKmz966Odrg52eTHMSGEEJVQtXlHOXDgAHPnzuXgwYNobt/aqxBTp041yQpITk4mKCiovIZYcsUJxoFpjzdn95kEpqaMolfT2jx7f2Owc1KDTHsn9XtHV7XxIx/mzeBr7MzP3uuy8r5XFFg1DPxaQPB9ULd9Xl+FyT8LnRQFL+5QZ59tRXmMr7h9ZmeAQ76ZnEPL4PAP6s8j+1a+/gpZLmEI7l1qgUdd8AwEj0D1q0FxfsZCCCHKVWxugT1/D+dify4RQgghimKTAb63tzd2dnbExsaaHI+NjcXf39/sffz9/e/YfteuXcTFxVGvXj3j7TqdjjfeeIOwsDAuXrxYoE8nJyecnGx0dhmKHah5ODvw0VMtGfZNBhEnIPi+VjxQ39t8nw27Q4Nupmngt/fdZnje99fPwckN6gXUPdID26jBfvADENQBnD3U24pKL7e28hhfYX2e2gRae7h5OfdySf2aGgtTruS9ZlEH1L3ni+P+idDpFbXKvWONwtsV52cshBCiXOWtv5f0fCGEEJZjkwG+o6Mjbdu2JTw8nP79+wPq+vnw8HDGjx9v9j6dO3cmPDyciRMnGo9t3bqVzp07A/Dcc8/Rs2dPk/v07t2b5557jlGjRpXL8yh3JQjUHmjszXOdgln69yUm/3yEza93wcO5kCKD+fcwNxecejXKa+taGx7/TK0FcPFPSLkGV/aql92fQefx8PB7uenlsyD6sDpGwOJF+8qa/p7/Ncw/vpuX1B0McrLU/nVZoMuGkPvBwUVtc3U/xPyrHjfUNUg4Ded3qEH77X3+9p/Cx3PzMvi3UL+/6wn167kdcOOCmppf2Ox9reDiP+eifsZCCCHKlRTYE0IIUR5sMsAHCA0NZcSIEbRr144OHToQFhZGWlqaMRgfPnw4gYGBzJ49G4DXXnuNrl278umnn/LYY4+xcuVK9u/fz1dffQWAl5cXXl5eJo/h4OCAv78/TZs2rdgnZ0klCNSmPNKMP87Ec+n6Ld7bEMlHT7Used/JUVDDJ6+Na21oN1q9KArcuKgG+5f+gku71TXfi7rnBs6568ZvPwFxYoOaWu7XAlxqlvw1KElKvV6vnoRIvKAGzOcj4Gw4ZNzM199t4/txOGZN/Bdq5maEHF8De+abb2euz5oh4NNUvX+tYPVrzXpQM1hNrzdo2F29mDsJYYkZ9+L8jIUQQlicYYs8P9kiTwghhAXZbIA/ePBg4uPjmT59OjExMbRq1YrNmzcbC+ldvnwZrTZvl7/77ruPH374gWnTpvHWW2/RuHFj1q5dS4sWLaz1FCpWMQK1Gk72fPJ0SwZ9uYcf91+l993+9LjL7w6dmun7TjPkGg3Urq9eWj+rHpvfIa9OQGEzz7s+Vi8Dv4F7nlKPXTsEx9eCV0Oo3RBqNwB3f/UxDApLf0+OhqxbagCfeEE9+WDvqN7n11fVde0l4eQBDq5g5wh2DnlfNXm/f/g2h6aPqcfPbS+6iN2g76BOq+KPobxn3Iv7MxZCCGERcblr8P3cJcAXQghhORpFUZSimwlQi+x5enqSlJSEh4eHtYdzZ3dIV39/YySLdl3Ax92J3yd2oVYNx/IbR/5t9wqbda7bXl3n/vS3eUHv31/A5imm7RxqqIF+7fpQvwscXp6XGVDYyQOA8QfAO3dZwc6PYOeHuTPn9dVgPeaoejKksH5e3FmyYLw4z7mkfd4u/8mN5CgYE2FaSE8IUW1UqvemSqCiXs+BX/zFgUs3+PzZNjx6T0C5PY4QQojKryTvTTY7gy/KSKMpdBb2jYebsv1kHOfi05ix/jj/G9q6/MZRnDoBj35SMNj1awHtx0DiOUg8r65Lz06D2H/Vy4n1eevazQXljm5qAF87BJOtAzuPhwdCwS7fr76l098rooidzLgLIUSlJmvwhS3Jzs5Gp5Niu0JUBK1Wi4ODQ7ntoCIBfjXk7GDHp4NaMfCLv1h/5Bp9WviX7+xBadLL6z+oXgxystRid9/3U2esofCA+bm1aoBt7o/G3BZ+5ZH+XlFF7O5wIkcIIYRtUhQlL0VfqugLK0pOTiYhIYHMzExrD0WIasXOzg5XV1d8fX1xdLRsNrUE+NVUq6CavNy1IfN3nGXa2mN0qF8bb7dyDhTLUtDN3hG8G0O/BUWnv7vUMh/cl+f4KrJPIYQQlVpiWhZZOvVkr6+swRdWkpycTFRUFG5ubnh7e5frjKIQQqUoCjqdjvT0dJKSkrh48SJ169bF1dXMJGQpSYBfjU3o0ZhtJ2I5GZPCW6v/5cvn2lbMP/aypJdX1vR3SakXQgiRKzZ39t6rhiOO9toiWgtRPhISEnBzc6Nu3boS2AtRwdzc3KhduzaXLl0iISGBevXqWaxveVepxhzttcwZ1AoHOw2/R8ay9nBUxQ6gtOnlhmB5zA4Y9gsE3Jt7g4V/ncsj/V1S6oUQotrLW38vs/fCOrKzs8nMzMTT01OCeyGsxM7Ojtq1a5OWlkZOTo7F+pUAv5prXseDCQ81BmDGuuPEJGVYeUQlcHugX6cluPlK+rsQQgibJgX2hLUZCuo5ODhYeSRCVG9OTur7gAT4wqJe7taQlnU9Sc7I4c1fjlLpdk7MH+hPPCbbxQkhhLBpMbkBvr+nzOAL65LZeyGsqzz+BiXAF9jbafl0UEsc7bXsPB3Pqn+uWHtIpSPp70IIISoBwxp8KbAnhBDC0iTAFwA08nVn0sNNAZi1IZKLCWnsOXeddYej2HPuOjp9JZvVF0IIIWxUrMzgCyGEKCdSRV8YjX6gPluOx7D/0g0e/uwP4xY+AAGezszo25w+LQKsOEIhhBCi8pM1+EIIIcqLzOALIzuthida1gEwCe4BYpIyeHnZQTYfi7bG0IQQQogqQ6roC2E7NBpNiS4hISEWH0NISIjUQxAWIzP4wkinV/hi5zmztymABpj5ayS9mvtjp5V/QkIIIURJZeXoSUjNAiTAF8IWjBgxosCx3bt3c+7cOVq2bEmrVq1MbvP29q6gkQlROhLgC6N9FxKJvsM2eQoQnZTBvguJdG7oVXEDE0IIIaqI+FS1wJ6DnYbaro5WHo0Q4ttvvy1wbOTIkZw7d47+/fvzzjvvlPsYwsPDyc7OLvfHEdWDBPjCKC6l8OC+NO2EEEIIYSom90S6r7szWsmGE9WETq+w70IicSkZ+Lo706F+bckGzadhw4bWHoKoQmQNvjAq7nY9sq2PEEIIUTpxUmBPVDObj0XzwIfbGbrob15beZihi/7mgQ+3V8q6Tt9++y0ajYZ33nmH06dPM2TIEPz8/NBqtaxduxaAs2fP8s4779C5c2f8/f1xdHSkbt26DB8+nNOnT5vt19wa/IsXL6LRaOjWrRvp6elMmTKF4OBgnJycaNSoER9++CGKUvxdrjIyMvjmm2/o168fDRo0wMXFhZo1a9KlSxdWrlxZ6P0URWHFihX06tULLy8vnJ2dCQkJYdCgQYSHhxdof+XKFSZMmECTJk1wcXGhdu3atGvXjpkzZ5KcnFzs8YrSkxl8YdShfm0CPJ2JScqgsH8X9lqNfCgRQgghSilGtsgT1cjmY9G8vOxggc+VhuLNXwxrUyl3aDp16hTt27fHy8uL7t27c+PGDRwcHAD4+uuv+eijj2jRogXt27fHycmJyMhIli5dyrp169i1axf33ntvsR8rKyuLhx9+mMjISLp160ZaWho7d+5kypQppKSk8N577xWrn4sXL/LCCy9Qp04dmjZtSocOHYiJieGvv/5i165dnDx5ssByBJ1Ox9ChQ/npp59wdHTk/vvvx8/PjytXrrBx40aysrLo0aOHsf2uXbt44oknuHnzJiEhIfTt25f09HRj3/369StQ00BYngT4wshOq2FG3+a8vOwgGjAb5OfoFfot+JM5g1rRq7lfRQ9RCCGEqNRik9U1+JINJ2yVoiikZ+vK3I9OrzBj/XGznycNxZvfWR/J/Y28y5yu7+JgV6FV6FeuXMn48eMJCwvDzs7O5Lb+/fszduxY6tevb3J8yZIljB49mokTJ7J9+/ZiP9aePXvo2rUrFy5cwMPDA4D9+/fTqVMnPvvsM6ZMmYKbm1uR/fj4+LB161Z69Ohh8lpduHCBhx56iFmzZjFy5EiTXQJmz57NTz/9RPPmzdmwYYPJc0pKSuLw4cPG64mJiQwcOJCbN2/y8ccfExoailablyy+Z88e6tSpU+znLUpPAnxhok+LAL4Y1oaZv0aaFNwL8HRmQo/G/LT/Cgcv32TM9/t5pVtDQns1wd5OVnoIIYQQxRErM/jCxqVn62g+fUu5P46CmtFyzzu/l7mvyHd74+pYcWGNj48PH374YYHgHqBTp05m7zNq1Ci++eYbIiIiSEpKwtPTs1iPpdVq+fLLL43BPUC7du145JFH2LBhA/v376dbt25F9uPl5UXPnj0LHK9fvz7//e9/GTNmDL/++iuvvvoqoGYOfPrppwAsXry4wAkLT09Punbtarz+9ddfEx8fT58+ffjPf/5T4HE6d+5crOcryk4CfFFAnxYB9Grub7YYysA2dZm96QRL/rzI5xHnOHzlJv8b2hpvN0nbF0IIIYoSK2vwhaj0evbsiaura6G3p6am8uuvv3L48GESExONFfKjo6NRFIVz587Rpk2bYj1WcHAwTZs2LXC8SZMmxj5LYvfu3URERBAVFUVGRgaKohj7OHPmjLHd/v37uXnzJi1btqRjx45F9rtt2zYAxo4dW6LxCMuTAF+YZafVmN0Kz9Fey4y+d9OmXi3e/OUof527zuP/282CZ1vTNri2FUYqhBBCVB4xxgBfZvCFbXJxsCPy3d5l7mffhURGLvmnyHbfjmpPh/pl+wzp4lBwJr081atXr9Dbtm/fzpAhQ4iPjy+0TUpKSrEfq27dumaPu7u7A5CZmVmsfpKSknjyySfvuDwg/7iuXLkCFL/Cf0nbi/IjudWiVPq2rMP68ffT0KcGMckZDP7yb5b8eaFE1TyFEEKI6iY2SQJ8Yds0Gg2ujvZlvjzY2IcAT2cKWxmvQV0C+mBjnzI/VkWuvwdwdjb/95uamsqgQYNISEhg+vTpREZGkpaWhl6vR1EUhg4dClCiz8v517GXxZtvvsn27dvp2rUrERERJCQkkJOTg6IobNmypcTjErZLAnxRao183Vk3/gEevzeAHL3CzF8jeXXFIdIyc6w9NCGEEMLmpGbmkJalFi/zlwBfVHGG4s1AgSDfcH1G3+ZlLrBnS3bt2sX169cZOHAgM2fO5K677sLV1dV4AuL8+fNWG9uaNWuws7Nj/fr1dO3aFS8vL2MNAXPjCgoKAuDcuXPF6r+k7UX5kQBflImbkz3zhrZmRt/m2Gs1bDgaTb8Ff3I2rvipR0IIIUR1EJM7e+/uZE8NJ1klKao+Q/Hm24tK+ns6V9ot8u7kxo0bgPm0+rNnz3Lw4MGKHpLRjRs38PDwMCnWZ/Djjz8WONa2bVtq1qzJkSNH+P/27jwsqur/A/h7gIFBhEFFVpHFQHJfUiTXlIRyLVNxt9TKn31zqTS1ot1vWWmlj6blUpqpX7ey1EBxxxW0UENEREUWQRkWWWfO7w9kbGQGBpyBYXi/nmcemDvnnjnn3hkOn3vOPefUqVNV5l8+gd+qVasevbD0SBjg0yOTSCR4sacPNr/SAy4ONriSkYehy45h91+31GmUKoHoxCzsOpeC6MQsKFUcAkRERA1Lxv377505wR41IKHt3HB0Xn9smtYDX4d1wqZpPXB0Xn+zC+6BBxPfbd++XeMe/OzsbEyZMkU92V5d8Pf3x927d7F582aN7UuWLEFUVFSF9DY2Npg9ezYAYMqUKUhOTtZ4XaFQ4NChQ+rnU6dOhZOTE/bs2YOlS5dWGO5/4sQJZGRkqJ+fOnUKAQEBGDBgwCPXjTTx8jEZTFevpvj99d74z8+xiL6ahdd+jsXZ5Lvo0rIJPv3jUoVl98KHtDHLP+5ERETapHGJPGqgdE3ebG6eeOIJPP3004iIiIC/v796+bqDBw/CyckJw4YNw65du+qkbPPnz8f48eMRFhaG5cuXo0WLFjh//jz++ecfzJ49G0uWLKmwz4IFCxAbG4udO3fC398fvXv3hrOzM27cuIGYmBg8/fTT6qXymjZtiq1bt2Lo0KGYPXs2vvnmG3Tr1g0FBQW4dOkSrly5gtjYWDg7OwMA7t27h/j4eBQWFlZ4X3o07MEng3JqbIOfpnTH//Urm0Fz7bFr+M+mWI3gHigbpjh9Qwz2xlVvaQ8iIqL6Kj2nbLZrF3sG+ETmateuXVi4cCGaN2+OPXv24OzZswgLC8OJEyfg6OhYZ+UaN24cfv/9d/To0QPnzp3Dnj174O7ujgMHDmDo0KFa97GyssK2bduwbt069OjRA2fOnMH27dtx8+ZNDB48GLNmzdJI369fP5w/fx6vvvoqhBDYuXMnjh07Brlcjg8//JAz7NcSieB0iXrLycmBXC6HQqHQev8KadoXl4ZXN5yFrg+YBGW9GEfn9TerCVaIiGoT2ybDMubxfP/XC1h3/Bqm92uFeaEBBs2bqDoKCwuRlJQEHx8fnTPCE5Hx6ftdrE7bxB58MhoHW6nO4B4ABIBURSFOJd2prSIRERHVmfJJ9lzseQ8+EREZBwN8MpqMXP3uqdE3HRERUX2Wnst78ImIyLhMOsBfvnw5vL29IZPJEBgYWOUSDVu3bkVAQABkMhnat2+PP/74Q/1aSUkJ5s2bh/bt28POzg7u7u6YOHEibt26VUmO9Cic9bzH0J5LBRERUQOQriifRZ8BPhERGYfJBvibN2/GnDlzEB4ejpiYGHTs2BEhISEayyv82/HjxzFmzBhMmTIFsbGxGD58OIYPH464uDgAZTM1xsTE4N1330VMTAy2b9+O+Ph4nZNK0KPr7tMUbnIZqrq7ftbmc/h2fwJyC+tu6RAiIiJjUqkEMnLLJtlzZYBPRERGYrKT7AUGBqJbt25YtmwZAEClUsHT0xP/+c9/8Pbbb1dIP3r0aOTn52P37t3qbT169ECnTp2wcuVKre9x+vRpdO/eHcnJyWjZsmWVZeJERtW3Ny4V0zfEAIDG/fiS+89dHGzUswrLbaWY0ssHk3t6w0EmrfWyEhHVR2ybDMtYx/N2bhG6fRIJiQS4/PEzkFqabB8LNQCcZI/INDSYSfaKi4tx9uxZBAcHq7dZWFggODgY0dHRWveJjo7WSA8AISEhOtMDgEKhgEQi0blkRVFREXJycjQeVD2h7dywYnyXCvcbusplWDm+C46/PQBfh3XCY86NoSgowVcRl9HrvwfwdWQCctijT0REZiI9p2x4fjM7Gwb3RERkNCbZwmRmZkKpVMLFxUVju4uLC9LS0rTuk5aWVq30hYWFmDdvHsaMGaPzKsiiRYsgl8vVD09PzxrUhkLbueHovP7YNK0Hvg7rhE3TeuDovP4IbecGSwsJhnXywL5ZffDNmM54zLkxcgpLsSSyLNBfGnkZioKKgb5SJRCdmIVd51IQnZgFpcokB6IQEVEVqjPfTklJiXotZZlMho4dO2Lv3r0V0qWkpGD8+PFo1qwZbG1t0b59e5w5c8aY1ahSeYDvKucM+kREZDwNcnazkpISjBo1CkIIrFixQme6+fPnY86cOernOTk5DPJryNJCgqBWzSp9fWhHdwxq74Y//k7FN/sTkJCRh6WRCfjhaBKm9PLBiz19ILeVYm9cKj747SJSFQ9m33eTyxA+pA1C27nVRnWIiMgAyufbWblyJQIDA7F06VKEhIQgPj4ezs7OFdK/88472LBhA1avXo2AgADs27cPzz33HI4fP47OnTsDAO7evYuePXviqaeewp49e9C8eXMkJCSgSZMmtV09DeW3o7noOQEtERFRTZhkgO/k5ARLS0ukp6drbE9PT4erq6vWfVxdXfVKXx7cJycn48CBA5Xew2BjYwMbG15pr02WFhIMKQ/041LxdaRmoN/Hrzn++DsVD/fXpykKMX1DDFaM78Ign4ionvjqq68wbdo0vPjiiwCAlStX4vfff8eaNWu0zrfz008/YeHChXj22WcBANOnT0dkZCS+/PJLbNiwAQDw2WefwdPTE2vXrlXv5+PjUwu1qVza/R58Fy6RR0RERmSSQ/Stra3RtWtX7N+/X71NpVJh//79CAoK0rpPUFCQRnoAiIiI0EhfHtwnJCQgMjISzZrp7lGmumVhIcHgDu7YN6sPlo/tAn+XxsgtLMXvWoJ74MEEfh/8dpHD9YmI6oGazLdTVFRUYRIiW1tbHD16VP38119/xRNPPIGRI0fC2dkZnTt3xurVq3WWo7bm2ylfIo89+EREZEwmGeADwJw5c7B69WqsX78ely5dwvTp05Gfn6++yj9x4kTMnz9fnX7mzJnYu3cvvvzyS/zzzz94//33cebMGbz22msAyoL7F154AWfOnMHGjRuhVCqRlpaGtLQ0FBcX10kdqWoWFhIM6uCGvTP7YFawX6VpBYBURSFOJd2pncIREVGN1WS+nZCQEHz11VdISEiASqVCREQEtm/fjtTUVHWaq1evYsWKFfDz88O+ffswffp0vP7661i/fr3WPGtrvp30XN6DT0RExmeSQ/SBsmXvbt++jffeew9paWno1KkT9u7dq/5H4Pr167CweHB94sknn8TPP/+Md955BwsWLICfnx927tyJdu3aASibcOfXX38FAHTq1EnjvaKiotCvX79aqRfVjIWFBD5OdnqlzcgtrDoRERHVO19//TWmTZuGgIAASCQStGrVCi+++CLWrFmjTqNSqfDEE0/g008/BQB07twZcXFxWLlyJSZNmlQhz9qabyftfg++swN78ImIyHhMNsAHgNdee03dA/+wgwcPVtg2cuRIjBw5Umt6b29vCMGh2/WZs57DGpdEXkaqohCD2rvBs2kjI5eKiIhqoibz7TRv3hw7d+5EYWEhsrKy4O7ujrfffhu+vr7qNG5ubmjTpo3Gfo8//ji2bdumNc/amm8nI7dskj1XBvhERGREJjtEn+hh3X2awk0ug6SKdNcy7+G/e/5B78+jMHz5MXx/5CpSFQWV7sNl94iIaldN5tspJ5PJ4OHhgdLSUmzbtg3Dhg1Tv9azZ0/Ex8drpL98+TK8vLwMW4FqKCpV4k5+2e2ADPCJTMvYsWMhkUjw0UcfVZn21KlTkEgkcHFxQWlpabXfa/LkyZBIJBU6Kvv16weJRIJr167pnde6desgkUjw/vvvV7sc1VWT8lHdYYBP9YalhQThQ8p6ZR4O8iX3H4tf6IBPnmuHIN9mkEiAczey8fHvlxC06ABGrjyO9cevVRjCvzcuFb0+O4Axq09g5i/nMGb1CfT67AD2xqWCiIiMp7rz7Zw8eRLbt2/H1atXceTIEYSGhkKlUmHu3LnqNLNnz8aJEyfw6aef4sqVK/j555+xatUqzJgxo9brVy7j/hJ51lYWcGwkrbNyEFFFEyZMAABs3LixyrTlq3WMGTMGVlYmPRC6WiQSCby9veu6GGQg5vPJpAYhtJ0bVozvgg9+u4hUxYNA3VUuQ/iQNuol8sYFeiEjtxB7/k7D7r9u4fS1u+rHB79dQKBPMwzu6AZrSwvM/d9fXHaPiKgOVHe+ncLCQrzzzju4evUqGjdujGeffRY//fQTHB0d1Wm6deuGHTt2YP78+fjwww/h4+ODpUuXYty4cbVdPbX08iXyHGwgkVQ1Do2IatPAgQPh4uKC+Ph4nD59Gt26ddOarrS0FJs3bwbw4KKAofz444+4d+8ePDw8DJqvoZh6+UgTA3yqd0LbueHpNq44lXQHGbmFcLaXobtPU1haaP7T5Gwvw6QnvTHpSW+kKgrw+1+p2P1XKs7dyEb01SxEX83S+R4CZSMCPvjtIp5u41ohb30oVaLKMhIRNXTVmW+nb9++uHjxYpV5Dh48GIMHDzZE8Qwi/X4PPpfIIzI9lpaWGDNmDJYuXYoNGzboDPD//PNPZGRk4PHHH0fXrl0NWoaWLVsaND9DM/XykSYO0ad6ydJCgqBWzTCskweCWjWrMnB2k9tiam9f7JzRE0fmPoW3nwmAt1PlE/CVL7v367kUFBQrq1U+Ywz75zwBRET1U1p5D76cAT6RmhBAaVFdlwIAMH78eADA5s2boVRq/5+vfAh/edrs7Gx8++23CAkJgZeXF2xsbNCsWTOEhoYiIiKiWu9f2T3ux44dQ3BwMOzt7eHo6IiQkBCcPHlSZ15XrlzB+++/j6CgILi6usLa2hotWrTAxIkTcfnyZY205ffxA0BycjIkEon68e8Vxior38WLFzFu3Di4ubnB2toaHh4emDhxYoW5UICyi7YSiQSTJ0/GnTt3MH36dLi5ucHGxgbt2rXTWBFFHzU9ByUlJVi5ciV69eoFR0dH2Nra4rHHHsOLL76Is2fPVkh/6dIlTJkyBd7e3rCxsYGzszN69uyJL774okZzMRgbe/CpwfFs2giv9m0FN7kMM385V2X62VvOY/aW85DbSuHqIIOrXAZXBxlc5DK43f+9fJtjIyn2XUjD9A0xBh32vzcutcJtCW4P3ZZARESmST1Enz34RGWBfeJ+4MDHgCIFeDkKkLeo0yJ17doVjz/+OC5duoSIiAiEhoZqvJ6fn49du3ZBIpGob/c5ceIEXn/9dXh7e6N169YICgrC9evX8eeff+LPP//E999/j5deeumRyrV7924899xzKC0tRffu3eHr64vz58+jT58+mDx5stZ9vv/+e3z++edo164dunXrBhsbG1y8eBE//fQTdu3ahSNHjqBDhw4AgMceewyTJk3C+vXrYWdnhxdeeEGdT0BAQJXl279/P4YMGYKCggJ07twZ/fr1wz///IOffvoJO3bswB9//IHevXtX2C87OxtBQUHIy8tD7969kZmZicOHD2PKlClQqVSYOnWqXsenJucgPz8fzz77LA4fPgw7Ozt1kH/t2jVs3LgRcrlcY4TG1q1bMWHCBBQVFeHxxx/Hc889B4VCgQsXLuCtt97C1KlTNW4TMwUM8KnB0nfZPRsrCxSVqqAoKIGioATx6bk601pbSqAUqBDcAw+2hf96AcGPu8DKUr8BNHvjUg1+wYCIiGpPeYDvKjf+cnxEJuvfgf2tWJQNJFYB+Zl1HuADZffVL1iwABs2bKgQ4G/fvh35+fno27evekWO1q1bIzo6Gj169NBIGxsbi/79+2P27NkYNWoUGjduXKPy5Obm4qWXXkJpaSnWrFmjnnxUCIH58+fjs88+07rf8OHD8corr8DHx0dj+9q1a/HSSy9h1qxZOHDgAACgV69e6NWrF9avXw8nJyesW7dO7/Ll5+dj3LhxKCgowLJlyzQmMl2yZAnmzJmDsWPHIiEhATKZ5v/cu3btQlhYGNatW6depnTnzp147rnn8NFHH+kd4NfkHMycOROHDx9Gnz598L///Q/NmzdXv5aenq4xSiEhIQETJ06EUqnExo0bMXbsWPVrQghERETA1tZWr7LWJgb41GCVL7uXpijUGpBLUDZ535G5T+FeiRJpisKyR86Dn+mKQqQqCpGeU4is/GIUK6seNp+eU4SAd/fCxUGG5vY26odz+e+NH2xr0sgaH/x2UecFg0edJ4CIiIwvTVE+yR578KkeKc7X/ZrEEpDK9EsLCXD9+IPAXmJ5f7uq7EdpwYP9JRaA9F8BU/E9aO82uZ+vdeW3W1bHuHHjsHDhQuzcuRP5+fmws7NTv1Y+e3758HwA8PHxqRBEA0Dnzp0xY8YMfPLJJ4iKisKQIUNqVJ7//e9/uH37Nvr06aMO7gGol/TbuHEjbt68WWG/h4Pdci+++CJ++OEHHDx4EAqFAnK5vEblKrdlyxakp6cjKCiowiols2fPxsaNG3H27Fls27atwiSnDg4OWLZsmTq4B8ouTLRr1w5xcXG4du2aXrP6V/cc3Lp1S31R4ccff9QI7gHAxcVFPckrUHahorCwEK+++qpGcA+UnYeBAwdWWca6wACfGqzyZfemb4iBBJrNR3moHD6kDawsLeBgaQEHmRT+LvY68ysqVeLnE9fxwe6qJ4AqVQmkZBcgJbvgkepQPk/AqaQ7CGrVrFr7chJAIqLakZF7f5I9BvhUn3zqrvs1v4HAuK0Pni9+DCi5pz2tdWOgOO9BYC8eusd9zb96y907Ay8ffPB8eSCguK493+YBwAzd96JXV8uWLdGnTx8cOnQIO3fuVAel6enp2L9/P2QyGUaOHKmxj1KpxP79+3H8+HGkpqaiqKjsu56QkKDxsyaOHDkCAAgLC6vwmlQqxQsvvIClS5dq3TcvLw+//fYbzp07hzt37qCkpAQAkJqaCiEEEhMT0aVLlxqX7d/l07VCyfjx43H27FkcOXKkQpquXbuiWbOK/7f6+/sjLi4Oqampei/bV51zcPDgQSiVSgwePFg9EqMykZGRAIBXXnlFr7KYCgb41KDpu+yePmysLBHg5qBX2m/GdIJnk0a4nVuEjNwi3M4twu28IvXzzPvbipUqvfL78s94BLdxQWtXewS42sPVQVbpUky8p5+IqHYIIdQ9+K4M8KkhKs4r+/lwYG+CJkyYgEOHDmHDhg3qoHTTpk1QKpV4/vnnNXq9b968icGDB+P8+fM688vN1X1bZ1Vu3boFADoDUV0B8IEDBxAWFobbt28bpVwPl09XOcq3p6SkVHitRQvtt2TY25d1pJUH6VWp7jm4ceMGAKBVq1Z65V/d9KaCAT41ePouu6cPfYf9D2rvXmX+Qgjsv5SBqT+eqfJ9zyTfxZnku+rnDjIrtHa1v/9wQICrPfxd7CG3lfKefiKiWpRbVIqCkrLAhj34VK8suKX7NfUw+/veuqI9XdJh4OB/gdRzZftoC/Jf2gu4drif70PzE804iUqH6BvYCy+8gNdeew2RkZHIyMiAs7Ozenj+hAkTNNJOnToV58+fx4gRIzB37ly0bt0a9vb2sLCwwKpVq/DKK69AiNpd8SgvLw+jRo3CnTt38N577yEsLAxeXl6wtbWFRCLB2LFjsWnTplopV2UdTRYWhlnIzRTPgSlggE+EB8vuGSIffYb963PxQCKR4KkA50ovGABAk0ZSTH7SGwkZeYhPy8XVzHzkFJbi9LW7OH3trkZaVwcb3L1X0mDv6edtCURU29Lv9947yKxga21ZRWoiE2JtV3WaqtK2fgbwD9WcXO/hQN/KVvf+BrzHXh9yuRxDhw7Fli1bsGnTJoSEhODs2bNwcnLSmHgvPz8fERERcHFxwebNm2Fpqfndvnr16iOXxc2trLMlOTlZ6+vath85cgRZWVl44YUX8MEHH1R43RDlKufu7l5p+conq/Pw8DDYe/5bTc6Bp6cnACAxMVGv9/D09ERCQgISExPRqVOnRy5zbTHM5RMiUisf9u/60HrHrnJZtXvHyy8YABWvU0vuPxY93x4zg/2xbGwXRMzpi4sfhuCP13tjyeiOeKWvL55q3Rzu98uSllOEolLdw/4f3NOfpXcZyylVAtGJWdh1LgXRiVlQqh79iqkh89wbl4penx3AmNUnMPOXcxiz+gR6fXYAe+NSH7mchmKMY0hEdSs9h/ffUwMnkQCPBQPTooDx2wC3+731JhqGlE+kt3HjRmzcuBEAMHr0aEilUnUahUIBlUoFNze3CoFlSUkJduzY8cjlKF9ebsuWLRVeKy0txbZt2ypsv3u3rGNH2xD4K1euICYmRut7SaXSaq/nXl6+TZs2aX29fOSDtmXyDKEm56Bfv36wtLTEvn371MPvKxMcHAwAWLVqlWEKXUvYg09kBIYc9l/deQJsrCzRxt0Bbdw15wNQFJRgzdEkfL2/6glfpq4/g+4+TdHJswk6tXREpxaOkDeS6kxvjHv6DZlnfbgtgfMiEJmnNPUSeQzwqYErD/RbDXjQo5+TAtg1r3rfWhQaGgonJyecPn0aSUlJACoOz3d2doZcLkdcXByOHTuGnj17Aiib8G3evHm4fPnyI5dj5MiRmDt3Lg4ePIj169dj0qRJAMpu4QwPD8f16xUnH/T39wdQtqzfggUL1LPEZ2dnY8qUKerJ9h7m7u6OlJQUZGdn672m+6hRozB//nwcPXoUq1atwssvv6x+7ZtvvsGZM2fg4eGBESNGVKfaeqvJOXB3d8fEiROxdu1aTJo0CVu3btWY7C8jIwNJSUkIDAwEAMyaNQtr167F6tWr0bdvX4wePVqdVgiByMhI9OnTR70awI4dOzB//nx0794dP/74o1HqrQ8G+ERGYqhh/4BhLhjIbaXo4dtMrwA/v1iJqPjbiIp/MEGLr5MdOnk6lgX8no4IcHWAtZWFUYJnQ+apVAmTX2qwPlyAIMPhrSINS/r9AN/ZngE+EQDNQF9ZDFjZVL1PLZJKpQgLC8OyZcuQmZkJPz8/dcBXzsrKCnPnzsXChQvRt29f9O/fH02bNsXJkyeRnp6OGTNmYPny5Y9UDnt7e/zwww8YMWIEJk+ejBUrVsDX1xfnz59HQkICpk2bhtWrV2vs88QTT+Dpp59GREQE/P390a9fPwBls8c7OTlh2LBh2LVrV4X3Gjp0KL799lt06dIFTz75JGQyGVq3bo233npLZ/ns7OywceNGDBkyBK+88gpWrVoFf39//PPPP4iNjUXjxo2xadMmyGTG+dtX03Pw9ddfIz4+HlFRUfDy8kKfPn3g4OCA5ORkxMTEYPr06erz7e/vj7Vr12LixIkICwvDhx9+iA4dOkChUCAuLg43btzA3bt31QG+QqFAfHw8XF1djVJnfTHAJ6onDHHBQJ9JAF3kMiwf2wV/38zGuRtlj2tZ93A1Mx9XM/OxPbZsNlRrKwu0dbNHfHqewYJnIQRKlALv/3pBZ54AsGBHHCwlEhQrBQpLlCgsVaKwRIXCEiWKSpQoLC3/XYWbd+9p9Ipry7MulxqsDxcgjKmhBbscqdHwpKt78E0riCGqcxKJyQX35SZMmIBly5YBeDBk/2ELFixAixYtsHTpUhw7dgy2trbo1asXPvzwQ51D4atr2LBhiIqKQnh4OE6dOoVLly6hW7du+P777xEfH18hwAeAXbt24ZNPPsGWLVuwZ88eODs7IywsDB9//DHeeOMNre+zaNEiCCGwa9cubN68GaWlpejbt2+lAT4ADBgwAKdPn8Ynn3yCAwcO4K+//oKTkxPGjx+Pd955B61btzbIcdClJufA3t4eUVFRWLlyJTZu3IgjR45AqVTC3d0d48aNw8SJEzXSh4WFoU2bNli8eDGioqKwbds2NGnSBH5+fpg1axYaN25s1DrWhEQ0xKkFaygnJwdyuRwKhQIODvoth0Zkasp7iwHtkwBq6y2+k1+M8zeyEXs/4D9/IxuKAu3DvLTxbGILmdQSpSqBUpUKpcqyQF5Z/rtKBaWqbFtdae/hgKfbuKK9hxxtPRyq7G17lEBNqRJIzsrH5fQ8HLiUji1nb1ZZvk3TehhsRIipaGjBrq6RGpV99/TBtsmwDH08X/7xDP68mI4Ph7XFxCDvRy8gkQEUFhYiKSkJPj4+RuthJaKq6ftdrE7bxB58ogamuvf0A0BTO2s8FeCMpwKcAZT1tCdl5mPNsSRsOFHxHrCH3bhbYLgK3OfZ1BZuDrawkVpAJrUse1iV//5gW6qiQK8y/p2Sg79TctTPne1t0M5DjnbuDmjrIUc7Dznc5TJIJBK9h9SrVAI37xbgcnouLmfk4nJaLi6n5yHxdl6lkx1qs/FkMjwcbdGyWe3OKPwwQ/W4G+u2BFMdEdDQR2o0ZOm5nGSPiIhqDwN8ogboUe/pl0gk8G3eGIPau+sVPM9/JgDtW8hhZWEBK0sJpBYWsLSQQGopuf+z7LmVpQTnr2dj2k9nq8zz8xEd9erRVqoE9l/KqPS2hKZ21nilry8upeYiLkWBxNt5yMgtwoF/MnDgnwx12iaNpGjr7oDY69mV3kIwe/N5LI+6gisZ+er1rx8mk1rgMefGaGJrjSNXMqusx+6/UrH7r1R08nTE0I7uGNzBDc61HDAYqsfdWMGuKY8IOJV0x2i3ipBpK18mz5UBPhER1QIG+EQNVG3d0+8ql2Fqb1+9A7X+j7volWd3n6Z65Ve+1OD0DTGQQPttCZ88104jALxXXIpLqbm4cEuBuBQF4lJycDk9F3fvleDolaqXECwoUapHA1hbWsC3uR38XezR2tUefs6N4e9iD8+mjWBpIYFSJdDrswOV1tfBVoq27vY4cfWOel6Ej3+/iB6+zTC0ozueaeemdZUDQ/ZmG6rHvaBYiX0XUvUKdg/FZ+CpAGdIJFWX2RQnKswvKsWJq1k4dPk2/vhbv+UYM3J1Hxeqf5Qqgdt57MEnIqLawwCfiGpMn+A5fEibagWVxsizurclNLK2QlevJujq1US9rahUictpedhwMhmbT1e9dupLPb0xNtAL3s0awcpS91q/+tT3sxHtEdrODRm5hfj9r1T8ev4WYq9n43hiFo4nZuHdXXHo698cQzq64+k2LmhkbWXQ3mx9etzDf70Ar2Z2yMorRkZuITJyi5CRU4TbeUXIyCnE7dwiZOQWIa9I/3V2X1p/BjZWFnBqbAMnexs42Vnf//3+z/uPpnZShFcyMeOjDH+vzkUSlUrgUloODl/OxOHLt3Em+U6155XgTOvmJSOnEEqVgATAlYxcNLe34S0YRERkVJxkrxo4kRGRdsYYGm2MPA3Rox2dmIUxq09Uma66k+JVt7437tzDr+dv4bfzt/BPWq56u63UEm3dHXAm+W6FffSZzE0IgfxiJRQFJci+VwxFQQlOJ93Bksiql1fUl9RSUicTKi4f2wXPtHOFhZ7nXJ9zkplXhKMJZQH94YRMZN7vrS3n2dQWffyao9djTnj/twvIyCmqdGTK0Xn9q/2ZZNtkWIY6nnvjUrFwZxyy8orV20zllhEiTrJHZBqMMckeA/xq4D9RRLoZY3IzU5wwTZ8h9TUN1Gpa38vpufj13C38ev4Wrt+5V2X6xjZWGN7ZHTkFpVAUlEBRUIKcghJk3/9ZqqpZs2ArtUSLJrZwdrCBs70Mze1t4Gxvc//n/ecONmgktUTvz6OqPIZ/zu6D7HsluJ1XhMzcImTmFSMzrwhZeWW/384rQmZeEVKzC1BQot+khVJLCVzlMng42sLDsRE8HGXwaHL/9ya2cJPLIJNaVjrjvQAQ0tYFKdkFiPvXxIwA0MjaEkG+zdDHvzn6+DeHd7NG6lsMarKChT7YNhmWIY6nsVZMIDIUBvhEpoEBfh3jP1FEBBgvUHtUQghsOHkd7+6Me+S8rC0t4GArhdzWChYSICEjv8p9qjNqwZDHUN9RFRYSQJ9rF83srJFTWKL3KIM2bg73A3ondPVqAhsrS51pjTEyhW2TYT3q8Sy/CKhrnolHuQhIZCgM8IlMA5fJIyIyATVZarA2SCQSOMj0+7Me0sYF3Xya3g/ipXC0lULeqOx3ua0UtlJLdc+zvqMW9J34EDDsMdR3sseDb/ZDVn4xUrILkHK3oOznv3+/W4CCEiWy8ou15FLR//Vrhck9vat13/yjrmBBpo8rJlB9wn4+orpljO8gA3wiohow1UBN32Bzck8fvYMLY0x8CBjuGOpbPhupJdwdbeHuaItu3hXzEUIg+14Jfj51HYv3xVf5vq1d7Ws0KZ4hVrAg06XvSghcMYHqkqVl2UijkpIS2Nra1nFpiBquoqKyuXusrAwXluue2pmIiCpVHqgN6+SBoFbN6jy4Bx70ZusqiQRlQ8Kr09sOPOhxd5VrBrSuctkj3ZJgqGNoiPJJJBI0sbNGl5ZNqkwLcMZ70k7fzwU/P1SXpFIpbGxsoFAo2ItPVEeUSiXu3LkDOzs7gwb47MEnIjIjxuptB0x31EI5Q5VP3yH/1b1IQg0DPz9UXzg5OSElJQU3b96EXC6HVCpV35pFRMYhhIBSqURBQQEUCgVUKhXc3Ax7aycDfCIiM2PMOQJMfXi5IcpnzIskZP74+aH6onyirszMTKSkpNRxaYgaFktLSzRq1AjOzs6wtrY2aN6cRb8aOFMxEdUnprjMYH1ijBnvjYFtk2EZ6njWl88PEVB2L75SqazrYhA1CBYWFtUeMWM2s+gvX74cixcvRlpaGjp27Ihvv/0W3bt315l+69atePfdd3Ht2jX4+fnhs88+w7PPPqt+XQiB8PBwrF69GtnZ2ejZsydWrFgBPz+/2qgOEVGtMvXedlNn6rckkGnj54fqE6lUCqlUWtfFICIDMNlJ9jZv3ow5c+YgPDwcMTEx6NixI0JCQpCRkaE1/fHjxzFmzBhMmTIFsbGxGD58OIYPH464uAfrQX/++ef45ptvsHLlSpw8eRJ2dnYICQlBYSFnsiUioopMcSJFqj/4+SEiotpmskP0AwMD0a1bNyxbtgwAoFKp4Onpif/85z94++23K6QfPXo08vPzsXv3bvW2Hj16oFOnTli5ciWEEHB3d8cbb7yBN998EwCgUCjg4uKCdevWISwsrMoycRgkERGZGrZNhsXjSUREpqY6bZNJ9uAXFxfj7NmzCA4OVm+zsLBAcHAwoqOjte4THR2tkR4AQkJC1OmTkpKQlpamkUYulyMwMFBnnkVFRcjJydF4EBEREREREZkikwzwMzMzoVQq4eLiorHdxcUFaWlpWvdJS0urNH35z+rkuWjRIsjlcvXD09OzRvUhIiIiIiIiMjaTDPBNxfz586FQKNSPGzdu1HWRiIiIiIiIiLQyyQDfyckJlpaWSE9P19ienp4OV1dXrfu4urpWmr78Z3XytLGxgYODg8aDiIiIiIiIyBSZZIBvbW2Nrl27Yv/+/eptKpUK+/fvR1BQkNZ9goKCNNIDQEREhDq9j48PXF1dNdLk5OTg5MmTOvMkIiIiIiIiqi+s6roAusyZMweTJk3CE088ge7du2Pp0qXIz8/Hiy++CACYOHEiPDw8sGjRIgDAzJkz0bdvX3z55ZcYNGgQfvnlF5w5cwarVq0CAEgkEsyaNQsff/wx/Pz84OPjg3fffRfu7u4YPny4XmUqX3CAk+0REZGpKG+TTHRRnHqHbT0REZma6rT1Jhvgjx49Grdv38Z7772HtLQ0dOrUCXv37lVPknf9+nVYWDwYgPDkk0/i559/xjvvvIMFCxbAz88PO3fuRLt27dRp5s6di/z8fLz88svIzs5Gr169sHfvXshkMr3KlJubCwCcbI+IiExObm4u5HJ5XRej3mNbT0REpkqftl4ieMlfbyqVCrdu3YK9vT0kEkldF6fGcnJy4OnpiRs3btTreQXMpR6A+dTFXOoBmE9dzKUeAOuiixACubm5cHd317jwTTXDtt60mEs9ANbFFJlLPQDzqYu51AOou7beZHvwTZGFhQVatGhR18UwGHOZONBc6gGYT13MpR6A+dTFXOoBsC7asOfecNjWmyZzqQfAupgic6kHYD51MZd6ALXf1vNSPxEREREREZEZYIBPREREREREZAYY4DdANjY2CA8Ph42NTV0X5ZGYSz0A86mLudQDMJ+6mEs9ANaFqDrM5TNmLvUAWBdTZC71AMynLuZSD6Du6sJJ9oiIiIiIiIjMAHvwiYiIiIiIiMwAA3wiIiIiIiIiM8AAn4iIiIiIiMgMMMAnIiIiIiIiMgMM8M3MokWL0K1bN9jb28PZ2RnDhw9HfHx8pfusW7cOEolE4yGTyWqpxNq9//77FcoUEBBQ6T5bt25FQEAAZDIZ2rdvjz/++KOWSls5b2/vCnWRSCSYMWOG1vSmcj4OHz6MIUOGwN3dHRKJBDt37tR4XQiB9957D25ubrC1tUVwcDASEhKqzHf58uXw9vaGTCZDYGAgTp06ZaQaPFBZXUpKSjBv3jy0b98ednZ2cHd3x8SJE3Hr1q1K86zJZ9QQqjovkydPrlCu0NDQKvOt7fNSVT20fWckEgkWL16sM8+6OCf6/M0tLCzEjBkz0KxZMzRu3BgjRoxAenp6pfnW9PtFDYO5tPWA+bT39bWtB8ynvWdbz7bemOpTe88A38wcOnQIM2bMwIkTJxAREYGSkhIMHDgQ+fn5le7n4OCA1NRU9SM5ObmWSqxb27ZtNcp09OhRnWmPHz+OMWPGYMqUKYiNjcXw4cMxfPhwxMXF1WKJtTt9+rRGPSIiIgAAI0eO1LmPKZyP/Px8dOzYEcuXL9f6+ueff45vvvkGK1euxMmTJ2FnZ4eQkBAUFhbqzHPz5s2YM2cOwsPDERMTg44dOyIkJAQZGRnGqgaAyuty7949xMTE4N1330VMTAy2b9+O+Ph4DB06tMp8q/MZNZSqzgsAhIaGapRr06ZNleZZF+elqnr8u/ypqalYs2YNJBIJRowYUWm+tX1O9PmbO3v2bPz222/YunUrDh06hFu3buH555+vNN+afL+o4TCnth4wj/a+vrb1gPm092zr2dYbU71q7wWZtYyMDAFAHDp0SGeatWvXCrlcXnuF0kN4eLjo2LGj3ulHjRolBg0apLEtMDBQvPLKKwYu2aObOXOmaNWqlVCpVFpfN8XzAUDs2LFD/VylUglXV1exePFi9bbs7GxhY2MjNm3apDOf7t27ixkzZqifK5VK4e7uLhYtWmSUcmvzcF20OXXqlAAgkpOTdaap7mfUGLTVZdKkSWLYsGHVyqeuz4s+52TYsGGif//+laYxhXPy8N/c7OxsIZVKxdatW9VpLl26JACI6OhorXnU9PtFDVd9beuFMN/2vj629UKYT3vPtr6i+nBO6ktbL4Rpt/fswTdzCoUCANC0adNK0+Xl5cHLywuenp4YNmwYLly4UBvFq1RCQgLc3d3h6+uLcePG4fr16zrTRkdHIzg4WGNbSEgIoqOjjV3MaikuLsaGDRvw0ksvQSKR6Exniufj35KSkpCWlqZxzOVyOQIDA3Ue8+LiYpw9e1ZjHwsLCwQHB5vceVIoFJBIJHB0dKw0XXU+o7Xp4MGDcHZ2RuvWrTF9+nRkZWXpTFsfzkt6ejp+//13TJkypcq0dX1OHv6be/bsWZSUlGgc34CAALRs2VLn8a3J94satvrc1gPm196bS1sPmHd7z7betM5JfWrrAdNu7xngmzGVSoVZs2ahZ8+eaNeunc50rVu3xpo1a7Br1y5s2LABKpUKTz75JG7evFmLpdUUGBiIdevWYe/evVixYgWSkpLQu3dv5Obmak2flpYGFxcXjW0uLi5IS0urjeLqbefOncjOzsbkyZN1pjHF8/Gw8uNanWOemZkJpVJp8uepsLAQ8+bNw5gxY+Dg4KAzXXU/o7UlNDQUP/74I/bv34/PPvsMhw4dwjPPPAOlUqk1fX04L+vXr4e9vX2Vw9zq+pxo+5ublpYGa2vrCv9AVnZ8a/L9ooarPrf1gHm29+bS1gPm296zrS9jSuekvrT1gOm391Y13pNM3owZMxAXF1flfSlBQUEICgpSP3/yySfx+OOP47vvvsNHH31k7GJq9cwzz6h/79ChAwIDA+Hl5YUtW7bodWXPVP3www945pln4O7urjONKZ6PhqKkpASjRo2CEAIrVqyoNK2pfkbDwsLUv7dv3x4dOnRAq1atcPDgQQwYMKDOyvUo1qxZg3HjxlU5AVVdnxN9/+YSGVJ9buuBuv/eGgPbetPGtt401Ze2HjD99p49+Gbqtddew+7duxEVFYUWLVpUa1+pVIrOnTvjypUrRipd9Tk6OsLf319nmVxdXSvMUpmeng5XV9faKJ5ekpOTERkZialTp1ZrP1M8H+XHtTrH3MnJCZaWliZ7nsob/OTkZERERFR6RV+bqj6jdcXX1xdOTk46y2Xq5+XIkSOIj4+v9vcGqN1zoutvrqurK4qLi5Gdna2RvrLjW5PvFzVM5tbWA/W/vTenth4wv/aebb3pnROg/rT1QP1o7xngmxkhBF577TXs2LEDBw4cgI+PT7XzUCqV+Pvvv+Hm5maEEtZMXl4eEhMTdZYpKCgI+/fv19gWERGhcXW8rq1duxbOzs4YNGhQtfYzxfPh4+MDV1dXjWOek5ODkydP6jzm1tbW6Nq1q8Y+KpUK+/fvr/PzVN7gJyQkIDIyEs2aNat2HlV9RuvKzZs3kZWVpbNcpnxegLKesK5du6Jjx47V3rc2zklVf3O7du0KqVSqcXzj4+Nx/fp1nce3Jt8valjMta0H6n97b05tPWBe7T3betM7J+VMva0H6ll7X+Pp+cgkTZ8+XcjlcnHw4EGRmpqqfty7d0+dZsKECeLtt99WP//ggw/Evn37RGJiojh79qwICwsTMplMXLhwoS6qIIQQ4o033hAHDx4USUlJ4tixYyI4OFg4OTmJjIwMIUTFOhw7dkxYWVmJL774Qly6dEmEh4cLqVQq/v7777qqggalUilatmwp5s2bV+E1Uz0fubm5IjY2VsTGxgoA4quvvhKxsbHq2Wb/+9//CkdHR7Fr1y7x119/iWHDhgkfHx9RUFCgzqN///7i22+/VT//5ZdfhI2NjVi3bp24ePGiePnll4Wjo6NIS0urs7oUFxeLoUOHihYtWohz585pfG+Kiop01qWqz2hd1CU3N1e8+eabIjo6WiQlJYnIyEjRpUsX4efnJwoLC3XWpS7OS1WfLyGEUCgUolGjRmLFihVa8zCFc6LP39xXX31VtGzZUhw4cECcOXNGBAUFiaCgII18WrduLbZv365+rs/3ixouc2nrhTCv9r4+tvVCmE97z7aebb0x1af2ngG+mQGg9bF27Vp1mr59+4pJkyapn8+aNUu0bNlSWFtbCxcXF/Hss8+KmJiY2i/8v4wePVq4ubkJa2tr4eHhIUaPHi2uXLmifv3hOgghxJYtW4S/v7+wtrYWbdu2Fb///nstl1q3ffv2CQAiPj6+wmumej6ioqK0fpbKy6pSqcS7774rXFxchI2NjRgwYECF+nl5eYnw8HCNbd9++626ft27dxcnTpyo07okJSXp/N5ERUXprEtVn9G6qMu9e/fEwIEDRfPmzYVUKhVeXl5i2rRpFRpvUzgvVX2+hBDiu+++E7a2tiI7O1trHqZwTvT5m1tQUCD+7//+TzRp0kQ0atRIPPfccyI1NbVCPv/eR5/vFzVc5tLWC2Fe7X19bOuFMJ/2nm0923pjqk/tveT+GxERERERERFRPcZ78ImIiIiIiIjMAAN8IiIiIiIiIjPAAJ+IiIiIiIjIDDDAJyIiIiIiIjIDDPCJiIiIiIiIzAADfCIiIiIiIiIzwACfiIiIiIiIyAwwwCciIiIiIiIyAwzwiQgSiaTKx+TJk+u6mFV6//33IZFIsG7durouChERkUlhW0/UMFjVdQGIyHRMmjRJ52u9evWqxZIQERGRMbCtJzJvDPCJSI1Xw4mIiMwb23oi88Yh+kRERERERERmgAE+EdWIRCKBt7c3iouLER4ejlatWkEmk8HX1xfvvfceCgsLte6XlZWFt956C35+fpDJZGjatClCQ0Px559/6nyvrKwsLFy4EO3bt4ednR0cHBzQvn17zJ07F6mpqVr3+fvvvzF06FA0adIEdnZ26Nu3L44fP26QuhMRETUEbOuJ6h8G+ERUY0IIjBgxAosXL0abNm0waNAg3LlzBx999BEGDx4MpVKpkT4lJQXdu3fHF198geLiYgwfPhydO3dGZGQkQkJCsGTJkgrvcenSJXTq1AmffvopMjMzERISguDgYAghsHjxYpw8ebLCPmfOnEGPHj1w7do1hISEwM/PD4cPH8aAAQMQFxdntONBRERkbtjWE9UzgogaPACiun8Oyvdp0aKFSExMVG/PyMgQ7dq1EwDEkiVLNPYZPHiwACDGjh0rioqK1NuPHDkiGjVqJCwtLUVsbKx6e0lJiWjdurUAIGbNmqWxjxBCxMXFiStXrqifh4eHq8v19ddfa6SdNWuWACAmTJhQrXoSERGZA7b1RA0DA3wiUjeUlT127NihdZ9Vq1ZVyG/Pnj0CgGjVqpV6W2JiogAgGjduLLKysirsM2fOHAFATJ06Vb1t8+bNAoBo27atKC0trbIe5Y1+z549K7yWmZkpAAgvL68q8yEiIjI3bOuJGgbOok9EapUtndOyZUut28PCwipsCw0NRZMmTZCYmIjU1FS4ubnh6NGj6teaNm1aYZ8JEybgq6++wpEjR9TbIiMjAQBTp06FpaWl3vUYOHBghW3NmjVD06ZNdd7HR0RE1BCwrScybwzwiUitukvnNGnSBPb29lpf8/Lywt27d3Hr1i24ubnh1q1bAABvb2+t6cu3p6SkqLfduHEDANCqVatqlatFixZat9vb2+POnTvVyouIiMicsK0nMm+cZI+ITIJEIjFYXhYW/NNGRERkatjWExkfvxlEVGN3795Fbm6u1teuX78OAHB3d9f4mZycrDX9tWvXAAAeHh7qbZ6engCAxMREg5SXiIiIqodtPVH9wgCfiB7Jli1bKmz7888/cefOHfj6+sLNzQ0A0KtXLwDA3r17kZ2dXWGfDRs2AAB69+6t3hYcHAwA+OGHH6BSqQxddCIiItID23qi+oMBPhE9kg8++EB9RR4AMjMz8dZbbwEAZsyYod7u6+uLQYMGITc3FzNnzkRJSYn6tejoaKxYsQKWlpYa+zz//PPw9/dHXFwc5s6dq7EPAFy4cAFXr141Us2IiIgIYFtPVJ9wkj0iUps8ebLO11q2bIkPP/ywwrYOHTqgbdu2GDBgAKRSKQ4cOIDs7Gw89dRTeP311zXSf/fdd+jduzd+/PFHHDp0CEFBQbh9+zYOHjwIpVKJL7/8Ep06dVKnt7KywrZt2/D000/jyy+/xM8//4ygoCAIIZCQkIC4uDjs2LEDvr6+hjwMREREZottPZGZq+t1+oio7kGPtXE7duxYYR8vLy9RWFgoFixYILy9vYW1tbXw8vISCxcuFPfu3dP6XpmZmeKNN94QrVq1EtbW1sLR0VEMHDhQ7Nu3T2f50tPTxZtvvin8/f2FTCYTcrlctG/fXsybN0+kpqaq05Wvjbt27Vqt+Xh5eQn+2SMiooaIbT1RwyARQojau5xAROZCIpHAy8tLY8geERERmQ+29UT1D+/BJyIiIiIiIjIDDPCJiIiIiIiIzAADfCIiIiIiIiIzwHvwiYiIiIiIiMwAe/CJiIiIiIiIzAADfCIiIiIiIiIzwACfiIiIiIiIyAwwwCciIiIiIiIyAwzwiYiIiIiIiMwAA3wiIiIiIiIiM8AAn4iIiIiIiMgMMMAnIiIiIiIiMgP/Dz7y/DPShzNnAAAAAElFTkSuQmCC\n" }, "metadata": {} } ], "source": [ "hist = history.history\n", "x_arr = np.arange(len(hist['loss'])) + 1\n", "\n", "fig = plt.figure(figsize=(12, 4))\n", "ax = fig.add_subplot(1, 2, 1)\n", "ax.plot(x_arr, hist['loss'], '-o', label='Train loss')\n", "ax.plot(x_arr, hist['val_loss'], '--<', label='Validation loss')\n", "ax.set_xlabel('Epoch', size=15)\n", "ax.set_ylabel('Loss', size=15)\n", "ax.legend(fontsize=15)\n", "ax = fig.add_subplot(1, 2, 2)\n", "ax.plot(x_arr, hist['accuracy'], '-o', label='Train acc.')\n", "ax.plot(x_arr, hist['val_accuracy'], '--<', label='Validation acc.')\n", "ax.legend(fontsize=15)\n", "ax.set_xlabel('Epoch', size=15)\n", "ax.set_ylabel('Accuracy', size=15)\n", "\n", "#plt.savefig('images/15_12.png', dpi=300)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "d3dx-LhlifCi", "outputId": "c2d73fb8-ef1d-4e67-8d7b-d3113ba106dd" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "500/500 [==============================] - 2s 4ms/step - loss: 0.0503 - accuracy: 0.9919\n", "\n", "테스트 정확도 99.19%\n" ] } ], "source": [ "test_results = model.evaluate(mnist_test.batch(20))\n", "print('\\n테스트 정확도 {:.2f}%'.format(test_results[1]*100))" ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 373 }, "id": "T7kb_hRaifCi", "outputId": "c599467c-df28-4170-dee7-2b517a489892", "scrolled": true }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "TensorShape([12, 10])\n", "tf.Tensor([2 0 4 8 7 6 0 6 3 1 8 0], shape=(12,), dtype=int64)\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} } ], "source": [ "batch_test = next(iter(mnist_test.batch(12)))\n", "\n", "preds = model(batch_test[0])\n", "\n", "tf.print(preds.shape)\n", "preds = tf.argmax(preds, axis=1)\n", "print(preds)\n", "\n", "fig = plt.figure(figsize=(12, 4))\n", "for i in range(12):\n", " ax = fig.add_subplot(2, 6, i+1)\n", " ax.set_xticks([]); ax.set_yticks([])\n", " img = batch_test[0][i, :, :, 0]\n", " ax.imshow(img, cmap='gray_r')\n", " ax.text(0.9, 0.1, '{}'.format(preds[i]),\n", " size=15, color='blue',\n", " horizontalalignment='center',\n", " verticalalignment='center',\n", " transform=ax.transAxes)\n", "\n", "#plt.savefig('images/15_13.png', dpi=300)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "id": "5sLLwpHLifCi", "outputId": "39ae8e83-1323-4374-f0db-40c65383bd33", "colab": { "base_uri": "https://localhost:8080/" } }, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.10/dist-packages/keras/src/engine/training.py:3079: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.\n", " saving_api.save_model(\n" ] } ], "source": [ "import os\n", "\n", "if not os.path.exists('models'):\n", " os.mkdir('models')\n", "\n", "\n", "model.save('models/mnist-cnn.h5')" ] } ], "metadata": { "accelerator": "GPU", "colab": { "name": "ch15_part1.ipynb", "provenance": [] }, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.3" }, "widgets": { "application/vnd.jupyter.widget-state+json": { "f5811f7a80374167ab567e6993aa7305": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "model_module_version": "1.5.0", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_f14a9a46ed324257ab26fbccf5ed5fa6", "IPY_MODEL_b7a23744985b4457a51e9a9dd5f52b44", "IPY_MODEL_c190d2c40d1045cca1cef4ec4261473d" ], "layout": "IPY_MODEL_4d7074fe24804f2d8af5c1806cde1098" } }, "f14a9a46ed324257ab26fbccf5ed5fa6": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_1297a1c9e5dc4515a8c8cdec783119a1", "placeholder": "​", "style": "IPY_MODEL_cd15ff3ec76947d29c9f2be267ed92c0", "value": "Dl Completed...: 100%" } }, "b7a23744985b4457a51e9a9dd5f52b44": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "model_module_version": "1.5.0", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_6ed5ab9f93ca400faa09f9ad89ecd8e2", "max": 5, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_8ef4468985274fb8a0e7566755228f80", "value": 5 } }, "c190d2c40d1045cca1cef4ec4261473d": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "model_module_version": "1.5.0", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_cc52b2d1cf7c4261a25b9701cbef5fbf", "placeholder": "​", "style": "IPY_MODEL_3698440c0e9a420ab29237955cdd5bb0", "value": " 5/5 [00:00<00:00, 12.25 file/s]" } }, "4d7074fe24804f2d8af5c1806cde1098": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "1297a1c9e5dc4515a8c8cdec783119a1": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "cd15ff3ec76947d29c9f2be267ed92c0": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "6ed5ab9f93ca400faa09f9ad89ecd8e2": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "8ef4468985274fb8a0e7566755228f80": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "model_module_version": "1.5.0", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "cc52b2d1cf7c4261a25b9701cbef5fbf": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "model_module_version": "1.2.0", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "3698440c0e9a420ab29237955cdd5bb0": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "model_module_version": "1.5.0", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } } } } }, "nbformat": 4, "nbformat_minor": 0 }