diff --git a/transformer/transformer.ipynb b/transformer/transformer.ipynb index f45a72a..ef03b9b 100644 --- a/transformer/transformer.ipynb +++ b/transformer/transformer.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "b19f0e22", "metadata": {}, "outputs": [], @@ -12,10 +12,19 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 6, "id": "bc1a0f32", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/.env/pytorch/lib/python3.8/site-packages/xgboost/compat.py:36: FutureWarning: pandas.Int64Index is deprecated and will be removed from pandas in a future version. Use pandas.Index with the appropriate dtype instead.\n", + " from pandas import MultiIndex, Int64Index\n" + ] + } + ], "source": [ "from typing import List, Optional, Iterable, Dict, Any\n", "from itertools import islice\n", @@ -77,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "ac78c47a", "metadata": {}, "outputs": [], @@ -243,15 +252,15 @@ " ): \n", " # time feature\n", " time_feat = (\n", - " past_time_feat[:, self._past_length - self.context_length :, ...]\n", - " if future_time_feat is None or future_target is None\n", - " else torch.cat(\n", + " torch.cat(\n", " (\n", " past_time_feat[:, self._past_length - self.context_length :, ...],\n", " future_time_feat,\n", " ),\n", " dim=1,\n", " )\n", + " if future_target is not None\n", + " else past_time_feat[:, self._past_length - self.context_length :, ...]\n", " )\n", "\n", " # target\n", @@ -273,9 +282,9 @@ " assert inputs.shape[1] == inputs_length\n", " \n", " subsequences_length = (\n", - " self.context_length\n", - " if future_time_feat is None or future_target is None\n", - " else self.context_length + self.prediction_length\n", + " self.context_length + self.prediction_length\n", + " if future_target is not None\n", + " else self.context_length\n", " )\n", " \n", " # embeddings\n", @@ -305,10 +314,8 @@ " lags_shape[0], lags_shape[1], -1\n", " )\n", "\n", - " if features is None:\n", - " transformer_inputs = reshaped_lagged_sequence\n", - " else:\n", - " transformer_inputs = torch.cat((reshaped_lagged_sequence, features), dim=-1)\n", + "\n", + " transformer_inputs = torch.cat((reshaped_lagged_sequence, features), dim=-1)\n", " \n", " return transformer_inputs, scale, static_feat\n", " \n", @@ -358,7 +365,6 @@ " past_time_feat,\n", " past_target,\n", " past_observed_values,\n", - " future_time_feat,\n", " )\n", " \n", " enc_out = self.transformer.encoder(encoder_inputs)\n", @@ -391,7 +397,6 @@ " )\n", " \n", " #self._check_shapes(repeated_past_target, next_sample, next_features)\n", - "\n", " #sequence = torch.cat((repeated_past_target, next_sample), dim=1)\n", " \n", " lagged_sequence = self.get_lagged_subsequences(\n", @@ -410,18 +415,16 @@ " output = self.transformer.decoder(decoder_input, repeated_enc_out)\n", " \n", " params = self.param_proj(output)\n", - " distr = self.output_distribution(params)\n", + " distr = self.output_distribution(params, scale=repeated_scale)\n", " next_sample = distr.sample()\n", " \n", " repeated_past_target = torch.cat(\n", - " (repeated_past_target, next_sample), dim=1\n", + " (repeated_past_target, next_sample / repeated_scale), dim=1\n", " )\n", " future_samples.append(next_sample)\n", "\n", - " unscaled_future_samples = (\n", - " torch.cat(future_samples, dim=1) * repeated_scale\n", - " )\n", - " return unscaled_future_samples.reshape(\n", + " concat_future_samples = torch.cat(future_samples, dim=1)\n", + " return concat_future_samples.reshape(\n", " (-1, self.num_parallel_samples, self.prediction_length)\n", " + self.target_shape,\n", " )" @@ -429,7 +432,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "a8873ae3", "metadata": {}, "outputs": [], @@ -512,7 +515,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "99d97334", "metadata": {}, "outputs": [], @@ -534,7 +537,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "bc39c0e9", "metadata": {}, "outputs": [], @@ -649,7 +652,7 @@ " AsNumpyArray(\n", " field=FieldName.FEAT_STATIC_CAT,\n", " expected_ndim=1,\n", - " dtype=np.long,\n", + " dtype=int,\n", " ),\n", " AsNumpyArray(\n", " field=FieldName.FEAT_STATIC_REAL,\n", @@ -812,7 +815,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "f1c38a2a", "metadata": {}, "outputs": [], @@ -822,7 +825,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "6e17f04e", "metadata": {}, "outputs": [], @@ -839,18 +842,916 @@ "\n", " batch_size=128,\n", " num_batches_per_epoch=100,\n", - " trainer_kwargs=dict(max_epochs=10, accelerator='auto'),\n", + " trainer_kwargs=dict(max_epochs=1, accelerator='auto', gpus=1),\n", ")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "ed0d8504", "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | model | TransformerModel | 70.4 K\n", + "1 | loss | NegativeLogLikelihood | 0 \n", + "------------------------------------------------\n", + "70.4 K Trainable params\n", + "0 Non-trainable params\n", + "70.4 K Total params\n", + "0.281 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation sanity check: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fd7b03e750ac406b867957df471b71ec", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validating: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "Epoch 0, global step 99: val_loss reached 5.87883 (best 5.87883), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/transformer/lightning_logs/version_9/checkpoints/epoch=0-step=99.ckpt\" as top 1\n" + ] + } + ], "source": [ "predictor = estimator.train(\n", " training_data=dataset.train,\n", @@ -862,7 +1763,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "4f319643", "metadata": {}, "outputs": [], @@ -875,19 +1776,42 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "c4d84519", "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n" + ] + } + ], "source": [ "forecasts = list(forecast_it)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "fcfa0dc3", "metadata": {}, "outputs": [], @@ -897,7 +1821,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "4239bdbb", "metadata": {}, "outputs": [], @@ -907,30 +1831,138 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "bf9638c4", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Running evaluation: 2247it [00:00, 3782.99it/s]/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:306: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/.env/pytorch/lib/python3.8/site-packages/pandas/core/construction.py:781: UserWarning: Warning: converting a masked element to nan.\n", + " subarr = np.array(arr, dtype=dtype, copy=copy)\n" + ] + } + ], "source": [ "agg_metrics, ts_metrics = evaluator(iter(tss), iter(forecasts))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "d52b033a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{'MSE': 5663932.213705687,\n", + " 'abs_error': 15884110.07395649,\n", + " 'abs_target_sum': 128632956.0,\n", + " 'abs_target_mean': 2385.272140631954,\n", + " 'seasonal_error': 189.49338196116761,\n", + " 'MASE': 1.2228158317665538,\n", + " 'MAPE': 0.16195644943880783,\n", + " 'sMAPE': 0.15256039233967505,\n", + " 'MSIS': 9.666505938800974,\n", + " 'QuantileLoss[0.1]': 6094882.807487315,\n", + " 'Coverage[0.1]': 0.0931427087969144,\n", + " 'QuantileLoss[0.2]': 9951667.05002583,\n", + " 'Coverage[0.2]': 0.21057706571725263,\n", + " 'QuantileLoss[0.3]': 12961542.022116888,\n", + " 'Coverage[0.3]': 0.341251298026999,\n", + " 'QuantileLoss[0.4]': 14974556.35043285,\n", + " 'Coverage[0.4]': 0.47546728971962615,\n", + " 'QuantileLoss[0.5]': 15884110.014152177,\n", + " 'Coverage[0.5]': 0.5992248924491916,\n", + " 'QuantileLoss[0.6]': 15648592.372865904,\n", + " 'Coverage[0.6]': 0.6949451120011867,\n", + " 'QuantileLoss[0.7]': 14572382.714138813,\n", + " 'Coverage[0.7]': 0.7893116748256935,\n", + " 'QuantileLoss[0.8]': 12225912.691949772,\n", + " 'Coverage[0.8]': 0.8672674677347575,\n", + " 'QuantileLoss[0.9]': 8136894.739575123,\n", + " 'Coverage[0.9]': 0.9306853582554517,\n", + " 'RMSE': 2379.901723539375,\n", + " 'NRMSE': 0.9977485096978678,\n", + " 'ND': 0.12348398550334558,\n", + " 'wQuantileLoss[0.1]': 0.04738196957463463,\n", + " 'wQuantileLoss[0.2]': 0.07736483215099114,\n", + " 'wQuantileLoss[0.3]': 0.10076377333750215,\n", + " 'wQuantileLoss[0.4]': 0.11641306253144684,\n", + " 'wQuantileLoss[0.5]': 0.12348398503842341,\n", + " 'wQuantileLoss[0.6]': 0.12165305734609647,\n", + " 'wQuantileLoss[0.7]': 0.11328654154646663,\n", + " 'wQuantileLoss[0.8]': 0.09504494860515972,\n", + " 'wQuantileLoss[0.9]': 0.06325668780848917,\n", + " 'mean_absolute_QuantileLoss': 12272282.30697163,\n", + " 'mean_wQuantileLoss': 0.09540542865991224,\n", + " 'MAE_Coverage': 0.05728749443702716,\n", + " 'OWA': nan}" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "agg_metrics" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "d61f32ab", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABY4AAAQlCAYAAAARPll0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOy9d3hj133m/znoAME+5Aw5vY80snqz4iI5dlxiOU7sxIkTJ07seFPszW+TeDfZXe8mm2zilE026zTbiWPHvRfZlmSrjCSrjEYjzYymFw57J9HLBe695/fHBUCAKAQLQIBzPs/DZ4a34YAE77nnPe95v0JKiUKhUCgUCoVCoVAoFAqFQqFQKBRZbOvdAIVCoVAoFAqFQqFQKBQKhUKhUDQWSjhWKBQKhUKhUCgUCoVCoVAoFApFAUo4VigUCoVCoVAoFAqFQqFQKBQKRQFKOFYoFAqFQqFQKBQKhUKhUCgUCkUBSjhWKBQKhUKhUCgUCoVCoVAoFApFAY71bsBK2bRpk9y1a9d6N0OhUCgU1xDHjx+flVL2rHc76o3qcxUKhUJRb67FPlf1twqFQqFYDyr1uU0rHO/atYsXXnhhvZuhUCgUimsIIcTQerdhPVB9rkKhUCjqzbXY56r+VqFQKBTrQaU+V0VVKBQKhUKhUCgUCoVCoVAoFAqFogAlHCsUCoVCoVAoFAqFQqFQKBQKhaIAJRwrFAqFQqFQKBQKhUKhUCgUCoWiACUcKxQKhUKhUCgUCoVCoVAoFAqFogAlHCsUCoVCoVAoFAqFQqFQKBQKhaIAJRwrFAqFQqFQKBQKhUKhUCgUCoWiACUcKxQKhUKhUCgUCoVCsQRCiH1CiI8LIU4JIQwhxJEljv9bIYQUQvx1nZqoUCgUCsWa4ljvBigUCoVCoVAoFAqFQtEEHAbeAjwHOCsdKIS4HngfEK5DuxQKhUKhqAnKcaxQKBQKhUKhUCgUCsXSPCCl3C6l/FngzBLHfgz4OyBQ+2YpFAqFQlEblHCsUCiaHtOUhBLp9W6GQqFQKBRNj6YbxFP6ejdDoWhIpJRmNccJId4JHAI+WtsWXRskUgbJtLHezVAoFIprEiUcKxSKpuc7J8f5sY8+RiKlHigVCoVCoVgN//t753jvp46tdzMUiqZFCOEF/g/wB1LK2Hq3ZyPwm58/zn/75un1boZCoVBckyjhWKFQND3D83Gimk5EU65jhUKhUChWw3gwycCs0roUilXwh8AE8LlqDhZCfEAI8YIQ4oWZmZnatqxJGZ6LMxqIr3czFAqF4ppECccKhaLpiWrWklotXdXqQYVCoVAoFGXQdINQIoWUcr2bolA0HUKI3cDvA78jq/wjklJ+Qkp5u5Ty9p6ento2sEmJaDoJFVWhUCgU64ISjhUKRdOTFY5V9plCoVAoFKtDS5ukDUlcxT8pFCvho8CDwAUhRIcQogNrzO3OfC/WtXVNSiSZJqap7HWFQqFYD5RwrFAomp5oMiscK8exQqFQKBSrQdMtwTgQT61zSxSKpuQg8DNAIO9rO/DBzP+3rl/TmpO0YZJMm6qWiUKhUKwTjvVugEKhUKyWnONYVw+UCoVCoVCsBk23JmGD8TTbOte5MQpF8/F+wL9o25eAJ4B/AlSI8TLJOo1jSjhWKBSKdUEJxwqFoulZcByrB0qFQqFQKFZDVjgOJVTB2fUglAzhc/pw2p3r3RRFCYQQPuAtmW+3Am1CiHdmvv++lPKFEuckgREp5ZH6tHJjEck85yvHsUKhUKwPSjhWKBRNjyqOp1AoFArF2qClVVTFevLS5EtcmrvE9vbt7Oncw66OXbjsrvVulmKBXuCri7Zlv98NDNa1NdcAWeE4ZZikDROnXaVtKhQKRT1RwrFCoWh6VFSFQqFQKBRrQ35UhaL+RLQIhjQYDA4yGBzkYPdB7tt933o3S5FBSjkILKvAnZRyV00ac40QSS7ci+Ipg3avEo4VCoWinqi7rkKhaHpywrFyHCsUCoVCsSpUVMX6EklFCr4fCY+sU0sUisYg+5wPEE/pFY5UKBQKRS1QwrFCoWh6VMaxQqFQKBRrQ7YvDcRUVEW9kVISTUULtsXTcWbjs+vUIoVi/ckXjmOaetZXKBSKeqOEY4VC0dRoukHKsNxRSjhWKBQKhWLl6IaJbkoAgspxXHfm4xGeOutncfLWcGh4fRqkUDQA4eSCcKwK5CkUCkX9qYlwLIR4pxDiGSHEnBAiKYS4IIT470IIV94xQgjxX4UQI0KIhBDiSSHEzbVoj0Kh2LjkOw+yy2sVCoVCoVAsn+xELKiM4/XgR1cmeepMO8MznoLtSjhWXMtE84TjmIqqUCgUirpTK8dxN/AY8H7gzcCngP8G/E3eMX8AfAT4C+B+IAo8IoTYUqM2KRSKDUj+w6SmHMcKhUKhUKwYLZ0vHKuoinozH7diKqLJwiHaVHQKTdfWo0kKxbqTXxxPOY4VCoWi/jhqcVEp5ccXbXpcCNEG/LYQ4kOAG0s4/nMp5d8DCCGeBQaBDwL/vRbtUigUG4+ItvAwmVSOY4VCoVAoVkz+yh0VVVF/Qok4ALGkvWC7RDIaHmVv1971aJZCsa4UZBwrx7FCoVDUnXpmHM8B2aiKe4A24CvZnVLKGPAAlkNZoVAoqiI/qkJlHCsA5cpSKBSKFaJlwnU9TpuKqlgHQskEUCwcAwyFhiqeG0vFODV1iqFg5eMUimYjmtSx2wQAceU4VigUirpTE8dxFiGEHctdfCvwH4F/klJKIcQhwAAuLTrlHPCuWrZJoVBsLKL5jmMlHCuAQDLAFr9KPVIoFIrlksxEVWxp8zAaSCClRAixzq26dogkk4CNaAnheCQ0UvKcgcAAp6dPMxGZQCK5ecvN7OzYWeOWKhT1I5zU6fG7mQwniWvKcaxQKBT1ptaO41jm6yngCeDDme2dQFRKuVjlCQC+/CJ6+QghPiCEeEEI8cLMzEyt2qxQKJqISF7GcTKtoioUEEgE1rsJCoVC0ZRkHce9bR50UxJT7r66EtGsFTOxZPEQLaEnmIkVjn/GwmP88MoPGY+MI5GZa0Rq39A8RkIjvDz1MkdHj/LY1cfq/vqK0jx/dZ6/evg8pinXuymrJqql2dzmBiCuTCIKhUJRd2otHN8DvBr4PeCngL9fzcWklJ+QUt4upby9p6dnLdqnUCianGzuWafPuWEcx6ZUAvhqCCSVcKxQKBQrIZtxvLnNA6gCefUmlrJWUZVyHAMMh4bzjo3xyMAjOcE4SzQVrV0DS3Bk8AhPjzzNS5MvcXHuIpqh4qIagReHA/zD41dI6s3/bBxJ6nT73dgExLXmfz8KhULRbNRUOJZSviil/JGU8m+woip+UwixF8tZ7M9EWeTTCcSllOopVaFQVEUsIxxv8rs3THG8iBYhkU6sdzOaFuU4VigUipWh5aIqLHefyjmuH7FUjGzdr1IZx7AgHJvS5IcDPyShFz8rRFL1c/ya0iSejtft9RTV0+KyPkMbIRM4qum0ehz4XI4N8X4UCoWi2ahncbwXM//uBs4DdmDfomMOZfYpFApFVUSTOkJAZ4sLbYM4jkNaqORgUFEdCT2hhHeFQqFYAdmoigXH8cYXjg2zMZ4dIqkIumHlSad0Gym9OFt6OjaNpms8N/ock9HJkteJp+N1e08RLVLkeFY0Bl6XVcpoIzh0o8mscGwnnlIZxwqFQlFv6ikc/1jm36vAM0AY+NnsTiGED7gfeLCObVIoFE1ORNPxuxx4nfYN4zgOJUPKwbMKUkaKWDq23s1QKBSKpqMoqiLR/IsAg8kgE5GJkvsmIhP84MoP6tyi0kS0CGljQSwulXMskTw1/BSnpk5VvFa94irCWrgur6NYPjnHcbr5hdZIUsfvdmaE4+YXwhUKhaLZcNTiokKIh4BHgDOAgSUa/x7wZSnllcwxHwU+IoQIYLmMfxdLyP5YLdqkUCg2JtGkjt/jwO2wbSjHsdvhXu9mNC1pI00sFWOTb9N6N0WhUCiaiqzjeEu7JRwHNoDjOKkn+c6F73DTlpu4c+ud2IQlyJ6ZPsPTI0/jdXjXuYUWkVQEXV8Qi2NJO53+4ueay/OXl7xWNBWl3dO+pu0rRT1jMRTLw+e2hvmxJncca7pByjDzoiqaXwhXKBSKZqMmwjFwDHgvsAvQgQHgD4F/zjvmo1hC8R8C3cALwBuklFM1apNCodiAxFI6frcDj9O+YYrjhbUwra7W9W5Gjtn4LF3ertxgu9FJGam6FwdSKBSKjUAyk3Hc22pNXoY2SHE8ieTE5AlGQiPct/s+zs6c5ezMWcCKdpBSIkRxNEQ9yTqObUJiSlG2QF5V16qToBvRlHDcqPgyjuNEkzt0I0lLKF6Iqmju96NQKBTNSE2EYynlR4CPLHGMBP535kuhUChWRCSp0+J24HHacgPeZieUDNHp6VzvZuQYDY8STAbZ17U4lr7xMKWJIQ0lHCsUCsUKyK7cafVYy8I3WsbxXGKOr539WsE2iSSejtPialmnVllEUpZw3N6iE4g6yxbIq+padRJ0VVRF45IVjmNN7tCNZoRjv9uBz+0glNhY9ySFQqFoBprDPqZQKBRlyFZa9jjtJPXmdyFIKYmkIg2VcTyfmF8yT7FRSBmWO05lHCsUCsXyyWYcux02On2uDRFVUQ2N0OdGNKs4XpvXQAi5KsexyjhW+DLF8ZrdcRzVso5jJz6nnUSTC+EKhULRjCjhWKFQNDXR5EJUhbYBHMeRVARTmssaxF6Zv4Ipa/feA4kA07HpshXcG4mccJzaGMKxEGKfEOLjQohTQghDCHFkieP/VgghhRB/XWLf9UKIR4UQcSHEuBDifwkhVq5MKBSKDUe+cNzudRLaAMXxqqERJhujqShpQ+B0SFrcRsnieMu5Vj1QGceNS8sGcRyHk9bkleU4tjd9ZrNCoVA0I0o4VigUTU1MywjHDhtJ3cBKwWleQskQAAk9UdXxL0+9zA8Hfsh4ZLwm7ZFSEkgGAJrCdZwVjjdQVMVh4C3ABeBipQOFENcD7wOKLGBCiE6sorUS+Cngf2EVrf3jNW6vQqFoYjTdwG4TOOw2OnzODRdVUY71nmyMpWIY0kDXBU67pMVjNnzGcdpIk9STNX8dxcrwbpCM4+iijOPEBqlnolAoFM2EEo4VCkVTE9GsjGO3046UkDKa23Uc0izhuBrH8dHRozw98jQAw6HhssfNJ+ZJGysb/EdSEXTTemi/Grja8IVwsu+zEdxja8QDUsrtUsqfBc4scezHgL8DAiX2/QbgBX5GSvlDKeU/Y4nGvyuEaFvTFisUiqZFS5t4HNbwoMPnJLBBiuMtxXr3GVmhN20IHA4Tv8dYVcZxNBWt+US6iqlobLJRFc3u0M0vjtfichDTmttBrVAoFM2IEo4VCkXTIqXMZRy7MwPdZi+Qlx2IJfVk2fgJKSVHBo/w0uRLuW2VhOPzs+dz1eOXy3xifuF1kbw8/fKKrlMvso5j3dTRdG2dW7N6pKwug0QI8U7gEPDRMoe8GXhYSpk/0v8Slpj82lU1UqFQbBg03cTttATLDp/rmilEtd6O4+wqGd3IOo5XJxwvN/JqJaiYisbGbhO4HTbi6eYWWrMZx363A5/LgaabGGZzry5UKBSKZkMJxwqFommJpwykJJdxDAsV4ZuVbFQFQCJdOq4ikopwfvZ8wbZgMljWDTwQGODk1EkMc/k/m0Ci0Lx6fvb8it3L9SArHMOGiquoiBDCC/wf4A+klOXUj0NAwYdGSjkMxDP7FAqFgmTayE3EdnitqIpmj4CqhnV3HGsLjmOnXWYcxzZWo4/VWthVjuPGp8XtIN7kjuOccJyJqgCIN3lus0KhUFTDUjWMVjK2XylKOFYoFE1LLO9hMiscN7vjOBtVAeXjKsoN1oZCQ0XbpqJTRFNR4uk4F+YuLLs9+Y5jsITZxaJ1I5E2F0Tt9RYC6sgfAhPA5yoc0wkES2wPZPYVIYT4gBDiBSHECzMzM6tupEKhaHw03VwQjn1OdFPmhJuNzHo7jiOpCFKCbthwZDKOJYKE1rgF8ho9uqpWLFW0VgjRJ4T4KyHESSFEVAgxIoT4jBCiv95t9TrtxJs84zicTONy2HA77PjcGyO3WaFQKKrh/Ox5xsJjZfdfDV6tW1uUcKxQKJqWSN7yNY/Tup1pevM+TEopCwZi5QrklRuslYqruDx/Off/E5Mnlu0cWywcAw0tHF9rjmMhxG7g94HfkWtsC5RSfkJKebuU8vaenp61vLRCoWhQNN3A7ViIqgCuiQJ56z3RGNEi6IYAyEVVAKsrkFdjYfcadhwvVbT2NuCngS8C9wMfBu4CnhFC+OvVSIAWt73p3bnRpE6r28przjqOY0o4VigUGxwpJScmT1Q0fl2YXb4pbKUo4VihUDQt2UrLfrcjN9BtZsdxNBXFkAsPw+Ucx+WWn45HxouWrAwEBnL/D2vhAiF5KaSUBJPBou1zibmK+cFT0amqX2OtyReO19tBVic+CjwIXBBCdAghOrD6dnfme5E5LgC0lzi/k9LF9BQKxTWIlXG8EFUBXBM5xykjlSsEux6EtXBOOHY4rKgKYNUF8mrJNZxxvFTR2h8Bh6SUH5VSPi6l/BLwNmAn8I56NtTrcjS94ziStGqZwELBv2YXwxUKhWIprgSuENbCDAQGCsa3Webic8zGZ+vWHiUcKxSKpiVawnGcbGLH8WL3TlnhuIyLSDd1xiPjue8no5NFLqr8gnpZyonAIS1UIGTnk/86i1lJJMZaUSAcXxtRFQeBn8ESf7Nf24EPZv6/NXPceRZlGQshtgM+FmUfKxSKaxctnR9VYTmOA/HiActGZD0nG6OpKOk8x7F/LRzHKuO4JixVtFZKGZRS6ou2XcSqKVDXuIoW1wZwHGs6fk+h47jZxXCFQqFYipcmrDG7buoljV8X5i4gqV8NCiUcKxSKpiVaMuO4eR8m8/ONYfkZx1CYc1yqk5lPzDMYHASswnePX32cz576LEk9WXTs4sJ4+ZQTjk1pcmX+Stnzak1+4b5rIaoCeD9w36KvKeArmf9nw4kfBN4ohGjNO/ddQAJ4om6tVSgUDY2mG7n+tNNnOY6vhagKWL/Jxng6jiGNAuG4xWNpk7FkY2YcJ9KJdXVoNxtCiBuxJmpLRVvUDJ+r+TOOragK61604Dhu7vekUCgUlRgKDjGXmMt9vziSwpQml+Yu1bVNjrq+mkKhUKwh+VEVZsb/0cxRFaFkoXCcSJfJOK7gIsrmHEspuRooHZh/bOwY52fP5wRkgKuBq1zXc13BcaXyjbOUE44no5NohkY8Hcfn9JU9v1ZstKgKIYQPK0sRLPdwmxDinZnvvy+lfKHEOUlgREp5JG/zPwP/EfiGEOIvgD3AHwF/I6W8Nm1jCoWiCE036WqxxMr2rHB8DURVwPr1GdlVRGk9E1VhlzgdErfDbNiM42s4pmLZCCFswN8Bl4DvlDnmA8AHAHbs2LFmr+3bAFEV4WSa7V3W82TOcXwNFOxUKBTXLotXCE/FpggkAnR6rXrmw6FhEnoCj8NTtzYpx7FCoWhaSkZVNLHjuJqoCsM0yjqRs9cIJUMlYyqyzCXmCkRjsHKUFlNJOC6Xc5yt/Lpebt8NWByvF/hq5utu4Pq873urvYiUMgD8OGAHHgD+GPhb4H+ucXsVCkUTk0wvFMdrz2QcB2PXSFTFOjmOsyLsQnE8awK8xWOsKuM4baYr1iNYDddqTMUK+XPglcB7pJQlZ2FqVYzW57ITa3KRNaotFMdryTiOVXE8hUKxUZmITDAZnSzanh8FWc+ieFmU41ihUDQt+VEVWUeFpjex47iKqIpqXD7DoeGiay3FeGScpJ4smLkMJCvXTBuPjLO7c3fBtrGIJRzHUjFoWVYT1oS0mS74f8pI4bK76t+QNUJKOQiIpY5bdM6uMtvPAq9bfasUCsVGRdMXMo7dDjs+l105jmtMdpIzvzgeWMJxdBVRFWA9M7gd7mWdMxGZoK+1r/J1a+hm3kgIIX4L+DDwC1LKo/V+fZ/LQaLJRdb84njejOM40eS5zQqFQlGOFydeLLn94txF7tx6JykjVRBNWS+U41ihUDQtUU3HZbfhdthzA91mcRyXcgEtdvAk9OKoimoGa0OhoWXnDJvSLIi2MKVJMBmseM7iuIq0kWY6Ng00huN4PduhUCgUzYimm7idC8ODTp9LZRzXmGyNgfyMYwC/x1yV4xhW1gdeml86N1E5jpdGCPEO4GPAf5ZSfnk92uBz2YmldKSsXwGltURKWVAcr8Vt/T0ox7FCodiIaLrGSHik5L54Os5IaIRLc5cwK9dorQlKOFYoFE1LNKnnHiLdTVYcb/FsYiwVKyo0kzJSRduqcRyPhkdLis5LkR9XEUqGluyUFgvH45Hx3DmVBqu1LKizWDjeCDnHCoVCUS+0vKgKsOIqgvFrJKpinfqLbL+VFY4d9gXH8WqF4+U6g5N6ktHw6NLXVRnHFRFC3At8HviYlPKv16sdPrcdUzbvarxk2sQwJa0eKzbHk7k3NXtus0KhWDtqFcm0Hiy12vf87PmCyIp6ooRjhULRtOS7ELIZx83ycHxu9lyBo7dctMTiAnm1dPmMhcdyzqdK+cZZFuccZ2MqoLJwPBAYWEUrK1MkHK+Tg0yhUCiakfyoCoAOn/PaiapYp/4i24+mdevnvuA4NkjpNlL6stKKCliuwBtKhghr4bLFebNcy45jIYRPCPHOTKHarUBP9vvMvuuAbwHngS8LIe7O+9pbz7b6nM0ttEaS1r3Hn8k4ttkEPpddFcdTKBSA1Rednz2/3s1YMwKJysLxYHCQ2fhsnVpTiBKOFQpF0xJJ6vjdlgvBZbchRPM4jk1p8tzoc7nvQ8nSwvHinONa5gpKZE7UrUY4hkLXcbYwHlQWjkdCIzmBei2RUha5mVVUhUKhUFSHlDITVbHgcrWiKq4Nx3GlwrO1JDvhmSuOl5dxDKzKdbzcPjArCGdjp0ohpbzW+9alitbeBbQDNwHPAM/mfX2kng31ZQTXeJNmAkcyAnE24xis+I14kzzrKxSK2nJq6tSSLt1mYqn3Ilm/2CElHCsUiqYllldpWQiBx2FvGuEYrFnDicgEUN69UyQc13h5aDYbudpOOCscJ9IJ5hJzue2VBpXBZLDioHSlLHYbg4qqUCgUimpJGdaKnXzHcbvPSegacRyb0lzSaVsLNMNyHOuLoir8GeF4NQXyljvZnF39VKmPjqai65Kv2ChIKQellKLM16CU8tMV9r+3nm31uZrdcVxKOHYox7FCsUEwpcmF2ZVFL2i6xvnZ82XNV83IUo7j9UQJxwqFommJagsZx2DFVSTTzTWYeXb0WaBCVMWirOJaVzIfj4yTSCeW7ThenHccT8fLDixDWoip6NTqGlqCtFksblzjriiFQqGommz/WRBV4XUSjKebtrjWclmPuIrFGcfOXMax9ftoNMexyjduHlpcWcdxcwrH0YxwnF1dCBnHcZO+H4VCUciluUtV5eqX4uzMWXRTX7KYezPRyO5pJRwrFIqmxco4XniYdDvsaHpzPUxOx6a5Mn+lqqgK3dRXVPRuOUgkl+cvVz17OxOf4xc+8SwPnx0quk6pZb+JdIKUkao4KF2pG7mk41hlHCsUCkVVZPvPxVEVuimJXiMOv/VYpZITjnWB3SYRmUhjvzfrOC4Ujpfj9k3oiWUVpK1GOL6W842bDW/Wcdykf7/ZjOOiqAolHCsUTY+UkhcnXixrnqqEKU1OT58GrH6u1Biw2Ugb6YY2PCnhWKFQNC1WxvHCw2QzOo4Bjo4drSqqol6DtROTJ6rOUEqmbDw7MM8LQ8UzpKU6v2qWwT4z8syKZp9VVIVCoVCsHK2E47jdZ03OBuPXRlzFekw2Zovj6abAaV94hvG6TISQxBILwnHKSPHMyDPLuv5yBqLZSWPN0Mq6uGq98kmxdjS74zibcZz/rO9zOZo2s1mhUCwwEBggpIVWFDVxef5yQX+9EeIqGt05rYRjhULRtMQ0vcCF4HE2V8ZxlrAWLhmzAIXCcb0Ga8sZOCdTVjcSLpGBWVI4XmJQqukaU9Epnhl5ZtlLo9NGcRs0Q1uW20qhUCiuVTS9dFQFXEPCcZ0nGw3TwJDWc0taF7nCeABCQIvbIKot/D5OTJ7g0vylZbmrqn12SBvpglVN5SZ4VVRF85B1HMeaVGiNlsw4Vo5jhWIj8OLEi4A1VstOoFbLycmTBd83uuhaDY0cUwFKOFYoFE2Kbpgk0kbOTQHW8tqk3nyO40oUCMcNOFhLpq1uRNNF0b5KjmOgZM7xcGgYiWQ+Mc/52fPLaku5gXQjL/tRKBSKRiEXVeFYcLh2+FwABBPNvwy0GurtOM7vt3RD5ArjZfF7zZzjOKyFOTNzBsM0GAoVxkNV4tj4MU5OnmQuPlfxuMXLhcsJx7Px2apfW7G+ZOuAJJpUaI0kSzmOlXCsUDQ7g8HBgqLqy4mrGAuPFZy73PMblUYujAdKOFYoFE1KTLMeGv35jmOHrSkdx4t5/qKfoxdaAQoqvDdirqCWsgRjLV3cnVRyHANMxUoLx1mOjR8r6SIuRznhWMVVKBQKxdJkHcce58L9vPNai6qoc3+R32+lM8JxUk/mtlmOY0v8OzZ+DMO0nnGuBq5W/RrTsWmeHX2Wr579Kv9+8t8ZCpYWnRc/Y5Sa3B0KDlVdPFex/vic1jNyrEmF1qiWxuu047Av3JN8bhVVoVA0O1m3cZblRE2cmz1XtE05jmuPEo4VCkVTEtEyBTPchVEV2gYQjk8PtfDE6XZCcfu6RFUsh6zjOFVCOC41AM+fEV7sZpJSFgjH8XScE5Mnqm5LubgP5ThWKBSKpVnIOF5wHC9kHCvHcS3QjIXlubohcNolz40+x/Njz2NKE7/XIJa0MxmdLBCLx8Jjy17aC1a/ejVYWnRePHCfS8zlhOosL4y/sOzXVKwf2aiKRJMKrZGkXmAQAfA5leNYoWhmRsOjRWPA5TiGS4nEGyHjWDmOFQqFogaUchy7HbacY6qZSaRsmFJw9EIrhjRyjqSGjqpIVxlVkdexz8XnCvKHp2JTBYNogJNTJ6t2gJVzHOdnNioUCoWiNMlsVIUzP+M4E1WhHMc1ocBxrNtw2iWhZIhTU6d46PJDuJ0a8aSN50aeLzjPkMuLq8hnMjpZcvtix7EpzYJYiqHgEDPxmRW9pmJ9cDlsOO2iaR3HkUW1TCDrODYwzeXVwVAoFOtPykjx9PDTRduXs6q2lJGq2R3Hhmk05MrifJRwrFAompJoxnHc4m7+4nj5SAlxzY4QkpNX/USTtpzruCEdx6mscLx0VEU8HS9wBUskM7GFQWip5bO6qfPE0BNFrqdSlBOOl1tkT6FQKK5FFhzHC/dzl8NGi8tOsEQB1I2IZmhV9Tdr9np5ruG0IXA4ZM55NR4Z53LoRSSC6Ui86NyBwMCKXjOYDBbEYWQpNWjNj5RSbuPmxOdyNG3GcTSpF6wsBCvjGBYmuhQKRWNRbtwlpeSHV35YMpKhWuFX07UikxFYq07zV+k2GyEthKSxx6s1EY6FED8rhPiOEGJMCBEVQhwXQvxCieN+XQhxSQiRzBzz47Voj0Kh2HiUKpjhcdpIppvbcZzSBYYpuGl3DNOEYxdbiafjpIxUyY5yvdFyxfGKu5OEnigYgJdaRpQ/KC3nnhoODfPdi99dclnucqrMKxSKjYlumHz66au88W+f5C8eOk9Ma84l2utBqeJ4YBXICzRxVMVyheB6xlUsLo5nE3qhCxmrAJBp+IvOHY+MlxSAq6GU67jUUuHscuLluI3rKbwrlsbnsjftfTCSTNPqcRZsa8kIx9mVhwqForE4OXWSi3MXi7Y/PfI0I+GRkudU67attPp2LVzHpjSXVV9nrWj0mAqoneP4d4Eo8J+AtwGPA18QQnwoe0BGSP5n4N+BNwNngO8KIW6oUZsUCsUGIpp5CM5fwuZx2pvegZDQrNtyf5fGddvjvHjFz2Q42pBuY8h3HBdHVUDhALzUoDRbfCeailYsuDMRneBb579VMa94PTp6hULRODx9eZa3/L+n+KMHzmJKyT8ducJ9f32Eb740qlYeVEE26infcQzQ7nUSauKoiqvBq5ycOln18fWMq1hcHM+kUAi22a0+zzRais41pclgcHBFr7tYODZMo+T7zvbR1bqNL81fYiwytqI2KWqDz2Un3qSr8aKaXmAQAfC6rO+b1UWtUGx00kaax64+xuNXH89FEp6ZPsPp6dNlz0nqyapy+yuNh1ebczweGeerZ75atg5ALWn0wnhQO+H4finlu6WUX5FSPial/H3gi1iCcpY/Aj4jpfwTKeXjwHuBy8Af1KhNCoViA5F1T/g3WFRFPFM93ec2eeWhMGnDxpefn2rY3KNsxrFu2DBKmL3zhd5SHXrWzZRfFK8cgWSAb577JnPxuZL7leNYobg20Q2TD37hRX7xX46SSBt8/D238YP/9Bq+8Vv30Nfu4T99+STv/Odnm1r8rAc54dhZODzobHE2dVTFD05pPHt1kJcmXqrq+Ho6jhcXxysWjq22lBKOgYKCecthsXAcSUVKLpONpCKcnz1fldt4PjFfMrtSsb74XA7iTes4Li6Ol3McN2nBP4XiWuHC3AW+fvbrnJk+w9MjS/cN1RTIq4XjOJ6O8+jAo3znwncIJAO5CdN6cs06jqWUsyU2vwT0Awgh9gAHgK/knWMCX8VyHysUCkVFslEVBRnHDiuqopmdZfGMg9fnMulp1zmwNc53T0SYjDRmtdis4xggtUTOcakHglg6RiwVK5lvXIpYOsbL0y+X3KeEY4Xi2uTkaJDvnprgfa/azQ//02t54+EtCCG4dUcn3/ytH+NP334Dx4cCfP/0xHo3taHRMhOvHmdhVEVXi5uZSONFJVVDKJHm33+UJBm+k+MTxzk+fnzJc9bNcawLdFlYzFXkhOPiqAqA8eg4ifTyC8DOxGaWjJLK8qPhHy15vazDLL/graIx8LnsxJvUnRtNFhfH82aE42Z9TwrFtUQgGeCp4acw5dJRktWYpCodU43wnMUwDQaDgzx29TG++PIXuTR/KbcvP0axXlzLjuNSvBLIhp0cyvx7ftEx54AuIURP3VqlUCiakmgJx7E7M9hNlbK+NgnxTFSFz209EN9zKExMk3zzeGmX7XqTH1Gh6cVxFUs5jgHGImPLWtpabplSfuE9hUJx7XBm3BpIvO9Vu4tET5tN8It37aDV4+DMeGNOwDUK5aIq+ts9TIaSmGbzTcpemrL6CyO1CYCXJl9aUjxej4xjKa2oirRZ+NpCaICOLOM4llKuKK7CkEaBi7jSYLwaMfip4aeavqr9RqVZhWPTlERTxcXxsoaRuHIcKxQbimqiJipFVVTbBx0ZPMKnT3yahy4/xMW5i0Xjx7n4XF0nQaWUZdveSGa4ugjHmaJ3bwf+T2ZTZ+bf4KJDA4v2L77OB4QQLwghXpiZqa5Ag0Kh2JhEkzo+lx27bUGszA52m7lAXiITVeF1W+9hS2ea3T3wwtWVFcCpNcm0DYfNaqu2AscxwInJE8vqoMstU1KOY4Xi2uTMWJhOn5O+dk/J/UIIru9rywnMitJkHccu+yLhuMNLyjCZizXfPfZCVjhOb8pte3n65Yr9RT0dx9lMR2u+W6CZhTn+QlhxFeWiKoACp9RyyI+rWI5TazFnZ84yEBhY8fmK2uJzO5pSZI2ldKSkqDie16kcxwrFRqSafqjSJGdYCy8ptA4Fhzg/e76i2Ugic1GK9SCshcs6soPJYMPEVdZcOBZC7AK+AHxbSvnp1VxLSvkJKeXtUsrbe3qUKVmhuJaJpYoLZmSdZloT5xzHNRt2m8TlWOj4etp1psONKYYnUzbafNbPu5RwnB2Ax1KxsuJwpaJ4pYimoiUfDJRwrFBcm5yZCHG4vx0hShfpBLi+v43zExGMJnTN1gtNN3E7bEU/x6wgPx5cfiTCenNx0hKOTaMN03QDloO2Uq5+PB2vS9tgod/SDetnvthxDFZcRSXheDo2vaKiQPnC8WoGpicmT6z4XEXtaWlSx3FuZeHijGPlOFYoNiRVOY4rZByb0qy4H+D4xNJxVUBdc44rxVTMJmaLahKsFzUVjoUQXcCDwBDwi3m7sj+d9kWndC7ar1AoFCWJJMsLx83sOI6nbPjcBvnj9jafRjRpI1UiCmI9kdJyHC8Ix+WjKlbjZlqMKc2SS4nThoqqUCiuNdKGycXJKNf3t1U87nB/O4m0wdXZ+rlJm42scLyY/g4vABOh5hOOL0xFyPZMRqo7t72SQ7aewnG2OF7ayPzcRfEEqM0eQ5rlhWOAi/MXK+4vRYHjeIXV6EPJUF1/Xorl43M5mlI4ztYyWfys71MZxwrFhmSpsWIinVhyhWqluIrh0HDVTuJ65hxXKow3F59bl2J9paiZcCyE8AHfBVzAW6WU+U8V2WzjQ4tOOwTMSylVDoVCoahIVCuutOzJVIJP6s37MJnQ7HhdhcJ3i9carAejjlKnrBtpQyCloL3F6sRTevmoipUOSsuxOOMqbaRLVoRXKBQbm8vTUVKGyeElhWNrv8o5Lo+mG7laAfksOI4bMzKpHFJKLkxGONBnvaf8uIqx8FguJmIx6+E4TmcnhssIx5UcxwCX5y8vOwsxqScJJoNIKZd0aZVjPYoIKZaHlXHcfO7crHC8uDheTjjWmvdZX6FQFJPUkxVXj1azMqaScPzC+AtVt6VhHMfxWSaijVHYuSbCsRDCAXwV2A+8SUpZIO1LKQewCuX9bN45tsz3D9aiTQqFYmMRLeU4dmQdx837MBnXbPjchcJxp996eA7EGks4TqasLqRSVIVmaOimvqaOYyheqqRiKhSNzjNXZvmXp1QO6FqTzS1eSjje1+vH5bBxdh1yjkfm4/zZ9881fEyGli7tOO5qceF22JouqmI2miIQT3PrLgdgYKQXYu4MaTAUGip5XtpM160wTk44zkRVCFvx62aF40q6cCwVYzw6vuzXn4xOEk1Fq6p4X4pGcUIpyuNz2UkbkpTeXKvxslEVxcJxNqqieZ/1FQpFaSoZjaqZ4Cx3/nLcxgAJPVG3bOFyjmMpJfOJecJauCFW9tTKcfyPwFuAPwG6hRB35325M8f8EfCrQoj/LoS4D/gUltD80Rq1SaFQbCCiWrFw7M44jrUmezjOJ5GJqsinI+PobTTHcTIjFLf7rPaViqoAy3Vcc8dxhSIHCkUj8BcPXeDPvn+OYFxNcqwlZ8ZDeJ12dm/yVzzOabdxcHPruhTI+8STA3ziyQEuT0eXPngd0XQzF/mUjxCC/g4vE6HmchxfzBTG27nJjt05j5HaVLD/SuBK2XPrMUiTUhZlHAtR3JcJewykEyldFa93aW75RfImo5OrmthVjuPGJyu0JppMaI0krb+FxcXx7DaB22FrShe1QqGoTKX+aDWO4+W4jbOsJFvYlGZF1/Nisit/ShHWwrlnhEbIOa6VcPwTmX//Dnh20VcfgJTyi8BvAO8FHgJuxIq0OF2jNikUig1EKeF4IeO4uR6O84lrdryLHMcel8TrMhrWcdziMbAJWdJxDBnhWDmOFdcww3NxTo4EMSU8eWm2bq85Glh/h0KtOTMe5lBfK3bb0hnwh/vbODMeWvaS/tWgGybff9laZjg839i/D003SjqOwYqrGG+yjOMLmcJ427ps2J2zBVEVABORCZJ6aTG8HsJxfr+VriAc2+zWhINcIq5iMDi47L5wMjq5YldVpQGvonHIRTukm0tojZbJOAarQJ5yHCsUG4+KjmOtCsdxifHmSGhkWW7jLCs5ZzI6ydHRo1UdOxQc4sunv1zW/DQbXxgvbFjhWEq5S0opynwN5h33SSnlPimlW0p5q5Ty0Vq0R6FQbDxKZhw7mrs4nmFacQ8+V3H7O/06gQZzHGcdxh6nidtplhWOI1qk5o5jJRwrGpnvvmwtIW9x2TlyfvkPoivht7/wIh/+6qm6vNZ6YZqSc+PhJWMqslzf30Ygnq6rc/a5gXnmYtb9qdGF42SZqAqwCuRNNFnG8cWpCF0tLtp9WeG4CykX3p8pTa4GrpY8N5GuvUie32/p2YxjWynh2CrouFTOsW7qDAYHl9WGYDK44riJRhjIKpbGlxFeY02WCZwrjucpfvb1Ou3ElONYodhwVDIaVRNVEU1FC6KmJqOTPDv67IraspI+bjg0zNXg1QLRdzFpI82RwSM8ePlBEnr5Z438azRCznHNiuMpFApFrZBSls44zhbHa1LHcUKz2r84qgKsuIqGi6rIOI49Lks4TumlHX9TsSkMuba/k8UPD2lDRVUoGpcHTk5w644OXn/9Zp64OINZ46zbeErnzHiIC1MrK3jVLIwE4kQ0ncP97VUdv1Agr35xFQ+cHMfvduBz2RlpcOHYchwXR1UA9Ld7mIokSRvNMzF7YSrCgc1WhIndNQs4MPWOgmMGgqVzx+vhONaMheJ88cxzS2nHcXXCMcCl+eXHVQwEVpa9fq3mGwsh9gkhPi6EOCWEMIQQR0ocI4QQ/1UIMSKESAghnhRC3Fz/1oIvsxqv2aIdIpmMY7+rlOPYrorjKRQbkEorYKpdHRNMBrkauMo3z32Tb53/FvOJ+RW1ZT4xv+x6B8OhYQCOjR0ruT+iRfjKma9wfvb8kteaS8zl/h9MBkuukKpn9rESjhUKRdOh6Sa6KYsdx00eVRHXrPYvjqoA6PDrhON2GmnMns049jglbqfMfb+YsfDYmr92NBUtWG6uHMeKRuXydIRzE2Huv6mfew/2MBdLcXp8bR34i3l5NIQpYT6WIhDbuH8b1RbGy3JoSxtCULcCeSnd5MHTE/zE9ZvZ2d3S8I5jTTdztQIW09fhRUqYCjeH61hKycXJCAc3twJgd1rOHX1RzvFkdLLkwKveURWRpOU6KptxDEijco43WO+nmuW8+ay0RsBk7Jp1HB/GquVzAavYeyn+APgI8BfA/UAUeEQIsaUuLczD584Kx831bJw1iNhKxBB5XY7cZItCodg4lFuhKqUkmqquTsQDFx7g4SsPrzqD35TmsuIqIlokJ1IPhYaKzk0baR68/GBVzmmAufiCcCylLDlZe3z8eNXtWy1KOFYoFE1HttJyueJ4ySYtjhfPOY5LR1VIBKEGyjnOOo7dmaiKVJnieNV2kMvBlCaxdCz3vRKOFY3KAycnEAJ+8hV9vGZ/D0LAkQszNX3NEyPB3P8HZhu7INtqODsexm4THMiIg0vR4nawe1MLZ2os3Gd56tIM4aTO/Tf1s6PL2/iO4yWiKoCmKZA3FkwQSxkc2FIoHBvpnoLjpJQl4yrqLhxrlvvYkHEGAgOcnz3P6enTnJg8wcmZI4y6f5WB+AMMBAYYj4xjmKVFMyklj119jEvzl2q6Ekc39YJB7TXGA1LK7VLKnwXOLN4phPBgCcd/LqX8eynlI8DPAhL4YH2bulAcr+kcx8k0rSViKsCKfYprzfV+FArF0iT0RMkxXSwdw5TVje/zV/OsluWsrMm6jbPku46llPxw4IdVu5/DWrjofSyOzphPzFcs8rvWKOFYoVA0HeUKZmSX2GpN6kJIZIRYr6u4/Z0t1ntupJxjLW3D5TCx2cDlKF8cr1bku6qUcKxoRKSUPHBqnLt3d9Pb5qHb7+bGbR08fqG2OccnRoJ4MyswrkzHlji6eTkzHmJfjz+32qQaDve31y2q4oGT43T4nPzYvk3s6PIxPB+va2G+5bJUVAXAeLA5CuRdzMS0HNzcSspIIUUMYY8UFciD4sEe1F84jmrW/yP6LIFkAIHA5/TR5e2it6UXj7wecBFPx5mITnBh7kLZfm8mPsMTg0/wxdNf5Knhp1Zc/K4SM7GZqgfxGw0pl3zj9wBtwFfyzokBDwBvrmHTStLialLHcYki2Fl8LnvTvR+FQlEdpfqsWvRj1bAc1/LiZ4mR8EhOeH529NmSzxrlKDUxuzjn+KWJl5DU75lSCccKhaLpKOc4zmYca03rOLYe7ks5jjv8GeG4kRzHaRueTCE/t9NE0+ssHOc5mVe61FahqCVnJ8IMzMS4/6b+3LZ7D/RwYiRY0wiJEyNBXneoF5fdxpWZjes4PrOMwnhZDve3MRZMEIzXdrIpkTL44dkp3nzDFlwOG9u7fGi6yUxk7Zwwa42mm7l+dDF9GcfxeJMUyLswaX3u+ztt3P/F+5mOTVsF8lLFwnFQCxZtq1SwZq3Q9LyM44wbNKlb7d7fvZ89nXvY0b6DbW3b6DV/jW3iN7ih9wb2d+1HMzTOz54vWHmzmJSR4sLsBc7NnFvztqvCeBU5BBjA4sDpc5l9dcWbFY7XORP4/GSY40OBqo+PJIuLYGfxuRxN56BWKDYCpin5+vFRUjUcaweTwaJty41gWiuqdRzrps5YpDia8dj4Mc7NnOPU1PKKVZcqrjeXmGNo2sZ0yMl8Yp7B0OCyrrlalHCsUCiajpxwvOiB0mW3IUQzZxzbAInXVdwZt7hNnHazoQrkJVM23M484bhMVEWtUI5jRaPzwMkJ7DbBm25YiLW892APUsKTl2oTVzEVTjIRSnLrzk52b2rZsMLxTERjOqJx/QqEY6h9zvHjF6aJpQzuv9GaNNje5QNo6JxjTTfLOo79bgdtHgcToeZxHPe1e+hv76C/tZ9IKoLDOYuR7i46Np6OFxXAqbfjOJEyAJ2knsDj8GAThUM0mz2GNK3PUJu7jUPdhxBCcHHuYslBdj7LyWislnIuLN3U61qsp0HpBKJSFlUFDgA+IYRr8QlCiA8IIV4QQrwwM7O2fUNLg0RV/Nn3z/MHX69ePAnEU3R4nSX3KcexQrE+vDAU4Pe+erKmK+dKxUetl+M4oScYCAyUjYfKMh4ZL1lIbzQ8ypNDTy77dWcTxcKxlJLvH+/kyKl2Xpx4se4r2JRwrFAomo5yURVCCDwOe9MKx4mU5eC1lbgzC2G5jhvLcSzw5IRjK6qinn1YvuN4owrHS1VvF0L0CSH+SghxUggRzVRw/4wQor/EtbYKIb4phIgIIWaFEH8vhPDV7c1cY0gpeeDkOK/at4mulgWd4MZtHXS1uHiiRjnH2Xzjm7d3sLe3hSszGzOqIptTfLi/fVnnXd/Xljm/toOQB06Os8nv5q49llC5owmE42TaKJtxDFbOcfM4jiO57Oubt9xMLB3D5pxCmi2YRuFtT0pZNCith/iZzS+UUqLpBsKWJpERjhdjs8cwjZbc916nl0Pdh/A4PFwJXClwLy9mNjG75KB3OUgpy4rRk9FJ7v/i/VUXMVJYSCk/IaW8XUp5e09Pz9InLIOs4zi2zkLrWCDOWDBRtdgxGUqypd1bcp/lOG7OZ32FopkZC1p941igdpPIV4NXiaUKn11rUS+nWn5w5Qd86qVP8d2L3+Xk5EmSevFzUKUYipXESZSKqpASogkX8zHBUGho2ddcLUo4VigUTUe5qAqw4iqS6eaNqigVU5Gls0VfF8dx2kiXfNDX8qMqHCZSCnSjfq7jfMdxLYsArTNLVW+/Dfhp4ItYlds/DNwFPCOE8GcPEkI4gYeBncDPA7+DVaznE7Vs/LXMSyNBxoKJgpgKALtN8Jr9m3ji4gymufYzLSdGgjhsgsP9bezt8TM8H0fTN94AOyv8Ltdx3O13s6XNU9MCeZFkmsfOT/OTr9iC3WbdE7d2eBGisYVjTTdzRWZL0dfuaYqMY90wuTwT5WCmMN5Nm2/ClCaazUoOKJVzvLiSuynNimLsWpCd8IykIhimAyliaIaG11Esli0WjgGcdie7O3YDEE6VnwgxTIO5xNoVsptPzJecrDVMg5n4DHdtvQu/y1/izGuGAOAXQiy273cCcSllXWe63Q4bdpvIuNrXByklE6Ek8ZRBOLG08zmZNpiLpXLZ6ouxHMd6Q2fGKxQbkezkcS1XH5nS5OzM2YJt6+U4zmJIg9HwKM+OPst3L363qA8cCq6dkBtNRXPidNpI55zM0vRgmA7CcVtNxg9LoYRjhULRdESSlkhYKvvM3cSO47hmw1cipiJLp18nGHPUzdUrpeTi3EW+fObLfPH0F3lu9LkCl5GWsuFxWo3JRlbUM67iWnAcs0T1duBHwCEp5UellI9LKb8EvA1LIH5H3nHvBK4D3iGl/J6U8vPAh4B3CyH21/g9XJM8cHIcl93GTxzeXLTv3oO9zMVSvDy29uLlieEg1/W14XHa2dvjxzAlw3ONK1aulLPjYbZ3eWkvs5S5Eof72zg7UbtByCPnptB0k7fmTRp4nHa2tHkYmW9M4VU3TAxTlo2qACvnuBmiKobm46R0s8BxDJCQgwAlc45LDUpr7TrOCtOhZAikk7SwHEulhGNhjyGNFqQs7GPddjcOm4OoVtnhu5zK8EtRLqZiJm4VzHvPTe9Zs9dqUs4DdmDfou2HMvvqihACn9NObB2jKsIJPecQHq/iHjIZskSTbLb6YnxuO6Zs3pomCkWzkn0GGA/VdvXRudlzBQVY1yvjuBSz8Vm+f+n7OUE3kAisqSM6P9/4SuAKA4EBAEzdWmFnmi6kWXpSrZY0zppnhUKhqJKZaAohoMtXFBNnOY6b9EEyodlyRfBK0eHXMUxBJGGnzVdbcTyQCPD0yNMFBXBOT5/m9PRpun3d/NTBnyKZXsg4dmUEZE234ac+P/9oKoqUEiHEhhWOl6reLqUMlth2UQgRB/Ktrm8Gjkkp84PDvgWkgDdRXMRHsQoMU/K9UxPce7CHNk+xsPmaAz0IAUcuzHDT9o41fd1To0F+5tZtAOztsVx/V2ai7M+IaBuFsxNhDvctL6Yiy+H+No5cnCGZNvA4ywulK+WBkxP0t3u4bUdnwfbtXT5GGtRxnBVgKkVVbO3wEoinSaSM3PL3RuTipDWAO5j5zHd4OvA4PMT0GVwiXdpxrBVP4sTTcTq9nUXb14psvxXSQkizg7TNGhyWi6oAG9L0IuwLnyEhBK2uVqLpysLxWuYclyqMZ0qT6dg0ra5Wrtt03Zq9VpPyDBDGWtXzpwCZWKj7WadVPj63fV0dxxPhBbF4MpTkur7KK0Wy4nJfOcdx5r4dT9XmHq5QKEqTndSZrCAcn54+zcNXHiaRThBPx9EMDbuwW182O/u69nF7/+0VXyeejjMQGGBf1z5MaTZcdv5kdJKHLz/Mm/e/uWJMxUrIxlTopp4rgJs20khj4b5pGm3Y7PWNDlOOY4VC0XTMRJJ0t7hw2ItvYR6nHa1ZHceppaMqAAI1jqsYCg3xzfPfLFs1fS4+x5W5QVJ6XlRFznFcv27FlGauQ92owvFKEELcCPgojLYocjpllsteYR2qvG90nr86z3REK4qpyNLV4uKmbR1rXlzk8nSUWMrg5owYvafHWtq+0XKOo5rO1dnYsmMqslzf345hSk7XwPEdjKd48uIMb72pH5ut0B26vdPXsFEV1QjHWRGnGsfgenJhKoIQsK93IS4hK67anFPoJYTj9XAcZ/uteDqOlE7StlEEooxwbAnDi+MqAPwuPykjVTFao5xLeLmY0ixZOX4+MU/aTLPZX7zCYqMhhPAJId4phHgnsBXoyX4vhPBJKZPAR4H/KoT4bSHEjwNfxRp3f2w92uxzOdY143giLxu9mvtH9viywnEmqi6mrW/BP4XiWiMXVVEhtmoiOsFIaITZ+CzxdBzDNEgZKRJ6gmgqytmZs1VFDJ6ePg1YbuOV5ATXmpHwCI8OPMpgcHBNr5stjJdfKyCkhTD0BbOEqa/s+Xc1KOFYoVA0HTMRjZ7W0g+Tbqe9KR3HUlqOY5/LJG2kSxayybqRg8sokCel5Ojo0ZIVakthmAbPjTxXsDyoFCcmLA0yVxzPYf2bSgtOTJ6oun2rJbt0KW1u2IzjZSGEsAF/h+Ug/k7erk4gWOKUQGZfqWvVrMr7Rue7p8bxOu38+HW9ZY95w/WbOZHJQV4rTowEALh5RwcALW4Hfe0erkxvrEJVAzPW+zmwQhf13Xu6aHU7+IfHL69lswB4+Mwkuim5/8biSYMdXT4mw8mGjFPK5mBXcu/1ZQpVTTR4gbyLUxF2dvkKXNF+lx9TmuiOUyWjKhZnHINVTb2WZIVjTdeQ0kmKUTwOD0IURz4JuzX5U044BioWpIun42uy1HcsPFYkUEspmYpN4XV4aXPVfzC7DvRiCcFfBe4Grs/7PnvT/yjwv4E/BL4LtAFvkFKuXWbIMvC57CTWMaoiXyyu5v4xGc4Kx+WK41l/24kGvJcqFBuZbFTFVETDWGHObspIcSVwZcnjJqOTzMZn1z3fuBJXAleYiE6s6TWzjuNoKopA4LQ5CSQDBWKxqa9sxd1qUMKxQqFoOqYjGr2t7pL7PA5bQw7Kl0JLC0wp8LoNxiJjzMSLhbo2n4FNyKodx4Zp8NjgY7w8/TKPDT5WVGigFKemTlWV0zQftx7qFxzH1sPDZDjE8YnjJNL1caRl26ocxzn+HHgl8B4p5arU9FpWed/IpA2TB09P8vrrN+Nzlf9bfeuNfQB879T4mr32iZEgbR4Hu7sXxKW9PX6uzGws4fjqrCWi7d5ULKJVQ4fPxX/88f08fmGGI2vs+n7g5AS7un3csLVYQNvRbYkgozWsRr5SskVlKxXH25rJG214x/FkpGhSodVlfZ+0ncbUO5Fm4d9mQk8U9SM1zzg2tIV/pZOUmCjpNoZsVAXIEsKx1+HFLuwVhWNYm7iKgeBA0bawFiapJ9ncsrmk6L3RkFIOSilFma/BzDFSSvm/pZTbpJReKeWrpZQvrVebfS47MW19Hcc2Ab2t7qruH+PBBJ0+Z9lInBaXchwrFPUmkTIIxNP0t3swTMl0ZOWTyOdnq4t7Pz19ek3zgxudQCKQe/aIpqL4nD46vZ1EtAjptBubPQyYBe7jeqGEY4VC0XRMhzV6ygnHTRpVEdesh2Of22QkNFJyWalNQEeLXpVwrOkaD115KOc0llLyzMgzHBs/VvacaCrKyamTVbXXNKzB7ULGsfXv2ZmrSCkZj6ydGFaJiBbBMI0lHdLXAkKI3wI+DPyKlPLoot0BoNRTRmdmn2KNeObKHPOxFPdnhOFy7Oxu4aZt7Txwcu2cCi8NB7lpe0dBRMLenhauzMQ2VPX5oUyxv53dvhVf41fu2cWubh9/+r1zpI21uX/MRDSeuTLL/Tf1lxTQdnRZ7R0JNF5cRdZxXKk43uZ2q99tZMfx0FyMgdkYN24rvN057U7cdjdJBgAbht5VdO7inON6RVUk9SSGaaAzX7IwHiwIx6Ucx0II/C7/koPr1cZVGKbBcLA4y3EyNonT5qTLW/wzVTQGPpeD+Do+G0+Ekmxu87Ct01sxGzX/+C1l3MZATlBez9xmheJaI7sS4Nad1kLF8VU8C8zGZ0uapBZzef4yM7HarXpM6knOTJeqPb4+ZAvhGaZBLB2j1dVKh6cDiSRqjGJzBLHZIyqqQqFQKJbCNCWz0fKOY7fDlnNONRNxzbode10GI+GRshXQO/z6klEVwWSQ7178LhORYkHq5ORJnhx6MlcJNp/nx54vub0U2WquUd1yMGUjK7KOlroJx6mIchsDQoh3YGUn/mcp5ZdLHHKeRVnGQggXsId1qPK+kXng5DitHgevPbi0S/v+m/p5eSzE4OzqM4hjms7FqQi3LCq2t7fXT1TTmY6Uzz9tNgZnY/S1e1ZVFMnlsPHffvJ6Lk9H+fxzQ2vSrgdPT2BKymZbb88Kxw2Yc6yll844djvsbPK7GV/DeJW15t+fHcIuBO+8bXvRvlZ3KzFzEolRMq4inCxcDltL4Vg39dyEZ1JPksLq873O0mKZsCUAs6RwDFZchWZoFXMjVyscj0fGcy7pLLFUjGgqes24jZsVn8tOfB3duROhBH3tHvo6vExUIRyPBxP0l8k3hjzHsRKOFYq6kc01vi0jHE+scvXR+Zmlhx+6qXNh7sKqXqcSz489z3Njz615TvFKyUZ4ZGv4+N1+/E4/DpuDqDyHzRHC5ghjZgrlDQWH+MLLX6hL25RwrFAomopAPIVuyvJRFU47Sb35HiQTKet2nJJzxNNxpmPTJR2CWcdxKfNgNBXliaEn+Pq5rxNIljeRXpy7yNfPfZ2R0Ehu22R0MjfLWQ3StAa3V4PWLG2aaGZ7pnhStH6O42tdOBZC3At8HviYlPKvyxz2IHCHEGJn3ra3AW7goZo28BpC0w0ePj3JGw9vqejczPKWV1iu5O+uQVzFy2MhTLmQb5xlb4+Vf7qRco4H52Ls6l5ZTEU+r7+ulx/b183fPnKJYHz195EHTo5zYLO/bPZyj9+Nx2ljeK4BheNccbzKn9utHZ6GjaqIaTpfOTbCm1/Rx5YSolOrqxVT6qTEVYwSBfLq6TjOzwnWdA0NqxhtuagKISTCHi8ZVQELURyV4irmE/NVFSQqR6lMyqnYFHZhZ5Ov+OepaBx8Lgfx9SyOF0rS1+Glv93DeDCx5AoY6/jywnHWcRxfx9xmheJaYzwz6XPrDks4rmb1QCWuBK5UNYar1arSicgEF+cuIqXkyOCRXLbwepGf55zty/1OP0II2t0dxMUphH0emyOEqbcTTUUZCg3xxOATdWmfEo4VCkVTkXXNlSuO53Hacs6pZiIbVTGnWctAk3qyaBAL0OnXSem2nNAMkEgneHbkWb565qtcmrtU1ZL0iBbh4SsP88jAI0RTUZ4dfXZZ7c0KxDPJYaZj0xwbOwpCwzTduevXo5hBJBXZ0IXxlqreLoS4DvgWlmv4y0KIu/O+9uZd6muZY74hhHiLEOIXgL8HviClvFTnt7VheeLCDBFNL+s4XUx/h5c7dnWuSVzFiZEgADdt6yjYnhOON1DO8eBcnF0rzDfORwjBR956PZFkmv/7yOr+DMaDCY4NBkoWxct/ve2dPoYb0XGcjaqokHEMVrGqahyD68E3Xhwloum8955dJfdni8ilHMcw0sU1QRf3WbXM6s8fLGuGRppxBA7c9tKT4gA2W6ys49jn9GETtopxFVLKqpYGj4XHirYZpsFwqDCmImWkCCQDbPJtwm5buftfUXt8Lvu6iaxSSsaDCfraPGxp96LpJoF4+ee2eEonlEiXLYwH0OLOCsfNZxRRKJqVrOP44JZWvE77qqIqwHITX55ffZHi+cT8ss8xTIOnR54uaMsPB35Ytxo9pcg3cEVSEXxOX65vbXdtRooECdtZbI4wad3NYHAQt93NX/9EOc/Q2qKEY4VC0VRkhePeto3lOM5GVUwnFjqNyehk0XGdLdaDfyDqQNM1jo0d48tnvsyZmTMYcvnvezA4yFfOfGXZs6xmxnFssyV5cuhJBgID2Gwa0lz4vZSKylhroqloUYX3DcZS1dvvwsouvgl4Bng27+sj2YtkCuW9CRgBvoIlGn8d+ECd3sc1wQOnJuhqcXHP3u6qz7n/pn4uTEW4MLm64h8nhoPs6PLR7S+8N25uc9PisnNlZvVxGI1AKJFmPpZi1yryjfM5tKWNX7hzB599bmhVkSHfO2Xd7966xKTBjq4GFY6riKoA6OuozjFYb6SUfPqZQW7c1s6ti1z3WVx2l5VzbD+FoRcLx6Fk4WRtUk/WzOmUFY5TRgrDNEmJUVyiCyEELa7S4rDNXl44FkLQ4mxZskBeuRisLLFUjB8M/KBIYB6NjBY5w7K5kz0+VTy10fG57esmsgbiaTTdzDmOgYpxN9mJqf4KjmOf04qqUMKxQlE/xkNJulpceJx2+jo8q46qADg3e25V58/F53jo8kPLXk1zauoUwWSwYFs0FeWRgUcwzPW5r2SFY1OaxFKx3GQ3QIttO0J6iZoXsNvDBB1fQjM0Dm46SKu79Cq3tUYJxwqFoqmYyQrHlaIqmrA4XkKz4bCbBLSFQV2pPMIOvyUcnxgd48tnvszJqZNV5xKXYyUDY8txrINI5zpesUg4rkfOsSnNirEczc5S1dullJ+usP+9i641KqV8u5TSL6XsllL+tpSy8RSsJiWe0nnk7BRvvmELTnv1j1dvvqEPm1hdXIWUkheG5nO5c/kIIdjb698wjuOhOUvcXQvHcZbfvHcvhil5/ML0iq/x3VPjvGJrO7uXaNf2Lh8j8/GGE16zURVL5UZv7fASTxmEE421RPxHl2e5MhPjvffsqpi163f5SYrLGOniWqGLHccSWTP3UTYrOKknATtpMYJbWMXlDvccxiaK7yHCHsM0y3++Wl2tJPRExWeC6Vjlz/jV4FUM0+Dxq48XDMSzhXazmNJkJj5Dh7sDt6O8S1rRGPicDjTdxDDrf9/Jikv9mYxjqLzEPVt8c0vb0sXx1jO3WaG41pjMZJUD9Ld7c9EVqyGQCJQ0SlXLyamTxNNxXpp8qepzQskQJ6ZOlNw3FZvi4tzFFbdnpUxFp3ITv7F0DInMRVABSKMLr3E7EX2YOBeI2L9Dt3snHZ6OurVRCccKhaKpmI5YnVRPOeE4Uxyv0QblSxFP2XE6tIJ2l3IGdbTogOTKbGhds32l4UHYkuSPz4UtmYuwAJiIlnYcn5o6taZtX8kSJYVirXn03DSJtFF1TEWWnlY39+zdxAMnx1d837oyE2U2muKu3V0l9+/t8W+YjOOrGVfwWmQcZ9nW6WNbp5ejAyu7lwzNxTg5GuL+m/qWPHZHl49Yyqi4VHs9yE64Luk4ziwfb7Sc408/Pcgmv4ufvLHy76DV1YpJAs0MIGWhSK4ZWpFQnNBr8z6zfaCma6QNMGyzeGzWxE+Xt4ttbduKzrHZY2UzjmEhiqOS67hc/YQs2QJBYS2cW8ZbKqZiLjGHIQ16W3rLXkvROCxEO9RfaM0KwfmO40pOxey9pZLj2OWw4bQL4k1oFFEompWJUDL3DNDX7slFV6yWoeDKChSHtTBXg9ak5pnpM0UO4nI8M/pMRVfxal3QKyE/piKqZfKN8xzHpt6Oz7wbXaYYTj6OQ25hi+vOurZRCccKhaKpmA5r+N0OfJmKyotxZ9xSWfdUs5DQbAhb4WAvrIWLivM47OB0RtG1vpIF8qS0EZ19C8Gx9xd8JcK3l3xdaTqIztxPKnZgWe01TQ82e+FM82LHcTwdJ5AodAMHk0FeGH+Bp4efZq1Y72IGCoVhSv7pyBW2dXq5Y1dp8bYS99/Ux+BcnNNjK8sFP3rVEjzv2lM6ImNvTwvjoSSxDeDOGpy17ok71yiqIsudu7t4fnB+ReL9s1ese9Abrt+y5LE7uqx2N1pcRbXF8bIFq9ZiiepaMTgb47EL07z7rp1Ltj+7pDPo/BwJzVm0f7HruFYF8nLCsaGRTFv/d9stF7TX4eVAd3GfbLPHkKaXTk9psbbF1YJAFAjH0VSUmdhM7nOtGVrZwXU8HS9Y6XR5/jKX5i8xEh4pmOyVUjIdm8br8BYMbBWNy0IxufoLrfmO401+Nw6bqOhUzDmOSxS4zMfncijHsUJRR8aDidyETl+Hl5moRtpY/Xh7qZUw5Xh56uVc32ZIg+dGn1vynMHgYMkc/3zmE/OrckEvFyllTgAHq9/2ODw4bAtah2m04TVuQSAwpU53+neQZvWxeGuBEo4VCkVTMRPRysZUwIJbqtkK5MU0G7ooLoa32HUcSARw+E6Qih8iEby3YJ+Ugsj0z5AM34UQacsRbEsipYPY7P0kQnctOt5OeOrnSUZuJzr7k0Xuq0pI04uwVRaOoTiu4tjYMUxpciVwhUvza1OTTTmOFevNV18Y4exEmP/ypkPYbeWXyZfjjYe34LQL/v3ZQV4aDuS+ZqPV5XcfHZinp9VdNvc3WyDv6ioyfBuFobkY/e2eJSMVlsvdu7uZj6W4vAJn9pWZKG6HLScKV2J7wwrH1TmO+zNuo7EKRXEiyTTROgo6//7sEHYh+KW7dix5rMvuYrPnOpK2k5wLPMNQcKggJ39xUdpaCcfZ10zqSZKZ/3vs1t+pz+lje9t2PI5C4cxmt/5+X7v9LficxZ81m7Dhc/qIpqKEtTAX5y5yYe4Cw+HhAuf0UKi0u2soOFQ0cfLsyLOcnj5dsC2SipDUk/S29FaMBVE0Di2u9csEHg8lcdgE3X43Nptgc1tlp+JkOMEmv2vJSSCr4J9yHCsU9SCm6YSTem5Cp6/dg5QwFV59XMVsfHbZucKJdIKL84WREqPh0YruZcM0ODp2tKrrn5upn+t4MjqZe9aQUhJNRwtiKgBMvQ2Hw2CzfzP9/q14zOsw9ba6tRGUcKxQKJqMmYhWNqYCFvIZtSYrkBdJSIStWNRZnHN8fvY8vq5HcftfIh64j3jwVYAlGkdn3k4q9gp8XT+gvf8ztPd9jva+z9Gx9RO4fOeIzb2FZPi2zPE2IlM/RzqxH7f/RUyjAy1yU9XtlaanKuE4P65iIjJRMGB9duTZInfXSkibjbXkW3FtEUmm+esfXOD2nZ28dYll8uXo8Ll47YFevnp8lJ/+x2dyXz/zj88smUkppeTo1Tnu2t1VVsTZ22sJUhsh5/jqXIydaxhTkeWuPZZT/Lmry5+IujITY/emlqomDbZ3WcLrSMMJxxnHsbPy0KCn1XIMlhJ+NN3gH49c5u4/e5S7/+xRPvHkFVI1Xv2TTBt89fgIb3lFH71tlR2KWfpaN9Of/Be6HIeZS8xxZuZMri+ql3CcH1WR0OMI6cFl82ATNjwOD3abnT2dewrOEXbr71fXvdzad2vJ67a6WomlY1yav0RST7K5ZXPR+zg1dSqTrVxIvuMpv52LnVfTsWkcNgdd3uWvrlCsD1nH8XqsOpkMJdnc5sndH/s7PLkCeKUYDy4sh6+Ez2UnVqfoDSklv/eVkzx1aWbpgxV15+vHR/nog+fXuxkbmlzRyryoivztq8GQxrJdx6dnTpcUm58be66sCH1q6hQRrbpC1IPBwZrVOFjMlcCV3P/j6TimNItW8xh6OzZHiK2tW+lr3YLNEcHUi2s11JLSa70VCoWiQZmOJHnFto6y+7PCcbLJHMfJlB2nu4RwnOc4ThtpLs1fQgiJv+fbSOkgPv8GhNAxUj1o0ZvxdT6Gr6MwBkIIk9bNXyU8+fNEZ98KwiAV308qfoiW7u/haXseI7WZePBVuFtPIMTSPzvT9OBwFMZQLM44BksszjqYnh97vmBfykhxZPAIbz3w1pKFgBSKZuDvH7/MbDTFp957x6rcd3/1zhs5MRrMfX92PMxfPXyBR85N8cbD5SMQhubiTIW1sjEVYMU62AQbIud4aC5e8eexUnZ0+djS5uHowBzvuXvnss69MhPlhq3VPcD7XA42+d0MzzWYcJzpM11LFHa0Zx2DeYNFKSWPnJvmT793lqG5OK+/bjOmlPzZ98/zpedH+Mhbr+e+Q7XJwn3i4gyRpM47bivOBC6HzR7FIVrptd3P1l7B2ZmzBJIB2txthJP1iarIL46X1GM45XZsdh2Pw5O7j+zv3s/ZmbO5czpbHESAuGbnwOYDnJk+U1QctsvbRTQdpcvbRbe3G4FgJj5T8D5SRoqXJl7ildtfmduW1JNl6xIUtFvXCGkhtvi3lOy3m6y8xDVD1nGcWIdM4Pzl7WDlpJ8YCZY9fiKUqGpycHuXb0UrRFbC0Fycr784iqYbvHp/T11eU1E9//7sIGcnwvx/r9+/5quRFBbZyJlccbxMocvxKnOODdMgZaRIGSlMadLh6Sh4Zp6KTdHXWp35ImWkyjqCI1qExwcf57U7X4vTvhBHFUvFODl1sqrrgyVmX5y7yE1bqjdVVSKRTjASHmEkNEIsHaPF1YLf6cfv8udqC4C1ogco6Th2ekZz39vsobo7jpVwrFAomorpiEaPv5Lj2BrIJJvEcWxKk4iWxDCduG3FA9S5xBxpI43T7mQgMJBzKQkhae39BpEpO7G5NwPg7XgSb8cTJV9HCIO2zV8mPPmLRGd+GoCWrofwtltirrfzSSJTv4AWPYyn9eUl2y0ND7bFjmOhIaUbKQVCLOQpziZmCSfDzMSLnRrTsWmeHn6aLm+XlfWoJ/E4PGXdVApFIzE0F+PffjTIO2/bxo0VJrSqobPFxX0HF8S1V+/bxBeODvPppwcrCqVHr1r5uneXKYwHVm7tji4fl5pcOA4l0szHUuzetLb5xgBCCO7c3cWzA3NIKaueBEimDUbm4/zUzVurfq0dXd6GjKpw2ASOJYRjgK0dXr53aoKnL88CYErJbDTFvl4/n33fnTlh5fEL0/zJA2f51U8f40Ov28fv/cTBNW/3AyfH6Wpxcc/e6rP+hJDYHUEMvYMWuwuv05tzFi1eBVMrx1FBxrERwW3eDCJdEEHR4+uh09uZqxVwc99ehgesaCubsHHn1jt5+MrDBdf1Or0c7C78OXsd3pxwnE5uJzb/es7Kz3N9z/W0e6wJj8HgYFX53rOJ2VzbShEP3MvvfHaWx37PxFnFZ0lRH9bTcTwRSnLz9o7c930dHh46ncQ0JbYSqzQmgkleWWEiNMttOzo5cmGGUCJNu7c4r3wteXHY+ht8aThY09dRLJ9k2uDMeBjdlJweC3H7CupMKJYmmz2eFYyrcRzrps5UdIrZxCy6WXjv2d62vaC46uIVtpU4P3u+YpH1weAgYS3M6/e8nja3Ja4+P/Z8URuqeZ0bN9+4KlPITHyGZ0eeZSY+U9jHlkmOi6aiuO3uAtFbSoGpt2GzLzyf2BxhdG15xbhXixKOFQpF0xDVdOIpg962CsKxI+s4bmzh+NsXvk0oGSKhJ9DTrcBBbPZiIcGUJjPxGfpb+4uqvFpO4q8RnX0rdkcIb8cRKvVtwqbTtuULRGZ+CqdnFG/7QhEBl+8CducUieBrcPtP54TfUkiZyTheVBzPZrMcVNJ0F+wbDY1yca4whyqfC3MXirZtbd3KZv/m8m9GoWgA/uz753DYBR9+49oLYg67jfe8cicfffA85yfDHNpS2llw9Oo83S0u9vVWLlJ18/YOnrw0W3aw3gwMZjKaaxFVAVZcxXdOjnN1NsaenuqKfg3NxTGlVYCwWnZ0+XhhKLD0gXVE082qnVq//bp9PHS60J16fV8bP3/njgKx8L6DvfzY3k2899+e57unJtZcOI6ndB49N83P3Lp12SKlzRHASHcC4HP4mE3MIqUkpIUKJg5qHVURSobQpUar3IEQs3idhUv0D3Qd4OjYUbb4t7B3UyZ2Imn9nra3b6e/tb+olsBifE4fcwlrQkSL3oCe3EUq2ccL4y/w43t+HKDA8VSJsBamxdmCy+4qfUB6F+4WhxKNG4wWt/WZSdQ5E9g0JZOhJH2vWHAc97d7SRkmc7FUUfRcJJkmoun0dSwdVXHbTuvv98RIkNceqK0L+Hjmfj0WTDARSlQVpaGoD6dGQ+iZSK/jQwElHNeI8YzjeHMmEqrV46TV7WCyhHCcSCcYi4wxHZu23MXuDlpcVr/hsruYiE4wGh6lzd2Wy/Kfjk5XPWlfLqc/n/nEPN++8G1et+t12G32gjiIaomkIoyGR9nevn3Z5wKMhEZ49OqjVQvWhmkQ1sJs8m0q2C4NH+DA5liI0rI7QqTih+q6ykf16gqFommYiVjCZMXieFnHcYNHVczGZ4mn40gpMx0CCHvp6cep6BQzsRlm47NF+4QwaO35Nr7OyqJx7nhbmrbNXysQja3rSHydT2Kke0nFD1W+iHQC9pIZx0BRzvGJqRO5pTfVsjjWQtH8DM/F+cNvnGJorjkLtA3Oxvij75zhI986zUe+dZrf/+pJHj4zxW/fty/3IL3W/Pwd2/E4bXzmmcGyxxwdmOfOCvnGWe471Mt8LMWpseIinM3CYOazs3tTjYTj3ZbL7fll5Bxnc6P3Vik0gyUcjwcTa1KNfK1Ipo0lC+Nlee2BHv78Z24s+HrPK3eVFAtdDht37+nm6mxszQvmPXJumkTa4P6blu+6sTsDmOkupLRcuqY00QwN3dQLxOJaF8fLFnd1mtsRtjQ+R6Gbfm/XXoQQ3N5/Oy6HxGEziWsLP+c7t9655N++z+lbeH+a5YxPa9u4GrzKVHQKTdeWFJ+B3M8m6+BajJSQTm7lhq3V/y0o6oPPaXnFYnUWjudiKVKGSV9eH7kl51QsdvNnRaism7ESN23vwCYWRN1acnwowKbMascXh4I1fz1F9WTd4Jv8rrp8Fq5VJoJJNvnduPKeE7a0e4qiKh4deJS/euavmIxO0uZu4/pN17O3ay9b/Fvo8nbhd/nZ2b4Tm7AxFFooyKoZWlH0UimklLlVOEuh6RoPXXmIx64+tox3WsjZ2bNLH1SCczPn+MHAD5blcg5pISSSTk9nbpsQAsOwVgblC8c2RxikE9NY+xV45VDCsUKhaBqmM5Vbe1vLP1AuZBw3tuM4H9OwRJBSjmOAydgk52drX/TB1XIGm3OWeOA1FWcwTdNyWthshQ8LWSFZykLheLmVcsFaslStA0rRPHzx+REeO7+8AhiNgGlKPvTFl/jC0WG+9/IE33t5gsfOT/PKPd2871W7a/a6HT4XP33LVr750hiBWPGyvNFAnLFggjsrxFRkefX+HoSAx5vw559lcNa6R+7oqs2D8t6eFjb53RxdjnCcif/YswzH8b7NrZgSTjeQiK/pZtXC8XI53G8JjecmVl8MNZ/vnhxnc5ubO1bgMLM7AkjpQZreXDxENpYiv0BerR3H0bT1+bHJDsSiqAqwRN+7t97NFv8WhACfxySmLTjDN/k2saejsIjeYrLXjKWS6JqVIaknrUzo58eeZyg0hCmXnsSIpqy2Ls5ezGLqXeiGSwnHDYgv5ziub1RFTgjOcxBni2uVWuI+nhOOl3b0trgdHNrSxkvDtRULI8k0F6civOuObbgdtpxQqWgMjg8F2L2phdfs7+HF4WBVkTuK5TMRThZklYP1d7347/jmLTdzcNNBrtt0HXs79xatogFw2V1sa9tGNBUtiDHMr+tTjkgqUjGmYjFSyor9eCKdYDo2XfZzMxoeXXYh92Pjx3h65OllfxYDyQAOm6OgMF6fv48O5y4A7I78qArrOUXXS/fHtaBmwrEQYp8Q4uNCiFNCCEMIcaTEMUII8V+FECNCiIQQ4kkhxM21apNCoWhupjOO48VL2/JplqiKfEwz4zi2lXZiTsemV7TEZrkIIfF1PIWR6icVP1D2uGwBvPKO47VxXx4bP1bVYFbRHOzo9rFnUwuPX2i+quRff3GUl8dC/OU7b+TFj7wh9/XFD9xd80Isv3LPLpJpky+/MFK07+iAJXBmnbKV6GpxcdO2Do5cbL6ff5ahuRj97Z6a/cyFENy1u4ujmZzjLKYpuTBZetXElZkoWzu8+FzVp7+9et8mhIAjDfS3oOkm7hr9XA/3W26ZM2solIeTaY5cmOEnX9GPfQXRKzanJf4YemduqWx2cJk/SEyb6WXnIlZDduCbFatttCJEuuQg+3Dv4dz/fe5CxzHAoU2VVwl5HB4EglhSAA6ELZ5zHk/Fpnhh/IWq2hzRIggELa7SkyQibQnYSjhuPHzZjOM6O46zy9v784Tgvoz4NFGiqFZ2WzWOY4Bbd3bw0nAQw6ydWHhyJIQprX72xm3tytXaQEgpeWk4wC07Orh1ZyezUY2R+drk0l/rTAQTRX+X/e2eopUD3b5u3nX4XUWToIvp9nbT5m5jLDKWW4FTTc5xdpXOWiClZCA4YBWtC4+UFHqllGUL8ZUirIU5OVl9Eb4s2ZiKTk9nwSqiXR276HTtBUo4jgEjvQGEY+Aw8BbgAlAu3PIPgI8AfwHcD0SBR4QQa18uW6FQND3VRFVki+NpevMIjnIJx3HaqM3AtRRu/ynszhmiMz+TcyYtRhpZ4biM49gs//tZDqFkqMhpHUqGKuYlKxqbew/28tzAXN1zFldDTNP5y4cvcPP2Dt62giXxq+XQljbu3tPFZ58dQl8UbXD06hztXieHtlT34HjfwV5OjQaZi2q1aGrNuToXY1eNYiqy3Lm7i/FQktHAwv3tow+d543/98mSTrMrM7FluY3BKoR48/bGEvG1ZURVLJfNbW66W1ycGV87x/EPzkyRMkzuv6m6KuyLsTus36WZ7sAmbHgcHhJ6xnGcLBS4a+E61gzrbzD7mjbpB1ux43gxLW6DuFYo8G/xbynrAgZy7y+etl7T0/oiptGOkXEqVfv+wqkwfpcfmyj9OXGbB3A5THb3qPzXRsPjsCMExOvc9+aE4DynYneLC5fDVtZxLMRCnMVS3Lazk6imc3FqeXFoy+HF4QBCwM0ZcfLMeKipzCkbmeH5OLPRFLft7MxlXitHeG2YCCWLVgL0tXuZjabQVlCQXgjBzvadAAyGrOKs1TiO11I4nk3MktSTtLpamYnPMBYZKykeX5y7SNpIV3XNgcDAitoS1sJWHrSnI7ct+zNyyh4QOsK20Ffb7RvIcQw8IKXcLqX8WeDM4p1CCA+WcPznUsq/l1I+AvwsIIEP1rBdCoWiSZmOaDjtgg5f+erJzRlV4QOMnPA6F59b045xOQhh0rblswibRmjiPeip3qJjzCUdx2sjHAO8NPESKSNFykjx/NjzfOPcNzgxeWLNrq+oL/ce7CGlmzw3MLfeTamafzxymZmIxv+4//p1Kyr33nt2MxZM8Mi5wpiJo1fnuWNXV9XtuvdgD1LCU5eK89KbgcHZWM0K42W5a48Ve5CNq/jcc0N84klrIPD0op+blJIrM9Fl5RtnufdAY4n4tYyqEEJwfX/bmgrHD5wcZ1unl5u3d6zo/AXHsfX79jl8JR3HsPbCsSlNdFPHMI3cYNSGz3IcOyqLrj63STxZ+HsSQrCva1/l85w+kuY8wh7C1WJlNuratqrbnDbSJPVk2XxjAC3Zz5bO1Ioc4IraYrMJfE478TXOGV+KiVASl91Gd8tCMUUhBH3tnlwsRT6ToQQ9fnfVxRVv3VF7sfD4UIADva20eZzcuqOTtCEbKmboWib7e791RycHNrfidzuUI7wGhJNpoppeIqrC+n4qtLLnGJfdxdbWrURTURJ6gkgqQixVuQ7KWo2PDdNgPDKO3+lnf9d+enw9TMWmmIhOFB2rGRqX5y9Xdd2VCsfZmIr8SeBNvk20uFqIJh14XcmCWkbCHgd0jHT5PnmtqZlwLOWS64vvAdqAr+SdEwMeAN5cq3YpFIrmZTqSpMfvrlgIJlccr6kcxz6EPYEQElOajIRHGA4Nr1tMg90Zor3v0whhEJr4FfRU4TJ4mc04tpcWjs01iqoAy411ZPAIXzv7NU5NncKQ1lKepR4sFI3Jnbu78DrtHLnQHDm7I/NxPvnUVd5+c39ugLoevP66XrZ2ePnog+dyhdsmQ0mG5uLcvaf6fNdXbG2nu8XF41X8/H/nSy/xrz+6uuI2rzWheJpAPM3uTbUtBHKgt5UOn5OjA3McuTDN//zOGe472MOBzf6i7OPJcJJ4ymBv7/KF4/sOWSL+k5caw3Ws6QZuR+1iV67vb+PSdITUGvTN87EUP7o8y/039VdVgb0UNlsKYYtipq2/a6/Tm4ulWCwUZ+Mk1opsTEXSSKKbOjbcCCRCmCWjKvLxuQ1imr2oDsG+rn2Yhofo3BsJjPxWrnZC7jynD4MYwnUOh3sS0HM5x9WQLXBbztlsx00w4qe/q/rsSUV98bocdY+qmAgl2dLuKfo73dLmYbJEcbyJULIgD3kpdnT5aloUzTQlLw4HuDXjZs0+ByhxsjE4PhTA73ZwYHMrdpvg5u0d6ndTA7JZ5VuKHMfWeG+8xN9ytWT7lKRuvcZScRVzibUxnkxGJ9FNnW1t2xBCsL1tO93ebiaiE0xGJ4uOPzuzdJG8YDK4ImHblCYhLUSHu6MopgIgEnfQ6RcF+4SQ2BzhDeM4XopDgAFcWrT9XGbfhkNKyUOnJwgnq7O6KxTrhW6YfO/UBJEqP6vJtMF3T42v2OUb1XQeOz+1ZIj8TESjp62yKJkd+GpN5ThuwZZZfhLSQhjSyAmk64XdGaCt7zNWmyZ+mVSqFcM0rC/D+hkvdhzb1jiqIstwaLhoID8eLV8B/tj4saqXFCnqi8dp55V7u3n8wkxTFDD56EPnsQn4z29a38cSh93GX73zRlK6yc99/Fk+9MWX+PaJMaC6fOMsNpvgtQd6ePLiTMVMSN0wefDlSX7UIKImwOCcNVm0q8aOY5tNcOeuLh6/MM0Hv/ASBza38rF338or93RzfChAOi8u5Mq01aa9y4yqALihv51NflfD5BxbGce1GxYc7m8nbUguTa9+SfmDpycwTMn9N1YXHbPJt6lkvILdGcTQLSEoGxERT8eJ64X9zVo7jrN5jpquYZgGdrwIYfVZLc7KnyWfx8QwBSl9YQBpShic6Cc0+jskQ3djpDejRW8oOM9j6wAg7TqJEAYO9yTpTM5xNUS0CHZhLxul0em8EVMK+pRw3LC0uO11L443ESrORQXo7/AyHiwRVRFM0LfEc34+Qghu2dHJS8PB1TSzLFdmokSSOrfu6ACsGis7u30qDqFBOD4U5JYdHblVDrfu6OD8ZJhYnZ31G53xYDarfJHjOFfocuXCsdthjRlzwnGFuIqUkcoVac2SSCcYDg3n+tVq0HSNqdgUXd6uXGZ/Nhaiw9NRkLucJZAMMBYeq3jdldYjysZUdHoLDSq72ndZ+xN2Olug31/4zGNzhLAZyy8OvFLWUzjuBKJSysXqTgDwCSFci08QQnxACPGCEOKFmZnGeNBeDj+6PMtvfO5F/vrhC+vdFIWiLIYp+fDXTvHbX3iR9/7bsSU735Ru8tuff5EPfuEl/sNnjy875yim6fzKp57n1z79As9cqTyLOBPRKuYbw0LGcbNEVaQSu0gl9mN3Wfe0+cQ8DpsDh82xJrOqpjQZDA4yGh7FMIt/JvF0nMvzlxkMDhJLF7p4pX2CePt/Y9j5H3h57ggnpk5wYuoE5xOfZNr1x6TlImFbpAFjzYrjVWI8Ulo4NkyDM9NneHrk6Zq3QbEy7jvYw/B8nKuzje0aPz40z/dOTfAbr91L/zIcULXinn2bePT37uU//vh+fnBmkj9/8Dx+t4Pr+pbnNnjtwR4C8TSnRoNljxkNJEgZJjMNEqMAecJxjTOOAe7a081sNEWL286n3ns7freDu/Z0k0gbvJy3RPnKjDWA2beCqAqbTfCa/UuL+PUimTZr6jg+3G8tp1yLuIoHTo6zt6el6s9+p7cz59zJx+YIYGQdx5mIiEQ6QSKdKJjYWmvhOOc41pPoUseGF2xpXHYXdlvl30GL2+rHv3esiweet74+/chmHjzeRYdfo2PrJ7C7JouEY6e5H6QgZbMGtg73KLrWj5TVObbDqTCtrtayDm+XYRXU7e9qnHuGohCv017/4njBZMn+s6/dw1Q4WXDvk1JmHMfLe4a8bWcnV2djNYn9ybpXs/m5YLmOjw8Fm2LyeyMT1XQuTIa5JW812K07OzElnBwJrl/DNiDZPPLFqwGy0RWlJoGqxSZsuOyunFA7GSt2+2aZT8wX/N1JKRkODzMTn+HMzBnGI+NVrdYdi1gC8NbWwsnTrPNYIEo6n8/MFKXvFnA1sLJVeoFkALuwF6zo6fR00u5px5QQSdhp8xpc13NdwXk+t4ZdblrRa66E9RSOl42U8hNSytullLf39PSsd3OWzcces7JRvnRshOnwyv/AFIpaYZqS//bNl/nmS2O89cY+XhoO8L7PHCtbyEo3TH7nSy/x6Plp7r+pnycuzvDBL7xU4MiqRCJl8L7PHOPESBCX3caDp4tzhfKZrkI4dtltCGENghuddHI74cl3Y3cE8G/6LoZpEEqG6PJ00enpJJQMraoonpSSgcAAc4k5pmJTnJk5QyARQEqJYRqMhkc5N3uOaCpKIBng/Ox5zs+eZy4+x3BomJenX2Y6cYUWez8d6ffS5z3EttZtdNnuIWk7ybnZ08zF53KduBBWXMVaO45LMREp/VkZj4yjmzqX5y+rInoNyr0HrdzsRnFaluOJCzMIAR94zZ71bkoOr8vO777hAI/87mv56Vu28ms/tgtHlVmQWV6zvwebgMcr/Pyzgmi2IGkjMDgbRwhraXKt+YnrN3P7zk7+9VfuyDlq7tydyT4eWFiGeGUmSqvbQc8S/VI5siL+yQoifr3QdKOmjuPd3S34XHbOrlI4DsZTPH91nre8om9ZMRU39N5QtM3uDGDq7Uhpw2l34rA5SOgJTGnmitdB7YTjBcexlW+8VGE8gP6uFJva0kyHXIzNuRmbsz57b7trll++bx63dxp3y2l0bQeG3p47z9R245B9aNIalDvcoyDdGCXqGCxG0zVSRopWd2mhXgiBluyj1avT6m38Z69rlRa3o66FaQ1TMhVOlnQc93V40U3JbJ7YG07oxFMG/e3Lm6jNxkfUwnX84nCATp+T3XkTlrfu7GQ2qhUUUFXUn5MjQUxZKOrfsl0VyKsFE8EENgGbFz3r+FwO2r3OVTmOATx2D0nD0sbmE/O5PnIxi2MgIqkI0VSUPn8fHZ4OJqITnJ05SzBZemJHSsl8Yp5AMsAW/xZc9iKfKi67iy5vF7Px2aLVqyPhkbKrgeficwSTwWrebgGmNAkmg3R4SsdUxJJ2pBS0+nR2tO/IPSd0eDo40NtLJGnHrJP5YD2F4wDgF0IsnlrvBOJSyg211un5q/M8f3We996zC90w+eRTKwvOVihqhZSSP37gDF86NsIH79vH37/7Vv7m527m6NV5PvDZF4qcxIYp+f2vnuTB05P895+8jo/9wi388dsO88OzU/ynL59Y0kGl6QYf+OwLHL06z9/83E287lAvD5+ZKnvzS+km87HUkgN0IQQeh31FFV7rSSrZR3jil7A7IrT3fQabPU4gGUAi6fJ20e3tRiKr6oSyRXbykVJyNXiVkBZie9t2DnUfwmFzMBAc4NL8Jc7OnmUqNsUm7yZu6L2BG3tvZFvbNnRTZzA0yEx8hi5vF4d7DrNvUy8dxlvxa7/CZv9mNok3szX9Z3gcHgZDg1wJXMl1rvUSjqOpaMnOeyg0lPv/MyPPrKgTV9SW7V0+9vS0VJWzu57MRDW6W1z4XI71bkoR27t8/O27buZ3f+Lgss/tbHFx0/YOnqjw888Kx7PRVEO4YcFyHPe3e3MFUGvJ9i4fX/vNe7hh64LwtsnvZl+vn6NXF1aCXJmJsqfXv+Kc3ayI3wiTKFq6dsXxwHJYX9fXxpnx1RWVeurSLKZcmICqlt6WXnpbCs+xOwKAHVO33NA+50KBvHyxePHS2NVSnHHsQwh9yXxjgK5Wnff/xCS/8eaJ3NevvWGK67cncDtc7Gzfidt/GgAtejh3nq5tw81WErr1Xpyesdz2pVgq33hzy2amAl4VU9Hg+Fx2YnWMqpiNauimLJlZnF3ynl0CDzARtv6/XMfxjdvacdgEx2sgFh4fCnDrjs6Ce/xtKue4IXhxKIAQFBRIbfc52d/rV7+bNWY8lKS31VPSqNDX7sllIK8Ut8NNUk8ipURKyUys9DNRvnAspWQsMobL7mKLfwt7Ovewv2s/YEVGvDz9MmPhMRLpBIZpMB2b5szMGa4Gr+K2u9ncsrlseza3bEYimYkXtkNKWTbreKVF8XIxFZ7CmIqdHTsBiMStZ942r4FN2DjQfQC/y8+b9r2JLr/ANEXBBFwtWc/R0HnADuwD8rMbDmX2NSRnx8Ns7/LS6nEu67y/f/wy3S0u/subDhFKpPn80WF+8959dLUUz3QoShOIpZiNauzfXPrBdTaqEUqky1Y3nwonSaaNshXZp8NJJLB5GdlaG4mPPnSezzw7xPtftZvf+wlryeHbb9mKphv8l6+/zG997kXeedvCAOOHZ6f41olxPvzGg7z/1ZYj71fu2YWmG/zZ989jE4I337Cl7Ot97fgoT12a5S/fcSM/dbO1VOShM5O8OBzg9l3FeT3Zm2Jv69K/H4/Ttq6O45mIRjyll/2snR0PMz/2boQ9TlvfZ7A5rIHcfGIet92dm010293MJebY5Cu/DMWUJudmz5E20pbg7OvG7/QzFBoikAywtXVrbrB83abrmI5PMx4Zx2V3cbD7IH7Xwt/L5pbN9Pp6iaVjuOyuvJnYJJ72YySCP4aeehxpenDZOzjYfZDp2DRjkTHOzp5lV/uuugnHYLmO8yu8SykZDg3nvtdNnUevPsrrdr2uLu1RVM+9B3r53NEhEikDr6v2QuBKmImk2OSvz2e53tx3sJe/feQic1GN7hLvMZvda5iSQLwxfg6DczF2dtfebVyJO3d38Z0T4+iGicNu48p0jHv2VZ8xvZjOFhc3Z0T8333DgTVs6fLR9NpGVYAVV/GNF8cwTYnNtjKx/ciFGTp8zgKxoFpu6L2Bx64+lvve5rQGoYbeid0ZxOvwEtEimNK0CuJl9K61noDMupk1XcOQBm78CFsan2P1n+/9XfsZCDyMwz1KKnoDvo5nkBJ0bStebzsxI4Vu6tgd8whbnLS2FQ/HK14zokVw2Bx4HKWfv/p8Bzgdc3DznrUV2JsdIcTPA/8ZOACEgEeBP5BSli/SUEN8LntdV5HklreXGFdtyQjH+YLTRGa5e98yHccep53DW9vXXCwMxlNcmYnxM7cWTq4c3NJKi8vOi8MB3n5L9TnhirXl+HCA/b1+2r2FmsytOzp5+OzkqvoZRSGTmSKXpehr96wqqgLA4/BgShPd1HHanQyFhtjaVvy3lR/hGNJCxNNxdrbvzNUwaHO3cX3P9QSTQeYSc0zGJpmMTSIQSCQtzhb6Wvvo9HSWrHuQxev00u5uZzo2zeaWzQURUhfnLnLLllty2cxZBoLVCcdSSlJGKldPIZgMWjEVeSt6Wl2tubF/OGG9dqvPMogd2nSI/V378bv8tHqticDxUJLeOuhX6+k4fgYIAz+b3SCE8AH3Aw+uV6Mq8fXjo/zkx57iXR9/jlC8+sJLJ0eCPHlxhve/eg9el53funcv8ZTBvz3dONXKG52pcJK3/+PTvPnvnuLRc8WZMyPzcd72sR/xlr97imcuzxbtvzIT5Sf/31O8+e+e4vhQcbXLcxNh3vC3T/LefztWk/Y3Openo3z8iQF+4c7t/LefvK5gZv1dd+zgT37qMI+en+Y3P/9i7usbL43xodft47fv21dwrQ+8Zi+/94YDfOfkeMHxi78ePT/Nn/zUYX7uju0A3HeoF6dd8NDp0tlG2YfdpaIqwHqIXM+M49//6kl+5h+fIV7C2WGakv/vyy8hbGna+z6D3WG5ZtNGmkgqQpe3CyGsyqnd3m6iqWjFwP+J6AQpI0WHp4NAMsDFuYucmj7FXGKOPn8fW/wL4r0Qgs0tm7mx90au33R9gWicf4zf5S9avuNtfxaETiL4akzTi7Alrev5N3Pdputw2BxcDlxmzvZFTLP8nKSma1yav8Sl+UuMhEaYjk0T1sIryoqbiBbGVczEZ4qWFAcSAZ4ff37Z11bUlvsO9ZDSTZ4dKL5fNwqzUa0hBNNacO/BHqSEJ8sUv8s6jgGmw40RVzE4G6tLvnEl7trdRVTTOTcRIarpTIaTZSerq+Xeg72cGgvVzTFSDk03auo4Bri+r42opjM8X3ifrvb+b5qSJy5O85r9PbliSMthV8eugn7P7gha100vFMiTSJJ6sshxXKpGwErJOY7TSQzTwCb9INJVOY6XYmvbVnxOnxVXkdqKke7C1LuQpo8Wp9WvJ9IJhACHeww9WdlxLKUknArT5morn29sWi6vfuU4ziGEeBvwRazx7k8B/wV4DfA9ISooFjXE53LU1XE8ESzvIM7GUYznCcfjmeXupaItluLWHR2cGg1WHZVXDdnoi1t3FDoB7TbBzTs6lKt1HTFNyUvDwYKYiiy37ewkGE8z0OB1NJqJ8VAil2e8mL4O76qjKhYXyBsIDJRcSRtIBHL/H4+M47a76fYWTt7bhI0ubxf7u/bnVtNu8m3iUPchDm06RLe3u6JonGWLfwuGNIrqDaWMFN86/62CWjvTsWki2tKFf6WUDAQHOD1zmoHgAJNRS/PY1ratoE1ZtzFAOM9xDOB3+Wn3WKvh2jJi8uQqf/7VUjPHcUYEfkvm261AmxDinZnvvy+ljAshPgp8RAgRwHIZ/y6WmP2xWrVrpTxwcpwPf+0kr9jazvmJCL/8b8/zuffdWZXz+O8fv0ybx8Ev3b0DgP2bW3nzDVv49DOD/Ppr9tC2TPfytcZsVOPdn3yO2YjGvl4/v/m5F/mXX7md1xywcq4nQgne/S/PEUsZbO/y8b7PvMC/v+9O7si4Vofn4vziJ48Cluj43k8d4/O/fhc3busA4PJ0hF/6l6NEkmnOTaQZmImyZ5UDwWYjWyTpvffsLjkweM8rd/G66zYTSS5MmPicDnaUcX996Mf38/ZbtlZ8QG31ONmat3ytzePkVfs28dCZySLxGqx8Y4DetqWFHLfDRlJfH8dxMJ7i6cuz6KbkC0eHc27sLD84O8XFqSgdmx/F7gzmtmeX33R5F9zWXd4uxqPjzCfn6fP3Fb1WUk8yFbWqwu7u2I1hGrlZVr/LX/IcYMniO6Ww2WN4Wo+TDN+JsMdxuhcqy3qdXq7bdB2j4VFm4o+SlJfx6P4id1LKSHFx/iK6qeO2u4mmorkiBr2+Xra3b19WmxYXyMuPqchncUaVYv25c3cXXqedx8/P8LpD5ZeLrSezUY1d6+xwrRU39Lezye/iiQsz/PQtxcLRlZkoBzb7uTgVbYgCefOxFIF4et1/H3fvsQYoR6/OIbHEztUKx/cd7OVvfniRJy/OFDnb6ommmzXNOAY43G8Nds6Mh3OTAIYp+eVPHaXH7+b//NzNFQXhM+NhZqMp7j24sjonNmHjcM9hjo5Zz4Q2RxgwMPTiAnlxfUE4zsZGdftW7i7PJ5S04jqi6SgSiU1mHMdVZBwvhU3YeEXvK3gmcYbY/JvQojdgywjkfq8GmhXD0epuxeEeJZF4LabpwmYrLfomdStOo1y+cU9LD4FIOwLJlk4lHOfxbuBFKeUHsxuEEGHg28BB4Fy9G+Rz2euacZwVhUtlFnf4nHictpy4DJbj2CaqM4gs5radnfzb04Ocmwjnxner5fhQALtNcNP29qJ9t+3o5O8fv0xM02lxN16c1UZnYDZKKJEuEvXByqAGK8piX++1NZ6vBVJKJoJJ7isTD9Xf7iEQT69qBaHHbo0XNUOjlVaSepLh0DC7O3fnjglr4Vzdn2AySEJPWCtdK0SFOe3OipEUlfC7/PidfqZiU/T4egpeJ5KK8ODlBznYfZA7t95ZdVG8uYSVg7y5ZTOdnk68Tm9JETu/mG8k4cBhN/G4inWNrJi8Wsd3tdTyTtcLfHXRtuz3u4FB4KNYQvEfAt3AC8AbpJTFltJ15OEzk/x/Xz7B7Tu7+PSv3cHTl+f4zc8d59c+fYzP/NqdFfMPz0+G+eHZKX7nx/cXiMy/fd8+Hjw9yWefHSpybCoWCMRS/NK/HGUsmOAzv3onB7e08gufPMoHPvsCn/7VO9nT08IvfvIowViaz73/Lvo7vLzrE8/yq/92jM+9/y56Wt38wiefI6kbfOkDd9PmcfJzH3+W9/zr83zx1+/G57Lz7k8exWYTfPZ9d/GL/3KUh85M8lv3Xlu/kzPjYdwOG3t7yru5LJG3ejfM9hUUMHrzDX08/vVTnBkPF2RLAkxHrJtiNUWI1tNx/Mi5aXRTsrXDyyefGuCX7t6Zy+SUUvIPj19mZ7cPrfUs+dr2fHIen8NXILa6HW78Tj/ziXm2tGwp6LSklIyERxBCsK3VEhvsNjvdvu41G9wuxtvxDMnwHUijFWErnN20CRs72nfgSLyBKfltzs4Ms61tW66zTRkpLsxdwDANDnQdoMXVgpQS3dSZiE4wHZ+mxdVSIJwvRTwdzxUUABgODlc+QdEwuB127tnbzZGL00gpV5wRWyuklBvacWyzCe7Y1VUyEzIr0r7tpn4uTkUbopjv05mVRLftrP7+UAs2t3nY1e3juYF5uv2We3Nf7+pc0If729jkd3HkwvoJx1JKUrqJp8ZRFQe2+HHYBGfGQ/zkjdbE5teOj/D0ZcvR0+1385G3Xl/2/COZXO6scWAlHNx0kBcnXyRtpBHCxOYIYmQcxx6HB4EgrseLVq+spXCcjb7IZifbZBtijRzHAK/Y/ArmEnO8MD2IFr0Bp3cQhIbbE8Jpc+bem9MzSgIbutaPyztYdB0pJbNx62+vXL7xno49nL3oYlN7GpejMfLQGwQnVjxFPsHMv+vS4flcdqKaztU6OTEvTkbwOG10+IoNUkII+tu9XJmJ5tpzeTrK5rbSOapLkRUQHzs/vew4yXIcvTrHdX2tJcf5t+zsxJTwyLmpNROqF+N22OgvkQ+9UiZCiYYqHN7lc9Fe4rMB1oTiyHyccneUR89ZfcGtJRzHeza10O518tTlWe7YXbtnhq0dXlxlVunEND1neKoFdiHY3uWt2bPzTEQjqlkibUzTSaSNsisBstEyx4cCbO20/t8idmMzNpM2qzPu2KVEcJZECgyn9Ts7NT5Ju2N/7piRcBwj3ZVxG5/HbW+h3bEPI12722mPdx9XwyeYi0fY1NJWsE9KyfnZ84yGRyuuSJLShql3kDISjIRH8Ts72eJ5BUIIpA6Lz/Q5fTjNrcxHrPc1H3HQ5jUo9av2uEwcdrlqx3e11Ew4llIOskTHKK21af8789UQTIWTuUwmgKuzUf7z105x47Z2PvWrd+BzOXjD9Zv5u5+/hQ998UXe/5kX+PAbD5b9w/2Hxy/T4rLzqz+2q2D7DVvbue9gD//y1AB37+ku67Bw2W1c19facIPqWqDpBhcmI2Tr8Bim5I++c4aB2Rif+pU7uCvj9Pnc++7k5z/xHL/26WNsafMwGU7y7792Jzdl8u6+8P67+bmPP8sv/+tROnwuwsk0X/z1uzm0xfqD/+Kv350Rj4/idtjQTcmXPnA3Bza3ctO2dh4+vTGF46lwkh6/u2Te0+mxEIf62lb0sLaWvP76zdi/acVVLBaOZyIaQlCVkOOusXCcTBvEU0bJjPKHTk/S1+7hL995I7/4L0f52vFRfulua8nJExdneHksxE/fM8x3BqfwOXy5ggDxdDwnAOfT5e1iODxMXI/T4lwQKEJaiLAWZlvrNpz2+qxasDvCeFpPkIzcjrCVFpPa7PuxJ/+KcNsfMBIeIZgM0t/az2BwEN3Uc6IxWAMHp93JtrZtxNNxhkJD+Jy+sjmKpZiITJDWNhGIx5kO+gAfwpbG4WrswmsKKy7h0fPTDMzGVu3aXGtiKYNk2qxqoqpZuXl7Bw+enizKOc7GVNy1p5vPPDvUEI7j1eTarjV37u7i4TNTHNjsx24T7OhanXBsswlec6CHx85PY5hyRREMq0XLzGLW2nHsdtjZ1+vnzLgV0RRJpvmrhy9y285OXrG1nX/90VV2dft4zyt3lTz/yMUZbtrWvqoJHZfdxYGuA5yZOQOA3RnAzDiOhRB4nV4S6YSVcZzHWuYcB5LWhE0sZQlmNtm6ZhnHWV6949VcHR9kavxeTLMFh3scIaRVADDjpna4FwrkLRaOpZSMRkaZjk+zybupKM8RrJ/Xro7dPDLv5tC2eNH+a5xPAd8SQvwy8C1gC/CnwGNSytLVlWpMh89FMm1y318fqdtrHthcvnjo9i4fj1+Y4fELC+25c4VCX3+Hl60dXv7vI5f4v49cWtE1SvHee3aV3H7r9k7sNsHvfOnEmr1WKT7//rv4sX3l65xUy3MDc/z8J55bgxatHR0+J8//19eXFF//5ocX+IfHr1Q8v7vFxZ4S8VU2m+D2nZ08cHKcB07WLk78bTf18/9+4ZaS+97xT89wfnLp6ILV8Ef3X897f2z30gcuk+G5OPf+9eMsrotczhCWXX38S/96NG9rG/Bby3pdh/sikWgfgfnfASAAnCtYl9EH3Enc9ixJ9yNsSv0XgtFXL+s1lovExOn+IOOhOF3e1pIaylLFc6MzbyMZvZlp139H2ly0R/6aYLi8CzoAfHJRXPKezaWFYSGsuIrxVRYnrBa1tiIP3TB58989xXyscKnVDVvb+PSv3ok/bynKT97Yh6bfxO999SQ//Y/PVLzuf3jtHjp8xQLTB1+3n3f80zO8458qn//Pv3Qrb7qh9JLzjcT/feQS/3SksJNw2gWfeM/tvGr/QqfZ7Xfz+fffxc99/FnGggn+7VfvKCimtqXdwxd+/S7e9fHnmItqfPb9dxWIkNu7fHz+/Xfxrk88R1TT+WJGNAZ44w1b+MuHLjAWTBTEKDQ70+Ekr/7Lx/mTnzrMu+7YUbDPNCVnx8O87eb+dWrdAl0tLu7a3cWDpyf4/TceLNg3HdHo8rlwViFuexy23EC4Fvyv757lh2eneOLD9xY4EWKazpOXZnj3nTu4Z283t+zo4J+OXOFdd2zHYRP8/WOX6W/38HLwG7nqqy67C4fNukant3jmvNPbyUh4hLHwGFv8W3L5jCPhETwOT1GV+Frj7fgRycjN2BylH4iETcNu9rOvcx9ziTlGwiNcmLuATdjY37U/JxrnYxM29nTu4dzsOa4ErnCo+1DVcRrnxmxcvJy9P+7NbW/b/HlcLReX/f4U9SO77P/UaLDhhOPZjFNkozqOYaES+cnRYEFcyJVp6yH4FVvb8bsddS2mVAor13aGV68w13atuWt3N195YZQHT0+ys8tX1nG0HO472Ms3XhzjxEjpzMZao2VcaLUujgdWXMUTF61s7X94/AqzUY1//ZXbuWFrO6OBOP/zO2fY1unjvkOFfVswnuKl4QAffN3+UpddFrf138aB7gPYhI2n9C6uTCy4ab0OLyEtlBN1c6+/RsKxpms5x28snRWO20GsTVRFFrvNzv03buNfxk2k4cfpPwFYbqaQFiJlpHDZweaYQ08WFiHKFpqdTczS6+tlW1tpJ3yvr5dUqgMtbVP5xouQUn5PCPFe4F+Bz2Q2PwO8rdTxQogPAB8A2LFjR6lDVs17XrmT7V0+zMWKUA25vr+t7L4/ffsNRTnBq5kc/NR77+DcRHjF5y9GCHjN/tKrG9p9Tr70gbsZC9TG6Tcb1fjT753LrbZcLU9fnsVuE/zlO25siH70zHiITz51lXMT4ZzxK58fXZ7j0JZWfuO1e4tPzrCvt/ykxJ+8/Qbuv1pc02it+MoLIzxzZbbkirnZqMb5yQjvuHUbr96/etG/FP/j26e5OF2bYqTPDcxhSvgfb70+Z5DyOG287lDp8eZtOzr55C/fTkxbiKccCAxwNXgVKSVj4TEGggM4bU5a3a34nX58Lh+GaZAy06SNFPOJeeZDkDLP4W//Wu46+7r25WIMX556mdn4LDHtOCJto7dzAiG+VtSetUaPv5Jx88tMRjz0t3cs+3wj3Uvc/SWStpP0uV9JR+tTZY912By8cvsrc7pAlq3d5Z/Df+LmGD97w65lt2slKOE4j3MTEeZjKT70un25JS9CwB27ukrmF/3Mrdu4vr8tVwW2FDab4K4ys6e37ezkm791D8EyhfYkkg994SV+dHn2mhCOf3Rplhu2tvF7b1gQDHd0+0oKCr1tHr79wVcRiqdL5uxu6/Tx3Q+9ilhKZ1tn8f49PX6+/x9fjW6aBdV733TYEo4fPj3Jr71q7Wfx1ovnrs6T0k2evDhbJByPBOJEND2XPbjevOmGLfyPb5/h8nSEfb0Lg7npsFa1+8/jtBOM124Q89SlGWYiGl98foT35X1OHr8wTUo3efMNVqzEh163j1/79At866Uxtnf5eGEowB+/7TDveeXD3PLxWwgkAkS0CJFUhA53R1FBOrA6kS3+LUxGJ7k0fwmbsOG2u0kZKQ50Haj7agS7M0Dn9n/AZi8nHCcBB0gnm3ybaHW1MhmbZJN3U0nROIvL7mJ3x24uzV9iODy8ZG4VgJQwOHod7T6djt6Hcy6u6OxbiAdfi9N3seTSHkVjsLO7BbtNcGW68QqYZF22mzaw4/gV29qx2wQnhhcJxzPR3BLZ3lZ3TZdbVoOVa6tx7yriCdaSu/ZYz3RXZ2O8/rq1yed+9f5N2AQ8cWF6fYRj3VqhU+vieGBFc3z9xVGOD83zqR9d5R23bssJB3/387fwcx9/lg9+4UW++hv3FIhOT16axZSsON84H5fdlYud6G2zcXbYSYvpxmbT8Dp8zCXmmI8X9nFrJRxn+ykg52oWsh0hQnida/sctsnvZuumKGOzbTg8owB0ejqZik1xce4iB7sP4vSMkk4sPMeY0mQwOEggGWCLfwv9/v6yffHuzt1MzFvPLUo4LkQIcR/wz8DfYRV93wz8EfBNIcTrpZQFy+KklJ8APgFw++2310TZbfM4edtN628SybK9y7eiWLtyHNzSysEtpSNVasEdu7q4Y1dtrj0WTPCn3zuXm9RbLS8OBzi0pZV33LZ+Ofr53LWni08+dZUXhwNFwnEybXB2PMT7XrWHt9+ytfQFlqC/w7vic6shquk8c2WOkflEkQ7xYmYy5Bfu3F5gbFtLPvnUQEE++Fry4nCAdq+T996zq6TDdjE2m+AN1xc+Cx0bG8c3YU2Q3kAXhtle0RB0YnKa4fMporEwbv+pXJ8Ts49yeMc7ADgVfh6PPYaeHsHtcOFtO7PSt7gselybCU6/isn4M3S1XLesVbEAST3BnOurtLpa6evUEOLlssce7j3MTdtSQPX96aGtqbrFuCnhOI+jV62MtXfftaNATKzEoS1tuQiElXBLiVD3fG7b1cXzNZwxaxQiyTRnxkN88L59RS6TcrR7nbR7yy/R72xx0VkiSiBLKRFyT4+fg5tbeejMxhKOn898to9enS+aHc0uGb1h68o/x2vJGw9bwvGDL0/yoR9feACciSSXIRzbapbjNR5MMDKfwGETfOLJK/zS3TtyLq2HTk+yye/KPSjcd7CX6/va+KcjV9jS7mGT38277tiOTdisDCObk96W3iUzXvtb+9ni30JEixDSQoS0kCXKlilWU2vszvL3JGGzRCYp3Qh03A43O9t3lj0+nzZ3G33+PiaiE2i6Rrevmy5PV9mHjXRyN6nkVm69/ipXtGO4fNZYy9fxI6KzbyOd2IPLN1DyXMX643LY2Nnly0UjNBILjuPyfUiz43M5OLC5lZdGggXbr8zE2L3JEvU3tbrX3XGczbV97RoIhmvBtk4fWzu8jAUT7F1lvnGWDp+LW3Z0cuTiDL/7EweXPmGNyUVV1EE4zorBH/rCSzjsgv/8poX32+J28Kn33sHb/+Fpfu3Tx/jWb/8YWzK5ikcuTNPpc3LTGueJdvgtl5RLbiGRNDGC94H9r5mYK3w+XyvhOHsdKSVJwzKe2MwObLb5ZQ9Iq+H2vSkm5nWcbqsGgNfpZX/Xfi7NX+Li/EV2uC5jRm/C0FtJmpMMhYZI6Am2tm5li39L2esKIdjduZunx1y4HCbdbaoI7SL+D/AdKeV/yW4QQpzAKgb/U8A31qldiiYgey9OGasfyxim5MRwsGFEY7BycfvbPRwfCvCri+IWXh4LkTbkukyiVku2bceH54uE4+PDAZx2URS5uJb0tXsZDdQmHuj4UIBbd3RUJRpXy1KrSFtdrbgdbiSSlJHKRSMFkgFmYjO0udtyq4CSerImfWU57K5puvXfYMxxnMHgIAe7y0fU5mNKk5nYHJPOP0ZgFbyrdJ4QgsM9h9ew5WvP+gaaNhjPX51nR5evatG4Hty1u4uLU1ECsY09k398KIAp4c7dtSnqtRzedMMWjg3Or/tgebnoFR4ujl21KgPPRrWiohinx0LYbSIX17HebG7zcOuODh46M1mwfSai0dtaXUfhdthJ6rXJOD42aImmH37jQabCGl87brl4kmmDx89P84brt+SWgQkh+ODr9jEwG+OZK3P8+qt35wrl5VNNB2QTNto97exo38Erel9RtRhbb7LZx9JcmVOzz9/H9rbtGNJgODTMqelTuXzkxSQCr8VmDzPP97Ei8y3crSew2UPEg69d2ZtQ1I09Pf7GFI4zjuOeDRxVAXDz9nZOjgQLli5fmYmyN1OJvLcRhOOLM9y4ylzbtSbrOt67ae0iVu490MOp0VDus1dPco7jEv3TWpMVjsdDSX7r3r1sbivs1ze3efjXX7mDSDLN+z5zjJimY5qSJy/O8JoDax9X0tFi9S2h6fsJjb8fp2FFYcTTCdLGghiaNtNF8RUrIZCw3GiaoaEb1mvbZAfOvMJyXsfajUOu257gZ+99AZtjoe1+l5+9nf8/e/cd3th53nn/+xx0AuxlSM6QUzhNM6M2o251ybZkW5bt2HGLEydxnGInu0m2ZL2bXdv7ZuNkX292XRK/SrKbbGKv107ixHJix73baiPLVpdGmqKpnGEZckiCKM/7B8oAJECCJICDA/4+14VLInAA/mZ0hAPc5z73M0I8GefY/OdImjMcnTzO0+eeJplOMtI5smTRGGBDdAPRQJQTYyH6O+dpgKvfG81u4EeFd1hrnwFmKZyrJVJCbgTSfBXG7j1zaooL86n81dSN4srNnTx6dGLR/bnxJVcOd9Q30Ars3NBKLOTn4JGJRY89emSCvYPtJb/vVctgR7hoTa5qmZxN8NyZ6brvK62h1nwxeC5Z/Od6buw5xmYz372ttcRT8boWjo2xhMIX6E6/lQuJC4zOjC65fdqmOXPhDI+feZyXpo7iT29kc/iuklcVF9rcvpm2UGM08ZWjwnGWtZaHDo+teih/reTy5IpVzeqhw2P4HcP+zR1uR+Guff1YC1958rTbUSr20OEx9v/nr/CZh44temz8wjzPnJ7i3uwM44X70hMnzrOjL1bTA9xK3b1vgCdOnOfL2eKxtZbR6Th9bSvpOK5N4fjBF8doDfl5103buGIoM8M4kUrz3efOcmE+xV37ir9s3bW3n+19MTpaArz9usYs9lZTvuN4lYVjYwx90T729Oxhd/duuiJdjM2OcXTyaNF2iblhEnNbiXR8j7G5MwteI0Wk43sk57aQmK3NrECpjpG+KIfPzix54ssNo9PzGEPJBTCbyRVDHZyfS/LiuWwnRyLFsbGZ/IioXpcLx7m5to0ypiInN597+4YqFo53Za62+vazS38pqYW5RP06jtvCAbZ0Z7q233XTtpLb7Bls42Nv289TJ8/zLz79KI+9NMHZ6fmqjKlYKFM4tszNdRHp+Bbdm/4nxvpJpJP5WcQ51eg6zo2qiCfjJG2mcGyIEPJfrLzu7tm95t9TaGN776IT1G2hNkY6R5hLTXI89IuMzT9HX0sfe3v30hHuWPY1t3VuI5mCMxMBjako7Qiwv/AOY8wlQAQ47EYg8Y5gdj2XaqzX8sjRzHtOo3XwHhju5PjELKcWFEAPHhlnS3dLQ50sXsjnGK4Y6lg0o3s+meaxl2q/VkF/e5jJ2QQz84ubatbiUZf2ldZgKyFf5r937kqcnEPjhzgzk/meF0/Fsdi6Fo4B/KFjROL30hbs4PjUceLJ0p+LrbUcGjvEsfPHCPlDbIveRP/8h4iFls+7r29ftWNXnQrHWc+fmWZ8JtFwhePLNrUT9DtNP67iwRfH2LexvWihMbfs7m9lS3fLoo7XRvWjYxP8/P96iPNzSf7vw4sLx7lC8VuuHqYnFuSBgn3JWssTJyYbZr5xzluvHebyTe2891OP8q1nRxmfSZBIWfpWMOO4VqMqHnxxjANbMqspv/e27bw0Psvnf3SCLz1xirawn+u3FXfNO47hz372Kj75rmuLFthsVrnCcTq9toO6MYZoMMrm9s0MtA4wPjee79QCmBm/GeNME259pOTzw60HMb5pZiZuXlMOqa2R3hjzqTQv1WiBmdU6Ox2nsyWIv4LFOL3siqHMl4MfZbt+jpybIW1hpDczgqGvNcx0PFn1LyeVys+1rXCEVb28/sqNfOJnDnDlGhZyWmjvYBs9sRDfeKb+heNccaJeJ5A/+tb9/OUvXL3k77ttdx8feO1evvrUGd7zyYNLLlS1FuGg5S03jXL7Vd8l2vV1HF8Sn4mRTMeZTRa/L1WlcJw9js0l50ilU/iMH4MpKhz3RfuquvBt0BekO7L4ir72cDvbOrcRsZcxxHsZah+qaGFaYwxbOrZweiJI2hoVjkv7BPBmY8yHjTF3GmPeDvw9maLxP7kZTBpfrnBcjY7jg0fG6W0Nsamzca6ohovFyYNHL362t9Zy8Og4+xusyF3K/s2dPH3qfNGicE+dPE88ma554XUwe3X8iSXW2VqNg0fGcQwlFyyspUggQtgfxmd8i4qy8WScJ85k5hnnupHXWji+euPVvHLklbzhkjfwjsvewZ3b7lzy6t9A+CgGHwPhGwA4PHmYtF38/+aZC2c4P3+eobYhdnbtJGIyF5c4/skl8/RGe5e9yqcRNPc3ohXIFdPKLWTnlpDfx5VDHTzYxB3Hc4kUjx2bbJi/e2MMr9zXz/efP8tkmYULG8UTJyb52T9/gM5ogJ+5bphHjoxz+nzxQeTBF8cI+h0uH2rn6gUzs89MxTk7Pd8w841zYiE///sXrmV7X4x3/++H+fyPjgOl51KXEg748pfeVtO56TjPnZnOn2C645I+Lhlo4+PfeJ6vPnWaOy/ZkL+8rNCWnmjDFedrxVnjqIpS+qP9tARaOHr+KIlUgmR8gMTsDiLtP8Q4pf8fNU6CSPsPSMzu4NR443YtrHe5ztZGG1dxdire9GMqILMqeTTo40fZOce5/w6FHceAa13HtZpru1YBn8Nd2UVQq8VxDLfs7OU7z42SStdkbayy4on6LY4HmYUZCxe/Lecd12/hF2/cyonJOS7b2E53jf6f3LIhzmDnxdf2mzBJO8P0fHU7jpPpJFPzmUX34qk4yXQSv8ms1VFYRI8EIox0VneawUCs9CLbHeEONvnfij9xTcWv1R/LHJNP5BfG89Zotzr5CPAe4OXAPwB/SGZ0xR3W2sZbEVYaiuMYAj5TlY7jg0czM2vrvZj2ci4ZaCPkd4q6do+OzXB2er7hxmqUsn+4g7SFxwrWicj9WWqdfyA7+//kZHWbLg4enWB3fxtRFxqd2kJthP3hRaMqgPzVP7nHcjOQV6Mz0snlGy5nqH2IrkgXIX+ILR1buGn4prL/j/hDmTqEM7+L4bZhpuenOTxxuGhM4kxihuNTx2kPtdPbkrnKJ53KfPf3+c8vmWlfb+N3G4MKx3kPvjjGhrYQw1Vc3bVartnaxePHJ5mOu9PxU2s/OjbBfCrN1TVaeXQ17t43QDJt+drTjTuu4tnTU7zjzx8kFvLzqXddxztv2AKQH++Q8+DhMa4Y6iDk93HN1i5eGp/leHYl1sePZ86ANWJRs70lwF/94jUMd7Xw/vufBKh4xnHYn1kcr/ANvRoeOpz5QJA7yWFMpuv4hbMXmJhJLBpTsR6tdVRFydc0hi3tW0ilUxw7fyzbbTxLuP3BRdum0ilOTJ3gwvwFwm0PYZwZHnrW/dnpUlqus7XhCsfTcXpam3tMBWQut7xsU8fFwvGZzH+Hbdn/Lm4WjnNzbW/aUf25to3q1l29TMwk8v896qWei+Ot1PtedQm/dusI//LOnTX9PYXjGfxOkJSZZGy6uGiz1sJx4fPnknOkbAqfk3mfiQQvFo7D/jAjXVUuHLeWLhwD+IOnSCe7SKcq+4y1rSMzYuTEWJC2SJJYpLFGDTUCm/En1trLrLVRa+1Ga+2brbVasVcqEvL71txxfHY6zpFzMw03pgIyc5wv31Q87uFgg47VKOXKbHG4MP8jR8fZ2BHJL+paK4MdmY7jk1XsOE6lLY8eHXft7741lFkgr1ThOGcuOYff8eN3Vl/Y3tVdegHind07uWaw9AlUxzeHL3CaxNwQ3S3dbGzdyPjcOMfOH8NaS9qmeXHiRXyOj83tm/MF6HSyHePMYpzyV+X0RfvY2rm17OONpPE+IbrAWsuDL45xzdbuhjsbB5nCcdqyaI5OvX31ydPc9Idf58z51b1JffrBo7zij7616JLXB18cwxgaqnB82cZ2BtrD/PZnH2P7+/4pf3v/559wJc/sfIrbP/zNoiyv/O/fxu8YPvVL1zHU1cL2vlZGeqN88fGLhePpeJInTpzPFzrzM7OzXcdPnMicAcstVtNoumMhPvlL17KtJ1PE2FDpjOPsF7DJ2ep2jD/44hghv8OlGzvy9921r5+R3iiRgI+bG2wOpxvyheNUdU/CRQKRiyMr5sYJtz2A4ywuZo3OjHJy+iRPn3ua58Z+TCL61xw6FeHpU0uf7RV3dLQE6YkFOXRmcQNWKm354k9OFi3cVi+j0/GGnq9XTVcMd/DUyfPMJVIcGp1mY0ckPzYqNx7ojAuF48dPTHJ2ep7bdq+f99WbdvTgGPjWM2eW37iK8ovj+RtnrYMcn2P4N3ft5rYajyuJBqP5xWsCPoe0mWB8uvjvY62F48JxS/FkpuPYMdnCcaC4cBwLxtgQ3bCm31eoP1a+Q94fOglAcn75k9+5MRUAJ8ZCDGhMhUhNBP0O86m1XT15sE4dsKt15eYOnjgxmV+X5pEj48RC/oZZsH0p7ZEAO/piRaM2Hj0yXpdF/XJr/lRzgbz8IoourTfVGmwl7AuTSCdKjoGATOF4LWMqfMbH9q7tZR+/dMOlXN5/ecnH/OGXSMY3Ya1hQ3QDG6Ib8t85j08dZy45x5b2LQR8gfxz0sm2JcdUtARauGPbHTjGGyVZb6SssWNjs5w6P9dw841z9g9n5qk+5OKc43Ta8of//DTHxmb50++s/GT5XCLFh7/yLM+enuZTDxQvcvXgi2Ps2tBKe0ugzLPrz3EMH37T5fzarSP88i3b+OVbtnHJQBtf+PGJqnexVuLTDx3lhdELvO3a4XyeX79tO5/9levZki2qQqZT+oEXxxi7kPkgf/DIOKm0ze/bu/vbaA3786NPHj8+ydaeaEPP3u1rDfN/3n0dv/f6fRVfEZCbg/jJBfvaWj14+BxXDncUjaPwOYaPvPVK/vjt+xtqgUG3GGcG45siOV++u2m1+qP9hJ1exoJ/jD/60KLHrbWMzowSDUTZ1LaJ+fQ8x5Of51zslzg8+eOq55Hq2NYTK9lx/KXHT/GrnzzID144V/dMZ6fm10/heKiDZDoz7/7Q6IV8tzG423H8zWdGazbXtlF1tATZP9zJN+u8QF6+4ziwvr8WtIczV18FfZBikokLxZ+NpuenSaZXf/VfbmE8yCwAlEqn8JH5Epz7HGYw+S/GS33BXalyc44B/MFM4TgVX/64PRAbIBKIMBN3mLzg13xjkRoJ+pw1dxw/cnScgM+wb2PjXVkKmQXyEimbvwL24JEJrhjq8MxVRgc2d3Lw6ATptOXk5CwnJufq0rEb8vvoiYWqOqoi3+097E49LNdxDJTtOl5r4Xi4fXjZ5189eHXJY28gfBSbbiGVyDSabmzdSHekm5PTJzlz4Qy9Lb35zxA5qWQbjq9045LP+Lhj6x1EA9GSjzei9f0JMeuBFzNfSq9poI7XQtGQn30b211dIO8rT53m2dOZTqRPPnA0X5is1GcfeYnRqTgbOyLc9+0X8mcWE6k0jxwZb5j5xoVu2N7Dv37l7vztbdcOc3Z6nhfP1nc0WTyZ4r5vv8A1W7r44L378nl+6xW72Nxd/GZz175+UmnLV5/MjNh48MUxfI7Jn2n2OaZozvETJ86zt0G7jQttaAvz9ms3V3xFwL6N7dy6q5c//+6LVVvUaWouwZMnznPN1sVfvPYOtte8G8orjIFA+AiJuc0Vbe9zfOwf2L/8hmQ6nTbYt5LmPGfmnlr0+Pn4eeZT8/RF+9gQ3cC+3n1s69hGf1srVw1Vd5V6qZ6RvmjJwvEPswXj505P1TXPhXiS2URq3RSOcwu8PXp0gkOj0/n5xgBdLUF8juHMVHUXYKnEN585U9O5to3q1l29/PilyboW6+OJxh1VUU+5cRUBfxpMmomZ4qKNxTI5t/QiN0sp2XFsM5113dkGu8Ivtds6ty16jZZAC7dsvmVVv7/c4juO/wKO73xFHce5TCfOZTql1XEsUhtB/9oLxwePjLNvY3vDNrbsL1ggbzqe5OlT5z2xMF7O/s2dTM4meOHsBQ4emQDqN2ZjsCPMiSp2HB88Mk5PLMhQlzuLKMaCsfzxb+ECeZBZIyBlU2sqHO/srmzk1cuGXkZnuPi/oz90LJNjbhjIfCfd3L6ZrnAXLYEWNrVtWvQ66WR72fnG1w9dz4ZY9a4qqof1/Qkx66HDY3S0ZC43aFTXbu3iR8cm8gXXerLW8rGvP8/m7hb+7OeuYmY+xf/63osVPz+RSvOJbx7iwOZO/vCNl3FmKs5nH3kJyBQuZxOpksW4RpPr2q13Af/vDh7n5OQc7719+c6TvYNtbOqM8KXsnOMHXxxj38b2oiH312zt4vkz0zx/ZprjE7MNOd+4Gn799u2MXZhf1OG+Wo8cGSdtG28BzUYUCB8hnewglVh63zLGcPPwzVzRf0XRpT3lWAtO/FrazAFGZ0aZTxV/YR2dGcXv+PNf/o0xdEY6ec/V76GnpWfVfx43GWO2G2P+P2PMj40xKWPMN0tsY4wx7zPGHDPGzBpjvm2MuaLEdnuMMV8zxswYY04YYz5ojHH928RIb4zxmcSiE5K5k7ov1Plk3dnpzAfWnljzzzgG6GsLM9ge5kuPn2JmPsVIwWchxzH0xIJ17ziemsvM+b1lHY7/uXVX5iTkt+vYddzIoyrqKV849mX+HqbnFp94Xsu4iqIZx4nMjGMn3Q4k6WnNHAMjgYtf2qPBaNGidgbDndvu5JLeS+iKrPyzyFJzjn3BU8sWjh3jFIypCGKMpb9ThWORWgj6nTUtjjefTPPjlyYbdkwFQE8sxObuFh45Ms5jxyZI28yic16R+7s9eGScR46MEw44XDJQn4asgfYwJyeq23G8f7jTtbGtrcFWQr7yHce5+8K+4sKxMYarBq8qWqeglNzVqJUI+ALcse2OolnKvsA5jDNDIn7xNYwxbO3cyu7u3YvGTdi0H5uOlhxVsbtnN7t7vNfQpMIxmeLa1Vu6cBr4sohrtnQxn0oXrdy5Ut8/dJY3feL7+ctBKvXt587yk+OT/NqtI1wy0Mbd+/r5i+8f5vxcZfNjP/focY5PzPLe27Zzw0g3+4c7+MQ3D5FIpXkwWxi4emvjHtRytvVE6YkF61o4TqbS/Mk3D3HZpnZu2rF84csYw117+/nuc2c5Ox3nR8cmFhU6cwXwv/z+YQD2bWz8juPVOLC5i+u3dRd1uK/Fgy+O4XdMXWZXeU13S3fRl91A+AjAsl3HVw1cxUjXCI5xyq74Xiid7CSdamdDOLOwwcmpk/nH4sk4k/FJelt6PTMrqkJ7gVcBzwDPltnmd4DfBf4AuAeYBr5qjMlXAYwxncBXAQvcC3wQ+G3gAzVLXqFch+sLBV3HYxfmefZ05ud6L5yXLxy3rp9O1yuGO3g4OwtxpLf4Spbe1lDdC8eHRi+QtnDppo66/t5GsGegjZ5YqK7jKnLFiXCTjqpoCVQ25ipfOHYyRdzZRPUKx2mbZjJ+8fP3dCLzvmZsJ77AJNHsMXRhN1XhInnXbLyGwdZBAK7ov2LFGfqjS805PkVqvhebLj+6bKB1IJ/vxFiI3rYEQX/9x7eJrAehNXYcP3nyPPFkuuEXmjswnBn3kFvL6coGLnQvtK0nSkdLgINHxzl4dJzLNnUQ8NXnODrQHuFUlTqOz07HOezyIoqtoVZ8jo+AE2AutUTheMExcmvHVq7ov4KfuuSnuG3LbYs6hXN2du9cUVG8I9zBjcM35n82BvzhYyTnhhZtW+p106lMfWVh4bgr0sX1m66vOEcjac5PiCtw+vwch8/NNHwX4VVbMv8TrLZo+dDhMX7xLx7mocPjvOPPH6h4oShrLR/92nMMtod5/ZWZMyzvuW07U3NJ/uoHR5Z9fipt+ZNvHmLvYBu37urFGMN7b9/O8YlZ/v7R4zz44hhbe6L0tdZ29dFqMMZwzdYuHqhj4fj+H5/g6NgM771te8Vvdnft62c+lea/f/VZ5lPpRYsO7htsJxxw+Jts13ezdhwDvPf27ZyZiuf/rGuR697OLRpVS52RziU7g5azu2f3mp6/Ej0tPbx6x6t58943c/2m64kGo/iCZzDOLIm5LUtmLFyAoJKzwLlCdEt0jN6WXs7Ons1/kBidGc3naTL3W2uHrLVvAhatzmmMCZMpHP++tfZj1tqvAm8iUyB+b8GmvwJEgDdYa79irf0EmaLxbxljXD17lCscFxaIcycVt/ZESy6cV0ujU5kOut51NCLhiuy4CoDtvcVXX/W1huu+ON6hM5l9YWERez1wHMMtO3v59rOjpOq0MGTu5Gqzdhy3hdrynUxL6Qh1AOS7jOLJ1KJFelZbOD4fP1/0WhfmM+9rJtWDPzCJz8n83S/8UrytcxuGzCWxVw5cmb9/e9d2YsGVXSkZ8ofKdipn5hz7SCbKj93a1pEZU2EtnBwPar6xSA1lFsdbfeG40RfGy7lycyejU3E+/9gJdvTFaI80zppHy3Ecw5VDHfzghXM8caK+3d0D7WGm4kmmKmzkW0p+X3GxcBz0BQn7w4T94ZKjKuaScxhMfhFbyFwFc2DgAJCp04x0jfCGS97ALZtvKTqWGmPY0b1jxZm2d20v6gwOhF4ilegjnVq+bpVK5grHF2tuxhhu2nxT/njvNeu+cJwrxDbqwng5HS1Bdve35hc1W4kfHZvg5//XQwy0h/nbX72eoN/hZ/7sAZ4/s3wX1wMvjvHwkXF++ZaR/IJg+za2c9uuXv7sOy8sOz/2H39ykhfPXigqfN62q489A238yTcP8eCLYw07W7qUq7d0cXxilpfGZ2r+u9Jpy8e/cYjd/a3ceUnlM3D2D3fS2xrKj2i4ekvxQSDod9g/3MlsIsVge5iuaPNejn3DSDdXDnfwJ9kO99WaS6R47KXF3dtrsdQXvp1dO7lh0w2r6pzNncm8fcvtRIOliy7VugypPdzOK0deSdAXxO/42du3l5/e89PcMHQdgfBRkmU6jje1beKGoRsW3becxOxmjDODLzBKf6wfxzicmDpB2qY5O3OWjnBH0QeKZmBtmaWFL7oBaAM+U/CcC8D9wN0F290N/LO1tvCs4afJFJNXNzCzSjZ2Rgj6HQ6NXiwQ//CFMcIBh9ddsZFT5+eYjldnVnklch3Hveup43goc5xoDfkX/bl7Y250HE8T8BmGKlwQtdncvLOHydkET52s7CT/WsWT6cx8el/jXnm3Vr3R5cee5DuesqOTUnaWydnifX+1hePC+cYAFxLZ97tUH+HQxc/jEX/xfMmWQAu7enZx+9bbi+53jMNlGy5bcY5yV/f4Q0svkFc4pmJsyk884Wi+sUgNBX1rG1XxyNFxNnZE6G9v7OasA9li6/Nnphu+O7qUA5s7OXJuhkTK1jX/QEfmWHGyCl3HB49OEPAZLnV5EcVYMEbIH2IuOYe1xSfOcwvjFX6H3dm9c9GCdLki8Rv3vJEdXZli8UBsgLbQ6npkrt90ff6Eqz+cqa0k48t/Z00nM7l8BR3Hl/ZdSm/L2kawbW7fXNGJ8FpQ4fjFMaJBH3vqNI9mLa7Z2sUjR8ZJrqAA9sSJSX72zx+gMxrgk790LQc2d/GpX7oOMLztT3/I4WVmR378G8/TEwvx5quL2/Lfe/sOxmcSS86PTactH//682zvi/HKvRfnphlj+PXbt/PC2Qucn0s2fNG+UC7rQ6so4K/UPz9xiufPTPOe27avaIyK4xheuXcDaQu7+1vpaFlcSMv9OfY0cbcxXNzXjk/M8g8/OrHq13n06ASJlK3qvrqnZ0/J+x3jsL1rO52RTvb0lt6mHL/j5/att+NzfEQCEe7cdueis5rRYJR7dt7Dy7e9nNZQ66rzRwNR7t5+d9GICsgsdre3by9DPXFSiR7SyeICeWuwldu23LaoKN4Walv2oJ6Y20wgfARjLAFfgL5oH+Nz4xyfOk7KptZ8MPao3UAKeG7B/U9lHyvc7unCDay1R4GZBdvVnc8xbOuJ5rtMIXNs3j/cye6BzD76Qh3HVeSKpM18Um2hSze2Z/479MUWnVjqawtxdjpet+5XyBSON3dH63bJZ6O5NrvuQ26ByFqLJ9OE/I5rsw3roZLjg2Mc2kJt+IwPg0PKTHBmsnjU1aoLx3PFhePZZGY2pZPupiV8sRmh1MI/t2y+Jb/afKFLei5Z8RfI8gvkTWDMXNk5xxtbN+YznBjLvDcOdtX3hJLIerLWxfEOHhn3xHi9Xf2tRIOZ7yqN3h1dSmHmev59D2ZPCJyowpzjg0fG2TPo/iKKraFWwv4wKZsimS5uGMkVjnP8jn/JxdXD/jC3bLmFu3fcvaqTrDk+x8dNm2/CGEMgdAJIk8gukLeUXOHY8WUW+G4LtVW8GHw5XZEu7tx2Z8mFc+uh9tdcN7gHXxzjwJYu/B74cnLN1i7+9w+O8FOf+EHFK18/ffI8sZCfT73rOgbaMwWekd4Yn3zXtbzlvh/wxk98n229pTsf02nLw0fG+Xd37170RnJgcyfXb+vmf3ztOb785OmSz48nUjxzeoo/evPliwqfr9zbz/a+GM+fmfZU4Xh3fxutYT8PvjieH91Rzn/7yrOM9Ea594qNK/491lo+9o3n2dYT5VWXrnzkwF17B/jrHx4t+3ebu79Z5xsXynW4/94/PslnHj6Wv39LdwsfesNlFRXlf/jCOYyBqzZXb1/d1bOLB088SCJVfInRprZN+WLs/oH9vDD+AjOJyjrcr990fdHiAL0tvdw4fCPfOvwtAAZbB7l96+35A++mtk08dvoxHjv9GKl0Cp/x0R5upzXYypHJ8qNoQr4Qd22/a8mu6etHejl0FBJzw4RiTwKZg+/t224v+QUYYKhtiJ+cfp4LZ19DS8c38QUvFk1SyVbSyW4CbQ/l79sQ3cDohVHOXDhDyBeiNbj6QriHdQLT1tqFg7zHgRZjTNBaO5/dbqLE88ezjy1ijHk38G6A4eHlPyStxUhvjCdOZM7KT84keOrUef7lHTuLxlhcVqd5t2en43S2BNZV0TIS9HHH7j529y/+f6i3NUTaZuZO16sL+9DohXU5piKnvz3M5u4WHnxxjHfdVPsvCPFEqmnHVOT0RcuPYCjUEe5gfHYcvxMkZSY4O23ZVfB4Ip3gwvyFslf0lFPYcZxIJZhPZrp1HRsj1nKxGWHhyVgof5VQwBdgb99eDp48WHGO/lhmzvHCbi5jLL7QKZJlOo63dm7N//uJsRBBf5rutvpdCSKy3oT8DmcrLBwnUmk+9cDR/NVZ8WSak5Nznujg9TmGK4Y7+N7z51wdlbBalw914BgY7mqhp44jzlbScfxPPznJy7b3lBwDkkileeylCd5+7dLr0tRDa7A1/11ufG48f9xO2zTxVLxo1NLe3r0VrV+wsXXldZiFelt6ubTvUn58+sf4gqeYv3AJxlz8/u4PHSfY8kLRc9LJNoxzAeMkMiMqhm8qWmxvpcL+MHdvv5uAL8CO7h08dfapVb/Waq3rwnEylWZzdws3jHS7HaUiN+/s5eV7Nqxols01W7v596++ZNHlnrv6W/mrX7yWD3/5GWbLLBzm+Ax37+vnZ64r/Ubyvlddwh986WmS6dIHtUjQxxuu3Mg9lw0ufm3H8MF79/LlJ06zqXPxh+RG5XMMV2/pys/fLOfx45N85GvP0dkS4OV7Nqx4Lu43nxnliRPn+cM3XoZvFYs2Xreti7deM7yoUzznwOZOfvqqTbz28sX/bZqNMYb/eM8ePvK150hnvyjNzKf4zMMvccclG4q64UuJJ1P834eOce3WLtpbqjd3K+gLsqNrB0+OPll0/87unUXbXL3x6nzhdynbOrexq2fXovt3dO3g3Mw5HONw1eBVRZ2+PsfH/oH97OzeSSKVoD3cnn/8y4e+zNHJ0lcUXLvpWjojS3+4G+hM4velsfMjQObPeP2m65fs+trUtomHnu0mPn0Z1vpo25CfvkAye3bXH7lY0PY7fvpj/RyfOk5vtLepu+XcYK29D7gP4Kqrrqppu+lIb5QvPn6SeDLFQ4fHsBau3dbF5u4W/I6p65zjs9Pxun74bxT3/exVJe/vyxaLz0zN1aVwnEilOXLuAq/YU/mIpmZ0zZYuvvLUadJpW/PFm3Mdx82sklEVcHGBPL/jJ2XGGZ9eXFCfmJtYeeG4oOM4noqTtJkCj0OMjujFz/WlOo6XcmnfpTx26jFSi84dlhb2h+kKd3FudvHnWH/wJHNTB7DWYMzFt3yf8bG5/eJ3gRNjQQY652ngNcVFPC/k9zGfrOz/60ePTvCfPl+8DEbQ73DTDm9ciXfX3n7OTc+zrcd7J4yjIT+37epj+4aVzZxfq77WEMYsXzg+NDrNr33yIP/qFTt57+2L5/w+eSKziOL+zR01Slq51mArLYEWooEoZy6cobcl890uN/M4d3wM+UJr6iJejf0D+zk8cZiZ6DPMjN/GzPid+ceMM0PX5j8sOm6mku35+ca7u9e29pBjHF4x8or8lcKDrYPEgjGm5+u7ePi6Lhz7fU7ZL0qNqC0c4E+rmHffxnb+189fs+rnX7qpnb9+17Wrfv4NIz3cMOK9hayu2drF158+s2Rx4WNff56Q38mP81hJx5C1lo98/Tk2dkR4/ZWrO0vm9zn8/hsuLft4yO/jD994ednHm81127q5btvFE0TJVJo7/9u3+NjXn+cVezYsWXD820eOc+r8HP/1TdU/QO3p3cNTZ5/Kd/5E/BGG24s7O3d07eCZs89wavpU2dfZEN1QtPLrQtdtum7JHKU6h6/deC3Hzx9f9GV0Q3RDfmbUUnwObOqeZ3L2Eoz5wqIFBkrpCg8wO7kBTIL5C5eQnO/BHzwLQGJuC8bE8QeL/x76on34jI/uFm+cAKyBcSBmjPEt6DruBGay3ca57UrNpunMPuaqkb4YaQtHzs3wwIvnCPocrhjKrE493N1StHBerZ2dnl+XheNycsXies05PjaWmRVY7mqo9eLabd189pGXePbMFLv7a3t10Gwi5folqrUWC8aI+CP5ERHl5BbIC/gc5swYkzOLTxhPzE2wsW1ln88KR1zEk3FS6czbtWNb6YxebMBYOON4OZFAhO1d23nm3DMVP2dLx5bShePQKTgfJJXozh97ATa2XRxTkUgZRicDXLtzakU5RWRlVrI4Xm7Nof/77uu4IjsuwWeMJ66oBnjH9Vt4x/Vb3I6xan/+zqvr/jsDPoe+1hAnlxlV8cjhzEf8R46U/qifu78RutNzhdHell4OTx5man6KtlBbfiH0XOH40g2Xlr16tVb8jp+bhm/in+b/iUjHd/L3x6euYPrsaxcdN9OpNnz+Cboj3Vy9cW37x43DNzLYWtzst6NrB4+eenRNr7tS3ng3EWkgV2cX83voxdJzjp89PcWXnjjFL9+8jRtGurnv2y/kVyyvxA8OnePRoxP8yq0j6+pS6Xry+xx+9dYRfnJ8km8/d7bsdslUmj/51vNcPtTBjdurf5KjI9zBYOzigWCka6Tkgng3DN1Q8nIcn+Pjmo3X8Oqdr676onDt4fZFM5aNMdwwdEPFnb1DPXHGp1q4pv9WXjb0smW3f/xIJzbdQtuG/wsmyezETfnHErOb8YePYUzxh2jHOPRGe1e1kGCTeBrwAdsX3L9wpvHTLJhlbIwZAloWbOeK/EiKM9M8+OIYVwx15AtZI72xOheO4/Sso4XxltMby3xQr1fhOLdI4noeVQHkF2N94IXar6kwdmGeznUw07uSruNcx3HACZAy40zPLH4vWOmc46n4VNG8xrnkXLZw7OA4KdoKLh9eaccxVN5NnbO7Z3fJVd39wcwCecn54s6ownmKp8cDpK1hoFvzjUVqKeirfMZxbhG9WNhPyO8j5Pd5pmgsqzfQHlm24/jg0Uxh+NFjE6RLrFVx8Og4g+3h/EhTN+S+4+bGVHRGOvE7fs5cOAPAXCrzZ8zN9K/G+InVGGgdYHf3boxJ5W/+cOZK2ORc8VXe6WQbkdAcd22/a03f0bd3bS+55tGO7uWbuKpN7ygiK3TpxnbCAYcHyhSO//gbz9MS9PHzL9vKe2/bzpmpOJ995KWKX/9j33ievtYQbzqw/Iqdsnqvv3ITg+1hPvq15xbN+sv5/GMnODY2y3tv216zMQh7+/bm/71wTEWhrkgXb9n3Fu7afhcjnSP4HT+90V5ev/v1XLbhspoVTa8cuLLoS+zu7t0r6uzd1BMHDBG7d9m5TomU4cFnW+nuOEuw5TnCbQ8Tn76UVKKTdCpCKrGBQLj83OV17PvAeeBNuTuMMS3APcAXC7b7IvBKY0zhENs3A7PA8rNQamxr9vLEx16a5PET57l228U5ZiO9MQ6fnVnRwrBrcXYqTk+s+YtolerNj6qoT6EotxDieu84HupqYWNHhAeWGY1VDaNTcXrXQZd9JQvkdYQ7MovgOAFS5jwzc4u/TB+ZPFL2c0MpCxfGy42q8NGC3z9R1GW8msJxZ3hlnWKRQITtnQvPNYIvOAokScUzI7zS6SDp8/fwtQdv5BNf7OcTX+zn736QOYk+2DW/6PmQKbiv5s8gIsVWsjhernDc7LPqpdhgR5gTk8t0HB8Zx+8YJmYSvHB28di3g0fGubLK3cYrneWbu9o2Fsws0OwYh55ID5PxSeLJOHPJOQJOAJ/jwxhTtJ5PvV298Wp6Wi42k/kC5zDODIn4xcKxTQew6Rb29A+WXLegUi2BFm4avqnkY12RrqKZz/WgwrHICgX9DvuHO3mwROH48NkLfP6xE/zMdZvpjAa5fqSb/cMdfOKbh0hUUPR45MgY3z90jnffvK3pLxt1W9Dv8Mu3jPDwkfGSJwHSacvHv/E8u/tbuWN3ZYvqrMZQ2xCtoVZ6WnqWPAA4xmFT2yZu23obb7/07dyz856aHziDviAHBg4AmS+zVw2ubFTOYPc8jrEcO7t8QeLHL0a5MOfjht2ZBdIi7d8Hk2Zm4sb86rWB8OGV/QGagDGmxRjzRmPMG4GNQG/uZ2NMi7V2DvgQ8D5jzHuMMXcAnyVzfP9owUt9AogDf2eMuTO78N37gf9mrT1f1z9UCdGQn8H2MH978CVSacu1Wy+eoBjpjTKfSvPS+NpXjl7OzHySC/Opui0C5wWRoI/WkL+OHcfT9LaGSi7ist5cu7WLB18cW1GRcjXOTsfpbW3+kyWVdOb6HB+xYAy/zw+kmZ2HhX/95+Pny64BUMqRieKTnrmOY8fGcALjRV8sV/Mlc7k1B0opPGmdY0waX/AMyfkB5qYuZ+LYbzB29iq6Ykk2ds+zsXuerRvmuGnPJLHw4s+0LYEW7t1975IL54pIZYJ+J18QXk7uytZmn1UvxQbaI5yanCv7GWFyNsFzZ6a5J7um0cEF4ypOTs5yYnKOA8PVLRyv5JgU8oXoj2VOVvocHy3+TPdx7nh9duYsc8m5/AnJWDBGwOfe58OgL8i9u+7lzm130hXpwhiLP/RSUcdxiMyfpzu2tlrOrVtuXXIkRyWjI6tJ7y4iq3DN1i6eOnWe8wsWKvzEtw7h9zm866bM6tPGGH799h0cn5jl7x89vuzrfuzrz9MVDfK2a4eX3VbW7s1XD9ETC/Hxbzy/6LEvPXGKQ6MXeO/t22u6MJExhj09e8p2G5cS8AXqNpphV88uOiOdXDV41YrnSQV8lsGu+WULx6k0PPBsK5u64+zZGCQWjOHzTxFufZT41JUwdxWYBP7QibX8Ubyqj0wh+LPAdcCegp9zZzQ+BPwe8O+ALwBtwMuttadzL2KtHQfuIDPW4n7gA8AfAf+pLn+KCoz0xRidiuN3TNEiHSN92TEWdRhXcXYq00WnGcfFettCdR1Vsd7HVORcs7WLs9Pz+fEdtZBKW8YurI+53pV0HEOm6zjgZL6YJplmem7xl78fn/5xRa/1wEsP8MRo8aJVM4kZkukkTrodn38833Ec9AVXdWxvCbTkL+GtVFekq+Tlvv7QSRKzI0yPvoFoOM7P3n6aN914lnuuGcvfXrZn8bnGrkgXb7jkDUWdWCKyeqHVdBwHVNpZTwbaw8zMpzg/myz5+KPZMRVvPLCJ9kggP7Yi5+CRCaD6841X0gnbG+0tuuomN+c46AvSEerg7Gxx4XilV9jUgjGGLR1beP3u13P71tvp75ohlehjd9d+rhy4kv0bbgegraXyUaULXdJzyaJ1jxba0b0DQ/1WqdW7i8gqXLO1C2svDpwHOD4xy98efIm3Xj1EX+vFy/Ru3dXL3sE2/vibh0iVmC2U8/jxSb7xzCi/eONWWoLret3KugkHfLz75q1857mz+YMrZBYo/OjXn2dbb5S7961+FdRK7ezeWTRDsJE4xuG2Lbexq3vXqp4/1BPn1HiQ+WT5A9vjR6Kcn/FzwyXnMQY2tW2iM9zJy3bP4hiHqcmdhMInMU7pD0bNzFp72FprytwOZ7ex1trfs9ZustZGrLU3WWsXrZhgrX3SWnt7dpsBa+3vLlhQz1W5OceXbWoveg8c6alf4Xh0OlMcXQ+X7a9Eb6w+hWNrLc+fmc7vC+vdtdlFXWs5rmLswjxpuz5OlkSD0ZLrBSzUEerIX2qbNhOMTy8uHB+fOs7Y7NLzp3/40g9LLl6TmXkMDq34ghP5k7JrGfGwmiuQ9vXtW3RfKPoUvsAZuvq/wC/eOVF2JEWhja0buXeXOo1Fqinod0imbcm5tAvF8x3Hulp1PcnNJS43ruLgkXEcA1cMdbB/uGPRAnkHj44T8jtcMlDdBXjbQm0Vj6vobektutKm8DjSG+0lmU6StumLheNVXGFTK8YYtnVu42UjmY7uwfANHBg4QDrVAUBbZHXfW1uDrdwwdMOy28WCMQZaa1+nyFF1SmQVrhzqJOAzfOJbh3jocOaLw4+OTWAtvPuWkaJtjTG897bt/OonD/Kv/+Yx+ttKfzH43qFztIb9vOP6zTXPLxe9/drN/PE3D/Ef/+EJbtqR6ZQZuzDPUyfP8/++6XJ8New2zqn3yrArtZYZSkO9cX7wTBtfebSTWLh0jfKJYy30d2YugQW4duO1+cuQzpye4SdHomzuTVD7JaLETbku01yxLKe9JUBPLMShM7Xrusw5my0cr4ci2kr0tYV5/PhkzX/P2IV5JmcTKhxnbeluoa81xAMvjPH2a2vz2WC97fO9Lb0cmVx6Xn5hx3HKjHN2qo/hEs3Kj595nJs331zyNb5/7Ptlu5Kn56dJpdMEbIxIcDrfZVzYdbVSnZFOTl84vfyGBTa1baIj3FG02F+w5TmCLc9x65ZbCQcq2ydu3nxzw3+OEfGaYHbsxHwqTbjEYpaFch3HYXUcrysDHZmawsnJ2ZLF34NHJ9jd30Y05Gf/cCffeGaUydlEfhTYI0fGuXxTR35fq6auSFd+cbul9EX7ik7o5jqOIVNADfvCzKUudhx3hes717cSg13zGCwvnQuyrX+O8zOZ/19jkdX15ty29baKx3HUc1yFCsciqxAJ+njF3n6+/MSposs+3nnDFjZ2LP7g/8q9/Vy1uZP7Hyt/qb3B8Nuv2ElbWHMd6yka8vMbt+/gQ198mqdPXbz8cu9gG/deMehisuawsTtOW0uSJ46W7/LyOZZXXjlObv3BwoPlDZec5+jZENdtb+G7J9s4H3d9HK/UyJ7BdgBu2r74UueR3mh9RlXkimjrYN7rSvTGQpw5v/TK3dWQG8mQG0+y3hljuHZbNw+8eA5rbU0Wab1YOF4f+3xftG/ZwnHhDMUU45ydKr3ds+ee5dqN1y4qmn7v6Pf4yZmflH39qfkpkukEIWJEWy528q+l43g1l+8aY9jbt5fvHf1e0f2DrYNs71q8eF4pPuOjLVTdbjURgaAvU8yLJ9PLrnuTKxznniPrw2Cu43hi8eezVNry6NFx3rB/E3BxHMWjR8e5dVcfc4kUT5yY5Bdu3FqTbJUWjheNqgheLBwbY+iL9XFs8lh+m0bqOM4J+i19HQmOn8t8Fpia9dESSrGaCwA6wh0MtlZef1hunEU1qXAsskoff9v+ird1HMPf/OrylxyIO37hxq01O3Cud6GA5ddedXLVz++MJfnVuzPPP8ABvnH4G9WKJg3mwOZOvvpbN7O9r3XRYyN9Mb74k9XvR5XKzTjujqp7rlBva4gL8ykuxJNEQ7X76Jg7OaAZxxddu7WL+x87wZFzM2zpqf7fy8WTJetjn69kgbxIIILPZL7xpX2nmZj2AYlF2yXTSZ46+xRX9F+Rv+/bR77Nk6NPln3tZDrJhfkLpJnHsTHaIhcvMV7L6uur/TK9o2sHj5x4hKAvyIboBvpifWxp31Lx89vD7TU5oSGy3uUWuosnU8DSTUXxRIqQ39H/i+tMb2sIn2M4Nbm4cPzs6SkuzKfya4ZcPtSBYzLjK27d1cfjxydJpGzVF8bLqeRq1Yg/kh9NEfQFmU/NFxWOAXoiPXSEOvLr+7SH2quedU/vHl4Yf4G55OobJDZ2x3n8SJS0hfMzvlXPNx6IrWz0hG+ZqxGqSYVjERHxhG2d2/jxmR9zbqZ28z7FXaWKxgDbeqKMzyQYuzBPV7R2nZFnp+O0RwI1uWzPy/qyRcXRqXhtC8dnpgkHnHwXjWQKx5CZc1yTwvE6WxCykgXywv4wxhgCToC0HWVyJgCU/kL5+JnHuXzD5QB84/A3ePbcs0u+9vT8NKnsaHmf46MleLHLuN4dxwB+x89b9r2l4nmU1fq9IrK03LziShbIiyfT+UKzrB8+x7ChNVRyxnFunvGB4cxniGjIz+7+Ng4enSh6fH+VF8bLqaRw3Bfty/97xB/JFI5Dxd8DjDH5K4DaQm1VL5SG/WFu3nwzNwzdwFOjT/HY6ceYnl/5FY4bu+c5eKiV0ckAU7N+OmOLTzZXop4zi1fK1XcYY8weY8zXjDEzxpgTxpgPGmM01V1ERBYxxnD14NVuxxAX5EYX1HpcxdnpOL3rpPNyJXJ/J7nFA2vl0Og023piOHWYLe8V2/tidEeDPPBibaa8n52OE/Q7tIXXRy9JJBBZdhG3XOHY7/hJmzGmZ8sXdKfnpzk0foivvvDVZYvGkFkYL5XOFI79TvFc47XMOG4Nta66+Lva58HqFuUTkeXlZxxXVDhOLTvOQprTQEeEkyVGVRw8Ok5PLMRQ18XjyoHNnTx6dJxU2nLw6Dibu1tqdtK4O9K97DaFVwDlrriJBqL5uf8L1WJMRa7D1+/4uXTDpbzt0retaFREzsauzOfjE+eCTK2h47g/1r+q59WDa4VjY0wn8FXAAvcCHwR+G/iAW5lERKSxbWrbtKoDunjb9uxiaYfO1LZwPDoVXzezXleiry3zxeLM+VoXji9ovvECxhiu2drFAy/UpnA8OhWnNxZaV5c4L9d17BiHoC9IwBcgZSaJz4dJpMr//Xz9xa9zaPxQRb87M984s9K635cmHKhOxzG4U8RtxHmTIs2gcHG85cQTaUJaGG9dGmgPc7JEx/HBI+PsH+4oOrbv39zBhfkUz5ya4pEjEzUbUwGZQvByJ0MLj8W5bY0xZU/u1uIKl4XfKR3jVDzjv1B7NEU0lOKF02HiSYe2VSyMFw1EG3rNADffYX4FiABvsNZ+xVr7CTJF498yxjTu35iIiLjq6o1Xr6sih8BgR4SQ36lLx/F6uWR/JXpjuVEVtVsgby6R4tj4jOYbl3DFUAfHJ2Y5P7e6Sx+XMjq9/k6WFF4eW07EH8Hv+EmRec+ZvFC+my9tly/s5EzFp0hmi9ABf7K443gNM46hskuDq00dx+UZY/zGmN8xxjxnjIkbY14yxvyR27nEG3IL3VXScTyXTOVHW8j6MtgR4eTkHNba/H1np+McPjeTXxAvJze24h8eO87Z6ThX1mhMRc5yx6SiURWB0gvkFapH4Rhga8dWDCv7nmlMZs7xC6cyf47WVRSOG7nbGNwtHN8N/LO19nzBfZ8mU0y+xZ1IIiLS6HpbetnWsa3s47u6d7G3by/D7cN0hDvWdBmuNAafY9jaE+XQ6IWa/p6z0/MqHJfQ2RLE75iajqo4fO4C1sJIrzqOFxrsyHwRKXU56lqtx32+khmCYX+YgBMgaWexWM5MVl4cXsr0/DSJZObvO+CP0xJoKfqda+FGEVeF4yX9BfAbwP8LvAL4HWBxa6BICcH84ngVdhxrxvG61N8WJp5MMz5z8cTyo9k5xgvnFw91ReiJBfnUA0cBatpxDEtfkRILxoqKxYUnUcs9r9pXuIR8IbpbFo/UiAQiqyribuyeJ5XOFJxbW5Irfn4jzzcGdxfH2w18vfAOa+1RY8xM9rH7XUklIiIN7+qNV3N48nB+VmTOQOsANw7fWNSRfO3Ga+sdT2pgpC/G48cna/b6c4kU0/GkZhyX4DiG3tZQTQqXOYfOZE4KqHC82GBHpqB4YnKWXf2lO3FW6+x0nMs2Vn+V8kbWH+tnW+c2Xhh/oew2EX+EgBPAksZygedGx9gz1LHm3z01P0UimVnoJxCYq9qMY6j/QnWtwdXPVW52xpi7gDcDl1trn3Q7j3hPaEUzjlU4Xq/ynw8mZvOLRz9yZJyAz3DpgmO7MYb9w518+cnTRIO+qn+eWGipOccLR0YVnkQd6Rrh8TOPFz3uc3xVH+OwVKF2a+dWTk6fXNHrbey+2FyxmlEV6jgurxOYKHH/ePaxRYwx7zbGPGyMeXh0dLSW2UREpIHFgjH29u4tui/oC3Lz8M0aY9GkRnpjHBubYS6xugUnljM6lfnAt94u26/U1p4oL5ytXcf3odFpjMn8Hik20F6bjuN02jJ2YZ6e1vW3z79s6GUEnEDZxyOBSL4omnLOcnxidkUjKcrJjKrIXFIeDE5XdcZxvUdVqNt4Sb8AfF1FY1ktLY4nlch/Ppi8+Png4NFx9gy2l9wncl3IVwx34KvxQsRLHZMWjowq7D7ubeld1F3cEe4ou2jeai21Zs62zvJXtpbT3zmPYyxgia2wcBz0BStaUNBNnjo1Za29z1p7lbX2qt7epRe2EBHxqs5w55q/QK4Hl2+4nJD/YnfotRuvpTVU27Pn4p6R3ihpC0fOzdTk9c9O5wrH6jguZaQ3xqHR6aI5etV0aHSajR0RIkF9+V2orzWEzzGcmKjuVe7jM/Ok0nZd7vPRYJRrNl5T9vGwP0zAlyksW99LzMWjHJ08uqbfOZ+aJ56Kk0gZjA3i98/nu4x9xpf/favVFmqr+hfrpWhhvCVdCzxrjPmYMea8MWbGGPN3xhit7isVWcmoijmNqli3BrIdx+///BO85qPf4TUf/Q4Hj4yXHUORm3tc6zEVsHThuDdaXMtbeMXNzq6dRT/Xa75xTiwYW3Yh3YX8vkzxOBZO4Vvh/44bohsavvHJzXeYcaDUtXGd2cdERNal4fbhhj/r2AhC/hBX9l8JZP7OdvXscjmR1NKW7kwn6pFztel6PTs9D6BRFWWM9EaZmkvWbM7xodFpjakow+9z2NAa4kSJldPXYr3v8/v69tHT0lPysbA/nO84tv6TpJMdPDm6tubRqfgUAKl0GocIYX8oX+itxsliY0xdu4DVcbykfuCdwBXAW4CfBw4AnzMlqgO6qlYWyo+qSFXWcazF8dan3liId96whd39rWxoDbOhNcztu/v46as3ldz+iqEO3nnDFt54YKjm2QK+QNmF7hYWZRcuDru9a3vRidCazDde5rv2arqOb9h9npddcn75DRdo9PnG4O6M46fJzDLOM8YMAS3Zx0RE1qXNHZtJ2zTHp467HaXh7endw6HxQ9w4fKPbUaTGhrsy88+OjddmbaGLoyrWZxFtOSN9maLuoTMX6Gut7hUR1lpeGL3ANVt0wqycgY5I1UdVrPcue2MMN2++mc899TksxZ30uRnHAGnnDKl4OyemTjAxN7HqgunUfKZwnEwn8Tnh4vnGgbXNN87pDHcyNjtWldeq5HdJWSZ7u9daew7AGHMS+BZwO/C1wo2ttfcB9wFcddVVtbmsQzwl6MsUguMVjOeKJ9OEAuo4Xo+MMbz/tXuX3zAr4HNWtP1adUW68se+nPZQe9EVo7C44zgSiDDUNsSRySNA9Y83A60Dy3b4buvcxgPHH1jR624fXN3ntIFY4xeO3XyH+SLwSmNM4WmIN5NZbfZb7kQSEXFX0BekP9Zf91mFXuUYh9fseE3RogrSnDpaArSG/Bwbq82oiiPnLhD0Oeu2+3I5uW7gQ6PTVX/t0ek4M/MpNnfr/+NyBjsiVe841smSzJzFvX2Lv0QXdhynzDlsOoZNB3hq9KlV/66p+BTWQsrG8ZlA2RXl16JUV5ahNpe/quN4SePAT3JF46zvAvPAHnciiZfkCsEVdRwn0oTVcSwNqNT32YVjKiBzFenCUUs7unfk/73aheOlxlTktIfbq/593DHOovUVHOMsmvnciNwsHH8CiAN/Z4y50xjzbuD9wH+z1q68v1tEpAkMtQ3hGIfuFnXeVcrn6MPyemCMYairhaM1Khw/ceI8O/tjBFY6mGyd6G8L0xL08cJo9UeF5DppBzuqUzxrRoPtYU5OzlV1xnSu47h3HReOITOyYqFIIIIxBr/jJ+VkJuilku08N/YciVRiVb9nan4Km4qRNjP4HF/ReIpqrWuw8Mt1V6SL64eur8prFwr7w1Xrkm5ST0HJir0B1r7KojS9oG9li+Op41gaUanC61Bb6TEZC0+gDrcPE/FHCPqCxILlR5ndOHwj+/r2regEbCWFY4CtHVsrfs1KHBg4wGt2vqaoeNzb0uuJ77KuvcNYa8eBOwAfcD/wAeCPgP/kViYREbcNtw8DugRUpJShrkhNCsfWWp48eZ69A6WWXhAAxzFs643WpOP4ZLaTdrBDi4KWM9AeZj6Z5tyF+aq95uh0nKDPoS3i5uQ693WEOxZ94cwVcgNOgBSZy2zTyQ7mU/M8P/b8qn7P1PwUqWQXaabxO6ao8Fq1wnFBx3HQF+SVI69kV/cufKa6X0rVbbysLwCXGmMKh2jfDASAx9yJJF6SWxyvksKxFseTRrWwcLy7Z3fZNWkWnox0jMNI1wjt4fayYyUc47C7Zzc3Dt/IOy5/B6/e8Wr29e1juH2YrkjXou5eqGy+cc7WzuoVjvuifewf2M+G2Iai4rEX5huDuzOOsdY+SWbOk4iIcLFwHPAFaAu1cT6uCzBEcoa7WvjmM6Ok0xbHqd7l16fOzzF2YZ69G9uq9prNaKQ3xiNHqr9+8fFcx3G7OhjLyXVjn5iYrdpoibNT83THgg2/knc9DLYOcmj8UP7nkC9z2azf8ZNKZ7rsU8kOAJ4de5ZLei9Z8e+Yjk+TSmwmbabw+2oz47gj3IHBYLHctuU22sOZk2HD7cO8OPFiVX4H6OR2Be4DfgO43xjzX4BW4A+Ar1prv+tqMvGESgvH1lotjicNqzPSiWMc0jbNxtaN3Lz55rLblho7uLN7J4l0+at8uiJd+bFSjnEYah9iqL24o/nszFm+d/R7nJw+CUB/rL/izz09LT30x/o5NX2qou3L8Tt+7th6R/73boht4NU7X80/PvuPnphvDO6OqhARkQJ90b6iL4+acyxSbLirhXgyzWj2EvtqeeJ45gTNngEVjpcy0hvj+MQss/PLL9azEicnZgkHHDpaFneGSMbFwnH1Fsg7Ox1f1/ONCy3s+DHGEPaHCfgCJNNxIEk60QFkvoROz6+8835qforkfCfWzBLwJ4sKx9XqOHaMQ1uojSv6ryjqlNrZvbMqr59T7RXum0127OLtZGYdfxr4OJkF8X7azVziHX7HYMzyM46TaUvaQlijKqQBOcahPdROR7iDV4y8YtEc40KlRk10RbrY0bWjxNYZlcwG7mnp4d7d9/LybS8nFoxVPKYi595d93LD0A35AvVq3DB0Q/5Ebk5/rJ9X73w1/bH+Vb9uPa3va9NERBpIrts4pzvSzeGJw+6EEWlAQ12ZboRjYzNsaKveWIMnTpzHGLhEheMljfTGsBZePHuBPYPV+7s6OTnHYEdEna9LGGjP7O8nq7hA3tnpOH1aDBIoPe8w7A8TcAIk0gmMfyLfcWyt5fDE4ZKzkcuZTcySTCdJJDJfjP2OryaL40FmZvPCbJs7NhPyhYinVn7SrTXYytT8VNF9GlWxPGvt88Cr3M4h3mSMIeR3iC/TcZx7XB3H0qgGWwe5vP9yQv6lP2+Uu/JmqcLqhuiGinOMdI2wuWMzyXSy4udA5v/FyzZcxtaOrXzn6Hc4Onl0Rc8fbh9mT2/pNVG9UjQGdRyLiLii1FnLze2bi35Wx7FIseFs4bjac46fODHJ1u4o0ZDOpy9lpC8KUPU5xycmZzWmYhld0SAhv8PJyep2HPeqcAxkjrcLu34j/gh+x4/F4vhPk05e7BZa6UndXOE1kQwC4DO+mnQcA1y64dJFJ2FysyJX45XbX7noM4tGVYjUXtDnLDuqYi6RuQJIi+NJo3rZ8MtoCy3fbLCaE6gbYpUXjiHz/Xu1x9vWUCuv2vEqNrZurPg5BsMtm29Z1e9rNHqHERFxwd3b7yboC+Z/bgm00BvtLdpGhWORYhs7IxhT/cLxkyfPV7WDtllt6Y5iTA0KxxOz+Y5aKc0Yw2BHhOMT1ek4Tqct56bnNaqiwMI5g7mOY4C07wTpbMcxwOkLp5lJVP4+NBWfwlpIJDNfvfyOv7jjuEozjpeymnEV0UCUnpYerui/In+f3/EvucK9iFRH0O9bQcexyjrSmJYaT1FopcfBkC/kytUvKzkJ293STTQYrWGa+tE7jIiICzbENvDaXa/Nn/VcOKYCoD3cXvWV0EW8LOT30d8WrmrheHImwUvjs+wdbF9+43UuHPCxqTPCodELVXvNRCrNmak4Ax3qOF7OQHuYk1UqHE/MJkimrQrHBRaOqwgHwvh9mU5b6z9FOtWGtZljcm5cRaWm5qewqSgJMwpAyB+qWcdxOf2xflqDrSt6TndLZuX5K/uvzD+3PVR+hXsRqZ6Qf/mO43iu41ijKsTjVtpxXMl841rY2rEVQ2XHQK8sfFcJFY5FRFzS09LDa3e9log/UrJw7BhHcwRFFhjqauFYFQvHT5ycBGCvOo4rMtIb49CZ6nUcnz4/h7WwsUMdx8sZaI9UbVTF2ewCkz0aVZG3cIG8iD9ysePYyRR8VzuuYmp+ilSym4R5CYNDa7AVn5Mp9BhMXQrHsPKu4+5IpnDsc3zcMHQDoPnGIvUS9DvLLo6X6zjW4njidS2BlhVt71bhOBKIVLzA3sLPFV6mdxgRERd1Rbq4d/e9bGrbVPLxXLePiGQMd7VUteP4yRPnATSqokIjvTFeODtNOm2r8nonJjKF0AHNOF7Wxo4wp8/PkVymkFCJs1PZwnEsuMyW60d3pJuQ72IhvXBURZKzAKQSHfnHT06fZDZRWQf4VHyKVKKLhPMSIV+EluDFL8j1KhrDKgrHBZ9BtnZuZahtiM6I5huL1EPI7+Q7isuZU8exNImVjqpY6Xzjaqp0XIU6jkVEpGo6wh1F844LNeOc48Iv5iIrNdzVwunz8fyXpbV64sR5NrSFdMl+hUZ6Y8wl0pyYrM7IhJPZ1xlUx/GyBjoipC2czhZ912I023Hcq/0+zxhTtMJ5JJBZHC/gBJhNnwYomnNsreXI5JGKXntqfopUItNxHPIH6j6mIqc93L6iVegXfga5cfjGfBeyiNTWSjqONeNYvG6lx8KVHMuqrZJxFe2h9rqsX1AveocREWlgzVg4bg2tbMaiSKGhrsyHsJfGq1O4fOLEpOYbr8BIb2aRj2rNOVbHceVyCwhWY87x2el5AJ0wWaDw8tOwL4wxhlgwxoXkOJAmVVA4Bnhx4sVlX9Nay4X5CyTn20mak0T84aLCcb2/WL585OW0h5Z/z/MZ36KxFO3hdrZ2bq1RMhEpFPRVMOM4VzjWqArxOMc4FReP20PthPzufX6pZFxFpeMsvELvMCIiDawZO3tWujiPSKHhrswl3tWYczyXSHFo9ILmG6/ASF8MoGpzjk9MzNIeCRAN+avyes1sY3YBweNVKRzHCfgM7ZHAml+rmRR+0csVdKPBKIn0PGn/i0UzjgFOTp1kLrn03OkLiQukbZq5ZApMirA/XFQsrmfHMUAsGOPe3fcue2K6M9KJY/RVUcQtQS2OJ+tMpQvkuTmmImdb57YlH2+m+cagwrGISEOLBqNNN9pBHceyFkPZwnE15hw/c2qKVNqqcLwC3dEg7ZEAh0arUzg+OTmb76SVpQ1kC8fVWCDv7FSc7mgIx6lsZfD1oqelJz86KlfQjQUyJ0vi/kcXdRynbZqjk0eXfM2p+BTWwnxqJv+6bo2qyGkJtHDvrnuXXFyoGa94EvESLY4n602lV+C4tTBeoW2d25YcV9FM841BhWMRkYbXbF/eooGouphk1XpjIcIBpyqF4yeyC+NpVEXljDGM9EarVjg+MTGX76SVpcVCflrD/iqNqojT06qF8RYqnHMc9AXxO35aAi04xmHeebpoxnHOY6cfY2JuouxrTs1PYVMx5s0pAEL+UNGX40o7rKot5A9xz8576GnpKfl4uftFpD4yi+MtXTjW4njSTCruOHZxvnFOJBAp21UcC8aarlFK39xFRBpctQvHLYGW5TeqoYAv4EqHlTQHYwzDXS1VKhxP0hr2s6lThcuVGOmNVW/G8eQsA1oYr2KD7RFOVKHjeHQ6rvnGZRR2CYX9mTnH0UCUWV4gnWzF2uKvT5Nzk/z903/Ps+eeLbo/lU7x2OnH+OFLPySV7CJhXsJvwvgdf9GX42gwWts/0BICvgD7+vaVfKzZTlqLeE3Q79PieLKuVNJx7DM+ulsaY5TjSOdIyfubrdsYVDgWEWl41T44bohucPVM7cIvzSIrNdTZUpUZx0+cOM+egTaM0eX6KzHSF2N0Ks7kbGJNrzM7n2JiJqGF8VZgsCPMiWp0HE/Nq3BcRm+0N//vuZOc0WCUuB0lTZx0cvFom2Q6ybePfJtvHv4m86l5Do0d4m+e/BseOv4Q86l5UokukuY4IV9mXy/8cuz2ydytHVtLXgXUjGssiHjJyhbHU8exeF8lx8PeaG/DXLm6tXNryXEVzTbfGFQ4FhFpeNXu+mkPt7O9a3tVX3MlAo46jmVthroyhWNr7apfI5W2PH3qvMZUrMJIb2bm6wtrHFdxYjJTANWoisoNdETWPOPYWsu5C+o4LicauNgBnDvJmZlzbIk7zy5aIK/Q82PP86mffIpvHP4GU/NT+fuT810knGNEAplFIAuPgW4XjkP+EBtbNxbdF/FHKp41KSK1EfQ7+cJwOfFkblSFyjrifZU0FjXCfOOclkALl264dNH96jgWEZG664p0VfXMaluobdmB/rXkd/xV/UK6pWNL1V5LvGG4q4UL8ynGLsyv+jVePDvNXCKthfFWYaQ3U1hb67iKXOesFser3GB7mLEL8/m5lqsxOZsgkbL0xDTjuJRYMJb/93AgXHRf3Hlq0QJ5CyXTyUX3zSdCpM004UCmWF/45djtwjHASFfx5baabyzivpDfYT659Hv9XEKjKqR5VPL9sJEKxwDXb7qeobah/M9hf5jOSKeLiWpD7zAiIg0u6Auyu2d31V6vPdRONBjNLwBUbwFfoKqjKvb27iXoUwFkPRnuyhRa1jLnOL8w3kYVjldqqKuFgM/w3Jmp5TdewsmJTOfsoDqOK5b7u1rLuIqz03EAelvVcVxKwBfIH1Nyxyqf4yPsjxB3niy5QN5y4snMSa6wL0zAFyDgC+Qfa4TC8cJxFZpvLOK+UIUdx0G/o5Fb0hQq+X7YGW6soqwxhju33Ul7KHM1UjN2G4MKxyIinnBl/5VV6zpuD2cObG6Nq/A7/qqOquhu6S4607seGWPeYow5aIyZNsYcN8b8b2PM4IJtjDHmfcaYY8aYWWPMt40xV7gUeU2Gu9deOH7s2CThgJMfuyCVC/gc9gy288ALY2t6nROTsxgDG9rUcVyp3DzotYyrGJ3KFDF7NaqirFyHceGX2FgwStx5mmRiZSebrIV4OnOSJewPF71mxB9piFmNIX+ITW2b8j83ysJDIutZ0O8wn0ovOZYrnkir21iaRiUnUnPfYxtJyB/iru13EfQFm3K+MahwLCLiCa2hVnZ271zz6/iMLz+/0a1xFQEnULVRFSFfiJZAy7oeV2GMeS3wf4DvA/cC/xa4GfhHY4oqEr8D/C7wB8A9wDTwVWOMO63na7CpM7P/vDS++q7LHx0b59KN7QR8+ii0Grfu7OWxlybWNC7k5MQcvbEQQX3prdhgR6bIXo2O4x51HJeVO04WnuSMBWJYM8tccmV/9zYVI8EpDD6CvmDDjanIKVwdXgvjibgv6HOwFpLpJQrHyTRhLYwnTWK574etwVb8jr9OaVamM9LJHVvvYLB1cPmNPUif1EVEPOLAwIE1dya1hlrzl7NFAhFXDm5+x1+1URUd4Q4AhtuHG6JryyVvAw5aa99rrf2atfavgd8ArgB2ARhjwmQKx79vrf2YtfarwJsAC7zXndir1xL00xMLcfTc6jqO55NpHj9xniuGOqobbB25dVcv1sJ3nhtd9WucmJxlQGMqVqS/PVc4Xn3Hcb5wrI7jsnIdx0WF4+x9M+mTK3qtVLKLhPMSISeGMaboi3EjFY63dmbGVTjGacr5jCJekzupOr/EuIp4MqWOY2kafse/ZGE4972vUW3u2Ny0awToXUZExCNaQ63s6NqxptfIzV/Kqfa4irZQG1cPXr3kNgFf9TqOc19uQ/5Q086UqkAAmFxw30T2n7mW8huANuAzuQ2stReA+4G7a5yvJoa7IqseVfH0qfPMJ9NcMaTiyGpdtqmDrmiQbz6zhsLxxCyDWhhvRUJ+Hz2xECcnV99xPDoVx+cYOiKB5Tdep6LBbMdx4OL+GfQF8RNj1h7G2sqv1kklukiYlwj7G3NhvJygL8hQ2xAd4Y71fCJWpGFUVDjWqAppMks1FzXimIr1Qu8yIiIesn9g/5rGSyw84OY6jKphR9cO3rTnTct2MVdzxnHhmeetnVur8poe9D+Bm4wxP2uMaTPG7AT+H+Dr1tons9vsBlLAcwue+1T2Mc8Z7mpZdeH4R8cmALhiuKN6gdYZn2O4eUcP33p2lPQSl9GWY63l5OScFsZbhcGOMCdWOeN4LpHiO8+dpb8tjONoMaVySs04NsYQ8fURd54mnap8Nnpivp2kOU04kOmiKiwW5wrUjWKka0RjKkQaRMifGUGx1AJ5mY5jjaqQ5rHUCdVG7zhuZioci4h4SHu4nR3dq+86bgsVL+oT9ofZ2LpxTZn8jp/bttzGHdvuWLRa/EK5y2CrNaqicGXd9Trn2Fr7j8A7gfvIdB4/A/iAnyrYrBOYttamFjx9HGgxxgQXvq4x5t3GmIeNMQ+Pjq6+q7RWhrtaODk5u2QnTjk/OjpBb2tI3a5rdOuuPsYuzPPj4wsb3pc3OZtgZj7FgP4brNhAe5iTq5hxnE5b/tVnH+Mnxyf5D6++pAbJmkduxvHCY1Us0EbKOUN8vvIxH3MJCyZNOJB5m20NteYfa6SOY8gcR/uifW7HEBEqHVWRJhxQSUeax1JXpapw7B69y4iIeMyBgQOrfu7CURWQ6TBai60dW9nVsyv/c9C3qAaZF3AyReWQP1SVTufCOYyxYKxp50otxRhzG/AJ4H8AtwFvAbqAzxljVt2GYq29z1p7lbX2qt7e3uqEraKhrhbSFv7vQ0dX3PH6o2MTXDHUkZ/3Latz885ejIFvPnNmxc/NzehVx/HKDXZEOD4xu+L9/sNfeYYv/Pgk/+7u3dx96bod7VORXMexz/EVHdNiocyJjvOzC8/BlRdPZvb13JU2rcHGLRwHfUF293jyIhSRppMvHKfKv99kRlWo41iaR+74W4oKx+5R4VhExGPaw+1FnbYrsbDjGDIrqa9ldMTC18wVh0spXPCg0t9Zbjuf8RV9AYd123X8YeDz1tp/a639prX2/wKvA24F7s1uMw7EShSSO4EZa+18vcJWyyv29HPlcAe/+w9P8Po/+T6PHh2v6HmTMwleOHtBC+NVQVc0yOWbOlY15zg3o1eF45W7criTmfkUDx0eq/g5n3noGB//xiHees0w7755Ww3TNYfCL65FC+SFE/hsB2OzYyTmll9c1lqIpzMd+WFftnDcwB3HwJJXDcnqGGM2GmOmjTHWGFP5nBNZ14K+TKlmqVEVc8kUIXUcSxPpbSndrOJ3/EsWlaW29C4jIuJBG9tWPl7CMU7RF9acgC/A5RsuX3WWha+51JfOlRaOg74gd2y9o+Rj7eH2RR2j67RwvBv4UeEd1tpngFkg107+NJnxFQtXQ9ydfcxz2lsC/O2v3MCH33Q5JyZmef0ff59/8zePkUwtPbriRy9NAHClCsdVceuuXh57aYJz0/EVPe9EdtSCxoWs3J2X9BEJ+Lj/xycq2v6HL5zjfZ/7CTft6OGD9+5Vp30FAr5AvtO4cFyF40BPtJVZ51HGTt9FKrH0Qj02FSNhTuE3UXyOD7/jL55xHGisGcdSM/8VmHY7hHhLSIvjyTq0Ibah5P3qNnaX3mVERDxoU9umso+VGwERC8bKPravb9+qu44Xdhz7HX/ZBfwKi8qVzDk+MHCATW2bCPkWz5Ms1XXd09KzHs9GHwH2F95hjLkEiACHs3d9HzgPvKlgmxbgHuCLdUlZA45j+KkDm/jGv7qVn3/ZFj7z8Et8Y5nu1x8dncAYuHSTVmauhtt29WEtfOe5syt63onJOQI+Q0+s8lmxktES9HPHJX38009OLXuiBOAjX3uODW1hPv72/QR8+uhfqVxRd+GxsTfaDsYy7XyX86feTjpdfh9OzA2TcF4i7MsUixdeJdOIHcdSXcaYm4G7gP/X7SziLbmCsBbHk/WkI9xR8ntfqXGLUj/69Cgi4kGDrYNli8AjnSMlv4wudcBdquv46sGrl8xSavxFua7jwo7jpRY/gEzeSzdcijGmZId1uTPP67Dr+BPAm40xHzbG3GmMeTvw92SKxv8EYK2dAz4EvM8Y8x5jzB3AZ8l8DvioK6mrKBby875XXUJnS4D7H1u6C/NHx8bZ0RejNazLsavh0o3tdEeDK55zfHJilg1tYRxH3a+rcc/lg4xdmOf7h84tud2Z83P84IVz/NSBTbRpn1+R3EnIhceqkD9ELBhjJvh5kokupk7/NNaWPh7PTe0jYY4Rzo5JjoUuntgM+UL4HBV8mll2PNRHgQ8CKzu7JuueFseT9arUIq3qOHaX3mVERDwo6AuWnQE10jXCcPvwovtLFXgLleo6vnzD5Vw5cGXZIrVjnJKX2pabc1x4/3IdzjcM3ZD/vRtbFxeOCxfGK7S1Y+uSr9uEPgK8B3g58A/AH5IZXXGHtfZCwXYfAn4P+HfAF4A24OXW2tN1TVsjAZ/D3ZcO8JUnTzMznyy5jbU2vzCeVIfjGG7e2cu3nztLagWLtZ2YmNN84zW4ZWcvrSH/sidK/uknJ7EW7rlMi+GtVDRYuuMYoCfSw3z6Ak7nn5GY3c7c+cUnWNPpELNz3VgzSyT7Gm3Bi8dhdRuvC78ChICPux1EvKeSwvFcQh3H0nxKjatQ4dhdNSkcG2PebIz5O2PMyewiAO8ss91GY8znjDFTxpizxpiPZS+dFRGRZZQaVxH0BRlqG2KobWjRY+3hpS/xWdh1PNg6yHWbrsvMRg4uno0MmctuS83LrKjjeIlRFcPtw2zu2Jz/uVTHcbkFAgdaB9a02J/X2Iw/sdZeZq2NWms3WmvfbK19ocR2v2et3WStjVhrb7LWPupW7lq457JBZhMpvv506e7Xo2MzjM8kuGJodYtLSmm37upl7MI8P87Oj67EiclZzTdeg3DAxyv29vOlJ04RT6bKbnf/j0+yu7+VHRtKv4dLebmO41LHk85IJ45xOG9+gD90lNnJa7G2+FgYn97FeOB/Fr1W4ZoAucK0NCdjTDfwn4HfstYmltn23caYh40xD4+OrnyxUWlO+cLxEiOJ4knNOJbmsyGqwnGjqdW7zBuBLWQ6mkoyxgSAfwY2A28B/gWZ2Yv31SiTiEhTKVVM3dy+GZ/jY1PbpkVzhpfrOIaLXcfRQJSXb3t5vihc7mBd7jVziwotVDTjuMyoCsc43DB0Q9F9HeGOos5mgymbyTEOm9s3l3xMmts1W7voaw2V7cL80bEJAHUcV9nNO3oxBr72VGXjKuYSKU6fn2NAHcdrcs/lA0zNJfn2s6WvgH9pfIZHjoxzz+WDdU7WHHLHnFKdwY5x6Ip0MT47TrDtO6ST3SRmR4q2OXXhNDO+77OxdVP+NQpPwqrjuOn9HvBDa+0/LbehtfY+a+1V1tqrentLX00m60+uk3i5URUhjaqQJqOO48ZTq3eZN1tr9wO/ucQ2bwQuAX7KWvuP1tpPAr8OvM0Ys6NGuUREmkZ/rL+ogxcyYyogM4Nx4UG3kkUFAr4A+wf284qRVxQVdssdrAu7p4pep8yoiko6jnd07Sj5+woL5bFgbMnZkFs71924CgF8juHVlw3wjWdGOT+3uMHrR8cmiAR87Nyw7hZQrKnOaJCbd/TymYePLfkFN+f+x06QSFlu2t5Th3TN62Xbe5ac6/2PPz4JZDrxZeVyXcLlVnjvifRgsUw738fxnWd28rr8YxMzc4zZL9Lm7GFDwazGwmOmCsfNyxizF/gF4IPGmA5jTAeQ+w/ebozRWTNZVjC/OF7pq0qSqTSptCWsURXSZIK+YNGVpdFAtOzVrFIfNSkcW2uX/9YAdwMPWWtfLLjv74F5MivPiojIEhzjMBC7OLcyN6Yip/DfDaaijmOAyzZctuiL8ko7jssd3CuZcVxqQQQonnNcbr5xzlDbUNnitTS311w2yHwyzVeeWDy6+UfHJrh0Yzt+n7pzqu2dL9vCmak4X3z85JLbWWv5i+8fZueGGNePdNcpXXNabq73F358ksuHOhjuVoFyNXKjJKKBaMljYEughYg/wrnZUcJtD5OY3UFyvpt4Ms6Lk88RsJvZ3D5cNM4pV4zOPV+a1g4gAPwAGM/ecnOOX6IJFqWV2gv6lp5xHM/er45jaUaF30XVbew+N99ldgNPF95hrZ0HDmUfExGRZRTOOd7SsaWoC7dwgbxoMLqm1dtXXDiupOO4zKiKrkhXyfsL/6zl5hvn+BxfyQUCpfntH+5gY0eE+39c3IU5n0zzxInzXDHc4U6wJnfLjl629kT5i+8fXnK7h4+M88SJ87zzhq0l56PLypSb6/3i2Qv85PikFsVbg8Iib6kFWo0xdLd0M5OY4ZT9a84G/ojDY2d4buw5sH76079GIHRxXm3YHy4a41RqYVlpGt8Fbltw+4PsY68C/qtLucRDLnYcly4czyUynchaHE+aUeGcYxWO3edm4bgTmChx/3j2sUW0cICISLHCYuq2zm1Fj/VGe/PjICrtNi6nah3HhTOOy4yqKFc4jgaj+XEblXyA0LiK9ckYw2suH+C7z51l7MJ8/v6nTp5nPpnWfOMacRzDz12/mUePTuRnSZfyF987THskwOuu1PiEasjN9f78j4pPlHwhO77i1Socr1rQF8yfBB1sK72/dke6ifgjTCfGifsfYjp9DKyPnvl/RzR6hsJzIwsXmVXHcfOy1p611n6z8MbFhqnvWGufcTGeeERomcXx8h3HWhxPmpA6jhtLRe8yxph2Y8zu5W61DquFA0REinW3ZL60LhxTkTPUnrmvkvnGS4kEIoR8oUX3r3RxvMKO45A/hGOKD0MtgRZC/sW/Jyc353i5URWQXSjQqAtjPbrnskGSacuXHj+FtZb7HzvBr/71IwR8hgObl993ZHV+6sAmYiE/f1mm6/jExCxfeuIUb7l6iJagv+Q2sjI+x/C6Kzfy5SdP86t//QjHxmYAuP/HJ7hmSxcD7Rqluha5ruOB2MCi4xVkjml7evdw2YbL2Nt1M5vm/pKN8x8lkr6SUOzxom0XrgmgwrGILKXSURXhgD7rSvPpDHfmT96qcOy+Sk9PvQl4qoLbSowDpSoZndnHRESkAoOtg4vGVOTkislr7TgGaA8Xv2WHfKGyBeJyoyoW3r9wznG5buOcXIf1cqMqINPdXLignqwfewfb2NYT5ZMPHOHN9/2QX/8/j9LREuRTv3QdG9pKz9aWtWsNB3jjgU184ccnODM1t+jxv/7hEay1/Mx1m11I17x+6+U7+e2X7+Sbz4xy53/7Fu/73E949vQ091yubuO1ys05DvqC9LYs3bTiD53EHzpKKrEBX/AU/mDx1ZELO45zry3rg7X2L6y1xlo77XYW8QbHMQR8puyoityieeo4lmZkjMmve6PCsfsqepex1v5Z9kC35G2Fv/tpFswyNsYEgW0smH0sIiLlbWrbxEjnSMnHhtqHMJhFRd/VWHjQXqoYXW5URWHHMay8cDzYOrhsV3KhheM7ZH3IjKsY5IkT53n+zDT/5fWXcv+v38jVW5bev2Ttfvb6zSRSlk89cLTo/rlEiv/z4FHuvGQDQ13qtKymcMDHr9+xg6//q1t45d5+PvXAURwDd1+qwvFaFc45LjeuolCk/YcAhKKPL3qssOM44AQWHQ9FRBYK+pyyHcdzCS2OJ81tQ2wDPuMrOhaLO9z8xPJF4G3GmM3W2iPZ+14LhIAvuRdLRMRbNndsXlSAzQn7w/RGe6vScbyiwnG5juMFBeWFc46XKxyH/eGyRfJSNrdv5tlzz1a8vTSPd920ld7WEK+9bJD2ltL7o1Tftt4Yt+7q5ZMPHOXXbt2eX9zn84+dYHwmwTtftsXdgE1soD3CR956JT93w2bOTc/TE6vsBJuUV7iA3cbWjTx68tEltw9GnyTacz+h2E8WPVbYcaxuYxGpRNBfvnAc1+J40uQ2RDfQHm7XYsoNoCaFY2PMHmAPkKtkXGWMmQZGrbXfyt73N8C/B/7OGPO7ZMZW/BHwKWvtc7XIJSLSjJabkzjcPrzmGcewuHC8cF5joUpmHENmdnKhSkZQ7Ovbt+w2ha/fH+uveHtpHm3hAO/QSARXvPOGLbzzfz3Ez/3PB+nIFu0fPTrBrg2tXL+t2+V0ze/AZnXWV0thl1NftI+AL0AilSi7vTGWSNvDJR8rPGZqvrGIVGLJwrEWx5MmtyG2QWMqGkStOo5/GvhPBT+/J3v7FnArgLU2YYy5C/gY8BkgDnwa+Nc1yiQisi7t7N5ZdnTESqyk47jcJbhrHVUBi2ctL6dwVV4Rqb2bd/Tyqkv7ef7MNOcuxAHoaAnwWy/fqa4R8ZTCzmDHOPTH+jk2eWzFr2OMKSpCq3AsIpUI+X3Mp7Q4nqxPYX+Y4fZht2MINSocW2vfD7y/gu1eAl5XiwwiIpJRjTEVAO2hdgwGi132dStdNK9wVEVrsLUqBW4RcZfjGP747QfcjiGyZgvnKm5s3biqwnE0EMUxF7sCVTgWkUos1XE8l9DieNL8VjKiUGpH7zIiIlIRn1O8OEE1FscrHFXRGVl+TIWIiEi9FM44hswCraux8Hi58HVFREoJ+hziyVTJxy6OqlDHsTQvNRU1BhWORUSkYrlxFQaz5Aq3q1kcr5IxFSIiIvUS8oeKjmddka5VdQsXLowH6jgWkcoE/U6+QLxQrqAcCqikIyK1pXcZERGpWK5wHAvGii67XajSjuPCGccqHIuISKMpnHMMq+s6XriYrArHIlKJJRfHS2RnHKvjWERqTIVjERGpWK5wvNzc5FIzjg1myVEVKhyLiEijWXh1zVDb0IpfY2HH8cJitIhIKSG/s+zieOo4FpFa07uMiIhULFc4Xtg9tZDf8WMwi+5bKDeqwmDyry0iItIoFs4j3tKxZcUdwwuLz+o4FpFKhCpYHC/oU0lHRGpL7zIiIlKxSjuOYXGhuFThOOQP4RiHtlBbycdFRETctLDo63N87O3du6LXKDxm+h1/yatyREQWWnrGcZqgz8FxTMnHRUSqRYVjERGpWDQYxe/4KyocL/xiXG7uccgX0pgKERFpSKXGSuzu2V3xSu9+x180lkndxiJSqaBviRnHyZTGVIhIXeidRkREVqQj3FFR4Xjhl+pyHcWRQESFYxERaUgL5xND5mqZXd27VvV8FY5FpFJLLo6XTBPSwngiUgcqHIuIyIq0h9pLfpFeKOAElvw5J+KP0BnprEo2ERGRamoPt5e8f1/fPhyz/FephWsCLJyZLCJSTsjvK7s43lwiRcivco6I1J7eaUREZEV6o71Fl92WU2nHcdgfVsexiIg0pFgwVrJAHAvG2Nqxddnn98f6i35Wx7GIVGrZjmONqhCROtA7jYiIrMhw+3BF2y3qOC4zDzIajOYX3RMREWkkjnEWLZCXc9mGy8o+zxjD9ZuuX7RNudcSEVkoszhequRj8YRGVYhIfahwLCIiK1Jpd/DCxfHKdRwPxAYqutxXRETEDe2h0uMqulu62di6cdH9QV+QV468kr19exc9psKxiFQq6HNIpCzptF30WDyZIqyOYxGpg9Lf4kVERNZoYYdxuRnHA60D9YgjIiKyKu3hdo6dP1bysRuHb+T41HEm5yaZjE8ST8W5afimslfSqHAsIpUKZmcYz6fShJ3i7uLM4ngqHItI7alwLCIiNbGwULzUjGMREZFG1RZqK/tYa6iV3aHdFb+WCsciUqlQYeE4sKBwnEjR0RIs9TQRkarSKSoREamJShfHExERaWTlRlWslGMcLY4nIhXLF45LLJCnjmMRqRe904iISE0snHFcbnE8ERGRRrZUx/FKRANRjDFVeS0RaX65URXxMoXjhV3IIiK1oMKxiIjURKWjKkRERBpZW6gNw9oLvhpTISIrEVyq4ziRUsexiNSF3mlERKQmKl0cT0REpJH5HB/RYHTNr6PCsYisRNCX6SguVTieS6YJBVTOEZHa0zuNiIjUhDqORUSkWVRjXIUKx+uDMeZNxpjPG2OOG2OmjTGPGGPe6nYu8Z4lZxwnUoT8GlUhIrWnwrGIiNTEoo5jzTgWERGPqsYCeSocrxu/BUwDvwm8FvgG8CljzK+7mko8Jz+qIpVa9FhmxrHKOSJSe2r/EhGRmlDHsYiINAt1HMsK3GOtPVvw89eNMYNkCsofdSmTeFB+cbxEccdxMpUmmbbqOBaRutApKhERqYmgL1j0s2Yc144xxm+M+R1jzHPGmLgx5iVjzB8t2MYYY95njDlmjJk1xnzbGHOFS5FFRDylPayOY6nMgqJxzqPAYL2ziLflC8ep4sJxPDu6QovjiUg9qP1LRERqYuFoCnUc19RfALcDHwCeBoaAPQu2+R3gd4F/nd3mt4CvGmP2WWtP1S+qiIj3qONY1uh64Fm3Q4i3BH2lZxyrcCwi9aRv8SIiUhMLO4w147g2jDF3AW8GLrfWPllmmzCZwvHvW2s/lr3vB8Bh4L3Af6hPWhERb1rrjOOAEyDkD1UpjXiJMeYO4HXAL5R5/N3AuwGGh4frF0waXm6G8eLCcWbmcSigURUiUns6RSUiIjWhjuO6+QXg6+WKxlk3AG3AZ3J3WGsvAPcDd9c2noiI9wV8ASL+yKqfr27j9ckYswX4FPAP1tq/KLWNtfY+a+1V1tqrent76xlPGlzQlykMLyocZ2cea3E8EakHvdOIiEjNFHYda8ZxzVwLPGuM+Zgx5rwxZsYY83fZhXhydgMp4LkFz30q+5iIiCxjLXOOVThef4wxXcAXgSPA212OIx6Un3FcdlSFOo5FpPZUOBYRkZop7DpWx3HN9APvBK4A3gL8PHAA+JwxxmS36QSmrbWpBc8dB1qMMcEF92OMebcx5mFjzMOjo6O1yi4i4hlrmXPcGmqtYhJpdMaYFuALQBB4jbV2xuVI4kG5wvF8svjj21wiO6pCM45FpA70LV5ERGom12XsMz4u1jClykz2dq+19hyAMeYk8C0yC+Z9bTUvaq29D7gP4KqrrrLViSoi4l1rmXMcXXg+QQABAABJREFUDUSrmEQamTHGD3wW2AHcYK0943Ik8ah84TiljmMRcU/VT1EZY9qMMR8wxjxojJk0xpwyxnzOGLOzxLbtxpj/ZYwZz277SWNMd7UziYiIO3Idx1oYr6bGgZ/kisZZ3wXmgT0F28SMMQu/YXQCM9ba+drHFBHxNnUcS4X+GHgV8J+BbmPMdQU3rZAoFQv5l14cTzOORaQeatFxPAz8EvDnwL8HWoB/BzxgjLnMWnusYNvPADuBdwFp4A+AvwduqkEuERGps6AvMwFBYypq6ikgXOJ+Q+bYCvA04AO2A88UbLM7+5iIiCxDM46lQq/I/vN/lHhsK3C4flHEy/yOwZjyi+Op41hE6qEW3+RfBEastbO5O4wx3wGOkln5/QPZ+64nc1C9xVr77ex9x8kUmO+01n61BtlERKSOcqMqVDiuqS8AHzDG9Fhrz2bvuxkIAI9lf/4+cB54E/D/QH7+4j1kx1GIiMjS1tJxrMLx+mGt3eJ2BmkOxhiCPmfR4nhz2Y7jkDqORaQOqv5OY629UFg0zt43RmY12cIV3u8GTueKxtntHiRTeL672rlERKT+8qMqHI2qqKH7gHPA/caYe4wxbwP+Cviqtfa7ANbaOeBDwPuMMe8xxtxBZv6iA3zUpdwiIp4S9ocJ+VY3aUCFYxFZjaB/ceH4YsexCsciUnt1eacxxvSSuTz22YK7y10e+1T2MRER8Th1HNeetfY8mUXwxoFPAx8nsyDeTy/Y9EPA75EZH/UFoA14ubX2dP3Sioh422q6jlsCLThGBR4RWbmQ39HieCLiqnp9k/8wMA38RcF9ncBEiW3HgW2lXsQY827g3QDDw8NVDSgiItWnxfHqw1r7PJmFeJbaxpIpHP9eXUKJiDShtlAbozOjK3qOuo1FZLVCfp8WxxMRV1VUODbGtAMDy21nrV3UQWyM+VXgZ4CfWrDi+4pZa+8jO4vxqquusmt5LRERqT0tjiciIs1kNQvkqXAsIqsV9DuLCsdzWhxPROqo0m/ybwL+tILtTNEPxryWzOzEf2ut/dyCbceB3hKv0Zl9TEREPC43qkIzjkVEpBm0h5YuHPsdP8l0sug+FY5FZLUyi+Oliu7L/RzUjGMRqYOK3mmstX9mrTXL3QqfY4x5GZlZi5+w1v7XEi/7NKVnGZebfSwiIh6TG1GhjmMREWkGnZHOJR+/ov+KRSdLVTgWkdUq1XEcT6YJ+Aw+x5R5lohI9dTkFJUxZi9wP/Al4DfKbPZFoN8Yc2PB864iM9/4i7XIJSIi9ZXvONaMYxERaQJdkS4M5Ys1A7EB9vbtLbpPhWMRWa1gqcXxEmnCGlMhInVS9RYwY0wfmYLxNPAR4Bpj8h+uzltrnwSw1v7AGPNl4H8bY/4VkAb+APiutfar1c4lIiL1pxnHIiLSTPyOn7ZQG5PxyZKPd7d00xnp5Cenf0LKZi4nV+FYRFYrVLLjOEVIC+OJSJ3U4pv8HmBT9t+/seCxbwG3Fvz8ZuCPgP9Jpvv5C5TvUBYREY/JFYw141hERJpFd0t3ycJxS6CFsD8MwK6eXTw5+iQArcHWuuYTkeYR9DtciBfPTZ9LpLUwnojUTdVPU1lrv7nEHORbF2w7Ya39eWtth7W2zVr7Nmvt2WpnEhERd6jjWEREmk1XpKvk/d2R7vy/X9l/JQaDz/iIBCL1iiYiTSazOF6JjmMtjCcidaJ3GxERqZncbGPNOBYRkWZRWCAuVFhQbg21sr1rO9FgtF6xRKQJlVscLxRQx7GI1IcKxyIiUjO5ERXqOBYRkWZRtuO4pbigfOXAlRpTISJrEvSX6jhOq+NYROpG7zYiIlIz+Y5jzTgWEZEm0R5uL3lCdGFBuSvSxd6+vfWKJSJNKOT3MZ8qLhzPJTSqQkTqR+82IiJSM+o4FhGRZrSwSOwYh85w56LttnVuq1ckEWlCIY2qEBGXqXAsIiI1Y4zB7/hVOBYRkaaycM5xe6gdn6NCjohUV8kZx+o4FpE60ruNiIjUVNAX1OJ4IiLSVEqNpRARqbagzyGeTBXdN59ME1bHsYjUiQrHIiJSUwEnoI5jERFpKgsXwlv4s4hINQT9DmkLyYI5x5pxLCL1pHcbERGpqYAvoMXxRESkqSwcVbHwZxGRasgViAsXyIsn0yoci0jd6N1GRERqSh3HIiLSbEL+ENFANP+zRlWISC0Ec4Xj5MLCsUZViEh9qHAsIiI1FfKHtGCQiIg0nVyxOOgL0hpqdTmNiDSj0oXjFOGASjkiUh96txERkZpqCbS4HUFERKTqcnON1W0sIrUS9GVKNvFs4TiVtiRSVh3HIlI3KhyLiEhNRfwRtyOIiIhUXa5grMKxiNRKruM4VziOJ1MAhNRxLCJ1oncbERGpKXUci4hIM8otiKeF8WQhY8weY8zXjDEzxpgTxpgPGmPUIiorlusszo2qiCfS2ftVyhGR+tBqRSIiUlMqHIuISDPqjHTiGCc/skIEwBjTCXwVeBK4FxgBPkymaes/uBhNPChXIJ5P5TqOM/8MB3QeQkTqQ4VjERGpqUhAoypERKT5OMahI9yhURWy0K8AEeAN1trzwFeMMW3A+40xf5i9T6QiCxfHy4+qUMexiNSJ3m1ERKSm1HEsIiLNanP7ZoK+oNsxpLHcDfzzggLxp8kUk29xJ5J41cUZx5mC8Vx+VIU6jkWkPtRxLCIiNaXCsYiINKsd3TvcjiCNZzfw9cI7rLVHjTEz2cfudyWVeFLQlykcf+D+J+mIBLgwr45jEakvFY5FRKSm/I4ONSIi0pw0pkJK6AQmStw/nn2siDHm3cC7AYaHh2saTLxnx4YYd+/r5/xcAoBQwOHOSzZw2VC7y8lEZL3Qt3kRERERERERF1hr7wPuA7jqqqusy3GkwbQE/fzJzxxwO4aIrGO6vkFERERERESkOsaBUu2gndnHREREPEOFYxEREREREZHqeJrMLOM8Y8wQ0JJ9TERExDNUOBYRERERERGpji8CrzTGtBbc92ZgFviWO5FERERWR4VjERERERERker4BBAH/s4Yc2d28bv3A//NWnve1WQiIiIrpMXxRERERERERKrAWjtujLkD+BhwPzAB/BGZ4rGIiIinqHAsIiIiIiIiUiXW2ieB293OISIislYaVSEiIiIiIiIiIiIiRVQ4FhEREREREREREZEiKhyLiIiIiIiIiIiISBEVjkVERERERERERESkiLHWup1hVYwxo8ARt3Nk9QBn3Q6xSl7ODsrvNi/n93J2UH63bLbW9rodot4a6Jjr1f0mR/nd5eX8Xs4Oyu8mL2dfd8fcBjregrf3HVB+N3k5Oyi/m7ycHbydv+wx17OF40ZijHnYWnuV2zlWw8vZQfnd5uX8Xs4Oyi/rk9f3G+V3l5fzezk7KL+bvJxd3OX1fUf53ePl7KD8bvJydvB+/nI0qkJEREREREREREREiqhwLCIiIiIiIiIiIiJFVDiujvvcDrAGXs4Oyu82L+f3cnZQflmfvL7fKL+7vJzfy9lB+d3k5eziLq/vO8rvHi9nB+V3k5ezg/fzl6QZxyIiIiIiIiIiIiJSRB3HIiIiIiIiIiIiIlJEhWMRERERERERERERKaLCsYiIiIiIiIiIiIgUUeFYGoIxxtP7YhPkN25nWC1ld4/X84usV01wzPJsfq+/b3o5v7KLiBs8fszybHbw/nunl/Mre3Px9BuBNAdjTMBam3Y7x2o1Qf6Y9egqmV7OnvULxpjt4NkPZl7PL7LuNMExy7P5vX7M8np+vH3M8nJ2kXXL48csz2YH7x+zvJ4fbx+3vJy9JvSXABhjLjXG3GWMaXc7y2p4Ob8x5m7g48aYFrezrEYT5L8d+Lwx5jVuZ1kpL2cHyOb+U+A3Abz2wczr+cU9Hj9meTY7NMUxy7P5m+CY5fX8nj1meTm7uKsJjllez+/lY5Zns0NTHLO8nt+zxy0vZ68lFY4z/gn4G+B9xpjLjDEBtwOtkJfz/2/gjLV2xu0gq+T1/J8AXgLOuB1kFbycHeDjwGPAW40xHzXGtIGnLo3xen5xj5ePWV7ODt4/Znk5v9ePWV7P7+Vjlpezi7u8fszyen4vH7O8nB28f8zyen4vH7e8nL1m/G4HcFP2P34bcAJoBX4ReCfwX40xnwFOWGuTxpiQtTbuXtLSmiD/fwRmgfsK7gsALwOmgOPAeCNmh6bI/x4gAPyutfZI9r79wKuBC8Ak8AVr7Wn3Upbm5ewAxpj/RObE3TuAXwN+AXgQ+CsvXJLk9fziDi8fs7ycPacJjlmezd8Exyyv5/fsMcvL2cU9Xj9meT0/eP6Y5dns0BTHLK/n9+xxy8vZa85au+5vwB3APwNXAL8PJICHgDcC7cC3gbvcztlM+bO5LgC/WHDfa4FvAXEgDTwJ/EugNfu4cTt3s+TP5vkg8FdAJPvzL5P5gHYOOAU8A3wBeGWj5fd49g4yH8beVXDfXwJzwLsaKWsz5tfN/ZsXj1lez+71Y1YT5PfsMcvr+b18zPJydt0a4+bVY5bX83v5mOXl7AV5PXvM8np+Lx+3vJy9Ln8/bgdohBuZMzpfAP40+/MB4MvZN8bHgGngGrdzNlN+4M+y+XJveMHsm+E/AO8GbgM+nd3mQ27nbbb82cy/DbyQ/fdI9k3xA0AfmTNtvwI8CnwHCLqdt4my/w3wCJkOCpO9byvwJeA54IDbGZs5v27u37x4zPJ6dq8fs5ogv2ePWV7P7+Vjlpez69YYN68es7ye38vHLC9nL/gzePaY5fX8Xj5ueTl7Xf5+3A7QKDfgeuAQcGfBfT9L5szmHPBfgT2A3+2szZCfzJnLJ4HzwO+SOav2Q2Djgu3+LZmznte7nbmZ8mez7QdOAm8GdmYPPkMLttmZ3Yf+pdt5myE7mTOZfwm8rMRju4CngReBK93O2oz5dWucm9eOWV7P7vVjVhPk9+Qxy+v5vXzM8nJ23Rrr5sVjltfze/mY5eXsBdk8eczyen4vH7e8nL1uf0duB2ikG/Ah4DMFP/9/ZC4F+C/ZN8ajZC/JaMSb1/KTOYP2O9kDU5rMHJnc2Z1A9p8HyMzxeaPbeZstfzbf/wOMA58ExoCbsve3ZP/pAF8DPux21mbJDvSw4FKXgv1mP5kPa18GhnN/DrczN1N+3Rrn5rVjlteze/2Y1QT5PXnM8np+Lx+zvJxdt8a6efGY5fX8Xj5meTl7wZ/Bk8csr+f38nHLy9nrcXMQjDH+7BD+vwZuMcb8vDHmSuCXgA9Ya98HXAL8lrV2yhjTUH9vXs1vrZ211n4I2Av8R+CYzf5faK1NZDebI7OaaNidlOV5OX/BqqAfJ7Nq7gEyl2W80xgTsBdX0O0GBshcCtYQq4l6OTuAtfastdYW5inYbw6S+RB8M/AHxhjHWpt2KWpJXs8v7vPqMQu8nd3Lxyzwbn6vH7O8nt/LxywvZ5fG4OVjFng7v1ePWeDt7F4/Znk9v5ePW17OXg+5Cvq6ZIxptdZOLbjvF4F7gM1kLhF4q7V2csE2xjbAX5yX85fJbrL/s/ptZqXcCPAbwL8GNlhrU42QHZorvzGmDfh54OfILD4xCnwUSAK3k/nQsDn7Z3I9v5ezQ+l9p8Q2ryczP+xPrLX/si7BKuT1/OKeJjxmeSJ7NkfTHLMK7vNE/mY6Znk9/xLbNOQxy8vZxV1Neszyen7PHbMK7vNEdmiuY5bX8y+xTUMet7ycvS5sA7Q91/MGXAP8AZkB158H3gt0Fjw+BDxB5rKMW93O20z5y2TvWmL7XyOzcuivZH92dXZVE+b/daCn4PGtwG8CfwscBw4D/xO42e38Xs6+xL7TWWK73Mm8KJmZYm8rvF/5dfParQmPWZ7IvkR+Lx+zPJO/CY9ZXs/vmWOWl7Pr5u6tSY9ZXs/v1WOWZ7KXye/1Y5bX83vmuOXl7PW+rauOY2NMH/BtYAo4CFxO5iD0e9baP16w7TXA4/bi5QCu83L+lWTPbn8j8C+BMWvtu+sYtaT1lN8Y0wLEyZxBPlHvrAt5OTusfN9pNF7PL+5ZL8esRssO6+uYld2+YfKvp2OW1/M3Gi9nF3etp2OW1/Nnt/fkMSu7fcNkh/V1zPJ6/kbj5eyucLtyXc8bmbbyLwJbsj87ZObHzAGXZ+8LLHhOwwy99nL+CrObgu0NsA/oyP7sU/6a5/cveI6X9p2GzL6afSf7c9Dt3M2SXzf3buvgmNWQ2VeQ3+vHrIbMv06OWV7P35DHLC9n183d2zo5Znk9v5ePWQ2ZfQX5vX7M8nr+hjxueTm7G7eGGSBfa8aY7WTOIvyptfZwdg5MGvggmcHur8tumsxubwBsgwy99nL+FWTPbe+zGY9baycArLWpOscuzLNe8qey23tx32m47LCqfSeXf77eWUvxen5xzzo5ZjVcdlhXx6zc9g2Tfx0ds7yeP7d9wxyzvJxd3LWOjllez5/b3ovHrNz2DZM9m2e9HLO8nj+3fcMct7yc3S3rpnBMZpB+D5CAohUSTwOfAl5jjAnl7gdeZYz5L6ZxVmf1cv6VZr/LGPP7DZId1l9+L+87jZQdlF/WLy/vO17ODuvvmNVI+dfbvqP81ePl7OIur+876y2/l49ZjZQd1t++o/zV4+XsrlhPf/CHgY8AX8/dUfAf/otkVqq8IXt/P/DfyVx60RBndPB2/tVkd6y16dzZHZetx/xe3ncaJTsov6xfXt53vJwd1ucxq1Hyr8d9R/mrw8vZxV1e33fWY34vH7MaJTusz31H+avDy9ndYRtgXka9biyYjVR4P/Ak8OHsz+8nM/A993hDrJbo5fxezq78yq783s2vm3s3L+87Xs6u/Mqu/N7M7+Xsurl78/q+o/zKrvzKr+yNfVtPHcdYaxNL3P9p4G5jzC7gXwD/CsAY47fZPcRtXs7v5eyg/G7ycnZQflm/vLzveDk7KL+bvJwdlN9NXs4u7vL6vqP87vFydlB+t3k5v5ezu8Gs0z/3IsaYm4DPAyeApLX2cpcjrYiX83s5Oyi/m7ycHZRf1i8v7ztezg7K7yYvZwfld5OXs4u7vL7vKL97vJwdlN9tXs7v5ey14nc7QAN5FJgGLgEOALmVQ11bKXSFvJzfy9lB+d3k5eyg/LJ+eXnf8XJ2UH43eTk7KL+bvJxd3OX1fUf53ePl7KD8bvNyfi9nrwkVjrOstdPGmF8CLrHWPmqMcby0Y3g5v5ezg/K7ycvZQfll/fLyvuPl7KD8bvJydlB+N3k5u7jL6/uO8rvHy9lB+d3m5fxezl4rGlVRwGRWUrTWWpvdOTy1aqKX83s5Oyi/m7ycHZRf1i8v7ztezg7K7yYvZwfld5OXs4u7vL7vKL97vJwdlN9tXs7v5ey1oMKxiIiIiIiIiIiIiBRx3A4gIiIiIiIiIiIiIo1FhWMRERERERERERERKdLUhWNjTEeZ+032nw29OKCX83s5Oyi/m7ycHZRf1i8v7ztezg7K7yYvZwfld5OXs4u7vL7vKL97vJwdlN9tXs7v5eyNoGkLx8aY64H/UfBzbocw2QHXO4F/bYzZkL2/of4uvJzfy9lB+d3k5eyg/LJ+eXnf8XJ2UH43eTk7KL+bvJxd3OX1fUf53ePl7KD8bvNyfi9nbxTN/BeyC3iHMeZ9kFkOsfCfwJuB3wPen72/0VZJ9HJ+L2cH5XeTl7OD8sv65eV9x8vZQfnd5OXsoPxu8nJ2cZfX9x3ld4+Xs4Pyu83L+b2cvTFYa5v2Bvwm8ALw1uzPzoLHXwf8BPh1wO923mbK7+Xsyq/syu/d/Lq5d/PyvuPl7Mqv7Mrvzfxezq6buzev7zvKr+zKr/zK7q1bU87xMMb4rLUp4P8AtwEfNsY8aa19bMGmnwc2A2FrbbLeOcvxcn4vZwfld5OXs4Pyy/rl5X3Hy9lB+d3k5eyg/G7ycnZxl9f3HeV3j5ezg/K7zcv5vZy9kRhr7fJbeVh2fsnXgAjwS9bax40x/sKdwRjTYq2dyc04cS1sCV7O7+XsoPxu8nJ2UH5Zv7y873g5Oyi/m7ycHZTfTV7OLu7y+r6j/O7xcnZQfrd5Ob+Xs7utKWYcm+zwamPMoDHmLcaYu4wxEWNMf/Y/9m8B3cB7AHI7Ru551tqZ7D9d2TG8nN/L2ZVf+47yeze/uMfL+46Xsyu/9h3l92Z+L2cXd3l931F+ve8ov/Ire3NoilEV9uLw6v8A/CwwBrQBB01mwcTPAk8Cv2yMmQN+11o7DTTEzuDl/F7ODsrvJi9nB+WX9cvL+46Xs4Pyu8nL2UH53eTl7OIur+87yu8eL2cH5Xebl/N7OXsja7pRFcaYfWQK4ruAK4B24HbgGHBZ9ue3W2v/1q2MS/Fyfi9nB+V3k5ezg/LL+uXlfcfL2UH53eTl7KD8bvJydnGX1/cd5XePl7OD8rvNy/m9nL3h2AZYoa8eN2A7mZb0jwCTwO1uZ1ov+b2cXfmVXfm9m183925e3ne8nF35lV35vZnfy9l1c/fm9X1H+ZVd+ZVf2Rv/5umOY2OMY61NG2M6gP3AIDBmrf2n7OMGCFhr5wue0w18Gfhna+37XIid5+X8Xs6ezaL8LvFy9mwW5Zd1ycv7jpezZ7Mov0u8nD2bRfld4uXs4i6v7zvKr/ed1VJ+5V8tL2f3BDer1mu5AU72n+3A58nMLvkeMA58CbiuYFt/bvvsz58Dvq386y+78mvfUX7v5tdN+856y6782neU35v5vZxdN3dvXt93lF/vO8qv/MrefDcH7/tjoB+4Dvh9MoOvtwFfNcZ83BjTY61N2uyQbGNMDxDMbtsIvJzfy9lB+d3k5eyg/LJ+eXnf8XJ2UH43eTk7KL+bvJxd3OX1fUf53ePl7KD8bvNyfi9nb2xuV65Xc+Pion57gVPAK7I/fwv4DHA98I9AGjgD/OcFz9+p/Osvu/Jr31F+7+bXTfvOesuu/Np3lN+b+b2cXTd3b17fd5Rf7zvKr/zK3pw3Px5ks/+FgRuAHwLfN8a8ErgSuNVae9AY81bg+2SGXbcseP6z9cy7kJfzezl79vcrv0u8nD37+5Vf1iUv7ztezp79/crvEi9nz/5+5XeJl7OLu7y+7yi/3ndWS/mVf7W8nN1LPFU4Nsa0Wmunsv/uAA8BKWvttDHmFcAPgBcKnnIa+OvsLT8wu86x87yc38vZs79f+bXvrIryu5tf3OPlfcfL2bO/X/m176yK8mvfEe/x+r6j/HrfWS3lV/7V8nJ2L/LMjGNjzOuADxtjbjHGBKy1aWvtj8gMs4ZM2/klQHf25xagF5i11iYAXP6f8nV4NL+Xs4Pyg/ad1VJ+d/OLe7y873g5Oyg/aN9ZLeXXviPe4/V9R/n1vrNayq/8q+Xl7F6VmwfS0LJnEKaBMPBV4OvAF6y1jxdscxfwWTLt6T8Grga2WGuH65+4mJfzezk7KH/9E1/k5eyg/PVPLI3Cy/uOl7OD8tc/8UVezg7KX//EF3k5u7jL6/uO8rvHy9lB+eufuJiX83s5u6fZBhi0vNQNMGTOEHwBSAGHgXNkdpB3AgMF215FZnbJaeBvgduy9/uVf31lV37tO8rv3fy6uXfz8r7j5ezKr31H+b2Z38vZdXP35vV9R/n1vqP8yq/s6+fmiY5jAGNMN/BBMmcXHgB+C9gH3E9mtcTvWGsnstsOW2uPuhS1JC/n93J2UH43eTk7KL+sX17ed7ycHZTfTV7ODsrvJi9nF3d5fd9Rfvd4OTsov9u8nN/L2T3L7cp1JTcujtR4JXAC+HD2518EXiJzpuEPgOsBn9t5mym/l7Mrv7Irv3fz6+bezcv7jpezK7+yK78383s5u27u3ry+7yi/siu/8iv7+ri5HmAVO8qVwGPA+7M/twN/DEyQmWHyu0Cf2zmbMb+Xsyu/siu/d/Pr5t7Ny/uOl7Mrv7Irvzfzezm7bu7evL7vKL+yK7/yK3vz3lwPsMyOsJPMHJOOBff/HHAK+KWC+y4lM9vkFBBxO7vX83s5u/Iru/J7N79u7t28vO94ObvyK7vyezO/l7Pr5u7N6/uO8iu78iu/sq+vm+sBltgxfgNIk1kp8T7gL4F7gGuzO8zPAePAzwPBgueNZP/palu6l/N7Obvya99Rfu/m1037znrLrvzad5Tfm/m9nF03d29e33eUX+87yq/8yr7+bn4akDHGD9yb/fEq4FEyqyf+OZmZJZuBJ8ispPizwD8bY05ba1PW2kMA1tpUvXPneDm/l7OD8oP2ndVSfnfzi3u8vO94OTsoP2jfWS3l174j3uP1fUf59b6zWsqv/Kvl5ezNJDdYuqEYY3zAK4A7yAy9jpE5y/CPwC5gmMzO0wocA363kXYGL+f3cnZQfjd5OTsov6xfXt53vJwdlN9NXs4Oyu8mL2cXd3l931F+93g5Oyi/27yc38vZm4qb7c7L3YAe4M3A3wHTwJeA/QWPtwMt2X933M7bTPm9nF35lV35vZtfN/duXt53vJxd+ZVd+b2Z38vZdXP35vV9R/mVXfmVX9nX160hO44XMsZsBe4m03q+B/gc8G+staezj/uttUkXIy7Jy/m9nB2U301ezg7KL+uXl/cdL2cH5XeTl7OD8rvJy9nFXV7fd5TfPV7ODsrvNi/n93J2L/NE4TjHGHMl8DrgbUAb8GFr7R+6GmoFvJzfy9lB+d3k5eyg/LJ+eXnf8XJ2UH43eTk7KL+bvJxd3OX1fUf53ePl7KD8bvNyfi9n9yJPFY4BjDER4EbgjcDPAI8BL7Me+YN4Ob+Xs4Pyu8nL2UH5Zf3y8r7j5eyg/G7ycnZQfjd5Obu4y+v7jvK7x8vZQfnd5uX8Xs7uNZ4rHOcYY3qB1wLHrLVfNsY41tq027kq5eX8Xs4Oyu8mL2cH5Zf1y8v7jpezg/K7ycvZQfnd5OXs4i6v7zvK7x4vZwfld5uX83s5u1d4tnAsIiIiIiIiIiIiIrXhuB1ARERERERERERERBqLCsciIiIiIiIiIiIiUkSFYxEREREREREREREposKxiIiIiIiIiIiIiBRR4VhEREREREREREREiqhwLCIiIiIiIiIiIiJFVDgWERERERERERERkSIqHIuIiIiIiIiIiIhIERWORURERERERERERKSICsciIiIiIiIiIiIiUkSFYxEREREREREREREposKxiIhIAzLGvMkY83ljzHFjzLQx5hFjzFsLHt9ijLFlbs8UbHdrmW0+5M6fTERERERERLzA73YAERERKem3gBeB3wTOAq8CPmWM6bHWfhQ4CVy/4DkR4MvAF0u83tuBFwp+Pl71xCIiIiIiItI0jLXW7QwiIiKyQLZAfHbBfZ8CrrfWbi3znDcBnwGus9Y+kL3vVuAbwKXW2sdrGlpERERERESahkZViIiINKCFReOsR4HBJZ72VuCFXNFYREREREREZLVUOBYREfGO64FnSz1gjGkD7gY+Xea5XzfGpIwxh40x/8EY46tVSBEREREREfE+z8447unpsVu2bHE7hoiIrCOPPPLIWWttrxu/2xhzB/A64BfKbPI6IMziwvEk8CHgO8A88BrgA0Av8C+W+H3vBt4NEI1GD+zevXv14UVERFbIzWOuW/QdV0RE3LDUMdezM46vuuoq+/DDD7sdQ0RE1hFjzCPW2qtc+L1bgAeA71trX19mmy8CQ9bafRW83h+QWXxvoMxIjCI65oqISL25dcx1k463IiLihqWOuRpVISIi0sCMMV3AF4EjwNvLbNMN3An8nwpf9m/IXHV0WTUyioiIiIiISPNR4VhERKRBGWNagC8AQeA11tqZMpu+kUwhuNx844Xsgn+KiIiIiIiIFPHsjGMREZFmZozxA58FdgA3WGvPLLH5W4EHrbWHKnz5NwJJ4MdrSykiIiIiIiLNSoVjERGRxvTHwKvILGDXnR1HkfOotTYOYIwZBG4CfrvUixhj/gQYBR4iszjeq4D3Av/dWnuudvFFRERERETEy1Q4FhERaUyvyP7zf5R4bCtwOPvvP53952fKvM5TwLuA3yQz8uJ5MkXmUq8rIiIiIiIiAqhwLCIi0pCstVsq3O6/A/99icc/AnykKqFERERERERk3dDieCIiIiIiIiIiIiJSRIVjERERERERERERESmiwrGIiIiIiIiIiIiIFFHhWEREmtbzZ6b43b9/nKPnZtyOIiIiDehTDxzl+MSs2zFEREREGpIKxyIi0rSOnJvhr354hPGZebejiIhIg5mYmed9n/sJn37wqNtRRERERCqWSqfq9rtUOBYRkaYVT6YBCAd8LicREZFGMzoVB+D4uDqORURExDsuJC7U7XetuHBsjPmmMcaWuV2f3cYYY95njDlmjJk1xnzbGHNFidfaY4z5mjFmxhhzwhjzQWOMvt2LiEhVzCUyZ2LDAZ0nFRGRYqPTmcLxSxpVISIi/z977x0mW1af575rV46d+5w+ecKZcyYPaEACJCEEiGCCrCuEgq8sJyxb2LIl2wpXXAGyrpDvRcHCFubasmT5IgQIjAAhYMgwhBkmnzAn5w7VoXLVjuv+sWtXV1VXd1d1V+71Pk8/5/SuVbt2d1fttda3vvX9FIohomj2LorRv4Pn/HMg2XDs3cALgMcq3/8q8A7g3wJngV8CHhFC3CelXAAQQkwAjwCngTcDdwDvxRWzf2MH16VQKBQKRR1lUzmOFQqFQtEc5ThWKBQKhUIxjAy0cCylPF37vRAiCDwM/KWU0hJChHGF49+RUr6v0uabwBXg7ayLwj8PRIAfk1Jmgc8LIZLAO4UQ/6FyTKFQKBSKHeM5jkN+5ThWKBQKRT3zGXeb50K2jGU7+H2qr1AoFAqFYqekCikWC4vYjo3lWMzGZjk8drjflzWS9FI47sTo6LXABPAXle9fiutI/rDXQEpZAD4JvK7mea8DPtsgEH8IV0x+eQeuS6FQKBR7HJVxrFAoFIrNuLC8CIDtSBay5T5fjUKhUCgUw82V9BW+fu3rfPPGN3ns1mM8tfBUvy9pZCkYA5xx3ISfBG4AX6t8fxKwgfMN7c5UHqOm3dnaBlLKa0CxoZ1CoVAoFDtCOY4VCoVCsRlXV9eq/1dxFQqFQqFQdJaF/AKWY/X7MkaSoXEcCyGiwJuAD0spZeXwBJCXUtoNzdeAaCXawmuXbnLatcpjzV7vbUKIx4UQj6dSqd1cukKhUCj2AGXLJuTXEEL0+1IUCoVCMUCky2mW8wahgLsz5aYqkKdQKBQKRUexpc18br7flzGSDI1wDLwRiLEeU9FVpJQfkFI+LKV8eGZmphcvqVAoFIohRjcd5TYeUmxH8uln5nEcuX1jhUKhaJNzK+co6D7mJgwAbijH8cgihLhTCPFfhBDPCCFsIcSXm7QRQohfF0JcF0KUhBBfFUI81KTdPUKILwghikKIW0KIdwshfDs5l0KhUOwFrmev9/sSRpKCOTxRFT8JXJBSPl5zbA2IN3aguC7iopTSqGk31uScE5XHFAqFQqHYFbplq3zjIeWLZ5f4hQ8+wWNXVvt9KQqFYgQ5v3KeQtlHMmoRDzsqqmK0uRd4PfA8cG6TNr8KvAP4XVxzVB54RAix32sghJgAHgEk8Gbg3cAvA+9q91wKhUKxV7iRvdHvSxg5pJSUzN6NW3YsHAshxnAL3DW6jc8CPuDOhuONmcZnacgyFkIcBqIN7RQKhUKh2BFl01HC8ZBydt6tnasKVikUik5zK3eLjJ6jWNaIh22SUYsb6d5t+VT0nE9KKQ9LKd8CnGp8UAgRxhV7f0dK+T4p5SPAW3AF4rfXNP153ELuPyal/LyU8v24ovEvCSGSbZ5LoVAo9gSrpdWexirsBYpmEUnvdmXuxnH8d4EQG4XjR4EsbgcJVLOQ3wh8pqbdZ4DXCCESNcfeCpSAr+ziuhQKhUKhANzieCqqYjg5t5QHYDlvbNNSoVAo2uPcyjlKuoZEEAs7JKMW11d7t+VT0VuklM42TV4KJIEP1zynAHwS1yjl8Trgs1LKbM2xD+GKyS9v81wKhUKxZ1Cu487SayF+N7PpnwSellKeqT0opSwD7wF+XQjxC0KIVwIfqbzWH9U0fT+gAx8TQrxKCPE24J3A7zV0xgqFQqFQ7AjdUo7jYeXcQg6AVE7v85UoFIpRwnIsLq5epFB2+4ZY2GYsajGf0VWm+t7lJGAD5xuOn6F+h2zjDlqklNeAYk27Vs+lUCgUewYlHHeWXgvH/p08SQgxDbwSN7upGe/BFYp/DZgCHgdeLaVc9BpIKdcqovL7cFdg08Dv44rHCoVCoVDsmrJpEw4ox/GwYdoOl5Y9x7ESjhUKRee4mb2J6ZgU9BAAsZBNMmpj2pLlvM5sMtznK1T0gQkgL6W0G46vAVEhRLBSp2cCd87ayFrlsXbOVaVioHobwJEjR3b1gygUCsUgooTjztLLwniwQ+FYSrkMBLZ4XAK/Xfna6jyngR/eyTUoFAqFQrEdZdMmFtpRV6foI1dXCpi26/xTjmOFQtFJVkorADWOY4cx0wLgRrqkhGNFz5FSfgD4AMDDDz+sbO8KhWLkKJpFVoorTEWn+n0pI8EwRVUoFAqFogPYjo3lWP2+jJGkbDoq43gIeX7BdRvvS4aUcNwnfvnDT/Nfv3ap35ehUHSclWKjcGwzFnPNoTfXelehXDFQrAFxIURjttUEUKxxCK8BY02eP1F5rJ1zKRQKxZ5CuY47hxKOFQqFYo+RKqaqE1lFZ9Etm9CQZhwLId4ihPhrIcRNIUReCPFdIcRPNbT5shBCNvkKN7Q7KIT4uBAiJ4RYFkK8r1K4diA5t5hDE/B9t0+pqIo+YFgOf/30Tf700Su4m8gUitFh3XGs4fc5BP2SZNRdvL2ZVsLxHuUs4APubDjemGl8loacYiHEYSBa067VcykUCsWeQgnHnUMJxwqFQrHHmM/Ns1xc7vdljCRl0yHsH07hGPglIA/8a+BNwJeADwoh/kVDuy8BL2n4qqqtQogA8FngKG5h218E3kJlW+wgcm4xx5HJKIcmIqwUDGxVsKqnXFrOY9qSG2slnl/M9ftyFIqOYTs2mXIGgILuIxZyEAJCAUk4YHNlRdXn3qM8CmRx+0YAKourbwQ+U9PuM8BrhBCJmmNvBUrAV9o8l0KhUOwp5vPz2E5j/PvoIKXEtM2evFbBGIKMY4VCoVB0joX8ApFApN+XMZLo1lAXx3tjpaaAxxeFEAdwBeU/qjm+KqX81hbn+XHgbuBOKeVlACGECXxICPEuKWVj5fe+c24xx137EszEQ9iOZK1oMB0P9fuy9gxn59fF4kdOL3Jyf7KPV6NQdI618hoSdyEqX/YRC69PYJMxm6sraqFkFKkIt6+vfHsQSAohfrzy/d9IKYtCiPcA7xBCrOE6g38J12RV29++H/iXwMeEEL8L3I5b2P33pJRZACllucVzKRQKxZ7CciwW8gscTB7s96V0hedXnicWiHF47HDXX0s5jhUKhWKPsZBfUI7jLuFmHA+n47hBNPZ4EjjQ5qleBzzmicYV/hdgAK/d2dV1D92yubJSdIXjhJu4oeIqesuZhSxBn8Z9B5N8/sxSvy9HoegYtbFQxbJWJxyPRS1upsv9uCxF95kFPlL5+j7gnprvZytt3oNb2P3XgE8BSeDVUspF7yRSyjXglbhRFJ8E3gX8PvCbDa+37bkUCoViLzKfn+/3JXQFRzp899Z3WSp0f9wspaRk9TZaSwnHCkWP+P++fZVvX1I5top6Vkur6LbOamkVRzr9vpyRY8gdx814CXCu4diPCCGKla/PCiEeaHh8Q65ipTjPRRqyGgeBS6kCtiM5vi/OdDwIoArk9Ziz8znunI3zuvvmePp6mqWsEtMUo4GXbwye43i93x2L2ixlTZXrPYJIKa9IKcUmX1cqbaSU8rellIeklBEp5Q9IKZ9scq7TUsofrrSZk1K+Q0ppN7Rp6VwKhUKx1xjVuj6nU6fJGTlSxVTXX6tslXuuG4zUbFqhGGTe+7lz/Pm3rvb7MhQDxkJ+AXBXKVdLq32+mtHCdiSmLQkPaXG8RoQQrwR+FHhvzeGv4GYWvwZ4G3AE+JoQ4lhNmwkg3eSUa5XHNnu9twkhHhdCPJ5KdX8Q5HGukql7Yn+CmYQbT6Ecx73l7EKWk3MJXnX3PgC+cFa5jhWjgTdhtR0oGT5ioZqoiqhF2YRMqTf5hAqFQqFQ7DVGcZet5Vg8Mf8EAKlC9+dMBbO3+caghGOFoidIKcmVTSV+KDbgCcfQm45mL1E2XUFgFBzHFSH4g8AnpJR/6h2XUv6mlPK/Sym/JqX8n8ArAAn8q92+ppTyA1LKh6WUD8/MzOz2dC1zfjGPTxPcNh2rCsfKcdw7VgsGi1mdu/cnuWtfnMOTER45rXZXK0YDb4G2qLv9Qrw2qiLm/v/GWm+3fyoUCoVCsVfIGTkM2+j3ZXSUU0unqpnDBbPQ9cJ1vc43BiUcKxQ9QbccTFuynB+tm6Ri98zn1nOeRnEFtp94wvGwZhx7CCEmcSuxXwV+Zqu2UsoF4BvAC2sOrwFjTZpPVB4bKJ5fzHFsKkrI7yMe8hPya0o47iFnF7IAnJxLIITgVXfv4+sXlikaVp+vTKHYHSWzVM0ELJTdfiFaF1XhvsevrmR7f3EjRE5XBQYHkWdupHnPZ86qKBaFQtE3CmWNv/3uBLeyozPnNW2TJxfqk4i6HVehhGOFYkTJlt1tj0r8UNRSMArkjPUJlhKOO4tuuYLAMDuOK5XgPwUEgTdIKVsZKcjKl8dZGrKMhRBB3GrwddnHg8D5xRwn9icAEEIwkwipRbcecnbevSed3J8E4NV370O3HL5+Xt2fFMNNbb6xJxzXOo6TUff/51MqNmqnFIwCuq3GuoPIXz52nfd/5SILKrNeoVD0icuLYZ66HOexq6NTIO+ZxWcoW/X31W7vIlbCsUIxouTKroslUzLRLXub1oq9Qm1MBbiTWuUE6RzrURXD6TgWQvhxK74fB14rpdw2aFYIsR/4fuC7NYc/A7xICHG05tibgBDwt5274t1TNm2urhY5PpuoHptJhNSiWw85u5BlOh6sxoS86LZJEmE/j5xRcRWK4aa2IE9Bd/uFWI1wHAk6BHwOV5TjeMeslQduE4uiwtkFd1HwuZvq/a1QKPpDruT2vbcy6f5eSIcwbIOnF5/ecHyp0N3aIN2OwmiGEo4Vih7gCccAK8o5p6gwn69fbbUcS026OkjZdB3HQxxV8Z+B1wO/BUwJIb6v5iskhHhACPFpIcTPCSFeIYT4+8CXAQf4g5rzfBTXWfwxIcTrhRA/BbwP+KCU8nxPf6JtuLCUR0q4a9+6cDwdD6l8+B5ydmHd8Q0Q8Gm84sQsXzizhO2ohS3F8FLvOHanQLHQelSFEG7O8c20yjjeKarI72DiOJLnq8Jxps9Xo1Ao9iqecLyYG41Io9Op003zmlVUhUKh2BG58nqFbuWcU3g0Oo5BxVV0knLF3R8a3qiKH6n8+4fANxu+5oAVQAC/A3wW+D3gFPBSKeU17yRSShN4LXAd+DCuaPxXwNt68lO0wblFdyB517549ZhyHPcOuyIueDEVHq+6Zx8rBYOnrquFLcXwUitqFso+gn6HgL9+MSQZtVjImI1PVbSIEo4Hk5vpEnndNbEo4VihUPSLfCUmajlfHPpdto50eHbx2aaPla1yV/P++yEc+3v+igrFHqTWcayccwpwg/Rrt816LBeXuWvqrj5c0eihVxzH4SF1HEspj7XQ7PUtnusG8KO7uZ5ecG4xT8AnODYdqx6biYdYLRpYtoPfN7SLAEPBlZUCuuVwssZxDPDyu2bwa4IvnFnie45O9unqFIqdI6VkrbS+8FEo++piKjzGojbP3xzuyWw/UcLxYHJm3o2nuH06xnO39oZw/A/++3d46PAEv/iq4/2+FIVCUSFfcRwXdMjqWcbCzWp3DwfnVs5RMDePjFgqLJEIJTZ9fDcox7FCMaIox7GikYX8ApKNk9Nuh+nvJTzH8TAXx9trnFvMcft0nECNQDydCCElrBZUzE+38bYy3z1X7zgeiwS4bTrGpVTvM9UUik6QLqex5bpQnC9rdTEVHsmoRVEXFHRrw2OK7akV5xWDw9mFHELA333BQRazOku50S+Q99iVNb5xUe3iUygGCS+qomxqQ7/L9umFjdnGtXQzrmIrwbpbqNm0QtEDlONY0UizmAqoz2BU7A59yIvj7UXOLeY4XhNTAa7jGGBJLbp1nbPzWTQBd87GNzy2LxlmcQ+IDYrRpLFvLeqbOI5j7njtYkoJoO2S03OYjor5GESeX8hxZDLKi29zd4ycujXaBfLKpk1et7i8rBY7FYpBwZHrURVlQxvqOe/V9NVt6xJ1q0Be2SrjyI0L391GCccKRQ/IVoTjeMivHMcKYHPh2LANMuW9sY2w26wXx1Nd3TBQ0C1urJU4sa9+W9dMwhWOU2rRreucWchx+0y86WLLbDLEUlb9DRTDSWOEQn6LqAqAi8tKOG4XVdx3cDmzkOXk/gT3HHB3k5wa8Zxjb66Vyul1uz4VCkX/KOoaUgoASobWNLJxWHhy4clt23TLUd2PmApQwrFC0RNyZZN4yM9sMsRyXm23Vmy9fWXYt+4MCrqlHMfDxIWlPADHG4XjiuN4WS26dZ2zFXGhGfuSYZZyZRxH5b8qho/aCaplg25qxMLNoyoArqyMtiOzG6h848GkZNhcWS5wcn+SRNiNHXru5mi/v2t3d15Z7o/IolAo6vHyjUEOteN4Mb+4qQGsFsM2SJfTHX99JRwrFCNMrmyRCPuZjoeU41gBsOUWEyUcdwbPcayE4+HAm+jtHwvXHZ9OBAHlOO42ubLJ9dXShnxjj32JEKYtWSuqxU/F8FE7QS3obp8Qb+I4jlZyj1N5JTa1ixKOB5PzSzkcCXfPuYuC9x5IjnyBvNq51qXlfB+vRKFQeHj5xuMxi5KhkTfy6Nbwje2fWniq5bbdiKsoGP2J4FHCsULRA3Jlk0TYz0wipDKOFVxK5VlK+zd9vJth+nuJciXjWEVVDAfporuddDwSqDseDfqJh/ws55Rg2U3OLbqF8RqjQjz2JV1Bf1HFVSiGDMM2yBvr4lGhkrEYDW0Ujn0aBHwOa0WV590uSjgeTM7Ou/f2k/vdRcH7Do5xY61EeoQXAWt3d6qcY4ViMPAcxzNjJmXDnZsNm+vYciyuZq623L4bRe+V41ihGGFcx3GAGeU4VgDv+MRzfOxb45s+rhzHnUE5joeLdKkiHEcDGx6bjgeV47jLnPHEhbnmwvGsJxyrAnmKIaNxq2ih7E5/4k2iKgBCAYdMSeWitoOUsitbchW758xClkjAx5HJKAD3HRgDRrtAnmfSmU2EuKKEY4ViIMiVfAgkUwmLsqEhJUOXczyfm2+rMF03HMdKOFYoRhgvqmImESKnW1UnpGJvcn4xz3LWj26Kpo+XrTJrJVVkZrfolk3AJ/BpzX/PisEiUzIRAhLhjcLxTCJESgmWXeXsQpZEyM/B8UjTx/cl3azppaz6OyiGi8ZJnuc4blYcDyAUkGRVQa22yOpZLMfq92UomnB2PseJ/Qm0yljo3kqBvGdHuEDecl5nLBLgxP6EchwrFANCrlKUNhqykQh0Uwyd4/hW7lZb7VdKK20Jza1QMFVUhUIxsrhRFYFqkSflOt675HWLpZwOCJbSGwUyjxvZG727qBGlbDqE/cptPCxkigaJkL+p0D8dV4VFu83Z+Rwn5xII0XyhZSbh9l8qqkIx7GwVVQEQDjgUdLXA3w5rZbXYPYhIKTcUPZ2IBTk4HuG5ERaOUzmd6XiQ26ZjXFouIKUq6qpQ9Jt8yUciYhMJukJq2dCGznF8M3ezrfaWY3Ez295ztkM5jhWKEaZaHK9S5EnlHO9darfMLaSDm7ZTwvHuKVs2oYDq5oaFdMlkPNr8M+E6jtV9s5tcTOW5cza+6eMhv4/JWJBF5ThWDDkFXSMcsNlsXTEUcCgbom+Ts2FE5RsPJqmczlrRrBOOAe47mBz5qIrpeIjbpmPkyhYrBbXwrFD0m3zJRzxiE/aEY1NjtbQ6NAs7hm3sKLP4/Or5jl6HEo4VihGmGlURdzMilQCyd7lUEY6FkCysbS4c38rd6vjWlr1G2bQJKcfx0JAumk3zjQFm4iEyJRPdUi7AbpAtm6wVTY5OxbZsN5sIKcexYugplH3ENsk3BggFHcqmRlYfXWGt04yKcCyE+FEhxDNCCF0IcVkI8UtN2gghxK8LIa4LIUpCiK8KIR5q0u4eIcQXhBBFIcQtIcS7hRA9HZScWfCy65N1x+87MMbl5QK5EY1kWc4bzCRc4RhUgTyFYhDIVRzHnnBcMjRsaQ9NPv58bh5J+yL3pbVLHY1yUsKxQjGilE0bw3ZIhgM1jmO18r1XuZTKIwQcmzW2FI5Nx2Qxv9jDKxs9dMshHNAoGGrCMAxkSiZjkebC8XQlJmFF3Tu7wrUVdxB6bCq6Zbt9yTBLKmtaMeQUKjmLmxEOSHRTI6fnenhVw80oCMdCiJcBHwO+A7wR+BPgd4UQ/6qh6a8C7wB+t9IuDzwihNhfc64J4BFAAm8G3g38MvCu7v4U9Zyddxc/NjqO3QJ5p0fUdbyccx3Ht0+7u2gup9Q4UKHoJ6YtKJs+4uH6qApgaHKO242p8LAci8trlztyDbql962egBKOFYoukyu7H+5E2M9UTGUc73UuLxc4MBbh0JTBSs6PYW1euE3FVewO3bQJB3wsF5f7fSmKFthKOFb58N3lyoo7qT4yubXjeF8ypKIqFENPQde2FI5DAccVjg0lHLeCI52hcYxtw/8JfENK+Y+llJ+TUv4W8B+B/1MIEQQQQoRxhePfkVK+T0r5CPAWXIH47TXn+nkgAvyYlPLzUsr344rGvySEqLf/dpGzCznmxsIbYqA84fi5ERSOy6ZNTreYSYQ4OBEh4BPV3X4KhaK36JbOUmGJfMmVHRsdx9A/B2277Car+NzKuY5cQ97Id+Q8O2HPC8em7WDZaju4ont428ASYT9Bv8Z4NKAyjvcwl5cL3D4TY27SBASLqkBe1yibDkG/NioT2pEnXTQ2j6qoOI7VvbM7XK04jo+24DhO5XRsZzjy6IaVpVyZTzzV2WIqinUKZR+x0BZRFQEH2xGsFEZPVOsGmXJmVKK1HgI+33Dsc8AE8JLK9y8FksCHvQZSygLwSeB1Nc97HfBZKWXtm+hDuGLyyzt61VtwZj67wW0Mbp+6Lxni1AgWyPMWmKfjQXya4OhUjMvL/RNbFP1nKVvm+upwiJOjQsEs8O0b3+ZDpz7Ely5/iWzRlR3jEZtwoN5xbNiDv5uwbJV35Yy+kb3REYG8nwvae1o4zusWP/7Hj/LHX77Y70tRjDBVx3HIFURm4qrI015FSsnlVIHbp2PMTbgLClvFVaSKqaHoTAeVsmnj0+xRmdCONI4jyZRMxiPNPw9eVIW6d3aHqysFpuMhYiH/lu1mk2EcCStKwO8q//ObV/nFDz1FXu/PdsRRpqhrGJZGMrr57zZUmdQu5ZTjuBXWymv9voROEQYaB13e93dX/j0J2EBjtaMzlceoaXe2toGU8hpQbGjXNQzL4WIqvyHf2OO+A2M8d2v0hGNvgdlbcD42FePKshIN9zLv+uRpfv5/frffl7FneHLhST783Id5dulZTNskZ+S4suL2E4mIW5g24HMoGW7k+zDMdW/lbu3q+RLJhdULu76OfkZo7WnhOB7yc3Qqxh9+4TzP3Ej3+3IUI0ptVAXAdDykXHN7lFReJ6db3DYdIxFxiIXtLYVjRzq77qj2MrrlIDQlvAwDecPCkWzqOJ6Ou58TJRx3h6srxW3zjQH2VSbiqkBed/G2VWdLo1m4qp94u3xmxzf/3YYDrqM+VVDb21thFPKNK1wAXtRw7MWVfycr/04AeSllY9bJGhD1Ii0q7dJNXmOt8lgdQoi3CSEeF0I8nkqldnLtG7i0nMe0ZVPHMcDJuQQXlvIjt4PEqyMzXYm4un0mxuWVAs6I/ZyK1lnKlbmYyiPl3ngPFHSrr+/35eIydsMt8tKq20/EI+7xSNCpOo5Ne/DHOruJqfDoRFyFchz3kd96833MJEL8q798ipKhqrUrOs96VEXFcZwIkVLC8Z7EK85x24xbrGP/uMFienPhGFRcxW4omzYw+IMRBWSK7t8puUnGccjvYyyiYn66xdWVIkdaEY6TYQCVc9xlvMxpb+FZ0Tm8PnffFsKx5zheK5b2jNCwG0ZIOH4/8KNCiH8ihJgQQrwG+KXKY13duiSl/ICU8mEp5cMzMzMdOefZeVdgOLm/ueN4NuHuIFktDL7brx3Woypc4fi26RiG5XArU+rnZSn6SKZkUjadPTH/zusW3/d/fYG/fnqwjEeZosDvswn53T41HHSqGcfD4DjeaWG8WpaLy6yVdrdDRzmO+8hYNMD/85YHuZQq8J7PnOn35ShGkKaOY+Wa25NcrrjIbp92C1DtnzBYyaoCed2ibNk4qM/aMJCuCMfjmwjH4LqO98Kgv9eUTZuFbJljU1sXxoMa4TinhONu4UUaAWTLauGr0yymAySjVrWqezM84bhkCAqmch1vRdkqj9LOqD8B/rjytQp8DPitymMLlX/XgLgQwtfw3AmgKKU0atqNNXmNicpjXWchWybk17h9pvm93RNWR21B1vt5pio7lW6rjLkvqwJ5e5ZsyZ2L74Wc40upPDnd4mJqsHK9HSuJ319AVKa84VrHsTPYY52CUehYvZzduo5Vcbw+87I7p/mHL7uNP/vmVb5yrjPbgxQKD2/il6xxHBcMm4LKLtxzXF4uEPRrHBiPAK5wLBEsbVEgL11O97WTGGZ008GWSuAaBjKVLfmNld9rmUmEWM4Nvith2Li22lphPHDFeyFUVEU3SeV1CpUdcDklHHecpXSQfeNb30e8iu+6Kfrq7hkGHr3+KGVrNPpZKaUtpXw7MAM8AOwDvlV52Pv3LOAD7mx4emOm8VkasoyFEIeBaEO7rvHzL7+DZ975IwR8zaf7XgTUKArHY5EAIb+r7d+uhOM9jzfGvLYHhOMrlWLHg7aTwLET2GKlWiAuEnQom8PhOO6E29jj/GpjPH57qKiKAeDfvfYEx2fj/NuPPM3agH3QFMON5ziOVxzHXrGGURuoKbbn0nKBY1NRfJq73Lq/hQJ5oFzHO6VkWvh8qjDeMJAuuf3uZhnHADOJsHIcd4GrlUnGkcnthWO/T2M6HmJJRVV0jdoiTiqqorMYlmAl52d2bGtBPlTJONZNra+TtEHneuZ6RzIbBw0p5ZqU8lkpZR7458CjUkpP7H0UyAJv8doLIaLAG4HP1JzmM8BrhBC1AcNvBUrAV7p5/bV44mkzRnU+spzXq6I4uD9nLOjjUkoJx3sRw3Iome5i7LWV0Y8ruVJZIBk44dhKoPlznE6dBhocxwOecdzJXTV5I8/ltcs7eq7lWBsWav/6O3He98XdidGt0rZwLITwCyF+VQhxXgihCyFuCCF+v6GNEEL8uhDiuhCiJIT4qhDioSbnukcI8QUhRFEIcUsI8e4mW396Qjjg4w9+8iFWCwbv/+rFflyCYkTJlS1iQV9VLBzVFX7F9lxK5atb5gDiYdstkKdyjrtC2XQI+IY3n1II8RYhxF8LIW4KIfJCiO8KIX6q5vGkEOJdQojvCCEyQogFIcTHhRB3NZznmBBCNvn6UO9/quZ4URVj20VVqJifjnO1kqfbSlQFwL5kSGUcd5ErNa44VRyvs6QyAUCwb2LrCbUXVVE2NbJ6tgdXNnyYtslXrvZM/+wJQojvE0L8GyHEq4QQPyaE+Ajw48A/89pIKcvAe4BfF0L8ghDilcBHcOfUf1RzuvcDOvCxyvneBrwT+D0p5UC8qaY94XjEdvKkcno1hgNACMFtMzHlON6j1EY+7Q3HcX+F41RO5/PfPYpjrY8ppXQdx5ovy9nls9iOTTjgZhxLOfiO462EY0c6LOQXNn28GY/fenxH19FsB9TFhUDPFsV24jj+U+BfAv8P8CPAr+Kuntbyq8A7gN/FXYHNA48IIfZ7DYQQE8AjgATeDLwb+GXgXTu4po5w74ExHjw8znev9CR6SrFHyJXNamE8WF/hVwLI3sKyHa6tFrltOl49JoRbIG87x3EnKrnuNRxHYtoSnza8wjFuUZ488K+BNwFfAj4ohPgXlcePAP8E+Czu5PafAnPAtytbYhv5N8BLar5+o6tX3wbeNsKthOOZRIi8bqlCth3m6kqRRNi/pdu7ln2JsIqq6CKXVwrVheaschx3FK8wXii0xOnU6U2L1AR8EiGk6zhWURVN+fbNb49ijJaJ6wr+X7jz3SjwMinlMw3t3gP8NvBrwKeAJPBqKeWi10BKuQa8EjfW4pO489vfB36zqz9BGyRCfoJ+beR28iznjepcy+O26XhVUOsGlu3w9g8+wf/71Us4zlCPO0eO2gXYvZBx7C0+rxX7I8Z+8ewilxfGKecfrB6TTgRkAM2fo2yVubR2iUjQwXYEli0GOuO4bJW3XEBezC/yyKVHqm2evhzjK881i7dfZ6W0wpX0lbavpdkOqKIumIhtrSN0Cn87jYUQr8XtUB+UUp7epE0YVzj+HSnl+yrHvglcAd7O+kT154EI8GOVldfPCyGSwDuFEP+hX6uxDx4a54PfuYplO/g3yYRSKNohV7aqhfEAZiqr4Kn8YK+uKTrLzXQJ05YbipTsnzC4tBDGsATBSqXZTNGHT0jikUqBHquE7dj4tL5syBhKDNv93Q2z4xh4o5Ryueb7LwohDuAKyn8EXAbukFJWF2+FEF8DrgH/kI0Lsc9LKb/FAJIpmYQDGuHAFttqawr5HG4hVkHRGldXixybiiHE5kU6a5lNhnn6Rrq7F7WHuZwqcHQqyo3Vkoqq6DCL6QDhoM2qcYnvzruOn2ggyvGp47zowIuq7YSAcMBxM45VVMUGFvOLnFo61e/L6DhSyu8CL2qhncQVjn97m3angR/uzNV1HiEEMyNYsHu5wXEMcNtUlE8/cwvDcgj6Oz+/v5gq8Kln5vnUM/N86fkl3vsTDzI3Fun46yjaxzMmTMaCe8Rx7GUc90eMffZmBgCjcA/R8UcBtzAegOZz5b2V0kq1lkDJ0AgFBlcTSRW2rn92LXONslXmkUuP8Ma73sjpa1GWMgFefl9my+c9futxjo0fa+taGheyLRtM28dkj4Tjdu+c/xD44maicYWX4q68ftg7IKUs4K62vq6m3euAzzYIxB/CFZNf3uZ1dYwHD49RNh3OLY7cKrqiT+R0s044noy5xYWU43hvcamyAnz79Ebh2CuQJyU8fj7OB/52jk8/PlnXrmSNfi5XJylX8sz8QywcN4jGHk8CByqPF2pF48qxVeCq12ZYSBcNxiNbD3xGtQJ8v7m6UuBIC4XxPPYlQyznDUxb5Yd3gysrBW6bipEI+1VxvA6zmA6yb8xktbxSPVY0izy//PyGtqGAoxzHm/Cdm99B0rxvLRuCTEkteAwL0/HgSDmOy6ZNTrc2Oo5nYjiye1EFp265ItE/+6E7ePJamtf+wdf4m2fnu/Jaivbwdu7cd3CMxVy5Oj8YRTIlk9WCQTigsVY0cNe4esuzN9zPgqUfxq4Ixo7tRr1rfrc/zerZqnBcNjQc6eDIwRxTLhWWtnz8auYqAKulVb5y9Stkij5Khg/D2tqMsVxc5mr6alvX0rjLp2S4ZptWdwzulnaF4+8Fzgkh3ieEyFayiT9WcUB5nARsoDGl+Qz11WUbq88ipbwGFBva9ZQHD40DKDeNomPky1ZdVIXfpzEZDSrxY4/h5Q/dtkE4doWBSwthPvqNaR55egKBZDVX3wmUTCUct0Oq4A5chlk43oSXAJtWIxJCzOBWe2/W5r8LIWwhxLwQ4veEEANjh0kXzS1jKgCSlcczKve1Y5i2w821EsfaEo7DgFr87AaOI7myUuDYdIxkJKCiKjqI7bgZx/vGDVaKK3WPla3yhglZKCApGxp5Iz+wE9p+sdW23W+cGePv/MGTPbwaxW6YjrsLgaOC1y/VFscDqjFx3co5PnUrSzig8cuvvou/+cUf4NhUlH/+/z3B3z7XXvapovN4URX3HUgipbsDdFTxalY8cHAc25Fke7yIZ1gOZ+ZzHN3nuY7vBjY6jnN6jkiN4xgGN+d4K+F4rbRW1x9eXrtKpuiKuZnC9ruEvzv/3baupbHvLeru724yOpiO4/3AzwEPAT8J/APge4CPi/U9jhNAXkrZuJyzBkSFEMGadukmr7FWeWwDQoi3CSEeF0I8nkptbRvfKUenooxFAjyjhGNFh2iMqgA3q1NNuvcWl5fzJMP+DdtJ4mGbWMjm0bNjXF0K8eqH1njR8Ty5ko/amDTlOG6PhZwrDIyScFwpwvOjwHu3aPZe3FzkP605pgP/CfhHuJmL/wW32M+WxfF60ed6ZEomY9usmI8p4bjj3EqXsBzJ0cnWCuOB6zgGVIG8LuC6oRyOTSvHcadZyQWwHcHUWKlp/MRKqV5MDlccxxJJwVBFtWrZajxSNjTGIm0lISr6iCscj858xPtZNjiOK8VfLy93Z0fxczcznNyfxO/TuG06xkf/2UsJ+jSevK7qJvUbb8x4/0E3d3aU4yq8mIoXHB0HYLXHOcfnFnMYtsOdB9L4AovohXuAWsex+/nLGTnCAVcqLJuDLRynipvPfzy3sYdjJ5DS/Xkyxe37waXCEtcy11q+lo2OY/e1epVx3K5wLCpfb5ZS/o2U8i+B/x14MT3IcJJSfkBK+bCU8uGZmZmuvIYQggcOjfHU9a1zSRSKVsk2OI5h9AZqiu25vFzg9pn4hhxRIeCugyX2Txj8/Vcu8T135hmLWThSkC+tr1aWLSXStMNifhUYHeFYCHEM+CDwCSnln27S5p8Bfw/4x1LKqgoipZyXUr5dSvnXUsovSynfiZuT/CYhxIPNzlV5Xtf7XI9MyWR8G8exJxxnlXDcMa5WJhlH23AczyZcx7EqkNd5PDfcelSFchx3iqW0e/8Ihpaabt9tdCGHKhnHsLXDdq9h2iaWs/n7sqSE46FiOhFktWCMTEE3zz3dmHE8Fg0wFQtycanzi0BSSk7PZ7n3QLJ6LODTODgR4caaMn30m2xlAfa+inA8ygXyvMJ4Lzg8DsBqobdirJdvPDNWJBg7jVU+gmPFcawkQssjhCsWW46F9LnXWq6In6Y9eGP7vJGnaG7+ftkgHJvj1f9nCq31g9+91brruHHRO1N0++JBzTheA56tnZACXwcM4J6aNnEhRKM/ewIoSimNmnbNSg5OVB7rGw8dHufcYk5Vbu8w11eLfOTx6/2+jJ6TK5skleN4z3M5VdiQb+zxmheu8XOvXGRmzO00k1H33pMtrt9GVVRFeyzl3W5kFIRjIcQk8Bnc7OKf2aTNm3AL5v2KlPLjLZz2o5V/v6cjF7lLWomqUI7jzuNtazw61Y7j2BWOl3JqMavTXFl2JyjHpqMkQgG1SNJBFtNB/JqDpd1q+vgG4TjoVJ1QqkDeOltNokE5joeN6XgI25Gs9diZ2C08U06jcAxwz4Ekz93qvDHseqWQ6b0H6mWNQ0o4HggyJZOgT+PQRIRwQOPayggLxysF9ifDHBh3k+jW+iAcJ8N+ElGDUPw0oKEXT2LbiWq+sYfpuJ/FQY6q2KowXtEsslysL0VjW+PV/2eKrRW0XywsbtuvAtiOvaGdtzAwqBnHZ3Adx40IwAsAOwv4cDMWa2nMND5LQ5axEOIwEG1o13MeOOTmwpzqQueyl/nLx67zbz/6zJ6a9BuWg245G6IqpuNuxnE/QusVvadk2NzKlDfkG29GMuquINZuc1FRFe2x7GUca8P9GRNCRIFPAUHgDVLKDaMLIcTLcGMn3i+l/L9bPLVs+LevpEvGtgOfoF8jEvDtqT6k21xdKRIOaMwmNk6yN2MqFsSnCRVV0QUuL+cJ+jUOjEVIRpTjuJMspgPMjJmslptPBJdL9RPAcECie8KxKpBXZbuxSMnQSCrheGhYLzo7eKLNTvBMOVPxjQ68+w+O8fxCruPF0Twx+r6DybrjhyYi3FwbXZFyWMiWLJKRAEIIjkxGRzuqYrnAsekoE5XM2547jm9kuP/QGEKAL7CEL7CMUbgHx0qg+Rvyea00Pk2uO46dwRvbb5VvfC1zbYOO41hu2m4gkGvZcQyQKW+vOTbGVADVQrQTA5px/CngfiHEdM2xHwQCwNOV7x8FssBbvAaVie8bcR1THp8BXiOESNQceytQAr7S5nV1lAcPuSuGT99QwnEn8VazR3mLSCNePmFjVMVMIkTZdMjralK4F6huP55pVThWjuPdUDSL5HX3fjPMjmMhhB/4CHAceK2UcsMIRghxL/BJ4G+Bf9nG6X+88m97lRm6QNm0KZsO4y0MfMYiASUcd5ArK0WOTEbRtK2rP9eiaYLZREhFVXSBy8tFjk25f49EOKAyjjuElJLFdJB9E+YGZ7FHwSjURUKFAg6GpeE4ynFcy3bOqJKhMRZVwvGw4GUBj0p83nJeZywSIOTf6PZ74NAYliN5fqGzn+dTtzL4NMFd+xJ1xw+OR1jOG2oHc5/JlszqYtbIC8crRY5NxaoLJ73MONYtm7MLWe4/OA64UYzB2GnM0jEccxLNV/+5yxs5wkGnKhwPouN4K+G4MaYCXMex8OUQgcWWHccA6XJ62zbNxiG5koPQygR87Uq6O6PdV/kAsAJ8UgjxRiHETwN/Djwipfw6gJSyDLwH+HUhxC9Uivl8pPJaf1RzrvfjFuz5mBDiVUKItwHvBH5PStnXMLHZZJi5sTBPX0/38zJGjnTRnQDtLeHYFYY3Oo5Ha4VfsTWecHx7parzdgT9kkjQJlvjOFYZx62zXFzGquyBGWbhGPjPwOuB3wKmhBDfV/MVEkLM4grGeeA/Ai+uedyLj0II8U4hxHuFED9W6W/fDfw+8DEp5TN9+Lnq8LbjbxdV4bVRwnHnuLZaaCumwmM2GVaO4y5wZaXAscrfIxH2UzBsLNvZ5lmK7ZjPGOimxkxS33KCVisqhwLu7123tJYmdXuFrYRjKVXG8bCxPh8ZHeF4uonbGNYzbp+52Vlj2KlbWY7PxgkH6oWiQxNu7YCb6b0z7x1EsuX1KLRDE1GurxZHcsdvpmSyWjA4Nh0jEvAR8ms9jao4t5DHtCUPHFqPbAnFTgM+pAzja4iqyOpZwgGnGlUxiBnHmxXGM22TW7mNsVeOOY7Pn0bzrZEutC4cZ/Tt70nNdj4VdIHP1ztjWVvCcUXQ/WHcDOIP4VZp/wLwEw1N3wP8NvBruC7lJPBqKeVizbnWcKu7+3DdUu/Cncj+5k5+kE7z4KFxnrmR7vdljBSe43iUV/oaWReONzqOAZVzvEfwqjgfm269AFUyatetVqqoitZZLi5j2a6DMjDcwvGPVP79Q+CbDV9zuLUFDgGHgS81PP6fa85zFng58N+BvwF+Gvi/K//2nbQSjvuC40iurRY5Otn6fcljXyLEknIcdxTbkVxbKVYjjZKVcYPambR7zi24485wNIUjNxfiV0pNhGNTKOG4hq12P+mWQEqhhOMhYiY+WvOR5ZzRNN8YXAfwZCzIsx2e3z93M7sh3xjcqAqA6yrnuK9kSma1Pz0yGaVg2D2PcOgFXs2KY1NRhBBMxoI9/TmfuZkG3EgYD19wHs3vFivXfPW+0KyRJTLAjuN0Ob3pNd3I3sB2Nu4ksK1xNH8aLZCmbPgxrNZ287UyxmgWVVE2/Gg9FI7b7tmllBdwHVBbtZG4wvFvb9PuNK4QPXA8cHiMvz21QLpotLR9VrE9nuN4bwnHXlTFxuJ4MDor/IqtubRcYG4sTDTY+i03GbVYy68LaSqqonWyehbLdgciviEWjqWUx7ZpcoXmdQcaz/Mh3MXegcQTglsp7pCMBLiZVp+FTrCU0ymbDkdbzF6vZV8yzHeurHbhqvYut9IlDNvh2PS64xjcBWg1Dt0d5xZKCCTSd3PLdrWO43DA7TvKhoZhGxTNItFA+4sso8ZWjmNPAFDC8fCQjPgJ+rSR2QGZyuvceyDZ9DEhBPcfHOPZm53b2LyULbO8yWt6juO9UCBvPlPic6cW+dmXHEWI1qOvekG2ZFZ38hypLJRfWy0ytckCw7ByZcUrruv+rBPR3grHz97IMB4NVBdMXCSF8P9gxXyW28X3EK55JK/nCQcdsiXXJDVoGcftxlRIKXCsMXzxU/j8aQAyBR8zY9sv/u8kqkK3dCwrQiAwoI7jvcRDh8YBeEblHHeM9B50HGe3iaoYlRV+xdakcjqzyfD2DWsYi9pkiz683VTKcdw6OT03Ko7jPYG3qDgeaS3jOKscxx3Bc6fsyHGcDJEumh0vMrSXuVJ1C3nCsbuQohz2u+fcYpHJhEXWWN6yXXPHsTtVUq5jl62E45Lu/q5UcbzhQQjBVKVg9yiwnNM3dRyD64Y8t9i5AnmnbrkidDPheDYRIuAT3NgDBfI+8dQtfvOvTw3kHD9bttYzjqfWheNR48qyN6ZzxxBT8WBPM46fvZnh/oNj1YUDRzpczVxlyX4EW1tk1Xqirn3JKhEMmAPrON5MOJZSciN7Y8Nxx04APtdx7AnHxdb6wqye3TY+pTGqIl1O4zjRnjqOlXC8Cfd5BfJUznHHWNuTGcfuz5xsiKqYiLpV6UdloKbYmlzZIhlubyKVjFoYlka5Mmm1HAvLUVuWW8F1HLv/H/KM4z2Bt6jYiuNYRVV0jqueO2WHGcegFj87SbWIqhdVEVl3HCt2x7mFIvvGjU0L43lk9Ew1Z1EJx81RjuPRYzoeGon5SNm0yelWdVdnM+4/NIbtSE7Pd8Z1/FwlL/meJsKxpgkOjkf2hOPYMwCc6dDvtVNIKeuiKg5XXOCjqEVcWSmwPxkmEnQdvBPRYM8yjsumzfMLuWpMRaac4fmV51kprTAXn2M6Ms1qeXHDPFbTytV+Y9AyjlOF5vnG6XK6ad0hxxwHwOdfqzqO1/Ktue8d6WxbhLfx8XQ5jWMr4XggSIYD3DET42nlOO4IZdOmZNqVldcStrM3xBxvwhcP1Q+ifZqbPaQm3XuDXNnc4DrfjmTUVT6ztTnHKq5iW6SUFMxC1XGshOPBxxOCky1mHOd1SxUM6wBXVwv4NcGB8fZ2Q4AbVQGoAnkd5PJygUjAx76kK3p4E11vAVqxM84t5ljKmRyc0uscxc2QUrJaciNYwkH3HlM23b5ECccuW+1+KhnueEUJx8PFdHw05iOe+L1ZcTxYz199rkMF8k7dynJsKrqhlo3HoYkoN/eAcJyt9FOnbw2WcFw0bGxHVmtoRII+ZhKhkXUc19bS6WXG8dmFHJbjFsZ77OZj/KfH/hNlq8wdE3dwIHGA2dgsEslysWHXj1bEsDRsZ7Acx450Nl5rhfn8fNPjtjUOgOZPI3x5ECaL2dbHb1uNMRzpUDAKdcdWilmQocEtjrfXePDQOE/fSI9k5c1e4wkDJ/cnsRzJfGb0O1GoEY6biIajssKv2J5c2SIR2l4Uq2Us6r53VIG89iiYBRzpYNkCgUQbrKg1RRMyJRNNQCK0vdjgCRJZ5cLcNVdWihyaiOD3tT8U9MTNRVUgr2O4k75YdZtnbcaxYud86pl5BDA3vdHt1AxPXA5VMo6V47ieLaMqPMdxVAnHw8SozEc88Xsrx/HcWJjpeLBjUZSn5jNNC+N5HJrYG45jL0Ls9PzWrsle08yYcGQyOprC8UqxbgfZRDRItmxh9sBo8WxlIeb+Q+PMxmaZik5xcuok4+FxACKBCIlggqXCUp2u5gj3/VI2tIHKOF4trWLL5nE2C/mFpsedinDs82cQAnz+NCttfBwy5c3vSQWjgKRej1zJu8YNza+E44HgwcPjpHI6C8pRs2vWKluR769EgIziDbsZubJJJOAj0GRiPpMIjcQKv2J7cmVrg+N4q9B9qHUcrz9POY63x8uAMm0Nv08yYDU6FE1IF03GIgG0FlT+sajKfe0U11eLHN5BvjHAvoRyHHeaKytFbqtxC3kOtqxyHO8YKSWfeuYWLzgap+QsVo/n9NymIrIXZxHy10dVrJXWuny1g49u6ThycxHCE45VxvFwMZ0IsZI3cIZ8N6hX4G+rjONqgbwOCMeZosn11RL3HmxejA9c4Xg5r498PQBvTDZoURVe/znWIBxfXx2t+VSmZLJaMKqF8QAmY+7PvNaDnONnb6SZjAU5MBbm6PhR3vbCtxEJROrazMZmMR2TtfJ6X2rjvl+8IrSDwlZz9M2EY9saR/hyCM0dW2j+NNli66axrRanm8VYeH9XTVPC8UDwgMo57hhe9tGDld/pKGYLNaOZYOgxHQ+OTBVjxeZYtkPJtDdsY/vUuU/x6PVHN3SUBaPAd25+B5sMfp9DtrDuOG6WqaSox+tcbUfFVAwL6ZLJeHT7wniwPvhXwvHuWckbWzqztmI8GiDo05Rw3CEs2+H6ar1bSDmOd8+Z+RyXUgVedc9kddup5VicWz3HlfSVps/xHMeaBkG/U81fzBt5bGe0xZ/t2MptDK5wHPI7+NVWn6FiOh7CcuTQ96vrURVb92v3Hxzj/FKOkrG7z/OpeVd83tpx7C4Gjrrr2NsFdjNdGqj3Uaa4sdbQ4cko85kShjU6kWdXG4rrAkzG3M/BWqH7f49nbtQXxhNNXDtjoTFCvlCdKGvKNOD2HYOUcbyZcJwpZzb0g6lCiivpKzjWeDXbGFzHcUlv3ZyxpXDcUBjPtE0Kuqi8jhKOB4K755IEfGJkc46llNxM9+bN5hU/unsuiU8Te8dxrG+ebTsTD5HK6yoKZcTJ6+5gqvF9IJGcTp3mr878Fdcz11ktrfLlK1/mL0/9Jc8sPsNzqWdJRu26iqwqqmJ71h3HgoASjoeCTMlsKd8YlHDcSdaKBhMtCvaNCCE4MhXlYqqwfWPFttxYK2E5ss4tFPBpRAI+lXG8Cz797C00Aa84OV4VhL2dOxk9Q1bf6I5bK61VXbWhgINuuZMziSSjj+Z8oFW2E47LhkY4NDpizF7BW0Ac9riK5couzqktMo7B3U7vSDg9v7vPs5fne2+TwngehyZc1+WNtdGe92ZLZrUI+NkBch17gnaj49iRcKtHGkgvuOIVO67ZtTRRcRx3O+e4bNqcX8pXDZebIYRgJjZDwSxU83rLjus+HjTHcTv5xsulZVZKKxStFbQa4VjzZ3DsKLlya/fVrcYXeSNf931aT+PY7r2lYN/g4urFll5jtyjheAvCAR937Ut0LEB/0HjfFy/wsvd8kUup/PaNd4nnOJ6Ohzg4HuHaiG0R2QzXcdxcEJlJhDAsh5yu3ESjjOcW22wBoWAU+OzFz/KxMx/jwuqF6oT13Mo54mFDFcdrE89xbNkCnxKOh4JM0WBcCcc9RbdsiobNRLS97PVa7plLcvrWaI6Pes3lZXcSdVuNcAxuv5EtqTHCTnBjKuZ56R3TTMQCVeG4YLq/64AW4Eb2xobFe1va1ViKcMBBN9anSns953i7xeuSoREJOi1lSSsGB6+YXGrIheNUXmcsEiDk923ZzhO4dptz/NzNDPuT4S0dznvGcVwyefFtUwCcHiThuJpxvD4HO1KJ6BolE9uVyhji6GSt49j9XHc7quL5hRy2I7d03ntMR6bRhMZS0XX0lh1vQXewMo4bHb4ejTEVjnSqc/M0X653HAfcccTV1dZ0tryR37TvbIyqSJfTOLb7Pr6UfZx/98i/a+k1dosSjrfhvgNjnLqVHTlX6DcuLPN7j5wD4Nxi94XjtYpwPBENjmwofTOyW0ZVuAMNlXM82nj5Wpu9DzbDciwskarPOFaO423xOnvLFtWoikHa/qTYiBtV0ZqAmVTCcUfwtm+O7dBxDK7L6lamzFqPqnaPMt4206NT9dsak5EAOV2913fCczezXF0p8oYH5lgprqBb7liraBYJ+oIcTh6mZJVYLm10FtUWyPMyjkHlHG8bVaFrCK3ArdytHl1R5xFC/KQQ4gkhRF4IcVMI8T+EEAca2gghxK8LIa4LIUpCiK8KIR5qcq57hBBfEEIUhRC3hBDvFkJsrWr2gZm45zge7nv5cl6viuBbsS8ZZiYRqhb02imnbmW3dBsDzCZCBHxipIVjKd2Yk+P74kzGggOVc1wtjheudxzDiAnHKwX2J8NEguu3l8nK+G6ly2O0pYqOcXA8sk1L8Gk+piPTrJXW3LmZcP8Gg+Q4thwL3W6uzTQKxyWzhEQS8kUo+r6B7btZfcxzH99aaz3SbbMCeY1CdrqURjpRJBZlq8iJqRMtv8ZuUMLxNtx7MMlqwRipAnmL2TK/+KEnqzfOXuQNp4sGQb9GOKBxeDK6hzKOzbrOqhZPOF4eAuHYcSRfPZfqSWXWUWPdcdy+sy9nXaWg+7AqMWwq43h7vK3HVk1UxfXs9X5ekmIb0kWzZcexdz/NKuF4V6RL3mLuzh3HnrtkkNxFw8pCVifgE1UBxyMR9quM4x3yqWdv4dcEr7l3f10xnqJZJOqPMh4eJx6Mcyt3a0N2cbVAXsChbCrHscd2u55KhkbWbF44aBgQQrwJ+AvgUeDNwK8APwh8WghRO2f+VeAdwO8CbwTywCNCiP0155oAHgFk5VzvBn4ZeFf3f5L2GKb5yFYs54xt8409HthlgbyVvM7FVJ77Dm7tstQ0wYHxyEhHVZRMG8uRjEUC3D2X4Mx8c7dmP2hm3plNhAj6tZHSIq4sF+piKgAmPMdxl4Xj1YJ735hsYdEGYCIygURSMAsITQckJUPDkc5A1BFojIXwyOm5DY95O5gORR4GJGnnu9XHPPdxKte6drJZXEWj43itvIZjR7F9V5BITk6fbPk1doMSjrfBmxg9d3M0JkaW7fAv/uJJCrrNf/3ZhxmLBHqy4pYumkxEA24u4mSU1YKxJ3L7tiyOl3BvsIOywv/Vc6lqFnUtlu3wyx95mp/9k+/wuVOLTZ6p2Irtoiq2QvrcyavnOlZRFVsjpax24p7j2HbsoXY/jTqOI8mWzbr8ua0IB3yE/JpyHO8SbyIxHtm54/ieitPqlIqr2DVLuTIz8dCGgjKJcEAtkuwAKSWffmael905zUQsWN01aDs2uq0TDUQRQnAoeQjLsTbkFq6WVwEIB506x/FeF463cxznyxKboZ4v/TTwhJTy7VLKL0gp/yfwL4GHgBMAQogwrnD8O1LK90kpHwHegisQv73mXD8PRIAfk1J+Xkr5flzR+JeEEFvbVHvMWCSAXxNDn3G8mCu3XPD1/kNjXEjlKewwLvDjT97EkfB3Hpjbtu2hichIO469OKVkOMDd+5M8v5jDGhCjUaZkEg/58fvW7+OaJjg8ERkxx3F9cV1w6yQkwv6uZxyvVorvTba4gy3id53JJauEEJKA36wWoR0E13GrMRXgxk0GtABh7iTifC+rxnrkpPAVQJikC61vMmk2xpBSbsw4LruOY1O7DKCE40Hh7rkEmmBkco7f+/lzfOfyKv/Xj93H8X2JnsVG1BbhWXc6j24n6pErb10cDyCV67+L9Mx8lp/9k+/wuj/8Gt+8uFI9bljuQsPHn3S3XpxdGOoJQV/IVVe723f2aX73vrNWcMUEFVWxNQWzUO2wLVvg1yTLxWWVtzjA5MoWUrYXmTAWCVSjFhQ7w3MctxoR0ozJWJC5sTCnbql+YbcsZXVmkuENx5PKcbwjnrqe5sZaiTc0iDqe8BkNuOPQWCDGVGSKpcJSNcoC1iMpQgEH3VwX85VwvPl8YaW4hmUHENpQj1MCQOOEL13513sjvBRIAh/2GkgpC8AngdfVPO91wGellLU3yA/hiskv79wl7x5NE0zFg0MtHJu2w8210oa4n824/+AYUu5sx4yUkg8/fp2HDo9z177Etu0PjUdHWjj2FvLHIgHuOZDEsJxqbn+/yZaspsaEQxOj8zfJ6xarBYMjTd77k7Fg1zOOVws6kYCvLiZjK3yaj6AvWDVD+f16VTgehJxjz4DUSFPh2CwQC8RwrHGS1puxpVmNuhJC4vNn0I0Y51fPt/TazaIqbmRvVOe24C6A54wcjh3F0q4BqKiKQSEa9HPHTHwkHDXP3czwx1++yE+9+Ah/9wWHAFfE7U1UxbqjbBSzhZph2g5l09lUMJyIBvFpYiAcx09eSwPuqPin/+u3+L8/e5a8bvFP//xxPvPcAu94wz3cORvn+YXB2X40LOzGcextc7mQct1PKqpia2pXiT3H8VJhqY9XpNiOdMlzvrYuYI5FAtXth4qd4e0u2Y1wDG7O8WklHO+apVyZ2SZOuUQ4UK0Kr2idTz0zT8An+JF799cdbxSOAQ4k3Phar1gPuH1tySwRCkjKpoZX5sR0zGo1+L3IZovXUkq+duVxQKD5hlqM+RPgB4QQPyuESAoh7gL+PfBFKeXpSpuTgA00KgFnKo9R0+5sbQMp5TWg2NBuIJiOhwZiPrJTbqVLWI7kaIPrcjPur0RMfPqZeZYaDDy2Izkzn+UvvnOtacTEU9fTnFvM89YXHW7ptQ5NRFjO65TN/m/D7wbeeCwZ8XP3nGumH5QIq0ypuYFrKhbsuhO3V3i1kvYlNi4+T0S7/3OuFsxqIb5Wifgj1f5E08qUBshxvFlURePOJC8LORaMYVvjhMURIv4IS4Wl6i4nzZ/Gscb56tWv8vTC09u+drPF6VOpUxvaSClx7CimdpOgL8hYePvChJ2gfSVjD3LfwbE6F+aw8sQ110Hxr151vHrs8GSUz59exHYkPk1s9tRdky4Z3D4dB+hptnI/2U4w1DTBZGwwVvifvp5mIhrg87/0ct79ydP8py9d5E+/cYWiafM7P3Y/P/XiI3z36qoSCHZAXt+5cKz5s4DDlZUskMByLEzbJODbndgzqtRmQFmOKxwvFha5c/LOPl6VYisyO3C+jkUCKqpil6RrCtbuhnsOjPHFs0uUDLtlt4liI0s5nRffNrnheDLsV4skbSKl5DPPzvODx2c2OM2KVpGAFqjrQ4O+IIlQgnQ5zaHEoWpcyFp5jVBgFikFpi0I+t2JYLqcJhZsTZwaNTZzHJ9fPc9izu1/hTa8Y3sp5aeFED8H/DfgzyqHHwXeVNNsAshLKRtVwDUgKoQISimNSrt0k5dZqzxWhxDibcDbAI4cObKLn2JnuMJx/+cjO+XKivu+u226tc/mbDLMyf0J/vTRK/zpo1c4NhXle45OslLQ+e7Vteoc7qHD43zsn70UrWaO/OHHbxAJ+DbsaNiMQ5Pu1vyb6RJ3zMTb+bGGAm8HWDIc4I6ZOAGf4PR8ljc/dLDPV8amUWgTsWDTeMZhxBOOZ5MbF58nY0EWu1yna7Wg70g4zugZHOkgtQJlw11wGIRi5s2E44JZqNbQqT0G7kK0kxvH78+wL7aPK5kr5IwcyVASnz+NXjiJlJLHbj1GwSzwkkMv2RBL5tEoHBeMAlfTV+uOeY5m6UQxfQvV6I9eoBzHLXDvgSQL2fJQd6gAF5byJEL+OlfLkckohu10/aayVjSrwsBYNEAy7B95x3ErEQUzAzJQe/pGmgcOjRML+fndH3+A//wzL2T/WJg/eOtD/NSL3QHsXfsSXF0tjuyKebfIlk2Cfo2Qv31RRQgHzZejWA5VCwaouIrNUY7j4cMTMFvNOPbaKuF4d6wVTYI+jeguxd57DyRxpIox2g26ZZMumsw2cQslwn4My0G3VL/bKjfTJW5lyrz8xMyGx4pmsc5t7DEeHsewjbr+da20Rjjgbg9VOceuIL9ZnYVnl57Fsd3f6zA7joUQrwDeD/wh8ArgJ4FJ4ONCiK6ujEkpPyClfFhK+fDMzMb3breZjoeGujje1RVXxGk1qgLgr9/+/Xz8n7+UX3/9SY7vS/CVc0vcXCvxhgcO8Hs/8SDveMM9PHU9zV8+vl5guWhYfPLpW7z+/rmWI+gOTbjXNCrRCI14i5tjkQBBv8ads4NTIC9bMkk2GV9OxoIUDHsk5rSecNws33syFux+cbyiWS3E1yqRgCt26paOI/LVIrSD6jheyDXPNwY38so2x9H8aSYiE/g1f3XuqfnTSCeOdNz34OnUaR659Ehd9EQtuq3X7S4+nTqNRNa18YRj2w5jsNR0TNMtlOO4BbwCeaduZXn5Xb3vzDvFxVSe22fjdasctbERB8a7s2IhpSRTNBmvcTYdmepNtnI/aSWiYDoRqt7w+0XRsDi3mKvb0vn6++d4/f31K+kn9iWQ0l2A2K6KsGKdXNkiEdr5rVbzZ3CsMUpWiXgwTtkqkwwNVF2VgaHWcWzaAgd922I+iv6yk6zdsUiA5xcHY1IyrKSLBmOVgrW74Z45r0Belhcc2WCiU7RA1S3UZNLnTXhzZYtQXDm6W8GL3nphw/vRdmzKVpmJ8Mb36XhonGtcI11OVydha+U1pirCcdkQJCpD5L0qHJet8oYJLLhj/KyeRTrTwHA7joH3An8tpfwV74AQ4incyIk3Ax/DdQzHhRC+BtfxBFCsuI2ptGs2WJ6oPDZQTCeCLOcNpJS77hf6wZXlItGgr1o/phWCfo0XHJngBUcmeNsPbnxcSslnTy3wu397ltfcu5/JWJC/eXaBvG7xEw8favl1Dk24N49msRejgLeQ7/VXd88l+Nr55X5eUpVsySTZROD3xpzposn+seHuW71aSc3e+5OxIKs9yDi+vUWnv0dtgbygKFAqD07GcVPhuEm+cdEsEvaH0YQfxxrDFzuNJjSmIlMsFhaxHRtfwL3V29YY/qD7mbiauUqqkGJffF/T18+UM4TjYRzpcHb57IbHV0urSMePI3UcylURvhcox3ELeJXDh71A3oWlPHfM1H+we5E3XDRsDNthokYY6FW2cj/JVh3HWwjH8WDfM8Weu5nFkfDgoa3F4OOVAhAq57g9cmVrRzEVHpo/g22NV50+mzl+FBsdx4azd7Moh4VMZUA7FmndrZBUjuNdky6adX3yTjk0EWEsEhiYPMNhZGmLbaZe36EK5LXOk9fShAMaJ/bXF63y3MTN3DkBX4BYIFZXmMaNqnCFUuU43jymIm/ksR0bx3Ynr8PsOMbNHn6q9oCU8nmgBNxROXQW8AGNGViNmcZnacgyFkIcBqIN7QaCmXgIw3bIlobzXnNlpcDRqVhHRW8hBL/15vvIlS3+w9+6f7IPP36d26ZjTaOFNmM2ESbgE6PrOK68Z5KV/uqeuSSpnD4QO2qz5ebF8SYrZrZuF47rBam8jk8TTaPHJqJByqZDyeies3qtYLYdexb2hxEISmYJoZWqtQQG1XG8WFis+15KuV4Yz44DfrRAGoCxkKunZPUsWqVWkWON1z3/Vu7Wpq/vjTGupq82LdS3WlzFcaKY2g2g+ZimWyjhuAXGIgGOTkWHukBermyymNW5c7Y+W2luPIxPE10VcdeaFOE5POlWM7Wdje6FUcGb6DVb6fSYiYdI5fVqiHo/eOZGGoAHDo1v2e7YVJSgT+PckhKO2yFXNlveztYMnz+NYyUpesKxiqrYFC9/SkpXOC7b6r066NRW426VsUiAXNka6f6j26wVDcbbEOs3QwjBPXNJTqn8+x2zlPUcx02iKkLu5yKrFkpa5snra9x/cIyAr36K06wwXi3j4XGKVrE6cU2X0kMbVTGfm9++UZtsNvao9ruO+3sV2lCPUa4CL6w9IIS4G4gAVyqHHgWywFtq2kSBNwKfqXnqZ4DXCCFqVzDeiitCf6XTF75bvG3uqQEQ+3bClZUCx9qIqWiVE/sT/MOXHeNDj13nY0/c4DuXV3nLw4faEqh9muDAeGR0heOySSzow1+553o7kc70eUHZsh3yukUystG840UrdDvGoRekcjrT8WBdDrfHZMwdQ6wUuvO51i2bvG5VX6dVhBCE/WFKVqmy2CjQTdH3jGPd0rGc+sUzRzob+n3DNrAcyxWOK6KwV9A+HozjEz4yeqZ6zLbqdzo1FtqrJaO7euPp1OkNj+WNPLqtI+0IpnCFY5VxPIDcd2CM524O78ToYspdsWgM5Q/4NA6Mh7vqOPYyLOuiKnqUrdxPWomqmEmEMCynr1XTn7qe5uB4pGk2Ui1+n8Yds3HOKcdxW+zacRzIAH7WCpWMY+U4boq3+gtgOwCCojm8i317hXTRJBr0EfS3PhwZq27fV2LaTsmUzLbiQbbingNJzs5nsezmmW2KrVmqbDPdLqpCsT26ZW8am1I0i/g1PwGt+ft+PDwOrAvDuq1j4/Yp5RrhOGfkNkwsB40n5p/ouHNrM8exN8l1HccOQhvqcf37gbcKId4rhHiVEOJngP+FKxr/DYCUsgy8B/h1IcQvCCFeCXwEd079Rw3n0oGPVc71NuCdwO9JKQduQjld2eY+CC7RdrEdyfXVIkenulO08hdfdRf7kiH+zUeeRhPwv72w9ZgKj0MTkZGOqqhd/L+7Ihz3u6C61282dRxXhONuxzj0gqWcvukc3nMCrxW6M172zjsZaz0ixsMTjr3FxpLh67vjuDby0COrZzdkEnvzzVjQzTcGqu5iIQTJUNLtG7U8CBOn0sbDi7JoRrqcJqtnuZ69vuExL9/YcaJY4gYCjbB/o+mgWyjhuEXuOZDk2mqxWjl02Li45NruGx3H4Iq4vRCOJxqEY+huREa/aaU43iAM1J65keHBw61lFp/YF+fc4sYtHIrNcR3HOxeOvdXKtYJ7u1aO4+YUzEK1Y7dsd9W9ZA/c3KwthBBvEUL8tRDiphAiL4T4rhDip5q0+ydCiPNCiHKlzSubtDkohPi4ECInhFgWQryv4pLqK+mSyXgbbmNYnwSouIqds1Y0OiYc33sgiW45XFpW0TA7YSmrowmYapJPuB5Vod7rrXBmPodhObzg8PiGx7zCeJs5BcP+MGF/uM5ZVHZWAdDN+ufURlpYjsWF1Qu7v/gOki6nObdyrqPn3E44lk4UoZURYqh3gvxH4BeAVwOfAP4DbnTFK6WUtTe49wC/Dfwa8CkgCbxaSlndzyylXANeiRtr8UngXcDvA7/Z9Z9iBwzCfGSn3EqXMG3JbdPdGdLEQ37e8YZ7cCS84sQs+5LtCzWHxqOj6zhuKEA3EQuyPxnuu+O4mr28RcbxqDiON8v2nop3VyD3nMztOo7BLZBn2AaOcN8nuin6nnHsFbyrpdkuo4JZQCCI+CM4FTexz78+LhgLjWE5FiWrUI2crMV2bBYKG3OTwR1fNHMbgxtTASBtN6oi5OtsPM92KOG4RbxiYKfmh9PBdjGVx6+JqmBbS7fzhptFVewN4biF4njeQK1PBfJWCwbXVovbxlR4HN+X4Ga6pCaxbeA6jncu0GiVjihXdIs31FZbVazTmG8MgBj69+kvAXngXwNvAr4EfFAI8S+8BhUh+f3A/wBeB5wCPiWEuK+mTQD4LHAUt0r8L+Jus/1Ab36MzUkXTcbazEZTwvHucTOOdx9VAesFhPvtLhpWlnJlpuMhfE22mXrjh6zqc1viyWtuIZpGx7Fu6ZSs0rZZgOOh8TpHccFyi9nURlXA+kQyp+f4+JmPc2rpVCcuv2MUzALPLT3X0XNuttvJi6pw7AjCN9xjeunyx1LKB6SUMSnlQSnlW6WUl5q0+20p5SEpZURK+QNSyiebnO+0lPKHK23mpJTvaCioNzBMVwSmfs1HdsPVFfd91y3HMcDfuX+O3/g7d/PvXnty+8ZNODgRIZXTKZsD+effFZkmBejunktwZr6/O1S9frOZ47jqxB1SQ2AtqZzeNOoKah3H3RGOd+M49iIWdJly/zW1vjuOm+UbNxWOjUJ1Idq2xhG+PEJbfy+Nhd1xsRdX0ZhxDJvnHGf0DM8vP9/0sdWSKxw7dgxT3CDsb//3vhuUcNwi91YK5J0a0riKC0t5jk5FN2S+gZs3vJw3KOjd2XqXLnlRFes37gPjETTBSBfIy5VNwgGt6e/cw9ta0q8CeV6+8YMtCscnKgXyzi8p13Gr5DtQHA8gV3I7fxVV0Zza7UWW4wowYviF4zdKKX9aSvlhKeUXpZT/BvgLXEHZ453An0kpf0tK+SXg54ALwK/WtPlx4G7gf5NSflpK+f8B/wL4aSHE8V78IJuRLZmMNcmf24qxqBKOd0PJsNEtpy4+ajfcMRMj6NeGug5EP1nK6U0L48H6jiUVVdEaT15Lsz8ZZv9Y/ST64tpFYPsiMl5checozhmr+DTZVDi+kb3BR09/lJXSStPJZr8omaVqJuON7I2OnXdTx3HZcxxH0IY733hPMxEN4tNE3wt274QrK65L8FgXhWMhBP/4B27fUHSzVQ5NuCLZzfT6Z2RURORs2apzHIMbV3Ehle/rz1h1HDcRjgM+jUTYz+qQO45tR7JSMDaNqvAiOVa69HO26jgONRE4q8JxZWePYfU/47gV4VhKSdEsEgu69xtb348/sFTXxq/53YK7eqbiON64s3uzWgSuU7l5X+pFVdh2AEssEvZ3ZhzfKko4bpHpeIi5sfDQTowupvJNYypg3f17vUvZS+nKzaq2EI+brRwZecfxdk5Tb4U/leuPi/Tp6xmEgPsPtRhVURkwqZzj1nAcSd7Y+n1QMAqcXT7LUwtPcXb5LFfTV1nML1ZXXTVNR2glimV3IqyiKprTzHEsxHCLLVLK5SaHnwQOAAghbgfuAj5c8xwHN2/xdTXPeR3wmJTycs2x/wUYwGs7e9XtkS61X6RNOY53R7NdQLvB79M4uT+hCuTtkKXs5m6hRMiPEPS1DsIw8dT1NC84Mr7h+PMrrnsnFthaWIoGogS0AGk9DcBqeZVQwKnLOAY4s3yGT5/7NLrtTpqbVT7vF7XX0kkndDPh2JFOdaLt2NFhL4y3p9E0wWQsOJRRFVeWC4QDWtOc+EHh0IQ71/7gt6/xax97hle+98ucfMff8hffudbnK9s9blRFvQHgwcPj2I7kuZv9002ypUqR+k3MCRPRYHU8NKysFQ1sR24qHCfDAXya6KLj2D3vVo7j28Zv4413vRFN1PejQV8QTWjoThoYHsdxySohkcQCMaT0YRn78Ic2uofHQmMUzSLSN4+03ba1pIqptn5e0zarJind1kE4RALKcTyw3HtgjOeGcGJk2g5XV4obCuN5VGMjVroj4q4V3WqrjcWP2s1WdhyJbg3P6mwrRdH6vcL/9I00d87EiYdac/wdHI8QCfh4flEJx62QNyykdCf/jViOxdXMVc6unMWwDcbD4wghSOtpbuRucGH1AlK6WYGaP01Jdz+nynHcnFrHselpLEMuHG/CSwAvvNLbM3m2oc0ZYFIIMVPTrq6NlNIALtacoy+ki+0XaVPC8e5YrzvQGeEY3F1Zp25lq/csRess5fRNBQ9NE8SDfrLqvb4ty3mda6vFpsLxuZVz+IRv08J4HkIIxsPj1WI4mXKGUMBBN+rHr3kjj2T9ve5IZ1NHbq+pzWi8kr6yYSJ8cfUi37z+zbbP22zROqfnqrUFpBNBG/Koir3OdDw0nMLxSpGjkzG0JnE/g8KxqShCwH/7+mU+/cw8R6di3DOX5Hf+5sxQ/s5ryTYUxwN4YSUu6IlKfFA/2CqqAtws5mF3HKcq0TKbCceaJpiIBrqWcbxaMBBi89/x4eRhfujYDzEeHufOyTvrHhPCzQguV+rRGJbW94zjxv5SSrlBOPb62Fgghm3MAv7mwnElrqIgTwMajlW/W0FKyUK+ec5xM1ZLq9Uxtm67c95mTu5uooTjNrj3QJKLqTxFY7jEiKsrRSxHbus47pb7N10ymm6JbSdb+dELy/zIH3yVV//eVzGs4ajcni2b2zqONU0w1acVfiklz9xIt5xvDO713rUvznlVIK8lNsu5/rOn/oynFp5iubjMbGyWe2fu5dj4MU5MneDBfQ9yOHmYklWqTtR8gVUM3e2AlOO4ObWO43TZva+MQFRFHZWidz8KvLdyyAvyTDc0XWt4fKJJG6/dRJPj3uu9TQjxuBDi8VQqtYMr3p5MyaxGT7SKEo53R7oygRhr0+m9FfccGCNTMrmVURns7WDZDiuFzYVjcPsPFVWxPU9dSwPw0OGNt7RzK+eIBVorIjMWHsORDlk9i2EbBPzWhuJ4zWhWVKcf1DqOJbLOdfzc0nM8cukRzi6f3bSi+2Y0E8a9fGMAaUeU43jImY4HSQ1hVMXVlQJHp/pe63dLZpNhPvxPX8Jn/9UP8tT/+SP8yc+9iP/4Uy+gZNq85zONa//Dg+1Icrq1IeN4JhHi8GSEJ66m+3NhbF0cD2AyGqgupA8r2wnHUHFWd0kgXy0aVRNcI3OJOV55+yvxaa7T9qH9D21wHUcCEUqWuxBrmGLgHMcFs1CteeCRNbL4NT9BXxBTPwjQVDiO+CMEtAB5x43Id+zkhjab5Rw3w8s3BtCl6+QP+9ov1LkblHDcBvcdHENK+l4ltF0uVPJoN3Mcj0UCJML+ruUNb+YoOzoVYzlvbFn0ZT5T4u0ffIKf/q/fZq1SyO3Tz7b+IesnubJFsoVs2+l4qHrj7yU30yWW8wYPHW4tpsLjrn0J5ThuEa+IYOMCwucufY6wP8zd03dzOHm42ql6TEYmgfVOwhdYwTLHMW0HRzp971gHkdoJ7HLe7VCFNjpiixDiGPBB4BNSyj/txWtKKT8gpXxYSvnwzMzM9k9ok7LpZu1u5lTYjHDA3cGihOOd4dUdmNhBFezNWK8DMZxxXv1iOW8gpSsqbEYyElAFaVvgyetr+DTB/QfrxzRlq8yltUvb5ht7JIKuK8gTSjVN3xBV0YxByTluFLDPLJ/Bdmy+fePbfP3a15FIdFuv5j63giOdpoV5M3ol31hqSBlG8ynheJiZiYeGrjie40iurha5bbp7+cad4kXHJjmxP1F1Rt85G+cf/8DtfPS7N3j8yuo2zx5Mclu4el94ZIInrq31bSdStmTi1wTRoK/p4yPlOI5vIRx38edcLRhNd68dSh7i1be/Gr+2roMkQ0numrqrrl3EH8GWNjYpdEvra8axlHJD7FSj29i0TTLlDJORSYQQWPocQiui+Tc664UQjIXHyNvzSEwca6NwvFnOcTO8fGMAw1nBz9gG/aDbKOG4De476P7Bn7o+XBOji6mKcLyJ41gI0XZsRDukK6tRjRyvXM+FTQqtfeVcile+9yt87vQiv/jK43z9V36YO2fj/LevXx6K7bC5stlSUbTpRH+2hj1zw30ft+M4Blc4TuX0oe9se8FmjuP/8ob/wr0z9246kfVrfsZCY9VtKb7AMqCxlHHd9iquop7Gzj6tV/4/IlEVQohJ4DPAVeBnah7yRiqNqz8TDY+vNWnjtevbPkLP6dFuxjG4kxS1fX9nVDOOO+g4Prk/gRConOM2WarUN9jOcbzVArvC5anrae6eSxBpEAkCWoD3/533Mx2dbuk8mtAIaIH1BVqttKE4XjMGRjhumPiWrTIfO/Mxnlx4su74mdSZls+52ZjDW7CVtlvkSDmOh5t+zUd2w0K2jGE5HO1iYbxu8i9++E4Ojkf4jf/1HJY9HDtqa1nPEW4uHC/l9LqCgL0kUzJJRgKb7jQZhYzjpRYcx5PR7grHU03yje+evpugb+MY86H9D+ET6320VyDP9F2gZMi+GqOKZrEaveTRKByvlFaQSKYj7njC0g/gD81zKHmw6TnHQmM40qasnWpaIG+1vNp0UbYZtY5jkxRBplp6XidRwnEb7E+GuWcuyX/72qWhiqu4mMqzPxneMse2u8Jxc8fx8X0V4XiT2IO/fOwa8ZCfR/71y/nXr76LSNDHP3jZMZ67meU7lwd/Zbag28SCrTiOg33JOH76epqgT+PkXHsVgu/yCuQp1/G2rDuO698H8WB82y2zU5EpTMcNwneFY1isrFmpuIp6CmahrrMv6u79eRSiKoQQUeBTQBB4g5Sy9kbt7W9szCk+CaxKKVM17eraCCGCwO1szEfuGenSzou0jUUCynG8Q6qCfQczjqNBP4cmItXq9orWWMq6k76tHMeJcEBFVWyD7Uievp7hBU1iKnyajxPTJ9rKAgz5Q9XCdw754RKOm0Rm1DqVPObz8xsmxZux2ZgjU3YHJY7jTv5VxvFwMxENolsOJWN46slcWXbf78cGPKpiM6JBP+94wz2cXcjxZ9+82u/LaRtvHLaZ4xjgiUqMUK/Jlq0td7RNxoIUDZuyOTzv90ZSOZ1Y0EdsC41nItY9gXy1YLS1ey0ejHNi+kT1+0jAE44vUTboa8ZxsyK3tX2klJJUMUU8GCcSiCAdP7axj3h0lfv33d/0nIlgAoGg7PtmU8exlLKluAopZVU4llJiiHmC2qZJg11DCcdtIITgXW++l1uZMu/74oV+X07LXFzKc8fs1iuxRyajXF8r4Tidd/KuFY2mE9RDE1FCfo3zS80FyLPzOV5wZJwjNYOBH3vBIcajAf7kG5c7fp2dpmhYm26PqWUmESKV13vuon76huvOCfnb2+ZwYp8rHJ9XwvG2rDuOdyCMhcfQhMZqaRVfwJ30LWfdW3arq5N7hdp8Y4CS6Q48xJA7joUQfuAjwHHgtVLKpdrHpZSXcAvlvaXmOVrl+8/UNP0M8CIhxNGaY28CQsDfdufqt2e1smDWbEfKdijheOekiwaRgI9woLNb3Lq5AD2qeG6hrRzHSZVxvC0XlvLkdYuHDo+31L6ZE6rxcc/5ZMkc5RYyjgdFOG7nOlp1HW9W+K/qOHbccbrQ1Od/mJmsCEDdKqTVDa5UCrsfHYKois14zb37ePldM/z+58+xlB2u8b23G6ZZNOPJuQThgMYTV/uzsS1TMreMjPTGnsOcc5zK61u6jQGmYkHWimZXNJ7VgslkE8fxVjy478FqxIJf8xPQApjiKmVT4kin7fz9TtE4l4R64Thn5DBsg5moG91nGbOAj+nxIgcTB0mGNgrDPs1HMpQk6/8018y/YLW0usHV3EpcRVbPVrOWTUsiRZGQ1p7xrxMo4bhNXnRskh97wUH+369d4lJqMAaJWyGl5GKqwJ2b5Bt7HJ6MYlhOdRLTKRxHkimZTYUBnya4YybO+SZRFSXD5spKgRP76z+EkaCPn/neI3zu9CLXVgZ7gFoybSItOI5n4iEMyyHbw4mh7UievZHhwRYnWbXsS4ZIhP0q57gFvMl+K1nXjWhCYyI8wVp5DbQiwpdnNe8O6lVURT05o1E4XnccO9JhsbA4FPE2TfjPwOuB3wKmhBDfV/PljdTeCfwDIcRvCCFeAfwJrtD8nprzfBTXWfwxIcTrhRA/BbwP+KCU8nyvfphG5iuF1ObG2i/ukAz7lXC8Q9Y22QW0W9opeKtw8aIqprfIJ3Qdx+q9vhVPXnOFiRccGW+p/YmpExsqvNcS8oUwbMN19sgMlq2x3S7yZm6lftDOdZxbObdhEtuMZsKx7djkTXf87tie41iNTYYZb67WrUJa3eDqSoGgX2Nui10bg44Qgl993UnyusWXnl/a/gkDRLUAXRNnb8Cn8cCh8er9uddkK1EVm+Fl8w5z9GIqV95WOJ6IBd0ihh3WGRxHslY0qgtOrRILxjg+ebz6fSQQwRDXqwu0/Yqr2M5xnCqm8Akf4+FxACzDjac4NGkjhODu6bubnvfY+DEmeT2mzHA5fZlnFp8hVVgvOH4rv73juHbXUNF057Nhf+93WSjheAf86utPEvb7eOcnTw+8GLGY1cnr1qb5xh5HJt03X6fdQrmyhSObb2EBN67ifJOoivNLORwJd+/fuJrysy85hl8T/PdHB9d1bNoOpi1bchx7E8Ze5opdXy1SMGzuO9BeYTxwBzgn9iU4tzD4Cyf9ZjeOY3DjKhzpkC6n8QWWyRTcgbGKqqindpVYt3Qsu+IOExY5PcfvfuN3+eLlL/bp6nbFj1T+/UPgmw1fcwBSyr8Afh74OVz38AO4kRbPeSeRUprAa4HrwIdxReO/At7Wix9iMxYqzpr9OxCOleN457jxUZ3LN/Y4PBllOW9Q0JU7tlWWcjqTsSBB/+bDcTfj2Br48WY/eep6mrFIoOUCWfsT+3nZ4ZcxEW6+1dNzJBu2gRRuf7tdXMUgOI4tx2pr0l2ySlxe234s3WyxOqtnq+9J6aiM41FgMlYRjofKcVzgyGS0WnBuWLl9xr13efFFw0J2i6gKcOMqTt3K9iUOYlvheAjf742kcts7jj1hd6XQ2fdWrmxhO7JtxzHAbGy2+v+IP4IpFtBNdxGzX3EVjX14ySxVd/iatkm6nGY6Oo0m3LGApR9AaAUOTbif3eNTx5sWq/Nrfqb938tB8w85PnmckD/EjdyN6qJtppzZNjaqNt+4XDFHtRO/1SmUcLwDZhNh/tWr7+Kr51J89tRivy9nS7zCeNs5jrslHHs34822Ih+fjXMzXdow0Ty74ApBJ+c22v73JcO84YEDfOTxGwPrwilW8sFajaoAelrJ2Ps7H91hJthd+xOcW8qpiew25MomPk0QDuzsVhsPxglogWpcRb7o/r2U47ger7I7uB2/dNxBkhAWGT1DQAvw0sMv7dfl7Rgp5TEppdjk60pNu/9XSnmnlDIkpXyhlPILTc51Q0r5o1LKuJRySkr5Cw15yT1nPlNiIhrYUWTCWCRAZoi3F/aTdNFgfIvJ1E7xxhHX15TruFWWsuUtYyrAXXi0HUlpiHMYu80T19Z4wZHxbWsHgLv4vT+2n4AvwCtvfyUB38bPQsjn/k10W6+KodsJx0Wz2PcxUbN84+04s7x9XEUzx7EXUwHg2JWoCl8JKSXz+dYrxSsGB29BcZgcmFdXihwb0sJ4tYT8PsYigY7v/O02WzmOAb7n6ASWI3n2Zqbp490kWzZJbmHcGcaFkkZSOZ2ZLXYsQc1Ogg7/nF6kTbuOY4CJyPqibdgfRmKRt9x6Pv1yHDcKx7Vi7nLJvbbaIruWPoc/dIvpqFukLuwPc/vE7U3P7fNnwR4jEZxgLj6HI52613t++fktr61OOLZ0hAwT6mzaXEso4XiH/P2XHOXk/gS/9anTA11E4EIlBmI7x/GB8Qia6LxwnK50KJsFp9856zqKLzbEfpydzxEOaNWJaCP/8GW3kdct/vKx6x282s5RqgrHrRTHc2/4qR46jr2/85EdCscn9iVIF01SQzbA6TW5skUi7G9pMtsMIQSTkUkyegbpv45phSkbQmUcN+AV6IGKcCz9gIPEJKNnOD55vFqAQTE4LGR09o/t7O8yFgmQ062uZLaNOumS2VYxk1apLkAPeIzUILGU07csjAeQjLjjCJVz3JzHrqxybjHPDxyfaan9RHii6tQZD4/z/Ye/f0ObWsex0Nz+tmxs3Y870tk0C7hX7MT1fCN7o2m2Yy3Nfq7aBVvXcWwjKXEpfYl/8L/+AWul/mxPV+ycqpA2JMKxlJIrK4WhLYzXyGwiNHTzqmzFIBPbxCjlxQf1OudYSkm2tHVxvGGMZqmlbNpky1YLGcfu46uFzpotVisO5p04jifDk9W5sdff6rbbf5n2YDiO03oacN9Ly8VlEsEEYb87XnML480SjS7XOX83i6vQfJVCslaCZCiJQNQJ0xdWL2wZG1UbVaHbBQLyIJq/9yYyJRzvEL9P411vupeb6RIffnwwxUtwBdl4yL+toyXo15gbi3Q8n9Bb3RqLbOI43ucK2o1xFWcXspzYl8C3ydaj+w+N8aJjEwMrHBcNd4LXWlSF+7vppeP4+lqRoE9jX2JnmWDVv1uTfGrFOrmySWIH+ca1TEXclcw8TwKwkguoqIoGaiewOSMH0g/CQrfLGLbBPTP39PHqFJuxkC2xP7mzrVbJSAAplZi2E9JFY9M+eTd0a+fSKLOU1VtyHMP6lmBFPb//+XNMx0P89IuPtNR+f3x/3fd3TN6xYbK3PpHV0TR3bLad4xj6H1ex05zl69mtx9LNzlvrOJZ2FMe3wLnV50mX0/zsgz9b5yhTDAdjkQBCwOqQ7OZZzOqUTWeoC+PVMpsMVXPvh4VsySK5hUFmOh7i6FSUJ3qcc1w2HQzbqS68NmO8mnE8HO/3RryIy+0zjgN17TuF93ub3EH0mU/zMRZy4zL9mvs3Mhy3nxkYx3EpDUDWyGLYRr3b2NgP+Jgeqx/vzsZm69p5aH5POE6iCY1kKOmawiq7lEpWiWuZa02vK11OV3cTOdKhaKcIOneg+Xo/1lbC8S743tuniAV9XB1gd83FVJ47ZuMtOR67URE9XY2qaL7id3QySsAn6gRIKSVnF3KcaJJvXMv9B8e5lR5MAc2Lqoi0IBxPRIP4NMFyvnc3yhurJQ5NRHacCTZXcQkO2wCn1+TKFonQ7px9kUCEsD9M3r4CwGrOr6IqajBso86B7TqOA9WYCth8BVjRXxYy5V05jgGVc9wmUkrSRXPTPnk3jEUCJMJ+VSCvRRxHspxvRTh2J1W9LKA7LHzz4gqPXlzhn/3QHS2Nt2CjcAzwgrkX1I2ThRAEfUEMq8Zx3IJw3O8CeTuJqoD6bbCtPl67YFu2c8wH/g9KZok7Ju7gp+//6R1dh6K/+DTBeCRQnbsNOldW3Pf7qDiOZ+KhoYyq2MrVC27O8RPX0j2N8smWt85eBrd4XyLsH9qoCs+dvp1wvD8ZZioW5Ovnlzv6+lXHcXxnRoTJyCSwLhybsogj+5Nx3GzHkOcIXiut1RXFAzffGODg5MbUgWZzTs3vLrTatiuWj4fHN8xfN4ur+PaNb1f/nylncDCJ2j9YjdES9C7fvW3hWAjxc0II2eTr52vaCCHErwshrgshSkKIrwohHmpyrnuEEF8QQhSFELeEEO8WQvQhsWPnTMVDHQ8b7yQXlvLcMdPaSmx3hONKVMUmq1F+n8bt03EuLK1vk0vldVYLBif3b8w3rmUiGqBg2BjW9hWhe007GceaJpiKBXu6PenaapFDm8SAtMJUpZNY6aHYPYx4URW7JewLY8oiYLM6ZI7jslXedBW1E9TGVMB6VIUnHEf8EeV8GkB0y2Y5bzC3g8J4oITjnZLXLSxHbton7wYhBIcnOj+OGFVWiwaWI7cVjr2MxkGt6dAvpJT8/iPnmE2E+Jnvbc1tDM2F42gguuF40BesZBy7E7vSNlEVMLyO462E47yRb+oAy5bdiXDRLHLd+WMkOiemTtRNrhXDx0Q0ODQZx1erwvGoOI7DpHJ637PS2yFb3roAHcALj4yTyuncWOvd3KWavbxNcfLJWHBohWNvkWF2m93Dfp/GGx6Y45Ezix0dR+zGcQzrwrGvIv05Iothib44jpv13Z5wXDJLRAPRalE8qBTG8+U5NL4xCvaOyTuqdRI8POHYsVzh2HNb18ZV3Mjd2LD4eyN7o25H0EppBR9xItyJEK7+1cs57m4cxz8MvKTm62M1j/0q8A7gd4E3AnngESFEdVQmhJgAHgEk8Gbg3cAvA+/axTX1nKl4cGDFs1zZZDGrc+c2+cYeR6aipHJ6RzOb14omQmwemg9w5754neP4ea8w3jaO4/FKFtcgroy3E1UB7laeTm8h2Yrra0UOT+w88zUR8hP0aT11SQ8j2bJZ3Wa8GwK+AKZt4AussZL3UzSLfc9S3I7F/CJfvPxF/vzpP+erV7/atdep3S4L61EVjsiQN/LVzlkxWHiVw/fvUjjOKjGtLbzF3LEuOI6hOwvQo4r3Gdg243gEHMfPL+S4lOqsqProxRW+c3mVX3jFnS0X2EyGkkQDzRfNbxu/re77kC+EYRtovgLgsJzbfmzcd+G4C47jleLKhmOmbVK03M95qpBCIjks3k4sOBoC3l5mYoiEtCsrRQI+seMF6EFjNhFCt5yhutdnSlsXoAN4wRFX2OplXEV2m6J9HsO0UNJIq45jgDc9dBDdcvjsqcWOvf5qQScS8LW826cRL4pRExoCHw5ZDFPrS8ZxY99t2AYFs4CUkpJV2jBusPQD+IO3mIpNbjiXX/NviEjUNAOhlXAs1xQZ8AWIBWLVHGVwF8OfX1l3HTvS4ds3193GlmOR1bMkeagaoQUwF59r/wfeIbsRjh+TUn6r5msJQAgRxhWOf0dK+T4p5SPAW3AF4rfXPP/ngQjwY1LKz0sp348rGv+SEGJrq+kAMRXrreDXDpdS7gDyjpnWhONDFSHxRgcromeKBslwYNOsYoDjs3GurRYpVyqGn513hePtoiq8rbZrA5jF5YnvkUBrbtPpRO/eR9mySbpoblp4sBWEEEzFgwP73h8U8rpVnfTvhoAvgC1thH+elazbQV9NX931ebvFo9cf5eNnP865lXPY0iZv5LsWr1G7WguQ1/NIJ0BJexqAsbASjgeR+Yzr4tux4ziqHMc7YbtdQLvlyFSUG2slVbSwBbyop33b5HwnRsBx/Ct/9Qz//tNnOnY+KSW///lzzI2FeeuLDrf8vGZuY49j48fq4iqCviCmYyKFgeZfYykzuo7jslXedDG6maic1bN12YwheZSgTxWgHQVcIW047jVXVwocnozi941G8qYnAKaGKAYw20JUxcn9CaJBX08L5Hljw+2ubSIaGIqFkqKxsRh0KqcjxHpRy6144ZFxDk9G+MRTNzt2TasFs6XX3gzPcSyEwCdC2CKLbg6G49jbzVq2ykhkXYF16QSwzRki0RSxQPPF0ntn761GcHhovmxVOAZ3flo0i3VC+fmV89W+9fmV5+uKzK6V15BIYnxvXb7xsAjHm/FSIAl82DsgpSwAnwReV9PudcBnpZS1drEP4YrJL+/CdXWF6XiQlQFdqfIm5gfHWxvMHai0857XCdaKZjV8fjOOzyaQ0s1jBji7kGM2EWIqvk3Yu1cNdQBv+O1EVYCba9Ur966XP3l4F8IxeG57JRxvxU6iKjShsS++r7p1ByCguZ8hGbhKuhDAkXA1M5jC8c3sTZ5ZfGbD8VQx1ZXXq3UcG7aBbutI6aekPY1P+Dbt1BX9ZT7jLiSoqIre4vWX2/XLO+XwZBTdckipvmFbqo7jbbaZen3IMBeCXC0YHR2rfe38Mo9fXWvLbQxbC8eNcRXeVlPDNvAFl1nLb+/q2qnjt1Ps5vU3cx1vJhwDVTeW3zmK5hueCC3F5kzGhifj+PxifmRiKmBdOB6mnONMydqyAB24UQkPHBrjiWvp3lwU67vRtjPvTMSCrA34QontSH7wP3yZD3ztUt3xVF5nMhok0MLCiRCCNz94kG9cWO5YfaLVgl4tvLcTYsEYIb/7nveLII7IYVhaXzKOG/tOz5TkLahG/euaiVsYT2MquflCcdgf5sTUibpjmr9eOB4PjQOwVsrjOO7vIWfkuJW7hWEbPHHribrnr5ZWCfnC+M0HKzuh3L/rvvi+1n/QXbIb4fiiEMISQjwvhPinNcdPAjZwvqH9mcpjte3O1jaQUl4Dig3tBpqpuLvFYRDdNd7Wi6kWQ8v3V7ZLLnRUODYY38bZdHyf64i+sOQJx9lt3cawPvEdxAFO0WxPOJ5OBHuWa+UJx7txHIPrth/URZNBQEpJXreItyAcCyE4OX2SV93+Kv7eA3+PN971Ro6OH60+7lV4d3w3sR2NbMHHjewNbKdzsTKdwLANvnTlS00fWyosdeU1awv0eCvGUvoo8hzJULKlwqCK3rOY9dyWSjjuJemS5zjuXlQFMHBxFXnd4h//2eMDVVDXm7xtt800GvTh08RQO45zZZOC3jnh+4++eJ6D4xF+4uHW3cawtXAM9XEVQb/b7xq2gT+QolCK4WxTUqOfjuNmxX3aoR3h2Ot3TcfEkQ5B57ZqoR7FcONt3R/0nN2FTJnzS3lefNvGreLDireI2MuaN7ullYxjcOMqTs9ne1aXKFNszXE8GR38aJZrq0WW8zqfO7VQdzyV01uKqfD40RccwJHwqafnO3Jdq0WTyVjrr9+M2gJ5blRFfxzHOSNX930139gqIRCE/etzlWphvKmt5+D377u/LhdZ82eqxfHAFZeDviAruTDZ+b+Pd8t9fuV5nlp4qq6ekW7pbvyidi/SmiSUeBJwf3+eRtALdiIcz+PmF//vuPnF3wLeL4T415XHJ4C8lLLxt7kGRIUQwZp26SbnX6s8tgEhxNuEEI8LIR5PpbrjXmuXqVgI25EDOXn1boStbkn1JvA7dRx/4cwir/2Dr9ZlTmZK21dvPzYVw6cJzi/msWyH80t57p7bPq1k3XE8eL/7UiXjuNXcn5l4CMPuTa7V9VX3RnR4ohOO48HubPtJ0bCxHdlSxvGh5CG+/8j3c2z8WLUDODm9vn7mOY4dzR00rOQCWI7FzVznthx1gq9f+/qmE+dUoTv37NrieF7HX5a3sEVOxVQMMPOZMvGQf8cZ4JGAj4BPDGTfO8h4C61jkS5FVXjC8cpgCcfPL2R55Mwij/dwq+x2LOV0kmH/to5ZIQSJsJ9saTgdx1JKsmWLgt65hc5nb2Z43X37Cfpbn8ZEA1GSoa3HlrVxFZ7jWLd0fMEUUvpIF7ZeCC6aRRzZn4LNJbOEZOdiXzOB2JEOa+WNnxlPOPYmtgF5pG7r7LAihPjyJgXgpRDiJZU2I10AfiIWRLccSuZgGRMa+eo5d0z5Qydm+nwlnaPqOM4Oh3BcNt0C9dtlHAMcm4piO7JqGug23nx624zjWJCiYVfjMgeR84vu3ObpG5k6jaVd4fjO2QT3zCX5xNO3OnJdqwWdyV2aECbDlQJ5mh9b5CgYTl8yjrdyHEcCkToTkmXsQ/jyHBjberdDPBjnjok7qt/7/FmkHUdKtxsQQjAWmqAkL2DoU1hlt8jv1fRVTqVO1Z3L64eDhZ/BH7pBMOp6b/fHtl4M7zRtC8dSys9KKf+9lPJzUsrPSCn/Pm4sxW8IIboaMiSl/ICU8mEp5cMzM4PRUXhu3pXC4N3kV/IGsaCv5W18Qb/GdDzIQnZnroFPPzvP2YUcH35svfrjWtFgfJubdtCvcWwqyvmlHFdWChiWw4l92zuOhyOqorWYAu/G34vM4GurRZJh/66LI81UCvoNuiuhX3jbiluJqmjczgJuZpE3yQ343L+VrblFalbz7jkHKef48tplzq2c2/TxbjiOTdusW5H1Ov4CpwGhCuMNMAuZ8o4L40FlwBUJKOG4TbyM425FVRwcjyDE4DmOPdE1P0BxD0tZfdvCeB6JsH9oHcfeImqnrr9oWJRNh+k2JsywvdsY6uMqAloAget+8gWWAUhltx5PS2TfCtfuNN/Yo6mzuJxpKoRX8x9NVwQKOEdHxXH8z6kv/P4S4PPAMvBYpc1IF4CfrMytBr1g2FfOpdifDLc0XxwWkmE/Ib82NFFP2RZzhAHmxtw4zF7t+smWTKJB37YxDp6WkB5AE5rH+cqObNuRfPvS+n06ldOZ2SbWs5EffcEBnr6e5sry7mOV1gqddBz7cESWgu4MhuNYT1ejmCL++shXxxrD508zHZ3e9rwP7HugKjpr/kzl+esL2AntdqQwKGtPUcp+LwC2tDfsKF4prRDR9uOz7yI6+Xk8HbuXMRXQuYzjjwKTwDFcx3C8yarqBFCUUnrvhjWg2ax+ovLYUOB9YHuVT9sObvZMe66i/WPhHUdVPH7F/bP96aNXsCvRHemCuW1UBbg5x+eX8pypFMY7Obf9QCAS9BHyawN5sy8ZNiG/tmVRwFqm415BhO4PFq6vFXedbwzuooluORSMwV2l7SfeJHk7R2U0EOXI2JENx4UQ3D19NwA+4UMgMGUBv89gNeeec1Byjktmia9c/crWbaxSx7fx1sZUAOR09/5REs8R5siGwgSKwWE+U951JfSkEo7bZq1oEA/5W8rE2wlBv8aBsUg1EmlQ8Fw6eX1w3i9LuTKzLYqfyXBgaDOOvesuGHZHFpq9nU7tFuVpRTiG9bgKIQRBXxDddh3HAPNr27uJ+xVXsdt85doiPB7NxGTbsVkpuYvYJauEX4TwMYYYAcexlPJ0beF34AngYeCjUkprLxSAX48BHJx7ZSOW7fC18yleftfMSMWRCSGYSYRY6pErd7dUc4RbEI4PjO9uV3O7ZEpmS07oyUpG7yAvlFxcyjMdDxEOaHzjgruIKaUkldeZ2aa4biNvfPAAQsAnntqd61i3bPK6Vf397ZTJqCscBzSBQ568bvYl49ibP4Lbx2X1LKZjYjkW0UC9ZuJYSfz+PIlgCybHyASHk26klubLVp/vEbRegJAx9PDfYBTuxrY2nrNoFilbZSL66wlELhCMXKk+1uq4plN0auYga/49C/iAOxvaNGYan6Uhy1gIcRiINrQbaLwCboO4ZX+1aDLV7sA6GdnRTX0pW+baapEXH5vkxlqJz51awLQdcrrVUlTG8X1xrq4UefZmBp8muHM23tLrTkSDrA3gzb5o2C3nG8O6cNwrx/Fu843BjWkBVIG8Tci26Dg+PnW8LgOp8TGf8CGEIOALYNkmkXCW1Zx7zryRZ7m43NkL3wGnU6cpW9vfNzodV1EbUwHu78O0TXRxmZg43tHXUnSWhUy5mqu/U8YigarjRbGR937ueX7v8/W7ADItFKzdLYcnIwPoOHbfJ4Mkvi7l9JYzvhNhf90W1WHCu27bkegdyLes1u/oknBcG1cR9AUxbANN09F8WRYy24tU/SqQt1vB2nTMuskzUBWIG495bqiSVSKkjQOgjYbjuJHX4hqa/qLy/cgXgPcWZAZZSHvqepps2eLlIxRT4TGbCA1NcbzMThzHmd7cJ1YKRktjnUHevezhRngmePFtU3y9IhxnyxaG5bTtOJ4bi/C9t03yiadv7moh1ysouGvHcXgSIQR+nwDhkNeLPXccl61ynVid0TOu29h036uRQKPjOEksbLS8aPXQ/ocAtzgegF0jHNv6bcTkw+TkU1himXL24Q3PdxdwBVHrlUQnv1A9ngglNoja3aZTwvGP427juQo8CmRxV2ABEEJEcbfzfKbmOZ8BXiOEqJXW3wqUgK2tawPEIEdVrBb0th0Zc2NhFnaw0unlBv7K605weDLCn3zjcrVDaeXGfedsHNuRfOa5eW6fjhHytya6jkcDA5lx7ArHrbsdpyvvo+UuDxYcR3JjrdQxxzEMptt+EMi1UNFXCNE0psIj7A9Xi+QFtSCGYxAMpatRFTAYcRXnVxtroTan03EVXmV3j5yRq27XjWkbXdyKwcCyHZZyu3ccq6iKrXnkzBL/81tX64r3rhWNluse7JQjk9HBE44rgvGgCMdSSjeqokXHcWKoHcfrn9F8BwrkeePtdsa38WCciXDT8ikbqI2rCPlC6Lb7er7AMmu57V+zb47jXUZVwEaHcTPHsdePSykpW2VCwt2uK3wjKRz/JHAD+Frl+5EvAO/tVB1kIe0r51L4NMHL7tx+q/iwMZsID01xPC8Caqt5jkcs5GcsEuhZVMX1Fk1SEwO+UOI4kgtLeY7PJvj+O6e4sJRnMVsm1WJx3Wa8+aGDXEoVeO5mdvvGm7DeD+/OiODTfIyFxvD7XN0nq+d7nnHcuGBazTe23HFs1L/+PnKcEFKGGYu1LrrPxma5e/pufBXh2KkUyJMSzPIRZvwvAiTZ8B9Tzj1czUAGtzhvqrhMxH6YSOw6gdC6U7zXbmPYgXAshPgrIcSvCCFeJ4R4gxDiz3EF33dLKR0pZRl4D/DrQohfEEK8EvhI5bX+qOZU7wd04GNCiFcJId4GvBP4vYYV2oFmIhpEiMEUz9YK5o6iKtJFk1Kb8QOPX1kj5Ne4/+A4P/fS23jsylq1cEErwvHxWXf94PpqiRP7W8+rmogGq8V+BomiYbVcGA/cn8Onia7nWi3ldAzL6YhwPB1XjuOt8CbIW0VV1OYYb4YXVxHwBTBtE19gmVzJj2G5K539jqtYLi5XO9nt6LRw3BhVkTfyVedzsOKCAhCMzlbGUSCV13Ek7FPCcVfJlkxWCwbnltYHxWs9cBwfmYyylNPbHkd0k0FzHGdKJobttDzpG+aoitqifoVOCMd5z3Hc+oR5f3x/W1vavbiKoD+I5Vg40sEXTJErxtjOpDWsURXQnnBs2AaOdAiKWWD0HMcV09ObgA/LdWveyBeAH4aM4y8/n+KFR8ZbcroOGzND6DhuJaoCXHPafLr7URVSypZ3165nHA/m+/1mukTJtLlzNl5dKPnGheXqe2QnwvFr7nUFR8+9vBM65TgGN+fYL9zFh4JZ6LnjeEO+cWVOWzJLBH1BfNq6nuNUoiSm4u3VOX3J4ZdwdGI/QitVoypscxrpxIhGMszGZsnxOLqzhJ6/B3Dfx1cz15BSY8L8R0Qnvlh3zn2x3uYbw84cx88D/xD4K1xB+B7gZ6WUtaLwe4DfBn4N+BTutp5XSykXvQZSyjXglbixFp/EzX76feA3d3BNfcOnCSajwYEUz1YK+g6iKtyJfLuu48evrvLQ4XGCfo2fePgQ8ZCfP/yCuyDfSsbx7TMxvDjgu+daj/+aiAUGclW83agKTRMcmohwuQNh9Vtxfc1dPTs8Edmm5fasu+0H7/c/CLRSHO/k9PbGk7nEHOPhcVc4dkzwu5M2L65iqbBU3U7TD86vtOY2BkgVuxdVYdomZauMbutoMlmXbzyXmOvo6yp2h5ejrxzH3cX73Xzz4krdsVb65N3gLUzeWBsc1/GgZRx7k752iuMNayxLbcRGJ8RvT9CajLf+Pm43B9UrehPyuZNi3dLxBZZxnCD58tZju1FxHJu2uWFXD6wLx94ird+6C6GVENpwvj+34I1AjPWYiq4yKAXgk5EAQjCQuznBjfR79maGl981ejEV4EZVZEomZXNwFl43w7u3tyrgHxyPcKsHGcepnI5uORyZ2l449hbSVwuD+X6/kHL7k+P74ty9P8lkLMjXLyxXXemt7lqqZTIW5OB4hDPz/XccQ0U4rszZSmax5xnHmzqOzWKd2xjW84kPjLWno2hC4xXHXkEwUMCxXMexVXZ3xgbCV9kf349P+EgHP0C5UiRvOV8mq2cYN36OZPIK/mB9dNRQOI6llL8upTwhpYxKKSNSyu+RUv55QxsppfxtKeWhSpsfkFI+2eRcp6WUP1xpMyelfEeTVdyBZyoeHLiMY6/qdLsrQd5Efr6NDKKiYXHqVpaHj7mL6IlwgLe+6DBXV9xJ40QL7qZwwFddGTzZhuN4PBocyAIOJcMmEmhvNereA8ldbRtphWuVv0knMo69baKDuGgyCHjbc+Oh5sJx2B/m6NjRls51YuoEAS2AIx1McR2gWiAP+us6vrB6oeW2hm1syCXeDbWOY2+yXrZ0/HIOIdzfv0/zVd1jisHAE473J3e3gOVlHNdGMShcLNup7nqoFY7XigbjXXZpef3L9UESjkuDFVWxlG1v0peMBMgbVrXw8DCRLXfWcbxaMAj6NWJtLM63i7cTKOhzxzmGbVQL5KUy/ReOmy3YdtpxvFbeWCyvYBaqP1/JqswTij9IOPn4rl97APlJ4IKUsvaHG/kC8D5NMB4JDGT9GICvnXc/hy+/a7bPV9IdZpO9q3mzW7zFzFaK0AHMjYd7ElXhRWW1srs24NNIhP0DaUIDuLDo3m/vnImjaYKX3jHFN2qE45n4zgwYd88ldiUce/eHTjiOpyJTVeG4bBdwpFPN0e8FjQuk6XIa27HRbX1jvrHtjg3m2hSOwd05vH8sAvY4AGb5KELLowVW8Gt+5hJzlLTnyJkpMivfy43cNULOXcxN6MSmPl93rog/wnh4vO1r2C3dKau9x5iKhQbuBl91ZLS5ErS/IhwvtuE4fupaGtuRPHxssnrs5156rOogbjVP8c5KXEV7URUB0iWzI5W6O0nRtNpyHAPce2CMa6tFMl0Uwq+vFRECDnbAcRzy+0iE/QMZ0zII5MoWQkBsk6zruybvqtv+shXHp46vT2C5CUhWcv3POb6Vu9W2y6lTcRWWY1E014UpbzKrWzoB5wAIV6CYi88R8I3edsZhZr6DjmNHQt4YDDFwkPAEUr8m+PblVRxH4jiSTMlsaTF3N3iTNW+hchBYdxwPxntlqZJP2KpwPJsIIeX684aJWqd0oQOf1ZWCwVQs2LaLuB3C/jBBX3DdcWzr+AOuYHVrbesJbSecv9vx6PVHWcgvdPx10+U0jnQLGDaNqciv999lq4yPBH4RJjL2jV2/9iAhhBjDLXDX6DbeEwXgJ2JBVgdUSPvy8ymm40HuPdD67tRhwoseGIa4ikzJJBLwEfS3JifNjUXIlEyKXR6zeYvWrZqkJmPBgY1mOb+UYzoeqkaPfv+d0yxmdb51aYWgXyMZab2eUi13zyW5tFzYsbN9tWAgROtu862YiExUhWPDLlb+7d3fozaqwpEOGT1TXRhtLD4nK/nE8cjOfm8TMYkmp/FpPszyEQLha3hDmZnoDEFfiLXAn3Cz9CSSMrdNThJJntpwnn3x3sdUgBKOO8JUPDhw2/VXd7gStL/qOG59cvL41TWEgBceWY/tOjwZ5UfucS30Yy1OUr/v9kmOTkU5ON66qDkRDWI7ktyATAY92i2OB3DfQfdmdGq+c47MRq6tFtmfDLdcfHA7puODt2gyKOTKFvGQH01rPrk9Mb15UbxGwv4wEb/7uTBliWTUrCuQdyN7oy+LJ+24jT06FVfR6FzOGTnXke0Y+OUBREU4PpQ81JHXU3SOhWyZkF/bddau53L5y+9c58OPu1+fO7UwcAuJ/cATSl9yxxSZksnp+SzZsomUMNblqIqpWJBo0Me11cHJPB20jGNvjNZqTq+32HtzbXB+p61S+zvP67t3Ea0WjLYLP++ERCiBX/MjEBi2gfDlEVqJhfTWgnXRLFbF126wWlqlZJX45vVvVo/plo7l7P69bUu72reuFFc2PF678Fs0LAL27YTHvoU2eoXx/i4QYqNwvCcKwE9GgwPpOLYdyVfPpfjB4zObjq2HndmEOw/3dqUMMtmS1ZZw6c3vb3U55/jaSqnu9bZjIhocWMfx+aU8d87Gqt97Ocdffj7FTDy04wXUu+eS2I7k3GJu+8ZNWK0UWvZ14HMYD8Yrc1wfhnSF417GVdRGVeT0HLZjVyMgvbm3R9J/hGjIZqcySiJiUzb8jPvvwLEmCYSvVR/ThMbBxAFM7Qol3zeZS+wjFmn+e+hHvjEo4bgjDKJ4tlPHcTToVj1daEM4fuzKKif2JTasOv3GG+7m//q797e8heUfff9tfPnf/FBbN0EvqzE9YNlEJcNuqzgeUF09P32re3EVN1ZLHJ7YfUyFx1Rs8GJaBoVs2dzyvb9dUbwN7cNue9M2SURLrOXXz206ZlN3UDdxpMPF1YttP69TjuPGrUV5I49uuffhgDxQjapQwvHgMZ8pMzcW3rVj8Gglv+63/+YM/+6jz/DvPvoMb/vz73J6F9vvRgUv3/hHKkVQvnlxpRrr1G3HsRCCI5PR6nbRQcATLwdFOPauI95CNXqAQ5UJ8M0eVaTvJLUZx/kO/P5XeiQcJ4NJhBAEfUF0W0cI8AWWWclt//npRGzEZtzKuVXVFwuLXF677L5eB13O3liiqeO46PbfUkrKdpGAPEhk7NGOvfYA8ZPA01LKM7UH90oB+PFocCAzjp+7mWGtaPLyE6OZbwzru1C6XSy9E2RKZluOU2+XWbfjKjyTVLjFyMjJ2GAKx1JKLizlOT67vv50eDLKkckoliN3VBjP455KPamdxlWsFoyOjiWnYlP4iGI5bl/WL8dxWk8DULSK+ISvutsX3JoHYTFHYoduY4BE1B0D2aWHAPCH63cMT4QniAfjxAIx9m/hKlaO4yFmKhYkV7bQrcGJZ96p4xjcAnmtOo5tR/LktTTfc3RjkeBDE1F++nuPtPy6Qoi2hQTvpjVoN/yiYbedvzcdDzE3Fua5m91zHF9fK7aU+dQqrtt+8Ac3/SBXtrYsjNcuXpaR6ZhEIwXW8v666u6dEmRb5XrmOrrd/t9+ubjcEUdobb4xuB1/2a4U63EOIDSTRCjRlwwoxdYsZErsa7Eo2FZ87+1TPPZ/vIqv/8or+PqvvIIP/9OXAHT1HjoseMLxiX0Jbp+O8c1LK9V+stX4qN1weDLK9QESjgetOJ63I6VVt47nOL4xpI7j6bg7Fu1MxnH7hZ93QiLkTtZD/lB1EusLpsgVY1s9DehuzvF8br76/2/d+BaOdJoK1Y50SBVTnE6d5mb2Zsvn30w4dqTDcnEZgGJpHIlJLGyi+ernC9FAlAOJAy2/3qAhhJjGLd7+oU2ajHwB+MnYYGYcf/n5FELADxwfXeF4MhZECEi1WaS+H2xnkGnkQGUBtJ06Sjvh+mqxrVo+49EAawNmQAM3riRXtji+L1533HMd70Y4PjIZJRb0cWZ+h47jgtHyjqlWGA+N4yOChduXmXZv/h4ls1S3W8crjFcyS0QCkTpd6qH9D1EoB3YlHCcrz11euQ2EgT9UHzklhOCuybs4MXViU00s6AtWC/j2GiUcd4CpyoB4kPJx1oXj9gfX+8fCLTuOzy5kyesWL6rJN+4lnuN40IRj13Hcvmh474ExnuuS41i3bBayZQ5P7j7f2GM6HlKO403Id1g4TgQTaELDtE1CwRy6qVEy1m/hi4XFLZ7dec6vbizO0wqWY3XEHd0YVdHoOEZYHEoMv9tYCHGnEOK/CCGeEULYQogvNzz+Q0IIucnXZ2va/dwmbX6+1z+T5zjuBDOJEIcmohyaiPLw0QliQR+nurhrY1jwisElI36+744pvnN5tXqvbjU+ajd4juNBiA2RUpItuZnzZdPBtLsXI9AqubLZVv8QDfqZjAWHUjjOlkz2j7nj5E5kTK/mjY4U5NmO2gJ5Xt/iC6SwrEhd39uMbgrHnuMY3AXUM6kzGxzHj916jP/x9P/gE2c/waPXH+XJhQ31yTdltbRKySytF7+rsFxcrhYsymSOAZBIzDc+nXtn7q3mVQ4jUsplKWVASvmeTR4f+QLwXsbxINy/a/nGxWUeODjWkx0H/cLv05iKhYYm4zjZhuN4XzKMED2IqlhtzyQ1OaBRFee9wniz9cLx93dAONY0wYn9iR3v0FstGEy0uat9KyKBCH4Rxpa9dRzXuo0B0qU0UkpKVomof/09lAgluGfmHnIl3y4dx+5z0/kowfANhNg4Ht3OSHnX1F1ooj8SrhKOO8BU3O3ABklAWy0Y+DVBcgfC1dxY647j7151iwM3cxz3As9xnB6gLVWW7WDYTtvF8QDuO5jkYirflcIBN9dKSNl6sYBWmIqHWC0aQ1npvdvkdJNEGyvx2xENRAlqQQzHIBhKA7BWk3PcS8ex5VhcSV/Z8fM7kXPc6DjO665w7BNBNGIIYXFobPiFY+Be4PXA88C5Jo8/Abyk4eutlcc+06T9Dze0/ViHr3dLHEeylNXdysIdRtMEd88luxr3Myx4juOxSICX3D5FXrf4+gXXLdgLx/GRySgl0x6I4qm65fbJ3hbgTsQl7Jad7Eg5OB4Z2qiK8Yibe71bx3HZtCkYdnXc3U084TjkC2FLG9ux8QfdviuV2Xp8Vysc245dV8h1N6yV1jYIuo/fepy10lrdsYX8Qp2LarGw2LKYvVpabbq4myq4P7tZPkjJdCe7jePcgC/AyemTG56rGC4mo0EMy6FoDJbOfW2lyF37Wi+gPqzMJkKkhkA4zpbbi6oI+jVm4qGuRlWUTdck1c5cdyIWpGjYOy4U1y3OL7miZqNw/NI7pvBroq2aUM24ey7JmfnsjhaIVgtmRxdww/4wPhHEETlMS/Ys47g23xhcx7Fu6zjSIRJY//2+6MD/z957h8mWHuSdv++kyqlzuDnMTTOjCXdGoyw0EkICIRtLSAQTbC9g7LV37WXNCmML2WBwAO8CNmgXW0aywQgBkhAojHKYGU1ON8zNoW/n7urK4Zzz7R+nT3VVV1V35a6+t97n6WfmVp2uqq50vu/93u/3PoSUKtmCSsjX+jim3HSOhKp7BLaTIhTuHru75ftvVwPjuANyt+D1E+fYWQlqrXV6IuJlOZ2nYG6fynnq6ioTYS97Yp03ARpRrA8Tx5n1E08rxvGpqQhSts4c2koub7KTqIqRoIGU/fX894s6jarw6T50VadoFVE1Z1JXbhyvZld7trXnZuJmW0U8nTC5yxPHpm2SNbPkrBwexZlUqIrFVHD3bpct02ellHullO8Hqqp1pZQJKeUT5T/AfsAG/qTG7T216fieMk5WMgUKlt2xxPFmnZpyBsL2Hb6Y5aIZIj6dRw4NA/D5l50tcdEOtGBvJ3fS1g+cY7cYz51k9QPnuJWFxemoj5nVnX8+m1Uy5xQoBTwa6TYXxTdKBXtnHLuMw7yVR9WdxZeZ1a0Nhmtr1/ja1a/xyVc+yR889wc8dvmxjjym8rSxq6yZ5ZXFylPD5smwlJJLq411EiTyiZrn6Pn0PGZhmOT8Bykql9AVoypZfGz4GB6t+2nwgbqrfpxbmZbNQjLHZJtm2W7QaGiXJI4zxaYDapNRX8PhtFbk7srZN9z4+8RNsPfT+x3g4kKKiE9nNFj5nRoLGPzFP3gDP/G6/W3d/onJMMmc2fSCtG1LVjOFpnu0tpJX86IpBpZIkMx3ZmdqI9rclxPPx0vFeH7dGccKIdgb3ksy6/g67SSODU3i1Z3f3zPS/OfgUOwQQSO4/YFd0sA47oBG+jRxPNRiqmgy4kVKWEhu/4Z+5uoKDx6ItV1y1KrCPh0h6KsSh8x6a3iz5XjgJI6Brmy1vuGeTDuZOF5fbeyn936/yGVYdkp+ze8Yx3YRqS4hkBXGsUT2LHXc7v1cWrnUlvFs2VbF1lw3SZU38+jC2f0wFvagq903yLotKWUr++p/BPi6lLLaZdhhuRikia4ZxxHSBYury90rp9oNWssW0RSBT1cZDXk4OhZkLpFDCJraWtqq3AXKfuAcuya6y1dM9gHnuKXEccxJHPfb9vHtlMg6HMygR2vbtG8Hw9asAnoAVah4VGecU7AKKFocRJG5+NavwVxqjnNL51jOLmNLuyoB3KpqGcdAxW1btlWVSga4vHK5ofuQ1DaZb65YrM3+NBIF23gBn1b5Hb7TSaiBOqeYa6T1Efd1PpnHlnRt0bmfNBbyNDQH30nZtiSZN5tKHANMR73c6iLj2B1zNJU4Xt+93E/IUYALCymOjgVreix3T0fa3tV6Yr0gr9ldesmciWXLLiSONWySJLMFXll4pSPnzO1UjqpIFVIUrSIZM1N6TABBI4iu6iSzzpitHeMYHFyFEJK7Jpofx9wzdk9b992uBsZxB+QyjvupJGyljdZpt7RoO87xTDzLrbUcD+0QpgJAVQRhr068j1YJXcxEK4njibCX4YDRlXKnGyuZ0jahTmkD09I/7/1+kJRynWHZWf6TrjiJ47yVJuy3Koxj6B3n2N2y2qiurVW2xuatPBdXLjb8+0/efJKXF14u/bsKU1FIYUubol3EYAyA/UORph7j7SIhxF3A/cAf1TnkkhDCFEKcF0L8bA8fGkApadKtyd/Jqe4tvu0mJdbbzt0Jx+sOO6njsFdvuJCtHbm7kPrBwF9b5z33VeI4ZzZ9ftgT85Er2iz32eR2O7kmecDTPqrC3dnXC1SFEIKQJ1RK0GaLWYSQqPoSy8nmXjtb2hWldq1qNrX9baQKqZqLC8vZ5SqkRT25JXiubiybzF7/YQDCE/+FnJXEq1d+hx+MHtzRJNRAnZObJFzpo7nV7Hoq8o4wjsMellKFvt45lSqYSNn8QvRkxMetLi6AtrK71k3Y9xP2EpzE8eZivE7q+EQIIWi6IM/1u7ZKHLslqYdjhzk1eor9ka3T0U7iWANhs5JJkbfynF0829TjakXlu3PcYry8mcejekoc4WGfM34uJY797RnHY5Eie0fy7ImMNsUqng5NM+wfbuu+29XAOO6AAoaKR1P6KnW5ki4w1OLAejLitp5ubRw/fdXZRnB6h4rxXMX8en8ljteZYD69+bSpEIJT0xFenulC4nglw96YD6WDpoGbtl/aZRPZbitv2hQt2VFUhV93EscSSSKfIBY0q4zjXiWOm2EUL6QX+NrVr2FvCs6+slBFXairiysX+db1b/EX5/6CeC5eVYyXzCdL5UWaPYlQ0hyITTd8+7eZPggUgU9tunwW+GXgbwPvAZ4Afk8I8b/XuyEhxM8IIZ4WQjy9uNg+lxpgbj1pMhHuzuTv6HgQTREtF37cLtpcWvO6dVxFrAfFeABeXeX4RIjHLzXPcOu0NieO+4Nx3Fw5HmwY3zO7qCCvYNpkixZhr07A0Ejn25twbSSOe4NDCHlCaIqGT/ORKDjfKaq+RCLd/M6tmeRMW48lnos3xEreXPZTrkZxFeVaTmr86bf2ILCJTP5XLHUGicSnVW4Fv3f83qZve6D+VKl4vI/G9u6cdOpOQFUEPVi27CvjfrPW1ufdzRvHXnJFu2sm7fWVDF69uZCUG7Trp8TxcirPSrrA4dHuGccBj8aB4UDTeEyXvz28xXn41NgpfvDYD/KOw+/gTfvfxDsOv4OIp36gx6t50VTHmF3NOrtIX5x/sWru2GmVny9LxrGVLyGqAGI+JyCZzLSPqgB414MrvP8NS+iq3pQR3A/n2IFx3AEJIRgJevqiBMbVSqZ1VIW7hXi7xPHjl5YJeTWOT+xsUUHUb/RV4jjbBuMY4O6pMK/OJ8mbnYX0N9sy24g2UBWDxHG5XKOilXLKevJpPgzF+UzXM47nU91PHCfzSXJmY1voLNvim9e/SdEqVqWUFzOLDRnda7m10ol9LjXHJ1/5JM/PPV/5mAobj0m196LpKYZ8O7ugtYP6IPBFKWUFIExK+QUp5b+WUn5RSvnXUsqfxGEg/3Mhai95Syk/KqU8LaU8PTo62pEHN7uWQ1NEaadOp+XRVI6Oh+74xPFm4/i168ZxtAfFeK7ecXKcp6+t7rj5UMU47gNURaJFVAWwqwrykuvnwpBXI+TVSLWZOO4lqgIgbDg7GCKeCKlCqlSQVygEuLbaXIJ4JtGecVwPU7FZm/nG5WrFOH7+cpCiqRCZ+q9oxnLpXOstQ1VMhaZ2PAk1UOc01IeM49m1Oylx7PyN/VyQtzHPaZ7VD3QNV3F9JcO+IX9TCM1oH77fLy445unRLpdBnpgMcXauufHytRZwIJqi8ZYDb6l7vVfzoivOVCSec85hyUKSSyvNn7OaUd3EcRmrf8jrzCcTWRWPbmNo1Wn5zbz/raSpoK/fxkRgoqHfGfYPMx3e+UDUwDjukIaDRt+gKkzLWclrdWAd9mr4DXXbxPG3Ly3xyKFhNHVn30ZO4rh/vuzdxHHLxvF0BNOWvDrXWAN2o7qxfjLtpCI+Z9tzPxVD9oPcrdCdRFV4NS+G5nymU4UUQV+GXFElW9j4/GXN7JaTxk6ombTxC/MvlLbGzqXnqq4vx0/U0/W16xX/tqRVheRwW3ABNOsQQd/OG0M7ISHEa4AT1MdUbNafAkPAgW49ps2aW8sxHvZ2FZdwairMmVtru44F20klcpXswaGAwWv2RkvmYy/09hPjWLbka6/2tH+xSon17+N+SRznTYuCaTc94d4Tdc7fuylx7J4Lwz6dgKd943g5XUBXRUcXZbdSyONM2sNex0BO5BOo+iKg8K3LrzaVhlrKLJV2xrSiho3jLRLHyXyy6QXm+biOx7uIqjtrkW5xUHnieMA2vr0U9ukoor8Sx7fiOUIeraPj6n7VWMgxrfq5IG8tu1HA24zccsNb8e4wnFuZ60bXd2L1E9P7gmscj3UX/3NiIsy15UxT5+bryxlURTQ9npwKTXFy9GTN6xSh4F3fqZ3Mb+ys2RwU6qQyxQyW3AjpxXNxLNvCklap2wAoBZGSWbVm2lhXdA7FDrX0GCZDkw0dd+/YzqeNYWAcd0zDAaNvUBXx9S/zVo1jIQQTES/zifpf6jdWMtxYyfKGwzufMIj5jb76ss+uM45bKccDx/QAeOVW5zjH8UyBRM5kb6yzxrGiCIb66L3fL0qVjOPOTW6FEKX0U9EuouqOIbua7C2uolG+8Up2peKEP5eqNo4vrVzaNr18I3Fj2/uK5+LkzJyz4mtOEPHfsYbhB4Es8OkGj5eb/tt1zSVyXSvGc3VyMsxSqtDXk65uyykkq/xu+K8/9RC/9jd7V6xxz3SEsZCHx87ssHFclTjeWeM42eL5IezTCHq0XZU4Lk+lBTxa24zjlVSBmN/oWSFz2OOcc4N6EFWojnFsOPzf1ZSXlxZeavi2JLJh87eWGv1dtyy2nppJHUvpGMdSv1m6LF1M41E9qMrGGHc8MN7wbQ7U/1IVQdRv9BUqYXYt2/WxQ79o1DWOt5iH77QSWXdRsLnz2NT6azjbhcSxlJIbKxn2NDnX1VWFsFfrqxDaxYUUAUPtesLeLcg730Tq+NpKhqmoF72F4OAjex4hoAdqXhcw3HDURjfGcnaZG2vbzwNb0eagVXkIyTWONUUrjQNSWZWQr3oMM+QbYio01dJjmAhObDue8et+DsYOtnT7ndbAOO6QhoOevtmu34mtfBNh75Zf6t++6Ayc33BkpOX76JT6DVXhJo4DRmum4b4hPyGvxssdNI5d8H03IPvDAaOvMC39oG4kjgEiXocPVbSK2KpjxK6me1uQ14gxbUubb177ZkUaaz41X5UAtaS1ZfmBZVvbTpYt2yJZSJK38nhUH9L2E6s9JrkT9EHgs1LKRrcrvA9YAq5td2CnNLfWfePYXXxrtin6dpJbjleuoYDRdDqoHSmK4NET43z91cWOo5eaUTJnYmgKYZ+GroodL8dr1TgWQjAd9XFzFyaOQ17H9O5E4rhXmArYMI7dory1/BqKtgiiiFWY5Pm550kXGi+AbJVzvJZba4hvDFujKgCurF5pOCm9llHJF1VUw8FySCmdHU9lJXgBPVCxrXeg20NRv95XoZzZtVwprXq7ayy0jqroE1+hltwF2WZ3zowEPeiq6ErieCVdIF2wWtpdOxQw+opxfGEhyZGxYNcXSU+2MF6+vpxm/1BrEy1DNXjz/jfXvC7ic973WbNyjPPc3HMt3dd2SuQ3/uZsMUvOzFGwCqXHCRDzxkqvQTKr1Uwcx3wx9oT3tPQYDNXYFq14KHaoqRK9bqo/HsVtoOGgY571w9ZYN/053I5xHPFuyTj+9qVlxkIejnR5C0Ujivl10gVn62c/qF1UhRCCU1PhjhbkuUVRp6bqg+lb1UjQ0zeYln5ROdexkwoaTuqpaBfJyZuAbIhz/NL8SxStzkwANret19Kry69WIS0KVoGV7ErVsWcWz9T93ryVvIVpb200JPIJpJTkzTyG4mwrHgm29tnrRwkh/EKI9wkh3gdMA6Puv4UQ/rLjHsFBTtTEVAghPiWE+GdCiHcJIX5ACPFx4APAR6TscvvEuqSUzuSvS8V4rk52YdfGbpKUsopxvFN6x8kxUnmTJy9Xf/Z7pUSuSNirI4RwzMsdN47Xzw+e5l+fPTEfN1cbMxD7QSVzwacT9GjkTRvTav3rZiWdZ7jF4udWFDJCpUljxBOhaBfJWxk0Y45ifoqiVeTJmScbvr2biZvbH1RDzSSVk/kMxVz99FPWzPL83POcWTzDs7PP8p0b36n7uObjznOtrRvHeSuPJa0K4/gO7hO4rTXkN/oqgXkrniulVW93+QyVkEdjIdG/c6t41nlvRJss3FUUZ1fzrS7snLneAnvXVbTP3u8XF1IcGet+h9RkxEvEp3NmtnHM4bWVDPuGW9/BvD+6n4PR6gRtyPCCVMmZlWOcW8lbXdlNW7MYbx0n5S6Guuc3y4ZUTqlpHA/5hggawdJCc7OaDG6Nqzg8dLil2+2GBsZxhzQS8FCw7B3fAgkbcPdYG8bxZMTLfDKPZVcbOlJKHr+0xOsPD/dsu+BWiq7/nf2SOs6uG8etoioA7p6KcHY20dYEq1yv3FpjLOQpbX/qpEaCA1TFZrkpq6Cns8axX/djqAYFq8BqbpGw36oyjpcySxVpoqXMEo/ffLwh5MN2WsutlbbxbKVXFl+peXktXEWykKziGLtqFFNh2RZFu4ghnObbkdDtYxwDY8An138eAU6W/Xus7LgPAmvAX9e5nfPA3wE+tf67J4GfkFL+dncedrUSWZNs0ep64jjk1dk/7L9jC/KyRQvTlj1NF9fT6w+P4NNVHjvb/eLOekpki6XttCGvXjJud0qtJo7BKcjbjaiKkFcjsH4+TOdbT5+vpAsMbdHk3mmpiopfcybI7qRwLb+G5rmFlZ9CSsHl1csNJ4njuXhTCWVXV+JXGjquaBVZWzvI2q2f3dI8dg3jZ2ef5cziGV6cf7HmcfOrOmCjGc7n18VglG81dhvnB7q9FOujBGbBtFlK5ZmM3BmJY3BwFf1cjreaKaIpoqV5zlTE1xVURck4bsHUHA97tu126pXWskXmE/mehPOEEE5B3mxj4+W1bJF4psj+NjuTaiV0/R4fCkHyVvV748zimbbur5ZqFuNZeRShoApnHukax6mcCoi6xjHAdKi18rqJYP2CvKg3yqi/M+XkndDAOO6Q3AREPxhoy+lOJI59WLasWXp2fj7JUqrA6/sAUwFO4hick1g/aCNx3LppePd0hLxpc2mx+QlGLZ25lSil8DqtfsK09ItabRveTj7Nh67qFO0ia/k1ooFilXFsSauUCjZtk8cuP4Ytba6sNjbx3EqNFOPNJmdLhXibVcs4Bnhm9pmaqeN6hnK51vIbZrYunZNr2L9z2+I7LSnlVSmlqPNztey4/01KGZVS1vwwSik/JKU8JqX0Syl9UsoHpZQf79kfAswmnMFgLziFJyfDd6xx3GppTTfk1VXedHSEx85Uo2p6pUTOLH0XdwKX0K42dqQ0//pMR30kc2bpHNPvKi/HC3qciVgy3/pjX04X2hrbtiK3GM9QDXyaj0Q+gea5hZQerKLT89FMgU+zuIpUIdUw4zFZSGIVHSM3n26cZz6bmq3JRr6xLFH1JYTivI7pQhpVqHi1je/wQeL49lQ/JY7dzp3J6J2ROIb+N47jmQLRFnnzU1FfV1AVN9aN41b6fPYPB7ixksGuEZjrtS6uF+Pd1QW8ZC2dmAxzfi5ZMyy4WdeXned4fxuJY6i94OhVvagySMGu3lV1ceVix3bOuqqZOLbyeFRP6X1dKsbLOOOXLY3jcOvGcb3P0eFY/6SNYWAcd0wjQScB0Q8GmtuCG/W3kTgOu/D66i/2b19cBuD1fVCMB045HtA3A5xM0eEpqkrraey7pzu31TpXtLi4kCpxPzut4aBBumCVktYDlSWOO4yq8Ot+dEV3GMfSxu9NVRnHsMEhfvzG46WT4bW1a001wNdSI8V4W60Kz6VrG8cL6YWqiXcynyw99q0Uz8VLW4t06Zy0a53YB9p5xfwG/+f3HeOe6c4jczbr1FSY6yuZXWOwdVJrLbIHu6W3nxzn1lquhEzqtRJl2I6QVyOxw6iKRJuJY4CZXcI5TmSLCAFBo/3EccG0SebMnjKOgVIpLTip41QhhTCcRU0z76R651JzDTOIZxLNGcdnF88iG+wvTRVS2JZjNhRSJ5GysXGolJKLKxerLl9Y86B5Zjduv5giYAQqJrkD4/j2VDTgMI77AcHoYg26XRTWTxoLe1lI9kcCtpZW08VScKtZTUa8zCdyDRmVzej6SobRkKelHb97h/zkTbsvSpUvLjiGZq9woCcmw2SLFteWtw+rXVtxjtnXIuPYVcxbwzjWvKgigGlXj29M26x5jmpHtRLHBatQKsaDDYM7mV03jjcFk7yaF7/umOitJo69mpdjw8dqXtdPmAoYGMcdk5s47oeSsJV0gZBXw9Baf3ndRFgtzvF3Li6xf9jfdGtpt+TylfoFVZHJWy3zjV0dHAniN1RevNm+cXxhPoVpy67wjcHBtAADznGZkjmTgKG2tXhQSz59I3EspUTTV8kWVHKFyvtZSC9wLX6tAhlRsApNT1g3a7vEcbqQ5tpa/Z61bDHLWq72e/qpW0+xnFku/btRtEZ5C65m7UXXcmi3Fani9tF42MvPv/UI+4e7317oft+d3SJ1vJDM8Z1L2zO7d5vctvN+SBwDvO34GELAY2c6z6hrRA7j2EVV9APjeD2F22LiGHaRcZwzCXo0FEWUjONWE99uOKAbxvGh2KG614U8G5zJiCeCRJKxr4AolIxjKWXDu3qaSRxLKTm3dK7h45P5JLblPF7bimLmGy/subByoeLfmbxCvuBDNZwFX9M2yZk5gvqGmaEIhYin+wuBA/VeQ36DgmWXdlHupNwQ0x2Fqgh6+sLErKfVTKEU3GpWU1Efpi07nqi+vpJpiW8MG1xkF3exk7q4kMKjKT3zWU5OOoujf/bs9uema8ut40DK5dN9+LTKz7NX96Liw6T2a9DMuXA7SSkrEsfJQnKjL0dz3tcBPVDaXeMax2Ff5fil3AD36b6WF1JPT52uKpkdD4y3zE3ulgbGcYdUShz3gXnWia18G8Zx5eTEtGyevLLC6w/3B6YCyhPH/ZEsyxQs/Hp7zpWqCO7bG+Xpa+0XCrmpZffE0Gn1E6alX5TMFVvahrydfJoPQ3Geb9M2kapjxKymKu9rJjHD165+rer3G+Uk1pKUctvE8dmls9ummmeTc1ye81IwK81uW9p85cpXSr/fCKYCnHK8nJlDUzSkNYbfO3gfDkRph0UtXIWUkk89c5N3/OY3+LH/78m+2CnUSZUSx77O7nhoVSNBDw/si+0Y5ziRNUvfxyGv3hYqoRNyURWt7EhxJ5K7hXPsFhMChEqJ4+2NY9Oyq9JoLjptpMPleALBG/a+oWoS66p84hYwAihCIVGIoxmzJeMY4HL8ckP3lyqk6i6gbta1tWuki40jy5KFJLYZRPPMgCiSSR5lNbvKfHp7VMxabq2igOj6knMudhPHLpu5vBgv4omgKoOV2ttRbk9OP3COb63PRafuIFTFWNhDpmA19H25E4pnik0X47lyX8dbHeYc31jJ3hbG8YWFFIdHgx0PH9XTqakwP/iaKX7nqxf5d184t+W54vpyhpGg0ZEOn824Cp/mQxU+LJmuOZecT8/XRSE2q0wxU3EfWTPrzKuRpcRx+eNLZjV01cajVz43m43iqVD9boGt5NW8nJ46XXFZv6WNYWAcd0yuedkP5tlqutBWMR44K82GqjCbqEwcv3BzjVTe5A1H+gNTAf2HqsgWzbaK8Vyd3h/jzK1E2zzGM7MJgh6t5ZPpdhruo0WTftFKutDygGor+XU/uurcbsEukBdOE/pmXEW6mCZrVg/IrsavtrztMJ6LU7TrGy6WbXF+6fy2t3N+Fv7kW6O8fK36/bicXeapmaewpd1QOjpdSFOwCuStPF7Vi22Fbyu+8UCtazTkYSRoVBnHt+JZfvpjT/FPP/kCuiqQsj8mxp1Uoo8Yx67efmKcl2bWulKIs50SuY1yvKBn5xPHiWzrO1JGggYeTeHm6s5PbhtRMmeWkByBJozjD370CX71c2crLnM/p50uxzsQPUDACNSd8JUnjhWhEDbCJPIJVGMGszCJlM5UaiG90HDxXaOp42YLgVKFFKblIaF+hgXvL3Cx+Jtcjl/mZuJmQwb0heWN1PHFeWf8r60njlNFh7vpbsuFAabidtZQH82t5tZyRHx6W90xu01j62Xm/Zo6bidx7CbHZzvIOS6YNrfWsuxtca47HfWhiD4xjudTHO0R3xicgrzf+sB9fPChvfzuVy/x4c+8Upf1fG0l3TE/YTOuwqN5UPFikSZXrP3eOLt0tublzao8bVy0ihStYmn3qmscl5/fklmVoM9iM4p48zmwVVwFwPHh44z4nWCmIpQtd0LtlAbGcYdkaAoRn94XyaVOJI4VRTAe8VShKh5f39b7ukP9Yxz7DBWPphDvp8RxBwY3pw8MYUt4/nq8rdt55VaCk5NhlC6tXLrvtX7AtPSLLi+lOTTa+HZ8RSgVZTP15DKOwTnRZSwnlbtSg3NcS5lihvl0a6m/7TAVl+OXa5rVm3Vl5ggAy8naptbzc8/z/NzzW5rUrkplBmYej+bBNsPEAr1ZoR+ovyWE4ORUhFdurWHZkicvL/Phz7zC9/7WN3jy8goffs9J/v37XwNsJHRvF/VTOZ6rd5wcA+BPn77Z0/vNFS0Kpr2RevU65Xg7ye1sZ0eKEILpqK/pxPHnX57jH/3Rc6XyoF6pnC/tJpSSDRjH5+eTfOti5TlnwzjubOL45OhJoH5SqJxxDE4CuWAVsI2zIA2sojPRk1I2vKvn6VtPb7uDp5lSPFeJfJKUfJFF+TlsZZGw+Tc4GHgDAtFQZ8Dl1ctYtrP4emtVRdHiKKrzXksX0vg1f0XCuFbB0UC3h2IB53PbDwurt+K5O4pvDM7iN8BCov84x1JKJ3EcaDVx7BjHtzq4c2YmnkVKWjY1DU1hMuLjegOc324qUzCZiWc5Mto74xicnc7/5ofu4e+98SD/7fFr/MKfvohpVad+ry9nOoab22y6+jQfquIBYZEo1MbMXVi+0HZfDzi7VV25/QRuX46LjNhsHG9VjOdqKjSFoLV5qBCC1+99vTPOC0835Av0WgPjuIMaDhos9cEJdjVd6MjAejLsqyrH+/bFZU5Mhksp035RzG+USgF3Wo5x3H7i+P59URQBT11tHVdh2ZKzswlOdqkYD8r53ju/aNIPKpg211cyHG7ipD/sG+a+ifu2PU5VVAKGc8IuWkUKMk3QW6xZkFdPjXIYN2u7SW4jySgzP0kufQCoTkm7kki+O/Pdhh7TWn4Ny7Yo2kU8qh9p+4l1H5870C7RqakwFxZSvPbXvswHPvoEf/Td67zlrlG+8L+9mZ96w8FSWqZbi47XlzN89Xzvub6ucdwNXE6rOjwa5O0nxvkPX3qV//5kfQ56p+WWI5bMS69G0ZLkzfYnHq2qPIXbiqZjvqYZx5944hqfeeEW3/tb3+Bj377Ss+b4RM4smfaNJo5zRYtkzuTiQqriWHdHX7vBiHJFPBH2RvYCMBmarHmMR/NUsAdddEVWOLzFclzFpdVLDd1vppjh0+c/veX5uJlSPFeJbAFTLAKCkyPHiVk/hlF4lKARZC2/PR4jb+VLRbqJVBjNcDAVUkrSxXRp/OFqkDi+fdXt82Mzml3L3nHG8fh6Sf1cHxrHmYJFwbJbThyHvRoBQ+0oqsJdFG0nDbtvyL/jieNLC45x3cvEsSshBL/0/Sf4x48e5VPP3uRzL81WXJ83LWYTuc4ljjctPHpUD5pwxgv1kBRZM8vV+NW277u8GM81jguWM8YwVOd93Ypx7NE8pdRwKxoLjHHX8F0ciR1p+Ta6qYFx3EGNBDw7njiWUrLSAVQFOJzj8sRxrmjxzPVV3nC4f9LGrqJ+vW8Yx9kOGcchr87xiTDPXGud53NtOU2mYHXVOPYbGn5D7QtMSz/o+koay5ZNJY7HAmPcPXZ3xRbQenInrW4i1+9LE2/GOG6Rc7xV4nghvbCtsQyQib8BIXKMD600ZXbXU3kxno4zABmgKgZy9da7Ron6dF57cIjf+dH7efaX38Hv/tgDpVIPN5HbrcTx7371Iv/r/3iuK7e9lRK5IiGP1jM+XiMSQvC7P3Y/jx4f45f+/GX+8PGrPblftyiwVI7npl53EFeRzBfbM46bTBzbtuSFG3HeeWqchw8O8eHPnuEDH32cy4uplh9Do0qWFRMGPM64aDvj2E042tJBbZVfriqio0l6N20MzgSwLue4LHVsqAaaopGzFxEiX2EcL6YXSRUae15N2+SLl77IC3MvVF3XbCkeOGmpXMGDKebRhR9FNTH8F8inTxLxRMmZuVKiaitdWLnAzfgiZnEIzeNgKrJmFlvaFXxjuD2NYyGEJoT4RSHEBSFEXghxUwjxW5uOEUKIDwkhbgghskKIbwgh7qtxWyeFEF8WQmSEELeEEB8RQuwKKPRQHzGOZ9dyTEbvnGI8cExMIeDy4s4mYGvJxZfEWkTyCSGYjPo6iqpwDd+9Q62/T/YP+7m+srP9ARcWHEPzyFhomyO7IyEE//jRo0R8Ot++WFkefXPVSXXvb7MYz9VmVIWu6ujrPT7xLXoAOlGSV46qKCWOrTy6oqMIBUUoRL1RwBmLpLIq4U3GsV/3VxXaAUyHK3EV7pihUT009RD7IvsaPr6XGhjHHdRw0Nhx8yyVNylYdkcSGRMRL3OJHLmixXevrPAbnz9HwbR5w5H+KcZzFfMbxPuAwwXONpNOcbhOH4jx7PXVmttFGpHL9zzVReMY3Pf+IHEMcHF9tbiZxPFYYAxN0bh/4v5tjw0aQXRFL62M6ka8YVQFONtzVrLNpdillCxllupe9/jNx7f8fVvaWMUYhfQpvOGnMbyzxNMaLb6tS4rn4uRMZ+CpMw5Qc0V4oDtTrz00zDPrZvEP3DtVSjy6cjnk3TKOLy+lSOVNcsXevifXyvAA/SSPpvKff/xB3nFynH/x6Vf4L99qvayzUSU3JY7dFLZ7+U7ISRy3/vrsiflYShUafl9dWkyRzJu84+QEH/vph/j3738N5+eS/P1PPNvyY2hU5agKj6ZiqAqp/NaPu3wc/eLNjcnjcrpAzK93DLulCpXjI8crLquXOi7nHAsh8Gt+MsU0qudWhXEMDu6hUUmc8+cXLn6Bl+Zf4sbaDZL5ZNOleOCgLWwrhCkW0BXHPPEEXkZaQfycAmgodTyTmOGFmUVAQV1PHLtmeLlxbKhGlZF8m+hjwD8C/j3wvcAvApvdpF8Efhn4DeA9QAp4TAgx4R4ghIgBjwESeC/wEeCfAr/S3YffGYW9OorYecZxrmixki4wdYcljr26yt6Yn0s9WOBrVm4KPdpi4hgcXEWnE8eGqjAeav19snfIz1Iqv6OFhBcWUuiq6Jg524oURfDag0M8cblyrnh92TFYO/XYfLqvarHWu27ErmSStX4FgBtrNxruE6in8sSxi1nMW/lS2jjqjaIIxybN5BRsKQhtCibVWzh1OceKUDg1eoofuftHqsYaW8mreUt9Rv2mgXHcQQ0HDZZ3eGV2Ne18mbe6faRcE2EvBdPm3g9/kR/+/cf5r9++ymsPDvFIH/GNXcUC+o4PblxlC1ZHyvHA4RxnChbn5up/gW6lV24l0FXB0S6vXA4HPDv+3u8XuYO8Q00ax+Ckn7abiPk0H7q6YRyjLpItqOQKjU+mm8VVrOZWMe3aA6lzS+fqpo2llMyl5nhu7jlmVz2AjTfyBHluIqVgLd3eAstabq2UoNKlM+EP+/qzgXqg/pNr3sVbNI4/+o1L/MR/+W5dXu6VJWeQXS+x9Uffvc7/8odPU+gwNiGRNfvSOAaHI/iffuwB3nX3BB/5yzN84ZW5rt5fIucmjis5u+2WzrajTqAqgIZTx8+t9yTctzeKEIL3PbiHDzy0l2sr3U2y2bYkla/8WwMelVR+689bOfbqpZvx0v+vpPMd5RsfHjpclRaqyzn2VC6++3U/WTOLalzHLEyUCvKgOePY1ZX4Fb5949t87sLn+O8v/Xc+f/HzTd9GspDENoOYYh7P+qTT8F8AkUdkH8Gjehoyjm1pc3XRmSC7ieNUIYWu6KWOBbg9+cZCiO8DPgC8XUr5+1LKr0spPyGl/FDZMV4c4/jfSCl/R0r5GPB+HIP4H5bd3M8BPuCHpJRfklL+Ho5p/E+EEN1Nc3RAiiKI+o0dTxy7O1/dQrU7SUfGglzq68RxG8ZxxMutDiaOb65mmY752lpYdBEMN3awfPbiQooDwwF0dWctukcODXN9JVMxzri2zn/eN9Q5JuDm84hfd4z/pUy87u9IJJ999bM8N/tcwzt8Nquc+e+a0G5fDmzGVKyXK2+aX9YzjidDkxyMHuT9J9/Pm/a/CZ/u4zXjrykZ0btZu/8v6CMNBzysZgotp0M7oeW0M+B2ubPt6M13jfLmu0b5qTcc4P/9idM898vv4H/+7Os6Zop2UlG/0RccLoBMsTOoCoDT+50v1FY5x2dmExwdC2Fo3f2ojwQ9fVWO9/yNOP/HJ1/oedIPnG1l42FPyaDYToZqlE6cqqLywOQDWx7v1/14NW8paVsUtwCIN2HCNouruBavzSTNFrM8fevpmtcVrAIXVi4wk5xBEQrLxWcwgs+haknyOIU/7eAqilaRdDFNzso5k1nL2QkRHCSOB2pQqiIIeTUSLRjH//GxV/m1vzrHN15dZLHGbotkrlgywOpNvL9+fpEvnZnn1/6qMy3RrhLZDTxAP0pXFf6fH7kfQ1VKpma3lCgVBa6jKrx9gKpooxwPYDrqTG5vlnGOX55Z4+N18B/P3Vgl7NU4NLIx2Yv6DXJFu6vnyHTBxJYbpj04nOP0Nolj93NzfCLEizMbRudKh/o7XJ0aPVV1WaPGsU93TCxLPwtSxyqMlq5byixVFO/0Ssl8EssMYollPLozBhVKEY//PPn0CSKeqHOMvf1rbhYmEEoGRXWe/3QxTdAIIsoq5Ye8tx+mAvg7wFeklFuVNrweCAN/4l4gpUwDnwXeVXbcu4AvSCnL3wx/jGMmv6Vjj7iLivn1HZ9buanUyeidlTgGODwa4PJiCqtHTPpG5aIhW0VVAOwfDrCUyndst+pCMsd4uL3+Jdc4dpO1O6GLC6kd4Rtv1msPOd/vT15eLl12bSWD31AZ6YDH5Gqz+eo3nM/5ambrc2g8F+fJmSf5xIuf4NPnPs1CuvE+EdM2K3b0uCgmpy/HeQ+VG9rJrHM+3YyqqGcca4rGO4+8s+I2Qp4Qh2KHGn6M/aqBcdxBjQQNpGRHWbvuKuBQoP3yuiNjQf7w7zzMh959gnecHO8IN7lbivl14tnijjalu8p0MHE8FfUxHfXxdAucYyklZ26tdR1TAc57v59QFZ978RZ/+sxN/u3nz/f8vi8tpprCVIz6Ryv+fXzkeNUktVw+3YdX81K0i04xnJgBmjNhV7IrTbXS1iv8eeLmEyXGcLnWcmucWTxDuphmf2Q/E+r3YypzmP7PAKDqzkJIM4iNzYrn4wDkzBxezYtlhvEZRbT+W9caqI8V9etNoSqklPzmF8/zHx+7wD3TEcAZ6G/WtbKJRz3jeDmdRwj42Heu8rkXZ2se04oSuWJHObDdkK4qRPw6a9nuLjiWyvHcxHEfGMdOYVwHEsfrxvFCMsdPf+wpfvnTr1T0Urh67nqc+/bFKpJYblKsmzu1Smlv38bfGvRo26a93d1L33N8jMuL6RJWZDldYLgDY1uAEf8I48HxqsuHfEM1m8w3n6fdPoKC4pwbzXwl0/Ds4llurN3gzOIZnrz5JGeXOrs4VEvJQpKCZYOwMdSNE6EROI+0A4TUg0hkBduxnqzCJJpnFiGcReCCVagqxrsdE8fAa4FXhRC/I4RIrLOJ/0wIUb6icBywgAubfvfs+nXlx1XAOKWU14HMpuP6VkOBnU8cuxzcOzFxfHg0SN60udUE074XctGQ7aAqHj7ofH9890rrBfDlmk/kGWsDUwEbCIadKsjLFS2uLad3jG9crhMTYSI+nSfKjOPry5l19nbn+jM2c46DhgekQiLfeNJ+NjXLkzefbPj4tU385EwxU9rF6xrHw76N3fWucbwZhdgs4/++ifuaOr4fNTCOO6jhoPNmW9pBA81lww11AFWxmxT1GVi2LE1UdkqmZVMwbfx659JeD+6P8fTVlaZN8YVknqVUoavFeK6Gg87gsldN7dvJLZP4L9++UgX376aklE0bxy6mwpUiFB6cfLDu8eVMqJyZQ9FcE7Zxo8iWdsOc40Q+UZNvPJOcqWkoF6wCF1cvYqgGJ0ZOMOydQE//KBoRlvIXARBKGlUttJU4jufiSClLxrG0IoT9O7fbY6DdqYhPb5iPL6Xk337hPP/PVy7ywYf28vt/2/mc1jKOryxtDHrrG8cF3nFinAf2Rflnn3qxY2Vla9n+N44Boj69hNfqlkrleOvPR3iHGcd506Jg2m2hKsZDHlRFMBPPYFo2/+iPniu9h798br7i2FTe5NX5JPfvjVZc7ibFuvn8u89xebo66NG25Ucup/L4dJXXHnQmZS/POMmjTiaO7x67u+51k8FqznHUG60wlD2qB0UoZO0lhJKt4hy/tPASX7j0Bb5z4zu8tPASF1cuduRxb6VkIUnedJ5zj7bxPKmGg5vw2MdRhVqxRbeWpFQwC2No67/nbuMN6rd/MR4wAfwUcB/wQeCngQeBPxcbbkkMSEkpN0e3VwG/EMIoOy5e4z5W16+rkBDiZ4QQTwshnl5c3L5suBeK+o0dxwDOuonjO4xxDHB4zPnMXewzzrF73oi2kTi+ZzqKT1d5sgPGsZSShWSOsVB7C4sRn07Iq+2YcXx1OY0tneDeTktRBA8fHKp4fa6tZDrOXq5CVXgUFILkrXyptK4RzSRnWM4sb38g1az/cuPYZRyXB7jWMiqKkPg9lXPMzab3dhrxj7A3vLep32lEgt4VYQ+M4w5qZN043smCPHeCOtTBbQS7Qe7Ja6cL8jLr2z47haoAeOhAjPlEvmJbaiM6UyrGi3TssdTTcMCDactSumundWUpzVuPjXJ4NMA//ZMXWOvRLoClVIFkzuTQaOP8p83GMcBdw3cRMmqvOPs1f2kCmzNzCKWI18ixkmzOiGj0BHtppdoctmyL79z4Ts3jXUP6cOywk4zOHQA7xLBnH8lCkmwxixCgaittGcdruTVM28SWtmMcm1HC/gGmYqDmFPE1njj+i+dn+M9fu8SPvnYfv/Y372Ey4iXo0Woax1fLjON6/PflVIGJiJff+dEH0FXBz//3Z8kW2n8P92s53mZF/TrxHiSOdVXgWcc17TTj2E06t4Oq0FSFyYiXmdUsv/XYqzxxeYV/80P3sn/Yz2NnKo3jF2/GsSXcty9acbmbFOvmmKlk2lehKrZ+7pdSBYaDRinR/9JMHNOyiWeKHTGOPaqHo0NH616/uREdnEK88cB4xb/9up9sMYPmuYVZqI24cBXPxlt+vI0qlU9RsJ1xopuagvUdPqKIXZwk7Amzll+rCCLY0i6hrwCs4ghIvVSMt5ZfQxFKCc/hqtlJ8y6RWP95r5Tyr6SU/xP428DDwNu6ecdSyo9KKU9LKU+Pjo5u/ws90FAfMI5vreUYChh49TtvO5kbQrlUY4yxk1rNFAh5tLY4vIamcPpArCLR2qoSOZNc0WY83N7ighCCfUP+HTOOL8w7r/PRPjCOweEcX1vOcCuexbYl11cy7B/uHN8YqhcgAx4FRYYxbbPpIveXFl5q6LhaiWO3L8dlHAd05+/MFhReuhpgz4izQ9BVyAi1VGDX6dRxzBvj3Uff3dHb3EoD47iDcrnCLmd4J7SSKWCoCoE+5BB3U7HSJGhnjUt30t9JDvSD+50v1aevNfcF+sot54vxxGT3t7y47/1+4BwXLZvrKxlOTob5rQ/cx1Iqzy9/+uWe3LdbjNdM4rjWdlkhBCdGT9Q83q/7S5NCd7IXCs1ycdZH0Wp81XE529hgrVbRz/W161UnXnBW/ZezywT0QOnkW8gcAVFkPKwjECxk1jlU2iLLydZPQWu5tdLf79E8WFa4ahvRQANtp6jPaNg4PjubxKMp/Ov33o2iCIQQHB4L1k4cLzusc1URrNaYeBctm7VskeGAh6moj9/6wH2cm0vyrz63FVpzexUtm0zB2h2J4x50Ezi8Z720tdJFVaR2aHfShnHc3q6k6aiPb1xY4ne/eokPnN7L+x7cw9tPjPPtS8sVxuzzN+IA3LcnWvH7scB64riLz/9G4rgSVZHc1jjOMxL0MBz0MB318eLNtdLj7ER/x4nRE6hK/TFaPc7xRHCi4t9+3U+mmEHVb2Lmx5Gy/m3mrXwFU7EbShaSmHYKEBUTWiFsNH0BszBOxBPBtM1Skitn5ji7dJZXFl8pnU/NvPN3ap45bGmzmlsl5o1VFPsEjEBVseBtolXgJSll+QDpW0ABOFl2TFAIsfkFjwEZKWWh7LhayY3Y+nV9r/Gwh6VUvuMFrs1obi13R6aNwUGFDAWMvivIi2cKHcFXPnJomHNzybYXJxaTznfXWJuMY3BwFTtmHC+kUAQcHOmsOduqHnE5x1eWmU/mKJh2iQPdKXk1b2kXLTjBO1WGsWSx4XmqqwvLF8gWtw/Zle+6MW2TglUgb+URCHRFx6t5S2OEr78cIVdUePtr4hW30eqOm+nwdBX6qhUJBPeO38v7Tr6P0UDvFhoHxnEHNbLOXputwZjrlVZSzla+TvJndoM2JkE7nDgudD5xfGwiRMij8fTV5saZr9xKsH/Y31ayqVG5afvF5M5zjm+uZjFtycGRAPfuifKPHz3KZ164xaefn+n6fZeM4wZXiwN6oMRK3KzjI8drNrD6dB9CCLyal6zpnCC9oefJFxVenWmcAddI4jiZT7KYqd4yWesycAoGcmau4oRazB5B915F1wRDviGWM8uYtomqL5PIGLTaJRrPxclZ68axEsK2PFXFBQMNtJ3CPp21bGMmYjxTIOrXK1ixR0brGMdLaQ6NBIn59ZqJ49VNu4PeemyM9z+4h794bqatIhy3DK6fy/FcRZtIe7eqRM6sSF/rqoJXV7Y1L7ulWviGVjQd87GSLnB8IsSvvNcpeXv7iXEKps03L2yghZ67HufQSKBqkt8bxvH6e9FXnjhWG0BVFErlO/fuifDSzFopkNFu4lggapbilase57jKONb8SCSWfg7QsArVu4fKtZrtnleYLWYxbZOiXEMjWDV2UI15xzj2Oj7mWn6Ntdwa55bOUbSc18lFUlnFYcBG1ZdZy61hS7tqknybYirA4RTXmkAJwB2tnANU4MimYzYzjc+xiWUshNgL+Dcd17faPxzAlnBzdefKwm7Fs3ck39jV4dFAHyaOi20V47lyjcnvXmkvdTyfcM4P7TKOAfYO+bm5kt2RQsKLC0n2Dwf6Jl1f4hxfWin1dnQaVQGVuIqgR0MhjGnnWck0F5izpMUri69se1w5qsJdRC1YBQzV8c/ctPHsisHzlwM8eDjFWLRyrNrOObDd1LGhGvzgsR/k9Xtfv+UieDc0MI47qIhf59h4qGqrYC+1muls6/RuUbRPEseZgjMh8hudm7SriuD+/bGmjeMzs4meFOMBHFhfHb3UBxwulxN6aD31+/ffepgH9kX5l595BbNVl7Lh+07j1RUmG9wuVQtT4cqv+zkQPVB1uVfzogoVr+YtJYTyykuE/UVeutr4KnUjK7n1SvHqmc7utiL3hGoVI1jFUQyfczvjgXEkkqXMEqq+DAji6eY/K7a0SRQS5E1nhVi1ndXW0ABVMVCTclAVhYYY8mvZIlFf5fn1yFiQhWS+CtNzdSnNgZEAQwGjZuLY3Z0xUna+fu2hYTIFqy3Wscv5j3RgUtdtRf16jxLHld8xIa++Y+V4nUocn5wME/Zq/Ocff7A0yTx9IEbEp/PYWWcMKqV0ivE28Y2hN3ivDVRFeeJYJ53f+nt6KZUvleDdsyfCteUMV9YTd+2Ob/dH9xPybL8LqxbneNg/XJHkLRXkqRcBm0z8DWz1NVKecuq0J5EsJJG2QVEsoSvVC9eaZx5phVDsCAE9wEJ6oaKLIOqNspxdxpY2thVGUVMIYbOcXUZX9Cp01pD3tjWO/xK4RwgxUnbZmwEdeGH9398BEsD73QOEEH7gPcBfl/3eXwPvFEKUP3kfALLA1zv/0Dsv1yQqL3vttWbv4MQxODsY+2FuVS5nEb19r8HlHD9xuT3O8UIHE8f7hvwULJv5RO9DgBcXmuvI6bYURfDQgSGeuLLMddc4Hup8GrrchA16dRQZwpL5plEVAK8svIJlbz3GKN8x6xrHeStf2kXjN/zYEr7wXIyg1+ZNp6p32LZjHB+KHSqxlFvR/RP3MxmqHqP0QgPjuMP6wfumePraKjM71IC63MHykN2kXqRnGlG2C4ljgIf2x3h1Idkwq3c1XeDasoNr6IWmIl5CHo3zc9u3dXdbbinVoXUzW1MVfuiBPcQzRRa7XFx5aTHFoZFgRSJxK21lHAN1k1Fe3YtX85K38s5ED4uJ0WtcXfCwlm7svZczc6XSm3qqxTcGWMpWl+VJKVnJrhDxRNAUxygoZp1Aju53ysd9uo+QEWIhvYCiObexkmz+s5LMJ7Fsi5yZw6N5kJaTohqgKgZqVlG/TtGSZIvbv3dqlc65JSblqeO1TJHVTJGDI35idRiRboLSLdUFJ10J8OLN6kFqo3ITvLsFVZEtWuQaeO5bVSJXzXsOebQdK8erhW9oRX/3jQd58kNvr9jSqqsK33NslK+cW8CyJTdXsyyl8ty/iW8M4NFU/IbaI1RFeTmeSrpg1i3StW3JSrrASGg9cTwdBeDrrzq7XFxDuVXdM3ZPQ8fVwlUoQmHMv3HO9mpeBIKcvYw/9hUK6XvIJR6qe5tu4vjmksF//PQ0c6ud+4ymCilsK4glFjCU6kSYajiLCWZhnKg3iiUthnxDHB85jkfzMOofxbRN4rk4thlC0ZKYtkkin2DIN1S1i/E2Thx/FFgGPiuEeI8Q4keBjwOPSSm/BSClzAG/DnxICPEPhBCPAp/EmVP/dtlt/R6QB/5MCPF2IcTPAB8GflNKmejZX9SGXJ7pteWdQSVkCiZr2SKT0TvbOF5OF2ouQO+UOpU4NjSFB/e3zzleWE8ct8s4Bkoohl7jKoqWzZWlNEfH+8c4BicVfm05wxNXltEUwVQXPovlvPyg4UUliEWO1dzqtibwZmXNLBdWLtS9Pm/mS7t1ocw4NvMlDGRAD/DC5QBzqwZvuzeOR68cryhCYcQ/QqsSQhA0WnudA3qAe8YbG8d0Q20Zx0KIaSFESgghhRDBssuFEOJDQogbQoisEOIbQoj7avz+SSHEl4UQGSHELSHER2owo3aV3nOvM9j87Au3duT+O9k6vZsU8ekI0V1eXyPqBqoC4MEDMaSEZ683ljr+0nri6C13bW1MdkpCCO6aCHF+fueN48tLaaJ+vWJrrnui6zZG5tJiqmFMBWxvHE+Hp4l4qhF5fn2jIM8F+puebwKCl651JnVcD1ORzCdL91muVCFF0S5WTCgLmSMoahxV3zCaxwJjFO0iaem0zN9cbX4w7G4zypk5vJoX23Seo7B/Z1KEA+1euQZrI8iEeKbahKxlHF9Zn2QfGA4wHDRYqbGgWSqyLfueOjwaxKervDTTvnEc7gGiqF25z32ii7gKl3FcrpBX27FyPDcR3u7rI4So2aXw9pPjrKQLPHd9tcQ3vn9f7RKzmN/oMqrCxKsrGFoZG9ejIeVGkXD17xQxbbmROF4vyPva+XXjuA3Gccwbq1l8V0v1JoXluAohBD7dR6aYwRf9FrrvVdLL30cxX5uRvJJbwbLhC8/GKJgKy8nOfUaT+SRWMYApljBqFPZo68axVRhnPDDOseFjHIgcKCEtQkYIQzVYzCxim2EUNcFqdhWJrDKJhRBV2I5yKUIh6o127G/rpdYN3bfhMIj/GPhd4MvAD2869NeBXwX+L5yUchh4h5Ryvuy2VoFHcbAWnwV+Bfgt4F9296/onEaCBn5D5doOMV9vxZ0x+9SdjKoYc8b0l5f6J3W82qHEMTjGZLuc4/lEHr+hlspv25GbqO21cXxtOUPRkn1TjOfqkUPDAPzVS7NMx3xobRQi1lM5qsKjeVDxIbGwbIuVXPOp45fm65fklWMqwDGOLdvCklYpBawT4+svR9g3muPE3sr3wdGho3zw7g9WPOZW1KpxfHrqdCmctRNq99X/d0Ctb7JfBH4Z+A2crTsp4DEhRGmkIYSIAY8BEngv8BHgn+KcWHet9g37uW9vlE8/PzCOeylVEYS9ele3XTaiTBfK8QDu2xtFUwRPXW3sC/QLL88xHfVx93RvEsfgsJjPzyUb2vLdTV1ZTFcVC0yEnUHnXBeN41zR4uZqtpR03k4Csa1xDHBy9GTVZT7NVzKOXVxFwrzK1HCSl64FttwuW66tOMf1MBUuB7HqtrLLFRNGKRWK2UPo/ksVTbRhj/OezJirCCXDbLx5A2c5s4yUkryVx6t6sQeJ44FalGteNoJMSGSLpS3+rvbGfBiqUsEgvLq+6+HgSKBu4riEqigzwlRFcPd0mBdvxpv+O8ofI+yWxHH3C9ocxnHlIDvo1XY9qqKe3nzXKLoq+NLZeZ67HsejKRybqI1m6DYqJJkrVrGcA+sT+3qc46WUm8R3PhcRv87+YT9ziRxCbOwua0V3j93d8LHueWqzahXkOWU8NqGxP0PRUiTnfxjbqk5lreXWeOZikMWE8zdk861PwZL5JNfXrnN26SzPzD7D5dXL5E0FhIVHq35vKWoGoSYxC+OltFN5ilgIwah/lFQhRc5OoGhJlrPLVcVFAPvC+wgY9cc5k8HJHZ3Ytisp5UUp5bullAEpZUxK+VPrJnD5MVJK+atSyj1SSp+U8k1Syudq3NYZKeXb1o+ZlFL+spRy1wxUhBDsG/LvGKpids1JBt7JqIojo87396WF/ijIMy2bZM5s67u4XK4x+d0rreMqFpK5jqSNASajXlRFlNAMvZIbPjg61v1C+2Z0Yh2LlSt2vhjPVfnipEd1jGNwiuua5RyDMx+dTc7WvG5zsXummCFv5Uv3DTAzd5yCqfC996+W5q97w3t5/8n38+ihR+uOD5pRK8Zx1Bvl+Mjx7Q/soloetQgh3gx8H/DvN13uxTGO/42U8neklI/hcKAk8A/LDv05wAf8kJTyS1LK38Mxjf+JEKJ3blcX9N77pjg7m+DiQm/TlwXT+TK/E41jgJhf3/HEcbbYecaxe3unpsI8fW37xHEyV+SbF5b4vrsnelqSeGw8xFq2yMIOF+RdXnJwEeVyB53dTBxfXU4jZePFeDFfrIKXWE/HR46jbtqI4df9eNVK4xggHH2FtbTG9cXGtvNulTi+vHq55uW1MBVu83rUGy0lmMz8HqT0YvgqtwwpQikV+6n6CivJ5j4rlm1xduls6UTv1byocpiAx6ILC+ED3eaKNpE4roWq0FSFgyOBysTxUhohnIXk4YBBPFOoKlpZTuXR1hc8y3XPdJRXbiVa5rGXEse7wTj2ud0E3VvwTeaqE8dBj0Zqx4zjYukxdENhr84jh4Z57Mw8z91Y5d49EfQ6X4xdTxxnzRp8aeff9RLfGwsqG+cwN3Uc9emoDWKgNstQDe4avqvh4wNGoOq8C86OmfIyGr/ux5IWBauAomYJjf0Jthkitfg3kbLysWbzXr75SphDE44Zli20fsL65vVv8sVLX+Tb17/Nc7PPsZxdJm863zGbt9W60tYL8upp2DcMCJLi65jiBulimmHfcNU48sToiS0f257wnub+mIH6WgeGAzuGqnDH7FPROzdxPB3zYWgKF/uEcxxfH2O4pfTt6t49Uby60hauYiGRZzTUPt8YHOTTVNTb88Sx6xm5CfN+kaoIHj7omPvdKMYDKhYohRAYipPmzVutcY4BbiRu1Ly8vGsAnGJZdxetyzheWRtmajjPSNgZpwgE7zzyTob9wy09llpyC/ia0cPTD/fU16mllkYt6ziJ38ZJCW92EV6Ps2XnT9wLpJRpnG067yo77l3AFzZxnv4Yx0x+SyuPq1/0/fdOogj4TI9Tx+7k6041jqN+o28Sx51GVQCcPjDECzfiFMytDYWvnl+kYNl83931txJ2Q26q6dwOco7TeZP5RJ5Do5VfyFG/jkdTmFvrHnvcTQMcHm3sZNBI2hicE9nhocMVl/l1P6qiYqhGhXGcEN/E0GxebLAkr17iOJlPspBeaPh33OZ1Z+LpqJA5AljovitVx/s0X8k4zuSCTTGsXl15lUwxU/q7PZoHrNhtW4wnhDgihPh9IcSLQghLCPG1GsdcXUdGlf/M1TjutsNDtatwg8Zx0bJJF6yaSd4jY8GKSd3V5TTTUbuXTRkAAQAASURBVB8eTSUWMLBl9e2vpAvEAkYVD/3ePRHyps2FFlvU3ZK+3ZQ4jncJVZE3LXJFu5px7NV3kHFs4jfUrmz3dPX2E+NcWkzzwo14XUwFdD9xXIsvHTC2Thwv1zCOXfZ3O2PbId9QQwu15apVoqcqKqP+0dK//ZozkXY5ibp3hsDwFylkjpOY+1EscyMHk17+PmwJ33v/Kh7dbtk4Nm2T+XR1CXfBdF7LemsSmjGPVRxFytr3q6s6UWOMtPZl1uSzQCV7EpznZDq0Ne5jb2Tvdn/CQLtI+4f93FjJVi1+9kKz8c6Vnu1WqYrg0EigYlfTTsqdZ3cKVWFoCqf3D7VnHHcwcQwO57jXxvGFhRTTUV/Hg2ed0COHnERwN4rxXJWjH/yKMz/OmtmWUBUAt5K1PbhaqIqC5bynDdVA2horiQB7hjf8pCHfUMd30TSbOB4LjHEodqijj6EVtTpy/TnAg8N+2qzjgAVsJlOfXb+u/Lhz5QdIKa8DmU3H7TqNhby87vAwn3nhVk+37S/XYCbeSYr5dS4vpvnEE9dKPy+sM/56pUy+O6gKgNP7Y+RNm5dvbc2//MLLc4yGPDy4xYSxGzo27kyyzs/tXOfHlbIt4uUSQjAZ8XKri4ljt/V4833XU6PGMVSX5Pl0Z2XWTe66Ktgp9ozNc37GR764/apkPBevadq+uvxq3d+pZRyvZFfQFK2ieb2YPYLmuYmiVj/nPt1HwSog1VvYZpjZRDVLuZZsafPi/IvABtvZq3mxzDAh34YRETJC6Er/G2cN6hTwbuA8UP+Fgf8BvK7s593lV96ueKh2VWIcb2OgucbvZlQFOLsMbqxkSiVvV5c2cDnu+XgzrmIpVWC4xrn6nnWT7KUWC/LWskUMTcGr9/96gPtcNlr62qySJZ7wJlSFRyO5Q4xjB9/Q3Ynhoyecc4st4f690brH1cOodEqJnFkXVVEvcbxRGrnx2bhnvSCv3WK8ZlVvO+p4cCO1656LXeMYwBt+ksDwX1HMHSB+4x+QSzxAIXOEQvoUh/deJBqw8BlWy8bxXGqu5nm7YDtjAY9Wew6gGnMgdaxi/WK7mH4UWyRZKr5I0AiWEliujg8f3zLx5NN8bZUGDdR/2jfsp2DZzCW62xFSS7NrWUaCHjxa/5/PuqnDo8HSHGOntZJeTxx3oBzPlcs5bqUAUErJfCLPWIcSxwD7hgK9N47nU31XjOfqLXeNoiqCU13EX5YvUno0H4r0kzNzLaEqABbSC5h29TijHqpCEQqaomEWprClwvTwxu7p8nN+p9Sscfza6dd2/DG0oqZHLUKIYeBfAf9ESllrtB8DUjUYTquAXwhhlB0Xr/H7q+vX1brvnxFCPC2EeHpxsTGjYaf0g6+Z4upypq129Ga1uI4IqDUZvRN0ZCzITDzLP/+Ll0s/P/eJZ3pq3pcSx12YtD94wPlYPHO1Pq4iV7T46vkFvvfkeFWSrduKBQzGQh7Oz+3c4MY1jjcnjgEmI76uMo4vLza3WtyMcTweHC8hIGAj5eTVvOTMXMV7XAt+F9NSOHdz+y1FEllzG9D55fM1j08VUhVGNTjpp7X8WkXzum35MfOTGP7anGR3S5KpXgIULi01tthwafUSybyTaM+ZOTRFQ1M0CgU/4bLE8emp0/z0/T/Ne+56D68Zf03LJQR9os9KKfdKKd8PvLLFcbNSyifKfp7ddP1ti4dqRyXzcpvU69oW7OCjY0Fs6Xz/SCm5vJTmwPDWxvFyOl+RqnR1cDhA0KPx4ky86b8FXDzA7lg0cRNL8Wx3zMtEHWxHeL0cbyd4/MkaZmqntSfm5+Sk85G+b1+07nGxgEEiV+xakjCZLdY07YG6qJClZB5lE8vY7WrodSiinnE8GZws/b8iFHyaj4y5YTIIAb7Ik8T2/Cc0zy1SS+8lMfcjqPoSsZFnAPAZNtl8a+PEmcRMzcsLMoUqIxVjhXKVF+TVk08cRrMnoUYpnirUbXEfA0zF7Sf3XLYTuIpba7lSufWdrMOjjpGZN3d+Z52LN+oU4xjgteuc4ydb4Byn8ibZotVh49jPSrrQ051JN1Yypc9av+noeIinfuntvP5w9xYFy7n5hm6jy2lyZo68lSdVaN5XsKXNfKp6Z05V4tjMULSKpWI8O38AgOmyxPF4YGeN46nQVMPFvt1WK8vdvwo8IaX8q04/mO0kpfyolPK0lPL06Ojo9r+wg/q+U5MYqsJnXugdrmIm7hg607E7kwX1oXef4Lu/9Gjp559933Fm13LcXO0enmCzMkUTQ1W6sg11LORl/7B/y4K8b7y6SKZg8a67J+se000dmwhxfn7nEseXF52Bba2T72TE21Xj+NJiuqZhXU/Nto6X85DKE8cSWdpmA7BiPkcsmOfM9cZYVJs5x7eSt0jka7+GtYrxVrIrSGQlpiJ7GFDQ1/nG5Vt7YcM4LghnAnxufpnFzNaLgVJKXph7ofTvnJXDo3qwbQPT0iuK8SJeZ/I8HZ7mdXtfx9Hho1vedj9LStka7LZaty0eqh0FPRqqIrY1jt0t/bXYwUfWueYXF1Lrkw2TA9skjusV2SrrBXmtJo4T2SIRX/9tdaylgKGiKaJruIREnSK6oFdDSkgXej8Jd4zj7r8+P/7Ift50dITJSP3xYMyvI2tgVDql2oljxyxNF+oYx+ufi3KWccir8+57Jnjd4c7xBRtRPeN4LDBWkbr1634yxUzVQoSqrxKe/EMCI59F0dYIjnyGtbxzvvV5WkdV3ErVnlcU7QS6iNb9PdVYAizMQn2MmbQihMwfRBVaFaZif3R/aexRTwNMxe0ntxCr12Vh4CwkjdZYYL3TdHh9cXqnSgrLtYGq6NwC6L17Ii1zjt1enU6jKgBurPTGP7BtSTJv9jVirNsLt359Y87q0SS63FtCEm7Vx7OVNuMqssVsxXzZsi3yZp6CXdgwjgv7GQoW8Xs2pl7dSBxvVTC7WQ9MPtDx+29VTY1ahBCngL8DfEQIERVCRAH3lY4IIXw4ieFgDW5iDMhIKd1XbBWI1Lib2Pp1u1oRv85bjo3yly/e6hkXamY1i6oIJjr45bmbJIRgLOQt/bz5Lmdl7JkGCuU6pWzB6gqmwtXp/UM8c221blLq8y/PEfHpvPZQ/a2I3dSx8RAX5lM7wkIDuLLkpH5rbdOeiHiZT+S68tiklFxeTHF4tHvJ1vKTjHuC9WrVBXkgiUZvcGPJQ64BXMVmM/j8Uu20MdTGVCxllvBr/oqTfjFzBKGk0TyzTAQn+IG7fqACY2GoBopQyEuHo5zPR/jixS9WbSEq19X41YpSg5yZw6t5sdcZkuFy49hT69Ry2+vvCiEKQog1IcSfCiH2b7r+tsVDtSMhBGGvtm3q1U2vRmsM7A+OBFCEYxxfXXZxOc7noW7iOFWo2I5frnv3RDk7m9yWZ19La9lqrmy/SgjhcHa7ZVy6ieNN5qVrZu5EQZ6Dquj+6/Ojr93Hx//u1lsb3cRYtwryHMZxtWkPkMrXNu2XU/maSIr/9GMP8pOvP9Dxx7iV6hnHhmpULJT6dT+mbVK0q9/HQkh84acZ2vf/oPuuEc/FkVI6ieMWjONsMVu3LMgUK+ii/hhECAtVX9qyIM82Q4Ttd3Dv+D1VTMcTI1uX4sEgcXw7airqQ1cFV3fAtIxnCh1j6e5muXOLi33AOXZL6DuZOPZoKg/uj7WUOJ5fR6h0MnHslsBdX+lNyt5dSO3FonK/qjwc5dFtdHsfpm1i2mbLuIrNxvHmYjwXMVW0iuiKs5Cez05XpI09qqfpoFcj0hStNIffSmOBsb46rzY7ajkK6MDjOObuKhuc45s4hXnnABU4sul3N09az7FpsiqE2ItjRFdMbnerfvA1U8wn8jx5pXXgezO6uZphIuztaunKbtLxiTBBj7ZlQrfTyhQsAt00jg/EWE4XSkiGchVMm8fOzvP2E+N1W9S7rWMTIfKmvWMNzFfK2KKbNRnxYtqS5VS+5vXtaD6RJ12wGi7Ga0XlJ1W3HM+r1jKOIa8+jS0FV+e3PymVm8FFq8il1dp4CYClbKXJnClmyJrZiqZZKZ3Ese67TNDj59GDj6IqKsdHN77uhRD4NB85K4VQ0tjFYbJmls9f/HwFK7JcL8xvpI0t28K0TbyaFzPvbN8ZCjmDWUM1tk1F3Yb6NPDzwKPAL+Awjr8phCh30G9rPFQ7ivoN1rJbm4iusVwrEeLVVfYO+bm4kOLKkvP+dXc9uJOrlfTG906uaJHKmzVRFQD3TEcoWDavzjdfNJrIFfs6tbJZEZ/etVJbtyhws5Hu4hJ2oiCvV4njRlQqJ+zC858rWhRMu8q0d5/7euV4S1ssqPRa9YxjgIngRmrXXTS9lbxFtrh1Qs20TZKFJD7DJteCcXwrWbs7xbZUTJYxlK13GmnGPFahPibLtkKoWrIKdxH1RpkMbb2Tbcg3VLGAPNDtIVUR7I35e2ailWs1U2QosHvOZ92Su5uxHwryVjMFDFXpeAn8wweGOTeXaHoHjIvpHOtgaG6vm7LvEec4WWd31J2k8nOHVxfo9kFgvSCvzmLpdlpIL1T0AdQqxpNSUrQdVIVtDmGavgq+cTNYyWbVCK7i/on7u3b/rajZUcu3gO/Z9PMb69e9G/h3wHeABPB+95eEEH7gPcBfl93WXwPvFEKU1xZ/AMgCX2/ycfWl3n5inKBH48+erc0j67Rm4ln23KGYilpSFcH9+6K3VeL4oXXO8dM1/qbHLy+TyJm86+762xC7reMTzkTr/Fzzhke7ctmi9XARE+tbdrtRkOeWVvQqcawIhZg3hq7qqEKtNo6V8yhqlldubP8VX35CvrR6qWaZgKvNieOlzBICUcFCtIojSCuEN3CVtx96e8nEPTZ8DFXZ+Gz4dB/ZYhZFXy6V9SQLST5/8fOl4jtwSvAurFyoSEa7f69X82Jm7iHsMxmPrptEW0z2b1dJKf+xlPKPpJTflFJ+FHgnMAX8dJu3u2vwUO0o7NO3Zxxn6jOOAY6MBp3E8VLamWivTzy8ukrAUEuFMrCRPq639e/e9YK8VjoS1rK7yziO+o3uoSqybjne5sTxunG8AwV5iZxZxf3dKZUSx+nOP//1igl9uooi6hvHy6na7O+d0FbnkvLJZEAPMOQbYjm7zJmlM5xbOsdiZrHuzrDV3Co+j03BVLCa3FRQryk+X9RBmBjq1s+d6pnHNmPYdu3jbDOMolaP346PbL8pZW94gKm4XbVv2M/Vpd4mjnNFi2zRGiSOAb+hMR319UVBXjxdJOrXtyzJbEWnD8SQEp673tycvZQ4DnfuvBHx6UR8es+MY7csNujZPWO3Tqt8juszQJfO+SRXzLWMqrCkxXx6g3O8eVdr1syWdgoZqkEx59xnt4vxXJUHwmppyDfEwdjBrt1/K2rKOJZSLkkpv1b+w0Y6+JtSyvNSyhzw68CHhBD/QAjxKPDJ9fv67bKb+z0gD/yZEOLtQoifAT4M/OYmBuOulc9Q+f57Jvmrl2brDpI7qZur2TuWb1xPp/cPcX4+2TWG32ZlCmbD5Wit6NBIkKhf5+kaKerPvzxHwFB549Gda7Q+MhZECDjfQlKuXS2lHLboVoljgLm1zjOr3MHcoS4ax5tXJt2tsj7NV2UcC2Gj+17l4qyXi8v1E8QAeStfKpzbClORLqYr0sC2tFnJrhD1Riu2tJp5Z0vN6w6OV7CNvZqXQ7FDpX/7NB+WtJDaFaziRmJ5JbvCp89/mk+d+RR/+MIf8vEXP87Xr1auJbp/r64EyWcOctd0FncMe4diKiokpXwZOA+Ug7FuazxUO4r4dNa2SV26ieS6xvFYkCtLaS4tptgb81Xs+hgKGhWJ4+WUc1/1imz3DfkJezVeaqEgL5Et7ppyPHDQH91jHLuJ48pzcsk4vo1RFY2om6iKemlvIQQBQ6v73G+FcOm1NEUr8fg3q3yxVAjBwehB7h27lz2hPVjS4vra9YoJa7lWs6v4DCcFlc03l9+ZSdYOouRN5wTo0ZzFWZ/uY29kL6+ZeA1vO/i2kvG7XUGebYVQtOrx28Ho9pPXAd/49tWBYaecrZeFovEuIBF2sw6NBri0uDO7Ocu1mil05TV5zd4oioBnmwx7LSTy+HSVkKezc+99Q/6eMaXd82GwTxaVd0JezVva6eI3FFQ5goJCzsyRLCQpWq2NE2eTs6X/r4WqcJnHuqJj5vahqUVGwhvjk24U47naLnF838R9XbvvVtWt/ey/jlOi938BfwmEgXdIKUujKCnlKs62WhX4LE67+28B/7JLj2lH9MMP7SFTsPjcS7PbH9yGCqbNfCLHnthgm1i5HlpfwXy2yRXMVpXpcuJYUQSn98eqEsd50+JLZ+b4nuNjNfm+vZLPUDkwHNiRxLGL79jOOJ7tRuJ4IUXAUBnv4Ir3Zm1emXTxEF7NS9asNsMN/3mk7edL5y/y5M0nt7zt5ewyiXyC2VT97yk3bSylILX4AywndSxpVWAqAMzcXlS1wH17qre1nhw9Wfp/d0JuqhexrQjS3jAYEvkEq7nVihKDcuUtx4RT8ncjpcax6Y3BXcQ7MI7XJdd/XN32eKhWFW0gcRzPFgh6tLooqMNjQQqWzbcvLpWK8VwN+Q1WyszRpXUTebhOslIIwb17ok0njqWUJHL9XbCyWQ4mpHuMY00R+DadE3eKcVwwbfKm3fEJbquKBlxURfcSx7W23ga9Ws0wRa5okdwC4bITqpc6jngiVQxgXdUZD45zcuQkYU+YudRcxTZZV45x7ESNs4XGx2trubW67fJ50/mqdwNrb9z7Rt55+J08NPUQh2KHSudedd04NvPVk2EpBbYZQlErsztDvqFti3w0RWMyuDOlzAN1X/uG/KTyZhWrv5tyF7RiHSxh2806PBrk0mKqp+Z9LcUzxY4W47kKejROTIZ5ptnEcTLPWNjT8QT04dFAz9AgG4nj/hgb7JTcee5QSCJQMJQIOTOHlLJlXEX5Lp3NqIp0MV2aZ7qJ49FoivK30k6hKkJGiKND/Vfs3rZxLKX8mJRSSClTZZdJKeWvSin3SCl9Uso3SSmfq/G7Z6SUb1s/ZlJK+ctSyt7XXHdRD+yLcWg0wCefvtHV+5lby2FL2BMdJI7Ldd++KKoiaiZ0u6Fs0eo492mzHtw/xOXFdAWr9w++dYWlVIEPPLTziY9j46EdSRxfWdoaFzEUMDBUhbkuGMdPXV3l7ulIxwcu5do8cXMTT17NiyWtqtVY3XcJsChkjvHSwkvMpebq3vZyZnnLtDFslOgV0sfJJR9iKR1HV3TCRuXE2szvZXq4SK2nYtQ/ymjASSG7CIuCuA6AZdbE7NZUzszhUT0UM/eg6zmmRzYmM4PEMQgh7sYxiZ8pu/i2x0O1qkgjqIptEBBHxpzvnUTOLPGNXQ0FKhPHK9skjgHu2RPh/FySXLHxIVEqb2LZsiph28+K+rvLOA77qrfU7hTj2L2/fuEYhjwamiK6kziuU0wIEPBopTKgci2nt/9c9Fr1FiKFEHULc4QQTIemq7bJuorn4mXGcePTsHqYCoC86TzfXn3dsPeEKq4f8g0R88ZQ1ARCydRMHEvbD2hVieNGinkmg5MVKKqBbi+5ZWG9LMhzv5cGqApHR8aCZAoWc4nOz2GaUbcSxwAP7o/x/PU4ZhMMn4VEjvFQ5/jGro6Oh7i1liuZut1UasA4BjY4xxPrp12PGCsFo64nrrd0m/PpeWzpvJ+qUBXFbGnurBLCKo4yNbzx+Yp6o3i0LgbCtliQvX/y/q56Cq1q0KLWZQkheN+De3jq6mrNQrNO6WbcOZkPGMeV8hsap6bCPH21d4njbhvHLufYZTffimf57S9f5B0nx3nT0Z3nkN41EeLqUropw6MTuryUxlAVpuosngghmIh4O544XkjmODOb4M13dfe535w4HvINIYQotbJuxlUoag7de41C+i4Anp97vu5tL2WWOL+8vXEsJWTX3ojJEhl5gWHfcMWJzbYNzMIYe4frD7ROjjjJJ03R0BWdAo6hbeYbZ3M7xrGXQuYo0yNLKGXn1tstcSyE8Ash3ieEeB8wDYy6/16/7vuFEH8khPgxIcT3CCH+PvAF4DrwsbKbuu3xUK3KNY5tu36SJ9GgcQzVux5iAaOCI7tcShzXn3zdOx3BtCXnmti9kchtjdPoR0V9OumCU6TWaSXr8ITd7aC9mBBufjxA36AqhBBE/TqrXU0c1zaOU/nq8YG7GN5PieOQEap7XTmuYrP8up+oN8p8er6qNyCej+MxnMuaMY7rYSoAClYORUZRtXzdx3146DBCOKljs4ZxbJvO7yha5emgEXZxP7W+D9R57V9fDO1lQV4JVTEoxwM2QjEX5neWc7yaKXbtNXlwf4x0wWoqfLSYzDPahd2e7piuF6njVN55r9/xieN1IzUW0BFKGk1OU7SLWLbFywsvVxm/jci0TRbSCyTzSaxN2dRMMUPBLqAIBVnYBygcGN04prwEtxuqlzjWFI1jw8e6et+tamAc90B/64E9KAL+9JnupY5vrjorMgPGcbUe3B/j+RvxrkxMNytbsPDp3f3iv3s6gqEqJVzFr37uLLaU/IsfOLnNb/ZGxydC2BIu9rj99/Jimv3DflSl/grdRMTb8cTxN191krhv6bZxvGll0lANQkaornEMYPhfxSqOYxWj3EzcZDGzWPO2r61dq7sF1tVyZpli7gBmfg9Zz5+BkET1uyqO8cljgGB6uH6C7VDsUOkx+3QfOXsFVV8ks/J2bGv77y8pJXkrj84ESA+HJysHmLdh4ngMpyfgk8AjwMmyf48BN9b/+x+BL+Lgnr4EvLHcEL5T8FCtKOrXsSWkaqQgXcUzWxvHYa/OWMiZvGxGVQwHjJJZDA7H1dCULScJ96wX5L10M97InwBsX+DXj3K3vHYDV5HIFqsYuwBBY2cYx/3YnO6UE3aTcVzDuPeopGqkvUvs7z5hHMPWBXlbGccAU8EpbGlX7faxbAsL56u5UcaxlLKC1bhZRTuNLkcQQuLX/ehq9fve7RjQjHmswjhSVo6VbNP5W8tRFYZqNFQONOAb397aO+RDCHrGfIVyVEX/fB/spI5POAs7Z2Z3bp1fSkk8U+haCvyBfU4wqhnO8XyXEseucXyhB3PZfhwb7ITcxLEiFHTPEpp5GHDmt5Zt8Z0b32npdm8lb1VhKsAxjotW0eEb5/cDNvvLpvLdxFRAfeN4xD/Stzt4BsZxDzQe9vKWu0b51DMzWFskmtrRzKpTDjUZGRjHm/XQgSHyps0rt5pfqWpW6YLZ9cSxV1e5d0+Ep6+u8K0LS3zupVl+/q1H2DvUH3zru8adwU2vOcdXltJ1+cauJiNebnW4HO8bFxYZCRqcnKw/weyEFKFUFfUM+4YxVANFKOSsGsZxwEkRFzLOyuULcy/UvG13G089ZYtZ0sU02fgbQU2Q0h7DY92NUrin4rhR42EApobytW4GAFVRuWvYMZzdYr/g6CexrSCppe+v+TvlSLeiXcSWNmrxLoSS5fDExmM3VKOEwLhdJKW8uo6DqvVzVUr5opTyUSnlqJRSl1JOSCl/SkpZta/5TsBDtSLXXFzbInm5lt2e6+dONA7VSBznijbZgvNUL6cLDAeMLbehTUd9DAWMpjjHJbOuTxKtjSiyPgHtjnlp1nwuFEUQ9NQvaOuWNlAV/fP6xPx671EVhka6RuJ4sQ8Tx1sZxzHf1ngln+5jyDfEQnqhCiWVs53OgEYTx0uZpRLbv5aKJNDWu0/rpaTDnjCjgVE0Yx4pPdib8FCWtW4cl6EqpkJTpcKievJpvm1N9IF2tzyaylTE11Pj2E0cd4OnuxsVCxjsHfLxUpPdB51UKm9i2pKhLhnHe2I+xkKe0o7aRh5PumAx1oXE8f4hP7oqehKCcsciAePONo7Ld9Z6PHFU0wnEucGomeQMl1cvN327s8nZmmnlbDFLwSpgqAZmfi+GZxFD25hwdrMYD7Y2jvtVA+O4R3r/6b3MJXJ880LtxF+7molnGQ95MbTBS7pZp/c7g+Ne4Cp6gaoAePBAjJdm1vgXn3mZfUN+fvYth7p+n43qwLAfQ1N6yjm2bMm15TSH6vCNXU1GfMwncltuSW9Gti355oUl3nR0FGWLpHOnVItzLITAp/lI5asHN6rupHkLGceovbZ2jbMzef6/L07w1IWtn6tyLWeXMfMTFLNH0UOPUbAzBLmPYnajaf1A9ACp1CjDoSJeY+vndzo0DTgTTonEVK/ij32NQvoe8qm7S8c5aIyHWbn2C2QTp4GNVlw1/3oM/6tEvBvPyW2YNh6oB3ITululXrdjHAMcnwjj09UqXI7LbHVTx8up/LapSiEEd09HeOVW4+ki9/HXStn2q6LrjzXepcRxvQRPyKuVtof2Sok+TBU5iePuoCpURdQcDwW9Wk1MyK5LHHu3N0sng5NIZFXx7Fp+EU2xGzaOr6/V5ztKKSnKVXTFeayb+cblOhw7jOZx1hTNfGWZnYOqsFHUjbFEIwiK6fD0tscMtPu1b8jPteXeoSpW0gX8hopH68/k3U7o3ukoL87Ed+z+u23mCyE4fSDWcEHewjrv2d3t1UlpqsKhkSAXF7o/l03lTYIerSfzyH6WmzgGCPiSaNZBBKKiAP6Jm0/ULU6vp7nUHKu5yveULW1yVo6CVUBXDMzcHoLBhdL1uqJ3fUG0ViAMnD6gftXAZeyRHj0xRsyv88lnbnbl9m+uZgZ84zoaC3vZN+Tn6WvdLcizbEnBtPH3YMXwof1DFC3J5cU0//I9J/Hq/TOw0lSFo2PBptic7WpmNUvRklVJv82ajHgpWrJUwtOuXr61xkq60HVMhavNnONh/zAAMW+MjJmpi6soZg9gW15Sy2/l048fYimhc2m28e+LlewK2fgbECKH6fm281gMH8XsAaRUUBWVh6YeZmbZYGpo++fW5RC76eCsmcUX/Raa5zqppR/AMsPYlp/E/I+SXv5+EJL00nvIrD7CQnoBnzqEbt1NOHKpYjvPVpP8gQaqp0aM43gDxvE/fNsR/vhnHqnC5bhbbV3OsZM43n6iMx31sZBsHK3jpjx3I6qiG+ZlIlesm77uduL40mKKn/v4M2TK8CfJPkyEdy1xnHNM+1qp+mC9crxUHr+h9mQM1agCRgBNqf14fLpv2x0uXs3LiG+EpcxSxWT3pYWXMHRzW+PYljZP3nyS5+aq+sVLKtpFECaG4ky6tzoPHoodQvMsgihi5isNX9sKoagphNjYxTPgGw/kav+wv+eoigGmolL37IlwYyXLaofmMM2qF/iQB/bFuLGSLZnCW2kh6SzGj4c7j6oAZxdZL1AVqZx5x/ONoTIcFfSnEGgYSrBibpspZnhm9plav15XRbvIpZVLFZdlihls26ZoF9GIIaWHWDheun4sMNaTcrpaqeNB4nggPJrKe++b5kuvzHdlS+ZMPDvgG2+h0/tjPH11FSm7gwoBShPEniSO98dQBDx6fIxHT3R3K0UrOjYe4tUeGseXlpwT+8HRrY3jiYgzuOgU5/gbrzo7CN54tDdf8rUSx7CxZXY1W71Kb/jPAxrxmz9PNv5WPMEXOTSRYCnR+CDlVrxAPn033vAzZK04AkHQl0FKL2Z+ikOxQ9hmjGxBZXq4/nba0t+hO5Nxl3WcNbMIYRMa+zOkVEjOf5DVmz9PMXOYwPBfMbTvtzACL7O0NkTeyhOV34MQRUZjSxW3W6/lfqCBttJ2nN1c0Slvi2yTshkKGLxmb7TqcjdBuZE4LjSUqhwOGKykCw3vkNidieMuoiqyZk3GLriJ4+4Zx198ZZ7PvzLHk1c2Fqz7kWMY8xusZoodHxslc2bdvzPg0Ujnzar7XGogib8T2rIgr4HU8URwAomsOD+btklBrm65YJIupPnchc/x0sJLW95+3nTeV4biPHdbJY79up+p0DiaMYeZn6q4zjbDFZiKId/Qlq3vrgbG8Z2h/cMBltOFnpWKxjPb46HuNN0z7YQuXu4BerGWVntQWPjg/soC+K0038XEMTjG8fWVTNfL3lN5s1TaeyerPHEcCzrjZUOMVoWiziyeYSlTOf/bTuWpZVjnG9vO+1mxnN03Y9GNRYJu841dbTaOVaFui8HaSQ2M4x7q/af3ULBs/vLF+gUXrciyJbPx3CBxvIVOHxhiOV3gahdXy11+pa8HxnEsYPDf/94j/OYP39f1+2pFxyZCzCVyWzJDO6mX15lfjSSOAWY7xDn++quL3D0d7hmTcXPiOGgE8WpeDNUgoAeqtuIAaN4bCCWNtD2Exj5JaOzPsfXLpHIauUJjq6lXZw4BNt7I42SKGXy6D4/f2TpbzB5ib3gvM8vOc9BI4lgIQdgTRhEKXs1Ltui8Hqq+SnD485j5aRQlS3T6o/giTyKERWjsU6Q8n0C1R9HTP4bhv0DEV8n1dpPMAw3UjNyEbj0TZ63NJO/Qerp4JV1ASslyOl/CV2yl4aCBLRvHOCSyRYSA0C5KrkQD3SnHK5g22aJVP3Hs1UvoiG7I5SI+fbXaOO6nCWLUb5Seq04qkd067V20JPlNhcXL6UJf8Y1dtVOQB+DRPHhUD4lCJXZGKGnmE6mq0lpb2lyNX+Uvzv0F86n5LW/bsi1mk075nld3xjdbGd3gpo5vYeYnkVKgKiohT2g9cbxhHDdiCEc8kbqcxoFuL+0fdsZbvcJVDBLH1bp7yhnjNtN90Em5C7zdKscDODUVwdCUhozjxfXE8ViXEsdHx4NI6ZSvd1PJ/CBxDJVz3PGwByHyGHKKvJWv6OKRUvKVK19pGllRrmwxW+oeUO1JhMgzHNyYE08EJ1q+7Wa0+fw57B/etldgJ9W/j+w21MnJMPuH/Xz57NYDwWY1n8hh2pLpaH+Uo/WjTh9wVm+euto9XEVm3TjuReIY4HWHh7dNwO2UjvWw/deyJX/81A1ee3CI4W0mnRMl47j9xHEiV+TZ6/GeYSqgOnEMGxPXId8QWTNbMmFdCWETnfoDYnt/G0/wZQCS1qsALCW2f/9Ytk189QSe4EsoaoJ0MY1f96OoGVRjlmL2ENOhaW6tGBiazUikMQPI5RH7NF/FSrAn9CyRqT8gOv37aJ6N78qsmSLLFYa01yAw8ARerpogD1AVA7Wi7VAVrqHcsnG8PslaSRfIFCxyRXvb7yqgdMxyavsUPzgM3dAu4+SFPBqqIjqOqihhIeq8ZiGvRirXvYXNi4uOcfxUWbdCMlfEp6voav8MvWPrY4jVDj//LqqiltwJcnpTcnEp1RjCpdfaKsHbaDIo7AmTKqQqJr9CzWJZXr5w8QvMpea4sHKBr1z5Cp948RM8dvmxqoTUZhWtIueXz5Msxhku/CO8uijd11Y6ED2A7plFSi+Hw6/lA6c+wHuPvRdpRVC0jTFbI5iK241vLIT4KSGErPHzc2XHCCHEh4QQN4QQWSHEN4QQ99W4rZNCiC8LITJCiFtCiI8IIfqHK9ek9g25xnFvcBWDxHG1In6dA8P+HSvIcxEZ3TT0DU3hNXsiDXGOF5J5PJpCuEuLsUfHnO/+C13mHKe2OF/eSfJoHtT1r8iRwDCqsYhmOx1OebNyHJzIJ/ja1a+1vFsqU8yUjGdVjiDULEHPxhy7VztYN8/r+xlTAQPjuKcSQvDo8XG+fWm5gnvXrm6uOoPLQeK4vo6MBon4dJ66cvsYx/2s1+yJAvD8jXjX7+ur5xaYiWf5idcd2PbYkYAHXRUdMY6/c3EZy5a8+WjvjONayZ5hn8M5dk9ytVLHqrGMom1swbHVGaAx43g+mQFpoHlulVZ93VVh3XcFM78XRXi5teJhMlagUc+qxDnWfBSsApbtfH6EAN17HaFUfkfOp+dRhMLkyCLRPb+DEThT9XwMyvEGakU+XcVQlbrGsXu5i1VoVmGfY46upAusrE+8Gkocl0r1GktVrGWLfbuYWE9CCCK+9jm7qbzJu//vb/LIr32ZR37ty7zzP34ToD6qYhPj+MJ8kvf+zre4sdK+KSKl5NJ64viFG3HypvPdthW+YacULfG3O4sKiWeKdc2FQMk4rkw5L6XyjPQhqmKr84p7/t1OYU8YW9qkCxvJNUXJYFs+cmaOv3z1L/n61a9zefVyQymqnJnj3PI58lae/b63ELS+F0VNoilaxXbfWvJqXh4+4KSpxoyH8et+VOHDtnz4PM59G6rBeHB7DNptjKl4G/C6sp8/K7vuF4FfBn4DeA+QAh4TQpQiakKIGPAYIIH3Ah8B/inwK7148N3QRuK4N8bxIHFcW3dPR3hpZudQFUJ0v0fhgf0xXp5Z2xYRMZ/IMR72do1Fe2DEjyI2dhB1S/04NtgpueevId8Qqr6EWjwGVKMmwCmNfWH+hZbuJ1PMULCd851mjyGUXGU5XwOYpk5o8zy2n4vxYGAc91yPnhijYNp8++Jyx25zJu6cxAeM4/pSFMEbj47wyWdu8nc/9lRDW2CaVbboTEJ9fVTsslOKBQwOjgR4rsFm3Hb0h09cYzzs4XtPbT/JURTBeNjLXAdQFV9/dZGgR+OB/b1jEW1GVQAM+Z3EsaEaBI0gK9mVbVdgFW0NVbVYbMA4nl3/flE0J20MGyd2w3cZKTWuzntYiOtMDTduPmwuyFvOLpMqpCq2D7kqWAVWsiuM+EbQVQ3NWHS25Jcljg3V2LaoaKCBakkIQdins5at/f5tF1UhhFhnyRZYWk8PN8Q4dtnIqcaN434qXmtUUZ/eMI6jni4upDgzm+DYRIi33DXKo8fH+InX7a+7sFfOOJZS8kt//jIv3Fzjmxea4+bV0nwiTypv8oYjw+RNm5dnnBRnMt9/qaJYl8oJ49n6acGgx1lcL2el2rZkJd0Y+7vX2irBG/VGGzIt3MlhsrCRXBNqFmn7aDYwlTNznFs6hy1t7hq6i4A4AYCqJbbFVLh6cO80umozt+o836msMx18YPoQASPAVGhq2+2yAsFUaGrLY3axnpJSPlH2swAghPDiGMf/Rkr5O1LKx4D34xjE/7Ds938O8AE/JKX8kpTy93BM438ihNiVW6NCXp3hgMH1le6jKixbspYtlr6fBtrQvXsizMSzDe9E6qTimQJhr15VANxpnV4vgH95G4N8IZHvGt8YnH6qA8MBLsx31zhODVAVJbmGraEaBHxJVPM4QM3yd4BnZp/hZuJm0/eTMTMUrSICAXIIoeQq7rteKW6nVWUcBwbG8UBleujAECGP1lFcxc0VxwSbjg5Mk6306z90D//0HXfx7PVV/tZ//g4/8tEntj0pNaNB4rhS9++L8uz1eFcLCa8spfnGq4v86MP7G97+Oxnxtp04llLyjVcXef3h4Z5uO661AlqeeBryOuVx221xFUIS9CUbShwvJtfLA9QkmUIGgcCnOd81uvcaQkiePB/GloLpocYHsm6KyzWhbyRucH75PGeWzvDiwoucXTzLQnoB0zZZTDsMyM1lBeVbiAdp44HaUcSnbYGqKKwf0/okdjhgsJwqlEzgRrbku8e4pXpb6bnrq3zzwiInJ3efJxHx623z8N2SnF945zF+43338hvvu5ePvPfuukiQoEcnU7AwLZs/e3aG765jrF7pQOmQm076wEP7gA3OsZMq6i8jJLaeam838V0uKSVrmSKROgl9N3FcbhyvZYtYtuxLxvFWqApVURs692iKRkAPkMhvoCAUJQOoSLs5PudiehFb2hwfPk7ACGCbURBFhJre8rGWS1FgPFosGcfJrPOajIQ03n3k3RwZOrLtbQz7h0sFt3eQXg+EgT9xL5BSpoHPAu8qO+5dwBeklOW8tj/GMZPf0oPH2RXtH/Zzdan7ieNEtoiU3WXp7lbdMx0F2JHU8WqmN2b+A/uiwPYFefNJJ3HcTR0ZC5bQU91SKmcS9PTX2GCnVB6QGgoVUPBgKP66xrGUkq9d/RqpQnOvkYuqMFQDbB+KksOvOfPR7XbtdFLlxrEilIZ6E3ZSA+O4xzI0hTffNcpXzi003JS+nWbiWUaCHrz6wLDcSiGvzv/66FG+9c/exj///hOcn0/yoT/fuq26GbnGsW/wOgBw/74YS6l8CaXSDX3iiWtoiuBHHt6exedqIuJjLtGecXx5Kc1MPMube8g3BmcVVFcqBxdRbxRVUUv/D1S0t9eTx7vSkHG8knaYjG7i2K/7Swkrv0dlaijPTbcYr5nE8fpk21AN7h27l+PDxzk6dJSD0YNMh6aRSG4kbvDi/IvMp+eJeqJ4tA1TQRVqxQBjUIw3UDuK+o1tURXtYCBiAQfHUEJVNJCsdCdo2yWOV9MF/sF/f5bxsJd//v0nW36MOyUncdyecbngtquHGzMe3eTvrXiOX/urs9y/L8rDB4Y6wuW/uM5DfOTgEIdGAiXOcaIPt6NGS4njzhnH2aJFwbLrJo4DNRjHG0n8/jOOt2MGNzrRC3lCpIvpDSyT6hhw0m489GFLm+XsMlHvxvnQMiMo2hpCyKY4/xOxAvNxHduGVNYZQ4R8FhFvhAPRA9v+/m2MqQC4JIQwhRDnhRA/W3b5ccACLmw6/uz6deXHnSs/QEp5HchsOm5Xaf9wgKs9KMdzF7JigYGZtll3Tzuf8Z3gHK9mCj0x84eDHg6OBHh6G+N4MZFntIuJY3AK8q4upSlsKnPtlGxbkiqYfVWau5MqN20nY85c0xDDdY1jcNLIZ5fONnU/K5kVilYRXdWRtg9dK5bmtrV293ZLft3vpJ5xxhL9XIwHA+N4R/ToiTEWknle7kCyBRzG8YBv3LgCHo2/96ZDvPueCa4udW4A5HKrB4ljR/fvjQLwXJc4x9mCxSefvsH33T3RVKOumzhuJwn99fNOAraXxXiuNqeOFaEQ8zq4DF3VCRkhVnLb4yqENkc6p5ItbH0aSGQEYCOUFJlipuKEuie8hwNjzoQ/Giji99QeWNUq2fFono3ksqoTMAKEPWGGfENMBCc4OXqSEyMnGA2M4tE8TIYmq56H8i3Cg8TxQO0o4tPrGseJrMP1C7WxlXA44GE5XWBpPT3cSOJYUxVifn3LxLFtS/73P3mepVSB//RjD+w6xjE4pn27qIT5RB5VEQ2Xq7mTtH/5mZdZzRT413/jbk5Nhzk3m8Rqc1H/4mKKkFdjNOTh9IEYz1xbwbYlyVz/oURcbncny/Hc1zJar5iwRuJ4aX1xZKQB9nevtR03uFHjOGw4ho+Lq1AUZ1HdthpPN63l1rCkVbHTyDajqJozn2jWOC5aCstJneS6cRz0bc0ULdd06PYqxlvXLA6/+G/j8IufAH5PCPG/r18fA1JSys1P1CrgF0IYZcfFa9z+6vp1VRJC/IwQ4mkhxNOLi4vt/RVd0t3TEWbXcsx1oCdkK7nfR4PEcbVCXp1DI4EdSRzHe5Q4BnhgX4zvXlkpFd1uVqZgksybDS8Wt6ojY0FMW3KtSwsmmaKFlO2NL28nlc9x90S9gIkhJ8mZW8/br8evN3wfK9kV0sU0BbuAoRhIy4tH35i/9opvDM4c3h1f9DvfGAbG8Y7orcfGUAR8+exCR25vJp4d8I1b0HTUTyJn1j0pNasNVMXgyx/g+EQIn67ybBd40gCffn6GRM5sqBSvXBNhLwXTLiX/mlWuaPHfHr/K8YkQe4d6t53FVa2V0ApchW+IglUgU9x6O2FRcU6yS4n679eiVSRX8KCoKXJWGonEb2z8zXvDe9m/bhxPb5E2fnDqwZqXb5cS9ut+9ob3cmr0VNXEfTPLcZA4HqgdRXx6XfMyvs4OVtrg+sUCOqtpB1XhN1R8DS4wDgc9W35X/eevX+Jr5xf55R84wb3rpaS7TdEOoSpGg56G2YvuJO2r5xf5ydcf4NRUhFNTEbJFiytL7W1LvbiQ4shYECEEpw8MsZopcnkp1ZcFOIamEPRoVaiKb15Y5L9860pLC6wl47iJxLG7ODLS5fRYq9rKkI35Gus5CBgBFKGUcBWtJI6Xs8voil7xeJzEcRyoPi9upcmY85rPruqkciq6auPRGnu9VaFWLebeDpJSfkFK+a+llF+UUv61lPIncbAU/1yI7kbBpJQflVKellKeHh3tTwPhoQPOe/2pq90rGoeNHRCDcrzaumfPzhTk9bKw8Cdfv59ErshvfWlzuN/RQsI5Z4yHuouqODrmfKd2qyAvtV7SO0gcOyqf640Eh1D1ZXT7EBK5JYZxNbfKWq6xz8TNxE2klOuJYwMpvXj1jXNfL1EVsIGrGPGP9PR+W9HAON4BDQUMHtgX48vn2ucc27ZkZpA4bknuczYT7wxKIesax55B4hictNy9eyJdSRxLKfnDx69xfCJUGsg2qsmIM8holXP8/37jMteWMzu2JbzWSmh54snFVSxnty7glOoswJa4itXcKpYZQtGSJSPaNa6FEEyHppkezjM1lOf4ntpGtZsg9qjVhkA7KeHNLMdB4nigdrRV4nhti6KvRjUU8BDPFllM5psqABsKGKU05mY9fmmZ//DF87znNVP8+CP723p8O6mozyCZNylarW8FnU/mGW8ieeSyhsdCHv7JO+4C4NSUY8a9cqs9XMXFhTRHRp2JwEMHnO/mp66uksz1XzkeOAbv5kWT//DFV/nIX57hX3z6laaxai52pF5asBbjeIP93Z9G0VbG8ZC3scSxIhSCRpBkvrnEsZSCQvYgebPAWn6NYd9wabeNtDWkFUJ1jeMGGccAQyETQ3MK8pJZlZDPooGePwDGg+M9Kw/qA/0pMAQcwEkMB4UQmwf6MSAjpXS/rFeBWoOS2Pp1u1InJ8P4DbXEbe+W3MTxoByvtu5ZT34vJntbkBfPFHuWAr93T5QffXgf/+3xq5ytgZBaWP/bu504PjwaRAi40CXj2A2v9ePYYCdUHo4K6AEMzwqe4usBtjWGr681ljq+mbiJaZtIJLpwzr8+z84Zx+68vt+L8WBgHO+Y3nZijJdnEm1v91lK5SlYNnsGxXhNy01pz3SIwVtKHA8YxyXdvy/GmVtr5IqNb39sRM9ej3NmNsHfft3+hhrNyzW5/llp5bN3YyXD73z1Iu++Z4I3Ht2ZlcGaiWP/RuJYUzRG/CMsZhaJ5+J1b0fR1tBUa2vjOLuKbYZRVIdvrAilZACP+cfwaB5UBX7ibQscnar9fB6KHQI2DO1ytZMSHiSOB+qkIj6dZM6siSlYyxbbKsYDGPLrSAmXFlMMNYhTABgJGnXb0//T1y4yGfHxb37onqa/B/tJrilfz7hvRAuJXFPIoj0xH6oi+PAPniqZyEfGghiqwpk2jOO1TJGlVJ4jY45xfGDYz0jQ4PFLy+SKdt+V44GT6itPHGcLFi/PrDEd9fHxJ67xS3/xclPm8baJ4/W0fWoT41gR/bs1fSvjOOQJOQU7jdyOESZn5ShYhbLE8daT1FzyQRKzP8VSyhlHlZ/vLdM57ylaHCFEU4ljIWA8WmBu1SCVVQeYivqSZf89B6jA5vbAzUzjc2xiGQsh9gL+TcftKmmq4iAErnbX+3YTx/36fbDTumfa+dx3suB9OxVMm1Te7KmZ/wvvPEbEp/PLNc5BbiFut8vxfIbKnpive8bx+nkwOEBVANWmbTiQQZgHCOhB4vn4lr97be3atrdftIrMpeYo2M53jCacsVrQs2GJ9pJxDE7iWBFKxe7hftXAON4hvf3EOABfOdceruLGuum5J9b7LfO7Xa7Z3qnEcaZgYagKmjr4WLl6YF+UoiU70lRfrsfOzqMpgr9xX/OTl1LiuIWCvH/1l2dQhNjRAqryBlZXQ76hCuNob3gvPs3H1fhV8mZt00kIScCXZGmt/iBwJbeCbW0kjgP6Ble40WIc1ziutZ23U4ljj+q5E9vdB+qgXGM4UcO8jGc6YByvl35dXEg1xXEdDtRHVdxczXLf3uiun3BsFLS1bhzPJ3JNJY4PjAR46cPfy7vv2dhur6sKd00E20ocX1x00qSucSyE4PT+Ib7+qsMs7cdUUdSvVzCOn78Rx7QlH3nvKX7+rYf5o+9e5xf/7MWGzeMNxnHt97mmKvh0dVM5XoGhQOOokV5rO3Zwo7gK97yVzCcRSg6wsa36wQ8pBbm1R5BIVnIzBPRAxbnONqMAqNoaft1fKsptVJOxAvNxg7WMkzhuVFOhqabuZ5frfcAScA34DpAA3u9eKYTw4/CQ/7rsd/4aeKcQotzJ/wCQBb7e7QfcTZ0+EOPcXIJEhzB/tbSaKaAqgnAffl/2g05NRxACXuxhQV7JzO/hrpCo3+AX33Wcp6+t8qlnb1ZcV0oc9wBvdGQ0yIX5ZFdu20VV9OPYYCe0eVftSNgEFELaNJlihoJVH902n54nW9za07mVvIUtbYqW8/2lC+fcHig3jnvIOAZnXl9edN/PGjhcO6SjY0H2xHx8pU1chWt6DhjHzWsk6MFQlY4ljrMFs2Fu5Z2i+/ZFAXjueryjt/vM1VXuno6Utrw2o5F1DubcWnOv+9fOL/DFM/P8w7cdYWoHE/61TmiGalSsVCpC4XDsMACXVy9jy9pbwA3v8paJ4+V0wklDKatki9mKleA9ke2N44gnUsJodDpxXG6gN1MINNBAtbRV6jXRkcSxM9nKm3bTqIrVTBFzE8ZBSsmteLa0ELab5T63a9nWuPN502I1U2yadVirj+DUZIRXbq21XJ7qchBd4xgco8V9X/Vr4jheljh++uoKQsDp/UP8wjuP8Y/edoQ/efomv/pXjbWWb6Aq6v+tAY9GKr9hVC6n8ow08bnotcYD41te3yiuwqf50BSNRCGBEBKh5LZMHBezh7CKoxSUcxTkWhUD0TWOFS3e0nlwYqiAZQuSWY2gt3HjuNFCwN0mIcSnhBD/TAjxLiHEDwghPo5j+H5ESmlLKXPArwMfEkL8AyHEo8AncebTv112U78H5IE/E0K8XQjxM8CHgd+UUrbHwtlhPXRgCCnpWn8JOKiKqE/f1TtpuqmgR+PwaJCXZuI9u8+dwoe874E9PLAvyq//9blSF8JSKs+LN+MYmtL22KwRHR0PcXkp3XZxbi2lSonj/hsb7IQM1ajAIE3FHKsyKI4BW+MqpJTb4ipuJG4AlAxolSgA4bL30U4wjndDMR4MjOMdkxCCt58Y51sXl9raxn9z1dnqNj1AVTQtRRFMRb3c7GDi2D8wjis0FvKyJ+brqHGcNy2evxnn9P7m2MauVEUwHvIwG288cZw3LT78mVc4OBLg773pYEv32ynV20IzHqyc2Ho0DweiB8iYGW6s3ah9Y9os6bxKNl/7VLCcdAY0ReUaElm6b5/uY8S3ParDTRsDxLzVr1fYE0ZpsW+mfEvuAFMxULvaMC+rjeOOoCrKUjrNoioAVjaVl8UzRfKmXULv7Ga525FbTRyXSnI6sGX11HSY1UyxZQb+xYUUHk2p2AXmco6hP1NFMb9T3OjqqWurHBsPEfE7xs0/+d5jPHp8jMfONhZ0WMsU8WgK3i2wXUGPyos343z0G5f46DcucW4u2dSCSq8V8Ua2nEzui+xjT3gPI/4RQkaoLv/XxUkk8gmklAg1s2XiOLv2CEJNktY/i8CoOo86qAoLRUsSNpo3jidjG5+5RhPHPs2HR+vPEsMO6Dzwd4BP4RjCJ4GfkFKWm8K/Dvwq8H8BfwmEgXdIKUsfECnlKvAoDtbis8CvAL8F/Mse/A1d1f37oqiK4Oku4irimULbvQK3u+6ZjvQ0cby6Q4WFiiL4V3/jblYzBX78D57kbf/ha5z+14/x6edvcWIy3JPFhSNjQQqmzY2VrUvHW9GgHK9a5fPc/cM+wEY1j+BRPW3jKm4mnOR60SoiEKjSmT+W75DaEeN4F/CNAQbv0h3UoyfG+Nh3rvLti0s8emLrNEM9zaxmifn1lpKXAzlJ7Y4xjovWIHFcQw/si3W0gfnlmQQF0+b0gdYTLxMRb1PGwMcfv8bV5Qz/7e88jEfb2de43haayeAkryy8UnFZ1BtlIjDBXHqOgBGoSiuZwlmZXUpo7B2tNKayxSyZvHMizUnHeHZPptOh6YYGa+XGca3EsVsW5LbMNypN0fDpG5PtQTHeQO3KNYbjm4xjKSXxDhvHzSQrh9cRFyvpAmNlidpb6zsmpm6DxHHU1x6qYiHpfJd3oiTHLcg7cyvR0s6SiwspDo0GK5ALJ6fC+HSVbNHqS+M46jdI5ExMy0YIwbPXVvkb91eiCPYN+3ni8taFq66cAqWtPy9Hx0N86cx8BRbknadaGwf3SlOhKS6uXKx53d7IXvZG9pb+ncgn+NSZT2HJajM27Amzmlt1egOUbN3EsVkYppi9C2/0C6TzTxKwH0JVKsctthlF0RIIYTdVjOcqGjDx6Db5otIw47hRLMdulJTyQ8CHtjlG4hjHv7rNcWeAt3Xu0fWH/IbG3VNhvtvFgrzVdLHinDlQte6ZjvDnz82sY5q6Pw7Y4E733tA/NRXh597iYJMe2Bfj/Q/u5eGDMe6Zjvbk/o+u7yC6sJDiwEhnMQYDxnG1/LqftbyzKDLsD6PqcWxzjKgvykJ6Acu26mIdbiVvUbSK6Gr1+zSei5MqOLvCCnbBOcZ2xnlRnwew8aienhe/BvTq+Xm/apA43kE9fHAIv6Hy1fOtc45vrmYHfOM2NB31dYxxnB0kjmvq/n1RZtdyzDaJhqgnt835wRYTx+AU5M01wTj+4ivz3DMd4S137fyKoE/z1Uzp1ttKOxWaImSEuLZ2rXqLjzYHUBNXsZJ1+MYAWbmApmilAqDJ4GTV8ZsVMkIVK6hhTxi1qoi8tbTw5gKgWqb0QAM1o3qoinTBwrJl25OlWGDj95tFVQAspyoXdtwdE7dH4ri2ad+o5juYOD4+EUYIWuYcX1xMVWAqwGEn37+ObQr3Japi471/bi5BKm9WpKTBQTylCxbZwvbmYjxbqMs3dvX7P/4gr/zKOyt+PvTuE63/ET1QM1zfsCfMidHaf0/EE0FXdC6sXCCjPF03cZxLPAKYJLTPYpMnUPx+pKw8h1pmFEVzzuvl58VGztHgFORNxJzvlkYTx4Pz7UCnDwzxwo04ebOzxdeuVjOFQTHeNnrN3igAj19qbEGvXS2tj0GGm9gx1Un9n993nOf+xffyBz/1EH//rYd5cP8QhtYbG+vw+jn9YhcK8pLrrPCBcbyh8oCUEAKfdw2rMErEG0EitwwbmbbJTHKm5nXlu28LVgFDMZC2M270eRwMSa/Txu59DozjgbaVR1N5w5ERvnZ+sWWe3kw8O8BUtKHpqJ/FZL4tXIirTMHErw+++Dfr/n2OwdspXMVTV1c5OBJgtI1ChMmwl5l4lqtL6W2PzRUtnr8R53WH+6PtVAhR88Tm0301J3RCCA7HDuPTfFyOXyZd2PibFW0NTTVZrGEcr+ZWsUwnfZc1V/Hr/lLKeDK0/aS0PG3sPo5aJnHUU/2Yt9PmZNVgIjtQuwrXQVW4/243cezR1NLEoBVUxVKqsuTSXYi7HRjHYa+OELCWaY1x3Ml29YBH4+BwoKVC12zB4uZqliOj1QWm7g6Zfkwcx9YXJ1YzxdL28807etz34XK6dtlquRpJHCuKIODRKn76nWfaqBnr6v6J+/Go1Z91XdU5PnIcr+pllv9CnG9UzQFsy0su+RpE4CvMpa8RVvfjte/FKlYumNvFCKoWByrPiw9MPsCRoSON/V1NGse1sFMD3Vl66ECMvGnz8kx3cM3xTLHnLN3dpvv3Rtk75ON/PlUHRddhXVlK49WVnpTR9ZvCXp2JsLcrBXmpnEnAUPu2GHYntHmOGw3ksIrDBLQwmqIRz8W3/P16uAoXUwGUUsm27QVsDG3njGMhRM9Tzq1qYBzvsL7n2Bg3V7NcWmx+FUtKyc3VDHsGxXgtyy0VbJVnWK5MYYCqqKWTk2EMTeG56+3z0KSUPHNtpa20McAHHtpLwFD54d9/fNuBwHPX4xQsm9ce7J8ymHqc44ngRM3LVUXl6NBRNEXj4upFcqbzfhcCAr7kloljW8TJWZnSfQaNYEMlPJuNY6ht8Ia9zXMZN9//7WwcCyGOCCF+XwjxohDCEkJ8bdP1k0KIfyeEeEEIkRJC3BBC/DchxNSm494qhJA1fn69p39Qn6rEOK5iCRcqrm9Hbnp4uIktuG66ZyVd+bhureXQFMFIcPdP4hRFEPHppfKdZjWfyKOromNGw8mpcEuJ40uLKaSkKnEM8CMP7+Uffs8R9vbhDrENxnSBp66uMBXxVgUS3Pfh5uR7LTViHO9GxXwxfFrj422P5uH+yftrXmeoBncN30VQHGVF/QTXE9crzONc8gGk1FlUPo4iFKaDTjGQVdxYwJZSwbbCpcRx+XnRp/t4y/63NHRuvO9gijeeXGvcOL6NURUDNSZ3YamTGDpXUkpWMoWes3R3mxRF8MGH9vH45WWuNBCCaVeXF1McHAmi3KEG5+kDMb58bqGhXTfNKJU3B3zjTdo8xx2LFQENqzBFxBNhLb91gfGNtRtVpfBFq8hc2tllK6V0EseqgbR9aGoRd926Hg5yIEcD43iH9dZjzlbur55bbPp3V9IFckV7YBy3IXdy1C7nWErJcqow2GpSQ4amcM90pCOJ40uLaVYzRR460N7E5eh4iP/5s69DAh/46BO8PFM/XfbklWWnYb4NpnKnVe/Etrkgr1y6qnN06CgAF1YuULQck8bwLNc3js0wBf15wDGMobG0cUAP1HwstSaxzSaOVUXl5OjJivuqxbK6jXQKeDdOac+rNa5/EPibwB8B7wF+AXgt8B0hRLWDBT8GvK7s53e78Jh3nTyaik9Xt0gctz+JdZOdzZi9EZ+OqogaqIos42HvbZNSifr0llEVC4kcYyFvxxKrp6YizMSzpQb3RuUGAGoZx5MRH//HO4/15aTbNdxXM0WeurpS81w3sp4y25x8r6VGUBW7VY2c/8p1YuRE3YVWVVHZY7yLcPH9LGWWeHXlVYpWESkVcomHyXg/QdpcZU94D16v896yihvbWW0zDCioWhxDNfBqG4l7n+ZDV3Xeefid2yaZokGLN55M0OjH53ZeqB2oMY0EPRwaCZTQcZ1UtmhRMO0BqqIBvf/BPaiK4I+fut71+7q8lObw6J1rqv3tR/azli3ymRdqYxBaVTJvDryDTdqc+j0xbYMokk+9hog3giUtkoX6oa+cmePV5VcrzOPZ1CyW7Zj+lrSQSHRVR9pedM0sHVcvmDWQo4FxvMOaivo4PhFqiXN8Y93snO7DBMtukWu6z8Tba0r97pUVZuJZ3nzX7mDU9Fr3743y4swaBdPe/uAt9Mw1l2/cvol713iIT/7s6/DpKj/y/z7BM9dqJ6KfvLzCyclwRxKHnVK9E9t2W2m9mpcjsSMUrSKzqVkApHaLTF4lk984HUgpiefi2GaIgvJyxX02wnm8d/zempfXmnA2yzg+NXqqYiJ+B0xiPyul3CulfD/wSo3rvwUcl1L+upTyq1LKPwZ+ENgP/K0ax78opXyi7Kc3+xx3gSI+vco4TnQIVQEbSeNy3vF2UhRBzG9UIQJureWYiu5+TIWriN8opbub1Xwyx3gHivFcnVwvyHtltjlcxcWFFIqAAyO7a0zmJvtemlljPpGvuTA7XIe1XUu3a+IYmuMcg2MOPzT1UN3rFS1HzPxJ9odOkC6kObt0lrVkhIJpsSL+nJARYtg3jKLkEWqywji2zOj6bcSr8E1ueWzMF+PN+9/c1GPeSrqilxaRB7qzdfpAjKevrWLbraEW68ndeTJAVWyvsbCXR4+P8adP32x7frWV8qbFjZUMh2pgmO4UPXxwiOMTIT72nWst40VrKZUzCfZh98FOanM4ajIcweN/lXzqbkJ6FIGo7uzZpG9d/xb/46X/wbevf5u51FwV3xjAUAxs24vH2Pjs7ASqYjdpYBz3gd56bIynrq6UAOmN6vycs5XyrvE794u8XU1EvCii/cTxHz5xjYhP5wdfM92hR3Z76fSBIQqmzYc/+0pbPOmnrq4S8+sdW/U+MBLgf/7sIwwFDP7uf3uqagtS3rR49voqrz3YH3xjV/UmbkEjuO2kLmAECBgBMkVnscRUHOZTeeo4kU9g2ia2FSYnXsWv+0sNtlPBrSfOY4GxusZxLTaiX/eXSve2k1/3c9/EfRWX3e7GsZRyy9mAlDIupTQ3XfYqkAGacznucEV8OvFNKVP335EOTGKHAgYhr4ZHaw5pNBI0qhPHa1kmI7fPbqNoDdO+Uc0n8h1tlT+1bhyfaRJXcXEhxf7hQNOv707LTcJ/6cw8UHt3jVvouLQN4zhXtMibdkc+L/2oZo1jgIOxg3XLaxXFOQ9HjQMcHzmOEILL6a+y4PkwYLE/sr+UpFf1ZazCxljENiPrl8cJGxuLqR7VU1Gge9fwXTXRUa3odj/fDtS4HjowRDxT5GILqMWttLqOZRokjhvTj7x2H8vpQun7uxu6tpzBltzRiWMhBD/5+gOcnU3wdJ2gUStK5U1Cg8RxhTaHozRFY2joAtIOYOWOEfaEWc2tspJdIZFPkC6mMW2z6nZyZo6zS2f5y1f/krNLZ0uXl3bcqk45nk/fWAgYGMdba2Ac94G+59goRUvy7YvNNaOenU0SMNS+ZObtFumqwnjYy81468bxQiLHF16e4/0P7hkwjuvoHSfH+V/edJD/8eR13vPb3+LsbGuFGs9cW+XB/UMdLdHZE/PzG3/rXuKZIp9/ZbbiuhdvrpE3bV57qH8wFbA1g6ke57hcPs1H1swipUToDvNpKeEMXCzb4ls3voWUYJk+clwnqDtmdNgT3vK+VaHyPQe+p+7rU4+NuHkrb70T94OTD1aZzIOJbLWEEPcCfmqjLb6yzkq+KoT450KIwZfWuiL+avPS/Xe0A4nj/+VNh/i3f6v2ospWGgoYLJcxjm1bMreWY/I2ShxH/dWmfaOaT+Q6ahyPBD2Mhz0tGceHd2EiK2Co6Krg7GyCkFfjrvFQ1TF+Q8NvqCwlt04cu6/h7YqqGPINVSAhGtXdY3fXvFyojnFsW378up8TIyfwyiMUlatMhabwaBtJelVf2oSqiAKgqImKxLGbNi7X3vDeph9zLQ34xgO5eqhLnOP4IHHclN58dJTpqK+ruIrL64sDh0Z23/mtk3rvfVOEvRof+87Vjt1mKjdAVWxWrTngntEkQkmRT72GId8QRbvIlfgVLqxc4NzSOV6cf7FkCG8nN3GsqzrS8uL3bMxZB4zjrTUwjvtAD+yPEfJofK1JXMXZ2QTHJkJ9yczbTZqO+tpKHP+P717HtCU//sj+Dj6q20uqIvil7z/Jx//uw8SzRd77u9/mY9++0tRtLCbzXFlKt803rqXXHhxi35CfTz59s+LyJy45izkP9xHfGLZmMDVkHOs+bGlTsAoo6hq6arK4ZiCl5OvXvs5schZp+ymIa0jMUop5u7TV6anTW04sNUWr+dgjHic5ZagGr9/7en7k7h/hDXvfUEo5A4z4R7hr+K6q3x0Yx5USQijA/w1cAD5TdtUa8OvATwHvBP4C+BXgN7e4rZ8RQjwthHh6cbF5Dv9uUy1URTxbRFME/g4sCh6bCPGue5pjpAIMBz0sl7Fll9L5/5+9+w5z7CzvPv591KXpdXvz7nrXva2DbWyDbdwAY5qNyUvAIYlfIIQ4EEwJBmNDMM0h9JjkDRBCsYFADBiD6S6A1xWX9a7XXm+fndnpRRqV5/3jSLOaGU2X5uhIv8916dod6Ujzm9mzOtKt+9wPybRleYV1HM9nVMXwaIqBeIr2Io6qAGfO8VwWyEulM+w6PFRwvnG5M8aMdfedtqZpyrnZrbXhSSNTJuodyXULVm7RZ6aRUAXvU7es4AeqPp/z2tOmnf/LPmpoi9/M6uDraa9pH7etP3gYm6khk902nWrE+AcwvhTN0SOvUQot4Dfd+gdzUeisIalOa1pitNaG2bqreN2XAD3Z40DTHBaRrWZ+n+HKLav43Y4udh9e2NjFqezsdBbfW1fFHcfgfID6utNX8dPHD3KwL16UxxyIJ6nT4njjBP1Bgr7xryFaa5oI1z7O6PAmGkPLObH9RI5tPZZNLZtY07AGi6U30Turx4+n4xgMQV8Qm4mOLxxrxvG0VDguA0G/j3OObuVXTx+a9dwcay3bDg6weVnhRTdk9lY0Rdk3z47jZDrDN/+wmxcd3cbaVj3ZzOScjW389O/P4ewNrdxwx5M8tHv2LzhzM4i3lKBwbIzhtaet5L6dh9nTfeSF1x+e62bz0rqyewFbjI5jgJHUCMZAXW0P+7tD/HHfH3m251kAMqk6En5npO7YwnjTvGFui7Vx0tKTZvzehQrLDZEG1jau5TXHvIZj247FGMMxbcdw+abLxwrDZ6w8o+AbbxWOJ/kYzqJ3f2GtHauCWmsftta+z1r7E2vt3dbaa4FPAW8zxhQczm6tvdVau8Vau6WtrW1RwrupUOG4byRJQzRY1LMc5qplQsdx7g3LsobK6ThuiIXoj6dIz3Fe5qF+p5C5pK64v4vjltfzTOfgrEcrPd89TDJtPVk4hiPdfadP8yFpS4GRKRONdRxXcuF4jgvkgbO+QGt08tNsruPYZpwOq9TIGgxBGmpGJz3nBIJdAKSTzriKTKphbGG8NQ1HGhcKdRw3R5tnPRJqOjreSo4xhhesa+Z3OzoZSkw+TXy+ch8gVvJzSLFdefpKfIaSdR0/2znE0vqIOmOBvzhjLRlr+eYfni/K4w0kUtSqcDzJxK7jlmgL4dpHwQYZHTqWoD9INBilNlTr3OYP0zvSO+PjWmvpi/dRF67DGIPNRIhoVMWsqXBcJl68qZ2O/gRPHZh6lch8B/ri9I0kOUaF4wVb0RjlYF98zm9YAX72RAeHBhK88Ux1G89WS22YW648CWPgN0/Pvotx665uQgEfx6+Y22Jqs/Wa01ZiDHz3QafrOJnO8ODzPbxgXXl1G4NTyJ34aWxOY6SxYMdRvtzt8ZRTgApH93OoN8BjB7eNbZNJ1xP3PUnIV0PQ73yvqTqOfcbHi9e+eNxcxakUeuN5QvsJvOSol0wqiDdHm7l80+WcvfrsggXxgC8waVGgamaMeRvwbuBN1to/zOIu3wUCwNznJ1SgQnN2+0aSrs9rbakJMRBPkUg5Rcz9vc7/2+WNldNxnCtcznXOcUe/87so5qgKgGOX1ZPOOB/Qz8aODmc7rxaOcx3HW9ZM/cFsS02YrsEZOo5zRZ8KHVUB85tzDLC8fvL9ch3HmbTzZnU0vg5MkmB476Rt/aFc4bg1+2cjvkAv6xrXjR2jYeo3vlPNWZ4LjaqQfH91zjq6Bkf57C92FO0xeyp83E0pLGuIcv7mdm5/cC/JdPEXyXu2a5CjqrzbOGd1S4zzN7XzzT/uHntNls5YtncMzPn1i7VWM46nMPH9YEu0hUB4P/5gJ/HB8U1KxhiaIk30j/YXnHWcbyQ1QiKdoDHSiLU+rA0RyS6OF/aHx53pKpOpcFwmXny008316+2zG1eRmxF7zFIVTRZqRVOUVMaOvQGdi6/fv4uVTVFevKl95o1lTGMsxIkrGrjnma5Z32fr8z2ctLKhZAsPrWiMcvaGVr774F4yGctje/sYSaZ5wVHltTAeOIXalfUrp7x9ptNS/T4/IX+IkaTzpjXh24bFRypx5I1tOllLwvckNUHnOaYp0lSwkwlgfdN6WmKz+z0VOtU1/01vods2t24ueFtuxIWAMeY1wOeA66y135nl3eyEP6taQzTI8Gh67M0AQN+w03HsppZaZwxDd7br+ECf8/+2kjqOc91lcx1X0TGQ7Tgu8qiKk1Y1AvDont5ZbX/vM4eJBv0cs8ybr8maYkGCfjP2cxfSVheiSx3HY91Nc7WybvIx2/hSYEaxGefYmhxZSzC817l+Al+gF0iRTrZircl2HPdNGuE01QfHszkbaTo+45u0HoFUt1NXN/G6Lav4j3ueY3vH7D5km0nP8Ci14QChgEoUc/H6P1tN50BirPmlWKy17DykwnG+N561lq7BUd77vT/xl//5R06+8Wdc9C+/5dpvPzynxxkeTWMt6jguYOLIiGgwSiwUJVz7GKn4WtLJxnG3N0adr3vjvdM+bu72xnAjNuO8ho4EncKx5hvPTM/KZaK9PsLxK+r59bbZdWDmumA2qXC8YCuyXVtzHVfx9MEB/vBcN284Y82UMwFlamdvbOWRPb30x2f+hHZkNM3j+/oKrvZeTK89bSX7eke4/9nD/OG57HzjMuw4BljTOHWX+2zeIEYCEUZS2X0+uAuAZOLIAjrxVJqM6acu7BxYpzs9dy4dWMU81VWnzTqMMS8G/hv4nLX2U3O462uBFPBYCWJ5zsbsomD37zyyUG1uVIWbWmqdzqvcmIADfXFCAR/NZTZCZyFy3WW9c+zYOZT9wLe9yB3HyxoitNeFeWSWhePf7ujkzPUtJftgs9RecdIK3vriDUSCU+dvqQnTPZQgM83ZWbl/v0ouHBtj5lWEba9pJ+CbXCDw+YbJpGNk0lHSo0sJRiev/7C0dinGZPAHe0iPtpBJ1wIBaqOJSR8UT/UB70LnHDeEG2Z1VpFUl/dcupnaSIAP/ODxWY9bnE7vcLKinz9K5fzN7Zy+tolP/HQbPUNzXy9gKoeHRumPp6p+Ybx852xo5egltfzPw/vY2zPCy09czqXHL+XX2zvZP4dawmB2xEttWPv7RIU+pHTGVThvVxKD40+UjAVihPwheuLTj8Dsjfc6Z+36g2OF43C2cKwxFTPTK4Ayct6mdh7c3UPfLFYWf/JAP6uao9RF9GSzUCubnBfZe3vmtqjAf/1+F+GAj9dtKc5q1dXm7A1tpDN2bAG66Ty6t5dUxk57Gm0xXHzcUuojAW7fuoc/PNvNhvZaWmuL28lWLKsbVk9522wW74kGosRTcay1+PzD+AKHScWPdEQNpZx/l7pwzYyPOZeZjyocz40xJmaMea0x5rXACqAt93X2tmNwFrrbBnzHGHNG3mV93uN8yRhzozHmMmPMxcaYf8UZa/FZa+3M/wmrwPmb22muCY1bJLNvJEmj24XjbIE4N+d4f+8Iyxoirs5dLrbcOJDZvP7J19EfJxL0UV/kjh1jDKesbuThWczhf/7wEM8fHubcjQVHhXvCy05cxjsvnLz4aL6W2hAZO31xv3c4ScjvIzpNAboSzGdchd/nL1hwNv4RbCZKMr4G8BGMTC4cn7XqLJbWLsUf7CKdbCWTcs62WdMy+c31VB3HS2qWYJj/c0Y1HG9l7pprQlx38Wb++Fw3P3hk34Ifr2d4lKZY5XwouliMMdz0yuPpj6f4xF3bZr7DLD2bXRhPHcdH+HyG7771LB6+/kJ+/s4X8bFXn8D7X3oM1jKnju+BeLZwrI7jSRoik88obY424w/2EojsIj5wKiO9Z45dRoeOpynSxEBiYMpxFfFUnJHUCI3hRgAy6Qkdx1oYb0YqHJeRF29yCmn3Pzvze/htB/o5ZqlOGSuGFY3OJ0z7eubWcfyrbZ1ccEx72S2c5hWnrmkkFvLPalzF09kO+xNWlnY0QSTo5xUnL+fOxw+ydVd3Wc43zokFY7TGChcqWmItM76xjQaiWOzYnONgZA/JxEpyDSPDmQP4bC1hfxhjzJTF4WggOqc3lDWhmqIs0gNV80a2Hbg9ezkDODbv63bgBUADcBJwH3B/3uX6vMd5Cngl8E3gf4GXAO8C/nERfgZPCAV8XH7ycn7+ZMdYx07v8GgZdBw7H14dzs6XPdAXr6gxFcBYcb53ZI6jKvoTLKkvTRH9lNVN7Do8PDYiZCq/3eEcw849urIXkMx9iDrdnOO+kVEaYu4uJrkYNjRvmFf37Yq6FZOu8/mdjuPkyDowowQi44tvYX+YpkgTZ606i0Com3SymXTS+RB9U/vkfW6qjuOgP0hzdP6vaTTfWKZy1emrOGlVIx/98bY5z3mdqEcdx/O2eWk9V5+1lm8/sGdWH3rOxrOdgwCsb1PHcb76SHDc+/9VzTFeuKGF27bumfasnHwD2TNu61Q4nqTQKMKWqDMSMVr/AJlUE0Pdl4xdBg5dSZ1/AxZn8btCxsZUZN87jnUch9RxPFsqHJeRtS3OJx0zzdqNJ9M81zWkhfGKJBry01ITmtOoisFEin29Ixy3XDNW5ysc8POCdc3cs2PmwvHB/jgBn6G1pvTdv1ectopEKsPQaHnON86Xv5L6RGeuPHPaN++5N5e5cRWB8F5suo5MqtG53j5P1KzFGENzpJlIoHChaj4rzBer4FsNhWNr7S5rrZnissta+9Vpbr8673E+a6090VpbZ60NW2uPs9Z+xhbj3NIKcsVpqxhNZ/jhI/vIZCwDiVQZFI6dNydjM457R1jeUDkL48GRxdkOzzBDd6KO/jhL6kpTRD95lnOOf7u9k5VNUda1Vna3Sm4/nK5w3Dvsfof+YqgJ1bC2ce2c77eifnLh2PhGsJkYyfhagpE9GJMed3t7bbtzHI42s7o5DARIxp3v3V4/ueAw3eK4C5lzXA3HW5kfn8/wkcuP5/BQgk//7OkFPVavOo4X5NqXbKS9Lsz1P3x8Xou+T7Szc5BwwDc21lGmduWWVeztGZlVAyAcGVWhxfEmm6rjGCBc+zgtaz9K89p/pnntP9O0+tNgkviGzyPoC045rqI33kssECMccGoJmnE8d3MuHGdPj73PGHPYGBM3xjxtjPmAMSaUt40xxrzfGLPHGDNijPmtMebkAo91rDHmF8aYYWPM/uxptJV9fts0GqJBjGHG7pbtHQNkLJ5dhKUcrWiKsncOHce5FdQ3enQF9XJx9sY2nu0amrFo39Efp70ujG8RZkmfuLKBTdlZp2eUcccxTD+uoinaxDGtx0x5e64QnN9xDJBKrCSZTpIyh4j5nK7l6d5szmYsxkQqHEu5OnZ5PcevqOe2rXsZiKewFhpcfhNbFw4Q9Bu6BkdJZywdAwmWNVZWx3FTLMiKxii/2T67dR5yDg0kaC/ywng5J65swGeYtnMrmc5w/87DnHt0W8V32baOdb5P/Rq1dzhZNUWfE9pPmPN9mqPNk7qafP5h0ql6Z75xgTEVS2qOzCY+eaVzvE2ObCAUTBIOTi4MTdVxDAubc1xoYVuRnBNWNvCmM9fy9fuf5/sPzX+Btp6hUZrUcTxvdZEgH3jZsTy+r59v/uH5BT/es51DrGutWZT3X16XG3d429Y9s9p+UKMqphQJRCYtQtsQacDvc8qExjeKz5fA50vgD/QTjj3F6NBJNEVa6E/0k86M/wB2ND3KUHJo/PtG6xyLIyHnOKqO45nNp+O4Bfgl8NfApcD/A/4JuCVvm/finCL7ceAyYBC42xgzVn0wxjQBd+Os5n45cCPOabMfnkemihDw+6iPBGdcVfypA/0A6jguohWN0Tl1HO/ocE7dyS2mJPNzTnYm5D07pi8WHOpPFH3xo6kYY3jXRUfzxjPXLNr3nK/2mvYpO4EBTl126tgnqxP5jI+IP8JI0tnv/aFDYEZJxlcxMOrM+64JOB3X073ZnE/HcTHegNYEawj69eZCiu/KLat48kA/9+10zoZwu+PYGDO2MNmhgTjpjGVZhXUcG2N4zWkrueeZrlkvLmOtdTqOS/Q8HQsF2Ly0noen6Th+6PkeBhMpzt1Y2WMqIG/W9jQdxz3Do2PzqivdsrplU46Lms7EMVLGNwLW+d1OtTBeTnu2CSuTaqSxJjNpW7/xTzsKajYdx+sa13H26rMnXa9RFTKT97/0GM48qoX3fu9PPLCre873T6Uz9MdTY2egyPy8/MRlnL2hlU/c9fS0Z4jMxrNdQ5pvPEuRoJ/LT17BnY8fnNV6DQNji+OpcFzIxK5jn/FN+f4xXP8QNhOlxp7ijKtIjB9XMXFMBUDIOI8f1ozjWZtz4dha+2/W2g9Ya//HWvsra+3HcYrGb8h2GkdwCscfs9Z+3lp7N3AFToH47XkP9RYgCrzaWvtza+2XcYrG7zTGVG1FtLkmRPcMTzZPHRigJuRnVZM+GSmWFY1R9veOzHpF4B2HBggHfKxu1r/BQmxsr2VJfZjfzTCuwikOLN4idRcdt5QbLz9+0b7ffBljpu06jgQinLbstKlvD0bGRlUYkyEQ3k8qsZKBeAJjw2OnvE71ZjPsD4/NnJqL9pr2Od9nInUbS6m84qTlhAI+/v0ep4jjduEYnDEBhwdH2d/rnCGwvMI6jgGuOM2Zsf69WS4uM5hIMTyaLumx4eTVjTyyu3fKmYW/3dGJ32c4a0N5jzUqhqZYCJ+Brmk6jsthMcnFdHz73F8nTJxz7PNnF2Y2CQLh/eNu8/v8tMWOfCgRC2eIhJxOqobY+I4qmL7bGJyV6qcaZWEw/NmKP+PiDRdzfPvxbGrZNHZbbaiWgE/FDZleKODjS284lZVNUa75+laePzw0p/vn5iOr43hhjDHc8IrjGB5N84VfPTPvxxlNZdjdPcxRrTq7drZed/oqRlMZfvjozAtF5jqO68La3wuZbs7xRMHILnyBHnwjFxUcV9Eb7yXsD49rtvJTh89Ygn51HM9WsWYcHwZyHw+eBdQDt+VutNYOAXfgdCjnXArcZa3tz7vu2zjF5BcVKZfnNMWCY4vyTOWpA/1sWlqn00aKaEVTlHgyM7Zq/Uy2dwyyvq0Wv/4NFsQYwws3tHLvM13TLibQ0R9naZl3/7plujnHAJtbN0/ZKRQNREmkE2Ss82lrMLyHVGIpQ8lBQpmjCQSHqA/XT3kwXVq7dF6nZy+vWz7tHMbZUOFYSqUxFuKiY5fw4PM92a/df1HfUhuma2iUA33OBz2V1nEMzuIyZx7Vwu0P7p3V4jId/U4nVak6jgFOWdXIQCLFs12DBW//7fYuTl3dSH3E/X2k1Hw+Q3NNmMNDM8w4LoP/L4tlY/PGac/6KWR5/cSOY6dwHIzsxpjxXcSt0daxU3NzWmqdYkPBwvEsjquFPggO+8NcuvFSTl126th156w5Z6y7q1rHVBhjVhhjBo0x1hhTm3e9RjJOoTEW4j+uPh0LvPmrD8xpsbyebOOUFh1fuA3ttVy5ZSX//fvd7Okentdj7O4eIp2xrG9XJ+ZsHb+igWOX1c9qXEVuxnFNuKKfEuZtujnHExljidQ9TGpkIw2hJfTGe9nZs5PDw4dJpBIMjA7QFGka957VTy3hYIbcVZpxPLN5F46NMX5jTMwYczbwDuBL2UV2NgNpYMeEuzyVvS1nM7AtfwNr7W5geMJ2VaUpFqJnmlEV1lqeOtDPZo2pKKrc0P99s5xzvKNjgKOX6BPYYjhnYys9w0me2N9f8PaR0TT98VTZj41wy8r6ldOu7u4zPs5ceeakN59w5E1mblxFILKXpDnASLqHSOYkfP6Boo+pAOcDg3VN6+Z13xwVjqWUrtyyauzvZdFxXBOieyjBwb5sx3EFFo4Brtiykt3dw/xxFqc5H8ouJNxeosXxAE5Z7RTMHtrdO+m2w4MJHt/fVxVjKnJaa0NTdhzHk2lGkumqOs3c7/NPu5ZAITXBmnGFWJ/fOf4WGlNR6PjbXJctHNekJt02m46piY9ZG6rl1ce8etLZSwFfgAvXX0jAF6jm4+0nccYtTqSRjNNY11rDl99wGru7h/nL//zjrMcP5UY1VtNzSCm944KNYOAzd08syczOzk6nY1wdx3Nz5ZaVPL6vnyf290273UA8STToJ+AvVh9nZSnYcRyb+uyucN0jQIamzOW0xdoYGh1iV98uHu98HCjwvtHGiIScD2sjgci076XFsZDf0FD28jvgN8C7s9c3AYPW2okfhfcAsbxF9JqA3gKP25O9bRJjzDXGmK3GmK2dnXNbQMUrmmpC03YcH+iL0x9Pab5xka1oyhaOZ/HiZiCeZH9fXPONi+SFG5wZgb97pvD/6UMDTnGglF1lXhYOhMctnlPI8rrlvOaY17CqftW463OntebGVQTDe+kL3IaxYepSl+IL9LO0prgL4+Wsb1o/7/uCCsdSWi/c0MqyBuc5p1wKx7lRFdGgn/poZZ42funxy6gNB7h968zjKjrGjg2lG1VxVGsN9ZEADxcoHN/zTBfWwrlHV1PhODzljOP+bGdhOfx/WUzHtR835zecK+tXjv3dHzqIP7SfcM2Tk7YrXDh2fs/18xhVAeM7juvD9bxy8ysLdnaB0911zupzqnK+sTHmXOAS4FMTrtdIxlk446gW/vWqU9h2cIBLPvNb7nh0/4z3Ges4rqKzFkppWUOUq89ay/cf3svTBwfmfP9nc4VjzTiek1eesoKQ38eXf/PstCMwBxMp6rQw3pTm0nEM4A/0EYw+S2rwTFbVr+GE9hPY1LKJJTVLaIu1Tfpg1WYiRLLzjTWmYnYWUjg+CzgH59PTy4HPFyXRNKy1t1prt1hrt7S1VeYL9aZYkO5pOo5zC+Mdu0xFy2Ja2eg8Ycym43jHIaf54GgVjouivS7C5qV13DPFnOMjpyMv3oxjr5luznFOfbieizdczEuOesnY6ThhfxiDIZ5yCjCjdDHk/zV1qZfiNzGMb2TK+cYBX4C2mvk/Dy90XIUKx1JKfp/hqtNXEwv5y+LU+5baMMOjaZ7tGmRZY2ReI2K8IBryc9lJy/jJnw6MncY5ldyxoZRno/h8hpNWNfJIgQXyfrO9k8ZYkONXFC66VaKWaTqOe7OF43L4/7KYakO1rG1cO6f7nLrsVNY1Omfd+AMDNK38N/zB8TMZjTEFPxRe2jQKWFrrJ48AmM0xtS3WNrbI0OWbLqc2NH034abWTWxo3jDj41aS7DiJz+F0CU98caqRjLP00hOW8ZN3nMNRbbX83bce5p3feYSB+NSjK3KNU03qOC6at75oPbWhAJ/62dNzvu+znYO01YWpq4JRTMXUGAvxlhev545H93Prb5+dcruBeIpaFY6nVKjjOOQPUReauv4SqXuITLqR5MhRGGOoDdWysn4lqxtWT3rdnEmHCQedwr4WxpudeReOrbUPWWvvsdbegjOq4q3GmPU4HcO1BWY4NQHD1trcK84eoNCr7absbVWpqSZEPJlhZHRyJwHAtuwnhpuWVvyH1YuqPhqgNhyYVcfxjg7n32Bju07dKZazN7SydVdPwf2+o18dxzNZ0zj9nON8axvX8opNrwCcN6aRwJEF8g4OHsQYP/WpV+PzDxALRafsRFpSs2RBp/UsZFxFwBegLqwPbqS03n7+Bn7xrhcRDrg/f64lO/Px8X39FTumIueKLasYSab58WPTd6h19MepDQdKviL5KaubePpgP0N5hWxrLb/b0cXZG1qraq2DlpqpO457x7oFq6/ok7+Q3GwE/UHOX3c+pyw7ZcptGsONBecnr21P8LaXHqClbvIHK7PpOPb7/Gxu3cwrNr1i1jMdQ/6q+zd9CxAGvlDgNo1knIO1rTXc/pYzeccFG/nBI/t4x7cennLbnrFRFSpUFktTTYhrzj2Knz/ZwUO751ZeebZriKNaVVCbj2sv2MjLTljGzT/dxl1PHCy4zWAiRV2JX794WTgQLngMnG5cRahmG8Y3THzg1Cm3yUmmgmOjKtRxPDvFGubxUPbPdTgHST8w8ePpiQfQbUw4cBpjVgGxCdtVlebsC+6p5hw/eaCf1c2xkr9RqjbGGFY0Rtk7m47jjkHCAR+rmvUkUyx/tq6Z0XSGbQcnzzkeKxyXcI6l1zVHm+d00KsJ1oxtHw1GGUmOkEglODxymMbAMfhpwhcYmH5MxTznG+eb77iKQp9CixSb32fKZhG6llrntUHXYGJshEalOmVVI+vbamYcV3GoP0H7IpyJcsrqRjIWHtt7ZF7hI3t66RxIVNWYCnD2w6HRdMEPeXOvW6ttVAU4Z9DM9YNUYwynLTuN89edT8A3+TX9VOsLGFN4TAXMruMY4Nw1586qyFyNjDEtwE3AO621hdpjSzKSsZLHMQb9Pt554dG87vRVBc/eyOkZThL0G73HLbI3n72O1toQH79z27SjEyba2TnIejVJzYvPZ/j0lSdx4spGrv32Izy+b/K840F1HM+o0Nml042rMCZNuPZRRoeOp3v33zNw6FXE+08lnRz/vjHgCzCaChDOjqrQwnizU6zC8Quzfz4H3Af048x7AsAYE8NZPODOvPvcCVxsjMlvG3sdMIIzM7kqNc5QOH7qQD+bl6rTrhSWNUY42D9z4Xj7oUE2tNdWVZdRqa3NfqK9u8DKvx39ccIBX8XO9CyW5XXLZ94oT+4T22ggSjKTZN/APgyGJdlisc/fP/3CeAuYb5wz33EVGlMh1aal9kiBdFljZRd8jDFcuWUVW5/vmbbI0NEfX5QPFE9e2QjAw3ucbq1nDg1yzX89SEtNiAs2t5f8+5eTtux+2FWg67hvuDpHVYDTQdxeM7994aimo7h0w6WTunqnO/5ORcXgovgo8Htr7U8W85tWwzjGNS019AwnpxxX0Ts8SmMsVLGjmNxSEw7wt+dt4A/PdfP4vsILkU/UPTRK73BSHccLEAn6+cobT6O5JsRffe2BscWNcwYTKX1IMoNCjULTFY4Bapp/QU3zTwmEDjI6vIHBrsvp2ft2bObI77ouVEdi1GjG8RzNuXBsjPmpMeYfjTGXGmMuMsZ8GPg08B1r7U5rbRy4GXi/MeZvjTEXALdnv9fn8h7qy0AC+L4x5iXGmGuAG4BbJsyDqirN2dNRe4YmH1RHRtPs6hrSwngl0lYbpmtg6vnSOTs6BjTfuMhWZ7u3nz9cqHCcYEl95c70LJYVdSvmtH1r1FmUMFe47Yn30BJrIRbtw5g4/mD3lG9cfcY3rze1ExljOKrpqDnfb6q5yyKVKjeqAmB5hXccA7zq1BXUhgO88gv38rLP/o4v/OoZdnYOjtumYyC+KLPvm2pCrGut4ZHdvWzvGOCqW3+PtfDta84YV9CvBrnO98MFFnHuHcmdZl51Yw2A8QvezdWS2iVctP6icZ3HMy16W8hC1g0QMMYcB7wZuNEY02iMacQ5ExagwRgTRSMZ5y33Wn9Pd+EmnZ7hUS2MVyIXHee8bn5kz8y7nrV2bLv1beo4Xoj2ugj/cfUW+kdSfHrCnOmBeIrasPb36cx1gTwA40sSbbyf+qXfoXnNJ6lpvQNsiHTyyIiLWLCBVMY3NqpCM45nZz4fczwAXA2sBVLAs8D7cArBOTfjFIrfB7QAW4ELrbUduQ2stT3ZovLncRYU6AX+Bad4XLWaa5wnkEIL5O3sHCRjYZM6jkuitS7M4aEEmYzFN0U3cX88yYG+OBuX6EBaTJGgn6X1kSkKx3GWar7xjFbUz61wPNZxnNehtLRmKcakaVz5b4RDo7REryx437ZYW8FTa+djffN6nuh8Ytbbh/whNrXObZ6kiNflCnZQ+R3H4LzZ+tk/nMtP/nSAn/zpAJ+862k+edfTbFpSx0tPWMalJywd+1BxMZyyqpFfbDvE62/9PX6f4Zt/cwYbqvAU3lyhvNCc497hJAGfoSbk/kxwN6ysX8nW/Vvnff+ltUu5eP3F3LXzLsL+MPXhuTeJqON4wTYCQeD+ArftBf4D+CZHRjLmV4I0knEGucLx7u5hjl0+ef/uGhwda6CS4lreEKG5JsSfCoxMAIgn09z+4F7+8Oxhtu7q4WB/HGNUcyiGzUvreeGGlkkzpgfiSeo0qmJahTqO60J1hPwhRtNOraw+XI/f+OmJT/5QxBgIhvcAkE62EQg7pcio35kWpFEVczPnvdVaez1w/QzbWJxTfT46w3ZPAufPNUMly3Vq9BYoHOdmva6ogjeNbmirDZNMW/pGkjRN8cJlR4fT8XR0uw6kxba6Jcbu7qFJ1x8aSHBcgReYMl59uJ7aUC2Do4Mzbwy0xpyO46AvSNAXpD5cTzjgFAX8wW6W1K2YcmZjU3TSeL55W1a7jFgwxnBy8ocGhRzTekw1LtQjVS4WChAN+hlJpqui4xhgeWOUvz7nKP76nKM40DfCnX86yE8fP8hnfrGdf7l7OwDti1U4Xt3I9x/ex5L6MN/6mzM4qkq7sFpzHceDhTqOkzTGglV7dlB7TTtBX5BkpvBp+LOxrG4ZF62/iB3dE9ddm5nBqON44e4Bzptw3SXAe4CX4jRLPc+RkYwfgXEjGW/Nu9+dwLuNMXXW2oHsdVU9knFVU67juPDrvV1dQ1x47MLPZpPJjDGcsKJh3Kz+fD98ZB/X/+BxltZHOH1dM6evbeKs9a0sV82hKE5a2cjdTx2ibyRJQzSItdZZHE+F42kV6jg2xrCkdgmxYIyNzRtZWruU7pFu/mfb/xSc4e0PHgYypEbbyJ0jFjbO+9hI0Nm+NlSdr+nmSntrmWnMLirSXeA0wIO5RcLUfVkSrXXO00nnYGKawrHz2k8dx8W3pjnGr7ePXxDEWktHf5zzq2yO5HytqFvB04efnnlDnINkOBAmkUpwbNuxk4rE0y2MN59OqKnkxlU8fujxGbf1GR8nLDmhaN9bxEuaa0Ls6x2pio7jiZY1RHnz2et489nrONQf564nDvL7Z7s5b9PizAK99IRlPLa3j789b8PYTP5q1FJz5HXSRH3DyapcGC/HZ3wsr1vO833PL+hxltctn9eYinAgXLVF+2Kx1nYBv86/zhizNvvX31lrB7PX3Qxcb4zpwekefieFRzK+A2ck48eBo6jykYwNsSD1kUDB9Uz6hpMcHhrlqLbqfX4ttRNXNvDFX3cxMpomOuHMkD88101LTYj733e+nkdK4OTVjQD8aW8fZ29sZSSZJmPRjOMZTLUY+sXrLx73dXO0mU0tm9jWNflkDuNL4Qv0kE4eeb0YMM772HAwg9/4NeN4loq1OJ4UScDvoyEapKdA4bijP4ExRzo+pLjGFn0ZmPyGKGfHoUEiQd/Yp+ZSPGtaYnQOJBgeTY1dN5hIMTyaXpQ5lpVgzuMqos64ioAvMLlwPM0c4akO5PO1rnHdrLY7qukofSosVau1NkRdJFD1bzTa6yP8xZlr+cL/OXXROn9ba8N88oqTqrpoDBAN+akJ+afoOB6lqUrnG+csZM5xPr9v7uM+9MZ3Ud2Mc1bt+4AfAfUUGMkIXIAz1uIO4MM4Ixk/tOhpy4hzduHkwvHOLudsuaNa9RqvVI5f0UA6Y3nywOTPLbbu6mHL2iYVjUvkxBWNADy6txeAwbjzXrdWHcfTCvqDsz62nbbstCnPSA2EOkmPOoVjn/FRE3DOuo2EMnpfOQcqHJehpliQnuHJp7od6o/TWhsm4Nc/Wym01TlPNoU6aXK2dwywob12yhnIMn+rW5w35PkvKDv6nX8LddnPzvK65XPaPlc4nshv/LTVTN3JV8yOY3BOzw37Z/5w4KQlJxX1+4p4ybKGKGtaVBwSd+XWg5ioZ8gZVVHNilU4ng+NqSgNa+1XrbUm122cvc5aaz9qrV1prY1aa8+x1j5c4L5PWmvPz26zzFp7vbU2vbg/QXlZ3RwrOKri2U5nVN06dRyXzIkrnaaPxyfMOe7oj7O7e5jT106/6JjMX0MsyFGtNTyypxeAgUS2cFzljQCzMdtmpWgwOuX7RH+ok3SyBWt9TrOSdY6XkaAKx3OhCmQZaqoJ0TPFjGN1XpZOW61TnOycruO4Y1DzjUtkTXbRjPwF8g5lx7O016lwPBu1odo5dQPn5hxP1FYz/eJ3hWZOLYTP+FjTuGbabZbVLpu2mC1S6W54xXF84c9PdTuGVLmWmhBdhUZVjCRpiFZ3x3FTtMm11dkjAb1OkvK3qjnG3p4R0pnxs0if6xok4DNjC+hJ8S2tj9BaG5405/iBXd0AbFHhuKROXtXII3t6nfnG2Y5jzTie2Vzecx7ffjx1ocl1Gn+wE/CTTjZz/JLjSYw6JdBwKENdWHWd2VLhuAw1x0IFZxx39CdYogJaydRHA4T8vik7jvtGkhzsj7NxiZ5gSiHXSbc7r3DcMZCb660PTGZrLuMqWmKFO46PajpqyvtEApGSLE63tnHttLeftFTdxlLdljZEWNOibixxV0ttuPCoiuHRqu84hrmPjCoWjaoQL1jdHGM0nRlb8D3n2c4hVjfHCOqs2pJxFsir50/7esddv3VXD9GgXwuRl9hJqxrpHEhwoC/OQG5URVjHzJnMpSHK7/OzZfmWydeHnDWU6v1H0xZrI550nmciwUzBQrMUpmfnMtQYC9FbaFTFQJwlVbKauhuMMbTWhugamPyGCOCZQ87CeEdrYbySaIyFqI8EeL57aOy63KiKdo2qmLW5jKtoCDdM6iz2Gd+0heNij6nIWVW/Cr8pPNexIdwwY2FZRERKr7U2RNeEwvFoKsPQaHpsgedq5ta4imhQoyqk/OU6iifOOX62c0gL4y2CE1Y28syhwXHryTywq5tTVjeqaF9iJ61qBODRPb0MJpw6jzqOZ9YYaZzT9uub17Osbtm46wLBLgAaApsBiI/68PssAT8aVTEHeoYoQ801wUkdx8l0hq7BUXUcl1hrXXjKjuPtHc54s40aVVEya1pqxo2qONgXpzasxaDmYkXd7LudjDGT5hyvqF8x7SmvxV4YLyfoD05Z9D5l2Skl+Z4iIjI3rbVhuocSZPJONe8bcd4Eq+N4bsfgYtKMY/GCQoXjdMby3OEh1lX54qOL4cQVDWQsPLnfWSBvIJ7kqQP9GlOxCI5ZVkfI7+ORPb15Hcd6fzuT+YxHvGDdBeMKzsY3SiDYR2rUGdGYSPqIhDIAGlUxByocl6GmmhAjyTTx5JH1Ew4N5BYJ0yn7pdRWG6ZrihnHOzoGiQb9rGzSi/NSWdMSGz/jeEBzvecqGozSFGma9fYTx1Wsb1o/7fal6jgGWNe0ruD3O7rl6JJ9z3JnjNlgjPk3Y8xjxpi0MebXBbYxxpj3G2P2GGNGjDG/NcacXGC7Y40xvzDGDBtj9htjbjRmijZvEZECWmpCZCzj1uLoG3H+3hir7hnHADWhmjkdg4tFHcfiBcsbo/gM7M0rHO/vHWE0leGoNnX+ldoJ2QXycnOOH9rdS8bCn6lwXHLhgJ9jltfzyJ5eBhOacTxb83nfGQlEuHj9xeNGODXXJTk84Hy4HU/6iASzhWONqpg1FY7LUFP2hXf+i/LcLKglOmW/pNqm6TjecWiADe21+HxmkVNVjzUtMfb1jpBMO0/mHf0J7fPzMKc5x3kdxwFfgDUN0y9SV+yF8fIV+t6nLTsNn6nqQ9VxwEuBp4HtU2zzXuB64OPAZcAgcLcxZmluA2NME3A3YIHLgRuBdwEfLllyEak4LbXOh7mH886My41XU8exw41xFeo4Fi8I+n0sb4yO6zh+tssZUXeUOo5Lbkl9hPa6MI/vcwrHW3d14/cZTl7d6G6wKnHyygb+tK9v7CydGnUczyjgC8xr0dm6cB0Xr7+YkD9EJBBhVXOQ7v4AGQuJpCEczGAw1IT0vDNbVf1uvFzlCsf54yoOZQvH7eq+LCnnFMzRSav9AjzXpdOoSm1Ncw3pjGV/7wjgfGCiwvHczeVU2dZY69jf1zSsIeif/o1/KTuOa0I1tNe0j33dEG6o6m7jrDustaustVcAT0y80RgTwSkcf8xa+3lr7d3AFTgF4rfnbfoWIAq82lr7c2vtl3GKxu80xmhFFBGZldZs4bgr70P2scJxVB3HAKevOJ3z153PusZ1k9YRKBUtjidesbo5Nr5w3OmMAlTH8eI4cWUDj2ULxw/s6ubYZfUambBITlrVyPBomkf29BIJ+jRXepbmOuc4pyXWwoVHXcjx7cfT3pAmlfHRN+QnPup0HMeCsWpvTpoT/abKUFO2Y6Nn6MgCeblFwlREK622ujDpjB3X7Q3OjOkDffGx2VxSGqtbnN/v84eHsdZyqD+hD0vmYUX9imm7j5qjR05Ja4o2jS1Kt6F5w4yPXaoZxzn5i+Cdtvw0jKnuDn9rbWaGTc4C6oHb8u4zBNwBXJq33aXAXdba/rzrvo1TTH5RcdKKSKVrrXWKw4fzFsjLvWZSx7Ej5A9xdMvRXLzhYq4++WpOX356yb+nRlWIVziF45Gxr5/tHKIuEhh7bpHSOn5FAzs7B+kdHuWRPb2crjEVi+bk7AJ5f3i2m9qwjpeztZCzeJbVLePkpSfTWu/U1br6g8STPsKhjOYbz5EKx2WouabwqIqAz9Cs+XElleuk6Zww5/hAb5x0xqpwXGJrcoXj7mF6h5OMpjNaEHIeQv4QZ68+u+BtQV+Qi9dfjMEpyPqMj6ZoE5FAZMYRF0FfsORvTnOF48ZIIxubN5b0e1WIzUAa2DHh+qeyt+Vvty1/A2vtbmB4wnYiIlNqKdBxnDvttkGF40kCvgAnLz152kVni/E9FquzWWShVjXH6BpMMDzqzHl9rmuIo1prqr5RYLGcuLIBa+E7D+whnsxw+trFn8lerda21FAfCTCSTFOv+cazduKSExd8xmtLnfM65fBA0FkcL2g133iOVDguQ00FC8cJ2uvCmq9bYm11k98QAezpcU6pWtmsjo5SWlIXIRTwsfvwEB0Dmuu9EOub14/r3s15wcoX0BBpoDZ05JTAllgL6xrXzXi6TinnG+c0R5upD9ezZfkWvYmYnSZg0FqbnnB9DxAzxoTytustcP+e7G2TGGOuMcZsNcZs7ezsLFZeEfGwxmgQv8+M6zjuHU7i9xnqdLpzQX6fn00tm0r2+JpvLF6Sa8LZk+06frZzUGMqFtHxK5zX8l+7bxcAW9RxvGh8PsNJ2a7jWhWOZ83v83PmyjMX9BiRkKU2knY6jrOjKvLfC8vMVDguQ43RyaMqDg3EWdKgAlqp5U6TmthxnJvFpY7j0vL5DKubYzx/eDhvPItGVczXOavPIeQ/cpbC0tqlHNd2HMC403Naoi2sb14/4+OVcr5xvlOXncr6ppnzSGlZa2+11m6x1m5pa2tzO46IlAGfz9BcE+LwUN6M45FRGqJBfdg3jWPbji3ZY2tMhXjJqux7qd3dwwyPptjfF9fCeIuovS7C0voI+/virGutGWuaksWRG1ehudJzs65p3YIXnm2pT3KwJ0TGGo2qmAcVjstQwO+jPhIY13F8sC+uU/YXwZQdx93DBHyGZQ16cV5qa8YKx+o4XqiaUM3YJ7R+4+fFa1889sY+vwi8umE1S2qWzPh4pZ5vnLO5dbMKELPXA9Qakx1UfUQTMGytHc3brtA/YFP2NhGRWWmpCbGvN86hAefS0Z/QfOMZNEQaWFW/qiSPrYXxxEtW5xWOn+saArQw3mI7YaXzcnDLGo2pWGwnrWwEVDiejxeueuGCFrNrqUvS1e+8VokEMxpVMUcqHJep5poQ3UPjZxyr87L0asMBwgHfpI7jPT0jrGiK4teokJJb01LD7u5hOvqcwrE+CV+YY9qOYUXdCk5bftq4VWnzD5a1odpZFWoXq+NY5mQb4Acmrmw4cabxNibMMjbGrAJiE7YTEZnWkvoIv93eyZ999Bf82Ud/wc+f7KC1RsfqmRzXflxJHlejKsRLmmJBasMB9uQVjtep43hRnZgdV6GF8Rbfiauc371GVcxdU7Rp7MzZ+cgtkAcQ1qiKOdMeW6YaY6GxjuOR0TT98RTt6rwsOWMMbXVhuvJm94HzqfiqJnV0LIY1LTFGkmke399HUyxIJDixkVLm6vx15086lXU+ReDFmHEsc3Yf0A9cAXwEwBgTAy4Dbs3b7k7g3caYOmvtQPa61wEjwG8WL66IeN0HLzuW+3ceHnedChAzW9OwhtpQLYOjg0V9XI2qEC8xxrCqOcbu7uGxBeFVOF5cL97Uzjf/uJtzjm51O0rVaa+LcNb6lrHOY5mbLcu38Ez3M4ykRuZ839b61NjfIxpVMWcqHJep5poQh7KLgx3SImGLqrU2PKnjeG/3MBcdt9SlRNVldYtToH9gV4/2+SKpCU1+QT6fwrE6jhdftgj80uyXK4B6Y8xrs1//xFo7bIy5GbjeGNOD0z38Tpwzij6X91BfBt4BfN8Y83HgKOAG4BZrbX/pfxIRqRTr22pZr1PL58wYwzGtx/DA/geK+rgaVSFes7o5ys7OIeojAVY0RomG1CSymE5Y2cD977vA7RhV65t/c4bbETwrHAjz2mNfy3O9z7GzeycHBw9isbO6b37HcX0kSMCnUuhc6LdVpppiIZ4+6DSFaZGwxdVWF2ZPdjE8gKFEisNDo6xqVkfHYliTnX3WPTQ6tvKvFN9cP2X1G79O6XFHO3D7hOtyX68DdgE34xSK3we0AFuBC621Hbk7WGt7jDEXAJ8H7gB6gX/BKR6LiMgiOKbtGB488CAZmynaYy6vW160xxJZDKubY/z66U6iQT9HtanbWERmryZUw/Htx3N8+/EMJ4e5+9m72T+wf8b7xcIZoqE0I6N+Wmr0getcacZxmWqKBcdGVWiRsMU1seN4T49TRM4t5iCltbIpRm6U9BLNNy6ZWDA2p09a1W3sDmvtLmutmeKyK7uNtdZ+1Fq70lobtdaeY619uMBjPWmtPT+7zTJr7fXW2vSi/1AiIlUqFoyxrnFd0R6vLlRHc1RjQsRbVjfHSKQyPHmgX2MqRGTeYsHYnD48bcl2HbeqcDxnKhyXqaaaEMOjaeLJ9JHCcZ0Kx4uhrS5M9/AoqbTTDbL7sFM41ozjxREK+FjW4HR368OS0prLarIqHIuIiCzcSUtPKtpjrWlcU7THElksq7LNOOmM5SgVjkVkAZoiTbPeNjfnuL1O843nSoXjMpVbLKBneJSO/jiRoI/6qCaLLIa22hDWOqMSAPb0OMPXV6njeNGsyc451niW0ppLMVgL44mIiCxce007qxtWF+Wx1jSocCzek38W51Galy4iC9AUnX3h+OR1g5x7XC9NUTVEzZUKx2WqKRYEoGcoSUd/giX1EYwxLqeqDm3Z8Qidg864ij3dw9SGA2P/JlJ6ucJxuzqOS2ouc44bwioci4iIFMOW5VsW/BhBX5AV9SuKkEYAjDGvNcbcZ4w5bIyJG2OeNsZ8wBgTytvGGGPeb4zZY4wZMcb81hhzcoHHOtYY8wtjzLAxZr8x5kZjjFaAy1rRFCX3tlYzjkVkIRojjfjM7MqaS5uSnHXMgNbtmQcVjstUU2x8x7HGVCyescLxwJHC8cqmqAr3i2h1s/MiUqMqSmsuHccaVSEiIlIcxeg6Xlm/ctZvlmVWWoBfAn8NXAr8P+CfgFvytnkvcD3wceAyYBC42xizNLeBMaYJuBuwwOXAjcC7gA+X/kfwhnDAz7L6COGAj+UNWnxcRObPZ3xzfp8610XiBTT7oEzlRlV0D41yaCDBcctVtFksrbXjC8e7u4e1cMMiO/foVu5+qokN7fo0sJTmMuNYoypERESKZ8vyLezu2z3v+2u+cXFZa/9twlW/MsbUA39rjPk7IIxTOP6YtfbzAMaY+4FdwNuBD2Tv9xYgCrzaWtsP/Dz7ODcYYz6Rva7qrW2toTEWwudTY46ILExTpIneeO+st5/Le2Bx6GPqMtU4seNYnZeLJlc47hocxVrL3p4RzTdeZMctb+B7bz2L2rA+2yql2X466zM+ndIjIiJSRO017ayqXzXv+2u+8aI4DORGVZwF1AO35W601g4Bd+B0KOdcCtw1oUD8bZxi8otKmtZDbrz8OD59ZfEWihSR6tUcbZ71tkFfkHBA6yjNlQrHZaoxO093T/cww6NpLRK2iGrCAWIhP50DCboGRxlJpsct4iBSKWZbOK4N1ep0WBERkSI7fcXp87pfe0070aBO8S8FY4zfGBMzxpwNvAP4krXWApuBNLBjwl2eyt6WsxnYlr+BtXY3MDxhu6q2ob2OY5bpjFoRWbi5LJCnMRXzo0pAmQr6fdRHAmw7OABo1utia6sL0zWYYHf3MACrmvXiXCpP0B8kEpj5uaUl2rIIaURERKrLfLuO1W1cUkPZy++A3wDvzl7fBAxaa9MTtu8BYnmL6DUBvQUetyd72yTGmGuMMVuNMVs7OzsXGF9EpLo0RWZfONZZtPOjwnEZa6oJ8dQBp3DcrsXxFlVrbZjOgQR7e5zCsTqOpVLNputYq7aLiIiUxubWuTehar5xSZ0FnIOzoN3lwOdL/Q2ttbdaa7dYa7e0tbWV+tuJiFSUxkgjhtnNS9d84/lR4biMNcVCdA06C7QtbVDheDG11WY7jg87heOVTSocS2WazcFzed3yRUgiIiJSfVbUr5j1G16AmmANrbHWEiaqbtbah6y191hrb8EZVfFWY8x6nI7hWmOMf8JdmoBha+1o9useoNCKwk3Z20REpIj8Pv+cRjDK3KlwXMaasnOOAdrrNON4MbXWhegcTLCnZ5j2ujCR4MTXiCKVYaaDbDQQndOCAyIiIjJ7kUBkToVgdRsvqoeyf67DmVvsBzZM2GbiTONtTJhlbIxZBcQmbCciIkUy2znHmnE8Pyocl7GmGmdUVl04QE044HKa6tJWG6F3OMmznUOs0pgKqWAzHTw1pkJERKS0VtavnPW265vWlzCJTPDC7J/PAfcB/cAVuRuNMTHgMuDOvPvcCVxsjMl/gfU6YARnZrKIiBTZbOccqyFqflSNLGPNMadw3F6vbuPF1lrn/O7/tK+Pl56wzOU0IqUzU8fxijoVjkVEREppZf1KHj748Izb1Yfr9YFuiRhjfgrcDTwBpHGKxu8CvmOt3Znd5mbgemNMD0738DtxGrE+l/dQX8YZcfF9Y8zHgaOAG4BbrLX9i/PTiIhUl9l0HLdEW1Q4nicVjstYruN4Sb3mGy+2tlqnWJ9IZVjVFHU5jUjpzFg41htUERGRklpWt4yAL0Aqk5p2u/kspCez9gBwNbAWSAHPAu/DKQTn3IxTKH4f0AJsBS601nbkNrDW9hhjLsBZVO8OoBf4F5zisYiIlMBsOo43tW5ahCSVaU6jKowxVxhj/tcYs88YM2iMedAY8/oC2/2NMWaHMSae3eaCAtusMMb8jzFmwBjTZYz5fPZ0H8lqiqlw7JbWvJnSKzWqQipYbah2ykV56kJ1s15oQERERObHZ3wzLkRrMCocl5C19npr7fHW2lprbaO19lRr7eestcm8bay19qPW2pXW2qi19hxr7aRWcWvtk9ba87PbLMs+dnpxfyIRkeoxU8exz/jY2LxxkdJUnrnOOH4nMAj8A/AK4FfAN40xf5fbIFtI/jLwdeBSnNN9fmSMOT5vmyBwF7AGuAr4e5x5UbfO+yepQM01zuJ4GlWx+HIdxwCrVTiWCuYzvilXl53pTayIiIgUx0xzjlc3rCYW1GtSERGRiQK+AHWhqdfuWVW/imhQZ5LP11xHVVxmre3K+/qXxpjlOAXl3GynG4CvWWtvAjDG/AY4BXgv8IbsNq8FjgE2WGufy26XBL5tjPmwtXbHfH6YStOY6ziuU8fxYmvL6zjW4nhS6erCdQyMDky6XmMqREREFseq+lXT3n5M2zGLlERERMR7mqJNBd/TgsZULNScOo4nFI1zHgaWAxhjjgKOBm7Lu08GuB2n+zjnUuCBXNE46wfAKHDJXDJVslXNMfw+w8YlhbsBpXQiQT914QBBv2GpRoVIhZtqHIUWxhMREVkcTdEmaoI1BW+LBWOsaVizyIlERES8Y6o5x2F/mLWNaxc3TIWZ66iKQs4Etmf/nhu8tW3CNk8BzcaYtrztxm1jrR0FduY9RtVb0Rjl/vedz9kbWt2OUpVa68KsaIzi9xWe/ypSKQqd1tMYaaQmVPgNrIiIiBTfVOMqNrVswhi9HhUREZnKVHOON7ZsxGeKUfqsXgv67WUXvXsl8OnsVbl/qd4Jm/ZMuL2pwDa57aacam2MucYYs9UYs7Wzs3Meib2nvS6iF4ouOXZZPSevanQ7hkjJFeo4Vrexdxhjfm2MsVNczsxus6vAbQfdzi4iIkesaig8rkKL4omIiEyvOdpc8PpNLRpTsVBznXE8xhizFvgm8ENr7VeLFWg61tpbyS6gt2XLFrsY31Oq1+def4rbEUQWRVO0CZ/xkbGZses039hT3gZMrP7fiLO+wAN5132TI+sRgDMeSkREykShD22X1y2nIdLgQhoRERHvKDSqojnaTFtNW4GtZS7mVTg2xjQDdwLPA/8n76ZcZ3ED4zuKmybc3pPdZqIm4NH5ZBIpNp9GVEiVaI218ucn/DmPdTzGU51PkcwkWV633O1YMkvW2ifzvzbGhIAtwHestam8mw5Ya3+/qOFERGTWosEorbFWuoa7qA3Vsr5pPce2Het2LBERkbIX9AepCdYwlBwau+7olqNdTFQ55lw4NsbEgB8BIeDl1trhvJtzc4s34xSVyfu621rbmbfduHOusm90jwK+PNdMIiKyMLWhWs5adRZblm9hV+8uIgEtCulhl+B8EPstt4OIiMjcnL78dMKBMEtrl7odRURExFNOW34a1loaIg00hBuoDdW6HakizGnGsTEmANwObAQusdYeyr/dWvsszkJ5V+Tdx5f9+s68Te8ETjfG5C8P/AogDPx0LplERKR4Qv6QPpn1vquAvcDvJlz/V8aYUWNMnzHmuxOOwSIiUgbWNK5R0VhERGQejm07luPaj2Nl/UrqwnVaL6xI5tpx/EXgpcDfAy3GmJa82x621iaAG4BvGGN2AfcCb8IpNP953rbfBf4J+L4x5nqcsRX/AnzTWrtjHj+HiIhI1cueFfQK4N+stflrAfwQ+D1OQfkY4EPA74wxJ1hr+6Z4rGuAawBWr15d0twiIiIiIiJSfuZaOL4o++e/FrhtHbDLWvstY0wt8B7geuAJnJEWj+c2tNYmjTGXAJ8HbgMSwLeBd88xj4iIiBxxGVDDhDEV1tq/z/vyd8aY+4BHgL8EPlPogbQgrYiIiIiISHWbU+HYWrt2ltt9BfjKDNvsBV45l+8vIiIi07oKeMZau3W6jay1jxtjngZOXZxYIiIiIiIi4jVzmnEsIiIi5ckY0wBcyuwXxbPZi4iIiIiIiMgkKhyLiIhUhlfhLDI7Y+HYGHM8sBl4sNShRERERERExJvmOuNYREREytNVwKPW2qfyrzTGvAx4A/AjYD9OwfgDwG7gq4ucUURERERERDxChWMRERGPM8a0AhfgLEo70R6gHWcRvEbgMPBT4P3W2v5FiigiIiIiIiIeo8KxiIiIx1lru4DgFLc9hlNUFhEREREREZk1zTgWERERERERERERkXFUOBYRERERERERERGRcVQ4FhEREREREREREZFxjLXW7QzzYozpBJ53O0dWK9Dldoh58nJ2UH63eTm/l7OD8rtljbW2ze0Qi62Mjrle3W9ylN9dXs7v5eyg/G7ycvaqO+aW0fEWvL3vgPK7ycvZQfnd5OXs4O38Ux5zPVs4LifGmK3W2i1u55gPL2cH5Xebl/N7OTsov1Qnr+83yu8uL+f3cnZQfjd5Obu4y+v7jvK7x8vZQfnd5OXs4P38U9GoChEREREREREREREZR4VjERERERERERERERlHhePiuNXtAAvg5eyg/G7zcn4vZwfll+rk9f1G+d3l5fxezg7K7yYvZxd3eX3fUX73eDk7KL+bvJwdvJ+/IM04FhEREREREREREZFx1HEsIiIiIiIiIiIiIuOocCwiIiIiIiIiIiIi46hwLGXBGOPpfbEC8hu3M8yXsrvH6/lFqlUFHLM8m9/rz5tezq/sIuIGjx+zPJsdvP/c6eX8yl5ZPP1EIJXBGBO01mbczjFfFZC/1np02LmXs2e92RizATz7wszr+UWqTgUcszyb3+vHLK/nx9vHLC9nF6laHj9meTY7eP+Y5fX8ePu45eXsJaFfAmCMOcEYc4kxpsHtLPPh5fzGmEuBLxhjYm5nmY8KyH8+8L/GmJe7nWWuvJwdIJv7K8A/AHjthZnX84t7PH7M8mx2qIhjlmfzV8Axy+v5PXvM8nJ2cVcFHLO8nt/LxyzPZoeKOGZ5Pb9nj1tezl5KKhw7fgJ8F3i/MeZEY0zQ7UBz5OX8XwcOWWuH3Q4yT17P/2VgL3DI7SDz4OXsAF8AHgVeb4z5nDGmHjx1aozX84t7vHzM8nJ28P4xy8v5vX7M8np+Lx+zvJxd3OX1Y5bX83v5mOXl7OD9Y5bX83v5uOXl7CUTcDuAm7L/+PXAfqAO+CvgauCTxpjbgP3W2pQxJmytTbiXtLAKyP9BYAS4Ne+6IPBCYADYB/SUY3aoiPx/CwSB6621z2evOxV4GTAE9AE/stZ2uJeyMC9nBzDGfAjng7u/AN4GvBn4I/BfXjglyev5xR1ePmZ5OXtOBRyzPJu/Ao5ZXs/v2WOWl7OLe7x+zPJ6fvD8Mcuz2aEijllez+/Z45aXs5ectbbqL8AFwF3AycDHgCTwAPBaoAH4LXCJ2zkrKX821xDwV3nXvQL4DZAAMsCTwLVAXfZ243buSsmfzXMj8F9ANPv1/8V5gXYYOAg8DfwIuLjc8ns8eyPOi7G/zrvua0Ac+OtyylqJ+XVx/+LFY5bXs3v9mFUB+T17zPJ6fi8fs7ycXZfyuHj1mOX1/F4+Znk5e15ezx6zvJ7fy8ctL2dflN+P2wHK4YLzic6PgK9kvz4N+Fn2ifFRYBD4M7dzVlJ+4N+z+XJPeKHsk+EPgWuA84BvZ7e52e28lZY/m/ldwLPZv0ezT4ofBtpxPml7C/Aw8Dsg5HbeCsr+XeBBnA4Kk71uHfBTYAdwmtsZKzm/Lu5fvHjM8np2rx+zKiC/Z49ZXs/v5WOWl7PrUh4Xrx6zvJ7fy8csL2fP+xk8e8zyen4vH7e8nH1Rfj9uByiXC3AmsBN4Sd51b8T5ZDMOfBI4Fgi4nbUS8uN8cvkk0A9cj/Op2u+BFRO2ew/Op55nup25kvJns50KHABeBxydPfismrDN0dl96Fq381ZCdpxPMr8GvLDAbZuAbcBzwCluZ63E/LqUz8VrxyyvZ/f6MasC8nvymOX1/F4+Znk5uy7ldfHiMcvr+b18zPJy9rxsnjxmeT2/l49bXs6+aL8jtwOU0wW4Gbgt7+t/wzkV4J+zT4y7yZ6SUY4Xr+XH+QTtvdkDUwZnjkzu051g9s/TcOb4vNbtvJWWP5vvI0AP8N9AN3BO9vpY9k8f8Avg025nrZTsQCsTTnXJ229OxXmx9jNgde7ncDtzJeXXpXwuXjtmeT27149ZFZDfk8csr+f38jHLy9l1Ka+LF49ZXs/v5WOWl7Pn/QyePGZ5Pb+Xj1tezr4YFx+CMSaQHcL/DeBFxpi/NMacAvwN8GFr7fuBY4B3WmsHjDFl9Xvzan5r7Yi19mbgOOCDwB6b/V9orU1mN4vjrCYacSfl1LycP29V0C/grJp7Gs5pGVcbY4L2yAq6LcAynFPBymI1US9nB7DWdllrbX6evP3mIZwXwecCHzfG+Ky1GZeiFuT1/OI+rx6zwNvZvXzMAu/m9/oxy+v5vXzM8nJ2KQ9ePmaBt/N79ZgF3s7u9WOW1/N7+bjl5eyLIVdBr0rGmDpr7cCE6/4KuAxYg3OKwOuttX0TtjG2DH5xXs4/RXaT/c8asM5KuVHgHcC7gSXW2nQ5ZIfKym+MqQf+EngTzuITncDngBRwPs6LhjXZn8n1/F7ODoX3nQLbvApnftiXrLXXLkqwWfJ6fnFPBR6zPJE9m6Nijll513kifyUds7yef5ptyvKY5eXs4q4KPWZ5Pb/njll513kiO1TWMcvr+afZpiyPW17OvihsGbQ9L+YF+DPg4zgDrv8XeDvQlHf7KuAJnNMyXux23krKP0X25mm2fxvOyqFvyX7t6uyqCsz/d0Br3u3rgH8AvgfsA3YB/w841+38Xs4+zb7TVGC73Id5NTgzxf48/3rl18Vrlwo8Znki+zT5vXzM8kz+CjxmeT2/Z45ZXs6ui7uXCj1meT2/V49Znsk+RX6vH7O8nt8zxy0vZ1/sS1V1HBtj2oHfAgPAQ8BJOAehj1prvzhh2z8DHrdHTgdwnZfzzyV7dvuzgWuBbmvtNYsYtaBqym+MiQEJnE+Q9y921om8nB3mvu+UG6/nF/dUyzGr3LJDdR2zstuXTf5qOmZ5PX+58XJ2cVc1HbO8nj+7vSePWdntyyY7VNcxy+v5y42Xs7vC7cr1Yl5w2srvBNZmv/bhzI+JAydlrwtOuE/ZDL32cv5ZZjd52xvgeKAx+7Vf+UuePzDhPl7ad8oy+3z2nezXIbdzV0p+Xdy7VMExqyyzzyG/149ZZZm/So5ZXs9flscsL2fXxd1LlRyzvJ7fy8esssw+h/xeP2Z5PX9ZHre8nN2NS9kMkC81Y8wGnE8RvmKt3ZWdA5MBbsQZ7P7K7Kap7PYGwJbJ0Gsv559D9tz2fut43FrbC2CtTS9y7Pw81ZI/nd3ei/tO2WWHee07ufyji521EK/nF/dUyTGr7LJDVR2zctuXTf4qOmZ5PX9u+7I5Znk5u7irio5ZXs+f296Lx6zc9mWTPZunWo5ZXs+f275sjltezu6Wqikc4wzSbwWSMG6FxA7gm8DLjTHh3PXAS40x/2zKZ3VWL+efa/ZLjDEfK5PsUH35vbzvlFN2UH6pXl7ed7ycHarvmFVO+att31H+4vFydnGX1/edasvv5WNWOWWH6tt3lL94vJzdFdX0g28FPgv8MndF3j/8nTgrVZ6VvX4p8BmcUy/K4hMdvJ1/Ptl91tpM7tMdl1Vjfi/vO+WSHZRfqpeX9x0vZ4fqPGaVS/5q3HeUvzi8nF3c5fV9pxrze/mYVS7ZoTr3HeUvDi9nd4ctg3kZi3Vhwmyk/OuBJ4FPZ7++AWfge+72slgt0cv5vZxd+ZVd+b2bXxf3Ll7ed7ycXfmVXfm9md/L2XVx9+L1fUf5lV35lV/Zy/tSTR3HWGuT01z/beBSY8wm4O+BfwQwxgRsdg9xm5fzezk7KL+bvJwdlF+ql5f3HS9nB+V3k5ezg/K7ycvZxV1e33eU3z1ezg7K7zYv5/dydjeYKv25JzHGnAP8L7AfSFlrT3I50px4Ob+Xs4Pyu8nL2UH5pXp5ed/xcnZQfjd5OTsov5u8nF3c5fV9R/nd4+XsoPxu83J+L2cvlYDbAcrIw8AgcAxwGpBbOdS1lULnyMv5vZwdlN9NXs4Oyi/Vy8v7jpezg/K7ycvZQfnd5OXs4i6v7zvK7x4vZwfld5uX83s5e0mocJxlrR00xvwNcIy19mFjjM9LO4aX83s5Oyi/m7ycHZRfqpeX9x0vZwfld5OXs4Pyu8nL2cVdXt93lN89Xs4Oyu82L+f3cvZS0aiKPMZZSdFaa2125/DUqolezu/l7KD8bvJydlB+qV5e3ne8nB2U301ezg7K7yYvZxd3eX3fUX73eDk7KL/bvJzfy9lLQYVjERERERERERERERnH53YAERERERERERERESkvKhyLiIiIiIiIiIiIyDgVXTg2xjROcb3J/lnWiwN6Ob+Xs4Pyu8nL2UH5pXp5ed/xcnZQfjd5OTsov5u8nF3c5fV9R/nd4+XsoPxu83J+L2cvBxVbODbGnAn8a97XuR3CZAdcHw282xizJHt9Wf0uvJzfy9lB+d3k5eyg/FK9vLzveDk7KL+bvJwdlN9NXs4u7vL6vqP87vFydlB+t3k5v5ezl4tK/oVsAv7CGPN+cJZDzP8TeB3wUeCG7PXltkqil/N7OTsov5u8nB2UX6qXl/cdL2cH5XeTl7OD8rvJy9nFXV7fd5TfPV7ODsrvNi/n93L28mCtrdgL8A/As8Drs1/7Jtz+SuBPwN8BAbfzVlJ+L2dXfmVXfu/m18W9i5f3HS9nV35lV35v5vdydl3cvXh931F+ZVd+5Vd2b10qco6HMcZvrU0D3wLOAz5tjHnSWvvohE3/F1gDRKy1qcXOORUv5/dydlB+N3k5Oyi/VC8v7ztezg7K7yYvZwfld5OXs4u7vL7vKL97vJwdlN9tXs7v5ezlxFhrZ97Kw7LzS34BRIG/sdY+bowJ5O8MxpiYtXY4N+PEtbAFeDm/l7OD8rvJy9lB+aV6eXnf8XJ2UH43eTk7KL+bvJxd3OX1fUf53ePl7KD8bvNyfi9nd1tFzDg22eHVxpjlxpirjDGXGGOixpil2X/sdwItwN8C5HaM3P2stcPZP13ZMbyc38vZlV/7jvJ7N7+4x8v7jpezK7/2HeX3Zn4vZxd3eX3fUX497yi/8it7ZaiIURX2yPDqDwBvBLqBeuAh4yyYeDvwJPB/jTFx4Hpr7SBQFjuDl/N7OTsov5u8nB2UX6qXl/cdL2cH5XeTl7OD8rvJy9nFXV7fd5TfPV7ODsrvNi/n93L2clZxoyqMMcfjFMQ3AScDDcD5wB7gxOzX/8da+z23Mk7Hy/m9nB2U301ezg7KL9XLy/uOl7OD8rvJy9lB+d3k5eziLq/vO8rvHi9nB+V3m5fzezl72bFlsELfYlyADTgt6Z8F+oDz3c5ULfm9nF35lV35vZtfF/cuXt53vJxd+ZVd+b2Z38vZdXH34vV9R/mVXfmVX9nL/+LpjmNjjM9amzHGNAKnAsuBbmvtT7K3GyBorR3Nu08L8DPgLmvt+12IPcbL+b2cPZtF+V3i5ezZLMovVcnL+46Xs2ezKL9LvJw9m0X5XeLl7OIur+87yq/nnflSfuWfLy9n9wQ3q9YLuQC+7J8NwP/izC65F+gBfgqckbdtILd99uv/AX6r/NWXXfm17yi/d/Pron2n2rIrv/Yd5fdmfi9n18Xdi9f3HeXX847yK7+yV97Fh/d9EVgKnAF8DGfw9VHA3caYLxhjWq21KZsdkm2MaQVC2W3LgZfzezk7KL+bvJwdlF+ql5f3HS9nB+V3k5ezg/K7ycvZxV1e33eU3z1ezg7K7zYv5/dy9vLmduV6PheOLOp3HHAQuCj79W+A24AzgR8DGeAQcNOE+x+t/NWXXfm17yi/d/Pron2n2rIrv/Yd5fdmfi9n18Xdi9f3HeXX847yK7+yV+YlgAfZ7L8wcBbwe+A+Y8zFwCnAi621DxljXg/chzPsOjbh/tsXM+9EXs7v5ezZ76/8LvFy9uz3V36pSl7ed7ycPfv9ld8lXs6e/f7K7xIvZxd3eX3fUX4978yX8iv/fHk5u5d4qnBsjKmz1g5k/+4DHgDS1tpBY8xFwP3As3l36QC+kb2MDcxe5NhjvJzfy9mz31/5te/Mi/K7m1/c4+V9x8vZs99f+bXvzIvya98R7/H6vqP8et6ZL+VX/vnycnYv8syMY2PMK4FPG2NeZIwJWmsz1tpHcIZZg9N2fgzQkv06BrQBI9baJIDL/ylfiUfzezk7KD9o35kv5Xc3v7jHy/uOl7OD8oP2nflSfu074j1e33eUX88786X8yj9fXs7uVbl5IGUt+wnCIBAB7gZ+CfzIWvt43jaXALfjtKc/BpwOrLXWrl78xON5Ob+Xs4PyL37iI7ycHZR/8RNLufDyvuPl7KD8i5/4CC9nB+Vf/MRHeDm7uMvr+47yu8fL2UH5Fz/xeF7O7+XsnmbLYNDydBfA4HxC8CMgDewCDuPsIFcDy/K23YIzu6QD+B5wXvb6gPJXV3bl176j/N7Nr4t7Fy/vO17Orvzad5Tfm/m9nF0Xdy9e33eUX887yq/8yl49F090HAMYY1qAG3E+XfgD8E7geOAOnNUSf2et7c1uu9pau9ulqAV5Ob+Xs4Pyu8nL2UH5pXp5ed/xcnZQfjd5OTsov5u8nF3c5fV9R/nd4+XsoPxu83J+L2f3LLcr17O5cGSkxsXAfuDT2a//CtiL80nDx4EzAb/beSspv5ezK7+yK7938+vi3sXL+46Xsyu/siu/N/N7Obsu7l68vu8ov7Irv/Ire3VcXA8wjx3lFOBR4Ibs1w3AF4FenBkm1wPtbuesxPxezq78yq783s2vi3sXL+87Xs6u/Mqu/N7M7+Xsurh78fq+o/zKrvzKr+yVe3E9wAw7wtE4c0waJ1z/JuAg8Dd5152AM9vkIBB1O7vX83s5u/Iru/J7N78u7l28vO94ObvyK7vyezO/l7Pr4u7F6/uO8iu78iu/slfXxfUA0+wY7wAyOCsl3gp8DbgMeEF2h3kT0AP8JRDKu9/67J+utqV7Ob+Xsyu/9h3l925+XbTvVFt25de+o/zezO/l7Lq4e/H6vqP8et5RfuVX9uq7BChDxpgAcHn2yy3AwzirJ/4HzsySNcATOCspvhG4yxjTYa1NW2t3Alhr04udO8fL+b2cHZQftO/Ml/K7m1/c4+V9x8vZQflB+858Kb/2HfEer+87yq/nnflSfuWfLy9nryS5wdJlxRjjBy4CLsAZel2L8ynDj4FNwGqcnacO2ANcX047g5fzezk7KL+bvJwdlF+ql5f3HS9nB+V3k5ezg/K7ycvZxV1e33eU3z1ezg7K7zYv5/dy9oriZrvzTBegFXgd8H1gEPgpcGre7Q1ALPt3n9t5Kym/l7Mrv7Irv3fz6+Lexcv7jpezK7+yK78383s5uy7uXry+7yi/siu/8it7dV3KsuN4ImPMOuBSnNbzY4H/Aa6z1nZkbw9Ya1MuRpyWl/N7OTsov5u8nB2UX6qXl/cdL2cH5XeTl7OD8rvJy9nFXV7fd5TfPV7ODsrvNi/n93J2L/NE4TjHGHMK8Ergz4F64NPW2k+4GmoOvJzfy9lB+d3k5eyg/FK9vLzveDk7KL+bvJwdlN9NXs4u7vL6vqP87vFydlB+t3k5v5eze5GnCscAxpgocDbwWuANwKPAC61HfhAv5/dydlB+N3k5Oyi/VC8v7ztezg7K7yYvZwfld5OXs4u7vL7vKL97vJwdlN9tXs7v5exe47nCcY4xpg14BbDHWvszY4zPWptxO9dseTm/l7OD8rvJy9lB+aV6eXnf8XJ2UH43eTk7KL+bvJxd3OX1fUf53ePl7KD8bvNyfi9n9wrPFo5FREREREREREREpDR8bgcQERERERERERERkfKiwrGIiIiIiIiIiIiIjKPCsYiIiIiIiIiIiIiMo8KxiIiIiIiIiIiIiIyjwrGIiIiIiIiIiIiIjKPCsYiIiIiIiIiIiIiMo8KxiIiIiIiIiIiIiIyjwrGIiIiIiIiIiIiIjKPCsYiIiIiIiIiIiIiMo8KxiIiIiIiIiIiIiIyjwrGIiIiIiIiIiIiIjKPCsYiIiIiIiIiIiIiMo8KxiIiIiIiIiIiIiIyjwrGIiIiIiIiIiIiIjKPCsYiIiIiIiIiIiIiMo8KxiIiIiIiIiIiIiIwTcDvAfLW2ttq1a9e6HUNERKrIgw8+2GWtbXM7x2LTMVdERBZbNR5zdbwVERE3THfM9WzheO3atWzdutXtGCIiUkWMMc+7ncENOuaKiMhiq8Zjro63IiLihumOuRpVISIiIiIiIiIiIiLjqHAsIiIiIiIiIiIiIuOocCwiIiIiIiIiIiIi46hwLCIiIiIiIiIiIiLjqHAsIiIiIiIiIiIiIuOocCwiIiIiIiIiIiIi4wTcDiAiIlJtjDEbgHcDZwLHAb+z1r447/YQ8A1gC7AMGAS2Ah+w1j444bGOBT6Xfaxe4N+BD1tr03nbGOB9wFuBVuAB4B3W2kdK8gOKiIhISfT393Po0CGSyaTbUWQWgsEg7e3t1NfXux1FRGReVDgWERFZfMcBLwV+DwQL3O4HLPAxYCdQD/wD8EtjzCnW2mcBjDFNwN3Ak8DlwHrg0zhnFH0g7/HeC1yPU6zeBrwTuNsYc7y19mDRfzoREREpuv7+fjo6OlixYgXRaBTnc2EpV9ZaRkZG2LdvH4CKxyLiSSoci4iILL47rLU/BDDGfBenC3iMtXYEeF3+dcaYu4HDwCuBW7JXvwWIAq+21vYDPzfG1AM3GGM+Ya3tN8ZEcArHH7PWfj77WPcDu4C3M77ALCIiImXq0KFDrFixglgs5nYUmQVjDLFYjBUrVrB//34VjkXEkzTjWEREZJFZazPzuNsQEAdCedddCtyVLRrnfBunmPyi7Ndn4XQs35b3/YeAO7L3FxEREQ9IJpNEo1G3Y8gcRaNRjRYREc9S4XgOMhnLq794Lz96bL/bUUREpAoYR8AYsxT4BJAGvpW3yWac0RNjrLW7geHsbblt0sCOCQ//VN42IiIi4gEaT+E9+jcT8b6v3beLt/zXgzNvWIFUOJ6Dfb0jPLS7lz/t63M7ioiIVIf3AEngAPAm4KXW2ufzbm/CWRBvop7sbbltBvMXy8vbJpZdiG8SY8w1xpitxpitnZ2dC/gRRESkWgyODrodQUREpOge2t3Db3dU53siFY7nYHvHAACJ5HzOMBYREZmzrwKnA68AHgR+ZIw5djG+sbX2VmvtFmvtlra2tsX4liIi4mHDyWHiqbjbMURERIpuKJFmeDRNPDmxF6fyqXA8BzsOOZ+gj4xW344iIiKLz1p70Fq71Vp7B3AZzuJ4783bpAdoKHDXpuxtuW1qjTH+AtsMW2tHixxbRESqUM9Iz8wbSdW77bbb+OpXv+p2jILKOZuIuGsokQKge6j63jqpcDwHuY7jeEqFYxERWVzW2hTwJ+CovKu3MWFOsTFmFRDjyOzjbYAf2DDhISfNRxYREZmvnrgKxzKzci7OlnM2EXHX8KgKxzILz6jjWEREXGKMiQCnAs/lXX0ncLExpi7vutcBI8Bvsl/fB/QDV+Q9Vgyng/nOUmYWEZHqoY5jWUzWWuJxjUYRkcUxlK0DqnAsU8pkLDs6nMJxPKUZxyIiMn/GmJgx5rXGmNcCK4C23NfZ215vjPm6MebPjTEvNsa8Hvg5sAy4Je+hvgwkgO8bY15ijLkGuAG4xVrbD2CtjQM3A+83xvytMeYC4Hac1wCfW6yfWUTEDdZatyNUDXUcy0yuvvpqvve97/Gb3/wGYwzGGG644QZ+/OMfc+GFF9Le3k59fT1nnHEGP/vZz8bd94YbbqC1tZV77rmH008/nUgkwu233w7A7bffzsaNG4lGo5x33nk8/PDDGGMmdQ//+7//O8cddxzhcJg1a9bwiU98YsZsIiJwZFRFz3D1FY4Dbgfwin29I4xkh2DH1XEsIiIL045TvM2X+3odzgiJN+AUiZuAA8AfgC3W2idyd7DW9mQLwZ8H7gB6gX/BKR7nuxmnUPw+oAXYClxore0o2k8kIlKGOoY6SGfSrKhf4XaUiqeOY5nJ9ddfz+7du+nt7eWLX/wiACtXruQHP/gBl112Gf/4j/+Iz+fjzjvv5NJLL+W3v/0tL3zhC8fuPzw8zJve9Cauu+46jj76aJYvX87WrVu56qqreO1rX8vnPvc5nnrqKV73utdN+t6f/OQnef/73891113Hi1/8Yh588EGuv/56YrEYb3/726fMJiICRwrHhwdVOC4KY8wVwF8Ap+Es2vM08Clr7bfytvk18KICd49mu6PKyo5DznzjukhAM45FRGRBrLW7ADPNJruAl83ysZ4Ezp9hGwt8NHsREakqv3zul1x53JWEA2G3o1SseCrOSGrE7RhV6cN3PMGT+/td+d7HLq/nQ5cdN+vt169fT3NzM5lMhjPOOGPs+re//e1jf89kMpx33nk88cQT/Md//Me4wvHIyAi33HILl19++dh1V1xxBccccwzf/va3McZwySWXkEwmec973jO2TX9/Px/+8If5wAc+wIc+9CEALrzwQoaHh/nIRz7CW9/61imziYhYaxnWqIqieycwCPwD8ArgV8A3jTF/N2G7XwFnTrgkSpRpQbZnx1ScsKJBM45FRERERDxiKDnEr3f92u0YFU3dxrIQe/fu5U1vehMrVqwgEAgQDAb52c9+xvbt28dtZ4zh0ksvHXfdAw88wGWXXYYxRz6Pf8UrXjFum/vvv5+hoSGuuOIKUqnU2OX888+no6ODvXv3lu6HExHPS6QypDLO6KtujaoomsustV15X//SGLMcp6CcP0+x21r7+xJlKKodHYO014VZUh9hT8+w23FERERERGSWnut9jqc6n+KYtmPcjlKRNN/YPXPp+C1HmUyGV7ziFQwMDHDjjTeyYcMGampq+OAHP8ihQ4fGbdvU1EQoFBp33cGDB2lraxt33cSvu7qc0sRxxxX+Xe3Zs4c1a9Ys9EcRkQo1nNc82q1RFcUxoWic8zDwmlJ8v8Ww49AARy+pIxL0MzKqxfFERERERLzk3j33srxuOQ2RBrejVJzukW63I4hHPfPMMzz88MPceeedXHLJJWPXj4xMHn2S31Wcs3TpUjo7O8ddN/Hr5uZmAH70ox+xZMmSSY+xadOmeWUXkeqQm28M1dlxXKpRFYWcCWyfcN1Fxpjh7OUuY8yJi5hn1jIZy46OQTYuqSUS9JFIalRFMdz2wB7O/9SvGU2pEC+S7z3ffYz3ff9PbscQERGpKKlMit88/xu3Y1QkjaqQ2QqFQsTjR5Y0yhWIw+EjM8iff/557r333lk93umnn84dd9yBs5yD43//93/HbXPmmWcSjUbZv38/W7ZsmXSpq6srmE1EBI50HPt9pipnHJdqVMU42RXfXwm8Oe/q3wBfA54B1gD/BPzOGHNSdtGgQo9zDXANwOrVq0uYeLx9vSOMJNNsbK9jb88wIyocF8WTB/p5tmuIe3d2cd6mdrfjiJSNR/f2ks7YmTcUERGROdk/sJ/B0UFqQ7VuR6koGlUhs7V582Z++MMf8oMf/ICVK1fS1tbGypUrede73sVNN93EwMAAH/rQh1ixYsWsHu8973kPL3jBC7jqqqv4y7/8S5566im+8pWvAODzOX1yjY2N3HDDDfz93/89zz//POeeey6ZTIbt27fzq1/9iv/5n/8pmG358uUsX768NL8IEfGMwWzH8bKGCD1VWDguecexMWYt8E3gh9bar+aut9Z+yFr7n9ba31lrvwGcB1jg2qkey1p7q7V2i7V2y8S5RaW049AAAEcvqSUS9JPKWFJpdckuVN9IEoAfP3bA5SQi5aV/JMnBPnU7iIiIlMLO7p1uR6goiVSC4aTWgJHZedvb3sZFF13Em9/8Zk4//XT+8z//k+9///sEAgFe+9rXcv311/O+972PF73oRbN6vC1btvCtb32LBx98kFe+8pV873vf40tf+hIA9fX1Y9tdd9113Hrrrdx5551cfvnlvP71r+e///u/Oeecc6bMduuttxb3hxcRTxoedQrHK5ui9AyPkqmyJq+SdhwbY5qBO4Hngf8z3bbW2oPGmHuBU0uZaT52dAwCsLG9jod2O5+mx1MZav2LOemj8uQKxz974iCjrzqBUEC/TxFw/m8MjaYZiCepiwTdjiMiIlJRdvbs5KSlJ7kdo2Ko21jmorW1dazDN98f//jHcV9fffXV476+4YYbuOGGGwo+5pVXXsmVV1459vU3vvENAE46afz/8ze84Q284Q1vmHM2EaluQwln6sCqphi/f7abvpEkTTWhGe5VOUpWODbGxIAfASHg5dba2XwMbbOXsrK9Y5D2ujANsSDRoB+AkdE0teFFmfRRsXqHRwkHfPTHUxpXIZKVTGcYys5QOtgXV+FYRESkyA4NHWIgMUBduM7tKBVB843FbW9961u58MILaWpq4qGHHuIjH/kIL3vZy1i3bp3b0USkAuQWx1vVHAPg8NBoVRWOS9LiaYwJALcDG4FLrLWHZnGfpcDZwIOlyLQQOw4NcPQS54VlOFs4jmvO8YL1jSQ5Z2MbdZGAxlWIZOU68QEOaFyFiIhISezsqfxxFR2DHTx+6PGSfx91HIvbDh8+PDZm4pOf/CSve93r+OY3v+l2LBGpELlRFauaowD0DFfXnONStcx+EXgp8PdAizGmJe+2h4FNwMdwisvPA6uB9wEZ4DMlyjQvmYzlmUODvO70VQBjHccqHC9c30iKtroQFx67ROMqRLLGF45HXEwiIiJSuXZ27+TkpSe7HaNkdvft5mc7f0ZrrJXj248v6fdSx7G47bbbbnM7gohUsNwZwSubsh3HgyocF8NF2T//tcBt64DDgMEpHrcAA8CvgVdaa3eXKNO87OsdYXg0zcZ2p+M4MlY41uJ4C2GtpX8kSX00yJ+tbeb7D+3TuAoR1HEsIiKyGDqHOyt2XMX2w9v59a5fk7EZOgY7SKQShAPhkn0/dRyLiEglG0qk8BlY3lidHcclae+01q611popLrustfustS+11i6z1oastS3W2tdYa7eVIs9CPHPIWRjv6CW1wJGO4xF1HC9IPJlhNJ2hIRrk7I2t1IUD/ETjKkTGF457VTgWEREplWe6n3E7QtE9cegJfvncL8lYp8nFYtk3sK9k3y+ZTjI4OliyxxcREXHbUCJNTShAS3aucfeQCseSZ3vHAEBex7HzK9OoioXJFccaokHCAT8XHreEu544yGhKndxS3fqz/zfqwgEO9KtwLCIiUiqVNue4P9HPfXvum3T93v69Jfue6jYWEZFKNzyaIhb2Ewn6iYX8KhzLeNs7BmmvC9MQCwJHRlWo43hh8gvHAC87YRn98RT37uxyM5aI63L/N45eWseBXs04FhERKZWu4S76E/1uxyia+/bcR9pOfo+yp29Pyb6n5huLiEilG0ykqAk5k36bYiEVjmW8Zw4NcPSSI7PPIlocrygmFo5z4yp+8PA+DvbFxy4jo1P/ntMZSzpjFyVvNdLv1h19w87/jU1L6zioGcciIiIltbO7MrqO9/TtYVfvroK3DYwO0BvvLcn3rZSOY2PMa40x9xljDhtj4saYp40xHzDGhPK2McaY9xtj9hhjRowxvzXGnFzgsY41xvzCGDNsjNlvjLnRGONf1B9IRESKZng0TU3YKRy31KpwLBPs7BxiQ3vt2NfRkArHxTCxcJwbV/HDR/Zzxsd+MXa54NO/JpUuPL7ioz9+ild/afLpeLJwnQMJjv3gT3lgV7fbUapO30iSaNDP6uYYA4kUA/HkzHcSERGReSnlGIfFkrEZ7t1z77TblOrnrKCO4xbgl8BfA5cC/w/4J+CWvG3eC1wPfBy4DBgE7jbGLM1tYIxpAu4GLHA5cCPwLuDDpf8RRESkFIYSKWLZWqA6jmWcRCrNYCJFW92RVYgjgdyMY83iXYiJhWOA9166mZtffQIfy17++ux17O+L84fnJhcvk+kM3394L7u6hhYtczXZ1ztCIpVh28EBt6NUnb6RJA3RIMsaIgDqOhYRESmhgVHvv9Z5/NDjM3YUl2pcRak6mRebtfbfrLUfsNb+j7X2V9baj+MUjd+Q7TSO4BSOP2at/by19m7gCpwC8dvzHuotQBR4tbX259baL+MUjd9pjKlf3J9KAH70ox9hjGHXrl0A7Nq1C2MMP/rRj9wNJiKeMTSaOtJxXKPCseTJFTfr84qbuY5jzThemEKF4/a6CFf92Wpen72866JNRIN+fvynA5Puf9/Ow/QOJxlMpLBWIxWKLdflengw4XKS6tM3kqQ+6qcx5uzXB1Q4FhERKZmhUW83IYwkR9i6f+uM2+0b2EfGFrfxJWMzFVF4n8ZhIDeq4iygHrgtd6O1dgi4A6dDOedS4C5rbf7w7G/jFJNfVNK0MivLli3j/vvv5+yzz3Y7ioh4xHDiyKiKJhWOJV9u1mh+cTMS0KiKYsgVjusiwSm3iYb8XHBMO3c9fnDSuIqfPOYUk9MZqyJ+CQzGUwBV94S4mBKpwkX5vpEk0RCkjLNQ5IE+LZAnIiJSKmmbZiTp3WPt7/f+ntH0zK/XUpkUBwYmN2MsxEBioOjFaLcZY/zGmJgx5mzgHcCXrNOlshlIAzsm3OWp7G05m4Ft+RtYa3cDwxO2E5eEw2HOOOMMGhsb3Y4iIh4xNJqiJttE2lwTYiSZnnY9rkqjwvE0CnXF+nyGUMCnURUL1D+SpC4SwO8z0273shOWcXhodNy4imQ6w11PHiTkd3bfXJFTimcg4fxOD6twXDJdw10Fr+8bSRIOpulP7sEYdRxXKmPMBmPMvxljHjPGpI0xv55w+zJjzCeNMY8aYwazC/F8zRizvMBjrTDG/I8xZsAY02WM+bwxJlZgu78xxuzILvrzoDHmghL+iCIinjE4Ouh2hHnZ17+Ppw8/Pevtiz3nuC/RV9THKxND2cvvgN8A785e3wQMWmsnVgp6gFjeInpNQG+Bx+3J3jaJMeYaY8xWY8zWzs7OBcYvf1dffTVbtmzhxz/+McceeyyxWIyXvexldHd388wzz3DeeedRU1PDli1beOyxx8bul8lkuPnmm9mwYQPhcJijjz6ar33ta+Me21rLDTfcQHt7O3V1dbzxjW+kv79/3DaFRlV8/etf5+yzz6a5uZmmpibOO+88tm4d38mfy/3zn/+cE088kZqaGs4++2yeeOKJEvyWRKScDCfSxEJOx3FzjfN03z1cPbUSFY6nUahwDM6cY3UcL0zfSJLG2NTdxjkv3tQ+aVxFbkzFRcctAY4UOaV4csV4jaoonUNDhwpe3z+SJBAYpXPkAK01IQ70qnBcoY4DXgo8DWwvcPtpwKuAb+EswPNu4AXAfcaYsRVbjTFB4C5gDXAV8Pc4MxdvzX8wY8zrgS8DX8c5jfYJ4EfGmOOL+lOJiHiQFwvHqUyK3z7/2zndZ09/cecc98UrsnB8FnAOzoJ2lwOfL/U3tNbeaq3dYq3d0tbWVupvVxZ2797NBz/4QT7ykY9w6623ct9993HNNddw1VVXcdVVV/Hd736XVCrFVVddNTaW8O/+7u/4yEc+wjXXXMOPf/xjXvWqV/HmN795XAH4s5/9LDfeeCPXXHMN3/3ud4lGo1x33XUz5tm1axdvfOMbuf322/nmN7/JqlWrOOecc3j22Wcn5X73u9/NP/3TP/Gtb32LQ4cO8brXvU6jE0UqmLWWodEUteEjHccAPVXUZBdwO0A5m6pwHA35VTheoNwCYDOJhvycnx1XceMrjiPg9/GTxw5QGw7wshOW8aPHDqjjuAQGExpVUWqdw4U7SvpGkhjfCBmboanWcKBfheMKdYe19ocAxpjvAq0Tbr8H2GytHXuCM8Y8hFNofg2Qa7F5LXAMsMFa+1x2uyTwbWPMh621uVNqbwC+Zq29KbvNb4BTcBb6eUPxfzwREe8YSnpvzvGD+x+cc8dv13AXI8kRosFoUTJUYsextfah7F/vMcZ0AV8zxnwap2O41hjjn9B13AQMW2tzL5p7gIYCD92Uva3orv3ptTxy8JFSPPSMTl56Mp+55DNzvl93dzf3338/69evB+Cxxx7jk5/8JF/72td44xvfCDjFmpe97GVs27aNYDDIl770Jf7zP/+TN73pTQC85CUv4cCBA3z4wx/m5S9/Oel0mo9//OP83//7f/nIRz4CwMUXX8yFF17Ivn37ps3zwQ9+cOzvmUyGCy+8kD/+8Y984xvfGHdbd3c39957Lxs3bhzb9lWvehVPP/00mzdrEolIJYonM2QsxMLjO46r6exsdRxPY8qO46Bfc3UXaLaFY4CXZ8dV/PG57rExFRcc005LbRiAARWOiy63OJ4Kx6XTOTS5cJxMZxgaTePzOcXimsgoBzXjuCJZO/1QSGttb37ROHvddpwZifnjKi4FHsgVjbN+AIwClwAYY44Cjmb8gj4Z4HbGL+gjIlKVBhLeWuCta7iLRzsendd9izmuokI7jvPlisjrcOYW+4ENE7aZONN4GxNmGRtjVgGxCdtVtbVr144VjQE2bHB+reeff/6k6/bt28cvfvELfD4fr3rVq0ilUmOXCy64gEceeYR0Os2ePXs4cOAAl19++bjv9epXv3rGPE899RSvetWrWLJkCX6/n2AwyNNPP8327eNPClu7du1Y0Rjg2GOPBWDv3uKOgRGR8jE06rwly59xDOo4lqxc4bg+Mv7XFA2q43iheodH2bS0blbb5o+rSGUsvcNJXnbCMuqy/y6DiWQpo1al/I7jTMbim2EWtczdSGqEodEhakI1Y9f1Z59zIiGnphgIDLK/1+9KPik/xpgTcd545r+L2Qw8mb+dtXbUGLOTI29cc39OfMP6FNBsjGmz1lb+UEURkSl4aVSFtZbf7PrNvBel2z+wn40tG2fecBYqseN4ghdm/3wO2Af044yD+ghAdj2Byxg/HupO4N3GmDprbe4TidcBIzgzk4tuPh2/bpu4MF0oFJp0fe66eDxOV1cX6XSahoZCzdxw4MABDh48CEB7e/u42yZ+PdHAwAAXXXQRS5Ys4ZZbbmHNmjVEIhH++q//mnh8/Jl/U+WeuJ2IVI6hbG1kbMZxrPo6jlU4nkbfSJK6cICAf3xjdjjoZ0SL4y1I30hq1h3HuXEVP338IIlUhtpwgHOPbqNzwJm/q47j4sv9TjMWekeSY5+qSXEdGjrEutC6sa/7JhSOa6JJBhMpBuJJ6iKz+/8ilckY4wP+FWc19//Nu2k2i/Dk/py4XU/e7ZMKx8aYa4BrAFavXj2P1CIi3uClURVPdD4x5bir2TgweGDmjWYhYzOe69SejjHmp8DdOGsApHGKxu8CvmOt3Znd5mbgemNMD86Hse/EOYP3c3kP9WXgHcD3jTEfB47CGRd1i7V2/CptMmvNzc0EAgHuvfdefL7JJ023t7eTSjnvXw4dGr+OyMSvJ7r//vvZu3cvP//5z8eNm+jrq/gPRkRkFoYSTtNoTXZURUM0iM+o41iy+kaS1BcobkaDWhxvIay19E/xu53Ky05Yxo8fO8D3H9rLZSctJxL053Ucq3BcbPm/0+6hhArHJdI53Mm6piOF495c4TjoFI7ro87zzMG+uArH8jHgTOBF1tpFOc3CWnsr2S6qLVu2aNUXEalYXuo43j+wf0H37433FmXO8UBiAEtFHRoeAK4G1gIp4FngfTiF4JybcQrF7wNagK3AhdbajtwG1toeY8wFOIvq3YHzoe2/4BSPZZ7OP/980uk0fX19XHjhhQW3WbVqFUuXLuWHP/whl1xyydj13//+96d97JERZyxcOBweu+6+++5j165dnHbaaUVILyJeNpwbVZFdHM/nMzTFQuo4Fkf/FHN4I0G/Zr8uQDyZYTSdmXXHMcB52XEVI8k0LzthGXDkEx91HBffYDyF32dIZyyHB0fZMP0ZXjJPE+ccT+w4ros6+/b+3hE2LpndaBepPMaYtwHvBl5vrf3DhJunW4Tn0bxtyG7XO2Gb/NtFRKrS0OgQ1lqMKf/RXP2JhTetHhg8wFFNRy3oMXrjvQvOUU6stdcD18+wjQU+mr1Mt92TwPnTbSNzs2nTJt7ylrdw1VVXcd1117Flyxbi8ThPPPEE27dv59///d/x+/1cd911/OM//iOtra2cc845fO973+Opp56a9rHPOOMMamtr+Zu/+Ruuu+469u7dyw033MCKFSsW6acTkXI2OGFUBThzjqup41iL401jqgXcIgHNOF6IqRYdnE405Oclxy6hLuKMqQAI+n1Egj51HJfAQDzFyianE6WaPklbbBNPNe0ddn7XuY7jupjzPPP0DKfYSeUyxrwG5xTY66y13ymwSaFFeEI4p8Zuy9uGidtlv+7WfGMRqXYWy3By2O0Ys1KUwvHAwsdVFJpvnLEZDg8fXvBjixTyhS98geuvv56vf/3rvPSlL+Xqq6/mxz/+Meeee+7YNtdeey3vf//7+fKXv8xrXvMaBgcH+cQnPjHt4y5ZsoTbb7+dgwcPcvnll/OZz3yGL3/5y2OL84lIdRsedd6T14aPFI6bakJV1UyqjuNp9I0kOaq1dtL10ZDT+SrzM5/CMcCNrziOw0MbiASPLBZWFwmq47gEBhMpjmqr4fnDwyocl1A8FWcgMUBd2OkmPtDfC+R3HKcBy/ZOFY6rkTHmxcB/A5+z1n5qis3uBP7cGLPGWvt89rpXAGHgpwDW2meNMdtxFvS5K/vYvuzXd5bsBxAR8ZCB0YFxC9aWo0QqwWh64a/LijHnuC8+uXB8cPCgp+ZFizu++tWvTrru6quv5uqrrx533dq1a3GavB3GGK699lquvfbaKR/bGMNNN93ETTfdNO76P//zP5/ycQEuueSSceMtAF760pfOmLvQY4lIZTmyON6ROlRLTYgdh7wz5mqhVDiexpQdx0EfcS2ON2/zLRw31YRomjBrty4cUMdxCQzEk6xujgHQPajCcSl1DneOFY4P9juLzOQKx34f1EQy7DqsxTkqTXYl9tw7khVAvTHmtdmvfwKsAX6A0y38HWPMGXl378wt1AN8F/gnnEV4rscZR/EvwDettTvy7nMD8A1jzC7gXuBNwEbgzxEREYZGy7/gWajLdz4ODx9mND1KyD/zGhZTzUMu1Pm8u293UfKJiIiUi1zhuEYdx1JI30iShljhGcfxUXUcz9d8C8eF1EYCDMYXZZ2oqmGtZTCRoikWoiEa5PBQwu1IFa1zqHNszmDn4CBBfwZ/3hChumiaw4Np0pk0fp9/ikcRD2oHbp9wXe7rdcALcIrAJwH3TdjuazgL+GCtTRpjLsFZhOc2IAF8G2cm8hhr7beMMbXAe3BmOD4BvNxa+3iRfh7xuN8/e5imWIhNSzVPXaqTFxbIG0gMFOVxLJYDAwdY07hm2u364n082fkkZ646c9JthWYcP9/3/KTrREREvGwoW/vLLY4HTsdx7/Ao6YzF7yv/9REWSjOOp5BIpYknCy/gFgn6iadUOJ6vohaOwwGNqiiykWSajIW6SICWmupaLdQN+XOODw/Fx7qNc+qiKQZGAp6ZvSizY63dZa01U1x2WWu/Os3tV094rL3W2ldaa2uttS3W2r+11k7aYay1X7HWbrDWhq21p1prf7FoP7CUveu++xj/+ovtbscQcY0XCsfFmG+cM5txFU92PlmwizhjM5N+X90j3UUrbIuIiJSL4dEUAZ8hlNfd1VwTImOP1LYqnQrHU8jtAPUFipvRoJ9k2pJKa1zFfBSzcFwX0aiKYssV4msjAZprQhpVUWKdQ07h2FpL38jo2MJ4OfWxNAPD/ooqHHePdLsdQUTyWGs52Bend7g6XvyKFFJ1heMZFshLZ9I8ffhpeuI9k343/Yl+LOPnumpMhYiIVKKhRJpYyI8xRzqLm7MjVKtlXIUKx1Pon6a4GQk6v7Z4SoXj+cgVjusixeg41uJ4xTZWOA4HaKmtrtk9bkikE/Qn+ulL9DGcgPCkjuM0iZSPzsHK6eLZ17/P7Qgikqd3OMloOqPjqVS1aiscdw53kspM/X9+Z89O4qk4AHv69oy7rdDCeBpTISIilWgokaI2PH7KrwrHAjDWdVOocBwNOrNN4kmNq5iP/pEkdZFAUWbBqOO4+HK/z7pIgOaasGYcL4LOoU66hruIJ31EguM7eOqjzvPMnp4KKhwPqHAsUk46Bpzi0IDWDJAqVm2F44zN0DHYMeXtT3Y+Ofb3Pf0TCscTFukbTg7TNdxVtGwiIiLlYng0TWxC4bgppsKxMP04hXC2cDyiBfLmpW8kWZQxFeB0xQ4mUlhrZ95YZmUwniscB2mpCdEznCST0e+3lA4NHaJruIvEqK/gjGOAfb3lv9r7bHUMdpCxOmNDpFx09DsfEPar41iq2EhqhHSmfF/bF5orvFBTzTk+PHyYg4MHx77e27933HF7Ysfx7r7dei0uIiIVaWg0RU1o/CL1LbUqHAvTF45zHccJLZA3L0UtHEcCpDOWEXV/F02u4yw3qiKdsVUz9N0tncP5HccTCscxZ9/e1zviRrSiS6QSjKRGGBqtnEK4iNd19B/pOFbxR6rZULJ8j00DiYFJc4UXaqo5x/ndxgCj6VEODR0a+3pix7HmG4uISKUaSqSIhQp3HPcMq3Bc1aYrHEfGOo7VMTcfxSwc10Wc/8CD6pIqmoHEkRnHudk9GldRWl3DXXQMdjGaKtRxnAYsh/oro3jfG+8FyvvNuch8fOP3z/PSf/2d2zHm5VC2cJxMWxJav0EqzFwWly3ncRXFHFOR0zE0+QygZDrJ9sPbJ22bXxzO7zhOppPsH9hf9GwiIiLlYCiRpmbCqIpI0E9NyM/hQRWOq1qucFwfCUy6bWzGsTqO56XYoyrgSLFTFu7IqIoALTVhgKp5QnTLaHqUvhHndzyxcOz3QU0kQ+dAhRWO1XEsFeaJ/X08eaCf4VHvHY8OZgvHcGRxYJFKsa9/Hzu6d8xq20orHHcPBPjxA81M9ZYllUmxp2/PuOLxju4dJDOTnwdyC+SlM+lxv6d9A/umXWRPRETEy4ZHU9SE/ZOub6oJqeO42vWNJKkNBwj4J/+KIkHnOs04nh91HJe33OJ4NdlRFVA9s3vcFB91nlcmjqoAp+u4Z6gyugDVcSyVqmfIKbQc6i98hkYqnSnbRXU78jJrzrFUoj/u+yOJ1MxnT1Va4Xj7/ih/er6GvV3hKbe585k7ufXBW/nqI1/ltidu44F9DxTcrnO4k5HkCP2J/nEjMzSmQubjBz/4ASeeeCLhcJh169Zxyy23TNrGWss///M/s2rVKqLRKOeeey6PPPLIrB7/hz/8ISeccAKRSIRjjz2W73znO+NuHxgY4Morr6ShoYEzzjiD7dvHd9n39PTQ3t7O1q1b5/0zikhlGEykJ42qAGipCXG4Suokk396AaYvbuZGVZTrG8ByZq2lbzhJQ6xYHcfO4wzojW7RDCZSRIN+gn4fLdlRFV1V8oToprHCcWhygTgczDA8arDWYoxZ7GhFpY5jqVS92bMGOvrjrG2tmXT7Z3+xg7ue6OCufzh3saPN6FB/HJ+BjD0y516kkowkR3jwwIOcteqsabertMJx76DzVm9PV5i1S6YvnMdTceKp+LTb7OnfQ8gfGndd/uxjWRxf3vpltyNM6y1b3jLt7ffeey+vfvWrefOb38ynPvUp/vCHP/Ce97wHn8/HtddeO7bdzTffzE033cQnP/lJNm/ezC233MJLXvISHn/8cZYuXTrl499zzz285jWv4W1vexuf/exn+clPfsLrX/96mpqauOiiiwD46Ec/yvbt27ntttv46le/ytVXX81999039hg33HADL3/5y9myZcvCfhki4nnDoylqp+g4rpYzs1U4nkL/SJL6GQrHWpBt7uLJDKPpTNFHVQwm9Ea3WAbiSWqzndxN2cJxd5U8Ibopnpy64zgczDAUDzKSGiEWjC12tKLKLaijjmOpNL3DznGoY6BwcebJA/1sPzTAaCpDKFBeJ3x19CdY01LDc11D+iBWKtZTXU+xsWUjnYdXs7JllPrY5Nfx5Vw4HhgdmPN9eoaOFI6LYU/fHlpjrWNfZ2yGgcTcc0l1u/HGG3nhC1/Iv//7vwNw0UUX0dvby4033sjb3vY2QqEQ8Xicm2++mfe97328/e1vB+DMM89k7dq1fP7zn+cjH/nIlI9/0003ce655/LZz34WgPPOO48nnniCG2+8caxwfPfdd/NP//RPXHzxxZx88sksXbqUoaEhampqeOqpp/iv//ovnnzyySm/h4hUh0zGMjxauOO4KRbimUPl+7qhmMrrnUsZcTqOC9fVoyGncJxIVsap44tpukUH5yM3qkJvdItnIJ6iLluQD/p9NESDdGtxvJKbtuM4YBlNmjkt8FOOrLVjC+qo41gqzVjhuK9wx96BvjjWOh3J5SSdsXQOJtjQXgtAvzqOxeMO9ccLnhVoreW3z/2R//1DK3/cXgc4heKd3TvHtinnwvFsOo6ttTza8SgPHXiIxw89Tme/M1Ji/+EQ6SK8bdnbv3fszCFwfl9pe+R3nRjazH/d04+1tsC9RRyPPPIIF1544bjrLrroInp6erj//vsBuO++++jv7+fKK68c26ampobLLruMO++8c8rHTiQS/OpXvxp3P4CrrrqK+++/n74+53Xo6Ogo0WgUgFgsNnYdwDvf+U6uu+66abuaRaQ6DGdfTxSacRwJ+olXSU1QheMpTDuqItsppI7juStV4XhQi+MVzWAiNdZxDNU1u8dNYx3HBQrHoWCGRMrn+cLxwOjA2BtMdRxLpckfVVHIwWxBeX/vyKJlmo3DQwnSGTtWONYHseJ1L/3sPXz5NzsL3tY54ByDdnVafrbzZ3znie/waMejY7eX64ea8VSc0fTMr8Ue2P8AD+x7gIcOPMT9ex5gOB4mHD5MKuPjQHdoxvvPZCQ1wq7eXWNfTyxmJ4c38osnRzw/VktKKx6PEwqN3x9zXz/11FMAbNu2Db/fz8aNG8dtd8wxx7Bt27YpH3vnzp0kk0k2b9486X6ZTGZslvFpp53GV77yFQ4fPsy//uu/ctRRR9HU1MSPf/xjtm/fzj/8wz8s+OcUEe8bzlv/aaJI0Fc142s1qmIK0xWOcx3H1bKTFFOxC8e5/8B6o1s8g/HU2AgQgOYqmt3jppFpFscLBzIkkqZs39DOVn6Xktd/FpF88WR6rOOg0KiKeDI99gHcgSk6kt2SW8xvQ1uucKyOY/GueDJN12CCpw8WHp+QSTYC0NUfwfbuxRjLSPLIhzmJdIJkOknQX5zXqcUym27jbV3beKzjsbGvnZ/Vh79mKyQuZk9XmJWtC389N5I68vuamCudrqOlVn1JMr0NGzbwwAPjF2H84x//CEB3dzfgLE5XW1uL3z++y6+pqYnh4WFGR0cnFZ9z9wNobGycdL/82z/0oQ/xkpe8hNbWVmpra/ne975HMpnkXe96F5/61KcIh4sz3kVEvG1oNNtxXGBUhdNxXB01QR3ZpzB9x7FmHM9XsQvHQb+PSNCnjuMiGkykxjq5wSkcd6vjuOTioz4C/gyByWfBEA5awHB4qHxPoZ2N3JgKgLRNz2qFexEvyI2pgMIdx/nX7e8rr47jXLZ1bTX4DPSP6Hgq3tUz7Lxe2dtT+P9ZOtXo/MWGSI+2ARBPx8nYIx/aluO4ipkKx3v793LfnvvGXZdOOYWyYGQv4XB30eYcT5crk6qnpbbACxmRPG95y1v4wQ9+wFe+8hV6enq46667uOWWWwDw+RanPLF27Vqefvppnn76aTo6Orjooov43Oc+x4oVK3jVq17F7373O0488UTa2tp461vfOjbGQkSqy1C2zhQLFRhVEfCTylhSxZgFVeZUOC4gkXI6hxpjhU/p8vkMoYCvauaZFFOxC8cAteGgOo6LaCCeojZ85N+npTasURWLIJ40BbuNwVkcD+DwkLdHVeR3HIPGVUjlyI2pCAV8HCpQOM7vMj7QW14dxx3ZjuNlDRFqwwF1HIun9Qw5+++ensLHy0yqYezvqcRywJkLnN9F67XCcfdIN7987pfjit8A6WQzAP5ANya0kz1dQTJFHj1cqHDcXKPCsUzvzW9+M29961t561vfSnNzM69+9au5/vrrAcbmCjc1NTE4OEg6Pb5Rq6enh1gsVrDbOHc/YGyWcf798m8H8Pv9HH300cRiMTo7O/nnf/5nPvOZz5BIJLjyyiv5wAc+wI4dO3jooYe49dZbi/PDi4in5ArHtVOMqgCIpyq/LqjCcQG54mb9NMXNSKB65pkUUykKx/WRgDqOi2ggnhzXcdxSE6JneJRMsd9tyDjxUR+RUOHfcShbOO4ZLq9OxbmaVDjWuAqpELmO4w1ttXT0JyYtDJWbbxwL+ctuxnFHfxxjoLU2TF1EH8SKt/VmO457h5MFPwRJpxrxBQ5jTJxUYsXY9fnjKrxWOH74wMMF5x+nk81gRjH+QQLR50mmAhzqLe4IjvxcNhPAZmpoqdPbS5me3+/n85//PJ2dnTz22GN0dHRwxhlnAIz9uXnzZtLpNM8888y4+27btm3S/OJ869evJxgMTpqDvG3bNnw+H0cffXTB+11//fVcccUVnHDCCWzbto1kMsmVV15JY2Mjf/EXf8GvfvWrhfzIIlUj/3haCYazoypiBQvH1TPCVkf2AvpnUdyspnkmxZQrHNdFithxHAkwqA6porDWOovjTZhxnM7YsX87KQ2ncFz4OSUccIpQvSPl1ak4V+o4lkqVK1ZtXlrHSDLNwIQPM3MdxyetbGR/uc04HojTUhMm6PdRHw3Sr8KxeFhP3tiYQuMqMqlG/MFeAuH9pEaXj13v5cJx10hXweszqSb8wW6MgWDkeQAe31u8N/TWWgZGj8ySzqTrANRxLLPW1NTECSecQG1tLV/84hc566yzxorCZ511FvX19dx+++1j2w8PD3PHHXdw6aWXTvmY4XCY8847b9z9AL7zne9w5pln0tDQMOk+jz76KN/97ne56aabxq4bHR0d63YeGhqa9IGwiBTWPdLtdoSiGhrNLo5XaFRFruPYpbrgxDONSkmL4xUwm67YaEiF4/noH3G6Wf2+4q227Jxaqze6xTCSTJOxTjE+p6XWORXs8NAoTTULX5FbCosnfTTECj+n5DqO+0a8OxM4mU5OKhSr41gqRa7j+OilTuHkUH+c+rwPSA/2jVAfCbC+vYYfPXbAlYxT6ehPsKTemX1aFwnQrw9ixcNyY2PAKRwfs6x+3O3pVAOh2HZ8vhFG+s7AWj/GpBlOHhltUY4fak5VOE6kEgwkCi8EmE424w8eBsAf6McX6OHpAxleckJxMg0lh0hnjrxuyaSc5z/NOJaZ/P73v+eee+7h5JNPpr+/n29961vcdddd3HPPPWPbRCIR3vve93LTTTfR1NTE5s2bueWWW8hkMvzd3/3d2HZf//rXefOb38zOnTtZs2YN4HQPv/jFL+baa6/lla98JT/5yU/4yU9+wk9/+tOCea699lo+8IEP0NraCsCmTZuIxWJcd911nH/++XzhC1/gH//xH0v4GxGpHD3xHlbUr5h5Q48Ym3E8bcexO6MqEqkE0WB0Ub6XCscF5N4ATttxHPBrcbx5mG7RwfmqDQfY7fHZr+ViMFuAHz+qwikoHB5MsKG91pVc1SAx6iPSWLhgk+s47ot7d9Z0X6Jv0nXl+OZcZD56sx84b8oWjjv6E2xorxu7fX9fnGUNUZY1ROkdTjIymiZaoHPBDR39cZbURwBn9NO+MpvBLDIX+QtV7uke/9rQZgLYdB3+QB/+YOf/Z++9wyW56jP/91Toqs59c5g8mhmNJCSBJCyJIJAACQR4MUgytpc1611jMHhtg9cLBtYYmeBdg02wCTb7A5uMLINBCQQCBEIC5ZEm5ztz872dq7ri+f1Rfapz385hpj7Pc5+Z211dXd23u06d97zf9wtAgKlPQZTmSzKOi0XkQcCmds2F1lrOLkoJLHMEvsAR9zZRPoVMZhfOpp7Fpshs1cc1Q/m4bluOSD8W8gpau81br3prvw+hLURRxDe+8Q184AMfAMdxePGLX4yf//znuPTS0lWNd7/73bBtGx/5yEewtraGq666Cj/4wQ8wNTXlbmPbNizLKnEEv+hFL8Idd9yB973vffjMZz6DHTt24Ktf/SpuvPHGimO58847sbCwgLe//e3ubbIs4+tf/zre9ra34Qtf+AJuueUWvPWtw/2ee3j0CtVQoRgKAmKg34fSEbKao/mFfIMXVZEzcz0Tjr2RvQqNOI5lH+81x2uBbgjHXiZj52AlyuVRFQCw7jXI6yo5g3Ob45WXw7HmeKrurCwOI+UxFcD57TgmhOwihHyOEPI0IcQihPy4yjZ/SAi5ixCyRgihhJCX1tjXxYSQHxJCFELIPCHkg4QQvmwbQgj5C0LIHCFEJYT8lBDy3G68tvORuKLDx3PYPhYE4IixxSwmc5iOypiNOQLtfLKyXPxbj87hI/cc6P7BllHqOBa95ngeQ008q0MWOQR9fEVUBWuMxwlOVAUAN+e4WCwetHE2raVBUb1Mfk1dq3q7bYUAKoIT4+5tonwK1A7h8HLlQm4rlLugLdMRjkc9x7HHBlx55ZX41a9+hUwmg1QqhbvuuqtCNAYAQgje+9734syZM1BVFQ8++CCe97znlWzz5je/GZRSbN++veT2173udXjmmWegaRoOHjyIN77xjVWP5fWvfz0OHjwIUSydn770pS/FgQMHkEgk8M///M81m/F5eHhUElfjG280JCj5qIpqhg8mHGtm/4TjXuEJx1VoSDgWOM9x3ALdEY695nidgr2PxY7j8aKoCo/uYNmAbnKQfY5A/OTikyUZi0w41k0ycE6oRqkqHJ/fjuNLANwM4BCAwzW2+S8ARgHcV2snhJARAPcDoAD+E4APAngXgL8q2/TdAN4P4G8AvBZABsD9hJDp1l+CByOpGIgGRFeAXUqVCk8LyRxmojJmo44roFqDvG89dgb/9tjZ7h9sEYZlYy2rYTJccBynvDx7jyEmrhgYCfiweSSAuXjpeGmZMQAALyTACQkQLgtTc5y3xRnHmjVYwnHdfGOlRr6xMQoA4IWCI1n0nwQAzK10RgBL5UqPyzYjIERDwNe5ODoPDw8Pj+HjXMo5zmgWfDwHn1ApncoCyzjuj6HUE477DBOOI3LtJA+/j4fmCcdN062oioxmek0LOkDGdRwX/kYjnuO462iGcyqWfTYW0gt4fPFxrCkFF5EvH1WhGdy5JRyfx45jAN+llG6hlN4K4Nka27yAUnotgA/X2c9bAfgBvJ5S+gNK6WfhiMbvJIREAIAQIsMRjj9CKf00pfR+ALfCEZvf0aHXc16TUAyMBEQEfALCslDiONZNG6sZDTNRP2ZjjnC8UBYHQSnFkaU04oretbHsx4eW8fDxUnfiakYDpcB01BGOw7LojaceQ01S1REL+LB5xF/FcRwD4DiOCYHTIC8vHCvm4DqO6wnHtRzHljkCAODFwuSdE9ZB+DTWk2MdaahTfly2FQEnpECIJxx7eHh4nM+cS8KxopsIStUrafodVdHLhW5POK5CUjUQkgQIfO23x8s4bo2uCMeyAMum3t+jA2Q0Z9GkOKpC5DlEZAFrmcGaSJ1L5HTnXMNzOTxw8gFQSku6pHMcIPI2dIMMrUu3mnCsmmpPu8EOEpRu/MIb2QbAqwDcRyktnsF/HY6Y/JL87y8AEAHwzaJ9ZwF8N/94jzaJKzpifmeRbSoiYzldEIaZiDwTlTEVkUFIZVTFakZHXDFg2RQptTsVNB+95yD+6rv7S25jzuji5ng2BbK6N556DCfx/CLO5hE/zqwrJYsglhkFYIETnGZygnQWlj4JaotD6Ti2bAvJXPXYCcsYhfNaC/cT4sRV6OqWmoJzO8dlm2FwfPVGfR4eHh4e5w/nknCc1SwEquQbA/1vjuc5jvtMI+Km38s4boluOY6BglvWo3XSVZrjAcB4SPKiKroIE44Px590HcXl5ac+kUIzh9dxXGtyO6yvZ4DYC+Bg8Q2U0tMAlPx9bBsLwJHSh+JA0TYebZBUnagKwBFhi6MqFvPC8XRUhk/gMB6SKhzHh5cKYsu60p1z7XpWx8HFFJJFzcOYqO1GVeTHZy+uwmNYiSs6RgI+bBkNIK2ZJQsxthkDJ6RBiHP97uQcczD16ZKxyKY2THtwrilrCcdr6lrNxVfLGAUnJN3XyhDlU7CtGE6uZqo+rlEopUjrpSKxbTqOYw8PDw+P85tzSziu5zh25vD9MjD2skLKE46rkFINd/JUC1n0Mo6bJWdY0E17w/e2WZjImfZyjtumlnA8GvR5URVdJJePqljXCvmmxVEVgJNzPKxRFVk9C8OuLkSd53EVnWAEQKLK7fH8fWybDKW0fNCKAwgQQqoGXhJC3kIIeZQQ8ujKykqnjvechEVVAMBUWC6JqlhIFhzHADAblSscxyXCcRfOtZTSfAwG8MuThYv55fxxTkVYVEV+PPUWYj2GlIRiIJZ3HAPAXFxxRWDLjIITEu62xQ3yTNuEbhW+e4MUV1FPOK6FbY6UxFQwWM7xiaX2GtgphlIirlNKYFthTzj28PDw8IBhG0hr50YFSlY3EZQ2chx7zfHOSxxXbO18Y8D5kPTrAzKsJJSNmw62Apvoeo7j9mHN8cpPjqNBH9YynnDcLVYzjhhMuIKYpBhKiUgsCU5UxTAKx9ViKhjDGr1xPkAp/Tyl9CpK6VUTExP9PpyBJq44uaoAMBmRsZzS3BL5hXwjPJYjPBvzVzTHO7xUcP91QzjO6hYMyzmeR4pyjpdSGniOYCyfZR+WnfE5nfMcxx7Dh21TJBQ9LxwHAACn1zO49Vu34tDaIaxZP4bO73O/m7yQBsenBr5BXrmzl1G+wFyMZYyCFyq72vPiCgiXxXI81tYxJbXSKiJqBQHw4HhPOPbw8PDwOHdcx4puIVgrqkLwhOO2IITcSgj5D0LIWUJIhhDyGCHkt6ps9/uEkCOEkFx+m5d143iapZE4BU84bh7WdLDzURVsousJx+2S0UzIIgexLN97zIuq6CpHVh2nMceVnvxLGuQNcVRFrUkv4DmOO0AcQLTK7SP5+9g2IUJIucVsBIBCKfW+3G2QMyxopu2ObVMRCbplu4ulC8kcQpLgirIzUT8WkrmS7NUjS2lsyjfOi3fhXFu8z4dPFAvHOUyGJXCc08wq4jmOPYaYtGbCpnCiKvLC8fHVOG664CZYto2EcAfm7M/hqaWn3AmtIJ0tCMdmkXA8II7jnJkrcUIXU8txbFsyqB0AV8VxTAiF6D8JRdmErN769US5C9qyIs7t9Gn87wf+9znjNPPw8PDwaI1zRTjOaiYCvupVOlI+qkIz+xNhey40x3sngAyAPwXw6wAeAPBVQsgfsQ3yQvJnAfwLnOY8zwL4HiHkOV06poZpKONY5GFYFKbl5Rw3SveE47zjWPMcUu2SzpmuEF/MWNCHuKLDtmmVR3m0w2JmEWtZZ7JK+LKGWUU5x8xxPIxCa71j9hzHbXMQZTnFhJAtAAIoZB8fBMAD2FX22Ip8ZI/mYQLxSKDQHA8AlvIN8haTOddtDACzMRmKbrnZq5RSHF5K4+qdowC6k3Ecz+/zktkI9s+nkMo7ipfSGiYjhWNj4nbKcxx7DCGJ/Oc8FvAhGhARlgWspIC3XvVWXBi7FpvVr2CzdAMkQcKp5CnkzBwEaR6WMQHblkoWZgfFcVwrpsKmNuJqpaMYcGIqAFSNqgAAUT4J24zhxFr13gOtHJdthmFDwWLucRyLH0NADLS8bw8PDw+P4Seeqz5GDRtZ3XT1pnIkgQMhnuO4HV5LKf1tSuk3KaU/opT+GYCvwRGUGR8A8CVK6e2U0gcAvBnAUQDv7tIxNUxjjmPnrcv1aXVhGGHCcSzQpYxjzyHVNhnNdB1nxYwGfbBs6v4NPTrHo/OPgtoyQHQQUjroFLuJJJEOb8ZxHXF4GIXwAeMeADcRQsJFt/0mABXAT/K/PwQgBeBWtgEhJADgtfnH94xzcfEp7opVBccxALdB3kIq5+YbA47jGICbc7yc1pDKmXjulhgkgetKVAXb5ysvmYZNgUfzOcfLqRymwpK7HTv/p7zx1KODsB4X3SbuLuI438XNIwHMxZ3vmW1GwSOKEXkMF4xcAAKCE4kT4HynAQCmNlMaVTEgjuNazt1kLlmzgZ9lOItQ1aIqAED0nwAAHF1sfRpYKRxHkRS+AZPm8O4Xvhs8116GsoeHh4fHcHOuOI4VzUKgRnM8QghkoX9JBEPfHI9Sulrl5icAzAIAIWQngD0Avln0GBvAt+C4j/uGZlrIGXZDjmOgf6sLw0i3HMduxrHXHK9t0jkDoSrC8VjIcdJ5cRWdZS45h8XMImzbXxFTAZQ6jn2iDc3kYNjGQHV7bwTPcVwJISRACLmFEHILgE0AJtjveVEXhJCr8ve/Iv+wl+Tvv6poV58FoAG4kxDyckLIW+AszH6cUpoCAEppDsBHAfwFIeTt+Viob8G5BvhUD14uAGDfmSRe8rcP4JmzrbvcBhHmOI7lx7bJcN5xnGKOY7VUOI45/1/IC8eHFh1haPdkuGuNSNkx3nDRJESe4JHj6+4xTlVxHHsZxx6d5A+/8jjec+e+rj9P+SLOlhE/zsSdxVbLjAEAeCEJH+/Dtug2KIaCVfMRAICpzUIxh8dxvKpWm2o5TuS05pxbeLG6cOzkHGewuBauen8rx6UaOlLCtzHmH8OlU5e2vF+P84MvfvGLIIRU/Hz2s591t6GU4sMf/jC2bNkCv9+P6667Dk8++WRD+//Od76DSy+9FLIs4+KLL8Y3vvGNkvvT6TRuu+02RKNRXHPNNTh8+HDJ/fF4HJOTk3j00Ufbfq0eHucrcTVeEss2rGR1s2bGMeAYSnNG782khmXAquh73j3qd4DrLNcCYGdlVlZbXiJ7AMAoIWSCUtqXFu6NipuSJxw3TbeEY9bIzWuO1z6ZXPVSjLGg40jrhqBxPjK3rmDfSRmPnE0hp18KS58saYzHyOgZ5MwcZEGGJNjQDAJKHSE2KleLtR1MPMdxVSbhiLfFsN93ADgJ4B0Afrfo/g/k//0SnCodUErjeSH40wC+CyAB4O+KtmV8FI5Q/B4AYwAeBfAKSulSm6+jYbaOBbCa1vHlh0/ho2+4rFdP23WSaqE8HgAm847j5VQOhmVjOa1hOu8yBuBmGZ9NOMLy4SVHON4zFcJo0NeVjGN27p6N+nH55hgePrEOzbQQVwzXIQ0gn3FP3BgND49OcGAhVbJ40i2SbBEn/13cPBLAz46ugtIA7LxwzAnOwtWIfwTj2jiWlDOY4h+FbEagGgUxdlAcx7WE41qN8c6mz2JZfwLTwl4Qrvq5hBBA9J9EKrMFlp0AzzXvIyo+Lkoplowfg4OETeFNTe/Lo3neeMcb+30Idfn6LV9vaLsf/ehH8PsL4+POnTvd/3/0ox/F7bffjv/7f/8v9u7di49//ON4+ctfjmeeeQbT09M19/mzn/0Mb3jDG/CHf/iH+OQnP4m7774bv/Vbv4WRkRHceOONAIAPfehDOHz4ML75zW/ii1/8It785jfjoYcecvfxgQ98AK95zWtw1VVX1XoaDw+PDbCohaSWREyO9ftQWsa0bOQMG4G6wnF/HMe9jKkAeiQc5ye1rwPwe/mbRvL/Jso2jRfdXyEc551UbwGArVu3dvowAQCpvLgZ8RzHHSeh6OBIwdHUKUSegyxySHuO47bJaCa2Bitz6UaDecdxZjAmUsPOO772BJ6aGwHwSvc2X6B61OyasoZNkU2QRAqAwLAIFEMZLuHYcxxXQCk9CYBssM2bkReIN9huP4AbNtiGAvhQ/qcvRP0ifv3yWXznyXn8xasvQqTDY0G/iCulMUySwGMkIGIppWE5rYFSlIhm4yEJAkewkHAWi44sZTAW9GEsJGE06OtKZUc8P/5G/CKu3jmKz/7kOE6sOt+94oxjQgjCsug5jj06hm1TLKc1+Gs0lukkzHHM8sa3jPqh6BbSOQrLjIHwaRCucK24ObIZaT2NVfETCJpvH6qM42qN8bJGFsvZZQBAWvgunGj76ojySejZ5+Dk2hwumGjueiJrZEsqnxK5BBQcxzi9FSJ/vKl9DRKEkFsBvAnAlXCazh4C8LeU0q8VbfNjAC+p8nB/vrqHbbcJzoLuy+FUBX0dwJ9TSocvb6yLPP/5z0coFKq4PZfL4aMf/Sje85734B3veAcA4Nprr8X27dvx6U9/Gn/9139dc5+33347rrvuOnzyk58EAFx//fV49tln8cEPftAVju+//368973vxU033YTnPve5mJ6eRjabRTAYxIEDB/Cv//qv2L9/fxdesYfH+cW6uj7UwrGS1/qCNaIqgLxw3If42l4Lx93KOHYhhGwH8FUA36GUfrGdfVFKP08pvYpSetXExEQnDq+CRl2xsiscexnHjbKQzGEyLIPn6molLRGSRC/juAOkc6YXVdFl5tYVPDWXwMjYLzGy5RPuT3iy3HzqwMpRfaJzrtEMMlQ5xza1SzrVl2PaZs2O8R7nHm+6dhtUw8Kdj53p96F0jIRSmd8/FZGxmMphMR9HUdwcj+cIpiIyFpJ5x/FyGrunnInzaL4RaaeJKzqifhE8R3D1jjFYNsXd+xbdYy0mLAveeOrRMVazGiybusaMbhJXDBBSuIbfPOIshK+mqZNxLCRKtuc5HjtHdsIicSTsfSVj1aCMS7WE43WlNDuSUorTidMQOAFh6wZkyVN1X4PoPwkAODzffBlxKlc4JpvamEvNwUe3IMY/r+l9DRgbNnfP8wCcStriH3elgRAiArgPwDYAbwTwx3B6DHy+y8d/zvDQQw8hlUrhtttuc28LBoN47Wtfi3vuqd2aQdM0PPDAAyWPA4A3vvGN+MUvfoFk0qk40HXddToHAgH3NgB45zvfiT//8z+v62r28PBojGHPOVY0JhzX9ttKAtcXM2mvF7i7KhwTQkbhNN45BeB3iu5izuLyJe6Rsvt7TqPCMXMcq57juGHKO8t3krAseBnHHSCdM6q6AJl7x4uqaJ+79y0AAITwL8GL6+5PsQuqGFaOKrnC8XA1yGvkWM/juIrzjudsiuLyLTF8+ZHT50TuGQAkVB0+gXOvCwDHxbucyrnicHmZ/mxMxnxCBaUUR5Yy2DPlZI2OBLqTcRzPGhjJV45cuW0EPEfw3afmAaAkqgIAIp7j2KODLOebRCZVo+vf+YSiIyKLrkFh84gjDK2kbFhGzI2pKCYgBsAhAIOmBq45nk1tZPRMxe0pLVUxYVzOLkMxFWyJbEfE+B33tlrw4goIn8GZtcoqs40oFrNXsiswbAMj+h+AF4Z+LG+kuTsArFNKHy77Kf5w3wLgIgBvoJTeRSn9CoA/AvDbhJDdvXkpw8EFF1wAQRBw4YUX4nOf+5x7+8GDB8HzPHbvLn27LrroIhw8WL1CDwCOHTsGwzCwd+/ektsvuugi2LbtZhlfeeWV+Kd/+iesra3hE5/4BHbu3ImRkRHcddddOHz4MP70T/+0g6/Sw+P8ZdiFY6YvBepUTZ0vURVdE47zzX2+B8AH4DVlpTnsjL+37GF74QzGfck3BppxHDtvnRdV0TjzSRWzsS4Kx95Ety0opcho1TOOfQKHiCx4wnEHuHvfAi7dFIUgJhranjXIkwRnTqIPmXDciCjczbgKzdRwKnGqa/v3aJ7/fPVWHF3O4JETw30xyUhkDcT8IggpVNNMhSUspTQsMuE44i95zEzUj4VkDvPJHDKa6QrHo0Ef0jkTeodL3uKK7i4ABiUBl26KulEVU+FKx3HKcxx7dAj2HTAsCkXv7jVzQjFKnP9MOF5O2VUdxwwRYZg0CdVUXXF7EKIqMnoGFJVie/lEXDM1zGfmEZWiCHM7IdApRPitWFVWYdPq5xJCnLiKRGoCzer5xcJx1sjCx8uQ7eeCE6q7o4eFjZq7N8GrAPyKUnqi6LZvA9BRnFF2HjMzM4Pbb78d//qv/4rvfve7uOaaa/DWt74Vf/d3fwfAaU4XCoXA86VizcjICBRFcd3B5cTjjvcsFotVPK74/r/8y7/Es88+i/HxcfzN3/wNPvOZz8AwDLzrXe/C3/7t30KSShdUPTw8WmPYhWNFd66Hq+kjDKc5nicctwQhRIDT5Gc3gFdSSkuWvCmlx+E0yru16DFc/vfa9Sc9gJWcNhpVoXb5IvhcgVLqOI7LJs+dIiR5pbXtohoWbIqqURUAMBaSsOplHLfF3LqCp84kcfOlMw0/Jq2noVt6IarCHK6oikZE4W45jk3bxN1H7h76i5ZzjddePouoX8SXHz43BP2EqpeIVYAT/7CS0XAmrsIv8oj4S8+rszE/FpIqDi+yxngF4RhwnJOdZD1bEI4B4OqdowAAH89VHLsTVeEtxHp0hqV0YWKT7HJcRVzR3cZ4gNNTIxYQcXTJAiCAqyUccwGYZB2WJbpxFYPgOG6kMR6lFHOpOQDA1uhWUMv5bo/7N8OiVt3xT/SfhGVGsJBo7u9SfFyaqUHinKgdfsiF4xoUN3dn3EgIUfI/9xFCyru97kVZA3hKqQ7gGCpNU+clN910E973vvfhxhtvxKte9Sp86Utfwm233Ya//uu/hm13PwZy+/btOHToEA4dOoSlpSXceOON+NSnPoVNmzbhN37jN/Dggw/isssuw8TEBN72trfVFKo9PDxKoZRC1Qvf4ZSWgmUPr16WzUdVbNwcr/fxtb2+TumW4/gfAdwM4HYAY4SQa4p+2BLeBwD8V0LI+wgh1wP4f3CE5o926ZgaoumM4z4EYQ8jKdWEoltdcxyHJC+qol0yuforamPB7pRQn0/c84wTU/HqJoRjSinWlDXXcTxsURX9chzb1MZ9R+/DUnap4/v2aA9Z5HHLlZtx7zOLWC4SlTKaiR8eWBq6CAvH5egruW0qIsGyKfbPpzATlUvcyIATVWFYFL847ghAe4oyjoHO58knFAMjRQLxNTvGAACTEani2JyoCm889egMS8neCcfln3MA2DISwKEF5/PM16j08fESLLICaobduIpBcBzXEo5Z7wPAWVxOaknMhmbh432w9HEAQMRP4Bf8WM4u1zynirJjiH30ZGWERy1WlBXMp52YG0opclYOPuK4OTn+3BKOi5q7f6zo5p/AySy+CU7D9q0AHsz39GGMoLIBPOBEMY5UuR2EkLcQQh4lhDy6stK3wtu+csstt2B9fR0nT57EyMgIMpkMLKtUcIrH4wgEAvD5fFX3wZzFLMu4+HHF9wMAz/PYs2cPAoEAVlZW8OEPfxh///d/D03TcNttt+F973sfjhw5gscffxyf/7wXT+3hUYvjKxn868On8EdfewJXf/iH+N3PrWIx7ozFNrWRyCX6e4BtkM3rS3Wb4wleVEU73Jj/9xMAflH2MwMA+Q61b4XTMf5eAJfBibR4pkvH1BBJ1UBIEiDw9d8aN6rCcxw3xEKqskFQJwl5zXzaJp0/MYZrOI5HPeG4be7at4hLN0Wxday5TMFVZbWoOR7X1WiHTtMPxzGlFD88/kPXheUxePzO1Vth2hTf/NUcbJvim4/O4fq//TH+25cexUPH1jbewQCRUJyoimIm8w3n9p1NYqbKgulM1Km++cmhFUyEJVd4Zq7geAfPtZRSrCu6K0oDwFXbR8CRysZ4gOPS7EUjM4/zg6VUQYBlVX3dojiShbF5xI9s/hCqZRwDgI8XYZMsDFMaKMdxWktXvb24MR4bP8cDjmBsGWMgnAKOVzEZnIRqqlVzkgGAF1dB+DSOLXG49+i9Gy5KL2WWcM+Re1xR3bRN2NSGCOe5OaH68Q4jtZq7U0r/klL6/1FKH6SUfhnA9QAogD9p5/l60QB+0GGLmIQQ7N27F5Zl4ejRoyXbHDx4sCK/uJgLLrgAoihW5CAfPHgQHMdhz549VR/3/ve/H7feeisuvfRSHDx4EIZh4LbbbkMsFsOb3vQmPPDAA22+Og+Pc5ODiync8LGf4P3ffga/PLGGX9vhVL0cWyxUmQ9z5WdWZ8LxBlEVptccryUopdsppaTGz8mi7f6JUrqLUipRSq+glP6wG8fTDEnV2NBtDBSa4/XjQzKM1GoQ1Ckisug5jtuECe+1hOOxkA+rGU84bpW5dQVPzSWaiqlgrKlrkPPCsW4SZPUsDGs4hJ1GROFOO6j3Le/Dsfixju7To7PsnAjhhbvG8K8Pn8JrP/0z/PkdT2MsL2yeXh8eRz1QO6oCcCKAqkU0sbHw0FLadRsDznkWANY7GFWh6BZ003ab4wGOOHzdnglcvjlWsX1YFpDVLVj2cDm/PQaTxVQOPsGZbvTCcVx+Db9ltLBQWyuqwic4glVxRY9Frb6X11ZzHOfMXMmCrGqq8PE+8JwzL7GMMfDiGggBRv2j4AmPZaV6kzyWc2yo2zGXPIM7D9yJE/ETVbedT8/j3mP3QrcK5ybmdhKpEwHM8eeGcFynuXsFlNJFAD8HcEXRzXFUNoAHHLdx3xrADzp33HEHxsfHsW3bNrzgBS9AJBLBt771Lfd+RVHw3e9+F6961atq7kOSJFx//fUljwOAb3zjG7j22msRjVb+WZ566inccccduP32293bdF133c7ZbHboKqE8PHrFqTVnzPzif30+Hn7Py/Dp374C28YFnFou5IQfjx/v1+G1DevNEKwTVeH39SeqoteO49rvwHlKSjUQaUA49jKOm2MhwYTj7mUcZzSZGS2+AAEAAElEQVQTlNKKsluPxihEVVT//I8GfYgrOmybguO897hZWompYKwqq/AVRVVoloZv7f8WbthxA6ZD0x09zk7TiOO408Jxcf6jx+Dypmu2461ffgwCx+GTv/U8vPKSaex9/z1YSKj9PrSmcMrjK6MqGNUWTGdjhbFw92TY/T/bTyerO+J5Ebq8hP//e/Pzq46X7BookzMRDWx8PeThUY+lVA4XTIRwYCHVVSe7YdnIaGZVxzEAx4XLVf9euc1nTbtkPNIsDQGuuQqhTlJNOF5TS8c31VThFwrnE8sYh+h3Fk45wmE8MI6l7BKOrR/DWGAMUSla8r33+U9Az14Ky5hAjqzghyd+iOmVaYwHxjHmH8NYYAxZPYsfnvghTLvUoJGz8sKxvRk2lwXhht/AsUFz91rQ/A/jIMqyjAkhPgA7AXy2Q4c61LzhDW/Ar/3ar+Gyyy6DZVn4xje+gW984xv45Cc/CY7jIMsy3v3ud+P222/HyMgI9u7di49//OOwbRt/9Ed/5O7nX/7lX/B7v/d7OHbsGLZt2wbAcQ+/9KUvxZ/8yZ/gda97He6++27cfffduPfee6sey5/8yZ/gfe97H8bHHef8hRdeiEAggD//8z/HDTfcgH/4h3/An/3Zn3X/TfHwGELW8qayC6fD7thyyWYR9z4twbQAgQdOJE7gTOoMNkc29/NQW4JFVQTqRFVI50lUhSccl+E4jjd+W9yM4z6sLgwji0kVHAEmw93pUhuSBVg2hWpYdcPLPWqT0ZwJXe2MYyezM5WrzPP02JhmYipYF3SO5F1aWhIUFkTehm44g3JKS+E7B7+D504/F8/f9Hx320GjH47jYYryOJ+56ZIpfO33r8HztsbcMXUyLONsorcXQu2g6hY0064QWMdDEggBKK0e0TQSEPNdmG23MR4A17ncUeE4a+Sfs/S8XWuRlVWdpHKGJxx7tM1SKoeX7JnAgYUUEmr3qpZYDMZIsDLjGKjtNgYAtl6uW6abcQw4cRUBcbCE4+KYCpvayJk5xKSY87vtg21FwIsFcXkm5CxWr6lrSMQTEDgBk4FJTIemQQiBGHD6vunZvRB8TrbuYmYRi5nFqsdEKQ9q+cEJGWimBgICYm0Gdw40xitr7v6C8ubuNR4zDeBFcHr1MO4B8NuEkG2UUtYF9tcBSHDiGdvm67d8vRO76RsXXngh/t//+3+Ym5sDpRQXX3wx/uVf/gVvetOb3G3e/e53w7ZtfOQjH8Ha2hquuuoq/OAHP8DU1JS7jW3bsCyrxBH8ohe9CHfccQfe97734TOf+Qx27NiBr371q7jxxhtRzp133omFhQW8/e1vd2+TZRlf//rX8ba3vQ1f+MIXcMstt+Ctb31rl94JD4/hZj2fBVUch3bpZh/uelLF2TUJ2yad+392+me47ZLbBna+WgvWHK+e41gWeWjnQXM8T2ErI6ka2DEe3HA7niPw8RzUPqwuDCPzyRwmw/KG2dGtwsTOTM70hOMWaSSqAgBWM7onHDfJmbgTU/G/XrlxM+2skcWx9WMI+oK4YOQCAE5GaVJLwidSaGbhO0RB8cTiEzibPovXX/T6rh1/OzQi4rJMyY49Z4czkz26AyEE114wVnLbTEzGQnJ4HMdMCIv5S8+JIs9hLChhNaNVdRwTQjAb9eP4arYkqkLkOUT9Ykczjl3HcbCx83akSDj28GgHzbQQVwzsnAiB50hXoyoS+c95+fUJcxzzNfKNASfjGJRAt3Ml41E/G+Tpll71+Ysdx2zS6Bed12gbzvmU9xWa5/Ecj82RzdgU3oSklsRydhnzmXlE5AiCYhC8kIYgnYGu7EVg5MENj0tZfxnU1PMxsvkfkDOPQhIkUC12TgjHKDR3/2M4zd2LB6gnAFwI4CNwxOVTcBrjvQeADeDvi7a9A8B7AdxJCHk/nNiKvwPwVUrpkS6/hqHgwx/+MD784Q/X3YYQgve+971473vfW3ObN7/5zXjzm99ccfvrXvc6vO51r9vwOF7/+tfj9a+vvH5+6UtfigMHDmz4eA+P8521rI6wJEASCo7cvbMiCChOrRSE40QugX1L+3DZ1GU4upzB7iLTxCCj6CZkkQNfp9paFjnolg3LpnW36zQ5M9fTSvvhkvx7QKMZx0A+CHuAhWPbpvjB/sY71OumjR8eWOrKsSwmc11rjAcUxM60l3PcMiwjupbjmK0keg3ymueefY5zZ6OYinV1HYdWD8GwDaS1dMl3N5lLQhJsaEblaXs5uzwQjXzK0S29orQVQMVtpm2W5Ca2S6cdzB69YzbqdzPxhwHX5VjFmcviKmqNfaxpXvnF82jQh7WuRFU0JhyHZee1eA1nPdplOd8YbzoiI+oXuyocx/PfxfJGlZvywnE9xzEhBDyiMOxsaVRFH8fVam5joLTJEBO5WVSFaTil9ry4WvE4Qghicgw7YjsAlDbe8wUOwdQ2wzLrT+RtW0IudRVAfciu3wjN1CALMmwzDP7cyDfeqLn7GgACRzy+D8DHATwLx518mu2EUmoAeCWAOQDfBPBpAP8G4C09eRUeHh4ePWIto2M0VHp9GZQ4TI/oOL1cev376Pyj+NqvjuMVf/dTHF2u3rR10MhoZl23MVBIItB62PuMUnpuNMcbViiliFfJKqyFLPYnz6RRHjy6it//l0fxiwY71P/rw6fw3770KI6tdP6LvJBUu9YYDygIxxlvotsyTCQI1XIcBx0RhJWkeDTOL0+u44KJYM2YCkop5tPzOJE4gaAYxExoBha1SsTUpJaEJBaiKspJarXdVP2ilvN3Ib1QcVtxeXA7mLbZV5eYR3vMRGXMJ9ShaUTDhONqkQ6sQV6tbP/dk2HsHA9WLFaPBERX7O0EzL1cTdyuRsQTjj06xFLKWQSaisqI+UX3+9INEjUWSAI+Ab9/vQx/9Jd1Hy+SCAyarsg47hfVhGPLtpDIJdzf2bgpCc71maWPA7DBC7X7r4m8CL/gL9m/L3gQAKArF9Y9Ji11BSiV4As+Ay27F5qlQeL9oHbonHAcb9TcnVJ6llJ6M6V0hlLqo5SOUUrfQCk9WGVfZyilr6OUhvLbvb3BvGQPDw+PoWE9q5fEVDC2TWqYX/dBNwvzVsM28PkHDwHA0FQXpnPmhv3P5HwD4F5G2Pbj+sQTjotYz+rQTbthZ6zTQXFwheMzcef65MBiYy6Au56eB1AIOe8UlFIsJHNda4wHFBq6eRPd1sloTimGWCNOpDiqwqM5MjnTFd6rcTp5GguZBYz5x7B7bDeiktP1WTELc4xELlERVVFM8WRyUKgVU3Emdabitk65hL2YiuFmNuaHZtque3DQccvj/ZUXzdNRGbLI1RRs/9cr9+KOt72g4vbRoIT1bOde/7pigBA0XE3lZhx30R3qcX6wyITjiIRIlx3HTJSOVfm+XbfXB15cr7i9GJGEYCJR0mymk5UwzVJNOI7n4m4PBMBxHMuC7GZGWsYYOCGxYZO6sBRGRs+4++LFZXDCOvRsbeGYUgI1dTUE+RTCE/8OWzgMCgofRgEAHD/8wrGHh4eHR3OsZfWqc9ytExpsSnB2tXB9vLAu4uSKYwwZ5Arm4oqcVM6oGePJKPQ+650u2I+KKE84LoKVxzbqjJUFfqCb4y3kGwwdWdpYOJ5PqHj8dAIAOn5hn8qZUHSrq45jN+NY8ya6rZLOma4AXw3m4hnkE/2gouhmzW6siVwCq+oqpoJT2BbdBo5wbl5hsQs3qTlRFTUdx7nhcRzPp+dLJr9AB4VjrzHeUDObj2+YTwyHEyGhVm/IBQB/cN1O/OPvXFEzf8zv46u6NEaDYkcrO+JZHVG/2HCPATf6ycs49miTpbKoim4uRjSb5V2OyPlhkTXkdAuG5RznoEVVrCmlFYSqqboxFQBgGeMljfFqEfFFQEGR0Z0KQ0KcuAojtwPUrv7+6cpe2OYI/NFfgHAm+MhdAACqvBgAzgnHsYeHh4dHc6xlNIxVGXc3j2vgCMWplYL+88TxEDjiCMed7OXRaQ6uFopIUqrhVuLVggnHvex9VrzI3Ss84biIgnDcmDNW9vED3RyPvZ4jDWTI3PNMoXtyp4VjVorA8hy7QWGi6zmOWyWjmXVX1HwCh4gseMJxC9TKRzJtE6eSp+AX/JgNz7oCE0c4yIJcIqYmc5XN8YoZyKiKKiKuZVtIaIkKobhTDfI8x/Fww8bfoRGO3VzVKmV6Y0HcsHeq4vaNGAn6EM8aHYvriCt6wxFcgJdx7NE5llI5+ASn4WMsILoLLd0grhgQeYKgr/oi7Ub4eBGU6DBM2R2P+hlVUex4YhTnG1u2E2fFhGNKHcdxtXzjckK+EAhIZVwFFaErF1R9jJq8FpwQhy/gTKgt4ahzh/IiAJ5w3GuGJc7Jo4D3N/M413BiXiszjgHAJ1DMjuo4veK4kXM6wf65AC7ZlgVAsZga3Fz8Q2uH3P+nc/X1EcDpewb01nHsCcd9ZpEJnA07jge7OR4TbA8vpTccrO56et7tPN154bg5J3crFBzH3kS3VTI5o2ZjPMZYSOpo06bzBUW3EKgymT2dPA3LtrA9tt0tNWUExECJuKpbOnhOr9ocDxgex3FSS4LSgtOJ4TmOPYDCAuOwNMhLKDp8AudeNHaCsaAPumUjq3fm+sIRjhuLqQDgvp6U5zj2aJOlVA7TERmEkK43x0uqOqJ+X8sdxn1uRiHnjkcD5zhWC25iNmlkFUq2FQGoD7xvY8cxz/EI+oIlzyHKp0E4Bbqyt2J7Q5uFmdsGf+QRkLxbTLM0cEQAhxAAgDs3muMNBaIoQlWHY3HVo4CqqhDFxsdiD49BJ5UzYVi0quMYALZO5LAQ90EzCJ45HYRpcbjyggxkn41j68s9PtrGMCwDGT2DpcwSACeqYiPHseRGVfQuicATjvvMQjIHgSMYC9XOIi1m0DOOF/MT73TOdMsFq8FiKn7zqi0AOi8cLzbp5G6FkNccr20aWVEbDfqwlvEajzVLVjMRLBPl15Q1xHNxzIRmEBArm+YFhAAM23BLZgGAEgWaQVBtHWhYHMcsi7lrwrHnOB5qxoMSRJ5gfkiaZiQUAyMBsWWxqhpuLFCH8uTj2cab/jLCsug5jj3aZimVw1TEuaZmURW23R3XnfM5b0yU2RHbgaAvWHKbJDjfYd2gbkxUvxzHlFKk9fqOY+aKZo5jyxgDgIYcxwAQkSJQTdW9xiDEhi9wGLqyB5SWTg9zyWtASA5S5PHCbWYOsuBDIPZzcMIaCDcci33nApOTkzh79iwURfFcrEMApRSKouDs2bOYnJzs9+F4eHQMpgmMlTmO2Xlp66QGSgnmViU8cSyEmREN0yMGAj4b84lkyRx3UGCC7InECQCsOd4GjmPBEY61XmYc9+H6pP67cJ6xkMxhKiKD5xqbAA5yxjFrSHfJbATPzqdwZDlds+kfi6l4zeWz+PyDxzueQbeQUMERYCLcmCDfCiLvOKTSnuO4ZTKaia3BSgGzmNGgD3PrXlPoZqCUQtEtBIsyjleyKziROIGAEMB0aLrq45iYrJgKorzTLM9CFgCBYRH4hNLJgm7pUA3VdR8NAtVE3HjO6fbuOY49qsFxBDNRv5vRP+gkVL1qTEU7sNzjdUXH1rH65+RGiCs6Lp6NNPWYiCx4wrFH2yylNFyS/+xF/SJsCqQ1s+FGjc3QaCQLIQTP3/R8mLaJ7x3+ntsAT/I5n3fdsgpRFX1yHGeNbEUfgJSWKmnWpxoqOMLBxzuv2dLHATjCcUSKVHUsFxPxRTCPeaT1NEb9ToM7X+AQtMxzYeS2wuc/6ezXDEPLPAdy5JfguML7oVkaQmIIgdiPEBh5AMVrZwSdW0jzqCQScb5T8/PzMIzBE148KhFFEVNTU+7fzsPjXIDFV46WNcebS80BADaN6eA5iocORLCWFnHzVc7ip1+ykdWAw2uHccnkJb096A1gguyJ+AlcOfNrUHTLjXCrhT9fVZwzz+2oCk84LmIhqTYVp+Af4IzjpGpANSxct2cCz86ncHgpgxfvnqi67d37FnDxTAQ7xoOIBTpfSriQzGEiLEFssDFPq4QkzyHVDumc6Tq3azEe8uHJuURvDugcQbdsmDZFoCjj+B33vMOJqBjdXrtxVl4AVgwFUckRjg3qOJA0o1I4Bhw37yAJx9XE4ISaAFApHBc3AmwHz3E8/MxEZTdqadCJKwZiTcRANAITjjvVOKTZqArAcRx7URW9g1KK1Yze1QX2XkMpxVIqhxv2Og47JhanVKMrwnFCMbCtgYWWnbGdiEiOePOyHS/Dfcfug01tiLzpZPzaeiGqok+O42qib7HbGHAcx7Igu9cQljEOEA28kMGVMy/FAycfqPscATEAnvBIaSlXOBYDRwGY0JULwQtx5NJXIpe+AgCBP/qI+1ib2tAtHZJfygvGhesRiZcwG55t6XV7NE4kEvFESA8Pj77C4ivLoyqOx49DFmSIvIhNYxpOr8iQRBsXbXbGVr/PRkrl8czyMwMnHDNBNqklMZdwKngiDWcce1EV5w0LyRxmYo2LLrI4uBnHLB/yObNRjAZ9OLJUPXtsPqHisVNxvPqyGQDoSgbdQjLX1ZgKRlgWvIzjNshoJsIbZByPBn1Yz+pdKzU9F8lqzjmiuGHPb+z9DWyLbasr8gqcAB/vKxFUNduJo9Br5RwPUFwFpbS6cJyPqigXeDvlOO7UfroNIWQXIeRzhJCnCSEWIeTHVbYhhJC/IITMEUJUQshPCSHPrbLdxYSQHxJCFELIPCHkg4QQvpV9DQKzMT/mh8RxnOyicNyJPHlVt5AzbIzUyJ+rRVgWkPIWYnvGF352Atf9nweQPYeuYdKaCUW3MB1xDBlMLO5WznFc0Tf8LhJCcPn05e7vmyKb8KKt+eZuHCBgFIatFKIq+uQ4blQ4ZjEVAGuMt4YRfwzbY9shcPWv5wghCEthpLSUW1bMcTpE/3HkUs9HfO5PoCZeDEGaR2TmS+DFuPtY9r7IQqXZZmtsK3iutQaFHh4eHh7Dw1o+Uq08qsKwDZxJnQEAbJ1wxotLt2Uh5k1PfsmCqnGI5+LudoNC8bh/cPkUAGzoOGZRFb3UBftxfeIJx3lYtEMzjmNZHFzHMXNrzcRk7JoM4chypup2LKbi5ku7KRw35+RulZAkIOM5pFqCUuoIxxucGEeDEiybek60JmBCQKBIlH/jc95YM6KimPIGeZqVcP4dggZ5iqGAonSBwaa2OyGucBybHXIcD09UxSUAbgZwCMDhGtu8G8D7AfwNgNcCyAC4nxDifngIISMA7odj+fpPAD4I4F0A/qrZfQ0KM1EZi6kcrCFYoOpGVMVIBx3H60q+jLDJjOOILCLtned7AqUUX/3laaiGNTRO+0ZYTjmLP5NFGceA4wzuNJRSJNSNs7y3RLa47lrGnrE9rpgsIAaDZgtRFX1yHKe1SrPHmlJoemdYBkzbLFl8toxx8OIaZkOz4Dm+oWuMiC8CwzZKXqcceRSckIQ/9iBGtvw9otNfdWMrGMzpVE043hnbueHzenh4eHgMP+tZZ+wYrWJOOJ08DQC4cJOC0ZCBK3cV5n0Bnw1Vc+ayzyw/04MjbZxiJ++RNUfUjmxQJSV7zfHOL9azOnTTdp0RjSCLPLQBzThecBvSydgzFcLhpXTVBgp371vARfmYCqDzwnFBkO+N49iLqmgN1bBg2bShqAqgM0648wVFdxaXQhu4uasREALQLA2W7ewjZycAAJpZPd6CuXkHgWoCbkpLwaLOa8kYpcKxTe22B0HVUCtyIQeY71JKt1BKbwXwbPmdhBAZjtj7EUrppyml9wO4FY5A/I6iTd8KwA/g9ZTSH1BKPwtHNH4nISTS5L4GgpmYH5ZNsZIe7EaclFInqiLYWcdxWBIg8sQVfduBic+xZoVjvzee9oon5hI4vuKcL+s1Mh42FpPOa2HX1ewz2A3HsWpY0E17w8/55VOXV719W3QbAEAkIRg06Y5Fpm32ZUyptpC6pq5V3M8cx9QWYJtR8OIqZsKOEWRzZPOGz8MiO4odzlLwEEa3fArB0R+BF6svRjOhWeJLo1W8mAoPDw+P84fVjI6wJEASKqtM5lJzsKmNiaiJt7xyESOhwjWl32fDtDkYJsGpxKmqi6X9onguupBMAGgmqqL3zfF62WDQE47zMKF1NtZExrHIQ7fsgXRFLSZz4DmCybCMPVNhpHMmlssm4Sym4jX5mAqg88JxKueUKvbMcdzHMs+Hjq7iUz88UvJTKyKEbT8ojeYyeYFgI3HTLaHOeMJxo2T1vOPY13zpptsgj7mOiXOequk4HqCoimpZw8XCtmEZFUJxuzET1cTqRIbHVx+OYz4xWE4+SjdUI14AIALgm0WPyQL4LoBXFW33KgD3UUqLa5u/DkdMfkmT+xoINuXH4fkBd1/mDNsRqzrsOCaEYCTgw3oHzrNx5jhuOqpC7HijXI/q/NtjhTLNpdRwRLQ0AnstUz2IqojnXcz1srxnwjOYCk1VvY+NtT4SgIV4aaVPH8pBy8dGzdRKqnTY/Uw4tsxRABwE35rrNN4U3rTh80iCBB/v27CRXrXjEzmxIpJia9SLqfDw8PA4X1jP6hgNVb++zJk5LGWWqt7nl5wpkKJzoKA4kTjRtWNsluIKHM105tsbRlWI/WuO18uIRk84zrOYF46nm3DG9mN1oVHmEzlMhiXwHMGuyRAA4HCZiMliKl71nEI5W6TDwjF7X2eaEORbZSoi4/S60re/x/u+8ww+9oPDJT9/f/+RqttSSvEHX34Mn/nJsR4fZXXYosJG4gK7n5WmeGyMwjKOW3EcM+HYdAYFku9orpvVT93NTv5aRTO1ku7u1agq4pY5ojudc1xNrF5JifjWIypWM0P3md0LwAJQfhI5kL+veLuDxRtQSk8DUIq2a3RfAwGrUFkY8JzjhMrcvJ1v9DUa9HXGcdyAoFaNsCRAMx1h3KN75AwL331qHjde7Aia55TjuIZwzL43naQRZ30ttzHgjLWEEIi8BBCKdK44Iqr/wnFFvrGhQuAEN8fY0scAACMh3Y2PGPGPICgGN3yuiBRBWk/DtBs3XuTMHCShspHjjpEdDe/Dw8PDw2O4Wc/qFY3ximFxFeX4JWduzOIqBqk/TfH4m9Od44v468/hJaF/zfHKox+7iScc52G5crNNOGP9+dWFQcw5XkwVcoX3TIUBAIeXSj9YLKZi50TIvS3qF6GbdsfEV+YY64Xj+BUXT0HRLfzk8ErXn6sa6ZyJ37xqC45+6FU4+qFX4QUXjNV0zKU1E+mc2ZEMy05wNJ+BzRYZajEeciYKXlRF47TjOBZ5EQInuAMqE441o3pUhWmbPRlAjseP40tPfgn3Hb0Px9aPVZ1wVhNx42q85PfyY+2G43gl4+wzukE+1QAyAiBDKS0/GccBBAghvqLtElUeH8/f18y+SiCEvIUQ8igh5NGVld6dV2eZcDzgjuN4tjVRthFYI9J2YWNMs83xWJ7buZJzvJzK4aq/vh/753uzuNYo9x9YQipn4r9cux1hScByerAXS5phOZVDRBbgz499ssjBJ3BdcRyzfdZaxJkJz9SNbuAIB5mX4eOdyWFas92Iio0WSbtBuXBcHFMBOFEVsiCDEOdawDLGAQBbx0qvtRuJqxj3j4NSiiPrRxoWjzVLg8yXPpeP9zXkcvbw8PDwODdYzWgYDVYuIjJOJU9VvT3gc8bXQRSOi6uM2HxbFuunCxBCIAlcz8yLlm2543Uve/t4wnGehWQOAkcwFqr94S9HEnvfQbFRFhKFXOGxoA8jARFHlwuO44WkE1Px6ktLm2d0upSwFSd3q1x7wRhiARF371vo+nNVQ9FMhGQBAs9B4DnMRP01HXPsfelWd/FmObyUhsARbB+r705hjWe8qIrGYc3xgr7mHceA44RiHd4LwnHtU3cvGuStq+uwqIUTiRP4wfEf4Gv7vlaRsVTVcawlSn6vaJBntCcUVhOrF1PO+zGEwnHfoZR+nlJ6FaX0qomJiZ49b8QvIODjMT8kjuNoh6MqAEfo7cTCIouqiDX5+Q/n89zOlZzjI8sZrGY0HFkenBw9ALjjsTOYjcq49oIxTEQkLJ9jjuPpItMAIQRRf3ciUNjnvFZzvJCv/qI4APhFPyTRmSRqRmHy2I+oivKxsLiaiFIK1VTdmArAEY45PonN0dLz9KbIxkJu0BfEBSMXQDXUhsRj0zZh2maF49iLqfDw8PA4v9jIcZzSUlX77/iZcKw7Y0a1+Vu/KF64debbFJq98dxaFvmeaYLFx+hFVfSBhWQOUxEZPFfdyVcNfx86KDYCa0jHLtgJIdg9FS5xHN+9z4mpuPnSmZLHdrrr9UIyB44Ak+HGBflWEXkOr7xkGvfvX+q5mG/bFIphlcQRzMZkLKdzMK3KzwfLWx0U4fjIcgY7xoPwCfVPCT6BQ1gWOuKEO1/I5pvjBaTWJlQBMQDVdJq+EWKDEAN6Dccx0Juc4/Ky2ayRxeMLj5feVnYRQCmtELV76TjeKJ9qAIkDCBFCyj84IwAUSqletF20yuNH8vc1s6+BgBCCmag8cLnU5SSV+i7HdhjrVFRFVkckv6DZDOz7kjpHHMcsqiY1QEL4UiqHnx5ewW9csQk8RzAVls+xjGPNjalgRP1ix64vi2k1kqWYgBiAJDrXa5pZaNbaj6iK8ucsHht1S4dNbfjFYuF4DLxvDTOh0mv62fCs60quR1SOYufITlc8Zg15qx5bXkhnkRgML6bCw8PDozv8n3sP4onT8Y037CGUUkc4rpFxzKjmOi7OOAYGzHFcNP7mDA6SSJHRNzYdyGLvHMfFx+hFVfSBhaTadJyCPKCO46RqQDVKG9LtmQrh8FIalDpW+2oxFUDnHccLCRUTYQlik5PWVrn50hlk+xBXoRoWKAWCRXEE01EZNgVWqmSrDprj+MhSGrunNnbkAI6g4UVVNI6iNdZ4sBYBwck5LnYdazUyjoHKHOFuUC4cA8DTS0+XuKLKLwKqZShmjDLHcZVO8s1Q/pyJXAKqDvgEq6lFwQHhIAAewK6y28szjQ+iLKeYELIFQKBou0b3NTDMxvyDH1XhilVdcBwHfEgoRtWFx2ZYV4ymG+MBhQ7S54rjmFXJZAbo9Xz7ibOwKfCGK5w4gamIhKVzKKpiKZWrEI5jHe6jwUjkr0mibQrHopADoUHoRc1be+041kzNjclgFDuQ2TjJHMeUOo7jgD9T4QKWBRnj/vGGnjcmx7BzZCcUQ8GB1QM4ET+B08nTmE/PYzm7jDV1Dclc0l2clvjCc/l4HzaHN47F8PDw8PBojqRq4B9/fAz35ntTDQop1YRp0w2vMU8nKnOOZZ8NgA5kVEW541gS7YZ6CPlFvmdmUs9x3GcWk6UldY0wqM3xFlhDuqJ4iN2TYaRzJpbTWs2YCqALURWpXMlxdJt+xVW4ObbFjuP8665Wbj0/QMJxzrBwal3B7slwQ9uPhSSsDV+jsb6R1S0QAshC645joLhBXg6qXntg6nZUhWqoVQVei1r4xdwv3N/L3b/FgrZu6aCUdt5xXOZyPpk4CWr78xcoQ8dDAFIAbmU3EEICAF4L4J6i7e4BcBMhpPgL/JsAVAA/aXJfA8Ns1O+eJweVbjfHc56jvTEioeh1G4bVgjmOz5WMY1Ylk9EG4/VQSnHHY2dwxdaYu4A/FZGxlNLcBf5hxrYpltMapiKlQma0W8KxaiDg4yG1OM4CTlQF4bMQ6DgMO+c6enrtOC7PNwYK43/x/a5wbAdBbT/Gw9XHuUZyjhkxOYYLRi6AwAnIGBmsq+tYyCxgLjWHk4mTOBo/ioXMAghIiUjtxVR4eJRi2RTv+uZTeOZs96sAPc5tTq855/+MNjgL3wCwlnXGxo0cx8vKckX8EkecuAo17zjWLK1upUsvKc84lkS7oWreXkZVFB9jL2M+WrPAnWOwaIcbL6kUUusxqM3xmJt1JlYQwpmb9PBSGkfykRXlMRVA54Xj+YTqNufrBSLP4aaLp3HXvgXkDMt1hXcbRXM+A+WOY6Dw9yhmMe+kS+dMWDbtqxvy2EoGlKJhx/Fo0Ie59cFZGRx0FM1EQOTBtfg39vE+8IQvaZCX1WqfuqsNbqeTp7FvaR9icgwxOYaxwBimQ82d7xjV3MaME4kTmE/PYyIwUdFQKJ5zSqx0S8czy89ge2w7gr7STO1OR1WcTJyEbe+BJA7WORpwhdub879uAhAhhNyS//1uSqlCCPkogPcTQuJwnMHvhLPg+6miXX0WwP8AcCch5G8A7ATwAQAfp5SmAIBSmmtwXwPDTEzGakaDbtobRuj0i6RiwCdwXRlnmHAcz+puU9JWWM/qFa7PRmAZxyl1sCYqrcImOIPiON53Nokjyxl8+DcudW+bjMjQTRtJ1WhJ7B8kVrMaLJtiukpUxcHFzudMxxW9bed/UAyCEAoBMRj2ct8cx9WE4xLHsaE61wV5odbSxwAAm0erL2BtimzCE4tPNPz87DqBQSmFaZuwqNOMx7ItCJwAjhTOy9tj2xvev4fH+cByOod/e/wMRoMinrOpWpqYh0djnFp35jaDJhyzBfmxKs3xFjOLoJSCEAJKKeZSc9gztqdkG7/PhqoVrp8VQ0FY6p1mVA3N1EBRWLxvxnEsiTxyZu8dx0eP34C//t5+vO81F3f9eQdzNtZj4ooBzbQrLnA3Qh7QjOP5vChZHFXB3KSHlzK4a98C9k6HK2IqgM4Kx0yQ76XjGABefdkMMpqJn/YwrsJ1HPsqHcfVyq0XisTkfju62EJCowK/F1XRHFndLHGiN0JMjrmTMkIIAmKgIBwTDWqdtz+lpUoca5RSPHzmYcyl5rBveR8ePP0g7jt6X/MvJE894RgAfn7651XzlpjjWDEUUFDkzBxUUy1ZYW5HOLZsq2QgzegZrCqroJbfza0cMCYBfCv/cw2Ai4t+n8xv81EAHwLwHgDfAxAB8ApK6RLbCaU0DuBlcKIovgvgrwD8HYC/LHu+Dfc1SMxG/aAUA535msoZXWu6yITjds+1CcVoyREdOecyjp33MT0gE69/fOAYgj4er76ssIDP3LlL50CDPNbkb7JcOA50pzleq5/zYpiDV0AUBlJ9yzguF451Sy+JeVJNtSRf2DKcKIoLqlzTA8BkcBI+viCqc4SDwDV+TUIIgciLkAUZIV8IUTlaseg7FZxqeH8e/ePHh5bx+n/8OT7wH8/i3mcWvOrBLsKy3A8sDFZDVo/h4xRzHA/IwjeDXVeVR1V85+B38Klffgrpolzg08nKuAq/ZLsZx8BgxFWUj/c5g4Ms0oaEY1noXcZxYWFbh5rdjJzZm+f1HMcoNCprNeN4EB3HPEcwGS68nvGQDyMBEQ8eWcFjp+J41yv2VH0sK0/thHCcyplQdKvp97VdiuMqmnWRt4qSb4BWnGMb8Qvwi3yJSMwovq3f7qIjy2kIHMH2seDGG8MpSYlnddg2bdlFez6R1awSJ3o9gr4grpy5ErtGd+E/Dv0HVpVV53YxiMXsotMgj8tBq9Mcz6Y20noaESkCADiyfqRC7M2ZOXcluFk2Eo7X1DU8Ov9oxe3FwjEAGLbhxlVE5ah7XDa1S5xMjVJ+wXEycRIAQG0Z8gA6jimlJwHU/QNQZwXgQ/mfetvtB3BDJ/Y1KLCKmbMJFVtGA30+muok1e4Jx8w9GW9TOF7P6hhtYXwJnWMZx25UxQC8nidOx3Hvs4v4k5fvLvn8sGu25XQOF07313XTLqzSqprjOK2ZMC276YaN9eiE45jFQolcEDaybvlnrx3H5VFQxWMbpc6iKxvfAUc4JsTEeLj6+8kRDs+bfh4IIZgITGAsMIanl56uaGjbKgExUNKoz2NwufPxs3hmPoX9Cyl88aGTAIAX7RrHl//71f09sHMQJhzvX0i1fL3t4QEMblSF6zgui6q4addNCIpBLGeX3bFqPj0Py7ZKIo38PhsppdRx3G/KF241nYMUcXoe6JZesghbjizySHSgqXUjsONcSWuwbbnhuNF28RzHKI52aO7CZ1AzjucTOUyGpZL4A0IIdk+F8eNDjgv35ssqYyoAgOcIwrLQEUeIO3HosXDM4iruP7Dcs79NVmMZx4UTICEEM1G5RlRFDltGnc9bv3OODy9lsH082HA5+GhQgmnTc8aJ1m0U3SxxoleDEIKrN12N2y6+DXvG9oAjHKZCBQcPc/dk9SwIp0Gv0xwPKOQc29TGr87+quJ+CtryAL2RcAwAx+LHah4TmxQblvP5qWiQZ7TWEK1aTAUA2LYf0nBmHJ/XzNSp2BgUUqrpNpHrNOxCfL2Ni9CcYUE1LIy00ByP5whCknDOnOeZs67fQjilFH9z70GMBX347y/eWXLfueQ4Zk3+ymNSmFCe6vDfIaEYbTXGAwrCsY9z/g5xtRCv1EvKJ67FY7VmOWW0zB0NAKYxjoCcRb11/EunLsVzJp+DqdAUBE7ATKj6HKAVRv2jHduXR3d57FQcr7hoCk//5U34t7ddi5svncbPjq72vfLxXIQJSOtZ/Zw4p3v0j8GNqnA+1+WOY1mQcc3ma5DUku6cTrd0LGZLm/sFJMvNOAYq53H9oHyhmGUcA9jQdSyLXM9SCJgzejHh/L57srG40XbxhGMACynWTK45gdPvRlUMlnC8mFKrirXsQ7V3OlyzpA3oXPMSNuGfjfVWOAYcYbyXcRVZN+O4VESYicludAgjlTOQ0UzsnXZW4fotHB9ZSmNPg/nGgBNVAbRfQn2+kNWsEid6NUb9o7h06tKSldji0s+Qz/n7ZA1HOLas+hNklnP87PKzJaVCxbQqHLOs4mbI6ll38l3sOGb3FVOt8V6jz+Huw1CxlHUSGAbVcexRHzZuVGsuOiikcgYiXXIcs7L79Uzr59l4fuLaqhMzIgvnTsZxhjXH6+/r+cnhFTx8fB1/dMOuinGBOY4HOZ6lUZaSOXDEqXYrptN9NABHoFlO5Vpy1hfjOo7zjqJ4vkqm31EV5fnGAEocvpYxhrFwc+/nZHCyY83sPOF4OFhM5nA2oeKKbSPwCRyu3DaKm/JVmdUMLh7tUdzY9sDCxmXuHh61mFt3zvvZAROOVzM6wpJQtSnt1ZuuBgHBcnbZvW0uOVeyjZNxzIGlKw6a45hSJ+NYblg45nsWGeE6jlPOe7+rCR2nHbyoCgALCRUCR5puQMOiKu56esFtFsZxBP/l2u3Y1KR7uZMsJHO4aDpScTvLsH11laZ4xXROOGaO496/Fy/ocVxFIeO49OQ5HfHjoWOrJbexC7S902H8YP9SX4XjnGHh9LqCX3/upoYf4zrhsjoumCjs5yuPnMbvXL21Zw0Jm2FuXcGXHzkF267drX7PVBi3XrWl48+t6OaGjr/Z0GzFbcXN6wROgMRLyOgZhDkNtu1DWssgLFUfKBK5BAzLqFuK2soAndEzLbmvWEyFZVvu413HcVkecqsXDsUr1aeSp0ApBbUFgIoD2RzPoz4Bn4BYQBxox3FSNbBjvLGIn2aRBB4hSWjLcczKCEeDrYnboyGf6ygZZjTTcrON+ykc2zbF39x7CFtG/fjtq7dV3O/38YjIApbPBeE4pWE8JFXEUbAFkU5d99g2xTu/+RR0y8YtV25ua188x0MSJEgCBxhAXB2M5njFYyJbWGUZx5TysI1RzIxs3PG9GJ7jMRGYwGJmceONN2DMP9b2Pjy6z+OnnUX/K7eNuLcVKnty2N3DRubnAyyqAnDiKq7fO1lnaw+P6mim5RrQ+r3wXc56Vq+IqWAEfUGMBcawpqxhNjwLkRcxl5rDNbjG3cYv2TBtDoZF4BNar4TtJMULxbpJQEEgiY52sKFwLPA9zzheT0vgOBUTbTTRbgZPOIYj5E1F5JJoh0bwizwumY1g39kk9p11LtoU3YLIcfizmy7sxqFuCKUUC4kcrr+wcoB64a4x7JwI4nXPqy8Sdko4Zq6ZyXBvPszFiDyHl+6ZwC+Or/Xk+ZT8yTxY5iCajclYSuVK8vyYoM4yDPspHB9bycCmaMpx7DZtKmqq8R9PzeP27+3HbFTGqzZYmOgH33x0Dp/7yfEKYZ9hWM5q4i1Xbu54DllWt7B5pP6pdlOk8jsZEAMIS2GkNccxHPQFnUHLlwPA4fDaSVw5+5yq+0vmknhq6am67t1WSoIaiamoBnMps+PxC36opupmHBfT6oVD8X7WFOd7b9vOpGhAm+N5bMBM1I+FQXYcq4bbRK4bjAZ9bWUcs4lrqxn64yHJbX4yzDABXeBIX6Mqvvv0PA4spPCJNz63ZjTUVEQ+J8qa5+JK1cq3TjuOP/OTY/jRwWX81a9fgsu3xNreX0AIwCc440VWc46x347jcuFY4iW3D4BljADgMBFpfoybCc10RDj2HMfDwWOn4pBFDpfMFoxFrNLWcxx3noSiwydwmIpI2O85jj1a5ExcBaXARFjqSmPZdljLahUxFcVMBaewqqxiRVnBbHgWyVwSyVzS7Wvjz8cIqhoHn2ANhHBcPP5qhjPOyr4BjKrIL2insgGI0lrPMtQ94RjAfLJ6tMNGcBzBXf/jxSW33fCxH+PIcv86qKZUE6pRvSHdrskwfvSul264j1hAxOGlzIbbbcR6VkfUL0LsYAOUZtg7E8G3n5zvagMjRjbfHK/CcRyVYVNgJaMVVvbzzRgHIariSP7vvKcJp8FY0FkIKI6quHvfgrO/5Qxe1cHj6xSrGcf99Oj7Xl71/n/88VH8n3sPIWfY8DfYyK5RsppZU7AGnMY1tTqSTwWnXOE4JIawrq7DJI6D/djq2ZrC8aqyuuGEsJUBmgmyzcLyjdlzRqQIVFOFaZsdE46LH8dyk6ntnAdln+c4HkZmozLmB3RCSylFKmd2dWwZCfraigQqOI5bE44nQhIOngMd4VlMxdbRQEV0VK/QTRsf+/5hXDwTwWsvq6wwYUxFZDcfeFj53tPzeOjYGt5+/QUV97HvSycayPz86Co+9v1DeO3ls/gv11Y6uFshIAYgCDkQKiFnOIsMuqW33dyqmcdXRFWYpVEVxfnGljEOABgLN78gMh2eBtrUjXmOd0UAj8Hm0VNxXLY5VjInYxnk/TovnsskFAMjAREXz0RwYN4Tjj1agzXGu3gmgp8cXoFh2X3TVcpZy+jYPFK7ebUsyIhKUawoK5gOTYMjHOZSc+6YEZCcuZmqc4gGB0M4Lq4wyuWF48YzjnmoPXYcZ9Uw5ODhnjwn4GUcA3BWWpvNN67FnsmwK8b1Azb4z7QRD9Epx/FanRKGXsAynY/2QMhXdBMCR5wSxyJm83+H4pzOhWQOhADbxgLw8Vx/hePlNASOYPtY4+XWI8HS7M2EouNnRxwx8/DSYIoMaxndzWauRjjvFE9rnf9bZDWzwolezGRwEiJfXXwqjqtgDfJy9AwAYF1RazqAVVN1M4Rr0coA3Uq+MVDIXFYNFTzhERSd12LYRueiKooyjjMaE449x/EwMxOTMZ8YzAltVrdg2RQRf/fW30cDoiv+tgIT52ItNg2bCEtYzWh1I36GgdV8dczWsQByhu1WmPSSe59dxOl1Bf/zlReCq1PdNhmWsDzEjuOjyxn8rzuexhVbY/jjl+2puD/qd8bhdp1Ti8kc/sfXnsDOiRA++vpLO+a28Yt+cEIaHA1DtyzY1PmstOs6Pps+2/C25Q1i2ZhoUxuapZXlGzvC8WiTGccAMBmYdJ3LrTIij7S9D4/ukzMsPHs2WRJTAQA+gcN4SPIcx10goeqI+X24aCaCE2tZKPpgxQx4DAen1py5DasUGKSc4/WsXtHHoJyp4BRM28Sa6hiPinOOix3HQGXPm35Q6jh2rivYHJKZoGohizx00+7JNbNmaVA0Dqbphyj1proe8IRjJ9qhk8LxVAgn17J9a5jHBv+ZNhrSRTolHGe0umJdt2Eu2k64pzciq1kI+PiKyct0lTKwxWQOEyEJIs8h4hf7WnpyeCmD7ePBmmWz1ZAEHmFZcJ1w39+/BNOmmI3KOLrcv0WTeqxn9bquu3C+3DzT4TJmSikU3arrOJ4N13GfFTmR/YIfHOGg2o5FiNoSjq0fa/nYWhmgW42qYBnHiqkgIAZcodywDWSNLCgtDLLlk+ZGKY7eYI5j23K+f17G8XAyG/MjqRoDOeFi5+1uRlVMR+W2JvTrWecYW22ONx6SYNq07w1c24WJ72yBtNPn+UY4vpIBIcALLxivu91kRMZyOldyThwWFN3EH37lMUgij3/4nSuqXld0KqriXd96Eqph4bP/+Yq6C7PNEhAD4PgMOIRh2qbrPmo35/jI2pGGt63VHI/dzvKNAcA2JhCUTTeDsRlEXsREYKLpxxXj5RsPB0+fScK0Ka7cOlJx32xMdiP0PDpHXDEQzTuOKQUOLg6mscZjsDm1riDg4wvXLwMiHFNKN5xbA05z94AQwHJmGZRSLGYW3R43fskRZBXdmSPnzP5f+xQvEmt6PqoiP75mjay7mFwN1uNJM7trTtBMDTa1sZpyrqdE3+oGj+gc571wHFcMaKbdlkO3mF1TYdgUOLHan1UTNvi3I4RH/SJ0025b/G7khNJNNsX88It8TxzgtVyl7O9Q3OBpPqliJt88MeoX+hxVkXad2c0wVlRCffe+BWwe8eO1l8/i+EoWZh/cXBuxkfuddbfv9ICsWzZMm9ad2NYTjmNyDJLgRIMQQhAUg1CsFQB54Th+rOVBtllnL6UUcbV5x7Fu6VAMBZRSp8xW9EPk8sKxZcCyrZJS3HYdxzkz516UMMex7DmOh5JqFRuDAjtvdzOqYvNIAGtZvWWHSVzREZaFlssaJ/L9CVYyw+uABQpRFdvGnJLKfky85hMqJsPShou0UxEJhkURV4ZLrKeU4i/u3Icjyxl84o3PrXlN7RM4+EW+pHFUsyQUHT8/uoa3XLcTuyY729ArIAZAiA0efpi27oq1rTSFZaiGijOpMw1tSymtcDcrpuLuB0BJVAVnTbcUU8GYDrfXPNrLNx4OHjvlXLtdsa1SOJ6OyAPdhHZYSbKoirxT9ICXc+zRAnPrCraOBhCWuzNPbZWUasK06YY6DyEEk8FJ5KwcMnoGFrXcCpxAmeOYov8N8ooXbsujKmxqV1TJFiOLXP5x3TUrMTPWSsoRqhPWU7jv6H1dfU7GeS8cL7jRDp1zHAP9K9lfSKrgOYLJcHvCMdC+I8QRjnvfGI/BcQS7JkM9yZyu5SqN+kX4Rb5kNX8xmcNMPlesU7EgrZAzLJxeV1rqpDwa9GE9q7kxFa++dAZ7psLQLRsn1/qfUVTORu73EBuQO+xEUzRn8AjWcBwLnIDJYO1Oy4SQEtdxUAxCtZKwkQO1JWT0DJayS60dW5ODc1JLwqLND4astCdn5kBBERBKHcdAaWO7Vi4aNFNzj63YSe0Kx17G8VDChL5BjMBxHcddFI63jjqvfy7e2jk1rugtu42BIuE4PdzC8WpWg4/nXDGzHw3y5hM5zMY2NiiwzFHWXHhY+Mojp/HtJ+fxpy/fgxfvru9ijQXau+554nQCAHD1js67XQOi853jiQwLmjuJbCeqYjGzuKFTiVHuNrZsy3U7q6YKAuI6jikFdH0Uo20IxzOh9poZe8LxcPDYqTh2jgerijwzUc9x3A1YVMWmmB8RWcB+L+fYowVOrTnCMTMgDUpUxVrWGZfGQxvrPDE5BgBI6c53gMVVSD4bBBSqXpAj+y0cF1cXaWXCMVA/roI5jnNmd+ecrPp3KUFAiIa5zCF88akvdvU5GZ5wnGDRDp1xHO8YD4LnSN9yjheSOUyGJfB1MvQ2ohPCsW3ThrJvus3uqVBvHMd6dccxIQQzZeXGC8mcG2HRT+H42EoGNi0sdjTDWEjCWkZ3YypuvnQGu6d6lyndDLppI5Uz6y5iMMdxqsOCAlsZDtRwHM+EZjbMB5wKFQnHviAACp07Ckqd19NqXIVqqk25lVuOqdAS7vMB+QxJwoEjnOsMLhaOi93H1VhVVnHX4btK3M/FMRVpvfD5Y1EVPs9xPJQ8Z1MUfpHHL0+09tnrJr1wHG9hwvF6a26w9ayOkTaqftiEYNiF47WMU/0U6aNjZz6hNigcO+/5MAnHBxZS+OD39uMleybwjut3bbh9u9c9j55aB88RPHdLrOV91KIgHEuwqFoQjtuIqljIOM2D6zmVGPUa4+XMHGRBdiPRqB2Aafow1kK+MWMqONVWRvFYwIuqGHQopXj8dLyq2xgApqN+pHPmwDgZzwUodapGYkERhBBcNBPBfs9x7NEktk1xel3BtrGAa3Dqx8J3NdaaaL7Mc05vG9bsfS41B0opOALIPnughON6GcdA6RyznILjuLtzTjYfX00J4HxL0EwN26Pbu/qcDE84TrUf7VCMJPDYNhboicu1GgtJ1RUlW6UTwnFCNWDT1ru5d4rdk2EspnJdF2cVzULQV0McjMlu08J0zkBGMzEbKwjH7ZRstgMT1He3UOrJoipYTMVlm6PYNcnc9oOVcxzPN4iqF1XRrRIgRWeO4+qfjXoxFYxix3HI57zHGncQ1HY+QycSJxpyMpVjU7tiklqPtvONDaXELSVyous4LnYJ65YO0678O1BK8cTCE7jzwJ2YS83h3w/+u7tqXdIYr2hyTm0/CKeijXU0jz4i8hyu3DaCh4/3rvFDo7BFpm5mHDPH8en11i6k2UJyqzDH8eqQR1Ws56OKChOv3o65lFKcTajY1IBwzKrFhqVBnqpb+B9fewIRWcTHbru8buM/RsQvItHGNdljp+K4ZDYCf53eAa3ChGOBCLCRdYXbdhzHC2lHOGaT5nqUj8nFk2jVVEvyjYnlxEyMhlq/bhF5sSHxt5qzOOwLw8f39xrfY2NOrGaxntUrGuMx2HzEa5DXOXKGDd20Ecs3A71oJoJDi2lYQ95o1qO3LKc1aKaNraOBrkUqtgqLAGtU54lIEWSNLEzbhGIobrM8v2RD0QpjeT+FY0ppSSyVZnAQOBtC0aVGXcdxfsNuR1Ww+Xg8I4EKx0FBsT22vavPyTjvhePFpAqBIw1Z7Rtlz2S4r47j2Tbzml3huA1Bcz1fwtBv4XhPj1ywjuO4+iRmOuJ3L8jYv9NRlnHcP8fxkeU0eI5gx3iw6cc6URWFmApCCAI+AVtG/TgyYA3y2OBWL6qi0Byvs3+LrM4cx9U/G40IxxOBCfCc83iBEyDxUl44ds5ZOTPXcH5ixfEZjWextyocp3KOy4JNepm7SeRF13FcvoJb3iAvo2fwH4f+A4+cfcQVyXVLx91H7sbTS0+XNsarEI69ydAwc/WOURxaSiOhtJ4x2g2SblRF5xpzlTMSEBH08ZhrQTg2LBsnV7Pugl4rRGQBPoE7BxzHGsZCUt8mXutZHZppY7aBRX0m1g+L4/iv79qPI8sZ/N1vXt7wdXSsjabAhmXjybkErqjS5KsTsPxggecAYiOVc8aTVh3HhmVgVXEa19RzKjFqCceWbUG3dPjFwvV9gOwAAIxF2rtu2SiuQhIkvHjriytu92IqhgOWb1xLOJ6OVPZi8WgPZliJBZy5xcWzESi6hVNr/el/5DGcsM/L1rGge/0yKFEVrOlwo+N+WHJMamwcZA1jAwPkONYsDRSFxZ2cwUHylS72pLTalQNuVEUPhOOcTqBqEmzhBABgx8iOrj4n47wXjhcSOUxF5LaiHcrZPRXCybVs1z845VBKsZDIdcxx3I4jhIl1nRTkW2FPPr+320K+k3Fcw1Uak7GUysG0bMznhWM2gYwGfEjnzL6sQh9eymD7WGDDZj3VGAtJsGzqxlQwdk+GcWTA8kjXGyinYaJ/xx3H+YzjUJWoCr/gb2jixXM8xv3j7u9BXxAadwC2VXg9R9ePtnZ8TQzQnXAcMzcXIaTEcVw+oS5xWRkqvnPwO265bzEUFA/NPYRfnf2Ve1uxcGzbMsClcSp5qu+dej1a4+qdY6AUAxdXwYSvcBcdx4QQbBkNtCQcn1pTYNoUF0y0LhwTQjARkoZeOF7N6BgP+vpW6smaOzYSVSGLPGIBEctD8J7f+8wCvvLIafzBdTs3zDUupp0F8wMLKeQMG1dt745wLPIifLwPYn5OwNz2rTqOFzOL7kS0kaiK8qgmtojqRj0VNcYT7E3gOYpIoL25xkbC8WxoFhPBCUyHShvpjQY84XgYePx0HBFZwK4aYwHLfvdyjjsHqyQdYcLxDGuQN1jzI4/B5lT+2m/b6ABGVeTHxpFg9WtgViHr/i6GwBHOrbw5sHoA6+q6E1WhFXSIZgxNnaZ8gVgzuJKYCqC+cCz1IKpCNVSopoq1tPO+W5zTaNBzHPeI4rzZTrF7KgybOuVBvSSlmlANq+3YjU5EVTSTfdNNNsX88It81+MTMlodx3FUhk2dzvSL+RX94oxjoPelswBwZCntCuvNwty7LKaCsXsqhOMrWZjW4GTKsgD/sTqLGJLAwydwSHdYOHYdx1VKamfDs25W4UYU5xyHxBBskoRuFyaYp5Onq8Y7bESjwrFlW3XLc2phUxspPQXDMmDapuuWikpR13FMKa0o4WXHZdom7jl6z4ZOrZqOY8uPHPcEPvHIJ/DDEz9s+vg9+s/lW6KQBA6PDJpwnDMQloSOLjpXY8tooKXmeMdWnO9BO45jABgPS1gZ8qiKtayGsZAPYSlfWdJjx87ZhHOubkQ4BoCpsDzwjuP5hIr/9W/7cNnmKN5144VNPbadiK6N3JOdICAGIAiOGMucg606jhczi+7/W4qqMJWS24uFY9MYx2jYaDuKaSo0VfdaZFNkEwDgkolLSm4f83v5xsPAY6ecfONaMTJTUefa2Iuq6BwJ1TlvRPNRFbsmQxA4gv0LzV9He5y/nF5TwHMEm0b8buRhVhuMZt9rWR1hSYAkVNc+9o7tLfmdEIKwL+wKrza18fO5n8MvWQPjOC4efy3bgmYQyE0Ix71ojlfIN3auZ01uGQCwNbq1a89ZjCccJ9WO5RszWDxCrzvBL6ScyclMm1EVzEHVCeG4XjxAL+A4gl2Toa5nTiuaWdNxzD5fC8kc5hM5EFLonN4Jkb4alFJ8/qfHcKaG4JAzLJxeV7C7ReGYLQjcnI+pYOyeDEO3bHeVdBBoJKoCAMKS0PGVXCUvHFfLOG4kpoJR2SAPyGga0iu/jvTKryO+dDMePVF7cWTfyQDOrFa+/uJs4HokcomS8p1GSWtpWLbluqUCguM4ngpOQeREUFBYNsXC4nORVgufI8VQQCnF/cfvx3J2uannLI2qkJEmv0RQDOIl217S9PF79B9J4PG8rTE8cmKwco6TqoFIFxvjMbaOBjC33lwjSwA4mo8MumCi+SiiYobdcazoJnKGjdGgBFnkIHAEmZ47jp3zXyMZxwAwGZGwNODv+f+97xAMy8Yn3/i8pquWYgERqmFBN5tfYH70VByzUbnt69x6BMQARN75jLBrgoXMAp5dfhbL2WVYduOTwuJKmZaa4zHHsaGCI5ybKSzxEjJKoGa+scg1fm7y8b66IjC7VtkW21biIvOiKgafpGrg8FIGV9aJdpEEHuMhnxdV0UHYwhiLqpBFHhdMhDzH8QCxmtEGfrHk9LqC2ZgMkefAcwQBH4+M1p94y3JY74hajPhHKsaVsBSGZmnuQuxSZgk5axWKxoNd4vY7qoLx+OLjyOmVjmPDNiriFBks41jrYuJAsXBMiAmDJuHjfSX9D7rJeS8cs2Z2nWTHeBA8R3qec8wmd5OR9uIheI4gLAstZ9ABwHperGuno3un2D0Z6urfwrYpFMNCsEajFrcMLJHDYjKHiZAEkXe+et0SjtezOj5890H8wwPHqt7/yIl12BS4bFO06v0bcclsBM/bGsNvPn9Lye1s0WSQ4irWszp4jrjvdS3CstBxQSGTXxmulnG8Kbyp4f0UN8jzC34QiNDIcRjKLhjKLmiZS/HIgS1VH6vqHO55bBQ/ejpWcV+jA3TL+cb5lVn2PMxxPBWagsg7fw8lO4vs+vV4+FBBCFBNFT+f+zlOJk429XyGZZRMvE2bIIv9uHzqcvf5PIaPq3eMYf98Cqk+VGbUIqWaPROOVcPCaqa5jOdjyxlMR+S2ozQmwtJQN8dzFw5DPhBCEJKFnlf4zCdU+PMRFI0wFZGxPOCO41NrWTxvawzbW+iR0M51z+On4rhye3cFS7/ghyiyxq3Ov4lcAg+efhB3HrgTX3jiC/jBsR9suB+b2ljKLLm/t5NxzHoEsIX6qeAmJLICxsLV38PJ4OSGz1VMrTLXiBRBRHLK7DnCua5jH+9D2Nea8WCQIYTcSgj5D0LIWUJIhhDyGCHkt6ps9/uEkCOEkFx+m5dV2WYTIeTfCSFpQsgqIeTThJDOTjg34InTjTn0p6OyF1XRQQpRFYU58MWzEeyfr+1W9Ogt7/rmU3j7Vx/v92HU5dS6gm2jhTE2KAnuvLLfrGW1DavKt8ZKXbARnzOWFI+Fy+pxWDaBYTlj26A4jp9dfhaKTiGJlaaNWq5j1rBX7YFwvJYS4JPWoVt6z0RjwBOOcd+fXof/edPejTdsAiZGd9vlWg67CN9IIGuEdpu2rWU1RP2iK5D2k91TYSymcl1rQpczLVDqnNCrUXAcq1hI5Uoc7t0Sjlkpy33PLlaNjbj76QWEJAEv2j1ecV8jjIUk/PsfvrAiP5OVRferOWQ11rIaRgK+Dbu9h2ShCxnHtR3HzDncCLIgu04fQghCPhmm/DOMbvs4Rrd9HMHR+6HmYlhJVn7fjsz7YVOC+XUJKaVUwO62cMzyjVVDhciJEDjnfWCOYwBQVUcUP3w26K44H1g5gGeWn2n6+cqzsRTsA4WB500/r6Xj9xgMrt45CpsCj54cnLiKlGogInevMR5jy6izoHK6ySqOoyuZtmMqAGAi5DRCHdZu8Ez0Hs87Y0KS0PFIoo2YT6qYjcmNRxNFJCynNdgD/J6nciYiLS5KRNzrnuYWQ84mVCwkc7hya6yl522UgBiAKDjXZDmj8rNiUxvH4sfc8a0Wy9llWLQwgczomQ0rB8qdTMXCcXFMRVjYAUoJRsPVP8vlecQbsWdsj9u4tpjyBe49Y3sg8iJG/CMNf56HjHcCyAD4UwC/DuABAF8lhPwR2yAvJH8WwL8AeBWAZwF8jxDynKJtRAD3AdgG4I0A/hjArQA+35uX4fD4qTg4Aly+JVZ3u+Im3h7tw6IqihcLL5px5qKs74pH/7BtisdPxd1Ir0Hl9FoWW4vMjWGp8/PUVlnL6HUjIAFgW3Rbye+yIEPkxBLh1UK+gXo+57ivjuO8E5rFK2Y1uyKqAqgtHMs9yDh2HcdpEZy4DM3SIPG96yfWf1XvHGXPZLjn4tlgCcd632MqGMwFy0p3O03WdZVWFxGifhF+kcdCMoeFhFpSYtk14TgfkbCe1SuyQQ3Lxn37F/HyiybdPJ5OEfAJ2Dzix+EuvdetsJZp7LMYkjrvOM7qzmfD34H3ubgsNCgGoRgKbOoMTr7gfgA2Hj1eOSk9eMYP2We5/y+m68KxlnCexyw0xhN5EVE56k6Cc1oIhMsircpYSjjfh1abI5TGVAjI8j+DgFDPus16dIcrto7Ax3N45PgACcc5oyNj7UZsHXW+N7Vih6pBKcWx5Q4Jx2EJNi1kxQ8b625slnNh3Y3z/EacjasN5xsDwGRYhmVTN/JrEEmqrX/+Y3kXXrPXPYV84+46jgNiAALHA5RAM2sf4/6V/XX3s5AubehqU3vDMbdaVIXbI6BIOKaGs+A61iHhOCAGsCVSWbXE8o0ZkiBh9+juDfONCYZWVH4tpfS3KaXfpJT+iFL6ZwC+BkdQZnwAwJcopbdTSh8A8GYARwG8u2ibWwBcBOANlNK7KKVfAfBHAH6bELK7Fy8EAP7w+l34zttfVNPYwpjxHMcdJaEYkASuZI518YxT4XlgwXMd95uTa1mkNRMJxehLj6FGSOUMxBUD20YLwnFIFpAZkONdb0DnGQ+Ml5ikCCEIS2Gk9bS7iEp4Z0w8m3Tyv21qV4yDvYI9L/vXtERoNFGxXU3hOB9Vkeui4ziei0M3CVKKAPDznuP4XGH3VAgn17Jd/fCUM0jC8XpG73tjPMbuSaecrlvxCYUc2+riICEEM1EZi0knqmK6B45jdkwA8L2nSycvvzi2hoRi4OZL63fSbpU9U+GBi6po5LMYksSOO9EUzUTQx2/odm6E4okaG4iZwMoLaQjyaRyZLxWKVJ3DySUZl2/PYjKm4+CZ0irJbgvHyVzSvQhgwjErew1LzvfSQgbBsXtBYFccX7MUlz/ppgCVexwRYWdVJ5XH8CCLPC7fEsXDA9QgL9WjjOPNI8534vRa48LxQjKHrG7hgg4JxwCGNueYRVWwMSDchcqSjTibyDWcbww4jmMAWE4PrpDTjnDc6nXP46fi8Is8LprpbkRCQAyAEAIOfpjUcBdoyzm8drhu3nFxYzzGRnEVxRNmSilUU3Vvk8XCtaOuxQAAo1WiKnjCYzzQfDXZ3vHKZkYzocrrxEsmLtkw35jFUg0blNLVKjc/AWAWAAghOwHsAfDNosfYAL4Fx33MeBWAX1FKTxTd9m0AOoBXdvaoayOLPC7dvHEk3UxMRlI1SuYOHq2TUPSSmAoAeM6mCHw8h8/+5NhANRA/H9l3ttCkcG59MLO92TVfcZxq0CcMRHM8SmnDc+ty13HEF4Fpm27vGy4vHM8l4u42/XIds4zjnJkDtQWAiljKnqy4BqjtOGbCcXe+3xk9A93SsZZyFgJt8ZTzvJ5wPPzsngrDpsCJ1dacc62QVA34ylY4W6UTURX1QtN7yeYRP/wij8NdcoCzSWit5niAc1F2eCmNtGZiNta7qIpNMX9FXMVd+ZiK6/ZMdPQ5GbunQji+kh2YC6O1rI7RBj6L4S5kX2Z1q6YTvVlG/IWMuqCYF46LmttJwf1Q1BhWkoXvP4up2LtZxd5NSkVcRSPOXtM2G8pmrEYyl3RLf9jAxoTjoBgEgQCLrEAKPYtweBEHz/jRZA+wEoodx4lcAiAmRnzVs589hourd4zhmbPJgSnTa0c4awZZ5DEZljDXhOOYVdfsmmhfOB7PlyI2m7E8KKzmndLseiQsiz39DOUMC6sZrTnHcb557nJqMMX6XL6xXasLJ+x7w3JAG+XRU+t47pYYhC5HoLFFTp74Ydp6TfdTzszhePx41fsopdWFY61x4Thn5mBT253MyrzzueA5Hhk1iJBsVc1fDIgB+EV/Uw3yAMddXOwOGw+MQxIqS2CjchQXjFxQcz8c4Urc0ecA1wI4nP8/U9cPlm1zAMAoIWSiaLuSbSilOoBjRfsYGIqbeHu0T0IxKjLtYwEfbn/dJXjwyCo+ck/5x8ejlzw1VxCOm6nm6iWn8sLx1qKM45Dc+6itaqRUE6ZNN4yqACqFY2YaYuIrxzmvM60WBPFGG7d3mmLHMbWd16bZCRxaO1SyXVJLVjwWACSBRVV0R9wvjqkAAIs7C8ATjs8JduedPod76LxMdXAi27bjOKtjNNi7zJV6cBzBrslQ1zKnlXwcQbBKAzTGdMSPo/kspemiqApZ5ODjua45jt9w5eaSuAoWU/GyLsRUMHZPhqFbNk41mcnZLdYyGsYbWBXthhMtm3ccd4Jix7HIi5B4qWRwZXEVTxT5Ww6e8SMaMDE9omPvZtW9jdFISVCrbuOcmYNqqu6kl2UwMeFYFkLg6SioeAqEWAhEDiKRFd24ilYofj8S2jIEexZ+oae9aDoOIeR1hJCnCSEaIeQEIeSdVbYhhJC/IITMEUJUQshPCSHPrbLdxYSQHxJCFELIPCHkg4SQ7pwIOszVO0dh2dQtV+8npmUjq1stZ7w2y5bRQFMZx65w7DmOsZbREfDx7sJuSBKQ7mFUBcsNbUY4nsoLx0sD2iCPNU5uVzhu5ronq5k4sJDesMlXJygIxxIs5OqOkbXiKtbV9ZIO7Yzixc1yLNuCYRfeE+bI0i1n0YY1eI1KUaynxapu4+LjZxP0RuEIhwvHLnR/3xzeXHPbes1m/YL/nMk/zje9ex2Aj+VvYh/ARNmm8bL7R6psw7ar+iEmhLyFEPIoIeTRlZWVFo+4NaYjzvnJyznuDAml+nz8N5+/FW9+wXZ84Wcn8K1H5/pwZB4AsO9sAjvzjV3n4gPqOM5f8xVnHIckAdkBEI7dBfkG5tYz4Rn4+MJ2Pt4HWZBd4ZhFVWSKTj19cxznjU6qqcK2neswwuXw+MLjMKzCeFvLccxxBD6BQ87sjnC8pqw5/6ZEEGLDJM7vnnB8DrBzIgieIz3NOa41ULVCO8KxbdOGsm96ye7JUNf+FuwkXi9DbCYqu07K4uZ4hBBE/KI7EevcMTknrddcNoOAj3fjKlhMxau7FFMBFDKlB6FBnmHZSOXMhhYxWPblRs1rmkHRzbpO9GaISBG3uRzgOHYzRqHZjhNXMYdD887FEIup2LtZASHAaNjEZEzHoSbjKuJqa0JdMuesyLrCcd65FJWcsklN2QHeHoPNOa4sIj8NQmjF8TUDm5Trlo6MuYKg9RJw/PBOhAghLwRwJ4BfAngtgP8H4G8IIX9Stum7AbwfwN/kt8sAuJ8QMl20rxEA9wOgAP4TgA8CeBeAv+ruq+gMV24bgcARPHJ8rd+HglReeIz4u98cD3Byjpsppzy6kkHUL7oN4dqBOY6HVThez+ol1U8hubfC8XzC+bsVVxptxET+PV8aUMdxu7ForKlkM9eYT51JwLIprtzefeGYxSzwRISNbN1MyYXMQtUmeUfWj1Tdvl71TrlAzcZm3dIhcqIbuRTxRbGeFmrmGzPXcNjXfKTHnrE9rug7G55t+vHFzz/sEEK2A/gqgO9QSr/Y7eejlH6eUnoVpfSqiYnuVATWgp2fPMdxZ0iolVEVjPe9+iK8cNcY3vvvzwzEQvj5hmVTPHM2hev2TCDo4zE3ICanck6vZzEW9CFUpC2EBqQ5HosAa6SynCMcNkdKFyEjvggyegY2tUG4HAAbilaQJPslHJc6jp1zIsfnoBpqSQWRYigw7ep/B1ngoHUpqiKec84XqykRIX8WupWPsToXhGNCyC5CyOfyTimLEPLjKtucJITQsp/K2q4hRBJ4bBsLdM3lWo1Ols5G/CJ0027Jbp9QDdi0sRNKr9g95XSz7bSzFyhyHG8QVeH+P1r6BY/6ha41xxsN+nDD3kk3ruLufd2NqQAKLrdByDmO55sLNRJVEZIFmDaFZnbuhJ/VrLpO9GYghJTGVfiCMG2zxKEkBZ9FVoliLSWUxFSktBQopdi7ScHZsriKjQbolvON86U8uqmDIxz4vLGVOY4TiZ3gEYGZ76hr0Di2Tqg40EZcBZuUs8E1aF031MIxgP8N4OeU0v9OKf0+pfR2AJ8E8L8JIT4AIITIcITjj1BKP00pvR9O93YK4B1F+3orAD+A11NKf0Ap/Swc0fidhJBID19TSwR8Ai7dHK1o9tkPUh3sJ9AIW0b8WEiqMBqM/zmab4zXCddfUBIQ9PFDKxyvZrSShUOnK3nvmsuczQvHzWQc+wQOo0EflgY047hd4VjgOYQloamoisdOOuf0K7Z0Xzj28T6IvAiBE2AhjYRS/3tX7jp+5MwjeHLxyarb1ouqqCccFzu2/PwEcgbfcccxAIR8IWwOb4bIi5gKTTX9eKAQpTXMEEJGAdwD4BSA3ym6iyl95cHBI2X3x6tsw7YbOLWQVTksJAbTfTlsVIuqYAg8h0//1hWYjsp465cfw11PLwzt+DqMHF3OQDUsXL4lii2jAZwZUMfxqTWlxG0MONdjvW7uWw1WDcXOGxtRkXMsRUBBkcwlQQgF4VTopui6egdJOHaEbWBFKa0CWVWqxeE78XLdjqpIZAVIUspdVG5lrG+VbjqOLwFwM4BDKGRDVeOrcPKj2M/NXTymntJNl2s1OikcswGvFUFzPV/CMCjN8YBCdAgr4e0kWTfjuLZAyMRiQipPtO3GglQ/poKY/epLZ7Ce1fGzo6u479nuxlQAjsCzecSPw114r5uF5XI2FFWRX9XtpButk45joHqDvOLSVxZX8eRJzo2p0Lgj+PbBb2P/yv6qcRUbZUm1KhwzF5ZmaZB4yRWxolIUpgWsrs/CJwBmkfC9dWq15biK4o716+o6ZDIOkW4B4QbzorBBngvgB2W3fR/O5PPa/O8vABBBabOeLIDvorJZz32U0uIaq6/DEZNf0tGj7hJX7xjD02cSUPX+NgdJ5R2IvYyqsGnBvboRx5YzHck3ZoyHJaxmhnNiu5bRS87/IUlAzrAbFuHbZT7hTDqmo805QibDEpYHNKqiE42Ym620eux0HLsnQ4jWEGM6jV/wQ+A42CSNpFJ/AYY1yaOU4qenfoonFp+ouW29qAoWTeH+bji/a5ZWIhxzllNIUtNxnBdu2SJts1w4fiGmQ9MtN5VlwvWwQggJAPgeAB+A11BKi1UMFk5bnlO8F8A6pXSlaLuSbfKLvTtRmY/cd2SRx2jQh4UBPecME5RSpwK4zrlqJOjDP//uVaCU4u1ffRzP/9D9uOFjP8b/uuNpfOiu/e7P/7n3oGuA8egMT59JAAAu3RTD5pHAQGccbxstPZeGZQG6ZUPrUhRCozQrHG+JbikZTyJSBCInuuIrxyuwrYAbAdGKcFxvbG0UViGrmqqbcUw457Zyofjo+tGq++iWcEwpdSuAVY0D4TPu/LrVsb4Vuikcf5dSuoVSeiuAZ+tst0Apfbjo5/EuHlNP2TMVxsm1bNdWHsrppHDcTtM2t4RhQDKOAedvAXTHBVvIOK4XVeEIdRMhCWJZY5duCMeKboIQJ0P5pRdOwi/yuP17+xFXDNzcxZgKxp6p8EA4jteZ47gB4TgkM+G4c3+LrG6VlBm1S3En84AQAAEpaXDH4iqePR3CySUZIyMn8MMT90O3dDy68Ch8UgKT0dK4ig2jKnKtmWPKhWPAcXL5RT9OLsswLRGST4FFLbdj7VjsTMtxFVk9C0opNFODYigIcxcDKKwWDykynC7sxbDfL8r/uxeABaC8NvoASieu1Zr1nAagYACb9VTjym0jMCyK/QvV88V6hSuc9UjE2pKfPDSScxzP6ljL6h3JN2ZMhKShdUSVN+pl5/le5QTOJ1RMhCVIQnOLtVMReWCjKgoLJ62PbZtG/HjkxHpDi0CGZeOxk3FctX10w21bpbyZW0AMQOQpKFGQVOuXwOTMHI6uH8X9x++vmXnMaDaqglIKwzJKhGMt51SMjUc2cBy3EFUBAFujW7F7dHdLjwWGO6qCECIA+BaA3QBeSSldLr6fUnocjhnq1qLHcPnf7yna9B4AzyeEFFvtfh2ABODe7hx9e0xHZC/juAOohgXdsmtGVTD2TIXxi/e8DN9++wvxnlftxY6xIH5wYAlfeeS0+/OPPz6Gf/5Z9QacHq2x72wSQR+PneNBbB7xY25d6WhEYadYTucwU1apxOaTzBzWL5bTGmSRa/gawMf7MBMqaA+EEEwEJpDSU9BMDYRTQK2AOz420ri9nJ+d/lnTjynGprbbT8BxHDvvPZtDVhOO2dy1GFnkkOtCVEVSS8KiFih1oigpl3GqkQTfuSEcU1rl3TzP2D0Vhk2BE6u96Q45KMIxE+sGKapi84gfssjhcBcc4JkmHMflMRVA9xzHQZ8AQgj8Ph43XDSJYytZBH08XtLFmArG7qkQjq9kYfbI1VWLNRbg38BnMSw5n/lO5kcpmln3c9EsxcIxIQRBX7DCMSwFn4WSC8KmBHH6I/eCyLAM/Hzu59i7uTSuop5wrFt6Q6u41bKeklrSFXJZvjEb3A6eCUAUTMhSxj02ANCwjm0TGg6ebT6ugh0nez0BshuE5EDI4F0QNsFRAM8vu+3X8v+yD8MIgAyltPxKMg4gwCItMGTNeqrBchj77cRMqfmM4x45jrfmheNGco6PrXSuMR5jIixhZQgdx5Tm+y0Udf4O5/9mvco5nk+qTTXGY0xFJCwPalSF0r7j+J2v2IOzCRWffqB6FnAxT5xOIK2ZuG73eMvPtxF7x0vXzgJiAILgnFKTDURq/OTUT3AsfmzD7UzbrNlsr0I4NhUYtgEK6i6+AkAiHUNINhEJVBcP2omqAJxMyp0jO1t6LDD0URX/CKfy9XYAY4SQa4p+2B/hAwD+KyHkfYSQ6+H0HtgN4KNF+7kDzkLtnYSQmwkhvwXg0wC+Sind+EPfB2ZjcsNVLR61iefPF7EGzo8iz+G5W2L4g5dcgC+8+fl4/P2vwP4PvtL9edneSXzjV2egdzBC73znqTNJPGdTFBxHsGU0gKxuNRWb1At004Zh0Yrm6kGptwvftVhM5jAVkZuKQ9se217y+1jAqaBdUVYcx7HduuM4mUviZOJkyz15gEJjPMAZi+2yqArFUEoE7ZyZw1yyssGlX+S70hyPVf9qJoFNCSwah27pkHjJ7R3UCwahOd5/I4TohJAkIeSOstXZoYbFIxyu4bzUTRsfuftAR8okLJsinTM7Lxy3cDJdZcLxAEVVcBzBrskQ7to3j7d9+TH355sd6Gqr6CZ4jkASan+don4RfpF3ncfl97XyPm90TMWC5WvyLuOXXzzV1ZgKxu7JMHTLxqk+Nx1oxv3OnGidzI/KaGZdJ3qzjPpHSwbqoBiEYiglq54sroIT4hCk+ZLHzyXnEAgfAlCIq6g3QNcahDN6Br+a/xXuO3YfvvbM1/Clp76En5/+ubtaa1MbaS1dMemNSlFYNnBk3o/tU0mIeRcey2lOa2lctEVBPCPijofG8e+/GMO//2IM3/3lKDK5+sMVE47Zvnh7EoQf+knQZwG8jhDy+4SQEULITQDemb+v6zOJfjbrqcZkOC8c99n9yhb6etUcbyoiQ+RJQ45jFsfUSeF4PDScURWpnAnDoiXXIqEuRBLV42xCxaYmGuMxpiIyVtJa3xdfq5FkCydtXG9es3MMb7hiMz7/0+MbVif99PAKeI7gBbu6IxyLnIgLxy8suS0gBsAu6VK5jUvFqzmPitGMwrhdK+e4XDhWDdUdU5nj2C/4sZTwY2a09jExx28vXUjFDHlUxY35fz8B4BdlPzMAQCn9GpyeAW+G4x6+DE6kxTNsJ5RSA8ArAczBiZH6NIB/A/CWXryIVpiOylj0oiraJqE4383YBo7jRvjP12zDakbD9/efE+2f+o5u2jiwkMLlW2IAnP4RADA3YHEVis4MaaXXmL2+fqnFUiqHqXBz1zXbY9tL5q8+3oeYHMOaugbKpUAtf8vC8VJ2CQDw7Eq9gIP6FI+/juNYAmCDkMJYW+46rtYEVxL5rsTpMeFYzTcRVOkCAOd9PFcyjhvhOwD+EMDLAPxPOJmNDxJCqkrng+Z+2ogLJkIISwJ+frR6gPZPD6/gcz89ju89vdD2c7Hy+oFwHOfFupEBEo4B4NYrtyDqF3FsJYNjKxk8dGwNn/pR+wv/jruXr7vyRgjBm67dhtdcXhkTEfWLSGsmbLtzzsjyiITr907i5RdN4s0v2N6x56jHninWIK+/OcfrWR08Rxr6XrgDcodWcimlUHSro45jH+9DyFcQhIK+IChoySDLC2nI0YcRiP0U1T6Sz64/gGhQx9k1R8ytVxJUK9/4dPI0nlp8CnPJOTci4sDqAfzbgX/DXHIOKS1VUvbjE5xzQUSOIJkVoBkctk1qEDnn78Icx2ktjQs3Kdg8piGZFbCWFrGcFPHs6SBOLde/SGHCsW7pICAg9tiwx1QAjpPpM/mfdQB3wnFCAQCbScQBhAgh5R+0EQAKpVQv2m5omvVUYyzoA8+RvjsxUx0ebzeC5wg2jwQamtwcXc5AErimmrFtxERYQkIxms7VSyh6z7KEq7GWqaw4CbMFwh44diilmE+omK2yYLwR01EZNu3/Ikk1kqqBoI+viN1qlr+4eS8CPgHv+/YzdUuFf3J4Bc/bEuva9217bHuFS9aJqsi7u/T2MkaTCo9P/McmzK04n8NaVTzVoirKheOgMIl4RsRsHeGYCbc+3lfiVO4VwxxVQSndTiklNX5OFm33T5TSXZRSiVJ6BaX0h1X2dYZS+jpKaYhSOkYpfXtZXvJAMRP1I6EYfe8hMOwwI1Ct5njNcN2eCWwe8eMrD59ue18ejpFPN21cusm5FN480ng1Vy9hEZjl80c3qkLvr3C8nNYwGWlubPGL/pK4CgCYCEzAtE0oeNJxHOecRVXTNt2xrxGWMo5wfGTtSNUK2KPLGXzuJ/Urgli+MeAs2lJbBuFyJfPo1WypnncycdKdvzJkkUeuCxUCBeHY+UzocFKUfLzv/HEcU0r/mFL6NUrpg5TSzwO4CcAsgP9aY/uBcj9thE/g8PKLp3Dfs0tVJ09373ME41qO5GboRLOSYtqLqtAQkYW2JxWd5ndfsB3f/9OXuD+/98IdmFtX3ZW9VlH0xlylf3HzRXjNZbMVt0f8Iijt7ApiVjMRkAoDjizy+OfffT6et7X7HckBZ9EE6E6mdDOsZXWMBERw3MblNGG5syu5umXDtGlHHcdAaYO8kOi8z+VxFaGx+yBHqsfFq6YKXlzCasr5jtdb2a0lHNe6Patncd+x+/Djkz8GUCj9YZPXiBSBkl8tjQW4gnCcdwmn9BRkH8V/vn4Z//3GRfz3GxfxX25wBkf2uFoUC8ciLwK2H9xwN8YDpdSilL4DwAQcV9MUgIfzd7N/DwLgAewqe3h5pnG1Zj1bAAQwgM16qsFxBOMhH5b7nP2aUg0IHIG/B9UbDJbFtxFHVzLYORFq6JzXKBNh5/vLKjga5aa//yk+9aPqDUR6gRubVVRxwiZeGa37palxxUDOsFuKqmAT2rMDWDqeyhltuY0ZYyEJ737VXjxyYh13Pn626jarGQ37zia7GrG1a3QXRF4sad7jF/0QOOezkjPauyZIZXnYlGAp6Yi/tXKOWTM8RjXhmDO3A0BNxzFPeMhCYZG1l04kxpBHVZy3TOcbXXmu4/aId1A45jmC3/q1rfjF8bWuNHc/33j6TBIAcNlmR2jbMuqMzYPWIM91HJfNH7tRGdsslFLHcdxgY7xidsR2lPwe9oUh8RIS9DGAikhqhTGwGdcxcxxrloZj65UC8R2PncFH7jlYt+cYW7g1bRMZPYOUdbTCfLSqlgrHpm3ieLw0g1wWOGhd6G3G5t2K7lynGDSefz65xFDWbQZK2cuX+RwCcEW/j6VT3HzpDJKqUeE61kwLP9jvfNA7MRh0WjhmOYCtCMerWR3jod67HJpld94Ve2y5vQzqbJuu0nZE+lpkNbOixKWXBCUBm0f8ONLnC521jNZwk0b2mc90qDmeolVfMW6XEX9B/Bd5ET7e13QjAYObw3pGgGV3VjhmsHIetoLLJr1RKYpsfrU0JBecUWzFNqtnK0p+ZdEGRyiUXP33sTiqwsf7QG3/ueA4BgBQSuOU0n2U0gycKp2HKKVM7H0IQAqlzXoCAF6LymY9NxFCipWE3wSgAvhJN4+/k0xF5L67MFk/gWby3dpl62igMeF4OdPRmAoA7njeTFxFzrCwlNLwo4NLHT2WZlhlUUVVmuP1otST5YW2Ihwzx/igTWiBzvbT+M2rtuCKrTF86O4Dbol3MT874owl13VJOJZ4CVuiWwCgRHD1C37w+SIO3WrvmkA3nakW6yvQSFSFYRmu64onPHguH+ukbQJAMT1SXTguj4lotUFeq/CEd3saeAwXM/lInYUBXKwaJhJqvuq2A1EVAHDbVVsg8gRffcRzHbfLvrMJRP2i2zciLIuIBcQBjKrIzx/F6o7jTlXGtkJGM6HoFqaadBwDlXEVhBCMB8ah2PPQyWlkVOrOARsVjk3bLJmTVmtQy6oU62VDM6NTzsxhObuMBftryPA/KtmmPKoCqIyrkEW+rkDdCpZtIZlzFj1UVzh2fh/1j5YsenebgRKO89D8zznBi3ePIyQJrruY8eDhVaQ1E7smQziylGk7pqDTXd55jiAsCy1HVYwOWExFNVicQruOb6XNHNtuCMeKblWE6veaPVPhjrjp22E92/hnMZh3aHeqhJmVEnXTcQw47p5GGtiVICyAUoL1tFi3JCieq0wwoJRWvb0amqXBx/vcQS0qRd18poBkwy/6IXKi6zi2qV3xWggB/JLtrrLWgrm4dEuHj/M5ZUZDnnGcb8jzZ4SQlxNCXk8I+RaAWwC8jW1DKc3BacrzF4SQtxNCXganKzwH4FNFu/ssAA1Os56XE0LeAqfJz8cppakevaS2mQxLWOp3c7yc2RHHZTNsGQ0grhhuLFU1VN3C2YSKXROdFY6Z43ilCcGejWfPzqc6nuHfKG5z1KLFw05XltSDuYVbiQ3ZnM9ePBsfvHNYUu2M4xhwqgj++nWXIqka+NvvH6q4/6eHVzAa9LmlxZ1mx8gOd3wqFo4lQXIdx6atN92stRjNdCbKaSXvFmsgqoJNmtkYyshmJzAWNiGL1Q+oQjjuseN4mGMqzndYD5aF5Lmx4N4vEh1oHlrMRFjCTZdM447H5rwYkTZ5+kwSl22OloiXTjXXYI2zrnAs1Yiq6KNwvJSv+GvFcVwtrmLMPwYCDhnhXphGxB0fyytpa7GSXSkxHC1ll7CmrJVuk792Vep8f9j4q5qqa2ZaIV8uGa9VQ60Yv8+mzpaI3LLIIWd0NqoiqSVB89Iom0PrNNPzmApgwIRjQshz4JTSPtbvY+kUssjjFRdP4fv7S+Mq7t63gIgs4Hev3QbVsNouR+y045jtq7WoiuEQjreNBSHypG1XbFZrz3HMGih01HGsmxUlLr1m92QIx1eyfW3us57VMRpq7LMoCTx8Atexldxs3nEc7LDze9Q/WvJ70BeEYRtN5UHxohP/sJpyjq3aym7OzFW9Pa2nKzKdaqGZhUmvLMiQBMmNnAhIFvyCHyJfEI6B6m6sgGTVjaqglCJrOFnLhmVA5EXYth/c8DuODTiu4G8D+CKcWIkXUkqfLtvuowA+BOA9AL4HIALgFZRS1+5JKY3D6SfAA/gugL8C8HcA/rKrr6DDTITlpgTMbpBUDUTk3p5fmUOm3gTn2EoGlHa2MR7QmnDMJs+UAg+fWNtg6+7AojWKr0fCUr6ypAcTr4LjuPkJlizyGA/5cGYAheNUBx3HAHDxbAS//Wtb8fVfzuH0WmHMsW2Knx5ZwYt3j3c0eqWYC0YucP9fIhzzUl5Q5mBBgaK1rhzrRt5xrOYdxzWiKqoJx7qlu2MopUA8FW4o35jR6wZ5Q94Y77zGi6roDAlFhyxyHW1E/p+v2YZUzsT3np7feOMucXwlgz/71lPQu5Df2gtyhoVDi+mKRcgtDfaP6CU1m+MNQFTFcv780IpwDFTGVYi8iKg0gSz/Qxh6zG2QN5eaa+x4sssVt5W7jlm8XT3hmFXIaqbmVK7SbRBJFMfix0rm1+WuYwqKo+uFSDYn47izCzzFjepVjQchNgxLhY/39XyM75pwTAgJEEJuIYTcAmATgAn2e/6+VxNCvkYI+R1CyPWEkLcBuA/AaTgT5HOGmy+dQUIx8NAxZ/LEYipuumQaF886f/Ajy+05MwdJOF7LahgbgqgKkeewYzzYdg5vVjfbEge74jjWLIT6GFUBALunwtAtG6cbKK/uFqsZDeNNLGKEJaFjA3LWzajqrPM77AuXOJBq5RzXgxdXQUDdnONqjy0eqIrZKKaiGM3SSvKNASCr8ZAEGwLvTNRFTiwRotlFQzEBya4bVaGaKizbgmmboKAQORmgIsjwZxw/Ril9fr65ToRS+mpK6b4q21FK6YcopZsppX5K6YsppU9U2W4/pfSG/DYzlNL3U0qHysIyGZawlu1v07VUBx2XjbIln3lb73x6bMVZBO18VIVzvmlOOC5caP/iWH+E4/WsjogswCcULnVlkQPPkZ5MvOYTKiSBa3khfdNIYDAzjjssHAPA26/fBY4j+GRRw+L9CymsZnRct7v9mIrxwHiF00kWZGyKbCr5vfj/hBAIRIJNUljLtv550YzmoypUUwWlFLqlFxrcWSNQdREzo7W/h+WO315HVXj5xsOL38cjFhDdBS+P1kgoRsdiKhhX7xjFrskQvtzHuIr7DyzhjsfOtK1X9IsDCymYNsVlm2Mlt28ZDeBsXK3boLXXMIGzvHKYRVf0YuG7FottCsflcRUAMOYPwyZZZHXNHR+PrR9z4yPqwfKNizmyXtokbyUfs1avqWCJ49g2INqbMMv9Nmxq49j6MdfVvKKsVDz28Nph9//diKpI5BLu/xWdA8+rbjVSr6uKuuk4noRTLvstANcAuLjo90kAc/l//x7A9+G4nn4A4EXDVDbbCG5cxdNOXAWLqbj5shnsmnT+4IeX2nO9DopwbNsUccXA2BA4jgFH3Dzc5iCo6NbARVU4juP+RlXsnmRRIP3JOTYsG6mcidEGM44BZzW3UyXMSpccx4QQjMiFnGO/6AcBQcZo/H0mnImgP1e3QV6r+cYMm9owbdPNO2TCsapx8EuWe+zljuPqwrFVN6qiON8YAATifPaGParCoxLWybmZvN1O06nmYM3AHMf1Mm+PLmfAEWD7eGddf5LAIyILTb3nifx4Nh6S8NCxyly4XrCa0Sr6LRBCEJKEHjmOc9gU87echb055h9Ix7HjuO/s5386KuNN12zDnY+fwfH8AshPDjsTtBfvGW97/wIn4NV7Xo3ZcKFB8c6RnSXZgMXCMYtY4okAi6SRyLYuKrCoiozKw7adBdXyqh3DMmAVreEphgKLWrCp7S4UC5bT/7Se47hcuPWiKjyaYSbqx6IXVdEWiS4srBFC8DtXb8VTcwk8O59saR/zCRW/98VftTzXnE84n4viqpBhYt/Z0sZ4jM0jfmim3fdKtmLY/NFfJhxzXO+uX2rBoiomw60ZBKvFVQR8TkyOaqruHNCiVokgW/N4MpXCsW7pOBE/4fzftN1Gyex9rQYTqVXdiarg6RhkPoIdsR1QTAWnkqcAoCIGA3BcyI+ceQSryipkwYmq6ORCRHE8pKpzAJeCYRuQeKnni8NdE44ppScppaTGz0lK6dOU0pdRSicopSKldJpS+mZKaf/qMLqELPJ4+UWTuG//IgzLdmMqXnjBOKJ+EVMRCUc6IBz7hM6WxrQiHCdVA5ZNhyKqAgD2TIZxJq66ZSGtkNVMNx+3FTotHFNKnWPqs+OYud6O9ml1Op4fKBqNqgCc/MtOZxx3ujkeUBpXwREOESmCNWWt4QgJAAgGUi0Jx7WcyOWwQZi5pVgOk6LxCEjOyi1zHJu26Q6y1cp4A5INRav9PjLhmJUTicQRqbkhdxx7VDIVdsQddvHaD7rhuNyIaEBEWBZqOo5tm+KJ0wlsGwtCEjp/zpkIS65roxHYeHbTJVM4vJTpy6RsrUa/hZDUuQXCepxNqC01xmNsHvHjbEJtuwdGJzEsG1nd6srn/20vvQCSwOMTP3Rcxz85vIJLZiOYDLfmbCpH4ATcvPtmbAo7LuPimAqgVDgGnLFL4HjYSCPZhlbCoiooCNK56nEVxW5jwKkCYuOZG1VhbAPPUUxEa4/zXlSFRzvMRGUv47hNEoqOWIf6DRXz2sudRS/WMLRZ7nlmET86uIwDC6158xaSzvX0qT5WkTbDF39+Ajd87Mfuz8e+fxjjIR9moqXneVbNNUhxFUyTqDaPD0p8X6MqllI5hCWhLcNcRVwFJ4KDBM1OloyN1RrdFZPVszWbw7Ooi2LDQz2th43BKT0FCgqOToBwOcTkGCYCE1hX12FTu2qDPAB4YvEJ3LH/Dhxce8Y5Nq1z17wljuMcgcE5r+2ciqrwKIXFVfz40Ap+sH8JN14y7ZZP7pkKt1360Y2JbCvCsduMpgmxrp/sngqBUuDYcuNl/uUoulWRQ9QMssjBx3MdE44104ZNOx+R0CxBScDmEX/fHMer+XzLZtzvoQ5GVbABKtSFrOnynOPNkc2wqd1wJhQAyHIc8YwAy0bVgbeWcLymNlZ2zvKiKqMqOFc4ZhnHQMEtXD3j2IZmcKgVG8WOlU20BcQAACSfcTziH6n6OI/hgzmOl/uUw0gpRUo1O+64bIStowEcX8lWOBl008Y7v/kkfnZ0Ff/pubM1Ht0eE2GpueZ4+Yzjmy91nCUPH+9sXIVu2njnN56suzDpxGZVnv/DslC3yWCnmE+oLeUbMzaN+KGbdl/d9eWk3Oq2zo9r4yEJv/uC7fiPp+bx2Kk4Hj8Vx3V72o+pKEbgBLxq96uwe3R3ifsYqCIcCxIEnsAmaaTU1jOWdbPw2HSNuArVLF3kXFfXK4RjTZ3BdEwHX2fmVi7cCpwAv9D64kWzeFEVw810VHYFQo/W6EZUBeCcH7ePBfDYqcbMG+U8nn9cqk3H8akhcBxTSvHPPzsB06K4eCaCi2ciePHucfz5TXsrKoC2jDrnx0Gq7snq1R3HQH6e2obZrV2W0zn3OrxVyuMqCCHwkTFodAnJXEEziOfiWEgv1NxPtZgKxpnUmfzxFgvHtR3HbAxO5hxnOk9HwHHOY5mrVzVU5MxczbgpALDg7Od0ovZxN0uxcJzVCCzO2bfES+dUVIVHEdftmUBIEvDB7z2LtGbi1ZcWbPq7JkM4spRpy1WSHBTh2BXrBj/jGAD2TDmu2FaFe0ppPuO4dZGWEIKIX0RSbby5WT1Yt9V+O44BJ67icJsZ0q3CSlOaE47FjjfH64aAXy4cy4KM6dA04rl41aiHaoi+VdiUYD0tVnUcF5fGMAzLqNnYpxxXOM5HVURlx3GsajwC+agK5jhm+wZqOY6d7VW99L1UDRU/OvEjPLn4ZMk+ONt5LsKpkAQJF09c3NAxeww+zH243KeywpxhQ7dsRLognG3EldtG8LOjq/idf37EdQ2lcwZ+74u/wrefnMf/vOlC/PHLdnflucdDkrsY1wgJVQfPEVy9YxRhSXB7PHSKw0tp3PnEWXz1kdqLZetZvWq/hU5WltRCMy0sp7W2HccAcGaAMkdT+YXVaBccdQDwB9ftRNAn4A+/8hhMm+IlHRaOAUdMfdnOl1UICNWEY5HjYZMUMmrr33fN4MAR5/o+peSbG5V1Zi93HK+r6+4Y6uN9oJRDJjuCmToxFUD1qIheTiy9qIrhZlPMj7hiuPMIj+ZJqEZXHMcAcMW2ETx+Ot50GTylFI+ecgwWrVbbsAWF0+utG616xdHlDM7EVfzBS3bi0799hftz2/O3VGy7mTmOB8hJreoWeI5AEiplupAs9tlxrLWcb8yoFlch8yEY3GnEM6Wv+cDqgdrHUiWmgqEYCtaUtRKTSb2MYyYYJ7WCcMziDtmCLJsr13IdA4DIO9/Ns6nKLORWSGvpkrxmRedgkkUAzthe3POoF3jCcY9gcRVz66oTU7GrkNm2ZyoM1bDaaoLSDeE44hehm3ZTId9MrBuWqIptY0GIPGnZFasaFigFAm26SqN+oWOOY7ai1o2IhGbZMxXG8dUszD40smrF/e4ICp35O3RTwB/1j1ZMeqdD05B4CaeTp90Q/3oQ0Rl4VlNChXCsGErFRBZwVj0bvWDVTT2fEel8DiNSBJQCSpHjWBaLhOO841i3dKhG6bmQba9o+ZJfSnFw9SDu2H8HjsePF57Tznegp84gz/E57BrZ5T6Hx/AzHvKBkMaEY0ppSZO2TpDKdb6fQKO8/zUX44P/6RLsX0jh1Z98EO/+t6fxm597GL84voa/vfVyvP36XS3n6W5Es47jhGIg5hch8Bx+bcdoxx3HLOv5J4crO2oDgGVTrGf1qs1Re5ERuJR03qt2hONNMZZrPTjCMbtO6ZbjfiTow++9aAeWUhqCPh5XbO1dtYjbhK7od57jYSHdlnCsmwQjIefzllKd8fB08nRJU9ri8VYxFKimCt3SQUAgcAIsfQKWzdfNNwaqR0X0MgPRcxwPN+5i1QCdc4YJds0R9XdnDnzlthGsZvSmm46fTahuvFeqhWobzbTcheNhcBw/cMi5Lrj+wskNt5VFHuMhCXPrg/OZz+omAiJf9XouJP3/7P13mGTZXd+Pv8/N91buHGeme/LszGzOUWElrRYhIQTCRCFAgPHP/hoHhG1MtoHHX7Cxv1jIYAzICLDAEiggaRV3FVYrbZqd2cm5c6pcdeP5/XHr3Eq3UndVdXVPvZ9nnt2uuhW6+tY957zP+/P68Nu6sbOUzG/ZOAaA20dvL/tZFUU4JIlMTilbk9ZrklcvcQy4uIqyxHENxnHaSHs9BliamKdRr2pV4iXwhPfel1+DPCahYBzPp9rT26M0xEUpYBgCLOI+96A22JbXaEXbH0m8hfT2E+P4+MvzZZgKoDz1Oj2wOT5YIme2jQPHxBbGP/rH34Io+C9Gh4Myfuc9t3u/z1rBOB7aIagKkecwMxTAhU2mYlmqdCusH2Bz6e5aynQQkdCqDowEYVgOrq9nMTsc7NjrnJ5P4H8/fx2/9t23QSjUcRY3MVpojtdG9qVXatRG7jiTyIuIKtEy3jBHOOyJ7MGF9QtYTC9WleFWyubmQUCxmhSxlF7CR099FIQQcISD7fgPrs00xqOUQ2btbcjhQ5B5GYQQqKIKiZeQNwgcSrwEsSqoXiK5dOGcMlJQxaLhwo5nxvEL8y/g1aVXq17bsA2InAjquI8lXA6Hhw43fM997RwJPIfBgIyVVGNUxZfOLeNnPvIinvvXb8BIGya6QOeNs3oSeQ4/+uA+vPP2Sfz+Fy/gT79+FZLA4Y9/7B480cQCaSsaDslI6xZyhu1bPlmpeM70UqkP7h/EF84uF9AN7SmbZ4u8SysZ3NzIeqkh7/WzBhzqv4kdVMSOL35ZEGByK8ZxwcSZ6yETpxONmCv1E4/M4E+/fhUPzg6WzZU7rdIxB3ATyAInAMRCxth8RaBhcgipNtJ5HskCquJa4ho+8upHMBWewpGhI2Umcil6iY2hlj4FABgfqL15wxGuKjUNdJdz3Gcc72xNlzRhPTzW3RLo3aCsYcO0KWIdShzfs9etNvzOtQ3sHWx+k6YUb5HMtb7GYQ0TxyMK5uM5mLYDsR4zZ5v1xbPLODIWanq+MT2g4ma8dwzxnGHXrFYNygLW0tvzXimlWE7qW0ZVAMBkeBIHBw/iwprb00CTAeSArOE2SWdjiU1tnFs7h5OjJ8seX483zHQzeRPLKQ2EuKZrLVQFSxsDRXQjT2MgBVQFIQSaqDWVOGbG8VKquUbyjVSKqdBNAgoOFtYg8RKicrQtr9GKevdbvwv1+OFhvPvOSfzEI+VQ8AMj7uC8FRZsJxLHD+4fxEP7B+FQCt10qv5tZEx8/OV5fK2kYzpDVcR2SOIYAA6OhnBheXOffRFgvzVzsK3GcWEncqsp6Hbo0OjWz+1m9D++ehl/8fx1fPNy8UK9ljbAESDawvcipLiM43Z0Q83qFjSJB8d1JgE4olUbRWE5jAFlAIvpRd/EcKnydgrRoIXVpAib2kjoCcTzcazn1r1SnUo1Yxyb+b3IJ++HbtlFTEVJYzwAZYxjgRMg8VLZDnMlP6qYOOZBKcWl9Uv+r22bkHgJju0unkdCoSqsR187XyMhuanmeNfWsjAsB5dX21dameyCcdZIEU3EL33XMXzpXz6Bz/yzRztuGgMuqgJA07zdZM70rr0P7XcrrL7RRlzFzY0s2KX1q+erJ/FXC8aw34ZBUBbahiSqpfmCcVzZiKcVBWUBUU300tW9oG4YxxFVxCd+7mH85vcc79hr+MkvcSxw7jwqZ2x+fqZbHCTRQVi1PFQFAFBQ3EjewOcvfx7Pzz3v3V5qHEuCO5d2jD1QJRvRQO0KwFpp326hKkRO9HoW9LUzNd2DZfs7SRuFCqdOoSoOjgQRkgV8u0XO8YvXNqBJPBSR2xTfn/GNH5gdhEN7azOzUsm8iW9f3cAbjjQ/L5qOaT2WOK7dOynQhYqpWopnTRi2g7E2BTHun7zfY/BrkmtJ5iy9Clno1yRvLbtWhnDw00JqAUvJHAYDEmSBq9kcr3TN665FCTiEwHHFdbQmashZOTjUwVq29lyWGcdpw6jLQm5WpQExhms0aBwSL3Wdbwz0E8ddlSzw+N333lF1e0QVMRqWcWErxnG2/cbx/uEg/uKnHqh5v27ZuOfXn8GnXl3wykHWMzrCitDTO5GVOjQSwqdPLTSdpCqVx7HdIo4gooq4uNIec9VLQfcAquLAiJsydhsYjXXkNfKmjWded8uSPnVqHo8cdE2KtYyBgYDUknEbVARYDoVuOVC2mBSuN/A3UkAMQLf1uoPicGAY59bOVd0+FZ5CQk/g0sYlHB487C18K2XYBgZCBlaTzW/yrOfXQSnF+fXzoJQiIAUQEN1/zCQ20sdB4cCkSci8W0ZTNI7d6wIzgmXBTVMFxEBZg75KTnMpqmIps+TbzI9SCsM2EFWioIYKQvI4MnSo6d+tr52jkbCM5SYSxyxZM99GRiwr8wxvo3HMtNkKpc1oOFRoSpjSm3rdeNb0HnNkLISYJuIbl9fwvXdPteX93NjI4fBYGImsga+cX8YP3r+n7P5PvDwHSeDKsGBM4S40x2M8yPHI1hLWUzF1SxizdqtbGyf7hrqPPPBtjlcYP/OWAd3iIQuthyIMk0AWKMKajVSu8byi1Dj2UlfGFCYHDNQj0dRK+3YLVdHnG+98DQUlKCKHGz1sDPay4oWmsNEONMcDAI4juHNvzGt016y+c30Dd0xHcWklvSlUBRvPHpgdwP99aQ7X1rPbco1uRs+eX4XlULyxBeN4Kqbi06cWYDsUfIfCPq0oZ1g1cZOhbTSOFwu84HagKgB3zH1w+kF88coXIXIiOKpCtxNVhms8H8fljcuYic54+I5GmArATSvf2EhgOKTAofmajGO25rQdG3krD4GoIOA8VAXgjq8UFHkrD45w2Mht+DZeZ8axZRMsZ5a3bO6WJo7ZGtqkKWi81lUMFdPOcfd2uQ6OhDbdoM12KJJ5q+sLWVng8eSxUXzu9CIMyzV21mo0o+llHRwNglLg0iaMWy9xvMUGaBFV9LrQb1XsPW3VzG6HArKAyaja0cTxV8+vIK1bmIyq+OzpJY+nvJ7RW2Zthwop7XbgKrKGheAmz4vjI8cxGhite8yw5t80SORFzMZmoVs6zq+dr2s+hwMZbKQFNIug3shtwLANpI00TMfESmYFV+JX8NrKa1jOLINSDnrmKGxsgMLyElxscGWJ46jmfs4c4SDzMjRRg2EbXnO7ygmBIjrgCEVW58uYxqWyqQ0KCpEXQR0FHJ/H/tj+5n6xvnaURkIylptIHLMFUjuN4yKqYvuvr93UcGFcb5ZzHM8ZnrnIcQQPzA7iG5fW2lLNAbiJuOmYiscPD+PrF9dgllzEdMvG370yj7feNuZrcAZlAXnTKXtMu7WQyCOmiS1vRldqMqr2FG/UO/97YOOk3ZIFGQRF00ARFPCc+/dzSBYvz1/c1PPqFgdBsBDSbA9VUU/ruXU41IHlWG5jPEeCnh/AeKx1vjHQPVRFn2+880UIwVRM6yeONyl2fWyl0rFV3b0nhnNLqaYN4Ixu4fWFFO7eG0NYETeFqlhIFBPHAHB9rXcb5H3p3DIiqog7p6NNP2Z6QIPlUM8Y3W5ldLumcRxsY2Vsq1ryjOP2+TyzsVnsiewBIQQSGYZOV32bvH/u0ufwxy/9MT5+9uP4+o2v16w8rdRCIouRkAxV5GsyjhmqIm/lYTomBOKOZaXGMRvfWHXs+bXzvs8llhjHzZjbjVTKOM7qBBQmLJqDxEtdxVAx9Y3jHtHB0SAuLqfhOK1fCFLb2Kzn7SfGkcxbHq5iLW1gcAdhKoAiY/r8JjjHGaN9ieOUbm3q71/1njzu8vYnjgH3890sCqQZffrUAqKaiA8+dQTrGcPDVbjnYmuDW7BgBrVjNzejW5s6L0ROxLHhYxgL1k9ox9RYzTRxWA7jwMAB5K18XfM4oCbhUIL1VOP3mTEyyFt55CzXxJiJzuCOsTtwZPAIQlIIc6k5ZLOjoE4ANncdALwy25jCjGN3yNkTK+7SKoJSNSDPpebKynMIAVTZQSZPcCV+xff9Gba7qJY4CY6jQpGcftnsLtVoWMFqWofd4HrJ0pFz8fYtBtiiaztRFduhkUJ6eKVJVEW8ogrqwf2DmIvnWm7q4ydKKW5u5DA9oOHxQ8NI6RZeuh737v/S2WXEsya+965J38ez63wnG8wsJvIY22LaGHA7vs9t5LZlkeinZM6EJHBbrsjpVZWmjmVehkDcc8UhSZxZmq/J/68lSt3EcUJfRFi1kDN4mFbtRJvt2Ijn48XxjJdg6WMAOIw3aIxXK/EblDrXX6KZ1+9rZ2k61lubVTtJRVRF59bBd++NgVLg5ZIxr55euRmH7VDctTeGsCoitYkG4PPxHGKaiD0DGmSB69kGeY5D8eVzy3js0LDX76YZ9RqiJWvWR1WwythuiwU22t1T6+HphyHxEhQ+DJPMYSPjP2e3HAuL6UW8uvQqFtILTT33WtrESEhGQOZrM471EuPYNiHAHTMZ4xgoNshjFa/n1/3X1ixxbBYSx1tR3sqXYSc3sgYs4j6nzMvbgqroG8c9okOjIWQNe1Mlid1gztXSo4eGEJIFfOpV9wu8XsAD7CTtHQxA5MmmUrFs4blVkzasiqC0fUlX9z31RiLu0GgIl1bSDU2ezYhhKt56bAxPHhuFJvH41KmSc7HFJo0h2f0OtaOMOaPbmzovjgwdgSzIDY1jjnAY0qrLsJnCchj7Y/uRt/K4sH7Bd4CTFddkX002vnawXU9mHKuCCo5wCEgB7InsgUMdLKTmAaID6ovu8xcSx1E1CqBoHM8MFt+3KqpeUooNyJRSvLpc3vxOk22sZ03kTP9rJEsrS7wEaisI3WKJ0FtJIyEZDgXWGpiY7HrakcTxLWYcDwQkEAKsNpE4tmwHqbxVxnl8aL+bVPp6GzjHq2kDOdPGVEzFQweGwHMEXzlfnKB/7Ds3MRqW8ehB/6qMYBsrS2ppPpHfEt+YaTKqImfaXrPX7VYn+mn0ksqM4xJUhYMUcrpYM2VUS6ZNQEEQN5YQ1txFa7IOriKej8OhDnTb/Z7JvAzbcjn9g6H685JaiWOe47uSBu43xtsdmoppuNFDXPWdJIaq6FRzPAC4fToCjpQ3vKsnhrW4azqGkCJsOnE8HlFBCMGeAQ3XesRgrdSpuQRW0wbeeMR/7K+lqUIj2p4xjvX6qAqgPQGnVsUSx+1ojleqgBTAocFDUEUZDkljKdme3831VQhiAQ6aJDREVeSsHCzHAo8wQHQQUjTnKxvk6ZbuWwFbiqpYza7CoZs3+EsxFQCQyNqwiJtiVkRlW6p8+sZxj+hggQW7GVzFdhrHlbgKF1Wxs4xjkecwMxQocHhbk2cctyFxDKAtDfJYCnqr76ldOjAShGE5uNaB0qZnL6wirVt4+8lxKCKPNx0dxWdPL8KyC+dii5sYXuK4TQZ+q4ljAuJ1jh0NjpaVzfqpFq6CKaJEMBubRc7M4UbyRtX9vLgKAtqUcbyWcw2fvJmHyIleCS/gLraHtVEknJdA1a/A4uYAykEgIci8XEwU6zwkwcFEqMgeU3i3HFgRlDJ28aX1S2Wd5jXJQSJbO+3FEloiL4JDEGG1N87/vtqv4ULaYbmBidkJVEUyZ0KT+B3F8W+HBJ7DYEBqqtFgsnD9LC3X3T8cREgR8PpCdQliq2LN4qZjGsKKiLv2RL0GeSspHV86t4LvuXOqJqsw1MbKklpaTOTaYhyzBW2vcI53u3HMWP1AOarCJknYVgSvLr/a0kLQMN1z0HSSCKru9ShVB1dRyjcG3I1Qx3J7BITU+mnneovI0mQSAalZrbQV9VEVu0PTAypSeatt+LxbSd3YWA4pIg6PhfHi9eaM429f28Ch0SAimoiwIm6yOV4OE1F3PNs7qOF6jyaOv3h2GYQAjx9qrWHwRFQFIeiZpH22QXM8oLMVU7W0lHIRXLLQ/oqjqBKFKrnjZTxremGgrSirc6CUQBCyNRPHGSPjBauyZhamY4KnERCuerNeEzXkzGIFmF/TvlLj2HKspprK11Jp5S0AJHM2LOKG4wbVQY/33MgraKdurZVPD+vgiDup20yDvO00joEiruK5iyvYyLaOB+gFHRwNbSpxzC5CW033ttU41i0QAihib3y9D40Wzu0O4Co+9eo8opropdmePjGG9YyB5y6uIpEzW0dVsCRaO1AVRuuJ49nYrLfAk3gJA+pA3eOHA4131aNKFEPaEDZyG1WpY91OIxq0mksc54qJY1WsLsEeEu4HhwDWuL+GiVXwdAiwo2XNA7I6B022y943e66AGEDGyHgDskMdvLb8WvE42UZOr/15Gk7BOOZEECcARex+GVdf3RFLOzRqkFdqHLer1D+ZNxFWdq9xVk9vPzGOz5xaaLho9DiPJeW6hBDsGwzgahsWnKxxE2vS9/ih4ULSSMcnXp6D7VC8525/TAXgLryBziWO86aNjazZJuPY/R17ZUHrnv+7d1OOdXgH3LQvRzhwhINDEnDMKFJ6Clc2/HFJfsoZ7nWHcnlwfBwAkMjW/vw849gqjme2FYYqmWi0Vq+X+D05ehJvnn0zvu/Y9+En7/pJPLLnkaZ/h2bVR1XsDnll+z2YOs6bNvJma7iYbmojY0AV+Y6jfO7eG8VL1+MNKzkdh+LFaxu4e687Dw8pgrex24pY4hgA9gwEcH0923BO5Th0U434tqIvn1vGndPRliufJYHDeFjB6wtJnF9Kef9yNdAGnVa2TnO8blRM1dJSUm9bY7xKReQIArL7eedM05dz3KrSefczpFwcqij4mu0MUwEUE748ImWYCibWII9V3q5mV7GSWSk7ppRxDABL6c1zjkv5xgCQ1gGbnweAsorjblb79Iaz1BcimoiRkLwp83K7jWOGq/iL52/AduiOQ1UAwKGREG5sZFseJDJeI7qtN8cD2mUc2whIgrcTtd06wNL0m2BI11MppoKl/544PAJN4vGRb7qM3ZZRFe1MHG+CcXzH2B1lPzfCVTRKHDMNaUOgoFU7nxkzg8FQc8bxem4dlLodZUsX10xO9k5ErPciYy8iZV2HQMfgWGFElah3TFbnEVAoglLQSzyx0uCAGIBNbS9pBQDn1s55P1MuCduuzQw1bdM1jQmBaYtQpL5xvFvFeLuNGuSxksyMYW+qPNNPiZx5y6bZf+4NB8BzBP/lCxfqHhcvcB4r5yR7B7W2VJ6wclKWxn3skHsdfO7CKv7mxTncPh3FgZHa7LegV+rZmUUtayQ03gbG8SRLHPeIcXwrJY7Z/wucAMqteciIV5de9X2sn67HXYQKR3RY3BoAilQdVEVp4ljiJRBC4FgRD3NRT/WM29nYLA4MHMCgNgie43Fw4KDvOL4V9VEVu0NsQ+5mDxrHP/Vn38YH/6b571+3Fc+ZHcVUMN29N4a0blX15qncTL+0kkYyb+GuPa5xHFZFJHNmSxvpWcNCImdivCRxnDPthv0O/uJb1/HIb30RutUd83UlpeOVmwm84XBraWOmmeEAPndmCW/5va96/372f3+nze+yOWUNG1qN4FFwG1EVy8k8RjpkHIflMESegKNB5O00UsbWPYNMwTjWsYKAzCPns+lUalAzo5anAyCkuBblOd5r5A4U+/EAwJnV8tSxUGEcb4VzXImqyOk8LLJQ1RivNKDVafWN4x7SodHQjkNVAEVcxRfPursqOw1VAbjNCSl1B9lWlNVt8ByBLGztqxTR2mcc19up3A4FZAGTUXVTmyL1VIqpYGK4Cu9cbBVV0cYBOWPY3vM1o/HgeFWCuJFxHJJDTS3+NFGDJmpYza6WTRizZhbDYRMbaQF2HZ/VoQ7i+Th0WwcFLeNAAgClHPTMMQxKM5B5GQ4siHQMjhXxGuMBbuI4rLrfFcY/Zu+fLXpLcRWGbeD11dfdx9rLoI4KSv3PbbbQpo4Ax+H7ieNdrGFmHDeBqhgKuse2q9Q/mbN2tXFWT6NhBT/ywF7835du1h0r42xOolUbxzc3cjDrXWya0M2NLAYDklfpc3wigoGAhA9/9TJeX0jiPTWa4jExJFGnEjsLCfdca0fiOKKKCClCz5g4u904Lh3bBE4Az/EQOAEOF4dtusbxWm4NNxLV6Cc/XV53y0oJpyNjJBBQHCSbRFVIvDt/cawIIlrj70wrxi3P8Tg+crypYwVOwG3DtzU8ro+q2B0q8l57Y7OqVK8vpPDqzUTjA7dJ8ayJSAcb4zHdvce9FjHOMaUUv/u5c7jvN7+A3/6Hs948n93PEsdhRYTlUOTN5sfg+UJz4QmWOB50rzONKo9euLqOZN7yuM+d1pfPuQbdG45szjj+7e89if/vB+/y/r3l2Ci+eXkNRpeb0NmFxnea6L9+7EZz31paTOYx1ma+MVNACkDkRUhkFDpdx2p2dcvPyRLHkpADx5nI6NXGcSKfqPp/jg54iWOBE/CW2bdgMjzpVSGVGsdXNq6UNbATS5rjAVszjitRFbopwCLLkHm53DhW+sbxLamDo0FcXE7DabGJ2HYbx4Bbwsre9k5EVRwadVOxlbu3jZQpmLRbTfe2m3HcK43xmA6NBtuOqvj0qYUyTAXT0yfGSs7FzTGOt9ocj1KKTJ3mBn6qTBsDjY1joDlcBeCmjnNWrsyYzZgZDEVMOJRgPVX7nGENe1hjukqz2szvBXUCUIJnMRWeAgAIdAy2Fa5CVcS08qQx+68qqCAgZQMyAJxePg3DNpA05wAAju2/ODZtEyIvgjqF5+0njnetZIFHTBO9Rh1+opQilbdwZMxNnraLc5zI3bqoCgD4mSf2QxF5/OdnaqeOGRszWpU4DsB26Jb/FjfWc5gaKF4HOI7gsYNDOLOQhMRzeMftE3Uf3+nmMguFhfZYG4xjwG2Q1zOM4+ytYxwDBQY/4eGQBGxzAGzf9bkbz+GLV76Ib978Jk4tncL1xPWq50obaaxk3Dkl4XTE9TjCqoVkDVRF1sx6JbCGU2Ic2xGEGiSOOcJVvfdGOjZ8DDxpPEc5PHjYd35SqT6qYncooooIyb2zWcWkWzZW0zqur2dhbXHzsVOKZ42qca8Tmh5QMRyS8eK1DVBK8dv/cA6//8WL2D8cwH//8iX8h0+/DkopvnNtAzFNxMyQ+91kVZWtICQqN0L3Fsbeaw2M43OL7rWvHevaZvT8lXUMBSXcNhFufLCPpmIanj457v37njsnkTcdnJrr7kZFscF9byWObYdiJdU5VAXg9uVRuAgMLGAuMb+l57IdG+mca3MGVAc2ct5nW6pSVAVLH/POIAhnQORFvHX/WzEZnsSwNlzVIA8ALMfChbXifJgQgOeolzjeyG+UVdI2K8uxkDbKfRPDlGCRNUi8VNa3oBHWsp3qG8c9pIMjIWQNu+UFQiJnQhK4bWXaMlwFgB2Jqtg7GIDIk5bNzYxutZQqraV2GsdZ3WqZrdtpHRwN4dJKuiGPq1nlTRvPnFkqw1QwMVwF0Hr6XRZ4SAK3ZcaxYTuwHNqUgR+Ww3hi3xPYG91bdV9IDjVM8TSLqxhQBsARrmwXN2fmMBhyB7R6uIpLG5cAwNtVrVygGunbAGJA0i4iIkcwG51FiD4Mxw57O6GUuqgKtrFUaRyzAbnU2AbcxfRXrn4FDnEHdGpXfx6UUm+hzcHdBOobx7tbIyGlbuI4a9iwHVo0jhNtShznd7dx1khDQRk/9tA+fPLVeW9hWCmGqohWJK/2Dbrf3a1yjm9sZL1UHBPDVbz52EjV61aqnU1Q/bSYbB+qAnAXtK0yjvOm3ZAB3qochyKl7+7EfeXYJguymzhGBqAyqO2OLxkjg8sbl/Ha8mt4fu55fO7S5/CVa1+B7RQN3gtrF+DY7rlIOB2JfAJhzUayBqqCpY0ppV7i2HFkUEdGuEFjvM1gIlRRxaHBQ3WPYQ17Q3LI2xT2kyIo4Eh/SbkbRAjB1IDmseTbqXjW2PR1abGAALIc2jPM90rFcyZigc5fHwkhuHtPDN++toHf+NTr+NBXLuGHH9iDz/3zx/G+h/bhfzx7Bb/692fwnQLfmIWbWNO+VsIxbCN0IuqOZ1MxDYQA19Zrj+OG5XhVSd1KHMezJoZDStswjffOuGbcC1c339xsM2K9k9QGjONuG8draR0ORcdQFYC7HlYEDZRkcTOe3FKDvMvxy0jneciiA5GnMJ00soZdFc4sRVUwo5ZzhiFwFt62/20YD7lVzYwprAkaclZ535TXV18v+1ngqZc4BlDFQa5UIp/AQmqh6jaK8gphy+FhIwWZlxGSisZxN1EVvRVLvMXFUq8XllMeY6oZJQulg9vJtGW4ir99aW5HoipEnsPMUKBlDm/GsNuChVBFHhLP4X9+7Qo+fWrB9xiOAP/8yUN4ogG/yU1B99ZX++BIEIbl4Onff7bK6GWKaiI+9MN3N2W2fu3iKlIVmAomhqv4+1fmMbCJ9HtIFlo2FD7x8hzOLqbwC287AsBFmAD12ddRJYqToydxYOBA3QXXWHDMM2791GzimOd4xJQYNvIbmHamwXM8HOogoKZBQAvGcfVk3HZsnFs9B8BtjCfxktdpHmCYiqOQtHMgnAmAIKbGEBcoYMegiu5EVTcJHEowHHInn4wfWdpoLyAGsJpzcRql17NriWvguD0A/BPHDnXgUAcSJ0Hh3MmeIrZnk6Kv3tRIWK5rHLNEzcxwABLPtRFVYXa0Y/pO0E8/NouPfOMafu/z5/GhH7m76v5EgSdd2URt3yBLKmUANHfdqhRLLD91vPza/4bDIzg8GsL7H55p+ByqyIPnSEdRFVFNrLnwa1VTMRXPX16rui7W0x986SI+8vx1fOMX39i2Dugp3QKl2NXnfy3j2IabSrKtGDjBP2BwYe0C4vk4npx9Eqqg4vz6eVDnKICCcaznMarauLyogFI3mVSqUkwF4OKcHCsCAAhr9c/VzWIiTo6e9HBQftob3YuI4r6Ho0NHcTN5s62v31dvaiqm4urq1nn0lfpXH3sVGxkDH/vZh1p+bOkYfmUtg31DvXfOxbMmImp31sB3743hH04v4o+fu4L3PbQPv/yOYyCE4JffcQwCR/BHz7lNPN9zT3HDh43JiRZ6PswnciAEXtJUEjhMRFRcr9Ov4PJqGqZNC6/VHeM4rZtegK0dGgrKmB0O4FtX1vEzj+9v2/M2EjOOAzXW8Z3e+K6lpUJPkdFQ56rKI3IEqrQMGEA6z2Eps1R3w7KWEvkE5pJzyOQfQFBxP0/DSQEIIW/ZZR5JKaoiY2bAEQ6EhjEZETAaLCaFB7VBL+DkZB23309h/ZrUk1jKLHlVwgJfTBwDwFJmCZPh2gi15+eex3JmGd937Pu8tXFlY7xEPgnLYd9ByTOOecIjIkda/ow2q/72cA+JmcWssUqz6hXm3M8+sR8/9eiM17hop2kyqnoXxmblpnu3PlARQvCzT+zHickIhkOy77/r61n8j2cvN3wutzlebyWOnzg8gqdPjGMiqvr+bhxH8OyF1aYT368vuDuE98/4l2f83Bv246cfn91Uk4qgIrS8k/tXL9zAh75yCcuFpBlrmlhr4AeA7z36vTg0eKhhSqeZBnnNmgnD2jAc6pQ1ydOdNAKKXbNhz6WNS17SOGflamAqgpADp8tu5/gkYEe9n7O6+/xjYfc6V5k4BgBN0uBQp4wXxUR4d5LqONWLBbbQFnkRIinsCsu923m7r61rJKRgpQ6qgjXDi6oSxqOKx+nbiljistIQvdUU1SS8/5EZ/MPpRbzmU8YZzxkIyQKEik3C4ZAMVeRxdXXzieOlZB6mTTE9UH4digUkfPafP4Z79jUu2SOEIChXX+dPzydaahpUSwvxfNvSxoBr4qR0q6UGjzc3cljPGPjm5falpZIFA+BWMo4VXnGNY2qAwvY4x7W0klnBx89+HK8uv4qUngJ13Pkw4XTkzBwCqg7T5pA3q8f9SuNY4iU4llt2HepA4hhwk0rT4ema958cPen9/0xspiYOo98Yb3dpulDl0I7rIROlFN+6so6lTSaOS8fwKyvtN7W3Kkqpi6roQnM8AHj4wBA4AvzUozOeaQy449u/ffoofubx/eAI8MiBIe8xoQJmqyVURTyPoaAMqaSXz54BrW7iuLQaqVvGcUa3215te//MAF64ut62atlmxNjFtTaeVZEHR7rPOGZouE6iKsJyGEHZ/b1ypoX51OZwFYvpRazn1pHO8wgUjGOeLzTLLuEcZ80sTKd4fubNPEROBHUkhJXyDSCJlxCRI74N8gDgRrLY96DSOK7HOV7OLOPyxmWkjTS+cu0r3u2VfOP1TA4WcSuG3UaC7nc5okS6Ghy9tVc/PaZYobxyLd0aC6VXjOODoyH826ePbffb2LQiqohLLU5G2pU4Btw0cT39p8+ewx98+SLW0joGg7XN+YxhYY/cW5P44ZCM/++H7qp5/0vXN/A9f/B1rGeaM+4XEnkMBCQoov9nf2QsjF98anOcq+AmEsfnl9KgFPjMa4v4sYf2eTvGtbriAmj6Qt/IOJYFF5JfumtaS5qoQRVUrOZWvaRy1sxCkx1kdP/3embF7RjLDN2oHC27vxRTUSpOSMLMHwTgfqeyujvpHA+7u6RsAcqaDTjU8VJLGTNTlkQGAI53B2k/VIXhFBfaxHYX9s10od8JIoT8AIB/DeAQgASALwD4IKV0vuQYAuAXAfwsgCEALwD4p5TSlyue6xiA/wrgQQBxAH8E4FcppTvuw2KJY8eh4Ljq7xJbGIVVARMRtS2M41shcdmsfuLRGfzRs5fxVy/cwPHJ8rRDImtWNcYD3Gve3kGtkDjenG4UFqvTsa2NcUFZKEscf/ncMt73Jy/grz7wAO6fHazzyMZaSOTb0hiPabJQInwznkVEay5ZwhoUfv7MIh4/tLl0d6V6oZ9Gp1UrcQwADpKwzcbnRtbM4oW5FwAAlMoALBDCFq9JAENIZnmoFTglZhzrtjsPknkZjs4Sx/Uv0VvhC58cPVm26GUa1oYxESrywjnC4fDgYbyy9EpbX7+v3tP0gIqcaWMtY3gNZreqK6sZJHImfIbrpsTGcE3icXULY0inlNYtWA7dVGBlMzo2EcaLv/SkL5qJEIIPPnUEP/P4bNn9EbX1xrDziRwmKsazvYMannl9qeZjXl9IgRAXUcfQVZ1WRrewd7C9a9979w3go9+6gXOLKRzbJDu5VeXM+oljQggCsrBlpGKrYhs+HWUcyxGIog6ORpGzslhI+1dgN9JSZslt6J7jMDlYCBYJ7njrco7da1oppsKhDnRbh8CJAJWhStUbXEPaEDZyG24/HiuLQRTnAzcSN3DvxL3ua7VgHD9/83nv/y9vXMaZlTM4NnwM8Xy87Li1rA6LuOG60mZ43eQbA/3EcU9JEjiEFAHrmZ1pHO90RVSx5Z3RrGHVTZW2U6wB4WdP1x6sAReT0GuJ40Zi3NtmN00WE3mMdWjwCilCS5OqjYyB1bS70PtUATPCkmztSKMPaoPewrWWmuUcE0IwpA0ha2a93dKMmYEmO8jp1cPBUnrJYyLrlvs7li6si5iK8wVMRVGckITtiNBNd/BkiePJaKTseQghZSYyT/gqzjEAEC4PwIbjYxwzDpbIiaB2BALnVC3Kd6IIId8N4KMAvg7gnQB+AcBjAD5FSFlU/YMAfgnAbwN4B4A0gGcIIWMlzxUD8AwAWniuXwPwLwD8aud/k/ZrJCTDcig2aixKvHSkImIi2h7j+FZIXDarsCJiZjiA6z6po3jOrJm62jtYP6nUSIy72QrOy08hRUBaL16z/u4Vdx+m1c1jPy0m22scTxVM8la4nmwu88yZ5balBpO3onHMy0U0kzDfMHFcKerIXnd2AKDCGgAgmS2fo9mO7S0U81YeBAQSL8G2IiDEQbBDiWMAmI5M+84hStPGTEeHj/o+Rx9VsbvErjk3tnCtrtTLN+IAXNNyM9ek+XgOwyEZB0aCuNIBjMZWxVi+sQaM/XaqEc+/8n4vcdzCWnc+nquqoNkzqGE1bdSszjy3mMShkRAIae21tqJ0m3oOleq+beAcN0ocA5tDKm5VS0kdhABDHcSRuulZQMYodLqBtezaphrLLaYXYTsO0nneQ1VIgnvNKU0clwauclYOpmNC5KSy40s1pA0VG+QZ5dfG9dy6x0iuTBxnzSzOrp6ter6byZuYS82V3fb1G1/HRm6jGlWRtWCRJRBwGFSLhnWpidwN9Y3jHtNQUMZa3zjeFkVUEcm8WQVOr6esbkNr80BVS0fHQ5gZCuBTp+qXbmSM9uAzuinGxW723J9vc6KrVEFZbGknl+E17piO4oWr61hO5j3GcTs2FTjCYTQwWveYkUB97nWpBtQBEBAv3ZQ1stBk2zN2S3V6pYifYN3eS5PAtTAVAMAL7oDMEBhe4jjistxlvphiqWqQZ/gYx4SC8FlfxnFpaa9thRDS7Cp+5A7VDwJ4kVL6TyilX6CUfgTAPwVwB4DDAEAIUeAax/+RUvrfKKXPAPg+uAbxPyl5rp8BoAJ4N6X085TSD8E1jX+eENKdKEUbNRJyz5lanGOWOA4pAiajSgFxsLXNhFshcdmKJmsY8m5nef/Fxb7BAK6vZTdd+nljPQtCgIno1q7/pagK3bLx+cKG7M2NrRkledPGesZob+K40AhwrgXjOJ41IAkcFpN5vDaXbPyAJpQo2YzZrSodlwB3bBKIO45TcR6O1apxLJUZxzbcjdhktnxuEM/H4VD3+qRbOmRBBiEEjhWBKjdOaTa7eVxL7zryLjw0/ZCHogqIAewfqOZ6RpUoxoPVvSX6iePdJYYCamcTOmYcWw6FbrU+Fs/Fc5iIqtg3GOhJ45iFvrppHLcqdu1uNhxDKXUraCrG270D7vf9eo1Gt2cXUzg6HkJYEb3ql04r0yZ0ZKmmYhomIgq+daV7xnGOMY7rVKwGZMFDInZLy0kXWVKJIGuXBE6AIiiQBRkyNwCDLsF2bMwnl3FzVcL5ORXN7DflzBySehKUyrAdDgHVvdaIvPvgtF70GRJ60TjOm3mYtgmBFDjCYvU1ijXIC8thpM10WbN5wE0du79LeXM8APjy1S+XpYsB4Js3v1n1GpZj4ZnLz1RVESdzNiyyDJFTEZSD3u39xPEtroGAhLV0a5zdRLZvHLdDYVUEpWjJNHR3OLuT7iWE4OkT4/jGpbWa5wilFFnD7loKul3SJB6ywDWdtl9M5KomMu1SZRKtkc4XGir+P28+CEqBfzi96A3o7cKYNMJVsMGsGbHBmXGEGaoiW5E4zppZXI1f9X5mx5cmsoqYigtVr8MJrlnBFsjs+QcCUtXzlHKTA2IAOSvnLaLLnpPP+KMqbAMi5zYI1Q21IQ9yB0kEUMkgiRf+y2YlDwEIA/hrdgClNAPg7wE8VfK4pwB8llJa6iL9JVwz+fH2veXuaDTsGjw1jWPWoE11E8cOLTLaNisPf7GLjbNWNBnVMBev5mAmcv6oCgDYOxiAYTtY3OTf4uZGDmNhZcsN34IllSXPXVj1xv0bWzRKFgs9KsbayDiOaSI0iW85cfymIyPgiIuraIe8jZMulWJvhwghZeZxKaoC/BJss7V0T2XiOOcsgyO0qqdAad+BvJ333oNjhRFS689Jg1JwUw2ESsVzPE6OnsQPnvhB3Dd5H+4cv7Nm/wW/1HGfcby75CWOt7iRVipmHAOtoRKY5uM5TEYV7BsKYC6eg2711jyPVT/FAr1rHCsiB5EnTTOOkzkLWcPGRMV4xpAQ19erDfxE1sRCIo8j4+FNVfJuRo5DkTHstieOATd1/K2r6w1T8i9cXcfFJvv01FOGoQ7F2r9LsMXK2HZoMdm5Sl9N1HB0yB1XwnIYCh8EJTrWFr4Lf/2le/GRL4/ib78xhEuLjV9/KeOGABzLxSIWE8fumnIuWTR7S83ZtJGGTW0IRCscX/33HlTdBnljwTGE5TCuJa6VISUY8qkyccz00uJL+Pylz8N2bFxav1RlPDOt5dZgVxAEM3kCi1uEzMsIikXjOKb2E8e3tAYCUkuoCq9ZT9843rKY+d5KWU3WKO/O2Wk1wlXolgPboXXZur0oQggGA1JTqIqcYWMja7a1+VCpWmUcX1hKISDxePzQMA6OBPHJVxcKDKX2oCqA5hrkHR853vTzSbzkpXRdVIUNw+JQOg9/ffX1MvM2Z+U8HjFQH1MBAAHFff5i4piHIsIzfEqN49L/Z8klP1wFx2X9URWO6TUKyObl3WQc/08AjxJCfpQQEiaEHALwGwC+SCk9UzjmCAAbQKV7/3rhPpQcV1YrRSm9DiBbcdyOkJc4rmFApkoSxxMFRuxWG+QVURU7a2OuU5qIKsgadtXCsF4V1L7CgvPaJhNjNzaymIpt/dofUkTvOv+pUwsIKwLu3RfbcuJ4PuGau5VMyK2IEILJqIq5eHPvzW3SZGLfUAD37BvA587Ux1s1q1slcV86Hsl80Tim3Aqoo8Gxmz//XOO4OK9J6gmENLsKVcEWu5RS6JbuvQfbiiCi1U9nHh483LbmOCIv4q7xu+rOJ2Zjs1AFFQPqAPbH9uPeiXsbVkX1tbMUlAXENBE31tuTOM6bNl5fSHqVGKkWmrMB7vdiPp7HRETF7FAAlNZOu26XmHE80MPGMSEEIUVsep3LxrPKoM4eNo77/A3OLrrZhMNjIUQ10UN4dFIsrNMJ4/jemQGspHRcrXO+/c13buK9f/gNfP8ffmPLeJccCx7VWccHZWEbmuPpXmCj3bp7/G6EZbfwMSJHEFTcMS9HFxGJvYZ3PbCKSMDCs6cjDVPHi2l3o9yxXXOVNccTC0bwXHzFO7aUccw2b3nPOK4ed0VeRFSOgiMcZqOzCIgBXN64jJTuBsjmU/OwHAui4Pgax4DbcP7vzv0dvjX3rfq/SInyVh55U4BFliEJordO5gjnfW7dUt847jENBaWWUBUuK2r3T+S7IfYZNrs7Sil1sRBd5AkzXMWnT/kD49lAstMSxwAwGJSx1kRzPJZU6xSqwk0cN89gu7CcxoHRkJsIPzmOF66u48qqO3Fo17kxGhytmf4B3MngA1MP4A373tCQhwyUG8cscQwUOcS2Y1fxmHJmzksG84SHld9XE1MBAAMBAQD1FshZnUNYLf4OslCCqhCLf8ugFARHONxM3qxKHRM+A8fRqv42hm1A4iRInIJ0Xtg1jfEopZ8C8D4AH4abPD4HgAfwvSWHxQCkfRrcbQDQCCFSyXFxn5fZKNxXJULIBwgh3yaEfHtlZcXvkG3TSKPEcd6CInKQBb7EON7aIpilmPvjrStm4JYmYZlpGa3xGbEFZ71FWD3dXM9uuTEeUGiOp1supuLMEt5y2xhmhgJbLs0uJo7bOz5NxdSm31vWsGE5FFFVxJNHR3F2MdUWVmkyb4LnyI7rodCqyoxjQfY2JU3imrutcI6pI4OQ4jUqoScQVq0yVIVDHa+6x7ANUFAoggJKAceOIBqoPxc5PHS46ffTDgmcgB+748fw/bd9P57c/yTunri7qpltXztf0wPaljfSmE7PJ2HaFI8edKvjarFxaymeNZEzbRdVMeSaJr2Gq1jPuGvHgR5GVQBAuIW06gIzjiuCOmFFRFQTffsVnCtUYR4d617imHFrO4FpvJ9xjmvgKv7qhev4lx97BffsHYBpO/ipP/u2Fx7ajLzEcZ1xthS11S0tJ/MY6UDiOCJHcHT4qDfuRuQIQsF1EBAg9HEI0Y9jZiyOh48msBSXcGG+/lizlC4kjm3/xPFCqsgOLkVVbOTc2wUSLBzvP+4OBdxrGM/xODBwALIg4+LGRWTNLCzHwkJqASJPYVi1N3OXMktlr91I86l52LYAhyQg87zXUyCqROt6A51Q3zjuMbHEcbOc3VslAdINsc+w2d3RvOmAUnSNcQy4BuHbT4zh65dWfXEV2SYGnF5Vs2l7NpFp98KcKagIMO3mGWznl9I4NOIONE+fGAelwP996SaA9k1iJF7C/lg1b7BS+wf24x2H3oGQFGr4fDa1YTt2hXHsDgmX45eRM4smBes2ywzemdgMpuXvBs/Z2D+e8zWrB7UIAopTljiOBYrH1UJVCJyAfZF9yJrZqqYBHJ9Bkn4TLy2+hKvxq7Acd+Jk2m7iWOVHQSlpWNq7U0QIeQOADwH4LwDeAOAHAAwA+L+EkI5/ySmlH6aU3kMpvWd4eGsMzXZLEXmEFKFm4jiZMz2kBOPhzm3ROE70m+OVaTLqGriln2uGmZY1cAbjERUSz+GaT4lrIxmWg4VkHlNbbIwHFDYI85aLqchbePrEOKZiGlZSOvLm5jeeFhJsY7O9RtpkTG36/GVMyagm4sljbhL0mde3njpO5EyEFaFt6dZeVWXimCOci3eibpLJboFzTGk5qsJyLGiKjmQJqmI+Ne+hoHRb916XOgGA1t8InQhNdD1x1NetoemY1jbGMcNUPHLQnUe02tiLXfsmogpmBl3T5OpabxnHGxkDHHHHll5WSBGbRlWwKi2/ngJ7BzTf1PfZxRQiqojRsNw147jYkLz90+L9w0EMBCQ872Mcf+Sb1/ALf3MKjx0cxp/9xH34r//oTpxfSuFf/p9XNt2UNmu4PVqUOjiugCyUNXnrtAzLwVrGwGio/evu+6fuB0c4b/MxokTAEc7rd0MpxWJmEcf3ZDEQNPHsmXDN1LFpm1jLuQ1oGaqC8G6qmCWOV7MpWI6FnJkra7wX1+MAAAHu4/wSx0B5PwGBE3Bw4CB4wuNK/AoA4HriOhTJQd5sn8U6n5qHXnivsiAjKLmeQ7cb4wF947jnNBCQYTu06Yt63zhunxi3r9lBjpXGdDt98/SJiZq4ikybEQndVLOoigU2kekQqiJU+Oya2ZHfyBhYTes4OOpexA+OhnBwJOiV96li+86N20Zua+q4QW0Q7zzyzqru8KVi/ETd1pG38pAl95xniePXll8rO54tapnBG5KiuLwQxsEJHW87+Cb8o+P/CFElWvaYmBpDSLXLmuMNBkrYkSUcyUo+YkyNYVgbxnJmuayz7AZ9FmvihyALCtZyazizcsZjQUm8BAluk8BdhKr4fwH8HaX0FyilX6aU/hWAdwF4AsA7C8dsAAj6GMkxAFlKqVFyXMTnNWKF+3acRkJy3eZ4zODVJLfsdquJ442sAYEjCO7Aio5OiC0mSz/XeKFct1ZzPJ4jmB5QcW219STbfDwHSoHpNqAqgrKAnGnj716ZR1gR8PCBIa8h1FY2GBYSOUQ1sW5H9M1odiiIeNZs6r2xv0FEFbFvKICDI0F8vg24ikTOuiXmmn4YJZe9HweFDaeFxLHjyOC48muUKKaRyvFg+ZArG1e8+0p7CTiWawiH64xnR4Z2HGWorx2iqZiKuY1cSw3Da+nlG3FMRBTMFtLCyRaN43nPOFYR0UQMBKSeSxxvZA3ENAlco06W26ywKjSNqlhI5MBzxEODlWrPYADXfRLHZxeSODzmVmF22zjuhGlPCMG9+2J44WrROKaU4o+evYx/9/HX8MYjI/jDH7kbisjjicMj+OBTR/DpU4v4r1+8uKnXy+oWVJGvex4FZaFl3MtWtFIIqrUbVTESGMFsbBZAcaxlG6EBKYCsmXUbNKYWwHHAw8eSWElIODfnPwdcya54larUDgLERMp0qyVZgtgwXZxFKaYCKGIreLivL4k1EscVPYUkXsJIYAR5y22udyN5wzWODa6pZn7NaD41D9N2r4GKoHhr5m43xgP6xnHPaSjoLraaxVX0jeP2qVVURVZn6d7umgj1cBWdLNfptAaDUkuoik4mjoHmSukuFBohHBwtJnzffsLtOK5J9Qf+VjUWHGu6CZ4iKLh99Paa90u8e51hu62Ec3+PrM5hPjWPtexa2fGVxrGR24OszuPIlDtplAUZb9n/lrLkcEyJIaxaSOWKzfGGg8W/WWkTIr/fayo8BU3UcC1+DbqlYz41j2XrK9Dsh3Eoei+ODB6BwAleia/ES+CcQQDYNagKuOzhl0tvoJSeA5ADwCLoZ+HiKw74PLaUN3IWFSxjQsg0AK3iuB2j0bBStzleuGQRMRFVt2wcL6d0DAXlnl8YdksDAQmKyGFuo9Q4btxAbd9gYFNpMdaoaboNiWPGQvyH1xbx5LExSALnNYTaSspuMdGZBjKsxPur5xsjY4rzQvc6/+SxUTx/ZR2JLbIm67Grd5NKMUrs/zVRg0UtUP5K66iKCuOYE+KglCCT511MReKqd59u6eAIB4ETYFvuPl9Y85+LiJzoLbr76qvdmhrQYNgOllJb6w0AAC/f2MAde6JeFVCrZfaskoNhp/YNar1pHPcw35gprIjNoyri7njG+8x59g64zXFNu5jMdByK80tpHB1z10TMON5s+rZZdRrTeO++AVxfz2IxkUcia+JnP/IifuNTr+Ntt43hQz/smsZMP/XoLN595yR+9/Pn8ZkaWMl6ypqNeye1ilTcqk7ddLEKDBPTLj049aD3/2z9GJHdcS8gBkBBkbNyWEi5n+PR6SyGwiaePR2B334W4xsDLqqC41PYKLCLRb5gHFsEc8m5KlQE4xTz1H39WqiKAXWgCg/BEsAZM4O0kQYlaQAEurn1tULaSCOpJ2FQd50eVaJe1Ve3G+MBfeO458Sg+s0kLwEgnismS/ramlo1joulMd01aevhKrLblIJuhwYCMvKm05ANNR/PIaaJZQN1OxWUCxPbJiZW5wssr0MlxvHTJ5lx3P7z4tjwsZaOZYNZpSqNY8q5v0dW53Bq+VTV8QxbwRbRy2uTEHkH+8eKC4qwHMaT+58Ez7l/l5gaQ0izkcryoNRNM4+Fy98P22GOKTHvPTGx5gOA26hvIb2AqLgfQ8a/BnGCCEgBHB06iongBEROhCZqIE4UwK5KHF8DcFfpDYSQowBUAFcLN30dQBLA95UcowF4B4DPlDz0MwDeSggp5Zi8F64J/ZV2v/FuaCQkY6kWqiJvIqQUx0XXON7aAng5pXts5b7csWgiWo5QYEmmWoxjANg7GMC1tWzLix5m6LbDOGbJJN1y8PRJt/koYzZvhQc8H8975kY7dWAkiPGIgq+ca8I4zhZRFYBrHNsOxZfPL2/pPSRz5i2BaSndAOUIB4mXPKagKb7atHFMKQdQqco4djh3YzaZ5TGXnINuFe/P23kovAJCCJyCcVxrPDswcKCpngZ99bUZTfsw7F+8voG/+c7Nlp5nLa3jxnoOd0xHi8GMFtOS8/EcJIHDYGGNPDMU7DnjeD1j9DzfGHDHvqZRFYlczX4yJ6cisB2Kz7xWNOvm4jmkdQuHx9zUZlQTYTu04zzeTq/H759xQyl/9OxlvP33n8Uzry/h37z9CP7gh+6CJJRbaYQQ/Id3n8Bde6L4p3/5Ev6h5PNpRlndaoibDMgCHOoiM7uhz51ZREQVcc/e9hmVeyN7MR4a935mqAqRd9dzbMzNGBms59eRt/LgCPDIsQTWUiJev1E9D2R8YwBwrCA4Pu01vSMEEHkHhuUGpBL5cuM4Y2bAEx483NethaoQOKGqwlYTNRAQpA3X3E0XUs55Y+s263xqHgBg0iQIyl+7j6royzOO132Sl/GsgR/48DdwaSXt3dZPHLdPqshD5EnziWOjc0ylRnr7iXE4FFXlp5ltSkG3Q4NNbposJvJt50eWihkKzZQBXVxOIyDxmCiZWB0q4Co6cV4cGjxUZbDWEs/xuGv8Lt/7BE4AAfGMY4umwBGK9YyJm8nqRUHOykERlMIuK8G1pRj2j+c9ZhTTSGAEj+99HAExAImXEFZt6BaHZI6HQwmGK8rdmBFNCCnjRpXevy+6Dza1MaKNYFo7AQIejh3wHjceGsfJ0ZNQBAW2FYbAOVCl7kymuqAPAXgvIeT/JYS8mRDyQwA+Dtc0/jQAUErzAH4LwL8hhPwcIeRNAP4P3PH9v1Y8lw7gbwvP9QEAvwLgdyml5TVbO0QjhcSxnwGZyltlJtdkOxLHyTxGQn3juFSVnyvj69ZLHO8d1JAzbazUSIvX0o31LASOtCXRy67zIUXAIwfca89ISIHIk60ljpP5jlTDEELw+KFhfO3ialnCy0+ljGMAuH0qiuGQjM9tEVdxqxjHpYljwMUqqaIKAgKdO98045g67lhdaRwbdBUAkM7zuBy/XHafbune6ztWGByxvR4Elep2U7y+bi2xCgy2kXZxOYUf/eNv4V9+7BVcLlmHNhLjG98xHfMqPVo1EufiOUxGVS9pNzOkYSmpb6kJWbu1kTFrsv17SS0ljhN5jNfYCH3z0VEcHg3hPz9zHlZhTDq76IZQjowXE8dA84GszYoljoMdMo6PjocQkHj80XNXwHHAx372IXzgsf01q88Ukcf/ev99OD4Zwc/9xYv41KvNJ4+zht3QOGa/Z0rvPK7CtB184fVlvOnoCAS+PbahKqh4dO+jZbexTVrADSJJvASBE5AxXc7xjcQNAMDhyRyGIwaeOxMua0DnUAcr2eLGumOHwAkpj3kMuJxj0yZYya5gNbta9vppIw2RFyEQxjiuHWyoXK96TGbT3cxKmK7Zm2urcbwOEREvEMYRDhHFjz7YWfWN4x7TUNCdMPqhKl6bS+Kbl9fx0eeve7f1jeP2qVUeU7HzafdN2mPjYWgSj/NL5ZO3TAcbBHRag01iWhYS+Zo74O1QcUBuLnF8YDRU1Szol99xG37+yUNtf28CJ+DQYPPPe2DggO+OJCEEEi95xnHOykKTbSwkUr4mXM7KeSksjR9GVucxOehv+szGZvHEvicAFJNSS3H3+jRQUcZXypIcCY74Pl9UieL20dsxHZkGJ7iGjuP4l0sZZgAhzW0ssUv0+wB+DsCTAD4B4HfgoiveRCktjdv8FoDfBPCLAD4JIAzgSUqp5xRRSjcAvAku1uLvAfwqgN8D8Msd/y06pJGQDMNykMxVf1eThUZeTBNRBSndajpp46fVtF61+XGra6qiaRtDVdRiHAOucQzAtyN7Pd3YyGEiqvqWzbYqVlny5LFRLzHEc26C+ubG5hLHedPGesYo20hspx4/NIyUbnlGTC15uJDCvJDjCN54eARfPb+yJV7prYKqqOwPIAtugzxVUGGQa6B2EI5TNJcppYjn42XJYfd2tjFaURlmuwvZvAFcjxfn814T2sLr21YEqqL7jmdRJYqx4Njmf8m++mqgYgVGDomsiZ/8029DETmIPIc/eu5Kg0cX9fKNOHiO4MRkBJLAQRa4po1Lpvl4rqxBGyuZv7oJVn6ntJE1qua4vaiQIiJr2A03ICmlWEjka45nHEfwz588iMsrGXziZdfcOrvgZhBYFSbDJTXbdH6zYhsRwQ41JhR4Du9/ZAbvvWcan/qnj+KO6WjDx4QVEX/2/vtw154o/n8ffRGfeHmu4WOA1ozjbjTIe+HKOhI5E2+9rT3jDUc4vPXAW30rYtnYF1EiIISUmbHP3XgOV+NXQQjwxhNxxNMC/s9zQx4OYi23VtbszrHdxHHKSHm3SwKFaRE41MGN5A3vWMM2kLfyEDkRAtEg8k7ddaQfXjEgBbxmfknD3ShoV+KYUgKLrEMkYe9ziyrRKmRGN9Q3jntMMa126nI+4S7OPn1qwTN3EjkTEs9BEft/ynYooopNNw3IbqNJSwjBWETBQqI8GcV233di4rhe2r5UC4kcxn06/LZLIa+UrjnG8aGR6sHvkYNDeOcdk21/bwBwfOR408dyhMM9E/f43ldqHGeMDBTJRjxbPQmxHAuGbXjGsULc0qJ6HGFWfhQqsBmXNty/7WCwPMlVukAfDYzWfD5Wjsvx7gSC2tXGMSEEubyymzAVoK7+O6X0JKU0QCmdpJS+l1J62ee436SUTlFKVUrpo5TSl3ye7wyl9I2FY8Yppb9EKd2xH9hIIXlayWCklJY1xwOAyahrVm42dWzZblfp4X7iuEwTERWraQN50z2NGD6rXvJq3yBb9LdWanxjPes1sNuqpmKuAf2eu6aqbt9s4ngxwfj7namIeejAEHiONMRVsHlhaXPWu/ZGkcpbLZv1TJTSW9c4LrD4NUlDzlkCBYVjFjdkM2YGlzYu4bWV13Bp/RJSursBSwvmcmXiOGe7pbPL6RR0u3gfG4/Z6zlWBEHFfz56cODgVn7FvuqIEHKAEPKHhJBXCSE2IeTLPsdcJYTQin9VNemEkGOEkC8QQrKEkHlCyK/5NLLtSSkij5GQjGtrGfyTj76IuXgOH/rhu/G9d03ib75zE6vp5ipGXr4Rx+HRkNcwNKQITQUzSjUfz5c1xJ4pGMeNcBV//o2reO7Cat1j2iFK6c5hHKvNNQBfyxgwLKduUOctx8ZwbDyM3//iBZi2g7NLKewZ0Dxjk40Xza6rN6t0hxPHAPAv3nIYv/2ekx6nuxmFFBH/68fvw30zA/jnf/UyPne6MbYia1gNkRtecr/FDZjN6LOnF6GIHB47WF0Vuhk9uufRmpuebJ3pNcgTA8hbediODdux8YUrX8DrK69jZkzHO+5fw801GX/93DB0k5RhKqgjgDoqOD4NSqmHqxAFx0spsyZ6ABDPx2E6JkROBIFaN20M1DCOC0zmrJkFOHeelTe35s1t5DbcBoGOAossQ+I1zzjeDkwF0DeOe06SwCGkCFj3SV2yRcl8Io+XCokTVjpYmXjsa3PaTOK4UzD+RpqIqF7DCCb2njo5eHZKg4FC2r4OqiJv2tjImh1FVTRbShfPGlhJ6Tg46s8R7pSiShSToeZN6b3Rvb6mrMRL3qI1Y2bgkARsu/pzzRjuxJwNVhLcZHC9Tu9MxcRxwTiulzgOjDS8jhEuD8CGY1ezrVRBRTov7CrjuK/6Gi2YuJWc47zpwLRp2QSfpZU2axyvpg1Qij6qokKThVQa+1wTWROywNVl0E8WTNtra62ZmDc3spiObZ1vDLiJtVd++S146ED5AmA6pm3aOGbjcacqYiKqiDuno/jqhUbGsYGIVj4vPDEZBQCcmkvUeFR95UwblkNvTeO4gI4IiAE4MGCRhTLO8UZ+AwQEo4FRpIwUzq+fx5nVM7iReh0J4W+QtC95fQIAAMQ9T5ZS5X8L1oSWvb5jhWtu0DbbKLevTek2AG8HcA7A+TrH/QWAB0v+vb30TkJIDMAzACiAdwL4NQD/Am61z47Q9ICGT7wyj2cvrOI33nUc9+wbwE88MgvdcvDn37jW8PGOQ/HyjTju2BP1bgvKQkuGl1lo0FeKTPA2H+s0Wc2bNn79k6/jI99s/D63qrRuwbTpjmAcs3lRIxzfQqEnRC1UBeCmjn/+yUO4tpbF3754E+cWUzg8VmyjwTaQ411AVfAcgSz0nq0VkAX8yfvuw2BQxqeaaJaXNeyyTV8/sWR1p1EVlFJ87swSHjs47G38bEXHR47j6PDRmvd7iWPWIE8qcI4LqWNKKb5242v49vy3cWw6h3fev4qFdQl/9qUILq4WE922FYCNODjeRacw41gSKAyr+hzZyG3AciyIvAhCVUhi/TT+gDoAvmL/r7RBHse5352toioYpsKyRDgkCZFTPPbzdjTGA/rGcU9qKCj7lusvJHIIyQJEnuDTBV6OmwDZeSZhr6oV47jION6ez983caxbIAQ7MoHeDKqCLcw70bWeyWve0cA4ZpiQg6Ohusd1QreN3NbS8fdO3ltV0iLzMizHgkMdpIwU8s6Kxw4uFYP9swGcOG6TiJDaeOLvmri0JqqCJasA18iOytG6z0cIBeGzvu8zKIaRyvF1k9B97S4xluxSsjz5xHAU4ZKxcbKw+JnbZIO85UKquW8cl2vC+1wLxnGuMedR5DlMxdS6i/5K5Qwbq2mjLY3xmPw2WKdiKlbTupegbkWLSfcz6CRK6fFDw3j1ZqJu2i+erU4GHxwNQhI4nLoZ39TrsnlRK2mrnapK45j9rInuuWdwFzzOMcNUhOUwpsJTODl6EnsjeyFwAhLmAuLin+B69us4s3rG6+JOiAOet7GRLf8bMtSFLMiglMCxQ4jVaGK/HWzDW0h/TymdppR+H4DTdY5boJR+s+TfixX3/wzcRrbvppR+nlL6Ibim8c8TQsIdeu9t1VRMhe1QvO+hfXjvvXsAuI0633x0BH/+zWvIGfWvk5dXM0jlrbLS/pAiNtVDhGkxkQelwGRJpWFAFjASkusmjr9zbQOG7fgGsdqteEVD0l4Wq6r0Q3yVilU5TzQI6rzp6Ahun47ivzxzAVdWMzhaYhx3j3FsIyDxPRuiUyUeo2G5qeR1L6EqTs0lsJDI4y2bwFQMqAPYG9mLidAEhrQhzERn8ND0Q3UfwxrkecaxWG4cM728+DI+duZj+NbahxEY+SjWkiouXHwaZm4vAGA5u4w55SdBeRcL5SWOeRdVUanV7Coc6rjVrY7smzgeUIubxTzHYzJcHuCSeAkiJyJtpEF497vT6DvWSHMp1wxn+2wyL3lr8X7iuC9PAwEJaz6LgoVEHnuHNDx2cBifeW3xliod7JZaMY6ZsdjoAt8pTUTcxlClnKqMYSMgCT07eNaTJvGQBa7uJI8Z5Z1EVcgCD0ngGrJQLyy7O5kHfVAVndbeyN6Wjh8LjuFNs28CzxXPVdaEwLANrGRW4JAkqE+SN22kERADnvFM7Qg4QhFQGjeg4zkgoDhI5dxJTj3GMVCbc1wqjs/4oipkMgRKSVOGdl+7Q6MMVVGROGaT81CJyTUUlCHyZNOJ4+WCOT3SwU2rnShmyLPP1c+09NOeAa2lxPG1dXfh0E7j2E+sIdRmOMfzLKHVwYqYxw655aL1yq8TORPRir+ByHM4Nh7Gqzc3lzi+lfpp1EJVqILbIM/gT3uJ46yZhWEbXqdzjnAY0oZwePAwjga/H9O5v8LByIMAipuwAEBIDpZd/lnm7TwEToDACXDsEAAeMZ/pBQHxSnn7ar8ope3qrvsUgM9WNJ/9S7hm8uNteo2O6nvunMSPPLAX//bp8pTgBx7bj/WMgY+9WN1MuVSMx35niXEclIWWmuOxsWWiIvk6MxSoaxx/45JrGq01wN+1Q2zdshMYxwzh1ci8Xy7Mq0bD9TfLCXFTx/OJPGyH4vBY8drULeM4lbfK5nu9qIgqItlE0j5r2NCaRVV0OHH8udNL4DmCNx1pvDar1P6B/Xjq4FP47sPfjfccew/eeuCtDZm8pagKQggEToDMy8ga1fOxeD4OwzYgB84hPPZROHYQiYX3Iz7/49jIr4OSPHKOe31iDfIkwfE1jpcyLuZC5ERQKkESyoeAgBioaoh3z8Q9VV5LUAoiY2ZAiA0QHUupVN3ft54c6mAx7aJN9EKQQRb4Iqqinzjui2kgINVEVYxHVLz9xDjm4jm8fCPeN47brJYSx7q9raUxYxEVlKKsM31Gt7bNyN6qCCEYDEh1URWLic4vzAEg1EQp3YWlNAIS7xkn3RTP8d4A26z2Rvbibfvf5hnGpcYxAHB8FpQqoE5xwuJQBxkzU9bEwDSDCKrNN6Bj6IiAxFeVr1cu0Otxjpk4LuuLqhAwXPZ6fe1+KSKPiCp61wUmNjkvbY7HcQTjEXXzxnHhOttPHJdrLKKAI8BcAe8Qzxl1G+Mx7RsM4OpaxrcZp5+urLgGwexQjQhmm+Q1hNoErmIxkUdUE9tS0llLJyYjGAhI+Or52riKeNY/9X1yKoLT88lNNchLZG8d45gjHESu+HsyVAVr1mNw5z3jeCO/AQCecVwq6ijgEEBAUqEKqss+ZPeRrMdAZspb+RK+sWu++CGhQnJoW5ri9FWlnyCEGISQBCHkY4SQyh39IwDOlt5AKb0OIFu4r+f1xOER/Pq7jkPky8+3e/fFcPt0FH/87GXYNa4nlFJ8+dwyQrKA/cPFOWRQEVpqjuclX32M43qc/G9cLqQNu5A4Xs+6r7EjGMcFg7VROGYlbYCQ5szwxw4O4e69rpFViqrQJB4iTzreHC+jWz3fFD6sNOcvZA0LWgNURcAzjju73vns6UXct2+ga+c1SxzzHI+g6F4zAlIAGbP+XFHSLmJg+j8jMPhpGCaQpy7iIWO7xutGbgOUUog1UBWrWXcjXuRFOLZYlTge1AarNmsH1AEciB0ouy0gBmDYBgzbAMflsJbZXIUje09sfc7+q8kCFEEBRzjfOUc31J959KAGA5Jvuf58PIfxiII3HxuFyBN86tWFvnHcZrk7gmZTC6uM4Zq025XuZanbUlxFxrC3DZ3RDg0EpbrN8TrNkGQKKo0TEeeXUjgwGtq2vz8rV2lF46FxPHXwKSiC4mMcuxNwxymaslkzCwpa5BvzErJ5qSm+MVO4kAAeCFZPPNiCnGkk0HhXm/AZOI5PczzHXcj3URW3lsbCSnXi2ENVlI+NE1Fl08Yx26AbCvaN41KJPIfRsIKbpYnjJsp19w5qSOWtpheUVwpYi30dN45Z4rj182QhkesoRglwN0AePTiEr15YqTlPceeF1dfb45MRpHXL+yxbEduMuVXmm6WbmqXjlCZq0Ml12Ga0iKmQwl4D11J5zfGIDk3U3PG0sPglXB7UKT9XdEsv4Ru7pbp+4xkr4+1rW/UJAP8YwJsA/Cu4jONnCSGlf5wYgLjPYzcK95WJEPIBQsi3CSHfXlmpzzHfbhFC8IFHZ3F1LYvPn1mqup9Siv/4mbP45KsL+IH7psFxxXlyqFXjuFDJUYlM2DcUwFrG8DXjMrqFV27EIfEcNrImLLtdIXJ/bRTW7LEdwDhuFlWxmtYxoEkQ+MZWESEEv/7O43jfQ/vKNncJIS0FsjarTBMN5bZbYUVsiKpwHIqc2ThxzP6GrSBfWtXllTQuLKfx1tsaB3rapdJxt7RBnumYMJ36vyvhLKiR50GG/hMAgEcAGctFVFiOhYSeKDCOy9fstmN7GCmRE2HZQrVxrFYbxwBw98TdZZW8HpPZyIDweeQNDhu5jYa/t2EbWM4sl93G+Mbu/XkQKiNa2PQprQLutvrGcQ9qMOgmjksXBRndQjJvYTyiIqKKeLSAq2i2LLSv5hRWRVCKpjr+ZnV72xrjAUXztLRBXnYHJ44Bt0FefcZxDjFNrNt4qR1qpnnHheX0tmAqmBj7qVUNa8N4cvbJKuOYFIzjUgxEynDLbJhxHFEiSOV4hLTmJ/2hwsLXz3CrTBxH5EiVmVypWqgKaruDej9xfGtpJCzXRFVU8lgnoqq3CG1Vy6k8YpoIqQebr2y3JqPFJLcfJsFPzTQ3KtWVlQyGQ3LHG7+OhFykyWZQFQuJfMc3NQHgsYPDWE0bOLOQ9L0/njV854Unp1xP69QmcBW3EqoCKB+bFL6ErSoGQGFAd1LIGiZ0W0dUjfo+B6XuGEs41zi2HMtb/BJOLzOObceG6Zje+GcXjGO/sbbPN95+UUr/GaX0o5TSZymlHwbwVgATAH58C8/5YUrpPZTSe4aHhxs/YJv11ttGMT2g4nf+4Sy+dnHV2xShlOLXPnkGH/7qZfzog3vxi0+VYy5CLaIq5uI5DASkqkqOmYJB6Zc6fuHqOiyH4vHD7ue40eHEK3v+HdEcT20ycZzSW9ooPzYRxq98921lmwQAq+TtbOo7rVs93xQ+ookNP/O8ZYPSxghMWeAQUgSvgWEnxDaEntwE33izKq2kZYlaj3NsNDdXTOgbkHgJQwEXG+EUyEMr2RWIggPTLj8/k3oSpu3+XVRRhWnzVc3xBtQBX+M4KAVxdKh4fdNEDQSk0CAvB8dRcXHjYsP3fGrpFP7u3N/hMxc/4xnIZcaxk4VARxBW3TnDZoJj7VJ/BdSDGgjIsB1adoGpTFo+XcBVpPLWLTOR74bYZ9kMwD5jWNC2sTRmPOxeYEsHjp2w61pPjVAVC/E8xjqMqQAKiYg6E9t41sBKSseh0W00jrcwcMTUGAghEDmxOnFcgoFIG2koguKlqcJSBKmc0FLimBm5gz6lTpXGMSGkYeqY47OgjgpKy797hhGEwDlQpc4mS/rqLY2FFSxWJY4LqIqKxrGTURWLyfym0kfLKR0joT7f2E8TUbWl5ngAsG/Ivc40yzm+upbxjIJOiuMIJqPqphLHi4l83Q707dKjh4YAAF/xwVWYtoOMYfv+DQ4MB6GIHE7Nbd44rvxO7VbVSxwDboO8jZx77tZq6kodGSA6CKHe4xiugnB5OCWoCt12KxqYSe1YEfCcCUWsTpVvV4lqX7VFKX0NwDkAd5XcvAHAz+WPFe7b0RJ4Dr/xrhPIGBZ+6I+ex/f+96/jS+eW8e8/cRp/8rWreP/DM/hVHyORVfQ1iylaiOcw4dPXxDOOfTYfv3FpDSJP8JZjblqy07iKjYwBniNeErSXxQzWRrzd1bSO4TagubqROE7nrW0NcjWjsCIgbzrQrdrrp6xRRPvVEyEEs8NBXF5N1z1uK/rs6UWcmIx0FcdYOu6yZnSqqHpmbCPZjo2knkRUjiIkucgU1ltgKb0ESaCwbA6lxVrxfNwzjiNyBKZFmkJVMN0xdocXxOIIB03U3AZ5XA7UVnF543Ld95wxMzi1fAoAMJec8wxkxl12qIMcnYeIMQRl95q32eBYO9Q3jntQzGApTV4uVhjHDFcBAJEdsMO5U9QKyD9r2Nu6wxlWBWgSX544NuyGA04vqxbfm2khkcdEFxJdQVmsW0p3YdkdiA6Ohmoe02ltZeCQeAk8x0PiJW/BynHugtYppHkppcgYGY8zBQABYQS2Q1pK9TKT2Y+TVmkcA405x8TH4CaEQDdUhLTm2ct97Q6NRRSspPQyzmKtxPGeAQ22Q/HKJhKXyykdIw2axNyqmoypWEzkkTdtZA27qc1shoS4sd6ccXxlNYOZwe5MlqcHtJaN47xpYy1jYLwLzRNHQgpumwj7Gsds7uJnHAuFBnlbSRz3egOidqnMOOblsts58DC4i4jrqwhKQYi8/2fiODIIV2ATFoxjtvjlKlAVecudxzGT2rHCUBX/NFkfVdGzooV/TGdRwTImhEwD0FDBPt6pevzQML7yr96AX3/XcSwldfz4n7yAP//mNfz047P4pe866otyCyki7EJJfjOaj+d9+5rsGdBACHB5xcc4vryGO6aj3jjj13DeT//sL1/Cf/vihaZNbab1rIGYJlaZ5L0oniMIyUJDzMFqWseQD2KuVUU1qSuM42CPm/Ze0rsOIiRbYBarTZjgs0MBr/dDu7WcyuOlG3Fv46VbYoxjABjQXOOYmbHNGMdJIwkKiqgS9SplmXG8mF6EWDCESxvkxfNx6LYOiZcQEIMwLK6sOR7jCauiWtb7gEkRFJwcPen9HJSCLpaKS4E6KlJ6CkvpapwP04vzL8Jyys+JueQcbMc9F9Zz67CRRpg+4q3HS/sOdVt947gHNVi4UJcmLxnHlg2eDFfB/r+v9qgV4zi9zVgIQgjGIko541i3GrKRelmDQRk500bW8B9YFxI5jHXBOA4pQt1uteeXXITDtqIqtliqogoqJF6qiarIWTnY1C4boARaaEDXAkc4VGAcD/qUvAmcAJ6Uf4caJ47Z+ywax0ExiFRO6GMqbkGNhBU41F3kMCXzJiSeq0LaPHViHFFNxB98qXHpWKVWkvm2pG92oyajKkyb4sKSO0FvZjNbEXmEFKEumogpmTexmjYwM9wd43gqpuJmk4Y2E8OldCNxDACPHBjCi9c2qtLz8QZN7E5ORfHafKJmQ6taSuZMhBQB/A4wRtqhWoljt0FeAFn+a9CdBGJK7c7m1JHBcYWNWcKVNcgjnA5qF19Dt/Sy13XsCDTF/7vRR1X0ngghx+GaxN8pufkzAN5KCClNGLwXQA7AV7r49joqReTxIw/sxZf+5RP4nfecxG+86zg++LYjNft/sMBNIxwc03w855t6VEQeExG1CtmTyJl4bS6BB/cPFdfTTYwza2kdn3h5Hv/pc+fxW58525J5HM8aiO6gEFdYFesamJRSrKaMtvR06ErieCegKppAhGRN92/STABsdiiA+US+5np5K3r2/CooBd5wpHHfmXaqLHGsDHjXkMoeAbWUyCfAEx5BKeg1kWfGcTwfByHuOGv4GMcyL0MVogBQljiOKlGPJxyS/cNitw3f5r13F2dFYZKrcBz3unVp45Lv49Zz6zi/fr7m70MpxWJ6ERKdRoCb8db9fVRFX2ViybzSJmEsVToaKV7E335iHACa4gn21ZxYUx+/Qe7ff+I13PFrn/P+fefaxraXxkxE1LLEcUbf2YljL23vg6vImzY2smZVZ+VOKCgLiGfNmoPUucUUAhLf1RKeSm21VEUVVci8DMM2QCkF4fIALK/xHBtsS41jrwFdK6gKrTaqAqhOHQ9rw3UbDnIcSxwXB/CQHHLZyz7viyc8xkPjTb/fvnaWWDOyxZLrYCpv+ZbUB2UBP/nIDL5wdhmvtVCuTynFSrqPqqgldh08Pe9+ps3OSRpVmDAxhuW+LiWOp2Ia1jJGSwsyxs7uBuMYAPYOBmA5FMup8iRdIxbx8ckIsoaNyyutlbgmb7FGzJWJ49IxSZMU2MRtulMPG0EdGYQr/n1KF7/ueCuAOu51Km/nIXKit0C1rbDXWLZUHOG8Ety+OiNCiEYIeQ8h5D0AJgEMs58L9z1NCPkoIeSHCCFvIIT8LIDPArgO4H+VPNWHAOgA/pYQ8mZCyAcA/AqA36WU+gPKd7AkgcP33zONH35gb905nNfYqwnOcTJvIqVbvqgKAPiuk+P4/JklvHIj7t32rSvrcCjw4OxgyXq68Tjz+oIbCLl3Xwx/+NXL+LVPnmnaPF7PGDuCb8wUUoS6BmbGsJEzbQy1C1XRwcSxWx1pI7CN6MhmxCrg6pnoGS9x3IRxPOyuza74ML63qucurmIoKOHYuD+eoVMSOMFDI/Ic72GgwnIYDnWwnF2u+VhKKRJ6AhE54l1/QlIIaSPtcY6zlksIMq2i/RnX49AtHbIgQ+Lc37c0cTyoDnr/XwtXIfIiJkITAIpr5hy5ClAR1BFwZeOKlyAu1bfmvlX3GsNM7bDxjyAqN73n7qMq+irTYMC9UJfukC4k8hgKSpCF4sXku06O44NPHcHDB4a6/h53q+oljr94dhlDQRnvvH0C77x9Aj98/x789OP7u/0WyzQWUcoMk4xhQetxzlM91Zvksd+z013rAeDEZASpvOXLgqSU4guvL+O+mYG6k+NOq12JYwAwHROEuPxghqpIG2mInOgdQwiBZboL1pDPgraWIpqNf/P2/fjuOyZ8769shifyose28hMvLwGwYOSK372gGEY6x1d1oCcgeNPsmzAW7F5zh766K3Y9KG2Ql8yZVZgKph99aB/CioDf/8KFpl8jnjVh2rSfOK6hyZhrHLPkVzOMY8C93m9kGy/o2cJotouJYwCYawFX8eJ1d0GyZ0BrcGR7xIwU1pSQiTUhqpV+8xrktbBxcm0tg6+cX9nWjdJuq9Q4JoR44yBQXLTJ2Ft2e6Uolb2EE4CyBnmucVzgIMNNHLPXpJQHtUOIBqpZ7GE5vK3zjltEIwD+T+HfAwCOlfw8AuBG4b//GcDnAPwygM8DeKTUEKaUbgB4EwAewN8D+FUAv1c4/paVZxw3kThm17dagZF/8sYDGArK+JW/P+01lP/GpTVIAoc790QR0yQQ0hyq4vXC+PWhH74b7394Bn/ytav49584XdaovpY2MiZigZ2zsRZWxLqoitXChuRwmxLHKd1qucqlWeVNB7ZDe76/Dwsz1OuhlGOM4yZ+FzYf8kO1bEWOQ/HshVU8fGBoW9ArpQ3y2FowIkcQkSOYS84hZ/rPyzJmBpZjlVXkBKUgKKhX6ZM23Q1fljimlGItuwab2pB5GTLnrnGlkt4CpevRWsYxAM84Fnl33Zx3bgIAHEdFzsrhr0//NU4tnfJ4ynPJOdxM3qz5fJRSLGYWIZIINOdhKMGXvblHP3HcV5kGfFKXfiX6isjjZx7f39TOVF/NqZZx7DgUS8k8njw2il9953Hv330ztQ2ubmg8omA55TZ7opRuO3d5qyqWlVVP8uY9XEvnjeO33DYKgSP41KsLVfe9cjOBuXgOT5/0N0K7pXYkjtmitxRXQW0NlFKkjTSCUrBs5zaTF8ERioDSfHMxkRfwU48erpnWbJVzzHE6JO0ijPQxUEowqA5iT+g2OJRUGdqP7HkEs7HZpt9rXztPrAqnzDjOWwjVSEeGFRHvf2QGnzuzhDPzzYW+WKpzpG8c+4ot6tnnGVWbS14NaPWboTJdWc2AkO6Zssw4bpZzrFs2/tfXr+LRg0OY7ppx7L7H+ZKNY6CIqqiV+t4/HIQq8ni1Sc7xesbA+/7kBdiU4j+8+8QW3vHOUuW4VMo5dsdegoD9UN3n8EscA26DPGYcOwXOcd7Kl/GNASAWqF609/nGnRel9CqllNT4d5VS+iql9E2U0mFKqUgpHaOUvo9SOu/zXGcopW+klKqU0nFK6S9RSm9pplZQdq9NzaAqGhnHIUXEL7ztMF66HsfHX54DAHz90iru2RuDIvLgOYKYJjWFqjizkMRoWMZgUMYvfddR/PRjs/jzb17DR56/1vCx61nDt49HryqkCHVRFQz91a7EMdBc0/nNKF1Irod6fO1bRFXU/twzhSonVWzs67AKrHYnjs8uprCa1j0carflxzkmhGBvZC94jseV+BUvQVyqeD4OAlI2RlZyjpOGm1hmjOOMmfFMZZmXITLjuDRxrDVOHANF4xhw8YkZZx4UNmgBV5ExM3h+7nn85em/xIsLL+Jb89+q+zmkjBSyZhYR650Q5Tnw0ppnGPcZx32VSRI4hBShLHW5mPBvDtBXe6WKPESeVIH8VzM6TJt2rQy1WY1HVDjUNTZ0y9111Xq8XKeevLS9j5ngNYjsQuopqkl4+MAQPnVqoaqM5NOnFiDyBE92uWlApWRBruIDtyJN0KqMY5Y4NmwDpmOWDU4RJYJUjkdQba0BXUyJ1U1IlS7ImabD03WfUwqchmNHcTz2NN515F2QiPu3KEVV3D1+N24bua35N9rXjtRgQAbPESxWJY5rLyJ+/KEZhGQB/+1LzaWOl1Puc/eNY38FZQERVfQSW80iDZpNHF9dzWAiolYxqzsl1lDp5kZznONPvDSPlZSOn36sexVIbC5SmThuxDjmOYLbJsJNJY7zpo2f/NMXMBfP4Y9+9B7sH96+xUq3VWUcl1TGyIKMfcKPImi8B5TWHttqGccZM+Oxj6mjwHIs2NSGwhf4xgXjeDBYvUTr84372unyGMd1+ogwzRUQQPWqHb73rincPh3Fb33mLG6sZ3F2MYUHZ4tmT7NIpNcXkl5pPiEEH3zqCMYjCl4uwWD4iVK6MxnH9RLHzDhuS3M8dyyKd8g4zhSM455PHDeBqmglcawWcIl+2KmsYeHR3/kiPn+mdlO2Wnruott099GD21PNXjr2lmIiRF7E3she5KwcFlLVoa54Pu6xjYGCEcyLUAQFKcPF0KTMVQCAUUBVxPNxr7+ALMgQ4BqzYgnjuBlUBbuPYaSiShQ21aFzp0Ht8muXbul4ceFFrGXX6n4Oi+lFCESGZrwLcugVSLwEiZdAQLy5xHaobxz3qAYDUhWqotdMy90oQogvyL+bmIRWxM6JhUQOWTbg7GRURbA2qmKhy3+Dp0+M4+ZGrmyBTSnFp15dwCMHhnqC97iVchW/xDHHZeDYAV++cVSOIpnlW+IbA6iLnQD8E8fTkemywbpSt0054DmKbMptwJLMuhMFhqrYH9uPeyfvbel99rUzxXMEIyEZi4ny5njhOt/PiCbifQ/vw6dPLeLcYqrhaywnC4njHrv+95ImoyoyhTEo0gKqYi1jNORIXlnNYGaoe6V5w0EZksA1lTh2HIoPP3sZx8bDePhA7WtWuxVSRIQUAQtVqAp37lLv/D8xFcGZ+WRVY71S2Q7F//OXL+OlG3H8l/fegXv2bW91VbdVOS5V/hyQZRDIZaz9SlFHKjOOSxvkEb6IqmDd4r3EcQEXpflU9tRjKvfV104QQ1XUS14yzcdzEHlSF5nAcQS/8o5jWE7p+MCfu70JHyq5Fg8GGle26JaNi8tpHC1huhJCMBlVGyKL0roF06Y7inEcVoS6qJCVNqMqgOaazm9G6Z1iHDeRvGaJY63JSvLZ4QAu+ySOX7mRwI31XEu9PJievbCKQ6NBjG7TfNcPVcEUVaIYUoewmFn0zGCHOkgbaei27o2PmqjhyNARAO46Nm2kQSkFLaCjTNvd8GUMYcA1mjm4hqxcMI5lXi5bZ9czjoFi6jgsh0HAIct/zasqakVZM4uUkUKUPAxCCOTAa977UEXV64WwHeobxz2qwaDsMZmyhoVEzqxCVfTVGbndZssv7KzxTTcas7Wi8SgzjvPermuzA04vKiDxkAXOt6xsIZFDTBO7hmbxcBWnijubvYKpYNoKrkIRFPAcD57w3sDJUBVpM+0tcplY4jiktdbBdzPGMQDcPna77+2aqOGRfXdjZjSPczdVUAqkcu45wRLHe6N7W3qPfe1sjYYVLxUMAMmcVTdxDADvf3gGAYnHf/vSxYbP30dVNBYbGznSfMnoQECCYTnepqefKKVdN445jmAqqjZlHH/p3DIuLqfxgcdmu86enYioXiKPKVFI2/N12IQnpyLImTYu1WEjfugrl/APpxfx754+hqdO3HrNReuhKgCAE1ymtW36j2+UVieOgWKDPBD33HJsGYvpRYic6C1KHcddvGpS9feij6roa6eLGcfNoirGIkpD1uqde2L43rum8PpCEprE4+RU1LtvMCj54u9KdWEpDcuhODZRbgxNxlTMxeuPAxsZd70Y21GoCpdxXGvTdiVtgBC0Bb/hJY6bqC7ajJhx3OuYRkXkIQlc3aQ3Sxw3bRwPBXB5JVP1d2Qp+VbN+rxp4/kr69uGqQDKx15N1MrWoQAwFZ6CxEu4uH4Rryy9gpcWX8K5tXMAihurBwcPYjjg/g4hKQSHOshZORDinoOMccwSxwInQBVVUMc93xmqonL96hrCta9FzDjmOR5haRBZ/utw7Na8O9M2cT1xHRzhoeV+BJJ2DhyfR1Dc/sZ4QN847lmVltawpOVEH1XRFfknjt2JQ6+Z9+Nh95xYTOS9ncpe33WtJ0JIzXTAYiKPsS5+Bxiu4tMluIpewVQwbSVxzEpdJF4qR1VQGWm9nG8MABE5ilROKMNBNKOYGqt7fy3jeCY645uuumv8Loi8iCNTWSRzAubXJaSyPATOgSq5g30/lXVraTQslzUJTeVrN8djigUk/NADe/HJV+cbTq6XU3loEr+jr62dFuMCR1Sx6YYqsSY63q9nDCTzFvZ10TgGXMPgRhOoig9/9TImIgqePtl9c3UiqmAhUYmqMBomvk9MuubjqzfjNY95/so6jo2H8ROPzGz5fe5ElXIWgeomrrzoNtlxzBrjGxUACL7GseVYsOBiXdLWOtJGGmPBMS9FRG13bFbl6sRxH1XR105XwENVNDaOF+J5b53TSL/wtsMIygLumxmAyBftjYFAY8Yxa+x6bLzCOI6qWEzk6zZ2Wy8YogM7qTmeKsCh8KqEKrWa1jGgSRD4rdtEnU4cZ3aIcQy4uIq6iWOdGcfN/S4zQwGkdctLiDO9fMPd2GwGBVaqb11Zh2E524apAKrH3krzlud47I/tR0SOICpHMR4cx97IXhwZPOKiHAjB4cHDGNLc34FVzqaMFAjnfh5mKarC1t1ksRjwDGXWHK+Ubwy4VUP11t3joeI8MKbGYJMNZMzmU9/ruXWcXjmNrJnFuHwfiDMMJfQygOJ6fzsb4wF947hnVYqqWCgkSnrNtNyt8jOOFxJ5SDyHwR7bUQ6rAlSRx3w8XzLg7NzEMeDiKtb9muPFu49refrEOG6su7iKXsNUAFvbeWS7uDIvlxjHGeS4byBv5xGVo2XHS2QAtkPajqqoXJAzEUJw+2h56nhQHcThwcMAgAMTOfAcxdmbmmtoa0X2cj+VdWtpLKx4jOO8aUO3nLql+kxHx0OgtL5xCbhlm/20cX0xBmUrnEdW2lvv87+65qZiZ7tsHE/FtIaJ41duxPH8lXW8/5GZMqOiWxqPqlWM40TObNiccGYoiIDE1y1jXUvrt/SckyOch3IC4PGHvfuFJAAbtuVvHFPqXi9YwomJbdjm7DVQUCwbL0LkRG+RCwCOrYHnDVSeUgInbGtTnL76aodEnoMq8kjVSV4ybWQNr2l2I42EFfz1Tz+I3/ye8iaegwEZ8axZF83z+kISqshj72D5ODMZU2E5tKyiye89Aq2NfdutkFIfm7Ca0jHUBkwFUEQ03OqoCsBds9drSpg1LcgCV7diqFSzhb4DlbgKljjeyLb2mT93cRUSz+H+me5htypVGSbyW0NqoobZ2Cz2RvdiIjSBIW3IM1THg+MIy2EEpSAUQfHYwGkj7Y3HbM8qkU94xrEmadALhrJYI3EM1MdVaKKGmOLOCSKyBlARSftqw9/Zcixc3riMK/ErUAQFx4aPQdPfDcKnIKqXABQN8O2eA3RspksIOUAI+UNCyKuEEJsQ8mWfYwgh5N8QQm4QQnKEkK8SQu7o1HvaSRoMuoljx6FeoqSfOO6OahnHYxGl66WojUQIwXhUwWIyh6yxc3Zd62kwIPumAxaT3TeOS3EVDFPx9h4q293KAMJ2dVnimFIKh4tjXfwfUPhQ2UJWFmSYpjsoh7TmjWOJlxq+x1qJYwDYP7AfIbnIkLx/6n7vO6iI1MNVJLO8l4RWBKWmGd3X7tRoREEqbyFrWB63rxGqwj2muW7fyykdI6Fb10RrRgxV0Yxhz1SPac90uYBT6HbieCqmYj1jeGkmP334q5cRUgT8wH17uvjOipqMqtjIml55K+A2IIo2SBy7DfIieOVmPePY6LmN8m6rdGyqHFMIccAJiZqJY1bySrhyw8kzjq0k8ty3kXMWMR4cL2MWUkeDLFafd434in31tVMUVISmEsfNXM9KdWwiXNVIjxnP9Uy0M/NJHBkPVRl2bFyrxzneKIxfO4txXJj71DDvV9I6htu0We4ljls0MZsVC03thLVvpEFTwqxutxT+mh1250WXS7BTC4kclgp9ORItJo6/en4F9+yLdQ0J6adKNMWA1lp/BRYuAoqJYY9zDBOAg0Quj7yVR8bMwLANyIKMoBiEYRYSxwXGsV+vnWY5xwLPQ3VuR8q+ULePB6UU59fOI56PYyI0gcODhyGRARjZQ1CCr4IQ18RmQbHdjKq4DcDbAZwDcL7GMR8E8EsAfhvAOwCkATxDCBnr4PvaERoIyLAdimTe9EpwRyN9M6Qb8jeOcz3bnHA8olQkjnt/8KwnP1RF3rSxnjG6/jcoxVUwTMVbjvXO5WkrJSsSL4HneEi8BIc6sKmNVeNF2NwKJpR7yzZJonLU4wiHVdvbUW2kZo6rZxxzhMPJ0ZMAgD2RPd6AzOThKjYkzzjup41vPY0WTN2lpO5NypsxML1mJQ2STyspHcPh/vhbT5MFVEW0FeO4ycSxwBEPhdEtsderlTq+vpbFZ15bwA/ev2fbFqxsPJwvwVUksmZTFTGHxoK44tNUB3AXMmsZHYNtSpztVJWOTZWLWQDgxQ3YVg3GsVNIHFegKrwGeVYGcfEjEBGpKod1bA0BuXqh2R/b+totCsn1m7MB7nXIvZ5tzZAdDLjfxVqcY0opXl9IljXGY5pixnEdzjEbv3YS4zisumNWrb/BalrHUJNJ70aSBR6qyHccVRGQe7/aNqxU+wulyhp2S2v4iYgKWeBweSXt3fby9TgAYN+g1lLieDmZx9nF1LbyjYFqVEW9RumVkgUZ+6L7vJ+H1CKuwnIsGI4OQgwkc3nE83Gv2pY1wTMtApF3wPaPWk0cAyhbpwZxFywkvQa4flrMLCJn5TATncF4cByEEOjpEwB4yAVMBXBroCr+nlI6TSn9PgCnK+8khChwjeP/SCn9b5TSZwB8HwAK4J908H3tCLGkx1rGwHwij6GgBFno/YviblC0sCPolDCtFhLdT7s2q/GIy+DKGjtn8KynUr43E9s8Gd+G1D3DVfzvb15zMRUtpB86ra3uPKqC6pXjJvIJrOiXELTeApWUN5cbCgwhlXMnMyHVwnRkGnsijVN2jTAVQH3jGAAODRxCSArh/sn7q+5juApKCcKFJPRuYkASQr5MCKE1/j1YOKapyh1CyDFCyBcIIVlCyDwh5NcIITv7YlEQK6lfTOS99HAjxnHpMQ0Zx8l8H1XRQBOFRq2tpMOaSRxfWc1gekDrOgqCNVf6zGsLvvf/8XOXwXMEP/7Q9jGAWRpuoaRBXjzXnHE8HFSQyJkwrOry7WTegmnTWz5xXGoW+7H6eWEdds3Esb9xDLip46SehMFdwgB5Y3WHdCeIkFp9vvfZ/X3tFoWUxsZxzrRh2E5LY4qfWIO3dZ/eKYBrCifzVhXfGChuiNYzjuNZEzxHmqpy6hU1RlUYbUNVAO68IN4h4zjFjOMdEJoKq/UZx1nDailxzHEEM0OBMlTFyzfikHgOD+4faolx/NzFVQDYVr4xUL0mjCpR8E0uVQ7EDoDnisd6nONCY7mMkQHhDKR0w+MbA4AkSAXGMeeljUNSCCJffe1pZByPh8a94FWAHAHAI56P+x6bt/JYSC0gqkS9OQalQD51F3hpHoK07B276xPHlNLaMCFXDwEIA/jrksdkAPw9gKc69b52ithAt5Y2sJjI3dKsuW4rrIqgtDgYOQ7FUrK7jdla0XhEwXKqaJjs9MTxQFBCzrQ9IxwoNojcDvOe4Soyht1TmApg6zuPqlg0jq8nr4MnPKLmj4Ha5c87oo0gmeXBEYqA4iAiR7wkcD01YxxXdquvFM/xeOrgU76GsCJS7Bt1z42Q6p4vu2xx/Y8BPFjx7/MAVgG8UDimYeUOISQG4Bm4G7PvBPBrAP4FgF/tym/RYY2G3evCciqPZGExGmpiEccMtnrMuYxuIWPYfVRFAw0FZKgi31IX9pAsQOSJ11zIT1dWs5jpMqYCcJvOvOnICP7sG9fKUBCAW5r819++iXfeMbmtczOGL2OJY0qpyzhuwmhhZch+Kby1tHtbs2zR3arSBWxEjlQtIjlxA9QJwHGqx7ARzd18Zc14SsVwFQIdRohWb4gSGoTWb4zX1y5WM6iKeCEt2UoVi5/YdaxWg7zXF1IA4Js41iQBMU2si6pYzxqIaWLPoQzriZncfuZ9RreQM20MtXGz3K+St13K6BYCEt90U97tVEQVvDmqn7KGDa3FCqbZ4UBZ9dBLN+I4OhHGaFhGKm/VZXuX6rkLqxgMSL4bKN1UZXUPRzhE1WhTjz08dLjsZ1bNowgKOMK5yV/OQMawXePYcuc6LHFsWMTjG1dWAjE1Mo4lXvIMa4EDNHoMG/mNKlwFpRTXEtfAEQ57wsUglpnbD9sYgxp53ruNELL7GcdN6AgAG8CFittfL9x3S2vQS+LoLl+3ya6yfW1dRTPBHeRWMzpMm3qJql7TWESBQ4Gra24H+J2eOB5iZWUl6QDW3X47FukMV9FrmAqguACtVEgKNUzyAuWJY4c6mAxNgkcQjlNu1AwHhpHK8QiqbgO6iBLBVHiqoTHclHHcBI+43kB9dMo9N8K7EFVBKT1DKf0m+wfgRQD3APgYpdRqoXLnZwCoAN5NKf08pfRDcE3jnyeE7Hhw5mgBI1GWOG4KVeFO0OuhKpYL3arbxfvbreI4gv/5vnvxgcdmm34MIQQxTaqZBKOU4upqBvsGtydh8YHHZrGeMfCxF2+W3f7n37yGnGm39Lt2QqMRGYTAa5CX1i3YDm3YHA+AV4Zc2Y0dKCbAb3VURWnJLCGkqmSWF9zO9Y4ZLb+d47E/ehsAgCPVny9b+A3g7aC0+ty2LRWq5GMc76Kxra9bW0FZQLpB4tgzjreYOPYqeNP+qIoz80kQAhwZC/nePxlT6yaONzIGYjuIbwzUx3StFj6n4TZe/yOq2EHGsbUjGuMBRVRFLeZt1rCgia2t4WeHgri+noVhObBsB6duJnDndNQ7J5sx7Cml+OqFVTx8YGjbDXiRF6sSxs2sJYcDw1XHheUwZF4GIQQBMeA1yLNtDtcS12DYBggIRE5EUApCtzhIYm2+MXvORpoIurgKjs9Bsx+AYRvImtmyY1azq0gbaUyFp8o2pXOJh8DxScjBU95thwYOeUnq3YyqaKQYgDSltLLT0gYAjRBSdRUmhHyAEPJtQsi3V1ZWuvImt0tFJpOBhUS+Z03L3ahIRQdYhkkYC/fm34Clji4up0EIoLY46PSavLKyknTAl84uYyQkV3U87pZ+6buO4Q9+6O6ewlQARV5ipSZCE7hr/K6Gj9dEDQIngCMcAmIAQ9ogOD4Dxy4a0oqgICyHkczyVebs8ZHjdZ+/mcG+snt9qzo6ncVb71rHzJj7Pd3lqay3wR07P1r4udnKnacAfJZSmiy57S/hmsmPd/INd0MhRURA4rGYzJc0x2v8XVVFHgJH6pYOMmOtj6porAf3D7aMExoISDUTx0tJHTnTxszw9lz375sZwO1TEfzxs5dhF9BVedPGn379Kp44PIxDo/5GQ7ckCzyGgrKHqmBGS1OoisL5vOpjpqwWjPxbHVVRuflamUDiRdc4ruQcz8ZmveZ4h4fLsU+AO+6eGDmBMHcS1Cl/DeoIsB0BmlzdhHaXj2193UIKKWLjxHHOvQ5tlXEc1SQQUhuJdGYhgX2DgZrm40RErZ84zhg7im8MFCuy/OY+bM6zUxLHad3aEY3xANewtx2KrOHfZDxr2C2Hv2aHA7AdiuvrWZxfSiNn2rhjOuptuDTDOb64nMZqWscjB7YXU8G0Gc7x0aGjvrezcTsgBZCzcqBcGtSRkNJT0C0dsiCD4ziEpBBMi0AqJI5rrV8VQWm4ZmWcY8LloNoPAgBWsivImTkYtgHd0nEzdRMhKVT2u1n6KMzcASiR50GIe47ElBgemHoAgJuMFrjtPde30zhuWZTSD1NK76GU3jM8vL3w7k4rFnC/8Dc3ckjkzD6qoouqNI7nC4uyiWhvpr7ZuXFxOY2AJOyocik/VXIvM7qFL55dxlPHx6o6HndLB0aCePLY6La8diP57T6OBkdxfOQ4QlJ9Y0MVVBBCcGjgEPbH9oMQAsJny1AVwwH3WpvK8QhpFnjCe4mpQ4OHaiabVUGtGvxrqZl0dC3xHHDnbAYMgbrLUBWV+gEANwE8W/i52cqdIwDOlh5AKb0OIItdUuEzGlGwXNYcr/HkihCCcIMFzXLKvf6P9JvjdUR+THumy6tuw5eZbdowJITgA4/tx9W1LD5/ZhEA8LcvzmEtY2x72phpIqp6qAp2Hjezwcn4lX6JY4avaCfjcieqclxi5adMnLgOAFWc49uGb4NuuQPSg3vuxFiwulJJ4iVwXN5jITOJJAoAVYljkRNrVhj11ddOU1AWGjalbVfimOfcypZ6qIp65fkscVwrJRrPml6j150iWeAhC5wvqoJtJrarOR7AGMfN83ZbUXoHJY4jDRoyZw0baou4SYbyurySxss34gBQMI5Z4rjx5/5SoaHeXXuba3zeaVWOvY1CSEeHjuLQ4CHf+yo5xwa5BErdz0a3dRdTIQbAczwMi4NcYBzXe81Ga+vR4Ch4jgfhcuCcEYTlCNZyazizeganlk/htZXXQCnF3sjeMs8ml3gYhOhQQt8GAAicgDfOvNFLJG932hjYXuN4A0DQpzlPDECWUtqZK8wOkSzwCCkCTs+7AbGJHuXr7kaxRVcxcewuynrVvGfnxmIy3xJUv1fFUBVs8vLFs8vQLafn+MK9Ij9Q/khgBBzhcO/kvXUfy4zdgBTwBiY3cVx8zhFtxGV+5wSEVBshOeQNdAIn1Nzl9WsmVEtbMY5LFRAD274b2ykRQjQA3w3gr2lxBdNs5U4MQNznaTcK99V6zR1T5TMaUrCYdFEVAkearryIqGJd5txykiWOe/P6v9MVC0jYqLGgv7rqlvZtV+IYAN52fAx7BjR8+KuX4TgUf/TsZZyYjODB2eY7fXdSExHFQ1WwOUszTNBi4rj6s2eYqFZ41btRldU8rEM7E8fpIFwWjlW8hI4GRjGkDcEwCQgoJIHgTTNv8l3wES5flTgekF3WoVrBOO6njfvaTQoVGMe1zFigfcYx4FZPrPlc61J5E9fXszg6XtsImoyqyBp2zQ3m9azhhb12kkKK6GtgrhQ+p7ajKjrION4xieMGDZmzhstrbkWzw64hemU1g5dvbCCmidg7qCHGEseZxp/7SzfiCCkCZrehn4SfKsfeeibuTHQGD00/VPN+ZhyzMThPLoM6EiilnnHM8BOGSSAJFBzh6o65jXAVAidgPDgOjnfnZntDR3Fw4CBmo7PYE9mDidAEDg0eKkM12lYYevo45NCL4Hg3sPLg1INla+ntbowHbK9xfBYAD+BAxe1VyahbVYMBCafnEgB617TcjapMHC8k85B4rmfLNsOq4JkkO2XXtZ4qE8efPrWA4ZCMe/Y1xh7ciqpckAqc4A2yBwcO1i3x8cNccFw5qmI4MIycwcF2CMKqXcVZPD5yvLorPJrDVDA1apDXrHb54vodAAIoYio6rp1U5TMWUVzGcd5EWG2+UU1YEeqiKpZTOkSebLlBT1/+GqyDqriymoYscBjfRkwUzxH85KMzePF6HL/9D2dxeTWDDzw22zOVPRNRFfPxPCilJUZL47mKIvIIyYJ/4jitI6wIkIQdVZTYdlVuaEaUSNXGJC9ulCWOjw0fAwCPlejiw1TcM35P1fMTTgd1ZJR6Z2HR3SDXpPK9wD7fuK/dpJAigFLULNkHiqiKZpjtjVSrsuXsotsY79hEbSNoKubOk2/64CoopTuScQy4a0e/TfPVlA5C2rtxGFFF5E0HebP233uzSuv2jln7NmrInNVtqC0axxFVxFBQwuWVDF6+Ecft01EQQrzvzUad5sNML9+I447p6LbzjZkqq1UVQfE1TSdCE3hi3xN152NsDSxwAmReRp5eBaUSLMeCQx3IQolxbHEQBQdhOey7rmVqhnO8N7IXhHOvGTxCCMthxNQYhrVhjAfHq5rc5RMujkKNfAMAsD+2v6rZ362eOP46gCTcRj4AvETVOwB8ZrveVC9pIFAsrRnvG8ddU5VxHM9jLKL0zEKxUoQQ7/zYDYnjgMRDEjisZ4yewFT0uioH0yFtyBvwCCG4f6q6azuTH0qiFFVBCMGwNoxk1j2vQppdZc4GpABmY9Vl260Yx+1KHN8CmIqLlNJvl9zWbOXOBgA/5yFWuG/HazSsYDmVRyJnefy+ZhRW/VM3TMupPIaCcs9MqHebYpqEeNb07fx9ZTWLfYOBbf/s33P3FKKaiD/86mVMxVQ8dbx3mqSORxTkTDcN56EqmtzkGA7JWPFjHGeMWx5TAVSPSxzhqjZiOWEDtumOdZqoYSY2AwAwTA6yWDynRwIjVc9PuDwAHqBFg0bj3eMqE8e7fGzr6xZTUHavUX6oBKZE1oQkcFDErVsVg0HJQ/CU6kyhqvdoHVQFwxT6NchL6xYsh+7I6oywIvozjtM6BjQJAt8+iyhSMNbrbdJvVm7ieGesfb2GzD6fA6UUWdNGoEVUBeA2yHt1LoELy2ncMR0FAEQD9dPNTFnDwrnFpPe4XpDfmnA8NA6Zl7317ZA2hDfPvtlrGldLYTnsMYkDUgB5XIfjiNBt93og8zJCsltxYFhu4jim1K+Ybco4ju71ksOOXZ8a4Dgy8sm7IQdOgxcTUEUVD+95uOq4SrN5O9SxLZqCCfz2wo+TAMKEkPcUfv40pTRLCPktAL9ECNmAmzL+ebhm9n/t1PvaSSrtaD3ao43ZdqNUkYfIk7LmeL2e+B6PKri8mtnUgNNrIoRgKCBhNW14GxKp/wAAS71JREFUmIqn+5iKmqrcgRwNlLOYWVnMfGq+6rG+iWM+A0oVUMojqoQgCzJSOXdg9kscA8A9E/dgIbWAjJnxbtsO43i3prIIIRG4De5+p+Ku0sqdcyW3V1bunEUFy5gQMg1Awy6p8BkLyzBtiutrmaYa4zGFFbFux/SVlN5vjNdBDRYqTOI5s8qsvLKaxoGR7Z8oa5KAH31gL37/ixfxE4/MtHVBvVWVmhpeQq/J0u6hoFwzcTzYRr7lTpXfxuqgNoilzJL3My+uw8gcBaUER4eOeota3SKQhaL5G1EiUAQFeSvv3cZxhUWlo4DnDMiCDB7ugrSScVzZmK+vvnaygoXN3bRuAvCf/8WzJqItVA/V02BAxlpmrer21xeSiGli3ebnk+wa65M4ZhiAnZg4Dim1E8ft3jgsDWSNtNnP2EmM43qoCt1yYDu05cQx4HKO/+rbNwAAd+5xTc+QLIDnSMPE8ambCTgUPWUc+61Nn9j3hPf/tmODEFI3FcxECMGgNoiF1AICYgDruXVYNA7dKhjHgoywFAalBeNYdBpu1DZjHGuihpgmIwmAOvWN43zyblCqQI1+HQBwfPi4bwO+3Y6qGAHwfwr/HgBwrORntvX+WwB+E8AvAvgk3O7wT1JKl6qe7RYUQyMMBiQoTfIa+9q6CCFlPKb5RA4TPW4cj4ULrNodsuvaSANBCesZvY+paEKVA4lfsun+Sf/Usd/CmONd89exAxjWWGM8d1IWUi1fHERUieLdR99d1jyo0Y5tqdpmHO9eVMX3AJBRjalotnLnMwDeSggpBfm9F0AOwFc68Ya7Lba5emE53VRjPKawKtYsGwRc43i4zzfumNiCu7KM2HYobqznMDO0/cYxAPzUY7P44FNH8I/u27Pdb6VMzDheiOeRyJqQBa7p+eJwSPZ6CZRqLW1gMNDfLJF4qWphWtkgjxc2APAgdgxHhop7c4bJQRLK+a2s0SwTKRjHrEHeeHAcOcP921Uax5Wv21dfO1msKqhe4jieM9rCNwbcCl6/ypYzC0kcHQ/XNacHAhIUkfNY8qVimKWdyDgOqyJSPtVWq2kdQ6H2GuEM9RXvQOI4rVveRkSvq15zvFwB29Iq4xgAZkv6QNwxFQWAAq5CxEa2/mde2lCvV9RoTchzfFOmMRPrT8ASuzp3EbrtfnclXkJYDsO0CQACWaANe/Q0YxwDwHTU9S4qexlUSk/dBUG5CkFegMRLODrs3ztoV6MqKKVXKaWkxr+rhWMopfQ3KaVTlFKVUvoopfSlTr2nnSZW+jIe7S9au61wwTh2HIqlZB5jPd6ccKJwjmg7ZNe1kQYCMm5s5PqYiiZUlTgOjlYdMxoc9d2plHipitlICsYxtTVvoZvM8uAIRUBxaqZ6A1IA7zryLsxEZxAQA2XQ/0Zq5dh62q2JY7iYilcopa+X3kgpzcPdgP03hJCfI4S8Ce7mbGXlzocA6AD+lhDyZkLIBwD8CoDfpZQmu/ELdFqjhc29rGG3ljhW63d3X07pGAn3TbROiW2QVxrH8/EcDNvBvkHN72FdV0gR8TOP7++5TXy2qb2QyCGeNZvGVADAUFDyTxxnjH7iuKDKBWylgcuJLulnWDlathGrm25yqVQjWvmmbtE4dl9jLDiGrM5BEW1wJasztrDtq6/dopDchHGcNdvCNwaKlS2lJpphOTi7mMJtdfjGgGvATUZV38ok1th1JyaO3f4OPonjtNHWxnhASeK4gYnZqkzbgWE5CO6Qalu2YeL3uWcM9zZtM6iKQoO82aEAIiWbLVFNbPiZv3wjjj0DWlmV+3bLL9S0FbGKHVVQQSBA585Ct0yInAiOcAjLYRim6zOIQuPEcUgOgaCxLzE74K7HS/sGVcoyhmCbw5ADpwEAR4aO+KaNgd2fOO5ri2JfYpYm7at7iqgu+2k1o8O0qWfM9qoYSmMzO5W9qKGAhIvLaeiWg7f3MRV1VTqQaKJWk4G0J+KflKssCSpLHAdY4phHULUhcHxdxpLACXjrgbfikT2PtPQ7tJJOriUCsisTx4SQIQBvAvCXNQ5pWLlDKd0oPAcP4O8B/CqA3wPwy517591Vaalpq6gKw/Jv2mJYDtYzRh9V0UHFahjHV9fc69C+Huny3asaCsoQeYK5eB6JnNlSQm84JCOVt8rOfduh2MgaPdsMuNuqNI6jSrSMqegmjoFBubyJjWFxkMXyxHFlNRDhXNOeGcdu4pir4hv308Z97TYVURV1GMc5s8wE24pYBUUp5/j1hSQMy8HtTSQtJ2Oav3FcSBzvVMaxX+J4pQOoCjYutTtxnCmcPzsFVSHwHAIS74uqYIljbROVwyxxXJkajmlSQ1QFa4zXS2pXFSoTG0MJIVC5YejcOeiWi4dSBRUiL8KwXEtUEmhD45gjHI4MHcGAOlA3+Twadjel6qEqjKxbqSQFzoLneBwfOV7z2F3NOO5r62IT935jvO4roopYSxtYTLiJkHr8q15QsTne7vhKs0nYUFDGvX1MRV3JggyBE2A5li+mgmk6Mo3XV1+vul0RFaSMlPczx2Xd/6EhrxFQMssjrNoIy/VL+phYg6BmNRocBUc4OLS6QVazCsmhlkqXdooopasAaq6eKKUUrnH8mw2e5wyAN7b33fWOhkMyCAEoRcuoCsBtVlKZJmVl/CN9VEXHVCtxfHXNvQ7tG+wbx/XEcQRjEcVNHOeMlhJ6zBxYTeuYirmJmI2sAUrRU+mj7VTVxirhMKAOYCWz4v4sJADYsI0YgIR3nNtkp3w8Gw4MgxAC95JdjqpQBAUD6gByOg+tj6noa5crVNjcTTdIHJ+YbB+qAgDW08VxppUS/cmogtNziarb2bgV3YmJY1WEXtg0Z3OfjG4hZ9oYavNmeWXT+XaJJdaDO8Q4BgrBNB/DPsOM400EwPYMaLhzT7QqaBXVRMzF8zUeBSwl81hI5HvOOPZjHG9FETkCkRdh2iY0YRCr9lnYNkFUDHvVPIblrm3DilQz8Vuqx/c9DgBwqINEPoFnLj+DtVw5R53nAJ436zbHMzJHIcg3wQtJHBw4Ak30TycLnNC26tytaPetsneR+qiK7RNjHC8UjGPGEexVjUd2H+MYAN5+oo+paEYsdVzZGK9UU+EpX2O1coBmqAoFYzAtHrpJkMoJCGn+fON2SOAEj6e8We1iTEVfTUjkOS9VFGohcVyPObdcKOMf7ieOO6ZoDcbx1dUMFJHDaB8T0lATERXz8QKqosXEMeCWJjOtFf6/j6pw5Zd8YrxEACCEIqjqiGfKjQvdh3Es8RKictT7ubQ53lhwDIQQZPuJ475uATGjrx4mqp2MY3Y9W8uUG8fDIdlrfldPk1EVaxnDS4UybWQN8BxBeIcwdkvlx5lmm+XtThyzOVmiQfq1VTG8w05hHAOsr0b1eZ/dAqpC5Dn833/8MN58rHwNGNWkup/5S9fjAIA79kRbfs1Oqt2JY0KIF4TS+BhALNjUhCzICMlu6xeWOB7QWgsrcIRDTI3h0OAh3/sV0anJOLatECx9CpJ2FoQQnBw9WfN1egFTAfSN454Wa/bTzKDWV3vlGceF0qSxHk99T0RUEIKW+Ia9LJbw62MqmhPjHNdLHEu85GssV+5uEi4PEBPLSw/i9z4xhd/7xBTiGQFh1e6oOTse2trfejdiKvpqTWMRd7HTyiKOHZvwYc4x/msfVdE5SQKHkCJUGcfX1jLYNxhoqsLhVtdEVMV8PI9krlXGsXtel3KO1wrGQb85nis/1mKpkRuQAhgKEcQzxU17tzs7B1msrqApHaNLURUMJZXTOahyuTnVN4772m1ixnEtVEXetJE3nbYleVlly1pJM1BWot/MGDMZc68D84lyXMVG1kRMk3bkOMWQXqXmPTOO271Zzsz1dieOdxqqAnA/d7/PIatvPnFcSzGtfnO8l2/EIfIEx8Z7i6EvC3LbK0jZ2KuJxd9V5uVi4rjAOB4Ohqof3IQODBzw5R4HZAJC/RETpZiKmehM3V4GvdAYD+gbxz2tQ6NBfOiH78JTx/vmWbfFSknmE3lIPIeBHi9Dimgi/vTH78P33zO93W+lLXr7iTF86Ifvxv0zfUxFMwqIARCQqq7tlZqOVJ8fVYljAoRH/wq3H7iEN5yM4w0n43jjyQ3cczDVUXN2PLi161wjJlVfu1+jhQ2ncAvmWbhu4thNBPab43VWAwHJF1Wxt0ca4/W6JqIKFpN5rGcNr3t9Myomjotmymrh7zDUTxwDqJE4LjFyjw0fQyxoY6MkccxKXqUKxjGA8jGamABscFTDTHQGlLrGcSmqQuCEtvQA6KuvXhLPEQQkviaqghlr7QrDRDUJhBQrW+JZA1dWM02X6E9G3bFobqPCOM4YGAjszMDOnsL4+urNuHcb20TsxPU/ooltZxynC2ZrcAdV24ZVEUmf8z5rMuO4fSZ4VJOQM23fHh4A8PKNDRwbD/dc01+g/alj1jhe4nnwjvv/Zcax7Y7bI8HNrXMDUgAToYmq21XJgUj8n9PIHAEvriKopnH76O31n7+fOO6rkQgheNvxcUhC/8/UbUVUEZQCF5ZSGIso4HYALuGxQ8M7krPlJ00S8LbjYztyF387FJACiCrRhlwmvwZ5fokqSbuAR47quP9QCvcfSuG+Q2mEVKfjieNmutTWUh9V0ddooTKk1eZ4AHxLB4uLqL5x3EkNBMobuNgOxfW1bJ9v3KTGIypshxYSes2f+6x82zdx3D/nAfgvXmNqDDzHQ+AEHB48jGjAQt7gkTfc8YuVvMpCg8QxcSt8guJIgb9IYDnlqIoBdaA/D+prVyqoCGWYhFLFCynJdqEqeI4gpkkeqoLxje9s0jhmDdIrG+StZ4wdu+66YyqK8YiCT76y4N22UkAVDXfg+h9VpbYnjtnGw45KHKuC73wz56Eq2mfisu+P3+duOxSnbiZ6jm/M1G7O8WhgFIQQEM6A7LjNbGWhNHHsjttjoeimX+Pg4MGq2xTJKUscD2lDeGj6ITx94D2w8/txz4yEH779hzCoDdZ97l5ojAf0m+P11ZevWArt7GIK0wP91FNfva2AGPB2U+tpSBuCJmrImlnvNr/BWRVUj/tUqk4mjiVewqA2iNXs6qYe308c98WamLaSOI6o9Y3jgYAEke9v3nZSA5rk9RMAgIVEDobtYN9Q3zhuRqU4s0gLJoYs8IioYlnieC1tgCNoKbm8m+U3PnKEQ0yJYUgbgiIoiAbdBf/p6wGspQScn3PnjJWsYgCIKTFIvATDdg0awuWh8QMAssjp7nVGLUkc9zEVfe1WBWWhJqoiXthIbKXZZyMNBiSP4f7yjTgIAU5MNTenHQsr4DlSnTjOGpgd6g1Dp1VxHMHTJ8bxp9+4ikSBj7+a0kFIscdSO8UQkO2Uh6rYQY3hw4o/4zhTSE+383eJFeYDG1nDw58yXVhOIWPYPcc3Ztpq4ng0MIqlzFLZ80XkCNZMA0H7rZCUJfCEr2qONx7efKXzbGwWz157FjYtJrxVyYFtKTg5ehIHBw4iproVRKeva3AowaHJXK2nK1MfVdFXXz0sZiYsJPKY6HG+cV99BaRAXb5xqabD5bgKv8TxZHiy6jae8B3f8dwsroIjXM/sxva1fSoax81PvFmDGL/SwZWU3i/Z74IqE8fX1tyNrT6qojmVNlButbR7OCSXJ44zOgYC8o6osuqGai1eh7Qh3DZ8GwAgGnCvHZ9/OYZXrwYwMajju+9bw8GJ6gUhIaTMDBYFC4S653nOcJdkWgnjuG8c97VbFVJEpGoZx7n2Jo6BciTSyzfiODgSbLqRrsBzGAsrmI/7MI47YLJ2S991+wRMm+KzZxYBuNiiAU2C0IHN8ogmIlGHt7sZsY2H0A5qjhdR3fPedspRRrkCTkJtZ+K4MB/YyFR/7i+zxnjTvYlC8lubNquQFMI9E/dU3e6mjg2ozu2YkN4MWZC9MZ5VCg0FNsc4BtwAVGVlryI5yJs87p24zzONAeD8nIqgYmNioLmGkX1URV999bBKF19jkX5zwr56W0Ep2LxxXME59ktUzURnqm7rRvM5Pz5UM4rIkX45b1946sQY/t3TR3FopPmJnyLykAXOP3Gc1tveJKavag0E3BJiSt2F1NW1DAD0URVNarxkjtJqUngoKFUljvubJUXVMo6Pjxz3FoEjERNvOBHHux5YxT99xzze/eAaju3Jopb3XjpWB2UBeqFENqu7hkFp4nhYq9+3oK++dqpCioCUT28BAJ7B2M6G30NBGWsZHZRSvFJojNeKJqMqbpYYx7pl72jGMQDcPhXB9ICKT77q4irczfLOzHk6mjjeUagK93yp5HtndAsiT9qKJ2UYlXi22px86XocUU3Evh7doN/Kpum+6D5Mhich8+Xn8mhwFIRzPwvqiGWVtYZFIPJ0y5smlbgKRXJgOwSmXZwQmDbB5UUFBydyaHbp2k8c99VXD6t0l3si2k8c99XbCsthDKjNlddMh6fLWMKVu7oSL2EqPOX7Gp3WeGhzieNumNp99b5CioiffHS25bRkuMaCZjWtd4T111e5BgISDMtB1nATN9fWspAFzkuQ91VfYUVAsLBwbjWhNxxSKhLHhsc+7qt26qkUjUQIcP/hFI5M5SAJ1Q3xKsWMY57jEdNk6IVu7sXEsWscc4Rrelzvq6+dpqAs1GyOF88VUBVtThyvZQxcW8tiI2u2nLScjKllqIr/8swFWA7Fg7M7tyqAEIKnT0zgaxdXsZ4xsJrWMRTqzPU/orrN8Ryn8TWyWaV1C5LA7SicWLiQjq6cc2YNG2qbm9TFCpsafk0JX74R//+3d+dxkp31fe8/v1q7et9m10zPqpEEkkAaCbQhELIQBGzsgAEnxjI2S2LgAjHXmFgJ5gYD9iXEwThYzk2ujRNz2ZwLBCEHfMNyAQNCFotAEtpBSJoZZjTT3TO9PvnjnOqu7ume6e7pquf86nzfr9d5jbr61PR3Rs/UU/U7z/k9XHxOf2YX3Yz0jaz5uTv7d1KwAiP9C3+PTV2bgBlghhAqCz7XTk4XqFXO/u9ipG9kwX5D9QvBJyfnx+hDj1eZmikseVfScrTiWCTDFqw41odXybiOUgcFW9nLebVUXbDiqVKsUCrMX63f3rudYuHUNy+t2Hyuo9Sxph3kteu8nI2+Wplji1Y+hRCauvpG5tVv9a3fRvzAoTFGhjrVLmGFzIwtaUut1a7QS1Ycz69GOjyatKqQxHrv7A7zheOdfTupVYyTcyuO0x7HaeF4oGNgyblYpB30dJyux/EUpYLNXRBbD4NdFY6OT3H7Q0cAVr3ieGt/B48dO8n0zCy3P3SED33xPl52YDtX7/NbOAZ40cVbmJkN3Pq9n3JodLJp73l2DnUyMxt4IL2jaD2MTkyv6xhphbl9NU4uLhxPr/vK6XqP8COLVhyPTUxzzxPHM7sxHiSb0K5lwVK1WJ1bhLT47tm+jj46yzWsMEmYrdBbaSgcT9m6bExYLBTZPbB77uuOJQrHd/+kk2pplpGNJ095/lIKVqCznI2V4Sociyyh8cPXFrWqkDazuAdTY7uKXQOntqmA1q3qXcuq472De5uQRPKit6PEsRMLP8COTkxzcmpWrSpaYGhR4fihw2OMqE3FqmxNN8hb7WZSG3qqjE5McyJd7X14dHLu/4ckH9gaVw+th45SB73VXvYP76danp1rVXFiooAR6CgnHzTV31jaWXe1zPFlVxxP0d9ZXtfVkPUWPH939xPUykXO3bS6fTG29SeFzwcPj/PbH7uTLX01fu+F569bvlgu2NLL7uEuPnPnT5t6l9WlI8kCj3rhfj2MOSwc9y6zIfP45My69jeGpF9ytVTg6KLe0j96YpQQ4IKtzb+T9Gzs7N+56ueM9I/MLaTa3rd9wcIoSNtVWFo4XrTiuKu6Pnc47Bucb1dRn8/rdxSNTxT4wSM1zts+zkoXym/v3Z6ZleEqHIssoVYuUi6mO2yqVYW0mVP6HKe341aKlVM2z6trxYpjWH2f483dmxnqHGpSGsmD3iVWHNdXYapw3HxzK47HJ5mdDTx0eDyzffeyamt/B2ar3ySovrrs0OgEJ6dmOD4xrR7HizRj1fHewb1s6d5CtTzL5HSB2QAnJovUqrNzPQ9VOJZ21p2uOF6qdcGT41Pr2t8YmLuT4kt3H+TCc/pW3ct020DyPvmtH7+TBw6N8UcvvWjFm+tlmZnxwou28PUHDjM+OcNwk97z7B7upq9W5vYH169wPDox46q/MUBvOmaWalXRVVn/P8tAZ+WUHsf3HxoFYM+GbF+gX0u7isZic6lQOuUz7aaupM/xqa0qjN6O9Xnvs7Vn69yCrLkVx+kF4m/f1830bIHL9h1f8e+XpcVRKhyLLMHM6KuVqRQLDHbqQ5S0l8VF4PoEt1ybCmjhiuPu1a04ru9sL7JWvR2n9jiu931V4bj56nPsz0Ynefz4SSamZ7XieJV+6ZJzeMNz9q66vUd9fD9xfGJuxfeQ2rMssNQGsmfr4k0XY2ZU09VIk1PGicnCgo3xVDiWdlbv9To2eeqq46MnJuc29lovg+kFyuMT0zx9Dbfob0vv6rjj4aPcdOVOrtzTPv8+X3jxVtK9aZvWqqJQMC7Z0c/tD69n4XiK7qqvdj59ncu3qljvFceQ9Ak/smjF8f0HxygYbB/M9gX6LT1bVnXHT9GKpxSKF99F27jiuHFzvKnpAr0d6zP2zWxur6DGHsdTM8btP+pmz5YTDPcufbfFYqVCadk7gWNQ4VhkGb21Mpv7OtRnUdpOtVRd2Lw/XXG83ORUKpTorqzutr616qp0rbivVa1UY8/gniYnknbXVyufcttgvXCsHsfNN9g934fvgUNJ/8OdKhyvymU7B3nLDftX/bwNDSuOD6er7NWqYqFmrDiuX6CtlpNqzcmpAuMTKhxLftRbDCzVruLo+BT967ziuPFOirX0dq0XjncPd/E7N563XrEy4dxNPXOtO5p5x8mBnYP86InRU1bArtWYyxXHy2+O19WkwvGpK47H2D7YSbWU7aJ7wQrL3gW7lG292ygXF75u1DfKqxuqDWGFKQjVBRvOTc+U6F7lHVunUy8cN/Y4/t6DnZyYLPKMc1e+2nikb+SUdhsxqXAssowN3VW2D6q/sbSnxkJwrVw7bZuKtWxQcDZWuur4vOHzVrwpoMhyemsljp2cJoT5W2YPjWrFcav0VEuUiza34z3AzuFsr4RpF/XxffD4BIfGkjGvFccL1S+sNkP9Q+XEVCFZcVxNek33VftO+QAs0k7qRZqlNsg7Oj41tzJzvQw2XBB72o7+VT+/VinyB794Ibe88tKmrAyN7YUXJW3imvme55IdSZ/jOx4+ui6/n8cex12VEgXjlH01xidn6Gxaq4pTVxzvHvZxcX6kf+l2FYO1wVMeW6oncqVYYVvPtrmvi4UiHWUo0LGgb/DUdGFdC/f1wnG5GChYYHyiwDfu7WHzwCTbhydW/PvsG9p35pNaSJ+4RZbx3n98Ee/+xYtixxBpip7K/C06tVLttG0qWl04Xu6NQiPDeMpGtamQs9fbUWZmNjCebhAGSSGtWDAG1Kqo6cySv+cjY5M8eHiMSrGgTWlbpF5MOTQ6wc/SFcfqcbxQM1Yc11VLDYXjiSKdVW2MJ/lwuhXHT56YWvVGn2fS31nBDDb1Vtc8v/zKM3awd2PPmU906KardvKOF13A+Zub937/4u19FAu2bhvkjTosHBcKtuS+GuMT03Q2ZcVxZUGritnZwAOHRtm9oTV3kZ6tkb4RjIV3fu/q38VLL3gpF268cMHjy22mt/hu2lqlBGHhBZKJaVvX1etdlS4GOgYwS9pV/OCRTo6MlnnGucdY6T531WL1lM3sY1PhWGQZO4e72KENeqRNLVhxXKqdtodSq9pU1O3q37Xk1eRGO/p2tDyXtKf6LteNtw4ePD7BYFeFoloVtcRgVyVZcXxonO2DNf29t0i5WGCwq8LB4xMc1orjJTW1cFyuF45tQasKFY6l3dU3llu84nhqZpbRiWn613nFcbFgDHVVefr2gXX9fdtFb0eZm67a1dT2jJ2VEhds6V23wvHYxLS7VhVw6r4aIQSOn2xW4ThpVVG/o+6nx05ycmqWXU5WHFdLVTZ3b577urPcybU7r8XMuGrHVVy5/UoMY2PXRjrLS9dsdvXvWlB87qmWCWH+wlQIMDEV1v0iRGO7imMnSvR1TrN/24kVP3/3wO7M3VWbrTQiItISjUXX3mrvaftItXrFsZlxYOuB057z1I1PbVEaaXf1Xa4bV4AcGp2Y6/8qzTfYNb/iWP2NW2u4uzLX47haWt/bNdtBcwvHyYf5Y+MlZoNRS1ccn+nCqTSPme01sz8zs++Y2YyZ/c8lzjEze7uZPWJmJ8zsS2b2tCXOu8DMvmBm42b2qJm908z0Dwzo6aivOF648rJeUFvvwjHAH7/8afzO89urP7E3l44M8A+PHGV6ZvbMJ5/G7GxgbNJfj2NI26M1FI7veXyU4xPTXLB1/T9rDXSWmU7/rgAeOJjsI7F7g5/3WY13oT5757MXzMkXbbqIG/bcwL7B5Vs61Mo1NnZtnPu6p6PK7Mz868vUjDEbWPextLjP8WX7jlNYReV17+Dedc2zHlQ4FhHJocbdZIc6h5ZtUwGtX3EMyZXWodrQkt/rrfayvW/lGyaInE5fuuK4sefcwdEJ9TduoYF0xfGDh8fY6WQlTLvY0FNNehyPTjLcXV3Q90+SO3Kapf6B8uhY8oG1s5J8uFfhOKqnAC8A7gbuWeactwE3A+8FXgSMAp83s7mlcWY2AHweCMAvAO8E/gXw+01L7kh9dd/oolYV9X6sfeu8OR7AVXuH3ay0bFeXjAxwYmqGHz628g3CljI2mYyb7qq/6zB9tTLHGsb9l+89CMDV+zas+8/qT9utHRlLWlHdf2gUgD1OWlXAfAuKp2x4ypKtG3YN7OLCTRee8nijgdr8nQadFWNmpsTEVPJeZ3I6+XW9C8dbe7ZSsAKd1Rmq5Vku2jW24ud2lbvY2rN1XfOsBxWORURyaDXF4MZ+yK201KrjghW44pwrIqSRdtVbS94sHlvUqmJYK45bZqirwkOHxzg5NctOtYhqqeHuKodGJzk8NrFgAylJtKJVxZHR5DWoVp2lUqwsuLArLffpEML2EMJLge8v/qaZdZAUjt8dQviTEMLngZeSFIhf33Dq64Aa8EshhP8RQvgQSdH4LWbW2tu4Mqhnmc3xnjyRFLj6tb9AW7p0JCngnW27irGJ5CJbd9XfJqKLW1V8+d5D7NnQxbb+9b9I2Z9egKlfkLn/4BhdlSIbHS2M6O/oZ6RvhCu2r/2zX+Ods3u3nCRgfOfB5CKSzSZz/HrfbVUultnYtZHnXPgkL7/mCSqlcOYnpfYM7snkRXwVjkVEcmg1xeBYH2J3Dexa0OuxYAWu3339afsxi6xWvVVF/Y18CCFpVeHojbV3A50VZtP31CNqVdFSG7qTFceHRycZ0sZ4p6iVm7fiuFiAUmG2YcXxLAMd6sEaUwjhTPfQXwn0Ah9teM4Y8Gng+Q3nPR+4LYRwrOGxj5AUk69dn7R+dVXSC7bLrDjub8KKY4lva18Hm3s7zrpwXL/g0OVwxXFvR3luocLJqRn+/oHDXNOE1caQ3M0FcDS9IHPfwVF2bejKZFHydG7YcwOlwtpXBPdV++b+e+vQJOcMTfDNe3uYnYWSJe85m9H2ZHvvdgZ7ptkyOHXmkxtksU0FqHAsIpJLneXOFTXdLxVKTV1xdSaXbb0MSIrGP7f759g9sDtalhjMrGRmbzOze81swsx+bGbvX3SO+i2ehfrmePUex0+emGJqJqhw3EKNBUv1OG6t4Z4qJ6ZmePhn4wx1acwv1uz5r1oJHB1NXoZr1RmGOpdu0SSZcR4wA9y76PEfpN9rPO+HjSeEEB4Gxhedl0uFgtFdLS3bqqIZPY4lPjPj0pGBdSscr/eGZq3Q11mee795+0NHODk1yzX7mrMh6kD67+hI+u/qgUNj7B7206ai7nTtFFdi8QKoy/cf49h4ibt/UqOYFo6bMZa29W5b9XM6Sh0LejJniQrHIiI5ZGZ0lc9coInVpqJupH+Ezd2buWHPDXldafx/A28E/k/gBpJbZBdvy6t+i2eht6PeqiL5IHLw+ASACsctNJDellwuGlv7412oyqP6JpBPnphiWCuOT1EpVpq6s3m1PMv0bPL716qz6m+cfQPAaAhhZtHjR4BOM6s0nHd0iecfSb+3gJm9xsy+ZWbfOnjw4HrmzayejhKjEwtX4h2tb45X02tRu7pkZICfHD3BY0+eXPPvMTa34thf4bi3o8TJqVkmpmf48r2HKBeNZ+5uzgXDvvTf0dHxSU5OzfCToydcbYy3XhZv8r5vy0kGu6f4+3t6KZC0R2vGWNrYtZFKcXWvZY132maNCsciIjm1khYUWei1+KJzXzS3OUKemNmNwMuA60MIfxZC+GII4a9CCG9vOEf9Fs9SqVigq1KcWwFycDQpHKuI1jpD6e2U2wc6KRX11rSVhhsukKhVxdKa2ue4lHRGKFigWgoqHOdUCOGWEMKBEMKBDRuac9t61nRXSxxftOL4yfFJzOZ7IEv7qfc5/vbDa1917HnFcW/Dhsxfvvcgl+wYaFoBvL5y/+j4FA8eHiME2O1oY7z10lHqWFDANYPLzz3OY0cqfP+R5LH17nEMyd2yq93kToVjERHJnJVskBd7xTGc/S1Kjr0K+LsQwl2nOUf9FtdBb21+s5L6imNPm4d4V+/DN6KN8VpuQ8MmkGpVsbRaqXl9jjsqSeG4Vp3FDBWOs+8I0L1Em6cBYDyEMNlwXh+nGki/l3vdHaVTNsc7emKKvlqZQsFXD1ZZuQu29FItFc6qXcWY48JxX1o4fuDQGN9/9BjPOrd5F4rKxQI91RJHxie5/+AYALuH87fiGE5ddfyUkXE6qzPc9t1RoHmr18/pPWdV5w/VstuuSoVjEZGcWklROAsrjnPsGcA9ZvYnZnYs7U38STNrvHytfovroHGzkrlWFd1qmdAqQ3OF43x+oIlpg1Ycn1FTVxyXk10hOyszdJY7o+4pICvyQ6AILN69aPEc+0MWza1mth3oXHRebvXXyjxxbGLBY0fHp7QxXpurlApcfE7/WRWOR123qkjG92e/+1MArt7b3BWmfZ1ljo5P8cChpHC8S4VjAMrFwCV7RplOd2bOSuFYK45FRCRzvKw4zrHNwE3A04CXA78OXAr8jc1vidyUfouQr56LfbX5zUoOjU5SKRborfn7QOLVYFeFAyMDXLs/H7doZ8lgV4X64r7hbq04XkpzC8fzK4612tiFrwLHSFpCAWBmnST7C9zacN6twPPMrPFN1MtI9ij4YgtyZt7TdwxwzxPHOTo+OffY0RNT9HXqAla7e+buQe788VH+2x0/WdPz26FVxWe/+1P6O8s8ddtSNyasn4HOCkfHJ7nv4CibeztcFtvXw+LCMcCBveN0lJNyaDNaVQD0d/Qv+bOXUiqU6O/ob0qO9aDCsYhITq2ocKwVxzFZevxCCOGzIYT/B/hV4HLgumb/8Dz1XOytlRZsjjfcXWG+Ni/NVioW+Pg/u5Ln7M/mTtLtrFgwBtMWFVpxvLRauXmtKuYKxxUVjrPAzDrN7CVm9hJgG7Ch/rWZdYYQTgLvAd5uZr9lZs8FPkbymfoDDb/Vh4AJ4JNmdr2ZvQZ4B/BvF7WMyq0r9gwRAnz9/p/NPfbk+KRWHOfA6569h2fsGuTNH/0HPn77j1f9/LGJaYoFmyv6edKXLkp44vgEV+0dptjktiz9nWWOjE9x/8GxXG6MV7dU8XZDd41XXL6DjT3Vpu6vce7QuSs6b7A2mOnPHv7+tYmIyLpY0eZ4WnEc0xHguyGEww2PfQWYBC5oOEf9Fs9Sb0dDj+PRiQW374u0u/pGkINdKhwvZTUrjg1j/9B+jJV9+JtrVaEVx1mxkaQQ/DHgmSRzbf3r+pWt9wDvAn4X+AzJPgM/F0J4vP6bhBCOAM8laWvxaZLNaN8P/OuW/CkcuPicfmrlIl+779DcY0dPTM1t6CXtq7NS4j/fdDlX7RnmrR+/k4984+FVPX9sYoauSjHTRbbl1FtVADxrX/PbEvSnK47vPzia2zYVsHThuLfay798wfl87k3PaurP3j+0f0XnZblNBUA+16qLiMgZVxwXrdjUlVZyRj8AlqpYGDCb/ndjv8W7G85Rv8VV6G1sVXF8gq396jMq+bGhp8pPjpygWsrtRqSntdLCca1U4/rd17OtdxsbujbwlYe/csbnzK84nlHhOANCCA/C6av+IYRAUjh+1xnOu4sW3B3kVaVU4MDOAb52//y1cfU4zo9apch//LUDvPbDt/O2T36XR46Ms2NwfoPcvRt7uHTk1E5qE9MzfPW+Q2zq9fk+rbdhfF+9r/l38w10lvnJ0RNMzQR2bzjznabtarnCcalYaPpF855qD1t7tvLo8UdPe54KxyIikkmlQomOUgcnp08u+X21qYjuM8Dvm9lwCKG+JOdZQBm4M/26sd/iv4EF/RZvafi9bgXeamY9IYTj6WPqt5jqrZUZnZhmdjZwcHSCi85pbs85kSzZv6lnbpd6OdVK2jpt7NrI8/Y8j65KsqLrqRufytjkGHc8dsdpnzff4ziocCy5c8WeIf7wc3dz8PgEg10Vjp1Uj+M86SgXueWVl/L6/3oHH/z/7lvwvYLBf7rpMp69qIXVv/v8vdzz+Cj/+abLWhl13XSUi1RKBc4ZqLGtv/mLc/o7K0zNJHe25LlVRXelm4IVmA2zc4+ttPfwejh36NwzFo6HakMtSrM2KhyLiORYT6Vn+cKx2lTEdgvwRuDTZvYHQA/wXuDzIYSvAIQQTprZe4CbzewIyerht7B0v8U3kvRbfC+wG/VbnNPbUSIEePLEFIfVqkJy5m3PP4+ZEGLHyKxtPdsoWpGZU/YgTezo28GNe2+kYAs7AD7jnGcwPjXO3YfvXvJ5AB1p4Xiwq0KpoI9lki9X7E4KJV+//zDX7BsmBLTiOGeqpSK3/OqlPH5sgtl0HpqeCbz2r27nDX99B//tt65iT7pS9vaHjvBnX7yPl1+2neec53dPhHM3dXPdeZta8rMa/z3tGc7viuOCFeiudHNsYv4jTysLx3sG9vCVh7/C9OzSF+kNY6gz24Vj9TgWEcmx062k0orjuNKC7nUkPYg/AnwQ+ALwy4tOVb/Fs1S/dfDBw2PMBlQ4llwpFQtqU3Ea5WKZc3rPWfb7F2266JSicd21O69le+/2ZZ/bWU0Kx+f05/cDveTXhdv66K6W+Nr9hzkynrSLUo/j/DEzNvd1sLW/xtb+GjuGOvnzV15KuVjg1X/5LY6dnOLE5Ay//bE72dJX41/+o/NjRz4rn3791bz5+n0t+VkDXcm/p0qxwLaBfLcfXFwobmXhuFwss3tg97Lf7+voy/zFYxWORURy7HTF4ZXcnivNFUL4UQjhBSGErhDCQAjhprQI3HhOCCG8K4RwTgihFkK4JoRwyv3RIYS7QgjXpedsCSHcHMIyS+hypr5ZyX0HxwAY7lbhWETm7RrYteTjtVKNbT3bln1ewQoc2Hpg2e9vHZzkl68+yDN3Z3ulkUgzlIoFLt81yNfvO8zR8WQvXxWOBeCcgU7+wz+5hIcPj/PGv76Dd9/6Ax44NMYfvfQiejp8jxEza9nGfv1p65eRoU6KBX+bCa6nmIVjSNpVLCfr/Y1BhWMRkVw77YpjtaqQnOir1QvHo4BWHIvIQjv7d2JL7Jm2Z3DPGQsAm7o30VVeurekGezefJLhjN+iKtIsV+4Z4v5DY9z9WLL9Ql9NPY4l8YzdQ7zj55/C/7z7IH/5tYe46cqdXLkn+wW2LKm3qshzf+O6xkJxtVilWmrte/1tPduWfS+gwrGIiGTa6YrDalUhedFbS24Pu79eONaKYxFp0FHqYEvPllMe3zu4d0XPX27Fcp02xpO8qq+2v/V7jwFacSwL/dNnjvDaZ+3m0pEBfufG82LHcWcgXXG8e4PuIm0sHMf4jGtmy646zvrGeKDCsYhIrmnFsch8q4ofPZEUjoe14lhEFtnVv7D4213pZnP35hU993S9DYtWpK+j76yyiXh1wZZe+mplvnrfIUCb48mpfvcF5/OJf3YltYp68a/W5r4OLtzWx7XnbogdJbrGwnGr21TU7R/ev+TjWnEsIiKZtlzhuGAFOsudLU4jEkd9c7yHDo9TKxfp0ocTEVlk8arhla42BtjSvYVaaemNifo7+pfdXE+k3RUKxjN3DzI1E4D51lEicvY6ykU+/Yar1UefhcXivmqci7X9Hf1csOGCBY91lbuolbO/caHepYiI5FitXFtyF9fuSnfLNm4Qia2nWsIMpmcDG3qqGvsicoruSjcbOudXba2mcGxm7OzfueT31KZC8u6KtKjVUy1RKqo8ISLrr1KsUC0mdxTGbMd49Y6r2di1ce5rD6uNQYVjEZHcW2rVsdpUSJ4UCkZPNbmAoo3xRGQ59ZYTfdW+VX/YW65dxenaWIjkwZV7k39LfepvLCJNVG8LFatVBSR39d6w5wY6Sh0ADDnZHFeFYxGRnFuqSKyN8SRv6u0qhru1o7uILK3ermI1q43rtvVuo1Jc+PqyZ2DPGTfOE2l3+zZ2M9xd0cZ4ItJU9c+8MQvHkCzaun739RjmZsXxqfcni4hIrmjFsUh9g7wTWnEsIsvq7+hnoGOAfUP7Vv3cghXY2b+Tew7fA0CtVOOakWvWO6KIO2bG667dEzuGiLS53movBSucdnP4Vjmn9xwu23aZCsciIuLDkoVjrTiWnKlvyLOhuyNyEhHJsgNbD9Df0b+m5+7q3zVXOH7WyLPmblUVybvfvEYtW0Skufo6+uiudGdmQ9pLtlwSO8KKqXAsIpJzSxWJteJY8qa3lrwlGu5RqwoRWd6ewbWvjNzet51SocTO/p1qUSEiItJCPZWe6G0qvFLhWEQk55ZacZyFW3hEWilpVQEbutWqQkSao1Qocd7weVy29bLYUURERHKlt9qrwvEaRV2jbWY3mVlY4nhdzFwiInmypXsL145cS1e5CyAzvZ9EWqm+OZ56HItIM121/SqqJb3OiIiItFJ3pXvNrabyLisrjq8DTjR8fX+sICIieWNmnL/hfPYN7eM7j3+H+352H2YWO5ZIS9V7HA9rxbGINJHmVxERkdYzM7b1bIsdw6WsFI6/GUIYjR1CRCTPSoUSl2y5hIs3XRw7ikjLHRgZ4PKdg2zu02ZVIiIiIiLtZqhzKHYEl7JSOBYRkYwoFoqxI4i03JV7h7ly73DsGCIiIiIiIpkRtcdxg/vMbNrM7jaz18YOIyIiIiIiIiIiIpJnsVcc/xS4GfgGUAReDnzIzDpDCO9ffLKZvQZ4DcCOHTtamVNEREREREREREQkN6IWjkMItwG3NTx0q5l1AL9nZn8cQphddP4twC0ABw4cCK1LKiIiIiIiIiIiIpIfWWlV0ejjwCCwM3IOERERERERERERkVzKYuE4LPpVREQkd8zsJjMLSxyvazjHzOztZvaImZ0wsy+Z2dOW+L0uMLMvmNm4mT1qZu80M+2CKCIiIiIiIsuK3eN4KS8BDgEPxQ4iIiKSAdcBJxq+vr/hv99GslfAW4EfAm8BPm9mTw0hPAZgZgPA54G7gF8A9gDvI7l4/HtNTy8iIiIiIiIuRS0cm9knSDbG+w7J5ngvS483Lu5vLCIiklPfDCGMLn4w3RPgbcC7Qwh/kj72NeBB4PXMF4VfB9SAXwohHAP+h5n1Au8wsz9MHxMRERERERFZIHariruBVwGfAD4GXAC8MoTwgaipREREsu9KoBf4aP2BEMIY8Gng+Q3nPR+4bVGB+CMkxeRrW5BTREREREREHIpaOA4hvD2EsD+E0BlCqIUQLg0hfDhmJhERkYy5z8ymzexuM3ttw+PnATPAvYvO/0H6vcbzfth4QgjhYWB80XkiIiIiIiIic7LY41hERETgpyT9i79B0s7p5cCHzKwzhPB+YAAYDSHMLHreEaDTzCohhMn0vKNL/P5H0u8tycxeA7wGYMeOHWf5RxERERERERFvVDgWERHJoBDCbcBtDQ/dmvY1/j0z++MW/PxbgFsADhw4EJr980RERERERCRb3BaOb7/99kNm9lDsHKlh4FDsEGvkOTsof2ye83vODsofy0jkn/9x4JeBnSQrhrvNrLho1fEAMJ6uNiY9r2+J32sg/d4ZZWjO9Tpu6pQ/Ls/5PWcH5Y/Jc/bYc27LZWi+Bd9jB5Q/Js/ZQflj8pwdfOdfds51WzgOIWyInaHOzL4VQjgQO8daeM4Oyh+b5/yes4Py51ho+PWHJC0s9pJsNlu3uKfxD1nUy9jMtgOdi85b/odmZM71Pm6UPy7P+T1nB+WPyXP2PMrKfAv+x47yx+M5Oyh/TJ6zg//8y4m6OZ6IiIisyktIrmI/BHwVOAa8tP5NM+sEXgTc2vCcW4HnmVlPw2MvA04AX2x2YBEREREREfHJ7YpjERGRdmZmnyDZGO87JCuLX5YebwwhzAInzew9wM1mdoRk9fBbSC4Kf6Dht/oQ8Ebgk2b2XmA38A7g34YQjrXojyMiIiIiIiLOqHC8Pm6JHeAseM4Oyh+b5/yes4Py58HdwKuA7YABdwGvDCF8uOGc95AUin8XGAK+BfxcCOHx+gkhhCNm9lzgT4BPA0eB95MUj73xPm6UPy7P+T1nB+WPyXN2icv72FH+eDxnB+WPyXN28J9/SRaCNkoXERERERERERERkXnqcSwiIiIiIiIiIiIiC6hwLCIiIiIiIiIiIiILqHAsmWBmrsdiG+S32BnWStnj8Z5fJK/aYM5ym9/766bn/MouIjE4n7PcZgf/r52e8yt7e3H9QiDtwczKIYTZ2DnWqg3ydwenzc49Z0+9ysz2gts3Zt7zi+ROG8xZbvN7n7O858f3nOU5u0huOZ+z3GYH/3OW9/z4nrc8Z28K/SUAZnahmd1oZn2xs6yF5/xm9nzgg2bWGTvLWrRB/uuAT5nZC2NnWS3P2QHS3H8OvBnA2xsz7/klHudzltvs0BZzltv8bTBnec/vds7ynF3iaoM5y3t+z3OW2+zQFnOW9/xu5y3P2ZtJhePEZ4GPA283s4vMrBw70Cp5zv+XwBMhhPHYQdbIe/4PAT8GnogdZA08Zwf4IHAn8Aoz+4CZ9YKrW2O855d4PM9ZnrOD/znLc37vc5b3/J7nLM/ZJS7vc5b3/J7nLM/Zwf+c5T2/53nLc/amKcUOEFP6P78XeBToAX4DuAn4IzP7KPBoCGHazKohhIl4SZfWBvn/FXACuKXhsTJwFXAc+AlwJIvZoS3y/xZQBm4OITyUPnYJ8I+AMeBJ4DMhhMfjpVya5+wAZvavSS7c/Srwz4FXAd8APuzhliTv+SUOz3OW5+x1bTBnuc3fBnOW9/xu5yzP2SUe73OW9/zgfs5ymx3aYs7ynt/tvOU5e9OFEHJ/AM8FbgOeBrwbmAK+CbwE6AO+BNwYO2c75U9zjQG/0fDYzwNfBCaAWeAu4E1AT/p9i527XfKned4JfBiopV+/luQN2mHgMeBu4DPA87KW33n2fpI3Y7/Z8NhfACeB38xS1nbMryP+4XHO8p7d+5zVBvndzlne83ueszxn15GNw+uc5T2/5znLc/aGvG7nLO/5Pc9bnrO35O8ndoAsHCRXdD4D/Hn69aXA36YvjHcCo8DlsXO2U37gP6b56i94lfTF8P8FXgM8B/hIes57Yudtt/xp5n8B3J/+dy19Ufx9YCPJlbbXAXcAXwYqsfO2UfaPA7eTrKCw9LFdwOeAe4FLY2ds5/w64h8e5yzv2b3PWW2Q3+2c5T2/5znLc3Yd2Ti8zlne83ueszxnb/gzuJ2zvOf3PG95zt6Sv5/YAbJyAFcA9wHXNzz2SpIrmyeBPwIuAEqxs7ZDfpIrl3cBx4CbSa6qfR3Ytui83yG56nlF7MztlD/NdgnwU+BlwLnp5LN90TnnpmPoTbHztkN2kiuZfwFctcT39gM/BB4Anh47azvm15Gdw9uc5T279zmrDfK7nLO85/c8Z3nOriNbh8c5y3t+z3OW5+wN2VzOWd7ze563PGdv2d9R7ABZOoD3AB9t+PrPSG4F+IP0hfFh0lsysnh4y09yBe1t6cQ0S9JHpn51p5z+eilJH5+XxM7bbvnTfP8GOAL8F+BnwDXp453prwXgC8D7Ymdtl+zAMItudWkYN5eQvFn7W2BH/c8RO3M75deRncPbnOU9u/c5qw3yu5yzvOf3PGd5zq4jW4fHOct7fs9zlufsDX8Gl3OW9/ye5y3P2VtxFBDMrJQ24f8r4Foz+3UzezrwauD3QwhvB84H3hJCOG5mmfp785o/hHAihPAe4CnAvwIeCem/whDCVHraSZLdRDvipFye5/wNu4J+kGTX3EtJbsu4yczKYX4H3SFgC8mtYJnYTdRzdoAQwqEQQmjM0zBuvk3yJvhZwHvNrBBCmI0UdUne80t8Xucs8J3d85wFfvN7n7O85/c8Z3nOLtngec4C3/m9zlngO7v3Oct7fs/zlufsrVCvoOeSmfWEEI4veuw3gBcBIyS3CLwihPDkonMsZOAvznP+ZbJb+o+1FJKdcmvAG4G3AptCCDNZyA7tld/MeoFfB36NZPOJg8AHgGngOpI3DSPpnyl6fs/ZYemxs8Q5v0jSP+w/hBDe1JJgK+Q9v8TThnOWi+xpjraZsxoec5G/neYs7/lPc04m5yzP2SWuNp2zvOd3N2c1POYiO7TXnOU9/2nOyeS85Tl7S4QMLHtu5QFcDryXpMH1p4DXAwMN398OfJ/ktoxnx87bTvmXyT54mvP/OcnOoa9Lv47au6oN878BGG74/i7gzcAngJ8ADwL/CXhW7Pyes59m7AwscV79Yl4XSU+xX2l8XPl1eDvacM5ykf00+T3PWW7yt+Gc5T2/mznLc3YdcY82nbO85/c6Z7nJvkx+73OW9/xu5i3P2Vt95GrFsZltBL4EHAe+DVxMMgm9K4Twp4vOvRz4Xpi/HSA6z/lXkz09/2rgTcDPQgivaWHUJeUpv5l1AhMkV5AfbXXWxTxnh9WPnazxnl/iycuclbXskK85Kz0/M/nzNGd5z581nrNLXHmas7znT893OWel52cmO+RrzvKeP2s8Z48iduW6lQfJsvJbgZ3p1wWS/jEngYvTx8qLnpOZptee868wuzWcb8BTgf7066LyNz1/adFzPI2dTGZfy9hJv67Ezt0u+XXEO3IwZ2Uy+yrye5+zMpk/J3OW9/yZnLM8Z9cR98jJnOU9v+c5K5PZV5Hf+5zlPX8m5y3P2WMcmWkg32xmtpfkKsKfhxAeTPvAzALvJGns/uL01On0fAMIGWl67Tn/KrLXzy+GxPdCCEcBQggzLY7dmCcv+WfS8z2OncxlhzWNnXr+yVZnXYr3/BJPTuaszGWHXM1Z9fMzkz9Hc5b3/PXzMzNnec4uceVozvKev36+xzmrfn5msqd58jJnec9fPz8z85bn7LHkpnBM0kh/GJiCBTskPg78V+CFZlatPw68wMz+wLKzO6vn/KvNfqOZvTsj2SF/+T2PnSxlB+WX/PI8djxnh/zNWVnKn7exo/zrx3N2icv72Mlbfs9zVpayQ/7GjvKvH8/Zo8jTH/xbwL8H/q7+QMP/+FtJdqq8Mn18M/DvSG69yMQVHXznX0v2Qghhtn51J7I85vc8drKSHZRf8svz2PGcHfI5Z2Ulfx7HjvKvD8/ZJS7vYyeP+T3PWVnJDvkcO8q/PjxnjyNkoF9Gqw4W9UZqfBy4C3hf+vU7SBq+17+fid0SPef3nF35lV35/ebXEe/wPHY8Z1d+ZVd+n/k9Z9cR9/A+dpRf2ZVf+ZU920eeVhwTQpg6zeMfAZ5vZvuB/w34bQAzK4V0hMTmOb/n7KD8MXnODsov+eV57HjODsofk+fsoPwxec4ucXkfO8ofj+fsoPyxec7vOXsMltM/9ynM7BrgU8CjwHQI4eLIkVbFc37P2UH5Y/KcHZRf8svz2PGcHZQ/Js/ZQflj8pxd4vI+dpQ/Hs/ZQflj85zfc/ZmKcUOkCF3AKPA+cClQH3n0Gg7ha6S5/yes4Pyx+Q5Oyi/5JfnseM5Oyh/TJ6zg/LH5Dm7xOV97Ch/PJ6zg/LH5jm/5+xNocJxKoQwamavBs4PIdxhZgVPA8Nzfs/ZQflj8pwdlF/yy/PY8ZwdlD8mz9lB+WPynF3i8j52lD8ez9lB+WPznN9z9mZRq4oGluykGEIIIR0crnZN9Jzfc3ZQ/pg8Zwfll/zyPHY8Zwflj8lzdlD+mDxnl7i8jx3lj8dzdlD+2Dzn95y9GVQ4FhEREREREREREZEFCrEDiIiIiIiIiIiIiEi2qHAsIiIiIiIiIiIiIgu0deHYzPqXedzSXzO9OaDn/J6zg/LH5Dk7KL/kl+ex4zk7KH9MnrOD8sfkObvE5X3sKH88nrOD8sfmOb/n7FnQtoVjM7sC+OOGr+sDwtIG1+cCbzWzTenjmfq78Jzfc3ZQ/pg8Zwfll/zyPHY8Zwflj8lzdlD+mDxnl7i8jx3lj8dzdlD+2Dzn95w9K9r5L2Q/8Ktm9nZItkNs/BV4GfAu4B3p41nbJdFzfs/ZQflj8pwdlF/yy/PY8ZwdlD8mz9lB+WPynF3i8j52lD8ez9lB+WPznN9z9mwIIbTtAbwZuB94Rfp1YdH3Xwx8F3gDUIqdt53ye86u/Mqu/H7z64h3eB47nrMrv7Irv8/8nrPriHt4HzvKr+zKr/zK7utoyz4eZlYMIcwAfw08B3ifmd0VQrhz0amfAkaAjhDCdKtzLsdzfs/ZQflj8pwdlF/yy/PY8ZwdlD8mz9lB+WPynF3i8j52lD8ez9lB+WPznN9z9iyxEMKZz3Is7V/yBaAGvDqE8D0zKzUOBjPrDCGM13ucRAu7BM/5PWcH5Y/Jc3ZQfskvz2PHc3ZQ/pg8Zwflj8lzdonL+9hR/ng8Zwflj81zfs/ZY2uLHseWNq82s61m9nIzu9HMama2Of2f/RZgCPgtgPrAqD8vhDCe/hplYHjO7zm78mvsKL/f/BKP57HjObvya+wov8/8nrNLXN7HjvLrdUf5lV/Z20NbtKoI882rfw94JfAzoBf4tiUbJn4MuAt4rZmdBG4OIYwCmRgMnvN7zg7KH5Pn7KD8kl+ex47n7KD8MXnODsofk+fsEpf3saP88XjODsofm+f8nrNnWdu1qjCzp5IUxPcDTwP6gOuAR4CL0q//SQjhE7Eyno7n/J6zg/LH5Dk7KL/kl+ex4zk7KH9MnrOD8sfkObvE5X3sKH88nrOD8sfmOb/n7JkTMrBDXysOYC/JkvR/DzwJXBc7U17ye86u/Mqu/H7z64h3eB47nrMrv7Irv8/8nrPriHt4HzvKr+zKr/zKnv3D9YpjMyuEEGbNrB+4BNgK/CyE8Nn0+waUQwiTDc8ZAv4WuC2E8PYIsed4zu85e5pF+SPxnD3NovySS57HjufsaRblj8Rz9jSL8kfiObvE5X3sKL9ed9ZK+ZV/rTxndyFm1fpsDqCQ/toHfIqkd8n/DxwBPgc8s+HcUv389Ou/Ab6k/PnLrvwaO8rvN78OjZ28ZVd+jR3l95nfc3YdcQ/vY0f59bqj/Mqv7O13FPDvT4HNwDOBd5M0vt4NfN7MPmhmwyGE6ZA2yTazYaCSnpsFnvN7zg7KH5Pn7KD8kl+ex47n7KD8MXnODsofk+fsEpf3saP88XjODsofm+f8nrNnW+zK9VoO5jf1ewrwGHBD+vUXgY8CVwD/HZgFngD+j0XPP1f585dd+TV2lN9vfh0aO3nLrvwaO8rvM7/n7DriHt7HjvLrdUf5lV/Z2/Mo4VBI/w8DVwJfB75qZs8Dng48O4TwbTN7BfBVkmbXnYuef08r8y7mOb/n7OnPV/5IPGdPf77ySy55Hjues6c/X/kj8Zw9/fnKH4nn7BKX97Gj/HrdWSvlV/618pzdE1eFYzPrCSEcT/+7AHwTmAkhjJrZDcDXgPsbnvI48FfpMdcwu8Wx53jO7zl7+vOVX2NnTZQ/bn6Jx/PY8Zw9/fnKr7GzJsqvsSP+eB87yq/XnbVSfuVfK8/ZPXLT49jMXgy8z8yuNbNyCGE2hPAPJM2sIVl2fj4wlH7dCWwAToQQpgAi/6N8MU7ze84Oyg8aO2ul/HHzSzyex47n7KD8oLGzVsqvsSP+eB87yq/XnbVSfuVfK8/Zvar3A8m09ArCKNABfB74O+AzIYTvNZxzI/AxkuXp3wEuA3aGEHa0PvFCnvN7zg7K3/rE8zxnB+VvfWLJCs9jx3N2UP7WJ57nOTsof+sTz/OcXeLyPnaUPx7P2UH5W594Ic/5PWd3LWSg0fLpDsBIrhB8BpgBHgQOkwyQm4AtDeceIOld8jjwCeA56eMl5c9XduXX2FF+v/l1xDs8jx3P2ZVfY0f5feb3nF1H3MP72FF+ve4ov/Ire34OFyuOAcxsCHgnydWFvwfeAjwV+DTJbolfDiEcTc/dEUJ4OFLUJXnO7zk7KH9MnrOD8kt+eR47nrOD8sfkOTsof0yes0tc3seO8sfjOTsof2ye83vO7lbsyvVKDuZbajwPeBR4X/r1bwA/JrnS8F7gCqAYO2875fecXfmVXfn95tcR7/A8djxnV35lV36f+T1n1xH38D52lF/ZlV/5lT0fR/QAaxgoTwfuBN6Rft0H/ClwlKSHyc3Axtg52zG/5+zKr+zK7ze/jniH57HjObvyK7vy+8zvObuOuIf3saP8yq78yq/s7XtED3CGgXAuSR+T/kWP/xrwGPDqhscuJOlt8hhQi53de37P2ZVf2ZXfb34d8Q7PY8dzduVXduX3md9zdh1xD+9jR/mVXfmVX9nzdUQPcJqB8UZglmSnxFuAvwBeBDwjHTC/BhwBfh2oNDxvT/pr1GXpnvN7zq78GjvK7ze/Do2dvGVXfo0d5feZ33N2HXEP72NH+fW6o/zKr+z5O0pkkJmVgF9IvzwA3EGye+L/RdKzZAT4PslOiq8EbjOzx0MIMyGE+wBCCDOtzl3nOb/n7KD8oLGzVsofN7/E43nseM4Oyg8aO2ul/Bo74o/3saP8et1ZK+VX/rXynL2d1BtLZ4qZFYEbgOeSNL3uJrnK8N+B/cAOksHTAzwC3JylweA5v+fsoPwxec4Oyi/55XnseM4Oyh+T5+yg/DF5zi5xeR87yh+P5+yg/LF5zu85e1uJudz5TAcwDLwM+CQwCnwOuKTh+31AZ/rfhdh52ym/5+zKr+zK7ze/jniH57HjObvyK7vy+8zvObuOuIf3saP8yq78yq/s+ToyueJ4MTPbBTyfZOn5BcDfAP97COHx9PulEMJ0xIin5Tm/5+yg/DF5zg7KL/nleex4zg7KH5Pn7KD8MXnOLnF5HzvKH4/n7KD8sXnO7zm7Zy4Kx3Vm9nTgxcCvAL3A+0IIfxg11Cp4zu85Oyh/TJ6zg/JLfnkeO56zg/LH5Dk7KH9MnrNLXN7HjvLH4zk7KH9snvN7zu6Rq8IxgJnVgKuBlwD/FLgTuCo4+YN4zu85Oyh/TJ6zg/JLfnkeO56zg/LH5Dk7KH9MnrNLXN7HjvLH4zk7KH9snvN7zu6Nu8JxnZltAH4eeCSE8LdmVgghzMbOtVKe83vODsofk+fsoPySX57HjufsoPwxec4Oyh+T5+wSl/exo/zxeM4Oyh+b5/yes3vhtnAsIiIiIiIiIiIiIs1RiB1ARERERERERERERLJFhWMRERERERERERERWUCFYxERERERERERERFZQIVjEREREREREREREVlAhWMRERERERERERERWUCFYxERERERERERERFZQIVjEREREREREREREVngfwGdS13du7keNgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plt.figure(figsize=(20, 15))\n", "date_formater = mdates.DateFormatter('%b, %d')\n", @@ -951,7 +1983,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "d494463f", "metadata": {}, "outputs": [], @@ -971,10 +2003,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "5256fde1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "index = 123\n", "plot_prob_forecasts(tss[index], forecasts[index])" @@ -983,7 +2028,7 @@ { "cell_type": "code", "execution_count": null, - "id": "84e15650", + "id": "2eee87e9", "metadata": {}, "outputs": [], "source": [] @@ -1005,7 +2050,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.8.10" } }, "nbformat": 4,