data_processor_v4.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "44a7d641-fbb9-47d5-a54a-826a597d216f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "dd9cf71b-e692-4c35-864a-428259e8bf7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "from matplotlib.dates import DateFormatter, MonthLocator\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "class CropSiteData:\n",
    "    \"\"\"Process data for latent heat flux comparison between FLUXNET and MODIS dataset\"\"\"\n",
    "    \n",
    "    def __init__(self, FLUXNET_file_path, MODIS_file_path, crop_rotation=None):\n",
    "        \n",
    "        self.FLUXNET_file_path = FLUXNET_file_path\n",
    "        self.MODIS_file_path = MODIS_file_path\n",
    "        \n",
    "        self.crop_rotation = crop_rotation\n",
    "        \n",
    "        self.data_FLUXNET = {}\n",
    "        self.data_MODIS = {}\n",
    "        \n",
    "        self.data = {'yearwise': {}, 'cropwise': {}}\n",
    "        \n",
    "        self._load_FLUXNET_data()\n",
    "        self._load_MODIS_data()\n",
    "        \n",
    "        self._merge_datasets()\n",
    "        self._compute_delta()\n",
    "        \n",
    "        self._sort_for_crop_rotation()\n",
    "        \n",
    "    \n",
    "    def _load_FLUXNET_data(self):\n",
    "        \"\"\"Load latent heat flux data from FLUXNET dataset\"\"\"\n",
    "        \n",
    "        date_list = []\n",
    "        value_list = []\n",
    "        \n",
    "        with open(self.FLUXNET_file_path, 'r', encoding='utf-8') as f:\n",
    "            \n",
    "            first_line = f.readline().split(',')\n",
    "            ts_index = first_line.index('TIMESTAMP')\n",
    "            le_index = first_line.index('LE_F_MDS')\n",
    "            \n",
    "            for line in f:\n",
    "                line = line.split(',')\n",
    "                date = datetime.strptime(line[ts_index], '%Y%m%d')\n",
    "                value = line[le_index]\n",
    "                date_list.append(date)\n",
    "                value_list.append(float(value))\n",
    "                \n",
    "        for year in range(min(date_list).year, max(date_list).year + 1):\n",
    "            self.data_FLUXNET[year] = {'dates':[], 'values':[]}\n",
    "            \n",
    "        for date, value in zip(date_list, value_list):\n",
    "            self.data_FLUXNET[date.year]['dates'].append(date)\n",
    "            self.data_FLUXNET[date.year]['values'].append(value)\n",
    "            \n",
    "            \n",
    "    def _load_MODIS_data(self, pixel_number=145):\n",
    "        \"\"\"Load latent heat flux data from MODIS dataset\"\"\"\n",
    "        \n",
    "        date_list = []\n",
    "        value_list = []\n",
    "        \n",
    "        with open(self.MODIS_file_path, 'r', encoding='utf-8') as f:\n",
    "            \n",
    "            for line in f:\n",
    "                line = line.split(',')\n",
    "                date = datetime.strptime(line[2], 'A%Y%j')\n",
    "                value = line[5:][pixel_number - 1]\n",
    "                \n",
    "                if value != 'F':\n",
    "                    date_list.append(date)\n",
    "                    value_list.append((float(value) / (60*60*24)))\n",
    "                    \n",
    "        for year in range(min(date_list).year, max(date_list).year + 1):\n",
    "            self.data_MODIS[year] = {'dates':[], 'values':[]}\n",
    "            \n",
    "        for date, value in zip(date_list, value_list):\n",
    "            self.data_MODIS[date.year]['dates'].append(date)\n",
    "            self.data_MODIS[date.year]['values'].append(value)\n",
    "            \n",
    "            \n",
    "    def _merge_datasets(self):\n",
    "        \"\"\"Merge datasets into one dataset with only shared values\"\"\"\n",
    "        \n",
    "        for year in range(1990, 2030):\n",
    "            if year in self.data_FLUXNET.keys() and year in self.data_MODIS.keys():\n",
    "                self.data['yearwise'][year] = {'dates':[], 'values':{'FLUXNET':[], 'MODIS':[]}}\n",
    "        \n",
    "        for year in self.data['yearwise'].keys():\n",
    "            \n",
    "            for date, value in zip(self.data_MODIS[year]['dates'], self.data_MODIS[year]['values']):\n",
    "                if date in self.data_FLUXNET[year]['dates']:\n",
    "                    self.data['yearwise'][year]['dates'].append(date)\n",
    "                    self.data['yearwise'][year]['values']['MODIS'].append(value)\n",
    "            \n",
    "            for date, value in zip(self.data_FLUXNET[year]['dates'], self.data_FLUXNET[year]['values']):\n",
    "                if date in self.data_MODIS[year]['dates']:\n",
    "                    # Create 8-day composite period for FLUXNET based on daily data\n",
    "                    first_day_index = self.data_FLUXNET[year]['dates'].index(date)\n",
    "                    last_day_index = self.data_FLUXNET[year]['dates'].index(date) + 8\n",
    "                    eight_day_range = self.data_FLUXNET[year]['values'][first_day_index:last_day_index]\n",
    "                    eight_day_sum = sum(eight_day_range)\n",
    "                    eight_day_average = eight_day_sum / len(eight_day_range)\n",
    "                    self.data['yearwise'][year]['values']['FLUXNET'].append(eight_day_average)\n",
    "                    \n",
    "                    \n",
    "    def _sort_for_crop_rotation(self):\n",
    "        \"\"\"Add data sorted according to crop rotation to dataset\"\"\"\n",
    "        \n",
    "        for item in self.crop_rotation:\n",
    "            if item[1][0] != '' and item[1][1] != '':\n",
    "                if item[0] not in self.data['cropwise'].keys():\n",
    "                    self.data['cropwise'][item[0]] = {}\n",
    "                sow_date = datetime.strptime(item[1][0], '%d.%m.%Y')\n",
    "                har_date = datetime.strptime(item[1][1], '%d.%m.%Y')\n",
    "                sow_year = datetime.strptime(item[1][0], '%d.%m.%Y').year\n",
    "                har_year = datetime.strptime(item[1][1], '%d.%m.%Y').year\n",
    "                \n",
    "                if sow_year != har_year:\n",
    "                \n",
    "                    if sow_year in self.data['yearwise'].keys() and har_year in self.data['yearwise'].keys():\n",
    "\n",
    "                        self.data['cropwise'][item[0]][sow_year] = {'dates':[],\n",
    "                                                                    'values':{'FLUXNET':[], 'MODIS':[]},\n",
    "                                                                    'deltas_abs':{'FLUXNET':[], 'MODIS':[]},\n",
    "                                                                    'deltas_rel':{'FLUXNET':[], 'MODIS':[]}}\n",
    "                        for date, value_f, value_m,\\\n",
    "                        delta_abs_f, delta_abs_m,\\\n",
    "                        delta_rel_f, delta_rel_m in zip(self.data['yearwise'][sow_year]['dates'],\n",
    "                                                        self.data['yearwise'][sow_year]['values']['FLUXNET'],\n",
    "                                                        self.data['yearwise'][sow_year]['values']['MODIS'],\n",
    "                                                        self.data['yearwise'][sow_year]['deltas_abs']['FLUXNET'],\n",
    "                                                        self.data['yearwise'][sow_year]['deltas_abs']['MODIS'],\n",
    "                                                        self.data['yearwise'][sow_year]['deltas_rel']['FLUXNET'],\n",
    "                                                        self.data['yearwise'][sow_year]['deltas_rel']['MODIS']):\n",
    "                            if date >= sow_date:\n",
    "                                self.data['cropwise'][item[0]][sow_year]['dates'].append(date)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['values']['FLUXNET'].append(value_f)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['values']['MODIS'].append(value_m)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['deltas_abs']['FLUXNET'].append(delta_abs_f)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['deltas_abs']['MODIS'].append(delta_abs_m)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['deltas_rel']['FLUXNET'].append(delta_rel_f)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['deltas_rel']['MODIS'].append(delta_rel_m)\n",
    "\n",
    "                        for date, value_f, value_m,\\\n",
    "                        delta_abs_f, delta_abs_m,\\\n",
    "                        delta_rel_f, delta_rel_m in zip(self.data['yearwise'][har_year]['dates'],\n",
    "                                                        self.data['yearwise'][har_year]['values']['FLUXNET'],\n",
    "                                                        self.data['yearwise'][har_year]['values']['MODIS'],\n",
    "                                                        self.data['yearwise'][har_year]['deltas_abs']['FLUXNET'],\n",
    "                                                        self.data['yearwise'][har_year]['deltas_abs']['MODIS'],\n",
    "                                                        self.data['yearwise'][har_year]['deltas_rel']['FLUXNET'],\n",
    "                                                        self.data['yearwise'][har_year]['deltas_rel']['MODIS']):\n",
    "                            if date < har_date:\n",
    "                                self.data['cropwise'][item[0]][sow_year]['dates'].append(date)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['values']['FLUXNET'].append(value_f)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['values']['MODIS'].append(value_m)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['deltas_abs']['FLUXNET'].append(delta_abs_f)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['deltas_abs']['MODIS'].append(delta_abs_m)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['deltas_rel']['FLUXNET'].append(delta_rel_f)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['deltas_rel']['MODIS'].append(delta_rel_m)\n",
    "\n",
    "                        self.data['cropwise'][item[0]][sow_year]['period'] = (sow_date, har_date)\n",
    "                        \n",
    "                else:\n",
    "                    \n",
    "                    if sow_year in self.data['yearwise'].keys():\n",
    "\n",
    "                        self.data['cropwise'][item[0]][sow_year] = {'dates':[],\n",
    "                                                                    'values':{'FLUXNET':[], 'MODIS':[]},\n",
    "                                                                    'deltas_abs':{'FLUXNET':[], 'MODIS':[]},\n",
    "                                                                    'deltas_rel':{'FLUXNET':[], 'MODIS':[]}}\n",
    "                        for date, value_f, value_m,\\\n",
    "                        delta_abs_f, delta_abs_m,\\\n",
    "                        delta_rel_f, delta_rel_m in zip(self.data['yearwise'][sow_year]['dates'],\n",
    "                                                        self.data['yearwise'][sow_year]['values']['FLUXNET'],\n",
    "                                                        self.data['yearwise'][sow_year]['values']['MODIS'],\n",
    "                                                        self.data['yearwise'][sow_year]['deltas_abs']['FLUXNET'],\n",
    "                                                        self.data['yearwise'][sow_year]['deltas_abs']['MODIS'],\n",
    "                                                        self.data['yearwise'][sow_year]['deltas_rel']['FLUXNET'],\n",
    "                                                        self.data['yearwise'][sow_year]['deltas_rel']['MODIS']):\n",
    "                            if date >= sow_date and date < har_date:\n",
    "                                self.data['cropwise'][item[0]][sow_year]['dates'].append(date)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['values']['FLUXNET'].append(value_f)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['values']['MODIS'].append(value_m)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['deltas_abs']['FLUXNET'].append(delta_abs_f)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['deltas_abs']['MODIS'].append(delta_abs_m)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['deltas_rel']['FLUXNET'].append(delta_rel_f)\n",
    "                                self.data['cropwise'][item[0]][sow_year]['deltas_rel']['MODIS'].append(delta_rel_m)\n",
    "                                \n",
    "                        self.data['cropwise'][item[0]][sow_year]['period'] = (sow_date, har_date)\n",
    "                            \n",
    "                    \n",
    "    def _compute_delta(self):\n",
    "        \"\"\"Compute absolute and relative deltas between datasets\"\"\"\n",
    "        \n",
    "        for year in self.data['yearwise'].keys():\n",
    "            self.data['yearwise'][year]['deltas_abs'] = {'FLUXNET':[], 'MODIS':[]}\n",
    "            self.data['yearwise'][year]['deltas_rel'] = {'FLUXNET':[], 'MODIS':[]}\n",
    "            for f_value, m_value in zip(self.data['yearwise'][year]['values']['FLUXNET'], self.data['yearwise'][year]['values']['MODIS']):\n",
    "                f_delta_abs = f_value - m_value\n",
    "                m_delta_abs = m_value - f_value\n",
    "                f_delta_rel = f_delta_abs / m_value\n",
    "                m_delta_rel = m_delta_abs / f_value\n",
    "                self.data['yearwise'][year]['deltas_abs']['FLUXNET'].append(f_delta_abs)\n",
    "                self.data['yearwise'][year]['deltas_abs']['MODIS'].append(m_delta_abs)\n",
    "                self.data['yearwise'][year]['deltas_rel']['FLUXNET'].append(f_delta_rel)\n",
    "                self.data['yearwise'][year]['deltas_rel']['MODIS'].append(m_delta_rel)\n",
    "                \n",
    "            \n",
    "    def plot_values(self, *years, crop_type=None):\n",
    "        \"\"\"Plot latent heat flux data from FLUXNET and MODIS given any number of available years\"\"\"\n",
    "        \n",
    "        if crop_type == None:\n",
    "            for year in years:\n",
    "                if year not in self.data['yearwise'].keys():\n",
    "                    raise ValueError(f\"Make sure all specified years are available in the dataset ({list(self.data['yearwise'].keys())})\")\n",
    "                    \n",
    "        elif type(crop_type) == str:\n",
    "            if crop_type not in self.data['cropwise'].keys():\n",
    "                raise ValueError(f\"Make sure the specified crop type is available in the dataset ({list(self.data['cropwise'].keys())})\")\n",
    "            for year in years:\n",
    "                if year not in self.data['cropwise'][crop_type].keys():\n",
    "                    raise ValueError(f\"Make sure all specified years are available in the dataset ({list(self.data['cropwise'][crop_type].keys())})\")\n",
    "                    \n",
    "        else:\n",
    "            raise ValueError('Crop type must be specified as a string')\n",
    "        \n",
    "        fig, axs = plt.subplots(len(years), 1, figsize=(10, 5*len(years)))\n",
    "                   \n",
    "        for count, year in enumerate(years):\n",
    "            if crop_type == None:\n",
    "                x = self.data['yearwise'][year]['dates']\n",
    "\n",
    "                y_f = self.data['yearwise'][year]['values']['FLUXNET']\n",
    "                y_m = self.data['yearwise'][year]['values']['MODIS']\n",
    "                \n",
    "            elif type(crop_type) == str:\n",
    "                x = self.data['cropwise'][crop_type][year]['dates']\n",
    "\n",
    "                y_f = self.data['cropwise'][crop_type][year]['values']['FLUXNET']\n",
    "                y_m = self.data['cropwise'][crop_type][year]['values']['MODIS']                \n",
    "            \n",
    "            if len(years) > 1:\n",
    "                axs[count].plot(x, y_f, label='FLUXNET', color='tab:orange')\n",
    "                axs[count].plot(x, y_m, label='MODIS', color='tab:blue')\n",
    "                \n",
    "                if crop_type == None:\n",
    "                    axs[count].set_xlim([datetime.strptime('1.1.'+str(year), '%d.%m.%Y'),\n",
    "                                         datetime.strptime('31.12.'+str(year), '%d.%m.%Y')])\n",
    "                    axs[count].set_title(f'Year: {year}')\n",
    "                else:\n",
    "                    (sow, har) = self.data['cropwise'][crop_type][year]['period']\n",
    "                    axs[count].set_xlim([sow, har])\n",
    "                    axs[count].set_title(f\"{crop_type} Season: {sow.strftime('%d.%m.%Y')} – {har.strftime('%d.%m.%Y')}\")\n",
    "                    axs[count].axvline(x=datetime.strptime('01.01.'+str(year+1), '%d.%m.%Y'), color='lightgrey', linestyle='--')\n",
    "                    \n",
    "                axs[count].set_ylim(0, 200)\n",
    "                axs[count].set_ylabel('Latent Heat Flux [W m-2]')\n",
    "                axs[count].xaxis.set_major_locator(MonthLocator())\n",
    "                axs[count].xaxis.set_major_formatter(DateFormatter('%b'))\n",
    "                axs[count].legend()\n",
    "                \n",
    "            else:\n",
    "                axs.plot(x, y_f, label='FLUXNET', color='tab:orange')\n",
    "                axs.plot(x, y_m, label='MODIS', color='tab:blue')\n",
    "                \n",
    "                if crop_type == None:\n",
    "                    axs.set_xlim([datetime.strptime('1.1.'+str(year), '%d.%m.%Y'),\n",
    "                                  datetime.strptime('31.12.'+str(year), '%d.%m.%Y')])\n",
    "                    axs.set_title(f'Year: {year}')\n",
    "                else:\n",
    "                    (sow, har) = self.data['cropwise'][crop_type][year]['period']\n",
    "                    axs.set_xlim([sow, har])\n",
    "                    axs.set_title(f\"{crop_type} Season: {sow.strftime('%d.%m.%Y')} – {har.strftime('%d.%m.%Y')}\")\n",
    "                    axs.axvline(x=datetime.strptime('01.01.'+str(year+1), '%d.%m.%Y'), color='lightgrey', linestyle='--')\n",
    "                                       \n",
    "                    \n",
    "                axs.set_ylim(0, 200)\n",
    "                axs.set_ylabel('Latent Heat Flux [W m-2]')\n",
    "                axs.xaxis.set_major_locator(MonthLocator())\n",
    "                axs.xaxis.set_major_formatter(DateFormatter('%b'))\n",
    "                axs.legend()\n",
    "        \n",
    "        plt.show()\n",
    "        \n",
    "        \n",
    "    def plot_deltas(self, *years, crop_type=None, mode='rel', base='FLUXNET'):\n",
    "        \"\"\"Plot delta of latent heat flux data from FLUXNET and MODIS given any number of available years\"\"\"\n",
    "        \n",
    "        if mode == 'abs':\n",
    "            delta_type = 'deltas_abs'\n",
    "            ylabel = 'Absolute Difference in Latent Heat Flux [W m-2]'\n",
    "            ylim = (-100, 100)\n",
    "        elif mode == 'rel':\n",
    "            delta_type = 'deltas_rel'\n",
    "            ylabel = 'Relative Difference in Latent Heat Flux [%]'\n",
    "            ylim = (-200, 200)\n",
    "        else:\n",
    "            raise ValueError('Mode not valid')\n",
    "        \n",
    "        if crop_type == None:\n",
    "            for year in years:\n",
    "                if year not in self.data['yearwise'].keys():\n",
    "                    raise ValueError(f\"Make sure all specified years are available in the dataset ({list(self.data['yearwise'].keys())})\")\n",
    "                    \n",
    "        elif type(crop_type) == str:\n",
    "            if crop_type not in self.data['cropwise'].keys():\n",
    "                raise ValueError(f\"Make sure the specified crop type is available in the dataset ({list(self.data['cropwise'].keys())})\")\n",
    "            for year in years:\n",
    "                if year not in self.data['cropwise'][crop_type].keys():\n",
    "                    raise ValueError(f\"Make sure all specified years are available in the dataset ({list(self.data['cropwise'][crop_type].keys())})\")\n",
    "        \n",
    "        fig, axs = plt.subplots(len(years), 1, figsize=(10, 5*len(years)))\n",
    "                   \n",
    "        for count, year in enumerate(years):            \n",
    "            if crop_type == None:\n",
    "                x = self.data['yearwise'][year]['dates']\n",
    "                y = np.array(self.data['yearwise'][year][delta_type][base])\n",
    "                \n",
    "            elif type(crop_type) == str:\n",
    "                x = self.data['cropwise'][crop_type][year]['dates']\n",
    "                y = np.array(self.data['cropwise'][crop_type][year][delta_type][base])\n",
    "            \n",
    "            if mode == 'rel':\n",
    "                y = y*100\n",
    "            \n",
    "            if len(years) > 1:\n",
    "                axs[count].bar(x, y, width=8, color=np.where(np.array(y)>0, 'c', 'm'))\n",
    "                \n",
    "                if crop_type == None:\n",
    "                    axs[count].set_xlim([datetime.strptime('1.1.'+str(year), '%d.%m.%Y'),\n",
    "                                         datetime.strptime('31.12.'+str(year), '%d.%m.%Y')])\n",
    "                    axs[count].set_title(f'Year: {year}')\n",
    "                else:\n",
    "                    (sow, har) = self.data['cropwise'][crop_type][year]['period']\n",
    "                    axs[count].set_xlim([sow, har])\n",
    "                    axs[count].set_title(f\"{crop_type} Season: {sow.strftime('%d.%m.%Y')} – {har.strftime('%d.%m.%Y')}\")\n",
    "                    axs[count].axvline(x=datetime.strptime('01.01.'+str(year+1), '%d.%m.%Y'), color='lightgrey', linestyle='--')\n",
    "                    \n",
    "                axs[count].set_ylim(ylim)\n",
    "                axs[count].set_ylabel(ylabel)\n",
    "                axs[count].xaxis.set_major_locator(MonthLocator())\n",
    "                axs[count].xaxis.set_major_formatter(DateFormatter('%b'))\n",
    "                \n",
    "            else:\n",
    "                axs.bar(x, y, width=8, color=np.where(np.array(y)>0, 'c', 'm'))\n",
    "                \n",
    "                if crop_type == None:\n",
    "                    axs.set_xlim([datetime.strptime('1.1.'+str(year), '%d.%m.%Y'),\n",
    "                                  datetime.strptime('31.12.'+str(year), '%d.%m.%Y')])\n",
    "                    axs.set_title(f'Year: {year}')\n",
    "                else:\n",
    "                    (sow, har) = self.data['cropwise'][crop_type][year]['period']\n",
    "                    axs.set_xlim([sow, har])\n",
    "                    axs.set_title(f\"{crop_type} Season: {sow.strftime('%d.%m.%Y')} – {har.strftime('%d.%m.%Y')}\")\n",
    "                    axs.axvline(x=datetime.strptime('01.01.'+str(year+1), '%d.%m.%Y'), color='lightgrey', linestyle='--')\n",
    "                \n",
    "                axs.set_ylim(ylim)\n",
    "                axs.set_ylabel(ylabel)\n",
    "                axs.xaxis.set_major_locator(MonthLocator())\n",
    "                axs.xaxis.set_major_formatter(DateFormatter('%b'))\n",
    "\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b5ff9ec5-2ccf-408f-98b5-1df96f2d5d26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Years available: [2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014]\n",
      "\n",
      "Winter Wheat – years available: [2006, 2008, 2010, 2013]\n",
      "Winter Barley – years available: [2004, 2011]\n",
      "Winter Rapeseed – years available: [2007, 2012]\n",
      "Peas – years available: [2010]\n"
     ]
    }
   ],
   "source": [
    "# Oensingen data\n",
    "\n",
    "crop_rotation = [\n",
    "    ['Winter Wheat', ['16.10.2003','04.08.2004']],\n",
    "    ['Winter Barley', ['29.09.2004','14.07.2005']],\n",
    "    ['Cover crop', ['09.08.2005','']],\n",
    "    ['Potato', ['05.05.2006','']],\n",
    "    ['Winter Wheat', ['19.10.2006','15.07.2007']],\n",
    "    ['Winter Rapeseed', ['28.08.2007','16.07.2008']],\n",
    "    ['Winter Wheat', ['07.10.2008','21.07.2009']],\n",
    "    ['Cover crop', ['12.08.2009','']],\n",
    "    ['Peas', ['09.05.2010','19.07.2010']],\n",
    "    ['Winter Wheat', ['15.10.2010','02.08.2011']],\n",
    "    ['Winter Barley', ['24.09.2011','09.07.2012']],\n",
    "    ['Winter Rapeseed', ['04.09.2012','28.07.2013']],\n",
    "    ['Winter Wheat', ['19.10.2013','24.07.2014']],\n",
    "    ['Winter Barley', ['29.09.2014','04.07.2015']],\n",
    "    ['Cover crop', ['03.08.2015','']],\n",
    "    ['Peas', ['09.05.2016','25.07.2016']],\n",
    "    ['Winter Wheat', ['12.10.2016','19.07.2017']],\n",
    "    ['Winter Rapeseed', ['30.08.2017','12.07.2018']],\n",
    "    ['Winter Wheat', ['11.10.2018','19.07.2019']],\n",
    "    ['Winter Barley', ['04.10.2019','']]\n",
    "]\n",
    "\n",
    "FLUXNET_file_path = 'data/Oensingen_FLUXNET/FLX_CH-Oe2_FLUXNET2015_FULLSET_DD_2004-2014_1-4.csv'\n",
    "MODIS_file_path = 'data/Oensingen_MODIS/LE_500m_filtered_scaled.csv'\n",
    "\n",
    "oensingen = CropSiteData(FLUXNET_file_path, MODIS_file_path, crop_rotation)\n",
    "    \n",
    "print(f\"Years available: {list(oensingen.data['yearwise'].keys())}\")\n",
    "print()\n",
    "for key, value in oensingen.data['cropwise'].items():\n",
    "    print(f\"{key} – years available: {list(value.keys())}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2ccfe8b7-b77c-4d27-abf8-af0f7c0db240",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmQAAAJOCAYAAAAZJhvsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAADKY0lEQVR4nOzdd3gUVffA8e9Jb4TeAwYQkB4hoGJDRUREsYJYEBv6KnZs6Puzd+z6qtgroih2RVAQVARDr0qH0Ak1hdTz+2MmsAkpS7KbTTmf59knu3dm7pzZlD259869oqoYY4wxxpjACQp0AMYYY4wxNZ0lZMYYY4wxAWYJmTHGGGNMgFlCZowxxhgTYJaQGWOMMcYEmCVkxhhjjDEBZgmZMYCInCgi/wQ6Dm+JyHAR+T3QcRhjjPENS8hMtSQi94rIj4XKVhRTdrGqzlDV9l7W3UdEkn0c7z8iMsTj9fEiokWU7ROREF+eu4hY1opI31L2GS0ia0QkVUSSRWS8P2PyJxEJF5F3RGSviGwRkds9tl3qXmP+I939vvQopq6RIpIkIpki8l4R208TkeVuPVNF5Ihi6mkkIuNEZJOI7BGRP0TkmEL7XCIi60QkTUS+EpF6HtvqichEd9s6Ebmk0LE3ud+/vW68Jxzm21Y43nAReds91z4RmS8iZ3psDxORCe7PlopIn1LqKzZ+92fP83uSISJ5ItKgiHr89j6K4z4RWe++j5+KSGzZ3kFjLCEz1dd0oLeIBAOISFMgFDi6UNmR7r4VppiEajpwksfrk4DlRZTNVNUcP4ZXKhG5Argc6KuqMUAi8EsgYyqnB4G2wBHAKcBdItIfQFU/VtWY/AdwA7AamFtMXZuAR4F3Cm9wE4Yvgf8C9YAkoLhENgb4G+jh7vs+8L2IxLh1dQLewPk+NAbSgf95HP8qkOVuuxR4zT0GNyF5ErgQqA28DUzM/70ooxBgA3CyW+f9wGciEu+xz+/AZcAWL+orNn5VfbzQ9+QpYJqq7iiiHr+9j8Aw97jjgWZAJPCyF9dmTNFU1R72qHYPIAznj2sP9/Vg4F3gt0JlK93nfYBkj+PXAqOAhcAenA/OCCAayADygFT30Qznn5t7gFVACvAZUM+tKx5Q4GpgPTC9iHgvBxZ5vP4BGF5E2f3u8+E4H3BjgF3AGuBMj33zP2g3AxtxkoRgd1sb4Fc3zh3Ax0Add9uH7rVluNd2VxGxvgK8UMJ7X6Zzu9vvdo/ZB/wDnOaWhwMv4CQ8m9zn4Z7fO+AOYJt73isP42dlE9DP4/UjwKfF7DsVeMCLOh8F3itUNgL40+N1/s/SUV7GuZeDP7uPA594bGuDkzjUcuvNAtp5bP8QeNJ9PgSYXSgOBZr6+HdwIXBBEeXJQJ8Sjisx/kL7Ck6CfMVhxOWr93ECcKfHtt7AfiDKl++jPWrOw1rITLWkqlnALA62MJ0EzMBJYjzLSmodGwz0B1oBXYHhqpoGnAls0oP/pW8CbgLOxWkhaIaTJL1aqL6TgQ7AGUWcazrQye0iCcJpdRoP1PEoO75QvMfgJC0NgKeBt0VE3G3vATk4LYBHA/2Aa9xtAjzhxtkBaIHTSoSqXo6TNJ7tXtvTRcT6FzBMRO4UkcQiWlbKdG4RaQ+MBHqqai33fVrrHncfcCyQAHQDeuG0wuRrgpMINsdJfF8VkbpuvZeIyMIirgN3n6bAAo/iBUCnIvY9Audn5oOi6vJCJ8/zuD9Lq4o6VxHnTsD5J2NlMXWtwk0e3EeOqv7rUYXnNf0IBIvIMe737ipgPt61XHlFRBq7cSwpw+Glxe/pRKAR8IWXcSXgu/cRnJ9nz+fhOK2txhw2S8hMdfYbB5OvE3ESshmFyn4r4fiXVHWTqu4EvsVJBopzPXCfqiaraiZOknFhoe7JB1U1TVUzCh+squtwEqETcRKOFe5+f3iUheEkmfnWqeqbqpqL0xXTFGjsfhgOAG51z7cNeB642D3XSlWdrKqZqrodeA4nWfSKqn6Ek4CegfP+bRORu+HAB3FZz52L84HWUURCVXWt+wEJTnfRw6q6zT3uIZxWxXzZ7vZsVf0Bp3WvvXvOT1S1azGXE+N+3eNRtgenhaSwYcAMVV1T6ptU/Ln2FCor7lwHuOOSPgQeUtX840uqKwanFai48+zDSWB+BzKBB4ARquqThY1FJBSn5fN9VV1ehipKi9/TFcAEVU31Ii5fv48/AdeISLyI1MZp3QWIKi0WY4ri18HBxgTYdOBGd5BuQ1VdISJbgffdss6U3ELm2WKQjtOqU5wjcMbh5HmU5eKMPcm3wYt4T8JJzGa4Zb97lM12k71D4lPVdLdxLAZnrEwosPlggxlB+ed3k6YXcRK9Wu62XaXEVoCqfgx87H74nus+n+/WU6Zzq+pKEbkVJ5ntJCKTgNvdFshmwDqPENZR8PuRogXH1qVzMNkqSf4HeSxOd1P+831F7DsMp4urrFLduj0Vdy4ARCQS55+Bv1T1CS/ryivlPFcDV+K09KzEacH8TkSOdt9rz/P3Bb4qVNeLqnpfMfEG4SQ9WTitnWXh1fskIlHARcCg0ir00/v4Dk4L7zScz9JngbNxumSNOWzWQmaqs5k43VjX4rQ0oap7ccYMXYvT7ViW1o6iWhI24IzhquPxiFDVjaUc5yk/IctvzYODLXon4v3NBxtwWj4aeMQSq6r5XS2Pu7F0UdVYnIHWnl0vXreUuC1Sn+OMF+pc3nO7rVkn4CS4ijNgG5zvmecdiS3dsnJR1V04Y866eRR3o1BXm4jkD9yeUI7TLfE8j4hE44xZKrJbT0TCcZKhZOC6UupqjdO6+K/7CBERz64zz2tKAL5T1X9VNU9Vf8J5D3oXjkFVp3h0zec/ikvGBGfsYGOcsWPZRb4LpSst/nznATtxEqJi+et9dN+7B1Q1XlXj3PKN7sOYw2YJmam23C6/JOB2DiY44LQ63U7Z767cCtR3uynyvQ485o4zQkQaikip/7kXMh1nzNVJuAkksAhnDNsp3sarqpuBn4FnRSRWRIJEpI2I5HcN1sJpGdgjIs2BO4u4vtbF1S/OHGhniUgtt+4zcVpbZpXn3CLSXkROdT9A93Pw5gmAccD97vvaAPg/4CNv3g8vfODWXVdEjsJJ1t8rtM8VwBeqWmxrlnsNISISAQTjjNOK8Oi2ngh0FpEL3H3+D1hYVLee2/I4Aec9uEJV8wrt8jFwtjjz50UDDwNfquo+d2zal8DDIhLtJpODcFquwLnr8CwRaS2O03HGSy0u5X0qzWs44wLPLqpbXpypMSLcl2HueyOF9/Mi/nxXAB+U1NXqz/fRHdvZxn0PO+J0vz9cxDmM8Y43I//tYY+q+sAZQK5Ad4+ywW7ZdR5lfTj0Lsu+Hq8fBD7yeP0Ozp2Cuzl4l+XtOIPs9+EM1n7c3TfePV+IF/FuxvmQ9iz7AWeMVLRH2XDg90L7KXCk+7w2zgdkMs64l3nAxe62TsAcnMRoPs7diZ7XPgini3Q3MKqIGM/HSRh34YyxWYRzwwPlOTfOjROz3fdvJ/Ad0MzdFgG85L4/m93nEUV97wp//3DGny0p4T0Pd7+fe3GS0dsLbY9w34vTijh2NPBjoZ8TLfR40GN7X5zpTDJwWnbiPba9DrzuPj/ZPTadg3fzpgIneux/ift9SgO+xr2r191WD6dVKM3d5xKPbYKTeKx33+tlwOXl/D3Lb9HcXyjeSwt9Twq/N/HFvI/Fxu9ub45740gRsVTU+9gO5/c9HacL/fayvHf2sEf+Q1R9Mo7TGGOMMcaUkXVZGmOMMcYEmN8SMhFpIc7SIEtFZImI3OKW1xORyeIsWTPZY64gEZGXRGSliCwUke7+is0YY4wxpjLxZwtZDnCHqnbEmdDxRnfg4z3AL6raFme5lXvc/c/EmVCvLc6M1q/5MTZjjDHGmErDbwmZqm5W1bnu8/yBo81xBgy/7+72Ps4cRrjlH6jjL5wZypv6Kz5jjDHGmMqiQiaGFWeB2aNxZhlvrM6t8eBMbJk/cWZzCk6cmeyWbfYoQ0RG4LSgER0d3eOoo47yX+DGlFFOjjNHaUiIzb1sjDHGMWfOnB2q2rCobX7/tBCRGJxlOm5V1b2e086oqorIYd3mqapjgbEAiYmJmpSU5MtwjTHGGGP8QkTWFbfNr3dZupPyfQF8rKpfusVb87si3a/b3PKNOMtQ5IvDZjw2VVReXh55eTY/pDHGGO/48y7L/GU0lqnqcx6bvsGZYRn369ce5cPcuy2PBfZ4dG0aU6WsXbuWtWvXBjoMY4wxVYQ/uyyPBy4HFrmLDoMzG/OTwGcicjXO7MaD3W0/AANwFrtNx1n81hhjjDGm2vNbQqaqv1NwwWJPpxWxvwI3+iseY4wxxngvOzub5ORk9u/fH+hQqpyIiAji4uIIDQ31+hi7BcwYY4wxh0hOTqZWrVrEx8dTxDrwphiqSkpKCsnJybRq1crr42zpJGOMMcYcYv/+/dSvX9+SscMkItSvX/+wWxathcwYP6hbt26gQzDGmHKzZKxsyvK+WUJmjB9YQmaMMeZwWJelMX6Qk5NzYLZ+Y4wxZRMcHExCQsKBx9q1a5k2bRoDBw4ssN97773HyJEjC5T16dOHpKQk9u3bR5s2bVixYgXg3KzQpUsXZs2aBTitWXfccceB48aMGcODDz4IwIMPPkjz5s0LxDB+/PgDz2NiYmjfvj0JCQkMGzasXNdqLWTG+MH69esBaN26dYAjMcaYqisyMpL58+cXKDvcOR5r1arFE088wciRI5k0aRJjxoyhd+/eHHPMMQCEh4fz5Zdfcu+999KgQYNDjr/tttsYNWpUgbIhQ4YATtI3ZswYEhMTDyumolgLmTHGGGOqtcGDnSlPn376aV5//XWeeOKJA9tCQkIYMWIEzz//fKDCc+II6NmNMcYYU/n9eA9sWeTbOpt0gTOfLHGXjIwMEhISAGjVqhUTJ04s8+lefPFFOnTowNixY6lXr16BbTfeeCNdu3blrrvuOuS4559/no8++ghwxgdPnTq1zDGUxBIyY4wxxlRKRXVZFqW4uxo9y3/66SeaNm3K4sWLD9kvNjaWYcOG8dJLLxEZGVlgW1Fdlv5gCZkxxhhjSlZKS1ag1a9fn127dhUo27lz54ExYZs2beKll15i9uzZnHLKKVx99dV07dq1wP633nor3bt358orA7Nyo40hM8YP6tevT/369QMdhjHG1Ag9e/bkjz/+YMuWLQAkJSWRmZlJixYtAKeVa/To0cTFxfHcc89x44034qzYeFC9evUYPHgwb7/9doXHD5aQGeMXtWvXpnbt2oEOwxhjqqVffvmFuLi4A4/Vq1fz4osvMmDAABISErj11lsZN24cQUFBTJ48mfXr13P11VcDcPbZZ1O3bl0++OCDQ+q944472LFjR4Gy559//pCpN/xBCmeIVUliYqImJSUFOgxjDpGVlQVAWFhYgCMxxpiyWbZsGR06dAh0GFVWUe+fiMxR1SLnyLAWMmP8IDk5meTk5ECHYYwxpoqwhMwYY4wxJsAsITPGGGOMCTBLyIwxxhhjAswSMmOMMcaYALOJYY3xg6IWqDXGGGOKYy1kxvhBbGwssbGxgQ7DGGOqNBHhsssuO/A6JyeHhg0bMnDgwANlX331FV27dqVDhw506dKFr7766sC24cOH06pVK7p160a7du0YNmxYgTvg4+PjD8w79thjj9GpUye6du1KQkICs2bN8v8FerAWMmP8IDMzE4Dw8PAAR2KMMVVXdHQ0ixcvJiMjg8jISCZPnkzz5s0PbF+wYAGjRo1i8uTJtGrVijVr1nD66afTunXrA0sjPfPMM1x44YWoKi+88AKnnnoqixcvLjBP5MyZM/nuu++YO3cu4eHh7Nix48B8khXFWsiM8YONGzeycePGQIdhjDFV3oABA/j+++8BGDduHEOHDj2wbcyYMYwePZpWrVoB0KpVK+69916eeeaZQ+oREW677TaaNGnCjz/+WGDb5s2badCgwYF/ohs0aECzZs38dUlF8lsLmYi8AwwEtqlqZ7dsPNDe3aUOsFtVE0QkHlgG/ONu+0tVr/dXbMYYY4zx3kPfLmHppr0+rbNjs1geOLtTqftdfPHFPPzwwwwcOJCFCxdy1VVXMWPGDACWLFnCqFGjCuyfmJjIq6++Wmx93bt3Z/ny5QwaNOhAWb9+/Xj44Ydp164dffv2ZciQIZx88sllvLKy8WcL2XtAf88CVR2iqgmqmgB8AXzpsXlV/jZLxowxxhgD0LVrV9auXcu4ceMYMGBAuesrasnImJgY5syZw9ixY2nYsCFDhgzhvffeK/e5DoffWshUdbrb8nUIERFgMHCqv85vjDHGGN/wpiXLn8455xxGjRrFtGnTSElJOVDesWNH5syZQ7du3Q6UzZkzh06dio933rx5nHbaaYeUBwcH06dPH/r06UOXLl14//33GT58uE+voySBGtR/IrBVVVd4lLUSkXnAXuB+VZ1R1IEiMgIYAdCyZUu/B2qMMcaYwLrqqquoU6cOXbp0Ydq0aQfKR40axUUXXcSpp55KfHw8a9eu5fHHH2fChAmH1KGqvPzyy2zevJn+/Qt04PHPP/8QFBRE27ZtAZg/fz5HHHGEX6+psEAlZEOBcR6vNwMtVTVFRHoAX4lIJ1U9pMNaVccCYwESExMPbXc0phJo1KhRoEMwxphqIy4ujptvvvmQ8oSEBJ566inOPvtssrOzCQ0N5emnnyYhIeHAPnfeeSePPPII6enpHHvssUydOrXAHZYAqamp3HTTTezevZuQkBCOPPJIxo4d6+/LKkCK6kv1WeVOl+V3+YP63bIQYCPQQ1WTizluGjBKVZNKqj8xMVGTkkrcxRhjjDFlsGzZMjp06BDoMKqsot4/EZmjqolF7R+IaS/6Ass9kzERaSgiwe7z1kBbYHUAYjPGJzIyMsjIyAh0GMYYY6oIvyVkIjIOmAm0F5FkEbna3XQxBbsrAU4CForIfGACcL2q7vRXbMb42+bNm9m8eXOgwzDGGFNF+PMuy6HFlA8vouwLnGkwjDHGGFNJqCrOxAjmcJRlOJjN1G+MMcaYQ0RERJCSklKm5KImU1VSUlKIiIg4rONsLUtjjDHGHCIuLo7k5GS2b98e6FCqnIiICOLi4g7rGEvIjDHGGHOI0NDQA2tEGv+zhMwYP2jSpEmgQzDGGFOFWEJmjB9ERUUFOgRjjDFViA3qN8YP0tPTSU9PD3QYxhhjqghLyIzxgy1btrBly5ZAh2GMMaaKsITMGGOMMSbALCEzxhhjTOlUYfMCyMsLdCTVkiVkxhhjjClZXh78dA+8cRLMfDnQ0VRLlpAZY4wxpng5mfDF1TDrdYisC3+9BjlZgY6q2rGEzBg/aNq0KU2bNg10GMYYUz6Z++CTwbDkS+j7EJz/FuzbDIsnBDqyasfmITPGDyIjIwMdgjHGlE/qdvj4QtiyCAb9D46+1BlH1qgT/PkydBsKtvC4z1gLmTF+kJqaSmpqaqDDMMaYstm1Ft7pB9v/gYs/cZIxcBKw3jfBtqWw8peAhljdWEJmjB9s27aNbdu2BToMY4w5fFsWwdv9IH0nDPsa2vcvuL3zBVCrGfz5YmDiq6YsITPGGGOMY+3v8O4ACAqBqyZBy2MO3SckDI69HtZMh03zKzzE6soSMmOMMcbA0m/gw/OhVlO4+mdodFTx+/YYDmG1nLFkxicsITPGGGNqur/fhs+GQdNucNVPUDuu5P0jakOPK2DJRNi9vmJirOYsITPGGGNqKlWY9iR8fzu07eeMGYuq592xx/7HGeT/12v+jbGGsITMGD9o3rw5zZs3D3QYxhhTvLxc+P4OmPYEdLsELv4YwqK8P752nDPAf877kLHLf3HWEJaQGeMH4eHhhIeHBzoMY4wpWvZ++Hw4JL0Nx98C5/4PgkMPv57eN0F2GiS96/MQaxqbGNYYP9i7dy8AsbGxAY7EGFOt7F4P8z+BkAiIbug8YtyvUQ0gNKL0OvbvgU8vhbUzoN9j0Htk2eNp0gVan+Isq3TcjRBi/4iWld8SMhF5BxgIbFPVzm7Zg8C1wHZ3t9Gq+oO77V7gaiAXuFlVJ/krNmP8bceOHYAlZMYYH8lMhT9ecO5qzNlf/H7hsRDd4GCyFt0AohsdfB5RG6Y8ANuWwXljoduQ8sd2/M3w4Xmw6HM4+rLy11dD+bOF7D3gFeCDQuXPq+oYzwIR6QhcDHQCmgFTRKSdqub6MT5jjDGmcsvLg0WfwZQHnTUkO18Ipz8EEXUgbTuk7XC/boe0bQVf71wNG2ZBegpo3sE6Q6Nh6Hho29c3MbY+BRp3cZdTugSCbDRUWfgtIVPV6SIS7+Xug4BPVTUTWCMiK4FewEx/xWeMMcZUahv+hp/uho1zoFl3uOj9ghO1hsdAvVal15OX6wy6T93mJG31WkOdlr6LM385pYkjYOUUaNfPd3XXIIFIY0eKyEIReUdE6rplzYENHvsku2WHEJERIpIkIknbt28vahdjjDGm6tqTDF9cA2/3hT0b4dzX4Zpfip413xtBwU53ZeOO0LqPb5OxfJ3Ph9jm8OdLvq+7hiixhUxEbveijjRVfcPL870GPAKo+/VZ4CovjwVAVccCYwESExP1cI41xhhjKq2sdCeh+f0Fp4vxxFFwwm1OS1hlFxzqzEv28/2wcS407x7oiKqc0lrI7gRigFolPO7w9mSqulVVc1U1D3gTp1sSYCPQwmPXOLfMmCopLi6OuLhSZro2xhhwJmddNAFe6enMCda+P9yUBKf9t2okY/m6X+HcVGDLKZVJaWPIPlTVh0vaQUSivT2ZiDRV1c3uy/OAxe7zb4BPROQ5nEH9bYHZ3tZrTGUTFhYW6BCMMVXBxjnw4z2QPNtZtuiCN+GI3oGOqmwiYp01Lme+ArsegLrxgY6oSimxhUxV7yqtguL2EZFxOIPy24tIsohcDTwtIotEZCFwCnCbW8cS4DNgKfATcKPdYWmqsj179rBnz55Ah2GMqaz2boaJ18Obp8KutXDOK3Dt1KqbjOU79j8gQbacUhmUepeliByFM8B+lqqmepT3V9WfijtOVYcWUfx2Cfs/BjxWWjzGVAUpKSkA1K5dO8CRGGMqnaR3YdJ9kJftjBE78Q4IrxXoqHwjthl0uQjmfgAn3+39upim5BYyEbkZ+Bq4CVgsIoM8Nj/uz8CMMcaYamf7v/DDKIjrATfOhr4PVp9kLF/vmyA7HZLeCXQkVUppg/qvBXqo6rlAH+C/InKLu038GJcxxhhT/Uwa7UzMeuG73s0hVhU17gRH9oVZbzhrZhqvlJaQBeV3U6rqWpyk7Ex38L0lZMYYY4y3/v0ZVk6Gk+9y5gWrznrf5ExCu+izQEdSZZSWkG0VkYT8F25yNhBoAHTxY1zGGGNM9ZGT5bSO1T8Seo0IdDT+1+pkaNLVmQIjL6/0/U2pCdkwYItngarmqOow4CS/RWVMFdeyZUtatvTDbNjGmKrp7zchZQWc8QSE1IBpcUSg982w419YMSnQ0VQJpU17kayqBRIyERnhbvvDn4EZU5WFhIQQEuK3pWKNMVVJ2g6Y9hQceXrNWuex07lQu4VNFOulsqxleb3PozCmmtm1axe7du0KdBjGmMrg10chOw3OqGGTE+Qvp7TuD0ieE+hoKr2yJGQ2mN+YUlhCZowBYPNCmPOeM26sYbtAR1Pxug+D8Nq26LgXypKQne3zKIwxxpjqRhV+uteZHPXkUhe+qZ7Ca0HilbDsG9i5JtDRVGpeJWQiUkdEbnanu7hLRF4SEUt3jTHGmOIs/RrW/Q6n3g+RdQMdTeAccz1IMPz1v0BHUql520L2AxAPLALmeDyMMcYYU1h2Bvz8X2jcGbpfEehoAiu2KXQdAvM+gvSdgY6m0vL2NrAIVb3dr5EYY4wx1cXMV2DPejj3WwgKDnQ0gdd7JMz/CP5+G06+M9DRVEretpB9KCLXikhTEamX//BrZMZUYfHx8cTHxwc6DGNMIOzdBDOegw7nQCubshOARh2gbT+YbcspFcfbhCwLeAaYycHuyiR/BWVMVRcUFERQUFnumTHGVHlTHoS8XOj3SKAjqVx63wRp22HBuEBHUil5+4lxB3Ckqsaraiv30dqfgRlTlaWkpJCSkhLoMIwxFW3D37BwvNNFVzc+0NFULvEnQtMEpzvXllM6hLcJ2Uog3Z+BGFOd7Nmzhz179gQ6DGNMRcrLg5/uhpgmcIINuz6EiNNKlrIS/v0x0NFUOt4O6k8D5ovIVCAzv1BVb/ZLVMYYY0xVs3A8bJwD570B4TGBjqZy6nguTHnIWU7pqLMCHU2l4m1C9pX7MMYYY0xhmfucsWPNE6HL4EBHU3kFh8BxN8BP9zjduy16BjqiSsOrhExV3/d3IMYYY0yVNeM5SN0CF38MdkNPyY6+HKY96SynNOTDQEdTadhPjTHGGFMeO9fAzFeh68UQlxjoaCq/8BjoeTUs+xZSVgU6mkrDEjJj/KB169a0bm03IhtTI0z+LwSFQN8HAh1J1dFrBASHOomsAUpJyEQkQUSkooIxxhhjqpTVvzktPSfeDrHNAh1N1VGribOc0vyPIW1HoKOpFEprIXsLSBGRySLykIj0E5Fa3lQsIu+IyDYRWexR9oyILBeRhSIyUUTquOXxIpIhIvPdx+tlviJjKoEdO3awY4f9kTGmWsvNgZ/uhTot4biRgY6m6ul9E+Tsh7/fCnQklUKJCZmqJgJxwGM4013cDKwUkQUiUtqy7e8B/QuVTQY6q2pX4F/gXo9tq1Q1wX1cfxjXYEyls3fvXvbu3RvoMIwx/jT3Pdi2BPo9CqERgY6m6mnYHtr1h9ljncXYa7hSx5CparqqTgNeBJ4HXgWiOTTZKnzcdGBnobKfVTXHffkXTrJnjDHGVC0Zu+DXx5zZ5zucE+hoqq7eN0F6Csz/JNCRBFxpY8guEZFXROR34BvgdGARcIIPlk66CvCcqreViMwTkd9E5MQSYhohIkkikrR9+/ZyhmCMMcaUwbSnYP9u6P+EMwO9KZsjjodm3Z3B/Xm5gY4moEprIXsDOBan+/E/qnqPqk5U1S3lOamI3AfkAB+7RZuBlqp6NHA78ImIxBZ1rKqOVdVEVU1s2LBhecIwxhhjDt+25U43W/croEmXQEdTteUvp7RzFfzzQ6CjCajSErI6wAggAnhQROaIyHcicp+InFqWE4rIcGAgcKmqKoCqZqpqivt8DrAKaFeW+o2pDIKCggiyySGNqX5UYdJoCIuBU+8PdDTVQ4dzoM4RznJKNVhpg/pzVXWuqr6iqpcAA4CfgCtxBugfFhHpD9wFnKOq6R7lDUUk2H3eGmgLrD7c+o2pLOLj44mPjw90GMYYX1vxM6z6BfrcA9ENAh1N9RAc4tylumEWrJ8V6GgCprQxZF1F5HoR+UBEVgJ/AycALwPHlHLsOGAm0F5EkkXkauAVoBYwudD0FicBC0VkPjABuF5VdxZVrzHGGBMQOVnONBcN2kGvawMdTfVy9KUQWddZTqmGKm0ty/eA33EG39+vquu9rVhVhxZR/HYx+34BfOFt3cZUdtu2bQOgUaNGAY7EGOMzs99wxjpdOsGZZd74Tlg09LwGpo+BHSuhwZGBjqjCldZl2V1Vb1bVcYeTjBlT06WmppKamhroMIwxvpK6HX57Gtr2g7anBzqa6qnXCAgOg5mvBDqSgCity3JsaRV4s48xxhhTpf36CGSnwxmPBzqS6iumEXS7GBaMcxLgGqa0LstzRWR/CdsFOMWH8RhjjDGVy+YFMPcDOO5GaNA20NFUb8eNhLnvw99vwimjC2zatz+bmPAQqusS26UlZHd6UccMXwRijDHGVDqq8OM9EFUPTvLmI9GUS8N20H4AzH4Tjr8VwqIAmL1mJ5e/PYvrTmrN7f3aBzZGPykxIVPV9ysqEGOqk5CQ0v7XMcZUCUsmwvo/YeALEFkn0NHUDL1vciaJnf8x9LqWVdtTufaDJLJy83h9+moG92xBXN2oQEfpczZzpTF+0LJlS1q2bBnoMIwx5ZGdAZP/Dxp3ge7DAh1NzdHyOGieCDNfZcfedIa/O5uQIGHctcciwJhJ/wQ6Qr+whMwYY4wpyp8vw54NcOaTEBQc6GhqDnc5pYydG7l67K9s35fJW1ckcmzr+lx9Qiu+mr+Jhcm7Ax2lz3mVkIlIRBFlNkWxMcXYsmULW7aUa8lXY0wg7UmGGc9Bx0EQf0Kgo6lxctsP5FbuZOEOeHFIAke3rAvAf/q0oX50GI99vwx39cVqw9sWsr9F5Nj8FyJyAfCnf0IypupLT08nPT299B2NMZXTlAdB8+D0RwIdSY302I//MimzE/8N+ZAzaq09UF4rIpRb+7Zl1pqdTFm2LXAB+oG3CdklwMsi8oyIfAxcC5RpcXFjjDGmUls/CxZ9DsffDHWPCHQ0Nc67f6zhnT/WcOWxcVxVa/Yhyyld3KslrRtG88SPy8jOzQtQlL7nVUKmqouAx4DrceYdG6mqyf4MzBhjjKlweXnw091QqxmccFugo6lxJi3ZwsPfLaVfx8bcf05XZ83Qf36AHSsO7BMaHMToMzuwensan86uPosIeTuG7G3gVqArcCXwnYjc6Me4jDHGmIq3YBxsmgd9H3TWV/SD/dm51aplx1fmb9jNLZ/Oo2tcHV68+GiCgwR6XgshEc4NFh5O69CIY1vX4/kpK9i7PztAEfuWt12Wi4BTVHWNqk4CjgG6+y8sY6q20NBQQkNt8WFjqpT9e52xY3E9octFfjlFamYOA16awSVv/kVuXvUalF4eG3amc837f9OwVjhvX5FIZJh7V2tMQ+g2FBZ8CqkHx4yJCPcN6MjOtCxen7YqQFH7lrddli+ox+0MqrpHVa/2X1jGVG0tWrSgRYsWgQ7DGHM4ZjwLadug/1MQ5J9ZoR75dimrt6fx99pdvPP7Gr+co6rZnZ7FFe/OJjtXee/KXjSICS+4w3EjITcLZhdcOrtLXG3OO7o5b/++ho27MyowYv/wtstyjYisLvzwd3DGGGNMhdi5Gv76H3S7BOJ6+OUUPy3ewvikDdzQpw2nd2zMmJ//YdX2VL+cq6rIzMllxIdzSN6ZwdjLe9CmYcyhOzU4Eo46C/5+C7LSCmwadUZ7FHi2GkwW6+2/AIlAT/dxIvAS8JG/gjKmqtu8eTObN28OdBjGGG/9/F8IDoO+D/il+m1793Pvlwvp0rw2t/Ztx2PndiYiNJi7JiyssV2XeXnKnZ8vZPaanTxzUVeOaV2/+J173wQZu5xF3j00rxPJ1Se04st5G1m8cY+fI/Yvb7ssUzweG1X1BeAs/4ZmTNWVkZFBRkbVb0I3pkZYNRWWfwcn3g61mvi8elVl1ISFZGTn8vyQBMJCgmgUG8EDZ3dkzrpdvPtHzey6fHbyP3yzYBN3ntGeQQnNS9655bFwxAnw+/POklYe/tOnDfWiw3j0+6VVerJYb7ssu3s8EkXkekpZmNwYY4yp9HJz4Kd7oc4RcKx/Jg/4YOY6pv+7nfvO6siRjQ52yZ13dHNOO6oRz0z6hzU70kqoofoZN3s9r05dxdBeLbihTxvvDjrlXkjdCknvFCiOdSeL/Wv1Tn5dXnUni/W2y/JZj8cTQA9gsL+CMsYYYyrEnHdh+zI44zEIPWSVwHJbsXUfj/+wjFPaN+SyY1oW2CYiPH5+F8JDgrhrwgLyakjX5bR/tnH/V4s5uV1DHhnUGRHx7sD4E6DVyU4rWaGxZEN7taR1g2ge/2EZOVV0ShFvuyxP8XicrqrXqmrVH0FnjDGm5krfCVMfg1YnwVEDfV59Vk4et3w6n5jwEJ6+sFuRiUfj2Aj+7+xO/L12F+/PXOvzGCqbJZv2cOPHc2nXuBavXtqdkODDvJv1lNGQtt0Z4O8hNDiIe848ilXb0/j07w0+jLjilNjtKCK3l7RdVZ/zbTjGVA/h4eGl72SMCaxpT8L+PdD/SfC2leYwPDf5X5Zu3subwxJpWKv4vwkXdG/O9ws38dRPyzmlfSPiG/hnQtpA27wng6ve+5vYyFDeHd6TmPAyjHxqeSy0OQ1+fwESr4LwWgc2nd6xMb1a1eOFKf8yKKEZtSKq1lyQpaWmtUp5GGOK0Lx5c5o3L2WQqjEmcLYtc1pZelwJjTv5vPq/VqfwxvRVDO3VktM7Ni5x3/yuy9CgIO76YmG17Lrctz+bK9/9m7TMXN4Z3pMmtcvRPXzKaMjYeci8ZCLC/Wd1YEdqFm/8VvVm5ioxPVXVh8pTuYi8AwwEtqlqZ7esHjAeiAfWAoNVdZc4bbkvAgOAdGC4qs4tz/mNMcaYQ6g6A/nDY+CU+3xe/Z6MbO74bAHx9aP578AOXh3TtHYk/x3Ykbu+WMhHs9Yx7Lh4n8cVKNm5edzw8VxWbkvl3St70qFpbPkqjEuEtmfAHy85SytFHKyva1wdzk1oxpszVnPJMS1pVieynNFXnBJbyETkZ4/n95ah/veA/oXK7gF+UdW2wC/ua4AzgbbuYwTwWhnOZ0ylsHHjRjZu3BjoMIwxRfn3J1g9FfqMhugS5r4qowe+XsyWvft5fkgCUWHed8tdlBjHSe0a8uSPy1mfku7zuAJBVblv4iJmrNjB4+d14cS2DX1T8SmjYf9umPX6IZvyJ4sd83PVGupeWpel5zt32At7qep0YGeh4kHA++7z94FzPco/UMdfQB0RaXq45zSmMsjMzCQzMzPQYRhjCsvJhEmjoUF76On7FQC/nr+Rr+Zv4pbT2pLQos5hHSsiPHl+F4JEuOuL6nHX5Su/ruSzpGRuOvVIBvf04XJyzRKcGzH+fAUydhfYFFc3iquOb8XEKjZZbGkJmT9+Ghqrav4U5luA/M715oDnrRHJblkBIjJCRJJEJGn79u1+CM8YY0y1Net1Z5mk/o9DsG8HfW/cncH9Xy2me8s63s+tVUizOpHcf1YH/lq9k49nr/dpfBVt4rxknp38L+cd3ZzbT2/n+xP0uQcy98DMVw/ZdMMpbagTGcpj3y+rMpPFlpaQtRaRb0TkW4/nBx7lPbm7YPlhvVOqOlZVE1U1sWFDHzV9GmOMqf5St8Fvz0C7/nBkX59WnZen3PHZfPLylOeHJBz+dA4ehvRswYltG/DED8vYsLNqdl3OXJXCXRMWcmzrejx1QVfv5xo7HE26QMdB8NdrzhQmHpzJYtsxc3UKU/+pGpPFlvYTMwhnMtgxHs89H2WxNb8r0v2a/05tBDzbM+PcMmOMMab8fnkYcvZDv8d8XvVbv6/mr9U7eeCcThxRv3zTVogIT5zfBQHu+XJhlWnhybdy2z6u+zCJI+pH88ZliYSFlD05LdXJ90BWKvz58iGbLjmmJa0aRPP4D8urxGSxJb5LqvpbSY8ynvMb4Ar3+RXA1x7lw8RxLLDHo2vTmColMjKSyMiqc3ePMdXepnkw7yM45jpocKRPq166aS/PTPqH/p2acFGPOJ/UGVc3itFndeCPlSmMm111Jjrdtm8/V7zzN2Ehwbw7vCe1o/w8F1jjjtD5fJj1BqTtKLApf7LYldtSGZ9U+d9DP6atICLjgJlAexFJFpGrgSeB00VkBdDXfQ3wA7AaWAm8Cdzgz9iM8aemTZvStKndk2JMpaAKP94DUfXh5Lt8WvX+7FxuHT+PulFhPH5+F592zV3SqyW929Tnse+Xkryr/F2Xu9Oz+OivdYz/ez3ZfmgxSs/K4Zr3k9iZlsU7wxNpUS/K5+co0sn3QE4G/PHiIZv6dWxMr/h6PD/5X1IzcyomnjLya0KmqkNVtamqhqpqnKq+raopqnqaqrZV1b6qutPdV1X1RlVto6pdVDXJn7EZY4ypIRZ/ARv+gtP+DyJq+7TqJ39czr9bU3nmom7Uiw7zad0iwlMXdEWBe79cVKauy5zcPKb+s40bP55Lr8d+4f6vFnP3F4s466UZ/LlyR+kVeCk3T7l53DwWb9zDy0OPpmtcHZ/VXaqG7aDLRTD7TWecoAcRYfSByWJXVVxMZeBVQiYih0x5UVSZMcaxYcMGNmyo/E3kxlR7Wekw+QFo0hWOvsynVf/273be+3Mtw3vHc3I7/9xk1qJeFPcO6MCMFTv47DC63VZuS+XJH5dz/FO/cuW7f/Pnqh1cckxLvrvpBN64vAfpWblc8tYsbvh4Trlb31SVh79dwpRl23jwnE70LWVlAr84+W7IzXKWVCokoUUdzunWjLHTV7N6e2rFx+Yl8SbjFpG5qtq9tLKKlpiYqElJ1pBmKp/Vq51lO1q3bh3gSIyp4aY9CdOegCt/hCN6+6zanWlZnPHCdOpEhvLtTScQERrss7oLy8tTLnnrL5Zs3Muk204qdvb5PRnZfLdwExPmJDNv/W6Cg4RT2jfkwh5xnHpU4wKD6/dn5zJ2+mr+N20lAP85+UiuO7l1ma7jrRmrefT7ZVxzQivuH9ixbBfpC1/dCIsnwM3zIbbgkJGte/fT7/nptG4YzefXHVeuu2DLQ0TmqGpiUdtKm6n/TBF5GWguIi95PN4DKndnrDHGmJpt9wanxaTTeT5NxlSV0V8uYnd6Fi9cnODXZAwgKEh4+oJu5OTpIV2XuXnKjBXbuXncPHo9NoX7Ji4mLTOH+wZ0YOa9p/LWFT3p37npIXc6RoQGc/NpbZly+8mcdlRjnp/yL32f+42fFm85rK7RHxdt5rEflnFm5yaMHuDdMlF+c9IoyMuB358/ZFPj2AgeHtSJeet388b0yrnOZWlrOmwCkoBzgDke5fuA2/wVlDHGmBpAFfwxP1W+KQ8ACqc/7NNqP5+TzE9LtjB6wFF0aubbMWnFaVk/invOPIoHvlnC53OS6Rlfjy/mJPPF3GQ279lP7chQhvRswYU94ujSvLbXNxfE1Y3i1Uu7c+nKHTz47RKu/2gOJ7ZtwANnd+TIRrVKPHbOul3cOn4+R7eow/NDEggK8uP30hv1WkHCpTDnXTj+FqhdcG75c7o14+clW3lhyr+c0r4RHZuVc01NH/O2yzJUVbMrIJ7DYl2WprKyLktjSrHuT/h8OHQ4G858GoJ83Mq0bia8298ZW3TKaN9Vm5LGgBdn0DWuDh9fc0yFJiF5ecrFb/7FvPW7yM5VggROateQi3q04LQOjcrdUpeTm8eHf63jucn/kpGVy/De8dzSty21Ig6dumLtjjTOf+1PakWE8OV/elM/Jrxc5/aZ3evhpe7QfRgMfO6QzfldzfWjw/h65PGEh/i3dbOwMndZeogXkQkislREVuc/fBijMdVKVFQUUVEVdMu3MVXNws/gg0GQlwt/vwUTrnTWmPSVvDz46W6o1cxpKfGRnNw8bhs/n6Ag4dnB3Sq8RSgoSBhzYTeOP7IBd/c/ipn3nsZ7V/birK5NfdJtGhIcxJXHt2LqqD5c2COOt/9YwyljfuPzpA0F1tXcmZbFle/9jary3pW9Kk8yBlCnpZOMzf3ASc4KqRcdxlMXdGH5ln28MGVFhYXlTeOXtwnZu8BrOOPGTgE+AD4qc2TGVHNNmjShSZMmgQ7DmMpFFX57Gr68FuJ6wci/4YzHYenX8PGFkLnPN+eZ/zFsXuB0VYaVb9Z8T/+btoq563fz2Hldih1Y728t60fx3pW9+E+fNjSOjfDLORrEhPPkBV356objiasbyZ0TFnLB63+yMHk3+7NzGfFBEht3Z/DmsERaNfDd++szJ97hdIVPf6bIzace1ZghiS1447dVzFm3s8h9fGlh8m6GjP2LHakl/9PhbUIWqaq/4HRxrlPVB4GzyhmjMcaYmiInC766AaY+Bl0vhssnQlQ9OO5GOO8NWPsHvDcQUreX7zz798IvD0GLY6DLhb6JHZi/YTcv/rKCcxOacU63Zj6rtzLr1qIOX/6nN2Mu6saGnRkMevUPznppBknrdvH84AQS4+sFOsSi1W4OPa6EeR87C8kX4f6BHWhaO5I7PltAepb/7lH8Z8s+hr0zm427MsjKKXkyXm8TskwRCQJWiMhIETkPiClvoMZUV+vXr2f9+kOby42pkTJ2wUfnw4JPoM+9cN7rEOIxiWq3i2HoONj+jzPua9e6sp9r+jOQth36P+mzGwbSMnO49dN5NImN4KFBnX1SZ1URFCRc2COOqaNO5poTWrFhZwb3DejAWV0r+UokJ9wGwaEwfUyRm2tFhDLmom6sTUnnyR+X+yWENTvSuPStWYSHBPHJtceU2qrqbUJ2CxAF3Az0AC7j4HqUxphCcnJyyMmxmWGMYddaeLsfrP8LzhsLfe4pOlFqdwYM+8pJpt45A7YuPfxzpayCv15z7rRr7rtpMh/9fhnrdqbz7OBu1I7089qMlVStiFDuO6sjSx4+g2tPqgI3K8U2hcSrYcE45+eiCMe1qc9Vx7fig5nr+H2F71YtAEjelc6lb/5FniofX3OMVwvOe5WQqerfqpoK7FTVK1X1AlX9q7wBG2OMqcaSk+DN05zlbIZ9Bd2GlLx/y2OdCVxV4d0zYf2swzvfz/dDSLizRJKPTF66lXGz13PdSW04tnV9n9VbVYUGaELVMjnhVgiJgN+eKnaXu/q3p03DaO6csIA9Gb6ZTGLr3v1c+tYsUjNz+PDqXqVOH5LP26WTjhORpcBy93U3Eflf2cM1xhhTrS39Gt47C8Jj4JopEH+Cd8c17gRX/+yML/tgEPz7s3fHrfwF/vnBmRy0lm9uqNm2bz93f7GQjk1juf30dj6p01SgmEbQ61pY9LnTHV6EiNBgnhucwLZ9mTz0zZJynzIlNZPL3prFjn2ZvHdVr8Oap87bVPcF4AwgBUBVFwAnHW6gxhhjqjlV+OMl+OwKZ/3Ia36BBm0Pr466R8BVPzuLRn861JkmoyS5OTBpNNRtBcfeUPbYPagqd09YSFpmDi9enHDITPemiuh9C4RGldhK1q1FHW485Ui+nLeRnxZvKfOp9mRkM+yd2azfmc5bV/Ske8u6h3W81z9hqlp4VdPcwzqTMTVITEwMMTF234upYXJz4LvbYPJ/oeMguOIbiG5QtrpiGsIV30HL45xpMv56rfh9k96B7cuh36NOl6UPfDRrPVP/2c7oAR1o29i7LidTCUXXh2Oug8Vfljgu8aZTj6Rz81jum7io1OkpipKWmcPwd2fz79Z9vH55D45rc/jd294mZBtEpDegIhIqIqOAZYd9NmNqiEaNGtGoUaNAh2FMxdm/F8YNcZatOeE2uPBdCC3nXF0RsXDpBGc2/5/ugV8edlrgPKXvdKbSaHUyHOWb2ZhWbkvlse+XcnK7hgw77gif1GkC6LiREBYD0x4/9OfHFRocxHODE9iXmcPoQuuFlmZ/di7XvJ/EwuQ9vDz0aE5pX7a//d4mZNcDNwLNgY1AgvvaGGNMTbcn2RmEv2oqnP0S9H0QgnzUxRcaARe9D92vgBnPwre3ODP855v6OGTu9dk0F1k5edw6fh6RocE8c2FXr9eENJVYVD3ofRMs+xa++g9kpRe5W7vGtRjVrx0/L93Kl3M3elV1Vk4e//loDn+tSWHMRV3p37ns04GUtrg4AKq6A7i0zGcxpoZZu3YtAPHx8QGNwxi/27wAPhkCWWlw2QRoc6rvzxEUDGe/6HR/zngWMnbC+W85k34mve1Mb9C4o09O9eIv/7J4415ev6wHjfw0E74JgJNGAQrTnoTNC2HIh1C/zSG7XX1Ca6Ys3caD3yzhuDb1S5w7LCc3j1s+ncfUf7bz+HldOO/ouHKFWGJCJiIvO1dQNFW9uVxnN6aayssreUZmY6qF5T/AF9c4LRBXTfJZUlQkEWc6i6gGMOleZ6klgPBYny0ePnvNTv43bRVDElvQv7MtfVatBAU7c+A1T4Qvr4GxfeDc16DDwAK7BQcJYy7qRv8Xp3PnhAV8eFXRC8jn5Sl3TVjIj4u3cP9ZHbjkmJblD7GU7UnAHPdxjsfz/IcxxpiaJi8Ppj3l3AHZsJ0zrYU/kzFPx93gTDC7fiasneEkY1HlX8Jn7/5sbhs/n5b1ovi/syvoWkzFa9sXrpsO9Y+E8ZfC5P9zbkbx0LJ+FPed1YE/Vqbw4V+Hrhqhqvz368V8OW8jt5/ejmtOLGWi3DXTYfzlkFPyzQIltpCp6vv5z0XkVs/XxhhjaqD9e2Hi9fDP99BtKAx8vvyD9w9XtyFO9+WKyZB4lU+qfPCbJWzZu5/Prz+O6HCvRvOYqqpOS7jqJ/jpXvjjRUieAxe+A7UaH9jlkl4t+XnJVp74cRkntm1A64bOXfOqyuM/LOPjWeu5/uQ23HTqkcWfZ9M850aUVb9CbBzsXFNiWIcz6tL7Ww6MMcZUPztWwFunwb8/Qf+nnC6fik7G8h15Gpz5pLNeYTl9t3ATX87dyMhTjjzsuaNMFRUSDgOfcxa23zgH3jgJ1s08sFlEeOqCroQFB3HH5wvIyXWGobwwZQVvzljDsOOO4O7+7Yu+6WPHSvh8uNMtumk+nPE43DQHGh1Vcki+uzpjTL7Y2NhAh2CMb/3zkzMfWHAoDPsaWp0Y6Ih8YvOeDO6buJiEFnUYWVJrh6meul0MTbrA+MuclSX6PeJMLixCk9oRPHJuZ275dD5vTF9NSJDw4i8ruLBHHA+e3enQZGzvJmcC2rkfOks2nXy3M+VGhHefB6UN6t/HwZaxKBHZm78JUFU97E8dEWkPjPcoag38H1AHuBbY7paPVtUfDrd+YyqDBg3KOBmmMZVNXh7MGONML9G0Kwz5GOq0CHRUPpGXp4z6fAHZuXk8PyShaq3TaHyncScYMQ2+usFZ8WHDLDjnFYiI5Zxuzfh5yVaem/wvuXnKWV2b8tQFXQsO9E/fCX+8ALPecKZk6XmNc1dnzOHNR1baGDKfT0+sqv/gzGOGiATjzGs2EbgSeF5Vx/j6nMYYY8ogc58zXmz5d9D1Yjj7hcB1UfrBO3+s4Y+VKTx5fhdaNYgOdDgmkCJqw5CP4M+XYcqDzqz+Qz5EGnXgkXM7M3/Dbjo1i+WFIQkE5ydjWWkw63X4/UVnLryuQ+CUe6FufJlCCHSX5WnAKlVdZ5Pvmepk9erVALRuXcrdN8ZUVjtWwqeXQMpKZ9LVY673ycSrlcWyzXt5+qd/6NexMUN6Vo8WP1NOInD8zdC8O3x+Jbx5Kpz9EvW6XsS0O/sQEiRON2VuNsz9wOmeTN0K7c6E0/7rtLSVQ6DbZy8Gxnm8HikiC0XkHREpcmSliIwQkSQRSdq+fXtRuxhjjCmPfyc5H0bpO2DYV3Dsf6pVMrY/O5dbP51P7ahQnrzAZuM3hcSfANfPgKYJzpxlP9xJqOYgqrBoArzSE76/Heq1dubfu+TTcidjAHI46zX5koiEAZuATqq6VUQaAztwxqw9AjRV1RLvZ05MTNSkpCT/B2vMYbIWMlMl5eU5M+FPfcwZ6Hzxx84UAdXMI98t5e3f1/DelT3pU8Z1B00NkJsNvzzkdGM26w552bBlETTuDKc9AG1PP+x/VERkjqomFrXNqxYyEXnKm7LDdCYwV1W3AqjqVlXNVdU84E2gVznrN8YY463MffD5MJj6KHQdDFf/XC2Tsd9X7ODt39dwxXFHWDJmShYcCv0ehcEfOFO+7N8L578J182Adv183mrs7Riy04G7C5WdWUTZ4RiKR3eliDRV1c3uy/OAxeWo2xhjjLdSVjnjxXascOZMcm/7r252p2dxx+fzObJRDPec2SHQ4ZiqouMgaN0HQqN8Mu9dcUqb9uI/wA1AaxFZ6LGpFvBHWU8qItE4Sd51HsVPi0gCTpfl2kLbjKlSateuHegQjPHOiskw4Wpnrb/LJ0LrkwMdkV+oKqMnLmJnWhZvX9GTyLDgQIdkqpII//9NL62F7BPgR+AJ4B6P8n2qurOsJ1XVNKB+obLLy1qfMZVN/fr1S9/JmEBSdcaL/fooNOnszC9W94hAR+U3X87dyA+LtnB3/6Po3Nz+YTKVT2nzkO0B9gBD3TnDGrvHxIhIjKqur4AYjaly8vKcZTaCggJ9I7MxRchMha/+A8u+gS4XwdkvQVhUoKPymw0703ngmyX0alWPESfZjTamcvJqDJmIjAQeBLYCeW6xAl39E5YxVdvatWsBu8vSVEIpq+DTS2HHP9DvMTjuxmo5Xixfbp5y2/j5CPDc4G4HJ/U0ppLxdlD/rUB7VU3xYyzGGGP8acUU+OIqkPzxYn0CHZHfvf7bKpLW7eKFIQnE1a2+rYCm6vO2P2UDTtelMcaYqiZ/vNjHF0Ltls66fTUgGVuYvJvnJ//L2d2aMSihWaDDMaZE3raQrQamicj3QGZ+oao+55eojDHG+EZmKnx9Ayz9GjpfCOe8XK3Hi+VLz8rh1k/n07BWOI8O6myz8ZtKz9uEbL37CHMfxhhjKrudq53xYtuXOxNcHjfSp+PFFibvJmntLo4/sgHtGsdUqqTn8R+WsSYljY+vOYbaUf6bO8oYX/EqIVPVhwBEJEpV0/0bkjFVX926RS7FakzFWTkFJlwFEgSXfQFtTvVp9Z/MWs8D3ywmO9dZfq9FvUj6dmhM3w6N6dWqHqHBgbvD+NflW/nor/WMOKk1vds0CFgcxhwOb++yPA54G4gBWopIN+A6Vb3Bn8EZU1VZQmYCRhX+eAF+eRgadXTWo6wb77Pqs3LyePDbJXwyaz0nt2vIfwd2YPaaXUxZtpVPZq3n3T/WUisihD7tG9G3QyP6tGtUoS1UO1IzuWvCQo5qUos7+rWrsPMaU17edlm+AJwBfAOgqgtE5CR/BWVMVZeTkwNASIi3v2LG+EBWGnx9IyyZCJ3Oh0GvQFi0z6rftm8/N3w0l6R1u/hPnzaM6tee4CDhyEa1uOSYlqRn5fD7ih1MWbaVX5dv49sFmwgOEnrG16Vvh8ac3rExR9T3XTyFqSr3fLGQvftz+PiaYwkPsdn4TdXh9aeFqm4oND4g1/fhGFM9rF/vzJls85CZCrNzjTtebBmc/jD0vtmn48UWbNjNdR/OYU9GNq9ccjQDux5612JUWAj9OjWhX6cm5OUp85N3M2XpVqYs28qj3y/j0e+XcWSjGDc5a0RCi7o+nRds3OwNTFm2jf8b2JH2TWr5rF5jKoK3CdkGEekNqIiEArcAy/wXljHGGK+t/MUZLwZw6QQ48jSfVj9hTjKjJy6iUa1wvvhPbzo2iy31mKAgoXvLunRvWZe7+h/F+pR0pixzkrO3Zqzm9d9WUT86jLO6NmVwYotyL2e0ensqj3y3lBPbNmB47/hy1WVMIHibkF0PvAg0BzYCP+MsOm6MMSZQVOGPF+GXh6BhB2e8WL1WPqs+OzePx39Yxrt/rKV3m/q8ckl36kWX7Ub7lvWjuOqEVlx1Qiv2ZGTz27/bmbRkC5/+vYEPZq6jU7NYhvRswaBuzQ97zFl2bh63jZ9PeGgQYy7qRpDNxm+qIG8TsvaqeqlngYgcD/zh+5CMMcaUKisNvh4JS76ETufBoFd9Ol5sZ1oWN348l5mrU7jq+FaMHnAUIT66c7J2ZCjndGvGOd2asTs9i6/nb2L83xv4v6+X8Oj3y+jfqQlDerbguNb1vUquXv5lBQuS9/C/S7vTODbCJzEaU9G8TcheBrp7UWaMMcbfdq6B8ZfBtqXQ9yE4/hafjhdbsmkPIz6Yw/bUTJ69qBsX9IjzWd2F1YkK44re8VzRO57FG/cw/u8NfDV/I98s2ESLepFc1KMFF/aIo1mdyCKPn7NuJ69MXcmFPeIY0KWp3+I0xt9EVYvf6Ex30RtnLcvnPTbFAuepaje/RleKxMRETUpKCmQIxhRpzx5npbHatcs3LsaYQ6z61Rkvpnlw4TtwZF+fVv/Ngk3cNWEBdaPCeOPyHnSNq+PT+r2xPzuXSUu2MP7vDfy5KgUROLFtQ4YktqBvx0YH7p7ctz+bAS/NQBB+uOVEYsLtrmZTuYnIHFVNLGpbaT+9YThzj4UAnres7AUu9E14xlQ/logZn1OFP1+GKQ9Aw6Pc8WK+u4s3N095etJy3vhtNT3j6/K/S3vQsFa4z+o/HBGhwQxKaM6ghOasT0nn8zkbmDAnmRs/mUvdqFDOOzqOIT1b8OaM1WzclcHn1x9nyZip8kpsITuwk8gRqrquAuI5LNZCZiqrrKwsAMLCbKUx4wNZ6fDNTbB4AnQcBIP+B+ExPqt+T3o2N306j+n/bueyY1vyfwM7ERYSuJn2i5Kbp0xfsZ3PkzYweenWAysE3Hzqkdzer32AozPGO+VpIcuXLiLPAJ2AAyMmVdW3a3EYU00kJycDNg+Z8YFda+HTy2DrYjjtATjhNp+OF/t36z6u/SCJTbszeOL8Lgzt1dJndftScJBwSvtGnNK+ESmpmUyct5GNuzO46bS2gQ7NGJ/wNiH7GBgPDMSZAuMKYLu/gjLGGAOsmgoTrnTGi106Adr6drzYpCVbuH38fKLCQ/h0xLH0OKKeT+v3l/ox4Vxzov2zY6oXbxOy+qr6tojcoqq/Ab+JyN/+DMwYY2osVZj5Ckz+P2jQ3hkvVr+Nz6rPy1Ne+GUFL/2ygm4t6vDGZT1oUtumizAmkLxNyLLdr5tF5CxgE1A1/pUyxpiqxHO8WIdz4NzXfDpebN/+bG4bv4Apy7ZyUY84Hjm3MxGhtuajMYHmbUL2qIjUBu7AmX8sFmcqDGOMMb6yax2MvxS2LIZT/wsn3uHT8WKrt6dy7QdJrE1J56FzOjHsuCMQH9ZvjCk7rxIyVf3OfboHOAVARG4tz4lFZC2wD2eR8hxVTRSRejhj1eKBtcBgVd1VnvMYEwgNGjQIdAimqlk9DT6/EvJy4dLPoe3pPq1+6vJt3PzpPEKDg/jo6mM4rk19n9ZvjCmf8tzXfLsPzn+KqiZ43AJ6D/CLqrYFfnFfG1PlxMbGEhtb+gLMxjjzi70CH54HMY1gxFSfJmOqyqtTV3LV+3/Tsl4U34w83pIxYyqh8syk54927kFAH/f5+8A04G4/nMcYv8rMzAQgPDwwE2uaKmLnGvjuVqd1rMPZ7nixWqUd5bW0zBzunLCAHxZt4ZxuzXjqgq5Ehtl4MWMqo/IkZKXPKFv68T+LiAJvqOpYoLGqbna3bwEaFz5IREYAIwBatqyc8+UYs3HjRsDmITPFyMuFv16DqY+BBMNZz0Li1T4dL7Y+JZ0RHybx79Z9jB5wFNee2NrGixlTiZWYkInIPopOvAQoeqVX752gqhtFpBEwWUSWe25UVXWTNQqVjwXGgjNTfzljMMaYirV1CXw9EjbNhXb94aznoHZzn57i9xU7GDluLqrw3pW9OKldQ5/Wb4zxvRITMlX1Xdv5oXVvdL9uE5GJQC9gq4g0VdXNItIU2Oav8xtjTIXKyYTpY+D35yCiDlzwNnS+wKetYqrK27+v4fEfltG2US3GDuvBEfWjfVa/McZ/ArIaq4hEA0Gqus993g94GPgGZxWAJ92vXwciPmOM8an1s5y5xXb8A10vhv5PQJRvp3Lcn53LvV8uYuK8jfTv1IRnB3cj2hbcNqbKCNRva2NgojueIQT4RFV/cmf//0xErgbWAYMDFJ8xxpRf5j745WGY/SbUjoNLv/D58kcAG3dncN2HSSzZtJc7Tm/HjaccSVCQjRczpioJSEKmqquBbkWUpwCnVXxExvhWo0aNAh2CCbQVk+G722BPMhxznTPRqw9n3M83a3UKN3w8l8ycPN68PJG+HQ+5F8oYUwVYe7YxfhAT4/sPXlNFpKXApHth4XhoeBRc/TO06OXz06gqH/21joe+XUrLelGMHZbIkY3s586YqsoSMmP8ICMjA4DIyPLejGyqDFVY/AX8eBfs3wsn3wMn3g4hvp+LLjMnl//7agnjkzZw6lGNeOHiBGIjQn1+HmNMxbGEzBg/2LzZmU7P5iGrIfYkw3e3w4pJ0LwHnPMKNO7ol1Nt3buf6z+aw7z1uxl5ypHcfno7Gy9mTDVgCZkxxpRVXh4kvQ1THgLNhTOecMaLBflnNvy563dx/YdzSM3M4X+XdmdAl6Z+OY8xpuJZQmaMMWWx/V/49mZYPxNanwJnvwB14/12us/+3sD9Xy2mSe0IPri6F0c1sbVSjalOLCEzxpjDkZsNf7wAvz0NoVHO+pPdhvp0gldP2bl5PPLdUj6YuY4T2zbg5aFHUycqzC/nMsYEjiVkxhjjrY1znQlety6GjufCgGcgxn9TnOxIzeSGj+cye81ORpzUmrvOaE9IcJDfzmeMCZyam5DtWgcxjSE0ItCRmGqoSZMmgQ7B+FJWurMQ+F//c/5uXPwJHHWWX0+5KHkP132YREpaFi8MSeDco3273qUxpnKpmQlZdga8PxBqt4SLP4LIuoGOyFQzUVFRgQ7B+Mrq35yxYrvWQo/hcPrDEFHbr6f8at5G7v5iIfWjw/jiP73p3Ny/5zPGBF7NbPsOjYTTHoANs+Cd/rB7Q6AjMtVMeno66enpgQ7DlEfGbvh6JHxwDkgQDP8ezn7Rr8lYTm4ej363lFvHzyehRR2+uekES8aMqSFqZgsZQJcLnbEfn14Gb/WFyyZAky6BjspUE1u2bAFsHrIqa+k38MMoSNsBx98Kfe5x/pHzo11pWdw0bh6/r9zBFccdwf0DOxJq48WMqTFq9m97q5Pgqh+dOYPeORNWTQ10RMaYQNq3FcZfDp9d7owVu/ZXOP0hvydjyzbv5ZxXf2f2mp08fUFXHhrU2ZIxY2qYGttClpmTS3hIMDTuBFdPho8vgo8vhEGvQreLAx2eMaYiqcK8j+Dn+yB7P/R9EI4bCcG+XY4oOzeP9TvTWbUtlVXb01i1PZVV21NZsmkvdSJD+fS6Y+ne0sa0GlMT1diE7ILX/iQ8JJh+HRvTr1MTWl31I3x6KUy8DvZuhBNu99u8QsaYSmTnGvj2FljzGxxxPJz9EjQ4slxV7snIZvV2j6Rrm5N4rUtJJydPD+zXODacNg1juKRXS27o04ZGsXbXtzE1VY1MyPLylNM7NOHnpVt44sflPPHjcto2iqFfh6fpJ+/QZcojBO1JhjOfgeAa+RYZU/3l5sCs1+DXx5yWsIHPQ/fhEORdV2FenrJpT4aTdLkJ1yo3Cdu+L/PAfqHBQnz9aNo2qkX/zk1o0zCGNg1jaN0wmlq2ILgxxiWqWvpelVRiYqImJSWVq47kXelMXrqVn5dsZfbaneTmKU3Cszg9Zxr9WgZxzOUPExZVy0cRm5oiIyMDgMhI/449MmW0ZTF8MxI2zYP2A+CsZyG2WZG7ZmTlsmZHWoGEa9W2VFbvSGV/dt6B/WpHhnJkoxjaNIw+kHS1aRRDi7qRNpmrMQYAEZmjqolFbqvpCZmnXWlZ/Lp8Gz8v3cJvyzezPzeIWkH7ObVjc/p1PYKT2zckJtxazIypsrL3w/RnnKWPIuvCmU9Dp/NQYEdq1sGka9vBBGzj7gzy/0yKQIu6UQeTrkZu4tUwmnrRYYgNczDGlMASsjLIyMrl96k/8vOM35mS151dedGEBQdx/JH16depCX07NKZhrXC/nNtUfampqQDExMQEOBJzwLqZZH9zK+u372HVEUNY1fJCVu3OOzDGa+/+nAO7RoYG06aRR0tXwxjaNIomvn40EaHBAbwIY0xVZglZeWyYTc7HQ5mT24afW9/LzxuUDTszEIHuLesevCmgQbR/4zBVyurVqwGbhyxQCgyq35zCqmXzWLUzi3XahBwOJlT5g+rzW7nyW7yaxEYQFGStXcYY37KErLx2rISPzofUbeiF77C89gn8vGQrPy/dwpJNewGcmwI6NaZfxyZ0jattXRc1nCVk/uf1oHpyiJcttKkfQZsO3WnTtK4NqjfGBIQlZL6Qug0+GQybFzgDgBOvAoq5KSA2gtM7NqZfp8Yc06o+YSE2oLemsYTMd8o0qL620Gb9Z7RZ9zktGtUjZNBL0KJnAK/CGGMqWUImIi2AD4DGgAJjVfVFEXkQuBbY7u46WlV/KKmuCk3IADJTYcKVsOJnOHEUnHp/gbnKCtwU8O929mfnUSsihFOPakS/jk3spoAaxBKyw6OqvhlUD7Doc/jpHti/F04a5cwpGBIWyMszxhig8iVkTYGmqjpXRGoBc4BzgcFAqqqO8bauCk/IwJm76PvbYO4H0G2oM4lkEX/sM7Jy+X3lDn5esoUpy7ayKz27wE0B/To2pn6M3RRQXVlCVrTiZqr3yaD63Rvg+9udf5jiesI5L0OjDhV0ZcYYU7pKlZAdEoDI18ArwPFUhYQMnGVWpj8DUx+D1n1g8IcQEVvs7jm5ecxZt4uflzrjzjbszCA0WOjXsQkX92rB8W0a2ADiaiYz0xnDFB5eM5Puw52pvlyD6vPyIOltmPIgaB6c9gD0utZZo9YYYyqRSpuQiUg8MB3oDNwODAf2AknAHaq6q4hjRgAjAFq2bNlj3bp1FRXuoeZ9BN/cDI06wqWfQ2zTUg9RVZZt3scXc5P5Ym4yu9OzaVEvkot7tuSiHnG2dIqpsjbtzuChb5cwd/3uImeqz2/l8ulM9dv/hW9ugg1/QZtTYeALUPeI8tVpjDF+UikTMhGJAX4DHlPVL0WkMbADZ1zZIzjdmleVVEfAWsg8rZwCn10BEXXgsi+g0VFeH7o/O5dJS7bw6ewNzFydQnCQcOpRjRjaqwUnt2tEsLWaVVl79zp338bGFt9yWp38unwrt3+2gOycPAZ0aeoOrvfjTPU5WfDHizD9aQiLhjOegG4X2/qzxphKrdIlZCISCnwHTFLV54rYHg98p6qdS6qnUiRkAJvmO3dg5uyHi8dB/PGHXcWaHWmM/3sDE+ZsYEdqFk1rRzA4sQWDe7ageR13+R1V+OcH+Os1CAmHmCYQ0whqNYGYxs6jlvs1zOZFC6SaMoYsKyePZyYt580Za+jYNJZXLjma1g39PBnuxjnw9U2wbQl0Oh/OfMr5PTDGmEquUiVk4kzQ9T6wU1Vv9Shvqqqb3ee3Aceo6sUl1VVpEjKAXevgowtg9zo47w3ofH6ZqsnKyeOXZVsZ9/cGZqxwbjg9uV1Dhh4VyqkrHyN01WSoG++0yKVudabj0NxDKwqrdTA5K5CseSZxTZzlY7xcTNl4ryYkZBt2pnPTuHnM37Cby489gvvO6uDfWeyz0mDq4/DX/5yf3bOehaMG+O98xhjjY5UtITsBmAEsAvInERoNDAUScLos1wLX5SdoxalUCRlA+k4YN9QZz3LG43DcjeWqbsPOdD77axWfzVrJ1swwGsoeLjpSuWjgWbRoEOt0A+XlQXoKpG5xErR9W91EbSvs2+IkbKlbnPLstENPEhTiJmyNnA85zyTOs+UtppHTKme8Ut0TsklLtnDn5wtQhScv6MpZXUsfP1kuq6c54zV3r3PmAOz7IETU9u85jTHGxypVQuZLlS4hA8jOgC9HwLJv4NgboN9jZWuBUoUlX8Kk+8nZu4VpR9zMp3o6v67cQ/5NamEhQUSHBRMVFkJUWLD7CCE6PJjIsBCiw4KJDAsmOiyEqPBgoiSXKE0lKncf0Tm7iczeSXTWDqL2byNq/xaiMjYRlbqB0IztOHlxIZF1C7Ww5SdxTQomdOGxNX4sT3VNyDJzcnnih+W89+dausbV5pWh3WlZP8p/J8zYBZPuh/kfQb02cM5LEH+C/85njDF+VFJCZrOU+lpoJFz0Hkwa7XSt7N0I542F0MO4e3LrUvjxLlg7A5p0JeSi9+jb8hj6Apv3ZDB56VZ2p2eTlpVDRlYuaZm5pGflkJ7lfN28J/vA8/TMXNKycsg7JL8KxZmbtzHQqcCWsGAhKiyIqGCICs4lKiibKMkiSjOI2pdG9J69RGbvJTpnB1G6nij2E81+IiXT+RqsREdHExVdi6hadYiuVY/I2vUJq12oyzSqAQTbj2BVsS4ljZGfzGPRxj1cdXwr7j6zPeEhfuyiXPo1fD/KaQE+4TY4+W7n98sYY6oh+zT0h6Bg6P8k1G4BP9/ndBte/AlE1Sv5uIzdMO1JmD0WwmvBWc9Bj+EF5lNqWjuSYcfFH1Y4qkpmTt7BJC0rl7RMN5krpiwjK8f96iR06Zm5bMt2vqZn5ZKmOaTn5pJ7aKYH2cB+IKVgcSg5RLKbaLYQJbOJIpOo4DyiQiEqNIio8FCiI8KJiowgKspN6GJiiYqtR3RU1MHWvrBgosJDiAoNJio8mLDgoEq3dmhcXFygQ/Cp7xdu5p4vFiICYy/vQb9OTfx3sn1b4Ps7YPl30LQbXDbB+WqMMdWYJWT+IgK9Rzpzk028Ht45Ay6dUPQcSXl5sGAcTHkA0nY4Sdip/4Xo+j4KRYgIDSYiNJh60b5bQkZVycrNc5K07FzSM93Ezk3gPMvSM/aTlraXjLQ00jLSSc/YT3pmFmlZuezIziMtQ8hIDSYtL5R0wskhGEh3H1tKjCNEIDJMiA4LJSo81OmedRO36LAQN5E72I0bFV6oi7eIsqiwYMJDyp7ohYVVj6V69mfn8uj3S/nor/Uc3bIOLw89mri6fuqiVHVWwPj5v5CbCX0fguNGWiuqMaZGsL90/tb5AmdQ/KeXwNunOxPIev63v2ke/HAnJP/tLPdy6efQ7OjAxXsYRITwkGDCQ4Kp66tK3ZsUsvZsIX3XFtL3bCd9z07SU3eRlrqX9NRU0jNSSc/IJD0H0okgXcNJy4kgPSec9PRI0oNjSQ+KYadEsYEIMjSMtNwQMnKDyMorPYR8QcLB8XdFjdMLzR+v59Fy526rG5JDRGgQIZExHtuCiQ4PKVeiV5FWb0/lxk/msWzzXq47qTWjzmhPqK/nE8uXsgq+vcXppo8/Ec5+Eeq38c+5jDGmErJB/RVl2zL46ELYvxsGf+AkXb88DHPeg+gGcPrD0PVim4LicGSmFn9HaarHIy1/vmHI1mDSCSedCNLCG5ER2ZS0iCZkhDcgLbQ+6aF1SQ+pTVpQLTIkijQiSc8NIj0772Br34Hxem5rYFYuWTkFM70nTm8MwL2Ttx4SdpBAlEfLXVQR3bBRB5K8/G2eLXruseHBRIWGHNgWGRrss0Tvq3kbGT1xEeEhQTw7uBunHtXYJ/UeIjfHGWs59XEIDoV+j8DRw+z3wBhTLdldlpXF3k3w8UWwfTmExUDmPjjmOuhzj93C70+52ZC2vZhpQbYWLM/NPPT4kMgi7izNnw7EKcuJbuwkc9k4N1ukbCY3T9kZXMcdd3ewOzf/RoyM7JwCN2QcGLvnUZaZ432TnghEhbpds+FOghbt0RV7MJELcbd5tvy5XbzhwXz2dzLjkzbQM74uLw09mqa1/TSQfssi+HokbJ4P7c+Cs8ZAbDP/nMsYYyoBS8gqk/17YeJ1zqz+/R6Dxh0DHZHJp+q0YKZuK5SsFdH6tn/3ocdLkHPnaK3GrE64B4JDab13VqF53dyELsy7cVg5uXlkZOcebJEropUu3U3i8m/EKLg9f5tHMpiVw/7s4hM9EbihTxtu69vO90seAWTvd5Y8+uNFZyqVAc9Ax3Nr/FQpxpjqz6a9qEwiYmHouEBHYYoi4iQIkXWhYfuS983ef3ClhAKT8rrJW26WM7P87y+UspJCCctfxTQhJKoetSJCy78IdyG5eeokepmFWu6ycmlUK5wOTf20Bue6P50JXlNWQMKl0O/R0u8+NsaYGsASMmPKIjTCuWO2qLtmAdyJYfnvDnclBY9krXBX6eb5sGIbZKUeWk9QqNuqVqiFzXP5q/ztId7f2RkcJMSEhxATXkF/AvbvhSkPQtLbUKclXD4R2pxaMec2xpgqwBIyY/ygZcuWzpOgIIhp6DzoXPJBxd2kkJ/E7V7v3I3rcZNCAfkrKRS7/FXjwKyk8M9P8P3tzhjKY2+EU++DsOiKO78xxlQBlpAZ4wchIWX41QqPcR6lTffgzU0K62c620q9SeHQblJimzkL2IfHHP41eErdDj/dDYu/gEYdnbuL44ocOmGMMTWeJWTG+MGuXbsAqFvXZzO0HRQc6iRNpd2ReMhNCvk3Jng83/4PrJle9E0K0Q2hbiuo1+rg13qtnefRDYpvZVOFhePhp3udO4n7jHaWPjqMLlVjjKlpLCEzxg/8mpB563BvUkjb5rSq7U2GnWtg1xrn67o/YeFnFOgmDYtxk7T4gklbZB349VFYOQXiesE5L0Ojo/x4kcYYUz1YQmaMcW5SqNPSedDz0O05mbBr3cEkLf/r9n/g30nOXaUH6oqGM5+GntcUWIfVGGNM8SwhM8aULiQcGrZzHoXl5ToD9netgT0bIf4EqNOi4mM0xpgqzBIyY0z5BAU7CZglYcYYU2a2YJwxxhhjTIBZC5kxfhAfHx/oEIwxxlQhlpAZ4wdBQdb4bIwxxnv2qWGMH6SkpJCSkhLoMIwxxlQRlpAZ4wd79uxhz549gQ7DGGNMFWEJmTHGGGNMgFW6hExE+ovIPyKyUkTuCXQ8xhhjjDH+VqkSMhEJBl4FzgQ6AkNFpGNgozLGGGOM8a9KlZABvYCVqrpaVbOAT4FBAY7JGGOMMcavKtu0F82BDR6vk4FjPHcQkRHACPdlqoj8U0Gx+UsDYEegg6gANeU6PdW0a66u11tdr6skNeWaa8p15qsp11uZr/OI4jZUtoSsVKo6Fhgb6Dh8RUSSVDUx0HH4W025Tk817Zqr6/VW1+sqSU255ppynflqyvVW1eusbF2WGwHPBfHi3DJjjDHGmGqrsiVkfwNtRaSViIQBFwPfBDgmY4wxxhi/qlRdlqqaIyIjgUlAMPCOqi4JcFj+Vm26X0tRU67TU0275up6vdX1ukpSU665plxnvppyvVXyOkVVAx2DMcYYY0yNVtm6LI0xxhhjahxLyIwxxhhjAswSMj8SERWRZz1ejxKRBwMYkt+ISK6IzBeRJSKyQETuEJFq//MlIqmBjqGieHyP8x/xJew7TUSqxG3n7u/pRx6vQ0Rku4h8F8i4/E1EznWv/ahAx+IPNfX7CjXr7xKUfr1V5e9Rtf/ADLBM4HwRaRDoQCpAhqomqGon4HSc5a8eCHBMxrfyv8f5j7WBDshH0oDOIhLpvj6dw5xuR0Qq1Q1SXhoK/O5+9Zq7xF1VUO7vqzEVyRIy/8rBudvjtsIbRCReRH4VkYUi8ouItBSR2iKyLr9lSUSiRWSDiIRWdODloarbcFZTGCmOYBF5RkT+dq/3uvx9ReRuEVnktqo9Gbioy05EYtzv4Vz3Wga55fEiskxE3nRbDn/2+HCoFkSkh4j8JiJzRGSSiDT12Hy525K2WER6BSxI7/wAnOU+HwqMy98gIr1EZKaIzBORP0WkvVs+XES+EZFfgV8qPuSyE5EY4ATgapzphRCRPiIyXUS+F5F/ROR1j79FqSLyrIgsAI4LXOSHrSzf1+kikuCx3+8i0q0ig/YF9/v5ncfrV0RkuPt8rYg85PE3q8q3kpZ0vVWFJWT+9ypwqYjULlT+MvC+qnYFPgZeUtU9wHzgZHefgcAkVc2uqGB9RVVX40xd0gjnj/4eVe0J9ASuFWeuuTNx1io9RlW7AU8HLODy2Q+cp6rdgVOAZ0VE3G1tgVfdlsPdwAWBCdEnIj26Kye6/yi8DFyoqj2Ad4DHPPaPUtUE4AZ3W2X2KXCxiEQAXYFZHtuWAyeq6tHA/wGPe2zrjnP9J1O1DAJ+UtV/gRQR6eGW9wJuAjoCbYDz3fJoYJaqdlPV3ys82rIry/f1bWA4gIi0AyJUdUGFRVxxdrh/s14DRgU6GFPJ5iGrjlR1r4h8ANwMZHhsOo6Df+w+5GAyMh4YAkzF+c/1fxUUqj/1A7qKyIXu69o4iUpf4F1VTQdQ1Z0Biq+8BHhcRE4C8nDWZG3sblujqvPd53OA+AqPzncy3AQLABHpDHQGJrv5ZzCw2WP/cQCqOl1EYkWkjqrurrhwvaeqC8UZEzcUp1XFU23gfRFpCyjg2WI9uYr+3A4FXnSff+q+/g6Y7f4zhYiMw2lFmwDkAl8EIM5yKeP39XPgvyJyJ3AV8F7FRFvhvnS/zuHgZ5EJIEvIKsYLwFzgXS/2/Qbnw70e0AP41Y9x+Y2ItMb5I74NJ2G5SVUnFdrnjEDE5geXAg2BHqqaLSJrgQh3W6bHfrlAdeqyFGCJqhbXhVV4ksPKPunhN8AYoA9Q36P8EWCqqp7nfrhP89iWVlHB+Yr7t+VUoIuIKE4ircD3FP8926+quRUXpU8d1vdVVdNFZDJOK+JgnL/DVVEOBXvBIgptz//blEv1yAVKu95Kz7osK4D7H/RnOF13+f7EHbuB84E+w903FWcJqReB76riH0ERaQi8DryizszDk4D/5I+FE5F2IhINTAauFJEot7xeoGIup9rANjcZOwU4ItABVZB/gIYichyAiISKSCeP7UPc8hNwuqz3BCDGw/EO8JCqLipUXpuDg8GHV2hE/nEh8KGqHqGq8araAlgDnAj0cocTBOF8/6pS92RxyvJ9fQt4CfhbVXf5Nzy/WQd0FJFwEakDnBbgePytyl+vJWQV51nA827Lm3CSkYXA5cAtHtvGA5e5X6uK/PFFS4ApwM/AQ+62t4ClwFwRWQy8AYSo6k84/70mich8qtg4BnHurMvEGQOYKCKLgGE4Y1OqPVXNwvlwf8od7D0f6O2xy34RmYeTnF99aA2Vi6omq+pLRWx6GnjCvZbq0JIwFJhYqOwLt/xv4BVgGU6SVni/Kqcs31dVnQPsxbtejUol/++Sqm7AaQhY7H6dF9DA/KQ6Xa8tnWRMGbl3Xr2pqpX9DkJjSiUifYBRqjowwKEEnIg0w+nCPEpV8wIczmGpaX+XqtP1WguZMWUgItfjDFq/P9CxGGN8R0SG4dyNeV8VTMZq1N+l6na91kJmjDHGGBNg1kJmjDHGGBNglpAZY4wxxgSYJWTGGGOMMQFmCZkxxhhjTIBZQmaMMcYYE2CWkBljjDHGBJglZMYYY4wxAWYJmTHGGGNMgFlCZowxxhgTYJaQGWOMMcYEmCVkxhhjjDEBZgmZMcYYY0yAWUJmjDHGGBNglpAZY4wxxgSYJWTGGGOMMQFmCZkxxhhjTIBZQmYMICInisg/gY7DWyIyXER+D3QcxhhjfMMSMlMtici9IvJjobIVxZRdrKozVLW9l3X3EZFkH8f7j4gM8Xh9vIhoEWX7RCTEl+cuIpa1ItK3lH1Gi8gaEUkVkWQRGe/PmPxJRAaLyJ8iki4i04rYfraILHav9U8R6ViOuhJEZI67fY6IJBRTT7iIvC0i69zv+XwRObPQPqeJyHK3rqkicoQ3cYhIAxH5Q0RSRGS3iMwUkeNLe59KIyJj3N+nfW5cw4rZb5j7s31NCXXVE5GJIpLmvgeXeGwb7X4v8h8ZIpInIg2KqKeRiIwTkU0isse97mMK7XOJe440EflKROp5bBspIkkikiki75UQ7/+511Ti740xJbGEzFRX04HeIhIMICJNgVDg6EJlR7r7VphiEqrpwEker08ClhdRNlNVc/wYXqlE5ArgcqCvqsYAicAvgYypnHYCLwBPFt4gIm2Bj4HrgTrAt8A3JSTFJdUVBnwNfATUBd4HvnbLCwsBNgAnA7WB+4HPRCTerasB8CXwX6AekAR4JsXFxgGkAlcBDd04ngK+9UGinwac7cZ7BfCiiPT23EFE6gKjgSWl1PUqkAU0Bi4FXhORTgCq+riqxuQ/3PinqeqOIuqJAf4GeuC8T+8D34tIjBtPJ+ANnJ/nxkA68D+P4zcBjwLvFBeoiLQBLgI2l3JNxpRMVe1hj2r3AMJw/rj2cF8PBt4FfitUttJ93gdI9jh+LTAKWAjswfmwiwCigQwgD+eDLRVohvPPzT3AKiAF+Ayo59YVDyhwNbAemF5EvJcDizxe/wAML6Lsfvf5cOB3YAywC1gDnOmxb23gbZwPiY04HyrB7rY2wK9unDtwEo467rYP3WvLcK/triJifQV4oYT3vkzndrff7R6zD/gHOM0tD8dJMDa5jxeAcM/vHXAHsM0975Vl+Jm5BueD3bNsJPC9x+sg9705rQx19XOvTTzK1gP9vYxvIXCB+3wE8KfHtvyfy6NKi6PQ9iCcJEqBRj7+HfwGuKNQ2evADcA04JpijovGScbaeZR9CDxZxL4CrAauOIy49nLwb8DjwCce29q4565V6JhHgfeKqe8nYADO34y+vnwP7VGzHtZCZqolVc0CZnGwhekkYAZOEuNZVlLr2GCgP9AK6AoMV9U04Exgkx78L30TcBNwLk6LRjOcJOnVQvWdDHQAzijiXNOBTm5XTRBOq9N4oI5H2fGF4j0GJ2lpADwNvC0i4m57D8jBaQE8GicZyO8iEuAJN84OQAvgQQBVvRwnSTjbvbani4j1L2CYiNwpIon5LY4eynRuEWmPkwD1VNVa7vu01j3uPuBYIAHoBvTCaTXK1wQnEWyOk/i+6rbG5HdJLSziOrwlhZ4L0LkM9XQCFqqqepQtdMtLDkCkMdCOgy1LnYAF+dvdn8tV3tTlUedCYD9O4vSWqm7z9lgv6o4EenrEi4j0wvm5fr2Uw9sBOar6r0fZAoq+thOBRsAXXsaVgPPP2kq3qPD7uAo3GfSyvouATFX9wZv9jSmJJWSmOvuNg8nXiTgJ2YxCZb+VcPxLqrpJVXfidFUllLDv9cB9qpqsqpk4ScaFhbqBHlTVNFXNKHywqq7DSYROxEk4Vrj7/eFRFoaTZOZbp6pvqmouTldMU6Cx++E9ALjVPd824HngYvdcK1V1sqpmqup24DmcZNErqvoRTgJ6Bs77t01E7oYDiUNZz52L0xLWUURCVXWt+wEJTrfVw6q6zT3uIZxWxXzZ7vZs98MxFWjvnvMTVe3q7fUVMgU4WZxxg2E43W1hQFQZ6orBaW31tAeoVdJBIhKK05L4vqouL09dntz3JBa4BOcfFV96HSfRmQTgJu3/A0aqal4px8bgtGJ5Ku7argAmqGpqaQGJSCxOS9tDqpr/3pX5fRSRWjgtbLeUtq8x3vDr4GBjAmw6cKM7SLehqq4Qka3A+25ZZ0puIdvi8Twdp1WnOEcAE0XE88MmF2dcSr4NXsR7Ek5iNsMt+92jbLab7B0Sn6qmu41jMThjZUKBzQcbzAjKP7+bNL2Ik+jVcrftKiW2AlT1Y+BjN1k4130+362nTOdW1ZUicitOMttJRCYBt7stkM2AdR4hrKPg9yNFC46tS3ffi3JR1eXumLlXcBLej4ClOF2khysVJwHyFIvTPVskt2X0Q5xWm5HlqasoqrofGCciy0Rkvqou8NwuIu2AuYUOm+i2pBYX8zM4v1uneLQG3oDTOviXF2F5dW0iEoUzdmtQaRW6LXbfAn+p6hOHe65iPAh8qKprvdjXmFJZC5mpzmbidGNdi9PShKruxRmDdC1Ot+OaMtSrRZRtwBnDVcfjEaGqG0s5zlN+QpbfmgcHW/ROxPubDzYAmUADj1hiVTW/y+dxN5YuqhoLXEbBbrnS4jy4o9Mi9TlO11vn8p7bbc06ASfBVZwB2+B8zw7cRQi0dMv8TlUnqGpnVa0PPIAzJvDvMlS1BOjq0a0MTld4kQPc3f3exknqL1DV7EJ1dfPYNxpn/FNpg+WLEwq0Llyoqv96dM3nP0pKxh7C6dLv5/6u5TsNOE9EtojIFqA38KyIvFJENf8CIe4NFfm6cei1nYdz88K0ki5MRMKBr3CS6OsKbS78PrbGaaX9l9KdBtzscU0tcG68uNuLY405hCVkptpyu/ySgNs5mOCA0+p0O2W/u3IrUF9EanuUvQ48Ju7UAyLSUERK/c+9kOk4Y65Owk0ggUU4Y9hO8TZeVd0M/IzzgRcrIkEi0kZE8rsGa+G0DOwRkebAnUVc3yEfzvnEmQPtLBGp5dZ9Js5YnFnlObeItBeRU90P0P0cvHkCYBxwv/u+NgD+D6e1qtxEJFhEInB6DIJEJMJt+cvf3sPdpyEwFvjGo+vwcOqahtNqerM401rkt3j9Wkxor+GMszu7iG7uiUBnEbnAPd//4bRALS8tDhE5VkROEJEwEYl0E4jGFOwOP2wici9O92dfVU0ptHm4ey0J7iMJp9v5vsL1uOPhvgQeFpFocabkGITTUujpCuCDQmPyCscUCkzA+Vm6ooju0o+Bs8WZhzAaeBj4UlX3uceHuO9jMBDsvo/5PUun4fwTkn9Nm3ASvsJjR43xTlnvBrCHParCA2cAuQLdPcoGu2XXeZT14dC7LPt6vH4Q+Mjj9Ts4dwru5uBdlrfjDLLfhzPA+nF333j3fCFexLsZ54PVs+wHnDFS0R5lw4HfC+2nwJHu89o4H+jJOGNi5gEXu9s6AXNwEqP5OHcnel77IJwu0t3AqCJiPB8nYdyFM9ZnEc4ND5Tn3DitRbPd928n8B3QzN0WAbzkvj+b3ecRRX3vCn//cMafLSnhPR/uvneej/c8tv/uEdMbhb4PBer2oq6j3evPwOkKPNpj22jgR/d5fgvhfg7ezZsKXOqxf1+cqVEycJK9eG/iwBmzt8Djmn4DTvLB75ritI56xju6mH2n4XGXpee1u6/r4bRqpeH8LF5S6PjmuDeOFFH368DrHteqOF3YnnGd6LH/Je450nCmJalX6Pe+8Pv4YDHXdOBnzh72KMtDVL3unTDGGGOMMX5gXZbGGGOMMQHmt4RMRFqIs5zHUhFZIiK3uOX1RGSyOEtsTPaYK0hE5CURWSkiC0Wku79iM8YYY4ypTPzZQpaDM0tzR5wJHW8UZw24e4BfVLUtznIr97j7nwm0dR8jcMagGGOMMcZUe35LyFR1s6rOdZ/vA5bhDMQchDOJJe7Xc93ng3DvmFFnrpo64qw1aIwxxhhTrVXIxLDiLIh7NM5t1Y3VuTUenIkt8yfObE7BiTOT3bICC7aKyAicFjSio6N7HHXUUf4L3NQoOTnOvKIhITZfsjHGGN+bM2fODlVtWNQ2v3/yiEgMzjpjt6rqXs85EVVVReSwbvNU1bE4cwGRmJioSUlJvgzXGGOMMcYvRGRdcdv8epelOynfF8DHqvqlW7w1vyvS/Zq/oO1GnJmO88W5ZcZUiLy8PPLySltmzxhjjPE9f95lmb/sxzJVfc5j0zc4Myzjfv3ao3yYe7flscAej65NY/xu7dq1rF27NtBhGGOMqYH82WV5PHA5sMhddBic2ZifxFnv62qcBYIHu9t+AAYAK3FmVb7Sj7EZY4wxxlQafkvIVPV3Ci5Y7Om0IvZX4EZ/xWOMMcYY72VnZ5OcnMz+/fsDHUqVExERQVxcHKGhoaXv7LLbyYwxxhhziOTkZGrVqkV8fDyeN+SZkqkqKSkpJCcn06pVK6+Ps6WTjDHGGHOI/fv3U79+fUvGDpOIUL9+/cNuWbQWMmNcdevWDXQIxhhTqVgyVjZled8sITPGZQmZMcaYQLEuS2NcOTk5B2brN8YYE3jBwcEkJCQceKxdu5Zp06YxcODAAvu99957jBw5skBZnz59SEpKYt++fbRp04YVK1YAzs0KXbp0YdasWYDTmnXHHXccOG7MmDE8+OCDADz44IM0b968QAzjx48/8DwmJob27duTkJDAsGHDynWt1kJmjGv9+vUAtG7dOsCRGGOMAYiMjGT+/PkFyg53vshatWrxxBNPMHLkSCZNmsSYMWPo3bs3xxxzDADh4eF8+eWX3HvvvTRo0OCQ42+77TZGjRpVoGzIkCGAk/SNGTOGxMTEw4qpKJaQGWOMMaZkP94DWxb5ts4mXeDMJ31bZzEGDx7M22+/zdNPP83rr7/OvHnzDmwLCQlhxIgRPP/88zz22GMVEk9RLCEzxhhjTKWUkZFBQkICAK1atWLixIllruvFF1+kQ4cOjB07lnr16hXYduONN9K1a1fuuuuuQ457/vnn+eijjwBnrPHUqVPLHENJLCEzxhhjTMkqqCWrsKK6LItS3F2NnuU//fQTTZs2ZfHixYfsFxsby7Bhw3jppZeIjIwssK2oLkt/sEH9xhhjjKnS6tevz65duwqU7dy588CYsE2bNvHSSy8xe/ZsfvjhBxYuXHhIHbfeeitvv/02aWlpFRJzYZaQGeOqX78+9evXD3QYxhhjDlPPnj35448/2LJlCwBJSUlkZmbSokULwGnlGj16NHFxcTz33HPceOONOCs2HlSvXr0DY80CwRIyY1y1a9emdu3agQ7DGGNMKX755Rfi4uIOPFavXs2LL77IgAEDSEhI4NZbb2XcuHEEBQUxefJk1q9fz9VXXw3A2WefTd26dfnggw8OqfeOO+5gx44dBcqef/75Q6be8AcpnCFWJYmJiZqUlBToMEw1kZWVBUBYWFiAIzHGmMBbtmwZHTp0CHQYVVZR75+IzFHVIufIsBYyY1zJyckkJycHOgxjjDE1kCVkxhhjjDEBZgmZMcYYY0yAWUJmjDHGGBNglpAZY4wxxgSYzdRvjKuoRWWNMcaYimAtZMa4YmNjiY2NDXQYxhhjXCLCZZddduB1Tk4ODRs2ZODAgQfKvvrqK7p27UqHDh3o0qULX3311YFtw4cPp1WrVnTr1o127doxbNiwAnfTx8fHH5h37LHHHqNTp0507dqVhIQEZs2a5f8L9GAtZMa4MjMzAQgPDw9wJMYYYwCio6NZvHgxGRkZREZGMnnyZJo3b35g+4IFCxg1ahSTJ0+mVatWrFmzhtNPP53WrVvTtWtXAJ555hkuvPBCVJUXXniBU089lcWLFxeYc3LmzJl89913zJ07l/DwcHbs2HFgbsqKYgmZMa6NGzcC0Lp16wBHYowxlctD3y5h6aa9Pq2zY7NYHji7U6n7DRgwgO+//54LL7yQcePGMXToUGbMmAHAmDFjGD16NK1atQKgVatW3HvvvTzzzDN8+OGHBeoREW677TYmTpzIjz/+yKBBgw5s27x5Mw0aNDjwD3kghrD4rctSRN4RkW0istijbLyIzHcfa0VkvlseLyIZHtte91dcxhhjjKk6Lr74Yj799FP279/PwoULOeaYYw5sW7JkCT169Ciwf2JiIkuWLCm2vu7du7N8+fICZf369WPDhg20a9eOG264gd9++823F+EFf7aQvQe8AhxYLEpVh+Q/F5FngT0e+69S1QQ/xmOMMcaYMvCmJctfunbtytq1axk3bhwDBgwod31FLRkZExPDnDlzmDFjBlOnTmXIkCE8+eSTDB8+vNzn85bfWshUdTqws6htIiLAYGCcv85vjDHGmOrhnHPOYdSoUQwdOrRAeceOHZkzZ06Bsjlz5tCpU/EJ5Lx584pcozM4OJg+ffrw0EMP8corr/DFF1/4JngvBWoM2YnAVlVd4VHWSkTmAXuB+1V1RlEHisgIYARAy5Yt/R6oMcYYYwLrqquuok6dOnTp0oVp06YdKB81ahQXXXQRp556KvHx8axdu5bHH3+cCRMmHFKHqvLyyy+zefNm+vfvX2DbP//8Q1BQEG3btgVg/vz5HHHEEX69psIClZANpWDr2GagpaqmiEgP4CsR6aSqh4wgVNWxwFiAxMTEQ9sdjSmjRo0aBToEY4wxRYiLi+Pmm28+pDwhIYGnnnqKs88+m+zsbEJDQ3n66adJSEg4sM+dd97JI488Qnp6OsceeyxTp04tcIclQGpqKjfddBO7d+8mJCSEI488krFjx/r7sgqQovpSfVa5SDzwnap29igLATYCPVQ1uZjjpgGjVDWppPoTExM1KanEXYwxxhhTBsuWLSuya894p6j3T0TmqGpiUfsHYmLYvsByz2RMRBqKSLD7vDXQFlgdgNhMDZaRkUFGRkagwzDGGFMD+XPai3HATKC9iCSLyNXupos5dDD/ScBCdxqMCcD1qlrkDQHG+MvmzZvZvHlzoMMwxhhTA/ltDJmqDi2mfHgRZV8AFXs7gzHGGGNKpKo4EyOYw1GW4WC2lqUxxhhjDhEREUFKSkqZkouaTFVJSUkhIiLisI6zpZOMMcYYc4i4uDiSk5PZvn17oEOpciIiIoiLizusYywhM8YYY8whQkNDD6wRafzPEjJjXE2aNAl0CMYYY2ooS8iMcUVFRQU6BGOMMTWUDeo3xpWenk56enqgwzDGGFMDWUJmjGvLli1s2bIl0GEYY0zFy0qHP16CRYeuAWkqhnVZGmOMMTVVXh4s+hx+eQj2boTIutDhHAgJK/1Y41PWQmaMMcbUROtmwlunwcQREN0Q+oyGjF2wckqgI6uRLCEzxhhjapJda+GzK+Dd/rBvC5z3Blw7FU68HaLqw6LPAh1hjWRdlsYYY0xNsH8PzHgW/noNgkKcFrHeIyEs2t0hCDqdD/M+hP17ISI2oOHWNJaQGeNq2rRpoEMwxhjfy82Bue/D1MchPQUSLoFT74fYZofu23Uw/P0mLP/O2c9UGEvIjHFFRkYGOgRjjPGtlVNg0v2wfRkccTyc8Tg0Syh+/7ieUDceFn5mCVkFs4TMGFdqaioAMTExAY7EGGPKadty+Pk+JyGr2wqGfARHDQSRko8TgS4XOV2b+7ZCrcYVE6+xQf3G5Nu2bRvbtm0LdBjGGFN2aTvgu9vhtd6w4W/o9xjcOBs6nF16Mpavy0WgebDkS//GagqwFjJjjDGmqsvJhFmvw/QxkJUGPa+Gk++B6PqHX1fD9tCkq9Nteex/fB+rKZIlZMYYY0xVpQpLv4bJ/we710HbM6Dfo9CwXfnq7ToYfr4fUlZB/Ta+idWUyLosjTHGmKpo41x490z4/AoIi4HLJ8Kln5U/GQPofAEgTiuZqRCWkBljjDFVyZ6N8OV18OYpkLISBr4A18+ANqf67hyxzaDVic4ksaq+q9cUy7osjXE1b9480CEYY0zxstLgjxedRcA1D064HU64zX8TuHYZDN+MdFri4nr45xzmAGshM8YVHh5OeHh4oMMwxpiC8vJg3sfwUnf47SlofyaM/Bv6PuDf2fQ7ngPB4baUUgXxW0ImIu+IyDYRWexR9qCIbBSR+e5jgMe2e0VkpYj8IyJn+CsuY4qzd+9e9u7dG+gwjDHmoLW/w9iT4esboHYcXD0ZLnoX6h7h/3NH1IZ2/WDxF85s/8av/NlC9h7Qv4jy51U1wX38ACAiHYGLgU7uMf8TkWA/xmbMIXbs2MGOHTsCHYYxxjh3N356Kbx3FqTvhAvehmumQIteFRtHl8GQth3W/Fax562B/DaGTFWni0i8l7sPAj5V1UxgjYisBHoBM/0VnzHGGFPpZOyC356B2WMhJBxO/S8cdyOEBmhpt7b9ILw2LPocjjwtMDHUEIEYQzZSRBa6XZp13bLmwAaPfZLdskOIyAgRSRKRpO3bt/s7VmOMMcb/crNh1hvw0tHw1/8gYSjcNBdOGhW4ZAwgNMIZS7bsW8hKD1wcNUCJLWQicrsXdaSp6htenu814BFA3a/PAld5eSwAqjoWGAuQmJho9+IaY4ypulTh30nuJKwroNVJzgLgTboEOrKDug6GeR/Cvz+685MZfyithexOIAaoVcLjDm9PpqpbVTVXVfOAN3G6JQE2Ai08do1zy4wxxpjqacti+PBcGDcEUBj6KQz7pnIlYwBHnAC1msHCzwMdSbVW2hiyD1X14ZJ2EJFob08mIk1VdbP78jwg/w7Mb4BPROQ5oBnQFpjtbb3G+EJcXFygQzDG1AT7tsLUx5xWp/BY6P+Us/ZkcGigIytaUBB0uQD+es25wSCqXqAjqpZKTMhU9a7SKihuHxEZB/QBGohIMvAA0EdEEnC6LNcC17l1LBGRz4ClQA5wo6rmen0VxvhAWFhYoEMwxlRn2RnO+LAZz0HOfjjmejjpzqqR4HS5CP58GZZMdJJH43OipSyJICJH4Qywn6WqqR7l/VX1Jz/HV6LExERNSkoKZAimGtmzZw8AtWvXDnAkxphqRdWZy2vKQ7BnPbQ/C05/GBocGejIvKcKrx7jJI9XBfSjv0oTkTmqmljUthLHkInIzcDXwE3AYhEZ5LH5cd+FaEzgpaSkkJKSEugwjDHVyYa/4e3T4YurIbK2M0Zs6CdVKxkDEIGuF8H6mbB7faCjqZZKG9R/LdBDVc/F6X78r4jc4m4TP8ZljDHGVF2718OEq+Htvs7zc16BEb9B65MDHVnZdbnI+bpoQmDjqKZKG9QflN9NqaprRaQPMEFEjsASMmOMMaagzH3OGLGZrzqtSifdBcffAuExgY6s/OrGQ4tjnEliT/RmVixzOEprIdvqDsIHwE3OBgINgEp2X64xxhgTQIu/cBYA//056DgIbpoDp95XPZKxfF0ugm1LnSk7jE+VlpANA7Z4FqhqjqoOA07yW1TGGGNMVbJ3M3w5Amo3h2t+hQvedBYDr246nQ9BIbDos0BHUu2UmJCparKqFkjIRGSEu+0PfwZmTEVr2bIlLVu2DHQYxpiqaM67kJfrLAIe1yPQ0fhPdH1ocxos+gLy8gIdTbVSlrUsr/d5FMZUAiEhIYSElDas0hhjCsnJhKR3oN0ZUL9NoKPxvy4Xwd5kWP9noCOpVsqSkNlgflMt7dq1i127dgU6DGNMVbNkIqRth2OuC3QkFeOoARAaDQut29KXypKQne3zKIypBCwhM//f3n2HR1VmDxz/nnQSUoAklEAIJfQSiiBVQFHsYMGu2LtrXXXdXfW3q2tZ29pRUezYsICCBZCm9K6UEEJCKEkoqaTNvL8/7gABQjIpM3eSnM/zzJOZO7ecSWDmzFvOq1S1GWMtKRTdFTqOtjsa7wgKg25nwx/fWK2Dqk641T8jIlFYA/wTgAARq5HMGHOXpwJTSimlfF76Uti1Gs5+zipz0Vj0mWgN7E/+2UrOVK25O2Dme+B3YB2go/iUUkopgCVvQHAk9LnU7ki8q+NoCI22ui01IasT7iZkIcYYrQKnlFJKHZKTYXXbnXxrw6o15g7/AOh1Aax8H4pyISTC7ojqPXfHkH0gIjeKSGsRaX7o5tHIlFJKKV+2fAoYJwy60e5I7NF7IpQVwZ/f2R1Jg+BuC1kJ8CzwCGBc2wzQ0RNBKWWHhIQEu0NQStUXpUVW7bGuZ1lLCjVGbQdar33dZ9DvCrujqffcTcjuAzobY7I9GYxSdvLzq8mkY6VUo7T+Syjc23hKXVRExKpJtuA5yNsN4a3sjqhec/cTKBko9GQgStlt79697N271+4wlFK+zhhrMH9Md+jQyFcR7D3R6rZd/6XdkdR77raQFQCrRWQucLjoiJa9UA1JTk4OAC1atLA5EqWUT0v7HXavhXNebFylLioS0wVa94V1n8OQ2+2Opl5zNyH72nVTSimlGrclb0BIlFWLS1mtZD8+AtnJEN3Z7mjqLbcSMmPMVE8HopRSSvm8nB3WrMIht1sV6xX0uhB+/Ls1uH/03+yOpt7SUcxKKaWUu5a9Axg46Qa7I/EdEa2tsXRrP7PG16ka0YRMKaWUckfpQVjxnqvURXu7o/EtfSbC/m2QscLuSOqtShMyEUkSaewjFlVj0bFjRzp21NJ6SqkTWPcFHNwHg2+xOxLf0/1c8A+2WslUjVTVQvY2sFdEfhKRx0XkdBEJd+fEIjJFRDJFZH25bc+KyEYRWSsi012LliMiCSJyUERWu25v1PgVKaWUUnXNGFjyJsT2hIThdkfje0Iioes4WP8FlJXYHU29VGlCZowZCLQFnsAqd3EXkCwia0TktSrO/R4w7phtPwG9jDF9gM3Aw+We22qMSXLd9OuH8rrs7Gyys7X2sVKqAtsXw551ViFY7TiqWL+rrWK5m763O5J6qcoxZMaYQmPMPOAl4AXgVSCM45OtY4+bD+w7ZtuPxpgy18PfsZI9pXxCbm4uubm5doehlPJFS96AJs2syvSqYp1GQ0Rba8FxVW1VjSG7XEReEZGFwLfAWGAdMNwYU9vBNtcBP5R73EFEVonIryIyopKYbhKR5SKyPCsrq5YhKKWUUlU4kA4bZ0D/ayAo1O5ofJefv7Wm5dY5cCDN7mjqnapayN4ETsbqfrzVGPOQMWa6MWZ3bS4qIo8AZcBHrk27gHhjTD/gXuBjEYmo6FhjzGRjzEBjzMCYmJjahKGUUkpVbdnb1k8tdVG1JNci46s+qnw/dZyqErIo4CYgBHhMRFaIyAwReURExtTkgiIyCTgHuMIYq2CJMabYGLPXdX8FsBXoUpPzK6WUUnWmpBBWToVu50BUO7uj8X3N2ltdl6s/AqfD7mjqlaoG9TuMMSuNMa8YYy4HzgJmAddiDdCvFhEZB/wVOM8YU1hue4yI+LvudwQSgZTqnl+p2vDz88PPT0vzKaXKWfc5HNyvpS6qo//VkJMOKXPtjqReqXTpJBHpAwwtdwsCFgMvA4uqOPYTYBQQLSI7gEexZlUGAz+5ypv97ppRORL4PxEpBZzALcaYfRWeWCkPSUhIsDsEpZQvOVTqomVvaD/U7mjqj65nQWgLa3B/59PsjqbeqGoty/eAhViD7/9ujHF7lJ4x5rIKNr9zgn2/BL5099xKKaWUx6UugMwNcP6rWuqiOgKCoc+lsHQy5GdBUx3v7Y6quiz7G2PuMsZ8Up1kTKn6KDMzk8zMTLvDUEr5iiVvWi09vS6yO5L6p/9V4CyFtZ/aHUm9UVXZi8lVncCdfZSqD/Lz88nPz7c7DKWUL9ifahU4HTAJAkPsjqb+ie0ObQdZ3Za64LhbquqyHC8iRZU8L8DoOoxHKaWUst+ytwGBgdfbHUn91f9q+PYOSF8K8YPtjsbnVZWQPeDGORbURSBKKaWUTygpsFp2epwHkXF2R1N/9ZwAsx6yfpeakFWp0oTMGDPVW4EopZRSPmHtNCjK0VIXtRXcFHpdaJUOGfcfCKmw3rty0aJLSrkEBAQQEFBVo7FSqkE7VOqidV9op606tdb/aigthPVaSKEqmpAp5RIfH098fLzdYSil7LTtV8jaaLWOaamL2osbALE9dMFxN7iVkInIcVNMRCS67sNRSimlbLTkTQiNhp4X2B1JwyBitZLtXAm719sdjU9zt4VsmYicfOiBiFyIVbFfqQZj9+7d7N692+4wlFJ22bcNNv0AA6/VUhd1qc8l4B8Eqz6wOxKf5u6AmcuBKSIyD2gDtABqtLi4Ur6qsLCw6p2UUg3XsrfBzx8GXmd3JA1LaHPofi6s+RROe1yT3RNwq4XMGLMOeAK4Bavu2B3GmB2eDEwppZTymu2LYfm70ON8iGhjdzQNT/+roegAbJxhdyQ+y90xZO8AdwN9gGuBGSJyuwfjUkoppbxj84/wwQSr5tjp/7Y7moYpYSREtYeVWk3rRNwdQ7YOGG2M2WaMmQ0MBvp7LiyllFLKC9Z/CZ9eBjFd4doftHXMU/z8oN9VsG0+7EuxOxqf5G6X5YvGHFmMyhiTY4zR9SRUgxIYGEhgYKDdYSilvGX5FPjieqve2DUzIEyLB3hU0uUgfrDqI7sj8UluDeoXkW3AcauDGmM61nlEStmkXbt2doeglPKWBc/DL49D4hkwcSoENrE7ooYvMg46j4XVH8Goh8FfC3GX5+5vY2C5+yHAxUDzug9HKaWU8iBj4OfHYNGL0PtiGP86+GvLuNf0vxqmXQHJP0PXcXZH41Pc7bLcW+6WYYx5ETjbs6Ep5V27du1i165ddoehlPIUpwNm3GMlYwOvhwmTNRnzti5nQFisVu6vgLtdluUH8PthtZhpW6NqUA4ePGh3CEopTykrgek3w4avYPi9cOo/dWkkO/gHQtJlsPgVyNsN4a3sjshnuJtUPVfufhmQCkys82iUUkqpulZSCJ9dDck/wdj/g2F/sTuixq3f1bDoJVj9MYy41+5ofIZbCZkxZrSnA1FKKaXqXFEOfHwppP0G574EAybZHZGK7gzth1lLKQ2/R1sqXSpNyESk0tTVGPN83YajlFJK1ZH8LPjwAsj8Ey5+F3pOsDsidUj/q60u5O2LIGG43dH4hKoG9YdXcVOqwQgODiY4ONjuMJRSdeFAOrw7DrK3wGWfajLma7qfB8GROri/nEpbyIwxj9fm5CIyBTgHyDTG9HJtaw5MAxJwjUUzxuwXEQFeAs4CCoFJxpiVtbm+UtURFxdndwhKqbqQnQzvnw/FeXDVdGg/xO6I1LGCQqH3RVZNsjOfhibN7I7IdpW2kInIj+XuP1yD878HHFto5CHgF2NMIvCL6zHAmUCi63YT8HoNrqeUUqox27UGppwBZUUwaYYmY76s/9XW32ndF3ZH4hOq6rKMKXf/4uqe3BgzH9h3zObzgUOri04Fxpfb/r6x/A5EiUjr6l5TqZrKyMggIyPD7jCUUjW1/Td47xwICIHrZkPrPnZHpCrTJgla9dEFx12qSsiOWy6pDrQ0xhyqvrkbaOm6Hwekl9tvh2vbUUTkJhFZLiLLs7KyPBCeaqyKi4spLi62OwylVE1s+Qk+mABNW8L1s62ZfMr39b8adq+DnavtjsR2VSVkHUXkWxH5rtz9w7faXty1YHm1kj5jzGRjzEBjzMCYmJiqD1BKKdWwrf8SPrkUYrrAdbMgsq3dESl39b7YatHUwf1V1iE7v9z9/9bRNfeISGtjzC5Xl2Sma3sGUH5157aubUoppVTFVrwH390N8UPg8k8hJNK2UKYs3EZBcRkjusTQOy4Sfz+tr1WlJlHQYzys+xxO/7c12L+RqmqW5a8euOa3wDXAU66f35TbfoeIfAoMBnLKdW0qpZRSR1v4Ivz8KCSeDhdPtfXDfMPOHP5vxh8APPfTZiKbBDK8czQjEqMZnhhN22aNN9GoUv+rYO2n8Mc31rJKjZRH16MUkU+AUUC0iOwAHsVKxD4TkeuB7RxZgul7rJIXyVhlL671ZGxKHatJkyZ2h6CUcocx8MvjsPAF6HUhjH8DAoJsDem1uVsJDw7g2zuHs3bHARZuyWb+lixmrrPaFTrGhDEyMYYRidEM7tiCpsG6HPRh7YdB845Wt6UmZJ5hjDnRb/bUCvY1wO2ejEepyrRurZN6lfJ5Tid8fx8snwIDroWznwM/f1tDSs7M5/v1u7j1lE50iA6jQ3QY5yfFYYwhOTOf+VuyWbAli0+XpfHe4lQC/IT+7ZsxMjGaEYkx9Grs3Zsi1uD+nx+zasg10gkZYuVBVewkcrEx5vOqtnnbwIEDzfLly+0MQSmllLc4SmH6LbD+C2sNxFMf9Yl1EO/7bA0z1+1k0YNjaNH0xKt9FJc5WJG6/3CCtmFnLgBRoYEM6xzNyMRohifGEBfVCFvr8/bA891h6B3WAvANlIisMMYMrPA5NxOylcaY/lVt8zZNyFRdSk+3qq60a9euij2VUl5XUgifXwNbfoTTHofhd9sdEQDp+woZ9d95XD2kPY+e27Nax2bnF7MoOZsFrgRtT65VdqdTTBgjEmMY2SWawR1aENZYujc/vQJSF8KdKyAs2u5oPKKyhKyqxcXPxBrXFSci/yv3VARQVnchKmW/0tJSu0NQyl6ZGyGmq0+0Oh2lKAc+vhTSfoNzXoSBvjPE+M35W/ETuGlkx2ofG900mPOT4g53b27JzGf+5iwWbMk+3L0Z6C/0j2/GyC7W+LNebSLxa6jdm2P+AW8Mh9l/gwsm2x2N11WVdu8ElgPnASvKbc8D7vFUUEoppbws7XdryaFRD8Ooh6re31sKsuHDC2DPBrjoHWsQv4/IzC3is+U7uLB/W1pH1q6bUUTo0jKcLi3DuWFER4pKHazYvp/5W7JYuCWbZ2dv4tnZm2h2uHszhuGJ0bRpSN2bsd2sruj5z0DfS6HTGLsj8qqqyl6sAdaIyMfGGG0+UEqphuoPVwWieU9Bu0G+8WGYs8Oqvn8gHS77FBLH2h3RUd5euI0yh5NbTulU5+cOCfRnWOdohnWOhjOPdG/O32x1b85Ya83e7BzblBGJVoI2uGNzQoPqeffmiPtgw1cw4x649bd6U5fM6TQsTd3H4uRs7j29a43O4e5fLkFE/gP0AEIObTTGVL+NVimllG8xBjbOgA4jIT8LvrwRblkAEW3si2nvVnj/fKu78qqvoP1Q+2KpwP6CEj78fTvn9m1DQnSYx693bPfm5j35LNiSxfwt2Xy8JI13F1ndmwPaN7PGnyXG0LNNhNe6N4vLHKzPyCGySSCdY8NrfqLAEDjnBZh6rtVSdtpjdRajJ2zNymf6ygymr8og48BBwoL8uXxwe1pFhlR98DHcTcjexaoh9gIwGqtGWFXLLilVr4SG1o9vYkrVuT3r4UAajHwA2g2GyaPhi+vgmu/AP9D78exaa3VTGgOTZkDrvt6PoQrvLk6lsMTBbaO8X6JBROjaKpyurY50by5P3c+CLdb4s0Pdm83DghjmKk47IjG61t2q5RUUl7EybT/Ltu1jybZ9rE4/QHGZk7Agf768bSjdWkXU/OQdRkLSFbD4ZWtppZbVmyzhafsKSpixdidfrsxgTfoB/ARGJMbw13FdOb1HK5oE1awMi7uzLFcYYwaIyDpjTO/y22p01TqisyyVUqoOzHvKut2/BZrGwNrP4asbYNhfvF+CIO13+GgiBIfD1V9DdKJ3r++GvKJShj01h5M7tmDy1RVOmLNVVp6re9OVoGXlWbM3E2ObMiIxhhFdohncoXrdmwcKS1iWup+l2/ayNHU/6zNycDgNfgI920QyqENz+rSN5ImZfxLo78c3dwwjupISIFUq3AevDLQKxl73I/jZ2wZUXOZgzp+ZfLUqg7kbMylzGrq3juDC/nGc17cNsRHutYjVeJZl+VhExA/YIiJ3YK0x2dTNY5VSSvmyjTMg/mQrGQPoczGkLYZFL0G7k6HbWd6JY8vPMO1KiIyDq76GKN8sQfPh72nkFpVxxxjfLGAaEx7M+H5xjO9ndW9u2pPHgs1WgvbRku1MWbSNIH8/BiY0Y7hr/FmP1kd3b+7OKWJp6j6WbtvLsm372bQnD4CgAD+S2kZx6ymdOKlDc/rHRxEecqQVtUN0GBPf/I2bP1jBRzcMJiSwhkV7Q5vDGU/C9Jth+Tsw6MZa/U5qwhjDyrT9fLkyg5lrd5FzsJTY8GCuG96BCf3i6N66Fq2AFXC3hewk4E8gCvgXVtmLZ40xv9dpNNWkLWSqLqWlpQEQHx9vcyRKedH+7fBSH2th56F3HtleWgRTTof9qXDzAmjW3rNxbJhujV2L7QZXTj+SHPqYolIHw5+eQ/fWEXxw/WC7w6m28t2b87dk8+cuqzht87AghneOJijAj6Xb9pG2rxCAsCB/BiQ0Z1BCMwZ1aEGftpFVJlkz1+7i9o9XckG/OJ6b2BepaRkVY6xxhDtXwe1LIcI7q6ls31vAVysz+Hp1Btv3FtIk0J9xvVoxoV8cwzpH12pVhVq3kBljlrlO5DTG+E4BGKXqUFmZltZTjdCm762fXY9pBQsMsRbsfvMUqyDrdbMhoBZdUJVZMRVm3G2NX7vsU2gS5Znr1IFPl6aRnV/CHaN9s3WsKiGB/gx3LXj+MJCZV2QVp92czYLkbMocTk5KaM7VQ9ozuEMLurcOJ8C/et2FZ/dpzdasLjz/02Y6xTbl9pr+rkSsAf6vD4Uf/gqXfFCz87ihpMzJjLU7+WhJGiu270cEhnZqwV1jEjmjVyuvrD3q1hVEZAjwDlY3ZbyI9AVuNsbc5snglFJKedjGmRDbA1pUULqheQcY/xpMuwJmPwJn/7fur7/of/DTP6DzaTDxA58uc1BS5mTy/BQGtm/GoA7N7Q6nTsSGhzChX1sm9Gtbp+e9c0xnkjPzeXb2JjrFhDGuVw1bt1p0glP+Cr/8H2z8vs67z3MKS/l4aRrvLd7GntxiOsWE8eC4bozv16ZOJ0G4w92U70XgDOBbsOqTichITwWllFLKCwr2wvZFVu2nE+l+Dgy5A357BdoPqbvCrMbAnH/Bgueg5wUw4U0ICKqbc3vI16sy2JlTxBMX9K55N1wjISI8c1Ef0vYVcs+0NbRtFkqvuMianWzoXbDuC/j+fugwwprwUUvp+wp5Z+E2PlueTmGJg+Gdo3n6wj6c0iXGtr+t2+2Qxpj0YzY56jgWpZRS3rR5FhgndDu78v1Oe8zqTvz2LsjeUvvrOp0w8z4rGRswCS582+eTMYfT8PqvW+kVF8GoLr45vs3XhAT6M/nqATQLDeSGqcvJzC2q2Yn8A+HclyB3J8x5olYxrUzbz20freCUZ+fy4e/bGderFd/fNYIPbxjMqK6xtiba7iZk6SIyFDAiEigi92MN8leqwWjatClNm+rkYdWIbJwJEXHQOqny/fwD4aJ3wT8IPrvGWui7phylMP0ma+bcsLuttSn9ajgTz4tmrtvFtuwCbh/VWVvHqiE2PIS3rzmJ3KJSbnx/OUWlNWzLaTcIBl4HS9+EjJXVOtThNMxav4sLX1/MBa8tZuGWbG4a2YmFD47h+YlJ9GhTt7Mla8rdhOwW4HYgDqvkRZLrsVINRmxsLLGxsXaHoZR3lBTC1jlW65g7CUZkHFz4FmT+Ad8/ULNrlh60ylqs+xxOfRTGPu57C5lXwOk0vDY3mc6xTTmjZyu7w6l3erSJ4KVL+7E2I4f7Pl+D01l1dYcKnfYohMXCd3eBo+pJWIUlZUxdnMqY5+Zxy4crycwr4tFze/Dbw6fy0JndalRN35PcnWWZDVzh4ViUUkp5y9Y5UHYQup3j/jGdT7Oq+c9/xhpP1u9K948tyoVPLrPGrJ39PJx0ffVjtskvGzPZuDuP5yf29dpSRA3N2B4teXBcN576YSOdY5pyz9gu1T9JSCSc9Qx8djUsef3oMi3lZOYWMfW3VD78PY2cg6X0i4/iwXHdOKNnq1qVrPC0ShMyEXkZOGEqa4y5q84jUsomqampACQkJNgah1JesXEmhERVf43IUQ9B+u8w835o08+9ZW0KsuHDC60lmi58G3pfVKOQ7WCM4ZW5ybRr3oTz+tq4tmcDcPPIjiRn5vPSL1voFNu0Zr/P7udBlzNh7pPW/XL18TbuzuXtBdv4dvVOSp1OTu/RkptGdmRA+/oxI7aqFrLyVVcfx1rPUqkGyel02h2CUt7hKIPNP0CXcdVfq9LPHy58B94YbrVU3DSv8llvORnwwXhrrcxLP4YuZ9Qmcq9bvHUva9IP8MSEXtWux6WOJiI8MaEXaXsLuf/zNbRr1oR+8c2qexI461l4dTB8fz/msmksSN7LWwtSWLAlmyaB/lw6qB3XDevglUXf61KlCZkxZuqh+yJyd/nHSiml6qm03+Dg/qpnV55I01i4aApMPdeaeXnRlIrHgu3dCu+Ph6IDcNX06rfG+YBX5iQTGx7Mhf3rtk5XYxUc4M/rV/Zn/GuLuPH9FXx7xzDaRFWz3ldUO4pP+TvfzvqBd56ZycYDfsSEB/PAGV25YnA8UaG+PWP3RKqT7tdwFJ5SSimfsnEmBIRA51Nrfo6E4TDmH7DhK1j29vHP714HU8ZBaQFc8129TMZWbN/Pbyl7uWlkx5qvyaiO06JpMO9ccxLFpQ6un7qcgmL3V0k5UFjCq3OTGfFrFx4ouwWTt5tnz+/MwgdHc/vozvU2GYPqJWRKKaXqO2OshKzjaAiqZZfOsLsh8QyY/bejSxGkLYH3zra6Q6+dBW2Sancdm7w6N5lmoYFcPljXt61rXVqG8/Ll/di0O5d7pq2ucubl9r0FPPrNeob8Zw7Pzt5E11bhTD2/BbMC/8rF2a8RHFD/E+aqBvXncaRlLFREcg89BRhjTLWLd4hIV2BauU0dgX9iLVx+I5Dl2v43Y8z31T2/UjUVEeEbtWiU8qjdayEnzVqOprb8/GDCG/DmSGu9y5vnW4nZtCshvDVc/TVE1c9kZsPOHOZszOS+sV0IDfL8OoaN0aiusfzjnB48/t0fPPvjJh4c1+24fVZs38db87cx+4/dBPgJ5/WN44YRHeje2vV+nXubtYpEn0utmb/1WFVjyGq/PsHx59yEVccMEfHHqms2HbgWeMEY44HF0pSqWnR0tN0hKOV5G2eC+EHXM+vmfKHN4eL3rO7J98fDng0Q0w2u+soaa1ZPvTZ3K+HBAVw9NMHuUBq0SUMT2JKZz+vzttIppikXDWiLw2mYvWE3by1IYVXaASKbBHLrKZ24ZmgCLSOOqR026mH441trcfqbF/j8ig+VsTvtPxXYaozZrpWPlVLKCzbOhHYnQ1gdfgFpOxBO/zfMetA69+XToElU3Z3fy5Iz8/l+/S5uPaUTkU2qOQtVVYuI8Ph5PUnNLuDhr9aSml3At2t2kravkPjmoTx+Xk8uGtCWsOATpCvBTeHs5+Dji2HRS3BKDYsW+wC7x5BdCnxS7vEdIrJWRKaISIVzYUXkJhFZLiLLs7KyKtpFqRpJSUkhJSXF7jCU8px926xaYDWdXVmZwTfDpJnWbMp6nIwBvD5vK8EBflw/vIPdoTQKgf5+vHZFf9o2C+WVucnEhAfzxpX9mXv/KK4ZmnDiZOyQLqdDzwkw/1nITvZO0B5gW0ImIkHAecDnrk2vA52wujN3Ac9VdJwxZrIxZqAxZmBMjC7wqpRSbtvkGpbb7ay6P7eINfMyKLTuz+1F6fsK+Xp1BpcNiqdF02C7w2k0okKD+OzmIcy4czhf3jqUcb1aV6+q/rinrZnDM+62Jq7UQ24lZCLytDvbqulMYKUxZg+AMWaPMcZhjHECbwGDanl+pZRS5W2cCbE9oXlHuyPxWZPnp+AncNNI/R15W0x4ML3iImt2cHhLGPsYpC6A1R/XaVze4m4L2dgKttV2ROhllOuuFJHW5Z6bAKyv5fmVUkodUpBtFYTtXo21KxuZzNwipi1P58L+bWkdWc1ipcp+/SdZYxh/fMT6917PVJqQicitIrIO6Ooa23Xotg1YW9OLikgYVpL3VbnNz4jIOhFZC4wG7qnp+ZVSSh1j8ywwTs+MH2sg3l64jTKHk1tO6WR3KKom/Pzg3BehOB9mP2J3NNVW1SzLj4EfgP8AD5XbnmeM2VfTixpjCoAWx2y7qqbnU6ouREbWsKlcqfpg40yIbAet+tgdic9ZlbafyfNTmLVhN+f1bVPv1kBU5cR2h+F3WwP8+14KnUbbHZHbqqpDlgPkAJe5aoa1dB3TVESaGmPSvBCjUl7RokWLqndSqj4qKYCtc2DApIrXnGyEnE7DnI2ZTJ6fwtLUfYSHBHDLKZ24dZS2jtV7I+6H9V/BjHvgtt8gsH50P7tVh0xE7gAeA/YATtdmA+hXLdVgOJ3WP20/P7urwShVx5J/gbKiKrsrcw6WNvi6W8VlDr5elcFbC7aRnJlPm8gQ/n52dy4dFE/TqsorqPohMATOeQHeP89qKTv1n3ZH5BZ3//XdDXQ1xuz1YCxK2So1NRWAjh11dpVqYDbOhJAoiD/xAt+z1u/ito9W8tdx3RrkGKqcwlI+XLKd9xankpVXTPfWEbx4SRJn92lNoL9+CWtwOp4CfS+3isX2ugha9rA7oiq5m5ClY3VdKqWUqk8cpdaA/q5ngn/Fb/m7c4p46Kt1BPj58fSsjSS0CGNcr1ZeDtQzMg4c5J0F25i2LI2CEgcjEqN5fmJfhneORleIaeBO/7f1b/+7v8B1s61B/z7M3YQsBZgnIjOB4kMbjTHPeyQqpZRSdWP7Yig6cMLuSqfTcP/naygudfLNHcP42/R13D1tFZ9HDaV32/o70WXDzhwmz09hxtpdAJzbpzU3juxIzzb19zWpagprAWc8CV/fAiumwEk32B1RpdxNyNJctyDXTSmlVH2wcaZVwbzTmAqffndxKguTs3liQi+6t45g8lUDGf/qIm54fxnf3D6cVpEhFR7ni4wxLNiSzeT5KSxMziYsyJ9JQxO4bngH4qLqx8BuVcf6XgprPoGfH4euZ0NE66qPsYlbCZkx5nEAEQk1xhR6NiSllFJ1whgrIes0BoKOL+WwcXcuT8/ayGndW3L5oHjAqpb+zqSBXPjaYm54fxmf3TyE0CDfHuxe6nAyc+0u3pyfwp+7cokJD+av47pyxaD2RIY27EkKqgoi1gD/14fCrAdh4vt2R3RC7i6dNERE/gA2uh73FZHXPBqZUl7WrFkzmjWrcE17peqnXWsgd0eF3ZVFpQ7+8slqIkICefrC3keNp+rWKoKXL+/HHztzuWfaapxO31wbML+4jLcXpHDKM3O5e9pqSh1OnrmwDwsfHM1tozprMqYsLTrByAfgj29g0yy7ozkhd7/2vAicAXwLYIxZIyIjPRWUUnbQZEw1OBtngvhBl3HHPfXMrE1s2pPHu9eeVOEi2mO6teTvZ/fg/2b8wbM/buLBcd28EbFbMnOLeHdxKh/+vp28ojIGdWjOv8b3YnTXWPyqsyC1ajyG3gXrvoDv74eE4RDc1O6IjuN2O7QxJv2YGSmOug9HKfuUlZUBEBDg290zSrlt40yIHwJh0Udtnr85iymLtnHNkPaM7hp7wsOvHZbA1qx8Xp+3lQ7RYUwc2M7TEVcqOTOPyfNT+HrVTsqcTsb1asVNIzuR1C7K1rhUPRAQBOe+BFNOh7lPwrgn7Y7oOG6XvRCRoYARkUDgL8CfngtLKe9LS7MWntA6ZKpB2JcCmRvgjP8ctXl/QQn3f76GzrFNefis7pWeQkR47LyebN9byCPT1xHfPJSTO3p3RQtjDEu37WPy/BR+2ZhJSKAfl5zUjhtGdKB9C13iSFVD/GAYeB0seR36XAxt+tkd0VHcLcpxC3A7EAdkAEnAbR6KSSmlVG1tnGn97HbW4U3GGB7+ah37C0t46dIkQgL9qzxNoL8fr17Rn/jmodzy4QpSsws8FfFRHE7D9+t2Mf61xVwy+XdWpR/g7tMSWfzQqfxrfC9NxlTNnPoohMXCt3eBo8zuaI7ibkLW1RhzhTGmpTEm1hhzJVD5VyullFL22TgTWvaGZgmHN32+fAezNuzm/tO7VqseV2STQKZMOgkBrpu6jJzC0rqP1+VgiYMPfktlzHPzuO2jlRwoLOFf43ux6MEx3H1aF5qHaeUlVQtNouDMp2H3Wljyht3RHMXdhOxlN7cppZSyW34WpP1+1OzK1OwCHvtuA0M6tuDGEdXvlm/fIow3rxpI+r5Cbvt4BaUOZ9UHVcPe/GJe+Gkzw56ewz++2UCz0CBev6I/c+4bxVUnt6dJUNWteUq5pcf51kSXuU/AgTS7ozms0jFkIjIEGArEiMi95Z6KAPR/h1JK+aLNPwDmcEJW5nBy97TVBPgJz03sW+OZiIM6NOc/F/Th/s/X8M9vNvDkhF61Xn4oNbuAtxem8PnyHRSXOTmteyw3jezESQnNdGkj5RkicNZ/4dXBMPN+uHyatc1mVQ3qDwKauvYLL7c9F7jIU0EpZYcWLbw7WFkpj9k4EyLjoVVvAF6ek8zq9AO8cnk/2tSyYv1FA9qSkpXPa/O20ikmjBtq0NoGsCptP5PnpzBrw24C/fyY0C+OG0d2oHNseNUHK1VbUe1gzCMw+2/wx9fQc4LdEVWekBljfgV+FZH3jDHbvRSTUraIjNQ17lQDUJwPW+das8lEWLF9Py/P2cIF/eI4p0+bOrnE/ad3JSWrgCe+/5OEFmGc1qOlW8c5nYY5GzOZPD+Fpan7iAgJ4NZTOjFpaAKxEfVniSbVQAy6GdZOgx8ehI6jrfFlNnK37EWhiDwL9AQO/68xxlS8OJpS9VBJSQkAQUE6aFjVY1t/AUcxdDub/OIy7pm2mjZRTXj8/J51dgk/P+H5S/pyyZsHuevTVXxxy1B6tIk44f7FZQ6+XpXBWwu2kZyZT1xUE/5xTg8uOakdTYO17p+yiX8AnPs/eGs0/PK4tcSSjdwd1P8R1rJJHYDHgVRgmYdiUsoWO3bsYMeOHXaHoVTtbJwJTZpB/BAe+3YDO/YX8uIlSYSH1O0yQqFBAbx9zUAiQgK5YeoyMvOKjtsnp7CUV+cmM/zpuTz45ToC/f148ZIk5j0wiuuHd9BkTNmvTRKcfBssn2JNhLGRuwlZC2PMO0CpMeZXY8x1gLaOKaWUL3GUwuZZ0OVMvv8jiy9W7OD20Z0ZmNDcI5drGRHC29cMZH9hKTe+v4KiUmsBl4wDB/m/7/5g6FO/8OzsTXRrFc4H1w/i+7uGM75fHIH+7n70KOUFox6GyHbw3V+grMS2MNz9enKo6MwuETkb2Al45n+4Ukqpmtm+CIpy2N3ubB7+ah1920Zy16mJHr1kr7hIXrw0iVs+XMGdn6wiLMif79buAuDcPq25cWTHatU8U8rrgpvC2c/BxxNh0UtwygO2hOFuQvZvEYkE7sOqPxYB3O2poJRSStXAnzNw+ody38rmlJTl8sIlSV5pjTqjZyseGteN//ywkbAgfyYNTeC64R2Iq+WMTqW8pssZ1kzLuf+GjOUw8q/QdoBXQ3ArITPGzHDdzQFGA4jI3bW5sIikAnlYi5SXGWMGikhzYBqQgDVObaIxZn9trqOUUo2CMbBxJlMib2NRyn7+c0FvOsY09drlbxrZkd5tI+nZJpLIJnU7Xk0przj/VYjtCb+/Cm+PsWZenvJXaD/UK5evzVene6vepUqjjTFJxpiBrscPAb8YYxKBX1yPlfKK6OhooqOj7Q5DqeozBpa8wZ85/jyzux9je7Tk0pPaeTUEEWFop2hNxlT9FRRmdVfevQ5Oexz2rId3z4R3z7JKyRjj0cvXJiHzRFnb84GprvtTgfEeuIZSFYqIiCAi4sRT95XySQV74dMrKPrhH9wtDxIZGszTF/bRKvdK1VRwOAy/G/6yFsY9BftS4IPx8M5Y2DzbY4lZbRKy2kZkgB9FZIWI3OTa1tIYs8t1fzdwXLVBEblJRJaLyPKsrKxahqDUEcXFxRQXF9sdhlLuS5kHrw+F5J94sd3/2FTcnGcv7qsLcCtVF4JC4eRb4a7VcPbzkLfHGvg/+RT48ztw1u16rpUmZCKSJyK5FdzygNqWfB5ujOkPnAncLiIjyz9pjDFUkPQZYyYbYwYaYwbGxMTUMgSljsjIyCAjI8PuMFR9lZMBm36A0uPrcdW5shL46Z/w/ngIiWDdud/zVkoUlwxsx6iusZ6/vlKNSWAInHQ93LUSznsFinJh2pXwxjBY9wU4HXVymUoTMmNMuDEmooJbuDGmVhX9jDEZrp+ZwHRgELBHRFoDuH5m1uYaSinlUU4nJP8Cn14BL/aCTy6F/yXBkjc9l5hlJ1tdJ4teggGTKLluLg/MO0h00yD+dnZ3z1xTKQX+gdD/KrhjOVzwlpWIfXk9vDoIVn9s1QGsBVuq84lImIiEH7oPnA6sB74FrnHtdg3wjR3xKaVUpQr3weKX4ZUB8OEFkPYbDPsLXPIRNO8IP/wVXuoLv78OpQfr5prGwMoP4M0RcGA7XPIhnPsib/y2i4278/j3+N46oF4pb/APgD4T4bbf4eKpENAEvr4VXh4Ay9+FspoNfbFr3YqWwHTXoNMA4GNjzCwRWQZ8JiLXA9uBiTbFp5RSRzMGMlbCsrdhw1dQVgTtToZRf4Me50FAsLVf93Ng2wL49WmY9RAsfMFK1gZca41JqYmD++G7u+GPryFhBFwwGSLasHlPHi/P2cK5fdsw1s0FvpVSdcTPD3qOhx7nWytk/PqM9X++61kQXv3/j2I8PI3TkwYOHGiWL19udxiqgUhJSQGgY8eONkeifEpJIaz/wkrEdq2BoKbWt+OB10OrXpUfm7oQ5j0FqQsgLNZKzAZeV73ELHURfHUT5O+GMX+HoXeBnz8Op+GC1xeTvq+Qn+4ZSYumwbV7nUqp2jEG9iZD9IlXxxCRFeVKfR1FV3ZVyiU2VgdDq3KyNlsLDq/+GIpzIKY7nPVf6HMJhLhZHiVhOEyaAdsXW4nZj4/AohetpOqk6626RyfiKLVa2RY8B80S4PofIe5I5fApC7exJv0A/7usnyZjSvkCkUqTsSoP1xYypZRycZTCxplWa1jqAvALtLojT7oB4odYb7i1sf03+PUpq1xFaDQMvdM6d/AxFfX3bYOvboQdyyDpCjjzaas2kktqdgFnvDifEYkxvHX1AK05plQ9oS1kSrnh4EFr8HWTJrr+XqO0dS5Mv8XqGoxsB2P+Af2vhqZ12HLafghc/Q2kLbESs58fhcX/gyF3wKAbraRrzTSYeR+IH1w0BXpdeNQpnE7Dg1+uJSjAjycm9NJkTKkGouEnZNnJsO4z6HcVRHl3KRFVv+zaZdUk1jFkjdCeP2DaVRAZB+e+CImng5+/564XPxiumg7pS62uzF8et2ZttkmCrXOsyQIXvgVR8ccd+vHSNJZs28fTF/amZUSI52JUSnmVLWUvvMlsm0/ZvP/Ci73hwwvhj29rXStEKdWA5GfBJ5dY47mu/BK6nunZZKy8doPgqq/g+p+t8WEpv1qzNifNrDAZ23ngIE/9sJHhnaOZOFC/YCrVkDT4FrJfI87h0SbtuKvtFsbvfhn/z66yZjv1u8LqjmiurSFKNVqlRfDp5VZSdu33ENnWnjjanQRXfmHVLwqoeIC+MYa/TV+Hw2n4zwW9tatSqQamwbeQNQn0J6xJCPetb89YXue7wZ/gbDPAqnL9v34w9Vxr6YMaFnJTStVTxsA3t8OOpTDhDYjrX4tTGV6bl8ygJ37muzU7ax7TCZIxgOmrMpi3KYu/jutKu+Y1rGemlPJZDT4hG9yxBTPuHM7rV/QnwF+481fDWVm3MeusRZhRf4d9qdbSB891g1l/g6xNdoeslPKGX5+26oud+k+ruGMNOZyGx77dwDOzNuE0hjs/WcU/v1lPcVndrG8HkJlXxOPf/cGA9s24ZkhCnZ1XKeU7GlXZC4fTMGPtTl76eQsp2QX0iovg3lMTGR24Dln5Pmz6Hpxl1vT2/tdY1XdrWllb1TuFhYUAhIbq37zBW/eF9UWs7+Uw/rUal7MoKnVw32drmLluFzcM78AD47ry39mbeGvBNnrHRfLaFf3rpDXr1g9X8MvGTL6/awSdY5tWfYBSyidVVvaiUSVkh5Q5nHy9eicv/bKZ9H0HSWoXxX2nd2F4Kyey5hNYORX2pUBwpFWRe8A10Kq3B16BUsrr0pfCe+dYg+iv/rrSbsLK5BaVctP7y/k9ZR+PnNWdG0ceGY/644bd3P/5Ggzw34v7ckbPVjUO94d1u7j1o5X8dVxXbhvVucbnUUrZTxOyEyh1OPlixQ5e/mULO3OKGJTQnHtP78LJHZpbS56snAp/fAOOEmjTHwZMsmoCHVvEUTUI2kLWCOzfDm+Nsep93fALhLWo0Wn25BZxzZSlJGfm89+L+zK+X9xx+6TvK+T2j1eydkcONwzvwINndiPQv3qjRA4UlnDa8/NpFRnM17cNI6CaxyulfIsmZFUoLnMwbVk6r8xJJjOvmGGdW3Dv2K4MaN8MCvfBmk+t5Cxro7WOXa8LrVazNv1rX7lb+Qxdy7KBK8qBd86AvJ1WmYmYLjU6zdasfK5+ZykHCkt4/coBjOwSc8J9i8scPDnzT6b+tp1+8VG8cnl/4qLcLzx872er+Xb1Tr69Yzg92ri5XJNSymdpQuamolIHH/6+ndfnbWVvQQmjusZw39iu9G4bac3ISl9qJWbrv4Kyg9Cyt5WY9b4YmkTVWRzKHpqQNWCOMqvWWMo8q9ZYx1E1Os3KtP1c/94y/P2EdycNst4b3DBz7S4e/HItAf7CCxOTGN2t6ur/czdlcu27y7hzTGfuO71rjeJVSvkWTciqqaC4jKm/pTJ5fgoHCksZ26Ml947tQvfWrm+oRTmw7nNY8R7sXgcBTaDnBCs5azdYW83qKU3IGrDvH4Clk+Hcl6yhBzUwZ+MebvtoJS0jQnj/ukG0b1HJwuAV2JZdwG0freTPXbncOqoT943tcsIuyLyiUs54YT5hwQHMuGs4wQFeKlSrlPIoTchqKK+olCkLU3l7QQp5xWWc3ac195yWSOdY1yK/xsDOVVar2bovoCQfYrpZBWf7XgahzT0Wm6p7mpA1UEsmww8PWOtFnvFEjU7x2bJ0Hp6+jh6tI5gy6SRiwms2EaCo1MHj323gk6XpDOrQnJcv61fh8kd//3odHy1J48tbh9I/vlmNrqWU8j2akNVSTmEpby1I4d1F2zhY6uD8pDj+cmoiCdHlviEX58OGr2DFVMhYDv5B0P08q9UsYYS2mtUDmpA1QFt+go8nQpdxcMmH1V4SyRjDq3OT+e+PmxmRGM3rVw6gaXDtFzj5auUOHpm+ntAgf166tB/DE6MPP/d7yl4unfw71w/vwD/O6VHraymlfIcmZHVkX0EJb/66lam/pVLqMFzYP447xyQeX2do93qr1WztNKt7s3lHq9Us6QpoWvXYEWWPgwcPAtCkifuDrpUP2/MHvHM6NE+Aa2dVe3a0w2l4/LsNvP/bdsYnteGZi/oSFFB3sxy37Mnj1o9WsjUrn7vGJHLXqYmUlDkZ99J8jIHZd4+kSZB2VSrVkGhCVscy84p4fd5WPlqShjGGiQPbcceYzrSOPOaDvPSgVTZjxVRIWwx+AdbCxf0nQafR3lvAWKnGJj8T3jrVKllz4xyIPL4sRWWKSh3cM201P6zfzU0jO/LQuG74+dV9K3dhSRl/n76er1ZlMKxzC+Kbh/LJ0nQ+vnEwQztFV30CpVS9ogmZh+zKOcirc5OZtiwdEeGKwfHcOqoTseHHjwkha7PVarbmEyjcC5Hx0P8qq9Wsmh8WyjPy8/MBaNpU68zZInMj7F4LzTtZJSmCw2t2ntKD1hq1u9dbC4ZXc43KnIOl3Pj+cpZu28ffz+7ODSM824VtjOGz5en885sNFJc5uXxwPE9O0ELUSjVEmpB5WPq+Ql6es4UvV2YQ6C9cMySBm0/pRPOwoON3LiuGjTOtGZrbfgXxg8TTraWaEk8H/9qPT1E1o2PIbLJjBSx8HjbOOHp7RBzEdLUmykR3sX7GdK18sowx1pJI67+EiR9Aj/OqFcrunCImvbuUrVlWwdfzk7z3ZemPnblMX7WDu05NJDwk0GvXVUp5jyZkXpKaXcBLv2zh69UZhAb6c+2wDtw4oiORoSd4c92XAis/gNUfQf4eCG9ttZj1vwqaJXg1dqUJmVcZA9vmw4LnrC8mIZEw+Bbofq5VTT9rI2Rvdv3cAqWFR44Ni4Horq5kreuRpK1pS5j3FPz6FJz6KIy4161Qikod/Lkrl/U7c3lj3lYOFJbw5lUDjxpor5RSdUETMi9LzszjhZ+3MHPtLsJDArhheEeuG55w4m+9jlLYPNvq0kz+2fqw6jTaajXrehYEVNDSpuqcJmRe4HTC5h9gwfPWbOSmLWHI7TDwuhN3UTqdkJMOWZsge5OVpGVtth4X5xzZLzjSepx0JZz/SoUzm/OLy6zkKyOHdRk5bMjIJTkrH4fTeh+Mi2rCm1cNoFecewVflVKqOnwqIRORdsD7QEvAAJONMS+JyGPAjUCWa9e/GWO+r+xcvpqQHfLnrlxe+GkzP/6xh6jQQG4a2ZFJQxMIDaqkWzJnB6z60Go5y90BodGQdLmVnEXrwsKepAmZBznKrLIwC56HrD8hKh6G3W21CAdWMObSHcZYLctZG63kLGsTBIXCmH9CQBA5B0vZkJHD+p05rM/IZf3OHLZlF3DoLS+6aTC94yLoFRdJzzaR9IqLIC6qCaIlapRSHuJrCVlroLUxZqWIhAMrgPHARCDfGPNfd8/l6wnZIet25PD8T5uYuymLFmFB3DqqE1ee3J6QwEpmWTodsHWONdZs0w9gHNB+uFXXrPt5Nf8QUyekCZkHlBZZXfKLXoID2yGmu9WV2POCao+XLClzcrDEQWFpGQXFDg6WOCgoKTv8s7DEQVZeMRtcCVjaviPdnG0iQ+gZF0kvV+LVOy6S2AoKsiqllCf5VEJ2XAAi3wCvAMNooAnZISu27+f5nzaxKHkvseHB3DGmM5ec1K7qZVHydlsfaivfh/2p0KQZ9LnUSs5iu3sl9saguLgYgODgmlVhb8z2FZSwJv0AO/YXUuowlJUcpCxtOWVpSygrPkhZeFscbQdTGpmAw2kodRocDkOp00mZw1jbHE5KHE4KS45JtorLOFjqoNTh3ntVfPNQerlavnq1iaRnmwhaNNW/qVLKfj6bkIlIAjAf6AXcC0wCcoHlwH3GmP0VHHMTcBNAfHz8gO3bt3sr3Drze8penv9xM0tT99EmMoQ7T03kogFtCTzBunaHOZ2QOt+qa/bnd+AshbaDrMSs5wQIqt7aekrVRFGpgw07c1mTfoDVrlv51qiKBPoL/n5CoJ8fAf6Cv5/fkW3+fvj7CQF+QlCAH6FB/oQGBdAkyJ8w131rmz9NggIIC/J3PRfg2uZPWHAATQL9iQoN1BmKSimf5ZMJmYg0BX4FnjDGfCUiLYFsrHFl/8Lq1ryusnPUtxay8owxLEzO5rkfN7M6/QDxzUO569RExie1OeGCw0cpyLZqmq2YCnu3QHAE9L7IGmvWJsnj8TdEubm5AERERNgcie9wOg3b9hawOs1KvNbsOMCfu3IPt1a1jgwhKUboG7KHpNLVdNrxNUFleQR0GYv/sDsJjB+An6DjspRSCh9MyEQkEJgBzDbGPF/B8wnADGNMr8rOU58TskOMMczdlMlzP25mw85cOkaH8ZfTEjm3Txv3KoMbA2m/WYnZH19DWRG0TrJazXpdBCGaXLhLx5BBdn7xUS1fa9IPkFtUBkBYkD994sJJiiygryTTr2ARLXf/CiV51sHhraHTGBh6p3alK6VUBXwqIRPrq/JUYJ8x5u5y21sbY3a57t8DDDbGXFrZuRpCQnaIMYbZG/bwwk+b2bQnjy4tm3LPaV04o2cr95dsObgf1n5ulc/Ysx4CQ6HXBdZSTW0H6gLnVWhsCVlRqYP1GTmHk6/V6QfYsd9az9PfT+jSMpykloH0C9lNUtkaOmXPxX/PWmuCCQKxPSB+MMQPgXaDrZmT+m9MKaVOyNcSsuHAAmAd4HRt/htwGZCE1WWZCtx8KEE7kYaUkB3idBpmrNvFiz9vJiWrgB6tI7h3bBdO7R7rfrePMZCxEla8C+u/gtIC6HQqnPEkxHbz7AuoxxpyQuZ0GlKy81mVdiT52rQ7j7Jy9bf6to0gqVkxSX7J9Mr7jdCMRZCTZp0goImV1LcbDPEnQ9uToEmUfS9IKaXqIZ9KyOpSQ0zIDilzOPlm9U5e+mULafsK6dsuinvHdmFkYnT1xuMU51ndmfOfgeJ8OOl6GPVw5cvPNFINKSHLzCtidZo15mt1+gHWpueQV2x1PYYHB9CnXSR9W4eRFJpJUslaYrMWQvpSKLbG0dG05ZHkq93J0LoP+OtgeaWUqg1NyOqxUoeTL1fs4OU5yWQcOMhJCc24d2xXhnRqUb0TFeyFeU/C8inWBIBRD1vJmX7IHmZXQmaMobjMKvlQXHrop8PaVuYs99Nx+PHR94/sk76vkNXpB8g4cKTrsVurcJLaRdE3RugnyXTKXYJf+u/WQt5OK0kjprvV/djuZOtnsw7a/aiUUnVME7IGoLjMwWfL0nllbjJ7cosZ2qkF953ehQHtq9nStecPmP0wpMyzFmw+40lIHOuRmH2dMYZShzmc3BQWlVDicFJm/I5KeA4lQ8cmP0clRaVOShyOcgmV62dZBdtKHYcfH0rE6kKQvx8x4cEkxUfRr20kfcNz6VW8iiY7l0D671YNO4CAEIgbcHT3o7aYKqWUx2lC1oAUlTr4aEkar89LJju/hFO6xHDv2C70bRfl/kmMgc2zYPYjsG8rdB4LZzxhLdLsBcYYypymwtae45KfCpKYI8nM8ccdleiUO9fRrUlHjqsLgf5CkL8fwYH+rp9+BAf4ERTgR3DAkW2H9jny3JF9gl2Pjzru2H38hSApI9gUE2SKCTZFBJkigh0HCXIW4ld20FqIO32JdStyrfMYGm0lXoe7H/vq+qhKKWUDTcgaoMKSMt7/bTtv/rqV/YWlnNa9JfeO7UKPNtUoc1FWAksnw6/PQEk+DLoRTnnwcGuJw2nYkpnHhoxc8opKj0lsjk2Gjmw/uqvNUWGrkrMO/tn5+8lRyc3xSYwfQeWSnWOTn2OPiwl2EOAvlPo1Kffc8QnSoWMOJVmHZ8EaA6UHobTQupUUWhMqSg8ec7/gyH7l7x8+5kTHF2LNealCdJcjyVf8ydC8o3Y/KqWUD9CErAHLKyrlvUWpTF6QQl5RGWf1bsU9p3UhsWW4+ycpyIa5T7B7+Tes9u/N6jaXsbosnnUZuRSUOI7bXYTjEqDyyc9xiUsFLUKVHRd0TMITEuhHkL//US1PQf5+7hXQLc/pdCU7BytMlFJKmoHTSceideUSpQLXPhUfc1QCVVp5tfoKBYRAYBMIDLN+BoUec991C3JtO/Z+YOjRx0S00e5HpZTyUZqQNQI5haW8vTCFKQu3UVjq4Ly+bfjLqYl0jGla4f4FxWWs3ZFzuPjn6vQD7M4tAiCQMroH7iEpsR1JvXrTp20kzcOCDydDAX7imcrrTseRhKmkoIL7hUcnR0clQxUdc0wrVNnBSi+fcsrLAHT89c4jGwOOSYwCm7gSovL3j02UKkquTnCMXxXrmCqllGowNCFrRPYVlPDm/K28v3g7JQ4nE/rFccfozhwsdRyVfG3ek3e427B9i1BrFl7bKJLaRdIj7zdCfnkE9m+DxNOtgf/RieAoO7o16LjutSruV/hcueTKUVz9FxwYekxLUfn7ruTouPsVJVehpBQEg/jRsU2MtV9AE/CrZiucUkopdQKakDVCWXnFvD5vKx8u2U5JucHrUaGBrsQriqR4KwlrHlbBAO+y4qPHl/kFgKOkmlHICbrXqrh/TKJU6X512FLXkOqQKaWU8j2akDViu3OKmL4qw1oEul0U7VuEVq+7MT8Llr9jtWRVNnapovFOASH1ajC5JmRKKaU8SRMypdxQVmYVSQ0ICLA5EqWUUg1RZQmZfvIo5aKJmFJKKbvoiGWlXPbv38/+/fvtDkMppVQjpAmZUi6akCmllLKLJmRKKaWUUjbThEwppZRSymaakCmllFJK2UwTMqWUUkopm+k8f6VcEhIS7A5BKaVUI6UJmVIufrpupVJKKZvoJ5BSLnv37mXv3r12h6GUUqoR0oRMKZecnBxycnLsDkMppVQjpAmZUkoppZTNfC4hE5FxIrJJRJJF5CG741FKKaWU8jSfSshExB94FTgT6AFcJiI97I1KKaWUUsqzfCohAwYBycaYFGNMCfApcL7NMSmllFJKeZSvlb2IA9LLPd4BDC6/g4jcBNzkepgvIpu8EFc0kO2F6/iSxviaQV93Q9XQX19lGttrb2yv95DG9rrr6+ttf6InfC0hq5IxZjIw2ZvXFJHlxpiB3rym3RrjawZ93XbH4SkN/fVVprG99sb2eg9pbK+7Ib5eX+uyzADalXvc1rVNKaWUUqrB8rWEbBmQKCIdRCQIuBT41uaYlFJKKaU8yqe6LI0xZSJyBzAb8AemGGM22BwWeLmL1Ec0xtcM+robqob++irT2F57Y3u9hzS2193gXq8YY+yOQSmllFKqUfO1LkullFJKqUZHEzKllFJKKZtpQgaIiBGR58o9vl9EHrMxJI8SEYeIrBaRDSKyRkTuE5FG9W9BRPLtjsGbyv3ND90SKtl3nojUq+nkrv/DH5Z7HCAiWSIyw864vEVExrt+B93sjsVTGvvf+JDG9t51SFWvuz6+bx2rUX0IV6IYuEBEou0OxEsOGmOSjDE9gbFYS1U9anNMyrMO/c0P3VLtDqiOFQC9RKSJ6/FYqlkyR0R8apJTNV0GLHT9dJtrubr6otZ/Y6V8mSZkljKsGRv3HPuEiCSIyBwRWSsiv4hIvIhEisj2Q61KIhImIukiEujtwGvLGJOJtfLBHWLxF5FnRWSZ6zXffGhfEXlQRNa5WtWesi/quiEiTV1/05Wu13W+a3uCiPwpIm+5WhF/LPch0GCIyAAR+VVEVojIbBFpXe7pq1wtaetFZJBtQVbP98DZrvuXAZ8cekJEBonIbyKySkQWi0hX1/ZJIvKtiMwBfvF+yLUnIk2B4cD1WKWCEJFRIjJfRGaKyCYReaPc+1W+iDwnImuAIfZFXiM1+RvPF5GkcvstFJG+3gy6rrn+vjPKPX5FRCa57qeKyOPl3tcaTKtpZa+7IdCE7IhXgStEJPKY7S8DU40xfYCPgP8ZY3KA1cAprn3OAWYbY0q9FWxdMsakYJUZicV6U88xxpwEnATcKFZduDOx1hUdbIzpCzxjW8B1pwiYYIzpD4wGnhMRcT2XCLzqakU8AFxoT4h1pkm57srpri8PLwMXGWMGAFOAJ8rtH2qMSQJucz1XH3wKXCoiIUAfYEm55zYCI4wx/YB/Ak+We64/1u/hFOqn84FZxpjNwF4RGeDaPgi4E+gBdAIucG0PA5YYY/oaYxZ6Pdraqcnf+B1gEoCIdAFCjDFrvBaxPbJd72uvA/fbHYxyT31uoq9TxphcEXkfuAs4WO6pIRx5I/uAI4nINOASYC7Wt9LXvBSqp50O9BGRi1yPI7GSk9OAd40xhQDGmH02xVeXBHhSREYCTqy1VFu6nttmjFntur8CSPB6dHXroCvBAkBEegG9gJ9cOag/sKvc/p8AGGPmi0iEiEQZYw54L9zqM8asFWts3GVYLSnlRQJTRSQRMED51uyf6vm/58uAl1z3P3U9ngEsdX3ZQkQ+wWpF+wJwAF/aEGet1fBv/DnwDxF5ALgOeM870drqK9fPFRz5/FI+ThOyo70IrATedWPfb7E+zJsDA4A5HozLo0SkI9abdCZWknKnMWb2MfucYUdsHnYFEAMMMMaUikgqEOJ6rrjcfg6goXVZCrDBGHOiLqtjCxTWl4KF3wL/BUYBLcpt/xcw1xgzwfWBPq/ccwXeCq6uud5/xgC9RcRgJdYGmMmJ/4ZFxhiH96Ksc9X6GxtjCkXkJ6yWxIlY79f1XRlH93CFHPP8ofcvBw3rc76q112vaZdlOa5vyZ9hddsdshjXuAysD/AFrn3zsZZ6egmYUV/f4EQkBngDeMVYVYJnA7ceGg8nIl1EJAz4CbhWREJd25vbFXMdigQyXcnYaKC93QF50SYgRkSGAIhIoIj0LPf8Ja7tw7G6sHNsiLEmpgCPG2PWHbM9kiMDwCd5NSLPugj4wBjT3hiTYIxpB2wDRgCDXMMN/LD+nvWte/JEavI3fhv4H7DMGLPfs+F5xXagh4gEi0gUcKrN8XhLg37dmpAd7zmg/GzLO7ESkbXAVcBfyj03DbjS9bM+OTSeaAPwM/Aj8LjrubeBP4CVIrIeeBMIMMbMwvpmulxEVlOPxyWINZuuGGtM4EARWQdcjTUGpVEwxpRgfZg/7RrcvRoYWm6XIhFZhZWsX3/8GXyTMWaHMeZ/FTz1DPAf12tqSC0GlwHTj9n2pWv7MuAV4E+sJO3Y/eqlmvyNjTErgFzc6/3wWYfeu4wx6ViNB+tdP1fZGpiHNZbXrUsnqUbHNcPqLWNMfZk9qFS1iMgo4H5jzDk2h+ITRKQNVhdmN2OM0+Zwaqyxvnc1ltetLWSqURGRW7AGrP/d7liUUp4nIldjzcZ8pJ4nY43yvasxvW5tIVNKKaWUspm2kCmllFJK2UwTMqWUUkopm2lCppRSSillM03IlFJKKaVspgmZUkoppZTN/h/HuTe9IWhjOAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Call the plot functions with the years to be plotted\n",
    "\n",
    "oensingen.plot_values(2008, 2013, crop_type='Winter Wheat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "58787137-5c82-4f17-9abc-4f46846d77e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Call the plot functions with the years to be plotted\n",
    "#     mode: 'rel' or 'abs'\n",
    "#     base: 'FLUXNET' or 'MODIS'\n",
    "\n",
    "oensingen.plot_deltas(2008, 2013, crop_type='Winter Wheat', mode='rel', base='MODIS')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9fbf83f6-3f20-4949-9b5d-97b277186c2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Years available: [2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014]\n",
      "\n",
      "Mustard – years available: [2004, 2007]\n",
      "Maize – years available: [2005, 2008, 2011]\n",
      "Winter Wheat – years available: [2005, 2008, 2011, 2013]\n",
      "Barley – years available: [2006]\n",
      "Triticale – years available: [2009]\n",
      "Phacelia – years available: [2010]\n",
      "Rapeseed – years available: [2012]\n",
      "Mixed CIPAN crops – years available: []\n"
     ]
    }
   ],
   "source": [
    "# Grignon data\n",
    "\n",
    "crop_rotation = [\n",
    "    ['Barley',['','02.07.2004']],\n",
    "    ['Mustard',['02.09.2004','07.05.2005']],\n",
    "    ['Maize',['09.05.2005','28.09.2005']],\n",
    "    ['Winter Wheat',['28.10.2005','15.07.2006']],\n",
    "    ['Barley',['04.10.2006','29.06.2007']],\n",
    "    ['Mustard',['25.09.2007','14.04.2008']],\n",
    "    ['Maize',['28.04.2008','10.09.2008']],\n",
    "    ['Winter Wheat',['14.10.2008','31.07.2009']],\n",
    "    ['Triticale',['20.10.2009','19.07.2010']],\n",
    "    ['Phacelia',['14.09.2010','23.03.2011']],\n",
    "    ['Maize',['21.04.2011','06.09.2011']],\n",
    "    ['Winter Wheat',['20.10.2011','03.08.2012']],\n",
    "    ['Rapeseed',['31.08.2012','06.08.2013']],\n",
    "    ['Winter Wheat',['08.10.2013','05.08.2014']],\n",
    "    ['Rapeseed',['10.09.2014','06.02.2015']],\n",
    "    ['Maize',['16.04.2015','26.08.2015']],\n",
    "    ['Winter Wheat',['20.10.2015','28.07.2016']],\n",
    "    ['Rapeseed',['16.08.2016','29.07.2017']],\n",
    "    ['Winter Wheat',['25.09.2017','08.07.2018']],\n",
    "    ['Mixed CIPAN crops',['03.08.2018','15.04.2019']],\n",
    "    ['Maize',['20.04.2019','16.09.2019']],\n",
    "    ['Winter Wheat',['03.10.2019','10.07.2020']],\n",
    "    ['Rapeseed',['20.08.2020','31.07.2021']],\n",
    "    ['Winter Wheat',['07.10.2021','']]\n",
    "]\n",
    "\n",
    "FLUXNET_file_path = 'data/Grignon_FLUXNET/FLX_FR-Gri_FLUXNET2015_FULLSET_DD_2004-2014_1-4.csv'\n",
    "MODIS_file_path = 'data/Grignon_MODIS/LE_500m_filtered_scaled.csv'\n",
    "\n",
    "grignon = CropSiteData(FLUXNET_file_path, MODIS_file_path, crop_rotation)\n",
    "    \n",
    "print(f\"Years available: {list(grignon.data['yearwise'].keys())}\")\n",
    "print()\n",
    "for key, value in grignon.data['cropwise'].items():\n",
    "    print(f\"{key} – years available: {list(value.keys())}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "52fbae49-70aa-414a-b61d-14a66b245934",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Call the plot functions with the years to be plotted\n",
    "\n",
    "grignon.plot_values(2008, 2013, crop_type='Winter Wheat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9837064c-b59f-4947-b127-a7c321d3a3a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Call the plot functions with the years to be plotted\n",
    "#     mode: 'rel' or 'abs'\n",
    "#     base: 'FLUXNET' or 'MODIS'\n",
    "\n",
    "grignon.plot_deltas(2008, 2013, crop_type='Winter Wheat', mode='rel', base='MODIS')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00151f15-fb21-4907-92ef-93c104041eea",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}