picturetrans.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-07T04:07:25.820874Z",
     "start_time": "2020-09-07T04:07:24.892352Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "akbnue_JqLiG"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "from torchvision import transforms,models\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "from torch.autograd import Variable\n",
    "import copy\n",
    "import cv2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-07T04:07:25.920604Z",
     "start_time": "2020-09-07T04:07:25.915616Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "lF0JStj1qvLL"
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 定义转化方式和输入函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-07T04:07:27.061886Z",
     "start_time": "2020-09-07T04:07:27.057875Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "L29BtuJrqza7"
   },
   "outputs": [],
   "source": [
    "# 定义转化方式\n",
    "transform = transforms.Compose([transforms.Resize([224,224]),transforms.ToTensor()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-07T04:07:27.820625Z",
     "start_time": "2020-09-07T04:07:27.816602Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "eD07MrlorMF5"
   },
   "outputs": [],
   "source": [
    "# 读取图片\n",
    "def loading(path = None):\n",
    "  img = Image.open(path)\n",
    "  img = transform(img)\n",
    "  # 提高维度\n",
    "  img = img.unsqueeze(0)\n",
    "  return img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 导入内容图和损失图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-07T04:07:31.225268Z",
     "start_time": "2020-09-07T04:07:29.115713Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "AB0FxQjerMZh"
   },
   "outputs": [],
   "source": [
    "# 选择内容图片和风格图片\n",
    "content_name = \"1.jpg\"\n",
    "style_name = \"2.jpg\"\n",
    "content_img = loading(\"./content/\"+content_name)\n",
    "content_img = Variable(content_img).cuda()\n",
    "styple_img = loading(\"./style/\"+style_name)\n",
    "styple_img = Variable(styple_img).cuda()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 定义损失值和格拉姆矩阵\n",
    "* MSE:$\\sum_{i=0}^n(yHat^i-y^i)^2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-07T04:07:31.387834Z",
     "start_time": "2020-09-07T04:07:31.380851Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "OHG9Q-WBrMcJ"
   },
   "outputs": [],
   "source": [
    "# 图像内容损失\n",
    "class Content_loss(torch.nn.Module):\n",
    "    # target是通过卷积获取的输入图像中的内容，weight是我们设置的权重参数\n",
    "    def __init__(self,weight,target):\n",
    "        super(Content_loss,self).__init__()\n",
    "        self.weight = weight\n",
    "        # 用于对提取到的内容进行锁定，不需要进行梯度\n",
    "        self.target = target.detach()*weight\n",
    "        self.loss_fn = torch.nn.MSELoss()\n",
    "        \n",
    "    \n",
    "    def forward(self,input):\n",
    "        # input是卷积层中输入的图像\n",
    "        self.loss = self.loss_fn(input*self.weight,self.target)\n",
    "        return input\n",
    "    \n",
    "    def backward(self):\n",
    "        # 保留计算图（中间变量保存下来，便于对style_loss进行计算）\n",
    "        self.loss.backward(retain_graph=True)\n",
    "        return self.loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-07T04:07:32.455547Z",
     "start_time": "2020-09-07T04:07:32.450560Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "uAtgcAHFrMer"
   },
   "outputs": [],
   "source": [
    "# 格拉姆矩阵的解析：https://www.cnblogs.com/yifanrensheng/p/12862174.html\n",
    "# 作用：提取风格图片的风格\n",
    "class Gram_matrix(torch.nn.Module):\n",
    "    def forward(self,input):\n",
    "        a,b,c,d = input.size()\n",
    "        feature = input.view(a*b,c*d)\n",
    "        gram = torch.mm(feature,feature.t())\n",
    "        return gram.div(a*b*c*d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-07T04:07:33.292908Z",
     "start_time": "2020-09-07T04:07:33.286924Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "DXnWKN-FrMhC"
   },
   "outputs": [],
   "source": [
    "# 图像风格损失\n",
    "class Style_loss(torch.nn.Module):\n",
    "    def __init__(self,weight,target):\n",
    "        super(Style_loss,self).__init__()\n",
    "        self.weight = weight\n",
    "        self.target = target.detach()*weight\n",
    "        self.loss_fn = torch.nn.MSELoss()\n",
    "        self.gram = Gram_matrix()\n",
    "    \n",
    "    def forward(self,input):\n",
    "        self.Gram = self.gram(input.clone())\n",
    "        self.Gram.mul_(self.weight)\n",
    "        self.loss = self.loss_fn(self.Gram,self.target)\n",
    "        return input\n",
    "    \n",
    "    def backward(self):\n",
    "        self.loss.backward(retain_graph=True)\n",
    "        return self.loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 导入预置网络VGG16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-07T04:07:37.423315Z",
     "start_time": "2020-09-07T04:07:35.427617Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85,
     "referenced_widgets": [
      "9f88fe92388d4c20a8bc04ad3cf7e924",
      "7fc9a7348f544940b08a24b1ba9d1ccf",
      "e1de2be4586b45c4a4eb89d8db5add64",
      "6002eea3297e4f3399cbbcdb5ef18bbc",
      "8c47f46b4eb2485b9e40128d9926bbba",
      "032d72fcacaa4808b953bd85dae65a90",
      "faac7ec2b6bd464c9492c7b8064acc22",
      "5f52ed3c438d4dc0917f3ac95595bb7a"
     ]
    },
    "colab_type": "code",
    "id": "rJ-JDvgrrMj0",
    "outputId": "ad0ddfbf-b0e7-4bb8-e152-248fc64c169b"
   },
   "outputs": [],
   "source": [
    "# 导入特征提取网络\n",
    "cnn = models.vgg16(pretrained=False)\n",
    "pre = torch.load(\"./model/vgg16-397923af.pth\")\n",
    "cnn.load_state_dict(pre)\n",
    "# 提取VGG16的features部分\n",
    "cnn = cnn.features\n",
    "cnn = cnn.cuda()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-07T04:07:37.911978Z",
     "start_time": "2020-09-07T04:07:37.901004Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "j4-8CtBGuehf"
   },
   "outputs": [],
   "source": [
    "# 重新创建我们的模型\n",
    "model = copy.deepcopy(cnn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 对迁移模型初始化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-07T04:07:38.359779Z",
     "start_time": "2020-09-07T04:07:38.355789Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "g-eGdCCNueeh"
   },
   "outputs": [],
   "source": [
    "# 提取内容所需要的卷积层\n",
    "content_layer = [\"Conv_3\"]\n",
    "# 提取风格所需要的的卷积层\n",
    "style_layer = [\"Conv_1\",\"Conv_2\",\"Conv_3\",\"Conv_4\"]\n",
    "# 定义内容和风格的损失值，用于控制内容和风格对最后合成图的影响程度\n",
    "content_weight = 10\n",
    "style_weight = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-07T04:07:39.387525Z",
     "start_time": "2020-09-07T04:07:39.384511Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "X3muK9FGxTA7"
   },
   "outputs": [],
   "source": [
    "# 存储每一个内容层和风格层的计算图列表\n",
    "content_losses = []\n",
    "style_losses = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 构建迁移模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-07T04:07:41.269894Z",
     "start_time": "2020-09-07T04:07:41.264873Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "1aw4kBZOuebg"
   },
   "outputs": [],
   "source": [
    "# 创建一个空模型，用来存储我们的迁移模型\n",
    "new_model = torch.nn.Sequential()\n",
    "\n",
    "gram = Gram_matrix()\n",
    "new_model = new_model.cuda()\n",
    "gram = gram.cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-07T04:07:44.089174Z",
     "start_time": "2020-09-07T04:07:42.180844Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "itlgIsM6ueYp"
   },
   "outputs": [],
   "source": [
    "# 构建迁移模型\n",
    "index = 1\n",
    "# 从VGG16中提取出前8层来当做风格迁移的特征提取层\n",
    "for layer in list(model)[:8]:\n",
    "  # 如果这一层是我们的Conv2d类型，就将它加入到我们的新模型中\n",
    "  if isinstance(layer,torch.nn.Conv2d):\n",
    "    name = \"Conv_\" +str(index)\n",
    "    new_model.add_module(name,layer)\n",
    "    # 根据选择的层数分配为风格提取和内容提取\n",
    "    if name in content_layer:\n",
    "        # 创建特征提取层，\n",
    "        # 将内容图输入到模型中进行计算，获得卷积得到的feature map\n",
    "      target = new_model(content_img).clone()\n",
    "     # 将控制内容图的权重与feature map 构建内容损失函数对象\n",
    "      content_loss = Content_loss(content_weight,target)\n",
    "    # 将这个对象添加到模型中\n",
    "      new_model.add_module(\"content_loss_\"+str(index),content_loss)\n",
    "    # 记录损失函数计算过程\n",
    "      content_losses.append(content_loss)\n",
    "    \n",
    "    if name in style_layer:\n",
    "    # 将内容图输入到模型中进行计算，获得卷积得到的feature map\n",
    "      target = new_model(styple_img).clone()\n",
    "    # 将这个feature map构建格拉姆矩阵\n",
    "      target = gram(target)\n",
    "    # 实例化风格损失函数\n",
    "      style_loss = Style_loss(style_weight,target)\n",
    "    # 讲风格损失函数对象添加到模型中\n",
    "      new_model.add_module(\"style_loss_\"+str(index),style_loss)\n",
    "    # 记录损失函数计算过程\n",
    "      style_losses.append(style_loss)\n",
    "\n",
    "  if isinstance(layer,torch.nn.ReLU):\n",
    "    # 激活函数正常激活即可\n",
    "    name = \"Relu_\" + str(index)\n",
    "    new_model.add_module(name,layer)\n",
    "    index = index + 1\n",
    "\n",
    "\n",
    "  if isinstance(layer,torch.nn.MaxPool2d):\n",
    "    # 最大池化层也正常池化即可\n",
    "    name = \"MaxPool_\"+str(index)\n",
    "    new_model.add_module(name,layer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-07T04:07:44.564903Z",
     "start_time": "2020-09-07T04:07:44.560912Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "r8AjqxMyueV6"
   },
   "outputs": [],
   "source": [
    "# 获取输入图片，避免在卷积过程中对原图产生影响因此使用了clone\n",
    "input_img = content_img.clone()\n",
    "# 将一个不可训练的tensor类型转化成可训练的Parameter类型，从而使得在训练过程中对input_img进行风格修改\n",
    "parameter = torch.nn.Parameter(input_img.data)\n",
    "# LBFGS也是一种优化方法，他最大的优点就在于它能够写出一个closure函数，\n",
    "# 在函数中记录多个损失函数的计算图，并返回\n",
    "# 通过优化器，实现反向传播和参数更新\n",
    "optimizer = torch.optim.LBFGS([parameter])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-07T04:09:27.078905Z",
     "start_time": "2020-09-07T04:07:45.172278Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 125
    },
    "colab_type": "code",
    "id": "Cfn-wkitueTB",
    "outputId": "c222dd07-e288-4fbe-d856-45668b328291"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:[50]  Style Loss:0.762888  Content Loss:0.222426\n",
      "Epoch:[100]  Style Loss:0.194673  Content Loss:0.022245\n",
      "Epoch:[150]  Style Loss:0.039755  Content Loss:0.009413\n",
      "Epoch:[200]  Style Loss:0.017350  Content Loss:0.003220\n",
      "Epoch:[250]  Style Loss:0.009732  Content Loss:0.001658\n",
      "Epoch:[300]  Style Loss:0.006569  Content Loss:0.001040\n",
      "Epoch:[350]  Style Loss:0.004555  Content Loss:0.000647\n",
      "Epoch:[400]  Style Loss:0.003578  Content Loss:0.000447\n",
      "Epoch:[450]  Style Loss:0.002913  Content Loss:0.000324\n",
      "Epoch:[500]  Style Loss:0.002368  Content Loss:0.000255\n",
      "Epoch:[550]  Style Loss:0.001942  Content Loss:0.000201\n",
      "Epoch:[600]  Style Loss:0.001631  Content Loss:0.000158\n",
      "Epoch:[650]  Style Loss:0.001390  Content Loss:0.000128\n",
      "Epoch:[700]  Style Loss:0.001189  Content Loss:0.000112\n",
      "Epoch:[750]  Style Loss:0.001011  Content Loss:0.000096\n",
      "Epoch:[800]  Style Loss:0.000867  Content Loss:0.000082\n",
      "Epoch:[850]  Style Loss:0.000747  Content Loss:0.000071\n",
      "Epoch:[900]  Style Loss:0.000646  Content Loss:0.000063\n",
      "Epoch:[950]  Style Loss:0.000560  Content Loss:0.000054\n",
      "Epoch:[1000]  Style Loss:0.000490  Content Loss:0.000048\n"
     ]
    }
   ],
   "source": [
    "epoch_n = 1000\n",
    "epoch = [0]\n",
    "while epoch[0] <= epoch_n:\n",
    "  def closure():\n",
    "    # 初始化梯度\n",
    "    optimizer.zero_grad()\n",
    "    style_score = 0\n",
    "    content_score = 0\n",
    "    # 将图片的数值（0~255）压缩至0~1\n",
    "    parameter.data.clamp_(0,1)\n",
    "    # 训练模型\n",
    "    new_model(parameter)\n",
    "    # 累加风格损失函数和内容损失函数的反向传播值\n",
    "    for sl in style_losses:\n",
    "      style_score += sl.backward()\n",
    "    for cl in content_losses:\n",
    "      content_score += sl.backward()\n",
    "    epoch[0] += 1\n",
    "    if epoch[0] % 50 == 0:\n",
    "      print(\"Epoch:{}  Style Loss:{:4f}  Content Loss:{:4f}\".format(epoch,style_score.item(),content_score.item()))\n",
    "    return style_score + content_score\n",
    "  optimizer.step(closure)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 展示成果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-07T04:09:27.921580Z",
     "start_time": "2020-09-07T04:09:27.670251Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 287
    },
    "colab_type": "code",
    "id": "nkLdtqqOueKo",
    "outputId": "79a29b43-bce0-4e53-bfcb-fed857905695"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "D:\\Tools\\Anaconda3\\envs\\pytorch\\lib\\site-packages\\torch\\serialization.py:402: UserWarning: Couldn't retrieve source code for container of type Style_loss. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "D:\\Tools\\Anaconda3\\envs\\pytorch\\lib\\site-packages\\torch\\serialization.py:402: UserWarning: Couldn't retrieve source code for container of type Gram_matrix. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "D:\\Tools\\Anaconda3\\envs\\pytorch\\lib\\site-packages\\torch\\serialization.py:402: UserWarning: Couldn't retrieve source code for container of type Content_loss. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAACTCAYAAAB1YlneAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz92a8tW5beh/1mE/3qd9+d9p7bN5lZmZWlKrKKjUSKgmECtmTY1pNfCn7wgw0YMP8E+08wHwzYgATLIEBJpkhKbECxGmYxM+/NvH1z+nN2v/om2tn4IXbeKlmsIg0prVThfNgLe6+1Y8WKiBUx5oxvfOMbwnvPK7zCK7zCK/z5gvwfegNe4RVe4RVe4b9/vArur/AKr/AKfw7xKri/wiu8wiv8OcSr4P4Kr/AKr/DnEK+C+yu8wiu8wp9DvArur/AKr/AKfw7xSwvuQoh/VwjxlRDioRDib/2yPucVXuEVXuEV/tsQvwyduxBCAV8D/w7wEvgx8L/y3n/+3/uHvcIrvMIrvMJ/C7+smfuvAw+994+99zXw/wT+5i/ps17hFV7hFV7h/wu/rOB+BLz4E89f3rz2Cq/wCq/wCv9/gP4lrVf8K177b/A/QojfBX735umvbW8fIYTE+//mgkK0a/N/4h/iZu1StA+lBEJ4tBQoCVIKnPNUjUMIQagVxlkEAi0FUoJHYK1v14tHSoEQAtc+vfkM0f4IEEKAb/8hbzbAOfft7nrvETfb9ot1CQk6CMD7dlkPzju8cwjxi3HVI5VqlxcC7/zNbvpvnzvncd6DF3h8+xq0y/p2OfAoKb89Ns558Df7d7P9UrTvB9BaoZTCOYt3Dm7Wa637dr9+8VsIgZTtPjaNw9o/3v7r+RwrYoSz4BxIgdBRe0yQIBV4B94jpMJzs5/eo0KNkmAbi/cebx3SbACLFxonw3Y9QiIQICVSKRASnEFojcBjHThjv91OhGy/RNsgJTgRtt8dAu8t3pp2u27W42wDN9+JDkJUFIA1OGO5OTR4Ad45pFJIHYAUxJlECVBaoiUILKGs8QQY65HC4Z2kMQ21UWzWFo/AW4OQ+mYfgvZcDkOkACckznqkkkgtwUMStNuntSMNG5Roz3fhG4QHpcJvjy2+AluANe0+O/A6BB19e03VDSxyhTUl81lNEHapGoXzEgLVfrcShPBgLd4rsB7vHaBAeaSy7bWg2utPKYH2ljiE1aamagKkVggpwLXXV6QcXkqsAWUbvPvja80rif/FeatUex0hkFoihEC7CiUtQoZYoamKCuc8Qiik8CitAIEQhkQZVABCC5SQWAS2tpjC3JzfEqk1YSAIEoHAt9eNbM8PKdprxFiFsQInNM6DrRsaCx5FY9oYopUgFI44BCk8tQEHNFZgHYAiUhaJxViDUBqtNWEgEaJCOINFURmQtaUpa3QYIIUlCD1CeiwBTWNRDuqb60AYz3Q2xzs/9t7v/Cvi7S8tuL8ETv7E82Pg7E8u4L3/28DfBlBK+f/wP/w/IkVM03gM0CBwvj14SnuccVjbntRSOqJA00k0/dTTyRRZLImkI4skobJ0en0enc6ZLRqOdwcUTYUG9gYx26OE1abAe0eahHS6Mf1Bl8VswenpAuclYXRz0UlBGAY3AdQSaIWUEucc1lqMcVSVQTqII02aBkSBBgxBpOiNekjvaZqaIAgoi4rVag0CojAkzTKybobz7fqEFwQ6wFqHaRqaxpLnNVXjyNc1jbFUjaExvwhWDu8dYQh3bh9T5jnFusQ5h7OesijJOglhKCiKksV8RV1ZhqOUW7f3kXiqYkmebyjLCjzESYS1Dav5gjiKkUown8+pcsdyUdE0niQO2WwM/5f/6P+F3fmAalZRjc8RNMj9e+jB6zTFEsIdyDJcUxFEW2ilEMripSTppsT1nDSVzKqQYjFFfP2fEbFE7L1L1f2AMAhYOY9rDJgC5QQ+SKnyBaEWGF/RWMFgsEMQCIxX6LSLKq6hqoj7fSqfYOoCKQzLeUFd13gPYSjpxrBYrLFW0N3Z4+hkmziVOFMxf3bB1VWFtxaTr/HKER68hu716SjYux1x/7WQ2/slLtAsXZ9j/5ym0pyOA7Ks5mC7x4dfbfjwC8P5z35GM7mk8Zb+wX06YUTpPDIIyR58QH5+SrA1olo7Bm/fJtrt45cL3t4a8+bWjCxac7d7xf62JlMe7daY6ppueoKKRxjXIGYfIqafQtFQ1yF6dBt2d6id5HpcUqkeYRjy0+c9/uO/O+VH/+Jzjv7q/4Hq4QWTOMCVAdUsINvqEGQ1YV2Q14qNjBD5FCtj3O6ARG5IA0sYG0YxyK6iu7nkvTtTnpwd8vsf1cjekKjbQxQ5O92SW3sQyS5+VTA0K5CWznZKlg15+PUVT56uifa70N0mSSyhDkmkIIgSMnOGy2KyxuCjjOurNacvLzFrQ5LG9HZTsjghSJbsJVNudUs6W9BxMZ1Rh6u85PLSkC9jNj5Fp32cr3htt2RPTtDuOVUV0aiItN+jsF3O5pLnU1jbiEJKFmdrzKqhkSlNuANhyG7c0Oms+J27EVcLw5cPL7B6hxrBZNXQ3dnluDfj8UPHdDImGSYcvJbx1q5iL32Jm6758rOccWHY6kXcOuxRrVaYZMrJ1i7l6ppnLzTntaOsJU4UBDJhskn4L/+T/5g6z5/9aUH4lxXcfww8EELcBU6B/yXwv/6z3uBsg1AKIX07kroA5ySVd2g80gu0FlgLxnqU8pSNg8KR1w1RKNHCo5UgVpZ4apmuHfOVoajnRJEkFBBpiCLQgWQwTImzgN3DXZxpaOqQbiemsaC0/nbmqpTCWovWqt1W51BKIqXE2gqtJVoq0jQmTQOEM5SlwTnDarpEB+0dQBiGZN0uQRRRVRVZlhGGYbseY9sZoveUZYlpDNZ6jPHtBMy59g5GSIRUZLHCC0FVVzSNBSTL5YrwZmbgnCOvcsJQE4YaKUFr3c78vccax9XlNWGgkRjqssF7wWh7SH/YxTQVWRajEFRVzWK+RAgIw4A4Cqirik3ZDjZKhtggoBGgZIxbrundTtk0DaYpCfQWVkSIIED3MgLtaTYFpihYN2D8Bi0V0gucFiitaaQkSWBvpybb6XM1bZhee5KiZLpY4GyBklDOF8jeFiLUJMpxdTVFrNfs7iYsZEYju8hiRrU5I1+MaUqPMxBGAWWlcXKEynqE6QiihPPzFdoV0NvGNZrtXVhMljRljers4OuczHmCdJdmVnP6FPrDHutNiA8ET8wegbfIYcDl+RXLJuCFuUPh52R7r3N19hScY339ArI+XseUjSPcmeLmU1SgCS1IUxJFW4iBYN6k+PqSODIEssZWMSJe4p0gjEb4QFGbNXL1BKZf4MuatbtLcus99N5rIFbUqzNcsk2Rh0xryc4QPriz4g9+3xFGXZrU0k9A9FLm8oIkf4ydpHDc4f0HQ+ZNw5fPHYGs8MGGWIKNJCJI2ODoWpjIIVebGruVMNiGpQlYzT1ZaSjKDS6I6OzN2T8WdLOYo+EW/U7Ep5OEW6TMg2uqfI2yJd1uD2NilFgiY8PG7JDGCq8MDZru3R2GMoRZDoMeR0cRUnqKPOO06TE/u6Inu8RBxF1zzt5xSpD0eXjWIdx0UElEIRo2CZTxEDUVNFHA5TIlKwPi7QEyqGjCgNWqIA86NHFCvydwrkehDet5iZ2VZNkhYzshSEKK7m3yMmI+n9PbvkvWDZFJCGmNrEKiRNMUIZeTM2TTp58O6d0rEaXmQb/DwV6MKcbMFoeEgx5j2ePDqwjdiSjOx5jNDDHscVlr7L9GC/NLCe7eeyOE+N8B/yWggP+b9/6zP315EN6TKNjb01TO8fyqoW5CnADh2+RAFIVY61htGlxlcA6qBqRwKOnQur3N7ncCgtKRVw7rJcZrMqXoJJogFDjfsDUasrffo2lKFpcXeONYLyu0BqQnCBWe9hYZHFqLP+aaxA2VoxRKS5IkRGlFFEh0IHAGhPJIBM4YKufQgaaqKsJIEsUxSZYipfp2xi6ReFr6xjSGqqppaosQGuvAGo+zDmssSkq0li09AighcMazXhZEYYBpaqx1SCFIOwlCCpxzDIcDgkDiTEvV1HXJpi6IQkV/uIXzliAKb6gTTZx0EK69jY2iFNtUeAzrvGCzqdnkLc0wXtdo2SPK+kgMNkppmgCV7eCswyzm6DBCIFCVYtRRTPKW61DdIakIWGw8URxRq4AwikgHGW+/F/Pb7yzI829o6jVn0x060RH/1R8848V1gNBdgkTiHaxnS6ogQIYB3ubM1go13KHJS+bnz0m0h2BI3axRomK5XhImPY62OqSR5LLU4C3DkeD+TpfLdc1sU+HzBYOu5LU373Je9bE2gNWY6eUXDO6kiHnG2aOGeKdLPOpRzjaoRCDCkPO8y2yZstoYmvk1utNDD3ahLPHWUZRTDu+/xcXFmipfUlcrhuExWofUqw1NXiG1oioNn39T8ZtvW8KtkkhlSCyehjDutN/vZoFYPYWmohE7xPf+Ai7sstw0dBKJcwG7WwlKanyec7nYppeWVI1lM90QZoLjwZqoF/Ao3acqKoLLFdtRzNPJhHePUzajlJnyBIHCVQ6hu8i4pgklm0CyMilWxjRVQNwNaVYroiQiPNyhm3Y42ptw6/aIk5FmP/JcTA1n64xlbpjIDjtHHUw9IZBQyy57257GJpQbgfdQmR5pN0Dla4RWbB/cxgwLRntdtjuCfD1nlEpmK0cRvMWm6XBdC9abIVNfcPutEUcZPH3iCNAkGsoqpIh6ZAdHaAShWHKRL2AqqUyHKghYlhFe9NCB5eSkT1nXXCxKgmGHoBdT+RVSKS7rHpeBIor6aH2bvd2co7RLNOqztRPw/OU53dTwYjlnrY64ahSXruWWdU8T7Vs6xxHjdZfezpp+0qXp93lbJjw8bzAqogj6LNcSKRr+RET6V+KXNXPHe//3gb//b7KsEJBFlpOh5Xe+1yOIBD/6bMXPH1VMckknTgiUZrneoHWA8xJnWx42uuFukYKqcYRCIWVA1lP0pabMG5S0nGwn7O0k7G5FKG8INJTrDYOdAfPxjOWiIApD8A5rJTpQqAACHVGVJdZanBM3M/aWO7emJgoleyeH6CihLsZoYfFeInIDlQUvQQiUEDR1Q91YkjQl62RYHI1pEM4jb2bt3npsY3HGEYYxzkHdNFRVjXOOQImb4+tQUpCEIUa2nLsQLfXScs8KKT060Hjv6HY7aCVJ0gRnLEVRUVeW9WaNlJB2MpIsBu+pi4Yiz9tBJGhnCForgigASsqqoTKWIFBoKej2E/KpRUQJYZrg07s4N8JqD9oRyJrAlcSxwLmK8nqNXRvCJMCYgjL0WFtgpUBJz6aquLXd48625fTpV7x93zJMS052+yyaivv3Uh6fz7F5gXQ1yA5JOkD3RtSLM1y1pi4aysmHBHGH9PgYLUPS/pAoDEjSgHw6pxmPGY+vuTOck5ohax+S3b9NEWtkneOFAyyDbswmb8h2O+AUeRkQ9Dt8/nSOZsxgGfH+b+0TVkC/S6KuePqo4eV8Bzp9TH5Nc32B7kaEOqFz+zZuPWZdWWZ5ihM5xXxKk69Y5BVBEiIvJiwcRDvbPNgpGCiHijy2rtG9BikcBBIhJK4Bu3yJLq+xMsT03qXT26WscpSSCBRJGlE0c8KoT7y+5ngY8NO1xBpP4Sr+6nuGv/4XetSLmL/9keazi7cQ808JMkGM46uJYefNEYsLhfM1vt6guj1CQnydsiwiau1ZiIxuNkeNjiG8xtQBvWTEVifHdBJ8GiLimHDXsr+b8Xt/uKTTCegdaB5eGny+zU5XIBNFkO4zeTFGBgWBtViXsSgUm+UYMZ/QG51w6/4R9WrOpHb88LUui5VnnJfYbkKSafzcMhVHlFZz9rMZf+V3YpK9Dj/5WU3XSKrNGkTMQbeDtwsqL9nbPqS/vc2HT3JOrwQzajpNyPGBJev2WOcrekpThD2q+QIXdJnoLX4yk6iyprvbZdi94LX9XRYq5f0jwfVywtUmZZkLtOwwKSpOrwp6Wcyb7x0xW+Z8vako5yGXteKdw102puJqGaOCBgOYYUaqBpTjBh0s/jj5+Kfglxbc/3/F3aHjO+8GbA0qOmnIDx+E9OOQHz3KGa8LAqXbwFMbAgVI3yaxbnZQSEGoNLGWBErQS0KSQOESiZaOnaFmNJBsDSO8CaiqCmsbmrpChRoRKuIopNeNKIqSKIkJIg3GUgXtHYO1bVLUtx+Id4Kkm9DdGaCTbTADhM0B6JkGU6woNht83SBwbNYVdW0xTQN4lNJYZ5FC4LxHipuBIAiItUagWa9zmrq+4f4jtA5x1iGkQApFURQIoRGiHXBQkjAM24EgkG1QDmK0UhRFznqdo26So2Gk6akOzhmc9ygV4H6xj07QWEdjK+q6wSMIg4DgJv/gnEfKNqka7RwhJVRna05ee4PTK0NdTQkHewRaU5UVzdrgS4tzhrJcYuIUR0KxmuMjEFKS9rpsdIBwIe882Ob770himdHLKuazgEQLlLsglSU4i/OWOEvw8YAg0jitiPt9yuKMMEkZ3noNMTymbhrC9YKlA6tiNipD9yzaG/yoh45n7CU79MKE3sDRk2ucjhilbxCYDX0z55MPx4Qs8VmHyii8FfQ62+iuZHiwx/V5xfoipxiO+Mrd5/Snn2DkmmRPkT/5gs35Q5LBXbKjY1Sygwodu2mXRa7JZJdqvkZaj0bi85x0K6MKAkzdYIQiigyBLjCNBWqU0kjdQYoE6ivC8jnClgh2ifsneFMRBBEIiVSW2uTUTU0SeppuRCJmDDODCgS2KjkcTonlbaax4a0HBzyvK67mu3xqDEc7eyxmNeYChAUrEgrbEC03qLAhzEIoIXSa2jT0uwF3spwvV1tEHcu/9VrFD981jOKYcQXXkxwd9Eh6nnu/9jof/fSUN6KKu6HkhUr4wZuCxsU8WjiiTsBemHK+hmZVIC305Dbr5YaDBxFkGulCOmHEi/WAg8zx4L1dChom8xWj0FCXjum0wtqAP/qjgvfel7x9b8BkVbDVZMwmJbU/4v7tPQ4O1yznc1YbybXpkteOVDTc3ZFsbcW8XFp2Oz0mUUl5XWIx+HiHr+Ylm7XkfmeDXD/jcK/LuRhwPy14tvQ8HUdYCTLoMX55RqQNUvXJMsHlpGK/36WqMp5cbdjaTdksPaczy3S1IQoKjhNFqnqU8xVFolnP3I0Q4k/Hr0xw3x8otnsKHUqsF5iqpBMpRh3JeNkmEbVWBEoS3MhStFIIL5HSttl1JdBaoYMAKQVaWoTyBAr63YA09pSbJaZ2CCWJAkW5XqOTjL37d9jMl1R1QdCBzlaGjlLcJofNBusgjlKKoqIsKuJQEyQJSX+ATjKcDJGBRgR9vABpK5QU9LodfF1iTYEPU+qLMaYxmKrBBW2A9M6hfqGY0ZIw0HjnqQvTzubxBKEmDH6R5FWApygKGlMRhiFCQFFUaK0JQkXTtNn5qqqoqjYpqJSiaQwWQaebsr09pGlqnDftrbYFYxy2brDWs16vKcqcSGu00jTOYI1pt0EImqbBOcfgZBu/1eHl6VPONxnObRA0mM0CU5egJXU5RwYDZNSn9j28t4RxCPE+ZVMTJJq027DwFdJJAvMS1+zh40N0CEkWo8MZUb7g+FbKaGfIZl6wLBqy4QjvDcpVrNYFRvaJgxEqOsDlhkzWOC0R0twkyiVBUyKzjEYFLBoYhI6u2tC3gm2/Ii4a0oNdvrkIOBsr9o8HTG0FKsMZS5OXWC+IdZeriwWjk30efv2UYv0l++9+j+DOG5SffUzZPCHtbOH37jN5fMbw3huUriTZuk81mxFKR9wdoYymiWKMt6SDEZ29jCbIqDYFl9cVuzuaQNRoHaJEjFQOKfuAo86foc0Sh8bpDB1nABhXo4XBAh6P8IZ1EZCmezhqlDwDK7h7p8PBrZKDOCDrphiV89GzhPzkA6rnn7Ost9H9nL4oEaHDEdLJbjOfPKY2IasiRhATq5qcDhu75s5ezsZHjFLLrbslR7Fgtlnx4pnCxX1ePq4YpA2j/R3C7ohHF2MQkiyIiEKJlDED5SkMFOuA4W7KQgiaxYQ3bmXkd0eMjm8xm65xyR4HA0+3L/jmazi6LamJ6DtF0Lf0u5aHj3MuHgsm64Tf/8zx5u6EvpKsjebeG/s8fXRNU3WIkgArBjyfVVxNpnQdvHVP8/pr8OR0w3aYsi42vLgo2Eq2GBx0EKbmxXPBg3DC0XBDScpneZ/desYZIbmNWC8URgKy4N/9juLodp+VDbmeRSyKgHnR0FOwsDPKusuPJwX5ZM1xt+KtKOBHmcCQk9c5Uibs7LQKJftnxNRfieAugDDwIBRhEqKUIsgimkmBqSxJGLGpWvlfoARhIG+Ct0RJifEtKa+lIAoFOhBIKQkDCJUHYen3IwZ92UryUMhQgpTUm5IgVETdlLi7RV0VCOHQUYJSMU4uSUKJ8A7vLL3uDplpcGaNSrvozh6IhFbIZXFYBBFCalQQ45sVQnuCoMcgyzBVjSlKTF2jvEMEGiEkApBKYZ3HWXujxjFI6UnTCB2GOOepK0NdNTSmaRUfQYRSEtvUaCXppAlCCEwDzlrW64qmaXMMWiusbQjikDBSIBxxEgEh1tp2sKhrvHXtjLGxRFFMoBXeWVzV0B90QEiULqhLQxBIJuuQ4f4tnArIF2vCnTuIxRWBKKhMQyQ0Ikmoy4og8sg0oxM58sUMi0QkPaxMmM5m1JVl0Bc8uDsn0p6tVDE0Y0aiocwGjO0E0tdI93eo/QatHbGwJKKgyi2uXJMMD+jsHFLUG2QcsRIZwcEeWzsdahejbU0djChXJarccNDX7O33SENHsTJMCViYFfWTAp9GNEXBfLHh3Q8SjCp47nusrxVFbcl6A2xtkbNLDvZ3ucz7zJ6f0dk/It07wlcVfvqM7u4IFziGnYhZlVLkG8x6RpgNSQZDKGs2myVdsSHo36dSIENNWjXYumSRQ+AbAu0RBAgJUmX4eonM12AD8KDCCHQM3iJshZa6VZh5TdM0lHWFDCKmq/bcapViElsnxKMd+p2A6+UZygkacUy9WNFJFYv5NcW9Pv0o4Xx8zsGtHui3qK6/oV5dE8uYJhugasFqmdAJe3SHHfb31rx5F6rrS251+1xvg+/e43y85urJGZtiA7HmYHQLk4UsxzM+OVPsdBUqCXj70PDZaQjSoba2CDoBD7a/JI9uca41Vlj2txOeTQ1//eiSr7MU36S4Omc2KXjrMORwtA2ZYTwec355ja5Sps9Kvv/OAFMbsmjB/v2E0+se+ekFZbzHclLSWV3RHcZ8916fUQdO05in44qvzxzDdAcfV/St5+HZYw4HHb575FmbgOvVDraoKWPHeuJ5fSugk4z59BncO1D0EthMl+wdHDNee2KpcKZhPb+i0+/x6YXj/GXFb94JePdOwGZZ0c9qkolFdyLmxrM8K7Huz86o/koEdwT0ByllVTG9ruj2UrQQyBtdupIOIW50yEoTB61mWynQyrd601AThYJYC5JIoIUj1IqtfkyUarYOtkhSAUicN9R1QZwMSboeLxtwNR5DlHRBJghqcCVIi4qjVptsXKtpjiOMFahwG0Sr6cZbnFljqwlB2MfZkrqYYDZLlNIIlRJmku3jXWzVMLscY+oKvEWp4EZb7FpNu3N475GqvRsJdYAOQqqqwXvf0i9AELTKGO8dQiuSpN0W5xyh1lTWYLyj3+8xGPQAR10nxFGAtQ1R1N7h1HVDVbWDgNIa65obNU+XTjclz1c0pibpZMSJo9vrkE7mLBZrtBY0qzHF0fvozjYuyDB5hTKGxiwQuoc1FpGmDHdGrKsaZSVex1hlcKspQkviaITLLcoaZDBAR7cYZoZ+4gkWFl1c4cMcW1dUZU2NZlXWOFNRlZoodlTLK7xVKB1SLy/pbWdsZESwPSAcJSw2DXI9pd/J2e42CHPNbs/x2q2IMPZ0Ol2GWwM6WcL0esqyXFM0ip8Ihd0sWC82HL/RIdrpcf4crk8nqOYlzmRcPvcM9wcM4wGzTYmbnZMvx0gSyk1NMH9OcPAabtihl/ZYv5ziDm4RxBFya5tyUZJtVVw9/JhusENX7EFQM9QVQSdFZQ1RWKKlQ6kC75NWl97MwUwRMgJnEaZE3UwyJAKcBGGRXhEGilG8oRL7TIoeUjwi8YaelHz0EA6P5tySnqvCobuH2LMJthMzP39MvHeCXK2J924TFB0ml0+Qw9tsdftIGzMIVtSBotezNKUgVQt+a/8ctfsawvQJ9zrQBIRBQ1mseG9Uo3Yzvjo19HpbPH/6nL3gFsY4no1jwtBgjSMapXSDgkZ36Qw1m3nCTG4zl3ssFjNyp9jyG5Yzwzdf59ztWh6NHWI5ZfK8ZCZTlILbR32aH+7z5FPF6cOn2MPXeHTdcBQrPv1oxTvf2eK0XGGriHSUYfSErZMuH9zLUL2EHz2rOBvD1QKU6qL1jCNdMF4rvv/dAb3eNp99s2SeR2QxzNcl2ghuHw4wdkPXXTGIuizKLj99qHhw5zabdcbcGPLzb7AbxdGtLT6fWz57UvHbb/f53rsNX/z0Eu8VP/i1Yz54yzBfVfynf+8pVdZtVXZ/Rlj91QjuHpbLBZ1sl+vLNYuZRasEJRVxZEkaSXNTXRQoR3BT5IC34DxJpOlkkizTRAoCIQkVKBxJorn92h7JYIgQrazQ2zVRmILMcDbHmgKNZ3U1Q4YxUdZDK4mzJVJ4RBAhVMtTe1+AU0il2/Jes8R7gVAhUtR4DUiLsO3M3LoA11TU9ZpyNaeztY0INYODbTaTKcI6hL8pivItTfMLHb0zhjBUBEFAUxmwjjgKEaINyPImkeqcJQzUt5r3IAgQQhGECiE6JElMECjquiGOI4JAfVuIVRQF5U3COIraQpeyKRFCo5Qm3xRUdUOn20HrANs0VEVBEErCUBIEmnI8pTu5Qu3sERhBozQu6lMVS1LdgARbGTpxQBN1qWzCKl8Qbx8i9g4pNjl2MeV2z3AVe0zcx0tFVc4htPgqp1msCHZHdIav8a494idfOnjtFtOzBcJLarOksA45OMJXOfF2QFlFuG5A2M2oL8eYVc53j5d8f29KGlruf18Q6BQVaUrvGC8KlLUM020YxmwucyoETdTlZDdjvvGMi5r3HnR58zjj09MDbOkoliUPv5mz3CjC0NONNYlcsypKfJIR7N7FLZ4T9kbUKmF4soXWGlVt6PVS9CBEqmOku0OYRPhUYYQl7SZkhSIMG8KolSyGYUUoJc5apAJsjZIK5xzSV9DM8OUaGcV4YfGuwssI7y1xklKZDU09x4oRm1KRe8lEdilyw8dfv0RuuuQzhTclaRKSvvsdzj8NqM4m7L65w+b0G1SVIW1EMb4iSbrc6+YMtWTsoDIBm1JgXMN7oynng4zpWjCehaxXKXkDmzAiz6/5q6+tkMGSa3vM1YtTVJRgG0VkLWY14TffEpyqDnbjiXcikkDRaM/pcsD+Uckkn6H8PnWxRhULvnxhef8djep63t8L8KKBTcmXn02J1REn3dv4ky3u7df83k8vWAy22MkCtOyR1yFvvtvlk4chm7IgMZfcP65Qwzf5F49nTM4bDgeO33wn54tzzZ00opMIVoVksoCHF3PieEiiBefTisiH+DhjXTr2+gmzUqHDPp3DOyhVMa0rpt+syMfnCDPlwRtvspRdxqfP+Ov3xrx9GPHpz6aM52u+9+5bbFxFL5I8uqgJuprtqHNDz/7p+JUI7h64mhRYP8UYg/OSOG5orCQIPEoaIi0JA4VWop2tewBHFCrSSBJrCL0l1Yo4kAQ3VYOmNlhbgQyANvHoXQMiaKsUnUc4i68bfFOzXqyoZnOUlgjf6uGDXoqOA0xdtNWAXuNFhasWSCfb5GKUIqRE+lZVI4RHxilJ1KGcnOONocobFBKCgKTTJe2mmE2FM22AVl4ibwYRpRQyClvuvW6oqgZrHCiNUoIgaJOZzjukEigticKw1bBbh5QCKfWNysdSVgZnW25d8Md6+qqqMMYQhiEAdVVjjEXrgOVyhXUNW1tDwjCmsQ1lVbFcrFAqZDAYIaWiqWsWX/+cYHRCsJggk5DaNqSDHXy1xDmDVJrr8xUi9mzf22Zx2RDYFQ0h3pbYckkuK4yMSeOI7Y4lEzNMbckCkN2U3FVtEjTIuJ6vWSwX1PM13dCR9LdYVF1CtyTqb7MJ9rDSEfRiVi/OacbXHO0qbh2E7B7sc7d7xWGvpq5zzhaOld2i243Z7gUkgWPnIOBgsM2//PqSKIBsOOD1NzOeXle8KCU7/Yjffs/z8ddT3FYPeh0eP1pSXF0j6jW6J8gChRx10ComSI5Y51ds3T4hrc+4/doI4wSHHeiqNf/wwlHWhujuuwSDHqJc4ec5KpLEHgaxResYHURtPYBvaMwGZR3SCoQMUAiwBb6aIcKjtgjXVXgPUjpQIFcO11yy121QsiLWgnxTEPV6fHjmmdaC9048uwvLWMHl5Iz+/iFlP+WUkjt7t/BXa9bzCrKEte8RqZxhvOIH6ROeTIbU/oCzqeejrxe8NVqykQlRmlE2A2JX0UkctolZ1Iq7WcFqs2KUadZX1/hwn/0jyfjyMVfLgLfevs/1ZEAhPEWxRkUB8yJmdz3l3rbl4fWcKOhycNeReIXWnkE5ZffOgAcVPHt2ReANn/3Rz3j917uIeMhJr8cb+zWfXxY8Xy/Z3R7yzSPLyV2PNg5xOWWw08P1BvzBl0vWkxWH2YbGhJTlCBF4fGD46Krg7a19ridn3Nk/IE9irh9vUHnG8WjDSq7YChTTWlK6iJNByNpcsb+X8MWXExaTkkB6vvvDf4vZsuHLlwVvbi0Zac+//L1TDg9Svvu9O0ipKTeerz5f8uh8wq3tDheXq5uK4T8dvxLBHUDIEIRESI2xksp4olixLQVCBRSVBC0oG8ArvPdoHRCGHh1AoCCQnkg5otB/y7sbZ1nNN6SdGYQxQsUoFeCbDTYvcHWJqdvkp9YarQ32F6X0QFN6KtuQDnuE6QAV9vC2ArNu6RBMOzM1K6RQKKHwpsDSQJAggiEyjBBijVYCfI20AlcWID0oQVMbJK2dQFM3baAXAuMspqqpyxovJAiHMw1I2fLg3qGUJo5j1M0o3tQNdVXdlPYrmqZu5ZhKIkV7TNrEakNZtpWsYRiitcYYg7EG4xzeGeIsIg66aKWpyxrjDPmmYr2pEE7cFHp54ljSkQ2lA5v2sfkcqQPqWkJZ4ZoGlSjSnmpzBrMzOr2EZrHCLRui7g6+n5FXFbkRxLViPPOc3E3InSUSFSKKyH2NaF7y9Ooe12NFWRm63S5RYFnUFuFW7O7fYtMZEgYBlfcIKQkiCEcp/dcOmSWChb1ilDQoV+NcSlU36DBne9hls5Z479jqCoIo4vWDLv/kkwm/93nF/ZczvnM/Q24d8HSc82RteO+oy8MnL3jvaIvpesTpy0cU02tseJcgqGiqNa6eEOzfIt6ccf9wyfdv1WxsRVPHnDNAJTVvvZPw5U/GrPMeTVTScRWL6xn5fkZdlJTdGiET4ljghUULhxMCFaUthWfL1r4Aga8u8YN7IFqq0Tmw1iBETr2cI7Vga7hipw+mtOxGAZermv2sw8Mp6G7F7xwtaIoOnbOcSZIS9x5wPc15dP6SSIYE2S5xGnK7HxH5PeblS8S2YxvB6npDaHKeXESUP35Bd+87rIMu3aBh3VSIpaOnC754UvLuocSz5OS1XU4/PmXVTfm1ezlfTks++ulzbFNyZ/e3+HJt6UcwNxZ/LTm9uOS91/fp2Bn7h0O+eJLy2rCmkhU70Yaq2UfaJfPLS/Z6mhdXJZePHpEe/wYvlh1uv2V5PJthTEiaarJezLMXC0KpGe5EJLrkX3y0Zkc/5PvHkg+fDVjZPmsLH5zAZQFv3YoZJGO+c7/LRxcVV2clxXrJ92+vGK975HM4K5eM+jvoVLJ3y3F3pLh6NGG3eIqsNeHJBzy+cghnOO4ZPn3SI288v9ZNqaJdFitD0eRIEfPxuWSnk1IVJcevhehAUP8ZMfVXJrhbJI11OCeIgxCtFWkYEAWtF8dCBCwqh7EQBQKlGryL0EiyECJtCANFoETrDeFtm6TEU64LiuWMuB9jNq3PRVnmrMZT0iBESY3UCiUVURS16pQouKlAtSAFYdxHR9sQ9BCuBqFwYoPEtp44tJ4snqD1w/AW7y3C1wRJhMtilAyRWiC8bv1epMD+ohThxhel9ZDx1E2DdQZrLXEnBqWpixJrHUrqlqoxDd1OB6UUZWHI87yVeJoGrRPyvMA5h9YafOvr4f8E9RNFUWt5IESbxA5aiahUgq3dXZQUVJuCPC9uPDlgtazYbGq0FHRu1DuhEIxGCWu3oqpNW+EZbsNwm2U9R0nH3u4hy/WSHIO2MT63hGFG0tfUQdT693iL8RULG/HxVcDd/pi9UUalAlz8XlvgZRf0E80gbRg3irqYUriQrUwTxjuski10GFNrSEfbeFcjneTwzi4/uJfzw4M5d5MKu2r49PE1L65TSpHhwjnFyiCE4PGq4eo65c7RPrUVhDjubxkWC8UfflPy6+Kcdw+3ePKi4uXVgpODDv2+4HQTU06OuDIlppDUjaOTCcr1FdvxPtnJPY52r1jMxhg3IAoKBmaBaRS7cY/ZiWby2BDUho1UEGUYnXGQTLDrBbOJ56SvyQtDHFqUFsiwS61DVHmJNQYnHX7xNWr0HlZpnE8w9QatCygfEyAJ1QDhHdqXNzUVKxZTSe5C7m+HfPMkId+v2esqPqsjNsaT19+A22Irj0jjDVeux2E5JgwvKXyX40GH680dVqWm17EEBHij0e6cA33GU5ugbcP1WtK1S5w9YyedEbqMarJktL3Pi+YrdKDBTvnOO4d89NOGq69WhOYJSf9dXJOQSsc69czO4Xy24Y3DiCSu2e2liHhMPS5JaPj8iwtSnXG4GxHqnDfujzi9Mlj1iDA55s7RkDt3FS+e5tThLh0VE4YxtlmzyCd8c52TVJf88F24qGIMEcnI8WCQ08wEbOB3vqsRwZrz9YjL8ZJPPp/z1mFDgGKyCBgGsHOyxdUypBPUJJHEjEvinuD9gwO+eLjh6fqcN0+6ZNT81580bI8U33vDYqQkNiU//vmU0XYflQnKMGU2GROEQ7Zl1cqW/wz86gR370njkMmsoCwtOpDUTYCnDUTCFXiboBy8vh9y/84OD5/XrPOK91/fYl3kbDZ1S93cGBYFgSILFMpbVtMFdb3B1g0yCsh6I7Ksh3IGpdrDYJo20GmtkLr1lIEAryRCa7wQgELIGHQPgcT5EkGrOedGe+7sBtcUeFOBmyN1iE5vZtemNepqZ9g13qub4qgbczQhMMZSFSVhrOkNuwRJghMCHQcIc2MG5T1pGqOUIr+pGF2vNxjTEIUKjyOOI/SNMZW5kS1+Wxcg/tjAKwxDkiQBoNPpMBr9Md++XufUdYPWmrqyVJUhjlI6WYK6GSR83CEd9dm9dcJ87XjyBx/TjwuaWtI9uI9ZL9msLrh154CLmWG1nOM2a0pTs3P3AN/UVFaQ1yHGQOpzrpoR30z3CHhER2vqzXOa6DazleKTF5pNY/GmQiZdDu/eYr+b89FlRGfYp7GezskhzC+xV+ds397jrx1f8TceeCJpmMzXfPVoytUy4/xKMFl5fLDh7MWco35Fv9fl4cuKx9eOUkTsbMWsrqeoIGBdhvzsK9ieXfLgZJ/L1QX3DrbpDftczJc0d7ex5Yr1+QZTN1TzNZ2tfXqZI9tPuN3JOd6OeDGrOK273O7WzJZzKqs5utPlamlZW4WzGu0slQ05GgW8O1wyiKGpQ4STCEKMzZFBgoh2kdUp0hmENfjmDK5/Ars/QEcjmnyCpSZYrjBzTXQnoagN13OHdY6jvkUsZzxZ7rASjuFOwOc/M+weLfngpMen5w1X0xQjp/xPvmdQKfzd38/RJz3e3tN8/NiyvMpJdjKsVKTao4VC+IiZSQnyn/ObvVOeRbd4r9+nE3jKaUDgJMLX0CwYdEeISNLv1szLhHf2DW+/f0zUlIzLNaWWPB8r9kaa/f6SRy9qzi5rTo4Txuuorep2mvFixevbNUW5QHYyHrx9l0WxIvSCZNzncrZhyoLpOGUUK14AjY4Zrxp8IFheXHC9XNLRId9/5wFN0hBs9fhgJyDhJTse/ul1wF/+QUhpL/n8dJs/+HTCcuFJBjscjEom7PDB+w2bouRyKtGxIlSWr58siEZ9DvspH/30MbWp+f53Qn7wfsA//b2SewcNf+0twabcMJ/l/P7DnHITog8HPH8xYza2hINjXrttKKrT1tjtz8CvTHBPkoTbJ3t00hlpKAnjgKKwrFY1aS/l5CDmR5+METJg0NHs72rOrmrWGzB1wf7+gOWygFoihfxW8x6Hqk0gKlCyTzwICdKgVbA0BlevW/5aSpTRrbJDSmQg8aqlMVAKJw24DdLoP7aqlBrvBN4ZlIiQMgHhET5HConD4lyBRSKjqE142qatOq1qyrwkznqo1qYSYwweqOsKoSBMAsIkRAa/qDiN8JXDNRZrDB5PnuesVms265ZmCQJFnEQkSXwzOLUBXIpWReO8a/MaN4qcKIpI0rT1zzGGJElw3lIWJUXRyq2kUBhjAUenk1KVJUVeUDcGYyyNjnFRh0Vp2P/Ou0zGBnN+RbNuk8i93dvk6xnfPFmgB7uMDkYUBphPWNUhjTOIQGKtwCEInWR6avlR/S5h5x0WL5+wv2epq3t8+uWCf/aRpTIBUpe4IGW+qVmsNnS2OgTaEGxtUU8n3GmeEvYts4szLnuOD2VOaFcsG8FSv8611uzdbXgrlSzna2bXKyJZsbqeU7htikCxqhsu5ob7eyk7zuGV4+PPxzw6j3l8cU2/s827rsPAKyKt6SQN9w9SXtaO0+dTmlVDnYwIleC1+IqRzjkedlCRwCw8R33Hok5Q1qN1zPFty6Mva0wQ4LQj39Q8m8B390Ksq6mb5sZ9tIszNS7oovuv4zbPQaxxpkKjMeOfI3UXOicEZoU0NebFAqn2kHGXcmPJyxAThXwyV/ylNzy7pqYfDrjarBgMthCrx9ALef+1u/zBT8+5WCVc+YRfHxUc79VQhgQ7mvdTePJwxWx8SifbAtMljA3v7M+4d6KJoxP6h/f5jTgmkI6vzgyPmyk1BmUFmcrRNAwPFMdHG7rpFl8+W/HuYZ/Pn0fc3ov4g+sVSgzYOMn92HLdKVnXA87Hnmi3ZLGo6Q1Disbiygq3sQyOHYR97t0bsbiueHi6oQginr+YEYgVu4MeSlhW4yuSOIFiw2Q8J8Rz/3uvU+o179xaUgjLJ4821NbyIu9y/0RwZyfj9z7e4+PTiIsNJD1Fpizxbsqb21cc78JHjwKajqUoN0zrASL0+KXjpz/5lPtbju3tHTpbO/zkWciLZov3dw0/+XqODHMurjRn0y6duMPLFVyuUva3G4ZDy+mTR1SNw7v/MVSoenh0XnDrpOCdN7ZQkcHUDcuVo7YNVb4k7TiOtwNeThuuJjm9ccy6NpTOMi9r7u/0CANYXJdIQGkIAkEYQdwJSXcO0OkRILBuhm+mWFvjkAhTt/akQUAYB0gVgAjwwoPUIPSNrMyC34AQeEwrnzQlAosXIdBa0OI83ktQIUIZUCky6CGEwQdLVGNpqiXSN4RJgrWOcl1grUcrRRhqgliT9DJUELQz+qbBG4OzFttYmsZgGkdRtElR7xxxpMg6CXEaoW8sGbT6BQXEtwNIXVaAJ05ipFTfGqP94tE0hrKoaWqDs+Lb4qY4CYgTQZxovBecvrjCWs92R2CTbdJiTkdUZFt9Xnz4Mb5ZkXZ2yc8fIuOY9eVzIiOwXU283GCcY3E1Rg22kGGKXU8JbU1Rab55LHl8nTBptjHiAb3KUdaKhx+9ZD5fo4OArcSyjLr0O4rR8IiFSnFJxGy2ZOhmiJ7g8blit6t5MmnYFVfc3fZsbZ3w1fkhH77YQN1wEFtO9nt89x1BHAmuJyuqa4GRmn7oWVWSL76eEwYh0ck2R292WT2rWldQFfNHDxf8xfsKRMzOIMKvC667jijN8FVNs5xQbHocpyWhkGyqnN3+CSd7fQJfk8U155Mp/+hRDFVIOTU09Qrdz7BSc7aMGM/7lG5BadYcDFLOZoa9UYj0FSI7QA7fQJTneOcxviGwM5rTf4APRgjTYOoSsbLIvYhVk5JXa/odT24DPnk+4s5uyX/wvmOxnDCuPH943XB5scfs1PA3f/gS+77in/7+mCeP9vE+Y2NorW7rnL/w/gGm2ub50zHC1+yGz9jqS+7ecXTNimf5+7x82kN3EkoR8OzsktXzDns7M1arkoCQyoRkOwH7A4cs5ozrHmcLzeNFRDYMMMuC5OCQoBMRuDm9OMD4kIuzinePSsrdgMZFJMJg1wWdWhFHc55cHPLwXHOyM+Te9yQ//vE5wjacXVUMtwWDPhTLBZQTlM/pRpaDN16nIODt7QlBJ2Q+EwTliu2tLT6fGwZW83d/rDi7Ulwua3bckv6wzwd7K949tpz0O0yWCXd6KdIZniwtaafH48k1ssoZZrC/pdCdLi+vMr4aB+z3Gnx9zXV5j8VM8fJCUpqATRRQzAIy7dnfznnrZEEed3h0afjXNdH7lQjuHnix0Hzx9YLDgWH7UCO1oz/QdLrbXJ0XLJYbXr8z4v33enz+5YQPf3KJ05o4CmlKw9OHL8F7QoLW8ySURJEkSQVBJlHJCG78wYVVOK+JRrfB17jNFcKVIH0bBHGAQMoQLzXQVo+2ZsTmZqMb8A0SgRca7y34EoTHuwbnLVKHrUQy3EWIHh4HeoSIKwJ3zXrzjHy9xFmoSkOSpMRhhNSg4+CmqMliG0NTVG11qBNUed3KF4371jFSqtamuD/sf+sKKYXAWtP6yNtfWBSbbz3gBeLbgA6gbiSYZdlWtRprW2fK2lAUBdY2DIYZg0GH5bIgyzoEQcDuccyyl+EXK4L1mOO3b7N69ILlZ/+C8uwp4f7byKjP4Nab1OMz6lJhckMSKrQvqJczFIowSjFSU1YFnaRDVWk+/PEFKgnRgcf5GO0Uaawox8/Y/uABBCOUWLAKAxZreDd7QWQlrjviQmyh0yUD/Yx3Robvv5mSdQI+ebzgX3x4yXgd8GAnIaXg429CHj/tYc2CuujRiQwqqbi3n/LXfjAgKDP+4T9/zmePFN17J/Ruj7CzKUf9mu+9scX4/AKNIghTjk9OeD4ZE3QCNs2UQWeEi3bw4gWdXp+yWjBUAYGrifuvMTJP2cyfE/kulQ3xcYdyOUG7nGRLk7su//TskO86T1kH3N2ueXw6Z3/3CGyJFR4ZD9vT0lq81xivEM4gmuubnApsbILsHZIv56TBmgqL0qCrhofPMx7vTrk76nIwcKztJUV2wD/4BH7v8Zy/8V7AQdzjw5+f8tHnD+gFA1Z1w88+X9MfLnFyizAoCGTId+83HMhrzi4q1smI0/mUmeoQjkLcZsF6s2Z3S9Pphlysc2QQ4CLB8V6P/YMDvvzmmpOjmGfzgMLC2SqkocIbBQ4WhUXWFa/d1Tx8ESNMyOERXF3CIKyY5zmHWzsIv09IxrXv82gOadKw/9YhlbhkfbXgm8cLokiRJQ2vH2m+Po9baWq4RW+4QYQBdaO4uJyQhoKnl57LieNalqxkA3ZJr1rwF++XdE42vHerh3YNX556qrViY2ZI3acppzip6RoJ+ZR3TyJc2me86XExK3nwYM6v7+VczUbkV0uEWeDJOHeSLBd0Vc7hcMX3b635jfvwHz31fPrpEvtnidz5FQnuAFJpkk6Hso5YTg15XiKlJOtEbG9lCCWIU8to4JBv9PjqsWe6rgmkQ/qQ1bwmTTQq9ujAEUWaMBSEkUZgMeUpSs8Q6LZq1BqkinHe4kyJlgaPwrm2SYGQDcKrNt0pWste7yye1okRW+GtQQqJUCHeevAlDgu2vlmHxougncWLvH1NJHgfEHYVnT1Ls57hy5ooitrmGd6hhW7VMuXN7LBpaKq6lTVaQVNbrHV4QEpJt9cjShN0oIjjiObGZMxZizcOY9tRXqnWi17o1rrB/aKJCCCFpGka6rrG/eKs8R4p26YBcdIh66R0OgmTyYT1umj5eyEwQrO9l9L07lMuXlBFGfHeDnJ9n+lnlyhTIotTdP82Jh4hwxQ9SvEKFIJYwmZ2jvcrvPVtla8XRJ0etXQIKynXC+KuAyEoFmu6995gmu2zmq4IRyH9rUPk6mN+7XjFF1vHfDQPySbPeUs/YSF2Oc8lk/GYIndcFTvkIkYHknnTtB5DjaH2YGzAyitU1GWRe/xlhfVTfue72/zP/6dv8vTvXLSGcInEdlO+uVzSjxbsRQGr+Zg63eF4O0EPMpxsk+1GQKQdkYNMCzwx0q1AxDTVErxAy5Djkz6z6YDoyuLViGa+IgoEWlly3ePJtCBWC3Q4JwpnLDcZw26G8A7iHUx2gsq/QooGrGubYaAwjQCncCrGhoad3prVJmKxAFFXBNUEHUUI75mJmnwV8+vbSz45n/K9B28wLXf4f39t+N49yZv3BOtHT7h+vkAPb6G2NP/8Xy5IQ8/20QCvO3zBHr2dJxy5NYc7EdFK8eGZYWQvaJZn7G/f4Z07u7x8OmFqLHe7IaW3mHxAYyy5D0AFpKliOLB88mXO0X7DXrZmWqacTR2BXXP7MGcihkgidKOJmjlJN+RqYUh6Gc8vYxYXJclxl2E0xZYanwQ8eFNyJR2zxZJlkZAqx3kRsTbw+nHMzsE5/S1FWq55/rDk+tQwSlMuz2tsBUtbYb3FlGu+eyugSEM+uHfEwyvL5uqK641DUXC8q3j00hFECZ2exs0ueftNS9jd5psLRbLleEef8oODhI++ifjZ8w07+pKHtse1j8jMnP2+5AevC377zR524/k7//Abfvp1xs7BFlL92Y30fnWCu3S8nG2Q3yx5+25KrC1CweR6TllKoiQlDCKcE6ShZGcQoqRiUxq0bH1XQi0JdevaKGXbGcUbj8BiN+c4JVFC421buu/dGucE+WpFkoTIRCFkiMe13Zokv2jDhPc1uAYh2opQZytsVaOlbgO81HjjsLZEIZAywDmLVP12EHFLXDVum07IjCDdpjPap1ae3M5pSot3DcaDtBZXNpiqpqrrVsYmW326lhoR6m+TwFII0iwlThM8nmLTJvKsszjrUFLh3Y1uHnC+7Q6llLrh3lt1TlmWlGXVDhoevG9tVmUg6A/6DAZdtFIsFhuqGvLcUNQW4yyLheEwEpzmVeuxs54Sbncw0x3Cw/v0O7ApSuY/+8+R/duINCPIOqzmM9xqgRYlgfN0ByMW5wGVq3BRigwVAy04zFZUNiHtd1ktZmy9d0IedKijmNV6yf7tY9aXT/kb70w4bTK+mYI6+5o3Oy842VdsRY4Hu4adg7ZZCJOUwFaIomjltN2AOExwwjIMBE9fwHxi6e706W01fPFiycXZM37333/AX/+tI/7eRw2xn1MRs5Ej/osPz/jf/OVttgZrvIB+FnE89DwSHhlkWAydXsRmU9GUhihKEDIBb7HljLKuUbFmUFXEdkY26NM0oOMYLUIoLtg9KrlejLi7WfL8umR729FUU1wnBeuwLkTu/oC6nBJtrpHOoTwUTUKep4TC4nb2cJHi67M9xmNJFkpsbgmTCLFoQCp+uB3zo8oyd1uk8owXY82DgebX79/lVqfhv75MUIEj9SvKWc3jJ45bbwzZGqbMfEA8L9BBQKQCYh0xmzu26gve24bjgSI9KngeeDZBlzQSnM1qdDfl6rRkvQhI+oL3jkLmTlCtNfvdFZ8bT6JSellNfVFwuakIp3Nm5xt6ccx8KWjmnlSPSRKHdJI63aLIRxQ9w4FuOKkuePjylOz2b9EPDAd3t/nR15bLZ4/xteAyfIfuKOfBvZrjvYZydsU3D8c8eRHgswHjZUnS2aYyDh1r7HrFyYllZzdjEt9hvAj58JOf88Fhxnhm2O54FnmHTbFh/2SH2eSaO4dL7t0/4ecXktf2S5y8YrWq+Cc/zfj4iaSjPZ8Hx1yMG2Jq+lnJv/ediL/w1jZ1nfNPv1J8cXmbtKfBrm66yP3p+JUI7kJAN7BI6wmFQmDZ3k9IRxHODTh9tuT6bMZmkxOECSpIyWuPCgIyoehmgiRpiJMYFUcY66iNQUuHMy3VopwCHEiDQLZa9rqksR5UiI8G6M4dpIrxrgRfI0SIQwMV+BJBO5tHtA/vHM7WoBVSaBAKpRPwhtpWSOlBVGBn2CbHbZb4IsexwtcW0xjGlxfYoiYJY9Ctta7zFlM12MYggEC3bb6EECipWhtX0WrMweO8paoKAJw1rYmaELibg6tD3dJKN5JHJX9BM0FT1RhrKYsaY9smfE1taOqaKAzZPRiRZjHWGoyHunFMJmtms5zaexrjqEuFNzUHqmR7b4f45QvY3mPiD+ns97BPP0Fs1oCjOP+EYHiC6HbxVUM83KXMZ1TlGm8klU+gKpHlObv7J4TxNvd3JF9fhRSjA9773iF1UzFfOWobsjXMCPMzfuvuhGsX88nymNDlpHtdVLjFW7dXdLYkJthjauDqesGnz9oAYKOYPOrjjcDOxsT1FdeVwoXbLM+/Zjt9jZcOVNRlJTxPLmvevZ3yz79quDid00zHRCd3iaIuV7nkh3eO+OQnY2SRs9dPGW2VnBeOqi45n3jyvRDvllxf1QQHHdJIg0xYGUMYJuhmzlAKFClmsyHKuuTe4s+nhPs1YRzz40cZiRrx9oOQW8MN+WZNGg+QOERygN39LfKrnyHzFZG0+CRD9vro4T4bldDQ55NnEam6II1zfChwkWC4G/PNeMNrWcP3X7c8zYf07u4zfLzmw48dRbLFpCx5bg/o3OozPBwwvVjz3h1HrK5YNUccDCKW1zMYvyDaiwmSiFop+pmkY64pTMbLWnH2+COieMh+J6LvQlZihyYc0QSOR09zth405L5mvO6y3VPsRBM2PqXyMVV5QRCVrMuC8XVD+E5MPWvodA3HoWHxcopKY7zXxKlip5mAg+LyMZ3VBWp6SHFyzKNnUy6uC7SNCXcT+nuGk3jCZr7kxVQymV0S2BiDIvI1qVZ04zXLokPiPLs7ktu3d3g4Tdna2uPs6jG/c8czL2vCIEVg+PJ5q97bFDnNOuforfc5vdhwFKds1ufMNpK66fHxuSLylnEdcFWEZOQM/Iy/+IbhTgqXF1cUpWZjh9RNiZGwXpb4/zF4ywjgN96I2O2H7HQlw52QzkgjOh7tDSf3O6RhyPS6pigtjW3Y5IbaKJIwJAwc23sZvd19dLxFVdXk82uqzRwhLalMQEqca/lnJRVRELfdlZRDZhE6GyKjARCCC/B2DTJEiBicxLk1CI8UQSuFFB5CC03V8tuAQCKUwhmL9wKlezhjaOprtI4ATdMIivWa4nqJs4668WjVyhW99xhj0IFGB62WXd6Umltnv+XRBbK9K7ixPPa0vTqts23P1ht/miC4yTEIgRMthfOLvqxN01AUJaaxGGPbhiDWf+si6WzNaJiilSPfrJmM5zSNoyosxrT2wOJmlq/CgDgJsIHm4dM522VB4M84+eAO+bxgYhpWF5/A1tuEnTnL86/JBIh4AOmA/miH9fQKUa+wOsLYJe8fz9h66z6n9RZ/+PWY49sD7r3WJ04aXkxCLkpDMa04ylb823eviGLDP35+zP3diE9eOLweMt6seLxKidM7xCbj+uyCb8YjTi8XhJspG9FltjKsVUAn2yceJDRXG7QK2L77HuXVY37th/t8/HiGTbe4dF3Wk4Z33+hSbiqKUrJ6+YLg+Jgvvrjke/dfJ9YLZhvHsCsI+inhUlCXAZPzhuvjPpvyJZM8ohjnnGwLFuWQl9WQHdUwsRW1cRS1AAK62jLdVKzXNU+fVHzww4afXO7x05cR35SW/+3vzBHuisYqoqCPB+LhW7h4H1NsIKpIkoiIkPly2urdZciv312w06/4z0+HpFxyO2jIwohABPyDl/C7d2Jm62vs9YB//y9Jvvom5+9/+ZxZsctwoBmPr5CbnP0jxTu3He8/gFkZ8OI6xZwcUF1t+OqbU167lTK3MaECtoa8LhvSJKbow3o9xwUxSnnSqCGsK/JCsig7/N5D+O79gFIpZuWAbjBmVdRUZYlwJYe7gpdZl9XccVAVZPGKzDvsYo5brxjEXYo6Zthf0Ykg9GtcHjDcusOL1Rn/+B/NWIzXiHCXoNullhW39DWd+imxlcRhzJ29LYSMmBclldAEQrJZ1QxijS8bRJTycBLi6hpRTFGbl9x6Z4evP63pBg29CJ5dWIZ7IZPTKQf7W1zMGzKdkm82jNfgbMq6dISqy7Ra8HJaEEaWwUDwP/t+nx++H7OcLPjy4Rgb7rBYNxgfEXvN+bXgX1Og+t8tuAshngIrwALGe/99IcQI+E+AO8BT4H/hvZ/92SuC99+B0VAhtcQ2Deu5R200YNGBopOFSCTWK8J+xLEPKJeW1aqiO1D0doeEvS6IhDiKiWOoZg5hG4SWqCBC+Nav3DmPt7QJCSkII4HwBt8sECIDb1sKw9mbhssZUpZYZ/FC3fRabtvdeSlRqnWbdLbBlEXr0BgnCKVQLkTqBG9LPCWNN1gDrm7XFciW12/ZH4kK2gYZ31IpqpW5tFRRO4TgPepm5g2/aMHn0VrfeK3bb/l15zzG2LaZtnRtkZQQbWLVeZwDYyx13bQKGdMQxZLhaESWKry3RGFAHGuKfIWQml6/g2eDLSukbGfzF1OJV4oNQzqLU8z0DD3YYjiMcDsB1W/+NvOvv4SyT1jWOCkgSnDCs15MaRaXDDqG0UnGxaMzdKR5Wu5TNQ1/9bdvcSua8/n4lIUIaayicTHbu4J/+62EgRVULuHoYIt1afDxLtHsKQO9YqPusptkvHh4zj/+WcH0PGdzdYG1Dj04prPlibcOCSTMw0Pc9go3XdDtBYjhm/z060se7Hn+4OdPeXg3JtSC0dYWdw5jrsMR4sWUel3x9XTJH/7kKSdDwaOx5snEYIKUdDtELwtsWfPR14LvHSbUKF6cT9nkMd1hQTfs8WRseF4OuVyXWOvpH+9STCaYwhB2d5hv5vRETrefksZ9vpkK/ui54i+95vFiiRUKmiXOG8KkR9w/QYi2DqHcjDHyCYPtIyazDQeDip+9yPgvPjnkcPeUf+c3DI2qKU1MWUf8Pz5RHCeOH48Vf6XT4e49y//+tmDaTCh0wWwiePpsQbnO2du+S7dRlKom2ynYU0ec+ZCrWUW2mvGdBylRIPn50nC66nC9qqkLgdY5l9dToiyla1Yc7Xd4vtgninNmRYfrdUQn9Pimi905xF1MQISsa8MDKrr3Bzxf5KSdiLi+YnORc356TVEJ9k4OMZ0tkqKiGXTI6hle5jiR0PEO7VPCzgBLjziJuNNdkyjDa68dsZ+EPLpeI2SHJp/QUTlGRgRO0vcVQdrBpJLSS+qiJjQ5xdlDfJLxh6eKVanpy5rKRdy7E7CZGcJU4wLJbLlGZynLwlA2MeNVRWNjTmcbyuWCXtilN5DcvxPT68z47BvLYmExJuXyeo2evmCrs81VnhJ3EqT85Vv+/mXv/fhPPP9bwD/x3v+fhRB/6+b5/+lftxIVeZJhSLWuyHPB6Ysca8I2MRpvODruMDpOkFGK07YVq/QUh7oDQUaQReAqhFjfcOJLgvBGKeJdGxy1xvkbOWHdtGb3UtzMyOdoZ/Cqg9Aj0F2kb0vRhRCguijhwRqE9Phq0w4IeFxd422NrSusqZFK4q3CmxxkjBBx+7nSt23sEo8XmrJukAJ0qNBxiI4UQdxy67h2dqxk221HmBvjMtdSJ94Bzt1Ujjpah/d2gGiTwoJW9QNS2tbPG4lpLI1tZZR1bamqurUdaFrz/0BLju8cMNxLcMJha1hPloRaM+wPMI1kuWz7xkZaooRkfjllPst541iwSDqsi116Yc31V49I79zircOGTrdivPNrSNuwOX3ExcML6nqKSkO6+0P6OzN2b21z/lzBo6+5fv6E/Xcdab/L+HLJFxcLZmbAcL/D3smAnqt48yDh5XhDf9RH+nMuzi85j19nb1AQ+Yq4f8KtW7c5/fJL/tE/eczZhSHwNdXaEA72iCJFxzasF3NGWxohPfG2QsRbbBYNW9mKSWmZLmt6Pcnj52v+yluedREyGmlEqTl5MOR5o7m+TvjRT57zve9sE/e2EXmKMQ7dzXClx3e7TG3BV2tPP7hgEJfMxYiiiRnpiihJ2CwTstTQm3iKUBKdHFOWl1SbHJMOKJqao37JphDc2k/56lLxnYOMfiyoHaTKQ30N1HgVgUppXIXUhigccXm9YLlZE8cJ//Dru6ztSzqhpZuGJCLim7Gh8h1+/FziRJdRU/PPVpLv3L1DGcR0ecZWWPBrb0RcH8KXjwR/7/cueHCwy4PXLTvDiGazwNdz9o467O6ErAtDpBrei6/5r5+s+WI2JNKCB1sQ+5DxxnPoBel0zJYYUachWks21pCaNasmptMbMj9fY6qG+3d7XD75mMNbtxjVY4RTaGB28ZLnLyc8eGub5HCfxghqEmgEDTVRUpNfL0g7O4yyhmsXMvAb3jye8e7+gjQWZMkWNZJEhNTWMMhSLlVJbAUHBwPEpmQjFdaWvFzX1LknDRxVCYUaMXs8Y9QNsKUmDi33TzRPijnZsE+RGepVw8VijjMZ5+M1jYOzizOiICZJPL1E8cEtxXfftWxHHS4mJZICV3i8HJEknvH0HCEGlNXmfxDO/W8Cf+nm7/878M/4Nwju45cSKotrQi6vK15OA84Xjiyy3NmGJCnZyTpkSYTAka+XRCogiBVGOOp6hdZBW7XlRatBF22hkZYRCI0TTUuXO4EKNDoIELL16pCBR8gSKzRKhTg6bSszv8L6Gu9rBB7vaoRZYIs5TWGRSmIteOPINxuCQJP1s9axDwuuxNkc3+RI6zDO4loHELRqlTlBJInTgCCJ0KFs5WzGgfU0Tf0tt6akxEtwzmO9beuopGgLsm7ULsbUONtaDAjZNrRWWmKatnCpMQ2bzYaqNNS1w3t7Q9dAEAq8d8yvrwniLTq7A5yt6fY6+NAyvppTlQU4RxIpJCFaSboHGSEN1Upwe69mcZLwTnzFZ50tPv/sEaudHT54K+WN4S7XVcb4ZI+jHzqq9YaLR2f0drfQyT5jkbJj1ryINKvxBW/OP8JWA9ZVxvD2LWQe4rM+qxLePIq4l8wYZDVNGfLZ9S6PmhPSKCRfrbB6wBv3DlmeveDv/L1HXF2sSbWhKEpk5zbRzm0GW5rlxRV17qmEYzAMcJ0DDvYUL7IO641iO8v5/NMX7L33GlfnF/j39hiGhjjU2JUkE2FrBuc6nD+p+NnXG77z3S5bmcBahYwE3nqE0ngdccEDrqpd7kYVZdRHFJIs7fPxQjLLHcoo8jBBBJo4C7G9kPzUYLXjJ08Ub70BM5PSDRy3DzsIW7MoHTudDetNSVNL+llNEBiwExCO1fwF8/kpOt1lazjk9x9u0bge7x6c8wc/j/h6PSBp4MF+xY9frMkvNWsfI4eOoXd8OZ2g4jcQnd/ErSf8p19d8Ou9FQ9u99jatUwWa+Q6wu+E0Ex5a18xXjnG8wlP7TH+KuL+XoMcxvQVRGoBacLBKOV8ds2zK00SrpmPx7i4Tzc2bNcNl3qIdwVEASrIKJdLjvYDvvz6Cab3fQb9gPVswmw5w8xO2Q4VSaoIbEnkS5Cavs/ZDqaUdsm16TK78nw+TSgLz9a+Yb87Y6QbUhGjpWO5mKOSiNVFzcZoXq4lcSjZGI9yEdKUOLWmL1pX1uNdybgOOF8GNGVDwYzb232apmB3Z4cwikiCjK9fXgOK06sGqxImyxohYXf3hNKuaDY1XSx78VN6DNjMIEk1tw53GT/bcPZCcNXZgmpAfVGSBWuE/OUWMXngvxJtHez/1Xv/t4E97/05gPf+XAix+696oxDid4HfvfmbR2eC6cZRN03rhOgFGySzZU2aJsQThYol+XpOtp0ShimuNphKICJBGIQIESJEhBcBDonSGvDcGOMiUSBrJIZWSOhwFqyt8UVNEHVQnQQhQqAGs0L4FVJovGjVMlJaXJPTbDbky5okTUAGNGWJNxYRtW3odJC1vvAenFuAq3GmBuFRSuC0IwxkG3xDhY4VQaQREpwzWGfwxt0YiTm00gglcb6tSAqCAGsM1luU0t+O4m3xbNuGT2v9rY+M954iL9hsyhsap3WuFN6B8zcdrDR1Y1CBZL3OiToRrmqguRlcFASBxBhL4Nt+g1JCg2N7v8/DZxtKWfKXvhci6gfEs1P6bsn0WlJ/5zajrZieDzjyK0w147o/4v0Hb2CCDh+9aMhnOZG1yMBxPp2TlI+QOz/gtbsJR9sZHz5zfLWoSYOY3WDFTpDzYq15fBby5WzAsvEU5ZwsCvmN796jmL7gH/zDL3j2zTkq7rEcXzE8eo/+/h6v7xZIZ6gOLDIquZj1WX59iqoz1N0ttnuCLxYJ/cEWKp0wmaXEnQ7fnMN+d82oG3NrR3B9mbM9jLEm4tmTiLOzBduHNd+5P8LbGr+YE0pLLUFIzemTK5KjAzbrGkVC5Bq++LxguYmwywmZX2IngjdHnokIuZpMUN7hTcV4kvBkPqKuYr56dM52qJC3M5pNSSWGIA156dDak4kxVb1itSooHejObS7MMZ9/UfHkKmGUBvzoYcpsAy+v2pzTbLZi2IV+VGLXOS8WGZvCMKo03+19SFzv0tkKGIsuT6fHLMWYrXjE997M2aw965lh2A+oZwGD7DtYWbBpSnxVceU6ZFHB7a0V+4mhMYrJrAHp+KMvL/j175ywd7/L6axHqT0v5o/pjyyD/QwfweZkxDJfcvq0pDSep19+ycnxPmWzoBi/5CiEo9t3iLRBe0Mcb8CG6PIltv6MF4uAL5aHvCxSTDrgMN0QJRvuZY5UWFRP46mRquHFmefFWY2TEVMHRxqafEknlqiuwCwbpFiRdPrcfq1LfVrAZEy0mlNPHpPtvcucCFdH1MuGabFhOi04HzucG+BsifCaNNQEUUUWD4kOdgnKl3zzNCfWJW8fHCPijEVl+XRuqOqAyFtEOMN3Erqd/i89uP+W9/7sJoD/IyHEl/+mb7wZCP42gFLK/+xJzmioccKx21V0E0U/FkxryeMrz/NJzeilYX8rYLTjyKKQUECWVfS3FZ0InC1bHXqwjQyHCBeCN3ifAzWSGKTGmRxJhTMOZxzeNJTFmqVZ0tn1xD0FNIhminNrpErxCJxr0NEIVI8yH7OarciXBZ1+78Z7XbeKnUDfUOOmrWoFvJCIQBJphaHVjzvv265SkUQFIFQrSwSH9+bGqlXgrMM0Nf7GR17dcOsqCHBa46ylrluVjFYKQWuOpqTAmHawNHWDtRYpuDFJaykVvKItxBVIDf1hn97RNkEUIuqCxjvsDR1kbYN1NVJ6Qi1QQqGUYHa5oK5riuWS50XE89dvcXewwmTbbJ0YDneOKFcrnj7M0W5JL5yzXlq8bxhkBdfVmv3RPo2LCVcdsjTiIvf85KNz/oP3PcNhwhebEV/MF2zFjlGnYblp+LIMyBvPl1OY1yl7qmA7qzl+cEJ/M+Pv/8ElX3z8stXqB5DtnbB1e5+t7Riz1WExF/z1B3PePDT8Zz+SXHWPgYLrSUMxCggygU8ybj+4w9NrQ9iP+eKTp2zu7jIZ5+hQM54J3tiRJKGjmwXM1vDwVNKL1mgVoBtBZS14hW0ML2YJXdmQ7g5Q1hLnhvV0xWgrZh2EFGYL3Q04vVgSbweoKMI6x3IjeG1nga13uLxq6HVjonrKutzncGgZFyXD7iE74WOUNDgDi8qzNinLtWc23eWTM8XhMOXUbHE93+LZoo+TIcFyznhpmI0OmQc5g2GHTXONLSXn65BxLnBql3s6Y35lyAsIkpC3Qng4rtgbBlxcPqXu7xE6Q2UyvIyZqQSncrJBiYw85cbhrCHtavphyc9Oc6Ikxq0Lfv75hDv3djjqSWaFR+aXbI0c+8MDCrlN3Q1YqC7TaknS61BcPOdsXuFPDPvlhMHBLmE3IelqvGgQZkoA1E3N2BxihgN6lWJ7EDHykmFY872BodPpIVRJVRsaFG7tGc8rSilZVzOMaRhpiGSI0gkqdPjI0ekpOnIFjeb0sqYbW3YPPMuJYDxbIoc9zi7POX9eMp5MKVF4E5BGDTujGKUEtRngSktdnJH0EoYHu+xs30K6Kc/mY3bMjCSFSfEaC1+Rq5Kj4QCrNOOra/51Jar/nYK79/7s5veVEOLvAr8OXAohDm5m7QfA1b/JuiwhpZUI4VjVEMeSrU5bjbgqPYtNw/Op42zhyM4rlKpRCA5GAe+8EXIvsUBFvZkjwg1RNkDIGKHUDTVSI3TSWgsEUevx0tTUZYVtDPmmYb2pWK2e0OleEoa2bQwSOWQYIFWIDEOQ+0id0dndQfiKqnCslwu0lGTdLioLETrEuQYwCKEQIkQGCkECeGQokXXR8vfO42kDnb1p3OFsc/NolTTCKxrTJne9t3hX/4nGHgrnTNutCt8qgKQH2+CwNMbc5BcE0nsCzbcdrWwkqU1rmhBHGhFIko4iCjxCOrwQRHGEoWG9XqOUJMtirOWmoMq1Xjba8uyiodFdNtfP+PSTjFsfrPn+/nM+0q9TG0AFfPZoTbd+wa8dTun19ol0wemLnOfFNsuiQPVH9BNHHCbUiyXnp2OenVd8vKj55vwZt5MFd/ZOOJ+uyf4/1P1ZjC5bep6JPWutmCP+Mec9T2c+VXVYLBbJttSkpKYkSILVaFiGDcHuCwHtC8O+dLevDBhoQIAB+8aAgYYtyG5b7pbdTWhqNTXQYpGsYs3DqTPuee+cM/855liDL+I/RdkQSVnqNqgAEjt35J/xx97I/NaK73vf500d+96Kz848FnXKnUnLpHrK/aEjXFzyG99v+eSTBUZb4p0jzPKYmw8ecfe2ots9oNAeDw/nqECzQPDz7wdsWk3uP+DH33/Cwr/PIFEQRIQ7CYfdGk/5LPINgpssi44sSTm5nHF3d8YgnbA71gSNZFkbPnmW07QR0UBRV/2g3dLiRQFWxZSzDWHsUVSC8kRTbkrCUchkP2GzkOQVXL68hCjGhRFS95r8n8ueslw8YHdkePRmxGJ5xaaMCNyGF4uUR7s3CTYf4rwhQu4QBDW+mxM0p7w1SWnUPpBRVAHOj1lrx6ezjkwtKHMJu1MeHVyRth16FbNoFgQbwfGnkvKtHd4cCE6urrgaZOyGEdNhzPGJQImM459+xtEbb+FJD0uHWS/R+TFiZEhuH7I/FNi6I5Y+81WBEiWysowGPot5y8WNFm0XlCdLDrNrgovn7Ezvc9HewPA+bn/AzkXH5J2bvM7mXD2+onqy5sa0oJ2+DUWJn04x2hKkBl8qBlHCJL7BqjSsVx5F6aNEyS1vhcqvsC4kGI4htERacaYNadriBYp4viGUC6b+gLrzwQhCuU9uSo5u7qGEoSoMWerYj1pGwuKZIecXr3j36BHLyzkut4zjEWedRCBZG8WkWOJ1LdXmDJHtEZqAUXPKTTHjZnqTrpMYMeWqLHHXa87Oz3FVTeosOpVMRzHjMEX+4R6mf/XiLoRIAemc22w//7PA/xr4u8C/D/z17Z9/51/mekHoMc4CIt/Dk44okP0OMRKMhgHxxrEoHE3rI4BBmtBZzaJxnJ52hLIkSR2uFRibM5hYgkiCBxKBkBKcxXSqb0V0hq5qMV1Hp/vBYtdp6tqxWTUIDEkMw6FPmjX4SYBU+wjnEM6gQkU6CRlMBVWpMY0kzkZ4ftRLIrch3kJ44If9wNP9/mBTehLaCq1bhO2Q1uK0wLJ1YPmqT3+ytle/eA6k6Vkw/hcsGI2j75nLwEcb3Yd9WNuHdKtefeQCH7dVxcgtdkD5Pl7g02mNbTqktKhIIaKAzXxFHIb9/5uQVGXZc9/DEOd68mXX6S1PXnH3zojBWDOXQ4Qe8eqzE/5OOeQvvyfYS9eciXtU8xWTuKJTN/jcHnLPzCnmhu+/Arvj8+jGmDwcYi8t66oEYWk2JW7+ks1ckMkhX37jJp8tHJ2VmKsLwoOWs+KAg3DDr6Y/JjiK0TTM1wWv6n1E9YIw8enqnLHX4e+MeB7scSQdR1FO3Vh+MB/wyAt4ddHw3u2I1bzk9sGIxeWCaP8GaRpTrQ37gyVXzuJFg16h4CmaMKX1K4o8ZzoaMMx8ojZgdl2wcSl1tSEd7xKkMW3b4DDYomD1qiNMA0ysMJUmEjnjQcaDe0PatmSVhCyaECUlxXKBSANkKzi5XvB2YXj78IqPT4Z89trxpTuGp8dz6rbj47OGt+7v8fW77zGqT/j42YbZlWGyo1DhHh9eZDy72OOq83FeQJT5eEAwPkR1hrgWFJsN/t6MIIt4x5shjxSvL30Wl2vmr8+YPUq4lxk+vqz4QTPifjDj/Xd32Ynu8uLpp6xOnrPz4CGZb7g1PkFfvcIbHDFyM3aCmNKGnJ+c0NZrUjRpEPDSGvK6o3o9QyrHpHtBI9bouGaYf8gyDUlcwMBzrNMRl+cp7z+4w2oKs8UrQhzWKfbvj2mKvovod9B6hoWAPJfUnU94ELGz9kkCAfoW2a2AcP05xoaM45hloXFScniYcVUqRLNi6ufsZD6nswZfB8zLGfmiYB70kZu26T06w0STtA6zN6QSNbcOYm7flJzNYmYvLWdLjRd7jMKc27c8mvmEwdlL6uo5w7u7vH3jNlf5nNfnp9xII3aGikVu+KxIsTphOJ3ypb0Lbu0mfF448lmO+MO7Mv9aO/cD4Ne3CFkP+FvOuf9aCPFd4G8LIf4a8Ar4K/8yF7PG0hl6nrqnWNV9m8E4jec5lKdIY4GUkEYh2rUIKVG+x6J2cFoyiAWe69sFdd2QJo4oFkhPEcYhUlU0dde3KOqOpihwAjptaLs+gcg5Qdfa/hdr09BWNU0Fk8MdkukNHClCesjoNlZ7WLMiGnZ9ayPog7txAscXsXx9OEfPnNH0qn6FkgIbDgiSEFPOcbbt6V4CpAqJohDjLLYuEHI7YBW2b8nIvv3SVh1a97F6yvORfoAQYLWha1qc7eWTfhL2Zq6mQQqJs4YglgRJQGAUutoiF5IAb7iDFTPyiwuk67EQRVEhlY/vBUjpbTHCDq17CWa1OOXuoGIYST6+AFEKXnyc873BETu3U7QfU0WOvTSg2WiOmbLq7lApgR3n7BykpJkjKs+YRCu+YzSeUDjdsCPPeSkOcd4hP3yyZLo/YH5xxmFc8/HyDnnR4uanMDgmSGKUi+nsmLffyHjZ7cLJhhcv1+y+/w726C73DjzeO9zw3U8lSQd6MuKirBBO8LsfNty6MeB6XRO5kOWyIUkTGm/E3miFvSohm6BlhB9J4ixkshsRZprdnZT6SUuQZdiTGdObu5w8O6GtYwajjPr1FSZIcGWJiIe0dUtbamQwRE4OCDLF7KJitjYsVAtth/I0yhjigyFdYWlNxE+ON/zZn+9YrDZ849mQb79O+blRSZYGGFnyrachZ/Uh7++2/MMfN8zmPgcTQ8OYp8VNGhETioqWOa4rUaKhOjvBP9jh/qMhF1rxYXGT2hkGXclUeoTBAM/bkDQ1y5MdLuUlR2rC2cpjsLfDbOaIb3mMHz7k4qcvWa6ecPutPW7etBRyxEo+ZHfTsWrWdKsSs1xgtGGSxFgZ41xFFkHSOWRgkaTMuph2HnAvveJkmHASKNK6RneKmzvv8PnK4I1rhsE+0aYmGPSZAFb1vycOjapaOmmhqxi6ltbbwXOKlpRSKl7N7/DAa5iqGozDyhrnDVkrh058kmxA7FJM6HNzxzHvBKor2U0c84s1TnSEyQHjyDEIQ6AjlR035A7nyw2P7u/hr3Lu3Sswp5qL4A7vTefcGQwY7WYsb7xBWDfEWY63k6LMmLMfPuH5q2PmoUdFymblc3M4ZZllXEifIL9AVDN2Ascf0XL/Vy/uzrlnwFf+BednwJ/5//V6SRz20qB5A0hUT8Htk4NkRxB6BL5H6AuaTlPVDgnEscLRZ5wa55AYAtmB76E8hbUSpRzOaJSyaN1htEFJQTZOaNsa22gCIRFfyA5hS2DsAyyiSOBFU1R0ACIAJxH+lGA4wugLXH2K7VYYV+O06oFh9KoeYwpoW6ztEML0Sh4nEEoigylSZYhIIWyNE5Ye0Sx6B6xrUb6HFAatemCZlPSaemfxo14Pr7VGNxope4288iQIH2sMQkm80OvfV/W9996p6zCmRbct1nRIIXCVRsQJ6c6YUAlWJxesVyuU9EA6Ot0i0OimN25Z22vl83bMZ89r7gwXvPvWLo+/f87iZMXnP93lRncTMV3SpgGrLiATJQPVIdMUL9KkTc04yZC+4F5wxcuzE7qu6xk6QvB8bvDeu4daSB7cCHlxOkNtWuzBDT55WiLLEuNtmIxTbu0LstERN1pLcrnmyW8vEXKP3Vs+aneXYab5SnjB+XqPpsy5e2PAedMQbxY82g954TRxItjZzRBdxEJJ1oucNBEkoxR1lhMnEU1jsX5IHIccHmUc7YakyYggLZkmKcPX19zYibn8aY2sNojDCUkWIoxgvSwYDi0uG6Fci2kNTSN4fS0wXYfxPRLnse8uWXcN9miCCCK8uMJ1E2zj862nOWncm3rOL+HvvZ6iQovxB2waS8EKzxsxfag4eqQpVpryDEzTMhgHKNkyf11QXCw4mCa8eejz4nrDh2WOnwzwohGt8ijbitaPiSPNYJgQCA/ME56uDshViedP+fHLjumgRs0arDdk5537XJ9uoIv47KTi4kIRZZcw8NnJWqTdMIhSPAtxJNGBQBNyczcgmkheLDYMvRW+2aBVQBmOaZslywba2CACj1nTcmfnJlV7ysmq4HY6RQwlpWlxrgPnGGpDaWu0sUijGZs1pjbQ+jRBixR7rPOYT+UDDidzDoozcuNz0YQM1Ia9ROJGDf6mT+ScBBmNCVEbjfU6hHP4TqCLDZVnSEZjgmGAu6jxPFjP5zx3LUkWsqMUXXZJu8i5xLEbLsi6GU0nef75CVkm2Dm84r0v3+H+X3ibs5+MefKNb3M1n6OzA+7uGhI5I/T2wdbcSAXnVzl/lIvpj4VDFSAOgUDSVYJO25+lGwll8TyB7yyhMcRRHy9Fpwl8j3XdUWqL1Qo78BgkCl9BawWb0uB5Gl856qbGk44wVCRJiPIFIjB4GmIylBdhOo1pa6Sz6Kalaz2iWKE8ix8nYCsQTe9aRYHKELLDdUukaRAyQvqDrQvUYEzdt0iwONfgXI8vcA6E81CqAdEiVABKIjAIY8C24PreudMaS4sQfXEXQmBMS900JHHcM3AwONH34621CK8vxlIJkGClAQt+5IFyGA3KVzirkRhkIDFdi6lrzKoiSEd4cUQ0yujaFk8FeH4IyqdrWsp1TlNvC7zRpNN9Nk3CLNf8yXszxHsjlmdPePFKUY7uMY4jkrrlIDxl5DfEASzqBavcoOafUicPcf4dvvWdx7z69lOKBoyARjtOFh47WvLgVkbbrqjOT5BRwOcvF9i8YXeiCC6uOJNH/NLhiMgJjBLc8pa8eX/IDz8ssE4j/YD7kcYzHWcLzde+vMdlIUhXK4aZx43dhBv7Hv/s8w23jzJUmdJUirZpmPiK6TiF0QC/qljOV3zlzdsM4wA5ifFiRa0dv/b1A8rKML/aJfAMbbWiXEHCGxRlr4/2BgFSbED7NJWhLSuUEpjUwxRr7GgC3oqT6zOuLzfsvO3hhZa9m0NmL6/BD3l5PcIfDWjaBYGo+6eybIT1xvhOs9p4fLZK8HVDebZktlTo9Qoh17Q6pZE38KcNYnSIyF8wvT3gooCVi6maBTQrdJgSeiknL1f4qc8wHZIkHofSshYOrXY5f9USj0NePLskUTBSATv7U+zNjKZZcbVqWZaCHXuBjH0SmZF5kqaSWxPbANIR77274bytaYvXvD0SPIjOWa8Ne3srJnsHvHJ3uZvUjEOf4qJls/L4SAy57S3IL5esD4fsb0ps1D/VBtZinCaxLb6IcMqx0T6ZXaKEpNOKqyCh9kcIYhomXKcJqi2R1sfIEaHXIOSagQfWFqhBxp4fc5ZfU64aEj/i7sPbPH0yJxpFuNCnNiWt6HBdhzKSUAuC1tEGlmka84YoaFSCUBGWjszLePudG6zzOdXJOR+3C0Y3JRwdcTRxLCqPTNXcF6es4h2s6ghczem6YJHX/+0OVP8bPazFGYPvgb91aHbG9UYaFEZbtAVta4apT5ZI0ggQW4qgUmhrkcJDSI+6NjRWE4bgSY0SFuUMYQSODj/u9e9Btovvx4DE6RKrFZgGq8FaD2tblB+hoghrlzhrECLrWyAyBIJ+UCsMFocVHeiulyMKixAKKSOkTLC26YmROKTyt2Hd9Va/6LYfGuvqHuXrNNgabNvPCRxY1wEC36fHDguBlBZDz6Dp5Z1t39sXAutAovooQSERSqKNBGnxhMC0PfZAehLPy3DS4OolnVZI55EOMpT08bwQJxRKCEzTAj3CwOG4cRTQjCZcXod8crbiaJLzK3/pa/zWP/6ck2//Jl36F0nSCHVmGXge+7dq3t93rNSa58/nFHyNcp5zfXnN1eWc1iksDonDF5r9iY9xio+eXBMnGfdvDtkLSz7ZRPjzzxjfVoySgLZ0KL1EhmOErvshdLshjIaI0MdWHUU0xKs7tFPEoiLYm5BrzYsy5Gs3PWhfsCgTlleLvph4EZ4BP4gwfsQwsqzXHb4E5zoGw4iq67DCcPtgyk+fLwmShLxoKYs1svZRsuP2nuV4laBNh/YSjHQQWzLPp7Y+xhr270xR4zFLE1B6Ae2L77D45Ji9uzdYWMvtB1MeXyToxYImrxAqpBU+dw4a/CzizkFDZ0uePm548nRKqjzkukJfHGOKi968J3y6QYJ1Ei+SiGVHqKBTAUvrY7odYr0hMC1NooiF5fzZU9I7DzheGg4eTbg9kbCzz9VmybozFBxxcl6RHQoW5RJtFVcbQ9f0w3ujW7rFgicXc46GHTuDAW20w2U3glXBw0cDxPNLdGx4aBYMuOKBJ4jv7KLNEUOToLuS1TLgbCZJYwluzGfzmhTFIBxQ1y1eACoQ/VN7Zwkq8BIfaRqcL8ArGBQhbVeQB3tkQUW7BeqFRmOdR+RD2pR4CZi6wAQ1vlXUTU00lIxvJwi/n+ONEkUrDUc7B9QWZLWm7VpoDJ5RDALLzk5I0xZkgylp5aOwmCDh5fNzXGaYThLeevgW2nQsXjxm9vT3OPqFfxt5f8DNKOG9N3YhS+lWHbRL0BU3lcXJP4L3yx+j4h4EDhHS79RFH3dnrKJDUraaVjucsTjl0XUWKQyJL4inPnVjiENLGkqwHdoKFOBJhTG2b6NIxyCNGY59skmKjAdIP+vVNK7FmQprKrD9Dtl5Ail8PJkh5AShJoBFyABJ0sPD0NvvMVszaAeYbRh1z3gBgfD8rXtUbOu43bpMK6ytQHpbVY3Xr8Y9Ybj/2F6rp9eAcwopFMK5Pv1cyF7euEUlWGOQdFtEgui/JgUCs0X4ip8xZ4zuMKJFqH52IYMUYVraboUwBl95qCii6wxN12KdBGMZDDLC0KcoCqQQxNU5v/S1R3zDlrwujijzOT/3huLdX/nv8N3/6/+Ry3/wNxl/+c9RhDuIzYw3gpDxTsAbuwEX3YYiX3JlQtxqjdc1KKnwfQt1R1G0vDjJOUprojgmSId87VHEYvGSFx/N8Y7nfPDBkGH1hM7sMRoOoFiiXEAjMlS4YufOLjZIMbbF+DHxrs9yUWNXCzaN496jI4qiIvMlv/TOkH/8gzkmHhHMzsnlCOSUZL4hczVjWSJvj0gjqJYzcj3lKO3VRy9nLct1AQaOr5oe8lQVWAcr3f8c66amePKS7PAmydGYkBLZdBgUmYTb44bns5xF4kjeOuTq6ZzNvCZoOvLAkE0yrq8s4XxNHacQx5wzwtaK+XHNwd6UebtCLzcUUYY2EwgddW76orTukOEl+1PH0luyaAU/XU/p9AUH+pJpprChJfXGzHXJLPAZTfd4tmwwYUz7dM2fe+jYGcEiFbyeazxXIaOGmdsja9dcrQ2xb7lqFQehh4wiHt5TdFrhmhVtPGDuH3AxbznYmbK+Lig2jq/csKhWkcgRwu1xkfvM5Rs8XUy46HzyeMpB0hDHBmdzdocN8mifyd6QstYMBhFSOwKh6TxJIQR+1yBCD9EFZF0IGajNNUnp49yKenoTgpBSF0gt8GWLkArdthjTUHuaQEJd50SuZDBUzC4jNrXi47OKKIo4flpyrTLeORziiWuy6YjWbvClpiEAarp8TrQTIlqHcBXJuONkbtjoPsoxwZKNE+riNaff/qdk3YY7t+5RuBarU6Z7Gaw1uttAa4hD9UfW1D82xd1KQ+JbBrEkUCCcw1hBYyxNKGkNSOnTto7OaBIhCBXEgcMlfUCHEg6JxPP6oaECpIU49IkCj3SgiNMIFUQIL8TZBtt1OIrefepaHB1ym76E8/rWizcFMf4ZqwOrsd0aK/qdtTA9s8U6jXABygsQeCBtL3HsVljbbEOgewetEH1/X0HfO5PBlhVj+nBtHMJWvYzTORBh//7KBxH0bSvX9eYlJxHSYm2Ho0MIvSVCKqSQsA3r3uqG+p6HcAjbIl2NIECquFfbdIa2bBEdgANnt3wai3OyRwgrifIEgaeQQhCYJbveBYejA/w44PxY8juPI+7sWX7lz/88L370KfPHv4mZ3uPBrYibyS4n8wOS6IiLjSDaTUndgOsi7+9JhCShoq3BNZJ7+yGj0Q6VnfEnHoTspDnf+sjy5PMKvRjx1v2c7K5H1z7n8rLi2cUNXrRvkScpIl5TuhRvoZmvC8LEJ50I6lWDrkqOBhGPXxS8tyd5db1EBR63py2vtGSdbxCjMcvK8twG6E6xagxNXRCUIfiC6+s52UjhRUOkDbk19Di1LdWyJIwkWRKhnOC6VNCVBHFGoGpu7PlsnGOdKwZBh+hKrk/WzGcRESVqecEqh8OjiMv5miAd8Py0ZWwXDGJHm2vk4oIuuIfwArzMpypDXr6s0Q246pqD8DUnry8p1msGw4Ddhw85q0JivcCcLFlczWgqQ7XsGAnYu5mQ7cekqmFVbxjrgOasRaVjgqDjZBHwahPyj57n/KX9JX/+T0o+Od0lcBF100DeMBkIOllzNWswaoqTLUI5hpml9QPC4A0+ee6xKSAVNd5wis47RgPJ/kTidRFVHlNHA4p6lxebiMpadjPN/eAUpaEoYw4OW+4FSy66DOGg7Ry+ciTEhF5DtbrGtWviru0ZUl2DM4IkiMjFNXH9FNFl+HpN++AR0go81SCNh1G9/0NqixESG0g8LJiculJs1palDsiN4/bugItZy08vL7CF404GnVIc7GQMTEm1eokVNdILSOo+27mu50TlEyadD819duN98FO6ZU5gYDCYQHxAFgxQtqOjRioIvYaNyVBiQSgq/oh56h+j4q4lkRR4wiCdI/L7wWaGwjjQTmAxFA10umMS+3imAdsnJXUt4Ct8LyCQ9INFBYFQ+MrgKY3AYLVmdXGMJw3KdyhfIuIxhCOECJHOIgm2+RwKKxROOIQwfWvEmH5IajY41w9/hZMgFALVa9FNg3MVgt7Oj63BNf3u3G0pMM5ujU4OrAC7DePegsEArOt32wILroF+uUJIibVf7O37nFbpNNayff0WSaC8nn1jLXZrZlJK/kwvb60Gq/sZrzH4ngQpCIMIFfo0tcG0/b0EQR86IoTonbHWYnS/uJwWh3x6vce9HUlxKfjg/UNezCxnec3h7j3+9P/oEXUx56pKiZKILpCoScCzOua81ByQEEjXx7Z5CqUtwikUilEcsD/yWLct7x1FHEYVf/+7M771nVe0C8vIzDl93XHy6AAxuEOw+Zy2CymXOUIklDLDVwPGnsNajYgyiqLBw+DT0JmYq7Xkh0XNVV5yYz9mcuuIzz8rEF7I4TSjjGNePS+5NfRIheTuXkY+3xAeDknjBt9ZNuuKIFU0RlLUjtivuXN7n3ZwSCst4cBDJjuU1zOsNpSbHFKvT8jqNCLw6PwxbWcwOuDW/g7SlXRSMEhAOwnpkOXGMlY1je64fzfg3A9pZwVR0RHgWF9usLpCCEPdNiS+IxpFmMGY3J/iNR3LkxxvdIA3vcPy+ac0m9dYf4xqa+oS2mTMcNBRN5Zf+AA+feJIfMNIXDK3U7z5mh9/R3Nwa8CmXWBqGAZjhvGC9w8dnweC1VwxnXaorsOziqva4jWC/+qTY945HLJYHDOe3KI4X/HV2zDdG7Gj1myUR7FuiLuQs0XGIBvh6ZbxwEdUlh9sYu5nNUFxic5PKDtF7hxCGjarmjBTGNGB0Phev9MVtYCwQUUKWoOLQeqSxK6RVUu8HhAfTDF1QqkU3XpJYxuEi0g8SxsP8JY5jW5xfsTtuxlJm6HNkKsu5/33DnlVX/B8rpmkIWajuXczI9RX6Lwgki2BN8KVNdIPsV1B0Fwzqn3c3V8gu7FPVyzYXCzodINJSwLPQ+qc1guwVhPalk5IXJzjnAJVwb8pAdltXRPhI+l13cJJfNnjeQPfx1OCWnfEEqIwYJxGCGuonaNq662yJuiLlwVfbVsXtsM4g3QGXUOlO7qmxsgWLzYEaUAgJkg/6YfPusDpBucatOeBDfBsjbXrPhsVAc4gbI41FVKFIDMQvY3f6KaHdtmObY5TL3Ok6YsjPmDQuullk0CvfwxQXopQCfRJrCinsEYhXItzetvS6bDaIIQCfBAaa/ocVaUsQji6DqK4vye7ZdAoT2K3unhrttJHa8DRt42kxel1P1Tt+cBITyKlh9V97CCu19e3XUtX1z33xjlezxO8546ff7vjF2+tmXcDqs7n2cLjeXeDNhgRxZL9VLKqHaWQxJ5C5TPacsly0TIcxPhxglQekXN4nqUVljBSNOuCJPCQnuO3frLkw8/mPP3udxHRLQ4eJvzwMuZNd4+9akmtJ4h0xOpMsDpdEYQBjIcMoxxv47GoWkQY4/uKRbFCBRFp7HE2k/hBjBd5hB6oZoOVkkUDbW3pCsONt8d064Z41yM0PnU8Igk1eVfT1i2IK+ZdjLaWR2/tsbgOuQ4OKBtB48WYLGEYBwyqayZZxMvSEY7GuK7Ck4ai0RAFNC7jaTVnqta4YIgnBbUfI/xtayOWeLsjroUkuzGkmLW0VzliqshVSSw9YmO4rjNu3IhRpuNcTpHKwwmP4d23KesO03ggJJkS3B6/wsYHzPIC1V0xVhFVs8MbtzzCtwXf/VSylvBX3q24fVjRWvjeRxapoZjnqKFBByG1LXngVVzGHl3rKGXE4WBN4OV8+0lJKCKOF8dcnsOyvcMt/5LjYAczitmPzzhdlnStYZYnnOUtwi6oq5Bn18dMdx1fuyHp6kuyoEa2FZdNwOaqI5GwKASHX7Io3yJyA6bGCkfkabQXYlVAXTfESYb1Aggr0sbg5RuIJCebAZU/wmGJRAthRmsUmecjMgXOEFqPhRYsuognJw3C83nxw99Djo7QtWHTRHiDgK4Co3K8qOmDYWyAlhWCCbar0LohDTW+6shnC1y+Rl49A22xnWKcKVon0F1HIDt8LWicI9QOrQyBJ//N2bn7vmaQCMqyQQiDbQXWUwilUb4j8kNiXxFYg7ENAZLxdEijNVXbYW0P1go8gRSOMJB4vtzmgxp8KZDO0lYtKgLtB/zej14yHMf8/NcmRO0ah6CrzqHdIHHYMMH3RrTVEmRPaZQyQ8gYIXozD9ZgXY51XR+iYQ1ShAjl45zG2F4+KJzujUdug5RqW5wVONcnPkmwQiJVhJB97126DoHEWdUraIQEzPaJwUOIfjf++tWc/9Pf+Af8O3/6S/zyL90nL2q8QCHp21MACK+HpJlt/J41WNPhjCWIxqhwQLeu6NZNjzkIfHzPx4p+SNu1Xb94mV4hAxap+lva9ec82O2YDBV52fHOzjUP0ojuukLvjNmUkk1b4hUVdrBPI0MKJxl6Emcck/oaOb21ZZm3KCGYTHawbY51kjDb5br2+a3vnSKbEnn1lLaCnf0Jn74uGLxznycvFmz8mqP9KefNkN97LdlcnLGzP2Qnrnn3tuPksSEMQ8ogY11tSIZTTjaSLOyYJg6b57TTIYtKEnuOAg/tJxSVI536CKFJpzvs7/g9NpmM5WKF5wJc4tGKFle0JKHABSnspoRkOByxK6GZ4cuQcq05zktEOqQzDZvZDM81xLYk3JlglEdtNYvK9L4G3ycIJNnIMMs9ikahIsiORqzzvJ8vJQIvTUnjhlBF+IFj11mazZq6WBCFAjvLMV1CmvWbn6IpiBKPwSBhLiRT3ZDqPq3sapkjlMdnz1vePbD8hfcj/uGPIn54Ynjj9pg3xoK8Cfhnv10QDIeQBMjW8fGlzy8/jPi3BiWfnl5hkbyVZJzkMTdHI37y7JS9YcSHP/qI/T3NG794n1dnDe/eiJlVl1SzCi+KKYtTMuM48msuzxd8/XbAWzcPWAEyqogzwfKyIRApIsu42OTci0Os30dRhqMdhrsjUC3k53R57xJWnkAkjrgBKwQmcLSBx0W1w5nbJ+4WfSxilDLKljQbjdYecZKhtUa6JVZmlPoWpT/g/NUr/vH/4df5ub/8V/nghs+rk5zBe0c0ecXOyGIDH7p+MxiHI6wuafQFVgjk7a8yzAKKgaSt1lib09SS0aTtW8Nao0RLZyxlLfFsR6MsrdNUS4lz/+2yZf4bO3ypOZstiD3J3ijAmg7P9/pEId1Rlw7fD4hCSacb2rYkz/vEIR/6waJUhJ7E9yW+L/A8ief7aAOubZAWnp0viBJFNEj5G3/rNwkTyf/m0V/lQMm+/VEvcF2FEwq6GuMtsNbgnENFU4Ro+6Gr9JDOYvQGY6o+d1SpPm5PDZCq7+lv/aAIEYLSP8PxCtG/FrZzV2RPsuxykP52Ve4Tl4RSOD/qd++2RbI1RDmLs5oPf/wp3/idnzIYhLz5zk3+yT/+Af/uX/wFsrTv04PESd3zcZxBOrst7hoZBgiffi5gmv7pxQC259k73Zui2OIGjNY4q/uvbR8L3zwseX/vMXV1m3l9l8VJxaPdkl/9uYzT2Yx1KPjJE49P5nD74IJbuyENKbu85sN6TlK+RKsbSCnojMUJxSzX/f9cOuCzq4rv//SS2een3LuhqBcB+3feJi82mMFNyoslJzjyW4c0p2u+9/GcTdmrgyLf527UMPAVd+8NeN1aFtbDNY6jLKVdt/iZxBch558suXnos7leM/AVnbGsrwtu3Uy5dzNjdV5wviyQOsQbDPHT3h2Mn7EqDe265fVHxwxHGaevVtx8/wbrSwh1zrR4zr6aUREyuBdQVw2zIuDz6iYORyAMReXQ1yuC1KOzAj9KyLyWeRtiXMU4aJh1KSKb0hUN67OSVkm6eYNXabg6p+4cSMs6GJAPElwt2Zz3PJ9J2HFxrpEHb+DJirvZK56GPrXpkBvLwY0NKnZY1+HCiLPKUHYh3/v4iq/fv+bN/ZTPXmT8vd8856/8+SE7gwmT22OUhkpbUqEwxYaTi5q37kx5cHPKs8cLHi8iZFzz8YtTbu9OOLmY8eKjV4y/nmGjXX75bcXeaMH1yYq8dBwmkihJuO+9YuBd8bWfDyD9Ep+fQSMN+4MAUUQ4s+BIXVJcWR5Egj9x+8sYPeA6z2GzRA09rluBLuHejsX6Q1zXENYeKohwWEybczV7xtpKjKgRcchgPCQLNNJNiQY1S9+SeJq9aAPCIG3Cyewpr64e8K2/91MuXgna5TXjX36Dj39wwcPOIy9XuIkiUAI/UGTWYj3J60WJcjPkICQWioHncJsZxdnn6LwhVCGT4S6VEDjZ4vsGbR2dK3FCo6oKZyxhFm2x3n/w8ceiuAsBjw4GdFojsNzYz4hin/W6pe16yZ21jq5t+jxT2zPJc61/BtESQoFo6dqWJN4ONDEEUUSSxJSrCttonp0uiNKE57/zPep8A1b1NvdxbyJq6hrbtL3CREr8ANy2fWK7HNOWvd3f8wGB1gW2a3DOYTUIP8L3EpztMcGgkDIE1xMakcH2X+2AXhUkXIfrapACJ4rewPQz429PgeyTpEwvf7S9Ealv+vRyzySW/PCHHxPFksUazi8rHt33kGzTl4QDZ7bv6RDCEoQeKvTB1Limoy1KMAJPhT8jSTpn+u+zhi1RAU9JJD6d7Ymbn1U3uGPu8jBbkOxZPjs/4NOTY8JQMI4CpmbFB3emtMEBo9QwlEUfmWg1bWW4PnlNev8rOKMReHTGUeaG1DrWneHFDy84/sETRHnNq+4+ohlRn3zCZnGJ/2hMnXuchBOEW/PN8w1FOKBaXhNHMZ0K0ManNUPeehf8zYCrY4+yzFhKyAYbLq4LGIy4WmpWs5L1qsUdTSlaTdtoiHP27/h8drJi0TiWteXBmwkHnmaYhcwXDa9eLlm+yrk4N4zWBfsHIdW6onx2SZMm5CbjcHLFlw+vsdrw0t7gMJRM7BWfrTJcNMBbpn07ygpkZ9msWx7s90Puq2VHdZ4zsbus6hTqhs3ZilqXJMMpwdEuxjWkaohrGzzXIV3HaASNH7A5fsbSLPCnb+EFHl+6VTFtK45fCcJA0eZrLjrLr74pSBnycqbJtaG0ATO9wyeFz4OdGWWtaaqbfPhZReIVUAo67aPxeN1uePv2kgd7EUnYEMQBe0cDXsgr0vCA01ePqVufb/7d71OsO84XJZOh4b1wTmvWdKEkSULWRUTu+RxOIAxjHl8HuMU1Nwc+g2TK00XDy40m2Gy4f9gyDeck/gHLCq7Pj7F1hZ/AfBNxfGoxyYiBD69XJZ712BsUxB6IYIp2AW2zIRVzBmMP6d+grRSlbSjXgp1RSpcHfHNV8c40YlfNeCEyJknOodJMJlNeJ0N++t0fI9yQ5fqS+VcewM2Kzhl2PR8TeDjT/+wE1WvCgYCVZjfWNDLn+sULmtkJy1Jx4yij9S2hABVGdFVLbXs8sBUa6TtCGWHa/N+MDFUcbJYLkqRvd5ydLxgNs/7RxBqEtcRB2Cs27FbTbgxGb409Wx65VJK2bcF1CBn3easKwsTHD0Zcnc74xnd+yma1IV8eU5eaL7/7BpMsANtghSNJEqyM2Kw3GN3iUtUz1nFY1/x+S8UGSC/CDzzwuv4+6GFb1lkQpte6w7Zfvi2UW7ZLr520/U5+m8Xax/MtAdfnnKron0tbcv1u/4tkJqdxrscVvPfefW7c2GE5X/ON3/qYRdVx8zDl3u0P8JRGovr0KeFw24APtnesO41tAS3wnUIGIc7JfghLrz5C9ElQ1vRehC+GgLptsdbitOUHV0dE0nJvdMn7u5KjBxFPn17w7eubSE9wMGy5O3UgUp5eGkJPYsIbhJHg+vkFw/fX1HlHLgA0utPIyEMs11zXZ3jCkt24g59EzF5eUqw3uLbGri9IbnxA0xmePy/RxYKDfUsjPA72fG5PHaOBYFlXKOGTBr0iy5aOmRH4QUjdFuzEPlZ5vDgvuH9nlxedxB8P0NryyZMlO4N9/sSfvM+3n87QJmJZOsZZimw0x88XrBcd61IzmUbcuJnw8F7A/Owl2f4G/9YDbk2nTIOUKq+xxZzdfcPTywFOJHzl1oaLaMpT6VAIxqKhWOS00xFObBjFBaVNyIuQkXdO0UUozye7OaCWR6gwQiWS5qpB6469YZ8dvDmdc7ZqKLWHzfaJb36No33FJK15+1ZFd94HvQgEIkyp6phaeOAUy+4K7XVM2g2Hb97g+Vqyp8Y8PGz50XPDRaW4fHKJH4DY3Ud2EaUMOXEtD82Cu+EAYRT3j3aIM8Vvfl5xfir40Xe+RXEyYzKV+CEsTMBVkzKrNhzuPSKMU/6L3zqh9BveuZcQq9u44pTJOOdKTnh6OSPL7jNf5bx34zarUcOmesClg8WrJSGSdLSL1j7HjSGXOYe7GW6aEtSvKGqHyu7zulxwcWoYx5K6zbl6/JrB6Iq7b7ZEyZSzsxY/HfHRsyvujQ07g4TvrT1SKxkw5zrdZRqtOLoPP/0dxeZ1x3fkR4xupRzP1pg9i0l9oklD4xpU2yBXM7KhR9v6DHyJG4W8ODmny4+pOlBJTLJ/G2E8vCxCaHCyRTWOWtWEqsXzHNdlxLKbb7Hlf/Dxx6K4O2DdGqRv8PrEOqp2hicknpL4nr/tcX/BXpEESmKd2zKNBcbqLSvdw1hL0wB0KD/Bi0FKy6rRnFwtWM5WREohgoCf++pXCH2BMzUqCBBSUbUtXQvGCESpwfUtH4RAKtmTG10HToG0WPS2aPeadCHoZZBGb3952l4g4wxC2H4oK+hbLtu4Pi9IcE5juw6j65/p2pX6fXWNED5KBDghMLbfjVvrCIKAbLDL0xcztDPUwKvjJVVdk8UGKyTOslX9gJAOKXrFjdUNtArdSJxTdG57X8oiVY8ulqJX7Bjd0nUdbdPS1pq2rtFaw/KanbCj9g+oURRtwWq15itvTQhPLvjowvLm2PB8k1KoiF3VEmQptp2QxFNevDrDfvczymKF9DyM65c+zxeMVMl45OMPbpKpHL+bs5KSMDuiakuySBCoFaIzzM8fE6cTrlaO0f6AygXESUAch5RtRVOHdHmFJwMmiWXthYRaYfIMGYT4Wcp6PWdnN+LF8wY7iIl8QeUJfvufPSZfXLF/74jdachPziryVtOtcjCGd44kn6wtjXYkfoeVHo2N2L2peefolEdHGWs94ZU/gigiTXO+9kHMb/wk4nwWMVENhzsxm8LSqpioy8kLyYsqZehy3nsr5nK5y9mrCCc0jQgJpaJrGmwQ0GpHJ0CVG/JOUVlBWdXYZEy6d4AX+wRKc2/4il/7uQu+el/wu9+4R9H8hM0iJwrBdh6niwmBnTPrJJvOEZiWh/GK4ipktnGMu5osjElTw4M3btOsGl5dX6I9n4GT/ORTuGEdB+Epd+/cRvoFcl7yne+tubrcwGxFNIAwMLz7wYTN/Jyr/YccZm/y4vKCf/Rhw0lxi2VreF0JfulOwnt3dll3kk+eXHEQJRy3FbWMeLLO+MnnOfu7IwInuHeww86Ox9Ona07OLwjDFKsF5x9dcvs2WLGPdYIfXQ9ZVQlPZx23Ys07d+6xK6+xVyd85zufg8wY7WWMB4dczwJ+/PSCL98e8ZW3b/Hdqzm3h4qRes1v6BGuyfCHb9CsXxMgKO2QF89r/HdbpGyRviA0La0oyQ5jbOVzvfHZ2fM4XS8pzq8YjUOuryz+7X06kRJvg+oTXzGIRxT2ikhb0sTn+KLibKkJVI78N6G4AyhhEBiU8PgiIa6jD8NujabTGk+qnxVZ6OFZfuChpMSajraptgEVAik1UvqUBXiewfMdT5+9YL5esWoMrtNkWcR3fvSSX/75hwzGDl8GSKGQA58sjnsEr7WYpsMYh9UCJ/1eOIJACQsWnPOwziBkX4yF9RDSx0mv19K7nhkjhNf3vU2vYnHYbYqSQiABH2SIVRUgcSKi1f0CAf42qVb8jC3jhEQb+I3f/DYfPb5iYyLM1u1qHCjZL4oIkK4P9rAuwIkACT0AzFZo4TDWbrXsDqV60WUPbrOYLYjMdh2u09i2xTZ9rKCzlhc/eQ7Jjzh9831e1BN2djLO13OeL5aMfEO8u8uHZcyq8mlxnLodoqZgebLgZBMhqprh7Me0UiNt70j2PZ8wDvntH52R7H/O7TsHzJqQxG4wVUGz+IS9/X2MzonXT5DRiHU0xiVHkA7I64bc+Xy6TgkOA27sCYIgYi+1pDJCW81hZlhtNN6dCRcbgZpOyT9/wWcnBcuzinYecfP+HnffSJiPfV6uHP7jkqdig5hMOLwdMtclDx4MCYxmct2R3T5A2YrPn15Trg27twPCZIdVN+BiJRn68NbDIz45WdCi+NPvK37jp4LzVysOJwvGw12enhnayiPQmlpmlKWl/WTB1z+wFMshp3qM9mLmLfjdnHq1YnhrD+/okOZqhvEgUA4Z36KrO3CSw2DJ126f8KfeecFbt0OEvEO+OUY6g6q7Hs6nNJezGbads5Yhrq05bRTxbEMyMDSdIHceQdJR1j57w5bDcUpjZpzNOw72Mk5mGtOFzBaa0XhGsjug1CWnFyWmaPCHHs1Vh8syTl6WfPBoiO8qvn/c8vjikHmaslx/xK2kJNUN3382xzYNX35jxM2DAZtCM2wVL1Yp58ry4NaY58/W4O9zsa4YnTnOX10TBYrj2Tl700N+7vZtLs43dHHBrvR5PfMobcUH05iPLz0++ajlXpryc29/hcHqmnKl2J9GLFca6cEv3L/NbL3hm59f8cvvRtTKo5kJws2aDz9e0QmBixJWZceu2CPqaqBknEZoW+BsTaI6OrPHsU1hoMGbU15X7B0GdHWOP0gInEbVK+LJDbxYofyW+fkVqW1oRUC12VC2jsp0LE/nfUzoH3L8sSjuAgix+MIi0fTdi75Iua3N3TQ93ErK/hdfKUUv7LZY1eeO+lIQeB7GapqyQuLoJJS0hJHicG+H8TCjaEqMg6YzfPN7nyGlIEq3gdRS9euh7Q1LwmkUBqXkdhfNNsJO9vjcrUZciA6pBNZ6OCsRMtzycQxOGIzVWGMR28i8PhKv60O3O4uz/YKlLTg0xkDV6e28AYz5oge+1a3b/glAa7i+LtiUDfTamp6FvxMhlca4frFzCoRIUP4YGYzAFQjTIDuDl9r+31MBeD/ruRtj6LoG3Wpsp9Fd1+/Ubd+DN7rrMcoi4uxlw6o8I88V8/El796BMzngtPLJ7ZggcfzC+Cm6go/yG1x2At8V7GaGVzrn8uwldatRFjoh8KTEWEfrAiJ/n5fHOeNJSNs0uPlTdndDxntjTo/P6Pwd0hv7pLHCF5ZCeXTLkjiGwgYYJNNhisbhJSFZJ7nUsCtLRCCRKqCTEavhmFWteXneQpSha4tbrpjeimiHiru3JjRWsl635J5htrjCLHNmlxsObg5Rw4DUL3j5ekV9Mecrt5Y8nIzZH2TsTg44efWSl5cXkMfcejjltz9r+dqjIf/OB45vu4rPHs/J9hckwYSzC58uX2A80MKn1Pv4ny7YvRfh+2NmuUNqQ5CHLK9L1NUFXjqiKzZI0TLczZimp1xV4GUJf/HdZ/zqo8fsjn384A02hSYbZEinUZlikGrSqKVZLhCeQ4aKzlp0qzm7jPCnYAvNgJbJdMxlXpHFPnHb8M7bU9J5hWlygqJm0zg+vjDcfBiSrjTnlw6VHBKNLilPl4SBxnaSV082/G7csHl1zdK/zXefnSFEQ3FVsTY5N8cbCm35eLbhxWdTytLDBCkDNcemETJv+M8fL8gXBft3DuniFCEUtw8zPvn4GeHimu7wNZ5OKTdLrp7VOKcpZcZkbDhxDS8XEW3p8YOrjk/vBsQ3bvDi9ZKq00xdyfmzEpPN8aMdNnbE/22aIIMxpR5RLxfo6wahSlAaVzTYoOHoUYCNKiBEeg5ZwyU7PF9OCY1l6BVQKZI4xXceQZTiLwtSURNHe8y1IdBXVGsJxRLPC3lyXHJ3d4OoE4J8yXQQIP9NGKgCDOOA0N/uFI3bclQcdstIcTikUijpcK7pWxSyr+9f7DbDwMPzBLZxOG1oyhKhW9A+tlOYxkLnaKoWYyxBoCid5P/17RcIqRFsHZjCbZ2egBUIK0CIPsPU9X10IcXW1fr77RaJQTm3JQiIPsNVKayTPwu3xva5q+KLgaWw2E733BfRM+yFBCEDNGC07Xf8rte+49z2wUX0SaxOggvwQsdmsehToGRAVUsQfSZr74sKEX6KlRJhSkwzA132+GIRIsMATwqsUWAE1lq01nRtg2k7bGfQTZ/mZLpeSqlkv9CZtsYYTWsDliczyuOco6Lmq1/a4SLYYb6ucTLmd/MjYldzWWgaEzAsNtjVDFvXrCVESqGkxUPSmJbNpsWJhE2h2cksTb7k2o6YvPkuk6MbnD97Rnz7fTo/5fTFCQd371I5H1lYrC9IpinIkE3lECridLnBT4eEwlEULcFug9ExUrfczCT1HszGU7rZnPTWA1xxzesnHbry6cIJSRwzDSreOfTpvID1xZrT53M83fE7Lyv8QUoxr0AEfOVhwDvpNXf2xiipuDz+jO8+3rCzu89vfP8V90+XmOEdvvOk4OtvjvjK+7usWoWt56SjgHgR05QGXVd4oU8ySLmuDsgvPLw4J3IOvd6Qzys0sKkFvquY3BqTJJI9OWN3fYGf+Lz7YMYv3DsjDFcI/0u0GhqhmG9KPGcZJQplGry8pliWHByGvLSaatPQdhpHQyAlUeRBGnC66VAuxHWGdV1wma/xs4I3Qo/Xl4brxjBIJbp1kLQEgw03hj7HIqDNCwLl4UlBvqj40Y8bnn5S0zaXFJXhcLjisgxQ0U0uFxMoX/JxOKXbeIQ2Z7xrmA4Krq7mXL6sQNdMfU2tl6zTMVVhyef7nH3nI4IRnKw7fufjQ+q8QzcdYtPi78XceOhYVjHzkwvapkW6jIurESo9JhAJ+0O42ORcHs8w2S7joz1G9pqr6wLEnDbIEDLFDxyutLg4RnUWvdmQXw4ZaofnCzqd0MiIlbjP/aMI1b7k+nSDWTe0QUIY+HhJyuGRhwwVV1XNiydX7B+Mefxyya88EHzvWYkXDZk1krpt+4zfp6OftW7/oOOPTXGXsiXwQ6zrOw9SehjnaLsWY3tolnTgK4GQDiFajDVoo1BSbTeT21xQAZ4nEcL1r9EOWzlevJqT15YyL7DOUeY52XCM8iJwfr8LdV8AvOTPtOxfmI20o+/7y37I2LdGHEL2ffF+6Gp6bszWPNR/3rdGrAAr/N5YZr5YIATWE5ht+6xPTBI47dDOYbQFup/t2p3rXa/bCNN+GCYEVbnu2yddR9cazq9yyqolivoFQsohUoY4W2C6Eto1mAZjPKQAIRTObrGzjcNZ+nmB7nC6oa0bdNcvTlb37+yp/slFWmg2C8b3au7cOOTiAn58NqAoTvi5N59wUIx4fT6lHtxnVTUwSlFGcLkMeLFJsFbgNy1WOIwQBEpghMDpDqlaQleyqQJsvWHvxgEmOOL46QVl4RMd7FAfP8WvXuDf2GXp9hGiJRzsYLWPJywXuceLuWJ1rnn7XUHXtbRlR86A1XxBbiMeZXB/zzB/6xaXP/mUIA6phaRcFlyZjrc+8CjLhNW1z6cfXxPKc5aFwHR9MlUTJERlSeAuuTU23HA5ZZfyzbMp558t+Atvb0hvjjhuMvzDN/nJxYrdxYJoOuRbSO7shNy9pfj0Q4HzauKRR1Um+B2kCrzI4pkF5WzI4ZHhygXknaPVlnh/QjAegvTYvT3m3qTil/1P2XGampqd9JRR3CLCQ642NUHos2494jhFOUNiCqZjD48xSimGSUi6yrncaJTrkGGA380ZyZKbuxFjk3DVhhSnc0Q2JAsmuEbxebliypxhu2JiQ0ZezOOnGw6TQ6ryEil6F7ReL5mRkw738XZ2uGotxfmS4e0h8TBDFIayvMYfJLTs05UdMg1J0jF1s+b5sqWeBTTNNWHm0LHH+M0JQZXyenNMdW5oI8nuzVvsDsaItsaoXdp6jZeF+OOMRb2i6HI6k/RPQIlHmNYYGZEmJR2Woi7wRxHpNCNSzynDkFRMUSZHsGGGwxcNQhdIp1BhhNzk5KFP6youliVeqcmiPfxgzFkOF5cTwg78tkTogp3JHaqyJBnvcjZf8/mVwHaax8cz9o4inl11vF4nvD8Jma1TlNT8o++1DAYjrPjD+TJ/ZHEXQvwN4C8Bl86597fnpsB/DtwDXgD/fefcYvu1/yXw1/ryxf/cOfcbf3Rpd/ieIfD6MIvG9hmixgmk3AKynMFag+la/EBt+84SSYAzGpAgVV9sML2lWwicFWjlE4URlXUs8xxjWobDrC/eHiCaL3hdW1UKW2epwwrdB1Nbt8X3Ojzl9RpZY4D+qWH73dtBpcHavs1jTK9O+WKB2O73f187rzyMMSilUMqj+2IXLyWd1tvr96+xtu/RG23o9NY0JcAas9X2S9qmoS0L5suCqra0dYmwDhGN+rYMIL0YYzVGl+ja4SsDUtN1lrps6CqDcAJPeVit6eoaq7ufDbQdZotE2ILS8NnbO+DOVHLvrkcYJ8wbeHwy4PWrEhvWrNprdnZr9lPNfNOwXjma4zNsuUI6h226XnIahgw8j9J+AUbrMJszhkeHDHZGnFzNaUVEeHSLtNC4ckVTLBjsv8Eqd/iJo/ESOgTZQDJKHY1xNLrAVCs2Mw9d+QS24yevJDuBT50LklgRWMu9t+5w/tlrvPwaYUuq1StEl7I4U0QPd6m1pmg1l9cFnQs42vXwPUHBmkF4wVcPVjzc36VLv8y3Tg2eHuCVa55cRFx89JyNuOT+UUIU+YSd5tVZy6x2DFOJ6CAZpIiLOYM0YBn7aOvwU01VOA4OM5rC49kKhCfI1xYV+ASp4v5tj1t39xioJQ/la94ZaoZJQlnOadqUMPFZVHuczT12RgXj8SFGQxbCXrjGVRKjHZM0ITcNkyzmieuodIe/aTkIK/7kWx6xPWetY+bnPp31mAxDzpcLwOeNzHA0abh/W+PbnM9e7FHnFXV6Sa59ykWBcJZ4uovpagIvxnctfqnYuX0brTKeXZxj/AjV1TRtThzd4GaWcDWb022WyGRC5yWgLhntjZGDIZtFxScvMuympr5sIPFJ97/K1dk1y+MzPDmnMXtEcUKYWrr1KbG/Jg4yWip2Jgo5SNjYkvs7lvXccH5WEsYxDAbUZYt2I0geIeIce7nGyA02HmKKnCTao406vMJQNZr1q4qmu0sXrrg2kqO15mIoKJuco0lN0AxZ5iXWlFTlHMIBHx9rPjtOKZuCdwZ9EMyBy/kvn8L7D3Z4Nl8wUhnP5gv+1AcDjk/sti39r1Hcgb8J/O+B/8s/d+4/Av6pc+6vCyH+o+3f/0MhxLvA/wB4D7gB/BMhxJuup1b9oUeoGgLpekRtKPtdotnuToVBKkMUeviqH5Y6Z7d8lf5F1vQRdcqXhL7c5gtanDB9vqiMOblckK/WeKLnqwSB3/f0m7IvwMrbakfdNvxZYYxGbgelzm01914/9HXbHFNrfr9VY1zXD0CdoOv6BeCLQWWPAO5lhkIIrDV4Xl+4heh7+m2r+7mC36t+gO01tg5XY/u4PCl/xonRWvf5TkpSNzXKSo5Prvj02YqDX9pBdius22Dcir6dU/QzAqJ+0dTgbEddVDRlg9H9k4tVHs4YnO56FRMWbftevDYd2hictajRmC99+ZCvf31KqU+JognD12u+vV5xerbV70tHJ/eok1tYk+DFM5J4QxE0mK3qSQBRECJ1hxWO0PeomxrpLvCWmpP5hMXFKeHNB+zduEVxfEy3LAkHB5T+IYOdmzSbBic0SRb3UDYFVWkQMuHeUcRsU3Nrt5eyfuejK3a/POV26iAIybqKW2PFo194m82rY3bv7lMWjvXTn/Dx775mfFIzunkH1ziyUUwQZtzYtSzzOV+aXnA/W7M/SvmsTalrh1/VXLx4xlKP+enpgNn5iGiQsPYjpm3F8rJi5Sne8gSmFRgMtY2QdsObe5Lr3KeaG7rEQ6G5XiuSwwhRG8pSMUgjbuxU/NJXHcFAoOwT3kzW3Bt1KG2QVhDHY0IlUYGg3ewwiAMGkaKqGzprUZ4lckuoA4JRyHBP87oyPDt3eIGHNgMGh5Y/8bbhICkor3KOFx276S0KqVgdzzhZBfypD1K+ettwmsdMo4KilHz6es2t4ZiXlwecXlzQuRKjJFbCZG/CMHVcHC/pVMIgDGi9grr2kF5LlAxpFh1qL6fJJeiWtutohMRzMTLtKOsQWdT4UyAOWC/XyCxADTyMKtChh+xiqjxD63OiYJ9OO9rFNVUiaFSOCyO6ROFLQ5NnfHa9ZGcqe2xFNMSYDrFZsz7fEO6uiGWKbTrUKMB6mqpc4w8DvMjHWkNbdXz+cc6PX6X86qOSuK7ws4Qk22E3dIjqFD1fkvgloTOY9g6frX1enF1wcbbkTz2a0naCWDX83e/N2dt/k/NNw729CRezBXenEbJrOXk964GC/zrF3Tn3DSHEvf+v038Z+NXt5/9n4J8B/+H2/H/men/8cyHEE/rQ7G/9Ue/jiY7Q8/qijcIIi28kobEYo/E9R+Q7pLA9sJHtwuV6IqOxvZ3Y9xSBJwj8LWBL9Fjc2XzNt7//OW3dIaVktdzg+T5CSHzfp2nbrTZ9O+D1LaWusNYi5ZauiNsWf4NSX8gZwROgtSYIA9quwfd9rHFoY3+2U/c8gZT+djhqt4akvnBL+QXO1+GsRHkBTaO3772N7sMH1ydUeWG/EGij8ZTC2raHeNle0aNwrNY1v/XNp3z9F+6QqjWmOgMJXrSPrje0+QJRK1zbO36t6VOBlOv76J02GLdlz4geuqW1pqoF8/kGIxQXF/M+GtFqcq2wVcV/7xc03/r0lB+EMbHv08UCrUJkkGGkjymuOAgveXi0YpR8wq9/7NOq/ilN0DP50R2ekiir+qhBU3K9HmBix/jmHbSM2FxcQZuT7k+QoykiGSMiELXGFwpPNjQmo9tAEAuWZcuXbg5Yv5rRuYz7e4rnA8t54bh7ELKpQXgRN70C9yjGe/gBdd7hC5/ruOX86TPWr44J2hoT75CmEbHQnFxHPJjU3A4VwqX8cLNPJRNuu1ecXqWs3AFyFOIpn7AbIZ0kSRXHmxi6DU2+ZF0lGOthpc9pWdIheX5SgghQUlHVFuVH2NKR1Q7PKHxd8/6dFf/2+zm3B09ZVh4i3mMsLWdXNbdGK5xMCFRKY1/j3COk3jAc3GPTLQiDAE9IiqLDRhGLPOeNyS7PTq+plUfmJHfvC56et3ywX7MvNbb2KSvH1x4+4qNjjx9/91NuDG9wO+nIZzN+rCRfv7XH/q5gvtww1ZabOxt+8pFmcbzA1g1CW7pqRSUsqom3+cBQlS1OWTylMI2j4Aq0RuiUq/mG8chDp3u4dQ5iTVkK/MggNJS1hwwr2OSkOwOsMXRn14gsATSTgx20GFIuc1itsMqn6hRSRFjpUcoBYrnGjxrk5C6r0wusbxBt28+7vBgpO/S6pruxSyN3cF2OEGu0imjKBbQSJwKcNGg74J9+3/DVw9scTR9Tl8+x3ZzKQHu9QpgN86Xh2cWQya7i0iremk5IpeLz9RTP3/CoykkHdxnvRRyfXnF+bpCR4eWra37y2mO12e0l1f86xf0POA6cc2fbgnQmhNjfnr8J/N4/97rj7bk/8nh5vqGrFzy6t8tmUzAcKZzxUX6DJyy+EAQY4sjrk4Och7GCwAOtHU1niKKAMFIEwRa9JVvUQNDh8Xd+5yUvTmb4cYTv+2hj8DyFkj3bfDjMMNZsdecCX/Q9585C4KmtQoXeuo9AqD7DUCqFNR3C69UxUaAIw4BOG3x6HK9E4oTpP/clnm+3MiaBkqrvxwNSgHV9o94Pt9Ax1wdraGNwhl4KCv2O32qEdfhhjO1qlJKYzJHnOZ3WfO9Hz/jJx2/xS+84lDXo4gLRlkgcpuyoFiVKh3TOsGwkF5dL3ro1/lm4SasNuoOyrhE4Xl+sGQ1SfvzknHQ05be//4J12eEyRxw3/PxbkkApfvmDe7y4WGAUIDcEfoDIEpJRyrt7P+Xfe+f7+FHIyaXg3fuWY5txdZUjlKLVPakyTRN8P2BdNwhrEGmEG92jOv4Byf0xnijx9w+wWuGbmiBI8UJBaC2qbTnYSyiFoaZDupDluuZsmrJYa0Ss2dsxfO2dAd+bCy5zn0GiyLIAaWrKRrBYFxhiFo1icuuQwc4O9fUJ63nFIE0QnmCVb9jPNqTC8bunE+7fCTBqh2LVcW19bt2dUm98mrol0kta6XBE3InXyNGEk0VMECv8yOeicsTDKd7QQ7YVp7OANgQvECSRjxUhm/maRVcz2o3Yn4T8ylvXPIzX7KY5rR0zay2vOsfNtCWWDVH4FqvVT/CDO0iZc+MwIdca00ka69g0JZu55p/83oz33j3g9WXLq7MCp5csnOEozvjlacvDsuXyece9Nw7ZGWWIsuD4rOKrH7zL589/gipLksNH/OLhEBuvubiaE3kl794XnH1s+S/+do1X7SHaAutZ/MTDH3jIIITSI8gOIFNg+ifbprok7WqKKCQbp6ydRLcl4VCyWtSoRCJ1w3iUsbpcMZjcZLOYE94Ys5Npzl6tcL6H9H2s8DFhgm4alG8wCoQRSD+hU31gTdtVTKYZxek1Jn/O8M03qS6XlDYnDhTF2hKMxkSqo+ocam9AFKYsXjzBG3hIUjANniepSku3WfHpy5BvH4f82f0YlGHx/LfwxBt0TPBsykenB/ywesQ72V2+8cklE7lE7d7k3YOWNyY+j59NOG5WhFfXbKoBF42jO7N8/rHk2QraVY62///Vuf+LlpJ/4R0IIf4D4D/44pt+/ZuP2cumaNEbG95+b4diNWec+kwGktBTDCcO6Svwaj75acXlWnD7wOftGwmJksiwIfANBovy4p4PA3x6suAffvMxrTbESYzvBzRNQxCE9D5/SRiGaGt/1ooJPYWxhkj5Pd/G9lrw2PNotabtOpQSeErSut5UhTP4Xt8795SHk33PHye3CUr9cFY5+naG9LahHfQURkCo/r0AlBS9cmg7gfUDkMKnM/3uWiqFdNts0zDqFwxhiZIET8LpWcH/4//5I+78Tz4gkj7zWc3eGEQnaRtF00qMUBxfwn/669/A6Yb/xf/4V/A9RdvWzJYVYRzw+eNzbt7c50fPNoynkt/69ILZ5oTluuL0asXwTsiN2yMGA8HV1YadmwGjkUXaAnbvIv2YZDzgK/uf8yv3X3F0OGCzWnPjxoBf/LpkcRZwrXwQvTHNGENdVVStxVMC3zhU7JN3Bc4bYGTG3q0DCm/IsMsp1h6dlhCkvHu34dfeu8feruBkqfm7P7omGe+yMwp4lvsUao/LVxWTdEDkaXZDwbKpWVaWsfKZl5KffJoj4wAd+og7DynaNeP6kn/vT8DrJxteXMOzS8kgUtwcr1k2h1yWIX6Rkp9b7KohuHmLvAzQCDY6JIk19w93OK0MLQFB6vPmLcnzWcRkBLGEOA7ZzXzqOmJWBFRVCc7iiYjC+rhsyF52wa0J3Lyn+Pn7MV5zQWUneBLuDc4J/R125RN8dUC+eYFpHco3KNfhBTcJZIvUsM5hvbY0umb94imfeh6LTcc7b9/l8OYhg6ZlsVkRRw43OOfubgosmM1mfOubT7l0txC+5d96d8KOP0RGOScr6GrJr+ztMffg4+shf/9HOcVmjWevUcqghlOqvMXpgFXnUIMJxtN02sMfDGFxSRgkJL5m3UZUQmC1oiwlgwMPhKGrJXEa0+kcqzwaJWjqimxyg+LqBb4XozOPMjc46WjkGln3WQhWGTzn05levSZDiesMm3VBsjMh38xYvHjGeHefJs/Q0uGnAdn+hKboUMsSVy4RLmF/GrOZl8iDXYrlJXEyoCxWmLphOSv5r74Vcuv2Q4xeMro+R2SP6eSIi/wtHm8KjL3Br//2nE+//5g7D3b5n/1ixV5i+J3HCd89GXI43efvvJwzkhmies3jzzRiKRjsp+BesbTdH1qM/1WL+4UQ4mi7az8CLrfnj4Hb/9zrbgGn/6ILOOf+E+A/AZBCuNNXG17YJR8+PmNn6pNLyV4mqFuDHyhmS4s/Sbg6W/Lu+0M2jeY//XvPee+NPfjT9wlEgxIW6QmsCHl9OqdqLSod8l9/85Lnx0tC30MKH6UCglBirMWTijAIe5klfcE0W+qhEpLAU7S6H4oK2UsEhewXgzhQvSBRKHzPw5qWIJK0jcVX/aixw+CM22rkZe9ktQ4hv9DNC6ywPXGSbeBHb3FFiJ6/bq0l9BVxqNAW0P19+F4IThMFivVmQxhGNF2H70mc1Rin+Z3f+5xAKcLQ8uT5Kx7dOyDAp2ocVWvJ85r5uuX52QW/+rWHqCTjOx+eEGcDfvrpa3YPbvLjTyvk50/56OUJbd2RG4vwY2Rb0DYtmXK8cVhT1IJRJDl+/W1ac4s3dhf8+CxGDvYRXcnX977PmwclnrLsHd7moptgBxGr7jsIZ3rJqFIY67DaYKQgDh2s13S6JMiG1OWSJAUXDHE2JN+c4rTFG425M1rza+/vYDenPH7mGAxj/uovJ3y2CWi8lOPSEMaCq2bEt48lh5MBJnDsJYp8Y7ncdBiVIvY9uk2D3xUoZUlCQ+oURQ1JVlG/CtgPFXePYFlNOc099nYzzlY+3SxnZxizlhl1saLxxuyOFdIJQrPhcGefprK0G8vX3pyy+emCtmtxxTkL4THdyfjpcYPWNd31C4TKqPwE7XUcjC2BcTjP49fel0RBTl1b4sjnTrwh9Peg/iHCVHjeHTbrS6aTh2zyGcHgHpoEo0sen5QcX2gC0WJ9g3n1CXl+ztGDr/LiJz/i1Tjl3bdu8koPKK4C3jqco/ycs9WaWBzhZ6c8+/SYVdfwgCkLX2B9SA8F3tUVf/ObOfXoF/nW645XT1eIoEYuWuxwSFclJIOWQkuiQYwNoDUClaQ0SMKRx3rhSPcGxHWPvTBhgBfFtEWLNCB9GGaW2dwg4hCZ+shkjYze5HrTMLh7C3l9hS98tNSoWqD8AAKJWDVYWyNCnyD0aHVDPEpplzVlWeB7CqEjlq8XTG5KNibBCxxBmEEmqF2H2eTUzYYPHgpObMlsfkoWBbSuYXw0QQWGbtny+anm739fcdXtsny84o3dCDfIeHk+oZg/ozj9HdbrjjQ+5OduddjC4xvPSz58fEA6eMmr8x1MO+bjyzMWr9eMRmOyewk0ms3lY/6oUea/anH/u8C/D/z17Z9/5587/7eEEP9b+oHqG8B3/mUuOFnXFImkRPLyuuH4tx/jK8koinl0L2TkRxye1xTLllUBrVQsdM03Przih0/neNIhnQUcTsBy1bGzf4sorPjkyXPCoN9RB0H8BTEFz++RBspThIGPc31hMa7fpSdxhBLQdg1yq5JRYtsuEYYk8miammEWodum33U7i7OOLEvJ67pnqguJNl3vXu11Jgi57eHjUAJ85RikKU1bUTVmizBW/dDECaIoxGqDkhI/UTRNuzVdSVLfo201URTjqPB8h1IC23Us1yv+0W9/zp3btzifWV5eXm4fpRRCKYwzGG0oteOz19f87/6z3+Hl6ZqutWzqGssr6rbF9wBPEkZD5GKOW8y4JRqunaOtOq7PNsgbLUHm0y4LTl6tOd2kONEvesrXBLLjaKdDBQ+QxSsG6iXcDfj1SBF4Pm2n6LY+AIVEA6FSCDTjRDDzW956Iya8k3FSlPh+jVSGW2NJOFxAXrPnw4mr2JlOeefhEVq3HB6m/L0PS2wl2E8cr65b1m2MWTmGowTZae4/3OV0ueHlVYWKFHv7uyTKYasWtZpxe9xr/e/fiNgJzrjcTHh2LTgzB9y6HXDVCfR1TeoqbDDl7OKS8ThmT7b8mXcC9kaST+cDvnfpMyuG2G7BUjfcexQRhR6DuOLZ5Zq3HoTkqwZTWPy6o1UdbeYjbIfZrKl3Jrz/wHI01GwuLojSHSJZMcjeYV0+53ql8byMneCKINhh2XhI/wDpx1gHZ5cbnr/QPLqb0B0LvDAhunmP1ctnDC8/wwZH5Lrjs6gmHkeIpOPZ1Q7Hj+G59vi19z1eXGsWVxWv55f85EnOX/jvPqJ+fsXsH3+fJ3qKLgK+9CcME/GEVVUxayxtKhgOd1m7OZX28EZTrCgQRjDaydBpQp2v8QKfJHXsjSq0ldS+h7OWaCKo5iUyDBgdhH1LNmrRgUWvSwLPJ00sVTIk8xouu5zBTki1aoAcvFvgBJb11oTX0dY+wo+ITMPe/R1OPnlOZ3P29u9yeQmtNkihMdqwXp0wGhyiQw+0pVmVLDYtN27tcva9a7IsoFis2b0zJS8bbJpRXxd877uwc/AGl1XK8WfnbFaCuH3JSDYUlSRMBrhxzOdnK376DwTzKkBIg1pI1s7gTElnB/BgD6vnbJbHDK6e8P7BnGslegroH3D8y0gh/+/0w9NdIcQx8L/aFvW/LYT4a8Ar4K8AOOc+EkL8beBjQAP/038ZpYwA3ogEl2vNpWvYROCFGaZxaJfw3c8LhMnxsEgsv/HDU4yU5EWLFYraCpTsU5K0MShPEYQZr84vqcuSwA8IgxgZRKitvC8NA5I4oNV2uwu2GE1vUnKGcZbitjp7KQ1JJFFSIq2kNQYnJGiLsY7UsxinehNS4CNsRVEUFFXNMAkwyoHs3aNSCDoNpuuQQd+mSfyA0Jd0VU4cBJR0eMoSRwnrvEAJH6yhrkuiOMYTChX6CCUpy4LCGuI46hnwW0OA7wcEUYSQjtlyzkcf/5R0NKSpaow2PT4h8AiS/kcgjkNOrgqu172sNPFC0myC1o7heIeqLRBliV3PyNZrdjvDlycDXnobKhXyg5cZ926VOO8OH77e4eXpnPN5hIkFo7BCNAt2Rx6+9JHhLpF3xGb5m2SRJgk1dRZRL5utNQs8FIVuaTaKoecTRx1ffj+l+/wjrj5tCQ8V8ViRDeDLD0LeGq2oupSHD+5AKEgDha9KfFFRd4JfeWuXHz1eEPqSNA2YrTXFsqItDX46oHq5YLQbc7gjOTsvaeY5g4OUNgs4Wezx4vWSP3mzJJAdZVuzXq95cDBCaMHri468jRh2S7wkYpFLAi/C4fOVuz6RXDDyWkZql7pusCog9TWdP2Bvx7KT+uhCUJaKRkMw8MkXFtuA9vtWoR9JUD5v7Mz4+sMBsi0wTCh0zGiwR1Uv+eQarL7L/bTGiiHORehWkQQJ1gjOVg0vLzX3DncZeiuCwJJ4HaObB9RnjvNNh7dX47I91rmkiySX7PC95YDYn3DUXfFffnfFJ/M3qHYmeHJIlqz58fdeU796TVkL3GTAe48ygvn3+fD3foL238Ubpuwf3eNqtsA5n+BwjKdBdxrnG4Rn8ZoNmS0o5wX3jwLapiHvEmKzJtnboTiboYYhodTEqWR2pdmZxLy+WmGChul4jNQFw92MvFjhxQGDSUJ1scDPUiQFMky5LjuiYYYSNU52jCY7SNOQz67Zf+Mhlx9/Shy03HtvyPFxThgpXOCor9aEAoYqop4G2DDl9YvXmNuQPLxNs9kQ+DHrqxmSmPF+xNL3Of7wMy4++i67aYTxQsYuoV5pqiwhiRVCnrA8u+azbAdbK47eGzJQLTp9i3mTkKocV1TYfEX3g98gDufcf6T5yp2U35aSbXjzv1pxd879D/+AL/2ZP+D1/zHwH/9R1/3/OATc2I8Iu4aoLFhUglUq2AQhq7YlVDFBFuNJSVsVGKPZFA1KDemafqhYtS3WGJqmwRjLcGjRpiWMQ+I0IwxjhFBorUmigDQI6boWjEUJgdN2u4uX+MieEmkMnhRb9Ugf3RWGMUa3KN/DDwSx9GnqBiUE2oJuOqJQ0TSawOu1Mj3Zstfpd9ZsW0O2t9gbjQoUgVIoIcjrgq4zCE9gTQt0GGsRDaSRxLqmV8UYi9biZyavQEoC3ycKfYwDZyytscRxwr5SVGXF69NTsiQhChKSNMOPfJwEP/Dp6g4/DkiSFCklcRjS6YZ8s2Yzu4amxMtzvCpnZOFoGHDny0eMXM3F9RXLRcv3nk35wdMF61wg/Awv6CBIqHLD0Z6h9VM2csieSulaTetuUBDhhSuMWqJd1yuIOo0MAkJfYQuL8ByhLqlefMKPf7zh9s+/TTCMEV3DJJXcPUwZiJYPbo3YbM64dxjiOzjftGSRBAJGgeHPfbDP6WLBp2vF64s16SDj/HTOcADNJCJqjzk82mV4I+Xpszmffjzj4HbCg11J2F4QuDnHS828vsl1XXP62vFso2nagJvjDXfe2uE4V5jjnOD+lNCV7O9PELbm+MoxKyzaWlzbkAQty9LigpC39y0vZg1G+5xfFjhPYANFi0JYQ2A27EaKX7y/4Y1dy+FOwpPPz7BScpRIwOPpcknDlHs7HWkQ4QUZployGY1p2xVXG49PXm9IB0M+e37N7sOWTjt2BpZ/940T/rNlxdVpCFdP6WpBN2oZ+ANCsUuQjMm1+n9T91/BtqbpfR/2e9OXVtw5nNSnT5/OE4nBDAYgAg3QhCiTolUSaavksuWidGGXL+wr+8auUunO4cZVVsllm1aVSMoizSTSJIgBOUNgBjOY3DPdffqc7hN2Tit/+Q2++FY3QAoYsMiyavxd7Np77RX3Xut53+95/v/fn0dmgJ8ukb0WrEDOL1jNb7jK5+ilYfvwDvX8imfvnVHVCVX/DcYHDxkfbHHx5CnNIkePN4gijbNLRFvhtcG5FmUti3nVyQPnC47nS6RQpFuSVdFiMo3u9RkyIZ9bnM6QoWQwGiKqhlgLpospcW+PupwT9/oMsphZVOPVNvlVxf7tAddGIIc99CpQFTOSPuwMtnnv3efIwwirUq5O53xqd8xF4mi9IRChx5BfXsF4k0REmERR5JrnF0u2bvVw/YxlkNjFCt1TaFp2NwYs61eYPgucHJ3R29ljazhgdM/ge9ss+imtvU17vUSONtmNIoKOiR7uIZaaraMn6MvHuFZhTr9FPbnEvvUlHrw+51e+2PCf/pUfkhd/dFn9qXCoCin4tb/8kA++fs1v/OZzfO4Ztp6errnBE7KU2nRSseF4CykVfScoqhaBo6pKIpOipGI+n1MWK5arGds7m/T6fbJsQFO3NE3b9d0JFFWB1AaL72KjvcD7But9Z/BxgqapMVoBXSIOUjLLl0RaoUPAOkvbWIzpslcdAhEcsYkpq5p+r9ORu8aTRobgwYVOISMC6Dj+xAi1Kkp8cDRCkKYRtmmpm4Ysy1itKnTcKXwcguUy71o8UhKEIAhoQuiSYqTslDRr1n0aJ4wGIHcEUmsiqRkNN3BA1utR1g0AySjpkpa8o8oLpsWKIp8R5jk0NWMNy+mcHEfUS/jin/4Un/ncLv/l0yOy/j6nT6eEskVlmqPjG9RwB9nbwQhQscYNt3heHfKyneLCDSp9g7yuaZZXhJCh3QQbHMJLXBCYRGOERylHEkqKyxtOp5tEL/0CTW+LxTJhs52zexCjqxt27mwSZE6kHVk0JtEpKrEEb8B6rldTbo93kcTopmCURVTeIY3ho29+i3uffhnxcp/i5Amb916ivd2j+eEZV6cx0aHmM5+9g1hEHB0XfPXdluUCtjYPaCvL7qjkjc/dZlI5Lh5dUBSWPgN2x5JJJbg7HPPBSQNpgEWOEkN80mdeG97e6dE0Z+SLgt2+IosSpExxvqS0Co2gLQsOBw1/6g1Blo6gXnE9ndMb99BK8+xsycoGbqUTRFmjhm+xyqeMegmtn1JJw9cfV4wHGd9+POczL2sm1vDBC8XmrQ1+8Qsj4voj/loz4PSdc3pyxMRHXKzmiJMzzOEBu/tbFG3EPIlwrUDUC8IwQW7ssNmM2N0wXJ9V+HnNquwxfP1tjO4zHGacHx8hfAFCkSWGVjYEJ2jamliBbHvkeY3xBmkLnj2+QIx38H5JNVOEaATakVU3aLNiWY7I9JJVOWew+wB5fc5ibtC9hDTzuGTAZhIzu7qmrB2joaUUivnyjHGSYFuHkDVBGC7evaIanzDO+pwfXZPGkmZZ8eG7p4g4ImQF0hpcsMi0x2S2Iq6GxHFJm1aI65x5HHB6iFSC3cNdJs+W2O0eo1EfpRSjvc8we7FPMZ2Ra8sg1+goIBtFr7/J1qs7rCqLdyWD5ikffGNJdfEh8eQKkzR4p3GzU8RbX+Zn3hT89z+zYGNLI/7/JUM1Gzt+8c8fkGwb/uZf+4DjaYGJ4SCJSWvHxekZC6moegkqGqCzHjpJMLLLJB0OR8xmM4bDPuNRwnY7ZGNjA6MMzgUiYShEQ2Nb0JrGNrR1RVmVGK2RQhG8XyOE6Xbzqiv+ii4hSAQQIeCcpQ0C5+hSlsI6oQiBUZKmrBGug40557BVTax7gMAHgaQLsG7LqsMIS4V1ntZavJR42+npnYWqyZEoWuuxrcf6Ti7pnO+wvASKusY5iNeLRRx1Ch/pPVpIggAvNOONXYzUuKY7G1jOVwTvsG1NPfMIAVVR4JYLYhz90BV74iHLtiRHM4jh13/1dT7z+VtEynXTCy8IZszZ0hGbbeKdHUITCJFB2obEeXwrkL4hk0vqJifVnr6pGIYVt8Yx7jrmimWHddACZSAxiig0bPcGvHfRoj7zEq434PpyhRlGhH6fO5s5t7YzYl3jbEsvkYz6I4RKEW2D1kPipqIfWazLiaUhDiWpVlR5i1vMGaaCyx/9CKNeYyO2vLR3wWzVcju65rxqOXuueb+cMZLwnUctzcrxyt6YtNcwbjX339zphsze0VQaM+qT9QaY3oooeAyORqacTQLSW2zkmbWB7YEhVDkvGsiXFYM0IzWW0kqktwQRiGTFVr/lSy8vWC0F26OEfFFwZzfjZOppm4Qnz465c5AjcsfSe+bnFwwSgV5d02D46gcbVN6iVyVbg5Y4SvntHwr6/ZRYO3bubvPygzv8d0aKv3Ghad0cP0uJ9rfYSAsufvQ7TI92iPf32Nrbh6HEZiNqkxLFkCxLLvKPkMkOZBOi4UuE7DaRrLg6v8HlDfXZOX7rEGdrlIwxaYuYNdhZTukcob+NcTMiX9KKhqr29FWNUim+sSRYRuKKy9mSjYHBLXOaKGawfM5sNqfKMzazfaaTJYlqObqa4uYLQr5C7Hr0UDOfzIniQC/S+LrbIFmRcXV0SZwu0Zkn6hncSnBzNiXeHmC9YjBIaG5a4iiCNKGpG4wIyLpChBpVZ0gCRhSM4hFzO+fmhaeSA0Q1ZyAdd+9v0G6mXB9fUa+mmLggWaTYxNKMD4j1BqvTS5qrb5A0FcLt09/dpjQjyqsLzPZnuf9qwl/+hR/x1q0Z1fgza+yJ/SNr6k9FcRdAlsakmeALv7hFXT3g7/y9F5y0mjZNWKwqIuvYocVVFXOVU0eaJolp0ejYUBcNZVWsh5YOgeCiuuqyilpHXbewLlbGRDjfhWaL1tG6zmkqhMB5h1aKeh26HfAkUYfOzRWItjPYWB9wPqDWtwkEIqWQbh2AoAS579QupXOU8zlKSJyUWO+RIXTqHNFRmRtnaaxF0tEorff4xiKERGtFHKuOJInAhtCx7INHC3DrcI9WdDhhWKtp4ohKduqc0DqU7AawhM44FZwjEpJIeZSnGzS3ltZ5iCTTskCkBuMLlHHsjiL+u7/0Nr/yC/cxqu2E+SIw6guCaXFB4FuPXdygfI4Zv0brNUUxh+czxO0bVosSn41w6ph5UXBxBVVdUjUtUijiXowpW4KHsmyh9cxKwXgzZfsg5ngJvp9w+16Gz+dERhFoWDR99seCOA44l+OdR6sIb5eE5oZMeBp1h1pokkFEe22pZi3ex9RtQNiUqw+OSN+6z48uFQOjefTMs5g9RnjLO7vbxFpwetkiZMys8NAWDLYNJ4+nCNVp1qXphu5ylXMjHMtBYLoM5HXNi6kmy2LSBGxtyK3jW+9O2exZenaOVkMcGqU89XxOaCt82ucz96f87Ks133835aV9i4kC8WBMvFrw/OSSVtREMuFHT2/Y2u3jQ0XDmBfnC4SKqGYVt7YUvZ7ms3cF7z3J+cKDmK8+u4IoJtm8x6sH76F0yfGvb/N7344pypTppGAxucHnc2ZLjRGbZPMj7mx7WrNNiFNU7VhevCCNIiI9oxiMGW/D+fmH7PUFss45PztFlDk63yOkFTZAfH2JCoGy9lhdI+wNCsvBZo/8yiDbBbWfs6xGJLtb+JtzHp1eEd0+YH5+iShrxvcPOH73mmQwIPglswtNhYZ4ha8VWnahZfU8RyQ9ZFDYWQFRDHmNiBSDnqeQEnvZIPZLCtGhOWKjELOcQbJDWOVAIHKWVijKqqBYNIS2xKuIpm7ZThwX5ws+OL4kbiLiWpLeL/Ey4eqHH3Hqp6hkg+DmFFdzzFCz+/A1Qt2nuJjg5Iz26oRyUuHzHPPSgGWyQ2EVemufvb0+/8Fb3+Wtg0d4+1nqxv/rO1T/2zpC7JA9SZbAz/+ZXa7mlm/8aMVKCObAR6c5aRSjnWNoLIkV+HxJisQrhbMwEgFHoMVjfSAI1VEXHegQSFSXBOIROAJa0BVYROc8XdMWlZQI4daIA4+s6w4zECBGodZF1vuAkhK7dsmqxpIqiRegfGdycralEYLQNBipqD+GfglwotuhRygUAi/BB4/zDicCbbQmjOEQrUCvFwRChy6wsgvRQEoUDhECMjIUTYVQAtk6VFBdb18GbLD4xmFClz0rZJcTWrgWrzSFh6ZtsUFQ5y3eWb784IBP3d+nrWpubWf8yZ/bJ4kdMnTOWSVhkltGo4w09ljZ/Q0XV1f0eoe48Zg42mZ2WfPNd3v87L0TMjnBKQ91xMn5JrPZitnKgTGEOMJVIEOgbhxDk7GoG6J4wOPrEdHdPe7ciRjUVyBzUm2wLgapiGQXTu6DIQhLEJ6mmaMERNGAKE7IkohPH0S892RFWC7w0ZDd2we42SVpohHXF/jhAe+dN8yblCbJqM9eMJkcAxlxf4PN/RHb8SWZbJjPBU/OPcPbEUb3GaQrrq9nzHXN2EhWq5RTG9OPDHtJ4P2lITExShv2kpJSJZTTIwYqJhItL2YN+fkMu1xCkzMe9/m1zy6J1R57ewMiUwMe31aMs4rvvl/y9sMR1wsNekAwBpI+33mmGZaBl7anZGaTy5nhl18W2CZjtbomX0zIZEvwLUou2NoO9FXOJI34jr3NcO5ZTUa48z7V8YRoWMFkSaFrntzE+Fhjdkpa76FqkdZRr2b42Q3Xqy16G1u48ytOP3iB15J7rx2ysDn5okWLCeX0EkeGjw0ypITKIvsRJ0dzap9h8yXpKMbIHnE9IdQF23t9ptZ3AL9WdBJZ00N4i29ByxJjUno+QBRoCmh9y/zqCrGX4pWFZMi8KtHWgvNEffBRTGtqQkipjKBp6HwrVTdAv2k89WwFsaEOLZHs0tNEaHF6hFsWeLUiCi113iCFxYSWm69foNMEYonwULsbZAjEaUPcyyifX6HvSLwZUy47NHCT3UX2ewi7oFE10XiT+/E5v/7aMX/+/jNSETBJzVU14Y+wEH1y/NQU92hoiIYRtrEMteO/928/ZLR1zellzUfHN3z00RXXZUOQmhey2yUbqVAC4iRa56/aTpsuu7QkQsdR/xjP2IYus9Su0VeCsA7R6NKcPs4kDHSskxC633+cPxoQCNp17FyH7JVCdE6x0IGuOsa7QHmPpYuqC6HDC3QSyjU8LATE+vG8EPiO/L5uIzk8oMIfWHTW9jAHuPVzlgSk91ggqC5KT4m2i8ML3Q6e9eOJAM7azglr1JooCYkyVI3FuYbWWazv0p0EHiMUwjrGmcQp+OUvHqCzmkgY1JolLQQ4ExGiiMnZR/Q2G4RIGd95m3pzi2RzjPCB2EjmwPOrKbks0FFCuax58tQS6pq8aamkwC8sg7bbgUsh8XjK1uO1QW3voEzE2UcL8iTiF+4PcH7BeHSbJC6IY4OUfXQ0JuBwvsbEY7ydg+7h2gpnLZ/e7/P15JS5XXB2ec7tT91Fyx47tzd59TDBG8Ob9/d59MPnfPNxg9rao61bZN0SpSmpbimd53JuWJWWYlGSFkOW+YxYJPT6CSNRYLzg6GLO/maPB3fH7G/PmX9guZzNuH1g2HAzikoRvGbKiEETmFYgy4pmfk7wOQ/v1NzbKclXklHW4kOJ0YZUl0yWV+xtj9na3ONr373gYMvy/tEmYjTgYl7w6mHL6XnBs9kOf/ZPbvDD75/yD37jMU+f3rDKC8rVGXcOK4LNERsxhsCf5Ij3bg34HXefa3oURlE/EzTTC+LEoHwfNRgQ5Bx/6iBJGfQjFic3hHpJT+Z4xlw+ekIoW6zaREeSfrKHqTV5scIubghViYtSjKlpV0uE8OSVQpQV+AScoyokwZS0ZyWpryhETCPnYFpwnsWsxhtLvmzJ4oykn3BzXVAnntW8yxrWUmKLEnl5AtITJ4rGaXxdImPDxcUxqYkw4xENHtV4VJRgbyboSDK7mGKSjNrHVB60kNjKEseBpg6kqqIlMJtO8I1BSYFf5jRGEHSGbwxOVPj5DbKeosa3aYOgmV/hdodUzxfEo5JhamkHAruEockpzIJez3NnfMGv3Psq/85bBTLJSbJb1GGFDvqPq+0/PcW9Y5h3NN3Wegbjhu0dz9m5p1qV9HSEawrypiX3EiEhiyKs82jXFdXQWoa9DOs8eVN3+vA4QopOvli0DUp2FnkRAq31tK5jk2vVtWVa2+WcavWx/b/boRsJiY6xvqWWonMOhoBRisq2bOsujNrTSSlFCOua3BkxulLYLQJSSJwUtL67xaRuCEquVS9r4LCSCCWpraV1jihRJFohre/aCHgiLWiAvG6QQaClQGmDkBJnO966EBIXAq2z+ODRWiHXHPraOurWgQj0EsVWnHE1y6kbh0GRKMViVXKxsByMJb1+g8NDsOtFq5OOSh9QeFKjWZ09xyR9ku1NpEtpZhotPSa/pNnO+Os/fJtbdxzWR1SN5vF3/wGcn2Jtg5MJyjt0cBgZdfMKBHVQjNMET8TsOifb3mC8VTPI5sj+mF5f09cKRIYLFdLnBJvj64Ko9zLeWJyvsI2jLCTKKcaioCqXyKrm6e89whYT3v32jNmnX2Xv4avE8SUbmxGDvQFeC4SvKU4u8UqyqhW9gz1e3m/43e9dkvb7TC9yepsROwfgFivOzyuMc+w+HGB7EfM859624M99JlBax8AfcTGPSV3FaWNIs4TLheweZ3aJWx2xdf8urx/WNCVIWbPTN58QRZW06Ejx6v6Q01lCb0vx/DLmd36U89LLV3z+YUFfCdjYIo1K/u5/8dt85XeOWRxdoBqLk4FFVbK7CfObp2zqnHTDsNJDPvvmkPcuG66KKbqoGL31OdzJ+9hoi2SscKGhXRVQV7RGcXN6g2sW3H/5AfnFc86ePkdv7BNFY5zpUZY17753Dq1HjTUIjW8a4rTFtQ5lc1qZoKLulFbSmQtJDHUdEWORiWF1NkVtJBA88SCimVn0UJKJBCFbLk9ytBQsg11nDWcksaauaxJpKH0NqUYuS5RW+Lykbitc0idVKUZahK/QJsVvH9DOL/CrGkSM1CO8X9DUDUIZBBpfn+EWLYiEqg2IxiK0I4pa+nfeYFVtUjaXmOUZkctR+/dpxDaqXKKGCcJKovGI2weC5eKKjx6dEt/apU7GeHXIRnLDSOS80teYkaQNEdLP6A9HTJaLtXP9jz5+aop7u7RYsbZ1Nt1pDFbw7MWKg50+d4ZTzmcGjcVoiU4jEmOo6pYGT9M6XNsyXVgiIVBG45ynCBVt6wgBPIE2eMoQkKGjfrn1Lr2sahSiSzcJAbduLyitAdHdrmxAQBTFOO8p6wrhYRQbdpIIGUX40GW5uk92zOGTRaLDxgQQncrFe4loS67KltoGtFI0oRvqtrXrqIYIQhAUq5ZV6OYBYk2EnBdNx7sRHV++cJ68qjFGoaUgoCjKqpsjSNlhBaqa3PuOeik1UnfLTiQFG2lKImPOrqf0UXzm/og//auv8NXvHPPWnVto5RFuHfTdKeURAux8wtK/hxMenaS0tMzOj3BHj1Fbe4zvvUawKVfzlknvUzx9vETRkm4k5MsasawIRuJl56wFj3eSWEhcU+OsZHmzRK2mxG+8zt6mgvk5Z22ftxJPqhrSdIQUgqo+Rrg5wrbUl99C7KeYbIiQistlYFGUPP3wnNsb8GAv5n1v2MgUuiiYTDeZzlaI0wt++Vde5/w85/amRSURLz6cE3oD1OYdXFMz7l/x/GSBSnssr2ZsjFJ2tzQ2OBptkH3JxLaYyYrCJESpILYNo+0MheP6rOWdmz47vZi97ZbJItBPHcXNkma24LWHm3zuixm/9LkRNzcv2NnboaqnDPo92qamri29foY0fX5wpXlrL+Vr30uIVEU/TCnnBX/nOxc8/cEp5WzBaulZrVaIakYgBSe7VDAvENqQuimjaJPpyKDLl9kbXhHOjnD3dvnRew3R4T7L5YK26eOFQ44ydN59XKVqaRdTPvj2dwi1RW7dJUmGlGVF4iE1isoqbGMxbSBNJdL1aGpP3I+RsUcnQ4pc0JSnDGSOdwajhxghUCjKsiKKYmJjaHtDRFNiRorGCg5f2qRYVNRtw8BAvgiYfoZtHQFJqwPGgBYD+iqiNTX7uyOKsuLpcUO7zBGiopEBs4poTYRUMbbI8b5B0JIMLCE4rMyI4oxyfoRQAd84QgyGFhIDVsLgFs4qnLgkyl/QTC9ge49WD2inOXLgoSlxvsHVmhdKEW3eIfvMPo0LaCV49SXFa/KC6/qakdxiYxjTn66wqeVsIVi5ri79pOOnprjXVw1t06UR2TZgW8v2OKOXCP7dv/Amn3ttn7/7X7/D09OcldDkBBIp2N4ccDZdEMURy7ahblsq0cX2hRDwNmCtQwlFL4kpW9dpjX0gNoZYSRpr18NTQS+NIQQa52iaFhV8d6oVuoXBCMkoibDekhNTti1eeKJI8mg6pUFQrfvW49jgAyzKGtYBIm3rSI1hd5giW8t2T6/BYR2ioJ/F1E0n20R1+AOtNEXdYq1HKIUR3e7Nuc41G2tFP0u4Wixo6YBnKI31Due6BSExBmM0ZVkBnUM2iRSjLAEcSZpxMlnhVzm3+jG/+qV7/Nt/+j77+4ZlWfPw3hAVWj7OZ3Wuo3J654iNQCtPtr2LTgf0Zc3NZY5wV9iLY0abhsoNuLryZNtDnJMo4QnVApcv0YmmF0cUTTf7b4VErqFubdMijKR1Jb5dEbctyx+fUWaOOBJc3eRcjzPiaIgSFVJEhKDQoiTkFwRf0LYpXjnieMyzR5esWsNoJ2O8pwmTioulZdy/zbAvWeYl/VnJR++dc7ZU3EwK6qJlaAxqvMu0XDLyOd97Z0Uawer0BNMb0esZijpmY2cbGVZIFdhQK4ZjiQlTPnhmORIRL9/v0d/YQPbhi3cOyHTg6OiEvCwprePFi5KtDc1br/b5c18ybOgzwsFdzi9LIqNIohilarLUoP2Qp9c96nrF0WnDvNqgsQ2Tss/1E8E7354xfXbNvdsDwnSKygtc6Jj8QoIXHoEiQqJNoPANQ7VC2OfEteDefuBn3jpkZC747ScWd1rRaEuyu4EKjp27Y0TVcnbsiFyMt54m7SGilHxe0DY5QTT0hgNUGrNoQdc5rUzZv3+H4ydzkAJjOgVaOtjATxRtuQJj0TOHC4LKxOhU099PSUYJl8u6OwMOgkSnDHXFlS3AaopFTjbsIVuFyDyryxV9HXX5y2sKq48TojRiFTRK1yhjUS4w2NiltRpWS7T0JD1DNS9pl1NMvcLJCD0e4PIbtPSIKCOOAqpQLL3qKLUqRfiUfLLE5M87McHGIXL4Mr5d0Ns2VJMG1Q+kacTcLQjVHqInEPWIQX3JL3/B8mceOOrLa37zW2ds7N1GYEkzxaIu8HFKP2/XUKo/+vipKe7UCl926gshFFpIksSyO4KNQcEXvtBjf++zfOU3j/jqt46oigZhDK5tyeKYZVURRxpbWZQQJCjiLGZV17jWsw6pIzKdDJL1bnc8HLJc5fiq6eSDQJpElGstuQQ2+n3K2uJ8gQqSRAqStEdZ3KDQBOfRvtPoREnCqnVUQSKTmLJsqIJgI+0csS8mC/qxIk0iCtthBpzv+tsGSRbF2MYSKUPwniyOieOYop528WRCMerFrIqSVAkCnq2NEUoF9BKiOCIEQRoZqrYhSw3BepIkWTNwOsmeEIFeP6WxMF8WMC+IQ8tbhz3+vX/jbX7+S5ukccCHijQU2HqJt2lX0IPHB0E3MvDk549x/SVVW7Fz7wFKzVExSLmL7o2ZyIh2WUFTUZczIiNRbYOdT3FVhVCSnoqYS0sVBGVjycsK6z3aK4RWjPs9dL+PW+aUQvBz21N6RcnFLOK02GZsPX1dI0QfQh9nF0Qbr4JSqHUbLVUlLx/GnMURTy8rZlWL7qVkcUXdZuyNW3q65nIy4/2vXBP1NknSlM29A6Ke4sVVSWwEs4srhIgpSk+0cQfXLtG+xgjLyYdXWKXZHXju38qYBOiFGxAxZ3VK/WHN1rDCoVm+8z5V2WClRvU8QWZsbA/49G3Hn/rUDYP4GVE8IundoqxvqKpAni/pDXLKSnN1U/D9s0CSCn77x4bDseW40UyLiAe3ErYeforZ0RkvPprg6yV4C6aHtx6PZTzOENQ0AZAj7GRCtj8k6kncvGB5vuD92yt2NlN+5dWab7gx1WXNPA9IZbk5mTG/LBFtTSwVDFLS3oidnU3yYkl+XVA1Fr9s2NwZgKqRqqbMW6bncPvBIZdnS6pSAi3RSJIONqhFg10VeKFRmwfI3hCTVPj5kkEsyGXATsD5BiUDi5WmzhWDPlSkVAWgc6oXE2RoGW710FHDZN6ifIRJM3Ss2VMV842UIAVaJZRVg3CKZHMDHQn6/SFNm3P57glVaBlv7uJUilc5oe2RZJa97Qy79FRnC8yoh6s9TVOhyhvqNEIMXqK3sYutCkSoKPIaGUe0qSSYGoqIaKtFtQVbw5q/+Pkb/q17R6SH93lXGzIRqE8j3H4K/RjTOjZTSbG4QP4Edyr8FBV3oSREHW9FIFBSIHVAY0kjgwstr7yccOvff5233h7wd/7xR3znyYIXN57hqM9LdzaZzHPUokWqqMs7VQEjNSKOkQIiIzFSoqT5ZPdibSDpJeg4IsiYJIoZ9iNa1fv9yL4EeqZPlCR4IYhTTS9JGGIZNgJjLVp12vjEdIEfCkGmVdcCkYphllK13cCXIMgrh/UQq5iNnRFGpgQUorX0h31iZXC2A4oJHdje2aWjSnYLlErGWGdRJiBdoLUto+0dgvMdn0wKjB+hZTeQdaIbKvfimKAMTTljZ29MJDXuaSDxBX/2C3f5S//mQ16+FyOE7Xr3vlM8KgS9JMGHzmXp10ofpej8BvWKMD2n3L6NyyW7ac7x8fuonU+TDraxbYvQEfVqRm8AWmfkxTVFXRDrFu8LrOraYgKBbSAoiZCeNPIkMSyqEnc5JbOXvH99xqfevkutRuhsA0kBIbCqK7ROMXIHs5MiVALCImWEcS3KCB5dO2a54PpyQRLv8/an73OYQNNc8/33HOxvMeyPkDJGCUkIOSosOdzrk+cgkgQXYNEkjEYOU1t8LTl5PqH2it7d2ySp46Pzmod3Vxxsw1av5dsvLMV0zuQyQyUNwZUQGdJexNagpm0D492cz9y54vZ2BH6EEyMa4Zgsl5ycLPncGzHOaeazM56cJbz7fJNRFjEabXOzXFFlu5xOE65XOa+9toE62eZHv/sY5VVnepEaKzwyaOrSoX1A1p5CxZhQEeodhIjRWc3q+oKeuOTLX96CSvEXfmWHr/9wxV//nmJ+1rC0kt5Wn83NPWanU6q8QqmY66sFLkji3bvQBqrpnKqu2XtpxM2zFdgV1dRTCMHO1h7ziwnNMKF1hmRvmyA9u3cinEjI4220tkhtaRaOvK4JtSfqpdiFo64XPDuSNGTISFPXgswIZOOwUUIvG9Db3uXycoZznt5GympV8/73z5FG02wcMogU5dkpTePo7dymRjBbGVZWoZIh2WtDYiyVMripRemMaKAxfsb10+fkU0n/YJ9QLWm9RjcBMRqS9IfEvSE0OSvfJY4F6ck2JCob4VxDI0qMSXjzTsO/9eVzfv3OO2z3JKfCMI4Cs0jyuKh5jRFVdYOMA73mmoW0a577vwZb5r+tIzgPvguHDuuQaWt9F8SswSjVDVJSzy//0h5vfWqbf/o7J/zdr7ygSYfYWGLnHYOj+0ALTJLgat3JH32glS1KF0hTo41hNBxQnV8z2Bxghn3ylUVJhZMNut/1zmXQxGkPrxN6ImW0BSwqTBN4cLhNFkvqytGcXCEJ5EVBFClCHagtSGVQ0rLIS6wPHbBMKsq6JQaUhjfv3kMHS1uBzHPKVFFFGflUEDB4PaXBdb1u6emN9ilWgSSqGW46Zu8eoxDsHhxydXmDICD1JvNCUdFJOnuxJTUlbR2IjMemmuX8hq20xxdeHvIX/8xr/NLntkmSBkxLoIvwk02X2Wo9mEgQkGjXAeh96NANZuM2o9FtlrObzkQW52ybOXtvao4mj9FhhFTQTk4Q2R6Z0vQTwdLVNN6SuG7ukUpHGbphtwgdNUMQSCW4xiOKgny1pJaOsjfm0Qc33Lp3QCodse6hhEDpQGCCMIeUYYsin2N0YJhmSC3oxYGxOMOZlLsPDskxXFxMyYPkYCfGJ5vEqyUPsyVHPqEQBqdjFl5Se8O8sdAKfHFN2kt44zDm8jJjnFzTq+DYvUS0N0b3pnxuP+FwVNBUsHLwuQcxomg5vam5LGPSKNAf9QjOUreKu/sVf+rVOTvjfc5mlu2owPuC8+OWvFpwcLCNSeDZ6ZSeyjm+HpDaGedXQ7LIs3eg+cLmDV/5lmF2kZPJd5mfnRLHAWEV3tIVQARCSfKgCfaMetFQiRWkKW0ZsZgFpmXO7Z1tfua1EdvpkhdNhakLfuHTh6Sb8A9/vOL5hwJfVawacCpFyBFNW6OUJhmmeNnDRIY4HVNfnfP80TVm3MPECbFdML+5Juw+wA4iyFcw6PKTfRYxX1SInsGTEyJFU0j01gaTao6S0IqIg8+9Qf70CN+WXFYCETKiuKRaLNafXUNhA8XZHFsqQhIxvWlQrSXxFqUlarBB2B+jl0vk8oLB1m1WLtDM5ogM/HyKz8+J+pv4UcbmbopRW+S2JXUwO32C3LyNlw0CgzESNeghlcFFfVZW0OQVSWTwwTGM6KIHpaVpY7buj/nyayP+nZ/5Eb/0+juMNCybfWpjkG1M4yDNDKUqUWsHeen6lGVMCJc/sab+9BR3EVBadVF1thsqOgdt2+WnfrxIdRhcz9624C/9+Ye8/vAl/qvfesq3n5wTecuwn2K9w4eA1jEsI5zrADtCWAZG4iJJFCnGqebaCPqpIe1lSK8QUqOiFtk2QEAEwSCNaYXGSMko9mRpQBlNEWuyniTBUyh4dSOhdAIvBUZIpAz4XgwiQQFBdEHYWnSa9UhIdPAk1uKVJRAYJQoTIGpahND4YImilJGKOhVPCKQhYFyNtzVyZVF4DkYZmanZ3IoJqiHICtsznyxs0liMAjkwXV6r2QAZGEYRB1sZr72yRX8LfDCIoDqVjw8ELNZ1vgGpP5ZYQghrD5MQGA0hSejdeqVj4vQEfpCxEac8uNvwj37wiLLeYDQasWgaln6XvMyRYUkUKRIpcAKGwVEDJtI0LkCkcQK8VEiZM0prisFDlF9CeYOPAudHl0xux9zEMQebfbQPNPUCpxxRtEFZO1oH1scIoFw1jEZDzlaam8mCfj8w7LX0I83BMOeJFlzkgQ9fzNAbCZWP2L0dcbDb4/io5GJ6xU6aY+2S1jWI/ivs9zK++BL88GrEfPkAFbdsx4670TkH6ZwySnnz5Zc43N1gpG/x7kdHnBUtkXAIP6dul1yXivEgZWtjm+vFjIuFpb+3yeX5imGWszXIGPQU33oypy9yGjnkvY8Uv/RzEV+/3uTBqOIga3n0T7/OyT/5kGJZ8vfsAtlCEBbnu0F+T4mOkGoCupX4WLH0FtUIEjNmXi7Z4xgbG4IvyUZwMb/hi7f7NM2c6wr2kof8R2nG3/Q57zx3FNcNTV2T7ES09YgWhUcQaYeWMShJvB1hJ0DwRP0RD26NefSD92hmK3rDEYwDVjUEY6luHEoGeqrAIimuc8ZbG2yokiIRrKxhtN9jd0fx3iOwlaOPIVIVpZJsjAWtkxgvkYOM6aLl7qt7TCcFsqrx/hjXTFjUu4y2c/wswoua7bgmclddgIifIJYWly+JbMnO3h61d5TtitIlKBmTL2b4ek720n2Ei0hHgrQ1TKdTxjtDbFSzrB3ZyLGVambLFfNZielltFaTRYHXH/QY3YXP3TonNZs8v0gxvYT3jxU//lHE8WqHVt9hJi5ZqgUhb3juEvJsB8eHdCPtP/z4qSnu6aCPNArnPcp0GaWt9chIoYwGDd6Ftb67m4KvqoYfvvuUnld86aXbXeSedTjh8XQcl7DHOvXIr2PqBhi5iVICqSRnAh4fX+KXlgxNEil0FLFD1unVkaimxrcV3oIrWkS9wlgQhSZOUlrh6fUStiO4jaRWjqnp3KACieuCYAHw1rFvFa2HU2Kq4NFtjakVfrXCLAtE1kNFMePGE0Vg/AArfv9fpVxNJFsWtUA6zTDp8fm3XmWYKsDgVadoMcoQ1kOkLkkbRPAgwOjOdYsT5HXFo/dm3L+1RWhrvHV8TJvzIRCcwrYQ/PrsIch1EEr3msqTD3CTC5Kt+yTsoLb2Oa0GFIz54PiGfHFDO3/OdHTA4asPyIsVqQy8/GCPHz2PCHWDF4HtQY/JTY71IFwXgh40yFRTNJa4qRD1BTo19JLAfs+jvCNx4J3EkoBfEUV7RMkBAkk/kh1m2QPCk6aW2Fte3lFMZvCd5zlaaw7jBfe2x2g3oz9MccJQyJh+f4DxDVdHFSwmbG+02NYyOZcc3M4Y7UhubUm2Ms8oSN6MLgmTKQ9HN5SrU/TuiHuHd9nb2CYyikg53n64yf1yys20II0ibm6uiIJk2UqIt+gpx0Gv4fo6oydheyNjfn3O07OcZ6dDfuaO4nc/2ObNlzyDgwF3DbSF45/8jX/MD7/xEcEJdNsi0i18e41rA1IazKBPXRYIBK4FZZdEkSHeGLEql5R5Rn31jCN1m2lbszncpFoNuL5SnI8a+oMNtnqCl8+veGfZo6xyer5hsOsYCXDkxInHMWAhEqq2ApfT14q8tLy1r2iCJAwMbetpQkY5vWbVrtAqJtnfIto+pGfPCJVEG0s5WyGUZ7VcMa1O0c0cm26zuz/ifFHSHu6wet7yyrjktY3Ak8vAzkZCFfrklSeEmBVz5tMTdiLH3Z2Im+QBHx4dsDkaMNi9RU8cU5lzzs8uYXNKtHWL5jiQDveQBw9omxecNIpIZ4hg8Ys5Pk4hn5PEJbfDhGwouHdnn8kcDl++w63dHa5nC65OL9jv18RtyY/nnu17WwwODrlB0iwsN/mAh7Zhywy4zlOu6gYmJafPIr56tsFc1Dxdwc/ZHkFIztohIt7DXnedjp90/NQUd7/qYuSE72SISgnKlSXITheulSPILlgaCcjA1dRT3ii2+9trfACfnM77T/JOO0VHwONdF4QhRWfqCUBeeeLxmOHmPlWt0ZtDhLlLXd1BoAhSoJJzCE/wOWz2YfvFBzBbYV59iTDaZJjA5KqkWC6ZXZxQJorTrW0wUYc0CCBk126gzHEvrnG6x3L/Lib1RFsCv3SklxeM362QWztcb94lXzjaOAG9TeOSbhoRLGm0pFmd4VpLllgmTyZcPz3Gak8rNJ2nKnQ5s+udtgggEcj17zrflsSvMcm3Btu0yyHeNnivUKqTW3YTkIi6Bt928wIZumSfEAQyBAapYZh6bh1Y3njwEbcPPiCOGmz6KifXPb56ozjJI4QW3Dz7kP5rn6VqBB99+ANWpSVWkjZYellKdFMQpEBaj/Ch4+hITZk37McNarhJiMBOFkxDTFMnnN5YtjYteW3pmQStezhfEMdD2iZFBIfUMYvVnOniiqvJnIsy4+yiYqM3JBaOjaTleJJzUxpEb5NeWtEzGWnkOUhXLJuGpioJ0jCZ9Xjl4SZfeBsO92e8dig5n0r+xM6S3Vcc+eKKWS1R6ZuIvidLFY2tqeuaYW8THyJsGCBlSVHN2NnZZGNTMy0sQ2Up4gHX8xVarNjdG3F+ccIoXfDhxZhh0vL4ZIt5Dj//WTgrBbjA9HrF+++8wPfuIGxFaAoqoTFihdMej6YpQHqLci1OCurG0doRi3aDuvEoucCoVzk6zqiPLXYj5nxRU4we0PZaSqHx7Zw2lnxQ5ixWlpuLGf1xytZA8OqOptaBVK+oyyWnK89ydsnBzhaL7QjhDf0QSH3AbGveH2psNkLqhEEWs3dvH79zn2Znn3kZiEpPpj+Edo6Ocg533+Ddb/wuupiSDl4j6d8niWuelZ782fdo9JC8hGW8j29bxKBHv99H+R6ibSnqSy5ubrisPWrnAaRbEPeo6gzZG2PSmmyccblYsn24xf5rrzB1CdfXPXaEpz/aZHo1Z4nCqZRBcoycW8ZxBXlNfROxqkG1C46unuCLOaJyXF05GG8w2owpbo4QqsbWG+RpRj3NeSN9zoXoAokO0ynnVcYPbjT3DnpcLq+4uMl4UsZMqpjd7R4X05rgxCcbxj/q+Kkp7q0VNK2AtR7c2kCxsqggEJWiDR4vDABBBlCCYBXL4ytmy0u872z9Sq6DsdfF/ZPXvzbchLUrVa916EezggUaM25QcctlUXB88QzrVbcvDQETLC/tDcjShOXSMvaerJ/y7HqKDB4jA00rOTq/5ptHE0Ic0Zx34diC9R5YdI/vfItZFXg157aJub3TY3HisFWgusnZ3xxRLWfUCByOZ+cTTi5XBCe75y6g35O8cnuXRCWU1znNakVrPM6ApQv4+JiV87ELNghJEN18vftbhbWm32MCtKXleCbxIu48BnQGKBsk162HecO7xy3eO7xTtI2maRzXi4CbPeKVVw7R2Zg/92sRgx5cTyo+mK44PFS89jOvY394xWSukVFEM71Bjwc0VUEIsKpKlBZcXU3p+5ZWaZx1iKAwKHCCECSp9lRxIJo9ZqVG2LqhnC+5nErKZotJ3iASR+09SeTxfg56jBWOq9mC6WTKfOoJyZCTFw05PaySeBNxhcPPNbcPYzZH19zfsjgr0aZlrz/nbJ7w92YbXB7PGY5SXn0z5nOvtIh2STFr6OmEWztDLheWEB3y+NSiMkNRVUjVYOQ1STSisHPmNXx04dg1LdKkXJUJs6sFmxuS1gnOF5bZyvDGyxu8//SSob5GxTt8NNlB5zk+KA5e3uLbRyuiUeDpRPIwWhFcwEcGX+YYExOqFoJEpylKGppygRYaLy0eg8JSl5IijzitRuyZKaUf8P1inxeLJWKkue/vYZopkf0xzy8DFxcJ9/Z3eWNc8vWnx/iqgOkms7zgqvT4fkaBZHkxZ14EeqqltUuiNGa+aJFphshPGd0aol2OEZJkb5O9rYT6o3eY/uA3MMozGL2O8B57vYC4z8btQyaTc1763C2KpeTqSvL2KxFnlxWff+02jz/6p3zl95ZEO7cZ+Kc4GaN8y7RcYlsLyxUX85IXK8too2BzW6IiS8OU1ekK3fRRexVeSHbvDomD5Nl3vsF8McOuWkpXY9SI4c4Gb77xkJVIsSFmclKyvJggpO8WiyonL0+p6wLtK3S8QasjZG5ROPyiZLL4ED+6gyxT3t7x9Kziu89e5/Lkkp+/n/Kf/5bAbY5ZXZ6zWpb83gcZD16yfCq6w3fOBhyfwV64wP6EoA74KSnuPsBvfv2aYRajlSIIgZTw+FnFyU3gK9+qgBneNZ0ZyEFrLcUiEDlFJqCVlsYH5HqHqlgP5MLH82SBXysxpAQTAipAjGSgFMq23EwXXC+XTKZlp4WnwwVIBeUqY3uQcW9rTLQ9IpGG1IEvPIt8zs1sydHphPki7yz5YrEu7QLExw7Vri3iRcAgUM9f0C767Aw26WeGjWRAb3tAvJxxcXnB6fWCeVVRtfafG4q3peTHi4JBL+K1vZ0u51VphPB0Ys4uRESIsIYLdc8h4JDr4cUaHoCWoIPgW9+/4v/x7RNU2v0P1lt7XOsp2j51c8Ff+YePELJj0kitcC7w9HjO/+Tfe4n/4b9/hx9/uMsHZzXn+R3u32p446ULvnm5g7/zCv2riEl5CTIhCYL6ZkUUOaQMWByxVzS152DU4zpf4YyiaVw3YLcdNoLFMYO0z/Hj9yj1FoNXH1BcHPPiwPCrvdtkJkOriEntWdU1e4OYZbvidFoj7YRF0TBvE755HvOk8myOgcjQ5jn91PGLr0n2enOqtmFvc6vDH3iHlgpblmzEmtXY8HNvwq+9KbgzKCiLHO9zBuNd6sZzuLXPvFGU7z3hYBwRJRlCR2hlmFc1syrhw1XCh1dLduOYJxeG/Q14dWeHdycrXhRL8pVjXmSc/2jJaq44GO3y/R/t8o13FftDxa/+2j5H5xXWzXgwzLm1belfrtBOIvIKqhvaaIywFcI1qGiELVZI182igo7xegh1wflVxW99o2Zr7GlVjxfXm3x4o/C25eoKHh2v+GLvlGs54/mJ5KYZ841vXPO975wwuzrG2BaTzUmt47IU3Hr1Ve6/ep93m3eJqRFO4xqLbEqsbXGhQUuHr1Ky2JEOJffe3uH5d3/IzTsfUCzPkKFF+g8JoUX0Nkn27nLyaE5sUt5+8yV+9FHOG6/ewc5vWHzzfS5f/IDJpMb09vCzCRfXgfTOLoMkZ34dsNOC7cyiXUkTArNJzupbP2L74Zio32fUE2weHrJ169MU5YzZdMbj7zzBLadQzRFVwGuNTQtyW/K8zjnczkCU6KhHJGN0BKJZYG/mBFejMXihKau6yyYQjraqCVkf4ZcM2wmq8fTOtnh08TK/941jqkrzt79meHEZMz445fj5NUn/gGJ2yv/nWwn/xWyDhEsS2cL1BXX7rymFFEL834F/E7gMIby9vux/B/xl4Gp9tf9NCOEfrH/3vwb+p3Sd/v9FCOEf/XGPEULgP//GU7TogFZ+vcuuVh5Xe358/l2QXRCHkAprPYu8YWwlf2p7jFKBxguQXSvCeb8evnbtGUL4hK8i5LrkClBCooSgKCseP37CPK9xrFeDNdyLIAit4XqSczOdc3U15eD1l+mlglUF3/nxU6arOZk2xMawuzFEBoFCdFF3dNF/UnQ9/sp3hVd7ga8tz55f8L49ZXtjwOf391npmGcXM358dkZjO2ft79f1rjB775hXlmVT4vKC1yKNlilGKgIKGVQX9yfpXogA8QnfptvNS9GBzVTwGKCoPc/mNToR3ewD8M4TGYMxFisVQqQ0dQM4Nsc9dKRxTHj7bYNwEt8b84PLbVZug9Mzzb87es6vvfaUxdED3tjZ5yu/nXF+6jkcVGSp5PsfVtR1iwoSKTVRFGOSiGpSUHiwOLQTuLbFeE+9vMLGO8zqls1XPkdLy+p6wdky44OLmtFswqce3iVOPMNkgLWa55MJy2XOeGuT945vePz0mrFZ8JfeKtnayjid9dFc8dbtPoNEcppHfGc+YLtc8Knhgn7cEGeSpY/Z3hmyt13w6TsZQ85IdYOPM6RSpOkdtscbCA3zy5w/8bCHkR7MiBfnM/q9iBDt8mLZ48kchB7y3UnMy7uSTMz52g/m2CDxVtASCFIwyTdwlaTON5jXjtuvpLx6IChWV3xqp2S0U/H+u89Q9YKvfO0py2VJ0DOk0vhIIooZTjtwDt9WqNCdzXrRzTOEhItK8BvfCzRpyp/YPOSjxlCVnrAqqNQG3zsqUUrxT7/hWMlNPjyaUp1UbA0LfvHnP8PlzYzVyfuYJGVZep69+5RqUiBMwOUdOprEdG9iZ5HCgoqxzlPljkS8x0e/dcX1hyeEdtmF4QSD8IqgetAf0nqLnpTEtzU3szPefPU2p++9y7vvvYc9mSFSj+rtdkonVRJvZ2ze2qPnZ+ztCkq3SygjRLlkp65ZFZaiFMyuJfFyQc847r5xiNmJ+eDvf8T1Ry9wyyUaj3USqbqC0TqLayuW14GiLenJBaYfM+z38SHQBNVlLkQC5QMtmtC0eF3jnSVEkjavyXyOdiv2RyN0GvOP/+kzjo6PSO9+Ci9HlItrro6O6d2+hVcK4VouZoa8cGS5ZOvOgOFwwo+l+Anj1H+5nftfAf7PwH/+L1z+fwoh/O//4AVCiDeBvwS8RZeh+ptCiFf/2Ki9AIWNiLQkeI+zHcJ2Wua4FmrtscESMDjrupxTkZAE14GuCGtY1xofIOnkHOsgCxHWPfbwMUgLxMc5qlLi6payrrsEo/DPP6/uS7v+MbBqLMdRxxL/1jvfZVKu8C4QXKBoWoIMneMvqC7ZSYR/TonqcLSwBnQ5fCc/53gyByFJ7t7h+PSS2kpYo4T/hSf0yfOSvnsTZYhOtrjOHg3rXrVcR/s5Ojxx+Ph2dG0pQugQB0IQhEQog0dB6MAHUkiE6L73PnT3rztWfFV5QqjxAY4uYh7YPd493eTxdAMhY7ZD4Ednh/yFOy94mDzmveZtfvbndvmNr1vO5jNGTUvSTzuQm5WUkUa7wPFsRe0CNYIojhluZKAFkauZTBrm1hBawzCy7IwarvOCx49u+PBhwi9+tuXRyTGF3GQvXYHs8SJX3BmO+cGTG/7ZezVfvO/5c2+cEJym8BkJczJZUFSOsynMxADV5vSTK2wKH9U9htPAw9t77IwbHl8KblYriqFhUg8oLLQ5tFcT7t3qCJmTVU1bBbKtBBsLhDc8nUZc2w6CdjjqBGAHfbib5BydOYaDCB2n/OBZyf3bguObiNI6ikVgv7fgi59J8EnFG+YZt7b7XDxZ8V/9rW/x4/fnhLqlbR3oHYJrsEohQ0C6psNo5MvuLZNkWBtAJngEXsa0ImaWD7CTCV95UZGOdlCZpgoFot3m5LphZzhjkA74waOWOu+h05amp2nahsIZqvFd6smKEErGI4W0UxaTGiM73lOYrgi9HkKBUimgCFriCs90eU4jrjshhFdEdcBIgY0jfNYDZfA2IH3NcuHZOXiVi3cn/OCbz6ABsZVSVQI1HmJ8SWkUqplQPjrHRRWiUZQqJtt+DZcNKKqGqihQaUbwE1SlmK5KphcDDnpT2qsbbLlE4QgyBl9jRYyOIpwxtF5A5KBu8CFHGYNUAddaNlJFjeg48VIjg4KoQoqAq2ts23Yzr2VD/+6Qw80eZWKQZ9fsD25R9DJa2aPXWpws6B8cMn3xgu39IcuQ0e+BMQ2T2RUn84D910X+hhC+JoR46Y+73vr488BfDyHUwFMhxBPgZ4Fv/MTHAGqXUreuc5KGDs1bNALQJKqHDw5rA14EvHS01qJM1x4QwSOcR8J6gOnWIMjwCYERH9ZlbV37BUihkAJSIUilovLuv2EJ+Lhv3n3f9aGJY+okoUQQPOiPl4vg6ePZzgKDRBJFAiPXlMq1R7YJnmnZcpUHZk3oBt7O0wSBMjGpkmSRQoX2J67K0P3zMiSJlCgp1sNiiSR0DPfw8bP+eIi6vg50OmDRkScFAqkgiWN0b9hJJZVGCIHWgnxVo5RhY2u87tZ09+mcw1xP+e6TBxw8PGBD3fByVNIfpbxyNxB8xrzo8/rohHem9+hFjgevZDx+NODyYo4OMaFx+DU1rmpaPA0bmSCYlNo7bGgJTrI3iKiaBNWLGXrPK7cVsxdnaFEQZT2enFg+/6kRzy9rymhFOYhRpmViDd//5lMujm/47Jvw65+eMhANL87AJS1NC8iUo4njpYOUnVgyWN0wyWPes5I74yXj2NPWjtVUsZ2WqLrk+qrBSM3u7gGV3uGv/rMXzCePePvhmPt3N+lnmu1xxuWkoS9iyuB5406MSXqs8huEK1jklienFcQjtpKIs7MlL40aji41B3JOsbI83HT80sMzHl8lfPhCs/Ln/M1HR5x9NKH1PbxPQCcIWxJ8hQkVyitc67p3bxB4XyKEIE4TfBVAGxSeKvfECHq24PJmjs428Acvs7x4jpzXyL7HN31+dDYmugwUK48yFSK0xKFPmsRI63np1jbZ4RaP3nnEqijwOCIdI00fb1e4tIdRhixJ0MMere1mKcnWiOaixDQl3moEGqcEKjK4OEK2La3zyNDghGMYblMVYwbZkt4oxtHHNzl6IJCjEaqZouKaMY6V9NiNQz4nL/Des1JPqcZDTs0BaWWhuuZmOoN+Rj2LuDpMePmL2/Q1LHWEDwVB2E6xhYYgUEF1sZxtjaw9Uc8ykIbFsmA4lLimjzHg64YgarAKbwJaGGxTQQsm7uETh9Ajji5gJG4ojaJ2llm9iXIQsltE6Yjzk5bq+QmZqfG379FOCkJ2C5kMEFX45LP9k+rDv+rxPxdC/I+AbwP/qxDCFLgF/O4fuM7x+rKffAhBlA5IYkNwFikFbduyyMvObj/exHrfQcKaFudbpKzRtiWs6YQoQZCqO+0MXd8eQHrXwdOE6EKqhUQKkL7rySsliYQglhItO6bMH36sy7639K7nbDSO2LXUodO0Zwo2E80ru4Yvf26fzS2NTjTSgDJdD/vjltH82vHt37vg8VnBooSLqqVxHl3VyJsL2sWi20mvW0p/2PosACMFiRBEUnZDUi8JMuC9x7m1Hh2BX+vRP3kla059kGtupQgoARqP0ZIoiVBSdcHMxjCbrvDeMUx7Xd8Uj450hxhWkqy34mpZ8rsfbXBU7ZBN4VHp+bNvVpzOMrayCb98eMwyz0lHLU/Va4ixIZxU6OBo12cbzjYI4XABSluT9GOqRUGUKnQ/htAQ50csliU/eGKYfbhiW2q2k5KqSPh//q0btJuwdzvmh2GPCT1EgMHikl97e8aX3tA421CJEYOx5mSuGW5t421NvWg5X1SM+5aHL91hsqxw4Yp5HTha5hSF5Pb+FkM9Z76cUzVQLFs+yCP+1j9+wXuXCQeRQD0MvH9UIlNFS8FZbkglHO5ssKxa3j26YRi1TNuIahH40v0RH76Y8rXvr3hr54ZpqRh6uDs8Zuk2+ex2yt/5h1M++LChF0pOqxuWtSOEIU4JJBZfLcAplGqRxtN6gRAN8d4+o50BwTpcMKxsQjNdguk2OaFpcK7Ejw+IiwPUwRYuO8S0R7SlR7iISIwwe1vU0yf0NmpaN0PPW4yD2VXFUC348IdnKG9AKFQBbSK6wW3wjDbHzBZzrJREaELQKJMQGcFuv6W6ABs696wIAik6r0nkoLWOxAS08bh6SXXl+NyttzjzDiUCzlWIWCJ2U3bENeP0krfu9TBRwixecrA7Je5BuigY6ys+NYaj/Nv8vZ2fhVmf3/6dM0KU0eiSflZQXjZc3wTQAWMTPAqtBVI7Fl6iJBgFNA3alfS3EoaqQgqDieIu31h3bUSkRmKRckDaz2jSPmq1JN4Y4JcxxmimswXtiWJKRuEHxK5lWZRouYUdbaDqE7RvEcRoM6ZNBDYb46p1HJEQf2ht+Pj4Vy3u/xfgP15XvP8Y+D8A/wF/+FLyhz6+EOI/BP7Dj39OY40xmqAVwQUwiqqqibQBZZDCI0QXXWeUZtXUCAK+dZ2+/Q80MNZOe7oIO8l6w/6JNDCENc9dCnxwxHKNGQ2e9g84eiWdQ5LfV18SvOO7R8c8ShKqqkEJyU5q+NRej0/dH/D5z+/z8796h8GhRKQKEUmEdh1eQQmCDSzPHW9+7YQffuuK549qvvLOKS9cw+liwd//0Qcsigr5CY9drgt86Lr3Ys2ED5AYSaQlkeg401prpNAgHSg60LCUeB8+UciwTnASa3OTRXYzgiDXyUUW4WO0ligp0QiaqqC1FqM0cRThnO3+GAqUVPz86w0/9/mKXr/HP3gU4aOISe8212LI/UhzUW+z3buGAnbVCfeM4HH6Gvcejpm/q6kcEDzOQZJoGmspXCAJgbpoSXTAVjFathz0pzS5oLAWVeeISDCrE559BEIXDPGcnV2ycwsGW33e2HN8+Ys1w8hzXg2YVRk947laGIQZcC9ccTW7oqo3eLC1yaAfkbeKd16seFzvc9hb8fO7Hmk9y5tr5iHHOsW9OyPyIuJv/KMpV8sR29GUX/jSLu++aBltSoxI+OoHin4Pxpnn0XefsWdq9voGl9+AuMOvPuxT3XzE08cVh9oxvfL8+EPPS/0z/tnklJvpJe/+rqNmSDOZo2VBOX/Bzu1bXJzMCFJ3jo/KdmazEBNGu9x543WsHFPUDjnQlNMlg8NN8qsaNa7Y2N2gubpgMfs2tl1g53OSzUNK2SMsZ6S+oHYrEgnx/ghVnHPtAyrKcHVOYSOIIbQF9WLF/oNPMTk9QrmC/iCh9R6TRUgRUzUVIkiMgEx7VmWD1IKgIqIEot4Q1xTEytIIgXUKiad1bZeDUDfIxGDTmDpf8Lf/6u8wzz1hVWEGhrbRpFnKX3zwmFcfTLi7ccUgDmxvGTbGBS6J0EFhc8FqXhGdVGQbP6IevsL2B2MuFy3KK378nW9z/XhKlRfoNCHIQEtAO48xiqQNBC+QsUZZj4wypGuJkwwRgXMaIR3SC1xQnYNbRiSZxmNYLVdEG1u0AYJULBcN2gqywx3kzQqvBKLJSbMhQRUENohsg/WXzCYjNl+XqNEISUtoW5SNPrai/JHHv1JxDyFc/IEi/X8F/uv1j8fAnT9w1dvA6R9xH/8Z8J8BSClDEiVoowneE1RHcnStxQZBpA3OW3ykEMHS1O0nNn6pZGdOwrN2quBF+KQoiz/QlpDr1oSUsiuGotNyayE667rodNsB0Tlh/8Cy1OGAu1bPbJVzna9QCPpCcS8O/I//wlt88Uv7JBsKk3poJcFDqBwyVchIr+ehJf0MfuHL9/iZ12/xjb9/yqPH10zahpV1rJadyUSvm0rdbHctWySs81A7RdD2xogNo1Fl3mGKrcUSaLyl9a4r7mI9SP1kyPzx6vVxw6kb9BoUsQ84PLJpSIwmiQwojZQCZy0yBFIToZK08xQIiLRmUu/x7tMeP/hI0rYCV1QMd0sqnXFlb4FSnNcNW+H7NGLE/q2E5xce0RictOD1J22rKI4g0/ipo6wDjRVUy5oy0qiexDUFzml6yhPpgnqeE1lPfzNhbxR4/SDitb0eWTrHm4aXN1ao6DZWHSJKz2xecSkcwzRlOy25zpcs2OD13ZR+JHjnec4336+5ZMTLtzWTsyumqeVwfw88XNwoDvYMqyLw4iLnrEjR4oIoHfGP3wk4djnMFKsy47WNCfbD5/z2uyecHl+RANo4hqPAG2/dZab3OJ4mPH9cMb8857oeUpYNM91i6xGqXdBXFdiSYC2NWyGCZzlbQL3EBo3TBo3ARhFsvUp8+00mUlIhaJXj+qILeL54UWOcxTrBxeNj3GpBtL1DNS2JhaQJS4QbMUwz1PWUWRPTOsc4dUxOLFJLlosJUbOiaT1npznjQ0UTElIJ2UZGfpUzn+cMdsco55EJlMsCqUAoRyMDkoCSAYRFtC1yOMAuG5T1xEohrUC6Dq/rQrdrVmTYYkEaWj786AY7BBUceqUYjnf4c5+d8itvV+wNPBuZJO45ksQihMP6mKsqJZE5vNRjMNzif/lgRHkt+E/LbX7j7y7QIsdPAkc3j5FSItsEr2QXGB8CzgWMVLR07U+lDYkDjcU7R6Q2kHHnp2k8WBE6lLJ0naCiaYiyNb+KgPagypLtbcfWsOLDZc2yKahsS6sTXhnMYTSmWFoqhrjTGW09IWSv0EwuUW1E6leI/1+Aw4QQByGEs/WPfwH40fr7vwv8VSHE/5FuoPoQ+Na/zH0OB6Puvul2y2dnZzR1QxzFJMYAEuUtwjV4K1BZimnKLpnIexxdqwH453a4Lrgup9R3yUdCdkPXj6PuCAElJGmcol2B9GuZTQifpA0FEdCiMwB5ukVF4IkQDIViTxm2expb5ayuVHcOITxxpLrQD6O6x/ShG29agasamtrSFzU72jMSkuYTyaTsdtaqmxe48PuLlAcI3WJTFxW2l2GU6Uq1YD3EVXycGyXocMUfUzARAuG71CZkh3PAe/w61MN6D03Lwq9o2hahDU1T0zYtRVkipOyY8nTzB2c9v/neiLejPS7rIcZI4sxQTxooS2bKkaWKECJqodgdlvzyEwpBbQAAeJ5JREFUdsCrCR8eNYQQE8eCNgSC96w8KNXF7K2KBuEhQpEaSes8j5/eYLZfoq5y7GLKliyIzRHZ/oiNuAITuG4MvWTAkIYgN5j4LXw+ZTsTfOZOjAuOZW45v7acVGNE8Lx7OmVCwkk9xmrY2azZS2ds7NYc7A24nhQcXQZ2dmK++ruXlLXAmQzsku29uzw+i0lGY1ymmTQrwoe/zW+9/y5nM8lomPHag31mF0uOTmc8+3DBj3/wY46f1zRym9P5mDB6BS1jtlKNambUkyk8P2N+dk6ItzFxjF3OGKYJzXKF9eCiPpm2FB44+BQ+3WW1rDBmiCurLv/WJHjpOrWG7dwTTTEjvnWLdnZMJDWjnYzQH3JkBUkyYOWvuve4KxHLJUYreqnm/HqGNBDyHJlYCDHbe5s0iyULZ9nfyHj+bIa9njO6c8ji+oaytGSRpAmWtl2gkwwhBYulxLmWzAhsDFXbbVqCXm87pMbrCGUSsp1DVjOL6Vn03iHLySnBSgZbCQ9uz/jzLy3YSWNCSBD9Bp8EVqXDNjVirNg+FJjkkKtiSBQXlI2l6U95eCfjH9oZkYtwqcEXbn1aLFE6JlhLEBXeCbySiDTrtPe1ZRkX7NDNzIRvyYLq8AS2QbQVbUjQSlItKkw/gtDgbUzRKpyW1MU13rbkfsmyBOFKQmSR7ZzF2Tn344yLYoNabaPFDfboHPXqy8idQ8Tygnp+8y+oP/6bx7+MFPKvAb8MbAshjoH/LfDLQojPdmWGZ8B/BBBC+LEQ4v8FvEuH5v6f/bFKmfVxfXGJMQbvHHjLzfU1rXeUecnF0QmehqIs8NaC6NQmQxnwJunUIB/3ptdyRyklTqwVI0LihQMXOp287wp28J3RyMSGBwe3WD5+QmmLbmEI65zR7oVhZKeucUAiJSHQDaNUINOB1nkmyxYvLVJ6EAEtu7MCI1XXwxadi9Y7cHXTJUE1ikwKRkqyCgENCClZBY9bu0gb3yVNtXyc7tQRKG3TsrQL6PW6hUqqTzT9AfH7MsoAlq41I4QiyTKybEAInmY1J7QNbdMyuZzRCpChQwkLIdEmQkqNtZaPPnjUBaGIdYsKmM/nvGh2mBxvU15cMs4M8WgLGzu++ThmL/G8ej/m7sYM48ecLiwb/Zy9rM8PFjnSCFzb0AaQBFa1xRYtRgiSSFCt3w8iGhGcJy8cSZ0jltfURUMvqkhnx9zqvcQq3uNGKlS74qZIeKXX4+vXgcdTy8/uj/HVFUuR8NE8Yb6o2YgablYts1XE6WyHaaGJjKVNY9oQMUrgy6/FPPrI8fe+NmcWUjZ6nucftPwbv7zD+49u+NM/e8D+4RjzYpu8tTz97g84+dZXaW9u8PEm/a0NfuZnX+LpDx/z4sU1drCNDRkB+K1vXqGTnMM/8TJivEsTIorpC+wkx50eIa+OoXUEtcKaLg1MRZJV3eJVhIoy6mZBdOfT1KMDXGNRscJWJbauMLFGtBXBWnxlaZXDzxfEm9tdcHTespovOXv+lOHWy8TGkdQ3TIoJLkjqlWB+PmMxW1Ecn3Z5qyKlN5BEUUB5T+tbZDbApLsEv2Azt5ydnrNajUkTxbJRqCRCOEFTVUjju8+khNA6Qr1ivNXnoi4Q0mBUDy1a9FrOq9OUbDDC9CNUpnHE+LIhUZrRwSaDwQnzYgAy4fZ2gUoMhXI4eUPc6yOTDF1ULFxEImboWHMm7pKKBTRT/HiIWHiwDmU01gtc50JBaUlwhqAFWmlapfDdnBrXSCwebEmRLxhmCWmWIsMNpQcRmo6+2VhMBciYPK+oDt5AbN0ifT0QPf9taj+jKSJ8K7DLGU5HXIseZ98/Q1tNyAZUeUnv6glbL99jvkppF0f467NPNrP/ysU9hPA/+EMu/r/9hOv/J8B/8sfd779wGxaPH2PWUXNOeIqm6Taa3lFNLsG2aNdRCKUUNN5htIRxiiUw2j9kc3cH5zwXR8fk0xkWjxWgleoK23p3G0K3Exei66ojHGcnJwhvUXKN4hECpSTSdxmo8fq2NgR6gBed5LEnBYlSeKUwiel2zELjCXjBevAhsaFzg+I7rbFUAp0k6KRioA0bxrIkkAWPVwIbAl7IdYJT92HwQaypOnRtqGAxdKoWT8CJzplrvVjz1j926Yr1Ph7G23s8/NIX6G/fIl8tOXn3e8wff4AKjlhKhAzEUuNl18KJkx5lMBR1gxaQiIDUXYup8Q4fPPfNMXP9Gn5zn63eDYN+yconnD655PCzY6bnFbupZjcRzOJX+MazjJsrg8q20GlMqGoiExEc+OAIfk1vHEWce8fW1pjJoqQ/6nVy2aYmNAtqZyl9y87ynM8dNBzVM+Z+gE5TZo1hrjfwomG7X/P+TPFjv8PpBJ6/e0Y/TTm8N+JsqlhUnqAT7mzM2evnnMRbvHW35W6/4FuPHP/v35YItcFgMGC+nPOlP/mQhCv2ho7ecMjf+NvHPJu/YPbih7QXp+BSXLRLOhzx4JVb/PjxBCcSRrd2uFnpbqBvDN4nuLLg+nv/jPFbP0Ob9mnmN7TX1/Tqa7QJ1KE7q/LFjMI6irlAW4nyjsZYslufohnv44UgSLDSIYqyyxW+vmFzKFg0QDBIqWk2trBRimwbtNboULPhIa+OcJeWy9qTuxSrQJULDvslw8RwtjRYK8h0y/zSs0zBDSDbuI3+1JfpRVtMHv+A+fvPsdZzcnPJnc2UxGic0p3+O46IBj2sNiAF5TxQzyrqEOMxOCeQMlAqifGWKDNY2zCdTnFIZquWjTRHyxKtU/LTcwavZvTGDbcHGVrDYnpJdHsX2UxQpWMVNaj5NZNhYKtZ4tPbmMiijGVyXpB5Q+kKRNCotE/berzvyrtRglLHiEgiPeA74YKWntA6civYwOMjBUHgdUITeihX4rTupIo+4Jc5Zifj4Gd+HXPn5wl9yCdL5h99n/nqnOWyJiFBW49US7wQRNEmaiSIOGAZPNPas3n0lJEriaonnDTrmdxPGKn+VDhUAaauQqHAd8oN6wNKR6AUy9biglvrtT3OemzwpDqhDZD0B2y8dJdbr7zSZRz2Ep798MeEvCDQQa6ElMiw7mCLgFPrlgsC31iKou128muEQcCjwseySU8sO8mlAjIJXihMUKRKoJEYbTBRhKKz/q9T/D5huoT1QNPjCM53Id2uwXmLEYKBVPRkIA0CKySJVDg6Lo1dn0HYAGqtfFGIbmYgukXHh25nbkOXDu/XwNyPV/cgO+Jmb3+bF5MJr+zfw8cJC9sSpMIFz6SsKaRFO4FXAi0VaesorSfYlpsWrgN4aZB4nO9cwTjBXnvNeH/M2w83aITkd35QkMYpRxPF/ZdXHF8Erocv8/Qm4fGRoi4dIzMiyD6hnYG0BCExkULRIIRgkMSUaYsyBltbfOiCzyWCtm1oQ00t4OZ8xte++mPsrU9zYnYY7/V4fRuMkVRFQVTnTNU+T881y9Mr8kWgJWbyVLKcVKQx2GrOpT1nsK/QY08YKL57KTg/y0goKGzEybXl4eGQyxcfUWvHfGZ5+k8WPH96wdWj98iyiI3dO8xWHqkSooHhet6Q9UcMxxnnz0+IlhOiWLCct0gdsFZStRWLZ4/RGxvImyvU7IKNnme6ENx/8x7H5zWrlcOP74LoQZvT1jPU5m3qbBevNaFyoCXeWZJBH7dYIV2LDwZXe0hi6l5EEqXUkylCtjTzKU2+oJo9JVZD9PA2xQIyt4fTC6q24ObDjyijTVzdnb0W10uiXoGelOSHAwb79wh6k1xGRPc/z92fveLF136TYnbNla3p9UcEGwEBhWJzM+N6rhBInDUE5ynqFdZHmDRCSAVe4YYJOokQkUKZmO1bKYvLkrqYIZRmkAruHgiE2mBjEKgrQ5WV9AfjDjxoLU2zQi4WXe7B5YzrNmIxTHDxgOvFgKurFV7UXULZqibqdyIC6qZDnFgL3neDXaUIUuKJO42DF7QuYJQkEQphOvZS0jPUlUAbRdkGQltRrgo27t0h2uxR+ceockyzuYvSGXuh4bKpOoaW7mPdAnzLKBM06gCVgjcHVPOa6cUM1czxy5KmkX9cV+anqLiXXXi11Hoti3JEOIJtmbSOIFzHdPfukx0wUUzjHFppRGxY5Eu888yqHJ3FtHnZqUXWziUh131rEWiRWK9xdIoQLSXSf9yP73oOhi4OTiLoAYmQNATi4PBIYilJpUQF8NaitMIotVborEeEAYL3ne3bd1F63n8sRexYMZJAIjvVS4xAC0FCF36t6BjXIQg6/2m3VishMKJr9QRYg74Uga6NE7z7pC8e6FpQXsL5YoqRcHl+ipGKjeEGF81TYul5/WADHytiNJWzRMbw0u090AlKGFoXOLqZ8vxmipIWb2uuJgtUEhPvbPPkqKDyimawiU0t7vqEKZJvVgkHGytWVwl6o491MxprOJkpnEowWuGFwAlP1VgyBU3ryOcLbo37nC1K0sh0Ek8bMB6aZYl0LdZDVTecvPOIL9+7S+0zVJGzLMcw6QgqUX/A8rQiqRzLVYutJe00Jx4K7uw5Ully8cEzXj8wZKMdrkvHN94p6bUFwtVcLySNb8h6GRfXhv3Ne8RZzQff/x6JesL86TNUPGZ0uIVvZhgTaIRl3M8wUcpyNqdsZiwKx2Bzj0p4RHPNwYbn6voGRII9fpfmqo+rK7YHiuAtVkjyoqWyGrn7AGUy2sqimh5B97FmiIwjVN0pl2Qv7UxnTaCpGqKtMXlTE2JBiDtTXT6bdaaaoFBphpCaxbykCQPCQY9kyyCyQFKnBDfn+HgJUUHUy9DBYpVDVjVNO2VyfQDn5/R3X0e2GY0LVONXSEffpZhfUDWOTBmCBOcs3mnaBka7e8yxxIuSm/NzWl8SwhjXGOwwITGeoGOkEQQjEVoyyHr43HJ+OSMaBFblgtOzwGADvv1BzJ/8osCQILIB5fWcmJR2AN7nFE2LTzOa3iaKhndelDTFHebFKTrMcUISYgjZGLFYoHFICcIBIlDTIr3vtAlKELzq2kuR7tQzxuAcWDzbm9s8m5fIAFZ4hK/wocHlgbYtqPqfoxIN3m0jqilXRzMSL6l1jbAx0WCIChFqY4e9B6/gJgWHY8nFTcHq8SOsh0Gyw0g0zHLZueH+iOOnprgf3trDrCPiXjm8zZ1xH+9K6qqgqHPeObpkEEXcHWXYpqH10Gs9xrdIbYjTIVXR0FQdwlXFMW6tnQ22C3R26+KugCLpweYhy9UHGGqQH48gFS50OtpBGvMnXt8j04LMSPpGUVSO9985pmoCWoAOAZRCJxE60mhtusAPOpAZgU7WuG7HdLt3tW7qe0xaEaRC4lAeEiVZ+rDW7wua0DFuPOsFYg0FM8qs3bhdb712nspZnFC0XtKi1qauNZKBgIgiNrc2iXt9ivmUxXzGeP1GTo3klokwkSaSilkNbRLzhdfukxc1Wzu3uJov+OGTx5yfnjHKUnbHI+ZCMz0+58ItKWzM6mmMDRWDvuPn3u5T1wXfe7ekqXvoTUjjli+/JUik5aNbQ77/ZEXlPFIJTKpp2xapPI0NKG1Q0rNY5ah+j7Jpu7MUEf6/1P1JjG1bmt+H/Vazu7NPH33c/vXv5cu+mFUkSxRkmSJhGxA0sGEN3AACNDFgGPBAsucCNBLgKWEPZEGGTdmCaQGkSJVVVWQWq7Kyqcx87X23vzf6iNOf3a7Ogx35ipBZScIijdSZ3ItzI04Tcc+31v7W//v96A17mBuJdwEjHVcnV5x8+ku++Ts9PttK2lFJkvfZ7WneXG+ZLzU3r2bcnBpkljKZSPJcsrlZs3aS47ff4t6dhn/8s4pXb06hXnH3rbssbISKBR/fcQwnjlXZZ3a95np9w6inODnfEO3fB61YSoG2KSoWJFFM1UquZjM0XaQ3H0VkMSxfXkO14qquiGNFHHtWJYQQEaKMRd0SkFgV8epCIAf7yMEOVdkiVaANNSEofBxjW0sSazQaVIKMY7bLK5JxnziP2R/B3OVsixqz2XR9bqUgjlFJjNQJQib4bMzk3fskccZAGUamod22XE5ecPrymn6jOXq0RzNrmF9oQm2ptmek7mPcdc3oYAcO38VWBUWzwSMwZc12uyIbjxEiIdGem8slh9/6bXI3Zf7lC6xp0DLCKQehQrktRqTsjWH49h1cWGKTPvfzPu3+iMvfWxPZiH4K7dLh6pIXiwFvbaY8kjNUco7wLXG2D8RYsyTsZSi1h12vcK6m3Agm/Z1O7GMCGSWLKIUkQ9oLhK0Q0RRhDZqACd1pWxIHbNP9HxREOG/wkaRC/jnaZDyEeIZturROLTN8Ai5YrooBKhf0bcsm+ozapmyqCBOBtAVBZeT7Y4r5Gg7v0dufkPQM9+/sES3X/OzLJzCz+NhzNPGcKfh1eJnfmOJe15bZYsN6s2E3H/LXvvNNIuWpNwuqcsGfPT1Heou2C4SzGNsVSZ/FtD5wennNyetX7O0O2dvboUwTbPDIzs8O/Ir3olDCk2Qxk6N9NhevcWGFwBFL0K4DYwnvuDNN+Z//mx8yHgjiWBNFgtNTw/XzGTfWYDHI22RL0xqqxiGqwGh4O6l2269XQSJUl7G3LnDxesF2XZPmMdvCcjtv1LVcOtx654CNJNp7auu6XXzwICRCakLoily4VQF6oXBSEoK81QOK28SQ6J43BJSUJFFMFCvenLxEa4nuTzsCpe0Or62UuEiyNZ5Z7UFEjIcx1XaNqBsiFeFs4Ga9ZbkpccHz5syS1M9wcUqtEuLegCYa8rjo87vvt8yKFZ/9/IoPf7fHi2ew7mtG/opmWzDME+Z4MB6ZdZeazgqUllS1BTz9PEFJgTGeWEjSOO7Y+k6CbBnkCatFxZ/99Ev270x47+GHTOWST06P+FzusJwNuDxbUW0kapgy3MsJbcPJaUmIJuwf5ewcROhxzXsfVLz7wRFXi4rFKiCalunUMR0bZouGWM4YRC2L9SuwATXZJ4on7IwjmmpLbSFJFGmWsV6t0HFMpCQ9WtbLmo01GCdAWiI9oGlqdD4m2tnF6wxra8ASJymiMjjjCGmfxgpIUpRxhMQSIo+IY7QEpyWxypEoojjFJynkKSqOqJIEW3QwOSkCDoiSFKkklfcI53ChhNUau7hm+N5d7kwPsNsLdvY0tcq4uVREqmF1tsEtLgjlgqzfZ5SOmdx/yDwRnL1+g1xtyXotcTRg6w2x0sRBIuMewlm8Tim3JfX6FK01RevxAmICJhikFmgVsVmXfPydXQ7eyhgd7fOtt0aMphv+zn/2jM/3I/zWEOkMk2oGUc6jHTDbhmQP6nUKaKrpmDxERKOc4DXuZsbYxLyYDTg9d/QHM7RzWFoiFVBeItotsW+xrkYm+9j2FJxES03wNcGAk4pYxFRYeigaG3CtZ5iDFZrF2rDxGcIV2BgsKT5IBg/egeGUzHxGtV4T9d5GZ5YrDK0XDIRlG1o2yy1JpBFuw5iKe/sp8+IN6gJGSWAbe6xY8+J60QlYfs3tN6a4vzk5x90eNAopub6ZkycxeZLR2jU3yy1CwKNJD0lAu9uihkbFPR689TZKBXq9jN3dKZevT/G36AEhupRJFyPsdsVqs2D7xU8Q5QohA0Ml6AmFwVG57jA08i1JWBOpPonWKG1xtkTivkYJh9C1SKoqcHVZsb7ZMhqseOu9I+IMCN0IeJe6ETSF4fGnJyznLSoRpE3056AzukZ9hCQToku6/6pII2lvo4y/yr5//QIQXw9nAQRncdZ2h2xC3u74IfhAnPZ48NYHHB4/wDmHNI5Xnz3GNYZIaSLVTeWZpuFytuDy6pqj/V18cDTOMF+t+NXZsLkdHTPWIJsStzxFJCmYXQ4f5BRtwqcXLT/4SwNmC0O/nHG3t0spxly3+4SgMP07GPEaFRxt3XYKtcKQ9RTOGBojEJFGJoLQelIVdaKR4/sUrz9DUGFdIEQxTen4e//ln/Gdv77PJ8k+L6+vKNavGdx/D4Jl/3hM03jqeUFrBSrq0ZPnRGvPL98k3ByMGPVi9octaa9HdTnn3o5iMgl89menVKZHnkc0p7/k9MRy9727DHsDai/ZzNd4U1PXLXv7PXQSKFvP/rTPZtuyPFvj3G0kV0u862GsRWRH2PwRSkmMrQk6wcm0211nCXqaEnRMrAQieNLgKbxB3UZ9ZaaI45i4n5FNRrRFixgMmNzbx9dbMgWeFh86jk+UC6wJiCCRvnMTN82GKMzIV9fY5S6vTMk4nlK6ObiWplmzwDCRLYmIkHkfFTk2VnATJdThIdI9Y2/nHj6bsTvRLF47nNcstpbeiI5Y2cuIMs/mzQy7e5dt44njCBEinBAYNKZuSHtDnrw843sfrzjMv4VdFFwVFV/89AX1zYaqgWoVkGHDi+U+f2Nwhydvrvnlz5fcv6O48+GQMJvw/t0RuciZn78hixRfPhf8g58Jnny1YZ1+xaZt2NqGnbxH2AQiv8a3C3QvIcolUaVZmwrIsL4l9h4Tujy0QiMih5EC4QWt1t3vV1Q0vYxgajKpcbIkyiVG7rPXN/QP3sIpxyDOWFwf8PRPBbbaUOiceF8jpvvo4hJTXmPaXda5Ynz8gDfXN9RVhXIOZwWuNv/t0zL//7r5X/FggmC9XqOjBCG7bPbZ5TVlWWGSCKE0Eo/EE3ygsYbD/btEcZ+D/WPywQCNpRel3NiAc/ZrHorv/NsoAb0gkJHBOgM4duNu4uvalBRfDxBpvMh5/GaLoMCahhevlqxb01me6OA9y8YyW1iMNtycbXm5vWQ5K/j2Dx7Ry7tYZvDdCv/k09dcnm8oa0hSyXZdY5zD+a5QSvmrxBA4H2huM+hAFwENXbsnkbprOQEQcM5hrcUFT+M8jXWY4HHcDnAJyXQ8QUUJN1czhBI4D/XqhiC7Hj2/GvISgkES8429PUaDDCk0Wsf0Esn3Pngb9fQVry+ukEJigye//y6y/w7Nm0/xxSU+zdisK3b24dWn5+ydPuN/+Jc/5O/8oaMsTpke1WxqRdvENGKnSxNFXWZ4mkasihZTB7JxRE/AddkghzE6ixBFQC1ntLsF5H1Ss6KnBaUSaBGzWJZ8+csXbKOE7aoAJanyknhnTBMUzfycg9QyOUj4xZ/+IZcvv+TSeGQ85CKf8NF3PiI8uktPVTw6cKw2gZ+eOI4PvoHezvnih3+MNJa3vvUR6V7O9rpgu7wkUhqHoTdUqCBYr1oGSUJrHNdnBdZEnQg9GOpiQbVucEyIDh9hZURbbhBJhLGCdNDvDo3rLVHa8flx4I2jkYEgFdb5blJxUeGnkta0pLYlynr08xEWwfH7R1w9eUPrAm3dEPcG1OtFZ2FCoZy/hcY5nF/QrC/JVvfoDR7wzvsjXt0kXJ29wVoJ3jB5tItfXrBd2y52q6dEfoLVN4wfvs1y8IjF6xJZdWdPTdpB6Bo5JMQptWtQ9Ii2ho13FI2nn8RMpnvcrCq87VqiNYGwI4lKR1WfYorApRe0bURMi1ESkgmt8VyXLb9cRySmx49+/5LjYca/PfG8f9hns3VshGEUOS6aff7BpzN++NzRWIVxisLGNEYhVYSgQePx0tEbTynaVffJciBTsIbugBXwMZ3P1AaqTDPo97A2oXUVyljMusI3moAiotsUhmzM9UYQfI08POL0/Bmz1QA5mKC8xScKh6Pfh6ZypJNjhtOEItQkSY/s7hHZ7oBieYNV4Nvo1wVlgN+g4q6EAhl45/5d3r9/B9NscZWjVR3T4fvvPKRerpGio0KGX4HARGCznqFOX9LUJYvZJaO8U/aJXkYomttc+58PLYkARnYRQ3s71RpLMN4T8DQuoAi0LvCHP3/N5XJBEmv6PcWmhMIYjO/SKk0QrFzg7GLL9WLOotgincI8vmQwGnD4aMrOtEsLnL684fHnZ6wslN6RGY9wEUWANoALHVjMeo+/7be3dINFXb6gm/DzXQQH5wVtCDTeYr2ist0wl7Fdf75bHDvEr9Ka/XvH9AYjtqslN9enlNYw6A2pbbdYoSQm6nqHad7jX/2rv80wgaK5HXKSgm+89RZnNyteXVx+PT/bbm/I83skgyFVcU5YnFC8Tjm4P+Ho4RE/+vELtsVz3n74LebnG3R1gmsTfvd3dljtJfzez6GSEWkk2d8ZsJxXBNeJvfd2R6zdEqkEoRHUZdlJy1kyPTrCnp4wHCY0ccAawWjlsYszGmLKxZze3h2UddDC5vqKXDVM9JIvfviEelGgs328bghtA7M3fPX7z6iav8kPfvAILWNWqw0yQHG65Pkvf4lsK0ZvvYfe2acWlsE4pb+zx/LyCmEFq9Wa7U1DnAXu7WYstjV1VdJLY8rSoWQNbUUrc7Ld+wz3d6m2czAQ0hShu6ipry3DYU4A6m2LqdpOMi4FsrVYHxDeEiuPbx2hamm3Nen+FL9YokZ9Nq3m5mKB1inZaJfV4gRbVggZQxD0shgpHMo3tEjiyQ7x0QN2di2CZ0iV4PoHiHwXX9TMFg53umBbl8hpn4MDweLyBL3/NqUtSd58yYO+4no8IkQZ2iuczmnLlmTaIwoZwmpcJBhPas6lxClHISWb4PDBkgdNkCVlM+b/fnqX3kXN7rt3yNKIRt4giQl2ixxpbEjZmohNESjOKoz2zBdLfvh7Y/Z2I4Z7Hrvfo67u8sMfBf7hTxe83jjCQJNr2A6mBHqUNaS33mMTxyRZxnzVdrheBTpShEZg6QYbnXFEOPRmiciG2NEuOo04uyooHUQqYh4kkVMYk/HWUc5eonFiyPrpH3PxU0t6+AgTHVOP7kINMoF261nMb1Bxn6P7e2yNwtYJ5YuSqrHsHr6LmZX4s5f4EPHfmSikk10EcjIYsT+e4BqDjkBLwf3DCePBiJ/++BOMsRhnaVyXEKmsQ6UJ89kF8/k1O9M9DvaO0WlG1u9xtdrcGokkznXoX307uKt8wNxOsfogqMOtCFpqhLdUreHJ6ZJWOSbKkwiJl/o2ftjJP8oACQEboKkblmWLtxrXSn70s5fsX6757b/8TU4vt7z69IqzVc11A5P9Yy5nC8qbilonbETVRRgDSCk63+kt4ZFwW9yFQLvu1xm8xYtOHt0qheiNsTrupnMDeO86nvst/jgEaIzj9PSE/ngHA8zn19y58xEXgyXGz7CbDcEahIKirVjM50TjmNlii/Edua5sLScX5x1RUoJxkI9ivC/ZmQb6h494/WLO4e6A7+xX/OizC6LDD/jhZ6e8vfo5/9bfHHPnKOE/+eGAX5zEMB/jhUDrgA2WarvpoGiAai2Xy5LGBkZJhBKwWEOiBVl7TjI95quv4PJqTbQzZFG09IWHcsN4v2S8u4OPdqiaknYeSCSEzZrHXz3H1Bqdj7tBrnKN9CB9TVNuefnzH1FGI966k+OMw7x8zJvzlwipOHr3fZooY1k5xgc5NhhmV1s8MVEaoZ2kKJeIrWPht+TDFJkkZKOMWAW224qiTdDjPaZ377C4mmOrCpTC1Q0ii/HWEWlBJCOqYkUeQxkErt4ifYa0nl4i2ZYF9GPSwRCnElonSUyBcwXaxJQXN+i4j6sKnGwQZQHOILzDh5imqvFeIJVHeMXOo2OMUixf/YJ3BinD5gHHuSJ67yE3n89oQoSLHf0oRU+PaVTOuHfAk08/IxaBRx99n+O+4nrjEFGf1kcoleALSxstEGkPLVt80JjKkkymyO2G8vy6O0MJBpELnBGUzS6y3iXba3lT7WJNn6s24K3Dli3JcUokx6jJHqsipWcDbBwLUfLZacH9l46PxwnTasrf+/mKv/9ffoG7LvhwJ+Wm6nMqDaPDh2Tpc2bVAh1H9BJN6TqBjEj7sF2CUOgkw1YlzhhUnhF0iggSu7lhMplwHiaUccZ8NOb6umCwn9CbCmRoUeucrZDMnv2M4fQ97Ogh9U//n8hJj/vf+ks00Yrzv/9HpO6c4DzmxSnTd99ldyC4enLJ3RHMNytKv8OllfT2R9TXMbb61TjjfweKe3Q7FXpyesr79/bI45jWKEoEw7ilLFuW6w27eYr1Ei8E/d0Dkl6P3u4h5fYKcAQBz148ZzW/JuoPmTwadMNKssuqSgRKyO5PLYi2G25evSLPI2RjGMuIclV1OybreXOxpfIGu9+jn+9Sll3MSQvJKgRCljC9t8+6KsiGmjZoTIjYrNdspEP1cz57vODpq2suT7fMS0FjIfERF4XvxpxHKdfrgs4SJbtiriR5mrDdbm4nTX81ewq9JOZod8LOaMgwielZweTDb+KVgtsrAHc7yeuCI3hHEhyTfsTV9QW90Q5Bp4xGE+IoZu+d99lsS9af/5xmfQVeUtvAxdU1o94uR/t7BGKsEFwsluA94yQl0pqbskQtL+h98C2y/oi7RxnJXkEph3x2Irk6NbgkEPIpT1/X/Mf/yQvu32nI3/k+Nzwkyq8YxApizaIyLLcN3ntUFhOpwHxdsfGCQykpNluMd1gvuLq8YD/uIVXEalVi6xWNitHB0a9KjnsrZiLhSoxoSk2mJLq5ZvXyMTrO0dMh5ewCEVqkMXgbEDJDRENEuca8+AWffOVpLs8IxjHa30VMd7FJj91hzgpB62JuZnNiNI3xSKfQSZ985KkXl1SDIzarBV60eNuyXS+Rg0Pu3D1g7+FDtusCEWvyNKdV4LYVSnpMURJlGTbUTMMFzbZGugmomCjqTt2lqdCmwlaCwfQAkQ/xxYpmdonUKZEtqVtPFmvspqGpt/TaLdvLJ0ymQwqmVNUK6NqViYi4fnlFNRyyM7rPVu+wqS9prSWoEmEqFiFibBr6d48x6R3kw7cZ7e6QvnqCbi2xL3j+i1+ytlsm3/gWmRox9yl160hGMb2gmdydsrCB9O5D7MkJcuPJ7uww9SnXT94gYwNuCcWMzVXEc5Ux1A1Hg0tuzJaNMUjR0s7nJPe+ze7+EW/OL9i1W/S9t9k+/4zr9RV/9LMjFtkHOC14+azALk8IznFzJXjw1w75yU/O2XsQUU5yzk4WiFQiI7DGs17NmUxzNkuDMJI2KFTSw5W/ikMOmO700K7A7h3Ru/NXKIua7MGYycUVcdqjpy0sajbzBY/eHdDO5sxXb5je/1eI7n3CrrYc78Ly7juUb5cUn86JhzWh2aAuTtietuznFb/7wT0+nedcNBnLyxmFT1GpxBfqXw447F/G7TAfMKsrGhtI8gPyXo8syxnmKeXsCauLKxrnaTHYIHFSMTx+wGBvH5kP8MUMKSL6gwGLmxlZv0dvsE+qhzS2k174W7yKVhqtFFGkkLML1rNr9g6nGGtp4xWzzSm1C0RRzPe++W0q6zg9PePx45KEgAwdRqBwjnzQZ7C7w+XsJYf9A0bTA2aLLa1JWdZwsyjJ8w3NpmLtJFb1Ub7CO0PRNMjWMxztUUhF5A3Od5l8ay2mdChxi+yla694AlGkGWUpg15Kv5fTrCvqpI8aDgjO4W2gbQ3qdnjKmJaYGmcber0eznp6wz2kjCiaLbKXUG4dXidESYaSkjSCYb9PmuSMhlNM42mNZZIPuLe7y3qxQgALIZg//jnpvKS+/y6V/0tUK0WUCpablGj6gIOJ587RiMfPJ8wuFoSbc77xdszZ6yXDi1coKyibiiAEy6IbVqqCYLQ/YnOxJjSO+XXBpnHYIGhcYD5bYOxzdvcTqlk36i1EoNaaPpI3X7yhijf4t94j7ins9ROsmaPTMTLp4bwnGYwZpYFiGbOuLa5YA2DakpuXzxBU7Ez3COketZAEl5D5BK8kZeHQXtHL+6RqgCjLTiKznlMur8gGPWy1YZzUTEJFsV4zvvMANX5Ioh2rq2suL1do1ZD1A7/zjbe5Or/gZtUwq2siLblznDEIhzx98hS/OSWePiLtJ4yk4/TlEtHOmBxOGDaveP/7P2B+XdErFKezhrTfY0YKzpEIR884nv3iKVoVFFWXuU5ETR3FCJ0g0x6mgd3jXVARlcx494Hii+ucag1N0OhmRhs0TZvR//Ahg4Nvc76tiUYHrK9ec/nmDHl2gc1GVJMjknwXlR8y0JraG7SSbPspWyaoKDDKU5zO2PvgmwyiQPFmTjLKUFdr7kwD0/fuclEWpKsrfHvKWDQsixUiGJAV43s72KbhzfyE8WGKmKZEyyHNzSWz03NePD3lg3f24PyMZrnGmJjk0V1UsDgvebVoWY8PcWenGNsSWtdFmOs10+mE+uoKW1ps26KihECDMw6d76HHCVmxy6siZjocEyWGWmf4ScLy/BJL1A1EyYqryxn37x9yerMl7sfEb33Ml68+Ybc4hyhieDyluZxQlycEv8aanPt3U2x0j/V0H9oNfnVOpHqwWneYZ53dDsD8xTX1N6a4ZwqUEuwdHDEaHZOqGKU0Mpb0BkOOdh3PRkMY9W4PgiQ+TkgnI2TsSac7HGdDJvsHVE4wO3lB5ZYke7sE3Y0Nc4s3EKoTNXspcWQEoYl11PWmRWcuCgHiEDjMFIZAk0mqJib1MEd2B5dA1Lasiy3Oa568WqCkJO8psiQw7qcc7k3YHaW4ukdVVcyqLfFQcnFyQrNp6emIqtzQ+i4WVgePD2CCp3HdYuT9beTxFnzpPDQuYAzY1tP60C0KIWC87VoMtnsME1p88MTe0vgWlQyQ2YBUKOJ8h8p40DHQsLN3n2RvFxl1UaAP33uXyXDApmwxpqJtuw/A0c4O1XZNpBVxpVGugc0J1dMt417CnYePEGFLVZVUXvDR9JrfetuQ1zk/X23ITMXmYk0v2mNtE7wF7yyDYcraaRpvqa2laC2B7ne2XRlU1qEZisYjhcbVBf39AduVR3kIwWBVxNJ7RkgmVKyv/4zr4peopEe+e4RpWux6iUoipFbcrAu8FyRpxigTzBcOMTzm6GjAXj/CuJib1YadvQOu1zAe5jR10cUOowiTpFRNg6nXBBVBu0bHAlEU7AwVcbvkdLZh+uhbTB7cYblqqUvL+cUNg/0+slgQu8DLLz7lzsO7CKWZn17SblZsqn1M2mfw6D3iwRnerBFScThpiaOM2WtJcJfcn+5z3LthOjV8+uwxdZFwdv6Ge//Kv0FzccLq6c9xckPs56Q7Y47u71EVDV9+coYcZASbI1RG7/gB03sTqq3lYlNxfxCx13fc6DHr8SGZWdHi6N19gB1PaaVlND5C4tk52iPbOWCpbjj5/RP2dxPawYjKpchmhhoeUJcK2Q9k6R7b1XOcS4jUCOslzq/pjwdUjUKlI2y+h9hRHB8d8uzpS76cvU1//VXHdkeT0hLJNdulJkEx9zBfO8p2xAcfwIO3I+7HM8ZNRFqtWRvP6KMd8uIp57/o02sslXsL09+hjVJ8a0HmqDjFVzV14RDTO/jNOdp6WisReGQjMHnAhYgQKapNS7ADrKoByfHQclGnmHXNar5FlIINCb/85Qu++zvv05rn9A52OBDf5pMTiPua63WJmE659/E7ZO0VQWrePlS8mfd5uVLMXc6LuoffKfHtgpVvIEqhFr+2pv7GFPckjckJ3L13B5IYoTKiWNJUc3rA3nTC3bfeZTTdwVqDtQ6R9DEeCuOpjCROh9y0HhM0cZwiE93FDJXuDhYjhRaywwRrRUDc6ucC1lmscx0DIwT8LfaXdksiA4kxLJcbDvZ2mCvfJRACBCGJteBb7x8x364pqpLdnR774yNGfc1omJIoy/R+j6Oxomx2KNo543jNg90dLmclrU67KFzjqUWXzG98wEqJ1ApjOpeqCXyNJHAIjLU0psU4i7ddZhnvCLY7bBaiG39SWpDqjGnccXiiXgIhxfsIREPrHULGtCHFBjqGdSwZHx6TaU3ptkip8QK00Ny5c4fWtvTSmMv2JSsTo0SEajdcfP4jLs+ekfV6xCoBpfnFvOVHf1hQrCXFpsV6x7Pnc0TynJ5usK6F4EkiidIK31jiWFM68Krj5rRtS5YlxKmkqQwajzFwelEi44j1utu992NN0LAuK3acgPNnqOEj1GhMvVlhihnlek486NGbHhAkqEySSg1G0d/bwQVBFPd5cbVg29ak2lNfXSHkgFUpSfKIrN/DmpqmavHLFX0KlpvAJNHczA3b1ZZ65ellGjl5jzU9xj5mkLTMFiV79w7ZXD6hnr1hdhPxje98gzdvbpAy8N1vH/L6qy8ZxBHZKMHYEb1RRE94np7csPWKcV8y+Ogtzq8rTk5e0z8+4umnv+Rgt8ebrx5j8iOGPcPi5R+g3ZzKSAoXI0vL9U1Na2rySZ/ZeQ1EiDihNYrrp0+ZDO6yEhN+fPmKPRlTyg353i5p8hAxO6MdjNAhJh5PiPKYtPAkOufi9ITmfMGov2Gg55y0e4TQcDgasg0tapSiU0GBRfiMsnbEpuAoqlmdzfCxoDGOxgsun1/z3jf3iHzNORWxqTnYz3h9MUCnjqifsC000X7MnjtAhDMeqEvufrfmu4cJ44OIgweO3J1gvz3huH/M8V6fn5Y51U3G/iVcbudIcryNcY1j2zqC0rSVYLGc0Z/eoUhuCK7BNhFeGmQU42pBWdQMdY0UObUypCoQXERbrgmrLaFuyXwPPSy4e9THV2vevDjj/aPvUWaaR8c5P32ypd5akrFmezXi7NRzcDxlOh2SxhCLlpOVo2xzXGhRUtA/ekQymaLLirMvPyU4+xfW1N+I4i6Ah4c7HHrB2wdT+plHauiN+rBpSduKoDSy16eJcozyuGBIrCKSCcPBGCEr8sEQERyq3jJWR1jZ47LtRp8FHVsdQcdsVhInZJcH9x5nu4Naf0uXDEIglODecZ/dPc1b74748Y+e8GD/gJdPzii9obmNGhIM37i/z907R3jR8SZWVyWDUcb4cNB5Wq3h/CTgg2M0vUP97SOWa8Hf+a+e83xlMK5LQNSyizt2cNbOdWpv4emt757PB6jqlkR1sg4pJdo7lA0INJWrgC6zHhmFNYbaGJoA8+U1brkiH95lODqGZk1TFUhnO9iZ1LjOSkJV1iR516bpMA+Sfq54dLTDh/ePkMLz9OqG5bJzdvrQEOoNYhNRtZ5Wt3gpWC9BxxFVW2NtQ6QFdnmOqDf4zNA60x3+WkvrPEpL0kxxvapIvEVIOhNXgNQLhHGgFcYGqqpmZ2dArTsDl28tMpEk44y2bIk0KGfw2wV+e46rNyjX4rdrNs2CNN+hdgE92mWyNyXPJPOrK2ZbQxtPiPsC0VQsL1+SDHYZDFLK5QIjDTv3D7Crc6oXzyCWFG1ES0uWRajhAC9T6PVI84z9e3cpFjPmV5cIKfFn57TViqppEdbyxRdfIkLEo/s7XK1OuXh1RhA5s5sbNkUgERbnLHK0y/zyit08J6QRi9U1/mzL5fL32b97n9UW4rzP6vqMN7/3n+OX1xRoBsMBkdd4F5iOE67PNzTbLcJrdh8csq2m9PoDjK2p8w15vEsRDumLa/b2LfObHI6P8XbN8uKSnIxw/A4mGtC79xAbUsaxpHmyYfKNfYq9B8gwZKpj/PIZ/fyYNutR2TFCmO4wPpmgsxxfrzE+sGl1J7oXlmJb8TZXfPjokCwb863iDQduyv/xk5e4EHfs98STqZoffGz57V3FYRIIvqGcvWG0c0gphxwcDuiPDZ+4Obs7ff6Gfsj9ouTNq4Q/+PmSjVdINM5rlvMlSiQIaWmWBUm0RWd9TF2hdE0IEm9aiNbUDDB6TEpN1gTWImUQSpamJYocTR2IEsm6HjMLc77/1pRnT2+4Pv8JZue3WZCSes969hhReGQ/wbUBjER7zWxZcDzq4W+2/PTlJcfaYsqIm7cPGTVH7LVvuHraBRr+ottvRnEXgt/65gekaU4bPGJ9TlA5LkvRcYRtJF52RUxGkgSoG4MIFZvZNb5JyUdTVHDMLk8orl4ziBRECi2jTkx7i9911iHpoFgd2Kuh14spm4aiqanbht3xgNmyQmrJm2evYDNisjvmWw/3KYqG2jiaIMmSGClBSxgkgkkiIOrSNLO6JmSQioTgA9JL7LYm+EA+7ncyDimY9DR605JEApxmcxtLNLccdxkCxnfMehtA6Y4XvylLIuEYDXpMdiaodo3cmO652uprsbUKHm9a4kyjVMbueEJvuse6lhAssRL0E812vWSY+VsWj8O1La6tUf0euJay2HAzv+GzZ0/I8x77O3t8+vwpby6vUek+QgFOAwJRbZDO4ZIBXgiiSCGcQDpB7Fva9TW6NUg8tdOY0CWPlJdo5RlkkuAluEAaxcjGEFSHTW7KFonC24DDdZYp55kMUq5WNZNRj/l8gx4m1JHHlC395BLskmXZgggIpdEqIN0Wu6rwqodRiujugEdv3eeVMlzcbMkGA5rVivnNM2zbMN2/Q7Z7h5uXS4RcI+P7REnCynpM6/FJRDoYE+Ie5BFxkuBDy/7xmJuTF2wuV4TgMK3how9GXC9iiqVDeEex2ZBlI16/vqBZXJFrx6snX6DiPq3z2BAjeinxxjKZxGyqAukiVrMlUYBvTRxbu+XpaYltIsx2w/qkRiQZ77yzw3R/j8uLFU1ryWTJ/jijbXOq4Lj/4CNOrxVN5LHG0dgpR1NN1t/l5WnBw71dXpaSZjyh/kozSFL81Rl2+ZTaS5Jml6q4oldeI8OGGztFVD0SrXFXP+e9j+7w2bMV5cohpo7R7iEjZejtFFTRlHpVsJx5msoTegFfe9LY8CcvvkTkZ3z/4QHNRcHv/d4zlG5wzYCiUHC6YPpAcieuGImam+lD3g4rhCjZrq7oj3c4fXbF9s01LCtMoyhHJW9PJEvfMBrk3Gw1/VGPlq4eYFpQmlhFKJEgE49cC5AFqbeAIENQLSzl/j6jfkZqrhD5PqezNbnfsLs3oagXNKsbvMuxRcbFpuZbv/UBVuzxuKqoexGPjgw3qyXPRTcYSZaCiCnqjLObIdP3MrZtSSoj5q+fEU969MQhpVnwi8efY37Nrh1+Q4p7CIE//uUXfOOdh2wtFKsl7zx8n9XNjCyRDLxHiwbZLPFbT6w1fWGJQmDU67M7HVMZh2xr7h7sUMqSYjGnqVfU5Q3GeRrnULJjumil8FJ1h6raMTrY5eLslKIoARgmkE4i3tsbcreXMQySeL3hQAXObMvuSNOUgSxS5AmkwnH65hJRZPSTGB8Ci5uCsthSblZ4L3FWsFwYkBDaksZ4rBHs5ZrdTPDWXo+i9l1byAesD1+jh73zt/f5W2696IiMpvua3mhMVSwJ5QLvOhZNCB7nDMFb2rZF5z3qeJ88TYnjnL6SuGBJBzlRDXUxQwSLVLfEPtNgjEFIibMtbVvhvKM2js31AtB88fqMbd2SJg7vHVp0Sj8RHG57TfBgvSPKe8SypFgtoC7RwYCKsEGiUVihUC7Q1JY81exPEi5nNXXTsKs0qYIKiGQA7TEyRrS2E5FYT914epGn19N46xAyoqo9hwcDChrW25J2u6Eykijro2/Z+tIJVGQwpqIurrm6GXF0XHHveMRod5fz8ytUmCPHY+xeRluWbJ5/Qj4+JAprolThVILvDdm9u8+6qChkn8HOAVkvIy62NJsL7OYK7StE1CKahr1xS0mCk4q8n7Nddyat1hhsYQk6Yxsco8iQpw03m0BbW4J3ODdnFE3YGst0LyXXEkfg3qMJb843rNcz7NYxHaWMDqZUdY3dllxVbxAiIlUKU3tuVhbrY4rrV7z84hnR/Q8pti07Sc3IKxbFDe/cy3jxtMbnitBukZXtorg6xuqYvo8o+568V7GbpRzkY76aPwIXoXoxzevXjGPJi69WVGWMKF6hQ0D2U/rNOe98931+8ctTzl58xeJyQzyJ8I2g1+9x727J37jv+d7OltXpihdXU7zbI4m3lJHChJKxboiFQ5kZzvTZUVOW55eoGeDPKT6pMMkObfEa0ayY2RPuH4/Z1o5xr+LBzpiLwiAnE0I9J04dtg704wk+Doh+iV1byBzKxYDD2jVuY9HssaZPXcPg5JoqqWjmG4Z3R8xrT7lyDKUgWn+J3t7lermPzofcexQzWrXMLq5ZJYKqWmOqAqk8SdySpIG2abHhfZzrkdTP2Dt4wOn5HRafnjLceUGqA5HM4GvDxD/99ptR3IGz+ZadmwWzRjGKFVIKrGmRKkKrzuSyWa3Y7Y9wTYN3lqpYMxn30AgiApEPKC8wdUux3bAqtlxtSozrJjiTKCJJYpI4xVqD0hoRRSRxzPVyTTAWJQW7vZjd/SG7PcV6s8U3FUXU7fbbyvL2W3vsOolSmlgK9nuCpmmZLSxVknTseO9wZWBRt3gUUnRjyz54rq5LbIioWkNZt0wzz+DBDkUbEChkFOGCuM3cdzx457rDUkJ3TuAIrIoaZy3r1Za2rTtrk+1270IIjG3g1lC1EYGzqyt2JxPSqUUGR7mZkw7GSFNQF3M8rnvtUUakI5ztfs7BW4QPDLOc+/s71KZlNMz59rsP+NPHr2kISAHculmdUgivCE2JpMFuK9bzAmUMoAlCEbxjmEe0rcM7SSQ8QiqyJKJuLUksqJRAaEVsDQZNHMVkGmaFI4hAFmuklFRO0jhHHEuMlXjrKWxgU3ny6YDVakEdFPQidCYYxJrVqqa1EmclcQy4ltXNJU9fxPz2D75D4iyDYQ8Z7mGHezx/8pLzT3/BdOeA3qBlOJziZSAb93j74wd8+1/7K7y6blhsA7gWIXrc/PiPmEY173/zG5ydLaifnJLu9Bnv9JjJCS5cc3c05PJySVVusN4QxZ5Iwzv39/mdbx1yftXw2ZdzlsttF4EUCdNRj/m6wtdL0p7DyTE/+dLwzXdG/BsTz4vnG6pGkqaK6XDIIDPUdUxpAk4EEqUYTyP8rO5YKUnMzfk19jpGD1fsfwivXtywufeIOk1ZVBvUeoFqF1QDi6k2iLZH5S0DkbCsIlwUUc4FjZyQNi95/PMz1heebX1DNsrRgz79iUKxYXVyzv4OPLupKYpAcbaCRNK6lN5kwu5I8P7Rlrd2WnI5x0UbdF/AeJeDnRH1wmDjhH6uOYoL4qph61akeNh+iVwu0BacatAHmmA3NMKSximvP7+m7h9SlJqeCSR+ixlOYFshZcy9gx2GiWVTCDIhmB4KnN6FaIcmwPpmiW1qmlDinKIRA6pZwKsNzWbB6bYkzTy6XDJ/c4XwNU3j2I1TZtNDdquU6VCwERHv7Uku3rR88eIG39OMd0e0ZUuaRwzGOxwdTfj0H/6QxyefsnPnPqs3bzjYHRBFnpPlLl/Lof+C2z+Pieke8H8GDumSlX8rhPB/EEJMgf8b8JDOxvQ/CSEsbr/nfwf8O3TLyv86hPD3f/1zwMdv32XUT4gSST+NCN502FqZILQikTAd9YhcS1kVONv1YhPVYXmrcoVRmp5MKduWm/WWsjFstl3EzrQtNo5pjaWSdWdgupVObINjlGVkw5h+puhFgkxLhrFhOuqxnyfgHbGWTHYUYVVzWXYHl/044mCkOZym7A5iYq07drwAHSBKu0NK7y1l1dJYR9M6qtbSkzl22eDWLaUJyNupU2MtznbeVBEkwZuOC+89ZWtwrotGxiFgveHm/BXWgXOepmlxwSEQOBxCdiLsgCKLY47LFhNPcO0GbEu7vSaONaHd4L3DOY+rClqpgLdQsivcQgTSNOHdtx/SBkOeZty7f8DLqxVnK9P5ZYXCh46Do4QmRBHBC0K9uWX8eIKQEKWIYIgixbZuQEIcgxFQ1y2zskb4DsVQSM1oGGHXFbNVxd2dmCQRtMYyiEFkEVebBqTAO4uNBEF5XBO4nHV0SiE8QiQ4L5A6oxGy4+JIS6JiIuG71pCpWS43fPrFa957/w5t0iMSMa+ePiO4wOD4PqurG3r7x5ycNxxNM2TPkfgVn/ziC1xvj3JVUa/X5Hv3sdpzZSN++OUWVxX0e554uss2G0CAaTwgT1LuTHaYrQqSRBH1Inq+4jt3LToXJP6Iux+NeOQX7A01r062nN4kCB0z2E1RccLFTcHNueEf3cx59+0Bjx7uokzL0f0eVzOLlIFTM2ZPR3zx89eYumZ3mjGfF8TjMf33PqI6XyCHE9bzlvnpOcNeRGpi9ia7jAqLLT7HXZ/RvJoTRWuy8YS9fEVdnxCpCXkYMBknvNi+5sWLa7wZErfPoZzTtH109Ihmk1L7Ob2HU063gtmT5xTPHxNaAcmIfDpisjelF04YHhn2slOU7DEatTzot9w7NyxHPVQbECpHI9kZWFRTMowV3izwZoPQAp1KXJKDtQgVk2oozTWi12Jdgp1p5HrFwyxwUlaw06c8ecVG9hiM++zkgqYpCTYQpQ0iipgtBWQCTU4QUQcFzCPatSE0BZg1RSGxqxbaLSIW+HgH01jWl2fEO2MuVjHrZyvaJuFqVZFgiBJB3dbYjeXixPHBN++xcpoNDswcU1l27rxPUxxx9MEee0jSfI/ZzzXWNv+/F3c6Xd7/NoTwMyHEAPipEOK/Av6XwP87hPAfCiH+feDfB/49IcRHwP8U+AadR/X3hBDv/TrdnkDw3oN7ZFnSQaBwlHWL0DXOgIi7XHnkHavLk45/ohRJHOHrDSevv2KxXmOMI4o0m+2a06s51nY9ZSUleRojRUAJh+4qEcEaktvMezydEClFrDxJDP1Ucr+f8WiUMk06UUdrYWEdeawZOIXR3WN5F3DGEkwn1ZVKIoWibFua9ZbGBoz3tM7RGIdxHR0yCEVZOKwLGBcAiZQRWmviuBu8klLempTAOkfmOtNScAGCu2W4B2oLZVWi1ZDgu/aOlAFC+HryFcBWBc8f/wKJRwRPEmniKGKQZUjVyT2sMSgVkei4sz4JiRASLwXD4ZQ40V2Li0Ca9vCzOSEWBGQ3VyECIe7hbNXFVqM+3ldoJfFOE7Sirg2zRYENCh1DJG4xCk5jfGe+GvU1s01FnEU8Opjw+GLDatPgQsZg2GOcCK7rFu09XsZIG2jpFl0VHJEQuNaRJYpI51QAzrIqPCJE7Ixj+roi7Q/J+kNenK6o5gteNI6ibelPcubn15jlCjE9YDIaYZcLFjaldTVt2kMaz/LVNcPJfUIkaRZXpAdv4W1FNO4je3tY74mTFq9TTNtgX36JkY5FnOLMio2R9N/5gHyyg9jZIXUtv/zkD5jPPf1Jwocff0SeGdLiBVc/vsTLgJKK5yeegxE8fNDn2VnL4dGU+/czcJ71teXleWcr+/ijIdsXnpefP2d5voI4Yrq7w/HdYzbPThkd9zg8mPJqneHjPZ49u+bj7z9isW64s5uho86kVFyfoqKK0c4uh3dirJa8fPac9Txhe99hqg2vvrzmZr0liRWR7pMexmzLBIOnaBL6WYZ7+SkmlEzjjOStA1yZ0jrH7kHCIK748E7EX71nGKYVeTxGxmN81QnpaxtQeoxKJSPpGfXiDg0eDdDhhqg3ZO9wiE0jfGNYFwKjAlo5lLToZMgXp2u2V46F6RFMS74xEOf0JncYDSXzsmS336MRsN8fIyOIYoil53rWIHop2bTPeBzx2cvXaBXhioaorBGJJNqZ4LYRMmlQqSbzOW7pePUHP2Nx8AK1MyLvJzy+nPPudMPunuTiKqYyjhAEtc7BTbBVhJEBbwMXp1fEwzHSxgSZ8I33FD/Tgl/Xdf/n0eydA+e3f98IIb4A7gD/Jp1bFeA/Bv4A+Pdu7/+/hhAa4IUQ4inwA+CPf93zaKlIopTOhe1oTNXRH1WHGQhIeklGGifkaXTbU3bMrs5pfcBai5YS00h6SvPO3SOkFKjb8ftfDetChw4IHrz3RFIjBGgliJRECYuUlp4KeNewKUuUVWgpcEGzrWqa2tK23CrQApF0LCsI1hHLTnsnCKhIoSON0rcFPziU7azuZdVS1B6PwDn7tQ5P4NGxQsoOGPUrHrtUmiyJyUXXlhFS354fdM/Xvbndr41P3e/L09gWT2cvErcSEut8J8gOXZvIedclMaQAKRFaoaP4VgTeES1DCKRRwiAfEsUaqWSnaYsiLBE2KFSnRSGYBqcDQXW0P7xBeY/zAqFinPEE1+BFwAXPOMuY9gPt1lMV3WtTqaKfxcw3lk1tSC4X6MZTWfDS0h8l5LnifOsBc4tkcEQoGiRCdQyeJI0YZZKL+YbR3h57B0M+f3pOXRUUs5LkeEKz+zbRdIcdccbl2Q12u2H21VecOIetC7SEYZoTdo+Z3nnEstwQSUjHO6QysPvRO1xbh/A1Mo0Q1iAx9LKYspqjpbpdBJ5AsWJ7dU6c9sjGUy6vzujt7CNvFrSbCuUSRP2Gowd3mTnLRsGfPl3y7jce8s27iuN7M168McwXJUQpsw2EEOOTiCYd8MvXkotnLzF1xUfffov33lJsbyw///2vUIN9dr6xw+LZa86fvcSaEm8l65VD9WP2diNUPmH2yYZeE3O18nz3TsumaugNIjalon/3kMO7Y4pF4OknNdUmZpQvaF/M+er8gqIxDHYmDPYOeP/tPtezitm6RYeMfgaz1RXWKB69PWIb56y+0Ny7IzmcSmalJ52W9LRktY54WQjeOypRHjQtw2FE7+gOuoUs10z3Nd4UuEjiwxrvA1kGJt3HVNeUS0sT1US9Ae1wl2HoUTnNw94OT/daxElDWzS4NiLVgjR3HO2MeRMkWdInosf2YsFwL0VrSe5aRsc9Hs+2tHrAMDF858MpSW459EMutgV5FnFSSm7mGbbY8t1vHXL28orXkePdQYYeeJ5fNVRtSRJJPlv22TsK1FHNZutxIvD2gx65+YKmvMuyyam3M4qX13z8/W8zzQ2xtbx30KLUv8CcuxDiIfBd4EfAwW3hJ4RwLoTYv/2yO8Cf/BPfdnJ733/zsf5d4N+9/Tt5ntPr9UiyjKra0DaBxjqUApQkGId3DuccK9tdBGglibWiF+tblV3Xyoh0B9WRooODOedJ0wSBxDuHvQWoB+9vd8YdnUDiUVIRSUXsDVEUQyRopcCJTsmn4gjddrx1pSSxEGjtqLyDxpBFEMdxV9y9xbQe4UMnqBYC6zrlnVIpSjXEkSQNCqzvgE5S4VwHdQ/+z4XXHUYgoCN1q9rzGOMxzpImKVoIvLcopZBKff1zlo2nMZY8iVHy1tZ0uxha5/4bA263Oj/vCEJ0hqTQ0SoJAWcM5XZLlETEaYJzrltIpEJib3vNsnsPQhFClyTSvsX5FqsyojhHmoJUKyrfxS8zaen1B9jFEmMDqlvisAEcki2CXm0ZSI+TEaUKyEhT1l3yBNUx9X0I3YQugUgEskjSGo+PFHkvpbSOr56dY1pBmvaJXEkzOIbxR1yIMdH+PvcPNqiyQKuazz/7kvF4RGsrXLFmcfoc6i3JYMxqXtDOL2FxjsgjdscZz1+dMc4TpNwQlOLk868I2RgloLq+wi3PwDiybAR1webiFGygWS65+epLkjRBXLwhm0j+0es5yfH7mKs5g/tv8eLNhme/uMG9KricBbxI2M8FYphSyJzdoz3ufP8bXLoBUvwC85PfZ/bmDPnwkD/+4Qva2nP8aITJc47fcrz68Wc0piUfjQhAOk3ZH2uSleMiddzMbvjOW7tsbcGiCTSmwa0Kqszx5LFkOB5w70HKSFUMF9dcXtbYvTFHHz9CS7jyOWfFgkzk7L814Wgy5OLNG2R2n4Ms4aRpyX3NNz/qc5xXnLy5oCFivG0Res1ov2EYa9YW4uCRUjMRCZOkTzHZMDmK2Ukcq8qR9CVClAgtCXGPxbKhMgWOHCWhtBN6ISOkCS7O+eTNDf3BlP7Aslx5eqMUnQ/QIuANPNrrUfuS7bwh3+lh1xvO5w2jUZ/9PUUdYpY28NXTOdnhIV4MiNOSICR7vQTZ1hwcS54/q/jH//BT+tMRHzw85OjuhJqKMrb0I0NDzMvzhPHYMN2H4X7K5UvHeJyS9Ec4l7K5LmkaQ+QsUbzER5r7I0EqPP8sLOQ/d3EXQvSB/wfwvwkhrIX4C1eNf9o//H+9ihDC3wL+FoBSnW8ujmOqsqCuq27XiifSEq1jAo5+r2NSayXQSqKjCITHO9PhZ2243c1GKNEdeJatoSwLlPIo1XlGpZRoFXcWduGxpsF529nWZcdnjyONUNASEM6jRAfjskCWZdhIErQmUoJItmQy0E8EeSxvEbuKRMfdAiIUVgQ8YGygMQ7rIIoSkgAhlsReEFBIrW538h1yuG1aAiCkJPhul60jTRwnOCdojaETMWgCokvbmM4WE+mISHYe2uDBGIOh7Q7mpEDLjp2vlUQI1elMhMB6h4ojsjgi0V2pbeoK53wnFqdHnEQ42+3UlW2RqqNWehnhZAJSI12NN003NRun4BSuLnChoafBh4iqtfiq5fSyoG1lt+NNIyprCU4QpKBxYFH0VCANtjsEjSRtYfDOo6K4c10icdYRJRGJD+RKsTKBVnpsa5BJhkwkypQkQbB7OKGKEszyBNXbICLP1dUNGocPNXkmSGNHu/QcjRKEWPDk5QX0r0mC5foP/x6z09cs3nrI9/57/32K01MWb17TO9rn6KNv07//kGbd4BanJAkkR8ck2R69nUPs4jXV5ZdsK4t3iub6Cqc83sPTbERbzKnObxBpSjbaId4dcfH6BcuzG+J8h+FOH+G3rNc1682GeHjAqydnRPsfku4c4/f2uVit+eJZg1UDVN9TtiX9wzvs5IGTP/OYoiJlRKJyIjPl2eU1dSlIpeP0zVe8/a0H1EXAbgyyannnwz02reNwEnPvqCFsn9KuGyqX0TsckO3eZXZaMzya8H5fcPHlDWcXJWolWaU9hkcP2dkGHoy2HB1nzGae5794xZ+c35AfH5NMpiiumAiBXjtm4yMWVjJsSiITKMsBu6FBZJq2LtmIjDtJQAVBKgIIRWN6uKZG+D0aDM15xnZpWAvIkogbU2CLhvn8AjudEnRKkmQELch6Q5pNjRKOYU9Q5JrWOHp7U/JtyfHdEbkQ3B33iGYbrooF40KQTe5Shz7VesHLzZa17THuB/r79wk7EcZHPNvM2VxdYZwmbiUuj+j1Y7596Pj8M8POYIStLPHhmMdnhoO+xBeGNK4xIpDHguATKqcQQ0Hlxb8Yh6oQIrot7P9pCOE/v737UghxdLtrPwKubu8/Ae79E99+Fzj7Zz2HtY6mrim2WxrbUjvfwZx8H4XAeNiZDBGYzrUaoDItxrpuRD94wi3qFiQq0bTWoHD0kq5lEJzAe4cUgSgBaxoa2+CDv1VndR8uGWscnVnFyoDAkmiFDx20CqXppQmh216TSOjFgjwRaNEtHtYLCuvxjq6V07Zd31tKfBA4L2mcoDKW1kuQMSCQ7pZKKSXBBdIk7XyroctncyvwkARUdPu+vUCqgHVdAybWERCw1uCDIIo0WRqTxN3ARncN0l0xmVtI2W17Hug48oPBEKzl5uI1ZyenWA+TwRAtPG2zQaxqQoC2rkhijbx9TBAIGRFFMb7ZIIMlywdURkBwCNFJD7jFMCeRoG4NpTcE51EicHjc4+KiwhjHcJhSrVpCsPSnGYmSuKuKtyd9TlrRyTqsBxmw4nYH7zp0pjEOJwTWWyIlsFJRzUpU6aiiCHX0PjI/Qjc1fd0SDSbMNxWhKVByQLupKUUAleCdYe0Uw6MxplFEfkt9fcKdUUI5m/PJP/ojZs+eYKqK8QffYruRZINdsklO0RTISGGqLT7pI5OYtTHk00PGxrPcFIT1nFCskWlGu7kGb7spbAlufsbl8pTFV4/pjceM9ndZVyXbjSVKIMFz/ewJR7/9r9HOX9KcXxD1+mRHB9yUNVdPntG/d4/9u3d48mc/YZZ48r0J69UcEQK7PQfyDbpVeOvo9TKqFwXFbM5R4nm8qBndPSYkOWjY3dOsXz3nuohZWsk6jjl+7xjlx/QnZ9wfbbm8PGOzdmSjHZJ+jLPdjMP9dx334prHP/6M01NPsy1RUYTAoTcbDu4N0NWSK59wJ1uTKolxmtOFptw4qtWSKJqCzgghJk8G3NzMOR5myJDSlBpvW4xNcF5RRUNCXtM2gdL2eHlTs6klea9PqEAkPbTQSCFIIoWIBGVVIqI+WdQgZcPmxpMNUsq5ZSYCo92Yo6OU/uiQ5WzD7GTOKE7YHQ0ZDRJWj19xVY5ovGNFw2g34vjREZHQNFFL1BqEMrxZNkwGNe8fpWxVD+0bFo9fEg0/xsmUi5OvqKqaXGV4McYsbzByxKrUvG7//BztL7r986RlBPB/Ar4IIfxH/8Q//b+A/wXwH97++Xf+ifv/L0KI/4juQPVd4E9/7ZMEqKqK4CxKSgb5kL7WnJ2ecvXmNW3exyDQUrNdLkjSlDRJ6eUDEIpI6u6wzvuu3XArpG6bpjPO3O5QO2mRJnjPdrPCeUsIHq07qbULnYrMWlCq600bAcYF2tZ2PG26Dq9zrov50LUCpPcoFFoEAhYh1dcWJKRE6giJoDKeEAQ+CKTSxEIhbMBYTwimcyKKTgfonLu90uhaQEL8uVmqNf5rCYkSnThciQ4X3L1fRQgOGQL4hu26ooo0WZoxyPqdwDt0C+hqsQYP/TTCOsemLHnz8iWTyYi0l3C13PLq/Ib3igX9fo8kSdCjMWmcIEWgtQatY7wAFUlEMLigkVEEZUNTllghQWqC1DR1g1aqY4g736EWEGSx6DgzbeDunoZWIkOETDy+tGyNYe00tZY8/fSUrfUEDEIkqEhRo5DWQnA4GTryZxAo49mWnhB54taj8h5mMObNxZLewZA7x2PiLKFtHNJ3OrhBrskO9lltG+JgKIqW9MMf0L58SqgvsbEiV5L57Iqti1iX7W3CCeqba7YXV+ztDsjuf4TcOWBZFKh+Sj2/Zj07QUQKn44RwaHTmHhS0bZVl7SyNUHcKgfrgvWb5yjvEbbFWss2eNLJmDaU1IslXg8ICFYvvuDO++/Qf/chZrXD4vnnrF+/wFdbJBGvP3/GwZ1D4t0p25NTLl6/QdPineOLx55a9tkfVkz3+8yfPYbmlFevR6jIoKZ7vDmfYc2I8zzh/Q++Q2wd9noX6XpkpmS3f0JkF/yjv/8S8h6Hd+9zctWAS3jvg3tM4jnl0+f811+9Im5Lkt6Q9DBD1wk9qRkNEjaLa24GY+J6zeCsQu+3FL5lsexxs2iJ8imqn9MLglppyijrcND9BCUSQmhQeoC2KfVly8bAYgnFVqBTWFUxR2/fR4kUIwLFRcstrINm0xJ8zHB6AL6B1JAKibcCJVuassOAbOuGRgWkSjBVzfh4yHa5pD4t8ftTdnYy3v3Bff7sCcy/WnPztEJwzaP3jtjR+8yuX1HWLSoYnl9LHu1bjtMeF3FO7+U5X376mN/66JD68pJnLyP0OCbTGe3FVxTrEa3sEUvRgab+2xR34K8C/zPgEyHEz2/v+9/fFvW/LYT4d4DXwP8YIITwmRDibwOf0yVt/le/Linzq5u8TYYUZcnl5QVX8wVPzy453j0gjyTLomC72bCTJxzsjpmORrfALMnedEqepUghsNYyW8xp2ubruKMUkiiKEALqusuDK9WJLEL41QGr7/rKOJwHLwReOBobiKQkqE5354PAWtH5S+lUf0EKvIyorbvth3cpjduZKUrbCTS4Zdk451FSI4Tv0ihad0q80KGIAbTuDnp/tWB1r1ngvL8t3t3C4r1Hia6doqWCX6kFg+tcjEJA1qOsGxCaqm3pTXKGezuY7Ra7nDEYT5FJhrA1eI9SEdW2pJyvUNuITx6/prWWuyONa7ZUmw2nOibLMjarJcJHXe89OFxbY6XqTvUDBK1BRwTr8CoFabFSUHqLiDNwhv4wxzSBrBeROoltDb1csbMz5s3TK0bjAaaqWW9qBnsj8v0BUVNxjEK7hHljiBRoGbqkkNII2Z2DBNklmAajGJQBKfj4dz/m0vY5f32GThNms4rtxWck+RhtK9rZCclhihSO3/pL90ml4cd/9Jjy9Ct2f+uv8fIf/GdIG+gPh7SLNSJ4pNJEowG2WLN48gkq7mPu/etdr307J9hAfu8+MZbRZEAbAsW6oB9HXH71FYM7H2F3jrDFivriJfHuEaZu8bNznPH4JKWXB/LJkDqOoD9ilCe89d2cy6ua+ekZut1Sto6oXlDUgbpt8f2EMA8sXr8mGQwRu/cpvzrFliX5wR3MqkRa2Bs1ZOmCbXHD6VcvKS4uefbVPitzTc+ds2oaQrnP0fgV3zic8OqFZxPlpKM+7/aW7PVWvHh6zS9/dopOh+yMJjx/veGDd3L6uSFafsWLJ6+xZYPyFcE1yLrFbiU7RzlyMIByw3CYEbaWRRnhZM5WeKJkwmw9QOVDXJKjUAjfXZEKmTJSPYLVLLwhiTLaKmM9z7iqhmw8vNo0pPGYfDpAXs7IdBdDjKMIHzRBeFSWoKXu2pG9iHobiOsapQNx4sl7fTC2+5naGm0tIbJM8pi9fuCNFSQyYXn6HCEE68eao6NvIrJDXvz8GdfnitrDOx9K7r11j5uzp6wXhofHH+N6GrG5INET7n/8DR7/+BNe/ekXmF5Mmw/Y2TtmOE5xL2dsL/+EN6d32NvPfi1X5p+ruIcQfsg/vY8O8K//Bd/zHwD/wT/rsf+Jr+cnP/4xUkBrWjyBqjWc3Kx5fTFn2ouxzjLs5+xNB4zHI/r5ABkl6CglOM9iuaQsNzjXjQj/qtAnkSaJo9tCadFaIG931CKA0lHnOZWiK7TSI0J3SeyDg6Tb1XNrYHF0O9BO+dHhAHxosXQ9f3HrMi1qe7sYeEARfHdl4BB41/XLtJbIKAGpEFKgle4WnQBKSrx31FWFVJLgHUpJ9O0hZwdj+ZUgW9zu7LthJ24VgF3KxXPw8B3EIMdbz/XrN4SsTyVjzi4uWV685uD+W4yGI/JojIpj7k/2uD+7wZoaOZxw7zszttsNo34fZSue/PRPqTZLWusw1oGIkEojoh7ZoE9RFRjT4JQmyncQkUSURfefyHUWG4dAeg/BEScatpayVMSZQMWCZemollc4oairFnxLEB00LE0d2cGQ5YsZjREgPb41DIc9NmUnOVEyIJCY1lNh2O9lrK7WCAKbmwuqOqWZ3dDOC2Qa49YXlAiiNILg+erxgg+//ZD/0b/9V6kXJ8xeX3ITWrLdHXrH76FCwzf+1b/M07//X7BabdE6MLu5wDcG2i293TuE4Rjz6gvG4wH1YsHm4gyxvqYRDcY5Vm9e00hJM7vgrSPHwgcuVyVKC7LhPiJtKDcb4uE+PhLUZael80VBWTSYQYpKIzara3xoiMqS5vUT7KCPSHok/QxTSoJUaFPglyXLNznpqMfD737IzasrTv7kj7h69oKLm4pmuyXNAia07H94l8v1lrYSNJtzRD7me99T3IkSsnzI/bcnzLY5rRBsrxa8/PxT5mvIDu+QxgHlDd/+cMp7x4EnX77hiz/9nPGDYw72Rpw9LugnKcNH7xDt7zBwFTdLRzpICPNLfDWjlA1WefzlgCAGzMMQF6W3yjKPVZZMeELtKeNdHl/UDHsxCxOzrfrczBJW2xXGp/QP7pMkOZs319St49mLC7xOiTJLLx/RBA+3hd1rTWsDIoYQ6U7aEVqcELf1IEchca7B1BaRaiJfkUcJi2WByEf0/IrFecmVPyV796/znX/rHcqrkhpLrWquix7Pf/9z2mxL/7ffpjfYJRMD7ud3sO9EFKMxO2l39ifFlLfff4v0+IjLPYX/Lz5DL05YtzHB/fo982/EhCrAcrNGa0GQiiTOmE5HHN+5T5bG9BPNIEvpZwlpomkN3MxXrNfrjs+uFUJ2xTtNU2IdoVVE3B+glaBt29s2igM8ddMSRRFRFKGU+rrdQbd574qy90gZ4YSi8Z0GUEYx3oOKYiIVd0UfCETdIWSUQjB4H8hH3QJirUVKTaQ13geq2lFVDf422eNvd/FBiA5m5rsooHEO1xqgS/N4KSgbg/76AFQiQyCETkfng0Vp3RnuXXdVoZVGyA5VkEcZN1fnpElKMuzTn05YDXKKeULIMirnWC5mpIMB+4MpKhtgvGOyt4cSjjvHe2iVsr6+5O33P6RazWlqh365RHqJjDWtjHFWo5McpzVCx9CUaATGeoRvOq1b8NQiRt8SK70VaCeoPZQRmK3ByRThAjLuDlmjVFE5SV0Y2m2NSoEkxhVbdC8mkpI81VSRow0eb7uIpGnBp1BcL9lWkGYZJ5sYn/YZHPXg9RMSJCQaF+VsQ0APR5hiyar2/OiLmvblFZv0kEEvZ3txwu43vocr1kzuHhAJUOkAX5dMju9TrLe4MsZ7SyZbrAgsXr+gFwuUbZk/+4rrkCDTGL+6RA3H3D8e8T94e8WNifj8ztu8fio4+eqnOOsJSZ/WOERT0RrJxdkKmWbd7zo0nF6d8P3vvcfjx4arl6/IS9h/eIidnXHz/DVaOKKB5sNvvYsNjpczjUpyqmXDyZdPaTZLTr76Ahs0vt+jTEdERx/Tz3vU2zX5QPPuWzHjoSVSBbNVTHn5mqV9Su2G6Dgiaz2H+znxToyMa/Z6kGUDJnLN019ekPWGHH3zYyaZ4PKXn3YJt/v3yKcTrq/X2EwSmwV+uaY2FSpOSYlpYsFCpOg0R4oRmC3CthgEoQ1sEQSjuPADlElRS0/kFRV9ZsWMwaCH8DFRNGR2McO3LbUzBJ2SKkFdC2RsCZHGozC1oK6WiMQyjiOk9CyuCvIsZrwzpK57mKBwW4VswIWaGMXJyYy9u8eUG0m73GCUJXJbpskYEY8oHz9nFVX0+wf09t5HzJ6gQ4XUA6L+AcVacH225s57oOsBO+mKMsvIojGjg1+wjRTbytFTH1G/81cY6yvW29m/mAPVf+k3Ae88fMB0PCBJU6I0IVGaGJDB0RpDUVvOL+dcXl1Slg39QZ+jwx36STeCrlSEUvr24cStWs5T13V3AHkr2xZCkGVd6sY5R9u2Xxf4SEWd1MN7pJCdpDqI7uBCKJTWBOswzhFJd5sp7/pezjlEJJBCY71BBoE1ntZ4ItVgqIAuChlHXb9dCtVBwegWk6IoujaL6lpJ1t2uNkLSWo9Ak6YJWneRReEcbfurBFAgWHvb3rolWwZLQOFs2/F4RiOWF284e/ol4709iusLMqkZpjlRr4fbzJlfX+FkTLUpMFVB6wXt4hqFZf/RO+AtvTghHg6xaSCJY7zxeK+ROsF7gTEBmRis81jXYJsY4gRhK6QFvKKnJF540BHzVdNx6pWi8hKBwFhHKyDSkqStSLOEqrCkcY+iCMy2DleXaAJpHGFMgxIK4233QUWgvSOSgt1hn83lgpaITEEqBF7a7spNeHbzHao056KpKM+eI5fnCBHQxx/x6uWWN3/8BkOGYoNY1Oj3vovevUtZNlxfXFK0AmEdDz78Szz64DusTl5y9tN/RHl+Qnlzxeb152xVjFQC68G3FTrbQY73aZOE0+sNf/dPKkY7KU821wSZkQ9jqm1LKyy+mBMFg5Ia35QEZzrngNrlwXe/w/rqlM3lBbuTjGJ5yemP36BCzb37u2iVEvyI52cF7WCAH/Yo5xdszlpyZbFCsjvI2P/gO2R3D7mSQ2RkeT/+is26pioreu0C5zW/eLygKBLGA4Fppxwc9jg8jKntgh15gCpLiqJk0M+IooY//OM3vPXBPk1pKdaGYdVyeOcRXf5LcfLqBSHvkbsIawWRihnu7GKqFmMaIglIidITvK/J45gNEuUlxlmccVQOglZUtSaqa6aTAZdnC5wA6TxBBNbbDWmS4IKl3nR4bNLAsK/ZONBJQmsFIdIonxKaik3bohNNyCIqai6fn6F7PUajITZVVCJB42gagzEeQYnWnjLU1HULwpHWSx5OrrC/c69z616/4HoWsb1qMU1LLvMOmZBFeLfh+vwZg4eK9eP/mnL4A4p7Ge0vzkk+3Gf67j386DmT/ZjSHWCtIHS0vr+wrP5GFHeB4P7dYyZ5fpvgCGzLgtPra67ncxabisVyQ5ZE7E76HB0OSJMEbyqKFpRS5PmQJEqwxhBuY5rG2NvVrWO266ibqgRue9hdy0VrjVKKWMfEscQ7Q7Dd+LsPDik9QkX40PXFjfN41yUZpBSE0PW+rHGAwDkgWJztBoOSSCFlp8pT3kFQELriLW6XX++799GdDXRXBMZ6Wmvp5xlpLDG3HPuA6OBnvotXdgvFny/j3UFxN8UogiJsNpx98lOifo5ZzzgeDKjWS3o4on6KLNa0pmVx9obeeITfLrHrDcV2y+skxdUtNycvOV4W7O+NMatrskSSJN1whwsKVNzZ4WXAofGtRygQMumsNHkfKUewWSCbCukMLY7Waly3fqGkx1ooPfhgmE5StFCEwrIsHcRJt/i6QKw0VsSkSYuKBNtGcHmzQRMQOtCaboo3SSWhaqiEpBGBomooXz3Fyog4wF6mqVOFjTS+9NzZyxlmmlevZizOZjTNP6barPGZp28qBolh8+XP6P+1e1Rn19htSdYfUVlL+eUfMRJXNOeXuJsTltUa01ps3ZAfTvF1iVYxbrPFFVuiwS4qzbFVxZu1QBzcJc0iZBox3dlls9ywXW9Ynl8gg0EgCK6FphvMkJFEVi37x0f0D4b0R0N+8g9+gnn5nI+//wA72uHkbE5iHavWEecJvm5IksD+ZMT8xQK5s8P+736Ij/pclwZYMAxP+eWTZ7x8XtKEnHQSEQ09SasZRxXJYISOEtpQc37d8r2P79BUNduTc4qgefl8gQ8Jdx7cpZ3Pcb0ej477rOdzbFDgBW5dIawgUxvSwS6qr2k2AlPX2NbSUfw7Giy+oS5b2trSJAqnNQ6BshD1At4LXBPwQbNelZgmoHsxYpCTpAmudkQqYEqNc90jWxOwuSQ0Gabt2i9CdtPck0GEWReUTUGcxfgatm1BEhqcFvSSGK0VTsV4ug1Ws2rIk4hNEhNhEVFMr14yf/wL8vtHmKsN67OK0eQa/+rvMpu9wPRTxlHFdnnF6ZML1EGGHoBZtSjxDHVSU6xWfPX3/lM+2J4SkiFlbwe52bI/XPMXp9G7229EcYduKOdyueB6vuJ6tuBqtqBsG5QI7IyHfPDwgMkgI1Jdjty7QKQVg8GAfr/fTXT6cLtj7wZaolu2SbcbVgjRcVa6XHiXHReiE0QI0cUkjfG3GFmQAbzzSAmNtcjQTXoiFFZ0liThQxc9FB5vLJHW6KjLqidxhFYa7ztOvJASLSPKosF5kFohbr2u+rY15H0gBNsNCBGItCQEQxzHaCW76Cd007tRN8rfCcBvvamAirrhJxFAoGgWc4KztIsZkVRUdkFrDG1dY1XbJWuUpq8V1eyG5eUVTWOp24bq/IzZYsNiXfKzTx5zf3fEo90eo74m1jGmrdEuwjmLpxtsQgaEUKhIY00DpsVSEXSEDhohQpcaUhGWLs2kgydIcEFTt5Ys0aRZxGLe0JFWY2zoIGqdSkXhgiTSgjiNsFtHbTx7gx6td5TGgoO0ct0kcJagfTcMd+fBfQqvaC7PWJcF5atXWCSVSCD1JInl0QNHejAm7qVExxpHzMvPLzm6/4Crnzxlen3C89fPaPHsTYeoyZi6NLy+8rx775Dq/AKjHEZalBDYusU1llHfMTzu8+qmptmsaF2Fdg1meMjs3b+OFxq7vKKtKuRuSvOLP0AbS6Dppoed6RZ/LXHLGZcvA+3dO+Sp5uT8iu2mRUrB48cX+H6JQ9LWW9y2or7oENJewGnco9wsiaaHxG7M1WzNxWZLWG/47PwCHTTpaJ+9vZy9PUEaGW42MVVR4o1llBZM9nOyOObi+oSDoynD4xGbN3PE7pjj3R6XP31JXS+Z3ulztZrj24CODDpA29Q476iWkkRIjBOUZUuiS/I8RrqAIBAHzXK95KpsqNqKjCnBh4754iuiElJytLdYJ2isp9EC1YupXcviqkXr7jNTlZbWe+JYEHTCYttSVRuaJiXT0LYSd5sWE23BSFuESuiNhqyspG03VPM5GxUxGaUoDToOtCvHtmiROSQqpvAlXgXq4prLTwt2Z6YLaMiU69Ofo61kVdaI6xv86hl7m5InouHdvTVx9V9x4gvWizdcffmcel5iFhd88nf+NoNHD5keTvngvqeabfkXNsT0L/MWQuBHv/iUbVGyLFpWpWGQau4dTDneG5OnCXHoWCjcfsCzYc6g3+dXw1SdncliTDdZGmndme3b22TM7QGj+prX0kk8vOvaK/6WaKhUt7vvJns7GYaALm2CIFIaKRUudNVdyoB0AiE9qRJoDCLcYg+ArjKFWwSCBAFRrMCB812So4P0djwaHStCCBjT4r0jTVO0lEg8WmuiSN/28eXte+926M44hI6+vhrpBCTuNrweUFGECtC2Ld50SRqZ96ibirbdIqUiiSVaJmRBUCeWqpb0bWCcZxRVw+XVkvOrGW+u59zZG3M0jKiamiC6lkMIFt3UBOGJkxGVSglKIGS3Mw/OIYTCEmgRaHwHR/OeTEHpAlYEpJBIIZn0eqwua1ogVgKhoa1bsBGrRYHwhigVt4fXEhcEUnnauu3aVkqQBYGRAhlFZFZSNpbl1Ry9v0fVWlzbXdYGqUAaNoXj/Xf6/M2P+/x4nZDtHrC5vmZxs6YuKvLjQ5LBDcvKsdq2iCQhSDg4PGJ7cUOQCevSE1xgNbtEZ31UFFMvb8jHOb/z0Yi9xPN3Pwk08Zik32cyHHJ+coo0DcnOmHg4oN2UNNUKX64JbosVglh7ZKxwwuKNwW0kbjLi8vkpxrUkaYxotwjvaUqDr65xQdAKUCEgjEUIh0YTTIlwlnK+4M/+8c9YXS3woma0PyDXcHwXoiShtY6b85J6e04aCdrDXVK9R3+s8VXNz59c8f9p71xiJbnOOv77Tj36cfs+59ozE4/l2NEIEkWRbUEECooQIEhCRFhmgZQFUTYsQCyQo0hILGGB2EVCAYTEw4uER5QVEQ8hNgSbjPFrxq8Ze+7M9cx9dN/uru56nfOxOKfv9JjrEQZHffuqflKrq09XV3//qtNfV536vu9cfHSdg9cPyI8G9DY6pF3Dmy9ew93dx0WG/Vu3EUloJYbEtCiqisJOfOioCv2+n9HMVDV2RSgKJUmExBl2dkdM1FFQE7c6FBVEOkVpURU500lBN89pRY5K2mxuxmRJi0Rq3ro5ABex3lVamylJXFJkNXUdYZ2ldjCtMtL1LlnVosrGVFaZDMb0J0N+fLMgymq2zq9Ce4WyLqiyDLWKygpRrUxdjo1ihkWN1DUr7YhxJkycxR2OUM25M3iNx5+6TH/3FjkT1jcMK49sk/WPeO2NG2xfWqf3cMKVmze5cKlNMdhl1HmC3mZEzzjs5jb5retMr/0bN+5cYqWfcvnicFbJ6X05Hc4deGVnH3GWjdUVPvWxc5zf6LLWTn3JAOfTj+PY0Ol0Wel0iOPYO0Hr65XXdeVriicJYKkqHzUjxseFi8+/JIoMTl2IYvE1ZfxdVF+1UMIwjhGHUQEXUdbOn4knaZigw1A4GE3GJHHEcDRF1bHWaTMaZ8RxQlFWoXiXd+hVXfsCZSahrivW19eZlkOSNCVJEibTCau9LeIoxYc4grU502lBp5Uiao/L/6pCXTvquvLZsMYgIaNBRIhjf1jV3ctMkhCimaR+2r6inPqhqMSHT5pZfRoD4hxxamglbYrCl2vopoa1TsqFyRaHozH7R0fs3KnYGxWYlqWuLZbaDxdISjGZQlGCGmJ8lJFLUiQGIl+iudsW8sKiGNZX2xT9CSYxdLtCEgm2KhFbsr7aJZ9UbG+uk90ekkRgqek4S7eVsDctsQ4kTrCq1A56nYSkclDVVHGL/rQiKZUyEtpVTtU/wNqaZH3LV8WeTFlf6zLqH1BNas4ZQ6ea0tKK13f6HB2O/OTIUUz7/EWSixcYvfMa4gx5XnIhjri+8w7W7bBfDtFs4o9TVePLvlki4zi3lnCu5TBJydpah6izxp2DIZPdNxl/55s+wcIYnBOgxmR9f9WZdInx00A6a8FWKEPGu7cQiWlf+AjV0RCdjHwgle8AvqYQEZKkmDSBMvc1fjCoU6pigLtzFZcd+kSZdsyTn9ymGky49s4VRqMusXFsnbesrm7x8XOb7GUpOzcPONgvcdM+k5evMqwGXH7s41Sr+5S3lSTqknd7REWE1uASR22nlFVNPS1BasQ4RIXaCZWrSaZT1HVY20qJ6phBVrGz+y5R0mNlq02kMTaf0oqFLIVyPIajI+ppi9W2Y1y3qCcJt4Y5Uoyp6NBZ7ZCPam5Nu5D1GVa+KilVhVaG1FVYLYmlptYuRV2TVyU2K7kT51xeiSkGEc7VvuQHkOLIx1Py8girSuJSsnqMSovYJIjGxDZiWOZsrHbYH/aZvvUyg72YcvUclG/zsUc/wgsH1+ihvH3lJu3eNtmRo9Y+d2yL/rSFqWrakdAToXNxG7cPo70dXjsaceMaFNUSOHeARzZXeOShDda7bbrtNk6F3FqM+ptqSTtlfW2NdruNhvK2eVmSTTJqa4kiP+NPXpXBAXrhzlnv1OIYcQAlOouOAQR/+eeHbnyhXEWZlrMYUqGs/OQZ6yZBygoRYVJZsrwgSVP2Rn5ii8NxgRHjJ/GtLO1WSmmtT9M3MVUNI+vLHIwO+8TGkNaOVstXhjwaT2i3/E3f2lrKwlJWJdOiotdNwUJkOI6VB++7q6Lwg/ZB03EUULix7MKN31lsvEjYRlUiasLwlL+pa52SRArGoc4Rp0KkKYkVogS6bcvmasr2Zoe90ZSbk9uUrvZfLykqEdZEUGcYKaG9TiJKKpCrRasCU1s6aUQHR4FSWOHgaERsDIkPi0cU7u72qYocTEUdpby7u89KKeTqaCUJcWmh06UqMgwxrq4YTR2VUxLrqLKCTC1JHIGkaKzYUhnagp4riaIYpzUun1LmEw61Quuc69dLnmWDUToiOniTV158F5sf0U4Mb794FWc3iNsdokTYuniBPMvIx0Pq4QCrUNdTxFpcFPka9w6SlTWKScnbdyZcV8PRyFEO3vIx/qVybnuFFo5D1onWNlhLKvqDMesPGy70hrx4dci0NDjT9jWORGkZQ5FNEeOo9iLc4T6mzrEmXKmKL+HhVKgqSxQ5f5MxTPLg1FHlQ+reKslj5zFRB7qWq/u3ObpeUGqM2U7QpEA6EYOOIxocstu/S7WfMcoGxBS0VyI2BoZsdJPJIZRVRGulB7mhZ1qoFICfllJcgqkttalwiM9DKHNMWeOKHJGCrOwyPsyY5DAdZMQdC13oJAeQC+NeirNKPZhSZVOKMqOwKeW4z6hYpcxKJuMJbZMxKhJyUVJJGZaOiBjXCkEUBta2ulSDu+TVkGnvAjVCYUq0DaNRzn5LaY0ykriDpm2kKtDYUGtBMSmoXUVtM9JYiJMWw7hFgcNqQn/vEEaH3N7L2dlZIequ0KtKXr12SPWTK+SpIZrsMb11h/qSUIz3mNiEQZVitvq42mKrDoMsp3M+Inn4YaIb61SRkh/dRnX0QJ8qMye3SEREW7GfoGOWwj5v1SxV/rj6YXhTw/g6Mit5pScUsZnbyL2nD4Aehxz5qo33NuszXr1T9NUm762H+rNlfyFwz4j3Wnhsjxwn789/s9+A4M+s5626bzP6P3R+AHncJyps4/69Kfd9xewdVaWsXWifmzhAwtWQEMZj5o2dDVHd/5Uz0/V4P4S9NWffbJMavkLCjVg7txGZ6x8zbb7WZvjs8f6cLYc/+uMv8rbNrrgQQu6A32gURRBFSNLCVaWvp2NdmFym4p6F9+NvkitxHDJPZ1daYW0T9rmTyGepoj5hTZTYOIoyBAKEYyGzDjYT6mOBw7G5tw9P2sfHbepDZoliX3wNQkiwghO//dh/wojvAL7Uh19Hme3LkC0p84c6RHQxO1Dzx+OEPXSsKewHH6J2XC0VI2FCmNBHBDREk8ncjpz1H+eU42KpoV84DV5ivt0Is9ENZwwz36MKor4cxrEe46vJ3uuPLvRJb+t9P1EBZ33GsnV6nCzp7+2BiX3CXRyFQoHG4FAi8dnrYVwY1XC8Q30QdbMhTgc+iel5Vf2J9+5OOD3OfQ/IgP1F2/L/ZJtGw2ngLGiAs6Gj0fCj5TFVfeikN06FcwcQkefe7x9oWWg0nA7OggY4GzoaDYvjwZPwNTQ0NDQsJY1zb2hoaDiDnCbn/seLNuBDoNFwOjgLGuBs6Gg0LIhTM+be0NDQ0PDhcZrO3BsaGhoaPiQW7txF5HMick1E3hCRZxZtz/shIn8qIndF5KW5ti0R+b6IvB6eN+fe+3rQdE1EfmkxVt+PiDwqIv8sIq+KyMsi8puhfWl0iEhbRH4gIi8EDb8X2pdGwwwRiUTkhyLyvfB6GTXcEJEXReSKiDwX2pZKh4hsiMi3ReRq+G389LJpOJFZItAiHkAEvAk8AaTAC8AnFmnTA2z9LPA08NJc2x8Az4TlZ4DfD8ufCFpawONBY3QKNFwEng7Lq8Brwdal0YFPIemF5QT4d+CnlknDnJbfBv4K+N4y9qdg2w1g+z1tS6UD+HPgq2E5BTaWTcNJj0WfuX8aeENV31LVEngW+NKCbToRVf1X4PA9zV/CdwzC86/OtT+rqoWqXgfewGtdKKq6q6r/GZZHwKvAIyyRDvWMw8skPJQl0gAgIpeAXwa+Nde8VBoewNLoEJE1/InbnwCoaqmqA5ZIw/uxaOf+CHBz7vVOaFsWzqvqLnjHCTwc2k+9LhH5KPAU/sx3qXSE4YwrwF3g+6q6dBqAPwJ+B+4r7bdsGsD/sf6DiDwvIl8Lbcuk4wlgD/izMET2LRFZYbk0nMiinftJlVDOQvjOqdYlIj3gO8BvqerwQaue0LZwHapqVfVJ4BLwaRH55ANWP3UaROSLwF1Vff5/+5ET2hZ+HAKfUdWngc8DvyEin33AuqdRR4wfbv2mqj6FL4PyoHt/p1HDiSzaue8Aj869vgTcXpAt/xfuiMhFgPB8N7SfWl0ikuAd+1+q6t+E5qXTARAun/8F+BzLpeEzwK+IyA38UOTPichfsFwaAFDV2+H5LvC3+CGKZdKxA+yEqz+Ab+Od/TJpOJFFO/f/AC6LyOMikgJfBr67YJs+CN8FvhKWvwL8/Vz7l0WkJSKPA5eBHyzAvvsQEcGPLb6qqn8499bS6BCRh0RkIyx3gF8ArrJEGlT166p6SVU/iu/z/6Sqv8YSaQAQkRURWZ0tA78IvMQS6VDVd4GbIvJjoenngVdYIg3vy6Lv6AJfwEdtvAl8Y9H2PMDOvwZ2gQr/7/3rwDngH4HXw/PW3PrfCJquAZ9ftP3Bpp/BX0L+F3AlPL6wTDqATwE/DBpeAn43tC+Nhvfo+VnuRcsslQb8ePUL4fHy7Pe7hDqeBJ4LfervgM1l03DSo8lQbWhoaDiDLHpYpqGhoaHhR0Dj3BsaGhrOII1zb2hoaDiDNM69oaGh4QzSOPeGhoaGM0jj3BsaGhrOII1zb2hoaDiDNM69oaGh4Qzy31ORftg9B/r4AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 一般样本不可能只有一个，我们需要把他转化成网格输出\n",
    "img = torchvision.utils.make_grid([content_img.squeeze(0),styple_img.squeeze(0),input_img.squeeze(0)])\n",
    "# 其次，如果我们是在GPU上跑完的结果的话，我们需要再把结果带回cpu才能转化成numpy数组\n",
    "# 但是我们通过上面的size可以知道我们的颜色通道宽高是不对劲的，于是我们需要转变他的维度，就是我们的tran\n",
    "img = img.cpu().numpy().transpose(1,2,0)\n",
    "plt.imshow(img)\n",
    "plt.savefig(\"./output/\"+content_name)\n",
    "torch.save(new_model,\"./model/style-0.00007-content-0.000006.pth\")"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "风格迁移(内含图像处理方法（矩阵转图片），(图片转矩阵）).ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "pytorch"
  },
  "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.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "032d72fcacaa4808b953bd85dae65a90": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "5f52ed3c438d4dc0917f3ac95595bb7a": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "6002eea3297e4f3399cbbcdb5ef18bbc": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_5f52ed3c438d4dc0917f3ac95595bb7a",
      "placeholder": "​",
      "style": "IPY_MODEL_faac7ec2b6bd464c9492c7b8064acc22",
      "value": " 528M/528M [00:32&lt;00:00, 17.0MB/s]"
     }
    },
    "7fc9a7348f544940b08a24b1ba9d1ccf": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "8c47f46b4eb2485b9e40128d9926bbba": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": "initial"
     }
    },
    "9f88fe92388d4c20a8bc04ad3cf7e924": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_e1de2be4586b45c4a4eb89d8db5add64",
       "IPY_MODEL_6002eea3297e4f3399cbbcdb5ef18bbc"
      ],
      "layout": "IPY_MODEL_7fc9a7348f544940b08a24b1ba9d1ccf"
     }
    },
    "e1de2be4586b45c4a4eb89d8db5add64": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "100%",
      "description_tooltip": null,
      "layout": "IPY_MODEL_032d72fcacaa4808b953bd85dae65a90",
      "max": 553433881,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_8c47f46b4eb2485b9e40128d9926bbba",
      "value": 553433881
     }
    },
    "faac7ec2b6bd464c9492c7b8064acc22": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}