diff --git a/bin/mmnist/autoencoder2d/best_encoder.pth b/bin/mmnist/autoencoder2d/best_encoder.pth deleted file mode 100644 index e2834ea..0000000 Binary files a/bin/mmnist/autoencoder2d/best_encoder.pth and /dev/null differ diff --git a/bin/mmnist/autoencoder2d/contrastive05/best_decoder.pth b/bin/mmnist/autoencoder2d/contrastive05/best_decoder.pth new file mode 100644 index 0000000..25c2518 Binary files /dev/null and b/bin/mmnist/autoencoder2d/contrastive05/best_decoder.pth differ diff --git a/bin/mmnist/autoencoder2d/contrastive05/best_encoder.pth b/bin/mmnist/autoencoder2d/contrastive05/best_encoder.pth new file mode 100644 index 0000000..2db308e Binary files /dev/null and b/bin/mmnist/autoencoder2d/contrastive05/best_encoder.pth differ diff --git a/bin/mmnist/autoencoder2d/contrastive05/best_model.pth b/bin/mmnist/autoencoder2d/contrastive05/best_model.pth new file mode 100644 index 0000000..e5d6dac Binary files /dev/null and b/bin/mmnist/autoencoder2d/contrastive05/best_model.pth differ diff --git a/hrdae/__init__.py b/hrdae/__init__.py index 5535101..16fe9cb 100644 --- a/hrdae/__init__.py +++ b/hrdae/__init__.py @@ -160,7 +160,7 @@ ) cs.store( group="config/experiment/model/loss", - name="perceptual", + name="perceptual2d", node=Perceptual2dLossOption, ) cs.store( diff --git a/notebook/mmnist.ipynb b/notebook/mmnist.ipynb index 5e3478e..e088baa 100644 --- a/notebook/mmnist.ipynb +++ b/notebook/mmnist.ipynb @@ -12,55 +12,49 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "import torch\n", + "import matplotlib.pyplot as plt\n", "from torch.utils.data import DataLoader\n", "from torchvision import transforms\n", - "from hrdae.models.networks import create_network, RDAE2dOption\n", + "from hrdae.models.networks import create_network, RDAE2dOption, AutoEncoder2dNetworkOption\n", "from hrdae.models.networks.motion_encoder import MotionRNNEncoder1dOption\n", "from hrdae.models.networks.rnn import TCN1dOption\n", "from hrdae.dataloaders.datasets import create_dataset, MovingMNISTDatasetOption\n", "from hrdae.dataloaders.transforms import create_transform, MinMaxNormalizationOption\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# contrastive autoencoderの効果測定" + ] + }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ + "# results/BasicDataLoaderOption/BasicModelOption/AutoEncoder2dNetworkOption/2024-07-02_07-37-26/options.yaml\n", "net = create_network(\n", " 1,\n", - " opt=RDAE2dOption(\n", + " opt=AutoEncoder2dNetworkOption(\n", " activation=\"sigmoid\",\n", - " aggregator=\"addition\",\n", - " cycle=False,\n", - " in_channels=1,\n", " hidden_channels=64,\n", - " latent_dim=8,\n", - " conv_params=[{\"kernel_size\": [3], \"stride\": [2], \"padding\": [1]}] * 3,\n", - " motion_encoder=MotionRNNEncoder1dOption(\n", - " in_channels=5,\n", - " hidden_channels=64,\n", - " conv_params=[{\"kernel_size\": [3], \"stride\": [2], \"padding\": [1]}] * 3,\n", - " deconv_params=[{\"kernel_size\": [3], \"stride\": [1, 2], \"padding\": [1]}] * 3,\n", - " rnn=TCN1dOption(\n", - " num_layers=3,\n", - " image_size=8,\n", - " kernel_size=4,\n", - " dropout=0.1,\n", - " )\n", - " )\n", + " latent_dim=32,\n", + " conv_params=[{\"kernel_size\": [3], \"stride\": [2], \"padding\": [1], \"output_padding\": [1]}] * 4,\n", " )\n", ")" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -69,26 +63,26 @@ "" ] }, - "execution_count": 14, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "net.load_state_dict(torch.load(\"../results/BasicDataLoaderOption/PVRModelOption/rdae2d/2024-06-27_21-27-00/weights/best_model.pth\"))" + "net.load_state_dict(torch.load(\"../results/BasicDataLoaderOption/BasicModelOption/AutoEncoder2dNetworkOption/2024-07-02_07-37-26/weights/best_model.pth\"))" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "RDAE2d(\n", - " (content_encoder): Encoder2d(\n", - " (cnn): ConvModule2d(\n", + "AutoEncoder2d(\n", + " (encoder): AEEncoder2d(\n", + " (cnn): HierarchicalConvEncoder2d(\n", " (layers): ModuleList(\n", " (0): Sequential(\n", " (0): ConvBlock2d(\n", @@ -98,7 +92,7 @@ " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " )\n", " )\n", - " (1-2): 2 x Sequential(\n", + " (1-3): 3 x Sequential(\n", " (0): ConvBlock2d(\n", " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", " )\n", @@ -106,142 +100,22 @@ " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " )\n", " )\n", - " (3): ConvBlock2d(\n", + " (4): ConvBlock2d(\n", " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " )\n", " )\n", " )\n", " (bottleneck): PixelWiseConv2d(\n", - " (conv): Conv2d(64, 8, kernel_size=(1, 1), stride=(1, 1))\n", - " )\n", - " )\n", - " (motion_encoder): MotionRNNEncoder1d(\n", - " (cnn): ConvModule1d(\n", - " (layers): ModuleList(\n", - " (0): Sequential(\n", - " (0): ConvBlock1d(\n", - " (conv): Conv1d(5, 64, kernel_size=(3,), stride=(2,), padding=(1,))\n", - " )\n", - " (1): IdenticalConvBlock1d(\n", - " (conv): Conv1d(64, 64, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (1): Sequential(\n", - " (0): ConvBlock1d(\n", - " (conv): Conv1d(64, 64, kernel_size=(3,), stride=(2,), padding=(1,))\n", - " )\n", - " (1): IdenticalConvBlock1d(\n", - " (conv): Conv1d(64, 64, kernel_size=(3,), stride=(1,), padding=(1,))\n", - " )\n", - " )\n", - " (2): ConvBlock1d(\n", - " (conv): Conv1d(64, 64, kernel_size=(3,), stride=(2,), padding=(1,))\n", - " )\n", - " )\n", - " )\n", - " (rnn): TCN1d(\n", - " (rnn): TCN1d(\n", - " (tcn): TCN(\n", - " (network): ModuleList(\n", - " (0): TemporalBlock(\n", - " (conv1): ParametrizedCausalConv1d(\n", - " 512, 512, kernel_size=(4,), stride=(1,)\n", - " (parametrizations): ModuleDict(\n", - " (weight): ParametrizationList(\n", - " (0): _WeightNorm()\n", - " )\n", - " )\n", - " )\n", - " (conv2): ParametrizedCausalConv1d(\n", - " 512, 512, kernel_size=(4,), stride=(1,)\n", - " (parametrizations): ModuleDict(\n", - " (weight): ParametrizationList(\n", - " (0): _WeightNorm()\n", - " )\n", - " )\n", - " )\n", - " (activation1): ReLU()\n", - " (activation2): ReLU()\n", - " (activation_final): ReLU()\n", - " (dropout1): Dropout(p=0.1, inplace=False)\n", - " (dropout2): Dropout(p=0.1, inplace=False)\n", - " )\n", - " (1): TemporalBlock(\n", - " (conv1): ParametrizedCausalConv1d(\n", - " 512, 512, kernel_size=(4,), stride=(1,), dilation=(2,)\n", - " (parametrizations): ModuleDict(\n", - " (weight): ParametrizationList(\n", - " (0): _WeightNorm()\n", - " )\n", - " )\n", - " )\n", - " (conv2): ParametrizedCausalConv1d(\n", - " 512, 512, kernel_size=(4,), stride=(1,), dilation=(2,)\n", - " (parametrizations): ModuleDict(\n", - " (weight): ParametrizationList(\n", - " (0): _WeightNorm()\n", - " )\n", - " )\n", - " )\n", - " (activation1): ReLU()\n", - " (activation2): ReLU()\n", - " (activation_final): ReLU()\n", - " (dropout1): Dropout(p=0.1, inplace=False)\n", - " (dropout2): Dropout(p=0.1, inplace=False)\n", - " )\n", - " (2): TemporalBlock(\n", - " (conv1): ParametrizedCausalConv1d(\n", - " 512, 512, kernel_size=(4,), stride=(1,), dilation=(4,)\n", - " (parametrizations): ModuleDict(\n", - " (weight): ParametrizationList(\n", - " (0): _WeightNorm()\n", - " )\n", - " )\n", - " )\n", - " (conv2): ParametrizedCausalConv1d(\n", - " 512, 512, kernel_size=(4,), stride=(1,), dilation=(4,)\n", - " (parametrizations): ModuleDict(\n", - " (weight): ParametrizationList(\n", - " (0): _WeightNorm()\n", - " )\n", - " )\n", - " )\n", - " (activation1): ReLU()\n", - " (activation2): ReLU()\n", - " (activation_final): ReLU()\n", - " (dropout1): Dropout(p=0.1, inplace=False)\n", - " (dropout2): Dropout(p=0.1, inplace=False)\n", - " )\n", - " )\n", - " )\n", - " )\n", - " )\n", - " (tcnn): ConvModule2d(\n", - " (layers): ModuleList(\n", - " (0-1): 2 x Sequential(\n", - " (0): ConvBlock2d(\n", - " (conv): ConvTranspose2d(64, 64, kernel_size=(3, 3), stride=(1, 2), padding=(1, 1), output_padding=(0, 1))\n", - " )\n", - " (1): IdenticalConvBlock2d(\n", - " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " )\n", - " )\n", - " (2): ConvBlock2d(\n", - " (conv): ConvTranspose2d(64, 64, kernel_size=(3, 3), stride=(1, 2), padding=(1, 1), output_padding=(0, 1))\n", - " )\n", - " )\n", - " )\n", - " (bottleneck): PixelWiseConv2d(\n", - " (conv): Conv2d(64, 8, kernel_size=(1, 1), stride=(1, 1))\n", + " (conv): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1))\n", " )\n", " )\n", - " (decoder): Decoder2d(\n", + " (decoder): AEDecoder2d(\n", " (bottleneck): PixelWiseConv2d(\n", - " (conv): Conv2d(8, 64, kernel_size=(1, 1), stride=(1, 1))\n", + " (conv): Conv2d(32, 64, kernel_size=(1, 1), stride=(1, 1))\n", " )\n", " (cnn): ConvModule2d(\n", " (layers): ModuleList(\n", - " (0-1): 2 x Sequential(\n", + " (0-2): 3 x Sequential(\n", " (0): ConvBlock2d(\n", " (conv): ConvTranspose2d(64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n", " )\n", @@ -249,18 +123,17 @@ " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " )\n", " )\n", - " (2): ConvBlock2d(\n", + " (3): ConvBlock2d(\n", " (conv): ConvTranspose2d(64, 1, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n", " )\n", " )\n", " )\n", " )\n", " (activation): Sigmoid()\n", - " (aggregator): AdditionAggregator2d()\n", ")" ] }, - "execution_count": 15, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -271,7 +144,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -293,143 +166,69 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ - "loader = DataLoader(dataset=dataset, batch_size=10, shuffle=False)" + "loader = DataLoader(dataset=dataset, batch_size=8, shuffle=False)" ] }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0 0 tensor(1.4039e-10, grad_fn=)\n", - "0 1 tensor(2.2091e-10, grad_fn=)\n", - "0 2 tensor(1.8385e-10, grad_fn=)\n", - "0 3 tensor(9.5200e-11, grad_fn=)\n", - "0 4 tensor(3.6294e-10, grad_fn=)\n", - "0 5 tensor(3.1136e-10, grad_fn=)\n", - "0 6 tensor(1.1639e-10, grad_fn=)\n", - "0 7 tensor(7.3829e-11, grad_fn=)\n", - "0 8 tensor(4.8012e-11, grad_fn=)\n", - "0 9 tensor(5.2832e-11, grad_fn=)\n", - "1 0 tensor(2.2091e-10, grad_fn=)\n", - "1 1 tensor(3.0423e-10, grad_fn=)\n", - "1 2 tensor(7.5801e-11, grad_fn=)\n", - "1 3 tensor(3.8858e-10, grad_fn=)\n", - "1 4 tensor(6.2034e-10, grad_fn=)\n", - "1 5 tensor(2.4635e-10, grad_fn=)\n", - "1 6 tensor(1.1119e-10, grad_fn=)\n", - "1 7 tensor(2.3004e-10, grad_fn=)\n", - "1 8 tensor(2.6573e-10, grad_fn=)\n", - "1 9 tensor(3.0289e-10, grad_fn=)\n", - "2 0 tensor(1.8385e-10, grad_fn=)\n", - "2 1 tensor(7.5801e-11, grad_fn=)\n", - "2 2 tensor(3.6883e-10, grad_fn=)\n", - "2 3 tensor(3.2594e-10, grad_fn=)\n", - "2 4 tensor(5.0680e-10, grad_fn=)\n", - "2 5 tensor(1.4440e-10, grad_fn=)\n", - "2 6 tensor(1.3460e-10, grad_fn=)\n", - "2 7 tensor(2.1659e-10, grad_fn=)\n", - "2 8 tensor(1.9823e-10, grad_fn=)\n", - "2 9 tensor(2.4722e-10, grad_fn=)\n", - "3 0 tensor(9.5200e-11, grad_fn=)\n", - "3 1 tensor(3.8858e-10, grad_fn=)\n", - "3 2 tensor(3.2594e-10, grad_fn=)\n", - "3 3 tensor(2.7341e-10, grad_fn=)\n", - "3 4 tensor(2.1864e-10, grad_fn=)\n", - "3 5 tensor(3.4957e-10, grad_fn=)\n", - "3 6 tensor(1.7128e-10, grad_fn=)\n", - "3 7 tensor(8.5589e-11, grad_fn=)\n", - "3 8 tensor(1.2116e-10, grad_fn=)\n", - "3 9 tensor(7.4654e-11, grad_fn=)\n", - "4 0 tensor(3.6294e-10, grad_fn=)\n", - "4 1 tensor(6.2034e-10, grad_fn=)\n", - "4 2 tensor(5.0680e-10, grad_fn=)\n", - "4 3 tensor(2.1864e-10, grad_fn=)\n", - "4 4 tensor(5.7858e-10, grad_fn=)\n", - "4 5 tensor(3.6352e-10, grad_fn=)\n", - "4 6 tensor(3.7786e-10, grad_fn=)\n", - "4 7 tensor(2.8377e-10, grad_fn=)\n", - "4 8 tensor(3.4256e-10, grad_fn=)\n", - "4 9 tensor(2.5163e-10, grad_fn=)\n", - "5 0 tensor(3.1136e-10, grad_fn=)\n", - "5 1 tensor(2.4635e-10, grad_fn=)\n", - "5 2 tensor(1.4440e-10, grad_fn=)\n", - "5 3 tensor(3.4957e-10, grad_fn=)\n", - "5 4 tensor(3.6352e-10, grad_fn=)\n", - "5 5 tensor(4.9348e-10, grad_fn=)\n", - "5 6 tensor(2.1875e-10, grad_fn=)\n", - "5 7 tensor(2.6515e-10, grad_fn=)\n", - "5 8 tensor(2.7397e-10, grad_fn=)\n", - "5 9 tensor(3.0599e-10, grad_fn=)\n", - "6 0 tensor(1.1639e-10, grad_fn=)\n", - "6 1 tensor(1.1119e-10, grad_fn=)\n", - "6 2 tensor(1.3460e-10, grad_fn=)\n", - "6 3 tensor(1.7128e-10, grad_fn=)\n", - "6 4 tensor(3.7786e-10, grad_fn=)\n", - "6 5 tensor(2.1875e-10, grad_fn=)\n", - "6 6 tensor(2.5243e-10, grad_fn=)\n", - "6 7 tensor(8.0260e-11, grad_fn=)\n", - "6 8 tensor(1.2736e-10, grad_fn=)\n", - "6 9 tensor(1.3085e-10, grad_fn=)\n", - "7 0 tensor(7.3829e-11, grad_fn=)\n", - "7 1 tensor(2.3004e-10, grad_fn=)\n", - "7 2 tensor(2.1659e-10, grad_fn=)\n", - "7 3 tensor(8.5589e-11, grad_fn=)\n", - "7 4 tensor(2.8377e-10, grad_fn=)\n", - "7 5 tensor(2.6515e-10, grad_fn=)\n", - "7 6 tensor(8.0260e-11, grad_fn=)\n", - "7 7 tensor(2.5253e-10, grad_fn=)\n", - "7 8 tensor(8.5414e-11, grad_fn=)\n", - "7 9 tensor(5.3537e-11, grad_fn=)\n", - "8 0 tensor(4.8012e-11, grad_fn=)\n", - "8 1 tensor(2.6573e-10, grad_fn=)\n", - "8 2 tensor(1.9823e-10, grad_fn=)\n", - "8 3 tensor(1.2116e-10, grad_fn=)\n", - "8 4 tensor(3.4256e-10, grad_fn=)\n", - "8 5 tensor(2.7397e-10, grad_fn=)\n", - "8 6 tensor(1.2736e-10, grad_fn=)\n", - "8 7 tensor(8.5414e-11, grad_fn=)\n", - "8 8 tensor(2.5835e-10, grad_fn=)\n", - "8 9 tensor(4.4578e-11, grad_fn=)\n", - "9 0 tensor(5.2832e-11, grad_fn=)\n", - "9 1 tensor(3.0289e-10, grad_fn=)\n", - "9 2 tensor(2.4722e-10, grad_fn=)\n", - "9 3 tensor(7.4654e-11, grad_fn=)\n", - "9 4 tensor(2.5163e-10, grad_fn=)\n", - "9 5 tensor(3.0599e-10, grad_fn=)\n", - "9 6 tensor(1.3085e-10, grad_fn=)\n", - "9 7 tensor(5.3537e-11, grad_fn=)\n", - "9 8 tensor(4.4578e-11, grad_fn=)\n", - "9 9 tensor(2.1350e-10, grad_fn=)\n" + "torch.Size([8, 10, 1, 64, 64])\n", + "torch.Size([80, 1, 64, 64]) torch.Size([80, 32, 4, 4])\n" ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvwAAAKqCAYAAABGj4plAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACRAElEQVR4nO3de3hV5Z3+/zsEcjCQBBASg+EgoogHVFSMh9FaKuNYR0entY5TrfXQWrAq7a+WjoraqdiTtXZQqlXsyS/WadU6noooWKd4AMVqreABBMGAoEkgCsFk/f5wjI1kfe6EDcnO7vt1XbkuzWc/a6291rPWXjxZ+37ykiRJBAAAACAn9eruDQAAAACw43DDDwAAAOQwbvgBAACAHMYNPwAAAJDDuOEHAAAAchg3/AAAAEAO44YfAAAAyGHc8AMAAAA5jBt+AAAAIIdxww9gh7viiiuUl5fX3ZsBAMDfJW74AXTKbbfdpry8vNafoqIiVVVVaeLEibr++uu1YcOG7bKe1atX64orrtDixYu3y/K624f7beHChe3Wjz76aO2zzz47dBvuv/9+XXHFFTt0HQCA7MMNP4BtctVVV+mXv/ylbrzxRl1wwQWSpIsuukj77ruv/vznP7d57aWXXqr33nuvU8tfvXq1rrzyypy54c8G999/v6688sru3gwAQBfr3d0bAKBnOu6443TQQQe1/v/UqVP1yCOP6NOf/rT++Z//WX/9619VXFwsSerdu7d69+ZyAwBAd2CEH8B2c8wxx+iyyy7T66+/rl/96letv2/vGf45c+boiCOOUHl5ufr27as999xT3/rWtyRJ8+bN08EHHyxJOuuss1ofH7rtttskSX/84x/1mc98RkOHDlVhYaGqq6t18cUXb/VXhC984Qvq27evVq1apZNOOkl9+/bVoEGD9PWvf13Nzc1tXtvS0qIf//jH2nfffVVUVKRBgwbpH//xH7d6BOdXv/qVxo0bp+LiYg0YMECf+9zntHLlyu2y/9rTkfV1ZH984Qtf0IwZMySpzSNZkrR8+XLl5eXpBz/4gWbMmKHddttNO+20k4499litXLlSSZLo29/+tnbddVcVFxfrxBNP1Ntvv91mG+655x4df/zxqqqqUmFhoUaOHKlvf/vbW+3nDx9dWrRokQ477DAVFxdrxIgRmjlz5o7YfQAAMcIPYDv7/Oc/r29961v6wx/+oHPPPbfd1/zlL3/Rpz/9ae2333666qqrVFhYqFdeeUX/+7//K0naa6+9dNVVV+nyyy/XeeedpyOPPFKSdNhhh0mS7rzzTr377rs6//zzNXDgQD311FP6yU9+ojfeeEN33nlnm3U1Nzdr4sSJGj9+vH7wgx/o4Ycf1g9/+EONHDlS559/fuvrzj77bN1222067rjjdM455+j999/XH//4Rz3xxBOtf8n4zne+o8suu0yf/exndc455+itt97ST37yE/3DP/yDnn32WZWXl9v9U19fr3Xr1m31+y1btmz1u46uryP740tf+pJWr16tOXPm6Je//GW72/brX/9aTU1NuuCCC/T222/re9/7nj772c/qmGOO0bx583TJJZfolVde0U9+8hN9/etf16233tra9rbbblPfvn01ZcoU9e3bV4888oguv/xyNTQ06Pvf/36b9bzzzjv6p3/6J332s5/Vaaedpt/85jc6//zzVVBQoC9+8Yt2HwIAOikBgE6YNWtWIil5+umnU19TVlaWHHDAAa3/P23atORvLzc/+tGPEknJW2+9lbqMp59+OpGUzJo1a6vau+++u9Xvpk+fnuTl5SWvv/566+/OPPPMRFJy1VVXtXntAQcckIwbN671/x955JFEUvLVr351q+W2tLQkSZIky5cvT/Lz85PvfOc7berPP/980rt3761+/3Ef7rfoZ++99259fWfW19H9MWnSpKS9y/6yZcsSScmgQYOSurq61t9PnTo1kZSMHTs22bJlS+vvTzvttKSgoCDZtGlTuA1f+tKXkp122qnN64466qhEUvLDH/6w9XebN29O9t9//2Tw4MFJU1PT1jsPAJARHukBsN317ds3TOv5cGT6nnvuUUtLS6eX/+F3AySpsbFR69at02GHHaYkSfTss89u9fovf/nLbf7/yCOP1Guvvdb6/7/97W+Vl5enadOmbdX2w8defve736mlpUWf/exntW7dutafyspKjRo1So8++miHtn3GjBmaM2fOVj/77bdfm9d1Zn2d3R9pPvOZz6isrKz1/8ePHy9J+vd///c238EYP368mpqatGrVqna3YcOGDVq3bp2OPPJIvfvuu3rppZfarKd379760pe+1Pr/BQUF+tKXvqS1a9dq0aJFHd5eAEDH8EgPgO1u48aNGjx4cGr91FNP1c9+9jOdc845+uY3v6lPfvKTOvnkk/Wv//qv6tXLj0OsWLFCl19+uX7/+9/rnXfeaVOrr69v8/8fPo//t/r379+m3auvvqqqqioNGDAgdZ0vv/yykiTRqFGj2q336dPHbrckHXLIIW2+7Py32/S3j/p0Zn2d2R+RoUOHtvn/D2/+q6ur2/39367rL3/5iy699FI98sgjamhoCLehqqpKJSUlbX63xx57SPrg+wSHHnpoh7cZAOBxww9gu3rjjTdUX1+v3XffPfU1xcXFeuyxx/Too4/qvvvu04MPPqg77rhDxxxzjP7whz8oPz8/tW1zc7M+9alP6e2339Yll1yi0aNHq6SkRKtWrdIXvvCFrf5iEC2rM1paWpSXl6cHHnig3WX27dt3u6yns+vr7P6IpO2rtN8nSSJJqqur01FHHaXS0lJdddVVGjlypIqKivTMM8/okksu2aa/4gAAth9u+AFsVx9+IXTixInh63r16qVPfvKT+uQnP6lrr71WV199tf7jP/5Djz76qCZMmJA6M+/zzz+vpUuX6uc//7nOOOOM1t/PmTNnm7d55MiReuihh/T222+njvKPHDlSSZJoxIgRraPRO1JH19eZ/bGjZjueN2+e1q9fr9/97nf6h3/4h9bfL1u2rN3Xr169Wo2NjW1G+ZcuXSpJGj58+A7ZRgD4e8Yz/AC2m0ceeUTf/va3NWLECJ1++umpr/t4pKMk7b///pKkzZs3S1LrzWBdXV2b13042vzh6PKH//3jH/94m7f7lFNOUZIk7U5K9eF6Tj75ZOXn5+vKK69ss+4PX7N+/fptXn97Orq+zuyPtH2aqfa2oampSTfccEO7r3///ff105/+tM1rf/rTn2rQoEEaN27cdt02AAAj/AC20QMPPKCXXnpJ77//vtasWaNHHnlEc+bM0bBhw/T73/9eRUVFqW2vuuoqPfbYYzr++OM1bNgwrV27VjfccIN23XVXHXHEEZI+GOEuLy/XzJkz1a9fP5WUlGj8+PEaPXq0Ro4cqa9//etatWqVSktL9dvf/narZ9c74xOf+IQ+//nP6/rrr9fLL7+sf/zHf1RLS4v++Mc/6hOf+IQmT56skSNH6j//8z81depULV++XCeddJL69eunZcuW6a677tJ5552nr3/969u8DR/X0fV1Zn98eDP91a9+VRMnTlR+fr4+97nPZbythx12mPr3768zzzxTX/3qV5WXl6df/vKXW/1D5UNVVVX67ne/q+XLl2uPPfbQHXfcocWLF+umm27q8HchAACd0MWpQAB6uI/HSxYUFCSVlZXJpz71qeTHP/5x0tDQsFWbj8dyzp07NznxxBOTqqqqpKCgIKmqqkpOO+20ZOnSpW3a3XPPPcmYMWOS3r17t4nofPHFF5MJEyYkffv2TXbeeefk3HPPTZ577rmtYjzPPPPMpKSkxG5PkiTJ+++/n3z/+99PRo8enRQUFCSDBg1KjjvuuGTRokVtXvfb3/42OeKII5KSkpKkpKQkGT16dDJp0qRkyZIlHdpvaXGmRx11VJtYzs6sr6P74/33308uuOCCZNCgQUleXl7rPvgwlvP73/9+m3U/+uijiaTkzjvvtO/lf//3f5NDDz00KS4uTqqqqpJvfOMbyUMPPZRISh599NGt3ufChQuTmpqapKioKBk2bFjyX//1X+H+AwBsu7wkSRmCAQBgOzv66KO1bt06vfDCC929KQDwd4Nn+AEAAIAcxg0/AAAAkMO44QcAAAByGDf8AIAuM2/ePJ7fB/B367HHHtMJJ5ygqqoq5eXl6e6777Zt5s2bpwMPPFCFhYXafffdddttt3V6vdzwAwAAAF2gsbFRY8eO1YwZMzr0+mXLlun444/XJz7xCS1evFgXXXSRzjnnHD300EOdWi8pPQAAAEAXy8vL01133aWTTjop9TWXXHKJ7rvvvjZ/Gf3c5z6nuro6Pfjggx1eV9ZNvNXS0qLVq1erX79+O2waeAAAAHRckiTasGGDqqqq1KtX9j0gsmnTJjU1NXXLupMk2eqetbCwUIWFhRkve8GCBZowYUKb302cOFEXXXRRp5azw274Z8yYoe9///uqra3V2LFj9ZOf/ESHHHKIbbd69WpVV1fvqM0CAADANlq5cqV23XXX7t6MNjZt2qQRI0aotra2W9bft29fbdy4sc3vpk2bpiuuuCLjZdfW1qqioqLN7yoqKtTQ0KD33ntPxcXFHVrODrnhv+OOOzRlyhTNnDlT48eP13XXXaeJEydqyZIlGjx4cNi2X79+kj7oUKWlpSmvGp6+gHu2nk6+jeVxWb+Ky0uXptdeNYvub+pDg9o603ZvU3fyg/7yyntx2w1m2QdEbzztEH9ojKlvMfXNQe0m07bK7NW3/pJeu88s+w5TX2XqUTd/17Q1mt5Pr7nd7UT9eBfTtmCAecEpph7tM3e9NJeV6I098ETc1J0/NaZeXRAUDzSNDzD19UHtGdPW9cMhpn5UUFth2r4YlxuC7ww3m0W7rtDH1KuDT90kOPckKc8dr+gErTRtdzL1ogzW7S4c7ngGg6QNT8dNF5pFH3O+ecEngtobpu08U482znUkN3BsOmrDW+m1jcHvD9ZH92nZpKmpSbW1tebeccdoaGhQdXX1VuveHqP729MOueG/9tprde655+qss86SJM2cOVP33Xefbr31Vn3zm98M2374J5HS0tLgoAWP+mR60cqPy32Dmlt1ialHp9Am0zbT7p0f7NLoPUuS+xJIafRklvuroLvoOdGnt7tmlZrOEB0UdwPpzjy3X6J9muGTcNEfRDO94Y/+/eX6cIHbJ9GNrxT3pUzaSuHxdNcFd4Npu2l0vF0/c59H0fs2p4ftw5lsmzsebtsC7niYe3K7adHxctfSPPe+WoKa27BM65lw7yuDOxX3uVvqzoHoBHbXebfPonPEnT+Znn8B9xGSzY9bx/eOPXPdlZWVWrNmTZvfrVmzRqWlpR0e3Zd2wA1/U1OTFi1apKlTp7b+rlevXpowYYIWLFiw1es3b96szZs/ug1oaGjY3psEAACAnPe+/D/Ld8Q6d5yamhrdf//9bX43Z84c1dS4v/+2td2/dbFu3To1Nze3+7xRe89WTZ8+XWVlZa0/PL8PAACAXLRx40YtXrxYixcvlvRB7ObixYu1YsUHz7ZNnTpVZ5xxRuvrv/zlL+u1117TN77xDb300ku64YYb9Jvf/EYXX3xxp9bb7V+znjp1qurr61t/Vq5c2d2bBAAAgB7n/W766biFCxfqgAMO0AEHfPClnClTpuiAAw7Q5ZdfLkl68803W2/+JWnEiBG67777NGfOHI0dO1Y//OEP9bOf/UwTJ07s1Hq3+yM9O++8s/Lz89t93qiycutvDW2v2CIAAAAgmx199NGKpsBqbxbdo48+Ws8++2xG693uI/wFBQUaN26c5s6d2/q7lpYWzZ07t9PPGwEAAAAdk/0j/N1lh6T0TJkyRWeeeaYOOuggHXLIIbruuuvU2NjYmtrTMcOV/l3xICvulLHxYl/9c1w3MVuj306vla9Jr0k+EKN/9I1+E49iQ11c1E4QZZBv4vVc+l5jsM92CmqSlOcW7jINo8gNF9e7yfSVuqDmtutgUx9t6lFCUJ1pa/Z5QRAJWhBEuUmyyRFN9cGyd2QikxSnbbh1u6idivTSbqZpnamXm3qYPOZSydz7jiJOzPw275lrabHrS1Esp4stM9kPUVdxu6zc1DMZRXOXO5c4oyi61vVhl/riNi6KcA3Oe0m2L0VvvNS8r2q33S+berRfXjJtl5h63TauV/LxXY1xOfqIWp3y+7S4TvQMO+SG/9RTT9Vbb72lyy+/XLW1tdp///314IMPbvVFXgAAAAA71g6baXfy5MmaPHnyjlo8AAAA8DdyL5Zze+n2lB4AAAAAO84OG+EHAAAAuk6zun7E3X2BLDswwg8AAADkMG74AQAAgByWvY/03PNOeoxYGL35XLzckQPj+gEms/CP6aVCE8tplqwtQfSmm394yAjzAvO2o4ivkWbD+5jI0Cg1Lc9llZposbUmci3atCGPmHW7OLeIi2MrM3WXDTgoqLn4PRcZGu00c6y12dQjLiLS7ZNM6i7iriXDdQdc+p6rh8czikqU0vP3PhREZzYsi5s+YxZdYvrKwS8GxdfMwl+Py1FiaHRqST4R1I6iBeeQS68sKTcviJ4scBvurgtOtM/dst01qzyoRVGkkga46/iTph71UxfL6T70o87iMlgzvB5uCTI207pKJpf3rsOXdtMwwg8AAADksOwd4QcAAAA6jBH+NIzwAwAAADmMG34AAAAgh/FIDwAAAHIAj/SkYYQfAAAAyGGM8AMAACAHNKvrZ77tGTPtZu8N/3Kl58i++uf0di5n3wVTH5kX14Ns6P51cdMWk1sdxQmbiH9piKm7/hhkQzeb7HUXzZ4XZSy7vzGZLOHBJhg4iTbuLrNul4O8a1BzOfujTL3c1KPO4rKfXR531D7IZZdk+1kUx11u8rLzXB92edtRexd27zKvG9JLmR4ONz2BzTDPZOHBxrlodbfoHfrn5cq4XBHMP+CmZMjgUiop7mp2n7idGk3YUuEWbmQwZ4PdqU51UDMdsTyadEHy143l6aUms+xMLlkDTR/OdMKIqCulXe56xoMrSJO9N/wAAABAhzWr6/9p0jNG+HmGHwAAAMhh3PADAAAAOYxHegAAAJADiOVMwwg/AAAAkMMY4QcAAEAOYIQ/DSP8AAAAQA7L3hH+Xyk9sDjKvj3ApF67nP2RSVz/XhBmvO/asOnA/4oXrZZg0c+YtrubustQfjm95HLCXYT5e0HYsFv2lo1x3UUoR8vfaUHctsAsu7ImKB5oGo8x9d1MfXhQC+aKkOQD1AONz8V1Fwkfxdm7Ltpo5lzY4yGzgEyywF0Of1V6yU1d4PaZy3UviE4Ct3JzDqg2veSOl9tuK7qUR/NQdKA+OErRM/1kiHvjLis/2LZSt2z3vqNzP8MD1vB6XI8uDQPMhXrvvnE97At7xk0LzAm26Km4Xv5Keu3JuKn9fIu62sRgvZJU6pIgTY7/kOBzYFB9+78PphtBD5C9N/wAAABAh/FITxoe6QEAAAByGCP8AAAAyAHMtJuGEX4AAAAghzHCDwAAgBzAM/xpGOEHAAAAcljWjvAvXSqlJXWNjiK6/mgW7CILo9hNSdKa9NLnTT7YkqVxfeU21iRpoakvj8uvBvGXr5lFmyBUlQU1lxroYjfdk3NR0pxLz3Mpjp+Pdsy+pnG5qZeY+vqglml2WrDuxaZpqam/GtRSkuBaRW9Zkg4zsYHRLnW7zCTchXV3/rhYTtcPS4I4335RhHEHlh0luLr31WTqLuk07GyDTFtXj7KEzYWhyVyU3HUlCoZ20bMlJgdyaXAOmEVbLhn6+aAWpNZKkjaZ+OVxf8pg4SY3+jemeTQq6lJtXSxn1E3rTNtjlsX1alOPti2tlkGiM7JA1t7wAwAAAB3HIz1peKQHAAAAyGGM8AMAACAHMMKfhhF+AAAAIIdxww8AAADkMB7pAQAAQA7gkZ40jPADAAAAOSxrR/hfVXo+dXkQhV8Y1CSpf51Z8b5r43qYtb8kbvvVKIFZ0sNBzQXWm3zmBpNzHC0+yrKXpEJTD2LCbfZ6rak3mnrERXW79x0GJbvj9ZKprzL1aKe68GcXFD5g21bbkVVHcza4ORfcst0ujzKk3TQXbtsyyad278utO4oZd1n3bt2RoJtI8jni5aa+NrhmDXYdMZOcfnNBK3AXvPJtX3eJO2Bm4pHVQc31Ubdqd0mKpsFw11K3beuDk2CgO/HNJBrufUXbHs0rIvnPt2FBzdzK2Plv3PGMPgbS2rq5NbJDs7p+xN3NCJQdGOEHAAAAcljWjvADAAAAHccz/GkY4QcAAAByGDf8AAAAQA7jkR4AAADkAB7pScMIPwAAAJDDGOEHAABADmCEP03W3vD3l1SSUotikF02bcuyuD7wv8wClixNr7mc/cFJXP+3tHcsqTFO4371gXjRLm87yhp2CbPBVkuK87pdjr7L/Y0yyJ2DM112lOXtJhAwxyujN+YyyKtMPcg4j2ahkHw/izKvXa67y/LOpL3r4+5wRP34INO2ztSrTT1634PdnAtlph7stJEmPH2Fycp37+vloDbITE6QV2AWHq28n2nrOoM7v4YENZcp/0xcjnL4Mz1/MpmDw+Xsu/ryaL0m7H6IeeMjzbqj9/Waaety+KPT0526Lmff1aPjnZdWTCS9YxaMrMUjPQAAAEAOy9oRfgAAAKDjeKQnDSP8AAAAQA5jhB8AAAA5oFldP+LuvgWWHRjhBwAAAHIYI/wAAADIAc3q+hF3RvgBAAAAdLOsHeEfqvQ45P5BQO0Wk7nrsoZt2PDKoPawaRvl7EsK07zPPSZs2e+8R8O6y+SNcpBdRrLLd45iqV1kvMsi3mzqUY6/i9u2ojfuAundBASuq2TCZa8HnWWwOYGazUQY0enj4s1N9HoYby7FfcHt7n1M3cW+R1xXKRlhXhCd3O4EcxeG14OaGdQatDGu542N6wOfC9ruHLe1B+zIoGa2Kwy7l6SdTP35oBZNVCHZ41UX1Nz1zn02uvbRdT6TuSQkaXhQc7vbvcDN6RDN+xPNFSH5a9bAoFZp2u5q6v3djokOaFrbFpHD34Nl7Q0/AAAA0HHEcqbhkR4AAAAghzHCDwAAgBzACH8aRvgBAACAHMYNPwAAAJDDeKQHAAAAOYCZdtNk7Q3/OgVxdUEcYhT7J0lrTH3fZ8wLohW8Zdo2mpCuMHrzkbDpc8oL6y7y8NWg9oJpa2PRAi7SM4pSlHwcYvS+XbqeO4VHBZ1poImntCt3OXXRG3f9MJM8UvM3QRcxGaXeuojVBlNfb+rRIXHnRybvq8TEoJa47Nnhph5xx9r1ldfSS+vNyevifIebEyzatIH1ZuHugEXHxGVIVpi6EyUom4tt85K4HpVdQqvrKu6Slkm0s+uG5aYeqVoX1911PorsdaeuW3bUTetMW3cvU2BuN4qCen7aG0vMSpHVsvaGHwAAAOg4vrSbhmf4AQAAgBzGCD8AAAByACP8aRjhBwAAAHIYN/wAAABADuORHgAAAOQAHulJwwg/AAAAkMPykiTpVLLqY489pu9///tatGiR3nzzTd1111066aSTWutJkmjatGm6+eabVVdXp8MPP1w33nijRo0a1aHlNzQ0qKysTG9LKk15TfSvlLwRZgVDTH13U18Y1Ey2+qsmyDjKQX4ubqpP2cM4Ni6v+nN67WWzaLdxTwa1OtP2xbjc8Hpcj6ZNiDZL8rnVRwS1ItPWzR/g8pujCHSXR++mAIjqY0zbKlMvLQyK5aZxnam7/PRIram7A7pveunfotx1+bkoPm3q0XVjmGkbzR8gxafffNPWzaFxoKn/a1AzEeNW1MfdPnPZ6y7PPupKbnqByovMC25KLzWZneauCy5L/6WgZj59tMde5gXB+aXjTFszJ8OJ58f1iUHNHetKU98zqA091jQ+zNTdAb0nqKUc7IZEKntPqq+vV2lp2h1a9/jw3rG+fqpKS90Fe3uve5PKyqZn5X75W50e4W9sbNTYsWM1Y8aMduvf+973dP3112vmzJl68sknVVJSookTJ2rTJjcTCgAAAIDtrdPP8B933HE67rj2/0mdJImuu+46XXrppTrxxBMlSb/4xS9UUVGhu+++W5/73Ocy21oAAAAAnbJdn+FftmyZamtrNWHChNbflZWVafz48VqwYEG7bTZv3qyGhoY2PwAAAEDnNOujL+521Y97CDc7bNcb/traDx6EraioaPP7ioqK1trHTZ8+XWVlZa0/1dWZPIgLAAAA4G91e0rP1KlTVV9f3/qzcmX0NUsAAACgPV09ut8dMaDbZrve8FdWfvCd9DVr1rT5/Zo1a1prH1dYWKjS0tI2PwAAAAC2j+16wz9ixAhVVlZq7ty5rb9raGjQk08+qZqamu25KgAAAOBvMMKfptMpPRs3btQrr7zS+v/Lli3T4sWLNWDAAA0dOlQXXXSR/vM//1OjRo3SiBEjdNlll6mqqqpNVn+m8voGxYGmsftuhcuuXZ5eatgYN3XBpFFybL5p65OOTVj+kL3Ta0+bMPzlZtXRU1o7mbYm9DqTTGy3T/0+T+cyq11KsHtf0b/U3Xa7U6AxqLnZNPLdPBjRAty5u8rU3Qn2RnopMeduXgadJcralnymvMuFLw9q7htRrp9G/cz1o0yz8qP5CdyhrjP1t4JaRVCTMp9jI9ovbjqISjMnSpS175Yd7RNJKjP1TK61dqdGdReGb+qZfC6XZLZqDY0u9O7kdRPFmHl/ohPsvZR+9J5ZJLJbp2/4Fy5cqE984hOt/z9lyhRJ0plnnqnbbrtN3/jGN9TY2KjzzjtPdXV1OuKII/Tggw+qqKhrJ0IAAAAAsA03/EcffbSiyXnz8vJ01VVX6aqrrspowwAAAICOe1+Z/X1+W9eZ/bo9pQcAAADAjtPpEX4AAAAg+3w48VZXrzP7McIPAAAA5DBu+AEAAIAclrWP9OQXS/l5KcUoC8vlYEVZb5JkYs9eDeL7XKyZW3UUkfeqaXvMqj/HL4hiNyVJf0kvnTQyblr9WlyvCmpup5jv3uS/Etdbgto+ZtUuVyradDdftHvbTrRtbtkura0+qOW7zMJoh0tx7K3L/HQxdC7LNFh33kumrdupwV90o+4vhWmhHRL9MdmN6LjDOXwba5JP63VdJTqc7nC4ekNQc8nMdabuumlUdxGsGmPq96WXXFyo6yvua5DRPrcRrWtMPfpcf9wtPDbE1NufMvQDLqp0gFt5dALuZtq6+nJTD06w4pTalkQ94Pup76vrx7KzfqdIYoQfAAAAyGlZO8IPAAAAdBwj/GkY4QcAAAByGDf8AAAAQA7jkR4AAADkAB7pScMIPwAAAJDDGOEHAABADmhW18982zNm2s3aG/5X3pP6ptTyg1DfkSZkvNkENG+Ky4oS5zOI6pYU5/C/YNq6+QP09ItxPczaN7MAjDs5rtfdlV57Lm7qJjdYYppHu6XctHV59VF0tJs3YbOpu34YZZS7fhbl7EtxRvlyk5edSZb3kEbTuNTUXeh1NHnB63HTZtMZ8oMDsjBuGl5TJN8Xdgpq+5q2Lod/fVBz/cxtd62pR/vFzXnict9d7HvE5dm7dUe57yUu2L06Li8Pam6fuX7o5k14OqiZzVazmfygKqgPdhMnRPP2yPfD54Oam/bHrFoFwSQcwx82jd28I9ENhRRfONKW3SI/UQWyVtbe8AMAAAAd16yuf6a+Z4zw8ww/AAAAkMO44QcAAAByGI/0AAAAIAe8LymvG9aZ/RjhBwAAAHIYI/wAAADIAYzwp2GEHwAAAMhhWTvCv0FSklKLco77mDB8l5Uf5YRLcTZ7oWnrMnmjbYsicyX5PPvlpl4dpDC7nH39Li4fGfxru84sujwuuxzkKHrdcX0lijl2WfcuItllmEfvy/XDTPqp64du7oIoan+I22kuh99tXPTGTEfJN0MjTUFncZvl+qirR3Hc7vwoN/Vol7lj7fpwpalH12J3LR1o6tE+c/vbBfDZbpg2wYzkJ04YE5ej+Vp25PwckrTS1CMu2j26Fpe/ErctMHn1g8y6o77m+ri7zkf7bLhpayeEcCe/O0na0yxy+HuwrL3hBwAAADqOR3rS8EgPAAAAkMMY4QcAAEAOYIQ/DSP8AAAAQA5jhB8AAAA5oFldP8LvvhKfHRjhBwAAAHJY1o7wH9BfKk35R1pjkAfnItHyzAveizI/JZUFtRaz7gGmXmXqoSdN3WWmRSuvuytuG8VuSlJBWsCqpFP+KW5b/UBYHl4RNx8e5dS9HLdtNn2hNqi5qLcgBFVSHF8pxYlrLm3NnSNRPx68Z9x2sHljDVG+3ti4rc1x3NXUo+O5u2lrskz7LEuvHWkWXW3qB5t6dArs4S4q7n0HuYP7vxg3bdwY10tMXGJz0FdcHGJJdKGWlAQZlC6Ot87UB7thtH8Nau5gHxOXo2uSuy6YXWavSVGcqYs6XZ/Bsp83bVvMAf2GaT86qLmPVVcfFRVNBKuOMHV3wNyHVHs2SXp2G9ohK2TtDT8AAADQcd3xBVq+tAsAAACgmzHCDwAAgBzACH8aRvgBAACALjJjxgwNHz5cRUVFGj9+vJ566qnw9dddd5323HNPFRcXq7q6WhdffLE2bXLfZmqLG34AAACgC9xxxx2aMmWKpk2bpmeeeUZjx47VxIkTtXbt2nZff/vtt+ub3/ympk2bpr/+9a+65ZZbdMcdd+hb3/pWp9bLDT8AAABywPvd9NNx1157rc4991ydddZZGjNmjGbOnKmddtpJt956a7uv/9Of/qTDDz9c//Zv/6bhw4fr2GOP1WmnnWb/KvBx3PADAAAAGWhoaGjzs3nz5q1e09TUpEWLFmnChAmtv+vVq5cmTJigBQsWtLvcww47TIsWLWq9wX/ttdd0//3365/+ycSaf0z2fmm3VKn/HNkpyOHPM3nZ7p847omot4JaEO0sKbNYXJcNbcOhXfh6tILnMlx3mLV/f9z2kKPi+r88FtejLOPvxE3zTV8q2vpc/qgWN7XyM6xH3HwRTVHRzHvgzq/SgqBoDrXdqXWmHs0REJ3YkhRcc6Q44j+aM0HycdguSn+3qGjmTbBzG7wa1ExHcpccN29C/ur0WnTuSbITX7pzIGKmD/CiDwozN4i7Fq8Jau4zxM0V6j4bM7kmuWVHdTdq6d53eP5Iyt8rvTY86KOSNMjcFJQMC4puXhJXrzP1aB6NdSm/d+ddVuiOWW8/WGd1ddtZVaZNm6Yrrriize/WrVun5uZmVVS0/TCtqKjQSy+91O7S/+3f/k3r1q3TEUccoSRJ9P777+vLX/5ypx/pyd4bfgAAAKAHWLlypUpLS1v/v7DQjUB3zLx583T11Vfrhhtu0Pjx4/XKK6/owgsv1Le//W1ddtllHV4ON/wAAADIAe9LSrp4nR+M8JeWlra54W/PzjvvrPz8fK1Z0/bvcWvWrFFlZft/cr3sssv0+c9/Xuecc44kad9991VjY6POO+88/cd//Id69erY0/k8ww8AAADsYAUFBRo3bpzmzp3b+ruWlhbNnTtXNTU17bZ59913t7qpz8//4CG6JOn4P24Y4QcAAAC6wJQpU3TmmWfqoIMO0iGHHKLrrrtOjY2NOuussyRJZ5xxhoYMGaLp06dLkk444QRde+21OuCAA1of6bnssst0wgkntN74dwQ3/AAAAMgB3fdIT0edeuqpeuutt3T55ZertrZW+++/vx588MHWL/KuWLGizYj+pZdeqry8PF166aVatWqVBg0apBNOOEHf+Y5JHvkYbvgBAACALjJ58mRNnjy53dq8efPa/H/v3r01bdo0TZs2LaN1csMPAACAHJD9I/zdJXtv+McoNfA4Lwq9dmH3Jst7y8a4Hq261qw6zDdXnO/s2oaZum7hUhyi7DLKy029+oH0msvZ1/y4fIoJGl+7NL12o1l1SVweuDK91hx1FEmrzKpd5HwmWeDu0hRmlLu+4JQFNbdhbt2u3n7E8QdMXnZi6huCmtss01WsvGifupz9Aaa+PKiZoP08N4GAyxEPdmomme9SB66nAZfr3mRC/gvqosZm4Q/F5egUcvssk48ISaoOam6uiWh6DsdMkWHPv0/tY14wIaiZHP6SJWbZUWqjux6+burRRUmKd1zaZ1smJw66HSk9AAAAQA7L3hF+AAAAoMN4pCcNI/wAAABADmOEHwAAADmgWV0/wm++uJMlGOEHAAAAchgj/AAAAMgBjPCnYYQfAAAAyGHZO8IfhR0H+bJrTaj14M1x3WViR9/FdlMAuBzjaNNcTnGDyeS1GcuvpNdclHA/Ux9eERT/5bG4scvZd1s3+FuppYY3podNS11GeaDc1E3Evz3eUT/MNC9gU1Q0udNhGLcU7xiXK/2yqZttW+qWH3DnbnTdyHSKDJvTH03a4HKz3eQhr6WX3lsXNy124esDTT3ICX/PDKgVm0VHx9Pl7DuufUHUT92HiAmVjw6n68PuOh5eF5RZRLt729FUEy5u3k4dYuaTCHdMuWnrzoH1Qc1da58x9TpTj66naR+r75tlIqtl7w0/AAAA0GHvq+sfXuGRHgAAAADdjBF+AAAA5ABG+NMwwg8AAADkMG74AQAAgBzGIz0AAADIATzSkyZ7b/g3Kz1fMMgddJFoiXmBix7LNLItEsWauUi1labuItei7urSEKNUQEka/kJQHGMar10a14PYzQ9cnVrZojiW0+ZbBm/cxWqWm6xF1w+jTXN9xcVAhut2B9tF3EXt3bLdGzP5fC7lbket2u3vTHdpGA3oTnyb+ZnOfsRlmOOYBCuw6zYviDbN7RIX8+iO18jl6bVmExudbz6AgiRTGwXsuNjNaNMzuZ5JUn1Qc8fDxnK6kzuTa1aUJ+q47XIXNHdTEOUFp8VydvV8VtiusveGHwAAAOiwZnX9iHvP+JcQz/ADAAAAOYwRfgAAAOSA9yXldfE6GeEHAAAA0M244QcAAAByGI/0AAAAIAfwSE8aRvgBAACAHJaXJEmH/2kyffp0/e53v9NLL72k4uJiHXbYYfrud7+rPffcs/U1mzZt0te+9jXNnj1bmzdv1sSJE3XDDTeooqKiQ+toaGhQWVmZ6v8qlaZlSNcGC3jErOCuuLxiQVz/n6BWZ1Z9sKlHkdkuctet20X67hPUogzkjjjGBokHBsTlhjfiehRbPdB2/TPi8t2/TK/NiJu+93Bcfy0uh7nWLhq60tSj3Pg603aNqb8U1NyUDKNNveRY84JMJtGIMqslrQ/euGlqz+1Bpl4V1Ebvahr/k6lHFwbXSR83dRfOHnVUF67+alxevjG91mgW7Y6Xm/rg0MKgONA0Nsdz6VPpNXfeu+uGUxfU3D5zhzM6dZ8xbaNrjiT96svmBcOD2pNx0yZzvxHdyphpRTK6jrvlp52aGyQdIKm+vl6lpaVmDV2r9d6xvpdKS7t2hL+hIVFZWUtW7pe/1akR/vnz52vSpEl64oknNGfOHG3ZskXHHnusGhs/ukRefPHFuvfee3XnnXdq/vz5Wr16tU4++eTtvuEAAAAAvE49w//ggw+2+f/bbrtNgwcP1qJFi/QP//APqq+v1y233KLbb79dxxxzjCRp1qxZ2muvvfTEE0/o0EMP3X5bDgAAAMDK6Eu79fUfPOwxYMAHz10sWrRIW7Zs0YQJE1pfM3r0aA0dOlQLFixo94Z/8+bN2rz5o0m5GxoaMtkkAAAA/D1KWrr+O7Q94zu72/6l3ZaWFl100UU6/PDDtc8+HzzoWVtbq4KCApWXl7d5bUVFhWpr239abfr06SorK2v9qa6u3tZNAgAAAPAx23zDP2nSJL3wwguaPXt2RhswdepU1dfXt/6sXLkyo+UBAADg71BLN/30ANv0SM/kyZP1P//zP3rssce0664fxQZUVlaqqalJdXV1bUb516xZo8rK9r9TXlhYqMLCKLYAAAAAwLbq1Ah/kiSaPHmy7rrrLj3yyCMaMWJEm/q4cePUp08fzZ07t/V3S5Ys0YoVK1RTU7N9thgAAAD4uOZu+ukBOjXCP2nSJN1+++2655571K9fv9bn8svKylRcXKyysjKdffbZmjJligYMGKDS0lJdcMEFqqmp6XxCT9XeUmlKevymP6e3e9cstyQuF5jmUcayi/l2WfgR159cVrdbd5TB/LZp6953c3BM8t0fd8zxKjU5/fGOMzn7+kVcnhjk8D8XNy024exVJrja5d1HMrk2uWPtplwoD2rmUPvRCZfrHoV9uz/JmpMgWnWUtS1J603d5bqH3D5xofOvBzX39KXrLC74fVhQcyHjJti9Kcjhd7usztTd227YnF4rdYH05gQrD2pudxe4E8x0xMHBGy8xn8tu26JrluuGbpfae4aor5mvHBZEfVhSZXB+uXsRd611/TCqp9XeN8tEduvUDf+NN94oSTr66KPb/H7WrFn6whe+IEn60Y9+pF69eumUU05pM/EWAAAAgK7XqRv+jkzKW1RUpBkzZmjGDDPVKAAAALC9dMcjNj3kkZ5tTukBAAAAkP0ymngLAAAAyArdEZPZQ2I5GeEHAAAAchg3/AAAAEAOy95Het76S3o+Wl0Gy901Llea6QI+/1pQrDPrdtmZQU7WKJPDmOm/3KKILhcBucHUo1jCoiCiTpIGZjrxcpT3dncQqynFsZuSVBx8iX3a2LhtdRAtK6n/k3Hz/s8Hxbq4rc15DDrDpmfjpi4lNYo8dH243tSLX4nrSRB16qIYM0mYdH/tdZGEbp+GlxWXx+syC6OTO7oWuraSvx5GkYftz+P4EZNZuMdDQdHFNJoD6o5n6Q4cZhscLLvZdcRMcqOl8IuLJeY972m2LS+Ib+5jPkN2i8vSw6Ye5eaaa05DFGur+PRzybPF5gWuXhT087TrXUO8yOzAl3ZTMcIPAAAA5LDsHeEHAAAAOoov7aZihB8AAADIYdzwAwAAADmMR3oAAADQ87Wo679EyyM9AAAAALobI/wAAADo+YjlTJW9N/z3SSpOqUX5zkvMcstM/UBT3zeouUzrKJBeCsPAB74dN33PBIW7SOwo7v5V09blo0dx2y6zutlkYpeb9gVRcYZp/Jyph1n7pvEZeXHdhUdXBTXXz0pMPeiHb5scfnfdi/qKiz93p1dZkLMvxX3c5exnos7U3Z9ZXR532N5NMOAm2Yi4HH73xtzJH+XCm5x9e/4MCWp1cdOCTPaZpPeCP/+/ax4NGGhOgvVBe9fH+5kXNJsLfdTV3CXHdZXioK+4uVxcV3nPXDfSbkMkaa1p+7JZd/SxHl3iJX+8ikzdfW63Z+M2tEH2yN4bfgAAAKCjiOVMxTP8AAAAQA7jhh8AAADIYTzSAwAAgJ6PL+2mYoQfAAAAyGGM8AMAAKDnY4Q/FSP8AAAAQA7L3hH+O5S+dQcH7VzO/ihTH2Pq5UHtJdP2AVNvDGom79dlQ7vI6yiy18Qc24x/F9cdWWXqLt+5PAh33+fhuG3xi2bh1X9Or7mc/d5JXD96Slwf86P02vNxU3vAgnqDmbvAZcZHWd0Npq1LPnPx6FHutIurd6Ksb5d/XmjqbtuiaPYiE7ZdHE1OIIUjV6+aiRPcdBDDzZwpQ6Lzzw1V1Zl6tHHmouI+Ypzo9HOHo585ntFuaTLLdpeF6ONJijPlXRZ+NFeLJBUH/XCgaevOn4WmPiD47HVt60w94q4b7jPd1aPrRtqp7foAslv23vADAAAAHUUOfyoe6QEAAAByGCP8AAAA6Pn40m4qRvgBAACAHMYIPwAAAHq+RF3/TL3J4MgWjPADAAAAOSx7R/hXKf2fI6ODdi6LqtzUdzP1KLLNZUjmZ7DsAXHTZpNJ6OISIy7WzNWjKC+3S9zhLDD1aNtcXGiViULt/2RQdP3IxW7q2rg8+IX02sFz4rbujQdxiC4G1fWzTPqhixV0Mll3P1MvD2ouxtH14UpTjy4NxS7z0+2UuvSSi910MamuLw2Jrqdup7lnaqP3bTIkXQykE8VfZhqNGUU5ul3mojNdbG60bW5k0V3nVZpeKjGjuYNMfKzrp9FnyHrT1h3P6PMvk+uV5E+BbYlINrsSWS57b/gBAACAjuJLu6l4pAcAAADIYYzwAwAAoOdjhD8VI/wAAABADuOGHwAAAMhhPNIDAACAnq9FXZ/D39Xr20aM8AMAAAA5LHtH+N+RlJdSiwJkB5nlmjx7DTf1KHh3R/4rz4QoR/nLUmY5yC4P2GUoRxnmLoffrdt9Vyaqu/kDXD5z/+eDYpVpPOZHcT3K2Zck/SG9VHqlWfcVcX15emlU3NJyudQRd6yHm07eEJyfbtn93QkUhJjvuzFu6s6fka4vRUH/bgIBF84eXFhK346busxu+z236AR0O82Fyrv3ncGqXVeJrmnu48v1w3eCPh5E2UuS8s2EEe/Wx/U3zPIjNoc/Op6mI5WbjlhuVr0jR0Wjt+Xm33Cntrsd6SGD0p3Hl3ZTMcIPAAAA5LDsHeEHAAAAOooR/lSM8AMAAAA5jBt+AAAAIIfxSA8AAAB6PmI5UzHCDwAAAOQwRvgBAADQ87Wo679E20NG+LP3hv9dpefw1wXtXP6yyY7Wi6beENRcsLsLWY68FZej6QEkn3cf5fi7c6fQ1AeaeibctkXv22Y/O3VBrda0jTL8JengOXE9zNqfFrct+N+4Pip93SU7x01lsrrzg47mcqXt8TLB1aXBMUncBdtdV4L3ta9pmu8mm9jH1KMdV2Laup0anGBjFsRN3XXBbZqagprb7nJTj67V5mKZ7/qCOZ7RFADV5vxxnyFvBHMXVJhFDzZ59XWmfVR3jxK4j+XK4AXNpnGdWba77kTd0F023C1BtG7Xzdwp4ObBiI5J2rJ7SBgNUvBIDwAAAJDDsneEHwAAAOgovrSbihF+AAAAIIcxwg8AAICej5l2UzHCDwAAAOQwRvgBAADQ8zHCn4oRfgAAACCH9cwR/ih3d4Np64JxXfuIy9OuMvWyoGbCglc/GtfdP0CjXeqioV3edpQn7L7cnuk/nKNDYmLb/bozyT93/ew1Ux9zRXrN5ezrD3F57zPSa9W/jNua8OeGDHL4XS61Pf8C0TwUktRnY1yPzp+BY83C3QlUbepRbryb+yODfZZvrqV7PGcWUG7qw4Oau5a6fR7Na+ICzN1niJv0JFC60rygPC4/H+Twu7laWsxJ4DYt2qXuWurO/T7BCeamPHGX2uGmnsmoqOtKUd21dZ+d7tTelo8vd6lCduuZN/wAAADA3yKWMxWP9AAAAAA5jBF+AAAA9Hx8aTcVI/wAAABADuOGHwAAAMhhPNIDAACAno9HelJl7Q1/0/tSU0qtYFXQ0OXrRfl5HRHFLQ4wbd03uYs6uS1/Y7WpN5p6FL3ZYNq6BMrobacd4460lXxCXlTPIJHwA1FfyzT+9UVTXx7URs2J20axm5KkX6SXNsSxnM0mSy46/QriplZplAso6Z2gM7kIPHe4omjAo11fcH9ndXmI0UmSaR5iVHdxoW67B5p6lMNanuGyo3M308QNdzwz+Qwxol1uo2dNfbmpR59B7vxxuzxqb057u26X8BrtN3d6uc/d6PSKbnMkH1PsjmeUHpt2LX7fLBPZLWtv+AEAAIAOS9T1MZlJF69vG/EMPwAAAJDDGOEHAABAz8cz/KkY4QcAAAByGDf8AAAAQA7jkR4AAAD0fC3q+i/tdvX6thEj/AAAAEAO69QI/4033qgbb7xRy5cvlyTtvffeuvzyy3XcccdJkjZt2qSvfe1rmj17tjZv3qyJEyfqhhtuUEVFRac3bIvS828LouBdFzZsQnsbn4vri4Oa+0fenqY+OMpgNv80G2OWPcrU84NDtHxN3NblAQ+O3rjrGi5k2U1AEMxtsMK8L9eVNj2bXns7qElSw4y47uY2iI5nyc6mcXWcpR9m7b8c54/lJ3lh/YRvBcWJYVP/xSjTF/rfE9RcWHcUWi1pdBSAfp1Zdp2pDzf1TL4wttDUg33m2taaOU/K1sX14uja8Hzc1s63UhfUokkVXFsps7kNXNvRcfm1Jek104XtqjebejRfi/uMcNMP7BbUhpu2blTTfOTrmKD2L6at2+cj9wqK/24aV5r6/5j6Q+mlhpSJSdycPFmBL+2m6tQI/6677qprrrlGixYt0sKFC3XMMcfoxBNP1F/+8hdJ0sUXX6x7771Xd955p+bPn6/Vq1fr5JNP3iEbDgAAAMDr1Aj/CSec0Ob/v/Od7+jGG2/UE088oV133VW33HKLbr/9dh1zzAf/Jp41a5b22msvPfHEEzr00EO331YDAAAA6JBt/tJuc3Oz7rzzTjU2NqqmpkaLFi3Sli1bNGHChNbXjB49WkOHDtWCBQtSb/g3b96szZs/+mNhQ0OP+KMRAAAAsgmP9KTq9Jd2n3/+efXt21eFhYX68pe/rLvuuktjxoxRbW2tCgoKVF5e3ub1FRUVqq1Nfyhy+vTpKisra/2prq7u9JsAAAAA0L5O3/DvueeeWrx4sZ588kmdf/75OvPMM/Xiiy9u8wZMnTpV9fX1rT8rV0bffgMAAADa0dJNPz1Apx/pKSgo0O677y5JGjdunJ5++mn9+Mc/1qmnnqqmpibV1dW1GeVfs2aNKivTv05eWFiowsLCzm85AAAAACvjHP6WlhZt3rxZ48aNU58+fTR37tzW2pIlS7RixQrV1NRkuhoAAAAgXXM3/fQAnRrhnzp1qo477jgNHTpUGzZs0O2336558+bpoYceUllZmc4++2xNmTJFAwYMUGlpqS644ALV1NRs/4SeKNzWhQWbA+PygkuD2ibT1tWbg+xo17bK1PNHmBcEf5Jy/yp0kdeDXwuKmf6T033lIzigazKcXyDKjnbnf58M66F6U0/JWP5Qc1B3OfvKi3P6NT04eZvM30Xvj8t6PIO6m++h3NSD+R50lWnrJl0Ya+rRJBwuCNw9jRnUG82J786BYnfuB5nydpIM976ic2RHn7xRN68zbV+Oy9H8HC7r3m22a98Y1AaZtu4yHkXOF7gHBMw58Li5HjYFtZFu1e6DOQr5d9cFJ9pwI22XvLfti0QW6NQN/9q1a3XGGWfozTffVFlZmfbbbz899NBD+tSnPiVJ+tGPfqRevXrplFNOaTPxFgAAAIDu0akb/ltuuSWsFxUVacaMGZoxw0wjCgAAAGxPLer6R2x6yJd2M36GHwAAAEDHzJgxQ8OHD1dRUZHGjx+vp556Knx9XV2dJk2apF122UWFhYXaY489dP/97jnXtrZ54i0AAAAga3RHTGYn13fHHXdoypQpmjlzpsaPH6/rrrtOEydO1JIlSzR48OCtXt/U1KRPfepTGjx4sP77v/9bQ4YM0euvv77VvFcON/wAAABAF7j22mt17rnn6qyzzpIkzZw5U/fdd59uvfVWffOb39zq9bfeeqvefvtt/elPf1KfPh98vX748OGdXi+P9AAAAAA7WFNTkxYtWqQJEya0/q5Xr16aMGGCFixY0G6b3//+96qpqdGkSZNUUVGhffbZR1dffbWamzv3ZYWsHeFfp/SEzSYXOxjYYOpRup4kvRrUXDzlKlOP5hh2fzE60kWTRXltkrQ6veSS/aI4NklqCCL0SgtM4zJTLzf14IC+FD8yZxcdRaW6LupiVl1EXtSP801kYXQ8pLgfn/CtuG0Yuykp/DZVgTnYrzfE9Ufi8l+CGFZ37g4yL9gtqD0XnFuS7+J7mChGHRHUXB7in+Ly0jfSa6+bRbtr6QBzUXsuOF4uldOdXxEbIWminwe6zhR4b1lcLzZRwhH32ZfpNSlKt3Trdscz2qWVrqOZeyL3+RXJ72te4LJMXWeLuAPm9ksw3Ju26EzOqy7THbn4/7e+hoa2n1HtTSy7bt06NTc3q6Kios3vKyoq9NJLL7W7+Ndee02PPPKITj/9dN1///165ZVX9JWvfEVbtmzRtGnTOryZjPADAAAAGaiurlZZWVnrz/Tp07fLcltaWjR48GDddNNNGjdunE499VT9x3/8h2bOnNmp5WTtCD8AAADQYd34pd2VK1eqtPSj6Vk/ProvSTvvvLPy8/O15mMzf65Zs0aVle1PMbfLLruoT58+ys//6C/oe+21l2pra9XU1KSCAveoxAcY4QcAAAAyUFpa2uanvRv+goICjRs3TnPnzm39XUtLi+bOnauampp2l3v44YfrlVdeUUvLR/+SWbp0qXbZZZcO3+xL3PADAAAAXWLKlCm6+eab9fOf/1x//etfdf7556uxsbE1teeMM87Q1KlTW19//vnn6+2339aFF16opUuX6r777tPVV1+tSZMmdWq9PNIDAACAnq8bv7TbUaeeeqreeustXX755aqtrdX++++vBx98sPWLvCtWrFCvXh+Nx1dXV+uhhx7SxRdfrP32209DhgzRhRdeqEsuuaRT6+WGHwAAAOgikydP1uTJk9utzZs3b6vf1dTU6IknnshondzwAwAAoOfrASP83SVrb/h3kVSaUiuIAoFNWHB5FBasMI5eUpyvbhZtI3mjBHMT/exD4weaepDTP8QEFQ9xofNjg9pRpq07kTIIAx9jmpaYevQFGNcXTKJ8RvplWA+/AjTRNG4y8Qhh1r7pSBfuada9NCzvfWNQNP2o2bytqC8c7E58F27tOmp1UIsmCJDshSWaA6BoY9zWRca7r5odHNTWm7Yu9z3KdXczSbhlDzDdOC84AYtdrvuBcbnXY+k1F8u+k6m762G0X9wp4KaRiT7WE7O/XcZ/dPpIUv/omLgcfffGhwW1Y0xbd9140dQDafvbzcWA7Ja1N/wAAABAh3VjLGe2I6UHAAAAyGHc8AMAAAA5jEd6AAAA0PO1qOu/RMsjPQAAAAC6GyP8AAAA6Pn40m4qRvgBAACAHJa1I/wFA6SCbfnniAkbzjPPdjWaXOoo/9nF4ro84Ci73ea215n6KlOP8oTTJkToaL0yqLlw6LdMPcgJlxSGao82TV33i+Kf3Wa7AYEmU4+6caZ529u8Ykm639RfD3qyy9nXkrj873lxPZpk47m4af7yuB4e8N1N2zdM3U2cEF1YXGfY1dSD+Tmqn42buhx+d70sqUqvDXITphhRc5ez7+YAcIZHfcUFnZvc9yhTProMS76buUj5aNNc26CbSZLygouxmyPDXYvdVBXhTnWTE7gLffSh785dl7Nv6suDeTRqU35vpuRBlsvaG34AAACgw5hpNxWP9AAAAAA5jBF+AAAA9HyM8KdihB8AAADIYYzwAwAAoOcjljMVI/wAAABADsveEf5TJBWk1DLJJIxisCTt8VBcP+z19JqL/3LRZEOCmo2Ci6LDJJ+BF8XBuQ13OY9R9F+daet2qovnCzL2So41bc0+K34lvVZmtstFFjrDo3+qu/w9E/1XGu1zt78fN/VHglrT0riti93cJYnrPxqbXlv757jtH+OyFgY1Fx1rooBVburRNc1lTLo8xMPSS3l1cdOKZXHdPvb6z8G6X4ubDjb9tOiF9JrbZS5e2V0uw/xKl40ZHA9JOvG36bWCvcyy3XXDvPGhUT83caJ23cFOzTfxk1XBsZakvL5m3VFu59umbZ2pR9fDIJZWUnp25ofM51f0EZLWDc0VGFkue2/4AQAAgI7iS7upeKQHAAAAyGGM8AMAAKDnY4Q/FSP8AAAAQA7jhh8AAADIYTzSAwAAgJ4vUdfn4puAuGzBCD8AAACQw7J3hP8dpeeFR7nvLofffbnC5CCXBLVM85ubgpqL+7XeMPUot9rt02inSHFOuMnT1ktxeWkwL4IUv62j3QExcwAkwcJXmkXXm7qJyldDMIJR6vKZjXeCZfe/xzQ2Ofx/CSYg2PtGs2w3B0CUsy9Jei69NDgIfZekfe+N69HJ/99x0ySYz0HqQPZ1Q1Bbbtq6HP5on5vJJNxcE+5wHhotwF0QTT26JDWaReeburushKOPbuFmzpOCaM6TMWbZ5aZurrXhZ6ubB8aJ9ovZJ3nmYtqwMa6XPpteazadeFVc1qBgjoBi15Hch4T5EDJTEvVcfGk3FSP8AAAAQA7L3hF+AAAAoKNa1PXP8Hf1+rYRI/wAAABADuOGHwAAAMhhPNIDAACAno8v7aZihB8AAADIYYzwAwAAoOdjhD9V9t7wF0sqSKlF+bMmR9/mHBtR5LXLXnd9Ioqzt5ttstcTkzWcF+Xdu/xll9O/e1AzWfc2sH5HMt+8j6KlXYRyprHUUV9KzHa7bYvymfu7ySbM8Qzj0V0/C2L0JUlr/xzXw6z938dt99gzrtctTa+ZEz+vLK5rgKlHy3cXHRc6X5deescEebtF27z69UHN9UPzt2sT3Z7Jor3oHInesySZORvCyQ3cPis39UwmKHAfYO5zIDpHTNu1pqO5aWSideebdReYdUefA8VurgnXEc3xjg5n2na5LoDsxiM9AAAAQA7L3hF+AAAAoKPI4U/FCD8AAACQwxjhBwAAQM/Hl3ZTMcIPAAAA5DBG+AEAANDztajrR9x5hh8AAABAd8veEf53lJ63H4Uou39pucx4U68MaiaW2kYR7xPUbG672e48t/IgL7jZ5AHnu382FgY1s+zE5PC7txXWXzSNzbbZHPEMuOkk+kf73ISM9zFzMoTxzW6Hl8flQcE+bTbnbv5ys+4/mvq+96bXXM6+lsTlQ45Nr707J27rOtIgU4+OtwsZdxetl9NLbtoE97ai6VQkSU+ml5LNcdO8irhe2jeoxU2lgabuRhejfu5y+JfH5WgOjjy3w10/c+2jA+4+d4eZ+oGmHhicNp/P/1luTu2S4DPoHdPJzfQ44eW0f5Np7M5ts8/Lg/eVdr+RvTeM6AiOHwAAAHo+YjlT8UgPAAAAkMMY4QcAAEDPRyxnKkb4AQAAgBzGDT8AAACQw3ikBwAAAD0fX9pNlb03/OuUvnVR5JqL/2ow9aq4HMVyhnGGkhpNPUoPs/1pX1N3cYrBM2j5Jo6tyUST9VmWXnOpgG6fZtJ+/Zq4rYtCdV0tYpIzXbplvABzPEzaaBglN3qlaWx2ym5Bzf658S1TX2jqUWeoWxq3jWI3JUl/SK2sWpMXtnSPfw5dbl4QXRxclKI5wVa9kV57xizanZsDTL0hiN50kZ87mXM7al8axQhLPjPXCU6w9SZudKB5X3lRuqyL3XQXtHJTj65Jbp+5z6+xQW24aRtddCS9+P24XrU6vWZSozOLps0059uc+1HztO3ekVHU2PGy94YfAAAA6Ci+tJuKZ/gBAACAHMYIPwAAAHo+RvhTMcIPAAAA5DBu+AEAAIAcxiM9AAAA6PmI5UzFCD8AAACQwzIa4b/mmms0depUXXjhhbruuuskSZs2bdLXvvY1zZ49W5s3b9bEiRN1ww03qKIiCs/f2gNPpMf6mljdkMsgd1Hfr2Ww7oMyaFtSFtf/7dG4HsUzS/H0Ay7e3GXKHxnUXDyzOx4vmnoURezWHeXRS/E/6utMW5dnbA639t0Y1EzbgVGmtaSjowkIrjMLvyouPxdkWh/sgtl3N/WXTf2/g5r70tW7c8JylLU/JEnMwj8bl5feGdcfDmrugrc+Lg8Jal80J98fzaiX2+Wl0UeGy5Q3fak4ClA3+6T5BbPuDLi5P5oej+t7B7UxS+K27rrhrofBqa1+wXwOklRt3teobVyv5KeicPPjRN3BbLbctCWHBbUNpp+5+yC37uj0TTt13zPLzAot6vov0eb6CP/TTz+tn/70p9pvv/3a/P7iiy/WvffeqzvvvFPz58/X6tWrdfLJJ2e8oQAAAAA6b5tu+Ddu3KjTTz9dN998s/r379/6+/r6et1yyy269tprdcwxx2jcuHGaNWuW/vSnP+mJJ57YbhsNAAAAoGO26YZ/0qRJOv744zVhwoQ2v1+0aJG2bNnS5vejR4/W0KFDtWDBgnaXtXnzZjU0NLT5AQAAADqluZt+eoBOP8M/e/ZsPfPMM3r66ae3qtXW1qqgoEDl5eVtfl9RUaHa2vafAJw+fbquvPLKzm4GAAAAgA7o1Aj/ypUrdeGFF+rXv/61ioqKtssGTJ06VfX19a0/K1e6r5oAAAAAH9PSTT89QKdu+BctWqS1a9fqwAMPVO/evdW7d2/Nnz9f119/vXr37q2Kigo1NTWprq6uTbs1a9aosrKy3WUWFhaqtLS0zQ8AAACA7aNTj/R88pOf1PPPP9/md2eddZZGjx6tSy65RNXV1erTp4/mzp2rU045RZK0ZMkSrVixQjU1NdtvqwEAAIC/1ayun2EqF5/h79evn/bZZ582vyspKdHAgQNbf3/22WdrypQpGjBggEpLS3XBBReopqZGhx56aKc2bIPS92Fd0C7fLNflHLtM+ajull1n6lH7EhMm7HLd3zX1KCbZzT3gHu6qDmouTtttt8tYjrbN5TebOO5w2e56U2jqBRmsO9/tFLfyaOPrTNuSuBzOL+BOIJPlrc1xOXklvZbnJj4wJ1h8vTc5+/pNXN7DHLAlTek1FzJeZ+pBjn+D+TO2u5a6w60NQa3ctHUfBNHGBbtTkvLdGzMf/knQT93hcm8rul66a2mmnyFRe/fEg+sLmdxP2Sk2TD2TpzXcZ2N0qXbbVWfqmbyvtFPAnBrIchlNvNWeH/3oR+rVq5dOOeWUNhNvAQAAAOh6Gd/wz5s3r83/FxUVacaMGZoxY0amiwYAAAA6pju+RJuLX9oFAAAA0LNs90d6AAAAgC7Hl3ZTMcIPAAAA5DBu+AEAAIAclrWP9NRI6pdSKw/audgyl1joosnStknyMVhRPKUklYwIisPjtp9+NK4PM+uOuMg0Fz12cFCr6uS2fJzb51GC3uumbXSsJWlAUHP9zO3T9qep+8jIaMftE9Qk3xGjya6Hm7Zj4/IeLwfFMWbZ7oCUx+W8qBgdTMnmxw5dHhSX3hk3drGbLm/0hJPTa0fcFbc1ZS1MLxWZXFvXzcpNPeTyAV10ZtSX3AXNRM+6kz8viDodviRuW9A3rp+4Mb12QNxUh5m6i2eOuoPrC66+e1CLLleSPXu0ytSjz68K0/YtU983qO2/q2lsbnYGmQ+46F4n7fPJfd5mBR7pScUIPwAAAJDDsnaEHwAAAOiwRF0fk5l08fq2ESP8AAAAQA7jhh8AAADIYTzSAwAAgJ6vWSahYQetswdghB8AAADIYYzwAwAAoOdjhD9V1t7wVxdIpWkHLcpJ3mAWbPKZC0zQbEnw7W83B4CL+rb5z4EMI8rD/uoirV3mfJRVvJtpm1dmXuD2WXl6aYvJvHaiaHb3pzOXz2z7SrRfXGdwHTVKOHAXNpelf0RQc2HcbpIMFxLdENTc+3InQbTPHjZtl5hQ+ShnX5L0u/RS/2PjpvvMievBfA8F5lo72F0YzNwGei6oub7gwtejbXPLdlxOf1B3+9TNP1AR5PC7uT3c4XBzh0SnkFu2y7MvDqaqKDXHutEs280/ULpneu1I8xniMv5HRUV3LTX9tP/6uD4s6Ctp3TBogh4ga2/4AQAAgA5rUdfHcnb1+rYRz/ADAAAAOYwbfgAAACCH8UgPAAAAej6+tJuKEX4AAAAghzHCDwAAgJ6PL+2mYoQfAAAAyGHZO8J/oNK3LspeN9mzlglI7/dGes1FwmeUS22y1YeZRbuI8+hffvuati72fY8gy1tBxrEkHx5tcqmjjRvtAppd8HSUZ2/aFtXH9Sh3WlK8010OuAvFzuR5RJfxH63bTcrgTjCXYb48qLn37PZpdG6/bdq6fnjEXXE9zNr/Q9z2kLFx/V/+nF5z81i49x2GkCvOGXd9wQW7R8fLXdBcX3HnV7R8t2636qCrZLJZkjTQ1KNpMNzhslPQBCOobtTSTc9RGs0NIkn7pJfcZWGUOUfyog9ud35kaOQz6bWmlM+naCoTZL/sveEHAAAAOoov7abikR4AAAAghzHCDwAAgJ6vRV0/4s6XdgEAAAB0N0b4AQAA0PO1qOuf4WeEHwAAAEB3y94R/gMkpUUTRpFqq81yXTTmgrgcRZe5FEeVmXqUTWbiQt0/MF1iYZRi5xLuyk1duwc1F7s5wNRrTT3KZPsn09bFJUbHZE3ctHilWbbrpwVBzWXcuWVHnXyhafuiqf8pqG02bXc1dRdjF9XdsXbZftEJ5qKC60zdpHJqnznpNRe7qefi8peDfNinTCZuEPsnyec8RnG+jstLjI63e/7XROpaUUZydK3sgOjUdZeF6JIiSTuZenkGbd3nU78gotV95LtL7b5j3MpNPeAuGyXRxr1mGrsPZqc8vZTWFwoSkc3Zg2XvDT8AAADQUd0RkUksJwAAAIDuxgg/AAAAej5G+FMxwg8AAADkMG74AQAAgBzGIz0AAADo+cjhT8UIPwAAAJDDsneEf73S88KjjGWTV2/D8k2uu8sLDgVZwpKk14OayeR18efuX3bDg5qLEXeR1+E+f9W0XW7qLqs48h+mHh0PKbPO4L7kU2fqUV/K9AtEUe70Paat6YhL30iv7fGyWbbL2T/M1KPA7jrT1mzbquB9DTGL1tum7uY+iPLq/+XPcdsoZ19SODnCIcfGTTcE8wNI/tx118tMRNckF+y+xNRdbvtuQW2QaWtGEqNZFdzurDN1M7VI+DnhBkDd51O0W9zhcDn8J7gPuKCfvmNWbqb1UVGwY2oeiNsWjzALzzf1XMWXdlMxwg8AAADksOwd4QcAAAA6imf4UzHCDwAAAOQwbvgBAACAHMYjPQAAAOj5uuPxGh7pAQAAANDdGOEHAABAz9csKenidfaQEf7sveF/Ruk5sk3pzRqWxYt10ekugjmKjh5g2o50Kw+yXNebEOX5275oSXEOv2vrYsT3j7LZ3YmyU1x+b11cjxZf4nLAXYBz1N4s+9V347qZDkKlwU4fY8Kf891cFNVBzWTCN5rOEE1tULQxblv9bFzPq4vrUZD4O+Z4uCkZnglqXzRzEzSYc6DIXJQKouuKCyl/KriYSiZr/w9x2yNNVIbLCY92qsu6bzT16Hgvj5u+Y/p4f7fu6H2Xm7YPxeVough3HTengL0mRbvF7ZKiDOpu+g43NY9948vTS+668Lypp001JIW3OZKkfc29TrlpX+Km4GhPV99IY7vikR4AAAAgh2XvCD8AAADQUXxpNxUj/AAAAEAXmTFjhoYPH66ioiKNHz9eTz31VIfazZ49W3l5eTrppJM6vU5u+AEAANDzNXfTTyfccccdmjJliqZNm6ZnnnlGY8eO1cSJE7V27dqw3fLly/X1r39dRx55ZOdW+H+44QcAAAC6wLXXXqtzzz1XZ511lsaMGaOZM2dqp5120q233praprm5WaeffrquvPJK7bbbbtu0Xm74AQAA0PNl+Qh/U1OTFi1apAkTJrT+rlevXpowYYIWLEiP2Lvqqqs0ePBgnX322R1f2cfwpV0AAAAgAw0NDW3+v7CwUIWFbfNP161bp+bmZlVUVLT5fUVFhV566aV2l/v444/rlltu0eLFizPavuy94X9XqX9/eO+N9GZRdLMU595Kkom7D7Nx60zbFeab3IOCHHIX4e8yezOIGpaLbXf1xuB9mZh95VXF9eJBZgHRxj1u2rrOEB0U87czl2kdRMZLio+ni1fe4znzgmD+gVqTQe4GOqI8bfeeXb3C5FJH7V1OuOsK0fH4oznv3TkQTYsgSYOji5qbJMNdMDfMSa+5nP0CE9p9VNz+neCA2az7SlOPdroJhS8wi7YfMuVBzc1NYILfoz7upi4oN3U3R02dqUfcZ0h5UHPnph18dX0p4A6X27a6oObmD3D7rMQ9vzEqqKWdA82SzHwof8+qq9teradNm6Yrrrgio2Vu2LBBn//853XzzTdr5513zmhZ2XvDDwAAAHRUN8Zyrly5UqWlpa2//vjoviTtvPPOys/P15o1bf95vmbNGlVWbj1S8eqrr2r58uU64YQTPlpdywcr7N27t5YsWaKRI0d2aDN5hh8AAADIQGlpaZuf9m74CwoKNG7cOM2dO7f1dy0tLZo7d65qamq2ev3o0aP1/PPPa/Hixa0///zP/6xPfOITWrx48VZ/VYgwwg8AAICer0WSeZpwu+vk+qZMmaIzzzxTBx10kA455BBdd911amxs1FlnnSVJOuOMMzRkyBBNnz5dRUVF2meffdq0Ly8vl6Stfu9www8AAAB0gVNPPVVvvfWWLr/8ctXW1mr//ffXgw8+2PpF3hUrVqhXr+3/AA43/AAAAEAXmTx5siZPntxubd68eWHb2267bZvWyQ0/AAAAer4WSSZAbLvr6keItlH23vAPUerWFQd5VSWb48Vm+keSKLGt3LR1X63IG5teG26yxQ58wSzciL7Y7iIkXQJeSRRTt6tpHOwTSdJAU4/ySheatiaeT1EkqGk7fElcLzGrjrqDa2s7arBPy9bFTYvNCTYg6Ggu7tDF0Ln4vShW0MXnuaTFAUHNbVcmkYSS4n4YRe9J/vx5Lai5TEITu6m8+FOyIJNPbbfTowNmrjklw82yTZRwWA8icSXZzjIsqLkEY1d3l8MomtadPy6aNlq3ixutM3X7xoJzaJ9X4qavmkVHyc77mrYjXf6yu+GIzoE0729DG2SN7L3hBwAAADqqWYzwpyCWEwAAAMhhjPADAACg52OEPxUj/AAAAEAO44YfAAAAyGE80gMAAICej1jOVIzwAwAAADmsUyP8V1xxha688so2v9tzzz310ksvSZI2bdqkr33ta5o9e7Y2b96siRMn6oYbbmidLrhTjpKUljN7VHqzg1/s/KraeNvUF6eX1m6Mm75sFj3wufRaMPWAJOlfTT2TnPEoilvycdzNwcrzo3B0KQ4qluzxSoLc97wJZtlRqLUU5xybnTLE9NMhq8y61wS1aO4BSRpu6kEodrE7lc38As8F232wWXSJyzf/57h8aLTP1ptlPxmXG4L5P0rdPnN93AmuG/bEd/s0av9M3PSdaH/L5+yXJNGw2XnxwufcHNevCmqL46ZPm+u8M+Y36TWXV19wXFw/J5iPpdws2+XZu25aF9QyydmX4kut+3xyn7vv/CGu9w/y6t3H1xBTj0Zcx5i29jpuPgfWP5ZeSzvWmV6qugRf2k3V6RH+vffeW2+++Wbrz+OPP95au/jii3Xvvffqzjvv1Pz587V69WqdfPLJ23WDAQAAAHRcp5/h7927tyort55btb6+Xrfccotuv/12HXPMMZKkWbNmaa+99tITTzyhQw89NPOtBQAAANApnR7hf/nll1VVVaXddttNp59+ulasWCFJWrRokbZs2aIJEz56TmL06NEaOnSoFixYkLq8zZs3q6Ghoc0PAAAA0CnN3fTTA3Tqhn/8+PG67bbb9OCDD+rGG2/UsmXLdOSRR2rDhg2qra1VQUGBysvL27SpqKhQbW1t6jKnT5+usrKy1p/q6uhpPQAAAACd0alHeo477qNvDO23334aP368hg0bpt/85jcqLi7epg2YOnWqpkyZ0vr/DQ0N3PQDAACgcxL1mC/RdrWMYjnLy8u1xx576JVXXlFlZaWamppUV1fX5jVr1qxp95n/DxUWFqq0tLTNDwAAAIDtI6Mb/o0bN+rVV1/VLrvsonHjxqlPnz6aO3dua33JkiVasWKFampqMt5QAAAAIA2P8Kfr1CM9X//613XCCSdo2LBhWr16taZNm6b8/HyddtppKisr09lnn60pU6ZowIABKi0t1QUXXKCampptS+hZofRQ4k1BOxfK6wSZu5KkQemlwUHmuyQNejeu5+2cXhtYH7d9yeRtR7tMiuO23RwAJaYerbsoyC+XfMb/e2afR+US98ZcKHb6H6588LT7p3aBqUfB1S7U2mWvlwe1501b0w+jsovCH2RCr/PcuR/N2WACphPTT8O3HVwzJPmAdDevQrRy1xcyYYLb+zdmuoIoa/+muOknTA7/nKBmzvs9H43rbuqDcD4Jd+dgjmd0irjD4bqpmVYhPH/d3+3dx27U1dxnmzsF3NQ7pcEL3CXnJVOPts3Ni7CHC8U3B3Rg36CW8sHZkEh6z6wXWatTN/xvvPGGTjvtNK1fv16DBg3SEUccoSeeeEKDBn3Qs370ox+pV69eOuWUU9pMvAUAAACge3Tqhn/27NlhvaioSDNmzNCMGTMy2igAAACgM7rjEZue8khPRs/wAwAAAMhunZ5pFwAAAMg2LYq/u7ej1tkTMMIPAAAA5DBu+AEAAIAclr2P9Lyo9EzGhqDd62a5UZSilFEsp4vBynNRi/sENZc9dltcrjPNoyg5kyaqgaZeUhYUM/y2i53fOfpb26umrYvtjKI3dzNt60zd7Zdo3eWm7VhTjw6oy7B7MS5H3dilzDmDTWxnuO1m6COvIq7vFGUWumuKy551Ea9RZKjZbpupG3E5j+5a6/r4nCBa08Vu9jZTbX4v6OT3xZ281MX1ugtmdG1w13kTqftkUBtmFu0eS3jO1FcFtSGmrUsKjiIq3XXDnV4uRjXq5i6W01wOw7jS8aatva64Ax61T8sL3SLpYbPcbsaXdtMxwg8AAADksOwd4QcAAAA6iC/tpmOEHwAAAMhh3PADAAAAOYxHegAAANDj8aXddIzwAwAAADmMEX4AAAD0eC3q+hH3nvKl3ay94W94Ib0WHcw3zHIrTFb3YNdTolBfk8OvalM/MqhFWfaSVt8W112kfDS1QRQxLkkuljqpT6+5E6XJ1F3GchRr/bYJYG7aGNf3eCgouuDpWlN3OzWa08FlebvOEO2XOtM2ONaOi/h3MftFwTVDiuPRXdR9ad+4Hu2yYrdP3MqjEHIp7iuuH7ks/agvubx5975cjvhVQW2OaRvl7EuS1qeXjh8XN930TFx351fkr6ZuTpKng1qdWbT76IuWLcVT4Oxq2o429bRYeMlf7lw3dJfi6Nx+3rR1cxeUBzU3pdAerp+NMvXofiTtuuE+kJHVsvaGHwAAAOgoYjnT8Qw/AAAAkMO44QcAAAByGI/0AAAAoMcjljMdI/wAAABADmOEHwAAAD0eI/zpGOEHAAAAcljWjvBH/0qLMnldFL6LtM4o87oww2WPDWomw3+YWXSFqbuM80h0PKQ4xzhTbtlRVHgmEeR24XWmbYmpu/DoiJucwOWnRxljLrTaDHVE56fb7A0Z1t3xjpS6enTuB5Hvkny2dSYnmLvmuKGp6MKw3LR12x1d7yRpcVBz8wvcZwLrw6z9RXHbU/aM6+8sjevzg9rjcVN37kZTG7hd5rhLVtTVXNtyU4+uG+59uekeXjT16LrkPiNcPTr97OePe+Nm7p5wp6ZdUzabZSKrZe0NPwAAANBR5PCn45EeAAAAIIcxwg8AAIAejy/tpmOEHwAAAMhhjPADAACgx+MZ/nSM8AMAAAA5LGtH+N+R9H5KrTxol0kMliQNMfmUTUEsWoGL5XS5g9G6Ta6mS+hyCXl1Qa3AtHX7NFq22+5MIz3fCmouYbLOLTz4Z33BmripS0wbaOrR8cx3kZ427y1QZ+rmgFYHsW4uVtOlW7q+Ep1+duTDHZAgk7D5hbipPV4u0zDiTs56U1+SXnrHJF+660bJ8Lj+9Mb02p6Pxm1L3YVl0zPpNRe7Ge0USer/3bje75vpNbNP3UWrMqhVmUW7SGsX7RxdVtyyM4mVLjdtXSxn0BMkxaeQ+1zNJMrU3S7Y63j04SfFEZsNKb/fkRnb2OGy9oYfAAAA6KgWdf2XaHmkBwAAAEC3Y4QfAAAAPR6xnOkY4QcAAAByGDf8AAAAQA7jkR4AAAD0eOTwp2OEHwAAAMhhWTvC30fpkd7Rv1Lcv2BsjKzJbw7L5WbZLgjZ5XEHojxfyWdiRznJwdQDkvxmD87gn5VN5p/O7nhG2+b2mVu2y2DekcJd6jLIXcBztHC308y6BwY54wNcJrzh8rYzipDekd/Kcst2xzMK+3YB6E5wvPs3mrZuu931MGCPpbtoRRnl7yyN27qcfV0Sl8cGOfxjzKLNGx8e1FxXiDL8JR/rHu3yctPWdYWovdvuEvMBNdD0leiS5/ZpJvvcXc/stdh9QEXzBpWm/L4H5PDzpd10jPADAAAAOSxrR/gBAACAjmKEPx0j/AAAAEAO44YfAAAAyGE80gMAAIAej1jOdIzwAwAAADmMEX4AAAD0eHxpN13W3vBX95ZK87ahocmJdRHkLvw23CQXujvE1J8Pao/GTV3krouljjbdbXZJX/OCfw1qJnu9oM7UV8f1kcuDWtxUDZvjemnw97H3zN/4Nph1u3oUce7mXLCiXHeX/ZzB3zbzzLKHuyBwd/5F2+aW7d5XrakHEtPP8oK5CyRldryqTX23oOYupuWmbsLXx/wmvVbigtuj7Xbmm3q/IEdfinP2JWnnJL32g/Fx29lPheUBDwe1eMn2M8RdV6Kbnk2mrft8cqdAZIBZ+BGmfbRfVpq2bruj08+dmtrX1E1XCtunzV3QKOm/zXKRtXikBwAAAMhhWTvCDwAAAHRUoq7/Em3wN7uswgg/AAAAkMMY4QcAAECPx5d20zHCDwAAAOQwRvgBAADQ4zHCn44RfgAAACCHZe0If/J++jefo1hdE+tu/4VTanLdG4PM7BIXZOyyvlcFtRfipu59u5jwYUGtpMw0dnnABwe1l03bJlNvjMvNwfHKN1nepe54Bd41MQEuv9nl8EeR89WmM5S6lUeB3S7XvS4uv7csvVbs5nOIJh+Q/LZFufHrTVtTXx/0M5dBbrqwhi+J6wVRZ3H7ZHdTjzpauWnrcvpNPwwPtxtSczv9r0HtcdPWhauPMfUwa//JuO2+8eQ00dt2u8Rdc+pMPbpcunW7S1I0vY67TLtTYGwG63YyGfl1lzsrk8le0naancgI2Sxrb/gBAACAjmpR18dydvX6thWP9AAAAAA5jBF+AAAA9Hh8aTcdI/wAAABADuOGHwAAAMhhPNIDAACAHo9HetJl7Q1/3gFSXkoEVEnQrqTcLNhlXUWRhJJKotQ0d9SfMfUg1rPZRPNVXmTqLv4yipKrzqCtJB0T1J4zbR8ydZPJlh9lqu1qlr2TqQcGmu3qZ6IzXVRj/+hvc1GUouTjFCOjTd30s+I1QfFAs2z3vg4z9eh4vmLaLo/LA4P31WRiHl3SXYGLK3XRtZmI4ifcufm6qZusxoLjgqKLQDaRu2G0ZpT7LPmMY5fjOPup9JqJ3dTeaWHVHxir9Pbu9HH9MJN4ykpTP8jUdwtq7n25BJXlph59/LmPxqNMfc+gNvh40/gsU3cbF91TpF3H3zPLRFbL2ht+AAAAoKOI5UzHM/wAAABADmOEHwAAAD1ei7r+mXpG+AEAAAB0O274AQAAgBzGIz0AAADo8fjSbjpG+AEAAIAclpckSRzs+zGrVq3SJZdcogceeEDvvvuudt99d82aNUsHHfRBkm6SJJo2bZpuvvlm1dXV6fDDD9eNN96oUaNGdWj5DQ0NKisrU/0+UmlaMLDJyg+tNnWTDb00yJZ2i3b1uqBmYvj1Y5MZ3+SypQPLTf0FU49iq6NYdsl/+cZFYkdx29eYtuWmPjj45/J6809+9y9tl3kdTSfxhmn7vKmvDGqvmbYdO8vb5/aJi5U+0dQLonkXzMmZmOOZFwRqjzInrzs13fuqCGouo7yfqUfTZLipPdy5PczUzwlq7loaTZciSU8HNffx4jLlh5t6tHzz8aOxpv6P4ce5SYX/82Nx3c1hc1dQcxc0NwdHdNGKLvKS9Me4/LtgWgQp7qflZtVmOhZt2MZaR5btzs/ospR2qLdI+h9J9fX1Ki0tNWvoWh/eO96ujKbQ2SbvSvo3Zed++VudGuF/5513dPjhh6tPnz564IEH9OKLL+qHP/yh+vfv3/qa733ve7r++us1c+ZMPfnkkyopKdHEiRO1aZO7lAEAAADY3jr1DP93v/tdVVdXa9asWa2/GzFiROt/J0mi6667TpdeeqlOPPGDcalf/OIXqqio0N13363Pfe5z22mzAQAAAHREp0b4f//73+uggw7SZz7zGQ0ePFgHHHCAbr755tb6smXLVFtbqwkTJrT+rqysTOPHj9eCBQvaXebmzZvV0NDQ5gcAAADojOZu+ukJOnXD/9prr7U+j//QQw/p/PPP11e/+lX9/Oc/lyTV1n7wRHVFRdunSisqKlprHzd9+nSVlZW1/lRXuyd1AQAAAHRUp274W1padOCBB+rqq6/WAQccoPPOO0/nnnuuZs6cuc0bMHXqVNXX17f+rFwZfWUQAAAA2FpLN/30BJ264d9ll100ZsyYNr/ba6+9tGLFCklSZeUH+QVr1rTNZ1izZk1r7eMKCwtVWlra5gcAAADA9tGpG/7DDz9cS5a0DXNaunSphg37ILhqxIgRqqys1Ny5c1vrDQ0NevLJJ1VTU7MdNhcAAADYGs/wp+tUSs/FF1+sww47TFdffbU++9nP6qmnntJNN92km266SZKUl5eniy66SP/5n/+pUaNGacSIEbrssstUVVWlk046qXNbVqn0MNgoZNWlf0ah1ZINeN4c1FxurosijjKxXZ62y9l3efUFQc3l/brOPjCouX2SNhVDR+slQc3laReZenPwdzz3vppMPToekhT9Hcx18fWmHm27298uwzw6R9z+dserYC/zgjFBzZy8eS6DPDhBx2SYw3+AqUf7xV033D6P+oI7713Gv9u28qDWaNq6jP+6oOYOdZWpu/eVSQ6/W3actT8/brrfGWbZv47LC4MLYgbnj6R4Eg434YP5ADvMNK+MhkXNBbHIfBBEDzC7XeLOP3dub8vb6imPrqB9nbrhP/jgg3XXXXdp6tSpuuqqqzRixAhdd911Ov3001tf841vfEONjY0677zzVFdXpyOOOEIPPvigiopc9wMAAACwvXXqhl+SPv3pT+vTn/50aj0vL09XXXWVrrrqqow2DAAAAOio7njEpqc80tOpZ/gBAAAA9CydHuEHAAAAsk2irv+uQdLF69tWjPADAAAAOYwbfgAAACCHZe8jPTspPcorisJy2ZiOy1MMuBwiF1kY1V3EnUkTtdGa0b/8XjNt6029LKi5L7u4NDe3XyLueBW4fw4H/bCf6Ueum0bJs5KUH+zUwSbnscVsW7TP3f52xyuKHXTv2R5rl9tZvo01KaN8y31NU3fJcbGB0aa5febiX+uCmosTLTd1t0sziSl2f9LP5Et2bt2ZxP2664KLxdWfH0uv2djNX5j63LhcGXwKRR8Ckt+pUQ6ryziOsrRlYjelOIe1zrQ1J3fUD9310F1rM5G2S3rCCDFf2k3XE44fAAAAgG2UvSP8AAAAQAe1qOu/tNtTJiRjhB8AAADIYdzwAwAAADmMR3oAAADQ4/Gl3XSM8AMAAAA5jBF+AAAA9HiM8KfL3hv+IqUHzboA6IgJrG94Pa4/E9RWmVW7b3JHudNvm7YjTd3FIEf5zm67G0w9ilCOctklnzvt2ruI5lAGIf/NZnKCaJ9Ifp++Gyy/zrRdaerLg5qJtLZzTUTZ0SUZLtsG2kfntjsgLvS6PL1Ua5q6y5mbByM6Bwaati7re01Qc+/LzQ3i5sGIMumj7ZKk50z96aDm+mGFqbs5T6K5D+pMW9fF9w/76a9Na5Oz7z7hPvVPQfFVs+x1cXll8AnoPgTq4vIq8wE3JCpWx22r/hrXoxtF97bcnA2uH0afA2mfuz3lxhbty94bfgAAAKCDiOVMxzP8AAAAQA7jhh8AAADIYdzwAwAAoMdr7qafzpoxY4aGDx+uoqIijR8/Xk899VTqa2+++WYdeeSR6t+/v/r3768JEyaEr0/DDT8AAADQBe644w5NmTJF06ZN0zPPPKOxY8dq4sSJWrt2bbuvnzdvnk477TQ9+uijWrBggaqrq3Xsscdq1SoXFdMWN/wAAADo8VrU9aP7nf3S7rXXXqtzzz1XZ511lsaMGaOZM2dqp5120q233tru63/961/rK1/5ivbff3+NHj1aP/vZz9TS0qK5c12yVlvc8AMAAAAZaGhoaPOzefPWQdZNTU1atGiRJkyY0Pq7Xr16acKECVqwYEGH1vPuu+9qy5YtGjDAhlW3kb2xnFHg8PqgZnL0XTity29+PoNVu1zdqqDmMndfMnUXKR/t7iizWvK57lHetsvZNzHHNmc/yo2vM20Hu9Dr4ME9d6zdvAouFv6NoFZn2rp85ig/PZM5F6Q4c9718UGmPvRl84LoQUvXEV1fCALtXR69W7RrH70tl/FfburRpdb14TpTd9sWtY+2S/JzokTXanetdOe2e1/R8XLnpnPqXUFxoRmHrDQ9LczZl6T7g9oX46avzorr0QF7Nm662BwQd90ZEh0UMz9Hnqm/G5z87nPVzc+xJMN6e5JtaPP3pLq67R3LtGnTdMUVV7T53bp169Tc3KyKirYzelRUVOill9yd3AcuueQSVVVVtflHQ0dk7w0/AAAA0EHdmcO/cuVKlZaWtv6+sLBwu6/rmmuu0ezZszVv3jwVFbnpC9vihh8AAADIQGlpaZsb/vbsvPPOys/P15o1becLX7NmjSorK8O2P/jBD3TNNdfo4Ycf1n777dfp7eMZfgAAAPR42R7LWVBQoHHjxrX5wu2HX8CtqalJbfe9731P3/72t/Xggw/qoIMO6sQaP8IIPwAAANAFpkyZojPPPFMHHXSQDjnkEF133XVqbGzUWWedJUk644wzNGTIEE2fPl2S9N3vfleXX365br/9dg0fPly1tbWSpL59+6pv374dXi83/AAAAOjxuvMZ/o469dRT9dZbb+nyyy9XbW2t9t9/fz344IOtX+RdsWKFevX66AGcG2+8UU1NTfrXf/3XNstp70vBEW74AQAAgC4yefJkTZ48ud3avHnz2vz/8uXLt8s6s/eGP8qqqw9qLmPLZK4NMBFeUXSmi9dzmxZFULq2Y03dpQ5Gb9tFYzqd+x55Wy6K0Yki9FzcYYnpCyXBN2BKzLKDFEdJmX25xrV1zxtGfc1ttzte0bJdorBNHHYrjzqDO0FcJw6uK/2iDFX50SF3/kVv2222O57RtrkIVsckFobbFn8tThpi6rsGNXfuum5WbupRN3SRn/FX+hR/CLkdXuYW/qqpR9Gb7U8o1Grkb82yg0Dgh+KW+5qsbdNczUG2c36U+yzZfV4UHK9RZtG1pu5iN7fls7VFPi4U2St7b/gBAACADursl2i31zp7AlJ6AAAAgBzGCD8AAAB6PEb40zHCDwAAAOQwbvgBAACAHMYjPQAAAOjxekIOf3dhhB8AAADIYdk7wr9C6dnYTUE7Fyxt7G1mKd60Mb3msvJdPcoZf8u03WMv8wIXyL0mvdRsAutdnv36oOZypwtM3WWBR1+mcfvU7bI9g3/Wu39Juwxkt+6o/rZpa6aiCEcrXBa+y4yPYsILTVuXS+1DygOuMwwz9X3TS9WPx03dOeD2aUVQc/3IXZOifuyW7d6Xu1RHy3f9MJovRZJGB7Vy09Z1BbfuaHoPl3F+kKnrwKDmLjo2mH1dXH51VnrN5uxHk+tIGnlseu3KOWHT/N3iRa//dlyP8u7LzYefO7+imP4h5oLYZOYAcOveFluU/Tn8Ler6L9Eywg8AAACg22XvCD8AAADQQcRypmOEHwAAAMhh3PADAAAAOYxHegAAANDjEcuZjhF+AAAAIIcxwg8AAIAejy/tpsveG/5CpW9dSdCu3CzXhVqbEPNxf0qvrY8CliUtN6seHtTKTdsoB1ySD80OwtmrTNZwlK3uVu2yup0yU4/Snd12u5M4L8hJLjb7u9gtvNTUgxDzStOH+5h6lN9sIq1tFH606iiTWpLy3N8jXTh72rweku9IUb65JI1NL7n5A1xX2N3Ui6O8bvO35n7mJIii2d0lpdzUXfvoUu3mknD1aN0ujj6a90Dy7zs6B9w1yZ1/ej6ouc8+N6nJSnPheD0qNsRto5x9SdIfgrYD46YHxtttZgAIr4eZfn6FzNvaI5rgRtJbJqe/Lqil9cMd+n6xw/FIDwAAAJDDsneEHwAAAOggvrSbjhF+AAAAIIcxwg8AAIAejy/tpmOEHwAAAMhhjPADAACgx2OEPx0j/AAAAEAOy9oR/oan02ulQQa5zeKOQnUlaU9Tr0ovDXwrbrrJBP5Gb8s6ztRdMPXj6aXBJoe//JW4HkVDu39xmuRnezijQ7LStHX1PkHOcZHJQDYRyypxX/sPhhSazU6rNYuO9tlw07YgyoSXVBkEoCfm/Gg2+yT/xbgenmDm3LWGp5fM6WO5flga9DV3frltWxLUXjZtXaa8uyS9FtRcHri7LkTt3XwQ5abu5qKIuG7o5ggIL5hrTNsmU3c7/dmg9pBpe+WcuB5m7ZtA+pOOCsvz9VhYj86haEogyffxYVHRDRubzjDqjbgeldOmZHgvXiSyXNbe8AMAAAAdlajrYzKTLl7ftuKRHgAAACCHMcIPAACAHo8v7aZjhB8AAADIYdzwAwAAADmMR3oAAADQ4/FIT7qsveFfqPTIq+p309sNCGqSVG6iqgpcNmZ+UDN5bENcTl2w7qp1pq2LTHP5YBGTPVZgcuxagvftdomLqcukbsLc7LJ3C2quG7nDNcj146BeZ5btIgujuv2TYHR+SOGVMdO+UPVCXM8L+ulas/LBBWblQWdwMY/uw8IkvKZG6EmS6UYZRdO64+HeV52pR7GfQbqrJN8NM0l2dvUSc/JHn1HuMu3SR/L/GBTdAXMdrS4uLw7e177PxW3zo4upJB0Y5I2a2E1pflh9WnlhPTom7nroYjvHBrXRJka1pCKuu74UJIynnrvRtQbZL2tv+AEAAICOalHXx3J29fq2Fc/wAwAAADmMEX4AAAD0eDzDn44RfgAAACCHccMPAAAA5DAe6QEAAECPx5d20zHCDwAAAOSwvCRJko6+ePjw4Xr99de3+v1XvvIVzZgxQ5s2bdLXvvY1zZ49W5s3b9bEiRN1ww03qKLCBMb+jYaGBpWVlan+fKm0MOVFUUDzk2YFJph6kan/JqitMqseaeqDgpr7Usgjpu5y34cEtVrTNtpuSfpGUDNTF2jgPuYFmcybEIUgSz7E/OH00nur46YLzaKd8qDm8pddhnlTUDNx2jbjP8pxrjZtXVT3Hn3jesPG9JrLbXcR5i8GtSgaXfLd7DhTPyyolR5hGo8x9WiyCrfhLrTbdMR3/pBeC1LZJfk5HaJrmpubwF1LB5p6dEjcuen6YXR+Rv1EkirN8N8qM4z5WlBz1wU3J0p9UItT9qWnTX25uwVqCnL6p5mF/zAuPx10VHcdd30hk3lN0k7d9yRNllRfX6/S0lKzhq714b3jZyW5aVO2tyZ9cG+Yjfvlb3VqhP/pp5/Wm2++2fozZ84cSdJnPvMZSdLFF1+se++9V3feeafmz5+v1atX6+STT97+Ww0AAACgQzr1DP+gQW3Hcq+55hqNHDlSRx11lOrr63XLLbfo9ttv1zHHHCNJmjVrlvbaay898cQTOvTQQ7ffVgMAAADokG1+hr+pqUm/+tWv9MUvflF5eXlatGiRtmzZogkTJrS+ZvTo0Ro6dKgWLFiQupzNmzeroaGhzQ8AAADQGS36KIu/q35y/ku7d999t+rq6vSFL3xBklRbW6uCggKVl5e3eV1FRYVqa9OfmJw+fbrKyspaf6qr3ZO8AAAAADpqm2/4b7nlFh133HGqqqrKaAOmTp2q+vr61p+VK91XpgAAAIC2WrrppyfYphz+119/XQ8//LB+97vftf6usrJSTU1NqqurazPKv2bNGlVWpmexFBYWqrAwLY4HAAAAQCa2aYR/1qxZGjx4sI4//vjW340bN059+vTR3LlzW3+3ZMkSrVixQjU1NZlvKQAAAJCiq5/f//CnJ+j0CH9LS4tmzZqlM888U717f9S8rKxMZ599tqZMmaIBAwaotLRUF1xwgWpqarYtoecTSs9Yj0KzN5vlLo/L5a/E9ehfSC731uU3R3/nKDFtJ5q6y3eO8vCfN23dto0Oavl7mcYTTD2T0HkXvt7H1IPw6GLTdIDJ6Xd9JeqHUY6+ayvF/fgY09atO9Lf5OhnGtRf+mxQLIvblkRB4JKqguPpMsbdn4MPNvXSPYOim8fCnT9RuPpy09YZFZf7D0ivlZogfjcFQNTH3WXBfbhncklynyHuFKgLai5nX+bp3GiuFkkaEgS7N5vPZTfXS5Tj796WOx5hzr4kFQQ5/VebtsbBfwqKpjOMjs5NSc1r4no0d0hdyu/deYXs1ukb/ocfflgrVqzQF7/4xa1qP/rRj9SrVy+dcsopbSbeAgAAANA9On3Df+yxxyptct6ioiLNmDFDM2bMyHjDAAAAgI5qVgZpNBmssyfo6v0CAAAAoAttU0oPAAAAkE26Iyazp8RyMsIPAAAA5DBu+AEAAIAclr2P9Lyh9GzDl4J2UU1S0xtx/cm4rAVB7VXT1qRo6eWg5hIiP23qLjozSiV0sWYuQjKaO3m4iaeUq5ebepSB5yZ1dhl4QYTrWrPdC82iXZRjJNM/L0ZfQPoX03akqedH0ZuDTGPXiU1UY3NwTPKDSEFJesdE5EWpnY/HTa0KUz9ySXrN7TLnnWDZr5u2Lt5yHxOBHJ1C7lrq6lHUsLueuYhj140zmUveXZLKo6I7IHUZrjz4kMo3sZzlGcQUuz5uRzWnmXoUvZkXRHZK0nSz0+8Mrtb3xE3DGwbFsZuSFCWCpn3+uHMjG/Cl3XSM8AMAAAA5LHtH+AEAAIAO4ku76RjhBwAAAHIYN/wAAABADuORHgAAAPR4Ler6L9HySA8AAACAbscIPwAAAHq8ZklBkOoOW2dPkL03/POUnusbZEPbLG6zWpczG9WjLO6O1N8Nam67zzF1l6U/IKi5nOMNph7lTg8yO6UkOtaSD70OJhhouituWjAsrjcEQeQmItlGXrt9GnF9OOpnktQY1FyUd36VeUHU0aKa5P9uWheXVwW1ApOzX2tWHTV3uesu191MERC+r1Hm/HF9IZp3JMqyl+J9Ivl5S4YENTPdis0gfy6oufPHXQ/dJSn6iHLX+aNMPdrnRe6AmHrVX+N6XjRZjJlIJpPrnftss3NR/DCDlbucfXdEPxP08pfN5ARmgo9V6+J6dA6kXbNcF0J2y94bfgAAAKCDiOVMxzP8AAAAQA7jhh8AAADIYTzSAwAAgB6PL+2mY4QfAAAAyGGM8AMAAKDHY4Q/HSP8AAAAQA7L3hH+hUr/50hd0M78E8blTrtM3yhj2cS2uyhiDQxqLht6T1Mf6lZekV4qeCNu6nLGRwW1ErfTCk19vakHXLZ6ZZCzL8X56GY6CMulO+8U1FwfzuQcGLmXaXyMqWdyArkNf8Ss+oX0mju/3PGITq/DMmgrSfuaenR+5Zl9WmJO3qIgb85td52pu+z16FLu5i4oNfXyoOZG69z5VWnq1aYecdf56JLlrtPufbv6u0FIu5sDwPWliLtsjDX1p822HfynoHinCWSMcvYlhbNoHGPGqYPrmSSNMZ9fUQ5/mqZtaIPskb03/AAAAEAHkcOfjkd6AAAAgBzGCD8AAAB6PL60m44RfgAAACCHMcIPAACAHi9R1z9Tn3Tx+rYVI/wAAABADsveEf4+Sv/nSJSRVxIvdqDJTJv4SlyvC2pr4qY2eizatGi9kjT0WPMClwW3W3pp+MNx0+Fm0RoT1Fxmmns4brWpB31lg3lfBWbR0fGsMm1NElxGfSWK7JR8umUQFCf9u2lszr+Qi/R0WYxmpxcHO73Y5Kj2d3l0wU7dYOLz3PHYf1fzguj8ijI7Jem1uFzzQHrN7ZIotlbycaPR23LRmONNPUoszDSidYCpR5did94PPj6uv3Bfei1KxJX8dcPtlyj203XDIS5+OcqsNp8Ro80Hs4srDS/W95i2L5sPqCh681Azbjw2flLdRXGf84v0WtplYaOkW+LFIotl7w0/AAAA0EHd8QVavrQLAAAAoNsxwg8AAIAejxH+dIzwAwAAADmMG34AAAAgh/FIDwAAAHq8FnX9TLtdnfu/rRjhBwAAAHJY9o7wFyo98DgKYXZZ3SaMuNR8++KYZek1E+VtNy2K23YZ/zrM1F0Ic5DDb8OhXWD9EUHN5fBHgdmS9IypBzHIZkoGm0tdHOyXfiZo3/UFJ5NTwI1GhO/b7TQnCvN2Qd8vmnqtqUf92A19uPkFgnD26NSS/BwbNvjdTeoQqYjLxSPSa/sG10LJH86RLnt9eHppjw2mrQnD3yOaJMBd79wbc5MEuAkIImfF5beCHH73xUL3tt0uj6Z0cKdm0+a4vsf6oGg+20pMH3/LfLiOjt7Yy3FbPW7q0RwdJmdfxSan/+a4/cBgcoSBKe+roUnS7Hi13Y0v7aZjhB8AAADIYdk7wg8AAAB0ECP86RjhBwAAAHIYN/wAAABADuORHgAAAPR4xHKmY4QfAAAAyGGM8AMAAKDH647R9p4ywp+9N/zvKP3vD41BOxdC7jKUTc54dZA97Vbt6v2DAPSCd03jIG9ekp8kYHlQcwHMLnc6Ol51pq1bt2u/Mr3kcqddvHmUw1+UYQ6/+9Z/dIFxXcW977D+P6Zxk6lHb9zl7Lu6O7eDvmD7mTtgwU6LViv54zXIzEXRP8ooz1QwB0C5aVri/n5cbepRX3Lzigwz9SCDXGWmbZThL/m+Mj6ouX5o9lkUC5/p3B/ubS/Zxprk3/ZbQU7/qDfitu7jyV3nm4OcfndJWrUuro8Jzu2h7kJtcvZVYHL6L90zvfbq0vZ/v0FZn8OPdDzSAwAAAOSw7B3hBwAAADqIR3rSMcIPAAAA5DBG+AEAANDjNUsy317Y7hjhBwAAANDtGOEHAABAj8cIfzpG+AEAAIAclrUj/A1B6G+U2btlY7xcF207xAQCR1HfbtkDTD0KDC5yYd33mLoLG442PpgfQJI00NSjzGwXZOzmD4iCp83yXfaz22XRMak3bV2mtYuUj0YU3L/iXS51EL0uPWQaOxkMMSw357ZbdHQKRVNFSFK5OaDRPnNd3I0OuX44LNgvI58xjctNPVBSaF4QZd1L9oK4/rH02sC+mS07zLN3Gf9BJrwkye2XfYOauyiZQPuonOnonptPIlq326VOXVAzMfyqMnV3LY7O3z+Zts9lUD/nF3Hbge78inL2JYVHbORX2v99Q5OkW8xyka2y9oYfAAAA6ChiOdPxSA8AAACQwxjhBwAAQI/Hl3bTMcIPAAAA5DBu+AEAAIAcxiM9AAAA6PFa1PWP9HT1+rZV1t7wb5SUl1JbHbRzcYZFpj7IxO9Fy3fLznNRcUH8Zb7L/DRxbu+ZWM/iaPlu3ZlYZ+qZZMGZuusrLg7R1SMuZbUhg2W7flhi6gVBrcFsuHtfmcTa1pq6ixuNuL6QSV9xz3c2Zbju6NRvMtez6FhnzHVEI3pfA91OdeuOOps7sd3JWWrqUcyx68Qmhjh6W2Hcrvyf+137HSk6JC5St9nUXfu6oLbetHUfX5HXTH2gi6R+dWlcT4velCTdkPL7BhHL2XNl7Q0/AAAA0FEtSh8s3lF6ygg/z/ADAAAAOYwRfgAAAPR4zWKEPw0j/AAAAEAXmTFjhoYPH66ioiKNHz9eTz31VPj6O++8U6NHj1ZRUZH23Xdf3X///Z1eJzf8AAAAQBe44447NGXKFE2bNk3PPPOMxo4dq4kTJ2rt2rXtvv5Pf/qTTjvtNJ199tl69tlnddJJJ+mkk07SCy+80Kn1csMPAACAHq+lm34649prr9W5556rs846S2PGjNHMmTO100476dZbb2339T/+8Y/1j//4j/r//r//T3vttZe+/e1v68ADD9R//dd/dWq9WfcMf5J88DTUxuA1UW2zWf77pu4S18IIPNPWPugV9RrX1tTfM823RO1db3a5Z1GuoDtgbqe6Axq8L5NkmlFfifqo5KPgXLxlxB2OQlOP3rc7P1w/yySW0+2zTJ7bdMt2F8ooNtDtE9fFXV+I+po7XgWZPHzq2rqOaE6w6PxscOt20ZrRTnfXpEzzeqPO5rIvTWfKJB7Wjf65w5nJR4jbZdF1w51f7tzOpH2m0c5RN3SfIQ3uwuE+4MIFtH/laGj44Pcf3qdlo+7Ysg/X+eH++VBhYaEKC9t+4jY1NWnRokWaOnVq6+969eqlCRMmaMGCBe0uf8GCBZoyZUqb302cOFF33313p7Yz6274N2z4oJce3M3bsUO8k2E94u5OM2kfTXzQkfqzndwWAF0jkwkfnB153ru7tId34Loz9d/dvQFdz+XRZ5JXn6ts2v3sDOvhGuK1b9iwQWVlZW4FXaqgoECVlZWqrXUztuwYffv2VXV1dZvfTZs2TVdccUWb361bt07Nzc2qqKho8/uKigq99NJL7S67tra23dd39r1m3Q1/VVWVVq5cqX79+ikvL08NDQ2qrq7WypUrVVrqZjSBJPbZNmCfdR77rPPYZ53HPus89lnnsc+8JEm0YcMGVVVVdfembKWoqEjLli1TU5N91mKHSJJEeXlt/8788dH97pZ1N/y9evXSrrvuutXvS0tLOQk7iX3WeeyzzmOfdR77rPPYZ53HPus89lks20b2/1ZRUZGKijKc4nsH23nnnZWfn681a9a0+f2aNWtUWVnZbpvKyspOvT4NX9oFAAAAdrCCggKNGzdOc+fObf1dS0uL5s6dq5qamnbb1NTUtHm9JM2ZMyf19WmyboQfAAAAyEVTpkzRmWeeqYMOOkiHHHKIrrvuOjU2Nuqss86SJJ1xxhkaMmSIpk+fLkm68MILddRRR+mHP/yhjj/+eM2ePVsLFy7UTTfd1Kn1Zv0Nf2FhoaZNm5Z1z0JlM/ZZ57HPOo991nnss85jn3Ue+6zz2GfoKqeeeqreeustXX755aqtrdX++++vBx98sPWLuStWrFCvXh89gHPYYYfp9ttv16WXXqpvfetbGjVqlO6++27ts88+nVpvXpLN+UoAAAAAMsIz/AAAAEAO44YfAAAAyGHc8AMAAAA5jBt+AAAAIIdl/Q3/jBkzNHz4cBUVFWn8+PF66qmnunuTssZjjz2mE044QVVVVcrLy9Pdd9/dpp4kiS6//HLtsssuKi4u1oQJE/Tyyy93z8ZmgenTp+vggw9Wv379NHjwYJ100klasmRJm9ds2rRJkyZN0sCBA9W3b1+dcsopW0148ffmxhtv1H777dc6IU1NTY0eeOCB1jr7LHbNNdcoLy9PF110Uevv2Gdbu+KKK5SXl9fmZ/To0a119tnWVq1apX//93/XwIEDVVxcrH333VcLFy5srfMZsLXhw4dv1c/y8vI0adIkSfQz5K6svuG/4447NGXKFE2bNk3PPPOMxo4dq4kTJ2rt2rXdvWlZobGxUWPHjtWMGTParX/ve9/T9ddfr5kzZ+rJJ59USUmJJk6cqE2bNnXxlmaH+fPna9KkSXriiSc0Z84cbdmyRccee6waGxtbX3PxxRfr3nvv1Z133qn58+dr9erVOvnkk7txq7vfrrvuqmuuuUaLFi3SwoULdcwxx+jEE0/UX/7yF0nss8jTTz+tn/70p9pvv/3a/J591r69995bb775ZuvP448/3lpjn7X1zjvv6PDDD1efPn30wAMP6MUXX9QPf/hD9e/fv/U1fAZs7emnn27Tx+bMmSNJ+sxnPiOJfoYclmSxQw45JJk0aVLr/zc3NydVVVXJ9OnTu3GrspOk5K677mr9/5aWlqSysjL5/ve/3/q7urq6pLCwMPl//+//dcMWZp+1a9cmkpL58+cnSfLB/unTp09y5513tr7mr3/9ayIpWbBgQXdtZlbq379/8rOf/Yx9FtiwYUMyatSoZM6cOclRRx2VXHjhhUmS0M/STJs2LRk7dmy7NfbZ1i655JLkiCOOSK3zGdAxF154YTJy5MikpaWFfoaclrUj/E1NTVq0aJEmTJjQ+rtevXppwoQJWrBgQTduWc+wbNky1dbWttl/ZWVlGj9+PPvv/9TX10uSBgwYIElatGiRtmzZ0mafjR49WkOHDmWf/Z/m5mbNnj1bjY2NqqmpYZ8FJk2apOOPP77NvpHoZ5GXX35ZVVVV2m233XT66adrxYoVkthn7fn973+vgw46SJ/5zGc0ePBgHXDAAbr55ptb63wGeE1NTfrVr36lL37xi8rLy6OfIadl7Q3/unXr1Nzc3Drz2IcqKipUW1vbTVvVc3y4j9h/7WtpadFFF12kww8/vHW2utraWhUUFKi8vLzNa9ln0vPPP6++ffuqsLBQX/7yl3XXXXdpzJgx7LMUs2fP1jPPPNM6NfrfYp+1b/z48brtttv04IMP6sYbb9SyZct05JFHasOGDeyzdrz22mu68cYbNWrUKD300EM6//zz9dWvflU///nPJfEZ0BF333236urq9IUvfEES5yZyW+/u3gCgO0yaNEkvvPBCm2eEkW7PPffU4sWLVV9fr//+7//WmWeeqfnz53f3ZmWllStX6sILL9ScOXNUVFTU3ZvTYxx33HGt/73ffvtp/PjxGjZsmH7zm9+ouLi4G7csO7W0tOiggw7S1VdfLUk64IAD9MILL2jmzJk688wzu3nreoZbbrlFxx13nKqqqrp7U4AdLmtH+HfeeWfl5+dv9e34NWvWqLKyspu2quf4cB+x/7Y2efJk/c///I8effRR7brrrq2/r6ysVFNTk+rq6tq8nn0mFRQUaPfdd9e4ceM0ffp0jR07Vj/+8Y/ZZ+1YtGiR1q5dqwMPPFC9e/dW7969NX/+fF1//fXq3bu3Kioq2GcdUF5erj322EOvvPIK/awdu+yyi8aMGdPmd3vttVfrY1B8BsRef/11PfzwwzrnnHNaf0c/Qy7L2hv+goICjRs3TnPnzm39XUtLi+bOnauamppu3LKeYcSIEaqsrGyz/xoaGvTkk0/+3e6/JEk0efJk3XXXXXrkkUc0YsSINvVx48apT58+bfbZkiVLtGLFir/bfZampaVFmzdvZp+145Of/KSef/55LV68uPXnoIMO0umnn9763+wzb+PGjXr11Ve1yy670M/acfjhh28VK7x06VINGzZMEp8BzqxZszR48GAdf/zxrb+jnyGndfe3hiOzZ89OCgsLk9tuuy158cUXk/POOy8pLy9Pamtru3vTssKGDRuSZ599Nnn22WcTScm1116bPPvss8nrr7+eJEmSXHPNNUl5eXlyzz33JH/+85+TE088MRkxYkTy3nvvdfOWd4/zzz8/KSsrS+bNm5e8+eabrT/vvvtu62u+/OUvJ0OHDk0eeeSRZOHChUlNTU1SU1PTjVvd/b75zW8m8+fPT5YtW5b8+c9/Tr75zW8meXl5yR/+8IckSdhnHfG3KT1Jwj5rz9e+9rVk3rx5ybJly5L//d//TSZMmJDsvPPOydq1a5MkYZ993FNPPZX07t07+c53vpO8/PLLya9//etkp512Sn71q1+1vobPgPY1NzcnQ4cOTS655JKtavQz5KqsvuFPkiT5yU9+kgwdOjQpKChIDjnkkOSJJ57o7k3KGo8++mgiaaufM888M0mSD2LZLrvssqSioiIpLCxMPvnJTyZLlizp3o3uRu3tK0nJrFmzWl/z3nvvJV/5yleS/v37JzvttFPyL//yL8mbb77ZfRudBb74xS8mw4YNSwoKCpJBgwYln/zkJ1tv9pOEfdYRH7/hZ59t7dRTT0122WWXpKCgIBkyZEhy6qmnJq+88kprnX22tXvvvTfZZ599ksLCwmT06NHJTTfd1KbOZ0D7HnrooURSu/uCfoZclZckSdItf1oAAAAAsMNl7TP8AAAAADLHDT8AAACQw7jhBwAAAHIYN/wAAABADuOGHwAAAMhh3PADAAAAOYwbfgAAACCHccMPAAAA5DBu+AEAAIAcxg0/AAAAkMO44QcAAAByGDf8AAAAQA77/wHiMmebVxw2ygAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ "for data in loader:\n", - " xm = data[\"xm\"]\n", " xp = data[\"xp\"]\n", - " ys, latents = [], []\n", - " for i in range(10):\n", - " y, latent = net(xm, xp[:, i], xm[:, i])\n", - " ys.append(y)\n", - " latents.append(latent[0])\n", - " for i in range(10):\n", - " for j in range(10):\n", - " if i != j:\n", - " print(i, j, ((latents[i][0]-latents[j][0])**2).mean())\n", - " else:\n", - " mse = 0.\n", - " for k in range(10):\n", - " mse += ((latents[i][0] - latents[i][k])**2).mean()\n", - " print(i, i, mse / 10)\n", + " print(xp.shape)\n", + " y, latent = net(xp.reshape(80, 1, 64, 64))\n", + " print(y.shape, latent.shape)\n", + "\n", + " latent = latent.clone().detach()\n", + "\n", + " distances = torch.cdist(latent.view(80, -1), latent.view(80, -1))\n", + "\n", + " # 距離の最大値で正規化し、距離が小さいほど赤くするために1から引く\n", + " normalized_distances = 1.0 - distances / distances.max()\n", + "\n", + " # ヒートマップの描画\n", + " plt.figure(figsize=(10, 8))\n", + " plt.imshow(normalized_distances, cmap='hot', interpolation='nearest')\n", + " plt.colorbar()\n", + " plt.title('Distance Heatmap')\n", + " plt.show()\n", + " \n", + " # 同じframeのlatentはどのくらい似ているか\n", + "\n", + " # for i in range(10):\n", + " # for j in range(10):\n", + " # if i != j:\n", + " # print(i, j, ((latents[i][0]-latents[j][0])**2).mean())\n", + " # else:\n", + " # mse = 0.\n", + " # for k in range(10):\n", + " # mse += ((latents[i][0] - latents[i][k])**2).mean()\n", + " # print(i, i, mse / 10)\n", " # for i in range(len(y)):\n", " # for j in range(len(y)):\n", " # if i == j:\n",