Perceptron.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2697,
   "metadata": {},
   "outputs": [],
   "source": [
    "#パッケージをimort\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import cross_validate, StratifiedKFold\n",
    "from sklearn.datasets import load_iris\n",
    "import sklearn.base as base\n",
    "import sklearn.metrics as mt\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2968,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalize(data):\n",
    "    return ((data-data.mean())/data.std()).copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2606,
   "metadata": {},
   "outputs": [],
   "source": [
    "#base.BaseEstimator, base.ClassifierMixinを多重継承したPercepptronクラスを定義\n",
    "class Perceptron(base.BaseEstimator, base.ClassifierMixin):\n",
    "    \"\"\"\n",
    "    paramに必要な値\n",
    "        rho:収束速度を決めるパラメータ\n",
    "        margin:誤りの範囲を定めるマージン：0なら通常のパーセプトロン\n",
    "        maxTrial:最大試行回数\n",
    "    関数:\n",
    "        fit:estimatorに必須．内部でtrainPerceptronUpdateかtrainPerceptronを呼ぶ\n",
    "        predict:scoreを求めるのに必須．内部でpredictPerceptronを呼ぶ\n",
    "        set_params:値のset(入力はdict)\n",
    "        trainPerceptron:パーセプトロンを学習．\n",
    "        trainPerceptronUpdate:パーセプトロンを学習．重み変更ごとに最大scoreとなる重みを求める\n",
    "        predictPerceptron:学習した重みを用いて入力データのラベルを予測する．\n",
    "    その他\n",
    "        w:重み\n",
    "    \"\"\"\n",
    "    def __init__(self,params):\n",
    "        #parameterをdict形式で入力\n",
    "        self.params=params\n",
    "        self.set_params()\n",
    "\n",
    "    def set_params(self):\n",
    "        self.rho=self.params[\"rho\"]\n",
    "        self.margin=self.params[\"margin\"]\n",
    "        self.maxTrial=self.params[\"maxTrial\"]\n",
    "        #estimatorの要件でselfをreturn\n",
    "        return self\n",
    "    \n",
    "    def fit(self, train, train_label):\n",
    "        self.labels=train_label.unique()\n",
    "        self.labels.sort()\n",
    "        self.trainPerceptron(train,train_label)\n",
    "        #estimatorの要件でselfをreturn\n",
    "        return self\n",
    "    \n",
    "    def meaureScore(self, train, train_label, test, test_label):\n",
    "        self.labels=train_label.unique()\n",
    "        self.labels.sort()\n",
    "        self.trainPerceptronMeaureScore(train,train_label, test, test_label)\n",
    "        return self\n",
    "    \n",
    "    def predict(self, test):\n",
    "        preds=self.predictPerceptron(test)\n",
    "        return [self.labels[1 if pred else 0] for pred in preds]\n",
    "        \n",
    "\n",
    "\n",
    "    def trainPerceptron(self, train, train_label):\n",
    "        #重み，学習データは定数項分の次元を加える\n",
    "        self.w=np.ones(len(train.columns)+1)\n",
    "        ones=np.array([np.ones(len(train.index))])\n",
    "        X_values=np.concatenate((ones.T,train.values),axis=1)\n",
    "        ansLabels=train_label.values\n",
    "        misIdentified=True\n",
    "        #試行回数\n",
    "        trial=0\n",
    "        #試行回数まではLoop,分離成功したら終了\n",
    "        while misIdentified and trial<self.maxTrial:\n",
    "            misIdentified=False\n",
    "            #識別関数をデータ数分：行列演算で\n",
    "            preds = self.w.dot(X_values.T)>0\n",
    "            for i in range(len(train.index)):\n",
    "                x=X_values[i]\n",
    "                self.w.dot(x)\n",
    "                isMargin=self.margin-np.abs(self.w.dot(x)/np.linalg.norm(self.w))>0\n",
    "                #ラベルが一致していないかマージンが境界との距離を越えていないか\n",
    "                if self.labels[1 if preds[i] else 0] != ansLabels[i]:\n",
    "                    misIdentified=True\n",
    "                    x=X_values[i]\n",
    "                    #学習\n",
    "                    if preds[i]:\n",
    "                        self.w-=self.rho*x\n",
    "                    else:\n",
    "                        self.w+=self.rho*x\n",
    "                    #値が発散しないように正規化する\n",
    "                    self.w/=np.linalg.norm(self.w)\n",
    "                elif isMargin:\n",
    "                    misIdentified=True\n",
    "                    x=X_values[i]\n",
    "                    #学習\n",
    "                    if not preds[i]:\n",
    "                        self.w-=self.rho*x\n",
    "                    else:\n",
    "                        self.w+=self.rho*x\n",
    "                    #値が発散しないように正規化する\n",
    "                    self.w/=np.linalg.norm(self.w)\n",
    "            trial+=1\n",
    "\n",
    "    def predictPerceptron(self,test):\n",
    "        #定数項を加える\n",
    "        ones=np.array([np.ones(len(test.index))])\n",
    "        X_values=np.concatenate((ones.T,test.values),axis=1)\n",
    "        # g(x)>0\n",
    "        preds= self.w.dot(X_values.T)>0\n",
    "        return preds\n",
    "    \n",
    "    def trainPerceptronMeaureScore(self, train, train_label, test, test_label):\n",
    "        #重み，学習データは定数項分の次元を加える\n",
    "        self.w=np.ones(len(train.columns)+1)\n",
    "        self.w/=np.linalg.norm(self.w)\n",
    "        ones=np.array([np.ones(len(train.index))])\n",
    "        X_values=np.concatenate((ones.T,train.values),axis=1)\n",
    "        ansLabels=train_label.values\n",
    "        misIdentified=True\n",
    "        #試行回数\n",
    "        trial=0\n",
    "        #最大重みとsocore\n",
    "        trainscore=self.score(train,train_label)\n",
    "        testscore=self.score(test,test_label)\n",
    "        max_w=[self.score(train,train_label),self.w]\n",
    "        trainScores=[trainscore]\n",
    "        testScores=[testscore]\n",
    "        #試行回数まではLoop,分離成功したら終了\n",
    "        while trial<self.maxTrial:\n",
    "            misIdentified=False\n",
    "            #識別関数をデータ数分：行列演算で\n",
    "            preds= self.w.dot(X_values.T)>0\n",
    "            for i in range(len(train.index)):\n",
    "                x=X_values[i]\n",
    "                self.w.dot(x)\n",
    "                isMargin=True if self.margin==-1 else self.margin-np.abs(self.w.dot(x)/np.linalg.norm(self.w))>0\n",
    "                #ラベルが一致していないかマージンが境界との距離を越えていないか\n",
    "                if self.labels[1 if preds[i] else 0] != ansLabels[i]:\n",
    "                    misIdentified=True\n",
    "                    x=X_values[i]\n",
    "                    #学習\n",
    "                    if preds[i]:\n",
    "                        self.w-=self.rho*x\n",
    "                    else:\n",
    "                        self.w+=self.rho*x\n",
    "                    #値が発散しないように正規化する\n",
    "                    self.w/=np.linalg.norm(self.w)\n",
    "                elif isMargin:\n",
    "                    misIdentified=True\n",
    "                    x=X_values[i]\n",
    "                    #学習\n",
    "                    if not preds[i]:\n",
    "                        self.w-=self.rho*x\n",
    "                    else:\n",
    "                        self.w+=self.rho*x\n",
    "                    #値が発散しないように正規化する\n",
    "                    self.w/=np.linalg.norm(self.w)\n",
    "                #scoreを求めて，良いscoreなら最大重みとsocoreを更新\n",
    "                trainscore=self.score(train,train_label)\n",
    "                testscore=self.score(test,test_label)\n",
    "                trainScores.append(trainscore)\n",
    "                testScores.append(testscore)\n",
    "                if max_w[0]<trainscore:\n",
    "                    max_w[0]=trainscore\n",
    "                    max_w[1]=self.w\n",
    "                        \n",
    "            trial+=1\n",
    "        self.trainScores=trainScores\n",
    "        self.testScores=testScores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2933,
   "metadata": {},
   "outputs": [],
   "source": [
    "#base.BaseEstimator, base.ClassifierMixinを多重継承したPercepptronクラスを定義\n",
    "class PerceptronExtend(base.BaseEstimator, base.ClassifierMixin):\n",
    "    \"\"\"\n",
    "    関数:\n",
    "        fit:estimatorに必須．内部でtrainPerceptronUpdateかtrainPerceptronを呼ぶ\n",
    "        predict:scoreを求めるのに必須．内部でpredictPerceptronを呼ぶ\n",
    "        trainPerceptron:パーセプトロンを学習:重心法\n",
    "        predictPerceptron:学習した重みを用いて入力データのラベルを予測する．\n",
    "    その他\n",
    "        w:重み\n",
    "    \"\"\"\n",
    "    \n",
    "    def fit(self, train, train_label):\n",
    "        self.labels=train_label.unique()\n",
    "        self.labels.sort()\n",
    "        self.trainPerceptron(train,train_label)\n",
    "        #estimatorの要件でselfをreturn\n",
    "        return self\n",
    "    \n",
    "    def predict(self, test):\n",
    "        preds=self.predictPerceptron(test)\n",
    "        return [self.labels[1 if pred else 0] for pred in preds]\n",
    "        \n",
    "    def trainPerceptron(self, train, train_label):\n",
    "        ones=np.array([np.ones(len(train.index))])\n",
    "        X_values=np.concatenate((ones.T,train.values),axis=1)\n",
    "        w=-(X_values[train_label==self.labels[0]].mean(axis=0)-X_values[train_label==self.labels[1]].mean(axis=0))\n",
    "        w/=np.linalg.norm(w)\n",
    "        self.w=w\n",
    "\n",
    "    def predictPerceptron(self,test):\n",
    "        #定数項を加える\n",
    "        ones=np.array([np.ones(len(test.index))])\n",
    "        X_values=np.concatenate((ones.T,test.values),axis=1)\n",
    "        # g(x)>0\n",
    "        preds= self.w.dot(X_values.T)>0\n",
    "        return preds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2476,
   "metadata": {},
   "outputs": [],
   "source": [
    "#kakiデータを入力\n",
    "kaki=pd.read_csv(\"sample/kaki.csv\",dtype=float)\n",
    "kaki[\"ans\"]=\"kaki\"\n",
    "peanut=pd.read_csv(\"sample/peanut.csv\",dtype=float)\n",
    "peanut[\"ans\"]=\"peanut\"\n",
    "kakiData=pd.concat([kaki,peanut],ignore_index=True)\n",
    "#正規化（前処理）\n",
    "kakiData.height=normalize(kakiData.height)\n",
    "kakiData.width=normalize(kakiData.width)\n",
    "kakiData.length=normalize(kakiData.length)\n",
    "kakiLabels=[\"kaki\",\"peanut\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2416,
   "metadata": {},
   "outputs": [],
   "source": [
    "#アヤメデータを使用する場合\n",
    "irisdata=load_iris()\n",
    "\n",
    "iris=pd.DataFrame(irisdata.data,columns=[\"sepalLength\",\"sepalWidth\",\"petelLength\", \"petelWidth\"])\n",
    "iris[\"ans\"]=irisdata.target_names[irisdata.target]\n",
    "irislabels=irisdata.target_names\n",
    "#二値分類\n",
    "def getIris2(iris,labels):\n",
    "    labels.sort()\n",
    "    iris_2=iris[(iris[\"ans\"]==labels[0])|(iris[\"ans\"]==labels[1])].reset_index(drop=True)\n",
    "    #正規化\n",
    "    iris_2.sepalLength=normalize(iris_2.sepalLength)\n",
    "    iris_2.sepalWidth=normalize(iris_2.sepalWidth)\n",
    "    iris_2.petelLength=normalize(iris_2.petelLength)\n",
    "    iris_2.petelWidth=normalize(iris_2.petelWidth)\n",
    "    return iris_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2967,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x21cda8179b0>"
      ]
     },
     "execution_count": 2967,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#学習過程を得る\n",
    "dataset=kakiData\n",
    "\n",
    "train,test=train_test_split(dataset,test_size=0.2)\n",
    "trainX,trainy=train.drop(\"ans\",axis=1),train[\"ans\"]\n",
    "testX,testy=test.drop(\"ans\",axis=1),test[\"ans\"]\n",
    "\n",
    "params={\"rho\":1e-2,\"margin\":0,\"maxTrial\":100}\n",
    "perceptron=Perceptron(params)\n",
    "perceptron.meaureScore(trainX,trainy,testX,testy)\n",
    "\n",
    "plt.plot(perceptron.trainScores,label=\"train\")\n",
    "plt.plot(perceptron.testScores,label=\"test\")\n",
    "plt.ylim(0.5,1)\n",
    "plt.xlim(0,500)\n",
    "plt.ylabel(\"accuracy score\")\n",
    "plt.xlabel(\"trial count\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2793,
   "metadata": {},
   "outputs": [],
   "source": [
    "#扱うデータ\n",
    "dataset=kakiData\n",
    "#評価関数\n",
    "scoring = {\"precision\": \"precision_macro\",\n",
    "           \"recall\": \"recall_macro\",\n",
    "           \"f1\": \"f1_macro\"}\n",
    "#バリデーションにStratifiedKFoldを用いる,\n",
    "skf = StratifiedKFold(n_splits=5,shuffle=True, random_state=None)\n",
    "results=[]\n",
    "margin_sets=np.linspace(0,1,20)\n",
    "X,y=dataset.drop(\"ans\",axis=1),dataset[\"ans\"]\n",
    "for margin in margin_sets:\n",
    "    res=[]\n",
    "    for i in range(10):\n",
    "        #fitパラメータ\n",
    "        params={\"rho\":1e-3,\"margin\":margin,\"maxTrial\":100}\n",
    "        perceptron=Perceptron(params)\n",
    "        result=cross_validate(perceptron, X, y, cv=skf, scoring=scoring)\n",
    "        res.append(result)\n",
    "    results.append(res)\n",
    "mean_results={}\n",
    "for key in results[0][0]:\n",
    "    mean_results[key]=[]\n",
    "for result in results:\n",
    "    for key in mean_results:\n",
    "        meanres=[]\n",
    "        for r in result:\n",
    "            meanres.append(r[key].mean())\n",
    "        mean_results[key].append(np.array(meanres).mean())\n",
    "\n",
    "mean_results[\"margin\"]=margin_sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2797,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.95, 1)"
      ]
     },
     "execution_count": 2797,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "%matplotlib inline\n",
    "plt.plot(mean_results[\"margin\"],mean_results[\"test_precision\"],label=\"precision\")\n",
    "plt.plot(mean_results[\"margin\"],mean_results[\"test_recall\"],label=\"recall\")\n",
    "plt.plot(mean_results[\"margin\"],mean_results[\"test_f1\"],label=\"f1_score\")\n",
    "plt.legend()\n",
    "plt.xlabel(\"Margin\")\n",
    "plt.ylabel(\"Score\")\n",
    "plt.xlim(0,max(margin_sets))\n",
    "plt.ylim(0.95,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2788,
   "metadata": {},
   "outputs": [],
   "source": [
    "#扱うデータ\n",
    "dataset=getIris2(iris,irislabels[[0,1]])\n",
    "#評価関数\n",
    "scoring = {\"precision\": \"precision_macro\",\n",
    "           \"recall\": \"recall_macro\",\n",
    "           \"f1\": \"f1_macro\"}\n",
    "#バリデーションにStratifiedKFoldを用いる,\n",
    "skf = StratifiedKFold(n_splits=5,shuffle=True, random_state=None)\n",
    "resultsirisA=[]\n",
    "margin_sets=np.linspace(0,1,20)\n",
    "X,y=dataset.drop(\"ans\",axis=1),dataset[\"ans\"]\n",
    "for margin in margin_sets:\n",
    "    res=[]\n",
    "    for i in range(10):\n",
    "        #fitパラメータ\n",
    "        params={\"rho\":1e-3,\"margin\":margin,\"maxTrial\":100}\n",
    "        perceptron=Perceptron(params)\n",
    "        result=cross_validate(perceptron, X, y, cv=skf, scoring=scoring)\n",
    "        res.append(result)\n",
    "    resultsirisA.append(res)\n",
    "mean_results={}\n",
    "for key in resultsirisA[0][0]:\n",
    "    mean_results[key]=[]\n",
    "for result in resultsirisA:\n",
    "    for key in mean_results:\n",
    "        meanres=[]\n",
    "        for r in result:\n",
    "            meanres.append(r[key].mean())\n",
    "        mean_results[key].append(np.array(meanres).mean())\n",
    "\n",
    "mean_results[\"margin\"]=margin_sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2792,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.985, 1)"
      ]
     },
     "execution_count": 2792,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(mean_results[\"margin\"],mean_results[\"test_precision\"],label=\"precision\")\n",
    "plt.plot(mean_results[\"margin\"],mean_results[\"test_recall\"],label=\"recall\")\n",
    "plt.plot(mean_results[\"margin\"],mean_results[\"test_f1\"],label=\"f1_score\")\n",
    "plt.legend()\n",
    "plt.xlabel(\"Margin\")\n",
    "plt.ylabel(\"Score\")\n",
    "plt.xlim(0,max(margin_sets))\n",
    "plt.ylim(0.985,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2779,
   "metadata": {},
   "outputs": [],
   "source": [
    "#扱うデータ\n",
    "dataset=getIris2(iris,irislabels[[0,2]])\n",
    "#評価関数\n",
    "scoring = {\"precision\": \"precision_macro\",\n",
    "           \"recall\": \"recall_macro\",\n",
    "           \"f1\": \"f1_macro\"}\n",
    "#バリデーションにStratifiedKFoldを用いる,\n",
    "skf = StratifiedKFold(n_splits=5,shuffle=True, random_state=None)\n",
    "resultsirisB=[]\n",
    "margin_sets=np.linspace(0,1,20)\n",
    "X,y=dataset.drop(\"ans\",axis=1),dataset[\"ans\"]\n",
    "for margin in margin_sets:\n",
    "    res=[]\n",
    "    for i in range(10):\n",
    "        #fitパラメータ\n",
    "        params={\"rho\":1e-3,\"margin\":margin,\"maxTrial\":100}\n",
    "        perceptron=Perceptron(params)\n",
    "        result=cross_validate(perceptron, X, y, cv=skf, scoring=scoring)\n",
    "        res.append(result)\n",
    "    resultsirisB.append(res)\n",
    "mean_results={}\n",
    "for key in resultsirisB[0][0]:\n",
    "    mean_results[key]=[]\n",
    "for result in resultsirisB:\n",
    "    for key in mean_results:\n",
    "        meanres=[]\n",
    "        for r in result:\n",
    "            meanres.append(r[key].mean())\n",
    "        mean_results[key].append(np.array(meanres).mean())\n",
    "\n",
    "mean_results[\"margin\"]=margin_sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2784,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.98, 1)"
      ]
     },
     "execution_count": 2784,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "plt.plot(mean_results[\"margin\"],mean_results[\"test_precision\"],label=\"precision\")\n",
    "plt.plot(mean_results[\"margin\"],mean_results[\"test_recall\"],label=\"recall\")\n",
    "plt.plot(mean_results[\"margin\"],mean_results[\"test_f1\"],label=\"f1_score\")\n",
    "plt.legend()\n",
    "plt.xlabel(\"Margin\")\n",
    "plt.ylabel(\"Score\")\n",
    "plt.xlim(0,max(margin_sets))\n",
    "plt.ylim(0.98,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2940,
   "metadata": {},
   "outputs": [],
   "source": [
    "#扱うデータ\n",
    "dataset=getIris2(iris,irislabels[[1,2]])\n",
    "#評価関数\n",
    "scoring = {\"precision\": \"precision_macro\",\n",
    "           \"recall\": \"recall_macro\",\n",
    "           \"f1\": \"f1_macro\"}\n",
    "#バリデーションにStratifiedKFoldを用いる,\n",
    "skf = StratifiedKFold(n_splits=5,shuffle=True, random_state=None)\n",
    "resultsirisC=[]\n",
    "margin_sets=np.linspace(0,2,20)\n",
    "X,y=dataset.drop(\"ans\",axis=1),dataset[\"ans\"]\n",
    "for margin in margin_sets:\n",
    "    res=[]\n",
    "    for i in range(10):\n",
    "        #fitパラメータ\n",
    "        params={\"rho\":5e-3,\"margin\":margin,\"maxTrial\":100}\n",
    "        perceptron=Perceptron(params)\n",
    "        result=cross_validate(perceptron, X, y, cv=skf, scoring=scoring)\n",
    "        res.append(result)\n",
    "    resultsirisC.append(res)\n",
    "mean_results={}\n",
    "for key in resultsirisC[0][0]:\n",
    "    mean_results[key]=[]\n",
    "for result in resultsirisC:\n",
    "    for key in mean_results:\n",
    "        meanres=[]\n",
    "        for r in result:\n",
    "            meanres.append(r[key].mean())\n",
    "        mean_results[key].append(np.array(meanres).mean())\n",
    "\n",
    "mean_results[\"margin\"]=margin_sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2942,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.9, 1)"
      ]
     },
     "execution_count": 2942,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "plt.plot(mean_results[\"margin\"],mean_results[\"test_precision\"],label=\"precision\")\n",
    "plt.plot(mean_results[\"margin\"],mean_results[\"test_recall\"],label=\"recall\")\n",
    "plt.plot(mean_results[\"margin\"],mean_results[\"test_f1\"],label=\"f1_score\")\n",
    "plt.legend()\n",
    "plt.xlabel(\"Margin\")\n",
    "plt.ylabel(\"Score\")\n",
    "plt.xlim(0,max(margin_sets))\n",
    "plt.ylim(0.90,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2465,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset=kakiData.sample(len(kakiData.index))\n",
    "#全てのデータで学習    \n",
    "params={\"rho\":5e-3,\"margin\":0,\"maxTrial\":1000}\n",
    "perceptron=Perceptron(params)\n",
    "X,y=dataset.drop(\"ans\",axis=1),dataset[\"ans\"]\n",
    "perceptron.fit(X,y)\n",
    "w=perceptron.w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2466,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support. ' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option);\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAyAAAAJYCAYAAACadoJwAAAgAElEQVR4Xuy9B3hkV3n//05T73W12qbtvXnd1utur01ooSSAITEQEkIIeSgBAoHnB6GkQEIgCQSSGAh5IIQEQolxt9dlvV5v8VZv1xbtSqveRzOa8n++7/rof3c80hRNuVf6HluPVtKde8/9nDN3zve8zRWNRqPCRgIkQAIkQAIkQAIkQAIkQAI5IOCiAMkBZV6CBEiABEiABEiABEiABEhACVCAcCKQAAmQAAmQAAmQAAmQAAnkjAAFSM5Q80IkQAIkQAIkQAIkQAIkQAIUIJwDJEACJEACJEACJEACJEACOSNAAZIz1LwQCZAACZAACZAACZAACZAABQjnAAmQAAmQAAmQAAmQAAmQQM4IUIDkDDUvRAIkQAIkQAIkQAIkQAIkQAHCOUACJEACJEACJEACJEACJJAzAhQgOUPNC5EACZAACZAACZAACZAACVCAcA6QAAmQAAmQAAmQAAmQAAnkjAAFSM5Q80IkQAIkQAIkQAIkQAIkQAIUIJwDJEACJEACJEACJEACJEACOSNAAZIz1LwQCZAACZAACZAACZAACZAABQjnAAmQAAmQAAmQAAmQAAmQQM4IUIDkDDUvRAIkQAIkQAIkQAIkQAIkQAHCOUACJEACJEACJEACJEACJJAzAhQgOUPNC5EACZAACZAACZAACZAACVCAcA6QAAmQAAmQAAmQAAmQAAnkjAAFSM5Q80IkQAIkQAIkQAIkQAIkQAIUIJwDJEACJEACJEACJEACJEACOSNAAZIz1LwQCZAACZAACZAACZAACZAABQjnAAmQAAmQAAmQAAmQAAmQQM4IUIDkDDUvRAIkQAIkQAIkQAIkQAIkQAHCOUACJEACJEACJEACJEACJJAzAhQgOUPNC5EACZAACZAACZAACZAACVCAcA6QAAmQAAmQAAmQAAmQAAnkjAAFSM5Q80IkQAIkQAIkQAIkQAIkQAIUIJwDJEACJEACJEACJEACJEACOSNAAZIz1LwQCZAACZAACZAACZAACZAABQjnAAmQAAmQAAmQAAmQAAmQQM4IUIDkDDUvRAIkQAIkQAIkQAIkQAIkQAHCOUACJEACJEACJEACJEACJJAzAhQgOUPNC5EACZAACZAACZAACZAACVCAcA6QAAmQAAmQAAmQAAmQAAnkjAAFSM5Q80IkQAIkQAIkQAIkQAIkQAIUIJwDJEACJEACJEACJEACJEACOSNAAZIz1LwQCZAACZAACZAACZAACZAABQjnAAmQAAmQAAmQAAmQAAmQQM4IUIDkDDUvRAIkQAIkQAIkQAIkQAIkQAHCOUACJEACJEACJEACJEACJJAzAhQgOUPNC5EACZAACZAACZAACZAACVCAcA6QAAmQAAmQAAmQAAmQAAnkjAAFSM5Q80IkQAIkQAIkQAIkQAIkQAIUIJwDJEACJEACJEACJEACJEACOSNAAZIz1LwQCZAACZAACZAACZAACZAABQjnAAmQAAmQAAmQAAmQAAmQQM4IUIDkDDUvRAIkQAIkQAIkQAIkQAIkQAHCOUACJEACJEACJEACJEACJJAzAhQgOUPNC5EACZAACZAACZAACZAACVCAcA6QAAmQAAmQAAmQAAmQAAnkjAAFSM5Q80IkQAIkQAIkQAIkQAIkQAIUIJwDJEACJEACJEACJEACJEACOSNAAZIz1LwQCZAACZAACZAACZAACZAABQjnAAmQAAmQAAmQAAmQAAmQQM4IUIDkDDUvRAIkQAIkQAIkQAIkQAIkQAHCOUACJEACJEACJEACJEACJJAzAhQgOUPNC5EACZAACZAACZAACZAACVCAcA6QAAmQAAmQAAmQAAmQAAnkjAAFSM5Q80IkQAIkQAIkQAIkQAIkQAIUIJwDJEACJEACJEACJEACJEACOSNAAZIz1LwQCZAACZAACZAACZAACZAABQjnAAmQAAmQAAmQAAmQAAmQQM4IUIDkDDUvRAIkQAIkQAIkQAIkQAIkQAHCOUACJEACJEACJEACJEACJJAzAhQgOUPNC5EACZAACZAACZAACZAACVCAcA6QAAmQAAmQAAmQAAmQAAnkjAAFSM5Q80IkQAIkQAIkQAIkQAIkQAIUIJwDJEACJEACJEACJEACJEACOSNAAZIz1LwQCZAACZAACZAACZAACZAABQjnAAmQAAmQAAmQAAmQAAmQQM4IUIDkDDUvRAIkQAIkQAIkQAIkQAIkQAHCOUACJEACJEACJEACJEACJJAzAhQgOUPNC5EACZAACZAACZAACZAACVCAcA6QAAmQAAmQAAmQAAmQAAnkjAAFSM5Q80IkQAIkQAIkQAIkQAIkQAIUIJwDJEACJEACJEACJEACJEACOSNAAZIz1LwQCZAACZAACZAACZAACZAABQjnAAmQAAmQAAmQAAmQAAmQQM4IUIDkDDUvRAIkQAIkQAIkQAIkQAIkQAHCOUACJEACJEACJEACUxCIRqMyMDAgg4ODEgqFJBKJkNcMI+B2u6WoqEgaGxvF4/HMsLuz3+1QgNhvTNgjEiABEiABEiABmxAYHx+XtrY2GRsb0x5hcYrFKtvMIhAOh1VYQoQsWLCAIiTLw0sBkmXAPD0JkAAJkAAJkIBzCXR2dkpPT49UVFRIQ0OD+Hw+594Mez4pAVi5Ojo6pL+/XyorK2Xu3LmklUUCFCBZhMtTkwAJkAAJkAAJOJvAmTNnBFaQ5cuXi8vlcvbNsPdTEoAIOXHihIrMxYsXk1YWCVCAZBEuT00CJEACJEACJOBsAqdOndIbWLp0qbNvhL1PigDHOylM0z6IAmTaCHkCEiABEiABEiCBmUqAC9KZOrLx74vjnZvxpgDJDWdehQRIgARIgARIwIEEuCB14KBNo8sc72nAS+GlFCApwOKhJEACJEACJEACs4sAF6Qc79lFIDd3SwGSG868CgmQAAmQAAmQgAMJzCYB8r3vfU/e8573yKOPPip33XXXtEfr3e9+t3z/+9/XIH6v1zvp+T73uc/J5z//eUEQeL7bbBrvfLKmAMknfV6bBEiABEiABEjA1gRm04KUAkRkNo13Pt94FCD5pM9rkwAJkAAJkAAJ2JrAbFqQ5kuABINBwVdZWVne58JsGu98wqYAySd9XpsESIAESIAESMDWBGbTgjRfAsROE2A2jXc+uVOA5JM+r00CJEACJEACJGBrArlYkJ7rGZHLgwFprCiUhbWleeMRT4BEIhF5//vfLw888IB8+9vflje/+c3y13/91/LII48IijTCcrF69Wr5yEc+Iu9617uu6nu8GBBUlX/Na16jr/31r38t1157rTAGJG9DnrcLU4DkDT0vTAIkQAIkQAIkYHcC2RQgL13oly/931F58WzfBIZrF1XLn792tWycX5VzNLECBOLivvvuk1/+8pfywx/+UN7ylrfInj175E1vepP+G9XhA4GA/PSnP5Vnn31W/u3f/k3e+973TvQ7VoC0tbXJ9u3bZWhoSAXMqlWr9FgKkJwPdd4vSAGS9yFgB0iABEiABEiABOxKIFsCBOLjbd9+XgKhyKtuvdDrlh+//8acixCrALnhhhtUaOzatUt+9rOfTWTFguBARiuPxzPRb2SvQtYsCIzjx4/HFSCweEB8FBYWapatBQsWTBxHAWLX2Z+9flGAZI8tz0wCJEACJEACJOBwAtkSIL/1zzuvsnzEYoIl5Cd/uDWn9IwA+fGPfyx/93d/JydPnpQHH3xQrr/++rj9gIVkeHhY4Kb1L//yL/LpT39aBgYGpKKiQo83FpDdu3fL6173OmlubpaHHnpIGhoarjofBUhOh9kWF6MAscUwsBMkQAIkQAIkQAJ2JJANAYKYj1u/8lTC233647fLgtqShMdl6gAjQMrLy2V0dFT27t0rGzZsuOr0sHZ8/etfl3/+53+WEydOvKp2x7lz5yasG0aA4Hz19fWyf//+CXFiPSkFSKZG0DnnoQBxzlixpyRAAiRAAiRAAjkmkA0Bsru1V377288nvJP/ev+Ncl1LTcLjMnWAESAoRogCggg4/9GPfnRVEcGvfOUr8olPfELe+c53yj333KPCAi5ZsJR87Wtfk9bWVlm0aJF2yQiQ973vffKv//qv+vcPf/jDr+ouBUimRtA556EAcc5YsackQAIkQAIkQAI5JpANAWJ3CwhiNC5duqRV0d/61rdqALqJ+di0aZNUVlbKU09dbcH51Kc+JX/1V38VV4DAVeuP/uiPVIR84xvfkA996ENXjSIFSI4ntQ0uRwFig0FgF0iABEiABEiABOxJIBsCBHdqtxgQuFZ9+18fkA/8wfs0SBxB5Ui9C+vF29/+dvnBD36gImTLli1SWloqO3bsmBiwrq4uWbNmjeB7PAvI+Pi4vvb3fu/35Lvf/a5885vflA984AMTr6cAsefcz2avKECySZfnJgESIAESIAEScDSBbAkQO2XBGg9HZCQQkv/5z/+Q9/3e700IEAwcgstRBwQ1PuCi9eUvf1k++9nPyjve8Q65/fbb1VKC+iBNTU2yb9++SQUI3LQQrA6rCsQMYkj+4A/+QOcGBYij3yJpdZ4CJC1sfBEJkAAJkAAJkMBsIJAtAQJ2+a4DAqvH2HhEQpGIFPs88h8/+HcVCMYCYsYXAgMWi/vvv1/Fxpe+9CWNEeno6JCWlhb54Ac/KGVlZfraySwgECBoECG/+7u/q25dEDewilCAzIZ30tX3SAEy+8acd0wCJEACJEACJJAkgWwKENMFUwl9TkVRzrJehcIRCYYj4hIRr8ctPo87SSIz+7BcjPfMJpjc3VGAJMeJR5EACZAACZAACcxCAjNxQTo2HhaXSyQaFfG4XRQflnk9E8fbjm9bChA7jgr7RAIkQAIkQAIkYAsCM2lBiliPYOiKuxX+7ab4eNUcm0njbYs30CSdoACx8+iwbyRAAiRAAiRAAnklMFMWpP5gSAKhiFSVFEhgPCxul0t8XrpdxU6umTLeeX3TJHFxCpAkIPEQEiABEiABEiCB2UnA6QvScASB5mGtWF5W5JNAKCwucUkBxUfcCe308XbKu5QCxCkjxX6SAAmQAAmQAAnknICTF6SwdESiUYlERUoLvRIMhUUoPqacQ04e75y/OaZxQQqQacDjS0mABEiABEiABGY2AScuSCOweoTCGlyOmI+SAo+6X7ldIgVez8wesGnenRPHe5q3nJeXU4DkBTsvSgIkQAIkQAIk4AQCTluQwsUqEhEp9LnFHwxLcYFHhsdC4vW4pKTgSi0OtskJOG28nTqWFCBOHTn2mwRIgARIgARIIOsEnLIghavVoH9cinweKfS6ZTQIC4hLCw3i50IfLR/JTBanjHcy92LnYyhA7Dw67BsJkAAJkAAJkEBeCThhQQo3K/94WEp8HrV0QHygzgeax+Wi+EhhBjlhvFO4HdseSgFi26Fhx0iABEiABEiABPJNwM4LUmS2gvBAQUHEe8DiMTgW0u9et1szX9HykdoMsvN4p3Yn9j6aAsTe48PekQAJkAAJkAAJ5JGAXRekKCSIL1g4XKjp4XFJ32hQs12hxgfS78Idiy01AnYd79Tuwv5HU4DYf4zYQxIgARIgARIggTwRsNuCFFYN1PXwuFFEMKppdeFuhfiP6pICCUejFB/TmCt2G+9p3IqtX0oBYuvhYedIgARIgARIgATyScBOC1JYPEYCIako9kkoHFEssHQgBqS82CdIvxui5eNV0+WBBx6QwcFB+fCHP5xwKtlpvBN21sEHUIA4ePDYdRIgARIgARIggewSsMOC1Fg9UMujstgn42FYOSIa+4HsVyWFXoqPKabBtm3bpK2tTc6ePZtwsthhvBN2cgYcQAEyAwaRt0ACJEACJEACJJAdAvlekMLSAQsHhAbiOyA+UOujwONWawfqfNDyMfXYU4Bk570xnbNSgEyHHl9LAiRAAiRAAiQwownkU4Ag1gPZdCE0TDXzwHhYyop8KkKKvB6teA43rPIi37TH4Xvf+5685z3vkQcffFCefvpp+f73vy99fX1y7bXXyt///d/L5s2bJ64RDoflG9/4hnz3u9+VEydOSHFxsdx2223y5S9/WVatWjVx3Llz5+SrX/2qPPHEE4J/o23atEk+/elPy2te85qr+ozXg/fOnTvlT/7kT+Txxx8Xn88nv/3bvy1f//rXpbCwcOL4RYsW6fXQZ2v73Oc+J5///Oc1AxgajjPXtR5n/h4LLZ/jPe0BdNAJKEAcNFjsKgmQAAmQAAmQQG4J5GRB2ntGZKhDpHyOSM1ida+CuxUKCKKQIMTHSBDpdq8IjdFgSC0gECiIQC8rzEyFcyNANmzYoNe6//77NXbiH//xH2V8fFz27Nkjy5Yt0wH4rd/6Lfnf//1f+Z3f+R257rrrpKenR775zW/KyMiIvPjiixPH/fd//7d85jOfkTe+8Y2yePFiPd8PfvADOXz4sDz66KNy5513TgwoBMWhQ4ekurpabr31VhU+u3btUiGEc3zhC19IWYCgj5/85Celt7dXvva1r028/l3velfciZST8c7tFLbl1ShAbDks7BQJkAAJkECuCJid0EgkIh4P05bmirtTrpPVBWnbXpFH/lzk/PMTOMLzbpDxu/5CChdepwUFC31uGQ2EtcBgSYFXxYdLXOqS5XaJFBdkRnygA0aAQCgcOHBAysrKtF/4N6wfb33rW+XHP/6x/OQnP1GrBL7jd6ZdvHhRVq9eLb/xG78hP/rRj/TXo6OjUlJSctVwBwIB2bhxoyxYsEAefvjhqwTIjh071GLysY99bOL3v/mbv6lWkc7OzpQFCF5AFyz7vdsoQOw3JuwRCZAACZBAFghAaEz2BXcSLIrg4gERYr5QX4FtdhPImgCB+Pjeb4iExl4FOOotkrF3/kJc87ao+5XX7dKaHqOBkAoPn9etcR+ZFB9WAQI3qk996lNX9Wv79u3y/PPPy8DAgIoOWCYOHjz4qr6/853vlH379klXV9er/jY2NqYWErwPP/vZz6qYgWXCNFhA4PqFY+DSZRosFx/96EfVelJeXq6/TtYFiwLEnu9fChB7jgt7RQIkQAIkkAYBY82IFRqwbuB3+H769Gmpr6+XioqKiSvg91gcQXC43W7x+/3678rKSvF6vSpI8HsKkjQGxeEvyZoAeeDeqywfsZhgCQnd/6BW+oD4QJ0Pt9slxT63umfBGpLpZiwg//M//yNvfvObrzr9hz70IXXF6ujokNtvv11efvnlKS8PUY/3DFy34Dr17//+76+KxcD7Ce89qwA5fvy4tLe3X3Vu0y9ksVq4cCEFSKYHPg/nowDJA3RekgRIgARIYHoEprJmmL/hCvECTeF3vmbNGpk3b552AougUCikCyUsmPAa+KFjYYTj8Dt8GauIVZBM7y74aicQyIoAQczHNzYlvP3AH+2TgvrF0u8fl2Kf50rcRyicFfGBzpiF/k9/+lN505veNKkAQXxGMBiU73znO5PeA2I78N764Ac/KN/61rfkAx/4gLpC1dTU6HsJwes//OEPr3qPmiB0pMy1NtOv1tZWtXygtbS0aJxIbBA6LCtf/OIXrzovXbASTrWcH0ABknPkvCAJkAAJkEAyBBJZM6x/t57PWCms1grzb7wGPudr166dECB4rREgJgYEriU4dv369SpEjPUE5zFWEhwLMWIECa0jyYyq847JigA5t1Pku1dngIpHJvS7/yfDc67TIHO3y6VB56j5ka1mFvqJXLAQUP7UU0+p+xSyVE3VEFCO42OFwjve8Q75z//8z7QFCGJS5s+fLz//+c+vujxcwGKFzc033ywXLlxgHZBsTZw0zksBkgY0voQESIAESCBzBNK1ZkwlNCbrHcTEI488cpUAwe/gW45mgmURdIvzQ4CYZg1WN6LEiBFYSIwQYfxI5uaGHc6UaQGCGI6R9pNS/p1rE97eyB/ukcL6Jep65Q+GtQ5INps1CB0ivLS0VC9ngtDf8pa3yH/9139pgPl9990n/+///T9B2tvYhmDxhoYG/XVdXZ289rWv1UxWpsHNCkHocHu0WilTsYC87W1vkyeffFLduky8CFy0YLVE4Lv1vPfee6/GrPT39yfEl+nxTnjBWXoABcgsHXjeNgmQAAnkkkA8kYHrm4V8OtaMVPqP88NlZGhoSFOJ1tbWqlsVgl2xWDENAgQuIgi0xc4uFkmTNes9GT92YyEx1hEjRhg/kspo2evYTC5IUVBwJBCSimKvuL/7GnFd2DXpzSIGJPqeX0+ID6TizbaVLTYN77vf/W4V5//wD/+gSRrw3lmxYoUu7mHBQBA5gtPvvvtuDQ6HGHjooYc0E9Z//Md/6L29733vU3er97///Vr/48yZM+qShUxb+/fvT1uAwAKDWJStW7cKrB4IekcaYFhF9u7de9V5kcL3S1/6ktYWuf766/W9//a3vz0u+0yOt71msr16QwFir/Fgb0iABEjAsQSmcpnCTU0VmxFrzUh3oQUhAFER7wtuVqYVFBRogDl2ePFVVFSkQgQ7pCi8hp1ZNBwDQYIvLLCwcEkkSKyiyho/YrWQTHUex06AGdrxTCxIMff941cKBiJ4XAXxuRel+IdvENckWbDCv/srkeZrNBVveZE36+IDwxevECHcrFCPA5motmzZMjHKuAfEgDzwwANy5MgRvae5c+dqnMfv//7vqzBAGx4e1oxaiCvBuVauXCl/9md/pkHs1oKBODYVCwiOh5D5m7/5G7l06ZLWHYFFBn2JPS82FCCAYP3Ee9z6LIqdtpkY7xn6VsjobVGAZBQnT0YCJEACM59ALl2m4tE01gwjMrDAgXjAd2SvMg0LfiMwzHdYOFBPYN26ddLc3DxxrDUGBOdHGlFk8YEwgSDBv3E++LPjC4IEbh9TCSUTN2KNHzGWECNGGD9i//fLdBek4+GI4AsNhQVRoHs4EFIhEmnbI4WPf/YqS0hk/g0SufuLEmrarDEflcW+nIgPqwBBooa77rrL/oOThR5Od7yz0KUZeUoKkBk5rLwpEiABEpgegVStGViwo4YG/K8zZc3Aoh/CIpE1A6IiVmjgZ1g5YgUCzonFFWI7sFtrWmwQ+ksvvaSZeiBUYNGA6xZ2b/EFlxTwgTgx1hGIkqmCcWPdtfBzvPgRCBK6a01v7mb61ekuSDHGEBAet1srmxd43RIKR2V0PCxVxT6tcO7zuDSlbqTnjJSPd0uguFGkepHW/kCsCILP07UGpsPBWEAoQESWLl2aDkK+JkkCFCBJguJhJEACJDATCWTKmrF7925dkG/YsCElTFZrBiwYJiYjkTUDFZohMiA+UnFnSkeAxN4QxAqsIviCIDExJHDRMoIErlupuGvhGvHiRyBIzO9TAsuDM0YgHQESCIVlPAx3K48ELEIDLlgVKj7CghKXEBpoCC4PjIdl/JWig1dctbIf8xELiQJEJJ3xzthkm0UnogCZRYPNWyUBEpidBKayZsQGf1szx8RLYzvZbiwECCwgkwmQbFgz0hnNZAUIgmNh0UC63kQN8SLGOgJRYuqJWN21IJYSuWsZVy1YXHDsxYsX1d2rqqrqqgxbqQiuRH3n3xMTSGVBijFEzIYRGoj7QNQQXLCQRhcpdCE+8HePG0X4ohO/Q4C6CpZXvufS8mEoUIBQgCR+R2TmCAqQzHDkWUiABEgg7wQyZc0wu/Gp3BAECFyeVq1apbEYsW5TU8VmpGvNSKV/5lhYLx577LGELlipCBBrPzAGuH8jSBD8CkEBNlZ3LYi1qRrOgxSjcAOZM2fOhLsWFqXW2iNwE8vHQjUd9k59TbICJBSOyFgoopYNWDQmhAaqfcuV4PPRYEjFB4oKGqGBrFiwg8DdCuIlH5YPp45NNvqd7Hhn49qz6ZwUILNptHmvJEACjieQyJqRKJ2tVVyku3CNZ824fPnyREpdcw0EaScbm5GrgTECBJaapqamicvGxoCkK0Bi7wOsTGYtiBKIEzRwMYIEFg5TANH6+ieeeEJTniJWxYjLyeqPWKuzpzuuuRoDp10nmQUpxAaCy6OvCA2ICsRwQGgEw7BseGXQP65Wj+ICj9b0wN+GAuNa3bzI51Hxgb/BUsKWPwLJjHf+ejdzrkwBMnPGkndCAiQwgwjk05oBjLg+8v7HCwC3WjPgpoQ4DPwOu/xIhZlObEauhi5ZAWINqs9k31CLxFhH8B0/QzDEpvvFNWEBQcpSa7C8GRtrhi0j+EzKX6uFhO5a0x+9qRakCC6HJQMiQl2oCi1Cw+eRsVBYCr0eGRobV8GBQHQIDa/7SvB5kc8tPs+V31F8TH+sMnEGCpBMUEx8DgqQxIx4BAmQAAlkhcBU1gzEFSCeAFWEYxeR6VQAn+wGkonNwPXiWTPgOgUBgr+/+OKLCQv3ZQViiifNtwCxdlfjBUZHJwQJLCXWdL8orIZibYsWLZryLuOl+zUZtqwFEU1Ae4rIZv3hky1IRwMhLRIIUQGLBsTE0FhIhYbvld8ZoQFxgX+PBMLidiHhgOhrIU5gLcFr8DNb/glQgORmDChAcsOZVyEBEpjFBNKxZvT09GgtiptvvlktDKal416TijUjnstUMpmmnCJAECD++OOPa4VzxFaYFuuClS0LyFRvA7hXIWYEwhPjj9S/aBB/1vgRCInJmhG1ONdk7lqmOjvjR5J7KKFyN+bN8uXLVWwjcBwWjcJXLBoQH3CtggUEQgP/VnECleES8bph5XCpCxaECYQI3LWMNYTiI7lxyMVReP+cOHFCN1Mg/tmyR4ACJHtseWYSIIFZRCAdkQE8k1kzsADFov6WW265SoBMhTRT1ox0hm2mCZC9e/fqwn/16tXp4Jj2azCWO3bskHnz5qmQgLsWrGKYL9Z0vxUVFUml+7VaSUydEXzHQssIEtYfiT9snZ2dKgjBuqqmViIuj1ouICpgvTBCw+d2i+cVoYGCg7Bo4D8Ijn5/UMqLfAgS0dgQiJTBsZBUFHnF60GeLLZ8E/Rz1gMAACAASURBVMB7pKOjQ2O24BIZ6/qY7/7NtOtTgMy0EeX9kAAJZI1AqsX5rB1JtTjfZAIkF9aMdABSgKRDbfLXGAECAWQsNYizsab7hdUG4sFUZsd3WKuSTfdrRLOJHTFCxBrQntm7cubZYP04f+GCDI2MqjXD6/GI1+uZSK1rYsbhQIU6Hj5YOCy3iqxXEBn6/Ljyv4oQnIvx5vaZE3jPQeyjntGCBQviJoawT2+d3xMKEOePIe+ABEggwwQybc1Ip3vd3d2yZ88eDULGB6M1GBwLT7R4sRkmpa2JzUjn2um8xikCBEHfyC6VyAUr3xYQjPHTTz+tleUbGxtfNSSYo9bq7HDdwu+Q3tfqroXEAFO1ePEjxhJi4keMIEnH/S+duWS317T1jcrA6LgURsYkODYiPldULvaNSkN5oYRR0V4FhUj/aFCaKos0FS9UBmp/4N/1ZQUSDF+pio5jIUBKCxETQsuHncYa8x7iA++3eFnp7NTXmdAXCpCZMIq8BxIggZQJ5NKaMVnn7GrNSBmmiGOC0I0A2bRp01UL+9gYEIg/xMOgrkk+Gnbdn3nmGS2E2NDQkLAL6L813S8EKxoEqbU6+1QLq3jxIxA5SB2MHWEjRPB9NrhrjYfCsqu1V1bOqdBUuuEwkuxGZXdrr7x5U7NcGhjTeJCe0aD0DAflzpUN0j44JpcHxjTQHKJj04Iq6R8dl5cu9MnShnJ12VpQWyIVcMdiI4FZTIACZBYPPm+dBGYDATtYM+LFZphiffgbWqw1Az+3trbK9ddfry42dm9Os4DMNAESOz+QQtnqrgXhBdGAmiMQJJhTECeJ3LXOnj0rbW1tcsMNN0zMU7wmXnatmWQhudQ/Ks+d6pHXb2iSvtFxDSof8I9L78i43A6hMeCXjoExDSSHZeOahTVyedAvRy4NyqqmCrk8GJB1zZVyacAvBy70y92rG+Vs96g0VxVLZQnFh92fZ+xf9glQgGSfMa9AAiSQZQKJivPh8u3t7VrXAju5plkXTPGCwVPpdqatGdjN3rVrl9x0000adGz3BgGCnXEs7O3cnGIBQT+fffZZWbdundTX108LKeYmLCJGkGBuwdcdbnrGOoLv8aqzQwRfvHhRtm3bdlUxRLwe75l46X4hTpxafwQWDYiIzqExuWlpnVovzvWMvFK5PCybFlRL+8CYHL00KBvmV0pbn19/d6x9UC70jsqdqxvl8MUBFSE4T+9IQO5ePUdebh9U96yqkqld4qY10HwxCTiIAAWIgwaLXSWB2U5gOtaMo0ePaorTrVu3TuzkpsMz1pphLBlY4MWzZpiYDJPeNpFPvumT0wQIXJaw8LS7AIEIRYG/zZs3X+XaFOuCBUEF4YcYnHw09PO5556T9evXay2YTDbMU5PuF6LEpPtFALu1OjsEJVLQQrxDCMe2qeJHrMUQnZLuF6IDVo1QOCqr51ZI/0hQ9l/oVzcqCI0N86tUSFzq98tdqxrlpQv9sn5epTx/ukeDzCFY8Lt51cUqSIoKPLJlYY0c7xiS+vJCqSml+MjkPOa5nE2AAsTZ48fek8CMI5DImmH9u/XmE1kzIEBQXyHeQirewirZKuDp1s1INHBYID7//PMqmJD+0+6NAiSzI5RNARLbU1hb8N4wFhJc21Rnx/sN2bfwvknkrmU2CCarP2LNrmUndy30G9aK6tIC6R4KyLLGMjnbPSJne0Zk++o5cqCtX9bOvSI0UOfjupYa2Xe+T+ZVl6glpLGyUFY3VcrBtv5X6oGEpcDrkTVzK+XE5SGpLS2Q2rLCzE4Qno0EHE6AAsThA8juk4BTCUzHmoF7jic4pmLx8ssvay5/uJKYZrVmWC0ZsdYM7AzHExrJWjPSGSMjQG688UbNSW/35mQBgrmIuYDAbxOkvXv3buW+YsWKvKBHzY+dO3fKhg0bpLa2Nmd9MILDiBG8Z/A7iIfYdL9TdSpWjJj3rEn5a7WQ5NNdC+5VEB3r5lWppaKlrkStHqjtAYsGhEZjeZEKCVg2ljWW6+88KEgYjUp5kVeDy1882yOhsMj8mmJ121rbXCmnOoeksrhArR9sJEACVxOgAOGMIAESyBqB6VozUhUZ8W7ExGZAgGBRheJSJqUtdnZNgz98tqwZ6QAeHBzUBSgFSDr0Jn8NFvZPPfXUVS5YdhQgmJuwgCFdMNyi8tVQFbqrq0uamprUSoJ5CV5IV2pN94v3T7KCZKr4EQiTXFlH9p7r1aByBIgjbgNi4lzPqNSVF6hFY9+5Pq3TgdS55cU+WVJfJs+c6NIK6BAjyGgFQfLIkQ6pKyuU5XPK1XKyuqlCHj7SIRvnV0lTVXG+ho7XJQFbE6AAsfXwsHMk4AwC8awZWGSgmb+Zf1vvaLIq4OnctbFmxFoyrNYMnDeeyMDvsmnNSOd+4JePGABkH0LmIrs3p1hAjAC55pprJoK7MUcRA2IK+4F1vi0gdhIgEB7IxoYGRsZdC99HR0f193ATNBYSWI4SWTVM/Mhk7lqmKGI24kdQ0wOxHF6PS7YsqpHDF/vFH4xIkc+t4mJ5Y7k8c7JLCjxumVdTLP5gWK0cvzhwUZbWl8mcymLpHg7IgpoSefBQu2xZWK0uVqe7hmVOZZHsPdunsSHN1SV2f9uyfySQNwIUIHlDzwuTgLMI5NplKh6ddDNNIRAcu7idnZ1y++23OwI8BUh2hilZAfLCCy/ognr58uXZ6UiCs2JhjyxoCOrPZxrm48ePa8D6ddddF7fH4GlN92vc2KzpfiHwU40fMXVG8D3WXWs6FpKTl4dkPBzVIoEIKt91ukdC0agsrS+Vfv+41vyA0FjRUKGWkN6RoDRWFqmV49bl9eLzuKVjcExKfF6N+di2rE4KvR453gFB45ahsXFpqYNIKcrLvOFFScApBChAnDJS7CcJ5IBAssX5kBkHO5PxUtpON50tbjMZawauk0psxsmTJ7WegVMECCw5SMPqlDogqByOxaLds2DBsrBjxw5JZAHJtwCB5Q59QLaufFrAjh07plmyrr322oRPIDw/MG8RNwLrCDK54XewLlrdteKl+7WePDZ+xPyMfoAF3L+sAe0JOyYiw4GQnOoc1jocF/v96h710OF2mVtZLAtrS7VeB/796NEOuW1FgwaTdw0HNBYEouWW5fWaHetc74hWPUftj5VzyqXI55FdZ3o0vW5ZoUdKCrwyl25XyQwJj5nlBChAZvkE4O3PTgLTtWZgsYkFAPzT092NnMyagQUMdlVNs8ZmmJS2EB74SuTmYR3d06dPy/nz5ylAsjTlMScwF7BgtnMzAmTLli0T6W3juWBRgFwZRcROQQyBV6oNGwkQIbCQQJDgvY2G97Fx14KgmKo6O443dUzgFofK8HitsZCYgohGkMR7HiHWo7LYp1mr4Hq1pKFMnjzWKdcuqpbSQp9c7POrO1Zr17BsXVon4UhUWrtHdD4HQmGN6YDo2Hu2V60hCEBvrCiSYp9b/u9Qu1zXUivRqIjH41KBw0YCJJCYAAVIYkY8ggQcSSBZa4b5gLfeZKwVI/ZDPZXFJhYhJug79ru1bkYq1ox0BgRWGxRVu/POO9N5ec5fA1bPPPOMur7kMwg52RtPZU4ke85sHJesAIH7E7JPLVu2LBvdSHhOLNax4IalJp9Z0JC+GszQj+k2pPs17lr4jp/xbIEIMYIEtVfiiQhjEYKFDccjdmSq+BEIkkAoKs+e6pYFtSXSUlcqhy8OqhBB5isUD/R5XCpIkDI3FI5oEHk0IrK7tUcW1pWqm9b8mhL921PHu+TmZfXSPxrUeh6hSFSePN4pv7lxrnQNBRUNjmUjARJIjgAFSHKceBQJ2JbAdK0Z6WSa2rdvn+5KmkVJPGuGCQaPZ82ILc5XXFyckjUjncGA+IAV5K677krn5Tl/DWIAnn76aXV9yWUa1nRv1CkCxHBNZAHJtwCBuxGKIaKf+awDc+TIEUFdkExbtvDMwFhYq7NjQwIWTyNGILzhboVmBFksj8nS/V4cCEhbf0CWNpbLnMoS2XcBWa58Km4gFBBsjkDzZQ1lEgxF1XIRDIflmZPdcufKRnXTwu8uD12pev7GjXM1yByuVu39fjnfOyq/sa5JLg2MCaqnU3yk++Tg62YrAQqQ2TryvG9HEUiUzhY3Yz3G3Fyi4nypQjDWDCxKsHuJnUhj1cilNSPVfuP4s2fPCuJA7r777nRenvPXUIBkB3k8rvFcsChArvA/fPiw1kfJdmwPrBkIdjfuWkj3iwbLKAQJhAg2ECDIYSWZrAVDYXm5Y1jcEpWyArc0VhTKEyd6ZVlDqRT4fFJTVqguX8+d7pXta5u0qvmciiL9frprRF6/Ya5aRRrKCzVmxD8e1pgQ/FskKgP+kATGw3Ljklppf6VqOiwsbCRAAqkRoABJjRePJoGsEsiHNSP2hmKtGda0tlZrhnGdiE1rmwtrRjqDcO7cOUFGn+3bt6fz8py/Jp6rUM47kcIFnWYBsVqW4gkQ1OCor6+XpUuXpkAhc4diAY7UxokW3Jm7YvwzHTp0SJNCIN4rlw2ix1qd3Tx7YD2tq6tTt0RYhqxxYLBGDPpDUlnsVRcpuEo9ePiy3Lm8Rut9lPhc0j8WktaeMXnNmgZp7R2T2rJiOdvnF5fLLduW1Wsxwkg0IsNjIc1qBVetM13DmvmqobxIXbCuWVgtlwcDGoi+qK40l1h4LRKYMQQoQGbMUPJGnEIgkTUjniUD95Yta0a8+IxE1gwEc2OBjBoVTmnoMwJq77nnHkd0OV62Jjt3HAIELROxAtm8z2QtIHYRIIgBwqI7X+3gwYNqXUVF9ny2y5cvCyyvsIbAPc3UbMHPlVXVcmLQIxsX1ko4KhIMRSQqUTnQNiSvX9cg53r94nW71GKBv93QUnXFuhEMSygi4vO6tW4HBEnPaEgW1pXJgD8smxdWa6rdrqGAXN9SI8c6hmTzgmr9Xlzg0bgSNhIggfQIUICkx42vIoGEBJKxZsAtCDt48+fPnzhfJovzWa0ZsQX6rNYMpMmMV6BvMmsG3DKwCECVbqe0Cxcu6ALm3nvvdUSX49WrsHPHnSJATHC/3S0gcEcCUzsIEMy79evX53X6wTXrpZde0mcO3LFgIcLvTrf3yN4LQ7K2OipRb4EUlFaKr6RMwp4SuWNVg1zoG5O+0aAKEGS32jCvUk50DkvnYEBaakukZyQoq+eUyp7zAxIYj8jm+RVyqtsvmxZUyfNnB6S4wCs3LqmXl9oGZP28Ktl5qltKCz1ybUttXnnw4iTgdAIUIE4fQfY/rwSma81AMLepnZBuOlsAyHWmKWTGgXvETTfdlFf+qVwcNUAgnGABmQ7rVK45nWONAEHwb0NDw3ROlZPXxiYmyMlF07hIvOxi8Vywdu7cKY2NjbJkyZI0rjL9lyB9LZiiDgw2B/LVDhw4oM+odevW5asLel3UFkFftm7dqgIkEo3Ky+3D0js6LuubSqWju1eOXOiWkH9IBobHpKVCZMRdIiPuUtm8qEFGXQWyaX6V7Dnfr4UIN8+vlOOdI7J+brk8frxbmioKNU7k8KUhaakplN1nB2RRbbEsriuRg+0j0lRZLBf6AzK3qkRWNVc54hmS1wHjxUkgAQEKEE4REkiCQDxrBoIm0czfzL+tp0tkzUhl0WasGbGWDCyopmPNSOL2X3UIXJmwINi2bVs6L8/Lay5evCjwZ0cMSCr1Q/LSWRHNPPTkk09q9iEKkMyNglMECAT+/v378y5A0AdkpkL9jXy27u5ugTsYNj2Gxl0ag4G2sLZYRgJhOXhxUDbOq5C2/jFZUVcozx27KJd7B6XZMyRnBkKyqNwtZwKlsmxOlaxvaZTzQ8h8VST7LwzI2rnlUl9eqOKjosgrnUNBPe+c8gLZd75fixEWeK64ai2tL9Pnh6k7goB2fDlhUyOf48drk0AsAQoQzgkSeIVAMi5T6YiMqQDDpQDBltYqw7m2ZqQzARDMDZ/sW265JZ2X5+U1ly5d0gUMsmAlKnyWlw7GXBRZxp544gnNPoSdeLu3VMR0Pu/FVJi31lexowXECBDEWSETVL4axhWVy9esWZOvLuh1u7q65ODBQ9K4YrPUlBdpsDkExMX+MTnf55c7V9TKoUtDsmpOuew83auCYuWcMjl0cVAqPOPy4pkuqfeMStQ/JGcHI1qx3FtSLqvm1cni5no50O7XrFlFBahm7pHmyiJ56mSP1JQU6HXgxrWkrkQ3nLD5hGd3U1OTfhlBYq3OTkGS1+nCizuAAAWIAwaJXcwcgWwW50ull8aagR15BMUi244JBs+1NSOVfptjT5w4Ie3t7XLrrbem8/K8vAb9hQsH6oBgoWD3RgGSnREyAgSuTQhgNpsKCGo2gc343XPPPaeLy8WLF2enIwnOao15QCxWvhoECFyeVq9ena8u6HWPnGmTx/efkN9/3TY53x+UxvKCK+l23S65bmGVvNQ2KA1lBXKye1SFwtzKIo3bKPS4JRiJ6s+1pT559lSP+CJjMj46LMHRIfEEh2V/t8ji2iJpqquWsopKWTm/Xh482iObF1RIZZFPLg8FZXnD1W5wO3bskEWLFklzc/OEFRxCBF/GKmIVJHmFx4uTgA0JUIDYcFDYpekTyIc1I16vk7Fm4HXw8UamG1MN3BTqg+uDHdupU6cEQd233367HbsXt08dHR26a4lK6Hblau04LGOPP/64pj+dM2eO7Tk7zQJidwFiYh4QdJ1PAYJAeDyXVq1albc5eKR9SI60tkutv02aV2+RAp9XXbBqSn0qDPa3DYpHRMVIVYlPLRY7Tvaq4Kgs8kqhzy21mpK3UzbNr1B3KQSlVxR75ZcH2uWaBrdc7u6T7r5+iYaCcqzfJbe2lEtFVY0EfaWyqaXhVS5WcI9ctmyZzJs3b0LEmsrs+I5r4MsIEogRI0hoHcnbVOKFbUSAAsRGg8GupEYgXWtGptPZoh+wWsRLZ5vImoFdeWSTclIsBUYJBcFQV+OOO+5IbdDyeDRcxuDPjj4j65fdm9MECNhi4WX3NLzJWkCeffZZmTt3bt4sILFB1/mar6hFgg2RlStX5rwLg2MhOdM9KoFQWOYX+OWJvcdk6ZqNKjKwsIf4ePpkj8ZtoHBgOApLR6H8/OBluW5RlbjEJW6XSKHXrYHmr13bIH2jIXG5RMZDETlwcUh/h0xYo8GwjATD0tY9KEvKw9LV0ytnOgakqTiswiG2OjsECJhgjsQ289mE94MRJUaMMH4k59OIF7QpAQoQmw4MuxWfAFwkYq0b8A1GwG7sB0GiAPBUGePacJcyQgMLGfOztW6GSWeLXUNjycDv4u26Hzt2TH2bb7755lS7k9fjW1tbVYTAnckprbOzU7MKwWoDn3a7N8y3xx57TOsvwBXI7g0CBO+DLVu22LqrEPxwr7JaQPD8QFpXvEdNvAUECNxrWlpa8nI/1qDrfM7XF198UQv+rVixIqccIDzwrIcIQXD5I/tPy6nW8/K2e26SnpFxFR+/PNQp65vLpdjnkbFQRGM4njzRI69b16jZsaJRkeFASE53j8q9q+ulYzAggVBEhvzjWpBw6+Ia6RsJauA6LCJIK7KsvlQzbCF974qGkol0v4jJwRxBn+CShs0lzA+46CWyqFo/s0zyEmMhgbuWNaAdAoUWkpxONV4sTwQoQPIEnpdNjwAe+uYBjjPgQY2MTNaUsNN5eE/HmgGRkWoVcCfGUoA76pecPHlSA7qd0iD04E5y22236QLC7g2L+UcffVTrL8TbZbVb/+0uQEzcFeYB6sEgsxisTNhIwHfTsGmAKttIWgD3mnzFgBgBAutoPi12u3fvlqqqKlm+fHlOptxI4IrVY2FNsQoHiI8njndL1D8gge4LsnT9tVJXViDPnOqVO1bUau0OiIyx8Yic70cwer0WDhwYC0lwHFaNiFpDOocCcqHPr9YSWDvWNVfIwOi4WkFWNZVJ/+i4XhOfH2d7RmV1U/mr7hebAviswdjAem0aBBrmjBZFrKxMmGXPCBJjHcHP1viRWEGSE/C8CAnkmAAFSI6B83LTI4CdSmPeNkIjnYxMVmuGSWs7lTUjtkhfoh2vZO/SibEUuDenVRVHn7FogDsJAufz6VOf7NygAEmW1NXH4fmAKvJ4X5svWC3xb2OpxCtg6cDC0VgpYWWAdQQLTLg/QZTgGVNXV6eLy9ra2pwKVwglJKnItwB54YUX9P4R75DthpS4GL+N8yvlQNug1uF4obVf1jWXy1BPp+w+2irXX7dFM1/d0FKtQuJS/xiSoUsghNdVqDvVqa5RdcUa8IdUaOCY45eH5ZoFlZoxa01TuZzv9etxEDH4Pr+6SDoGx+Rcz5jcubJuylvF3HjmmWfUKoQ5goQBmDf4PSwaEGxghi/Ms0SbYiazlvlu3LU0VsXr1XMyfiTbs4/nzzUBCpBcE+f1pkUAD3irBQQnw048ajxgZ9vacm3NSOfGzpw5I3BnQmC0k5qpKu6Uon5gi0Ul3EmQOjifaU2THWfM80ceeUQLwMHVw+4t1xYQ8LG6Q1rr45hnBBZuRmDgO77Q4IqH9LZYKKLFpuHFz1hglpeX6/MGVcnRsBEBIYKFJV6bzXoycBlE4Uy4Z2ZqwyOdObRr1y4VYUuXLk3n5Um9Zmw8LHvO9Ut5kVcFA8RHWaFHs0+taCjVtLhPHDgtvZ0dsnHjJllaXyL+8Yim3V1SVyy9oyFZ01SmFo7TXaNyY0uVnOwa1foeR9uHVZTcvrxWDl4akpUNpXLg4qAWI7xpSY0c6xiWhvICae0eVTcu/C5Rw0YY3PhgnQQbM4cgYI0YQSFJzCMIW2v8SCJrVqy7Fn6OFz8CQUJ3rUQjxb/bmQAFiJ1Hh317FYHJBAgCopEm0hoIDotGvNiMbFkz0hkuJ7oy4T6dVtQPfcbCAO4kWNDls7J0svPECBAUgDOZdpJ9bT6Oy5YAgbUyntDA+9tYQ7FAjxUaGGO42sXuPsOPH1XOkV0K7jLxBAh+BwEyf/58TbWK5w7mD0QsviNFMsQNFpZGkGTaqmYXAfL8889rmvBsCRCIBsRmVJf4NH3uztY+KS/wSoHXrVmuygq9VwLNwwNy9mK7vOGOrRoDcrR9SG5bXisnOkdkZWOZHL40KKPBiGxbUq0CAzEie89fETKb5ldqPZB6FRp+qSz2qosVrCKIE0FcCKwoG+ZdmQ+JGixs4IIMdRCj8Ro+eyBCMF/whTmMZlz8MHcgYhPVJIp118I54sWPQJCY3yfqP/9OAnYgQAFih1FgH5ImALcEmLqtQiNRpik88LEQyeZuZdI3EHOgE12ZcAtOK+qHPmPewJ0ELi1mJzzdccvF67DwePjhh7UC9WwQICYew7hLGfcp6/sbu8nGkmFSV+PnRLvK1vFKVoA8/fTTsmDBAhUg1oZxQd8gRvBlApNhVYMYwReETaKFZaI5hKxtiFWBxS6fdWsg1lAIc8mSJYm6nNLfx8MRreMBgRCOiFo1HjzSKcsbyjRrFQQIMljtPNMn21fVy67DpyQ82Cl1S9ZrYPqty2q1+vm8qiI5cmlIqkoLZN3cchUfVcVeudQf0Fohi+tLtcI5AssRaO5xu2RFY5m83DEkfSPjsqi2RDqHg7KhuTyhq5S5QYhfWIZQJNTUkkl087Ca4BlkBAlELD6TMFeMuxbmcjLuWsZVy5ruF+fH+wDz0NQhseNnXiJO/PvsIUABMnvGekbcKXawUc/BasXAAgULYqekV7UORFtbm7pZOMmVCf13Wk0N9Bm7kVg03HTTTepaY/dmBAgqUGMn3u4NFhBYK6699tpJu4p7wsIrNjYDogMLKNNgTYgVGpNlkkuVSyoCZOHChYKvqRru2WodwX1g4We1jqTj8of32NGjRzVmabpiJlVG1uOzUZDx0sCYxmc0VRSomxXiLx460qUWDaTC9Xlcmi73fO+o3LO6QS0VfZ2X5NDZy3LdpvVqqYBFA0IFYqSmtEAW15XIlRgSUVHj9bj1dy+09qnoQIA5MmNBfDx/plfHaNO8cjnaMSwbmq/UBkm2Yf7iswgpp40VLdnX4ji8DzDnjSDBd4gJWPJi0/0mOq8RI+gPXguhaFyzrLVHMIdSucdE1+XfSWC6BChApkuQr88pAew8xfq9OtEdyEBzoiUBfXdaTQ30GX78cJvYunWrBh87oT300EPiFAGCIo+wYkCAmEBwY82wWjWwYEfDYshsJFjdp/C7bC64zTxI5IIFC0gyAsQ6j8zC0lhHcC38DoLKWEeScbvBOe0iQDKZjjgcicpjx7o01W1tWYG6XhX73HLw4pDc80qa3GAoouIkGI5ooDlcrBAjcqHtgowM9Mtvb79J9p3vl0hUNBsWzrmkvlSeOtGjrlUQM/3+kCytL5WHjnbJoppiLUyIwPWlDaV6/SV1pdJSV6IiBlm2Ul2YQ8QioQXmeiY2M0yckbGOIJYEDcLVZNeCuJjKEgZLFTK7IWubNajdfF6a+iPW6uyp3rcTnpnso3MIUIA4Z6zYUxHdYbVmsgEUpEM8cOCA1qTIp6tCOgPkREsC7tNpKW3R53g73+mMWS5fAxcsVKCGK5AdGxZOJnsckkHAugF3RwgO8z7FwidefAYWV/lwEYknRGOD0MF6x44dWgNkOuxN2lYjSIx1BCLECBKIk3gLQTzXkGIcyTXywcnMN2sszHTmICqXw2UKGa1KC7ya6lbfl2MhuXZhlXQNB1UkVBShpkdUXaKOtA/LoP+Km9ThE2ekIjIoo9VLtar5gppiDS5vqS2R/zvcKRvnlUt5kU+6h4MaVP70qV65oaVKSnweOdfr13gSCJ1N8yrUYoK+pCM+zGYGUnpfd911WXHnhJC3umvByo85YtL9QpRA+FjnRTyhOFn8iEn5a7WQ5HOOTWde8bXOJUAB4tyxm5U9jydAnFZgzjpwTu2701LagrkpQGfNfmT3N5FdBAjExGQZp6xpsWG5QLyA1X1qsgV2vthP85JcLwAAIABJREFUJUBwn2YhlgkBEmsdgVgzYsRkSYJgM2IEu9zG+gPrKAqVonBmPneq07EEWe8bsReI9UCdDsRrlBZ6ZO/5AZlTUajB33CJutTv19ofEAQX+sfUJeq5M31S5HXLyjnIbjUmkb6L8sixHnnrbZukvNCrggUWj91n+9V1C5YQWFQQ53G+b0xT7uLfp7tGxO1yyVgoLAuqi1V8IE4E18Lv02kQB3A5xLMkHfe6VK+JeWN118LnoEmCYOJHkOEP8UpTuQzGS/drMmxZU/2agPZU+8njSSAVAhQgqdDisXknEE+AmMWwU9KrWiEaS4JTalOYvjstoxT6Db9t7BJaK2DnfUIn6ADS8KLWQKI4hEzdB95fJp2tNU4DCyDTEOgaLz4Du/WJYkAy1c/pnCdfAiS2z2AFEWIECXa5TVAyBAnEEFJ051uATEeIwRoBUQDRgWrlcLd6+mSvbF1SLe0DAVlSX6LZrFAscOvianWJWjWnTN2pIDzqywrUelFZ7JOH9xyTlqIx2XzNNdI+GJBwOCp9/nEVEnDHOtU5ooHrECKoH4J/Q5zgHMUFHikt8KjL1ktt0xMfGEc8/+ByCDe+TGc/SzS3YXU06X7RD5MEAa+DhQTxYhAliVI3m40DnM8URIyX7tcEtOdTBCdiwr87kwAFiDPHbdb2Op4AcVp2I+vgmdoUTkkNa/ruRObYwYc7Cfy2scBzQoMAQQXq2ExM0+37ZIHg1oxT2JmPJzQmyzhljQGZbv+y+fp4yQiMC5bVAvLUU09pQG8uEgDg+hB5JpgdfTS1TFADxsQB5MPFNB0OuB9knoK1ISpXsk/5x8Ny+NKwvG5tg9bmgDVkf9uAxoKsmlOu4qO21KdFAZHNqrTQKye7RsTjcslIMCTugUviHx0VX+MSdbWC8QIWDbQXzvarmEFtj4ayAg1if+xYt9y4uFotLwhWh2vXrtZ+uWVZrQalT6eZKvVIaIHMbPlsRsgePHhQs2DhvY0GFy1jHUmlOvtk8SMQNNbsWhQk+Rz1mXFtCpCZMY6z5i6wQDBBrOamnRhcHLuQd0pmJiczxwIP7iRbtmyZKB5m9zfOo48+qhWo0xEgWEgg5iA24xR+ho85GhYRk2WcSnWx63QBYmoMGResdBbemZpPeM4hpgZuWBgf1J3AWJkK2xDQCNbPxSLwySef1DmYbCrovtFxeepEt9yxok6GA2FNf9s1FFQRcfPSWrV4FHjccnkooMHh86uLZe/5frVYQBbMrSySsiKvZq9qrCjSVLyN5YVy8sQxeeHCiLzllo0aN6IuXONh2XW2X+5cUadWEcSGDI+F1MXr9esbBdm2IEYC4xF56eKQvHZtg4qh6Ta71Ggx9wGxivm6cuVKFR3W+BHMa8xpa3X2ZOZObPwIfjaxI0aIWAPap8uUr599BChAZt+YO/qO4wkQJ7rWxC7krRl5nDBATgzoxu4+PqSROhOF1ZzQHnvsMd2FRzD0ZM1knIonNKyB4NaMUyYoHL/LVPApBUhmZxRSdEOEwAXLxI6YKttYcGLn3RRBxKIzVcGYbG+feOIJdQOEJSZRO9k5Iuf7/HJjS7X0+8c1IByuUi63S12lYBUZDYY1dgNWCQSSw1IBIVJW4JlwlXr0WLdsW1IjEDNwmxoaC8n/vfCyXFMflaoFK7W+R1v/mAato0YI4kdg4cDPKFKIqucXB8YkFI5qEDuyYsEa4vO4E91CUn+3S40W01lsymFzBcV458yZM3EPpmaNya6FzTrMHVhKrOl+k7HixIsfMRm2TPyIESS5EMZJDRQPsjUBChBbDw87F0sgngAxO9tOcq0x92UCo50Ul4C+O1H0wRqA3dzNmzdrukonNKsAwcJhskBw466DhcBkGaeyvSiAAIH7BzID2bkZ90Gr1RGLq1gLSKo7/5m+5wsXLsjp06c1C5a1WStsw4UTzz+MrSloB1GSTEG7ZPoLLuCAnfW5c+dO+hJYJM71jEooEtUK5AP+cTl+eUTdovr8IQ0qf/Z0jxR5PVqPYzgYVhesnx/oUKsIUu7CKoKg9H3nB+QNGxqltXtUCwoioBxipi7QLmf7ArJlw1pp6/NLVFxy3aIqFR8oaghXK1x/8/wKtYZc6h/TeiD+8YisaSpXC0umml0ylJn7wdyFe+m6deum3FzB3IEIMYIEz3E0bERY0/0mSoOdbPwIBEls2vxMjQHP43wCFCDOH8NZdQfxBIjZ2XbSwtIMmhPjEtB3028sNvHB5YSGxTF2c1G9GJma7Nqwm2mEBopUIsuOiREwH/zwx44nNBC3kW2hMRk3pMKGyHOKANm2bdtEClU7CpDz589rEDoSVEzV4J4FIWIWlWaH25pZK1FA8mTnN649SAXd1NQU9zAIAMRjQACgBseFPr9c7BvTQPOTXaOyZk6ZPPJyt6ycUyoVRT51nyr2ueT51n55/bpGDVJHTEbXYEALBSKjVWuPX+c8LCBeD6wnlfLgc/tlNBiRVSuXSyQSlXXNFXKme0QuDQSkpbZYOoeCamWBBQaWmGsWVOm/VzZeqayeyYbaU8ePH897ggBzT3jfoWDk+vXrU3IvxTPR6q6F81jFrEn3m+iZMlm6XzzHYG1BPIqxkuBcic6XybHiuexLgALEvmPDnsUhgA9E479u3f15/PHHZePGjVeZn50AEIsHZJlxklsQuJp+OymeAvPGTvME/YmXcQpsrQ0xALDYYJfSBIVPFgiezzlPAZJZ+skKEOtV8Xw0mbUgSLAANPUjjCBJxTqCDR88n2Jde3BNuDYdbh+S9c0V0tY3JnMrC+XQpSGNudg0v1JreKDS+b7zg1qPIyKidTuC4xHpHA7KzUtrVDT0jgYlEpEJ60Vrz6j+Hq5X/mBYhcbLHUPy4sHjsqjSI5XzlqhFBVXPEWMCKwjiSiA+kOEK7lo4N9y9ljWUSpHPk9mBERGre1zGT57GCWEF27Vrl34GprshZE2EAFGCL4w/rBhWd61ksn4ZQYLUwMjMtXTpUp2HeN595CMfkY9//OOajZBtdhOgAJnd4++4u48nQPCQRLAudn+mchOw480atyC778rHsnNiPAUsC3Bp2rBhw6S7uZmeI/ggnizjFMbetMkCweFWgRS8iAOxe5tpAiSV2IdsjM25c+cEX0gvnm6DmDWZtcyCEuIVi1QTPzKVdcTEFqxZs+YqqyGsHkfahzSjFSqVo9gfhAMCyBe9UmEcQmQoEJJVjeUSFZETncNS6vNIIByV9c3l0jkUUEsFRIKxXkDA9I+Oy8b5lXo+rQdyuldjN1w9rXJ+WORNN2+Qp072avYsZMs60HYlde+u1j7NugVBBPGxuK5ESgoyLz4wFumIw3THMJnXQWi+8MIL6l6KYPNMNHzWItbPWp0dzzM8q0x2LVxrqvkDUYR5BgGC88GtEJ/TP//5z+UNb3hDJrrJcziYAAWIgwdvNnY9ngDBQxEF2/AhmYuUmZnkbnblc7kozkT/neLOZL3XbApVzEGIsniB4CZrG3YArYHgxqKB75P5XMP/HnMaH+B2b04RIKaGTSIXrHwLkLNnz+qCDSm6M9Hw7IT/v6k7gkUrGnaojXUErjJW9xgTW7B27Vq1wo2Nh+VYx7AKi5uW1KiAGAmEBbHdFcU+zWj1zKleqS3xSqHPIw3lhSLRqGaqQqXyy0PjsnpOmb4OWbBwDmO9QOXyiiKvrJ17pQL6ioYSPdeS+lINVv/pU3ulubJQAuVzNc4EgesQH6hwfqk/IE2VhVoxHcII1dGzJT7ADGMDETIdcZiJMTXnQCwhrA2wSGM8s9HwHLO6axlLrbU6O/5tTWoBtzC47i1evFi7hKQKsPYjvfjdd9+djW7ynA4iQAHioMFiV0V3UWJdsMAlW/USss3cLIoRPJhMlpls9yfZ89vNnSmZfmPuYJ5MhzXOAXcHLN6s7lP42ZpxarJA8FQzTjlNgECE2d21Il4RzXgxIDNNgMS+RzBWxjqC75i/2M22WkfwGhTvxHtmzFsmw4GQukXBQnHw4qCMBsIyv6ZY628sqC6SXx7ulC0LKiUYikh1iU8G/CE52jEk96xG7Y8hFQ57zg9oTMbm+ZVakRzxG3vPDcjSxlJprixSAVFT4tPgctQHgaXjYNuAtJ46LuItlK0bVmoKXpynwO2SkkKPeD1uFR2ouI44lLJCbzKPhLSPQWwO4kAgYu3QICz37t2r8Vd49uSiGeuaESWmOrs13S/6tGDBgok04tikgKDGnEISCLbZTYACZHaPv+PufjIBAt9+pCo1Oy1OuTGnWm+yaU3I1tgZ1tjNTVTTAPcHoWEsGkZsQGiYQHD4RscTGnBRyFSQJdIGQ5iiDoPdGwqhYVEyEwRIstmfsjkmuVzkGuuIESQmOxLm98DgsESr58mm5QukrT+gLk6wTFSXeGVedbGKDKTVffJ4t7xuHWpvBKSi0CNne/3iD0Xk5iU1WmQQMR0nLg/LvJpiFQuI1ygv9EjvaEgW1hRJXVmhZsAq8rp0Fx3Ho4r5M6dhUfHJ+VMvS1lpqdxyzRp59FiXNFcWazrewUBY3a0QJzKvqljKi7IrPjDmyE6GVLxbt27N5hRI+twQAfv375cbbrhBk1bkuuH9Yq3ODkFknpOwqsGKi59hNYLlA8IE7mJss5sABcjsHn/H3b3xqY/tuJN2imP7DvcxpLmEr79TWiasCfm414ceeugqVz3s2sULBIf4MA0+8/EqgiN3fqaExmQsKEAyP0vgggR3FezEwv0NLdYCYgcBcubMGS1EmI9ddsQnQYzsOdUuFzr7ZXmlyAW/V9bMq5LTo0Vy3dJGqS4r1qxVSIF7rtcvd6+s16xToXBEekfG1QUKAeQQHyhGiDiQ6pICtZTsPNOndT9Ki7xSWnDFVQuiYlFNsVZAR/wIxMcvD3XK5gUV4nO7Zf9LB2R+fYWcCFTJtiVXanogS1ZTZZE8cbxbtiysUstILtqpU6ekq6tLUL/JDg1zGtYFCCJkwst3wwYORJGpzg7h8Yd/+Ie6SYi59Rd/8Rdy3333aTwJ2+wlQAEye8fekXc+mQBBESakVkXBLKc1BNDDx3+qYnN2uyenWW5MIPju3bvVxQTCAdYMuKGYhg/ueEIjnxmnkIEIPtTLly+32xR4VX+cYgExAgT++2a3OFaAWCtL5yuxBQQI6k3kw1UlHIlqNfFR/5iELx2VUNV8KXSF5WR7n9R7/FqdfNhVIlWVFVJQUi63rpqrhQGRUheB4Hj96qZyrWaOY+dWwU0rojVAHjzSKSsay1SgRKMidWU++cXBy1o8MBCKakrfAo9LnjzRo2l6UUQQrz144IBcDBbJ/bevk9HxiGbUQvre010jcu3CKqks9uXsPXLixAldYNvF2gcxdOjQIRWr+XxeWQfAmsIZrn0/+clP5MEHH9R0wdj4wQYONgG2b98uf/qnf5r1zZycTQ5eKGkCFCBJo+KBdiAwmQCBTykCKZGv3mkN7mOLFi1yRKYjK1tYbsAbPr52aJgb2F2LFwhujRvCBzT8lK3uU9gJz1Yl6emwgQBBZWMnCOuZKECmqn8xnXFN5rX5cvNBdqpzPX6NrVhU4ZYfPPyCrF65XKorK9TaEA2HZMfRNqlw+eVS94A0F4ek3e8VV1GZbGmpk4C3TDYurJGHjl6xaMCVCrU/Gsp8+ru7VtbJWCiicSNoiOV4w7oGuTyEdLxRjTOB+xYsKqikPhwMaazJC/sPyY1L62Xewha1uLhEJByNysKaEo03yWVDDRBkiELxWzs0u1VmB5N4GdR+9rOfyf333y+w7O7bt0+zV8LShmxZbLOPAAXI7BtzR9/xZAJk586dmv0D/v1Oa3AfQ0yCE/z8rWzx4YE+QzzlsmEOINYgntCwBoJbM04ZsfH888+rNSHXfU6Xj5MsexQg6Y5y/NflWoDgfYUgbtTN8I+HNVvVrw5clJ5zJ2TzhjUyp7ZKa3Wg/sZty2rlZNeIHvPEkUsy7h+WGhmWk51DUlckcmq0SG5aWiu11TUS8RWL2+2SlztGZPuqOukZGZfRYEiGx0LSMxqSW5bWSNdwQHqGxyUciYg/FJVrFlRK70hQzvaMSnmR74pbV+thqaypkz5PjQa+Q4BAeMDikuv28ssvqwUVWafs0OxWmR1M4hVH/NGPfiTvf//7NV7EBMtj3mXbldU6Rhi7z3/+8xqHAm6IN0Ls6Lvf/W75wAc+oJYZttwQoADJDWdeJYMErPUTzGmRAx3+pMgx7rTmpF1uK1vU1EB9imy5jsGEbyqCW8UGfoe/oSF97WQZp+J9qGW7z5mee6gDUl9frzFCdm9OESDd3d2yZ88eTaE6mQuWKcCXTwtILuMM4M7UPhBQF6nzvX5Z3lgqvzp0WTbMKZTde1+SLRvXy5irQDoGg3Lnilo5cHFI5lcVyUuaxapEixAita7PFZEj57tlfqFfevr65PJwSFxuj/iKy2Xr8kZxF5VL52hE3a+Q0nf9vEq1chy/PKzZsCBOkIYX35FlC5myLg8GpKWuRJ58dqdcjlbJW29apa9Byl5YV/LRjhw5ogtsuwRS260yO8YEm0TY8LEWR3zggQfkwx/+sGayzJfFGZkQv/rVr6r7HDb+8F6HWxjE0Wtf+1r55S9/mY8pNSuvSQEyK4fd2TcdT4AgqBQPNBT0c1rDIrOurs5x7mNIU5qJInkw1VuFhklxi0Bwk0kFPsTxhAbiNlLZPXNatjQnzQ2nCZBbb711Igg2NgZkqgrguXq+oGYC4lWQ2ShbDff9fGufFHo9srqpTE51jmja2z3nBtRacfZyv+w/cEDmLFou5WVlGugNYVCAAHD/uAqW2tICtYogmBwuURAkiO1Ait1Kb0g6uvukIjIk7b1Dcm5IZHVjsYQKK+X6pXOkL+yTs71jcvOSajneOSJrmspVyFzsH1NXLVhkUNsDlpBHn98vb9g0X6SiUcoL8yc+MBaHDx/WRbRdPm9QLwYWs9tuuy1bUyXl88YrjvhP//RPan3A31JNSZ5yB1J8wR//8R8L+nfs2DFHuLymeHu2PJwCxJbDwk5NRSCeAIE/KT5MUeTIaQ27L9XV1bJ69WpHdT3VzGP4wI6XccoUtMLNw/wdGwiOnzMVWJkp0ZSrgXJSbBMECERjNhfMmeBuLCBOECDwj89WoDMqjkNMIK4DtTOw2EdmKfz+moVXLBOtl/vk5PFjsmHtGtmypFF2n+0Tj8ulaXeLkL2qrFAeO9YtKxpLBSEdDWUFEgiFNa5j25IaudA3JkvqS6S1e0TOobJ5bVR2n+qUquigHOsZF5fLIzcurpauSKlsbGmU4z1BFTcQOqgbAgsHLDIQNsELh8VdOUeWtSy4UuAwjw1zHZ83KCBrh3bu3DnBl10KI4IJYmRgabQWR/zbv/1b+frXv67C2m4CBFaRj3/84xqPkq33nB3mip36QAFip9FgX5IigIxGZmfcvOCll17SHSm7BAUmdSOvHAQzNXKlOy1+BYGEyBBkzdBkYnRi4zOw42UVjnCXi5dxCpaObLZURVM2+5LMuSFAkLXLCeIUWXgwznYXIMgYBP/vqQSICaAFdyQByEfLZqalU12oYB7S6uVzK4vkudO90lhRqOlyl9SVajar1p5RmV8alZ37Dslb77hOdl7wy7yqIo27QCwIXKAgPu5eWSedw0G1hHQMjqlgQOFBFBRcWF2sblpF3iuiQgVPRaFWUy9xh6TW45cXT3dKJDAifWNRqasokg0L66UnUiJlZeWCQA+XuGTN3HL574eflsUL58nmlVeqauezIeUtFtAo0GiHlsuaMcneb39/vwaaYzFv0l1/8YtflB/84AdaxDEVy3Wy10zlOGyWmKKyyI74wQ9+UAtxwvWR6YFTIZn+sRQg6bPjK/NEIJ4AccriJx4yJ8avQGggdqWyslIzSlkrg5uMU/iAsQaC49/GjQqxG/loTqqrAT5Oso455T1oBAjcVUzNhFgXrHgZfHI9X5FpCQXdUN06U21oLKTuTFXFPhmPRKW5qlAePNwlN7ZUSc/o+CvVxIdkNBjWQPCDZ7uk/9zLMli1RG5ZASEW1exVqHR+tGNYXre2QSuWo/I4zotgc6TEhfWi2OdRQQIrxrKGMq0Hgr+HwlEtFojigQfaBjVlL5JYDQwMSkV0WPac6dLMV3NL3RIuLJfrljSK31Mqhw8ekC2rl2hRu3w3FP3DYtUum0a5TliQDH9Y77AxiFopZkH/53/+5/KrX/1K3cXyLUA+97nPqTuYaRBK3/nOdxwZR5rMeNjxGAoQO44K+zQlgXgCBEGB+LC2S2XaVIYQ8Sv4MEOwnt0agr3NLpHVfQqCw5pxarJAcLuZ2Z1UVwNzAdndIPLWrFljt6nxqv5QgGR2iDItQGB9wMIf8RNIi1vic2tBwDesb5QTnSMaSL7vwqA0lBfI0vpSjcVwjfvlod1H5P7t10rYXSCDfmSwCstQIKQuVq09fk2bCxFR5HPLqjnlavlA2tyKYq/W6cC5XjjbL163SwsFIvh8SX2pPH2qV0oL3LKkrkRT8KI2yFMne7RAYUulW/ae7pA617DsPjcgdYVRqSkS3exA3Bm+52sTA6MMCxoW1XaxTOYiXijV2W1qk6COjcks9bGPfUyfaXhW5FuAoM4OvuAOBtdcuNX95V/+pa3iaFJl7rTjKUCcNmLsr8QTIEitB99uFDZyWsOHGR7G+cyoAjEBoWFcp4zYgNAw7m4I8rcKDVS3RewK3BDy/WGS7Jg7Ka0tBUiyo5racclYQGDFQwIA7HA3NDSkdoEMHY1gWKQrna5bKQTDs6d6ZHljmQqQvpGgjIWi0j44JnetqJNjl0fE5xZpHwzKwpoiaawoUmtFodctl3v7Jdh+StZs3CyXRqJqOYGA2DivQtPwXh4IyKK6EoFlBYUHnz/TKx63W5bWl0j3yLgsbyiVR17u0hiTORVFGlcCy8evD3fK2uZyTaF7qX9MFtYWy1MnejQQHi5hsK601BRrLElzRYFUe8Y08BvPIFinsLGBZw/cE1H/yWQzyxD6hKdBbAMsunapO5VpsZoQQBIHxKtNAjeno0ePamyI3drXvvY1+eQnP6kV5e0yrnZjlOn+UIBkmijPl3UCWByYNKzmYvCXRk5v+HU7rcGcDwGQi5zy+PCOFwgO8WEaAr7jxWdgF8sqNJwYu+KktLYYDycxdooFpLOzU33Tp3LBsoMAyUStCcRjnOsdleUNZeLzuNRdCpYIuF9tWVCpC33U40AsCLJYwUKx41SPpthFmcCS6Ji8uP+QFM5dLjcta9ACgRAfe871qysW/o3frZpTpkUGlzeUSH1ZocaQQEg8daJbrm+pviJmhoJSWeSVF8/3y81LatQ6giB1pORFTMqmeRUqkI60D0t5oUfFSnN1kcyrKtbnPdwnkY4a9Z7g3oOda8QZYIME1ggIEQgSCJNsW0cQMwDLpF0KhGZirmT6czNebZL3vve90tHRoeLebg2CCfFen/70p+VLX/qS3bo3I/tDATIjh3Vm31Q8AYLAMaQivP322x1389hxQYB2Jn29YSWKFwg+NjY2wQf+7/GERrIZp5AtBLuAdgnETGbgnZRVyokCBHMOPt92bkaA4FlhXENiY0CcLkACoYjW1oDYgJWh0OOSF88PqEWib3RcNsyrkBda+8XtFk2lGwhFpb7MJ78+0iW3LqvROhwQI4daO2TPkZPyB6+7UY51BzVN7o6TPTK/ulgW1RbL6a5RPW732X65vqVKs2jBolHgdavYuaGlSt2zkFYXqXkH/OOytrlCPC5Rty8cj+KD86qLpbLYp1m24IKFmBKf163XQZssLTI2VPr6+iYECZ5vsI7ARctqHcm0hRbPPggeuxSPtVtdEoxZvNok9913n37WoRaH3drZs2e1phWKEX7zm9+0W/dmZH8oQGbksM7sm4onQJAFBIFtd911l+NuPt2dYyya8DCPJzQgQNDwwTtZxqnpFoJC8DxEjF1SUSYz8E4K6sb9OEnkwUUGLkMzQYDg/QOxCnGNQpD5aHBVQYrqVFOLt/X7ZSQQ1hgPLOLHQxE5eHFIbl9RK8cvj8i65nJ59OVujb1ARquRYFjcLlF3p99c3yinuv1SU+LVY4OjQxLpPC1lLetlXk2p/g7WDogaI3D6/eOyek65eD0uOXF5WAq8HhkPRzTOA9XKEXsC1y0EoCPOBKLj+TN9Ws0cAgnZtNAPWFBWNpaq+ICAWlBzRXygJZMUAM9DWHJhGYGFBNYRWE7wjLJaR6b73DMbA5gXS5cuzcfUeNU18RkCRnapS4IOwkUXn8tWr4Q3v/nN+nn0i1/8Im/csAERz63yE5/4hHzlK1+R733ve3L//ffnrX+z6cIUILNptGfIvcYTIMiBDp/pe+65x3F3mSiAHh+sWIjECg38bA0Et2acMrEa+F22AsHtHDw/2SRwUlC3ESDwb1+/fr3t57VTBAhcLeD2OJUFxA4CJNVdbSz6Hz/WLdcuqhL/OESFS6uIo67HrctrNeMU3KL2XRjQTFVosEgMB8LSOxKU25bXyunuUQmHI9LvD0lNqU8qZVR+vvOwbNqwQbw+r1o7akoKZFdrn4oQuHXVlxWoixUKGi6uK9UUvY3lBeJyiTx9slfT7yJGBMchi9ZTJ3vl9uW1aomB+xWC1yGIUPjQPx7RIHcUH7Q2Y5FKRRDi2Wi1juAZig0ZWEeMIMHzMR3rCDYympqaZPHi/KcEBidY0XEfdnpOwKIArwRrXOa9996r1cd//OMf5+159qY3vUlFKlwwkVENQvXhhx8WFKndtm2bIFV7JkRq3m7QQRemAHHQYLGr//9umFl4GyZtbW0apAgBks4HSj7Zwn8XD0Rk8LJWBLcGgpuYF/g2T5ZxKtf3bYfg+VTHzUkxFbg3J6VodpoAueOOOyYKXMa6YDlNgCDd7b7zA3LTkhoVFKPBkPSOjKswgLsVKpWjwN9QMCwrGko1vuNU16haSQLhiGyNiUNqAAAgAElEQVSeX6lB5T3D4yoeUFRwWX2J/OzFM9Lffk5u37pFCgsKpK70ipsWUvQGw1EtSAjXKmTTgqhA7AeyaEH0HLg4JK9d26D1RFAjpGc4KC9fHpbXr2vUWiHoG7JpwarymjX12l/8jErqsQ2WXiz6scCuq6tL9W2vx1utIxAmeKbCBQ9iBF+IHUl24QnrWHNzs7rs2KFBUKPvdnKHRYYpxIEgC5ZpWPSjj7Ay5KtB/OD6yHqFhBSYA4gtetvb3iYf+tCHJtwy89W/2XRdCpDZNNoz5F5hao4VIJcuXdIHyt133531AMTpYkTfrYHgCMoz1cBNximk5Y0nNOBOkGuhMdn9OrH6PFyanGJRAHcEu+ID0glubjNJgGRiwTvd5wR4Yud/KrcaxFeggjkW7qvnlKk71bkevwZzw60K7lJId4vg7+ICj9bkwDNm7/kBWd9coYIBAuXFcwMai4HjO4eCmsXqF4c6paVkXE6dOqnxaUU+rzxzuk9ev65BLg4ENJ1v9zAKFvrlNWsaNJAcrlSoB4LUvLcuq5PTXSNq5WgfGJPRYES2LUV1dL+6aCH4fTgYlusXVas1BKmBkSErXkNsB6yXeB9ALEy34RmMnW/jrgVxgucqAsuNIJnKOoJsekgHjC87NGwG4bPBTum6Y1MDY97BPRPV2r/1rW/ZARv7kGcCFCB5HgBePnUC8QSIcauw7mqmfubMvgKLh3gZp4zYwNWwuISLFHZckVHFBIUnGwie2R6ndjYnVp93kkXBCBDMBTvWiImdLU4RIBD8mLtYCJlkDYhdgfUR7z/49mMDAAve6ey4p/ZuevXRifz6O4cCKhaQTQrVxbGIP909ImvnVqhLFeIpfnmoUzbMK5eouFQw9I8G5WTXqNy1sk4OXxqStXPLNf0tgr2bKq9kr6op8clzp/tk++p6OXX+khw7flJWbbhGLg0GZPuqejnX61f3rq6hgGbTuqGlWgPO4bo1GAhrf5AdC7+DEMHPKFyI310cGJOLfVeKE0JwrGuu0Noi6DtiRiZreGbCeon3AYLLM91wfogRfBnrCN53VusI5oRpyMi1ZIk9iiKiT3ZLC4w+xaYGhgDB+L3xjW8UpLxlIwEKEM4BxxGIJ0Di5fbPxY3hoWoWMaYauBEd2EU1bbJAcHyoIXgeMSwQT05q2cjele37d1rcipP6a1cBgt1uvDchMvDexCJzcHDwqqmG9yd2kPF7HI/FJ97XixYt0l3ubKd1jTfvIUDQl1jxCdeho+3DUldeIENjYV3Mt76y2Ee8BVyemisL5fHjPXLP6npNZwsrBCwTqEJ+4+JqealtUOM5IEJgCcHfEbwOd6rLQwG5saVa40BOnLskJ0+3ypr1GzWd7vm+MekZCUoRgtsjUdnQXKFWjo6hgKbuxWtwPgSoQ8zAKtPWP6biAxYSpN29dmGlxpogoxZECMQHihVO1TB+2DxArSTEcGSzgTmK2hpBYqwjSP9rBAnel8uXL9d4Bjs0u6UFBpPY1MD4rISr03ve8x6mubXDpLFBHyhAbDAI7EJqBOIJEHxY4EMBAW8wnWe64eEJN4B4Gadg6UCDCd8aCI5/GzeqqRYwTs3gBZc3fDjfcMMNmcadtfNhjsBX2k7ZYqa6WSf1FwIEC3jEMuWjYWFuNgGM2MD71VrjBiIDoh9/RxVruNzgfYr3J97HeLbgHmBRhf86mil6h9gDLEBxjlw0vL/w3LG638HlCYHd966pl/aBgJQWeuVYx5CKEFgQkBYXsRUQJAgqbx8MiD8Ylr7RoNb6gCDY3zao2aeC4YgsrC5W1yxkyUI2Krh0LW8slUF/SI5dHpai0KAcOt4q73nDbSoacM01TRAVAdnQXK7nQtXzzQuuxJBAkCBAHf2GGILAgfhAmt5IVDQtL2JD0A9UTEdw+i3LErtUYRyxyEZGMIxZLhusI6buCKwjxv0XggRBzLDIWK0jueybuZbd0gKjX3geQMSbAruYExD0H/3oR+Uzn/lMPjDxmjYjQAFiswFhdxITwAcAFgrWBn9ePIQR8FZeXp74JJMcgUUMFixmIWP9bs04NVkgeDoZp5AtBIUUt2/fnna/8/FCu+54T8UCvtIYI6cIELhWYHHshP7mSoCY96jZDMB3CAq8b00MFVwbjTsjvuOZgO8Qn8YF684775xYOMYGoZuYA7hF4n3f3d2tu+I4DueBGMEXzputmCwIEDS4geG6qJuB+IlbltaqVQGB5gg4hyUDXwcuDkqJz6OZpNY3l2sGLBxXW+YTl7i0BojGgxT7VGyg8GBpgVt2nOqTTfMrpG9kXFrqSjReA2Jj25JqefbwWXH3nZfyJZskEhHZsrBShcP6ueXy5IkeaSwvlBWviIlVjVfiTZA+FxYN9AexJAiOR/YtVGJHSt6myiK1mhT5PCpOkmkYX4hxFGvFwj9fDXMPYgRjgzlmrNxW60g258Rk9w13wcbGRnULs0uLFdCYwyj094UvfEE+9rH/j733gI7jus++HwCL3jsIgiRIACTYqyQWkSJFUZZsyUWyE9tx4iR28n5xjWM7efO+iXPSHH8pdvw5LnHsOHHixI6rJBdJlERRIiX23gmCRCGI3utiAXzn94eGXq0WxAJYALvkXh0cUuDszJ07szP3uf+nfDJUuhnpxyyOQASAzOLgRw49uRHwB0B4QeGSwmp8ICV69sGExV9Fw5nEMFnxBzSgawRz0oFfOp7/WBSGU6PPrAh6u5yEev/DTTgfTk5j49lJT/TecOynvasZzvfV26zBARfegONWGioqG9AHyQxyXI98AYijOfAWPVMhYfIJGKHiyiIIK98OGJmIi1IgY+FYqy4oW2quUbhOUX2obutTI25TaaOZGkzuX7jYrCX5KWZhW5KbZJUQqiVoLJq63JZQ/tSZJq0pSjX9Bp/zDA/raFWH3rwiz8BNcVaiJaOTcL5pYYbRtJIH2/XzY5V6eOtdVmE5fb1TRRkJ9m/L5qQoL3WUxpWdjPi8T2V5ycpPi7d/B+RArwIcoTHhs2SBkA1CH8oLUgIZBtuGqhRgHDE813k2m3cmCdUYpzrCn7xXuCecEET+nAk9X6i5cnF90FmxeOI4czE2fEe+/OUv60Mf+tBsXsLIsUNkBCIAJEQuRKQbgY+APwBCpeLll1+2F5S3SJGXhT8huDctgxeEv0RwVriCCTTGOkPHQpgKyGQqKIGPXHC3dOyD8U4Pl4ZdJfcPK6nh0O4EAOJNb/QFG479tLMY4F3N4O9OkvlEruVEAMhYomf6xaQYMMKPoxNgggVNC1DCQsVUGhO4Gz3SsqVLjKoEsGASD0DAShfBN4JxwMeupTmqbu23CsaR6narbpTnp5hgHABAejkC8ra+QcVERZl4vblnQDuX5OrcjS5zr6Lqwf5wwqJ6QXjg8cs1Gm6/obc/eJ9VL+JiotTnGTYQkpMSb9WNBFeUYmKi7bMcC0teBO+piThxRVnSOrQs0s8XZCdZyjrHmEijws3iwT333DMtFNuJ9GUsi2buCapkDiDhvUOjOuIAEv4+He+UUHPl4rx9nbn4jlAB+dd//VfTgURaZAQiACRyD4TdCPgDIEwGKEPPnz/fHvAO6IBK4TS42/4qGjOxQnWrQXYshL1XZMPhouByAlceN6HpbKQr/+xMvfHa4bdvWpSlB5flWWLyRFu4OXeFU8VmvAoIQAPKii91yjtQ08m5cRYEnOpGMBcDggFAfO87J2MCMMJkmXNFW+KAEVbKJzLxJEfjRy8d16qCRCXmFdsknqA/Jv5UPjr6PHYMdBpvXp5nVryAiPM3ulSck6SCtARdbe6RKybaxOVbFmXZxB/Rd++AB8GaZXlcqO/WgGfITic1IVYLsxPNkpdUc+hcnS0N6mmqlQpXWJWDqgbfQSofuy80aX5mov2OcyPl/OdnG7U4L8X6ggMWgYLPnG+y/rMtAnnE5xNtVFpZPKDCjY32bLZALZrZzrH5BZQ4FTPAiANIgvXuCTVXLq4PlDm+x0uXLrXLxRigAfnv//5vvfvd757NSxg5doiMQASAhMiFiHQj8BGg2kHVwFufwaqU03hB+atoBBoyFXhPgrOlw0kPJQvhQM4M3QqTufvuuy+QzSe1zf8cua6v77tmVp2IZpno4NjDxOZz71hu1I6JtHBz7gpXAML30beawf872i0qfd6UKefvwaY3+rs3/AF+XwoWgAJN2WRsXzlHb6oW1C2HluMI2W/1LLrc2GMuUnMGr+t6b7RWL11soYHLClMUHxNt7lIDnmHL/NiyKFMXGnrkGRq29PO5GYk2+Sf1nCwQvjNUG6BCYYuLXS/ZG4jFCSdkPwADPksGx+4LzQYkCA4k0XywvV7fP1yj9+66y6oZpJtT6fjp6QYTuVONGRoZsZyRZ883a+eSbHmGZUAHwIJgfuOiDCXHuWwBYXnhxMGHM3ll8YAcialWlibyvPC37WQsgZ2KmQNI+C4Y6EtNvemsxd8nUwHn3iW9G70S4Yih0nAtoyKIWxiNdzbGDz/5yU/MijfSIiMQASCReyDsRqCxsdEsGb0dp3gpYVsJ3zSUHsKBDC7nw0STlNiZctgJpF/jbUPQFC+VHTt2jLfppP79WHW7Pv3DM2rtHbRJFSuv2IQSutY/OKT18zP0tfeuMV55oA1hJBMIqBzh0EKdMuZk3TChQsvE2FLFcBYEHGc4X50GiwQTqQgE81r5Cy0dC4Ag/mcSNdnGfh2qFpNPqj1O4J2jHXFW9NFvXG7sNmE5Vrk/efGwhqPjtGhRsQrTE+3+P1PXadQn7n8E3LhQDXqGrSIR64pSTnKc2e+uLEy9mSqOcB0x+t1mf9tn7lV7LrfYtoCPpm63irMT9dSpBjsuQANgkhQXrR++ekmlsW1auvZuDY+MWNXlSFWnhRE297gNgJDxAQh6cGmOAQ+qM7hpccwN89MVGxNlAIrMkck2Kkt8d9GbTYZ2N9nj+vtcMCyB+X44Nr9OdQRQ6q0dCfQ8ATdUQKg0zJkzJ5inOqV9kdtCpk5paantp6KiwhyxnnnmmbAzXJnSQEQ+POYIRABI5OYIuxGAgsXEx3sCw4uRB9uKFStCxps90IHl5YrAEirTbNMLAu0z2013fslnnjqvn52uV2ZSnOJc0a/rGlkEibHR+vvHV5rdZ6ANkMoEIlysg0OFMuZoqRzHKYdG5bgA8V10rKbJzXAAB/fzZFZ1A72ek9luJgGIb/+ghDoidifwjjFyx6UrMTVd0fFJWlOUrsNV7aq4fMmoVCuWLTHb3EPXOnR3cYY5YQE+cKHCfhfwQbI4AGX/FSx686zaQJUQ3QYNuhXuVaU5SZZmDkChQkI1JTk+RsdrOvXAkmx1DQyZkB3r3pr2Pi2K69a5q9e1cu16dREY2OfRlpIstXS71drrtlwRKjHr5qXbn2SN0NdhyUTtOF1RzSEbZCqNnCe+u+jNgkVbmmx/gm0J7IBUpzriZNRQFXRyR9COjPU98hbF44QVKg1hfGFhoRYtWmRdAkBy/dBqhpNuMFTG83bsRwSA3I5X9TY/J1Z8nOwN71MFgLAKhA4knBorYHjc81CebYeXiYzbdOeXPPbPB20ihW3nGyZyg0PqGRjSh7cv1G9sDPx6h5t18EwDEMC9t0bDARzeWipviqMjCqcaeeHChbBwRQsEgDir3FOtgNzq+8RY32hs0vGrTXL1t+l6p0clGS5VDCRrWVG2OpoblJycpIJ5C81h6oHybMvrwGnqxcstWluUbpP9UTqWxwTnDy0b1YNkJLoElQtHKtyrqJxAk6pq7TeLXrQhNa29ls1B1YIcD75P19v7zKUKx63VVFjOV+jMtQZt3rDGgAmuWtC5cM3CfatnwGP2ugCWI9Ud1jf6k58aZ1RJXLWw7J1qtYsqMd9dcp5mO3PDceS66667pmT5Pta9QXXE21mLdx3VEcfgAFDiXR0ZSxQ/kWf5dGzrK4znHYfO0bFTno5jRvYZXiMQASDhdb0ivZU0FgDZvXu3lXsXLlwYVuMUrAyTmT5p8kugYe3atWtaDv3Orx9SRWOP5qS/0Y2MCQ+89Y9uX6Rfu2dewMcfTygd8I5maMPp0qw4oX2+Og3f0D5/FrdjhWqGiy3z9evXbTXd23XOl4IVDJrNeLcImgxE4w8vz7VwvgyXRy+ev6GiuB61d/aMgoMhl/Lz87R92VxVtA0pMznOtBxQm5joUwnkuwAViuoIwABK1MDQsFGs0EgRApgSH2PdKcxIUFxMtOk/clPjNTQ8rEU5ySZMpw9leUlq7fWY3W9T14CeO16hXHVoTtlKE49fb++3igZVEEARzlwkrQOM7l+Sbf/Ocdnv2Rvd2lqaNWXwQb/RyXF/oTebjVR672uJ0xUOTzPhyMV9yXfUoWs51RHH4MABI+iVvC2jx7v3ZuLffYXxAJJHHnlEPIPRgkRaZAQiACRyD4TdCPBQ9hadOyfwwgsvCPpHKIUxBTK4joMXAsuZTvkNpH9jbVNVVWWr3m9605umspsxP/u5py/ph8frjCoClcNpXH8mPSkJLn353au0bE7g9I5wmSQ75woAofowWc2Kd2ifbzq4v9A+b8AxUdOGcBnb2QYgiLtP1Xaq2+3R1pIss7yNd8XYhJ+qA1SmmuYuXbh4UfHRI8qPH9KFtmGlJMYpPT1DKxbkKiU1XRcbe63S0Ds4KipnP/3uIQMZQyMyfQcOVIQBuqKjza0qJlraV9FqTnKNXQPmToUlL6Di/iU55qqFfS9/kh8yP6ZNh6406l0PbLK8D5ytSC6HzrUwO8k+h+YDQTrhgmi1Grrcqmrt1ZuW5gYFfPBdwOwC2290crNN6ZtNRy4ni8aha/EeBJBRTSOVnZ9Q0BH6E8bDUHjXu94lKue4YUVaZAQiACRyD4TdCIwFQFhxgXPquG6Ey4lBc4EvyyRzKoLXmT7fmpoaW80CgEyVYuGv70xuPva9UzZRIlcgMS7GxK1kIoxoRNtKc/R3jy+f0LHDLbskUNE83wnvYE0HbLCS7wAN77wb7zyNYFFabicAEmyev3N/o7lo6Ow3MwWoUAeudSgpNtpsb3GwgubEfY8j1ZETp7W8ME1XhzKV5fKop6tDnu42dfS5Vdsbo43FGeqJSdG2ZUV6tbrb3KmgRUGpyk+L0y/ONGpneY7a+zxKiYux7w2UqLesyDPR+Nz0ePsTp6x7S7IsYwQxOg5ayfEurZ2Xrp8dOKtYd4eSCpdYgjoULCc3hHDE+Nho06xQlYG6hVtd/9Cw7l6QMaHv5XjPLmhzLHZgeDEdz5rxju/970z+WRjYvHnzrE72+V5znwLOMANxGtURR8xOKO9sADYA0d69e63SQfYH7YknntCv//qvWzUrlLQqE7n2kW2DOwIRABLc8YzsbQZGYCwAgrgN143y8vIZ6EXwDsHEkfI0nGJK6uHSZiJAcc/FJv3d7gq197rV7xk2hx5C1pgI/cWjS5WVHDeh4WISg6AVLnk4NAAI94cjmnfSwX11Gvy/E9oHoPC1uKWyMd3i3XABIP7uW8YOMS9/MmELNgDBQcqyOhJdaux2W8Xi6XOj1Qkm1ICHGx39qu903xSat147q5Md8fqVLctMHJ6e6FJ1a6/q27q1OGVQB680KmOkR2fbZJSpOblZciWlKzU5SafqRoEGTlS4UNW195tz1r2l2QZwyPhAzJ6eFGvUKqobmDpQWUTY7qSeX6+tUXN7hzauW63S3GTLDeF7mOCKNlesZXNSVdnUY+dECCH6EKo4fE+D2ahaYfs9XY57E+lrKDly0W9Hk4JeiQqJQ9dyqiMsajmAZKYsjOkH72NMYfLy8mx4v/vd7+p3f/d3rb88jyItMgIRABK5B8JuBMYCIPv377cKQrjxS6HYUL1Zv369Aahwaf7EvNPRdxx3nj3fqMrmHiW4YrS5JEt3F2cqZgL2u06/Zio8carj4IT2Oa5dAFMHdLC6SHNC+3x1GsEM7ZvIeYQbAPGu3E0nACEQsLl7UCvnphq1CScq8jbuK8u26kRaQoyBEyp8ywpSLawPwfj39x7XA4szlZy3QHGuKFW19Jlj1crCUboVQvOKhi7NT/LYpLOyoV2Dg0NyR8dqW1muBuPSNBKXpGFF2XcF0AP4gOIFgOB3S/JHU8+x8oU+RQN84MJFmaa/7Yaa2jr12P0bLWHd4xm2z9R1DhhwwWWL0MQNC9J1saFnWsAHfaLaiuseFKzZbqEkiGcs/KXEO9URR8yOboXfYSDBswRAQnVkuvQ0/sIav/Wtb+njH/+40aeDVXWd7XshcvypjUAEgExt/CKfnqURcOw/vQ+PEI/yM1kg4dR4IKNfYQUrnErTToDizp07w+aFMhPhiRO59xww7Wtvy/87oX3sDxtOb9oUf4frPdt0FO9zBYAw4Ql1i02nAnIrAAKFzXHrYewn07i2R6s7zCwBzQUUJyb5gJDtZdmq6xiwAEFoWXMzEy0A8FJDt1GZsLuNab5sICIzb648IzJQguj74LV2qwKyf0TmVBtO13UqO8mlxtZO5bl6dbG2STXtbhUmRys6MVX3lBWopj9ew4o2pyqydQASey+3KC3eZdSr5p5B+7dnzzcZlWteZoIOnLqorOg+tacutP5BDbvSRJr56GehZWEJfKK206x2J7MoEMjYkjGDdmA6Q08D6QfbhJIgnv7wnRsvpNEJx3QACe9PKn3e1ZFgWsA7QZ7eLnJf+cpX9Gd/9mdW0Z0NWlig1zey3cyNQASAzNxYR44UxBHwB0Cw+YNmQnpxODVeDs8995y5mIRSkNR4Y9jQ0CCC8sIpwR3XLugcs7GSCtD0pk45Og3HUhow4U2dorJBlYkXNnzzUG/hoq+ZCQDS2uO28D00EivmpOpIVbvZ0jpWtvWd/WrodJs7FWYKTPhfrWy1TI/R9PJUPbXngDxxqdq8skT9nhGV5SaZqLw4K8lycRCVA0JwuSJAsLqt7yadqqNvUCvz4nSkol650d16qbJDabEj5njliU/XupI52ldDKGGaMl4TjgMw9lxsNgpYYpzLaFud9VU6VN2pd25fa3k8AKSizEQdrWo3+11ACuADSiSWwNPVMLzgh6yk2W6hJIhnLCZKCeOeQRvmgBEqKPwOepZTHQGYTKU64o/C+PnPf15f+MIX7LgRADLbd3FoHD8CQELjOkR6McERYDLniGudj2KNyCSOtNVwatA/nn322bBLcQ/HBHfSeKFzTCeXHEDpa2/LC9k7tI9Kna9Ow19oXzjZBocLAHHMEx566KGbjwlfCtZkKyA8ky43IcgmIXxE5QUp2n2hyUIBh4dH7M+Kph6jLVFt6Bsc1py0eAMWmxdlqqFzwH4PLerM2XNauyBbyblF5lb1szON5jaFyBxThqbuAaNlkUCO5qM8P1mvVraZLmrZnBSzwS3OStCrV9u1LD9Rnt5Ona9p1mBPhyraPFqV51J2VrY88WnKykhXdbtb9xSPhnqiD6GacfRshQoTPdp81zqdq+8yCmTXgEdFGQmm+aCfULFisdeaxkb1g4WDUKiu0Q+onKEgiGfIp0oJ43mFs5cDSKAEAxCgaDmAhGfTRKqt/rJS/vqv/1r//u//bosqE9nXNN5WkV3P8ghEAMgsX4DI4Sc3Av4ACKvx8OM3bNgwuZ3O0qecFPfly5ebjWK4NCfBHVrETIkbpzo2wUxv58XNSqIv2PAN7fPVaAA+Al0BjACQqV7xN34+EAAymbA5jBJq2wdsco74m0yNJ081mL0tVrfzMxN0uLrDqFTzsxLNvjYuJkpHqjr06CoCBHs0PytBB6+2qygzQXWXTms4MVPlpQt0rKZTDy/LNdoW1Y+a1j6NSNq4MNN0GIjYqbhAkSI3B5tcaFpY4i4tSFFibIwuN/UImICV7tzEYbW1tep0dbMGB/o1pCgtLcxQbk626t3xykxJNGeujhtVih4aUH96sWlO0hJj7fiAJnJDlhWk2P9Pd6usrDS3py1btkz3ocbdPxU0FjJmo4rqr3PBpIQ5bnqOkN2pjkD3dFLZA6mO+LMq/pM/+RM9+eST4lpGAMi4t9kdsUEEgNwRl/n2O0l/ACRQy9JQHA0qIEuWLLEck3BpvKTgyeMoxaQ6HBovP1ZT0a0E2gC1AA1fnUZfX9/NXQDAnIqGAzgYk6nQGNh5uAi76evtVAGZKAAh2K97YMjE2IRnZiXH6nBVhx5ZkWfAAKE5FYmy/GTTXDQTIDg4LAwWdizONntchOE1bf1anJdkE/0nXjhgYuHkrHyjWAE+oFYROohjFQ5UVCCorFCtQF8yJz1BB662KS0+RrGuaOWmxBv16/C1NuWlJQiWFJULtj9wtd0AS3dvr1zubrW3tmj/tU4tSBlRXEKi5uVna6ivS69cH9RjW1dZlWNoZERFGVj1dqi8IFXxMwA+uLdYOIDyGQpUxFDSozA2jkXxdGSk8OwDTDiAhMUVwINTHQGU+KuO+LMq/tSnPmXOWCyqRABIoG+f23u7CAC5va/vbXt2/gDImTNnbDWaQL9wa2hACFAMpxR3XkwHDx40WgST73BogA8mMw888MAbuuukg/vqNHzTwX11GgCNiYb2BTpW4TKpDycAwgQSYHcrClagAIRqAqGC6DgW5yWbm1VMlNTS67EUcMAImg60Hwi9CRzkd0zc3cMjWj8vTWdudKvP7bEqRXZKnFVIqJTUV55XSnqWHtxQbhUVaFGE/3FMwMe+ihb7DKCDcMO5GQn6+dlGrZiTYhM8KiA4a+0+36StpdlmkYvF7uDQsIEUKjM3OgbsdwODQzpwrV27lmTpQnWDBro71NLaqlNNHm3IjVJiRo5S0zM0ryBH+ys7LPU8NWHUNWsmGhUHKq6OHfVMHHOsY1y7ds1onKFi5T1TFsWOBbh3dYRnJq573tURnoVYnePgx7vBsf/+yEc+It7RUKUjLTICjEAEgETug7AcAX8AJFxcePwNeDimuGPt+Oqrr9qq5GSdgmb65mPygClr5+YAACAASURBVBMWVA5f6pR3aB8vVV+NBv8/0/aR4wEQQu0QIZPxMC8rUevnZ0w7H3+sazZeX2f6Wo91PAAIfcUFy2lMpDADYJIFPY57m4nS3XffPSa4xi63s89jk3w0GvuvICKP04BnWKuL0nWmbjSZPDs5zgAKFQ4m+SsKUy1vA/eo/ZWtpquANiVFmSh97+VW04P84qVDuqtsjvoSstU9MKx189J0raXP9B3oQXCiIjCQSgoZIQCNh5fnqaVn0I7FPXG8tlNvW5VvQYFUSHDcAsw8uDTXtCjkklzvGLCwzwfKc1XV2qcEV5TZBte09ym3r0YNXQPyjESro7tXLQNR2rggXYX5OcrJybHV75lofGdZ8CCsdbZbKOlRGIvZsiimOgJFywEkVIQBvunp6QY60KYA0pxn5gc+8AGr1hC6G2mREYgAkMg9ELYjwGTBCV5zTiJcMh78DTo5IHPnzlVZWVnYXBNWiV955RWrOPHSCbXmHdrngA2Elt4Oak5on69OY7pD+wIdq7GCE1nF/sa+KstHIX0aagyr4diyfvz+EkvQnul2pwAQbHWpYmQmx6lnwGOVjZ+fadLG4nQ1dLtNlL0fMXhSrIEPGna7p+q6tKs8x6okgJBnzjUZmOC6cf3cnmGjaUHbOl3XpcbLJ9QUnaMVJUUqzUu2YxrFqrJNW8uybHsyPbgXLjX2GPi43t5vtrwACsTq20qzdLWlTzClmrrcGpZ014IMAyR8P9hmaHhEGxZkiGTz3sEhq4a4h0a0fn66Xj58Ui29Q1q8eLF6+vrNkre3s83AAM9fJ1cCMMIzIFBt00TvTZ7tgEIA4Wy3UKKDMRYsqgCqZ9shjEqxI2TnT+4vFnJwL0Mv98wzzwiQsnv37tm+hJHjh8gIRCogIXIhIt2Y2Aj4AyCzabE6sd6/cWuS0MkAQQcSLo1JPeGPrEoiTJytxosObrIvdYqKhhPaBy3AoYmxakfqPP8P0AhlPjIAhJVE38nF1166qh8drzNHoszEWLliom0yzIR0YU6S/vYdyzUva2ZWp53rDgCBJhMq1JSx7sepVEDQPjDJpuJBcjlaC1ymHl2Zp7P1uE4l6ZXKVrOlRWfB5L6pa0Dd7iHdW5Klk7WdVu04Vt1hVQ7sdZnwt/YM2rW7tzTLUskJHPz5y0e0dlGB1i0tsQBBNBgtPW6tnZeu/sHR/BDufe6Be4rRiPSrrdetKEUZJYsKy7XWPts3dCyACv1yksup1gBAsOKF3lXV2q/i7ASrfpDpwbGeeuW0FqTHaG5xmVnupsS7RgHVa85JXG9WwKlI8x1DswIYgZITzGoh3wOeN3xvZ7uFEh2MsQi1igx94jvGOGGq8hd/8Rd64oknTA+HdgQtCPRHbOdD+dk72/fZnXD8CAC5E67ybXiO/gDIZATGoTI0lKV5aS9dujRUujRuP5jgIypkVZKJx3Q3J7TPn8WtE9rnpIP76jScdHDHAck7hG66+z2V/fur6rG6/f9854RNgKFdseLttK5+j/h5911z9aH7Fk3l0BP+7FjVmgnvaJo/wIosfb0VBcs3XZpqw8GrbRa8B8Crbe8zMTjXYucSbHC7lBwbYxSmdfMBCENq6xlU54DHROBUPBCqx8VEq2tgyOhTgAjoUAjDuYRritItrJBjxcVGq+LMCS0vmaf64TSrpIxoRPOzkgxIsB3VLsDHisI0q3xcbe41K94bnQMGPi7Ud1u4IMeqae83oAEA6uj3mPaEqgnbAXigbW1elGFiePZ3rblHV5r7lNVXq/o+afuGlUpNGAUfvs1AUFeXgU/ACH+nUREBjDhUralMNqHXsnq+fv36ab47xt99KNHB6G2oVWQcAOIdHMlz7GMf+5hVQ6hk8e4g84pckF/91V8df9AjW9yWIxABILflZb39T8ofAKEUTRVk165dYTcAUJl4YWPFGy6NkjuVG2yPmWQEszmhfb5gwwntYxUa8bcvdQo3qltNdPyF0AWz38HeFy9ubDa9E6B/fqZB//DcZZvMMiH2bkwGmQQvzkvRt39rZidr4QRAGNcHH3zw5tD5akC8AUiHJ8Zsb3NT4pSfFm9gI9EVrUGoS/PTzSJXIyOKiYnS/MxEoy8xuc9LidPwyIjZ4L54uVU5SbFyvWZhC43rbF2X5YS09A4aONhX0aqE2GijWfG5SycO6+pwlh5eX2IOW7hXUbEAMGwtyVRFM4nkqTp3o8sE5ptLsmyfo9qSNhO683doXasKU/RSRavdL1RBADCr56bq5SttBizWFqWZoxa2usdrOuUZGdGWRVl6Yu8R5afGaeO6VQHf2lAcHTACFYexxcbVASOsgk+UqoVzEvsNhYynUKrGcFF45wH8QkGg79wk/qoy5Kbwfvv6179ulfNf/OIXeuyxx8LSNCbgL0Nkw1uOQASARG6QsBwBVrwdeo1zAo67TbisbnsP/IEDB2xCvXLlyrC5HtCe0K6wKpmbmzupfgMo/KWDA0Bo5ubzWmifN9iYaDCW0zlEkNg1M/mc6CRoUic4xQ+x2kr+gTcA+cmJOn3xhUoTLCNC9m1MlgszEvQ/v3PXjFIcbicAgsbhyLHjyiheoYzU5Jv2tUziARRM+Jncv3Cp2axuU+JilJ4UawGD6CuogkCRWpqfrCdPNxpQQSyO4xQp6LVt/eaSdaGhRysLU/SLc02235Q4l4nYEYL/69OH9Pj6eRpJzTMwc62lV219Hm0vy7IMDqodZIZkJLmsakEeSGluktnrluQmWbUEITygCJCESxdOWWxHVokFFWYnGp0M8AHAqaTqkeQyi11AVH3lBWWnJkx6YcTbxhVQAoigSulN1QpEb4V7Es+KtWvXTvEbNfWPQzVkBT9U8qZCSR/jjK5vVYaFEcxKcMX62te+NvWLMMk9HDlyRP/5n/8pTF8ASbxbAEV//Md/7NcZcZKHiXwswBGIAJAAByqyWWiNgD8Agh0h1n/hMrn0HtFDhw6ZYA9ebLg0QAIPciYF6Fdu1bhe3kDDydTwTgcHVPhmafhLB5/K+DgABBve6bLOnUr/fD/rT9d0tLpdf/rkeaP55KXinvTLhtgZWs+2smz97WMrgtmVcfcVLgDEcUK7VQXk9LV6HTt1TvdvWqcBxRrYY7L/4LJcE5FDa3r6bJPlflDxIJn8ajOWuyOm0YAOVZAWZ45WDy3PNbvbtESXLjX0KM4VZXQrwgIL0+LNcpdqg2PX2zMwpNqOPsU3nFd05lyVzJ+r6rY+c9vicwAIQMfV5j4DEFCxoFZRySDwcFFOonJS4q3KQV4IVRO2oXoDDYzKCNoUEtP5/Ql0LVFRFooIKAeo4JAF7avy/CkLGV22bNm413+8DZiEMnEHiPCDiQUNBz1HN8L3318Fk+c6YGbNmjXjHWba/z2UqjGcbKgBIvrkW5Xh2vOeePTRR/WP//iP036NxjrAO9/5Tu3du1ePP/64VdN4D33rW98ye+CvfOUr+r3f+71Z69udeOAIALkTr/ptcM7+AAhUlRMnTljIXDAFkDMxXKzMsDIYCit8gZ4vK5LPP/+8TQoKCgrsY05ony91yju0zxtoOIAjGKF9gfTbuUfCGYAwefzY907pWHW7Wasy8WTSBviA/5+W4NInHyjVA0vzAhmSoG0zlmA+aAcI0o78UTUdCtbQ8LBeudouufvUXnNJC5euVnRsnAEIsi9O1HYaJQmaEgGCTd2jlTpob1C00IdcbuyxyTy6i+1l2RYuyLXBejcnNd7C/wAHbNPeh4Yj1XQfXLuR4RENDI3orgXp+t7TLykrb459twANS/JT7PgED8bHRhvoITGdTA/0J0mvVcTyU+O170rraHJ5QqxtS3Vj76UWAxXZKbEaGpalsb9U0WJVlwXZidY/jnEFe96kWAMoPJf4bk6HNo0FDKhDgBGoWjw7WIRxwIh34vbJkyftHl+1KnAqWJBulzfsBjDE+ydUntWhBogYMF+aGgCEe+g3fuM39Dd/8zfTdWnG3S/ULypX3GdO493EO4zsEgw/wmFhatwTDZMNIgAkTC5UpJuvHwF/AISHx7FjxwTX1PsBEw5jR795SIeCyDKQ8WLCxgom1LG8vNGJLqtJ/kL7fHUaU00HD6R/Y21DmvLx48d1//333wzImsr+pvuzOMkgnOee9m6XGrr1lz+7YCvjUHYQMg+PSFlJcdq1LFcf31GiaH45gy3cAciNth7TU0Bdkrtbzx86o6XLlik+PsEsaY8iIo9GRO4x+hUCb0ToVA+YsBemx+todYcBQAAFWgvE6g2dbqtYoNkpzk4yLUZOcqxiYqI1Nz1eg55Ri16ACdSu1UVp1o+XDhzTPUsXKDkz17Qiey+3GNjkOAOeEc3PHA0eLMtNtpyRkRFSzuP009ONWjs/Ta7o6Ju/e+JUg+5ekKE4V7RRwfjsU6cbtLIwVdkp8apr79eS/GS9erXN9ENQxWiHDx82nVV5efm03kk8T9DdONUR6J1UY6BqYc7B95ZFpVCgqELh5FkdKtXqUKoOOTeJr2kA40XI7sc//nF95jOfmdZ7aTI7/+QnP6nPf/7z5t6Fc1ekzcwIRADIzIxz5ChBHgF/AISXFyt2WJbOVEBWsE6LSTHnFAo2k97nxMQAUOEvHZyXCo0VIwT0VDO8wUYoriSFG0gFgPBSBDD5Nlywfna6Xq9Wtlp+AxawDy7L031lOTMOPuhbuOTw+FZAuI/P1nVqwO02m1lW/l88e12dNypVvnylNizM0QsXW5SbGmfWumgqsLyt7+hXcU6SVRPQVhAEiH1te9+gVRLO13epu39Ii/OTjQZVnJWop840WnWj1z1sFRM0I2gttpVlGbULYPNKZZtlgzRcPKakvPnaunKRfn6mUauKUpUc5zIAlJscq6fPNZkD18DQsNnuIozfc6lFb1mRb33gd/ExUdp3pU1vXpmv7n6PpahjyYt1MBUc3LfI/0D4fuham2lJOBenQQ3luz2T9uBcD545DhjBNcl5zhQVFVmFhOfMVFy1pvLcpsrOIkoogCHOI5SqQ864+mp2uKa4Xv35n/+52fCGWnvPe96jH/zgBwaCqfhF2syMQASAzMw4R44S5BGgXO9Yrzq7Rjh68OBBE7o5mQ9BPuy07Y6XCKt+s5X064T2+bO4dYAGK5C+1QwmKIj4wmXViDI7Cdfbt283Z55Qb4g5sa70B0BCre/hAkAQnwLscMtr7XGrtq1PmUku9fa7jeqEYHtZlrTnyFn9ys67tbuiSxuLMw1EIO6nOgH2pmJAxYIUcrQeDy/P1ZWmXhOAk04PkAGsNHa7bf9sQ14IlCxCCtFZuD0j2lKSaYnlVDKoQPAnGR0/fPZlrVy8UNfdidq+ONtse+kD30fE6w8uzTH7XLdnSOhGqIbtLM9Vc/eAVcUAHKSYby3NVkefR539g1b94JzXzRsNDkXYHhMdbYCFCoyvpojnKVQogghnq0H1ZGGJxRDnuY9wncoIYIQqyUxWVVks4lm4YsXMaqzGGv9Q648/UMR14zp96Utf0oc//OHZupX8HhcNDRSsRx55RD/84Q9Dqm+3e2ciAOR2v8K36fn5AyCslL366qshm8x9q0tBGZ0qA6ni09l8Q/u8AYeTLO+E9vmCDX+0NtJt4fbOnz9/OrsdtH07VTJcpRDXhnoLp2ybcAIgALvY+Wtsoo9gu6PPre7egZuT+FcvXFdz1WW5c0r09rVFpvGAZoUAHO0EzlcE9VFlQHD+0LJcc5XKSo7VuRvd5lAFXQonLDQb6EGoVrAfmHHkdmQkxZrtLboOaFtUVaA/8TnAybGjR5RVME/3r15ogIKKF/vqdg+bqxbgB0ctiHZQstbMS7PQQfYTGxNl4AZ9CRUTnLmSYmNEzRLhOrQxBOnY8iJUp/KDSN23QbFkol9WVjarXxVHi0Ilhue8ox2hUgJVC2tfRzsy3d9rFjCCJcwPxqCGWn84J19QhM4Co5JvfvOb+u3f/u1gnHZQ9sG9xDsXp0EWAcPlPRaUkw+BnUQASAhchEgXJj4C/gAIE3gC/WY7mXviZyMhJKT8u2XLlsl8/A2fAWjgMOXP4taxL/YO7fMGG05oXyAd2b17t01OiouLA9l81rdh4gKvfTZoen3uIR2pbje6D2FyBWkJ2rQoS0WZYwOhCAAJ/i1z6kKFnjt5TW/dsdFAQHPXgFp7BzXkQduRqnP1Perr7tDBMxX64Js3qq572FyjmnvcKslJMhoUlQNav2dY9xRnmKMVYATtBwAlKc5l6eUJrmijx62fn2FUp5Zut7lZUWlxLHPJ/uD/qZhQTTls1ZNYHT1yRJtXlSknr8BcrkgiJy0deldH36DlgZTlJamlx2OuXACi03VdWlmYZtoUtoNyxf7WzEs3uhcVHFe09PzFFquCkDcCWOFe9NdY0MFiu7S0NPgXYgJ7HEuLAgBxwAjPT557UGiczBEctoJN1ZopXUygwxNq/aHfvqAIkwHeEf/1X/8l6E6h0ABFWPYzfk8//fTrrM5DoX93Qh8iAOROuMq34Tn6AyBOMB46ClbtwqlRBmZ1fuvWrRPuNm4y/qhT3qF9vsng/D8UpKm+nJ977jmVlJSYwDAcGi9CaGOM80xyfZu6BvS1l67qUmO3rVIzUSIhuyA9QY+vLdSOJf5zVKALsVqPa1eot3CogFQ0dutsRZX6Wm5o145tptPgOriipJKcBHOPykmOU1NruzwNFcorW6VeD4GPLmUkxZkdL0Jz7GuZ3KPZgG6FlgIxd1JstGksXrnaZtUNKFJUIUglBwAsLgA8eFSWm6RnzjcZRYuKByAAV6vdF5q1aWGmUaIunzykwuIS1bsTjEYF6CnLS7YqzbWWPtNwoBspz09RZXOPqttGqyz8DnAD1QtHq11Lc62ighMWVK1DVe16y4o8o2fFREWZ/mOsRkAqK9d8x2ezBaJFgZLL99sJQeT5B1XKm6oVDF1aIH2ZybEKBZqc7/kyRoA/x7wAi3wq5T/+8Y/19re/fSaHx++xeGe+9a1vNRv5H/3oR0a/irSZH4EIAJn5MY8cMQgj4Nhmeu+KFf89e/aYv7fjzBSEQ83ILvwlXvse2Ant8wUb3qF93kDD+ftkQ/sCOXFseFnZmu0JSiB9ZZvZ0AkBNv5+d4X2X2kxqgu0H8TMXf0emyQSBPf7O0u1OD/lDafhrVcI9Bxna7tQBiCABSbpgIMb16+rsa5G8UUrtKoofVQ0npekJ07Uae08ROQeZcf06yf7z2j1qhVamJtqDmOx0VE6Ut1hAYJQmnCr2n2+2SoTTiJ9lEZ0tLpTu5aOAgHAB7oOjluWl2I0Krb/xdkmbSvNMgE5IMAzxOc69OiqfF1p7lVusks/fm6/0vKK9M5Ni63asTA70dyyLNRtUZZZ+ZbmJetYTYdio6N1N5WYui67n6jI0OdNizLNFhjXLYALzl2AFGha6Fi8Bef+7htsSxEPL1q0aLZuKzvuRKlgjBEufY6QnfwRFlu8qVqTNSqZaF+me+BCpUrlfZ6+Y8QiCrbFVBqoOsxmA6iSB/LUU0/pO9/5jt797nfPZnfu6GNHAMgdffnD9+T9ARB/uRThcoYEN9XW1prdqndonzfY8Bfa55sOPtPp3gA+BOizTdEI9DpD0+DlCNWNsZuJhmXu3z17WR39g2bD6t163UMiufxtq+fot7cseEN3/GVWzESfJ3OMQED0ZPY71c9cb+tVv2fEqhcIuS9XVulYxXV95LHtulDfobQYj549W69NhS61DydqRXGenjlZI3dTlbZu3KBoV6w6+9BWDGhneY7RodBR7Kto1d3FmRoaGTEqE5UtckHuX5xtyeJFGYmms6BqQf4Gug/oV9CkdpXnWO4Gn4OWhZ4DoXlFE1qNaF1r7dW50yf16MZlahlJNo0IFC7scaFWAUhS42MMSGSnxJl2BNCBzoNqW2qiS0sLUq3yAdKg8jE4Iq2fl2a6FPpM/8ZrUFrnzp076xXOqU6yods4VC0WIawCmZR0UzeC01egz85QqQo51y5UQKL3veQ7Rmgceea+9NJLk6ryj3efBvrvzBve+9736nvf+56+/vWv63d+53cC/Whku2kYgQgAmYZBjexy+kfAHwDhd88++6zZI/LSDPUGjczRaAA+mByjv8ANy2n+0sGhDgX6spzuMXjxxRdVWFg4qy45EzlHx6hg8+bNRhGYifbMuQZ9c3+V8foJhvNtuCqtmpuuz779jWnT/lK7Z6LPkznGpUuXTMyJwD9UWk3bqOg7JkpqbOtUVWOHBY7lRnWr2ROnkcEB3eiV1uVGqa4/Rq5hjxoGYrRqTrLaOzpVumyV+oZjrGK1bn66gY/k+Bhdb+u3/wdAAh74ExoWWg/AR1x0lNrMWSrZgAJVCPZBJYakdD7T0DkwGiA5PKJ189KsqoJgnIpItEbUcPGoXLkLlZyeZULx2JhoAzNUPtCaQN0i66U0N9kqH2hNqHQgSCc35HJjt4EcKi5N3YNGF4N2NTg0YhSyQNrLL79sCwyzrfEK5qSfBR5AiEPVooIMNQuqlvNzqyDbUJvwh8o18r6ffIErOgsCgqFmzabV/B/8wR/oC1/4gj2jPvjBD77hK4AzHpTDSJuZEYgAkJkZ58hRgjwC/gAIq1q4MoWaLSx9hQLgS53yDu3jhUcFBy2FN41qJu0lJ3OJWNHigT2TOQGT6afzGWgZTGZwPmHVcyba7vON+sa+Kgujc6g6znG5Z3FNYlL6V297IwDBgpfKwoMPPjgTXZ3SMUIBgDjmC3zXKm60qru7RwN9Papq7TUHqcQYaW6aS5fahrSwaI7kStC28gJVtnnUO+BW/8CAUoZ7VN/QoKq2AcvRyMpI14aSPFV0xyozOUFR0VFGc8LS9nJTj2VyMKknePDgtTa5oqIMHPDD9SapHKoT22DRixYEehaVDMTiAAOqF2hDELkjiF+cm6ivP/mSFhUXa8PiuWrt9WhxXrJermi1Csmi3CQDFfwO3Qoidpy3oPQtm5Oqw1XtBlI2LBgVyK8tQpjuNtE8fQ+08f1esGCB/cxmY0LLQkewqWDcL9wrDhjh74BCng2OdsSXwhpqE/69e/faeyOUHJx8+8R9hM6CSshs2hdjv07fxmpU9Nkm0mZmBCIAZGbGOXKUII8ALw5H++C9ayogeNbPxoqdd2ifN9gAaDhZGlQ4fAP7+H9EeiRJzzY/dqKXiZcxjjMIDMOhcV1Ywdy4caPxwWeiIR7+m6cvWT4DWQvewn90IFBiEKK/7543JvASQohBQTjcFzMNQFjJ5no63zXn7yZGHpCiomOUkZqk6/3xWjwnTfEJyVoxP0ff3XdBCf1NKl+9QWuK0rWfCXyMlB4fbYniTNxfvVSn6JYqpecXKVNd2nOlU3OScFhKUcncHEXFp6mud8TscGvb+y2A8OlzjVqAqDzRZTa30KFIL7+vLNvoVwtzknS1pVf1HQO6tzTL8kQAHwAInLWoWvDviNcJmGy7dl6b1y6VJy7Vqhy/ONtoble4ZXHPlOQm65lzTVpWkKz8tAT7LIL0Fy42m9sVf6cas3puqgnlSUGnQjORFiqT25ma9ENzdcAIgnae6Zh1OK5aPDMAQ6EAypzrSBUaCiwhjaHSmMjjjuj0ifcyugtc/cLFsCRUxvJ27kcEgNzOV/c2PrexAAiiaB5wwV4p8x5KJ6nXoU85EyCqHA7QICjLqWR46zTGKu3X1NSYFS8Tzak6U83kZWcyT1DZsmVvXL2fyX4EeqzZsGrmnvjK3qvac7HJKDP5qfFyxUSZlWpDp9smkp/aVar5Wa/Xh3BOEwEgcP9/fOKGid3JjUD0/I41c7RugpPOQMfSd7vpAiAOsPcFGvD6aXxfoCU6wL5X8UpIStZIVIxpKrA6vtHZr8L00bTyxQndOnSpVu9/dLuBhmUFqUbTio0aVn2X2zQZpakePX/knN62Y6P2VHRo26I0VVxv0nBvh85ebzOQsrogUR0x6VpfUqBDdW4TfFPl4D+0Jtjwvnl5nlU7oEGduN5lCedUIwAGOGGRSE7wIBkc5Inw58GrbVpXlKKjhw8qe16pFs7NM4H6vSVZBmzQfaAJgQ62cWGG4mNjLAARfciZ651aXphq+3Gsey/U91iKOxWXiTYmtxhMzHbQ6GxUYqDIQtVytCOAEyrS/J6qLxNsnvOz2Xi2MNnHbYoKUSg0f3168skn9b73vc8omgUFBaHQzUgfQmAEIgAkBC5CpAsTH4GxAAgPY1ZdghGc5aSDe2dpOH93QvsAFL7OUwCOib6YqIBQnoZqEyr6jkCuCnQmtBSzWVYPpJ/ONoBEVlPvvvtuS+adjtY/OGQr1ICAuNcyFuD5/8u+a5YBgljZMzIqip6TlqBfu2femCvTDjB96KGHbtlVJrsf/94p4/gzOaahOWDC+zv3LtAH753+nJapAhDnO+1UMvyFZFJBdAA9fzp/d74z9R39csafMafCAf2K6wAQeGRlvn528LwG2m4odu5ybSvNtnRxaVhXGkYteaEwHbpYq9prV5Qyr1wPrygwahP5GdjfZibGKCd2UAcv39Bgd7uqOz1anRer+LQsJaVmaCg2yYDIlpIsO2aCK0q17QOamx6v4pwkCx7E1vdGx4BRqAATlxp7TONBSvnyOakaHhrUE3sOqLSkVK6kVPsdIIlqGu5VUKkALmSIkIruio6ybBlAFi5riN/jXTEa1ohVV6i8TaaFyur6bFdiuDd59lMdwZnOaTz7nOoIIHimF48AQ4wNFWjcykKhUYEEMLIo5YANRN8IvtHgzZT2LhTGItKHW49ABIBE7pCwHIGxAMhkNAnevHFfsOEd2uebDA7wmEho360G2kliJe8hGF71M3VRcZTixYvwPxzadGfFkLtwqaHL8h8AIKMBc7Fakp9qDljkTrBK7X5tssiE+eWKFptIfmR7icp8VqkDqYx5hob1K/9y2DJGOB7hdzQm4ATXMQH9x19ZaZWA6WwAkLq6uoA41I4B3ztYHgAAIABJREFUgy/YcGiVTkimL9i4FbBv6Ow3elPXwKCykuI0PztJOJCRFI64mwoCE/P6G9dVWdug33jLNqtCMenvcXuUGR9toZCnrnepr6tdZy9X6v0Pb1FDz5DpNkgRJw2dagYVCax1ATuFScOqvtGkC7XNksctRcforoXZalOKYpNSlZ4Up4TYGNNevFrZZnkf5H5kJsfZ/qh44JIVEy2jUgGWDlQ2q/byOS1ZUqal8wsMYByu7rDqWWz0aOYIx4e+RbUDoTsUK/79xcutykqK1Zz0eLN6psI22caCDpTW2Tb18KX0TPZ8pvo5Z3UfyhPPaaojULW4n3kXeFO1ZkK/50z2WQAKFet5vsPQ1HgnEGJJ+7d/+zd97GMfM9r0rQT+U70+kc+H1whEAEh4Xa9Ib18bgbEACA8+xIP+NAnOZwAZvoJwHuQ0XhredA6nuhGM0L5bXbyGhgYdP35c999//4SrJ7N5UxCCxdisXr16NrsR8LGh7bBiuGHDBpssBLPVtvXpcFWbuRtBeaH6ABWHiTETy7sWZGjeazSrFy826mP/c8ZAincrTI/XLz66SQmxLvs17mhnzpy5JTVv7+VmffIHZzQ0NKzk+NHPOc1AyIBHb1qer79/fEUwT/cN+8JKmkqet4jTm67oDTa8DRgQ+TrVDAdwTDS7hjE/U/faBN0VYy5PUNHmZiAWH7LU75cuk8MSo8YbdRrqbNDydffoakuPbYtAvTA1Vi9ebtHC7CTdaGpRf/0VFS5Zq/b+Yc3PTrSsjgXZSXr2XKNVLrh0iMsBMVQ6Vham6Gpjh/JjevXSpUb19/UqPylK8clpWrkgT8daorV0TrpZ8RoASYzV0+eatGFBut0npLJTBdlzqUUb5iZpz6uHtWnNMuVmZ9vvqKhQraF6QqWGLJF7F2XIPTxizln5qXF64lSD1s9PV2pCrDlg4Zo12RZK9B4C4zC6mG0g5FQcvFf3qYbjYOhkjuBiSEWOCivPGN5HgJPpaP4m+9NxnInsk/OnMs47wQkE/upXv6o//dM/Fc/fcKrwT+S8I9tOfAQiAGTiYxb5RIiMgJOL4d0d/OKZxLBq513NcACHdzq4AzS8ReGJiYkzXkan/1iDHj161CZvTOjDpWGvyIrWmjVrwqLLvByhlaxfv/7m6lwwOs5kbV9Fi07XddqKMxPJmyBgaNjyGFYWpmlLCenVnXr8nw/birq/xqr4gT8atbINhJr31b1X9bWXr1rlw/u4zr6xfGWS/fTHNgfjVMfcByYK9BfNgDfId6qI3CfeQMMBG1NdKb7S1G2VjrXzMixUsCAtQc9faNS2shwL31szN00/PdOgFXNS5RmRuptqdfzydZUuX6VVhWkWzpefGmvC752Ls4wula4e/fTgea1bvVqLC1LNmSovNd7AB8niUOxIEAfAtHYPaktJps4ZCEm1cEJcqlJdI6qsa5J62/TilU6tzByRKzFZOTnZys7K0on6AT26Ms+OBw2rq3/QMkIeXZmv83XtqjhzXHMXLdGNfpcll19r7bPqSa/bY4GIb1+VrxudbrseVEX2VbbroWU5Rv+if5PRfHhfXCbWfFdmm94TSkBovIqDA7gdMALliMa97rhq8fdgUbX8Tfan9UsewM6hubIwRfAg+kDa5z//eftBUxMBIAEM4h2ySQSA3CEX+nY8TQCI44TjgA0mQLw4HY2Gt0DVW6vBCmsoPQgp5TOZ37ZtmwVkhUs7cuSIVY142YRD456BzrFu3boJUxZeuNCoHxyrM9cj9BUkYf/GPfO1KDfZqC7PXWi0P6Hx+DaqI9iy7lySq3d9/ZBNJm/V/uqt5XrX+qKAAAjaki+/WKm4mGij4Xg3JkQke5NH8dSHN/o9JAABbQMr84UBhNPx3XIAhrcw3FkQ4HvlbcDggA7oU8GaeDkngvC+vrPfBPykjMe5onS6tsu0Hieud1o1A/H/zvJcs6GFDvf04QtydzTrsQe3mWYmLlo6Uduhh5dm6+yNbqtqvHCqSu6WGu3atskqIFxvwv8eWZlnmR7ZybFmn5yW6NKKwjTL5kDjcaymU+sXZBhlqqXHbboNqiM7SjN0qaZRra0tqmnqUEvfkDbOTdBgQpYKcrPUPRyn3sHhmynr0UNu7X7lmIqKS/Tw2gWm/eDaNnW5DQxtL8sykDE4PKKuPo+dBxQzqj3BAB+MrwNAvFf7Z+M7Hko6h4lWHFjwckTsULV4X/E9cMAIVZKpAHAqidBgvSf7s3GNvI/JM4F3GVVmR+/x2c9+Vt/61rdMhB7sZ8Bsn2/k+JMfgQgAmfzYRT45iyPAxArHK1ZbnMbEnQc8K61wdJkEhVJo362Gi5UhVo3uvfde63e4tGPHjpnzFxWFcGhMIKBz8MKeSODU//vMJXOYgs40/FrpAier7KQ4/cmbF+tKc6++c7DaJoeEDd6zMFPbF+fcpESh9UCfsbM8T5v+du/NfYw1ZlQsnvv9LaapOHXqlAjIGmuiwuT3A/9xzGg8aAG8X/BQvBClv+euIv3vhxa/7nB97iH97x+f1SuVLRakJ0XZBB3XrIXZySa6Xl2YrNL0KPX2/JK26O32RsXQqWTwe+5jqngzAe6xNSY7IzclzoTmnCtBf9tKc3S8dlSjwe+3luaorr1PQ8Mj5iAV3dOk7pYGzV+2XuhnqJpsK83SqZo2Axrka2RG9ehqxWUVLV1r4842TPBxm/JAuen1KD8tTguyknSyFsF3tLoGhoyahVMVx0V70u0eNqtewAiUKATkfe5BLUod1ulrDbre1KrBQY9iYly6uyRXfa40xSQka9AzqJMnT+sd29aoS4mmQQHUDHiGLDMGwIGIHdAJCCEDhMoHdr/Y+Qaj+aMbBWO/E92HU3Ug32ki39mJHieQ7QHZOP9504sC+ZwD6KiIODa/gAe+J1QJHEAy0eo3CwGE+/H8nalco/HOl3Okmo/Rh/Mug371k5/8xAT8EQAy3gjeOf8eASB3zrW+7c4U0avjQgXQYKIQbhNi56LMRkJ3MG4IdCtMEGYz3XYi58GKJMAVyligdpC7zzXqT586b9UNqhhMNgFdCLyZxLtiot+g5aBPOclx+oMHSozbz6o5IXPbl+RqxV+8MG6Xs5Ni9cof3XcTgNzKnIC+fPS7p/TylRbB60LQziQY4DEwNKzMpDj92/vXvU6MzOTy0a8ctOwIB1B5d4rkcCoD8TEjmpc8ol9bHK3C7F+6TjlVDW/DBH8akHFPdJIbIBznB23N8Zp2ozABMJick+uREu/S0Ii0tCBFde39VhVAOwG9rflGjfadv64dmzaYiJyKxbHqNvUNDColLkZZKfHqamvWLw5f1K4t69XnkVbPTbNkccwFADxc8+LsRO293GrVEETm/AlIOFrTYXkg3B/QoOjnhfpuleYlq6nbbdkfjDtp6qW5Saqsb1N+TI9OXG1UfdeA5qfGyB2brKzhTqXPW6yeqEQtm5Oi2rZ+q7pxLlRfVhSmGqgh3JBzx6mL8w1WG49uFKzjjLcfvrM414WC0BoNAzRfnh9TddEDgDhgBA0J32Mm7A4YoXow3mSdYFWq0Dx/+U6GQqPSc+LECctacqr5n/70p017d+7cuXHPKRTOIdKHmRmBCACZmXGOHGUaRoDVbCd3w9k9Dz5+z+pLOLXZCMgLxvicPHlSrAqGy3gzqXruuedsBTNQ28r/9Z0TeuUKAmbXGyhOrML76MhfN6xMCN+xttBEwqRSlxekavmfP28OVbdqS/KT9eSHNhllgTG+FQDp7Bu0le+/f+6yTtV2Ghhi7yZ0TorVXz66VJtLsu1w0GqoVPztsxX6wakWIYGPsSyNEdNHjDbW7qWsxGh5hqNsX/cszNKXfnWV5ZiM1WYKgDChp6KA49OeS81mYewkiqP1KM9PNZcxcx270aXewSEL8kNEzjX8/r4zKohqV1H5OhOnv3ipSRmJsUqLjzIAEeeK0dMnriqt+7oKy9dq7fwMHbzWbnQqsjva+jxamJ2on5xssByOAc+IASCqKWgzCB6EMoUA/GpLnwGge0szDTQAII7VdKjPPax7itNNNwK4Yf88y5Zmx1oIYuZQm07d6NXgsGy7ZqVp69IiXW0f1I3OAe1ckmPULihmVEcANuw7mM2Z+Hu7GQVz/4Hua6K0p0D3O5ntHH0DFM5gBpky1kzcoWvxw/+zuOZN1fLnjghwYdHtnnvusWp/KDRAFVXbLVu23BTff/SjH7XnGAtWkRYZgZtvmhHfGVxkbCIjECYj4A+AkKXBS4LVl3BqM5FPMR3jwYuGlbxwGW9W/nfv3q1Vq1YFHNz18JdeUXVrnwW9eTcenegKbg0lpE/sXKQNCzK1uijdROLv+cZhm4Teqv3Xb63X+uJM1dfX22rizp0732BfWd3aqx8er9PRqnabcMfHRNtKfHPPgIaHpYXZCXr/uhxluAZflxhOv//8WLRaB6INfERHy6ogVAy8W1LcqK0rtDIcvf7hnSsNRM0mAGnrdZsOAq0HlroPL8/X2RtdBgyePotAPM9CB+dlJOrA1VYVpCUqLy3etBFuz5CFA5bGdWj/hRv6tTdv1bPnm7RufrrgRrndg0axu9rar1UZg1YBefdD92rflXbL0chNjbeKQ0aiSy9VtJownGoEVC/+5AeB+tm6Li3MSTQ9CMYA7J/sDxLOX6lsszFdUpBiuhGoU/uutJlFL1oifgdofeHcDTVVXdKm8iL7bMZIly61jygzNUmby/LVOpKsxXMyVNnSZyJ6AEmwmzPx57sSbMe4ifQ1lITWDuXJW98wkXMJZFu+n1TEHe0I7wYqIQAex1XLqSw41YZNmzYJOmQotMbGRnPu27p1681n1gc/+EFz9IO+FmmREYgAkMg9EPYjwCqRIzZ3ToY0cR7emzdPr+NPsAdvOu1hg91X7/3xoqF6wwswHBr3y7PPPmse9YFaej765VdN45GTHPs6+gAr3kz+xmt/8Ui53rl+rukLaO19A9r2d/uNHuWvrZybph/87mgFbywAUtnco795+pLIHWHCAmUKXcDg0Gj9gkO5okeUECM9tki6b2HqzaRwqBoPfu2kaRagk9Gga/kCKSb5RRmJVlGBfvbbmxfo9+5beEsAwiRjx44d4w3JpP6dlX4E5+g86M/W0mxLFM9IiDHx+MMr8lXR2GMWtRfqu7RibpoBPipELb1uuQeHzYXsyVfOaLCrWSnzllo2yiiVzqO6NvRkUbqnOEPPn7yqlrpryixeYbQu9sP4cs3rOge0Y3GOVZ1GQeiAUd4AZ4AhqiFVLX0qSI832h0AgpwPqiLQpXDpOnW907I6qtr6tTgvSbkp8fY7aFzVbf3KSxhWzYVTiptbrgV5Gapu6VHcUJ+SPJ06UdWiOA2pNypOWRkZ2rp0rk1Ox6PrTHTQHb3DbAOQYNKeJjoGvtvPBuWJ83fACBor7jkACGCEqkhlZeXrqg1TPcepfp5nFlSr++6776ZujRR0gBTV50iLjEAEgETugbAfAX8ABCtQLG1ZfQmnNhV3ptk8z3ADfLy8n3nmGeOTFxUVBTR0CLV/cabBKE3eORuBApBv/Ppamyx393v0d7sv68VLzeodIPxu5HVVB6DA/eW5+vJ7fpmp4p0PAyWDahOA7+9fqNIr1d1Kc40oPnpYdb1R6jIsNApyElySKybGwENaYqy++p7VWlWUfvN8N//tXtMzYN+KENYfAEmIjVJheqIlbOOk9f6N8/TRHSVjjllFRYUITpwOAGJZGze6rFrjio7WqrlpOnStTUmx0ep2D+nuYgTi3eoeGNLQyIhRkwAFADVoVQAIgB2hfw11NWpobtWvPHivVUaoJIHDRoY85mh1vLbL3Kqqrl3TIzs2KTHOZRoOgA3jCdUJATjAA70NE3+SygEfaEqoeiTFu1SclWiUrFiO74o2DQpJ5Yeutdu+CBxMT4y1IMHD19rNhYwqVlJ8jDJcHv33c4e1bGm5CrLSjfpGFQZgBaByDfXpemOrMoc7boa7OSF4U3VWci5wqFQeQsnpabYpT1BIASGOdsQJ7iTwjx8oW7Md9IcT5cWLF+054IDixx9/3OhYTz31VEDP3MhGd8YIRDQgd8Z1vi3P0h8AQZgOb57Vl3BqkxFHh8L5nT9/3lbncO8Kl/b0008La9H58+cH1OVzN7r0e/91wug3WKEywaR20dvvMQeiW1GwyG14+VNb1dIzoHd+/fDNRO2xDgx8IIwQ7cbjK7O1PKXX7meqFqwgUsFp6Zf+84pL3Z5ozU2L1eBItC409WuYSkh0lAmSmXQjPsexqWdgSG9ZWaDPvn3ZzcN+9Lsntft8k/0/5wSY8qVg5aXEKSXBZUF7TOY/85ZyPbgsb8YBSEev24Tl0JYAGICEp882GGUJ4LS0IFUnatpNVwO9ick/FaBjNe1aVpCmjv5By2AhwwOL5JrqKg11t2jlurttQr98TprQ8izJTdCLl1qUlRInd1eraq9d1Y5tW3TgWodWzU01d6zlc1J0tbnX3LSWzUk1OtjywlS9WtmqmOhoLchOtPFGI7L7QpMBOKoa9A1732fONRmQQItCI6382XNNplfBrACwhwPaT49Xq7G6QjvvWa3BmATTsACeuNfoy6XGXq2eOyo6BpCy6MKP46wECGFCCiiZ7IQ0VCoPoeT0xOQfHYO3wDqgh8g0bMRiyrVr18xZCvE648SEHzcsb6pWsCtj450KixBXrlx5XSDpW97yFnMw+/73vz/exyP/fgeNQASA3EEX+3Y7VX8AhAdfVVWVJYqHU5uMNiEUzo+KE5xf8kvCpVEBIVwtUADCeeGE9blnLolQPyaJvNShLzG5RGgMcPAHRH7//hKjLT3wj/tV0zaa/THWtq8fv9G9FSRKn1w1pPmFBUazAYhc7RzRXz9zxQBHTkq85V9ca+5VVBTVjFEAwgQcYTWABNE2Oojnf/+XILG2tU/v+NoBdQ5gv/vGPrFqX5SZYPQkJv0Iqv/jN9crPhbViP82HRUQVvsRmt+/JMcscE2cf6peDyzNNRepxfkpVlEqykiwagLuVB19blU292l7WbYuN/WYpuKJk/XaVpqtzgGP2m9U60xVoxYsXq6NCzMtJLK8IFk/PnpdG4pHNS6tzU06f6lCyfOW6aHleSYWX5qfYg5XXD+crHA2A3ygPWF8oFlxf9CXn55p1OZFmXafAJK4T0g937E426ooABIoWPxu++JsE8j3e4Y1Jy1ePz/bqOU5Ll04c0rzFq/QquJc06osfE0nQqUF4bq/iSUABCDCCrkTgsd944CRiegEQqXy4C9XYraeNSy2IKaG4jtRy9zp6DM23TyDqTZQRfemarFYwfV2wAj3wUzYY/P+5cf7ncD7mGfut7/97ekYhsg+w3QEIgAkTC9cpNsypxBfDQirQYAQXIPCqU2GGhQK5xeOFSdE6GVlZSouLp7QEF5u6NI/7b1qOgMm9huLM/U7WxfouQvN+uzTl2yi6TQAwG9tXqBPPVCq49Xt+vV/PyokH2g1Xl9p8IYt/h2mlqQP638+tO3mhOdqc4/+6MdnLQODFX0yLqpaACBRowBkaNj+pIpC5YJJMfkeez5x7+smrfTrEz84LcL8HDkKvRnVj4xSsxCfF6TF66/ftkzLC2/tshRsAAJlrbqtV6W5KTp7o9PO53h1h966qkBn67us2nH4WpvZ6NrQj4yoqrXPxpgsE1yisMylcvCWlfkGALFR3n34vAZ7OvSeh7catQoK1IHKFm0rSbd8D0DM6crrulhZpY88tsPSyalKMF5FWYmW/XGhoVuFafE6VNWhTQtH9RdUyBLjonW8plO7ynPs+gAqeEadQaOyPM+2AcBSceJ3Dy3LtaoYQI976mRtp+5fkq3W9k7tOXhC9961RpdaPXY+nD8idcBPIKvaTEidRG7Eyo7NKxNSAAmr5rfaz3Q5Pk3oSydpNnQXY/URcIfRCRVfAgVnu6G5wn3Ol/bIgpY3VYt7AZt6KmMOIJmu/qNJARh5V8UBbPz88z//82wPWeT4ITQCEQASQhcj0pWJjQB8WB603o2VF1aE3vSmN01sZyGw9WRW5me727z8plN4PB3nhxCypKRECxeOLaj2Pe6Rqnb9+6tVJjxmskhDbMzE9He3Fpuw+Gdn6i2rISMhWtuKk5WkAaPH/NOrTdpT67HPjAKQsa1s/Z0vRrgvfvweFWSNAgAmkv/3ifPaV9FiAGRweFjn6rpeR8ECODDZZqW9s99joun/71dXvW737OfA1Tb9x4Eqm6xjFby8MEUDHqm2vc9oXIT6vW/jPOWlxo97KYIJQBCaA6rK8lIspZxMkrZej7YtzhGUOOpNaFjQghCiiC0vn6EKQer7KT7jirbfb16UZen1fYMem+z3t9QpqrdN6YtWKd4VI5y1sOOtb++xsSLQsaOtRVGtVcorv0sETlJFAngAaKhAoAfq7PNYBYRwwesd/Rp+bazXz083kTz9A2x09HtM2N7aM2iBhgBVjnN3cYaBFMfKmc+gL+Gana9p0oXz51VcVq4V83OsmoVIPVDw4XuxeFYCQphAs0rO/8PJd7QD0HZ8V8dDhfrkL9hu3Jtxmjbw5/A0TYcKaLfV1dVGwboV5ZjvOdfS0Y0A6Oz5lZZmYIQfLHwDAbWBdIrnAPeZY0zC8bEthob1xS9+MZBdRLa5Q0YgAkDukAt9O56mPwDCZBhnJgBIsB6oMzV2k12Zn6n++TtOOFLeCCJctGhRwAAEsfFf/vyiKhq7NTcj0YAHrbXXrRvtfSrLjtcH16TI099jgIPVRhr3H6vM3708omev9tvvoDahGwmk/ZKqNaI/fahE79u06ObHmGD/7bOXVd3WZ5oUciAIRaQBHNISR/uI0xXhep97bLnuK/ulVSuTgu8frTPQhH0sgmioQazQQ+Fi8g7FLDnOpa1l2frEzpLXCfD99T9YAMSscFugW6Voz8VmFabHWdYGNsbHqjuE6gYzgDlpCSb6phqBvoLxRl+x91KzaSvcnhEtnZNqInOyM6A3odPobazW8+fr9cCmdQYe0JK0dPfrfF2HAcp+z4gyRzr188MXtWbNWtPSxMdGWyVo35VWC5hkfKjAQHvD5Yp/A1iU5CYbIDrf0K05qXEmkEegThXqYkOP9bNrwGN0Lv6kAoO9LxURdCDQ6thf7FC/Ki5d0Na716koN90qI4ATKlpTbVRkEFM7VC3uV9yUnMkoQmZWy0OF+hRKugt/Dk9TvR5T+TwaEDQXEzFdcahaAFFAKYt4gFHn+kPV4vpPtlEV55qRTULjWYPmDiesz33uc5PdbeRzt+EIRADIbXhR75RT8gdAKP2STXGr4LZQHR8mxqzKMzkOl0a5nRU4cipCuTEpfLmi2dyGLl+rUVFOmtaXFdmEEB0FE9exAOtPTtTp2weqleySklySxzNo9D/uvw73aIbGm4td2rww3TQa/AA8WFVkVfl0bbve/c0jRhN6IwVr7FHzBiB/9MAi/fbW1ztQnazt0HcP15rOAboSFrUWcAi+iZJResio+M1NC6xK490QX//ds5dNP8IEnMbkHsE5k2Am2JmJsVbt4e/bF+for9669JagPhhgFBCFJmNxfrKeOHlD95Vmq7ZjwCodBkYyEowWhqNUQ+eA6jr6tHZehgEnJvBPnarXtrJs+zeqJ4wRQnzCCalEcL2//sxxFcf3qHTFWs3PSjL9jO2nMElVbaPH+t4rF9XbdF0P79hiVYy81Dj97Eyj0a163aTLx9p1p4K0pSTLwgYX5iSppXtA5+p7TP8BiCrPT7FcEsAHv6tsHgVW9JeKBr+r6xjQvMwEA34kqxNuWN/cpisXz+mBe+9WRdtQ0MCH793G5BCgweo4gATaFfcsVB3uYSa4s52yHUpZFxhCYLyxffv2GdFTjPdM5flLnwj9m0wDjAIWHO0IzmfO9XeoWoCTiTTGh4oL940DQHinEUb4Z3/2ZxPZVWTb23wEIgDkNr/At/Pp+QMg3ral08Vxna4x3bNnj+bNm6fS0tLpOkTQ98sEBRrWrl27gr7vYO0Qis0/PFdhNCVWont6+9U3zDx91J4VpypWyj9030ItL0h+XWgfk7P/PtOlo40jKkoesZdzrMslV6zL3IVGomJU0+7Wr2wo0vs3je2qRZghk8/JNChYP/u99SopyHrdx1u63Xry1A09f7FJPf1DZuOa4MJ6tteCCaFnfWpXqVnU+rZ/3V+lHx2v09zMRLOErW3rs5A+GqvsTEyzkuOUHB9jYYupCTH6wrtWatXcX1r5+u5zqgCEasalxm5lJcWZq9Q7VhfolIX6JemlS82Wxk6qORUdqh5UfkiWx5EKutnoZ+aYPqQ4K0mvXm21igb0OChUjM8rV1q1NKFdJ6ua9eiOzTpR2240LJylTte0m5j8hUstmhfXZ8B6/d0bjW5FgOBbV6Ej6TfwA4BgnNFwIFDHcvdSY4+BHMTvaDXYF+nnVDpIR+d3pXnJutTQbY5aD5Tn2JhjzdvUPWBZJo+syLMckIGeLl04e0aevDK9bU3RzQyZydw/E/kMwnMHjDgidoBIQUGBrZA7AXgT2edUtw0l4bc/i9mpnt9UPu9Ld5rKvvjOA0AdMOJcfxZUnOrIeLohjo81O1UWaFcOACksLNRnPvMZ/eEf/uFUuhj57G02AhEAcptd0DvpdCgdA0K8G6t4R48etRWqUHApmcj1ePHFFy2de/HixRP52KxuGw6amy/tuWI5Hjg4sXp+prZdgxQKRkYF1zHRoy5QaXHSr5d4tCB1lD5FBYMX7lOVHr1U1WuT3bhYqE2/pMEMDA6Z8PlXN8zV++6ZN+a1aOrq1zu+dsgmroERsH65q3nJI3riw5utP06DFva5py/pfD3ZE6Sgo0NwG/BwGr0kp+LTu8r0az5947MvXGy6KSwnVZx9JqI+jxoNJsQWNiMpzmhOaBZ+c+P8WwYRTgWAMI6cC2PT3OU216tTdZ0GGqpberVx3sYAAAAgAElEQVRpUbZpJehX3WtJ5/lpCaYToerDv+0sz9WZui6r+pD/gU0uyfCcF/Syxs5+PbA0T08fOK3ernZlzV+qeVmJVgU5U9ehpJgRC5wknLCyqlbnLl/V8tXr1dA9YP3hOkOhA/Bw79yzMNO0M5lJLnPoSomPMZoYfchPjbPKVFq8ywIRSUd3fkefCDcEfKApAchwDe8tzTKhPBS66vpm7Tt5Sb/7lo1KTU6ale+4I7iGkoNugNVy7kHHUYuJ6UzQXAFEVLVDQfjtz2J2Vi7Oawf1pTsFsy9kjFB9Yvz5k3cti3pOZWSsvBlE+ryb16xZY93hvmFb9B8f+chHgtnFyL7CfAQiACTML+Cd3H1/AIQH5aFDh4wT6z1hC4dxeumll5SXl6fy8vJw6K71kRcyK17TqblB3MtqNhQcJmis2N9TnGmZFKzS36rVd/TrD3902pyiilJdutjUr/b+IQMe/HhGRnUZya4o9Xiku+Yl6wuPLzPg4YhynzvfqG/sr7Jqia8Ym8oBWomP3b9IGxZk3rIvvMC/uOeqnjnXaFQnwv3Ga9lJLn1yWb8euv/19/M/vVhpdKPU+BgTXpMITnXHX4OK9cV3rdQurwyPL75wRT8/U6/FeSnm+nS0ql3NPQNKinVZkB90IGhGhBha4GK3W++9q0ifeGDs6txkAQigYv+VFmUmx5puY8P8DB2uarNKDNcIKhVicmhOXHuAEcnhx2o6lJHk0sDgsNbPz9CZuk71DQ5bxWJO+ihVC8E6nwGYsV8qLKcvVqinq1PbN91l1YcjVW1KjI1W34DbjjU4NKIjF6t0o7ZWK9euNYE64ANLYEQfAAR0Heg32C9ULI6xOC/ZgAaZ8tyz6FTI76APACvGlHsFChbVkqHhYQ16ULSM6lu4txHSY8nb2Nqu4YYK3btlk1mpzkbz1l5Aw3FE7ExIHRG746g1nRavoST8DkT0PZPXCsMVqrQO3Wm6jg2IoCLiuKqREcPzMTMz08IPuQ+cBT9sigGmq1aNml5A6+K99o1vfEMf+MAHpquLkf2G4QhEAEgYXrRIl0dHwB8AQVx54MAB48SyQhdObd++fbZShGAvXJoj+n/wwQenhRPNRO6rL13V7vONgnLEBBCNAqvcCH7/z0OLNS9rdIWY+wHuMS9k5+d4bad+UEEuxogSYqJ0pWs0J4NJalRUtE22cX/KSYkzhyIC4v7jt9bbqrjT0Ff81S8uGoWGCTn5DayAN/e4LUkbN6M/enCxaSUCbWhIHvnqIV1rGc0G8W1MvHeV5+qPdxbp5NHDtvoLKKLh5PSJ75+2CSsT3F63x9K1fSsrnBdjxe+hA/30w5tuHgah9tdeumrnj7CeSfL19tEVfrQqOD8Btjinrv5BmxT//s4SvXPd3DFPcTIAhMrHz8406K4FGWroGnWjevZ8o/XJEXpjxdvS5TZdyMDQiFUNAKMbFmSYfoLP7LvSYpN76FYARQAFgnEcqZxtjla3WwXF01anptY2ve2Bey3QEEDAPZGdEC338LBO1nYpU106dbla73/kPl1p6jGhPhkkUKdWFKaaXmbAM2S6E6pD7INkdiZe5IAg/geQ4J7GvgkoxOK3vCDFxppriO6oodttmR4AWSoh3NPcV3mxAzp/5vSs5k2Mpb1wJqOOiJ0JJiJ2JqJUR3iG8f/BatBqWeQgVyKY+51M/yYj+p7McQL9zLlz5wQYWL9+faAfCcp2DlXPyZtxLJ65B6BwQdVbsWKFHQsgu2DBAn3nO9/Re9/73qAcP7KT22MEIgDk9riOd+RZ+AMgTDz3799vSbWsyoVTe+WVV8wa0Xlwh0PfHdE/GpCpOKeMda7PXWjUl/ZUml0pAmImlyOkgfe41d7r1qr8eH1wZbwBD16KTuMFCAC93h+rbx7vkKJiDFycuN5pORmsYrOCh8CYv+NExOozf/+nd6/Wmnmv1zpA9fmXfde8VsJHg/5YMUfgHYhNrfc5rv/sHgv4G69BifrLNW7t2PFLAMKE+P/85KzRiphwX27sNptZmnfIIYJ3wAcr9FRBTvzfHTdBErQqXLSYINM4b8TfTNDjXFFKTQBo4T41ZBNiAMG3f3OdOUKN1SYKQBh7NBmIrsnEQLANINhSkm2T+tzUOJ2q7bTqgjPRByAdrWnXIyvydfL6aCDf0+caLA0dahMmUdCZmOQTIIh7FNa10M0KMxLNuerE2Ysa7m1Xe9oiPbQsT/VdbuUkx+p6a5eqWvu1c0mOnjtxRXGd15VcvNrGb+280eDBlXPT9PzFZgOsC7OTTMQP+CBQcH5mgt2jo2AlxZLmccdCw1Ld2meUMEARjmP0Ce0I/Uf7QRYLFCwoXXy2q73VaEcspExUBDzePRXovweivXAsXh0w4qRxO3kTrIxPtf+h5Dw1VdF3oGMf6HY4PkKVcvQWgX4umNuxmOJQtRyLZ56tVD3QqEApvvvuu/WjH/1I73jHO4J56Mi+wnwEIgAkzC/gndx9fwAEEd3LL79sDzxeguHUqNwwcXZK1+HQdxxYKLlPl+vYH/3otF6+3KLCVJc0MqyhIY+GPENGW2kdwJUqWv9rbYqWz329A5UDhnC/+vQPz5i+gKrGsep2Ax1MZKNY7R8asQkudCNoRljsfucDG2zC7duYnB+vadc1Qv8UpbL8ZHkGh3WtrdcoQItyRysU47XPPHFW3zt2Y7zNbv57YsywXv7EppsVPSa9nBMgbDQUr0s3Ol6z/vVKZAeAMCN3ktH3f3rb6yhrCLO/c6jGJvlQwrDyxVqY6g7VByaX0KCYbH9qV5lpLG7VACCsEAfiiMY1cEL1qFJRVYJCtbM8z6oBVDMQa1MRIOEcIwEoUNDWdizJMfoV4IvriQsVlSiqZdjtApruLcnW0eoOLchKvBlWCAgDyDIpOlXbrk+9c5uBClLKz9d32n1FXgfC94SBNj1z/Joe3rbhZvAgQvP9V1q1pijdbI4RpGPtu7+y1So4ACCuDaDj5YpWq9BwP3G/AEL2XmoxcIHuhHNH+L6vos0E/gQNoh0pyU0y6pije5hNADKZPrAa74jYqUbTWFRx8kYmI2L3TvueCc3JePc4FRlC9UKhobegIrV69epQ6I715eDBg7YYBRh97LHHbKEHIPr2t79dn/70p8PK5TEkBvU27kQEgNzGF/d2PzUedqy+eDdegHv37rWSNC+9cGpoVxD5OeK9cOh7sFzHAJOAR2/6VEdnl/7huEdtA1HKTYQWFGMvthhcqGJi1OuRcf4/8UCJ3rQsf8zh+vGJOv334VoLgoOu1NYzaCvlTGZY+UdTwOSVzAYC+z7/rpXjDv0/7L6sf/v/2TsPMLvO+sy/t03vXW3UpZFG1ZYsdxsjV2zHYHDCAgskhEAIkN1NKMtCgGyAlM0GsiwQCM0JWZopNsZV7pYtyepdUySNpvd+59Z9fv/xkcejGelOvXfM/Z5nHkmjc8/5znfOPed7v/9bdta9TvQNkPm9DaVavzBP160oHLcqsul/7rB+x96i+tn7Nmj90uFzBBj8z4dPGA0Jpysm52gKRjawB2nobMsKPpS1PZ++YUyaHBP+Mx2AKsL+gmZ/CxhgjK5dVqj3XFWudZdIQefYsVoyoylxQvV2n+kyOhxVC3QQTOChwgFQAIxMxmta+0V2I5QyxNuADnQrUONIZwdktvT6TT8C9QrR997aVqWGetTtj6hi6UK53F7Vdw4a5ezIyRqVpw5o3qpNBs4AcnnpXi0rSLWqCqDhQFWdXD3NunP7dVahyPC5DdxAv8J963THsFicagfVDMANgITfEeIILYxqXW3bgDmJQbXjs9xrgA+AC9esvCDdqjtoRwAp3EO0REjcnmofWJlnRZz9sELO8xoA4ojYASaxAArHeeqmm26K/SszQ1vi+Mc5UWFPhMbiDxP89esv/cyarf6ykAbgwM0RS94f/vCHuv/++40qxvsaivGdd96pL3zhC3POKGa2xvB35ThJAPK7cqXfgOc5FgDhpbdjxw5t3rxZpaXjT0oTcTj27NljL5N4ltMnOi4IRPfu3Ruz6xgTYl5Eo7Ua0Kf4PxqiWydL43NPtelcd1DLS7IumKww8UYwjNXsTavHB5tMMv/fnnN64lirTXDrOgYUftUBi1VrRzuBIPmf7ltvtKqLtS/+5pj+fVf9RbdhIoxe4hO3rLxAG7L280/Y8WNvUa0pzdQv//S1VVcAwj88fsomtpk+l2raBw1oOA0NCY3f8dc71pfqH99+8UkKgv2P/eSgjjX2mrMUn2MSvWVJvr523/pLBhHGAkC4FiSbb16YYxQlxhygs6Qo04AGlZiyVwXkTPpfPtOp1SXZRskiiO+pk20mPE/3elWak2oOXfSXz/P3tSVpevaFZ5XXfUyZwQ4VpQTlyirVXt8mzV+xUX2BiFJ763Wkrl0LVlQaJQsouKIoXS9UtRk9ChDQ29Gi3uZzSilfr5xUgO9w8CD/B3iCzke/F+RCC3RZ9YL/s9/lpZv7GEADAMUkGwcsDBNwG6O6BJjKSvNahQa6GH8iWndaIgivp7MPLDA4NB0qJExEWWxxwAhi5tFJ7M5YoDNj4v+mN70p9q/MDG05k65Tk+nyvn37zA48kWi7UKDnzZt3vtLBew3wyHuZqtiDDz5oYcFUSmIBoJMZl+Rn5sYIJAHI3LhOyV6OMQJjARDcWZ544gmjMWFpO5caE3nOacuWLXOm20wmeMHccMMNF7j1MMmgojEabDAZoSEodYL7HMDBnyOFpljo/nxfo9GAmPQ5DXE1q8usIP/z72+4pBsWn2vu8Zvm4bn9J1Td41KLf5iCheD66uUF+sA1S4zyc7HG/bXur5++pJUuk3dWxd9+2Xx94a41r9vl+r/eYVqL2FtUi/JS9cR/uf51HyFk70e76mw1vq13SPVd/gv6RT8I73vwT6+8KIAgffyu//vSeYvZkfoRwAwai599cOtFjQYuBUAc8FE5L0sPHmrWtcsLrCoFjWzP2S6r0jB5p0pBlQSQ9aZVxTrV2qcN87P1ywNNurw8X8FIxJy/CF481+nXlUvzLRF+bWmGHnz4QW0afEluf6cyMzINoL7Sla4b5kV0svAmbbjqFv3smX3q6unTfTdfaYGF2CvjCFaWBRUvxcYw2NWin+46rfvevNVAHFWRjBS3njrZbkGF6G/oA4Dl6VPtWj8/x6o2UPkAEjtOtJkIHQAHnQw9y5PH21SWm2qVMao2aEjQfBBCOPLe5iJP5+Q/9vvs9VvOlPh7pKMS1RFE7FQ2HRE7f458BuC0x73FMybebbZcp2I9TyznWbBJJOMSKNDkWS1ZMhx+yr/f8pa3mKYpXpUa3kH/8A//YBb9vK/QFb33ve/V97///ViHOrndDIxAEoDMwKAmdzk7IzAWAGEV/dFHH7UVoYULF85OR6bpKPv37zdBIfqVudKgI+zevduqNkzORwIOJhY0J1NjJNjg74hTL7UChuD68w8es1RptABM1LA+hTbDpPBtm+brD69ZPKHheuLZnXq6QXqlTerzB22SiPCZHA84+hdrX/rtcf3gpXOXPB5EmohruILwm49c+TpXrff/4BULtou9RXXvhmJ96d5hX/2RjUk9WgloS1gN/+SVBh1t7DFqEWN1U0WxPnvH6ktWL7Dl/daztTbZZkUf7QcNoMckHjD1d2+r1FvWl43b7YsBEChu+851WxUBi907KkvN9Ylqxv66bgM45LQEQxGjNQ0GQrpqeaGBEFylnqtuN8E4WhfE/2h6UixAMMfE84i/n9pzSHf0/FhtvYNKL1qspqFUNQ/5dHNhu/aeadW6edl6svjd8vcPKDMyoAWrNhiARfhOIvlQIGiVn8wUr3720kktc3do5cYtVtng9ziN3VFZYu5jAA0qLrvOdOv2yhIDfwQUgl6eOdWuW9YWG52N61+Q4dWvDzYbLY9xpJqDAxYAcmlRpt3Ho9tMTf5jv+dkkzRclpj4z4TBBH1xwu8cETvPD54JVESc6gj9IG8IF6x4t3i5To133jx7eZYmknU7FOilS5eqvHw4mPXxxx/Xvffea9qr5cuXx+USok2jT1RmoGc/9NBDSQASlyvx+oMmAUgCXIRkFyY3Ary8mLCPbgCQNWvWnH8ATm7vs/8pVoigIiUKv3j0CDDeJNy+TqfR3f069ym84EdWM/g7eSzj0StiGWU4/998rlaNXX7TTjCJYxKKKPr9V5fbJC/Whv3pH/3r8zrTE1FYbqPDsNpOQ9T8pXvWmhZhvPbe77+il2ovDR68aEzc2OBK/237Cv3RCJA0EAhqy5eemQANK6qX/8vWCbm6Ac4nMuZ3fn2nCbJZ0XfAhzMGoUhEDBEBfd9773C68VhtPAAC+MACl0oTQOnqpQUGKKkiQLlaXYpddtSqETiRAZxIpj94rtuqB004RC0vtEk+2RkAFITeVE4I8+Manu0Y0I3BZ9Vy8AmF85aqKZStFHdUl+f1a293pkqjbTrSEdW6y65TXbRUVU3dunLLZgMyVFlwVOsdGNRAMGpOZxWZA3rlxFlde9UVau4JmECf5HJAE5Ss+u4hSy/fXlE8/Ls0r/27pm1Qd1QWq77bbzQrxm7P2R5LOAd4IIJH9P5idac2l+faeYzVZmPyf6nvDAYTcPgJdZ3IvXSp/V7s/1m0GCli55nDQgXVVLIu0JBcatFiKse/1GdHp3xfavuZ/n9oTIC1RAmv5Xo99dRTWr16tRYsGLbshnL1rne9S2h54sVK4L3FfUWfWCiDtpasgMz03Xnp/ScByKXHKLlFgo7AeAAEChYrLax4zKUGL5bE4URwWOEhPZo6xb8d0T8rooALeNzQRag4obnhwT4TjbyIXWe6DISkpbh12aI849czQYVLH2v7xjO1+tfna4yrX5Sdfn4yg4sS4ATx8LffvdkE3GO1v/jZYT14qOmShwOAsA8qER+6fqk+dtPrV/5ONvXoHd/ZY+LrS7Uby0L6yh9ss4nGTLU3/ePzRr9CYD26UQUJhKMmRP/5n4xfnRsLgPAdffJ4q9GO2A9g43hzn5kB5Kf7VJiFra/LqjbDk3GXZZbgfFaQ5TPgQ3WE6k5z75CyjQrl1aL8dL18ukO5aT6jPq2dl6O2l/9drSf3yFe8Uj5PVGuzBrWnO1OofCLhsBYNHFHG+jv1UMdCBQYGtHJNpdYvyFWvP6TG7gEFAkEDuCScv3S4SrVnG1W5YaNC0aguX5Sr2vZBAxS9rwZIXr44zxyuuMbkfgwGwmYpTO4IfXJcu65alm/HoGoHICWZHcoWgvTxWiIAkHi7T/GsocLK6rVjsQ0AccIPYxWxT+d3ZnTK93TuezL72rlzp1WKEHwnQmPh4+mnn7YFQKoNtB//+Mf64z/+Y9N/5OaOv7gzW/1PApDZGulLHycJQC49RsktEnQExgMgiN0IPopXuXeyw0V5H6EmoXOz1RwKxGiwgVDcaVQwRms14B2zEglgIr/kqquumpWXC9oJdA+/PNBoq9LABCaC79lWbranF2tMCu/7l92qbu1VYbr7As0KtrSI0hFcbxinCtLe59fVf//8JS8PImT0JbQvv3Wt7t4w/DIe2aAefePZmuGwunBEQ6GoCaKdhqPSR69fqCVDtdq2bWYByL3f2qUjDT1WpWDlfmRzKiDQuf7vO8e3+6ytrTWuvmPDy72Fo9bWJfk2+V5RnKVdtR1mYVuUlaoUnKyGQqpq6deWJXk2MSeZ/dcHmrR1SZ5Z7qLJOdHUq27/cKUE7QTg47eHmyyrpccftm0IUazf/7jWtjys9qxVqsyP6InWXBWlhJTvCyol2KX8QKOezr9P4fQi04Dc/aYr7fiIxVcUZ6ixa8ByOTAqeOnYGbn7WrW8cqP9DqABsIDqRb82LsjW2U6/gbaSrBSrbuCGRXWGSk1WqsfAZeX8bPUPhXWqtd8AM7iWlHYoXBdr8ag+jO6P4z6F+DueVQfsnQFkrKo7VC1HxA4Y4QdwPlM0sZHjQpWalihW6aMF35d8MM3wBkzun332WVVWVp43gfnBD36gj370o1Y9Z8Eq3i0JQOJ9BV47fhKAJM61SPZkgiMwHgBhBYZSb6KUpWM9LQSOVBNmius8kj7lAA7+ZNWKBtWBtO2RYAPwcbEXuxP8ONMTZPoHgPjkA0f0XFW78e+ZLLOijHkWFJjP31mh7WtKxh1uAMY7vr1LnX1+5aV5LrCARIgNaPj8XRW6+SL7efd39wj72PEaAm6n+oFQ+fGPX6P0V+1Vnc+Q7P7t588I5ym2ZWKKtqUkK1W3VxbrA9cutUkf1+f555+f8VybH+2u0988fPJ8SvxIDQjVD3Qh3//Pl5kj1ngNAMJkkUwYvpu4XVE1Od7UpwV5w3kZG+bn2rliowttin1jrcsEH33IjpOt+r0N84wOtrQw3XQX+Zk+o1tx/dBZPH2yXXeuH9aQYGF7sL6biBhtSm/WmRd/prWuWj0QvEpb8/ut0uWJhpTaflRPRy/T9tvv1VNHm5WlQZWv3mAC95tWFetQfbcqStJNFN45ENJ8d7dePH5O733LdRZmCMDYsjjXrHMBJEcJD+wbMtDL7wAfhA1Wtw1YtQRRPMGKVHpeOt1lFQ8oZ9j94oZ1qTYT1QdXX5Nc/a2S26NI7mIp5eKGC4niPoV2AODBIgeNe6u7u/s8VYvFEp5R5D5RDUDEPlOVWHR6HCteYurR981owfel7quZ/n/eMYAiABrAkPbNb35Tn/nMZ8xsYLaofBc7zyQAmem7IPb9JwFI7GOV3DLBRmA8AMJDmRdRIgnzYhk6LB6ZeMC5nkrDZWpkRcP5u6OX4SUwGmg4dKqJHnc2gx9/ub9BX3rkpDlIMRF1VmWH6S5hc3t64E+uGFdwDY3rnm++rIauARWkupSekfG604WCBahBbH3l0ouHWL7ne69o1+mxtSCWMSJZNeWf3rFeN6wafhE7ra1vSB//ySGbgC80y9bh7AfOA4EzdKW/urPCJu+zNb6A0Hd99xUTRlO4cWog1HCoxNxcUax/+v0NF709HABCBQTwUTkvRydb+uzznBdhjf2BsAaHQqbroAqC/WxNW7/perAURmiOLgNAeay5VxWl2aYJoYKCGP50e79uryy1bYqzUg18LMhNV3lhhqpbelVS/7heOlqj21IOqNM3z8Irewb8qvEt0x3bNuhI1tXqbqzR4foeVaxdq2uWFZg17pqyTD17otXuKzRAj+w5oczBFoXL1qo4K8VSzKmUUPl4vrrTKhxUYPa/mrS+72y3ndv1KwttO2hkVFIANDevKbaMEM4JN7dY2rQCkMFOeasfl7ujSq6hbsnlUSSjSJF5mxXJWSRPy2Ep5Fc0s1jh+VuktGGaDO5TAMqpPo9iOd+LbXOx7A3eAdCzACj8OCL2vLy88yJ2dGnT1XAqZKGGFf5EaKMF3/HuE2AQWhhZVk4Q8P/+3/9b/+t//S91dnYmAUi8L1CCHT8JQBLsgiS7M7ERYMVldIMSBNc0UV4SsZ4RK3289GP1u3cyNUaKwgEbTFqdBmd6tCh8OoWcvPwpuSMQZeVxJtsH7t+nl2s7lZ/hvUCjAc2FxsT9zos4NX35kZP66Z46pXmkvOzXAAhC9NbegKWb/9v7t1yQ3THWeRGE95VHT5odrNsVVV3HoOq7AzaZJtDw/Vcv1voFORd8lGDEbz172ig5o3UAaFEQY2Pf+5Ebl9nkarbGlzH4/EPHRXWGyTQNsf+9m+fr4zctu+TkAQBSVVWt4oqtNmFH1wENCZE4FQzO7Uz7gLlK5aT7jIqEwUBWmkdDwYi2LM43uhXbhaJSef5wnkZN64BVTfwhNBYFVlEJAywGQ1pUkKGizBQTozPu7b0D2qYj6j5zUH193eoNp2govVhXbVqvY9615rT1/L5j8oUHddd1l2nnqWalRf061tCjkrSwKhaVqDmUIbe/S7urGvV7N15hoYFkf2CXe7C+V8uLMsw9iwT3FUUZ2l/fa8LyynnZlgeytIhsj77ziewI7rNSPCrOHltwPta9NW3he8EB+Q79SJ6GfZLHp2h6gRQJydXbKNdguxQJ45YgVySoqC9T0ewyBSvvU7j8GnsWJYL9LQsz6AdicQfkfeDQtJjw8ozk+efoRqjoToVOlmi2twi+V65cmTCOj7x7EMbjiggIpH35y1/Wv/7rvwpaYbICMpNvyLm37yQAmXvXLNnjESMwFgAhiZUXTaKUyWO9YBezMaV6MZYo3MnUgHLgUKec6gZ/jvTTj7UfE9mOsjqUt9lInr/tay+qoXtwTAoL1YOBQEQfvn6pPnjdsP/8WI2qwwe+/7Ka+8NK9XmV6sViNSJ/IKz8zBT95S0rbYV9so0qC/QiJsPjtW8+W2vJ7GgZxnLwomrw5tXF+uLda2YVgDj9BYgwoYd2taI4dgczAMgT+6r1n+96k16s6bAVfwBMbobP8j4Y+4qyLAMlBBA+cbzVqEut/UFtWpir3ac7FVVUpdlpVhUiQRzHMfqAe9bmhbk6UN9t9LuizFQDJ0zqd1Z3qDgn1dLs0YNAl6pu6lKRp18DIWnDsgXaf7ZDTR29UnBQnR3tKvYFVdMzfMbcByV5WSrOcOmVM13yuqJye73K8UZ187VbdKI9aGYHUKhwSpufm2rgIzvVay5eCOnJ9CDNHHDVPhBQmtdjyec4ahFKSVVrIm266E+ecy/Le/TnktunaM6wKxHN3bRfnvpdiro8CpdukFKz5Rrqkbu3QZH8ZQpc+TGdHswyAfhMUUJjHY/JZm84InbcjxCz86xEu+aAERapJgpGEsn21nGcotIfL3ep0dcQTSA5GyxI8T6ife5zn9MDDzxg99JExzvWe2Qi2yUpWBMZrZndNglAZnZ8k3uf4RFgYu4kaDuH2rVrl4ndKAPPpcYDmtU+bHhHgw0HaPEAH0mfcv4eS6bGTIwF/WIVjhWvkpLx9RfTcez7/mWXUW8KMn0XvMhs1dxS0VfqnVsvnv/y4MyurkUAACAASURBVLN79OMjfWrwe43OBVhgQvy+q8t169rJg49Yz/EHO8/qhy+dtYkrmRMjG2AIPcQd68r06dtWWWo8NAvCKR1OdazHme3tHtl1TIH2eml+pdGYCBSEPkXCOX+nKtLWFzAnqxeq2vWWdaU62tSn9fOzDYxQJaEyAoUNWdL+ui7LMcE1C/Dx9MlWCwqEageIIdzvt4dbdO2KQtNjoAepa+vR0XMdWpYd1ammbs3zDepA44DleMxLlyIp6ZqfIe1vCWv96qVaWpovl8dn1Y1HDzeqMN2raKDPLEPTI4M60imV5KRrSVmhjf+Kefl6oQYKltfyPciTJNPjUEOvAJ/QtfoCYauGoAmh+jOe1e7Frs90ARDfgX+X5/RTipRtskqHtZBf3urHpN4mAx6RguVGv7IWHJCns0ahVXfpZMkdVgW57rrrZvtWet3xsAJmZX0qAa1QDKmIONUR3hss2jhgJFYRO+8WVvYTQV8IoOLZQAhhWdn4+TyzefGoVEFTQxPIIiDtE5/4hL0juI5JADKbVyPxj5UEIIl/jZI9vMgIjAVAKJPzoGNSnKgN0ET1wKFPAThwwBpZ0XEyNUaKwqFPJUIZ2xlXVhmffPJJA3sz/RL8l+dO61vP1VpOBavjTsPetWsgZEGFpHWX5lyc833gwAEb+8KllZbXwEo2gXZULmajHW/q1f/41TF1DASMZuS8lLkncFGi8vDnb15hOScOAJmNCtNUzh0tRkdzo146XqcP3XODhfAhJDndNqB5OWkqy00zG10qVec6B3Xr2hLTXhAy+PLpTm1bQsJ51AwFcMPi89DYCC8kUfyZU23auCDXwgcBmy5F9MLJFl23KEWH6jqVJb9RvgYDQa3Klc4NeLR+XqaO9KRoeUmuVszPV0/IqzXzc/X13+xSeUZIV23dYiJx+vDAvgZdUZ5t1wINjL+9Xr/Y16BbNy9Td1eHWto6le8L62BPqjYuLtTyBSUKuVOt4vJsVbsyfB6tmZel2rZBq3ygeeE6UjGZTJsu/YXvle9YpcMAyKvN1XNOnjPPmT4GtBfJX6po1msTWHfrMUXzlur46j/TuabWWXXlG2uspjv8j+8ZK/UOGIHmyDMVCqnjqjWeiJ3qOttBe4p349mL3hEL9Jle/In1XHmHIdTHMIBqE+1jH/uY9u3bZ79PhJasgCTCVRjuQxKAJM61SPZkEiMwFgDhYcfq0FRWzCbRlXE/4iSEjwQb/J3f06BJATKY/PAAh+vMv2fKyWW6z43cFVxPZpoGgAsSOpDqtn4TSUOLwQULSg7ZEO+6YuEFeRtjnStWmkzsWaWLR2MC9I9PVFs+Rt+reRiAKug8brdMC4GjFzSk2aS4TXYs9tV1WYJ5fWOj1NWgzduuUUvPkOV+UK0AGJ5q6bPKRjAU1RVL8ky8zQSda4rlMRWNzoGA6Tq4rgi899Z1KzfNq5qWPq0q8Kiju0fNnT1q7exVa49fa/Miqh+QUec6w+laUJStDYsKdbpXWlGWp711PRb2BzjALpd+7DrdodJQi7r7B7Vy7QaletzaWduht6wrUUvXgIEgjv+Ll05qdVq31m66Qv5QRFkpLj20r04VWUNq7+gwK16qJicHs7RtZZmWzytQVeuAaX521nZqcX6a5ucNT8Am06ZLf+E99gt5Tz2iSFGF5B2mgbm66+Q5+5xpQeRNH66ApL/mbuZuO6lozkIdr/iozjW1xR2AkI/EZHvz5s2TGcpLfobqihN+CDDhOQw9y0lidybS7Ah9IXlHiWDxPpbj1CVPdoY3ANSRlYKVvGO5SwYISfaI0+PZ/s//+T+mJaIa9ld/9Vd2P73tbW+zLt19990JY60czzGa7WMnAchsj3jyeNM6AmMBkHhNMHmwsZo2UhTO35lE2ouflftXMzVG0qiodPB/ON/Q95tvvnlWPO2n40Jwzo899pjpbZzk2+nY73j7IO8BIfnes922ms6kljC6d1y+wNLGL6a9cPbJC5KKk2PrOZP9HW/f0HV+8FKdnj7ZZhkXrPxTibmsPE8fvG6xUY1os0lxm8w4PHWiTdlpHuu7v6tF+47XaHHFJi0uzLBrQd4FE/zlRcPaDCx3n68erhgAsBCiQ4M72dxnlDS+KwsyInruZKsiwUEN9PUr2w2YkVr8LuVlpSslPVNblxSoJeCT25cql2fY2hYK176zXUr1uS17Y0VJpmkxatv6FXVJ3QRNlufplQOH1dI9oJUVa9XeHzQKV3vfkLr6SEIPq6U3qIWeLtWca1bF+k1mFYyW4/oVBQaUmnv9Cgz0aXdVk+a5e83mtzmQonWLi1U/lKaKhYVaUZI1meE8/5mzZ88KTc0NN9wwpf2420/Kd+j/ydXXrEjhKhOia6hX3lMPyzXQpkj+EkUKV5s1r7VwUJ7Wowot267j8+5VY1OTrrnmmin1Yaofns3wPycxG0DCYhCLBTyrHTBC9ZSFlmXLlk31tKb8+bEcp6a80ynuoLm5WaTFoxty9Ifvec977J1IpTyebcmSJQaExmrf+9739L73vS+e3fudPHYSgPxOXvY3zkmzMubkWDhnxYoZD7yZmmDyUnIyNUbb3Tp6FDQZo8P7eJFdjD5F2BZlamxM50L1g/HmfB999FGjASxceHHtxXTeddWt/apq7bMJJkGEcPJjbTN9f8TaD7bDkvdoY69NsBFbL8x//ap5IgOQl2s7TFyNvoK8k2cOVKn+XL3uu/16kalCdWH32S69aXWR5XqQMv/gwSZLNo9EI0qJBlTf1q2TDV1amBbQuY5+zUsLaW+7tCDbq7zsLJUVZCs9I1PV3dIVK0rU3Buw/QA0BkMRLcpLt6oFInAyRLC5zfR5lJuRYoJwhO2OABxQhNvWwzsPKCUa1KqKtaqcn2MC99q2PvkU0VA4anS8A8eqdOxsizZv2mji87XzsgwooetgsYDf4YaV7nPp5VNNGujpVGNrp7I8Ic3LSbEJKz/oBSZDmWSixM+UBeDRqOk9PHU75eqtlzxpwy5YnTVyDXYY9SpSuEJye03/4e48rWhWiYKX/7FOBkrFhPLqq6+eyC097duyKMNzZuPG8UMwp/2gSGVCIROvOyJ2p2JNAjsVEKokk7m209XXsRynpmvfk93PWAGab3/72+199tBDD012t8nPvUFHIAlA3qAX9nfltMYCINOZKM5LZ2Ron1Pd4Lg0QqnGEoVPJvGVEEIEfNjwAmDmSgOArFmzRuXl5XOiy9wflOLjPbGKZbCo8O3YscPoAlA/EqWhtyjPzzALYuyEjzb1yjPYqc7Gs9q87Wr1+YNq6Q3oxlVF2lPbpuLUsJ441qJ1+RE14EYVGFTjQNSAV2VpunqUodVludrVEtGt6+bLH3abexbWyGc6BswV7GBDj4nRnzoxDDQW5mcYbQvw8YsDjWbRS1UMOl6az6Udx9usuoHwHWCH3mPP6S5lDTZacvrbbtpmnyezhP2ebes1cNTrD+mRV04qJ9yj5Ws2aGlRhoGsV84Oa1aouhVk+ExMv7MGW2if0bukqHLcAdMW8F0GPDpCZzj6CJ1jnbBiSEEVZMoAZHiVQO6Ww/I0HxRhhDhfRbPny918QJ7O03INtA6neXpTFMmar9Dy7QpV3qeq6mqbfGOKEc9G1YFxi6erIYtcPDOcvkDxZYXfEbGTeTEbSewjrwPvIly5oBoDihKhOfbRvMMcbdudd95pYPxnP/tZInQx2YcEGoEkAEmgi5HsysRHYCwAcuLECVu5m8jL2wm0Gq3TgFLlNCdTY2RlA37wdDl78LLHwhDaxUje8cRHZXY/AQULVxhK3HOhTSdAnenzdQDIbIj8Yz2XY429WpCXZmJxKh1Qq5YVZ6q54ZxeOVarhYuXaXCw36oaB871yh0OqHVIWlfoUdCbqczMDPVEUlVenKO1i4pU0+63yfzhhh5zITvXNWxdi9bH53Zr6+J8E6NTcXihusMctqhuACyw+n2uql13byxTY/eQ0rxu9Q2FdKSxR3dvmGd2wjicYQFMGOBtlSV64OlXLPMjf3GF6rv8umVNiTluLc1PUX3XkGraB7TY2639ta2668YrLBOFRHZCBlt7hyy7heM+dLhFW8pzlOLxWEWEbBCn8TzhWQIQAZBAl5nIhBUAMiMOVOHgMN0KR6yQX576PfI07ZdCg4pmFCm8cJsiRWtMnH6xAMBY75Xp2A5NH0COKmu8G5bj0K+obDkidioRACRAiCNin8wC1ETPjTR4DFfQDLIIlghtLOogFf3Vq1fr/vvvT4QuJnwfRrt6Ttf8IhFPPAlAEvGqJPsU8wiMBUB4cWJjOV6gH5O60ToNqhwOlYuXx+jwPh7wM73CBecYm0dsLx0Lw5gHIo4bIkKHkrB06dI49iL2Q2MHCbUCoWSit9l0GYtlLHDwQrdR19GnM83dSteQZWsEBwd0uLFXOT6SPKQVhamqGUxTSV6m0tMztWlJsXpDHrPLJRkd4fiC3DSrPlBB6R0KaUt5nhp7htTrDxqwyUtP0arSLAMfmSkeNff4tW4+tBepuXtIgXDEQBBJ86SOc2CctjAluG5lkYGPgnSvTrX22zGvWFpgKeU9DdU63jKoDZUVpiXBwWtpYbpeqe2wIbh6eYEe231MXn+nSpavNwH7LWuKVdM2YMCDnBSseO9aX6LuwZABFCyAx2tMKJikOmCEv/MswU2Jygh/jn62oP9gNTme9yiW4FjXxsuswRnPREofpxrJZHqk3o1FKkfEDiigAVCc6shMLSZxbQBnVKhYHEuENhZwRkNEH//lX/4lEbqYsH3gOfFGBhtjDXwSgCTs7ZjsWCwjMBYAcQL9brzxRqNPjdZpOFa3rFqNDO1zKhvxoj9R4sfmkQe2E+IUyxjEexvEhVQ/EsEZJpaxmEyFLJb9zsQ2UAABePDf582bNxOHuOg+R9pFHzjTprTIoFUqgkNDKrIFf5fSMzLUFEjV6ny3qhs79J47b9Ajx9q1fkGupYGXF2TodFu/WvsCpnNB1E0I4xPHW7SimGDCsAENaFFnOwfNmjgYjmp1aZaer2pXVppXKR63SnNS5XW7dbihWzlpPgMgGxbkGjAhPZ7MjXAkqs3leSZqR+g/FI4YeFkzL8f6jfPWnoPHlOYK6d7tVxsgyUr1qKFrUBk+aW1Ztk4096uj6ZxONbRpXeU60xiRzZKe4jHAw7FuWl1k4YoAJyhgE2kjwQjPJscC1hE6UylJBADC94QJdSwJ5BM5/4lumyjp47EE/7G45YARAAKLWiwmOZog3jfTNclkEQVKGFRSjEwSofHuRQfiGBcwZliI33777fra176WCF1M6D4wfpguOBVT7h1+AJhcY3RHixYtSuhzmEjnkgBkIqOV3DbhRoAJGj98YR2ggZibCgcPeqecySrUaFE4X+zpehlMx8BgAYnNI+J5HjRzpREyxUNxxYoVc6LLTKy4R6bqMDQbJzubAITJ0sjKIPejYxfdMIDbmFeNwXQtL0EcnqvU9Az55VXnQFjXLC/Q0/tPabDlrAJla3VHZZnlfQA09p7tUlqK28AGtruklz92tEU3ryk2WhRZGkcaejQQCGvjwhyjUpGYjmAdkTiaC0wGqGIASLDxpVJSOS9HdR0DRplCOE6lgkT1ww296h4MaEkhzltBrZ2XY6J1aFKAmENHjmleRlRp81dpMBCxYEvAyvLCVJ1s6ddgMKK2pnq1dXbpnbdcbQ5Y6EKo7SBix8kL4TrVD0IIp9JYPYfKw49jAQuVh8bYX6oC4uqpF7kdrkhIkdxyRYorXgscnErHJE02gXyKh73g44mSPj7R4D++u1S1AST88G8WtxygOVmDAmeA2CcC/ZGWt9M99hPd32jaHu/fyspK/af/9J/0t3/7txPd3e/M9jx7H3nkEX3xi18UJiksQrBQwT03si1evNgWJ/j9TDMyZmPwkwBkNkY5eYwZGwFeklVVVee/qHCF+eHFTkIs4jxWnRxLwBnryDTsGAD1/PPPG+UBwepcafCioSQkQjhXLGPGSxJ6CxWyRG+8aB5//PFpz1lhpdYBGM6fvPAcwM6KG98dQHtrwCdfWrq6h6Im0ga0dw4GDUxgp0vC+bGmPnW3NenFo2f0l3+w3Vyv8tJ9OtzYrWVFmWYr3N4fMLEz2961oUxHGnstS2NXbacFFQIY6jqHgwtJRieskM8gKoeWhdD9znVlOtTQo4rSLKNOAVquWlZgoANg8OypNtt+zbxsnWkfMACz43irctK9Vn0h6NHfVK099QPaWLlGK0syDfCsKsnQS9VtVnkhUHDnwVMqUK9KV24w56uK0kw1dA8Z0CGvhaBEgNN0NiyIHQG7Q+XhOQBNi0nr63QFwUH5Dtwvz7mX5RpslysaUSQ1V9HCVQpc9oeK5iyYctemI4F8yp2QjJbKggzUp3i2qQT/OSJ2pzpCFZ53EvQ7ri2gc6LvKCh9TFZHWt7Gc3w49uiqGc8TKuMf+chH9PnPfz7e3UvY4+N4h1aG5/2nPvUpM3RhHsN9wn3HD89nQOs999yTsOcx0Y4lAchERyy5fUKNAOVeqEsj6VPkaVDGvOWWW2J2nUmEkwI0Pfvss9q6dau9mOZKo884NMV7ghDreAFYEfiOpxGKdT+zsd1UAYijP2A13QEa/N2hIToubg7YGA3YEZy39Q9Z1gqVCwITT7X0KivVpzSf28AFVrdZaR7VnG1QWs85Ld10ldGqAAeAivQUt03iI5GoCcRxpsJ6mMA/fr+qNNP0HrhdkR1S2zZgKfBUNHxul+q6Bg0YXLei0EAHFK1X6rpUmp2qitJsHajv0eqSTBOjV5Rlm+1ubfuA9e3JYy3auCjXwBCCc7JBvvGbXVqcJb356i12TADUI4ebVZzpMSrY8eZ+ZQ42a2dVq5aurNA1y/J0oL7XEs7JF4FKBnCZyebQBHmuQeWhMfkwMFJUpOyD/ypP9eNyhfyKZpaYs5XL3ylXoF/h+Zdr6LpPS2lTq6JOdwL5ZMfr5ZdftgUZjC7i2QDtLBDhxgVomGzjO8likyNid2h4nKNTHYlFxO5Y3lLJTZTV8NGglXMlN+Wzn/2sPvnJT052yN6wn3N0HzAf0H7+9Kc/PR+O+IY96REnlgQgvwtX+Q18jpS1R5cp52KeBpdoLqRej3UrPffccya4xIp3LrTq6mrLWLjpppsSvrsTCXrku+BQqEaCDcdcAQ6xA9QdwEGlYzwa4ovV7Ug8tDA3XV6P2zQXiNCpApjzVVGmHjnSbBkZ3f6wckNdemLvSW247HIVZaYoM9WrzBSvXjnbqfm56RoMhq1Kcbi+R/2k1/s8FiCIjS3Agm39obA2Lcwze180Fgi+ASrrF+aaXgMNB1URqF0L8tJNxA41rK5zUOvm59gxyYjJTPWoqqVfVyzJN+rW2c4BZaf5dKi+W1l956RoRAWLK6za8tLpDm2an62cVJeONvVrbVmWfvL8YaWEBnTf9isN4FTOy9bRxj4DUNDNZroBkpmgQsd0dAWseANGMgYbtKn5p8qM9knFFa9bOcdmV+GAgpd/QKGVd0ypmwTKAVQvu+yyKe1nqh9GF8eCTLwrrDyfmSiix5rOBSLoww4YYTGNRsXHEbGPJzBnoQ0GwEjL26mO9VQ/T0WG+9W5Z5hgU935x3/8R33sYx+b6u7fUJ9n3sKzmUoHOr93v/vdZlUMpY57zamIOc9n/nR+3igDkQQgb5Qr+Tt6HnyJnYAoZwjmap5GomY+XOrWeuGFF2yFEsrbXGiOSQEl70RvDgAZGfQ4Uhg+Emg4ltG8pEZm0zhgI5ZVVWc8mMQz2WdfbpdMeN0zGNTli/NN21GWk2oicmhS1W0Dpsd44MVj6m6p153br7NYCT7/cm2nVTyoSJC1QQo6VrmAh4iG8zR2nGg1MTnUJioQOFrVtPdrZVGWuvxB+789Z7oUjqDXSJHP4zYAAkDKTveaVS/VGRyqACQAG3I7cKZCmA4Q4RxIMV9ZmqnjRw7rbNeQ1q+rVNfA8DGzUtzaf7ZThZk+06VEe5qVEuxV2sI1mp+TaqCG5PZNi6ZWVYj1fhvPAhcqxtCef1PW4fvV58pS0JMun9dnAlV+AIru5kMKrbhVges+FevhxtyOySTHI4Mmno1JPxXWeJtc8P0CDDEeM0WR5R2AuBxAgn7EEbE7YIQFBGdCitMjQDWRqKSjQyMBsFR1vv3tb+sDH/hAPG+jhD423zMAGs/or371qwnd1+nsXBKATOdoJvc16yMwFgDhAY5wEW5sotgTxjIwjuVqvByPYunjWNswQWCSmwg+/bGcAyI+qiDbt2+PZfO4buNQsNDYsCI2OgiT1bPRVQ3AR6yBd2OdXE1bv7JTvSbahkoFFQoKExUPKgk4UR1v7tVd68t04FyPFuanGdAocvWptrZG11x7nboHAjr3asYGNrrQlx470mKaDNykqGx4PS69WN2ht6wv08mWPq0szhIBhzhLXbE4X1Wt/dqwMFePHW1WaU6aynLSLExwcUGGHjrUZDoP3LGggtE/dCM4Z9EAKgAGQAohhC7JQAqWv//x5B5l+qLavL7StClUYHbWtCvNHbXPZKR6Ndhap1dOt2v9unVyKSqP223C+NlqF8vg8B7+iVL2fU+hnIUairjlH/RbpQKRvNfrU8FgrUJL3qTIzX89JZMNaKzcf2TQxLOxwIEDHPkb8WyznTzO2ANCACO803g/IGJ3skagbmF7m0hmGvv37zc6mBMaSUUHPcO//du/6V3velc8L19CHRuq2k9+8hOjVPIMh14Jve+BBx7Qhz70Iat88hxnUYFrzg/jSmVsLjlkXmrQkwDkUiOU/P+EHoGxAAg0BXjDlDITJaAplkF0Jps8vEf6zMfy2Xhuw6ogjmLxTCqeyPnz0maCd/PNN0/kYzO+7UhhuKPZGC0M5+XjVDT4Oy+o6XRyq22DvuS1RPG6jkHTfOAShUgcPQh0JnIvoCEdfJUSRXWEcMCaM2d16Hi11mzeKrekrUvytbeuW8VZKUa7QiwOjQtQg4MUNKtb1pYatYoQvz1nOk2/sbIkyzI8EI1TZSGIkKoHwKQww6dHj1F5KbWKCQCE/6OKctvaErX0BQyM4Jz1zKk2S2Jv7wsY0ECL8tvDLcoZbLA+XHHZJktUf/hwk1YUZSjDKwUjUbMN/vGzBxUY6Ncd116mlr6g1swi+OBGu1gGh+fMc0p5+Z/NAjmaPWzNTFUMEBLo65K3t05nC65R05K32eozk5zJ2L+OXs2e8S/AOAdgYsbzMN45Q/FMHqcSgjGBI2KHouN876k8QwmbqIh9Jq4nlsk8k3C+oqFTQRv485///HdK23Cpsf3BD36g97///TZWAEsai6U87x3KrOOSxnVlO8Dohz/8YXMTS7pgXWqEk/+fHIFZGIGxAAgP6p07d845O1smEY8++qg9vOeS1zdgD5vjDRs2zMIVn/oh0H8g8sWkIB5tpDB8pGZjPGE4YuCKiooZT5q3rAuf28TjVa0AgCzL1Zifl27uUlRAAAFQqRCeEwhIxQB9RygS0YtHatV87qyuu+YqE3bvOt1pFKhAKGI0p0AoaqCD6gf7JRiQbI5Uj9toV0uLMgyA4HaVm+7Tqea+86AFwAIFi3yP2ypLzYYXMNTZH7CAwLesLz0fFNjeP6RTLQPmtAV1Kjfda+Lx3Wc69dZN8/Xo83vkc0tXXL5Jjx5p1q2Vper3B9Uz4Dfa1m+Ptimlv0Wp4X4VLl1r+o/ZbhfN4AgOKvXJz1iCOda7Ss215HKSzd0dVYrkLFLzug+qPph73v6VCYzjpgWAjQW0kjHBdvH+XmNywSo6WUPxbNAd9+zZYyYh8VyFdp4fgFTedY6QeaSIPV5ZVqMtk6G7UkF7+OGHLQsk2YZHABMUgDXfL0AH9D4qWoARR8vH79EHATb5PZQ77Iz/63/9r0kAkryRkiOQCCPAaoGzguD0Z67a2dJ/AAiTTfy+50rjpUMZOd5UjVjH6+zZs6IEfuutt8b6kUlvN5YwnPvTMU5gojCyosHEZnQ+DfcEAn8mYTPVsKxF7E0YYO9Q2ITmbVQOMn167lS7tlcUW0bGZYty9ejRFqtYQKVCd9E3FNaJ5l6jYO09WqUPvO0Wy/kgMR16VFFWqoEOrHKXFKar2x+yvA7oW1Qi2Adhg1CsHEetSERaVpypUDiqsx0DBnYAEVRVqLiQyzEYDFmOB8nlaEyYg7f3Bow6ds2KQkElA1BBIevsD+nNFUUmVj9x7Ij6hiLyFJYb/Yvz7PMH5HNFtOtMt25YWagzNdU63tit+7Zvm6khv+h+LxUCiM4jZfc35O46I4UGJZfH9hfJWaBQxe8pVHGPgRLH/tVJYXdoPE5lBErHeGBkNJ0mLgMh6ZlnnrHqx0ze/7GcG3QiUtmxSec7Gu/mGBXw3HWyRugjgIRniuOoNZt9He1YhpEBdCKyohJJqxLva5c8/vAIJClYyTthTo/AWABkrtrZciHIfCDQL950g4ncFKwKwk+Nt1g11j6z+sSL8bbbbov1I5fcbqQwfKTl7UhhOBOBkXa3gI1YhOEzDUqZ4EcjUQv0K8xKMYF3a2/Aqhqn2was4gCVamVxpnacbNU1ywqMhgVViyBAqiLblhTo+UPVCjTXaqC0UtcuL9RAMGJ0qM6BgE619JmNLiAGJ6ynTraZe9WCvDQNhaiypOmRIy1GdQpHZRa7kWhUr5ztsuN2DATN5aq1b8hE5eg6CAMEEBEUSBo6VROqN+yfag4ULbQfCNIvK88zTUr/UEgHDh3RYEh6z63bLMuE7fqHgmrpHtRl5blG6Xp891GV+fy22h2PFksIoKu7Tt7TT8vdfFAKBxUtWKHQ4msVKd04XBEZ1bhHmaA6WSNQ/rj/nJTu0cF4+/bts4WFeGu7yBlCgB7vqjAUGEAZE2oqvvFuY9H0AJgOGEE3wvsRao8jYo+1+jXZc4N5wP3khNJCycKlC2ByxRVXTHa3b8jPsQjFH6KtxgAAIABJREFUD99B9CC8l/7oj/7IdB783glS5t1KFYR7DzOGeGuhpvNiJAHIdI5mcl+zPgJjARCoLKy4YAUI7WAutSeffNKoBvF2fJnImLEqyOTm8ssvn8jH4rYtpWwcfqiAxEJFGd1R7jmqGKOzNZxK3EhhuKPZmIow/LHHHjMe9UxUxagINHf7NRSOaH5ummklTrf3W+UBPcSVS4d1HIjS0YdQWaBiQKNqgoAbehXUKH9Xq367t1qfeud2m+znpHlU3TpgQObKpcOaEehMaDg2Lsg1+hai8rwMnx4/1qLboVZ1D5kugwRzAge3ry7W8eY+c9mqbu0zB66rlxfa76CCHWvqVUvvkLlTkR8C+ACgnOsaNJE62R+AFD4HVWtxQbpe3HtYK/I9WrZmvW1L9SUaiagk06P0FK9OtPQrtbfBrm+8AMhMhwDyfYVS5FRGmOBw3zoTVaxTmfBQoXP4/PH6wvIsx4J34cKF8eqCHZcJPbS0q6++2jj58W6XAqlMYtFDOha/PJ+Y7DrXGMrWVMwqxjr/0Xod/n3HHXfYuMWbyhfv6zXW8fnecS+9853vFICf9z96JyrnXBveNWhA0NIAfN/xjnfo7//+7+3/E0HzM9UxTQKQqY5g8vNxHYGxAIjjJkVpuqysLK79m+jBednyoo235/1E+s2DkwdivCZrE+kr25KCHmtQJavEo4EG4GNkYvhoF6rpFoZTFeN+mG4OfE1rv9GUoFOx6o9zFEJwgAhViY0Lc/RCdYeyUr2mv1hdmm0ZHC29fkWiMmrVwrw003Hw+ZNn6pXWU6e1W69VOBxVU69fxZmpWlmaZfa4xZk+HW3q07Yl+QZuyNRAH0J15M71w3oNAA1AAWByw6piHTjXbSGDu8902THI9QAQASpeqG6Xz+vWlvI8AzeAD9y4ELpfvaxA+8/16PLyXAs9bOjy67oVBXb8YHOVegNRDWUv0pYl+VZJKc70yquwjjcP2HkzuYODvWXLloneXtOy/UwDkJGd5F7mHncqI/DOmdwAzqna4coXr6A7+sYzEVoqgXbxbIwPzw3MTWKpXM50XycSFMk4ohdxwAjXmGuKeB1Awp8A0Kk29DoslDiLJeRbvO1tbzPTD6cqMtVjvBE/j7icCshDDz005ulhnIJpyp/8yZ/oL/7iL5IakDfiTZA8p7k3AmMBkImEtyXaGcN3BjTNlVRxxo/VLapOc6XEToAXDj880J2JFS9o6FIjczX4uyMMZzVqNNDg37OxCjUTAASBN9UBQgTRfAAyXqrt0LXLC3S2c1AbF+To4SMtRn8CbECVQvjd0DmopcUZViHBLeqpE61mw8u/M4Jd2nnghJav36LcDJ9pSoaT0jus2hEIRy1BnG3RmpAV0h8I6eplwzkhJKWTup6V4rXgwYPnui2XA9oWtDD2BfhYWpihvXVd9m9E44CbNaVZBpYW5KdZOjrbbV6YM5w7kuLVFYvzbDsqKb96epdaBqP60zuvNKvf4qxURSNhHTrXpSuW5NnK42wCgLGeQROZXE7nM8wROFMZQSvFs9SZqEKtmW23JY4PBQsNFFa88WyMCZVT7N1n43t/qXOdbE6Lc40dRy3AJ2ATCp6jG5lshWc0Xe7BBx80+12qznPJ2fFSYz8d/893HHti7vFf//rX9ud73/teo1lReeT9AtUP2hz2vF//+tf13e9+V/fdd59tO93Vq+k4p4nuI1kBmeiIJbdPqBHgYcoq9egVvbnoJsU5zLVUcfrMZJ4VNcSZc6E5FCxWVVnlBmiMFoaPtrsdLQyfzfNkFRFK3nTpgqgGhKNRE2jjLoWYu67Dr+1ris0Sd0VxhgnN31xRYvQmxORUEdBkrCnLNt0Emo3fHGrWjasKDZiQ4fHMgSodqTqt97zlRqsqYKP7yNFmLS3KNFtecjgAHcPgIUOdAyGrZNS295uwnAoM/w91CvBBJYNgPXQkUKf2nu0yIIOOA2cuKjVkjOSle63CgWidZHPAB4CJrJLy/HQtL86ySsrSwnQdqu9VVdVJrS9JVc7CVXZMqjqHz3Xp1ooCm2wzGYs3AEmEFHLMJZgAQR9k5ZyJKpMe6FlQW1k5n+mJODQiFmWwmo13NbupqUlMGsndiFdFaORzZ7pskqEBOWDEEbHz/BspYo+FqupUq1g8c8AG2gYCCNHPzFR442w+i6fjWI5r2Y4dO/Tnf/7n9qzhd4797njHeOtb32r0KzQgzj6moz/x3EcSgMRz9JPHnvIIjAVA2OlMrBpPubMx7GCupYpzSqzEMTmBo5pIzclGcKoazp/jCcMd0JEI9IqR4zidAAS7WxypMlK85g41MBQiTkKXv0pjQrdxvKlft6wtsaoEDlVkeCwqSFdpTqqJ01M8LgMD92yapyONfQYmqJ4EezvV31SrdVdcq0X5aRYWeNPqYksbZ6LfNRjQsYY+vWl1kVGhoEztr+tSXyBkaeeACIIKnzvVZva9UMMGgxGreDx9ss20IvnpPnk8bi3ITdOLNR3KSvMowzscHgjogKpFNojHLWWn+axCAphJ9bnNOSszxaP++pNqGohqw7pKAx+4eF21JNfc9JhgM9mKVwXCue6JAEB27dplglinGssig0PT4rvEOAFGHBH7dFB4Rj8/uCYsyiCEj7eej8op1DxE1bFMyGf6WTgTLmWMN1oXAAl/AgABoQ4YuZhr2lhg8Yc//KH+7M/+zBaoJltVmelxjNf++Q5hJMDi1vve9z4DaPwJqOcdxcIqFXiACVURtDRzKdcslnFNApBYRim5TcKOwHgABDEXK8ZzzTECFxEmwvF2npnIBWeyBL8YcWa82qWE4TzUHYDBPQO9BFvIufBSnK57uanbb1UF6FZoJtBbeNwuVZRmmXaCyfzAUMScoHCWwiIXMfiSwkz7DEJuAgqpbhDwh60uGRtY8K4uyVZ/Z4tePHBcb77hOu0716O7N5SZGxWgBoE4zll8jgrF+vnZevpUu0qzUyxvhO2orjx4qMloYQUZqXYcqha/OtBkInOqHxwfOtZDh5ot9Tw7zWuAClesx4+1GkjCQWsgGD5P/4pKWpCL/W9Qa+fl6NdPvazekLRtU6VVgBCzR6MRe+EnCgCZLL1mOr9/oy1VR+6bVXPACD+smjsUHidrZLpAPNcEITMhp0yC49nQjmGPfNNNN8WzG+ePjfnHTJoEACgc1zQACddipFEBE+aRlaCxwOK3vvUtffrTn7aJ9BuBMjRTF54FU8DdXKExT9c4JAHIdI1kcj9xGYHxAMhcFHMzgHMt1I8+U0JmtQxx5mw0Rxg+Uhw+EWE4XG5e3qxkxiuwayLjNB3OaNjUUk0g9O+Vs526vDxfbf0BCwwkCZzJvD84HBh4qqXfqhUlWalWWcAuF/1EQUaKhkJhs7Q90tAjfyhip0EQIUDgxcM1qq2t0dqNWyybAxCDrgMaF/+/fkGO9tV1qzQnzT5vQCMz1cTnpKW/fLrTMjjQnHQOBJWd6tEzVe26fW2paUXoH4AHx6yb15ZoKBixzI+ynFT96kCjrlleaJUTQMVy6F9HmrUwL92qIGc6Bqy6QsVlz8EjWlucptSy5ZZHAghjssV95Uyo4l0BSRQAQoXjUoYYTC6ZoPK9cig8jp4A0DAVkM++qQrjoATlK54NkXB1dXXC5Flgf87qOfqYmW6Oa5ojYmeFnu8K9wfXhR8WgUZfq3/6p38y2hD3RRKAXHiVGFcMXGaiejjT98R07D8JQKZjFJP7iOsIOELhkZ3AjYOy5VwSc9P/uRbqR5+hJTD5QJw5nc0Rho92oWL1lTZSGD5Ss3EpXjovUfzp50oFBK4wrjKTtWZGX4GrFHkd2Nxev6LQnKdIHn/4cLNuXVtiwnN0HKSXp/s8RrlyqFq4TWGjW9c1aNUC6FZut8sm/l73sEaD3/mGunX0VLUFEZIt0tQ9ZLQpJvgAnL1nuy1QkJBBNCR87kRzn/2ueyCojQtzLbOjtXfIXLKo2JAd0jUYsv7jmIVoHHpYR3/QKjTEXew53WmBglRYAC6AGfJK6DP2wbhqrZufrR3H25Sf6VWo6ZRqeqR33LTV+kYDgDgULP4dbwoUbkv06Xy4Jynn7VVyDXUr6k1TpGC5lJY3nV+3C/b10ksv2cRyIu5FjKFTGYH374TiOZWRieZnQN2hKowTFwL4eDaqprgRTfdzbrLnNJoiN9n9TOZzaOccMOLQ8XgG83dsm3n30r7yla/o29/+ttDPJAHIhSPtiMk/+clPGouArBuqibzDAJf8UBlhoYw8Fxwy+S4hTH8jtCQAeSNcxd/xcxgLgFC2Z3UG8eJcakyMeQCRYTJXGjxWfMoRZ062sQpEFWOkXmMsYfhIoDFZYTirtawe0t+JTogme35T+RzVPF5ME5kIOsej+oBovGMgIJ/bbVUIJv2ZqR7Tdty9AR1Hrwm6d53u0OqybGWYY1XEQv2oTty2tsQoVbhK/fbosDMW2RlUKtK8br1Q064bVxbp5aOnFWyp0YJ1Vxp9imOhGakoy9KOE62mAyFnBI0G7lbPV3eoJBsQAyBJN5H78aY+o3tBtaI6g24D6hcghdRzqi/su7N/OPEcfcm2pfkGPjhPQgwBP4APwEVVa9+rwvQuo3hB3/rRYy9pdXGatly2+fxlSTQAMlJg7G49Jk/NDrl7G+QK9ivqSVE0s0ThBVcoUlQhV/fZ4dTzghVSWu5UbrXXffbFF1+0ieRkga+jJ2BxAjDCZMsRN1MZiSWhm5V2gBAhp/EWMQM+qIJcd9110zbGU9kR4wIou1SFairHiOWzTgUMkMEkmtbc3GzuiDzXH374YaO8JoJuJpbzmc1tHDE5TmE4XTlzGe51553oWL5TceI5xfX+4he/qHvvvXfGTSBmeiySAGSmRzi5/xkfgbEAyFzUUjBQZGrwkIlX/sBkLhYe7/CjqShcqo0WhjvVjdHC8NEuVNNJlYIuRqWJlUxWlRK9TZZOSCUBfQbheoivHftaAEaPPzQc6NfUK7fLJcTpAAZAAJP+9j4m8wQRFphmg7yP3Wc6ddWyAgXDUauOkOOBUP2OdWXmMpUZ7NQDLx7X9mu3aVVpts52Dlh2yC/3N2or9ravpnOjPfntkWZdv7LIKhYl2cPuV4jKyfRo6RsyXQjp5PvregzAkIQOgECTAkghrJCKCJSxwWDYAgWx/UXvAeWKv3NuuGj5AxGz56ViAwVsqPGk0lNTXqsuJGAFBABC27g4T75DP5a745QiWaWKpubIRTWk87RcQz2S26Oo2yNzEsgoUmjRVQpV3CN5U6d8W0Onwfp2OnR0TKb43rFq7oibASAAEVZ0x1tMYKUdWioLMtC64tlqampsoeWaa66JZzfOH3uqAHG6T4LFIxZ2uF9+/vOf6+/+7u/Oi88/9KEPCRcnxi4RHMSm+9ynuj/A5Ec/+lGrHt15550qLy83wA5w+4//+A/LUfn4xz9uVVp0NVRIf/zjH1sw4VxuSQAyl69esu82AnC3nVUCZ0jmopaCvs+1TA36DC/6zJkzF4gzeYA6NrcjaVROYvhIYbiTsYHLx0y/oFiNhb7ASmYsq7Dx/prhrY+t5URWOsnr2F/fbaCizx82TQTaCSx2+wIRy/lAiB4MRZSe4lFZ7nCyMxUPJu8+j0vr5udoz6sBgIAN/g3tiQpE71BQ4bB05bKC83kdzxyuVbitTm+9Y7ulpFPxeKmmwyhenYNBq5gAXPa96qBV1TpgQIJk9ZMtfbqjstSqMbhq4Yh1srVPN1eUGJAAaACoCD28almhSHDnnAKhsOV/bFiQo4FgxATo2As/X9Wu0tw0c/GCJgbla19dl+WA7N+7x4LkztObXgUgIzUg067BiITkqX1G7t56RVMyFVpygwGG8RrPAauE+qrlrXpUYaobKZnDm0fC8px5Tp7WY4r60qwKQgXE1d9qFZDQsu0Kbv5D+91U2nQCkJH9YIGF7yCVEcAI4IRKpEPT4lngrJZTBeW7evnllxsVJZ6N5xwr+/E02xh5/qNTx+M5Nhyb1HUW0K688kpb2IE+95GPfMSCJFlAwkUMSt/nP/95+32yvTYCADR0Z+j9xtKDUK1HB/XP//zP9iGeXbwneTfwfZmrLQlA5uqVS/b7/AiMBUBYieELSul+LjVWNpi08xCfK42VQX4Y6/GE4U6g0sgwv+lODI91vHhRAlARzc8FW0NeMqRAr1q1KqZTpHpxrKnXQAbaDhyiHjvarO0VxappH7TJ+rOn2o0GlZeRYhN2wgEPAljm5xpYQDPx5PFWFWalGM0K4Ti0KLQj0KjCkag2vBoWCKgIRSXPYJfO1ZxQ+YYrjf7U2R+05HIAC3Su7sGAegZJOC8yoIMwnSR2gAkCcoTpWO9CDYNKde2KwldzSTLtfDoHApZNAgihmtPUM2Sfua2y1Fy0irNTDDyha0E7gp6EygrnT4UGt69Un8cmtLMJQNxnX1DK7m/K3XNOCg1Kbq+iGcUKLb9FwS1/gpjpguuKxSrJ7Jf1Py1X9xlFil8TGkO58tbtlCvQp2hKjiJFqxVNy5GiEbnbTyqaWaqhaz+pKDqRKbTZmOCySMH3ETBCdQQwwnPBqYzQfWipW7dujftEi1VoAFOiPJvRObJSvmTJkilc5en7KGMDcAagOcYDH/zgB1VbWyuqNbyTf/nLX5pd+1133TV9B34D7Akq3Wc+8xmzLHayiDgtvh8s1N1///2WGQIIphKIuP+///f/btqauawHSQKQN8DN+7t+CmMBEFyOqIqwcjaXWiJY2l5svEYKwx2wwQSCiQNtssLw2bxG8JSh6EEHmAurRwSxQYWJBYCgg6CiwIo/k/JUj8uyOu7eUKoD9T1aXpSpZ061afOiPAMRTNjRiSBUv2Z5gara+lVZlq0H9jdq25J8DYUjKsxMUfdg0LQjWxfnqa7Tb7a4z55qM3BS8qoYfbCrVb/aeVS333i1IkP9WpYbVW8kVWd6XMpM9Z530EIUTpgggIbjr1uQq6ONPUr1eoRbFxStNfNyDGggKIdehS5k46Lh7RblpetwU4+CwaiuX1WkqpY+q7bQR6oc92ycp+begAGQkqwUS2u/YVWxVXpoABBWZBE2O220C9Z0VUDczYeUuuN/GGUq6stQNCVLCg/J7e9SNKNIwXW/PwxCRjUAiC8a0GYASF+jIoWvgU/PuZflaTmsaEr2sPajcJWijvZjqNe0IsGN71Fo7b1T+lqRv4H2aLYmuEy2HNtXwIhj+0rFlNBQvgPx1BGgdaN/iWKVynMBuhPXKBEa14wFNBZ2HBvm97znPaYLoQoSr8Z3Gyeu73znO6bhYbwIR/zLv/zLGa+2x3rOAG6oV9/73vfG/Ahi/s997nO2wMeziwT1P/zDPzTN5FRc5mLt30xtlwQgMzWyyf3O2giMBUB4gfP7RHlZxDoYs21pe7F+jRaG8/Djhwc6jQchE3hACZQKJvSU3hPd7cQBIKzUzYXVo1gd3QAfrX0B02sca+y1KgTOV9cuLzDwkZniVW1bv9GmmKwjmMCeFtcrR5yOKPy5qjZzlYIGRbWDKgUVDPQfgAIqK7853Gx0prQUt1UwsOr96c4TKu48pJWFbi0ZOKzOoYgODxXr8uXzdSZ3mzavLNfJ5j6rXCwryrRcDmhd7LPXHzSbXybUOGZR2UBr4nJFlebz2u84J6/HZWLzjBT6nGuVlDTfMIhCkE7OCGAKET39OlTfbWGIACCnUf3ipX0xAHKBC1UkInfTPrl76hVJy1Vk4VWSN+WSX+vUHZ+V5+RvFE0ver1APBKSu6NakcKVGrznuxeIx6Gy+LxebQ7ulufcToVLN5reg+Y587w8bccV9aVLKVkKQ8FyNB/hoDztJxRc/04FN7x7uH/RiFzddXJ3nZHCASk1S5GClYpmXNxVivsO8MEq+2w3nil8T5kwMrGlQU1xKiOsAs/2cwa3P55/VGMSoTGpZ1HCSR2Pd5/GSopHo8B1Qoger/anf/qn+sY3vqH3v//9Vp2hGsNEn99//etfj1e3XndcABF94gd7eCoijBvaSKoeVIwwIaEqScM160c/+pF9P+ZySwKQuXz1kn23EWCFjNWzkW0uUpnoP0FX8Ixn0+rREYaPpE+xshKrMJyHIJWb2267bU7ckZwn/HaoAPHmlccyYLEAECbfTT1+LS7I0LNVbSrPz7AwvssW5Wr36U6zzUURsLw4yyb7ViGw6oZPiwszDQT4PG6rQCAOR2MBgAGgFGT4TEx+qKHHEsjJ67hxZaH6AxGFIxETg/N/V6Q16OhTP9I1Oa06GchXlytXN6ac1L7APG1eWqYXiu6ziTZ2u9Vt/ZZ+/typdjsOmSAAk4qybLP0BRxhE4xInd8BJPr8IZXlplsmCMAF8AGQAkA55woQId0cShm/YzuqJyPbRAGI+9wupez+vwYYXOEhRd0+RbPnK7jhXQqtuWf8SxjyK/0nvy83FKqClRdu19dkK/pD131a4ZW3v+7/nZC59XmD8h3/lRToUSR/meRJkafhFXka9pgdbzRviSJ5i89/1jXQbuJ0NCChlbcZ4PDWPiVXy1G5B1qGAYgvU5HsecMuWvPHrxCzwk6YazwAiHNCLGywmIQ4l+8tVC1suKGloCdAN4Lb4WyAkXhnw4y8QXjfQc2kMgQ9MxHaWEnxTJyZTCNKj0djHsBCAwLvr371q+e7gKAbPQWUMUIu492qqqoMIPFeYiGP+AAW+BCh/+Y3v7FrTNUDoxcWVtGDsLhK0vxcbkkAMpevXrLv4wKQRKcyjXfpJuIoNZnLP1oY7oCO0cLwkS5UlxKGnzt3TlBWbr311rhSJGIdD4StrCRt27Yt7taesfQZKgwrv0w2xmpMwnGxQoCN3e2Nq4rNnQrw8dixFi3ISzeqExoJdBlUQZYWZRpFCccoKh7FWan2b6xvG7r9ausdMgcpRNyLCzN0oK7bQv7Qc0DfgkIFIOgeCqp/KGygZfevvqHc079Vc9E25WVlaEPOgPZ1Z6lCp/V8W5oWr75Mi658m1VB1szLtqBAgM283DSz2sXtCv0GfSovyFB9F7/LNsoYAYpoV6rbBqxaA2Cij1DB+B35JAQrQtFamJumoa5GLUntVVZ6ik3SlfqaUHOkQQXgG7Es1Boqe0xq4WAzceG7srlUSn38UwYi5E4ZrjqEA3IFBxTNKlPgyo+PD0L83Ur/2Tvl7mtRJH/phZduoM0ATeDq/3YBXep8yvWaCnlP/dYAh6u3cVhY7u8e7k80rPD8ra+J00N+edpOGiVr6MbPWYUDsbq39mkpElIkZ6HkTZOGeoZBUc5ChVfeoUjhijHvKya4WPDGk+IzWlfA9eL762hGnEA8rhvfESa7M2ViEe9smJEXiXsVgIjNfFlZWSyPkRnfhvcA7y9W8J22fft2M89g8hyPhq7iS1/6kmkUAdNOQ5cCfQ0dxd/8zd/Eo2sXHBMQgsMVIAS3Nd7JmKQAkD7xiU+cZ3Pg+sn5AL7jnY0z1YFLApCpjmDy83EfgbEqIJTLKd0nimd7rIM0nqNUrJ8fuR3j4uRqOEBjZGI4wvDRdrf8bqI8a1a+sA29+eabZ+zlP5nzH+8zcxGAMME6n3gc6Jf6W+SKRNStTNUPZcjjcZtQ+671ZWabu6YsS48ebTZxN5a76DioGBDoB3UJqtaSgnT9+mCTUbT498qSLMvNIDNkeWGmJZ0DBp460abSnFSrVJCjge2tIyKHJrV5Ua5OnK5T3/PfUndbo5avWqtlGUPa252lXF9I9YOpWj24V/klC3V41YdVmJdnFY0rl+Qrxeex3A6oXztrOsz2l4oGFRjcsB4/1mqgCE0LwAXh+7Mn25Tqc2vr4nztO9dt4KO2bUAnW3p1/YKo6g4+p0WBGuVEOodpSxnFiszbpHDxWg32dGr/idOK+DKNp873wtEvcb8weeWlDiiB8rOt6YfyVj+maFr+azoLNsQKFzpW6QYNvv3fTVh+QYtElPaL98rTfECR/OUXbOPqOq1oWp6Gbv7KBZUIhNd8Fy3HCHF52wm5W4/KNdgpeTOkvgbTgbj7mqwSgtreFQ4okrdEwfW/r/CSG6VAn3yH/mOY6lVc+XpXrHDA9hdefL1CFXeP+VWB4sPkkfCzeDUye3i2sCo82oobMOIE4gFI+DuVEK6fMzm7VCjpRM7rAlreRD48zdvybGdhYt26dXauidDGCmrkurHQQxhhPBqLYlQ5oIeNbmTcYJzyyCOPxKNr4x6TxRBYECyAQK+bCzThyQ5gEoBMduSSn0uYERgLgCAYZGIcSzZFwpyIZI4hgBBWjmJtYwnDmViNTAynisGDzHGh4s+x7P5iPebI7Vit4SFPn6fzhT+ZvsTyGVZNoTXB5Z4LK0hUa+jnmtWr5Go+JFfbKWmwQ72BqKqGchXOKFF/7ipdU7HQJuQkjKOXuKmiWA1dg6Z/ONrQY2JxKgtUS3CgYsKPYPtYU59Z2pIonp7iNpoWQnbAxy8ONOiGV9PIqVRQbTna2KvLy3NNjA742H+uWwNt51R86Nvq7O7WlZUr9GJnrjK9YaW4I8r3hVXUf0r7g+XybH6nQqkFVoFBu4G+hHwQaFNUNggpRDyPxgPHLXJB6D99pD+7znRoRVGmfR6ghR4Fq2AE7deVp+rk8z/Xgu59yk5P1ZAnUwF/v1ztjFeXQhFpyJOlsDtV3VnLFVxxm9KLyu17wUojoIMVd17+TGZTwr26vuYflBZoV7Rg2QW3lqu3wcCA/5a/VaR87GwI3yvfkW//96XQkKJUIAAq0YhdP7e/U+GFV8p/1zcv2DeOQfTpPOgcvUU0Ks+5l+StekSujiqgkyLzNiu0fLsipcOUEldnjXyHfzqcFZJ14So5oCaSs0DBze8broyMajt27DAqSDw1BmMJm8f7jvO9diojPP8AI9CzqIwA4Kf6vHOskaG/xLuxCs5KOX3h3BKh8e4iDwoROo33EnlWgADHPna2+0n1gIUGAP1A+soDAAAgAElEQVToRrYMcweAZbLFZwSSACQ+45486jSOACuYjjDa2e10VhKmsauX3BVpu4CnW265ZcxtOU9HDD5Ss+GcPw/bkUCDv8+0MJwJG6LZm2666bz7ySVPNI4bMNGEvsDLMVFe3hcbDgAIE6nKPL9c9a/I5e9ST2qJXm7PUJm7S4FAUJtWLNGLns22ak5C+Pr5Oaap6PcH1T0UUnl+ugnKqSxQtWjrG9KbK4otd4PqyKGGbq0szrJtmnuHLLgQgPLWTfOM4kRYIFUGNBk3rCw0UTsUL6x6ca1amj6g+se/pnldB/Rywd1alTWoTG9UbldUxSlBPVHVqyVFWfJs/SPl5ecrI8Vr2pT8TJ9S3C6V5KQpzecx8Tl0MRy6AEsAJehWWAV3D4aMDkagIOBjQV6agZS8VI8WZEZ1Yu8zmt/wqFJcUfUq06oCKaFelQ4cV+ZQs7lQRfKWyd/XIbfHp4wVVyt81ccsj2O0CxYUKE/XGW069mV5Qv3ypxYZuE7x+eTxDlc7XFCoolH5b/yswqvuHPsShvxKffIz8pzbZddNHp/RoaKeVEXzl2nohs8qUrrugs9eEoAMdsp37OdyNx6Qy98puTyK5swfrmisuFVyuWMEIAsV3PzeCwAIk0cqIPHWGPBsgfqEJm4iixt8xwEvABKqwFR1SZemWsB33nFpmshjCC0KFbJE0Axwfjj5kQfBsyER2uicFO4hKjR/8Ad/YKGE8WhQCKl0IDwf3RCkc39AfUqERhghIJf3OtUP3tssQvDD/QqQTpQQzOkaryQAma6RTO4nbiMwFgCZTCUhbicw4sCUsRE7AkAQm40EGfydlVmnUdUYWdEAbExnYnis48FDnAkb3N94HD/WfjrbURmC345FMw/1RG+sdJLHsdZdY25GbZmr9EyTV9fPi+hsn0ub0pr127NeLV29QeH8ZTZJR1OBGxTUKShN2NTur+tSTrrPwgcvK88zyhZgBEoV1QWqDnyOakJrL5kbxapq7VdGils1rQPKzfCZqJuKx8riTBOQb1iYo6w0r1p6hpS991t64vA53V2RKX9KnmVwZHvDeqQ+Tbd49qp96R3K2vhWO85jR1vMVYuAQ/rG76B6rSjJNKoX2pPcdJ9eqGo3kJKd6lWqO6rC1IiFDAaG/Boa7Jd/oF/5br8aB6TKvhe0KnBUgZL1SktLt3sxo/FludtPmFsU+olo4Uo19YaVHu5RbkpEkXVvV2Tjuy4AIEwEPOFBbT36Rbk6a+VPn69gOGwTAyazPq9Paf4WuTLy5L/9q1Z9GLeF/PLt/a68h386DBa8qQotvUkB7Hfzx85w2L17t323x9T9BAeU8tLX5KnfzTqzomkFBmrcA62KZJcptOquYV1KoF++Qz+aFAXLETlTgcH+Nl5tLGelifaFaoEDRqC3cP1w0eK7z0+sz6zzupzKyol2Ydq3T6SEeOfkRuekAEBwbvrwhz+sL3zhC9M+BrHscC5UQHjPk/PBGPEu5d6kUZ1x2B1U96h2AYJZLJkpnVMsYzqd2yQByHSOZnJfcRmBsQAIE3ksbSn/JnpzhOEADErY0ECgC0xFGD6b5wxPmxVb0lpZgU/0xoSE1V1K8InCn77YmLF6V+ru0kqdVr83Ryf8+dpQGNXBdpdW50b1m7Muvdl3RE15l2nRhhtNXxGVTEPhD0WtQvH0yTYLBazv8lvlAtpSJBq1JHLyMZjgAyxwvPIHI9pcnmdi9Z4hqotRAwmE/1F5yE7zmFB9w/xcAwtUTDwuaffefbqi7jvKTpHCviwNerJ0uDtNb80+ptrsLUq97Pc1mFKsva9mdSCUz033GlAhU+TWtaVq7RsyylVumkcPvHJOFQVuhZqPG92ovGefnh0oV1pqijILF6u1YLMqFxaoM5yqBUV5WnL2p/I0H1S07NV8j8FOuaset4k47lsK9hsAaeyLmsVtUahB0eIKhbf/tdGyRiahO3SbLe2/kO/4LxW18MAShaMRhYIho1B5g73qzF6jc9d8RSVlZTZxGEs/5dv1DfkO3j+s34gEJZdX0dRshZdt19DNXx7z0pNVgkMbFKjRzVO7Qyl7v6cogCpnRAZEJCx32xHTmwRu+B+WM/J6EfqCV0XovedF6KFVbxkzsDBRRM7QO3mOQ6WdDqcrrjFghB/yi5gkM85OCvvFMhUuWZWaxQcf7wpAKlXcRNEIjLYpZmyh7yEE/9SnPjWLo/PaoRJZA8L48LxgwZEKH5bKgBBMBQAYvP+Z2/DDohmVEK73G6klAcgb6Wr+jp7LWAAkUZ2ZeKiMrmrwbx5GNAd44NjBhIZV0MkIw2fzVgAw8TLkIUrZONEbkxD47QgQKc8negOAlKhNi8JndCoyT2tL0nSg3aWCFOlAh0t3lEdUfbpGRQtWao/3MqtmkHCO4Jz76lBDr96yrlT7z/WYZuPxYy2WDo5WhEb14bmqdl21NF91XX7TVVAdwdqXagqULgIMn61qV16GVz43yeipptc43txnWo7BQFgl7n4d3PW0KnIDGupqUO9QVNcW9epM+jq5l12nZuVbEvqbVhebiJ0qB+DlTPuAbliapaN1rQr5B9Xd06NddX26vCAkT1e1Fnbu1PJIrR4ObNIVGY0qdPeqIX21Vm+4Uqfm32OVmaKsVLmP/UruU48oWrx2OBejt1Humh2QpYYF2C63okWr1NjlNypVkatb0fR8hbZ/UeG0wgsACBPe9UuLlf7bPzcROMJzBN+IvdlXMGuBais+pNOhYgFqoUn8f/beA0yOtLwaPZ3D9HRPTpqgNAqjuAorrTZocw7gJdgGwxpjzLPGxuB7DfcafA3Y8OOFx5gfYxv2YvjBcMH8hGXFBu2uNmil3VWOkzU5h56e7ulcVfc5b6u0rVbPqGc0cenvYZ5ZRtVVX31VXfWd77znHE5keU9xUsjJhenMT2E7+D+k/ErE4ia7gBC6aMGag9jG30d0799ecQtOBUCsh/4Z5gv7oZRsvpQNou9AbHij44hu/yiUFben2PAOJdnwlk1pw8tnKnVStL+d9neEbAx1N3QKcxZC89RcLoCfxheOCzK0Jie7Ol1zjKsdhs9iLp5w1Zl2v/yu8LrpzEjqs2xKVupqB5vlf2dGCnUNtGIlE74YWqpNMceT2rWvfe1roO3tQjS6XH3lK19ZlC5YXHjkM+aFF16QEEJmpbCM+XepZQHI79LVfoeeazoAojszLZQwWrf3THWhShWGp7pQcTJPmnWp6Cl4S3ElkdamFB8ulpfhVLc6Jx4vvvii1E8vFgvLqfrLWm8XJqAF+rDJE8KboWXIMQP+GLCzRMMFbwyqtwv9eddh/aYdMBmpl4hhNBgTYHBLbSGOdfqwvNCBw62j2LUiHzFVk6C+UDSOpsEA7t9QihPd42J1e6h1FDk2kwjTWYpVW5KDX53qF2DCuTxzNZiAfrB1RMIIeSw6aNEJ68CxBtx/6w3wjw1je7GGrrANw2ouzEaDlHZtrXTjfNcwxsb9GPT6MR6YwDJLCINBRXJKIgYroiYnbl9bKOVh7tPfhWW0GUfMO3BvySjimhFdIStqg8fwgroTtTf9Hpav2ybDZxhugpFlToEBARp0gRIGJOwDmN3hKgGK16NvYCABQOK9EgSo3PkPUEz2ywDIZfX+gX5Yj34H5vZXgVgAMNnE/pbibeo3+F3n95x6BU5mCXBZ1kMwsuHNv4Zl6Ky4XYEWvnpT4zBMDIowPfiHTwMOz2W3AL9P1CxwVTS1WV/5B2GEVIYTprbYBIzj3dK3uK5LYRDheA+M3raLQYS5UAtWTxlEOFOXJRHGN/waxrFOAVqiuylaJ4nvWjor4qu8k9JZu87Fa4zvEIIRMiN8BnNyyGeZHnzI1eeprslc9GmqffKZS93d7t27F82iD63Yed9wYYeN3wPqbWgt+7GPfWy+h0iORyaT/ZksB4Tf84UyFdAByPPPP48/+ZM/kTIsMn16zo0807hwcvE3/3u2QfiCXJSkg2YByEJfgezxr3kEWC6QbKXJHc6nMDoTYXgq0OALLV1Jga6n4INoqnKAax60WdwB66opoKNAjue52BvvFa46MaBqIevbMx2nVw4ewnDMgkfLB/Hb0z2oLXMjZMrF+nwNjSMKxkf74Xa5Ubj2BljyykW3QWE3gQg1Gsc7x0TgTeH5lso80Xww2Zz/n4F9e1YV4ESXDzUFDhxpH8PachfyHQkxelGOBS82DuH+jaUCRigej8YVHOsaw311pWganBCgQrettxq74PB1oHLj9dhWnY/mAR+aeryozFFxYcCHcksIrYMBjEQ0FNgA1ewQRiZodCJqtCHXlQMVJmyvzhNbYF/Ta4if+rlYDW8vBhg12hHOgcsUR7Pfik2Rkyi57l4o1388MZSaJoyHoeswDL4ecZwy9J+GITgINXcZULJetCB9/f1wqhPwmCNQNzwK9boPXaEBSQYghtFWcZsyjrQkmAyrS8qW4qvuhlpSd9llJBjh94HfY3/HSeyu/yIsShBxR7GUVSR/58lWsI/h278Ape7Ry/bDyS7FxbTBTW2WI/8OS9PTUIrWSzBhcjME+gBVQWznn0Gp2jP1LRYNwtzyDAy+TsDiRHzFndAKV12aPNL8gDX0meqkCD4sR78D41hbAnCRLYr4hTmiBXL0ps9Acy/L9LaX7RhySnHzfLoZ8nlOEMJryN/8/3xek+Xiij6tkRd6IpiajzKtQZ2jjVNdwsjSMEOGYXl/9Ed/NEdHvfpuP/7xjwsIYtAf31HU1DFx/M/+7M/w7/9+pQPd1fc4u1tQz8MsEoJKJrb/LrUsAPldutrv0HNNB0C4kkWKejZ1CcmJ4cllVMnCcL6oksHGdIXhup5iqZQz8Zbi6i/LhJZKsjjvl/3798vK12JJEZ7sq8mU8Z/tPywsREfYinscDejoH8R6xzgO+/LgRAylBR6YS9fBWLYBR7t82FzhFrcq2toyxM/tMMNqNGJZvgORmCrp5nSaov0tczVOSshgwgp3TUmulFT1jYWEIWFGxx3rS0Q7Yjcb0OuLyL4pUKc7FXUhp3t8CEdiKDeM4aXT7dhdWyqMSyAYxpo8iFB+c4ULfTE7VLMdN68pQ/cEsGN5gVju0oqXzEunN4ytlR7pR2O/H+X9BxA//xusKHIJe3B+wg2bUYUBGoqsUVSMHIa66k4ot33+7eFjXfVwgyR/G8b7oIXHYKR1cWgEsHlkRX58qFsYGcfKG6Ds+UvAVXoFAOHqMsshN1Xmwnry+zAO1UsOiGbNhSE2AUNwVNiT2JYPygp/uqb2n0bO//4gEA0iYnGL1oUTV7PJJE5ahogvwfrc9FnEt14+QSOg52Q3HQAx9h6D9ci/wxAaTSSsM+uELTYB00gzlLLN4q5FUDFZM7W+AOtb/wojAUs8nHDRsnvERSty82cRnRjH0cOvYu11N6CwNAPQoMZhe/HzMPW8IUGIl9n6UoszMYjYhvcgtu2j03oLUctHQxE+xxei8VnB8iy+T/QsCZbE6swIn/ULAUamY088X+Omf2fofMXG8SKD9/Of/xyPPno5wJ6vPvE4XHCiC9eTTz4JMmrMtfnoRz8q4X7TcVab7T7rGhCGCn7mM5+RkkeOE8G27l7Je40/7CcZ1cXieDZbY5EFILM1ktn9LNgIpAMgfGmwjppBhAQF023JwvDkMirSymxczUy1u71aYngmfdD7vVTKmXhOBGNcVWI5gO7gkcm5LtQ2vLakvbm6u5AZB1c7f4IPTvI7m86hK2TG4w9cj3PtvahBH15vHkCdOwZzTh4MeVXwmYrR4Q3i1jVFwkpsqsiVkEFO7AkkKCJncjm1HQQmTA3fvMyD11tHJGWcTlYUq9MxizkfzAOJxDUBBP3jYfjDcUxE4zAbDKgrdeBIaz8QDaFlwAdTLIhicxRtfqDMCfQpOVhelIuNVYXonDBiV20pXmvxisCdgOcUwwOrPHir3YtQVMUttQVS/sUSLwKd8/3juHFlIXpOPIuVzd+D0VmAl0O1WOUIwG5UYTaoqLAEJBNFXfsglJv/zymHkjkgxsZ9MIiOI4LBsQDixRtQcuvHgNyEw1OqDa8+mbpOOSFJ5HQXS05Tp77BNNyI+PK9iO34eHqNQzQE5w/vhmG8G1pOmVyHuBKHqioCRuwxL1SrG74H/gP2FbsvOweW3XGSSxehK5qqwHL6RzC1vwwjy80sLnHBMqgxKPkrENv64SuCDZP3Yew7AfsL/5cwH/ysZs2RzyZsgq3CFinWXIyPDsNZWAFT7R2IrXvX5eef0imGGtpe+UcgHoLmSRLGX9zOOHgeasEqhO/7RtrMkckuIG3JyYIshkBZBv9xAkgWiwtFLDciS61rRihmny8wMlN74qs9c67l3y8Lz7yYaUWWed++fbj//vuvZdfvyM/qblZkPf78z/9cytV4X7HxHtMBCrVlLMvSy8gIqBYSOM3mxcgCkNkczey+FmQE0gGQ6ZQFpROGMy2bE1U2vmRSwcZcCcP1ftOjfLG4m1ztourJ4hRELoUVGj7Yn3vuOfGoX8iU56nGlXoJOlU5zAa8deo8dla5YC5eAavJgE5vSJysqO9QNA1dYyFYDEZxrjrXN46qPDsONI9IiRTLqAgsyDR4g1HsWVmA5sEJAQJPn+5HbWmOgA4Kypn98XLzMK6rypMgQqaptw2Oob57BG5DFMPjARQbg2gdjSKqAnaLGYUeF9aWe9AVssCkxnCupQOP3HkTqgpyJBSx3G0Tofrq4hxU5jkSFr4lOQI+mOdRV+4WZy0CpVNdPvgjCZF6Q78fywxDiB14Aq8O2nFPjQE+xSaMwTJbCPB1CROi7PpzqKvuuNotKuVZCPTDEJ3AW2ea4SyuFoG13tIBEDvC2Dq6TwCEWrz+imMYR1ugOQoQ3f1JaLkVaftge+5vYG58CtAU2VaCCFUVGu14lShGc9bg8Oq/kUUSir25yknxsziflZaCOQZpmxqHqeNVmLregCHQL6J49pEJ6GrRlc5Zyfuw7f8szE37pD+azX3pnwzUzHgvyL7iuRWYiAI5ZhVGhwdKxQ5hRsTOOE0z9hyF7eBXJedEy7nS2pr7VZ3FCN/zdcCRf/XrdXGL1HC7jD84BxsSgLCkaPny5fJu4LNad9TiwpSe1cBrSDAyG65dk53GbLuDzcZwpRonUJTORSkaftBEINvSjwBzSGgLz0VNlvkx44W2u7yn+P/5m2zSI488gve///1y783lvTWf1ykLQOZztLPHmpMR4BdSt6zVD5BuVV4XhieXT5Hd0IXhXL1KzdWYzcTwTE5eL2daKmwCz2mpJYuzz88++6xMQDmhWGyN4GP/+UGx0Z2IqYj2NgqTsHzFKljMRtQUJJypmGgeUxXkOaxYWZQjbAnF4d1jYQkL7PGFpdSKmhCP3Yz1ZbmSKF5T6MDLjcPYW1uEiZgi5UihaAxvtgxhT6UVJztGUGAMoaE/AF84jtUeYDRuxZZKDy5MWODKcaKuqghRzYTVJS5hUWjlG/N70dLchPc/eCeOd43DajbCZDAI+8LQQOpMKGAfmYhgWZ4DVfkO+Vtlvh2NAwE5D7IzBB8ELh2jIfQe34eHJn6BnvG4TGAr7SGIdkJToVbthnLz34ib1HQaJ/ecIE4FQJj54NIC2EQAEhmHmndlXgeF3Sx/il7/F2mT0qVPIR8cT31ESrgQCyWYEoIhk1WYAv99/4pRQ4HoDbj6SSBEJpXPJE5k0+aAJJ8sU9WjgQSwmaLk6tJHVBWOHz8I41gHVLI6Sc3o64BBBPsmxPJrMRx3Is/jgZV5JxQVX/cRxDe8J+1QM3XdduALMIRHJWDxskZtzuBZKKWbEbn7iUQYY4aN5SmcbC+GADaGl9KdsLq6OuX0NFDvoGeNcNLI8j2dGaGZwGxPGOfSHSzDS3PFZqllg/wOsZyIf9+1a9dMd5v93Dt4BLIA5B18cX9XTi0dANEn8vpqlQ46khPDdbChsxuTCcPncxyXGpvAsVlqwX7sMxkQhqylTibm81qnO1ZcUfHbcwO4aWUB2kdDMiF/ct9hSSvfvrlOcjMoIG8c8AvooFMUReAHm0dQ4LIgrgAbKnIlp4M2ulFFRbHLJpN9PVG8azSITSVWdA+NSflc5/A4RvwhbMhT0REAVhTY0RlxoCzPhetWFKEnaMSO5UV45tyAHIsWvBSkryl14den+rC2lAnqFnT29GO4vQFa5RZUF+TI35g1QstfhgcSfDBckNkhtPc90TkmOhSTEbCaTbI/AhEK6EdDUcTjGq6vzsHAkV9C7TqCGqVDgIdGLUf5FijUTTgLp33JWC7ISSHFxHpLl4TuMGvYMrpPLHjV0k1XlFmx7Ig5HJE9fz31qn40AMuhb8By4QUBM5rFgXjVHkR3/xXgeVtfoYufWV7DySwbn1E6MzIrphTxKJw/fhAGf99loMoQD8Lo6064ZNFiOG8lhhWXlFRazCaYhuqhVGxD+L5vpi83Y+r8a1+B+cKLUN2VgCMRpkawZfD3AEocsc0fQHzj+6Z1vbg6THBGRnihG1epWRI3FWvKRS5+p9hnXkOuZrNchuU1BJS872YjRG4hxPlXG/9U1o7fs/vuu09cHVmKlW3pRyC5pIqaJ37/ea/o5cF6qdY7pewqeRSyACT7rVjyI0CKUlxn/P5LGRtTCcP5UqdN5nzV605ngHU2gYFDfGkthbbUgv04ptSAMOStpqZm0QyxompSonRdpRunesalbOmlxiGYvZ0wmMzYuXUTesZCItLeUZ2HvvEIVhU5RetBa13a7tYWu6TcatAfRlW+E7F4HPnmOA409MMcDyEwMYE8YxgTMQ3jUQNsNjtyc3OwY0URekNmFOa50Dsek9yPMo9dSrrK3XYc7RzD7uX5MJuMUtZV7LLiQOMQbl9bjKiiSeYIJkbx/ZfP4eMP3wwDmQFFFeDz61P92FiRi1y7RbZbUZSDV5qG4bSZsLzAKf0miCHzMRaMosxtl79RJ8I0d7I9Nc5IQsOhxqHl1QBpdAaZXshMAQifEVtMLWIrS52ERietiwwGLXSNwWHEa+9DbNMfTHloU9dhmDoPij2wgRoJsx2aq0xcqpTqG9N+lg5UegkmdWFcZNED8zg5yTS9O93O7b98DKaet6B6qsWemI3AyOjvTVjnmqyIFa7HSNiYACAWi6Spa+4KhB76zuV2wkkHIAtiPfwN0cbQs0wzO8CyLgr31YptiNzw6Sl1JOn6mpqunek1nu3tCCwYXspnRqa6MX6GC0o6M8JnO8EHn+tkR2gyMFMw0tHRAf7QrGSxNN6zHBuyRGy0On/3u9+NpqamtGYKi6XfC9kPXedBrROduWiOwuv6+OOP49Of/rQI0J966ilh0BiqyO/iO6llAcg76Wr+jp4LX9Csz+XDXHeg4heXAVZLxWpVv3Q6m7BUUrrZ76WWq8E+80FPhyEyZIuhqaomWghqO073jIseo2V4AjeuLMArbxyDzWqGpbgG+Q4LVhW70O0NIT/HIgni79pSjsaBCVS6zTjU1I9IOIQicwS9I364tBCOjgC1HiNMdidWlXpkYtgXMWFzdRH8EfWSMDwcV+C0kKUwo9xjF7E4tSETkTjWluUKc0F3LA0GdHuDuGl1EQKRuOg2jABePtOBomAntu25RTQiuTYTXmocxr0bSiRdndsRcDx1uk8E8ExhJ1OzriwXb7aNCpuzo8aDc30BGYdBfwShmCrBirPZpgQgRiMM/l60vPUcnIYYKpeVw9x7VHI06H4lgu1YAkSoJRsQ2/rYlHkadOAy1/8KxvEuATCJzwcTwnT3MsTWPgy1PJGbkNySJ3N6RgVXRvXAPAIDAhH+UHswnWY+/V/igEWLXNVVAZit8t/GcWZ3KNDsBYiUbIHX55MVe7p2sYSMmSfhB78tDMlkzeDrEtG+qe84oEREY0KgRaCGJL1Jpv3l5JX2pAtdwkMASAaErOlMrbu5KKYzIwQmnFQShBCMEJRMZ4V7MWlj9GuZWqL29NNP4w//8A/FRGCxau0yvQ/ncjtaKj/22GMC2JhbxsUx2hb/8z//s5Rj0i6YY/uLX/xCWFsdtMxln+Zr31kAMl8jnT3OnI0AX9BkP5KF4XrWw1KwWk0eGD2le6mE5LHvSy1Xg31mDggFvvpq3ZzdnBnsOBl8HO3wSlkS7Q/ICrCM6tCxU4iqRty8fSNKcm1oH5lAOBxB64AXW4sMON3lhTkaQNNIDCVOIN9hhmJxojQ/F+e9Bjy6vRIDIYMIw2l5O+SP4MZVBeKWRV0HmQymklOnQecr/iZwKPfYYDebUOiywmIy4kyPT9yyFEWTcinmifT7wiKEHw/HUWUL480TZ7Ht+hsQ0wzo8oZx25oijIdj8IXikrj+ZpsXt68rgkFATEgE6fsbBsXOt7YkVxgggg+yOBogZWaz3Ti5p1nCFSVYTDMfOAFj/0kMtpwUwX9BQaFY99Kq1hAZExE7c0CU5XsRr7ll6tIrTYXl5A9g6nxdwMplmR1KLKGLqNyN2HV/fEWiebLgOfn8Cfb1FXVOzDkZIUggEOFENiMwQsvclz4PU/urCecrNoYVKlFoFPaXbkXclicTf+7bEvEKkxHb8keIbf1QZpcjFkoANZvriqySzHaQ2IqLSNRX0OBiIRvLYDgJ5D0zG+GlZEP068h3F9n4ZDBytZVuZqMQkC6G0jT9upAh4qKODjb++7//WwL2OMFeCuYk831/6aVVtAh+4okn8Hd/93fidEWmg9rEb3/72/J9povYpz71KXzjG98QN7GsCH2+r1T2eNkRmGIE+BLW7XH1zZaC01G6U1qKwGmp2NomjzdXmwg+Vq5MEczO8zeN9ymZD9rdvlA/iPI8h0x8WYY0EohIZoe3q5kzRKwsL8TxDi+0aFASzFe5gaGoBQ5nDhSLHRsqC1GUl4vxmFHKosgu3L2+RJLOi3Otwqx47BZsrHBLaVVdWS6ePT8o6eR0tGJ5FJmP35zuE4G6Pwng9RAAACAASURBVKIIG0IWhHki26rzBBBRv8E8EeZ/VBc4hQVZV+pCc2cPXjl2Hjfuvh4qjNhQnotARMFQIAJaCo+F4thWnUj8Zr4IS7Ia+sfl3AtzbOKaRfvgN9q8Ip7ftaJgTq4GAQgne1zN1ps46Q00wNr2kgQXtvuMMDtyUVFeClP/aYjew2yXVXwpx/JUpw0iTO6wITgMhgYyr4PBhanNwGRymxvRHR+TkqzkNhkASQUjXFHnD8ECJ7HJYGTKSawal9IyM3Up431SVqU6i4SpkcwOswuBcAxuqwYjNKhlWxC59e+gOee3LLS+vh5kDliSupBtpsnwmfSZOhHdTYtgS7+Ouog9HahcLKVpye9bAhCaJujZSkz2pr0swRYXB7Pt8hHQtR8PPPCAmE/8+Mc/FqDG5HbaTn/961+XkitacrOUjWGKdMLKApDsnZQdgUU0AukACLtHoTEfiIupzv9qw6ZP5hezRWzqOSxFsEdrSN4Xk9qcXu1CzcK/6+BjDVmA+kHsWp6PgdFx2LQIznWPYswfQIGBeg0FbgvQGLDiukoXwkYnrl9ZLLkb1IbkO61w2y3IsZlwrs8v5VvhmIKdNfloHpqAoqoYnYiK8xR/KEZnwjm3pS1vRNEERLDE6mi7V0q6Orwh5NrMCERiONXtx4ObmHoeQHW+U/Z1pncce9cU4cLQhLAhvlAML55qh2G0Heuuux7ryz0ilj/b40NRrk2MnwhWjAaI0JzOW/xbeZ4dRTlWAR8luVZ0eUMozrGhtjS93essDDsmAyBq/dOw9rwBpWgd2jq7RWdRmWtIWN16me6dD7V4rZQpUf8hQYSbPyC/0zVqPqxH/wOI+qGlc9FiArnZgej2j4m+IrkxlIz3Z6bPLl0HRzBCe1hOYjmZ0ZmRTMt7TB0HYa7/BdSRC5jwj8GVXwpU7pDznMxqeDauyWT7oJUrJ+jbt2+fy8Ncdd8cX943ZNTnUptHPZ3OjPA6sunldgQkuvaHpWn894VmhvSB42Sa92wyQ/Td735Xwv5YVpzp/XfVC/EO2kBnQKjjYSkwS664MEJ3voceeghf/OIXhQFhySiZj5/97GfCjmQByDvoJsieytIfgckAyGIqs8l0lPXJPB/ki82haapzWKyuUpP1mat1pLnTBr1lerGuYTuuqL7e1A9TPIRzPT6scUXROcKgPQ2dAaAiz4HqIq62OzE2OowWn4a/fPgGnO71C2NAcTrLseiORV00QcdrLSPCUvT5IiLgZpo4xdwUjNMSl25ULPFiKRQZDOo6yEyQaQkLQxHDLauLhHVhNkinNyjajVtqi1Df55fSrMbBAPyhGG5fV4IzPePiitUxEkT7aBCb8xXsO3Qav3//bQjGNBzp8OLGVYWi5ajw2EXATs0KRei0C7ZbTAI6qP+wWUwCeFh2VVsyd+CDlywtAIlFoB3/Icz+bqhFayR922a1oSraDONwPTRbnljR8t8kzyMWhHGkCcqKOxC77rH0zlBKFJaj34Gp/5QwCHKh9EZr2v5TUEo3IbbjY1eE811WTx8eF3cpU/8JsfIlCxGv3gO16kYmll1xF3ISqzMjXFGn1kAHIxlpDVQFgfZjaDp3CnW77oC9ZOFYwnPnzkkWAjVxC9k4iabLEzWFnCTORyPooTWzznDx3UAjAgIRXleOy0IzQ/o46ACN4a7sH9u//Mu/4Ktf/ar0dbZtiOdj/Of6GDqQ+NM//VMJTaY1PPVFfCdRE/K5z31OuvDlL38Z3/rWt/Db3/4WLM3OakDm+spk958dgWmMwGQAZDGsck/jNC5tShHamjVrFo1AOpNzWGp9pqCUji2sWZ7rxpezbgNNe2i+kE/2BmE2AYpqQF25C1GTU0TiMYMVG6uKkOu0YTgQwXhYwclzDdhSbIKxtFayQWi5u60mYXNKFiESV3C2148HNpaKexYByqHWESmdWlnslH3UFDjw/PlBAQycCJfm2kDXrXO941KeRbZia1WeMBBjoajoPMxGI7ZUecSdym4xSkmXy2oW0TpZlMo8O872jcNiTJRLvXL6Asa6mlC1cScGA3Hcu6FUPstyMtoLv9IyjLvWlQjQYd9o5/vbswOi8+B/M/yQbMpcN5Y3cSKeXIIVj0WBEz+C2XcBanGdABCnMY7KwOkEg2FxwaApUBjyZ0+MvXGkGZqrJBFEOElpEnUWDP0zKBGodO8yWcXqljkcmtGC+Jr7oKy4/YpTJgBheWBVvgW2178O49C5REYHG0MHXaVQqm6EmlsB41g7NEc+4hveDzgSJW5648RZByO893ThM619p3Jhotid9qk33HDDgpbPnDlzRjRmLEtZyMYyIuZZsB8sc5vvxgULghGyI7orGk1XyJDp4ZXz3afU+ywVoBF8sGyIWpUsAJn86hw5cgR33HEHPvCBD+Azn/mMlF9RO0NgQhtqll2xTIuaEALQd1LLitDfSVfzd/hcuBqU2vgS54oCJ/NLqS1F5map9Xku7g0CYd6HnOjxh6CDYEMPuuSEga4mZ3xW1JZ5JP16XWUhen0REYYzsI85GWQomgb8sJhMiUXz4QuoH45i+6Y6CRckyxGKqmBgIS1xWW518+pC0ZKsLc3Bq00jWFvmkmA/TvbJgDx7fkD0IIP+qLhPEXAweXzPqgJcGAliyzK3MBlMWa8tzsFIMCYCdQKI8VAcuXaz9IWOVQQtLKGi8Jx/59/O941LEOHLx+uxe+cO7FpVJKVWZDh6vGF0eIN4YGOZABx+1mU1SZ/uWFssk5P+8YQb1nw0AhCu0iaH/HGSq7UegKXzVaieKrR1D8FljKAicAqIRwXpcZKvFq27FKRnYAmVxYnorr+8ooTq0nkoUZibnoap7yQMgT5JQSdroeWUQinfiviahwCz7YrTJkBmeeCqtv8Fc+uLkh1C1yyGBCIagnHgdEJAbpD/CSjRrG7E1r8b0Vs/n3YYWcqkgxHem7wfCUIIRsiQJFvCUjh86tQpETnPSv7IDC/s6dOnZcV3oXMkqEN58803pRRsoSeBvFcJDnk9WcbDlXQ+V3hPE4zwuTLfTR+fZID293//91I2xGyLxWh5P99jlO54OptBtuhLX/qSfA8JOjhnIdDlPUdGhEL0+Vgsm+8xyQKQ+R7x7PHmZATSAZB0K51zcvBZ3ulSZG4Wi6g700vBemVOvOjrP5PGFwcnADrY0H/rZggUD+oBl/zNH04MDrWOSokRszxYEkVnKbpeMS+DzldOiwlvtI1iU4Vbyqe2VLrxg+fegtmgYFNdHaoKnFI21TsWZtICbCYjNi5zS6I4nayYHs7PcJ/UarCkieVTD24qEwcsghyWWJFtuHNdsXyOYYfHO8ekLOv65XloGJjA1iqPlEaRJVlbmitlVOvLcyU8MKKo4pBFEETQwP3TEcvnHUVrSxMee+ROtI2GRe9BABSLa5JT0jMWFhBDW1/aBt9TR3teRf7Ofc9XmwyAxMd6YL2wH6bRVnR6ozA7c1HpPwVay3LyT2BySQch6d5nBJBEb/irqVPIVQWmjtcSWSAMIrR7oFTfDKV6TyLBPE1jiWBdqRU1574F48QAVDIvevP3wdx3CtBiRB4JcbyqwMCMFIsDsS0fQnTv3045nFzR18EILWH1fAodjHCVnZN/JpBfS+bItV5TgiBOXqm9WMhGwMaVapY86fksC9kfXhs26gUIFsmMkCEhIHE6nZfACIHJfEz+043PZz/7WbE7p5PZfPRhIa/HtRxbByG/+c1v8NOf/lQYI37/OGa7d+/G5z//eXlXvRNbFoC8E6/q7+A5ceLHL3JyIyXM1So+pJdSm8/yoNkal4XWVEz3PKYDTrnCyBW+ZLDBFy5XItk4QdNBhv6bq8apL13matAtqm0kiMIcC451+KREigJyshnUW1Dofce6YtT3+4WV+M3pARjHe6DE47hl1zaEKOzuG8e60lxhIBjwR9coOmexZKoizy5icoIMTvb9objoMHhMi5HWuCE4rCbRiBB8MOyQ1rj8HIER3bE2V7jxfMMQavKdqC50CDOyocKNF+sHUeCySkhhcn5HnCClxIXz7b0I9jSiZtMueCMqynNt8IbicizqUrzBqFj28hxYJkanri5vEHXl7ulevmvanuCTK8WpDAjLXKgBMXW/gd6GY3CaVRTBCzIdWk4J1NLNCQaClrXMBYmHEV/7IOJrH5q8P6oCc+t+GPuPwxgYAOKRhOOUq1wseJWK7TBIiVfOZSF9/D5tzRlARdMPEwDDVXLpGKb218QSWJrRIkF/crGVWCL4L6cYEx95BbBmVs6m51Nw4kNgQsEw85TorLXQDAhX+gmOqC1YyMbv/tGjR0X0zUn9Qrd040LwwWtGYEkwwucTn0O6EQGfTXMFBMj0Hjt27LLx+eQnPyljpoOlhR6zpXR8suYLyTzO11hlAch8jXT2OHM6AukACGt2ueq80C+v6Z74ta7OT/d4s7H9UgNN6YTIHAe+xLkinAo2CELYuLqYymxkskJ8utsn+gbmW5BVYMJ3XXlughGIKhgYD0PTDNi5PE/0FQzse7FxSFiK14+dgRUxlK5YLyVXDCdkSCHD/Pad7ZdtWbaVY0tY5lL8Ta2IN5iY/POYoxMRKemiloOsxckuHxxWI/p9EdGFUINBUXm52yY6EpZ5UdhO4ML9H2galn3lOSwiTl9flotnzg4IQFlZ5ELr0ASKTUH8/NWTqNu0FTesLsL5i4GCfb4wGgb8kvPhnYgK0OEYULhOS+D5bum+X5ysEYBIGVI8grMH9yHPbkT1sjKYul4XVsQQ8UEz2WFQwiJKV8o2IbbpA1OmezMDxNT8jDAfqrsKsOYADP0baZScDCm/kh87lNItiK++V8q5yIJuyx1FedP/gsabRHfJioZgbn8Z0OKJQECDScL+LrWIX1Low3s/j3immR0XP8wFHB2M9Pb2irU5wYgeeEg3poxq+WMhGFmepimJtPUMgVC6++D48eMC8Bd6EYmOU+wLAxEXosQpdWyuNi58XhGM6Pa+vLc5jnqZFhfmZhOM6JohrtjzGcnGAD3mlbCMKNveHgHqPXg9CGRpT8zx4m9eH/39wn+jAxZBCBcD+N8PPvhgZt+/JTTYWQCyhC5WtquTj0A6AELKnKUwdI5YSm2yyfFiPoelBprIjhFI0LM+GWxwAqZT4pxoJDMbfBFcLSAs3TViXsbqYk7SAwk9hcMsInC2ztGQHM9lMwtAIUtCMMFSqlvXFEl5UkdLI1qGQ9ixpU7YgqaBgAi3nzs/IFa4zNqgaxXF6NR13La2CI0MGVzmxrleP8bCUWFMvMGYgI/DF0aFDaF+g8di9sexzjEBJ0wjrylwCphpGQrIfsmaEHwwjJBsSHGuDW+1j+L6mgLZR/NQABvK3fjZ4Ub4+9rxoYdux9n+ILZXU6zuBwEI+9TQHxCww/NtvQigFuKevioAAcSVhpM0KdGLTsDU86bkgTAxXNK9yzZDqdw1delVPALLie+JC5ZC9kRPEI8GYO54DUbvhUSmCMXpBCMwQC1ej8j1n8BLx5pQt7wMy09/XcCKWrwh4XgV8sHc9bpM7mV/JmuCPdFbdIJFWYjs+gvEWBo2w0Y2hA5UdIrjJJYrsrz3k8HIFRNYsj0tz0jAIbNEyBRpjkLEK3chvu4RYX6m27iqzslZcmjkdPcxG9svFlG+fi5kFvh8SjZSmOw8+X0jgNLtffmu5IRWzxnJGFhOMZBkXFJL9j784Q9LKREXp7Lt7RFgOjzfObwO/F7xhyXk/P/8rf83F0X4w0UxbsOS30wWu5bSWGcByFK6Wtm+TjoC6QAIX158SS60heN0L9tSLB2bTknTdMdjNrbXxeG6GxXLFHRWg6u6BBc6s8GJJ1egkkW5M+0DWQWyEQn7W7OIsm1mk0zCyTQw7ZylVwQfr7UMI99pQTSuSckThdksszpb34QcQwz3792F+v6ATPobB/y4fW2xaDMIJihOZ9r47WuLRIzOQL+DraPIs1tk32QtCF72nenH8kKnaEFY9sVcEGaQVOc7YLMYJRyQWhL21+2wSGI57XdpmdsyGJDvkz8cx7oyl4AXCs0paqcwvdQSQU/LeRSu2YHravJx6IIXLpsJO2ry5d95XAYZMoTwhlXzY2Wa7rplCkA4MbvMwIIlnmo8odtIttSd5OagdoQAhCJ2zVN1aStT71FJQecEHfZ8KMV1woIwsNDo70Ws9n48F1iXyDDq+y3MDU8J+6LmlMqxzV2HEgwIyH64LtOR0ClLM9sQvu9foNTeO+Vty5wSBiwaYkx3z5W0dt3Nq7+/H8zgYEYBvwf83hCU8HvD7xInsDoYkdV0AJYzP4a5+VkYJgahOhkiaYQxNJIAbDW3ILrz45NqXibr6HQm2jP9jmbyOV2Uv9CaGL2vlwHkTE7g4jZ87nDyq+t/eC0JLOkKx+tJ4XNGLFfKMbm/s2fPioOTvkjzvve9T55ztJfNtrdHgOwHx4XvH/2HICP5h8CDcxr9N6/TQmfhzMU1zAKQuRjV7D7nfQTSAZATJ07IF3jnzp3z3p9rOeBSLB1jWBJfXgu9UskHO1eLUsXhukmBXt9OpoMriOwvf8/kpXu1a8xSKpY0vXHBi/UVLrGrZRbGSCCKXl8IN6wsEHZhTYkLvznTj21VHvjCcdFYkPnoGw+hwu1Aa0szXIYwUFIr4CMSV7GxwiP5HQwQpNCbTAVdq6jrIGA42e3D+tJc0WyQtaDg/cWGQdy8uggqxyimijvW02f7BcgkWBQjPHYznjk/iO3VecKGsOSKQIOsSYnbJqJ3ghf2g2wNE8u5P1rtqkEvfvXaKdx76x70+KKS/bGK2pA+WvY6JBRxNBDFXXVv6xmuNobT/neCBF8njCMtAF2iyBDk1UBjWODFFXg6oJWVlV1mQHBZCRYgZSO8n6/FQU8AyPHvie3uJQASj8Dc8iwMoRHA7BTgoQMQnqtxuBFqbjlestyJlZtvQHlxISzHvitlYAw/hBIHAv0wUjdCBsTmSYAhnnc8BIMShZq3HMEPvwSwnCxd01TRpZi6DsEQ6IchHoFmdkgae3zFXig1e9E/MCAAZO/evZcBcX0Cq4MRPnclsDEnjpUXfgBr8KJgnloZNor1va2A1Y3I7r+EWjG9QEGy2FwYmKlZxLTvn0k+QPaAlsA33XSTgK+FbnxH0MHsWpyReC0JLHVmhCvsfD4SjJAdSXVGm+qcdcCafL88/PDDEqL4y1/+cqGHK3v8RToCWQCySC9MtlvTGwGuKugr2vonSQnzocq63aXUuLrFl/pCW09OZ8wWgrXRa9Z1y1sddPBeYONEIbWEijW2XMXnBJOlHXPlrsMVf64Ki21uVR6CsYRdJkurCBao/6C+osxtw0sNQ3h4SzlahiaEJWB6uKJC2BGCC3/fBbzUPIZ3792GYEzFisJEGjldrSRjQ9VkfwQfJiMEXLCMiiCBx6DtLVkHitEJNOhYxbEjSHl4Uxm6x8ICJKjLOHRhFA9vTvzN40hoSvY3DEpAoT8SF3aEovkXG4awvNCBHKsZFrNRzuOZY63oaGvB3j27YLNapdyKDllmU4I1YaO2ZM6apsHQdRiGnqMiEheGgT+OAmiFa6DW3g3YPUhnwTwXAATxMCzH/1+YBs6IvkOAQtgHy4X9CTG6qkBzlUq44UUzXRj8vdAMJhy03o6q7XcJUGIzjLRKGRiF7xoMsB77DoyBftlHorSLGiUDNHsewnd9dUr2g7oUc8OvYJgYuqhLcYp43eDrFpev2Ib3oMdQgfr6etx6662TgnO9tIer3+bzv0TVwHOI2Qpgzi2S75bFbEmcVjwC00gzYnWPIrb9o9O6/LMBBKd1wEk21kvSyAgthlRvPm/pjESr5tloyfofAhIu0Og2zWRGpsqM4fF7enrE7eq22267pC256667pH//9V//NRtdzO7jHTgCWQDyDryov4unlA6AkBLmCg/DtJZSY9kBH/4LHb41nTE7fPiwlC3NleCfk/d04nDS1mwU66U6URHETSa0nEuQR6vasKLAYTajMt8ugGDAHxbmosRlk5RzljOxpL/LG5Z8DpZUMdn8WMeYgBDqLGiVW+C04IcHTmJrXhwlqzehptCJtuEJEaPvqM4TpoTlWgcahwRwFDit4nJF5oLWuvwbgUVtqUuyP4b9EcRUFWPBOG5aXYjesZBY9nJ/Q4GI9IWghankvlBMBPGPbCkXIXtC5G6Qkq0715WIeJ6fpSUvAwXdCKGvrRGbd+zGuoo8EbX7IzEBQywVo/PVbApfU+9Pw0gzDI37YAgMQitYBVjsCQDi74ch5IVWfSPUdQ9kDEC4AjyjFWa6UU0MAWoUxr5TMHe/IeyECLJhkFwQY3Ao4ayVt/yyEEPjaAtURyEOWO/Eyq03XwIgV3wXfV2wH/iCgBICHZZmMUAxuudTUKpvmvyrq8RgfetfwTIwprBfZgOsxGAaPIN49c3oqHgQDY1Nb08oyWQMnYfR2yYlXkrFDsDxdiCf+dQPYTzxQ/jtyxCMxgVsm01mOBx2OBxOWIfPQllzP6I3fGo6jxUJ/7vWlf5pHXCSjdOt8M/Gfme6D+oEGaS6YsWKme5iys8RgOjMCJ+7eoAlmREyJKkgrKurSwTnBKx6I1vE6oMnn3xyTvqY3enSH4EsAFn61zB7BoC4SqQyIFzBY+0uH4RLqdHhhCtSS6nmczYZBa5G61qN5N+6zXI6cfh0yyLmyqCAzAB1HAwUJFvAzIvmwQksL3Jc1FM4LuorzIjENGyvyRNROc9t6GISOMXgdMkSp6iRIKoxJKzIg3t34ehFUEE9BxmQurJc/OpU3yWROBfZCVqerx/EdVV5mIgokjFC1uNcn1/Sy1nmRYF633hEyrhoXh1XNOyoyROGhm1kIiKfZcChztqMBaOi+Xhoc5nY8LLqhyVbeqDg0PAwDh0/gw88eDsOt1NMb5ZMEgrRKWKfS/DBPhsbnoah7RVopXWJxPGkZhhpEUG0uvl9ePnIeTEfSC6vSmVAZjrxNXjbpIzKEByGQY1J2rnR1w1Ex2GMjCdS0H1dopNQPDXQhP242KIBmLwXEF1+B56PbMWGjRsn9f83DpyBufm3MIx1CLiCLRdq/krEa++FWja56QbLwghAEAsmxO8pzTjaCs1RgI7l78P5jmHcfvvt4DnZXv9aIo2dYnmGHjryEVv3CGLbPirWxARVluP/KX8nCxOJRBEKhxAOhWFQQnDHhuBf+SDMex6flosUFzY46WUY20I2uoI1NDRctsK/kP2hjokp6PyZ66YHWBKQkGXm95jgXBexU/PR0dEhP2SI2Pg8I/ggC/Ktb31rrruY3f8SHYEsAFmiFy7b7ctHIB0AISVM6lx/KC6VMaPHO89nKWlXZjqhZw25DjL0EiquvrHxRUdxuC4Q10Xis1ECMRcsE1PDOfkPRBVxter2hoRF4GR/eCKG6nw7nr2orxgMROXvZAnCcUUAC5PLJQV9MACLyYBITMH1ywvw20OnEA76UVizTtgRll2xXIuC9tdbR4SNYHmUHoPzZvsoHtpULgCFOgyGHjJXhGCiaZD2vW5hPqjJWF+WELtTf0I9Cv+b7Ecopgpo4N8YOBiMxRGMKJKczkyPRJ5HAlzdtZ5sSBwN7X0YbKsHKjZic1W+AB+x9J0H8EGmw3jsezB426GVrL/yqx4cTVjhbngUB871y+pxMrsxGwCEYMDUcwQGf4+AHeZ3UOBtCAzJ30wTAyJip5UvlDCM0QnZRrO6YIgFZVu1cA2C2/4ML5/rw8aNG0UYfAVIGG6E5cR/wjjSnGBPaO1L96vgMNSC1Yht/ZAIytM1ZppY3/xXQIlcJozXtxWGw+ZBR817Ud/txe3Xb4B93ydgHG64mDmSI4GHEqho8yC26Q8Q3fUJ0ZLYXv6iOHspDE3UAaAShzpYj6DRjTNFD2LMVikAhOfFEiLdsnWyZzO1ZeXl5Vi5cuWCPr67u7vR3NwsAGQxNDpLsbyJLmXz2aiv05kRZn/wGa27aPE5ri/2EYCQDacQ/YknnpjPLmaPtYRGIAtAltDFynZ18hHQ7eqSt+ALgy+OxfLSyPT6LUXtytUm9Hwh6U5UumaDLzC+0NhYcpYMNAg2WNI1F+JwHm+2HdLIDNBal5oNai6aBwIi1mbJFMubmKmRAAZlwggwffzVZrpeWaX0io2OUYcveFFXkSvlV9dVegQ4nG1sQTQ0gb27t8sxzvf5YTIZJFODDlN0yorFVYwEoyJwZ5Ah+0N7Xf4mC0NLX2pEmLtB0DMejgkgOdmdAAjM6SDrQtDROhxMAJLREDq8QRGQj0zE5G8speIPa/vDUUWE7wQrBC5MQn/tRD0+eN9NKPbkiMZkXsAHB48lQid+AMNQA7SyNKF1gUERW6sbfg8HzvZeFYAcOXgAxXlOLF+9FrBnoFvRVJjaDiTS0QvWACZL4useGYfl9E9gHGsT61yDyQbNmMju4ARe3K8oKLd5oJZslFDDiGcl6CqXFoBoGixH/wPmCy8IWIElkbkgjfkbIw1QVtyO6M7H0zt1xUKwvvk/E/3UdSn655nYPnAayrKdaC1/GK1tHbgrtxnWo/8BsN+OpHFgGCMT4l3lCD36QxGwm5v2wVz/C2F4CKqoeRHbYlcp4ivvQnjjH2I0KSiP5ZP8jutghLqR1DbXpUaZPpPTlRhl+tnZ3o7PUgZVUphPIL1Qjc9zPWeEmSNsBCPUg/DeJfvBLJAvfvGLC9XF7HEX+QhkAcgiv0DZ7mU2AukAyIULF9DW1gYG/yylthS1K8llY3xBkrZPdaIi28FGyj41zI+ronNdopN8D8xmmRsn+WQjmPExGowKU0AnqvwcqzANYYKDQFQscskIkMU42DqCLcs8klqu0sBIUXG6Zxz31JVIqRTBBwXh/PfoSDdGxnx48LYb8WrziGguVFXDiuIcBMJx9I5RA6BBUw3YVu0RloNajR5fCB67RUAHwcDqohwc6fSiRxbS+gAAIABJREFU0GkTAES7XgIEsihWs1HAjA4aCFKoCaFwXS+hGvKHpW9rmCkyERV732hclXwPu9WIMe8oBtoa8dDdt+Fsf0j2bTRShTw/zdD2Mowt+6F5KoHkcD5OlgfOQStcDXXz7+PA60dQWVmZngGJBWAaPIsLxw/A47SiuLQcau6yhEWtq3TSEyH7YGp9IcEs5FZc2s5y7r9h7D0utrmas1RCBqnZMI40XSxnMkEzmWWCT4eo6K6/QNizEpx4cwWZZS7JjcexHvyqpKoLAElpoiFxFiK65/+Alluetr+m1v2wNP5G+iq6FCatE7yMtcu4xda/G22GGnl23jv8XRj7TiTKtVKthyPjAuoiN30G8bpHBQQyRd7U8JuEzTA0aMV1iK+6U0CRpMhfbAQfLI/VU7tZPssFCLIiBCR6CjSBGFf5ly9fPj830SRHSS0xWsjOcKzIgDADhOzQYmh6uTOv4Qc/+EEpxyI4osnHt7/97QW/fothjLJ9uHIEsgAke1e8I0YgHQBpb29HU1MT7r777iV1jrS/5IoSPecXe+PLkCVTtKgkwOAqJql4Xg82CsFTxeGcXMwn2Eg3hrRo5iRox44d1zTEzYMBFOZYZULOUMGKPDtsFpOUYnES77SZoCiaAAOCDzpgUThOpoGidDIX/X7qLRIsBUHBxvJcvNAwJInhLM06U98IhMYw5l6FW1YXYngiiup8Z0Ik3jcu2w/4o7JP9ocOWRSfm00mcdKiXS6PS1alwmNDdYFTjlNTwBIpH1YW5ggoOtHtk7KwV1tGRNtBxypuR/E4QUbPWEgCBcnKMFiRoOm1lhEBM3TiCvu9aG84i4I127FzRZGAp3ltE4Mw1j8Fw1AjNFcJwBX7eASG8V5xv1KX3wyteo+sHqcFIIER2DpfEw1HV08v7J4SFOXlSHkU9RXK8ltkpT9dYwmSABAmk+cUJTaZGITtxH8CwRHRVYglMLM8IuMwiZ5iQrZXbW6xzxVthaca43c8gVcbh2XyRsFvcqO7l/X1r4lrVToNh7ASZruI0bW8SSbtShTm+l/C1Hs84aTFUEOK2F3lUCp3Ir72YXR09cgk8p7urycCE/MooE9psRCYOxK94a8Q2/JHQMgL2ytfgqnnLSnRElcuRwHiK25F9KbPJIBOmsZnhQ5G+JvPFD4zCEa4iEShdXV1muPP483FdwlZEOZcLHTjeFEDwnR4jtFiaAQgFKuzbJihhD//+c/xta99TYII2V9mcb3nPe8RRoT6kWzLjgBHIAtAsvfBO2IE0gEQvjCY5nvPPfcs+IR3OoPMhzkf4ovhZZfcb07Y0zlRJQf6cfUyuZRqsSa3zobOhk5WLLPipJ9MABkBOk3RieqV5uFEyRJLqao8kgViMRskC6SqwCHb942H5bfdbMTmSo9M9pnNca5vHNfX5EPRIDkfF1pbcbR9FH/z3lvQODAh7ArF6Szt2lv7NkNxtGNM9CRMPafug6nnb7SNwmw0Is9BQGIU0EF3LDIekbiGUrcNyzx2AR+00uW5rCjMQTW36/JhQ7kLb7WPSUbIzuUF4opFG2CWYZEteWBjmQATCs61oBe/ePUkHnv4NjjtibKyeW/edhjbXxM7W0QDCd1CTjG00g3igsVVeAIQrqonC5v5/FA7DsHadQiasxANnUPIy/OgtLRM9BXURijLdkBZeWf60iYKyFv3SwI4wQqbiQ5Y9b9IbM9+2HKhOYth6jsOQ3gU0AyA2QrVvSzBDoR8AkqiNbfiOdd70wIQisetr/0PmJgXUrLxir6QeaAOJHLT31zOAqVeCFURFkaE5dGgBBpyf/wsgZA+4b7L/3OYLrwIzcM+mi8HQ8ERAVDh278IpfpGOH71URj7TyRyT6Q0TIMxFpL/JgMSvufriTT3KRqvA5991O5x8ko2lQsWBCB8tkzXbGK27j8Cob6+vkWxKMSFnskYstk63+nuh+9ZlmTpob/UMNK97Bvf+IawNAQkzz//vADKLACZ7ui+c7fPApB37rX9nTqzdACEtahcmScDMldagrkYZIrnafvIUKeFahzP1BIqMh2cEJC9SHWi6uzslBfQUslcOXXqlPT3+uuvn9EQtw5NCHCgHmNZvh3FLptoMQzQcKbXj3s3lEjpEkEILWpXFjthNSXscZlAznIr5mQQsGysyMWR9jGYzRC2ZGWRS8L9hgMR0Vecb25DtcWPkjXXCdtyvt+PXBuDB/OE3SBrsb9hSETf/CHDsr48F8+cHRAgQUtfAhkCB7p0FbgsKMpJWBTTFeutdq8AEospEUTI0ELqRcjicF8EKatLXJJmzv03XNSV3La2WEIO6drFvJCnj7ehwN+Gu+68fcEminIxlag4NyE8LloMsgqQZO5ESwYgev6Bd3gQ7q4X4I4NQiteL5kGlwAIV+rGOsRpKr7mQQEo6RoF6PxR7fmyjXHwHFiCBbph2fOg2fMTZUoDJ2BgoCCBickiJV76xJxZHKqzGC9Ufgrrdt4qk7jURlBjbvg1YLJDI3hhDgi/lwRdsQDiax5CfOP7ZnRf6x9qb21CT28f9pZNwPbqlwXMCfujl1HFgjBODEEpWo/Qoz+C+fzPYXv9iUTqe07J20BDVWEI9Mq5h+//n1ArM/++cRLLEiwK1VnSyWvFcEgCEZamzScYaWlpEb3DYrB0p26OOSDMiUp3f1zThZ/hh/me5QLV1q0JBza+O8gy/uAHP8CHPvQh+Ruvp56SPsPDzNrHCIYIiqgFZN/ZN5YcLnSp36yd4BLZURaALJELle3m1CPAh59e9qNvyUk8V7qpAVksD75MruN8i+d1cXiyG1UwGJSuErjpjAZ/ezweEY5SNJ7clppu5VqE/gQf/nBMAMfKohyZgHuDMSl9YlkVdRMJzYUTLzYO4ZbaIvhCcQn2G/BF0O0LYc/KQrSNTGBThRvPnRvAsnwHnBYTPE6L2PWSaSBwoNOUM9iPExcGsPm66xAIKyjOtQpLwWOQtSCYIcvCUMBObxDL8hw40DiMG1flC8jgscl8/PJkH3avyL/IfqgCJp49N4CqfCeKXBZhRAhYCEgYHkj9CD9PoMQ0c5ZUUXNCRmVLlUfCDSm4HwvG0DEaxOZC4Mypk2L6sBiZLx1s6Jk1vLc5UeKzw6SEUek9DLsWgrV0DWiQQEHtpSDAiUHJFInXPpDQcaRr0QmYug4ntBSxIKDEYKn/FRD2QstfBY0gKDgM8+A5qiMErFKsfZm2JDAopUoHK/4Uy298T/rV4ogf1hPfg7H/NAwRX6K0iQGFNjfU0k2IXvfHmQnnU8+B4KjnLZjaX0GomyGuERSsvxnG0WYp1zKEx6BRXH8x/JAak8htfw+lcjfsv/4ozO2vQGWJmTklKTwSEKF9fMN7Ebk9c0FystiaoIN6Ef6wPJX3ZTIYmevnO5/JLA/bvXt3Jo/wOd2Gz2baRDMnimOwGBoXdHhN9GBXMlh0mfvZz36G9773vYuhi5f14bHHHsNPfvIT0Vnx/cf3VxaAzP9lygKQ+R/z7BHnYATSARC+rCg2ZjiSLmqcg0PP+i4Z6MQSiNkWz/OFztWzVGaDD2A22tumOlGR6ciEPSIFz0nbnj17Zn085mKHXPUiozPdCQWTvQcDEQkUdNnNAhp021ybySihgCxnousVNSEM+6NDFO11G/sD8veNy9zymdriHDx9dgA3ryqUpHTa39J691T3OHavLED7aFDE6PsOn0H34Ajuvmmn1NWTyTjS4ZX0cuZ3VBc6Zf/twxNSZkX7X34+ElPFlctmNuDNNq+USzEDJBxTpNRr39l+0Z1wKkwmhjqQZ872CyChloVlXNShnO72iUaF4IR2wnS+oj0vc0HYH+6PfxsbHZbv22IAIDrY4L3O+1K/5/XgSk5YuXpMrQFBtdNmQfzUzxDrO4d+rUgWMwiyWS6S5/HAHuqT4L3YmgcvC+C74t68KOYmk0GrXXPHqzB2HxGNh5pbJqDETIG2GhfgoIqN7ttOVtR4qPYCvFj5Sazbddfk5SoCdg7B1Hss4TRly4VSvg1K1Q3C1Ey7aRrM9f8b5oanYBzvESAdj0WR43RC9VSK4J2Ax+jrFC2Lsvw2xDa9D2rROjmU479/X8INE2GLKU2NwegfQHzNAwjf988Zd20ysTVLkHQwMjY2dimXQmdGZsOmO7WTZMR4H82UMc34pDPYkGWwDFJlThTv3cXQ+L3nogN1KWx8fxGMPP3003jggQcWQxcv6wOrI6ivYp8/97nP4R//8R+zAGQBrlIWgCzAoGcPOfsjkA6AcMWK+RTMAbma3/zs92jme+RKDCl/2hjOtCVPwJKZDVLNbCxfSBWHU0A+U3E4hfOs2V4qoY8zYWwk4TyuykSdAmwCgCMdYyLCJsuwoTwXr7QMI99hgaICa8tcIvweDyXYErIVegkTS7FO9/gkeZyhfkwZJ3DgpP+OtcUCYgg+qCXxDvbBGh7F2i07sLo4B8+dH5R8DwYdOqxmse9lyZTbYRZ3rFXFLinz6veFRRxOZ64bVhQI+CCQYHkX3azurSsVITvLs1hC9lx9AgxZzSbRl1DA/lLDIHLtFmyqyEX9QEDCDTtHJtAyHJQQRGpBuB2F9zrgn28AcjWwwfuaEzUdbJAVZakFcxT0JhqQzjdh7XodqiVHMjAIUjjZNcYCyIcPhpobkbP1XZmzO0xhV+KwvPlNmLvegCE4JCVKhtAwDHTLsuVBcyW5XEX8IuqOVN2E5z0fyGyFm+EvBDPUZ6S6VE3j4UE9iPW1r0hoolpYi/FgBJFwGMV5OTAO1ScS5c02KW+jnkUtWIXY1g9DqUmIsu1PP57QirA8LVVsTresWBCxzR9A9Ja/zbhXfKa/8sorqKurmzQRnosnOhjRcykILAlG0iV2Z3zwlA2py+OCxbWaVsz0+MmfI5im7TkF31wwWgyN/eFiFZ252BjaSLD24osvSpjlYm5ZALJwVycLQBZu7LNHnsURSAdASNUzoZuTYpYNLZVG9xk+wCmez6RxpTCdOFxf7SX7kwo2uPIzU7CRrk/sL2ukF5twfrLxmy5jQ9E3hdi0zOXkninhLKG6tbYILcMT4kT161P9F3MxFNQUMP8jjE5vCMvcdphMRgEfxzq9AjZYykSXqf6LiecEC2QxyCQQfNAy9+CFEWwoy8VwXycaO/rx6N0346kz/dhbW4xIXBEARNZkf8MgtlfnC5AgMGFIILUhpbl2ROMK1pblwh+Oo88XlmvOYzOBnVkgBEZkURhayFIxnhu3Y/bHy01D2FTpQbnbLiVhLPMi0CFo2VtbJA5ctcUuOCwGYGIII4P9OHm+CTfd9XDmk/RMbvCkbQg2WIKisxr6b/1eJ9jQgYZ+z6dqBTgpSgdAIgEvHN0HYRxuQldnGxx5JSjItSMU8GMY+bhgWI6I2S1lL3Qfog4h09If49B5mDoPSWmWITgC84X9EhxI4KCZbDDEwzBoqgjSx275Eg62RzIDICnjJ25cHa+9zVSUboZSuWtSByr945YT34fl7P8H1V0lwYac5HJyTwBCpkVctyw5AN28CEKYpM4SrFv+byjLb4W54TewvvyFRKYJ7Yp1wTqT32kZ7CxC+F3/CbU4wZhk0qbr9kR2Vwcj7D+ZW4IRXiv+Ti0bzaQP+jZcYKEOhazDQjfe89QuUG/HSf9iaGRkCPKZTcJGl0FqGFnuOF2Web7PJwtA5nvE3z5eFoAs3NhnjzyLI8BJuL66r++WLyGK9SgcXCxUdSanPJV7F1/KOqOR/JsTM7ZUcThXyOZDrLkYhPOZjG3yhCJTq2MKrTnZZ+Mkn+yAyWCQCTkzQOhKRdvcBzeVonM0LCLu+j4mnKvCioyF4gI+nj8/iLWlOQjFVZm4kz3o9SUcpLh/Mgl0nnJZTegbj4g4nXqLI2ebMDI0APuydbh/Y6kEBrLUiha+RzrH8MjmMklGZ/AgGY5jnWO4eXWR6EFolxuKKqIXWVnkFCCiu3URVFHrEYtrWFfmgqJqwsYYDQZxtiIYop0vNSZ1ZS682TaGQpcFm5Z5BJBQ/+IM9cI4WA8E+uEfG0V77yDW7rgN5qptwCRi7UyvUzqwkWzxnAnYSHcsHYDQ3pWNzw4CGGE74iFYRhtw4ehLKMy1o7C0XETsatF6RC25ArJZ367rEDixpU5kuhNcY9sB2I5+R8TyBorUTVZhHqLXfwL+/A2ycEJHIepQMm3UbkhCur9PROMGWgI780UoHt3z6YQ4fJJmPfhPMDc/A7Vsi2whACQaRak6kAhRVFVouWXi4iWN9sb+HqhlWxF61/fEDcv+7CcF/AhYMVIHoklqumrPQ7zuPYje/JlMT0W200XokyXCT7UzggUdjPCeIRghI0IwwrK66YIRMqbsD3UXC93INJPF43stXXjjQvSPmhSOr+4sx/fuvffeK0BEF6YvRL8yOWYWgGQySnOzTRaAzM24Zvc6zyOQDoCQFaBdIVeKFotYL5Nh0d27qF0h7Z+s2eD/Z+NKNsFFsmaD/z0X9c+Z9JkiTfabfV4KTQ/OulrJWBeF1iajTMrJEpiMENaBZU50hSJwoAD7rvUlAgKKXFac6BpDhcchgIAlVUU5VrzQMCglTx3ekGg42oaDGPSHRTMyOhETAHCwZUR0JXSUogCd++Yxu7u60Nk3iD995DYBP2yD4xGMhZh6XiIgiEGIHSMhYV3uqSu9ZJdLsFI/4JeyroTuhIAkjrc6xgQckQEhW8N2pnccOTaTgKsyt11E88wuyad43h8VoMUMEZ43E95d4X4YOw/BMNYOzZEPfzCKnrYmrK4ug7msDuryvYksjgyaDjZSNRu6sQRZvOQyKrIbmQBrHZjrv/mcYFmPbu3KSRMno/w7j8VVdD43WhvPo7K0ENUra2GwOq/QQemlPzS64ASX+yAjwgkunzWZ6KY4qTcOnJLSLM1VAbV0o4zUTGr8DaOtsL38BZi8F6DmVojrFkuzDBMDYrOr1NwigvHJyrSYjm6u/1VC02GywDfuQywSQWngrGhMEjkhzFZ5O5fEMDEIzWwTe12GKPJ4Fu6n5XkYQiOJHBD3MsTXvQuxzR+8qgVv6m3CMX799dfT2xFncE/pm5Ax08EIx5bXKhmMZHKtUl2epnH4Wd+UpcUUfTMnarGYPfA60W535cqEBfVLL72Ed73rXeImt2bNlYGZszUoBIXUTGbSWIadLk8mC0AyGb252SYLQOZmXLN7necRSAdA+OJhYBPrdlMDvea5e1MejpMj3YmKEzCuspJm1xtfmKnicJaUZfLinK/z5EuApWOLvd5XH49MSsYotOZknJqJMz0+ydUIx1RxhTrUOiLZGlEFuK7aAzpjUX/B9HD+O8ushvxRsQ7lxP/BTWVi2Sv5Gp3M1TBhfbkbXd4g1pW68NTpAWE86DRFRoTlXm+0ebGiyInG1g5YgwOo23YDBsbDsg01Jgw3JOghYOkdD8FqNGJ7Tb4ABB6Hv2MqcPPqQglFJAPC1PTGQb+AlJbBCWFruFL9ctMwtlblSQkWtSX5TqucI3Ul7otuWNS+0A2LIYgumxGG1hdh7D0BrahW9AG+MR9aL1zAxtpqWCMjkruhVVI4f3mbT7DBI6eCEDIY3d3d8h3jd4iryPzNVXMd8BDc0MVHX7jgv+s/qefD5wz3STDCfbAsi0CEPwRK0y111AEIn1v8fCbNcvQ7iRIqWuWmiNDpyqXZPIjc+v9Ionu6RubC+ua3EpbBnmoZm3gkiBL/WckmYfmVWP6aeb9cbGGfsDeSA7Lyjrf/Ho+KE5hGBiZ/xbSBx6Xdz4HdLBdwdDDC/+aCjQ5GpgKOqS5PmVyTudqG7wcCIpa7ZloCOFd90febmli/b98+/MEf/AFoz87MnblqFLvrTObVjsGSMCbIp7YsALnayM3dv2cByNyNbXbP8zgC6QAIJ/X0/GcpA0WJi6FxMsRJSqoTFcs/2PhC4aoWJyEUX7JcgGVV053EzPe5MmCK4vnZdu6aq/PgyhwnjTQoSNcoCKemd9gfEdZh94oCdI+FRAT+9Ol+0VCMTMSwscKNxgE/xkNx5DktklzOsiWGFBqNCXepPSsLJEmcDlgEIwQCJW67ZGhQmP5S0zDuWV+C0WBMgAdLoehydcfaEmFALMFBnGzqQNGqzSIG7/VFpPyLx/CG4rJf9rWu3C0AgcwJtSXM8SDIIRBh3se5fr9oiW9cXYiGfr/oRShQp67joU1l4mxF4FTotOCp0/1itUu2RzJEinIufcbtsIjmw9j8HMA0b09iguHzjctqJEtmbOMXoHlqoKx9QErAUjUb6ZgNXbsxU2aDfUgFG/q15bOATEU6QwZ9GwIMft+YX8Df3BdLs/hb3y+3nQyMcBvun/cVf/idJtPCEi2CkUzr9bkPmmdMB4DYnv00TN1vJgBGqhg94ocxOIzozo8jvv730n+l4mHYDj4BU/cbAkj9ig1KPIqCQHMiWDCnRDQfyY16E4YMhu//F6ilm2f9q8rnJDUELOGZi/A6PmMJRniteCyCEZ3FYulb8gIPS4n4bOa9vdCN/aWGjc+uhWK8U8eArCLZDx1sMGPjIx/5iIRKzmVWCa8bj51J4z2UzsUsC0AyGb252SYLQOZmXLN7necR4Mtfn8TrhyY9y3pvvsB0P//57BZBUWoJVXINO4FGqjicExY+tCky5IrNYqnxvdq4zYZz19WOMZv/3tTUJMnG6cIeqX+gHW6XNyxgYk2JS8qsmHp+sGUYj2wpx/m+AOrKc3HowohY8TLHgwJ1BvkdujAq9rXMBmEQIQEKJ/EEkaVuuwADMibUX/AYt9bSqjdyCTiwNOvuulJxyWLJ1P6j9Wjr6cfj774Npy+GGxI0cJ8Uv1MvwlIusjQUx7MMjO5XZGwISFg+Ricul82Mugq3AAluQw1IIKKIFW9CZE8go+FA0zAe2lgm1sB09yKj09A3jvI8hwAsaf4+GJueTaxu5yR0AToDIpMQbxv8ihVt9k2IaIkEbd0MIbmUarbBBsdYBxsE+Trg0J8Nye5vOqvI7yG3I4PBH36e3zs+M1hWwv8mEOH3eTpghDoRTha5Yk3ARdaS++RiyFS24DNxObpmAMILFPLCevpHMPadRGi0V4Cw2xyHIdAH2D3QWH6lgxuK6QP9InAPP/ydRBjiLDc+O6mFmeu8C17TZDDCMjyCDV4n/hCMEIAk28zO8qlOa3d8brGElOWui4EFT85rWbZsmZzLj370Izz++OPy/lvsDpRZADKt229WN84CkFkdzuzOFmoE0gEQThiYeMqwIf3BOFf94wSFLzGu9CaLw9kHNj6ECTaSS6kmq9/V7YNJsWe6ajpX55Xpfll+RVaBqfNLoU2mWWGJEsuiqOkvyLGgIs+BNpZXAej3RXB3XbGIsqvy7Tjc6kVdRS5sZhMUTk7p/tLlw13riwWgEHy80TYqczaGAxoAFLpsONruRV6ORUTkBA4UoxNM+CNxWIxGccdiyRQZCoKQqG8IhvFeFNTuwLYqtwjeqdFgOjmBDG2AX2kalkDEdaVkSBJJ6Ce7xoR94DlMROPCkDQNBMQZiwCF/dlCW92LgYLUq/D871xfIk5XBFCluTa83DyErcvyUFnwdvmNFhqDcu4pRLy9GDcXIhgMyWRD7ndNQ0G8H0rhGqi198Kdly/3fib16uk0G7yf0jEbBBsEFqmmDHquDSeR03V/43EIHDjJ4+o4gQO/swQiZDEIYHQwon+32T/2hZNB/Xfyd4Db8TtNcMPf/P+c1HJ/nOCmltHMBIBYjj0Jy5mfQKUDVWoJlrdNNCHUgKjFdVf9ehrGu9F58mVEYwpWb90D22tfhmngLKBEALMz4YKlKdDclQjf8SWo5duuus+ZbDATLcxMjpP8GZ3F0pkR3ks6SOZ9wGyLhWajqbXjAgrtrhdDS5fX8uSTT+Kv//qv5fu5WFiaycYqC0AW7i7KApCFG/vskWdxBNIBEP7tueeek1KmdOKzmR6ek5LUEipOvng8vpzSOVFNp1ZXtw+myHCx+LxfbaxY60urSjqfLIXGnBW6jSW/xBnk1zwUkBV/aiwIAI52jIkOgmBhR02+iLupwaC4my5R1EzQElfyPsJxsaelk9WWZW48Xz8o+2LmR1RRUZhjlb+xnGvIHxGWhL9ZZkWBdziuCZjgMYhmAtG4WOBGvX146XQbHr7jRpzuHsfmZW7kOa3S17UlLrHhrStzoyTXJs5XBBovNgwiz2GVLBICDP6NoIbCdbIqfeNhyfSgyJ6lX0YDRN/C0i6eB8EIQRhL0bZWumE3KnLPJ4f6eUZPoSDQBMVZDLO7VMS9oyMjqKvMg91qgrb8Jmilmya9HVJBhc4uTAU2dLtpHXRwtZqNk5x0bOK1TBYJNMhGEjiQxWC/WMahsxg8X8kPuciM6Cc6FRjh9rqTFt2MuK1uFasL4nWbVZaLTGUfbuw/BVPHqyIypxicJVim8S7RgbwtQh8Ui19l+V5E9v5dxlkhya5PtAu2nPyBJJ0jOiGCdKViG2KbPnBJOD8X3/mZlKLNZj94vXnPk8XipJ//nyBaZ0Zmou+Zjf7xucVSx8Vi+KHbJSe7lX3zm9/El7/8ZVkcWAwsTeq4nz59Gk899ZT8+YUXXpAyLgImLgzw5xOf+MRsXKrsPq4yAlkAkr1F3hEjkA6A8MT2798vYlL6/s+k6eLw5Npxik7Z+GDVGQ3+ZmkJJwzTtXhM7RcnIKx9Xkr2wRT1ctLC7JJrmfTN5BrN5DOpovm+sRAaBydkcj8UiAr42C9gIV80F2QzjrR7hc1wWE3icMX8DE7kozEVdosJmyvdONbpQ7nbJra3BBpxVUUopgrbQHtclm+d6xsXe1xqOKgv2bU8X0qgNld6cKRtVEq5Stw2OS06VD39Zj0G+3qxdft2sfNlGRSdrygWpwh9e5VHggC5D7pUMb+D4IiAp20kKDqVA41DyLGasbUqYaFLoMHt6ca1aVmulIIR/DAj5ExLn14WAAAgAElEQVTXCJRoCKGJAKxKCIZI4JLFNSdgeglVnh3IHzsDy3in2K2ynKu/sxU1azbCVL4RWvWeRHhdGgbjamCD5ZOpmo3JwAa/e9cSopnJ/cP+cFWczAgXCHRbVzIjBCW855PLtFLBSLpngu6kxQkuJ7q6OxPPhwB50pyHaBC2g1+BieGGIa+wEQz/08wOASK81ySPgyJwR4HoQqI3fCoREphhS+v6FJ1IhClaXdCY4D7HbSZM0Fx1iTazXFgiG0IAqet7dDDCazZfzz2yzfyZTL82V2Mw2X7TuZX90z/9E/7t3/5NvjOLEYB8//vfxx//8R+nPaWamhpJcs+2uR+BLACZ+zHOHmEeRmAyAEINCF0ydHvAybrCz3OCk8ps6OUcXGFNdaLiC2kuHq6ceNHWcCnZB/f29oKrSkxvv1YANg+3C5JF83SWIkig7SyZDYfZiKNdPjy8uQynuhOT9efPD6Aq3wmnzSTCbNbHszxqRWEOIkoi74MAxWI2IhJTJWsjpmjwh2PwhWMYC8Zxx7pimfzX5Dskv8NtY6ZGLhoGAgIYnjk3IGJxlleRhaBdL1PPDcFRDPd1485bbxYdyrEOL3LsZmiqhqoCp4AfEavTDetifgf1HGRICGCoU1lfmis6FZaPEUyR2QlG4thZlYPDTf0os8UwMDqGI51+VDriiGsQlqWyyHOZ/e0VZVRM7x5phsHXCb93BM2dfVi/5z5YyzdItoUOPpK1E8mCbk7aOLlPZTYoLmXjvZTKbMw12Lja/cfnhK4X4XeVzwaWU5EZ0fOG0oGRTJy0CEb0BQ7uk4L41JV26yv/AEvTPiAWElAhoINp4+ExaI5CqHnLYaBw3GxDvGYv4pveD1gSVsuZNn6XeZ22bEnkgixEGxsbw/HjxxdF4F5yzgXHhX3T9T28f3lP6mCEi1BzCUaotyMjczUL8fm6ZunMAr7whS/gpz/9qbhgzeVYzNc5Zo8zNyOQBSBzM67ZvS7ACOhgIfnQtN2j/oMsiN74AtHF4elccZKFqvrkZz4nPewbbQ137tw5pw4is3mJuDJMq8o777xz0df88rz5EicLsnnXzRLex4k9y5EYHkjB9m1ri6WUiiDgleZhcbKio5Vur9vpncBNqwrRPhIS+1yGDJa6bcIyFLqsAlDIcBCwkCmhroM2vHazUdLRaWlLXQjZkOp8Bw61juL6FflS3kXh97L/n703AW7sPM90X+wEQHBfm73ve7eW1m7J2m3HWxInTs3kepxxnNi35s4kk0klsVOTqsSZuMaeurdmkniS2Elu4uxzPbJjW4osS5aszdq7W73v3dx3ggSxA7een/rbRxDY3AASbOHvYpFNAgfnfOc/53zv/33v+9YH9M0j/bpne4suXLqiK5cu6qPvu1//cnxAuzpmVlsBTHwelRWqIZDN1zTUGEf1U/2TpipCNQeDQ7w8Xr4wrDZ/Wi+cG1Ywm1CjO6Yzo2l1haVo1qeRXFAP72rVpGrU0VSvtS1zS8BebZfKpjU8OKDXDh/V/gMHjbSpTTzsa/g/7RoWbFiSuE24i8lNw52q5ASGY7FghEQMgGbJ6+w7x75QJS3APHwq7kN2pd3K+tbmJhT65qcFTyPXtPlt5G/XZK9xHc9ToQg2zrish1qU7bzBGBwWckOudf1XguwslSbI37fdckiR8RPydL9gKj75QJ0hv2e7bjGeJcsxMNbjHGzZsuVtH0f7HfvJSr8VG+C8A0YWony2kGPgvgX4ueOOOxbytrK91ooFOI0zf+u3fsu0P8NVqeTrt2xBqW54XhGoApB5han6otUQgWIAhN5O9N1pk7DVDUAHSQHDKvM4V1lJIlbypmmlBW+66SYjC7kaBkkY7rz4gMxH2Wilj4kS+yvHzujGW+8wRoFvXJlQJOjFG043rKvT691Ro251ZTyuOzY1aTiWMipVyOjy/eDaekPoJrn/1pE+3bml2VRR4HskMzkd7h7Xjesa1DMB12Km7SmWyholKiootHChWgVxHP4IHhyAltFYyoAQWrg+uLdd/ZMp9fX26PL588qv2a0P7O0wbVtsIxLw6LHjg8b7I5WZqeDweyoetT4WyKflSk/Lk44Zcrw3n9F0RmqP+LWlvV79qYB2djWpZ9ott9enu7Y2G2lgKiqAqcIxF2eDecuKNRUCriuSMKqGrBDba8/ZvlgoyrAa5KZnm7fEhtZJgDjJIcfM8dCiBSDhnjJfJS3rdH3bbbcZRS62ZwnxW2Kvalv3P8rjC0gYA741cB93RXuMaWDeH1Z2wz3G08O4oiuvzPafUOrW+fe1A0Co2CDgsVKDOBx+7RXdFzismt4fCeNDVy6rvBuH9xZl196m1K3/l+RzeJOUaWcxtGUh61qeE4AR9tmCEc43c8CCkVKpQSGggZgB86MSRrFWuV/5lV8xUtIWyFbCflb3ofIiUAUglXdOqnu0yAiQ3DhBhv3Zbq4YObwSk+VK9C+Z65Tw0CX5hNQ9H7WjubZX7r+/cfKcjpw8p5948B49e2ZEhzY2GilcCNfPnB0xFQWXXEZpamw6ZRSh8Ppoq/NrY1PItE0hp0sr0wf2thugwXsgbVN1QFr3aO+kAR/PnBlRyO82LVxUWCCcU1VprfXL63abqgWEb3w4+IH2q9s2Nxl1LMwNT56/oldPXdRv/KuHDG8Do0KUrH50ccy0iZ3rH1c+HVc2PqXHT45orT+uVBpFLak14tf5eFAdjbXqamlQuLZWO9Y0GkK6z+NSPJ2Vz+3S3q56Q1YHXCEVPBfY4Pw4KxtOFTiSI6496/VhgT6LACwGADxIxsrRvljueTOf7TtVr7gurOqV9QOhZetaSlqsqNMCBQfMynDbbeZe/X/Vefrryrh9ytc0yufzy+/3yTPZK9f0iDB6yfuCyq6/y1RAmE/u0dPKRbqUfPAPlI+smc8hmMrDSvteIAAw+oOvaH/yJbkzceXq1s1wirIpuaPdynt8yuz9OaUP/B/zOqalvKjQaG+ubXF+LRjhOPg/rVkWjCxFXp3qGGC3mKfFXPtVjr8Xa5X7zGc+I4DSSy+9VI6PrG7zOolAFYBcJyeyehjSY489ZlYMqV6w8soXyRDf6WWudDlAew5X2r9kMXOJ9oPV4l0yMpXS8fOXdPbseTVv2a/37WnTm72TOtAVMY7kkLGRqYWIjhoUST8VC6/bZUjer18ZN61UE4mMbtnYqL6JGXdyqge0P1HNONw9od0dtfreqSHt7agznA2kdgEf3zrcrzu3NJmKCERxiO2vXho3bVlI8e7prDNVEQAI43JPn/zjl7Tz5ruUy6Z1vm9UfaNR7YykdXYgKncubRzPL8S8enh7vZKesBrq67S5s0nfPTGqQxsaFQp4TasZhoJwVXB3x9Gcyg4tZAAnlLA4zkKCeDGwUdjCSCsSw157gAwSLhIvEmquQwaKT2vWrDEtWmXjCuUyRrZYqSnJ41e+bs2CORCLuQaKvceqXlEZISG1MbBKWrYtzSpp8Z2KB202cMCsS7vdtrvvdQX+5T8pHxvRdKBd6UzGVDjqk33y5JgveSnUrGzXrVd3xwCTzLRSd/yaUcOaz2AxgcWZlTTeG+rvke+7v6I1ud63DBYdXiMAq+ETyrXsVOJ9/7fkD8/nsBb9GirpVD8Wo6bINcD8B4wCRjjHPJOsDPO1PGGK7TAeIFx/GFVWwrAVOydg/uQnP2mOdb4mgZVwHNV9WP4IVAHI8se8+olligDEPB6aJD52dRUjK27wK0mmXOjh8sBCvQvNeZK11TCsdwnKLKVqNSjHcdPi1D+R0PkrfTpz/oL+3c88aMz9NjTWGAO+9+1uV280aRzKzwxOGVUoAAmu5wAEJG+3tIRNmxUGhbRDIaULiKir8RnZXcBHY2hGqQqAQmsVwMLvcRtfkI8e6DSgBt4JoITX37ej1Sha7WyvNRWUE/1RbW4M6Hz/qOrTIzrdM6J43qtsJqNsXtrZ7FPCG1FdpFYpd41S7oAe3tupnomkARKkas+cG9FH9ndoMpE1n7+5JazvvtmvdQ01Zj/PDMbeAh/TRjnJgg8bd5JjkiXAhZMr5ZSc5lpzti86rz3n+YPLQJseiTjVEUvcpkUJ2ctStTy6Jq7I3fOqMclTetpwBHDxRgkqX8wlvByTbJZt2hgQB1awAWBUhLheACrEmFgDAPkbHDDiRGz4v7mn5XKqefQ/yHP5WeW9NcqFWk01zD96Rp5cXFlXQInIBrmaNskf8Jsq3oIBSD6nN156Tv5QRLv3HVzGCL39o0bPva7QE7+hhpBHatjwjv2A8wLATN7/BQNEyjmeeuopwyNEFGApw0o7A0asJwzXjwUj86ke44LOQhuci0oYLD6hmgYp3nYUfPzjHzeLD/BAqqMagdkiUAUg1blx3USAB7xTYYcDe+WVV8zDGzfd1TKsfwmrj0t94C3XMVvvEh5C1/IuWK79KfY5gI9jvVHV1ng1MjSk5MA5te08ZKoD3TiS4wg+Gldj0GcUrgAhKEcNTqYMbwIPj4d2tRkSOTK6l4Zj6n/Lz4NqxrbWsAEYEM9zWWljCyRkaWgqqcRbXiH3bW810rg4pl8cnTZtXffuaNErF4bVUZPV4UvD6h6Z1OYaCOIZbYpIw0mPBqazunvPBk3mA7pzR6cGp3MamkwZSeBEOmtI7j3jCSP7i4kgf7t7W7PZPi1kAKLnzo3o0IYG0yoGONq3JmK+w0tZi5N7LvcOcQabEJMEzxdszHWOATAAEb4sXwQgwteSjDdjQ/Kc+57cI2eVD7caMrYyiRlidm2HshvuVL5111y7V5a/c007W0RZNbZAzn4gx05liC97DRV6jABC8PoIPvWf5Rk9M1PlofKUSUq5jFLBVo3VbFQmm5Pb7TLtkJFEj1wN6+duwUrH5b3wfSPvO9Z7Tm5fUJFd9yqz6f6ZKtIyj+Fzbyj8/d9QU41L+cZ3yqgDNql8JO//feWafywyUurd5NwBQHbs2FFSQ1tAJ1UCC0b4HFTUACNw/2YDI0Ulkkt90AvYHhU7QBGLT7bL4CMf+YhZmHjkkUcWsKXqS99tEagCkHfbGb+Oj7cYAKGVgBs7hO7VNFg52rVr16JK/itxnPQBI1VZqeaJAxMJvXRpzBDDR0jI81P6+2eO6oG7bjUVBbwy4GAk01lT7djcElKkxqf+aMKoS53sn9SH9neYVi3+9trlcfm9bu3siJgWLMjo3z46oO1tYdOORXWDcbw3qsaw34AEjP8AHbHpuLqHJ5RLxtXhT+po94Tq3CldmJIBJkjy9qZqdGhzq85M5DU6NqHA+EW1777VAA2I8N3jcd2wtsGAmRvW1pt9oI0KrgmftberTpPxtIankkYOmO94nCDPe3Igpm2tQT1zakD+fFJdNTPGmqzAz2amWQp/m8J5aeVMLXGbhIykxRK3F8rPcl/6odwXn1G+YePbW3JyGbmHTpgqSHbHh8qunDSbpLflxNBWxXGSbFr/CJJQKiPcw/i7jQE/FyWvT48qePaf5e17Ta5M3Hh+uOGBpGLK1a9TxhNScnpSVAnyuZwGW25T7MbPGEJ8UbJ/Oi7/K/9Tnu6X5IqPKprKy6eMakIR5Vq2K3Xo/1S+cdOy3lr6errl/95val3monItO95+3nJZeYZPKLvmJiUe+nJZz2kxp+9SB4K2WwtGAKfMISqDFow4r4VKUChzHj/XL21hGCPazoOHHnrIeG/93d/9XalDVd3edRSBKgC5jk7mu/1QuInzsHAObtaUqyuFsDffc7RUA8X5fk6pXlfJ5onj02mjWAXXgTYnPDv+4umTqpm4rN033qJdnfXGR4MKCRK6AA9j8jcYE10vsWTWcDaO9U2a6ghyuptbQ2qtDah3ImGMB6mOPLi7TSNT6beUsLJGeeqGNSEd7x7R2pq0TveN6fLIlMKutDI5aXOjT6P5sOojYWU8QW1sb9TOrkajwGVBztqGoILpcf3zC8f0mZ9+yBDPafO/dVOj4aJgLHhhOGaO6+Z19bo0GtfO9rCRDD6BWWGAFh6pMZBXNhHT65dGlE/G1DsWV1Mgp5YamdV2p8cNP5eNnzHLhLOtKUjQLoovkk3Jc+z/k2vikvJF2nFMu47Lq+zOD86biD3fa8OalTqd4rkXMZzGjbZVDXJ3sUHSSfIJELGqV5wLC0Z432xKWpwv39lH5T/+v0zFR+kZx3J8QqYbd+ts50fUNzplWr0AIFbW15Khvae/I9/hrxsSe65hvYaGRuTz+8y8cU9cUWbTvUrd+evzdlKfb+yu9TrmwuiP/kGH0i+Ylrp8badR+ELZzTXZZ6pc6Rs+qcz2D5bi42bdBjGHy7Bnzx4Tt3IP5g5tTVQWqCxTfXSCEQxfV1ogwBkDWp+R20WAxI73vOc9ZtHva1/7WrnDVd3+Ko5AFYCs4pNX3fW3R6AYAKFcTatDpUgWzveczddAcb7bK/frrHkiceZhWSmDdiSqA/h5nOifUkd9QM+cGdZtHW499sIRffz979WR3in5vR6tb6wx5HMM+J4/N2J4EhDNqTAc74sa3gd/R80KgELFhOT+3FBMD+9u01nUqFJxXRgY16WhqHaE4zo5nNKGiNQd98oTCOnG9Y2aUlCHtrbr2EBcubzLENEhYQA6AC0Q3KMQ1utrDBH+8dfPaqr3vOq3HNCGprA2twSNR8mBLpzXx03VBgldTAapxAyORfXD0wPaEslrYHRS7nRMAXdOp8el5kiNWhpmuCO71rYY4LHcYGOuubEovkg6Ls+x/yVXbEh5/DEKR2xIrlzaVEDy9evm2oVZ/+6UFAZ0Azqs/DdJoXWJt2BjPj39xT7MAjJWl1kZB5ygIgYYQUmJleZiSlqeqV75u5+XOzZk5GmznTcq13nQgBErE2sN9Pi/aflpa9XGk38if/+ryrbvM94iQ4ODpp+/vqFB7rHzygcalHzPbxWP7aKjee03ktieOnlSD3WOy3vymzPHlEkYJSy4L9lt71N6378qOyjinKOCRUsssV/OwbVgwQhVZssHAkRWirAKZoP4Kt1zz4zAAXOVBb/7779ff/RHf7Sc4ap+1iqLQBWArLITVt3d2SNQDIAcP37crCLRGrSaBj3H69at09atW1fFbsMVQCufBw+JUiUMDAXhRQAkkJ31e13qm0gaR/Lnjl1S/4WTCq7fq91djaoNeAzAoN3qlctjemBnm+FHAD5+dGHMqAvhUI7TeUPIp9cujiibnNZodEprA0ldGIwqlUxpLC0FfV4j59uXDurA+ma9OZLV+paItrZFDFiB1I5xYUedX10NIcPRYB+fPj2sSI1XzeGZFXJc0QEYUxNjOnnmnDa0NWjfpk71pGqMmtWxvinVeXPqDGbN/jS44zrbP6mBeE43NEsT+aDWNEfU0VSnF/tzum1Lq+pCAaO+BaF+NYx580Ugbp/+jty9rynXvvdtBn0cJ27thgey88NSTf28Dt0Swy3QAGxYh3Z63Qsd2hG7WBCZnpX80fNy5TLK17aZFX6DaAsG9zVAA5UR7mWADzgCtFPBF7Fmh4V8EfaF19rvzs1a/gHbnRjq1YHLf65IbkL51h0K1tRoaHhYAX9A9Q31ck0Py5WOK3XbfzAGgMs1rly5YtTAaO2hAgI3hfawfE29smtvXzZeCgDzueeeM6IgxHulBvtBZez8+fMGfHJeUZUDFLFfK6XyiKcS54qqhwUgxOpnfuZn9KUvfWmlwlX93FUQgSoAWQUnqbqL84tAMQBy8uRJs4Jkb47z29LKvwoHdxSwtm/fvvI7M489gGD7zDPPVIx7+2Qioytj04YsTsUDz410Lm8MBAEWI6OjevnoSf3cQ3fK6/MrnspodDptwMC921v1evdMhQGjv7V1PnmyCU1MRE2P/bMXJrQmkNZURtrc4FXKW6uEJ6jm+oia6iPav75Zh3uiqg/6dHEEZauIGkN+nRma0oamkPEFuWl9vfHcQOZ3S0tIj7zRp31dEWN+CGEdpaqnTo+Y6khjyKPBwWHlogM63Dtl/Dvcbo8Crpxaa3K6PCVDmI8qrNpwSHdub9dwyqOm2qAhIz97blQf3N+uKdSwEkjxrg7w4Zx2s/FFuEZoi2G13jV0Qp4LT+HAqHz9+hleQD4nFy1Jyahy625XbuPdRWez9TFxtlEBfhgk8YVgY0kO7fmc3OefMkpWrsl+KZ9VPhAxBPnMro9KodmTXEj7Vk0M0G/VxAAjVDMYzjYte7BvU9IqiEAqHpPn0V+Te+ikRv1r5UJGTTME9samRrkne0wFJXXHf1KOCskyjcKV9WX62Hd8DDHHCZ2KAwn/Sg+UHalc0joJIGHOMkedYGQ5q5oAIip1dpGPa5Xn1qc//Wn93u/93kqHq/r5FRyBKgCp4JNT3bWFRYBVPetwbt9Jbyq9xKyiraZBMs/K1s6d5ZWXLFVMeEgDmirBvR1pWzw5aGn69tF+3bWlWX3RGRI2jue0UWXik+o5d0J33HGHRuJ5JbNZ+d1u7Wqr0XOn+xXKx/XyxXFtCExrOpk2RHWSvZ5kjR7e1aLBtF83bmrT5WjWkNrx7oBDAin9pQujhoiO7G5TrV/NIZ9O9E8aAnjPBOTxemVzMypWtHI9f35UD+xsMbwNvvAK+cZr3drR6FYqPq2RiUmFsjG9MZRR2Cu1hLzG0LCtJqeBlF9NZhW0XaFgjXZ3RnRheFpBv9v4iAxEZyo+GCnChaHSstoH1ziLCiQ9li/CCnBne5vaE2flHTo+04rl9sxUF2rqlW/equzG9xpyulX7clY2nGpfTj4MwIN2l1KaJnrOPCrPqe/MEMTD7cZQzxUfm2kRW3OjMoc+KwUic54m9pkYAEismhhAxBLNOU5iZX1d7AY5Fvtlf+c78nV5j/2TMoEmTSuk6GTUcI3cyqg53afcmpuUf+j35fLVzLlfpXrBpUuXxBfqSis5WFxBYAMlRWSTV3qwL8x3Wx2nKgcQ4YtWWM4tf+f5ASgpNxgpdGZnvlG9/43f+A197nOfW+lwVT+/giNQBSAVfHKqu7awCBQDIJTweYjdd999C9vYCr+adiZamXbv3r3CezK/j68U93bM9lCGgnyN6tVH93cYnw/anp48OaSO+hpDEp+eHNeRw0eUbdqgzlBew+NTanHHdHwoKY9LSsurPWsiqgnVyhesVdIVUDLn1v272nSke0Lb2sKGEI6ELaADF/HdnXV67NiA8dNoCnlN4FrCfgMwcE1nXbmrIWB+j18HLudUQA52BtU/MqGBsagSsSm93hvTgYaM4lmZfvfNbXV6ecit27Y0q72pXlMZl6maPHHkskZHRxRIjms0ntWB9U3KhprlC9cbTks8kzNgBx4Myl7s8/U23sEX8bi1vjajzkBCtd6MMSCcDrRqzN2siVjyqtqXFasolBYGfJQSbLwj3olx+X74X+UeOaNc217J7bn6EmOemI0rs//nldty/7xPla0OAURoqaISzHFZMEIlYzbyugUintiA/C/8P/IMHlXeF9JILKuAJy9/ekJRT7PON96taOtNV8nrbH9B7WbzPpofvxBeQXd394pXrwF6OHqzuGKrTIs4nJK9hXYwuECbN7+T6wRYsmCE/QZ8AEaoEvI8KcfcLnRmZz7SIvjFL35Rv/qrv1qy465u6PqLQBWAXH/n9F17RMUACA+xs2fP6sEHH1xVcaHkz+rrSjoRLyRgJIJPPvmkDh48aBKflRhUD04NTJqPphpx7/YW0wq1rjGoH54e1LYGt8ajk4rHptQ3PK6eyYx2Nkijaa8BKCcmfVrbUq+muojWt+KGLl0ZnTZ9+R63jIwu/iCACQjtGBHC1wDwbGgK6l+OD+qOTQ3K5mQqHC21Pj16bEiHNtQrns4ZMJLJpPWjMwMK5JOKTsVUp5gxO4ymJLfPr5wvqNs3N8sVCMnlCyocDOjlS+N6aFer4ajgkL61NaxHj2GIGNK6ppDODETV6onrxZNXdHk4qk11HmWCjXrPnvXyBSPG2HB7e+1KnJJl/UwSLhJWEnGScJIt5+o/bVOFrVTlXh0uDID78vPyvvbnJslXuIDQTGtW3+vKbnqvMrf/h0XFDmBFVYjKCFUi/o8oBNckSShVvGLkdcCEd7Jb/uP/JM/oWY0PdssfrFWwY5vSWx7WWMN+9Q8MmOSW2BJLq6RVLuPRwtaeRQWkBG+iqvDyyy8b53Hmz0oPFqe6urqMM/u1Bi2EFozwM+feghEqOaUCI4XO7MwPKi9f+cpX9JnPfGalw1X9/AqOQBWAVPDJqe7awiJQDIDQR8wN8uGHH17Yxlb41ZTZebBD5lsNg9g/8cQTpk+a1bnlHvFU1hjtQRSfiie0uU56+fyQEtMxdY9CFE+ZioLP69WkQqoJ+IzDeN36XbptR5f++eiAbt/cJLYDXyOZyRpVKaoagBnkbg9fGVcKdKG82iNUUrxGvhcuBzK479nSpGgibXw3qHagpHX3Or9O940bJarxiUkdG8loV4MUy/u1pS2iQKhWPXGPNnU0KiuPUbGCJE77VCab10QirZvWNxjwMRhNGl7Jq5fGdduWRsMXOT0YM61lfBZA6WBHjZ48clG1qRGNTyU07Qro1u1d5pyUK1Fc7nNtP4+qm7ONil54K38LJ4QEC2BMEk5lg6TN8kVWap/d55+U9/W/NIR4Bd6ZzLr7DxvVqvQ9n1/yLnJNWn8RQIklLTMXWKHm/+8AI5D5o5d04pUfqrm9S5377zVVODuIJUR4QB7qXLx/oU7e8z0wqtdUdGiTXMnBHHv11VeNwEYlmKzSnovHxvr16+cdFsC5BSNUSQAjzAGuBwDqUsAIssBcZ9aZHcDGtfaXf/mX+jf/5t/Mex+rL3z3RaAKQN595/y6PWIehtbsyx4kK6LcIAEg5W4ZKGVgKfmTRFFRWA2DxOTxxx/Xvn37SuoWPNex8+DrHRrVo2/2a0ddRucHJrUmkNSpcSno96ohEtKWjgZ5AmGl3AHTWtUaCajRk9I3ftz89kEAACAASURBVPCy7r/jZh0fSun9e9rVPZ5QfdCr3vGEke69Z3uzjvVO6kBXxBDZQ36P2utq0JlUU9inN65EjXpWOidtafKrd3hcw+NRDYxPqn8spl2RjAYTMqAh7Q0bF/MP7OtUz7RbWzvqNRZL62hvVHdtbdKlkbi2toUNAHqzN2rauAAdEMYBIkj+4qoeS2VMy1fQ59bJ/iltaA4ZQLKxOajNLWEd7o5q95qIxmIpXR4YVSg1ZpI4rg0SDUvaXinFnLnO52x/5zwDMJxfVv6W66SwsmHlb2fli3R2mtXgZa+A9L0h7yt/IuVy75QDzqbkHjxm5GUzN396saEq+j5ixTygMkIMOW44AoAR2oqIEzKv1pASwLJhwwaT5M6mpGWlgtkur7dSwdY8b6lzjMo1VZzbb7+9pLFY6MYAXK+//rqRcq8EEA/XDv7H2rVrF3oo5hxZMMJ5gzuEfDRzgS/uEQt9Th45csRsl8UnBudsy5Yt+od/+Af97M/+7IL3sfqGd08EqgDk3XOur/sjLQZAeOBiRvjAAw+smEzhYgL/yiuvmAe/XVVazDaW8z08gHBvp2VsMQ/G+eyrTULtqjffJ6cT6p6aUaMazOGz0aBXhly6YWOLkEVtqQ1oMpHWmcGY1jfNqD8hQfvDE906c/K4Nm3fo3t2dRq5XmR6kcnFTXzfmjrjer6ns1aPvjmovWtqVePzGDJ6vV/69pEebQjnNDw+qXBuWtF4Sv3TMjK6/pqQbt7YpIl8jSK1tRpP5uV2uXVoY4MBDZDMcTOPxjO6d0eLARwAjZGplPnM92xtNoCDtq5sPq9XL00Y/xKvy2XAE0DoWF/UkNynUzmtaagx2zzcPWHas84PT6s14jfVIAbXBaufxthtdNTMK5JEkk/6wheacMznXC3lNSwiFIKN2eRvSZ4BG/M5hkX5iyzlQIq9N5uS79kvy937inJNW39cBcll5Ro5LQUblbnxFwzpu1yDBJTKMIkiMSF2XL8Mq/jFSj9g1enAXYy8bveRyhNzjKQWIGNVmWj9Yo4tBughIELyf+utyyf9WyzmXDNvvPGGAULWuLFc52au7XKekGjfsWPHkhd62BbVCnveAKmcbwtGuLbmc10RG84vi08MOJf8/K1vfUsf+tCH5jqk6t/fxRGoApB38cm/3g69GADhgcjqFSR058O00o/9tddeM60j9B2vlvHYY48Z0vxCWgNmOzbnircFHIVJaDAcMSpQt2xt05nRjDEIfPbcsO7b0abhqaSawn7jEj4Rz+iGdfUanEppU3NQ3zsxpNZAVq8fPqr333FAKW/YVAxor2oMerWxJWxAAU7nr10e0/4Wj4bGJw1/ZHpqUkeH0jrUKg2nvdrUWif5Q+qJe3Xn9jYNTOfNZ10ejZs2qkjAa0DE3jV1Rv4Xk8G+aMKAiP1dGBxOGgPEkwMxI5ELIDG/awqaasePzo/r7m3NGo6lDPcEgPPDsyOGT9Lgz8p78SltmDqiw/EWBTbermTTDu3qmJ0gzIonoBwwQisGIA0gwhdqT8s9uGZJgpyAo2zyt46DK/QXIbEkWV6OOLgGj8t7+G/kHj1r9ijv8cuVjilf267shvcou/fjbyOnL+WckGRynt8G2icnrwIOVvQBC8wLgB//t+R1YrIQJS27n2zLtn5ZqWDb7gP3YD5JLdsqJDcvJQ5LeS+tZqzyIzO7WGPJpXy+872cDyogu3btKmmrK/OEa9C2aQFGOFYLRqgwznbeaE/jPoJTvD1vhw4dMi25mBFWRzUCs0WgCkCqc+O6iUAxAMIqHzdIXFpXevVqIYFmVYkknL7j1TJowWJljtaNhYxrgQ1W1nj4WYdpvpMkwbOgCoBXB+7hfq9bQ5NJ3bqpSf3R5EyVoHfCVECoJPC79ohfj58Y1P3bm3VhaFLD599U72RGGV9Y+zZ2qLauXi2BnF48N6RMApPBmNr9ABMp6/JKgZBS7ho9tLtdA0mvNrbV6ewQ1Y+07tneYiR+4Yq82RM1srf719apeyxhCO4n+ycNEGoIeZXLS7s6IgZohP0e9U4kFA7MABLkeqlmXBiOqz+aMA7r8Exo4+KYvnN0QHdtaZK75xW5Hv+cNqTO6MXsTrmV1zZ3j+o236zkh/+kKL/AeU5IOEhKASKAdJJPYmtbtGjLKPUgeSIhdYKN2eRv2RcA0XyT1cXuK3FglR1QRvJl4wAQKSdfxDV+Se7Lz5mWK+WyBnzkug4pt+4247mxmMGxFOPF2LZUrhvndUSVw1YmeC8r/TYOltth48B8mEtJqxiPAKBnTRQBJiwCWfI6vJxrnV88nACnJLMrOXiGHD16VHfdddeKL2JxLuGAkOwTx3IMe2+wYIT7MwDDgpHC8wZBn99ZyXieXUgnI6Sy0u1z5YhPdZuli0AVgJQultUtrXAEigEQHqrwKTAiXIkV3sWGhBU3Vi7pO14t43vf+57pTb6WOgutGk6zN5JgW9mYDWwUJinpbM44m+M2bs36XMprc2tYg9GEIYJPTFMRqTGu5ST4SOvS/vQTe9t0YiBmzAWfP92vibFR1WtKw7G0OoLS68PSmlqPQqGgNnc0yh8MayztVW2Y1WDpxvX1hvgN94NWJ4DBvjURA4Iggz9zdkRNIb92dtReJYi/cH5ULrm0oyNsgNAM+IgaY8D6kE+5fN78zlRIfG5DNne7XYZ8jqdHbY3HvPb1K+P66IEODV85Lf3TJ7Qhd0Xfzdyida4h7fdcuDpNspvvU/JjfzPvaWN5EoARevmt0zZgBDWbxYAAkhiSTyfYIJkEhLA9rkXL2yApJhleChF23gd7jRdeiy/CCn5Z9i+bkrLIBQeLuqBf67iKXUskiwxWr53AnZ/nCyptHCzR3HI7ACMkocRhNiWt2fgidoUdMGKlgudS0jp+/Li5B650FZj9PXbsmEmql8prWeo85fyigkWLE3Oy3MNKPBMDgBhzjoU8C0a4bnm+UtmyprkvvPCC4VxSxcc7pTqqEZgtAlUAUp0b100ESG6sCo49KBJcbogoqVSChOJ8gw1xnuRtpRVg5ru/vO773/++AR9Wn34+YMOZJM1nxRtnb7gO+9dE9MiRft2yocFUINY1BQ1vYiiaVFudXzVejxpDPp0Zismdz2lwfEo7GvI6emVMruSUTo8k1R6UGmo8SvtCWtsU0nOX4toejmtoKq3OhqAaWto0lAnrxk3NxtAPwAOXJJrIyONyKRL0GilcwAd8C6oXO9rDhqcB2MEU8IkTQ8b8j6rGpdG4+R0tVPA3AClwT/jd6YFJjU1nDLk9kc6ZqsnFkWmErTQeS2s8kTbcEGR4009+UU0n/0bd+VZtVY/C7uQ7TlP8E48p3zFDCl3IsE7bgBEABImsbdGaTQGIJAUQWcjbsKagVv7Wrr6zWroYTsBCjmOpr60IvojjIJytaradiuScQVLsBHP8zIp1KQbXsCWvW24HiS9tWpD4GazKc++1PBJ+B8icDYxYJS2b1HJszAlbGbFtTiT9VHRWmgdHVQglRcxsywJCF3CiVtKVnfPGHLDnzbbsca0wF6xnFRyVj3zkI6KCRUW8OqoRqAKQ6hy47iNQDICw6opxE5UEFD5Wy2D1j+oNZf/VMEhUaA2wK60kozZBspWNhYINjtsmNXzP5HKmzakj4tMLF8b1gT1tpkJAck9FxONxaX1DQCMTU/Jl4nr23IgaPQmNTia0MSL1xd3yB0Py1oS1vbPBmPpNpN3GtRzA8IG97To3NCVvJq43znbrQv+Y9jbmNeap17171+vStE8pFK9aQsJtHcL3q5fH5XG7jexuW11ALbV+o5yFP8ipwSnduLZeNX6PLg7HjREg/BMqIZ11PwYkL54fxXRae9dETFXlwNp6Az4APY1hn+GGwCvBtBDiev5vP66G+GWtdw/NOjXSd/ya0nf9p0VPHbtibZ22Ob+cP6oiXEeFgMMCfxJfZzJMYjnflfdF72yZ37jcfBFbPQJoWLBhW9VIgK1TuwV0ALzFVKkWGjbOOVURvtgfq54EQLWLO842Lbt9C0aKgU5eT9WNpBauBcfOajpgxMr8rvQqOmCcZPree+9dljhf67xUiiu7E0QyHxgAx0cffdQsQmFACBm9FHzAhc7T6utXTwSqFZDVc66qezpHBIoBEJKHH/7wh6aPmHaS1TJ44NGDS9m/0oatbDhbqSzYINkgQV0q2OCYrVs1SUk2l9drV8blc7s0Op3WXVuadXZwUt5cSq9eGFazL61cMqaxyWl5XdK5Sbfu3BDWaB5Fqmadn5T8gaBRhwr6PKqr8RnTQjw8SPDhjmAoiAIWvI5av0e720P6wdGLqkuP6NmLU2oPe7V7Y4d8kWYd2Niq7+GsXheYcTl3udQWCeiVS+OG1wGg6GoIGt4GylqQx2mxwpSwxuc1wGl7e1hPnBzSpuaQkdClggL4ONo7oZGptG7eUK9TAzEdXFtvOCVsB+f1g/94q3ypsWtOi/St/64kXhKsbrLqSZIBV8K2+PDhrLyTBNsvzvlqEnpY6HVVDr4I22RVu5AkbqtHVAULeRsrvQpP3FjYsWCE/Qd4WvI6+2yu2Wz2HZWRuZS0aPMBjDDXGIAcVtG5d69U1Qwp9zNnzhgAstKj0lzZicfTTz9t2sGI0S/90i+ZxQlA8r//9/9e//bf/tuiju0rHcfq51dGBKoApDLOQ3UvShCBYgCEhyOqITfddNOy9MyW4DDMJpCgZOWNsv9KjmuBDWdlg+STfWY11JIRr7XfzsoGr7OO1YW/N3+T9PjxATX685qYnFKbL6Uz/ROamIorkYWz4VZdJCwX7tL+kBIuvz6wv0uHeyYNL+PxE0NGehe+BtvH6+O5c2OmXWo8ntG+rojx4QCIwC9pCPm1pTVkqi34cbzRPaEdjV6NjQzqxKV+NXozOh4L6oE9XWoyXhJeI5P72LFB447u87gNbwMFLHw5ACEAKJStgn6Pzg7OkMoBQIALeCDHe9nXiJ4+M6q6oFc3rqvXa1cmdGBtnYYnU3q9e0I3b2gwylyBf/i4PJeeuea0SH7ofyq76yMLmjqF8rckxVw/FmxwjmnD4nX8DXAP4CDxpDJC0vFuGYvliwDgnOaJ/FxYPbKAg3ivNOdgrvNpOQJUyqyYAXPEghFWxRejpEXrFeqFxIv5xr3Gtn4t1ThvrmMq/PuVK1eEKztCJis9WPRBop0FtUq53ni+4vuxbt06Uxn7/d//ff3Zn/2ZmbuWw/OLv/iL+uVf/uWVDl/18yssAlUAUmEnpLo7i48AD0PnCi1b4v9PPvmkIcOVSzVk8Xs8+zsx4eLBt5yrbjaxtL38JEfONioeeM7V2ELOBpUmkoRCALIQsGHdmS2BeSIa1fdOjWl9TdL4aawJu0xVw1MT1NqmenW21KuuNmxMBFGXcrtk2pXgZXQ21JiKxG2bGo1qVi6XF/9evxzVQ7tbdKI/ZtqeTg9MmaoKalmY/8HZoLXK73YrmZ0xA6RS0juelM8jvXi6V1sDU7rUP6K8y6217c06Gw/rp27eoJHpjAEcgJzvnRjW7s5aYyAIGZ7KyOGeCYV8KGHljX9HQ9BnvD866vw60T9lPnt9Y9DsPzwQOCKoewE+bJuN5/R3FXjkUwaY0frlHPwuH25T4jMvSx7/rBPsWvK3JHuFbT4QTwvbfFgFBySTfJJE8x6ACMnn9VwJKQzqbHwR7jfEzMmNsYILrOwXksRXWuJ1qfcxgAZtU1RGqGTwf8CCVdJiXi1EScv6S8Aps+R14me9KphncylpLfWYeD+tRHxVQjWaaiTkbrxRKkFUxfqScM/n2md89atf1a/92q+ZKhbS7P/4j/9o/vY//sf/KMXpqG7jOopAFYBcRyfz3X4oxQAIDzzUmfbv33/1Brka4sSK24ULF8qmo25Xu52tH7OBDbvyPVefOeosmI6hUe8EHba6QdwLiaokKRZsWD8I2+9Oet2fCerg+gYNpgLat75Frw8gp4vBoN8oRQU8Lr1yecLwK6hgUPGgWgBJfDKZ0d7OOsXTWaUyOeOlgULWe7e1XHUMf/7cqKlUbGlDQStptkPFZE19jZHG5W8YENI+BQiZTmWNvO5EPK3oVFyXegd07NKgdkWSmsoHtG5Nu9ra2/Vq97Tev7dNA9GUqYbU1/jMdiGee90uA1IgnL96eUJBr9sgieaw33zuG91RA4ZQ76JqQrvY21FGXr4n/7N8r3716q8tGMn7wkr+zN8qt/bH8s1O+Vt7vok554Jz6gSWnOv5iAE498cmngAREk8GpFSSDr5XQstQua95G2OOn9ZJG1/7ucQYboMF8MUAXbn3cTm3z/2FODAn4LIxz5gLgBG+24UG4mZbLdk/J3kdA1mAGuam9t7BPcKCEYAfcbTk9XIl5NyHe3p6KoKPV0mmiJwTnq+0YEFABxAyABpf+MIXTDWkkq59nm9/9Vd/ZQwSkVWGe7Rx40Z98IMf1Oc+97lVxRFdzmu5nJ9VBSDljG5128sagWIAhN+V26G7HAd58eJF01P74IMPLnnzztYaZwLKhq3zcSFnYz4PjsLKBmpjrHLyMLKeK/Y1JBYWbDiN55w+EE5pVhK2cxM5HVg34x4Oz4KWJGRwZ0ybXcaoj3ame7bDB4kZ8PHkqWFDAA/6vWqL+E1Fg0Q+m82b1ih8OlDRggRuWqvaa011AnncDU01+uejg8b4L57KGpDA17NnR7SjPWI+D64GQKd3Im6SpWQ6Z7gaJy4PaWSwX+f6RjQSz+rerY3K17ZqXUericnTZ0b0vj2tGp5KGw4KAApAwmdSBcFhfV1jUG9cGZeXFq6A17SNzTryeXnOPi7v639hvCTy3qCy2x5W+sZPacrXcnXVnfNNjJ3yt84Wn1LL39pqAJURzjMJpLNFay4Qu+TJvgwbYE6TzDgrhcUkhmlBYcWepJFEjbiX219kGQ5/wR9BO5VV0iJmXA/IuBILFixsi5ZTSYsYkyTCLeF+Ung/snwcpyKTbf1i26VSAeNgWQwCSGFEuNKjkkwRiQWVTyrfgETizvjSl76kP/zDPzTVsPk8R5YrpihLshCJJD8ywewvHmFUbAAi/LyalDKXK27l/JwqAClndKvbXtYIFAMg7AAAhBLxQg3ylnXnCz7s8uXLRvqRG+VCxnzBhgUcJP3zeUjM1UbFPtKmwGohyRarvRBHScKs+ZxNhHktyYJVS7IVFqcpGlUAuBmADxzKp5M57eqsNRK12VzOtCYx8MrA0G93Z1jffnNQt2xoVCKTM4AF8IGjOWTvaDxrWpoAH4x4OmfI30H/TGtVwOvSkZ6o3r+nTX3RpJHxhQ9CKxZmgGeHYqYVazKe0ZHeqHZ3RIzTOaTxvomEUagCFyVSGa0LJPTamW7Fp6KaynmVr2nQx27drPGMzxgm4iHy6LEhPbCzxRxbKjPDD3n6zLBq/V7t7Yoo4PXMedo5J1aNygJLEmGn/K0TbCy3/C3n27ZoAUw451bSdzW1GxWa+xFra+4H0Ha2JRaL8WL5InNOgFX4AipDtGiR0Nt2KivpCwBxCluQ3DJf4BcAXLk/FLtXEV9AHttlVdu2flEZIclcqgob7bBUtirBVI+qEok0SfRSj6sU04drA5XJAwcOXBV5+d3f/V393d/9nWkhrqQFBwAR9yNAiHP8+Z//uT71qU/pv/23/6b/+B//YynCUt3GPCNQBSDzDFT1ZZUfgdkAyBNPPGEeYtcyyKu0o0N5hQcNAGS2m3gx0jAPeIaV6yzkbJQKbDgrG84VYZIzkgHb686+8KCkF5zVTsDGtRJhtgX4gJvx0sVx065EhaC51m+SdZL9dCZvHMUxHkTytrXWZ9qw3re7Vb0TSUPwBqD0TyT1nm2NOj0QM0DhGRL8gNeQvuFjhP1enRmcMp+Bt8ctmxqN9C2mhVRExqfTum9nqwE4AASkcdnu/TtaDFixTufnh2La2RlR/0TC8E+ujCWMN8nk9LT6B4bUmBlR/2RateGwaptaNJYL6SM3dBlPD1q6qHwAPqh4UGEpNogLD3tngsbPNhFmxdcJNiqJwExCSGJoXbY5PsCpbdFaKXWjYnEu1ppI3BlwDwp5GwvluszGFyEWnL9KStjKdU9kPthWKpJCe89y3rdYwLCtgcTE2bp5LSUtzh9gwaq28V7mGmCE1q/FzDUq0dzT4F2s9OC4kGiHEL+YYyn1/heTBaadCTle4rYa5jP3Ua49FLu+9rWvlTpE1e1dIwJVAFKdHtdVBGyy4DwojJFQ6MCle7UMVmpwQ6cFiwcND1Ye2k7OxkqBDacHhG2nsn3cVFQsgRngwf5a52NASFdXl0kGij08STJI7OFJQODe3ha+qihFq5MhabeElM7ltbklZGR5g16PosmMbl7foL4JKhduYz4If2Pfmjojbbt3TZ2+c3TAVBYwAMT3o67Gqx+eHTWcDzw9cCKnokElA8I6BYiDaxvM+9tqAzrWP6mgz20+xwIkFK5ox3rP1iaz37R3XRqZ1sWRuGnt6o/OAJLusbgu9w+rf2BQfSPj2l4v+euaVd/cptbmRkUTWXPMblwH3xqFakk8JK3AAklvIdhYaCK8UtcBq9p2BZy5QYXMtmiR3C9nwmITYSeos9eUVXhzxhmQV8r9o0JkY4HaGNUUVvyJR7n4DMt93p0yw9bXxNmuZiuhVjHJ2a5GHLhXcB9ZCHndHiPPAioG3H9s6xciGWwTgDOfxRi2derUKXMfu+WWH/OqljuO9vMqyZOEfSomC4wHyI9+9CPz/Crl9VKumHN+6ZD4zd/8Tf3BH/xBuT6mut0iEagCkOq0uK4iUAyAQJLjwb59+/ZVcayADTgglP55CHOT58u5QliOykYhQdy2+Dg5G4UtPraiYdupismGkuiRCEDkJMGwSSdgxNlzS3sURGy4GXdsaTKme3AwescTGp1O6ab1tDultLUtZAz9aKGiTWprW62pXFCxoEWrpdan9c0hI20LD4TqyL3bm02VA+4Iaf5LF8f00FutVQCdgcmkzg3GtK2t1nwWFRPAB/K5U8ms4ZVgPAjooBUL8jjbxsUcuV7AB+1a08ms7traZF7H79h33NO3toY0HEtrR2uNTl3s1ulLfZqajqsj4tfWdTNqPrbCQbJk5W+tWpKzXa2U/e0reUGQ7NsWLY6dpNu2aJX6GJnLVuzAAg7mspOIvxjvmlLEz/IZbIWI63+18kWsbLfTRNECZwCWjTHHN992NSqn3AdppwI0WDDiJK9zHgCNlsReeF5YqbfkdX7murLk9bmAL62wzJ2bb765FKd7SduoJE8SDqSYLPBnP/tZA9pefvnlJR3rcr35E5/4hL7+9a8b2Wdayapj+SJQBSDLF+vqJy1DBHjYORNpPhKSHOV31JkqbfAwLWyrsWCDfeUhTeXAAo75kobn4mwUAxskveyLE3BYPoFNHmwivFiHax7+JJ2AEc4V2wGIDGbDcrndRrGKigXGe7RCnRueNnyOTS1I7caN6/m/HJ/hT9AORcvS5dG4BqIJ08qUk4yCFEpYNR63UcLCawO/j3w+p6GplCGCP7ir1fBDkL090TdpwMntmxpNlQXgAKhgX/ABAeQATABIKGGNTWfMfqxtrDGv428Ams76gHZ2/BiQsP2hyZTu3takN3unTFvZWCypl88NqtaVVCQ3ZVZWbRsV5xtXa1pGrJnj9a6WxDEzFwGmzAuAKoklMQCMkHQutNXEtqs5q4XM62LcGK4rrqmFfka57iOriS9SWEFyynZbk0on4FholY77A6CBKhHys4APKhjMC2sqWwyMOJW0ipHXbeWJbfMZgF3AyGyVJ1qeqPriJbXSA24gPLtK8CQhFkjtkrjfdttt5t7F+IVf+AVzHT/zzLW9ipYSS4DuuXPn5rUJ9ms2R/Y//dM/Nf4kcD/ggFTH8kagCkCWN97VTytzBIoBkOeff94k8Hv27Cnzp1978xZsOAGHBRs8NG1yz77ycLe9vlZRaratLxZsADScYMPJJ3CuuPNzqQmPVroVIPKD08MK+93qbGvWgS1rlfMFDT8ik80bp/GWSMCADJ/HZQDCB/e1G3I6QIN2KCR3IZrTPkV14okTw+ZvxIVKCG1SQ1NJQ/amywniOuDASt5SydjeXmv4JAfX1umJk8OmirKpOWzasvjb8+dHFfC4jXQu58p+NhWakamU4YgAStgf2ql+dGFMdQGPNte79NK5IbX5kro4NKHTg9Pa1SiFfO6rrWrW3A+eBIk4ybBtS3q38ALs3CaxsIpJJJ0ksiSH1+JIOFfd7bVlV90huxe2q5V6LpfrplKoKDafWJRrX2w1tNCx3aqrFXoEkfSVsv0GAGCd17ln2goG1wlgvZiSFrGYC4wwx5hvJMzc/7gWbWXEVuHg4jHH8JJa6UFlHHI3JPRKGNyzkEu+4447riqP/dzP/ZyJJeIv5RrEYb6cTsAaZomF45FHHtHHPvYxfeADH9A3vvGNijf9LFcsV3K7VQCyktGvfnbJI1AMgLz44otmdaZQ/aLkH+7YoBNs2KTICTYKH9iFlQ0S0Zdeesk8aJz94AsBG3Z3bGvPXGDDcjcWulK5lDg+d25EbUG3rvQPKDUxpIGJhKZVo32baLloVVfzDDCg8hBLZnTb5iYDPhpDPh3rmzRtWLRtARQw9nv02KAe2NGigcmUAQT4fvB6Kh14d9BaBakcI0BavNY2Bk3l4mhPVBubg3rxwripmMAhgYhOe9a3jw6YykZD0KtYKmvAx7NnR1Vb4zVcEuR91zYE9MKZAbnScV0eiiqYm1Y4P60L0by6wi5NuUJqrg9rR1ezAZqzVbJItKgE8EVFinlLhYhV39WkHLWUOWHfa6tltCbZWJAc2nY12+ZjBQ9I0AtJ4qVu5SrFcS1mG9w7iANJuJMvwrywK8+L2e5s7yHhdrZROR3brfKXBXbLra7GfcxyZ7i3cY4BIjYW3COdnBF7jNcir1uhBMAIxHj+z/GxXf7PqyCOzQAAIABJREFUqIT2nEqSBCYmEP6RS77rrruumo9+9KMfNfe3b37zm6Wckm/bFtc8rdXzGbTwFfJ3Hn/8cX34wx82wOm73/1uSWWb57NP1dfMRKAKQKoz4bqKQDEAQi8qK2YHDx4sy7FaV+lCgrizv9zJ2ZhPGxUrcwAnbpC8nsH27Jf9f+EBcfyFbVQkEwwS2MLKxnKCjcJ9BVhQsaCViooDwIDkIpQa15X+YTUEpMuZOt2yo0t5X0g3rGvQ6cEpJdNZI6OLalTQ73lLucqlY31RfWh/h+FcACpQraIF6o7NTcZIkNYqnNHhdeDD4fW4DEg50h2daa2Kp428Lr83+xT2m8rHe7fPyOVOJQAfNfrWkX5tbfIrl5rW6PikQrmYXr48Ka87p5BHCoeC2t7ZoL6kX53Ndcp5arRrTZ0BKvMdhW1J/J+2E8DIu8ncj957risSHa4JZ7saiTDJBYRi5nWpV93ne66W83VOvgjJcin8RWwrlQUcfC/m2G7vYSt5z3DG2sYCMEIsbAXDEvnZT1sZcd432cZ8lLTYJi1GvJfnx7Zt20wL2Eq261WSJDBxLKbK9dBDDxnJ+7//+79fzktj3p8FcHn/+9+vffv26fvf//7V5+u8N1B9YckiUAUgJQtldUOVEAGS7UJyIgZDlOJvvPHGJe9iIdgg2Xea6dkqgnN1cD5qK05OBj+TBKAksnnzZqPgVfjQ43iKgQ2nUlIh2KikFXTABpUEqgwk/BgJ8v/GsN+Qyb3K6vHDl7TFP6EzQ3HtaqvRmLdZjU3N6mqqNcADKV38OZDRpc0K4jrggzYpwE190Ks9a+qutlZh/Le2oUZtkYCpZMAZof2rtdavgM+tltqAUcm6OBozVHVauiC+j09Oq294QplETC9cHNeucMKYEiaz0vrGGh2ZCGhPV726Whokf1Db2usMNwTuyPqmkNrrAkuad1Y5iqoI843EiiSLtiQLTpf0ARXw5kK1JGvyZ69lq5Zk29WoEAJIuC6oihAPgEgp234qICzX3IXF8EWIszVRdKpS2cUSZxso97DVwkGyLZ0kxIBV/s98sEpazJPFKGlxP+X5wTUIwGE7LAAw5wC/87m3l3IeVZIkMMdVTJXr7rvvNot9f/EXf1HKQy/JtnimPvDAA6Z9CyDCHKmOlYtAFYCsXOyrn1yGCBQDIG+88YZ5gBw6dGhBn2jBRiFnYzblHMDHfB5IhWCjWGWDz4YDwsOUhx4rbyQHTu8PCzaKKSUBNio1GUNdiuQf5SoUp3I5GUI3DuHwKaZSWQ1PJfXAzla9fmVC68I5PfLyefmSEwp58mpsatSW9V06Pe7Stvbaq61V54djxpkcWd41dQF1NQZNaxXA5oULY7p1YyMiWKaS0dUY0D8fHtDtWxqNclakxquQz6Pnzw4r5EoZUBlxJTQ6HjXqVZm8FM/5dOvGenlqauXyh9TZUq8XLk0aX5BMLm+AE61e3z85rMawVzesLb2vAxUiqxzFnGZOWGnj1cJt4CJ0ygzbyqGt1Dk9TaxaUjF1NduuZk3teB+grFxtSQu6eSzzi2fji3Df4P5iJbydogdUjApNFOdz/1rmQ1vwx3GPhNPBvACoch8ENDAv+M7/F0Jef+2110z1mMUgq6RFZY7rDZEEwMhycbVQl+J5tNBn2YKDOM83FKpyMdfwS7n33nv1x3/8x/PcyvK8DKNceDxcC1/84hfNeXMO/o/sfXUsXwSqAGT5Yl39pGWIQDEAgh45ycq1jKScYMPJ2SgEG7bHvJRgwxkWHo6WVMuNkhYAkgar4MPfSRx4kFqlpEoGG4WnHPCxtiEowALKU7RAUXWAc0F7ldflVk5547eBlG17xK9Xr0R1y8YGJZIpDQzOmIwd6Yvplk6f4sFW3bd/k86PpzWZyKqzbgZ4rWuaIYQHjWpV2rig4+8BJwQyOyaHH9jdrJNXhpVLTms6NqUXLka1tTaliZTUUetVqDaigVRAXS118teEtG9dk5HkHY+nDGiBd0J7F2aCo9Np89lUZFoifnXVB8s621nhBZwCRuhRJ3G0ZO1KqwQU87AplBl2JsILbfHhGqUaQixsWxLXBmCEmBQDL2U9OSu0cXsPI/lmTlDpsIsdzA9izNzgO1+rCbAuNqRwRCxfhPspcwHQQGWECgbxYX5yPRUqAxIz7iUAEHh4VkWR17FAYcGI5aFY8no5q5KVJAnMOUGVC0I4VQ8GsYEr89M//dP68pe/vNjTVpb3QUQHGM02ZiOrl2Vnqhs1EagCkOpEuK4iUAyAoGICqIBPwXD2PFcC2ChUo7LJmSXVWq8Nu7KH8gh/Y0WP1W/A0GoYkME76/165dKM3wetSVQOaKV68cKY8dQALBzoiuiNnqhgTMRSOe3urDUJPy1NcDomEhnd1OHTk0cuKpIe1dHhjNob6nTDti75wg1GsvepU8Nqr4Pn4VZnXY1SmYwu9I9qPDqpvtEpbQkljLKW3y1NZz2KqkYP72rRUDqgbWualHF5DYC5fXPjVblfZHlPD0yZakkulzfVFyouKGwxMDiczcm8nOeH+cJqLwk4SSdtM7YSMJeCWqn3i2uL5KyY0hsJXWGLT6nN/UjCScCJBavfFphxrZBwVmpVcKHnwbZSOYni1teEY7atoNwnWK3nnlEKvshC97OSXk8cLJGfBSmAriWvW6GPYuR1ZGYBbJjVFQ7bLgvIsUpabMuCkVJff8eOHTN+QaVoJy7FuUESGCVDSOgWgOC39Yu/+Iv6whe+UIqPqG7jOo5AFYBcxyf33XhohQCEhIgKCJUE2hEsQdtWNlitKiSIz5dk6FSkKiSHO1fTDNJ3ua66mdv+dqfhXCHYIFGbrf+ahyc3feulwf6vXbt2VofxSpgHkMCpdJwZnNLuNRHD20AWN5nJ6sxATPftbJnx4Fhbp6dOD6sp5Dc8D/gZEMD7JhJGltfvdWt/V51pzaK16qULY2rxJhQdGVTvyIQ6Il6dTNTpnu2tmphOyZuJm5L7sf6YGv1SWm7t7axV0huWvyasnLdGXn/AqGuxj4Ai3MwHJ1PGKwQuycaWoKLxtF57qxIzGE2Z31FROTMwZfaT1itayFZyFKsEQFwHjJSDPFvIJ7DXlpVmtbwNe32RmC1ni08hMAPsWKPD1eY0blvWnIDDEvI5FqffRjGRi8XwRVZyLpfzs5m3zFULRnhmUFVmbnCdOGPN6/g/99eNGzdek7zOvAf0UhmxPBTmPmCEqstCK3vFYoDiFJ9TCYpc7B9eHByvXdwjtnhu/Pqv/7o+//nPl/M0Vrd9HUSgCkCug5NYPYQfR4BWDG7+Nsm3q4K8ohhBvFxgw8rwOqVvrbIMn+kkiLNfi1HwsW049OFah3GSTaoi5WwDWOh8OzUwqbFYRm63jHJVPi9NJtOG75HLSzdvaDBcDYz6vvPmoA5taFAyk1NDyGcqDKhbkeDT6rQH5/HuCaMohazuttawkolpXR4cVyw6blzPb2zMaCgh1fqkvMdvTA7fu6NFI5mAbt7caiR6r4zF1VobMGaDSPNS2YCI3jeeMN9R3LJE+XPDMfVNJPXQrlYDkgA+gKIXzo/pwNo6dTWUt91qofHm9SSnJAZUAqyfhiWuO93nF7JtVl4Lzf1sEmylWZ0tivO9thayD4t5rV2lti1a1mnctmhVWiuSU+jCAg5bFSWJdYKNxXj0cB7t3LBtSXN5rSwm7pX+HuYFVREWcmzLmt1n68tEK5+VTAc8OxeW5lLSYpvEmXszgwoccaZ9drFtgXhusG/LKSl/rfNYSIonPoCt//Jf/osx96uOagSuFYEqAKnOj+sqAlQ76El1rr4CRiiP33ffffM61oVWNmzC4AQbtMIwSMIs8LGgYzFgY64d5/NsVYQVPR6crNotxkl6rs9ayN9fPD+qvGQMBakUuF0uXRiOye12mdYrTP6QwUUWl5anB3e2qC+aVF2NT70TCUNUv3NLo84NTRuA8r03e6VMQvlUXK7klBLTMQ1N54wDesZTozs3NyiaDyrkzetE96gGxqI62OrVhK9Jd+/doJ5ptwE+N2+oN9sEQFCVQYKX1irUr3Z1RARXBRWtiyNxI9GLeSGABPI87upUbe7a2mTarip9kGRZbxFWc7k2AKm0n8y2KsscssRl205F4sooRRK8UjGzlQDiQVuSddcGjFAtWu4WLZsE2xgDOKyq3nK0rC23v8hKnXc+1+ltYoGds4pkeX3cS/m7BQ22MsL5WKySFs8fwAjbZTuAEMtDWUhVkHYwAPPevXtXMpRXP/vkyZPmPmFJ8cQToAUB/bOf/WxF7GN1Jyo3AlUAUrnnprpni4iAM/G3b8e8iV7V+++//x1bnA1s8MJCOV+SE8sfcYINEjyGs/fagg3aI5YzqWH/eNhRFaHtjIeVrYosd9sJiT2GfyG/17Rc8fObPZOG0zGZzGpHe61evjRm1KemkhndsL5B/RNJU4E4OzglTz6r9eGcDl8eUbsvoSfOTmp9KGNiXR+uUVN9RJfjPm3taDCtVDduaDS8DnglgAyI7VsbfXry8AUFEkN6czCt5rqQ7tq1TiP5sG7e2KSXL40rlclpz5qIqXLAQznRN2kqI1RZ+MLZHP4KXiW8prO+xgCm1Tas2RrJN1VCBgCVBIt54mwNtHPaVuucbYqrSfTgWueIqgK9+8SD4+W4bItWuSqItopkK0nE3JkEL9QvqFRzkPsg9wvakgr9RUiUK61KNNdxM9c5p1T/LNiwzwaqD5aIb4U8Co8PoE4cmB9sg3u7Ja8DVBkLUdKy+0sV3KmkZUnxVEbYl7meFUgCU23cvXv3XCFYlr+j1Mgx3XTTTebzALQ8b5Dg/eQnP7ks+1D9kNUbgSoAWb3nrrrnRSLAw9wqRtk/UxE5ffr0VYm9QtlbXufkcPD/xYANKhsLWc0q9wnkAQwQIalg9Q8FHFsVKfd+nhuKGbdy2qaodgxEExqNpXXrxgZdHksY8PHYsUFtaQ0pm5O6Ih6d7x81PI6xiSl5M9Nq8GZ0JSajhHUpUaP7tzcr6wupqb5OLo9Hr12e0D3bmo3y1P61dbo0Eld/FFPDgAE7VDIOd0+oIegzqlsN7qSyk0N67eKINkRcupSp1/7Nndq7sU2XRhIGhPzowpiy+bxxQB+aSpltwA0BpFAJ2da2vICy1HPErrjTFkJyBZB2Am0SbxIhJ29jrqSo1Pu43NsrxglgAYFEainJt23DdPI2nK1UNgm2sV5sW06p47Ua+SLE1VaRAAz87OQiOWO90Ao0CbZV0rLyu9Z7hu3OR0mr2P3WqaTF/gOAnUpaxa47THWp1BQjxJd6Hsxnewi88GxB3pZB2xlyxZgQfvzjH5/PJqqveRdHoApA3sUn/3o8dB6egBBnZYMknJWaW2655apiVKHkolXvKaxsFJPhJTlZbkLtUs6VVQYiDjycaaGxVREexqUeJPu0UEEwp5JAVaO2xqvtbbW6MDytjohH33q9Wze2uXS+f0LhXEw90ZSiKam91qtwuFbbOhvVPe1VY31YsYxLN29oNMaAVFIAMyOxtO7b0WLatmjNAmgAdgAiveMzlYxXL42bQ6vxu83+4I5+tGdSEW9OL57qUX1mVO5MUhMK6tbtXToW9RsTwfVNQV0ajZttvHZlXIlUzsj40qK1mgZz1yZmTlUqC9CZwyQzJD4kWYASrh2AquVHVAqPY7ni7pQ3pkWLATHZtmjNBtwtsHO6iZOs8nvbSuVMgldLFakYX8QqRy2X90Xhub8WR4a4FgK7Us1hK79ryevEhmoE8eCLeymvKaakBZhgP4rNH8tRojJC9dqS4q2JolNJCyM9rk+UpiphFHJSkOWlPeyb3/ymPvzhD1fCLlb3oYIjUAUgFXxyqru2sAhwI//t3/5tfehDH3pbjyygghslDwxr3EbyZeVC+bvTzdzyR2wbVTFVmYXtWeW8muO0VRHbr0tVhCSrFFURAEZtjccoXF0enZZHOXnzaYXycZ3oGVcyPqULo0nd2CINJL3a3BpRT8qvutpaHdjQoqmMy8joPnlq2LiWU8nY3BrWWCxtfENo1cLH4+DaegM+qEgg4YsHBwR3CxwePzGo9khAbRFUtPLGe+SlS2MK+zyG+L6moUaRgEevnutXcmJIr14c0dY6aW1HqzLBJt22o0svXZpQ0Oc2JPXVMGyPuxNsWLNKm5g5SeKFbSeFErYkTCRBJN8rlWyuZNythwQtWlw3VraVeNiWNWd1wwI7J/+MuK2mxYprxXsl+CLc0wHHTmDnlBt2EvKJNUpnyzFsyxqVEYAD91LAvAUjzJXZwMi1yOsAYFrh2C7VBOYUx2grI7Rgca/eunXrchzmnJ9RyEmh0+Dmm2/W448/XjX1mzN61RdUAUh1Dlw3EcDp9LbbbjM379tvv91okT/88MOiTPzSSy/p4MGDV11w7UGTHNg+YB4g8zUYXO1B48HGgxMwwsOdBybEZL4Wq11/bnBSyiTVMzSus/3javYkNB6LqyUgXZxyq7kuKFcgrDu3tmoo5VNbY1gn+mPa1BxSU9in4amU4Vc8emxQ921vVj9yt81B45YOYRzTQoANrVJUPGoDXqNmRbtUfcini8Nx8/onTg7plo2NhiBOVYSKxnffHDBgJeD1GLnchpDXkN8DPsBSTmvrvJoYGdIrZ3oUyMUVV0C3bO/ShnVdy5bULGROOVeBLeCwKmtW0rmQt7GQ7VuXcZJvqihcJ9ZbBDDzbhokl7YFh2vFWT3lurH3j0prpSrXOSonX8SasDoBB79jWOd2W+GolIUhQANggcoI3/k/VQr4RFYEZDHkdd5jlbRsNY44wEGBA1IJLXuFnJQ33njDmBI+99xzV6V5yzUPq9td/RGoApDVfw6rR/BWBHhQsSLz1a9+Vd/+9rfNA4FVXG7krDr9zu/8jt7//vebhBJCIjd3kgtu6LYKcL33uxebLKwo2qoIsbLxQKlltqqIJXlaMu2ZvnFlktPqjeUNyNvZFlbGF9b2zga9MpjVoU2tGotnTIsUClK0ZiFlu74ppJDfo8Fo0ihkHe+L6kP7O4zcLYpTVFSGYzOqVRDM966p048ujhrHdAMkwj7DNYFzAri4MBLTnW+5k8dSWaNk9cTJYT28u9WYHMLjwGMEkLKlJSSvx6X6oF+1AY+O90+aFq9ALqlMdMZxneMkDgCza8WjnBdhYawBHE6lJCsTWg6VNZJNWrMAIrSH8H/iABhZqXgsV6zt3CbWDKtoB+gAlHHdMK7neMwV62J8EVboSb7nmh+2pamwbY3PdBLFLbArhY/GXMez1L/zDOI64d5hjTCt4hXfuTcWI6/b+cXfi91z7XapMNi2PrZHZYT7dSmq14s5dhb2OD87duwwb3/xxRf10EMPCWBSKWaJizmu6nuWJwJVALI8ca5+SpkjYIEEyRk34127dmnTpk0mUaAycuXKFT3wwAP6pV/6Jd17773mNbYKwN94H8AEIEKyuRoedqUOKfHgwQkYIR6sdBMLkk2SYKdyj5O8HHOF5A+GFVNAWzoatbG9QUOxjOpqvHr+/Kg+uLddx/unDFcDA8FsLm/ao6g+kPhT3fC4pGgyozu3zBgCtkXga0QNgXxHR63ODMaMAeGjbw6YigYeIWY1MIyz+rjqgz6jfkWVA3AzGc8YL5GLo9N6aFebkfQ14MLr0pOnRoynBzwS2sXYz2fOjBg/DxSvAEIMu/KNvDHxKDd3hs+0LSfONipLqOXvheZ+y7kKTBJkVaNsPKy3SLlUo0o9x53bI9ZOVSrmN/Pa2Url5BMUKtrR3mbjwftoy7Ita4DCd9tihm1ZY+HH+os4+SLFzBRtrK1UuRVAWChRvJzzZLHbtiprVuzBKl5xzVAhcbZoOYUgLAgpBkaefvpp84xiW1SwAcf8DOgj1vNR0lrs8RR7H4ADALRt2zbz5x/84AeG+wHnkmdwdVQjcK0IVAFIdX5cNxH4m7/5G23YsMG0WjkTIhKLv/qrv9JXvvIVnThxwtwsac/61//6X5sHAYPXkHjzsODBwMrSunXr3nW975a4TBz4squ/dpIA0mzLCSvuoymP+ibTph0KUEA1omc8YdqaUJG6f0ezjvRMaldnrZ46NWLAA2CBz6kLevXi+TFjMjgeT+uGdRgCxgzvAxldXoszOYBkQ3NIT58eNtWNZDY/sxJf69Njx4aMkSHeHLRo4U5+3lRD3Epkcrpxfb0hwQMp+IyLo3F9YE+b4YpQeWG//+X4oO7e2qTm2tlbi0ioACIkV5Y7AzBbqs+KTcqcgMO2nBBrZxsVSVoltF0wF4gHVRGrsMZ+Vqqxn527nDen3wbXvOXIEOtCg7+FkJe5Tmw8rNeKlfR9t7WsEW/izMKPrTKTTNvWtXdj2xrzw95TaW9kTli+CNc1AGQ28jqLZRaMPPXUU+b5BQhhIHRgeSgAHmJr+SLLAYKff/5583lbtmwx+/Poo48a9SuUJ3kWV0c1AlUAUp0D1Qi85evBCg0mSah0cLP+2Z/9WVMVwVmWmzzJH4kEVREeFAAZgAgPi0pJ/kp5Mp3u1tYHwpkAc/zEhQco8SBRs1yRE0MJQw7f3h42iT88jqPdkwrXeJTN5XTD2noDPvDMONob1c3rG5TO5ZXL5cW/1y9Hdf+uFp3qnzJEbxzPp5JZNYd8qvF7jHkh5n81Po8BNbdvajREdCoduBviIfKh/e06Pxw3r0V1C2leKiWDkynDFRmcTBr1LNzXE+mcbjEywHHVeD0GtPB7qibzHbZqBhhBUYxVbxLN+bjP2wTYxpkE2Mqysh0LNmwivBqqcE7VKJJNkiXrqg24X6kqgFW1cwIOp7eJE9jxc6lAgvVaAZjRisNghdi2rC0E1Mx3Tq706+yihfXcsPPbKghapT3uH8SHeHPNLEXieKWPebGfbxWvLBjhXktlzYIR7q+zkdf5zGeffdZI8DKfnIP3EHfrMWKVtCwYKYfaod0f7n10GzC+8Y1vGP8P9oPFmeqoRqAKQKpzoBoBRwS4WZNA/umf/qnhi5AsQF6nKvKTP/mTJsm2ve8AEUzbSBy46bPytBrbTTh8VmadZnP8bN2tCxNgkmBnUmYfcLZKNBzPK1zfqO0buuQJ1qop7NcPz4zq5o0Nxr384No6o1LF++B6IMFLS5StjKBmhYcHLVmAj6fPDKsu4NX65pAhjq+pr9Fz50ZMixVO6lRJeE8smVU0njbO5fdubzGtWW11AfWMxXVlLKEHd7UYqd3dayJGrvdUf8y0VQ1MJk2FpXssocRb/JNNLSGF/YuX1iWhZR4BWHngk1jxMOahTyIOaLNta3x3GlZakGG/M+dWKlkv1c0BMMW1RExINhEz4Jrhq5zqRDYBdipSFfpAOKsby2UOalvWiAn7xgKGbdFif1br+XZWkqznhq0kcc6dbWtOUY+l8EVKNUcraTsWrAJGAKtOcMY9hPlSKDbB65DgZR5ZNa3CY7JKWoAAnl1swyp0AQpKBbb5XFrCAB/r1683u/G3f/u3+sxnPmMqpKv1OVlJc+R635dqC9b1foarx3fNCJCAP/LII6Y9i5spvbSf+MQn9KlPfcrcVEkSSKZIqvjiQcvKLlWRUknXluMUFa62k5AVqiRZ0jLfF5IAXxyaNA/M0aEBDU3E5A8EFPM16uN3bNOpoYRJ9JHRBZTA8eB7JptXzwQroHn5PW7jqwH42NgS0gvnxrSvK2JI5VRA8Ov4zpsDuu2tigcSuoASCOa0TbEtPgMDwnDAq0sj00bxCuUr1LEwD3yzN2pI5/dsb9bh7qh5PSDl/Mi0NreEDcG9VIMHvJ0fhS1rfIbtb3ea+60UabRUx3yt7QAISEwBZtZV21YBuGaWWgUoVEpibjtbqWwCbOf3Uj+vFDEDfNoWLe45gCDbolVOcLbUfedcsu9OoriTlO8EG/w836rdXHyR1QrOFhtv7teABeYI5HUGi0LW04p4MGeY0zyXnNX4a8n6cm9CQQuQw3fOJ88vAA5gZKlV/cKWsK997Wv61V/9VbMgs9RtLzaW1fetnghUAcjqOVfVPS1jBLgxI9cLEIFLwkMWxaxPf/rTuu+++0zSxMqSla61hn6WtL6SSYRdJXNWNwpX251gYykET1qhiFXQ7zEVhv7hCfUPDqk1P6YL0bxu2NiiU/Fa3bNrjWm3wgAwlc3qWO+ktraFTQVjT+cMGR2eBu1Re9bUmVaoaCItj8tlSOUfPdihM4PTWtMQMG1eJwemDJ/jymjcgIlzw9OaTLwlz+n3Gmf1Iz1RrWusMYADLooFOXiG8PmjsZTu3Nokn8e9pJlUzNyPRIHBPGCukGDxO1YBqYqQbBb6bixpJ1bJm4kB1wyJFdcMSYklrjMn5xq2lcpZ3bBz2yk3bMFdKVd359q3xfy9UFWM4wOcOSVbF7PdUr2nkChO3OdLyl/sPlh/ESpF1tzPgrNytQ4tdl9L+b5CFTCuD9QZGRZUcP3wszXDbGpqMn8vpqR1LfI67wEUAHIAI3wW22XuWSWthQJ19h8A4mwJ+8M//EP97u/+rgGt1/MiSynnwbt5W1UA8m4++9VjLxoBEvm//uu/NmDk2LFjhmBHe9bP//zPm9UjbvRO6VqSCB4QVEXK3ffu7G23gMNpomhX2y3gKKUJGkpSKFiF/R5TYYBM7nbJAIhXLo4qPTmql870aWsoqZQnqE3rOqRgo0bjOd2+pVHnh6aNEtYzZ0cUCXgNtwO1K0Sn4GrA0RifTuu925tNaxUE9NMDU6Yqcvc2KhkTBnwANCYTGdOWNRHPmBYrFLPAFXBEOupqtKEpaEDOzs6IztGmFfGrvW7hJmV2td1JErdta6z2OrkExNyCDB7OcCJIvHnoM2d40ANGllupplIuc1sFICYkusxV2rNoJ7HGbYC7QtM55jzxA8w5V9yXAqQrISbMLcAZibcFZ5Y/sxzGj8SV+5gz3rZKaue2s5pU7hXtcvqLVMr5tjwZG3OAhHPzgzioAAAgAElEQVRuWxUwWtn4PYDE8kW4fqzSGtcM52YxSlrEwjrcM/+YA4APKiLMv/k+wwBHzzzzjPbs2WPex/jyl7+s//7f/7uptlQBSCXMusrehyoAqezzU927FYwAD2husACR//2//7dZvf3Yxz6mX/7lX75qashNmAQCrggPCBJ+qiKlWPG27Q/OyoZT/rbQsb2cJor9UZSt8ibJf+NKVDdtqNfQW0TvFy+MGi5FPJ3T3s5anesd1vDggI5dHlbAI928pU2JQJNu3d6pbx8d1IG1dYbXEanxmooHYKa1NqDpdFY3rqs34CPgcxvfj8agz/A53jBckTo9fWbEtHRtaQmrezxu2q1euIAviMuAGfjpmBECPvAAwQV9Z/sMkX6uQTJQyNuwK5I8oAtJ4qy2z2e7POxJui03gsTZVkUqfcV+rpgt5u+29x0+ESCNQcJL/O1qOwmYk7fB3F7oCu1i9m2l3sM8sy1agDDmiK0CLNYY1HkshTwZKzlswV0xR/H5zO1yxYt5QJsn91bbkjRff5Fy7dNCtnut6obl21mwwX1lrrnN9rj3Ew8ACQCeeWFljvl5NvL6XJURnluWvA4Ana+SFvsAKX7fvn1mAY7xe7/3e/r6179u7nUrOX8Wcq6qr125CFQByMrFvvrJqyQC3NhJDiCs/9mf/Zm5uR46dMi0Z/3UT/2UeRDY1TuSKh6c3HxJIKiKkDzNNXg/N/9CkrhNyEhInG1U/DzXQ2uuz5zv3yGVJzJZ0y41MpXWe7Y26fRgTPvWRAxXA4I5ylTI5vIaHM3hadT5JU9iTC+e6lEwl9CFeEAfuXGd3OFm1YcDhpBONeP2zY3GcPAgrVWDMUMwpz0r5PdqS2vIgI+ut1qraN/CGwQZ3V0dtfrusUFtbgkZAEMLF67qL5wfU9Dn1qbWsHltseEEd3Y1srCS5KxulGK13c4R5o819ePBDRihFeJ6fmA7V9ttNcnZbmIN2qyqGNfN9dx+M9u1Z+eINX7k+qfthnsJq8zzveZ5n7OyUSg5zNy2CXA5Fy7me4+51utWA1+EatZCqxuLjY2zUsR9hEUwzqGdI7aaWEzW91p8EQtyLBixIMcqabG45hwAZWR4Dxw4YO5fjM9//vP6zne+o7Nnz17X97PFnrvq+94egSoAqc6IagQWEAFuyt/61reMlC/9r9x4LWl948aN5qbLA5MkEzDCzzzsSaisOhIf5+QRFJO/LQQbK8UfoDWKL1qbQj6P8fM42T9lWpy+d3LYGPrRmgVRvHc8rv7JpNY3Bk0lAqL3kZ4J+TwuXRkYU4c7qtPdQwp4XMqHGuWPNOknblhvOBuAj1cvjSudzWlza1iTiay2toaMrC6cDSR28QIJBzy6OBw3LVUvXhgznA74I7RuAUT++f9v7zzA5KzK9/1me99sSe8hPSGUhCaBUKWINKUIgiiKih3/iO2HIoKKKCiiSJEmRektCNJBegLpBdLrZpNs7yX/6z7xrB/DbjK7Ozs7s/Oc69oryWZmvu+7zzcz5znv+7zvghKbODjbJg76n+jzu7+hzf28uPPmTi84orEgY8HiK0YhfPCOkI6EGOlNP1En3godPtSL6dCqVPye94fv3O55e6HB/LDwZoeXRRWpIL63SLgL70icf6y8BgxYYMKkrKzMiQ8+Q3wjOy9Yg2LaL4KDRvHQ6EY8R91iwS8S6ehGd+43PsOIIvKeIdWTc0OwEhnxPYp8jxH+jx8/9iRGuOcQI9yDvpKWFyPcQ0RO3nrrLdfxHDHLuOSSS+yNN96whQsXSoB0Z2IT5LkSIAky0brMyBLgg5xur6RnEXJm8XT88cc7r8ixxx7bZlrnS2HdunVtpj8+uFlY+F4b7FYFxUZnKslE9oo+/mpbK+tt0aZqG5iXZilJSW6BT6+OjJQkW7W9zokPuphjFN/lwejnoiF0GB9VlOkqYY3on2EtO3fauAE5VlrdYJU19fbh+i1WVbbNBqc22JaWLDt00nBbXpVmowfkuPK7PG7cgGz797JSG5KX4VK1qJDFnx9srXbHocIV5vLm1lZ3PNcAsazOKK2bnrSrJn5QcIQ2nAuWwe3p3PbdzRP3EeeJYGURwRc9opY0vuLi4rjIo/blnYOCw9/fuyvL2hEXn37jKwKx8Pbla6Phjejp91VXXp/oqE/R8mkyXrixKPdFEBDTQZ+M7+PTlWPG8nOi6ReJZnSjO8y9p4jPEcQDAoPPEAQrfzKCUZFwxYivpIUYwduBoEFw8EPDwZkzZ7rvMMbFF1/smv2+++673bkUPTdBCEiAJMhE6zJ7jgC5uYgQxAg7PyyWDjroIJcCwYfx2WefbUceeWTbjhAf/OwCU07R13PvubPr2iuvLK1xXowZI/NtW02jM3y/vnKHFWSmWH1Lq+03or9Lm6Ia1odbd0VE8GbgCxmcn27PLim1oyYW2eaKRhtdnOk6m6/ZvitywR7cxIHZ9vKSDdZYUWqL1pfZ6Lx+NmzIQEvNG2CThxfZ04tLbda4QufhIIJCKtVrK3c4gYKbY2h/erWYba6otYrKaktqrrOMllq3mA+WGw41icfy7i+LSBYPLDS5dxCnvo9GaPpD12a1+89i8REUd5yn502ULrSbeLhlWTs6M7/whglRQzjAhEVVLM9l90nveoXQKmBEODxvfwwiZux283kSCb9IpM49Wq8TSb/InqIbQd9GON6NaDEIPQ7vFW9e5/uJTRaiF3zfEFnsqnndV9JCjCByGLwe73te/9vf/rY77quvvtpbl67jxhEBCZA4miydauwR4IP8xhtvtLffftveeecdW758uftw5wOfXWxSr8466yzXcZ0dSxYUpN6QnsUXAwsGHseiqruLtUjRwcNRUdfoqkZhBMeH8dSirXbAyDzbXtNsU4bk2uptNVZZ3+I6mg/rn+H6ceAVwVRO93I6lC/9b6oWQoaIBSZyGgJiCn97TZmlpSS7Uy7O7GdlpSW2eM1ma25ssNKWTDttxijrl11gaam7oh8vLt9ms8cX2tqt5Zaxs96xW7C+3FJa6m1o1k5LSU5qS+3xi2BfSSZSXKL5OlwfURHuFZ+ORHqWT6uIxrlwH+PTCDZT5Lx8KpWP3Pkd957kzTExI8PEp5qwq+s7jPeVijuhVcCCDRWDqWs+UhrsHeG70CPOSMPpy56iju7/UL8IotinrbUXPYuX6EZ33u9EyBAFfJZwfyHcvXmdCBnvLT5j+G4KRkX2ZF5HhFAlkk0B/JGkJk+ZMsV992FO783Icnd46bnRIyABEj3WOlIfJbDvvvu6D3VC0ZjT+ZOdsttvv92Z1qmQNWPGDGdap4qWN62zsPOdxX2ZVgQLX5S9NTCR46cYnJfujN5EHl5ftcNO2WeQLdlc7Urevr+hwppazIb3z7CUpH4uNYqmgFSiqm5stk+MLXTig9SsuWsrrCg71cYNzHFiBuP4v5ZsdRETTOY0FkRgLC+psrSUJNtYssOKWsts1ebtlpyUZEmZ2VZan2wzBpgt21xpuSmt1rLTbF1Dhh04qr+NGlTgeEWy3HBvsW/vuH53l4U3O46+jwZiJJziBp25lmAPCJ++5lN7EM/BkqzR8Ml0dO6+wzhMEEQId99bJJ66LzO3nrNPX/MlnolqhHYU350PxnehJ1KEaOT5vopWrETPOnMvRuKx7flFSG/ks5ooUrDvBkIlXqIbXWWDuOA+Q4ggHngf+YaYCBK47KmSVvAexHuyYMECO/TQQ23lypV255132kMPPeQ8I2yUsPF2zjnnuGyARBTDXZ2nRHqeBEgizbautUcI+B3h9l6cBZw3rT///PNuZ/K8885zXpExY8a4D2YWft60zkKCnWWiInwpRNN8S6O+HbVNrhM5KVjkSpVWN9pRE4tdtarxpE19sN1GF2U5YULlq7yMZHtzdbnzbFTUNTkz+fKSaqPV35bKBucbKcxJs7Xb62x4QYb9e2mpHTG+2GoaW/5b6SrJXvlwh40vSrfN2ytsQGqjbSitsM07qqyhqdmaWs3G55uVNqY4sZHVf4AlpWfZPiP6J9yXWmgfDe4ThAj3SWd3G33zyqBvI5hKFVz8Bvub9MgbqBsvigDx3ggWVJy37y3SWSbdOI09PjUYTQqtukbkIpR3VwsR+EWm70LP549nQiSgt4pZ7BFQDzzARzcQGngXfJU7DgVz7msfLerJ6F0PXFq3X9KXwiYygmDwvg4+S7hPeO90JEa8eR0BQvPeww47rO2+Ou6445yomT59ut13331O7Nx77732uc99rtvnrBfoewQkQPrenOqKYpAAH+bLli1zPhGaHLIIwaxOVIQPbYQGj+FD3fdH4EuAxRRipKd3MctqKZ/b5NKp6OtBWVsqT+0/sr8t2lRlOenJrikg/6YZYVMLyVc7bf76Sjt2SrEt3VztxAdmdMQFAoXISFF2mq0srbb0lGRbta3WjsQXUlZr9XU1tr280uatLbepufW2qqzBhmSaNViKle3MsnGD8q01NdMOGT/IFq4tta1bttiWHeU2JCfFxo4Y4hbekY4AxOBt0+4psVjw9wkLK2/ShgmLqtDdxj0tfkNTe1j8xtuOJUxIR0LI+yZovqlfuI3VIjn/LH6DZXCJdHhjvjeKM1fsuvdU9A6R6VO0PBPfUbuvlX0O17vBve6b8MGE+zye+otE8h71r4VI5T4J9lzh/kCcwQZG7VXSQrxQbjcoQGbPnu3Exx133OEM7y+//PJHTOo9cf56zfglIAESv3OnM49TAuzE3XPPPU6MzJ8/30aNGuUiIkRGyGv3HXBZTPHDwqUnKyORckXlqQG5afbi8u3O/E26FF3HSbeipwcdz0cXZTvxUdfU7PqBVDU02+zxRa7p3z7D8+2VD7a75n8YxGlayOu9s7rMUnc2WnlllQ1Kb7L1pRVWV1trOxrMmncm2yGjc53nY8rwItvWmGJlDTtt1rgiW7q5yh1/1bYaK61qsiH9021gZj/Hgx+iRuzsIs460x8hTm+ZDk+biBk8vEmbFCR4ICKC/o1glaSgUZzH9xX/hIfk05F840d2t72Zv6uRhd3dNyzOiE75EriIDf7NYBMhGN3g770RhfCmZO4Tzo10G5+iFU9pa34eIuHd6KxfpK99drR3PV6cIS4Q0MEO6bx3uMf9fU7ElP8/+OCD3XcWnyOkYyFC+G6LtXHNNdfYE0884XyaXBufk6SH0buENGqN6BOQAIk+cx1RBBwBFi40cuLD+sEHH3Qf4p/5zGdcVAQviW/ORr4uURE+NPkSYKebn0hUASqva7KtlQ2uMhURjhOnDbT36csxPN9eWrHNCrJTrX9GquVmEpI3W7ej1p07fo29h+Y58TG6OMteX1lm+wzL3WUiL6uw1JZae3FFmQ1Pq7Oqpp02OKuf7UzLssaUbMvOyrL+ebl24LhdvhJSs+ZvqLCc9BQnZPg74oMeIHRHP2hMgaXRgv2/w+92wwRjso8UwSQeF1PdeTt4HwGLAqIi3rTMa7IgYMcX8cpOeyynUnWHQUfPZVccLr63CPcNLLhP2NntqvBikeajG7x+0CjO/RcUHJFoYBlJNr7ss++ozUKe+8KnrfWGONrT9YUb3fDcu5K2Ggv9RfbEIZr/z4YF3zvcJ9zrvHf8IO1x0qRJbZ8pfP6uXr3aFWK57LLL7PDDD7cnn3wymqcb1rHOOOMM996cPHmyq9zF9wc+TT4fXnrpJTvkkEPCeh09KHIEJEAix1KvJAJdIsAXLB/2t912m918882ub8h+++3nhAgfmsFGbRja2Z3iORj9MK2zuOxKygyeDUrpEtWg0znmcQTF+IE5rofHzFH5LpJB+hUNAhduqnIm9Kr6ZqMj+VsrS625oc7WlVbY0PQGK6uottrGZsdgY0O6HT+pwEqbMmzy8EKrszRbvaPeJg/Kse21TTZ9WJ6rlpXUr5/tqG2woXkZNrJoV9fzacNybUVJjetmvteAnN0yZZc/GCmCBVGRaFaL6tKkd+FJzDm710Hfhs9r9zntfMFyv7A7SW43fIgAsOhmkRkJ0dqFU+/1p/gFFfcK/Fhok+++p1S+UK8MzyWawIBlqHejK4vf3oLjhTwLMNKRGMEUra4KtO5eTySiG109h/b6i/CZ4ruMx6JA6+q1+udxzdzTwegGIoPhI3h8hhB1JlULYzmilagBnzP0w+KzhsGGx8knn+zK0sfD4LuU71CKw+BZ0YguAQmQ6PLW0URgtwRYKLF7RKf1f//7305cfP7zn3diZK+99nJCgy9oFg3s4LDAZNeVRTdfkuEabyvrm+yt1WU2sjDT6hpbbfqwXBf5IAqxenuNHbpXkVGOlwpVJZX1tqm81qYVJduiDTtsUEqdvb6mwlJ3NllKP7OBOamWnZtnlpZtlpZpLUlpdvTk/5XhXbypyuqbW+3A0RjUa1yUY976cmtq3mnFOWlOhNC4EPFRlJNmNQ0tTujw+3AHiym+BGFCtSgWCr6zeE/7Z8I9x84+LrjT7qslBbu3Bxe/7fkIfASARTcCl3/7BaZP9evsOfWFx4ea+Vk0+QgA77+gd8OXHQ4KPM+9J9K5eouvT0ficwVRS2Ux3/yxJ71WweiGT+3hM43R25Wpgv1F+pJfxPfy8bz50zdq9f4kXxGMzQw+V9988033Q5TDR50/+OADV76X++TEE0+0733ve64ML6O3xGtn3z/efE/q2NNPP93Zp+vx3SQgAdJNgHq6CPQEAb6YV6xYYX/961+doY9F9THHHOOECB3XfZUSvgxYdPMlwe6rN63vLhUJ8YHX44gJhbZ6W50TH6+vLrPstF2VT8YWZdqG0nKrrKqylSUV1tpQa8XJ9bap1mxMfootqsqw/UbmW1Z2rg0tzrf09AxbuqXKdSNvbKZJYb4rw1uQleIEByV9xxZn2+LNVbbv8Dz799JtNigvzYb1zzTOZUxRlr2xeodlp6bYyKJMK8hK6xZSFpgwIX0AsUa43UdFYvWLcXclWVkMhu60hys0PUg4wAMxwgKT3XsfFUnE5nVwYdHNfYI4854NzwsmwbKsfdEr09GbLLSyWFCgdbdXUW9GN7rzoRLPfhG/kRH0KLHwDlZf8ymafIcQ0UBsvPXWW+6H9CoGn6H4PUhV+sQnPuHSsNgko8rVnDlznH+RCH2sfsb6+SdVletHbF933XV211132fXXX2/f+c53unOL6LldICAB0gVoeooIRJMAiyPCw3hF5s2b5zoeX3jhhc60TqoRURFC6CymvEG7o0V3TUOz6+9BSV2qW+09JNsenrvBhmW3WmVVtaU311hJRY2V1e+0ftbPBhfm2F6D8m1rU5qNGVRgC0oa7PgpA21zZb2rclXX2OKExQGjC2z9jjonMBAjdU2tRtrwwLw0G5KfYYs2Vtrookx7fVWZzRjZ33lIaE64V3GWPbGwxCYOynE/kRx+BxMufPn6zuIsvH1aWySPF+5rBXd9fWQDUeB3DoMmcYQHYqErKXbtnY/3AHCfkH4Ao0j4IsK99t56XKiPgChH0CjOItsXf+C95PtoIOh7817pLV4c11dbQ7iSesPoTPPHWI5udIdrLPtFPPNgdMOX1/a9ZbywRlRzLUQ1vNh49913nacJIbLPPvs4wYHYIEJAsZSOPofYIKPKYzz4KILXwOfrt771LbviiitiXjh1556N1edKgMTqzOi8HAFVrvjfjcCXCztTpGc98MADLlpx+umnu6jIgQce6D5AfSoSO1F+0c2Cm92r5n7JtnxTuQ3JaLF3VpVadmuNvbm+1qYXtLiqVEMLsqwxOdtq+qXb3sOLLCUj00YXZztTeHpykmFYP3B0gW2uaHC+EIQMEYzDxxfZgg2VLvLx1ppya92500YUZFhLq7myvvQQyUhJsu01u7wflO+l5G9xTqrRJX3ioGzLz+xe1GNPbxe+aH1UhLQB+rHApDtm5D0d0/+/727txQZ/+lQqb1r2oqOnSrK2d66hvgjf0I/7JV7T1vx1BtPXfCf3UObBNBO/KAkKNCIjvgs9QiSRq62RooNgZdeYCIn30MDFi7c9RTeCEaW+0HeDe4UINAKNCDT3V7T9IjDn8yTo3+A8uJ+ZF8+cP3l/E80IRjfoZM51sGFFRSgEBGKD7xM+myK18RHuZ2U4j+OaaXwYzmDzgA274Hjuuefc+5oSwkQ/EFmsM/pSSmU4bGLhMRIgsTALOocOCahyxcfR8IXBjqQ3ra9Zs8bVXr/ooovszDPPbFs88mVD7jJfTvXNO21rfT8blrXTVlWZ5WakWV1Sps2eUGwVLek2elCBLd1a55oDThiUbaVVjTamOMueX7bNRhZmuKaDmNNLKhussbnFSqubLC8zxaYMznUCZe9hpFaVuufg68DHQXUrKmkNyk231JQk9ydRlZKqeidOiKCMKMiM6t3Pl3Owqhhfyr6qWCRSkfhiCwoNFr++u3XQtIzg4KezqVQ9BQuBRlTEp62xYIFLPCy6fU67X4gFjeLdSV9rrws9PDrqt9JTcxNrr8u9ghDhh8Ug97D3pnGuve3d6A1e0fCL8LnvO7j7CIePnMKc3Xzet/wgPvgseu+991x044033nCRDm8WnzBhghMbXnCQThUrn0V7mj++72jiG86gJDAVrjoafFbw3Ukvk3gxzodz3fHyGAmQeJkpnWcbAVWu+N/NwBffU089ZTfccIOxs8MuDmUGfSfkn//85zZ9v5m2rSnVhmQ02XslzTYwN80GDBpsh04ZZVuqm53Ze832WhtTnGmF2elOZAzOS7Nnl26zYyYV28byeufh2FpVb+vL6q0oK9VSkpNs3ECiI5Wu3wcRkINGF7hyvkRFSLt6YkGJzR5faFUNLVaYlWpJSf1cKlZ+ZqpNHpJjKUn/K63bG7c3O7k+KuJTkYiKkGYSTh6z7/8QWpWKayGFIZhKxd/jYYfNN69DjHizKcUN9lQtKlrzF6zYExR6/N6XHQ76ZSLVVBFjtO+4TkSLCBG7/7BJhMpiRECC5nz+7iNKLFx9nxmf+klkMZ4qgkXy/o2UX8RXYPPRDf4MNrP0YoP7nc0TxEVQbCA+mDf+b+bMmW3eDUSHbzAYyeuO1mshwmhwGM4g0k00Z3fj61//uqs+SUpmPHxGh3Pd8fIYCZB4mSmdZxsBVa7YhYIF4g9+8AN75513bNGiRS79isUAH7q+u+9pnz3Tph9+gk0bnm+Pzd9iexcn29LVmyy9fodtb+hnKbmFNmzwQBszuNDyMlJcehXFp5aXVNun997Vp2N0caYt31Jj1Q3NNm1ojot+4CF5Z22ZZaQkW0Nzq40bkO3EB00N0RXvr6+0k6cPcmlaCA56iLyxaofr6TEwNz2m7ma+6BG1iBEWtd6gzaLbfyH5ha9f9Pq0Hl8fP7T/AwvUWExf6Ax4X+KYhTcLGUQUTKh6E63d0mBEyS+AfcUeFlZBscGubzjCsTMMQh/r024QaH43GcEKF7w0PX387px7uM/tineDhTHvId83gvvDV9Hivon390K47EIfF+oXISUILgjXUG8RwiWYSsVnDXOBkPP3uTeLc58tXbrURTZCzeLciz66gX+Dku5EAhN1DvY0dxdccIHdeeedLjKOp1IjegQkQKLHWkfqBgFVrvg4PBZi5OvyBUPjQnZ6pk6d6haL999/v/3l5ltswfoyG5SXZbNO/6Jd8cUTbcfOLNdbY+6abVaytdSSqrdZQ1OTDS7Ms/qMYhtcXGh1La12yJhCV8lqaH66vbu2wokGhMim8gbn2Xh68VZXvSoluZ8VZlNK12x9WZ0TGhV1za6b+trtdZaTkezSsbZXN9r+I/Nj/kuQL32EiDdoIyRYALDr5ncfESWh0Y2+vNvrzcgsunkfsvjxPTRYGEVqYRPa5wTB4VNMgoswvxjrbkWmbnwcuaf6RTdciKbFq4emo+gG84qw7qx3w5c5RoywqOY95LuuJ+oOc3t+EdjCxvuOfH8ZGAWjGzwmUmbx7t7z8fp8X3Ai1NuGV5J+Jnye+2pf8XqN8XjeEiDxOGsJeM6qXNG5SW9obrG5a8ps5Yoldv8jT9kL9/zJkgpH2CcPnWEHfvp8O/bg6VaYk271jS3WUlthT7+/1gqt2mp3pthhk4dZXVqhZWSm2+byBpswMNvyMlNtQ3mdDcvPsH8vK7UjJxZbWU2Ti26kJPWzuevKXZUrxAd9PrwYIWpCrxEeF6uDBTZf8D6qEayQ5M+ZBTBRJSrB8GWVqINFEhERFt0+FYkdVxaYnRUEoQtfxJ9P5Ym3iBICxFcWQ5ggknxvkWhFi8K5J7sS3Qjnddt7jF90c78QLfKd6LlX+mKj0N1x4p7gcyWYTgUfP1atWuX+etZZZ7Uthr1ZHO8GZnH4Bc3iRDcwjseqWbyr901PPO/999+3o446yjX2nThxomO2fPly1wmd9+4jjzxiJ510Uk8cWq+5GwISILo9okJAlSuigtkdhF4czyzebOMG5FhtU4tNH5Zvby5bb088/pg98PRLtv69l23S5Cl25jnn2oknnGgflDXbcVMH2tyVpVa4s9z+s3yz1Tc129Ci/jZu5FAbM2ygK7GbnNTPVm2vtWMmDXACAxN5TX2zLdlSbUdMKLJlW6pt+vA821BW51K5BudlOFN6LA2fShX0bbDw5cvd7/j6HXaEBmkS3iviO9AjRPCKkOoWqd3/WGIUzrm0l4rEohIuLJJCucAXjkEfgS8P2h2jeDjnGs3H+O7iiBEKQBAt8sZ1drWjfb9EOrrRVZZ8/pPiQlSERTiiDC6ItEhG0bp6fpF8Hu8N0heDpXD9Drw36PsIB//mc+XHP/6xa0DLwthHAjmnoFkcwYG/L5YEbSS59eRrEbm9/PLL7ZVXXnG9Spgf7r9Zs2bZpZdeajNmzOjJw+u1OyAgAaJbIyoEVLkiKpitqaXVnl642Q6fUGwrS2ts+vD+Nn8DXcdbLSM12QblprmqILfdda+9Pne+ZeUX2ZmHTbVZp55vnz5kmr20YotDI8sAACAASURBVLsVZCVbUn2lrd+4yfo11tjmxnQbNWSg5RYU2cwxRbapvN4yUpNs3Y46J3YO3avQdVGfNjTXlmyucj4QvB4cr7eHL1MZFBzeQ+Dr4nvBgYdgd6lUoc388CD4Zn6JYETuaC7h6aMifLHDBTHCn/wb9ogPL/J8+hp/shCLlFG8t++10OP7aBFsEFv+fiEC0BOpSNGMbnSHdaihHy7e0B+JSnTdObeuPBcPmf988aLDp2sGU9j8ve7N4j7C4c3ilItlU4PysERkx44da+eff7599atfdSmPGiLQ1whIgPS1GY3R61Hlip6fmOaWVnt/fbntP7K/vbee0rj59sKyrc6/UZCdZpmpyc6r8UFJtaUm97OtJZvspYfvsrvmvGbbVy+x/U84x7540uF29DFH285+ya6T+VPvr7dBSVW2ctM2G55tlpxbZDkFAy05PdNy0lNs8uAcVwlr0uAcW1laa2kp/Vy53t4Yfpc9aBRnscNg1zDUt9FV0cBCjwWH76LNv3e3+98bLKJ5TL8AY/HFrr+PKHEORADgDh+E3p5EXjTPO1rH4v6ADVERogA+FQnx2p0+NLES3egqR7jQwM6naHEfsQBHoMVy+WeEZdAsjrj2ZvFg3w1vvscsjtjwgsN7DRBdvqt40CzO/cEm0d13320PPfSQex7ePg0R6GsEJED62owmyPWocsVHJzpUfIwszLLXV26zGaMKrKV1p+s83tyy00VD9h3R37ZVNzqvxrtrdlhrS5M99q/n7bn7b7V5Cxba4KEj7PTPfMYmzzrRzp01wXU6H1uYbu+tWGeL1my2/KRGS83ItkOnjrKtLVnWPyvd6ppanAihpG80hq+JH/RtBHfZWegGBQepVD2R/sJOp9/9J82C4/ioSGc9EdHg1t1j+PQSn88eahT3zNn5ZaHGgpt5Qeyx4IJNPO5yd5ebfz4eF9/QD3a+od+eyhzHS3Sjq5zgQmSA9xKihEgkIgQx0l5KX1eP09nnBVMHfXTDm8W5j4OCI2gW92Ij2FmcfhNecOyps7g/Tx856+x56/EiEA8EJEDiYZYS9BxVuSK8iUdgzFtXZjNGFrgICF6N0uoGmzmqwCrrml2lqi0V9VZaXW+Hjx9gy7ZUORHy3JKStsjI4PwMl071+jvv2d//+bC9+NrrVrvyXTvqjC/ZN8491TJHTLHWnf1sn2G5tnBNiWXWb7M3V26z1JQU23vMIJs2blSPds/2Js6g4PBpDsFyrCyAe2OX3e9y+6gIM8cCCk9Eb+T+h3fn7PlR7LIHI0rw90ZxFlzBMrgdmWF5vm9y6He5o9WFfs9X2HuP8A398EXAmfvWlzn2UbagZ8Z3uO5KZareu8rOH5lFt++5wt9JV/MpWqGlazv/6rt/ho8qebEBf0SIj+T5Zn/8iXgMdhaXWTzSs6HX6+sEJED6+gzH8fWpcsWeJ6+1dafN/a/4eOWDUstKS3beixEFWa5vR11js5VUNVh2eopNGZJnizdV2vRhefbIexvtwDFF1kxllaw0FyVZurnS+ru/t9rI7Fb7zS3328P3/M02N6TZqOIc++IZn7YDj/m0HThusD2zeKsVZ/azvJZdqSWIAdInRowYEXYjv46uLrjr6Be/wVSqoEmcv8dapCHUE8FCnQU3u7ksWmJ1BKuB+YWv5+47LQfZd/ZafBd67hcWeDzfNzlkUZ2oAy4IVxbdvuywZ5GIXcX9tXtR75uqwgkxjxhB3HfXjO3N3kGzuL/f+UwJlsJFHPIZ5zuLE+FAcBDhY8gsnqjvXl13dwhIgHSHnp7bowR6q3IFX0J33XWXPf7447Zw4UKX1z569GhXpo9qJXwxxcLw4mPf4f3tiQWbbPrwfGvdaVack241Dc22qrTGVapCfIwuznJdyAfkpNnbq8vsU3sPto0V9a48blV9ky3ZXGkHjSmydTtqnYdk4cYKJ0qq6xpt7ZK5dv8dt9pz7yy29KZKO/6M8+0r55xuh+w3zaU1sTAgfYLqIixcSbdhwc1u7p58Fj6lJ7jL7nOqeW2++EOrUvVEKlVPzKfPcWdxCR/O20dFYqHyD6kkwR32YDWwIHffaTmS3Flo+6gICzveU9wvsZz7H6l7ZHfeDXb4WVgzN/TQ8Lv/LLoTOXXNf8YgRmjA6quLIWDDrUbnm1oG/Rs+msf9Hkyn4nMraBZHbCA+mBPfWfzggw82vBukVeFxiuT7I1L3ml5HBGKZgARILM+Ozq1XCNBVnHzdww47zI477jj35TJ37ly79dZbnRDh773dC4LF7dy1ZUbq1NurdtixUwe5NCuaAm4ur3PiAhN6ZX2TjS3OsXfX7rCs1GQrr2uyg8cW2cbyXWV0V26tttrGFjt8wgBbsKHCiY/XPtjm0rYG5mVYWnKSDchNt6WbK2xbSYk98uD99sDf/uwa0sHnoosucsLMRyF8Iz/SSrw5m6iIT0Pyiy8vOPjTp1Kx+Ar6NqLR2TpaNxgLF+8VIa2EHX9EGtVtOhtJ6Mo5s4ALTaXinBidrQbWlePvLtrFQg8xwsLSd9BGjPT2eywS17k770Zo+WGEnq/C5pvT+d4izB9eCLgkWg+N0HlAnPH5wvuJzSLuX9/o0Dea8+W2g9ENNjYY3GM+lYrPJT5nEA/eLE5ncSIcoWZx79/Yf//91Vk8Em8OvUbCE5AASfhbQABCCbC45ssNERIcf/vb3+zCCy+03/3ud3bJJZf0Gji+XN9avcOJA6IXM0cX2uaKOhfNIHKRnZZiEwfn2uaKehs3MMfmLNxsEwblWEPzTps4iN/vKp9bUllvRTnp7rELMKcP729PLtxskwbnWm5GqjOtD8xLt/98uM2JkEmD85yZnQX0gw8+aH/5y1/sjTfecF/+X/ziF90Pf+fLHFFBRMQ3rONL3/8ecD6lJyg4orEQ77VJ+++Bff8MoiKlpaWOCSIEMeKr5nT3HINGcR/hIOLA730uu9/t5Zg9URK2K9fgy7Py3kMcBT0R8XJv9ERlKp+65g3avoeGF2mJuvPufTI+RYtoBvcy9wr3jy+3zcZGMLrBv4OdxREboWZxohsYxcM1i3flftdzRCDRCUiAJPodoOsPmwA7yOycfelLX7Lbbrst7OdF8oF86c5ZsNmGF2a6ilNjBuQ4IVHf1OIiIKOLsqw4J8M2lNfakPwMe3ZxiZ2w92Bbu73WiREes35HrTOfp6ck214Dsp1xnUjKvLVlLhJCRSsESnFOmj21gJ4iA93/hw7OZd68eU6I3Hvvve4L/4ADDnApEStXrnTpPTfddJNbZLOzywKBBTA7uESSWGAm8gjtKg4PHxXpTH570KDvTfrBqJJPYWMRxg4xcxDLAy8KaY+INDYDOF9EGgvuWEhd8+y6Gt3oDvtQkcZ8drUTfXfOo7efy2dNMLrBfc98BOfmvvvus+OPP95OO+00dy/5UrihZvEDDzzQpVKps3hvz6qOn2gEJEASbcZ1vV0msHz5cps0aZL98Ic/tF/96lddfp2uPpEvWPp6TBuWb6VVDTayKMsJio1ldVaUnWZ5malWmJNm67bXuEU/6VWf3meo836MHZBtSzZXWE1Di3v+tuoGGz8w195atd0y05JdGta0oflOfCBmEDc7ahqcr6SjBSvi45FHHjFSFvhSZxHAQGCwYJw2bZrrPssCiddgwU1EhMUACwgWxKRn8fhYXxR3dc7CeR7zykLbL7gRa8GoSPA1WJxTHY7Fl0+p8tXifGpJsDJVvEQOOuIU2syvNxfcPRHdCOf+aO8x3DOINN9Dg8fQUwSvSFFRUZ96P4UKPe59orAMvBpBszipjUQ3Xn31Vfv+97/v3lNEPLy5fPz48W2+DXUW7+rdp+eJQGQISIBEhqNeJQEI0JX273//uzMj7rPPPlG9YhdtWFdu04bl2Ydbq21EYZYt3LDLKE56VV3TrojF++vKLScjxQmKQ8YWOXP5kP4ZNndNmfuT6likZpGK9fj8TTZ+UI7RuWNo/0wX9UCYNLXsNPqIECXZ3fjTn/5kv/jFL+yggw5q+5kxY4a98847Liry5JNPOsPm2Wef7bwiU6ZMccKIRTTpR6RoUfOfXHhECrv/sZIOFNXJDRzMizSEmk9DQlAg0Mhh92VB4chiKyg2eqrXSW+xCB7Xp67BBc+IF7rcN+GakDtzHb0R3ejM+QUfS7TLeyK4R3g/IUT48Z6Irr52bzyPSGmwz4wv/RwsSuFFhzeLB6Mb3izOZwkiAyb4OxAmRGj5LPryl7/cG5emY4qACAQISIDodujTBPhyJh0onMECbuTIke0+9Oabb7avfvWrzvuBByTa4711ZTZ5SJ6rbFWQnWrz15Xb6OJsZzqn3C6Vr55bWmIzRxfY1soG239kgRMfDKIlCI3c9FRnPkeIPL1wi52492DbUllvg3IzrKm11RZtqHBRlXEDw0uNYqHAbn17Oegs4NatW2d//etfXboai0byqfnyP/nkk9tM6ywKfAlSct3ZxSUq0hOLymjPWWePx/V7kcEuL+LMp1LxWog5+BAxwrvhDcudPU68P55IBAtuxAjRH7j4BXdXBWwsRTe6Mz9ExXwPDd6fCFRfXawzaX3dOYfOPNc3FA2mU/lSxN4nFvQr8dpBszjR11WrVrlD+s7i7ZnFEfNPPfWU3XHHHS7185577unMaeqxIiACPUBAAqQHoOolY4fAmjVrbMyYMWGd0OzZs+2ll1762GMfffRR++xnP2snnniiPfzww92uPx/WyQQe5MXH6m01VtfY4ipbYQgnlZ9Ggzttpy1YX24n7zPMdTrfb2SB8ZyG5l09PvIyU5ypfMOOWveqRFBO2meo+5OoCZWxlm+ptCMmDrSstJTOnt4eH8+u/kMPPeSiIv/5z39cetEXvvAF56VhcYSAYbHEohIxwgIEMUhEhEVFvKcRtQco2MndG8V9+eFg0zMWkOzykqLFgpuFMr+DTSKUrN3dzeVNyL5SFJG14uJid0/xZ0dpfeFGN1j4xqvQQ8wSZUSMkKrlfTS8n3qzMaYX2UHB4c3ivrGlj24gLINmccQG0VVEFuKbIiG+FO6sWbNs1KhRYZXCZf4T1bi/xw9rPUAEokhAAiSKsHWo6BMgV/jll18O68DsumNIDI5nn33W7dgTyp8zZ07UU4QwiJMutXhjhdU1tzivB80CU5OTrLSq3irrm51nY/aEAa4sLx3O/72kxJnGqVyFL7N/Vqozmuem70rNOnBMoa3ZXmN5Gam2tarB8jJSbGRRdliMuvMgvvhpLulN6wgTSvh+5StfMcQfiyTffMx3FPdVooiKxHNZViIZoWVw2zOKIy5IrWpv8exT12DjS9ayoGTBnciN/LgnYUlTONj4NCS4wIed/2C/E/6eKF3FYRPqo2Fh743rXY0Yhfs5QOQhKDZ4D/hqbMGu4ogORAUbRqRTITb4Wbx4sUvZpAQxn81EN4ikkvbJPS8hEe5M6HEiEHsEJEBib050RjFCAOFywgkn2N57723PP/981Bd5lMalStWrH2yzwXkZrmRuUlI/S09JskUbK5yAYOw3sr/NW1dmwwoy7c1VO+yg0YXWamY0KsSY/vzSEic6qJY1fXh/VxEL0YI4mTwk11KSo18ViUUJ6RCkaC1btswmTpzo8rLPPfdct8PP8L0zWFSyiIqXnf/gDrtf+LZnFPcliLvSyR1TLTv/vgs9CziiIoneIwL2CBHfFDNYGSnYVTyeoxtd/XiEBWl9vmwtC3sM64gRUvu6WwgiWCDBiw5vFkfoBEvhEu1ANLIhgdCgnHewszhmcZ9KJbN4V2c8tp5H6twVV1zh+mgR7eZ+Gzt2rF1wwQX29a9/fY9Na2PranQ2kSAgARIJinqNPkeAL8VjjjnGpW8hRNiBi+ZAfPi+HjNGFbieHP36mTOdz19fYQeNLbCN5fW234j+9u6aMktN7mcVdU229/D+1tDcYk3NO62uqdkWb6y0U/Ydau9vKLe9h/W3laVVVlLRYFOG5dnA3I+X1o3mNXIsFi2IO6IidJ5noXLWWWc5rwhVtLxp3VeJIp2EhSQ72yy4SdXq7YFQCu0ozg47wxvF/YKXhVckd23hh78Gkcbi0rNhURmPBuTOzuXuvBtcP+IO8Ypggw19ahQxMpfyuGXLFidGuHc9G95X4ZbH9uWfvdgIRpa8uPaiI9hZ3IuNoFl85syZbYJDncU7+y6Ij8eTTXDttde66BWf3XxGkpJLueRPfepT9sQTT8THhegsI0ZAAiRiKPVCfYXA2rVrbb/99nOpHL/+9a9drn1w8O9jjz22xy4XPwflcJtbd7omgT5aQcnd8rpG16uD0rp0LX92SYkNyEm3jNQkG5SX4SpYVdQ1Wnltk/OAHDa+uK161vz15e7/P7FXUUQXwZEAwe4su9aY/TGtszhi55OoyKmnntq2O0YkwZvWWUSxg0t6Fjn/kVzYd3RNLPiDRnEWXSxwGaGdrVmERdP469mwu8jiENHsoyLd3d2OxBx39zV8ZCm44PXlVYPs24tuwIZoEQtu2HhzNn6kRDXz+/nAZ+GN6wi69hpABptbwp8fH9XzkSUvNoKdxREbPp2qI7M4n7UIlGi8f7t7D+r5kSfwzW9+02688ca2SHjkj6BXjFUCEiCxOjM6r14jgBH9yCOP7PD4HZnVI3HCLy7batnpydY/M82VwW1sabUd1Y1OeORmpNiUIfm2cGO569nx2PubnJhArPBYoiPLtlS659KSCz8IZvThBZm2qbzeVc0iqhLrg4gCZn+iItTzJ60I0zpd6FlQs1Bh9wyRgmhBEBA54f/Y3e5KSlN7TFh0IS5Coxs+h52FVrAMLucQC4so2PioCAtFX5YVNrEQMQr3/uuJylTeR4MYIZoW7LniF87hnl9fexxsiDQiRviT4RtXIvQQ/IxgVA/RwX2PiMEg7v0bdBbnfRNqFvedxfuCIO5r899b10NU5NJLL3X3DtERjcQhIAGSOHOtK41xAoiFhXPfsmeeedaWzJ9rS5evsKTCkfbo/XfYiGHDXCdzUrMKs9LsvfXlduK0wbahvN6JioraJluxtcoOHF1g68rqXBne99eVGU0+qIC114CcGL/6j58eC/0FCxY4IULZTPLJ8eSQnoVA9IsYFjpERRAkPMc38ets12wWWKFGcV+hB+NuUGywWI2HRZQvc0xUhOuj0AJCLRI5/5G8oboT3ejqeXA/+aiI77mCSOP+6YuV13bHyQttH93gfRAciHw2ZihFPnny5A7N4ggSFpHev0GVKpnFu3qH9s3nIWb5IYKG7+cb3/iGe799+OGHrqS2RuIQkABJnLnWlcYwgSWbKp2J/Cvf/J498ciDNmGfA6whOdNWvP6MPfvKWzZ7vwn2+ofbnNioami2maMKbVNFnatstaKk2lpaW+3gvYpcahaekZeWb7Ws1GSbPqK/ZaQmx/CVh3dqiIw777zTbrrpJtcHAJOqN617fw5igd1bxAiLS0QCi23y/kPTbFjw8gUYjG74/gM8Nig2+HukoirhXW3kH0VUxFeJ4pp980cW3L3xpd8T0Y2uUmPnn2gIYoSdf6JYpFnCpjdL1nb1evb0PK6Xe92LjWAaIfdC0CxOxAw2NGC9+uqr3fuK/+e5DG8W99WpECfRTDvc07Xq/2OPwM9//nNnRvcDwUrqLWWVNRKLgARIYs23rjYGCSylW3l+hpXVNtn2rVtte0uqFeZk2QO3/sGuv/XvtuSN52x+WapNH57vyujSVBA/CN4QmgwOyEu3cQNybeHGCttneL69vKLURhVlu4hJXxssntiJ/fOf/2yPPfaYW0ifccYZbmeWLzAWj4gLFk2kZ7GgZEHEghJB4g3j7PCGppR40RFpo3iszQG72Yg0oiIIE3w0CLXd9c7ozjX0RnSjq+frK68hRlhsswD35XzjVYQGxZ73z/A+4r2CT8n33fBCm/Q9fBukxLBDPW/ePPe+4bH777+/a+zKe4t/f+5zn3M72FQK1BCBcAjgBeKHz+gXXnjBRbl/9atf2RFHHBHO0/WYPkRAAqQPTaYuJf4IID4osUsFq23VDU5g4Nmgh8cPrrzWbr7+N3b9P1+wLx093VZuq3apVJvL62x9Wa0NyM1wJXnxdpCahRm9oq7Zpg6lSWG/+IPRiTNmUcsikZ2zW2+91S2mSfcgKkKaFl9qVFihkhYpIF5ssOji3/hKvFk5UXdsvY8GMYIgwwjMYpuf7vSHiKXoRiduqY881Jes5R4jcsQgbQ02CLZY8Pq0d23ByJ4XG94sjoAKRjd8tSvfWdz7N7xZnMhhsBRu0CxOugxltPlhR5v3nYYIdIXAddddZ5dddpnNnz/fpfdpJA4BCZDEmWtdaYwRWL6lygkNGgqu31FnI4uyLDmpn6tmtXJrtfM+3P3wHFv49F1Wk1poYwZk28IN5dbQ1OpExo7aJtcn5K1VOywrPdlGFGZZcU56jF1lz54OCy4WQ0REHnzwQbezj6BAcPDnJZdc4sr6stjidywmSTnxi212/vl7og8EiPfRIEz8YntP1cXiKbrR1TlGUOEvgg+LecSZbwDZHaHW1fMJPo+54n4ONvsLRvaC0Q1vFscg7qtTBc3iRDG84AjXLM7x+YnX6FAk5kCv0T0CfCbju/rxj39sV111VfdeTM+OKwISIHE1XTrZvkIA8VGck2ZLNldYP+tnEwfnuSgIqVhvrNruOp7feNPNdtuvf2zPvLXI9p04xuauK7ORBVk2tH+mlVTV27gBOfbkgk02aXCeTRqS11fQhH0ddAMnwkH0gzF69GibNGmSK7NKighdlSmXzO7s0Ucf3eYDIQWJ/+d5LKCJhiBE8JLE6s522FC6+UAWr3Bh599XF/NREYRaX4hudBUR9wqLfR8VYeGNQINPT6WvBc/VV2ULig28HPwese1TCH2UgyIJlBQPlsL1ncVDzeJ0GSelKtHv/67eG3pe1wnwOU2/LZoRspGkkTgEJEASZ651pVEkwCKYXOn2xtryRkvuZ7auvNGG5qXakIJcyy4c4KIX9PU4fHyxrS+rs0du+b1de+t99ujjT1h2/2IbPyjXstKSbUtlvUvbendtmR04utB1O0/EwcLryiuvtH322cdV3mEXzQ929O+++24XRWLRtddee7kyvuedd16b0GCOWGz7nW28H/QUIfUkUdOyPD+/2GZxgI+Gf2PO9w0W99R3o6/fj76RH2KEe60nSh37njNBwYEXg4E3BcHhIxz8m/uZ5n5B/waRG0bQLE5/nSlTpiT8Pd4X7lEiWBQIwEuxevVqVzZ56tSp9qMf/cg10o2lgbeIzZ7Q8YMf/MB++9vfunQ+yq1rJA4BCZDEmWtdaRQJ+F2d0EOmFo2wpOxCs9Zma6naZq2NdXbQ7GPs9r/dbos2V9pp+w51jQPp4fH1//ut3X3vfTbnoftswthRlpueahvKa23nTrOc9BTn/dDYPQEWca+88orbWXv00Ufdouuzn/2sM63vu+++baZ1uogTFSktLXXldREhREXC7QrdF+aho+gG10b0A5Yscn3PFdKQlL5mLlKEEPGljomkERVhsdWZJofwD4oNhA3MuR+9WdyLDsqWdmQWZ37oLI4nCrHBD+ei6EZfeJd+9Br4LHv55ZftM5/5jCsQQETs9ttvt0WLFrnPPKIKsTJOO+00ZzzHbM5GD/f6M888Y88//7zNmjXLXnzxRYniWJmsKJ2HBEiUQOswiUWACjp8MQTHB+WtVt9iNijTLKlfP8tINiut22lZOXk2ZvwEO2z8AJu7tsxVu/rXoi329D/vsltuvN4145syfozRyZwyvFOG5llqclJiAe3m1bKDT4neW265xZnWWTAecMAB9pWvfMVOP/30tlK09EPg/4iKsCBkhxkhQhWteOj7ES6mrng3fFQENuRtK33to7RDG0AiEhCyiBEKHwSHN4sHS+H6ru6IuqBZ3D/Xm8V9hCPULO5L4aqzeLjvgvh/HIU2EJvBjQC+e9hcYTMFkRor0dx//OMfLspBgRDOjXMmZRaP3re+9S1tZsT/7djpK5AA6TQyPUEEOk9gZWm1NTa3OgHR1NJqeRmp9vaaHTaiIMt1Mt9vRL5rLogBHRFyyF5F9qtfX2N/uvHP9u4br9mqugw7ZK9iG5yf0fmD6xkfIYCwoIQv6VnsulHV6Pzzz3cpWvhI2Cn2HbOJihAd6e2+Gd2dwkh7N4iEIOgQaxiz+0K52u4yDj4fJr7JIax8BAMRS8QELwlpXL4qW1BwsDBjJ5v0GipT8RNqFie6gVE8XLN4JK9NrxX7BL7//e/b73//e1u3bp2LNmiIQCwSkACJxVnROfUpAqtKqy07PcVad+50FawYRDNmTxxgCJP9RvR3fg4qYNU3tdrkIXmux8dvfnvtrupOc56zkw+eohSKCN8V7EIvWbLECRHyqEl5Oe6441xUBPO6T58J7SZOhSi+1OkqHotpLV2JbnQVLcdiF99HRXgdokVEjfpiE79wOMGEXWhEBuKVtBMia37wf3g5jjzySMfIm8W92CDCETSLYxD3qVQyi4czA3oM/VmoCsh7E1+IhgjEIgEJkFicFZ1TnyGwZluNpacmuZSrmoZm21rVYHWNLTZrfLHr3bH/yAJ7ZtEWG5SfYdlpyVaybqXN+dezVrcz2d56+117+4U59r1vXNRmNv3mN7/ZZ9jE0oWwK40IQYwsXLjQVWWhetbnP//5tr4P3nhMVARRQtdohAheCNJtemuEG91gsYs/oKdEk+9Ez84/6UQsfHwn+t7k09PzQrQM8Rr0b8CCAQPv24A9guSGG25waYAjR4505Y65n0iVYbRnFkcI99Sc9TQbvX70CZCqRwrWSSedZA899FD0T0BHFIEwCUiAhAlKDxOBzhJYu73GeTVSkvrZ6m01LgKSnZbiPBzzN5TbxEG59vSiLTZrXLHVNDZbfmaa3Xf/P+yyX99gzRVbrHn7ho8cctSoUa60rEbPEWAx+dprEZ65UwAAIABJREFUrzkh8vDDD7vdaYyeREVmzJjRZlpnd5uFI14IFodU4GKxzWKzJ0c0oxtdvQ7fxI+oCAtr+PioCHzifTFN9ML33kB0ID64Zu4VLzZ8SdyOzOLcKwx8HAgMUqm+853v2CmnnNKnvEZdvYf0vK4R4L7EC0RBBBr7IXI1RCBWCUiAxOrM6LzimsC67bWWTK3dnWbvry9zfTqIfEwanGvvOzN5ii3bUmXHTB5sG8vrLC8zxcpqGm1laY0dOXGgZaYlx/X1x/vJs6CkhCk71RjXERsIEKIiZ5xxRptpnZ1ub1onzYZcf6IiLLg7UwGpI17B6IZf7GJ2bs870JPRja7OJ4t17xUh9QhDNYtvBFs8REVCBR9zwHUw4B0shetTXYJmcdKpfDlu31ncN/ujahERkbvuusvdZzTUfOSRR+zUU0/tKm49L4EJcF+SQvrOO+/Yv/71L5s9e3YC09ClxwMBCZB4mCWdY1wRWL+j1vr1MyutarCSyno7dFyxrd1e67wdr6wotYLsVOcF2Xt4vm2uqLfs1GTbVtNoeRkpNrKo5/N1WcBSd51FDwtrFswsrC+99NKILJrjarLCOFlSrx5//HHnx6FkJN4PUrOIipCqhRhgoUq/DHiS88/imtQsFtsYtMMZ8RDdCOc62nsM1wYXxBoVcIJRo1hqgIdhnF3kYHdxL/goyRzsLI5ZnNQ9bxZHbLD447mITzqL+1K4RDgocNBRJTX4UDUPcaLSxl29yxL3eWxUnHzyya4fCJFb0q80RCDWCUiAxPoM6fziigDio7axxbZU1LleHUQ+MJpPHZJnD83baAeOKbSq+mYbOyDbiRP+jj+EtCxM6NEYF198sUsx+uIXv+jMra+//rqrHc/vb7zxxmicQlweg0XismXLHDuaHLLQxKyOEPnkJz/ZVu4S/wPpR+z8s6ClyhYij27ZwfSjeI9udHUSiRT5qAh/Z2HvoyLRLBnKfDJXQbGBt4eBgAxGN7xIorM4ZnFfCjfULO6jGzTGjCVh1dW50vNinwAbJKSJPvHEE3bPPffY2WefHfsnrTMUATOTANFtIAIRIrChrNaJjazUZMvPSrPhBZn2QUm1DchNt1c+KLXT9h1mH2ytdg0EN5bV2sayOps2PN8G5kavtC4GazqHU3f9D3/4Q9uVk3+OOZa8YXZuNXZPgIUqX/aIEZjhzyGKRKd1LzTYOccjQlTEd8v2Hgie7/s++K7ivhQrC9dIpG/F+hz6qBFijegR1+y9NDCI9GA+mIegfwOByCB9KhjdoMAA//f++++3lcJ9++23XVoeA7N4sNEfncVlFo/0jPXO6/HevPbaa23u3LkuusWc06GbHhaxNvCsnXPOOUaPjZtvvtlthmiIQLwQkACJl5nSecY0gcWbKmzDjjqbNizPahpbbGRhli3cWGGpSf1c5aujJw+ypZsrbWRRlq3aWm2V9c122PiP7ohH4wJ/8pOf2NVXX+3Mr6QP+bF69WobO3as/fjHP7arrroqGqfSJ47BAoAIEkKEspdEOOhKjE+ElCN2y1nMEinhsX6QlsViG18A/x/vxuzuTqZvAEmKFr4RBIiPinRVjPGaweiGN4vzet4k7kUfkRcM84iMN954w/353nvvufK5eD3w//johjqLd3e2Y/v5FPrgs5H3JvP+5JNPxqwAueSSS+y6665zfg82QEIHnzv40TREIBYJSIDE4qzonOKKwOaKOmcgH5KfaSVV9Ta6KNteWLbVRhZmOuP5fiMLbHlJlWtCuK260cYUZ7u/98bApMiOvd/JDZ4DX1R0UcbAqBE+AVIgiCw9++yzdv/999uiRYtckzkGC1yYX3755W7Ri9jwURFvyiY9CzESzfSj8K8uuo9EpBENISqCgIOJ7yZOqlZHg+excx0shet7b8A8mE7lPTmk0yE2SKfak1kcX0aii8To3gm9dzQEMPcgHex5H5OOF6sRkCOOOMJ5hzoaNFrlMRoiEIsEJEBicVZ0TnFDYEtFvWsa2D8r1bZU1rt0qn8vKbFPThloq7bV2PTh/W1FSZXrAVKck25jB+T06rWRXkXKD+kFoYOqPKSdsJjWCJ8A+f7smLNYJr2Nf7NgpcnhM88840QIpnV2KMeNG9dmWt+xY4dLz8KU7Rfa7PpTKUrDXLUpIiL84JdBRMAHoYzgCIoNIh38DpFA9CQoOLjfOzKLYwqfPn162GZxzUtiEYh1AZJYs6Gr7WsEJED62ozqeqJGABM5hvPCrDTbVFHn+nys3FptJ00fYu+tr7Dpw/Pt7dXbbedOswPGFFp6Su+X1t1rr73cAo60odBBaglpKJQD1QifACKDXXXSNYIVr/A4rFixwm666Sa78847XcnVY445xuVpH3/88W0Rj9CFdkFBgTOt06Suo6pJ4Z9d/D8S74YvdVxTU/ORCwr6ZxB6REkQIUGzONENolIIFB5DN3GZxeP/vojGFUiARIOyjpGoBCRAEnXmdd3dIrC1st6qG5qtKCfdlmyqsLTkJGtobrWDxxY68TF5SK4t2VRp2ekprvxurAxFQHpnJlg433vvvc4rgreABmFf+tKX7Pzzz7eBAwe6RTMLZNKzSD9id58oCmkg/OBDSJSB4AgthevN4gg8RBmi7T//+Y/NmTPHRZe4r+GK2CAaRSM2hjeLe8ExdepUmcUT5UaKwHVKgEQAol5CBDogIAGiW0MEOklga9Wu8rnF2Wn28opS23tYvm2vabQZowpck8HcjBSrb2q1KUPyLClKpXXDvQR5QMIl1TOPIyqCMZ2eIg888IDrH3LaaafZRRdd5HbmfcSDlCGECAtphAnREKIiREf6mhcBrwaCy6dUce1wwSzuTeL+T37nzeLPPfecy3//4IMPHBPYkQJ31FFHufLSiA6ifX2NV8/cmXrV9ghIgOi+EIGeIyAB0nNs9cp9kADNBSvqKN2501W5OmHqYFu0qdKJj7dWb3c9PfYakOMiI+zkdrWCT0+ho8rVr371K1XB6inAYb4uC2wW0n/7299c+Uwq7+BFQIiceeaZriwsgwUQIgSvCFEUfo8PAmN2PHQSD8WBmEJgBEvhYvplYBYPlsLlWn3vFUSb77/hO4tj3EdkTJw40fGjCAC+miOPPNL++Mc/2rRp08KcDT1MBNonIAGiO0MEeo6ABEjPsdUr9zEC26objNSryrpma2xpsUPHDbD31pU58fHUgk2uizmm81geVMCi0lVHfUDoe8BCWCN6BBCqTz31lEvPwk+Cidqb1kkh8p3W8ZAQFUG4sNvPApyoyO6qQ0XvKto/km+26CMclMJFhHD+QbM4pnH8HFSyoveCr07lO4vzeNKsfCpVe53FiaQ89NBDdsstt9jf//53J9Q0RKA7BCRAukNPzxWB3ROQANEdIgJhENhe3WDzN1RY/8xUS0nuZ9OG5tvcdWU2lqaC5XU2vCDLCrPT3Cth4r7yyivtN7/5jVsk+sFuLj+9bSz+2te+Zn/9619dJ3QWcuTS0wn9q1/9qjNMa/QOAe4N7h3mhvlgN590IkzrJ554YptpPbRnBlEDXx2qN+8tzp8oTbA6VbDZYjC64RsNyizeO/eajhoeAQmQ8DjpUSLQFQISIF2hpuckFIF122uct+PAMUWG/wPx8e7aHZaRmmz9M9Ncc8HgYPcVc/Hjjz9uJ510UqdYYa4lFaUnB1+q11xzjd16661uR53FKyVif/CDH6gXRU+C78Rrs3CnpwhRESICRDoQjBdccMFHTOuU8GUOESukZGFYZz57+h7iUriPQs3ivv8JUZmgfwNDfbCzuMzinbgZ4vyhRPh++9vfus8bUgm5l/m8ufTSS2MuRTUUtQRInN98Ov2YJiABEtPTo5PrbQI0GFxfVmsTBuXasi1Vts/wfHt2SYkNzE23acPyLTU56WOnSNM5drERIPSEYDz22GMuzeaKK65w+fvBwc6xN8pSypVd71/+8peuCpJGYhPg3mCx7k3rLOZOPfVU5xU5+OCD26JpRB4QIps2bXLCoLi42C30ioqKImLC5jzaM4szO/QwCfbdILoRNIvj3aAy1bx58z7WWdynVMks3nfv84svvtgJaQQ0xQEoAU6Ej9/feOONMXnhf/rTn1wkj3TBn/3sZy5t9fTTT3fnevLJJytNNSZnTScVbwQkQOJtxnS+USNQXttomyvqXefypZsrneCYs3CzzRxdYMP6fzTq4U8KQ+33v/99++c//+ly9RmLFy+2z3zmM64nxFVXXWU/+tGP2r2GdevWGX06fvKTn9hPf/rTPhuNIM//2muvdc0Q2d2nK3usdhqO2s22hwMhAOjO7E3rq1atcp4IdpLPPvvstuaFCBRM64gRzN5EQoiIDB061Hkswh0svPBrBM3i+DkYlMINRjcwi/N4Oot7oziiyfeT8WZxxAYpfzS8VGfxcGcivh9HU1Mqk3XkOcOTxn0ca2P06NGul0x7A/FEJFJDBESgewQkQLrHT8/uowSodLWxrM72GphtizdVWkFmqtU2tbjSuh2V9fSRjGOPPdbtQr/44otuUUb6wX333ecWgj/84Q9d/wcGpuKHH37YLSB91SMWmbwOZVf76qBi0ZgxY1wkiIjPk08+KQHSiclGZDz99NNuV5k/iTicc845ToxQEcqb1hEPCBEEHr9DCHAPEq0IHQhnLzb4M2gW5/E+wsGfpHp5s7gXHEQ4eJ43ixOdQWy0ZxbvxKXqoXFOgM2Uq6++WlX34nwedfoi0BMEJEB6gqpeM64JVNY32fodtTZ+YK69vWaH5aQl2+jibOufFd4OMo3lCNdj6MbYvWTJElcSlB01IiEXXnihbd++3X0xX3fddS5a8slPftJFSGbOnBnX7MI5eRa7CC38CsqxDodY+49BqBIJ4T5jV5Z7avbs2S4961Of+lRbmV4iF76TOGlUCBZStEidIkpCqgneIwaRiaBZ3FfYIjoXLIXrO4sjSOhfQmoNP6Qc8vrqvdH1ee1Lz1Tfob40m7oWEYgsAQmQyPLUq8U5gar6Jlu7vdYmDs61J+dvtmnD8mz8oNw9XpWPfpB6QmM58p2PP/545+f4wx/+YGPHjrVzzz3XXnjhBZeSQAoS/TgI5f/ud79z/8YETvlR7xsJHtT3FGHBzsIRQyeLQEQMKTHxOiRAIjNzmNYRsogR7kHEnTetE7F49dVXbfXq1a6MLdELP7hvMYcTiUJ4IEAQLKTG+FK4wc7i48aNc6+hzuKRmbe+/iqkV5H6R7pl6CAVj3uPNC0NERCBxCMgAZJ4c64r7oBAdUOzrS6tsSH9M2zRhgo7cEyhZaWndIoX6USkWJ111lm2fPlyJw4effRRu+2224wmgCUlJa5zMwu+Aw44wP7xj3+43eh9993XRo0a5czrpMoEjenBE/ACBK9ITk6OM7rzvOCCMp52nyVAOnV77fHBeDG4366//npn9kWsIii4nzB6P/jgg66bekZGhkuzomLb73//eyeKuafwj7z33nsyi++RtB4QDgHuKe477sXQQcQMn5z3CoXzenqMCIhA3yEgAdJ35lJX0g0CNQ3N9kFJlSUnJVn/rFQbUdi5qIIXDCz+SL+aNGmSEwh4PMi7p7s1UYz/+7//cyZz0rIwFNO1+bnnnnMpWHfeeadrQOcFBGKGHh2kv5C65auw8GU+a9Ysu+GGG+wb3/iGu+pY7LoeznRIgIRDKbzHUGGNalm++AF+EKIaDKIfCF3S/xC/CxYscJESGv3h2yAqgl8E0/rhhx/u7iu8TDKLh8dej2qfgCIgujNEQAQ6IiABonsj4QnUNjbbfz7cZoPzMm3K0DxLTurXaSZegPy///f/3I4y6QXUuScSQo49zf9IhSE/nigHpvQzzjjDHcdXyCKFZvLkyW4XmtcgNYsFIRVZyOFHrDzyyCP22c9+1qXI0CeCxSR5/Rje8QCQ/uUN7Z2+iF54ggRI5KDfddddLrrmvRiFhYVt4vTZZ5914gRRywiaxXk8gpb7hxSue++91wnaJ554wsjh1xCBrhKQB6Sr5PQ8Eej7BCRA+v4c6wp3Q6CirtGeWVxiR04caANyu993Y86cOXbJJZfYZZdd5ioTsYNMb4Zvf/vbLtLBLjSpVwgQBsZ0dqpJz+J5RE14LpWzyOGnZC+vQQ4/EQ88I1//+tftu9/9rvOQ8H8IEF5z/PjxbpEZTOHi/95//333//RmiLUhARK9GUEk/+tf/3Klj7kfOzKLU53tjjvucNES37E8emepI/UlAnyu8TlFsQQq3/lBRA5fHP9PaXINERCBxCMgAZJ4c64rDhBoaWm1pKR+PVq1hwpDmIKJhBAR4UvX177/+c9/7oQFu83sRPMYBAQ5+exaB0um/uIXvzAej+eDnWrStmiYxYKSXH4qIdGBnYG5k4gLlYt43BFHHOH8IrE2JEBibUZ0PiIQOQJEamni11EfEDZHpk+fHrkD6pVEQATihoAESNxMlU40XgkQASG1irQWIhl8ITOoXMTvEQdUwaL3B6lXpHFROYsvbZ5Dugy+ENKvSNuibwgREoTKlVde6UQJYuOEE05wvycS4gdmZBojkq7lU75iiaMESCzNhs4lngmwYUGRASpOUVmKTQgiDaRw9uYg/ZS0UyK69IXB18ZmCSXK2UjREAERSEwCEiCJOe+66l4gQLoV0QvvF0EUkFJFJaxTTjnFnRH+DhYSGIQRJ1Q1YiBCMK1/5StfsZtvvtmlxzAo60vPB3oxED1h4XHeeee5L3y8JFTkWr9+vUvDoiIXrxNLQwIklmZD5xLPBPgsIbWT6Cq9dijTHQsChPf4Nddc40qHU+iAohw0zaTsOFXaNERABBKTgARIYs67rjoGCCA6KNVLXj67lOxY8sWMVwTRgFgIChB6L1BSlXQrxAn+DtKySMNCxNDskN4NRFZIxSJiQvWtX/7yl85LwkD88Jq97QfhnBFMnMvPfvYzFxXyVb5OPvlkpWXEwP2pU4gvAhSqwGOGL+ynP/2p81bEggCJL4o6WxEQgWgRkACJFmkdRwTaIUDVIsyYXhBQohfTJp4QIht+PPPMMy7FilKreEh4PPXz8XfgF7nlllvc4sP3CWFxT+rVPffcYzSSo5QvKV7tNTnsjYlBcBERam+QnsFuroYIiEDXCEiAdJ4bqbJEjaksyEYNI556KnX+ivUMEehdAhIgvctfRxeBjxBAKBx22GE2dOhQJzSKioqcgMAbQroC1Yno04DQYKFOfjW/o8s6EROf3kVqFpWO6DfC69HnYdmyZa7iFtEHDO8aIiACfZOABMj/5pXNGPrhdNTclUfyf/jn7r77btcbh0adGiIgAj1LQAKkZ/nq1UWg0wToB0LKFOVQ6STMlyMeDkybpFPRyXrbtm3OVM6XK+lXEyZMcOlMiBDECY8jPYs0L0zqDCImF198sR199NEuMpLIO3y+chhCjTQVeqdMnTrVcT/mmGM6PWd6ggjEEgEJEHOfg5Qsv+2229pSWdubIy9M8Kn88Ic/dBs1fJ5i5iedjdRWDREQgcgTkACJPFO9oghEhAB+DiIhjz32mOv7we4ckQ4GUREiIXRWp38IDQt9N3SiHnhAECRPPfWUDRkypO18iJhgVOVLNvj7iJxwHL0IZv+XX37ZNYGkaSQRIiJKGHfppcLCRUMEeoMAXrCVK1eGdWgKS4wcOfJjj5UA2YXEp7S+9957LlXVlycPAvNpq2zYkOLKZy4bOzU1Ne5zl+izhgiIQOQJSIBEnqleUQQiSoAO1RjKjz/+eFdBhkElLC8m6C0SHFSbueiii9xCmseww8cP0REqz2BiZ4GDaEnUQSnQmTNnuh1OP+jXsu+++1ppaalt3bpVFXoS9ebo5etes2bNR5r27e50Zs+ebS+99JIESAgBHw0mOvy5z33OiQjEhB9btmxx7298cww2I6geiAdk4MCBLh2rsLDQpkyZ0q7A6+VbRIcXgT5BQAKkT0yjLiLRCDz99NOuHwhVrugbQqNDuqjzxUqa1WuvveZ28/ky9YMvZXYBafxFWoLynD9+12DcZ7GCF2fEiBGJdlvpemOAAEKYBXE4g0UyJbhDR1+JgJCGSmSSAhy+LHloKfHgBkvws47Hkbp64oknGhUEH3roIfve977nNmBgzO+IkNCHieqCPJYNmnnz5lllZWU4+PUYERCBbhCQAOkGPD1VBHqLAKV2f/3rX7sGhgiPP/7xj06QUNKXP0nB4nfB8eKLLzr/x5133ul2+zQ+ToDdUpq5kYKBL0RDBOKRQLwLEO/LILpz1FFHuU0Vimf4NFPmpCNTOe/d/Px8V8EKAUN578WLF9vVV1/teikRSSbtik0YqgmyUZOXl+emGQHCZ+qqVatcafTg8eLxPtA5i0AsE5AAieXZ0bmJwB4IIET4UuXLkl1CjOr82+c8B5+O74G+Iw8//PBHuqUL8i4CS5cudSlYJ510ktst1RCBeCXQVwRISUmJ+zyjTxDCob2B523BggU2btw4JxzYgPECgsd/85vfdI1Zx4wZYzfccIPbhCH9as6cOUbPIdJZadjKQJTQ7JU/6dwuARKv7wCddzwQkACJh1nSOYpAGARIKyDFAJFBtCM46LlBCV5K+1522WUf8T6E8dJ9/iEVFRUuJYMc8Pnz5yvvu8/PePsXiKC/66677PHHH7eFCxca/ivEPaKU9w7lXGN1sAjnvBk0MyWNi5RCzpkfFuJ9aTA/FIt488033RylpaW5VNTnn3/eiQsvWG688UaXpkrBCdKv/GBuiY6QxsbviXi+/vrrbq7ZzKFSYHum9b7EUNciAr1JQAKkN+nr2CLQAwQaGhraBIZPU6AU70033WSPPvqoHXzwwT1w1Ph9SYTbcccd5+r/k8KGsVcjMQmQjoNHit453BN4qCjHSmEHFrn83afrxBoh+gGxa9/eGDVqlGFuj9bYXc+N4DnwOLxpDN+MNfQcV6xY4dKnKC1OEQ4ez3uWdEnEBo1bmS/8bzRk5TOOz7vLL7/cvRSbMaeddpoTG0RTvKjgdSi7ff/99zvhgXjhNShdThEKynNriIAI9BwBCZCeY6tXFoGYIIDBctCgQe5LGv8HfUQ0dhGADWkY9AMhNY3dT43EJUB/HTpiI0KCg4XrhRdeaL/73e9c2WuN9gkggn72s5+5SAwFLzozECNEain+gBjxlayefPJJ9x71Vf14TTYKMJcjMnyfI36PkZyqgAjHV1991R1+/fr17vm81/GCBNOqSLXk8VTFO+igg9zjSWNFyCDYECUY0qkYqKIdnZlNPVYE9kxAAmTPjPQIEYh7AvT9qK+vdx4HjV0EMKLii3niiSdcugW54xoi0B4BFqEYm/EK4A/QaJ8AqUwUwGBhf+qpp7aVAO8oukHKG/2NWPDzGcXmCFW9SK3yDUFJKaXp6t57793WQJWNFKI9HIfohu/lQWQE/wsRKyrZMWcIji984Quu/xHHC5bexj9COW4KdjC3VM4iIsLfEaFEi9966y13LEqba4iACESOgARI5FjqlURABOKEALur55xzjusijwkV46mGCHREgEXwpEmTXKdsUn402idAIQcirUQRrrrqqo88CHHgew/56AYlr4kq0VR11qxZLlrBe5LHIjJIg9uxY4cTJDRmRVTw3HvvvdcuuOACF2khEhIcXpyQVuXTTZkzSu4SFTn00EPboiBUycKUjgjBoI444dhEckhZ5e9EZPDNffKTn9S0i4AIRJCABEgEYeqlREAE4oMAaTTXXXed83t8+ctf/thJH3vssS5tTUMEIMCuPrv77VWXE6H/EaAELuZvIg8ICcroXnPNNa4q1Sc+8Qn7zne+0+axIl2KaAfmeMrfkjZFBKK6utqJPSIe9Dti4AEhskGxiNzcXJeCRYSF33/72992Va18FIQIBpsLCIpvfOMb7vmPPfaYi6KQHoYQ8Y/FD8LvmVfOx6enInJI2VLale5uEeg5AhIgPcdWrywCIhCjBGg+trtmbxhXeYxG/BJgcbly5cqwLiArK6vDymdEyNjRR7SyW6/RMQEW9l/72tdcFS7EAalNlMdFNDzwwAOuNweLfczkV155pf3hD38wfDcMnosIwOiPIKmqqrIPP/zQxo4d656LV+Opp55yFar4PQIEjwaRCkrs+nH99de7uUI0EslgkGp15JFH2pAhQ9wxvADh//CFMKZOnfqxC8OXQgoX591RGpnuBxEQga4RkADpGjc9SwREQAREIIYJYCIOLkx3d6pEwtitDx1UVMInRJoPRQrYadfYPYG//OUvLvKA8MA7gXm/qKjIlTUm/YmSuFdccYXzXLEJgJCg+zgVyKjgN3jwYBclwRR+5plnun/z/xSIoPKVF4E0YqU0MlEVXo/ICVWxSP1KTU11/0aoIBz4O2lUlNolIqMhAiLQ+wQkQHp/DnQGIiACCUqAnHkWT+z60oOEFBR2fMlvJ+89aJhNUERdvmzy93cX5Qq+ML0gSAcKjmeffdZVTyJ1iL4SSscJbyrwXmAMZ7FPdMH7Png2fgvEAFWnEA90HZ8wYYLrdj5jxgxXOYuoRk5Ojrv3ERJEH2hIeO655xopXu+++647Efwb3/3ud52JnYjKyJEjXTSFfh9Dhw61b33rW84/Ek7vlnDLBodHQI8SAREIh4AESDiU9BgREAER6AECLHJZhLHbyyKKdA8WZ1Ts+dSnPuUqdGlEnwDChVQffAjsqrMg1giPAEIaDxV9U2jqiLjDT0GjwN/+9reubC4RDaITn/70p5234xe/+IWLfoQKbjwf+ElIp8O7QVPBmpqathOhqhX+jgcffNCJFYzi5513nnscTRg5DqLGC4xg6lV4V6NHiYAI9BQBCZCeIqvXFQEREIEuEsCYyyKK0qR0sI+3QZoL4onqUSwiMfQjslhExnopaMquUgKW9C2EiPrmdO7uQ0hgAie6h3jDd+F7byAIqDhFFSsEHlEPIhyvvfZaW9EHSh5z32Ai577BK0L0CT+kwFEVAAAKg0lEQVQJEY/58+c7YehFRXvRC1K/nnnmGdeEMB7fP50jrkeLQHwSkACJz3nTWYuACPRhAkRFLr30UnvzzTfbGqTF0+VSWYid68mTJ7sF/IYNG+z22293Tf7wWhxyyCExeTk0wttvv/2cARqPQWglNP7N7r5GxwQQBHQtp/QtZW8RGcFBpOJ73/ue82IQucAjQpoUggTRRwdyjOLMAdESPCI8h3uHFKwpU6a0iQ9fzpffI3y2b9/uXpPn8br0F9EQARGITQISILE5LzorERCBBCJAKgk/pJe8/fbbzsTLoos0lWAOfTwj2bJli+upgKmbFLNYHIgjqiV1NDoyq8fitfTmOdG9/JRTTnEpWHg3GD4KgiDBWE53eQQdjyUiggl948aN7v9IpaLqFdGS3Rn/ETuU3UWsH3DAAS5iiIikaABm+AEDBvQmBh1bBERgNwQkQHR7iIAIiEAvE2DHFjO6H6QrUf6Vbsx9ZbBbzU43lZB8f4e+cm26jo8SoPwxjQWpWvWb3/zGiWl8HPxJl3GM4zQWRGD4QRNCxAeP6czgWHhISPWjlC7NC4mwdfZ1OnNMPVYERKD7BCRAus9QryACIiAC3SJAozZ+SCF54YUXbMGCBS6FJd57kVCVCOFB+gyNH9kRp08DpVM1+i4BKl0RhSCNip4glOH1BnDSq/BxkKZH/5XQwf3iU6uoCqchAiLQNwlIgPTNedVViYAIxDEBFuv0LWChho8iXgcGYz/whFAalUiPFpbxOqPhnTfpVjQTpAwvHeSLi4vDe6IeJQIikDAEJEASZqp1oSIgAvFCgL4HpKPQK4HGar01uttNnN1vdr7xshD9OPjgg535WD01emtGY+O43g8SG2ejsxABEegNAhIgvUFdxxQBERCB3RDwXbxpRvjnP/+511hFopu4P3ly9PG0HHbYYW5XXKPvE0BoEO0KRsL6/lXrCkVABMIhIAESDiU9RgREQAR6gMDWrVtt4MCBH3tl0ldo2nbHHXfYF77whR44cngv2d1u4qFHQVBhrqfal6Ig4c2BHiUCIiACfZGABEhfnFVdkwiIQFwQOO2005zxHLM5JWrpZ0ADNRq4UUWIRmq7K0MaFxcZOMkLLrjA7rzzTiPFrD3hFW/Xo/MVAREQARHoGgEJkK5x07NEQAREoNsE/vGPf7goB1WvSktLLT093SZNmuR6IGDY5t/xNohuMLKzsz9y6pRZpQt6Xl6eazanIQIiIAIikLgEJEASd+515SIgAiIQcQKUWT3qqKNcmdWJEydaTk6OLV++3HVCpyzrI488YieddFLEj6sXFAEREAERiB8CEiDxM1c6UxEQARGIeQL0/rj88svtlVdeMaIedHin4zUpZXSsphO2hgiIgAiIQGITkABJ7PnX1YuACIiACIiACIiACIhAVAlIgEQVtw4mAiIgAiIgAiIgAiIgAolNQAIksedfVy8CIiACIiACIiACIiACUSUgARJV3DqYCIiACIiACIiACIiACCQ2AQmQxJ5/Xb0IiIAIiIAIiIAIiIAIRJWABEhUcetgIiACIiACIiACIiACIpDYBCRAEnv+dfUiIAIiIAIiIAIiIAIiEFUCEiBRxa2DiYAIiIAIiIAIiIAIiEBiE5AASez519WLgAiIgAiIgAiIgAiIQFQJSIBEFbcOJgIiIAIiIAIiIAIiIAKJTUACJLHnX1cvAiIgAiIgAiIgAiIgAlElIAESVdw6mAiIgAiIgAiIgAiIgAgkNgEJkMSef129CIiACIiACIiACIiACESVgARIVHHrYCIgAiIgAiIgAiIgAiKQ2AQkQBJ7/nX1IiACIiACIiACIiACIhBVAhIgUcWtg4mACIiACIiACIiACIhAYhOQAEns+dfVi4AIiIAIiIAIiIAIiEBUCUiARBW3DiYCIiACIiACIiACIiACiU1AAiSx519XLwIiIAIiIAIiIAIiIAJRJSABElXcOpgIiIAIiIAIiIAIiIAIJDYBCZDEnn9dvQiIgAiIgAiIgAiIgAhElYAESFRx62AiIAIiIAIiIAIiIAIikNgEJEASe/519SIgAiIgAiIgAiIgAiIQVQISIFHFrYOJgAiIgAiIgAiIgAiIQGITkABJ7PnX1YuACIiACIiACIiACIhAVAlIgEQVtw4mAiIgAiIgAiIgAiIgAolNQAIksedfVy8CIiACIiACIiACIiACUSUgARJV3DqYCIiACIiACIiACIiACCQ2AQmQxJ5/Xb0IiIAIiIAIiIAIiIAIRJWABEhUcetgIiACIiACIiACIiACIpDYBCRAEnv+dfUiIAIiIAIiIAIiIAIiEFUCEiBRxa2DiYAIiIAIiIAIiIAIiEBiE5AASez519WLgAiIgAiIgAiIgAiIQFQJSIBEFbcOJgIiIAIiIAIiIAIiIAKJTUACJLHnX1cvAiIgAiIgAiIgAiIgAlElIAESVdw6mAiIgAiIgAiIgAiIgAgkNgEJkMSef129CIiACIiACIiACIiACESVgARIVHHrYCIgAiIgAiIgAiIgAiKQ2AQkQBJ7/nX1IiACIiACIiACIiACIhBVAhIgUcWtg4mACIiACIiACIiACIhAYhOQAEns+dfVi4AIiIAIiIAIiIAIiEBUCUiARBW3DiYCIiACIiACIiACIiACiU1AAiSx519XLwIiIAIiIAIiIAIiIAJRJSABElXcOpgIiIAIiIAIiIAIiIAIJDYBCZDEnn9dvQiIgAiIgAiIgAiIgAhElYAESFRx62AiIAIiIAIiIAIiIAIikNgEJEASe/519SIgAiIgAiIgAiIgAiIQVQISIFHFrYOJgAiIgAiIgAiIgAiIQGITkABJ7PnX1YuACIiACIiACIiACIhAVAlIgEQVtw4mAiIgAiIgAiIgAiIgAolNQAIksedfVy8CIiACIiACIiACIiACUSUgARJV3DqYCIiACIiACIiACIiACCQ2AQmQxJ5/Xb0IiIAIiIAIiIAIiIAIRJWABEhUcetgIiACIiACIiACIiACIpDYBCRAEnv+dfUiIAIiIAIiIAIiIAIiEFUCEiBRxa2DiYAIiIAIiIAIiIAIiEBiE5AASez519WLgAiIgAiIgAiIgAiIQFQJSIBEFbcOJgIiIAIiIAIiIAIiIAKJTUACJLHnX1cvAiIgAiIgAiIgAiIgAlElIAESVdw6mAiIgAiIgAiIgAiIgAgkNgEJkMSef129CIiACIiACIiACIiACESVgARIVHHrYCIgAiIgAiIgAiIgAiKQ2AQkQBJ7/nX1IiACIiACIiACIiACIhBVAhIgUcWtg4mACIiACIiACIiACIhAYhOQAEns+dfVi4AIiIAIiIAIiIAIiEBUCUiARBW3DiYCIiACIiACIiACIiACiU1AAiSx519XLwIiIAIiIAIiIAIiIAJRJSABElXcOpgIiIAIiIAIiIAIiIAIJDYBCZDEnn9dvQiIgAiIgAiIgAiIgAhElYAESFRx62AiIAIiIAIiIAIiIAIikNgEJEASe/519SIgAiIgAiIgAiIgAiIQVQISIFHFrYOJgAiIgAiIgAiIgAiIQGITkABJ7PnX1YuACIiACIiACIiACIhAVAn8f/U6ntXF83OyAAAAAElFTkSuQmCC\" width=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "#境界面\n",
    "x = np.arange(-3,3, 0.2)\n",
    "y = np.arange(-3, 3, 0.2)\n",
    "X, Y = np.meshgrid(x, y)\n",
    "Z=-1/w[1]*(w[0]+w[2]*X+w[3]*Y)\n",
    "\n",
    "kaki=dataset[dataset[\"ans\"]==\"kaki\"]\n",
    "peanut=dataset[dataset[\"ans\"]==\"peanut\"]\n",
    "\n",
    "%matplotlib notebook\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "ax.scatter3D(kaki.width, kaki.height, kaki.length,label=\"kaki\")\n",
    "ax.scatter3D(peanut.width, peanut.height, peanut.length,label=\"peanut\")\n",
    "ax.plot_wireframe(X,Y,Z,linewidth=0.1)\n",
    "ax.set_xlabel(\"width\")\n",
    "ax.set_ylabel(\"height\")\n",
    "ax.set_zlabel(\"length\")\n",
    "ax.set_xlim(-3,3)\n",
    "ax.set_ylim(-3,3)\n",
    "ax.set_zlim(-3,3)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2934,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#重心法による\n",
    "#扱うデータ\n",
    "dataset=getIris2(iris,irislabels[[1,2]])\n",
    "#評価関数\n",
    "scoring = {\"precision\": \"precision_macro\",\n",
    "           \"recall\": \"recall_macro\",\n",
    "           \"f1\": \"f1_macro\"}\n",
    "#バリデーションにStratifiedKFoldを用いる,\n",
    "skf = StratifiedKFold(n_splits=5,shuffle=True, random_state=None)\n",
    "resultsirisC=[]\n",
    "X,y=dataset.drop(\"ans\",axis=1),dataset[\"ans\"]\n",
    "resultsExtend=[]\n",
    "for i in range(10):\n",
    "    #fitパラメータ\n",
    "    perceptron=PerceptronExtend()\n",
    "    result=cross_validate(perceptron, X, y, cv=skf, scoring=scoring)\n",
    "    resultsExtend.append(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2935,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_results={}\n",
    "for key in resultsExtend[0]:\n",
    "    mean_results[key]=[]\n",
    "    \n",
    "for key in mean_results:\n",
    "    meanres=[]\n",
    "    for result in resultsExtend:\n",
    "        meanres.append(result[key].mean())\n",
    "    mean_results[key].append(np.array(meanres).mean())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}