diff --git "a/Time series transformer tutorial.ipynb" "b/Time series transformer tutorial.ipynb" new file mode 100644--- /dev/null +++ "b/Time series transformer tutorial.ipynb" @@ -0,0 +1,1123 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "86ad0e30", + "metadata": {}, + "outputs": [], + "source": [ + "# tutorial url\n", + "# https://huggingface.co/blog/time-series-transformers" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4357ee0e", + "metadata": {}, + "outputs": [], + "source": [ + "from datasets import load_dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a7009beb", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Found cached dataset monash_tsf (C:/Users/yozhan/.cache/huggingface/datasets/monash_tsf/tourism_monthly/1.0.0/fc869f3ae1577c9def2a919ab1dd0c3d4a7a44826b8e0e8fa423bb0161b629e2)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "553772b851a041aeb196651882da5fbe", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/3 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "figure, axes = plt.subplots()\n", + "axes.plot(train_example[\"target\"], color=\"blue\")\n", + "axes.plot(validation_example[\"target\"], color=\"red\", alpha=0.5)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2e02e6de", + "metadata": {}, + "outputs": [], + "source": [ + "train_dataset = dataset[\"train\"]\n", + "test_dataset = dataset[\"test\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "030b3d23", + "metadata": {}, + "outputs": [], + "source": [ + "#lru_cache is a decorator for some recursive calculation\n", + "# the values will stored in cache so that cached values will be used in the future if repeating computation happens\n", + "\n", + "from functools import lru_cache\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "\n", + "@lru_cache(10_000)\n", + "def convert_to_pandas_period(date, freq):\n", + " return pd.Period(date, freq)\n", + "\n", + "def transform_start_field(batch, freq):\n", + " batch[\"start\"] = [convert_to_pandas_period(date, freq) for date in batch[\"start\"]]\n", + " return batch" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "965bdb44", + "metadata": {}, + "outputs": [], + "source": [ + "from functools import partial\n", + "\n", + "train_dataset.set_transform(partial(transform_start_field, freq=freq))\n", + "test_dataset.set_transform(partial(transform_start_field, freq=freq))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f162ef59", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'We specify a couple of additional parameters to the model:\\n\\nprediction_length (in our case, 24 months): this is the horizon that the decoder of the Transformer will learn to predict for;\\ncontext_length: the model will set the context_length (input of the encoder) \\n equal to the prediction_length, if no context_length is specified;\\n \\nlags for a given frequency: these specify how much we \"look back\", to be added as \\n additional features. e.g. for a Daily frequency we might consider \\n a look back of [1, 2, 7, 30, ...] or in other words look back 1, 2, ... \\n days while for Minute data we might consider [1, 30, 60, 60*24, ...] etc.;\\n \\nthe number of time features: in our case, this will be 2 as we\\'ll add MonthOfYear and Age features;\\n\\nthe number of static categorical features: in our case, this will be just 1 as we\\'ll add a single \"time series ID\" feature;\\n\\nthe cardinality: the number of values of each static categorical feature, \\n as a list which for our case will be [366] as we have 366 different time series\\n \\nthe embedding dimension: the embedding dimension for each static categorical feature, \\n as a list, for example [3] means the model will learn an embedding \\n vector of size 3 for each of the 366 time series (regions). '" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"We specify a couple of additional parameters to the model:\n", + "\n", + "prediction_length (in our case, 24 months): this is the horizon that the decoder of the Transformer will learn to predict for;\n", + "context_length: the model will set the context_length (input of the encoder) \n", + " equal to the prediction_length, if no context_length is specified;\n", + " \n", + "lags for a given frequency: these specify how much we \"look back\", to be added as \n", + " additional features. e.g. for a Daily frequency we might consider \n", + " a look back of [1, 2, 7, 30, ...] or in other words look back 1, 2, ... \n", + " days while for Minute data we might consider [1, 30, 60, 60*24, ...] etc.;\n", + " \n", + "the number of time features: in our case, this will be 2 as we'll add MonthOfYear and Age features;\n", + "\n", + "the number of static categorical features: in our case, this will be just 1 as we'll add a single \"time series ID\" feature;\n", + "\n", + "the cardinality: the number of values of each static categorical feature, \n", + " as a list which for our case will be [366] as we have 366 different time series\n", + " \n", + "the embedding dimension: the embedding dimension for each static categorical feature, \n", + " as a list, for example [3] means the model will learn an embedding \n", + " vector of size 3 for each of the 366 time series (regions). \"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "09f1f194", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 5, 6, 7, 11, 12, 13, 23, 24, 25, 35, 36, 37]\n" + ] + } + ], + "source": [ + "from gluonts.time_feature import get_lags_for_frequency\n", + "\n", + "lags_sequence = get_lags_for_frequency(freq)\n", + "print(lags_sequence)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ccd2aa3f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[]\n" + ] + } + ], + "source": [ + "from gluonts.time_feature import time_features_from_frequency_str\n", + "\n", + "time_features = time_features_from_frequency_str(freq)\n", + "print(time_features)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c84c2203", + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import TimeSeriesTransformerConfig, TimeSeriesTransformerForPrediction\n", + "\n", + "config = TimeSeriesTransformerConfig(\n", + " prediction_length=prediction_length,\n", + " # context length:\n", + " context_length=prediction_length * 2,\n", + " # lags coming from helper given the freq:\n", + " lags_sequence=lags_sequence,\n", + " # we'll add 2 time features (\"month of year\" and \"age\", see further):\n", + " num_time_features=len(time_features) + 1,\n", + " # we have a single static categorical feature, namely time series ID:\n", + " num_static_categorical_features=1,\n", + " # it has 366 possible values:\n", + " cardinality=[len(train_dataset)],\n", + " # the model will learn an embedding of size 2 for each of the 366 possible values:\n", + " embedding_dimension=[2],\n", + " \n", + " # transformer params:\n", + " encoder_layers=4,\n", + " decoder_layers=4,\n", + " d_model=32,\n", + " \n", + ")\n", + "\n", + "model = TimeSeriesTransformerForPrediction(config)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "76c9c724", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\note that, similar to other models in the 🤗 Transformers library, \\nTimeSeriesTransformerModel corresponds to the encoder-decoder Transformer without any head on top, \\nand TimeSeriesTransformerForPrediction corresponds to TimeSeriesTransformerModel with a distribution head on top. \\nBy default, the model uses a Student-t distribution (but this is configurable):\\n'" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "Note that, similar to other models in the 🤗 Transformers library, \n", + "TimeSeriesTransformerModel corresponds to the encoder-decoder Transformer without any head on top, \n", + "and TimeSeriesTransformerForPrediction corresponds to TimeSeriesTransformerModel with a distribution head on top. \n", + "By default, the model uses a Student-t distribution (but this is configurable):\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e97434e0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'student_t'" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.config.distribution_output" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "83e665f0", + "metadata": {}, + "outputs": [], + "source": [ + "from gluonts.time_feature import (\n", + " time_features_from_frequency_str,\n", + " TimeFeature,\n", + " get_lags_for_frequency,\n", + ")\n", + "from gluonts.dataset.field_names import FieldName\n", + "from gluonts.transform import (\n", + " AddAgeFeature,\n", + " AddObservedValuesIndicator,\n", + " AddTimeFeatures,\n", + " AsNumpyArray,\n", + " Chain,\n", + " ExpectedNumInstanceSampler,\n", + " InstanceSplitter,\n", + " RemoveFields,\n", + " SelectFields,\n", + " SetField,\n", + " TestSplitSampler,\n", + " Transformation,\n", + " ValidationSplitSampler,\n", + " VstackFeatures,\n", + " RenameFields,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "e3d6ce89", + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import PretrainedConfig\n", + "\n", + "def create_transformation(freq: str, config: PretrainedConfig) -> Transformation:\n", + " remove_field_names = []\n", + " if config.num_static_real_features == 0:\n", + " remove_field_names.append(FieldName.FEAT_STATIC_REAL)\n", + " if config.num_dynamic_real_features == 0:\n", + " remove_field_names.append(FieldName.FEAT_DYNAMIC_REAL)\n", + " if config.num_static_categorical_features == 0:\n", + " remove_field_names.append(FieldName.FEAT_STATIC_CAT)\n", + " print(remove_field_names)\n", + "\n", + " # a bit like torchvision.transforms.Compose\n", + " return Chain(\n", + " # step 1: remove static/dynamic fields if not specified\n", + " [RemoveFields(field_names=remove_field_names)]\n", + " # step 2: convert the data to NumPy (potentially not needed)\n", + " + (\n", + " [\n", + " AsNumpyArray(\n", + " field=FieldName.FEAT_STATIC_CAT,\n", + " expected_ndim=1,\n", + " dtype=int,\n", + " )\n", + " ]\n", + " if config.num_static_categorical_features > 0\n", + " else []\n", + " )\n", + " + (\n", + " [\n", + " AsNumpyArray(\n", + " field=FieldName.FEAT_STATIC_REAL,\n", + " expected_ndim=1,\n", + " )\n", + " ]\n", + " if config.num_static_real_features > 0\n", + " else []\n", + " )\n", + " + [\n", + " AsNumpyArray(\n", + " field=FieldName.TARGET,\n", + " # we expect an extra dim for the multivariate case:\n", + " expected_ndim=1 if config.input_size == 1 else 2,\n", + " ),\n", + " # step 3: handle the NaN's by filling in the target with zero\n", + " # and return the mask (which is in the observed values)\n", + " # true for observed values, false for nan's\n", + " # the decoder uses this mask (no loss is incurred for unobserved values)\n", + " # see loss_weights inside the xxxForPrediction model\n", + " AddObservedValuesIndicator(\n", + " target_field=FieldName.TARGET,\n", + " output_field=FieldName.OBSERVED_VALUES,\n", + " ),\n", + " # step 4: add temporal features based on freq of the dataset\n", + " # month of year in the case when freq=\"M\"\n", + " # these serve as positional encodings\n", + " AddTimeFeatures(\n", + " start_field=FieldName.START,\n", + " target_field=FieldName.TARGET,\n", + " output_field=FieldName.FEAT_TIME,\n", + " time_features=time_features_from_frequency_str(freq),\n", + " pred_length=config.prediction_length,\n", + " ),\n", + " # step 5: add another temporal feature (just a single number)\n", + " # tells the model where in its life the value of the time series is,\n", + " # sort of a running counter\n", + " AddAgeFeature(\n", + " target_field=FieldName.TARGET,\n", + " output_field=FieldName.FEAT_AGE,\n", + " pred_length=config.prediction_length,\n", + " log_scale=True,\n", + " ),\n", + " # step 6: vertically stack all the temporal features into the key FEAT_TIME\n", + " VstackFeatures(\n", + " output_field=FieldName.FEAT_TIME,\n", + " input_fields=[FieldName.FEAT_TIME, FieldName.FEAT_AGE]\n", + " + (\n", + " [FieldName.FEAT_DYNAMIC_REAL]\n", + " if config.num_dynamic_real_features > 0\n", + " else []\n", + " ),\n", + " ),\n", + " # step 7: rename to match HuggingFace names\n", + " RenameFields(\n", + " mapping={\n", + " FieldName.FEAT_STATIC_CAT: \"static_categorical_features\",\n", + " FieldName.FEAT_STATIC_REAL: \"static_real_features\",\n", + " FieldName.FEAT_TIME: \"time_features\",\n", + " FieldName.TARGET: \"values\",\n", + " FieldName.OBSERVED_VALUES: \"observed_mask\",\n", + " }\n", + " ),\n", + " ]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "73c8d1fc", + "metadata": {}, + "outputs": [], + "source": [ + "from gluonts.transform.sampler import InstanceSampler\n", + "from typing import Optional\n", + "\n", + "def create_instance_splitter(\n", + " config: PretrainedConfig,\n", + " mode: str,\n", + " train_sampler: Optional[InstanceSampler] = None,\n", + " validation_sampler: Optional[InstanceSampler] = None,\n", + ") -> Transformation:\n", + " assert mode in [\"train\", \"validation\", \"test\"]\n", + "\n", + " instance_sampler = {\n", + " \"train\": train_sampler\n", + " or ExpectedNumInstanceSampler(\n", + " num_instances=1.0, min_future=config.prediction_length\n", + " ),\n", + " \"validation\": validation_sampler\n", + " or ValidationSplitSampler(min_future=config.prediction_length),\n", + " \"test\": TestSplitSampler(),\n", + " }[mode]\n", + "\n", + " return InstanceSplitter(\n", + " target_field=\"values\",\n", + " is_pad_field=FieldName.IS_PAD,\n", + " start_field=FieldName.START,\n", + " forecast_start_field=FieldName.FORECAST_START,\n", + " instance_sampler=instance_sampler,\n", + " past_length=config.context_length + max(config.lags_sequence),\n", + " future_length=config.prediction_length,\n", + " time_series_fields=[\"time_features\", \"observed_mask\"],\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "82d5a50c", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Iterable\n", + "\n", + "import torch\n", + "from gluonts.itertools import Cached, Cyclic\n", + "from gluonts.dataset.loader import as_stacked_batches\n", + "\n", + "\n", + "def create_train_dataloader(\n", + " config: PretrainedConfig,\n", + " freq,\n", + " data,\n", + " batch_size: int,\n", + " num_batches_per_epoch: int,\n", + " shuffle_buffer_length: Optional[int] = None,\n", + " cache_data: bool = True,\n", + " **kwargs,\n", + ") -> Iterable:\n", + " PREDICTION_INPUT_NAMES = [\n", + " \"past_time_features\",\n", + " \"past_values\",\n", + " \"past_observed_mask\",\n", + " \"future_time_features\",\n", + " ]\n", + " if config.num_static_categorical_features > 0:\n", + " PREDICTION_INPUT_NAMES.append(\"static_categorical_features\")\n", + "\n", + " if config.num_static_real_features > 0:\n", + " PREDICTION_INPUT_NAMES.append(\"static_real_features\")\n", + "\n", + " TRAINING_INPUT_NAMES = PREDICTION_INPUT_NAMES + [\n", + " \"future_values\",\n", + " \"future_observed_mask\",\n", + " ]\n", + "\n", + " transformation = create_transformation(freq, config)\n", + " transformed_data = transformation.apply(data, is_train=True)\n", + " if cache_data:\n", + " transformed_data = Cached(transformed_data)\n", + "\n", + " # we initialize a Training instance\n", + " instance_splitter = create_instance_splitter(config, \"train\")\n", + "\n", + " # the instance splitter will sample a window of\n", + " # context length + lags + prediction length (from the 366 possible transformed time series)\n", + " # randomly from within the target time series and return an iterator.\n", + " stream = Cyclic(transformed_data).stream()\n", + " training_instances = instance_splitter.apply(\n", + " stream, is_train=True\n", + " )\n", + " \n", + " return as_stacked_batches(\n", + " training_instances,\n", + " batch_size=batch_size,\n", + " shuffle_buffer_length=shuffle_buffer_length,\n", + " field_names=TRAINING_INPUT_NAMES,\n", + " output_type=torch.tensor,\n", + " num_batches_per_epoch=num_batches_per_epoch,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "4b3f4fb2", + "metadata": {}, + "outputs": [], + "source": [ + "def create_test_dataloader(\n", + " config: PretrainedConfig,\n", + " freq,\n", + " data,\n", + " batch_size: int,\n", + " **kwargs,\n", + "):\n", + " PREDICTION_INPUT_NAMES = [\n", + " \"past_time_features\",\n", + " \"past_values\",\n", + " \"past_observed_mask\",\n", + " \"future_time_features\",\n", + " ]\n", + " if config.num_static_categorical_features > 0:\n", + " PREDICTION_INPUT_NAMES.append(\"static_categorical_features\")\n", + "\n", + " if config.num_static_real_features > 0:\n", + " PREDICTION_INPUT_NAMES.append(\"static_real_features\")\n", + "\n", + " transformation = create_transformation(freq, config)\n", + " transformed_data = transformation.apply(data, is_train=False)\n", + "\n", + " # we create a Test Instance splitter which will sample the very last\n", + " # context window seen during training only for the encoder.\n", + " instance_sampler = create_instance_splitter(config, \"test\")\n", + "\n", + " # we apply the transformations in test mode\n", + " testing_instances = instance_sampler.apply(transformed_data, is_train=False)\n", + " \n", + " return as_stacked_batches(\n", + " testing_instances,\n", + " batch_size=batch_size,\n", + " output_type=torch.tensor,\n", + " field_names=PREDICTION_INPUT_NAMES,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "2cbf8ec7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['feat_static_real', 'feat_dynamic_real']\n", + "['feat_static_real', 'feat_dynamic_real']\n" + ] + } + ], + "source": [ + "train_dataloader = create_train_dataloader(\n", + " config=config,\n", + " freq=freq,\n", + " data=train_dataset,\n", + " batch_size=256,\n", + " num_batches_per_epoch=100,\n", + ")\n", + "\n", + "test_dataloader = create_test_dataloader(\n", + " config=config,\n", + " freq=freq,\n", + " data=test_dataset,\n", + " batch_size=64,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "064793ed", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "past_time_features torch.Size([256, 85, 2]) torch.FloatTensor\n", + "past_values torch.Size([256, 85]) torch.FloatTensor\n", + "past_observed_mask torch.Size([256, 85]) torch.FloatTensor\n", + "future_time_features torch.Size([256, 24, 2]) torch.FloatTensor\n", + "static_categorical_features torch.Size([256, 1]) torch.IntTensor\n", + "future_values torch.Size([256, 24]) torch.FloatTensor\n", + "future_observed_mask torch.Size([256, 24]) torch.FloatTensor\n" + ] + } + ], + "source": [ + "batch = next(iter(train_dataloader))\n", + "for k, v in batch.items():\n", + " print(k, v.shape, v.type())" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "9a1e2036", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# perform forward pass\n", + "outputs = model(\n", + " past_values=batch[\"past_values\"],\n", + " past_time_features=batch[\"past_time_features\"],\n", + " past_observed_mask=batch[\"past_observed_mask\"],\n", + " static_categorical_features=batch[\"static_categorical_features\"]\n", + " if config.num_static_categorical_features > 0\n", + " else None,\n", + " static_real_features=batch[\"static_real_features\"]\n", + " if config.num_static_real_features > 0\n", + " else None,\n", + " future_values=batch[\"future_values\"],\n", + " future_time_features=batch[\"future_time_features\"],\n", + " future_observed_mask=batch[\"future_observed_mask\"],\n", + " output_hidden_states=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "29b4d896", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loss: 9.22168254852295\n", + "CPU times: total: 0 ns\n", + "Wall time: 1 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "\n", + "print(\"Loss:\", outputs.loss.item())" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "b00eda51", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9.025437355041504\n", + "CPU times: total: 32min 9s\n", + "Wall time: 4min 36s\n" + ] + } + ], + "source": [ + "%%time\n", + "\n", + "from accelerate import Accelerator\n", + "from torch.optim import AdamW\n", + "\n", + "accelerator = Accelerator()\n", + "device = accelerator.device\n", + "\n", + "model.to(device)\n", + "optimizer = AdamW(model.parameters(), lr=6e-4, betas=(0.9, 0.95), weight_decay=1e-1)\n", + "\n", + "model, optimizer, train_dataloader = accelerator.prepare(\n", + " model,\n", + " optimizer,\n", + " train_dataloader,\n", + ")\n", + "\n", + "model.train()\n", + "for epoch in range(1):\n", + " for idx, batch in enumerate(train_dataloader):\n", + " optimizer.zero_grad()\n", + " outputs = model(\n", + " static_categorical_features=batch[\"static_categorical_features\"].to(device)\n", + " if config.num_static_categorical_features > 0\n", + " else None,\n", + " static_real_features=batch[\"static_real_features\"].to(device)\n", + " if config.num_static_real_features > 0\n", + " else None,\n", + " past_time_features=batch[\"past_time_features\"].to(device),\n", + " past_values=batch[\"past_values\"].to(device),\n", + " future_time_features=batch[\"future_time_features\"].to(device),\n", + " future_values=batch[\"future_values\"].to(device),\n", + " past_observed_mask=batch[\"past_observed_mask\"].to(device),\n", + " future_observed_mask=batch[\"future_observed_mask\"].to(device),\n", + " )\n", + " loss = outputs.loss\n", + "\n", + " # Backpropagation\n", + " accelerator.backward(loss)\n", + " optimizer.step()\n", + "\n", + " if idx % 100 == 0:\n", + " print(loss.item())" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "2d4001c6", + "metadata": {}, + "outputs": [], + "source": [ + "model.eval()\n", + "\n", + "forecasts = []\n", + "\n", + "for batch in test_dataloader:\n", + " outputs = model.generate(\n", + " static_categorical_features=batch[\"static_categorical_features\"].to(device)\n", + " if config.num_static_categorical_features > 0\n", + " else None,\n", + " static_real_features=batch[\"static_real_features\"].to(device)\n", + " if config.num_static_real_features > 0\n", + " else None,\n", + " past_time_features=batch[\"past_time_features\"].to(device),\n", + " past_values=batch[\"past_values\"].to(device),\n", + " future_time_features=batch[\"future_time_features\"].to(device),\n", + " past_observed_mask=batch[\"past_observed_mask\"].to(device),\n", + " )\n", + " forecasts.append(outputs.sequences.cpu().numpy())" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "f924996a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(64, 100, 24)\n" + ] + } + ], + "source": [ + "print(forecasts[0].shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "d3a9c5db", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(366, 100, 24)\n" + ] + } + ], + "source": [ + "forecasts = np.vstack(forecasts)\n", + "print(forecasts.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "7dd17819", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7b3f56e729e3434ba3a89ce3681b6443", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Downloading builder script: 0%| | 0.00/5.50k [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(mase_metrics, smape_metrics, alpha=0.3)\n", + "plt.xlabel(\"MASE\")\n", + "plt.ylabel(\"sMAPE\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "d0be3a68", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.dates as mdates\n", + "\n", + "def plot(ts_index):\n", + " fig, ax = plt.subplots()\n", + "\n", + " index = pd.period_range(\n", + " start=test_dataset[ts_index][FieldName.START],\n", + " periods=len(test_dataset[ts_index][FieldName.TARGET]),\n", + " freq=freq,\n", + " ).to_timestamp()\n", + "\n", + " # Major ticks every half year, minor ticks every month,\n", + " ax.xaxis.set_major_locator(mdates.MonthLocator(bymonth=(1, 7)))\n", + " ax.xaxis.set_minor_locator(mdates.MonthLocator())\n", + "\n", + " ax.plot(\n", + " index[-2*prediction_length:], \n", + " test_dataset[ts_index][\"target\"][-2*prediction_length:],\n", + " label=\"actual\",\n", + " )\n", + "\n", + " plt.plot(\n", + " index[-prediction_length:], \n", + " np.median(forecasts[ts_index], axis=0),\n", + " label=\"median\",\n", + " )\n", + " \n", + " plt.fill_between(\n", + " index[-prediction_length:],\n", + " forecasts[ts_index].mean(0) - forecasts[ts_index].std(axis=0), \n", + " forecasts[ts_index].mean(0) + forecasts[ts_index].std(axis=0), \n", + " alpha=0.3, \n", + " interpolate=True,\n", + " label=\"+/- 1-std\",\n", + " )\n", + " plt.legend()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "015533fd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjEAAAGdCAYAAADjWSL8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAACtMElEQVR4nOy9eZwcdbX+/1T1Or1Mz75PJpM9YbKRQBZQgoQAGnK5eEGNRFEuIigYhMu9XPz6i3oNCLIoXFEQBQmIuMQLCiGsYckeGLJvk8ya2aenZ3pfqn5/dFf1Mr2v1T3n/XrNCzJdXV091V11Puc85zkMz/M8CIIgCIIg8gw21wdAEARBEASRDBTEEARBEASRl1AQQxAEQRBEXkJBDEEQBEEQeQkFMQRBEARB5CUUxBAEQRAEkZdQEEMQBEEQRF5CQQxBEARBEHmJPNcHkCk4jsO5c+eg1+vBMEyuD4cgCIIgiDjgeR7j4+Ooq6sDy0bPtRRsEHPu3Dk0Njbm+jAIgiAIgkiCrq4uNDQ0RN2mYIMYvV4PwPtHKC4uzvHREARBEAQRD2NjY2hsbBTv49Eo2CBGKCEVFxdTEEMQBEEQeUY8UhAS9hIEQRAEkZdQEEMQBEEQRF5CQQxBEARBEHkJBTEEQRAEQeQlFMQQBEEQBJGXUBBDEARBEEReQkEMQRAEQRB5CQUxBEEQBEHkJRTEEARBEASRl1AQQxAEQRBEXkJBDEEQBEEQeQkFMQRBEARB5CUUxBAEQRAEkZdQEEMQBEEQEsVkdYHn+VwfhmShIIYgCIIgJAbP8zg7ZMH+jhGYbK5cH45kkef6AAiCIAiC8ONwe3Dk3BhGzE4AwJDZgRKNMsdHJU0oE0MQBEEQEmHY7MCeMyNiAAMAA+OOHB6RtKFMDEEQBEHkGJ7n0TZoQcewBaESGKvDA6vTDY2SbtmhJJyJ6enpwQ033IDy8nJoNBosWrQIBw4cEB/neR6bNm1CXV0dioqKsGrVKhw5ciRoHw6HA7fffjsqKiqg1Wqxbt06dHd3B21jNBqxYcMGGAwGGAwGbNiwAaOjo8m9S4IgCIKQKHaXBwc6jGgfmhjACAxSNiYsCQUxRqMRF110ERQKBV5//XUcPXoUDz/8MEpKSsRtHnzwQTzyyCN44oknsG/fPtTU1ODyyy/H+Pi4uM3GjRuxdetWvPTSS/jwww9hNpuxdu1aeDwecZv169ejtbUV27Ztw7Zt29Da2ooNGzak/o4JgiAIQiIMjNux+8wwRq3RxbsUxISH4RPo3fqv//ovfPTRR/jggw/CPs7zPOrq6rBx40b853/+JwBv1qW6uho/+9nPcMstt8BkMqGyshLPP/88vvSlLwEAzp07h8bGRrz22mu44oorcOzYMcybNw+7d+/GsmXLAAC7d+/GihUrcPz4ccyePTvmsY6NjcFgMMBkMqG4uDjet0gQBEEQWaFj2IJT/ea4tmUY4DMzK6GUF76UNZH7d0J/jVdeeQVLly7Fddddh6qqKixevBhPP/20+PjZs2fR19eHNWvWiL9TqVS45JJLsHPnTgDAgQMH4HK5grapq6tDS0uLuM2uXbtgMBjEAAYAli9fDoPBIG4TisPhwNjYWNAPQRAEQUgRt4fD2SFL3NvzvLdLiQgmoSDmzJkzePLJJzFz5ky88cYb+Pa3v4077rgDf/jDHwAAfX19AIDq6uqg51VXV4uP9fX1QalUorS0NOo2VVVVE16/qqpK3CaU+++/X9TPGAwGNDY2JvLWCIIgCCJr9JrscHsSM7GjktJEEgpiOI7D+eefj82bN2Px4sW45ZZbcPPNN+PJJ58M2o5hmKB/8zw/4XehhG4Tbvto+7n33nthMpnEn66urnjfFkEQBEFkla4Ra8LPGbE4wXHk3htIQkFMbW0t5s2bF/S7uXPnorOzEwBQU1MDABOyJQMDA2J2pqamBk6nE0ajMeo2/f39E15/cHBwQpZHQKVSobi4OOiHIAiCIOLB7eHw0ekhHOgYwZFzJpwdsqDPZIfJ6oLTzaX1tYbMDlidntgbhuDheIxYnbE3nEQkFMRcdNFFOHHiRNDvTp48iaamJgBAc3Mzampq8Oabb4qPO51O7NixAytXrgQALFmyBAqFImib3t5eHD58WNxmxYoVMJlM2Lt3r7jNnj17YDKZxG0IgiAyicOd+E2GyF9GLE7YnB4YLS70jtrRNmDG4R4T9rWP4P2Tg3j3xAB2nxnGoW5TytmQziSyMAJUUgomIeecO++8EytXrsTmzZtx/fXXY+/evXjqqafw1FNPAfCWgDZu3IjNmzdj5syZmDlzJjZv3gyNRoP169cDAAwGA2666SbcddddKC8vR1lZGe6++27Mnz8fq1evBuDN7lx55ZW4+eab8Zvf/AYA8K1vfQtr166NqzOJIAgiVXpH7Zhaoc31YRBZYjCGaNbj4WH2uGG2u2EoUmBKuSap17E43EFuvIlC4t5gEgpiLrjgAmzduhX33nsvfvzjH6O5uRmPPfYYvvrVr4rb3HPPPbDZbLjttttgNBqxbNkybN++HXq9Xtzm0UcfhVwux/XXXw+bzYbLLrsMzz77LGQymbjNCy+8gDvuuEPsYlq3bh2eeOKJVN8vQRBETHiexzmTjYKYSQLP8xhOILBoH7agvrQIMja61jMcXcbkszAA4HBxMNlcMBQpUtpPoZCQT0w+QT4xBEEky0enh/DU+2fw8+sWoFKvzvXhEBnGZHVhX/tIQs+ZVa1POBvj8nD48NQQPCmWo6ZWaDGjSpfSPqRMxnxiCIIgJgO/eu80dpwcxP+1nsv1oRBZIFYpKRztw5aEg5Fzo7aUAxiASkqBUBBDEAQRgslnAd9jtOX4SIhskExQ4HRzCX0+eJ5H10h6Pk9muxu2JLqbChEKYgiCIEIQ2l8HaMVb8NhdHpjt7qSem0g2ZnDcAbsrfYFHMl1KPM/DZIs+oynfoCCGIAgiBCGIMVqc1Gpd4KTSspxINiaVtupwJFcCs2Lf2RHsbx/BwLg9rceTKyiIIQiCCMHmWzGb7e6Y04WJ/CZVfUk82Zgxuyvtn6NRqxMuT/wmfON2F84OmX3PdeFglwm72oZxbtSW1y7AFMQQBEGEIAYxDjeM5JBasHg4PuXzG082JpkRA7HgecTdFs5xPI6cGwMXEvNYHG4cPTeGj9qG0DlshTuBoEgqUBBDEAQRgNXhFm3mxx1uGC2UiSlUvLOIUt9PtGyMw+1B/1hmSjfxlsLODJmj6n4cLg4n+8fx4ekhnB4w51UJlYIYgiCIAAJX5ma7G5aAoIYoLNJl4e90c+iOYGLXY7SlJVAKx5DFEbMUNGp1omM4vkyQ28OjfciCnW3DeVNioiCGIAgigGGLP4ixuTxweziM2qikVIgMW9LXfdYxbJ2QjeE4Ht0ZbNP3eKKXwzwcj6PnxpCopa3Hkz9dTBTEEARBBBAqwDQ7SNxbiIzZXXC40pciCZeN6R+3ZzyLF61L6WT/eFLTsgHkzbRsCmIIgiACGA25eHt1MflxQSfiZygD06BDszHpMreLxtB4+M/mkNmRkllj6PdAqlAQQxAEEYAxNBNjd8PscCfUzkpIn6EUJklHIjAbM2p1YiwLJRm7y4Mxe/DruDwcjvWOpbRfk82VlhEJmYaCGIIgiABCbwhmhxs8P7HMROQvDrcnYwFGuy8bk40sjEBoVulE33jKpTKOQ17oYiiIIQiC8OF0c7A6gjUE477W1HxJrxOxyUQWRsDl5nB6wJxVR9zALqv+MTv6TOl57XzwSKIghiAIwofN6ZngkWF2eIOY0DITkb9kQg8TSNeINeGOoFQYt7thd3lgd3lSLiMFkg9aMApiCIIgfFhd7glpeMEkbNzuyhtHU6szuYGGhcjAuB3/PNgrnjuO4zGSBzfnRBkcd+BY7xjcnvRFT2N26etiKIghCILwYXV64AhpiR13eDMwPJ8fGgEAaBuwwJZka22hsfmfx/CdFz/GW8cGAHhbh6V+Y06GtkFz3GMI4oXjpF9GpSCGIAjCR2A5qUghA4Agu/Z8KClZHG4MjNsxbpf+sWaDcz59iNA1lOrAR6mSzgxMIFL/zFMQQxAE4cPm8sDuy8SU65QA/JoYQPqrUsA7x4fngbEos3ImE0IQKvw90p2tKHSk/pmnIIYgCMKH1emBwzfBukKrAhAcxEhdI2BzesTOlMDjnswIf4cxmwtmh5vKbAki9c88BTEEQRDwGoS53JyoiREyMeN2N3hfq0kmvTPSITYVsjAAqJzkQ/g7jNlcGe9KKkSkrouhIIYgCAIQZ8yEBjFujg8S+6bbO8Pt4XC4x4SPO4zoNSVvkGZ3eYKe73BxE9rFJxs8z4uZGJPNVbB6mEwjZV0MBTEEQRDwBgEAxHJSsVoBhYwB4De8A9K7Kh23u7C3fUQsAZ3oGxePI1E6R6zgQjrAzZNcF+Nwc3D5BK+jNlfedJdJDSmb3lEQQxAEgYmZGJWchV6lAOBvswaAMZsbXBo0Al0jVuxrHwlyCHZ7eBxNwqzM6ebCDvub7OLeQF2Q0eLMqgFdITFmk65HEgUxBEEQ8BvECUGMWiGDTi0HEJzR8HD8hPlKieDycDjYPYoTfeMTMicAMGJ2iu3A8dI5Yg0rvpzsmZjA909ZmOTheW8mS4pQEEMQBAGIXSuCjkQlZ6FT+YKYkE6fZDUCJpsLe8+OYGAsujbj1IA57i4al4dDV4SgZ7KLewPP2zh1a6WEVMW9FMQQBEEgXDlJBr0vEzNuDw1iEr+gdwxbcKBjJK7gxOPhcbTXFNd+u402eCIYnVmdHsmWAbJBYMbM6eYm9d8iVUYs0gyIKYghCGLS4+F4OH3BizA7SaWInIkx2Vxi23UseJ7H4R4TTvWbw5aPImG0uNA1Er2s5OF4dMbYZjL7xYSW06zkEZM0Up0dRkEMQRCTHkEPw3E8nB6/sDecJgbwZkrGbLGDA47jcbDbJHYfJcrpAXPUYY7dRitc7ug3ltAs0mQiNICjICZ5pKqLoSCGINLEB6cGceefWklAmIfYQkpJgK+c5MvEhNNTxCopuT0cPukaxWAKBmsejseRc2Nhsz4cx6NjOLYAOBURcr4zMYiZvAFdOjBKcPo3BTEEkSZ+s+MMtn7Sg9cO9eb6UIgEsYaIehkGUMiYiJkYIHoQ4/Jw+LhzNC0XfZPVFTZY6Rm1iSWwaEzmTEzoe6dMTGpI0fSOghiCSBNCJ0jbgDnHR0IkSqioVy2XgWGYiJoYILIuxu7yYH+7EWNpzMidGTIHHUO8WRjAO9U6Hb42+QiVk9KLFHUxFMQQRJqw+C6QZ4YsOT4SIlFsoluv9wKtlHsvjXq1z+wuTEnG7eEnlJlsTg8OdBhhSbOYluOAIz0mMWjqHbPH7ezL84B5kpZRQs+bZZL+HdIFz0svG0NBDEGkCavvxtU2SJmYfCPUI0btC2KETIzV6QlrJjca0HZqdrixP84W6mQYt7txdsgCnufRkWCgPFlLSqFlQJpgnTpS84uhIIYg0oSQuu4asU76wXv5BMfx/rlJgkeMQgYA0Kq8/+URXhQq6GJMNhf2t4+ImZxM0T5sQdugOeGyyGQ1vRMyZWqF91ZHmZjUSce09XRCQQxBpAGe58UbC8cDnXHqFYjcYwsoy9gD3HoBQM6y0Ci9gUy4bMaozYVhswMfdxrhjmA4l044DmgfSvyzNVkzMYIuqVyrAkCZmHRgdrjhkpAuhoIYgkgDTg8Hd0C5oW2QdDH5QmBWQzS6k/svjfoo4l6Xm0Nr12hEx1ypYLa74zbnKyRMPi+fcq0SgF+3RiQPzwOjEtLFUBBDEGkgcBIxQLqYfCJwdR5aTgIgtllHymbkQ2zg4fhJ2Zlj9pXRynXeIIZ8YtJDMmM3MgUFMQSRBkJX6WcoE5M3WF3+c+cIKScBgF7l7VDKd/v+yVhSEs5ZmVYIYiZfIJcJpGR6R0FMjtnVNox97SO5PgwiRUIvjmeGKBOTL8QqJ/kzMdJJoSdDvh9/MgjnVtDEUBCTHqSki6EgJofYXR7c+Pu9+Prv9lI3S54T2vVwZtAyKTUI+UjYcpI8oJwURROTT4xNskzMqNUp6tTEclKen0Op4PWLkUY2hoKYHDJqdcHh5mB1eiTXtkYkhqCJmVquAcN4W26H6ZxKHp7ng0zjRJ8YRUA5SV0YQUymMzFSC9oDh26WanxBjMsDTmLHma9IRdxLQUwOMTv8H4JhM93w8pnA2nt9SREA0sXkAzaXJ0iYa3dFzsTku6bE7eHjdvlNhv4xR1hDwFwxMO4NYtQKVjyHPI+Me/lMFqSy8KYgJoeYAzpaaNWe3whdD1qVHNMqdQCAM9ShJHlCNRLhhL26AsnEAJmdaN0zags7KDNXDPimhxcpZFDIGMhZBgB1KKULs10auhgKYnJI4Bd+xOLI4ZEQqSL4T2iVckyr0AKgGUr5QKj5mb/FOoxPjIRu0MmSqWyS3eWB0eLEuEMaJQbAn91WK7zDPAXTQhL3pg8p6GIoiMkhgSs7KiflN4JgUKOSYXqVNxND06ylj80VIYiRh/GJKYBMTKaCmHOjNgDSyVbZXR7xvRb5PH80Su95pNED6cNoyX3QmlAQs2nTJjAME/RTU1MjPs7zPDZt2oS6ujoUFRVh1apVOHLkSNA+HA4Hbr/9dlRUVECr1WLdunXo7u4O2sZoNGLDhg0wGAwwGAzYsGEDRkdHk3+XEiXwCy+V+iKRHMLUYq1SjumUickbJpSTXGHKSb5MjNPN5X0XYabEvYKIViq6oTG7SwxQ1WIQ4/0vjR5IH1L4PiSciTnvvPPQ29sr/hw6dEh87MEHH8QjjzyCJ554Avv27UNNTQ0uv/xyjI+Pi9ts3LgRW7duxUsvvYQPP/wQZrMZa9euhcfj/2OsX78era2t2LZtG7Zt24bW1lZs2LAhxbcqPcwBFxQKYvIboZykUclETUzniBVOd+5rxkRkQvUR4cpJRQoZZD49hcWR+4t2KjhcXNo/k6NWpxgMSiUTM253w+47pqKQIIZGDxQW8oSfIJcHZV8EeJ7HY489hvvuuw/XXnstAOC5555DdXU1XnzxRdxyyy0wmUx45pln8Pzzz2P16tUAgC1btqCxsRFvvfUWrrjiChw7dgzbtm3D7t27sWzZMgDA008/jRUrVuDEiROYPXt2Ku9XUgR+mUjYm98IN0OdUo7qYhW0ShksTg86RyyYUaXP8dER4Qhtrwb8QYw6oJzEMAx0KjlMNhfMdrfo/pqvjNtdKNep0ra/c6P+VmaPh4fV6RZLN7li3O4WMzFFyuByEgl7C4uEMzGnTp1CXV0dmpub8eUvfxlnzpwBAJw9exZ9fX1Ys2aNuK1KpcIll1yCnTt3AgAOHDgAl8sVtE1dXR1aWlrEbXbt2gWDwSAGMACwfPlyGAwGcZtwOBwOjI2NBf1IncDU67CZhL35jLBC16jkYBhGzMbQIEjp4nBz4EKSEvYw5SQgoM1aQsLVZElnycfD8egftwf9TgolpXG7SzyXgucPCXsLk4SCmGXLluEPf/gD3njjDTz99NPo6+vDypUrMTw8jL6+PgBAdXV10HOqq6vFx/r6+qBUKlFaWhp1m6qqqgmvXVVVJW4Tjvvvv1/U0BgMBjQ2Niby1nKChTQxBYNfE+O9UE6r9OliKIiRLKE3Mw/Hiw6vgcJeIMDwTgI36FRJZ5AxMG6fMME710GMw+2Bw8X5MzFCOUlFQUwhklAQc9VVV+GLX/wi5s+fj9WrV+Of//wnAG/ZSIBhmKDn8Dw/4XehhG4TbvtY+7n33nthMpnEn66urrjeUy4J6k6iICavEToeNL4V+7QK8oqROhP1MP6bW6AmBgjMxBRCEJO+bFJgKUkg17oYIYiaIOxVUDmpEEmpxVqr1WL+/Pk4deqUqJMJzZYMDAyI2Zmamho4nU4Yjcao2/T39094rcHBwQlZnkBUKhWKi4uDfqRO4Ipl3O4mEWgeI6zudL7V3vQqbyamjYIYyRLJI0bG+I3RBAopE2N1euBOg0mZ3eXBaBifkFwPmhSuq3an9z1SJqawSSmIcTgcOHbsGGpra9Hc3Iyamhq8+eab4uNOpxM7duzAypUrAQBLliyBQqEI2qa3txeHDx8Wt1mxYgVMJhP27t0rbrNnzx6YTCZxm0LBErJikYJxEJEcwrkUxINiJobarCXLxPZq701PKWcnZH0LKRMDpCdb0muyI9wYokx0QCXCmM0bREVqsbbmeYcZEUxCEvK7774bV199NaZMmYKBgQH8z//8D8bGxvD1r38dDMNg48aN2Lx5M2bOnImZM2di8+bN0Gg0WL9+PQDAYDDgpptuwl133YXy8nKUlZXh7rvvFstTADB37lxceeWVuPnmm/Gb3/wGAPCtb30La9euLajOJGDihWTY7ER1sTpHR0OkgiDs1fqCmGafV8yo1YURizPvO1oKkYlGdxOHPwro1QoAuS+VpItxuxslmtQ+k70+g7twmB1ulMlz85kPLScJwYuWupMKkoSCmO7ubnzlK1/B0NAQKisrsXz5cuzevRtNTU0AgHvuuQc2mw233XYbjEYjli1bhu3bt0Ov97eYPvroo5DL5bj++uths9lw2WWX4dlnn4VM5hfSvfDCC7jjjjvELqZ169bhiSeeSMf7lRShmZhhGj2Qt/g1Md7PcZFShvqSIvSM2nBm0IwybVkuD48IQ8SRAyGiXiBwCGT+dycBqYtvA71hwpGrVnSXhxO7kuyRMjFUTiooEgpiXnrppaiPMwyDTZs2YdOmTRG3UavVePzxx/H4449H3KasrAxbtmxJ5NDyEiE1XaJRiCt2Iv/geT5AE+P/Sk2r1KJn1Ia2QTOWTqUgRkrYXZ4JE5fF9uowmRjhvBZKJibVQZDhBL3p3H+yCKUkABO7k8RMDAUxhQTNTsohgkiwqUwDgOYn5SsONyfeEIXVHgBMF6dZky5GaoSznneKmZhw5aTCEfYC3pIKx4URtMRBOG+YUHIV7AVmmIRzHOoT4/Rwkpi+TKQHCmJyhIfjxZVCoy+IoUxMfhJYFgx0KhW8YsjwTnpYXRODGHu0cpLan4nhwqlZ8wyOA8xJakMGxx0TvGFCSSVISgUhiHF5ONHzR3DsFTIy3uOjbEyhQEFMjghcqTSV+zIxFMTkJdaAFZ8soDVXzMQMUZu11AiXiQk3/FFAKCdxfOEMEExWF3POFFnQK5BKkJQKgmYpcJyEMEKCZRkxkCmUc0hQEJMzhNW7UsaixteRNELC3rxEEPUG6mEAfyamc9hK6WuJETaIiVJOUshYsSxRKLqYZEpjdpcHxjgXW9kuvbk9nLigsLv855INWFj4h0AWxjkkKIjJGcKFUKeWo0zrHcZGmpj8JNQjRqCmWA2NUgY3x6NzxJqLQyMiEK7N1j/BemI5CQjsUCqMG2AynVaRvGHCke1gL0gPEyLqFRCCGMrEFA4UxOQI4QunVclQrvO2IpImJj8Rhz8qgy+YDMOIfjEk7pUWoR4xQIBPTJhMDFB4HUrjDjf4BPU90bxhJuw/yx1KgUGM2F6tDA1ivOeQMjGFAwUxOUJYvetUCpT7/BRIE5OfWCOUk4DADiXSxUgFp5uDO4ww1R7g2BsO0fCuQDIxHg+fkMA1ljdMKNnOWAW2dQvHOSETQ6MHCg4KYnKEsJrTq+SiKZTJ5iLtRB4iZmLCBDH+DiUKYqRCuHk/gL/FWh2rnOQoDMM7ILFAI5Y3TChuDx8ksM00YTMxIZ4/GgUFMYUGBTE5QghitCoZSjRKCKNaaH5S/iGkprXKiTe/aeQVIzmGImjP7O7I3UlAQJt1gWRiAMAcZ0Dm4XgMxPCGCUe2TO88HB+kc4qoiVHR6IFCg4KYHCFcCHVqBWQsg1IN6WLyFb8mJkwmRtDE0CBIyRBpvIfDFdknBvBmTYHCGQIJAD2jdhzuMaF9yIIhsyNi5mRw3BG2BBeLbAV8Zrs7SHAcOnJAgIZAFh4JjR0g0ofYneSr0ZZplRixOKlDKQ/xa2LCZWK8QcyIxQmjxYlSGgSZU8bsLjFYCUUQ9oYbOwAEG94VCi43hz5TcIZFLmOgV8uhUymgU8uhU8rRk4CgN5Bs6WJCMz6hwx8FtDR6oOCgICZH+IW93lNQrlXiNEjcm49E08RolHLUGdQ4Z7LjzJAZS2gQZE6JtkiI5hMD+DMxhVROCofbw8NoccFoSb0UlK2ALzRYsjvD65uKxCGQhX0OJxNUTsoR4wHdSQD8bdZmMrzLN4SANJwmBvDrYmj8QO4ZivL9EjI06gjlJCETU0jlpExjc3rgzkKzQqRMTKgmRiua3VEmplCgICZHWAKEvQDEDiXSxOQfgrA3nCYGAKZXkleMFHC6uaApx6EIwt6ILdaqwmqxzhaZzsZwIaJewB/ETNTEeL+jZHZXOFAQkyOEC6EwHVd07aUgJu8Q6uvhfGKAwEwMtVnnkhGLM6rbbLwt1jZXdrILhUKmdTHjDje4kNNhj+HYS2Z3hQMFMTliXMzE+DUxAGVi8hFx7EAYYS/gF/eS4V1uiVZKcgdMPY6kidGoZKIVQiGJezNNxoOYMG3ctkg+McLYAZenIKaRExTE5IwJwl6fJoa6k/IPv09M9ExM54iVVvA5guf5qFlOQdQLRA5iWIYpuNED2SDT4wfCBUl2wbE3wtgBnkdWjfiIzEFBTI4QHXvFcpIweoCEvfmGNcLsJIHaYjWKFDK4PDy6jMm1qhKpMWZzw+WOHEAKQYyMZSCXRb4sFtoQyGxgcSY+oykRwp2LSMJepZyF3DfVmnQxhQEFMTnCMqGc5NXEUDkp/xAzMRE0MSzrHwTZNkAlpVwwGKPrzxHDrVeAMjGJw3GZ6wbieT6s63CkIAYI1MVQEFMIkE9MjhBWD8JFUcjEjNpc8HA8ZL7VAiF9hExMpCAG8OpijvaO4cyQGUB1lo6MEBiOFcTEaK8W0Bfg6IFsYLa7IwrfIzFiccLl0yq5PRxcHh4ejhd/5+E4ON38BFGvsC0QXqStUckxZneTV0yBQEFMDnB5ODF9LXyxSzXe9k2e985PqtCpcnZ8RPzwPB91dpIAzVDKHXaXJ2b5R2yvjuDWK0CZmOQYt7tQY1DHvf2Q2YHWztGkXsse4MgcNoihIZAFBZWTcoAl4AIorN7lMhYlvkCGSkr5g93FwdfUEtaxV4C8YnJHPLYFYnt1rHKSmjQxyZCIQSDP8zidQtlVKCUp5WzYjLbQRUhBTGFAQUwOEC6AagULRYCIUGizjtYKSkiLQL8JTQR/EQCYTl4xOSNWKQnwr94jDX8UEA3vKBOTEImU3/rG7CmV6yJ5xAhoFDTJupCgICYHWJzBehgBEvfmH4GdSWwUHZMg7B22OGGyZrbllPDDcdFbqwViDX8U8I8eoHOYCE43F1dLM8fxaBtILVsZTdQL+F3SKRNTGFAQkwPM9vBBDI0eyD+EFXmkkQMCWpUcNcVeTUDbEGVjssWozQWPJ3Z7b6zhjwKTZQhkJogne9VltKbs3xLJ6E5AHALpoCCmEKAgJgeEuvUKlJHhXd5hFduro5chAGB6Felisk08pSQgMIiJfh6FTAyVkxInlo7I5eFwdij174ZodBcpE+NbcNDogcKAgpgcEOrWK0CjB/IPwWsikltvINMqSBeTbWL5wwg4YqzeBfQBZneZNHArRGJlrzqGLXDHkTWLhZiJidAtKGRiyOyuMKAgJgeEDn8UoHJS/mF1xJ+JoRlK2cXm9MRdMrD7MjGRJlgLCAsPN8cHjSogYhNNR2R3edA1kh4365iaGMrEFBQUxOQAc4RyUrnPG4a6k/KHeDUxgL9DicpJ2SGR75G/xTp6MKpSyKD0dRRSm3Vi2JweeLjwmZYzg5aIjyWK0GkWsTuJMjEFBQUxOcBM5aSCQehwSCQT0zFMgyCzQTxdSQKCmDSWsBcgw7tk4fnwJSWLw41eU/pmisXKxNDYgcKCgpgcQN1JhUOsCdaB1BmKoFawcHo4dNMgyIzCcTyMCXyPRGFvFK8fAb/hHbVZJ0q4ktLpATPSKS8SMizh3HoBf9aUMjGFAQUxOSCyT4w3iDFaneDSlFolMks8c5MEWJbB1HKfLobarDPKiNWZUHki3gGQQECbNWViEia0BDdqdWJwPL3lc9HsLoKwV8jEOD0cXJQRzXsoiMkB4vDHEGFvqS+I4XivvwUhffyamNgreACYXkW6mGyQqE1BvD4xALVZp0Lo3yyV8QKRiMcnRrClJMO7/IeCmBxgiSDsVchYFPsukCMWEvfmA36fmPhmqU73OfdSm3VmSVQcL06xjqecFNBmTSSG2eFvTR8Yt2M0A+7VscYOsAwjnmcaPZD/UBCTA4TViD7Mja9C7FAiXUw+4PeJiS8TM02coUSZmExhcbgT1jsI5aRYLdaA3xqBXHsTx+PhYXN5wPOpjxeIhD8TE/k7SaMHCgcKYnKAsIILt3oncW9+IfjERJtgHcg0mmadcZJxvHbE2WINUHdSqozb3ThnsosZ6XQjtlhHWVgUKSiIKRQoiMkBorBXHTmISaQ9lMgdFkf8jr2APxMzZHbARLqnjBCvS68Az/NiOSnWAEiANDGpYrK5Mmr4aIsxdgDwLyCpnJT/UBCTA0TH3jCr93Lf/KQRKiflBUJAqonDJwbwruKFQLXPZM/YcU1W3B4OJlti3x03x8Pj02nE152kAECamGTpNlrFoDHduDkOTk9sfRMNgSwcKIjJAZEce4HAchIJe/MBIR0d2i4fjQpfoJru1lLC21rNJXh/DBwfEI8mhjIxqZHo+UkEe0BwFG0OFo0eKBwoiMkyDrcHLt+Qs/DlJK+wl8pJ+YElwRZrIFC8TUFMuhkaT0IP4xOCylkGcjZ+x16Lw01+ThJD6ExSytio55KGQBYOFMRkmcCOhnA6CmGVnow4kcg+Yrt8nJoYgIKYTDJqTUHUG0d7NeDvbOFBK3mpEcsjRkBLowcKBgpisowgBNUoZZCxzITHqTspf+A4HlbfRTNeTQzgD2ISFaASsfEk4V/viHOCtYCcZcXMG+lipIXdGd2tV4BGDxQOFMRkGWF2SCQNBXUn5Q92t0ec+ZKQJkbvPcfJlD6I9CN4xKjjDGIAGj0gVWINfxTwD4Gk85fvUBCTZSINfxQo92liaH6S9BGyagwTn7+IAJWTpIXdFf/wRwH/EEi6CUqJeIzuAH8QQz4x+Q8FMVkmmkcMAJRqve2bHo7HGE3JlTSiqFchAxumNBiJSgpiJEUiwx8FhDZrysRIC9HoLmYQQz4xhQIFMVlGdOuNIARVyWViqppKStLG7xETfykJoEyM1Ehk+KMAtVlLE0HjQpmYyUNKQcz9998PhmGwceNG8Xc8z2PTpk2oq6tDUVERVq1ahSNHjgQ9z+Fw4Pbbb0dFRQW0Wi3WrVuH7u7uoG2MRiM2bNgAg8EAg8GADRs2YHR0NJXDlQRCCSJSJgYIMLyjIEbSJOMRA/g1McNmKhlKAdGtN4GSoH8IJGVLpUSs4Y8CmoAWay4JMTghHZIOYvbt24ennnoKCxYsCPr9gw8+iEceeQRPPPEE9u3bh5qaGlx++eUYHx8Xt9m4cSO2bt2Kl156CR9++CHMZjPWrl0Lj8cfFa9fvx6tra3Ytm0btm3bhtbWVmzYsCHZw5UMZp+wN5xbr4Ao7qWVuqRJxiMG8Oue3BxPowckgCjsjWPkgICeMjGSRBT2xvhOCkajPPyBD5GfJBXEmM1mfPWrX8XTTz+N0tJS8fc8z+Oxxx7Dfffdh2uvvRYtLS147rnnYLVa8eKLLwIATCYTnnnmGTz88MNYvXo1Fi9ejC1btuDQoUN46623AADHjh3Dtm3b8Nvf/hYrVqzAihUr8PTTT+Mf//gHTpw4kYa3nTvMUYY/CpDhXX6Q6NwkAaWchaHIq6mgklLuSbTFGggYAknCXkkRr0+MQsZC7tOxUUkpv0kqiPnOd76DL3zhC1i9enXQ78+ePYu+vj6sWbNG/J1KpcIll1yCnTt3AgAOHDgAl8sVtE1dXR1aWlrEbXbt2gWDwYBly5aJ2yxfvhwGg0HcJhSHw4GxsbGgHylijqecpKX5SflAonOTAhFHD1AQk3OEclIiHWZidxJlYiRFvC3WQOAQSApi8pmEg5iXXnoJH3/8Me6///4Jj/X19QEAqqurg35fXV0tPtbX1welUhmUwQm3TVVV1YT9V1VViduEcv/994v6GYPBgMbGxkTfWlYwx/CJAYAyHXnF5APWKDOwYuEX99I5zjV2oTspkXISZWIkiT2OCdYC4hBI6lDKaxIKYrq6uvC9730PW7ZsgVqtjrgdwwS3m/I8P+F3oYRuE277aPu59957YTKZxJ+urq6or5crRGFvlBtfObn25gWCZbk2QU0MAFTofUEMDYHMOf7upMQzMaSJkRZiOSmO76Q4eoAmWec1CQUxBw4cwMDAAJYsWQK5XA65XI4dO3bgl7/8JeRyuZiBCc2WDAwMiI/V1NTA6XTCaDRG3aa/v3/C6w8ODk7I8gioVCoUFxcH/UgRIf0cNYih7qS8wC/sTTwTQ14x0iEZnxjh++twc3C6MziWmUiIeH1iABoCWSgkFMRcdtllOHToEFpbW8WfpUuX4qtf/SpaW1sxbdo01NTU4M033xSf43Q6sWPHDqxcuRIAsGTJEigUiqBtent7cfjwYXGbFStWwGQyYe/eveI2e/bsgclkErfJV8y+lsx4hL10g5M2ybZYA35NDJ3j3CO2WCdQTipS+GefUTZGOiSkifEtPmj0QH6T0NVXr9ejpaUl6HdarRbl5eXi7zdu3IjNmzdj5syZmDlzJjZv3gyNRoP169cDAAwGA2666SbcddddKC8vR1lZGe6++27Mnz9fFArPnTsXV155JW6++Wb85je/AQB861vfwtq1azF79uyU33QuEVKX+niEvZSJkTRiJiYpYS9pYqSCOMU6gXISwzDQqeQw2Vww292iLQKRW+xxjh0Agr1iiPwl8SVkDO655x7YbDbcdtttMBqNWLZsGbZv3w69Xi9u8+ijj0Iul+P666+HzWbDZZddhmeffRYymf+D98ILL+COO+4Qu5jWrVuHJ554It2Hm3XMcYhBhQui0eqMS09E5AarM7kWa4Bce6WEUE5KpMUagBjECENdidzi4XgxII0nE6OhTExBkHIQ89577wX9m2EYbNq0CZs2bYr4HLVajccffxyPP/54xG3KysqwZcuWVA9Pcpjj0MQIQYzLw2PM7hY9RQhpYU7S7A4gYa+USKbFGggwvKMOJUkQaFoXj3EhjR4oDGh2UhbheV688UUrJ6kVMlE5TyUl6SK0ZqamifFm24jcIXYnJaCJAQJGD5AmRhIIQYxCxkAuoyBmskBBTBaxuzh4fLNyYnmLlPvKDSMWWqlLFUHflOgASMBfTnJ6OIzRSj5n8Dzv94lJsJxEowekhS0BPQxAk6wLBQpisohwsWMYQBPjiyaUlEj4KV2Ei18yPjFqhX9aOelicoeb4yEkwhLxiQECh0DSTVAKJNKZBFAmplCgICaLiKJepRwsG12sSx1K0kcYIZGMTwxAuhgpEKijSDwT49WqUSZGGogeMXEuKrRiJoaCmHyGgpgsYolD1CtQRkGM5ElFEwME62KI3CAOf5SxMRcWodAQSGlhS2DkAEBjBwoFCmKyiJB2jjb8UUCcn0Q3OEnCcby4gkvGJwagNmspkMwEawG9OASSWqylQKKaGK3ve+vy8HB5yHU5X6EgJovE4xEj4C8n0Q1OitgCyhDJ+MQA/iBmkMpJOcMh3vgSvxRSJkZa2BPUxKgVMgi5N6vTA8bjBOu2Z+joiExBQUwWEcpJ+riCGO8NjiZZSxPhXLJMcjdAgDIxUiCZ4Y8CgUMgqU0+99gSDEhZhvHPT7LbsfTdr+Cif14KhX04Y8dIpB8KYrLIuJiJiX3BpHKStLEEuPUm66hcqacgJtf4g5jkMzEcH5yZI3JDopkYwN+hVNv9Ogwjh6ByDKPu7F8zcnxEZqAgJov4hb2xHXipO0napDI3SUAQ9g5SoJozhHJSMkGMQsaKN0z6nuYeUdibgOWBRikHCw6L258Wf1d/9mWAJ41MvkBBTBYRaufR3HoFAruTKFUtPSwB7fLJQi3WuccuuvUmF4w2lhUBANqHrWk7JiI5EhX2At5MzFp2N8psHXApDXArdNCYO1E6sDtTh0mkGQpisog5gXKSoIlxejjyoZAgqXYmAUBlgCaGAtXc4EjSrVeguVwLADg7ZEnbMRHJkajZHQBoFQxul28FAHTOvBG9U9YBAOrP/Cn9B0hkBApisog5gXJSkVJGqWoJY3GmIRPjC2IcbgpUc0UqmhgAaK6gIEYqCGZ3iWRiVnl2YSbbAyurQ+fMr6Fn+pcAAFU9b5HAN0+gICaLCOUkXZyr93JB3EtBjOSw+tx642mXj0SR0j/okwzvcoMwwTrZcpIQxPQYbXC6SUeRSxLOxPAcrh1/AQDwluGL8Cj1MJfMhalsAVjOhbr2rZk6VCKNUBCTRYTVezxmd4Bf3EsdStJDyJxokpibFEgFdSjlFKGcpA7JxNS3vYTlb6yFbvR41OeXaZXQq+Xw8Dy6jKSLySX2BB17q3reRL2rHWN8Ef5RtE78fc80bzam/syfACrzSh4KYrKI6NgbRzkJCBT30g1OaljTUE4CArxiSNybE8I69vIcmo/+L3Smkzhv73+C4SI78jIMQyUliSBmYuJZWPAcmo88AQD4vedKDLmLxIf6Gz8Pt1wLjbkDpYN7kjsYnqMOpyyR2hWYSIhEhL0AUEaGd5JF9IlJoZwEBM5PoiAmFwjlJHWA2V3xyEGobf0AAP3oMTSdeAbtc78dcR/NFVoc7DZREJNDOI4XA9J4zO4qz70NvekEHKwGv3NfhdqAIZAehRZ9TevQ0PZH1Lf9Ccaq5Qkdi37kMJbs+BrkLjM4VgFOpgLHKsHJVPCwKvAyJTy+f7sVevQ2fxED9WuAJP2mJjsUxGQRv2NvfJkYQRMzQuUkyWFNMCCNhDh6gM5xTrAL3UkBN76q7u3ex4pqoLb1ofnIExiovxzW4ulh9yF0KLVTEJMzhPMIxCHs5Xk0H/lfAEBr7fUwtelgCJlk3TPtejS0/RFVPduhcIzApSqL70B4HnM+/hHkLjMAgOVcYKNk8gCgsvc9mEpb0LbgLoxUXxTf6xAiFMRkEUHYG38mhgzvpIrZJ+zVpKucRJmYnCAKe4VMDM+jqscbxJxcdC/qzv4FFX0fYN7++7D/0hcBZuIqf6oviOkfd8DscCc91ZxIHsHoTs4yUMiiZ2Iqzr2D4tGjcMs1ONb8NaCtb8Ik6/HS8zBW2oJi42HUtv8dnbO/Gddx1HS+CsPIp3DLNdi7+i/wyLVgPQ6wnNP7X48DMs4BxuOEjHNCbzyCxlN/gMF4GOfv+AZGqpbj9Py7MFa+MLk/xCSENDFZgud5mJMV9lIQIzlETUyqmRgyvMspoT4xOtNxaMyd8MhUGK75LI4v+THcci1Khj5Gw+kXw+5Dp5aLIyQ6hikbkwuE9uqYehiex7Sj3ixM94yvgtWUA/D7PgXSM+16APELfFm3FTMOPgQAaJ9zC6zFM+DQ1MKmnwqLYRbGy+bDVLkUI9UXYbjuUgw0XIG2+d/HR59/G50zvwaOVaBsYDcufPs6LPjoNmhNp+J+/5MZCmKyhNXpEb8HiZaThknYKzkCZyelQiVpYnKK6BPjKycJpaTh6ovhUWhh19bj9Py7AAAzDj0MleVc2P2Q6V1uidett7z3PRQbD8MjK0LHrJtETZvN6QEXEqj0TVkLt1wD7fhZlAztj3kMU4//FmpbP2yaenTO+kbcx+5Sl+Pk4h9g51XbcW7qteAZFlU9b2H59qsxb+9/Qm3pjntfkxEKYrKEOYmpx4KwlzQx0iPdmhjyickNohjUV06q6nkTADDYsEbcpnvGeoxWnA+524K5B34YdlVOHUq5Ja7hjzyPaUe9HUldM74Kl7pMtEjgA/Yh4FHo0DdlLQCgvi26g6/K2oumE78FAJxaeA84uTrx96Ctx9ELH8DuNf/AQP0aMDyHuvatWPn6FZhy4ncJ72+yQEFMlvC79cY/9TiwnES29NLC7xNDmph8RignKeUsNONnoTOdBMfIMVj3Of9GDIujS38KjlWgou991HS+MmE/gUEMfVezjzUOj5jyvg9gGDkEj0wtalwUMhYKmfd6bHGEKyn5HHy7t0HhMEbc94yDP4fMY4exYikGGq5M+n0AgMUwAwcvegJ7V/8Fw9UrwXIuzDz4IOTOsZT2W6hQEJMl/G698d/0BGGvw82FrdkSucMqtlinRxNjdXomiAuJzMLzvL/FWiFDpa+UZKxaDrfSELSttXg6zsz7LgBg1ic/nWBJ31hWBJYBxuxuGK3Ru1GI9BMzE8PzaPZlYbqnfwVOdYX4kLAQsYW5xo6XtmCsZB5knBM1Hf8XdteGoU9Q2/kqeDA4uei/09YqPVa2AJ9c8iws+mlgeC55z5oCh4KYLCG0V8cr6gW8brCC4JA6lKSFX9ibWiZGq5SJ5cWhcTrH2cTp4SDkTFRyVuxKGggoJQXSMeffMV4yB0rnKGZ/8pOgx1RyGepLvIZpVFLKPqImRhn+llbWvxMlw63wyFTomP3vQY8JJSVLuEUEw0R38OU5zGr9KQCgd+q1GC9rSeVthGWkeiUA73sgJkJBTJYYdySeiWEYRiw3UIeStBBSz6kKewPP8SCVlLKKkIUBgGJnHwwjh8CDwWDdZWG351kFjl5wPzhGhpqu11DZ81bQ46SLyR1RMzE8j2lHHwcA9Ez7MpxFlUEPC0FMpGx3X9PV8MiKoBtrg2HoQNBjNR2vwDByEG65Fqfnfz/VtxEWCmKiQ0FMlvB7xCR20ysT5yfRDU4qeDheXPmlOjsJIF1MrggcOVDtC0hGK5ZMuMkFMl56nqinmP3xpiCdAgUxuSNad1LpwC6UDH0MD6tE+5x/n/C4UE6KVM71Cny/AABoOOMX+MpcFsw49HMAwNm53476uUmFkcpl4BkW2vGzEbvjJjMUxGQJIVWpT6CcBAQEMZSJkQyBF7tUy0kABTG5ItAjJlYpKZAz826HRTcVatsAZhx8UPy9EMS0D1vAcSTuzSaiT0yYIGbKqecBAOemXQ9nUfWEx2NlYoAAgW/X65A7RgEATSd+C7VtAFZtA7pm3ZjK4UfFo9TDVLYAAFA2sCtjr5OvUBCTJYThj4mWH8rJtVdyCBc7GcuImqVUqNT7vGJIE5NVhExMnWwcJYNeH5DB+stjPo+Tq3HsAq8OouHMyygd2O3dj6EIKjkLh5tD35g9Q0dNhMMWoTuJ4dyiIPbc1H8N+9x4gpixsgUYL5kDGedEbccrUFt6xJbq0wv/E5xMlfJ7iMZIFZWUIkFBTJZIRtgL0OgBKWIR26tlcbfLR4MyMblB0MR8jtkPBjzGSltg19bH9dzRygvQNX09AOC8Pfeg7syfofBYMaVMA4BKStnGL+wNDmJ0o8cgd5nhVugwXjIv7HO1McpJACYIfGccfAgyjwPGygu8wxszTJAuhlr4g6AgJkuYxeGPCQYxgmsvmaFJhnSJegUoiMkNQjnpUt6bSYmnlBTI6QV3w6ptgNrWh3n778NnXr0Y9+G3mMe0UxCTZSIJe0sH9gIAjBUXAGx4/VpRHJkYAOidsg4emRq6sVOo6XrN11J9X1amT5vKF8EjK4LKMQyt6WTGXy+foCAmSyQr7K0QXHtp9IBkEPRNmhQ9YgTE7iSan5RV7G4OxbDgfM9BAEh4Re1R6LBv9V9xasE9sOqaIHdbsGrsFbym+m/8Z/dtqDvzMmQuCmaygV/YG3xLE0pJxqoLIz7Xn4mJHsR4lHr0N35B/Pe55i9ivDR8difd8DIljJUXAADKpVJS4jlUHHoasJtyehgUxGQJc4rlJBL2Sgch7ZyuacUVND8pJzjdHC5jP4YcHpiLZ8BaPC3hfbhUpeiY8+/YedUbOHDJc+iovRJOXoa53CnM2/8DfObVizFn/w+hNx7JwDsgBMJlYhjOjVLfzCNj5bKIz/VnYmKbTXZP/zIAwC3Xoi1DLdWREEtKA9IIYurO/g11e/4HeOpSwJM7o06aGZ8lzEn4xABUTpIiQjkpHe3VQMAkazrHWcXu8uBK2T4AwEDDFantjGFhrF6Bkarl2PDnD3CF6x18p/hDlNg60XDmJTSceQlDNZ/FoeWPwqPUp+HoiUDCtVgH62HmRnyu4Lodjyv6WPlCfPKZp+BUVwW5/mYDIYgpGdwHxuMEL1Nm9fUDkTvHxPZyLP0GIMtdKEGZmCxhSTKIoe4k6SGcy3RrYswO94QhdETm4J0WXMJ+CgAYiKMrKR4YhkFJeS2e9qzFz6ZvwYFVf0Bf4xfEuUsXvPNl8vpIMxzHiy3WgQuLePQwAKBRxFdOEhiuXZW1MlIgZsMsOFTlkLutMIx8mvXXD2TakSegdIzAbpgOXHhLTo+FgpgskYxjL+AvJ9lcnrCzPYjsY/GdB02ayknFajmUMu9XkXQx2WOGaTfUjAuD8lqYo6zUE2WqYHo3YoWxajkOr3gU+y77MxzqKujGTuHCt6+n8lIasbv918XATEw8ehjAr20TFieSxZftA3Lbaq01nUbDaZ/3zopNgDx3GSGAgpiskaywV6fy3+CGSdwrCaxiQJqecpJ39ADpYrLNQvP7AICD+s+ktcMknHPveOk87F39Z5gNs6CyD2DJu19F+bl30/aakxkhCyNnGSh818p49TCAP3vj5ni4PFzUbeNl3O4Cl4FW6Jz7xfA8Zn3yE7C8BwN1l8Hc8NncHEcAFMRkCSHKT9Sxl2EYlOuopCQlxExMmspJAOlisg3jcWKhzbtSP1ayKq37nlru9YrpH3MEre4dmlrsu/SPGK5eCbnbikUf3Yr60y+m9bUnI6noYYTnCSFsOrIxZ4cs+P7Ln+KFPZ0p7yuUYZ8upnjkIGTO8bTvPxaVPdtRPrALHlaJU4vuzfrrh4OCmCzAcbx440vGpt4/P4lucFLAr4lJTyYGIK+YbFM2sBMa3op+vgT9+vROHtarFaj0nc/24eAWa49Sj9bPPI1zU78Ihucw9+NNmPHpgwCfngzAZCRcZ1K8ehgAYBkmbq+YeDhyzgQewKmB9AcZDm0dLLqpYHkPSgf3pn3/0WDddsxqfQAA0DH732HTTcnq60eCgpgsEDjiPZm2XGqzlhbC+UzH3CQBsZxEmpisUNXtnZX0hucCKBWKtO8/2jBI7zTszWhr2QgAmHrit5i/606wHjr3ySBoBQM9YuLVwwjEM3ogXrqMNgDerCqfiZJSjqZaN514GkXWHtg1tWifm1sxbyAUxGQBob1aIUtu1o6/Q4kuclLA6kivsBdIPhMzZnfBQ8MGE4Lh3Kj0Ta1+nbsQKkX6L4NTK7wlpfZha4SDYHB23m04vOwhcKwC1d2v4/z3vg6FYyTtx1LoCOUkIZuSiB5GINYk60ToGvGec6ebE2fmpZNc+MWoLT2YevwpAMDJhf8JTl6UtdeOBQUxWSBQ1JvMrJ0yn2svZWKkgZiJyUg5Kf5z/GnXKBb/+E08uO142o5jMlAytB9K5yhM0GEvNyctQzxDCczERFuN9zX9Cz757O/gUhSjZPhjXPDWv0E3eiztx1PI2ELKSYnoYQTSlYmxuzxBHYaZKA8bq5aBZ1joxtqgsvalff/hmPnpA5B5HBipXIaBhquy8prxQkFMFkjW6E5AFPaSJkYS+AdApl/YO5jARe/tY/3wcDzePNaftuOYDFR1vwEA2MFcCA9kUMnTF4wKTCnTgGUAk80Fo9UVdVtj1TLsu+wlWLWN0Fi6ccHbX0J15z/SfkyFij1E2JuIHkYg3tEDseg22hAYsmZCqO9WGjBW6tVxZSMbU9q/E9Xdb4BnWJxY/IOszIpKBApiskDKQQwZ3kkK4UKXrrEDAEQhaCIrt6O9YwCA9iELmeTFC8+hsudNAMB23juLJhPlJJVchvoSb8o9nmGQ1uIZ2Lv6rxiq+QxkHjvm7/4+ZrY+AIbLvXcJ63FA5jLn+jAiImhihExMonoYILHRA9EQSkkCmRLqZ0sXw3AuzP7kpwCA7unrYSmZndHXSwYKYrJAsm69AuW+G1znSIT6OpFV0j0AEgAq9YkLe4+c8wYxHA+c6pfuTUZKVJx7F2rbANxyLXa4zwMAqDOQiQGii3vD4VaVoPXip3B2jlc02XTyd1j0/k251cnwHJa8+1Vc/M9LobZ05+44oiD4xKgVsqT0MIC/NJxqJqbL6L1Gy1lvtiLzQcwuIAPiYYGG0y9CN3YKTmUJ2lq+l7HXSQUKYrKAIO5KdPijwJKmUijlLE4NmPFp12gaj4xIBkHYm66xA4BfEzNmd8Phjn0hHbE40Wuyi/8+3jeWtmMpWDgPZhx6BADQNX09xt3e85cJTQzgd+4NbbOOCitD24K7cHDFL+GWa1A+sAsXvvlF6I1HM3KMsSjv3QHDyEEonCY0Hf9tTo4hFoHC3mT0MMJzgdSDGGGhObe2GEDmfJ9M5Yvhkamhsg9CO3Y6I6+hsA9j2pFfAgDa5n8fbqUhI6+TKgl9e5988kksWLAAxcXFKC4uxooVK/D666+Lj/M8j02bNqGurg5FRUVYtWoVjhwJttd2OBy4/fbbUVFRAa1Wi3Xr1qG7OzjCNxqN2LBhAwwGAwwGAzZs2IDR0dHk32WOEcpJybbklmmVWDu/FgDwh10daTsuIjnMoiYmfSt4Q5ECCpl39RaPH9Cx3uCg5URf9o2v8o3ajv+DbuwUXEoDTs74d/H3mQpimgOCmFjurUfOmXDPXw9i+1GvUHOg8Ursu+xlWHVTUGTtwdJ3voSajlcycpzRmHLyWfH/687+BUrbYNaPIRaBPjHJ6GGAQE1M8uUkD8ejZ9TbXr14SgmAzGViOJkKoxVLASRWUioe/hQNp55H6cAeyJ2mqNvOOPQwFK5xjJWeh57m61I63kyS0Le3oaEBDzzwAPbv34/9+/fjc5/7HP7lX/5FDFQefPBBPPLII3jiiSewb98+1NTU4PLLL8f4uP8Cu3HjRmzduhUvvfQSPvzwQ5jNZqxduxYejz8CXr9+PVpbW7Ft2zZs27YNra2t2LBhQ5recvYR3XpT0FBsWNEEAHj14DkYSRuTM9weDg63N32dTk0MwzAo18avizlyznsBEtLWxymIiQrrcWD6kV8AANrn3AIzqwMAMAAUGQpi6gxFUMpZ2F0c+gKyZqEcPTeGJ949jRGLE++fGhJ/bzHM8ulkPguZx4GWPXdjZuvmCToZmcsM3egxVHZvx5QTz2D2gU1Y9MHNaDr2VErHrxs9hvKBXeAZFubiGZBxTkw59WxK+8wEgZoYvx4m/lISkJ7upP4xO1weHio5i7k13kzMsMUJLkMWCInqYvQjh7DkvRsw55OfYMl7G7Dq7xfgon9cioUf3opph3+Byu7tUJu7AJ5H8chB1J39KwB4xbwJBITZJqGr8NVXXx3075/+9Kd48sknsXv3bsybNw+PPfYY7rvvPlx77bUAgOeeew7V1dV48cUXccstt8BkMuGZZ57B888/j9WrVwMAtmzZgsbGRrz11lu44oorcOzYMWzbtg27d+/GsmXeD+LTTz+NFStW4MSJE5g9W3rColiMp5iJAYBFjSVoqS/G4Z4x/PlAF7712enpOjwiAawBAtp0amIAoEKvRN+YPa4g5qhPD3PpnCq8ebSfgpgYNJx+AWprL+xFNeiacQMcNu95VMpZsBnqtpCxDJrKNDg1YMbZYQvqSiZ6axw9N4bH3z0Fl8d7o+s32WFzesTyhltpQOvFv8H0I79E87En0XTyWRiGD8KuqUWRpQtFli4oHcawr1/RuwPGqmUYK1+Y1PFPOfmc95garkBf0zVY9OEtaDj9ItrnfEtSpQWxnCTn/HqYRIMY37U5lbEDgh6mobQI5VolZAwDD8dj1OYSDUvTiRDElA7uBcO5wLORTRuVtn4s/OhWyDwOWPTNYDkXiizdKLL2oMjag8pzb4vbuhU6cKwCDHj0Nq2DqWJJ2o89nSS9BPF4PHjppZdgsViwYsUKnD17Fn19fVizZo24jUqlwiWXXIKdO72R4oEDB+ByuYK2qaurQ0tLi7jNrl27YDAYxAAGAJYvXw6DwSBuEw6Hw4GxsbGgH6mQqrAX8K7UNyz3ZmO27O7MWHRPREfQw8hZRhzMmS5Er5jx2Jk2QdR7zaJ6MIw3e0MjC8Ijc45j6rFfAwDOnHc7OLkaDp8YNFOlJAFRFxNG3BsYwCxsMKBUowAPoGMkZFtWhrb5d+LTlY/DLdeiZPhj1HT9E4aRg2IA41SVwlS2AH2NX8DZud/GUM1nAAAzP/1ZUsJPpW0ANZ2vAgA6Z30TQ7WrMG6YDbnbgsbTLyS8v0wilJOmONsgd5nhUugxbpiT0D6ETIwthS6/rhFvKamxVAOWZcTAJVPfy/GSOXCqSiF3W1A8cjDidqzbjoUffQdq2wDMxdOxd/Vf8dEX3sF71+zH/lVbcGLRD3Bu6hcxVjIPHKuA3GWG0mGEW67FqQX/kZFjTycJ31UPHTqEFStWwG63Q6fTYevWrZg3b54YYFRXVwdtX11djY4Or46jr68PSqUSpaWlE7bp6+sTt6mqqprwulVVVeI24bj//vvxox/9KNG3kxUEs7tEhz+Gsm5hPX76z2PoHLFix6lBXDp74t+JyCyBephkjAujIQQxsbxi7C4P2ga93UhLp5aiqUyD9mErTvSNo2KGKq3HVAhMPfFbKJ2jsOinoXfqvwKAWBJUKTKbJm8uD9+hdKzXH8AsaDDg25dMx9MfnIGxcxQdw1bM8ZUjAhlsuAJ7i2egtuMVuBTFsOkaYNNNgU3bCI9CF7StytqHla9fjtKh/ajofRdDdZ9L6LgbTr8IlnNhtHyxmMlpn3sL5u/+PhpPPouOWTeCk2sS2memEAKPpvFPAACjlYnpYQB/EGNxpBLEeDMxjWXev0uFTolB3+JiVrU+6f1GhGExUrUCNV2voax/Z/iMCc9j7v4fwDByEE5lCT696NfiZ8WtLMZo1YUYDWhFZzgXNGNnoDedgNkwC86i6on7lBgJL0Nmz56N1tZW7N69G7feeiu+/vWv4+hRv3I+9MLO83zMi33oNuG2j7Wfe++9FyaTSfzp6uqK9y1lnFSFvQJFShmuW9oIAHieBL45QRD+pVMPIxDv6IETfePgeO9Fskqvwuwa7wWSSkoTUdoGMOXk7wEAp+d/HzzrPW9CB5g6w5kYQdzbZbTB5fEGTsd6x/D4O6fFAObWS6ZDIWMxtTx2N5O1eDra5t+Jzjk3YbDhCphL5k4IYADAoalB58yvAwBmHHwoIb8Z1m1HQ5t3unbnrG+Iv+9vuApWXROUzlHUn3k57v1lGqHFusF0AABgrIzfH0ZAMK60uzwxRdiREMpJjWXesmEyLtyJIpSUyvs/Cvt40/GnUNv5CjhGhkMrfgGbvinq/nhWAUvJbPQ1rYO5JLFsVq5I+BusVCoxY8YMLF26FPfffz8WLlyIX/ziF6ipqQGACdmSgYEBMTtTU1MDp9MJo9EYdZv+/okOpIODgxOyPIGoVCqxa0r4kQqpmt0FcoOvpPTuiYEJxkpE5rFkYG6SgDgEMsZFTyglza0tBsMwmO1btR/vlU4JVSpMO/q/kHnsGC1fhMH6y8Xf28VyUmYzMRU6JXQqOTwcj64RqxjAOD0cFtT7AxgA/iBmKD3f6/Y5t8CpLIFurA21PpFmPNR2/B1K5yhs2gYM1q/2P8DK0D7b29XVdOIZMJ7cNxhwPA+7ywMZPKgyfgwgcT0M4M/E8PALhRPBZHNhzO4Gw0A0ORRcuDNZ5hWCmOLhTycYElace0e0FDi5+AcwVq/I2HHkkpSXITzPw+FwoLm5GTU1NXjzzTfFx5xOJ3bs2IGVK71/6CVLlkChUARt09vbi8OHD4vbrFixAiaTCXv3+seM79mzByaTSdwm3xCDmBTLSYB3ZfeZmRXgeeCFPZ0p749IDGsG5iYJVAoXvRiGd0d7vZ1J8+q8wctcXybmRD9lYgIpGm9HnS9jcHr+3UF26U53djQxDMOI2Zg3j/UHBzCr/AEMADSVe8sQg2aHeM1IBY9Sj7PzvgMAmH7kl2DdcQRHPIfGU15Bb9eMDWLmSqB36r/CXlQFta0ftR1/T/kYU8Xh4sADmMd0QOFOTg8DAAoZK1ocjCfxtxcWlNXFajEw9i9KMhfE2LUNsOqmgOU9KB3cJ/5eazqJlt13gQGPrunr0T3jqxk7hlyT0Df4v//7v/HBBx+gvb0dhw4dwn333Yf33nsPX/3qV8EwDDZu3IjNmzdj69atOHz4MG688UZoNBqsX78eAGAwGHDTTTfhrrvuwttvv41PPvkEN9xwA+bPny92K82dOxdXXnklbr75ZuzevRu7d+/GzTffjLVr1+ZlZxLgX72nqwQhCHz/tK+T7OazjDkDc5ME4i0nCZmY8+q8HSJCOelk/zhNtA5g+uFHwfIeDNVeElT3BwC7r5yUiZEDoUz1BSf72o1wejjMDxPAAN5yc5UvkO1IxCAvCt3TvwKrthEq+yCaAjxfIlHe9wF0Y21wy7XomTbRG4SXKdE56yYAwNTjT2VsLELx8KfeGVcxSjuCHmalzDs0Mxk9jEBjqfc8JeO5JJjcTSn164QSEeqnwkhVcKu1wjGCRR9+G3K3BSNVy3Fy8X0Zff1ck9A3uL+/Hxs2bMDs2bNx2WWXYc+ePdi2bRsuv9ybpr3nnnuwceNG3HbbbVi6dCl6enqwfft26PV+UdOjjz6Ka665Btdffz0uuugiaDQavPrqq5DJ/B+8F154AfPnz8eaNWuwZs0aLFiwAM8//3ya3nL2ER170xTEXDa3GvUlRTBaXXjtUG9a9knEh+Ajkaq+KRzxBDEejsfxXu9Fdp7PFbSpXAu1wutHkq6bX76jHzmMmq7XwYPB6fl3TXjckaVyEuDXxQDA/HoDbgsTwAj4dTHpKSnxMiXa5t8JAGg6/jQU9uGo2wv6oZ5p14XV2ngfux5OZQk05k5UdW9Ly3EGYhg6gKXvrseCnbdjxsEHowYy9pAgJhk9jMCixhIAwCed4VvWoxGqhwH832ejzQm3Tw+VCQL9YhiPEwt23oEiSzes2kYcWvGLqK3XhUBCQcwzzzyD9vZ2OBwODAwM4K233hIDGMCbOt20aRN6e3tht9uxY8cOtLS0BO1DrVbj8ccfx/DwMKxWK1599VU0NjYGbVNWVoYtW7aIrdJbtmxBSUlJ8u8yx5gd3im26QpiZCyD9cumAACe300C32xiEUXa6b/5Celno9UlikBDaR+2wObyoEghE2+OMpYRux/IudfLjEM/BwD0NV0dVqAoCHszXU4CgNnVekyr0GJZc1nUAAbwl5QSGlUQg/7Gz8NU2gK524JpR5+IuJ129ATK+3eCZ1h0zfxaxO08Ci26fKLhqcd+k9bZPSrLOSz46LtgOe81c+qJZzD90MMRX8Pm08MsYY4DSE4PIyC47B7rG09YF9Nl9LdXCxSr5VDKWPA8MGLNXDbGWLUMPBjoxk6hZc/dKB3cC7dci08v/jVcqtLYO8hzaHZShnF7OFFEmM6OluuXNkIhY/BJ5ygO90S3jybSh5CJyUQ5qVSjhIyNPnpAKCXNqdWL2wLeGyXgvQBPdsr6P0J5/05wrAJt54UfWudvsc78JVClkOG/Pz8XN39mWtQABvBnbTrSJO4FADAsTi+8BwBQ3/YnFI23h91MKDcN1F8Bu7Yh6i67Zt4At1wLvekEKnrfS8thsm4bFn50G1SOYYyXzMHJBf8JAGg+/hSmH34sbCBjd3kwj+mADtak9TACtYYi1BSr4eF4HErgmupwedDvc2QW2qsBnwu3oIvJYEnJpSrFeKl3mGl19zbwYHBo+SOwGGZm7DWlBAUxGSbQdyCdJYhKvQqf981Tonbr7CFmYjIg7I3HIEtw6hVKSQJzfP8+MdkHQfIcZhx8GIBXD2LXNYbdTAhiMjXBOlmmlGnAwLtyN9lcaduvsWo5BmtXgeXdYsdKIEr7EGo6vbOZOmfdGHN/bqUB3dO9Wsepx55MPRvD85i3714Ujx6FU1WGTy96Ep1zbsKJRT8AADQfexLNYbJINpcHy1mvxUcqehgBoaTUmsCg3Z5RG3h4My+GouDSTbw6t1QZrvY3vZxecDeG6y7N6OtJCQpiMozZ182ilLNQpjl1LQh8/+/THpis6bvgEZGxONPj+ROJWIZ3R3uDRb0Cc2qonAQAFZ2vo9h4GG65Fmfn3hpxO0FLkY1MTCKoFTLUGNQA0ifuFTi94G7wDIvq7m0oHm4Neqzh9As+c7tFMFUsjmt/nbNuhIdVomS4FaWDe2M/IQpTj/0aNV2vgWMV+HTlE7Br6wEAXbO+hpML7wUATD/yOJqP/iroeTanB8vZ1PUwAkJJ6WDPaMSSbihiKalsovlfNjqUAKCvaR3cCh26pq9Hx+x/j/2EAkJa3+ACRHTrzcBNb0lTKebU6GF3cfjzAemY+xUywtiBTGhigICLXpg2a57ncfRccHu1gNCh1DFiTWkSb17jcWHqp94sQ8fsb8KlLo+4qb/FWlqZGCD94l4Bi2EWzk31zrULHEcQbG53Y9z7cxZV4lzzvwGAONYhGSp73sKMw48CAI4v/iFMlUuDHu+c/Q2cWuAth00//FjQazmcDlzApq6HEWiu0MJQpIDdxcW9IBA6kwL1MALZMLwDvOf2vWv248SSTUFWApMBCmIyjCDqzcTKnWEYfG3FVABezxiap5R5hExMJjQxAFAZ5aI3OO7AkNkJlvFrYAQqdCpU6FTgeeBkv3nCcycFH/8BReMdcKrKgpxmw2HPorA3UYSW7HDzllLlzHl3wCNTo3ToACrOvQMAqOl8BUqHETZNHQbr18TYQzAdc/4dHCNDef9HUef3REJrOonz9njn83TNuAHnpn8p4uucnv99AMCMQ4+g6fhvAQDl5pMoZmywMNqU9DACLMNgYYM3y/lJnCWlbl9n0pSwmZjslJMAAIz0PsvZYHK+6yxiTrNHTCj/sqgOepUcZ4cs+PD0UEZeg/BjyXQmJorLpyDqnV6pE6ccB+IvKU1CXYzTAuz4GQDg7LzbIrYHC2RrAGQyiEMjhy3g09j5A/jGEfiyLTMPPgSGc2GKT9DbNfNrE8ztYmHXNqBvytUAfJ1KCaBwGLEw0M9k0b1Rt2+f+220tWz0HfuDmHLid5jqm5d0umhBynoYgcVTvB09rV2jMUcQcByPbrGcNHFKebbKSZMZ6X2DCwyhnJQOt95waFVyfHGJt5Mg39utN71yBOuf3i22v0oRUROToUxMtIueoIcJLSUJCCWlY72TUBfjdgAzL4dN34TuaV+OublDwuWkxlINWAYYs7thzIDWrX32zXCqSqEdP4OW3XdDN3baa27XPNHcLq79zf0WeDCo6nkTWtPpuJ7DcC7M3/U9aBL0Mzk77zacmfddAMCsTx/A5aNeR+azuvh0PPEwp0YPlZyFyeaK2eo+YHbA4eaglLGo1qsnPC5kYsbsbklf1/IZCmIyjCWNc5MiIcxTevtYP3pGbRl7nUzi9nB4fncHdrYN42C3dFvG/ZqYzAp7wwYxolNv+CBmUot7NWXAv/wvPv78P8HLlDE3d2TRsTdRlHJWnL+TTr8YAY9Sj7NzveMIqrtfBwCca74OHmVyk5atxTPEuVRz9/8A9af/CMPgfsidkTOCs1o3o2xgd1J+JmfOu10UbZdwXmO6ruLzkzr2cChkLObXe0tKrZ2jUbcVxg3UlxaBZSdqUbQqOYp8k9Ij2SYQqSG9b3CBMZ6FIGZGlQ4rp5eD44EX9+RnNqZ/3CFa5gs3ayni18RkStgb2ar8iCDqrTVMeAwA5giDIPvG0l6GyBc4+cTVcDik2mIt0BTHROtU6J7+ZVi13vZznmHROXNDSvs7O/fbAICS4Y8x9+P/Dxe8ux6r/r4UF7/6WSx6/ybM+PRB1LZvhd54BA2ntqDx9AvgweDw8ocT9zNhGLS1bMTZOd8CAAzzeowWp3ckjdClFEsX0yWKeieWkgSopJRZMndnJQD4y0mZWrkLbFjehJ1tw/jTvi7ccdlMSabJo9EdMJFb0kGMIzst1qEXPLPDLXarRConzazWgWW8jr+D4w5UFcd3Q5+MiJoYCWZiAG+XzIenh9JrehcAL1Pi1KL/woKPvoveKesi+unEy3hZCz7+7DMo698NnekEdGOnoLb2Qm3rg9rWh4q+DyY8p23+nRiq+1xyL8gwaJt/F/7QXoIDJj0+o4ydfUuE+fUGyFgGvSY7+kx2se09lGjt1QIVehW6jLaMdyhNViiIyTDCyl2fIU2MwOXzqlFdrEL/mAPbDvfhXxbVZ/T10o0gjgP82g8pYsng7CQAqNB7L8YjVu+8FbnP4fWY729Sa1CLhnihqBUyTK3Q4sygBcf7ximIiQDH8XB6pCvsBYLHD/A8DyYDbbOD9Zfjwy+8C6e6Ii37G6n5DEZqPiP+W+Ych27sJHSmU9CZTkJnOgmt6SSUzlH0Nv0L2ufcktoLMgzewHKc4+24XJHeRZtGKcecaj2O9I7hky4jrjLUht1OyMSE60wSqNBG934iUoOCmAyT7uGPkZDLWFy3pBFPvHsa7x4fyOsg5kT/OFweLqZFe7ZxeTjRXyQTjr0AUKZRgmEgzlup8okFIzn1hjKnRu8LYsbw2VmVGTnGeDg9MI4RiwsXNpfl7Bgi4QwwMZNqxrKhpAhyloHF6cGQ2YlKX9daunFo6zKyX8CrvTFVLIGpYon/lzwPuWscboU+LX4mdqf3XBalOYgBgEVTSnCkdwytXaO4qmViEDNmc2HU5gIDiBqmcAjlpGEKYjKCtO4SBUimyw+BLGnyiuOOSLgcE4meUX/a3OnmcGZQetOYrQFD4TLlEyOXsSjTTJy3IgYxEUpJAn5dTO7EvRzH44bf7sVXnt4temhICcGtl2EAhUyaxmByGYuG0syJe3MGw8CtLE6bIZvNdy7VGVhUCCMIzgxaMBpmgKMwubpKr4I6ShDlt02gclImoCAmw5gdmXPsDeW8eu8NrG3QnHeurYGZGAA42iu9DiUhIFXImLSPkAgknC7miO/vEakzSWC2BDqUTg2Y0Tdmh4fjJdnu7W+vZjNSpkkXonNvBkzvCgGe58WANBOZmFKNEs0VWvAAPg3TMdk1ElsPA2TZ8G4SQkFMhsmWsBcAqvRqVOlV4Pj88woRghihXCJFca81w3OTBARdjHDRc3k4nOzzuvBG6kwSENqsTw2Y4Y5z9ku62Xt2WPz/s0PScw+WskdMIJkaP1AoONwchB68TAQxALDYl435pMs44TEhExMziPFp2KxOT94tLvMBCmIyjJCJyZTZXSgtPn8DoR03H/BwPM75/G0un1cNQJriXtGtN0OlJIHQlVvboBlODwe9Sh7WFTSQxlINNEoZnG4uZ2WIve3+C/5ZCWYRHEIJQqKiXoGpFd6bY8eIJaZz7GREKCXJGCZjZUGhpHS8dxw2Z7BZnRjERGmvBgCVQiY2doSzTiBSQ9rf4gLAnAWfmEBafOWGwz35E8QMjNvh5njIWQaXzqkC4M3ESM3rJNMeMQKhQ+OO9HgDurl1xTHLHyzLYJZvrlIudDE8zwdlYqSobRIyMZksCaaDWkMRlDIWdheH/jF7rg9HcgyMeYN8jUqWsbJgrUGN6mIV3ByPwwELQ6ebQ5/Je06idSYJxJpOTySPtL/FBUA2HHsDOc+XiTncI71MRiSEUlJtiRpzavSQswyMVhf6JHbhFjIxmkyXk0TDO+8FTxw3EKMzSUAoKR3PQUmxc8SK/jH/hVqSmRjB6C5DJYh0IWMZMfNGJaWJ7D7jDZYFd91MwDAMFjd6GyY+CXDvPTdqA8d7r+uGotjjEsjwLnNQEJNhxnNUTjrZP543szqEDpaGEg3UChlmVHmH90lNFyPUs3UZGv4oIFzwhFWbUBqMJeoVEIOYHGRi9p4dAQDMqvaew4Fxh5iNlApSnmAdSrNvGGRHIXUopQGnm8P+Dm/ZcuX08oy+luDee6jHJOrMOkU9TFFcWSBhYZLr0QPH+8bw/qnBnB5DupH+tziPcbr9viK6DOsoBOoMapRqFHBzvCgGlTrdPpV/va+2LFVxr5iJybQmJqAlk+f5uNurBWb72qxP9Gf/7ycEMZfNrUa5T9Aote4av1uvtDMxgH/8gBQzWrnkky4jbC4PyrVKsXyaKZortChWy2FzeXCi37swEK5ZU0pjl5IAaXQouTkOv3qvDX/Y1VFQQTEFMRnEErAC1WZ49S7AMIyYjTmcJ+JeYWil4Ish3KylJu4VPX8yrImpDLjg9YzaMGZ3QyFjMLMqvou1kInpGrFlPQuyt90bxFzYXCZmEc5I7AbsyKNMzFSfc2/XiE2cLUYAO9u8paQV08vBZrhNnmUYUeArlJTi7UwSkEI56cygRfS6KqTypPS/xXmMcAMpUshE+/hscF6doIvJjyBG0MQ0+FY1YiZGakGMIOzNkiZmxOIUz+HMKn3cQtRSrRLVxd59ZNMvpn/Mjo5hKxjGa7woBDFnJSbuDfSJkTrVxWqoFSycHg7nTPk5oT7djFqd4rVhxbTMlpIEFk/x6mJau0bBcXwSQYxvYWJx5qxhIfB+0DlCQQwRB+YsuvUG0uIzvTsssXJMJERNjC8TM9cXxHQMWzFmd+XsuEIRVjGZFmmX+1ZtHo7HR6e9K854S0kCswMmWmcLoZQ0r7YYxWoFmiuFUoi0yppiOUniPjGANwvQVObTxWRoGGS+sfvMCHgemFGpQ3WW5oPNqdFDJWcxanNhX8cI7C4OcpZBTZyvX65VgoFXYjBmz41G7BAFMUSiiG69WRL1CrT4MjHHesfgypHhWbxwHI9zo94uJGH+SKlWiTrf1NhcdNhEQignZbrFWiFjUarxdjwIIrx4Rb0Cc3Pg3CsEMcK8pGkV0tRziOUkiU6wDkXwiymo8QNJwvM8dp4ZAuAtJWULhYwVu6BePdgLwKvhk7HxlbLkMhYlvu90LkpKo1anOHEb8C4cC6U8mR/f4jzF79ab3RXflDIN9Co5nG4OpwektQoOZdDsgNPDQcYyqA0Ydy/qYjKs6znVP44DHSNxbevXxGQ+KBXSzx2+2nW87dUCs3PQobRP0MNM9QYxzRXeDqUzQxZJef7kUzkJCHTupSCmY8SKc6N2yFkGF0wtzeprC11Kgj9MY5yiXoFcinuP+MpvU8o0UMlZuDy85CwskiU/vsV5SraN7gRYlhHnKEldFyOUkmqK1UG6oWzoYjwcj/W/3YPrf7M7rmyBxSn4xGQ+KBUueAJzEy4nCV4x2TENHLU6xYDpAl8mpqlcA4bxTnIftkjHqVQoJ6nzoJwE+IOYLqNN8pnVTCMIehdPKcl4l2Ao8+sNQZmXeEzuAsllm7VgmLmg3iAGX4VSUqIgJoP4g5jYZkjpRigpSX2itV/UG2zdnY0OpWO9Yxgcd8DD8dh2uC/m9n6fmCxkYvT+IGZKmQbF6sQ+QzOqdJCxDMbs7qysuPb7Rg1Mr9SKF2u1QiaWCKVUUrLnWTmpQqeEVimDh+PFTr7JiNvDiSXLldMrsv76GqUccwLauWONGwglVx1KHMf7vabqi8Xgi4IYIiZ+t97sr/jENmvJZ2KCPWIEhEGHJ/vMGVt9CuUPANh+NHYQky2fGMB/wQMSLyUBXtGqoEnJRkkpsLU6ECl2KDnzZACkAMMwCU+0HrU6C27Y4KEeE8wONwxFiqS+E+lgka+kBPi7KeNFWJhke/TA2WELLE4PihQyTKvQiUFMFwUxRCzG7dl16w1E6FA62jsmaQFXaHu1QENpkVfX4+HQNpgZXU9gEPNJ5ygGYmQssuUTAwSXkxLtTBKYncXxA3vOhg9ipknQKyafHHsFmkRxb+wbzyedRvzX3w5h82vHC2pw5E7fmIHlzWVxC2rTzflTSqFXyzGnRo+iBK8DlSEz0bKFsJCdV1cMGcsEZWKkpFVLlvz5FuchuWqxBryiyiKFDFanR1Kp/FBC26sFWJYRW60z4dzrHVToLYHofefnzWP9UZ8jtFhn43xWBgQxiXYmCQh/vxMZbrO2ONw44rtQXtgc3DEiZmIk1Gbtd+zNn8tfc3l84wf2nB3Gkzva4Oa8ws3OAjE1M9vdONjt/YzlopQkYChS4IF/nY+Nq2cm/FzBwXrE4gSXxYWlICmY75MY1JWoIWMZWJ0eSWnVkiV/vsV5iLBy1+cgiJGxjLiCPyJh594eIRNTMrG+7O9QSv9NuGPYiiGzA0oZi29e3AwAeONI9CBGMLvLRrdZhT6gnJRsJiZL06w/6RyFm+NRX1IkamAEmiu9HUpSCqQdeVZOAvzjB3pGbRFnor1/ahC//eAsON6fZWrtHs3WIWaUve0j8HA8ppRpJpSes41KIYOcTfzWWapRQsYy8HA8jNbsBA9mu1v87gnNHnIZK1pYFIIuhoKYJIknDTeeo+4kgZY6aXco8TwfMHJgYn05kx1KgoZjYaMBVy+sAwDsahuKaq5nzaImps4XDFToVHEbaoUyp9YbxLQNZk5XBAB7z3rT/KGlJMBfTmoflo4vhRAEqPOonFSqUaBYLQfH+0uwgbx1rB9/2NUBHsAlsyqx/sIpAIBPu0aze6AZYmeb1xsm08MeMwnLMijzZWOylQE52jsGHl4PrlKNf2FUSOLe/PkWS4RRqxPfffFj/GlfV8xtLTksJwHAeaK4V5odSoNmBxxuDiwD1Bgm3qgDO5TSXbvd59NwXDC1DDOqdJhWqYXLw+O9E+EnvDrdHJy+QCAbPjGzq/X44dp5+MWXF8U1JTcc9SVeXZHLw+NMBoW1kUS9gDcYU8pYON0czkmgs8bD8XB5vJ+lfMrEMAyDqRXhxb3/PNSLl3zXoyvmVeOGZVOwoMEAhvG2ZQ+nKCT98/4u/Hz7CYxmKXsQyrlRG9qHrZAxDJaF+YzlE6ET6jON4NIraCQFKIiZxPz9kx7842AvfvyPozHr04LZXbYdewWENuvD50ySFHAJK8qaYnXYuUAzqnSQswxGrS70mtLbJiyIegVPkyvOqwEAbD8SvkspsNMjGz4xDMPgmxc346IZydf/GYbBLNH0LjOBrMPtEYfiXTB14g1GxjJo8g0xlEJJKbAUk0+aGCDQ9M574+F5Hn/7uBtbP+kBAKxbWId/W9IAhmGgVysww1fK+7Q7+UzsqNWJ7Uf7cbxvHI++dSrrA0UBvzfM/HoD9AlaDUgNUdw7nvkghuP9rdXCvUCgkDqU8utbLAE2rJiKC5vLYHV6cNfLn0ZNkedS2AsAM6t1UMpYjNvd6BrJ/So4lEjt1QJqhQwzqrwX4nTqYgbG7Wj3DSo83zfYbc28agDAeycGw2oOBKM7pZyFIovDPFNlToadew/3mOBwcyjXKjHdNysplOYsjR/geR52lweOKD9CxyDLAPIcdbgkizDRun3YAo7n8dK+Lrzm8ze6bkkD1i2sC8raCZOXW1MoKe3vMEK4wvWM2vDLt0/B7gqvyckEHMdj9xn/xOp8pyKLHUrdIzaM2d1QyVnM9F1HBRrLNGAAGK0ujEtoPl0y5ObumsfIWAYPX7cQV/3iA+zvMOI377fhtlUzwm6bK8deAYWMxZxaPQ52m3D4nAlTyhPzNcg0PRHaqwOZV1uM433jONo7htW+QCNV9vm6kubUFMNQ5F3ZLWwoQZVehYFxB3a2DePS2VVBz7Fmsb06nczJ8AylPQFluUhlL/8gyMwFMRzH44Zn9oir9lio5LKky3S5QhD39pns+N1HZ7H7jPdvf8OyKVgV8nkFgIWNJfjzgW6c6B+H1elOSsslmMutmlWJve0jODNkwf++exp3XDYzK8H8sb4xjNpc0CplWNBgiP0EiZPN0QOHfVmYuTXFQW7ogHeBWKVXoX/cgc4RK86ry9+/bf4sKSVEY5kGP7x6HgDg0TdPRuz+ydUAyECED6cUxb2R2qsDyUSHkn/Gj3/2CssyuNwXJG0P06VkFoc/5lfcL06zzpDzcejQx3Bkwyvmb5/0xB3AABCH+eUThiIFyjRK8PBOcmYY4JsXTQ0bwADeMm1NsRoejk/KuXvY7MCZIQsYAGsX1GLjZTOhkrM41jeOpz44kxWhtnBOL2wuy6sMaCTKs+jaK+hhzqsP393YWCC6mPy6IkuI65Y04K2j/dh+tB93/qkVr3z3YqgV/lU6z/M5F/YCfkHXYQmOH4g0ciCQTHQoCTfeC0JuvFecV4MX9nTizaP9+Ok1LWADyg2CR0yusmrJIhjenTPZYbK5xMxTOvBwPA74xg1EC2KEQZCZ8oqxOt34+RsnAADXLW3AqlmVMZ+TT6LeQJoqNBjpdELGMvjWZ6ZhSVP0IYgLGw3oO2JHa9doWM1SNPb5zu2saj1KNEqUaJT47qUz8Iu3T+GTzlE8t6sdN66cCjZDGS2b06+3KoRSEuDPxIxaXXB5uIwFZlanWzQJDdXDCEwp02B/hzHvg5j8D21zBMMwuP/a+ajQKXGy34yHt58Ietzh5sQuiFze+MQZSj3SE/cKmZj6ksjlJMGwrXPEGrX9OV7G7C4c84lcLwy5qC+fVg69So4hswOfhOgIhIA0G6LedGIoUoieECf701tSOtY7hnGHG3qVXDxP4RA0Md3GyB4nqfD0+2fRN2ZHfUkRrjyvBiq5LOZPvvK52VWYXqnF7ZfOiBnAAMCihhIA3lW5m0uszT5c19nc2mLc8tlpYBlvluTl/V0Zu67s7xiB08OhxqAWzf7ynWK1HEo5Cx5e07tMcax3HBwPVBerUKlXhd2mUDqUKIhJgXKdCg9cuwAA8NsPz2JXQDo7UMWfjZbcSMyu0UPGMhi2OCU1ej3YIyZyJqZUqxRvwumwzz/QYQTPeycsV4X4ryjlLC6d403Nh3YpiW69eVZOAoA5vgDjSJpLikJGa8nU0qg28BU6JfQqOXgeaXeQHRiz4zfvtwEA/uuqOWG73AqJubXFuPequeJstFhMr9RBp5LD6vTg9ED8mbD+MTs6R6xgGeD8gHlBALB4Sim+sdJrEPnWsQG8erA37v0mglBKWjmtPO/0S5FgGAYV2vhLShzPY+snPXgrhpt4KILEIVrZVAhiBsYcSYm1eZ6XxFiLwv7GZ4HV86rx5QsawfPA3X/+VMwWBM7ZYXPYBaFWyERlupT8YoYtTthdHBgGqC2JbuY2z5dNOpoG5+FAf5hwrDnPq4t540hf0ArTr4nJv1W88F7/3nourfvdF8UfJhCGYURxb7p1MQ9vPwmr04PFU0qwdkFtWvddCLAsIwpiP+2K//sjnNu5NcVh25pXTC8XDfVe+fRcwjfZWAyOO3BqwAwG3gxpIZFIh9KutmHRB2hXnJovnufFa32kUhIAFBcpUFKkAA+gy5j44uLcqB3f/P0+bH7tWMLPTScUxKSBH6ydh8ayIvSM2vCjV44CyO3wx1CkONFa0MNU69Ux0/uBpnep4hf1hr/xrppdBaWMRfuwNWjlKvjE5JsmBgD+bUkDFDIGrV2jOJSCZ0gg3tlT0f+WgWSizfrouTG8fMBr8vaDL8wtmNV6ulnoKym1do/GXfoR9DDRdDSfm1OFaxZ53a5f2teFj04PpXagAezytVXPrS0WXW4LhXg7lOwuD/7m8wACgOd3d8QVbJwz2TFidUIhYzDLN3okEn6/mMQtOPZ1jGDE6sqokWY8UBCTBnQqOR69fhFYBvjrx93YdrhXEqJegRYJzlAS9TBxzEFJl7jX7vKIq9FQUa+ATiXHRTO8K7/tR/2rS4swciDPNDEAUKlX4fPzvVmK53e3p2WfZ4YsGLY4oZKzmB9H66sYxKTpgsfzPDa/dgw8D3xhQS2WNOW3k2smOa+uGHKWweC4Iy7TyHOjNvSM2iBjGSwOKSWF8oX5tWJX37O72nGgw5jy8faP2fHeiQEA+T1mIBLxdihtO9IHk82FSp0K59UWw+nh8OR7bUHGm+EQFquzqvUxy6vJ6mJ4nsd+37n+woKahJ6bbiiISRNLp5bhlkumAwDu/dshccWZi+GPobRIcPxATxydSQLCFOeTfanNADrYbYLTw6FCpxKNw8Kxxufe+0aALka4cOSjJgYANixvAgD8X+u5tNjHC1mYxVNK4hLKpjsT896JQXx4eghKGYv/unJOWvZZqKgVMnGOVjzGd0K28ry64piLMIZhcP2SBlw8owI8D/zm/Ta86wtAkuHcqA0PvnECY3Y36gxq0YyykIinnDRsdojXn39b0oCbPzMNZVolBsYd+P1H7VEzaocjuPSGI9k2655RG/pMdihkDFbPTY9/V7JQEJNG7lw9C3Nri2G0usQ6oRQyMXNri8EwQN+YHYNZsLuOh3jaqwUaSr0zgJweTmwbTAZx1MDU0qilh9Vzq8Ew3qBHmPdjzuLwx0ywpKkUc2uL4XBz+MuB7pT3l0gpCQCm+dqs06GJcXs4/NT3/brxoqnihZiIjNCl9GmMqdY8z8dVSgqEYRh8bXkTLppeDo4HXtjTiT/t7wKXoI9M14gVD20/AZPNhfqSIty9ZnZBCrUr4ygn/e2THrg8PGZV63D+lBLo1HLcesl0yFkGn3SN4o0wXlYA4HB5cKrfe42MxwtJyMT0jNrgTmCBuN/3GTl/SmnOR0EU3ickhyjlLB770iIoZSzG7NLRUGhVctFwTColJb/RXewbEMMwmJsG0zt/EBP94lypV2GJbwUoCBbFTEwelpMA799QyMY8v7sj4RtMKH6Tu/jS/VMrvOd5yOxIuVX+pX1dOD1gRqlGge9cGt4tmwhmgS+IOTNogckW+e/fbbShb8wOOcuIgU88sCyDG1dOxb8urgcAvHm0H0/uaIMjzq6X9iELHtp+AuN2N5rKNfiPNbNRnEZPIylRofeWk8bt7rB/nzODZuw5OwIGwJeWNooLruYKLb7iE1P/9ZPusPPQjvePw83xqNApUV0cvrU66Fh0SmiUMng4HufinE8XWEoSSu+5JKEg5v7778cFF1wAvV6PqqoqXHPNNThxItgfhed5bNq0CXV1dSgqKsKqVatw5MiRoG0cDgduv/12VFRUQKvVYt26dejuDl4dGo1GbNiwAQaDAQaDARs2bMDo6Ghy7zKLzK7R454rZ4v/loKwF5CeuFecm1QSOxMD+HUxyTiPAvEbswkIXUqCe6+giZFCZi1ZrllcB71Kjo5hKz5IQYTZbbSiZ9QGOcvg/KaSuJ6jVytEv4rQKcyJMG534dE3TwIANq6elVbzvkKmTKtEU7kGPBBV3C14wyxoMKAowU48hmHwhfm1uPkzzWLGQMisROP0gBkPv+ntMpteqcVdl8+SzHUzE2iUcrHLcSjEK4bnefxpv1esvmJ6uThqQuCzMyuwcnq5r3R3ZkJpWLi+n1dniEvozjAMGksTKyl1j/oD3XiupZkmoSBmx44d+M53voPdu3fjzTffhNvtxpo1a2Cx+C9KDz74IB555BE88cQT2LdvH2pqanD55ZdjfNzv8bFx40Zs3boVL730Ej788EOYzWasXbsWHo8/Kl2/fj1aW1uxbds2bNu2Da2trdiwYUMa3nLm+eZFzVg+zXtyhdRhrhEnWktAFxOvR0wgqY4fON7nNWbTxTBmE7h8nlcXs/vMMExWl5iJyccWawGNUo4vLmkAADy/qz3p/YiaiXpDQuW1dOhifvVeG4YtTkyr1GL9silJ72cysiigSykc3lJSfNnKaCxrLvcGIio52oet+Olrx0QNXCjH+8bw6FsnYXN5MKtahztXz8rbkm0iROpQ2tduRNugBSo5i2t9Wa1AGIbBV5dNQUNpEcbtbvx6x5kgE0PBmV1o5oiHRMW9wmKwJcHvf6ZIKIjZtm0bbrzxRpx33nlYuHAhfv/736OzsxMHDhwA4P0SPPbYY7jvvvtw7bXXoqWlBc899xysVitefPFFAIDJZMIzzzyDhx9+GKtXr8bixYuxZcsWHDp0CG+99RYA4NixY9i2bRt++9vfYsWKFVixYgWefvpp/OMf/5iQ+ZEiLMvgV19dgv+6ag6+eXFzrg8HgH9+xmEJlJOMVpdoHleXYCbmaO9YUg6hgj/M+U3RjdkEmiu0mFWtg5vj8c6J/gDfn9x/aVNhwwpvSent4wPoStKpc69vgOayBFdh4gylJDuUuo1WPPPhWQDAvVfNLYhZOtlkoW+q9dHeMTjdE/UP7cNWDJmdUMpZLEhxttTMaj3uvWoOqvUqjFiceGDb8Qml7CPnTPjF26fgcHOYV1uM7102M2h0SyFTIXQoBWgUnQF6tataalCiCd9arpLLcOsl01GkkOH0oBl/PeBtw+73aR5lLBPXQk3A32Yd+3rA8zz2dfgC3Tgco7NBSlcBk8n7oSwr817Mzp49i76+PqxZs0bcRqVS4ZJLLsHOnTsBAAcOHIDL5Qrapq6uDi0tLeI2u3btgsFgwLJly8Rtli9fDoPBIG4TisPhwNjYWNBPLinTKvHtS6ajuji6kVu2EAZBdhttaelOSQVBD1OpV8V90ZpZrYOcZWCyueKu3QYiiBUDhz7G4gpfl9L2I/2wOPO/nAR4HVwvmuFNR/9xb2dS+9h71uvhkehqvTnFQZAPvXECTjeHFdPKsXpu+KGHRGQaS4tQplHC6ebC6imELMyihhKo0hBMVBerce9VczGrWgeby4NfvH0K758cBODtknr8ndNweXgsqDfg9s/NyOtxEIlSHqZDafvRPoxYnSjTKLFmXvS25epiNb550VQAwJvH+rGvfUQstc+s0iUUDAZmYmI58HaP2tA/5oCcZcSgONckHcTwPI/vf//7uPjii9HS0gIA6OvztoRVVwe3XFVXV4uP9fX1QalUorS0NOo2VVUTL1JVVVXiNqHcf//9on7GYDCgsbEx2bdWkBiKFGjytRUnqytJF4m0Vwuo5DLM8DkPJ1pS4nlerPUncuMVLiTvnRiE0Ve7zldhbyAblk8FAPxpX1fCs4yGzA60+TIpFyQQEAKB5aTEO8xau0bxf63nwDDAfWRslxQMw2Bho3cxE9pqzQWVktK3wtap5bhz9Swsn1YGjgf+sLsDT+5ow5PvtcHN8Th/SgluWzV90mXVQjuURq1OvH7Ye2/74vn1cXVlLZ5SiqtavNeoZ3e244NT3gDxvARKSQBQY1BDIWPgcHMxu1eFrqT59QbJZM2S/uR897vfxcGDB/HHP/5xwmOhFxie52NedEK3Cbd9tP3ce++9MJlM4k9XV1c8b2NS4dfF5Lak5G+vTqw1NlldTMewFYPjDihlbEKrh5b6YtQa1LC5PBj2BTFSqAGnyuq5Vag1qDFsceL1Q+EXBZH428fedPecGn3EdHckplX6De8SKQnyPI+f/tPrhH3t4oa45wYRE1nk+/x/2m0KWnW3DZphtLpQpJCl/e+rkLG46aJmrFvodfc90GGEh+dx4dQy3PLZ6ZBPsgAGCCgn+YKYv7eeg8PNYVqFNiGx7DWL6jGnRg+Hm0OX77qa6PmTsYzYYBFNF8PzPPb7At2laQx0UyWpT8/tt9+OV155Be+++y4aGhrE39fUeKPC0GzJwMCAmJ2pqamB0+mE0WiMuk1//8Q++MHBwQlZHgGVSoXi4uKgHyIYvy4mt5kYf3t1/JkYIFAXk1gQFthxkcjqgWEYrJkX/HkrhEyMXMaKc2/+kIDA9/VDvbj/9eMAgOuXJp7pnFKmBcsAFqcnIb+id44PYF+7EWoFi/+4YnbsJxARmVWth1rBwmRzoSNgGKdQbl3UWJKRrAjDMFi3sA43XdwMvVqOS2dX4t8vbo5Ln1aIBBredQxbxJENX7qgMaEso4xlcPNnpqHE16VXUqRAQ5w6w0CEklJHlAGt3UYb+sd9paQE2u8zTUKfVp7n8d3vfhd/+9vf8M4776C5OVi02tzcjJqaGrz55pvi75xOJ3bs2IGVK1cCAJYsWQKFQhG0TW9vLw4fPixus2LFCphMJuzdu1fcZs+ePTCZTOI2ROIImZh0TzNOlETbqwWSnaEkDn1Moh1Q0MUI5LsmRuBLFzZCIWPwcedoXJm53WeG8b2XWsHzwPplU/ANXz0+EZRyVjSmS0QX8+Ier3Znw/Im1BikoTHLVxQyVrwOfOorKXEcL44LSGcpKRwrppXjkesW4qvLmnI6GDfXCKMHbC4P/rC7Azy8xpHTK3UJ78tQpMCtq6ajXKv0GXUm/neNR9wrCHrnJ7gYzDQJBTHf+c53sGXLFrz44ovQ6/Xo6+tDX18fbDbvTYlhGGzcuBGbN2/G1q1bcfjwYdx4443QaDRYv349AMBgMOCmm27CXXfdhbfffhuffPIJbrjhBsyfPx+rV68GAMydOxdXXnklbr75ZuzevRu7d+/GzTffjLVr12L2bFqJJYtQKz0zZMF4ioZjqZBoe7WAkInpGrHF9J4IJNbQx2hc0FwW5EWikdCXNxWq9Gpc2eKdp7Rld0fUbY/1juHm5/bD6eFwxXnV+Mm/tCStSUm0zbp/zC7a2H/5QmqpTgdCSVVotT45MA6TzQWNUiZ+xzIJ6Zm8Gr9inxdOx7AVChmDL54/saU6XqZX6vCzLy7AlS3JzTESxb1Ga9hSL8/7fbaWSqQrSSChIObJJ5+EyWTCqlWrUFtbK/786U9/Ere55557sHHjRtx2221YunQpenp6sH37duj1/mmajz76KK655hpcf/31uOiii6DRaPDqq69CJvPfIF544QXMnz8fa9aswZo1a7BgwQI8//zzaXjLk5dynQp1vpXssd7xGFtnBp7nk9bElGiUYvbmeJzZmIFxO9qHrWAYb3t1oihkLC6b4xWZq+RsQdXvv+Zrt/57a0/EoLDbaMWNv9+LcYcbF04twy++vDilEkCiQczfPu4Bx3svnMmsUomJzK83gGW8GdEhs0MsJZ0/pbSgPt9SpyLAQ2zNvBqxYykX1JcWgWG8LsKjYa4FXb5SkkImrVISkEQ5KdzPjTfeKG7DMAw2bdqE3t5e2O127NixQ+xeElCr1Xj88ccxPDwMq9WKV199dUI3UVlZGbZs2SK2S2/ZsgUlJSVJv1HCy3k5du412Vww+zxXEs3EABD9D+ItKe3zeZrMrtYn7e4quPfqC8xFdGlTKebU6GF3hZ+nNGJx4mu/24v+MQdmV+vx9NeWppxGTsQrhud5/NnnXpqMBocIj04lFzv9Pu40Zq2URAQjBDGGIoXYZZQrVHIZan12IOHEvYKgt0VCXUkCFHZPMoR6+P2vH8Oqh97FDb/dg//8y0H88u1T+NvH3dhzZjjhYWCJIGRhKnTKpL4MiXYoiaWkFOyxPzenGl++oBHfWz0r6X1IEYZhRPO7LSHzlKxON7757D6cGbSgzqDGs9+8AAZN6hb/zb5BkPG0We/vMOLMkAUapQyfX1Cb8msTfoQupX8e7IXZ4YZeLcecGmqGyCbnTylBkUKG9RdOkURgMKU8vHNv4KykC5pyP2YglMJaWhIxWXNeNX774RmM291oH7aiPYIaXcYyaCrT4NEvLUqrqZEo6k2wlCQg1Oz3nB3BwJgdVTHMBIVBhanYqCvlLB744oKkny9lrllUjwdeO46zQxZ81DaEz8yshMvD4bsvfoLWrlEYihT4w00XotaQeNYsHM2+NuvOESvcHi5q+eLlfd4szNoFtZIYpFpILGwowcv7u0UTxyVT4nOyJtLH0qllWNJUKhmN0JQyDXafGZkQxHSN2DDgKyUtaJCevQFlYiYZc2uL8fH/uxwf3HMpXvrWcvz8uoW4c/UsXLekASunl6OpXAOFjIGH43FmyIKfvnYsra+fbHu1wNKppdCp5OgcseKyR3ZMyCAEMmZ34ZjPmVQKg8qkiFYVOE+pAzzP47//dgjvHB+AWsHidzcuxYwqfYy9xE9tsRoqOQuXxz8/Kxxmhxv/PNQLgEpJmaC6WI3agE6vVIJ8InmkEsAAkTuU9gtdSRIsJQGUiZmUKGTeVleh3TUUD8ejbdCMtb/8EHvPjmD3mWEsn5aekevdSbj1BlKhU+HlW1bg3r8dxKfdJvzg74ex9ZMe3H/tfMyqDr7ZftxhBM97v5xSGf8gRW5YPgXP7mzHW8f6ce/fDuHPB7ohYxk88ZXzsSTN6WOWZdBcocXxvnGcGbJMmNIr8M+D52B1ejCtQoslEuuGKBQWNpSg19QHQ5ECM6tIND3ZEaZZD5mdsDjc0KrkvllJQleSNANdysQQE5CxDGZV63H9Bd4V+i/eOpW2fYtBTBKGTALz6orxt9suwv939TxolTIc6DDiC7/8AA9vPwG7y2+jn46JvJOBGVV6rJxeDo4HXvKVcDb/awtWzwtvLJkqYodSFHHvy/u9QuPrliZm/kXEz6rZlZhSpsE1i+omtWcL4UWrkotOwl2+jHnXiA2DEi4lARTEEFG4ddUMKGQMdp0ZFrUlqeL3iElOEyMgYxl846JmvPn9S7B6bjVcHh6Pv3MaV/3iA+xs87pfCp1JFzbTSj4WG5Y3if9/1+Wz8KULMufJEqvN+vSAGQc6jJCxqXlnENGp0Knww7Xz8JmZlbk+FEIiNJYFi3sFg7sF9SWSLCUBFMQQUagvKcK/LfHqER5/Jz3ZmFQ1MaHUlRTh6a8twa9vOB9VehXODlmw/uk9uPvPn4pmXpSJic3l86px48qpuOfK2fju52Zk9LViBTF/PuDNBl06uzKmcJsgiPQRONHaOyvJV0qScPs9BTFEVG5bNR1ylsEHp4ZEP4lkMdlcGLd7PWLq0xTEAF5x3JUttXjrrkuwYXkTGAb4y4FuON0cKnRK8aZJREYuY7Fp3Xm4bdWMjJdvxEGQYYIYl4fDXw/0APCWkgiCyB6BQUzniBWDZu/g3AUSHrpKQQwRlcYyDa71pfRTzcYIWZgyrTIj06CL1Qr85JoW/OXbKzGr2itUvHhGBWkqJIbgFdMzagvSMAHAeycGMWR2oEKnxOd8TskEQWQHIYjpM9mxs20YgHdWkkqipSSAghgiDr5z6QzIWAbvnRhEq29oXDL0pNiZFC9Lmkrxj9s/g9/duBQ/WtcS+wlEVinVKET35Pbh4GzMyz6H3n9dXJ+RacoEQUSmpEgBvVoOjgd2nBwEIL1ZSaHQVYKISVO5Ftcs8mVj3k4+G5Nqe3UiKOUsPjenOi0us0R6YRgmbIfSwLgd7xz3DnskbxiCyD4Mw2CKr+nCzfGSLyUBFMQQcfKdS6eDZYC3jw8kPXdJdOtNob2aKAzEGUoBupi/f9IDD8dj8ZQSzKxOn8EeQRDxE+gfJvVSEkBBDBEn0yp1WLewDgDwyySzMT2jQmdSau3VRP4T2qHE8zz+tI+GPRJErpkSEMRcIPFSEkBBDJEA3/3cDDAMsP1of9wDGAPJZjmJkDbNIR1KH3eOom3QArWCxVoJDHssUsows5pcbInJR3OFFgwAtYLFfImXkgAKYogEmFGlxxfme28wyXQq+YMYysRMdkIzMX/2CXo/P78WenVudUwsC7TUGzClTAMtDZ4kJhmVehVu/9wM3Ll6luRLSQAFMUSC3P65mQCA1w/34UTfeNzPG7e7YLK5AKTXI4bIT6b6ZiaNWJzoNdnw6qfnAABfkkApaWaVHoYiBRiGwQyaKURMQhY0lGB6ZX589imIIRJido0en59fAyCxbIwwbqBEo4COVreTHq1KjhqfG+8T75yGxenB1HJNzqeNVxerg4SNlXoVSrXU4UYQUoWCGCJhvnupNxvzz0O9OD0QXzame4T0MEQwQklJEPTmetijRinD3NqJXVEzqqhTiiCkCgUxRMLMqyvGmnnV4HnvKjoexJlJJaSHIbwI4l43x4NlIDpD5wKW9baTysMY7BmKFKimGU4EIUkoiCGS4o7LvNmYVz49hzOD5pjbix4xlIkhfEwLmGn12VmVqDXk7rMxu6Y4qqB4RpUOLF0tCUJy0NeSSIqWegMum1MFjgd++s9jomg3EoImhspJhEDgYM5cCnprDOqYBoxFShnqKYtIEJKDghgiae64bCYYn4vvZ372Dp545xTMDnfYbam9mghlXl0xFDIG1cUqXDa3OifHoFXJMbe2OK5tmyu0kMtomChBSAkKYoikWdhYgme+vhSzqnUYs7vx8+0n8dkH38VT77fB5gyeTixqYigTQ/ioNRThb7dehL98eyWU8uxfimQsgwUNBsjY+AITpZxFU7k29oYEQWQNCmKIlPjcnGq8/r3P4hdfXoTmCi1GLE5sfu04PvvQu3huZzscbg8sDjeMVvKIISYyv8EQ1NKcTebU6hM2s5tSpoFKQZdNgpAKZNhBpIyMZfAvi+rxhfm1+NsnPfjl26fQbbTh/3vlCH6zow3XLPZ2nRSr5SjOsRsrQQBAXUlRUkJiGctgeqUuqbEbBEGkH1pSEGlDLmNx/dJGvHPXKvzPNS2oKVbjnMmOX73XBoD0MIQ0KFLKMKcmee+XWoMaOjWt/whCClAQQ6QdpZzFDcub8N5/rMIP185DhU4JADRQj5AEDaVFYOPUwYSDxhEQ6UAmYzC1gjRWqULLCSJjqBUyfPPiZnz5wka8e3wQy6fl1lKeIFgWafGjqdCpUKpVwmhxpuGoiMkGwwDz6w0o1SjRbbTC7eFzfUh5C2ViiIyjUcrxhQW1KNepcn0oxCSnUqdOWycUZRaJZJlZpUeFTgUZy+TU5LEQoCCGIIhJQzq744rVCtQYJsc4ghyOtEoLUhobUVdShCnlmoB/S+fYEkURZkxHtqFyEkEQkwKNUoYyrTKt+5xeqcOY3QUGjHijZ+DVzTCM8P8AzwOj1uiu1lJFKWdhKFJgcNyR60NJCo3KO9hz2OLIedmmVKuYICrXqxUwaBQw5eHno7go992mFMQQBDEpqIsxWiAZipQyrJxeEXM7nuex4+Rgzm+iyVChU0GnkudtEFNTrIZcxqKhVIP2IUvOjkOjlGF+fUlYUXldSVFeBjEGCQQxuc8FEQRBZBiWzUwQEy8Mw6BUk94sULao0ClRos39zSpZhJLflDJN3O7M6UYmY7CwsSSiHqumWA1Zno20kMsY6BI0i8wEFMQQBFHwpFPQmyzpLmVlA5b1HrdeJc/LuVHFRQpolN4brVLO5iSQFTqRorlDy1gGNRLS7cSDFEpJAJWT4PF44HLlXxpvMqJQKCCTyXJ9GEQeIoVxF/kYxJRolJD7xJulGmXelZRCA4Omcg16Rq3guOwdg9CJFIv60iL0+Abl5gNScV+ftEEMz/Po6+vD6Ohorg+FSICSkhLU1NSAyfd2CSJrZELQmwxalRwqBQuHK4t30BSp0PpvvtkKYmQsg5nVOoxaXegz2ZPeD8MA1Ybg4EGtkKG6WI3e0eT3mwihnUjRKFYroFfLMW53Z/io0oMU9DDAJA5ihACmqqoKGo2GbooSh+d5WK1WDAwMAABqa2tzfEREvpBLLUwopRplSjfmbFOh9wd/2dDF6NRytNQboFPJUaJxp/S3KtUqoZJPzNxOLdeiz2QHn2GNdbhOpFjUlxbheO94ho4ovVAQk0M8Ho8YwJSXl+f6cIg4KSry3owGBgZQVVVFpSUiJiwL1ErIh6NMmz9BjEYpE/UkAERdTKY6rBrLNJhZpRO7d3QqOSr0Kgwlmf2JpDHRquSo1KswMJa5rFJRlE6kaNQUq3FqwAyPxLvYNEpZzjVmAtI4iiwjaGA0GhpImG8I54x0TEQ8VOrUYVfjuUIKZa14qdAHl2IYhkFJBjqslHIWi6aUYHaNfsJNf2qcpZhQWBao0kfWoWR6ZlFTuSapm7xcxqJaL52gOxJSEfUCkzSIEaASUv5B54xIBKm5oaoVMmiU0gmqohFOjFqW5iCmTKfEsmllEYWvJRolSjSJ3zArdCpRkByOYrUCZbrMBJQyWWqjBKQgQo+FVEpJwCQPYgiCKFw0Spkk53WV5kE2RiZjUBLmRpUuXQzLArOq9Th/SmnMTFlTeeJZk3jGQTQnsd94qDMUpeRHYyhSQKeWttLDkERgmSkoiCHSwo033ohrrrkm14dBECJSEvQGkg8lpXKtMqyeIx1+MUVKGS6YWhZ3106lXhXVYyUUuYwJ6qqKRKk2uSxPLBrSkEmpl+hnF/B2j+mU0gmyKIiZRGzatAmLFi3K9WEQRMaRmqA3kHxw7o1U3kmHLqapXAN9gh4jUyvi18ZU6dVxC2qTyfJEo1SrTCjgikSNQZ0zd+FY6NXyhAXLmYSCGIIgCg6pCXoDUcpZyZcLyqPoRUpTyF6wbHITpav1aqgV8Z3PRCaLV+pVaT0XjWnSsyhkLKqKpVcKBaSlhwEoiMk7tm3bhosvvhglJSUoLy/H2rVr0dbWJj7e3d2NL3/5yygrK4NWq8XSpUuxZ88ePPvss/jRj36ETz/91Ddhl8Gzzz6L9vZ2MAyD1tZWcR+jo6NgGAbvvfceAG9L+k033YTm5mYUFRVh9uzZ+MUvfpHld04Q8SM1QW8oUi4pFRcpogaAqWh6yrUqKKIIbiPBsgymlMXOxqgUbMJB1tQ0ZWNUChaVUTqiEkWqJSWpBTHSXg5kEZ7nYXN5cvLaRQpZ3F03FosF3//+9zF//nxYLBb88Ic/xL/+67+itbUVVqsVl1xyCerr6/HKK6+gpqYGH3/8MTiOw5e+9CUcPnwY27Ztw1tvvQUAMBgM6O/vj/maHMehoaEBL7/8MioqKrBz505861vfQm1tLa6//vqU3jtBpBupCnoDKdUo0TlszfVhhKUiRtdOKn4xtQlkSUKpLy3C2WELXO7IjsfVxeqEOxiri1U4MyiD1Zna9b++pCit3ZMlGm9pyuKQloOvlNqrgSSCmPfffx8PPfQQDhw4gN7eXmzdujVI0MnzPH70ox/hqaeegtFoxLJly/C///u/OO+888RtHA4H7r77bvzxj3+EzWbDZZddhl/96ldoaGgQtzEajbjjjjvwyiuvAADWrVuHxx9/HCUlJcm/2yjYXB7M++EbGdl3LI7++IogU6lofPGLXwz69zPPPIOqqiocPXoUO3fuxODgIPbt24eysjIAwIwZM8RtdTod5HI5ampqEjo+hUKBH/3oR+K/m5ubsXPnTrz88ssUxBCSQ6qC3kBKNQowDDLuGpsMof4woQi6mERN6OQyJq4ZQpGQsQwaSotwdtAScZtESkkCDMNgSrkmJadchsnM566+pAgn+6Xj4KtSsHGX9bJFwnk9i8WChQsX4oknngj7+IMPPohHHnkETzzxBPbt24eamhpcfvnlGB/3n4iNGzdi69ateOmll/Dhhx/CbDZj7dq18Hj8kfD69evR2tqKbdu2Ydu2bWhtbcWGDRuSeIuFRVtbG9avX49p06ahuLgYzc3NAIDOzk60trZi8eLFYgCTTn79619j6dKlqKyshE6nw9NPP43Ozs60vw5BpALLMJIV9AYil7GSW9EC3ptUPIP9ktHFJCK4jURjqSai4FWjkiU9lLDOUASVInl1RaVelZGbe22JGqyERB9SKyUBSWRirrrqKlx11VVhH+N5Ho899hjuu+8+XHvttQCA5557DtXV1XjxxRdxyy23wGQy4ZlnnsHzzz+P1atXAwC2bNmCxsZGvPXWW7jiiitw7NgxbNu2Dbt378ayZcsAAE8//TRWrFiBEydOYPbs2cm+34gUKWQ4+uMr0r7feF87Xq6++mo0Njbi6aefRl1dHTiOQ0tLC5xOp2jLnwis7xvCBywJQ91wX375Zdx55514+OGHsWLFCuj1ejz00EPYs2dPwq9HEJmkUq+SrKA3lFKNEiartJyny+NoTQaQVIdSKqUkAaWcRV1JEbpGJpbiIo0ZiAeWZdBUpk0669FQmhn3d4WMRZVenbZRFQwDlGgUMFqS+9xJMYhJa4x39uxZ9PX1Yc2aNeLvVCoVLrnkEuzcuRMAcODAAbhcrqBt6urq0NLSIm6za9cuGAwGMYABgOXLl8NgMIjbpBuGYaBRynPyE28ddXh4GMeOHcMPfvADXHbZZZg7dy6MRqP4+IIFC9Da2oqRkZGwz1cqlUHZLgCorKwEAPT29oq/CxT5AsAHH3yAlStX4rbbbsPixYsxY8aMIDExQUiFfCglCZRLUNwbOPAxGsVqOWQJ+MWoFbK0mfw1lWsQ7pKZTCkpkPrS5LIxGlVmp6SnU+BbpJShMYWAq+CDmL6+PgBAdXV10O+rq6vFx/r6+qBUKlFaWhp1m6qqqgn7r6qqErcJxeFwYGxsLOin0CgtLUV5eTmeeuopnD59Gu+88w6+//3vi49/5StfQU1NDa655hp89NFHOHPmDP76179i165dAICpU6fi7NmzaG1txdDQEBwOB4qKirB8+XI88MADOHr0KN5//3384Ac/CHrdGTNmYP/+/XjjjTdw8uRJ/L//9/+wb9++rL53gogHXRo8OrKFoUghKS8Qlo1/rADDhHf0jUSNIX1Ca7VCNqFNu7hIEbeuMBIylsGSptKEy0KpBAXxUKJRpGwwKGAoUqBCp4IiiblODIOE/X2yQUaqbaGZBZ7nY2YbQrcJt320/dx///0wGAziT2NjYxJHLm1YlsVLL72EAwcOoKWlBXfeeSceeugh8XGlUont27ejqqoKn//85zF//nw88MAD4rTnL37xi7jyyitx6aWXorKyEn/84x8BAL/73e/gcrmwdOlSfO9738P//M//BL3ut7/9bVx77bX40pe+hGXLlmF4eBi33XZb9t44QRQgLMtIyr69RKOMOm8olESyDzUpzBIKR+gAx1RKSYFolHIsnVoa93wr75ykzGqwGIZJWwakWK0AyzJJ/b10Krmkgm6BtC5bhK6Xvr4+1NbWir8fGBgQszM1NTVwOp0wGo1B2ZiBgQGsXLlS3CZc6+/g4OCELI/AvffeG5SVGBsbK8hAZvXq1Th69GjQ7wL1LE1NTfjLX/4S9rkqlSrsY3PnzhWzNeH2qVKp8Pvf/x6///3vg7a5//77xf9/9tln434PBEF4KdMoMWJ25vowACAuq/5A4tXF6NTytGfIdCo5KvQqDI07wDBAdZozPec3leLjTiOsjuht1zXF6oQCv2QxFCkwnIbPiRA015Wow+qK4nmu1EjrX7+5uRk1NTV48803xd85nU7s2LFDDFCWLFkChUIRtE1vby8OHz4sbrNixQqYTCbs3btX3GbPnj0wmUziNqGoVCoUFxcH/RAEQUgZKQ2DjFcPIxCvLiZTmYqpvtlLpVpl2sXcaoUMS5pKY7r5pmNOUjykOuoB8JYL9b5gUq9OfMikFPUwQBKZGLPZjNOnT4v/FjQWZWVlmDJlCjZu3IjNmzdj5syZmDlzJjZv3gyNRoP169cD8Bqs3XTTTbjrrrtQXl6OsrIy3H333Zg/f77YrTR37lxceeWVuPnmm/Gb3/wGAPCtb30La9euzUhnEkEQRC4oVidvHJdONCpZwpoSQRcTLUPAMMmNGYiHEo13gGO6SkmhqOTeQOaTzlGM2SZ285RoFFnTiBiKUvcVKlYrguQY9SVFONEXfzdWwQQx+/fvx6WXXir+WyjhfP3rX8ezzz6Le+65BzabDbfddptodrd9+3bo9XrxOY8++ijkcjmuv/560ezu2WefFbUbAPDCCy/gjjvuELuY1q1bF9GbhiAIIh9hGAalGiUGEzSOSzfJmtCVapRRg5gSjTKj5mjNFdqM3lwVMhbnTylBa9coRkPa4TPVVh0OGctAp5Jj3J68e2+oL1F1sRqnBsbBRTZAFlHI2ZSF05mC4XkpekamztjYGAwGA0wm04TSkt1ux9mzZ9Hc3Ay1WvrGWIQfOndEodE1Yk1oRZwJzm8qTapN2GRzYd/Z8JYOADCvrjiv2t4j4eF4tHaNwmjxBmxKOYuLZ1RkdZrzib7xhHUsgbTUGya0oR/sHsXAWOwAulynxOIppTG3SxfR7t+hSMgLkCAIYvKRa12MTJZYu3Qg0XQxMpZBVRoHIuYSGctgcWOJON27rqQoqwEM4C1fpUK4jFVtnF1jUi0lARTEEARB5BSdSg5lEr4d6aJcq0z6hhzNL6ZCp8pK5062YFkGCxtKUFWsypqgN5BUAgmFnEVRmLbxCp0yrs8eBTEEQRBERDLp+BqLVIYyAl5dTDhSddCVIizLYEFDSU6GIKoVsqRftzhCJxLDxOdzI8U5XwIUxBAEQeSYXJaUhBJJsoQLYhRyVpJjFfKdZEtK0TIpsTRLGpUMCgln1KR7ZARBEJOEeO3+041Bo0jZY6W4aKIuprpYlXXNyGQg2bJOtEyKViWP+riUS0kABTFEBFatWoWNGzeK/546dSoee+yxnB0PQRQyRUpZWM1CplDKWcys1uH8NHSchLPFry3O/44kKZKsa26sQKSuJHJJSepBjDQbvwnJsW/fPmi12tgbEgSRFKUaJWxOW0ZfQ6Vg0VSmRX1pUVrn4ASOT9AoZZK1qM939Cpv1suTgDmiRhm7HFRdrMbJ/vCeMRTEEAVBZWVlrg+BIAqaWoMaHM+D43l4OB4c751hJvy/8Jib4xO6iQFeUWhTuQb1GWoNDtTFVBegoFcqMAyDYrVC9KuJh3hEuQoZiyq9Gn0me9DvZTJG8pPhqZyUZ6xatQq33347Nm7ciNLSUlRXV+Opp56CxWLBN77xDej1ekyfPh2vv/66+JyjR4/i85//PHQ6Haqrq7FhwwYMDQ2Jj1ssFnzta1+DTqdDbW0tHn744QmvG1pOeuSRRzB//nxotVo0Njbitttug9lsFh9/9tlnUVJSgjfeeANz586FTqfDlVdeid7e3sz8YQgizynVKtFSb8CChhIsnlKKJU2lWDq1DMumlWPF9HJcNKMCn5lZiUtnV+HimRVY0GjAtEotqopVEacuqxUyzKnVY+X0cjSWaTKmUyku8k84zvRU58lOouLeeDMp4c5b6KgCKUJBjADPA05Lbn4SNE1+7rnnUFFRgb179+L222/Hrbfeiuuuuw4rV67Exx9/jCuuuAIbNmyA1WpFb28vLrnkEixatAj79+/Htm3b0N/fj+uvv17c33/8x3/g3XffxdatW7F9+3a89957OHDgQNRjYFkWv/zlL3H48GE899xzeOedd3DPPfcEbWO1WvHzn/8czz//PN5//310dnbi7rvvTui9EgQxEbVChiq9GtMqdVjQUIKVMyqwanYllk4txewaPepLizC3rhgrp5ejoTRzwYsAwzAwaBQoLlJI1p6+UEjUmLA4zvlOZdqJIyIMRdI/l9I/wmzhsgKb63Lz2v99DlDGrzdZuHAhfvCDHwAA7r33XjzwwAOoqKjAzTffDAD44Q9/iCeffBIHDx7Ea6+9hvPPPx+bN28Wn/+73/0OjY2NOHnyJOrq6vDMM8/gD3/4Ay6//HIA3iCpoaEh6jEEin6bm5vxk5/8BLfeeit+9atfib93uVz49a9/jenTpwMAvvvd7+LHP/5x3O+TIIj4kctY31DE3HQ6lWqUkFNHUsZJZBgkywL6OKdVMwyDGoMa7UMW8XdS9ocRoCAmD1mwYIH4/zKZDOXl5Zg/f774u+rqagDAwMAADhw4gHfffRc6nW7Cftra2mCz2eB0OrFixQrx92VlZTGnhb/77rvYvHkzjh49irGxMbjdbtjtdlgsFlEArNFoxAAGAGprazEwMJDcmyYIQtJ4V/KU3M80chkLrUoOcxzDIHUqRUJZuLqS4CBG6qJegIIYPwqNNyOSq9dOZHNF8AeLYZig3wk1TI7jwHEcrr76avzsZz+bsJ/a2lqcOnUq4cPt6OjA5z//eXz729/GT37yE5SVleHDDz/ETTfdBJfLP+k13HEW6LxRgpj05MMNr1Ao0SjiCmKKEywHaZRylGgUGLW6UKSUpewhlA0oiBFgmIRKOvnC+eefj7/+9a+YOnUq5PKJp3vGjBlQKBTYvXs3pkyZAgAwGo04efIkLrnkkrD73L9/P9xuNx5++GGwrHfl9fLLL2fuTRAEQRAiJUVKdCN2O34ygWVdSRFGra68CUop91fgfOc738HIyAi+8pWvYO/evThz5gy2b9+Ob37zm/B4PNDpdLjpppvwH//xH3j77bdx+PBh3HjjjWJwEo7p06fD7Xbj8ccfx5kzZ/D888/j17/+dRbfFUEQxOQl3gAjXlFvIFV6FWQsk9RzcwEFMQVOXV0dPvroI3g8HlxxxRVoaWnB9773PRgMBjFQeeihh/DZz34W69atw+rVq3HxxRdjyZIlEfe5aNEiPPLII/jZz36GlpYWvPDCC7j//vuz9ZYIgiAmNUVKGVQx9EdyGQNtEh4vchmLqmJV3mRiGL5ARQpjY2MwGAwwmUwoLi4Oesxut+Ps2bNobm6GWk2eBvkEnTuCIAjgYPcoBsYcER8v0ymTHithsrqgV8tzNv8q2v07FMrEEARBEESeUVIUvZU+lXKQQZNYV1MuoSCGIAiCIPKMWPOp8qUclCoUxBAEQRBEnlGslkcd4ploe3W+QkEMQRAEQeQZDMNEDFTUivzweEkHFMQQBEEQRB5iiKCLmSylJICCGIIgCILISyJNtJ4spSSAghiCIAiCyEsiZVwoE0MQBEEQhKRR+IZBBsIwgD5P3HbTAQUxBEEQBJGnhGZdtKroXUuFBgUxBEEQBJGnhOpiJlMpCaAp1hN462h/Vl9v9bzqrL5ePrBq1SosWrQIjz32WK4PhSAIQtKEBjHFkyyIoUzMJKG5uRnbtm2Le/uf/vSnWLlyJTQaDUpKSlJ+/ffeew8Mw2B0dDTlfREEQRBeNEo5lHL/rXyyZWIoiMlzVq1ahWeffTbqNgcPHsTw8DAuvfTSuPfrdDpx3XXX4dZbb03xCAmCIIhMIgQuMhkDrXJymNwJUBAzCfi///s/XHHFFVCpVHE/50c/+hHuvPNOzJ8/P+7ndHR04Oqrr0ZpaSm0Wi3OO+88vPbaa2hvbxcDqNLSUjAMgxtv/P/bu/uYquo/DuDvexEuKHDHQ5dnEEeZygoLIqPCWkFYQ5OWcy2zaesWIApzk3ShrALnTLeWZuXI+kdSa5GShBN7GHNrIIkycSWT50ghHiy5yP38/nCcnzdQHrrnwuW8X9vduIfPPef75tzBZ9/z5dzVAIBr165h1apV8PT0RFBQEHbu3DmubEREWjd0ScnbfQZ0Ou0s6gW4JkYTSkpKkJWVpfpx0tPTYbFY8OOPP2LWrFmoq6uDp6cnwsLCcOTIEaSlpaG+vh7e3t7w8PAAAGzcuBEVFRX4+uuvERgYiLfeegtVVVWIiYlRfbxERNPB0EyM1i4lAWxipr2Wlhb8+uuvWLJkierHamxsRFpamjJ7M2fOHOV7vr6+AACTyaSssenr68P+/fvx+eef4+mnnwYAHDhwAKGhoaqPlYhouvB2d4Ver71FvQAvJzmd9957D56ensrjp59+gtlsHrZtSElJCRISEpQm4tY6s9k84XEsWLBA2U9KSgoAYN26dXjnnXeQkJCAvLw8nD179o77+P3332GxWLBo0SJlm6+vL+bOnTvhcRERaY1er4O3uyu8NXSTuyGciXEyZrMZL774ovL8pZdeQlpaGpYvX65sCwkJUb4uKSnB0qVLlec1NTXK197e3hMeR2lpKQYGBgBAuTS0du1aJCcn49ixY/j+++9RUFCAnTt3IjMzc8R9iMiEj09ERP8X4O0Od1dtLeoF2MQ4HV9fX2VWBbjZQJhMJkRFRQ2r7evrQ0VFBT788ENl20h1ExERETHi9rCwMJjNZpjNZuTm5uKTTz5BZmYm3Nxuftrq4OCgzVhcXV1x+vRphIeHAwC6urpw8eJFJCYm2mWcRERaEGR0n+whTAo2MdPY8ePHcffdd9usTRmrxsZGdHZ2orGxEYODg8oMTlRUFDw9PUd8zfr165GSkoJ77rkHXV1dOHnyJObNmwfgZtOj0+lw9OhRLFmyBB4eHvD09MSaNWuwceNG+Pn5ISAgAJs3b4Zez6ucRETjMcNFm7832cT8y3S6g+4333xjcylpPN5++20cOHBAeb5w4UIAQEVFBRYvXjziawYHB5Geno7m5mZ4e3vjmWeewa5duwDcvMS1bds2bNq0Ca+++ipWrVqFzz77DDt27EBfXx9SU1Ph5eWFnJwcdHd3T2jMRESkLTqZpgsTenp6YDQa0d3dPWztx/Xr19HQ0IDIyEi4u0/PKbjBwUGYTCZ89913eOihhyZ7OHajhXNHRKRld/r7/W/anH/SgKtXr2LDhg2Ii4ub7KEQERGpgpeTpimTyYQtW7ZM9jCIiIhUw5kYIiIickpsYoiIiMgpabqJsVqtkz0EGieeMyIiGqLJNTFubm7Q6/VobW3FXXfdBTc3N8198qezERFYLBb8+eef0Ov1ys3ziIhIuzTZxOj1ekRGRqKtrQ2tra2TPRwah5kzZyI8PJw3xCMioqnfxOzZswc7duxAW1sbFixYgN27d+Oxxx77z/t1c3NDeHg4bty4YXMrfJq6XFxcMGPGDM6aERERgCnexBQXF2P9+vXYs2cPEhISsG/fPqSkpKCurk75rJ3/QqfTwdXVFa6u2vvkTyIiImc3pe/YGx8fjwceeAB79+5Vts2bNw/Lli1DQUHBHV87njv+ERER0dQwLe7Ya7FYUFVVhaSkJJvtSUlJqKysnKRRERER0VQxZS8nXblyBYODgwgIsP1AxoCAALS3tw+r7+/vR39/v/K8p6dH9TESERHR5JmyTcyQfy/iFJERF3YWFBRg27Ztw7azmSEiInIeQ3+3x7LaZco2Mf7+/nBxcRk269LR0TFsdgYAcnNzkZ2drTxvaWnB/PnzERYWpvpYiYiIyL56e3thNBrvWDNlmxg3Nzc8+OCDKC8vx/PPP69sLy8vx9KlS4fVGwwGGAwG5bmnpyeamprg5eWlzNzExcXhl19+ueNxx1Jj77qx1PT09CAsLAxNTU2jLnSy1zEd/bOwd8ax1vFc2r+O51K9Y/JcqrMvnkv1xjbefYkIent7ERwcPOprpmwTAwDZ2dl4+eWXERsbi0WLFuHjjz9GY2MjzGbzqK/V6/UIDQ212ebi4jLqiRtLjb3rxrovAPD29rbL/qbqzwKwX8ax1vFcqlfHc2n/Y/JcqrcvgOdSjWNOZF+jzcAMmdJNzIoVK3D16lXk5+ejra0N0dHRKC0tRURExIT2l56ebpcae9eNdV9jZa9jTsbPYqwm4+fPczn+Okcfk+dSvTpHH5PnUr06Rx9TzfFP6fvE0P9p4b43WsgIaCOnFjIC2siphYyANnJOx4xT9j4xZMtgMCAvL89m3c90o4WMgDZyaiEjoI2cWsgIaCPndMzImRgiIiJySpyJISIiIqfEJoaIiIicEpsYIiIickpsYoiIiMgpsYlxkIKCAsTFxcHLywsmkwnLli1DfX29TY2IYOvWrQgODoaHhwcWL16M8+fP29T09/cjMzMT/v7+mDVrFlJTU9Hc3DziMfv7+xETEwOdToeamhq1oim0kBFwbM7Zs2dDp9PZPDZt2sSMduLo9+yxY8cQHx8PDw8P+Pv7Y/ny5armA7SREXBczlOnTg17vw49xnJXWma0MyGHSE5OlqKiIjl37pzU1NTIs88+K+Hh4dLX16fUFBYWipeXlxw5ckRqa2tlxYoVEhQUJD09PUqN2WyWkJAQKS8vl+rqanniiSfk/vvvlxs3bgw75rp16yQlJUUAyJkzZ5jRThyZMyIiQvLz86WtrU159Pb2MqMT5jx8+LD4+PjI3r17pb6+Xi5cuCCHDh1iRifL2d/fb/NebWtrk7Vr18rs2bPFarUyo4OxiZkkHR0dAkB++OEHERGxWq0SGBgohYWFSs3169fFaDTKRx99JCIif/31l7i6usrBgweVmpaWFtHr9XL8+HGb/ZeWlsq9994r58+fd+gf+FtpIaOIujkjIiJk165djglyB1rIKKJezoGBAQkJCZFPP/3UgWlGpoWMIur//hlisVjEZDJJfn6+imlGpoWMo+HlpEnS3d0NAPD19QUANDQ0oL29HUlJSUqNwWBAYmIiKisrAQBVVVUYGBiwqQkODkZ0dLRSAwB//PEHXnvtNXzxxReYOXOmI+KMSAsZAXVzAsD27dvh5+eHmJgYvPvuu7BYLGpHGkYLGQH1clZXV6OlpQV6vR4LFy5EUFAQUlJShk3zO4IWMgLqv2eHlJSU4MqVK1i9erVKSW5PCxlHwyZmEogIsrOz8eijjyI6OhoA0N7eDgAICAiwqQ0ICFC+197eDjc3N/j4+Ny2RkSwevVqmM1mxMbGqh3ltrSQcWgsauUEgKysLBw8eBAVFRXIyMjA7t278eabb6oZaRgtZATUzXnp0iUAwNatW7FlyxYcPXoUPj4+SExMRGdnp6q5bqWFjID679lb7d+/H8nJyQgLC7N3jDvSQsaxmNIfADldZWRk4OzZs/j555+HfU+n09k8F5Fh2/7t1poPPvgAPT09yM3Ntd+AJ0ALGQF1cwLAhg0blK/vu+8++Pj44IUXXlBmLhxBCxkBdXNarVYAwObNm5GWlgYAKCoqQmhoKA4dOoTXX3/dHhFGpYWMgPrv2SHNzc0oKyvDl19++d8GPAFayDgWnIlxsMzMTJSUlKCiogKhoaHK9sDAQAAY1gl3dHQoXXVgYCAsFgu6urpuW3Py5EmcPn0aBoMBM2bMQFRUFAAgNjYWr7zyimq5bqWFjID6OUfy8MMPAwB+++03u2QYjRYyAurnDAoKAgDMnz9f+b7BYMCcOXPQ2Nho/0Aj0EJGwLHv2aKiIvj5+SE1NdXeMe5ICxnHzFGLb7TOarVKenq6BAcHy8WLF0f8fmBgoGzfvl3Z1t/fP+KCrOLiYqWmtbXVZkHW5cuXpba2VnmUlZUJADl8+LA0NTUxox04KudIvv32WwEgly9ftmOi4bSQUcRxObu7u8VgMNgseh1aLLlv3z614ikZpnvGoRyOfM9arVaJjIyUnJwclRINp4WM48UmxkHeeOMNMRqNcurUKZt/W/v777+VmsLCQjEajfLVV19JbW2trFy5csR/jQsNDZUTJ05IdXW1PPnkk7f992MRkYaGBof9544WMoo4LmdlZaW8//77cubMGbl06ZIUFxdLcHCwpKamMqOT5RQRycrKkpCQECkrK5MLFy7ImjVrxGQySWdnJzM6WU4RkRMnTggAqaurUz2bljKOF5sYBwEw4qOoqEipsVqtkpeXJ4GBgWIwGOTxxx+X2tpam/38888/kpGRIb6+vuLh4SHPPfecNDY23va4jvwDr4WMIo7LWVVVJfHx8WI0GsXd3V3mzp0reXl5cu3aNWZ0spwiN2clcnJyxGQyiZeXlzz11FNy7tw5ZrQTR//+WblypTzyyCNqx7KhhYzjpRMRsdelKSIiIiJH4cJeIiIickpsYoiIiMgpsYkhIiIip8QmhoiIiJwSmxgiIiJySmxiiIiIyCmxiSEiIiKnxCaGiIiInBKbGCIiInJKbGKIiIjIKbGJISIiIqfEJoaIiIic0v8AV2oh44sLyVEAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(334)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bae5b44c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}