rnn_tutorial_jm.ipynb

   1 {
   2   "nbformat": 4,
   3   "nbformat_minor": 0,
   4   "metadata": {
   5     "colab": {
   6       "name": "rnn_tutorial_jm.ipynb",
   7       "provenance": [],
   8       "collapsed_sections": []
   9     },
  10     "kernelspec": {
  11       "name": "python3",
  12       "display_name": "Python 3"
  13     },
  14     "language_info": {
  15       "name": "python"
  16     }
  17   },
  18   "cells": [
  19     {
  20       "cell_type": "markdown",
  21       "metadata": {
  22         "id": "hEhvqXQBNN6r"
  23       },
  24       "source": [
  25         "# Understanding Simple Recurrent Neural Networks In Keras\n",
  26         "From https://machinelearningmastery.com/understanding-simple-recurrent-neural-networks-in-keras/ \n",
  27         "With changes by Jan Mandel\n",
  28         "2021-12-26: small changes for clarity\n",
  29         "2022-06-16: added same by functional interface"
  30       ]
  31     },
  32     {
  33       "cell_type": "markdown",
  34       "metadata": {
  35         "id": "pINycjukQijP"
  36       },
  37       "source": [
  38         "This tutorial is designed for anyone looking for an understanding of how recurrent neural networks (RNN) work and how to use them via the Keras deep learning library. While all the methods required for solving problems and building applications are provided by the Keras library, it is also important to gain an insight on how everything works. In this article, the computations taking place in the RNN model are shown step by step. Next, a complete end to end system for time series prediction is developed.\n",
  39         "\n",
  40         "After completing this tutorial, you will know:\n",
  41         "\n",
  42         "* The structure of RNN\n",
  43         "* How RNN computes the output when given an input\n",
  44         "* How to prepare data for a SimpleRNN in Keras\n",
  45         "* How to train a SimpleRNN model\n",
  46         "\n",
  47         "Let’s get started."
  48       ]
  49     },
  50     {
  51       "cell_type": "markdown",
  52       "metadata": {
  53         "id": "3D7sqhF-QtJ4"
  54       },
  55       "source": [
  56         "## Tutorial Overview\n",
  57         "\n",
  58         "This tutorial is divided into two parts; they are:\n",
  59         "\n",
  60         "1. The structure of the RNN\n",
  61         "  1. Different weights and biases associated with different layers of the RNN.\n",
  62         "  2. How computations are performed to compute the output when given an input.\n",
  63         "2. A complete application for time series prediction."
  64       ]
  65     },
  66     {
  67       "cell_type": "markdown",
  68       "metadata": {
  69         "id": "jU0opwkmQ9wm"
  70       },
  71       "source": [
  72         "## Prerequisites\n",
  73         "\n",
  74         "It is assumed that you have a basic understanding of RNNs before you start implementing them. An [Introduction To Recurrent Neural Networks And The Math That Powers Them](https://machinelearningmastery.com/an-introduction-to-recurrent-neural-networks-and-the-math-that-powers-them) gives you a quick overview of RNNs.\n",
  75         "\n",
  76         "Let’s now get right down to the implementation part."
  77       ]
  78     },
  79     {
  80       "cell_type": "markdown",
  81       "metadata": {
  82         "id": "-UcYCr1FMaE7"
  83       },
  84       "source": [
  85         "## Import section"
  86       ]
  87     },
  88     {
  89       "cell_type": "code",
  90       "metadata": {
  91         "id": "FimVgAB4LsI9"
  92       },
  93       "source": [
  94         "from pandas import read_csv\n",
  95         "import numpy as np\n",
  96         "from keras.models import Sequential\n",
  97         "from keras.layers import Dense, SimpleRNN\n",
  98         "from sklearn.preprocessing import MinMaxScaler\n",
  99         "from sklearn.metrics import mean_squared_error\n",
 100         "import math\n",
 101         "import matplotlib.pyplot as plt\n",
 102         "import tensorflow as tf"
 103       ],
 104       "execution_count": 19,
 105       "outputs": []
 106     },
 107     {
 108       "cell_type": "markdown",
 109       "metadata": {
 110         "id": "O-okDDv9Md4Z"
 111       },
 112       "source": [
 113         "## Keras SimpleRNN"
 114       ]
 115     },
 116     {
 117       "cell_type": "markdown",
 118       "metadata": {
 119         "id": "W-WQZp0qRta0"
 120       },
 121       "source": [
 122         "The function below returns a model that includes a SimpleRNN layer and a Dense layer for learning sequential data. The input_shape specifies the parameter (time_steps x features). We’ll simplify everything and use univariate data, i.e., one feature only; the time_steps are discussed below."
 123       ]
 124     },
 125     {
 126       "cell_type": "code",
 127       "source": [
 128         "api_type = 2   # 1 = sequential, 2 = functional"
 129       ],
 130       "metadata": {
 131         "id": "Qf35beQp1Ewv"
 132       },
 133       "execution_count": 20,
 134       "outputs": []
 135     },
 136     {
 137       "cell_type": "code",
 138       "metadata": {
 139         "id": "Aoh0LWQ7Ltdk"
 140       },
 141       "source": [
 142         "def create_RNN_sequential(hidden_units, dense_units, input_shape, activation):\n",
 143         "    model = Sequential()\n",
 144         "    model.add(SimpleRNN(hidden_units, input_shape=input_shape, \n",
 145         "                        activation=activation[0]))\n",
 146         "    model.add(Dense(units=dense_units, activation=activation[1]))\n",
 147         "    model.compile(loss='mean_squared_error', optimizer='adam')\n",
 148         "    return model"
 149       ],
 150       "execution_count": 21,
 151       "outputs": []
 152     },
 153     {
 154       "cell_type": "code",
 155       "source": [
 156         "def create_RNN_functional(hidden_units, dense_units, input_shape, activation):\n",
 157         "    inputs = tf.keras.Input(shape=input_shape)\n",
 158         "    x = tf.keras.layers.SimpleRNN(hidden_units, input_shape=input_shape,\n",
 159         "                        activation=activation[0])(inputs)\n",
 160         "    outputs = tf.keras.layers.Dense(dense_units, activation=activation[1])(x)\n",
 161         "    model = tf.keras.Model(inputs=inputs, outputs=outputs)\n",
 162         "    model.compile(loss='mean_squared_error', optimizer='adam')\n",
 163         "    return model"
 164       ],
 165       "metadata": {
 166         "id": "zBQxW0h8pvGb"
 167       },
 168       "execution_count": 22,
 169       "outputs": []
 170     },
 171     {
 172       "cell_type": "code",
 173       "source": [
 174         "def create_RNN(hidden_units, dense_units, input_shape, activation):\n",
 175         "    if api_type==1:\n",
 176         "      print('using sequential api')\n",
 177         "      return create_RNN_sequential(hidden_units, dense_units, input_shape, activation)\n",
 178         "    if api_type==2:\n",
 179         "      print('using functional api')\n",
 180         "      return create_RNN_functional(hidden_units, dense_units, input_shape, activation)\n",
 181         "    print('api_type must be 1 or 2, got ',api_type)\n",
 182         "    raise(ValueError)\n",
 183         "\n",
 184         "demo_model = create_RNN(hidden_units=2, dense_units=1, input_shape=(3,1), \n",
 185         "                        activation=['linear', 'linear'])"
 186       ],
 187       "metadata": {
 188         "id": "dYLai9HypVRo",
 189         "colab": {
 190           "base_uri": "https://localhost:8080/"
 191         },
 192         "outputId": "8b705753-6ffd-459b-b268-8a70b1de89df"
 193       },
 194       "execution_count": 23,
 195       "outputs": [
 196         {
 197           "output_type": "stream",
 198           "name": "stdout",
 199           "text": [
 200             "using functional api\n"
 201           ]
 202         }
 203       ]
 204     },
 205     {
 206       "cell_type": "markdown",
 207       "metadata": {
 208         "id": "_CZtOyDPSuMy"
 209       },
 210       "source": [
 211         "The object demo_model is returned with 2 hidden units created via a the SimpleRNN layer and 1 dense unit created via the Dense layer. The input_shape is set at 3×1 and a linear activation function is used in both layers for simplicity. Just to recall the linear activation function f(x)=x makes no change in the input."
 212       ]
 213     },
 214     {
 215       "cell_type": "code",
 216       "source": [
 217         "print(dir(demo_model))\n",
 218         "# help(demo_model)\n",
 219         "help(demo_model.get_weights)"
 220       ],
 221       "metadata": {
 222         "colab": {
 223           "base_uri": "https://localhost:8080/"
 224         },
 225         "id": "TgDQmxwQpUtw",
 226         "outputId": "3d1f7c71-d4a8-4fca-af48-46eb3ac23607"
 227       },
 228       "execution_count": 24,
 229       "outputs": [
 230         {
 231           "output_type": "stream",
 232           "name": "stdout",
 233           "text": [
 234             "['_SCALAR_UPRANKING_ON', '_TF_MODULE_IGNORED_PROPERTIES', '__call__', '__class__', '__copy__', '__deepcopy__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_activity_regularizer', '_add_trackable', '_add_trackable_child', '_add_variable_with_custom_getter', '_assert_compile_was_called', '_assert_weights_created', '_auto_track_sub_layers', '_autocast', '_autographed_call', '_base_model_initialized', '_build_input_shape', '_call_accepts_kwargs', '_call_arg_was_passed', '_call_fn_arg_defaults', '_call_fn_arg_positions', '_call_fn_args', '_call_full_argspec', '_callable_losses', '_cast_single_input', '_check_call_args', '_checkpoint_dependencies', '_clear_losses', '_cluster_coordinator', '_compile_was_called', '_compiled_trainable_state', '_compute_dtype', '_compute_dtype_object', '_compute_output_and_mask_jointly', '_compute_tensor_usage_count', '_configure_steps_per_execution', '_conform_to_reference_input', '_dedup_weights', '_default_training_arg', '_deferred_dependencies', '_delete_tracking', '_deserialization_dependencies', '_deserialize_from_proto', '_distribution_strategy', '_dtype', '_dtype_policy', '_dynamic', '_eager_losses', '_enable_dict_to_input_mapping', '_expects_mask_arg', '_expects_training_arg', '_feed_input_names', '_feed_input_shapes', '_feed_inputs', '_flatten', '_flatten_layers', '_flatten_modules', '_flatten_to_reference_inputs', '_functional_construction_call', '_gather_children_attribute', '_gather_saveables_for_checkpoint', '_get_call_arg_value', '_get_callback_model', '_get_cell_name', '_get_compile_args', '_get_existing_metric', '_get_input_masks', '_get_legacy_saved_model_children', '_get_node_attribute_at_index', '_get_optimizer', '_get_save_spec', '_get_trainable_state', '_graph_network_add_loss', '_graph_network_add_metric', '_handle_activity_regularization', '_handle_deferred_dependencies', '_handle_deferred_layer_dependencies', '_handle_weight_regularization', '_in_multi_worker_mode', '_inbound_nodes', '_inbound_nodes_value', '_infer_output_signature', '_init_batch_counters', '_init_call_fn_args', '_init_graph_network', '_init_set_name', '_initial_weights', '_input_coordinates', '_input_layers', '_input_spec', '_insert_layers', '_instrument_layer_creation', '_instrumented_keras_api', '_instrumented_keras_layer_class', '_instrumented_keras_model_class', '_is_compiled', '_is_graph_network', '_is_layer', '_is_model_for_instrumentation', '_jit_compile', '_keras_api_names', '_keras_api_names_v1', '_keras_tensor_symbolic_call', '_layer_call_argspecs', '_layer_checkpoint_dependencies', '_list_extra_dependencies_for_serialization', '_list_functions_for_serialization', '_lookup_dependency', '_losses', '_map_resources', '_maybe_build', '_maybe_cast_inputs', '_maybe_create_attribute', '_maybe_initialize_trackable', '_maybe_load_initial_epoch_from_ckpt', '_metrics', '_metrics_lock', '_must_restore_from_config', '_name', '_name_based_attribute_restore', '_name_based_restores', '_name_scope', '_nested_inputs', '_nested_outputs', '_network_nodes', '_no_dependency', '_nodes_by_depth', '_non_trainable_weights', '_obj_reference_counts', '_obj_reference_counts_dict', '_object_identifier', '_outbound_nodes', '_outbound_nodes_value', '_outer_name_scope', '_output_coordinates', '_output_layers', '_output_mask_cache', '_output_shape_cache', '_output_tensor_cache', '_predict_counter', '_preload_simple_restoration', '_preserve_input_structure_in_config', '_reset_compile_cache', '_restore_from_checkpoint_position', '_run_eagerly', '_run_internal_graph', '_saved_model_arg_spec', '_saved_model_inputs_spec', '_self_name_based_restores', '_self_saveable_object_factories', '_self_setattr_tracking', '_self_tracked_trackables', '_self_unconditional_checkpoint_dependencies', '_self_unconditional_deferred_dependencies', '_self_unconditional_dependency_names', '_self_update_uid', '_serialize_to_proto', '_set_call_arg_value', '_set_connectivity_metadata', '_set_dtype_policy', '_set_inputs', '_set_mask_keras_history_checked', '_set_mask_metadata', '_set_output_names', '_set_save_spec', '_set_trainable_state', '_set_training_mode', '_setattr_tracking', '_should_cast_single_input', '_should_compute_mask', '_should_eval', '_single_restoration_from_checkpoint_position', '_split_out_first_arg', '_stateful', '_steps_per_execution', '_supports_masking', '_symbolic_call', '_tensor_usage_count', '_test_counter', '_tf_api_names', '_tf_api_names_v1', '_thread_local', '_track_trackable', '_trackable_children', '_trackable_saved_model_saver', '_trackable_saver', '_tracking_metadata', '_train_counter', '_trainable', '_trainable_weights', '_training_state', '_unconditional_checkpoint_dependencies', '_unconditional_dependency_names', '_undeduplicated_weights', '_update_uid', '_updated_config', '_updates', '_use_input_spec_as_call_signature', '_validate_compile', '_validate_graph_inputs_and_outputs', '_validate_target_and_loss', 'activity_regularizer', 'add_loss', 'add_metric', 'add_update', 'add_variable', 'add_weight', 'apply', 'build', 'built', 'call', 'compile', 'compiled_loss', 'compiled_metrics', 'compute_dtype', 'compute_loss', 'compute_mask', 'compute_metrics', 'compute_output_shape', 'compute_output_signature', 'count_params', 'distribute_strategy', 'dtype', 'dtype_policy', 'dynamic', 'evaluate', 'evaluate_generator', 'finalize_state', 'fit', 'fit_generator', 'from_config', 'get_config', 'get_input_at', 'get_input_mask_at', 'get_input_shape_at', 'get_layer', 'get_losses_for', 'get_output_at', 'get_output_mask_at', 'get_output_shape_at', 'get_updates_for', 'get_weights', 'history', 'inbound_nodes', 'input', 'input_mask', 'input_names', 'input_shape', 'input_spec', 'inputs', 'layers', 'load_weights', 'loss', 'losses', 'make_predict_function', 'make_test_function', 'make_train_function', 'metrics', 'metrics_names', 'name', 'name_scope', 'non_trainable_variables', 'non_trainable_weights', 'optimizer', 'outbound_nodes', 'output', 'output_mask', 'output_names', 'output_shape', 'outputs', 'predict', 'predict_function', 'predict_generator', 'predict_on_batch', 'predict_step', 'reset_metrics', 'reset_states', 'run_eagerly', 'save', 'save_spec', 'save_weights', 'set_weights', 'state_updates', 'stateful', 'stop_training', 'submodules', 'summary', 'supports_masking', 'test_function', 'test_on_batch', 'test_step', 'to_json', 'to_yaml', 'train_function', 'train_on_batch', 'train_step', 'train_tf_function', 'trainable', 'trainable_variables', 'trainable_weights', 'updates', 'variable_dtype', 'variables', 'weights', 'with_name_scope']\n",
 235             "Help on method get_weights in module keras.engine.training:\n",
 236             "\n",
 237             "get_weights() method of keras.engine.functional.Functional instance\n",
 238             "    Retrieves the weights of the model.\n",
 239             "    \n",
 240             "    Returns:\n",
 241             "        A flat list of Numpy arrays.\n",
 242             "\n"
 243           ]
 244         }
 245       ]
 246     },
 247     {
 248       "cell_type": "markdown",
 249       "metadata": {
 250         "id": "BI0vVCjQTBPF"
 251       },
 252       "source": [
 253         "Look at the model following https://machinelearningmastery.com/visualize-deep-learning-neural-network-model-keras/ :"
 254       ]
 255     },
 256     {
 257       "cell_type": "code",
 258       "metadata": {
 259         "colab": {
 260           "base_uri": "https://localhost:8080/",
 261           "height": 584
 262         },
 263         "id": "Rdz2nblaTMV5",
 264         "outputId": "ca8ace50-487b-43e3-f983-a705ccfa88e2"
 265       },
 266       "source": [
 267         "print(demo_model.summary())\n",
 268         "from keras.utils.vis_utils import plot_model\n",
 269         "plot_model(demo_model, to_file='model_plot.png', \n",
 270         "           show_shapes=True, show_layer_names=True)"
 271       ],
 272       "execution_count": 25,
 273       "outputs": [
 274         {
 275           "output_type": "stream",
 276           "name": "stdout",
 277           "text": [
 278             "Model: \"model_2\"\n",
 279             "_________________________________________________________________\n",
 280             " Layer (type)                Output Shape              Param #   \n",
 281             "=================================================================\n",
 282             " input_3 (InputLayer)        [(None, 3, 1)]            0         \n",
 283             "                                                                 \n",
 284             " simple_rnn_2 (SimpleRNN)    (None, 2)                 8         \n",
 285             "                                                                 \n",
 286             " dense_2 (Dense)             (None, 1)                 3         \n",
 287             "                                                                 \n",
 288             "=================================================================\n",
 289             "Total params: 11\n",
 290             "Trainable params: 11\n",
 291             "Non-trainable params: 0\n",
 292             "_________________________________________________________________\n",
 293             "None\n"
 294           ]
 295         },
 296         {
 297           "output_type": "execute_result",
 298           "data": {
 299             "text/plain": [
 300               "<IPython.core.display.Image object>"
 301             ],
 302             "image/png": "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\n"
 303           },
 304           "metadata": {},
 305           "execution_count": 25
 306         }
 307       ]
 308     },
 309     {
 310       "cell_type": "markdown",
 311       "metadata": {
 312         "id": "6KMS82uNTZz4"
 313       },
 314       "source": [
 315         "If we have m\n",
 316         " hidden units (\n",
 317         "m\n",
 318         "=\n",
 319         "2\n",
 320         " in the above case), then:\n",
 321         "* Input: \n",
 322         "x\n",
 323         "∈\n",
 324         "R\n",
 325         "* Hidden unit: \n",
 326         "h\n",
 327         "∈\n",
 328         "R<sup>m</sup>\n",
 329         "* Weights for input units: \n",
 330         "w<sub>x</sub>\n",
 331         "∈\n",
 332         " R<sup>m</sup>\n",
 333         "* Weights for hidden units: \n",
 334         "w<sub>h</sub>\n",
 335         "∈\n",
 336         "R<sup>m x m</sup>\n",
 337         "* Bias for hidden units: \n",
 338         "b<sub>h</sub>\n",
 339         "∈\n",
 340         "R\n",
 341         "<sup>m</sup>\n",
 342         "*Weight for the dense layer: \n",
 343         "w<sub>y</sub>\n",
 344         "∈\n",
 345         "R\n",
 346         "<sup>m</sup>\n",
 347         "*Bias for the dense layer: \n",
 348         "b<sub>y</sub>\n",
 349         "∈\n",
 350         "R\n",
 351         "\n",
 352         "Let’s look at the above weights. The weights are generated randomly so they will be different every time. The important thing is to learn what the structure of each object being used looks like and how it interacts with others to produce the final output. The get_weights() method of the model object returns a list of arrays, which consists of the weights and the bias of each layer, in the order of the layers. The first layer's input takes two entries, the (external) input values and the values of the hidden variables from the previous step."
 353       ]
 354     },
 355     {
 356       "cell_type": "code",
 357       "metadata": {
 358         "colab": {
 359           "base_uri": "https://localhost:8080/"
 360         },
 361         "id": "f-C4rYMDL1_l",
 362         "outputId": "091b0a04-68e9-4814-b454-804125accf66"
 363       },
 364       "source": [
 365         "w = demo_model.get_weights()\n",
 366         "#print(len(w),' weight arrays:',w)\n",
 367         "wname=('wx','wh','bh','wy','by','wz','bz')\n",
 368         "for i in range(len(w)):\n",
 369         "  print(i,':',wname[i],'shape=',w[i].shape)\n",
 370         "\n",
 371         "wx = w[0]\n",
 372         "wh = w[1]\n",
 373         "bh = w[2]\n",
 374         "wy = w[3]\n",
 375         "by = w[4]"
 376       ],
 377       "execution_count": 26,
 378       "outputs": [
 379         {
 380           "output_type": "stream",
 381           "name": "stdout",
 382           "text": [
 383             "0 : wx shape= (1, 2)\n",
 384             "1 : wh shape= (2, 2)\n",
 385             "2 : bh shape= (2,)\n",
 386             "3 : wy shape= (2, 1)\n",
 387             "4 : by shape= (1,)\n"
 388           ]
 389         }
 390       ]
 391     },
 392     {
 393       "cell_type": "code",
 394       "source": [
 395         "# help(SimpleRNN)"
 396       ],
 397       "metadata": {
 398         "id": "kNzpNlwP4MSs"
 399       },
 400       "execution_count": 27,
 401       "outputs": []
 402     },
 403     {
 404       "cell_type": "markdown",
 405       "metadata": {
 406         "id": "oks2sHZlUQZB"
 407       },
 408       "source": [
 409         "Now let’s do a simple experiment to see how the layers from a SimpleRNN and Dense layer produce an output. Keep this figure in view.\n",
 410         "<img src=\"https://machinelearningmastery.com/wp-content/uploads/2021/09/rnnCode1.png\">"
 411       ]
 412     },
 413     {
 414       "cell_type": "markdown",
 415       "metadata": {
 416         "id": "eGi9cUkgUkTe"
 417       },
 418       "source": [
 419         "We’ll input x for three time steps and let the network generate an output. The values of the hidden units at time steps 1, 2 and 3 will be computed. \n",
 420         "h<sub>0</sub>\n",
 421         " is initialized to the zero vector. The output \n",
 422         "o<sub>3</sub>\n",
 423         " is computed from \n",
 424         "h<sub>3</sub>\n",
 425         " and \n",
 426         "w<sub>3</sub>\n",
 427         ". An activation function is linear, f(x)=x, so the update of $h(k)$ and the output $o(k)$ are given by"
 428       ]
 429     },
 430     {
 431       "cell_type": "markdown",
 432       "metadata": {
 433         "id": "QSD8ABJXxS7K"
 434       },
 435       "source": [
 436         "\\begin{align*}\n",
 437         "h\\left(  0\\right)  = &\\left[\n",
 438         "\\begin{array}\n",
 439         "[c]{c}%\n",
 440         "0\\\\\n",
 441         "0\n",
 442         "\\end{array}\n",
 443         "\\right]  \\\\\n",
 444         "h\\left(  k+1\\right)  =&x\\left(  k\\right)  \\left[\n",
 445         "\\begin{array}\n",
 446         "[c]{c}%\n",
 447         "w_{x,0}\\\\\n",
 448         "w_{x,1}%\n",
 449         "\\end{array}\n",
 450         "\\right]  +\\left[  h_{0}(k),h_{1}(k)\\right]  \\left[\n",
 451         "\\begin{array}\n",
 452         "[c]{cc}%\n",
 453         "w_{h,00} & w_{h,01}\\\\\n",
 454         "w_{h,10} & w_{h,11}%\n",
 455         "\\end{array}\n",
 456         "\\right]  +\\left[\n",
 457         "\\begin{array}\n",
 458         "[c]{c}%\n",
 459         "b_{h,0}\\\\\n",
 460         "b_{h,1}%\n",
 461         "\\end{array}\n",
 462         "\\right]  \\\\\n",
 463         "o(k+1)=& \\left[  h_{0}(k+1),h_{1}(k+1)\\right]  \\left[\n",
 464         "\\begin{array}\n",
 465         "[c]{c}%\n",
 466         "w_{y,0}\\\\\n",
 467         "w_{y,1}%\n",
 468         "\\end{array}\n",
 469         "\\right] \n",
 470         "\\end{align*}\n"
 471       ]
 472     },
 473     {
 474       "cell_type": "markdown",
 475       "metadata": {
 476         "id": "MAvXBZodx8RP"
 477       },
 478       "source": [
 479         "We compute this for $k=1,2,3$ and compare with the output of the model:"
 480       ]
 481     },
 482     {
 483       "cell_type": "code",
 484       "metadata": {
 485         "colab": {
 486           "base_uri": "https://localhost:8080/"
 487         },
 488         "id": "kMOhAImzL7Ch",
 489         "outputId": "46407729-6ebf-43e1-e3f1-881b7c442bbd"
 490       },
 491       "source": [
 492         "x = np.array([1, 2, 3])\n",
 493         "# Reshape the input to the required sample_size x time_steps x features \n",
 494         "x_input = np.reshape(x,(1, 3, 1))\n",
 495         "y_pred_model = demo_model.predict(x_input)\n",
 496         "\n",
 497         "\n",
 498         "m = 2\n",
 499         "h0 = np.zeros(m)\n",
 500         "h1 = np.dot(x[0], wx) + np.dot(h0,wh) + bh\n",
 501         "h2 = np.dot(x[1], wx) + np.dot(h1,wh) + bh\n",
 502         "h3 = np.dot(x[2], wx) + np.dot(h2,wh) + bh\n",
 503         "o3 = np.dot(h3, wy) + by\n",
 504         "\n",
 505         "print('h1 = ', h1,'h2 = ', h2,'h3 = ', h3)\n",
 506         "\n",
 507         "print(\"Prediction from network \", y_pred_model)\n",
 508         "print(\"Prediction from our computation \", o3)"
 509       ],
 510       "execution_count": 28,
 511       "outputs": [
 512         {
 513           "output_type": "stream",
 514           "name": "stdout",
 515           "text": [
 516             "h1 =  [[ 0.26658928 -0.22793353]] h2 =  [[ 0.21754729 -0.608839  ]] h3 =  [[ 0.15476518 -0.63926661]]\n",
 517             "Prediction from network  [[-0.837604]]\n",
 518             "Prediction from our computation  [[-0.83760395]]\n"
 519           ]
 520         }
 521       ]
 522     },
 523     {
 524       "cell_type": "markdown",
 525       "metadata": {
 526         "id": "JopR12ZaVAyS"
 527       },
 528       "source": [
 529         "The predictions came out the same! This confirms that we know what the network is doing."
 530       ]
 531     },
 532     {
 533       "cell_type": "markdown",
 534       "metadata": {
 535         "id": "dHGF-tofMpJP"
 536       },
 537       "source": [
 538         "## Step 1, 2: Reading Data and Splitting Into Train And Test"
 539       ]
 540     },
 541     {
 542       "cell_type": "markdown",
 543       "metadata": {
 544         "id": "5x748YZuY-yL"
 545       },
 546       "source": [
 547         "The following function reads the train and test data from a given URL and splits it into a given percentage of train and test data. It returns single dimensional arrays for train and test data after scaling the data between 0 and 1 using MinMaxScaler from scikit-learn."
 548       ]
 549     },
 550     {
 551       "cell_type": "code",
 552       "metadata": {
 553         "id": "JyrxUuiuL8gv"
 554       },
 555       "source": [
 556         "# Parameter split_percent defines the ratio of training examples\n",
 557         "def get_train_test(data, split_percent=0.8):\n",
 558         "    scaler = MinMaxScaler(feature_range=(0, 1))\n",
 559         "    data = scaler.fit_transform(data).flatten()\n",
 560         "    n = len(data)\n",
 561         "    # Point for splitting data into train and test\n",
 562         "    split = int(n*split_percent)\n",
 563         "    train_data = data[range(split)]\n",
 564         "    test_data = data[split:]\n",
 565         "    return train_data, test_data, data\n",
 566         "\n",
 567         "sunspots_url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/monthly-sunspots.csv'\n",
 568         "df = read_csv(sunspots_url, usecols=[1], engine='python')\n",
 569         "train_data, test_data, data = get_train_test(np.array(df.values.astype('float32')))"
 570       ],
 571       "execution_count": 29,
 572       "outputs": []
 573     },
 574     {
 575       "cell_type": "markdown",
 576       "metadata": {
 577         "id": "iCsHwJOcZMJ7"
 578       },
 579       "source": [
 580         "Let's print the data shape so that we know what we got."
 581       ]
 582     },
 583     {
 584       "cell_type": "code",
 585       "metadata": {
 586         "id": "h5AmHug8JViT",
 587         "colab": {
 588           "base_uri": "https://localhost:8080/"
 589         },
 590         "outputId": "46440946-97c3-43ef-f49b-ff0a94bc4283"
 591       },
 592       "source": [
 593         "data.shape"
 594       ],
 595       "execution_count": 30,
 596       "outputs": [
 597         {
 598           "output_type": "execute_result",
 599           "data": {
 600             "text/plain": [
 601               "(2820,)"
 602             ]
 603           },
 604           "metadata": {},
 605           "execution_count": 30
 606         }
 607       ]
 608     },
 609     {
 610       "cell_type": "markdown",
 611       "metadata": {
 612         "id": "QHoBV8CSMt44"
 613       },
 614       "source": [
 615         "## Step 3: Reshaping Data For Keras"
 616       ]
 617     },
 618     {
 619       "cell_type": "markdown",
 620       "metadata": {
 621         "id": "B1CW_mu8Zbwb"
 622       },
 623       "source": [
 624         "The next step is to prepare the data for Keras model training. The input array should be shaped as: **(total_samples, x time_steps, x features)**.\n",
 625         "There are many ways of preparing time series data for training. We’ll create input rows with non-overlapping time steps. An example is shown in the figure below. Here time_steps denotes the number of previous time steps to use for predicting the next value of the time series data. We have for time_steps = 2, features = 1, and the first 6 terms are split total_samples=3 samples: 0, 10 predict the next term 20, then 20, 30 predict the next term 40, etc."
 626       ]
 627     },
 628     {
 629       "cell_type": "markdown",
 630       "metadata": {
 631         "id": "OeEc_dmqZmtx"
 632       },
 633       "source": [
 634         "<img src=\"https://machinelearningmastery.com/wp-content/uploads/2021/09/rnnCode2.png\">"
 635       ]
 636     },
 637     {
 638       "cell_type": "markdown",
 639       "metadata": {
 640         "id": "iLqm8291Pd5X"
 641       },
 642       "source": [
 643         "The following function get_XY() takes a one dimensional array as input and converts it to the required input X and target Y arrays."
 644       ]
 645     },
 646     {
 647       "cell_type": "code",
 648       "metadata": {
 649         "id": "IxJEj52BL__o"
 650       },
 651       "source": [
 652         "# Prepare the input X and target Y\n",
 653         "def get_XY(dat, time_steps):\n",
 654         "    # Indices of target array\n",
 655         "    Y_ind = np.arange(time_steps, len(dat), time_steps)\n",
 656         "    Y = dat[Y_ind]\n",
 657         "    # Prepare X\n",
 658         "    rows_x = len(Y)\n",
 659         "    X = dat[range(time_steps*rows_x)]\n",
 660         "    X = np.reshape(X, (rows_x, time_steps, 1))    \n",
 661         "    return X, Y"
 662       ],
 663       "execution_count": 31,
 664       "outputs": []
 665     },
 666     {
 667       "cell_type": "markdown",
 668       "metadata": {
 669         "id": "RFhadJjzQO7p"
 670       },
 671       "source": [
 672         "For illustration, on the simple example above it returns the expected result: "
 673       ]
 674     },
 675     {
 676       "cell_type": "code",
 677       "metadata": {
 678         "id": "V38oXJ32QiFK",
 679         "colab": {
 680           "base_uri": "https://localhost:8080/"
 681         },
 682         "outputId": "f6394f51-15ba-4c73-d958-7f68c02cc4dd"
 683       },
 684       "source": [
 685         "dat = np.linspace(0.,70.,8).reshape(-1,1)\n",
 686         "print(\"dat shape=\",dat.shape)\n",
 687         "X, Y = get_XY(dat, 2)\n",
 688         "print(\"X shape=\",X.shape)\n",
 689         "print(\"Y shape=\",Y.shape)\n",
 690         "#print('dat=',dat)\n",
 691         "print('X=',X)\n",
 692         "print('Y=',Y)\n"
 693       ],
 694       "execution_count": 32,
 695       "outputs": [
 696         {
 697           "output_type": "stream",
 698           "name": "stdout",
 699           "text": [
 700             "dat shape= (8, 1)\n",
 701             "X shape= (3, 2, 1)\n",
 702             "Y shape= (3, 1)\n",
 703             "X= [[[ 0.]\n",
 704             "  [10.]]\n",
 705             "\n",
 706             " [[20.]\n",
 707             "  [30.]]\n",
 708             "\n",
 709             " [[40.]\n",
 710             "  [50.]]]\n",
 711             "Y= [[20.]\n",
 712             " [40.]\n",
 713             " [60.]]\n"
 714           ]
 715         }
 716       ]
 717     },
 718     {
 719       "cell_type": "markdown",
 720       "metadata": {
 721         "id": "4V4IE7TvQpDW"
 722       },
 723       "source": [
 724         "Now use it for the sunspot data.  We’ll use 12 time_steps for the sunspots dataset as the sunspots generally have a cycle of 12 months. You can experiment with other values of time_steps."
 725       ]
 726     },
 727     {
 728       "cell_type": "code",
 729       "metadata": {
 730         "id": "YBnBPDxiQsjL",
 731         "colab": {
 732           "base_uri": "https://localhost:8080/"
 733         },
 734         "outputId": "3386c1a5-f697-4aaf-f83f-bb4ebe29a3d8"
 735       },
 736       "source": [
 737         "time_steps = 24\n",
 738         "trainX, trainY = get_XY(train_data, time_steps)\n",
 739         "testX, testY = get_XY(test_data, time_steps)\n",
 740         "print(\"trainX shape=\",trainX.shape)\n",
 741         "print(\"trainY shape=\",trainY.shape)\n",
 742         "print(\"testX shape=\",testX.shape)\n",
 743         "print(\"testY shape=\",testY.shape)"
 744       ],
 745       "execution_count": 33,
 746       "outputs": [
 747         {
 748           "output_type": "stream",
 749           "name": "stdout",
 750           "text": [
 751             "trainX shape= (93, 24, 1)\n",
 752             "trainY shape= (93,)\n",
 753             "testX shape= (23, 24, 1)\n",
 754             "testY shape= (23,)\n"
 755           ]
 756         }
 757       ]
 758     },
 759     {
 760       "cell_type": "markdown",
 761       "metadata": {
 762         "id": "Xz2JRTGKMzo2"
 763       },
 764       "source": [
 765         "## Step 4: Create RNN Model And Train"
 766       ]
 767     },
 768     {
 769       "cell_type": "code",
 770       "metadata": {
 771         "id": "SyAE6XLnMGDO",
 772         "colab": {
 773           "base_uri": "https://localhost:8080/"
 774         },
 775         "outputId": "0a2820da-7343-4135-f191-e5d0639f3592"
 776       },
 777       "source": [
 778         "model = create_RNN(hidden_units=3, dense_units=1, input_shape=(time_steps,1), \n",
 779         "                   activation=['tanh', 'tanh'])\n",
 780         "model.fit(trainX, trainY, epochs=20, batch_size=1, verbose=2)"
 781       ],
 782       "execution_count": 34,
 783       "outputs": [
 784         {
 785           "output_type": "stream",
 786           "name": "stdout",
 787           "text": [
 788             "using functional api\n",
 789             "Epoch 1/20\n",
 790             "93/93 - 2s - loss: 0.0512 - 2s/epoch - 18ms/step\n",
 791             "Epoch 2/20\n",
 792             "93/93 - 1s - loss: 0.0248 - 537ms/epoch - 6ms/step\n",
 793             "Epoch 3/20\n",
 794             "93/93 - 0s - loss: 0.0191 - 476ms/epoch - 5ms/step\n",
 795             "Epoch 4/20\n",
 796             "93/93 - 0s - loss: 0.0172 - 484ms/epoch - 5ms/step\n",
 797             "Epoch 5/20\n",
 798             "93/93 - 1s - loss: 0.0156 - 518ms/epoch - 6ms/step\n",
 799             "Epoch 6/20\n",
 800             "93/93 - 0s - loss: 0.0144 - 400ms/epoch - 4ms/step\n",
 801             "Epoch 7/20\n",
 802             "93/93 - 0s - loss: 0.0131 - 308ms/epoch - 3ms/step\n",
 803             "Epoch 8/20\n",
 804             "93/93 - 0s - loss: 0.0121 - 352ms/epoch - 4ms/step\n",
 805             "Epoch 9/20\n",
 806             "93/93 - 0s - loss: 0.0110 - 298ms/epoch - 3ms/step\n",
 807             "Epoch 10/20\n",
 808             "93/93 - 0s - loss: 0.0098 - 310ms/epoch - 3ms/step\n",
 809             "Epoch 11/20\n",
 810             "93/93 - 0s - loss: 0.0088 - 309ms/epoch - 3ms/step\n",
 811             "Epoch 12/20\n",
 812             "93/93 - 0s - loss: 0.0077 - 325ms/epoch - 3ms/step\n",
 813             "Epoch 13/20\n",
 814             "93/93 - 0s - loss: 0.0070 - 306ms/epoch - 3ms/step\n",
 815             "Epoch 14/20\n",
 816             "93/93 - 0s - loss: 0.0068 - 317ms/epoch - 3ms/step\n",
 817             "Epoch 15/20\n",
 818             "93/93 - 0s - loss: 0.0066 - 340ms/epoch - 4ms/step\n",
 819             "Epoch 16/20\n",
 820             "93/93 - 0s - loss: 0.0065 - 336ms/epoch - 4ms/step\n",
 821             "Epoch 17/20\n",
 822             "93/93 - 0s - loss: 0.0063 - 296ms/epoch - 3ms/step\n",
 823             "Epoch 18/20\n",
 824             "93/93 - 0s - loss: 0.0065 - 308ms/epoch - 3ms/step\n",
 825             "Epoch 19/20\n",
 826             "93/93 - 0s - loss: 0.0064 - 302ms/epoch - 3ms/step\n",
 827             "Epoch 20/20\n",
 828             "93/93 - 0s - loss: 0.0063 - 318ms/epoch - 3ms/step\n"
 829           ]
 830         },
 831         {
 832           "output_type": "execute_result",
 833           "data": {
 834             "text/plain": [
 835               "<keras.callbacks.History at 0x7f884baf3410>"
 836             ]
 837           },
 838           "metadata": {},
 839           "execution_count": 34
 840         }
 841       ]
 842     },
 843     {
 844       "cell_type": "markdown",
 845       "metadata": {
 846         "id": "tluiPIaxM9FH"
 847       },
 848       "source": [
 849         "## Step 5: Compute And Print The Root Mean Square Error"
 850       ]
 851     },
 852     {
 853       "cell_type": "code",
 854       "metadata": {
 855         "id": "LnWdCmqJMK-k",
 856         "colab": {
 857           "base_uri": "https://localhost:8080/"
 858         },
 859         "outputId": "a461af63-187f-4610-cf9a-fb396adc34c6"
 860       },
 861       "source": [
 862         "def print_error(trainY, testY, train_predict, test_predict):    \n",
 863         "    # Error of predictions\n",
 864         "    train_rmse = math.sqrt(mean_squared_error(trainY, train_predict))\n",
 865         "    test_rmse = math.sqrt(mean_squared_error(testY, test_predict))\n",
 866         "    # Print RMSE\n",
 867         "    print('Train RMSE: %.3f RMSE' % (train_rmse))\n",
 868         "    print('Test RMSE: %.3f RMSE' % (test_rmse))    \n",
 869         "\n",
 870         "# make predictions\n",
 871         "train_predict = model.predict(trainX)\n",
 872         "test_predict = model.predict(testX)\n",
 873         "# Mean square error\n",
 874         "print_error(trainY, testY, train_predict, test_predict)"
 875       ],
 876       "execution_count": 35,
 877       "outputs": [
 878         {
 879           "output_type": "stream",
 880           "name": "stdout",
 881           "text": [
 882             "Train RMSE: 0.076 RMSE\n",
 883             "Test RMSE: 0.120 RMSE\n"
 884           ]
 885         }
 886       ]
 887     },
 888     {
 889       "cell_type": "markdown",
 890       "metadata": {
 891         "id": "eed7244NNHs9"
 892       },
 893       "source": [
 894         ""
 895       ]
 896     },
 897     {
 898       "cell_type": "markdown",
 899       "metadata": {
 900         "id": "nDwJvflyNGz3"
 901       },
 902       "source": [
 903         "## Step 6: View The result"
 904       ]
 905     },
 906     {
 907       "cell_type": "code",
 908       "metadata": {
 909         "id": "fQPjWHWvMMGL",
 910         "colab": {
 911           "base_uri": "https://localhost:8080/",
 912           "height": 444
 913         },
 914         "outputId": "7f7aeb05-df80-4c53-bfe6-910f83113e6d"
 915       },
 916       "source": [
 917         "# Plot the result\n",
 918         "def plot_result(trainY, testY, train_predict, test_predict):\n",
 919         "    actual = np.append(trainY, testY)\n",
 920         "    predictions = np.append(train_predict, test_predict)\n",
 921         "    rows = len(actual)\n",
 922         "    plt.figure(figsize=(15, 6), dpi=80)\n",
 923         "    plt.plot(range(rows), actual)\n",
 924         "    plt.plot(range(rows), predictions)\n",
 925         "    plt.axvline(x=len(trainY), color='r')\n",
 926         "    plt.legend(['Actual', 'Predictions'])\n",
 927         "    plt.xlabel('Observation number after given time steps')\n",
 928         "    plt.ylabel('Sunspots scaled')\n",
 929         "    plt.title('Actual and Predicted Values. The Red Line Separates The Training And Test Examples')\n",
 930         "plot_result(trainY, testY, train_predict, test_predict)"
 931       ],
 932       "execution_count": 36,
 933       "outputs": [
 934         {
 935           "output_type": "display_data",
 936           "data": {
 937             "text/plain": [
 938               "<Figure size 1200x480 with 1 Axes>"
 939             ],
 940             "image/png": "iVBORw0KGgoAAAANSUhEUgAAA98AAAGrCAYAAADZ3yROAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAMTQAADE0B0s6tTgAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeXxkVZn/8c9TSyp7L+l0A73YSNM9stmI4DKgqAhugKCOoyiiiKDjNjLqbxx1GJ2fouMoOjIsAw6KogioqD9XtFFREWSVtdmaprttOp3estV+fn+ceyuVSiWpJFWpSvJ9v171Sqpu1b2nbm33uc9zzjHnHCIiIiIiIiJSO5F6N0BERERERERkrlPwLSIiIiIiIlJjCr5FREREREREakzBt4iIiIiIiEiNKfgWERERERERqTEF3yIiIiIiIiI1puBbREREREREpMYUfIvIhMzsLDPbUoftbjGzs2Z6u2XacYuZXVB0vd/Mjp/hNvy7md1cw/WvNjNnZmtqtY1qC9p7Qr3bMZHpvHZmtip4vz2zys2SKpoN70Uzu9/M3jaJ+19qZlfUsk21YmYnmJmrdzvmknodB4jMNQq+RRqQmb09OJi7cJKPu8DMbqlVuxqNmW0ys2QQnOwxs9vN7NRab9c51+6cu7mS+wZtfGct22NmHzCzp82sqcyyV5hZxsyW17IN1WRmHwte0/DizGyo6PpPa7jt4m3tCk68HF+r7QXbHPNz65zbHLzfHq/h9iPBPn/YzPqC5327mb2xVtusploGvvV4L5rZcSXbzJlZuvi2qazXOXeoc+7rk7j/ec65mn53hczsJcG+/c4MbKsmr2mlJzCDz3uupA39ZvbVqT0jEZlNFHyLNKb3AL3AO8wsUe/GNLj3OufagW7ge8D1ZnZw6Z3Mi81462bG14F24PQyy94N/NA5t3VmmzR1zrnPBAFnO7AwuPmV4W3OuVfWuAknB9teDtwO3GhmHTXeZj19GHgH8AagE1gB/BOwu56NMrN4PbcP9XkvOud+V7T+duCPwGdKbisod9JtFgp/8043s2W13FADfL8A/LH49Qwu752B7YpInSn4FmkwZnY08FzgLcAC/AFx8fLFZvbfZvZEkKV6yMxOMrMzgI8BLyg6k36cmR0fnI2PFa1jRPmYmb3BzO4ws91mttPMfmhmB06izYeZ2a/MrMfM9prZn8zspUXLw4zA28zsnqDdt5rZIUX3aTezK82s18y2mtkHJrPfnHMZ4L+AGHBE0TbPNrN7gEHguWbWbGafMbPHguf7WzM7sqgdMTP7vJltD57PZ8s83xGZNjN7gZn9Oth3u8xsg5m1BBmUVcBXg9fj/qLHnBnsi73my0H/vmQbbzWzR4J99T2GDxLLPfc9wLfxgXbxOlYCrwb+e6LXqMxzHJWNNbOrzOybRdcXmtklZvZk8Lr9xIrKo83s74Lnti/YNzeNtb1peJaZ/T7Yv38xs2NL2jzufh6Pc24IuBIfkK6rdJ2Tee0mYiXZtPCza2bnmq+q2Gtm15lZZ9Fjxn1dyjgW+Ilz7l7nDTrnfuOc+0Wl6wzeG981syvMV6FsNrOPFC1vDtq5NdgvD5vZP5Q8101m9m9m9jMz6wPON7P9zezH5is7+szsXjN7Q9Fjws/Uj6woa2lmUTM738weDPbRHWb2sqLHPdvMfhO0dXewfB3TU7P3Ysl6bjazr5rZd8xsN/CVSezfdwb/V/KdXPp532Rmnwxe+z7z36GnFS03M/s/wWu/J3gvfNfMrprg+ewPvBZ4H7ALOKdk+QXmK1D+1cz+av479jIb+Zt2lPnvtH4z+zNwxBR2bbiu5wX7uDd4v3863JaZNZn//d0e7INNZva+4KHhe/GeoB2XTnH7bwm2vTq43mxmd1qQGZ/oMxHcx5mviPqjmQ0Er/Hh5n/rHzb/nXy9mbUXPSb8/P06aP99ZnbSOO2sx2dMZPZzzumiiy4NdAH+F7gr+P87wB+KlhnwW+An+KDOgGcChwTLLwBuKVnf8YADYkW3nQVsKbr+CuDZQBRYAvwIf2a+7P3LtPkw4OVAC5AI2rEXWBosXx204SZgf6AZuB74TdE6LgfuxGfd2oL9kAXOGme7m4B3Bv8n8Ccf0sBBRdv8PbAyeG4J4KqgHSvwgfp7gR3AwmA9HwvWe0hw/08DGeCCou064ITg/0OBIeAfgFagKdjnidI2luzPzfiTLBF88LMPODZY/sJgmycHbTw52MbN4+yL5wTtOqTotk8BD03yNVozznvpKuCbRe/FDcC3gMXBOj8HPADEg32RBl4a3L85/H+Sn4dY0K7jyyxzwD3AmuB+FwFPVrqfx9he8WvbBnwl2PdLavjajdrXRctKX5ez8J+LLwWv5f7AI8C/VfK6jLGN84P3wifw793OkuUTrjN4b2SAc4PX//n4QOqMYHkL8Hb8iYgI/qRQCjip5PO8HXhBsM1W/Of0dHxlRxw4O9jOoeVes5J9ejf+pEkEOA0YAA4Klv8e+GTwGsWA9cCyRnovFj32FkZ+/9wcPJdXBetqncT+Db8vVzPxd/JVBJ/3osdvxn/XRIAPBc+hM1h+Jj57/bxgH4Sv1VUTPL9/BZ4OXt8Lg21ES17LDL4aowlYG7y33h4s7wR68N/VCfx396OAm+z3S/B+6Qf+Plj2jOB1/Zdg+TnAXQx/H+wHPKfcZ3Uqn/ei+1wM/Dl4PlcCtwJNwbJKPxN3AQcG++y7wGP439UOYFlw/Z9LXt8e4G+LXr8UcGDRe3hLyfOo6mdMF13mw6XuDdBFF12GL8AifIb23cH1lwY/os8Orj8XyAPdYzx+1I86FQTfZdZzZPCYjkruP8Y69uDLd4sPSl5UtPzVwGDwfwRIhvcPblsQPNezxtnGpmB/7cEH0LcAry7ZZvHBZ1dw27qS9TwCvKXo//cVLYsG676g6LbiAO2rwI8naGNp8H0vcG7Jbf8DXFH0/w0ly29gnAAuuM+twFeC/2PANuADk3yNKg2+n4MPrttL9tUQPrBoxR+I/QPBgeoUPxMTBTxnFl0/NLhtWSX7eYztOfzB997g/x7gFbV87crt66Jlpa/LWfjPSrzoPv8B/LSS12WMbRjwJuCHwfPN4oOyQypdZ/DeuKNkvZ8DfjXO874R+M+Sz8pnK3hP3MPIz2i54HsvRZ/94LZfAh8P/t8AXEEQKDTie7HofuWC729X8Lhy+7c0+C77nVz0mpYG358sut4WrON5wfWbgM+XtOHPjBN8B++jLcDngusH4b/3Ty35fDxe8rjrgEuC/8/AB+/FAfv7mFrw/ZXSfRus/9Hg/7fhfyNeRMnJLCYXfGfx37/Fl7cX3acJ393gTvzvz4opfCbeWnT91OC2/Ytu+y/g+yWv73+WrPdPwCeC/89iZPBd9c+YLrrMh4vKzkUay9vxP5DfCq5vwJ/Bf09w/UBgt3Oup5obNbMXmy9J/quZ7QN+EyxaWuHjVwUlkJuDcrY9+GxE6eO3Ff0/ALQE5Xzd+DP8T4QLnXN78dmNibzfObfQObfUOXesc+7/lSx/ouj/cCCcPwWlcHuCti7HZxMI/ha3I4fPxIzlQODhCtpZ7GDgP0va8CbggHJtKPM8xnIJ8FYza8UfbC3A9wefzGs0mecQA7YUPYfeYNlK59wgvqLiBOBh82W4k+pKUKHS9xT4zE7YxvH281he65xbgM96bcJnYkO1eu0mY6fz3SxCA4x8zmO+LuVW5rxvO+dOcc5140t2I8D/MzObxDrLPe+VAGaWMLMvmNnGoER1D/BKRr//RqzDzBaZ2f+Y72YTvm8PLfO44scsw7+3ryt5nV6I/6yDDyQc8GvzZfwXFZfgTlEt3otjKd1Ple7fidocfidPeH/nXOlzXA48WXL/TRNs/1T8PrgiWOdj+N+995Tcb1vJ9eL3/ArgqeC7OjTVz9zBwGklr9Ml+Aw3wDeBy/AnvHaa2U/N7KgpbOfW4Her+PK/4ULnXBofHB+JP0FT3E2s0s/EX4v+HwjWW3pb6VgWY36Gi9XxMyYy683VwYdEZp3gIPc8/Bnvjf4q4AOoM8zsw/gDmUVmtsQ5t7PMavJlbusL/rbhz1RD0QGf+cF6fowvUX6tc67PfB/oO/EZsUr8T7Duo51zTwfPZfckHt+DL29bDdwXtGsBvhJguor3yfbg7xHOubEC6i1BOwjaEWWMoCWwCV8GWcn2i9vxr865b1TShkDp9XKuBf4Tf1D/JnwGZ0+wbLKvUR/+PVPsAHwWJnwOaXwVRoYynHO/A34XbOvFwM/M7AHn3C8reC7VMNF+HpdzbrOZnQncbWY/cM7dVcE6p/raVcuEr8tEnHMPmNmX8JnwRZNY5+oy18Og4UP4EvyTgUecc3kzu5HR77/Sz8uFwN/g3z9POeec+TEcih/nSh6zB18d8Brn3G/HeI5PEvQtNt+f/kZ8MPIv4zy/6ZjWe7GM0v1U6f6tpa34E1bFnsFwX+hywiD7d0W/ee1Aq5mtcc49WsF2twArzSxaFICvrqzJo2wHrnHOvaPcwmD9XwC+EASSn8K/d1ZQ/rt+SsxsFfBlfGXVB8zsBufcHcHiSj4TU7W6zPWflLlfI37GRGYFZb5FGsfL8WfdT8T3jQov4cAxb8OX8P0B+F8zWwFgZgea2bOC+2wHVplZc9F6N+IDqXPNTym0HnhX0fImfH/B3UHgfQDw75Ns+wJ8qe5uM2sDPos/gKqIcy6PzyhcYGbLg3X8J6MPqqclOBj4AXCxmT0DwMw6zOyV5gf9AZ8pPt/M/sb8SPOfxPdzHcslwMvN7Dzzg6zFzVcShKPUb6dosK7ARcAnzOzo4DVJBP+HGZSvA6eY2avND2rzanz/zomeXxLfp+9f8F0W/rto8WRfoz8Dh5vZsUEb3oAvtQzdgj9RcomZLYVCRuZ1ZtZqZvuZH9xnoXPO4Q/WHL7ccqZMtJ8n5Jx7ED+Y3ecrXOeUXjv8+bfmkstUTpCP+7qMseHzg/YuDq6vwgdF9zvndk1inc82s3eaH7TwGPyBd5jNW4A/wdYDRIL304kVPJ8F+K4lvUDc/OBWh5bcZ8RnzDmXAi4FPm9mzzKvxcxeZGZrg/afZWYrghND+/Dvy1q+N6f9XpzAVPdvNV2Nn6Hj6OA98Hb8b1hZwWvxUnyGtPg3by0+oH73WI8t8WN8+fong/36N8BUq2z+G3h98N3VFHyG15jZK4I2v9TMnmv+pHUS/50aBvw9+AB8WoOKBb8d1wPXOefeh/89vj78fFLZZ2KqzjQ/gGjMzM7CZ96/VXqnBv2MicwKCr5FGse7gZuccxucc9uLLo/gS/LeHQQxp+LLyf5ofkTgnzCcmb0WXwK9zXwZ2LHOuT584P4u/A/gZ/GDmwHgnOsH3gl83Pz8sT/F96ebjPfjB2zbjR+EaSvDGa9K/SPwl+CyMfi7fdxHTM2bgTuAXwb772F8kBBmDT6Hn7LsN/jn0ITv91aWc+4+fGn1m/ClkU/jA/bw+/VTwKnB63Fv8Jgv4/v9XYovrd+KL2NsC5bfgn+9vowPWs8Gvlbh87sEn624zTl3Z9Htk3qNnHO/AT6D3xc9+LEDbihansOfMBrEl/H34fsdnoYPssNKjseD99X1+EGLNgCY2aVWw/m6gzaOu58n4VPA8WZ2Yg1fuxfi+1AXXy6YZDsreV3K2Qv8M/BI8Fr9AdgJvGaS6/w+fqC1nfj3yhfwJ9UI/n8KX5a8DXgZ/kTYRD6OPzn4NL7KZBl+IKdi/wx8NPiM/Ti47Z/wJ02uw78Om4L7hdOXvQS4DR883YPvX/u5CtozJVV8L45lqvu3mr6BHwjwe/j3wLH4wDg5xv3fje8//c2S37xtwBeBs8ysZaKNBl2UXhVcevHvuUum8gScc7fj3+vn4F+jXvx3V5jRX4rvC78L/734YuD1wWOH8AN2hiP+/zdjK56VJLz8KFj2Zfzn6oPB9QvxYwZ8MwhkK/lMTNWlwP/Ff2Y+DJwWdAUop6E+YyKzhfljeREREZGpMT+dVMw595Z6t0Uah5ndDVzrnBs1ZaM0FjPbBPy7c+6KerdFZC5T5ltEREREps3M3hiUHzeb2T/ip/2abCWViMicpeBbRERERKrhHHx3oR7gLfgpwyoZNE1EZF5Q2bmIiIiIiIhIjSnzLSIiIiIiIlJjCr5FREREREREamwqc4g2lEQi4bq7u+vdDBERERGR2evpp/3fZcvq2w6RWWLr1q1p51xiMo+Z9cF3d3c3W7ZMdjphEREREREpOPRQ//f+++vbDpFZwsx6JvsYlZ2LiIiIiIiI1JiCbxEREREREZEaU/AtIiIiIiIiUmOzvs+3iIiIiIjIXJLP53HO1bsZ85qZEYlUN1et4FtERERERKQBpNNpNm/eTCaTqXdTBIjH46xatYqmpqaqrE/Bt4iIiIiISAPYvHkzHR0ddHV1YWb1bs685pyjt7eXzZs3s2bNmqqsU8G3iIiIiIhIneXzeTKZDF1dXcRiCtMaQVdXF7t27SKfz1elBF0DromIiIiIiNRZ2MdbGe/GEb4W1ep/r+BbREREREREpMYUfIuIiIiIiMiY+vr6aG9v5+yzz57wvjfffDM/+9nPpr3NTZs2sXDhwmmvp5Eo+BYREREREZExXXvttRx11FF873vfo7+/f9z7Viv4novUk19ERERERKQBvfPrt/Nk72BN1v2MrlaueNvRFd33yiuv5BOf+ASXXXYZ1157LWeffTZ79+7l/PPP59ZbbyUajXLUUUfx/ve/n0svvZRcLsfNN9/M6aefzplnnsn69evZs2cPAP39/XR0dBT6UZ9xxhk8/PDDpNNpVq5cyZVXXsl+++1Xk+dcbwq+RUREREREpKwHHniAp556ipNOOolsNsuFF17I2WefzQc/+EFaWlq49957iUQi9PT00N3dzXnnnceePXu46KKLAF8+Pp6LLrqI7u5uAC688EIuuOACLr300lo/rbpQ8C0iIiIiItKAKs1M19KVV17JmWeeSTQa5VWvehXnnnsuDz74ID/+8Y/505/+VJiCKwygJ+uaa67h6quvJplMkkwmWbJkSTWb31DU51tERERERGQCD23fx3Gf/zWbdg7UuykzJpPJcPXVV/P1r3+d1atXs2bNGgYHB7nyyisrXkcsFiOXyxWuJ5PJwv+33HILX/nKV/jJT37Cfffdxxe/+MURy+caBd8iIiIiIiIT+NPju3hq1xD3b9tX76bMmB/+8Ic885nPZOvWrWzatIlNmzZx6623cvXVV3PKKafwhS98gXw+D0BPTw8AnZ2d7N27t7CO/fbbD+ccDzzwAADf+MY3Cst2795NR0cHXV1dpNNpLrvsshl8djNPwbeIiIiIiMgEdvT5jGwqm5vgnnPHlVdeyRlnnDHitmc961ksX76cF7/4xaRSKQ4//HDWr1/Pxz72MQBOO+007r77btavX8+nPvUpYrEY//Vf/8VrXvMajj76aDKZTGFdr3jFK1i3bh3r1q3juOOOY/369TP6/GaahaPMzVYrVqxwW7ZsqXczRERERERmr0MP9X/vv7++7WhgH7n+Hr775y189vTDedMxq6q+/lwux8aNG1m7di3RaLTq65fJG+81MbOtzrkVk1mfMt8iIiIiIiIT6OlLAZDKzJ/Mt1SXgm8REREREZEJ7AiD72y+zi2R2UrBt4iIiIiIyAR6FHzLNCn4FhERERERGUcu79jZHwbfKjuXqVHwLSIiIiIiMo5dA2nywTjVqYwy3zI1Cr5FRERERETGEZacg8rOZeoUfIuIiIiIiIwjnOMb5l/Z+erVq1m3bh3r16/nkEMO4eKLL57W+u677z5Wr14NwLZt2zjuuOMmfMxFF13E9u3bC9cvvfRS/uM//mNa7aiHWL0bICIiIiIi0sjme+b72muvZf369Tz55JMcccQRHHfccRxxxBEA5PN+f0Qik8/rHnDAAfzud7+b8H4XXXQRxx9/PPvttx8A55133qS31QiU+RYRERERERlHT39R8D2P+3w/4xnPYN26dbz5zW/mda97HSeddBKHHXYYf/3rX/n5z3/Osccey1FHHcUxxxzDhg0bCo+74IILOPjggznqqKP4zne+U7h906ZNLFy4sHD9j3/8I8ceeyzPfvazOeKII7jxxhv51Kc+xbZt23jjG9/I+vXrufvuu7ngggv44Ac/CEAul+PDH/4whx12GIcddhjve9/7SKfTAJx11lmce+65vOxlL2Pt2rWcfvrphWU/+tGPOOKII1i/fj2HHXYYN954Y833nzLfIiIiIiIi49ixrzjzPYNl59f8Pex+ojbrXnQgvPk7E9+vyF/+8hceeughTj75ZDZs2MBdd93FsmXLePzxx7ngggv4+c9/TmdnJ48++ijHHXccmzZt4qabbuK6667jjjvuoKOjg7e+9a1l171r1y5e+9rXcv3113PccceRz+fZs2cPp556Kl/72tcK2XeAH/zgB4XHXX755dx+++3ccccdRKNRTjnlFL70pS/x0Y9+FIC7776bDRs2kEgkeNGLXsQNN9zAm970Jj7+8Y9z2WWX8YIXvIB8Ps++ffumuCMrp+BbRERERERkHGHmu7UpOi/Lzt/4xjfS0tJCa2srX/va17jvvvtoaWlh2bJlAPzsZz/j0Ucf5UUvelHhMZFIhM2bN/OrX/2Kv/u7v6OzsxOAc889l1tuuWXUNv74xz+ybt26Qh/wSCTC4sWLJ2zbTTfdxFlnnUUikQDgnHPO4eKLLy4E36eddhqtra0AHHPMMTz22GMAvOxlL+MDH/gAr3/96znxxBMLgX0tKfgWEREREREZR09fikWtceLRyMwG35PMTNdKcdYZ/KBp7e3thevOOV7+8pdzzTXXTLguM6tJG8daf3Nzc+H/aDRKNpsF4Itf/CL3338/GzZs4G1vextnnHEGH/nIR2raNvX5FhERERERGUdPX4qlHc0k4pF5N9p5JU466SRuuukm7r333sJtt912GwAnnHAC1113HX19fTjnuPzyy8uu44UvfCGPPPJIYQC2fD7Prl27AOjs7GTv3r1lH3fCCSfwjW98g3Q6TTab5YorruDEE0+csM0PPfQQhx56KO9973t597vfza233jqp5zwVynyLiIiIiIiMo6cvxfqVC9m+z83rAdfGsmbNGq655hrOPfdcBgcHSafTHHnkkVxzzTW86lWv4rbbbuM5z3kOnZ2dvPKVryy7jkWLFvH973+f888/n76+PiKRCJ/+9Kc5+eSTef/7388555xDa2srV1111YjHvetd7+Kxxx7jOc95DgDHH398YTC28XzsYx/j4YcfpqmpidbWVi655JJp74eJmHOuthswOxj4OrAE2Auc5Zy7v+Q+EeALwCuALNALnOOce3Si9a9YscJt2bKl6u0WEREREZk3Dj3U/73//vHvNw8NprMc8smfc9qRy9n4dB99ySy//chLqr6dXC7Hxo0bWbt2LdFotOrrl8kb7zUxs63OuRWTWd9MlJ1fBlzunFsLfA64qsx9TgH+Fni2c+4I4FfAZ2agbSIiIiIiImMK5/he2pEgEVPZuUxdTYNvM1sKPBf4ZnDTDcBKM1tTclcHJIBm8z3kOwGls0VEREREpK7C4Lu7I0EiNj9HO5fqqHWf75XAX51zWQDnnDOzzcAqoLik/EfAS4DtQB+wFXhxjdsmIiIiIiIyrh3FwXc8oj7fMmWNMtr5c4HDgOXAAfiy80vL3dHMPmRmW8JLf3//DDZTRERERETmk5GZb192Xotxs8Ipsmo9JpdULnwtqjU9Wq0z308B+5tZzDmXDUrKVwGbS+53JvBr59weADP7OvCLcit0zn0R+GJ4fcWKFXp3ioiIiIhITYzs8x0l7yCbd8Sj1Z2vOhKJEI/H6e3tpaurq+bzYcv4nHP09vYSj8eJRKqTs65p8O2c22FmdwJvwQ+09jpgS5lRzB8HXmVmX3DOpYHXAPfVsm0iIiIiIiIT2dGXBKC7vZlEzAdhqWyeeLT6RcSrVq1i8+bNhfmtpb7i8TirVq2q2vpmYp7vc4GrzOxjwD7g7QBmdgXwQ+fcD4GLgWcB95hZBt/3+7wZaJuIiIiIiMiYevpSNMUidLbESMSD4DuToz1R/VCqqamJNWvWkM/nVX5eZ2ZWtYx3qObBt3PuYeAFZW5/Z9H/KeCcWrdFRERERERkMnr6U3S3JzAzEjE/13OtRzyvdtAnjUGvqoiIiIiIyBh27EvR3ZEAGFF2LjJZCr5FRERERETKyOUdvQNplhaC7zDznatns2SWUvAtIiIiIiJSxu7BNLm8G858F/p8K/Mtk6fgW0REREREpIwd+8JpxpoBlZ3L9Cj4FhERERERKaOn3wff3So7lypQ8C0iIiIiIlJGT19p8K2yc5k6Bd8iIiIiIiJl7OhLAgwPuBZX2blMnYJvERERERGRMkZnvlV2LlOn4FtERERERKSMHUHwvaRd83zL9Cn4FhERERERKaOnL8Wi1jhNQdA93OdbmW+ZPAXfIiIiIiIiZezsSxVKzgES8bDsXJlvmTwF3yIiIiIiImXsKA2+VXYu06DgW0REREREpMRgOkt/KsvSjubCbcPBt8rOZfIUfIuIiIiIiJTY2ZcGKF92rnm+ZQoUfIuIiIiIiJQoneMbVHYu06PgW0REREREpETpHN+gsnOZHgXfIiJSNdv3Jvnqrx8hn3f1boqIiMi09PQHwXd7cfCt0c5l6hR8i4hI1fzg7q184RcbuXvLnno3RUREZFp27PPB99LO4eA7HjXM1OdbpkbBt4iIVM1Q2pfh7R3K1LklIiIi01MoO28fHu3czEjEIio7lylR8C0iIlWTzvlMwD4F3yIiMsv19KdoikXobImNuD0Ri6rsXKZEwbeIiFRNOjgY2ZfM1rklIiIi07OjL0l3ewIzG3G7z3wr+JbJU/AtIiJVEwbffUllvkVEZHbr6UuNGOk8lIir7FymRsG3iIhUTXgwsm9ImW8REZm9cnnHzv50+eA7FtWAazIlCr5FRKRqhsvOlfkWEZHZa/dgmlzesbRs8K2yc5kaBd8iIlI1GnBNRETmgsJI52MG3yo7l8lT8C0iIlWjAddERGQu2BEE30s7mkct02jnMlUKvkVEpGrCg4sJJbIAACAASURBVBFlvkVEZDYbN/Mdj6jPt0yJgm8REaka9fkWEZG5oJKyc+fcTDdLZjkF3yIiUjXDfb5Vdi4iIrPXjr4kwBgDrkXJO8jmFXzL5Cj4FhGRqtE83yIiMheEme+u9qZRyxIxH0Kp37dMloJvERGpmjD4TmXzJDMaCVZERGannr4UC1vjJGLRUcsS8SD41u+cTJKCbxERqZqw7BygTyOei4jILNXTlypbcg4UAnJlvmWyFHyLiEjVpIsORDTomoiIzFY9famyg62Bys5l6hR8i4hI1YwIvjXdmIiIzEJD6Rx9qSzd7RNlvlV2LpOj4FtERKpmZOZbZeciIjL7hIOtLe1sLrt8uM+3Mt8yOQq+RUSkalI5Zb5FRGR26+n304yNnflW2blMjYJvERGpCucc6WyejkQMUJ9vERGZnXbsCzPfKjuX6lLwLSIiVRGOdL4kGKBGo52LiMhs1NPvg+8JM98qO5dJUvAtIiJVEfb3XtLeBKjsXEREZqewz/eYo53HVXYuU6PgW0REqmI4+PYHKyo7FxGR2ahQdt4xxoBrKjuXKVLwLSIiVVEoOw+D7yGVnYuIyOzT05+iKRqhsyVWdrkGXJOpUvAtIiJVEWa+WxNRmuMRZb5FRGRW6ulL0d2RwMzKLh/u863Mt0yOgm8REamKMPhORCN0NsfV51tERGalHX3JMft7AyTiYdm5Mt8yOQq+RUSkKsKDkKZYhM6WOPs02rmIiMwy+bxjZ396/OBbZecyRQq+RUSkKsI+302xCJ3NMfpUdi4iIrPM7sE0ubyrMPhW2blMjoJvERGpirDs3A9SE9eAayIiMuvs6AtHOq+g7FzzfMskKfgWEZGqKPT5jkfpbI4zlMkVbhMREZkNJprjG1R2LlOn4FtERKpiZObbT8+i0nMREZlNwsx3d7vKzqX6FHyLiEhVjOzzHQfQoGsiIjKrhJnvpZ3NY94nEdNo5+N57zV38t5r7qx3MxpS+ZnjRUREJildNNp5Rxh8a7oxERGZRSopO49HDTP1+R7LvVv2ktQc6GUp8y0iIlURlt/5qcb8ud19KjsXEZFZZEdfEoAl7U1j3sfMSMQiKjsfQzKTY2d/ilze1bspDUfBt4iIVEVhwLVoUdm5RjwXEZFZZO9QhramaKG0fCyJWFRl52NIZfPkHewaSNe7KQ1HwbeIiFRFqqjsvLPFB98acE1ERGaTZCZHS9P4gTcQZL4VfJcTlpyHJfwyTH2+RUSkKooHXItGDFDZuYiIzC7JTH7CrDdAIq6y83Kcc4WTEj39Cr5LKfgWEZGqKB5wLR71hVUqOxcRkdkkmcnRHJ+4ODgRi2rAtTKKqwF27EvWsSWNSWXnIiJSFSPm+S5MNabMt4iIzB7JbI7muMrOp6p4nyjzPZqCbxERqYqRU40Fo51rqjEREZlFkpn8JIJvlZ2XShVNMaY+36Mp+BYRkaoo7vPdHI/SFIuwL6mycxERmT0mVXauzPcoIzLfCr5HUfAtIiJVMTzVmM8YdDbHlfkWEZFZJZXJ01zpgGvq8z1KsijzvUPB9ygKvkVEpCqKy84BOlti6vMtIiKzRi7vSOcmV3bunJuBls0exZnvnQq+R1HwLSIiVZHKlQTfzXH6VHYuIiKzRNiHO1Fh2XneQTav4LtYUn2+x6XgW0REqiKdzROLWGGO784WlZ2LiMjskQzKyCvNfAPq912ieH/0pbIMpTUoXTEF3yIiUhXpbL6Q9QbobI4xkM6RzTXugUkml+eH92wjp8yFiMi8F2ZtK+3zDSNH95bhfdjV1gQo+11KwbeIiFTFqOC7xc/13cil57+4/2ne/+27uPnhHfVuioiI1Fkh+K6w7ByU+S4V7o8Vi1oA6OlP1rM5DUfBt4iIVEUqm6MpOvyzUpjru4EHXesd8Gfke/vTdW6JiIjUm8rOpy88gbFicSugzHcpBd8iIlIV6Vxp2bnPfO8batzMd3/Kt62RTxCIiMjMSGankvlW2Xmx8GTEykU++NZ0YyPVPPg2s4PN7A9mttHMbjezQ8e43+FmdrOZPRhcTq9120REpHrGKjtv5MC2PyiJ18BwIiIyXHY+mT7fynwXC/fhysVB2bmC7xFiM7CNy4DLnXNXmdnrgauAo4vvYGatwI3Amc65W8wsCiyegbaJiEiVpLMj50btDMvOGziwHShkvhs3Oy8iIjMjDKQrGnBNZedlDff5Vtl5OTXNfJvZUuC5wDeDm24AVprZmpK7vhm41Tl3C4BzLuec66ll20REpLrS2XzhYARmx4BrfSo7FxGRQJi1rXSeb1DZealwHy7rTNAUjSj4LlHrsvOVwF+dc1kA55wDNgOrSu53CJAysx+b2d1m9g0z665x20REpIrG7PPdwIFtIfPdwP3SRURkZgz3+Z5E5ltl5yOEme/mWJTujoT6fJdolAHXYsAJwLnAkcBW4JJydzSzD5nZlvDS398/g80UEZGxpEr6fC9oafyycw24JiIioUmNdh5X2Xk5xf3ml3QklPkuUevg+ylgfzOLAZiZ4bPem0vutxnY4JzbGmTHvwk8v9wKnXNfdM6tCC/t7e01bL6IiFQqnc2PmGpsOPPduFnlcMC1Ri6NFxGRmVEIHGMqO5+q8GREIhahuz3Bzv4U+byrc6saR02Db+fcDuBO4C3BTa8DtjjnHi2563eBo82sM7j+KuCeWrZNRESqxzk3quy8ozDVWONmlQuZ7wZuo4iIzAzN8z19xZnv7o4E2bxjj35jC2ai7Pxc4Fwz2wj8H+DtAGZ2hZmdAuCc2wx8BviDmd0LvBQ4bwbaJiIiVZDNO5yDpqIRYpvjEeJRa+iSbpWdi4hIaFJTjRX6fCvzXaw48720IwHAjr5kPZvUUGo+1Zhz7mHgBWVuf2fJ9auBq2vdHhERqb500Y9tyMzobI439GBmAyl/0NSfypLPOyIRq3OLRESkXoYHXKug7Dwelp0r810slcnRFI0QiRjdQfDd05fib/arc8MaRKMMuCYiIrNYGHw3lfST62yJN2xWOZ93hcy3c9CfbtyTBCIiUnsplZ1PW6po2tHi4Fs8Bd8iIjJt6VwQfEdLgu/mWMMOZjZYUiqoft8iIvPb8IBrkwm+VXZeLJnJFaoCugtl5wq+Qwq+RURk2sqVnUOQ+W7QoLa/5KRAI5fHi4hI7YXBd2IyZeea53uE4sz3UmW+R1HwLSIi0xae+R9Vdt4cpy+VJdeA04yEJecdCT/8SV+DlseLiMjMSGbymI0+kVyOys7LS2ZyhT7zS9oVfJdS8C0iItMWHnyUlp13NPvAtjTL3AjC4Hv/hc1AY89HLiIitZfK5kjEIphNPPimys7L85lvXxXQHI/S2RxT8F1EwbeIiEzbeAOuQWNO5RWeEDhgYQugPt8iIvNdMpOvaLA1oBBgKvM9UnHmG3y/b001NkzBt4iITNuYwXeQ+d7bgIFtIfO9wAffKjsXEZnfktlcRYOtAcSjhpn6fJcqznwDLO1oVua7iIJvERGZtsJo57Mp8x0E38tVdi4iIoSZ78rCIzMjEYuo7LxEucz3vmS2MJjdfKfgW0REpi09Rp/vzmYffDfidGMDJZlvlZ2LiMxvqUyu4rJz8KXnKjsf5pwblfkOpxvb2a/sNyj4FhGRKhi7z7cvO2/EwHb0gGuN10YREZk5xXNUV8JnvhV8h9K5PM4xKvMNmus7pOBbRESmLSw7HzXPd3NYdt54me8w+F7W2YxZY2bnRURk5iSzeZormGYslIir7LxYeCJiZJ9vTTdWTMG3iIhMW/iD27Xvfrj6dEjuA4r6fDdi5jsItjub47QnYsp8i4jMc8mplJ1rwLWCsF93ucy3gm9PwbeIiExbWHa+dPvv4LFfwV/vBobn+W7EwDbs893RHKOzOc6+IWW+RUTmK+fcqMHCJqKy85HCExHFpfsKvkdS8C0iItNW6POdH/I3DPQARWXnDRjY9qWyRCN+tNrOlrimGhMRmccyOUfeMcnMt8rOi4X7orh0v7tdfb6LKfgWEZFpC/t8x3Nh8N0LQGtTlGjEGjLz3Z/M0p6IYWZ0Nscasl+6iIjMjGQhcNRo51OVLJP5XtTaRCxiynwHFHyLiMi0hZnvWG5k5rsQ2DZgn++BtA++ATqa4+wbyuCcq3OrRESkHsr1V55IIh5Rn+8iwwOuDe/DSMRY0p6gR1ONAQq+RUSkCsYKvoGgpLvxssph5hv8lGjZvGMoo/JBEZH5KAyip1J2rhO3Xir4DS2drq27I0HPvmQ9mtRwFHyLiMi0hf28otlBf0Nx8N0cb8yy81SWtoQ/QAj7pjfiSQIREam95BiB43gSsSh5B9m8gm8YznyXTte2tMNnvnWSQsG3iIhUQZj5jmbDzPfOwrLOlsYsO+9PZWkPgu7OcFT2BmyniIjUXrKQ+Z7caOeA+n0HxjqB0d2RIJNz7NVvrIJvERGZvnDAtUiZzHdHIk5fKku+gTIDubxjMJ2jPcx8h/ORN2CGXkREam9KA64FgXpKXZaAsTPfmm5sWGy8hWZ25njLnXPfqG5zROa+rXuGOO3i3/Plvz+SFxzUVe/miFRF+IMbyQz4G0oy385BfzpbKO+ut4G0Ly8v9PkOp0RT2bmIyLw0PODa5MrOQZnv0HiZb/DTjR28rGPG29VIxg2+gZODv53Ai4FbAAccC/wGUPAtMkkbn+5jR1+KH96zTcG3zBlh2bmFme/UXsimIJYomus70zjBdyoMvoOy8xaVnYuIzGcqO5++8fp8gzLfMEHZuXPuDc65NwCDwHOdcyc4514OPBcYmIkGisw1ybQ/K3j7pl11bolI9aSzeSIGlh4cvjHIfhdKuocaJ6vcnwyDb392vkOZbxGReW16mW+VncPEmW8F35X3+V7jnLsvvOKcux84uDZNEpnbwqmMHt3Rz07NeShzRDqXpykWgUxR8D0YBN/hYGYN1J+6L8x8N5eUnSvzLSIyLxWC75hBprJpsYb7fCvzDUWZ75Lqge72ZgDN9U3lwfc+MzvLhp0F9NewXSJzVvE8wn9W9lvmiHQ2T2s0D7n08I3BoGth5ruRpvEKy87biub5hsZqo4iIzJxkEDgecue/wVePhuTeCR+jsvORCpnv2Bh9vjXXd8XB9zuA9wApIAmcB7y9Vo0SmcuSRWdHb3tidx1bIlI96WyezmgQuLYs9n/DsvMGzCoPl537oHu47Lxx2igiIjMnHLG8te8J2LsZfvP5CR+jsvORxsp8tzRF6UjElPmmwuDbOfewc+4YoAtY4px7vnPu4do2TWRuShZlvm/b1FvHlohUTzqXZ0EsyHovWu3/lmS+Gymw7U+VBt8acE1EZD4Lj89i+SBA/NOlsPORcR9TyHyr7BwYO/MNPvutPt8VBt9mFjOz84HPOef6zOwgM3tpjdsmMicNBQOurVvWwQPb9tHXQAGJyFSls3kWRMPg+xn+bxB8Dwe2jVPSXRp8x6MRWpuiGnBNRGSeCisTo7khiLVAPgs//9i4jyn0+VbZOTB25htgSUeCHQq+Ky47/yrwN8BLguu9wMS1GCIyStjn+8Xrusk7uONJlZ7L7JfO5umMBD+qC8Pgu2S08wY60VTa5xt8ebxOhomIzE9h1jaSTULXGjj8DfDIL2DjL8Z8jMrOR5oo871nMDPv91WlwffznXPn4Pt745zbAzTGZK0is0wh+F7bDcBtT2jQNZn9Utk87WHmu2M/iCaGy84bsKQ7HO08zMqH/zdSG0VEZOYkg6AwkhuCeAuc8G8Qb4Wf/zNk02UfowHXRkpl88SjRjRio5aFc3339pffl/NFpcH3iKHpzCw6iceKSJFwnu8jVy2kIxHTfN8yJ6Rzedot+EFtaoO27kLw3dYUI2KNmfluL858t8RVdi4iMk+FZeeRbBB8L1gOx34Ieh+F2y4v+5jhPt/zO5sbSmZyZbPeoLm+Q5UG0Pea2VuAiJmtAS4Fbq5Zq0TmsKFMDjNoiUc5avUi7nlq74hB2ERmo1QmR3tYdh5vhbYlhbLzSMToaI43Vp/vZLmy85jKzkVE5qnCsVgm6YNvgBe+Fxaugt98Dvp7Rj0mEQ/LzpX5Br8fyvX3BuhuD6YbU/BdkQ8BxwH7Ab8H8sD/qVWjROayoUyOlngUM+Po1YtJ5/Lc/dSeejdLZFrSuTxtFvygFjLfO8E5wM+j3ZdqnMC2P5UlHrVC1gL8dGPJTH7e90cTEZmPkpk8TRGH5VLDwXe8BU78d0jtg19/atRjVHY+UkqZ7wlVOtVYv3PuXOfcsuByrnNuoNaNE5mLhtI5moMzpc870M+HfLv6fcssl87maaUk+M4OQdr/VHQ2WuY7laUtEcNsuF9aZ4vPgvep9FxEZN5JZXMsiAcnX+OtwwuedQqsPg7uvBq23T3iMcPBt07agj8JkRgj8720oxlQ8B0bb6GZnTLecufcD6vbHJG5LxlkvgEOX7GARCzCber3LbNYNpcn76A1zHzH23zZOfh+34l2OpvjbN0zVL9GluhPZUf09wZ/ggD8wHBLgvI4ERGZH5KZHAtjGcgxnPkGMINXXAiXHQc//Si842f+NorKzjXPNxAc4zaVDy/DzHdvXz/0PgZdB81k0xrGuME38I/jLHOAgm+RSRrK5Ar9YRKxKOtXLuSOJ3eTzeWJRTWOocw+6Zw/6GgNx+Zsai0KvnfC4gMLI4k750Zkm+tlIJUbHXwHU6Ip8y0iMv8kM3k6o9nRwTfAfofBc98Bt18B990Ah78eUNl5qVQ2z6K28seyi9uaiBgcsuW78NVL4b1/npcB+LhH+s65l4xzeelMNVJkLhnK5GhpGu4P87wDFzOYznH/tn11bJXI1KWDg44Wigdc81PpFaYba4mTdzCQbozSvL7k6Mx3OO1YI43KLiIiMyOZydEZC77/Yy2j7/CSf4HmhfDLTxa6VKnsfCQ/2nn58DIaMbraE+zf/wC4PDx93wy3rjFUnGYzs7iZrTWzI8JLLRsmMlcNpfOFsnOAYw7sAjTft8xew8F3mPluHx18F5V0N4KBVJb25rHKzpX5FhGZb5LZHJ2x4Pu/NPMN0LoYjjsf9m2FxzYAFAYXU+bb86Odlx9wDfxc38vST/krvY/OUKsaS0XBt5m9BtgM3AtsAO4Gbqxhu0TmrGQmN+KL6chVC4lGjD8p+JZZKjzoaHblys7DzHfjZJWzuTxDmdyIacaguOy8/m0UEZGZlczk6YgG3//FA64V2+8w/zf4bYtHDTP1+QZwzo2b+Qbobm9iZX6rv9L7+Ay1rLFUmvn+NPB84EHnXBdwJnB9zVolMkc55wpTjYXaEjEOW76APz+5i3ze1bF1IlMT9vlOuCRgEGsuynz7ub7DrHIj9KcOS987VHYuIiKBZCZHezTtr5TLfAO0+mpFBv1vm5mfslJl55DNO/KOcTPfBzX30WbBiXplvseVd849STBAm3Pum4D6fItMUibnyOXdiD7f4Pt97xnM8MiO/jq1TGTqwrLzRD7pS87NoLU08904Zef9KX8CYFTmW2XnIiLzViqTp90myHwXgu/hasVELKqyc/zJC2DczPfa2PbhK7seq3WTGlKlwXd4tLTFzE4zsyOBRTVqk8icNRR8MbWUnBU8erWf7/u2J3pnvE0i0xUG300u6UvOAeLNkOgsZAc6Gyir3B9k30ePdt44bRQRkZmTyzvSuTztkQky3y3+eI3B4eM1n/lW8F3ogjZO5ntVUHKebun2J+eTe2ekbY2k0uD7y2a2CPg48HngF8AnatYqkTkqPCtY+sV09Gp/Luu2TbtnvE0i0xWWnTflBkdmC9qWFMrOOxooqxxmvsea57sRSuNFRMR315sJYdl4SyTMfDeXv2NTq/+dKw6+4yo7h8oy3/tl/GBr25a+2N/QO/+y3xUF3865bzvndjvn7nDOHeyc63bOfavWjROZa4aCvqalZecLW5tYt6yD257onbEfGpFqCTPf8XwSmtqGF7R1jx5wrYHKzktHO2+OR2mKRhqijSIi85lzjh/ctZVjPvMrvnv7UzXfXjIYMK3Vwsz3GGXn4LtVjch8RzXgGpVlvhcNPUnSxXm8/Sh/g4Lv8szs38ysq+j6EjP719o1S2RuGqvsHOCYAxfz9L4Um3cNznSzRKalEHznhsoE3zshnx/uT90AJd0DY/T5Bn+SoBHaKCIyX/X2p3jPt+7kg9feTU9fij8/WfvZYMKs7XDwPUbZOfgpxwZUdl6qksx3e9/jPOH25wlb7m+Yh/2+Ky07P9U5V3iXOed2AqfWpkkic9dEwTdovm+ZfcJyu1hp2XlrF7gcJPcUDbhW/5LusM936Wjn4EvPVXYuIlIfv7h/Oydd9Ft+et92XnX4fsSjxq6BdM23GwaOLaT8DeNmvrvK9PlW2fmEme/MENG+rTzm9ueRbDAjijLfk7pfUzUbIjIfJIOy8+YmBd8yd/gfXEcsWybzDTDQQ0cihlljZL7HKjsHP92Yys5FRGbW3qEMH/ru3bzr6jvI5Bxf/vv1XPzm57C4rYmd/TMRfAeBI5VkvrsgMwCZIUCjnYcmzHz3Pobh2BxZwdaBKHTsPy+nG6s0+H7YzD5iZlEzi5nZR4GHatkwkblovMz3ss5mntHVym2bFHzL7JLO5kmQwciXDLg2HHxHIkZ7ItYQWeXCVGNNMejZCBc/H3Y9Afgp0fY1QBtFROaLWx7ZySsu+i3fu3Mrx6/r5hf/+CJOXb8cM2NxW2JmMt9B5joRZr5jEwTfUJhuLBGPqM83w5nvxFiZ750bAehtXkVPXwoWH+TLzufZWEeVBt8fAF4BDAEDwAnA+2rVKJG5arzgG+CY1Yt5sneQp/clZ7JZItOSzuWHS/VGZL5L5vpujjdE5jvs893RHIMnb4GeB+GpPwG+jf2pLLn8/DoYEBGphw0P7+AtV/6JfUMZPnv64fzvWUezrHN4pPEl7U309qdq3o5C1taFZefjBN9tYfDtS8/DsvP5PmBuasLMt89y97ev9sF31zP9VGOD82ua3UpHO9/mnHspfm7vxc65lzvn/lrbponU3qM7+vjF/dtnbHthWVNLU/mP3tEqPZdZKJ3N00Zwwqhs2Xkw13dLvCFKuvuKB1wLf/SDDEY4Knu/st8iIjV31+Y9AHz9HcfwpmNWYWYjli9ua2IgnSsEx7USZq6bKgm+C5lv/9uWiEXJO8jO85O2E/b53vkIAOmFB7FrME1u0UH+9nnW77vS0c5PNrNO59wA8G4zu97MDqtx20Rq7ku/fIR3XX0H2/fOTKZ5aIx5vkPPC4Lv21V6LrNIOpunxcoMUlMSfHc0xxqipDsMrNsS0ULQHQbhHQ00KruIyFwXViLtv7B8sNvVlgCgt8al52Fw35RPQTQBkbGnyxpVdh5keud7v+8J+3zv3Agd+9PZuQjnYF/rKn/7POv3XWnZ+f91zu0zs2cDbwF+CVxSu2aJzIydQSnTLx98eka2Fw64NlbZ+arFrSxpb+KeLXtnpD0i1ZDO5mktW3Y+3OcbgrLzoUzdS/MGUlmaohESsehw5nsoyHwHg7DtbYAMvYjIXBcG3+1NowfABOhq9+M717r0POzzHXfJ8bPeUBR8B2Xn8SD4rnF2vtGNm/l2zgfZSw5m2QLfrWBbbIVfNs+mG6s0+A5TFScClzvnLgPaxrm/yKywZ9AfYM9U6Xmhz3eZ0c4BzIyVi1vZultzfcvskc7labMyZeetiwEbDr5bYmTzrvA5qJe+VHZ4pPNC2bn/W5gSTZlvEZGaG+4GVP64qKstCL5rnvn2gWMsn5p88B3zbVfme5zMd992SPdD18Gs6W4H4IGhRYAp8z2GqJk9D3gdsCG4LV6bJonMnD1D/sv81sd7Z+Rge6IB1wCWL2xhZ3+65v2bRKolnc2Xnxs1EvUHKWGf7+bGmOt7IJUdPtAr6fPdEQTljTAqu4jIXDeQypKIRYhFy4ckXe1B2XmNpxsLj7liuUoy38FgokUDroGC77DffNnMdzDSOUsOZu2yDgAe2pmBhSuh9/GZamJDqDT4/jhwGXCLc+5BM1sHbKxds0Rmxp7BDGaQyTlufrin5tsbmqDsHGD5Iv+lv23PUM3bI1INqRFl560jF7Z1F2W+GyOr3J/K0p4Izh8Xys53A8UnCJT5FhGptYFUlvZE+ZJz8AOuAewaqHHZeZj5ziVHnkQup2WR/zswPOAaQCo7v5MmhenaymW+e/1gayw5mJWLW0nEImx8um9eTjdW6WjnP3LOrXfO/VNw/WHn3Otq2zSR2hpK50hl8/ztQf4M5kyUnhdKcsYJvlcEg45sVfAts0Q6VzTgWlP7yIVtS4r6fIdZ5foGtgOpLB3hwV7JgGvDJwiU+RYRqbX+VG64G1AZSwp9vmcm8x3JDU2c+Y7GoHlhmT7ftct8/8M1d/LZnzxYs/VXw/iZ7yD47jqYaMRYs7SdR57uh641kBmEvvkzidbY73aROS4sOT94WTsD6Sw3P9xDKpsrnMGshYrKzoPM99bdCr5ldkhn87SHU42VZgzalkByD2TTw4FtncvO+5JB2Xkm6fuggQ/CnStkvut9gkBEZD6oNPNd8z7fQdY2kq2g7Bx8l6oZGu3cOcfP79tONu84qLudvzt6ZU22M13jZr53PgKxZljg2752WQff37aVoc7VtIDv9915wMw1to4qLTsXmXPCwdYWtjRx4iH70Z/KcuvjtZ3iayidIxox4lEb8z7LF/rgRZlvmS3SE5WdAwz2FjLf9Sw7z+TypLJ52pvjhRHOAcilID1Q6PNd7xMEIiLzwUTBd3siRlMsUvPRzsOsbSSbhFilwXfpgGu1KTtPZfOFOcQ/ceN9PLBtX022M13jZr57H/FZ7ogPPQ9e5qvktkSCgHsezfWt4Fvmrd2D/izqorY4Lz9kGVD70vOhTI6WeBSzsYPvAxb6KRiU+ZbZIp3N0zpm2XkYfO9siP7UhWltEkXTjIWGdjVMv3QRkfmgv3gAQvcPBgAAIABJREFUzDLMjK62JnbNwDzfRh6rZMA18FVdg73g3HDmu0Zl5+EAoEeuWkjeOd7zrTsa8jcqGWT+R2W+M0Ow5ykffAfWLg0GXUsv9TfMo+nGKgq+zWylmTUF//+tmb3XzDpq2zSR2tobZL4XtMRZs7SdZ3a38csHniafr92gD8lMrvwZwSIdzXE6m2NsUeZbZolUNkdHpMxo5+APUAAGehqiP3V4ENOeiA0H353L/d/BXbQ1RYmYBlwTEam1sBKpbZzMN/i5vnfOQJ/vZoJtTDTgGvipNPMZSO0b7vNdo7Lz8KTx85/ZxcdffQibegf58HX34BpskLJUJkcsYqNHru99DHCwZG3hpnDE87v6OiASU+a7jBuBiJktB74D/C3wtZq1SmQG7AkOrhe2+v5EJx6yHzv6UtyzZU/NtjmUydHSNPHHbvmiVmW+ZdZI5/K0RSYoOx9okMx3OpxTtij4Ds/GD/ZiZnQ0xzXVmIhIjQ1XIo0ffC9uS9A7A6Odt1oYfFdYdg4w2FvzsvP+ov105guewWuO2J+f3/80V97yRE22N1XJbH7Ckc5DKxa10BKPsnFHEhatVvBdjnMuCbwauMw59yZg7QQPEWlohbLzVh8QhKXnv3zg6ZptcyidG3ewtdDyhS1s35ckm5vfc0bK7JDO5mkvHLS0jVxYCL57hvtT1zGw7R+R+Q76fIcHBOF0Yy2xhizpExGZS8KgcqLM95K2JpKZPIPp2v12JLM5FsSC7/1JBd+7aj7gWnHFlplx4euO4KDuNj7704e4fVNtxyqajNRY1Z2Fkc6Hy84jwYjnhenGdj8B+fkxVVulwXfCzBLAy4ENNWyPyIzZWzTgGsCRKxeypD3BL2oYfCcz+YqC7xWLWsjlHTv6anumV6Qa0tk8bZaCSBxiTSMXlg2+6xfYhgd7Hc1Fme+wFC6cbqw5ruBbRKTGBlI+2Kqk7BxqO91YMpOjMxYEf5POfId9vmsTPJZWCLQnYlzylqNoikb4h2/dSU+DHCuOmfneOTrzDX7QtR19KVILDoRcGvY+NQOtrL9Kg+9vA9uBVcAfzGx/YLBmrRKZAeFo5wuCzHckYrz8kGU8uqOfx3r6a7LNoQr6fIPPfINGPJfZIZXN00pydMk5jOjzHYtGaG2K1rWke0SmZVTZuc8gdKrsXESk5gonQysoO4faTjeWzORZEJ1M5jv8bdtJIh6Wndcm812uQmDtsg4+e/rh7OhL8YHv3EWuhuMVVWrszPdG6NgfEiOHCwv7ff81Foy70vtorZvYECoKvp1z/w4cCLzA+d79fcDratkwkVrbM5QmYiO/9E88tLal50PpHC1NFQTfmutbZpF0LhjtvLTkHCDRCdEmGNgJ+IxzPefQHpFBKGS+g7PxwfWO5hj7hjINN5iNiMhcMlBh2flw5rt2GV6f+Q6D70oGXCuT+a5V2XlxxVaR1x65nDOet4o/PNbLl365sSbbnoxUNk9TaebbOR9Ul2S9AdYG0409mvPH3vQ+XusmNoRKRzu/zTm3xzmXB3DO9QM/qGnLRGps92CGha1NRCLD03698KAu2pqiNZlyzDlXmGpsIsp8y2ySzuZpIVU+823mMwQDPYAfzb+eA671lfb5TnRC+35+YTDvd2dLnLyDgfT86H8mIlIPw8H3+MdFXW1B8F3DzHcqm6djUpnvxf7viOB7ZsrOi33iNYdw+PIFXHzzo2zurW9RctnMd992SPdD1+jg++BgurG/DAVVBMp8jzDi1TazGFDRVGNmdrCZ/cHMNprZ7WZ26Dj3NTP7tZnVbrhpkcDewQwLg6mPQolYlOPXLeWup/awoy9Z1e2FZ0QrCr6DzPcWZb5lFkhn8zS7FDSVyXyDLz0Pgu/O5lhdS7rDPobtYZ/v1sW+n3pTx4iyc9B0YxXbdjdcfzak1RtNRCrXX+Fo513tQdl5jft8t0enmPkOy85rNM93OFBouQqB5niU809ci3Nw/Z1barL9SpXt870zyMiXyXwvX9hCa1OUP+9qgVjzvJnre9zg28w+ama7gcPNbFd4wZed/7bCbVwGXO6cWwt8DrhqnPv+IzA/9rzU3Z6hdKG/d7ETD12Gc/CrB3dUdXtDQRatuYKy8662JprjEWW+ZVZI5/K0MFS+7Bz8oGsDYUl3fftT96f8wVVbU5D5Dg+gWhcND7jW4g9w1O+7Qvdd7y9P/r7eLRGRWaTisvMg872rhtONJTM52iJB8B1rnvgBzQv8/NQzMNp5/xhl56HjDu5mv85mbrhjC/k69v0um/kuM81YKBzx/OEdg7D4mcp8By4FjgRuCv6GlwOcc+dOtHIzWwo8F/hmcNMNwEozW1PmvocCrwUurLj1IlPknGP3YIZFrU2jlh2/bimxiFW99HwoGAWzksy3mXHAwha27lYmSRrfcOZ7jGxBWzdkBiA9QEdzjKFMjkydptEbNdp5GHy3LC5MNdYRZr414nll9m71f7ffW992iMisUnnmeyZGO8/THplE5tvM/34M7qx52flE+ykaMV531HK27hniD4/11qQNlSif+Q4C6v/P3ptHR3bd952fW/uCqsIOdKMXdLN37mSTFGVKFLVZsrZYsaSRbMlxJrY8cZyRHSfxnJwZn3EcLxnZnnjsOLbs2HJkS5RkrZZiidpFURTZXJpNstk7gEYv2FF7var33p0/7ntVBaAA1PKqCo1+33NwCqgFuI1G3Xe/v+/39/3VsJ2Dsp7PZzSKiX2wPAV6+/6Ptwo2JN9SyqSUckJK+VZgDhizPuotPe0Grkkpdev7SWAKlZpehhDCD3wM+DDgNtm5aDsKJZOibq6xnQMkwn5etX+AH5xfKG94TqAR8g3KjnNlOe+GPrnY8ijpOkFZ2Nh2DpCdLxPbbqnKGXu0jacIer5K+R6oGjVmjURzbef1IWlZHa+55NuFCxf1I1PnqLFIwEfY721bz7eUkoJuqOsC1NfzDeXrRtCnznXFdinfBV1x/Q2ckz91724APn2iO+O6dMPEMGXZgl/G/FnlJEjsrvk6O3RtPrALpAlLE21eafdRb+Dagyg7+J9YH+et+5zCbwCfk1KermMtvyqEmLY/Mpn2jIRysb2xnFcbbC3bOSjredEw+d7ZOcd+pm07ryftHBT5LpRMlnIuAXCxdWGaEr9p1WM3sp0DZOerLN3d+bvOFEoEfR78BaVyV8h3P5RyUCoQD3e3QHDDIWUr36e6uw4XLlzcUKg3cA2gPxpgoU2286JhIiVERHPk2+8VCNFe23lPwIcQYt3n7BuMcv94P1976TrJLhSOC9a/PbRa+V44p8Z5empTTnvc2ITYqe64Cfq+6w1c+0Pgp6SUd0sp7wZ+yrpvM1wGdlgBbQj1V7MHpX5X42Hgl4UQE8DjQFwIMSGEGFr9DaWUfyCl3GV/9PT01PlPcOGigqWs2phq2c4B3nhUjT1w0npesJTveuZ8Q1XiuRu65mILo2iYRGwz1Ea2c4DsXDnMrFvENqsZFcs5VBJrbRKeXyz31bm28zpg6JC+pj5fvABaurvrceHCxQ2DbHnOd20hpBqDPYG22c4LVlBaBJt812E7B3X9yC8jTIOgz9Ne8r1Ov3c1fur4LjTd5Msnr7ZlHRtBs864QX8VtSzlYfmyIt/r4KClfJ/Wbp7E83rJd1hKWU5SkVI+AWyaRiClnAWeBX7GuuufAtNSyvOrnvcaKeVeKeU48BCQklKOSymdkx1duKiCrXz3rqN87+wNc/tYgm++MutYb6q9uddtO7dnfS+7fd8uti403SQsrMkA6x1Yqsh3t4ltWtOVxbFMvqt6vgFyC27aeSNIX1NWQY+1l8681N31uHDh4oZBRtPxCAj516EjpQJ88zfh+ilL+S62pRXPJo6hsvJdR+AaWNcPCYVlgj5vW3u+N7PmA7zt9h1EAl4+0wXreUX5rjrjLlwAJAweWvd1Y71hogEvT6f6q16zvVEv+c4IId5ofyGEeAOQrfO1HwY+LIQ4C/w68HPW9/gLIcQ7G1msCxdOIWlZuRM1er5tvPnYCOmCztOXFh35meWe70B9bztb+XbHjbnYytB0o0r5XseJVO75riLf+W4p33plxjestJ0D5BbL+0LKtZ1vDttyPv6QunWt5y5cuKgT2aIilTXt1KYBn/sX8P3fhyf/GwM9QYq66WgWj42yONKw8l3JMwn6PG0dNbZZKB2o3vm33b6Dk9NJzlzvrAuppvK9QdK5DSEEB0ZinJj3qZGfru28jP8d+EshxEUhxCXgL4FfrueFUsozUsoHpZSHpJTHpZSnrPv/hZTySzWePyGl7K33H+DCRTOw+6jXs50D3LFb/RlOLjqjPDccuFZWvl3y7WLroqibRLGU701t5/NVtvMu9Xyvp3xH1irf3VrjDQU7bO3wW9XttZPdW4sLFy5uKGQ0ozaplBK++m/h9JfV17MvVY0bc956XrAU66BdSG6k5xusWd/ts51nNX3dMWOr8Z7jKtis0+q3XcBYoXzPW+R7A9s5wKHhHuazJfS+fa7ybUNKeQI4ALwTeAdwUEr5bDsX5sJFO7GZ7RwoJ6EvOxR4Vig21vM9Gg/h9Qi359vFlkZRNwkL+8CyHvmuVr67nXauE9vIdp5fLPfWdUudv6Fgk++dd0PPiKt8u3Dhom5k17NTf++jcOIvYd/DsPfHYPYVBqLqefNt6Pu2M3mC0rqW+Zog322ynZumJFPUiQbqI9/3jfcxPhDhC89f6ehIT/vfvkL5nt9c+YZK6NpyeI9yUxW3d7tlvco3wL2oOdzvAu5pz3JcbGtMPQl/fD8sTXZ7JWXbeW94feXbJuY2UW8V+QYD13xeD6PxkKt8u9jSWBm4to7t3B9Wj+Xmu9rzremGUuprKt/2IWoRr0fQE/S5gWv1wLadJ3bB6B0wexoM9/fmwoWLzZEp1CDfz3wcvv1baj953ydgx12g59ktZoE2Kd+WahuUGngD4K2P6FY7ptoVuJYrGUhJXYFroGzc7zm+m/lMkW+/Muv4etZDWfmuPuMunIPYDgjGNnytHbp21WMnnl9syxq3CuodNfZrwKPAADAIPCqE+NV2LszFNsTUD2H+DJz6dLdXwlJu41FjUCHmSYeU70Zt51CZ9e3CxVZFUTeJbGY7B6V+V/V8d0P5zlozZXvKaecCQlaXU1XPN6hZ327gWh1IXgGPT6neo7eDoam5ri5cuHCxCVQGR9WZ6JWvwj98BHr3wk9/FkJxGDkGwK7SBAALGefHjdnKt19q9avesEr5bk/Pt50IX0/Pt4133zOGR8CnT0w7vp71UFa+7VFjUirlexPLOVSU77P6qLpjm/d916t8/wJwj5TyV6SUv4JSvn+xfctysS1RSKnb0//Q3XWgrORejyC+QSUxFvLhEc7Zzhud8w2q73s5Vypvvi5cbDUUdZPIZrZzUH3f2fmqGdqdJ7YrDjG5BQj3VhSOKts5QCzkd+d814PUtFI2PF7YcYe6z7Weu3DhYhNIKckWq4LEpn4En/05tRd/8PMQUyNfGT6qbnKKkC20RflW57OAWai/3xsqLVVttJ3b16FGyPeORJjXHBzi22dmmU0XHF9TLaxRvtPXoZjZMOncxo5EiFjQx3NZO/F8e48bq5d8p6SUC/YXUspFINWeJbnYtrDnv157vtIn2CUs50skwv7aCZsWPB5BIux3zHZeaFL5Brjqqt8utiiU8m3bzqPrPzE6BNk5evxehOiO8r3iEJNbrKgWoFR7X7hsR4+HXdt5XUhOK8s5KJsouOTbhQsXmyJfMjClSuhm7gx88n0gvPDTn4GBWypPHDoKCGIp5ahpx6xve0yWz9QaI99VIyrbFbhmp7vXazu38Z7juzBMyReeu+L4mmphjfJdR9K5DZV43sMPlhLWa13bOcC3hBB/LYR4jfXxl8A3hBB3CCHuaOcCXWwjaFX1mle+0r11oKzkvRuMGbPRGwk4p3w32PMNat44wLRLvl1sUWiGSbgu8j0Ipo6nmKQn0B1imy2uUr6ryTco63nZdu53A9c2Qymvfo/xMfV13z7V2+8mnrtw4WIT2KRy1LMM/+PdSqB539/A2KpYqUAE+vcRWjoDwEK2fbZzn1mof8yYvTZ/pK09383YzgHedGyE3oifz5yYbsts9NWwLfdB+4xrtx/VQb4BDg3HmMgFMcP9rvJt4T3Aw8DfWB+vB94HfBH4QnuW5mLboZBSVU1fCF7prvV8KVfcMOncRiLs77rtHHATz11sWRR1k6iwbG2b2c6hbD3vhvKdsZXvgNeynfevfEKkv0r59lM0zPKhzEUNpK6q24RFvj0eGLlNKd8dOOy5cOHixoWdwXF/8uuqfeVtvw8H3lj7ycPH8CxcoDdgtiVwzZ5R7TPyjSnfoIq4lu3cMCW6wwnjzdjOAYI+L++6cyfnZjM8f3nZ0TXVwhrle94i0AP1kW87dC3Ts9ft+QaQUu7b4GN/uxfpYptAS0EoAfsfgYkflBWmTkNKyXK+RO8GM75t9Eacs52XlW9f/UMGbNu5G7rmYquiqNerfNvkW4WudYV8WwpCr08Ds7RW+Q73Q34JoKup7DcMktYc2cTuyn2jt0NhueutRS5cuNjasBXdhEyqO/Y/sv6Th4+BNLg7MtemUWOKMHuNBnu+QRVtswtl0um0+p1pUvmGqpnfz7R/P17T871wTolt1deHDWCHrs36dkF2DgrJtqxzK6DetPP7hBAR6/P3CiE+KoTY2d6ludh20FIqufLI20AacPZrXVlGoWRS1M36bOdhP4WSM+pXoWQQ8HrweTd422Xn4eSj5Z7JMvl2lW8XWxQrer7rUr5t8t15UmsfYhJ2ZElktfI9oPYpo0TcmkfuWs83QNLqJbRt56DIN8D1Fzq/HhcuXNwwsPfjqJlRd4QS6z/ZCl27w3+FxTbazj16M+R7sNzzDc6T72yTPd8At40lOLojzpefv1p2X7YLa5TvpUnoG1eOqDpgk+9L0graW9i+6ne9EtxfAJoQ4iDwn4AS8FdtW5WL7YlCCoJxOPxWEJ6uWc/tMWP1Kd/WuDEHRg7lSwYhf4233MIFeOL/g//+VvjoQfj8L8Bn/1dAWdQHogFX+XaxZVE0TCK27Xyznm+wyHd3+qlt23nctMl3jZ5vgNwi8bCrfG+K8ozvKvLtJp67cOGiDtj7ccTMAEKdD9fDyK0AHPFcZjFbdLyHuaAbCEw8TSnfA1DKEvWoa4XTieetKN8A7z2+i7Sm881XZpxc1hqsUb61VGWUZx0YiQeJhXy8mB9Wd2xj8l3v/6QhpTSEEG8F/lRK+QdCiOfauTAX2xBaCnr3qEP4ngfh/DehmNt4NnAbYPdw19vzbb9mJB5q6efmi0al3/vaC/DyF1Xw3NxpdZ8/olwB2QWYegKWJqBvnLG+sKt8u9iysJVv0xvE49kgz6CsfC8QD/nK/dSNBBC2CvsQEzMsO9sa8m19nV8kFlKFBHfc2AaoZTsfOqqyPa65yrcLFy7Whx2AGTbSSvXeSCHtvwW8AcaNSUqGJFXQy+czJ1AomQSxCq2NBK5B+bqRkGqij9Ozvpvt+bbxwD61vvOzGcfWVAtrlO+C5XatE0IIDo3EeHLWIuzbuO+7XuU7KIQYAd4BfMe6r3MnJhc3PqRUSZZBZSvhyNtAz8PFb3d8KXYPdz3k237Ocq71HqN8yVRjxq69AH/2Gvj+R1Vfy90fhPd/Cv7dRXjfJ+BVv6hecO4xQFnPZ9IFim1I0XTholXYc75N3yYHlshK5Rs6T2xt8h1Zj3xXjY2p2M5d5XtdJK+o8Wzhvsp9/hAMHXaVbxcuXGwIez8O6ikIb6KQen0weJix4iUAFjLOWs8LJaOSXdKM8k0V+d5CtnOA0YQSjmZS7Z33vUL5NkrqjG+f+evEoZEeTuUHKRx8W90p6Tci6iXffwicAZJSymeFELcAS+1blotth1IeTL1iKzryNnXbhZFjFeW7vsA1UHPBW0VZ5VueUne84Tfg187Cu/5YWfHtDX//68Djg/PfABT5lhKuJ9u7cbpw0Qw0XR1aTP8GlnOoEF2r5xvoeN+3fYgJl5ZXrsmGaztvDKkrynIuxMr7R++A5FQ5vM6FCxcuVsPej/2l1Mb93jZGjhEvzhAj53jieaFkEsb6ng0r3+q6YQfHbTXbeV/ET8DrYSblfK98NVYo35oqRDRKvg8Ox8gR4pkH/ghu+6dOL3HLoN6087+QUvZKKX/KuusS8Kb2LcvFtoM949u2oPSNw8jtcOZ/gtFZ9atMvusKXLN6vh0YN1a2ndu/i+GjUMumG0ooW/7F70KpUBk35vZ9u9iCKOomUQrIzQ4sXp9SlrPzZeU71WHlO20rLUWLFK5LvivKt2s7XwdSqkTzxC6uLuf5w8fO8sT5eTVmpxy65qrfLly4qI2MNWrMV0zX1xtsha4dEpcdTzwv6AYhYX1PX4MthlaeSY9hk2/nbec+j6jYuRuEEILheLDtAs4K5ds+5zasfKvnn51JO7q2rYa6yyhCiAeAW1a95m8cX5GL7YmC/Uas6v84+nb4zu/A1A9h32s6tpRGbOeJsvLthO3cULZze3zCRpXeg2+Cie/D5OOM9d4GuOTbxdaEZpiEhQb+4c2fHB2C7FxZVe6G8h32e/HkrTGHq9PObdt5frEyasy1nddGIQnFDMR38ddPTPDn37sIKJXlw7sj/CKgXz2Jb99ru7tOFy5cbElkNR0PJt5iHbZzgOFK6NqCw4nnWskg5rGV7+Zs52Xy7XDPd1bT6Qn5EKsdRg1gNB7i0nzWwVWthaYbeAT4PKJK+a7D0VCFQ9as77Mz7e1P7zbqHTX2p8AngZ9C9X2/A3h7G9flYruhlgWlS9bzivJdh+28KnCtVVTId41CxGocsIwl5x5jpztuzMUWRnnUWD3BiRb57lrPd0EnGvRBbkFNXFittthKeG6ReNhW513yXRNVSeenr6UI+T185I0HGYmH+NMzqgXhK1//Or/8yef4ygvXKBluZoULFy4qyGo6MXLqi3qU75FjgFK+F51WvksmcZ91PWoycC1itM92Hg00Zzm3MRIPsZAttjU7qFAyCfm9qkjQpO18KBYkEfZzbpsr3/V6GN4IHJNSvltK+R7r473tXJiLbQbNVnurCOfIbSr9/JV/UBbGDsEOT+uN1hO4pgh6qz3fhikp6iahQJ3K9/BRiO+Cc19nV9l2nmtpDS5ctAOKfBcQgZ7NnxwdhPwicavu1WlVOaPpStHOLSqVe3W6blXPd0X5dm3nNZGcVrfxMU5fS3N4JMZH3niIf/zIa/nir72ddHCUO31TfPnkVX7p757lz767fZNrXbhw0Tgymk5CWGpsPT3f8THMYNxSvp0m3wZxr02+m1O+I7rKEnHadl6+brUAe1rPbLp91nNNN1YmnUPD5Fslnvdwdibt+Di5rYR6yfc1oL2d+i62N2qpvULAkXeocTXXOzeWZjlXwusRxOoIr4hbG16rPd+FkqqEhv3e2oWI1RBCWc8XL5LITRENeF3buYstCb1UJCh0RLBO5RvoQ1W1u5F2Hg16lfK9ut8bINADHj/kFwn6vAR9no5b428YWOR7OTDCfEbj6I7KfjY+GCU2fg/jcppv/usHALiy7AZGunDhooKMpjPotc419djOhYChoxwWl51PO9cNYr4mA9esaQ+hok2+nVe+mw1bszGaCALtTTy3lW+gonw3MGrMxsGRGKmCzmx6+9LOesn3j4DPCiHeK4R4p/3RzoW52GYoB66tqm7a1vPT/9CxpSznSiTCfmWN+fZvw5+8Cszam6XP6yEW8rXc852vJt+FJCAgsElF8OCbARDnH3NnfbvYuigpR4YnsEnaOZTJd6+VCttpYls+xKxHvoVQ9+cWAIiH/R0PhbthYNnOzxXUnl5NvgGVeG7qjEs1CzzpQG6GCxcutg+yms5owCKD9djOAc/orfSKLEbqmqNrKZRMesrKd4OBa14/hHoJlVSQp9M93+V2qRZgK9/tTDzXdLOifDcZuAZwaNju+96+1vN6yfdxoB/434BfsT4+0q5FudiGWK//Y8+r1GG3g33fy/liJWxt4nGYOw1LE+s+vzfib7nnO1+0yHfA6vkOxtdaXldj32vBG4BzjzHWG+bqcgHT3L42HBc3JoRNvoN12s6BmKEUgk4SWyml6jEMeCC/uDZszUakX9nSUc4XN3BtHSQV+T6VVv/vR0ZX7e1W4rl35hTxkM+R3AwXLlxsH2Q0gyG/JSrUYzsHGFZ9333pc46upbAicK1B5RsgMkBAs8i3g7Zz3TDJl4ymZ3zbsMl3OxPPNXucLjTd8w3ViefbN3St3lFjj9T4eH27F+diG2G9kDGPV824nn0JFi92ZCnLuVJlzFhSqTLMvLju83vDgZYPjrbtPGQr3/VcaII9sPfHYOJxxuNQNEzmHbZauXDRKjwW+RYNKN8RSyHoZJiZppuUDMmQvwDSrK18g7rfSkOPh/1dGTX2vbNz/PvPvqDGdq2GacBTH4P8csfXtQLJaQj1cmpO7W1H1ijflXFjiYifpFvEcOHCRRWyms5AI7ZzKJPvwbyz58VCySTqsfaoRnu+ASID+Is2+XbOdp61hJtN2ySnn4Hv/O66Ls6y8t3Wnu9ayndztnMhYO5mt50LIV5b66Pdi3OxjbB6znc1jrxD3XZA/ZZSspwvqSA104DUVfXAzEvrvqbXgYOjPf8wbM8/rLfKe/DNYGjcJ9X63L5vF45BynUv1I3Ao1tBgHWlnSvlO6gt4PWIjhLbrDXje8hrVdPXI9/hPkVsTYNYyN+VtPMvPH+FR09c5uVrqbUPXvoufPXX4Jm/7vi6ViClZnyfvpZirDdMIrwqwLJ3j9rnrp9ypIDpwoWL7YWsptPvsZXvvvpeZM363lO65KgTUCsZLZNvX2EJkI7azjPWdWtT2/n3/rMa3fvMX9V8eNQm321Uvgslg+Aa5btx8j3YE+Dl//u4F9lZAAAgAElEQVQt/Ppbjzi4uq2Fem3nv1/18SfAN4D/t12LcrENsVHy4f7XgT/aEfKdLxkUdVPZzjMzYFqH/w3Jd4CMprc0KidfVr49lvJd54Zk9X0fzT4JuOTbhYM48Zfwe+Nli3WzEDb59tevfIvsHLGQr6M93/YhZsCzCfmODAAS8svEQz5yRaPjY7LsgMcTE0trH1ywUsPnnbVdNgTThNRVzNhOLsxlOLqjxr4uhOr7vn6KvrDXVb5duLghIK2P9iOj6fR5rLTzepXvSD9J3yCHxJSje0pBN4gKS2lt0nYuzBIx8o7azjNWgXrDwDXThKkfqs+/8ZuQnlnzlHDASzzk43obA9dWKt/N286FEKpFcxujXtv5fVUftwMPAU+2d2kuthW0FOuGjPlDcPCNMPUkZGbbuowVM76XL1ce2NB2rhSdVjb6cuCaz1O/7Rxg4BboG2fn3PcB6YauuXAOz/2tel/On23p2/jKyncd5LtnRN2mr1vku3PKt02++4V1KFiXfNvjxhbKs747bT1fssYhnpisURhZvKRuF7pIvrNzYBRJBkYoGZIjo+sUE0fvgGKG/b75lguYLlxsNzx5cYE/+PqZrTVSafkyJK+2/cfohommm42NGrOwGD3AQXGFhbQz5yHDlJQMSUhYZzxfg4FrAFF1PekTaUdt5/Z1a8NRY7Mvq3Pl6O1qms7X/0PNp43EQ8y2MXCtUN3zXUiB8DbnIrgJUK/yvQJSyqeABx1ei4vtDC2lKmDrhYwdeTsg4ck/hVL7CGaZfEf8lX5vf0QFrmm1kxXtcLZWbJN24FqPt6TU9nqtOELAwTcTzFzhgLjiKt8unEHqGlx9Vn2ebi011qdbf5P1kO9QXP3tp6aJBTtr6bYVhITchHyHLfKdr8z67nQq+7JV6Ht6YmntwXzJJt/nO7qmFUipMWNXpPodrkk6t2H1fR+Sas1ueJ0LFxV84slJ/uhb53m6lsOlW9ALUMo60pK0EbKa1ctM4+Q7kzhESJTIXm+tcGzDzuSJ0FrgGkA/aWeV73ps57bq/ch/gENvhVOfgQvfXvO00USI66lCW4o9umGim3Jlz3cors6wLtag3p7vO6o+7hZC/CLg3/SFLlzYsBO+18PBN0N0GB7/A/h/DsIXfgkufV/ZaRzEsqUo9UX85Tm17H9E3c68XPM1ibLy3fyoHHtz72niQmNbz9/gO9ma8m2UHP99urhBce5rlc/T11v6Vj7D+pus98ASH4PUVeLhzirf2aL6WXFptcBsaDtHKd8h9d5P5TurfNu287m0xuXFVe95W/nOLbTcMtA0rKTzC9aYsSO1bOdQJt/7dGWVX3bJtwsXZRyb/xp/7P8vPPqjiW4vRcHQVRilNNsegJvW1F7QI7MQ6FHjuupEaVD1AuvXa5/ZGkU5ELdsO2+u5xss5dvJnu96bOeTT6jb3Q/AT/xndS3+yr+B0kqL+Ug8RK5okNacv57ZBYcVaedNWM5vFtSrfH+x6uPTwDuBn23XolxsQ9jK93oI98K//CG89T/D4AF4/hPw8bfDf7kDvvmbMOdMhdM+/CUigQr5PvTj6nYd63lvJADAUrZ123lUWhbdenu+AcYfAl+IN/tfaE35/pt/Ap/6QPOvd7F9cOZ/Vj5PtWYxLJPvepRvgMQYJK8QCyry3SnLpU30Y4ZNvjcYNQaQWyzbzjup0NuhkH6vUgyenlisfnDlWES7/7vTsPbOU5kYIb+H8YF1/u+HDoM3wFhBqfRu6JoLFxXck/kOb/f+iOdePLU1MhEKycrn10629UfZynfUTNc949uGsBLPffOnHVlLwSaOZeW7efKtlG8H084torzuqDEplfI9fExdu3r3wMP/HhYvwA9WRnONxIMAzLah79sm3yuU7ybC1m4W1Nvzva/q46CU8ieklM+0e3EuthG09OaEMzoID3wYfuE78EtPwUO/qiqw3/99+JP74NGfaXkZlZ5vS/n2+OEWa2reOqFrds93K6qNbTuPyiaUb38Y9r2WO83TLC8tNLeA5csw+fiGwXIubhIUc3DxO7DrPvV1i8p3wGyg5xsgvhP0PCP+HIYpy4WpdsO270WsGeObKt/5ReLWgaeTdum0pmOYklftV+tY0fedvg56HnpG1dfd6vtOKeX7qcUwh0fjeD3rWAu9fhg+ylDmjHrZViAYLlxsEcR0ZTffaV7ji89f6fJqwKhy0hhX20u+7f04bKQbOw8B4bFjGFIQWTrjyFo06xoUlAV1JmxAhS/Dum4MeFKO2s5tlXpd5Xvpkmod2/vqyn0P/hIMHVVn56oC7Wh51rfzfd8rxumCpXy75Hs9NNTzLYTYL4T4iBDi7e1akIttis1s56sxdBje+BvwkRfhZ7+sqnqn/0FZp1vAUtl2binf8Z2Q2KXGC61Hvss9383bzm2CETEt8t3opnTwzfjQubN0srkK+bmvq9tCl2cDu+g+Ln5H9fXd+m516Gmx59tvWFX0um3nuwDY5VEHvU5Zum0FIVRaVges9Zw4YWvkTZXtvJP2eNtyfnRHnLHe8MrEc7vf++Ab1W23Es+T00gEp7Mxjo5uYi0cvZ2wNscgSZZbaN1x4WK7IWGq9/YR/yyffOpy14PXMstz5c+16efb+rPs/Tiop+tPOrfQn0gwIUfpzTiTe2GPgg3KYvMBYRb5HvRkOpt2Pmn1e++piuHy+uHtfwhGEb7yq0odpzLrux2J52uVb9d2vhE2JN9CiG8IIe6yPt8JnAB+HPioEOLfd2B9LrYDjJJSaxqxWtvweGDfa2Hfw4BU48FagE1cy4FrvXtUIMTIbYp817j42eS7FVtYuSpoWGOOGqz0ckAdtl/neb65vu9zj6lbLaX6ulzcvDjzVXV7+C0Q29Ey+Q5I60Jez5xvULZzYATl4uhUmJl9iAkWl9VBab0gmBW2c0v57qDt3HbnJMJ+7t3bx7nZTKXwZ/d73/J6QHQvdC05TTE8RAnf+mFrNkbvBOCoZ9K1nbtwYUFKSb9UNu9HhtKcvpbi1JXkJq9qL7LLlWkzvtlTNc9Djv0sTQckAb1x23lfNMBZuYsBbdqRgN6CZRMPSM0h8u2g7by4Cfmesvq9q5VvgL0Pwt0fVMX2F/8eqJDvmTaQ7xXKt15UBX6XfK+LzZTvMSmlXf76APBdKeVbUUnnP93WlbnYPmhh3l8Z8R3qtsX+VPsQm/AWlAqcUCocI7dCMQ3LU2tekwgHrNe2bjsPlsl3g4WI/n2kevbxOu9Jri7lGnttqQCXvlv5utDdC7yLLsI04ezXYOgI9O+3yHdrtvOgafd899T3grgi30PmPACpDqnKGavH0K8trW85Bwgm1IiU3GJV4FoHyXe+4s65b1yp8M9MWuq3rXwPHVGFw26R79QVln3DABypQ/kGuFVMbI2+VhcutgAy6WUiVsDX7WG1F37q6csbvaTtyC+rdeh4CWhLLZ+3NkJG04lSwCONhpVvv9fDpHccD2bLozKhQhz9ZqF58h1S140BhwPX0vUo3717lYtzNd70m2p6xz/+H5BfZjTRPvK9Qvl24sy/zbEZ+a4uKb0a+CqAlHIJcOWz7Yorz8KjH1S9oU7AJnut9H/ErI2lxYvBUq6E1yOIaZaCXk2+oab1POFEz7fdU6Rbm1KjyjeQ2fUIO8QiuekXGnvh5A+glKuQo/wWGmviorO4+ixkZ+HwW9XXsR1QzKw7Zm8zmKYkRKO2c0W++w1lceyUqpyx0nU9+cX1w9ZAuW3CfdaoMTtwrXOXu+pxiMfH1TrLo4hs5btvHAYPqn6+Tk8wMEqQvs51VAHjyGbK98ABAHaJOVf5vkmwmC3y4O98k79/ZrrbS9myyC5Wip7x3BS37ozzpeevlu3Y3YCWVm6knFTBXFxv8KzRALKaTqKZ6S8Wrof2qU/WmVLTCGyy7De15saMgXJSRQasOd8dGjWWnlHBant/rPaLI/3w5t9S1/xv/UcGe4J4BFxPtln51qxQ02bcrjcJNiPfphBilxCiB3gYqJLPaPIv1MWWx8lPwekvwdXnnPl+TrwR7apeixbZZK5Eb9iPsEbl1EO+Az4P0YDXkZ5vv24p38HGLzbew2rkWOzy2vmNG8Lu9z76DnXr9n3fvLAt54ds8m0FdzWpfhcNkwgaJqJ+xcCynceLyuLYqX7qrGbgxUAUljdWvkE93jXbudpnesN+Do3EiAV9nLATz5cuQc+ICrcbOAiGptpnOonUVUByodjLWG+4XJxcF5F+pPAyJJKu8n2T4IkL81xLFvjiyfYppzc68otVZ5mlCd5/7w4yms5XTrV2xmkFes4i31jk+1obyXfRICFs8t2Y8g2w1HNQfTLbeoisTRx9rSjfoMh3G9LOgz4PAV8Nula2nD+49jEbd31AkfOn/xLv9ecZigWZSTsfuOYq341hM/L928BzwDng21LKswBCiFcDE+1dmouuYd5KkHTKclSwyHcThLOMsu28tUTQ5XyRhN3vDRXyPXQUEDBzqubreiMBR3q+fUW7ENH476Lv6OvIyiC75x9v7IXnvg6J3ZVADlf5vnlx5h8hMgi7jquv4605SmzyXfKE1u+hXo1AFEK99BSV+6RTPd9pTWc0UEAgN1a+QT2eWyDs9xIJeJlNOX9YWQ/lnu+IH69HcM/ePl6YTqo9ZPES9FmKz8At6rbTiefWHnw6G+foevO9q+HxIqKDDHmSLRUwtzv+7kdTvOuPHydXvPFNhXZI4ImJRUpGh50Z6yCr6fyPJyfRt8h6iklV8MwH+sHUedc+k5Dfw6eeWtv61inIrPp/KxBEx9NW5Ttd0IljuSsbtJ0DFOPjaNKPnGl93Jjd8+0zCuBrgXxHB0lIZ9POMwW9jrC1V9d+HNR1+Q2/AUg484+MxkPMdEr5dtPO18WG5FtK+TngduAtwHuqHpoAfqF9y3LRVdgJui0S3TKsKpju7+HZqSaJX8wm361VhZcs5bs84zuxW90GIuowu07ieSLsb7nnO+T3IFpwAQRCYU547mBf4UXI1jlybOECLF6Eg2+qpDjnXeX7psTSpFIJDr0FPNY4kFaVb90kIgoUPQ0eWOJjhHPqZ3ZO+dYZC1iHvXqU7/wSQkr2DkS5NJ9t/wItLJdDIVXWxH3jfRQNk9OXLkN+Efot8j1oKT+dnvVtuYamzX6OjNa5j/UMM+Iq3xvi8fNznJxO8oXnbny12M4oyBUNXpjeGtebLzx/hf/zCy/yjdOthbY6BT2l9r+lgXsBiGWn+Inbd/Ds1DJnZ5prA2oVwnLFeX1+LphjyDbO+s5qOglhZ+A0Tr77Y2HOyTFMB8an2mnnXqNV5bufHplBLzq3z6U1ff0Z31NPQHSoUohdD6O3AwLmXmEkHmIuo2GYzobp1Va+XfK9HjYdNSalvC6lPCmrZiBIKa9KKbtXnnPRPmjpCul2Svm2COcPrxR59399gueaIeD+sAqOaMF2LqUkmStVxoxBuf8UUNbzhQs1e917I/6Wbedhv1f1v/tC4As29X2eiT2CFxOe+5v6XmBbzg++uVJddpXvmxNn/1HdHn5L5T67qNXk+6qo28p3gweWxBj+3HVAdizMLFPQ2eG3SPRm5DvcB9IALcm+wQhXk/lyZb/dsIt8fdaUhXv3KpX+/JkX1RPKyrfqpe74uDHLNXRVDmyedG6jZ4QBll3lewMsZNTv5uNPTHR95FQryGo6L19LMRxT17gfXqizUNxm2H2uL11NdXklFjKq7SYzep/6evEC779/DwCfeqo7wWt+bQkTQdDv40W5F5G8DFWzv52EIt/N93wPRAOckbvxZq61fKZRe7vEa+Rbtp17kAR150Jts9o6ynchCddfVI7GzVxngQj07YW5M4zEQximZCHjrJtrpfLt2s43Q0Nzvl3cBKhOjnRK+bZs51NZtYGcm8k0933iO1taU75kUDRMy3Y+rQ7YwaqE5pHbAQlza21MvRE/qYLedLUwXzIt8t3gvPNVmBx5I7OyF/nUx+obGXb2a+ANqHFtZeXbJd83Jc58FbxB2P9I5T4HlO8wGnqjVr34GB5DY4BUx5TvjKYz4quTfFeNGxsfiCIlXF50KIByEyznigS8HrVfAHft7sXnEcxffkU9wVa+YztVOFCXbOeKfNd5uIoOE6JIKdcdRe9GwGJWke8zM2mevNgewtMJPH95GcOUfOjBvQR9ni3zb7FbR17eIuTbk1OBk8auB9QdCxc4vrePW4aifO65aUf7hutFQE9h4CHo8/CyOa7uvF67Fa9VZDSdXpt8N2E7H+gJcsa02gZnW7OeF0omQawicLOBa1C+rkQN58h3RtNrh61dfgqQ64etrcbQEVg4z86Yuq44Pet7hfJdDll2yfd6cMm3i5WYqybfTinf6o14paBslFPNHmJjO5TtvElVoJwiHA4o9cbu97axYeK5WnuzKl2haBAKWMp3E1VeG3uH+/iE/kZE6kolPGs9aBmVdD7+ULnPVi1ma9gAXXQQhSRMPK6KMNUFp54RQEC6hZ5voaF7G1e+AUbFYufmfGs6Qx6r8Ldpz7dFznOLjA9GATpmPV/Ol0hE/AhLzQgHvNw2lqA4Z9nLbeXb41F2wy7YznV8ZPx97B2I1veaHjWWLFCYu6FV3XZiMVtkpzUK6ONPTKx80CjBy1+EYufaH5qF3e/94C0DHB/v48TkYleI5GrMphXZePna1iDfvvw8hhT4d96h3HCLFxBC8L/ct4flXImvv9R5e3xYT2Hiwe/z8JIcV3e2qe87W9QZ8FkEsBnbeTTAGamcAuu1C9aLQskgjKUEt6h8g8Pku6ATq0W+J3+gbjcKW6vG0GEwS+z3qqLPjMM5Jpo90ada+XbTzteFS75drIQdthbqdbzn+3JWVdyaJt/xnSrdt0nldsmyPPaHPaqwYPd729iAfPdGWhs3Vrada6mWyPfDh4b4pPF6DOGDp/584ydf+h4YRTj44+prV/m+eXH+m2DqlRFjNrx+1TPWSs83BQxvg2qB1e6xx7vUEeVbSklG0xkok+/NbOcWOc8vss8i3xMLHSLfuaLKpajC8b19DJes1gBb+QZlPU9edm4sZD1ITXOdfg6N9uL11Bmy1zMCQL9cJlvsPhHbajBNyVKuyO27Ejx8aIivv3ydK8vWpFcp4R8+Ap/+EDz/d91daB04MblIwOfhdt9lHtoTpVAyOXnZOTLSLOYsm+21ZKHsMugmgtoCi8SI90RUQc0qor37njH8XsGnnu58Z2fUTCOFl4DXw8vmXnVnmxLPM5rBgKf5wLWBngCvmNYZrlXlWzcIYf1NtES+BwFIyJQjwX6artyaNXu+J3+oXJQjt9X3zYaOArDbUH9XbVW+3Z7vTeGSbxcrMX8OhFdZWTKzoDtwkbJs55OW7fzyUgvkG5ouCiQt5XvUmwKztFb57t0DgVht8m3P+m6yZ3FFz3cL1cC7dvdiRIf5ru8hmPj+xhXfcr/3m9RtIAoenxu4djPizP9Ut4fesvax2GjTPd9aySCChtGE7Rxg3L/UkTFemm5imJJ+YR0K6glcg7LtHODSfGcIbjJv5VJU4fh4P3vFDCVfdOXaB6zQtcWLHVkbgLk8zRWzn6OjDVgKLeV7ULiJ57WQzJcwJfRHg/yzV49jSvjEk5Pqwe99FJ77hPp85sXuLbIOGKbkuallPjB0icDHXss7Cl8Etkbfd/XEgtNbQP0OFxeYlwniIb9ysCxPgVFioCfIm4+N8oPzC0wtdK6oJg2dmMwi8eD1CIxAnFnvaPuUb02nz2v9+5oQJAZ7gszQR8Ebg9nWZn1rJZOwcIJ8q6Jtv0OzvrOaKlSusZ2XCnD1Wdh9fyU8dTMMHQZgWJsAcDzx3O35bgwu+e4AvnTyKr/y6POYDqcLtoJvvTLDYy/XsDXNnVHKSt84ICHTnCK2Albg2vmU+nNruneyxcRzW7UeYV7dsZp8C6HU75kX11jb7cNws8p3oWgQ9QPFTEvKt9cjeOTwMH+Ueb26Yz31W0o49xj031JJwhRCqd+u8n1zwdBVIWbHnWW79wrEdijluwk7cLGYxydMzEb75Kz33h5fZ5Rv+2ckpHXorrvne4HBngA9QR+X5pvMqmgAUkqWc8p2Xo3j433s8cwy49uxMlynnHjeob7vYg5PYamxsDUok+8hsdzS1IjtigVLiR2IBnj40BDjAxE+9dQUxWc/Cd/+LZVWHEqo6/MWxpnrabJakQ8XPw7ADv0KYb+XH16c7+q6DFMyn9HKIYZboe+7R19ikV5FVvr3q4DHJVVwed99StF99ETn1O9MagGPkEjhRQB7B6K8LMdVDlAbnDUqcC2nckiaILz90QAguBI+CNdOqja7JuG07VzN+m6dfGes69Ya2/mVZ5Srce8GI8ZWY/AQAImMcljMtFX5tkeNueR7PbjkuwN4fmqZzz93hckOBfZsBikl/+6zL/CRTz1HvtoCqBeVgjJ4uOX5vytQSCF9YXK6+nObzxTJak0cuO1k8ib7U23b+aCuUkbXkG9Q5Du/tEYJtA/DySYPjvmSQa/X2uxatOK84egwz8sDzCdug5OP1k4jnX0ZUtMq5bwa4T635/tmw+Un1f/54Z+o/Xh8h7qQN5FqaxTUgcf0NWo7V/vLDs9iR8i3vd/EZUr1V25WLLDJeX4RIQTjgxEmOqB8ZzQd3ZRrbOeDIdgpFjhfGlr5AruwNn++7WsDVoStHWlI+Va28yGR7Fi6/Y0E2wbdFw3g8Qg++OA4RwrP4/3yv4L4LvjAZ2D4mLLXbuGe+WcmF3m750l2ZFU4oDd7nePjfTw7tdyxaQG1sJgtYkp4zUH1/ul633cxR1jmSXmtVjD7fbyoiNFDBwYZ6w3zmRPTHZtLnl5UvcC2krpvMMozxd0gzZaV5VrIFHQSZJuynIMSRISAp8KvgVIOTn+p6bUUStW289YD1wZE2pGcg4x13VqTdj75hLrdaL73agR7ILEH38JZwn6v47bzNcq3x6+utS5qwiXfHcA9/RoPeU7x0tXu9z0BTCzkFAEuGnztpSple/Giqr4OHmzZ4r0CWhrDr0KeAl71Jze9lG/8+8Rt5bs58l0OXCtZiv/qnm+o9H1fX2nva8V2XjJMdFPS77H+zS0o3wCvOTiI3yv4e9/bQM9XLInVWG05txHqdZXvmw0bWc6hpXFjpqb6oGWjBxZrdOConO+I7bx8iDGS6oC02WiWcEX5Btg32MP1VGFlsbINKO9Rq5RvlqfwIHlFG2S2+tBkjxtb6BD5tsaMXZMDHGlE+Y4q0jNIsmn30HbGYpXyDfC+8Sx/5v9DCgSQP/1pde0bOqyKaNaIqq2I5yZm+TXfp5GBGPSMQvo6r9o/QFE3eW6qe0VfO2ztwHAPu/rC3Ve+s+r/MOu3yHe/Rb6tvm+PR/C++3Yzm9b4/rnOuAbSS9bflUed0cYHI7xoJ547PO9bSkm2qNMjM02FrYFyAfZFAnxdPKQmurSQh1AoqeBQwBnlW6TRSg4o39Z1a43tfOoJ5RgYu6exbzh0GDF/jp1xv/PKt/XvDfqtnu9gbPPr7E0Ml3x3AK+Z/GM+EfgdLkx2Z3bjapyYqChcf//sdOUBO2xt6HBFZXZC+dZSFH2KfN+xSxHPpkLXYq2R76R16OspWAWHmsq3FV6xqreutwXbed6qCPaWyXdryncs5OeBfQP80cxtyMgQPP0xMFeRgnOPqQru+EMr77dt51tYPXHhIKRUqfixncp2XgstjBtrmnwDJMYYNOfJaHrbW3LsQ0xET26edA6WGiPKboB9A+rf1+7QNXuP6l3V883iJQAm5TAnJquKZ6EERIc7ZztPqmKsFtlBYpU6vyHCfZgev2s7Xwc2+e6PBiA9Q89n3k9UaPy89hGeyVvXPSswiblXurTKzbH7wqPs9cwiHvqIKuKnrvLgLYqQ/PBi9/q+Z9OKWA3FghzbEef8XKarSjwZpTLnA5bDZpXyDfBjB9Rj52fb3+4CkE8pki+EUr73DkR5qTxuzNm+73zJwJRY5Lt5MWIgGmAqH1Curonvl237jaKgG8S81t9Do/kl1QhEKHlC9DtlO9esM2t14JqhqzFjY/eCL9jYNxw6DIbGrZFlx9POC5bSH/JZ2Uau5XxDuOS7A+gZvxeAwtSzXV6JwjPW4e3O3b08fn6e63bwgj3juw2287xHhRbdt08dfJsi3+E+tTE2GQ61ZB1wQrmrKnjMskKuwMgxdbsqyKycdt7EwbFgqWVxe6Zlk5Xearzh6DBZ3cvFve9RQS1nv1Z5ML8MU0/C/tet3ZzDvcpiXGrCeeDixsP8OeVoOfzW9avQMeu93kQ7h2mPPgrUOXKqGvFd9BrzIE0yxfZaz+3euVBpefN+b1DWy3DFJWKPG5to87ixdZXvJZt8j/D0xKr2gMGDSvnuQEFNX1YF5OjweGMvFAI9PMSQSJYLDC4qWMyqg/BgoAR/915ITjH3yEd5wryNv7bHjlmBSVuVfM/MzvGh0qOkfAPwqn+piuWFZW4fDhANeHmyi6Frcxb5Ho4FObYzjmFKzs10htTWhKV8ayGVjk1shyqWV40NHOxR1+75jLMkaT0UbPLtVURv32CUWXrJ+fsdTzy3i6FhI9O07RxUsWohW4S7PqDueOHRpr5PoWQQ9zkQuAYU/L1K+XbEdq6+xwrb+cwplR3USL+3jaEjANweuEYyX3K0AKWVTIQAv1co5dsdM7YhXPLdAXjH7gYgsnBqS8w4fWZyiZ2JEP/ydbcgJXz+Octabs/4HjxoqWHCMdt5BrWh3T+uyHdToWtCKPtds7bzfAmvR+DLXFHKfq2UyGBMhc2tIt+JFmznBcuOExMW4XVg/MLrj6gAo0/JN6lCwo/+W+XBC99S7QOrLefgjhu72WDPgl89YqwaLSjfWMq3aIZ8J8bwSZ1Bkm3v+85oOn50/HqmPvINynpu2c7Ls77brHzbuRS94drKdzK0q1w8LWPggFIasu23p6ZnJp/Z8k0AACAASURBVAAYHNvf8GtldEilnefdtPPVWMgW8WKw/7v/Gq49Dw//OqMP/3MeOjDIP754XVlErYPzViXfyW/9PgMizdmjvwyBSHlf8edmuW9fP89fXm5728Z6qJDvEMesdomXr3WvDbCUVHutHrYyHIRQoWuLa8m3vfZ2w8iqop6wzkVqyoNgOnhA9Xwbzu3RWc0gSBG/LLYkRgz2BFnOlSjte0Q5gE5+sqkiZKFkEvNaRcFWer4BLdDnnPJdqNHzPflDdVvvfO9qWHvIAaHO9U5azwu6QcjnRQiLfLtjxjaES747gdHbMBHsK10o25+6heVckXOzGe4d7+eRw8P0Rfx87tlpVRSYP6NUsFBczf/tGWld+TZN0FKkpNrQ7tzdi98rWkg839m87TxXojfsRySna/d72xi5TbkA9Mr/VcjvJeT3tGQ7j2Mr3631fIOyhB0Y7uELF0zk0XfBpe/CrHUoO/eYuj1Qg3zbFzo3dO3mwCtfAX8Uxl+z/nNa6PmWpRbItx26JhbbHsKV0XR6qXPMmI3IQJXtvEPKd34D5dvjZ2zvAV66mloZWFnu+26/9by4cJmsDLJvrEZq/ibwxEYYYpnkFpixvNWwlC3y896vELr0GNz5AXjdrwPws68eRzclf/vkpCKzoURln99KSF9n/Oxfcd7cSf9DP6fuq9pXXrV/gKJh8uxUd4q+dk7CkKV8Q3cTz7WklTsTrQpQ7N8PyenyuSMa9BEJeMvzydsN0yLfHkv5tqc8nGYf6IWKM9IBZDW9ch5qUfkGWCqYcMd7lcvr8o8a/j6FkkHMY5Pv1pTvUrCPfpFyqOe7hu188gcgPLDr/sa/4ZBKPN+lW7O+HRw3ppVM1e8NKu3ctZ1vCJd8dwLBGOnoXm4Vl7oeumZf/I7v7SPg8/DOO3dybjbDqeklZVG1R9eAOhy3Sr6LGUCyZIQI+T30Rfzs6os0Zzu311RYbso2vZQrMhLWlepbq9/bxsitSjleNdalNxxoynZuk++otGdaOlMRfMPRYebSGhf2W5arp/5cFTvOP6aScXtrFBhc5fvmwcQPYPopOPZO8G+QOhoZUMmkzSjf1ggaT7AJtSCu3oM7xEJHlO+6Z3zbiFjKt5T0RQMkwv62J54nLeV7TT/14iXo3cPxfYMYpuT5y1XFs/K4sfaHrnkzV7gqBzm6s/E9zBsfJSAMStnGU/W3OxayRe70Wf2qb//DcovI648Ms6svzN89NYVmmEq5mtuCieff/T0CZoH/6vsZ9g1bxeV4hXw/uN/q++6S9XwuoyGEIpRjvWHiIV9XE8/1lNprRayq9W3gFpUsvjRRvmsoFuyY8m0X5D1epXzbUx6eLlhnJQf7vjOaTkK0LkYM9CjyvZApwp3vV3c2Ebym6SZRjzPKdynYR1RolAqtF2rX2M6lVC2Fo7c3d44MJSC2k6GCclI5mXhuK9/ommptdMn3hnDJd4dgjNzBPs8M5yYd6KFuAScmFOm6d68iYe++R22s33zyWTWuwe4rA0V009dbsxtZ8/7mS0FG4yGEEOzuj3B5KdecBb+FxPPlfIkDQav4sRn5hpp93830K9pWu6h0TvkGeMMRdeH+0sJu2HEXnPyUUsCzc7Ut51BFvl3le1tDSvj2fwLhhdf+242f6/EoVa2J95Swer49zVxorZnjO8UC6TYnnmebId/hfjBLVgFRWc/bbTu3i3t90SrbuWkdyPv3cdxq27H3caCifM+3WfmWkh7tOjNigL0DjTsdPNasbztsykUFi9kig96csmpWFcq8HsGHHtzLfKbIV09dU+Q7v6T2+K2C+XPIZz7OM+Yh0nvfrGynUBWQeo1bd8aJBX1dC12bTWncEsnj+97vIopZju2Mc/pauu1Bj+vBTM9iSoGvZ7By56rEc1C26vlMZ5wiPk3tKR5PRWXdOxDl8ayVCeJg37dSvm0xonnle8Cy5i9mizB6myKlL32+YXGmUDKIOKR8GyG1R8smRneuxhrb+fw5yM03NmJsNYYOE8tcRGAy62DoWln51qzrrGs73xAu+e4QYlboWnayu6FrJyaXiAa85Rmtd+xKcGC4h3MvW+saPFR5cnxMKcDZFkabWG/E2WKA0YQ6VOzuC1Momc3ZqWLNBcFJKUnmSoz7rA1xQ/JdO/E8EfY32fOtyHfYtA7uDm1K9+zppTfi51tnZuGBD0MpC1/61+rBgz9e+0W2xctVvrc3Ln5H2dPuen8lSXcjxEabUr5FyVa+m7GdK/K9Q7R/1ne6oNNXtp3XkXZe/Tx73NhAhLm0Vg4LagfKtvNq5Tt9DQwN+vZx284EQZ+HE5NVB7u+cZX7UHVobwvyS4SkRj48itfTxAgZK+DSl99CxHGLYDFbpE/UHrv03uO7Cfk9/PUPJrZm3/c3fxMhDX679P5ycQioypK4hs/r4f59/Zy8vLyyZaJDmE1r/NPAj+C7vwdPf4xjOxJkNJ3LS+11sqwHkZtjiR7i0SqiVyPxfKgnyGJWw+hAkSBQTJInWCmeoNptJuWIGhXbLuW7Bdu5PZqvHEp3108rweeVrzT0fQolg6jHDlxrbTa1EbaKu/nWMzjW2M6nrPnezYSt2Rg6glfPMybm26N8W4Kbq3xvDJd8dwj+3WoeX2DO2dTIRlAyTE5eXuauPb34rHnbQgjefc8Yo0XVA7JG+YbWrOcF9Uacs5RvgD39ytbTVN+3vaYG+1NzRYOiYbLLY1XeN+r57htX1qM148aU8t1otdy2nYcNK13VIeXb5/XwukNDvHglxfXdP6EUveQUBBOwe51+IFv5dnu+ty9s1dvjh9f+u/peExtVRbYGXS5CV+9hX7Cn0VVW9XwvtH3Wd1PKd5l8K6LbicTz5VwRv1cQCVSFQVpJ5/TvI+DzcOfuXp6dXEI3rJ5Cr1/tWW3u+V68Zq0jvkHhciNYynew0Jm5xTcKpJQsZotqGkYNItIbCfCTd49xcjrJeWFdt7ZK3/flp+H0l7jQ/zDPyMMcH++rPFbu+VZFvVftH0A35drAwDZDSslsusBen/Vzn/7vHNuh3svd6vv25eaZl4mV7SW1lO9YAFNWRtG1E2EjRUasJEzjg1EkHlKJw4p8O9TukNF0Eg5k4Njku/z7uf09qhDZoPVczfm2yXdrtnMZVtcN4YDynbVs59GARb4nLfK9p4mwNRvWGf+guOIo+S4r3wWXfNcDl3x3CqN3ADBWONe1USsvXU2h6Sb37l2p/Pzk3WMc8Fip5oPV5Nue9d1C4rlVBUsTYTShqrwV8t3EuKsmCwK2orQD6+C3kfLt8cLw0bW287C6EKYbrNzbtvOQkQEEBJogKuvgDUeVmvSt8ym495+pO295RB3IayHkKt/bHuceg+mn4Z4PQd/e+l4T26H6DRu0s3pt8h1uQvn2BSmFBjuifGe0auW7gcA1gLwVumaT7zZaz5dzJRLhwAr1yU46p28fAPeN95EtGrxyPV15zsAB9TwHE4lX4+qkIveRoTr/plbDIt+Roku+q5ErGmi6SczMVIqjq/De44p0f2vO2r+3gvItJTz2f4Hw8OeBDxLwebhtrIpI+YKqdcMqlHdr3ndG0ymUTHYI6+cmp7i/+DRA1/q+A1oN8t0zrM4GK5RvJVh0ou87aqTJ+Va68vYNqrPadPCgmqiw3Nwc7dXIruj5bsV2XtXzDRAdhINvhovfhlR9Ao2UkoJuEMaZUWN20dabb518pzWdSMBbcRpN/RAGDkLP0MYv3AiWe+bO4PVyEKET0MrKt3Vdckhk2q5wyXenEO4lFdrF7eJS16qtJ6z5sMf3rrzA70iEuSc8S1JGWRJVG6EjyrfqsU7LCKNx1Z+z2yLfTYWuxZrr+bbt4oOGRS4Sm6T1jtyqiEimYrm3E4iTDYau2cp3wLBmH3qce9u99tAQPo/gm6dn4P5fgLHjcPyfr/8CN3Bte8NWvb1BeO2v1f+6skrV2PuqTL5DzVW5zfjOjijfC5kiO/zWYa+Rnm+oJJ7b48bm2ki+8yX61pnxTb8i37a194kLVSR24IDqT3focFwLS9fVOgZ2Nj5mDCjbzhPmEkUHxvBsFyxmi3gwCZvrzzy+bSxByO/h+zN+1ba0Kgy0Kzj3GEw9gXn3B/nKtTh37koQ9K0a3xnbUSbfR3fEiYd8HQ9dsyfMDJnzavKDx8euc5/A7xXdOYuVCgT1DPMkSFS/1+1xYwsXy3cNxlbZqtsETTeIk6G4inzb2Q5nxLi6w6G+74xmOJJ2PhBVZ8qFamfAne9XheQ6Z34XDRMpISys33GLyreIqj5+b8GJnu9Spd+7lIflKdXX3gos5fuY/1p7lO9yz7erfG8El3x3EMXh29kvrnFmqvGRPk7gmcklPALu3rN2s9vHVS7IHXz5VNXayuS7FeVbvREzhMvKd0vku2dEjVlokCTYhLmvNKMqrZttDCPWBldlPbcvlI3OqbV7vv2ljLKEO4hE2M994/08fn6efHAIfv6bsP/h9V9Q7vneGrbzM9fTbe2hvenwylfUnODj/7zy/q0Hqyyi9cKrK/eKL9ycm0PEdzHCEpl8ew+Xk4tZxoKW0yZcb8+3RdJX2c7bGbq2nCutHTNWVr7HAXhw/wCxoI8vnazaA8vjxtqXeK7Nq9aksfGDmzxzHVjK9yDJrrm/tiIWssUqIlJb+fZ7Pdwx1svzl5NIO/G825j4HgAXb/kQGU1f46gDVEBq+jpIidcjeGD/AKeuJDu659uhUr36LAwegCNvx3Pp27xuINkd5dtyF83LBPHQqvf6wC2Qmi4Hhg11aNb3YjpPgiyl4Mqz4UA0QCzo42nNandwqO/bKeU7Efbj9QgWqosTh35cvY/qnPldsEaChdCUZX0912Cd8ETVdcOvtS5wZDWjQr6T0+q2d09r3zTSD9FhbmGamZTWXPBxDRR0QxXf3J7vuuCS7w4iOn4vHiFJTTzX8Z8tpeTE5BKHR+PEVm/4uUWCxUUmxC7+/tkqot2kyrwCtu1cRsqBa4mwn0TY31zPt9dnzR9vrICxZJHvWHFm435vGzUSz3vDqgrd6Lgx23buL6XaYsV5w9FhNN3khxfrsHN6/cratgWU7zPX07z1v3yPP/5W+0ck3RQwTfj2b4MvDA/9SmOvrQpHagReQx0SA6HmyLe3bwyfMCE909Tr60GhZDCT0hj2ZtXffr2BOqsC1+IhPwPRQNt6vqWULOeKJMKBlQ8sXVJ7sWWHDPm9vOW2UV68kuL8rJUj0YFxY96MujbEmrWdB3ooeYIMie6T72vJPP/m0yc70ku7GRazGr3C+n9ch3yDKpqnNZ1Uz371N5ntsn3f+vlPL6pi+mpHHaD2lVKu7IB71f4BDFPy9ETnxs3NZTQ8mES0OZVXcP8vAPAh32NcSxZY6vTfgBVgu8Z2DpW+b6vgNhhT5Lvdyvfy4gIeITFDK/8P1bixKD9YHlQZIg4p31mHer49HkFfJLBS+fYFVe/33CtwdfOAY80SR4KyqK6dLcJrWcKdIN8ZTa+ErS1buUytkm+A4SPs0icp6kZT43NXwzAlJUO6aecNwCXfHUR4jwpd8850PnRteinPXFrj3r01qoyWhS0wepSTl5crBzp/CCKDjgSupQmzI1E59O7uDzdHvkEdRBvu+S4iMAnnr2/c721j5Ji6rSbfZeW7Odu5t5huC/l+/RGlKH3jdJ2p9OG+LRG49rHvX8SU7Q2wuqnw8hdg9iW4/+ehen5sPSi7XBoj334jR0l6CQSaS4j1Wu/FYK59biB7n+kTqfqTzqGikFf17o0PRplYaE9CcrZooJuytvJt9Xvb+Cd3q7aZLz5vFUsHLPLdxnFjieIsKRGHQJO2TCHIBwYZEsskG3QPOY3PPXuFv392ms8/14KryyEsZkv0srkKaDvWLpZD17qsfmfnwRfiyWllXb23Jvle6aix530/2UHr+WyqwBDLeKSh2s32vhqGj/FA8mtEKHC60+q3NWpvUSRWBitCJfHcKqJ1SvnOJK2zQ43iz/hglOm0gTl0xDHl2047l8LbskI6EA2sLaKVZ35/ctPX28p3EK31fm/A1zOAKQWhYut/4+lq23nysrp1gnwPHSFo5tnBoiPWc023co1c5btuuOS7k9hxJwAj2TNlK3KnYI+mOV7LGjavyPctx1Rx4HPPTlcei+90JHAtK6IMWhcSUKFr11KF8pu2IcR3QmYGzPpfu5wrMUgSj1mqj3yH+1SVvMp2bo//STY4bkyRb4mnmFI93w5j/1AP+wejfOv0bH0WolBv15XvmVShTBxm0s71Hd20MA34zu8oZffHPtL468vKd2O2c7+RJ08Qj7fJS4n1XgznGx9zVi8mLbIcM1P193vDmrRzgPGBKIvZYluUWzuXYkXPd35JFcr6V5LvV+0fYDgW5IvPX1Xv+Z5hCMTapnybpqRfLpH0D27+5A1QDA8yKJKOqC2t4IVpVXz87tnujz1bzGpVY5c2Ur7VY8/mrcJat0PXsnMQHeLE5DK3DEVXzqa3USbfqrh2ZDRGX8Tf0dC1ubTGTjtsLb5T9Vbf//MEjAw/6X2889ZzS/nOBwZWBitClfKtQteGOqR855LKxeCLrj0fjg+oYluq96j6f8y0/p7JajoJTw4RSqj/jxYwkghxLZlfOYVm590qWOzFz4K+8e+uYJ1BA6Yz5DsYDDJLLzGttWualJJs0SAaXKV81+Pc3Ax24rln2hnybRcw3LTzuuGS704iOkg6OMKt4uLKpNoO4MSEIls1q9NzZwE4fOtxxnrDfP65K5W5kvExpYaZTQbkWBaUULR3xWzY3f0RpISry0288eM71fzxTP3zx5dzRcbsC3A95BuU9XzuDBjW7N1Ic7bzQskgRBFh6m1LgHz9kWGupwq8VE+ATLi36z3ff/3EBCVDEvB6mEm65LtlnPoMzJ+FB34Rog0QTBvBuAqaadB27jcL5Alu/sT1YE1UiGnts53b2RKhUrIx8u21wq1yFaJgp/+2w61h7yv2PgOsSTovL80jeNddO5lazPHs1LI6wA4eaBv5TuZL9JGi4F+fHNYDIzzEACmSue6+51+YVjboH11c6HghfDUWskUSbG47H4mHGOsN860F62+46+R7nlJogCvL+dpFfVhDvj0ewQP7BnjxSrLtIYs25tJaJencHpN3+3uRgRgf8n6dl68kO7KOMqxzixassRcNrBw3FvJ7iQV9zLWZfBeS6vcTiK1d07gVunY1bLlrrp9s+edlNJ0+kWspbM3G/sEohZK5kkQKodTv/BKc/dqGr7ff/wFZaDlsDSDo8zAth0i0SL4LJRPDlMTK5NtWvp0g3yrx/KC44kjieWGF8u3azuuBS747jPzg7RwUV3jlcvsOm7XwzOQSI/Egu/pqVPbmz4I3iKd/Lz959xjXkgWevFhVKTZLkGuyv6yQQsdDb2Il6dzd19nE8+VciZ2ijjFj1Ri5FYxi+UDbtO28aBDH+ne2aUMqjxx7pY6CRLhX9eA14BxwEhlN52+fnGT/UJTXHBxkNq01PDvdRRWMEnznd1WY36v/VXPfQwilfjeofAfMPAXRnOUcKNvd46X6C2mNYmoxR5CiSmZvhHyDUr9X2c6hPePGbPK9og90VdJ5Nd5112rr+QFFcjTnC7sLqSwJkUMPtUa+6RnBJ0wKye71K8+mC1xLFgj4PGi6yY8uda7/uBYWM8Wqnu+Nychde3p5Yj6ADPR0N/FcSsjNs4RSt+4dX+fvokaWxKv292NKeLpDv/fZtMZev1VstqecBHsQd/8Mhz3TeKef6Mg6yrDIdylcY1xUZEDt44vViedB5tPtbdPQM+q8F06sdbbYe94ZrCkHDvR9ZzRDuT0cECPsKRQXV0+huON9Kpz35MbWc9t27ndK+fZ5uSIHiRlL/P/svXl8JNd93fu9ve/dABo7MDOYjbNwhjMiJYqLRFmKbMfWYkty7MSSndjSkx07jp/s5DkvsbO8LEr8Xux4SWxL8r5JihTLViRZ1kqRIiXuM1xnOBsGmBksjW6g96Wq3h/3VncD6KW6uwqgJZzPh58hwUajptF96557zu8cKv2PKGXL8n6waeY7NAK+Pmo9t0KR78NikVvrgx/sbFK+61Vje+S7E/bI9w4juO9OPEJn7crTO/Yz14tVXlrKctf+4e02J5C285HD4HLzjlfJm9MnnlDW8wETz/XSugpb27yo7Rsk8dy8ph4SzzPFKrMuU/m2eHI4cbv88+UvAE3ku4+qsYRr8HCRTrjrwBDRgEdWjnVDcAgw6iE4O42PPXadjVKN973uIBPxADXdYK1HK/8emvDMn0mSdu9Pd1TOuiI61XOLgF8vURyQfOsIRjTn7L/XUnkZtga9k+/g8DbbOcAVJ5RvNQe9aea7jfINcHIqxuGxCJ8+d5OqpjfmvlOXtj12UGykJWHQg324KprgjslDwtrGzh4+N+O8Ur1/UHVnf/Wl3bWepwsVhl3qPtjl83t2NoFhCLLRw7urfFdyUCtxoyrJd8uwNWi6VzcO9e45JAneTlWOLWdLHPQp8h1rqhh99XsBeOPGp3bW/aBs50a4xQiHEDBycNNneDTid1z51tUaF4pvPxAwye1TlRlA2DL3nS/XiBr5gZLOTdQrIFdzm/9HbBIOfgdc/HxHq7z5u/fYRL69bsEtIXN46nPafSBfltcVbp75tmPeGyCcRA+OcMS1aMvY3zbl2+2TwXd7aIs98r3DiByQc9Xi5uDWHat4+noGw2hjOa8UpJ1l9Cgg54fP7kvw2WdvkS/XGjerPkPXtOIGWSNYTzo3YZLvhUHIdw/hUJlChTmv2kRbVb6P/l3593/w/4XCGkGvG5/b1XNYULGqk/Som6dDp4Fet4s33DbGMwvrLHdbTM0b3i6ErtU0nY88dIVkxMf3n51mPCbfF0s29k1+W6FWga/+sty03/0Tgz1XdELa9KrWfxd+o0R5EPLt9rLhHmbMSFHTnOl+nl8rcCyuPrNWa8ZMhLaQb1P5dtB2PtRsO++gfAsh+L4zU6zlK3zt4oq0nYMj1vNCWpJlVz8jDU3wxaUSavTosLATzyjy/a47ZxiP+fnqBedcF1aQylcY95o1eF3It5r7vu7ZJ2eu8zvbmV2Hqsu6VAgyEvbVCdA2hEel+ti0fzg6HmEk7Nsxx8FKtsyMew0QDdccQPIwVxOv5c3iMa5e2bnGDT23TMYIEwm1sTiPHIbcLShLMpmM+kgXKvKArRlP/xlcedCei1IZMJHEdvI9FPISC3h4KW3IHnIblO9SqUyIoi2287ry3WpNPva9oNc6pp7XybdWtIV8CyEohtUeNdM/+c6VZB1fxO+R9/nsTXvmvRXE2G0cEYssZYoDP9dm5Xtjb97bAvbI9w5DTJ0BYGTjBcc2m1vxhKr1aEm+UxcBA5K31b/0d2+foFjVeGYh00R0+yXf6+QIbSPfU4kgQvRrO+9djc8Uqsy612SPo2mF6wZfCP7Ov5Uk9Sv/CSEE8ZC395nvikbSoxY4h5RvgDep1POvdFNyzA3eLoSuffbZWyxmivzIPQcIeN2Mx+TpqNnFuocesfgErM/L+pxBD3bMz0XOOjEKDEq+gaxvjEmRIluyv/tX1w2up4scjSjy3UvaOUilvFas2wcjfg+jUT9XHEg8N0PcNtnO165KG2obUmZaz//iqRuNrm8HEs+L63JN8UQGC1wLDEny4y7sntp8biGDz+3i+GSMB46Ocmklz0LamQR7K1jLV0i6rSnfJ6dieN2CZyuKRO6W+q1I/8Wcn1ftH2rtqANwuWU1aNNhixCCo+PR/u79PaJS00kXqkywJkMJPZtD4dZO/igeoaN983cdvxYTenZZdXx7Wj+gHromreejET+GweZE75UL8Bc/CZ//RVuuyV2WB/HuFoFrZt3Y1VQeJk/LMLgBR1tcFeW6s0H5nk4E8Xlcrd1IpnjUIR+oVNMBA7dWsoV8A+gxSZL19LW+n8O0nUcDHrnXNXT7lG9AjB4jLvKU1wdvGjEPMAIek3zvWc67YY987zSiE2S9SY5zufVJnQN4/FqaoNfNiakWHwgVtmYq3wBHxuWp1eWVfJPy3Z/t3FXe2FYzBuDzuJiKB/u0nW8OcbGCTLHKJKvyMMHl7v4NJk69C2ZeA499BJZfIBH09lU1NuRWaqKDi5J5uNK1OsU8bd7h0DXDMPidBy8T8Lp492tlV/DYnvI9GJSFsW45HgRbaoG6QtcJUqLiGmzDkg+MM0aGbH7wE/itWMqWqNR0DoTU+6sf2zlsmvueS4a5spKTKeO1ii3pv9BIO99kO09fgeEDbROBZ4dD3Ll/iL95fol8RPVvO6B8V7Py7xiIjw30PL64fI95irsz820YBucW1jk+GcXncfH6o1Lpe/DC7s2gr+UqDLsLske5S+BTwOvm5FScBzNm6Nou1Y0p5XtFj7W3nJuITm5bU5JRP+vFan9tJz3AtGuPaCubLecKo2ffyoKRZP/Vj8nP8g5A5FdYpUXHt4mRzYnnyVZ1Yw//KmDIuX8bslt8FbUXaHP4c2AkzNJGmcqInBUeZLSlpukENHMueHAxwuUSzI2EW5Nv1bldv0+2QKmq4aeKwLAlcA3AO3JA/djLnR/YAXXbuc9jb82YCTX3Hd0YfEypXDOVb2U731O+u2KPfO8CCsMnuU1c5/kF50//a5rO09cz3DEbx9uqDmhVke9kg3wfSkYAk3z3Hm5Wh2HgrmbZMEJ1e3Ezeun6/shDV/iFTyi7ky8sF22L12QYBplChVF9pXfbjhDw3R+U6ep//X+TCHr6mvkedjuvfE8lgvjcru6W2F1Svr9xZY3zi+v8wJ2zDKtamvGoSb73lO++oDbBtJof7BW9ftZr8j09KPkuhSZxCYNi2v7OZbNmbNqvPn89B66pxzdZz+dGwmyUaqzfvAS/8wD8xp1d62ysIL017bxakr+LFvPezfi+M1MUqxqffzknXUEp+5VvzQxkSgxGNlFifAAAIABJREFUvs3NcKC8O2R3MVNkLV/h9Iw8gLz/cBKXYNes55WaTrZck4FrwSFLtUtn9yV4qqhcKrsVuqbWnRSx1o66ZkQnpZumqTHF7K9ezTlLeFeyZdxoRKqpRthaE2ZGInxMfBeR2hq88JeOXgsAtQrucoZVowP5Ht6ceG7WjdXnvjPX4dxH1fMVIX114MsK1DYo42+r/JrjNisuc5Z5oeXjrCBf1oibvfY22M5BHoheXytsP8wJq+vtcEBaVm00gG3Kd3Rcrtnl1at9P0euOXDNtK/baDs368YmKle2jzT0iLrybVaN7SnfXbFHvncBvtmz+ITGyiXn575fuJmlUNHaV4GsvgSIhmURmB6SNp7LqzlFdBP9ke9aGbdRI0tom/INMvF8o1RjvQuZNQyD3/7qJT76+PWGVT86ZfmaChUNj1aUPb9W572bMXMnnP4huPQl7ucp1osVa33aCsWKRtxlkm/nFiW3S7BvJMTVbpZYk3zv8Mz3hx68jBDw4/c3yIRpO9/r+u4T5synHeS7V+VbWbGr7sE2LNWw/LnVtf7n49phXn0Wxt0qjKdn8q0+K011YweSYV4lLhD+w++C5edlcKF5iDkAMoUqHpcg7FPOnMw1wGg5792M7z09hcclpPU8eVhu2ntYn6xAFOXfPzo0IPlWm+FwdXdmlc2KsVMz8hA0EfJxZjbB119ODbwB7Qdp5XaIGjnLYYln9w1xgxGq7hAs75LyrdpPUkaMg6ORzo+NTsi526bGlDqhzDp76Lq8UWKcNC70lsq3EILnx99G2fBifON3HL0WoOEY6ES+R1SquLKdm8r3qvlaff3X5et58h3yvwd8D2i6QVjPUnC3VyvNisUFXe0jByDfuUqNmFB7FBts5wBzo2F0g+1iTtiK8q03yLfHHvI9PTrMihFH2DDzHfV7Gh3fDijfh1lkecDPYV35dqu0872k867YI9+7gPjBuwDQF59y/Gc9fk3Ne7erAlm5AEP7N534uZWN59KK2rDGpvuznZel/TlnBFsq31YTzy8u51jOljGMppPy2KS0nVvYZGaKVaZ67fjeir/zr8Eb4u+nfwu0KvmKdatXqaoRt/lm0w4HRuQJcMc8AfMadlD5fnk5yxdfXOa7TkzUT9FBhkt53cKWrslvS5gb2pAd5Ht7LVBHVKV6UXMPNvOtR+WmWMv0v6FrB3NtGXEpm2O/yneT7fzewpf4M99/QFTzcOaH5ReXnh/0UlkvVkiEfI352Q5J580YDvt44OgoD728SjF2UCZR2xxo5inJv78/1qIeqRf4QhREiGht5/MmAJljAtwx01iHHzg6RrZc46n5nQ+gTKn7WVjLWlYBz84mAMEt/4FdVL7lurPhTjAUakMiTbQYE9sx8p0tMyHUZ7cF+QaYnZnlL7V7EAvfAKeDcBUJ7Kh8B4fkuEsr5Tu/Ck/+IUychntUreSA5DtTkD3zJW97V95+1fJwsazeowOkeOdKNUeUb2hRN+YNyMyMTjPfVY2gUO9Dm5Tv2eEgC8Yo/vwAhxTNaefrNnZ8m4iMU/ZEOexaHHjsz1S+Q+6arCbes513hePkWwhxRAjxdSHEBSHEY0KIky0e80YhxDeFEM8LIZ4TQvwXIcS37MGAa/osAIn1F3pSUPvBE9fkJudVsy3It1aT84FNYWsmDo6GWUgX5YcqplTmXq+1JMl31RMh4N0+Z71vRJLv613Cbh662Dgxry8SsSmoFizVZWUKlcHJd2wK7v8AY5Xr/Ij78/X5TCsoVjViQinfDttx5pIharrBYqcEy7rtfOc2mx/+miQS73v9wU1fd7kEY9HAnu28X5i2815JZStEe8xSqJjke7A5OaHsoKLPXIlOuKbId0RTOQi9Bq6ZM9+FNbn+ffk/ccc3f540Ef7s5G/DvT8j///y4OQ7U6hun/eGrso3wNvPTqPpBueL6hDGZut5Yya0x9evBbKeIYb0tOP3vlY4v7BO0Ovm8FhDrX39Ufma7Yb1XIZoGQRqG5aV75mhIMmInxe1KUnmCjuTGr4Jat3xRJPtw9ZMmOvKxu6Q78a9vzX5PjEZ4w+175T/8dQfO3o9pv15lTixduQb5Ny3OfMdNZXvCjz6P6TV/HUfgDE1fz3g2rOWlz3zNV978j2nyPdz2TAgBlO+yzXZ8Q22jeEdGu1QARkZbdwnW6BU0wjWbef2zHzPDoVYMJJy3KGH9pBmbLadz8tDBDvHFoUgFzvMUbEwcOK5qXyHdLWX3yPfXbETBPe3gd8xDOMo8J+B32/xmDTwQ4ZhnADuBO4FfmQHrm13EJsm70lwVL/MQtr+kKFmPHEtzdHxCPFWp9Ppq/KUqilszcTB0TCGoWYmY1NQK/WulJbNRMvWhHNmyJry/dDLDfJdt8dEraewZwrNyvcAJ4f3/jQb/kn+qeeTZFPWlCXDMChWNaLmSa/Ddpz9VnqIdzhwbTlb4pNPLnLn/qGW84FjMf9e4Fq/yK/KG/KWFN++4A1KV4RF1dSok+/B1ALvkDwQ8+T6a1TohPm1AmNRP57sojygcHdR6bbCJOsbN+ATPw5f/SD6xB28vfz/8I3SrNwku322kO90oUoiaK3jeyvefHycsM/NZ2+pTY/NoWvBaoYSftkAMSDy3hGSIkOubH+6fSfousH5hXVun47hdjUI4+mZBImQd1dC19YKFYKUcRtVy+RbCMGr9iV4PC8703cl8Ty/So4gI3ELymULR81oqxAxB7CSLTNp3vtjrQ/eT0zFOG/MUfAk4IbDbsS68h1rr3yDnPvOr0Bpg2REru3Z9TX45ofkiODxt8mRwKEDAyvfqVyJOHm0QPv331DYRzzo5dJaTabXDzTz3aR822U7VzlFLfc94bEuyrdOEHuV77DfQ8qj3vd9vlbbbOd2Ws4VasNHGRI5MqnBEs/r5NtQr/8e+e4KR8m3EGIMuAswjxM/AcwKIQ43P84wjKcMw7is/r0EPA0ccPLadhVCkE2c4Li4xvMLzs2+LWaK3FwvcWfbeW8zbG278n1o1Axdy/WdeG6UpNXTE2p9WmfFdl7VdB69nMLnkW/Veod13cpmlXyrjVW/yjeAN8jTxz5ATBRIfOOXLX1LuaZjGBA2CuAJgMff/8+3gDkrPcT+GAj3jtnO/+iRa1Q0nfe97mDL/z8eDbCaK+9Y9d63FPKrjbk2OxCdtKx8V0tyLEXzDEbI/EPTaIbAV7C/+3k+lWf/cFBmW7RY57rCdBQ8/Kvw7Cfg+Ftx/dhnccWnZPWO2yvDKge0nRuGoWznW5Rvt69R99gBQZ+b7zo5wRdX1OHeqn3k2zAMIto6Obc9qkvJn2SIHJnsztZ7XUnlyZZrMmwtfRX+/IdhfRG3S/C6I6OcX1xnNbezDpy1XJlEH0Tk7L4hXtLV+2IXyLeeWyGlRxlvkeWyDeZBedOhnql8O/16r2RLTLtM23nrz9GRsShet4trngOSyOoO3odyFmznsCnx3O9xEwt4OLv0CSlo3PezjcaWsRPS5TJAUvtGJoVbGF0Pf+p1Y/GZgcl3febbJtv5UMhLPOjdbjsHqXwX10BrnS1UqmoEhL2BawClsNo3Z/qrG6vbzr1C7r3ttJwreCaOA2AsD7aG1APX6sr33sx3NzitfM8CNw3DqAEY0mc2D7Q9whFCTADvAj7t8LXtKtzTZwiIKrcunXPsZzyu+r3bVoGsqnmxZCvlW5LvSyu5vru+8xtqTjDceoFNRnwEve6OiedPzWcoVDTefFye8tftyfUDge5EIVOsMF0//W5tPbOK9bnv5Zv6bUxc/HNYeq7r48tVeSMPGzlHk85NmPPUHUPXhJDXsgOBa4VKjT969BoHRkK8+cT4lv+5Bv/tDG+pfAbdgFR+Z6pevqVQWLVn3ttEdMKy8l2ziXxHQwGWGCJUtJd8b5SqpAtVTsRLcjylhcOnK0ybtaHD/R+AH/hD8IU5MBLm6mpBWqfHTsDGwkBOkkJFo6oZjaRzkMp3Yr/lasS3n51mwRilJry2BMCZyJVrxMlS8tqzUa4Fk7iEQT5t/2FLJ5xT896nZ+Lw0mfhxU/Dg/IQ9fVH5Gfoaxd3tn98LV9pWHAtKt8gE88v6uogecCNcz/Q8yukiLUMUt2GuvLd2D8Mh324xM7Yzvd7MyBcDfv7Fvg8Lg6PRTlXnZZ5Cevzzl1QPXAt0dl2PqwOqtXc93QEvjv3Sbl/Of2DjceNHZfhawM4XQrrUpho1fHdjLmREMvZMrXotEyv77PhIVeuEUPlCdmkfAshmEuGW9f3monn+dbOlk2BazaSbyMuaU51rV/yXUUICJWX5e/YAeU7PCOngH1rg90vTOU7qO8p31bxipqrFkLEgL8C/othGI+3ecwHhBAL5j+5XG5nL9ImJA69GoDq4tOO/Qxz3vuuTmFr0NZ2DmbdmEm+e1O+1zOS8AairX++EKJr3dhDajP0jldJ0rxiKt/1OTKLyjeraL7YwLbvRNjHv6u+BzDgc/+i6xx80Qyi0PM7cho4GQvg97g6285BbvR2QPn+9DM3yRSq/Pj9c5usngA8/hFIX+FU/hFgr+u7Z+i6TOG2I+ncRGxKbkBLXbriAU2Rb31A8h0LeLllDBOtLA30PFthJp2f9inLYT/KtzcA3/Gv4F2/K0MXXfKWeSAZJleuyQDI8RPysQMokJmiqhkzN+S6JhUTC/PeJu47NMJwJMhL4iDG/CP1NPpBsZavMCRyVHzWyWEnaGozXNxx8i3HoO6YSTSUu6f/FLJLPLBLfd8pNW8L9ES+T8/EWXIlKYnAzivfhoGrkCJlxFsGqW5DcAjc/k2Hem6XYCTib9RnOYSVbFkq35EJcHvaPu7EZIwnSmqfY+FQvW8o5TslYtJO3A515Vsmnr/T9SDDRkaGrDWPGI2Za0//1vPShnzP+yKdybc50pbxqUP0fhpwULZzm2e+AQ4mw6zmymyUtijcEXW9bRLPN89820e+fcn9AGRv9df1nSvXiPg9CHOtsrNmTCEwKd8/0exgXd9ltc/1ayb53lO+u8Fp8n0dmBRCeACETObYh1S/N0EIEQU+B3zKMIz/2u4JDcP4r4ZhzJj/RCJdai5eofDOyNC16Nqzjv2MJ66lSUZ8dXv3Nqy+JE8FW9z0YwEvyYifS6v5JpW5t8W2oJTvaLz9or5vOMRipoimtyaxD728StTv4fVHR/G5XU3Kt2lls0K+ZeCa1mbmqxckgj6eNQ7y4sRb4cpX4aXPdHy8Sb6D+s4o3y6XYP9ISNrDOiE4tCMz349ekQcw33Nqi+pQK8v5NWC0IE/t90LXekQxLRVZO8l3XaXqToy0snyPGQNuWCIBDzeMEaK1tYHsk1thjrMccqnNSz/KN8AD/wxuf+emL5nVO1dTeRhTGaIDbNrNAMe67XzjBmgVS/PeJjxuF2+9Y5KPl+9GVHLb1qZiRWMhXehZbVzbyBIVRTQbwtYAhNoMV9d3nnzHAh72j4Qa6cFaGb7xW4zFAhyfjPHghRX0NvciJ5AuNJNv6ypgyOfhtok4l5jB2GnyXcrgMmqkjKg15VuIRjtJE0YjfkeVb103WMmWGTNW24atmTgxFeMlXZEbG5oL2iK/TF6E8ftDuLYeRjejuetbq/F9hf/JmhGhcsd7Nj9uTNqGB5n7ruaUSBLrfB8xR9qWUI/r03qer8ieb80btezqsQJTMNo2chdRY1ltur7LVY2Iy97ANYCY6vqupK729f25skZkU82Y/eSb2DR5goyVrw70NKby7TPJ917VWFc4Sr4Nw1gGngTerb70TmDBMIxNHhkhRARJvD9nGMa/d/KaXjEYOkDRFWGudsmRuadcucYLNze4c/9Q6zRSw5DK92h7NejQaJjLyzmMmHWVuRnFrCR3sQ7ke3Y4RFUzuNVC9dwoVXlmYZ3XHhrB63YxGvU3Zr5DI3Ie0oLtfD0vQ1dcg8x7K5ib489PvF/+/Md/t+Pji5WmE8EdWpAOjMik+o69tcHEjijfT1/PsG84xEhky6z7s5+A3BJ4Q4RKS8TJ7SnfvcLOmjETPSSe6yb5HjCEy+0SrLrUBsnCYZpVmOR7qqqIluo1tQObAn5M5XuA0LVMQao1cdN23kPSeTO+78w0n9buQcPFU//7Q7zl17/GfR/8Esd+8bMc/6XPcf9//jL3ffBLKmXbGrJrSjGyiXx7Y5J8azbXoXVCTdN57sY6p2cS8n6YuS7V0JEj8NhHoLTBA0dHSeUrPHeju+vDLqRyFSZ8at3rQfkGaT1/oTaFyC3tbOK5su+miFlTvkGuK1vu1aNRSb6dSr1PFyoIvUpMS3fNTTgxGeOCMYOBgGUnle8V0iLROgC3GYGYzPJYuwTPfoJk7Ra/V/tuUtUtavnIEXB5BiLfWl6+d0KJztkh5kjbNW2wru+cmvk2bBYj2oau1W3nbZTvqk7Uo9RyG5Xv6bEkq0YM0WctW65UleR73YGObxNCcNO3n9naYKMW5sy3t7ZnO7eKnbCdvx94vxDiAvALwD8CEEJ8WAjxNvWYfwq8BniHEOJp9c+/3IFr2z0IQSZ+nJPiKs8t2E+CXry5gW7AmVYVYyCVrUq25by3iYOjEbLlGitVP/iiPdvOKwVJvodH2i/q9dC1FjPKj15KoekGr1PzeDIVWx1UCKFu6N0367XsCn5Rwz00+OJl3jQXa1GZNJruPM9TrGq40fBphR1RvkGeUGu60dHOT3BIVpb0WYNhBeuFKpdX8pzdt0XRMQx45DfBF6l3lR4T1/e6vnuFWZ/SZ+BaKlfmSy9usXr3oHzrZaXYeQd3H2U86u+wbl/d2DW1piTyl+V7bcC8h2bUlW/TGeSPD6SYmeS73pncQ9J5M07PxJmc3sdD2u3cXnwMPZdiJOLj7rkR3nF2mtccGKai6d2dMU0oZuSm1RWx55DHl1AHPB0SiO3GhaUcpaou571BEofEPrjvZ2SI1RO/tyuVY2v5CpM+1XjSK/meHeKirt7TO9n3rdadlBG3pnyDXFcKq5ucLaNRP8WqRl4dUNuNlVyZcZHGhdE26dzEickYRQKseicdV75X6RK2ZmL4kJzlfuhXqLhD/IH2ndudAh6fTD8f4OBPqEN4b7hzXaVZN3ah2PQZ6gNmz7dh07y3CVOZv7Q1dC2iyHeu9VhTqaoRdZnk2z7le3ZY1o0F8/3d03LlmqoZU+Q97gD5BtZCB0mKdXLp/tc9U/n21mTI8h757g7HybdhGC8ZhnGPYRhHDcO4yzCM8+rr7zUM4y/Vv/8HwzC8hmGcafrnPzh9bbsNMXUHYVFm8dJ525/bPP0zrTjb0CFszcShrXPfPSrfelHO2CU7kO9ZVTfWiiiaFWP3HZabovFogFSu3LCox6YsKWV+tfiJxODKd9Tvwe0ScrOc2CdvQB1O7ktVjQhqc7VD5LsRutZhg23e+BwMXXtaBRydmd1yk73yVVh6Fs6+B/bfA8Ax1/ye7bxXmAEyfdjOL6/kePtvPsyP/f7jstHARNT6OIehlG876qeyfrVBsrHr+/pagZDPjXftIiSPyAM7mzA7HMIl1GdMCGn/XH6uawZEO2SKynYeHEz5FkLwFz91H/d830/iFRqf+Tur/OVP388f/Nhr+K8/eIZ/cLfcwPVy0FXekGTLF7WHfIeG5XvMU9i5cLPzi2bYWkIeOOaXZWrz6R+Uh7iP/Hfumg4T8rl3dO57LV9hzGPeH3ojI2f3JbhgqHvaTlrP1bqzRrSeWt4V5rrSRICc7vpe3igzSeeObxPxkJfTM3Geqc5gpF525lBaq0FhjWW9S82YiZFD0p228gKX9/8gG0RauyTHjsvDuj4zHlzmHqDL4U885CUR8nIup4hVn4quOfPtsinp3MQBdSC6XfnubDsv1TTCbkW+PRYPkyxgMh7gBqNEqqt9hdPlm23n3nCj9tJmFOJyxCEz3/8IbKmqIQS4K2ovsTfz3RWvqMC1bzckDr0GgPJ1+7sl6+Q72YZ8dwhbM7EtdG19sbfNpQptinXoAt03osh3ugX5vrjKVDxQ/zuMxfwyFTvXNPddSHVd2IJFZXezIbBCCEEi6JUBSfFZqR63SdEEaTuPmeEiO7QgHRgxZ5+6KN/gqPX8qXn53Gf3bbmpf/03ZPrs3e+H8dsBOOm+3nL0YA8dUFe+eyNFz1zP8K7feoSFtNz0b1IKelC+jap8fwlfmzWmBxQC6ufaSL6vreU5NmQgcrf6C1vrAL/HzVQi2Ki2GT8hE9Ut1rRthal812e+01fln4n9PT+X2yXw3f5W8ATh3Mc3/b+xmCQ8vRx01dSmNRgf6/laWiEyIpVvX2nnyPczKmzt9Ey88R6Lz8jqx9f+Y8jdwvf8x7n3UJIn5tPbQ5scgK4bpAsVht1m7VJvyvdcMsySX70/dkH5rgaSeN0Wt5C70PW9vKnju7vr5U3HxnmuNoMwtIY4YScKq4DBLS1KLGBF+VaJ524/qVPvBdq8VmMnAKPva/ZWrJFvkHuLcymPXFv6nfkuVYhRwBWyl3yHfB4m4wGurG4JYY50t52HHaga87hdrPsmpPOix9dK14164Brr1+W8t42Hx83QRuS9sXSj/3GLck3H73EhKqbyvUe+u2GPfO8iAvteBUAoZf+M0dVUHiGkQtMSdeW708x3c93YNFTzULY+D+eq5igQQHRIGTWV761d34uZIpdX89x/JFmfWR+Lbtk4WpxPjZYVkbBh5hvkCfB6odoIwOhQTVKsasR2XPluCoNqB/PU2cHQtaevZ/C5XRyfbLIgLb8IL/8NHHuLVPUiYxAe5XbP9b2Z715RUBvLHma+v/LSMj/0O4+SL9d4/wNyc3et+X0SGQOENRJZkd8nbLDqlYJqc26T7byq6dzIlHh1WBG8fsPWOmAuGeZaqqluDPq2rJqBa3VFLDMvZ5K9fSox/igc+x64/uim0ZgJNaPby0GXnpfvs/CQPeQ7GgqRNiIEyilbns8Kzi1kSEb80ia9NT34zn8oxwYe/m+84egwmm7w9ZedV7/Xi1V0A4b6TH4WQjAxe4SC4UcfwHbcM9Rhszvaw7hLi3u108r3SrbMpDA7vi2Q7+NjvOhk6Joas1jRLdrORw7LP8/8A2Kj8rpWcy2yGswsiz7mvg3DIFCTB1NWlNW5ZJjVfAVtgK5vrZzFJQyEzco3SMHoykp+c46ANyjHJtuMuZSqGmEHbOcA5YjccxqZ3lwC+UoNgKjPJW3nDiSdmzC7vgdxz5SqGn6Pu9GS4v/bGYS9k9gj37uJ4UOURJDZ0gWyNp+0X1ktMBUPEvC2SJPUdbj5jFyQOgSRzAyF8Lld0pbaR9e3r5aj6Or8IQz63CQj/m3k++GLmy3nAGNq41gPXbNwTYZhMFxVVjebyLdUviuNGZwOC2ux2qR87xD5Ho8GCHi71I05rHwbhsHT1zOcnI7JRdnEo/9d/qlmvQEYP8lBY56VjaIj1/Itix5t5598coH3/sHj+Dwu/vR9d/Nj90lL86bPntsrbXoWggxN8u2y4Uarh8eoGm60Pjd0W3FDNSjc7lMHbzYr3yBVoGJVk4eBJvnuM6xpu/J9DYZ6V7034dTfk3+eb6jf5hray0GXqygJTCDeX7bAtudzCdZEgkhtZ0LCSlWNl25luWMmLg9y6+Rb3Q8CMXj1j0PqZb7L9QQAX90B63lKhd7FyUny3+GQuh3O7B/hZWOK2tLO2c51pXz7Yj0cxtRDW1uRb2cOXZezpYby3cV2DnByKsZaWBJew4m6MaW8Wp75Pvrdsubwjb/Y+aBirP/Ax2y5RszIURU+S6qv6aorBCa7jty1gygpsm/zzDfIw4F8Rdv+OkVGG06xLShVdUIOKN9AnTTnl3urG8uXZQ7CmDsrGxmcCFtTSEwcpGD4Caz17/Yo13QCXheUs7JW0GNxHOXbGHvkezfhcpGO3cbtrqu8YGPCqmEYXF3Nt573rhbhf/5DWHgMDr+xo5XFrWqrLq/23vVdqNQI6Xmqnu4b833DQa6vbSZeW+e9oYXybYF8ZwpVJlhFw904fR8QiZBPzXyr08hMe+W7VNWIocjNDpFvl0twYCS8qzPfV1MFMoXq5nnv/Co88+cwfRfMvqbx9bGTBIwykeIC5Zoz4TvfkjA3E6HOQTkAv/PgJT7wsWcYi/r5xE/ew537hxmL+gl4XfVgsjpik5Zs56JaoGx48fl8XR/bDdGQnyWGMDL2kG/z73QQtV51aHXoF2a2wqbE836V72IVj0tIm2ElLy2qfVjON+Hwm2RC+fmP1zfJEb+HiN/Dcg+2c29ZHtAJG1P1111DxLSdId8v3spS1QxOzWwJimqu7nntT4Lbz+i5/8HcSIgHL6w4lsJtwkycD+s5CPZ3bzi7L8FFYxpfYWlHqiMBKuvyMDs6NG79mzop3w51fS9ny0yJFIbL0+h67gAhBEeOn6ZkeCku2p/DY84crxpxYlbItzcgaw7DI4xE5Brb8rUanpOEpw/lO6165ksea+8/c0+55hmTTsg+Du/dZfU+dYR8m27NFonnbZTvclUjJNTrarPy7R+VB9z5pd7Id64sD2MnUfd4J2rGFMbjIZ7UDzO+/ozkB32grnyXs3s1YxaxR753GdrEGWKiwMJl+2xOSxtlilWtfkpZR24Zfv8t8Pyn4OQ74Pt/u+tzHRwNc32tQDXSW93YrfUSEVGk5uueerhvOMRqrkxBWW103eDhl1c5MRkj2VRRNb5V+a6HQ7VX6RYzRabEKnn/mG2dkomgl3JNpxRWP79D8EixohEVitzs4BzMgZEwi+kilVqbujGHle+W896PfUSe4t7705sPfcZlT/IxMe9o7+u3HAopuYFxt9/I6brBv//08/zHz7zI0fEIn/jH93J4TH4mhRDsGw5ttp2D3Chnb3ZVNVy1AgX8+DyD30aiAS83jWFEp6C3Yhqe+hPQux/QmGr+ROUauLw9p4Zbwaau7+CQXI/6tP+uF6okQl5Vg2VTtYzbCye/X9qiBt9kAAAgAElEQVQJlxphOrI1wrra6DdnQm0M/Ml6h4ka+b6CiHrFORX8eMeM2uybY0LNTqjIGJz9YVh8gh+dWmAxU5TjVg7CJN9BbaPneW8Td8wmuFgPXduZue9adpmMESaZ6CHRuEWWhOO2840yM+41RHTS8r3/TSemuGhMY9xyUPm2Sr6b4HW7GAp5W79WLrc8XOyDfKfyFeLkqfiskW8zUXzRUAe+fTiV3BUlNDlhO28+EG1GZFTeL7Xatu8p1TQCVGUOTYd7aT+ITcgws0qqcyvOVmRL8jrHNeXadFD5TkZ8fNU4g9eowNWH+nqOhvK9sZd0bhF75HuXEd4v5761RftC18yF50Bz2Nryi/DhN8Hi4/C6n4N3fsSSxebQaATdgEVdbQ6sku+NElEKCAsfRHMu3VS/X7i1QSpf4f4jm5UWU/leNm9AFvrHF9JFpkSKSrhzz2cvMOvGMq4R2bHZzXa+w8o3yN+9bmyfpa+jTr6dUUuevi6f96ypfFdL8NiHpFX/2Fs3P1iR7+N7iee9Ib/StWbsX/7FeT780BVefWCIj7//Xibjmz/z+4ZlJ3ytuRM+OgF6tWt3sKtaIE/AJvLt4aYxgruYap00XM7BH78TPvWP4cJfd30+830fy12Ws5N9WHq7oRFs2BS6tvJSyw1eN6QLlc3z3jC47Rzg1A/IP899rP6liVigJ/Id1tYpipCtVsKiT23ed6Bu7JnrTWFrIAmDL7Jdebv3n4Bw8dbsRwHnrecm+fZX1/sm37GAl3xUzQav9N/13AuMfIqUEbNeMwbgC0trfdPhWtTvwe9xOUe+c2rmu0vHdzPuOTTCRfYTrqzY351uznxbtZ1vQTLib512DtJ6vrHY8/18LSeVb91vjQib5PtyVb1f+yDf3qoi3w7ZzoHtoWvhMcBo5KQoaLpBVTMIUJaqt82hZtPjo6SNCO6NHme+le18uGaOTDpHvj1uF+eDd8v/uPj5vp6joXzvkW+r2CPfu4z4kfsAGFl51LbnNMm3qcxw6cvwke+UJPXtvwlv+iVwWfvVHzRD10pKtbVoO19K5wiLMi4LdroG+ZYb5oeV5fz+w5vJ91DIh9ctGjU5ETMhuT35zl0/z4jIotuofJl1QJmyJtWTTsp3VSNaJ987p3xv6iFuhXrgmlPKd4ZkxMfMkCJ75z8uyeJrf2I7ERo9hoFrr+u7V+RXO857P3hhhT/75nXuP5zkj3787vqhUTMOjISo6QY315ted4t1Y65agaJhn/J9w1RTtq4xtTJ89N2wKOdxud59rbyWyhMUFTwb846ErYFct9wu0VBZxk5IZ8dabxZDkLbzRMisGVMqiR1qx+zdcuP27Cdk1gfSQbRRqlG00K9crGjEjA3yFm2pVlHxy/dtZb2/dPhecH4xw3QiyIjpolpfkOv21o328EE48XZGbn2N293XeOyKs7b4tXwZNxqeam4gIhKZPQVAftEBtbYFPMVVUsTq4X2WEZ3YpHwLIUhG/I7ZztMbWYaMdUthayYCXje1pAygys0/Y+8F5Ru2837I92jU3/6gYqy/0Ky1XIkEOYyQtcOfsN/DRCzA83m1l+mRfBuGQaBOvu0XI2aGgnjdooXyrcYOtiSel6pyDZTk2+Z5b2B2KMiCkSRU6C1I1LSdD1XV58VB2zlAaOo4141RjAuf72uOf9PM917SuSXske9dhmv0MAuuaW7PP9p3R+xWmLO+c8kIPPEH8Cfvkv/j3Z+Es+/u6bnMGZ8XM2a9hLVFZC0tTxh94e6bin3DmxPPv3ZxFZ/bxasPbLY5ulyC0Yi/oXx7fPJEs4Pt/MjFD8t/uesfWbpuKzBDkTIFVTfWQfkuVTRiYheUb1OVazf37eDMd6mq8cLNDc7MJqSN1jDgkd+UAX9n37P9G7wBivGDHBPze4nnVqFrUFxrS74rNZ1/81fPEfC6+OA7T7UOXgT2q6q/TXPfFuvG3LUiBfz4rdYNdUAs4OGWoT7vzeRb1+B//QRc/jK86kfljf36N7s+3/xakbtjawgMR8LWQFpBZ4eCjc9Yn6FrhmGwXqgyZB6OZEzybYPy7XLBqXfJ1/Taw/Iy63Vj3T9rqXyZIZGj7LVXpaqFpGOjkHaWfOfLNV5ezjVUb8NokO9WuO9nAfjZwGcct52n8hViqPdOn8o3wP5DxygaPoqLO5B4rmsEqhlSRoyJXpRv2Ea+oQuhHAD5co1YVc3LWghb23RNh84CcPm57utMT8gtUXGHKOHvW/nOlmp1wrgJfYau5TbSuIWBu4eRkrlkmKfWVZZPj13fUoww3/P2K98et4t9wyqnqBkRs+u7Nfn2G86Q7+Gwj1tijFh1FTTrocqm7Txauinn+cP2NE20w+nZBF/R7kBkrkLqUs/fX6pqch+wR74tY498vwLwYuxexowUlcWnbXm+K6t53C7Y99Qvw1/9jDz5fe/fwMEHen6uQ2aAhRm6ZtF2vpFWCbmR7puK2SbyXapqPHZ1jbsODBH0bScMo1stk7HJ9teUvsrta5/n6/pJho/ea+m6rWAT+U7sg/J6W7vXJuV7BxeluXazTya8AXmY4oDy/eziOjXdaMx7X/qitETe+aNt1X999AQHXEusZZzrHf+WQjENht62Zuz3Hr7C5ZU8P/WGw8wMtQ+R2dfqkMZihZ9HK1K0aeY7FvBys658q8+zYcBn/zk890k4/jZ4y6/AzF2w+CTUWlTuYH6bwXwqz50hs2bMGfINcrzjaqqApht9h64VqxoVTSeuHDVkrsn5Q5vaGThtpp5L6/l41Hri+Vq+wjBZav7+yWErGGozWXaYfD+7uI5uwGlz3ruQglqp/Ws7dQYOfgdv1B5GT12Rv1eHIMOuBiffZ/ePsGCMIjpUXtqGYhqB0R/5jk1JW2q5cagxGvWzmqug2/w6r6iwNflze/scnXqV3Ctk7Va+cyvkPZLkxgK9j8GYM/Itreem8t3j3HdpQ7oMvZHuoZ0mDo6GuVTeEl5oEblyrUmMsJ98gxSd5lMFqs2jVCZ53ZJ4XlKZOD6jbHvYGkh3RzYwiQvdsmsU5OERQKh4U65VFp2q/eL0TJwv62fkf/RhPS/XdKLuKui1Pdu5ReyR71cAViffAED23Kdteb4rq3neGLuJ++Ffgek74b1f7HsDGg95SUZ8XF7pjXxn1yX5Dka7L7ATsQBet2AhXeDJa2lKVX3bvLeJcXWzrm+KolOSJOgtgsUe/jXc6Hw08Pfw2KDOmTBPrTOFSqN/sc0JcLGqExMFDOGSc4Y7hNGon5DPvT3JuhnBIUfItznvXU86f+Q3JZm4+/1tv8c7dTsA7h2aW/xbjw41Y0sbJX7tixfZNxzifa8/2PFp9m9xnQCWlW9PrUDesG/m+8bWEJ+vfBAe+zDMvR7e+WEZLDR7t7R23zrX9rnW8hXyFY0TXkXsks7YzgEOj0ao1HQ5MpO8DYS7Z/WpZc1YbNq+8J+x4zB+SgZt1sr14MolC4pjen2dkCijB+0LWwMQUWkDrW10T9UfBOcX5bz3HfV5b7VOdzrYuP9ncaHz98XnWEh3WD8HRCpfYdyr0oUHUAEPj0VYFkkipSXb3HNtochLzpMg5OuRQLYJXdN0g3Sh/WFaP1jOlpnA7PjuLe8lOTHLuogRWb+wmcANivwyG255yNKv8g1tur7jM9JZ1iP5LmflAYU/Zp18zyXDVPBSCY72TL7zZY24g8o3yMOBmm6wkG5K7o4o8t1G+fYZZfD0eJhkEWbXt7ZmPXQtV64BBv7cgqNhayZun47ziH6CmvDCy3/T0/fqukGlppNwq/vJHvm2hD3y/QqAe+5eNowQnovdg4S6QdMN5lMFXhdSH/QHfqFhuekTB5MRLq/kMGJTUuUtZ7t+TzEnSZ3LgtXa7RLMDIWYXyvwtTbz3ibGYvJmnco31Y3pNVnN04zsEjz1x5znMLeGX7P9iQaAOZuZKTbXjbUh38p2LvxRx08vmyGEYP9IuEvXd8KRwLWn5jMIoQKOlp6DS1+CE2/veBPxT58GIJy5YPv1fEvCPMFvEbj2nz7zAvmKxr9+64m2dnMT00NB3C6xOfHcQoUfuobHqNimfEc3Kd+L8M0PwVc/CJNn4If+tBH2ZVbUdbCeX1MHCfuNRUBA8sjA19cORyfkRuOlpax0k4wc6pl8m8Qj0Ry4ZveG6/QPQGkdLn6eibgKrrSgfOfTcrMqwtY351bgjUsipmedDVx7ZkGS75PTW5S6TgFGcw9Q9I3wGteLjlrP1/IVZgLqdzCA8u12CaqRSfyUKWcd7idX604t0Mf7oVXdWMSZurHlbKmhfPdoO0cINmK3cdiY57HLNr2eugaFFGmXJJy9pp1Dl3R4IeQh29JzPR3AaHk1HtiD8n1I5QBt+Cb6IN814qbbw6ExvIOtQtfM+2SbmW+v7ozyDSDU+FDmpvUskGy5RoIc7lrB8XlvgLFogEQ8wTPu22XieaXDvnELKuqAKibUYcde1Zgl7JHvVwDmxhJ8VT9NPH1eksYBcCNTpKLp3C6uyC9MnRn4+g6OhmVAT9AMOOtuFSwr8m31gzgzJLu+H7q4SiLk5eRU64XZtEzWe2rriedbLD2P/iZoZX6t8jamh+1dVBPBLTPf0Fb5LlU1EqKwo/PeJuaSIW6sF1vPiIGjyveRsQhRnwv+98/LL97zTzp/k0o8T+Yv2n4935IwD5u2dHx/43KKv3j6Bm88NsabjnfvtvW6XUwngpsdEsFhWc/VSflWN+eC4cdnx8x30EOKKJrwwIufgc/8M5lS/u5PbD5Jn74LEHD9G22fa179XcbLV2ViuAOzfCZuG5fXduGWOpAcOw5rV3ravKybynfYJwlyKWPPvHczbn8XIODcxxhTa+it9e7ku7QuyZY3Yl/HN0AwPoZuCETeWfJ9biHDwWS4oTTWyXcH5VsISqOnuE1c5+qSc93Za/kKU77ByTdAYES+X16+6GzdmKEcN0aXloWW6NT1bfPc90q2zGSftnOA0OwpwqLM48/YZD0vpMDQSRlxwj433j7WzKTq+m6feH5c5oBssVZ3RFG6A0SPM98AK66k/F32MMucK9eIk6fmCtjantDq+i43d323Vb4lcfToJcfuE8FR+dksLFsn3/lyjRlhZhY4r3wDnJqO85nS7aBV4MqDlr/P3F/GXIp87ynflrBHvl8BmEuG+YImK8cYUP2u14xVLkhLdmTwoAbzpHOpVSBSC1Q1Hb2kEi0tzjnvGw5RrGqcX1znvkNJ3K7WlQ9mWFD9Zm0mMzcfCBTT8NhHKA8d5Qv6qzrOvPYD0x66Xqw0FKpM63m7YlUjKoqyZmWHcWAkjGE0UuS3ITgkN/qtLPt9YnmjxGKmyNnZIXj0v8P81+HV74OZOzt/Y3yWgggxU+09KfrbEnXbeWMTXNN0/vVfPofP7eKX3nLC8lPtH5GuE8NUTFwuFY7U4ZBNkUv7qsa8GLjIeEYhd0tu1N/zv7bb6gMxeVBz/RttFZ75tQJuNMK5q46FrZk4Mh5BCKV8A4ydBIyeUoczRUW+g177Or63Ij4NB+6HC3/NmE+unVZs59Ws3AD6YoO5p7ZdTiRIiiieQg9EoUdkChWupQqNsDVoOJS6zNP7Zl+FX9TILTzb8XH9wjAM1vIVxkzb+YDzr8lpOV5y7YqzzqFSRooDvqi95LstoewTy4p8Gy5v1zrGVhiek6LFrYtPNNbFQaBI37Ie68tyDhYOKvoIXXOZgas9HP6YieLXtRHAsDyKCCoIT+Sp+pxTR+dGW+Td+MLgDW8j3+WqBhh4NOfId2JSdn3X1q5a/p5cqca0UPf4HbCdg3Qqfkkz576tW8/Lam4+wh757gV75PsVgOGwjyd9d6LjstRh2wlXU3n8VEjkLtmiekMj8fy6Zq3reyVb7vmDuK9Jnb6vjeUcqKs29bCgWItapG9+CCo5Lh59HwYuZhL2LqrRgBchlPIdmwZE+5nvikr33AXl+0C30LVAQoZ2VbqPEVjFU2re+4GhFfjiv5Pq5Zv/XfdvFIKbgUMcMa5RLPfek/xthxYz33/yjXlevJXlfa+fq//urWDfcIhCRdts/exGvqvyQMcu23nY58YlYMF7QL4v3/PJ9puO2dfIa2tjebyWKrBPLOPSq47VjJkI+TzsGw7xkql8m6FrPcxebpr5NmvG7Oj43opTPwBaGf+FTzMU8loKXNNyUj0MJbq7KHpBIuhl1UjgL6e6P7hPmPPe9bA1UOu06DoHHNovD8P9yzaHbikUKhrlmk7Sow5GB1S+Zw/I0YrUDWcPL/MqIC/Qz/uhzcw32K98L2/Ijm8jOtnXuJcYlxkkw7mXubRi3cXSFsrhcVOL9mU5h4ZFv6PyDT2tPd6y/Iz08v4zE8UvlNTnqgfreV359jm3HxqN+In4PZuVb5Djl9sC1zR81GQgmkO286mJCdaNEO4eAtdy5Rr73Gpt3AHbOcCpmQRXjAk2grOSfFs8dDKV76hpO98FoelvI/bI9ysAQgiGkxOcE7fJ+dhq/3VLV1bzHBPzuIyanJe0AWbX98Wi2fXdmXzf2igR67HberaJfL+uTdgaNJTvet3Y1vnUck4qrol9PBl9I0Cja9omuF2CWMArN80enzzRbzPzXarUiFDYlTkY037Vtm6s3vVtn7XyqfkMXmq88flflLP43//b4LN2U8tEjxIXBVI9zEZ926JuO5efldVcmf/v8y8xGQ/wU99xuKenMmvp5jfVjU1KlUBrcxDSZDv3uzvPlVuBEIKI38OvxP4v+JmnGhvJVpgx575bW8+vrxW4I6DGdxxWvgGOjke5spqnXNMa6lMPieeNmW9fk/LtAPk+8XZw++D8xxiPBSzNfFMwybfNynfQy4oRJ1Rxbkb53IJJvps2g+sL8r3dJcxOqHvn8EZvvclWsZaXv/Nh1+Bp5wD+EXlQVVmbtz05vBkVNYYQGe4txAxokO+m/UN95ttu23muzJRYQ/Q6721i7BgGgmOu63zxhcFGAQHIydftRq1/8j0c9iGEfcp3qaoR0tWhYY/vv7lkhOf66PrOKeVbd7D5RQjBXLJF3k14rKXtPIAKsPM6E7g2MxRi0RglXOyNfM+5d1b5PjUdBwTnAq+G9XlYteaiMZXvsKFe7z3l2xL2yPcrBHPJMJ+tnJGK0tWH+n6eq6t5zniuyv+wSfmeVTaj81mlpnU5wVtaLxE16yR6sJ2DtMDOdpjR3qZ8m1Y203b+5B9I2/l9P8v1dbmoTttMvkGqVKZdlMRsW9u5US3gQdsd5XvEVL7b2c5N8m3f3PfT19P8vP9/EUg9B6/7OVkNZRGl4WMA5K+3T7LeTWi6wVt//SF+5He/abtNsmeYJ/hq5vuXP/cSG6Ua/+p7T/ScQrxPdX1f3Uq+MbYF1NRhs/INMoRoteqBbvOHXULXrq3lORtUG2YHa8ZM3DYepaYbcrM3NCcr/Hro+l4vNinf9Y5vBzZcwQQc+U648jUOh0ssbZS7WmrdJTUT2qZPvl/Egl5WiOPXiz3Nx/eCcwsZXILN+SGdOr6bEZ8h545zRHuZjZL1mVarSCnybVvyc0ySzBFthQvL9jmZtkLLLaMZgqFkH+NsbmUB3wHle309w5DIIvqt6/OFMYbmOO6a54sv2JBLoNbR+XKkb9u5x+1iOORrf++JjMrDWIvK91q+QkKY5Lu3NoNDo2Gu6+p7euj6zpeq8j3vUM2YiYOjYW5tlOqVXYAcwSysyvA7hVJVayLfzijfQZ+bZfcYiWqHw+wtyJVrzLhS4PI09rgOYzjsY2YoyGfLp+QXLFaOmcp3eM923hP2yPcrBHPJCF/Uz8r/uPC5vp/nymqe1wbUYmiT8u1xu9g/EuaZlFsqJ12U75vrpSbbuTXyfSAZJuL38J0nOtvZRsI+3C7RUL4DMVmxkb0BtTJ8/TcgMg5nfpjFTBEhYDLuAPkOelk361His3JRr2wnuZ6qurntAvlORnxE/B6utrOdm6fdJXuUb003EAuP8T7xKZi8A17/z3t7AhW6pt+0Tlx2Es8sZDi/uM6DF1Z4y689xJPzu9hJnk/J35/bw9PXM3z08evce2iE7zk10fNT7Vfke35T17dpEW1jPa/IJFm7Zr5BjnNsFC1sToYPyk1mC+W7VNVY2ihzzON8zZiJ28zE81tZaXEdO9aT8p0xle+Qmvl2eXquR7KM2bsBg+P+ZYpVjY1S59fbV1Hv8ZC9aecBr5uMUOtPzpnQtcsrefaPhAn6lDOjWpIkyAohE4JU7ATHxTyXHQhdSyvyHTVy8p466MbfF6LiSzAp1njsqnPrkquwSpooE4k+azO3jLMEvG6iAY/taefCJPixPpVvwDV+ggPiFueu3ar/vvqGeo8vDTDzDfKwouNBxdhxSb4tWIbX8hUS5KkJX8/zznPJMDcMdSDXA/kuFQv4hIZwqGbMREvXX3hUjtkV1hrXU9UJCvV6OhjMmQtM4UbvPMrV/PhSjWlW5H3ANbizzCpOz8T5ZHoOwxOwTL5N5Tuo9+Z2/XbHHvl+hWBuNMzLxjT58Kwk332EfFQ1nevpIifFFXlaFrVvTu9gMsx8pixnqLqQ76WNJuXb4gcx4vfw5Z9/A//su451fJzLJRiN+BvkG2Ti+cYNeObPJQm/56fAG2AhXWQ8ah85aEYi5NusfENL+5XXJN8O2qzaQQjBgWSove08YK/yfXFhif/Ib6ALj7Sbe3w9fX9gWs7ZeVO9VTXtFL7yotxAvff+OTLFCj/424/wR49esyeQp1fkVyA8iq4b/NKnnsXjEvzbt51EiNZBhZ1guk6uNQfzxVoEGTZDHTSVRaBtOGKviAY8ZK2ojEJIEnnr/DbV1AwX3KctyEM4hzd5sIV8gwxdyy835vK7IFOo4nZJ2z3pa5IcOrXhUmvVATVP2M16Hqz1HshkFXmvUs4cIN+6bnBtrbApS6Tu2LKohtbGTuEXVVYv2+/EMZXvkJaVr20fn9utcCVmmCLFY1fWuj+4T3jLa6SMGBPxPi260SmpfDetmV0JZY+oajqh0uDkm/GTuNE5xA2+cmHA96hyKq0acWKB/sl3MuJv3fNtYuyEPBi1QIil8p2j4ov3/P47OBphjSg1l78n27muiK8rZP960oy5Vnk3EbUfbnJzlaoaQYeVb4BqVK45pdUrlh6fK2uMGyvOjB91wKnpBEXDx/r4a+HaI5ZqhU3lO2iYbtc95dsK9sj3KwSym1BwMX6fXDh77IoFWEgX8ehlpqtXbFO969c3GkHTDUrBia6285vrJaIUMdz+nuokRqPWLKxjMf/mTaN5IPDwr0qF+a4fA2AxXXTEcg5SpZKhOVpT3dhm67muGwQ01TW5C8o3wP6RMDfXS63rxswNtU3k2/WFX2LOtcSl0x/oPLPbBmPJUeb1UeIbr8yu7y+9tEwi5OVffM9xPvmT9zEZD/KLf/EsP/fxZyhW2tS5OYXCKoSSPDGf5tzCOu9+7X6OjPd30wv5PIxF/Zvrxrop38p2XnXZNycXC3jJlmrWDjNmXwOGBjee2vRl+XcwSJau7ojlHORGz+sWXFjaGrpmbQ3PFKskgl4EqI5vBzdcqrZmCnkwsLTRnvRUajoRbYOCK9x1RrofFP1KOXOgbuzWRolKTefASNOG2iQJFi39wf2yoaGy8FSXR/aOtbx83f21ddsONjyJWSZcaZ644twcfaiaZo04Q6E+3w/RCdDKm+45oxF7yXcqV2GSPju+m6FmqG8T83xhUOt5bhndEyBPYGDlO1eutb/f9BC6JpXvHJq/9wPKObVfTXvGeiLfhsqX8YQctp0npTNjc92Yyq1oOuwr1TSCOK98u4bkmpNevGTtG8rrRIxcY2+5QzDzMZ4P3w16FS5/tev3lFVdW32vuwtC099G7JHvVwjMdOJH3GpG9qXP9vwcV1Zz3Cau4zY02+a9TZiJ52nPqOyGrBbbPvbWRokhdwnhkP1kLBpgJVtuBMvEpuVp79pluPsnwB+lWNFI5Su2h62ZMLu+14vVxmZ5S+hauaYT69EBYDfm1Nz3JmJlok6+bbBVvvwFjs5/lEf14wy96Z/29RSjUT8vGvsYLl6VIwSvICxvlHh2cYPXHxnF7RKcmIrxVz99P286NsYnn1zkHf/j65sDy5yErknrXDjJizdlpd8bbhssEGv/SIhrzQ6JYVldxNN/2vp3oWznVbd9n69YwENNN+rdqx0xe7f8c4v1fH6twCRreLXCjoStgexKPzQa4cW68t1b6FqmUCEe8kpCUsk6G7CjnjupyZn4Tonn6UKFYZGj6HFmo1wJKPKdsyHQagvM9W7/SFPq/7q1mjETI0dktkBw9byt1wYN5dtX3bBv/jU+jZcalY0lFtIOrEValYiepehN9OWwAdrWjaULVSo1eyovl7Olpo7vwZRvgNfFV3jwpZXBri+/TCUwCgjiwd4yOZrRvevb+sFfKl8hLvIYfbz/khEfUb+HmyQl+bbq/lJ7DW+ktxnzXnEgKQ/dNinfYZVT0JR4XqrqBISpfDtHvoNj8n5aWO6ufNc0nWRNHRDsUNiaidunJfn+Qu20/MLL3SvHSjV5EOTX9wLXesEe+X6FIOL3MBr184XiEfBF+qocu7Ja4JRLfbhtVr7rXd+YXd/tree31ksk3EXHPoRjMT813WDNnLmOqRu6NyzJN7CYkZuPaZtrxkzEQ/ImuF6oNtnON5PvYlUjWk993x3lu2PdmF2Ba4U1+NRPkyfILwd+lrFYf/atgNfNFfcBORu18tJg12QzvnJB3rC/41iD5MZDXj70I3fxgTcf5cVbG7zl17/Gl190Zn51EwprgAHhJBeWJAk+2qfqbWLfcJh0odoIl0rsg/s/ADeehM/9wvZvqJjKt31WvWhAbkotBVxNnQGXd1vo2vxagcMu5czZIeUb5Ou/kC6SK9eaNsDWsgsyhSpDIR+kr8ovOFEzZiKcBE+QREXacpey7cl3KldhSGSp+J2xiJtu+oMAACAASURBVOoh+Vkysk6Qb7nemZtwoKHQWSTf/uQcG0QYz9mfeC5niA3Zs2yXpV8RzSmR4nEn5r5V8n3ZP8D8f2xLQCqN0LVU3p4DV7NmDLD8u26J4YPgCfAq/yLZco3Hrg5g58+tUPLJ1y3er2uAxmu13DbxXI3tWVG+cyUS5HCFe/99CiE4OBrmanVIHsRazI0RqtrM7bDtPBrwMhb1c3mT7VyR7yblu9wcuOZxjnwnJmUDiWZWSXZAvqwxLdQBwQ7VjJmIB73MJcN8ZTkia2ItVI6Zyrdfy8vX0AGX1Lci9sj3KwhzyTAXV8sYh94IC4/V6yms4upqntuFIt82K9+HlPJ9raoIWxvybRiGqhorOmY/GVeJ58umZdKcT73rH9WTkhfSUpmfGXJmjsdUvjPFauMGvyXxvFjVGsr3Lllx5pJmknUr8m1T4Nrf/CJkb/Jvqu9h4sBgAVcrIVWTtfTKCl37ykvLCAEPHN2c8utyCX7mTUf4vX/4aoQQ/B9/9DiLmfauEFvQVDN2YSlL1O9hst8ZTIVG6FqTYvbGfwVzD8DjvysV8GYo23nNxg1LVM1CWpr79gZh8rRUvps2B9dSeW5zq7VpB8LWTJhz3xeXsnKTFxqxpHwbhlG3nTtaM2ZCCIjPECzI12hpvT35XsuVGSaLFnBmo2yozXBlw37yfdUG5RshuB44wlztMlrNWkqxVazlK8TdFYRetY98q7/XlEjxzUGIYhuU1+XvSQ8OkHzfRvkG+xLPV3JlJkUKzeUbLCjQ5YbRY0xVZPVl36nnug75lXrGwSC282S3ru9AHGIzlpTvfDaDR+h9q9BzyTCXKuq9a9F67qlsqOt0PotjLhnmykquMcYUVgfn22a+nbedT09OkDWCeLLdZ/Gz5SozQt3jd9h2DrJy7PJqnvLcm+SIaZf3kql8e2u5PdW7B+yR71cQDibDbJRq5A+8GTAsWT6acWU1zx3uKxiRicbMpk1IhHwMh328VFAfrjbkO6PsY2Hyjlmtza7vumpz/G1S8X7dz9UfY5JvJ2e+Qf598YXlTX6L7bxY0Zr6zndJ+Vabz5aJ537Z6ziw8n3hr8knjvFx7QHOzg52U12PScJkLD072DXZiKqm87ULq5yZTTAcbh0i94bbxvjVHzpDVTP4vYeshar0DWWbM8KSfB8ej/RvA1Uwyfem8QSXG971u1JR+/T/CTebgqdU0JlmI/mOBU3l2yLRmb1bvndTL9e/NL9W4HRg52rGTNw23hS6JoRUv1delBvvDihVdSo1Xaph9Zoxh0N2EvtwbyzgEkbHme/MRhq/qGIE7U06N+GLJqkabrSNW90f3COupfK4BJvHjtYXpKush43/euIkQVFh+bK91vNUvsJsUCludoUCKuX7WHCDxx0g35kV6ShxRQch32aWRFPdmM1d31L5TlGLTA4eZDd+Em9hmWOxKl98sc9DomIaDI0NtySqgwSuWTqoGDsOKxe61lpVspLg+SL9fb4Pjka4gfpey+RbKt87sR86OCr302tmUn1d+d5sO9+JwLWJeJBFkkSK3dPOc+Ua02JnO76bYc59vxy/R37hYmceYirfe+S7N+yR71cQTIvwpfhrAdFz5djCSoYjYgFhs+pt4tBomHMbnbu+b66XAAO/VnBO+Vbke8XcOEbG4O/+5039wKb66NjMd518N9WNbbGdl6paU+r77pDv4bCPaMDT2nbucsnrGmTmO7sE+RWuBo4BgrP7BtxIDh+kZHjRbu2S8p2Zhz94Kzz4y/W06sevpsmWa3zHbZ27bd9wdJTbxqP82Tfn693NjkBdV9aVIF2ocnRs8BueqRBuc0iEk/D3/lDOmX/sPY2DGkW+a247beem8m2VfJt933LuW9cNrqeLHHXdkAdLEfvaHrqhnnheD107qVKH5zt8l5yrBkgEfQ3l20nbOUBiFlErciRc7mg7L2akQuSO2NvxbSIe8pMiBln7RzWupgpMxoP4PU2p8WbHdw+ETJ+Qs4/py4/Zen1r+QqzQXX/sk35luT7dCzHhaXc4PVYW5BNScLsiw3wuYoql1q2cXhvt/K9nC0xJVL9d3w3Q42QvH0qw7VUgVQ/lWhKaV13yXujo8o3SPKtlSHd+RBYy8sDGtGnBXwuGWaxXjdmjXz7q0r53oEWCjPxvG4990WkLbopY6JU03akasztEqQ8EwzVljf1jLdCvlxjWqxgIAbLLOgTp9Tc9yPV2+SBRBfybSrfnqpzgtu3IvbI9ysI5mJxIReEmbvg5S9BzdoNtFTViGUv4KVm+7y3iYPJCM+V1Elnm5mipY0SIcq40B0j32Om7bzDxnHRVL6dmvkOqpnv5rqx7E3QGqSrWNWIoRb+XSLfQgjmkuH/n73zjm/srLP+96p3yXLvbcbTe0smvZGwpEEgBZYWCCVANrDAwsK77wLLyy5LDy1kl04KJIGELATSezIzmcn03jzuXbbVy33/eO6VZVu2ZftK8rA6n08+jm3JumNf3fuc55zfOVPXjVk98yPf3UIReiNSg1EvsaJqfv/OMreNw3Jt/mznBx+Dk8/D0/8G31oOv/8oB3c+DzAj+ZYkidsubMIfiXP/tulJ17ygkO/WsCC+i8vn2LmbgnpvGtu5ipqN8OZ/FzPJv/+IUHMV27msoVqQnPnOdOOiZjz57h4RCdc18TNQ2qJJfVOmqPZYsZn0Y4nnGYauDQXEv7XIZhQ1Y3rzWDBQtqBYGVfYfWOjO2kQHhYKkXE+Sud0h2E10iu70QVmN141E2RZ5nS/f/y8tyyPke9ZwN4gAlAT7domng+MRqgxK+MpWpFvZxUg0WQS1/PXT2s79x0cEqTFVjQPV52tWPTYpyrfGpPvYd8QbimAoUgD8q00F6wzi82Cg50zVy9NgjJj3I+4N2pBvqdXvjMLXZPVvmvr3GznTaV2OmRV+c6s69ucbH/JBfkW98WTauK5JInE84m2cyn7yjeA31qFkRjyDF3fI6EYNVIfQUvZrOtatcCKajeSBLu6QtB4IZx5FUK+KR+vKt/6yEhB+Z4FCuR7AaGpJEV9arlKJN+efimj57YOBLI27508vlI7QzgJuhdB6ytpHyNqxrKb8F2m3Kyns0y2DQYocZixGLPTlzvOdg6iwkdOjHMEBCNxnJKywMpj/UJDsZ3u4TCBSBpF0Vo0P9t5l7CHPz1UxrJK17x/3+UuC4cSdRgCPbPOPNAEKum/5ntQvR5238ut+9/HH6xfZsXgk+M2V9Lh2jVVlLvM/OylU5ql906CMvN9zC82oVTVdT7w2Iw4LQZOD0yxSbPxA7DmFuHGefGbY/3aBu2qxmatfLurBZE8I1TJ0/0BihjGERvKqeUcxOz/4nInh7uUxWWGoWtDQUX5tikz35464UjJJhRb+2LzID0jobHWiAmIKrZUizs7mwEem5Fe2YMx2Jt5WnIG6BuNEIjEx897B/ohFpr1DGV103KGZRv2Ae02AyOxBCPhGGVGZfNYKyJiMIGjnDJZ/N22n9bWeh5TZvNdJfMg3zodOCrGz3yrhHIuqnIaJHyKPV4L1bB8JQCN8VMAHFTaJWYFZUyoJyHWAK55kG+v3YROykD5hhlD1yQ162WOmz+NJXY65dnZzq1xZfMiB8q32tBzYmLi+QTbuUOn3NON2t3L0iGmdH37uk5M+zjVdh6y5V71BhH+3FzqYG+bDxZfAYkYnHh2yscL5VtGFx0p1IzNAgXyvYBQV2xDkpRk6parxBcztJ6f7POzUlLe1NlSvpXE83b3OrHTOTRZ3esaDo1ZrbP0Rix2mNFJMyjfQ9nr+IbUwDVl11SdzUmZ+1aV75jekpcdTBXqOMOpvjSqpsUzv8A1ZTZ7W6Bq3vPeIFwNh2RlgZxhWrSm6N4nFocb3gu3Pk73LX/lt7GLWMEJdA/dCt9ZBX/5Ahx7Mpn4nQqTQcf7tjbSNRzisT1TNwLMC4ryfcAnzqn5Jp2DUO0biu1T16VJErzlW2Ix+vRX4cw2ApgxGudemzMRLkX5zihwTUXtZug9CMEhWvsDLJLUsLXckm+ApeVO+kbDwpqaYeqwT9m8c1tTyHe2oSToNuj7iMZTWiMmQPaLdGubJ0vk22qiT3ajT4QhPAdSMwWSSefjOr5nGbamoNRp4RCNVASOzDi/nynUUYMyg/Je00r5BnBXYwl24bIY2H5SW/ItK9cdb+k8SYGrclzaudduQpK0U76No8o1YD4d3yocZWArodgvciXmRL4V5bsz7sJk0M1rg1qvk/DaZ+hFL10CSNMq37F4ApM6fz3H889mMuB1uxiUPBmR71g8gUMeJY4+6yozQG2RDb1O4mTf6NgXHWViM0R5L4eicZx6lXxn95j03gYABjum7/oOBUYokYaJOPNDvgFWV7tpHQgwXHOx+MLRv0752HA0gZUwkpw9t+vfIgrkewHBbNBT7bFyotcvZgbdtaLvOwNV4FSfn1W6k0SspWN1HhpDTTzfZxC7wZx+edJjunxBnChqb5aUb71OosRhnlL5DsfidA+HqcmS5RzGrGNJ5VuthEjZkBAz30FixvxacRqSYVpTJJ5HRmdUdKdE1z78tmpGsLF2vvPeiHn+Q7JCQHJtPY/HREiW0u8K8MRgBZ+NfZjn3vIsXPYvIOngle/Dr2+A/6iHn18NL3wT2l9PznK9c0sddpOenzx/YixpVUv4ewGJ3f06XBZD0gkyX9QV2+gcDhGKTjGTZrLBTb8SN9jRLgKyBZNeu1uIqnxnVDWmQrWet+3IW82YipbUuW+zUyjMM9jOB5XrR6k0DLFg9ue9Ian+ViHI1FRd37qgIG96exZt54oVV0uXS9qkc3VTdJbKtyRJtNtasMpBGJh+0Zwp+kcF+S7WZ4F8u6qRRrrYUu9ib7tv6vfyHKAP9ROV9ZSUzHMzxlkhrL9KIJhBr6PYbtKEfMuyjDWoWNpdGtjOAcqXY+g7RI3bzIE5Kd+CfHfEnPOynKsodZrpG51mHNFoFTVp02z8DQWjuFFI6TzOv8YSO22JYuQMyLc/HMct+QnqnTkZCTIZdNQWWcfn3TjKQI4n3X6hWAK7Lvs93wD2sgbxmj3TK9/qtUrOQ9K5ilVK6NruUbfYyD765JQ8JByL41DX/AXbecYokO8FBnU+NyEDLVeKBNwMOo9bewZZIp3JmuoNUOu1YdBJvBRdLL4wwRIfisY51DVCsUFZzGXxjVjuskx5s+4cEq+frbA1EAuGUqd5bJbaPbnrW6Sd+4mb8rsbmOz6nq5ubC5z39EQ9B3hjLEJgHW1819ElrssHE4ov8tck++BE8KamkK+nznUg14nsXlli0jTv3MffORFeNO/QcMF0LYDnvoy3HMpfL0JHv4w7nAXN22q41DXCC8e69P+OAP9yNYiDvUEaSl3zjvpXEW914Ysi5GNKeFtgrfdDYAfMyaDdreQMeV7FrVOKaFrpwdSle/c1YypUBPPj3SlhK71H502t0N1zpTGFcKQC+XbWQE6IyVxQQqmmvs2hBXl1Da3mdCZoNrOgXEhSPPFmPKdWjM2u47vVPiLxPUgeHrHvI8NSKYve1SHmJYWXHcNIHNBZYxoXOaNM/OskUyBOTzAoOTGaJjnKJezUoxo+cc2XEocZk1s575glFJZODY0Ub4BylZA1M/5pQGO9YwSjs1yQ0PZWDoTcWhCvkscGWxUlC2D/uPiHp0GA/4IHkkb8n0mUTwp7yYdRiMxXAQIG3K3HhLr6QBxdbRGzdNQNkTC0Th2SVW+s0u+i6pFjWpicPr5eP2Ieq3KfdK5CjXxfE+bDxZdDqNd0Hck7WPD0URKpW6BfGeKAvleYGgqsROKJkQK7Sys5/HuA5ikOMaadVk7NqNeR12xjdcH7ULVSVG+d7UO8nffe4E9bT621igW6yxaUMqcZnpGQmmVxWzXjKlYX+fhQMcwo+FYivI93nbulILIpvxekBqnqxtTF35zmfvuPQhynDeitXhsxmRd1XxQ6jQzgIshfXHuybdqc1fIdyga56XjfWysLxqrh9HpoGIVbP0EvPth+NxpeO9jgph7m2DP/fCDzdxhfgyLLs5Pnp9hl3su8PcSt5bgC0ZZrIHlXEXaurF0WPJmYtf+gO9Eb8A034V4CmY98w3ib2GwwpnXaB0IsNzYKebQ81DRMinxvGy5mJebYtECY7ZzT0Sx4Wa7ZgxEhZy7GndYvOZUyrclohC3+XQlTwO3zUifrCrf2pFvVfmu86bazudOvtUMlZGTGpFvxXbulNX5V22Vb4DNReJar2XlmCM2yKheg+DQZNf3+MRzLZTvnhFRMwZolxSthK6d6+gilpA51jM6wxMmwN8DejMdQaNmyncwGscfnuY6WbNJKLynXkj77f7RCEUq+Z7H5lpTqYMOuVhYjmcIEvOHY7glPxFjLsm3g0gsMbahnKwbE+Q7FI1j0+UmcK26shq/bMY4Q9e3ZVRcq/TeHNwLpsDySjc6CTH3XbNBfLEjfehkqKB8zwkF8r3AoCaen+z1C2XNaIMDf5jReu4eFLO3UlX2yDeIxPPWgQCJuq3Qf4zIUCff+MthbvjRy7QNBPn8m5fyvg3KxTyLtQNlLjPRuJy0baaifUhcaLOpfANsavCSkOGN1iExO21yjqsWUme+5TwlnasosptwW43pZ77Vhd9c5r6VsLUXRipYVe3WRIE16nWUOEyc1DcIC/gMXaWaons8+X7t5AChaIJLl05jszSYofECYUn/0DPw7t+DsxLPy1/lGccXiR1/bm5zgtPB34ffIDZNWjRIOleh2nRnJN9AeMXN/D5xgaa2c4tRh1EvzW7mW2+E6g3Q/jrtfcNC+S5eLAhmjlHiMOG1m0TXNyQX7XRN3RGtjq04gopdPhfkG8BdizUoyE+68Z14QsYW95FAyloysdNsoF9SfrZfO9v56X4/5S4zVlNqzdgZQAJX1ax/nrduOaOyBalrtybHN6AovI6Ecp5oeX9Q1N5msw+TQce2U9oknscTMm55mJBJAxdEknyPTzwPRGYglBmgdyRMldRPTGfRblOjTNwPlukEaZp14vloDzjK8IViSXfPfJBRL/rSq8XHg4+m/fZgIIKbUeI647xIZ1OJnY4M68ZGQjHc+Inl0Am4pla8t97/8+3CBWIvFd9QrjehaEJJO5dAn91cHrfNRCelOEPTb1JYA+K6bClpyOrxTHsMJj0t5U72tA2NuWk73kj72HA0QZFBORcLVWMZo0C+FxgalVCzE31+kb64+kax4zRN6rk/HKM+fFR8kqWkcxXNZXZiCZneYlHB8p/3/JzvP3OM5VUuHrvjfD58UTO6iHJzMmePdE5XNzZWM5bdncwN9eLmvuP0gJhh8tSOU77D4TB2KbwgQigaSuzpbeeWeSjfStjanlgtK6u1+1uXOS0cTNQKC/hAFpTjqdC9X9TgKJblZw6J3fFLpiPfE9F8Kdz+ClzyRcrjXdxn+iqB+28VfehaIB6D4CADiHNKi7A1FfXTZQNMgJrkbjZqdwuRJAmnxchwcJYL8NrNEBmlPnSQ0kRPXua9QRx/S7mDI92jwpFTd674xsnnp3zOUDCCXidhVtWQXMx8A3jq0UdGcOGnK43yPRiIUMQoIb0T9NqF6qVCkiSCJkVV11L57vOPn/cGQQyclWKzZpZoKnOyX27ANXhAk9A11XZuiY+Ie6SWG0XK+JNxtIO1NR52nh4cs9zOA32DQzilIFGLBi4Ip5KWPjy563vaFO8M0DMSokIaIGyr0G6uuGwpIFEdEW0yBzpmuZnq7yVhKyUSS2imfMMMv6uSRcJ5c+hPaXul+/0RPJKfuMkzr99TU6md9gwTzwOBADYpTDyL68KJuGZ1FZ9/81LaBoLc8KOXuf+gcq1Tle9YHCsRsQGR5Tl0SZIYMFbgjfdMex1xKOTcWpo/5RuE9bzDF6LXWC2uU9Mo3159/lt9zjYUyPcCg2oRToZEbL1DhDy98K0pn3Oq389K3Un8Ru/YrnKW0Kx0J373mNhBrB3eyR2XLeb3t583RgRCys0pixaUMtfUdWO5sp2vqHJjNujG+lQ9daJqTLmwysrvQbLmV/kGaCy20TsSFhb5VMxn5rtrH1GDnTa5lFUaku9yl5mdYcUyqBD8nKB7nyDeBnFuPXu4h2qPlcVls1SXDWa46DPoPr6NnebNbPA9QeKuDfDa3fNfvAcHAJnuuDgmLTq+VZQ7LZgMOk4PzKx8R+Li36Gl8g2i63tWgWsAtVsAuFH/nPg8T+QbYGmFi9FwjPahoFBZS5fCiWemdC4NBqK4rUakoVaxAMySxXsSUhLPe9KQ7wF/hCJphJAxu5VAMZuiRE1BvqPxBNtnYZ0eCkQYDsXGJ52DIAaeuQUYNRTb2ZdoxBz3w+DJOf2MVPQr5Nsc9WlfuaRarX3tbGwoYjQc08R509+jEGUtwvdU90Gq8p2JmpsBeoaF7TzunL3DYUqY7OBtxDZ0GLtJP7vfZzwGoz1EreL3ps3Md4a/q2XXiFrK1lcnfWtgNIKHURLzdAdUe6z06FTle3o7dWRUrJNy6QTU6SQ+fFEzf/zE+SytcHL368Jq398jNgpC0TgWwlmf91YRsFVhJkp0uGvKx3giXfTKbowW+5SPyQVW1Yhr076OYahaA1170m7khKMJPHrlXCzYzjNGgXwvMFQXWTHqpbH53OJmWH49HH8KOtPb3lq7h1gqtTLiXZn13Tu1O/Heo3r6pCLeUXqGT13RgjF1Ea7WxmTRglKuKt9pFo5tQ0E8NiMOc3YUGxUmg461tUJdiMUTQnWIR5ILSTkkqjx0Oei0nAljdWMTVM25znzLMnTvpdPcjIyOlVVakm8L+2PKbGau5r5DwyKpXrGcn+zzc6o/wMVLSudupy9qYOj6X3Fb5FOMYIc/fxb2Pzy/41TqflpDNopsxuSiVQvodBJ1XtvUdWMpSCrfGgaugSDfs5r5BmJVYibtGoOyyMxD2JoKdQPyiDr33XSJmIWcIjTTF4gqHd+nheU8BynAQHImfpnNJ/JFJmDAH8ErjRA1aziPnAYGq4cwxinTzr/1xBHe8eNXMibgaZPOoyExdzuXeW/AYtTTaVPOqc701svZQK0a04eHtJ33BjHTqjPAcDubGoVFXIu576E+ocbpnRrUzqnK9wTbOcyffPuGBnBJQfQejZLOVZSvQOo/xpoKEwe7hjNvseg9CIkofo/YEMyZ8g2CfAMc/OOkbw34w7ilUXTzDFM06HXo1XyNGZTviF+ch1IexvCWVDj5/e3nccOF6wF45vV9/PDZY4RjCSyq8p0DxF1iA7Cv7eiUj/FGu+mWSnNyPNNhdXVK6FrVOogG0uaXhGJx3LqC8j1bFMj3AoNeJ1FfbB9fj3D+neLji99O+5yRM3swSXHxBskyVlS52dpczIcubKZo2cVYBw5BYMLNPazazrM78w0iYGUi2geDVGexZiwVGxuK8EdEyvvEujFJUb4NtgWgfKvke6KlOKl8z5J8+9og5OOAXIfTYqDWq93vu8xl4bhchawz5I58q7UsCvl+WrGcTzvvnQEuXlLOyZKLuSH8L+ILUwTgZAxlVu3oqIXFGiadq2gotnFmMDCjVTWskG8t085BkNf2oSD72n0ZP+fZMwmOJyqxoZDIPCrfSyqEE+FwlxJm1HyJ+Hj86bSPHwpGKLLoxbhKriznkLQnt1iG0rqHBkbDFDFCwpqdpPPkYdhE13c65bt3JMzPXzoFkDH5Tpt0PqzM08+RfAP4i1cBIHfMf+67fzSCx2ZECmaBfOv04KwCXxvr64qQJNiuwdx3YEAQZYu7fN4/C7NLkJ2Rybbz+Saex5QkabNX45qmqvUgJ7jE1cFQIEqnL31I4SQoVt0Bt7ivuHKpfJevhKIGQb4nbBb0j4bx4Mdgn//7u6i0irBsJDE0vfKd8IvzUNL6nM8QJoOOj1+1joTeTI1xlK8/fhhZBoucO+XbUCyu8b7OKcbpYmG8iX569Bq8z+aJpZVOjHqJve3Tz32Howncuuw3HP2toUC+FyAaS+y0DgSIKtZOKteIuP8Dj4j6iAmQlN14Z8PGrB+b1aTn3tvO4Z//bhn6hvMAGc68Nv5BIZ+wypuyZ5spd6VXvmPxBF3DoayHranYWC9uXq+fHpxUN6bOvhts+bnZpKJhqsTzuQauKSFSL49WsbJKm7A1FeUuMxGMBJxNoj87MvMM8ryh2tuVcJ1nD/dgMug4t3l+NmCdTuK2Cxo5FvbgN5eKf898EBDKd0fUoWnYmoo6r51oXKZjKDjt49S6Ha1t57ee1wjAj5/LvFP53m2t7JKV+kNJD95mTY9pNlDT5w93Ke6f+vNAZxTW8zQYCkRpMI9AIprbhPYU23nfaFg4d1Iw7BvAKMWRstTxnTwMm5EuuUj0BE8gCHc/d5yg0lO9O8PKLDVUclzzgm9uHd+psFUuJSCbCZ/ZOeefoWLAH6HUpoPIiPa2cxCha8PtuK1Glla42H5qIHOldgqEfGJzxOGtmP/xSZIYjzv9Cvz3lXDvzazc/nm+YPg1TQd/BNv/C44+MWPIbDrEh8RGi6FIY/JdLdw1Gwxi7CBj63m7OF+6HCJ8UQvyPbZRMU3XN4jf87JrYLht0rxuyD+EUYrPW/kGkXjeLhcTG5iBfCujbQZ7HtdDkoTOUcbm0jgfPL8RSQKzFBH5SjmAvVzUsoZ6pxhfUdwDA8b8k2+zQc+SCueY8g1pnT+hWByXVEg7ny0K5HsBorFEhJqps8sAnP9J0Y350ncnPd49JNRBe2P2yfc41J8nPk4MgwsPizdhFi2UxXYTkjRZ+e70hYgn5KyHrakYUxcGxhbPivJtiIgbtG4BzHwnyfdES/FcA9cUsro7WsOqGm3/fepIwbGqa4Vd9A8fndNCbFZISTr3h2O8dmKAc5qKsZnmP7pw3dpqShxmXo82IncfgOj0xHZaKLbzflyahq2pUElL6wxz35EsKd8rq91c2FLKm1ETdgAAIABJREFUn/Z2ZhT81j4U5NnDPfjLlDoUbyMYsptaOx1cFiPVHiuHuxXl2+wQgXCnXprU9x2MxAnHEjTolS74XCWdg5gNlnRU0ocsT1YcQ0PCYWFwZJl8W43sTzQgBfqS100Qm6q/evU0K6pcLK1wsvtMZk4I9ZwZT77nUTOmoLHMxQG5Hn33nnlfiwb8EepsyrmQDRXQVQ2BfogE2NRQRM9IeMb380yIK2MBnlKNMmU2vFfcLwdOwLEncB36LbcZ/sT5rT+G//lH+M3bp9ywmgqhaJxQv3IOaVUzpqJqLSDRGD4EzIJ8d+wERzm9kiC5WtjOPVYjep2UmUV/2bXi4wTreXREcZJosPnTVGqnQy5GNzK97VxWNviNGqjt84K9FJ2/hy9evZznP3MJHkMsZ7bz4irR9S2nXOuS6NoLz3wVAJ9Jg00uDbCq2kPPSJhufYVYK6YJXQtHEzgL5HvWKJDvBYjGdPO59edBzWbYfR8Mj68qqAkeZlBXlPWwtUkoXSoWDyl934CYn81yoqVBr6PYbp7UUduuKHa5Ur7dNiMtZU52nBpEVhd3itKij2ahSmaOcNuMFNmM7O+YMK9mtILePPvAta69yOg4LNeyokrb8QLV1fBCyU0i7+DAI/DCNzR9jUno3i9uLq4qXj7eTySe4JIl2sxdWYx63re1nlfDDUhyHDr3zP2HqeRbdrG4TPsbXV2GXd/ZIt8AH7moiYQM97wwc9L9A9vPkJBh6ebLxRdK8mc5V9FS7uB4z+iYmtx8CUT90LZt3OOGgoKA1UjKvHMulW+9EZxVlMSEojnReh4ZEWMXZld2Zw/dViO7EmJBStv25Nd/+OxxwrEEn7y8hXV1HrqGQ3RlYPU91e+n2G5KdsYDmpDvplI7+xINGCM+MZ8/RyQSMoOBCFUm5fedDfKt1I0x3MGmBkF05ms9l5RxF4tbI1Jw3j/Ax7fBZ47C/+lD/twZLo7exZcqfwQ3/lI85o37ZvUj97T5KJOVjSy3xuTb4oaSFtyDe5GkDOvGoiFxX6laj09pcNCCfOt0EiUOU2bJ8NUbwVEhKsdS7vsJdbNdg/OvscRBh1yCIToqXI9TQFK+Z3Lk2QnoKBPjW7JMrdeGFA3mzHZeWVVLSDZiGlVGYeJR2PcQ/PQq+PH5sO8hdieaOeQ6LyfHMxNWK8LKnvZhsQHVtXdS/WsomtrzXZj5zhQF8r0AoZLvE6nkW5KE+h2PwKs/TH7ZN+qnWW6l07Ykd2E9KnQ6qNsq5kDCo2NfD4/kpO+v3GWepHy35yjpPBUbGoroGg7RHnUIIqvMPpmi2Z99nw2uWlnBwc5hfvlKyuJRksTu9xyU735LDSHMmtaMgfi7AnSPROD6H4rZtaf/DQ7/WdPXSUKWxSKpXAQWPnNYqRhbokG4kILr1lazW1bs0B3zsK4Gxsh3NmznqkPi9MD0qnMy7TwL5PvcpmLW1Lj53Y62adWdWDzBA9tbqXJb2LjxXLGgP+ejmh/PbNFS4SQST4y5TJouFR+Pj1fy1I7vClmcbzmd+Qbw1OKOiI3ciZuY8VFxnlndWSbfNhM71ZGBth0AdPqC3LutldU1bi5bVsYaJXX3jQys560DgfGqN6TYzudOvptLHeyTxUjEVMGnmcAXjJKQodKs/L6z0aGu2uuH29jYIIjO9pPzC10zhZXnZ2MMQZKQLC6izhpej9bB8uuE0HDosfHrihmw7WQ/lfSLT7RWvgGqN6AbOs1ab4wDmSjf3fsgEYNqbck3iLnvjJRvnQ6WXQ39x5Khj7Isow8pf09NbOd2Opi5bkwfFuTb4spRo8NUcJSJMZ/goLj3RwM5U74tJgOdUhklodPw7L/Dt1fCg7eK8YQ17yRy65NcF/kKEUcWzt85QG2x2av2facJXQvHEjhQfodZqqX8W0SBfC9ANJWodWMTbjwtV0HpMtjx0yRZ6j66E7MUY9S7MteHKVC/FeT4eFVHtZ1nGWVOMz3D4XFKrmrVz5XyDbBJWeC83uoTs5TKYs8cWzjKN8A//90y6rw2vvqng2NpzCB2v2cz8x0ehYGTHKUBu0mfrMfTCsUOMzpJIQQmO9x8L1i98NBtU6ZGzwtDrWL+snwFsizzzKEemkrsyYR4LVBTZKXTtkx8Mp+5b38vCST0tiKKNUw6V1HtsaKT4HRfhsq3xjPfIPpQP3JRM+FYgp+/PHW109OHeugeDnPTpjr0ej1c8WVovEDz45ktllaoc9/Ke6xqrSBZJ9KT79KY4mTKpfKtvJ45MoSN0OTWCCVEMxe289NyORGTJ6l8/+CZY0RiCT55RQuSJLGmVhDU3W3TX6NGQlH6RiPjw9ZAEAKTc15Et8xp5rhB2SRIEzqUKdSasTKj8v7Klu0cwNdOpdtKTZGV7afnTr5lWcYSHSQimcCk/YafihJnCqFcc5NY6KdJ6p4K204N0qzrRDY5snPPrRZJ2Ve42znV7ycQmaGVQZn3pmodvqB4r2sx8w1i7rtvNJzZLP+E1PPhUAxHQllbanD+FdtN9BuUjeppyLchIsi3Od/Kt105Vn+vUJ7leM6UbxCW8vJENzz7NeFAuuz/wqcOwFt/xIh3NUDWm3oyRUu5E5NBx552nzJ6wbi5b1mWCccS2ORAwXI+SxTI9wJEqdOM3aQfn3gOYhfz/DshMipCSYDAabGQl9Q3Rq5Rv1V8TLWeh4ZzovaWuyxE4onkjQ2gfUgsampyNPMNY6FrO04poWtDrSDLmOLKDS4HLoBM4LQY+fZNa4knZO64bxchJcwIyyyV754DgMy2YBUrqtzodNo6LvQ6iVKnmW51IVZUDzf+QizG7rtlbp3k06HngPhYvpzD3SN0+kJcrKHqDYJQLm2s4USikoSi8M0Fsr+PIdlBc0V2NnRMBh1VHuuMXd/ZtJ0DvGlFBU0ldn71yunJ3fQK7t3Wil4ncdMmjcOV5gl1Fv+wusGl00PjhWJeLqUZwqfYzt3hLjGmk+sUYEUhrZb6JtnOx5Sx7KpUHpsRkOjzrIbO3bT1DvDA9jOsq/NwcYtQ3ReXObAa9TOGrp1OVzMGghC4a+blDJMkCbmkhRCmedWNDSjku0Sv2DSzajsX1tbNDV5O9PozsymnwXAwRpHsw28oyqq7rtQhCGUiIcOKt4mgwj33Z/TcWDzB0KndbNAdQWq5MjvHqYSubTSeRJYRDSfTQZ2PrVrPcEisUbRUvsOxBCNTXBvHof48cZ4dfBSAQX8Ej6Qd+ZYkCWlC2Gw6GBUnYL7SzpNwKPf20R6IKe9DQ24C1wBONdzIn+Kb+Vj803yp6V7OrPhI0lGi3usWCvk2GXQsq3Sxt82HnEw8H5v7VltPrHJgwTg8zxYUyPcChCRJNJTYk8mt47DyBnDXwas/gkgAnWKBczVtyvFRKqhYLXbDVfIdC0M8nBPCWaakfqYuHNsGgzjNBlzW3F28aoqslDnNSuharSCJgQGsSfK9MJRvgA31Rdxx6WIOdY3w9ccVFdlaNGbBygRK0vkb0VpWVGfn71zusoxX4xovhKu+BgPH4aEPQCKu3YupSeflK3nhiLDbXqTRvHcqNtZ72S03oRs8ObmeL0PERnrpk10syULYmor6Yhut/f5pVRXVdq51z7cKvU7iQxc2MRyKcd9rk8NpzgwEeO5IL5cuLaPCnbuFUyZoLnWg10kcSV2cN18iAjNPPp/80qCifDuD7blXvSGZeF4t9dI1Qfk2RZTNuCyTb5WMdDhWQiLKHx9/nGhc5h+vWJJsUDDodayqdrOnzSeI2RRQyXdDScrGqyyPke95oqHUxcFEnagbm2Pomkq+i3TKxno20s5davaIUCHPaRJ/w1dP9M/px3UNhyiWhgmbsxuUVeo0E43LYjPd5oWWK+HEczDcMeNzD3aOcHPiT+KTLVkaPSlfCXoTTZHDymvOYD3v2Cne1/ZifMEoep2E3aTX5FCSXd+ZWM/1Rmh5M3TtgcFTvHayHzfq+acNEbYoFVrh/jRBYgrMsWESSPknaXbl3u7vGQs/zZHtHODqmz5E7O2/4FTpxfzslTNc/I1nueO+Xexr9y048g2wrtZDvz/Cex7uJmZyj3P+hKNiHWBL+AvK9yxRIN8LFI0ldtqHgmPqpAq9EbZ+QqSZ7vo1Ht9+emUXNXV5qtfRG6B2i5jXi4Zy0vGtolStGxsZWzi2DwWpLrJq3n88HSRJYlODl8PdI4TsquWvFavsJ4Euq1a9ueBjlzSzsb6In750kueO9IobcCKWeaWXQr4PJOpZWZWdjYVyl4WekfD4xfbmD8G6v4djT8JTX9Luxbr3AxKULuXl430Y9RKbG7RfaG5sKGJ3Qp37npwamhH8fQzgSlZaZQP1xXb8kXjSIpsO2er5TsVb11dT5jTzXy+eSFabqXhg+xlkGd65JQ+kdQZYjHoaim1jyjdAk9L3nWI9HwpE0RPHHOjM/bw3JAl/o2Fg3My3sBkrwUkazIROewg2Qb5PWkQV08Dhl9nc4OW8ReNJ/5paN6PhGCcmjmKl4FQy6TxF+fb3QSykCfluKnWwL9GAFOyf1l47HVTy7UY75XESbF6h5CnKt1qX+NKxuZHvzqEAxQyTsGZ3I2ZS1/fqmwAZ9v5uxue+ceQEb9W/yLB3NdRkqfXFYIKKVXiH9gEyBzqmId/hETEiVSWs6r5gFLfVqNm6JOOubxWK9bx3+0P866MHqDJr67xwVzQAEOxNH0b4+L5OCA4RlOzCwZlPJJXvXiGUQE5t5wa9jmvXVPHYJ87n1x/YwtbmYh7d3cHVd73IJx8QxNZhWTjk+47LFnP92ipePN7Py8E6wu272XlKBDCq92VLomA7ny0K5HuBQp37PpWubmfd34OtBF7+HpWh4xzRNWO3aGNnmhPqtwq1u2PnWNplDt6I5crNukdRvhMJ0U9c7cndhVTFhvoiZBlOxpTF6tAZ7Ak/QZ0990F4M8Cg1/Htm9biNBv49O92EzQof6tMrefd+wgY3HRTpHnYmopyl5l4Qh5PACUJ3vItqNkkKvf2PqjNi3XvB28jUYONbScHWFdXhFUjhSIVyypdHNKpc6NzCF2LxzBGhuiTs1MzpqLeqyaeT70ZMzbzrf3vSYXZoOfW8xvpHg7zyK4x9SsaT/DAjjNUe6xcuDi7gWBzxZIKJ6f6/WObp95GKGoYF7o2FIxQKQ2IBPxc1oypcAvy3WIeTF5DQdiMPYyIjcNsBIKlHoJV1MId1reQQGKNdDQ5650Kde77jWkqx5I1Y950Hd/zJ9/NpQ72zjN0bcAvfs+OhLIxkw3yLUli7lvZIKj12qj1WnnleN+cflz/4CBWKYJkz+57LUm+VULZcqU4/3Y/MONzbft+g1WKYDrv9uzeb6s3oAv2s8I6OL3y3bkbkJNz4sMK+dYKSeV7pq5vFc2XIBvtdL/2OyLxBG9qVOoYrdpsrtVXFNMnu4inqdA62DnMd3/7Z5bo2zG7spshkRGSM9/5Ub5VSJLE+YtL+NUHtvDYJ87n2jVVHOsRm3JFtvzVZU6E127iOzev44lPXkS4dBVmOczn736Q9/50G6+eHABkzHH/ghmvPFtQIN8LFI2lSuhab5oFsMkG53wEfGcwEqPLvjTHRzcBqX3fYeWGlAvbuaJ8dyvKd89ImGhczmnYmgo1VXb3sCBF8cFWHCjkewGi1mvjK9evpHckzF+OK4udTELXEgnoPsBJfSMWo57m0uz8+9Su74kpzBjMcNOvRa3eIx+D/uPze6FoUCTBlq9gT9sQ/kicrc3ZUXiMeh3m2rVEZT2JtjmErgWEcjWQpaRzFfUZ1I1le+Zbxbu21OG0GPjx88eTLoinDnbTOxLmls216DXOG9AKLeVOZJnkYgoQ6vfQadFtDPgCUWolJek8H7ZzhZDW6/uT11CAfn+YImmEoMGddZVKJSTbOqMcTdRwjul4UqlNxVo1dG2aue/T/QFcFkNSTQdSasbmnwvQVGpnf0Il33Ob+1Y3E20q+c7W5oa7BnztyU+3NpVwqj+QrOKcDXz9YuPL6CrX7PDSodQhCEeSfBvMsOKt0LM/6bZKBzkeZevAwwxIRVjW3JDVY1Tnvq/0tHOoa2TqMYiUsDUQyrdLQzWzJPm7mrl+D0A2WNht3cTy2CH+5SIvpfqAmKk3aXP/biwRXd/G0fEjAgP+CPf87B4ekL6AVxrBcNGnNXm9ecGhbCKNppLv3K8ZU7Gy2s33blnHc5+5hK++dSVXrVwYPd+pWFTm4IrLrwLgvfWDPH+0lzvu24WdEBJy/scJzjIUyPcChZrYenIq9WnTbSQUO7M/X0nnKqrXi4qt0y+LsDXIUeDaeOVbDVvLZc2YiuWVLmwmPS/2ir9bfLAVFwHChoVrxbl+XTXXr61iZ6+ygMhE+R48CVE/u8LVLKt0YchC2jWMdX33pFtcOCvg6u8IO+mBR+b3Qr2HxSxu+cqkLfO8RdnbnV/TUM4huZb4mR2znxtVasZCpiI8WdwZr/MqdWPTke8sz3yrcFqM/P059Zzo9fPEQdFJfe+2Mxh0EjduXFhBa6lQZ/LHhTI1j68cGwxEqNUpamQ+bOdGCzjKqaSXoUA0qdIP+CN4GREJ5FmGyaDDZtKzp83HzsQiSuK9aWd8qz1WShymaRPPT/cHaCixj1fNNej4VtFYYucoNUQl45yV70GFfJujw+Kema1Fv7tGNDgoTrStio3/leOzt56HhsT7zlaUZfI9UfkGWHOz+Lh76uC1rtceopJ+9lTeIKzh2YRCvjeZThGIxKcOpuzYBUiingmhfGuVdA5jeTeZKt+/29HGf/etRCfJvLtov7jXW7UL0BPkuwR7uCfZAx2NxXns7n/mP8NfwWLUI73rQVj/bk1eb16weEBvEmnnC4R8q6j12njXlnosxuw5yuYF5Xx+Z+0AT3zyQq5dU4VTUju+F+5adyGiQL4XKNSu77TKN4DVQ9fyWwnIZuTazTk8sjQwmIUVuPW1MQKXg5CxEocZSRojaGM1Y7m3EBn0OtbWeni2U48s6ZEHT+OUAkQMC2veeyK+fP1KdMpcZ2dX58xPUBSIXZHarM17A5S5JofpjUPTxcIqduyp+b1Q937lBZfz8vE+rEZ9slc4G9jQ4GVPohljMD3JmA6JETFnZXRpm8Q+Eary3TpN4nmulG+A95/XgMmg40fPHufMQIAXjvZy+bLypPNlIWKJUjc2rtKv8UKQdMm576FAlEVGhQzlQ/kGcNdSGhfkSt3E7PdHKJJGiFmyO++twqOQEn+pkqabpg1AkiTW1Hg42Dk8OQcFCEbidA2H0iedgybk22LUU+p2clJXL5TNeAZJ0xPQ749gM+nRh4Y0JT+TkFI3BnCuErr28hys5xGfcGdYPdlWvsX7uTc1lb12ixjX2PvglCGbuu13E5YNyBven9XjA8DbDGY3i6MzhK517ISSxWBxEY0n8EfimtrOZzPzfahrmP/zyD4OOs5B1pvQHfrjGPnWCDaTAZ+pDD0JGO2CaIi9P3gX7xm+hwFLHaaPPgeLLtPs9eYFSRKhawtI+T5r4KkTowqdb7CozMn3blnHC/+gZCwUyPesUCDfCxQemwmv3TS5biwFL9d8iC3hH1BeuQBCh+q3QtQPp14Un+fgjWjU6/DaTMlFo0q+8zHzDbCxvojRKETtlUi+NlwEiC5g5RvAZTHyzotEt+RvX9ibJFVTQkkGPyjXsTJLSecwpnxPsp2rMFqg4QI48+qY22IuUMh3yLuMnaeH2NzozSqhXF/nYY+shK7Nsu97oE+QdXtRdi1pdrOBEoc5fd6EglyS7zKnhRvW1/DGmSE+8+DuBRu0lor6Yjsmg26s6xtEsnXVepF4nojjC0Zp0CtkKF/k21OLI9qPmUjSej4wGqKIkayHralQFcGtF/+d+ILS9z0Ra2o9RONyWsKjbhQ1FE/YePWdERseripNjrW5zMFfomuFC+WFb876+QP+CF67SYz4ZCPpXMWEurEyl4XFZQ5eOd6fWTd0CuRRseknObK76VfinGA7B0GUVt8sCN2JZyc/qXM35YM7eSxxLmuWtmT1+AAxhlG9Dq/vAHri6cl3YAAGTyXD1oaD2taMqT/LqJfYdmqAbScHpvybjoZj3P6bncQTMl//+/ORmi6BUy+IjV+N399Rhzjn5LYd9H3/ctYP/pmd5s147ngOivMUCDwV7KWK8p37wLWzGpIk+r679iY3H41RZbSqYDufFQrkewGjscQ+JfnuGw1z3/YzjGDL2tztrKD2fR95XHzM0RuxTEnFhlTlO0/kW0nI7jeUYxg6hkFKEDMubPIN0NIgFv5+Xx9PHOie/sFd+4hLBo7KNVkLW4NU8j3Nzv7iK0RKe0p906zRvQ+MNnYMu4nEE1mb91bhtBjxFYvNDnmW5Lu/WyykvaXaEInpIOrGZradm7I0djARH76wCZ0Er54YoM5r4/wsjgZoAb1OYnGZYzz5BlE5FvJx9I3n6R4OUSP1CiUhX6qBQvorpf7kRpff149ektHZs/teUPGecxu449JFLF+1Udw3piHfkH7uO23SOQjl21kpWkI0QFOJnbsi1xApXgbP/cfYbG+GGPBHKLabNFceJ2FC3RjA1uZiOn0hTk3zvk4HXUhxZ2S5ds5mMuAwGyaruatvFB/3TA5ek1/7MQBPud4qNjVygeoN6OIhluvb05NvNUyzeizpHNDUdi5JEjdvquNUv58b736FG370Mn/Z3zVuBl2WZf754b2c6PXzuTcvZX1dkUg9T8TESILG55++SIwByQ/eSolvL78xvI3Gjz+K0Z7nXu90cJTBaHcK+c69W/KsRdU6MfLXe0h8ruY8FZTvWaFAvhcwGort9PsjyYu3il2tg1xz14u8fnqQ921tYFHZArA2124GnWEsXTZHyYdlTjPdwyFkWaZ9KIjFqMvdTXgC1tV50EnQGveii4mFbPxs2A1UQn+8Oj8P7Dgz/WO79tJuqEPSm1hclr2LbZFN7Oz3TKV8w5iN7dgTc3sRWRbku2w5L50QvdvZnPdWUda4Gr9sJnx6sr12OowMdAFQWT1/C+1MqPfa6PdHkr2jExFWrL/ZnvlW0VBi580rKwG4eXMtugUatJaKJRVOuoZD+AJRekfCPLyzje+dEn+7Rx/6NYOBKFVyT37mvVUoQWQ1Ul9yoyvkU8YbnLnZ4Hjnljo+9aYliqq4QczLxqOTHremRmz2vZGGfCeTztMp3xpYzlU0l9qJYGTv5q8LRf33Hx6zrs6A0XCMvtEwJbkg3xOUb4Bzm8XfczbW81A0jj2qjJJlOe0cxNz3JPJd3Aw1m+HgHyGcEmA42gt7HmR7ooWiRTkcvVPmvi9ztaWvG2tXaiSVsLXhkLiGaql8A3zl+pU8+amLuGVzLfvah/nwr17n8m89x/3bWglF49y7rZVHd3dwxfJyPnC+EhS45O/EeQuan3+2UvEakYSOzyY+wcYPfo8i5wJVlB1lEI8IAg4F5Xs2UOa+k3WpyXrhAvmeDQrkewGjSVG0TynqtyzL/PrV09x49ysM+CN88x1r+NdrV+S003pKmOxjb0rImfJd7jITjiUYDsVoGwxQ7cltx3cqnBYjSypc7POPKcIJ01lwQVJuwsuL4rxwtJe2wSmUkcAADLexN1bLkgpnVi3HkiRR5rSMS2GeBG+T+O/YU7MPLwMx8xXoh/IVvHy8H7fVyLLK7J+3GxpL2Cc3ou96Q6THZwh19rK2JvtkTVUQp6obSyrfOSLfAP901VJu2VzHu7bkkazOAmro2nU/eJFNX32ST/12N3cdKSKIhRu9x7j/1nW4Y335s5xDsuKsWupLbnTFlGwBqzu7NuO0qNkkVBVlvCUVHpuJhmIbu9sm142p4YDjyHc0KKylGpLvplKx0b03VguXfgH6jsCT/5rRc/+4u4NoXObKFpdQH7OqfI+f+QY4p8mLJMHLswhd6x4OUSwpBNOe/c2YUoeZvtE0bqc1NwmV8tBjY197/edIiQg/i13F5sbcjEgASfK9xXyKDl+IocCE0LOOXUKIqFgFjCnfWpNvEPV3X3vbal783CXcfnEzvaNhPvfwXi74+jN86Y8HqCmy8o23rxlbE9mLx9ppND7/XE0b+Xb0Bm6I/CuX3/TxZO7FgoRaNzao9JIbCuQ7YyibSsnGB5V85yDn6W8JBfK9gJEMXesTfbGf/t0evviHfVS6rTx8+1Zu2JB9BWxWUK3nkLNdsLKUSqqOoWBewtZSsamhiCPhsZuabD4LLkjKRXOJO4Esi2TUtFDmo3dFarI6762iwm3hVF9gWvsziy4X6lbfkdm/QI/49wS9y9jbNsS5TcU5qa7a2OBld6IZY2xU1JxlikAvcXS4irJPimaqGwvncOZbRV2xja+9bVVWFrHZwCaFEAwFo1yzpopvvGMNL/3zlVgXX0Stfx/nOHtFRUs+Or5VeITyXS310qWQ74RSaWd05qFDvWaT+JgmdA2E9fxkn38S4TndH8Bm0lOqBFEBY4GGmirfgnwf7/XD1jug7lx47cfj+tunwv3bWrGZ9LxlsRIUmM0OdYsLzO4xJxpi82JFlYtXjvdPXZE1AZ2+EMUME9XbcqIOljrNDAQiROMTNiVXvE1UY6mp57EIbP8vhgxl/DWxkU0NOSTfzgpwVtESE/ecg50TRks6dkLZsuTvK5vkW0WZ08Jnr1rKK5+/jC++ZRkGnYQE/OCd63HbJrzusmvFR40zB1bXevmN9Z1cc9WbedOKhVeVNQ5qfsGQQr4LynfmcNeIEZSk8l2wnc8FBfK9gKGS7xeO9vG2H77MQzvbuGRJKX/8+PmsyGLS9Jyh7qhCTpVvQEnBTeSlZiwVG+qLaJPHFAL5bNgN1BvA7KLUEKDCZeHB19uIp1ucjQtby/6/6/3nNRCIxLjx7lc43jua/kGLrhAfjz05+xdQNhP2x2pIyGN1PNlGtcdKq2Wp+CTDue9EQsYUHsCvc2a9exnGyPcjkvMzAAAgAElEQVSjb3SkTZdOBq7laOb7bMT6uiK2f+FyXv/iFdx1yzrevqFGJLQ3XyqUzzfuFQ/Mp/Kt2M6bDGMz37pgbmZ806JGSc49sy3tt9Umgj0T1O9T/X7qiyfWjCnEU4OObxXlLjN2k54TfaOg08P1PwKTAx75GASnrkE70DHM7jYfV6+uxB5XFqvZVL5BWM9TbOcAW5tLGPBHONw9MsWTxkNVvqOW3JwLpU4zsixm48fB5oWWK+HkczDcCQcfhdEufqe7kkqvk6pch6xWr8frP46V0Pi57+FOGOlMhq1Bysy3Jfubhg6zgQ9e0MTzn72EVz9/WTInYRxWvV3Yz1uu0vS1ix1mtn/hMj5y0QILV0sHdYRCVb4LM9+ZQ5KE+t21T4wHFWznc0Jh5bSAoXZ9P7SzjYNdw9x5+WL++72bJu9kLhTUbQEkMNoFocsBShXle1erWPjkK2xNxaYGL+0p5FtnPQvIN4DVgy40xDs21tA+FOTFY2nmArsU8p2oz2rNmIqrV1fxnZvX0Tsa5qa7X+FQV5r5uobzRF/u0TnMfSvk+6kB8ffa2py7EC99nSAZ4dPpw6Um4sxggCJ5mJApN4vg1TUeLmop5fH9Xbzthy9Psp9HYgl0Elnref9bQanTPNlN0XyJ+KiqeEUNOT2mcTA7wOqlXt+fbI0whJQZ33yQb5sXihfNKnQtHIvTMRRMk3SuXc2YCkmSaCy1c0KtAPU2wpX/T5DcP392yuc9sL0VgJs21Ymkc8hu2jkI6/lwx7iRnHOb1cqxzKznnT5BvhO23Fwb03Z9q1h9E8gJ2Ps7ePVHyAYLPxg+P7eqt4rqDUhynBXSKQ6kku8JYWuQnbTzmWDU6yiaKvvG5oVb7kva4rXEghiBzASq8q1u0BWU79mhci3Ew9BzMIV8nwX5RgsIhZXTAobVpKepxI7LYuCn793EnZe3LOygIWsRVK4BZ3b7QFOh9kHvbBULxnzVjKmo8ljBWZ38/Kwh3xYPBAd5xwahEqmLxXHo3sugvhifzp2zea5r11Txw3etxxeMcvNPXmVf+4R5T5NdjDucfgkiU1djpUX3PnBV8/TpKGVOc05bA5qal9EvOwllSL4Pd41QLA0j54gQ6XUSP33fJu68fDEHu4a5+q4XeXxfV/L7kXgip5bzvymUtICzaoyE5dN2DuCppZK+ZHClOaocV46qxiahZhMMngT/5A3AFVUuDDqJ3W1j5LttMEhCniLpHDRVvgFWVrnp9IV4/bSySbH+PUJF3PMA7P/DpMeHonF+v6udlnIH6+vEdRbIjfIdC4lcCwWbGrwYdBKvZBi61jUUxMswBmdu5v9Lp+uvbrlS3Kde+i607+BMzTUM4WRLLue9VShz3xfYWscr32r6vToXS37IdwEzQJ35jisOiwL5nh2qlHynzjcgpKzJCsr3rFBYPS1w/Oa2LTz96Yu5ZGkewm/mght/ATffl7OXUyup1NTRfM98A6xqrKBHFqqG/mwh39YiCPqoK7Zx3qJinjjQTX9q8E08Cj2HOCjXs7jMgcWoz9mhXbmignves5FgJM4t97w6tuhVsehycRM99VLmPzQehd7DhIuXcbh7hK3NxTndtd+gzH3bBw+K+cUZcLxrEI/kx5TDECy9TuLOy1v45a2bMep1fOTXr/Nvjx0gGk8QiSUKlvO5QpLG1G9Izl3nDe5avPE+wpEwvSNhXAlFyciH8g1j1vM0c98Wo55llS7eOONLdhurroxxyrcsQ/9x8f8aKt8AH7xA1N79518OiWOQJLjme6Iy7rE7YaRr3OMf39fFcCjGTZvqxDUmSb6zrXxPrhtzmA2sqfXw2okBYhPnqtPAN9iPSYpjcuWIfE+nfBvMsOKtomMdeMwqZpc3N+bhPK1aC0icYz7F0e7RsRn1jp1gsEDZ8uRDczHzXcAsMbGzvkC+Zwd1c6ljV8F2PkcUVk8LHJVuKyWpITILHUUNULY0Zy+n7pTHlBnlfNvOQYSuqdZzg20Bdlymg9UDYR/ExSIxGpf5/a6UecG+oxAP80akhlU5mPeeiIuXlPGz920inpB5z3+/xqsnUmyTi+cw991/HOIRWo2iHmVrjnujl1Y4OaRbhEGOpk12noiOTvG3sBflPsjmgsWl/M8d57Ohvoj/evEkN//kVXpGwpgMuduA+ZtDk0K+HeX5X/h56tGRoEIa5EDnMF5phLikz5+NsEapjWqbYu671k3faJgOn5hRV0MB64pt0HsEnvkafH8T7P2tIMQa524sKnNww/oaXj0xwEvHlOuQsxyu+a4g1o98fJzV+75trZj0Ot62TnFE5VL5hjRz38WMhGPs6xiGRBz2/A5GutP+iLBPbCToHLkJ30uS73SJ5wBrbhYfGy7gj11FlDjMk8cNcgGLG0paWBI/QiSeEJkksizISMWqcb3yvmAUSQKnJTejeAVkAItHJNKrMFjydyxnI1zVYCuBjjcE+TbaRQZGARmjQL4LOKthMoz1epv0uvFpt3lCauia0XG2kG/lOEM+3rS8HLfVyP3bzyTVpWTYWiI3YWvpsHVRCb+8dTM6SeJ9P9vG80dEJRIlLcJaOpu+b+XfsyNYJX52c27VE4NeR6BUWLdiZ2bu++7rFsnNJlfuRjpSUem2cv+HzuG2Cxp5/fQgx3pGc9bx/TeJpovFx3yGralQE8/p40DnMEXSCGGDRyi6+UDZchGANNXcd834uW9fxzE+qn+UTX++Fn6wCZ77d2Hp33QbvOeRrPw7/uHyxZj0ujH1G2D5tbDmFnEdOvhHAE70jvLayQGuXFkxNoOrBrNlM+0c0taNQercdx/svg8e/iD87M2TFPuDncP09SjPzUHHN8ygfAPUboGrv8PIFf/Joa5htjR68zdnXL0BT7gDL8PCej54SmyspIStgSDfDrNhYY8M/m+DTjd2Thtt+bvWna1QQ9e694mxFkth3nu2KKyeCjjrUabcsKs8lgVxg1ta4eI3umv59+jNmF15qOuZC1Ty/ezXsAyf4q3rqjnWM8pOJciOrr0AHJDrc1IzNhU2Nnj5zW1bMBv0fPAXO4QFXZJg0WUwcGLMajoTlLC1x3u91Bfb8jKu4GwWCp/v2KvTPi6ekAkOKQtje56swIgQny+8ZTl3v3sDTouBYscUgT4FzAxHKVz+JTjvznwfSXImukbq5WDnCEWMEDXncdNQbxAEpn2nUGYnYK0SunbwVDv88jru3P92/sl4P4bRNlj3bnj3H+BTh+At34DK1Vk5xJoiG+/cUsfuNh9/2Z+iGl/+JZB0gtQCD+wQgU63bEoZLciZ8q3azs+M+/L6uiLMBh2vHeuB578hVL+B4/CLa2FUbGgmEjJf+P1evOSu4xvAazchSdOQb0mCje9n+4gXWSa3/d4ToYSqrdadEHVjacLWAIZD0YLlfCEiSb7z75Y8K1G1Voz7de8rWM7ngAL5LuCsh7pbnu+aMRV6nYSxbiM/jl+LNYez0fPC8utEyvD2e+Cu9Xy655+4Ured3207Ib7fvY+IZKKVCpZV5neXc3WNh998cAtI8KnfvoE/HBNz3wDHn87sh3TvR9YZeWmoKOeqt4qVi5s5kyhF17lr2sed7vfjiiuhJjlKHZ4OV66o4NlPX8xP37cp34dyduP8O2HZ1fk+iqT6Xi31cVCxnSeseSQ1IOa+I6PQe2jSt5pKHTjMejYd+CqceJbn9efyRev/Qfr0Mbju+2KePgdtGx+7ZBE2k55v/vXwWDWjs1y4Go4+QXS0n4deb6POa+OcppRrTHAQkDS3w0+CK73t3GLUs7GhiLLWx0Sw3fmfhCu/Bn2H4ZfXgb+fB3acYWfrEG9pUkhjjsi3Ua/DazNNTb4VvHZyACA/SecqlNC1DYYTQvlOE7YGQvkukO8FCIfiIivUjM0N6nmeiBXI9xxQIN8FnPVQQ9dqPAvnIvqxSxZx+8XNeBZqLdxEVK2Dj++A9zwKy6/D0fEKd5u+zSf33UDkya9C5x6OS3U0lLqxmfI/u7ay2s3nrlrK6f4AX/3TQWi8SMxwZTr33b2fIUcTMQw5rRhLxdpaD3vkZtz+k2OhJWlwpHuUYkkh3zmyf86EYof57MqiKGBqqLZzqY/TvT7c+PMXtqaiRtnYSdP3rddJfKxoGxcGnya++CpuDX6CroqLwZBbJ0ap08yt5zVytGeUP6TmY6y6ERJRjjz9S/pGI9y0qXa8Iys0JGya2Z6RNFrEZt0E2znAeU1FfISHiRkdsOXDcO7tQrXv2U/sF9fygz/toMxp5k0NyhIxh9edUqd56plvBdtPDuCyGHLWupEW5StBb+Jcy2kOdAwjd+wEkxOKFwMi5X5X6yADo5EC+V6IUEPXCsr33FC5duz/CzVjs0aBfBdw1qNsgSnfAOc0FfPZq5aePb2XICx9TRfBjb+ET+5n9+KPE0OH6cWvQ6CPNyK1eZv3Tof3bW3gvEXF3PtaK0+fCkLtOXDyeYiGpn9icBCG2ziKqHg6N0/Kt91soMu5HB0ycsfU6vfe9iG8kkLOc6RAFfC/CBYPsslJja4Xp+xHJ8kYHHk+z1TynSbxnN7DfGD4B3TIXl5Y/iViCfITugXcdmETLouBbz95hEhMSbxedjUYrBj2P4heJ/GODRPS1oOD2becq3BXT1K+Ad6se41mXSc7ym8cO5bz74RLvoihZx/fT3yFL19Vizmsdr7n7nwodZqnVb6DkTh72nxsavCiz+eYmcEEFatYGj/KoD9EvH03XY6lfPbhvbz5uy+w4v/+hbf+8GX8kfiCCIItYALUDaVC2Nrc4Koaq2wrKN+zRoF8F3DWI6l8F25w2sFZQdMN/8qVibv4qutf6Gm6gV/HL2dF1cLZ4dTpJP7z7WtwWgx89sG9BOovhmgAWl+Z/ok9BwF4ZbSCpRXOvCq4OsW6OHAk/dz3/+zp5MfPnaDWpHSYLxDlu4C/IUgSkqeOOl0/Rcomj8md5/PMWS7s8BND16JB+N37MSYi/EPk4zx4UCSd1+eJfLutRj5ycTNtg0Hu394qvmh2Emi6kiXhfby9WabMNWFxHxzKHfl21cBwx/jZ+USChv0/JCCb+UnkTeMe/mrtrXwvdj1rdSe4ctfHhS0dcuqEKHWYGQ3HCERiab+/q3WQWEJmUz7nvVVUb8ARH+Ii3W4MMT9/6CnntzvaGApEuHRpGf94RQs/e/8mvnzdynwfaQETkVS+F45j8qyCJI31fReU71mjQL4LOOtx6dIyLllSygWLC8RESzgtRq5aXcM9PUv5D8s/sF9uXFDKN0CVx8qXr1tB32iYb59UkqNnsp4rYWuvhyrzpnqrqFi2hbgsETg52V77p72d3HH/LortJq6o14Okz35CcgH/O+GppYI+SpSALZNzATgsajaJOWQ1HRzgL1+Anv2Mbv0M2+WlPHlQhJ3VF9vzdJDCgVPqNPO9p44lCeMThgsBuM2TRrkPDuXufeyuBjkOoymhcIceQ+o9yHPu63i+TU4ecySW4It/2Mf3uQnf+tuR2rbB0b+KY82hpb9EcbLtax8eS5JPwbZTYt47r2FrKpTN03/yvgDA+Re+ie1fuJxXPn8Z97xnI5+4bDGXLCnDcrZkv/xvgr1gO5831LnvQtr5rFEg3wWc9aj12vjZ+zcng9cK0A43Kym9D+1sA1hQyreK69dW85ZVldxz1E7IXALHnpr6wbIsrOmI2rTz8jTvrWJdcy1H5Roc/XvGff1Pezv5xH2CeN/3oXOwx4bA5hUVKQUUoDXctRiJ0aITydjSAgj2S1rP2xUCe+AR2PHf0Hghzsv/iXKXmVBUWL0b8ki+bSYDn7h0EX2jYX7x8mniCZlvHq9lCCfNnX8a1/lNPAqRkRwq3xPqxmQZnv86GKwMrP4QsYTM9lPCWn7PCyc41jPKxy5ejPua/wdbPiqek+NRl1rFwXbj3a+w/itPcOvPt3PXU0d56VgfI6Eo204OYDXqWVm1ADaCFfK9dPQ1AFZuuqiwDjlb4EipGitgblDnvgu281kj/8lJBRRQwILFhvoimkvtHO/101hix2lZeMExkiTxb9evZPupAR4PreT68LPgaxur2lERHoVHboeDj3LMvIL+sIfNTflVTyrcFnYYW1gafQpGusFZzp8nEO/mUgf4ewuW8wKyByXxfJWUe5vxlKgRVXy07RBNDI98Qswev+0e0OlZU+Phrwe6Megkqjz5ndu8eVMdP3n+BD9+7jjVRVZafVFO1b+Jtd0PiZpGtfJMVfFzNvOdUjdWuwmOPC6O55zbWbu8BZ7s4eXjfTSV2Lnr6aM0ldj5yMVNwlJ61dcE8VbtuTnCTZvq+P/t3Xm8XeO9x/HP95yTE5lEEiIjQYiQSIxNBFeFq+a05oviUlT1GqrEVF6ttlylrrZK0JrVTNqqeQhCTAkJ1SQIUmPMUxD53T+e58jOcc5JTs7Zw0m+79crr+y11rPX8+x1nr32+q1nWN061fLky+/x1Cvv8+CMt7n3+beABY9jHrl6D2prKuBGZPc1oH1X+PwD6NAdVli13CWyxeWW75ZbbYv0pJxB25W7JG1O0c9ektaUNFHSdEmPS1q3kXQHSZoh6QVJF0mqvKt8s2WMJPbMrd+V2Opdp1unWs7cbT3u/nIoAPNn1Ot6/u5LcMl/wnO3Mn+dMezz+fEM7deN5SvgZsKnK6YL8w9fnMTt01Lg3b0w8Ab4dE5lBES2dMozng+tqgu+K6BLb6+hUN0eXp4INxyUApzvXghdegEwLD/vu3/3jtRUlzcQq62p4uit1+KDz77kuBueRoLeW+yfNk69bkHCuWUKvj/8d2r1fuB/0zHd9H8Y3Gt5VujYjokz3+HU8c8y98v5/GLMENrX5C7SEmxxLGzw/dKUNautqWLH9fpw6k7rcuuPRjH1tG258YcjOXmHwWw3pBcDenRij436L3pHpVBVBX1z19u+Gyy4O2CVr0sv0iP/Kve6puK175wm6K33eD1btFL8Yl0IjIuItYAzgUvrJ5C0GvALYHNgILAycEgJymZmi7Dbhv1Zp/fy7Lhe73IXpUnfHtSTXut/h69CvDzp1gUbXrgXxm0Jbz0Ho09l2shzeXNuDaPKPN67TufVvwXA4w/fzRFXT6Zbp1qu+UFB4D3vC5j7gVu+rXi6ppbvNZWGl1RE8F1TC72HwUsPpK7no46ENbf+evPwHHyXa7K1+sas35eBPTsz98v5bDZwRVZeZ4vUEjr1xgUTnn2WZw/vUKIx34Xdzl+4B157KgXTy/emqkqMXL0HU//9Afc+/xa7DO/DqIEVMNygnuXaVbPhqt05ePPVOX+fDbnv2C0Zs37fchdrgdz1nD4blLcc1jwdu8OeV8Koo8pdElsGFTX4ltQT2Ai4Mq+6EegvaWC9pLsB4yPijUgzbFwA7F3MspnZ4uneqZbbjtyc7wyp7OAb4JhdRvB89Vqs+NYjXPPIC0y7/nTiil35ct5XPDLifG7pvCeXPZJmJS7X873rW33IJsyNdgx68+9s3OE1rvnBCAb27LwgwafvpP/9mDErltztvEb5cVmV0suibtx3v41hq1MW2rRev65071TLRquWqBV5EaqrxAnbrU2V4MBRA1Ir6NDd4aPXYNZDKdHXwXeJytylN6gKPpydWr2r2qVHimWb5mC7y3I1nLTD4NKUaWkzcJt0jAduvei0VlkG7wjdPFTASq/YY777A69HxDyAiAhJrwCrADML0q0CvFywPCuv+wZJxwDH1C137VoBk26YWUXoWFtDt2Hb02Xybxn4j70YUjWdGfP7csgnx/DS/V2BKTldNRsNqIyL9rV6d+eXVQcxNi7mKk6k6pVqWOmABV0YP52T/nfLtxVLpxWZX7McVfPm8pXaUV3bedHvKYVhe8Kc6bDD2VC98BCRLsu1Y+LYragtc5fzQqMHr8wzp21L5/b50mq9PeDB36Su56v/R+nHfFfXQOde8ML9aaK3DQ9YaC6M0Wv35P861zJ2u8H07OLnHS+RVUfCSW9AjSdaM7PF0+YmXIuIc4Bz6pb79ev3zWdRmNkyq8+GO8Hk37Jx1XTe6rMVL29yFmPbLRxMrLZip4p5/EtVldjn8FP46L1d6H7bofC3o1JL2U7npllEP3k7JayU1khb+khUrbAKzJlOVecVK2fsau9hsO8NjW6ulO9woa8Db4CVBqXP8Nx42P7sBS3fpXxkYNe+6XnpqobNjl5oU58VOvDEyduUrixLKwfeZtYMxQ6+XwV6S6qJiHmSRGrRfqVeuleANQqWBzSQxsxs0foMh+H7QI816DnqaLZuA4/nWn2lzrDSptB/AtzyI5h2A7w+BXa/DD5xt3Mrga79Yc505Js8rWvoHnDnSTDjjtJ3O4fU0j37cRi2F3QbULp8zcysQUW9Ko2It4CngH3zql2B2RExs17SG4GdJfXKAfphwF+KWTYzW0pVVcOY82Hzn7S952J36AZ7XQXb/hremwUXj4bJl6dt7nZuxZRnPK+IydaWJkN2TWOCn7mu9LOdQ5o1vl3HdD40M7OyK8WV6aHAoZKmA2OBAwEkXSxpZ4CIeBE4FXiYNBb8bdIs6WZmyxYJRh4O/31HCrhfmpDWd3TLtxVRnnTNwxta2fK90/NwZ9yZHnkIpZvtHNJszkc/Cz3WWHRaMzMruqKP+Y6IfwEjG1h/cL3li4CLil0eM7M2od9GcOgEGP9jeHXSQhMlmbW6rg6+i2boHvDi/TDzLqhZDtp1KF3eVdXuzWBmVkHaWJ9MM7NlSMfuqRv6T/4FtZXxPGNbSn3d8u0eFq1u8E4p6I75pe1ybmZmFcfBt5lZpauqvFmdbSnTb2PY+jTYYL9yl2Tps9zyMGi7/LqEXc7NzKziOPg2MzNb1lVVpUdReXhDcQzdI/3vlm8zs2Wag28zMzOzYhq4NaywKvRcu9wlMTOzMir6hGtmZmZmy7SaWvjRJKhuX+6SmJlZGTn4NjMzMyu2Us5ybmZmFcndzs3MzMzMzMyKzMG3mZmZmZmZWZE5+DYzMzMzMzMrMgffZmZmZmZmZkXm4NvMzMzMzMysyBx8m5mZmZmZmRWZg28zMzMzMzOzInPwbWZmZmZmZlZkDr7NzMzMzMzMiszBt5mZmZmZmVmROfg2MzMzMzMzKzIH32ZmZmZmZmZF5uDbzMzMzMzMrMgcfJuZmZmZmZkVmSKi3GVoEUmfA2+XuxyLoTPwcbkLYUsF1yVrLa5L1lpcl6y1uC5Za3FdstbSWF1aKSLaN2dHbT74biskzY6IfuUuh7V9rkvWWlyXrLW4LllrcV2y1uK6ZK2lNeuSu52bmZmZmZmZFZmDbzMzMzMzM7Mic/BdOueUuwC21HBdstbiumStxXXJWovrkrUW1yVrLa1Wlzzm28zMzMzMzKzI3PJtZmZmZmZmVmQOvs3MzMzMzMyKzMF3kUlaU9JESdMlPS5p3XKXydoGSctJuiXXnacl3SVpYN7WU9LtkmZImiZpi3KX19oGSQdKCklj8rLrkjWLpPaSfp/rzFRJV+b1/r2zZpG0vaSnJE3J55/983qfl6xJks6TNCv/ng0vWN/oecjnKGtIQ3WpqWvwvH2Jz1EOvovvQmBcRKwFnAlcWt7iWBszDhgUEcOAW4GL8/ozgEcjYk3gQOBqSe3KVEZrIyQNAH4APFqw2nXJmusMIIC1ImIocGxe7987W2ySBFwJHBARw4EdgQsldcHnJVu0G4DNgJfrrW/qPORzlDWksbrU2DU4tOAc5QnXikhST2Am0D0i5uUfmteBzSJiZnlLZ22NpI2AGyJigKSPgYER8Ube9hhwYkTcXdZCWsWSVAXcCRwPnA2cGxG3uC5Zc0jqRPod6xcRHxas9++dNUuuI3OA70bEBEnrAf8AVgPexeclWwySZgFjImJKU+ch4MPGtvkcZbBwXWpg29fX4Hl5ia+d3PJdXP2B1yNiHkCkOx2vAKuUtVTWVh0J3CqpB9Cu7gufzcL1ypp2DPBwRDxZt8J1yZbAGqTA6ERJT0h6UNJo/HtnzZTryJ7ATZJeBh4C9ge64POSLZmmzkM+R1lLHElq/W7xtVNNqxfNzFqdpBOBgcBooEOZi2NtjKQhwK6Ax01aS9UAqwLPRcRYSesDdwE7lLdY1tZIqgFOBr6XW743BsYDw5t+p5lZ6dS7Bm8xt3wX16tA7/wDU9fFahXSnTazxSLpWOB7wHYR8WlEvAPMk9SrINkAXK+scZuT6siM3K1qBGks0x64LlnzvALMB64CiIjJwEukgNy/d9Ycw4E+ETEBICIeB2YD6+Hzki2Zpq67fU1uzVb/GhygpdfhDr6LKCLeAp4C9s2rdgVme2yJLS5JxwB7A9tExPsFm64HDstpNgb6Ag+UvoTWFkTEHyOid0QMyOOVHgUOiYg/4rpkzRARc4B7gG0BJK1GGqP7MP69s+apC4YGA+SZhNcA/oXPS7YEmrru9jW5NVcT1+DQgnOUJ1wrMkmDSLMp9iBN9nBgREwta6GsTZDUj3Rx8iLwUV79eUR8S9LKwBWki94vgCMi4r7ylNTaGkn3s2DCNdclaxZJqwOXACuSWsF/HhE3+vfOmkvS3sCJpHpUBfw6Iq72eckWRdKFpOEuvYB3gI8iYmBT5yGfo6whDdUlYEsauQbP71nic5SDbzMzMzMzM7Mic7dzMzMzMzMzsyJz8G1mZmZmZmZWZA6+zczMzMzMzIrMwbeZmZmZmZlZkTn4NjMzMzMzMysyB99mZtYoSbWSzpQ0U9I/JU2VtH/B9i0lTSlnGRuSy/WdguU+kh4sZ5mWhKTTJJ1b4jy7S3pY0hRJJ0k6SlKvEuS7s6TfFjufnNcKksbWW3expG+XIv96+Y6RNKLU+ZqZWenVlLsAZmZW0S4F2gPDIuITSQOAf0iqiYhLiplxzmPeEr59S2AF4HaAiHgN2LyVitamLMFx3Ab4OCJG5ffPAu4H3ihmvhExHhjfnDxaYAVgLKt/oKsAAAeASURBVHBGQf4Hlyjv+sYAU4BHy5S/mZmViFu+zcysQZLWJAUGh0TEJwARMQv4CXBqQdIaSZdLmibpSUnD696fW1Cfzi3mp+f17SSdIemx3Lp6naRuedulkv4kaQIwLbe8/r6gTJ0lvStpJUlDJT0k6SlJz0k6OacZDhwG7JP3/zNJAyS9X7CfbfP7npH0gKR18vot8+c4P5f7WUkbNXJ8LpV0oaR7JE2XdJOk2rxtoRZrSUdIujS/PkDS3ZKuyeWeKGkdSTfn3gV3SupckFV/SfdKel7SXyX1aO5xbKDsoyU9Imly/owH5fVbA2cBI+qOHdAHuDYvD29hvl0kXZs/y4P5+BUel1vy67sk7Vbwvi0lTS7Yx0U5/2ckjSs47vdL+k3e9wuSLmjobwdcAHTJ5X+i4L1jCj7HuPx3eil/pk1ymhclnVNQtl75GDymgnrewGcfofT9mJLr2A8lbQ/sDPw0rz84p91P0qRcRydIGlZwjO6VND7XnQlKN8Qa3H8jn93MzMrEwbeZmTVmfWBGRLxTb/0jpIBwpby8LnBZRAwBzgT+IknAEcDfImJYRAwF6gKWnwKfRMQmETEcmAoUBiwbAjtExNrA5cAektrnbbsD90XE28AsYHREbJDfs6ukERExhRRcXRURwyPi54WFl9QTuBrYPyLWA8YBN+QyA6ydP88w4HfAL5s4RsOBnYDBwMrArk2kLbQxcHxErAO8APwVOCwiBgNfAPsXpN0c+K98PF4Ffp3XN+c41vcUsFlErJ/3/zNJ/SLibuBnpGNcd+xeA/bMy1NamO/PgM9Ix2t7YNNGjs+fgQMKlg8E/pRfnw08GBGbAMNI1zJHFqRdA/g2MATYVtLIBvZ/GPBR/kwN3lwBhgI7AoOALYATSL0ChpJu7Kyb010G/CGXZ31gI0m7N7C/E4Df5DyHAH+JiNtIrf1n5fUXSxoF7A1skev2SaT6WmcUC+rO30j1t8H9N/K5zMysTNzt3MzMWmpWRNwDEBHXSRoH9AcmAGflVtwHgLtz+jFAV0l1gWotKZCuc31EfJT392pu8dwZuJ4UkJ2V03UAzldq6Z6f8xzOorvvfguYGhFTcx5XSfoD0DdvnxkRk/LrR4Bjm9jXzRHxKYCkx0iB3+J4JCJeya+fANpFxJt5+XFgzYK0f4+Iui7f44Cb8uvFPo4N6AFcImktYF5eHgLMXoyytyTf0cDRERHAR5KuBQY2kO5m4DxJvYGPSEHwMQX5j5RUt9wB+Krgvdfm7u7zlOYjWIP0d2yuWyNiLoCkqcAdEfEl8KWk54A1lbrkjwZWXnDvhs6kgL2++4BTlHqU3BsRDzWS7y6kmwqTCvbZXVKH/HpiRPwzvx4HnC6puhn7NzOzMnHwbWZmjZlMCjB61Gv9Hgm8GhFvFwQHhQKIiLhR0kRSa+ERwFGk1k4BP46IOxvJ9+N6y38CDpT0JClQuz2v/xUwB1g/IuZJuglYrtmf8pvmFrz+iqZ/KxtLOw+oLthWv1z139ecPCP/39zjWOgC4DZg14gISU81UMbGtCTf+qLBlRGfSboe2A94mxRM1tVB5XJPb2SfzTmWTVmcv1HdF2BEXaDemIg4V9KtwNbAryRNi4jDG0gqUs+LE7+xoeHvW3P3b2ZmZeJu52Zm1qCImEHqDj1OUkeAPL70bOAXBUkHKM8SncfpvgnMzi1wb0bE5cBxQN2MzrcARxfss2NBF96G3ELqpn0CcGXBJF7dgNk58B5ECvLrfAh0bWR/jwJDJQ3J+e8F/Dv/ay0zSd2Pq/PnXNzu6A3ZXtLK+fXBLOhB0NzjWKgb8HIOvLcgtbQ2pv6xbEm+9wL7K+kM7NFE2j+TupsfwIIu53X5Hy+pJuffTVJDredN+RDoUDdWfElFxMekFuevZ05Xmlm/X/20kgZFxEsRcRHpxlHd96H+8R0P7Ctplfy+Ki0878BISXVd+g8mDRH4qon9m5lZhXDLt5mZNeX7pPG8UyV9QWrxOysiCoOhZ4EDJJ1HGq+8dw7qdiMFEV+QbvYeltOfSZpBfZKkKFj3bEMFiIjPJV0HHE4aK1zndOAKpUefvUAK7OrcDOyXux3fRBo7Xre/tyXtA1yeA7j3gN1zmZt1cJpwE2l8+j9JXbknAx2XcF8PAldL6gvMYMFY6GYdx3rGkrrsn0KaaXtSE2nPAy6S9GnOuyX5/hy4hHRc5gBPA+83lDAiHpP0Fam3Q2Er+9GkWcqnSJpP6mVwHOmGx2KJiHclXQ48I+njJsZ9L459gHMkTSO15H8CHMo3u/AfIWkr0nfkK9LEhQBXAJcqTfb2hzzu+zjg5lw/a4G/k4YnAEwEzsw3HN4hfUeb2r+ZmVUIpWFXZmZmZsUlqR1QHRFzJXUC7gB+FxHXlrlobYKkA4AxETGm3GUxM7Pmc8u3mZmZlUo30nPiq0ljzG8FritvkczMzErDLd9mZmZmZmZmReYJ18zMzMzMzMyKzMG3mZmZmZmZWZE5+DYzMzMzMzMrMgffZmZmZmZmZkXm4NvMzMzMzMysyBx8m5mZmZmZmRWZg28zMzMzMzOzIvt/YqHlzUNoRx0AAAAASUVORK5CYII=\n"
 941           },
 942           "metadata": {
 943             "needs_background": "light"
 944           }
 945         }
 946       ]
 947     }
 948   ]
 949 }