simple-pv-simulator/main.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import glob\n",
    "import shutil\n",
    "\n",
    "def clear_folder_make_ess_pv(folder_path):\n",
    "    if os.path.isdir(folder_path):\n",
    "        shutil.rmtree(folder_path)\n",
    "    os.makedirs(folder_path)\n",
    "    os.makedirs(os.path.join(folder_path,'ess'))\n",
    "    os.makedirs(os.path.join(folder_path,'pv'))\n",
    "\n",
    "folder_path = 'plots'\n",
    "clear_folder_make_ess_pv(folder_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from EnergySystem import EnergySystem\n",
    "from config import pv_config, grid_config, ess_config\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Version 0.0.2\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "print(\"Version 0.0.2\")\n",
    "\n",
    "with open('config.json', 'r') as f:\n",
    "    js_data = json.load(f)\n",
    "\n",
    "data = pd.read_csv('combined_data.csv')\n",
    "time_interval = js_data[\"time_interval\"][\"numerator\"] / js_data[\"time_interval\"][\"denominator\"]\n",
    "\n",
    "pv_loss = js_data[\"pv\"][\"loss\"]\n",
    "pv_cost_per_kW = js_data[\"pv\"][\"cost_per_kW\"]\n",
    "pv_lifetime = js_data[\"pv\"][\"lifetime\"]\n",
    "\n",
    "ess_loss = js_data[\"ess\"][\"loss\"]\n",
    "ess_cost_per_kW = js_data[\"ess\"][\"cost_per_kW\"]\n",
    "ess_lifetime = js_data[\"ess\"][\"lifetime\"]\n",
    "\n",
    "grid_loss = js_data[\"grid\"][\"loss\"]\n",
    "sell_price = js_data[\"grid\"][\"sell_price\"] #kWh\n",
    "grid_capacity = js_data[\"grid\"][\"capacity\"] #kWh\n",
    "\n",
    "pv_begin = js_data[\"pv_capacities\"][\"begin\"]\n",
    "pv_end = js_data[\"pv_capacities\"][\"end\"]\n",
    "pv_groups = js_data[\"pv_capacities\"][\"groups\"]\n",
    "\n",
    "ess_begin = js_data[\"ess_capacities\"][\"begin\"]\n",
    "ess_end = js_data[\"ess_capacities\"][\"end\"]\n",
    "ess_groups = js_data[\"ess_capacities\"][\"groups\"]\n",
    "\n",
    "annot_unmet = js_data[\"annotated\"][\"unmet_prob\"]\n",
    "annot_benefit = js_data[\"annotated\"][\"benefit\"]\n",
    "annot_cost = js_data[\"annotated\"][\"cost\"]\n",
    "\n",
    "title_unmet = js_data[\"plot_title\"][\"unmet_prob\"]\n",
    "title_cost = js_data[\"plot_title\"][\"cost\"]\n",
    "title_benefit = js_data[\"plot_title\"][\"benefit\"]\n",
    "\n",
    "figure_size = (js_data[\"figure_size\"][\"length\"], js_data[\"figure_size\"][\"height\"])\n",
    "\n",
    "pv_capacities = np.linspace(pv_begin, pv_end, pv_groups)\n",
    "ess_capacities = np.linspace(ess_begin, ess_end, ess_groups)\n",
    "results = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
    "affords = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
    "costs = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
    "overload_cnt = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "hour_demand = []\n",
    "for index, row in data.iterrows():\n",
    "    time = row['time']\n",
    "    demand = row['demand']\n",
    "    if time.endswith('00'):\n",
    "        hour_demand.append(demand)\n",
    "plt.figure(figsize=(10,8))\n",
    "plt.plot(hour_demand)\n",
    "plt.ylabel('Demand Power / kW')\n",
    "plt.savefig('plots/demand.png')\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal_profit(es: EnergySystem, saved_money):\n",
    "    profit = saved_money - es.ess.get_cost_per_year() - es.pv.get_cost_per_year()\n",
    "    return profit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ess_capacity:0.0\n",
      "pv_capacity:0.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/stud/hanzhang/simple-pv-simulator/EnergySystem.py:52: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  soc = self.ess.storage / self.ess.capacity\n",
      "/home/stud/hanzhang/simple-pv-simulator/EnergySystem.py:95: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  log = f\"index: {index}, time: {time}, SoC:{self.ess.storage / self.ess.capacity}%, storage: {self.ess.storage}, pv_gen:{generated_pv_power}, power_demand: {factory_demand}, overload_cnt:{self.overload_cnt}, day:{int(index/96) + 1}\"\n",
      "/home/stud/hanzhang/simple-pv-simulator/EnergySystem.py:49: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  soc = self.ess.storage / self.ess.capacity\n",
      "/home/stud/hanzhang/simple-pv-simulator/EnergySystem.py:120: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  self.spring_week_soc.append(self.ess.storage / self.ess.capacity)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pv_capacity:0.0\n",
      "pv_capacity:0.0\n",
      "pv_capacity:0.0\n",
      "pv_capacity:0.0\n",
      "ess_capacity:11111.111111111111\n",
      "pv_capacity:11111.111111111111\n",
      "pv_capacity:11111.111111111111\n",
      "pv_capacity:11111.111111111111\n",
      "pv_capacity:11111.111111111111\n",
      "pv_capacity:11111.111111111111\n",
      "ess_capacity:22222.222222222223\n",
      "pv_capacity:22222.222222222223\n",
      "pv_capacity:22222.222222222223\n",
      "pv_capacity:22222.222222222223\n",
      "pv_capacity:22222.222222222223\n",
      "pv_capacity:22222.222222222223\n",
      "ess_capacity:33333.333333333336\n",
      "pv_capacity:33333.333333333336\n",
      "pv_capacity:33333.333333333336\n",
      "pv_capacity:33333.333333333336\n",
      "pv_capacity:33333.333333333336\n",
      "pv_capacity:33333.333333333336\n",
      "ess_capacity:44444.444444444445\n",
      "pv_capacity:44444.444444444445\n",
      "pv_capacity:44444.444444444445\n",
      "pv_capacity:44444.444444444445\n",
      "pv_capacity:44444.444444444445\n",
      "pv_capacity:44444.444444444445\n",
      "ess_capacity:55555.555555555555\n",
      "pv_capacity:55555.555555555555\n",
      "pv_capacity:55555.555555555555\n",
      "pv_capacity:55555.555555555555\n",
      "pv_capacity:55555.555555555555\n",
      "pv_capacity:55555.555555555555\n",
      "ess_capacity:66666.66666666667\n",
      "pv_capacity:66666.66666666667\n",
      "pv_capacity:66666.66666666667\n",
      "pv_capacity:66666.66666666667\n",
      "pv_capacity:66666.66666666667\n",
      "pv_capacity:66666.66666666667\n",
      "ess_capacity:77777.77777777778\n",
      "pv_capacity:77777.77777777778\n",
      "pv_capacity:77777.77777777778\n",
      "pv_capacity:77777.77777777778\n",
      "pv_capacity:77777.77777777778\n",
      "pv_capacity:77777.77777777778\n",
      "ess_capacity:88888.88888888889\n",
      "pv_capacity:88888.88888888889\n",
      "pv_capacity:88888.88888888889\n",
      "pv_capacity:88888.88888888889\n",
      "pv_capacity:88888.88888888889\n",
      "pv_capacity:88888.88888888889\n",
      "ess_capacity:100000.0\n",
      "pv_capacity:100000.0\n",
      "pv_capacity:100000.0\n",
      "pv_capacity:100000.0\n",
      "pv_capacity:100000.0\n",
      "pv_capacity:100000.0\n"
     ]
    }
   ],
   "source": [
    "for ess_capacity in ess_capacities:\n",
    "    print(f\"ess_capacity:{ess_capacity}\")\n",
    "    for pv_capacity in pv_capacities:\n",
    "        print(f\"pv_capacity:{pv_capacity}\")\n",
    "        pv = pv_config(capacity=pv_capacity, \n",
    "                        cost_per_kW=pv_cost_per_kW,\n",
    "                        lifetime=pv_lifetime, \n",
    "                        loss=pv_loss)\n",
    "        ess = ess_config(capacity=ess_capacity, \n",
    "                            cost_per_kW=ess_cost_per_kW, \n",
    "                            lifetime=ess_lifetime, \n",
    "                            loss=ess_loss,\n",
    "                            charge_power=ess_capacity,\n",
    "                            discharge_power=ess_capacity)\n",
    "        grid = grid_config(capacity=grid_capacity, \n",
    "                            grid_loss=grid_loss,\n",
    "                            sell_price= sell_price)\n",
    "        energySystem = EnergySystem(pv_type=pv, \n",
    "                                    ess_type=ess, \n",
    "                                    grid_type= grid)\n",
    "        benefit = energySystem.simulate(data, time_interval)\n",
    "        results.loc[pv_capacity,ess_capacity] = cal_profit(energySystem, benefit)\n",
    "        affords.loc[pv_capacity,ess_capacity] = energySystem.afford\n",
    "        overload_cnt.loc[pv_capacity,ess_capacity] = energySystem.overload_cnt\n",
    "        costs.loc[pv_capacity,ess_capacity] = energySystem.ess.capacity * energySystem.ess.cost_per_kW + energySystem.pv.capacity * energySystem.pv.cost_per_kW\n",
    "        pv_generated = energySystem.day_generated\n",
    "        ess_generated = energySystem.hour_stored\n",
    "        ess_generated_2 = energySystem.hour_stored_2\n",
    "    plt.figure(figsize=(10,8));\n",
    "    plt.plot(ess_generated)\n",
    "    plt.xlabel('day #')\n",
    "    plt.ylabel('SoC %')\n",
    "    plt.title(f'14:00 ESS SoC \\n PV cap:{pv_capacity}, ESS cap:{ess_capacity}')\n",
    "    plt.savefig(f'plots/ess/1400-{pv_capacity}-{ess_capacity}.png')\n",
    "    plt.close()\n",
    "    plt.figure(figsize=(10,8));\n",
    "    plt.plot(ess_generated_2)\n",
    "    plt.xlabel('day #')\n",
    "    plt.ylabel('SoC%')\n",
    "    plt.title(f'08:00 ESS SoC \\n PV cap:{pv_capacity}, ESS cap:{ess_capacity}')\n",
    "    plt.savefig(f'plots/ess/0800-{pv_capacity}-{ess_capacity}.png')\n",
    "    plt.close()\n",
    "        # print(energySystem.unmet)\n",
    "        # spring_week_start = energySystem.season_start\n",
    "        # spring_week_end = spring_week_start + energySystem.week_length\n",
    "        # summer_week_start = energySystem.season_start + 1 * energySystem.season_step\n",
    "        # summer_week_end = summer_week_start + energySystem.week_length\n",
    "        # autumn_week_start = energySystem.season_start + 2 * energySystem.season_step\n",
    "        # autumn_week_end = autumn_week_start + energySystem.week_length\n",
    "        # winter_week_start = energySystem.season_start + 3 * energySystem.season_step\n",
    "        # winter_week_end = winter_week_start+ energySystem.week_length\n",
    "\n",
    "        # spring_consume_data = []\n",
    "        # summer_consume_data = []\n",
    "        # autumn_consume_data = []\n",
    "        # winter_consume_data = []\n",
    "        # for index, row in data.iterrows():\n",
    "            # if index in range(spring_week_start, spring_week_end):\n",
    "                # spring_consume_data.append(row['demand'])\n",
    "        #     elif index in range(summer_week_start, summer_week_end):\n",
    "        #         summer_consume_data.append(row['demand'])\n",
    "        #     elif index in range(autumn_week_start, autumn_week_end):\n",
    "        #         autumn_consume_data.append(row['demand'])\n",
    "        #     elif index in range(winter_week_start, winter_week_end):\n",
    "        #         winter_consume_data.append(row['demand'])\n",
    "\n",
    "        # spring_week_time = list(range(spring_week_start, spring_week_end))\n",
    "        # summer_week_time = list(range(summer_week_start, summer_week_end))\n",
    "        # autumn_week_time = list(range(autumn_week_start, autumn_week_end))\n",
    "        # winter_week_time = list(range(winter_week_start, winter_week_end))\n",
    "\n",
    "        # spring_pv_generated = energySystem.spring_week_gen\n",
    "        # summer_pv_generated = energySystem.summer_week_gen\n",
    "        # autumn_pv_generated = energySystem.autumn_week_gen\n",
    "        # winter_pv_generated = energySystem.winter_week_gen\n",
    "\n",
    "        # spring_soc = energySystem.spring_week_soc\n",
    "        # summer_soc = energySystem.summer_week_soc\n",
    "        # autumn_soc = energySystem.autumn_week_soc\n",
    "        # winter_soc = energySystem.winter_week_soc\n",
    "\n",
    "\n",
    "        # fig, ax1 = plt.subplots()\n",
    "\n",
    "        # plt.plot(spring_week_time, spring_pv_generated, label = 'pv generation')\n",
    "        # plt.plot(spring_week_time, spring_consume_data, label = 'factory consume')\n",
    "        # plt.ylabel('Power / kW')\n",
    "        # plt.xlabel('15 min #')\n",
    "        # plt.title(f'ess: {energySystem.ess.capacity/1000 } MWh pv: {energySystem.pv.capacity/1000 } MW spring week generate condition')\n",
    "        # plt.legend()\n",
    "        # plt.savefig(f'plots/{energySystem.ess.capacity}-{energySystem.pv.capacity}-spring.png')\n",
    "        # plt.close()\n",
    "\n",
    "        # plt.plot(summer_week_time, summer_pv_generated, label = 'pv generation')\n",
    "        # plt.plot(summer_week_time, summer_consume_data, label = 'factory consume')\n",
    "        # plt.ylabel('Power / kW')\n",
    "        # plt.xlabel('15 min #')\n",
    "        # plt.title(f'ess: {energySystem.ess.capacity/1000 } MWh pv: {energySystem.pv.capacity/1000 } MW summer week generate condition')\n",
    "        # plt.legend()\n",
    "        # plt.savefig(f'plots/{energySystem.ess.capacity}-{energySystem.pv.capacity}-summer.png')\n",
    "        # plt.close()\n",
    "\n",
    "        # plt.plot(autumn_week_time, autumn_pv_generated, label = 'pv generation')\n",
    "        # plt.plot(autumn_week_time, autumn_consume_data, label = 'factory consume')\n",
    "        # plt.ylabel('Power / kW')\n",
    "        # plt.xlabel('15 min #')\n",
    "        # plt.title(f'ess: {energySystem.ess.capacity/1000 } MWh pv: {energySystem.pv.capacity/1000 } MW autumn week generate condition')\n",
    "        # plt.legend()\n",
    "        # plt.savefig(f'plots/{energySystem.ess.capacity}-{energySystem.pv.capacity}-autumn.png')\n",
    "        # plt.close()\n",
    "\n",
    "        # plt.plot(winter_week_time, winter_pv_generated, label = 'pv generation')\n",
    "        # plt.plot(winter_week_time, winter_consume_data, label = 'factory consume')\n",
    "        # plt.ylabel('Power / kW')\n",
    "        # plt.xlabel('15 min #')\n",
    "        # plt.title(f'ess: {energySystem.ess.capacity/1000 } MWh pv: {energySystem.pv.capacity/1000 } MW winter week generate condition')\n",
    "        # plt.legend()\n",
    "        # plt.savefig(f'plots/{energySystem.ess.capacity}-{energySystem.pv.capacity}-winter.png')\n",
    "        # plt.close()\n",
    "\n",
    "    # plt.figure();\n",
    "    # plt.plot(pv_generated)\n",
    "    # plt.xlabel('day #')\n",
    "    # plt.ylabel('Electricity kWh')\n",
    "    # plt.title(f'PV generated pv cap:{pv_capacity}, ess cap:{ess_capacity}')\n",
    "    # plt.savefig(f'plots/pv/{pv_capacity}-{ess_capacity}.png')\n",
    "    # plt.close()\n",
    "\n",
    "\n",
    "        # plt.show()\n",
    "\n",
    "\n",
    "        \n",
    "\n",
    "# results = results.astype(float)\n",
    "\n",
    "\n",
    "# pv = pv_config(capacity=100000,cost_per_kW=200,lifetime=25,loss=0.95)\n",
    "# ess = ess_config(capacity=100000,cost_per_kW=300,lifetime=25,loss=0.95,charge_power=100000,discharge_power=100000)\n",
    "# grid = grid_config(price_schedule=price_schedule, capacity=5000, grid_loss=0.95, sell_price=0.4)\n",
    "# grid = grid_config(capacity=50000, grid_loss=0.95, sell_price=0.4)\n",
    "\n",
    "\n",
    "    # print(benefit)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_data(data, filename):\n",
    "    data.to_csv(filename+'.csv')\n",
    "    data.to_json(filename + '.json')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAy0AAAOVCAYAAABkiQ8eAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAADo5UlEQVR4nOzdZ3gU5fv//c8mkEJCQktI6KFIr0EgIE0ioYigiCJIF5SiAiJFkWZBKSqIiBXQnygiigrSpApEOiodpH0pSeiBkL5zP+Bm/7smQIIJMyTv13HMoZm5dvaczG7Yc8+r2AzDMAQAAAAAFuVmdgAAAAAAcCskLQAAAAAsjaQFAAAAgKWRtAAAAACwNJIWAAAAAJZG0gIAAADA0khaAAAAAFgaSQsAAAAASyNpAQAAAGBpJC05wLFjx2Sz2TRnzhyzQ8mwtWvXymazae3atZl+7Lhx42Sz2bI+qP8gOjpajz/+uAoXLiybzab333//P13jvc6K9wj3lpz6nrLC3+s2bdqob9++jp/nzJkjm82mbdu2mRYT0rd3717lyZNHu3fvNjsUwHQkLfeAG/+gpLeNHDnS7PAsq2fPni6/Kz8/P9WsWVNTp05VYmJilj7XkCFDtHz5co0aNUpfffWVWrVqlW67efPm6f3338/wecuUKeNyDV5eXqpQoYJefvllXbhwIYuiz/maNWvm8nssVKiQ7r//fn3xxRey2+1Z+lxz585VtWrVlC9fPpUsWVLdu3fX6dOnM/z4W73fbTab/vjjjyyN91aio6M1bNgwVapUSfny5ZOPj49CQ0P1xhtv6NKlS9n63Bl9T1lVZt/rd8vGjRu1YsUKjRgxIsvO+e+/tf/+m3XD7ZKjhx9+WGXKlHHZ9+/z+fn5qWnTplqyZEmm4+zYsaPatGmT6ceZqUqVKmrbtq3GjBljdiiA6fKYHQAybsKECQoJCXHZV61aNZUuXVrx8fHKmzevSZFlXpMmTRQfHy8PD49sfR5PT0999tlnkqRLly5p4cKFGjZsmLZu3apvv/02y55n9erVat++vYYNG+bYd99996W5xnnz5mn37t0aPHhwhs9dq1YtvfTSS5KkhIQEbd++Xe+//77WrVunLVu2ZNk15HQlSpTQxIkTJUlnz57Vl19+qT59+ujgwYN6++23s+Q5fvzxR/Xs2VNNmzbVoEGDFBMTo++//14HDx5UsWLFMnWu9N7vklS+fPksifV2tm7dqjZt2ujq1at6+umnFRoaKknatm2b3n77ba1fv14rVqzItufP6HvKqm72Xjf77/XkyZPVokWLLH8dOf+tdebu7v6fz/3QQw+pe/fuMgxDx48f10cffaR27dpp6dKlioiIyNA5kpOTtXLlSsffgHvJc889pzZt2uiff/5RuXLlzA4HMA1Jyz2kdevWqlu3brrHnL/Nuhe4ubndlZjz5Mmjp59+2vHzgAEDVL9+fc2fP1/vvvtuuh8kDcNQQkKCvL29M/w8MTExKlCggMu+rLrG4sWLu1zDM888I19fX02ZMkWHDh1ShQoV/vNz5Ab+/v4uv8dnn31WFStW1IwZM/T6669nyYfIb7/9VoUKFdKyZcsc937MmDFKSkrK9Llu9X7PbpcuXdKjjz4qd3d37dy5U5UqVXI5/uabb+rTTz/N1hiy8z11J65du6Z8+fL95/P8u/pwN8XExGjJkiWaNWtWlp/7339rs9J9993ncu6OHTuqSpUqmjZtWoaTlt9//11XrlxR27ZtsyXGrJaSkiK73S4PDw+Fh4erYMGCmjt3riZMmGB2aIBp6B6WA6TXR7pnz57y9fXVqVOn1KFDB/n6+iogIEDDhg1Tamqqy+OnTJmihg0bqnDhwvL29lZoaKi+//77NM9js9k0aNAgLVq0SNWqVZOnp6eqVq2qZcuWpWl76tQp9enTR8WKFZOnp6dCQkLUv39/x4e39Pqm//777+rUqZNKlSolT09PlSxZUkOGDFF8fHzW/KJ0/UNPs2bNJF3/vUnXu2A9/PDDWr58uerWrStvb299/PHHkqQjR46oU6dOKlSokPLly6cGDRq4dEu40d3BMAx9+OGHji4M6V1js2bNtGTJEh0/ftzR7t9dITIqKChI0vUPCjf89ddf6tmzp8qWLSsvLy8FBQWpd+/eOn/+vMtjr1y5osGDB6tMmTLy9PRUYGCgHnroIe3YscOl3ebNm9WqVSv5+/srX758atq0qTZu3Jgmlg0bNuj++++Xl5eXypUr5/jdZdSCBQsUGhoqb29vFSlSRE8//bROnTrl0iYzr+eMunE/4+LidPbsWY0dO1Z58+bV2bNn07Tt16+fChQooISEhFue083NTSkpKWm+Xc6uysC3336r0NBQ5c+fX35+fqpevbqmTZvmOJ6cnKzx48erQoUK8vLyUuHChfXAAw9o5cqVtzzvxx9/rFOnTundd99Nk7BIUtGiRTV69GiXfTNnzlTVqlXl6empYsWKaeDAgWm6kDVr1kzVqlXT3r171bx5c+XLl0/FixfXpEmTHG0y85664cMPP1TZsmXl7e2tevXq6ffff1ezZs0c73Xn895439+Q3jlvxLl9+3Y1adJE+fLl0yuvvCJJ+umnn9S2bVvH37Zy5crp9ddfd3kd3uq9frMxLatXr1bjxo3l4+OjAgUKqH379tq3b59LmxtjxQ4fPqyePXuqQIEC8vf3V69evXTt2rU09+nflixZopSUFIWHh9+27cWLF1WvXj2VKFFCBw4cuG37u6ly5coqUqSI/vnnnww/ZsmSJapSpcpN/+YeOXJENptN7733XppjmzZtks1m0zfffOPYd+rUKfXu3VtFixZ1/Fv4xRdfuDwuKSlJY8aMUWhoqPz9/eXj46PGjRtrzZo1Lu1uvCamTJmi999/X+XKlZOnp6f27t0rScqbN6+aNWumn376KcPXC+REVFruIZcvX9a5c+dc9hUpUuSm7VNTUxUREaH69etrypQp+u233zR16lSVK1dO/fv3d7SbNm2aHnnkEXXt2lVJSUn69ttv1alTJy1evDjNt1IbNmzQDz/8oAEDBih//vyaPn26OnbsqBMnTqhw4cKSpNOnT6tevXq6dOmS+vXrp0qVKunUqVP6/vvvde3atZt+gFuwYIGuXbum/v37q3DhwtqyZYs++OADnTx5UgsWLLjTX1saN/6huxGvJB04cEBPPfWUnn32WfXt21cVK1ZUdHS0GjZsqGvXrumFF15Q4cKFNXfuXD3yyCP6/vvv9eijj6pJkyb66quv1K1bN0cXhpt59dVXdfnyZZ08edLxD6Ovr+9t401OTnbc94SEBO3cuVPvvvuumjRp4tJ9aOXKlTpy5Ih69eqloKAg7dmzR5988on27NmjP/74w/HB77nnntP333+vQYMGqUqVKjp//rw2bNigffv2qU6dOpKuf4Bq3bq1QkNDNXbsWLm5uWn27Nl68MEH9fvvv6tevXqSpL///lstW7ZUQECAxo0bp5SUFI0dO1ZFixbN0L2YM2eOevXqpfvvv18TJ05UdHS0pk2bpo0bN2rnzp0u37Rn9PWcGUeOHJG7u7sKFCigbt26acKECZo/f74GDRrkaJOUlKTvv/9eHTt2vO035L169dK3336rMWPG/OduKOm93202m+N1u3LlSj311FNq0aKF3nnnHUnSvn37tHHjRr344ouSrn/InThxop555hnVq1dPsbGx2rZtm3bs2KGHHnrops/9888/y9vbW48//niGYh03bpzGjx+v8PBw9e/fXwcOHNBHH32krVu3auPGjS5VrIsXL6pVq1Z67LHH9MQTT+j777/XiBEjVL16dbVu3TpT7ylJ+uijjzRo0CA1btxYQ4YM0bFjx9ShQwcVLFhQJUqUyFD86Tl//rxat26tzp076+mnn3a8pufMmSNfX18NHTpUvr6+Wr16tcaMGaPY2FhNnjxZUubf67/99ptat26tsmXLaty4cYqPj9cHH3ygRo0aaceOHWk+aD/xxBMKCQnRxIkTtWPHDn322WcKDAx0vA5uZtOmTSpcuLBKly59y3bnzp3TQw89pAsXLmjdunUZ7pL079erdD1h9/Pzy9DjM+ry5cu6ePFiprpK/frrr3r44Ydverxs2bJq1KiRvv76aw0ZMsTl2Ndff638+fOrffv2kq6P9WrQoIHji7yAgAAtXbpUffr0UWxsrKNLYGxsrD777DM99dRT6tu3r65cuaLPP/9cERER2rJli2rVquXyPLNnz1ZCQoL69esnT09PFSpUyHEsNDRUP/30k2JjY7P89wncMwxY3uzZsw1J6W6GYRhHjx41JBmzZ892PKZHjx6GJGPChAku56pdu7YRGhrqsu/atWsuPyclJRnVqlUzHnzwQZf9kgwPDw/j8OHDjn1//vmnIcn44IMPHPu6d+9uuLm5GVu3bk1zLXa73TAMw1izZo0hyVizZs1N4zAMw5g4caJhs9mM48ePO/aNHTvWyMhLt0ePHoaPj49x9uxZ4+zZs8bhw4eNt956y7DZbEaNGjUc7UqXLm1IMpYtW+by+MGDBxuSjN9//92x78qVK0ZISIhRpkwZIzU11eV3M3DgQJfHp3eNbdu2NUqXLn3b2P8d27+3Ro0aGefOnXNpm97v75tvvjEkGevXr3fs8/f3TxOrM7vdblSoUMGIiIhw3K8b5w8JCTEeeughx74OHToYXl5eLvdn7969hru7+23vUVJSkhEYGGhUq1bNiI+Pd+xfvHixIckYM2aMY19mXs/padq0qVGpUiXHa2Hfvn3GCy+8YEgy2rVr52gXFhZm1K9f3+WxP/zwQ5r7eDMzZ840PD09DUnGtGnTbts+Pbd6v3t6ejravfjii4afn5+RkpJy03PVrFnTaNu2baZjKFiwoFGzZs0MtY2JiTE8PDyMli1burwnZsyYYUgyvvjiC8e+pk2bGpKML7/80rEvMTHRCAoKMjp27Ohy3oy8pxITE43ChQsb999/v5GcnOxoN2fOHEOS0bRpU8e+G7/Xo0eP3vKcznHOmjUrzfWm9z579tlnjXz58hkJCQmOfTd7r6f397pWrVpGYGCgcf78ece+P//803BzczO6d+/u2Hfjb1/v3r1dzvnoo48ahQsXTvNc//bAAw+k+3658bvZunWrcebMGaNq1apG2bJljWPHjt32nIbx/96f6W0RERHpPk960vudSTL69OljnD171oiJiTG2bdtmtGrVypBkTJ48OUPxHTlyJEPv4Y8//tiQZOzbt8+xLykpyShSpIjRo0cPx74+ffoYwcHBaf4Gd+7c2fD393e8RlJSUozExESXNhcvXjSKFi3qcg9vvCb8/PyMmJiYdGObN2+eIcnYvHlzRi4ZyJHoHnYP+fDDD7Vy5UqX7Xaee+45l58bN26sI0eOuOxzHrtx8eJFXb58WY0bN07TXUiSwsPDXb7dqlGjhvz8/BzntNvtWrRokdq1a5duf/xbTYPrHEdcXJzOnTunhg0byjAM7dy58zZXmr64uDgFBAQoICBA5cuX1yuvvKKwsDD9+OOPLu1CQkLS9I3+9ddfVa9ePT3wwAOOfb6+vurXr5+OHTvmKN1nt/r16zvu9+LFi/Xmm29qz549euSRR1y6zjn//hISEnTu3Dk1aNBAklzuZYECBbR58+abzmi1a9cuHTp0SF26dNH58+d17tw5nTt3TnFxcWrRooXWr18vu92u1NRULV++XB06dFCpUqUcj69cuXKG+plv27ZNMTExGjBggEsFo23btqpUqVK6swNl5PV8M/v373e8FipXrqwPPvhAbdu2denS0b17d23evNml28nXX3+tkiVLqmnTprc8/08//aSBAwfq+++/16uvvqrBgwdr9uzZLm0qVqyobt26ZSje9N7vS5cudRwvUKCA4uLibvl3oECBAtqzZ48OHTqUoee8ITY2Vvnz589Q299++01JSUkaPHiw3Nz+3z8pffv2lZ+fX5r76Ovr6zI+wcPDQ/Xq1cvwfXS2bds2nT9/Xn379nXpKtm1a1cVLFgw0+dz5unpqV69eqXZ7/w+u3Llis6dO6fGjRvr2rVr2r9/f6af58yZM9q1a5d69uzp8s16jRo19NBDD+nXX39N85j03gfnz59XbGzsLZ/r/Pnzt/y9nDx5Uk2bNlVycrLWr19/24qMMy8vrzSv15UrV2bJJBeff/65AgICFBgYqLp162rVqlUaPny4hg4dmqHHL1myRP7+/i5/y9PzxBNPyMvLS19//bVj3/Lly3Xu3DnHa9YwDC1cuFDt2rWTYRiOv4/nzp1TRESELl++7Ph76+7u7uhZYLfbdeHCBaWkpKhu3brp/vvasWNHBQQEpBvbjfuWXjULyC3oHnYPqVevXqYG5np5eaX5A1iwYEFdvHjRZd/ixYv1xhtvaNeuXS5TAaeXYDh/OE3vnGfPnlVsbKyqVauW4ThvOHHihMaMGaOff/45TYyXL1/O9Pmk67+DX375RZIcY2vS6zKS3ixNx48fV/369dPsr1y5suP4nVxnZhUpUsSlD3rbtm1VsWJFPf744/rss8/0/PPPS5IuXLig8ePH69tvv1VMTIzLOZx/f5MmTVKPHj1UsmRJhYaGqk2bNurevbvKli0rSY4PuD169LhpTJcvX1ZiYqLi4+PTnQigYsWK6X7Ycnb8+HFH23+rVKmSNmzY4LIvo6/nmylTpow+/fRTl6mjAwMDXdo8+eSTGjx4sL7++muNGTNGly9f1uLFizVkyJDbrjszYsQItW7dWg8//LAefvhhRUdHq2/fvsqfP78ef/xxXbt2TUePHnXcr9u53ft9wIAB+u6779S6dWsVL15cLVu21BNPPOEyNfCECRPUvn173XfffapWrZpatWqlbt26qUaNGrd8bj8/P125ciVDcd7sPnp4eKhs2bKO4zeUKFEize+yYMGC+uuvvzL0fOk9979nwsqTJ88djxe7oXjx4ul2Zd2zZ49Gjx6t1atXp0kS7uTv1K3eB5UrV9by5csVFxcnHx8fx/5//x2+8YH24sWLt+06ZBjGTY9169ZNefLk0b59+xzj5m6Ij49Pc33Obdzd3TM0VuZ20nuftW/fXoMGDVJSUpK2bt2qt956S9euXXNJkm9lyZIlatmypUtim54CBQqoXbt2mjdvnl5//XVJ17+0KF68uB588EFJ1/+Nu3Tpkj755BN98skn6Z7H+e/v3LlzNXXqVO3fv1/JycmO/en9m5Pevhtu3DfWv0JuRtKSg2Vkqsnff/9djzzyiJo0aaKZM2cqODhYefPm1ezZszVv3rwMn/NW/xBmRGpqqqMP9YgRI1SpUiX5+Pjo1KlT6tmz5x2vpZHRf0gzM1OYFbRo0UKStH79eseH4CeeeEKbNm3Syy+/rFq1asnX11d2u12tWrVy+f098cQTaty4sX788UetWLFCkydP1jvvvKMffvhBrVu3drSdPHlymj7XN/j6+mb5Wje381+nTvXx8bnta6FgwYJ6+OGHHUnL999/r8TExNvOinThwgUdOHBAXbt2deybNWuWzp49qy5dusjHx0dHjhyRm5tbhseJ3E5gYKB27dql5cuXa+nSpVq6dKlmz56t7t27a+7cuZKuTy3+zz//6KefftKKFSv02Wef6b333tOsWbP0zDPP3PTclSpV0q5du5SUlJTlkwhk19+Q27nZh72bTeSQ3t+ES5cuqWnTpvLz89OECRNUrlw5eXl5aceOHRoxYkSWr/lzM3f6OyxcuPAtk/zHHntMX375paZNm5ZmTNb8+fPTVJ4ye89uVFRvNrnKtWvX0h03VqJECcd7t02bNipSpIgGDRqk5s2b67HHHrvlc167dk1r167VRx99lKEYu3fvrgULFmjTpk2qXr26fv75Zw0YMMCRIN24x08//fRNv9i58aXA//3f/6lnz57q0KGDXn75ZQUGBsrd3V0TJ05MdxKBW/07dOO+3WocK5DTkbTkcgsXLpSXl5eWL18uT09Px/5/d2vJqICAAPn5+WV69d6///5bBw8e1Ny5c10G3makC1x2KV26dLqz5tzoApKZrhM3ZNW3ZCkpKZKkq1evSrr+D9qqVas0fvx4l0XIbtYtKDg4WAMGDNCAAQMUExOjOnXq6M0331Tr1q0d3f/8/Pxu+SE/ICBA3t7e6T5HRmYbuvH7O3DggONbTOfH38nvNyt0795d7du319atW/X111+rdu3aqlq16i0fc+O+/u9//3Psc3d317fffquWLVuqY8eO8vPzU//+/dN8g/1feHh4qF27dmrXrp3sdrsGDBigjz/+WK+99pqj+lCoUCH16tVLvXr10tWrV9WkSRONGzfulklLu3btFBkZqYULF+qpp566ZQzO9/FGtU66PoHB0aNHs+Tb99s99+HDh9W8eXPH/pSUFB07dsylonSjGvHvGc3+XQm6lbVr1+r8+fP64Ycf1KRJE8f+o0ePpmmb0fe68+/v3/bv368iRYq4VFn+i0qVKmnhwoU3Pf7888+rfPnyGjNmjPz9/V0WL46IiPjPf4+dr7Vx48Zpjh88eDBD1etnn31W7733nkaPHq1HH330lr/r1atXKzExUa1bt85QjK1atVJAQIC+/vpr1a9fX9euXXPp0hkQEKD8+fMrNTX1tq/t77//XmXLltUPP/zgEuPYsWMzFIuzo0ePys3NTffdd1+mHwvkFIxpyeXc3d1ls9lcvm08duyYFi1adEfnc3NzU4cOHfTLL7+ku+rxzb6Zu/HNofNxwzBcpm+929q0aaMtW7YoMjLSsS8uLk6ffPKJypQpoypVqmT6nD4+Pnfc1c3ZjS5vNWvWlJT+709SmhW5U1NT0zx/YGCgihUr5qichIaGqly5cpoyZYojKXJ2Y0pgd3d3RUREaNGiRTpx4oTj+L59+7R8+fLbXkPdunUVGBioWbNmuVRtli5dqn379pm2nkLr1q1VpEgRvfPOO1q3bl2G1p4oWLCg6tSpo3nz5rmMa/Dy8tJXX30lu92u6OhodejQIcvi/PdU1m5ubo4P6Td+n/9u4+vrq/Lly9+2Svbcc88pODhYL730kg4ePJjmeExMjN544w1J18e5eXh4aPr06S6vv88//1yXL1/O1vtYt25dFS5cWJ9++qkjkZeud+n5d0XhRjK+fv16x77U1NSbdvFJT3rvs6SkJM2cOTNN24y+14ODg1WrVi3NnTvXJaHavXu3VqxYkaUruIeFhenixYu3HD/02muvadiwYRo1apRLdSI4OFjh4eEuW2aFhoYqMDBQn332WZrX4KJFi3Tq1KkMJRd58uTRSy+9pH379t12GuBff/1VdevWzfCMhnny5NFTTz2l7777TnPmzFH16tVdkl93d3d17NhRCxcuTPfLOecp09N7vWzevNnl35SM2r59u6pWrSp/f/9MPxbIKai05HJt27bVu+++q1atWqlLly6KiYnRhx9+qPLly99RH3NJeuutt7RixQo1bdpU/fr1U+XKlXXmzBktWLBAGzZsSLNgnHT9G8By5cpp2LBhOnXqlPz8/LRw4cIMj1fIDiNHjtQ333yj1q1b64UXXlChQoU0d+5cHT16VAsXLsxwf2pnoaGhmj9/voYOHar7779fvr6+ateu3S0fc+rUKf3f//2fpOsfkP788099/PHHKlKkiKNrmJ+fn5o0aaJJkyYpOTlZxYsX14oVK9J8A3zlyhWVKFFCjz/+uGrWrClfX1/99ttv2rp1q6ZOnSrp+offzz77TK1bt1bVqlXVq1cvFS9eXKdOndKaNWvk5+fnSJrGjx+vZcuWqXHjxhowYIBSUlL0wQcfqGrVqrd9/eTNm1fvvPOOevXqpaZNm+qpp55yTHlcpkyZNNOO3i158+ZV586dNWPGDLm7u9+20nDDBx98oPDwcNWrV0/PPvusKlWqpGPHjumLL75Q0aJF5ebmpi5dumjz5s0Zmop36dKl6Q7sbtiwocqWLatnnnlGFy5c0IMPPqgSJUro+PHj+uCDD1SrVi3HuKsqVaqoWbNmCg0NVaFChbRt2zbHdNe3UrBgQf34449q06aNatWqpaefflqhoaGSrk/q8M033ygsLEzS9W+eR40apfHjx6tVq1Z65JFHdODAAc2cOVP3339/ti04KF2vNI0bN07PP/+8HnzwQT3xxBM6duyY5syZo3Llyrl8u121alU1aNBAo0aN0oULF1SoUCF9++23LsnO7TRs2FAFCxZUjx499MILL8hms+mrr75K98uYzLzXJ0+erNatWyssLEx9+vRxTHns7++vcePGZfr3cjNt27ZVnjx59Ntvv6lfv343bTd58mRdvnxZAwcOVP78+TN0D1NSUhx/p/7t0UcflY+Pjzw8PDRlyhT16NFD999/v5588kkVLlxYO3fu1BdffKEaNWrcMi5nPXv21JgxY/TOO+/c8suAX3/9Nd0JFW6le/fumj59utasWZPuNNJvv/221qxZo/r166tv376qUqWKLly4oB07dui3337ThQsXJEkPP/ywfvjhBz366KNq27atjh49qlmzZqlKlSrpfiF0M8nJyVq3bp0GDBiQqesAcpy7Pl8ZMu1200TebMpjHx+fNG3Tmy74888/NypUqGB4enoalSpVMmbPnp1uO6UzBalhXJ+W13k6SMMwjOPHjxvdu3c3AgICDE9PT6Ns2bLGwIEDHdM/pjfN6N69e43w8HDD19fXKFKkiNG3b1/HlMrO15bZKY9vp3Tp0jedFvaff/4xHn/8caNAgQKGl5eXUa9ePWPx4sVp2qX3u0nvGq9evWp06dLFKFCggCHpttMf/3vKYzc3NyMwMNB46qmnXKaeNgzDOHnypPHoo48aBQoUMPz9/Y1OnToZp0+fNiQZY8eONQzj+hSxL7/8slGzZk0jf/78ho+Pj1GzZk1j5syZaZ57586dxmOPPWYULlzY8PT0NEqXLm088cQTxqpVq1zarVu3zggNDTU8PDyMsmXLGrNmzcrwPTIMw5g/f75Ru3Ztw9PT0yhUqJDRtWtX4+TJky5tMvN6Tk/Tpk2NqlWrZigewzCMLVu2GJKMli1bZvgxhmEYf/31l/HYY48ZhQoVMjw8PIwKFSoYo0aNMi5cuGDs2rXL8Pb2NmrWrGnExsbe9By3mvLY+b3w/fffGy1btjQCAwMNDw8Po1SpUsazzz5rnDlzxnGuN954w6hXr55RoEABw9vb26hUqZLx5ptvGklJSRm6ntOnTxtDhgwx7rvvPsPLy8vIly+fERoaarz55pvG5cuXXdrOmDHDqFSpkpE3b16jaNGiRv/+/Y2LFy+6tLnZfejRo0e6U91m5D1lGIYxffp0o3Tp0oanp6dRr149Y+PGjUZoaKjRqlUrl3b//POPER4ebnh6ehpFixY1XnnlFWPlypXpTnl8s9fLxo0bjQYNGhje3t5GsWLFjOHDhxvLly/P8Hs9vb/XhmEYv/32m9GoUSPD29vb8PPzM9q1a2fs3bvXpc2N1/vZs2dd9t9sOuf0PPLII0aLFi3SfbzzvzGpqanGU089ZeTJk8dYtGjRLc95qymP04tr6dKlRvPmzQ0/Pz8jb968RkhIiDF06NA0rxfDuPm/O4ZhGOPGjbvlVMa7d+82JBlbtmy5ZfzpqVq1quHm5pbmb9EN0dHRxsCBA42SJUsaefPmNYKCgowWLVoYn3zyiaON3W433nrrLcdrs3bt2sbixYvTvN5vvCZuNoXz0qVLDUnGoUOHMn0dQE5iM4xsHv0IAPeYP//8U7Vq1dKXX36Z4SmKYR12u10BAQF67LHH9Omnn5odjqX8/vvvatasmfbv35/uzH85yaRJk/Tuu+/qzJkzmR5PWLt2bRUqVEirVq3KpugyrkOHDrLZbGmm6gdyG8a0AMC/fPrpp/L19b3tzEQwX0JCQpruWV9++aUuXLigZs2amROUhTVu3FgtW7bUpEmTzA4l25UpU0bvvfdephOWbdu2adeuXS6Twphl3759Wrx4sWMKZiA3o9ICAP+/X375RXv37tVrr72mQYMG6d133zU7JNzG2rVrNWTIEHXq1EmFCxfWjh079Pnnn6ty5cravn17lk/ZjJxr9+7d2r59u6ZOnapz587pyJEj6U7BDMAcDMQHgP/f888/r+joaLVp00bjx483OxxkQJkyZVSyZElNnz7dMcC+e/fuevvtt0lYkCnff/+9JkyYoIoVK+qbb74hYQEshkoLAAAAAEtjTAsAAAAASyNpAQAAAGBpOXJMy95HW5gdgikKlQ82OwRTFGhUz+wQTHGpUmOzQzDFuTy583VuN3Lnd0xJ9rxmh2CKZLu72SGYIrded1Jqjvw4dlvhNTzNDuGmluStaHYIDm2TD5gdgiXkzn8FAQAAANwzSFoAAAAAWFrurEcCAAAAN2HLm7lFSZH9qLQAAAAAsDSSFgAAAACWRvcwAAAAwIlbHrqHWQ2VFgAAAACWRtICAAAAwNLoHgYAAAA4seXle32r4Y4AAAAAsDQqLQAAAIATBuJbD5UWAAAAAJZG0gIAAADA0ugeBgAAADix5aV7mNVQaQEAAABgaSQtAAAAACyN7mEAAACAE2YPsx4qLQAAAAAsjUoLAAAA4ISB+NZDpQUAAACApZG0AAAAALA0uocBAAAAThiIbz1UWgAAAABYGkkLAAAAAEujexgAAADgxOZO9zCrodICAAAAwNJIWgAAAABYGt3DAAAAACdudA+zHCotAAAAACyNSgsAAADgxOZGpcVqqLQAAAAAsDSSFgAAAACWRvcwAAAAwInNne/1rYY7AgAAAMDSSFoAAAAAWBrdwwAAAAAnrNNiPVRaAAAAAFgalRYAAADACeu0WA+VFgAAAACWRtICAAAAwNLoHgYAAAA4YSC+9VBpAQAAAGBpJC0AAAAALI3uYQAAAIATG93DLIdKCwAAAABLo9ICAAAAOLG58b2+1XBHAAAAAFgaSQsAAAAAS6N7GAAAAODE5sZAfKuh0gIAAADA0khaAAAAAFga3cMAAAAAJ26s02I5VFoAAAAAWBpJCwAAAABLo3sYAAAA4ITZw6yHSgsAAAAAS6PSAgAAADixufG9vtVwRwAAAABYmumVlqSkJC1atEiRkZGKioqSJAUFBalhw4Zq3769PDw8TI4QAAAAgJlMrbQcPnxYlStXVo8ePbRz507Z7XbZ7Xbt3LlT3bt3V9WqVXX48GEzQwQAAEAuY3OzWWbDdaZWWvr376/q1atr586d8vPzczkWGxur7t27a+DAgVq+fLlJEQIAAAAwm6lJy8aNG7Vly5Y0CYsk+fn56fXXX1f9+vVNiAwAAACAVZiatBQoUEDHjh1TtWrV0j1+7NgxFShQ4O4GBQAAgFzNzZ1uWVZjatLyzDPPqHv37nrttdfUokULFS1aVJIUHR2tVatW6Y033tDzzz9vZogAAAAATGZq0jJhwgT5+Pho8uTJeumll2SzXc9qDcNQUFCQRowYoeHDh5sZIgAAAHIZBsBbj+lTHo8YMUIjRozQ0aNHXaY8DgkJMTkyAAAAAFZgetJyQ0hICIkKAAAAgDQsk7Sk56efftLly5fVvXt3s0MBAABALmFzM3UpQ6TD0knLiBEjdOjQoVsmLYmJiUpMTHTZl5Rql4c7LzYAAAAgJ7D0J/v9+/crNTX1lm0mTpwof39/l+3Tg8fuToAAAAAAsp2lk5aMGDVqlC5fvuyy9b2vjNlhAQAA4B5lc7NZZsuMU6dO6emnn1bhwoXl7e2t6tWra9u2bY7jhmFozJgxCg4Olre3t8LDw3Xo0CGXc1y4cEFdu3aVn5+fChQooD59+ujq1asubf766y81btxYXl5eKlmypCZNmnTnv+wMskT3sC1btigyMtJl9rCwsDDVq1fvto/19PSUp6enyz66hgEAACA3uXjxoho1aqTmzZtr6dKlCggI0KFDh1SwYEFHm0mTJmn69OmaO3euQkJC9NprrykiIkJ79+6Vl5eXJKlr1646c+aMVq5cqeTkZPXq1Uv9+vXTvHnzJEmxsbFq2bKlwsPDNWvWLP3999/q3bu3ChQooH79+mXb9dkMwzCy7ey3ERMTo44dO2rjxo0qVaqUy+KSJ06cUKNGjbRw4UIFBgZm6rx7H22RHeFaXqHywWaHYIoCjW6f3OZElyo1NjsEU5zLkztf53Yjd34Zk2TPa3YIpki2u5sdgily63UnpVriO+S7LryG5+0bmWR/p5Zmh+BQacGKDLUbOXKkNm7cqN9//z3d44ZhqFixYnrppZc0bNgwSdLly5dVtGhRzZkzR507d9a+fftUpUoVbd26VXXr1pUkLVu2TG3atNHJkydVrFgxffTRR3r11VcVFRUlDw8Px3MvWrRI+/fvz4IrTp+p/woOGDBAqamp2rdvn44dO6bNmzdr8+bNOnbsmPbt2ye73a6BAweaGSIAAAByGbO7hDlviYmJio2Nddn+PQmVJP3888+qW7euOnXqpMDAQNWuXVuffvqp4/iNNRHDw8Md+/z9/VW/fn1FRkZKkiIjI1WgQAFHwiJJ4eHhcnNz0+bNmx1tmjRp4khYJCkiIkIHDhzQxYsXs/xe3GBq0rJ8+XJ9+OGHqlixYppjFStW1PTp07Vs2TITIgMAAADMl96kUxMnTkzT7siRI/roo49UoUIFLV++XP3799cLL7yguXPnSpJjGMaNnk03FC1a1HEsKioqTQ+nPHnyqFChQi5t0juH83NkB1PrkZ6enoqNjb3p8StXrqQZrwIAAABkp8wOgM9Oo0aN0tChQ132pff52G63q27dunrrrbckSbVr19bu3bs1a9Ys9ejR467Emp1MrbQ8+eST6tGjh3788UeX5CU2NlY//vijevXqpaeeesrECAEAAADzeHp6ys/Pz2VLL2kJDg5WlSpVXPZVrlxZJ06ckHR9oivp+thxZ9HR0Y5jQUFBiomJcTmekpKiCxcuuLRJ7xzOz5EdTE1a3n33XbVu3VqdO3dWwYIF5e3tLW9vbxUsWFCdO3dW69atNWXKFDNDBAAAACyvUaNGOnDggMu+gwcPqnTp0pKkkJAQBQUFadWqVY7jsbGx2rx5s8LCwiRJYWFhunTpkrZv3+5os3r1atntdtWvX9/RZv369UpOTna0WblypSpWrOgyU1lWM7172EcffaR33nlH27dvd5nyODQ0VH5+fmaGBwAAgFzI5nbvzdg4ZMgQNWzYUG+99ZaeeOIJbdmyRZ988ok++eQTSZLNZtPgwYP1xhtvqEKFCo4pj4sVK6YOHTpIul6ZadWqlfr27atZs2YpOTlZgwYNUufOnVWsWDFJUpcuXTR+/Hj16dNHI0aM0O7duzVt2jS999572Xp9lphjz8/PT82bN1dcXJy+++47/fbbb9q7d686d+6swoULmx0eAAAAYGn333+/fvzxR40aNUoTJkxQSEiI3n//fXXt2tXRZvjw4YqLi1O/fv106dIlPfDAA1q2bJljjRZJ+vrrrzVo0CC1aNFCbm5u6tixo6ZPn+447u/vrxUrVmjgwIEKDQ1VkSJFNGbMmGxdo0UyeZ2WKlWqaMOGDSpUqJD+97//qUmTJrp48aLuu+8+/fPPP8qTJ4/++OMPhYSEZOq8rNOSu7BOS+7COi25C+u05C659bpZp8V6DnVtY3YIDhW+/tXsECzB1H8F9+/fr5SUFEnXZ0YoVqyYjh8/ri1btuj48eOqUaOGXn31VTNDBAAAQC7j5m6zzIbrLPPVXWRkpMaNGyd/f39Jkq+vr8aPH68NGzaYHBkAAAAAM5lej7TZrmeQCQkJCg527fZRvHhxnT171oywAAAAkEtZaZ0WXGd60tKiRQvlyZNHsbGxOnDggKpVq+Y4dvz4cQbiAwAAALmcqUnL2LFjXX729fV1+fmXX35R48a5c7AxAAAAgOsslbT82+TJk+9SJAAAAMB19+I6LTkddwQAAACApZG0AAAAALA00wfiAwAAAFbC7GHWQ6UFAAAAgKWRtAAAAACwNLqHAQAAAE7oHmY9VFoAAAAAWBqVFgAAAMAJ67RYD3cEAAAAgKWRtAAAAACwNLqHAQAAAE4YiG89VFoAAAAAWBpJCwAAAABLo3sYAAAA4ITZw6yHOwIAAADA0qi0AAAAAM5sDMS3GiotAAAAACyNpAUAAACApdE9DAAAAHDCOi3WQ6UFAAAAgKWRtAAAAACwNLqHAQAAAE5Yp8V6uCMAAAAALI1KCwAAAOCEgfjWQ6UFAAAAgKWRtAAAAACwNLqHAQAAAE4YiG893BEAAAAAlkbSAgAAAMDS6B4GAAAAOGH2MOuh0gIAAADA0khaAAAAAFga3cMAAAAAJ3QPsx4qLQAAAAAsjUoLAAAA4Ix1WiyHOwIAAADA0khaAAAAAFga3cMAAAAAJzYbA/GthkoLAAAAAEsjaQEAAABgaXQPAwAAAJzYmD3McrgjAAAAACyNSgsAAADgxObGQHyrodICAAAAwNJIWgAAAABYGt3DAAAAAGcMxLcc7ggAAAAASyNpAQAAAGBpdA8DAAAAnDB7mPVQaQEAAABgaSQtAAAAACwtR3YPK/tES7NDMIURXMrsEEwRXaKO2SGY4oJR2OwQTJGa6m52CKZIsufIP9e3lWzPnfc7MSV33u+E5Nx6v+mKZDU2G9/rWw13BAAAAICl5c6vcgAAAICbYSC+5VBpAQAAAGBpJC0AAAAALI3uYQAAAIATmxvf61sNdwQAAACApZG0AAAAALA0uocBAAAATmzMHmY5VFoAAAAAWBqVFgAAAMCZje/1rYY7AgAAAMDSSFoAAAAAWBrdwwAAAAAnDMS3HiotAAAAACyNpAUAAACApdE9DAAAAHDmxvf6VsMdAQAAAGBpVFoAAAAAJzYbA/GthkoLAAAAAEsjaQEAAABgaXQPAwAAAJwxEN9yuCMAAAAALI2kBQAAAMhh3n77bdlsNg0ePNixLyEhQQMHDlThwoXl6+urjh07Kjo62uVxJ06cUNu2bZUvXz4FBgbq5ZdfVkpKikubtWvXqk6dOvL09FT58uU1Z86cbL8ekhYAAADAic3NZpntTmzdulUff/yxatSo4bJ/yJAh+uWXX7RgwQKtW7dOp0+f1mOPPeY4npqaqrZt2yopKUmbNm3S3LlzNWfOHI0ZM8bR5ujRo2rbtq2aN2+uXbt2afDgwXrmmWe0fPnyO/tlZxBJCwAAAJBDXL16VV27dtWnn36qggULOvZfvnxZn3/+ud599109+OCDCg0N1ezZs7Vp0yb98ccfkqQVK1Zo7969+r//+z/VqlVLrVu31uuvv64PP/xQSUlJkqRZs2YpJCREU6dOVeXKlTVo0CA9/vjjeu+997L1ukhaAAAAAItKTExUbGysy5aYmHjT9gMHDlTbtm0VHh7usn/79u1KTk522V+pUiWVKlVKkZGRkqTIyEhVr15dRYsWdbSJiIhQbGys9uzZ42jz73NHREQ4zpFdSFoAAAAAZzY3y2wTJ06Uv7+/yzZx4sR0w/7222+1Y8eOdI9HRUXJw8NDBQoUcNlftGhRRUVFOdo4Jyw3jt84dqs2sbGxio+Pv6Nfd0Yw5TEAAABgUaNGjdLQoUNd9nl6eqZp97///U8vvviiVq5cKS8vr7sV3l1D0gIAAAA4u8MB8NnB09Mz3STl37Zv366YmBjVqVPHsS81NVXr16/XjBkztHz5ciUlJenSpUsu1Zbo6GgFBQVJkoKCgrRlyxaX896YXcy5zb9nHIuOjpafn5+8vb3v6Bozgu5hAAAAwD2uRYsW+vvvv7Vr1y7HVrduXXXt2tXx/3nz5tWqVascjzlw4IBOnDihsLAwSVJYWJj+/vtvxcTEONqsXLlSfn5+qlKliqON8zlutLlxjuxCpQUAAAC4x+XPn1/VqlVz2efj46PChQs79vfp00dDhw5VoUKF5Ofnp+eff15hYWFq0KCBJKlly5aqUqWKunXrpkmTJikqKkqjR4/WwIEDHdWe5557TjNmzNDw4cPVu3dvrV69Wt99952WLFmSrddH0gIAAAA4sdlyZmek9957T25uburYsaMSExMVERGhmTNnOo67u7tr8eLF6t+/v8LCwuTj46MePXpowoQJjjYhISFasmSJhgwZomnTpqlEiRL67LPPFBERka2x2wzDMLL1GUyQ8M07ZodgCiO4lNkhmCKmRJ3bN8qBLhiFzQ7BFKl2d7NDMEWSPXd+x5ScS+93YkruvN8Jybn1fltn/MTd1KmBdRODuI9fNTsEB59n3zQ7BEuw7qsFAAAAAET3MAAAAMCVhWYPw3VUWgAAAABYGpUWAAAAwInNje/1rYY7AgAAAMDSSFoAAAAAWBrdwwAAAABnNgbiWw2VFgAAAACWRtICAAAAwNLoHgYAAAA4Y/Ywy+GOAAAAALA0khYAAAAAlkb3MAAAAMAZs4dZDpUWAAAAAJZGpQUAAABwYmMgvuVwRwAAAABYGkkLAAAAAEujexgAAADgzMb3+lbDHQEAAABgaSQtAAAAACyN7mEAAACAMzfWabEaKi0AAAAALI1KCwAAAODExkB8y+GOAAAAALA0khYAAAAAlmap7mGGYWjt2rU6fPiwgoODFRERobx585odFgAAAHITBuJbjqlJS5s2bfTNN9/I399fFy5cUJs2bbRlyxYVKVJE58+f13333af169crICDAzDABAAAAmMjU7mHLli1TYmKiJGn06NG6cuWK/vnnH8XExOj48ePy8fHRmDFjzAwRAAAAgMks0z1s9erVmjRpkkJCQiRJJUqU0DvvvKO+ffuaHBkAAAByFWYPsxzT74jNdr3P4MWLF1WuXDmXY+XLl9fp06fNCAsAAACARZheaenZs6c8PT2VnJyso0ePqmrVqo5jUVFRKlCggHnBAQAAIPexMRDfakxNWnr06OH4//bt2+vatWsuxxcuXKhatWrd5agAAAAAWImpScvs2bNveXzs2LFyd3e/S9EAAAAAsCLTu4fdio+Pj9khAAAAILdxM33YN/7F0knLTz/9pMuXL6t79+43bZOYmOiYNvkGIzlFnnktfWkAAAAAMsjSaeSIESPUq1evW7aZOHGi/P39XbbJP625SxECAAAAyG6WLkfs37//tm1GjRqloUOHuuwzFn2QXSEBAAAgp2OdFsuxdNKSEZ6envL09HTZl0DXMAAAACDHMDWNXLhwYZppjgEAAADAmalJS6dOnRQcHKx+/fpp8+bNZoYCAAAAXOdms84GSRYYiD9s2DBt27ZNYWFhqlatmt5//32dP3/e7LAAAAAAWITpScuzzz6rHTt2aOvWrWrSpInGjx+v4sWL64knntDKlSvNDg8AAAC5jc3NOhskWSBpuSE0NFQzZ87UmTNn9Omnn+rs2bNq1aqVQkJCzA4NAAAAgIlMTVpstrT99Ly8vNStWzetWbNGBw4cUJcuXUyIDAAAAIBVmDo3sGEYtzxevnx5vfnmm3cpGgAAAEBSOl+sw1ymVlqOHj2qgIAAM0MAAAAAYHGmJi2lS5fW/v37NXv2bO3fv1+StH//fvXv31+9e/fW6tWrzQwPAAAAgAWY2j1s2bJlat++vXx9fXXt2jX9+OOP6t69u2rWrCm73a6WLVtqxYoVevDBB80MEwAAALmJm2XmqsL/z9Q7MmHCBL388ss6f/68Zs+erS5duqhv375auXKlVq1apZdffllvv/22mSECAAAAMJmpScuePXvUs2dPSdITTzyhK1eu6PHHH3cc79q1q/766y+TogMAAECuZLNZZ4MkC6zTcmPaYzc3N3l5ecnf399xLH/+/Lp8+bJZoQEAAACwAFOTljJlyujQoUOOnyMjI1WqVCnHzydOnFBwcLAZoQEAAACwCFMH4vfv31+pqamOn6tVq+ZyfOnSpQzCBwAAwN1lM70zEv7F1KTlueeeu+Xxt9566y5FAgAAAMCqSCMBAAAAWJqplRYAAADAclinxXK4IwAAAAAsjaQFAAAAgKXRPQwAAABwxqKOlkOlBQAAAIClUWkBAAAAnLFOi+VwRwAAAABYGkkLAAAAAEujexgAAADgjIH4lkOlBQAAAIClkbQAAAAAsDS6hwEAAADO3Phe32q4IwAAAAAsjUoLAAAA4MRgIL7lUGkBAAAAYGkkLQAAAAAsje5hAAAAgDMb3+tbDXcEAAAAgKWRtAAAAACwNLqHAQAAAM7oHmY53BEAAAAAlkbSAgAAAMDS6B4GAAAAOGFxSeuh0gIAAADA0qi0AAAAAM4YiG853BEAAADgHjdx4kTdf//9yp8/vwIDA9WhQwcdOHDApU1CQoIGDhyowoULy9fXVx07dlR0dLRLmxMnTqht27bKly+fAgMD9fLLLyslJcWlzdq1a1WnTh15enqqfPnymjNnTnZfHkkLAAAAcK9bt26dBg4cqD/++EMrV65UcnKyWrZsqbi4OEebIUOG6JdfftGCBQu0bt06nT59Wo899pjjeGpqqtq2baukpCRt2rRJc+fO1Zw5czRmzBhHm6NHj6pt27Zq3ry5du3apcGDB+uZZ57R8uXLs/X6bIZhGNn6DCZI+OYds0MwhRFcyuwQTBFToo7ZIZjiglHY7BBMkWp3NzsEUyTZc2dv3uRcer8TU3Ln/U5Izq33O3cO+u7UwLrfnV/7fYHZITi413tEiYmJLvs8PT3l6el5y8edPXtWgYGBWrdunZo0aaLLly8rICBA8+bN0+OPPy5J2r9/vypXrqzIyEg1aNBAS5cu1cMPP6zTp0+raNGikqRZs2ZpxIgROnv2rDw8PDRixAgtWbJEu3fvdjxX586ddenSJS1btiyLr/7/se6rBQAAAMjlJk6cKH9/f5dt4sSJt33c5cuXJUmFChWSJG3fvl3JyckKDw93tKlUqZJKlSqlyMhISVJkZKSqV6/uSFgkKSIiQrGxsdqzZ4+jjfM5brS5cY7skju/ygEAAADuAaNGjdLQoUNd9t2uymK32zV48GA1atRI1apVkyRFRUXJw8NDBQoUcGlbtGhRRUVFOdo4Jyw3jt84dqs2sbGxio+Pl7e3d+YuMINIWgAAAABnbtbpjJSRrmD/NnDgQO3evVsbNmzIpqjuPuvcEQAAAAD/yaBBg7R48WKtWbNGJUqUcOwPCgpSUlKSLl265NI+OjpaQUFBjjb/nk3sxs+3a+Pn55dtVRaJpAUAAABwYdhsltkyHLNhaNCgQfrxxx+1evVqhYSEuBwPDQ1V3rx5tWrVKse+AwcO6MSJEwoLC5MkhYWF6e+//1ZMTIyjzcqVK+Xn56cqVao42jif40abG+fILnQPAwAAAO5xAwcO1Lx58/TTTz8pf/78jjEo/v7+8vb2lr+/v/r06aOhQ4eqUKFC8vPz0/PPP6+wsDA1aNBAktSyZUtVqVJF3bp106RJkxQVFaXRo0dr4MCBji5qzz33nGbMmKHhw4erd+/eWr16tb777jstWbIkW6+PSgsAAABwj/voo490+fJlNWvWTMHBwY5t/vz5jjbvvfeeHn74YXXs2FFNmjRRUFCQfvjhB8dxd3d3LV68WO7u7goLC9PTTz+t7t27a8KECY42ISEhWrJkiVauXKmaNWtq6tSp+uyzzxQREZGt18c6LTkI67TkLqzTkruwTkvuwjotuQvrtFhPXOQis0Nw8AnrYHYIlmDdVwsAAAAAiKQFAAAAgMXlzvozAAAAcBOGje/1rYY7AgAAAMDSqLQAAAAAzjKxPgruDiotAAAAACyNpAUAAACApdE9DAAAAHDCQHzr4Y4AAAAAsDSSFgAAAACWRvcwAAAAwBmzh1kOlRYAAAAAlkbSAgAAAMDS6B4GAAAAOGP2MMvJkUnLhTqtzQ7BFBfcA80OwRQXEvObHYIpku3uZodgiqSU3HndiSm58x/QhORcet1JubM/fXyC2RGYIz7RMDsEwPJyZNICAAAA3CmDgfiWkzu/wgIAAABwzyBpAQAAAGBpdA8DAAAAnDEQ33K4IwAAAAAsjaQFAAAAgKXRPQwAAABwYojZw6yGSgsAAAAAS7ujSktycrKioqJ07do1BQQEqFChQlkdFwAAAGAKg4H4lpPhO3LlyhV99NFHatq0qfz8/FSmTBlVrlxZAQEBKl26tPr27autW7dmZ6wAAAAAcqEMJS3vvvuuypQpo9mzZys8PFyLFi3Srl27dPDgQUVGRmrs2LFKSUlRy5Yt1apVKx06dCi74wYAAACQS2Soe9jWrVu1fv16Va1aNd3j9erVU+/evTVr1izNnj1bv//+uypUqJClgQIAAAB3Bd3DLCdDScs333yToZN5enrqueee+08BAQAAAICzDKeRs2fP1vHjx7MzFgAAAABII8Ozhw0YMEBJSUkqXbq0mjdv7tiKFy+enfEBAAAAd5VhY50Wq8lw0nLp0iVt2rRJ69at05o1azRv3jwlJSWpfPnyjgSmWbNmKlq0aHbGCwAAACCXsRmGYdzJAxMSEhQZGak1a9Zo7dq12rp1q5KTk5WSkpLVMWba6QN/mR2CKS64B5odgikuJOY3OwRTJNvdzQ7BFEkpufO6E1Ny56DQhORcet1JufNb3vgEsyMwR3ziHX0Uu+cNbW/d1/nFP9eZHYJDwZpNzQ7BEu5ocUlJcnNzk5ubm2w2m2w2mwzDUKlSpbIyNgAAAOCuY3FJ68lw0pKUlKQ//vhDa9eu1erVq7V582aVLl1aTZo0Ud++ffV///d/KlmyZHbGCgAAACAXynDS4u/vr8DAQLVr104DBw7Ut99+q6CgoOyMDQAAALj7GIhvORlOWmrWrKmdO3dq/fr1jq5hzZo1U+HChbMzPgAAAAC5XIY77P3xxx86f/68Jk2aJG9vb02aNEnBwcGqVq2aBg0apAULFigmJiY7YwUAAACQC2VqIL6vr69atWqlVq1aSZKuXLmi33//XStXrlTfvn119epVS8weBgAAANwpBuJbzx3NHma327V161atXbtWa9as0caNGxUXF6fSpUtndXwAAAAAcrkMJy1btmzR2rVrtXbtWm3YsEFXr15ViRIl1KxZM02fPl3NmzdXmTJlsjFUAAAAALlRhpOWBg0aKCgoSM2bN9e7776r5s2bq1y5ctkZGwAAAHDXGWL2MKvJcNKyb98+VaxYMTtjAQAAAIA0Mpy0kLAAAAAgN2AgvvVkOGkpW7ZshtodOXLkjoMBAAAAgH/LcNJy7NgxlS5dWl26dFFgYGB2xgQAAAAADhlOWubPn68vvvhC7777rlq3bq3evXurTZs2cnOjfAYAAIAcxMZAfKvJcMbRqVMnLV26VIcPH1ZoaKiGDBmikiVLauTIkTp06FB2xggAAAAgF8t0maR48eJ69dVXdejQIc2bN0+bN29WpUqVdPHixeyIDwAAAEAul+HuYc4SEhL0/fff64svvtDmzZvVqVMn5cuXL6tjAwAAAO46I/Pf6yObZSpp2bx5sz7//HN99913Klu2rHr37q2FCxeqYMGC2RUfAAAAgFwuw0lL1apVFRMToy5dumjdunWqWbNmdsYFAAAAmMJgIL7lZDhp2bdvn3x8fPTll1/qq6++umm7CxcuZElgAAAAACBlImmZPXt2dsYBAAAAAOnKcNLSo0eP7IwDAAAAsATDxkB8q8nQHTEMI7vjAAAAAIB0ZShpqVq1qr799lslJSXdst2hQ4fUv39/vf3221kSHAAAAABkqHvYBx98oBEjRmjAgAF66KGHVLduXRUrVkxeXl66ePGi9u7dqw0bNmjPnj0aNGiQ+vfvn91xAwAAANnCELOHWU2GkpYWLVpo27Zt2rBhg+bPn6+vv/5ax48fV3x8vIoUKaLatWure/fu6tq1K2u2AAAAAMhSmVpc8oEHHtADDzyQXbEAAAAAQBqZSloAAACAnI7Zw6yHOwIAAADA0qi0AAAAAE4MGwPxrYZKCwAAAABLI2kBAAAAYGmZTlqaNm2qL7/8UvHx8dkRDwAAAGAqQzbLbLgu00lL7dq1NWzYMAUFBalv3776448/siMuAAAAAJB0B0nL+++/r9OnT2v27NmKiYlRkyZNVKVKFU2ZMkXR0dHZESMAAACAXOyOxrTkyZNHjz32mH766SedPHlSXbp00WuvvaaSJUuqQ4cOWr16dVbHCQAAANwVhs3NMhuu+0+/iS1btmjs2LGaOnWqAgMDNWrUKBUpUkQPP/ywhg0bllUxAgAAAMjFMr1OS0xMjL766ivNnj1bhw4dUrt27fTNN98oIiJCtv9/TuuePXuqVatWmjJlSpYHDAAAAGQnBsBbT6aTlhIlSqhcuXLq3bu3evbsqYCAgDRtatSoofvvvz9LAgQAAACQu2U6aVm1apUaN258yzZ+fn5as2ZNhs6XlJSkRYsWKTIyUlFRUZKkoKAgNWzYUO3bt5eHh0dmQwQAAACQg2R6TMvYsWN16dKlNPtjY2P14IMPZupchw8fVuXKldWjRw/t3LlTdrtddrtdO3fuVPfu3VW1alUdPnw4syECAAAAd8zswfcMxE8r05WWdevWKSkpKc3+hIQE/f7775k6V//+/VW9enXt3LlTfn5+LsdiY2PVvXt3DRw4UMuXL89smAAAAAByiAwnLX/99ZckyTAM7d2719GVS5JSU1O1bNkyFS9ePFNPvnHjRm3ZsiVNwiJd72L2+uuvq379+pk6JwAAAICcJcNJS61atWSz2WSz2dLtBubt7a0PPvggU09eoEABHTt2TNWqVUv3+LFjx1SgQIFMnRMAAAD4L5g9zHoynLQcPXpUhmGobNmy2rJli8usYR4eHgoMDJS7u3umnvyZZ55R9+7d9dprr6lFixYqWrSoJCk6OlqrVq3SG2+8oeeffz5T5wQAAACQs2Q4aSldurQkyW63Z9mTT5gwQT4+Ppo8ebJeeuklxzovhmEoKChII0aM0PDhw7Ps+QAAAADce2yGYRi3a/Tzzz+rdevWyps3r37++edbtn3kkUfuKJCjR4+6THkcEhJyR+eRpNMH/rrjx97LLrgHmh2CKS4k5jc7BFMk2zNX2cwpklJy53UnpuTOGWQSknPpdSflzq4p8QlmR2CO+MTbfhTLkYa2t+7r/Og/1pm9NqRcebNDsIQMVVo6dOigqKgoBQYGqkOHDjdtZ7PZlJqaekeBhISE/KdEBQAAAMjtPvzwQ02ePFlRUVGqWbOmPvjgA9WrV8/ssP6zDH2FZbfbFRgY6Pj/m213mrDczE8//aQvv/wyS88JAAAA3Iohm2W2zJg/f76GDh2qsWPHaseOHapZs6YiIiIUExOTTb+pu8fSdfcRI0aoV69eZocBAAAAWN67776rvn37qlevXqpSpYpmzZqlfPny6YsvvjA7tP8s00nLCy+8oOnTp6fZP2PGDA0ePDgrYnLYv3//bas3iYmJio2NddkS01n8EgAAALjXpPtZNzExTbukpCRt375d4eHhjn1ubm4KDw9XZGTk3Qw5W2Q6aVm4cKEaNWqUZn/Dhg31/fffZ0lQmTFx4kT5+/u7bDM+/vyuxwEAAICcwbDZLLOl91l34sSJaWI+d+6cUlNTHUuI3FC0aFGXReHvVRme8viG8+fPy9/fP81+Pz8/nTt37j8HdPToUR0+fFjBwcE3XXTS2ahRozR06FDXGI8f/M9xAAAAAGZL77Oup6enSdGYJ9OVlvLly2vZsmVp9i9dulRly5bN1LkGDBigq1evSpLi4+P1+OOPq3z58oqIiFDNmjX14IMPOo7fjKenp/z8/Fw2Tw+PTMUBAAAAWFG6n3XTSVqKFCkid3d3RUdHu+yPjo5WUFDQ3Qo322Q6aRk6dKiGDx+usWPHat26dVq3bp3GjBmjkSNHasiQIZk618cff6xr165Jkl5//XVt3rxZv/32m65evar169frxIkTevPNNzMbIgAAAHDHDMNmmS2jPDw8FBoaqlWrVjn22e12rVq1SmFhYdnxa7qrMt09rHfv3kpMTNSbb76p119/XZJUpkwZffTRR+revXumzuW8ruUvv/yiSZMmqXnz5pKkRo0a6d1339XLL7+cbr89AAAAAP/P0KFD1aNHD9WtW1f16tXT+++/r7i4uBwxG2+mkxZJ6t+/v/r376+zZ8/K29tbvr6+dxyAzXY9g4yKilKNGjVcjtWsWVP/+9//7vjcAAAAQGYZ1l4V5KaefPJJnT17VmPGjFFUVJRq1aqlZcuWpRmcfy+6o6TlhoCAgP8cwGuvvaZ8+fLJzc1Np0+fVtWqVR3Hzp8/Lx8fn//8HAAAAEBuMGjQIA0aNMjsMLLcHSUt33//vb777judOHFCSf9aE2XHjh0ZPk+TJk104MABSVKVKlV0/Phxl+O//vqrSxIDAAAAIPfJdNIyffp0vfrqq+rZs6d++ukn9erVS//884+2bt2qgQMHZupca9euveXxLl26qGfPnpkNEQAAALhjhjI+AB53R6Y77M2cOVOffPKJPvjgA3l4eGj48OFauXKlXnjhBV2+fDlLgytbtqxKlCiRpecEAAAAcG/JdNJy4sQJNWzYUJLk7e2tK1euSJK6deumb775JtMBxMfHa8OGDdq7d2+aYwkJCfryyy8zfU4AAAAAOUemk5agoCBduHBBklSqVCn98ccfkq6vZO88hXFGHDx4UJUrV1aTJk1UvXp1NW3aVGfOnHEcv3z5co6Yog0AAAD3DkM2y2y4LtNJy4MPPqiff/5ZktSrVy8NGTJEDz30kJ588kk9+uijmTrXiBEjVK1aNcXExOjAgQPKnz+/GjVqpBMnTmQ2LAAAAAA5lM3IZHnEbrfLbrcrT57rY/i//fZbbdq0SRUqVNCzzz4rDw+PDJ+raNGi+u2331S9enVJ1xebHDBggH799VetWbNGPj4+KlasmFJTUzMTok4f+CtT7XOKC+6BZodgiguJ+c0OwRTJdnezQzBFUkruvO7ElHtzzYD/KiE5l153Uu78djU+wewIzBGfmLmeKjnF0PbWfZ0f+Mc66wRWLFfS7BAsIdOzh7m5ucnN7f/9I9K5c2d17tz5jp48Pj7ekfxI1xea/OijjzRo0CA1bdpU8+bNu6PzAgAAAHeKblnWc0frtFy8eFGff/659u3bJ+n6Giu9evVSoUKFMnWeSpUqadu2bapcubLL/hkzZkiSHnnkkTsJDwAAAEAOkum6+/r16xUSEqLp06fr4sWLunjxoqZPn66QkBCtX78+U+d69NFHbzrj2IwZM/TUU09lenA/AAAA8F+YPfiegfhpZXpMS/Xq1RUWFqaPPvpI7u7X+5anpqZqwIAB2rRpk/7+++9sCTQzGNOSuzCmJXdhTEvuwpiW3IUxLbmLlce07PvnlNkhOFQuV9zsECwh0/8aHD58WC+99JIjYZEkd3d3DR06VIcPH87S4AAAAAAg00lLnTp1HGNZnO3bt081a9bMkqAAAAAAsxiGzTIbrsv0QPwXXnhBL774og4fPqwGDRpIkv744w99+OGHevvtt/XXX/+va1aNGjWyLlIAAAAAuVKmx7Q4T3ec7gltNhmGIZvNlun1VbIKY1pyF8a05C6MacldGNOSuzCmJXex8piWvYdPmx2CQ5XyxcwOwRIyXWk5evRodsQBAAAAWAKzdllPppOW0qVLZ0ccAAAAAJCuO1pcUpL27t2rEydOKCkpyWU/C0ICAADgXkalxXoynbQcOXJEjz76qP7++2/H+BXp+lgWSaaNYwEAAACQM2V6hOOLL76okJAQxcTEKF++fNqzZ4/Wr1+vunXrau3atdkQIgAAAIDcLNOVlsjISK1evVpFihSRm5ub3Nzc9MADD2jixIl64YUXtHPnzuyIEwAAALgr6B5mPZmutKSmpip//utTzBYpUkSnT1+fEq506dI6cOBA1kYHAAAAINfLdKWlWrVq+vPPPxUSEqL69etr0qRJ8vDw0CeffKKyZctmR4wAAAAAcrFMJy2jR49WXFycJGnChAl6+OGH1bhxYxUuXFjz58/P8gABAACAu8kw6B5mNZlOWiIiIhz/X758ee3fv18XLlxQwYIFHTOIAQAAAEBWyfCYltTUVP3111+Kj49Pc8zb21t///237HZ7lgYHAAAA3G122Syz4boMJy1fffWVevfuLQ8PjzTH8ubNq969e2vevHlZGhwAAAAAZDhp+fzzzzVs2DC5u7unOZYnTx4NHz5cn3zySZYGBwAAAAAZHtNy4MABNWjQ4KbH77//fu3bty9LggIAAADMwjot1pPhSktcXJxiY2NvevzKlSu6du1algQFAAAAADdkOGmpUKGCNm3adNPjGzZsUIUKFbIkKAAAAAC4IcNJS5cuXTR69Gj99ddfaY79+eefGjNmjLp06ZKlwQEAAAB3m2HYLLPhugyPaRkyZIiWLl2q0NBQhYeHq1KlSpKk/fv367ffflOjRo00ZMiQbAsUAAAAQO6U4aQlb968WrFihd577z3NmzdP69evl2EYuu+++/Tmm29q8ODByps3b3bGCgAAACAXshmGYZgdRFY7fSBtF7bc4IJ7oNkhmOJCYn6zQzBFsj3t9OO5QVJK7rzuxJQM9+bNURKSc+l1J+XOLiHxCWZHYI74xBz3USxDhra37ut8+8ELZofgEHpfIbNDsITc+a8BAAAAgHtGhruHAQAAALkBA+Cth0oLAAAAAEsjaQEAAABgaRlOWoYNG6b9+/dnZywAAACA6QzZLLPhugwnLT/99JOqVq2qhg0b6osvvlBcXFx2xgUAAAAAkjKRtBw6dEhr1qzRfffdpxdffFFBQUHq3bu3Nm3alJ3xAQAAAMjlMjWmpUmTJpozZ46ioqI0bdo0HTp0SA888IAqV66sKVOmKDo6OrviBAAAAO4Kw7BZZsN1dzQQ38fHR71799bvv/+ugwcP6rHHHtPEiRNVqlSprI4PAAAAQC73n9ZpiYuL0++//65169bp4sWLqlixYlbFBQAAAJjCbnYASOOOKi0bNmxQ7969FRwcrBdeeEH33Xeffv/9d+3bty+r4wMAAACQy2W40nLmzBnNnTtXc+bM0cGDB9WgQQO9++676ty5s3x9fbMzRgAAAAC5WIaTlpIlS6pw4cLq1q2b+vTpo8qVK2dnXAAAAIApGABvPRlOWr777js98sgjypPnPw2DAQAAAIBMyfCYlvbt22vq1Klq1KiR7r//fo0cOVLx8fHZGRsAAAAAZDxpeeutt/TKK6/I19dXxYsX17Rp0zRw4MDsjA0AAAC46wzZLLPhugwnLV9++aVmzpyp5cuXa9GiRfrll1/09ddfy25nUjgAAAAA2SfDScuJEyfUpk0bx8/h4eGy2Ww6ffp0tgQGAAAAAFImBuKnpKTIy8vLZV/evHmVnJyc5UEBAAAAZmH2MOvJcNJiGIZ69uwpT09Px76EhAQ999xz8vHxcez74YcfsjZCAAAAALlahpOWHj16pNn39NNPZ2kwAAAAgNkYAG89GU5aZs+enZ1xAAAAAEC6MjwQHwAAAADMwPL2AAAAgBO7YXYE+DcqLQAAAAAsjaQFAAAAgKXRPQwAAABwwuxh1pMjk5Y/r1U2OwRTXElwNzsEUyQk5c6CYXyi2RGYIyExd3Y0vhZvNzsEU8TH584FjK9dSzE7BFPExyWZHYIpcut1q32g2RHgHpIjkxYAAADgThkGlRaryZ1fUQMAAAC4Z5C0AAAAALA0uocBAAAATozcOXzS0qi0AAAAALA0khYAAAAAlkb3MAAAAMCJnXVaLIdKCwAAAABLo9ICAAAAOGGdFuuh0gIAAADA0khaAAAAAFga3cMAAAAAJ6zTYj1UWgAAAABYGkkLAAAAAEujexgAAADgxGCdFsuh0gIAAADA0khaAAAAAFgaSQsAAADgxG5YZ8sOx44dU58+fRQSEiJvb2+VK1dOY8eOVVJSkku7v/76S40bN5aXl5dKliypSZMmpTnXggULVKlSJXl5eal69er69ddfXY4bhqExY8YoODhY3t7eCg8P16FDhzIdM0kLAAAAkIvs379fdrtdH3/8sfbs2aP33ntPs2bN0iuvvOJoExsbq5YtW6p06dLavn27Jk+erHHjxumTTz5xtNm0aZOeeuop9enTRzt37lSHDh3UoUMH7d6929Fm0qRJmj59umbNmqXNmzfLx8dHERERSkhIyFTMNsPIeTNRL92ZbHYIpriS4G52CKZISMqduXd8otkRmCMhMcf9ycqQa/F2s0MwRXx8qtkhmOLatRSzQzBFfFzS7RvlQLn1ur8YG2h2CDdlpc+SrWvnvSvPM3nyZH300Uc6cuSIJOmjjz7Sq6++qqioKHl4eEiSRo4cqUWLFmn//v2SpCeffFJxcXFavHix4zwNGjRQrVq1NGvWLBmGoWLFiumll17SsGHDJEmXL19W0aJFNWfOHHXu3DnD8eXOT3sAAADAPSAxMVGxsbEuW2Ji1n9zefnyZRUqVMjxc2RkpJo0aeJIWCQpIiJCBw4c0MWLFx1twsPDXc4TERGhyMhISdLRo0cVFRXl0sbf31/169d3tMkokhYAAADAoiZOnCh/f3+XbeLEiVn6HIcPH9YHH3ygZ5991rEvKipKRYsWdWl34+eoqKhbtnE+7vy49NpkFEkLAAAA4MQwrLONGjVKly9fdtlGjRqVbtwjR46UzWa75Xaja9cNp06dUqtWrdSpUyf17dv3bvx67wiLSwIAAAAW5enpKU9Pzwy1femll9SzZ89btilbtqzj/0+fPq3mzZurYcOGLgPsJSkoKEjR0dEu+278HBQUdMs2zsdv7AsODnZpU6tWrQxd0w0kLQAAAEAOEBAQoICAgAy1PXXqlJo3b67Q0FDNnj1bbm6uHbDCwsL06quvKjk5WXnzXp8MYOXKlapYsaIKFizoaLNq1SoNHjzY8biVK1cqLCxMkhQSEqKgoCCtWrXKkaTExsZq8+bN6t+/f6auje5hAAAAgBO7bJbZssOpU6fUrFkzlSpVSlOmTNHZs2cVFRXlMs6kS5cu8vDwUJ8+fbRnzx7Nnz9f06ZN09ChQx1tXnzxRS1btkxTp07V/v37NW7cOG3btk2DBg2SJNlsNg0ePFhvvPGGfv75Z/3999/q3r27ihUrpg4dOmQqZiotAAAAQC6ycuVKHT58WIcPH1aJEiVcjt1YDcXf318rVqzQwIEDFRoaqiJFimjMmDHq16+fo23Dhg01b948jR49Wq+88ooqVKigRYsWqVq1ao42w4cPV1xcnPr166dLly7pgQce0LJly+Tl5ZWpmFmnJQdhnZbchXVachfWacldWKcld8mt123ldVp+2W6d92C7UGoMEt3DAAAAAFgcSQsAAAAAS6PeBAAAADgxjOwZAI87R6UFAAAAgKWRtAAAAACwNLqHAQAAAE7suXOiSkuj0gIAAADA0khaAAAAAFga3cMAAAAAJzlv6fV7H5UWAAAAAJZGpQUAAABwYoh1WqyGSgsAAAAASyNpAQAAAGBpdA8DAAAAnLBOi/VQaQEAAABgaSQtAAAAACyN7mEAAACAE9ZpsR4qLQAAAAAsjUoLAAAA4IRKi/VQaQEAAABgaSQtAAAAACyN7mEAAACAE7thMzsE/AuVFgAAAACWRtICAAAAwNLoHgYAAAA4YfYw66HSAgAAAMDSqLQAAAAATqi0WA+VFgAAAACWRtICAAAAwNLoHgYAAAA4sdM9zHIslbTExcXpu+++0+HDhxUcHKynnnpKhQsXNjssAAAAACYyNWmpUqWKNmzYoEKFCul///ufmjRpoosXL+q+++7TP//8o9dff11//PGHQkJCzAwTAAAAgIlMHdOyf/9+paSkSJJGjRqlYsWK6fjx49qyZYuOHz+uGjVq6NVXXzUzRAAAAOQyhmGzzIbrLDMQPzIyUuPGjZO/v78kydfXV+PHj9eGDRtMjgwAAACAmUxPWmy26xlkQkKCgoODXY4VL15cZ8+eNSMsAAAAABZh+kD8Fi1aKE+ePIqNjdWBAwdUrVo1x7Hjx48zEB8AAAB3FYtLWo+pScvYsWNdfvb19XX5+ZdfflHjxo3vZkgAAAAALMZSScu/TZ48+S5FAgAAAFzHOi3WY/qYFgAAAAC4FUsnLTNnztSECRPMDgMAAACAiUwfiH8rCxcu1NGjRzVmzJibtklMTFRiYqLLvuQkN+X18Mzu8AAAAJADMRDfeixdaVm1apWOHDlyyzYTJ06Uv7+/yzb/i3fuUoQAAAAAspulKy0ZMWrUKA0dOtRl39p9ls7FAAAAAGSCJT7dnzx5UlevXk2zPzk5WevXr7/lYz09PeXn5+ey0TUMAAAAd8owrLPhOlOTljNnzqhevXoqXbq0ChQooO7du7skLxcuXFDz5s1NjBAAAACA2UxNWkaOHCk3Nzdt3rxZy5Yt0969e9W8eXNdvHjR0cYgxQQAAMBdZDess+E6U5OW3377TdOnT1fdunUVHh6ujRs3Kjg4WA8++KAuXLggSbLZbGaGCAAAAMBkpiYtly9fVsGCBR0/e3p66ocfflCZMmXUvHlzxcTEmBgdAAAAACswNWkpW7as/vrrL5d9efLk0YIFC1S2bFk9/PDDJkUGAACA3MrswfcMxE/L1KSldevW+uSTT9Lsv5G41KpVizEtAAAAQC5n6jotb775pq5du5busTx58mjhwoU6derUXY4KAAAAgJWYWmnJkyeP/Pz8bnr8zJkzGj9+/F2MCAAAALmd3W6dDddZYnHJm7lw4YLmzp1rdhgAAAAATGRq97Cff/75lsePHDlylyIBAAAAYFWmJi0dOnSQzWa75WB71mkBAADA3cQ8UNZjavew4OBg/fDDD7Lb7eluO3bsMDM8AAAAABZgatISGhqq7du33/T47aowAAAAQFYze20W1mlJy9TuYS+//LLi4uJuerx8+fJas2bNXYwIAAAAgNWYmrQ0btz4lsd9fHzUtGnTuxQNAAAAACsyNWkBAAAArMZOtyzLsfQ6LQAAAABA0gIAAADA0ugeBgAAADix1uy1rFkoUWkBAAAAYHFUWgAAAAAnliq0QBKVFgAAAAAWR9ICAAAAwNLoHgYAAAA4sdvNjgD/RqUFAAAAgKWRtAAAAACwNLqHAQAAAE6YPcx6qLQAAAAAsDSSFgAAAACWRvcwAAAAwImd7mGWQ6UFAAAAgKVRaQEAAACcMBDfeqi0AAAAALA0khYAAAAAlkb3MAAAAMCJYamR+DazA7AEKi0AAAAALI2kBQAAAMilEhMTVatWLdlsNu3atcvl2F9//aXGjRvLy8tLJUuW1KRJk9I8fsGCBapUqZK8vLxUvXp1/frrry7HDcPQmDFjFBwcLG9vb4WHh+vQoUOZjpOkBQAAAHBiN6yzZbfhw4erWLFiafbHxsaqZcuWKl26tLZv367Jkydr3Lhx+uSTTxxtNm3apKeeekp9+vTRzp071aFDB3Xo0EG7d+92tJk0aZKmT5+uWbNmafPmzfLx8VFERIQSEhIyFSdJCwAAAGBRiYmJio2NddkSExOz5NxLly7VihUrNGXKlDTHvv76ayUlJemLL75Q1apV1blzZ73wwgt69913HW2mTZumVq1a6eWXX1blypX1+uuvq06dOpoxY4ak61WW999/X6NHj1b79u1Vo0YNffnllzp9+rQWLVqUqVhJWgAAAAAnhmGdbeLEifL393fZJk6c+J+vMTo6Wn379tVXX32lfPnypTkeGRmpJk2ayMPDw7EvIiJCBw4c0MWLFx1twsPDXR4XERGhyMhISdLRo0cVFRXl0sbf31/169d3tMkoZg8DAAAALGrUqFEaOnSoyz5PT8//dE7DMNSzZ08999xzqlu3ro4dO5amTVRUlEJCQlz2FS1a1HGsYMGCioqKcuxzbhMVFeVo5/y49NpkFJUWAAAAwKI8PT3l5+fnst0saRk5cqRsNtstt/379+uDDz7QlStXNGrUqLt8NXeOSgsAAADgxG6pdVoy7qWXXlLPnj1v2aZs2bJavXq1IiMj0yQ/devWVdeuXTV37lwFBQUpOjra5fiNn4OCghz/Ta+N8/Eb+4KDg13a1KpVK1PXRtICAAAA5AABAQEKCAi4bbvp06frjTfecPx8+vRpRUREaP78+apfv74kKSwsTK+++qqSk5OVN29eSdLKlStVsWJFFSxY0NFm1apVGjx4sONcK1euVFhYmCQpJCREQUFBWrVqlSNJiY2N1ebNm9W/f/9MXRtJCwAAAJCLlCpVyuVnX19fSVK5cuVUokQJSVKXLl00fvx49enTRyNGjNDu3bs1bdo0vffee47Hvfjii2ratKmmTp2qtm3b6ttvv9W2bdsc0yLbbDYNHjxYb7zxhipUqKCQkBC99tprKlasmDp06JCpmElaAAAAACfGvdk7LEv5+/trxYoVGjhwoEJDQ1WkSBGNGTNG/fr1c7Rp2LCh5s2bp9GjR+uVV15RhQoVtGjRIlWrVs3RZvjw4YqLi1O/fv106dIlPfDAA1q2bJm8vLwyFY/NMHLebVm6M9nsEExxJcHd7BBMkZCUO+eTiM+aKdrvOQmJOe5PVoZci7ebHYIp4uNTzQ7BFNeupZgdgini45LMDsEUufW6vxgbaHYIN/XWfOv87Xnlydz5+e7fqLQAAAAATnLeV/r3vtz5FTUAAACAewZJCwAAAABLo3sYAAAA4MRO/zDLodICAAAAwNJIWgAAAABYGt3DAAAAACdG7pxl3tKotAAAAACwNJIWAAAAAJZG9zAAAADAicHsYZZDpQUAAACApVFpAQAAAJzYGYhvOVRaAAAAAFgaSQsAAAAAS6N7GAAAAOCEgfjWQ6UFAAAAgKWRtAAAAACwNLqHAQAAAE7s9A6zHCotAAAAACwtR1Za9hx1NzsEU1yLz52Til+7lmR2CKaIv5ZsdgimuBaXS+93XKLZIZgi4WqC2SGYIj7umtkhmCLhau687sS4eLNDMEmg2QHclEGpxXKotAAAAACwNJIWAAAAAJaWI7uHAQAAAHeKZVqsh0oLAAAAAEsjaQEAAABgaXQPAwAAAJzYmT3Mcqi0AAAAALA0khYAAAAAlkb3MAAAAMCJwfRhlkOlBQAAAIClUWkBAAAAnBh2syPAv1FpAQAAAGBpJC0AAAAALI3uYQAAAIATOwPxLYdKCwAAAABLI2kBAAAAYGl0DwMAAACcsE6L9VBpAQAAAGBpVFoAAAAAJ3Y7lRarodICAAAAwNJIWgAAAABYGt3DAAAAACeMw7ceKi0AAAAALI2kBQAAAICl0T0MAAAAcGIwe5jlUGkBAAAAYGlUWgAAAAAndkbiWw6VFgAAAACWRtICAAAAwNLoHgYAAAA4YSC+9VBpAQAAAGBpJC0AAAAALI3uYQAAAIATuodZD5UWAAAAAJZG0gIAAADA0ugeBgAAADihd5j1UGkBAAAAYGlUWgAAAAAnDMS3HiotAAAAACyNpAUAAACApdE9DAAAAHBiGHQPsxoqLQAAAAAsjaQFAAAAgKXRPQwAAABwYmf2MMuh0gIAAADA0qi0AAAAAE4YiG89VFoAAAAAWBpJCwAAAABLo3sYAAAA4MRgIL7lUGkBAAAAYGkkLQAAAAAsje5hAAAAgBO6h1kPlRYAAAAAlkbSAgAAAMDS6B4GAAAAOLGzuKTlUGkBAAAAYGlUWgAAAAAnDMS3HiotAAAAACyNpAUAAACApZG0AAAAAE4Mw7DMlp2WLFmi+vXry9vbWwULFlSHDh1cjp84cUJt27ZVvnz5FBgYqJdfflkpKSkubdauXas6derI09NT5cuX15w5c9I8z4cffqgyZcrIy8tL9evX15YtWzIdK0kLAAAAkMssXLhQ3bp1U69evfTnn39q48aN6tKli+N4amqq2rZtq6SkJG3atElz587VnDlzNGbMGEebo0ePqm3btmrevLl27dqlwYMH65lnntHy5csdbebPn6+hQ4dq7Nix2rFjh2rWrKmIiAjFxMRkKl6bkd0p3C3s3btXM2bMUGRkpKKioiRJQUFBCgsL06BBg1SlSpU7Ou+UH+xZGeY941p8Lr3uaym3b5QDxV9LNjsEU1yLSzI7BFPExyWaHYIpEq4mmB2CKeLjrpkdgikSrubO606Mizc7BFNs+KWp2SHcVPfXzpgdgsOXrwdn+TlTUlJUpkwZjR8/Xn369Em3zdKlS/Xwww/r9OnTKlq0qCRp1qxZGjFihM6ePSsPDw+NGDFCS5Ys0e7dux2P69y5sy5duqRly5ZJkurXr6/7779fM2bMkCTZ7XaVLFlSzz//vEaOHJnhmE2rtCxdulS1a9fWzp071b59e40ZM0ZjxoxR+/bt9eeff6pOnTouWRoAAABwN9jthmW2xMRExcbGumyJif/ti6wdO3bo1KlTcnNzU+3atRUcHKzWrVu7JB+RkZGqXr26I2GRpIiICMXGxmrPnj2ONuHh4S7njoiIUGRkpCQpKSlJ27dvd2nj5uam8PBwR5uMMi1pGTlypEaMGKHIyEiNGzdO/fv3V//+/TVu3Dht3LhRI0eO1Msvv2xWeAAAAIDpJk6cKH9/f5dt4sSJ/+mcR44ckSSNGzdOo0eP1uLFi1WwYEE1a9ZMFy5ckCRFRUW5JCySHD/f6CF1szaxsbGKj4/XuXPnlJqamm6bG+fIKNOSloMHD6pr1643Pf7UU0/p0KFDdzEiAAAA4Po6LVbZRo0apcuXL7tso0aNSjfukSNHymaz3XLbv3+/7PbrQwpeffVVdezYUaGhoZo9e7ZsNpsWLFhwN3/VGWba4pJlypTRkiVLVLFixXSPL1myRKVLl77LUQEAAADW4enpKU9Pzwy1femll9SzZ89btilbtqzOnLk+Zsd5/Linp6fKli2rEydOSLo+zvzfs3xFR0c7jt347419zm38/Pzk7e0td3d3ubu7p9vmxjkyyrSkZcKECerSpYvWrl2r8PBwR9koOjpaq1at0rJlyzRv3jyzwgMAAADuKQEBAQoICLhtu9DQUHl6eurAgQN64IEHJEnJyck6duyYo2gQFhamN998UzExMQoMDJQkrVy5Un5+fo5kJywsTL/++qvLuVeuXKmwsDBJkoeHh0JDQ7Vq1SrHdMp2u12rVq3SoEGDMnVtpiUtnTp1UvHixTV9+nRNnTo1zexha9eudVzwrSQmJqYZjJSSnFd58mYsIwUAAACcmTi57l3h5+en5557TmPHjlXJkiVVunRpTZ48WdL1z+iS1LJlS1WpUkXdunXTpEmTFBUVpdGjR2vgwIGOys9zzz2nGTNmaPjw4erdu7dWr16t7777TkuWLHE819ChQ9WjRw/VrVtX9erV0/vvv6+4uDj16tUrUzGblrRIUsOGDdWwYcP/dI6JEydq/PjxLvseemKMWj459j+dFwAAAMipJk+erDx58qhbt26Kj49X/fr1tXr1ahUsWFCS5O7ursWLF6t///4KCwuTj4+PevTooQkTJjjOERISoiVLlmjIkCGaNm2aSpQooc8++0wRERGONk8++aTOnj2rMWPGKCoqSrVq1dKyZcvSDM6/HVPXackK6VVaZi7NnZUW1mnJXVinJXdhnZbchXVachfWabGeLiNPmh2Cw7y3S5gdgiWYWmm5lVdeeUVRUVH64osvbtkuvcFJefLmzg/vAAAA+O8MO58lrcayScvJkyd18qR1slwAAAAA5rBs0vLll1+aHQIAAAAACzA1aTl37py++OILRUZGuswe1rBhQ/Xs2TNDU7YBAAAAWcluv6eHfOdIbmY98datW3Xfffdp+vTp8vf3V5MmTdSkSRP5+/tr+vTpqlSpkrZt22ZWeAAAAAAswrRKy/PPP69OnTpp1qxZstlsLscMw9Bzzz2n559/XpGRkSZFCAAAgNzoHp9cN0cyLWn5888/NWfOnDQJiyTZbDYNGTJEtWvXNiEyAAAAAFZiWvewoKAgbdmy5abHt2zZkulFZwAAAADkPKZVWoYNG6Z+/fpp+/btatGihSNBiY6O1qpVq/Tpp59qypQpZoUHAACAXMpgIL7lmJa0DBw4UEWKFNF7772nmTNnKjU1VZLk7u6u0NBQzZkzR0888YRZ4QEAAACwCFOnPH7yySf15JNPKjk5WefOnZMkFSlSRHnz5jUzLAAAAAAWYonFJfPmzavg4GCzwwAAAADoHmZBpg3EBwAAAICMsESlBQAAALAKu2E3OwT8C5UWAAAAAJZG0gIAAADA0ugeBgAAADhhIL71UGkBAAAAYGkkLQAAAAAsje5hAAAAgBO6h1kPlRYAAAAAlkalBQAAAHBiGFRarIZKCwAAAABLI2kBAAAAYGl0DwMAAACc2O12s0PAv1BpAQAAAGBpJC0AAAAALI3uYQAAAIAT1mmxHiotAAAAACyNpAUAAACApdE9DAAAAHBiGMweZjVUWgAAAABYGpUWAAAAwAkD8a2HSgsAAAAASyNpAQAAAGBpdA8DAAAAnNA9zHqotAAAAACwNJIWAAAAAJZG9zAAAADAiZ11WiyHSgsAAAAAS6PSAgAAADhhIL71UGkBAAAAYGkkLQAAAAAsje5hAAAAgBPDzkB8q6HSAgAAAMDSSFoAAAAAWBrdwwAAAAAnzB5mPVRaAAAAAFgaSQsAAAAAS6N7GAAAAODEMJg9zGqotAAAAACwNCotAAAAgBM7A/Eth0oLAAAAAEsjaQEAAABgaXQPAwAAAJwYdgbiWw2VFgAAAACWRtICAAAAwNLoHgYAAAA4MZg9zHKotAAAAACwNCotAAAAgBPDYCC+1VBpAQAAAGBpJC0AAAAALI3uYQAAAIATBuJbD5UWAAAAAJZG0gIAAADA0ugeBgAAADgx7MweZjVUWgAAAABYm4Esk5CQYIwdO9ZISEgwO5S7iuvmunMDrpvrzg24bq4bsCqbYRhMj5BFYmNj5e/vr8uXL8vPz8/scO4arpvrzg24bq47N+C6uW7AqugeBgAAAMDSSFoAAAAAWBpJCwAAAABLI2nJQp6enho7dqw8PT3NDuWu4rq57tyA6+a6cwOum+sGrIqB+AAAAAAsjUoLAAAAAEsjaQEAAABgaSQtAAAAACyNpAUAAACApZG0AAAAALA0khYAAAAAlkbSAgAZ1KtXL50+fdrsMJDFzp07Z3YIMEFcXJzWr1+v+fPna8GCBdq+fbtYBQKwLtZp+Q/27t2rGTNmKDIyUlFRUZKkoKAghYWFadCgQapSpYrJEZojJSVFp0+fVqlSpcwOJcskJyfr1Vdf1Q8//KBChQrpueeeU+/evR3Ho6OjVaxYMaWmppoY5d1x6NAhnThxQqVLl1b58uXNDidb/PXXX+nur1u3rr777juVLVtWklSjRo27GRayibu7u5o1a6Y+ffqoY8eOLLSXw9ntdo0cOVIffvihEhISJMmRrJQqVUoffPCB2rVrZ2aIANJB0nKHli5dqg4dOqhOnTqKiIhQ0aJFJV3/8Lpy5Upt375dP/30kyIiIkyO9O77888/VadOnRz1AX7cuHGaNWuWhg0bpkuXLmnGjBl68skn9fHHH0u6ft+Dg4Nlt9tNjjRrTZw4UfXq1VOLFi108eJFderUSatXr5Yk2Ww2tWzZUt98840KFChgbqBZzM3NTTabLd1vXW/st9lsOeo1np5Lly5pwYIFjiS1U6dO8vf3NzusLOfm5qaIiAitXr1aPj4+6tq1q/r06aNatWqZHdpdceTIEW3YsEFnzpyRm5ubypYtq4ceekh+fn5mh5YtRo4cqZ9//lmTJk2Sl5eXXn/9dbVt21aPPPKI5s2bp0mTJunnn39Wy5YtzQ4122zZsiXdL1zr1atncmTALRi4IzVq1DBee+21mx4fO3asUb169bsYkXXs2rXLcHNzMzuMLFW+fHnjl19+cfx86NAho3z58kbPnj0Nu91uREVF5bhrNgzDKFGihLFjxw7DMAzjmWeeMWrXrm3s2LHDiI+PN3bt2mU0aNDA6NOnj8lRZr2aNWsabdu2Nfbt22ccO3bMOHbsmHH06FEjT548xsqVKx37cppHH33UWLBggWEYhrF7926jSJEiRkBAgFG/fn2jaNGiRlBQkLF3716To8x6NpvNiI6ONs6ePWtMmTLFqFKliuHm5mbUqVPHmDlzpnH58mWzQ8wWV69eNR5//HHDZrMZNpvNcHNzM4KCggx3d3fD19fXmDFjhtkhZovg4GBj/fr1jp9Pnjxp+Pr6GgkJCYZhGMaECROMsLAws8LLVtHR0cYDDzxg2Gw2o3Tp0ka9evWMevXqGaVLlzZsNpvxwAMPGNHR0WaHCaSLpOUOeXl5Gfv377/p8f379xteXl53MaK7p3bt2rfcKlWqlOM+wHt7extHjx512Xfy5EnjvvvuM7p27WqcOnUqx12zYRiGp6en48N5mTJljHXr1rkc37ZtmxEcHGxGaNkqMTHRePHFF40qVao4kjbDMIw8efIYe/bsMTGy7FWwYEFj3759hmEYRuvWrY0uXboYiYmJhmEYRlJSktGnTx+jZcuWZoaYLW4kLc42bdpk9O7d28ifP7+RL18+o1u3biZFl3369etnNGrUyPj777+NQ4cOGY8//rgxfPhwIy4uzvj888+NfPnyGV9//bXZYWa5/PnzG//884/j59TUVCNPnjzGmTNnDMMwjD179hj58uUzK7xs1bFjRyMsLCzdzy/79+83GjZsaDz++OMmRAbcXh6zKz33qjJlymjJkiWqWLFiuseXLFmi0qVL3+Wo7o69e/eqc+fOCgkJSff4mTNndPDgwbscVfYKCgrSP//8ozJlyjj2FS9eXGvWrFHz5s3Vs2dP02LLTqVLl9bu3btVunRp2Ww25cnj+ifD3d1dcXFxJkWXfTw8PPT+++9r6dKleuSRRzRgwACNGDHC7LCyXUJCgvLmzStJ2rVrl5YsWSIPDw9JUt68eTV8+PAc2X3EZrOl2RcWFqawsDBNnz5d3377rb744gsTIsteP/zwg5YtW6Zq1apJkj755BMVK1ZMY8eOVe/evRUfH6/JkyerS5cuJkeatapXr65vvvlGr776qiTpu+++k6+vr4KCgiRdH/OSU8c1LV++XOvXr0/3s0vFihU1ffp0NWvW7O4HBmQAScsdmjBhgrp06aK1a9cqPDzcZUzLqlWrtGzZMs2bN8/kKLNHtWrVVL9+ffXv3z/d47t27dKnn356l6PKXg8++KDmzZunFi1auOwvVqyYVq9enWP/yPft21cvv/yyKlasqEGDBmnYsGH66quvVK5cOR09elRDhgzJ0f2+W7durW3btqlXr15aunSp2eFkuxo1amj16tUqV66cgoKCdPz4cdWuXdtx/Pjx4/L29jYxwuxh3GJop4+Pj/r06aM+ffrcxYjujpSUFJdxK76+vkpJSVFcXJzy5cunli1batiwYSZGmD0mTJigtm3b6ueff5aXl5c2bdqkyZMnO44vW7bM5XWfk3h6eio2Nvamx69cuZJjEzbc+0ha7lCnTp1UvHhxTZ8+XVOnTk0zmG3t2rUKCwszOcrs0ahRIx04cOCmx/Pnz68mTZrcxYiy32uvvab9+/ene6x48eJat26dVq5ceZejyn7Dhg3TiRMnVKVKFZUrV07Hjh3Tfffdpzx58iglJUV16tTRN998Y3aY2apo0aL69ddfNX36dBUuXDjHDk6Wrr/Ou3fvrrx58+qFF17QkCFDdP78eVWuXFkHDhzQ2LFj1a1bN7PDzHKzZ8/OkRMM3M7999+vadOmacaMGZKkadOmKSAgQAEBAZKkq1evytfX18wQs0WLFi20efNmfffdd0pMTNTo0aP10EMPOY4PGzYsRyZrkvTkk0+qR48eeu+999SiRQvH37PY2FitWrVKQ4cO1VNPPWVylED6mD0MwG3t27dPixcv1pEjR2S32xUcHKxGjRopPDw83a41uHctXLhQgwcP1unTp10qEJ6ennruuec0ZcoUubu7mxghssqOHTv00EMPycPDQx4eHoqKitLcuXPVuXNnSdKHH36oLVu2aO7cuSZHiqySmJiowYMH64svvlBKSoqj+2dSUpLy5MmjPn366L333qPaAksiaQEy4eTJkypQoECabx+Tk5MVGRmZ4ypMcFW2bFktX75cFSpUMDuUbJWamqodO3a4JKmhoaHKnz+/2aHdFbllqmfp+hjExYsXKzExUQ8++GCuWV8sJiZGu3fvVmhoqPz9/RUdHa25c+fKbrerbdu2ql69utkhZqvY2Fht377dpZdIaGhojq4k495H0pJNXnnlFUVFReXIwZu3ExcXp+3bt+eoD/BnzpxR+/bttX37dtlsNnXp0kUzZ850JC85fXHJ1NRUl2/XN2/erMTERIWFhTkGbuck06dPT3f/0KFDNXz4cMeA3RdeeOFuhoVs8thjj6lLly56/PHHtWfPHjVr1kw2m01ly5bVsWPHZLPZtHr1alWuXNnsUJEF1q5dq4cffljXrl1T0aJFtWzZMj388MPy9vaWm5ubjh07luPXaQHuRSQt2aR79+46efKkYyG+3CQnLi7Zo0cPHThwQDNmzNClS5c0cuRI2Ww2rVixQgULFsyxi0ueOXNGnTp10h9//KFGjRpp0aJF6tatm3799VdJUoUKFbR27VoFBwebHGnWcnNzU/HixdPMlnb8+HEVK1ZMefPmlc1m05EjR0yK8O4wDENr167V4cOHFRwcrIiIiByZpBYqVEibNm1SpUqV1KZNGxUsWFCzZ8+Wh4eHkpOT1b9/f/3vf//T8uXLzQ41S02dOlWPP/54jp3p8mYaN26smjVr6u2339asWbP0/vvvq0OHDo6xPS+//LI2bdqkjRs3mhzp3bdt2zZdu3YtR33piBzEpKmWkYPlxMUlixUrZmzevNnxc0JCgtGuXTujVq1axvnz53Ps4pLdunUzGjZsaPz888/Gk08+aTRs2NBo3LixcfLkSeP48eNGo0aNjIEDB5odZpZ79tlnjVq1aqVZSDGnr9PSunVr49KlS4ZhGMb58+eN+vXrGzabzQgICDDc3NyMSpUqGTExMSZHmfW8vb2Nw4cPG4ZxfeFB57V5DMMwDhw4YPj7+5sQWfay2WyGu7u7ER4ebnz77beONXlyOj8/P8f9Tk5ONvLkyWPs3LnTcfzgwYM58n5nRE5cZw05h5vZSdO97Ny5c5o0aZIeffRRx5z+jz76qCZPnqyzZ8+aHV62KVSo0C23nPgNzeXLl1WwYEHHz56envrhhx9UpkwZNW/eXDExMSZGl31+++03TZ06Ve3atdPMmTMVGRmpsWPHqnjx4ipVqpQmTJiQI6cCnjVrlsaMGaOIiAjHt6+5wbJly5SYmChJGj16tK5cuaJ//vlHMTExOn78uHx8fDRmzBiTo8x6N6Z6luSY6tlZTp3qWZI+++wz+fj4qFu3bipWrJgGDx6s3bt3mx1WtvLw8FBCQoKk6wPQ7Xa742dJio+Pz5EVxYxYtWpVjq8g495F97A7tHXrVkVERChfvnzprtNy7do1LV++XHXr1jU50qzn4+Oj/v3733Sg4vHjxzV+/Pgc1T2sRo0aGjt2rDp27OiyPyUlRZ06ddKOHTt08uTJHHXNkuTt7a2DBw+qZMmSkq6v47Br1y6VL19eknTixAlVqlRJ165dMzPMbHPq1Cl1795dHh4emj17tkqWLKk///wzxw5WdnNzU1RUlAIDA1WpUiVNmjRJjzzyiOP4qlWr1Ldv3xz3oWbJkiXq3r27pk6dKkkaP368Ro8e7TLVc+fOnTVp0iSTI81azvc7JiZGc+bM0ezZs3Xw4EGFhoaqb9++6ty5c46bgKFDhw5KTU3VyJEj9eWXX2rHjh0qWrSo5s+fL5vNph49eujq1as58gsZ4J5mdqnnXlW/fn2jX79+ht1uT3PMbrcb/fr1Mxo0aGBCZNmvYcOGxvvvv3/T4zmxe9jw4cONli1bpnssOTnZeOSRR3LcNRuGYZQqVcqlW9yIESOM8+fPO37e9f+19+dxNef///h/e55Oe2kdtEpCZalkLSZ7ssVgBhGRwTBDJEuWMbbsQxhDCoOJIUvZlWwTUZQt0kZakGxFi/P4/eHn+XGoefH+nnOePN2vl8u5zOX5vJ9yO56mzuM8H4/H/coVZmpqKkQ0lZHJZGzhwoWsdu3aTE1NTdTTwziO46d/1axZk127dk2unp2dzTQ1NYWIpnS7d+9mlpaWTCKRMI7j+IeWlhabOHEiq6ysFDqiwnEcxwoLCz84f/r0aTZs2DCmq6vLdHV1BUimXLdv32b169dnHMcxBwcHlpuby3r37s2kUimTSqXsm2++YUlJSULHVKr8/Hy2b98+tn79erZ+/Xq2b98+lp+fL3QsQv4T3Wn5P9LW1sbly5dhb29fZT0tLQ0uLi54+fKlipMp38KFC1FRUYE5c+ZUWb937x5mz56NiIgIFSdTnsrKSpSWlla7HWRlZSXu378vugWt3t7e6NixIyZMmFBlfe3atYiKikJsbKyKk6leUlISzp49C19fX7mpgmIikUjg5eUFTU1NxMfHY+vWrejZsydfv3DhAry9vfltUsXma9vqWU1NDfn5+ahZs2aV9WfPnmHnzp0YNWqUipOpRlFREUxMTPjj2NhYvHz5Em3atJE7LyYlJSUYPXo0IiMjwXEcjI2NAQCPHz8GYwyDBg3Cn3/+CR0dHYGTEvIhGrT8H9WtWxdz586Fr69vlfWtW7di9uzZyM7OVm0wQlQoMTEROjo6aNy4sdBRVCIrKwtWVlYf7ComFn5+fnLHXl5e+P777/njoKAgpKam4siRI6qORpTg3elh5Ovg7++P06dPIzQ0FJ07d+a3sn/9+jViY2Px888/49tvv8XGjRsFTkrIh2jQ8n+0du1aTJ48GaNHj0anTp0+WNOyceNGLFu2DD/99JPASYmi5OfnIzY2FsbGxujcuTPfSRh48+nV8uXLRblImfw/GhoaSElJ+Wr7dZSUlEBNTQ1aWlpCR1GosrIySCQSfvF1RkYGwsPD+eaSI0eORN26dQVOSRQpJSUFSUlJaN++PWxtbXH9+nWsXbsWMpkMffv2haenp9ARlcLIyAgHDx6Em5tblfVz586hZ8+eKC4uVnEyQv43GrT8f7Bz506sXLkSSUlJ/AJsNTU1uLq6YtKkSXKfUH5NiouLER0dXe1dqC/RxYsX0bVrV8hkMlRUVMDCwgL79u1Do0aNAIi7uWRRURFSU1Ph5OQEY2NjPHr0CJs2bUJZWRkGDBggyjfw3333XZXn9+/fj44dO/LThaKiolQZiyhJ+/btMX78ePTv3x/nzp1Dp06d0LBhQzg4OOD27du4desWTpw4gTZt2ggdlShAVFQUvv/+exgaGqKsrAx79+7FgAED0Lx5c6ipqeHEiRPYunUrBg8eLHRUhTMwMEBsbGy1mwRdvHgRnTt3xtOnT1WcjJD/jQYtClBRUYFHjx4BAExNTb/arRLfEmNzyS5dusDKygphYWEoKSnB1KlTsWvXLhw/fhwuLi6iHbQkJiaia9euePbsGQwNDXH8+HEMGDAAUqkUMpkMeXl5OHv2LJo1ayZ0VIWSSCT49ttvP/h0fevWrejduzcMDQ0BQFTrtqqSl5eHP//8k28u6e/vX+06vi+ZgYEBLl26hPr166N9+/Zo1qwZVqxYwddnzZqFkydP4uzZswKmVLxevXrh+++/R//+/UW7pXNVXF1d8d133yE4OBiRkZEYO3YsJk2ahFmzZgF403Rz27ZtuHz5ssBJFc/Hxwc3b97Epk2b4OLiIle7fPkyRo0aBXt7e2zbtk2ghIT8B4E2ACBfsKdPn/7n48yZM6LbScvIyIjdunVL7tyiRYuYkZERS0xMFG1zyc6dOzN/f3/27NkztnTpUmZpacn8/f35up+fH+vTp4+ACZXj77//ZpaWliw8PFzuvNibS2pra/O7h12/fp0ZGBgwOzs7NmDAAGZvb890dHRYSkqKwCkVT1dXl928eZMxxlitWrXYlStX5Op37txhenp6QkRTKo7jmFQqZQYGBmzMmDHs0qVLQkdSCV1dXZaVlcUYe7M7oLq6OktNTeXrGRkZorzejDH2+PFj1q1bN8ZxHDM2Nmb29vbM3t6eGRsbM4lEwry8vFhxcbHQMQmpkjhXkxKlMjQ0BMdx1dYZY/9Z/1K923wMAKZNmwapVIquXbsiPDxcoFTKlZSUhNWrV0NfXx8TJkzA1KlT5XYSGj9+vFwfD7EYOHAgWrdujSFDhiAmJgZhYWGi3THsXa9evQL7/998nzFjBr799ltERUXxd9Z8fHwQHByM6OhogZMqVqtWrRAdHQ17e3vUq1cPKSkpcHJy4utXrlzhd1kSm5SUFBw7dgzh4eHYsGEDmjRpAn9/f/j4+Ij237y+vj6KiopgY2ODJ0+eoLKyEkVFRXy9qKgIenp6AiZUHiMjIxw+fBg3b97E+fPn+Z0Aa9eujTZt2ojyTioRDxq0kE+mr6+P4OBgtGrVqsp6eno6Ro8ereJUytW4cWP8+++/aNq0qdz5wMBAyGQyDBo0SKBkylVeXs5PG1FXV4eOjg5MTU35uqmpqdwvezGxsbHB6dOnMXfuXDg5OWHjxo2iHIxXJzk5Gdu3b+d3SpNIJAgKCkKPHj0ETqZ48+fPh5eXF0pKSjBo0CBMnjwZ6enpfHPJ1atXY/r06ULHVApTU1NMnDgREydORGJiIjZt2oSZM2ciKCgIffr0gb+/Pzp27Ch0TIXq3Lkzxo0bh59//hk7d+5E165dMX36dERERIDjOEyZMgVt27YVOqZSOTg4iHI9IhE3GrSQT/Z2/YKHh0eVdUNDQ/7TWrHw9fXFqVOnMGbMmA9qQUFBYIxh/fr1AiRTLisrK2RmZsLGxgYAEBkZCTMzM76en58vN4gRG4lEgrlz56JLly7w9fVFZWWl0JGUiuM4fmAmkUhgYGAgVzc0NBTlrkJt2rTB4cOHMWnSJFy4cAEAsGDBAgCAubk5fv3112p7FYlJy5Yt0bJlS6xcuRK7du3Cpk2b0KVLF9Gt1Vu2bBmGDh2KMWPGwN3dHTt37sTMmTPh6OgIjuNQr149bNq0SeiYSlNeXo59+/YhISFB7k6Lm5sbvL295XbGJORzQgvxySfbuHEjXr58iV9++aXKemFhIdavX19t80ny5Zg7dy4aNmyIgQMHVlkPDg5GWloa9uzZo+JkqvfixQtkZGTAwcFBtL/U3w5UOI7DixcvEB4ejiFDhvD148eP48cff0RWVpaAKZXr4cOHcs0l3w7Yxehj+rTcvn0bDRo0UGEq4WRmZqK0tBT29vai7cV0584deHp6Ii8vD61atZJr13DhwgVYWlri8OHDsLOzEzgpIR+iQQsh5P+stLQUampq0NTUFDqKSmzevBl9+/b94A6EWGzZskXuuGHDhmjdujV/PG/ePBQXF8vtrEW+XB06dMDevXv53fCI+HXp0gW6urrYunUratSoIVd79uwZfH198fLlSxw9elSghIRUjwYthHykQ4cOISoqCsbGxhgxYoTcgsXi4mL069cPcXFxAiYkyva1N5cUq9zcXGhpafFTHc+cOYP169fzzSXHjRtHPVpEJiYmBomJifD09IS7uzvi4uKwbNkyyGQyfPfdd/jxxx+FjqgUOjo6SExMROPGjausX716Fa1atUJpaamKkxHyv0mEDkDEp7CwEL/99pvQMRRqx44d6N27NwoKCpCQkAAXFxds376dr5eXl+PUqVMCJlSe48ePY86cOfyA7PTp0/Dy8kLHjh1F26fE2Ni4ykdlZSXatGnDHxNx6NevH86fPw/gTQPR9u3b48WLF3B3d0dpaSk8PDwQExMjcEqiKH/++Sf69u2LQ4cOoXv37ti2bRv69OkDCwsL2NjYYOLEiVi1apXQMZXC0NAQ2dnZ1dazs7Ppzhv5fAm11zIRrytXroiuZ4mzszNbtWoVf7xz506mq6vLwsLCGGNMtH1a/vrrLyaVSlmzZs2Ynp4ei4iIYIaGhszf35+NGDGCaWhosH/++UfomAqnp6fHevTowTZv3sw/IiIimJqaGluwYAF/TmwuXLjAKisr+ePo6Gj27bffMnNzc+bq6sq2bNkiYDrl0dXVZZmZmYwxxlq1asVCQkLk6qGhoczFxUWIaEqlp6fHRowYwc6dOyd0FJVydHRkGzZsYIwxFhcXx7S0tNjatWv5ekREBHNwcBAqnlLNmjWLGRkZsRUrVrCUlBRWUFDACgoKWEpKCluxYgUzNjZmc+bMETomIVWiQQv5ZCkpKf/52Llzp+jewL/7puatuLg4pqenx/744w/RDlreHaydOHGCaWtrsxUrVvD1ZcuWMXd3d6HiKU16ejpr0aIF8/X1Zc+fP+fPi725pEQiYYWFhYwxxg4cOMAkEgnz9fVla9euZf7+/kwqlbKoqCiBUyqegYEB3zSzZs2aHzTQvHPnDtPR0REimlJxHMcaNWrEOI5j9vb2bNmyZXxzUTHT1tZmOTk5/LG6ujq7evUqf5yVlSXK6/1WSEgIMzMzYxzHMYlEwiQSCeM4jpmZmbHFixcLHY+QatGghXyytz/oOI774PH2vNjewJuZmbGEhIQPzsfHxzM9PT0WHBwsutfM2IeDNXV1dbk3dDdv3mQmJiZCRFO6iooKFhQUxOrVq8fOnj3LGBP/oIXjOH7Q0rZtWzZt2jS5+oIFC1jr1q2FiKZUvXv35l+rp6en3F1VxhjbuHEjq1+/vhDRlOrt9b5y5QobP348MzY2ZhoaGuy7775jhw4dYjKZTOiISmFpaclOnz7NGGPs/v37jOM4dvDgQb4eHx/PLC0thYqnMpmZmezff/9l//777wcfyhHyORLnnn5EqYyNjbFkyRJ06tSpyvr169fRq1cvFadSrpYtW+Lw4cNyOykBb3rVREdHo2fPngIlUy51dXWUl5fzx5qamnKdojU1NfHy5UshoimdVCrF4sWL4enpicGDB8PHx+erai55+/Zt/P7773Ln+vXrh6VLlwoTSIlCQkLQrl075OXloW3btggODsbFixf55pI7d+4UZR+mt5ycnBAaGoply5YhKioKmzZtQs+ePWFubg4/Pz/RrVH09vbGyJEjMWzYMBw4cAC+vr6YPHkyJBIJ31yya9euQsdUurp166Ju3bpy5+7du4c5c+YgPDxcoFSEVI8W4pNP5urqiry8PNSpU6fKh4WFheiaSwYEBEBLS6vKWvv27REdHQ1fX18Vp1I+Ozs7pKWl8cf379+X+yWXkZEBS0tLIaKpTMeOHZGcnIy0tDTo6upCTU1N6EhKdePGDaSmpkJbWxsymeyDuhgbbDo4OODChQsoLy/HkiVLUFJSgu3bt+PXX3/FnTt3EBkZieHDhwsdU+HeH4Rrampi0KBBOHHiBDIyMjB8+HBs3rxZmHBKtHjxYrRv3x6RkZFwdnbGhg0bMHLkSHh7e8PLywsmJiZYtGiR0DEF8fjx4w+2Pifkc0FbHpNPtnfvXpSUlMg1nXtXcXExDhw4gGHDhqk4GVG0vXv3wsTEBN9++22V9ZCQEJSUlGDevHkqTkaU4e0nzW9/LaxYsQITJ07k65GRkZg3bx6uX78uUELlY4zhwYMHkMlkMDU1hbq6utCRlOZjmksyxr6aO4yvXr1CRUUF9PX1hY6iNAcOHPjPemZmJiZPnozXr1+rKBEhH48GLYQQ8pH8/PywYMECmJubCx1FKXJycuSO9fT0YGJiwh9v3boVAER5V/FrNHfuXEyZMgU6OjpCRyEq8v4HE1XhOI4GLeSzRIMWQj5CRUUFgoOD+eaSY8aMwYgRI/h6YWEhzM3Nv5of9IwxyGQy0U6VSk1NrfJ88+bNsWvXLtja2gIAmjZtqspYREmSk5NhZGTET33866+/5JpLjh8/HgMHDhQ4JVGkNWvWIDExEd27d8fAgQPx119/YdGiRXxzyd9++w1SqfiW/VpYWGDdunXw9vausn7lyhW4urp+Nb/LyJeF1rQQhbt3757cG3oxWLBgAbZu3YoxY8aga9eumDRpEkaPHi33HDGO/ysrKzFz5kx4eHhgzpw5AIClS5dCT08POjo6GDZsmNxCfbFwdnaGi4sLnJ2d5R6VlZXo168fX/8aVFRUID09HU+fPhU6itL4+fkhIyMDABAWFobRo0ejefPmCA4ORosWLTBq1ChRLkxOSkoSOoIg5s+fjxkzZqC0tBQBAQFYvHgxAgIC4OPjg2HDhiEsLEy0U15dXV3/87r/r7swhAhKiC3LiLiJsbmknZ0di46O5o/T09OZnZ0dGz58OJPJZKLt0zJz5kxWq1YtNmnSJObo6MjGjBnDrKys2LZt29iWLVuYhYWFKPf1d3JyYj169GA3b95k2dnZLDs7m2VlZTGpVMqOHz/OnxObxYsXs9LSUsYYY5WVlWzy5MlMQ0ODSSQSJpVKmZ+fHysvLxc4peJpa2vz19PFxYVvPPjW9u3bmaOjoxDRlIrjOFavXj22YMECdv/+faHjqEy9evXYnj17GGNvfl+pqamxbdu28fWoqChmZ2cnVDylOn36NDt8+HC19RcvXrD4+HgVJiLk49H0MPLJvsaFfDo6Orhx4wZsbGz4c/fv30fHjh3RokULLFmyBFZWVqJ6zQBQr149rFq1Cj179sSdO3fQsGFD7NixAz/88AMAYNeuXZg3bx6uXr0qcFLFKi8vR1BQEI4fP45t27bxd1XU1dWRkpICR0dHgRMqh5qaGvLz81GzZk0sW7YMCxcuxPLly9GqVStcvnwZkyZNwuTJkxEUFCR0VIUyNTXF0aNH4erqilq1auHYsWNwcnLi6xkZGWjSpAlKS0sFTKl4EokE/v7+2L9/Px4/fgxPT0/4+/ujV69eop36Cbz5eZ6WlgZra2sAgIaGBi5fvoxGjRoBeLO2y9HRESUlJULGJIS8T+hRE/ny/FdzyXebTIpJ3bp12YkTJz44f//+fdagQQPWpUsX0b1mxhjT0tJid+/elTu+efMmf5yZmcn09fWFiKYShw4dYpaWlmzhwoXs9evXX1VzSRcXF/bnn3/K1bdt28YaNWokRDSlGjJkCBs5ciRjjLEBAwawmTNnytUXLlzImjRpIkQ0pXp7vSsqKtju3btZ9+7dmZqaGqtVqxYLCgpit27dEjqiUtStW5e/23D79m0mkUjYrl27+PrBgweZjY2NUPEIIdWgNS3kk5mZmSEqKgoymazKR3JystARFa5jx47YsWPHB+fNzc0RFxeHrKwsAVIpn4GBAZ48ecIfN2vWTG470LKyMlFvh+rl5YVLly7hzJkzaN++vdBxVOLt9bx79y7c3Nzkam5ubqL8t7548WLExsbCw8MDVlZWWL58Odq1a4cff/wRHh4e+PXXXxESEiJ0TKWRSqXo168fDh48iJycHIwbNw67d++Gg4NDtdudf8l8fHzg6+uLUaNGwdPTE0FBQQgMDMT69evx559/YsyYMejbt6/QMQkh7xHf1hhE6d4u5Ktu9xExLuSbNWuWXJPFd1lYWODUqVM4fvy4ilMpn6OjI5KTk9GkSRMAwLlz5+TqV69eRf369YWIpjK1atXCoUOHsHr1apiYmKBGjRpCR1KqjRs3Qk9PDxoaGnj8+LFc7fnz59DU1BQomfKYm5vj8uXLCAkJQXR0NBhjSExMxL179+Du7o5z586hefPmQsdUuKo+cLCwsMCsWbMwa9YsxMbGinIDgrlz50JbWxsJCQkYNWoUpk2bBicnJwQFBaG0tBS9evUS7UJ8Qr5ktKaFfLIzZ86gpKQE3bp1q7JeUlKCS5cuwcPDQ8XJiKLdvn0b6urq/Faw79uxYwekUim+//57FScjymBjYyP3RnbChAlyzSVXrVqFyMhIJCQkCJCOKNrHNJckhJDPBQ1aCPkEubm5MDQ0hJ6entz5iooKJCQkiHIqBfl/bG1tcfToUdHfXarO+fPnoamp+dVs91xZWSnKXh1vnTp1Cu7u7qJ+jZ+KMSbqKa+EfMlo0ELIR8jPz4e3tzeSkpLAcRwGDx6MdevW8YMXsTeXfP36tdxuQhcuXEBZWRnatGkDdXV1AZMpx+rVq6s8P2nSJAQFBaF27doAgF9++UWVsYiSHDlyBBYWFmjSpAlkMhkWLFiA9evXo6CgAGZmZhg/fjymTp1Kb2ZFoqysDMHBwUhMTESPHj0wdepUzJ8/H4sWLQLHcejduzfWr18v+qmghHxpaNBCFC4jIwOjRo1CXFyc0FEUZtiwYbh16xbWrFmDJ0+eYNq0aeA4DseOHYORkREKCwthZmYGmUwmdFSFys/Px4ABA3D+/Hm4u7tj3759GDp0KA4dOgQAqF+/PuLj42FmZiZwUsWSSCSwsLD44BPonJwcmJubQ11dHRzHITMzU6CEqsEYQ3x8PO7cuQMzMzN4enqKcpBqb2+PjRs3ol27dli0aBGWL1+O4OBgODg44NatW1i0aBECAgIwdepUoaMq1PLly9G/f3/UqVNH6CgqNWnSJOzcuRODBg3CoUOH0KFDB8TExGDhwoWQSCSYPXs2vLy8qv3wghAiEGE2LSNiJsbmkubm5uzChQv88atXr1ivXr2Ys7MzKyoqEm1zyaFDhzI3Nzd24MAB9sMPPzA3NzfWrl07lpuby3Jycpi7uzsbN26c0DEVbvTo0czZ2ZnduHFD7rzYtzz28vJiT548YYwxVlRUxFq1asU4jmPffPMNk0gkzN7enj148EDglIqnqanJcnJyGGOMNW7cWG77W8YYi4mJEWWzQY7jmJqaGuvcuTOLjIxkZWVlQkdSCSsrK3b8+HHGGGMZGRlMIpGwffv28fVjx46xOnXqCJSOEFIdmshKPtn/+vTp/v37KkqiOk+fPoWRkRF/rKmpiaioKAwYMAAdOnTAtm3bBEynPCdOnEBUVBRat24Nd3d3mJqa4vjx47CwsAAA/Pbbbxg1apTAKRVv/fr12Lt3L78d6vjx44WOpBJHjhxBWVkZAGDmzJl4/vw5MjIyULduXeTm5qJPnz6YPXs2/vjjD4GTKpaxsTHy8vJgbW2Nhw8fws7OTq7eoEEDUf5cA4CwsDD+DmqNGjUwZMgQ+Pv7o3HjxkJHU5pHjx6hQYMGAN6sU1NTU5O75vXr18fDhw+FikcIqQYNWsgnmzhxIszMzKChoVFlvby8XMWJlM/W1hapqalyC7ClUin++ecfDBgwAD179hQwnfIUFxfzAxRjY2Po6OjITSWxs7NDfn6+UPGUqm/fvmjZsiV8fX1x8OBBRERECB1JpeLi4rBkyRJ+5zhLS0ssXrxYlIPUvn37YsGCBdi3bx+8vb2xbt06bNiwgV/DEhoaCmdnZ2FDKkn37t0xfPhwPHjwAJs3b0ZERARCQ0Ph6uqKUaNGYeDAgXK9mcTA2toaCQkJsLa2xsWLF8FxHBITE9GoUSMAb9bsvf25Rwj5fFBzSfLJ6tSpg5UrVyIrK6vKx8GDB4WOqHBeXl7YsGHDB+ffDlzE+oamZs2acoOS8ePHw9jYmD8uLi6Grq6uENFUwsLCAidOnMC3334LFxcX0fUfqsrbN+rFxcWoV6+eXM3Ozg55eXlCxFKqhQsXoqCgAPb29nj58iW2bduGunXromvXrrC1tcXWrVuxcuVKoWMqVc2aNREUFISbN28iPj4ejo6OCAgIEN16NQAYM2YMhg8fji5dusDT0xPLli3DjBkzMHXqVEyfPh2jR4/G0KFDhY5JCHkP3Wkhn+xtc8nqenOIsbnkggULUFpaWmVNKpViz549opw+4uzsjISEBLRs2RIAPugKfvbsWTRt2lSIaCrDcRymT5+Orl274uzZs6J8E/eu4cOHQ1NTExUVFcjKyuI/fQaAgoICGBoaChdOSQwMDPDvv/9i06ZNiI6Oho2NDWQyGcrLyzFo0CCMHTsWlpaWQsdUuOp2Q2vXrh3atWuH1atXY+fOnSpOpXwTJ05EzZo1kZCQgBEjRmDQoEFo0qQJZs+ejdLSUgQEBCA4OFjomISQ99DuYeST3bhxA6WlpdV2iK6oqEBeXt5XtyPN1ygxMRE6Ojqinv/+rqysLFhZWYm2r4Wfn5/csZeXl9yHE0FBQUhNTcWRI0dUHY0oATWXJIR8SWjQQshHys/PR2xsLIyNjdG5c2e5NT0lJSVYvnw5Zs+eLWBComwaGhpISUmBg4OD0FEEUVJSAjU1NWhpaQkdRenKysqQm5sLS0tLaGpqCh2HqEBhYSEYY3wfJkLI54UGLYR8hIsXL6Jr166QyWSoqKiAhYUF9u3bx0+dEXNzyaKiIqSmpsLJyQnGxsZ49OgRNm3ahLKyMgwYMECUb+C/++67Ks/v378fHTt25BcmR0VFqTIWUZLNmzejYcOGaNOmDV69eoVx48Zhy5YtYIxBIpFg5MiRWLVqFQ1eROLx48f48ccf+eaSa9aswejRoxEeHg6O49CqVSvs2bNH9FNBCfnS0EJ8onA3b96Era2t0DEUasaMGejbty+Ki4tRWFiILl26wMPDA5cvXxY6mlIlJiaiXr166NSpE+zs7JCUlISWLVti06ZN2Lp1K1xdXZGcnCx0TIXbt28fHj9+DAMDA7kHAOjp6ckdi1leXh7mzJkDHx8fBAYGIi0tTehISvHbb79BInnz63DWrFmIi4vDP//8g+vXr2P37t04efIkZs2aJXBKxevVqxf++usvvHz5UugoKjVlyhTcunWL33igX79+uHjxIs6cOYOzZ8+isrIS06ZNEzomIeR9QjWIIeIlxuaSRkZG7NatW3LnFi1axIyMjFhiYqJom0t27tyZ+fv7s2fPnrGlS5cyS0tL5u/vz9f9/PxYnz59BEyoHH///TeztLRk4eHhcufF3lxSW1ubbx55/fp1ZmBgwOzs7NiAAQOYvb0909HRYSkpKQKnVLx3m0s2aNCAHT58WK5+6tQpZm1tLUQ0peI4jkmlUmZgYMDGjBnDLl26JHQklTAzM2Pnzp1jjDFWUFDAOI5jx44d4+tnz55lFhYWQsUjhFRDnKtJiVJNmjTpP+tibcr16tUrueNp06ZBKpWia9euCA8PFyiVciUlJWH16tXQ19fHhAkTMHXqVLk+HePHj0fv3r0FTKgcAwcOROvWrTFkyBDExMQgLCxMrrmoWL169Yrf+W/GjBn49ttvERUVBalUCplMBh8fHwQHByM6OlrgpIpVu3ZtZGRkwNraGiUlJTA1NZWrf/PNNygqKhIonXKlpKTg2LFjCA8Px4YNG9CkSRP4+/vDx8dHtP/mnz59yvdhqVWrFqRSqdxUMHNzczx58kSgdISQ6tD0MPLJVq1ahVOnTuHy5ctVPsQ4haRx48b4999/PzgfGBiI6dOnY9CgQQKkUr7y8nJoa2sDANTV1aGjoyP3hs7U1FS0b+ZsbGxw+vRpNG7cGE5OTjh69Gi1W8SKUXJyMqZMmcLvlCaRSBAUFISkpCSBkyne28HYkydPMHToUPz222948eIFAKC0tBS//vor3N3dBU6pHKamppg4cSJSU1ORkJCAVq1aYebMmbCwsMDgwYMRFxcndESFq1+/PmJiYgAAhw8fhpaWFo4dO8bXjx49yjdVJYR8RoS+1UO+PA0aNGB//fVXtfXLly+LbqrUxo0b2ZAhQ6qth4SEMBsbGxUmUg17e3sWGxvLH8fExLDS0lL++Pz588zS0lKIaCp15swZVrduXcZxnKinh0kkEn56WJ06dT6YCpaZmcm0tLSEiKZUZWVlrHfv3szIyIh16dKFaWlpMR0dHVa/fn2mq6vLrK2tP5geKgYcx7HCwsIPzpeUlLCIiAjWtm1b0f0sZ4yxbdu2MTU1NWZnZ8c0NTXZP//8w8zNzdn333/PBg4cyDQ0NNiaNWuEjkkIeQ/tHkY+mY+PD2rWrFlth+iUlBS4uLhAJpOpOBlRtLlz56Jhw4YYOHBglfXg4GCkpaVhz549Kk6mei9evEBGRgYcHBzktrsWE4lEAgMDA3AchxcvXiA8PBxDhgzh68ePH8ePP/6IrKwsAVMqz5EjRxAdHY3MzEzIZDKYmZnB3d0dgwcPhq6urtDxFO5j+rTcvn0bDRo0UGEq1Th37hzOnz+PNm3awM3NDTdu3EBISAhKS0vRq1cvDBs2TOiIhJD30KCFfLKCggKUlZVR80iC0tJSqKmpfTVbwW7evBl9+/YV7c5hW7ZskTtu2LAhWrduzR/PmzcPxcXFWLFihaqjESXo0KED9u7dC0NDQ6GjEELI/0SDFkI+0qFDhxAVFQVjY2OMGDEC9vb2fK24uBj9+vUT5fxv8v987c0lvybp6em4e/cu6tSpAzs7O6HjECV4/fo11NTU+OPExETIZDK4uLh8NR/EEPIloYX4hHyEHTt2oHfv3igoKEBCQgJcXFywfft2vl5eXo5Tp04JmFB5jh8/jjlz5vADstOnT8PLywsdO3ZERESEwOmUw9jYuMpHZWUl2rRpwx8TcVi0aBFiY2MBvPkAolOnTmjYsCG6dOmChg0bwsvLi3aTEpGcnBw0b94cmpqa8PLywrNnz9ClSxe0bt0abm5ucHBwwO3bt4WOSQh5Dw1aiMKlpKTIfXolBkuXLsWKFSsQExODM2fOYMuWLRg9ejQ2bdokdDSl2rZtG7p3746YmBh4e3tj8+bN8Pb2hqWlJerWrYsxY8Zg9+7dQsdUuIqKCri5uWHlypX8Y8WKFfwOWm/PiU1iYiJev37NH8fExMDDwwMWFhZo3rw5tm7dKmA65Vm3bh0/CA0KCkJxcTGSkpJQWlqK5ORkPHnyBIGBgQKnVDx9fX2MHDmyyp0RxWzy5MnQ09PDvn37UKNGDXTv3h2VlZW4d+8e7t+/jwYNGmDq1KlCxySEvE/IXQCIOF25coVxHCd0DIXS1dVlmZmZcufi4uKYnp4e++OPP0TbXNLZ2ZmtWrWKMcbYiRMnmLa2NluxYgVfX7ZsGXN3dxcqntKkp6ezFi1aMF9fX/b8+XP+vNibS0okEn43qQMHDjCJRMJ8fX3Z2rVrmb+/P5NKpSwqKkrglIqnqanJsrOzGWOM2djYsFOnTsnVL126xMzMzISIplQcx7FGjRoxjuOYvb09W7ZsGb97nJh988037PLly4wxxp48ecI4jmNnzpzh60lJSaxWrVoCpSOEVIeaS5JP9t133/1n/enTp6LrZ1GjRg0UFhbK7d3foUMHxMTEoGfPnsjNzRUwnfKkp6ejV69eAIBOnTqhsrISnTp14us9evTAokWLhIqnNHZ2dvj3338RHBwMZ2dnbNmyRbR9Ot7F3lniuGTJEgQFBcld37p162LJkiXo27evEPGUpk6dOrh27Rrq1KkDjuP43jRvqampoaSkRKB0yhUXF4f8/HyEhYVh4cKFmDFjBnr27Al/f39069ZNdD/LgTdNVN9upqGvrw81NTXo6+vz9Ro1aqC0tFSoeISQatD0MPLJoqOj+R/6VT309PSEjqhwLVu2xOHDhz847+HhgejoaPz++++qD6UC6urqKC8v5481NTXlrq+mpiZevnwpRDSlk0qlWLx4MTZs2IDBgwdjxowZonwDV53bt2+jf//+cuf69esnyuaxo0aNwpQpU3Dnzh2MHz8egYGByMjIAABkZWUhICAAXbt2FTil8jg5OSE0NBR5eXnYvHkznj59ip49e8La2hqzZ88WOp7CNWrUCOHh4QDe7JhnYmKCyMhIvv7333+LcptnQr50dKeFfDIHBwf069cPI0eOrLJ+5coVvtuwWAQEBFQ777t9+/aIjo4W5Xx/Ozs7pKWloWHDhgCA+/fvy30imZGRAUtLS6HiqUTHjh2RnJyMUaNGQVdXV3Trtd5348YNFBQUQFtbu8peS5WVlQKkUq7AwEDcvXsXjo6OqFevHrKzs9GgQQNIpVJUVlaiWbNm+Pvvv4WOqXDvD8I1NTUxaNAgDBo0CNnZ2di0aRM2b96M3377TaCEyvHrr7+iT58+WLJkCSQSCY4ePYpRo0YhLi4OEokEFy9exI4dO4SOSQh5D215TD6Zn58fdHR0sHbt2irrN2/eRPfu3UXbgO5rsnfvXpiYmODbb7+tsh4SEoKSkhLMmzdPxcmIMkgkEnAcx08TW7FiBSZOnMjXIyMjMW/ePFy/fl2ghMp18+ZNxMTEfNBcsnPnzqK8y/YxzSUZY6J87dnZ2UhKSoKrqytsbGxQWFiItWvXorS0FD169ECHDh2EjkgIeQ8NWsgnKysrw+vXr6GjoyN0FEJUys/PDwsWLIC5ubnQUZQiJydH7lhPTw8mJib88du7ib6+virNRZRj7ty5mDJlCv0sJ4R8EWjQQshHqKioQHBwMN9ccsyYMRgxYgRfLywshLm5udx2sWLGGINMJhPtVKnU1NQqzzdv3hy7du2Cra0tAKBp06aqjEVUpLKyEidPnuSbS3bo0EG0/9a/Vq9fv0ZOTg5sbGwgkUhQVlaG/fv3QyaToUOHDqhVq5bQEQkh76FBC1G4yspK5OXlwdraWugoCvPrr79i/fr1CAwMxJMnT7BmzRr88MMP+PPPPwG8GbSYmZlVuQbgS1ZZWYlff/0VZ86cQfv27TF37lwsXboUv/76KyorKzFw4EBs3LgRGhoaQkdVqPenSb3r7XmO476KQWpFRQWys7NRs2ZNfsclsfn555/h6enJ7wTYpUsXpKenw9TUFI8ePYKjoyMOHz4MCwsLoaMq1NvpUV+b1NRUdOvWDYWFhXB0dMShQ4f4Kc0cx0FdXR1Hjx5FixYthI5KCHkH7R5GFO769etyWwOLwfbt2xEWFobAwEDMnz8fly5dQlxcHPz8/Pg3tmKc9z137lyEhYWhefPm2L17N8aOHYvQ0FBs2LABGzduRGxsrCh3TmvatCm8vLxw48YNZGVlISsrC5mZmVBTU8PRo0f5Y7FZsmQJvxvc69evERgYCD09Pdjb28PU1BQjRoxARUWFwCkV759//oGNjQ2AN40HLS0tUVBQgIKCAjx48AB16tSRW9sjFi1atICdnR0WLlyIvLw8oeOoTFBQENzd3ZGSkoJOnTrB09MTDg4OKC4uRnFxMXr06IEZM2YIHZMQ8j4BesMQkbty5YroGi1qa2uzrKwsuXO5ubmsQYMGzMfHh92/f190r5kxxmxtbVl0dDRj7E3DRYlEwiIjI/n6zp07WePGjYWKpzRlZWVswoQJzNHRkSUnJ/Pnv6bmkkuXLmVGRkYsPDycXb9+nW3bto3VrFmTLV68WOCUiqelpcU3j7W0tGQXLlyQq1+9epWZmpoKEU2pOI5jo0aNYjVr1mRSqZT16NGD7d27l1VWVgodTamMjIzYjRs3GGOMlZaWMjU1Nblrfu3aNWZiYiJUPEJINWjLY/LJmjVr9p91MfbtqF27NjIyMvhPYwHAwsICJ0+eRIcOHTB8+HDBsilTXl4enJycALzZ/lhDQ4M/Bt58Uvv+4m0x0NDQwO+//47Dhw+jd+/e+OmnnzB16lShYykde2c63I4dOxASEgI/Pz8AgKOjIwBg0aJFCAoKEiSfsjRo0ACJiYmoW7cu9PX18ezZM7n68+fPRTf186358+dj3bp12L9/P8LDw9G/f3+Ymppi2LBhGDlypCj7lTDG+Aai7/8XeNNMVKzXm5AvGU0PI5/sxo0baNq0Kby9vat8eHh4CB1R4Tp27Fjlvv3m5uaIi4sT7fbOBgYGePLkCX/crFkzuT4tZWVlopwW95aXlxcuXbrEr+n5Gry9nnfv3oWbm5tczc3NTZT/1gMCAhAYGIj4+HhMnz4dv/zyC2JjY5GXl4eTJ09i9OjR+O6774SOqTRSqRT9+vXDwYMHkZOTg3HjxmH37t1wcHCodrvzL5mrqysWL16M+/fvY9GiRahbty7WrFnD10NDQ9G4cWMBExJCqkJ3Wsgna9y4MVq1aoWxY8dWWb9y5Qo2btyo4lTKNWvWrGo7gVtYWODUqVM4fvy4ilMpn6OjI5KTk9GkSRMAwLlz5+TqV69eRf369YWIpjK1atXCoUOHsHr1apiYmKBGjRpCR1KqjRs3Qk9PDxoaGnj8+LFc7fnz59DU1BQomfIMHz4cjx8/Ro8ePcAYw+vXr9G1a1e+3rt3b6xcuVLAhMpR1QcOFhYWmDVrFmbNmoXY2Fi+c7yYLFq0CF5eXoiIiICJiQlOnjyJkSNHwszMDBKJBMXFxYiOjhY6JiHkPbR7GPlkEyZMAMdx1S7AzsjIgL+/P06ePKnaYEThbt++DXV19Wo3VtixYwekUim+//57FScjymBjYyP3RnbChAlyC9BXrVqFyMhIJCQkCJBO+Z48eYLjx49/0FxSrAPzj2kuKVYlJSVIS0tDw4YNoaenh1evXmH79u14+fIlunTpgoYNGwodkRDyHhq0EPIJcnNzYWhoCD09PbnzFRUVSEhIEOVUCvL/2Nra4ujRo6J9E/u/nD9/HpqamnBxcRE6ClGAU6dOwd3dXW49ByGEfK5o0ELIR8jPz4e3tzeSkpLAcRwGDx6MdevW8YMXsTeXfP36tVxzvQsXLqCsrAxt2rSBurq6gMmUY/Xq1VWenzRpEoKCglC7dm0AwC+//KLKWERFnjx5gn/++YdvLjlgwADR9qj5Wj148ADXrl2Dq6srDAwMUFhYiC1btkAmk6FHjx78lFhCyOeDBi1E4UpKSpCUlCSquw7Dhg3DrVu3sGbNGjx58gTTpk0Dx3E4duwYjIyMRNtcMj8/HwMGDMD58+fh7u6Offv2YejQoTh06BAAoH79+oiPj4eZmZnASRVLIpHAwsLig0+gc3JyYG5uDnV1dXAcJ8peLe9ijCE+Ph537tyBmZkZPD09RTlI/e677zB48GD0798f169fR/v27cFxHGxtbZGdnQ2O4xAXFwcHBwehoyrU8uXL0b9/f9SpU0foKCoVHx+Pnj17orS0FLVq1cKRI0fQs2dPaGtrQyKRIDs7GwcOHJBb10QI+QwIs9MyETMx9mkxNzeX28f/1atXrFevXszZ2ZkVFRWxgoIC0b1mxhgbOnQoc3NzYwcOHGA//PADc3NzY+3atWO5ubksJyeHubu7s3HjxgkdU+FGjx7NnJ2d+V4Ob4m9T4uXlxd78uQJY4yxoqIi1qpVK8ZxHPvmm2+YRCJh9vb27MGDBwKnVDwjIyN28+ZNxtibv4PBgwezsrIyxhhj5eXlbOTIkaxr165CRlQKjuOYmpoa69y5M4uMjORfs9i1bduWjRs3jj1//pwtXbqUWVhYyP0cCwwMZG5ubgImJIRUhQYtROHEOGjR1dVlt2/fljtXUVHB+vTpw5o2bcpSU1NF95oZY8zMzIwlJCQwxt68ieU4jp04cYKvx8bGMltbW6HiKVVUVBSzsrJioaGh/DmxD1o4juObS44dO5Y5OjryTRfv3bvHXF1d2ZgxY4SMqBTa2trszp07jLE3/+bfbSjKGGO3bt1iBgYGAiRTLo7jWEREBPP29mbq6urMxMSETZgwgV29elXoaEpVo0YN/npXVFQwqVTKLl++zNdv374tyutNyJeO+rSQT2ZsbPyfDzFNC3vL1tYWqampcuekUin++ecf2NraomfPngIlU67i4mJYWFgAeHPddXR05KaS2NnZIT8/X6h4StW3b18kJCRg79698PLyQkFBgdCRVCouLo7vYQEAlpaWWLx4MY4ePSpwMsVr2rQp4uLiALxpJPt+w9ScnBxoa2sLEU3punfvjn379iE3NxdBQUE4evQonJyc0LJlS2zcuBHPnz8XOqLCaWho4NWrVwCA8vJyyGQy/hh40yBZjNMgCfnS0ZYh5JOVlZVh7Nix1S5UzMnJwdy5c1WcSrm8vLywYcMG9OvXT+7824FLv379kJubK1A65alZsyby8/NhZWUFABg/fjyMjY35enFxMXR1dYWKp3QWFhY4ceIEQkJC4OLiItcxXqzebnlcXFyMevXqydXs7OyQl5cnRCylmjVrFnx9faGuro5ffvkFAQEBKCoqgoODA27duoU5c+Zg6NChQsdUqpo1ayIoKAhBQUE4c+YMNm3ahICAAAQEBODFixdCx1Mod3d3TJs2DdOmTcPWrVvRrFkzzJ8/Hzt37gTHcZg3bx6aN28udExCyPuEvtVDvjxubm7s999/r7YuxulhFRUV7OnTp/9Zz87OVmEi1ejdu/d/Xus1a9awjh07qjCRcC5dusR+//139vjxY6GjKA3Hcax79+6sb9++zMjIiEVHR8vVz58/z2rVqiVQOuXavXs3s7S0ZBKJhHEcxz+0tLTYxIkTWWVlpdARFU4ikfDTAavy9OlTtmHDBhUmUo3bt2+z+vXrM47jmIODA8vNzWW9e/dmUqmUSaVS9s0337CkpCShYxJC3kO7h5FPtnDhQlRUVGDOnDlV1u/du4fZs2cjIiJCxcmIqiUmJkJHRweNGzcWOopKZGVlwcrKSrR9Lfz8/OSOvby85BqHBgUFITU1FUeOHFF1NJV4/fo1kpOT5ZpLurq6Ql9fX+hoSvE1N5cEgKKiIpiYmPDHsbGxePnyJdq0aSN3nhDyeaBBCyEfKT8/H7GxsTA2Nkbnzp2hoaHB10pKSrB8+XLMnj1bwIRE2TQ0NJCSkiK6rW8/VklJCdTU1KClpSV0FEIIIV8ZGrQQ8hEuXryIrl27QiaToaKiAhYWFti3bx8aNWoEQNzNJYuKipCamgonJycYGxvj0aNH2LRpE8rKyjBgwABRvoH/7rvvqjy/f/9+dOzYkf/kPSoqSpWxiJKUlZVBIpHwi68zMjIQHh7ON5ccOXIkvyEBEYeUlBQkJSWhffv2sLW1xfXr17F27VrIZDL07dsXnp6eQkckhLyHdg8jCldcXIytW7cKHUOhZsyYgb59+6K4uBiFhYXo0qULPDw8cPnyZaGjKVViYiLq1auHTp06wc7ODklJSWjZsiU2bdqErVu3wtXVFcnJyULHVLh9+/bh8ePHMDAwkHsAgJ6entyxmOXl5WHOnDnw8fFBYGAg0tLShI6kFJ6enti/fz8A4Ny5c2jUqBFiYmJQUVGBQ4cOoXHjxkhISBA4peL16tULf/31F16+fCl0FJWKioqCq6srgoKC4OTkhBMnTqBt27ZIT09HdnY2evTogR07dggdkxDyPiEX1BBxEuNCfCMjI3br1i25c4sWLWJGRkYsMTFRtM0lO3fuzPz9/dmzZ8/Y0qVLmaWlJfP39+frfn5+rE+fPgImVI6///6bWVpasvDwcLnzYu/Toq2tzTePvH79OjMwMGB2dnZswIABzN7enuno6LCUlBSBUypejRo1+D5MHh4eLCAgQK4+c+ZM5u7uLkQ0peI4jkmlUmZgYMDGjBnDLl26JHQklWjWrBmbP38+Y+zN/+uGhobst99+4+vLli1jzs7OQsUjhFSDpoeRT/bs2bP/rKempsLDw0NUU6WMjY0RHx+Ppk2byp1ftmwZFixYgPDwcPTv319Urxl487rPnTsHBwcHVFRUQEtLCwkJCWjZsiUAIDk5Gb179xblds/Z2dkYMmQIatWqhbCwMBgZGUFdXR0pKSlwdHQUOp5SvLswu0+fPpDJZIiKioJUKoVMJoOPjw9evHiB6OhooaMqlJ6eHi5dugR7e3vUrl2b71XyVkZGBpydnUXXs0QikeDatWs4duwYwsPDcf36dTRp0gT+/v7w8fGBkZGR0BGVQk9PD9euXYONjQ0YY9DU1ERSUhK/jX9mZiacnJxEd70J+dLR9DDyyQwNDWFkZFTtQ4zNJRs3box///33g/OBgYGYPn06Bg0aJEAq5SsvL+eb6qmrq0NHRwempqZ83dTUFEVFRULFUyobGxucPn0ajRs3hpOTE44ePcr3MPkaJCcnY8qUKfxOaRKJBEFBQUhKShI4meK1atWKH4jVq1cPKSkpcvUrV67I9ScSE1NTU0ycOBGpqalISEhAq1atMHPmTFhYWGDw4MF8000x0dfX539uPXnyBJWVlXI/x4qKiqCnpydUPEJINcS5bydRKn19fQQHB6NVq1ZV1tPT0zF69GgVp1IuX19fnDp1CmPGjPmgFhQUBMYY1q9fL0Ay5bKyskJmZiZsbGwAAJGRkTAzM+Pr+fn5coMYsZFIJJg7dy66dOkCX19fVFZWCh1JqTiO4wdmEonkg3U7hoaGKC4uFiKaUs2fPx9eXl4oKSnBoEGDMHnyZKSnp/PNJVevXo3p06cLHVPpWrZsiZYtW2LlypXYtWsXNm3ahC5duojuDnLnzp0xbtw4/Pzzz9i5cye6du2K6dOnIyIiAhzHYcqUKWjbtq3QMQkh76HpYeSTdejQAV5eXggKCqqynpKSAhcXF8hkMhUnI4o2d+5cNGzYEAMHDqyyHhwcjLS0NOzZs0fFyVTvxYsXyMjIgIODg9x212LydqDCcRxevHiB8PBwDBkyhK8fP34cP/74I7KysgRMqRwJCQmYNGkSLly4IHfe3NwcU6ZMwYQJEwRKpjwf06fl9u3baNCggQpTKV9hYSGGDh2KhIQEuLu7Y+fOnZg5cybWrl0LjuNQr149HD58GPXq1RM6KiHkHTRoIZ9s48aNePnyJX755Zcq64WFhVi/fn21zSeJeJSWlkJNTQ2amppCR1GJzZs3o2/fvqLdOWzLli1yxw0bNkTr1q3543nz5qG4uBgrVqxQdTSVefjwoVxzybd3GcWoQ4cO2Lt3LwwNDYWO8lnIzMxEaWkp7O3tRdtAlpAvGQ1aCPlIhw4dQlRUFIyNjTFixAjY29vzteLiYvTr10+U87/J//O1N5ckhBBChEIL8Qn5CDt27EDv3r1RUFCAhIQEuLi4YPv27Xy9vLwcp06dEjCh8hw/fhxz5szhB2SnT5+Gl5cXOnbsiIiICIHTKYexsXGVj8rKSrRp04Y/JuKQm5uLR48e8cdnzpyBj48P2rVrhyFDhoiyR8vXLiYmBrNnz8a5c+cAAHFxcejevTu6deuGDRs2CJyOEFIVGrQQhSssLMRvv/0mdAyFWrp0KVasWIGYmBicOXMGW7ZswejRo7Fp0yahoynVtm3b0L17d8TExMDb2xubN2+Gt7c3LC0tUbduXYwZMwa7d+8WOqbCVVRUwM3NDStXruQfK1as4HfQentObBITE+UWXcfExMDDwwMWFhZo3ry56JrGvtWvXz+cP38eALB//360b98eL168gLu7O0pLS+Hh4YGYmBiBUyqevr4+Ro4cWeXOiGL2559/om/fvjh06BC6d++Obdu2oU+fPrCwsICNjQ0mTpyIVatWCR2TEPI+oRrEEPESY3NJXV1dlpmZKXcuLi6O6enpsT/++EO0zSWdnZ3ZqlWrGGOMnThxgmlra7MVK1bw9WXLlomy6V56ejpr0aIF8/X1Zc+fP+fPi725pEQiYYWFhYwxxg4cOMAkEgnz9fVla9euZf7+/kwqlbKoqCiBUyreu/9/t2rVioWEhMjVQ0NDmYuLixDRlIrjONaoUSPGcRyzt7dny5Yt45uLipmjoyPbsGEDY+zNz3EtLS22du1avh4REcEcHByEikcIqQataSGfLDU19T/raWlpGDRokKi2yTQ3N0dUVJTcomQAOHXqFHr27IkJEyZg0aJFonrNwJsmbFevXkXdunUBvFnTcenSJb7JZlpaGtq2bSs3tUYsKisrERwcjD179mDLli1wd3f/qppLtmvXDm3btsWiRYv4+sKFCxEdHS266VKGhoY4ffo0mjZtilq1auH48eNyjWQzMjLQtGlTlJSUCJhS8d5e7/z8fISFhWHHjh148eIFevbsCX9/f3Tr1k2UvYl0dHSQlpYGa2trAG9+riUnJ6Nx48YA3jSWbdSokeiuNyFfOpoeRj6Zs7MzXFxc4Ozs/MHDxcWl2u1xv2QtW7bE4cOHPzjv4eGB6Oho/P7776oPpQLq6uooLy/njzU1NeWarmlqauLly5dCRFM6qVSKxYsXY8OGDRg8eDBmzJghyjdw1bl9+zb69+8vd65fv35IS0sTKJHyeHh44O+//wYAuLi4ID4+Xq5+8uRJWFhYCJBMNZycnBAaGoq8vDxs3rwZT58+Rc+ePWFtbY3Zs2cLHU/hTExMkJOTAwDIy8tDZWUl7t69y9dzcnJozRohnyHa0498MmNjYyxZsgSdOnWqsn79+nX06tVLxamUKyAgoNp53+3bt0d0dLQo5/vb2dkhLS0NDRs2BADcv38f+vr6fD0jIwOWlpZCxVOJjh07Ijk5GaNGjYKuri7U1NSEjqRUN27cQEFBAbS1tavstSTGBpshISFo164d8vLy0LZtWwQHB+PixYt8c8mdO3eKsnns+4NwTU1NDBo0CIMGDUJ2djY2bdqEzZs3i26Nore3N0aOHIlhw4bhwIED8PX1xeTJkyGRSPjmkl27dhU6JiHkPTQ9jHwyT09PtGvXDjNnzqyyTs0lxWPv3r0wMTHBt99+W2U9JCQEJSUlmDdvnoqTEWV4+6bt7a+FFStWYOLEiXw9MjIS8+bNw/Xr1wVKqDwZGRmYOXMmDh48iBcvXgB4c7etRYsWmDJlCvr06SNsQCX4mOaSjDHR3WEsKSlBQEAAEhIS4ObmhtDQUKxevRrBwcGoqKiAh4cHdu7c+Z9/L4QQ1aNBC/lke/fuRUlJiVyn7HcVFxfjwIEDGDZsmIqTEaJcfn5+WLBgAczNzYWOohRvp8y8paenBxMTE/747d1EX19fleZSJcYYHjx4AJlMBlNTU6irqwsdSWnmzp2LKVOmQEdHR+gon4VXr16hoqJC7m4yIeTzQYMWQj5CRUUFgoOD+eaSY8aMwYgRI/h6YWEhzM3NRbcQvzqMMchkMtFOlapus4nmzZtj165dsLW1BQC5xdqEEEIIUR5aiE/IR1iwYAG2bt2KMWPGoGvXrpg0aRJGjx4t9xwxjv8rKysxc+ZMeHh4YM6cOQDe9KzR09ODjo4Ohg0bJrdQXyyq22yisrIS/fr14+tfg4qKCqSnp+Pp06dCR1Ga5ORkZGVl8cd//fUX3N3dYWVlhbZt2yIyMlLAdMqTlJQkdATBrFmzBr6+vvy1/euvv+Do6Ah7e3vMmDFDlGu3CPnS0aCFKNy9e/fk7kKIwfbt2xEWFobAwEDMnz8fly5dQlxcHPz8/PjBitjmfQNvpo+EhYWhefPm2L17N8aOHYvQ0FBs2LABGzduRGxsrCh3TmvatCm8vLxw48YNZGVlISsrC5mZmVBTU8PRo0f5Y7FZsmQJvxvc69evERgYCD09Pdjb28PU1BQjRoxARUWFwCkVz8/PDxkZGQCAsLAwjB49Gs2bN0dwcDBatGiBUaNGITw8XOCUiteiRQvY2dlh4cKFyMvLEzqOysyfPx8zZsxAaWkpAgICsHjxYgQEBMDHxwfDhg1DWFgYrdMj5HMkRHMYIm5ibC6pra3NsrKy5M7l5uayBg0aMB8fH3b//n3RvWbGGLO1tWXR0dGMsTcNFyUSCYuMjOTrO3fuZI0bNxYqntKUlZWxCRMmMEdHR5acnMyf/5qaSy5dupQZGRmx8PBwdv36dbZt2zZWs2ZNtnjxYoFTKp62tjbLzs5mjDHm4uLCNx58a/v27czR0VGIaErFcRwbNWoUq1mzJpNKpaxHjx5s7969rLKyUuhoSlWvXj22Z88extib31dqamps27ZtfD0qKorZ2dkJFY8QUg3a8ph8sgMHDvxnXYyfQNeuXRsZGRmwsbHhz1lYWODkyZPo0KEDhg8fLlg2ZcrLy4OTkxOAN9sfa2ho8MfAm09q31+8LQYaGhr4/fffcfjwYfTu3Rs//fQTpk6dKnQspWPvTHHcsWMHQkJC4OfnBwB8Q81FixYhKChIkHzKoqOjg0ePHqFOnTq4f/8+WrZsKVdv1aqV3PQxMZk/fz7WrVuH/fv3Izw8HP3794epqSmGDRuGkSNHokGDBkJHVLi8vDw0b94cwJseNRKJBM7Ozny9WbNmX9WdJ0K+FDRoIZ+sT58+ctuiVkVsU6U6duyIHTt2fNCbxtzcHHFxcWjfvr0wwZTMwMAAT548gZWVFYA3v8zf3VmnrKxMdNf6XV5eXrh06RL8/PyqbC4qRm+v5927d+Hm5iZXc3NzE+Wbdy8vL/zxxx8ICwuDh4cHdu/eLTc437VrF+zs7ARMqFxSqRT9+vVDv379cP/+fYSHh2Pz5s1YtmwZ3N3dcfr0aaEjKlTt2rVx48YNWFtbIz09Ha9fv8aNGzfQqFEjAG96jdF2x4R8fmjQQj6ZmZkZ1q1bB29v7yrrV65cgaurq4pTKdesWbOq7QRuYWGBU6dO4fjx4ypOpXyOjo5ITk5GkyZNAADnzp2Tq1+9ehX169cXIprK1KpVC4cOHcLq1athYmKCGjVqCB1JqTZu3Ag9PT1oaGjg8ePHcrXnz59DU1NToGTKs3jxYri7u8PDwwPNmzfH8uXLER8fzzeXPH/+PPbu3St0TIWr6gMHCwsLzJo1C7NmzUJsbKwo1/L4+PjA19cX3t7eiI2NRVBQEAIDA1FUVASO47BgwQL0799f6JiEkPfQlsfkk/Xu3RvOzs7Vdkmm5pLicfv2bairq6Nu3bpV1nfs2AGpVIrvv/9excmIMtjY2Mi9kZ0wYYJcc8lVq1YhMjISCQkJAqRTridPniAkJATR0dHIzMyETCaDmZkZ3N3dERAQwE8nEpOPaS4pRjKZDCEhIXxzyWnTpmHnzp0ICgpCaWkpevXqhTVr1kBXV1foqISQd9CghXyyM2fOoKSkBN26dauyXlJSgkuXLsHDw0PFyZQvNzcXhoaG0NPTkztfUVGBhISEajvHE3GwtbXF0aNHRX93qTrnz5+HpqbmV7Pds9idOnUK7u7ukEpp0gUh5PNHgxZCPkJ+fj68vb2RlJQEjuMwePBgrFu3jh+8iL255OvXr+UaSV64cAFlZWVo06aNKDuGr169usrzkyZNQlBQEGrXrg0A+OWXX1QZi6hYZWUlvaH/yjDGRL1Oj5AvGQ1aCPkIw4YNw61bt7BmzRo8efIE06ZNA8dxOHbsGIyMjFBYWAgzMzPRTYnLz8/HgAEDcP78ebi7u2Pfvn0YOnQoDh06BACoX78+4uPjYWZmJnBSxZJIJLCwsPjgDWtOTg7Mzc2hrq4OjuNEuVPeuxhjiI+Px507d2BmZgZPT09RDlKPHDkCCwsLNGnSBDKZDAsWLMD69etRUFAAMzMzjB8/HlOnThXdm9nly5ejf//+qFOnjtBRVKqsrAzBwcFITExEjx49MHXqVMyfPx+LFi0Cx3Ho3bs31q9fL/r1a4R8cYTZaZmI2Z07d1iHDh2EjqFQ5ubm7MKFC/zxq1evWK9evZizszMrKipiBQUFouzTMnToUObm5sYOHDjAfvjhB+bm5sbatWvHcnNzWU5ODnN3d2fjxo0TOqbCjR49mjk7O7MbN27InRd7nxYvLy/25MkTxhhjRUVFrFWrVozjOPbNN98wiUTC7O3t2YMHDwROqXgNGzZkp0+fZowxtnDhQmZiYsJWrFjBDh8+zH7//XdWq1YtFhISInBKxeM4jqmpqbHOnTuzyMhIVlZWJnQklQgICGDm5uZs8uTJzMHBgf3000/M2tqabdu2je3YsYPZ2dmxn3/+WeiYhJD30KCFKJwYm0vq6uqy27dvy52rqKhgffr0YU2bNmWpqamie82MMWZmZsYSEhIYY2/exHIcx06cOMHXY2Njma2trVDxlCoqKopZWVmx0NBQ/pzYBy0cx/HNJceOHcscHR1ZZmYmY4yxe/fuMVdXVzZmzBghIyqFpqYmy8nJYYwx1rhxY7Zr1y65ekxMjCibDXIcxyIiIpi3tzdTV1dnJiYmbMKECezq1atCR1MqKysrdvz4ccYYYxkZGUwikbB9+/bx9WPHjrE6deoIlI4QUh2arEs+WXXz/d+6f/++ipKojq2tLVJTU+UWYEulUvzzzz8YMGAAevbsKWA65SkuLoaFhQUAwNjYGDo6OnJTSezs7JCfny9UPKXq27cvWrZsCV9fXxw8eBARERFCR1KpuLg4LFmyhN85ztLSEosXL8aoUaMETqZ4xsbGyMvLg7W1NR4+fPhBT5YGDRqI8ucaAHTv3h3Dhw/HgwcPsHnzZkRERCA0NBSurq4YNWoUBg4cKNebSQwePXrEN820tbWFmpqa3DWvX78+Hj58KFQ8Qkg1aNBCPtnEiRNhZmYGDQ2NKuvl5eUqTqR8Xl5e2LBhA/r16yd3/u3ApV+/fsjNzRUonfLUrFkT+fn5fHPJ8ePHw9jYmK8XFxeLeltQCwsLnDhxAiEhIXBxcfnPhqpi8XbdRnFxMerVqydXs7OzE2Wn8L59+2LBggXYt28fvL29sW7dOmzYsIH/uwgNDZXrmC5GNWvWRFBQEIKCgnDmzBls2rQJAQEBCAgIwIsXL4SOp1DW1tZISEiAtbU1Ll68CI7jkJiYyDeXvHDhAv9hDSHk80GDFvLJ6tSpg8WLF1fbm0OMzSUXLFiA0tLSKmtSqRR79uwR5Sexzs7OSEhIQMuWLQEAISEhcvWzZ8+iadOmQkRTGY7jMH36dHTt2hVnz54V3aYD7xs+fDg0NTVRUVGBrKws/o0cABQUFMDQ0FC4cEqycOFCdO7cGfb29mjTpg3++ecfHD9+HA0aNMCdO3fw+PFjHD16VOiYClfdxgLt2rVDu3btsHr1auzcuVPFqZRvzJgxGD58OMLCwpCUlIRly5ZhxowZSEtLg0QiwR9//IHJkycLHZMQ8h7aPYx8sv79+6NevXpYvHhxlXVqLvn1SExMhI6ODho3bix0FKIAfn5+csdeXl5yH04EBQUhNTUVR44cUXU0pauoqMCmTZuqbC45duxYWFpaCh1R4b7W5pLAm8a4b5tLDho0CPHx8Zg9ezbfXHLWrFmQSCRCxySEvIMGLeST3bhxA6WlpdV2iK6oqEBeXt5XtY3m/v378fTpU/j6+godhajA13q9S0pKoKamBi0tLaGjEEII+crQoIUQBbC3t0d6eroom0sWFRUhNTUVTk5OMDY2xqNHj7Bp0yaUlZVhwIABcHBwEDqiyon5ehNCCCGfIxq0EEKqlZiYiK5du+LZs2cwNDTE8ePHMWDAAEilUshkMuTl5eHs2bNo1qyZ0FGJCnytd5hmzJiBgoIChIeHCx1Fpeh6f13Xm5DPHU3YJAo3Y8YMjBgxQugYRAGCg4MxYMAAPH36FDNmzECfPn3QqVMn3L59G3fu3MHAgQMxb948oWMSFZk6deoH616+Bvfv30d2drbQMVSOrjch5HNCd1qIwg0bNgz37t1DXFyc0FEUTiaTVbk4UyaTITc3F9bW1gKkUh5jY2OcO3cODg4OqKiogJaWltxuYsnJyejdu7cot3uuSseOHREREfFVrdcihBBCPge05TFRuC1btggdQeGePXsGf39/REdHo0aNGhg9ejTmzJkDNTU1AMDDhw9Rt25d0a1xKC8vh7a2NgBAXV0dOjo6MDU15eumpqYoKioSKp7SHDhwoMrzp0+fRkxMDN+3pnfv3qqMRQghhHy1aNBCyEeYNWsWUlJS8Ndff+HJkyeYP38+kpOTERUVxTfZFONNSysrK2RmZsLGxgYAEBkZKdenJD8/X24QIxZ9+vQBx3FVXtOff/4ZwJseF2IbpFYlKysLd+7cgZmZmWi3ts7NzYWWlhb/b/nMmTNYv3497t69izp16mDcuHFo06aNwCkVb8+ePfDy8oKOjo7QUVQuJiYGiYmJ8PT0hLu7O+Li4rBs2TLIZDJ89913+PHHH4WOSAh5D61pIQpXWFiI3377TegYCrVv3z78+eef6N+/P/z9/XHp0iU8fPgQvXr1QllZGYDqG7V9yQYOHIgHDx7wxz169ODvvABv7ki8nSomJp6envDy8kJBQQFkMhn/UFNTw7Vr1yCTyUQ5YPnpp5/47ucvX75E//79YWdnB09PTzg5OaFjx46i644OAP369cP58+cBvFl83r59e7x48QLu7u4oLS2Fh4cHYmJiBE6peAMGDICZmRl+/PFHXLhwQeg4KvPnn3+ib9++OHToELp3745t27ahT58+sLCwgI2NDSZOnIhVq1YJHZMQ8j5GiIJduXKFSSQSoWMolLa2NsvMzJQ79+zZM9amTRvWsWNHlpmZKbrX/DFKSkrYq1evhI6hFCtWrGBWVlYsOjqaPyeVStn169cFTKVcEomEFRYWMsYYmz59OrO0tGRxcXGspKSEnT17ltWrV49NmzZN4JSKp6ury///3apVKxYSEiJXDw0NZS4uLkJEUyqO49hvv/3GXFxcGMdxrFGjRmzlypXs0aNHQkdTKkdHR7ZhwwbGGGNxcXFMS0uLrV27lq9HREQwBwcHoeIRQqpBC/HJJ0tNTf3PelpaGgYNGiSqT6Lt7e2xYsUKdO/eXe78ixcv0LVrV5SWluLq1auies0EuHLlCnx8fNC2bVusXLkSBgYGSElJgaOjo9DRlOLdDulNmjTBjBkzMGjQIL5+4MABTJkyBbdu3RIwpeIZGhri9OnTaNq0KWrVqoXjx4+jadOmfD0jIwNNmzZFSUmJgCkV793rnZSUhE2bNuHvv//Gy5cv0bt3b4waNQpdunQROqbC6ejoIC0tjd84RUNDA8nJyfz0x+zsbDRq1Eh015uQLx1NDyOfzNnZGS4uLnB2dv7g4eLigoEDBwodUeG6du2KiIiID87r6enh6NGjX22H8P3792Pr1q1Cx1AaZ2dnXLp0CRzHwdnZWZTrlt73dppjQUGB3Bt3AHBycsK9e/eEiKVUHh4e+PvvvwEALi4uiI+Pl6ufPHkSFhYWAiRTHVdXV6xbtw75+fnYuHEjHj58iG7duqFu3bpCR1M4ExMT5OTkAADy8vJQWVmJu3fv8vWcnBwYGxsLFY8QUg1aiE8+mbGxMZYsWYJOnTpVWb9+/Tp69eql4lTKNXfuXOTl5VVZ09fXx/Hjx5GcnKziVMKbOnUq0tPTRd18TltbG+vXr8eBAwcQGxsryo0H3jVr1izo6OhAIpEgLy8PjRo14mtFRUXQ1dUVMJ1yhISEoF27dsjLy0Pbtm0RHByMixcvwsHBAbdu3cLOnTuxfv16oWMqXFXr8LS0tDB06FAMHToUd+7cqfLDmi+dt7c3Ro4ciWHDhuHAgQPw9fXF5MmTIZFIwHEcpkyZgq5duwodkxDyHpoeRj6Zp6cn2rVrh5kzZ1ZZT0lJgYuLC2QymYqTEaJcGhoaSElJgYODg9BRlKJ9+/Zyb2R9fHzg7+/PH8+fPx8nTpz44E6EGGRkZGDmzJk4ePAgv9mAVCpFixYtMGXKFPTp00fYgErw7vSwr0lJSQkCAgKQkJAANzc3hIaGYvXq1QgODkZFRQU8PDywc+fOr+7vhZDPHQ1ayCfbu3cvSkpKMGTIkCrrxcXFOHDgAIYNG6biZMr18uVLJCUlwdjY+IM1Da9evcKuXbtEfcfhazJp0qQqz69atQpDhgyBiYkJAGDFihWqjCW4zMxMaGhowNLSUugoSsMYw4MHDyCTyWBqagp1dXWhIylNTk4OrK2tRbnz4f/Fq1evUFFRAX19faGjEEKqQIMWQj7C7du30bVrV9y9exccx6Ft27ZyPUsKCwthbm4uyoX4jDFkZ2fDysoKUqkU5eXl2Lt3L8rKytC9e3dRTpeSSCRwcnKCoaGh3PlTp06hefPm0NXVBcdxiIuLEyagipSUlGDXrl18n5ZBgwbxAzby5fv555/x/fffo127dkJHIYSQ/02gXcuIiN29e5f5+fkJHUOh+vTpw3r06MEePnzI0tPTWY8ePVjdunVZTk4OY4yxgoICUW55nJaWxurUqcMkEgmzs7NjmZmZzNXVlenq6jIdHR1mamrKbt++LXRMhVu0aBGrW7cui42NlTsv9i2PHRwcWFFREWPszf/HderUYQYGBqxFixbM2NiY1axZ84Otv8UgKSlJ7nVt3bqVubm5MUtLS+bu7s7+/vtvAdMpD8dxTCKRsPr167OQkBCWn58vdCSVCQ0NZUOHDuWv7datW5mDgwNr2LAhmz59OquoqBA4ISHkfbR7GFG4x48fY8uWLULHUKh///0XixYtgqmpKezs7BAdHc2v7cnMzBQ6ntJMnToVTk5OuHLlCnr27IkePXrA0tISxcXFePz4Mdq0aSO6RqIAMG3aNOzcuRNjx45FYGAgKioqhI6kEmlpaaisrAQATJ8+HRYWFsjJyUFiYiJycnLQtGlTBAcHC5xS8fz8/JCRkQEACAsLw+jRo9G8eXMEBwejRYsWGDVqFMLDwwVOqRzHjh1D9+7dsWzZMlhbW8Pb2xsxMTGiXpM4f/58zJgxA6WlpQgICMDixYsREBAAHx8fDBs2DGFhYZg3b57QMQkh7xN61ES+PPv37//Px8qVK0V310FfX5/duHHjg/Pjxo1jlpaW7PTp06J7zYwx9s0337DLly8zxhh78eIF4ziOnTlzhq+fO3eOWVtbC5RO+Z4/f858fX1Z06ZN2dWrV5m6urqo77RwHMc3l7S1tWXHjh2Tq587d45ZWVkJEU2ptLW1WXZ2NmOMMRcXF77x4Fvbt29njo6OQkRTqnevd3l5Odu5cyfz9PRkampqzNzcnM2YMYOlp6cLnFLx6tWrx/bs2cMYe9MMWU1NjW3bto2vR0VFMTs7O6HiEUKqQVsek0/Wp08fcBz3nz0rxLaw097eHpcuXfpg16g1a9YAAHr37i1ELKV78eIF369AV1cXurq6/DoeALCyskJhYaFQ8ZROT08PW7ZsQWRkJDp37izKNUvve/v/7qtXr+SuNQBYWFjg4cOHQsRSKh0dHTx69Ah16tTB/fv30bJlS7l6q1atkJWVJVA61VBXV8f333+P77//Hnfv3kV4eDg2b96MkJAQ0f27z8vLQ/PmzQG86T0kkUjg7OzM15s1a1btFveEEOHQ9DDyyczMzBAVFQWZTFblQ4z9Svr27cs3n3vfmjVrMGjQIFE2HjQ3N5drurZkyRK5bUAfPnwIIyMjIaKp1MCBA3Hp0iVERUWhTp06QsdRqk6dOqFZs2Z49uwZbt26JVfLyckR5UJ8Ly8v/PHHHwDeNJrcvXu3XH3Xrl2ws7MTIpogrK2t8euvvyIrKwtHjhwROo7C1a5dGzdu3AAApKen4/Xr1/wx8KbXGG13TMjnh+60kE/m6uqKpKQkeHt7V1n/X3dhvkTTp0/H9OnTq62vW7cO69atU2Ei1ejcuTPS0tLQtm1bAMDYsWPl6seOHUOzZs2EiKZylpaWot7qFwDmzJkjd6ynpyd3HB0dLcqdphYvXgx3d3d4eHigefPmWL58OeLj4/nmkufPn8fevXuFjqlwderUgZqaWrV1juPQpUsXFSZSDR8fH/j6+sLb2xuxsbEICgpCYGAgioqKwHEcFixYgP79+wsdkxDyHtrymHyyM2fOoKSkBN26dauyXlJSgkuXLsHDw0PFyYiqZWVlQUtL64NpRIR8aZ48eYKQkBBER0cjMzMTMpkMZmZmcHd3R0BAAD+diHz5ZDIZQkJC+OaSbzfeCAoKQmlpKXr16oU1a9ZAV1dX6KiEkHfQoIUQ8p9u3ryJ8+fPo02bNrC3t0daWhpWrVqFsrIyDBkyBB07dhQ6IiGEEEJEjgYthJBqHTlyBN7e3tDT00NpaSn27t0LX19fODk5QSaT4dSpUzh27BgNXAghhBCiVDRoIYRUy83NDR07dsT8+fMRGRmJn376CWPHjsWCBQsAvFnrk5SUhGPHjgmclBBCCCFiRoMWQki1DAwMkJSUBDs7O8hkMmhqaiIxMREuLi4AgGvXrqFz584oKCgQOCkhhBBCxIy2PCaE/Ke3fTskEgm0tLRgYGDA1/T19fH06VOhohFCCCHkK0GDFkJItWxsbJCens4fJyQkwNramj++e/cu7RxGCCGEEKWjPi2EkGqNHTtWrht248aN5eqHDx+mRfiEEEIIUTpa00IIIYQQQgj5rNH0MEIIIYQQQshnjQYthBBCCCGEkM8aDVoIIYQQQgghnzUatBBCCCGEEEI+azRoIYSQL9Tw4cPRp08fpXzv8vJy2NnZ4d9//1XK96/O5s2bYWho+J/PmTZtGn7++WfVBCKEEPJZoEELIeSzM3z4cHAc98GjW7du/HNSUlLQu3dv1KxZE1paWrCxscEPP/yABw8e8M/Zu3cvWrduDQMDA+jr66NRo0aYOHHi//zzT548ie7du8PExAQ6OjpwdHTE5MmTcf/+fWW83P+zVatWYfPmzfxx+/btP+r1fYz169ejbt26cHNz48+9vQ7nz5+Xe25ZWRlMTEzAcRzi4+MBAK1bt8aYMWM++J4cx8llBt5c73bt2n10tsDAQGzZsgWZmZmf9qIIIYR8sWjQQgj5LHXr1g35+flyj7///hsA8PDhQ3Tq1AnGxsY4evQobt68iYiICJibm6OkpAQAEBsbix9++AH9+vVDYmIikpKSsGDBAlRUVPznn/vnn3+ic+fOqF27Nvbs2YMbN25g/fr1ePr0KZYvX6701/0pDAwM/uddif8LxhjWrFmDkSNHflCzsrJCRESE3Lm9e/dCT09P7lyHDh34AcxbJ0+ehJWV1Qfn4+PjP6nfj6mpKTw9PfHHH3989NcQQgj5wjFCCPnMDBs2jHl7e1db37t3L5NKpayioqLa50yYMIG1b9/+k/7ce/fuMQ0NDTZx4sQq68XFxYwxxh49esQGDhzIzM3Nmba2NmvcuDHbsWOH3HM9PDzYuHHj2Lhx41iNGjWYiYkJmzlzJpPJZPxztm7dylxdXZmenh6rVasWGzRoECssLJT7PteuXWM9evRg+vr6TE9Pj7Vt25bduXOHMSb/9zRs2DAGQO6RmZnJ6tWrx5YuXSr3PS9fvswAsPT09Cpf58WLF5lEImHPnj2TOw+AzZw5k9WoUYOVlpby57t06cJmzZrFALCTJ08yxhg7evQoA8Dy8/P559WqVYutXbuW1alThz+XmZkp93URERHMwMCAHTlyhNnb2zNdXV3m6enJ8vLy5LJs2bKFWVpaVpmfEEKI+NCdFkLIF6d27dqorKzE3r17warpj1u7dm1cv34d165d++jv+88//6C8vBxBQUFV1t/e1Xj16hVcXV1x8OBBXLt2DT/++COGDh2KxMREuedv2bIFUqkUiYmJWLVqFVasWIGwsDC+XlFRgXnz5iElJQX79u1DdnY2hg8fztfv37+Pb7/9FpqamoiLi0NSUhJGjBiBysrKD7KtWrUKbdq0wahRo/g7U9bW1hgxYsQHd0YiIiLw7bffws7OrsrXeebMGTRo0AD6+vof1FxdXWFjY4M9e/YAAO7evYvTp09j6NChcs9zd3eHuro6Tp48CQC4ceMGXr58iZEjR6KoqAhZWVkA3tx90dLSQps2bfivLS0txbJly/DXX3/h9OnTuHv3LgIDA+W+f8uWLZGbm4vs7OwqXwMhhBBxoUELIeSzFBMTAz09PbnHwoULAbxZLzFjxgwMHjwYpqam8PLywtKlS1FYWMh//c8//4wWLVqgSZMmsLGxwcCBAxEeHo6ysrJq/8z09HTUqFEDZmZm/5nNwsICgYGBcHZ2hq2tLX7++Wd069YNu3btknuelZUVVq5ciYYNG8LHxwc///wzVq5cyddHjBgBLy8v2NraonXr1li9ejUOHz6MFy9eAADWrl0LAwMDREZGonnz5mjQoAH8/PzQsGHDDzIZGBhAQ0MDOjo6qF27NmrXrg01NTUMHz4ct27d4gdUFRUV2LFjB0aMGFHt68vJyYG5uXm19REjRiA8PBzAm4Xz3bt3xzfffCP3HF1dXbRs2ZKfChYfH4+2bdtCU1MTbm5ucufbtGkDTU1N/msrKiqwfv16NG/eHM2aNcP48eMRGxsr9/3f5svJyak2JyGEEPGgQQsh5LPUoUMHXLlyRe7x7sLuBQsWoKCgAOvXr0ejRo2wfv162Nvb4+rVqwDevGk+ePAg7ty5g5kzZ0JPTw+TJ09Gy5YtUVpaWuWfyRgDx3H/M9vr168xb948NGnSBMbGxtDT08PRo0dx9+5duee1bt1a7vu1adMG6enpeP36NQAgKSkJvXr1grW1NfT19eHh4QEA/Pe5cuUK2rVrB3V19U/4m5Nnbm6OHj168IOM6OholJWVYcCAAdV+zcuXL6GlpVVtfciQIUhISEBmZiY2b95c7QCoffv2coOT9u3bAwA8PDzkznfo0EHu63R0dFCvXj3+2MzMTG6DBQDQ1tYGgGqvJSGEEHGhQQsh5LOkq6sLOzs7uYexsbHcc0xMTDBgwAAsW7YMN2/ehLm5OZYtWyb3nHr16sHf3x9hYWFITk7GjRs3sHPnzir/zAYNGuDp06fIz8//z2xLly7FqlWrMHXqVJw8eRJXrlyBp6cnysvLP/r1lZSUwNPTEzVq1MD27dtx8eJF7N27FwD47/P2jfn/V/7+/oiMjMTLly8RERGBH374ATo6OtU+39TUFMXFxdXWTUxM0LNnT4wcORKvXr2Cl5dXlc/r0KEDbt++jfv37yM+Pp4flL0dtGRkZODevXsfLMJ/f5DGcdwH0wAfP34MAB/c4SGEECJONGghhIiChoYG6tWrx+8eVhUbGxvo6OhU+5z+/ftDQ0MDS5YsqbL+5MkTAMC5c+fg7e2NIUOGwMnJCba2trh9+/YHz79w4YLc8fnz51G/fn2oqakhLS0NRUVFCAkJQbt27WBvb//B3YSmTZvizJkz/3PHs7c0NDT4uzjv6t69O3R1dfHHH3/gyJEj/zk1DABcXFyQlpZW7Xoh4M0Usfj4ePj6+kJNTa3K57i5uUFDQwPr1q3j1wEBQIsWLfDw4UOEh4fz08g+1bVr16Curo5GjRp98tcSQgj58kiFDkAIIVUpKytDQUGB3DmpVApTU1PExMQgMjISAwcORIMGDcAYQ3R0NA4dOsQvOv/1119RWlqK7t27o06dOnjy5AlWr16NiooKdOnSpco/8+0alPHjx+PZs2fw9fWFjY0NcnNzsXXrVujp6WH58uWoX78+du/ejX///RdGRkZYsWIFCgsL4ejoKPf97t69i0mTJmH06NFITk5GaGgov22ytbU1NDQ0EBoaijFjxuDatWuYN2+e3NePHz8eoaGhGDhwIKZPnw4DAwOcP38eLVu2rHJdi42NDS5cuIDs7Gzo6enB2NgYEomEX9syffp01K9fX27Re1U6dOiAFy9e4Pr162jcuHGVz+nWrRsePnyIGjVqVPt9tLW10bp1a4SGhsLd3Z0f3GhoaMid/79Mfztz5gzatWunsLtRhBBCPm90p4UQ8lk6cuQIzMzM5B5t27YFADg6OkJHRweTJ0+Gs7MzWrdujV27diEsLIzfxcrDwwOZmZnw9fWFvb09vLy8UFBQgGPHjlX5hv+tn376CceOHcP9+/fRt29f2Nvbw9/fHzVq1OB3sJo5cyaaNWsGT09PtG/fHrVr166yM72vry9evnyJli1bYty4cZgwYQJ+/PFHAG+mNW3evBn//PMPHB0dERIS8sHUNhMTE8TFxeHFixfw8PCAq6srNm7cWO2b/MDAQKipqcHR0RHffPON3BqbkSNHory8HH5+fv/z797ExAR9+/bF9u3bq30Ox3EwNTWFhobGf36vDh064Pnz5/x6lrc8PDzw/PnzD9azfKzIyEiMGjXq//S1hBBCvjwc+6/7/4QQQv5P2rdvD2dnZ/z+++9CRwHw5s5Ep06dcO/ePdSqVet/Pj81NRVdunRBRkbGB40jhXb48GFMnjwZqampkEppwgAhhHwN6E4LIYSIWFlZGXJzc/Hrr79iwIABHzVgAd6sp1m8eDHfT+VzUlJSgoiICBqwEELIV4R+4hNCiIj9/fffGDlyJJydnbF169ZP+tp3G11+Tvr37y90BEIIISpG08MIIYQQQgghnzWaHkYIIYQQQgj5rNGghRBCCCGEEPJZo0ELIYQQQggh5LNGgxZCCCGEEELIZ40GLYQQQgghhJDPGg1aCCGEEEIIIZ81GrQQQgghhBBCPms0aCGEEEIIIYR81v5/WBkabQe9TwAAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x900 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.ticker as ticker\n",
    "\n",
    "if not os.path.isdir('data'):\n",
    "    os.makedirs('data')\n",
    "\n",
    "save_data(results, f'data/{pv_begin}-{pv_end}-{pv_groups}-{ess_begin}-{ess_end}-{ess_groups}-results')\n",
    "save_data(costs, f'data/{pv_begin}-{pv_end}-{pv_groups}-{ess_begin}-{ess_end}-{ess_groups}-costs')\n",
    "save_data(overload_cnt, f'data/{pv_begin}-{pv_end}-{pv_groups}-{ess_begin}-{ess_end}-{ess_groups}-overload_cnt')\n",
    "df=results\n",
    "df = df.astype(float)\n",
    "df.index = df.index / 1000\n",
    "df.columns = df.columns / 1000\n",
    "min_value = df.min().min()\n",
    "max_value = df.max().max()\n",
    "max_scale = max(abs(min_value/1000), abs(max_value/1000))\n",
    "plt.figure(figsize=figure_size)\n",
    "cmap = sns.color_palette(\"coolwarm\", as_cmap=True)\n",
    "ax = sns.heatmap(df/1000, fmt=\".1f\", cmap=cmap, vmin=-max_scale, vmax=max_scale, annot=annot_benefit)\n",
    "# ax.yaxis.set_major_formatter(ticker.FormatStrFormatter('%.1f'))\n",
    "plt.title(title_benefit)\n",
    "plt.gca().invert_yaxis()\n",
    "plt.xlabel('ESS Capacity (MWh)')\n",
    "plt.ylabel('PV Capacity (MW)')\n",
    "plt.savefig('plots/benefit.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x900 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "df = costs\n",
    "df = df.astype(int)\n",
    "df.index = df.index / 1000\n",
    "df.columns = df.columns / 1000\n",
    "\n",
    "plt.figure(figsize=figure_size)\n",
    "sns.heatmap(df/1000000,  fmt=\".1f\", cmap='viridis', annot=annot_cost)\n",
    "plt.title(title_cost)\n",
    "plt.gca().invert_yaxis()\n",
    "plt.xlabel('ESS Capacity (MWh)')\n",
    "plt.ylabel('PV Capacity (MW)')\n",
    "plt.savefig('plots/costs.png')\n",
    "\n",
    "    # pv = pv_config(capacity=100000,cost_per_kW=200,lifetime=25,loss=0.95)\n",
    "    # ess = ess_config(capacity=100000,cost_per_kW=300,lifetime=25,loss=0.95,charge_power=100000,discharge_power=100000)\n",
    "    # grid = grid_config(price_schedule=price_schedule, capacity=5000, grid_loss=0.95, sell_price=0.4)\n",
    "    # grid = grid_config(capacity=50000, grid_loss=0.95, sell_price=0.4)\n",
    "\n",
    "\n",
    "    # print(benefit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x900 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.colors import LinearSegmentedColormap\n",
    "df = overload_cnt\n",
    "df = df.astype(int)\n",
    "df.index = df.index / 1000\n",
    "df.columns = df.columns / 1000\n",
    "min_value = df.min().min()\n",
    "max_value = df.max().max()\n",
    "max_scale = max(abs(min_value/1000), abs(max_value/1000))\n",
    "\n",
    "plt.figure(figsize=figure_size)\n",
    "cmap = LinearSegmentedColormap.from_list(\"\", [\"white\", \"blue\"])\n",
    "ax = sns.heatmap(df/(4*24*365), fmt=\".00%\", cmap=cmap, vmin=0, vmax=1, annot=annot_unmet)\n",
    "cbar = ax.collections[0].colorbar\n",
    "cbar.set_ticks([0, 0.25, 0.5, 0.75, 1])\n",
    "cbar.set_ticklabels(['0%', '25%', '50%', '75%', '100%'])\n",
    "cbar.ax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, pos: f'{x:.0%}'))\n",
    "\n",
    "X, Y = np.meshgrid(np.arange(df.shape[1]), np.arange(df.shape[0]))\n",
    "\n",
    "CS = ax.contour(X, Y, df, levels=np.linspace(df.min().min(), df.max().max(), 20), colors='black', alpha=0.5)\n",
    "\n",
    "ax.clabel(CS, inline=True, fontsize=10)\n",
    "\n",
    "\n",
    "plt.title(title_unmet)\n",
    "plt.gca().invert_yaxis()\n",
    "plt.xlabel('ESS Capacity (MWh)')\n",
    "plt.ylabel('PV Capacity (MW)')\n",
    "plt.savefig('plots/unmet.png')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}