STLF_Comparison_All_Models.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S79MDMbtKFuj"
      },
      "source": [
        "# **Short-term Load Forecasting using Deep Learning**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ff8hI820J9LW"
      },
      "source": [
        "# Connecting to Google Drive"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2hgxBrN9QqDA",
        "outputId": "55451640-5e2f-4276-ed7f-fc89599200b0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "# from google.colab import drive\n",
        "# drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kBLyIxOxJ2mm"
      },
      "source": [
        "# Importing Necessary Dependencies"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5k3D4bJeQryd",
        "outputId": "d71b05de-8067-4efd-8460-689cb18aaa42"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
            "  import pandas.util.testing as tm\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "from math import sqrt\n",
        "from pandas import read_csv\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from sklearn.metrics import mean_squared_error\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "from scipy.interpolate import make_interp_spline\n",
        "\n",
        "from keras.callbacks import CSVLogger\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Dense\n",
        "from keras.layers import LSTM\n",
        "from keras.layers import TimeDistributed\n",
        "from keras.layers import Bidirectional\n",
        "from keras.layers.convolutional import Conv1D\n",
        "from keras.layers.convolutional import MaxPooling1D\n",
        "from keras.layers import Flatten\n",
        "from keras.layers import RepeatVector\n",
        "\n",
        "from statsmodels.tsa.seasonal import seasonal_decompose\n",
        "\n",
        "%matplotlib inline\n",
        "plt.rcParams.update({'font.size': 16})"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yFsWSQGIUWQf"
      },
      "source": [
        "# Helper Functions Defined"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JXGTHC9ZRciz"
      },
      "outputs": [],
      "source": [
        "from keras.backend import dropout\n",
        "# split  dataset into train, validate and test sets\n",
        "def split_dataset(data):\n",
        "\t# split into train validation and test sets\n",
        "\ttrain, val, test = data[12:13932], data [13932:18300], data[18300:22716]\n",
        "\t# restructure into samples of daily data shape is [samples, hours, feature]\n",
        "\ttrain = np.array(np.split(train, len(train)/24))\n",
        "\tval = np.array(np.split(val, len(val)/24))\n",
        "\ttest = np.array(np.split(test, len(test)/24))\n",
        "\treturn train, val, test\n",
        "\n",
        "# evaluate one or more daily forecasts against expected values\n",
        "def evaluate_forecasts(actual, predicted):\n",
        "\tscores = list()\n",
        "\t# calculate an RMSE score for each hour of the day\n",
        "\tfor i in range(actual.shape[1]):\n",
        "\t\t# calculate mse\n",
        "\t\tmse = mean_squared_error(actual[:, i], predicted[:, i])\n",
        "\t\t# calculate rmse\n",
        "\t\trmse = sqrt(mse)\n",
        "\t\t# store in scores list\n",
        "\t\tscores.append(rmse)\n",
        "  \n",
        "\t# calculate overall RMSE\n",
        "\ts = 0\n",
        "\tfor row in range(actual.shape[0]):\n",
        "\t\tfor col in range(actual.shape[1]):\n",
        "\t\t\ts += (actual[row, col] - predicted[row, col])**2\n",
        "\tscore = sqrt(s / (actual.shape[0] * actual.shape[1]))\n",
        "\treturn score, scores\n",
        "\n",
        "# summarize scores\n",
        "def summarize_scores(name, score, scores):\n",
        "\ts_scores = ', '.join(['%.1f' % s for s in scores])\n",
        "\tprint('%s: [%.3f] %s' % (name, score, s_scores))\n",
        "\n",
        "# convert history into inputs (actual) and outputs (predicted) for training\n",
        "def convert_train_val(train, n_input, n_out=24):\n",
        "\t# flatten data\n",
        "\tdata = train.reshape((train.shape[0]*train.shape[1], train.shape[2]))\n",
        "\tX, y = list(), list()\n",
        "\tin_start = 0\n",
        "\t# step over the entire history one time step at a time\n",
        "\tfor _ in range(len(data)):\n",
        "\t\t# define the end of the input sequence\n",
        "\t\tin_end = in_start + n_input\n",
        "\t\tout_end = in_end + n_out\n",
        "\t\t# ensure we have enough data for this instance\n",
        "\t\tif out_end <= len(data):\n",
        "\t\t\tx_input = data[in_start:in_end, 0]\n",
        "\t\t\tx_input = x_input.reshape((len(x_input), 1))\n",
        "\t\t\tX.append(x_input)\n",
        "\t\t\ty.append(data[in_end:out_end, 0])\n",
        "\t\t# move along one time step of 1 hour\n",
        "\t\tin_start += 1\n",
        "\treturn np.array(X), np.array(y)\n",
        "\n",
        "# make a forecast\n",
        "def forecast(model, history, n_input):\n",
        "\t# flatten data\n",
        "\tdata = np.array(history)\n",
        "\tdata = data.reshape((data.shape[0]*data.shape[1], data.shape[2]))\n",
        "\t# retrieve last observations for input data\n",
        "\tinput_x = data[-n_input:, 0]\n",
        "\t# reshape into [1, n_input, 1] that is 1 sample, sample data size, one feature\n",
        "\tinput_x = input_x.reshape((1, len(input_x), 1))\n",
        "\t# forecast the next hour\n",
        "\tyhat = model.predict(input_x, verbose=0)\n",
        "\t# we only want the vector forecast\n",
        "\tyhat = yhat[0]\n",
        "\treturn yhat"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6RFUT2uyGmb8"
      },
      "source": [
        "# LSTM - Building Model Architecture and Training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lzOO-UoyGWUd"
      },
      "outputs": [],
      "source": [
        "# train the model\n",
        "def build_model_LSTM(train, val, n_input):\n",
        "\t# Create training and validation sets\n",
        "\ttrain_x, train_y = convert_train_val(train, n_input)\n",
        "\tval_x, val_y = convert_train_val(val, n_input)\n",
        "\t# define parameters\n",
        "\tcsv_logger = CSVLogger('LSTM_Model_Logger.log')\n",
        "\tverbose, epochs, batch_size = 0, 30, 384\n",
        "\tn_timesteps, n_features, n_outputs = train_x.shape[1], train_x.shape[2], train_y.shape[1]\n",
        "\tnv_timesteps, nv_features, nv_outputs = val_x.shape[1], val_x.shape[2], val_y.shape[1]\n",
        "\t# reshape output into [samples, timesteps, features]\n",
        "\ttrain_y = train_y.reshape((train_y.shape[0], train_y.shape[1], 1))\n",
        "\tval_y = val_y.reshape((val_y.shape[0], val.shape[1], 1))\n",
        " \n",
        "\t# define model\n",
        "\tmodel = Sequential()\n",
        "\tmodel.add(LSTM(100, activation='relu', return_sequences=True, input_shape=(n_timesteps, 1)))\n",
        "\tmodel.add(Dense(100, activation='relu'))\n",
        "\tmodel.add(Dense(1))\n",
        "\tmodel.compile(loss='mse', optimizer='adam')\n",
        "\tprint(model.summary())\n",
        "\t# fit network\n",
        "\thist=model.fit(train_x, train_y, validation_data=(val_x, val_y),callbacks=[csv_logger], epochs=epochs, batch_size=batch_size, verbose=verbose)\n",
        "\treturn model, hist\n",
        "\n",
        "# evaluate model fits model using training and validation data, then conducts a walk forwad validation with the test data\n",
        "def evaluate_model_LSTM(train, val, test, n_input):\n",
        "\t# fit model\n",
        "\tmodel, hist = build_model_LSTM(train, val, n_input)\n",
        "\t# history is a list of houry data\n",
        "\thistory = [x for x in train]\n",
        "\t# walk-forward validation over each hour in test set\n",
        "\tpredictions = list()\n",
        "\tfor i in range(len(test)):\n",
        "\t\t# predict the hour\n",
        "\t\tyhat_sequence = forecast(model, history, n_input)\n",
        "\t\t# store the predictions\n",
        "\t\tpredictions.append(yhat_sequence)\n",
        "\t\t# get real observation and add to history for predicting the next hour\n",
        "\t\thistory.append(test[i, :])\n",
        "\t# evaluate predictions hours for each day\n",
        "\tpredictions = np.array(predictions)\n",
        "\tscore, scores = evaluate_forecasts(test[:, :, 0], predictions)\n",
        "\treturn score, scores, hist, predictions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "epqzZSjxGsh0"
      },
      "source": [
        "# CNN-LSTM - Building Model Architecture and Training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "785F8wyQGabq"
      },
      "outputs": [],
      "source": [
        "# Build and train CNN-BiLSTM model\n",
        "def build_model_CNNLSTM(train, val, n_input):\n",
        "\t# Create training and validation sets\n",
        "\ttrain_x, train_y = convert_train_val(train, n_input)\n",
        "\tval_x, val_y = convert_train_val(val, n_input)\n",
        "\t# define parameters\n",
        "\tcsv_logger = CSVLogger('CNNLSTM_Model_Logger.log')\n",
        "\tverbose, epochs, batch_size = 0, 30, 384\n",
        "\tn_timesteps, n_features, n_outputs = train_x.shape[1], train_x.shape[2], train_y.shape[1]\n",
        "\tnv_timesteps, nv_features, nv_outputs = val_x.shape[1], val_x.shape[2], val_y.shape[1]\n",
        "\t# reshape output into [samples, timesteps, features]\n",
        "\ttrain_y = train_y.reshape((train_y.shape[0], train_y.shape[1], 1))\n",
        "\tval_y = val_y.reshape((val_y.shape[0], val.shape[1], 1))\n",
        "\t# define model\n",
        "\n",
        "\tmodel = Sequential()\n",
        "\tmodel.add(Conv1D(filters=64, kernel_size=3, activation='relu', input_shape=(n_timesteps,n_features)))\n",
        "\tmodel.add(Conv1D(filters=64, kernel_size=3, activation='relu'))\n",
        "\tmodel.add(MaxPooling1D(pool_size=2))\n",
        "\tmodel.add(Flatten())\n",
        "\tmodel.add(RepeatVector(n_outputs))\n",
        "\tmodel.add(LSTM(100, return_sequences=True, activation='relu', input_shape=(n_timesteps, 1)))\n",
        "\tmodel.add(Dense(100, activation='relu'))\n",
        "\tmodel.add(Dense(1))\n",
        "\tmodel.compile(loss='mse', optimizer='adam')\n",
        "\tprint(model.summary())\n",
        "\t# fit network and store mse loss in hist \n",
        "\thist=model.fit(train_x, train_y, validation_data=(val_x, val_y),callbacks=[csv_logger], epochs=epochs, batch_size=batch_size, verbose=verbose)\n",
        "\treturn model, hist\n",
        "\n",
        "# evaluate model fits model using training and validation data, then conducts a walk forwad validation with the test data\n",
        "def evaluate_model_CNNLSTM(train, val, test, n_input):\n",
        "\t# fit model\n",
        "\tmodel, hist = build_model_CNNLSTM(train, val, n_input)\n",
        "\t# history is a list of houry data\n",
        "\thistory = [x for x in train]\n",
        "\t# walk-forward validation over each hour in test set\n",
        "\tpredictions = list()\n",
        "\tfor i in range(len(test)):\n",
        "\t\t# predict the hour\n",
        "\t\tyhat_sequence = forecast(model, history, n_input)\n",
        "\t\t# store the predictions\n",
        "\t\tpredictions.append(yhat_sequence)\n",
        "\t\t# get real observation and add to history for predicting the next hour\n",
        "\t\thistory.append(test[i, :])\n",
        "\t# evaluate predictions hours for each day\n",
        "\tpredictions = np.array(predictions)\n",
        "\tscore, scores = evaluate_forecasts(test[:, :, 0], predictions)\n",
        "\treturn score, scores, hist, predictions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KGj9Cs0HG5X8"
      },
      "source": [
        "# BiLSTM - Building Model Architecture and Training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "w6mMy2kTGduM"
      },
      "outputs": [],
      "source": [
        "# Build and train BiLSTM model\n",
        "def build_model_BiLSTM(train, val, n_input):\n",
        "\t# Create training and validation sets\n",
        "\ttrain_x, train_y = convert_train_val(train, n_input)\n",
        "\tval_x, val_y = convert_train_val(val, n_input)\n",
        "\t# define parameters\n",
        "\tcsv_logger = CSVLogger('BiLSTM_Model_Logger.log')\n",
        "\tverbose, epochs, batch_size = 0, 30, 384\n",
        "\tn_timesteps, n_features, n_outputs = train_x.shape[1], train_x.shape[2], train_y.shape[1]\n",
        "\tnv_timesteps, nv_features, nv_outputs = val_x.shape[1], val_x.shape[2], val_y.shape[1]\n",
        "\t# reshape output into [samples, timesteps, features]\n",
        "\ttrain_y = train_y.reshape((train_y.shape[0], train_y.shape[1], 1))\n",
        "\tval_y = val_y.reshape((val_y.shape[0], val.shape[1], 1))\n",
        "\t# define model\n",
        "\tmodel = Sequential()\n",
        "\tmodel.add(Bidirectional(LSTM(100, activation='relu', return_sequences=True), input_shape=(n_timesteps, 1)))\n",
        "\t# model.add(Bidirectional(LSTM(100, activation='relu', return_sequences=True)))\n",
        "\tmodel.add(TimeDistributed(Dense(100, activation='relu')))\n",
        "\tmodel.add(TimeDistributed(Dense(1)))\n",
        "\tmodel.compile(loss='mse', optimizer='adam')\n",
        "\tprint(model.summary())\n",
        "\t# fit network and store mse loss in hist \n",
        "\thist=model.fit(train_x, train_y, validation_data=(val_x, val_y),callbacks=[csv_logger], epochs=epochs, batch_size=batch_size, verbose=verbose)\n",
        "\treturn model, hist\n",
        "\n",
        "# evaluate model fits model using training and validation data, then conducts a walk forwad validation with the test data\n",
        "def evaluate_model_BiLSTM(train, val, test, n_input):\n",
        "\t# fit model\n",
        "\tmodel, hist = build_model_BiLSTM(train, val, n_input)\n",
        "\t# history is a list of houry data\n",
        "\thistory = [x for x in train]\n",
        "\t# walk-forward validation over each hour in test set\n",
        "\tpredictions = list()\n",
        "\tfor i in range(len(test)):\n",
        "\t\t# predict the hour\n",
        "\t\tyhat_sequence = forecast(model, history, n_input)\n",
        "\t\t# store the predictions\n",
        "\t\tpredictions.append(yhat_sequence)\n",
        "\t\t# get real observation and add to history for predicting the next hour\n",
        "\t\thistory.append(test[i, :])\n",
        "\t# evaluate predictions hours for each day\n",
        "\tpredictions = np.array(predictions)\n",
        "\tscore, scores = evaluate_forecasts(test[:, :, 0], predictions)\n",
        "\treturn score, scores, hist, predictions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s5bznUvEG80F"
      },
      "source": [
        "# CNN-BiLSTM - Building Model Architecture and Training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gHfL1SE1GHjq"
      },
      "outputs": [],
      "source": [
        "# Build and train CNN-BiLSTM model\n",
        "def build_model_CNNBiLSTM(train, val, n_input):\n",
        "\t# Create training and validation sets\n",
        "\ttrain_x, train_y = convert_train_val(train, n_input)\n",
        "\tval_x, val_y = convert_train_val(val, n_input)\n",
        "\t# define parameters\n",
        "\tcsv_logger = CSVLogger('CNNBiLSTM_Model_Logger.log')\n",
        "\tverbose, epochs, batch_size = 0, 30, 384\n",
        "\tn_timesteps, n_features, n_outputs = train_x.shape[1], train_x.shape[2], train_y.shape[1]\n",
        "\tnv_timesteps, nv_features, nv_outputs = val_x.shape[1], val_x.shape[2], val_y.shape[1]\n",
        "\t# reshape output into [samples, timesteps, features]\n",
        "\ttrain_y = train_y.reshape((train_y.shape[0], train_y.shape[1], 1))\n",
        "\tval_y = val_y.reshape((val_y.shape[0], val.shape[1], 1))\n",
        "\t# define model\n",
        "\n",
        "\tmodel = Sequential()\n",
        "\tmodel.add(Conv1D(filters=64, kernel_size=3, activation='relu', input_shape=(n_timesteps,n_features)))\n",
        "\tmodel.add(Conv1D(filters=64, kernel_size=3, activation='relu'))\n",
        "\tmodel.add(MaxPooling1D(pool_size=2))\n",
        "\tmodel.add(Flatten())\n",
        "\tmodel.add(RepeatVector(n_outputs))\n",
        "\tmodel.add(Bidirectional(LSTM(100, activation='relu', return_sequences=True), input_shape=(n_timesteps, 1)))\n",
        "\tmodel.add(TimeDistributed(Dense(100, activation='relu')))\n",
        "\tmodel.add(TimeDistributed(Dense(1)))\n",
        "\tmodel.compile(loss='mse', optimizer='adam')\n",
        "\tprint(model.summary())\n",
        "\t# fit network and store mse loss in hist \n",
        "\thist=model.fit(train_x, train_y, validation_data=(val_x, val_y),callbacks=[csv_logger], epochs=epochs, batch_size=batch_size, verbose=verbose)\n",
        "\treturn model, hist\n",
        "\n",
        "# evaluate model fits model using training and validation data, then conducts a walk forwad validation with the test data\n",
        "def evaluate_model_CNNBiLSTM(train, val, test, n_input):\n",
        "\t# fit model\n",
        "\tmodel, hist = build_model_CNNBiLSTM(train, val, n_input)\n",
        "\t# history is a list of houry data\n",
        "\thistory = [x for x in train]\n",
        "\t# walk-forward validation over each hour in test set\n",
        "\tpredictions = list()\n",
        "\tfor i in range(len(test)):\n",
        "\t\t# predict the hour\n",
        "\t\tyhat_sequence = forecast(model, history, n_input)\n",
        "\t\t# store the predictions\n",
        "\t\tpredictions.append(yhat_sequence)\n",
        "\t\t# get real observation and add to history for predicting the next hour\n",
        "\t\thistory.append(test[i, :])\n",
        "\t# evaluate predictions hours for each day\n",
        "\tpredictions = np.array(predictions)\n",
        "\tscore, scores = evaluate_forecasts(test[:, :, 0], predictions)\n",
        "\treturn score, scores, hist, predictions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p34TtevIHBuX"
      },
      "source": [
        "# Load Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Y7j04IOvQxaP"
      },
      "outputs": [],
      "source": [
        "dataset = read_csv('data/data_spatial_TotalKW.csv', header=0, \n",
        "                   infer_datetime_format=True, parse_dates=['datetime'], index_col=['datetime'])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lymP_dztHGTU"
      },
      "source": [
        "# Data Decomposition into - Trend, Seasonality, and Noise"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 322
        },
        "id": "ERElaRwiRasS",
        "outputId": "5c044ce7-c3dc-4cfc-b407-b780e19d6b8e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 0 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 4 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Display and decompose data into trend, seasonality, noise\n",
        "fig1 = plt.gcf()\n",
        "month = dataset.iloc[0:720]\n",
        "decomp = seasonal_decompose(month, model='additive')\n",
        "decomp.plot()\n",
        "plt.show()\n",
        "fig1.savefig('seasonal_decompose.pdf')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YtluWri2HL8c"
      },
      "source": [
        "# Normalization - Normalize data using min-max scaling"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cW2OqNH2RWMG",
        "outputId": "d4b80173-7c0b-4a50-b383-7e84faf17957"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "train size:  (580, 24, 1)\n",
            "valid size:  (182, 24, 1)\n",
            "test size :  (184, 24, 1)\n"
          ]
        }
      ],
      "source": [
        "trans = MinMaxScaler()\n",
        "dataset = trans.fit_transform(dataset)\n",
        "tran_scale = trans.scale_\n",
        "\n",
        "# split into train and test\n",
        "train, val, test = split_dataset(dataset)\n",
        "print('train size: ', train.shape)\n",
        "print('valid size: ', val.shape)\n",
        "print('test size : ', test.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uD1BNeMfTtmH"
      },
      "source": [
        "# Naive Forecasting Technique"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UNVVoFS5Ronh",
        "outputId": "bd127885-66bb-4be2-c609-a706b7baa067"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "N_actual size:  (183, 24, 1)\n",
            "Avg. score:  1.786631258343538\n",
            "rmse: [1.787] 0.5, 0.5, 0.5, 0.7, 1.1, 1.5, 1.4, 2.0, 2.5, 2.6, 3.1, 2.4, 2.4, 2.1, 2.1, 2.3, 2.4, 2.0, 1.6, 1.5, 1.1, 0.8, 0.7, 0.6\n"
          ]
        }
      ],
      "source": [
        "# Perform naive prediction\n",
        "N_actual= test[1:184]/tran_scale\n",
        "N_predicted = test[0:183]/tran_scale \n",
        "\n",
        "N_score, N_scores = evaluate_forecasts(N_actual, N_predicted)\n",
        "\n",
        "print('N_actual size: ', N_actual.shape)\n",
        "print('Avg. score: ', N_score)\n",
        "\n",
        "# summarize rmse scores\n",
        "summarize_scores('rmse', N_score, N_scores)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GH7wZvkiZWGB"
      },
      "source": [
        "# LSTM Model Evaluation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yDoJTK4wZUzL",
        "outputId": "6c2f56ee-89e2-4c84-dddf-649abca73f0f"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:Layer lstm will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " lstm (LSTM)                 (None, 24, 100)           40800     \n",
            "                                                                 \n",
            " dense (Dense)               (None, 24, 100)           10100     \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 24, 1)             101       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 51,001\n",
            "Trainable params: 51,001\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "None\n",
            "Avg. LSTM score:  [1.56893886]\n",
            "rmse: [1.569] 0.7, 0.5, 0.5, 0.7, 1.0, 1.3, 1.2, 1.7, 2.1, 2.3, 2.6, 2.2, 2.0, 1.8, 1.7, 2.0, 2.3, 1.8, 1.4, 1.4, 1.1, 0.9, 0.7, 0.7\n"
          ]
        }
      ],
      "source": [
        "# evaluate model and get scores\n",
        "n_input = 24\n",
        "LSTM_score, LSTM_scores, hist, predictions_LSTM = evaluate_model_LSTM(train, val, test, n_input)\n",
        "LSTM_score, LSTM_scores, predictions_LSTM = LSTM_score/tran_scale , LSTM_scores/tran_scale, predictions_LSTM/tran_scale\n",
        "\n",
        "print('Avg. LSTM score: ', LSTM_score)\n",
        "\n",
        "# summarize rmse scores\n",
        "summarize_scores('rmse', LSTM_score, LSTM_scores)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KegkuZMZb7rR"
      },
      "source": [
        "# CNN-LSTM Model Evaluatiion"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QIjE1Nvlb58m",
        "outputId": "052707cd-e237-4d81-813b-9c412e803b5f"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:Layer lstm_1 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv1d (Conv1D)             (None, 22, 64)            256       \n",
            "                                                                 \n",
            " conv1d_1 (Conv1D)           (None, 20, 64)            12352     \n",
            "                                                                 \n",
            " max_pooling1d (MaxPooling1D  (None, 10, 64)           0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 640)               0         \n",
            "                                                                 \n",
            " repeat_vector (RepeatVector  (None, 24, 640)          0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " lstm_1 (LSTM)               (None, 24, 100)           296400    \n",
            "                                                                 \n",
            " dense_2 (Dense)             (None, 24, 100)           10100     \n",
            "                                                                 \n",
            " dense_3 (Dense)             (None, 24, 1)             101       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 319,209\n",
            "Trainable params: 319,209\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "None\n",
            "Avg. CNN-LSTM score:  [1.54955935]\n",
            "rmse: [1.550] 0.4, 0.5, 0.5, 0.7, 1.0, 1.1, 1.2, 1.6, 1.9, 2.2, 2.7, 2.2, 1.9, 1.8, 1.6, 2.0, 2.4, 1.8, 1.5, 1.3, 1.0, 0.9, 0.7, 0.6\n"
          ]
        }
      ],
      "source": [
        "# evaluate model and get scores\n",
        "n_input = 24\n",
        "CNNL_score, CNNL_scores, hist_CNNL, predictions_CNNL = evaluate_model_CNNLSTM(train, val, test, n_input)\n",
        "CNNL_score, CNNL_scores, predictions_CNNL = CNNL_score/tran_scale , CNNL_scores/tran_scale, predictions_CNNL/tran_scale\n",
        "\n",
        "print('Avg. CNN-LSTM score: ', CNNL_score)\n",
        "\n",
        "# summarize rmse scores\n",
        "summarize_scores('rmse', CNNL_score, CNNL_scores)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YZwx9jzoT5nY"
      },
      "source": [
        "# BiLSTM Model Evaluation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jrdCiwpMT2Ls",
        "outputId": "8ef86afe-3933-47e8-b0b1-762f0fc87258"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:Layer lstm_2 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n",
            "WARNING:tensorflow:Layer lstm_2 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n",
            "WARNING:tensorflow:Layer lstm_2 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"sequential_2\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " bidirectional (Bidirectiona  (None, 24, 200)          81600     \n",
            " l)                                                              \n",
            "                                                                 \n",
            " time_distributed (TimeDistr  (None, 24, 100)          20100     \n",
            " ibuted)                                                         \n",
            "                                                                 \n",
            " time_distributed_1 (TimeDis  (None, 24, 1)            101       \n",
            " tributed)                                                       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 101,801\n",
            "Trainable params: 101,801\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "None\n",
            "Avg. score:  [1.50154125]\n",
            "rmse: [1.502] 0.4, 0.4, 0.5, 0.7, 1.0, 1.2, 1.3, 1.7, 1.9, 2.1, 2.5, 2.0, 1.9, 1.7, 1.7, 1.8, 2.2, 1.7, 1.4, 1.4, 1.0, 0.9, 0.8, 0.8\n"
          ]
        }
      ],
      "source": [
        "# evaluate model and get scores\n",
        "n_input = 24\n",
        "BL_score, BL_scores, hist, predictions_BL = evaluate_model_BiLSTM(train, val, test, n_input)\n",
        "BL_score, BL_scores, predictions_BL = BL_score/tran_scale , BL_scores/tran_scale, predictions_BL/tran_scale\n",
        "\n",
        "print('Avg. score: ', BL_score)\n",
        "\n",
        "# summarize rmse scores\n",
        "summarize_scores('rmse', BL_score, BL_scores)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZPJAMmaRWbAS"
      },
      "source": [
        "# CNN-BiLSTM Model Evaluation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U8CUXElkWZ7d",
        "outputId": "e4dcbe94-d2a6-4154-de07-d1ae8ca631f1"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:Layer lstm_3 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n",
            "WARNING:tensorflow:Layer lstm_3 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n",
            "WARNING:tensorflow:Layer lstm_3 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"sequential_3\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv1d_2 (Conv1D)           (None, 22, 64)            256       \n",
            "                                                                 \n",
            " conv1d_3 (Conv1D)           (None, 20, 64)            12352     \n",
            "                                                                 \n",
            " max_pooling1d_1 (MaxPooling  (None, 10, 64)           0         \n",
            " 1D)                                                             \n",
            "                                                                 \n",
            " flatten_1 (Flatten)         (None, 640)               0         \n",
            "                                                                 \n",
            " repeat_vector_1 (RepeatVect  (None, 24, 640)          0         \n",
            " or)                                                             \n",
            "                                                                 \n",
            " bidirectional_1 (Bidirectio  (None, 24, 200)          592800    \n",
            " nal)                                                            \n",
            "                                                                 \n",
            " time_distributed_2 (TimeDis  (None, 24, 100)          20100     \n",
            " tributed)                                                       \n",
            "                                                                 \n",
            " time_distributed_3 (TimeDis  (None, 24, 1)            101       \n",
            " tributed)                                                       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 625,609\n",
            "Trainable params: 625,609\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "None\n",
            "Avg. score:  [1.52415686]\n",
            "rmse: [1.524] 0.5, 0.5, 0.5, 0.7, 1.1, 1.3, 1.5, 1.7, 2.0, 2.1, 2.4, 2.0, 2.0, 1.9, 1.8, 1.8, 2.1, 1.7, 1.5, 1.3, 1.0, 0.9, 0.8, 0.6\n"
          ]
        }
      ],
      "source": [
        "# evaluate model and get scores\n",
        "n_input = 24\n",
        "CNNBL_score, CNNBL_scores, hist, predictions_CNNBL = evaluate_model_CNNBiLSTM(train, val, test, n_input)\n",
        "CNNBL_score, CNNBL_scores, predictions_CNNBL = CNNBL_score/tran_scale , CNNBL_scores/tran_scale, predictions_CNNBL/tran_scale\n",
        "\n",
        "print('Avg. score: ', CNNBL_score)\n",
        "\n",
        "# summarize rmse scores\n",
        "summarize_scores('rmse', CNNBL_score, CNNBL_scores)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BLHMqO6OLDX9"
      },
      "source": [
        "# Comparative Study - Plot an example prediction of each model for one day"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wifvPna8NyyM"
      },
      "outputs": [],
      "source": [
        "### Taking 24 hours interval for the day-ahead load forecasting\n",
        "hours = ['1', '2', '3', '4', '5', '6', '7','8', '9', '10', '11', '12','13', '14', '15', '16', '17', '18', '19','20', '21', '22', '23', '24' ]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 515
        },
        "id": "BOObQv93U8uL",
        "outputId": "3d6a2f97-050e-48a8-ab8d-c7cecc50f706"
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4YAAAHyCAYAAAC3X9DzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3hUVfrA8e+bEEroEIqiUlSQLhBEVBQV0BUEFHVB6euq4CoKC0iToFRXAUVBxIWAgmUBxUoRaepPBKwICgooICUJEFpCCJzfH+dOZpLMTCbJJJOQ9/M895nbzrnnTknmndPEGINSSimllFJKqaIrLNQFUEoppZRSSikVWhoYKqWUUkoppVQRp4GhUkoppZRSShVxGhgqpZRSSimlVBGngaFSSimllFJKFXEaGCqllFJKKaVUEaeBoVJKKZ9EJEZEjIjEejlmnKVWPpYn1rlmTH5dU6nCLJifGX9/D5RShZ8GhkqpgIjIZSLyhIh8KCJ/isgZETkhIj+IyGQRuSgHeb7vEVzE5rBcri8qe4J5bjCJSF+P+/RcTovIbyIyX0Ra5meZChoRqeC8PjGhLksw+XntvS3vh7q8+UVEokVkuoh8LyLxInJWRBJE5GsReU5EGoW6jEopVdQUC3UBlFIFn4hcCuwBxGP3caA00MRZHhKRbsaYNQHm2RXoEuSiFgaHPNYrAZc7S08RGWyMeTE0xcqRX53Hs0HIqwIw1lmP8XPeAee68UG4Zn47lMXxo/lSihASkbLAHODvHrvPAYlAeaCVswwVkXeMMd3zv5QXnGB+ZuKdvA4EIS+lVAGjgaFSKhDhzuPHQCyw2hhzVESKA7cCrwC1gfdFpJ4x5qC/zESkDPASNrj8C7gqrwpe0BhjqrvWRaQYcC0wG2gATBORDcaYb0NVvuwwxuT762aMGQGMyO/rBoPna18UOUHhBqApkIoNEOcC3xpjzotIGNAQuBd4HBs8amCYS8H8zBhjXgZeDkZeSqmCR5uSKqUCcRRoZozpZIxZbIw5CmCMSTHGfArcASQD5YCHA8jvWeBSYAxZ16JcsIwxqcaYL7A1p2ewNbKBPH9KFUavYYPCZKCjMWagMWazMeY8gDHmvDHmJ2PM09ha9E9DWFallCpyNDBUSmXJGJNojPnBz/FfgK+dzRb+8hKR5sBjwPfYmsYCwXOABhEpISKjRORHpx+lEZEKeXVtY8xvwGZnM+358xzoQUTCRORfIvKNiBxz9l+d4R7uFJFlInJQRFJE5LDTJ/Q2f9cXkXoi8pZzfpKI/CIiY0WkRBbp/A4+IyKlReTfIvKViBwRkWQR2SUiH4jIAyIS4Zy3FtjtJV/XEuNxzO9AGs5rN1hENopIonM/v4rIVBHxWmPn0Q9wrbN9p4iscZ7nk06/tx7+nou8EOjr7/k6iEh9p8/qXqff3vsZ8mwmIm86x884/ftWiEg3P+XY4+TfVkRqiMhM53U8IyLfB3gvLXDX/o02xqz0d74xJgHo6COv3N7DRSLyqpM+SUS2i8iTTo2l6/x7RWSD81wfF5GPxUe/xwx/O0qKyDjnM5TkfKbeEpG6fsp2o4i86Lxn//L47C4XkXv8pAvob5a/z4yIVBWR/4jIVhE55XxG9zqf2WdEpGaG8/0OPuO8T/8hIuvE/ZnfLSKvicgVPtK0FY++3yJyvYh85LyuSWL7sf9LRMRbeqVU8GhTUqVUsCQ4j+G+TnC+eM3G/ig10BhzrgD+ry8JrAeuwfadO51P193vPJbzckyApdiaxXPAiXQHbYA1D3jAY/dxoArQCegkIs8ZY4ZnyljkRmzNTKRHutrYfn63AWtzcjMi0gDb9LiWsyvVyftSJ/87gS+xfVePYPsuRTnnZqxFPhngNasAK4Bmzq4zQApQ11n6isgdxpivfWSBiIwBngHOY5/n0tg+b4tEpJoxZnogZQkyv6+/hzbAq9jX8gT2OXdnIvIQMAv3j8LHsH07OwAdRORNoK8x5pyP/OsC/8O+TqfJXt9SV034EQL8QcgYYzLuC8I91AbeAqpj348R2KbsU4E6wGMiMhkYjn2uTwNlsa0irhORa4wxO33kXQJYg20enoKtGa2CDYg7i8jfjDHrM9xPGWCdx64TQJKT7jbgNhF5zRjjryVBjv5mOUHf/wGugcPOYZ+TGsAlQGtsU/9XA8wvEngP+1rgUZZawD+BXiLS3RizzE8efYHXsa/vcefemgAzgCuAJwIpi1IqZ7TGUCmVa2L7yl3vbG71c+q/gGhgrjHm//K8YDnzKPYLcHegjDGmAvaLzak8vu5lzuMxL8fuBm4HBgLljDEVgWrALuf4c9ig8DfgPmy5y2ODzIHYL5vDJEOtl4hUxH7RjwS+Ba520pUB+mCb/Q3M7o2ISCVgOfZ52w10BUobYyo717oBG8imAhhj7gbSRmU1xlTPsDwf4KUXYIPCo87zUNoYU87J+yegIrYfbJSP9FdjB8AZA1R2XvvqwGLn+CTn3vJbVq+/y0xgE9DYue9IYAiAiFyHO6BaDFzq5FMBGA0YoCf++6K9gB105HpjTGljTBnAZ41WBjc7j6uMMckBpkknSPcwDfuebOrxGRnjHHtUREYCg7EBSHnneWyMHXClAjDBT94DsEFMb9yfwWbYz1Yk8K7zmfN03rmXu7DvuXJOuorYv5cnsQN73evnujn9mzUWGxT+BtwIFDfGVAJKOfc8HvDbXzyDqdig8AzwCFDWKUs97A9MJbE/sPiqPa2C/eFwFnCRk7YiNigEeFxEGmajPEqp7DLG6KKLLrrkagEGYb+UnQMa+DinBvYX4HjsFyDX/rVO2tgcXjvG49oHs1hOOufu8ZJPrHPMAB2C/Pz0deXt47hrMA4DzPBybwZ4yEfaK7FfLg9jvyh7O6e7k8fWDPvHOPvjgSgv6Xp6XD/T6+NxrFaG/c85++OAGgE+R7X8PUdeXqeYDPvbeJTnNi/pqmFrqwzwjK/XBxjlJW0p5/k1QO+cvvYBvD9v9/He9vn6Z3gdfgdK+ThntXPOF0C4l+MTneMnsMGn57E9zrGjQLUcvP8jPMo4Ihefo2DcwxGggp+8DfC0l+Ou91cyNoDy9p40wANe0kY5nzGDbUabnXvu5aRb4+ez4Pdvlp/PzDZn/9+zUR7XezI2w/5a2L/BBnjYS7pIbABqgAUZjrX1uI85Pq77o6/XRhdddAneojWGSqlcEZEmwCRn82VjzDYfp76EbZL1lLH9h4ItDPvl399SOoB8fjRZ9H8KFhGp4vQh+hDbBDcV7822ErCjN3rTG9vU8B1jzF4f5yzG/orfUNLPN+mq7ZljjPE2lP1C4A//d+GzTADPG2P2+z0zeFz3stkYsyLjQWPMIdzP7X0+8kgGMjUVNcYkYZuoAuRmfr2s3p8lfaTz9/p7etkpazpOLaerxm6S8d7Mcgr2/stgm016s8B5HrPLs5b1SA7SB/MeXjXGeKuV/8x5TMHWfGX0pZN3CWyTRm/+ABZl3Ol8tmY7m4HWsLp86DxeKyK+munn9G/Wcecx23PQenEX9m/wQWxT0HSMMaexPxgB3O3nXib52O9qfqrzWyqVhzQwVErlmBNkvI+tUdmC7Zfj7bxO2OZwXwP/zaPi/GGMEX8LMC6AfPK0iat4DKqCrYX6H7bf3RngH8aYn70k22yMSfWyH+A657GP2EFnMi3APmytDc61EDvViKtZ1jq8MMYYbN+l7NxfLWyQA/BJdtLmUnPn0d88mp87j3VFxNuPBNuMMb6a37kC3IxNAQOW1fvTGONrgnt/r78nX+/dZtgfDwy+X+tE7GcY3M9loPnnh2Ddw08+9h92HvcYYzL1aTV25FTXjye+3gPrnM+M12POYyPns5dGRIo5A7YsF5EDYgfUcf2NcM1tWdLPdXP6urg+n1NE5BURuVlESuUwL9fzvcFH0A7uz19pbPPSjI4YYzI2j3bJ9edPKZU1HXxGKZUjzi/4K7GDOezEDj+fqe+Q8wX8FWwzo4F+vjgVFHF5nL9njUsydnCHL4HZxo5Omt0yuX7tL+ssWXENMlMJ90BBf/k5P7s1ftU81v/MZtrcqOI8+ivvPudRsM37MgaBvgZ1AftagTvAzk+Bvid9ned6bhK9BT0eXM9PFR/Hc/rZ8KwlzGkfzWDdg6+J2c9lcdzzHF/vAX/vPdexcGxwcwjSBp9ZgfsHHrCDz8Rhm4iD+zNVGu+T1Of0dZmCHQW5M7b/6kAgVUQ2YQeRmeOjdtWb7Hz+PM/3VFA/f0oVGRoYKqWyTUTKY7/MNMJ++W/np4nZMOzAKnOAnc4XIU+u4KSYx7FTIQwgff3aHRQmZ5Oc+yuTq+XHkyY0I2YWNL6aYxZmgb4nszrP7/QjQSxHOsaYsyLyG7YJZtNcliG391DQjMEGhfHYgYKWG2NctZc4TS5dtcW+hnDO6etyBugiItdim4LeiA0UWzvLUBFpb/xMVeTFhfj5U6rI0KakSqlscWoAP8GOLnoQGxT6qxlyzYP1T+wvwhmXG5zjD3jsq4kKlCsgv8zvWZkdwf2F8mI/5/k75q88kL+vo6vWxN/zcInz6Bpwp6hwPTelnCk9fHE9P3lRa+5q4tteRHISPBSEe8hKIJ+jc7ibhwK4Rht9zBizwDModFQjjxljvjbGDDfGtMbWZvbA/uBXBS/9BX3IzufP83ylVAGigaFSKmBO/5MPsb9wJ2CDQl9zeqn84epfdHt2EhljUgBXf8YbvZ3jTCjt9ZiffPfgHuLe1wAg3riazbmum13fOo83+Ul/i/O4w09fwgvRd9hgGNwDuKTjtAJo4Wx+6+2cXHrNeaxEgFOgZHgdC8I9ZOWmAI5tdT57Lq5g6Tsf6drlulTZYIw5ZYx5G3jI2dXCR3/cjFzPdytnPkNvXJ+/U9jpP5RSBYwGhkqpgDgDJizFfik7hh0e3dtAKekYY/pmMSCMa1CG+R779+TZjVx4FmC/MNcXEX+TYLvmLfT0P+fxnz7m5+uOe4L67HjDeRwiIjUCTHPcY71CDq7pmmuwIXYi+HREpBp2bjWAd3OQf6FljDmCu8ZuuIh4+98/HNsM8CR5MGiQMWYz7ud9goi093e+iFQGPvZIH/J7CECtjHOFQlp/bFeg9b8MhxOdx8Ze0pUBRgW1hOnzL+7nsGt0WwH8neeyFPvjTmXc9+p5rUhgqOtcPwPUKKVCSANDpVSWnH4ui7C1UieAvxljQvGLfMiISIzHSIEFhjM9yDRnc6aITBKRtCZbIlJWRDqIyJtk/lL6CnY0xihghTP1CCISISI9sf1CE8m+KdhBKKKADSLS2fUl1Mn7JhF527OcziAXrkFw+mX3gsaYDcByZ3OuiNzjGhJfRFpgB0pyDfrxYg7uqbAbg/3i3hxIe+5FpIwzqftTznmTjTHHfeSRW//EjgpaEvjEGQmzuSvIE6uRiIzDzsn4twJ4D/4kAnNE5AERKeaUrQm2P3YV7GdtZoY0q5zHqc7nQpx0LbFzK1bOw/JuFZGJItLS4/MpInIN7knlNxljjvrOwjLG/IG7VniyiDwkIiWcPOtig/wrgNPA+GDfiFIqODQwVEoF4nqgm7MeAbzva2oEZ0Q7lb+GAbOwf9OfAvaKSKKIHMN+WV2B7cOZbu4w5wvffdjagWjgByfNCWyt349OvtnizFP5N+wohLWxc5CdFJF47BfDtcDfyTwAmqs/0wsiclJE9jjLEwFeujfwPTYA/J9zzePAZqAJtm/XXXk0j2aW/Hxm8vyzY4z5CtuE8zy2X9ufInIEW/s/AVsztBCYnIdlOI7tU7wY+9oPxE4vkSIiCdg5BH8CngbKAfML2j1kYRawFXgT+95LBH7AfrZOA/d6CbJGY/u7Xor9XJwWkZPAN9haxPvzsLxVgRHOtU47r8EZYCP28xIPPJiN/IZgA90S2HkbT4jIUWyz0bZO3vcbY3YE6waUUsGlgaFSKhCefytK4n+Sbn8DQ6g8YIw5Z4wZiP3S/SZ2ou0S2NfqT+AD4F94mVzbGLMOO0fcO9gBIUoAe4AYbJ+gMzks00/YZp2jsYFZEna4/T+xc1/2IP3w9QDPYJsD/oj9kl/TWQJqWmqMicOOpvhv55pnsc3gdmInrm9ojAnlXHxZTXCfp58dY8xsoCW29v8AdiL4ROyX+XuNMT3zuomfMea4MeZewFUr9RO2GXE55/FrbGBX3xjTtyDegx9nsAHQM9jPYHHsZ+ptoLkxJtOcoM68fddgP7eHsT/eHMMGuC1zOHF9oLpgJ5T/EltbXwYbnP+IfQ0aGmN+DDQzZxL7v2GDyQ3YYDgS+1y8DjQ2xizznYNSKtSk4E8pppRSSilVMIlILNAHGGeMiQltaZRSKue0xlAppZRSSimlijgNDJVSSimllFKqiNPAUCmllFJKKaWKOA0MlVJKKaWUUqqI08FnlFJKKaWUUqqIyziH1AUrKirK1KpVK9TFUEoppZRSSqmQ2LJlS7wxxuv0SEUmMKxVqxabN28OdTGUUkoppZRSKiRE5A9fx7SPoVJKKaWUUkoVcRoYKqWUUkoppVQRp4GhUkoppZRSShVxGhgqpZRSSimlVBGngaFSSimllFJKFXEaGCqllFJKKaVUEaeBoVJKKaWUUkoVcUVmHkOllFJKKaUCkZiYSHx8PCkpKaEuilJZKl68OFFRUZQvXz5X+WhgqJRSSimllCM5OZlDhw5xySWXUKpUKUQk1EVSyidjDElJSezbt48SJUpQsmTJHOelTUmVUkoppZRyxMXFUaVKFSIjIzUoVAWeiBAZGUlUVBRxcXG5yksDQ6WUUkoppRzJycmUKVMm1MVQKlvKli1LcnJyrvLQwFAppZRSSilHamoqxYppbytVuBQrVozU1NRc5aGBoVJKKaWUUh60CakqbILxntXAUCmllFJKKaWKOA0MlVJKKaWUUkHXt29frX0tRDQwVEopVWCdPAn33Qft2sH+/aEujVJKXVjWrl2LiCAizJkzx+s5IkKnTp3yuWQqFDQwVEopVWBNmAD/+x+sXg0xMaEujVJKXbhiYmJISkoKap5z5swJep4q72hgqJRSqkBKTISZM93b770HuRxwTSmllBfR0dH89ddfTJ8+Paj5RkRE5GrCdZW/NDBUSilVIM2cCcePu7cTEmD9+tCVRymlLlT33XcfLVq0YMqUKSQkJPg9d+XKlfz973+nTp06lCpVigoVKtChQwfWrVuX6dyMfQyHDx+OiPDjjz9mOjcxMZFSpUrRtWvXdPs/++wzOnToQIUKFShZsiRNmjTh1VdfzeGdKn80MFRKKVXgnD4N06Zl3r94cf6XRSmlLnQiwuTJk0lMTGTChAl+z42NjeXIkSP07t2bGTNm8OSTT7J9+3ZuvfVWNmzY4Ddtnz59AFiwYEGmY++++y7Jyclp5wC89tprdOjQgZMnTzJq1CimTp3K5ZdfzoABAxg6dGgO7lT5o7N3KqWUKnDmzoW4OLteqhS4uqi89x7MmAHh4aErm1JKXYjatWtH+/btmTlzJoMGDaJmzZpez5szZw6lS5dOt++RRx6hYcOGTJo0iTZt2vi8RoMGDYiOjmbRokVMmTKFcI8/5gsWLKBy5cp07NgRgAMHDvD444/TvXt3Fi1alHbewIEDGTRoEFOnTmXAgAHUqVMnN7etPGiNoVJKqQLl7Fn4z3/c2xMnQtWqdv3gQfjqq9CUSylVtIkU3CVYpkyZQkpKCmPGjPF5jmdQePLkSRISEggPD6dVq1Zs3Lgxy2v06dOHAwcOsGrVqrR9u3fv5ssvv6RHjx4UL14cgMWLF3PmzBn+8Y9/EB8fn2658847OX/+PJ999lku7lZlpIGhUkqpAuWtt+DPP+16lSrw0ENw113u40uWhKZcSil1oWvWrBk9evRg4cKFXvsBAvz+++90796dihUrUrZsWaKioqhSpQqffPIJR48ezfIaruDPsznpggULMMbQu3fvtH3bt28HbE1mlSpV0i3t27cH4NChQ7m5XZWBNiVVSilVYJw/D5Mnu7cHDYLISLjnHpg92+5bsgSmToUw/WlTKaWCbvz48SxevJjhw4fz6aefpjt28uRJbrzxRk6dOsUTTzxB48aNKVu2LGFhYUyaNInPP/88y/wrV67MHXfcwfvvv8+JEycoW7Ysb7zxBvXr16dly5Zp5xljABs0XnTRRV7z0makwaWBoVJKqQLjgw/A+ZGYsmXh0Uft+k03QaVKcOQI7NsHmzZBq1ahK6dSquhx4pQLXu3atRkwYAAvvvgia9euTXds9erV/PXXX8ydO5d+/fqlOzZ69OiAr9GnTx/ef/99/ve//1GvXj1+//13Jnv+KghceeWVAERFRdGuXbuc3YzKFv29VSmlVIFgjO1P6DJgAFSoYNcjIsBzBHMdnVQppfLO6NGjKVeuHMOGDUu33zVYjMkQJa9cuTKg/oUuHTt2JCoqigULFrBgwQLCwsLo2bNnunPuu+8+SpQowdixY0lyjUDmITExkTNnzgR8TZW1AldjKCIXAVcDtYGyzu4TwB7gO2PMgRAVTSmlVB76/HNbEwhQogQ8+WT649262dFKwTYnfe654A66oJRSyoqKimLo0KGZBqG54YYbqF69OkOGDGHPnj1ccsklfP/997zxxhs0btyYn376KaD8IyIi6NGjBy+//DJbtmyhXbt21KhRI905l1xyCbNmzeLBBx+kfv369OrVi5o1axIXF8dPP/3E+++/z7Zt26hVq1awbrvIKzA1hiJyp4h8DewDPgJmABOdZQbwIbBPRP5PRDqFrqRKKaXywqRJ7vX+/aF69fTHb70Vype367t3w3ff5V/ZlFKqqBk8eHCmvn0VKlRgxYoVtGrVihkzZjBkyBC2bdvGJ598QvPmzbOVf58+fTDGcPLkyXSDznjq168f69evp1mzZsyePZuBAwcyY8YMDhw4wLPPPkv1jP8oVK5IxqrgkBRCZBrwOCDAWeBn4E/gpHNKGeBSoBEQARjgJWPMk5lz8y46Otps3rw5mMVWSikVJJs2wTXX2PXwcNi5E2rXznxer17w5pt2feRIyGIeZqWUyrbt27dTv379UBdDqWwL5L0rIluMMdHejoW8xlBEugODgMNAX6CCMaa5MaarMaans3Q1xrQAKgD9nHMfF5G/Z5H3QyKyWUQ2x7lmSlZKKVXgeNYWdu/uPSgE25zUZfHiojMYhFJKKZXXQh4YAgOBZOAGY8wCY0zm3qUOY0ySMWY+cCNwxknrkzHmNWNMtDEmukqVKkEttFJKqeDYtg3ee8+9/dRTvs+97TZwza28Ywf8/HPelk0ppZQqKgpCYNgEWG2M+T3QBMaYncBnQNM8K5VSSql8MWWKe/3OO6FRI9/nlioFHTu6t3V0UqWUUio4CkJgGI6t/cuus05apZRShdQff8CiRe7tkSOzTnPPPe71JUuCXyallFKqKCoIgeEvwK0iEhVoAhGpAtzqpFVKKVVIPf88pKba9bZt4dprs07zt79ByZJ2fetW+PXXPCueUkopVWQUhMAwFigPfC4i12d1sojcAHyOneNwXt4WTSmlVF45fBhef929PWJEYOnKlLHBoYvWGiqllFK5VxAmuJ8JdADuBNaLyD5gE/AHcMo5pzRQE2gJXIKd1uIDY8zM/C+uUkqpYJg+HZKT7Xrz5tC+feBpu3VzD1izZElgTVCVUkop5VvIA0NjjBGRu4AngWHY+QovdR12HsUjSRzwHDAt3wqplFIqqBIT4ZVX3NsjRoCI7/Mz6tQJiheHlBT49lvYtQvq1Al+OZVSSqmiIuSBIYAx5jzwgjPRfWugGVAbO7E92Inu9wDfAv/nnK+UUqqQmjULjh+36/XqwV13ZS99+fK2hvHjj+320qXw738Ht4xKKaVUUVIgAkMXJ+D70lmUUkpdgJKSYJpHm4/hwyE8B2NM33OPOzBcvFgDQ6WUUio3CsLgM0oppYqQefPswDMAl1wCDzyQs3w6d4Zizs+bGzfC3r3BKZ9SSilVFGlgqJRSKt+cPQvPPefe/ve/bV/BnKhUCW65xb29dGnuyqaUUkoVZYUyMBSRgSLytIg8HeqyKKWUCtzbb9tJ7QEqV4YHH8xdft26udd12gqllFIq5wplYAg8Box1FqWUUoXA+fMwebJ7+4knoHTp3OXZtSuEOf/JvvgCDh7MXX5KKVWUrF27FhHh+eef93verl27eOihh7jqqquIjIykYsWK1K9fnz59+rBmzRoA+vbti4gEtMTExADQtm1bRISIiAgO+vgDPmjQoLR0a9euDebtqwwK1OAz2bAJ0H//SilViHz4IWzbZtfLlIFHH819nlWrwo03wtq1YIyd23DAgNznq5RSytq8eTM33XQTERER9O7dm4YNG5KUlMTOnTtZuXIlZcuW5eabb+bhhx+mXbt26dL26tWLq666ilGjRqXb36RJk7T1Yk5n8TfeeIOhQ4emOy8lJYWFCxdSsmRJkl0T36o8UygDQ2NM71CXQSmlVOCMgYkT3dsDBkDFisHJu1s3GxiCHZ1UA0OllAqecePGcfr0ab7//nuaNm2a6birpq9169a0bt063bFevXpRrVo1evbs6TP/EiVKcMsttzBv3rxMgeGyZctISEjg/vvvZ9GiRUG4G+VPYW1KqpRSqhBZswa++caulygBTz4ZvLzvvtu9vm4dxMUFL2+llCrqdu7cSeXKlb0GhQDVq1fP9TX69evH9u3b2bhxY7r98+bNo2nTpjRr1izX11BZKzSBoYiEi0gVEZFQl0UppVT2TJrkXu/bFy66KHh5X3wxXHedXT93DpYtC17eSilV1F1++eUkJCSwNA+Hfu7UqRNVq1Zl7ty5afv279/PypUr6d+/f55dV6VXYAJDEekjIm+KyH9FpLPH/uoishg4je1XGC8iU0SkRMgKq5RSKmCbN8Nnn9n1sDAYNiz417jnHve6jk6qlFLBM3r0aCIiIujWrRt169alf//+zJo1i+3btwftGhEREfTs2ZN33nmHpKQkAObPn094eDgP5HSyW5VtBaKPoYgsBboArtrAviIyAZgAfAq46q5TgYrAv4GrnDRKKaUKMM/awu7doU6d4F/j7rth8GC7/tlncPRo8PowKqUUgKwNdQl8M23zLmzJL4IAACAASURBVO/WrVuzZcsWXnjhBT799FPmzZvHvHnzAGjTpg2xsbHUCcIf9v79+zN16lSWLl3KAw88QGxsLF26dKFy5cq5zlsFJuQ1hiLyANAVOAw8DYwE9gEjgCeBBthAMAooAdwC7AE6icidISiyUkqpAG3fbkcKdXnqqby5Ts2a0LKlXU9NtSOgKqWUCo7GjRsTGxvLoUOH2LNnD/Pnz6dNmzZs2LCBLl26kJKSkutrNGzYkJYtWzJv3jw2bNjAzp076devXxBKrwIV8sAQ6AucB24xxow3xkwG2gIGGAdMN8ZMNcYcMdZaoDe2dtH3EEdKKaVCbsoUOyIpQKdO0Lhx3l1LJ7tXSqm8V7NmTXr37s26deu4/vrr2bp1K9+4RhfLpf79+/P5558zbtw4atSowW233RaUfFVgCkJT0qbARmNMWkNlY8xuEfkKaAPMy5jAGPOliGwDWuZfMZVSSmXHn3/CwoXu7REj8vZ63bq5ayRXrIATJ6Bs2by9plKq6MjL5pqFkYjQqlUrvvzyS/bv3x+UPHv06MHgwYNZvXo1I0eOJCysINRhFR0F4dmuAPzhZf8+53G3j3S/A7kfH1cppVSeeP5526wT7CT0rpFD88oVV4BrNPUzZ+Djj/P2ekopVRSsWrWKVNcfcw9JSUmsXLkSgAYNGgTlWuXLl+fVV19l7NixPPzww0HJUwWuINQYHgdKe9l/FsAYc8ZHuhPY5qZKKaUKmLg4eP119/bIkflz3XvugR9+sOuLF9vBbpRSSvm3evVqkpOTM+2Piori5ZdfJiEhgc6dO9O4cWMiIyPZu3cvixYtYseOHfTu3ZvGQewn0Lt376DlpbKnIASGh4EaXvavw45C6kt1QKcxVkqpAujFF8EZcZxmzaBDh/y5brduMGaMXf/0Uzh1Ckp7++lRKaVUmuXLl7N8+fJM++vVq8dLL73EsmXL+OKLL1iyZAnHjh2jfPnyNGnShOHDh9O3b9/8L7DKE2JMaCvdROQd7LQTFY0xSQGmCccGhd8ZY24NJE10dLTZvHlzzguqlFIqIMePw2WXQWKi3X73Xbj33vy7fsOGsG2bXV+8OP2gNEoplZXt27dTv379UBdDqWwL5L0rIluMMdHejhWEPoZfYIO8ZtlIczu2b+KGPCmRUkqpHJs1yx0U1q1r5xjMTzo6qVJKKZV9IQ8MjTEzjDGXGmO+ykayY0A/IDZvSqWUUionkpJg2jT39rBhEB6ev2W45x73+ocfgpduM0oppZTKIOSBYU4YY740xsw3xuwJdVmUUkq5xcbCoUN2/ZJLoFev/C9D48Z2hFKAkydh1ar8L4NSSilV2BTKwFAppVTBk5oK//mPe3vIEChePP/LIZK+OenixflfBqWUUqqw0cBQKaVUULzzDux2Zp6tXBn++c/QlcWzOekHH0BKSujKopRSShUGGhgqpZTKtfPnYdIk9/bjj4d2mogWLaBmTbt+7Bh8/nnoyqKUUkoVBhoYKqWUyrWPPoKff7brZcrAv/4V2vJkbE6qo5MqpZRS/mlgqJRSKleMSV9b+MgjUKlS6Mrj4hkYvvee7QOplFJKKe80MFRKKZUr69bB11/b9eLF4cknQ1sel2uvhYsvtusJCbB+fWjLo5RSShVkGhgqpZTKFc/awr593cFYqIWFwd13u7d1dFKllFLKNw0MlVJK5diWLbBypV0PC7MT2hcknqOTvveeHSRHKaWUUplpYKiUUirHPGsL77sPLr88dGXx5oYboGpVu37wIHz1VWjLo5RSShVUGhgqpZTKkV9+gaVL3dsjRoSuLL6Eh8Ndd7m3tTmpUkop5Z0GhkoppXLkuefsiKQAHTtCkyahLY8vGaet0OakSinldvr0aaZPn06bNm2oVKkSERERVKtWjTvuuIPY2FhSPYZ0btu2LSJCnTp1SElJyZRXTEwMIsLmzZvT9q1duxYRQUSYM2eO1zKICJ06dQqovK78nn/++SzP3bVrFw899BBXXXUVkZGRVKxYkfr169OnTx/WrFkDQN++fdPKl9USExOT7nmIiIjg4MGDXq89aNCgtHRr164N6N5CrVioC6CUUqrw+fNPeOMN93ZBrC10advWTp9x5Ajs2webNkGrVqEulVJKhd5vv/1Gx44d2bFjB+3atWPEiBFERUVx+PBhPvvsM/r168e2bdt47rnn0qXbvXs3s2bNYtCgQdm6XkxMDD179qRUqVLBvA2vNm/ezE033URERAS9e/emYcOGJCUlsXPnTlauXEnZsmW5+eabefjhh2nXrl26tL169eKqq65i1KhR6fY38fgFtFgxG0a98cYbDB06NN15KSkpLFy4kJIlS5KcnJxHdxh8GhgqpZTKthdecM8L2KYNXH99aMvjT0QEdOkC8+bZ7SVLNDBUSqmkpCQ6derErl27WLJkCXd7DuMMDB8+nE2bNrFp06Z0+0uVKkXt2rUZP348/fv3p2zZsgFdLzo6ms2bNzN9+nRG5MOviePGjeP06dN8//33NG3aNNNxV01f69atad26dbpjvXr1olq1avTs2dNn/iVKlOCWW25h3rx5mQLDZcuWkZCQwP3338+iRYuCcDf5Q5uSKqWUypa4OPBsDVSQawtdPEcnXbzY3QRWKaWKqtdff51ff/2VIUOGZAoKXVq2bMnAgQPT7QsLC2PSpEnEx8dnqkn057777qNFixZMmTKFhISEXJU9EDt37qRy5cpeg0KA6tWr5/oa/fr1Y/v27WzcuDHd/nnz5tG0aVOaNWuW62vkJw0MlVJKZctLL0FSkl2/+mq4/fbQlicQt94K5crZ9d274fvvQ1sepZQKtcXOaFwPPfRQttN27tyZG264gWnTpvnsY5eRiDB58mQSExOZMGFCtq+ZXZdffjkJCQks9RwlLcg6depE1apVmTt3btq+/fv3s3LlSvr3759n180rGhgqpZQK2PHj8PLL7u0RI0AkDy94PhkOPgL7u0NqXI6zKVEC7rzTva2jkyqlirqtW7dSrlw56tSpk6P0U6ZM4dSpU2kDsgSiXbt2tG/fnpkzZ/LHH3/k6LqBGj16NBEREXTr1o26devSv39/Zs2axfbt24N2jYiICHr27Mk777xDkvOL6fz58wkPD+eBBx4I2nXyiwaGSimlAjZ7Nhw7ZtevvDL9iJ95IuFZODYbTrwDB7P/q7YnbU6qlMqVX6TgLjlw/PjxgPsHenPdddfRtWtX/vvf/7Jjx46A002ZMoWUlBTGjBmT42sHonXr1mzZsoU+ffqQmJjIvHnzGDhwIA0aNODGG29k165dQblO//79SUxMTKuZjI2NpUuXLlSuXDko+ecnDQyVUkoFJDkZpk51bw8bZucJzDOp8XD0Jff2yfch6f9ynN1tt0Hp0nZ9xw74+edclk8ppQqxcuXKceLEiVzlMWnSJIwx2RpMplmzZvTo0YOFCxfy448/ej0nMTGRgwcPplvOnTuX7fI1btyY2NhYDh06xJ49e5g/fz5t2rRhw4YNdOnSxeuUG9nVsGFDWrZsybx589iwYQM7d+6kX79+uc43FDQwVEopFZDYWHB1Jbn4YujVK48veOQFOH8y/b7Dw3Nc1VeqlJ1v0WXJklyUTSmlCrlGjRpx/PjxXNWcXXXVVfTr14+lS5dmGoDFn/Hjx1OsWDGGDx/u9figQYO46KKL0i179+7NcTkBatasSe/evVm3bh3XX389W7du5ZtvvslVni79+/fn888/Z9y4cdSoUYPbbrstKPnmNw0MlVJKZSk11U5o7zJkiO23l3cXjIOjMzLvT9oApz7JcbaeTV+1n6FSKluuMgV3yYFuzh/E119/PVdPy7hx44iMjPQZ5HlTu3ZtBgwYwPLly71O/j5s2DBWrVqVbgnGKKJgB8Fp5cxZtH///qDk2aNHD0qWLMnq1avp06cPYWGFM8QqnKVWSimVr959147mCXay+BwMYpc9R14Ac8qul2gEFQa4j8U9BSb7TYoA7rgDSpa061u3wq+/5rKcSilVSD344IPUq1eP559/nmXLlnk9Z8uWLcycOdNvPhdffDGDBg1i3bp1fPJJ4D/cjR49mnLlyjFs2LBMxxo0aEC7du3SLSVdf7wDtGrVKlJdE+56SEpKYuXKlWnXCYby5cvz6quvMnbsWB5++OGg5BkKOsG9Ukopv86fh0mT3NuPPw5lyuThBVPj4KjH0KeVx0JkG0hcYIPFM1vh+EIo3zvbWZcpY6fXeP99u71kCYwcGaRyK6VUIRIZGclHH31Ex44d6dq1Kx06dKB9+/ZUrlyZuLg41qxZw4oVK7wGbhkNHz6c1157jU2bNgV8/aioKIYOHZrjQWhWr15NcnKy13wfeeQRnnzySRISEujcuTONGzcmMjKSvXv3smjRInbs2EHv3r1p3Lhxjq7tTe/e2f+fVNBoYKiUUsqvjz+2tWtgB2957LE8vuCR/3jUFjbh57C7OXU6jGsqDbajlALEjYGy90FY9n5BBjs6qQaGSikFV1xxBd999x2zZ89myZIlTJgwgZMnT1KpUiWio6OZP38+999/f5b5lC9fnlGjRjF48OBsXX/w4MHMnDmTAwcOZLvsy5cvZ/ny5Zn216tXj0ceeYSpU6eybNkyvvjiC5YsWcKxY8coX748TZo0Yfjw4fTt2zfb17zQiSki43VHR0ebzZs3h7oYSilVqBgD118P/+cMBjp4MLzwQh5eMPUw/F4bzGkANpZZwvW/3c05YH7d4/Q+dTmci7fnVp0KlZ7M9iUSE6FKFTh71m7v2gW1awep/EqpQm/79u3Ur18/1MVQKtsCee+KyBZjTLS3Y9rHUCmllE/r17uDwogIGxjmqSPPpQWFKRFNuWNPV1y9Cf+9uxxnKo52n5swAc4lZvsS5ctDhw7ubR2dVCmllNLAUCmllB+efQv79oUaNfLwYqkH4ah7kINnTsVwJNX9byruLEw7+QhE1LI7ziXYZqc54Dk6qQaGSimllAaGSimlPBw5AitWwDPP2Dn/Vqyw+8PC7IT2eSrhOTBJAByUZkw40iXTKZP3luBUxWc9CjwNUrPfN6VLFyjm9LL/+mvYty9HJVZKKaUuGBoYKqVUEZWSAps2wcsv28nq69aFypXtqJ1jx4LnqOP33gtXXJGHhUk9AMdmpW0OOBoDCAAjL4MrS9n9iedg4tH7oURTu8Ochvhnsn25SpXg5pvd20uX5rDcSiml1AVCA0OllCoCjIHff4e33oInnoDWraFcObjmGjvK6Jtvws6d3tPWqgUTJuRxAROmgLHDjm9Nbc77yXcC0LocjKsFz9Rynzp9fxhHK3q0cT02B1J8FN6Pe+5xr+tk90oppYo6na5CKaUuQEePwjffwMaNdvnmG4iPzzpdRAQ0bQqtWrmXK68EkTwsbOoBODY7bXPEiRhAKBcOC+tDsTC4rypM+hN+PAWnz0PM4dt5MbItnF4LnIO40VDjnWxdtmtXGDDAztP4xRdw8CBUrx7E+1JKKaUKEQ0MlVKqkEtJgR9+cAeAGzfCjh2Bpa1Tx9YauoLAZs2gZPanBsydhMlptYWbzkbz0ZlOAMyqC7WdJqRhAuNrQ2dnPsVXDwgjrp5M9dPX2h0n3oWkoVDK6wjcXlWtCm3awLp1tkb1vfdsoKiUUkoVRRoYKqVUIWIM7N7trgncuBG++w7OnMk6bYUK6YPAa66x8/mF1Nn96WoLY07GAEKvanB/tfSndqoMrcrCxhOQYmD0gVa8XrYbnHCGFY0bDpd+lq3qzXvusYEh2NFJNTBUSilVVGlgqJRSBZhnk1DXYyBNQosVg6uvTh8IXnmlHV20QEmYDMZGtRtTruGTM3dQpyS8fGXmU0VgYh249Qe7HXsQRl00gdon3gfOwenP4fQqKN0hc2If7rrL9rEEWLvWPrdRUbm7JaWUUqow0sBQKaUKoJ07oXt3+PbbwM6vXTt9v8CQNAnNrrP7IPG1tM2YkzGEIyxqAOV8/He6pSLcWgFWH4NzwMj99XirYn9InGNPOPwU1GoHElgEXKMGXHcdfPUVnDsHy5bBP/6Ry/tSSimlCqGC9tuxUkopYNAg30FhhQrQoQOMHg0ffgiHDsGuXelHHC3wQSFAwiQwKQB8ndKK5Sm3M642tCrnP9mEOu71tw/Dz5FjQZzOiGe+gxPZG4TGc7J7HZ1UKaVUUaU1hkopVcBs2gSffurebtEi8yihBa5JaHad3Ys59jqu3oBjT47jxvLCU5dlnbRVOehcGT5IsNsj/qzBB9UGwZHJdkfcaCjbDaR4QEXp1g2GDLHrq1fb5rsVK2bvdpRSSqnCrrB/tVBKqQvO+PHu9e7dYfNmeOUV6N0b6tW7AIJCwMRPRLC1hV+ltOab8x14sz6EBzhuzLO1SQsqP0yATRHDIcyJ5s7usnMbBqhmTYh2BjM9e9bWwiqllLow9O3bF8nTOZcuHAX664WIXCQiL4nIbyKSJCJxIvKxiLQLddmUUiov/PADfPCBe3vUqNCVJc+c/ZPzif9N2xx7chxz6gqXZqP5a5My0L2qe/upPypA5ZHuHfHPwPmTAefnOdn9kiWBl0MppQq706dPM336dNq0aUOlSpWIiIigWrVq3HHHHcTGxpKampp2btu2bRER6tSpQ0pKSqa8YmJiEBE2b96ctm/t2rWICCLCnDnef7QTETp16hRQeWvVqpWWn4gQFhZG9erVuemmm3j77bcDysNbOX1Zv349nTt3platWpQoUYKqVasSHR3N448/zq5du7yWyd+ydu3atHsWERo1auTz2ldffXXaefkh5E1JRWQbsNQYMzrD/kbAKqAq7h+GSwB/A24XkaHGmKn5WlillMpjnrWFd98Nfv5fFFqJhyZSnrMAfJlyHbUqteOeqv4SJNpZ6DO07xxXC949bAeh+fwYrLnsX9xc7CVI3QvnDsORqRD1dEBl6tYNnnrKrq9YASdOQNmy2b41pZQqVH777Tc6duzIjh07aNeuHSNGjCAqKorDhw/z2Wef0a9fP7Zt28Zzzz2XLt3u3buZNWsWgwYNytb1YmJi6NmzJ6VKlcpVuS+55BImTZoEwLlz59i/fz/z58+nR48eHDhwgCeffDLt3Dlz5vDqq6/m6DqzZs1i4MCB1KlThz59+nDppZcSFxfH9u3beeutt7jxxhupU6cO06dP5+RJ94+R27dvZ+LEidx1113cfffd6fKsX79+2nrJkiX5+eef2bRpEy1btkx33pYtW/jhhx8oWbIkycnJOSp/thljQroA54G5GfYJsNU59hVwJ3AlcC0wDUgFzgLNAr1OixYtjFJKFWQ//2yMiDF2tkJjvv021CUKvpTkPSZlW4Qx2zFmO6bPplXmZKqfBKtWGVO2rDHh4cYsWJDp8IO/GMMau1yz2ZjzR+em5W1+LWPM2UMBl61pU/dz/9Zb2b41pdQFYtu2baEuQr44ffq0qVevnilWrJhZsmSJ13O++eYb88orr6Rt33TTTaZUqVKmQYMGJioqyhw/fjzd+WPHjjWA2bRpU9q+NWvWGMBER0cbwEycODHTdQDTsWPHgMpds2ZN07Bhw0z74+PjTUREhGnSpEmWeXgrZ0Znz541FSpUMJdddplJTEzMdPzMmTMmISHBa1rXPY8dO9Zn/oBp3769qVy5shkwYECm4wMHDjRRUVGmQ4cOxoZsWQvkvQtsNj7ipYLalLQ90AD4HrjRGPOhMWanMeZrY8yTwHAgHBjoLxMReUhENovI5ri4uLwvtVJK5cKECTYsAbjzTjvlxIXmuz8mECG2tvCLlBt4vO6tlA73cXJiIvTqZavvzp2DgQPh8OF0pzxdE4o7bUq+OQEfnu0NxRvaHedPQsKEgMvmOTqpNidVSl3oXn/9dX799VeGDBmSqVbLpWXLlgwcmP7rdlhYGJMmTSI+Pj5TTaI/9913Hy1atGDKlCkkJCTkquzeVKxYkZIlS1K8ePqBx3LaxzA+Pp5jx47RsmVLypXLPFx28eLFqVSpUo7L68rjgQce4K233kpXK3jmzBneeustHnjgASIiInJ1jewoqIHhDYABRhljUr0cnw78BdzoLxNjzGvGmGhjTHSVKlXyoJhKKRUcO3aAZ9eIMWNCV5a88n/xu2l2bl7a9v6y42hezs8/65Ej4eBB9/bJkzZ69nBpSRhwsXt79J5wzleZ6N5xdBak7AqofJ79DD/5BE6fDiiZUkoVSoud+XkeeuihbKft3LkzN9xwA9OmTeOg599pP0SEyZMnk5iYyIQJgf9o5825c+eIj48nPj6eQ4cO8f333/OPf/yDEydO8PDDD+cqb5dq1apRpkwZ1q9fz6+//hqUPL3p378/x44d47333kvb995773H06FH69++fZ9f1pqAGhtWcR6+zeBljzgE/AZfkW4mUUioPTZxou9EB3HYbZOhqUOglnIU9+yYQIfa3vh/P38i9NW/2nWDjRpg1K/P+WbNg9+50u0bUhNLOf7OfTsE7p+6EUtc7R89CfGD9DOvXtwvYoHD58oCSKaVUobR161bKlStHnTp1sj7ZiylTpnDq1CliYmICTtOuXTvat2/PzJkz+eOPP3J0XYBffvmFKlWqUKVKFapXr06zZs14++23mT17Ng8++GCO8/UkIsTExBAXF0fDhg255pprGDRoEAsXLgw4GA5E06ZNad68OfPmuX84nTt3Li1atKBJkyZBu04gQj74jA+u3pvH/ZyTgHtQGqWUKrR27YI333RvX2i1hcbA6F93MaNEbNq+GhePIyzMx5/ws2fhoYfc7WozHhszJt0TVq04DLoEJv5pt5/+Q7i30WSK7W1jdxxfBJX+DSWvzrKs99wDzz5r1xcvtgMAKaUUwOXPXx7qIvj0+79/z3aa48ePU61ataxP9OG6666ja9eu/Pe//2Xw4MHUrVs3oHRTpkyhRYsWjBkzhgULFuTo2rVq1Uob4dQYw19//UVsbCwDBgwgIiKCfv365SjfjIYMGULdunWZNWsW69evZ9OmTQCEh4fTp08fZsyYQWRkZK6v079/fx5//HH27t0LwOrVq5kxY0au882uglJjeIWI9HYtQGVnv7+pjqtig0OllCrUJk+2XegAbr4Zrr/e//mFzZwD0DJlPMXE3mR8RFsqV2jrO8GLL8KPP7q377rLPdEgwKJFdl4PD/++FCo4P3X+lgSxiTdAmTudowbiRgRUVs9+hh99BPk1EJxSSuW3cuXKceLEiVzlMWnSJIwxjBgR2N9YgGbNmtGjRw8WLlzIj55/6z0kJiZy8ODBdMs51z9KoHTp0rRr1y6tBrJPnz6sWrWKBg0a8NhjjwW1D+Odd97JJ598QmJiIj/++CPTpk3j0ksvZe7cuelGP82N+++/n4iICObPn09sbCzFixenR48eQck7OwpKYHg9MM9j6e3s9zpfoYiEAc2BnNdBK6VUAfDnnxAb696+0GoLfzkFL+3+jd6l3L8KR10U4zvBH3/A2LHu7bJlYcYMGz27GAMZvoRUjIChl7q3x/0BZypNJO3f3KnlcGpNluVt0gQudyoFTpyAVauyTKKUUoVSo0aNOH78eNpcfDlx1VVX0a9fP5YuXcrGjRsDTjd+/HiKFSvG8OHDvR4fNGgQF110UbrFVZvmS7Fixbj11ls5depUtsoSqPDwcBo3bswTTzzBpk2bKF++PPPnz08XsOZUxYoV6dq1K7GxscTGxtK1a1cqZpiiKT8UhKak8/0c8zVW3d+ASsA3wS+OUkrln+ees60jwdYUtm0b0uIE1Znz0GM7DCk1Ia228FypmwmPvMl7AmPg0UfTj/oyYQLUqGGX9u3dkdqnn8K6dXCTO6/Ha8CL++DwWdh3BmYlNOKJ8r0hMdaeEPcURH4NfkanE7HNSadMsdtLltgRYpUqaL78Et54w75f23n9GV0FW06aaxZk3bp1Y/369bz++utMnDgx6wQ+jBs3jkWLFjF8+HDaBvhPrHbt2gwYMIAXX3wxbcJ3T8OGDaNnz57p9lWvXj3LfM86/1BzWxOalaioKC6//HK+/fZb4uPjc9Uk16V///688847ADmedzG3Ql5jaIzp52d5yUeyfcBdgK/jSilV4P31F7z+unv76af9xiyFzshdcCLpN3qVeiNtX3iVcb4TLF0KH3/s3o6OtlNUuHjWGgIMH56uH2KZYjCqpvvwxD/hVIVxICXsjuRv4MTSLMvt2Zx02TJISckyiVL55vx5GD8ebrwRZs+GTp1sywOlsuvBBx+kXr16PP/88yxbtszrOVu2bGHmzJl+87n44osZNGgQ69at45NPPgn4+qNHj6ZcuXIMGzYs07EGDRqkNRV1LSVLlvSbX3JyMsudUcOaN28ecDl8OX36NOvWrfN6bOfOnWzbto2oqCiCNfNBu3btePbZZxk/fjy33nprUPLMroJQY5htxpgfgB+yPFEppQqw//wHzpyx69dcYyvELhQrjsDUfRBb/tm02kIib4XINt4THD8Ojz/u3g4Ls996wz0ajjRvDt27u+f12LgR3nsv3QgxD18Mz++FvWcg7ixMP3wZoyr+C468YE+IHwllu4D4/vcXHQ2XXWa/bB87BmvW2JFilQq1uDg7teeKFe59Z87YQPG110JXLlU4RUZG8tFHH9GxY0e6du1Khw4daN++PZUrVyYuLo41a9awYsUKr4FbRsOHD+e1115LG5wlEFFRUQwdOpQxOehDkZiYyJvOIGSuwWfefPNNdu3axT//+U+uvPLKgPKZO3duWjDpqUWLFrRs2ZK2bdvSqFEjbr/9dq688kqMMfzyyy8sWLCA5ORkXnnlFcLCglPPFhYWxujRo4OSV04VysBQKaUKu8OHbdzjMmbMhVNbeDgF+myHK8N30LOkx3CrUX5qC0ePtlWoLoMG2UAwo2eftcOFpjpT3I4cCZ07QzH776xEGIytBQ86U0795094tOUIKhx7Hc4nQsoOSJwLFXzP2yViaw2ndfhVoQAAIABJREFUTbPbixdrYKhC78sv4e9/h/37Mx+bN89WoF9ecAfNVAXUFVdcwXfffcfs2bNZsmQJEyZM4OTJk1SqVIno6Gjmz5/P/fffn2U+5cuXZ9SoUQwePDhb1x88eDAzZ87kwIED2Uq3b98+evXqlbYdGRlJgwYNmDlzZrbmMZzlbVok4OGHH6Z9+/bMnTuXlStX8sEHH3DgwAGSk5OpUqUKN910E4899hg33+xn2qVCSIy34cAvQNHR0Wbz5s2hLoZSSgH2S9xzz9n1Zs1gy5YLIzA0Bu78CT4+AgvK96JXKScwjGwPl630nmjTJmjVyt0s9NJLYds2KFPG+/mPPgqeTZvmzAGPeatSz0ODTbAzyW6PuAwmlp8EcSPtjmIXQZ3fIMz3EONffeUeHTYqCg4cSIs9lcpX58/DCy/Y8ZY8x7gYMcK+T10t3Xr3hvn+Rm1QAdu+fTv1XZOaKlWIBPLeFZEtxphob8dC3scwJ0RkgojMFZH/hrosSimVXQkJ8Mor7u3Roy+MoBDglf02KKwb/iv3l1zkPuCrb2FqauY5C2fM8B0Ugq1e9Zw3KiYGkpLSNouFwTO13Idf3AeHSg+yASFA6gE4+qLf+7j2Wrj4YrseHw/r1/s9Xak8ceQIdO0Kw4a5g8JKlWxX3IkTbRNSlzffhO3bQ1NOpdSFoVAGhsDdQF9nUUqpQmX6dDh1yq43amS/+F0IfjoJrkH7ni7zDOFy3m6Uvg1Ktfae6KWX4Pvv3dtdu0KXLv4vVL06eDZX2r/fBpMe7qsKTUrb9dPnYeLeSIiKcZ+QMAXO+Z7nKiws/eT2S5b4L5JSwfbNN7Y19Ycfuve1bg3ffQd33GG3b7gBbr/drp8/b38jUUqpnCqsgeF72GkuFmR1olJKFSTHjtlYyGX0aBuEFHZJ56DHNjhj4Krw7fQo+Zb7oGdA5unPP+1QrC5lyqR/cvwZOhQqV3ZvT5oER4+mbYYJjK/tPvzqX/Bnif5QvK7dcT4REib5vYTn6KRLl9ov3krlNWPsx+CGG+y0ni5Dhthmo5ddlv78Z55xr7/7LviYL1wppbJUKL+OGGNGuqa0CHVZlFIqO156yQ7ACVCvnp2D7EIw9Hf42Zl+cFzZZwgTp2lo6duh1LWZExgD//qXu+oU7MAyl16a7rR9ifvoNL8Tbee0Zeuhre4D5crZqNrl2LFM01l0qgzXlrPrKQae+aMYRHnM1XX0ZTjre5z/Nm3ANQr5wYO2P5dSeSkxEe6914695JrftHx5O/ju889DRETmNC1bpq9k9/ytRSmlskMHn1FKqXxy/DjUquWu2FqwwA49X9h9GA+dnZitfvg2fq7SCMH531JzI5S6JnOiDNNM0Ly5nX7CY4SXM6lnuO+t/2fvvKOrKNo4/Gx6JQkJhBY6SA0gICA2OtJRQClSFUUEQUTpXYoI0kVBiqAUARVQkK58VJXeOwk9ISSk1/n+mL1374U0SEISmOecnNyZnZmdTW5u9t23/DqYDcKSeUuysetGHO10XcLYWGldm9wqTk5w/jwUKWJeY8c9aKCLG9kCp2oKygbVlpqGAB7doeDiFK/t/fcNGYCPP5ZhwJmJEBARIfNO796VOWWm18n1OTjAlCnw4ouZuw9F9nP4sDQKL1poqFevLr2AJUsmM0HEQ/Q+cPTn2ElPqlQxDh08KA1GxeOhis8ocisZLT6jaqwpFArFE2LePMMoLFUKOnbM3v1kBjdjoedZo/2d9zjDKHRtlrxRGB4O/foZbRsbaX09UPZz8l+TrbyEl0IuMWvvLAa/Mlh2ODrKOLpu3WQ7JgbGjpVVSnXqe0EDT9geConA6KsaK4pNgUC9xHjYD5B3EDhWSvb62rUzDMN166SERUqFguLi0mfcPdhn8gyll8aNYcsWZRw+LQghpWsGDDB0TUE61L/6Sr7NH56UCIGvQ9R2cKyCf+WDvPWWA6tWycOjRsGmTU9k+wqF4ikix3gMNU17FegCFAFuAmuEEH+kMv5zoIkQon561lceQ4VCkZ1ERkpvYXCwbC9cCL16ZeuWMkySgKbHYKtu7L7mfJIdHpUtvIUHwTkZt8WAATDToipo//7WbWDT2U18tOGjh6baaras67KOSr66IZeYCFWrwgndgLSxgZMnoVw585wD96H2IWONIzWgyr3XIVIXNXZrCUXWJ3uN8fHg62sY9H37yhv55Ay+iIjkf05Zgbs7bNsGLyRjdytyD+Hh0iu9wiIl191dfj506JDKxJDZcKe/0S64nDM3O1OxopELu3u3zFNUPDrKY6jIrWTUY5gjDENN08YAI01N/bsAtgHvCCHuJDNnMdBVCGGbnnMow1ChUGQn06fL4hEgi0ecPy/DAnMz0wKNKqQacLNYB3xjf5Ydri3Ab8PDk/77T1ozprvXwoWlZmGePOYhV0Ov0uqHVkTESUurcZnGhEWHceDaAQAq5K/Aus7rsLfVE642boSWLY1zvPHGQ2VEWx+H9XoR0pbesL7MUbhSDUxGbNHd4JL8XXTPnlJAPKtwdpZ1dExfefNat019NjZyL3f0/4geHrBjh4zCVeQ+jh+XoaNnLTzu/v7w889QtmwqE+MD4FIFEBb5uU41odgBunXX+EEvy/faa7BzZ1bs/OlHGYaK3EquNwx1T+FOZJTPEuAwUBboBngAV4EGQohLD8xThqFCocgVREfLHKFbt2R73jzo0yd795RRDoVLL1y8/i/k6yLHGZDgbwwo/i84VbeelJAghewPWbjv1q2Dtm3NzdiEWNr/1J6Td04C4Ofhx/p31hMSHUKzpc2ITZCxdp+89Al9a/eVk4SAV1+VLhIT+/ZJMUKdYxFQ9V+zGcjealAnsgvc/1F2ONeVxmEycaI7d0L9dMSm2NpKAy45wy41g8/ZOe21TZw4IW/47+pGrpeX3J9lfpki57N4sfQ+W8hv8t570nGe6vtBCLjWAiKTCagqtpeLN+pQrpz8UwPYvj19712FNcowVORWnoYcw4+Q/6s7CSF+NnVqmjYJ+BGoD/ytaVoDIcTZFNZQKBSKHMvChYZRWLiw9PrkZiJ1aQqTUVjTHfo7jQVTKKVbq4eNQoC5c62NwlatHhJx/GLnF2aj0MHWgdktZ5PHKQ95nPIwsO5AJv8lK4/O2TeHJmWaUNq7tDTmHqzIMmSItJh0Q8/fDd7ODyt0b9vwy7Cjwni4vxqIh+g9ELEB3Fs9tO169WDlSlmV1NMzZWMvT56slx6pVEmGkNavL8Nb792Dhg3lpVZKPk1SkYOIipIG4ZIlRp+LC8yfn85CVOErLYxCDZxqQcx+2QyZQalSdejZ08iLHTEC9uxJOS9WoVAoLMkJHsNrwF0hxEPPOzVNswW+BXoCt4GGQoiT+jHlMVQoFDme2FhZaOb6ddmeOVOm1OVmep+FBTfla1cbOOV/lKK3qhoDih8Cp2rWk65dg/LljUQ8V1cZQmohyrbxzEY+3vixuT2mwRjeqWbcLSckJdD+p/YcuyWF2qoVqsaqt1dha6P/G2jTBn77zTjnH3/A66+bm+ejoPxBGZ4CsK0KNIj7GO7p2okOFaDEMdDS9W8lW/nvP2jQQMobAOTPLzXuLFIrFTmMM2dk6OgJC9WVChVk6GiFCulYICEYLpeHRD1R2bMvePaGK6bbJ1sodZnAW36ULi2LIQH8/js0a5aZV/L0ozyGitxKRj2GOUHHMB9wKrkDQohEIcS7wGzAF9ihaZp/cmMVCoUiJ7JkiWEU+vrKcLHczNogwygEmFMGikaMNTrcWj9sFIK0hi2rs4wbZ2UUXr53meFbhpvbzco2o0vVLlZL2NnYMbnJZOxtZG7h4RuHWXZkmTFg4kRrl93QoVaq9GVcoEdB4/CwSyDyDgcbN9kRd0pWKc0FVK8Of/4pC5WAzDusX1/mripyHj/9BDVqWBuF77wjZSXSZRQC3BlkGIV2RSDfRHDyB5fX9AGJcG8efn6yoI2JkSNlBKpCoVCkRU4wDGMA19QGCCE+Br5GGpHbNU1L5q5DoVAochbx8daa659++mj5ZDmNwBh4zyKg/6180M3zCET8YnT6jHl44m+/Sd1CE1WrWrlNY+Jj6Le+n7nYTFHPokxsMhEtmfi35/I9R59aRoLmV39/RWBooGxUqGBIVwAcPWpd7hEYVQwc9GUPhsOGsPyQd7AxIHgUJEWTG6hVS0oSuOr/QW/elMbhpUupz1M8OWJi4IMPoHNnWZkYpNzmwoWwdKnxu0uTyC1w3+KhRYFvwFYv2ORleNkJ/RaSohg61PisOXQIfv01w5eiUACgaRrdu3fP7m0osoicYBieA5JJRrFGCDEI+ArwRlYrTe8zNoVCocgWli+HK1fka29veYOYW0kU8M5puKcXtSjqCPPLgnbX0lvYFpyqWk+MiLDWLNQ0KdpmoVk4fud4TgedBmRe4ZyWc3B3dE9xL31q96GsjyzbGJ0QzfCtwzGnRYwday38NmKElTicnxP0KWRx+DIkeX0CtvllR8I1uDc3jZ9GzqFuXRkqaDICrl2TOZFXr2bvvhRw4QLUqSPf7ibKlIEDB6RUTbrz/pIi4ZaFC9D9LXBrYbTdWoJ9CX3sPbi/nIIFZS6jiZEjpbKLQvEgu3btQtM0qy8nJydKlixJjx49OH36dJprFC9enErpSHKOiYlh9uzZ1KxZEx8fH5ydnSlatChNmzZlypQpKe4npa/ixYsDsGTJEnPfV199ley5Dx8+bB6jDNuUyQmG4d9AAU3T0pTqFUJ8BnwJeAHJxsYqFApFTiAhQUY2mvjkE3Bzy779ZJQpAfCXns9mA/xYHjwTD0OEhSsiOW/h6NEQGGi0+/a1Et9bf3o9K4+tNLdH1htJRd+Kqe7FwdaByU0mY6PJf2F7ru5hzYk18qCfn7UheuWK9Z05MLSYzI0EOB4Jq4LdwGeUMeDuREgMTXUPOYlXX4UNG6QnCiAgQBqH165l776eZdauleG+R44YfW+9Bf/+KyUpHomgURB/Rb628QJfqfk5/zoU2wcjLtuCl8V7PmQWCMFnnxmfOSdPwurVj305imeAjh07smzZMpYtW8bs2bNp3rw5K1eupFatWly1eNIUHR3NggULHnn9hIQEGjRoQP/+/cmfPz/Dhw9n1qxZdOnShYSEBCZNmgRA+fLlzfswfb388ssAfP3111b9M2bMsDqHk5MTi1PQFlq0aBFOpg9JRcoIIbL1C1l1NAlY/QhzJuhzEtM7p3r16kKhUCieFMuWCSEze4Tw9BQiLCy7d/T47A8TwnanEOhfoy7pBwJbCXEa+XXtzYcnHjokhI2N8YMoVEiI0FDz4QvBF0SlGZVEyaklRcmpJUX/Df1FUlJSuvf1xc4vzHOrzKoiboXfkgfu3hXCw8M4b758Qty/bzV3+EXjekrvFyIuIVaICyWN67kz9BF+QjmDzZuFcHAwLrt0aSGuX8/uXT1bxMYK0b+/8TsA+TuZO1eIR3hrG0QdFOK0jfG+vLdYCCHE7ntCaDuN9/DBkFAhzroZ4yK2CiGEGDHC2EfZskLEx2fShT7lnDp1Kru38MTYuXOnAMTUqVMfOjZz5kwBiOnTp6e6RrFixUTFihVTHbNmzRoBiAEDBiR7/ObNmynO7datmwDE5cuXkz2+ePFiAYiOHTsKQBw4cMDqeExMjMibN6/o1KmTAES3bt1S3WtuJj3vXeBfkYK9lFM8ho2Ab9I7QQgxAmiNrFaqUCgUOYrERPjiC6M9YICVfnuuIjwBOp0yKnnWyQMjiwEx/0HEemOg92jriYmJ0Lu3VfEXZs2SquxAdHw0H234iKj4KACKexVnQqMJyeYVpsTAugMp6ikL2ITHhjNq2yj58DBvXvj8c2NgUBBMm2Y191M/8NSjWS9Ew5LbDpDP4pcWMgPib6R7LzmBJk2kp8pe1ubhwgWZc3j7dvbu61nhyhV4+WX5NjdRooSUOfnww8eQjBDxcOtd5HNwwKUBeHQjIgG6nTE0OQEmXvcAjx5GR4j0pAwaJCVWAM6dk+HtCkV6KVRIxt07ODiY+x43FPO8XhmrQYMGyR4vUKDAo2/wAVq2bImPj89DXsPffvuNkJAQevTokcJMhYlsNwyFEAlCiO1CiJ2POG+DEGJpVu1LoVAoHpe1a2VpepBVI3OzPMVH5+FSjHydx1aGkNrZAEFjjEHu7cGpsvXEb76RcXMmmjeHN94wN8ftGMe54HMAONo5pplXmBzO9s5MajzJ3N52YRt/nNU13j7+GApalCCdNs3KQvK0h8/8jMPjrkKMSwdw1GubiWiwzJ/MJbRoIUMGTSmcZ89KWYugoOzd19PO+vVQrZqsMmqiTRtZ+KV6mlUUUiDkK4iV0ixozlDgW9A0Bl8y/iZN/BoMFxz7Abr1Gfk7xJ3H01MahybGjjVkLBQKS6KioggODiY4OJjAwEA2bdrE8OHD8fHx4c0338zw+qVKlQJg+fLlREdnTYEve3t7unTpwsqVK4mJMf5IFi1aRLVq1ahatWoqsxWQMwTuFQqF4qkhKQkmTDDa/fqBl1f27ScjTA2AHyy8TfPLQglnIPofiNyo92rg84C38Pp1GDbMaLu4wJw5ZpfJLyd/YfVxI+FpVP1RlM//eJphtYvWpmOVjqw4KquPjtk+hjpF65DXJa/MbzRV/ImIkL+Y2bPNc/sXgRnX4E48XIuF+TdtGJB/MgQ2kQNCvwevT8DxucfaW3bRpo0sxvr229Jxe/IkNGwIO3bIIkiKzCM+HoYPh6lTjT47O9n++OMMCMvHnYNgiwcTPuPAoRR/hsB8C0e2nyME6rWVvrhVhsWuzaRRCHBvNvjO4uOPYcYMuHtXejUXLcrdhbCyjQEDrJNGcxJVq8pfcgYYPXo0o0dbf5ZXqFCB3bt3Z4o3r3Xr1jz//POsWrWKzZs389JLL/HCCy/w4osv8uqrr2JvCnXIID179mTGjBmsW7eOTp06ce3aNbZu3crMmTMzZf2nHWUYKhQKRSayfj0cPy5fu7rCwIHZu5/HQQgYfhkmBRh9XX2ho6/eCB5jHHDvAI4PFIv5+GMIDzfaY8eCXj3ufPB5Rm4daT7Uunxr3qr8Vob2+/krn7Pz4k5uRdwiJDqEL3Z9wbRm06BnT5g+XcbQgSxCM3AglCwJgKstDC8GH1+QhycGwLsFGuHm0gCitgOJEDwcCq/J0P6yg3bt4IcfpFZeUhIcOwaNG8O2bbn3QUVO49o1WVBm716jz89Pemxr187AwiIJbvYGoVt8js9D3gHci4deZ4xhbX1gsB+8eFi2l9+GKf4DyG8yDMMWg8943N09GDIEBuuqLBMmQPfuRrEiRTo5cgT++iu7d5Fl9O7dm/bt2wOyeuipU6eYNm0azZo1Y+fOnRQrVixD6zs4OPDXX38xc+ZMVq9ezR9//MHvv8v3av78+Zk+fTqdO3fO8HVUrlyZGjVqsHjxYjp16sTSpUuxt7enc+fOJKrSvGmS7aGkCoVC8bQgBIwfb7T79AEfn+zbz+OQJKDveWuj8BUPmFtGb0QfgEg9XBPNuponwMaNMpbWhL+/NBSBqLgo+m3oR3SCDCMqmbck4xuNf6S8wuRwd3RnQiPDTfvrqV/ZeWmnTLazTPaMj5d1+y14v5D0ugAExcPMGxrksxCfDF8rrzkX0qkTLF5seK0OHZJ5iGFh2buvp4HNm2XoqKVR2KwZHD6cQaMQIOx7iDYZILZQcCFodnx8Aa7rYaD57KUHv46H/PsESBAwKbgBOOgPapIiIGwRIHMcTU6f69cfKtSrUFCmTBkaNmxIw4YNadGiBZ999hnr16/n8uXLfG6Zs50B3NzcGD58OEePHiU0NJStW7fSt29f7t27R9euXdmzZ0+mnKdHjx7s2LGDq1evsmTJElq3bo2XeiKWLpTHUKFQKDKJP/6QN98gn8Z/+mn27udRiU+SRS1W3DH6WnjD6grgbKt3WIa3ub8FjhaSspGR1uJpJs1CPURozPYxnL8rCxA42Tkxp+UcXB3Sq/CdOvVK1aN1+db8dvo3AEZsHcHm7ptxf/NNqFkT/vlHDvzpJ+k60XNNHG1gdHF496w8PDUAPixUAy/3DhCuh7sGDQG/HRmIC8w+unaV9vC778r2P/9IA2bzZpn/qng0YmNh6FD4+mujz9ZWPn8YPBhsMvq4PeEm3BlstPN+Ck7V+CUIlj0Q1p1frwcypCj8rUcpfHdTY3zF/rgF6bqH92aDV39cXGwZNszId544Ub4nXDPnz+/ZICfnp2XR3mrVqoWHhwc7duzI9LXz5MljNkSrVKlC7969Wbx4MXXr1s3w2p06dWLQoEG89957XLhwgTlz5mTCjp8NlGGoUCgUmcCD3sL33wdf35TH5zSiEqHDSfg9xOjrlB+WlAN7081u9H6I3KQ3kvEWjhkjRfRM9Oljdp+sObGGtScNT+KYBmN4Ll/m5u6NqDeC3Vd2ExIdwq3wW3z595eMbzQeJk+WFVhMDB0KmzaZm918pU7j+WgIS4SpgTCxyAQIXwckQNQuiPwT3Jpm6n6fFL16SeOwTx/Z3rtX1gLatEkZBo/C6dPQsSMcPWr0FSwIK1fCK69k0klu94Mk3aVrXwp8RnMnDt4/Zwzp4gtv5DPaTfOCvysci4SoJJh5vwvDbYZCUgjEX4aIDeDeht69Ze5jYCDcuQNz58Jnn2XSvp8FMpjDl1tJSEggNjY2S89RW/8/cf369UxZz9PTk7Zt27JixQr8/Pxo1KhRpqz7LKBCSRUKhSIT2LYNDugRhw4ORj5PbiAsAZoeszYKPywEy8pbGIVgnVuYpyM4WhSMOXrU2o1SoIB0SwBng84yeptR1KBthba0q9Qucy8CyOuSl9ENjPP8dPQn9gfsl5oNjRsbAzdvhp1GIWw7GxhX3Dg88xrcEmXA8z2jM2iIzP3KpXzwAVjWXti9G1q2hKio7NtTbkEI+O47WV3U0ihs3lymnWWaURj+iwxdNlFgAUJz5v1zMswZoLADzC5tPU3TpNfQxPTrLsR59DY67slfvKOjdST1lClw/34m7V3xVLJ161YiIyOp/tildQ2OHDnCzZs3kz3266+/ArLYTWYxZMgQRo8ezZw5c7DJsCv/2UF5DBUKhSITsPQW9uoFhQtn314ehaA4aRQeijD6hheF8SUeiJyM3ie9ZgDYgLeFtzAxUbpILRP7Z84EDw8i4yLpt6EfMQmydHjpvKUZ13BchvMKU6L5c83ZcHoD2y5uA2DYlmH83u13nCdPhi1bjIFDhsD+/eaL7JBf5lWavC6TAmBmiVEQthREFMQehfsrwCPjxRGyi/79pefQFOK8cye0bQu//aYKkaTE3bvw3nvwyy9Gn6OjVD95LG3ClEgMhdsWYdgevcC1HstvSSkKE4vKSamVB2mfTxaMuhwDIQmwLPZDejEVSJQe75ij4FSF7t2lA/3SJQgJkU6wUaMeXk/x7HHo0CGW60KXsbGxnDx5ku+++w57e3smWJbaToGgoKAUx/Xo0YNt27YxbNgwGjduTN26dSlQoABhYWHs2rWL9evXU7BgQT755JNMux5/f3/8/f0zbb1nBWUYKhQKRQb56y/pgQFZqj6T8vSznMAYaHQUzlpISn1VCgb5JTM4yKKMeZ5O1hIO335ruEsBXn8d2rdHCMGobaO4GHIRAGc7Z2a3mo2Lg0vmXogFmqYxrtE4Dlw7QHhsOFdDrzJjzwyGvjZUxgGukLIWHDwI69aBrs9lo8GEEtDqhDw8/wYM8itA0byfwF39Zid4BLi3AxvHLNt/VjNokDQOhw6V7S1b5I9g3Tpp8CgMdu6UVV0to9sqVpRvocqVU573WAQNkfmFALa+kH8qgTHQ77wx5INC0Dhv8tPtbGSF0g/18WOv+9Hd701sI/Q82XszoeAi7O2liku3brJ72jT46CPIm8K6imeHFStWsEL/fLSxscHb25vGjRszdOhQatasmeb8O3fuMPKB4l4mGjZsSLt27YiNjWXbtm3MmzePO3fuYGdnR/HixRk4cCCDBw/OFFkMRcbQhBDZvYcnQo0aNcS/lmLLCoVCkUk0bAjbt8vXvXrBwoXZu5/0cC4KGh41NNBsgAXPQc+CyQyO2gMBL2EeWfI0OJSVzZs3oVw5IybN2VkK55Uowerjqxn651DzMl82/ZI3K2VcKDk9WJ7bRrNhbae1+Ee5yr0mJMhBzz0HJ06Y1eCFkKX/9+uX0qsALCxzHy6VhMS7stPnC/AZ9uDpch3jxkkDwUSrVvDzzzIM+lknPl7+bCZPlu8JE337yhw9Z+dMPmHU3xDwqtEu9DPCvR1NjsHWe7KrpBMcrQFuqTzOj06E4vulLifA76X30SziRdnQHKFUINjlIzERKlWCM7r0xbBh1sV7FXD69GnKl388bVWFIjtJz3tX07T/hBA1kjumgm4VCoUiA+zdaxiFtraGJyYnczgcXjpsGIX2GqyqkIJRCBBs6S3sYhiFIEWfLROVRo+GEiU4E3SGMdvHmLvbVWr3xIxCgPaV2vNiUXlTnCSS+PzPz4kr7idDXk2cPSv1HHQ0Db4oYRxecgvOxeYB7+FGZ/AIiNiY1dvPckaOlMLsJtavl/IWJpv5WeXCBahbFyZNMoxCb2/585kzJwuMwqQYuGWRy+rWGtzfZP4NwyjUgKXlUjcKQVYOHlDEaH96ozbCSff0iFgIlRoVtrayTpSJmTNlMRqFQqFQhqFCoVBkAMvcws6doVSp7NtLevhfKLx2xChm4WIDGytDu/wpTIjarYu9A9iCzwjj2KZNUs3bRKVK8MknRMRF8NH6j4hNkJZnWZ+yjGkwJrMvJVU0TWNi44k428k7+XPB55h/YL60iCxLcY4ebVWBpb4XNPCUrxOB0VcAr77grHteEHCjI8SeeBKXkWVomnzvWhZJWrtWhk4+ixrQQsAPP0htQpOyCchogGPHZKGeLOHuBIjTS47a5AHfuVyM0fj0ojFkkB+dnAJ9AAAgAElEQVS85Jm+5foUAnddWuZ0lMYhu4+Ng6HzQEghxPbtjXDYyEhZiEahUCiUYahQKBSPyT//yAKXIG+0h+XwCMNNd6HxMbiv3/h72sG2KinnLQHJeAt1pfuoKFl9w5LvvkPY2TFiywgu37sMgIu9C3NazsHZPrNdLWnj5+nHoJcHmdvz9s/jrE0oWBY4uHkTZs2ymvdFSeP1yjtwNNIBCv8CdsVkZ1IEXGsJCbnbzaJp0iAYMMDoW7kSevR4tozDsDD5UKdbN4jQizDZ28uw0T//hEKFsujEMcfgroVFlm8KiXaF6XZaFkACqOAC44unf0lPe2kcmvj4dnuErR4KkHAT7v8MSL1Fy4da8+bBjRuPdxkKheLpQRmGCoVC8ZhYFmB76y2ZspZTWXVHFlaJ1m84fe3hr6pQxyOVSeHrIcok62ALPhaFBcaNgytXjPb770OdOqw4toINZzaYu8c3Gk8p7+xzo3at1pVqhaoBEJ8Uz9A/h5L4yUDw8TEGTZ4sSzTq1MoDrbyNwyMvA3b5ocgGsHGTnfFX4PobkJS1+l5ZjabB9OnWNv6yZdC7NyTlXnWOdLN3r9QGN9UkAihbVhas/fTTTBCsTwmRCLfeBfTYXeeXwLM30wNhjx6ZbafBD+XByfbRlh5QBBz0aql7wh244mzxy7030xwj26oV1NCzjGJizOoyCoXiGUYZhgqFQvEYHD0q845MWOZr5TS+uwEdT0GCnjNV3An+Vw383VKZFLkNbrxltD26goNu4B0/LssZmvD1hUmTOHXnFON3GG6IDpU70KZCm8y7kMfA1saWSY0n4WArq6ocvXWUxefXwgiLkNiwMGkcWjC+hMztAthwF/aFAU6VodAKzEei98Ct3tYVSnIhmgazZ0tZBhOLFkljMZdfWookJMhnG6+8Yv18o1cv+O8/eP75LN7AvdkQo8esag5QYAEno2wYcdkYMqIYVHd/9KULOkJ3i+KOQ0Pel8VnQJ4zZr88rWbtNfzuO7h69dHPp1Aonh6UYahQKBSPgaW38I03ZHpdTmRKALx/Dkz39+VdpFFYOjXFiMgdMlRSSO1B7IqCj37BSUnSnWRZpWTGDMJd7Pho/UfEJcocpnL5yjG6/mhyAmV8ytC3tqER9/Wer7nyVlMoXtwYNGsWBAaam/5u8LZF3uVw0w27WwvIN9U4cP8HCLFo51JsbGD+fOje3ej79lupffi0GYdXr0K9ejK91BQy6+kp02UXLgS31B6YZAZxVyDI4kmS90ji7cvR9TTE6T/r6m4wrGiys9PFYD/jBm9VSD7uOlvob4bMML9s0kQW2wFZjdXSUFQoFM8eyjBUKBSKR+TkSVizxmhbOp9yCkLAkIsw5JLRV9Md/q4KhVPTq4v6C661sDAK/aDoTrDXE5cWLJBxdiYaN0Z06MCwLcO4GirdDa72rsxpOQcn+5yjmv7+C+9TPp8s4R2TEMOwv8aSNHaMMSA21rpUIzC2OJii+HaGwna9SiR5PwGPnsbAoCEQ/lvWbPwJYmMjDaPOFjbEnDlS+/BpMQ5Xr4YqVeB//zP6Xn5ZRgC0b/8ENiAE3P4AhF7wyLESeH/GF1fhkJ7f6KiHkNpn4A6ttAu0y2e0v4ywKEITvhbi5UMQTbN+yLVkiazMqlAonk1S/NjRNO1SJn1dTOkcCoVCkRux1Pxq2VJWMsxJJAr44BxMMRxg1POE7VXAJzWduqjdENgMhK54b1cYiu4AB70ay61b8PnnxngnJ5g3jx+P/sQfZ/8wd09oPIESeS10H3IA9rb2TG46GVtNmnoHAg+wqpKttVL5kiVw6pS5WcbFWsJj2CXdQNI0KPANOL+iHxFwozPEHM3y68hqbG3lj6FDB6Pv66+lDEtuNg4jIqBnT5kLHBYm+2xtpYds504omgHv3CNx/0eI/FNvaFBgIf+GOzDBIoTzi5JQwTXZ2dbcvAnffCOfVCXD5xbX9NUdf6IdX9NbiXBvnvnYa69Bgwb6kUQYOzad1/KU86zofCueHjLjPZva86jimfilUCgUTwXnzsGqVUZ75MiUx2YHcUnQ+RR8d9Poa+UNf1QG99R00KL2QODrhifDrqD0FDqUNsYMHGjcVQOMGsVx1yi+2GVYyh2rdKRV+VaZczGZTCXfSrxb811ze/L/phIy0kKvISnpoWTRkcWMQh4Hw2HpLf2A5gCF14K9bgCLSL1S6S1yO3Z2sHy5DJE2MWWKDL3Mjfz7r8wZtJCspHhx2L1bevttH7G4y2OTEAR3LErAevUn2qEWXc9IaRSAlz2stQhT5PJl8PeXiaC1a1s90DDxvDs09pKvk4AlcRbnDv0WkgyZFssQ0h9/THa5Zwo7OzsSnnVRT0WuIyEhATu7NARP0yCtQIU1QIkMfK3N0O4UCoUihzFxolGtsUkTqFkze/djSVQitDkBq4KMvnd8YW3FNCobRu+Da02lcQNgWwD8dhrSFCDr9q9cabQrViT8o97039DfnFdYIX8FRtbLYZbyA/Sv058SXtKYi4iL4DObXYhXXjEG/Por7Ntnbvo5wYeFjcM9zsKoy5AkADsfKLJR6s8BJATCtbZStDyXY28vK3Va6veNH5+7ctCSkuDLL6FOHTh/3ujv3BmOHJH9T5Q7AyHxrnxtVxTyTWDkZTit22euNrCkHNhqKS8ByBKi7dpBcLBsR0TIEqrJMMTCazjoVgsS7PQHGUn34P5y87E6daBZM/laiIeiqp85nJyciDBplygUuYTw8HCcnDKWwpGWYRghhLj6uF+A+qtSKBRPDZcuSU+KiZzkLQyNhybHYJOhukC/wvJG0y61T/roAxDYRGrzAdj6yvBRRwvtjago6NPHapqYP58hO0YREBYAgJuDG7NbzsbRLrUExuzHyd6JyU2MCqQ7L+/if31aWA8aMsQqbnJEMShl8b92/FVofUL+zHGsAIVWYv53GrNfyhA8BWFoDg7w88/QtKnRN2pU7hBDv3EDGjeWkc8mx4+7u5TiWL4cPFKTackKIjbJMFITBebz9303pl8zuqaVhpLpkfvs3x8OHbLu27QJtm59aOhrnjK3GCBa2LJZ9DMOhsyyep+OG2cc+vlnaTw/q+TLl4+goCCioqJUSKkixyOEICoqiuDgYPLly5f2hFTQUnrDa5r2C7BdCDHnsRfXtH5AfSFE28ddI7OoUaOG+Pfff7N7GwqFIhfTu7esvQKyquGOHdm7HxN34qRReMTiUdyoYjCmuEyHS5HofyCwISTpwmm2+aDoLmnsWDJsGEyaZLTfe4+lH9Rl3A7jTnJWi1k0L9c8o5fyxBizbQzLjiwDwMvZiz2bfXHcaORJ8vvvhgsFuBsvJT+23jOGlHGGXyvp+WAhM63DBH2+AJ9hWXwVT4boaKl5t22b0Ve1qvVXlSqysmdOYP16mU94967RV6uWDJEslR2SmkkRcKkiJMiHKOTpTHj+5VT5Fy7rzuUmXrDJP42/V5AJoD16JHtI+PujHTr0UGzsuiB4U09DLGIXRkC+ImhC/7Dw2wquDc1j33gDfvlFvm7Z0lqS51kjLCyMu3fvEhubu7VKFc8Gjo6OeHt745GOp16apv0nhKiR7LFn5UmIMgwVCkVGCAiA0qVlSXeQRmG9etm7J4CAGGh0FM5FG31fl4IBfmlMjPkPAhpCUqhs2/rInELHB3Q3Tp6Ud/4mt0v+/JzcuYY3N79HfJL8YXSp2oWxDXNXxYqIuAheX/w6N8JvANDTpQ7D+60w4oQrV4bDh61ushOSYNhlmGpR1MfNFpaVgzY+erXJ0O+Mg4XXgrtFol4uJioKmjeHXbtSHlOsmDQQTYZi1aoyly/LROIfIDpaRlTOM+qqoGnyucbo0TI8Nlu4PUAKywPYekOJ03xwMR/f6nnAnnZwomYa1YIBjh5F1K6NFiOtySQNjhdxpEqgheGyeLG15ggy7LnCQTirf0b8U6Q/NRJmy4Zrc/DbaB57/Lj83ZluDffvl0a1QqF4elCGIcowVCgUGaNvX+OGs25dWbgizaf7WcyZSGh0DK7p94U2wPfPQfeCqU6DmMMQ0EDmGYG8WfXbAU7+1uOSkqQC+J495q6oRd/xevxyrt2XMXAVfSvyc8efc3wIaXL8fflveqw1vC9/HyhD4TV/GgN++AHeeeeheavuQM8zEJVk9I0oBmOLxWNzrTFE7ZKdmgsU2w1OWa2W/mSIiJA2x9pHqB7g7i4NDUuDsVIlcE5PyOQjcOwYdOxoXTSlSBEZNvrqq5l7rkci+gBcrYNZSbTgMjYndOH148aQ5eWhs28a64SFQY0aVloSsxt6cqldQyZ9tBanBLl+UsGC2Fy4AC7WQqWLbkKvs/J1bcfz7PV6Ds20p5LnrPKJO3WS+aUgw3H//BOFQvEUkZphmJpcRSNN0zL5o1uhUChyHzduwPffG+1Ro7LfKDwUDi8fMYxCBw3WVEyPUXhU9xTqRqGNF/hte9gojI2V7hcLo1A0bMhAz3/MRmFuyStMiVdKvMIbFQ2P3odV7yAsE/dHjpQ/hwd4Kz/sex5KWAydcBVanrAnLP8asNcruYoouNYKEm4+tEZuxM1N6neGhEiJhxkzpKFYrZrMR0yO8HCpGTh3Lrz3HrzwglynQgVpgEyZIg2PW49ZzFUImDVLrmtpFL7xhtQmzFajUMTJfFOTAebahHvOnc0GGsAbPtApf1rrCPmDtjAKd5dxJnbYECb2/IFVjYwypjY3b8L06Q8t0dkXCuu/o/2xZQiwM8KkuTfbauyYMYaXd8sW+PvvNPanUCieGlLLMUwC4oF/gF3ATmCPECJXlltTHkOFQvG4DBwob4JB3oDu35+9huHfodDyONzXa9y72shct4Z505gYcxwC6xmVEW08oej2hz1ahw5Bt25w4oTR5+jImpVj+PzCAnPX3FZzaVq2KbmZ0OhQmixuQnCUrPC46EA+Xl1zwBgwYwZ8/HGyc0P0vMMtD+Qd/vHcGUrfqQ1JurSHU00o+hfYPL3PWuPj4cwZWbDk6FH5/cgR6zy/tPD1NTyLJu9i2bJSPiM57tyR6XZ/WKSGurjAzJnQq1f2P7wheAIE6xWqNBcocZIuF4rz4x3Zld9ehpDmS01bFGDqVPjsM3PzpoctY6a2Zm6vVdjZ2LH10DqqvdoBnwj5gZDk4oLNxYtQoIDVMtMDYZCuLN3FbRvL3BrJho0blLoGtkZuUo8eMp0RZNDArl054OepUCgyhccKJdU07Q7gozdNg+KBgxiG4l4hRK7IylWGoUKheBzu3JF5UtF6fs6GDdCiRapTspTf70K7kxCjhzF62cmiFbXypDEx9iQE1INEXcvCxkN6Cp0t/jfExcEXX8ivxESr6ddHf0L9PBtJSJK5ht2e78ao+qMy6aqyl83nNtN3fV8APKISOTjtLnb39eIcPj5w8SLkSf4HnCik8P2XD+Qdbiq5lZfCX8esUOf+FhRa8UzdXQshve0mQ9H0/fz59BdtdXKSoaeWeYv+/lJRpFs3uH3bGFutGvz0E5QrlzXX80jEnoErVaTXECD/16xNHEA7Cy36XypCm7QKCP79N6J+fTT97zHOFj78pCKTR+/Cx1XeogkhWNK7Dj0WGg80xHvvoX33ndVS4QlQbD/cSwAQhBaujEeivqH80yHvQPPYy5elUW5KLd66FRo2RKFQPAU8do6hpmkVgVeB14BXAFPAg2lSHHAAw1DcJ4TpUzBnoQxDhULxOHz+udRCA3nj+d9/2Xdvv+I2dD0DCaZ0JQfY4g+V3NKYGHtKNwp1V4VNHlmN0PkFY8zRo/JO++hR67leXkROm0zT2B+4ESFDIv0L+LPy7ZW5NoQ0Ofr+1pfN5zcD8PleQe9fLhsHR460ruWfDKvvQI8H8g7XF5lHy4S+RofPWPB5OozpjBAZKYucWBqLx47JAjePy6BB8nmGY054S4okCHgNonfLtlNNbhfcR6V/bQnWi1d19YWl5dNY5+ZNeP55qzjbcW3z0Wz2H9QobH1Pd+H2GahShdK35S2YsLFBO3YMKla0GjfqspRbARjn+R0jnd6XDfsSUPI8aEaxpT59YP58+bpWLWmMP0PPNRSKp5ZMKz6jaVp5DEPxVcCULm1aJBbYD+wUQuQoGVxlGCoUikclOFh6CyN13fe1a2XuUnbwzXXoe974sC3hBNuqpEP3LPaMvElN1F0rNu7gtwWca8t2fDxMniwNH5N7wESLFohvv+X9A2PYfnE7AHkc87D+nfX4eaZV9jR3ERQZRJPFTQiLCcMpLol90++S5264POjqKr2GvqlXCDkWAW1PwCWLhIv1+T6ipe1co6PQKsjTIQuuIHeTmCh/xA96F69fT32er6+sEdS48ZPZZ7q4962sUAuAHaLYf7S94M9velhtEUc4XgM8U6uSmpAADRpYJfhtqOpK8IJZ9KjRM9kpqyZ15a1hy4wlmjbBbtNmqzFBcdJrGJ0EzkQRWtAPB6GLnxb+BdzbmMdeuyYrMZvSbLM7WkKhUGQOj1V8JjmEEKeFEPOFEG8LIQoC5YE+wCrgFuCENBrHZGjHCoVCkQOYMcMwCitVgjZtUh+fFQgBk67ChxZGYUUX+F+1dBiFcecgsL6FUegGRTYbRuGJE1CnjqymY2kUenjA0qWwfj0Lr/9uNgoBpjSd8tQZhQD5XPMx/LXhAMQ42DClnkVlmchIGJ/2s05/N/inOjT2MvraBs1gT7xFDN7NblI/UmGFra0MXWzfXnr+Nm6UhklQkNRPnDZNFoj19zdyDlu2lJ7GHGUUxl+HICMfEO/P+SHMMAoBFj2XhlEIUmPDwig8n9+eXUM607168hqGAM0GzuGf54yQZ7vNf1qLTyLzGd/VC1RF48LP8b2NgyZJDZ0iReCDD4z2yJGGmotCoXg6ybBchaZpPkhjsB7wNuAFCCGEbWrznjTKY6hQKB6F0FCpy3Zf135fuRLeeuvJ7kEI+PyStW7eC+7whz94p3VjGXcBAl6FBKnTh+YKfpvB5SVpBH71lRR3i3sg+v/112HBAi47x7H00FJWHFthzivsWb0nw+sNz7wLzGEIIeixtge7r+zGNlGwfcZt/G7p8Y12drK6SjoU0hMFDL8EU/Tfm6d2jwPedShrp5ejtCsIxQ6CfZGUF1GkSGysrIxaMK0KvE8aIeB6W4j4TbYdyhJY4CiV/nMyF4r6sBDMLZvGOr/8YhWaEOmg0X9kbWYM/hN3R/dUp+5YM43XOnyKjX5rF1upPI5HjlvpcV6NgVL7ZfZrEZtAAvKXQDPlwhY/Ak5VzGNv3ZJveVOY75o18Oabaf0gFApFTibTPIb6Yvk0TWunadocTdNOALeRHsM+gC2wCRiakQ0rFApFdjNrlmEUPvcctGv3ZM+fKKD3OWujsIEnbK+SHqPwoswpNBuFLuD3hzQKT5+WQoxDh1obhe7uiAUL2D13CL32j6LhooYsO7LMbBRWKVCFwa8MztyLzGFomsYXjb7A1d6VRFuNSY0skjcTEqTLJB3YajC5FKyqAC42ECq8aH5vAyFJuisx4SZcaw1JkVlwFU8/jo450CgECF9nGIVAku8Cep43jMJSTvBlWs8Vzp9HPCBQP/rtwnz+wZI0jUKAem9+wu6XipnbjidOI5YtsxpTzAk66VHR15L8+F+SxYfbA17DAgWgXz+jPWrUQ3WpFArFU0SahqFuCLbXNG2upmknkSGjq4APkTmG64FBQA0grxCiuRDiy6zctEKhUGQl9+8b8hQAw4dbPXB/Iky4Cgst5O/a+MDGyuCWQul+M3GXdaNQag2iOUOR38GxrvQSVqsGBw9aTUlsUJ/fVn/B67Zr6L62B7su77I6Xsm3EnNazcHBNq26+rmfwh6FzQbwn5VdOVrUIqR0xQop5ZFOOuSH/c9DSSe4kFiGN0PXEi/0X2DsIRlWKlRs3lNB4j24/ZHR9uzN/NBX2KZLmWjIYjOuqX2OREVBu3ZopidSwNK6eXj58zmU9UnLzaifR9MoMGMhMXZGlZjYIYMfquzzmUU0+Gf3LORY7v8ECUFWYwcPBnfdJj11SkZPKBSKp5PUBO4fNAT7AHmBNUA/wF8IkU8I0VYIMUMIcUgI9R9OoVDkfr75Bu7pN3SlSkHHjk/2/OejYOJVo93NF36uAE5pGadxV3SjUHczak5QZANcLyTFyAYPthJsT3J1YcugN3ih9T0+OTGD83fPm49paDQo1YBlHZbxa5dfKZSnUOZdYA6nc9XOsuqjpvHl617WBzt2tNZ3TIPKet5hEy/YFVePj+7PMQ6Gr4Xg0Zm0a0W2cuczSNSrh9oV5JLbFAZfNA4P9oO6HslPBWQY6ocfyqRJnUNFHbk6vB+tK7R+pK0893xDDrR/0dx2uh1M/FdTrcZUcoOW3vL1/vjaXKKmvo9YCP3Waqy3t9RyNTFmzMN1qhQKxdNBWgL3AjgMzAf+FkKce4J7y1RUjqFCoUgPiYlQsiQEBMj2woVSLPtJIQQ0PWaIpr/gDvueB5u0ysTHB8icwvgrsq05QqFfYdFZGTZqEmLUOVe5CB+0sONqXuvng672rrSr3I6u1bpS3Kt4plxTbuRSyCWaL21OXGIcixfc5JVzFj8/Z2f49ltZDSWdJAoYcRkmB8DX7gMY4GoRslfwR/DolIm7VzxRInfKIk86iYXW8cqFtuzVHX8VXeC/GuCYWozWggXQ2ygEc9fVhiETGzPnw18fSxbm3u2rJJUpjXe4tODiXBxxuHjFSvR+bxjUPSxfv+P8Iz94dJENu4JQ6gpoRoRAaKj8XDQ9MPv+e+iZfHFUhUKRw8lIjqEGVAO+ACZomtZX07TKmb1BhUKhyCls2WIYhd7e0Lnzkz3/miDDKLQBvimbHqMwUHoKzUahA8TOg+YTYcAAK6MwxtGWMW28adbF3soo9PPwY/hrw9nzwR5G1R/1TBuFACXzlmTAiwMAGN3Whzt5LGJ4o6Oha1d5Ix8Tk8IK1thqMKkkrK4AoyO/YlNsU/Ox+Js9SYzan6n7VzwhkqLhlkVlT7c3mBZqGIV2Giwrn4ZReOgQwiKRL0mDUd1LMbb794+tFerlW4yL/Y0HFw5RsUQMs84RftEDXta9mCuj2xOGnriZcBPu/2w11tMTPv3UaI8daxV8oFAonhJS+6gqCHQEvgXuAu2A2cARTdPuapr2q6ZpAzVNe17TlOSpQqF4OvjWIoqqWzdwckp5bGYTngADLxjtvoXh+bTqTcRfh4D6EH9JtoU9/N4L6vSD3buthv5TwolmAwqxrK4HQrc2axWpxTetv2F7r+30rNEzXQUunhV61exFRd+KBPjY0/LjQpyokN96wIIFUu7j4sXkF0iG9vlhz/N2DI1eyakEqXBuTyxhV9sQGhWQmdtXPAmCx0G8/kdr48Fp99mMvGwcHlUMqqX2JxUSAm++iWZhZc1onJe3Bi3McPh29VHfEFjQKKDksvRHmSRowZCi8ns8DsyM+NA4cG+mDF+woH9/8PGRrwMCpNdQoVA8XaRbrkLTtPxYi9tX0A8JIBzYA/ylf/0rhHisulWaptVGeilLAKaP03DgCnBYCLHvcdZVoaQKhSItrl+XEhWmqntnzsiKpE+KTy/ANL1mjK89nK0FHqkVm0m4KcXr4/Qo/+t2MK4C/H3MaliMncbUZnlZWjcPwkbDwdaBluVa0r16dyrkr/DQsgqD03dO02Z5GxKSErBNFAzfFUe3zQ+orufJA0uWQNu26V73Xjx8cuoiU+1r4WMjRe5OJVYBv/9RIY9bGrMVOYKYI3ClBuhSDwn5v+OFS+9xOEIeruEOe6uBfUqP4JOSoFUr+P13c9fOcs4cXzCR/i8NyJQtXlg6g9LdjQTBkPp1yLt9r7ktBFT5F45Hgo8WxE1fP+zQjdRie8G5jtV606fDoEHydaFCcOGCjKxWKBS5h9RCSR9bx9BCv/A14BWgosXhSCFEnmSmpbZeP2AIUMCyW/9uucmbwGRgrniEzSvDUKFQpMX48bIcO8Crr8KuXU/u3McjoNq/pltM+LG8UVI+WRJu6UbhWfkJudoG8ZUDWoR1aOOhYo4MfisfV/I54OPiQ5eqXehYpSM+rj5ZcyFPIdP/N525++ea26+djuKrlXfwirKutxbdrw/O02aCfVp6IpJEAd9f/Jvu8Q1x0OIB2BDbmtgC62jn+8hqUooniUiAq7Uh5j/Zdn6V0Yk7GBcgf2+OGhyuAeVdU1lj4kRZ8ljnmpcdk6e1Z1b35dhomfT7F4ILVYtR+pihexP/5ybsGxuhzD/dhs6n5etlnr3o4rRINtw7QOFVVstFR8uCXDf1isnTp1sXplEoFDmfLDEMHzhBeWSo6QAeUeBeD0P9GWiLNASvA/8AAYD+3A03wA+oCRRB3gb9IoRIt7KYMgwVCkVqJCZCiRIQqN8//fTTk6tGmiTglcOwR89LqqfrFaYYpJ9wW+YUxp2GG5AwQsNun/VneaydxvQmXix6xYPyBSvR4/keNHuu2WPnLD3LxCXGMfXvqaw+vpqIOPlvqeC9BOYsu03VQOtEq1OlPdkyoReVa7zOC0VeSFdo7r+B31Mj8l1ze1LEEMLzTmJ8CZmbqMiB3J0GQXrSnebIsXzHeP5YWfODnemlYKBfirNh+3ZE48ZoSfLhQqwt9P2sClNH7sTL2SuViY/OvT3b8XqpobkdXNYPn9NXwEYanwlJUOYgXImBynbHOOZjEri3hVKXwd76QubOhY90ZY58+eDSJXBTTm6FIteQ6YahpmnlMLyFrwKmxAvTv7AYIYRLOtf6EJgDnAb6CCH+TmP8q8A8oBzQVwgxPz3nUYahQqFIjT/+gObN5WtvbxlW6viEbKglN6HHWfnaToNjqXkaEu7InMLYk4SstMHlK4FTlPXn+FE/Rz5/25dSdVvQo3oPqheujkoFzzgJSQmcvH2SfQH72Bewj6NX/2Hgr9fptue+1bi7rjYM7JSffc+5Udm3MnWK1ltBV/8AACAASURBVOHFYi/yfKHncbZPPu4u+Nqn+ERMM7e7hi4lyKUrP5UHr/Q5IBVPiriLcLkyCFnUKd57Iv6Xh3JGlwp8xQN2Vk2laNT161JPNMjQCxzdzpc3Z23Bv6B/lmz5fPMXKfOHkYlz/9vZ5Olt6C7Ouw59dbWaPd71eNF+l2zkHQL5J1mtFRsLZcsaRbomTYIhQ7Jk2wqFIgvIsGGoewRfwwgbfdAQjAUOALv0r31CiHTVq9I07R+gDFBGCBGU1nh9Tn7gHHBeCFEzlXG9gd4ARYsWrX716tWUhioUimec1q1h/Xr5etAgqQX/JAiJh+cOQrCMJGRIUVm9MlkSghEB9Thy7Dz2owWVjsVZHY61hfnNChD9cV+61OhOEY8iWbv5Z5zYhFiO3DxC8JJvqD/xR5xjDHG3JA1mN/RkTkMvknQLwcHWgWoFq1GnaB3qFKuDfwF/HGx1SQCRSFxgGxyiNsq1hQP1Q3Zw27Yuv1aSunOKHIAQENgAonbKtqM/nyb8y7Tr0np3s5UPdkqklHcXHw+vvQZ7jTy/X553I3rhfDpVy7oSyPGXL5L0XFkc46WHMtTbDc+A2+Ain+FHJ0Kx/RAUD60cf+M3rzZyoo0XlL4GNtbP+r//Ht7VndxeXnD5MnikptOoUChyDI9lGGqa1gfDI5jP1K1/j8PaENybXkMwmfOEA1uEEG8+4ry1QGMhRLpK6CmPoUKhSIlr12TRGT2qi7Nn5RPxJ0GfczD/hnxd1BFOvQCuyQTix8beZOPe+lz94TbvrgwjT4x1ftu5ou6c/Woo9Vv3x9UhtcQmRZZw7hxJb76BzYmTVt3/K+PMwE75CXF7+JfqYu9CjcI1zB7F8nmLYBP4MlrcCQDuJObjhZCDBIviLC4nK5oqspnQhXDrPb1hw3/eB6l5srq5EMJ3ZeG91IqJDhwIM2aYm2cKOLBk7vtMajszy736gX274jdvmbl9/bM+FJ4yz9yeeBWGXwYbErmSvwx+Nnp51QLfgmdvq7Xi46FCBVl8BmD0aCl8r1Aocj6Paxha3nXEAQexNgTTJ96U9uZCgb+FEK0ecd564BUhhGd6xivDUKFQpMS4cfLGBuTD/J07n8x5D96H2oeM6lq/VoLWD9SECY4M5sfDC9m8az6DVgTR8FSU1fEEW42Aft0pPuUbbBxU/mC2EhUlk68WL7bqvu/jzpj3yvNb3uBUp3s4eVCrcGXquGzjxbxBlHKL50RCJV4M2UuEcGdIUZig8g6zj/gbcLkCJIUBEOv5GeWuTOGKfjf0el74vXIqucGrV8Nbb5mb4Y4aA8e8xKxPNuPikK7sm4xx/z7hRQvgHiZDYKOcbHG8FIBtQWnJhsZD0f0QnggDXL7m6zyfyHkOFaHE8YcubPlyeEeXSnR3h3PnoEABFApFDudxDcP/ATuRhuCezDIEkznPbuB5oLIQ4lI655QCjgP/CSFeTs8cZRgqFIrkeLDozIoV8PbbT+C8Al74Dw7pJbZaeMP6Ssa9V2h0KJP/msxvp36hyX+hjPklGM9oay9hTMVyOC1fAVWrZv2GFeln0SLo2xdiLP5t2toSPm4kO9tUZV/gfvYF7CMwLDDlNYB8jgnU8Y7GxaMsX9n9SJxjMZp4wQ/lIb9DFl+Dwhoh4HpbiPhNtu1L0zf+GPNuyZhRLzs4URMKpfRs5swZRM2aaBER5q5Pehaj39SdlMhbIos3bxA6fRKeg4aZ2+faNaDsz9vM7c8uwtRAyKOFcSN/EVw1fb9+W8G1odVaiYng729II3bsKIt2KRSKnE2WVyVN5oTOQuhZ2WmP7QQsB24AnwNrUgpL1TTNEWgPTEHKWnQWQqxMz3mUYahQKJLj99+hRQv52sdHhpU+iaIzc6/DR3qxBycbOFXTyEsKjgym689dCb5yinFrg2h6wtpLKGxt0YYPl6XuHZSFkCM5ehTatTNi7Uy0bSsNR09PAkMD2Re4z1zMJigy9TT7eAc/YtxrobmWo12x0nz6XGmKexRQhYWeBPd/hhsdzM0DHruoffZVcztVeZmICKhVy0pcfuErHhRZsJKmZZumMCmLiI8npIwfea/eBiDBBiIO7sGz+osA3IiFEvshTsBM9/70d50t57k2B7+NDy23bRs0amS0//wTGjfO8qtQKBQZIFMMQ03ThgohJqVjnCPwuxCiYVpjLebMBfogI6rigJPAVSBSH+IKFENqJTogcx3nCSE+eni15FGGoUKhSI5WrWDDBvn6009h6tSsP+etWCh3EML02vbji8OI4vL17YjbvLP6Hbz/OcGcZbfxjrT2ElKxIixdCtWrZ/1GFRkjLAx69YK1a637S5aENWtkZUodIQQXQy6y9+pe9gXuY3/Afu7H3ictHO3dKO9ThjLepSntXZoyPmUo412Ggu4FlcGYWSTehUsVIPEOANec36dSwHzz32+7fLC6QgohpEJAly5WrrR/Sjix/dthDGk08gls/mHif12HfVujrMOZWqUpt/+8ud37LCy4CaVtz3PW5zlsNP0+seQ5cCjz0HpdusCPP+pDSsKJE0r0XqHIyWSWYZgIvCOESDFQQNM0O+A3oGl6dQwt5r4JDEWGlabGIWCSEGJtGuOsUIahQqF4kMBAKF7cKDpz7hyUefi+J9N55zQslw/sKeMMx2uCow3cuH+DLqu7YHPuPOtm37AuMGOjwedDZDLkk9LRUGQcIWDWLPnUIcGoWoqjo+x/771kLYrEpERO3znF3uMfsO/GJf4JcSI6Mf2i5672rpTyLkUZ7zLSYNS/F/YonHni6c8KN7rB/R8AiNQKU/T2SUKSZAlOX3sZQuqTkuN+3jwZVqwT5GbLyCnNmP3+Wuxts0mHRAju1amG14Gj5q5LPy+gZDtZZvR8lKyULIANni1o4fS7HOTVD3xnPbTc7dtQrhyEhsr28OEwYUJWX4RCoXhcMsswDEDKVDQVQuxK5rgtsBopVL9dCNHowTHpPE9hoBpQAilsD1Lo/gpwWAhx7XHWVYahQqF4kLFjjUp69evD9u1Zf86/QuG1I0Z7iz80yguBoYF0Wd2F+7eusm72DUqY9CsAyvjC8vXwwgtZv0FF1rB/P3ToYCSzmnjnHfjmG3BNoZJsUgRcfYm46KMcC3XkWFhe/oxuw4GgIIi6gG1i2l5FS5ztnCnlXYrS3qUp612W0j7S01gkTxFsbR7pee6zQcRmuPa6udny3no2xrYEoJCDLDZTNaXa6AcPIl566f/s3Xd4VEUXwOHf3RTSSICQQBJ6b4J0GwKiiCBNLBQRpasgCkpRrCgiIqh8gjRFBREQCYKigmABpIuAdAk9hAAJCenJzvfHbLK7yaayCwHO+zx5sndum6Uke+7MnIORpv8vZxgw7Lk6vPH2b5Tzy23e6dWhtm/HaG6t9nW0SimqHInG5OYOwKP/wtJoaOe5lrVlLB/nTH5Q/RS45axLMWcODLYkLvXwgF27dNZSIUTx46zAsD6wETADdyml9tnsM9DrBHtZjmlf0DWGV4sEhkIIW+npOunMKcujpm++sUsY6BKpZmi8HTITiz4WBN/Uh4iYCB5f8jjRsZHMm3eWVodtfnw2C4U/jsjcrBvB+fN63t3PP9u316+vp5bWqeP4vLQTcKwFZFiGmQ1vkgLfY0LsM3wYcQGVdBjPpMN4Jh/BM+kIJVMOk5YWW6iuebl7Ub2MDhgzp6TWCKxBpYBKN2/AmBEPEQ0gXVdy/zqpF30u6UlTt/rBqlsgLLfB+/PnoUkTuwcB73cMpNXMVdxW6TZX97xALj/WHb8l4Vnb294ZRvOX9ZrCHfHQbAeAYk/gLTTwsJRhCZ4KZV7IcS2zGe6+GzZu1NutWsFvv4FJBqeFKHaclnzGMIy2wGogCrhdKXXG0j4X6A9sB9oppeKvuNdOJoGhEMLWqlXQWT/4JyhIB4iuzuMy+QSMseReLukGB1pAQvxh+i7tS3RCNK+uOM+TG2xGgEJKwI7/ICTMtR0TV4/ZDBMn6inBZpupwr6+etilVy/H5yVthhNtwTZBuE8bTpf+jDEnq7LwnM2xSlFaXeBJ/8PcYjpCxIXDHLlwhMMXDnMx6WKhuuvp5km1MtXspqTWCqpFlVJVbvw1jGeHQ+z/ADhvDqRu9H7OqyAeDIRFdcHPPZfzMjKgUye7BwBr6vlwdN4HDLlt6FXoeAGdOEF6zeq4p+opzlGlPPE5eoKSpfVoZvt/YE0MDPKezeyAIfocj6pQ7TAYOR8W7N2rl81mzpieNw/6978q70QIUQhOzUpqGEYf4EtgN3A38C7wDLp8RBulVMyVddc1JDAUQtjq3FkHhwAvvQSTJ7v2fieSoe5WSLTEAlOrwwNeB+i7pC8Xky7y6JY43v3Wps6dtwF/rINmbVzbMXFtrFung8Bz5+zbn34apk1zvI40eSdE9oOUvdY2wxeCp7DNNIRRRw3+vGR/SjUveK8a9AjSSxkvJF7gyIUjWYHi4fM6aDyfmHeNxexqBtake73udKnXhZCSIYU697qQuBF1ohWGpcpon9gFfJ3ch+fCYGqNfGpJ2s5RB46XcWfax32Y1vvzYhdMp45+Ec/3P8jaXj/gXtrOXQPAuhho9w94k8jJ4IoEmiwPFcKWQ8luDq83bhxMmqRflykDBw7oB29CiOLD6eUqDMMYB7yDLjERAhxGF5s/l+eJTmIYxjuW+yql1ICCnCOBoRAiU/akM4cPQ40arr3nQ3thueWzd0Nf+KLCHgYse5LY5FiaHU1iwexIPDJsTlg4BXqPcm2nxLV15owumvnnn/btzZrB0qX6H2l25hS48BZcmIRe2WHhcy+q/DzCL1Vi9FE4km0xx53+8EENaOnvuCsxSTFZwWJW4Hj+MOcS8v61bmBwW6Xb6F6vO/fXuh8/T788j78umJNJ+K8xvhkHAPghuSNdYlfxYQ2D4RXyOfenn1AdO2JYPlsluxsMG9eEqS+vw98rlz/8aykujpSqlShxUT9RuFzCIGrnBqrXuwOloOVO2BYPE/3GMc7PEvH5tIFK6x1eLjERGjSAiAi9/cQTOomyEKL4cEkdQ8MwZgJDgAigVea00qvBMIz9QG10YFigxQ8SGAohMr3xhn6oD9Cuna7F5Uo/XoBOe6zb80P/ZtrPTxGfEk/YxTTCPz5DmQSbqHDsw/DuUtd2ShQP6ek6jWP2IetSpeDLL63znbNL2qpHD1MPWNtMJSF4Gqkl+zMz0uDNYxCTbn/aY0EwqRpUKeCS1UvJl3KMMO44vYOk9JxpBLzcvWhfsz3d63Xnjsp34G7Kba5l8fb30fE0Tn0HgHizH80u7mNq3Yp0CsznxBMnUI0bY1y0Ttcd3zOE3h+tpV5w8c3Eoj75BGOYtfrX2vtq0u7ngxiGwXfR0ONfqGA6SURQVdwNy8+pKrvAq5HD661eDR07WrfXrYO2bV35DoQQhVGkwNAwjM/yua4b0BP4EziRbV+BR/KKwjCMiegRQ5RSTxXkHAkMhRCgP4dXqQKnT+vtxYt1skhXScqABtvgqGVp2EMe2zi8fQAJaQn4JptZNjOSmmdSrCc8WAtW7JesDTeb77+Hfv2sOf8zjRmjc/+7OwiyzMlw/jW4OAWw+V3u2wHKzyGGCrx9HKafhjSb3Z4GjKgAL1eCUkWomJCQmsDPh38mfF84m45vQpHzc0SQbxBd6nahe73u1A2uW/ibXANmBdP/28Uzac3xMHREPS5hBo/Vejr3zKOZUlJ09pWtW7OaFrcoidu8z3i4wcMu7LUTpKWRUq82JY7oYb50E2xcOZPWHYdiVlBvKxxMgkUBPenpvVifE/AUhOT+MfGxx2DJEv26Vi3YvVuq7AhRXBQ1MDQ73FEwBR7Ju1okMBRCgP783bWrfh0crKeVujLpzOsR8NZxy/0SNlL28BCS05MwzIq5Cy7QZo9Nspn6JWHzKfArhlPOhOtFRMAjj8COHfbtd9+t0+aG5LKWL3ETRD4JadYi5ZgCoNxH4P8E/yUbjD0K30bbnxboDm9UgSGh4FHE5xCR8ZF8v/97wveFc+j8IYfH1AmqQ7d63ehSt8s1L9OQm6QMePJAOqPNLWnqsROAnRmtKFf9N8K8CvCH8+yzumahxb+hnnwzczgTukxxVZedy/YHI7ChYWmabDuFj6cPn0XCgINwm8df/BV4hz7AKAHVT4K74wWEkZE6yW6c5cfbG2/ofEtCiGuvqIFhvyu5qVKqWM0ql8BQCAHw4IPwg6Ve85gx1kQJrnA4UY8WpirwvvQ7FY8+TXqGHh0c/2sST/0UaT040A227YSqDV3XIVH8JSfDyJG6tqGt4GBYtEgX3HTEnAjRr0DMR9iNHvp1hvKzwD2EjZdg1BHYki1veG1vmFwdOgfqBDVFoZRif/R+lv+7nO/3f+8wmY3JMHFn5TvpVq8b7Wu0x8fTp2g3c7KoVOiyB1qbJzO55BgAUlUJ0irvxtenVv4X+Ppr6NMnazPOy8Sot9vwvxE/UsL9OhkmU4r01nfj/ueGrKYlHw3l0edmkmKG6pvhdKpiS5mWtPDcpg8oOwHKjs/1kp98ApkzVD09Yc8ePXoohLi2XLLG8HojgaEQ4sQJXbvwaiSdUQo67IZfYsAndi3l/xsOKhWAx/e78eZnNqM7HsDPX0Lbvq7pjLj+fP21rhiekGBtM5ngrbd06sfcphon/gGRT0HaUZvzSkO5/4F/LxQGi8/B2KNwPMX+1LalYEp1aJLftMl8pJvT2Xh8I8v/Xc6aI2tITk/OcYyPhw/317yf7vW7c1vF265ZrcR/E6DTbvBIP8zusg3xNnRfzWUnYSo7pgAX+BfVogVGYmJW0/ODqjJq8u9ULFXRVd12je3bwabo/b6wEvj8s48qgdWYehJG/Qe9vL7m61KWINg9BKofA8PxlIuMDLjjDuvs2nvu0eu5i1liViFuOtdFYGgYRmvgcaACEAl8q5T6MY/jxwD3K6VyeXxqTwJDIcTrr+vP1QD33gtr1rjuXkvPwaP7wPfiaoIjnsdQes1Su4v+fDp1D6YUm2QzM56Gp2fkciVx09q/Hx5+GPbts29v2RKmTIG77nJ8njkBzo3NqsGXxa87lP8U3INJzoCPT8M7xyHO5p+iAfQtB+9UhQpeV/4W4lPi+fnQzyzft5zNJzc7PKa8X3m61O1Ct3rdqB1U+8pvWkBrL+rEKvEZZtaVuYc2nr/rHSUaQ5WtYOSTPCc+XgdSBw9mNc1sW4rac5ZxT/UCfTQpdtTjfTAWfp21PW94awZ8/Bvx6VB5M1xOT+VYUBVC3SyzHUIWQECfXK4Gu3bpJLsZln9jX34JfeX5lxDXVLEPDA3DeAN4NXPT8l0Ba4G+jspgGIbxOfCEZCUVQhREejpUrqwrBIBOjPDII665V3w61NkKcZErCIp4EcNSVqAx5Vj8wX7cztokGBnaHGZuzeVK4qaXkABDhsDChTn3deum50LXziWYSlgHkf0h/bi1za0slJsB/voff3QqvHkMPj0DttVSvE0wqiKMrgglnZRc9EzcGVbsX0H4v+EcuXjE4TH1g+tnrUcs61vWOTd2YO4ZePowpCsY7D2LWQGZhefdoMo28Gqc9wWU0hlWllqzB/9V3YtNc95gVNsCjDQWV8ePY65dC1OKnt0QGeDGoY2raF2/A69FwITj8Irv27xd0vKRzas5VN6S5zDgqFEwdap+Xbasrm0YmF+GVyGEyxR1jeFIYK9S6pcruHF7oIFSamoex7QG1qN/J80H/gZqAf2AAOA40E4pdTTbeRIYCiEKbMUK/TkaXJ905sUjMHvXUsoeG5dVILuOX2XC55zFY+d+64FtysKa0+Duwuw34vqnFMyeDSNG6OyXttzc9JTT11+Hcg4Su2TEQ/RLEDvLvr3ko1DuE3DXwdeBBBh9FFZesD+snAdMqAr9Q/Ip6l6ot6PYE7WH8H3hrNy/kotJF3Mc42a4cVeVu+hevzv3Vb8PLw8nDF+iM4+OOwqTT+rtMNMp9gfVo6RhWXgZOA6CJub3BuCDD+Cll7KaovzdeOv9bnw8cPE1mxbrNLZV6oE53avxxJJ9xJlLUHkz+KpoTgZXxMuw/FusvAm8b8/1cpcvQ716+mcuwIABMHeuK9+AECIvV5KVdL5Sqv8V3Djf4M0wjKXAQ0BPpdRSm/ZywELgHuAMOjg8aLNfAkMhRIF16gQ/Wianjx0L777rmvvsuQytfvyawBOvZrXVCqzJ8p9K4LXke+uB1T1g6yEoU8U1HRE3nv/+0x/alzqocennB6NH68Q1vr459yf8ApEDIP2Utc0tWE8tLdk9q2l9jF5L9vdl+9Mb+Or1h/eXcdJ7sUjLSOPPY3+yfN9y1h5ZS2pGao5j/Dz9eKDWA3Sr140WFVtgMoqWQjUxA57YD8uy8uIo/ijbmVbulmxUnrWgyj9gyiMI3bULXnwRfv01qyndBMNfaMCEN9e7dJTzqrl0CXON6pjO66cE8SUMli2fxJMPjOa5w7r8yVz/AQzwsZSrKPkohC3O85LZkp7yxx/QqpWr3oAQIi/FPTA8BVxQSuWolGoYhhswC+gPRAH3KqX+Lei1bUlgKMTN6/hxnXQm88fdkSNQvbrz72NW0PT7z4k7/HZWW92geiw5fis+r1vbCAA2rIQGDzq/E+LGt2WLDk42bMi5LyREL6R98smctQ8zLsG5kXApW/05/z5Q7mNw01GfWcFXUfDKUTidLU67v7QOEBv4Oe/tZIpLjmP1odWE7wtn6ynH06tDS4bStV5XHqzzICU9S5KakWr3lZaRpr+b00hNt7ZFp6Qy83QqJ5JSMcxpGCqVtl7/0JhVpJohzWyQ6t2BVKOUvla65RqW8/3PXeLxZQdo91ckpmwfm97tEkT7GatpGtbU+X8o14ptSlFg0Z2laf3jXtI8Q6m+Geq572Z32cyPbW5QPQI88k620707hIfr1/Xqwd9/u7ZUkBDCsSsJDC8DOXNOF1xZwDefwDAF+E4p1SuPYz4ChgPRwH1Kqd0SGAohCuq112DCBP36vvvglyJPkM/boLWzWLdrctZ2zeCGLPN9DN9HelkrCLgBy8ZD1wmu6YS4OSilh2HGjLFLfpKlfn147z3o2DHn+q/LP8LZQZB+xtrmVh5C5oCf9WFFYgZ8cBLeOwEJNpWNTegMpo8EQ/eyEOyCD/enLp0ifF844fvCiYiJcP4NCsgv2cyQ9bH0/+MSXun2n5fMBsy7OwD3KVN5qlmRn6EXT2lpqAYNMA7p2pTpJpj0vz6Mf3oBT+zXDw7WlW5L2xK/6ePLjIXgvKdhnDypA8LLltHod96Bl1924XsQQjh0LQrc28qz2L1hGJeA35VSXfK6iGEYHwAvABeA9sBzSGAohMhH9qQzS5fqRI/OpJRi8obpzN7yUVZb2cCmrGs0Ct/WbeCyTbr+iffBOBdFpuLmk5YG8+bpNYbncuRpgzZt4P33dWpIWxkxEPU8xH1p3+7fD8p9CG6lspoiU+C1Y/BZJGT/YGACWpeCh4PgobJQ3sll+5RS/HP2H8L/DWflgZXEJsfmf5ITuGcoHtsSx4hfYghMyPlx6Pfa3kzqFEjTDv2YcO8EjBuxBoPtwmxgbT0ffFevpWSZ27llO3QpsYIVpS37TaWh+mFwyzurzIcfwgsv6NdeXrB3r2tmbwghclfUwLCyszqglDqe2z7DMLYBoUqpsPyuYxjGZOBFIAY4AjSTwFAIkZfwcD2FCXRujpMnwcPDeddXSvHBhg+YucVakNzs35JtD7xL2bvvhGOnrQf3rgBfRYDJSWkehcgUH69LWEyZAjY19bL06qWHaKpWzXbeCjg7BDKirG3uYVB+Lvh1sDt0z2UYcxRW58wVA+iU4q0C4JEgeCgIQp0cJKZmpPJ7xO+E/xvOrrO7MGHC090TD5MHnu6eeJo88XTzxMPNA083T06nebIzwQOz4YkyPHB38+TBsh7U9jxJiYRv8DApPE3gUWYonj6N9XkmD8LWb6f2lM/wiTiVsw/16xD/zuuoe+/Fx8MHH08f577J4kQp/WDhjz+ymka/1Ix33t1Ej30e/HAhg0Nla1Hd3ZIbsGQPCF2aZ4bS9HRo0UJPIwW4/35YvVpqGwpxNRXrchWWkcDngVZKqU0FOH4SMBrLxCwJDIUQeenYUX/wAJ23Y2I+CQcLQynFxN8m8tkO65qtRP9WTO/wEQ/37QR/bLQe3NwLfo8A7/LO64AQ2Z05A2+8oUcRzdlGujw99bqxV16BMjZZZDIuQNRwiFtkf3zAQAj+ANz87ZpPp8CyaPg2GjZcss6StmUAdwbokcQeZZ1TE7GgzArGHoX3T1rbKpSAVbdAI+84iKhvTcLj/ziEfqVfb92q127++WfOi4aFwdtv6yJ8btd51tHC2LZNR3IWe8M82bZ8BrVrDeDOv+HBEitZWdpmwlf5eVAq72m127frUpyZ/zwXLYKePV3ReSGEI3kFhkVL7eVcP6B/hzxfkIOVUmOBiVjrHQohhEPHjsFPP1m3Bw503rXNyswbv75hFxQmBNxDk+af0uOd0fZBYZgB3/0sQaFwvdBQXdpi9254MFtyo9RUXVCuenU9sphsmeLsFgihX0Pot7rOYaZLcyHiFkhYa3eZsBLwXAX4ozGcvh3+VxPalLL/QKHQQePzR6DiZrhjJ0w9CSeScanEDHjkX/ugsIkfbGkCjfyA6LHWoNAtCIKnQUSEHlFt2TJnUOjnpwPCQ4d0Qp+bKSgEaN4cevfO2mxwOpXDH79JLffztAqAVSmdmZH4tPX4qOcg9XCel2zWDJ591rr9/PMQe3VmCAsh8lEcRgzdgdaAWSm1vhDndQbKKKW+KMjxMmIoxM1n/Hg9ew6gfXv4+WfnXDfDnMH4NeNZsmdJVltCqfu5VONDTv49h7Ijrdn88AHWToHbRznn5kIUxvr1ut7ejh0591WurP+D9OoFJktYl34Oop6B+GX2x5Z6GoIngyn3dKRRwk4DiAAAIABJREFUqbA8GpZGw2+xOdcjZmpRUo8kPhwEVb2L9rYcOZsCXfbCtnhrW5dA+Loe+LoBiX/AidbWnd5zYfp+mD5dB8228qsPeTM5fhxVuzaGpYbmmVJufDL/Oe68ayqd9oA3iews25Q67gf08V7NdG1DI/c5+3FxULeude3300/DjBmufiNCCCjmU0mvFgkMhbi5pKXpz72RkXp72TJ46KErv266OZ0xP40hfF94VtvlMp05V3UKCyJ/p88T7SHD8pHYAOb3gCe+vfIbC1FUZjMsXqxTQB47lnN/kyY6Qc099+htpSB+CZx9Bsw2Cwo9qkL5z8C3Tb63jE6F5ef1dNN1MZCRy3FN/XR204eDoPoVBIl7L0OnPXAixdr2QgV4vzq4GYA5CSIaQdphSAWW1YfpZyAmJufFunTRGV3r1Cl6h240Y8fqPxOLyQ+U4d45a3nqTGN2J8Ct7n+zNbAlHkaaPiDwZQh6J89LLltmTQRmGLBpE9x2m6vegBAikwSGSGAoxM1m+XJrIFi+PJw4ceVJZ9Iy0hj540h+PPhjVlt8YA+iq7zLfeeP8vOQZhgxcdYTRteESfvBuMmmn4niKSVF16d7+23HAVHHjvrDf4MGejv9LJwdCpdX2B9XejgEvQsm3wLd9kIahFuCxLUxkJ7Lx47GfjpAfCQIahYip8svF/X00ThL9GkCpteEZ2xT2p0bCxfeg5+AqQacctCJZs30FNvWrXPuu9lduqSnIF+wFr1/5oP2DOn9A63/ccMMjPT5gA/8X7ScYECl9eCT+5+lUtC5M/zwg95u2FCvP3RmcjAhRE7FfY2hEEI43ezZ1tf9+1/5h42U9BSGrRxmFxTGle1JdJVJ+CdcZvkrneyDwi5+8M5mCQpF8VGiBIwcCf/9p5OsZK8u/uOP0KiRXox7+jS4l4ew5RDyFZis5SuImQ5H60Lct/rTfT4CPWBACKxuCFF3wOe1oWMZ8MiWKeDvy/BKBNTaCo22wYRjcCAh72vPPgMdd1uDQj83nWTGLihM3gFr3oeewEhyBoWVK8PXX8OWLRIU5iYgQCc1siiZomi/8C9OnVzKmEq6bVriC/yacq/lCAVn+uqyKLkwDPjf/8DbMlK8ezd89FGuhwshrgIZMRRC3HCOHYNq1fRnVsPQn4OzZ+kvjOS0ZJ75/hl+j/g9q80t9AkOh7yGyWxm+5sP0vhPmyw3t5jgjy1QyuEDOSGKh2PH9ELchQtz7vP2hlGj9PpEf39IOwNnB0HCj/bH+dwL5aZDicJPu4xNg5UX9JrEny9Cai4fR+r7WKeb1rcMUpqVLp0xxVHmUdtlkAf/hefuhF8u5bxwQIB+/8OG6aJ6Im9paVC/PhzWyWXSTfDYy/WZOXYD9+8vxa7LEGI6w76gWyhlWKYgl3wUQr/Jsx7F++/D6NH6tY8P7NunY3UhhGvIiKEQ4qYyZ451IKN9+ysLChNTExkcPtguKGxYeyCHQ14Dw2Dq3LH2QWEwsHSmBIWi+KtSBRYs0PP32ra135eUpKec1qhhyQoSBBVWQch8nc0zU+JaiGgI58aA+XKhbl/KA/qWh+9vgeg7YUFd6FYWSmSLIf5NhDeOQYNtUG8rvBYBD/9rHxTaZR4FiI6G4cOhQcOcQaGHh06FmTlyKkFhwXh4wOTJWZvuZhj6XQQz/vqQBXX131ukOZSnYudaz4lfAnFf5nnZ55+HW27RrxMTdZx+k4xZCFHsSGAohLihpKXBZ9YKEgwZUvRrXU69zIDvBrDxuLX0RN9mz/KL/1gwDJ746QtGfDPFekIJ4Kt+UHtw0W8qxNXWtCn8+qte7FW/vv2+6GhdW6BBAwgPB/8noNpBKDUM60eINLg4GY7WgbjFRfpU7+8OfcrB8gY6SFxUV9c/9M72KWV/Ikw4rhPbZOoaqEtnhJZAB7STJumA9n//g/RsuVEfeQT274dp0yAwsND9vOl17QqtWmVt3rcvkcPL5mBK2M/EarotPKU7cxIHWc+JGgap/+V6SQ8PmDXLOqi4apVeIy6EuPpyDQwNw3jCMIw7ctnnbxiGw0dshmH0MgxjqrM6KIQQhbFyJZw9q1+XL5+zlFtBxSXH8eTSJ9l6amtW2wt3vsDusiNJVAa3793E3KmD7E96vxHcN6+IPRfiGjIMnXzmn39g7lwICbHff+iQzubUqhVs2Q/lPoYqO8D7Tusx6afhTE842Q5S/i1yV0q6Q89y8G0DOHcHLKmnE9L4OPjEMrICLGsAvoYZvvoKateGceN0PQRbTX1h4x+wZIlOoiKKxjB0gh4bY1ed5401rzE8NIM2lqWoz8dP42hGLb1hvgxn+oBKy/Wyt99u/xBv+PCcf4VCCNfLdY2hYRhmYL5Sqr+DfRmWfQMc7PsceEIpVawyLsgaQyFuDh06WOsVvvKKng1XWLFJsfT7th97o/ZmtY1tPZbQaoN4cA9UOHeS7UObUS7mnPWkoaXgf0fBrfQVvgMhioGEBD2q9t57cNnBFFEPDwgK0l9l0sHvPyidDGWwfJmgyqNQYzSEVIeSJfNcZ1YQiRnw00W9JvFAIgwL00ltWLdOTwn9+++cJ1UCRplg0E7wbnRF9xc2eveGRYuyNl/oFURA/2d48s7XabTdIC4DmrjvYGvZ23AjXR8U+CoEvZXrJWNjdYWQqCi9/dxzkoxGCFcoUrmKfALDvPZJYCiEuCYiIvRgQGbSmaNH9TKqwkhJT6Hv0r7sOG0tCP76Pa/zSKMnqL8NomIS+HNEK5octvkQ2s4NVu4E74bOeSNCFBfnzsGbb+q5fhm5VSMsAE9PCA7WgWTmd9vX2b/7+eUfSO7bp7OWZNY7sFUKeAZ4DAgZD0ETit53kdOxYzqKsyl6f+/oioy6bzweFQbQz1LrfrTve7xXcqzlJBNU+h187sr1sosW6ZgTwGTSiWKbyXJtIZwqr8DQ/Wp3RgghXMU26cz99xc+KDQrM6N/Gm0XFL5939v0atSL1yPgWKKZxe89aR8U1gS+mC9BobgxBQfr2ofPPaenaBZ18VdqKpw6pb8Kwssr78Bx82Y95dWcbQ1hiRLwVCg8FQH+gGcdCBxftD6L3FWpAiNGZCWjCY3N4M3l5xnnPpHpXcJ4qGwHvjsP7ye8RGevn7nLYz1ghjOPQ9V/wC3A4WV79oT58+GXX/Rf7ZAhOjh0l0+rQlwV8l9NCHFDcEbSmakbprLqwKqs7XGtx9GrUS8OJ8KkE/DqVxN45PdvrSeUBr5+BsIeL3rHhbge1K4N330HO3bAb7/pkcRz53RyGtvviYnOuV9yMpw8qb8Kqk8fGNMUPEZaGgwoPw9MJZzTJ2Fv3Dj4/HP9dw88su0y/1T0YpTHSD7pHszGS02ISjPRK+YL9gc1ws+IgfTjEPUMhDookYIeJJ4xQ+c6Sk6GnTv1c4kRI67mGxPi5iWBoRDihvD999a1KSEh0KlT4c5fumcpM7fMzNru06gPA5oNQCkYdhge/G0Zb85/w3qCOzCrBTT9+Ir7LsR1o2lT/ZWbhAQdKERHQ+QxODYPTqyBGDNcAC4CMe4QGwDnE/Sn/yvVpo1OiNKoIhytC5mDiKWHg4/DHHrCGUqV0gl/Hngga6rGayvOsz/Uk9GrhjCp41KeOl6FU+aKPBk7m29LP6LPi/safDtCQB+Hl61eXZeXHG8Z6B0/Hnr0gAoVrsJ7EuImJ2sMhRA3hPbtYc0a/Xr8eJhQiCVFG49vpP+y/qSbdZKENlXbMKv7LNxN7iw9BxNX/M2G5+7CN9lmNOTtIBh7UJLNCJGflH26ZEHievt2r9vBbwrElbcGk45GITO/nzunp6RmqlNHV0fv1EkPNZ3uCfGL9T73ylBtL5j8EC42caLO9GURGeBG1xFhlKxUg0otvmX+Bf0z8suAAfT1tkzrMPlDlV3g6bjIbGoq3HqrriwC0L27HrAWQlw5ST6DBIZC3MiOHrVmoDcMnYSmcuWCnXsw+iCPLnqUy6k682K94Hos6rkIP08/4tPhrp+iWDmgOZXO2Uxpe9wd5v4NJRo4+Z0IcYNSCuKXwrmRuqxFFhOUelonh8nvIYtSEB+vA0WzWf+nN1lqWMSvgNPdrMdW/Bl82zv9bQgHzGZdymTFiqymzdW86Dc4hAYVm7GrylccTS2Br3GZA0GNqWA6og/yvkMnozEcT17780+4+27r9ooV0KWLK9+IEDeHvALD/Arc17DUM7T7ymdfDaf2Xggh8jFnjvV1hw4FDwrPXT7HwO8GZgWF5f3KM6f7HPw89SjDhIMpzBzb3T4ovB34aKEEhUIUhmGA/6NQ7QCUGQN4WHaYIfYTOFobYj8DZc7nGv46IKxZ0xoUZsTqdWuZ/PtJUHg1mUzwxRdQq1ZW021Hkxn9w0V2ndlBy7MvYVJmEpQfD8UsJCNzFVPSJrgwMdfLtmoF/W2GH4YNc1w5RQjhPPmNGDreCUZ++2TEUAhxNaSmQsWKepYZQHg4dO2a/3mJqYn0Wtwrq1ahr4cvi3stpm5wXQD2xCt2PNqfJ3+abz2pErDmBag11blvQoibTcoBiHoOEtfYt3vdBuX/B155rGPMLnIwXLI8HXILhmr7wa2M8/oqCmbfPmjRQq8ztXi+dzArG/tRp9YQfvQfDcCrvhN5q2Tm1FM3qPwneN/u8JIXLugZw+fP6+1Ro/RyUiFE0RV1Kulv5B785Usp1bao57qCBIZC3Ji+/RYeseQ0CA2F48fzT22eYc7gmRXPsPa/tQC4GW7M7j6bNtXaAGBW8MmoqQyfNsp6UklgRStosx6MYvXcS4jrk1IQ/x2cewHSbbOPGlBqCAS9k3+Al7AOTrazbocuBf+HXdJdUQC2P5CBRA+DHsPDOBTiiVetCezz742JDLYFtaWJ25/6II+qer2hm7/DS375JfTrp1+7ucH27Xr9oRCiaIoUGN5oJDAU4sZ0332wVsd3vPoqvPVW/udMWDeB+TvnW7fvnUDvW3tnba/5+ifu6dsJt8waaSZgTgj02wdupZzXeSEEmBP0lMKLU0DZJJdxC4SgdyFgABgOVr6YEyHiFkg7qrf9ukPYMj3lVFw7o0frpEAWxwPd6ToijAQfT87VmE1cQBsqmk5wMLgh3lzSB/k/AaFfOLycUtCuHay35C5q0QI2bdJBohCi8K5kjaEQQhRb//1nDQoNAwYOzP+cL3Z+YRcUDmo+yC4oTIw8R5Nn+1qDQoDRntBnjQSFQriCyVePDlbdC74drO0ZF+DsYDh+GyRtzXne+desQaEpAMp/IkFhcTBxItxzT9Zm5QvpfLAoGpWRTvmI4Xgm/stJcyX6x86ynhP3JcR94/ByhgEzZ4Knp97euhVmzXJ4qBDiCklgKIS4btkmnXngAahUKe/jf/3vV95e/7b1nFoPMPru0dYDlOLEgGcIjD1vbesOjPsaStR3TqeFEI551oQKP0JYOHhUsbYnb9PBYeQgSLf830zaBhenWY8JngruIVe1uyIX7u7wzTd68bdFu/2JPPtrLOnpiVT+bxBuqWf4Jvkxvkt9wnre2aGQdtzhJWvXhnHjrNvjxkFkpKvegBA3ryIHhoZhuBuGMcowjD8NwzhgGMZawzAK8LxeCCGuXGoqfP65dXvIkLyP33N2DyNWjsBsyXrYOKQxUx6Ygslmilrc10uos3qZ9aSqwIejwb+HE3suhMiVYUDJrlB1HwS+BkYJyw4Fl+bC0VoQMwPODiCrkr1POwh46lr1WDgSFATLllmH+YARa2Josz+RjJQowg4PwEiP58mY6URTTR9gvgRn+oLKcHjJsWN1MlqAuDh4/nlXvwkhbj65BoaGYfQwDOOcYRjvONhnAn4AJgN3ArWAe4BZhmF85arOCiFEphUrrJlIw8KgY8fcjz0Td4ZByweRlJ4EQMWAinza7VO8PLysB0VFYRr2rHXbBGpKbaiYezp1IYSLmLwh6E2o+i/4PmhtN8dA1LOQskdvGz5QfrZMIS2OmjeHGTOyNk0Kpi46R+XzabgnHaLc0WHEZ3jT5cICzFgWDCb9CRfec3g5Ly/49FPr9pIl8NNPrnwDQtx88hoxbAsEAt862DcIuA9dmuJ7YBg6SEwCehuG0cHBOUII4TS2a0wGDMg9E2l8SjwDvhtAdEI0AAFeAcx7aB5lfctaD1KKhMFP4xd7wdrWH4wHvpAMpEJcS57VoeJKqLASPKrl3B/0Nng6aBfFw4ABMHhw1mZAkpkZX0ThnWrGJ24DZU+8yubU25iS+Jr1nPOvO15Til662LevdfuZZyAx0VWdF+Lmk1dg2AKIVEr97WDfEHQpi4VKqW5KqRlKqbHA4+hgsZ/zuyqEENqRI/Drr/q1yaQ/eziSlpHGsO+Hcej8IQA8TB7M7DqT6oHV7Q9ctAjf75dbt6uDevkJ8G7pgt4LIQrN70E9elj2TTAsI/3eraH0c9e2XyJ/H3+sU4la1Dmbyjvfngel8D+/lFKRM3g57mUOqDstR6TDmd5gdlzNfsoUKF1av46IgAkTXNx/IW4ieQWGIcCu7I2GYZQFMivITLbdp5QKByKA5s7qoBBCZFeQpDNKKV5b+xobjm/IapvUYRItK2YL9iIjSX92mHXbDdIn+WFUlCrKQhQrJi8o+xpUPwoVf4ZKa2RE/3pQooRebxgUlNXU9e/LPLkhDoAyZ6bifeEHOpxfQCqWWoZp/0HUCIeXCw62q4bBlCmwd6/Lei/ETSWvwDAIiHHQnhn0RSml9jjYvw8dVAohhNMVNOnMrK2zWLJnSdb2iDtG0K1eN/uDlEINGYJ7rM2PuoHg3u5dcA9CCFEMuYeAb3swPK51T0RBVagAixfbFR98edVFWvyn130HHRtDVGwUz8ZZ1yRy6TOIc7SaCZ56Cu66S79OT4ehQ8G2wpAQomjyCgzT0MFhdk0s33fkcl4cejqpEEI4XXg4ROvlglSooEcMs1t1YBXv/2l9pNy9XneG3z4854ELFmCsXGndrgnJz90CpYY6uddCCHGTa9sWJlsnmrmZFTO+vkC5S+kYKo1yR4byxYWWrM3oYz3n7CBIO5njUiaTTkSTubZ840aYN8/Vb0CIG19egWEE0MQwDM9s7e3Q6wv/yuW8YCDKCX0TQogc8ks6s/30dl5a/VLWdsuKLZl4/0SM7FkLT59GPWezPskNeBe8qswAI5dMNkIIIYruhRfgsceyNkvHpTJr4UU80xVuGXGUPzyAhyPfIs6orA8wx0LkEw5LWNSvD6NtytAOH65HEjdvBqVc/UaEuDHlFRj+gs5KmrWs1zCMtkBry+b32U8w9CevxsBpJ/ZRCCEAOHwY1q3Trx0lnTkWc4yh4UNJzUgFoHqZ6szsOhNPt2zPt5SCwYMxYmOtbYMhqWVf8LnLhe9ACCFuYoYBc+fqqM7ilojLvL7qEgAeqafwPTSKzuc+Q2V+RE38DS46XvM9fjxUsySlTUmB+fPh9tuhcWOYOVPXOxRCFFxegeE04DLwomEYJw3D2An8bNm3RinlaKlvG6AMsMmpvRRCCOyTznTsCBUrWrdjkmIY8N0AYpL0esEy3mWY+9BcArwCcl5o/nz48Ufrdm1IHuqHd/nJOY8VQgjhPH5+sHw5+PtnNfXceJGHt+sspF6Juzl4cDGzUl62nhM9HpJzrmDy9oaVK6FJE/v2f/7RpSxCQ3W1jB25LX4SQtjJNTBUSp0GOgNngTB0JlJ34B/gyVxOy0ztt9Z5XRRCCP00OLekMynpKQwNH8qxmGMAlHAvwZyH5lCplIN0pSdPwvPPW7fdgXeB0LfAvbwrui6EEMJWzZqwYIFd08TlMdQ/lQKAb+xaXv3HjRPGbZa9mSUsEnJcql492L4dtmyB/v11sJgpIUE/UGzWDJo314OVCTkvIYSwyGvEEKXUH0BVdDH7PkAroKlS6mwup8wHugO/Oa+LQgihk86cP69f2yadMSszY34aw/bT2wEwMJjacSq3htya8yJKwaBB9vOLhsKF+vXxChyW83ghhBCu0bkzvPpq1qZbahpffpNA6QS9ntD/3Ffcs7sHGYafPiD1EES94PBShqFLJc6bB2fOwPTpdrNVAR08DhqkRxGffRZ273bJuxLiupZnYAiglEpVSv2qlFqklNqoVO5LepVSK5VSK5RSqc7tphDiZmebdGbgQGvW82kbp7HygDWz6JjWY+hQq4Pji8ybBz//bN2uCwyGgND/Sep7IYS42l5/3S61dKmoWL5anoHJrD9qmo9/St9jNg/tLs2B+OV5XrJUKRg2DPbsgQ0b4PHHdSnFTHFxMGMGNGoEd9wBX34JSUlOfVdCXLfyDQyFEOJaO3QI1q/Xr22Tzizds5QZm611r3o36s3AZgMdX+T4cRg50rrtAbwLJ3x74u7XxiX9FkIIkQc3Nz2lNDODDFD3n1NM/FMnDDNQ/PXv9yyK6WQ9J3IgpJ3J99KGAXfeCV99BadPwwcfQK1a9sf89Rf06wdhYTph6oEDTnlXQly3JDAUQtg5cwYSE691L+zZJp158EE9lXTj8Y2MXzM+q7111da83u71nGUpQE8hHTgQ4uOtbc9AYi1fKlZ4P+fxQgghro4yZeC77+wWBz6y6iA9jvgAYDIn8/KWsxxKsmQbM1+0lLAoeEX7wED9XPDAAZ3Z+rHHwMNmkkhMDHz4IdStC23awKJFel27EDebXANDwzAyruAr/Wq+CSGEc4wbp5+cBgdD794621vqNZ4YnpmCPNPgwXDo/CGeWfEM6Wb9o6ZuUF0+7vwx7qZc6g/Ong1rbXJi1QcGwtmSr2F4VnBZ34UQQhRAo0b657SNSQsiqHlRB4um9Bi6bapITKplDUHir3BxWqFvYxjQti188w2cOgWTJkHVqvbH/P67/v1XoYKuk3jkSJHekRDXJSO3JYOGYRT8UYwDSqliNRrZrFkztX379mvdDSGKrT//hLvvztleujT06AG9ekHr1ta1fVfLN9/oe4MuT7F1bzSPLHqIM/F6KlF5v/J82+dbQkqGOL5ARATccos1FZ0HsAxO1ahNhTq7wfB0fJ4QQoira8QI+PjjrM2E6lW47SkPEkvohDTVygSxquUWSrgBeECVreDlINFYIZjN+rnhp5/C999DRkbOY+69V2fC7trVfqRRiOuRYRg7lFLNHO7LJzBUwDZ0ttEVQIHHDpRSFwrdUxeSwFCI3KWmwq23wv79eR8XEgKPPqoDtRYt9NNXV2vbFn77Tb8e/2Yie6r2Zk/UHgB8PXxZ3GsxdYPrOj7ZbNa/0TMXKAKMBAbBsaCfqRLY3qV9F0IIUQhpadCunX5SabG/7R08+EBk1i+c9mGefHLrAUwG4FkHquwAk49Tbn/mjM5RNmeOrmyUXfnyuiTGoEFQpYpTbinEVZdXYJjXqN5g4C+gBfAJsAd4DaiklLqQ35fT34UQwmXef98aFPr5wU8/6Sk0lbKVAYyMhI8+gttugxo14JVXYO9e1/Xr4EFrUOjmnsGJmi9kBYVuhhsfd/4496AQYOZM+6CwIfAU7OAhCQqFEKK48fCAJUv0U0iLuus38fI+66jgL6dTmXowWG+kHoBzLzrt9qGhuoJGRASsWqXXtJtsPimfPQsTJ+pcOR076hHGdFk8JW4guY4YZh1gGDWBp4C+6EL3Ch0kzgcWKqWiXdpBwwgBxgEdLfe/DGwFpiml1uZ1ri0ZMRTCsSNHoEED60L7adOs9d/NZp21bdEi/bs6Opf/7Q0a6FHEnj3tkstdsRdf1JnkAJo//zYXwqwV7ifcO4Het/bO/eT//oOGDa2ZdDyB7yCxmjeXKu4nxK+y8zoqhBDCeTZt0llg0tIAUCYT/V7sycagzVmHTGwYzWOVLAnFwr6Hkp1d0pUTJ2DuXP0VGZlzf1iYHkEcMECvSxSiuCvSVFIHFzGA9uggsStQAkgDfgC+AFYppRzMzC7QtfcB3ymlxmdrbwCsAYKB7JPWFPCSUmpqQe4hgaEQOSkF7dtb87I0aQJbtoC7gxwu6ek6m9uiRTqBnG2NeFstW+og8dFH7R76Flpysv4le+EC+N/xJWW7v5m1b2CzgYxrMy73k81mPQf1jz+sbS8B/WGN2wTuqzk+11OFEEIUAzNm6Er0FmllArnjpXZcdNef5UwGzGseyd3BSeBWFqruBvcr+KWTj7Q0PYo4a5Z9OdxMJhM8+aTutm3dRCGKG6cEhtkuGAD0RgeJzdBB2mGlVJ0idtAMzFdK9bdpM9Ajk/WAzcC7wAEgEHgMGG65bwul1N+5XHcwekoslSpVanr8+PGidE+IG9bChbr4L+hfalu3QtOm+Z+XnAyrV+sgceVKvZ2dyaQf+PbqpZPXlC5duL4tWqQzw/nUXUe5J4dgmHQ+rA41OzC9y3RMRh4z4T/+WCcxyHQrsACOUp3AmnsJ8PQqXGeEEEJcXUrBU0/BF19kNZ2qfyttBoai0nXBQV93xeI7TlPXPxV87oGw78AtwOVdO3pUr0OcNy/nTJoxY3S2UyGKK6cHhjYXrgu8BzwInFdKBRfxOo4Cw/bAT8AudPCXnu2cUcD7wDyl1KD87iEjhkLYu3hR12w6d05vjxih6zgVVnw8rFihA7lffnG83sLDAzp00EFily7g65v/ddu0gb+O7CX0mZ6YPJMAuDXkVhY+uhAvjzwCu8OHderzJH2OKgHGcqAqhJdYRbeqnXI/VwghRPGRlKSr1P9tff6/ouNjPNf+JO5pZwEo55XOsjtPE+KdAe6hUG4GlOx6VbqXmgrh4fDJJ9YJKiaTzp1zxx1XpQtCFFpRk8/kdjF/wzCGGIbxF7AXHRReAOZdWTdzuAs9IvhK9qDQ4kPgDOAgwb4QIj9jx1qDwrAwmDChaNcpWVKPOv7wg16Y/+mnuqyFbcbStDQ9sti7t66R2KuXXrSfW43EAwdgw64zlH9qUFZQWDGgIrO6zco7KMzI0E+YLUEhgPE8UBXWpnXmgcoSFAohxHXD2xuWLYMyZbIWmZN1AAAgAElEQVSauv64mK6H22N28wMgKtmdgVvLE59mQPoZON0NTj8K6Wdd3j1PT71sYv16nUwV9EqGfv2sFZKEuJ4UKDA0tPaGYSwCzgIzgKbo9YU9gFClVB4LfoqknOX7Tkc7LesZ9wCy1FeIQtqwQU+DyTR9ug7wrlRgoK719NtvOtX3Bx9A8+b2xyQm6tqEXbtCuXIwcCD8+qt97agZc+MpP2Ag7gE6cvUv4c/ch+ZS1rds3h346CPYuNG63RToC8mqBAmBH1KiWFVXFUIIka+qVfWUFJunjdNmv0PltGdQhl4QfyC+BM/urMilVMsP+filcLQuxH6mp6S6mMkEn30G/v56+8gRPaVUiOtNnh+TDMOoZRjGROAEsBq9tu8/YDRQUSnVRSm1XCmV5oK+XbZ8zyXFBaBHKq9CJTUhbhypqTp4y9SlC3Tr5vz7hIXByJF63eLhw/DWW3rqqq3YWL1G4957daKZESNg/e9phCcOp0TIQQDcDA9mdp1JjcAaed/w4EFdP8NCeQHvAG7wZdoYOoc4MV2qEEKIq6d9e3j77axNt7Q0lk55CwJeymrbGO1Opw212XrBMqvEHAtnB8DJeyH1P5d3sVIl/Wwy0yefWBO7CXG9yKvA/SagpWXzErAI+Fwp5fSFepY1hhuAuTbN96BLZNRTSh3M5bxfgLpKqYr53UPWGAqhTZxojZ98fWHfvpz1Cl1FKdi9W48YLloEdvmgTGn43bqKUm1n4Vn+cFbze/e/z8O3PJT3hTMy4K67YLM1lTkvA33hWEZlIkL20baMcwogCyGEuAbMZp3JLDw8q2lDo7vpPrI7/uem2xxo8GQNxdhaR/GwDH+k4c0mz7fY7fE8biZ3PAxwz/blsM2U/3G2274m6N5dL5UAqFgR9uyBANfnwxGiwIqUfMYSrClgOxAOpBTmpgUtI5HtXnbNlrbnlFKfODjHBJwDDiil7srvHhIYCqFL+zVoYM0iOnUqvPDCtemLUjqOW/BNMisOLsXUZA4eZU7bHXNr+nMsGzsilyvYeP99GD3aeu1mYHwBmODNtOW8fosLhkSFEEJcXXFxen3CoUNZTdMefp7xvTsQdOxl3DJis9qDS5ZmYdM9VPOzLmbfntaUgZfm8k/6rS7pXiNfWBACbW7VpZZArzecP98ltxOiSK40MCz0/QCllHIrRAc/z2P330qpjx2c0wlYCXyolBqZ3z0kMBQ3O6V0ZtBfftHbjRvraZ6OahZeDXHJcSzYtYDPd3zOxaSLdvvMyb6ovwezZcazlCuXz2zx/fv1m0nRz66Ujwkj3AwV4aeU+wmptppGJWXGuRBC3BD27dMFcy9fzmrqNf5rlrZqS1DES/jEb7Iea/Li2XrwQuV9WUsU05Ub7ye8xFuXXyMZb6d3r10pGHQEej5ibQsP1+vqhSgOihoY5hWs5Usp9dSVnJ8fwzAaAVWAf5RSx/I7XgJDcbPLrAsIeqH8li3QzOGPBdeKTojm8x2fs3DXQi6nXrbbV8a7DI836set7n2pXyOAsvnkmiE9Xacy37rV2vYq0BtSlQfj2cvkurWc/h6EEEJcQ99+C49YI690b2+WrNjM2doN2HFgLlv3TMVsk/6icWhVPm2wkbKe1qK7Z6nJXPMc9qrWpCuyvtJsXhemLdYmf/4rleDoeP17F3Q27r17ISjI5X8yQuTLZXUMrycSGIqbWUwM1KljLU8xfLiuAX81nYg9wdxtc1m6dympGfZ1KkJKhjCw+UAebfAoPp6FWAs4aRKMsyZEzmjpgdtnaWCCyQljeaz+u1SWWvZCCHHjGTMGJk+2bleoAIMHQ6dO7A314IUfR3L04tGs3SF+QXzQDFr6bbG/TqnBEPQeuJW6ou68HgFv2aybX1QFRt4BkZF6u0cPWLrUvpSTENeCBIZIYChubkOGwOzZ+nVoqJ59mZlW29UORh/k062f8sOBH8hQGXb7qpepzuAWg+lStwuebp6Fu/DevdC0aVYxROXrgbEiDcLgZEYFZnoeYGJNX2e9DSGEEMVJerpeH/Hrrzn3hYSQfv99LK54mfc8d5LgpbPQGBgMbXQbIyquxMM26b17CJT7BEp2L3J3MhR03A2/xOjt0u4w9TI89YD1mIULrTN3hLhWrmpgaEkK008pdUVTUZ1NAkNxs9q0Sc+2zLRsGTyUT5JPZ9hxegefbvmUdUfX5djXsHxDhrYcyn017sNkFKG4YFoa3H477NiR1WR+w8D0mP559mTcEqY2foQyHkXuvhBCiOIuOlqviThxItdDzB7ubK/qzZpaHqyv60NEkAcNy9djWjMzVYzV9geX7AHlputAsSjdSYUmO+CUJV1js5LQcA58Nktvlyqln2mGhRXp8kI4xVUJDC0BYV9gPFCtMMlnini/d4AQdKKbAfkdL4GhuBmlpUGTJvoXEUDnzrBiheumsiil+D3id2ZtncXWU1tz7L+z8p0MaTGEOyrdgXElnXj7bXj11axN852lMM2JBQN+TbmHnaXW8lJlma8jhBA3vHPn4J13dI2IY8fyPfx4oDu/1fFhU4PS3P/4w3QPXohhPms9wFQKgqdAQP8i/bL86xLcvUuvOwQYUBbWdYGICL3doQP8+KNMKRXXzhUFhoZhhALtgXJAFPCLUupMtmN6A28A1dFZSaOUUkV73FJAhmHsB2pTwAyoEhiKm5HtEjxX1izMMGew+tBqZm2dxb5z++z2GRi0r9meoS2G0jCk4ZXfbPdu/YQ4zZJYoKQXhCdDKKQpdzrE/cMPzerh5dJHU0IIIYoVpeDAAfjhBx15/fmnnm6ah0QPgyONK1Gzawjet2/Www2ZfNpC+dngWaPQXfn4FIw4Yt1+GXj3Ht1FgFmz9HJIIa6FIgeGhmGMACYBtot/UoERSqnZhmFUAxYCLdABYTwwBZiqlEpwUv9z69tELP+FC5IBVQJDcbM5ehTq17fWLJwyBUaNcu49UtJTWL5vObO3zuZ47HG7fe4md7rW7crgFoOpEVj4X6wOpaVBixawa1dWk/ntAEw9LgEwJWEUQWFT6FfeObcTQghxnbp0Cdas0YHi6tUQFZX/OXU8oVUqtAYaAR5eUPZNKDMSjILXdlIKeu6DJdF628cEPX6Fr97S276++hlntWqFfldCXLGilqu4G/jNshkPHAICgKroIPAB4Ev0SGIaMAN4Ryl13pmddxYJDMXNRCl44AH4+We93agRbN/uvJqFl1Mvs+ifRXy2/TPOJZyz2+fl7sVjDR9jYLOBhPqHOueGmd58E954w7rdtgp8cgwMOJMRQo/EA2xo5o+bTNERQgiRyWyGnTt1kPjDD7BtW/7nBAB3AXcD7W6B+l+AV+MC3zI+HZrvgINJeruWF6ihcPgfvd2qFfz2my4fJcTVVNTAcDHwCDrge1EplWxprw8sAyoBXsAe4FGl1EEX9N1pJDAUN5PFi6FnT/3aMGDzZj3QdqUuJl7ki51f8NWur7iUfMlun38Jf55o/AT9mvSjjE+ZK79Zdrt2QfPm1qlBASVR4YkY5XWm0z6xC3i8Zh8eCHT+rYUQQtxAoqLgp584u3gefus34pdszvt4Az2C2KEVPPweNLmtQIsE/02AFjsg0XL5e91gXVswWxJ0f/ABjBx5Re9EiEIramB4HFBAdaXsc8wbhvEA8AOQhE40U4Dx+WtLAkNxs4iN1TULM2fNDBsG06df2TXPxJ1h3vZ5LN69mKT0JLt9wb7B9G/Wn16NeuHn6XdlN8pNaqoOCnfvtrZNqQud9gPwR2or3jD/zq+NDFnQL4QQosCiYk4x96P+BP22lTYHEqkVlZb/SSGB0Kk7dOwI9/6fvfsOj6roAjj8u5veICGEBAi9d0IRpCNNiiC9g/QqCChdihT5kA7SFUWldxClSO+dANJDTSC09J7d+/1xw26WHiTZBM77PDzszJ25mash2bMzc6YmuLi8tOkfgdDuoqlc5wps66G9trOD06ehUKH/+BBCJMHbBoZRwN+qqj53qIuiKK7AE2Cbqqp1n+ucQhRFOQyUVVX1tQvkJDAUH4pevWD+fO11lixawpn06d/uXtcfX2fBsQVsvLiReIP5Jv7srtnpXrY7TYo0wc7a7j+O+jVGjYJx40zlOqVg+ilQIF61otTjU/xcvDhlUuhsRiGEEO8Pg2rgpxM/MXX/VDI9iqTapUiqX4ykol8strH6V3e2sYGqVaF+fWjWDLy9n2vS6wrMT0jbaK1A7hlwZYNWLlNGO1bKRo5XEinkbQNDA/CLqqqdX3H91zdJ/JJcEgLDjyQrqRCaw4ehQgVTec0aaNo06ffxve/L/KPz2X51OyrmPyMKeRSiZ7me1M1fFytdCqT+PHkSypUDfcIvZ1dX1C0OKO73AJgZ0Y8jDjNZXjj5hyKEEOL9dT7wPAP+HIDfEz8A7GMN1A1w4JvQQnju2Qt3Hr/6Bs7OsG4d1KplVh1jgEqn4USYVvbUwZNmEJeQnGbsWO3zTyFSQnIGhi+9nhIkMBTC5NkzC+vXh82bk3ZWkt8TP8b8M4aDtw4+d62sd1l6ftSTqrmq/rczCJMiJgZKl4YLF0x1cxpAjS0ABOozUfTxZY6WdSW3Q8oMSQghxPsrMjaSiXsnsvzscmOdgkLPj3rQP10pbNZ8BdvPwyngRZOJGTJoiW5y5DCrvhkFpU5CUMLim3whcLUJYNASwx09qv0OFyK5vSowfN0STK+E7KRJvq6q6r4kDLDJm7Z9RjJkuBAibZo+3RQUOjrCnDlJCwoDQgNou7Ltc1lGP8n9CT3K9aBM1hf+DEleY8eaB4UNPkH95G+ePtaQ8P/RJrMEhUIIId4NR1tHxtcaT5WcVRi2bRjB0cGoqMw7Np8DnsWYPmgTuYacgau9YF8g7AX2A08nE5880ZaUHjigbSJMkNMBfisEDc5p5avpwXsE3B2n5VTr0EHLHm5vn9JPLITJ62YMX37I4aupb7Lv7x18LQU54F4IbtzQziyMSsgL88MP8PXXb94/PDacVstbcfGhtkNep+hoULABPT7qQUGPgskw4jdw/DiUL6+lGQftU9jtJcBpNwCHY8vzachBrpXT4WH7ivsIIYQQbyEwPJCvt37NoduHjHWONo6M+mQUzQrVRHk4BEIWQQzQBvg3UedevWDu3OfuOdIPJtzWXiuA7SiI2a+Vv/kGJk9OrqcRQvO2S0lv8vaBIaqq5nrTtoqiPJ2Mf+NZxgSlAGcJDMWHTFW1xGh//62VS5TQYqo33cgeb4in54ae7PbTAi5rnTVLmi2hQvYKr+mZjKKjtTU1FxOlcls8ACpOB8CgKpR5fIKm2UoxIsdL7iGEEEL8R4kT08QZTBlL6+avy4TaE0ivPw33u8ONq9AUCE3UeelSaN/e7H56FeqchX+CtbJTPES0BR5oq3z274eKFZP9scQH7K0Cw5SkKMpFID+QV1XVG0noJ3sMxQdv1Spo2VJ7rShaAppy5d68/3e7vuPXU78ay/+r8z+aFWv2jkeZREOGmH9s+nlDmHwG9NrHrPMiezI+eh5Xy4FjCuS/EUII8WF7NjENgJeLF1PrTqW8d1G4VRG2+UKvRJ0cHLTNg8WKmd3rQSz4nICAWK2czh9COwFxkCePdmyvczKd/iTEqwJDXUoP5iWeRmyy7VaIJAgOhv79TeVevZIWFC49tdQsKOxVrpdlg0KDQcuYM2WKqc7dHcbnNQaFjwzujAibwNicEhQKIYRIGUU9i7Kp/SZal2htrLsfdp92q9rxw4F5xHqthhru0CNRp6goLTV4aKjZvTLZwqoi2tEVAKFZwTbhd/n169pno0JYQmoJDI+jLbUum8R+cpS1+KCNGAH372uvvbxg4sQ377vbbzfjdpvOBqybvy4DKw18xyN8A5GRsGkTdO0KmTNDw4amfYUAs0aD9Y/G4vCwiXg5ZOALr5QfqhBCiA+Xg40D42uNZ16jebg5uAGgojL/2HxarBnMDcfZ8KUOyifqdPUqdOqk7ftIpGJ6mJzbVI6tD3yivZ47F3bsSN5nEeJFUstS0vxok+/nVFX9OQn9fIB0qqrufV1bWUoq3jdHjmhnFj79J7xqFTRv/mZ9Lz28RItlLYiIiwCghFcJlrVchr1NCqVDCwyELVu0gHDHDlPWnGc1bw7ToiF8MwDH48pQ/vER1he1omHGlBmqEEII8awXJaZxtnVmWd0GFHkwUdtvGJiow9SpMND8w1dVheYXYO0jrWwVC/ruwC3ImlXLNO7qmuyPIj4wqX6PYUqQwFC8T+LioEwZ8PXVyvXqaXHWmxxP8TDiIY1/b8y9MO2A+CwuWVjXbh0eTh7JN2BVhUuXYONGLRg8cuS5T0+fU68ezGsPkaZlO+UeH8HWsRz7SibtKA4hhBDiXTOoBn4+8TNT9k8xJqbxdPZkXc0ceB1fAR2AhHMLsbKC3buhcmWze4TGQ5mTcDXh81Gru6DvBkRrR1j8+itCvFNpYY+hECIJZswwBYUODvDjj28WKEXFRdF9fXdjUOhs68ziJouTJyiMj4d9+7RzM/Lnh8KFYdgwLTvOi4JCKyuoXl07kPHaNdi8FuJGGi8vjuzCsbhyTM4tQaEQQgjL0yk6upbtyuo2q3GxcwG0mcTuh8KIKFsGBidqrNdDixam/R8J0lnD2iLgkPCOXO8NJBw3tXQpbNiQ/M8hxFMSGAqRxty8CaNHm8pjxkDOnK/vZ1ANDNo6CN/7WkRppVgx+7PZFPAo8O4GFx4Oa9dCx47apseqVbXlM9euvbi9i4u2XPT33+HBA9i1C776SkvL9mQqxF0HIMjgyrCw72mSET5O/+6GK4QQQvxXxbyK8WPDH7HWaUd4X3hwka/OFkDfIRPUTdTw/n1o1Ur74DRxf2eYnz9RRQ3gc+1l9+7ar0chUoIEhkKkIaoKffqYtuQVKwYDBrxZ3yn7p7Dt6jZjeXSN0VTJVeW/DyogAObP15Z+urtDs2bax5yPH7+4vbc39O4N27bBw4fa5si2bbUD7J+KuwWPJxiLI8PHE6R68H3uF9xPCCGEsLCKOSoyrpYpoduuG4eZcLMJjLOGxL+79u7VMsc9o4MXdMucqKIPUEj7Ndmr1+t3XwjxLsgeQyHSkDVrTAlmFAUOHoSPP359v1XnVjFs2zBjuVPpToysPvK5dgExsOgeOOoglz3kdtD+drNJ1EhV4dw5ba/gxo3wJv+ufHy0bKMNG2qvX7cW1L8ZhK0F4ExcCco8PkH3LNbMzf/qbkIIIYQlTd43mQXHFhjLoz+uRYegBdASiEzUcP16+Pxzs77Reqh4Gk6FJ1QEAt2BUPjtN2jXLpkHLz4IknwGCQxF2hcSAoUKwT1teyC9emkprV/n0O1DdFrTiXiDtnTlk9yfMP/z+VjpzA8BvBUNVU7D7Zjn75GROJr+u4/PDm3i472byHD35qu/qI0NVKsGjRrBZ59B9uyvHyiAIRKCF8MD0+GMFR8f4Ky+ItfLg6ftm91GCCGEsASDaqDf5n78deUvQNuHuLBqSarvXWPcOwhAunRw8iTkzWvW/0YUlDoJwU9Xmx4DhkL6dFqWUm/vFHkM8R57VWBondKDEUK8nREjTEHhm55ZeP3xdfps7GMMCgtnKsyMBjOeCwrvRsMnZ8yDwnThIdQ99hcND26i3tGtuEaEvPJrhbm4cq5KPfw/bUR87Tp4Z0pPbgfIbPsGa9Zjr0DQfAhZAoZgY/WvUR04FFeR0TkkKBRCCJH66RQdU+pOISA0gLP3z2JQDfQ/eImVNctRqN1R+D2hYWgoNG2qJWRzdDT2z+UASwtCw/MJFR8B7SFkqXbc719/SQI2kXxkxlCINODYMShf3rTHYOVKLbnZqzyOfEyzP5pxO+Q2oKXQXtt2LZldMpu1uxcD1c7AlShwjgyj8/al9Di+gfzH9mD9zAb5Z93wysnGio3YVKEh+4tXJt7a5rk2dgrktNd+2eWyh9wJr3PbxZFfvwmnsHkQ+c9z/W7qc1D+8RFUKy+ulQMX+RhLCCFEGvEo4hFN/miCf6g/AF7OmVj30R08O/vD2UQNO3aEJUuei/aG+cGk2wkFAzAEOAHz5kHPninxBOJ9JUtJkcBQpF3x8dqZhWcTfpF8+ils3frqTwxj4mNov7o9J/1PAuBg7cCK1iso6lnUrN3DWC0o/DcS8t++zNZh9cgT4PfK8fiX+Iij1RqypWJDdmUtyp1YBUMSnieLzp9ujovo5rCIrFYBz10PUXIzNbwnc8K7EKRm4Md80DtrEr6AEEIIkQpceXSF5suaEx6rbRos4pGLld4HcWgeDUGJGi5cCN26mfWNN0AtX9jzdBFNCNANnCK19wN58qTII4j3kASGSGAo0q6pU7WjAEE7s/DCBciV6+XtVVVl4NaBbLq4CQAFhXmfz6NW3lpm7Z7EactHz0ZAhXMH2TSyIe6hT56/oZ0d1Kih7Rds0ACyZDG7HGfQlqD6RcGNaO3P09d+UfA4HhQMfGK7i96Oc2lotwlrRW92D72qY0tMA+ZF9mJ7bG3UhMWn+RzgQlmwkfzJQggh0qADNw/QeW1n9Kr2e69mjoLMDd2KVTfg6VtwOzstm1zp0mZ978do+w3vxSZUXAC+gkrlYc8e7fhfIZJKAkMkMBRp061b2rnwkQmZzCZNgiFDXt1n1qFZzDw001geXm04Xcp0MWsTHAc1z8LJcGiydy1/TGiLfVyiDYZubqYsorVrg7Pz2z2A/gnRT35BCZmPXfzV5y7f13uyKKobiyK7ccfwfIKaNUWgqcfbfWkhhBAiNVjhu4IR201HVHQulIcR23fArESNcubUktEkProJ2B8M1c+A8ePUtcAc+OEH04fGQiSFBIZIYCjSHlXVEnr++adWLloUTp3SEn6+zMZ/NzJw60BjuXWJ1oyrOQ4l0brTsHio7QtHQqH/mhlMmzsQXeKfA2XKwJYt4On59gOPPg5BcyFsJajRz7dxrAauvVCdP+d+nK35LGO0dmxGDTf4JptsshdCCJH2Tdo7iUXHFxnLY0u6027ccdiXqFG9erB5M+jMl8lMuQ3fJN7l8R3YHtTeExQpkrzjFu8fCQyRwFCkPWvXamfFP3Xo0KvPLDzhf4L2q9oTq9fWnFTKUYnFTRZjY2WKJCP0UNcXDgQZmDpvEAPWzDC/SYMGsGIFODklfcCGCAhdDkHzIObU89d16SD9F+DaE+wKJf3+QgghRBplUA303dSXbVe3AVr20iWF46jU7Rb4J2o4fryWhjwRVYUmF2DDo4SKSKAnlPKAI0de/YGxEM96VWAoO3eESIVCQ6FfP1O5R49XB4W3gm/Ra0MvY1CYzz0fcxrOMQsKo/TQ8BwcexjNyu9aPh8U9uypHbib1KAw5iIE9odrWeF+t+eDQrtS4LUI8gaA50wJCoUQQnxwdIqOqfWmUtyrOKAFir2vOHFjojMkDuy+/RZ27jTrqyiwpADksU+ocATGwql/3+zoKiHelASGQqRCI0dCQELCTk9P+P77l7cNiQ6h67quPInSEse4O7qzuMliXOxcjG1iDNqnjWduPWbnoJo037vG/Cbffw9z54L1G54JocZC6Cq4XR1uFIagWWBIdM6hYg/pOkKOo5DzBLh2Bd1bzEIKIYQQ7wkHGwcWNl5IFhctiVtEXDTtI/MTOjTRnglVhdat4e5ds76uNrC2KNg/feeeCxgI48ZrWxOFeBckMBQilTl+HObMMZVnzNBywbxIrD6W3ht74/dE23xga2XLgs8X4J3e29TGAC0uwKULNzj4ZUUqnT9ouoGNDfz+Owwd+mab+eLuwMNv4VoOCGgJkXvMr9vkg0xTIa8/ZPkFHD6STYJCCCFEAg8nDxY3WYyzrZbU7V54MO1zliK+YaJGjx5B8+YQG2vWt4QzzM2XqKIW6OtChw4Q/YLt/EIklQSGQqQi8fHQvbvpIPs6daBlyxe3VVWV0TtHc+TOEWPdD3V/wCeLj+l+BmjzL/gfOsGRPuUpeOey6Qbp0sHff0Pbtq8elGqA8L/hbiO4nhMejwf9/UQNrMC5MWTbDrkvQYaBYJXhZXcTQgghPmgFPAow+7PZWCnaeRPnnwQxoHEx1AKJGh058sK0o50yQ2evRBV94d94bQWqEP+VBIZCpCKzZsGZM9pre3ttdefLJtwWHl/IqnOrjOWBlQbSoGADY1mvQsdLELX5T/Z+VRXPoAemzt7e2plJn3zy8sHEP4LHP4BffrhbF8I3QeKj7K2zgPtoyHMLvNeBUy1Q5EeKEEII8TpVclVhTI0xxvLWRxHM/yo7JD4davZsLSHcM+bkg5JP29kCY2HKIti/PzlHLD4E8i5OiFTi9m0YNcpUHj0acud+cdttV7Yxed9kY7lx4cb0LtfbWDao0PUyOP20kE0jG+IUHWnqXLy49klk0aLP31hVIeowBHSA697wcDDEXTdv41gDsq6FPDfBYwzYZE36wwohhBAfuDYl29CltOmc4Snh1uwblN68Udeu8O+/ZlUOVto5v+mfHnDvBQyFjp0gPDx5xyzebxIYCpFK9O8PERHa6yJFYNCgF7fzvedrdlbhR94fMaH2BONZhaoKvS+r5B0/goXTemBlSDTLV6uW9pFi1hcEc5EH4XY1uFUBQn8DNdGB9zo3cBsAuS9D9p3g0gQUyY8thBBC/BdDqg6hZt6axnJXFw/utEqUCC4iApo2hbAws355HOCXgokqysON8vDNN8k8YPFek8BQiFRg3z7YsMFUXrDgxecSBYQG0H1Dd6LjtV3mOd1yMrfRXOys7QAtKBz0byyVvmzPiD+eyWHdsSP8+ae2tzCx6LNwpwHcrgRR+8yv2ZcFr58h713wnAa2+f/rowohhBAigZXOiun1plPUU1vFo1cNNCqbm0ifRPtILl2Cbt1MCQgSfO4B32RLVNEJ5h+DjRtTYODivSSBoRAWpqoweLCp3K4dVKz4fLuwmDC6ruvKw4iHALjau7K4yWLcHNyM94JOP0AAACAASURBVBl9NoT67evSbucf5p1HjYIlS8yjzdir4N8abpaEiD8TNbaG9J0gx3HIeQxcO4HO8R09rRBCCCESc7R1ZFHjRWR2yQxAiCGe1s3zoM+YqNHKldqew2dMzAVVnq4+tQJGQtvBWiwpRFJJYCiEha1dC0ePaq9tbWH8+OfbxBvi6b+lP5cfaVlFbXQ2zG00l1xuuYxtphy6Q/MmlahxepexTrWygsWLYexYUxabuLtwrzv4FYKwxJvaFUjXTsssmvlncCjzrh9VCCGEEC+QyTmT2TEW520MfNs5K6pVokaDBsHhw2b9rHWwojBkerr61A0iJkDdXhASghBJIoGhEBYUFwfDh5vKX34JOXI832787vHsvbHXWJ5QewLlspUzlhf+5Uvrzz+m2I3zxjrVyQll82bokrCxPf4RBA4Cv7wQsgjQm76AcyPIeRay/Aa2ed7V4wkhhBDiDRX0KMjMBjPRJWT4Xulhx7qWiZLRxMdD82bw4IFZv8x2sKYo2D+tyAg3+0PDgZA4zYAQryOBoRAWtGgRXL2qvXZ1NQ8Sn/r11K/8dvo3Y7l3+d40LdrUWF61bCetmlXC+5G/sU718kLZtw/q1gV9KDwaC365IWiaeVIZx+qQ4zB4bwD7Yu/8+YQQQgjx5qrlrsboT0Yby4NLZuByOVtTA/8AaNMG9HqzfpVd4e+SYP80EHSFfZ9Dj+nJP2bx/pDAUAgLCQvTVng+NWwYZHjmXPjd13czfrdpbWn9AvUZUHGAsbx9xlIad6hLukhTtjJDoUIohw9DyULwZJoWED4aA4ZEGc3sy0K2HZDtH3Ao/64fTQghhBBvqZ1POzqV7qQVFIUW9bMQmjVRMpp//tHOtHpGVVfYXRrs4hIqXGBxQfj+z+eaCvFCEhgKYSFTp5pWg3h7a8tIE7v44CL9t/THoGof//lk9mHyp5O1JSaqyrHB46k9oCM2+nhjH33lKugO7AHXHeCXDx4MAv1j001tC0PWdZDjKDjVNO07FEIIIUSqMazqMGrm0Y6xCHfQ0aZVVvR2iRpMmKBlGn9G+fSwryzYPD2+2AmGW8NPZ5N/zCLtk8BQCAu4fx+mTDGVx40DBwdTOTA8kK7ruxIRpx1s6J3Om/mfz8fexh7i47nSrjsf/fCt2T3jmjXHak0XCKoE97tDvGlpKTY5IfOvkMsXXBpLQCiEEEKkYlY6K6bVn0aRTEUAuOhly6immcwbtWsDN2481/cjV9hdAqyCEyrsoNsDWHE7mQct0jwJDIWwgO++Mx1mX6wYtG9vuhYZG0n39d25H3YfAGdbZxY1WURGp4wQHk5AnYbkX7bY7H6xXzbBZtJleNIR4q6aLlh5gudsyHUJ0ncAxQohhBBCpH5Otk4sbLwQL2cvAFb4OLOhkoupQXAoNGsC0dHP9a2YFdZmAyVhZZJqA22uwsrAlBi5SKskMBQihV2+DAsXmsqTJoFVQrxmUA0M3DqQ84FadlErxYo5DeeQP2N+uH+foIpVybLrL2Nfg6KgH5Mb297rIM7XdFOdK3hMhDzXwa0v6BKvPxFCCCFEWuDl4sXiJotxsnECYFj9jFzLkehM4lNnnt+LkqBRaZgBkLCASLWC1v/C0vvJO2aRdklgKEQKGz7clEysWjUtcehTk/dNZse1HcbymJpjqJyzMly6RES5j3HzPWW8prfToZupYtXSz3QDxRHch0EeP+1vnVPyPowQQgghklWhTIWY+Zl2jEWstULnNl6EOyfaErJ4Mfzyywv79msB3S8Ct7SyqkDHS7AgINmHLdIgCQyFSEGHD8O6daby5Mmm7X4rfVey6Pgi47UuZbrQpkQb2L+f2I8r4HT7pqmjK1gtMUCtpxU24NpXmyH0mAhWbsn9KEIIIYRIIdVzV+fb6lpuAf8MNvRr6YmaOF1Arx5w9sUZZn4cA5XXAtdNdT2vwIw7yTZckUZJYChEClFVGDzYVG7ZEsqW1V773vdlzD9jjNdq5q3JkCpDYPVq9LVqYRscZOqYHVgO+ADoIF1HyH0ZvGaDtVfyP4gQQgghUlyHUh3oWKojAHsLOjK7hqvpYnQsNGkIwcHP9bO2hnU/g/c04KKpfsB1mHArmQct0hQJDIVIIZs3w4ED2msbGy3TNEBIdAhfbvqSWH0sAIUzFWZ63WlYzZgJLVpgFZPoQPriwDIgJ+DcBHKdgyy/gG2ulHsQIYQQQljEiGoj+CT3JwDMruXG/vyJUpr73YaO7bRPop+RMSNs/gPsRwKJUhKMvAEj/F7YRXyAJDAUIgXEx8PQoaZyz56QJw+oqsrgvwZzN/QuoGUgnVN/Jo7fDIJBg8xv8gnwC5CtFuQ4Bt5rwa5wSj2CEEIIISzMSmfFjAYzKJypMAadwoA2mbjnmijj+KY/4bMG4O//XN+SJeGn2cAQ4KSpfuJtGHBNgkMhgaEQKeKXX+BiwvINFxf4NuEIwp9O/MTO6zuN7aZUHUmOjo1g9gLzG7SGqPkfQf5dkH07OJRNmYELIYQQIlV5eoyFp7MnQU5W9GnvSVzi06j+3ApFCsKSJc9Fe23awMDewDDgsKl+pr+279AgweEHTQJDIZJZZCSMHm0qDx4MHh5wwv8Ek/dNNtb3zl6BWp3awp/nzfoHDvDk9swNOOQ9Ak7VU2rYQgghhEilMrtkZlHjRTjaOHI2uz0jmnqgT/yuPiQcOneGT2vCHfMsM//7H9SoAowC9pjqF96DLy5BvCEFHkCkShIYCpHMZsyAgIS00Jkzw4AB8DjyMf0390evaudWlHfNx4ARf8DpOGM/1QYWj+tN4Fh/sns0MqUvFUIIIcQHr4hnEWY0mIFO0bG2rAuNv8zK3ezW5o2274IiBWDBAuPsobU1rFgBObIC44Dtpua/BULrixArweEHKVUGhoqilFcUpZeiKJMVRZmX8Geyoii9FUX52NLjE+JNPXqkfTL31Jgx4OBoYNDWQdwP106YdbV3ZeE/vuiumdZvRLg48PnUHZTq/yPFXawQQgghhHhWjTw1GFF9BAAXvO2o2Ssbc+q4oU/81iEsSktuULMy3LwJaMlo1q8HBztgErDZ1HzNQ2hyHqL1KfUUIrVIVYGhoihfKoriDxwE5gCDgB4JfwYBs4EDiqLcVRSlr6LIFIpI3caPh9BQ7XXBgtqqjrlH5rL/5n5jm591OXFacc9YfuzmRvU5xxnesSalXFJ6xEIIIYRIS74o9QUdfDoAEGetML2mG5/1y8r5rLbmDXcdhKIFYM5sMBjw8YHFiwEVmAasMTX98wl8dh4iJDj8oChqKkhBlBDgrQYaAwrgDxwHbgPhCc2cgWxAWcAb7dt4vaqqzd7ka5QpU0Y9ceLEOx65EC/n56cFg3EJq0M3bAAPn0N0XN0Rg6qt0RiYrxF9us2Ah6Z/h00mbWFgj/pUcn3RXYUQQgghzKmqyoZ/N7Dk1BIuBF4AwFqv0m1PMF/uCMLu2QCvcmlYshLy5GHQIJg2LaG+C9DO1KxSevizGKR7ZoWqSLsURTmpqmqZF15LJYFhb7QZwotAL1VV972mfVVgLlAQ6KOq6vyXtOsOdAfInj176Vu35BRPkXJat9bW8ANUrAhr/3rAZ7814HHkYwDKZS3L70v/Qff3I2OfRZ91xXnRIlp7WmLEQgghhEjLVFXl9L3TLD21lL+u/EW8IZ5892OZtOohJe/EmLd1sEaZMIH43oOoU8+KXbu0ersuEJMoOCzrAn8Xhww2KfggItmkhcDwOJAPyKeq6sM37JMJuAJcVVX1tbn7ZcZQpKQTJ6Bsou/KfQfimXenA0fvHgXA3dGdnbE5STdgtbHNbe9sfL/hX+aVdk7p4QohhBDiPfMg/AErfFew7OwynoQ+oPP+EAZsC8Iu3vy9v+GjQoTMXI9PqwI8nUPJ1BseNDe1Ke4EO0pApmdWp4q051WBYWrZY1gQ+OdNg0IAVVUfAP8k9BUi1VBVGDLEVG7cGI4aZhiDQgWFeUU64TLSFBQadApfj1nFDyUkKBRCCCHEf5fJORP9KvRjX/d9TGs0i1Nta1B/QFZO5rAza6c7dhHnqoXZ0WAgjglrTh/MhRL/mNr4RkDVM+BvPuko3jOpJTDUA28zQW2T0FeIVGPbNozLMaysoMlXu5l3dJ7x+lfl+lJ68DCUCFOfye2GMqxFeZxlDb8QQggh3iFbK1saFGzAqtarmDnob9b8+CXfN/IgysaUw9Em1kC+H6dzJrM7JbP9AaicHQ+NL5mChUuRUOU03Iq2yGOIFJBaAsNzQA1FUXK/aQdFUfIANRP6CpEq6PXms4VtewYw3fdrY7lyzsr03rUHjoUY6y4ULITD6LH4SAZSIYQQQiSjIp5F+L7+D/RcfpkNfwzlTF5Hs+v5boZwJKAdk6vmwbX8Ujb0j+DrKLBOiCH9oqHyabgaaYHBi2SXWgLDeYADsE9RlLaKoti9rKGiKHaKorQD9gF2wI8pNEYhXuuPP8DXV3vt6BJLUJl+BEcHA+Dl7MUMzzooEzYa28fZWTPjf+v5Mpfs6BZCCCFEynBzcKN184kUuxjMpWGNiLYzzR7a6eGbvTfYd7cbtbv58NvP4xhrcwPbhCZ3YqDKGbgQ8ZKbizQrVSSfAVAU5UegF9oxFLHABeAW8PTbzgnIARQBbNGOtZirqmrfN7m/JJ8RyS06GgoUgNu3tXK98RO4ZPczAFaKFcsb/Uypzz5FuWT6STpywAz6Teovm7mFEEIIYTnXLxDZrjaORwLMqmOt4Mcabsz/xJW83lU55NKBYJeqoOhwt9YS0siKp7QlLSSfQVXVPkBz4DTaTGAptHMN2yX8aZxQZ5fQpvmbBoVCpIQ5c0xBYeYK24xBIcA3Vb6h9MzRZkHhoY/KU3VEPwkKhRBCCGFZeYrgeOguzB6O6mQKD2z1MGB7EOtn+qM7sYMMV7qS43wN0t//iaDoEKqfgSMhr7ivSFNSzYxhYoqiZAV8gFxoB9uDdtD9TeC0qqp3k3pPmTEUySkoCPLk0f62dr9F3qENiSUcgJp5azLfsQp82g4l4Z9bVDp7pv51nZEVslhw1EIIIYQQz7h1AzrVhd2XzarjdLCguis/1nQj1lrBoHMgPEMj4jJ3YGO5AlR1tdB4RZKk+nMMU4IEhiI5DR4MP/wAinUMuQY2B48LAHin82ZTw6WkK10AJcCU43nkpD8Y9U0bbFPNnL0QQgghRAJVhcVT4OvhEBpvdumKpw2DW3pwLpu9sS7GpRx9y3bg65I1sdZJivXUTAJDJDAUyef2bcifH2JiIGOTb0n38TJASw+9svVKivfvCquOG9tvq1OXvOu3ksfBUiMWQgghhHgDd++idmmEsv2UWbVegUXV0jOzlhuxNqZPuV0dvehauh3tSrbDxU42H6ZGaWKPoRBp1bffakGhU8lNxqAQYHi14RTfvdcsKAzxTEfIrGUSFAohhBAi9fP2Rvn7BGGz5xHjYDo0wEqFnrtD2D0nAJ+bphVRwZH3mbJ/CtUXV2fR8UVEx8mhh2lJmp0xVBRlApAZUFVV7fK69jJjKJLD2bPg4wPWHtfI2q8xOjvtYJ/6Beoz0+cbKJYbJVhbgqEq8MOSbQzuWNuSQxZCCCGESDLfbfcIa92CikEHzOpVBf5qkIuBlVyJ05lnosnklIk+5fvQongLbK0k215q8L7OGDYBvkj4I4RFDB0KWEfi2b6vMSjM5ZaLibUnQMfaxqAQYGObdvRqK0GhEEIIIdKe4nUyc2PmPtpZLSXC3rT0SVGh3uYb+P54jpoxVYmz9TZeexDxgNH/jKbmTzVZc24N8Yb4F91apBJpOTBcD/wKLLX0QMSHadcu+PtvlYxNRmHrdRUAO2s75jScg/OCaSi7LhnbPsjjQfbpi3CR/dhCCCGESKPatVfw+LI9uaJv8pfTp2bXbG/Hs+DbJfx98D4ZnToRb+NpvOYf6s+QbUOo+0tdtlzagkE1pPTQxRtIs0tJk0qWkop3yWCAjz6CK7pVeLQYZqyfVGcSzW2KovoURYnWfugZrBX+2HyM9p++cNZeCCGEECLNiI+HWrVgzx5oxip+tuuKS0yYWRtVgStl8zDlo6rsy3aGeF2w2fVCHoUYUGkAn+T+BEVRUnD04n1dSiqExaxaBecCLuLeeIyxrmmRpjQv+Dn6Np8ag0KATX2/pG0dCQqFEEIIkfZZW2vvg7JnhzW0IFeMHzvcG5u1UVQocOw6i+b8zMlxlxjxd2aK3dVpx2AAFx9epPv67jRb1oyDtw5a4jHEC8iMoRBJFBsLhYqHEdvoc2w9bgKQP2N+1rVdh/3YwSgT5hjb3vXJjs1BPzwdrCw0WiGEEEKId+/UKahYEaITEo9OLLeRoYE9UW7ef2mfS1k9We8D60vZ8TjR/pry2cozsNJASmctndzD/uC9tzOGiqIcVhRFdrGKFDVvnkp42eHGoNDB2pE5n83B4eQZmGQKCvVOOq4v3iFBoRBCCCHeO6VKwcKFpvLwo40Y/4U/7NwGzcuA3fN9CvoHMmxLIIfG32XBLw+odT4Ca73KkTtHaLG8BV3WduFC4IWUewhhJk0HhglkYbJIMSEh8L+tv+FcYquxbmKdCeSx9yKubSMUvantjm9HU7VUfguMUgghhBAi+bVvD/37m8qjx+rYElVbO8PZ/zpMrgolnu9nbTBQ80I4838N5NC42wzf9Jj892LZc2MPDX9rSN9Nfbn2+FrKPYgA0vhSUkVRDgMfqar62ikZWUoq3oWeo3zZ7tgCxToOgFbF2jKhznfEdW+LzSLT4fY3ahQk67Z/sbWSzy2EEEII8f6Ki4PatbVkNADp0sHMmdCunbYfkehzcLAbLD8KG4FHL7/XOW9bVpd1YXNJZ8KdbGhUqBH9KvQju2v2FHiSD8OrlpKmisBQUZQmb9n1eyCvBIYiJVy6EUKdxZ9h7eYPQGbrIvzTdzV227ZDg4bGdnHu1tw+eYs8ObJYaqhCCCGEECnm4UMoUwZu3zbVFSwI48ZBkyagU1QI3wgBA2H3DVgH7AHiXny/GGuFHUUcWVPWhaMFXGhaogV9yvchs0vmFHia91taCAwNwNsMRAFUCQxFcjOoBj4e25NHzv9oFbEu/NNzEzkNjsQVyo3NI1Oa5qO/zqJchy8tNFIhhBBCiJR3+jTUrQuBgeb1pUrBhAlQpw4oajQEzYBH4+FJBGxGO5n80ovuqLmX3or1pV3YVC4DlWt1psdHPcjolDE5H+XdCAuD0FDImtXSIzGTFgLDpzuz9iWxaynAWQJDkdzGb1nIkkv/M5Z75pzHN01rEdmwDo5bdhjr/VqWJtfyE8iRPEIIIYT40ISGwowZMHWq9jqxypVh4kSoVAmIvwcPh0PIL9rFf4H1YNisoAt5eWxyPJc9m8q74/FFb76o0pd09umS61FeTVW1adJbt17+JzhYS9t64IBlxvgSaSEwvAjkR1sWeiMJ/WSPoUh2J+6eoOXyNjzNLJP+ZhdOzRlO/JIlWHfubGwXk92WmLP3SefqZqmhCiGEEEJY3OPHMHkyzJplOs7iqbp1tRlEHx8g6jgE9oPoI9rFWGAXhKxNh/OhcKwMhmdvDUCErcJOHzcMHTtQu/M4nOyc3+0DxMeDv//Lg77bt59/sBfx9oY7d97t2P6jtBAY/ga0AVqoqro2Cf0kMBTJ6nHkY2ov+ozgOG1dRPRNHzZ0Wk5Zd3/iihbEJiIGANUK/LYuJU/t9pYcrhBCCCFEqhEQoAWBCxdqsVZizZvDd99BwQIqhC5DfTgEJd7f1CAQzqwtQaZNYWS55ffSr3Enox0PmtWl6OAfsMuV980GFhmpBXcvC/z8/eElQWmS6HRaAGlj89/v9Y6khcCwHzADmKyq6tAk9DsClJXAUCQHvUFPp7WdOXhLWwKgj3Djo1ubWLXIk9BK5Ul3xPT9dLtvFbLP3mupoQohhBBCpFp+fjB2LPz2m7YK8ymdDjp2hNGjIUe2CHj8PwyPf0CHaTYu0mDPqiNt+Xinnvyb16CEh7/waxgUCCxXFI++g7GuUQvu3Xt54PfoFalR35ajI+TIYf4ne3Zo1gzsXnCoo4WkhcAwP9ALOKeq6s9J6OcDpFNV9bXvyCUwFEk1+9BsZhyaYSw//OVnfLdUxWP5/3Aabvr8IrqoA7YnHqKzc7LEMIUQQggh0oQLF2DUKFi3zrzexgZ69oThw8Erw030DwZjFb7arM1tfTZWRYyjsy+4/rEE3Z4U/kDe3f35oC9x2d2dtJBkItUHhilBAkORFAdvHaTj6o6oCclyg3b2plORQUxpfxZD2dJYxWv7DVV7CDqwngylP7fkcIUQQggh0ozjx2HkSNi+3bze0RH694dvvgE3u31EBPTHKf6MWZtDcZV44jaT+jGu6H/5iejFC3C+//i/DUhRtOyhzwZ7iYNA53e8j9FCJDBEAkPx5gLDA/ls6Wc8jtR+yERdK0fkyqVcPx+PrmYJ3C5dMbUdVw/PkX9aaqhCCCGEEGnWnj0wYgQcOmRenz49DB4M/b7UYxP3M7EPRuDCQ+N1g6qwQ+2CT87xZLL3IGbH39yePoZsu05gH/eC2MbW9uVBX44cWpKYVLQPMDlJYIgEhuLNxBviabeqHcfvHtfKYRnxn76ZCSMy0SlgEJlmTTO2ja7kgv3eR6CztdRwhRBCCCHSNFWFrVu1APHsWfNrmTJp9T26BvPw0Tg8I2Zho5iy2IQa0nHd6VtKZuuHorMlLPAOf07phd+lw9xztcbfzRrX/CWY8sVSMjingbMPU8CrAkNdSg9GiNRs+oHpxqBQNeh48McMMqfPRM/ie/CYPd3YTk0Pul/WSlAohBBCCPEfKArUrw+nTsGKFZAvn+nagwfa0tJ8BV3ZvnMq0d7nOU994/V0ulB8or7h3uWiBAdtwSWTNy0nb8Z+yAi2lnDmbHZ79kZfpsXKVtwJTl3HRqRGEhgKkWD39d3MPzbfWA7a9hXR1z/m+6EhqF3aoCSaXQ/7oQW2eWpZYphCCCGEEO8dnQ5atoR//4WffoJs2UzX7tyBLl2gTJkC/Ou7hdPptnJdX8B4PYtyFdfAz7jvVxcl9hIDKw1kbI2xKGjJYG4E3aD58uZcfHAxpR8rTZHAUAjAP8SfQX8NMpYjL1cmeHcvihaFSnv64nrvnvFaTCM30nX93RLDFEIIIYR4r1lbQ+fOcOUKzJwJHh6ma1euaMFj5/p1OXPrHCuZTrAhvfG6V9w29H7FiLrXj3ZFKzOn4RxsrbTVXQ8jHtJqRSsO3z6c0o+UZkhgKD54QVFB9NzYk5DoEADig714sGwaqDpmNVhNzjWmIFDNDLbzN4PyYWxQFkIIIYSwBHt76NdPOwNx/HgtIc1TZ85As/o2zO76FcseXeW3mJ7oVS2ssVL0OITMxnA9N8Wt5jOv7pe42LkAEB4bTue1ndl6easlHinVk8BQfNAeRTyi3ap2/PvgX63CYE3g77MwRGagcYUAyszrZmqsQOzcTiheFS0zWCGEEEKID4yzs5aAxs8Phg3TjrR46uBB6FPVgyXfzmNA8Cl2x1QzXtNhIEvcRqrRhxllo3C1186bjtXH0m9zP5aeWprCT5L6SWBoQaoKEXpLj+LD9SD8AW1XtuXSw0sAKCg8XDOemFulAZXv4jvhEhJibB/bORN2jRZYaLRCCCGEEB+uDBlg4kS4fh2+/NL8dIndm2F2hRKMWLqLdsFb2BZT26xvNdcrbKpwkZxOWkZTFZWxu8by/d4pfCgnNLwJCQwtaPwtKH8K7sVYeiQfnoDQAFqtaMW1J9cA0Ck6XE//QNjx5gBMrz6PosdMp66q+cF26lZZQiqEEEIIYUFeXjBrlrbfsFMnLWnNU4enKSyrXJ/pv21jTMQllsX2I8SQDoCsjvGsqXgXH9doY/vFx+dRavlgptyK43KkNmnzIZNzDC1krj/0uaq9zmUPO0pAHgfLjulDcSf4Du1WteNu6F0ArBQr2meezqi2WvrjQukucyqmJPYxCT84bMCwow+6qnMsNWQhhBBCCPECly7BqFGwerV5vaJA06bQY0g4jhl/xzvqR7Ir54mMV+h3KhO7HzgZ22bJ4M2VXL/i5JCTehmgnjtUcwVHqxR+mBQg5ximQumt4en32o1oqHQafMMtOqQPwo0nN2i1spUxKLTR2TCs9Bx+Gq4FhdbEsTxjO1NQCMQPzIquyvQX3k8IIYQQQlhOwYKwahWcPAl165rqVRXWrIFaZZ35rmdPbj70JS7rHiKcmzGnzCOaZQsztg14cpcK1ysxVGnByYeHqX9Oxf0g1PWF2XfhepQFHswCJDC0kLaesLEY2Cf8H7gfC1VOw8GQV/cTb+/qo6u0Xtma+2H3AbC1sqVP3nkMalKbW7e0NqMLT6CEn2lmWS2jYP3tFllCKoQQQgiRipUqBVu3aglp6tc3v7ZtG1StqlDt06ocPb8Ku7y3mFS9Bz3zxRrb+AbbsfrUYdY4VOGke2na2P3E3ieR9LsGeY9CgaMw4BpsfwLR72mOEFlKamH7g6HBOQhN+AZz0MGaItoUtnh3Lj64SIfVHXgS9QQAe2t7WrosZHyvisTFaW0q5TzK7jsVsdYn/M9wAvYNhFJTLTNoIYQQQgjxVs6ehUmTtNlEg8H8WvHiMHQoNG8Wy7Lj3/DdoS08jYgy2cWzpNx9CqaL5YnBjZ+iujAvshc39LmN/R11UMMN6mWAuu6Qwz7lnuu/etVSUgkMU4EzYfCpLwQmBCjWCvxaENp4WnZc7wvf+758seYL4zmFTjZOVAr9iXmjyhrb5PKO4B98yHX3qrHOMCUHuoFXZbZQCCGEECKNunYNJk+GX37BOBnwVJ48MHgweFbYytDtA4g1aFlLXaz1LCgbSDl3bWuRQVXYGlOPHyP7sC22Duoziy4LO2qTOvUyQMX0YJuK12RKYEjqDgwBrkVCLV+4adraxuy80NfbcmN6H5z0P0nntZ0Jj9U2cLrYupDrsMQA2gAAIABJREFU3yVsWOBjbFOohMr0XD2os2GRsU6traBsOAMOxVN8zEIIIYQQ4t3y94dp02D+fIiMNL+WJQu0HHCYf2x7Gt8z2upguk8gn2aOMGt7U5+XWRG9WBLViWDV7bmv42IFNRPNJma1S7ZHeisSGJL6A0OAgBiofRYuJPpmHZMTRuXQMiuJpDl65yhd13UlMk77D5rezhX7Hb9yeHNRY5vqLSIYFNSN+juWmzpmBA4MgwITU3jEQgghhBAiOT1+DLNna0deBAWZX8tY8CKenToRpXsIaGdcjynlQbssRwHzmCkOB3bq2zIquC8n4kq88Gtlt4Ob5VPX+3jJSppGZLGDfT5QPp2pbsxN6HcNDB9G/P7O7L+5n85rO5uCQtsMRCxbZhYUNh9yjZknPjYPCgF1cl7I/12KjlcIIYQQQiQ/d3cYMwZu3YIpUyBzZtO1R5cKcXnSGuIf5QJARWX0qQdMDRyO6joAdK7GtjZEUddqMcfdS/LYuzI/ZV5BPvtYs69Vzz11BYWvI4FhKpPBBnaWgNqJZqbn+EP7ixBneHk/YbLr+i66r+9OdLy2LtfVJhP+c5dz5UgBrUF66DH8TxbOKUMxv3OmjlagjrRCabMeFGsLjFwIIYQQQqQEFxcYNAj8/GDBAsidkFsmPsibu3NWEn3bNAs49/hyhp+1Iz73LfBaBHbmM4QZ4g/QWW3NZfccPMw/hvm5AqjhCp+lsWSSspQ0lYo1aMHgqoemunoZYHWR9/OwzXdl25Vt9N/SnziDtrs4vVVmLv/wO5H3cgJgW87AmALjGLZ0jHlHd2CaFTT6FdK3TdExCyGEEEIIy4qPh9Wr4fvv4dw5UGwi8WzfF8dCe41tynrUYEmbmThY20PUIQiaA2FrgPhn7mYNLk3ArQ84VE5V04ayx5C0FxgC6FXoexXmB5jqKqWHzUXBVRJlPmfTxU18vfVr9Kp23ISLmp0L3/9GfJA3WEPmbkEsPN2eBkf+NO9YHJiTAUpvBMdKKT9wIYQQQgiRKqgq/PknTJwIh4/G4dF8OC5l1hmvO4T4MKXGIj6tlrC8L/4eBC+C4AUQH2B+M+vMkOdWqspwL3sM0ygrBebmg5E5THUHQqDqGbgfY7lxpUZrzq9h4J8DjUGhQ0wuzk9YpgWF2aD0aF/2bSz7fFDYElhZFMqfkqBQCCGEEOIDpyjQoAEcPAh7dtngEzyZoF09jdej0p+m25+tqPhpANu2gWqVGTKOgjw3IcsqcKhiuplrj1QVFL6OBIapnKLAuFwwPY+pzjcCKp4GvyjLjSs1WXZ2GUP+HoKakC3KJiwfl/63HH1IZqgHbdouZ++Ej8kbcN3UyRYYB0z5HPIfBpscL7y3EEIIIYT48CgKVK0K2/5W2DHuG7Le/BbVoC0JtfW8xt2yzfjsi8uULq0tQdUbbCBdc8ixF3L6akGha3cLP0XSSGCYRnyVTTv0/un2Qr9oLTg8F27RYVnckpNL+HbHt8ay8rgwV6csQ48H1t/GMdVxIH9MaoNTdKIzQDIDfwA9RkLWtaBzTvFxCyGEEEKItKF0adg35wuGlpmBYtBmAK3TB5Kld0suBh+jRQsoXBh+/hliYwH7YuA1X1tKmoZIYJiGdPCCdUXBLmH/6v1YqHIGDoVYdlyWsuDoAsbvHm8s6+8V58bM3zHky0CmKYHs3FiTgWumm3cqD6y1g9rLwWMcKPJPQAghhBBCvF73TxqwtNXPOFprkwpWDmF4deuIY9FtXLkCXbpAnjwwcyZERFh4sG9B3hWnMQ0zwrYSkC5h6jA4Hmqehb8fW3ZcKUlVVWYdmsXk/ZONdbG3SnN7/lIMrdJTrusRTo0oRVXffeYduwBLMkPJA5CuVcoOWgghhBBCpHkVsldgRetlZHTMCIDOJhbP9n1xKb8MgLt34auvIGdOGD8eYtJQXhAJDNOgqq6wpyR4JOxljTLAZ+dhRaBlx5USVFVlyv4pzDw001gXda08/puWoE52pofrfPYNqELWR4myQjkCM4CRZSHPCXB4YSImIYQQQgghXquIZxHWtFlDTrecACg6Ax5Nv8W78QxIyHnx6BGsWAE2aSf3jASGaZWPCxzwgex2WjlehTYXYa6/ZceVnFRVZcKeCcw/Nt9YF3m5Mvdv/ITddB0/benC/Om9sI2PM3XKCawEmreB7HvBJktKD1sIIYQQQrxnsrlmY1XrVRT3Km6ss60wm0bTRpAjp3au4dChoEtD0VYaGqp4Vn5HOOgDhR21sgr0uQrf3dTOYHmfGFQDo3eOZsnJJca6iEs1uJ9pAdk6BXJgaCU6/73EvFMNYBXw8feQ+XfQOaTomIUQQgghxPvL3dGd31v8TuWclY115/QrqTW1D0uXRdMqje1cksAwjfO2h30+UM7FVDf6Jnx1DQzvSXCoN+gZtm0Yf5z9w1gXfqMugdXnUCPDfk72KE3pq6dMHRTgK2COExTcCO5DtZzDQgghhBBCvENOtk4saryIzwt/bqzb5beTTWp7wuOCLTiypJPA8D3gbgM7S0AtN1PdLH/oeAniDJYb17sQb4jn67++Zs35Nca6sKBGPPh8OoP3TWfb4DpkDE2UeSc9sBDomxNyHgaXhik9ZCGEEEII8QGxsbLhh7o/0K1sN2PdqYBTtFrRiqCoIAuOLGkkMHxPOFvD5mLQ3MNU93sgNLkAUXrLjeu/iNXH0n9zfzZd3GSsC1WaE1VhFKvHt+Z/C4diZUgU+RYC1gC1qkCOY9oZMkIIIYQQQiQznaJjaNWhjKg2wlhXxLMI6e3TW3BUSWNt6QGId8dOB8sLg9sVWHhPq9vyGOr4wqai4JqGsiLFxMfQd1NfdvntMtaFuLYlo00r1vf+mEK3L5l3aAiMAby6gdccUGxTcrhCCCGEEELQuUxnPJw92HxxM5PqTEKXhs7MVtT3LUvJS5QpU0Y9ceKEpYeRIlQVRtyA72+b6ko4aecfeqaBeCkqLopeG3ux/+Z+Y12wZ2eq3CjEr//7gnSRYabG1sBQoI0CnjPBra/sJxRCCCGEEBalqipKKnxPqijKSVVVX3h2W9oJYd8zcfo4gqOCiYmP4V0H54oCE3PDlDymurMRUOk03Ih6p1/qnYuIjaDLui5mQWFIph58/VcY60c3NQ8KPYBfgfaukH0bZPhSgkIhhBBCCGFxqTEofB1ZSmoh5wPP02xZMwAUFOyt7XGwccDO2g4HGwccrN/wtY0dDtYOpr7WDthb22NvY09DBweUrPYMuemAXmfPtUh7Kp62ZntxKOps4f8ALxAWE0bntZ05FZAow6hLV5bN3kntEzv+3969x8lRl/ke/zxzn0wCgSSEXEhIUEFRCSSRkKDcQUWP6MLuqohx9eyR5XhwV+Kuu+JZWVeRFUFRYDnqybLsrgoI4noUBLlJEAl3gRwCGoFAAoRcmJ77zLN//KrTPZPunpnuquqe6e/79apXdVdV1+/p6q6n++mu+tXwhZcCXwfmvwHm/wRa3pBmqCIiIiIik4oKwyrpHsj9dec43QPdw6bFaUHebbdm3ntfG/u0tLF3SzttzW20N7UzpWUKHc0ddLR0MKVlClOah98veLt5yu5xc2NlJzDu6N7B6utW89jWx3ZPm9//Qf7lf/8zB279w/CFzwTWAPucAnO/D43TK2pbRERERKTeTYjC0MwagZlAp7tnqh1PHIaGhtirdS96BnroG+xLrV3zfmywn53dr7Ezxjq0pbFlWLHY0RwVkdlpefdH3m5tauXCOy/kiZee2L2+k353PJd892La+3pyjbQBXyR0NLPPp2G/fwKbEG9hEREREZGaVtOdz5jZm4EvAycB2W5TNgCXuPt3xrOuWu58ZnBokJ6BHrr7u+kZ6Bnb7f4eugdyt3sGovuFbkeP6R7owb22L2zYNABrbl/MJ265dfiM+cA3gTc2w/5XwvQ/q0Z4IiIiIiITVqnOZ6r+d4uZdQFXu/snR0x/B/BTYAqQf/bmG4F/NrM3u/un04s0Xq++CldcAXPnwpw5jcyZ08GcOR3MnQkNCXUJ5O483tnHqQ/3srm7GxvqpmGol8/O6+LoqV3s6M2ws6+Lnb0ZXuvL0NnXRWdfhkx/hq6+Lrr7M/T0Z+jt76J3IENffxf9AxkGBjJA5QXnfjuHuPSHLRz51Iii8O3ARcCMWTDvRzDl6IrbEhERERGRnKoXhoQDBIddRMHMmoFrgA7geuACwj+FM4A/IfyL+Ckzu8Hd70w33Hg88wx8/vN7Tm9qgv33hzlzskVjbsi/v99+0Ng4vjbNjDdPa+VXy1s5+dG92NAVpn9pO7C9wAMagfZoKMUd815sMEPDUBcNgxlsKEPDYBcNQ5nd022wi4ahThoGu7ChLhoGO3dPP3LjVq783sPM3jEikLOBc4Apb4F5N0HLgeN70iIiIiIiMqpaKAwLOZVw8OAd7n5G3vQtwDfM7FXChQr+HChaGJrZn0fLsGDBgmKLVcWLLxaePjAAzz8fhlIaGmD27MJFY/792bOheUS/MAe0wd1L4N2Pwf2vFV7/uJjh1oY3tDHEjLE9pg/23raDFb/9NSc+fCvn/vw6mocGcvOnAl8Fjgemvg/mXgMNNdiVqoiIiIjIJFCrheGRgBO6GtmDu/+rmf09cFSplbj7VcBVEM4xjDnGihx4IKxZAy+8EIrE7LBjx9gePzSUe0wpZjBrVuGi8dw5zl2zn2RX4wZ6h9roGeigq38qXb0ddHZ3sLOzg+07OujOtECfQS+5oa/IeOT87O0e57CGjbyrdR1v93UcllnHvB2PFw76IOAyYBEw4+9g5gVguuSmiIiIiEhSarUw3DcaP1ZimceBE1OIJRFvfStcdNGe07u7cwXfyKIx//62bWNrxx1eeikMjzwC+07fxolH3criVTdzzKG38OEZm0ddx8BAI5nujt1DZ2bqsPuZ7g56+zpobO6gqaWDtvYOOlqambPlZWZvepbpG5+m7dENNLy8a/SA3wl8CZjaBnO+B3t9cGxPVEREREREylarhWH2RLNS13F4jTh6PKkx7e2weHEYSunthS1biheO2fvbt/ez4rB7OXnVLZyy6maWHvoADQ3j+/O0qWmQvaftYu9pJQq7rcBD0fAw8AQwUHzxPSwEPgJ8CGieC/NuhPbl44pTRERERETKUyuF4RIz+0Le/TdG40UU/9dwLjDG/80mn9ZWWLgwDHvoexoyt0DmZjxzO+bFTyTclZnOQ08eRVubs/deGaZ1ZJjS1klbS4bmpgyNlsHoH/6gfuApcoXgQ8Aoh7QO0wK8BVgCHB6Ns6cmti0PRWHz3HGsUEREREREKlEzhWE0QDi30KLxuyhQGJpZC3AEUJsXJkzb4E7ouh0yN4eCsP93u2fZHgs3QPsK6DgZOk5hr7ZlHLN0lLfBtq1wzx2w7h649z5Y/yh09ZR+TL79WmHZVDi8DY5ogEMGoakLhjKwu+hsgr3PgtnfgobRukEVEREREZE41UJhWLCDmcgLRab/ETANuD/+cCYAH4Se9bv/FaT718Bg8eWbFsLUU6DjFJhyPDROL77s0BA89RSsW5cbnnxy7LE1NMBhh8HKlbBqVRgvWBB6wSn4XPqiArEJGqeNvR0REREREYlN1QtDdy9VGBbzK8JBiM/FHE7t6n8uVwhmboWhQhcejFgHTDkuKgZPhubXFy7MenpCLzYbN+aKwHvvhVdfHXtc06fDUUeFAnDlSnjb22DqOC4rYS3Q2DL6ciIiIiIikpiqF4blcPfnmOxF4VAGuu7MFYN9G0Z5wBLoPxq6lkDnfNi2E155Bbb9IIyzw7ZtuduZzPjjOvjgXBG4ciUcckj4l1BERERERCasCVkYTko+BL2PhkJw+8/gxXtge3/on3U7sIPht3e0wq6psL0BXu2CzocJ3YHGqL09/AOYLQJXrICZM+NtQ0REREREqk6FYbXcdBPc9lPY8lt4eRO88hJsHwiF35j+yMtePT5G8+blzgtcuRKWLIHm5njbEBERERGRmjMhC0MzWwssANzdT6hyOOX52cVw5V3ptDVtWvinb+ZMmDEjdzt7f/ZsWLYMDjggnXhERERERKSmTMjCEDgSOJhwSYuJadbrgDIKw6lT9yzsSt3fd99w0UMREREREZEiJmph+C1gYp/sNudwmALs0wozZ8CsBbDfIpg5q3ihN2OGijwREREREYmduU/cP93GY9myZb5+/fpqh5HjHq7h16BCT0REREREkmdmD7j7skLzJuo/hhOfGZiKQhERERERqb6aKwzNbAXh4vWLgGnR5NeATcBD7n5vlUITERERERGZlGqmMDSzTwF/A+yfPzkae95yLwIXAt/2ejkOVkREREREJEFVLwzNzIBrgfcTCsHNwP3As0BntNhU4ABgOTAf+AZwLHB6yuGKiIiIiIhMOlUvDIGzgQ8ATwJnu3vJaziY2THA5cD7zeyT7n5lCjGKiIiIiIhMWg3VDgD4GLALOHa0ohDA3e8EjiOcd/jxhGMTERERERGZ9GqhMDwEuM3dXx7rA9z9JeC26LEiIiIiIiJSgVooDAeB5jIe1xw9VkRERERERCpQC4XhY8AJZrZ4rA8ws4OAE6PHioiIiIiISAVqoTC8AmgH7jKzD5sVv+q7mbWa2ZnAXUAr8O2UYhQREREREZm0qt4rqbv/u5mtIvROejXwHTN7HPgDkIkW6wAWAocCLYTLWlzu7t+vQsgiIiIiIiKTStULQwB3P8fMfgl8DjgibyjkQeAr7n59WvGJiIiIiIhMZjVRGAJEhd71ZjYPOBxYRLiwPYQL3W8CHnL356sToYiIiIiIyORUM4VhlrtvBjZXOw4REREREZF6UQudz4iIiIiIiEgVqTAUERERERGpc+bu1Y4hFWb2MqGn01ozE3hFMSiGPLUQh2JQDIpBMSiG2o8BaiMOxaAYFENtxlDIQnefVWhG3RSGtcrM1rv7MsWgGGopDsWgGBSDYlAMtR9DrcShGBSDYqjNGMZLh5KKiIiIiIjUORWGIiIiIiIidU6FYfVdVe0AUAxZtRAD1EYciiFQDIFiCBRDoBiCWogBaiMOxRAohkAxBLUQw7joHEMREREREZE6p38MRURERERE6pwKw5SZ2cFmdq6ZXWNmG8xsyMzczE5Pqf1mMzvBzC42s/VmtsvM+sxss5ldZ2bHphTHp8zsh2b2pJltM7N+M3vZzG41szPNzNKIo0BcX45eDzez81Job21ee4WGDUnHkBdLu5l91szuN7MdZtZlZr83s2vNbFWC7R47yjbIHxYkFUcUy3wzu8zM/r+ZdZtZj5ltNLMrzWxxkm3nxXCAmX3LzJ4xs14ze8XMbjazU2Nso+w8ZGYfMrO7zWynmXVGeeQcMxv350k5ccSdQ8e7viRyaJnbIdYcGtd2rSSHlrkdYs2hFe4bseTQMt6TsefQcreDxZhDK4ghlhxa6b5uMeXKcuOIa58uN4ZKt1+M2yG2XBnnc7KUv2+OmbtrSHEALgW8wHB6Su2fmNfmi8B/Aj8AHsubfkEKcTwP9AEPAj8Bvg/cCwxFMdwINKT82iwHBvJiOC+FNtdGbf0quj1y+EpKz30RsDGK5QXgBuBa4DdAP/D5BNs+pMhzzw5PRHE9TXT4e0JxHA5sj9p6LnoP3hi9Vx14DViZwntwW9TeJuBHwLroNXDgizG1U1YeAr4dLdcd5Y4bgF3RtB+Nd58tJ45yY49rfSSQQ8vcDrHm0Di2KxXm0DK3w1pizKEV7Bux5dAy3pOx59AyX4tYc2iZMcSWQ6lgXyfGXFluHOW+l+OKoZLtF/N2iC1XxvWcqML3zTFv52oHUG8D8AngIuCPgYOAO8rdUcts/3jgOuDtBeb9SfRGdeC4hOM4GugoMP1QYEsUw8dSfF1aCR+em6MEnsqOSu5Lzeq0nmuBGDoIXxiGgL8GGkfMnwG8oYrxZb/U/G3C7ayL2rkKaM6b3gx8N5r3SILttwHPRu18E2jKm7eS3Beuk2Joa9x5CPijvA/D1+dNn533Gp2bQhyx5tDxri+JHFrmdog1h1a6XePIoWVuh7XEmEPLjCHWHJrAe3zcObTM7RBrDi1j34w1h5a7rxNzrqwgjtjeR+XEUG7cCWyH2HJlHM+JKn3fHPNrXe0A6n2oZEdNKJ7vRPF8t4oxnB/F8O8ptvnVqM33kvuiUS+F4VeiGC6rVgwlYjsqim0AmJtgO23kfu2bU2D+nLz5UxKK4YPkftVvLjD/vGj+3Qm0PWoeAtZHy5xVYN4x5L4Ilf1Pfzn5MO4cWun64sihMcRQcQ4dbwxJ5NAxvi8TzaFjjCHRHFrJ+yGuHDpaDGnk0DHEkGoOLbavp5ErxxJHnO+juGKo9DEJxBDr982xxJBEroxz0DmGMtJD0Xh+FWMYiMa9aTRmZkcCnyEkhp+k0WatMLMW4L9Hd79ezViK+LNo/HN3fyHBdgbJve9KyRAODUrC8mh8p7v3F5h/SzReZWb7JxRDQWY2H1hKOBzn2pHz3f1Owq+f+wMr0oytBimH1hHl0N3qMYfusa9XKVfWQs4pJ4a44y5nfXHnypIxTIRc2VTtAKTmvD4av1iNxs1sEfDJ6O5NKbTXBvwL8CpwbtLtlXCcmb0VmApsJZwv8wt3H0q43aWEw5w2u/vvzewI4P3AflEct7j7rxKOoSAzm0I4NAPCYUiJcfd+M7sNOAX4opmdk/1iYWbNwD9k4/DoJ78ETI3GrxSZn51uwBHA/0sojkIOj8aPu3uxL3X3A/OiZdelElVtUg6tDuXQEZRD9xB3Di20r1cjV1Y151QQQ9xxj2t9CeXKojHUUK4sSYWh7Bb9grY6unt9Sm1+jHBoRTPhF5aVhN5yv+zuN6QQwj8CBwN/6u7FPkzScFaBaU+Y2Z+6+2MJtvuWaLzZzL5G+CUr3/lmdiNwprtnEoyjkDOAacBLhBO8k/YXwM8Jv/6/y8zWR9OXA/sQTuT/bILtvxSNi/Xcd1De7UUJxlFItr0/lFjm2RHL1h3lUOVQlEPrIoeW2NdTzZXVyDlxxBB33GNZX9K5cgwx1EquLEmHkgoAZtYEXAPsDdyW4l/cq4CPAh8C3hFNO5/cr4uJMbOVwKeBG939B0m3V8TDwP8C3kT4tXMu8B7gkWjarWY2L8H2943GhxO+0FwKvI7wIf4+wiEvpwGXJxhDMdlDoK4uclhQrNz9d4QPip8RPjROi4Z5hBPF7044jl9G41Ojw5FGOjvv9l4JxlFI9pf4Ul9sO6PxtIRjqUnKocqhKIfWRQ4dZV9PLVdWMedUFEPccY9jfYnlytFiqJFcOSYqDCXrSuAEQhfTZ6bVqLt/wt0NmELoIepS4O+BX5vZ3KTaNbN2wkm/uwi/claFu1/q7pe5+5PunnH3F939p8DbgF8TDkf6XIIhZHNAM3CNu/+luz/j7jvc/SbCh7oDHzGzg4quJWZm9jpyift7KbW5Evgt4Uvd+4BZ0XAa4Uve9Wb2haTad/dfAncB7cAvomslTTOz15nZZYSOFbJfqpI+PE7GTzm0CpRDC1MOTTSHVmVfr9E4yokh7rjHtL6Ec2XRGGolV46VCkPBzL4BfJzQbe8J7r4l7Rjcvdvdn3D3NYQP8cOAbyXY5JcJx4L/lbtX87j8gty9j9DTHcC7E2zqtbzb/6dAHOuBBwjnZByTYBwjZX/pvtfdn0y6MTObTriW0TTgne5+k7u/Eg0/Bt5J6DDhfDN7fal1VegM4B7CdcluJXyQbAT+J+FD7JFouVcTjKGQ7C/cHSWWyf5S/lqJZSYl5VDl0Ihy6CTPoWPY11PJlbWQc8qJIe64y1lf3LlyDDHUdK4cSecY1jkzu5hwGM7LhDf0xiqHBOGXla8B7zWz5oQOPXk/4RfDj5rZR0fMOyQan21m7wGedvdPJBDDaDZE4yQPg/p9kdsjl1lG6EUtcWbWSO58oUQ7TMhzKuGX7V9Gh0MN4+5Pm9l9wLHRkMh+4u4vmdnbCRfRPZ7QqcVW4Mfuvt7Msr0KJnnOVCGbovHCEsscMGLZuqAcqhxa5PbIZZRDJ3gOHeO+vikaJ5YrayHnlBND3HHHtL61VJArxxjDRMiVu6kwrGNmdhHwV8A24ER3f6LKIWVtJ3Qh3EQ4f2NrQu00UPoX3MXRMD2h9kczIxp3llyqMg/l3Z5BOAxipJkpxJHvFMIXuU4grWPxF0TjnSWW2RGN9y2xTMWiHvt+EQ27RYehzSHsrw8mGUMB2ffJoWbWXqS3veUjlp30lEOVQ1EOzZrUOXQc+3qiubIWck45McQdd4zrKztXjjOGWs+Vu+lQ0jplZhcCawg7xUnu/miVQ8r3DsJOuoPi3U5XxN0PdHcrNBC6EwZYE01bkkQMY/DH0fj+pBpw983AfdHdE0bON7N9CN16Q7hobxo+Ho1/6O5pfZHK/oq8NOpafZho2tLobrF/BZJ2XjS+KjpMLjXu/hzhi1QL4VCtYczsGEJnE1uAe9OMrVqUQ5VDQTk0z6TNoePZ15PMlbWQc8qJIe64Y15fWblynO+JiZArd1NhWIfM7EvAXxN2hJPcPdVf+M3saDN7T9SL08h5q8gd+vJddx9MM7Y0mdmSaDs0jpjeZGafIRyeAHBJwqH8YzT+WzNblhdHG3AFoZetB0jhC7+ZzQTeG91N6xAoCL3odRF+9b7EzFrzYmoFvkk4/Gc7cHNSQZjZW8ysY8S0JjP7O+B/AE+Te73Slj1f66tRxxYAmNl+5HpcvNCTv25c1SmH1gbl0D0ph8abQ8vc12PPldXOOeXGEHfc411fErmyFl6LJJkndp1RKcTCxW/zu61+E+Fk7Y3knQzt7isSav+/AT+O7q4HHi+y6AZ3vzChGFYD/5ewUz1I+OVsGuEaQ2+KFvspcEaRwzASZWZrCV0ar3H3ryXYzmnADYTX/UHCNZhmEK6LNZdwTPrfuPs/JRVDXizZ62/1E3ry20bo1W8uobv149I4j8HmdFC1AAAEsElEQVTM/hL4OuH998ak2xvR9kcJHxKNhF+/s4caLSUcftRLuP7QjQnGsJbwK/ODhO3eDqwg9Ky4ETjZ3TfF0E5ZecjMLid0+d5D6Nihn/AvyV6EjidOH08hUk4ccefQ8a4viRxaRgyriTmHxrldy82hZWyH2HNoBftGbDm0ktcirhxa5r4Zaw4tM4a1xJRDK9nX48yV5cYR8z497hjizpVlxrCaGHNlAs9pLSl83xwXd9eQ4kA46dpHGxJsf/VY2gfuSDCGRcAFwO2EC712E5LnJuA64LQqv0Zro21wXsLtLCL0kraO8AHWE22LjYTuxZem/Lw/QLgO1HbCB/hG4GJgVooxPBpt+zVVeu2PAK4mHOrUEw3PAN8B3pRC+6cRLkT9XNT2DsJhap8B2mJsp+w8RLgG1D2E3v4yhH9CzgEa0ogj7hw63vUlkUPLiCH2HBrndqXMHFrmdog1h1ayHYgph1YYQyw5tNwYiDGHlhMDMeZQKtzXiSlXlhtHJe+jOGKodPvFFEOsuTKB57SWMnJlkoP+MRQREREREalzOsdQRERERESkzqkwFBERERERqXMqDEVEREREROqcCkMREREREZE6p8JQRERERESkzqkwFBERERERqXMqDEVEREREROqcCkMRERHAzDaZmZvZsaMsd0e03Op0IhMREUmeCkMREREREZE6p8JQRERERESkzqkwFBERERERqXMqDEVERGJgwUeicxC3m1mPmT1jZt82swMKLH9gdK7iphLrdDPzUtPN7ONmdp+Z7YqmT4/1iYmISF1QYSgiIlIhMzPgGuBqYCVwP3AjYMBfAA+b2fIE2r0MuAroBf4TeADYo5AUEREZTVO1AxAREZkEzgY+BGwFTnD3xwHMrBG4BPgUcK2ZHezuvTG2+xHgKHf/TYzrFBGROqR/DEVERIa7PXuoZqEBOKbAYz4Tjc/PFoUA7j4InAc8CywETo851otUFIqISBz0j6GIiMhwNwNbSsx/JzA7e8fM5gOLgSHgX0cu7O59ZvZvwOeAY4F/izHWH8W4LhERqWMqDEVERIa70N3vKDbTzO4grzAE5kXjF929p8jDfjdi2bj8Ieb1iYhIndKhpCIiIvGItdMXMxv1M9rdu+NsU0RE6pcKQxERkcpsjsZzzay1yDKLRywL0BeNpxZ5zMJKAxMRERkrFYYiIiIVcPfnCYeKNgBnjpxvZs3Ah6O7d+TNeplQHM4ws1kFVv3ueCMVEREpToWhiIhI5b4ejf/BzA7JTowuV3ERsIBwPuB12Xnu3g/cHd39YnQtxOzjjgYuSDpoERGRLBWGIiIilbsc+A9gDvCImd1sZv8BPAV8GtgOnFHgGoZfIPxreDbwuJlda2a/Ae6M1ikiIpIKFYYiIiIVcncnHC56FnAfcCTwAcLn7BXAYe5+f4HHrQNOAG4DDiB3+OhZ7n5+CqGLiIgAYOGzTEREREREROqV/jEUERERERGpcyoMRURERERE6pwKQxERERERkTqnwlBERERERKTOqTAUERERERGpcyoMRURERERE6pwKQxERERERkTqnwlBERERERKTOqTAUERERERGpcyoMRURERERE6tx/AYiIR9zgQbD4AAAAAElFTkSuQmCC",
            "text/plain": [
              "<Figure size 1080x540 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# fig2 = plt.gcf()\n",
        "plt.figure(figsize=(15, 7.5))\n",
        "plt.plot(hours, N_scores, 'blue', label='Naive', linewidth=3)\n",
        "plt.plot(hours, LSTM_scores, 'deepskyblue', label='LSTM', linewidth=3)\n",
        "plt.plot(hours, CNNL_scores, 'gold', label='CNN-LSTM', linewidth=3)\n",
        "plt.plot(hours, CNNBL_scores, 'forestgreen', label='CNN-BiLSTM', linewidth=3)\n",
        "plt.plot(hours, BL_scores, 'r', label='BiLSTM', linewidth=3.5)\n",
        "plt.title('24 Hr. Prediction Error Comparision', fontsize=24)\n",
        "plt.xlabel(\"Hour\", fontsize=22)\n",
        "plt.ylabel(\"RMSE [kW]\", fontsize=22)\n",
        "plt.legend(loc='upper right', fontsize=18)\n",
        "plt.xticks(fontsize=22, rotation=0)\n",
        "plt.yticks(fontsize=22, rotation=90)\n",
        "\n",
        "plt.savefig('RMSE-comparision.pdf')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 515
        },
        "id": "tBZhJP8ccHmj",
        "outputId": "396ffc82-0978-45a6-97be-26b63063727d"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1080x540 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# fig3 = plt.gcf()\n",
        "plt.figure(figsize=(15, 7.5))\n",
        "plt.plot(hours, N_actual[15], 'darkgrey', label='Actual', linewidth=3)\n",
        "plt.plot(hours, N_predicted[15], 'b', label='Naive', linewidth=3)\n",
        "plt.plot(hours, predictions_LSTM[15], 'deepskyblue', label='LSTM', linewidth=3)\n",
        "plt.plot(hours, predictions_CNNL[15], 'gold', label='CNN-LSTM', linewidth=3)\n",
        "plt.plot(hours, predictions_CNNBL[15], 'forestgreen', label='CNN-BiLSTM', linewidth=3)\n",
        "plt.plot(hours, predictions_BL[15], 'r', label='BiLSTM', linewidth=3.5)\n",
        "plt.title('24 Hr. Load Prediction Comparision', fontsize=24)\n",
        "plt.xlabel(\"Hour\", fontsize=22)\n",
        "plt.ylabel(\"Active Power [kW]\", fontsize=22)\n",
        "plt.legend(loc='upper right', fontsize=18)\n",
        "plt.xticks(fontsize=22, rotation=0)\n",
        "plt.yticks(fontsize=22, rotation=90)\n",
        "\n",
        "plt.savefig('model-predictions-comparision.pdf')"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "machine_shape": "hm",
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}