FourCastNet_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "07f683c0-53eb-444f-9ee7-72a44342992f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# inference and running script for FourCastNet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "62d72ac1-afbc-4957-b457-618ee3d19850",
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import os\n",
    "import sys\n",
    "import time, re\n",
    "import numpy as np\n",
    "import logging\n",
    "from collections import OrderedDict\n",
    "\n",
    "\n",
    "username=\"gupt1075\"\n",
    "# sys.path.append(os.path.dirname(os.path.realpath(__file__)) + '/../')\n",
    "if (f\"/home/{username}/FourCastNet_gil\" not in sys.path):\n",
    "    sys.path.append(f\"/home/{username}/FourCastNet_gil\")\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "import h5py\n",
    "import torch\n",
    "import torch.cuda.amp as amp\n",
    "import torch.distributed as dist\n",
    "import torch.nn as nn\n",
    "import torchvision\n",
    "from numpy.core.numeric import False_\n",
    "from torch.nn.parallel import DistributedDataParallel\n",
    "from torchvision.utils import save_image\n",
    "from utils.weighted_acc_rmse import (\n",
    "    unweighted_acc_torch_channels,\n",
    "    weighted_acc_masked_torch_channels,\n",
    "    weighted_acc_torch_channels,\n",
    "    weighted_rmse_torch_channels,\n",
    ")\n",
    "\n",
    "import glob\n",
    "from datetime import datetime, timedelta\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import wandb\n",
    "from utils import logging_utils\n",
    "from networks.afnonet import AFNONet\n",
    "from utils.data_loader_multifiles import get_data_loader\n",
    "from utils.YParams import YParams\n",
    "from scipy.stats import sem\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fea4902d-64f0-429e-817e-0de4460676bc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "e5c4adf7-45bc-4efc-bed2-7bb7ef24f0ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def save_dataset(file, name, data, shape=None, dtype=None):\n",
    "    \"\"\"Helper function to save or overwrite a dataset in an HDF5 file.\"\"\"\n",
    "    try:\n",
    "        file.create_dataset(name, data=data, shape=shape, dtype=dtype)\n",
    "    except:\n",
    "        del file[name]\n",
    "        file.create_dataset(name, data=data, shape=shape, dtype=dtype)\n",
    "        file[name][...] = data\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b91b53f6-193a-4c54-bafc-e19a39a64279",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "def plot_time_series(arr, filepath, fld=\"z500\", default_timedelta=6, start_year=2018):\n",
    "    # Compute the mean across the rows of the time series at each of the total_hours time points\n",
    "    means = np.mean(arr, axis=0)\n",
    "\n",
    "    # Compute the total number of hours based on the array shape and default timedelta\n",
    "    total_hours = arr.shape[1] * default_timedelta\n",
    "\n",
    "    # Plot the mean values\n",
    "    plt.plot(range(0, total_hours, default_timedelta), means, label=f'Mean of {fld} across {total_hours} hours for start_year {start_year}')\n",
    "    \n",
    "    # Compute the standard error of the mean (sem) at each time point\n",
    "    sem_vals = sem(arr, axis=0)\n",
    "    \n",
    "    # Plot the 95% confidence interval for the mean values\n",
    "    plt.fill_between(range(0, total_hours, default_timedelta), means - 1.96*sem_vals, means + 1.96*sem_vals, alpha=0.2, label='95% CI')\n",
    "    \n",
    "    # Set the x-axis label with the start time\n",
    "    plt.xlabel(f'Number of hours starting from {start_year}')\n",
    "    \n",
    "    # Set the y-axis label\n",
    "    plt.ylabel('Anomaly Correlation Coefficient (ACC) value')\n",
    "    \n",
    "    # Add a legend to the plot\n",
    "    plt.legend()\n",
    "    \n",
    "    # # Display the plot\n",
    "    # plt.show()\n",
    "    \n",
    "    # Save the plot to a file with the specified filepath and DPI\n",
    "    plt.savefig(f\"{filepath}.png\", dpi=200)\n",
    "    return\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "33cb62d1-b714-4b67-9b04-5d6fdfb7ae47",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def get_base_year(base_path):\n",
    "    year_match = re.search(r'\\b(19[7-9]\\d|20[0-2]\\d)\\b', os.path.basename(base_path))\n",
    "    if year_match:\n",
    "        return int(year_match.group(1))\n",
    "    else:\n",
    "        raise ValueError(f\"Invalid base path : {base_path}\")\n",
    "\n",
    "\n",
    "\n",
    "def gaussian_perturb(x, level=0.01, device=0):\n",
    "    # Add Gaussian noise to the input tensor x with a specified noise level and device\n",
    "    noise = level * torch.randn(x.shape).to(device, dtype=torch.float)\n",
    "    return x + noise\n",
    "\n",
    "\n",
    "def load_model(model, params, checkpoint_file):\n",
    "    # Clear the gradients of the model\n",
    "    model.zero_grad()\n",
    "    \n",
    "    # Load the checkpoint from the specified file\n",
    "    checkpoint_fname = checkpoint_file\n",
    "    checkpoint = torch.load(checkpoint_fname)\n",
    "    \n",
    "    try:\n",
    "        # Create a new state dictionary and copy the model state from the checkpoint, excluding the 'ged' key\n",
    "        new_state_dict = OrderedDict()        \n",
    "        for (key, val) in checkpoint['model_state'].items():\n",
    "            name = key[7:]\n",
    "            # logging.warning(f\" name {name}\")\n",
    "            if name != 'ged':\n",
    "                new_state_dict[name] = val\n",
    "        # Load the new state dictionary into the model\n",
    "        model.load_state_dict(new_state_dict)\n",
    "    except:\n",
    "        # If the above fails, directly load the model state from the checkpoint\n",
    "        model.load_state_dict(checkpoint['model_state'])\n",
    "    \n",
    "    # Set the model to evaluation mode\n",
    "    model.eval()\n",
    "    \n",
    "    # Return the loaded model\n",
    "    return model\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def downsample(x, scale=0.125):\n",
    "    return torch.nn.functional.interpolate(x, scale_factor=scale, mode='bilinear')\n",
    "\n",
    "\n",
    "\n",
    "def setup(params):\n",
    "    # Get the device (GPU if available, else CPU)\n",
    "    device = torch.cuda.current_device() if torch.cuda.is_available() else 'cpu'\n",
    "\n",
    "    # Get the data loader and dataset\n",
    "    valid_data_loader, valid_dataset = get_data_loader(params, params.inf_data_path, dist.is_initialized(), train=False)\n",
    "\n",
    "    # Get image shape from the dataset\n",
    "    img_shape_x = valid_dataset.img_shape_x\n",
    "    img_shape_y = valid_dataset.img_shape_y\n",
    "    params.img_shape_x = img_shape_x\n",
    "    params.img_shape_y = img_shape_y\n",
    "\n",
    "    # Log loading of trained model checkpoint\n",
    "    if params.log_to_screen:\n",
    "        logging.info(f'Loading trained model checkpoint from {params[\"best_checkpoint_path\"]}')\n",
    "\n",
    "    # Get input and output channels\n",
    "    in_channels = np.array(params.in_channels)\n",
    "    out_channels = np.array(params.out_channels)\n",
    "    n_in_channels = len(in_channels)\n",
    "    n_out_channels = len(out_channels)\n",
    "\n",
    "    # Set number of input and output channels in params\n",
    "    params['N_in_channels'] = n_in_channels + 1 if params['orography'] else n_in_channels\n",
    "    params['N_out_channels'] = n_out_channels\n",
    "\n",
    "    # Load means and stds needed for standardizing wind data\n",
    "    params.means = np.load(params.global_means_path)[0, out_channels]\n",
    "    params.stds = np.load(params.global_stds_path)[0, out_channels]\n",
    "\n",
    "    logging.info(f\" in_channels  {in_channels} {params['N_in_channels']}   >>   out_channels {out_channels} {params['N_out_channels']}  params.global_means_path {params.global_means_path} params.global_stds_path {params.global_stds_path}  \")\n",
    "\n",
    "    # Load the model based on the network type\n",
    "    if params.nettype == 'afno':\n",
    "        model = AFNONet(params).to(device)\n",
    "    else:\n",
    "        raise Exception('not implemented')\n",
    "\n",
    "    # Load the model weights from the checkpoint file\n",
    "    checkpoint_file = params['best_checkpoint_path']\n",
    "    model = load_model(model, params, checkpoint_file)\n",
    "    model = model.to(device)\n",
    "\n",
    "    # Load the validation data paths\n",
    "    logging.info(f\" in_channels {params['N_in_channels']}   out_channels {params['N_out_channels']}  params.global_means_path {params.global_means_path} params.global_stds_path {params.global_stds_path}  \")\n",
    "\n",
    "    files_paths = sorted(glob.glob(params.inf_data_path + '/*.h5'))\n",
    "    logging.info(f\" Loading validation data from {files_paths}\")\n",
    "\n",
    "    # Select the year for inference i.e. 2018 for standard case\n",
    "    yr = 0\n",
    "    valid_year = get_base_year(files_paths[yr])\n",
    "    logging.warning(f\" valid_year {valid_year}   \")\n",
    "    # Load the validation data from the selected year\n",
    "    valid_data_full = h5py.File(files_paths[yr], 'r')['fields']\n",
    "\n",
    "    return valid_data_full, model, valid_year\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "be7d922a-3242-4113-a570-e2ba9bb31dde",
   "metadata": {},
   "outputs": [],
   "source": [
    "def autoregressive_inference(\n",
    "    params,\n",
    "    ic,\n",
    "    valid_data_full,\n",
    "    model,\n",
    "    ):\n",
    "    ic = int(ic)\n",
    "\n",
    "    # initialize global variables\n",
    "\n",
    "    device = \\\n",
    "        (torch.cuda.current_device() if torch.cuda.is_available() else 'cpu'\n",
    "         )\n",
    "    \n",
    "    # exp_dir = params['experiment_dir']\n",
    "    \n",
    "    dt = int(params.dt)\n",
    "    prediction_length = int(params.prediction_length / dt)\n",
    "    n_history = params.n_history\n",
    "    img_shape_x = params.img_shape_x\n",
    "    img_shape_y = params.img_shape_y\n",
    "    in_channels = np.array(params.in_channels)\n",
    "    out_channels = np.array(params.out_channels)\n",
    "    n_in_channels = len(in_channels)\n",
    "    n_out_channels = len(out_channels)\n",
    "    means = params.means\n",
    "    stds = params.stds\n",
    "\n",
    "    # initialize memory for image sequences and RMSE/ACC\n",
    "\n",
    "    valid_loss = torch.zeros((prediction_length,\n",
    "                             n_out_channels)).to(device,\n",
    "            dtype=torch.float)\n",
    "    acc = torch.zeros((prediction_length, n_out_channels)).to(device,\n",
    "            dtype=torch.float)\n",
    "\n",
    "    # compute metrics in a coarse resolution too if params.interp is nonzero\n",
    "\n",
    "    valid_loss_coarse = torch.zeros((prediction_length,\n",
    "                                    n_out_channels)).to(device,\n",
    "            dtype=torch.float)\n",
    "    acc_coarse = torch.zeros((prediction_length,\n",
    "                             n_out_channels)).to(device,\n",
    "            dtype=torch.float)\n",
    "    acc_coarse_unweighted = torch.zeros((prediction_length,\n",
    "            n_out_channels)).to(device, dtype=torch.float)\n",
    "\n",
    "    acc_unweighted = torch.zeros((prediction_length,\n",
    "                                 n_out_channels)).to(device,\n",
    "            dtype=torch.float)\n",
    "    seq_real = torch.zeros((prediction_length, n_in_channels,\n",
    "                           img_shape_x, img_shape_y)).to(device,\n",
    "            dtype=torch.float)\n",
    "    seq_pred = torch.zeros((prediction_length, n_in_channels,\n",
    "                           img_shape_x, img_shape_y)).to(device,\n",
    "            dtype=torch.float)\n",
    "\n",
    "    acc_land = torch.zeros((prediction_length,\n",
    "                           n_out_channels)).to(device,\n",
    "            dtype=torch.float)\n",
    "    acc_sea = torch.zeros((prediction_length,\n",
    "                          n_out_channels)).to(device, dtype=torch.float)\n",
    "    if params.masked_acc:\n",
    "        maskarray = \\\n",
    "            torch.as_tensor(np.load(params.maskpath)[0:720]).to(device,\n",
    "                dtype=torch.float)\n",
    "\n",
    "    valid_data = valid_data_full[ic:ic + prediction_length * dt\n",
    "                                 + n_history * dt:dt, in_channels, 0:\n",
    "                                 720]  # extract valid data from first year\n",
    "\n",
    "    # standardize\n",
    "\n",
    "    valid_data = (valid_data - means) / stds\n",
    "    valid_data = torch.as_tensor(valid_data).to(device,\n",
    "            dtype=torch.float)\n",
    "\n",
    "    # load time means\n",
    "\n",
    "    if not params.use_daily_climatology:\n",
    "        m = torch.as_tensor((np.load(params.time_means_path)[0][out_channels]- means) / stds)[:, 0:img_shape_x]  # climatology\n",
    "        m = torch.unsqueeze(m, 0)\n",
    "    else:\n",
    "\n",
    "      # use daily clim like weyn et al. (different from rasp)\n",
    "\n",
    "        dc_path = params.dc_path\n",
    "        with h5py.File(dc_path, 'r') as f:\n",
    "            dc = f['time_means_daily'][ic:ic + prediction_length * dt:dt]  # 1460,21,721,1440\n",
    "        m = torch.as_tensor((dc[:, out_channels, 0:img_shape_x, :]- means) / stds)\n",
    "\n",
    "    m = m.to(device, dtype=torch.float)\n",
    "    if params.interp > 0:\n",
    "        m_coarse = downsample(m, scale=params.interp)\n",
    "\n",
    "    std = torch.as_tensor(stds[:, 0, 0]).to(device, dtype=torch.float)\n",
    "\n",
    "    orography = params.orography\n",
    "    orography_path = params.orography_path\n",
    "    if orography:\n",
    "        orog = \\\n",
    "            torch.as_tensor(np.expand_dims(np.expand_dims((h5py.File(orography_path,'r')['orog'])[0:720], axis=0),axis=0)).to(device, dtype=torch.float)\n",
    "        logging.info(\"orography loaded; shape: {orog.shape}\")\n",
    "\n",
    "    # autoregressive inference\n",
    "\n",
    "    if params.log_to_screen:\n",
    "        logging.info('Begin autoregressive inference')\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for i in range(valid_data.shape[0]):\n",
    "            if i == 0:  # start of sequence\n",
    "                first = valid_data[0:n_history + 1]\n",
    "                # logging.info(f\" >> in autoregressive step: shape of input step 0 : {first.shape} \")\n",
    "                future = valid_data[n_history + 1]\n",
    "                for h in range(n_history + 1):\n",
    "                    seq_real[h] = first[h * n_in_channels:(h + 1)\n",
    "                        * n_in_channels][0:n_out_channels]  # extract history from 1st\n",
    "                    seq_pred[h] = seq_real[h]\n",
    "                if params.perturb:\n",
    "                    first = gaussian_perturb(first,\n",
    "                            level=params.n_level, device=device)  # perturb the ic\n",
    "                if orography:\n",
    "                    future_pred = model(torch.cat((first, orog),\n",
    "                            axis=1))\n",
    "                else:\n",
    "                    future_pred = model(first)\n",
    "            else:\n",
    "                if i < prediction_length - 1:\n",
    "                    future = valid_data[n_history + i + 1]\n",
    "                if orography:\n",
    "                    future_pred = model(torch.cat((future_pred, orog),\n",
    "                            axis=1))  # autoregressive step\n",
    "                else:\n",
    "                    # logging.info(f\" >> in autoregressive step: shape of input  {future_pred.shape} \")\n",
    "                    future_pred = model(future_pred)  # autoregressive step\n",
    "\n",
    "            if i < prediction_length - 1:  # not on the last step\n",
    "                seq_pred[n_history + i + 1] = future_pred\n",
    "                seq_real[n_history + i + 1] = future\n",
    "                history_stack = seq_pred[i + 1:i + 2 + n_history]\n",
    "\n",
    "            future_pred = history_stack\n",
    "\n",
    "        # Compute metrics\n",
    "\n",
    "            if params.use_daily_climatology:\n",
    "                clim = m[i:i + 1]\n",
    "                if params.interp > 0:\n",
    "                    clim_coarse = m_coarse[i:i + 1]\n",
    "            else:\n",
    "                clim = m\n",
    "                if params.interp > 0:\n",
    "                    clim_coarse = m_coarse\n",
    "\n",
    "            pred = torch.unsqueeze(seq_pred[i], 0)\n",
    "            tar = torch.unsqueeze(seq_real[i], 0)\n",
    "            valid_loss[i] = weighted_rmse_torch_channels(pred, tar) \\\n",
    "                * std\n",
    "            acc[i] = weighted_acc_torch_channels(pred - clim, tar\n",
    "                    - clim)\n",
    "            acc_unweighted[i] = unweighted_acc_torch_channels(pred\n",
    "                    - clim, tar - clim)\n",
    "\n",
    "            if params.masked_acc:\n",
    "                acc_land[i] = weighted_acc_masked_torch_channels(pred\n",
    "                        - clim, tar - clim, maskarray)\n",
    "                acc_sea[i] = weighted_acc_masked_torch_channels(pred\n",
    "                        - clim, tar - clim, 1 - maskarray)\n",
    "\n",
    "            if params.interp > 0:\n",
    "                pred = downsample(pred, scale=params.interp)\n",
    "                tar = downsample(tar, scale=params.interp)\n",
    "                valid_loss_coarse[i] = \\\n",
    "                    weighted_rmse_torch_channels(pred, tar) * std\n",
    "                acc_coarse[i] = weighted_acc_torch_channels(pred\n",
    "                        - clim_coarse, tar - clim_coarse)\n",
    "                acc_coarse_unweighted[i] = \\\n",
    "                    unweighted_acc_torch_channels(pred - clim_coarse,\n",
    "                        tar - clim_coarse)\n",
    "\n",
    "            if params.log_to_screen:\n",
    "                tmp_dict = params[\"idxes\"]\n",
    "                idx = tmp_dict[params[\"fld\"]]\n",
    "                logging.info(f'Predicted timestep {i} of {prediction_length}. {args.fld} RMS Error: {valid_loss[i, idx]}, ACC: {acc[i, idx]}')\n",
    "                if params.interp > 0:\n",
    "                    logging.info(f'[COARSE] Predicted timestep {i} of {prediction_length}. {args.fld} RMS Error: {valid_loss_coarse[i, idx]}, ACC: {acc_coarse[i, idx]}')\n",
    "\n",
    "\n",
    "    seq_real = seq_real.cpu().numpy()\n",
    "    seq_pred = seq_pred.cpu().numpy()\n",
    "    valid_loss = valid_loss.cpu().numpy()\n",
    "    acc = acc.cpu().numpy()\n",
    "    acc_unweighted = acc_unweighted.cpu().numpy()\n",
    "    acc_coarse = acc_coarse.cpu().numpy()\n",
    "    acc_coarse_unweighted = acc_coarse_unweighted.cpu().numpy()\n",
    "    valid_loss_coarse = valid_loss_coarse.cpu().numpy()\n",
    "    acc_land = acc_land.cpu().numpy()\n",
    "    acc_sea = acc_sea.cpu().numpy()\n",
    "\n",
    "    return (\n",
    "        np.expand_dims(seq_real[n_history:], 0),\n",
    "        np.expand_dims(seq_pred[n_history:], 0),\n",
    "        np.expand_dims(valid_loss, 0),\n",
    "        np.expand_dims(acc, 0),\n",
    "        np.expand_dims(acc_unweighted, 0),\n",
    "        np.expand_dims(valid_loss_coarse, 0),\n",
    "        np.expand_dims(acc_coarse, 0),\n",
    "        np.expand_dims(acc_coarse_unweighted, 0),\n",
    "        np.expand_dims(acc_land, 0),\n",
    "        np.expand_dims(acc_sea, 0),)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "4d1a2737-d16f-4f8e-b186-21db8a9d989d",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def hours_to_datetime(hours, start_year, default_timedelta=6):\n",
    "    \"\"\"\n",
    "    Convert hours to a datetime object.\n",
    "\n",
    "    Args:\n",
    "        hours (int): Number of hours since the start of the year.\n",
    "        start_year (int): The starting year for the calculation.\n",
    "        default_timedelta (int, optional): The default time delta in hours. Defaults to 6.\n",
    "\n",
    "    Returns:\n",
    "        datetime: The datetime object representing the calculated date and time.\n",
    "    \"\"\"\n",
    "    total_hours = default_timedelta * hours  # Calculate the total hours based on the default time delta\n",
    "    days, hours = divmod(total_hours, 24)  # Calculate the number of days and remaining hours\n",
    "\n",
    "    start_date = datetime(start_year, 1, 1, 0, 0, 0)  # Create a datetime object for the start of the year\n",
    "    date = start_date + timedelta(days= int(days), hours= int(hours))  # Add the calculated days and hours to the start date\n",
    "\n",
    "    return date\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01c4a657-2406-4e59-99ef-a7acfe61d87c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59a1c51e-61f6-47d3-8189-202bbd7a474d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "e67280b9-bc82-4330-8d04-2471c91b0745",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "def main(args):\n",
    "    \n",
    "    params = YParams(os.path.abspath(args.yaml_config), args.config)\n",
    "    \n",
    "    params[\"fld\"] = args.fld\n",
    "    params['world_size'] = 1\n",
    "    params['interp'] = args.interp\n",
    "    params['use_daily_climatology'] = args.use_daily_climatology\n",
    "    params['global_batch_size'] = params.batch_size\n",
    "\n",
    "    # important step to index the correct variable from the 20 simulated variable by their index\n",
    "    params[\"idxes\"] = {\"u10\": 0, \"z500\": 14, \"2m_temperature\": 2, \"v10\": 1, \"t850\": 5}\n",
    "\n",
    "\n",
    "    torch.cuda.set_device(0)\n",
    "    torch.backends.cudnn.benchmark = True\n",
    "    vis = args.vis\n",
    "\n",
    "\n",
    "\n",
    "    # fld = 'z500'  # diff flds have diff decor times and hence differnt ics\n",
    "    if args.fld == 'z500' or args.fld == '2m_temperature' or args.fld == 't850':\n",
    "        params[\"DECORRELATION_TIME\"] = 36  # 9 days (36) for z500, 2 (8 steps) days for u10, v10\n",
    "    else:\n",
    "        params[\"DECORRELATION_TIME\"] = 8  # 9 days (36) for z500, 2 (8 steps) days for u10, v10\n",
    "\n",
    "\n",
    "    # Set up directory\n",
    "\n",
    "    if args.exp_dir is not None:\n",
    "        assert args.weights is not None, \\\n",
    "            'Must set --weights argument if using --exp_dir'\n",
    "    else:\n",
    "        assert args.weights is None, \\\n",
    "            'Cannot use --weights argument without also using --exp_dir'\n",
    "    \n",
    "    expDir = os.path.join(args.exp_dir, args.config, str(args.run_num))\n",
    "\n",
    "    if not os.path.isdir(expDir):\n",
    "        os.makedirs(expDir)\n",
    "\n",
    "    params['experiment_dir'] = os.path.abspath(expDir)\n",
    "    params['best_checkpoint_path'] = (args.weights if args.exp_dir is not None else os.path.join(expDir, 'training_checkpoints/best_ckpt.tar'))\n",
    "    params['resuming'] = False\n",
    "    params['local_rank'] = 0\n",
    "\n",
    "    logging_utils.log_to_file(logger_name=None, log_filename=os.path.join(expDir, 'inference_out.log'))\n",
    "    logging_utils.log_versions()\n",
    "    params.log()\n",
    "\n",
    "    # n_ics = params['n_initial_conditions']\n",
    "\n",
    "    if args.fld== 'z500' or args.fld == 't850':\n",
    "        n_samples_per_year = 1336\n",
    "    else:\n",
    "        n_samples_per_year = 1460\n",
    "\n",
    "    if params['ics_type'] == 'default':\n",
    "        num_samples = n_samples_per_year - params.prediction_length\n",
    "        stop = num_samples\n",
    "        ics = np.arange(0, stop, params[\"DECORRELATION_TIME\"])\n",
    "        logging.warning(f' stop: {stop}.   params[\"DECORRELATION_TIME\"] : {params[\"DECORRELATION_TIME\"]}   initial_conditions: {params[\"n_initial_conditions\"]} \\n ICS: {ics} ')\n",
    "        ics = ics[:params[\"n_initial_conditions\"]]\n",
    "\n",
    "        n_ics = len(ics)\n",
    "        logging.warning(f\" \\n ICS for default: {ics} num_samples {num_samples}  prediction_lnegth: {params.prediction_length}   \")\n",
    "        \n",
    "        # logging.warning(f\"{date} {date_obj} {day_of_year} {hour_of_day} {hours_since_jan_01_epoch}\")        \n",
    "    \n",
    "    elif params['ics_type'] == 'datetime':\n",
    "        date_strings = params['date_strings']\n",
    "        ics = []\n",
    "        if params.perturb:  # for perturbations use a single date and create n_ics perturbations\n",
    "            n_ics = params['n_perturbations']\n",
    "            date = date_strings[0]\n",
    "            date_obj = datetime.strptime(date, '%Y-%m-%d %H:%M:%S')\n",
    "            day_of_year = date_obj.timetuple().tm_yday - 1\n",
    "            hour_of_day = date_obj.timetuple().tm_hour\n",
    "            hours_since_jan_01_epoch = 24 * day_of_year + hour_of_day\n",
    "            for ii in range(n_ics):\n",
    "                ics.append(int(hours_since_jan_01_epoch / 6))\n",
    "        else:\n",
    "            for date in date_strings:\n",
    "                date_obj = datetime.strptime(date, '%Y-%m-%d %H:%M:%S')\n",
    "                day_of_year = date_obj.timetuple().tm_yday - 1\n",
    "                hour_of_day = date_obj.timetuple().tm_hour\n",
    "                hours_since_jan_01_epoch = 24 * day_of_year \\\n",
    "                    + hour_of_day\n",
    "                ics.append(int(hours_since_jan_01_epoch / 6))\n",
    "        n_ics = len(ics)\n",
    "        logging.warning(f\" #### ICS for datetime: {ics} \")\n",
    "        logging.warning(f\"Inference for {n_ics} initial conditions with ics_type {params['ics_type']} : current_date {date_strings} and hours_since_jan_01_epoch {hours_since_jan_01_epoch}\")\n",
    "        logging.warning(f\"{date} {date_obj} {day_of_year} {hour_of_day} {hours_since_jan_01_epoch}\")\n",
    "\n",
    "\n",
    "\n",
    "    \n",
    "    try:\n",
    "        autoregressive_inference_filetag = params['inference_file_tag']\n",
    "    except:\n",
    "        autoregressive_inference_filetag = ''\n",
    "\n",
    "    if params.interp > 0:\n",
    "        autoregressive_inference_filetag = '_coarse'\n",
    "\n",
    "    autoregressive_inference_filetag += '_' + args.fld + ''\n",
    "    if vis:\n",
    "        autoregressive_inference_filetag += '_vis'\n",
    "\n",
    "    # get data and models\n",
    "\n",
    "    (valid_data_full, model, valid_year) = setup(params)\n",
    "\n",
    "    # initialize lists for image sequences and RMSE/ACC\n",
    "\n",
    "    dates_from_ics = [hours_to_datetime(x, valid_year).strftime(\"%d_%B_%H_%Y\") for x in ics]\n",
    "        \n",
    "\n",
    "    valid_loss = []\n",
    "    valid_loss_coarse = []\n",
    "    acc_unweighted = []\n",
    "    acc = []\n",
    "    acc_coarse = []\n",
    "    acc_coarse_unweighted = []\n",
    "    seq_pred = []\n",
    "    seq_real = []\n",
    "    acc_land = []\n",
    "    acc_sea = []\n",
    "\n",
    "\n",
    "    acc_array = np.zeros((36, 41))\n",
    "    for (i, ic) in enumerate(ics):\n",
    "        \n",
    "        date_string = dates_from_ics[i]\n",
    "        logging.warning(f\"Initial condition {i+1} of {n_ics} with corresponidng time  =  {date_string} and valid_year {valid_year}\")\n",
    "\n",
    "\n",
    "        # run autoregressive inference for multiple initial conditions\n",
    "        (sr, sp, vl, a, au, vc, ac, acu, accland, accsea) = autoregressive_inference(params, ic, valid_data_full, model)\n",
    "\n",
    "\n",
    "        \n",
    "        with open(os.path.join(params['experiment_dir'], f\"seq_pred_output_{i}_datetime_{date_string}.npy\"), 'wb') as f:\n",
    "            np.save(f, np.squeeze(sp))\n",
    "        with open(os.path.join(params['experiment_dir'], f\"seq_real_output_{i}_datetime_{date_string}.npy\"), 'wb') as f:\n",
    "            np.save(f, np.squeeze(sr)) \n",
    "        logging.warning(f\" saved real and predicted with shape {sp.shape} {sr.shape} with np_save {date_string} \")\n",
    "\n",
    "        # concatenate\n",
    "        if i == 0 or len(valid_loss) == 0:\n",
    "            seq_real = sr\n",
    "            seq_pred = sp\n",
    "            valid_loss = vl\n",
    "            valid_loss_coarse = vc\n",
    "            acc = a\n",
    "            acc_coarse = ac\n",
    "            acc_coarse_unweighted = acu\n",
    "            acc_unweighted = au\n",
    "            acc_land = accland\n",
    "            acc_sea = accsea\n",
    "        \n",
    "        else: \n",
    "            # seq_real = np.concatenate((seq_real, sr), 0)\n",
    "            # seq_pred = np.concatenate((seq_pred, sp), 0)\n",
    "            valid_loss = np.concatenate((valid_loss, vl), 0)\n",
    "            valid_loss_coarse = np.concatenate((valid_loss_coarse, vc),0)\n",
    "            acc = np.concatenate((acc, a), 0)\n",
    "            acc_coarse = np.concatenate((acc_coarse, ac), 0)\n",
    "            acc_coarse_unweighted = np.concatenate((acc_coarse_unweighted, acu), 0)\n",
    "            acc_unweighted = np.concatenate((acc_unweighted, au), 0)\n",
    "            acc_land = np.concatenate((acc_land, accland), 0)\n",
    "            acc_sea = np.concatenate((acc_sea, accsea), 0)\n",
    "\n",
    "\n",
    "    prediction_length = seq_real[0].shape[0]\n",
    "    n_out_channels = seq_real[0].shape[1]\n",
    "    img_shape_x = seq_real[0].shape[2]\n",
    "    img_shape_y = seq_real[0].shape[3]\n",
    "\n",
    "\n",
    "    # save predictions and loss\n",
    "    logging.info(f\"Shapes: seq_real {seq_real.shape}, seq_pred {seq_pred.shape}, valid_loss {valid_loss.shape}, valid_loss_coarse {valid_loss_coarse.shape}, acc {acc.shape}, acc_coarse {acc_coarse.shape}, acc_coarse_unweighted {acc_coarse_unweighted.shape}, acc_unweighted {acc_unweighted.shape}, acc_land {acc_land.shape}, acc_sea {acc_sea.shape}\")\n",
    "    logging.info(f\"Saving files at {os.path.join(params['experiment_dir'], 'autoregressive_predictions' + autoregressive_inference_filetag + '.h5')}\")\n",
    "\n",
    "    # saving acc coreraltion only for current fld coefficient as a numpy file\n",
    "    idx = params[\"idxes\"][params[\"fld\"]]\n",
    "    # Shapes: seq_real (1, 41, 20, 720, 1440), seq_pred (1, 41, 20, 720, 1440), valid_loss (36, 41, 20), valid_loss_coarse (36, 41, 20), acc (36, 41, 20), acc_coarse (36, 41, 20), acc_coarse_unweighted (36, 41, 20), acc_unweighted (36, 41, 20), acc_land (36, 41, 20), acc_sea (36, 41, 20)\n",
    "\n",
    "    only_fld_acc = acc[:, :, idx]\n",
    "    only_fld_rmse = valid_loss[:, :, idx]\n",
    "    logging.warning(f\" >>> ONLY_FLD {only_fld_acc.shape}  {only_fld_rmse.shape} \")\n",
    "    # saving acc coreraltion only for idx index and for 36 initial conditions, and each condition going 10 days deep coefficient as a numpy file\n",
    "    # with open(os.path.join(params['experiment_dir'], f\"acc_{args.fld}.npy\"), 'wb') as f:\n",
    "    #     np.save(f, only_fld_acc) \n",
    "\n",
    "\n",
    "    plot_time_series(only_fld_acc, filepath=os.path.join(params['experiment_dir'], f\"plot_acc_var_{args.fld}_with_nics_{params['n_initial_conditions']}\"),  fld=args.fld)\n",
    "\n",
    "\n",
    "\n",
    "    # Open HDF5 file for writing autoregressive predictions and \n",
    "    # Saving the predictions and loss as numpy files\n",
    "    with h5py.File(os.path.join(params['experiment_dir'], 'autoregressive_predictions' + autoregressive_inference_filetag + '.h5'), 'a') as f:\n",
    "        \n",
    "        # Save ground truth and predicted sequences if visualization is enabled\n",
    "        if vis:\n",
    "            save_dataset(f, 'ground_truth', seq_real, (n_ics, prediction_length, n_out_channels, img_shape_x, img_shape_y), np.float32)\n",
    "            save_dataset(f, 'predicted', seq_pred, (n_ics, prediction_length, n_out_channels, img_shape_x, img_shape_y), np.float32)\n",
    "        \n",
    "        # Save accuracy metrics for land and sea if masked accuracy is enabled\n",
    "        if params.masked_acc:\n",
    "            save_dataset(f, 'acc_land', acc_land)\n",
    "            save_dataset(f, 'acc_sea', acc_sea)\n",
    "        \n",
    "        # Save RMSE and accuracy metrics\n",
    "        save_dataset(f, 'rmse', valid_loss, (n_ics, prediction_length, n_out_channels), np.float32)\n",
    "        save_dataset(f, 'acc', acc, (n_ics, prediction_length, n_out_channels), np.float32)\n",
    "        save_dataset(f, 'rmse_coarse', valid_loss_coarse, (n_ics, prediction_length, n_out_channels), np.float32) \n",
    "        save_dataset(f, 'acc_coarse', acc_coarse, (n_ics, prediction_length, n_out_channels), np.float32)\n",
    "        save_dataset(f, 'acc_unweighted', acc_unweighted, (n_ics, prediction_length, n_out_channels), np.float32)\n",
    "        save_dataset(f, 'acc_coarse_unweighted', acc_coarse_unweighted, (n_ics, prediction_length, n_out_channels), np.float32)\n",
    "        f.close()\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "fcae7142-808e-448f-91a8-870c2e022890",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "username = \"gupt1075\"\n",
    "parser = argparse.ArgumentParser()\n",
    "parser.add_argument('-f')\n",
    "parser.add_argument('--run_num', default='222', type=str)\n",
    "\n",
    "# defaul full_field vs afno_backbone\n",
    "parser.add_argument('--config', default='afno_backbone', type=str)\n",
    "parser.add_argument('--use_daily_climatology', default=False, type=bool)\n",
    "parser.add_argument(\"--fld\", default=\"z500\", type=str)\n",
    "parser.add_argument('--vis', default=False, type=bool)\n",
    "parser.add_argument('--interp', default=0, type=float)\n",
    "parser.add_argument('--weights', default=f\"/scratch/gilbreth/wwtung/FourCastNet/model_weights/FCN_weights_v0/backbone.ckpt\", type=str,help='Path to model weights, for use with override_dir option')\n",
    "\n",
    "\n",
    "\n",
    "parser.add_argument('--exp_dir', default=f\"/home/{username}/FourCastNet_tutorial_expts/\", type=str, help='Path to store inference outputs; must also set --weights arg')\n",
    "parser.add_argument('--yaml_config', default=f\"/home/{username}/FourCastNet_gil/config/AFNO.yaml\", type=str)\n",
    "\n",
    "args = parser.parse_args()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59a3f623-b126-4143-9158-6b4a0a77c3ed",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "6bd9ea81-4ce6-4e65-b387-610feff3adc7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAGwCAYAAAC99fF4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACe8klEQVR4nOzdd3iUVfbA8e/MZFp676GFEkIJRUBQwRK6gICKbWmLroogIqjYxd4QUX+ra0NBBV0REZQWpbOAdAglkEAC6aT3Ke/vj8hISGEmJKRwPs8zj/K+d+6cCQlzcsu5KkVRFIQQQgghRAXqhg5ACCGEEKIxkiRJCCGEEKIKkiQJIYQQQlRBkiQhhBBCiCpIkiSEEEIIUQVJkoQQQgghqiBJkhBCCCFEFZwaOoCmymq1kpycjJubGyqVqqHDEUIIIYQdFEUhPz+f4OBg1Oqax4okSaql5ORkwsLCGjoMIYQQQtRCUlISoaGhNbaRJKmW3NzcgPIvsru7ewNHI4QQQgh75OXlERYWZvscr4kkSbV0forN3d1dkiQhhBCiibFnqYws3BZCCCGEqIIkSUIIIYQQVZAkSQghhBCiCpIkCSGEEEJUQZIkIYQQQogqSJIkhBBCCFEFSZKEEEIIIaogSZIQQgghRBUkSRJCCCGEqIIkSUIIIYQQVWjQJGnTpk2MGDGC4OBgVCoVy5cvv+RzNmzYQI8ePdDr9bRt25aFCxdWavPRRx/RqlUrDAYDffr0YefOnRXul5SUMHXqVHx8fHB1dWXs2LGkpaXV0bsSQgghRHPQoElSYWEhUVFRfPTRR3a1T0hIYPjw4dx0003s27ePGTNmMGXKFNasWWNrs3TpUmbOnMkLL7zAnj17iIqKYvDgwaSnp9vaPPbYY/zyyy/88MMPbNy4keTkZMaMGVPn708IIYQQTZdKURSloYOA8oPmfvrpJ2677bZq2zz55JOsWrWKQ4cO2a7ddddd5OTksHr1agD69OlDr169+PDDDwGwWq2EhYUxbdo0nnrqKXJzc/Hz8+Pbb7/l9ttvB+Do0aN07NiR7du3c+2119oVb15eHh4eHuTm5tbpAbe5xSZOnyukS4iHXYfvCSGEEMJ+jnx+N6k1Sdu3byc6OrrCtcGDB7N9+3YAysrK2L17d4U2arWa6OhoW5vdu3djMpkqtImIiKBFixa2NlUpLS0lLy+vwqM+rD6UwsgPt9L/7T9447ejHDqbSyPJY4UQQoirSpNKklJTUwkICKhwLSAggLy8PIqLi8nMzMRisVTZJjU11daHTqfD09Oz2jZVef311/Hw8LA9wsLC6uZNXSSzoAyjVkNSVjEfbzzJrR9s4cZ3NvDW6qMcTpaESQghhLhSmlSS1JDmzJlDbm6u7ZGUlFQvrzP1prbsfi6aj+7pwbAugRi0ak6fK+L/Npxk+IIt3PzuRt5Zc4wjKXmSMAkhhBD1yKmhA3BEYGBgpV1oaWlpuLu7YzQa0Wg0aDSaKtsEBgba+igrKyMnJ6fCaNKFbaqi1+vR6/V192Zq4KxzYnjXIIZ3DaKw1MzvR9NZdSCFP46lk5BZyId/nODDP04Q7ufC8K7B3No1iPYBblckNiGEEOJq0aRGkvr27UtMTEyFa+vWraNv374A6HQ6evbsWaGN1WolJibG1qZnz55otdoKbY4dO0ZiYqKtTWPiondiRFQwH/+jJ7ufG8j7d3VjUGQAOic1JzMKWRATx6D3NjFw3kbmrz/OifT8hg5ZCCGEaBYadHdbQUEBJ06cAKB79+7MmzePm266CW9vb1q0aMGcOXM4e/YsX3/9NVBeAqBz585MnTqVyZMn8/vvvzN9+nRWrVrF4MGDgfISABMmTOCTTz6hd+/ezJ8/n++//56jR4/a1io99NBD/PrrryxcuBB3d3emTZsGwLZt2+yOvb52t9krv8TE+iNprDqQwsbjGZgsf/81tg9w5dauwQzvGkS4n+sVj00IIYRorBz5/G7QJGnDhg3cdNNNla5PmDCBhQsXMnHiRE6dOsWGDRsqPOexxx4jNjaW0NBQnnvuOSZOnFjh+R9++CFvv/02qampdOvWjQULFtCnTx/b/ZKSEh5//HG+++47SktLGTx4MP/3f/9X43TbxRo6SbpQbrGJ9bFprDqYwqa4DMwXJEwRgW6MiApmWJcgWvu6NGCUQgghRMNrMklSU9aYkqQL5RaZWBubyqoDKWw5kYnZ+vdfb2SQO7dGBTG8SxAtfSRhEkIIcfWRJOkKaKxJ0oVyispYeziNlQeS2XriHJYL/qo7BbszIiqY4V2CCPN2bsAohRBCiCtHkqQroCkkSRfKKixj7eFUVuxP5n/x57hggInOIe6M/GtKLtRLEiYhhBDNlyRJV0BTS5IudK6glNWHU/llfzI7E7IqJExdQzwYERXE8K7BBHsaGy5IIYQQoh5IknQFNOUk6UIZ+X8lTPvOsutUNhd+M3QL9bQlTIEehgaLUQghhKgrkiRdAc0lSbpQen4Jvx1MYcX+FPacrpgwdQ/7O2EKcJeESQghRNMkSdIV0ByTpAul5ZXw64EUVuxPZm9Sju26CujewpNbuwZza1QQ/m6SMAkhhGg6JEm6App7knShlNxiVu5P5pcDKRw4k2u7rgJ6tCxPmEZEBePremWObRFCCCFqS5KkK+BqSpIudDanmF/2J7NyfzKHkvNs19Uq6NHSi1u7BjGiazA+kjAJIYRohCRJugKu1iTpQklZRazYl8zKg8kcSfn7zDi1Cnq29GJ412BGdg3CWxImIYQQjcQVSZLKyspISEggPDwcJyenWgXalEmSVFFSVhE/7T3LqoMpHEv9O2HSqFX0bOnFsC5BkjAJIYRocPWaJBUVFTFt2jS++uorAI4fP06bNm2YNm0aISEhPPXUU7WPvAmRJKl6pzILWLY3md8OphCXXmC7rlGruKalF8P/mpLzctE1YJRCCCGuRvWaJD366KNs3bqV+fPnM2TIEA4cOECbNm34+eefefHFF9m7d+9lBd9USJJknxPp+Szbc5bVh1OJzyi0XXdSq+jVypuhnQO5NSoIbxcZYRJCCFH/6jVJatmyJUuXLuXaa6/Fzc2N/fv306ZNG06cOEGPHj3Iy8u7dCfNgCRJjjuSksfyvWdZcziVU+eKbNed1Cp6tS5PmIZ3CZJF30IIIeqNI5/fDi8mysjIwN/fv9L1wsJCVCqVo92Jq0jHIHc6BrkzZ1hHDp3NZfnes6yNTSUxq5jtJ8+x/eQ5Xl4ZS++/RpiGdZURJiGEEA3H4ZGk/v37c8cddzBt2jTc3Nw4cOAArVu3Ztq0acTFxbF69er6irVRkZGkurM/KYfl+86yLjaNM9nFtut6JzX9wn24tWswgzoF4GbQNmCUQgghmoN6nW7bsmULQ4cO5b777mPhwoX861//IjY2lm3btrFx40Z69ux5WcE3FZIk1T2r1cqexBx+3pfMutg0UvNKbPfc9E70b+/LrVHB3NjeD6Pu6ttRKYQQ4vLVewmAkydP8sYbb7B//34KCgro0aMHTz75JF26dKl10E2NJEn1y2yxsv3kOX7ad5Y/jqaTXWSy3fN20XFzhD8jugZzbRtv9FpNA0YqhBCiKZFikleAJElXTonJwu9H01mxP5nNcRkUllps94I9DNzSMYBR3YKJCvNEq1E3YKRCCCEau3pNkhITE2u836JFC0e6a7IkSWoYecUmVh9OZdWBZLbHZ1FmttrutfF1IToygFFRwbQPdJOESQghRCX1miSp1eoad7FZLJZq7zUnkiQ1vPS8ElYeSOa3Q6nsSczBYv37W7lTsDvRHQMYERVEKx8XnCRhEkIIQT0nSfv376/wZ5PJxN69e5k3bx6vvvoqY8aMcTziJkiSpMbDalXKz5Hbn8ya2FQOn83j/De1WgXdW3gxKDKAYV2CCPIwSMIkhBBXsQZZk7Rq1SrefvttNmzYUBfdNXqSJDVOZouV42n5/LwvmZgj6ZzI+PtYFJ1GTe/W3gzuFMDAyAD83Axo1FLbSwghriYNkiSdOHGCqKgoCgsLL924GZAkqfErNVs4kJTLiv3J/H40nbM5f9dgctFp6Bvuw5BOgdwY4YeXs14SJiGEuArUa5J08bEjiqKQkpLCiy++yNGjR9m3b5/DATdFkiQ1LYWlJnYmZLPyQDIbj2eQWVBmu+fprOWGtr4M7RJI3zY+eBh1qCVhEkKIZumKL9xWFIWwsDCWLFlC3759HY+4CZIkqWlSFIXcYhOb4zL59WAKW05kkl9itt0PcNfTv50fw7sE0b2FF24GJ0mYhBCiGanXJGnjxo0V/qxWq/Hz86Nt27Y4OV09VZAlSWr6LFaFcwWlxBxNZ83hVP4Xf44S098lBVp6OzOgvR/DuwYREeSOu8FJzicUQogmTopJXgGSJDUvJouV1NwS1hxOZf2RNP48lY35gpICHQLcuDHCj2Gdg2jt54KbXhImIYRoiuo8SVqxYoXdLz5y5Ei72zZlkiQ1XyUmC0lZRfx6KIU/jmZw4EwO5/MltQq6hnpyYwc/BkUGEOrtLAmTEEI0IXWeJKnV9tWVUalUUkxSNCsFpWZOpufz68FUNhzL4Fhavu2ek1rFNa28uKmDP9Ed/fF3N+AqCZMQQjRqMt12BUiSdHVRFIW8YjOxKbn8djCVDcczSMwqst03ajVc28abGzv4c2MHP3xc9bjqr541ekII0VRIknQFSJJ09TJbrOQWm9iTmM2aQ2lsissgPb/Udt/d4MR1bX25OcKfa8N98HbW4SIJkxBCNAr1niQVFhayceNGEhMTKSsrq3Bv+vTpjnbXJEmSJKC8YGVOYRnb47NYH5vGlhOZ5BSbbPd9XfX0b+fLTRH+9GjhiZeLDmedJExCCNFQ6jVJ2rt3L8OGDaOoqIjCwkK8vb3JzMzE2dkZf39/4uPjLyv4pkKSJHGxojIzmQWlbDqeyR9H09kef46isr/X6IV4GhnQ3o9bOvoTGeyOh1ErCZMQQlxh9Zok3XjjjbRv356PP/4YDw8P9u/fj1ar5b777uPRRx+VA27FVU9RFPJLzaTnlfD7kXQ2Hs9g16lsyix/12Bq6+/KgHZ+3NzRn3A/VzyMWow6TQNGLYQQV4d6TZI8PT3ZsWMHHTp0wNPTk+3bt9OxY0d27NjBhAkTOHr06GUF31RIkiTsYbWWV/g+m1NMzJE0Nh7PZF9Stq2kgAroHOJB/3Z+3BjhRwtvZzyMWgxaSZiEEKI+OPL57fBYv1artZUE8Pf3JzExkY4dO+Lh4UFSUlLtIhaimVKrVXi56PBy0dEh0I17+rTk9LkC1h/JYNPxDGJT8jh4NpeDZ3P5ZNNJurfwpH87P/q39yPI04CXsw6txr4SHEIIIeqWw0lS9+7d2bVrF+3atWPAgAE8//zzZGZmsmjRIjp37lwfMQrRLGg1avzc9Pi56ekc4snEfq04npbH70fLE6b4zEJ2ncpm16lsPvzjBNe39WVI50CuaemFt4sed6PUYBJCiCvJ4em2P//8k/z8fG666SbS09MZP34827Zto127dnzxxRdERUXVV6yNiky3ibpSUGomp6iMg2dz2XCsPGFKyS2x3Q/zMjIoMpDoyABa+Djj7ayT9UtCCFFLUifpCpAkSdS18wUrs4tK2XUqmzWHU9kcl0mpuXzBt5NaxbVtfBgUGUCfNt54u+jxctbiJNNxQghht3pNkl555RXuvfdeWrdufVlBNnWSJIn6ZLZYyS4ykZRVxPojaayNTeNEeoHtvr+bnkGRAURHBtDa1wVPZx3uBpmOE0KIS6nXJCkqKopDhw7Rp08f7rvvPu688058fX0vK+CmSJIkcaXkl5jIKixjf1IOaw6nseFYOoV/1V9Sq6BnSy8GRQZybRsffFx1eLvoZHecEEJUo96n2w4fPsw333zDkiVLOHPmDAMHDuTee+/ltttuw9nZudaBNyWSJIkrzWSxkl1YRkpeMRuOZrI2NpXDyXm2+97OOm7p6M/AyADa+JWPLnkaZTpOCCEudEXXJG3dupVvv/2WH374gZKSEvLy8i79pGZAkiTRUBRFIa/ETFZhGUdT8lgXm0bM0XRyLzgOpWuoB4MiA+kXXj665OWiw00v03FCCFGvdZIu5uLigtFoRKfTkZ+ff7ndCSEuQaVS4WHU4mHUEuxpoHsLLyb0a8X/4s+x5nAaexOzOXAmlwNncnHTO3FThD+DIgMI93fF01mLl7NMxwkhhD1qNZKUkJDAt99+y7fffsuxY8cYMGAA99xzD7fffjseHh71EWejIyNJojFRlPLK3ucKyziVWUjMkXTWxqaRWVBqa9MhwI1BnQK4oa0f3q7lyZKnsw6NWkaXhBBXj3qdbrv22mvZtWsXXbt25d577+Xuu+8mJCTksgJuiiRJEo1ViclCVmEZmQWl7Dmdw5rDqew8lYXlr7NQjFoN/dv5MqhTIO0DXPEw6vB00cp0nBDiqlCv02233HILX3zxBZGRkbUOUAhRfwxaDcGeRgLdDYR6OXN9O1+Sc4r542j56NLZnGLWxKaxJjaNVj7ODIoM5MYOfuXHpzjr8HSWs+OEEAKkmGStyUiSaEqKyyycKywlu7CMQ2fzWBubytYT5yizlBeq1GpU9Av3ZXBkAJ1DPHDWO+HlrJXpOCFEs+PI53eD7w3+6KOPaNWqFQaDgT59+rBz585q25pMJubOnUt4eDgGg4GoqChWr15doU1+fj4zZsygZcuWGI1G+vXrx65duyq0SUtLY+LEiQQHB+Ps7MyQIUOIi4url/cnRGNg1GkI9XImMtiDQZ0CeHpYR76a1JsH+7ehta8LJovCxuMZPL38EP9avJtF209z+GweR1LySMoqIr/EdOkXEUKIZqZBR5KWLl3K+PHj+fjjj+nTpw/z58/nhx9+4NixY/j7+1dq/+STT7J48WI+/fRTIiIiWLNmDTNnzmTbtm10794dgHHjxnHo0CH+/e9/ExwczOLFi3nvvfeIjY0lJCQERVHo168fWq2Wd999F3d3d+bNm8fq1auJjY3FxcXFrthlJEk0dYWl5WUEcorKiEsrYG1sGhuPZ1Bs+rtQZe/W3gyODKR7Cy8MOjWeRh1eLlr0TjIdJ4RomprM2W19+vShV69efPjhhwBYrVbCwsKYNm0aTz31VKX2wcHBPPPMM0ydOtV2bezYsRiNRhYvXkxxcTFubm78/PPPDB8+3NamZ8+eDB06lFdeeYXjx4/ToUMHDh06RKdOnWyvGxgYyGuvvcaUKVPsil2SJNFcnD8CJauwjNwiE1tPlBeqPJL6d0kPX1cdt3QMYGDHAALcDTjrNXg56/AwamU6TgjRpFzROkm1VVZWxu7du5kzZ47tmlqtJjo6mu3bt1f5nNLSUgwGQ4VrRqORLVu2AGA2m7FYLDW2KS0t3xJ9YRu1Wo1er2fLli3VJkmlpaW25wJXTdFM0fw5adT4uenxc9OTX2IiwEPPwE4BnMosZF1sGr8fSyezoIylu5L4flcS3cI8GdQpkD6tvdE5qfEwavFy0eGqb7B/ToQQol7U6l+1xMRETp8+TVFREX5+fnTq1Am9Xu9QH5mZmVgsFgICAipcDwgI4OjRo1U+Z/DgwcybN4/+/fsTHh5OTEwMy5Ytw2Ipnx5wc3Ojb9++vPzyy3Ts2JGAgAC+++47tm/fTtu2bQGIiIigRYsWzJkzh08++QQXFxfee+89zpw5Q0pKSrXxvv7667z00ksOvUchmho3gxY3gxaTxYq/m562Aa62QpVrY9PYl5TD3r8e7gYnbo4IYFCnAMK8nNE6qWy742Q6TgjRHNg93Xbq1Cn+/e9/285ru/BpOp2OG264gQceeICxY8eiVl96PXhycjIhISFs27aNvn372q4/8cQTbNy4kR07dlR6TkZGBvfffz+//PILKpWK8PBwoqOj+eKLLyguLgbg5MmTTJ48mU2bNqHRaOjRowft27dn9+7dHDlyBIDdu3fzz3/+k/3796PRaIiOjkatVqMoCr/99luV8VY1khQWFibTbaJZu/AIlIISM6m5Jaw7ksb6I2lkFZbZ2kUGuTMoMoDr2vpi0Gpw1mvw/ms6Ti3TcUKIRqTOd7dNnz6dqKgoEhISeOWVV4iNjSU3N5eysjJSU1P59ddfuf7663n++efp2rVrpd1kVfH19UWj0ZCWllbhelpaGoGBgVU+x8/Pj+XLl1NYWMjp06c5evQorq6utGnTxtYmPDycjRs3UlBQQFJSEjt37sRkMlVo07NnT/bt20dOTg4pKSmsXr2ac+fOVWhzMb1ej7u7e4WHEM3d+SNQWvu60D7QlS6hHkzs14ovJvTiueEd6dPaG7UKYlPymB8Tx4Qvd/J/G05wICmXM9nFxP61O66g1NzQb0UIIRxm13Sbi4sL8fHx+Pj4VLrn7+/PzTffzM0338wLL7zA6tWrSUpKolevXjX2qdPp6NmzJzExMdx2221A+QLqmJgYHnnkkRqfazAYCAkJwWQy8eOPP3LnnXdWGbOLiwvZ2dmsWbOGt956q1Kb80eoxMXF8eeff/Lyyy/X+LpCXM30ThoCPTQEuOvJLTbhbnSid2sfzhWUEnM0nXWxaaTmlfDboVR+O5RKuJ8LgyIDGdDej5wiEzonta32ks6pwauPCCHEJTV4CYAJEybwySef0Lt3b+bPn8/333/P0aNHCQgIYPz48YSEhPD6668DsGPHDs6ePUu3bt04e/YsL774IgkJCezZswdPT08A1qxZg6IodOjQgRMnTjB79mwMBgObN29Gq9UC8MMPP+Dn50eLFi04ePAgjz76KD179uTHH3+0O3bZ3SbE30egZBeVYbYoHDyby9rDqWw7eQ7zX8eg6JzUXN/Wl0GRAUQGuaNSqXC5YHecTMcJIa6ketndVlxczLp167jppptwc3Or9IIbNmxg8ODBDi3gHjduHBkZGTz//POkpqbSrVs3Vq9ebVvMnZiYWGF9U0lJCc8++yzx8fG4uroybNgwFi1aZEuQAHJzc5kzZw5nzpzB29ubsWPH8uqrr9oSJICUlBRmzpxJWloaQUFBjB8/nueee87uuIUQ5S48AiWn2ISL3omoUE/yik1sOJ7OmsNpJGYV8fvRdH4/mk6ol5FBkQHcHBFAYamF5Nzi8t1xzjpcZHecEKKRsXsk6f3332fFihXExMRUeT86OprRo0dXqGHUnMlIkhBVO38ESk6RCatV4VhaPmtj09gcl0GJqfwYFCe1ij5tfBgUGUC3ME/UKpVMxwkhroh6KSbZu3dvnnvuOUaMGFHl/ZUrVzJ37twajxVpTiRJEqJmFqtCTlEZWYVllJisFJWZ2RyXyZrDqcSlF9ja+bvpGRgZQHTHAHxdy0eiXQ1OBHkY5KBdIUSdq5ckycvLi/3799OiRYsq7ycmJhIVFUV2drbjETdBkiQJYb/zR6DkFptQFEjILD8G5Y9j6RSW/n0MSo8WXgzqFEivll5ondT4u+vxc9WjUsm6JSFE3aiXNUlms5mMjIxqk6SMjAzMZtnmK4SozEXvhIveiaC/jkDROalp7evKxH6t2H6yvFDlwbO5/Hk6mz9PZ+PlrOW2biGM6hZCXrGZUC+jjCoJIa44u5OkTp06sX79enr27Fnl/bVr19rOQhNCiKpcfARKVmEZN0X4c2MHf5Jzilkbm0bM0TSyi0x8ue0UO09lMXNge0pMFgI9DLbpOCGEuBLsXh05efJkXn75ZVauXFnp3i+//MKrr77K5MmT6zQ4IUTz5WbQ0tLHhQ6BbgS462np68zEfq34ckIvHrmpLUathsPJeUz/bi+bjmeQklNCfEYBpWZLQ4cuhLhKOFQn6b777uPbb78lIiKCDh06AHD06FGOHz/OnXfeyXfffVdvgTY2siZJiLp18REoyTnFzFt3nGNp+QDc3MGffw1oUz5t52HAR0aVhBC1UC8Lt8/7/vvv+fbbb4mLi0NRFNq3b88999xTZdXr5kySJCHqT6nZwtnsYnKLTCz5M4kf/kzCqkCgu4HHB7YnIsgdV4MTIZ5GKRcghHBIvSZJopwkSULUL0VRSM8vJT2vlMPJucxbd5z0/FLUKrirVwvuvCYMrZOKYA8jXi66hg5XCNFE1PkBtwDJycnMmjWLvLy8Svdyc3OZPXt2pcNqhRCitlQqFQHuBlr7uRAV5smCu7ozoL0fVgW+3ZnInGUHSM4p4Ux2MafPFWKyWBs6ZCFEM2N3kjRv3jzy8vKqzLo8PDzIz89n3rx5dRqcEEK46p1o6+9KgIeBWYM68PjA9jjrNBxJzWf6d3v541g6ecVm4tIKyC0yNXS4QohmxO4kafXq1YwfP77a++PHj69y55sQQlwurUZNa18XAtz13BThz/t3dadjkDvFJgvz1h3nnbXHyC02kZhVROK5IswyqiSEqAN2J0kJCQnVFpIECA0N5dSpU3URkxBCVMnf3UArXxdCvYy8ProL9/ZpgVoFG49n8OiSvRxOziW32ERcegG5xTKqJIS4PHYnSUajscYk6NSpUxiNxrqISQghquWqd6Kdvysezlru6tWCN8d2JdDdQHp+KU//dJDF/ztNSZmFxHNFJGUVYbHK3hQhRO3YnST16dOHRYsWVXv/66+/pnfv3nUSlBBC1MTp/PSbh56OQe68f1c3bonwx6rA0j+TeHLZAZJziskpMnE8LZ/8EhlVEkI4zu4kadasWXz55ZfMmjWrwi62tLQ0Hn/8cRYuXMisWbPqJUghhKiKv5uB1r4ueDhrmRHdnicGd8BFr+F4WgGPLt3L+tg0TGYrpzKLOJNdhFVGlYQQDnCoTtInn3zCo48+islkwt3dHZVKRW5uLlqtlvfee4+HHnqoPmNtVKROkhCNh9li5Ux2MfklZjLyS5m37hiHksvLlVwX7sPUm9riZtCic1IT4mXEVW/3sZVCiGamXotJnj17lu+//54TJ07YKm7ffvvthIaGXlbQTY0kSUI0Phn5paTllWC2KCzbe4ZvdiRisSr4uOiYObA9XUM9AfBx1RHobkCtVjVswEKIK65BKm4fOXKEzz//nHfeeacuumv0JEkSonEqKjOTmFWEyawQl5bPO2uPkZxbggoY0yOUe/u0QKtRo9eqCfUy4qyTUSUhrib1UnG7KoWFhXz++ef069ePTp06sXr16svpTgghLpuzzol2/m64G51oF+DG+3d1Z3BkAArw454zzP7vfs5kF1FqsnIyvZDU3BLkdCYhRFVqlSRt3bqVyZMnExAQwAMPPEC/fv2IjY3l0KFDdR2fEEI4TKNW0dLHhSBPA0adhkdubsfTQyNw0ztxMqOQR5fuY/WhVBRFISO/lBPpBRSXWRo6bCFEI2N3kpSens5bb71FREQEt99+O56enmzYsAG1Ws3kyZOJiIiozziFEMJhvq56wv1c0Tmp6Rvuywd3d6dbmCdlZisfbTjBq78eIbfYRInJysmMAtLyZFRJCPE3u9ckGY1Gbr/9du677z4GDhyIWl2eX2m1Wvbv309kZGS9BtrYyJokIZoOi1XhbHYxucUmrIrCin3JfLX9FGargtdf5QN6tPACwKhTE+rljEGraeCohRD1oV7WJLVs2ZItW7awadMmjh8/ftlBCiHElaJRq2jh40ywpwGNWsVt3UN4944owryMZBeZeGHFYT7bHE+Z2UpxmZUT6QWk58uokhBXO7uTpKNHj7J48WJSUlLo1asXPXv25L333gNApZJttEKIxs/ngum3Nn6uzLuzG8O6BAHw8/5kHv9hH6fPFaIokJZbysmMQkpMslZJiKtVrUoAFBQU8N133/Hll1/yv//9jwEDBnDPPfdw22234efnVx9xNjoy3SZE02WxKrZjSwB2JmSx4Pc4cotN6DRqJl/XimFdglCpVKhUEOBuwM9N38BRCyHqwhWtk3S+PtKiRYvIysrCZLo6zkiSJEmIpi+rsIzknGIUBbILy5gfE8eexGwArmnpxfRb2uHlrAPAWa8h1MuI3knWKgnRlDVIMUmz2cyKFSsYM2ZMXXTX6EmSJETzUGKykJhVXjdJURRWHkjhy20JmCwKnkYtj97SjmtaeQOgUkGQhwEfVxlVEqKpqvMkqbCwEBcXF7sDcLR9UyRJkhDNh9WqcPaC6bfT5wp5Z+0xTp0rAuDWLkFMvK6VbRTJ1eBEiKcRndNl1eMVQjSAOt/d1rZtW9544w1SUlKqbaMoCuvWrWPo0KEsWLDAsYiFEKIBqdUqwrydCfUyolJBSx8X3r2jGyOjggFYeTCFx77fT0JmAQAFJWbi0vPJLixryLCFEPXMrpGkY8eO8fTTT7Nq1SqioqK45pprCA4OxmAwkJ2dTWxsLNu3b8fJyYk5c+bwr3/9C42mec/by0iSEM1TiclCUlYRJSYrAHtOZzM/5jjZRSac1Com9GvFyKhg1H/t6nUzOBHiZUSrkVElIZqCeluTlJiYyA8//MDmzZs5ffo0xcXF+Pr60r17dwYPHszQoUObfXJ0niRJQjRfVqtCcm4x2YXl02+5xSY++D2OHQlZAHQL82TGLe1sa5M0ahXBngY8/1rkLYRovBpk4fbVRpIkIZq/nKIyzmSX735TFIXVh1P5bEsCZWYrbgYnpt/cjmvb+Njaexi1BHsacJJRJSEarXqpuC2EEFcbT2cdbf1dMWjVqFQqhnYOYv6d3Wjj60J+iZlXfz3CR3+csBWczC02cTytgNziq6MUihDNnSRJQghRA4NWQ7ifK96u5VNpYd7OvHNHFGO6hwCw+nAqM5bu40R6+aJui1Uh8VwRSVlFWKwyUC9EUyZJkhBCXIJarSLE00gLb2fUatBq1Ey6rjWvjOqMt4uOsznFzP7vfn7ccwbrXysYcopMHE/LJ79ERpWEaKokSRJCCDt5OGtp6++KUVf+T2dUmCcf3NWdvm18MFsVFm47xXPLD5FZUAqA2aJwKrOIM9kyqiREU+RwkpSYmFjlydiKopCYmFgnQQkhRGOldyqffvP5a/rN3ahlztAIpt/cFoNWzYGzuUz7bi9bT2TanpNdaCIuPZ+CUnNDhS2EqAWHd7dpNBpSUlLw9/evcP3cuXP4+/tjsVwdJ2bL7jYhRG6RiTM5RVjLSyqRnFPMO2uPEffX+qTojv7cf0MbnHVOtuf4uOoIdDegVqsaImQhrnr1urtNURRUqso/3AUFBRgMBke7E0KIJuvv6bfy+nDBnkbeGtuVO3qGogLWH0lnxtJ9HE/Ltz3nXEEZcekFFMqokhCNntOlm5SbOXMmACqViueeew5nZ2fbPYvFwo4dO+jWrVudByiEEI1Z+fSbCym5JZwrKMNJo2Z831b0aOHFu+uOk5Jbwuz/7ueePi25vUcoGrWKMrOV+IxCfN3KR5Wq+sVTCNHw7E6S9u7dC5SPJB08eBCd7u/KsjqdjqioKGbNmlX3EQohRCOnUqkI9jTionfiTHb59FvnEA8+uLs7/7fhBJvjMln8v9PsTcxmZnR7/N3LR90z88vILzET5uVsG40SQjQeDq9JmjRpEu+///5Vvw5H1iQJIapSZraSmFVEcVn5+kxFUfjjWAYfbzxJscmCi07DQze2ZUB7P9tzVCrwc9Pj76aXUSUh6pkcS3IFSJIkhKiOoiik5pWQmV9mu5aaW8K7645xNLV8fdKNHfx4sH84Lvq/B/SNOjWhXs4YtDKqJER9qdckqbCwkDfeeIOYmBjS09Oxnt/W8Zf4+HjHI26CJEkSQlxKXomJM1nFthpJFqvC0l2JLP0zCasC/m56Hh/Ugcigv/8NUanA312Pn6uMKglRHxz5/LZ7TdJ5U6ZMYePGjfzjH/8gKChIfoiFEKIa7gYt7QI0JGYVUVRqQaNWcU+flnRv4cU7a4+Rnl/KnGUHuPOaMO7q1QKNWoWiQFpuKXnFJhlVEqKBOTyS5OnpyapVq7juuuvqK6YmQUaShBD2UhSFtLxSMvJLbdeKysx8vPEkfxzLAKBDgBuzBnUg0OPvUiqyVkmIulevdZK8vLzw9vaudXBCCHG1UalUBHoYaOXrjOavIpLOOidmDuzArEEdcNFpOJaWz/Qle/n9aJrtVANFgfS8Uk6kF1BUJnWVhLjSHE6SXn75ZZ5//nmKiorqIx4hhGi23Axa2gW44qL/ewptQHs/FtzVnU7B7hSbLLy3Po631x6joOTvpKjEVF5XKSW3GKucASfEFeNwkvTuu++yZs0aAgIC6NKlCz169KjwcNRHH31Eq1atMBgM9OnTh507d1bb1mQyMXfuXMLDwzEYDERFRbF69eoKbfLz85kxYwYtW7bEaDTSr18/du3aVaFNQUEBjzzyCKGhoRiNRiIjI/n4448djl0IIRyl1ahp7euCv7veds3f3cCrt3XhH9e2RK2CzXGZTFuyl8PJubY2ilJeV0mqdQtx5Ti8cPu2226rsxdfunQpM2fO5OOPP6ZPnz7Mnz+fwYMHc+zYsUpnwwE8++yzLF68mE8//ZSIiAjWrFnD6NGj2bZtG927dwfKF5YfOnSIRYsWERwczOLFi4mOjiY2NpaQkBCgvHr477//zuLFi2nVqhVr167l4YcfJjg4mJEjR9bZ+xNCiKqoVCoC3A246J1IyirCbFHQqFXceU0Y3cI8eWftMVJyS3j6p4Pc1asFd14TZpumO1+t2/uvM+A0cgacEPWmQesk9enTh169evHhhx8CYLVaCQsLY9q0aTz11FOV2gcHB/PMM88wdepU27WxY8diNBpZvHgxxcXFuLm58fPPPzN8+HBbm549ezJ06FBeeeUVADp37sy4ceN47rnnqm1zKbJwWwhRF0wWK2eyiytMrxWVmflkUzy/H00HoFOwO48P7ICfm77Cc7VOKkI8jbgZtFc0ZiGasnpduA2Qk5PDZ599xpw5c8jKygJgz549nD171u4+ysrK2L17N9HR0X8Ho1YTHR3N9u3bq3xOaWlppUN0jUYjW7ZsAcBsNmOxWGpsA9CvXz9WrFjB2bNny6vh/vEHx48fZ9CgQdXGW1paSl5eXoWHEEJcrvPTbwHues5vYHPWOfFYdHseH9geo1bD4eQ8Hl2yl+3x5yo812RWOJVZ9NdolLWK3oUQl8PhJOnAgQO0b9+eN998k3feeYecnBwAli1bxpw5c+zuJzMzE4vFQkBAQIXrAQEBpKamVvmcwYMHM2/ePOLi4rBaraxbt45ly5aRkpICgJubG3379uXll18mOTkZi8XC4sWL2b59u60NwAcffEBkZCShoaHodDqGDBnCRx99RP/+/auN9/XXX8fDw8P2CAsLs/u9CiHEpfi7G2jt64KT5u/psxs7+DN/XDfa+ruSX2rmtV+P8O+NJyk1Wyo8N6fIRFx6AblFpisdthDNmsNJ0syZM5k4cSJxcXEVRmyGDRvGpk2b6jS4i73//vu0a9eOiIgIdDodjzzyCJMmTUKt/vttLFq0CEVRCAkJQa/Xs2DBAu6+++4KbT744AP+97//sWLFCnbv3s27777L1KlTWb9+fbWvPWfOHHJzc22PpKSken2vQoirj4veiXb+rrga/l4uGuxp5K2xXRnTvXxN5a8HU5j1w34SsyruMDZbFBKzikg8V4RJRpWEqBMOJ0m7du3iX//6V6XrISEh1Y4AVcXX1xeNRkNaWlqF62lpaQQGBlb5HD8/P5YvX05hYSGnT5/m6NGjuLq60qZNG1ub8PBwNm7cSEFBAUlJSezcuROTyWRrU1xczNNPP828efMYMWIEXbt25ZFHHmHcuHG888471car1+txd3ev8BBCiLrmdMH023lajZpJ17XmpRGd8DRqOXWuiMe+38fqQ6lcvKw0t9hEXFoB2YVlF3cthHCQw0mSXq+vcj3O8ePH8fPzq+IZVdPpdPTs2ZOYmBjbNavVSkxMDH379q3xuQaDgZCQEMxmMz/++COjRo2q1MbFxYWgoCCys7NZs2aNrY3JZMJkMlUYWQLQaDSVzqETQoiG4u9uoKWvMxf+U9WjpRcL7u5O9zBPysxWPtpwgjdXH62w6BvKz4g7k13MqcxCyszy75oQteVwkjRy5Ejmzp2LyVQ+961SqUhMTOTJJ59k7NixDvU1c+ZMPv30U7766iuOHDnCQw89RGFhIZMmTQJg/PjxFdY57dixg2XLlhEfH8/mzZsZMmQIVquVJ554wtZmzZo1rF69moSEBNatW8dNN91ERESErU93d3cGDBjA7Nmz2bBhAwkJCSxcuJCvv/6a0aNHO/rlEEKIeuNu0BLu54pe+/c/1V7OOl4c2YlJ/VqhUavYevIc05fu5UhK5V9e80vMxKXnc66gtNI9IcSl1aqYZEFBAf7+/hQXFzNgwADatm2Lm5sbr776qkN9nZ/iev755+nWrRv79u1j9erVtsXciYmJFRZcl5SU8OyzzxIZGcno0aMJCQlhy5YteHp62trk5uYydepUIiIiGD9+PNdffz1r1qxBq/17i+ySJUvo1asX9957L5GRkbzxxhu8+uqrPPjgg45+OYQQol4ZtBrC/VxxN/69TkmtUjGmRyhvje1KkIeBjPxSnlp2gKW7ErFcVJHbaoXknBLiMwoqLfgWQtSs1nWStmzZwoEDBygoKKBHjx4VtvJfDaROkhDiSkvLKyE9r+KoUFGZmX9vOMmG4+UH5XYJ8eDxge3xcdVXer5KBQHuBnxddXJgrrhqOfL53aDFJJsySZKEEA0ht9jEmewiLl5C+fvRdP698QQlJitueicejW5Hn9Y+VfZh1GkI9TJi0GqqvC9Ec1bnSdKCBQt44IEHMBgMLFiwoMa206dPdyzaJkqSJCFEQykxWTh9rqjSouzknGLeWnOUkxmFANzaJYhJ17VG51R5ZYVKBf5uevzc9DKqJK4qdZ4ktW7dmj///BMfHx9at25dfWcqFfHx8Y5H3ARJkiSEaEgWq0JSVhH5F+1sM1msfL39FMv3JQPQyseZJwZHEObtXGU/Bq2aUC9njDoZVRJXB5luuwIkSRJCNAapuSVk5Ffevfbn6Szmr48jt9iE3knNA/3bMLBjQJWjRioV+LjqCHAzoJYDc0UzV+9ntwkhhGgcAj0MtPB25uLc55qW3iy4qzvdwjwpNVv54PcTvL32GAWl5kp9KApk5pcRl15AYRX3hbhaOZwkjR07ljfffLPS9bfeeos77rijToISQghhPw9nLW39XSutPfJ20fHSyE5M6FteU2lzXCaPLtnL0SpqKgGUma3EZxRyNqcYq1UmGYRwOEnatGkTw4YNq3R96NCh9X52mxBCiKqV11NyqXDuG5TXVLq9ZyhvjulKgLue9PxSnlx2gB/+TKpUU+m8rIIyjqfnk18iB+aKq5vDSVJBQQE6na7Sda1WW+VxJUIIIa4MJ42aVj7O+LpV/je6Q6Ab74/rTv92flgV+Pp/p3l+xaFqq3GbzAqnMotIyiqqNpkSorlzOEnq0qULS5curXR9yZIlREZG1klQQgghakelUhHkYSTM21hpnZKL3olZg9rz6C3t0DupOXAml2lL9rIzIava/nKKTBxPyye3WEaVxNXH6dJNKnruuecYM2YMJ0+e5OabbwYgJiaG7777jh9++KHOAxRCCOE4T2cdeicNp7MKMZn/HglSqVREdwwgItCNt9ccIz6zkJdXxTIyKpiJ/Vqh1VT+3dlsUUg8V4SHUUuwpwGnKtoI0RzVqgTAqlWreO2119i3bx9Go5GuXbvywgsvMGDAgPqIsVGSEgBCiKbAbLGSmFVEYWnlc9tMFisLt51ixf7ymkptfF2YPbgDoV5V11QC0KhVBHsa8HSuPKUnRFMgdZKuAEmShBBNhaIopOSWcK6grMr7OxOyeD/mOHklZvROah7sH84tHf1rrMTtZnAi2NNYZTVvIRozqZMkhBDCRqVSEexpJNSr8jolgN6ty2sqdQ31oNRs5f3f43hn7fEaaybll5iJS8+vduG3EM2BXSNJ3t7eHD9+HF9fX7y8vGr87SIrq/oFgM2JjCQJIZqi4jJLpXVK51msCsv2nGHxjtNYFQhw1zN7UAQdAt1q7NNFryHEy4jeSY42EY2fI5/fdi3cfu+993BzK/8hmT9//mUHKIQQomEYdRra+rlyOquIoovWKWnUKu64JowuIR68vfYYaXnlNZXu69OSMT1CUFfzC3JhqYW4tAIC3A34uemvxNsQ4oqwK0nav38/t99+O3q9ntatW9OvXz+cnBzeGCeEEKIRcNKoaePrQnJuCVlVrFOKCHLn/bu689EfJ9hyIpOvtp9i/5kcHotuj7dL1Qu2FaX8HLncYhOhXkYMWhlVEk2fXdNtWq2WM2fOEBAQgEajISUlBX9//ysRX6Ml021CiOYgq7CM5JxiqvokUBSFdUfS+GRTPGVmKx5GLTOi23FNS+8a+1SpwN9Nj5+bvsblGUI0hDqfbmvVqhULFixg0KBBKIrC9u3b8fLyqrJt//79HY9YCCFEg/B20WHQqjl9rgizpWKmpFKpGBQZSMdAd95ac5RT54p46ZdYRkUFM6GamkpQPqqUllf616iSM0adjCqJpsmukaTly5fz4IMPkp6ejkqlorqnqFQqLJbKtTiaIxlJEkI0J6a/6ildvE7pvDKzlS+3JbDyQAoA4X4uzB4UQYiXscZ+VSrwddXj76ZHrZZRJdHw6q1OUkFBAe7u7hw7dqza6TYPDw/Hom2iJEkSQjQ3iqJwNqeY7MLqjyDZkXCO99fHkV9qxqBV89CAcG6OCLhk33qtmhBPIy56Wc8qGlad10maOXMmhYWFuLq68scff9C6dWs8PDyqfAghhGiaVCoVoV7OBHsaqqynBNCntQ8f3N2dzsHulJisvLc+jnfXHaOorPqaSgClJivxGYUk5xRjlQNzRRMhC7drSUaShBDNWWGpmcSsyuuUzrNYFf67O4lvdyZiVSDIw8CsQR1oH1BzTSUArZOKEE8jbgZtXYctxCXV+XRbu3btuPPOOxk0aBA33XQTP/3001W/cFuSJCFEc2eyWDl9rojisurXmsam5PHO2mNk5JeiUasYf21LbutefU2lC3m5aAnyMKKRtUriCqrzJEkWblcmSZIQ4mqgKApnsovJKap+nVJBiZkP/ohj28lzAHQP8+Sx6PZ4VVNT6UJOmvIjUzyMMqokrgxZuH0FSJIkhLiaZBaUkppbUmU9JShPptbGpvGfzeU1lTyNWh6Lbk+PllXPOlzMw6gl2NOAUzVlBYSoK/WWJAFs3LiR66677qqvuC1JkhDialNQaibxXBGWGhZeJ2YV8dbqo5zOKgJgdPcQ/nFty2prKl1Io1YR7GnA0/nSI1BC1Fad72670IABAzh9+jTPPvssd999N+np6QD89ttvHD58uHYRCyGEaPRc9U609XfFqKv+o6OFtzPv3hnFsC5BAPy09yxP/HiA5JziS/ZvsSokZRVzKrMQk8VaZ3ELUVsOJ0kbN26kS5cu7Nixg2XLllFQUACUn+/2wgsv1HmAQgghGg+dk5o2vq54Ole/hkjvpOGhAeE8PawjrnonTqQXMGPpPjYcS7frNfJLzMSlFVBiujrWuIrGy+Ek6amnnuKVV15h3bp16HR/D4nefPPN/O9//6vT4IQQQjQ+arWKMG9nAj2qr6cE0LeNDwvu6k6nYHeKTRbeXXec99Ydv2RNJSgfVYrPKJRESTQoh5OkgwcPMnr06ErX/f39yczMrJOghBBCNH5+bnpa+brUuIXfz03Pq7d14Z7eLVCr4Pdj6Ty2dB8n0gsu2b/FqpCQKYmSaDgOJ0menp6kpKRUur53715CQkLqJCghhBBNw/l1SgZt9R8nGrWKu3u34LXRXfB11ZOcW8Ls/+5n+d6zWC+xd8hsKU+USs2SKIkrz+Ek6a677uLJJ58kNTUVlUqF1Wpl69atzJo1i/Hjx9dHjEIIIRoxnZOacD/XS9Y66hTswYK7utG3jQ9mq8LnWxN46ZdYcorKanyeJEqioThcAqCsrIypU6eycOFCLBYLTk5OWCwW7rnnHhYuXIhGo6mvWBsVKQEghBCVpeeXkJZbWmMbRVFYfTiVzzYnUGax4umsZWZ0e7q3qLmmktZJRRtfV3ROUktJ1F691kk6LzExkUOHDlFQUED37t1p165drYJtqiRJEkKIquWXmEjMKsJ6iV38p88V8uaaYyT9VVNpbI8Q7uvTssaCkjonNa19XSRRErV2RZIkwHY8icqOM3qaG0mShBCieqVmC4nniigx1ZwplZgsfL4lgdWHUwFoH+DK7EERBHoYqn2OzklNGz8XuwpUCnGxei0mCfD111/TpUsXjEYjRqORrl27smjRoloFK4QQovnRO2kI93PF3Vjz6QwGrYapN7XlqSERuOg1HE8rYPqSvWw8nlHtc8rMVhKk4KS4AhxOkubNm8dDDz3EsGHD+P777/n+++8ZMmQIDz74IO+99159xCiEEKIJUqtVtPRxIcBdf8m217X1ZcG47nQMKq+p9M7aY3y5NaHaA9VLTeWJklkSJVGPHJ5ua926NS+99FKlnWxfffUVL774IgkJCXUaYGMl021CCGG/vBITSXasU7JYFb7blcjSXUkATOrXijE9Qqttb9CWr1GSg3GFvep1ui0lJYV+/fpVut6vX78q6ycJIYQQ7gYt4X6u6GuopwTlNZXu69OSSf1aAfDltlP8frT640xKZERJ1COHk6S2bdvy/fffV7q+dOnSq26HmxBCCPsZtOXrlNwMNa9TAhjTI5TbugUDsOD3OHafzq62bYnJyqlzhVistd6HJESVLv2depGXXnqJcePGsWnTJq677joAtm7dSkxMTJXJkxBCCHGeRq2ila8LaXklpOfVXE9p0nWtySkyseF4Bq//doTXRnehfYBblW2Ly8pHlFpf4pgUIRzh8EjS2LFj2bFjB76+vixfvpzly5fj6+vLzp07qzzTTQghhLhYgLuBFj7OqGv4FFKrVEy/pR3dwzwpNVt56ZfDnM0urrZ9cZmFhEwZURJ157LqJF3NZOG2EEJcvhKThdPniigzV7+mqKjMzDM/HeJERgH+bnrevj0Kbxddte2d9Rpa+7iglhElUYV6WbidnJzMrFmzyMvLq3QvNzeX2bNnk5aW5ni0QgghrloGrYa2/jWvU3LWOfHCiEiCPAyk55fy4i+HKSw1V9u+qNTCqXOFWGVESVwmu5OkefPmkZeXV2XW5eHhQX5+PvPmzavT4IQQQjR/59cp+blVX0/J01nH3JGd8TRqScgs5NVfj9RYTLJQEiVRB+xOklavXl2pNtKFxo8fz8qVK+skKCGEEFefQA8DLbydqe6kq0APAy+M6IRRq+Hg2VzeXXe8xvVHhaUWTmcVVVuQUohLsTtJSkhIoEWLFtXeDw0N5dSpU3URkxBCiKuUh7OWtv6u1R5g29bflaeHdcRJrWLriUw+2xxfYxJUUGLm9DlJlETt2J0kGY3GGpOgU6dOYTQa6yImIYQQVzGDVlN+gK1T1UNK3cI8eSy6PQArD6bww+4zNfaXL4mSqCW7k6Q+ffrUeIjt119/Te/evWsVxEcffUSrVq0wGAz06dOHnTt3VtvWZDIxd+5cwsPDMRgMREVFsXr16gpt8vPzmTFjBi1btsRoNNKvXz927dpVoY1Kpary8fbbb9fqPQghhKg7Wo2alt4u1U699W/vx/03tAZg0f9Osy42tcb+8kvMJMrUm3CQ3UnSrFmz+PLLL5k1a1aFXWxpaWk8/vjjLFy4kFmzZjkcwNKlS5k5cyYvvPACe/bsISoqisGDB5OeXnUZ+meffZZPPvmEDz74gNjYWB588EFGjx7N3r17bW2mTJnCunXrWLRoEQcPHmTQoEFER0dz9uxZW5uUlJQKjy+++AKVSsXYsWMdfg9CCCHqnlGnIczbudr7I6NCGPvXuW4f/nGCnQlZNfaXV2wmKatYEiVhN4fqJH3yySc8+uijmEwm3N3dUalU5ObmotVqee+993jooYccDqBPnz706tWLDz/8EACr1UpYWBjTpk3jqaeeqtQ+ODiYZ555hqlTp9qujR07FqPRyOLFiykuLsbNzY2ff/6Z4cOH29r07NmToUOH8sorr1QZx2233UZ+fj4xMTF2xS11koQQ4spIzy8hLbfq6tyKojA/Jo7fj6ajc1Lz6qjORATV/G+yp7OWUC8jquqGqUSz5sjnt0PHkvzrX//i1ltv5fvvv+fEiRMoikL79u25/fbbCQ2t/pTm6pSVlbF7927mzJlju6ZWq4mOjmb79u1VPqe0tBSDwVDhmtFoZMuWLQCYzWYsFkuNbS6WlpbGqlWr+Oqrr6qNtbS0lNLSv39Iq6oXJYQQou75uxkoNVnJKTJVuqdSqZh2U1vyik38eTqbuStjeXNs1xpHoM73U1MbIaAWZ7eFhITw2GOP1cmLZ2ZmYrFYCAgIqHA9ICCAo0ePVvmcwYMHM2/ePPr37094eDgxMTEsW7YMi8UCgJubG3379uXll1+mY8eOBAQE8N1337F9+3batm1bZZ9fffUVbm5ujBkzptpYX3/9dV566aVavlMhhBCXI9TLSKnZSnGZpdI9J42aJ4dE8MzygxxPK+D5FYd55/au+LhWX3epPFEqkkRJ1Mjhs9sa2vvvv0+7du2IiIhAp9PxyCOPMGnSJNQXHAC0aNEiFEUhJCQEvV7PggULuPvuuyu0udAXX3zBvffeW2n06UJz5swhNzfX9khKSqrz9yaEEKJqKpWKlj7O1e54M2g1PH9rJ0I8jWQWlPLCisMUlFRflRvKE6Uz2UX1Ea5oJho0SfL19UWj0VQ6ziQtLY3AwMAqn+Pn58fy5cspLCzk9OnTHD16FFdXV9q0aWNrEx4ezsaNGykoKCApKYmdO3diMpkqtDlv8+bNHDt2jClTptQYq16vx93dvcJDCCHElaPVqGnlU/2ONw+jlpdGdsLbWcfprCJe+TWWUnPlkacLZReaOJtT/aG54urWoEmSTqejZ8+eFRZLW61WYmJi6Nu3b43PNRgMhISEYDab+fHHHxk1alSlNi4uLgQFBZGdnc2aNWuqbPP555/Ts2dPoqKiLv8NCSGEqFcGbc073gLcDbw4shPOOg2Hk/N4d23NVbkBsgrKSJZESVShwafbZs6cyaeffspXX33FkSNHeOihhygsLGTSpElA+XEnFy7s3rFjB8uWLSM+Pp7NmzczZMgQrFYrTzzxhK3NmjVrWL16NQkJCaxbt46bbrqJiIgIW5/n5eXl8cMPP1xyFEkIIUTj4WHUEuBR/Xqj1r4uPPtXVe7t8ef4eOPJS277P1dQRkquJEqiIocXbp9XVlZGeno6VmvFAwZrOrqkKuPGjSMjI4Pnn3+e1NRUunXrxurVq22LuRMTEyusJSopKeHZZ58lPj4eV1dXhg0bxqJFi/D09LS1yc3NZc6cOZw5cwZvb2/Gjh3Lq6++ilarrfDaS5YsQVEU7r77bgffvRBCiIZU0443gC6hnswa1IE3Vx9l9eFUvF103N275s+nzPwyVKgI9Kh+faq4ujhUJwkgLi6OyZMns23btgrXFUVBpVLZdpk1d1InSQghGpaiKJzMKKxyx9t5qw6m8PHGkwBMvbEtQzpXvd71Qv7uegLcJVFqruqtThLAxIkTcXJyYuXKlQQFBUkxLiGEEA1CpVLRyseZExkFmMxV/74/vEsQ2YVlLP0ziX9vPIGHs5a+bXxq7Dc9rxQV4C+J0lXP4ZEkFxcXdu/eTURERH3F1CTISJIQQjQOJSYLJ9ILqO7TTFEUPvzjBGtj09Bp1Mwd1YlOwR6X7DfAQ4+/myRKzY0jn98OL9yOjIwkMzOz1sEJIYQQdelSO95UKhUP39iW3q28KbNYeXlVLKfPFV6y37TcUjLyqz4ORVwdHE6S3nzzTZ544gk2bNjAuXPnyMvLq/AQQgghrrRL7XjTqFXMHtyBiEA3CkstvLDiMOn5JZfsNzW3hMwCSZSuVg5Pt53faXbxWiRZuC2EEKKhJWUVVbvjDSC/xMSTPx4gKbuYMC8jb47tiptBW23784I8DfjWcMyJaDrqdeH2H3/8UevAhBBCiPoU6mWkzGKlqLTqX9jdDFpeGtmZ2f/dT1J2MS+vjGXuqM4YtJoa+03JKUEFNZ4HJ5ofh0eSRDkZSRJCiMbJbLHWuOMN4PS5Qp5cdoDCUgu9W3nz9LCOaNSX3q0d4mXE20VXl+GKK8yRz+9aJUk5OTl8/vnnHDlyBIBOnToxefJkPDwuvVuguZAkSQghGq9L7XgDOJycy/M/H6bMYmVgZADTbmprV1mbUC8jXpIoNVn1urvtzz//JDw8nPfee4+srCyysrKYN28e4eHh7Nmzp9ZBCyGEEHXFoNXQwqf6HW8AnYI9mD24A2oVrItN45sdiXb1fSa7mJyisroIUzRyDo8k3XDDDbRt25ZPP/0UJ6fyJU1ms5kpU6YQHx/Ppk2b6iXQxkZGkoQQovFLzy8hLbfm3WlrDqfy4R8nAHhwQDjDuwRdsl+VCsK8nPFwvvSib9G41Ot0m9FoZO/evZWKScbGxnLNNddQVFTkeMRNkCRJQgjRNFxqxxvAdzsT+XZnIirgySERXNfW95L9SqLUNNXrdJu7uzuJiZWHJJOSknBzc3O0OyGEEKJehXoZcdbXvHvtrl5hDOkUiAK8s/YYB8/kXLJfRYGk7CJyi2tOwETT5XCSNG7cOP75z3+ydOlSkpKSSEpKYsmSJUyZMoW77767PmIUQgghak2lUtHS2xmtU/WLslUqFQ8OCKdvGx/MVoVXfj1CQualq3IrSvlIVV6JJErNkcPTbWVlZcyePZuPP/4Ys9kMgFar5aGHHuKNN95Ar786akjIdJsQQjQtJSYLJzMKsFqrb1NmtvL8ikMcTs7D21nHW7d3JcCOg25VKmjp42xXYUrRsOq9BABAUVERJ0+eBCA8PBxn55p3ETQ3kiQJIUTTk1di4nRmzWtnC0rNPPXjAU5nFRHiWV6V28N46eRHEqWmoV7XJJ3n7OxMly5d6NKly1WXIAkhhGia3A1aAj1qHhly1Tvx0shO+LnpOZtTzNyVhykxXfrILUWB0+eKKCg111W4ooHZNZI0ZswYFi5ciLu7O2PGjKmx7bJly+osuMZMRpKEEKLpsmfHW1J2EU/+9wD5pWZ6tvTi2WEdcdJcemxBpYLWvi646B0++UtcAXU+kuTh4WGrQuru7o6Hh0e1DyGEEKKxs2fHW5iXM8+PiETnpGb36Ww++OME9qxQURRIyCykUEaUmjw5u62WZCRJCCGaNrPFysmMQsrMNazkBnadyuKVVbFYFbi9RygT+rWyq3+1unxEyVknI0qNSb2uSbr55pvJycmp8kVvvvlmR7sTQgghGoSTRk1LH2fUl/gk7NXKm2k3tQPgv3vOsGJ/sl39W63lI0rFZZdezyQaJ4eTpA0bNlBWVvnMmpKSEjZv3lwnQQkhhBBXgkGrIcz70puPoiMD+Me1LQH4bHM8m+My7OrfaoX4zAJJlJoou8cADxw4YPv/2NhYUlNTbX+2WCysXr2akJCQuo1OCCGEqGfnd7yl5pbU2O6OnqFkF5ax8mAK89Ydx92gJSrM85L9nx9RauPngkFb8zoo0bjYnSR169YNlUqFSqWqclrNaDTywQcf1GlwQgghxJXg56an1Gwhu7D6HW8qlYopN7Qhu9jE1hOZvPrrEV4f04VwP9dL9m+xKsRnSKLU1NidJCUkJKAoCm3atGHnzp34+fnZ7ul0Ovz9/dFo5C9eCCFE0xTiaaTUbKWotPqpMY1axeMD25NfbOLA2Vxe/OUwb4+NumTtJShPlBIyC2ntK4lSUyG722pJdrcJIUTzY++Ot8JSM3N+OkhCZiFBHgbeGtsVT2edXa/hpFFJotSArsixJLGxsSQmJlZaxD1y5MjadNfkSJIkhBDNkz1nvAFkFZYx+7/7Sc8vpa2fK6+N7oJRZ1/i46RR0cbPBb2TJEpXWr0mSfHx8YwePZqDBw+iUqlshbXOF5u0WK6OFfySJAkhRPNlzxlvAGezi3nix/3klZjpHubJc7dGorWjKjeA1klFG19XdE61PiFM1EK91kl69NFHad26Nenp6Tg7O3P48GE2bdrENddcw4YNG2obsxBCCNFo2HPGG0CIl5EXRnRC76Rmb1IOC2LisNo59mAyK8RnFlxyak80HIeTpO3btzN37lx8fX1Rq9Wo1Wquv/56Xn/9daZPn14fMQohhBBXnJ+bHi8X7SXbtQ9wY87QjmjUKjYcz+DLrafsfg2TuXwxtyRKjZPDSZLFYsHNzQ0AX19fkpPLK4+2bNmSY8eO1W10QgghRAMK8TTicokz3gB6tvRi+s3lVbmX7zvLT3vP2P0aZWYrCZmFmCySKDU2DidJnTt3Zv/+/QD06dOHt956i61btzJ37lzatGlT5wEKIYQQDUWlUtHC29mudUM3R/gz6a9z3b7Yeoo/jqXb/TqSKDVODidJzz77LNa/lvzPnTuXhIQEbrjhBn799VcWLFhQ5wEKIYQQDcneM94ARncPYVRUMADvx8Sx53S23a9TaipPlMySKDUadVInKSsrCy8vL9sOt6uB7G4TQoirS36JidPnirjUp6ZVUZi37jgbj2dg0Kp57bYutAtws/t1DFo1rX1dcLJzl5xwTL3ubquKt7f3VZUgCSGEuPq42bnjTa1S8egt7egW5kmJycpLK2NJzim2+3VKTFZOnZMRpcbArpGkMWPG2N3hsmXLLiugpkJGkoQQ4up0JruoxjPezisqM/PMT4c4kVFAgLuet8dG4eViX1VuKB9RauXrYnfdJWGfOh9J8vDwsPshhBBCNGf27nhz1jnx/IhIgjwMpOWV8uIvhykqM9v9OiUmK/F2HJEi6o+c3VZLMpIkhBBXL3vPeANIyS3mif8eIKfYRNdQD14c0cmh0SE5661u1fuaJLPZzPr16/nkk0/Iz88HIDk5mYKCgtp0J4QQQjQpjux4C/Ior8pt1Go4cCaXeeuO212VG8BsUYjPKKS47Oo49qsxcThJOn36NF26dGHUqFFMnTqVjIwMAN58801mzZpV5wEKIYQQjZFBq6GFtzP27Ftq6+/K08M64qRWseVEJp9tjseRiRyLtfwIk8JS+6frxOWr1dlt11xzDdnZ2RiNRtv10aNHExMTU6fBCSGEEI2ZvTveALqFefJYdHsAfjmQwo97zjr0WlYrJGQWkl9y6UXjom44OfqEzZs3s23bNnS6iiv0W7Vqxdmzjv2FCyGEEE2dr6ueEpPFrh1v/dv7kV1UxmdbEvhq+ym8nLXc0jHA7tdSFDh9rogwL2c8nC99rpy4PA6PJFmtViyWyvOiZ86csZ3pJoQQQlxN7N3xBjCqWwhje4QAsOD3OP48leXQaykKJGUXkV1Y5nCcwjEOJ0mDBg1i/vz5tj+rVCoKCgp44YUXGDZsWF3GJoQQQjQJjpzxBjChbytu7uCPVYE3Vh/lWGq+Q6+nKHAmu5jMgtLahCvs5HAJgKSkJIYMGYKiKMTFxXHNNdcQFxeHr68vmzZtwt/fv75ibVSkBIAQQoiLlZgsnMwowGpHaSOzxcorvx5h9+ls3AxOvDW2K6Fezg6/ZoC7Hn93+9ZFCcc+v2tVJ8lsNrN06VL2799PQUEBPXr04N57762wkLu5kyRJCCFEVew94w3Kk6qnfzpIXHoB/m563hrbFR9XvcOv6eumI8jj6vkMvhz1liSZTCYiIiJYuXIlHTt2vOxAmzJJkoQQQlQns6CUlJwSu9rmFpt44r/7Sc4toZWPM6+P6Yqr3uF9VXi5aGs1EnW1qbdiklqtlpIS+/7ShRBCiKuVr6seb1f7zmnzMGp5aVRnvJy1nDpXxKurYmt1FEl2oYmkrCKH6i+Jmjm8cHvq1Km8+eabmM1S0EoIIYSoTrCHwe4db4HuBl4a2QlnnYZDyXm8u+4YFqvjyU5OUflUn7UWzxWVOZwk7dq1i2XLltGiRQsGDx7MmDFjKjwc9dFHH9GqVSsMBgN9+vRh586d1bY1mUzMnTuX8PBwDAYDUVFRrF69ukKb/Px8ZsyYQcuWLTEajfTr149du3ZV6uvIkSOMHDkSDw8PXFxc6NWrF4mJiQ7HL4QQQlTF0R1vrX1defavqtzbTp7jPw5W5T4vv8TMqXOFtUqyREUOJ0menp6MHTuWwYMHExwcjIeHR4WHI5YuXcrMmTN54YUX2LNnD1FRUQwePJj09PQq2z/77LN88sknfPDBB8TGxvLggw8yevRo9u7da2szZcoU1q1bx6JFizh48CCDBg0iOjq6QqHLkydPcv311xMREcGGDRs4cOAAzz33HAaD7A4QQghRdxw54w2gS6gnswZ1QAX8etDxqtznFZZaSMgsxGxxfNpO/M2hhdtms5lvv/2WQYMGERgYeNkv3qdPH3r16sWHH34IlBeqDAsLY9q0aTz11FOV2gcHB/PMM88wdepU27WxY8diNBpZvHgxxcXFuLm58fPPPzN8+HBbm549ezJ06FBeeeUVAO666y60Wi2LFi2yO9bS0lJKS/+uR5GXl0dYWJgs3BZCCHFJjux4A/hlfzL/2RwPwKxBHRjQ3q9Wr2vQqmnl64JWU6vz7Julelu47eTkxIMPPlghWaitsrIydu/eTXR09N/BqNVER0ezffv2Kp9TWlpaabTHaDSyZcsWoDyJs1gsNbaxWq2sWrWK9u3bM3jwYPz9/enTpw/Lly+vMd7XX3+9wohZWFiYo29ZCCHEVcqRM94ARkQFc1u3YADmrz/OwbO5tXrdEpOV+IzCWi0EF7WYbuvdu3eF6a3ayszMxGKxEBBQ8cyagIAAUlNTq3zO4MGDmTdvHnFxcVitVtatW8eyZctISUkBwM3Njb59+/Lyyy+TnJyMxWJh8eLFbN++3dYmPT2dgoIC3njjDYYMGcLatWsZPXo0Y8aMYePGjdXGO2fOHHJzc22PpKSky/4aCCGEuHo4suMNYNJ1rekX7oPZqvDqr7EkZRXV6nXLzFbiMwsoMVU+UkzUzOFCDA8//DCPP/44Z86coWfPnri4uFS437Vr1zoL7mLvv/8+999/PxEREahUKsLDw5k0aRJffPGFrc2iRYuYPHkyISEhaDQaevTowd13383u3buB8pEkgFGjRvHYY48B0K1bN7Zt28bHH3/MgAEDqnxtvV6PXu94gS8hhBDivGAPA6UmC4Wll05Y1CoVMwe2J7vwEEdS83nxl8O8c3sUXi72J1rnmcwK8RmFtPZ1waizb8edqMVI0l133UVCQgLTp0/nuuuuo1u3bnTv3t32X3v5+vqi0WhIS0urcD0tLa3a9U5+fn4sX76cwsJCTp8+zdGjR3F1daVNmza2NuHh4WzcuJGCggKSkpLYuXMnJpPJ1sbX1xcnJyciIyMr9N2xY0fZ3SaEEKJeqVQqWvq42L3jTe+k4ZnhkQR7GEjPL2XuythajwhZrArxmQUUlkoJH3s5nCQlJCRUesTHx9v+ay+dTkfPnj2JiYmxXbNarcTExNC3b98an2swGAgJCcFsNvPjjz8yatSoSm1cXFwICgoiOzubNWvW2NrodDp69erFsWPHKrQ/fvw4LVu2tDt+IYQQojY0apVDO948jFpeHNkJd4MTJzIKeGvN0Vpv77daISGzkPwSU62ef7VxeLqtLhOJmTNnMmHCBK655hp69+7N/PnzKSwsZNKkSQCMHz+ekJAQXn/9dQB27NjB2bNn6datG2fPnuXFF1/EarXyxBNP2Ppcs2YNiqLQoUMHTpw4wezZs4mIiLD1CTB79mzGjRtH//79uemmm1i9ejW//PILGzZsqLP3JoQQQlTHoNXQwtvZ7h1vQR5Gnrs1kmd+OsSuU9l8sukkDw0IR6VSOfzaigKnzxUR5u2Mh1Fbi+ivHo4fDkN5naH58+dz5MgRACIjI3n00UcJDw93qJ9x48aRkZHB888/T2pqKt26dWP16tW2xdyJiYmoL0i1S0pKePbZZ4mPj8fV1ZVhw4axaNEiPD09bW1yc3OZM2cOZ86cwdvbm7Fjx/Lqq6+i1f79jTB69Gg+/vhjXn/9daZPn06HDh348ccfuf7662vz5RBCCCEc5mbQEuRhINnOM94iAt2ZNag9r/92lN8OpRLgbmBsj9BavbaiQFJWEVZPY63WOF0tHKqTBOUjNSNHjqRbt25cd911AGzdupX9+/fzyy+/MHDgwHoJtLGRA26FEELUhbM5xWQVlNndfsX+ZD79q4bS7EEd6F/LGkrnBXka8HW9ejYmOfL57XCS1L17dwYPHswbb7xR4fpTTz3F2rVr2bNnj+MRN0GSJAkhhKgLiqJw6lwRBSX2L6j+bHM8P+9Pxkmt4uVRnekc4tiJFxcLcNfj7351nDpRb8UkofzMs3/+85+Vrk+ePJnY2FhHuxNCCCGuaufPeNNr7f9Innz93zWUXrmMGkrnpeWVkpJbfFl9NEcOJ0l+fn7s27ev0vV9+/bh7+9fFzEJIYQQVxVHd7ydr6EUEehGYamFF385THah/VN2VcnML+NM9uUlW82Nwwu377//fh544AHi4+Pp168fUL4m6c0332TmzJl1HqAQQghxNdA7aWjp48KpzEK7drzpnTQ8OzyS2f/dT0puCXNXxvL6mC4YtLUvFpldaEJRigj1MtZq51xz4/CaJEVRmD9/Pu+++y7JyclA+cGzs2fPZvr06VfNF1XWJAkhhKgP5wpK7d7xBpCcU8zs/+4nr8RMr1ZePDMsEo368j6L3QxOtPB2Rn2Z/TRG9bpw+0L5+flA+ZlpVxtJkoQQQtQXR3e8HU3N45mfDlFmsTK0c2CtayhdyEWvoZWPS7NLlOpl4XZxcTErVqywJUZQnhy5ubmRl5fHihUrKC0trX3UQgghhADKz3hz0ds/bXa+hpIK+O1QKsv2nr3sGApLLcRnFmK2WC+7r6bK7iTpP//5D++//36Vo0bu7u4sWLCAzz77rE6DE0IIIa5GKpWKMG9nh6bN+ob7MuWG1gAs3HaKTcczLjuO4jILCZmFmK7SRMnuJOmbb75hxowZ1d6fMWMGX331VV3EJIQQQlz1tBo1Yd5Gh54zMiqEkVHBALy3/jiHk3MvO44Sk5X4jELKzFdfomR3khQXF0dUVFS197t27UpcXFydBCWEEEKI8qNL/Nwcq4Y9+brW9G3zVw2lVUdIqoNt/WVmK/GZBZSYLJfdV1Nid5JkNpvJyKh+6C4jIwOz2f5qoUIIIYS4tAB3Pc4OrE/SqFU8Pqg9HQLcKCg18+KKw2QXXV4NJQCTWSE+o5DisqsnUbI7SerUqRPr16+v9v7atWvp1KlTnQQlhBBCiHIqlYowL8fWJ+mdNDx3ayRBHgbS80uZuzK2TkaBLFaF+MwCCkuvjkERu5OkyZMn8/LLL7Ny5cpK93755RdeffVVJk+eXKfBCSGEEAJ0TmpCvBxbn+Rh1PLiiE64G5w4kV7AW2uOYrHWuuqPjdUKCZmF5JeYLruvxs6hOkn33Xcf3377LREREXTo0AGAo0ePcvz4ce68806+++67egu0sZE6SUIIIa605JxizjlQPwngaEoezyyv2xpKACoVhHk742HUXnZfV1K9HXC7ePFilixZQvv27Tl+/DjHjh2jQ4cOfPfdd1dVgiSEEEI0hCAPA0adY8eORAS58/gFNZR+qoMaSgCKAklZRZd9ZlxjdlkVt69mMpIkhBCiIZSaLZxIL8Dq4I78FfvP8unmBACeGNyBG9r51VlMQZ4GfF0d24XXUOptJEkIIYQQDUvvpCHU09nh511YQ2neurqpoXReSk4J6Xn2nzfXVEiSJIQQQjQxHs5avF11Dj+vPmoonZeWV0pKbnGd9dcYSJIkhBBCNEHBHgYMWsc+xjVqFTMH1n0NpfMy88s4m9N8EiVJkoQQQogm6Pz5bo5uVDNo66eG0nlZBWUkZRXRHJY8O5wkffnllxQV1d3wnBBCCCFqx6DVEOpg/ST4u4aSWx3XUDovp8jE6XNFWOuwz4bgcJL01FNPERgYyD//+U+2bdtWHzEJIYQQwk6ezjq8XByvVRTsaeT54ZHoNGp2ncrmk00n63T0J7/EzKlzhU06UXI4STp79ixfffUVmZmZ3HjjjURERPDmm2+SmppaH/EJIYQQ4hKCPYwOr0+C8hpKMwfWfQ2l8wpLLcRnFtbpKNWV5PBX1MnJidGjR/Pzzz+TlJTE/fffzzfffEOLFi0YOXIkP//8M1ZHizcIIYQQotbU6tqtTwK4rq0v/7y+NQBfbjvF5rjqD7OvjeIyC/EZBZgsTS83uKyF2wEBAVx//fX07dsXtVrNwYMHmTBhAuHh4WzYsKGOQhRCCCHEpRi0GoI9HV+fBDCqW/3VUAIoMVmJzyikzNy0EqVaJUlpaWm88847dOrUiRtvvJG8vDxWrlxJQkICZ8+e5c4772TChAl1HasQQgghauDtosPTuXZnqV1cQ+lMHdZQAigzW4nPLKjTnXT1zeFjSUaMGMGaNWto3749U6ZMYfz48Xh7e1dok56eTmBgYLOedpNjSYQQQjRGVqvCiYwCSk2OfwaXmCw8u/wQx9LyCXDX8/btUXg5O160siYatYrWvi4On0FXV+r1WBJ/f382btzIoUOHmDFjRqUECcDPz4+EhARHuxZCCCHEZVKrVbSo5fqkC2sopeWV8nId11ACsFgV4jMLKCw112m/9UEOuK0lGUkSQgjRmJ0rKCU5p3bnqZ3NLmb2j/vJLzHTu5U3Tw/riEZdi6yrBioVtPRxxs1Qu+nB2nLk89uuJGnBggV2v/j06dPtbtuUSZIkhBCisUs8V0RusalWzz2Sksczyw9isigM6xLEg/3boKrN8FQNVCoI83bGw3jlEqU6T5Jat25t1wurVCri4+Pti7KJkyRJCCFEY2exKpxIL6j1rrKtJzJ5c/VRFGBSv1aM6RFatwFSniiFeBrxcqnbtU/VceTz28meDmV9kRBCCNH0aP5an3Qyo4DaLK65rq0vk69vzedbEvhy2yn83PTc0M6vTmNUFDiTXYxVUfBx1ddp35dLDrgVQgghmjGjTkOgh6HWzx8VFcyIrkFA/dRQOi85p4T0/Nqtoaovdo0kXezMmTOsWLGCxMREysrKKtybN29enQQmhBBCiLrh66qnsNRMXrHjO8pUKhX/vL4NGQWl/C8+i1dWHeHt27sS6uVc53Gm5ZZitXJZSV1dcjhJiomJYeTIkbRp04ajR4/SuXNnTp06haIo9OjRoz5iFEIIIcRlCvVyJs6Uj8ns+LybRq3i8YEdbDWUXvzlcL3UUALIyC/FoiiE1LJ6eF1yeLptzpw5zJo1i4MHD2IwGPjxxx9JSkpiwIAB3HHHHfURoxBCCCEuk+Yy6ifBlamhdF5WQRmZBaX10rcjHE6Sjhw5wvjx44Hyw26Li4txdXVl7ty5vPnmm3UeoBBCCCHqhrPOCX/32i+O9jBqeeHWTrjpnYhLL+DtNcewWOun3KK1nvp1hMNJkouLi20dUlBQECdPnrTdy8zMrLvIhBBCCFHn/N0MuBlqtSQZgBAvI8/eGolWo2LnqSw+3RxPc61L7XCSdO2117JlyxYAhg0bxuOPP86rr77K5MmTufbaa+s8QCGEEELUrVAvI06a2heGjAxy5/GBHVABqw6msHzf2boLrhFxOEmaN28effr0AeCll17illtuYenSpbRq1YrPP/+8zgMUQgghRN1y0qgva30S/FVD6bryYtNfbD3FlhPNbzZJzm6rJam4LYQQoqlLzyshLa/2C6QVReE/m+NZeSAFrUbFy6M60ynYo05iC3DX4+9e96UAHPn8vqxikgUFBeTl5VV4CCGEEKJp8Hc34KLX1Pr5KpWKKde3oU9rb0wWhVdXHeFMdlEdRtiwHE6SEhISGD58OC4uLnh4eODl5YWXlxeenp54eXnVR4xCCCGEqCdh3s6XtT5Jo1Yxa1AH2ge4kl9q5sVfDpNdVHbpJzYBDi9vv++++1AUhS+++IKAgIA6PxFYCCGEEFeOVqMm1MvIqczajwAZtBqeGx7J7P8eIDWvhJdXxvLa6C4YtLUfpWoMHF6T5Orqyu7du+nQoUN9xdQkyJokIYQQzUlaXgnpl7E+CeBsdjGz/7uf/FIzfVp7M2doRzTq2g2mNMk1Sb169SIpKanWwQkhhBCi8fF30+N8GeuToGINpR0JTb+GksPTbZ999hkPPvggZ8+epXPnzmi12gr3u3btWmfBCSGEEOLKUKnKjy2JSyu4rCrakUHuzBzYgTdXH2XVwRQC3PWM7h5ah5FeOQ4nSRkZGZw8eZJJkybZrqlUKhRFQaVSYbHUzzkuQgghhKhfWo2aUG8jpy9jfRLA9W19ybiuFV9sPcUXW0/h52bg+ra+dRTllePwdNvkyZPp3r0727dvJz4+noSEhAr/rY2PPvqIVq1aYTAY6NOnDzt37qy2rclkYu7cuYSHh2MwGIiKimL16tUV2uTn5zNjxgxatmyJ0WikX79+7Nq1q0KbiRMnolKpKjyGDBlSq/iFEEKI5sLdoMXXTXfZ/dzWLYRbuwQBMG/dMQ4n5152n1eawyNJp0+fZsWKFbRt27ZOAli6dCkzZ87k448/pk+fPsyfP5/Bgwdz7Ngx/P39K7V/9tlnWbx4MZ9++ikRERGsWbOG0aNHs23bNrp37w7AlClTOHToEIsWLSI4OJjFixcTHR1NbGwsISEhtr6GDBnCl19+afuzXl/7Q/+EEEKI5iLQ3UBhqYXistrPDqlUKqbc0IaMglJ2JGTx6qojvHV7V0K9nOsw0vrl8O62ESNGMHHiRMaOHVsnAfTp04devXrx4YcfAmC1WgkLC2PatGk89dRTldoHBwfzzDPPMHXqVNu1sWPHYjQaWbx4McXFxbi5ufHzzz8zfPhwW5uePXsydOhQXnnlFaB8JCknJ4fly5fbFWdpaSmlpX+v+s/LyyMsLEx2twkhhGiWysxW4tLzsVovr58Sk4Vnlh/keFoBAe563r49Ci/nS49UNYbdbQ6PJI0YMYLHHnuMgwcP0qVLl0oLt0eOHGl3X2VlZezevZs5c+bYrqnVaqKjo9m+fXuVzyktLcVgqPhFMxqNtkN3zWYzFoulxjbnbdiwAX9/f7y8vLj55pt55ZVX8PHxqfJ1X3/9dV566SW735sQQgjRlOmc1IR6OZN47vLWJ52voTTrv/tJyyvllVWxvHpb06ih5PBIklpd/TImRxduJycnExISwrZt2+jbt6/t+hNPPMHGjRvZsWNHpefcc8897N+/n+XLlxMeHk5MTAyjRo3CYrHYRnr69euHTqfj22+/JSAggO+++44JEybQtm1bjh07BsCSJUtwdnamdevWnDx5kqeffhpXV1e2b9+ORlP5L05GkoQQQlyNknOKOVdw+RW0z2QX8cR/D9hdQ6kxjCQ5vHDbarVW+7gSO9vef/992rVrR0REBDqdjkceeYRJkyZVSN4WLVqEoiiEhISg1+tZsGABd999d4U2d911FyNHjqRLly7cdtttrFy5kl27drFhw4YqX1ev1+Pu7l7hIYQQQjR3QR4GjLrLOuoVgFAvZ54Z3tFWQ+mzJlBD6fLf9WXw9fVFo9GQlpZW4XpaWhqBgYFVPsfPz4/ly5dTWFjI6dOnOXr0KK6urrRp08bWJjw8nI0bN1JQUEBSUhI7d+7EZDJVaHOxNm3a4Ovry4kTJ+rmzQkhhBDNgEqlIszbmRomkuzWKdiDmQPLT+xYeTCFn/clX36n9ahWb3njxo2MGDGCtm3b0rZtW0aOHMnmzZsd7ken09GzZ09iYmJs16xWKzExMRWm36piMBgICQnBbDbz448/MmrUqEptXFxcCAoKIjs7mzVr1lTZ5rwzZ85w7tw5goKCHH4fQgghRHOmd9IQ6lk3u9Kub+vL5OtaAfD51gS2nMisk37rg8MLtxcvXsykSZMYM2YM06dPB2Dr1q3ccsstLFy4kHvuuceh/mbOnMmECRO45ppr6N27N/Pnz6ewsNBWrHL8+PGEhITw+uuvA7Bjxw7Onj1Lt27dOHv2LC+++CJWq5UnnnjC1ueaNWtQFIUOHTpw4sQJZs+eTUREhK3PgoICXnrpJcaOHUtgYCAnT57kiSeeoG3btgwePNjRL0m1FEWxLSQXQgghLqTRaHBycmoyB8V7OGvxLtORVQfrk27rFkJaXimrDqYwb90xvF10RAY1vmUsDidJr776Km+99RaPPfaY7dr06dOZN28eL7/8ssNJ0rhx48jIyOD5558nNTWVbt26sXr1agICAgBITEyssJaopKSEZ599lvj4eFxdXRk2bBiLFi3C09PT1iY3N5c5c+Zw5swZvL29GTt2LK+++qptJ55Go+HAgQN89dVX5OTkEBwczKBBg3j55ZfrrFZSWVkZKSkpFBVd3q4AIYQQzZezszNBQUHodJdfvPFKCHI3UFRqpsR0eXUBVCoV99/Qhoz8UnaeyuKVlbG8fXsUIV7GOoq0bji8u02v13P48OFKxSRPnDhB586dKSkpqdMAG6uaVsdbrVbi4uLQaDT4+fmh0+mazG8KQggh6p+iKJSVlZGRkYHFYqFdu3Y17h5vTEpMFk6kF1AXa65LTBae/ukgcekFBLobePv2rnj+VUOpMexuc3gkKSwsjJiYmEpJ0vr16wkLC3O0u2aprKzMVhTT2bnpVBYVQghx5RiNRrRaLadPn6asrKxSfb/GyqDVEOJp5Ex2cZ309dytkcz+735S80p4uZHVUHI4SXr88ceZPn06+/bto1+/fkD5mqSFCxfy/vvv13mATVlT+a1ACCFEw2iqnxNeLjoKSs3kFJkuvy9nHS+O6MQT/z3A8bQC3ll7jDlDO9ZBlJfP4b+dhx56iCVLlnDw4EFmzJjBjBkzOHToEEuXLuVf//pXfcQohBBCiEYmxNOIXls3SV5jraHk8EgSwOjRoxk9enRdxyKEEEKIJkKtVtHC27nO1id1Cvbgsej2vLXmGCsPphDu78pjA9tffseXodYpYFlZGWfOnCExMbHCQ4jGIDU1lYEDB+Li4lJh56No2m688UZmzJjR0GHY7T//+Q9hYWGo1Wrmz5/f0OEIUecMWg3BnnW3I+2Gdn5M6tcKgPdj4lh1IKXO+q4Nh5OkuLg4brjhBoxGIy1btqR169a0bt2aVq1a0bp16/qIUVwhEydORKVS8eCDD1a6N3XqVFQqFRMnTrzygdXCe++9R0pKCvv27eP48eO16kOlUlV6LFmypEKbDRs20KNHD/R6PW3btmXhwoWV+vnoo49o1aoVBoOBPn36sHPnzlrF01S98cYbqFSqSslNamoq//jHPwgMDMTFxYUePXrw448/NkyQ9SAvL49HHnmEJ598krNnz/LAAw9csdeu62SyVatWTTbJM5lMPPnkk3Tp0gUXFxeCg4MZP348yckVKz1nZWVx77334u7ujqenJ//85z8pKCiw3S8pKWHixIl06dIFJycnbrvttipf75tvviEqKsq2tX/y5MmcO3euPt9ig/N20eHprL10QzuN7h7C8C7lhZ23xzdsoUmHk6SJEyeiVqtZuXIlu3fvZs+ePezZs4e9e/eyZ8+e+ohRXEFhYWEsWbKE4uK/dy2UlJTw7bff0qJFiwaMzDEnT56kZ8+etGvXDn9//1r38+WXX5KSkmJ7XPgPY0JCAsOHD+emm25i3759zJgxgylTprBmzRpbm6VLlzJz5kxeeOEF9uzZQ1RUFIMHDyY9Pf1y3p5DLBYLVuvl1TSprV27dvHJJ5/QtWvXSvfGjx/PsWPHWLFiBQcPHmTMmDHceeed7N27twEirVlZmePF8xITEzGZTAwfPpygoKBa73Q1mS5/YWxt1eZ9N6SqvlZFRUXs2bOH5557jj179rBs2TKOHTvGyJEjK7S79957OXz4MOvWrWPlypVs2rSpQmJrsVgwGo1Mnz6d6OjoKl9/69atjB8/nn/+858cPnyYH374gZ07d3L//ffX7RtthII9jeic6mZ90vkaSi+P6sTLozrXSZ+1pjjI2dlZOXLkiKNPa3Zyc3MVQMnNza10r7i4WImNjVWKi4tt16xWq1JYarriD6vVavd7mjBhgjJq1Cilc+fOyuLFi23Xv/nmG6Vr167KqFGjlAkTJtiuWywW5bXXXlNatWqlGAwGpWvXrsoPP/xgu282m5XJkyfb7rdv316ZP39+la/59ttvK4GBgYq3t7fy8MMPK2VlZTXG+n//939KmzZtFK1Wq7Rv3175+uuvbfdatmypALbHhTFf6MI25x8tW7ascP+nn36qNoYnnnhC6dSpU4Vr48aNUwYPHmz7c+/evZWpU6fa/myxWJTg4GDl9ddfr7bfnTt3KtHR0YqPj4/i7u6u9O/fX9m9e3eFNtnZ2coDDzyg+Pv7K3q9XunUqZPyyy+/KIqiKF9++aXi4eGh/Pzzz0rHjh0VjUajJCQkKFlZWco//vEPxdPTUzEajcqQIUOU48eP2/o8deqUcuuttyqenp6Ks7OzEhkZqaxatUpRFEXJyspS7rnnHsXX11cxGAxK27ZtlS+++KLa96AoipKfn6+0a9dOWbdunTJgwADl0UcfrXDfxcWlwt+boiiKt7e38umnn1bb54ABA5Rp06Yps2fPVry8vJSAgADlhRdeqNDm9OnTysiRIxUXFxfFzc1NueOOO5TU1FTb/fPfcxd69NFHlQEDBlR4nalTpyqPPvqo4uPjo9x4442K1WpVXnjhBSUsLEzR6XRKUFCQMm3atCrj/PLLLyt9byUkJCiKUvP3rqKUf9/93//9nzJixAjF2dm50vs776OPPlLatm2r6PV6xd/fXxk7dqzt/VX12o78PL7yyitKUFCQ0qpVK2XAgAGV+qtJQUGB4ubmVuHfAkVRlJ9++klxdnZW8vLyFEVRlMTEROWOO+5QPDw8FC8vL2XkyJG2r5Gi2PdzYO/X6mI7d+5UAOX06dOKoihKbGysAii7du2ytfntt98UlUqlnD17ttLzq/oeUhRFefvtt5U2bdpUuLZgwQIlJCSk2liq+rxoqopKzcrBMznKgaS6eaTl1s/XpKbP74s5vHA7MjKSzMzGe85KY1VsshD5/JpLN6xjsXMH46xz7K958uTJfPnll9x7770AfPHFF0yaNIkNGzZUaPf666+zePFiPv74Y9q1a8emTZu477778PPzY8CAAVitVkJDQ/nhhx/w8fFh27ZtPPDAAwQFBXHnnXfa+vnjjz8ICgrijz/+4MSJE4wbN45u3bpV+9vXTz/9xKOPPsr8+fOJjo5m5cqVTJo0idDQUG666SZ27drF+PHjcXd35/3338dorHq+PCXl77nuwsJChgwZUunMwKlTpzJlyhTatGnDgw8+yKRJk2yFQbdv317pN8rBgwfbpjnKysrYvXs3c+bMsd1Xq9VER0ezffv2ar/++fn5TJgwgQ8++ABFUXj33XcZNmwYcXFxuLm5YbVaGTp0KPn5+SxevJjw8HBiY2PRaP6uK1JUVMSbb77JZ599ho+PD/7+/tx9993ExcWxYsUK3N3defLJJxk2bBixsbFotVqmTp1KWVkZmzZtwsXFhdjYWFxdXQF47rnniI2N5bfffrMdBH3haGNVpk6dyvDhw4mOjuaVV16pdL9fv34sXbqU4cOH4+npyffff09JSQk33nhjjf1+9dVXzJw5kx07drB9+3YmTpzIddddx8CBA7FarYwaNQpXV1c2btyI2Wxm6tSpjBs3rtL376V89dVXPPTQQ2zduhWAH3/8kffee48lS5bQqVMnUlNT2b9/f5XPHTduHGFhYURHR7Nz507CwsLw8/O75PfueS+++CJvvPEG8+fPx8mp8s/vn3/+yfTp01m0aBH9+vUjKyvLdn7m+++/z/Hjx+ncuTNz584Fyg8Gt/fnMSYmBnd3d9atWwdAUFAQUVFRPPDAA3aNiLi4uHDXXXfx5Zdfcvvtt9uun/+zm5sbJpOJwYMH07dvXzZv3oyTkxOvvPIKQ4YM4cCBA+h0ukv+HNj7tapKbm4uKpXKtl5x+/bteHp6cs0119jaREdHo1ar2bFjh90blfr27cvTTz/Nr7/+ytChQ0lPT+e///0vw4YNs+v5TZ1RpyHIw0ByTvMpKu1wkvTmm2/yxBNP8Nprr9GlSxfbUR/nXap6pWj87rvvPubMmcPp06eB8iHkJUuWVPiQKS0t5bXXXmP9+vW2xKJNmzZs2bKFTz75hAEDBqDVannppZdsz2ndujXbt2/n+++/r/CPspeXFx9++CEajYaIiAiGDx9OTExMtf8gv/POO0ycOJGHH34YKD//73//+x/vvPMON910E35+fuj1eoxGI4GBgdW+z/P3FEVh7NixeHh48Mknn9juz507l5tvvhlnZ2fWrl3Lww8/TEFBge3MwtTUVNvxOecFBASQl5dHcXEx2dnZWCyWKtscPXq02rhuvvnmCn/+z3/+g6enJxs3buTWW29l/fr17Ny5kyNHjtC+ffnOjzZt2lR4jslk4v/+7/+IiooCsCVHW7dutdU3++abbwgLC2P58uXccccdJCYmMnbsWLp06VKpz8TERLp37277EGnVqlW18QMsWbKEPXv2sGvXrmrbfP/994wbNw4fHx+cnJxwdnbmp59+qlSo9mJdu3blhRdeAKBdu3Z8+OGHxMTEMHDgQGJiYjh48CAJCQm24rZff/01nTp1YteuXfTq1avGvi/Url073nrrLdufV61aRWBgINHR0Wi1Wlq0aEHv3r2rfK7RaMTHxwcoT1DOf69d6nv3vHvuucd21mRVEhMTcXFx4dZbb8XNzY2WLVvSvXt3ADw8PNDpdDg7O1f4/tdoNHb9PLq4uPDZZ59VOCZDo9Hg5uZW48/ThaZMmUK/fv1ISUkhKCiI9PR0fv31V9avXw+UT0NbrVY+++wz2y8dX375JZ6enmzYsIFBgwZd8ufA3q/VxUpKSnjyySe5++67bZ9XqamplablnZyc8Pb2JjU11e6+r7vuOr755hvGjRtHSUkJZrOZESNG8NFHH9ndR1Pn46qnsNRCbnHDTRPXJYeTpPO/Od9yyy0VriuKgkqlksNcq2HUaoidW3eH5zryuo7y8/Nj+PDhLFy4EEVRGD58OL6+vhXanDhxgqKiIgYOHFjhellZme0fayhftPzFF1+QmJhIcXExZWVldOvWrcJzOnXqVGEUJCgoiIMHD1Yb35EjRyotgr3uuutqXcz06aefZvv27fz5558VRp2ee+452/93796dwsJC3n77bVuSVF/S0tJ49tln2bBhA+np6VgsFoqKimy7R/ft20doaKgtQaqKTqersA7oyJEjODk50adPH9s1Hx8fOnTowJEjR4DyMxgfeugh1q5dS3R0NGPHjrX18dBDDzF27Fj27NnDoEGDuO2222zJ1sWSkpJ49NFHWbduXY0VhJ977jlycnJYv349vr6+LF++nDvvvJPNmzfbErWqXLy+6fyH8Pn3GRYWVqH6f2RkJJ6enhw5csShJKlnz54V/nzHHXcwf/582rRpw5AhQxg2bBgjRoywe/TifHz2fO9eOKJRlYEDB9KyZUtbLEOGDGH06NGXXPdkz89jly5dLvscsd69e9OpUye++uornnrqKRYvXkzLli3p378/APv37+fEiRMVRoSgPIE5efIkcOmfg/Mu9bW6kMlk4s4770RRFP79739f1nusSmxsLI8++ijPP/88gwcPJiUlhdmzZ/Pggw/y+eef1/nrNVYhXkaKTRbKzA2zFrIuOZwk/fHHH/URR7OnUqkcnvZqSJMnT+aRRx4BqPK3oPO7PlatWkVISEiFe+cPCV6yZAmzZs3i3XffpW/fvri5ufH222+zY8eOCu0vHo1UqVRXbKHx4sWLee+999iwYUOl93GxPn368PLLL1NaWoperycwMJC0tLQKbdLS0nB3d8doNKLRaNBoNFW2qek38gkTJnDu3Dnef/99WrZsiV6vp2/fvrZFtNVNH17IaDQ6fF7glClTGDx4MKtWrWLt2rW8/vrrvPvuu0ybNo2hQ4dy+vRpfv31V9atW8ctt9zC1KlTeeeddyr1s3v3btLT0+nRo4ftmsViYdOmTXz44YeUlpZy6tQpPvzwQw4dOkSnTp0AiIqKYvPmzXz00Ud8/PHH1cZ5ud8varW6UpG6qhb8uri4VPhzWFgYx44dY/369axbt46HH36Yt99+m40bN1aK6XJd/NoXc3NzY8+ePWzYsIG1a9fy/PPP8+KLL7Jr165qS17Y+/N4qde215QpU/joo4946qmn+PLLLytMVRcUFNCzZ0+++eabSs/z8/MDLv1z4Gi85xOk06dP8/vvv1eY9QgMDKy0mcJsNpOVlWX36BmUL0G47rrrmD17NlCe0Lu4uHDDDTfwyiuvEBQUZHdfTZlGrSLM20h8RmGd1E9qSA4vRR8wYEC1j/PDy6LpGzJkCGVlZba1AxeLjIxEr9eTmJhI27ZtKzzO/xZ/fmrn4Ycfpnv37rRt29b2W+Ll6Nixo22dyHlbt24lMjLSoX62b9/OlClT+OSTT7j22msv2X7fvn14eXnZksC+ffsSExNToc26dets0486nY6ePXtWaGO1WomJiam09uni9zJ9+nSGDRtGp06d0Ov1FdYBdu3alTNnzjhU2qBjx46YzeYKH4jnzp3j2LFjFb5uYWFhPPjggyxbtozHH3+cTz/91HbPz8+PCRMmsHjxYubPn89//vOfKl/rlltu4eDBg+zbt8/2uOaaa7j33nvZt28fGo2GoqIioPKRDBqN5rIS5I4dO5KUlERSUpLtWmxsLDk5Obb36efnV2E9GpT/3drDaDQyYsQIFixYwIYNG9i+fXuNo55VxVcX37tQPh0UHR3NW2+9xYEDBzh16hS///47UP69d/Go/uX8PFbV36Xcd999nD59mgULFhAbG8uECRNs93r06EFcXBz+/v6V/v3w8PCwxVvTz4EjzidIcXFxrF+/vtJnVd++fcnJyWH37t22a7///jtWq7XC6OulFBUVVfk9DTSK6tFXkrPOiYB6OJz2SrvsoY38/Hy+++47PvvsM3bv3i3Tbc2ERqOxTcNcOBV2npubG7NmzeKxxx7DarVy/fXXk5uby9atW3F3d2fChAm0a9eOr7/+mjVr1tC6dWsWLVrErl27Lrue1uzZs7nzzjvp3r070dHR/PLLLyxbtsy23sEeqampjB49mrvuuovBgwfb1h1oNBr8/Pz45ZdfSEtL49prr8VgMLBu3Tpee+01Zs2aZevjwQcf5MMPP+SJJ55g8uTJ/P7773z//fesWrXK1mbmzJlMmDCBa665ht69ezN//nwKCwtrXEPRrl07Fi1axDXXXENeXh6zZ8+uMHo0YMAA+vfvz9ixY5k3bx5t27bl6NGjqFQqhgwZUm2fo0aN4v777+eTTz7Bzc2Np556ipCQEEaNGgXAjBkzGDp0KO3btyc7O5s//viDjh3Lz096/vnn6dmzJ506daK0tJSVK1fa7l3Mzc2Nzp0rbtt1cXHBx8fHdj0iIoK2bdvyr3/9i3feeQcfHx+WL19u235dW9HR0XTp0oV7772X+fPnYzabefjhhxkwYIBtWubmm2/m7bff5uuvv6Zv374sXryYQ4cOVZgmrsrChQuxWCz06dMHZ2dnFi9ebKsXZ6+6+N4FWLlyJfHx8fTv3x8vLy9+/fVXrFYrHTp0AMrXjO3YsYNTp07h6uqKt7f3Zf08tmrVik2bNnHXXXeh1+srTb9XxcvLizFjxjB79mwGDRpEaGio7d69997L22+/zahRo5g7dy6hoaGcPn2aZcuW8cQTTxAaGnrJnwN7mUwmbr/9dvbs2cPKlSuxWCy2n3dvb290Oh0dO3ZkyJAh3H///Xz88ceYTCYeeeQR7rrrLoKDg219xcbGUlZWRlZWFvn5+bbk+vyU5YgRI7j//vv597//bZtumzFjBr17967Qz9XCz01PYamZ/BJzQ4dSe7XdQrdx40Zl/PjxiouLi9KuXTvlySefVHbu3Fnb7pocR0sANAXVbWs97+ISAFarVZk/f77SoUMHRavVKn5+fsrgwYOVjRs3KoqiKCUlJcrEiRMVDw8PxdPTU3nooYeUp556SomKiqrxNS/ejl2VS22jvjjWi/3xxx81lgD47bfflG7duimurq6Ki4uLEhUVpXz88ceKxWKp1E+3bt0UnU6ntGnTRvnyyy8rvdYHH3ygtGjRQtHpdErv3r2V//3vfzW+tz179ijXXHONYjAYlHbt2ik//PCD0rJlS+W9996ztTl37pwyadIkxcfHRzEYDErnzp2VlStXKorydwmAi50vAeDh4aEYjUZl8ODBFUoAPPLII0p4eLii1+sVPz8/5R//+IeSmZmpKIqivPzyy0rHjh0Vo9GoeHt7K6NGjVLi4+NrfB8XqqoEwPHjx5UxY8Yo/v7+irOzs9K1a9dKf4/29HPx3/WlSgAoiqI8//zzSkBAgOLh4aE89thjyiOPPFKpBMDFr/PTTz8pffr0Udzd3RUXFxfl2muvVdavX19trHv37q2w9f88e0oA1FR6QlEUZfPmzcqAAQMULy8vxWg0Kl27dlWWLl1qu3/s2DHl2muvVYxGoy2G2v48KoqibN++Xenataui1+svWQLgQjExMQqgfP/995XupaSkKOPHj1d8fX0VvV6vtGnTRrn//vtt/6ba83Ngz9cqISGhyp91QPnjjz9s7c6dO6fcfffdiqurq+Lu7q5MmjRJyc/Pr9DXxeVFqKIkwoIFC5TIyEjFaDQqQUFByr333qucOXOm2via6ueFvUxmi3IkJbfJlgBQKYr9Y4CpqaksXLiQzz//nLy8PO68804+/vhj9u/fX6vh4qYsLy8PDw8PcnNzK+3oKykpISEhgdatW9e4cFUIIZqzRYsW8dhjj5GcnHzZi8Gbq6vh86Kw1ExCpuPrkwLc9fjXw5RdTZ/fF7N7TdKIESPo0KEDBw4cYP78+SQnJ/PBBx9cdrBCCCGal6KiIk6ePMkbb7zBv/71L0mQrnIueif83fUNHUat2L0m6bfffrNtEW7Xrl19xiSEEKIRGzp0qK145cWefvppysrKePXVV+nfv3+FYqri6uXvZqCw1EJBE1ufZHeStGXLFj7//HN69uxJx44d+cc//sFdd91Vn7EJIYRohD777LNqK657e3vj7e3Niy++eGWDEo1emJeRuPQCzJams9PP7iTp2muv5dprr2X+/PksXbqUL774gpkzZ2K1Wlm3bh1hYWGVCoMJIYRofi5VU0yIqjhp1IR5O5OQUdjQodjN4TpJLi4uTJ48mS1btnDw4EEef/xx3njjDfz9/SudqiyEEEIIcZ5rE1uf5HCSdKEOHTrw1ltvcebMGb777ru6ikkIIYQQzVSAuwEXveNHZjWEy0qSztNoNNx2222sWLGiLroTQgghRDMW5u2MRu3Y0UkNoU6SJCGEEEIIe2k1asK8Ha+gfqVJkiSEEEKIK87NoMXPrXGvT5IkSQghhBANIsBdj3MjXp8kSdIVdvBM7hV7OCo/P58ZM2bQsmVLjEYj/fr1Y9euXRXaTJw4EZVKVeFx4aGqpaWl/OMf/8Dd3Z327dtXOrjz7bffZtq0aXbFk5eXxzPPPENERAQGg4HAwECio6NZtmyZ7UTtG2+8kRkzZjj8XoUQQjQ8lUpFmFfjXZ9kd50k0fxNmTKFQ4cOsWjRov9v797Dasr3P4C/d/em2l3oqgsNSp3a0w2dUNEU4zQYMxyneTgczmMUksk5zgwx6SiGY5gMBsWJXCeXGUkTNSenlJyMrm4hp5ucUClSn98ffq2xa0ea2Lt8Xs/T87S+67vX+nzXZ+9nfVr721owMzNDXFwcfHx8UFBQIHVflLFjxyImJkZYVlf/5XLptm3bkJOTg4yMDCQmJuIPf/gDKisrIRKJUFJSgm+//Rbnz59/YSz37t3DiBEjcP/+faxatQpubm5QUVFBWloalixZgtGjR0NPT69bx88YY+z1U1NRgrmBJm5WP5R3KO1wkcQAAA0NDTh8+DCOHj2KUaNGAQBWrFiB48eP45tvvsGqVauEvurq6jAxMZG5ncLCQrz//vuwt7eHtbU1QkNDUV1dDUNDQ3zyySeIiop64QMFgaePNrhx4wYuX74MMzMzoX3w4MGYNm1ar30QJGOMvYnEGqroq6OG6trH8g5FCn/dxgAAT548QXNzc7viQ1NTE+np6VJtqampMDIygo2NDT755BPcvXtXWCeRSJCeno6GhgYkJSXB1NQUffv2xZ49e6ChoYFJkya9MJaWlhbs27cPAQEBUgVSK21tbaiocH3PGGO9iYlYA5pqijU/iYskBgDQ0dGBu7s7wsPDUVZWhubmZsTFxSEjIwPl5eVCv7Fjx2L37t1ISUlBVFQU0tLSMG7cODQ3NwMAZs2aBYlEAjs7O0RERODAgQOoqanB8uXLsWnTJnz++ecYOHAg/Pz88N///ldmLNXV1aipqYGtre1rGTtjjDH5E4lEsDR4C0oKVJnwn+NM8M9//hOzZs1Cv379oKysDGdnZ0ybNg05OTlCn2cfauzg4ABHR0e8/fbbSE1NxZgxY6Cqqoro6Gip7c6cORMLFizAf/7zHxw5cgQXL17EmjVrsGDBAhw+fLhdHK2TshljjL1Z1FSUYK7/Fm7dVYz5SQpUrzF5e/vtt5GWloa6ujqUlpYiKysLTU1NsLa27vA11tbW6Nu3L65evSpz/ZkzZ5Cfn4+goCCkpqbivffeg5aWFqZMmYLU1FSZrzE0NISenh6Kioq6Y1iMMcZ6EF1NVRhoq8k7DABcJDEZtLS0YGpqipqaGiQlJWHChAkd9r19+zbu3r0LU1PTdusaGxsRGBiIrVu3QllZGc3NzWhqagIANDU1CV/RtaWkpITf//732LNnD8rKytqtr6urw5MnT7o4OsYYY4rOTFcDGgowP4mLJCZISkrCyZMnUVJSguTkZHh7e8PW1hYzZ84E8LQ4CQ0NRWZmJm7cuIGUlBRMmDBBmGPUVnh4ON577z04OTkBADw8PPDdd9/h559/xtdffw0PD48OY4mIiICFhQWGDRuG3bt3o6CgAFeuXMHOnTvh5OSEurq6V3MQGGOMyZ1IJIJYQ1XeYfCcpNfNwVxX3iF06P79+1i6dClu374NAwMDTJ48GREREVBVffpGVVZWxs8//4xdu3bh3r17MDMzg6+vL8LDw6XulQQAeXl5OHDgAHJzc4W2Dz/8EKmpqRg5ciRsbGywd+/eDmMxMDBAZmYmIiMjsWrVKty8eRP6+vpwcHDA2rVroauruMeRMcZY7yAiniXbJQ8ePICuri7u37/f7r4/jY2NKCkpwYABA/h+PowxxjrE54vX73nn77b46zbGGGOMMRm4SGKMMcYYk4GLJMYYY4wxGbhIYowxxhiTgYukV4jnxDPGGHsePk8oNi6SXoHWf5l/+FAxbqvOGGNMMbWeJ1rPG0yx8H2SXgFlZWXo6emhqqoKAPDWW29BJBLJOSrGGGOKgojw8OFDVFVVQU9PD8rK8r+7NGuPi6RXxMTEBACEQokxxhhrS09PTzhfMMXDRdIrIhKJYGpqCiMjI+F5ZYwxxlgrVVVVvoKk4LhIesWUlZX5Q8AYY4z1QDxxmzHGGGNMBi6SGGOMMcZk4CKJMcYYY0wGnpPURa03AHvw4IGcI2GMMcZYZ7WetztzI08ukrqotrYWAGBhYSHnSBhjjDH2smpra6Grq/vcPiLie6J3SUtLC8rKyqCjo9PtN4p88OABLCwsUFpaCrFY3K3bZt2Lc9VzcK56Fs5Xz9HTckVEqK2thZmZGZSUnj/riK8kdZGSkhLMzc1f6T7EYnGPeMMxzlVPwrnqWThfPUdPytWLriC14onbjDHGGGMycJHEGGOMMSYDF0kKSF1dHWFhYVBXV5d3KOwFOFc9B+eqZ+F89Ry9OVc8cZsxxhhjTAa+ksQYY4wxJgMXSYwxxhhjMnCRxBhjjDEmAxdJjDHGGGMycJGkYKKjo9G/f39oaGhg2LBhyMrKkndIDMBPP/0Ef39/mJmZQSQS4ciRI1LriQjLly+HqakpNDU14ePjgytXrsgn2Dfc6tWr4ebmBh0dHRgZGWHixIkoLi6W6tPY2IjAwED06dMH2tramDx5MiorK+UU8Zvrm2++gaOjo3ATQnd3dyQmJgrrOU+KKzIyEiKRCMHBwUJbb8wXF0kKZP/+/QgJCUFYWBguXLgAiUQCPz8/VFVVyTu0N159fT0kEgmio6Nlrl+zZg02btyILVu24Ny5c9DS0oKfnx8aGxtfc6QsLS0NgYGByMzMRHJyMpqamuDr64v6+nqhz6JFi3D8+HEcPHgQaWlpKCsrwwcffCDHqN9M5ubmiIyMRE5ODs6fP4/Ro0djwoQJyM/PB8B5UlTZ2dnYunUrHB0dpdp7Zb6IKYyhQ4dSYGCgsNzc3ExmZma0evVqOUbF2gJACQkJwnJLSwuZmJjQ2rVrhbZ79+6Ruro6xcfHyyFC9qyqqioCQGlpaUT0NDeqqqp08OBBoU9hYSEBoIyMDHmFyf6fvr4+bd++nfOkoGpra2nQoEGUnJxMnp6etHDhQiLqvZ8rvpKkIB4/foycnBz4+PgIbUpKSvDx8UFGRoYcI2MvUlJSgoqKCqnc6erqYtiwYZw7BXD//n0AgIGBAQAgJycHTU1NUvmytbWFpaUl50uOmpubsW/fPtTX18Pd3Z3zpKACAwMxfvx4qbwAvfdzxQ+4VRDV1dVobm6GsbGxVLuxsTGKiorkFBXrjIqKCgCQmbvWdUw+WlpaEBwcDA8PD/zmN78B8DRfampq0NPTk+rL+ZKPS5cuwd3dHY2NjdDW1kZCQgLs7OyQm5vLeVIw+/btw4ULF5Cdnd1uXW/9XHGRxBjrtQIDA5GXl4f09HR5h8I6YGNjg9zcXNy/fx+HDh3CjBkzkJaWJu+wWBulpaVYuHAhkpOToaGhIe9wXhv+uk1B9O3bF8rKyu3+E6CyshImJiZyiop1Rmt+OHeKJSgoCN9//z3OnDkDc3Nzod3ExASPHz/GvXv3pPpzvuRDTU0NAwcOhIuLC1avXg2JRIKvvvqK86RgcnJyUFVVBWdnZ6ioqEBFRQVpaWnYuHEjVFRUYGxs3CvzxUWSglBTU4OLiwtSUlKEtpaWFqSkpMDd3V2OkbEXGTBgAExMTKRy9+DBA5w7d45zJwdEhKCgICQkJOD06dMYMGCA1HoXFxeoqqpK5au4uBi3bt3ifCmAlpYWPHr0iPOkYMaMGYNLly4hNzdX+HF1dUVAQIDwe2/MF3/dpkBCQkIwY8YMuLq6YujQodiwYQPq6+sxc+ZMeYf2xqurq8PVq1eF5ZKSEuTm5sLAwACWlpYIDg7GqlWrMGjQIAwYMADLli2DmZkZJk6cKL+g31CBgYHYu3cvjh49Ch0dHWE+hK6uLjQ1NaGrq4s//elPCAkJgYGBAcRiMebPnw93d3cMHz5cztG/WZYuXYpx48bB0tIStbW12Lt3L1JTU5GUlMR5UjA6OjrCvL5WWlpa6NOnj9DeK/Ml73+vY9I2bdpElpaWpKamRkOHDqXMzEx5h8SI6MyZMwSg3c+MGTOI6OltAJYtW0bGxsakrq5OY8aMoeLiYvkG/YaSlScAFBMTI/RpaGigefPmkb6+Pr311ls0adIkKi8vl1/Qb6hZs2aRlZUVqampkaGhIY0ZM4ZOnTolrOc8KbZnbwFA1DvzJSIiklN9xhhjjDGmsHhOEmOMMcaYDFwkMcYYY4zJwEUSY4wxxpgMXCQxxhhjjMnARRJjjDHGmAxcJDHGGGOMycBFEmOMMcaYDFwkMcYYY4zJwEUSYz3AjRs3IBKJkJubK+9QBEVFRRg+fDg0NDTwzjvvyOzj5eWF4ODg1xpXTyYSiXDkyJFXvp/O5I4xxkUSY53yxz/+ESKRCJGRkVLtR44cgUgkklNU8hUWFgYtLS0UFxdLPdSyN4qNjYWenl63bW/FihUyi5Py8nKMGzeu2/bTEUXL3cWLFzFt2jRYWFhAU1MTQ4YMwVdffdWuX2pqKpydnaGuro6BAwciNjZWav1PP/0Ef39/mJmZdVhw1tXVISgoCObm5tDU1ISdnR22bNnyikbGejoukhjrJA0NDURFRaGmpkbeoXSbx48fd/m1165dw4gRI2BlZYU+ffp0Y1S/3q8Z16tERHjy5EmH601MTKCurv7K4+hM7pqaml55HK1ycnJgZGSEuLg45Ofn47PPPsPSpUvx9ddfC31KSkowfvx4eHt7Izc3F8HBwZg9ezaSkpKEPvX19ZBIJIiOju5wXyEhITh58iTi4uJQWFiI4OBgBAUF4dixY690jKyHkvOz4xjrEWbMmEG/+93vyNbWlkJDQ4X2hIQEevZjFBYWRhKJROq1//jHP8jKykpqWxMmTKCIiAgyMjIiXV1dWrlyJTU1NdGnn35K+vr61K9fP9q5c6fwmpKSEgJA8fHx5O7uTurq6mRvb0+pqalS+7p06RKNHTuWtLS0yMjIiD7++GO6c+eOsN7T05MCAwNp4cKF1KdPH/Ly8pI53ubmZlq5ciX169eP1NTUSCKRUGJiorAebR4eGxYWJnM7np6eNH/+fAoNDSV9fX0yNjZu1/fmzZv0/vvvk5aWFuno6NBHH31EFRUV7Y7XsxYuXEienp7PHVdLSwuFhYWRhYUFqampkampKc2fP19mnEREubm55OXlRdra2qSjo0POzs6UnZ0t8+HGrWPYvXs3ubi4kLa2NhkbG9O0adOosrJS2Gbra0+cOEHOzs6kqqpKMTExHT58FwAlJCQQ0S85P3z4MHl5eZGmpiY5OjrSv//9b6m4t23bRubm5qSpqUkTJ06kdevWka6ubofjlDWW1n3t27ePRo0aRerq6hQTE/PC90Hr6/bv308jRowgDQ0NcnV1peLiYsrKyiIXFxfS0tKisWPHUlVVVYcxyTJv3jzy9vYWlpcsWUL29vZSfaZOnUp+fn4djrP1WD7L3t6evvjiC6k2Z2dn+uyzz14qPvZm4CKJsU5oPVF/9913pKGhQaWlpUTU9SJJR0eHAgMDqaioiHbs2EEAyM/PjyIiIujy5csUHh5Oqqqqwn5aT0bm5uZ06NAhKigooNmzZ5OOjg5VV1cTEVFNTQ0ZGhrS0qVLqbCwkC5cuEDvvvuu1InG09OTtLW1KTQ0lIqKiqioqEjmeNevX09isZji4+OpqKiIlixZQqqqqnT58mUiIiovLyd7e3tavHgxlZeXU21trczteHp6klgsphUrVtDly5dp165dJBKJhCe9Nzc30zvvvEMjRoyg8+fPU2ZmJrm4uEgVQJ0tktqO6+DBgyQWi+nEiRN08+ZNOnfuHG3btk1mnERPT54ff/wxFRYW0uXLl+nAgQOUm5tLjx49og0bNpBYLKby8nKp8e7YsYNOnDhB165do4yMDHJ3d6dx48YJ22wtkhwdHenUqVN09epVun37Ni1evJjs7e2F7T18+JCIZBdJtra29P3331NxcTF9+OGHZGVlRU1NTURElJ6eTkpKSrR27VoqLi6m6OhoMjAweG6RJCt3rfvq378/HT58mK5fv05lZWUvfB88G+PJkyepoKCAhg8fTi4uLuTl5UXp6el04cIFGjhwIM2dO7fDmGQJCAigyZMnC8sjR46UeuI8EdHOnTtJLBbLfH1HRdKcOXPI1dWVbt++TS0tLXT69GnS1tamtLS0l4qPvRm4SGKsE549UQ8fPpxmzZpFRF0vkqysrKi5uVlos7GxoZEjRwrLT548IS0tLYqPjyeiX05GkZGRQp+mpiYyNzenqKgoIiIKDw8nX19fqX2XlpYSACouLiaip8WEk5PTC8drZmZGERERUm1ubm40b948YVkikXR4BamVp6cnjRgxot12/vKXvxAR0alTp0hZWZlu3bolrM/PzycAlJWVRUSdL5LajmvdunU0ePBgevz48XNjbKWjo0OxsbEy18XExDy38GiVnZ1NAIQiqrVIOnLkiFQ/We8TItlF0vbt24X1rcemsLCQiJ5eSRk/frzUNgICAl4Ya9vcte5rw4YNUv1e9D6QFWN8fDwBoJSUFKFt9erVZGNj89yYnnX27FlSUVGhpKQkoW3QoEH097//XarfDz/8QACEIvNZHRVJjY2NNH36dAJAKioqpKamRrt27ep0bOzNwnOSGHtJUVFR2LVrFwoLC7u8DXt7eygp/fLxMzY2hoODg7CsrKyMPn36oKqqSup17u7uwu8qKipwdXUV4rh48SLOnDkDbW1t4cfW1hbA0zkorVxcXJ4b24MHD1BWVgYPDw+pdg8Pjy6N2dHRUWrZ1NRUGFdhYSEsLCxgYWEhrLezs4Oent5L76vtuD766CM0NDTA2toac+bMQUJCwnPnA4WEhGD27Nnw8fFBZGSk1DHrSE5ODvz9/WFpaQkdHR14enoCAG7duiXVz9XV9aXG8qxnj5+pqSkACMevuLgYQ4cOlerfdvllPBvny7wPno3R2NgYAKTez8bGxu3eyx3Jy8vDhAkTEBYWBl9f35cew4ts2rQJmZmZOHbsGHJycrBu3ToEBgbixx9/7PZ9sZ6PiyTGXtKoUaPg5+eHpUuXtlunpKQEIpJqkzUBVlVVVWpZJBLJbGtpael0XHV1dfD390dubq7Uz5UrVzBq1Cihn5aWVqe32R1+7bg6e0zbjsvCwgLFxcXYvHkzNDU1MW/ePIwaNarDCckrVqxAfn4+xo8fj9OnT8POzg4JCQkdxlVfXw8/Pz+IxWLs2bMH2dnZQv+2E8d/zTF/9vi1/iflyxy/l9HVOGXF2LatMzEXFBRgzJgx+POf/4zPP/9cap2JiQkqKyul2iorKyEWi6GpqdmpOBsaGvC3v/0N69evh7+/PxwdHREUFISpU6fiyy+/7NQ22JuFiyTGuiAyMhLHjx9HRkaGVLuhoSEqKiqkTurdeW+jzMxM4fcnT54gJycHQ4YMAQA4OzsjPz8f/fv3x8CBA6V+XubkJxaLYWZmhrNnz0q1nz17FnZ2dt0zkP83ZMgQlJaWorS0VGgrKCjAvXv3hH0ZGhqivLxc6nWdPaaamprw9/fHxo0bkZqaioyMDFy6dKnD/oMHD8aiRYtw6tQpfPDBB4iJiQEAqKmpobm5WapvUVER7t69i8jISIwcORK2tradvloia3tdYWNjg+zsbKm2tstd9TrfBwCQn58Pb29vzJgxAxEREe3Wu7u7t7tdQXJystTV1RdpampCU1OT1FVc4OmV21dVeLKejYskxrrAwcEBAQEB2Lhxo1S7l5cX7ty5gzVr1uDatWuIjo5GYmJit+03OjoaCQkJKCoqQmBgIGpqajBr1iwAQGBgIP73v/9h2rRpyM7OxrVr15CUlISZM2e+9Ak5NDQUUVFR2L9/P4qLi/HXv/4Vubm5WLhwYbeNBQB8fHyEY3nhwgVkZWVh+vTp8PT0FL76GT16NM6fP4/du3fjypUrCAsLQ15e3gu3HRsbix07diAvLw/Xr19HXFwcNDU1YWVl1a5vQ0MDgoKCkJqaips3b+Ls2bPIzs4WCtD+/fujrq4OKSkpqK6uxsOHD2FpaQk1NTVs2rQJ169fx7FjxxAeHt6pcffv3x8lJSXIzc1FdXU1Hj169BJH7Rfz58/HiRMnsH79ely5cgVbt25FYmJit92763W9D/Ly8uDt7Q1fX1+EhISgoqICFRUVuHPnjtBn7ty5uH79OpYsWYKioiJs3rwZBw4cwKJFi4Q+dXV1whVUAMIxbv36UywWw9PTE6GhoUhNTUVJSQliY2Oxe/duTJo0qVvHxHoHLpIY66Ivvvii3V+fQ4YMwebNmxEdHQ2JRIKsrCx8+umn3bbPyMhIREZGQiKRID09HceOHUPfvn0BQPirv7m5Gb6+vnBwcEBwcDD09PTa/eX8IgsWLEBISAgWL14MBwcHnDx5EseOHcOgQYO6bSzA069hjh49Cn19fYwaNQo+Pj6wtrbG/v37hT5+fn5YtmwZlixZAjc3N9TW1mL69Okv3Laenh6+/fZbeHh4wNHRET/++COOHz8u875AysrKuHv3LqZPn47BgwdjypQpGDduHFauXAkA+O1vf4u5c+di6tSpMDQ0xJo1a2BoaIjY2FgcPHgQdnZ2iIyM7PRXNpMnT8bYsWPh7e0NQ0NDxMfHd/KISfPw8MCWLVuwfv16SCQSnDx5EosWLYKGhkaXttfW63ofHDp0CHfu3EFcXBxMTU2FHzc3N6HPgAED8MMPPyA5ORkSiQTr1q3D9u3b4efnJ/Q5f/48nJyc4OTkBODpPDMnJycsX75c6LNv3z64ubkhICBAyFtERATmzp3brWNivYOI2n7ZzxhjrMeaM2cOioqK8K9//UveoTDW46nIOwDGGGNd9+WXX+Ldd9+FlpYWEhMTsWvXLmzevFneYTHWK/CVJMYY68GmTJmC1NRU1NbWwtraGvPnz+evjhjrJlwkMcYYY4zJwBO3GWOMMcZk4CKJMcYYY0wGLpIYY4wxxmTgIokxxhhjTAYukhhjjDHGZOAiiTHGGGNMBi6SGGOMMcZk4CKJMcYYY0yG/wNwFn5r3SE57gAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "main(args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2f1ac3a-f124-4f96-b054-9268f8742832",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "112a291e-fb56-4abc-bb88-4d94e233376c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e52751cc-9298-421e-b553-7a9e8565e929",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22de0055-36eb-4d62-879f-36e3a81625bf",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ec121c05-95f1-4533-84f8-661d585a2776",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc0d8d20-2d23-49fd-be94-1e8cb5395bee",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e24ab571-94b0-4942-be00-e66bf31cb527",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5d5fdaf0-4336-44d2-a18e-4ec452ce9b53",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b8031143-0a80-46a3-86be-ddfa5a3c2aff",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c11033ab-8c28-48c7-b58b-e4abe06642ff",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c88b1c63-3d2e-45da-b138-ef44d8901c4d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db61d557-08a8-48cb-8f4c-4ce4411b34b2",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (My FourCastNet Kernel)",
   "language": "python",
   "name": "fourcastnet"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}