From 279b9223091c1b141b0c154bc36db6dd42e490c0 Mon Sep 17 00:00:00 2001 From: zhangyi Date: Fri, 8 Apr 2022 13:51:15 +0800 Subject: [PATCH] add contents in new folder --- .../data_engine/auto_augmentation.md | 142 +++ .../experts/source_en/data_engine/cache.md | 510 ++++++++++ .../experts/source_en/data_engine/eager.md | 188 ++++ .../data_engine/enable_auto_augmentation.md | 232 +++++ .../source_en/data_engine/enable_cache.md | 401 ++++++++ .../data_engine/images/auto_augmentation.png | Bin 0 -> 454686 bytes .../data_engine/images/eager_mode.png | Bin 0 -> 48488 bytes .../data_engine/images/pipeline_mode_en.jpeg | Bin 0 -> 31992 bytes .../optimize_data_processing.ipynb | 787 ++++++++++++++++ .../experts/source_en/debug/auto_tune.md | 86 ++ .../source_en/debug/custom_debugging_info.md | 404 ++++++++ .../source_en/debug/dataset_autotune.md | 225 +++++ .../source_en/debug/debug_in_pynative_mode.md | 836 ++++++++++++++++ .../source_en/debug/dump_in_graph_mode.md | 580 ++++++++++++ .../source_en/debug/images/autotune.png | Bin 0 -> 146204 bytes .../source_en/debug/images/dot_to_png.png | Bin 0 -> 156409 bytes .../debug/incremental_compilation.md | 88 ++ .../experts/source_en/debug/read_ir_files.md | 422 +++++++++ tutorials/experts/source_en/index.rst | 61 +- .../model_infer/inference_ascend_310_air.md | 237 +++++ .../inference_ascend_310_mindir.md | 408 ++++++++ .../model_infer/inference_ascend_910.md | 203 ++++ .../source_en/model_infer/inference_cpu.md | 13 + .../source_en/model_infer/inference_gpu.md | 186 ++++ .../model_infer/offline_inference.rst | 11 + .../source_en/model_infer/online_inference.md | 59 ++ .../model_infer/post_training_quantization.md | 30 + .../experts/source_en/operation/op_ascend.md | 250 +++++ .../source_en/operation/op_classification.md | 624 ++++++++++++ .../experts/source_en/operation/op_cpu.md | 270 ++++++ .../experts/source_en/operation/op_custom.md | 891 ++++++++++++++++++ .../experts/source_en/operation/op_gpu.md | 287 ++++++ .../source_en/others/gradient_accumulation.md | 271 ++++++ .../source_en/others/images/fp16_vs_fp32.png | Bin 0 -> 38727 bytes .../others/images/mix_precision_fp16.png | Bin 0 -> 188851 bytes .../source_en/others/mixed_precision.md | 244 +++++ .../source_en/parallel/auto_parallel.md | 456 +++++++++ .../parallel/distributed_advanced.rst | 12 + .../parallel/distributed_example.rst | 9 + .../parallel/distributed_inference.md | 116 +++ .../parallel/distributed_training.rst | 25 + .../parallel/distributed_training_ascend.md | 687 ++++++++++++++ .../parallel/distributed_training_gpu.md | 137 +++ .../parallel/distributed_training_mode.md | 6 + .../parallel/host_device_training.md | 91 ++ .../images/checkpoint_integrate_process.pptx | Bin 0 -> 57078 bytes .../images/checkpoint_integration_process.jpg | Bin 0 -> 56040 bytes .../parallel/parameter_server_training.md | 156 +++ .../source_en/parallel/pipeline_parallel.md | 152 +++ .../experts/source_en/parallel/recompute.md | 137 +++ .../save_load_model_hybrid_parallel.md | 531 +++++++++++ .../parallel/sharding_propagation.md | 171 ++++ tutorials/experts/source_en/test/test1.md | 3 - .../source_zh_cn/data_engine/eager.ipynb | 2 +- .../model_infer/offline_inference.rst | 2 +- .../model_infer/online_inference.md | 2 +- ...training_comm_fusion.md => comm_fusion.md} | 0 ...ning_dataset_slice.md => dataset_slice.md} | 0 .../parallel/distributed_advanced.rst | 16 +- .../parallel/distributed_example.rst | 4 +- ...ning_fault_recover.md => fault_recover.md} | 0 ...ce_training.md => host_device_training.md} | 0 ...rator_parallel.md => operator_parallel.md} | 0 ..._parallel_opt.md => optimizer parallel.md} | 0 ...aining.md => parameter_server_training.md} | 0 ...eline_parallel.md => pipeline_parallel.md} | 0 .../{apply_recompute.md => recompute.md} | 0 ...training_transformer.md => transformer.md} | 0 68 files changed, 11643 insertions(+), 18 deletions(-) create mode 100644 tutorials/experts/source_en/data_engine/auto_augmentation.md create mode 100644 tutorials/experts/source_en/data_engine/cache.md create mode 100644 tutorials/experts/source_en/data_engine/eager.md create mode 100644 tutorials/experts/source_en/data_engine/enable_auto_augmentation.md create mode 100644 tutorials/experts/source_en/data_engine/enable_cache.md create mode 100644 tutorials/experts/source_en/data_engine/images/auto_augmentation.png create mode 100644 tutorials/experts/source_en/data_engine/images/eager_mode.png create mode 100644 tutorials/experts/source_en/data_engine/images/pipeline_mode_en.jpeg create mode 100644 tutorials/experts/source_en/data_engine/optimize_data_processing.ipynb create mode 100644 tutorials/experts/source_en/debug/auto_tune.md create mode 100644 tutorials/experts/source_en/debug/custom_debugging_info.md create mode 100644 tutorials/experts/source_en/debug/dataset_autotune.md create mode 100644 tutorials/experts/source_en/debug/debug_in_pynative_mode.md create mode 100644 tutorials/experts/source_en/debug/dump_in_graph_mode.md create mode 100644 tutorials/experts/source_en/debug/images/autotune.png create mode 100644 tutorials/experts/source_en/debug/images/dot_to_png.png create mode 100644 tutorials/experts/source_en/debug/incremental_compilation.md create mode 100644 tutorials/experts/source_en/debug/read_ir_files.md create mode 100644 tutorials/experts/source_en/model_infer/inference_ascend_310_air.md create mode 100644 tutorials/experts/source_en/model_infer/inference_ascend_310_mindir.md create mode 100644 tutorials/experts/source_en/model_infer/inference_ascend_910.md create mode 100644 tutorials/experts/source_en/model_infer/inference_cpu.md create mode 100644 tutorials/experts/source_en/model_infer/inference_gpu.md create mode 100644 tutorials/experts/source_en/model_infer/offline_inference.rst create mode 100644 tutorials/experts/source_en/model_infer/online_inference.md create mode 100644 tutorials/experts/source_en/model_infer/post_training_quantization.md create mode 100644 tutorials/experts/source_en/operation/op_ascend.md create mode 100644 tutorials/experts/source_en/operation/op_classification.md create mode 100644 tutorials/experts/source_en/operation/op_cpu.md create mode 100644 tutorials/experts/source_en/operation/op_custom.md create mode 100644 tutorials/experts/source_en/operation/op_gpu.md create mode 100644 tutorials/experts/source_en/others/gradient_accumulation.md create mode 100644 tutorials/experts/source_en/others/images/fp16_vs_fp32.png create mode 100644 tutorials/experts/source_en/others/images/mix_precision_fp16.png create mode 100644 tutorials/experts/source_en/others/mixed_precision.md create mode 100644 tutorials/experts/source_en/parallel/auto_parallel.md create mode 100644 tutorials/experts/source_en/parallel/distributed_advanced.rst create mode 100644 tutorials/experts/source_en/parallel/distributed_example.rst create mode 100644 tutorials/experts/source_en/parallel/distributed_inference.md create mode 100644 tutorials/experts/source_en/parallel/distributed_training.rst create mode 100644 tutorials/experts/source_en/parallel/distributed_training_ascend.md create mode 100644 tutorials/experts/source_en/parallel/distributed_training_gpu.md create mode 100644 tutorials/experts/source_en/parallel/distributed_training_mode.md create mode 100644 tutorials/experts/source_en/parallel/host_device_training.md create mode 100644 tutorials/experts/source_en/parallel/images/checkpoint_integrate_process.pptx create mode 100644 tutorials/experts/source_en/parallel/images/checkpoint_integration_process.jpg create mode 100644 tutorials/experts/source_en/parallel/parameter_server_training.md create mode 100644 tutorials/experts/source_en/parallel/pipeline_parallel.md create mode 100644 tutorials/experts/source_en/parallel/recompute.md create mode 100644 tutorials/experts/source_en/parallel/save_load_model_hybrid_parallel.md create mode 100644 tutorials/experts/source_en/parallel/sharding_propagation.md delete mode 100644 tutorials/experts/source_en/test/test1.md rename tutorials/experts/source_zh_cn/parallel/{distributed_training_comm_fusion.md => comm_fusion.md} (100%) rename tutorials/experts/source_zh_cn/parallel/{distributed_training_dataset_slice.md => dataset_slice.md} (100%) rename tutorials/experts/source_zh_cn/parallel/{distributed_training_fault_recover.md => fault_recover.md} (100%) rename tutorials/experts/source_zh_cn/parallel/{apply_host_device_training.md => host_device_training.md} (100%) rename tutorials/experts/source_zh_cn/parallel/{apply_operator_parallel.md => operator_parallel.md} (100%) rename tutorials/experts/source_zh_cn/parallel/{distributed_training_parallel_opt.md => optimizer parallel.md} (100%) rename tutorials/experts/source_zh_cn/parallel/{apply_parameter_server_training.md => parameter_server_training.md} (100%) rename tutorials/experts/source_zh_cn/parallel/{apply_pipeline_parallel.md => pipeline_parallel.md} (100%) rename tutorials/experts/source_zh_cn/parallel/{apply_recompute.md => recompute.md} (100%) rename tutorials/experts/source_zh_cn/parallel/{distributed_training_transformer.md => transformer.md} (100%) diff --git a/tutorials/experts/source_en/data_engine/auto_augmentation.md b/tutorials/experts/source_en/data_engine/auto_augmentation.md new file mode 100644 index 0000000000..c39910abf0 --- /dev/null +++ b/tutorials/experts/source_en/data_engine/auto_augmentation.md @@ -0,0 +1,142 @@ +# Auto Augmentation + +`Ascend` `GPU` `CPU` `Data Preparation` + + + +## Overview + +MindSpore not only allows you to customize data augmentation, but also provides an auto augmentation method to automatically perform data augmentation on images based on specific policies. + +Auto augmentation can be implemented based on probability or callback parameters. + +> For a complete example, see [Application of Auto Augmentation](https://www.mindspore.cn/docs/programming_guide/en/master/enable_auto_augmentation.html). + +## Probability Based Auto Augmentation + +MindSpore provides a series of probability-based auto augmentation APIs. You can randomly select and combine various data augmentation operations to make data augmentation more flexible. + +For details about APIs, see [MindSpore API](https://www.mindspore.cn/docs/api/en/master/api_python/mindspore.dataset.transforms.html). + +### RandomApply + +The API receives a data augmentation operation list `transforms` and executes the data augmentation operations in the list in sequence at a certain probability or executes none of them. The default probability is 0.5. + +In the following code example, the `RandomCrop` and `RandomColorAdjust` operations are executed in sequence with a probability of 0.5 or none of them are executed. + +```python +import mindspore.dataset.vision.c_transforms as c_vision +from mindspore.dataset.transforms.c_transforms import RandomApply + +rand_apply_list = RandomApply([c_vision.RandomCrop(512), c_vision.RandomColorAdjust()]) +``` + +### RandomChoice + +The API receives a data augmentation operation list `transforms` and randomly selects a data augmentation operation to perform. + +In the following code example, an operation is selected from `CenterCrop` and `RandomCrop` for execution with equal probability. + +```python +import mindspore.dataset.vision.c_transforms as c_vision +from mindspore.dataset.transforms.c_transforms import RandomChoice + +rand_choice = RandomChoice([c_vision.CenterCrop(512), c_vision.RandomCrop(512)]) +``` + +### RandomSelectSubpolicy + +The API receives a preset policy list, including a series of sub-policy combinations. Each sub-policy consists of several data augmentation operations executed in sequence and their execution probabilities. + +First, a sub-policy is randomly selected for each image with equal probability, and then operations are performed according to the probability sequence in the sub-policy. + +In the following code example, two sub-policies are preset. Sub-policy 1 contains the `RandomRotation`, `RandomVerticalFlip`, and `RandomColorAdjust` operations, whose probabilities are 0.5, 1.0, and 0.8, respectively. Sub-policy 2 contains the `RandomRotation` and `RandomColorAdjust` operations, with the probabilities of 1.0 and 0.2, respectively. + +```python +import mindspore.dataset.vision.c_transforms as c_vision +from mindspore.dataset.vision.c_transforms import RandomSelectSubpolicy + +policy_list = [ + [(c_vision.RandomRotation((45, 45)), 0.5), (c_vision.RandomVerticalFlip(), 1.0), (c_vision.RandomColorAdjust(), 0.8)], + [(c_vision.RandomRotation((90, 90)), 1.0), (c_vision.RandomColorAdjust(), 0.2)] + ] +policy = RandomSelectSubpolicy(policy_list) +``` + +## Callback Parameter based Auto Augmentation + +The `sync_wait` API of MindSpore supports dynamic adjustment of the data augmentation policy by batch or epoch granularity during training. You can set blocking conditions to trigger specific data augmentation operations. + +`sync_wait` blocks the entire data processing pipeline until `sync_update` triggers the customized `callback` function. The two APIs must be used together. Their descriptions are as follows: + +- sync_wait(condition_name, num_batch=1, callback=None) + + This API adds a blocking condition `condition_name` to a dataset. When `sync_update` is called, the specified `callback` function is executed. + +- sync_update(condition_name, num_batch=None, data=None) + + This API releases the block corresponding to `condition_name` and triggers the specified `callback` function for `data`. + +The following demonstrates the use of automatic data augmentation based on callback parameters. + +1. Customize the `Augment` class where `preprocess` is a custom data augmentation function and `update` is a callback function for updating the data augmentation policy. + + ```python + import mindspore.dataset as ds + import numpy as np + + class Augment: + def __init__(self): + self.ep_num = 0 + self.step_num = 0 + + def preprocess(self, input_): + return np.array((input_ + self.step_num ** self.ep_num - 1), ) + + def update(self, data): + self.ep_num = data['ep_num'] + self.step_num = data['step_num'] + ``` + +2. The data processing pipeline calls back the custom data augmentation policy update function `update`, and then performs the data augmentation operation defined in `preprocess` based on the updated policy in the `map` operation. + + ```python + arr = list(range(1, 4)) + dataset = ds.NumpySlicesDataset(arr, shuffle=False) + aug = Augment() + dataset = dataset.sync_wait(condition_name="policy", callback=aug.update) + dataset = dataset.map(operations=[aug.preprocess]) + ``` + +3. Call `sync_update` in each step to update the data augmentation policy. + + ```python + epochs = 5 + itr = dataset.create_tuple_iterator(num_epochs=epochs) + step_num = 0 + for ep_num in range(epochs): + for data in itr: + print("epcoh: {}, step:{}, data :{}".format(ep_num, step_num, data)) + step_num += 1 + dataset.sync_update(condition_name="policy", data={'ep_num': ep_num, 'step_num': step_num}) + ``` + + The output is as follows: + + ```text + epcoh: 0, step:0, data :[Tensor(shape=[], dtype=Int64, value= 1)] + epcoh: 0, step:1, data :[Tensor(shape=[], dtype=Int64, value= 2)] + epcoh: 0, step:2, data :[Tensor(shape=[], dtype=Int64, value= 3)] + epcoh: 1, step:3, data :[Tensor(shape=[], dtype=Int64, value= 1)] + epcoh: 1, step:4, data :[Tensor(shape=[], dtype=Int64, value= 5)] + epcoh: 1, step:5, data :[Tensor(shape=[], dtype=Int64, value= 7)] + epcoh: 2, step:6, data :[Tensor(shape=[], dtype=Int64, value= 6)] + epcoh: 2, step:7, data :[Tensor(shape=[], dtype=Int64, value= 50)] + epcoh: 2, step:8, data :[Tensor(shape=[], dtype=Int64, value= 66)] + epcoh: 3, step:9, data :[Tensor(shape=[], dtype=Int64, value= 81)] + epcoh: 3, step:10, data :[Tensor(shape=[], dtype=Int64, value= 1001)] + epcoh: 3, step:11, data :[Tensor(shape=[], dtype=Int64, value= 1333)] + epcoh: 4, step:12, data :[Tensor(shape=[], dtype=Int64, value= 1728)] + epcoh: 4, step:13, data :[Tensor(shape=[], dtype=Int64, value= 28562)] + epcoh: 4, step:14, data :[Tensor(shape=[], dtype=Int64, value= 38418)] + ``` diff --git a/tutorials/experts/source_en/data_engine/cache.md b/tutorials/experts/source_en/data_engine/cache.md new file mode 100644 index 0000000000..f5b8de3782 --- /dev/null +++ b/tutorials/experts/source_en/data_engine/cache.md @@ -0,0 +1,510 @@ +# Single-Node Tensor Cache + +`Ascend` `GPU` `CPU` `Data Preparation` + + + +## Overview + +If you need to repeatedly access remote datasets or load datasets from disks, you can use the single-node cache operator to cache datasets in the local memory to accelerate dataset loading. + +The cache operator depends on the cache server started on the current node. Functioning as a daemon process and independent of the training script, the cache server is mainly used to manage cached data, including storing, querying, and loading data, and writing cached data when the cache is not hit. + +If the memory space is insufficient to cache all datasets, you can configure a cache operator to cache the remaining data to disks. + +Currently, the cache service supports only single-node cache. That is, the client and server are deployed on the same machine. This service can be used in the following scenarios: + +- Cache the loaded original dataset. + + You can use the cache in the dataset loading operator. The loaded data is stored in the cache server. If the same data is required subsequently, the data can be directly load from the cache server, avoiding repeated loading from the disk. + + ![cache on leaf pipeline](./images/cache_dataset.png) + +- Cache the data processed by argumentation. + + You can also use the cache in the `map` operator. The data processed by argumentation (such as image cropping or resizing) is directly cached, avoiding repeated data argumentation operations and reducing unnecessary computations. + + ![cache on map pipeline](./images/cache_processed_data.png) + + > You are advised to cache image data in `decode` + `resize` + `cache` mode. The data processed by `decode` can be directly cached only in single-node single-device mode. + +> For a complete example, see [Application of Single-Node Tensor Cache](https://www.mindspore.cn/docs/programming_guide/en/master/enable_cache.html). + +## Basic Cache Usage + +1. Configure the environment. + + Before using the cache service, you need to install MindSpore and set related environment variables. The Conda environment is used as an example. The setting method is as follows: + + ```text + export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:{path_to_conda}/envs/{your_env_name}/lib/python3.7/site-packages/mindspore:{path_to_conda}/envs/{your_env_name}/lib/python3.7/site-packages/mindspore/lib + export PATH=$PATH:{path_to_conda}/envs/{your_env_name}/bin + ``` + + You can also set the environment with the following code. + + ```python + import os + import sys + import mindspore + + python_path = "/".join(sys.executable.split("/")[:-1]) + mindspore_path = "/".join(mindspore.__file__.split("/")[:-1]) + mindspore_lib_path = os.path.join(mindspore_path, "lib") + + if 'PATH' not in os.environ: + os.environ['PATH'] = python_path + elif python_path not in os.environ['PATH']: + os.environ['PATH'] += ":" + python_path + print(os.environ['PATH']) + + os.environ['LD_LIBRARY_PATH'] = "{}:{}:{}".format(mindspore_path, mindspore_lib_path, mindspore_lib_path.split("python3.7")[0]) + print(os.environ['LD_LIBRARY_PATH']) + ``` + + > When the cache is used, the server memory may be insufficient. Therefore, you are advised to increase the swap memory space of the server to more than 100 GB before using the cache. For details about how to increase the swap memory space on Ubuntu, EulerOS, or CentOS, see [related tutorials](https://help.ubuntu.com/community/SwapFaq#How_do_I_add_a_swap_file.3F). + +2. Start the cache server. + + Before using the single-node cache service, run the following command to start the cache server: + + ```bash + cache_admin --start + ``` + + If the following information is displayed, the cache server is started successfully: + + ```text + Cache server startup completed successfully! + The cache server daemon has been created as process id 10394 and is listening on port 50052 + + Recommendation: + Since the server is detached into its own daemon process, monitor the server logs (under /tmp/mindspore/cache/log) for any issues that may happen after startup + ``` + + `cache_admin` supports the following commands and options: + - `--start`: starts the cache server. The following options are supported: + - `--workers` or `-w`: specifies the number of worker threads on the cache server. By default, the number of worker threads is half of the number of CPUs. This parameter relies on the NUMA architecture of the server. The value will be adjusted automatically by the server if it's not a multiple of number of NUMA nodes in the machine. + - `--spilldir` or `-s`: specifies the disk file path for storing remaining data when the cached data size exceeds the memory space. The default value is '' (which means disabling spilling). + - `--hostname` or `-h`: specifies the IP address of the cache server. The default value is 127.0.0.1. + - `--port` or `-p`: specifies the port number of the cache server. The default value is 50052. + - `--loglevel` or `-l`: sets the log level. The default value is 1 (WARNING). If this option is set to 0 (INFO), excessive logs will be generated, resulting in performance deterioration. + - `--stop`: stops the cache server. + - `--generate_session` or `-g`: generates a cache session. + - `--destroy_session` or `-d`: deletes a cache session. + - `--list_sessions`: displays the list of currently cached sessions and their details. + - `--server_info`：displays the configuration parameters and active session list of current server. + - `--help`: displays the help information. + + In the preceding options, you can use `-h` and `-p` to specify a server. Users can also set environment variables `MS_CACHE_HOST` and `MS_CACHE_PORT` to specify it. If hostname and port are not set, operations are performed on the server with the IP address 127.0.0.1 and port number 50052 by default. + + You can run the `ps -ef|grep cache_server` command to check whether the server is started and query server parameters. + + You can also run the `cache_admin --server_info` command to get the full list of configuration of cache server. + + ```text + $ cache_admin --server_info + Cache Server Configuration: + ---------------------------------------- + config name value + ---------------------------------------- + hostname 127.0.0.1 + port 50052 + number of workers 16 + log level 1 + spill dir None + ---------------------------------------- + Active sessions: + No active sessions. + ``` + + Where, the table of Cache Server Configuration lists five detailed configuration information. Active sessions shows the list of active session ID in current server if any. + + Cache server generates log files with filename "cache_server.\.\.log.\.\.\". Note that there might be masses of DEBUG logs printed to the screen when `GLOG_v=0` is set. + + > - To enable data spilling, you need to use `-s` to set spilling path when starting cache server. Otherwise, this feature is default to be disabled and it will bring up a memory-only cache server. + +3. Create a cache session. + + If no cache session exists on the cache server, a cache session needs to be created to obtain the cache session ID. + + ```text + $ cache_admin -g + Session created for server on port 50052: 1456416665 + ``` + + In the preceding command, 1456416665 is the cache session ID allocated by the server with port number 50052. + + You can run the `cache_admin --list_sessions` command to view all cache sessions on the current server. + + ```text + $ cache_admin --list_sessions + Listing sessions for server on port 50052 + + Session Cache Id Mem cached Disk cached Avg cache size Numa hit + 1456416665 n/a n/a n/a n/a n/a + ``` + + Output parameter description: + - `Session`: specifies the cache session ID. + - `Cache Id`: specifies the ID of the cache instance in the current cache session. `n/a` indicates that no cache instance is created. + - `Mem cached`: specifies the cached data volume in the memory. + - `Disk cached`: specifies the cached data volume in the disk. + - `Avg cache size`: specifies the average size of each line of data in the current cache. + - `Numa hit`: specifies the number of NUMA hits. A larger value indicates better time performance. + +4. Create a cache instance. + + In the Python training script, use the `DatasetCache` API to define a cache instance named `test_cache`, and specify the `session_id` parameter to a cache session ID created in the previous step. + + ```python + import mindspore.dataset as ds + + test_cache = ds.DatasetCache(session_id=1456416665, size=0, spilling=False) + ``` + + `DatasetCache` supports the following parameters: + - `session_id`: specifies the cache session ID, which can be created and obtained by running the `cache_admin -g` command. + - `size`: specifies the maximum memory space occupied by the cache. The unit is MB. For example, if the cache space is 512 GB, set `size` to `524288`. The default value is 0. + - `spilling`: determines whether to spill the remaining data to disks when the memory space exceeds the upper limit. The default value is False. + - `hostname`: specifies the IP address for connecting to the cache server. The default value is 127.0.0.1. + - `port`: specifies the port number for connecting to the cache server. The default value is 50052. + - `num_connections`: specifies the number of established TCP/IP connections. The default value is 12. + - `prefetch_size`: specifies the number of prefetched rows. The default value is 20. + + > - In actual use, you are advised to run the `cache_admin -g` command to obtain a cache session ID from the cache server and use it as the parameter of `session_id` to prevent errors caused by cache session nonexistence. + > - `size=0` indicates that the memory space used by the cache is not limited manually, but automically controlled by the cache_server according to system's total memory resources, and cache server's memory usage would be limited to within 80% of the total system memory. + > - Users can also manually set `size` to a proper value based on the idle memory of the machine. Note that before setting the `size` parameter, make sure to check the available memory of the system and the size of the dataset to be loaded. If the memory of cache_server or the dataset size exceeds the available memory of the system, the server may break down or restart, it may also automatically shut down, or the training process may fail. + > - `spilling=True` indicates that the remaining data is written to disks when the memory space is insufficient. Therefore, ensure that you have the write permission on the configured disk path and the disk space is sufficient to store the remaining cache data. Note that if no spilling path is set when cache server starts, setting `spilling=True` will raise an error when calling the API. + > - `spilling=False` indicates that no data is written once the configured memory space is used up on the cache server. + > - If a dataset that does not support random access (such as `TFRecordDataset`) is used to load data and the cache service is enabled, ensure that the entire dataset is stored locally. In this scenario, if the local memory space is insufficient to store all data, spilling must be enabled to spill data to disks. + > - `num_connections` and `prefetch_size` are internal performance tuning parameters. Generally, you do not need to set these two parameters. + +5. Insert a cache instance. + + Currently, the cache service can be used to cache both original datasets and datasets processed by argumentation. The following example shows two usage methods. + + Note that you need to create a cache instance for each of the two examples according to step 4, and use the created `test_cache` as the `cache` parameter in the dataset loading operator or map operator. + + CIFAR-10 dataset is used in the following two examples. Before running the sample, download and store the CIFAR-10 dataset by referring to [Loading Dataset](https://www.mindspore.cn/docs/programming_guide/en/master/dataset_loading.html#cifar-10-100). + + ```text + ./datasets/cifar-10-batches-bin + ├── readme.html + ├── test + │ └── test_batch.bin + └── train + ├── batches.meta.txt + ├── data_batch_1.bin + ├── data_batch_2.bin + ├── data_batch_3.bin + ├── data_batch_4.bin + └── data_batch_5.bin + ``` + + ```python + import os + import requests + import tarfile + import zipfile + import shutil + + requests.packages.urllib3.disable_warnings() + + def download_dataset(url, target_path): + """ download and unzip the dataset """ + if not os.path.exists(target_path): + os.makedirs(target_path) + download_file = url.split(\"/\")[-1] + if not os.path.exists(download_file): + res = requests.get(url, stream=True, verify=False) + if download_file.split(\".\")[-1] not in [\"tgz\", \"zip\", \"tar\", \"gz\"]: + download_file = os.path.join(target_path, download_file) + with open(download_file, \"wb\") as f: + for chunk in res.iter_content(chunk_size=512): + if chunk: + f.write(chunk) + if download_file.endswith(\"zip\"): + z = zipfile.ZipFile(download_file, \"r\") + z.extractall(path=target_path) + z.close() + if download_file.endswith(\".tar.gz\") or download_file.endswith(\".tar\") or download_file.endswith(\".tgz\"): + t = tarfile.open(download_file) + names = t.getnames() + for name in names: + t.extract(name, target_path) + t.close() + print(\"The {} file is downloaded and saved in the path {} after processing\".format(os.path.basename(url), target_path)) + + download_dataset(\"https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cifar-10-binary.tar.gz\", \"./datasets\") + test_path = \"./datasets/cifar-10-batches-bin/test\" + train_path = \"./datasets/cifar-10-batches-bin/train\" + os.makedirs(test_path, exist_ok=True) + os.makedirs(train_path, exist_ok=True) + if not os.path.exists(os.path.join(test_path, \"test_batch.bin\")): + shutil.move(\"./datasets/cifar-10-batches-bin/test_batch.bin\", test_path) + [shutil.move(\"./datasets/cifar-10-batches-bin/\"+i, train_path) for i in os.listdir(\"./datasets/cifar-10-batches-bin/\") if os.path.isfile(\"./datasets/cifar-10-batches-bin/\"+i) and not i.endswith(\".html\") and not os.path.exists(os.path.join(train_path, i))] + ``` + + - Cache the original loaded dataset. + + ```python + dataset_dir = "./datasets/cifar-10-batches-bin/train" + + # apply cache to dataset + data = ds.Cifar10Dataset(dataset_dir=dataset_dir, num_samples=4, shuffle=False, num_parallel_workers=1, cache=test_cache) + + num_iter = 0 + for item in data.create_dict_iterator(num_epochs=1): # each data is a dictionary + # in this example, each dictionary has a key "image" + print("{} image shape: {}".format(num_iter, item["image"].shape)) + num_iter += 1 + ``` + + The output is as follows: + + ```text + 0 image shape: (32, 32, 3) + 1 image shape: (32, 32, 3) + 2 image shape: (32, 32, 3) + 3 image shape: (32, 32, 3) + ``` + + You can run the `cache_admin --list_sessions` command to check whether there are four data records in the current session. If yes, the data is successfully cached. + + ```text + $ cache_admin --list_sessions + Listing sessions for server on port 50052 + + Session Cache Id Mem cached Disk cached Avg cache size Numa hit + 1456416665 821590605 4 n/a 3226 4 + ``` + + - Cache the data processed by argumentation. + + ```python + import mindspore.dataset.vision.c_transforms as c_vision + + dataset_dir = "cifar-10-batches-bin/" + + # apply cache to dataset + data = ds.Cifar10Dataset(dataset_dir=dataset_dir, num_samples=5, shuffle=False, num_parallel_workers=1) + + # apply cache to map + rescale_op = c_vision.Rescale(1.0 / 255.0, -1.0) + data = data.map(input_columns=["image"], operations=rescale_op, cache=test_cache) + + num_iter = 0 + for item in data.create_dict_iterator(num_epochs=1): # each data is a dictionary + # in this example, each dictionary has a keys "image" + print("{} image shape: {}".format(num_iter, item["image"].shape)) + num_iter += 1 + ``` + + The output is as follows: + + ```text + 0 image shape: (32, 32, 3) + 1 image shape: (32, 32, 3) + 2 image shape: (32, 32, 3) + 3 image shape: (32, 32, 3) + 4 image shape: (32, 32, 3) + ``` + + You can run the `cache_admin --list_sessions` command to check whether there are five data records in the current session. If yes, the data is successfully cached. + + ```text + $ cache_admin --list_sessions + Listing sessions for server on port 50052 + + Session Cache Id Mem cached Disk cached Avg cache size Numa hit + 1456416665 3618046178 5 n/a 12442 5 + ``` + +6. Destroy the cache session. + + After the training is complete, you can destroy the current cache and release the memory. + + ```text + $ cache_admin --destroy_session 1456416665 + Drop session successfully for server on port 50052 + ``` + + The preceding command is used to destroy the cache with the session ID 1456416665 on the server with the port number 50052. + + If you choose not to destroy the cache, the cached data still exists in the cache session. You can use the cache when starting the training script next time. + +7. Stop the cache server. + + After using the cache server, you can stop it. This operation will destroy all cache sessions on the current server and release the memory. + + ```text + $ cache_admin --stop + Cache server on port 50052 has been stopped successfully. + ``` + + The preceding command is used to shut down the server with the port number 50052. + + If you choose not to shut down the server, the cache sessions on the server will be retained for future use. During the next training, you can create a cache session or reuse the existing cache. + +## Cache Sharing + +During the single-node multi-device distributed training, the cache operator allows multiple same training scripts to share the same cache and read and write data from the cache. + +1. Start the cache server. + + ```text + $ cache_admin --start + Cache server startup completed successfully! + The cache server daemon has been created as process id 39337 and listening on port 50052 + + Recommendation: + Since the server is detached into its own daemon process, monitor the server logs (under /tmp/mindspore/cache/log) for any issues that may happen after startup + ``` + +2. Create a cache session. + + Create the shell script `cache.sh` for starting Python training and run the following command to generate a cache session ID: + + ```bash + #!/bin/bash + # This shell script will launch parallel pipelines + + # get path to dataset directory + if [ $# != 1 ] + then + echo "Usage: sh cache.sh DATASET_PATH" + exit 1 + fi + dataset_path=$1 + + # generate a session id that these parallel pipelines can share + result=$(cache_admin -g 2>&1) + rc=$? + if [ $rc -ne 0 ]; then + echo "some error" + exit 1 + fi + + # grab the session id from the result string + session_id=$(echo $result | awk '{print $NF}') + ``` + +3. Pass the cache session ID to the training script. + + Continue to write the shell script and add the following command to pass `session_id` and other parameters when the Python training is started: + + ```bash + # make the session_id available to the python scripts + num_devices=4 + + for p in $(seq 0 $((${num_devices}-1))); do + python my_training_script.py --num_devices "$num_devices" --device "$p" --session_id $session_id --dataset_path $dataset_path + done + ``` + + > Complete sample code: [cache.sh](https://gitee.com/mindspore/docs/blob/master/docs/sample_code/cache/cache.sh) + +4. Create and apply a cache instance. + + CIFAR-10 dataset is used in the following example. Before running the sample, download and store the CIFAR-10 dataset by referring to [Loading Dataset](https://www.mindspore.cn/docs/programming_guide/en/master/dataset_loading.html#cifar-10-100). The directory structure is as follows: + + ```text + ├─cache.sh + ├─my_training_script.py + └─cifar-10-batches-bin + ├── batches.meta.txt + ├── data_batch_1.bin + ├── data_batch_2.bin + ├── data_batch_3.bin + ├── data_batch_4.bin + ├── data_batch_5.bin + ├── readme.html + └── test_batch.bin + ``` + + Create and write the Python script `my_training_script.py`. Use the following code to receive `session_id` and pass it as a parameter when defining a cache instance. + + ```python + import argparse + import mindspore.dataset as ds + + parser = argparse.ArgumentParser(description='Cache Example') + parser.add_argument('--num_devices', type=int, default=1, help='Device num.') + parser.add_argument('--device', type=int, default=0, help='Device id.') + parser.add_argument('--session_id', type=int, default=1, help='Session id.') + parser.add_argument('--dataset_path', type=str, default=None, help='Dataset path') + args_opt = parser.parse_args() + + # apply cache to dataset + test_cache = ds.DatasetCache(session_id=args_opt.session_id, size=0, spilling=False) + dataset = ds.Cifar10Dataset(dataset_dir=args_opt.dataset_path, num_samples=4, shuffle=False, num_parallel_workers=1, + num_shards=args_opt.num_devices, shard_id=args_opt.device, cache=test_cache) + num_iter = 0 + for _ in dataset.create_dict_iterator(): + num_iter += 1 + print("Got {} samples on device {}".format(num_iter, args_opt.device)) + ``` + + > Complete sample code: [my_training_script.py](https://gitee.com/mindspore/docs/blob/master/docs/sample_code/cache/my_training_script.py) + +5. Execute the training script. + + Execute the shell script `cache.sh` to enable distributed training. + + ```text + $ sh cache.sh cifar-10-batches-bin/ + Got 4 samples on device 0 + Got 4 samples on device 1 + Got 4 samples on device 2 + Got 4 samples on device 3 + ``` + + You can run the `cache_admin --list_sessions` command to check whether only one group of data exists in the current session. If yes, cache sharing is successful. + + ```text + $ cache_admin --list_sessions + Listing sessions for server on port 50052 + + Session Cache Id Mem cached Disk cached Avg cache size Numa hit + 3392558708 821590605 16 n/a 3227 16 + ``` + +6. Destroy the cache session. + + After the training is complete, you can destroy the current cache and release the memory. + + ```text + $ cache_admin --destroy_session 3392558708 + Drop session successfully for server on port 50052 + ``` + +7. Stop the cache server. + + After using the cache server, you can stop it. + + ```text + $ cache_admin --stop + Cache server on port 50052 has been stopped successfully. + ``` + +## Limitations + +- Currently, dataset classes such as `GraphDataset`, `GeneratorDataset`, `PaddedDataset`, and `NumpySlicesDataset` do not support cache. `GeneratorDataset`, `PaddedDataset`, and `NumpySlicesDataset` belong to `GeneratorOp`, so their error message is displayed as "There is currently no support for GeneratorOp under cache." +- Data processed by `batch`, `concat`, `filter`, `repeat`, `skip`, `split`, `take`, and `zip` does not support cache. +- Data processed by random data argumentation operations (such as `RandomCrop`) does not support cache. +- The same cache instance cannot be nested in different locations of the same pipeline. + +## Cache Performance Tuning + +The cache service performance can be significantly improved in following scenarios: + +- Cache the data processed by augmentation, especially when the data processing pipeline contains high complexity operations such as decode. In this scenario, you do not need to perform the data augmentation operation repeatedly on each epoch, which saves a lot of time. +- Use cache services during simple network training and inference. Compared with complex networks, simple networks require less training time. Therefore, the time performance is significantly improved when cache services are used in this scenario. + +However, we may not benefit from cache in the following scenarios: + +- The system memory is insufficient or the cache is not hit, resulting in poor cache service time performance. You can check whether the available system memory is sufficient and set a proper cache size before using the cache. +- Too much cache spilling will deteriorate the time performance. Therefore, try not to spill cache to disks when datasets that support random access (such as `ImageFolderDataset`) are used for data loading. +- Using cache on NLP network such as Bert does not perform. In the NLP scenarios, there are usually no high complexity data augmentation operations like decode. +- There is expectable startup overhead when using cache in non-mappable datasets like `TFRecordDataset`. According to the current design, it is required to cache all rows to the cache server before the first epoch of training. So the first epoch time can be longer than the non-cache case. diff --git a/tutorials/experts/source_en/data_engine/eager.md b/tutorials/experts/source_en/data_engine/eager.md new file mode 100644 index 0000000000..c8e32f089b --- /dev/null +++ b/tutorials/experts/source_en/data_engine/eager.md @@ -0,0 +1,188 @@ +# Lightweight Data Processing + +`Ascend` `GPU` `CPU` `Data Preparation` + + +- [Lightweight Data Processing](#lightweight-data-processing) + + + + + +When resource conditions permit, in order to pursue higher performance, data transformations are generally executed in the data pipeline mode. That is, users have to define the `map` operator which helps to execute augmentations in data pipeline. As shown in the figure below, the `map` operator contains 3 transformations: `Resize`, `Crop`, and `HWC2CHW`. When the pipeline starts, the `map` operator will apply these transformations to data in sequence. + +![pipelinemode1](./images/pipeline_mode_en.jpeg) + +Although the data pipeline can process input data quickly, the code of defining pipeline seems heavy while sometimes users just want to focus on the data transformations and perform them on small-scale data. In this case, data pipeline is not necessary. + +Therefore, MindSpore provides a lightweight data processing way to execute these data augmentations, called `Eager mode`. + +In `Eager mode`, the execution of data augmentations will not rely on the `map` operator but can be called directly as callable functions. The code will be simpler since the results are obtained immediately. It is recommended to be used in lightweight scenarios such as small data enhancement experiments and model inference. + +![eagermode1](./images/eager_mode_en.jpeg) + +MindSpore currently supports executing various data augmentations in `Eager mode`, as shown below. For more details, please refer to the API documentation. + +- [vision module](https://www.mindspore.cn/docs/api/en/master/api_python/mindspore.dataset.vision.html) + + - Submodule c_transforms, an image enhancement operator based on OpenCV. + - Submodule py_transforms, an image enhancement operator based on Pillow. + +- [text module](https://www.mindspore.cn/docs/api/en/master/api_python/mindspore.dataset.text.html#mindspore-dataset-text-transforms) + + - Submodule transforms, text processing operators. + +- [transforms module](https://www.mindspore.cn/docs/api/en/master/api_python/mindspore.dataset.transforms.html) + + - Submodule c_transforms, a general-purpose data enhancement operator based on C++. + - Submodule py_transforms, a general-purpose data augmentation operator based on Python. + +Note: In chapters [Image Processing and Enhancement](https://www.mindspore.cn/docs/programming_guide/en/master/augmentation.html), [Text Processing and Enhancement](https://www.mindspore.cn/docs/programming_guide/en/master/tokenizer.html), all data enhancement operators can be executed in Eager mode. + +## example + +The following example introduces how to execute data augmentations in `Eager mode`. + +> To use `Eager mode`, just treat the data augmentations as an executable function and call them directly. + +### data preparation + +Download the image and save it to the specified location. + +```python +import os +import requests + +requests.packages.urllib3.disable_warnings() + +def download_dataset(dataset_url, path): + filename = dataset_url.split("/")[-1] + save_path = os.path.join(path, filename) + if os.path.exists(save_path): + return + if not os.path.exists(path): + os.makedirs(path) + res = requests.get(dataset_url, stream=True, verify=False) + with open(save_path, "wb") as f: + for chunk in res.iter_content(chunk_size=512): + if chunk: + f.write(chunk) + print("The {} file is downloaded and saved in the path {} after processing".format(os.path.basename(dataset_url), path)) + +download_dataset("https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/datasets/banana.jpg", ".") +``` + +### vision + +This example will mix the `c_tranforms` and `py_transforms` operators from the `vision` module to transform a given image. + +You only need to focus on what data augmentations have to use, not any code for the data pipeline. + +The Eager mode of the vision operator supports `numpy.array` or `PIL.Image` type data as input parameters. + +```python +import numpy as np +from PIL import Image +import matplotlib.pyplot as plt +import mindspore.dataset.vision.c_transforms as C +import mindspore.dataset.vision.py_transforms as P + +img_ori = Image.open("banana.jpg").convert("RGB") +print("Image.type: {}, Image.shape: {}".format(type(img_ori), img_ori.size)) + +# Define a Resize op from c_transform and execute it immediately +op1 = C.Resize(size=(320)) +img = op1(img_ori) +print("Image.type: {}, Image.shape: {}".format(type(img), img.shape)) + +# Define a CenterCrop op from c_transform and execute it immediately +op2 = C.CenterCrop((280, 280)) +img = op2(img) +print("Image.type: {}, Image.shape: {}".format(type(img), img.shape)) + +# Define a Pad op from py_transform and execute it immediately +# Before calling Pad, you need to call ToPIL() +op3 = P.ToPIL() +op4 = P.Pad(40) +img = op4(op3(img)) +print("Image.type: {}, Image.shape: {}".format(type(img), img.size)) + +# Show the result +plt.subplot(1, 2, 1) +plt.imshow(img_ori) +plt.title("original image") +plt.subplot(1, 2, 2) +plt.imshow(img) +plt.title("transformed image") +plt.show() +``` + +The output is as follows: + +```text +Image.type: , Image.shape: (356, 200) +Image.type: , Image.shape: (320, 570, 3) +Image.type: , Image.shape: (280, 280, 3) +Image.type: , Image.shape: (360, 360) +``` + +The following shows the processed image. + +![eager_mode](./images/eager_mode.png) + +Augmentation operators that support to be run in Eager Mode are listed as follows: [mindspore.dataset.transforms](https://www.mindspore.cn/docs/api/en/master/api_python/mindspore.dataset.transforms.html), [mindspore.dataset.vision](https://www.mindspore.cn/docs/api/en/master/api_python/mindspore.dataset.vision.html), [mindspore.dataset.text.transforms](https://www.mindspore.cn/docs/api/en/master/api_python/mindspore.dataset.text.html#mindspore-dataset-text-transforms). + +### text + +This example will transform the given text using the `tranforms` operator in the `text` module. + +Eager mode of the text operator supports `numpy.array` type data as input parameters. + +```python +import mindspore.dataset.text.transforms as text +from mindspore import dtype as mstype + +# Define a WhitespaceTokenizer op and execute it immediately +txt = "Welcome to Beijing !" +txt = text.WhitespaceTokenizer()(txt) +print("Tokenize result: {}".format(txt)) + +# Define a ToNumber op and execute it immediately +txt = ["123456"] +to_number = text.ToNumber(mstype.int32) +txt = to_number(txt) +print("ToNumber result: {}, type: {}".format(txt, type(txt[0]))) +``` + +```text +Tokenize result: ['Welcome' 'to' 'Beijing' '!'] +ToNumber result: [123456], type: +``` + +### transforms + +This example will transform the given data using the operators of `c_tranforms` in the `transforms` module. + +Eager mode of transforms operator supports `numpy.array` type data as input parameters. + +```python +import numpy as np +import mindspore.dataset.transforms.c_transforms as trans + +# Define a Fill op and execute it immediately +data = np.array([1, 2, 3, 4, 5]) +fill = trans.Fill(0) +data = fill(data) +print("Fill result: ", data) + +# Define a OneHot op and execute it immediately +label = np.array(2) +onehot = trans.OneHot(num_classes=5) +label = onehot(label) +print("OneHot result: ", label) +``` + +```text +Fill result: [0 0 0 0 0] +OneHot result: [0 0 1 0 0] +``` diff --git a/tutorials/experts/source_en/data_engine/enable_auto_augmentation.md b/tutorials/experts/source_en/data_engine/enable_auto_augmentation.md new file mode 100644 index 0000000000..097f3299fa --- /dev/null +++ b/tutorials/experts/source_en/data_engine/enable_auto_augmentation.md @@ -0,0 +1,232 @@ +# Application of Auto Augmentation + +`Ascend` `GPU` `CPU` `Data Preparation` + + + +## Overview + +Auto Augmentation [1] finds a suitable image augmentation scheme for a specific dataset by searching through a series of image augmentation sub-policies. The `c_transforms` module of MindSpore provides various C++ operators that are used in Auto Augmentation. Users can also customize functions or operators to implement Auto Augmentation. For more details about the MindSpore operators, see the [API document](https://www.mindspore.cn/docs/api/en/master/api_python/mindspore.dataset.vision.html). + +The mapping between MindSpore operators and Auto Augmentation operators is as follows: + +| Auto Augmentation Operators | MindSpore Operators | Introduction | +| :------: | :------ | ------ | +| shearX | RandomAffine | Horizontal shear | +| shearY | RandomAffine | Vertical shear | +| translateX | RandomAffine | Horizontal translation | +| translateY | RandomAffine | Vertival translation | +| rotate | RandomRotation | Rotational transformation | +| color | RandomColor | Color transformation | +| posterize | RandomPosterize | Decrease the number of color channels | +| solarize | RandomSolarize | Invert all pixels within the specified threshold range | +| contrast | RandomColorAdjust | Contrast adjustment | +| sharpness | RandomSharpness | Sharpness adjustment | +| brightness | RandomColorAdjust | Brightness adjustment | +| autocontrast | AutoContrast | Maximize image contrast | +| equalize | Equalize | Equalize image histogram | +| invert | Invert | Image inversion | + +## Auto Augmentation on ImageNet + +This tutorial uses the implementation of Auto Augmentation on the ImageNet dataset as an example. + +The data augmentation policy for the ImageNet dataset contains 25 sub-policies, and each sub-policy contains two transformations. A combination of sub-policies is randomly selected for each image in a batch, and each transformation in the sub-policy is executed based on a preset probability. + +Users can use the `RandomSelectSubpolicy` interface of the `c_transforms` module in MindSpore to implement Auto Augmentation. The standard data augmentation method in ImageNet classification training includes the following steps: + +- `RandomCropDecodeResize`: Randomly crop then decode. + +- `RandomHorizontalFlip`: Randomly flip horizontally. + +- `Normalize`: Normalize the data. + +- `HWC2CHW`: Change image channel. + +Add Auto Augmentation transformation after the `RandomCropDecodeResize` as follows: + +1. Import related modules. + + ```python + import matplotlib.pyplot as plt + + import mindspore.dataset as ds + import mindspore.dataset.transforms.c_transforms as c_transforms + import mindspore.dataset.vision.c_transforms as c_vision + from mindspore import dtype as mstype + ``` + +2. Define the mapping from the MindSpore operators to the Auto Augmentation operators. + + ```python + # define Auto Augmentation operators + PARAMETER_MAX = 10 + + def float_parameter(level, maxval): + return float(level) * maxval / PARAMETER_MAX + + def int_parameter(level, maxval): + return int(level * maxval / PARAMETER_MAX) + + def shear_x(level): + v = float_parameter(level, 0.3) + return c_transforms.RandomChoice([c_vision.RandomAffine(degrees=0, shear=(-v,-v)), c_vision.RandomAffine(degrees=0, shear=(v, v))]) + + def shear_y(level): + v = float_parameter(level, 0.3) + return c_transforms.RandomChoice([c_vision.RandomAffine(degrees=0, shear=(0, 0, -v,-v)), c_vision.RandomAffine(degrees=0, shear=(0, 0, v, v))]) + + def translate_x(level): + v = float_parameter(level, 150 / 331) + return c_transforms.RandomChoice([c_vision.RandomAffine(degrees=0, translate=(-v,-v)), c_vision.RandomAffine(degrees=0, translate=(v, v))]) + + def translate_y(level): + v = float_parameter(level, 150 / 331) + return c_transforms.RandomChoice([c_vision.RandomAffine(degrees=0, translate=(0, 0, -v,-v)), c_vision.RandomAffine(degrees=0, translate=(0, 0, v, v))]) + + def color_impl(level): + v = float_parameter(level, 1.8) + 0.1 + return c_vision.RandomColor(degrees=(v, v)) + + def rotate_impl(level): + v = int_parameter(level, 30) + return c_transforms.RandomChoice([c_vision.RandomRotation(degrees=(-v, -v)), c_vision.RandomRotation(degrees=(v, v))]) + + def solarize_impl(level): + level = int_parameter(level, 256) + v = 256 - level + return c_vision.RandomSolarize(threshold=(0, v)) + + def posterize_impl(level): + level = int_parameter(level, 4) + v = 4 - level + return c_vision.RandomPosterize(bits=(v, v)) + + def contrast_impl(level): + v = float_parameter(level, 1.8) + 0.1 + return c_vision.RandomColorAdjust(contrast=(v, v)) + + def autocontrast_impl(level): + return c_vision.AutoContrast() + + def sharpness_impl(level): + v = float_parameter(level, 1.8) + 0.1 + return c_vision.RandomSharpness(degrees=(v, v)) + + def brightness_impl(level): + v = float_parameter(level, 1.8) + 0.1 + return c_vision.RandomColorAdjust(brightness=(v, v)) + ``` + +3. Define the Auto Augmentation policy for the ImageNet dataset. + + ```python + # define the Auto Augmentation policy + imagenet_policy = [ + [(posterize_impl(8), 0.4), (rotate_impl(9), 0.6)], + [(solarize_impl(5), 0.6), (autocontrast_impl(5), 0.6)], + [(c_vision.Equalize(), 0.8), (c_vision.Equalize(), 0.6)], + [(posterize_impl(7), 0.6), (posterize_impl(6), 0.6)], + [(c_vision.Equalize(), 0.4), (solarize_impl(4), 0.2)], + + [(c_vision.Equalize(), 0.4), (rotate_impl(8), 0.8)], + [(solarize_impl(3), 0.6), (c_vision.Equalize(), 0.6)], + [(posterize_impl(5), 0.8), (c_vision.Equalize(), 1.0)], + [(rotate_impl(3), 0.2), (solarize_impl(8), 0.6)], + [(c_vision.Equalize(), 0.6), (posterize_impl(6), 0.4)], + + [(rotate_impl(8), 0.8), (color_impl(0), 0.4)], + [(rotate_impl(9), 0.4), (c_vision.Equalize(), 0.6)], + [(c_vision.Equalize(), 0.0), (c_vision.Equalize(), 0.8)], + [(c_vision.Invert(), 0.6), (c_vision.Equalize(), 1.0)], + [(color_impl(4), 0.6), (contrast_impl(8), 1.0)], + + [(rotate_impl(8), 0.8), (color_impl(2), 1.0)], + [(color_impl(8), 0.8), (solarize_impl(7), 0.8)], + [(sharpness_impl(7), 0.4), (c_vision.Invert(), 0.6)], + [(shear_x(5), 0.6), (c_vision.Equalize(), 1.0)], + [(color_impl(0), 0.4), (c_vision.Equalize(), 0.6)], + + [(c_vision.Equalize(), 0.4), (solarize_impl(4), 0.2)], + [(solarize_impl(5), 0.6), (autocontrast_impl(5), 0.6)], + [(c_vision.Invert(), 0.6), (c_vision.Equalize(), 1.0)], + [(color_impl(4), 0.6), (contrast_impl(8), 1.0)], + [(c_vision.Equalize(), 0.8), (c_vision.Equalize(), 0.6)], + ] + ``` + +4. Add Auto Augmentation transformations after the `RandomCropDecodeResize` operation. + + ```python + def create_dataset(dataset_path, do_train, repeat_num=1, batch_size=32, shuffle=True, num_samples=5, target="Ascend"): + # create a train or eval imagenet2012 dataset for ResNet-50 + dataset = ds.ImageFolderDataset(dataset_path, num_parallel_workers=8, + shuffle=shuffle, num_samples=num_samples) + + image_size = 224 + mean = [0.485 * 255, 0.456 * 255, 0.406 * 255] + std = [0.229 * 255, 0.224 * 255, 0.225 * 255] + + # define map operations + if do_train: + trans = [ + c_vision.RandomCropDecodeResize(image_size, scale=(0.08, 1.0), ratio=(0.75, 1.333)), + ] + + post_trans = [ + c_vision.RandomHorizontalFlip(prob=0.5), + ] + else: + trans = [ + c_vision.Decode(), + c_vision.Resize(256), + c_vision.CenterCrop(image_size), + c_vision.Normalize(mean=mean, std=std), + c_vision.HWC2CHW() + ] + dataset = dataset.map(operations=trans, input_columns="image") + if do_train: + dataset = dataset.map(operations=c_vision.RandomSelectSubpolicy(imagenet_policy), input_columns=["image"]) + dataset = dataset.map(operations=post_trans, input_columns="image") + type_cast_op = c_transforms.TypeCast(mstype.int32) + dataset = dataset.map(operations=type_cast_op, input_columns="label") + # apply the batch operation + dataset = dataset.batch(batch_size, drop_remainder=True) + # apply the repeat operation + dataset = dataset.repeat(repeat_num) + + return dataset + ``` + +5. Verify the effects of Auto Augmentation. + + ```python + # Define the path to image folder directory. This directory needs to contain sub-directories which contain the images. + DATA_DIR = "/path/to/image_folder_directory" + dataset = create_dataset(dataset_path=DATA_DIR, do_train=True, batch_size=5, shuffle=False, num_samples=5) + + epochs = 5 + itr = dataset.create_dict_iterator() + fig=plt.figure(figsize=(8, 8)) + columns = 5 + rows = 5 + + step_num = 0 + for ep_num in range(epochs): + for data in itr: + step_num += 1 + for index in range(rows): + fig.add_subplot(rows, columns, ep_num * rows + index + 1) + plt.imshow(data['image'].asnumpy()[index]) + plt.show() + ``` + + > For better visualization, only five images are read from the dataset without performing `shuffle`, `Normalize`, nor `HWC2CHW` operations. + + ![augment](./images/auto_augmentation.png) + + The images above visualize the effect of Auto Augmentation. The horizontal direction displays five images in one batch, and the vertical direction displays five batches. + +## References + +[1] [AutoAugment: Learning Augmentation Policies from Data](https://arxiv.org/abs/1805.09501). diff --git a/tutorials/experts/source_en/data_engine/enable_cache.md b/tutorials/experts/source_en/data_engine/enable_cache.md new file mode 100644 index 0000000000..cb0cac5cac --- /dev/null +++ b/tutorials/experts/source_en/data_engine/enable_cache.md @@ -0,0 +1,401 @@ +# Application of Single-Node Tensor Cache + +`Ascend` `GPU` `CPU` `Data Preparation` + + + +## Overview + +If you need to repeatedly access remote datasets or read datasets from disks, you can use the single-node cache operator to cache datasets in the local memory to accelerate dataset reading. + +This tutorial demonstrates how to use the single-node cache service, and shows several best practices of using cache to improve the performance of network training or evaluating. + +## Quick Start + +1. Configuring the Environment + + Before using the cache service, you need to install MindSpore and set related environment variables. The Conda environment is used as an example. The setting method is as follows: + + ```text + export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:{path_to_conda}/envs/{your_env_name}/lib/python3.7/site-packages/mindspore:{path_to_conda}/envs/{your_env_name}/lib/python3.7/site-packages/mindspore/lib + export PATH=$PATH:{path_to_conda}/envs/{your_env_name}/bin + ``` + +2. Starting the Cache Server + + Before using the single-node cache service, you need to start the cache server. + + ```text + $ cache_admin --start + Cache server startup completed successfully! + The cache server daemon has been created as process id 10394 and is listening on port 50052 + + Recommendation: + Since the server is detached into its own daemon process, monitor the server logs (under /tmp/mindspore/cache/log) for any issues that may happen after startup + ``` + + If the system displays a message indicating that the `libpython3.7m.so.1.0` file cannot be found, search for the file path in the virtual environment and set environment variables. + + ```text + export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:{path_to_conda}/envs/{your_env_name}/lib + ``` + +3. Creating a Cache Session + + If no cache session exists on the cache server, a cache session needs to be created to obtain the cache session ID. + + ```text + $ cache_admin -g + Session created for server on port 50052: 1493732251 + ``` + + The cache session ID is randomly allocated by the server. + +4. Creating a Cache Instance + + Create the Python script `my_training_script.py`, use the `DatasetCache` API to define a cache instance named `some_cache` in the script, and specify the `session_id` parameter to a cache session ID created in the previous step. + + ```python + import mindspore.dataset as ds + + some_cache = ds.DatasetCache(session_id=1493732251, size=0, spilling=False) + ``` + +5. Inserting a Cache Instance + + The following uses the CIFAR-10 dataset as an example. Before running the sample, download and store the CIFAR-10 dataset by referring to [Loading Dataset](https://www.mindspore.cn/docs/programming_guide/en/master/dataset_loading.html#cifar-10-100-dataset). The directory structure is as follows: + + ```text + ├─my_training_script.py + └─cifar-10-batches-bin + ├── batches.meta.txt + ├── data_batch_1.bin + ├── data_batch_2.bin + ├── data_batch_3.bin + ├── data_batch_4.bin + ├── data_batch_5.bin + ├── readme.html + └── test_batch.bin + ``` + + To cache the enhanced data processed by data augmentation of the map operator, the created `some_cache` instance is used as the input parameter of the `cache` API in the map operator. + + ```python + import mindspore.dataset.vision.c_transforms as c_vision + + dataset_dir = "cifar-10-batches-bin/" + data = ds.Cifar10Dataset(dataset_dir=dataset_dir, num_samples=5, shuffle=False, num_parallel_workers=1) + + # apply cache to map + rescale_op = c_vision.Rescale(1.0 / 255.0, -1.0) + data = data.map(input_columns=["image"], operations=rescale_op, cache=some_cache) + + num_iter = 0 + for item in data.create_dict_iterator(num_epochs=1): # each data is a dictionary + # in this example, each dictionary has a key "image" + print("{} image shape: {}".format(num_iter, item["image"].shape)) + num_iter += 1 + ``` + + Run the Python script `my_training_script.py`. The following information is displayed: + + ```text + 0 image shape: (32, 32, 3) + 1 image shape: (32, 32, 3) + 2 image shape: (32, 32, 3) + 3 image shape: (32, 32, 3) + 4 image shape: (32, 32, 3) + ``` + + You can run the `cache_admin --list_sessions` command to check whether there are five data records in the current session. If yes, the data is successfully cached. + + ```text + $ cache_admin --list_sessions + Listing sessions for server on port 50052 + + Session Cache Id Mem cached Disk cached Avg cache size Numa hit + 1493732251 3618046178 5 n/a 12442 5 + ``` + +6. Destroying a Cache Session + + After the training is complete, you can destroy the current cache and release the memory. + + ```text + $ cache_admin --destroy_session 1493732251 + Drop session successfully for server on port 50052 + ``` + + The preceding command is used to destroy the cache whose session ID is 1493732251. + +7. Stopping the Cache Server + + After using the cache server, you can stop the cache server. This operation will destroy all cache sessions on the current server and release the memory. + + ```text + $ cache_admin --stop + Cache server on port 50052 has been stopped successfully. + ``` + +## Best Practices + +### Using Cache to Speed Up ResNet Evaluation During Training + +For a complex network, epoch training usually needs to be performed for dozens or even hundreds of times. Before training, it is difficult to know when a model can achieve required accuracy in epoch training. Therefore, the accuracy of the model is usually validated at a fixed epoch interval during training and the corresponding model is saved. After the training is completed, users can quickly select the optimal model by viewing the change of the corresponding model accuracy. + +Therefore, the performance of evaluation during training will have a great impact on the total end-to-end time required. In this section, we will show an example of leveraging the cache service and caching data after augmentation in Tensor format in memory to speed up the evaluation procedure. + +The inference data processing procedure usually does not contain random operations. For example, the dataset processing in ResNet50 evaluation only contains augmentations like `Decode`, `Resize`, `CenterCrop`, `Normalize`, `HWC2CHW`, `TypeCast`. Therefore, it's usually better to inject cache after the last augmentation step and directly cache data that's fully augmented, to minimize repeated computations and to yield the most performance benefits. In this section, we will follow this approach and take ResNet as an example. + +For the complete sample code, please refer to [ResNet](https://gitee.com/mindspore/models/tree/master/official/cv/resnet) in ModelZoo. + +1. Create a Shell script named `cache_util.sh` for cache management: + + ```bash + bootup_cache_server() + { + echo "Booting up cache server..." + result=$(cache_admin --start 2>&1) + echo "${result}" + } + + generate_cache_session() + { + result=$(cache_admin -g | awk 'END {print $NF}') + echo "${result}" + } + ``` + + > Complete sample code: [cache_util.sh](https://gitee.com/mindspore/docs/blob/master/docs/sample_code/cache/cache_util.sh) + +2. In the Shell script for starting the distributed training i.e., `run_distributed_train.sh`, start a cache server for evaluation during training scenarios and generate a cache session, saved in `CACHE_SESSION_ID` Shell variable: + + ```bash + source cache_util.sh + + if [ "x${RUN_EVAL}" == "xTrue" ] + then + bootup_cache_server + CACHE_SESSION_ID=$(generate_cache_session) + fi + ``` + +3. Pass the `CACHE_SESSION_ID` as well as other arguments when start the Python training script: + + ```text + python train.py \ + --net=$1 \ + --dataset=$2 \ + --run_distribute=True \ + --device_num=$DEVICE_NUM \ + --dataset_path=$PATH2 \ + --run_eval=$RUN_EVAL \ + --eval_dataset_path=$EVAL_DATASET_PATH \ + --enable_cache=True \ + --cache_session_id=$CACHE_SESSION_ID \ + &> log & + ``` + +4. In Python training script `train.py`, use the following code to receive `cache_session_id` that's passed in and use it when defining a eval dataset `eval_dataset`: + + ```python + import argparse + + parser.add_argument('--enable_cache', + type=ast.literal_eval, + default=False, + help='Caching the eval dataset in memory to speedup evaluation, default is False.') + parser.add_argument('--cache_session_id', + type=str, + default="", + help='The session id for cache service.') + args_opt = parser.parse_args() + + eval_dataset = create_dataset( + dataset_path=args_opt.eval_dataset_path, + do_train=False, + batch_size=config.batch_size, + target=target, + enable_cache=args_opt.enable_cache, + cache_session_id=args_opt.cache_session_id) + ``` + +5. In Python `dataset.py` script which creates the dataset processing pipeline，create a `DatasetCache` instance according to `enable_cache` and `cache_session_id` arguments, and inject the cache instance after the last step of data augmentation, i.e., after `TyepCast`: + + ```python + def create_dataset2(dataset_path, do_train, repeat_num=1, batch_size=32, target="Ascend", distribute=False, enable_cache=False, cache_session_id=None): + ... + if enable_cache: + if not cache_session_id: + raise ValueError("A cache session_id must be provided to use cache.") + eval_cache = ds.DatasetCache(session_id=int(cache_session_id), size=0) + data_set = data_set.map(operations=type_cast_op, input_columns="label", num_parallel_workers=8, cache=eval_cache) + else: + data_set = data_set.map(operations=type_cast_op, input_columns="label", num_parallel_workers=8) + ``` + +6. Execute the training script: + + ```text + ... + epoch: 40, acc: 0.5665486653645834, eval_cost:30.54 + epoch: 41, acc: 0.6212361653645834, eval_cost:2.80 + epoch: 42, acc: 0.6523844401041666, eval_cost:3.77 + ... + ``` + + By default, the evaluation starts after the 40th epoch, and `eval_cost` shows how much time it costs for each evaluation run, measured by seconds. + + The following table compares the average evaluation time with/without cache: + + ```text + | | without cache | with cache | + | -------------------------- | ------------- | ---------- | + | 4p, resnet50, imagenet2012 | 10.59s | 3.62s | + ``` + + On Ascend machine with 4 parallel pipelines, it generally takes around 88 seconds for each training epoch and ResNet training usually requires 90 epochs. Therefore, using cache can shorten the total end-to-end time from 8849 seconds to 8101 seconds, thus bringing 348 seconds total time reduction. + +7. After the training run is completed, you can destroy the current cache and release the memory: + + ```text + $ cache_admin --stop + Cache server on port 50052 has been stopped successfully. + ``` + +### Using Cache to Speed Up Training with Datasets on NFS + +To share a large dataset across multiple servers, many users resort to NFS (Network File System) to store their datasets (Please check [Huawei cloud - Creating an NFS Shared Directory on ECS](https://support.huaweicloud.com/intl/en-us/usermanual-functiongraph/functiongraph_01_0561.html) for how to setup and config an NFS server). + +However, due to the fact that the cost of accessing NFS is usually large, running training with a dataset located on NFS is relatively slow. To improve training performance for this scenario, we can leverage cache service to cache the dataset in the form of Tensor in memory. After caching, the following training epochs can directly access from memory, thus avoiding costly remote dataset access. + +Note that typically after reading the dataset, certain random operations such as `RandomCropDecodeResize` would be performed in the dataset processing procedure. Caching after these random operations would result in the loss of randomness of the data, and therefore affect the final accuracy. As a result, we choose to directly cache the source dataset. In this section, we will follow this approach and take MobileNetV2 as an example. + +For the complete sample code, please refer to [MobileNetV2](https://gitee.com/mindspore/models/tree/master/official/cv/mobilenetv2) in ModelZoo. + +1. Create a Shell script namely `cache_util.sh` for cache management: + + ```bash + bootup_cache_server() + { + echo "Booting up cache server..." + result=$(cache_admin --start 2>&1) + echo "${result}" + } + + generate_cache_session() + { + result=$(cache_admin -g | awk 'END {print $NF}') + echo "${result}" + } + ``` + + > Complete sample code: [cache_util.sh](https://gitee.com/mindspore/docs/blob/master/docs/sample_code/cache/cache_util.sh) + +2. In the Shell script for starting the distributed training with NFS dataset i.e., `run_train_nfs_cache.sh`, start a cache server for scenarios where dataset is on NFS. Then generate a cache session, saved in `CACHE_SESSION_ID` Shell variable: + + ```bash + source cache_util.sh + + bootup_cache_server + CACHE_SESSION_ID=$(generate_cache_session) + ``` + +3. Pass the `CACHE_SESSION_ID` as well as other arguments when start the Python training script: + + ```text + python train.py \ + --platform=$1 \ + --dataset_path=$5 \ + --pretrain_ckpt=$PRETRAINED_CKPT \ + --freeze_layer=$FREEZE_LAYER \ + --filter_head=$FILTER_HEAD \ + --enable_cache=True \ + --cache_session_id=$CACHE_SESSION_ID \ + &> log$i.log & + ``` + +4. In the `train_parse_args()` function of Python argument-parsing script `args.py`, use the following code to receive `cache_session_id` that's passed in: + + ```python + import argparse + + def train_parse_args(): + ... + train_parser.add_argument('--enable_cache', + type=ast.literal_eval, + default=False, + help='Caching the dataset in memory to speedup dataset processing, default is False.') + train_parser.add_argument('--cache_session_id', + type=str, + default="", + help='The session id for cache service.') + train_args = train_parser.parse_args() + ``` + + In Python training script`train.py`，call `train_parse_args()` to parse the arguments that's passed in such as `cache_session_id`, and use it when defining the training dataset: + + ```python + from src.args import train_parse_args + args_opt = train_parse_args() + + dataset = create_dataset( + dataset_path=args_opt.dataset_path, + do_train=True, + config=config, + enable_cache=args_opt.enable_cache, + cache_session_id=args_opt.cache_session_id) + ``` + +5. In Python `dataset.py` script which creates the dataset processing pipeline，create a `DatasetCache` instance according to `enable_cache` and `cache_session_id` arguments, and inject the cache instance directly after the `ImageFolderDataset`: + + ```python + def create_dataset(dataset_path, do_train, config, repeat_num=1, enable_cache=False, cache_session_id=None): + ... + if enable_cache: + nfs_dataset_cache = ds.DatasetCache(session_id=int(cache_session_id), size=0) + else: + nfs_dataset_cache = None + + if config.platform == "Ascend": + rank_size = int(os.getenv("RANK_SIZE", '1')) + rank_id = int(os.getenv("RANK_ID", '0')) + if rank_size == 1: + data_set = ds.ImageFolderDataset(dataset_path, num_parallel_workers=8, shuffle=True, cache=nfs_dataset_cache) + else: + data_set = ds.ImageFolderDataset(dataset_path, num_parallel_workers=8, shuffle=True, num_shards=rank_size, shard_id=rank_id, cache=nfs_dataset_cache) + ``` + +6. Execute the training run via `run_train_nfs_cache.sh`: + + ```text + epoch: [ 0/ 200], step:[ 2134/ 2135], loss:[4.682/4.682], time:[3364893.166], lr:[0.780] + epoch time: 3384387.999, per step time: 1585.193, avg loss: 4.682 + epoch: [ 1/ 200], step:[ 2134/ 2135], loss:[3.750/3.750], time:[430495.242], lr:[0.724] + epoch time: 431005.885, per step time: 201.876, avg loss: 4.286 + epoch: [ 2/ 200], step:[ 2134/ 2135], loss:[3.922/3.922], time:[420104.849], lr:[0.635] + epoch time: 420669.174, per step time: 197.035, avg loss: 3.534 + epoch: [ 3/ 200], step:[ 2134/ 2135], loss:[3.581/3.581], time:[420825.587], lr:[0.524] + epoch time: 421494.842, per step time: 197.421, avg loss: 3.417 + ... + ``` + + The following table compares the average epoch time with/without cache: + + ```text + | 4p, MobileNetV2, imagenet2012 | without cache | with cache | + | ---------------------------------------- | ------------- | ---------- | + | first epoch time | 1649s | 3384s | + | average epoch time (exclude first epoch) | 458s | 421s | + ``` + + With cache, the first epoch time increases significantly due to cache writing overhead, but all later epochs can benefit from caching the dataset in memory. Therefore, the more epochs, the more cache case shows benefits due to per-step-time savings. + + MobileNetV2 generally requires 200 epochs in total, therefore, using cache can shorten the total end-to-end time from 92791 seconds to 87163 seconds, thus bringing 5628 seconds total time reduction. + +7. After the training run is completed, you can destroy the current cache and release the memory: + + ```text + $ cache_admin --stop + Cache server on port 50052 has been stopped successfully. + ``` diff --git a/tutorials/experts/source_en/data_engine/images/auto_augmentation.png b/tutorials/experts/source_en/data_engine/images/auto_augmentation.png new file mode 100644 index 0000000000000000000000000000000000000000..3daa904f181d2c7a6a2b6f7f2271c8e33f2ba933 GIT binary patch literal 454686 zcmdR$g;!Kj*Z+qQ1|()^5Q!nAq*EFO7)o+LBqfG!0qGQml5dr`JVpSMa7XZLscxbgi?1w#V zy`mit8v-|&ktYB^(*M5=D~+4v2>`$ZP=(6tzso)7vahvS@LKy6*)`!-AqJnVsjlCv z-$SGvP(A+vQPTBx(oMh?D7HyTqUQ`}0%BR=K!_svDNYovIj`hiwOKNM48v8W7$AX2 zw1HVuS-uO>&bQz-EwFavtkl-;Wk(shG90;$FZegKo~UYsk0`h@*fTPh~!c2{`rr@)m}XR@qb-X-@Yy_`Hwa@c3WWo z*IDO>eNw`IRZ=<)dHP?es8%Sw_^%R@U&g-uujtwSKN(o8l$G#}l$ zb6$YC)ma<&d75|kA$|N_<>ef%in=XEHhlg`{MvQh+V`e|x!}7w^MKQV4*{Djv9YoH z`}-<^dTUB=FJ)i9xM7qqC8vL$cZbn98=Qt52cbKHk9LCU19>17S_Sw0&t%+NKK(US zvc;5?HDi*dMf#?GEMO*Bk1Fp3*XWodYzqP}HyAPRZc>p!f1-l^kYY|q83VMYg*B&J zKESFm(=2pRf$_tNq9!@{E!8Od4 z+?D@%Q)??5q^70@U0+*YZ}!=3y$>Dmo4nv(nfZ0u@xQt|qwVdn9NY2SP}lMMNs+#9 z<;|EWkBR$9O?ef0TMWxiANxPiQ@m-&8WAJr-;nHOG{Xf&EJ@b8rQElOy>A_QPf zSrkGG0fGHU7|wC6PYMwT2*AQS!j9BL40{X!5a9S{g36@90s^tXaR3kz(^(PTGdU%e zQnHT(_EtL<9)~~UYkYFL1W@dgQ2o$(5LQ)toWGI1juLLBue*dfLzNHJ8&331iV=-g z;E`zqE@Efl!hdLjVZuQ9n^i3Dag~oH0BGKT0rz$v{TBP?6mT-VGeH{l&2?ALd=0nf z>cf48Swj@^Z|~*iz7H1?7MA}ay1iI7H|eG&t`lx$Ju%^;}UuUEHN#DGs|B$y+);#kB z(7yZjvV`$ITDI%1!L&n^E@3f06o6+}4Up3SazOAU@h7_eEelNqoVHVUzeSH9u5?MO z8l)>VtmTZ+J+jMIme0tby6N%|l$c*zkrbz?NJUo8?LU8>aD6AAPMyV<2i_=j; z3XGZzuHHC(=Knsr+E}&~)T4zm%G&W|77*oT8M>5?Ll(#A$fr(-WT8{f*lCD7(0rA8@oF`^97b`k*jZV{Q)-9K3U6{bFHF zc7A20u9_CWf9@v!Z}n5~1itJ^H)+sG1HG|tfWPf6Y4Bliz-|q7=W*!i_;}q|-PrzI z17`OSQ*b-hZC1Vo_#SW1*rC{%B6;hh5Xk(B_B9u6FbpUfU$@gi^Amp!|4w8pO-f}%)a zQh?*b^Tzg?c)s(5bCqQxir!da^M?$U7VLP%DgSvyr|PAqldL$yU!%BDzxGi!%2CLW5e9B35ZXuSAke)tB)v{aws^^IR8JU$;JzhSIIdjDv zK0Hj>Q`uYPhB-s9rKm{pPn0#nLK$UIj(|cnERaCRR}^d}fr8c28xaWwGC`oFkOO*2 zWq$r?Z;c`r1@cFF0M7$@a^~IIro;H~;Ij`=PnNd!qCd8SFMV|SciLq=@$Sz^NB!60 zeX&Ax$Ux-GA*#9vYOCQ<2IgqBrEX49*k+(hxquRsf-=N+TGAV7&2{+4K-<#d62L=- z1?UANM(?0eaj@j#N+vGmCm~gt3)WKi!yhoSuB`-S_zx3@$HBY+!pz*f$Hyix@NRP? zg|z$G#JSW2W2fLB^qs{Y4Ir%?iU@!Nda5vh3**ppu0up2b@W%+Hd>k9=K z2`vDWI0m3-#2S7r{VQ5pyV9zw%jatGdThxjC)|B;X-w(791FzGLcB?aHZ9zcuvi-}Dep^x*d~%}o34 zU;g_!fY^AwXtc3_t2732v=9Vuatw9%MC+`xNrwic#-*7G|`E#uzJbtph8fHvY@aP8z^=-vOgrPs9KGv@A8>$ z!_vP<<3R3)+;2Z*DQ?i}vUC@Kr=4HanTlhMCfFy|KHnY;@O8PZt2_D}&A{OlR~DaP zPyx0=_DICVR9ZfFj!{>0b8~C^>$9_Ww|}!cfA;;i9hitnP7@rra1|OWKn7;wcZZJ=)p2-0A<&&%&s^Q=y+vk(j2`7P z8FG7t%%AY29Y{6_N%fb7ryo8%=i}u;B|LwAcVd3k7i(yK^=)E>si6YzgDdHgldI|Z zs%_TV(vqb3ycXwEdisE?*onDm2S?X^**ntUz36i-%A3n4#9DAz(OShEnR+Qsx}zLlvA)k8lQl$nL@KN zv0vWU^q~-3#WHiCA22vvy2Hq>vi@-a`sS{xjOTS#n>qYtKTPDkm8R$U*;s4%-LrJV zpY_XGairZp^kY%`=3OVq{*A|vch>H`N8Dj;S|mADp;~6Ws2GLWWFWR085}1dUiIK& zq37Ttwh0#pBG`P1fdTRGekwESry;T85)&&ad7%;Kb(}R^LZ5`V$;cW@h1ZxuZQAhx zkYqc61tb{)Rv^=;=6rXI2tHZ3{V_nU)ouT!{b&%sOG>DDWR;;?%B+&^744}%hK$Nr zBrka)aYQ34Ku_%PRWdTus3Rw~=yX+bXTA~ncUc>rUH%5L6R1Y8=={+x-Btkik(HJ} zznSa&j0o8vO&(@Hpom==k))S71i}u9VbgF>FiR{Md%3`Mk`WEzo_CDa2KjqPKcn(pecP<}3Wkn?K&GPXw-K@yVW-QXxr0Qt3!#K9G@u?D~(;}QsmC@A+>`=Kx%GBKG60>1R$sv;kvR(`B;%T?wAut3g# zQQelsCniR6u)p!P^Bl^n#!57TKy*%IYW81iQjYLw+IsaElH9OizZjY}LP_1^D$Vrj z3s+UzCkht|mg5ptDq+88P{n4@h=}`Tnfpa3myB-b*$bU`C#@M?)TolxLYW=TadkHA+!Jx&g1DV z-fJR(dqmSX`>j}&w0isNoeeM~5DOUU)~y_dg(XNvQ%DN|z&iR<$Bz#Wy8aDh%$c<_ z!<8Ir!9dvinM@cnndrQR>XRR()$Gw-K4$aoPoKO8##Hj!3d36_sB>GE0jl z_P-1|#1Qe0s)SIL(Q5J5ITwigTmJ25sTeOO0P&S4*A?xHpa{bQlC>OYmu{H_crBqF-nF^KNWL zxHhajfdE9HyU(Y@FK^{-WE81gg9kxn(PJ^UabZmX(~!e9kU@*;?@&5&a>QG$*6d2b zW){ohwzAC3c{bI^NMxOPPGTriITPXVxIiWWsAPhPO_*OuJ8cq>6K3bcFPciX{N+^p zU}8Lr?)RMXXQ;K6^WEq~(5`xc|Mp_psBgZFZ#{OAYBNH4wd+ng7|i6d@};}m-N!Mo zq~397`FmrT)lfSALo7}yw+c{bqQN1fcyEjFST?3jcv+h-)%Zo2Cg0e^MsA1x1%pDDDlF zB7ClzQ0mFHjj2{llUSC%K;8@A<-0$mJ(zQD>Vm*^%Z69)mh_I-=0AHKZhNkFpl%NH z4nYd=*$lJxVnoWw-)FYXi~$()JHGp$Yu8&n=utj%Kekakb63>d6z+M9lK8<|T?oMG z85KfThf*;L1w}$c8L^NEZHfU4ah_4B^DIvi@UfC5G09e0C~bCD=#PMZWX0GVkaCJy z6rk%|fG~t#0x;TCYZ|K*5mj#*2^H>7WJS;_`umqhO%a<(cZcC|3UjDIIax)mG<7uK z-#N-6v)%U>ou7G}o{f@+06=I`1p!onxX(^njj?&a5nuN){_nmB(n074ejTfFL}6WB z?MiJ<_oec#*FsNgMVlm}5F0}JHb_X0-_j-A1Zrn_m`*`7(_gz{SqM8rRV!EWo|m(8 z3XqYgxoJwFX?8TX;PloZfFD;upMkAO;ba5YDE?D?}?rD^GW&D`h z-23Z>}qiVSS#;^00^Ifu#=S59KVBsgU^s%&x0!px;8&XQ|6N zfy`9bS2)klJnNj>Pm;_`$jcJLnSG-}lJ|jLPp#hN-!BUve_2KzoFZt}p;(i@w(DU+ zzF!!Apa?)1?s?nlk}O-E6IhaA7In7{SLN|kia=U;SH7DB9^Yw8>9ZWBT)}g=L7kXE z?{ZP%*}m(s4nAqg?kl+Xd>aVHLi>UoA_u}dC&3yM2ziw*0gWp{B-UEsvb8KXa%Q@# z#USb_ON-c{a&8)N!-rJZOwoW4&w8(O2QpU2z(c(9>|7N&R+WQSY)PS2;_R&vP6Avk z5Rb2MO+>nKkA%Hm``SUL62sFRK=S@es19H)bWka{ny0{<4?S%W*z>v{{F_gbVPpK+_5F^-MGJ}1!2=5+Rqat zJdJujefB$;shU<-=N^h(S7?A*6xfs$0}vBZ`7b|bJcRPm!@fG32PWiSN64RfqtT;0 z`xk0hl{MG>dwYe$K9`r4D~X;)`D1$sdwY9VS1tI$jrK$*nvF@w5MDNAIbF-cJK`i- z!-ZYBmuA*}`4E!+OVP@|+N_WfBlf=jYaAc$$q0K*n z@Fol6)d1$YhxWsUA}#hIdxhy^Qd>&9b0v^GJPCxWOD1)2ih{ueqR(AEetdWKw`%J5 zpFU#U4p?T<3L|j{tQrhDe%=BsFBf{gi1xqiLk9J7CdIAQerNi zf`J$OcTDue@}F*+L;)jsU+LNlKbkHTu=fxs>Qh@C6PfleN{;AK_ThgP znC-*G)WMWH$xjkxt9EimQ!^sve}q)VJBnNG+)WL6`DS@0&NCsBbNv>0M)~AAPq=i! zmSlQ>L{`XNXRH9d=*sPyXx`&2czhC|*LSWz0s>1_(1k;UMc@v32#tBXj{t4>pO1iAELbq{U&(^-wSfSD=hNk}#t#SQtaG0=QFk8PGFO;?p2 zF8pL%H6|YfxXw4(j+IZ^G5YCwYVmzD@vxssrF@Uc#u>#6GJd%|9k^1) zlh@eTv^c(ge?cuP))h$kEds8SrXyXcsKdmsNDk}Ir>7CXDz3IB`Wf?5@%WV{@ni^5 zG!3Y429&nMFnJlO7)2xmD$4#TpOp!p>ID%qjnXGF%iq|H#6`=Oj)AQd*pU&1F;rG; z2cG(h#D6fS*dj5K&8i(@oq1kE#DQKoQ zBNxFLEuo*pY%=bQa!9qK3s0Zze`Ss)6Jm9*@N9w+I05YdhG2P+lKUY6dzqVaI_2P(8gX+dcBnxrJyiF@; zJ^_fQ=~xI%{~_(B7nh719hhF_U`J<}KXkMG(ufS~J;gfGT%>j{sYN7TY}SYv3g!rAz7!a6zPLn*a; zJsE5%VG44(`tjdZL7;5EVvR()%NcY%uaGbb$zr!_O1do5ET-NBZQ$!%lH0wcirU>Stv#Smm~r~(MV_c^pU5BTE!s0*!B zen>%5Ex2m7=C^fqnnwNg(wRuefEg~zra9io1>qrp7h+oOAgptiCcKiJJB zfB1JM4V)NBqp`#d#nouuMM-`Spi1E|dXA?`n27R+YE;`{|487*kz->0DC)%+5}jN0 z0vpG25Jju2Rt}4RLR48H*@{t{DdkKTijII>t&+MOqvYjouYJrv+aBNb8on*1B>j~6 z)qC;&Yt!KMu9})5^MLKgJ}#?f=4+D_23oZ|JaONP-{w}m(W{ZOBJ48Dr#{Hzrowy1 zAnkeEADw2!{dg!NU5noJnJD*JoY13qy>%($BjP=p^o(@D<5)8t>qkOjMMfx(;IAT@ zDJaWnVXqVkS-N+u&<`$gVZ*_0aaC!e2j#}cF(!u8%KpJ2@5^%zLt zJ^P?Ahre(7%F6QFdWr70*DA6n89_Hb!I-U4^QV7RY#IF*-3R-*zO=R)&CWU*ba`CG zpcia0hdtgT!N0%BUaq3McYI_nmPo6x0Kd9B!m<{jiK(oEGs=3493)@~Wd%W@0$cS_ zbz4TG=VyYWgb=@v`bR+yI|0^jau8KNw{51Sy!v@2zVmPsNc5*Be`JBPodKN4q9yu` zj3r>mU&3XjmJWmfO(ZUV0wqhMt>8t!HGo7hM(4*{(dJCI;Mbbvujj;k(E25|nD!-~ zmyEJmv&}>4TF!iWeCyg>`12jUUdQRiCa;gs-|IS-h`%0vw`|}E*v1NZnzdNd#zxwA z$x(ei$&by%m6_F=01{zivV@klHvl!1`nE6Jlly%esx1~HtrmZ}A1DyT{K-?<_P>H~ zMpCdaLse(3zXWXzUK{cm`21{EeV=ddngNcy>vNLwwrThj;CD4rL0WIZu(skR*3kZ` zi`X!sf@WYwe?h|IrQ#kMUlXWl+FE8EQdo`1wrPh!-r_|^1GM{*T~+TU1fcwsIuMr* zg7wbiVSiDfBxr=g4{uINVH}A;1xPp?GA`Z_5h=)%>Y+Dm5wY=22U zYjzsM9}G)Ig@ZNd-ZFTQsaA5Lm${plZTSDpd5Pp{=Bmo>Kfk>8A_BBzDAYsW%kqZP zXkulTw!aa6ZWUhmp1JG*3V%7>J;OYXxF6H9YanV6>Fl{v*qpr(^fo_Q?<6~gFPue@ z56+cOZY+yg5*Cg*9baC=XY?%Bc0H`b35j8>(F}d-CKu$Dwoq0CJHK!&vmmXcEs#A1 z_>iIEkmCA2SPSeDb^eAPqQccw>7o8qPt82cCRGGT%28xDca4=OrQR}QPRQwl2{w91CRZ> zW3=6g?&|DmIT^k>ca`vRN!%J89ep+-(=;-x>spEc^PHQp+R)OUd}g#`W^6eZCl~U} z-$8hX6on$dCVF!krG+tj3(>=F{Md2;_uQdO=zxTw$i>GspH*q^?Ia`kO1r<0r?EfG zH+@!UhXU5zrhRnECJLtll=uUWH=zeQq&mR~a!51IFO#rCI10a%FMx z5R`rT@7LMZsL^&X1}&RobH5h2c7qvLY?PJTf9=@8|1?HH2M3@t)=bo*S&7T)kx#&> zWR=0k!&A@GU~TjgO6rvQnvXhjvC9!r?tmg%9CXx$B~3CS#x0)+;W0r)L6nMbVF^!d zqjNxc&!BA0%l;?YBFqu<`&*o9xse*<OTrF7~2f1u{_~E1}u8U8>md4T^G`n`5!WI?JmNfbG6Y#gD+%rYNo@n!q-h;B4g6CW)_@fPGJWD96!C3Ck>TJB z`L>7mZ0x-X9mHymTq#dEhCtAPa;;SZ#vyFHW=tbcT4;w48KvN-}(CMjf?!f^@-bZ zkHNb8{w4I^BG2em4FEBTBJpl8o&R!D=66>uLJsV+WQtGV@gYgfVIrAH5=d$*`+!%z z=%TDiOr)PikmrMlfmsq(r-CS+POzvto2^TU?l7swZ~;p#vPwWuC83FgB!W&HEdE%a zMXxF@KnTL>G{I_TD}5{_m`MN*t>PkM4y!`a(qTieIOIH_m8AB1f<7CcsPGi8|Jur& z2M3?&l@o?&BH<#MoVl`?SG&y}hDWt4ra3PwMn@m3tE;ctM&#n|m#ZOG+vR&E5=`ykU^${Y|cG*)55 z@^_?<{ojA83t#p>ZjS4mkZzt%CD|Lf?Cbme)oo_~1Dah&v4fTLyGdVS;zEI>r>JeP z?KyAr6Jn~;ix+@uBY1eJwZYu__}*z+jhIWS(&?P+UzYHxugCYRJtK7i2g`azRaSO; ze!l+xLS-!-pZvG>M0S=dWbd+eTl~Z?U7uh90E>iX>=1S#J-K2~$LdT!Q z=;>wKl5KpAhvqJ4@w?C9&sdlhZt8t?shF6v!jc5Q*pZ+v&#*8gS2bd_(U#gu&9XmX zQhz|BqWQ%{;I?VLgixjiSM*0|2EOz%&+g|=B8~PyDi*q*8zYC|r}*P}H(wt=QT#Zu z((PN4P4-*(`|w6+)xhj~j`fPMP4M z3@4(n#!^<|qsM0SHLyU$C@Hu8h9}TPmZY1w*g{j zSN)5g)orzc29Pz6qblqS#gPNxxZMo)+2|qtITJ4RWN1s4%mZ$#gcxrd4<}?j(O0rB zE>X75f$_5cN>1vJE1DWq`!t{rt74pwsoVHjAK;ah$(C?J&vEb#tMr=F0CnPyJ; z*(we*^B~8nuO1s7Kttf;#?^sEIx7TBUd>6^B7!0m)= zX-b@r^cnZ*Ld7Ti|77cvjxaNSp@0XD8ySdK#_(a zCjXJMY9y;Y)^l9->T(fEBrUZ% zbhMKg)DggXsP8`^SquayM@F81mXLmzkVP9150dBC=hvTg==8rC;5#r0l=qn{%vT^P z{mMl$1!fb$J+)&<#nQwDJTDj3iXR3&FB_DII>-vmd(1qTy7-z#+j*kFij_rVvTb>YMI+y!Z`FLtj!w!x9$uNI;n7N9l0X*(g67n}gMl?+KZp z`PLoo%q%1=tIFSxudVVeYz>u1xY~n{asiv*zmTd})8OzBaM8IkBJm z7c(Q|;e8=UfGPQpqj4Fg+FG7;-;soKd5IT+w@G@otM~IcjKQ0Y92Z-LX1){XE`I|< z*k_aULQd6^@{(e)dIX|%nycSvH>UQL2Il~czs-by1-lSZ=WXVNLme>bvALKgQuD~! z_g$xo9=pTd;Es{QTlbd97_)bK{!wF&cUAIVnFi{!4pJyt+u9mKMa9H!?z+$KvutJ1 z+6Sc0q2g^WqAsJ8O2QMlK9!b`7-T|wTF*Ebux;aeJrljb&7JU+{)_057l9W_7tb9KRkJBG!1 zd>ZUB&Uy09PdVqwLme!cgq;o|NE^M z)guRclaNfuZ}D3c6|UNZ6mmVh-{F(O2PWw@u+8&jn|x$ctoqegg~rZAOBlZr+;Y{u zi#ANfhWzh}a5^S!Cc(OUymo;R^s!ujEpDtMA6o>wian z%d09=EAf)kUBr`-nM7fpe`xz5&7rJs-&Y~osWnS<1sjJ6%lDe{_2Jv|HoOYh4bWd% zRLVGigXpun=YynA%L$6y>W|NO6u&$F`dmQ*aO(cHwdUdjz!ONJ|IVox2 z(Yp37I%HFCrGT~5O6p)*&vn6FnLslFc$&Y4p2Q`!&XBQYXc5BZqFct09+kltr3QAo zM{%(zkOb4#Lgs!oWRKf&4fs6HE>N~5zn%9b6T6laM@*df%=COe#kYZ2Y7xHtcSDjdJC6fDbZw3K zV9>!W-dAO1Yj@VZTTK|!Andg>gMnP6HZ$6{7YIzo4c&M6$p9i##05YSio90^B;od? zoD#XPsyw^nL-gX_a~w(35~ZcGf{r}&I53B7kzGJnHd`e+xKYJqMXAiO`9{s#35T>&%EofKqFtK7+ zMY|S($$I<5ZyjQl_v&_EMi~TrXS$6T2{R-oIS1b)l`(;sb2Jcqrb;`0TDkGtbgB|B z9sz`~p-xsK06>UEvH5=PKfN&Y3`vV*r@^18^$q-;=^Hdw3=EGwx!l<2IACibyoPVE z>q1|XnIP*UEiD;c+bJ=*`d8?o$#nh+6gn;;A|MBM6oL_HXi5u&BY+7UG3;1c5e|So zhG8fBiJa41a5xMXXFM~yRJt`=PHD0wqmdSn9Mj|p1f*;9_x83Yl09y-4SEJw4cpx3 zNa$xKOYuyFI+?jE7G}0b&ENtNREnK`7uT-0*O=Siv3#3GqIvHfM3>uTHIh>|X%v zh3S2d_0-@i*5m#|#ZZgzdpSUxPn)9Nj#1F>`O~`*`C6-vt9Vs zC<|a(mOOoWwBubkVL~*bAN^D)O$iT)D>E@V_0>X{zU{c%M_AQAKP@yVXDDf1d#I+W z>V>yzvdS?sUQQngqXb6NWP?D7KzQ9)u5(2Ps3Z)5f}6%V+bSgt ztU~fa@MinzS885FM-~{ww3Iaca{J%!R(EGd&T_rekB2VV{qN$;R+paGbmxo@+%0v`cBXLiwiYi}yq_8wTOQBW*#v@w<)Zimcs1SfW7Ca&`OI$d< zXsU}#2dcH4|18H+p(&N@(}m=Zt$G;^kgk1Dx)cYCV3Pvv;;X~;V&tFs6|I5*{y8!L zpd9XXm6kKz;gdbK^6?XOj_~RtjjL-B^pc0`0OiX(mFS?0g_kz-V)MCZ`8bMMJgKy3 zJfJGu(t++T2{^xY;Ewag+a_u{1}@Gm3Ly!v-l%<-fNScq3@0UVx37{2mRRZ>)pF|u>Er81_5ceinyG|=f@VsYqmyAN!57bzF2F_UhJCDa>8VS zJv1Kj0CtGOHR>tfdYP)?Y{6m{K}seC78RmuKzT7Chouhrr%*FXN`k1TKYR`3vAr7H z-H!H!x({8BgD#s3?lxU9myGvQwy{zL@aY8}gINttKO3;3;57NO1U}w)4|5v1xFW)& zMEnx7eBXjA%bDO?{{p|I64#)!gZ7~b*`%GUbB*EbRNzPlO&Dv+sW7)kG%;YS7w+`7 zx=Y@^5JiHm{SvROd^Ga_|eNA9>>}QM&ma_pN^Id_Z4GRh$v%HhDSI<5dq3K9w#G>BR4e1bE4-1y83}4@6IHTyb#?ulcu$0n4YA0n zpYg~PcrQ?T#Y^AkKkmU-tTc6lS@3T*A5A{!bR`BiMtP3soo&A|^1SFpi24805X~ut z5rX8^=>HbtV+rnO?Z}S`ml*LZe@_yY_TS}dJ+weB_N7oVdPE8 ztQe0Ac#<%6_R3|=CuiMXD*-Q0IMPv4lI({Q=HzH$SDZMic?C{_e|Yn{{9|K zMqdwDHv0T3qhIOp|GS#k?2pEL6YD-b`qXn?#drUQ`hkmkD8~qWxF5p2T=j3jFa}ll zV(R`q!H9SM%OWUsP*l@-UQEKQ1YZ9rG61_^5OO7s*+%v01Nvsl>|%^F2@RTnwAd2* zyv^!KFX)8C0K&}}3iqQQbI(et+=1l1>A7?>Q>MUh=f@=McqfDiW$4Yu%`SBLGnFs20oevSJKsh)X+1PxBu7ra9yI}(Kog*`Wq7E%yu99X8`>&&p@ipT zH2|?;1fep;m^3R97V~_Z{Y&@u)fQsqQm@}iuzEx#?yo&IOUoGN;$9FAK>2jOqmCH- zu8zLEN_8H97#nF|6dlF4*-kXHa-=vasHH)h1*$Fqf4MXUC65e)pZR=M&z}mo4LF~= zwOPXagC(82dnK6Ps*G-&hD)NmP#kB3KCMse&_p>_#~h{zCxw(X~)%U0gFCCJj7 z&oPm5c;eQFbTQqJh9i2p@PG&gP_#si_zQmL=k00V0EIA(N~U3~=-FAU;l6(4NUywf zWCXHUmx*G)7nf2XMiXe^aG}C1w+ZS6L`G+Rv=teFyQ=DoN%qGste2T!d{%>YNHKr* z%`w-A9oMy0+4&7QE*Tf>#F&B>S3bQ_D)wm@lbZ9CA>&#-Yp4P;vcyB_b!wA_7QuMQ(*jEt8n$ z5@4p9dZ`->*UK5B+7K3Ye!}cgdH;<+ZlC6>9}Ut?z_@=tRS^8O_Sh0wu~UI7yqz1y z^JO88`$qRHv-wM_^BU_~oFjX7Q-~tx*6!(Pm%oo<;mq~piM8wawSTQ^S34NXSG(g! z7xvlpW?e55HmD^*wj`2dYVCf|$MH#EL7 zk~Bjj9`-qMKuxuF3LR(5$`$A{q4$kQT3cGBi;>-{y1c8U<2BRzjEbFa(A;x3ziz*) z?RZz`bbM1+n*-_&L+?wYIlL7oTlDu?$7gH}9YMA@1n{Ts-0%b%Ct^MeEHP=Dx&dP5SC&)jZ%1^X~X! zPWEPtujf|lKK7I}=y-D}xbgf#*5PR71Lj{rKjYOY=bMYK{p{Z}u@aFQsYos&VtVli zF6(GcD$bxH-fDTBr709!%s5#~ zr>rU*{!;^nFyn7Bc({)~o*m^dN?jf0Y@CumX||i<+{x{Wrx{a<)IO$;P-ysGOZkr~+lQc%NU`w9R^6@AjyURpMPfc&c|u zH&gsQDA5E?EDT}FlEm_V?y8>+T1ma~5Dmke72HqztOfdanTcvndmo+!Jcs0r`DK^u zs>$w~1znYehvWFvn>V)MZb<$1jX!G#nh5$~(~b(p9)O z8yy@CiiY7Myw8UlDU9-VC@k|+vvf0hr()|3t(N*1Eb$!DZ5sbL2=Avp6Ivn4+4A%I zx7lZF?oSM^xabGZP5&yRQKl`Q8RXRB6cuO+??_eM`gb7gw&c_Gxn)^f-l`+$f{u1I z@T4%hzPQ9%ObktfM2c?oQmh8-- zGp=`3@nWf6(9{f+9}Q818max*{rm4^t$?+T+@v+yd)ItvNTxjMA#i0hcH3 zViQNQb4R909yr5JZtG|K;$Wp3Qoa4& z3t+mG4y!~=6wee8xSuGfm`7(Y;{l+Sm{(j4Sf7pWZaZjkJrsmgzV`O5#1Q`Z8EAy# z=zys<;9m)tnxM8YC?Sq+3%;HIMDnr?tVm7FpPJN;GiPM++|O$DL%I$T^UGg$9*MdT z(J2TShdX00E=5i^+{=ZKo6rv_+hoZ1Kn;on242Jf=fyW zz#vM;}8<1dV2bLev=AYv4uVRT*(2-d{ z4IyTn7vkg|a<*@Ao)yPByc{!udOuktu;zuXwn-69SO4mKj5U>~uRfm0f6xZ|!|YZ@ zi`3(_i;QlsesP!VH`CB_U-yRQ3-5bSq&vmb8=5G0{^q-H+@JD0yxyIEi6*JBr+H?* zx_gspxtG1)(D`?l@f!6ZXzzhc+G-|}7^9G2f(Q(xDi9T^wl0~!&#ItbGmJee& zqMSw^VW;JCY6~5Qvx=?S8M=hK0+w)Ex1= zyn?`;JfG0|o`1hBcPuWKdM-Y6-yO~kxvxyP66K7o9`!9OEbQ){3Tr;N<{FL7g=&>~ zwIqdVA#A7YSJ15AvsVh_gEYDhZG6a^_vxd2lgG2{=SjbpS5VI*fg#0@lGLUa-IUPR z>I1Y+vQ%%({;jjn}{kQcwK8SlWd#saI0flpMG zgiPT1dR}hDg+rFE|Cbj7m)CYpVoU8l*MHPL!9t!Hs3DgRe>ny3E&5KIa9>#m8oW$T z&AvJA_V@M++L~^7+WT|1i5S`*x3$en_zQ4gfwV>}87aqq_pCh~cEI+670o)EFKyO; z@#^Y(kJqNA*g^qK)Lm{ln{!lezF)7_-MQlmGY%3Hx6~mPsHSvt^Axn%M%V`JHy6l! z4%}ZK<&zHBKfGD9(+b{twiSQ8iBIZ%KNn1J+?^A&|7o;B_Ho2; zDSI)V+%G02da1!uuGS2_Ql{dZpAr-^75ymvnteSrEa68V1PpjxFC}`Udsr%HYjgVzL0YZI6p-9pyTJnJ}_#0Q&Us+S#T<^ zP+xJP);LPX8fPwtImbTXh)+K-;uMubz6QMZ@fkG`j11yx2Mo%+q?1Fv zfx3jJRr?J-)H473Uw~Q^ilg6twLGCXno>#R*RV3h)8#kgZ|e4{Lx-_T0N{G{1kT#! zAm^M<$XpkI7YfvU)1wD7yiKs6X{0 z_5G_`vy7hWu@9^~$F03St<6Ld4XTb?C}*>jES2$vt^cb3 zh$sFZn!YlusrT`FbVzJ;3Jj!FV03p$cb9-eYSKvO7e<313`R?Xgmi;+i!`I8LxxHT z2t51!uj|>{^JZ_(x$jRSi=1<)9C+Sz+te)%2)OzA`we@pW}h*kS@s)hvJQ~14?AlM zE+>nQI$i6eA1VKbe9u?-*JZnAOK`Ugh^YV>(#epLR4}CSP?S}P3Tx;ij;EcyVDkqd zP-KwZe#^(=W&@)IL~&JVi~cNPJMpgD(<$s--H8nP2vJz|zV_}-j^$p375dUHf@-P?%h zU7Y%^$-nt9Wc#o5anJVQxv383qA}Iq|0A$_`Uc}`_PjGjNum~-s(7B~)VL!#hgwbm zYzevA13xwtNYVh+D@9kiTPsKd7NNnwe<6!6AVS6}Yb{&Z#W(`SUzm(7Rq{)Qd$GPA zt*rF-C-1u1Y5n{LuzTi58U^}~4$-bmrk!YCm0qmyCP2a-SFN>`Mdm;IGrj`Mx8!r^ zwQsiS$E>Eg$&lq}66qrQ}l_^`jVpfh$bhNDKsha;B7cAA!R=gTt<;#jt zBKwXKvNVzt`Ol{4tcPK4&KI5VMcW@sBX- zuc<{je7I9vIl%A@u0I$orrEH?+2C+f2H{BfFkE?e>xg0x^|*2wSE0fbE{#oy-L|;F zBHJnBp`Y<>JfB%H0@8!#7dSLm=4n`BRkEio zhbl_G%sOl1PrvlSB|of~8*TWlZV-c2Hn1`|>+i6$wMEfSz1D~Az5A`CMTs~ZGW;q7 zND{g%wkjvX9uq=Zn;b8l>UYU4s5Fl;yIXtTJV_y{;qwdRocDY4C{53B$n1e*1F%- zCNLSGY&!4PQo@c#LeU9wJq1whxi)%nAi>LR!bB$v7T?!&W9ZuKvMGVVJ|28fcSjhjxzZN+i$$HG%VeU^2qD-&8Tk9(&tTc0z~HW+ zyvc#|n>A7KsrUH*=*W zSl-MN%4}J=I_sBGROPPPe;Q}6AJ^ah;YXgC%9olEp8xDr)T3jMQ17}t0UpBIPAN}O zZvW=b`FlhD*|kepR=bPd{#iKLx&4>?_pTtIr(!Xxv-dLU<*Y0LpEkdqjFnEPa75+!T zShLq|iYdU$zcEps>cj2_ zut>7_UL`zbLY|IWlHZ2`yNK3!V)8Rm==wRg5HY2Av^o*ynRTyW0uzTAKQGT83+1VT z%*x;2R8-|@SWJ|h6-kz(>(#M{!{7UzL33{;*EzGlw|0KrBRx zD*IYI_hv!xL;(6otKQ&yAP2BZ_8}jf_W=L} zJZuFXduST=k~hMflEFg_$CwAqq-f$R1W6>x68RJdiKDtcUgsSUu<8wUg=}i`Y;-}^ zZ?>j?{P^+lc~Hpa2#|fmQmi2C^v2Xyrpp(2kTCRhYTk_@<~7rmpTBkn63QgRsy*<{ z&%JM}|2zX(t8eJBRD%f{PURZnvVQ!2eV?feD`OoHK$sKu6NwIlPrezqrcKqiwl?a= ziB(p3wcpsDouBvlo98=!Pam(f!ICnki8o8l7GIDb^;egfnB{tW?}v8{3kBYIUYpBN zg7g!h^jsAdIy@;U$@!h0=exTl&Nr(I-I#6~+Xq@qjRrfhH7a4$zDHb6sxo&<)9hg~ z&y;+8R9QQ{qt<*fNMFPl;+pgD%R{cTj6ox$+RF~0hZ-(KRCcm{p&v{IPy;-w-9Gzx zu;RXq*D521mo=kXfevqS_P}gyoz-ztn9NCW#iB<~MscUoB@v}gskAG(Fi-BgVbxQg zwdJ{;qyFx*r!o?zC!Kh7GakR(u9uLZ4I@cpLr-h7Y}+6HaZY5soZ7!DxYeo)eAu_V z{d>4O{@{InV;XwQMSgwdh5NzY<&b2{taC1_sY+nrUeRhtHF_)Dh=)^A8HMkn!f(TE z?DC#V2pRafO9?(h3@SOzs7bzCuUW*Zve3-2Si>}hv|A=NpaYq{UTuGn5&EnSGGrsG zJRSDjgGnvbUfl(W*@j%+W2%PGy^o7ysCPZye=fwYl%Cefg?_;>SBUkHx|_?*5B!g~ ze%h7SbQBQN1EVQ$3~z>s?=>(I&Khq1Suqv9UX4>No9F1ltH>jpu5P<%{dcBLSNY{v zGytcM=IgzwYg(T|*e}2_p+9=a6q{O9aA&p#9o-4>$||XJw!g7r=`$M0PyixT-mMDklCmzZ;QN~- zKsnp%+c(03ufBUz=78F12$tMQiV+3a#N2+Zb>}e+VwcoQ$mTs-(kP;{POqMia2cTwNp=B@rl80Xz2Oy zW!bC79^FbJNJ;IP)B2B(Q9Y+tACEcF0-MfGPYCGfjX8!e+K*gbeBZM)|$>D125I zqrKqq;?^Ag8$%yY2a~DayFJz5G5C_Po|o5iGW&CE<*4S}l*aUbaA-)Y6(2JuNbONj z_PalQM5;5WQ5G$B&;ReMY1p;@<7xUQHHfJD+zXn7mQ#~z%?cIXoJL~SNh44d7oJNL zkaZ9~Xsw}*v}Xm^-un^whZDNVjjlM-V z06`o+bvVq(GDT&=26Ti?n5Z|wJEUV~f;tcJ{+pb&7qo2Q&El{ZEO~3k*Beqn>_hFH zFW&_J9rWUnx_4um2F!Ui!VK7<*V8(U2lMEHP4h zh5iqEgk^lZ^?NzCU%dnr1?%0pKTAPO#|Yg#&kQ=5eMi46Y#FI!6MxMlgjN|0NjAsO zs6aUd=NO6y2KT2U*5+Ndjn#Rfc1&i<&jqx-R`9=y8++i~B<6%c8l7&FD7OVSHS4LwS65xVse)od0!`c2ZM@(-~8YJ{JerkQZRJQb1>vK91 z!mpQ=3A;v}x$Ee}o|k4}zs!PI>eDavuk<%3DwBHJ`w(OX*S;ChA%u^MCgSJEic}Fh zMN*PfMi8ds_l*aY;}cO!a3d&(!jl(cdq|7EyV>{YP_$w6jIqYECQ>09h*HjA+2zId zL$I;N68=xhXZ%AY++t&8FPIcb!qs_L+p0X$J;*km7iGQXfVkAWSZYEH?4(2AmH#}A zjE~Hw28iPHN_UUiR$H%=Ijw2E@xA!lkKDA73m6>@usXOLYm>$@miN||SH=hMy8L|l zLE9xRu8(NBi!3}(sm}s#bVrh2wJ^!+s3@=K1a!og7t!P5bZk038X?ib(xYCBj!S)? z!ztv-Gw;XOcCHcw2Vv8(g19`MRMe`%Nt*MY10(xItp>j3^pUY9Yhk6vFIti8d{&BB z!rKfa)?M10So&u-9QewKLMW-Ba^R11PT!B8|6X_qw2r7zsJ05!7RX(9!^gsQfv z>Wa?mkj;|e_5Jf9aahdjZND<`j?sSO^tYL;iGU?-E zK&|yYdzn)3P;<_$Q7iKt@=Qsej{e9S&!;Y!Rv|bjgAw) zhe(w6$U0Dd{7TYl`F*R{-u4sga`8hz+4v+X<^->^CExXP@j+XMZBks5ma>%)?XeGj zHdX|CH81;uBJQ#Dn}kJN{nuo0J18NCibQy}gguGp<84yj^Sf5L`%3?ZZMn6Z^mkpp z2T`A#FTaahhk5v)`Rm@Vx1u)xx!?cG!sKwG@u`-Tv7`s#7(2O2>NjOj3tVWK_+bp> zs)%gwBxYSC)40#d@_Ob>5W?Iw?DqlWQPcyH~x!xCD#k@efL^dDAVx+S` z>_F{_(v#?T^+o_rINLPN>54Ellu5-udvM~AGk`ed=^RXniCICruw#SoNFuoG;gN1E z5LJf-@MW3F-+0_;oleOgTo(A=Bsq5SO#L<3tGc7cfx?oSwt`J`gCNmP{+S_bby1O-8hgM z3#_Z6^@3H94Lh5sE$2BamA_{SA=#lkY*?M}xESKeqiPnA!a+=QF@$Gxl#|+(1PzpU z$4z0{RS&ONokl;Te-vn=z&0pOooh+eX$tValSkT)? zNFJ~L12s{*Gq4DG`BmVp`9W8~t!ky&@7$4v{jFo_mx00mLN^&ful%-=0c%VJpUJQM z9TM&IN~p#F)8TU-CPA?g1L8^6b2{yb0qT&`E9=V~Klh~)lP}F7CuknOVoGcy9KyDj zrd;r@R&P8|s)_pO;GFQD6)-J(5g8Guw6*6VK{9Z2hiw!w22F+I5uWMTiqw;vk!_c8A~l=CeRCF(7zYGRV`kA}s)0 zeW#6Wkd8vAGomv7P@L2ng)LtwuU@rp^HK>b15aZhX37Aa6cFvhI&u6CZ`T!@6WyViop0Hac`dR@;NFw#KKi z)NOvEbq!)_Dz6{*Pfg!#{w?ax+kEUj+xWYd^*=%C>ehS73MDguHm$fOeKyT)bUbl#mDPqS{&gTC&Gk`6euO) z(ub~n^F4`H*R%D%RP9gP0Q*9Fe07=gV49hD{9Sz^(I%cZJ%#F{Akwyq*j)Xl-L+^v zfDBMX*t_*c3(3s`ZYL;~kScUc!CfoQBy{*y6NSKc(L7T6RGpOfd78WyU!YvIRpCpP z_mh^OadL(%5==h|D|xlryWX4K={rb0vSwO0wy}H%s%-+uhy%tE{Z%ZPHWIqjqNc0N z_>2zGOc!=2OE7$bjRh2Fbjr}sW^=@~H}Mp4u74Pd29%nyeyfsEsi837GyxH!9-Qp> zTyUo&;NRAaNmIG&kqnZMVMO?70yaVuixXf+AVx==>p)BI=M0EdMganFaK7=e8Ma5J z^%0Ho)j>)PI_W4un_U6k%@)$3|H9*7o1y6aDaK}q>lRPhjhk%2RNX0yzz_nP4sa{3 z11ZezbZU;1$ZmI<3OVgAeL;!k1bH$%+Hg9NG36QHM=W2xV2%bb`&p|TDOj; zLsZp@A*s^wOn5?&_KEGgk`4K8RB7`i{i-k5uB8fBCb|1I&}gr2Y@ol~<_q#VCYRZ= zSK7S-A6rI5TY9G5=XR~CT=h$Uu)JJD6HrLtzl*55#uk(-YU+Gu{qMYMUGR11COa%U zKo)5`zNZ%5XLb6-H|4DJ$}TL+fg40&OI>5?QU<+J|;Huu+9jd#zbe>zV;mwwag*CRIrHw(mWBGD8Zo;E|;nC zyVZ)!>V^;1U!RQyqAYGV4N5xBWN3Y<&|)J^$Od>_k!jjE{=Tx3%Fe`z&rTgnoOoxz zU;`jSrnUAn+}1URR;9MB6(Fqb3i$K#XgpWX8Y@?^w87LXC!QGciE+fP$~OuiR2kC@ ztn0;i1iZy;|9w5!_MJIa6p;pJaH^Q1KQB9Gslr*d?WSx37MdE}e7$#Hh@fRG+psc9tjS5X1_Yz&>tQPTwW z@ZqX024NE@+YR@XbTt3L27oIi*kW>W$rOm-R(kzxU?EED4z86E(agVi2pD0JooX}<3g z6LDFYG}zQ)BzI0B{38qwkJ|@F7qvy6aQ_GN@61eFZ*auAUSDsI$DX}BS;AV39@JK& zLSl;dfCaNp{Ai>k4scnw+~trlq*z0onFg!NBJ(ZoVkFhrUtyElJa2M`hul2t8|5^L zJk8#T4g@kgXsQQ=v}VURkD7E9?R$hh4iJ!Q@Q@Y4+~=^j0~>AJMKQtFoeXcjIq?^M zQ2D>jwl{lAy?6NU*|z_hPQQFSquEyb4C5r$3fYXIncKx}2s(DSG4*D3+1uSOw@s+4f@~1L3FRspHx;GKm zL=H+$&&0GXbPW-BKw|v_%R~QnKhH#VFmaswcK+apt8;#p{V|N8fbqdNmX)lKlZx)> zlX89U<*k_@6E-3&k-zz41@1f`*@#~Y2iV&QAy(A%Zmkx&VI^@4j zI<=;$HsQ$S%X7a6=^wQ7VHQ5*mAs;DCK9v}gQ%A5xOu;XO3y^JO^Dc~mT~FKpc#Q_ zWr57~5dYJjKYwCvZ_~s=AIW>}hLKLl^MjORve>Dg5BFEqwyt4&XQWbh>dc2G;zpYF z@;+G5m(=4WWsa85^^DKJV9NMWVeOeRiAUT2u}IivyiV9#1VYQQi-4MLaqpn>sMwvO zKr_B`@jhsd$;rH*!Ix~da@g7Gk(Z2An@k=v#P^MORgx>t{FnZ3oe4*d3~-7e3D4Ii z0AUdlbfH6jfTH*}P^0Mw1W)|9FcB8obn?El5;4Sz`lyC_acj z2mS|Xu(V^3&z($tBB6(6=z*UAhxTk7PRr`26cq}-`dzc3JPc&yr2lV9<&9s@s&!rF z`NpfX$ZVTMZ?pD!mb-2o0BhUo`@rC{yLV>!9ib*=o@NEQ1H{e1_xEPtqHLVkCjKO| z8BA&6EvRs|jwnhsq3S+-c|m}wQ&lpTzt0X3IXte;8LeZN4Ae7X)5G1h@^XJkZ;?iv zBs!D;`SRoK(`*!Q!8v1%vlg~xaRKKR$}ZN709cAJU<(=A`DEGC*(ZcDCQ}PnI&p6S zU2w)p)&Q@P8Y3-<60@RB0pL|P(H(J&KMY=d$-Doytg+`EigR$34L6zh!}l&%LsY4; zIraRI{SQLLK6TFxbDsUwTa$SCLe6ITaKM7L7RVzr$3VkD3%*t&{l*?_A2kh1AcU9f zx-acPs^g;|BW3RM^MiB&qLw5Bx4S0391vJ^eH-vleRhAy8(J zO5odca1VWql?euY@?+le>b)HC{Lea*GBJnv;Q}AWChg%{KqWvcT_hF#1RV}EyLO{P zVsmAsW-&rZV`^^=P!Vd-w&f#)&1x4%^TkmF|Dsh3^xqY88Oe2+O=Eo(|9WaDTQ;rJTDQ7(S!gM7Y;8+9rNxJn$~yg zYl-o1!G<9Hyh+tfD!&5dsidh8ri9Glqm7`me`Bqi!FTJ|_JoG{Uv3mOf4=XBZ60Br z+tb|d2fu5V43n-^?Hed7NJ7eW`Jas^@Q0uq3&`AY!s}lm2>T|jjH@daLGZD)tq-?g z%k#ulp|N@#0sBj)b{Td)lYXhb#UOiSTsUlhEBA(@#ct`}=CkUmbM{EsGLv%ocScDSg?%sEWb(xa-bWVWi}+CXDIb$>g>Us0NqW{} z`#mTAax9k$iop7&jn%ce9&+jwx<5=Fg8uw?p0fEk@OZzACg6V|CKlV-`FI<4ycy_l z!1BO;KdwvChi{|OjBc*={TTR1Ug&d2!v`T&b)Ke64<-1l(Z3J%*kL>W^DP=NrK=Ls z3(OZr^>$U|SxoqZ`UvLcBM7MwnT&>&vubQ5sqcNggpp@%F{JTF9D1Yf_2NfO9Lcp` z*U}TrU%P~}{}T*(W!=G5h4dPNEzDR(neW50T06-L>&Y-)Ni172O7x}rl z{7~xmhc5lAm+tpvz)qNQkmc99P->62eq`p-w0h!#y zM6#Zz1dzv7?9-p8+Gne<`A|f)b+PM1hwm>mm%hV3``!1xzrWv2baMq&N+oviJULAQ zHaJ*!y5(x12CHLDlXa$JE;*yclh_flz(7S0pt0|Y zTTEl4=f=+YJ^J$g`B`p0*dCtMqGbQy7DS9^8fv}N3W;9*ciaIB!~D(!O3S8syv8ET zn}B$nqGD-QY+ol90%cE(-!R2erANiZ#pOuo3wr~&i`6q!G(l^sDyzYZ#_d|u?HP*U z>AQ4FNh4$JT83lh#tMUF&dPo-m4Fq02n`rxUL!bTrPsphG57T!Qk#}}b)o^?^qM5U zc^fIZ&o68^@W%@_+ArG)_jVhU#lzB!Q zXKt%Yq=$Kkxkqn!vl|P_DMU01wqwWthyGL@9eAC0-f89CbgNuN4K z-n-4sz_gHRYyMk~$=FI`&*j=T2YO@QKl#cJAf)JU-{Ypn-A0#18evUSd#DBE7`XhB z`*IDH%j7%?*z8muY|VX^HGXUnSdBIpe;%7q!Nx;W&&mLPW35?_rI1Q;&-~y(g4NRy z!WJ*=_zKfjB*S3PXqPiLCnRI}uG!I;&*>%;?*CgQ*DV>)@9>tQ%X#EYvB#hJn?K53 zzk6oRgHm18%u8up2-27ZDRB)U+e3L$wl^5)e7Mx}H|ueKv+Mryot3q07={>suzdH? zNtZV4?(TH+zWZo8J3UGg?@CGgOr4q?ugV2qec?ClS}x*P$&R#?`{h@%i}vjE$m(5q(3FU(fq+p}~)3d$^#M@_q%j z-#>Avy)|bnZ7KWrtCKEzP2VFX<;VR;t2o0kcdg(#>CG%2gSMysgq+9r?L9BWPGa z^H@UL+eO`pgvRtBU1Q7&hL%yv+ncCrE?D4qmLzE1davBOr*iM_8_8L^ANG-T+KH?& zgwYwA{YtoedL&R{FY&zJ2V9oDYgOzY2U>P?7G7AR*usWFD$xkZT|98rcb#6IS6!lN zWKgY|7qkQ)rEO&&0lRqKnng~@(YxVs+4RI3*#zm378cf&%q%p4?NyQn{@Q1>GjyD7 zk;q!yqi>y=mpNKdJEV#*>{}FlxrN`aX=K68df3$}LGR_l+5L%J$6s`7>)p{qY|7cg zZ#cY9BRj=8Bq)~2t)VqZpWb-L`gg$ceaV8D4Et!DEs~A6Zv@PX47eCkZ;Iutzns*_DTyf z$UF@mKBqiEqFr1PmIe?0;vnwUqz+q!qauO4;lVO5{v{JI8yiqz_@B&w(G~12uSGc( z_2l%{PIQz-EJUm4H)<+D5OWVqFC~uTo_;ZIA|ad!c*6;e#Afyrw)gh_ZwsN)Y4pQp zdXNhHzqeExAXTS}&Io_7v6v#xHQ`0I00sD}lBeoUnz^~Vor`$C1%}doN?~vT71Pa% zP#zkE42Mq+apm!NfIPpL3pparnH*}=rgNPZe##r>3m;TwEdT13no!X-_+#bMi(+hR zmkaR>eMD=@zvjCG4hYZiJQJMC#3YkrYLAdD>u#;)8u6Y_z11hRo>-9FPY3Uz8|gv* z+O+m-c99r$KOj#S3)35jU8TG#j`z_x4{sXI`esMU1#3fk_oz}0dD7Z3PM;geK zF}6ay%Ec`w#_&m;(4_iXQM|4l7@x+dooaZg2hFQA3X$hOx{wC&NY&_<^@!HQ0qN#& zXeQu`OXfEqMcbitwut8xBre>QX!O&LXCf>dFNC0YYY4Bw9ftu|-!^7K8Pe|}d z7Ne}B7cNKVkVVPrFd5`MdQ0%ER#dm3t*FRyOmxO1dUiP}mCPBej4OY*zYlJJaRAc7 z`-c`twKW|p{(^Q(;Q3r$YNp;?_5d~?C~i9Z>E?(@M zP*DLxwsJafPPRRxeI`jOX37Io(u3~Uf4I-$IDo90zL?R2KE2>Ew1mz@yzYhqggj&0NZjjGa z@@hqFU;1e}-X{!=bvMo{Y4ObLwP>BPMFSP%i_SXfxCQ;)9m_I+fW>Nz$x0i=Y!vSX z2=r;H(q{K3Wy4ogtZ~bfwD+i{$NspfQ>sq+sftw4&)QH~CQI@!KW|P#`&4_yssdT1 zfDW=Jp_JrUa#{jkW6CSHDWfI_=iCh6#8)J%SmgbyiIh4_=laERnX?cr`CKzG4$N<9 zTR>}Ix4u~PQ!DPA-!iq7RDhj4x$IpvS9y6|_bssmWAGYGJlC7LY>OZjVLHSOS=zbD zvL*10S$svqhE2(`yrNDhA2Bs)9aqIX2B?}LBn0}*6&Dj~&CaHgFoR?Gro7Ptyz&d$aqRI|oe>EJnp;2^ z5At-U2fmXOYWBw8w_(!_k!tK`YTE87reF$4Nc&YN5ar^pgb!xzD~9f;fo9nal7>q? z=sF{-6|j=G8!{?A31Nx&WYM#03v2?|h47O1z@{t%1|4He%mAYNa)mh}(nL}n;7!m> zg^jJwGmnd_CniSkKVTJ&!vTI7V@zN-{FZKo6f(Rl`t)tSs;?Wly@vk!;*v{TuUW*FIV7j$`vl z*dUX*BtS*9Q!f-R;@7TUw(qVB=VbJ}^S=v8|4>04E${I~dUfi?h0c465+1S>VB05B zhOieRQ34%xpojL0hfK=X3NCgy$)C|OcfuC*u=R|c8COre=c3QgX(v?3$w1pPvj0|G z+J9!Mb*}r(`U0l0kbYxK`J^-cU%DG*8}ym&x@|i75^e+%BfbVUucolarXKX09|Z6Y zqD@NZ%m{ObTITBc7y&gC8l=8bZuvywXVoA?O?s67IzZo{>e!aGIhlHPpCRR zpp2JSd#)mb?n9;aIh8{qqzdSX`6j^GDBx99_AZl`_|GC>1ca(fesj`T^3xJtzce=3 zg&R-NF1f1q0t3aer&o}sE&MI-v<&+Y=eZ6i3%&cJ zdlBkrOlZ2QGiOcL%m;jK|9@XD(Vc41b@r+E2^vQ)wSS58-4$j~*MtQ09-@N^o zvT>7uu(50NzkWb6nf+O~I);>&BF{uS@j?$TdWC}?0e?KAy@~>4G;HG;uDwlls9}v3>bBn3_4HRyr+G!Cc1zUO}Gq4y^CPxg!^2}8|S>f^1-OmSSZ@`k=(SK0AL^8ZtKwa}V4qaxN6 zN)@dBpamvFT!6=l^=aX}(>~|FwI2iM_Gypb;jW!p5y}RQ?KptqP9xWjiMQ1}Y&Zz|WS< z{a5;)={dHvmlXSTmo8vuoVQKXOF~o7=di|2H`+??=-hQ|)p!|poQ!jvw-F9^zXWNA)WZwsP8YC`4k8eSvs;O&##8Oapha9&$;I6m6Wj^JUF}P%>f|6 zhDtnKS+hSt!rVUVn|;>`Ck*CtAx%>Kld@QK>=fa+70 zB6XCB1|e4VERLXe;jrEtA96xsW1mdC9-Fl=9>&6hWObok^Y z0uoaD# z&gEw<e z1Guo9XRo*Noy=d*%n6gunX!*6J2qQsy{YwVRgV2xWN8lZm@C=);=n1us#UU9)+B9C z;U8U6g%%oTo1;!z``8BD+FRK3YR7%+J;gePL?Kg{{eBNt$-udx4#}=xN^Cdu)`^9 zc)v22(if0(^)%V2oIp*j_x#r-i!|LbHigM%cY z#!uEL8OJ~zoW9wksG0ku-p8p&?{m!IxH~l?)6>=VlO}{@)`zcDD+qbrdHH+cc=~+d zH$l;jy<3mVMcHmN#?(yB1h23k+%=h6HY<875;`+R1RLi7h^R!RL~zHhR+{K4lU3}` zmn?yAuJq`!N(xxHtJ<$t{0?!67V9j`8R{tv(t`5YTW zz?1DD?)ap0X=TcG;8uAae2AY|xyK>E9jlpw+B(ciM)^X-7W8_EYqd{T4evPXbI`YZernXJbWVV+jz*3+h$xJR<-J zaTqD#aAFJKDt?s@Zi}O@Xm1C+C$SO%m%^#N`L*cih9=jtK}ICn%r(b1@S*us12`Ws znwJK-Yo|k_#0tQ@HlRyG4Kpinlw$tXeuLw#usLiD1p^_WYqpkY8W`Ci86t4;^QVs? z-`e;HIk>SZ_&7;S?r~)%1MZ7EMR7n0^XSIalN>rJ9S({))x_FSi_Ap6@o zYQCqf%k26@rFEHH%J1yf*X7e&Payb(kjKR-`jv*HE(LAE+?!Eq@I?=P+f{$hbh=?O8r%T7_Y4&OONN(I!=h$N!UgG z$0r6{{KFA)$tTLf00Mb}IxMfrBH1j-LW#H5&#&730<3L=cFx`JbT=QSmo@@UPWSGR zmuY;NK%{XZ`5&KyPX!MGzjSRwPj4^!_YW_I?C)*d9`Sv9pr*w?U_@ zzr=)uFggf50cSC<0fd@RC*$}LM9$9TBcul1kI%K~_BqqUKw6voKUtd(J7Jf3kH0Qs zQKu6uva;=~FM1wBLN9njeoWk(h6=G1yoJl#I0}p9J(;)DT(Epe^tidm^@#?e#t%Id z$&4w)?*IeXs@dpZEhta1=~y-geF39%v(i06RF)!foo!rS?bP_R!;Ph*S&qqrx+m_8hb zUOpZK>Ze8!H9T8YVk>^(Vt6DVU!*R-i+ar{UXmg1Gl9mKu-kE{Zq!Tv!pnwWs258-^?S>OD#zi+fEOE~w(5cn?dG3+`7?LcPu1xC=7c*Ko~l=d zrlU@LGfaBVp%r#md6-O996pu&y2G;(1UpEmsB@3)zu_ryBSsl{jMIpX*R+ov3};|Z z#Q|hjXAc3j7O*7nebhK`g?*jCzrZS!hO`ILu4$Zt5S*fTV|-!#3ihYp6eG^9jFgR) zQ0nwJ#ggs^UqjNFLh_L<&m6PW*adm$c!qWbqfBNI2fPC=_uA2eH=t0z@xr&zy7FS^qQ9C-hv8 zLNxPGfv8@s7dzkbsczRZi%yjo<~L!%7|6O%XNa5WF(R;K3xy)j7qo?4+nSaCx}YAv zr>JlrEv+fC)8EFovDW#nwzF#kc7@Y-bM!lJ!Nt?l7o=##!Ymhh>o#4Q{b%6rx}aOU zV88PH(JhU9gvSd1YRdvoo#}*U{)w`cb`AnT&m-8kj!~LMcQTBJU~9O&|6GvJhC?K$ zpgm)DuHtU{?qS1+MU(2igzAaTa(_UfAJ3Y#c7i%GXVt`!!$;6tf9ibA-!lga@{X1t zWHOqXOqyNGj>=y0%&DTL{yHwULl=+(mB%gf94*T<0D{P*wIyQol+UfUV)RDgqY?3! zql;oJvLRQ&2)AYELe2LPfJ*P(zoW%O0MW{nIqu!%QMqij_VpI}s5^b9ac&Moj?){J zP1E--hIQdw*N3olF6Wn`TWg86iZa+p#J29i3xBGcM4!+xUH}kKPo0C zO~uY@u=fHjatS<>`8U6EuZB8tS~8u{5)rAF?U>^~E355%+&^b|+*{hb*;ra+kqNy? zI&ktAQ}dT~Gu2%gfd-gF**dsPh!*UU-$2CH@0Jln#Gzl1v&b#FWi1uYj)BYkLh6Y&BgrsDtrCv zXm~u$hXB3-PT-V9%(`e61>v{mvf}e1*W(BYd<%w7r?4Q~si z!C7(e1qnF(lypeF#tqhrpmpAf?eLL4I)mtTb-;QGduFAzys_5*_W}@cN5rLKrcCG} ztK;^{EOiEw`zY*}*2!Eo2Z6sY+HU3f z&GxCt$iA~3aF!jHj_NSKMsAxa_Y->Z)6ivUBOA%iakpZ~080U40XgSB_x6p%+DoPD zSCYEU3w0W^r?5u!UD-*3`jQ{OVKy>`(gapqk)qD0gkm zM1-Pr*hBGI2QBSVRqN0SHo)vf2QZ4VCB(j1G|d2}xOO@LYwh;G9yD?&e7zjo7qgFs zl!1#WxCUC>O*Gd|IcL{|hbF`ACQ-oUy#3q=#Z3{Bq=0(G!DxZv@bawA*b^NSZ z{AEhNZQ=7OE6L{IOz2LvYlMUZG)-gM^#HC~Du%vtXxtr95AVvY&S@$m?qeV|5Sg2S zhpv0$t6x2OaR2N7mg7tPZIFq5On5MvU|2EAAZ;})Y( zYG@K{gKEYAXa;~7#n~NGX8boCW-j{LEwiPZ$3q@w51X{l= z$vFZ!fQjsVP>~ozA0r`piqs`Razh1zmbhCK1kG@lmZg-?q=uH@ey1%sNq0#HE&po19A)ZCGY(3P10Q0gtC7$cx5 z!y$kZ5zK1G1p+%Uijx^J1DFCiB6A>jNh!{yvYU~>wPaOG9MHkdnJLCJPLmU9Xhc!w z637>AYYb{;s`D_QJ0ZlbKV9`#n`;12gXQvA=RJsy+v^YmhGanPVnrpRmI?^JmCrwf z2rv!9=J+U{o}PwC)1(NP=Q+ic^8}Gh;$K5h2Uk%rNY5*V-LxN!_t7efx*yhQX3~bOZI=~}r%&ly;)0F$BZ30aMQxU{* zEafPzV~RPC!#Gc~E*7ce0uCof>uheN?1#a@+omzkAv7&CL{wx()ZK6~?4E_@*trXl z6ZKy8LuO6ii^!_)*Na6;%{+};^WC_c=Nwbhq-fwxYLVE?=REB;@bua9pZw&#Qq&!Z zZYPhUUvy1Oxu~eMZOW$T>ckG=rMssg@YQCUV%qPAuJ5EsY9f)TNX{4-nFN`baW1L` zQj}0_-4nJ6@gV=zD{ zbJ3VfF*kwWf!d-u4CC(V#fRq?(>UBcKK^vyeU9-P7Z+F4WI%Z~Wt!Xo*<2AhGOS|1 zIz7Gn@TGl7&CyYl;_2~mC5f4u9aLZSoOD9;n@$6ms@fr+2@w#q+>Thm{f2Prjvzlb zWdS$)D?cq_RnHvQtX>_hH$4@1svu{qQ8fqYiD;=Yas~k4CLhyU4>H;MdjiLM4%E6!Re#df9Ie7vu~vImtX(-n^)IT%EMpz z0ydrOHuS+q&G`j=``h%!oBowA&o93k*LUXs-$!$c>)-=D{N>ybfB_Id0T3XIj>9|- zgFC2L-tAnnO0kk<+Pb4N0VXd%6c7tCFttGH=njU}2ajg+>=dX;^=B9p`s`N7mSGko zMDCKKSVA}ORT(%Xu>EcZO>vFnkr@Fe5d&u=H;bVuqJ(H6B2nK23dF$0&CF8_&#uSg zMcXZp99caV<2E!*JR`P?#K%X?cGjtcxwJ4u)<7&cxsbRC!?l;EW7FqLx6J**PF1fthng zQil#JzOhb{sO}pP4~<|4KuieANRC_}2AmNxIs-T}S0k&ti(&vjq|ZamTd#6?ONo(` z8B-(|H8o@kAtIuQxSQmHq>K!l3U|AykN}WQ!>;KTMQAd_QX-bvcg^~aAT06-)965X zzu_1ZnHfz@^3b$R-fz*}kpaqCZPU5~ z02^mbX*&+7ON1CXMh<3HR1nd;5PG0|ZxzRqck@U{MAU>>)pMoHm*c)~+a@M(ySloD zz|=Ir)-dNeH>tHui=$RdnxSHxJAeM7ZByGE-8<`EJbUrMwiiiWWsi|UN zck9|_wOkL=Gz@zJOeqf2yk0Gi*T-o7y?1};NFt@y&$sgV#}Jr_7#DrpcTI?4p0YVj zQ#Q4(Z4g{UVoEue5U7+=6Cb;_H3wA#w>jq!0{DzTj+#=Ka{)+g6Jv}fZj2ztDu{wB(-0UEj_225cz?Vrhw$86q}bn^{e+@`IVpj=$r5U z<-dRO-n*}V=EeP2H|vwj#nC%$_nV>n&5~aiM3aNL1`xr~G>eqfbQ}UvMbRIOJao{A zAONT-)qD#=L=-8tMu{QjJOdzs-+B1(cmC-=`Fgwf;n)7X?)K%Kci#NsmuR^z!%n7* zPo6gC&*}Sbr#pB2*S>%xOUcu{~L= zDaF}f%_NW@wpXRBQUJ@vgcnO*#lGkqg5^vxpxUG+LvBMVU90)#47*Jf+>9BU22aZ_QQaTxJ>7 zX32?zxnE7=QPWRlL+ov!VH!76IZ7QMs@YiP1$D)3H;ub_YGVTin|VArKHg2^cHS@B z9(>yG_ZJu0$O)2}kJBh3!?;(`;yRA|Ip?F*`rh5UQ=XW@i;IiYh9h3a7)AAZvoZ4` zf(T}sVtn@}KRQ~cRh!#3ot-`$=c#W{WE*%vl&<&VG>o%L8)692#5l32nuw`(i@4ox zRitfNSMORVIV0k7we0)FIBtr}QdDl~US9E8F?BI?(+ok8DdpL^CLw~E){ zi%xWzcdKq;ZY$_ajAJOG6!2rtMda4m$$fnC_)q`$KY8mL|6#%N8bxM|I*E*!zZ)s6gPQtB_i{N{cGmAlFW?kegG3=9s{!ec5NQnj`MIP&2QI64xV zItO-eFyO!j?g~J`04XN8G3q$rArpKr#f0O&3O3_kgQMkN_n`{2? zaXLP_l}GRk*C(PD$!_#<9v%PyR>h(N7Jv0Nte0S*26Igl1JytsAqNOpGNH3uq+~Xuj6Q)Oh89r0lp%I2 z10P`a#Ou(B8Dk^}5!n<`34yEkEE>$Sd0;~5QfQklGG5IafUqPguD~?vTrQsWX>`w* zZTslXeL+{CfPq_vzTM}HV46Y!h~aS9hr@&z!!TL7weDQ~!kC$x%)6`I)r;%vYa2&I zNB0}tSWW9BLLdTSRMkMxL>5yKZ338y0~v*`i4g%L!;P9u%&H?F+?A?Gu5Pg44xo~t zB%hgC-3S~3YpKNuD(c`}msAT>r5Yh1RzWROa4>Xqa8V1aG7C_g)Q}K?2-yK#HNe!G z7-@(R(5EbtIwEV>Ns&WRE#vOWRR9|fJ**q*S7m=4LJEtunNbK0lI497F;lrE?P?`O zZ#M%`|0|#V%*n~w)2HV)7et@OdEzm}#7(pYS$G(S&DHhutMj{yqd;6t0C18Su@e)VE=`9&$zGy&j3 zEkC)-D%rPY*>=s???Rs?- z2aTqX%GWCd~L2?RagUw)SvlNI^G)f3+ zMASB|l#-f2yhew)6xm<>`JevTM{mFVyAK}ycb|LXgX^pR;s5%R@19>Jbl3dTSqw{? z_+e4TF1$7i+4Q5$$}UX`BJds6$qL+7wWx=K+|RX1aDQ>f9|jEn**S=}mD9E%_$0E4Nc`9b2u z2oCBPsau|z3nLI1lnFpnTn9de;$abL>|)@APN?c+fQ06N;0ohpPc0j<`}8REff6wU zBz9!N;s$0#tU*HJE(Io<@|;rGs2HdKG{go*YV))0(ebg|JM-89>TZ~pjJSyN7~_-z zvocNlDTF{w=-_GvjLll-24H(zeUVy+n3X(jE}ri;+i9N3o!kMeBHGabNYxG-7CIpT zImE!l5#1_=nTWs)-BMr!Wr7f+0jeqmVsJcIl1z$l2t=qQN0?(^CP467>zD!6I1=%| z5JO-@gM(fk0e}e&kQ~rOtM$gLcwt2(R}B#%vSVti>%1#Q)E_BE;&$9^+yUkZLn5RQQYn+(l8-5b;O^(=FRnM+<)VM(m6w0= z;~!7c~BqalL*Bje_|8Smy>``mq&`Aj~4 z)c8HyZsKf~=iR!l>JYqhQKXE4WAxUc>dM+G8e^Qp&_qe=qw(Rrdy|5eWv3_>=I6$f zsm(G4Z8!o!Y`~OFC=nx}Mfmr_P6?jpa+1nz~MjiR_iaPO=KCdVs2GjG;VpqiN->MNTP+ zH6+3SY{-EE8Bm3)ZUAGa$V7#RnwVOmd)+kc(=UW1!bOoWO9&y$3ulQ%Dv3T=huX!W z;btsj#JWyk4b59jxvjD3dXpt+>Xeit3lRcBN{oPlfJoEj%g;al=ssib*}HJ8lRdjU z8C9i0JTl)KO~?Jc$JJxMPuZ}lrAd`oH)ycV=H{1-?!M~yw8(pg_RaM>S(bSRh=AIb z2b{Q_fvB(uBbk;7l2U3djAP{4#6|$FoMC<2Lsj7!;m(>FW~B97QPG)CjkI(cRaFuo zEM>X|m)7IuTF2hH`E1Xe-?eCV6{)KU+7yf07EVjXd3o*7ZIDQJoNWw}3bwfdAd~c zCE{odXErO8YY;#r0~u(e42%R)b2Bv&l+`$g#z?H|@w%~O^8(QzCuu4cG}!>1fmj)r z8}bH?B?m0lc#$L=LDd+iiqob-o8=~Jm<*r*J5dM%sv_#6lvS;oo4(InH?eSNLeiYE z;Rdpd$vPlmVM$X?i=93r8lVDWQ#V=RIt%?~QYVp+xKXhA3}vCL&R~e_y+a9Cir>%7 z%q+sqWIWy4XzGetI0P$g8G;545onvzBeV`JZ6{J&oEstlk}<&S5P%tw31=-(vW{76 z0T6MI?)}TQ!1StgoYpu~815E`WoCz}kU}W)@ylb(w ztq2M!*d*)`ML04TOWu3tB$`rGZ*xbjY>5zJJssxSMTOS-GBge4{c5zWWX_#Gcjl#+ZoJ|8n{GVu_~TCu$0G(ofE2@cJa)M^RdSs! zI={8PJ)KUg*Z@Kk1r@ey-akKwDy=+5KZi+EFD)$GcE=s68YL2;sP?;qX*FqLLPPVt z`O$Pd=odPzIfA8Psh<;O6<6MSW4tQ&h$Kex*?2Nh1Vav$k-1^+b&4>p>#8iA8zK4J zmXk@?0`$42(;-$SaI zD^wC#(~O%&lOgJMin6R?2&mHUcKi9@xzlI1x3|i&WM%@>>N3Cbm69lcu{KJwmQoUL zZ4$1hAg}RF6#Lxnh_WS*Aab4b>UplyW`0$YfyC=IA3M%H1 z1T}dn*akz-UsxWkuAbO;FiHQhi8mxedqH^WTP_Q+* z#hp3u4i%;C$|xD5qB}0Wievz&f#%%wg-1vCt(fIt8!&1u&CB9}!LftgBfF-1_nWII z8cs922>@)nr?c*h&Rl>2W>cbe9%qc*>Dac|I59TccktS!J^L?TxZ}mA{_KfI9y@Sw zviH#0xuvb%{3Vy&kab?e>Dm-CQBe|50%2B0L_*u9HSn^-T5E2XBJK>i+8j$kS$HOI zFKnFyK;Q4(^=9;d}a`-`HJj_giHu6ge1C$G>J{2l8bMK1F4 zmH^Ip2|BwC0RRX9qbQrioH#ZdKsbyh!ZDO%>k1VIP#H~R7X&(@)>uX;jqQ+C6_sE# z0@1EiZ!0MXiG);@lyz;pqxiS%oGtxp{eRgHOTr16q`~* zVwa({Y7E6h!b`mlr^KNl!4wmDD?|W_!^U1ALKllLGjlA5Tg_zDl+(JdEGKGp=34U` zW>r-)Q-9%@92r3ngQ8%JRTNIip<04g>>U7%K@f&iJ5&X<)>;DKw&_YNqAaao(aTi5 zl*Cyuh6KbIAO%BYO=}3;qGplRa7=_u&bFm9OY7`OtyY0`E(AqkL!#EO0vQs35CxSY zGa&d3!4X)}s4=n#i;R5MWu(Hn7{yvA)fiI^#KzfXG*l&Ly)TMb*WO@#h5R@=olc%* zAcxCN!GnoLQs*EP%tjMx%9)Mi88#!&SZ8pa$1nl@cF&tgk zpH$0+i2z7rYKD{H!rWr7=n~+tp3Zgph&Y@MK_E(#S=US}V5KNJtkHTlFm38QLshQo zdTC*?eE>HxOeWL0e!nPk5V&;tGUYTsnA_amVuZ^Z8{MJ+fZ=2Unl`q_3k&nc*tONQ zPNzQ_$)FF@=_D8;gOf>}>ac5}KesUGbry#sbN0fST}z9b+go$RU|ek*XPUZMSezS< z$93Ish@GNnIglxZOP4RMt*(rQ+htXOLaV!XMdELr@!kW*z;?4d=maANw@1geCmT!iuzUZ}xy2J#U;U~Z zuHSw1SjY6y_g&UZw?|`)FI+zNr6>0P`KcE^f9`Z6`l@|u2kj zIz`WS`+F7-bocLHA8mz$2aU1LP}kYeG`()8)9DIxYsTA7F^Fi#I2S~?oje$8RA-}; zoe~JIR4#%ueRqW&DsL-&wnK}>8L&ebfD}PvnpDH{@x>>ahtHYwNn$l^TGg?Oy7r0oiYGdSh^ZIs^?n*)g*IuIdjoqpRA8%acVmsHeeB!y&r*(N*nreR6(o$8v;l>lEU-hcr z{P53SkzM%P*FTC}1X^!K*kSj+d>H@%l7d)_sZIi%gk!{_AeV6nNEQ%NUE18Mbxo>M zReQ*M;SoeYPz|V6u?n7>np|dbl+*wMDj^FuW8*UbZ!@o`ENqMiZNCf*#-dSZg>*nv z2uPGDrbs}2n>pq=W0N8Rlra`)DVaVPK`o4x$T(>VzhI4X*4L6WchSpsDi?hp0LXgk znCa%omz%J-3jw{O2>=4QBJ-I~bu_|_YS)-RCb1Y+4UFDK6(e$`G~k6LN#f9?=~y|n zSdGYHO$+t_0n^Sz2oZ!;2!H@oiPRY3*0NFzg57cTBtxjmtY}bMLtR4z3e4V+qAG$l zhG(4>H5P?MQCnQ9B^x3upr{Cfbtp-M8ObVWs4C;g`c_fE)`3OUG61G5vp#c4ZIH&H z5CF3nKt)CJRTZ2ii$aEcmV>2OB}GVx)>=YPf-Em2Hi(v+34thLsB1NZH!5{v?yZ-679XxR0?mJ)o{HYhllL?3bLfupwn;S*1)6HB{jwZ&8 zN7Hd#CQjBkg9rpEsj*}U%MiwO4aSKiYuvD`Cr#PSip)CevtGxS%~S-Pp)U2B09K)_ z%5JxlWf`I%;?lw*GshGGpst(Ibbn& zN$H&{t5Q_6EFTZYscOg=&|DG^$CD;DDJ7S?a$J7(tEXRg=k1LdaFtn%&iTu0>(?GT z2B?9VQW%d$fY{A*LTW-#4UR~}5V;HMmo8qsI2;bEvg&jT?+oCTc@|o0oi#=7owIcn z+OfYXY-|oYojk?V$+O&hPQr;}O3vCC(|B4Ic@{$=oUzMNN(#y>o-)$HR~*-d&piL- z#~=O5UtGS7b(|k>l||RNU{&iw`=^|akLsRe&+J*;S5>%VdnTVcdpRrS>NwckSc&}P zxeE_I_u#HinyUu;Zod2Wt8TyL$bsvU_0w7&YDRy0?|%Y6->?%1cOKZ^Q{LFx>K(iK zDuJ7q*3Ue){pGENRqk=koJ6g4 zKJ!fo(`hqpE|!ZE*p2hueFx+!Oi5=mnOWCIL0cS5D`<;|JHIuxzk55)(N>0ypfxI1 zRp04cd-H1#UUlNk3lE+-^=B&=FB~|!zH9&1{Nj4vd(LGiz1|UJeBldU`1zmz`9~gkWO;e{lb`(Lw}1P$x7Stmr+(_Ee*M>feS3TR z^{;>Zul?Gu9Y21&eQR@b^M`)uhd%x3PZQC*-~H|nfB3__UhnVxAe9;83BN{FSa<#u z(eY>!Vxs`uG^uG6Af+IZ$T)!Z2Flgg#4*;5b%<0TSV15qVi)|WVn%4nRIV5|Z58iP90R$o)a5^+js6c8B@M8pY!mN6IxLCBm-EF555vt^Vf zOj4SszBKj9wCZGLnkLR=gT205ErX_@VpO#jM~YG_2e!E-XVCh*7lxw;o_g#Tf8#eF z{pt&sH#dIg-~G(D+2R;C_r+}t-D|Nh*-ShCi99$#Kv8IMMyObCEbM?rv=yObLnZC3y@SJYu7%H5&} zb<@uZ)!YGbsa0JO0;kLUJjbk2*X?B8CYWa0bh^$EQcsy8Yx53bKW`3 zyb|>~gT!^>6hbX3S(a6G-7RwV&XD04$J0sPDKg)TCL&2GfHUUERR=qR0oU`J({bHY z)2eDhwZ6HP=icT;HJwJLrm2&}5X0$Hr~c@_eD=&sXSTMs{?)(w*Gs#0EiYf(9&X1N zmoIH^ZfvF)0pP_KU%c(M+g`~Q5JAh-RprE7*4%_-j2R5Ny>8L#c9^-Yo0JkDSW8G4 zQ{u$JIxg!X&#EShuyrn`XwhZ_XP+S=Uwu^<1px7~3k?DQ}`{{Q~o z=l}SR%jxur#Q$aSP;C9E5eQlyERZoU8>g5ZB}7OZH^wU$%9muIo_Zkcedc{;j4{@D z>!#E3XjpCzMwk4H`^_;hGdcUVPQsTBVqgZIS5=@H5M_2t>~!mOriL#F*jg?FQK!Fn z)9v>hy!z%d&p&kPxj$dOeDUDX^~K$j{=#z6eI_gJ7QQv4K~g}aR=Ji46$F5gh+Cr{ z1RxX^+~M`K<}xDEDxu9Fw+KK4VE0{j-5bB}e|q>o-TV9l_f5y!VR?DqHT}VVE3LCD zsA~6Ly{6OYt+(F#E5Gt9f93km{oK#}(l7neM?UhA2OfB!+wH#XZEvgVx_#@rzU#Z5 ze){RpeeQGj-h1yCzVL8i&1Dae@jEtOD1g6q2%&3Nvg(wUFVD==;cMfGf$m) z1)~x}C{YAC`Z@?=(OZZTNmvf0Q(-X&!|KgAS7yuxlw?u$U_@PgJ{8vBq zA3yY?Kl+FN@e_Hk0|2i){+u|)&`h?Q@z5f1Og-;%-@@fvH!KC6nOCWxh@e4Mh@28f z0O8g<3$RX5MNI-BC4iYSqksSbGm9t^0s^5?z=mU6udrg^wkT5qy9H~lSZP#YKEZ>}t>e!6RsaM4$9dvthG-12j!MVOOnq)-qIvccYkUMH(2wKXP|C9;sxw5%r6>DF*q)|H6nSq2Ks5@H0REc1DmS50!( zvB>s#QZ`{Qn5#JWoRL5Q4(;1RXj4j}T297>XgVE>Hb{_VnW*gBf8cw+_xk`~YisL; z7oH!F$J?XvaJap;x_0d9tFOE6Iso{N@A!^axCMylECL461}TLmI&12x0R$G=9*(DF zon>BB>n7GsBq9+V40^_P5j(jb5MW3=MJ+hir_X)nqrdagchn{^k4M4*)F!6hQ&>)1Ug}XFv0q_r3r9|Mn+;>Waj_Ej@)rRdxhK zpmoKY$?GC0wJvqi5??2iQ49?#?ONEElefmIiZB~8)@5Y!C^&6K!)84}!zuzQpaKG@ zqKwqSHbgkK9g=n$)lO2r=07%*FabqCY7H<%L{&g(ZhqgZ?*6tr-}0}?{L`l&Uwr=Y z>e7oVn=8*u$G@-o+gbi_?rOxE$O0h%iU6~4;u#`Gr0v0oN^6AKf^m4qh=+`6@xsR1 z7QeD^@X%ZS$L~4*-~aRT2aY_!_NCJ=E}uR3bw&6UufNZ}$UENgj(5D{9e?Gbs($E0 zANq-(_=$JD>s11u=65g##G^ zCbWjsq^g3%>aBn_BCUeCX6O-JR!me;47kD<&hNoA z-<}Wt;xE4avnTGo_ulut?|t8J`~e`P1R$ZFHq$CJjkm^=OBz@em4JaRNCgl{-kin|1R+d-tJfAzf zM+;b6Svz~?!mh#op2xt65Tk-6iX0P9jaAD{QirP6+RS@n-Ntx(I3DeqU-E+j5OkZ! zWNRDiKs?vmuBtv|J>0Xffue#H2&>grlmRm1J!frAGY78b|b+W@e#vhoU#pnf+`EZt6C zR!tKm_nnw{b8~ahKV-;enTwHG7ywkYu0v>oHPk6GL*4PDn$%UECLRa%`LBNY{>LAD z`h{wB13R6iy@P*t`;E7qJbCj?H})YPhwo<$4`q|I?!MDHr-M8OyXEiOaNc`Jr1=0-HiL=vxCVPpfvt9zsET}9x7c(6S?@mow zIiINnK!_<3VF;0xZRVqzS~=K|#hic?a3;No$|7dRRF`B&G_oyUTj4bk#2HqX$mq+M zU2PF3tt6Hp(XQQx7vB6YE?>Ou)RTYm#KTYQJF>n1a6Py9Xwf^Bb#KXwZ;Iil#T$pvE6%6ZR&;qGzMy)`quV#AFw_rvS_UU1AXv0-_a#+z~4@Ny!-{%DnAlnQ3J)L4DLN<%D1ngEWyNfw5!^5C|v{IB#=P z4<{bMBbizNz!^gTDth|z^6J*+H{WrmLyT3^EBXNN&_fTslK2BaY>iLKvT5oN8X}P`#g1C*6>Pf$sxvhP0A-#bQKKk}@{T64D708OW5`;oB8X}X5s|#yV?lhmIA|xt zqQHPnYRd!xWO4FpoFr752 zlyy2T%M>YyDxo1rF(6s%Gb9p#Hb-Gr;|h~?jBx-^4mZcEm&0iD%(>;Yar3(4`xBVa zblSCaMdII|TiAEt;KIUEmK9(6(tVFS@)hgc{L<2EU-P>C`}a9xmBo@JpyB5B%Ejeo zeav;Uy}iAB@nYSSQ4#~BZk5`78X##Uf~xJ`r}5{Mw>~s*Xc!0<7%=s9c@j9 z0C90)!R7N)S<12=gk)C7e!I@L>R8pGX}GMNF|MD({!X-bAe-|QW0gF>#^%;=G*(em zGnr1OWfekfV#xEXC~`;wpu3m)-kDyJ?b$uQH0U{J$CGkvdl-c~odN)Qo&Ldn`%_43 zTU&`S0!+u_xn7$q2`H3h1puonmoHqnxUs$gqMXuTuplBS1pv77&O2Y>5fnl~#K@_t zA|bL!S=H9Ln9_JM6&7nvSp@|^!q$qh$TMcCLjVL-s4%QO^Tp5nhd+91ZI$zE&uee} z=6Ag1pSB+hK;&i-sKHuJ4zi|1|x#hKU7uVOy(Xbj$ro-`g zI2>(Gr=xK>np9=eRH3QsYC^!dbu`z{Z@S6d_4>vA2XD9i-da;ltE5c|i8UIWt+Zk`x3$zLs^X)GE;LG)Q!&;Ni3Ez@8)d zMo%|%b9Fg4#ZvE3Vdn`<2!WXk?+db+Nap=B@YrhSVk{ao(&`emdc-Z1)EKklsy-8y zM?g_!7MW$AtulCvtVI9=Kr`JmBvfP;M8EIg^{@Sw@4Noa|8;Hkt|uOJr=Km?F0Bn$ z@2e)iVa=zC;+%6#&ROSLwkRq~iU=*z4s}OsL{!^=tL~T-BC5<-!7Ncw$=V~g-S(#U z|I7J%-ulA)uCM2WdFAUL9CmeOWd#8C?)^)BmA!lSwij1cR`%@K^YV3T?c(BM`_|X4 zrfHg{Xc|WrJ*%7i()SuO!;qrZ9^&mRy#qvGRnWi(<)oP_e!c77~@z zSahI()-$jg#VABh)tIcyn4sFWM#YOkXIl4V@zxk)A;k$1K#Wikn`zQ$$r$ShEeRnQ zNTNcNASsPQZO{QA3RDXF3>c1xkQ1sx6v;CWVAwlA8A>n!idlw0WSf*aWrWwM0T{k1puA?U=mXmQyZeomoI<)@&6mQfSE}omeWvI){y}y zt7?WkMFKR4t#h&gKv5Q9WVM!{?RUV8d?$#EkQ7`C6t}1fDl8(XV9gAIFRyV6+ zcQ%ATbwk$rqSsUbAbDpvCE;YP$#dTTs4%m{NrcQnC~VOKfD}VDnV_{>O#uMA`vph> zrPkc|mB;_CJ6`?x(@*W&w;p5M*x2~3-~R18Zohrs?%g+Ef5Yk9?%3YiUR_%wBtuk( zxVF0HtUHt$mt~t5+E`WSd)p6vnEH6TsKUDu17T4Sby~XFMf6Tl6JDeLjNtVzy1wxzh}Yw$wQxh z=8K=36v;2pbuSIR{NULeuimS3oi#)hms?*}&EgG*w!dmO&#iEbsD#=Y@amL^yyFmH zzR%7y?$DA%M~=Bv8H$Inv;7D9=-75(=R>$Co9V@9=*EUwRg2Q_qn3?yz_Sy z`Kx2t1(Y!p;LOcxW&zj^1UOmen3Ev`M6e@?CL&~vF$N8&h=`Ig3;XuI>AT+h%+*)@ z=b!z_zkbME@%0Zb7kTCDXMgr*fBL6?`fIPKg0#(j*nwt$O+vyVswspLKsct@G=`O2 z=6buhoC14Lt2>@HNfKqwXFVcPB;iCLh@glqLraunH8kF!7|N_Rr~XW2qw2K_j%!LM_jRMF`=;lprDeZPTpEU6eL9ScBTe6s|knzz$$p6_>Ia= z{`Do zSzd+`S&}9Kn&u0fb$h)7vN`QAP3lRf=%~oJE}e68mF+clv@slX=9Dd=X{_7qlq{0D zyr{Iu^SW-lw{_Ea=c}qBA|hJsFOb6!Lsivvt=_p1m=%l8-foe_CU}d!>(@8d^P)pU zlj&q}e%_Fq@>CV9F;rwBgfr*PUbwjY%rj2_z;HNp)+vDZ9soeKs+#d+dPU+dqD5}4 zH8F8hCjbY~_CPrVR$vv)oEN96ntP{#*%qpuzT?UH3!nYMAC;n6uXpo-1Gl~D4cFXo z%w-j5V{e>);j^3fyz}VNRmErj^J$6t%w)2B>TEXXA=yb;)|;EAlV#n^FAkc^8_Xgi zprUjA>EXRw&TUSo)a?plC(ER6#)$o@I^112w=p!mykm>)dP2JwjCZ~5xDcCz{k#Zt z9)XSZ))7(5!L_#i4w11&M3BH)D1ngAm001h4 zAm5NN+h31Av8Up7xZ`%tw$Uf%nho9|(U z)>0u^x9QL(tz5X&^v0JCjn{Tx=q~im_0R0jk6z`jIbx4@V;=z_5dzJCt2>zoD1b^k zH$g(2Iq(4j&ZJZc5Q&A2F)d+NL0hSC5y-QJtI5!c2w|CqzIbRwgp8@2`E$ z-QU0#d;{wrTrRS2-#!4ieEIVJ{rlT1moHyFdGciY*6Ql&%l|T^w7I$2{`;?8KmOxC z{v$u~Bkk+aXmt4SVTIQDXf__imnB9(0U(4Fo1jQ68k(lAY6D0H6-}zAKn}$lXAn|* ze|SxZDMp7wph|YG*-0u1H zt>lWHS5ShgZi+g@vV?xe_wqO_5h1qUN(514g~h=<0Bmh-A31!`?5NYWZK|&`{(tip zsHn0r+syeMgKyu`aFd&pcyf>CaQpz&ptyoe(m{w6;^oByySm&)MC*~x;nXxF106^xf zC3L;czT^Sm^4dmk4pAk`-4%)dfdl*Ry8ZS)olJJ^-ZdO;EibQp=tDn$*PXZQ-tBL= zwl^ByzOlY``t)g0F@|Dn>Y6WJxL^zzD;Ki4XP#SK8XVm_*Yb}@XWpu?wz*kPE@hp( zJD76@V~wf;ih?+p8x%fU-CV2FP(Z=57QKyOwc8dttc$SC7b0miouJ4Ir@s39^Ut0?cMbqlC8p5n^zxzu04apg zcqB;yU~O&fjyvvnB}WhvI%}&kB$3Q}RSF?BO$;e{XH^_|A5#bn2oMu@eU^ODpOh<4 zKK=OzznB1u{`@UhA0GH>Xv9y6}CuM?bluxRL~iZX1!@DM}zf^9QaT&j}OZU+HS9F%D^JH zyuI7?=RlTEKmYUp$FF?%cfaS(+wTqvj60l=SrvoM+4gX4ClV}z!lcrQS}15rj3_&F zQ=*pOO4tT7#z+>Y|3Lr%AOJ~3K~#wI^9ukl8f`Bu_R(CK_|NpV0a>MW-J2m;wMER% z+9qEkoQj}2m>YcaTi$Wqxf@QrgXc9y+JIGntQI4NYcG{$* zW%@wNg|H$sgg>ZQwY|CBCr*CLp{s8_f9k4Wil6cS$kKMm8;lXQtrNqGuIY$az5U#;24xNxX7SAbyQ86xCJe8N)i*Is>GCx zu_~>}f(i&BkugM;H0>M>z^Wv`2xZb7&>|Z`L=+%aFw#ys6?Qa>SOFM}K|o9@F(pJy zBDU?u?uZ}9#9+V}Ltv7MD9n1N%of3*Nr{Ot&ocmwDH&rds)&RToVBbFlL*i>iOa!e zj++3ifhlrY8h8nH)l{qrEEsEzAxjnvq2Ux+07Mi4I7Kj)&;o!VHOR)~$L9OHy6(Og zH;$g@Iq&K!UXl0{nK!)d4PW@e7XbJ`2fqgk3w!tOo=m1+{EPd4>tnz5ga6C-A3S*A zrm3DjcWYUd%a<-W=R#-_$GWV}pSvI;BHj?q4f0o?xPJHioJDFlw$tyWxdrJ&<1CYm z>pI1dM60^V1t>)?KF^A2In45+iXfR;SlX4@tlFA-V+2q*IY$6lx9BXdTvnp#c-)=u zBRY$2eL6|5ZtA959~a)UsIwN0>2&5(iilL?c?f|-moF}Nx*gS!mhsSoFRzTpV*qGN(tf|+?e(2=TU(oDS!Q_# zBY61Xhd=Ov54@5i2ow+1~GsJy)%t~-JCxE*kAnF!(TDh z-g3*WZ~Ug4ho>H#JCI%c%Efa}HmR)cyZ^F5y5Y`ipMB!=>V>s^w_T-~3DYLa3T~3$ zW9zyhPZ9+cT(7`hLBq1uS7*es{Z0@9;=oW-l{GVV-Nn;u&#hmm3@u@Q+)U}vA?;_e z5xcTUiKZ9Ne)RwP=%x2eUj3Rk5*nDTr7!T!Hu_NUN5Nvw^Qc0z@!7N)IXsKn7dsB7oM3 z7o9i9uDSluv1{w5im?HuEX#fFob!Y_1#B?3(r$R-HeRn_FW#)+8Y6qCser3f#fP zDDI?Q*ydg{O;`~mN-3#|G1l7uMoGfoXD%|COirCT)xJJ+=FDS{J+`>Gc;v{DAO7JV z{+XZond8TgUv<@0AN=444;(nqN{`%lmo06;*S&?rknZE*^!%0R$V00t_M43Y8eHexOu2vM2aTUiQ^ z7Hk7(lmtOoH9!E(=VBC<a5;&R7dDlE|w0pby67y+r^tpfObtVj5050C8)(AlNR; zQy0(Mjst)*7cM?ESlr{f`}gko!FPVgzyA-vd+qV74;?-BzyId{4FKi=X-O`tgKY2G?Yq(D1n6pEzvfEqSas;2xw?< z6QMSs2WSVF7Y_k++jQFyfx}NUZnZIOBZfAEWoV(s0yLLYr5dtwtgIaGJe>La_TFnP zKYZtw8V?~wSGw)6_S4PG8*$Iw-^qQ}UhDt={SgYnVw@^hao|{XQDl~)L7Id*g{Gld z7s(8U!y_h2COKxq@yIac-Zi0V9vrSNE)BxX zbVN~A>J+n_o#WZ`$O==lBI^(qF~t}Y6AgxgCU2^u9E?VuoFut-|L)e-gI8a9<=*|f z!{MlXzl4yw-992a$7|~+HXqzCihOBl5dcn{IPp4jMEbR*ARomKV-Xi_8N$wd!E+ zkZF46)J6<3yjm5d%iJR4$P=AfP8l84)8&Ehj->Wnj|PA6+rK%L^yJq)g>$CYyvvM) zOq4{JSj`kPB_%=zRx&+KuQXHuK!jMwgM)o`8362TZ@+r$R;TJLE-ioCw}0pF|BHXI zwz1yt^&ZOp!|{aP2mq;dmK+x%^P7(WnY9%Gv~rRby=aKcF3<9IRMLiBA&?~_!Yc1P z{)V@nJM+la&ejW;zj*EPv!mNbqqAYQJ{&CWZ!bN#(Rt~Df78X{O-s6lkx>*|XUnmj zr)_tn7UW}qh|(%ak2MAJk(EJPxEL6=ZGI$BC8EXEGjD&__YU^nedDEn`P>)2c>3)4 zszS(SC?bTYuhl}PEf`HTWx4-qPMFuf z{@<)co_Xe(_rCYN?bmHf?MHs(M?U=F5C81X{_JEj`QQgXcyx61?svcYkN^0Oi=t@1 z?Kgk(H$U{D4}I&merpT5`PEDS-x111tdusgo6B6_?OcLJ+bdnU#Qz8j^v7{UklbB6Gu- zGzKyy%M*A>%HFA&QnD@1_aGc%e=dnPIywGwn7KvWT8M?eZjM2N~nOq5cLNdPQ!4vABe z`Itu~MRSbKxzs9Iz)T|mfofJ{B38%X*d=mA$c#x;L_C54GCA)vCEpCkq!G+=-=apG z##q<220`G~Lv(qk{>hKdWp}^yv0DJ}fwwIEqwiYz51wAHlm7h2AB-A#;$-zu_CLi$ zO#jX|e&dyES3m!S&z?AOaypsr?C$@AfACBH{Xctbb^XLU-|_X19U*<6GM=@&I=>XYeIvEVc%ru)!7}4iBiOyzqO0u%N z?BuXqqNiC@y{2hy-@Xk1zxR8;_j(^e8+ITJfB+6b zn~*Z^iZWBNSzYH@Rh#9K8iNrGUithNzV!U_-en#2?|#!`FZ|KR|M|;z#-pZ6>9N(N z>8R!&s zf56il`5Vs7I#rP5$=Cf}R5=@Y=y+65PUOp0H`wb#r)1OQ{iJlWV&Pz^f@az~n11|s zKBA(R-uQ+V7YW$rH~_qs1Em6BYGOK{;24p%o$2Gei&tO0^{c<~EA0;b5C81L0PyZ_ z{^k$<_)ot710SgC*@u7qziU}%uYdoKKVt#fP#+?5h-AhVF}9d&hZ!q_wWqp)nxVF8 z4+A441cG@Xf@tlqzm`+>_hyxPJZFE7xAyy}dI!bu>LOIb1#5THLt`QpcR?!S2U(ZkiXQEy?p=v>e8CC_IaUjVphu$m+nQ6z`fLRzWKMOV>w zl+*SI%>)sfdiGVl!(aD04r=-T=^74)3kwTB`O%N%oz5|O@5{>7c5t(Gck}L*TjQgn zqy2-?-Y%$4rek841J7Q$6%V$^34qV@j`Ji{l4qHhZM@DNlz86b%PqH1i=lt4g$kjWx}h*|0OtnROVa7}Z zKIbNg382A5y!YHGG|w`TXep%xX4>oKMX!rY&3I%n2&+0 zr*86j?hgm!JkJbGqq56~qr*;BInTr4IK||gt3xBAgczELW{t$MC}wrNu|_e?jt0{f zOxn5?ruEpwR+d))q2FKF+KSGzbAEkgrO2~cU5|&OS6;n!^~SY3w{Pw4ZcirDrU`9N zE`(6m_0rPviH(zaQKT3T4)+Ix!I{&idcE#ne)3bVfB*mZPye*n@6Bd45aQf>Lj7(P zlBjA3Ru(-mZDQ>;j-Pqv4?q2>F<7Un-hJWHy;rVXrS$yP)@pz8Eo;kplE3lhGcVlT zfAZ4mqZj+1yE**SbGHs3?4Ez>u?VnpV>cX))>al)&MjLloA>txz%7)1sl5C7>uFk7 zi;I(cTPii8o2@M!o;?u^v%}HmVlNBL`}PjMbnE&{-K7&5PHx=ULWyrY?UptqPS@`5 z4zQkfPjXr0yE|(;yH(ly=70ZtA31j}%=2Igk7XdLnvz6GtsH@fymQRVa}FT^01+aR z_uglDp64QB26M)c8h`@WXf*oJ-}?_=|Nj5NfBS3RdvaumO3I8g8g0VuJ-IuYH;vRLjfcQ!5-kDT{!IB6Gr${@k9_KIKoSeo~0{xu#+E3N?mGh=GwZRTi@ zV}XkjgQ*xIpv5qI_2tjszW&F{D|gPEm*thR)9X4{WVt8m`0Q-bOYGm&goPBns#7pX zb}XO)L`q3oB0m63CzBuh?(cj(kKn6Z|DV%~{6Dd5jva=%SbP4L^9Gn64^34QvzyF@ zDw<`^0MTb)#4eZ6dPy7S+c6{ofQmAbsTeb{Lm~tq2gpp`IRru@hk$~pNDcuVb_f|v zO%ouRMb(CpOk<1_@0N)O(IFuiqAC!IW3d#ajsSzy6zmIf6=Lq#8jEI*5DcPXZuw$= z;g!RK%Jn)`k<{`aR!`ZNCaQ#l=oMfvicwvAO(G19xSWtc)KrzxYA{b|1cZ?Ojdbk) zm(KtY1wcd)h?&5Whzg*A^08&cL{yWh0ihw)3F;ur9q$<|i4mqGo+$wWLNsGQGypZn zbUayU<&)O7R|%n|$*Td0GNTd1q>j)r5Q1k;CIHsPQvm=0rew@QL`G=nLbMcs$THH_ zgCCUY5Hl1^sL+rmBxDZ`0W>z_VNq3{NZ7>~9XnG^Q4oRAnp6`rInMJk)?qel6hlhm z{^DZhfLm6*Ssk0KsPLFw{W_PLPR5h6Q=K?*;`_h%`~K-~{JL`%L)_Wf`~5%o!>ZH$ z#h?GhOOHL8>Qv-~fPL;WpEk9@aFAkZiQT65%C(yZyL;RBZhrrde)m&vesAgX(tAYg z7Zni}4h@PXHVfs_Y*tUFv;G46Jl7CbSC)5pWW2jO9gapXU%hhY_O0#houi|}5Skbx5jplTNz;U~EEoEH@4bo+N29~T!-a)@ zufO{0^-n*ERVRA^!Oyn2(-J`)65i{=?lg8;Kt6O-#A%~23ykx zGtkWgC>C5%NmaUJTJM|Xu(Gm4p+5Frtl(6RT_A@x+_oasB#B&)@jM z*8RKVQ1BBClf-_W)XL;z@@U;yCVJSvGOBV+{U zT*d@VXc8J^xk?V8CJ{0(4m0n`0RTkEDTzwrtgsXi9Vfvuqf8Mag(;DDokfHxqL_K0 z4k9BFf*>YEzye7NL=16=VV0FENC=vkJ0=P#`m$h$$;F zP)|cYM+&gwJ4l%saaD3vNkYg770oPc@A_#ij?h5RJP`;$f+$FhYD_7qQ>}82X67L# zNcwQzhysd0s-y-;>=>XGj)11rW`(Po5+R5w8Y)CE0H{2HiY7!rF_}xx=9+Ja1}Rz2 zpq3c1Rki{lfr=yo=g5oS87$N0l=E{6> zIKq&`G$UX@<=hqIU5p_Sa^{eklcc1UGl8hojft>#h{$=Ssv43SlzG)*vy)4r)R364o^S*^n=X@zyC-7^VxHc0Pyzq&TswJ zNBaHl&;8ubJ@JmmX``&W7(C>k|Kh7RUp*Qei6m=GMZN05-oan|$zR;PdH-+y@bEqF z`X*+9p~O}tge~aXgClNcCHEH9Imab z9u9|PS#+!Ja5UbG&nfe zN20aWRo61YAI9o+x{btMry7oHQFBat`vW2rQO5`%3$V1CvERD!@xS=X-SPg&m5(hi zzICCxGB_G6_ix8Z3NyUFeRX$x8F=ioo39=|{p5)ocMtb>XRSDYa&N!9!4X3q6^+J>V(aMEW6Yo{bN-ut)Il0~tO^R$?xoJkrw{D-y{e#&cEN`6Xc3^Xl z%dGc~Cw&TjZ@V-U+PQh6eB_PpEvNkXDish2fY2c-n$EL!0RV6w z5~?CFr?nnWZRR-@Hvih7?YXu8x^m+D(|`TPp8MqQzVzHDFTJTzfnLAVJc`DYYH|ae zJ;>awQ~)J(1db_3jf`M` zjcFcv7MfX>^-PQj%o0+D@iQJqEqGE0FVG^QxM*xOIU_yqVC}Id`piL4cWHcaX%P3%A zYgw$+gcKD^M$gcC_01p|A&@B;AA<~$z%<0DU?Pe@(kiuBk;uR@=K+kFlog3U+W=94 z6o_4sG0g=+B4C2x$g+%EpS~KQn3_dV=hPEJQcwjH6_uELkvZp@IyE8Ym1AOanv$rI zmBqpma+o$DnW_=^%#&j>2z4{9n}@RhU2u7 zx3~9ezxL~+@%R^i@#o)o;n9QHWHOtOfXlO+SFi8y?MVx!P?MA-$+gQ@fB6^w;qN|j z{>g88=im9kA3C*uGG`yH#xggxn3~D-P?1!c+&lKRywV#-A8J^r{LaBa3XLzl?-xa5 z`$vb}qKlG3Xv~BF_Ye0}Q&I5A)z!gdP-Hm+G*L#QafL+_LZ0QTOUof>kuMCxq|-q} zQZtD$FS6liG#O0|@$T0BtGW03CZtiyx5H=h06=brwC zZ)E4mL5t`BI379Jy#1l3CP37-IJ^6 zck0B#iS;U_yGO~5vrb4&T}Hpu@mZcyEJkp`Z_Glyzjw4iy>6#79PO0FBqd>zNjfS# zx;%rLLyVdC-uacqrO{+EYr^u{`gk~P!C(?3s`xCMO=ciugU|MSaNF54rguZQOQo;rVNA3DlmzwP42`bzc6tAppBJJ?uV2vJhfEZWi4t*4)U?6Jq!UyXJ&NiNiqba>~W zJ{a}Rug>Zeh-BK}xVEODgCkm93SeB%7OKVVGTXU-@80;Jgi6w$0G35Zh!rd>^k&m= zu+$$7w^omIR2CuB2Eis{5a5K{&)>MYzINe}OH95c3hJ=|{GsfBOi@i^40}ggdvqX$7&;_y$i5Aj@=VUL^W*7wI3Dj5_qN^r z1>OJwGypOMG?|0S5Ye=ysv7_t+j81AkRd<|bRa-5GC%<8c9-7v&T)dB_mM+6+voiIA{@$t@GBb zC8rRWwNxg9*OaHgz@4)H_3!z>wHMZ|zwo>Dba>`Mv$)*NO9xJvpIJTT3>BzaF-Ynz>$Gdhb&?l zv2+YA0RkAA39)O16{zBp1RFc56O(W4HY#-!MPZtixzbE& zG0Qq+iY5RENG1eYn`J}}IdhI6M^a}Y)}YJ=D4rM@8Wa%8@@g0p8ZG$TCuNd6W6+Sf zBF(~de_-fH6}__*g)_&*A{b{qh6tFUVGf4S%o>xFlLLzeh%Jnn!L^Onhx7;x0JEI4 zf?%u!gj}a+(W)xXa@5qA0w5^1x!2$c1*lGtF*7QFhLji$)Y!<3>L>=r2xaB~AgPH! zGVqLQloXgy4VsudF*y`9hXeqQv6aE#oCA$Opk|C1LnK0GcAl{%AtnQhsEX7&bs34t zBy%W9l^r8RiGZAYCKM(oK*`hqV+e*|$enHnKvEMGO+`#otdm;foogmT&I?b>xzD{L zq{(=iMB6-3dPp+@m3Vk~7-Q`9x_!S8L+p0DKlXS3?mzjb9~Kdx`FpqT?C$P<?}xeBC#!E-gRz{PV7Iolf`WwVTuF)KXFv6-gdZ z>|g!q+WPvXOBXIaa`wXclZOZS^3uwwldFW1`9dTvNRESGSuRMqIIQX5Xq3=7qSEJ& zo?ngekhn<#3u|wl4yUmmWi$m)OEIQVRk35RH`{kWz{c^VOfiL&5*cR&_@aK{h0lEAv;O4j6{1I~ z?5{m`?&ha1cRPG@`$&tITvvYER^I|ZVjE3WSG%KqrMm?O>u_&8^p_?@lBi!F{3w?B)8Fa~MjNx$5 zAe=k3UO%|cg_GU8>B4EvGDHf6XCl9P#!v3$2!Rkxs^QMUUIdApiW|?ru(-79SC^fz zAhwr+*Lu$Y$BA$TVrHbMt=-1V=HnY?HdR1s^QVx=L|=<}d!0*7CBBH~|1ab2Vr? z2JTk>eq)(8?Q zp?I~#7Lf8V+cgo$y3(M_J!nn95uiX#DWRxl z9-EM60mPKa5oWDr^&#C0=T{_lhECNG35YVE)lIDHrYwkvlL!)_HwH8jL~xWL`$>=* zQk4+^n<#>zL1tzGhUU;RM+RU>U>a2gG-oC-08OH8x#11G_Y9~hA)50HrV5s%W#<~G zGP{<=+k$jO)Cg3}tc5YR8f8Y}7=r;P!I_vM7RX6VC1s4xah?^{Bql})mPAx*92Zr= z&WQ*ztD1p2W+E!tk>||i)>0V7va+a0;jjTFs~*y&B*fIzH4%ZDDO8=xdDrjve(Xno zG|HEJSPrmhi@6Xm(#ZlHPOJ6OmtX#i*b!U6K z%}fwc7Lg<=rMj+%!{Pq^-rYO5|1xun3kzpXZ=5-Ea(!cQb$#LF^4f`wjmnq4p97-` zlc{4bGt6Aa`)vR4pb4bXHG$l9CX>jc&A7)3-KuyUdXxUncfafDcb>ie7tep}g`Mq#{lkUj{K2MM=mVKdrj}>pS?u=u%`ANC#ruSK zbkKNYM=S`GZ1`Z<>32g8{gqC+QjPbgNB8%#ah?GHfO)Pp2^r36nAP0x72f&D^!!Ml zA5Ivs98Qn0oP`5AaY~$TXD$+hQ72<2M^HF&%QQVYebAImN{FG%iZH!)^>V-ePG&ZE zEevkH+95d|TR-fzS-BmztPNG$AqXH4Gq!_|hqCzq00yd7kEVkM2j&fWkU^1mJJadF zP-99+kYdxM1jN8d%6+#?$_mL$0o%z-o8AI*nS6V>C7Krj@Z}KT*AyghOt%6;CNeNn zD9iq(H@yAqxySE6xc%bg&)&TH^7!sxc4l0knhh2Yx4QRklrO%ac+(^0n-+Bq14>j< zM51sr}*X*6k}R%fr?6X=hqz)lpvEt2(#J#jl&z>;L!L`Y_kmL@lDKZRj0***-I$ z*MPMZyd_D1$TU|B#S{rJg_xK9l!k4hJs?1vsm2+Q0GKq>79E3<=09ns$)>JgV`m!0 z5)rFJ69&xKF$gr1p`*UbSVB#i$N4n^i5w_Oidorr>=oylDFq_{hgh2?izlFT2x1D; z89UFF6-;WN1P)=QsSeW`e2+30=s;8@N!Tj7WdMZjE4nj{9U zrDa6Ri_9LiiZ#Dkx@#CMsf%+EfV193z4V0E5_^xJE6`)le02 zuJ{K412kqZOY`c7u~gs`eMXKgNegc^iHRACtg6RRRdeqh5vcj103uV>WRjA#DX}7y zIHcN`oMROu#7<6$Toa>M`bt~-RW0eR+GuN>QpI2a@6Z~f8YmxAj|DbFTB+6 zE>^GH$hZ8?_U=!7=SZEe!%Y&Iamqv13~i6W!%xKozH@nIe6qv2#asgDMO z;o*2R9*xJ-(B`3qAR=wjSO~GMYgNs>&x_nSUzT~1=i|wAb91XK%jM;jsw|yzA%x** zSl6>Nr_YpSnYDFDkuR^Wd!Id&{cq{Ld0wt8mQ5XXDxw+y7BHE^S3mds?$&+jR!tMX zVY&aFH(&bf$3C;8HppC%7-!QwO{H4TnEZ*8CGsm*?j5c5&z)S`$lRwsb9p+64hdCT zkEc4?+aGM4SaLmI567brA@c`2dsY?V^X~dmv#|u5dwAwl7#)!aCS99NWgNDKqqncD z-q}0YnkZ(ut({6>06?l4x)C#{n2U51afE!Vl|?d2S-yR0<qpjDh))?y!8CS^3K}EwA-JB>7>(tkh_(K@(8}-`kJUk%q+=V z`Op?6cpL-(1|p)StqR#-KK^H7m+`D_#Ml?TX0nR_#7-q5qNQYzNB}^97*oRl;4_nC ziBcvQ&}EilAZ7z*VnDVCNhdmuTy|#T37Rr4u$D+sWlXL>%ux-*A+fb&J~IiBs|d1~ zB4P$D)k`%dQ$b=<2vH|7EFdLSQ;CsLqM{7yrr+&bzw%M-Xi^hkQtU8AbdI0`IWPn8 znTwN|#>56-mJjW~F(NUw zZv+G*Fa=6U000Tviv<9AM?lyftu4zbcdTlnqUZ&H8B`Mjgg65*6$J7r)CN(_NCb%; zGkPC1B-Jd>5KK~1QJ-aMIvb6M95EY6#}lI)Ps2mm{qbMNwxL>x*j6Ny$+RqsPN%A>$~SI2o**GJU%7JAc~@0s zk>z=rWx4NmJ6UJB)9+)(P>VzEbvjE+OItfTx9;3dDb8lQ!{H!=G@VXnb!b8pYmFhq z6hjl6Cd3par6dwUFf)<4#5ScALTp{TWm!~JnPpk#GRN-laIm?(RTRa_%1XD>@t#8r zhev~^X-=Lz)#-LJpE>8V!Y?fM7yA7a9!@P7LkdxfqMQW{K`cg5tq_nyG}Zd}qo_$Pn3b#OH37kh{ME`&-ZvbvTbVy80^St~N`WE&SZxG3-4*;SP!T7}6FHk>UJGCGi{c04pH~0A7)*$mC^WpUBY@q|(<-sT+W2EO^y;&en zlk85C!L0AHgaD=veKnhE<`ZEwMum0POO4~vb`?blB+Y35aC?2@RF=PT{pQB*mYnZoK%1&Iu=Ac*uRU}9I z1OZTw%XI)E%-dv61T|x(Iz>=rBrftet5Zzqa!n1W5IcN zRnSzZgjtF?X2z&7Xd<=1kXs~~qF6LnNGK2&O%0+FcF;VCnA4VYlOz;bWdUL{Xv~qz z8qfl;04xk5fB^@CzOhCigp6?#o7~J2i8CgzW}L!wHeDL9sx?gAZl*~*fI1{2V#XL- z{(TMrh?4Q7NjVcR?nP;Y^&x4;RITOkV^&gLLNjIW4M0UwQbbS{=h2KL3L*khGEqVT zaDd(nh*iWP0w^NZf= zg<{A&CQ+do#Aj8LTuY4h!A6}>v}jGWm#61MV{xG_hnhMC**W8ZO_KG0ZGKf z+(vX9W3sr7EfW<4jWLO~<&KI-YsUbCw)Y{T))sTBZ50w@3{8kBnHe)zRoUrO-uW!| zXt2Gry}P^L=~T-rE4^+f%X3p23=U_r>8X<^`~6;)WzJ{LXWfNf+36@iRhAEB{|!Jy zCevBBQ^lBKjQy&NoFJqxJp0AL;9y43F+8!{8}5yE9_)86tlYY{Rl72r?kgb0*xlaD z(0mhSRb`XWV7Q_P`@6$1X^0R3WRB%S5mCf+G`;<~tJV5~Wh4q=Qcq^JPGg$PY-8P) z76RxbE34(jOXJz@;ciohcdYbxd}gFs(Zk0dZFUcu?M-mZWj;K6M$NJ>8iJEUSb; zxN}B)E?i@74#v$a%*HUTZ$G&I=*5efclK9G5rF@L40zr$F*QX4Gf-%$N~GG-&jpV) z5D#NfQ5H)p_W0v(og5wQ-rj1)jlZC_A(NdEdh=>o@;0%0Tthz&XWOr?k0-ssR&oC= z`PVPH4GV~=eWhTc0P_Y9yw(B%`0@+>a>)f>{*GfqbK467VgN-1K+dQt~)k zeEQ1u7hb;krL8-6!|7Q%lg7(~z3%?4?$t-~i;rb*Td~v7m?=1B4QdFe0E7bC;>6K_ ziQ(8#-By5LGH+9<`7D3K6YpAFIrZW*AARB3XD_}Xo;Y==l8Wlji)v@%^xKzKzjJi- zzPmS`y?O1^ozA_5g~NyR2)@Gl+Ned2jWlh$4DB_OF8}~Lhn^g}0N{v4QX8c}%$d(c zR3yal)VYiREhQ*22m;74PT4s~xk)gC0Fvc7t4R!qMuv$6YH{8vnhJ4QnMCenT2HKQ zFv}n%AZLOi4Ukr0TCcF0!k8MB6bF-DvVY-2%^Z?MmC6Aog~kw!vv}#6wn+1 zqY|PRs8Uk%&N3oq0?{PmnZy9i9CJH&RW)GOo*<&8Ny#A*nTm-3v#9`pV-{64Wndy= zM0TzbX_Dkb2ug^KS=2&Qc9Q2j)Z7R&O;JVE%z%hYjR1*^2n<>_WlAY!d1i<{%K*T@ zLQF})nr0R;gooo~VxKv7*aYq9v(S_?cE#fLci(&mc*T>o_yQc)2Bc3JHIp7 zKf)7~7akE04-WtEkN)7#|KiWT>jU5Mw}0RV-}Tf}Z+Y~QE4OZb@s+Eqckis-c`(@9 zJvtl=2E*}Wl42Aw)g&S@#@TGf%FUZ4Bj4iUwN)E6lVUliGN(oCnb!e@?%88XZ6Tz%>0 zwHs8YvQwR2TUwm_@9e$VlU_%5Cw7+1yM1d_0Vou9f*_lly48!i)$F!Hnz1Ls)`UWS z7)RLQ@WYJ#;J?83f8j^}1+vE@Tej@>SQ=~8T3Rzyv$-_M<_3ZQL2R|xx7~X)^PJ;{ z{0d}yksef@7djshRfq!cA@99;&pE#>JP}#6t4H^{emaTcGUZ5UG~V2FNY(a5R~AJx zxc$cM&9aX3&d~al3S@_w;e@6}%%&+VWM#9^wiYFMnB2S`HfjIhP%dwWCwthn#ign~ zKK|KjZ|)tRT%AldH#Xn+PH zP(6OB_}=yEIZ6%#T2j%pb{hkR|647Br}l17=Rj-N_w;K303tQjEMZTbJvvNw5nZ*cdS@`Y!c=Qs5tMgV63s9;D)K!~WS zfFSF*5<|;Iv1(@76xS3?#UWq3{Oow+Kl$*j8y~&<=d+_H*PcC|Zp1-+r>GweN5AIF zUl~mP{%ZN12cN!s_s*XK?EXJ*>zS^vL@i=qnnMu)(0=Lu)*P1P$gv|p@4Z8^EnB^Dt@AdZq8dUg$96o6z%eUGMqOd(>4NCcjQ!Z0}rDDJlTPK2}7X7#Mi55QUsmg-(=^J2E(kdPG) zO2*Q;7*#bff~f)^Qx?~OsDW9Lk6^*B zFC_r{N~2SfA*jLlb2t3>G%KOf5@iY zbyJ+2%=$k5-hcP||I3g5=m+2bwg2cp{P%C%I9G4~`rVzK&vxz~9PI7gdoVjZUM-i) z#d5J+c5N5BRzyT3B?%$6ZHI);v2)IO=ba~F=NJ(XDG#5Vb9ppk_LTbwzcj@^Z6PwK zDxxZxvm#H)D~L26kC>U+F*|lHNjN!~9UdNo!E`#^*q9CnL+=YwSuR$q)oS~~)@U>; z3SSn!8q`%&)Juk4(s=~S3{v!R|wsZhyB1BkoeSUG&+tTf?s9z{jVC^H;lxYTl5B0|eM(c!|J?e1 zRn7b|z%OVex;B5y;lMcp!w}b18UixmbUOL=H@^GA&6nDv-NXVs+YF(ToEe}I(;(M1RbQcfrObUsHr+6Q_JyM zgq&NAN?co9|qVlS!2HXJ!3yQ-903=c`wKu(|y;_^*F* zCRgEaUSEk?1Pti(i>D_Xtj+U86dZ9FojR8#0AA^S;DCId-vs*OacycbI#$xGx#utC{sSDHPXFRl%X zu!!ZTFygQZDagR8#YsCIHkeX0HMJ<})d;K*O9+)Kj?Yj>vldfBLMARf`?9W6iXvi} zT&!Tm26}3@Y^v(m85*Dxs0kVpGCJo>K>-aYKYK~dfKZW=I07bgh~;Vi)Y{S2%nV5} zMPYVG$e2CXfE^_^`c(}DWos2iCK?4Tg`qf_ru#Z0Y#h?Dgp8-Hw)XUW>^!;kp z{_{Wjm;cAV{PUMydg1%O{{4UF@BQFcb~g5B_TkPa2T%4se{lck@UU&$6l1^YGIg}= zyAVQ((Ny~o`#$1nWIQv|>B>|)BFqWtdFM~vw%2n_Rn175YL*Nr0Guiqu&xJHRS}W* z-prUtG%XhMqob46s&$SxH#avox0*r2gdwEGa@qI&h4be|)u3`a+g)z<+b%6KY#}=$Dj29@&R%|cRz9t(ax8gQ2 zG^?GTPEB$O3}h%6R1uL8aWvZal^4JB+_SHI_Sv0ZeE73Z-gtj;Zl12iPqvQtFC5(& z+`Zr~oO3&uiW?)H7FJ@+UgD^rV8*~kdAGq}-CRRv;Gga)5?#9f!gTB6z1weo^v?f& z^yJaCo8jE~wi&F7!IQfF#K&LjhZ|>e3I4YAm8eCY+R)^0*F9EtsWUSH$IdZ_bp{a< zvq(}?H6dalPp$$@szLyWEGYpwGG$kYB@id-)mA7G%fd$#No2qr5RDZGkei`-=lm#k zGhTHBF-eTwLLIPYG?X+m8JH$XSRfJ^0;RA@Q3|dYNL9KNie%;_A{n|!sqa!ER{{jF zp>jkbLj$Y8(rn%tm}dsQve}&M?~R>rPrNpzwow&?$@+9)tDWhvZ3C%Rh0}brM=@}t z(cp2vI+IIar%Yip11ijw2^bJvQDW>xjM3$hgR14ZA{a1bUa2xA1YjmLO9G0J5Q1uP zO4V|NYoi#Xm_z}{GyplmTyJpZb7h|ZGc#fQLYgN@z!MRvDj})?sv(jns41HeTUq+t zY=|fj#gNI%>*hvOQc`0u!UW`1ICX-Y01-04M2LCz<5fgdNXZOB5QO9%6QTmSLE$`` zfI!Sv`De2K%hhVJm`}&!5TjYu3hi{he?B#;@Lb zX>s}FYcGB6@&5jkN00X(J({1K^lhI~Qm`Zv`d&r5u1hINN`2ppq*ED=e31$E)Jq$4 zeS(O@oX=1rqOvTBu9)imQ|K=s|P!MwpCnvC?wgac6r`=gT@#sR*V~ zNQsk+%Z=s=Zhij#r^hEJRZ%8WP|UDqeopdkgDEl{b^WH#cd(jd=IYaEp7oF@&xcN@BWAXi4HKQhI+#nes;Hj3 z_0sjLw;nyZ|L(`H-+t@8`Ea&({lW3Yy@#6*eDQAO23!8zj=Qp5Uf#kBjSY)bqC&Dj z;MYdsrUpi9mEn3@*M}{_U^sd48$Y~o>E`YC{`{Sv{_Nt_qs!N1V>71VFRI}|UEMsB zOYpa@uS6~Kzk)&YkoMR@y z5JK)Q^3O8SDG?nJ(6JQ``(8uJ1B*5M7D3p6$dEXR8X%$}phRN^0`+TJKO|Kq&b9?9 z2^uhSHb0SQpoXAHv~Yxgh8R^4(Pd*r6OjalX266CPSJF}T0yeC{k_p}m||Kk+J3rv_+T{|j|YPRdH(jdzx~Q9ue|oJUi-s;{)Zp@ z;)CH}6k=S==O?q{latxO;nDy2KmXAm{^(COrqi3xUjN~%|JJkDzP3HwEWi1!+k5x- zAMY*?ju(gX(6uQ=HOnk%%_>LLlv3841DHrkDQ3eT=a>i`yF4jDqR@wwr0v?(a@BTS z*YyC{Gd z_OmiKihru{*`Bz+n2kI>D=J{nOuUub$umjkuLyefPCKNxI+NTR=$Jr zAeoZ$KtTz)DpK2Ly%d-+vyn568RAqGWQu)TWE7BDV^8eV(D@?vJrP?~OG;iftvYUo zrb*>Q(g?wmvZye)!RB>Jy+WX(CMh+dSPHFH>QxePsS-ii8G%{Kd2Uf07cHuUgqA=U zSIeTQ%oQ3_n)hi#y&$BN`Wd$o6jx>#`glC&q)lCN+uN#jebi--oHV4%cO)!0_-S`YxW7|k;=7kxiR1a=63j@e8R#l!%S z83=&DO79S|XB04@nME;=1|mRcVvOntO--{oh?xO+Mg&rWAV6P`-ZQ0CMU#Qc;7*2g zO^t||kr^`EgNQ+mJOcn22>K*KXljP007S&ZHXb+=O-b1i1B95Ib4jd^X2_r#VpIiD zAcu|_2osu+!z3DIWmp1eFtIS}&ZZVAtFjq1nq)p-bY0ujbu$>Q`mjpv;%MO=9nWS} zS$**SjM?p+->QeBol6&)h>2c(_50ud!LPsl^Pm6dM?ZS~^`FKV#xOL~vM83zRoitZ zv-uluyz{fy-zMhGt<5V}u54U5f8)k8=dL^hJ4Q&$!dkx9rI{MQzd(_cW zI+1~e5GAD;V;{ot@kxqt)vmI{I!oTpof{WL5kdk0GZKjapekKVUDx$}4}gRWj8$Du zCX?Y{;Jr^NbzSO1KWOUB&58HEC`w=WW<0K{K~eguEJKXUETWdg04v}#l9a;nY(5w? zpjH({h&tr*(|dR0@#^P)@y=@Oe(Srp9_^m&-ruc<{;*9{6)_|qRc1>kW@ZQq2rfh_ ztI4frLe0NNEyuHy@6#a19t4W>eXqN*;2Q;v2MZtOyxet%cdGjXE~eaU zm0K6w)l2^R7F=j-gppB|C{q(CC-7woIe=PHB0{dWufDu>@!8$`AKm@VjMVn9$LRuWJs zl+hH3B=qDw0D}!B9)V?gLz_dgg)v%mNV-(Bm8e-4QP8aDmj`9ppdl*@BmeR6VG+X~oJOE6mn?iOfJ+Q%UODio6<3nqt|;Vii&d+L~98dD|^RYKl=^x;{de zhU13jUFAxfBsrQd=7EO8B;t*%HAC(DSkvc!CDU0skORP%ps_4H1XpoADos+i z(v;fON@8T^*!dVbKvq$JoE9WR1PJRiT}A{YHd)hvkk)5hrjb*Y$pHe80aDVWf{v5{ zy{8ye)x?Ym7*SP{C=)0`O0n>si2x87MRGKNqG1l{V&{+y6p#?O0P<x6@kLDN*44LF$GgYOpq+L9aEt~C#}sTUYxLl#NIc}*?5rq!Xe?R zTMe4VF=T|%dskY4qtSy$Ps*ykhq44SH1w(W2vh@9i9EZ7xHSQJS_x=dFP4WZA8 zIm}K~0cVHbMuoMYFv zJ)%c8@!`Ag>*E8- zv8$R5vc!pLg>f(h!=5m?l1KIBZ#)ZwLewS*h>((|Wh;^_fe_fEy>xgK&~#_JV;8{` zj1P~hS$k*iaI~>KeE!zY4vuS!<7U_;5I`}tqq#C602*mZ&J`=~EcKTk9c}C$?N4eX zH#s;6b#-{@%9B!c>2&{r=|BbgB*U`S*=+CVxET*E!!MWz5B5vr4}%<^l7;PSwkoYd z@*vkMXP1ZtVC%%)oXlsc2AB^FLRBNCTpSb98X7`Euyb1%U;T~0f9;uDZ@=}^J8%3V zK5o0`+lS{L_8aZqX!phPo6puS3~^#&5DmeMNY&6X28^eCk$e#|$;l)ocKJqywb1ue zV}#lI^7J>e;E!kx*@!7KU%T?`*5v#fZ@u=Dcm8B~a-_GGbgr}tLeQ>Hb6oE8(P#e2 zpt?KpZ*Nsw+q8Y9ynfy;)jGmRWRNT(uqmCQV}O8WDyrT!mv4Oi!sT20kM2FX|JJ=b zuLFF3c30v5b$umj5i=A0l7P_QRNk8>B%mS%J0fzvFp{FGr0p@rwcVH*vj;*=mcd1p z1fr&rQb*3KL{KFWQ}hIcL;;;E0Fqe(wA6Q4mOx0WR7OLv6nZo&ipo?`4b(t-0Ms?>we zTO7}nXfkcu`3hW|oZBp-MYOQ$>dJXT0YfzeWW#n)b_H2`W|!dfDaBtS3(@D9z45j-OrDi|XtrmW z7*knr>A8!^OwrI0J7yIn50X7?5Q>s>A~};oGsy*zkN@#ce)2C~`|CH~eDlq^s$+_))hdKo*Hs8%xmW>OQ50oasOWMrn`L(p zL=ky#Abrz7Kt$m}%$Yg~6clzHsd7!H`{176Xo{NQRa9K?!EdltK&$NS>i| zA)L)zs*Ry+nANH2plS|2`sDD@5g?k{CcBfp+41gUs`xmBVmRtCXkDh-7i~yHn8P8_ z7+vanJ3LI)Hm*WCI+$F)8VYB<5VXQAC#EQjN9zbJe6`2PK?mo6p%%4#t*Fw7Rx0Dw;kssP#W@RYR* zK#GvPf_^#C=I^jFB#(fWiN0T|58x?zR!*%{QSs@71d-5{j&I(4{^IuK4?le7&39kh zd+m|k(!*;<%gwOdTxl@!sccY9RhhYN>VrLDqQ2`KJEMq(hDeB#BA~IaK@E~+A%K!l zQbHzjYNjb*49*W#=8B1VXk9Ci(4%q^Mu;LyDV=Yn^Cdc80&$GN^(ww~z$SuRyL!aK zVTe7bpc=TkCJ!KzdQdV#OFi|jENeAmqKbGG6L9dUY)r%PvU0v%#w4by^P`2oFdCYz zLa-1#;Ii-FXz3<{q7z+ zD+d$;NM961qUg*_jT{%14jX@b12K$4e~4P{_Q zV3^b9f|&s%m0>|-000GpW3+5-KrUn328u|`4zkY5wDdltBvBma$uVk7AqYFlfG{%| z8X=`*pcX>P37rg-6ryS2m|Z5@qp1KR6EScIT{LM!0^|Z=qw*Fx3Uv@gEu2wKFA+KC z5Fw>h4aZ_}Yilz`L~AwiUCSRWo8&E~UVGbua` zN5ie@=I{LWfA9}~`ycJ@?*8Ka_uqQ+%{Sh9bmY@7z#Iok$Q?K(su^XG);^V%m}dU z`xN4t>_4ahnyMr-VL870Fhr>xpELNKfB21?-~H{$^s|5V-~6*T-ui4WM&hz*2KBeE zp4|P^b`M}QNbL%fA+iTt-TSQRLwj%pXgnMow#gwDZ3xSyC0RV&!+D!q?5HZG^-RzO zI^36mXXirIRVTqjFJ3%1bJfKce&znZ{>dtYdFX|KcDB;Jhp@E~KE2J|Ze3rvbdWs6 zL@+t-LktYezG8BMmO%4iSeZ4G&Ds26xuE$Z)wgcx`=9PVe!S?qnraV#WZA~<3)M`v z-x49B%=jdtQ!Z!5By24?Ih$qKLo(CP;fwC*X{nHZ6NuL^M#fjxsviI{8V<(a{N@j? zT)p-78~^J4_upFXE&E%mC#%o8t=Vd0dCR?cy?LSO2M`s~S{if;1oM{)k~KvavqJ1? zoDF7J>I>l6q!@&L^P0jPnf zkw8po(Z~66@x<-jsqRe6$%S(JhI{rBUz?NLpFvwwTj8n17-%&5|MO_hZk>`v z)*``E{{n$i*_DYUH0QkZLDi5+L^7d7)c{3F0UTnDC~6Bc6$gcS2%17?mOzC7K$LKp z^h8kzP(_SMqbU`(h?LOPr~+IS$s-1VKp3?w%zVlop1@U#0YKReEVdpBBMIG-)QCN- zDd?(Mf=WD#q4H&NMbB=Tl3(z!I$INOfW&lun&WN!B8dyq+ z5Xt!vl>vxJOhF)12Z)gnB?mo#WXm!Y&8Tw{UH4XqMC{lTt@F~wOhgGGiB)A8MNtiq znb8D8ACOrAqX2>y%xgE=V zbk`vo=*`O)U-{whmXqmx?~TttIi4La(e&`(!N#>4{dnNcpLf30tqqsb^23j%OPBzF zsA)zUo6VqFmW3vDeK>sYwp(@xNKrHgJc40U6wh6ws+!N{@y@5^-G@4=9Tv_~F_}L1 zgYSRd_wU{PtdHD>B%Z4mZpP(8$?(G14NJPXEkz~q!TE>#6bOwXIRH$cngRn}{dBLq zv^p7$=Vi4o$(nL|9+ojI>t?hyvAg$Ii-oUBhXl0tx3&S-;1YqI|7j}O0@BQ|(pMC9TZ~f%{ z>vzL5-Qo4UW!s&cJ9yGOe7^YlHecnAK#c_L^jKo#r@4T68j?>iIE85}qs(TsR&(aS zJ6(%`pMDrvx6wponh;@g^ZY;fw}0pI&#(T)+kbp=a^#;Wa0}I|0Wpv{bLQxA=(^sf zb~Kuul=Fw>!`sD2=gRXh48C?rpFOXaeJC6hhBpy^)y$ctQ0Lfx)EHB!~o-yY@;23>HWh&CnD9(JX}( zyAq5vp(vJUjtv|DC;@3J5*;NY-z)mGB5(`xTr?vCOKs$G=cPP+001BWNkl# zdq}K|6#-yELX-?CnRsGVVI?z#KBgl1ga_@sE(;P%Q7oDDY4zx+EQ-=O0TZxA2&4(y zpjE}}y(4YoQk0@BByLg#0DZ7}XS`%+q&UFknOp)iTgPNQb+F22W?Z7L(JdIv%v(wZ z20)@hjFuq8L`1}t>21sm07=ad9cIFr5q*)Dz1Bw|CbKLR%+xR@bil#XR7ETicqYVk z3t(U>vYwSOS^k@!64?wSsbkJIB&r}{o)`&Y&J%WM2qus+wZ$xn#uS-2^W~BxLWck` z3U~w{Lxvm$42FQ7n6dy0tso@;2fsAk{k!fzGZMPO4TnPm=$FUNFROZ54;up*bltS? z>#DkW?Rp==?*2Zg^li(`ee74e?aBP)XgKohFI+gszI=ag@3|W{Cc|ML10y--Q;It~ z*RNi@$=LUD68iR|Pj276cfV^>ANmhJzWaFhNw?~VyQ1(ZO3HF-G!-SHEU|Hpz4J)O zM5>l3Az@0A{b_UJovlxEFf(RUHAzB*lgYSghR%8C*bG*yE+v^v#v2>6NkRaLy6BgTxG~*Wb!`$zayGuJeIJ`pO$G%yw+j8i-ibpb z!m1u9Q~(G6`p0jd+dB8zgQK|_k4JsqIvvx6^Gh`mwGb>z+6eshOL*}@B5VO#Ffh<0 zzKbfBi)b{;nhn0Xy_k+?j~`pr$jzJXz1yRsplP?XZgX^o4$=~0}W zZ!bZHuj#+ZQb?RUyW`wAxED8X~hG&#rF>p;HIg|Z|?BVf+pT}BA znR6g)jilh|TOZfYzN#T)0-C91qYeZti|UzMFJ8EG_5F9>eCNa0_jez5&(H5KRwoyZ zj;BXg`R4P@%fql~Q9%uv)?L`CMkbft_|zdSi)c=Pq@0qPLwSA)M|v8=dn(LbyYVR2 z<=|Vt_WkoaJAe7wpM3iB_uX?K+n|jiAt7z>`1@CXc<{-Sk3M?$xIB^b5;pL-jzeFzuJdnVeI;rUcv^kfnjw<0ne4)ut(5AzBG1lz z484lv#{dbz(8N43v1$sYf`}6Pdh(O6At?E*w$ zMhGIIBO?+gmGviwP-3|`G$Bi!3i!>DNo#7TDng`|=Re1OD^W(o)d zif1(zF_R=_RyGwPI)@T;wp{g{jYnhht}4oy(#B+9y5Cg&@oY)dbbZ*^+-z4XF@5m( zAt>Cte{VY3V8`RZ;P#z6=Qby1+LWWo)?_|g44Z+c)qM3BabsuuYhSzd9p`+ALB&Lm zRlCJO?gRi+N?*QZa9xsO z2ob=V!C*KX)K$go%`C*&_kCFumoIM*27_iaVCRV)5G*WKgQkyNUAfX#2G*H$(sxn1 z6v?~7b5@xgFJ}z7A3dA7U|AH$^A>qk6xHhX#}U*!BF{(5#oIsrz_uayaSs9{V7M29uGyaiem4@bPV&cRX(J(srmycWno5-#1V& zI>j|?<@}K-@6Gz|GkW1=-JGUQbZ7J8H@sWK)Wp-Ab`MUa1VdC|{u8^PDr^y3rP~z#A1ekTj zkOR717Ji*tiQupvfBV}%xN-gYpT7MU@4x+Kf7l-{_m^9X*@fff@Z^Sne%oK8mRJFa zQqrfAX3(_>IIZb2c|M|$iDXEpFDWDDF9ykY8pwgCJ7>9!F$6^5YgeBA-K|S+yz!IQ zKlt(Da8ciMaiT^hwH=*1dF9ggzBzmK^ShsXaQEkr9z0xZ&F#F+hHXsOFADRW>VfH~F~*f|I}QPc#b1ErO7 zO&6VNHzNX-g&&N|=_Tj_0Ei?uXDaMVO%VVQPzpElWp}hps-(8)gQ`_TF~tO>15UZy zQ0vTwRS`n+b-76DMujc3B4$G}Gr~-U=e0j084`w+ymNUPtES1s5fh=QIz}~QLX@*Q3XF)=G#@a& z^k&WGRvFtwL@7m^jF#G3; zuA5A!OYMhffA!AC&9L^Wg`+Fu!6$FOe5B??kFZ7l@5;aXdV}>d-1t=VbeX@*W;Oi!CEm5{oOklcchzD2gm9Dg9>f< z!i~{4e)W&vc=O7toeg1+V3tDAI3Q2N(5{r&^%0WwfJNvc>Z&A@2!;Tp-d5vt_pXe( zs_GGlvE7;MUl>Iuh^@znS{>TKxF5~kg{rDfj!!~}t|Ao8Dtac$c*$uivX<8>D5z1M zL1gM`9v_^^?!)@j$=>t%5IX$;*>?@sR(q$jll({45fFJ?p^|AXUjQg(&XpIoFaLwz z`rTWfyztlW{N&-@r|DLBu(~tf-ap)Ua*dvSX7KW)KZh}=?yN^ac4{;tBKRfed-y^C zyoQAE%cVe;=D?Q#$~CD25r6>!p{bi!U;V8cS8o3KPye^OZ-4A=qV3=u58sB@cQ+s3 znmqr)*I#+zxo_|7J^u8w4{m?*-htZ<=fiU2xNB$o<--rE51y-^`?~+$cDyP~loT=3 zp#M#*uS6|k`Tb!z;l%JXa}~uh2fQ3gn*rP^HuZ)PGI zk{B@|#MB!wmjz@%IU9gzR^Wjdcw$fi1Xoagff+(bi2&F;RaLc^6dh$Sod6KYz!cfc zf~qJm;rekmgSEnDt=-5JTJVHsjL1x2kVMyoiyEK-VoGS1ydywLB7B;{fdHDhWchGa z^94I5BFbi8u)d?LaE_RgXcA?^ct*7dG3F2)08=p}D(ejubx!-X8;yo$WB_~nCrw$m ztE16q;LFK$WAotfNF;5Hr^Iw{a0rA&S?o01v-!-in=R%K9zC2d767)tx2Gb^ylPjb z5K}ON(61KrrD#s4iP;bSRR5xxf|{pFIYKbk9Qmj5)GeEc3h&Wp%7_rra5$>Us;=v@ zEQmXua0fS+2eoG%df=}-O@xqkA%E>6*e^~VD_ZD{H$hObLQHh5Mke+fLS-iUP z;OZ5cjH~k(IoV)q`{>~CVrlcbxjVen?j7RE$)u=!`G2zaCOx)g*O}OA_THztUG%Tb z*CaEUY(z3yVyP&~Qn^&H1e7%>*q(SKz%z~YBMAKgO$^vm6<|o37%G=tkX0(GN+P99 zQWP_p$z(RKe=oXwYjt4GD-;fowU2Gma_@);q>tQ}hKn&&CtQR9V!pnw1iYFbVkR zO#49!kA@ybz!c1Y(9E`BKO=iXAt!kQ66qL~aAm%$;}{_`$MgK-W$}@#0Ug2GyiYM_ z4`0G8^c{~AF>CkLwrQ7Y;++5d7rt`+=G`Cs@O$6?(RVg4F3vu8y57H7T|ZsUj$bXm zdc)oIT>#C$WbR1?5Dk#bM(xa~>J&uU8h`_U!lgr6CIDo?@aV~gBfMqXym3S_zI*Sr z|Nh$l^!8hS`Q7*b{rSl$+?P#Sf7Jiv+3fL$^PhZa^0n8hFTQf~-ap!W>+yq+-hKGi zCr>|U_L_cweKKjzyOU2QAAYU;`WyC-XKqf$FUzC<#OpIri@>FR=5qLD29m=9^4PSQ{(I9nnjJJx<6q=+#aN5ljLv9dq}7lOn=Qi@>0q>1yL5&Ml}4@P;y9wj1>ccdbz z-%yE^c~b-+(YEtC90aU$>>O024Cs)_B%&-Jq1r$LNONISxN>TPNz3;S9gl>#qyR<^NL3I4C6AhOP$vOEN+}1hXi`7}H9$}`KyXB; zCNUymMhXDw)4ckhXG!d_nj)blK|)g%MHP)PK791}`HSblyUnIMyf&9%vuWZ-51zLD zqvIE+`@6gI*WN zTFPU=Ja^X|ai^MTTe%#`q}2R)=0eap&YJ2ZVkvna=JQ!ql|?8eEzp-2d26(&^`Ww01w*%P@mq;%ts+q68yV$j|5wMPT;rcsbBsau`nWLKf5 z5VUW1BC|`aD~c%7O?%ffFW>sJAOGO(?v-9|r3>wU+H}vS zPd}Kx^9$kYcin4WsK55w-7ha!XFqxL!ykYAgJb_F9`(nI$KR=6d^~&qANl|KwtXJ> zzwkw_ZskqR)Br8-e`Mp3PGw}oDL{^^FfiwxI;X1ae3InM^?S zm>M_?NT`ZtVrI#DMl%B>hKx-jsteE$j0C6zXlh6fRZ$5=%@mEu4A70U$)t`-=o{Vi z76m;pIZM)CoPmI#PY@Y+FulIm^UilePt44|o=ys+=cmiU`NH|qaa|XVNZ5IzGK8*= zg%7Hxo~f5)z*Xp@)!q%IZye)%Zs@=efdH;ZM`I&t2XH$f9SL38+XoaFLgl0{@-vDU zQz{GZ7zh=akqH4r%)l;l>%c%%iAcc`K#siRG35f7-7rK$111C@A~8b%MO;IHGYHWvc^JW&>nXRHPv@T#-!GvRiyI$82DZ2{NuXveL{9MTEeNvq?Qe zCWGi!hMfCYg`}GKF<=gH+mqAPG$lIPTPHy6o3vbCJbL{2`1$i6{N3Na_4eDtFo;N1 zl)iA+j;3wbUtDa?&R6ZGugc<;yY~Ry*~v-Ub{7|`&1Riq>iRy$oNFja5+Y_DuU%GG z`Lf$({c+g^jKxPjs+SC|JVhsR%+5RSJrSyyiXvmSd#}nmgu;18NNSc+GJv|C>@0T6 zx~PC}?H<kS{T(JGh6$%DoYF1ShD8z0swE%p6ayF}{LeT7X zlj2qJ6_QF5hn9#>PS02C9am4*!^scdIsLmI|73X_cIm{?Q}>Af=56vNH$CK88~}DnRCyR|F|muzG$*cbD$A(W_8qJJ)-QeQ z)+_h^=l|t@El!@Fy+D8O74KZtbgppHCDTL(X5yc}=nr=jxyi`|nRvi4jt~sZgrsbB z|D->kr1s*OBs%weBklN$vPk}9cWwqZpSpI~tPZ<7_3Yd|ZO+g2`XQT{C_vWAQx@xH zHAyx*wahLx$P}S`FECx7T?{kkM@s#{mtfEkDq_?-lMl4ym}a24AT(9?dhA0!`C-@6h=|k}yE&DR|wf$=uZz!$^4|GJ>_Z-GFSQ?0^A9 zS8$k+X+e~RAteD7?>MtIVoXJF0APms^_GXMoKv|CF&hJb#q6()WTqiFNhx#9F8!1Y zDXB^pbt900BQ!unQdLnK%m9^1|tDMAWxi5`>K2;Ghz3fcG-(FF2L zBnMKBzqJTCm!%{sniIzmL6H!^)R-|3jIT<^L0qWmhwuOGd+-1B!Gp7R-+%APlSii~ zCqv(hs%>FxBK+hdLnM)uZA@27Jw858q9QWHm|~R7bV?~D$#1HZ(w5PopPFst@?$JQ z0AO4H!{z$`Mk^;`cFg3xBjih#IU?7SqAZJ|D4AVVmd-g*6@ej%4}LLU?Cc&*Cmskr z`-+^Pom=mB9OL@NVgiO1gGO!puBxYD;zUyHV`Xe$s!)eHB!i?W4W;voFi%55cE{bt zV2PRdiU!n02xZ|V%JRi2cfu14$deGBtT(#{lY=|%ylKzY-O2fdwJjk|3N#-&_CQ|S zHI;QJ%VshOw{Fqt-|?nJVPHc;^1C}1tNBG(9<6Ay8@$)1$?g5P2~$Q`b66~m zaopQN1OZGzAMaS#IV(tI^X`oY$fWc+P1VGa@0jF1r-=n{R(FB2uC;N2HK{|m3&x%b|W|L(01 z{^G@h$9iAl(fYac%kKPf{mK3E^*7zO_R>L77q8v@!fUU*ake^naPr}Y58gWQ4}W;; z-#-iQU(Gf6S?e=VivVW9Ofp4OVFSJF$UYTIO$^1P!qqtvGjl&8nn;KRyEYC3D45bX zZ_j{VLRXk>3<0HP?$CgIZK-EfL?r-cY(t_rfBc7kwA@_0``-7@&z5JW%dTrv(v&nM zG1Vv$RLp<~nVFd2rA-s`L+txLKQBW}rkXSDL?q>sWYoOqcy>mT^8d?=B=4tgiw@)V@J%x5Sw;LNy@4?x^}p`zjt_eWM)NCsK~`?HITBm zG~jBr+M6#-69GBZNzS8*iJ6=WDMpb9h$#sIX8*CSYwEJjS1a}Ey!XBkk>QHG&KyEu z$HV3a4~^4ktFShRM*XH zHm^!ru0=c#>AL;;SGuCmz`MuKC(qWMS<+NKcsyyFi=9$rXtVPmGB75EV8-Uwa?xPHv2~rX zFHX`1RhJJ}cyl+=&=tjWwVA#1ljYHMhtv(jHgRrj@f9*T1Pp-3v4dUOlNyWzlq?;& zD&pj*q}44bGvXOpUzUi8iA@y^;~ek7TK}U8*%&Dt+PFnv#b*~*xSGM z&wu^5?tlE+cfbGVk54{nUtNB*-mH#RXYAsf9W@^_Xz8nK*Ylb3DF zA$<99#$wR6B$822ftSx5!uI$P8F*UHzW&v3e(u#TzW>u7{@sUv{p{hRbZ6-InrB^m zHaUJ!{q&9S>W(2Uw1?XO+YdKt_zyfYrod5WN6EjcW&HCIBOAoXcQc z8ruT|BLadrG>!|h4ge*>uv)3BASqEL&47FJd{3JuMOOBPkjwBK&L2LQJYw5H~T^&JT_qvp8SeSgcL2D23zY zLdfA*Xb40oqIo+QHz5Os>;Xe97eF!i6oA=5R!ek#R^MVu-+$g~ebtTGHmP zB4$-k6DDV-V-zX!$gjmQBAtkkz&V$v#W4vW5&;o8B101c1rk6uL_>kA>C6A%fBRRe zlHwo|QxY|8+rIB(+qPZTrxZm}-lmzEnM3g2JLjAkh{(_nDWy#8lPwc9CAmxt$t_ym zAwTtFUs|MWVfeA!agMiT2|LH$`yvGIeJBd&f_Hx0>j_P@ZM&GHD2kgmZ_O5m)x@a| zv)Xy+s=72m3YGZ595HbZR!?^ci>~cFJC7tH%*@1+lB84?MHER%9Aj?@n7m`9ez0hL zYmyLfz*v@HFzNfN@!$ubD7J83mKPbL^TBx{5&gmUpO$+bJXfJOoX)zU?&Hv=2$O{k zonKcyX(N$_4f_Kj=%;mkx)w4Z6o_FEokJ;#001BWNkl~sHz*)YDh6v z&rc6t|NQ$8pM`qXJ^b+c;n9m5N7c2X(4NzLRy5rZN<}hXl(Z&N)f%Xqo-M0kX!aJT zRgr>6a2Um%yqI=z(XS7azUa=?piN5k#8%6_a>o$#!EwAlS?}&w7fooRoSwsC-V9Mq z0eK{68lWl?sTrh1KIDq`@;=FfGf~K1$Z}QORW&mmi;VF{j_g%c1%yn@+VVoisJzkA zV@&teEpLSKFG7UlTSN?)EFTWxi4Qky7TrA{^Ex}{HylH=6UmAeROiM z`}DMY{95(qUOdDImU4k3IMN9}Rl1qw~u!;gRb&L?j@c=SPgy^%e6G<$e9IsT~p@t4D!ulcV`(t^~v(%-oD z`t`&6C#R481pe)nT!nvleI{y=EoMCu=*Cfdl6-ra8K|L}nK|#B4{h9_XBv>buL0vQ zsF|;7iGyRWSRy&kZa8~^N?-|;kSat)a!HfK2FQZ*AWG~^MWZk>AtESwZyJFok%VH$ z)FV2gIu31ocEN^BEl@38bfHoiG&bg7NE?!gOpAa;TCb6a!PLv-U{=?4KP2ZpA@)Om zda>M@%@9fYVL+_FFWcTblR;uYBoYog)0)%_ZAhuA>a}U*{NSir)RXDlW$5%j;pMRH z|HlzR{s0lwAOW>p7{$VaGX@hd>$(BKm??{B05b7}KtUuSVBr{1GD;!}DoRL%ghY^2 zYZTOsOuTbopekcjFJjD3H<=s2YI-Wr7;h+>s|7(tu2PzL96LXvTmk$(H1X zm%CgRkB=Xkff+jnz$D2TZb!vq+hwN2h>+Q|h|H4rKDwGGbiG;{Xcn-f7>6M?P1`h0 z-w#Prrgw~@pR8>_BqVms%reeB48SNS7b807iV#wgBnbe=9QZ7S8MjN!{8MIPB6iMu zzpZs#E_9spOpHX{aZ!}a#Ox3`iL`CoZq_lS>11;4+O^4Sw%FUvQk>o0ebqF?6soxr zlmnzL@?c=5qEkO7K^kxo=9{LmD$lEunI*H$#cDd61AwFi2z|&V%R|pCW57t0P(%?w zBpi?ot1IFTXS|Lr()kJjz|qd_+xE&U>7$QRJKWwqd=7$Yr^heE1@^_o^1PZa;%3dM zFQ&7QC@xQ1lLRDXp(Y3pMEuQby{2&1aMPP59ftM6tT;Q*???o#yWxZPK78-PkHzGc zHNST6_S-jauE6lglbugKR1M9}j=J#t_EEK77j26J=w$EN&Bf`wY?+Ka5K5A?S%QU- z!tS!$AKX5a>hvMC%jZu4_-y?Is~W&$v)N21`^+pE^#<*lOkh?Rt-=f}i69~YCP|#< zWB_2GIXrKKNX9I%t2zIOIMxcItk<>z+M+CA`|7rlfCHx40P{c$zg#N6Dg<9v*dv&9 z37z0}9~hex8=s}j{9wSH`OdF?^Ed84dHp}W^?!f7d~b7q^TG9>oEGd~X zyZ5DM#}D6o{KF4F`0;Xj5)ax(^ADGk7a!K|eyRG!d-|m!P1!_{s%rO2F2T=SpNU#T z%}~|MShH{eM8V9NrA%qV5wQVwSk-0UH0T@@-oy~Wd9Oq%4FDk-s3TuZ`71k472?&TIjV-fFE8`*;wjP9C z2x@@B<^Y(K2@Q&><{~U*h^8yFGR8uo0Gt%1wY_$aP&ui*9qhD$+5D9Ydh;^7d`^)JZR;|Cm_1;|FN?(F${>Ie0nxdDl+;v{F_Gq6 zEB2;pmc10T7xK;lXr4qNpol1dfH(%l%pe9MOO_DXMj0*vk*Tnm0}@k1FttD~vlnG_ z2T=kA17<=-H6_C=(M1FVK{FI2W&i+9X6ACm14>L_kXZ*YB_cpstwMy(duATJ{M7)!IX?_T+qHTtBqT-X&N!o6;BL*gG#GNGOs3X=lD@<1)sG#4>>6 zvJ52|pmP>XO&L=kW0KUjv7Qv{eM;JOEdUQ)EIp_8YRu+(ZM!bf&^DV5qG?_J%5VMp z^*i^%_x_3q_h#jj;le-%i6YoEO;nj8xvGXuGrV{f3UBi{AbLaulHi@726r(Fc=Ofx z>_z$ECy*jMc;vtE`tozP!ui@0w-vttd-S*8?Vp{wYWmNA+)hzmz!>NWB=K`gBK9Nd6Q(;+K@~MNED?js>k!y>88CYYTUv_z;!b?nO z`^{=P{!;Pv zYx1feCj6hv?Cdj9i)1J*bCU5Tl&zy5ycxmhYia2!U55&I#DSWUVp5r7aYU2S`m{vAX;mK11r79)Pkv=<+a-@)@Gy4Xm_N$WwJm=Q z4P0XFGC|iYiF)rvqQ;~mr~reH}ldzT@Sn&lo0kqE&% zFMvZ*Fa=OTLnJlqC5`<_0w!VuL}N4}WX&TJL?JN_3Gk6#bQc14}p*vnTT@jFJ{S!BP}h~3Hf_fdRVAij zy=o5k4pfCXkR$eJU|7<6-52b+ss=N2+@lf^5~c(}C=FV$_ikz(ptF<&2qnd;tW-6G z;!4hcCxZ-wo-CiXD?_lt&0e|VuV26ajjx{lpZ^wB22=0DE7xv5J3cKjv}L(&8;LTg z`mP&HHnGF$+|8zz1{F2$%7dfMg`w-(o7cG;!h=V=T;aR#$*o%#H;+JNXxH%Q*%x~} zeDj~M=l0`|kE^n*<}j?govEp?cDu`yfp&X9m(tnw#e+MCYf@E!I2Z^a8=xk&gcxe% zATaB!`zWnq(mg9rU4PLJ6Lr_?{gq#)HZG3Ok8jN`KySL)q#@)nnb}}Fc*yFLkyErq zB1YRMrR`)cllkO|{B>}v!5w#;Pu=aBCES2Es(nYVj=b{h9JiFv5hWSH+pJ0$yPxdI zI+96=E}2ufg?8#`{Y!8D>Z`Xt|K0EZ*^l4){`&s%2b;ejG1MjUI9Z3q$I$g|1ZS3oo6T=Zum`PNtkz?g7SFFt?&&ClQc z>ZV;kJp162XYW3H{^8^OcblCjcP4MV?!W11dL@_OXRgmgErR1SfRr`8YFj9uNqK0h}eDHyYG2 zokl{!82RAY*8MSZ!d?Cs2()iQReaeh+=LnESJ{U3fk zruRO2)S1EY$$7in^i4yK)K>$u5P6$n*V&}zqD*C_DOH<|fhJ9@$9Qy@j!yv~9qfmX zpR%Uph-_Mx%tZG&MUUR;l=#eqbyetLKm6&Hz{MQv%Aot#fpQRtJq zM>?JH&{9$*Qe#4r*nudLL-4yxTTW+bJ~wtx`b}{4-Dc+u(;@K0`kAYv5%qNJ3$-+) z4Z;*OifS^=5l@+q%{j{fK-HMGM0o^L6H`P6w5(^5EAtom6#kNZ-?t*2kt+&$#)k%3 zC`)?@qobl}7VaY=0lA~2+yBi!{qOF4@Y?s@ z`?Hg?r_VMISBK}z{nL~3*}dZRgK)#gk|Lsl8B*5PC>UfH0LTszBb^p-v^#s*I$oyS zjH!O(lw=ePZ*@ABzn>u@Dk1?OET%h)={MfE`R2MiKVCoVE|$6(E@r25y+ZTte`tLs zY7yAhw4!$d`U#)eHsQN^6Zk!_GP&Um87wn&M5U}k#GKtS*ZZPziKe)z|hTpjp<<=92nq1f`H`2h3_XBq9}ok!z)wK0jN)hO()U z05@nD%EEc-`>tyoK#GHiiYNdwvuz3YrkW=%lv^P7h=QE!i_8`gBvi;M5H(;=ltk&$ zUJ*b{$5Adq_BaOsLiCJ?mZGVEF#szADAi%5t4N zS{V0VbS|MY6=z1K%t$WNb4es-GvA+o<<>68lBp(9%Y2Qz=Y|lb4F?(J7pp&z=Y?QY+`b#!#_;`kU1 z8MsTsrroIR8bDxr`%H!}=3_jcoYN$k8Yb{2IpsoR*;Ecl`w`WRDLmSCuo zDs$RPT&*Wzl6%m)sE(J%y$rrA)-o`0+cu)=T#(cw)6hrHzNo^G230MJqD{T?e!W=- zWT(`{zVty<%`}P*&Lmw8Ml(cV1?Y!!Xdhg^$yJEJfZ#my+@JpF9OiC1pKn%eA{d6I z8CqWKw5zk>#fcW7QVC}(S?qFb-NlOLQx7xyIqZeXYPDMJt$%&)INQt z`?5Z|)_e44XXT3*n8>d-RQRG<57;$+1{`jlpG;P#5AWS?!vtbyX*fD=&!@g|sM6H+ zPM^+E#ie0yGXVKPql2=U)Q@~~AKYuJB-FKG=b=jl;a=P9tRXd44Xy3eXxZHw#z$+b z9=A^kL)6Alu%zmkx7^apvB}k}>?4wQHq|_U*-HDilbCU2OWEsv1eb6ea)5z>qLSh^ z876=JvT3m~4z_y9yW~#)Toy8FdbKo$JChp?_0E~l^+$MqM zwlE*Osv&|Sx2O*mlY?vqiadF+%d+i~%9WuC31EClac_xQg$EG#y>sci)mQ?OI z^eLH<7QyfD%pPByFCwY+MOm&S6~qM4iaK&C)5zjKLeZpv0H3xPcIo8A|5#<^IKaaNd%Dp@3=DNGY%fv6LfiuH^g^ zjTo7#(Uwz_r7}cR*AwrZ555S6_wMP_rv()|yLNk(o?&(9Dc4&4x2M&AyDn#hoveglYWRUb+dnN(Fu zeOUo>eBM15$JJ!ENvU4U5Xq?k`mzYC^@S50+KZwryRIoh?HK1_Vy*>8ecyGCZ{E9i zzC1r}R-r2U7@3)!>)N&`ecKKxiT6d*wuH3qHcV88!6f=3sf8XwlcJhIOs-T8&T-YP zuVy1YnoY_GC#KQtJcMgR1kkmew+oN7Jl#yHx%M%s6*q4e2+fm+YCwRzw=dJlTBPbv zlUaE3w5V(P@|)*fC!l6#MXAr9^#=#t>#riy^oQ?+MiCGg%S|l0XS%c76V0AIUo5*J zFgua`dIgUJ6Wvei=x|bO0L(%(`UZWp(r8gP^^xU55r&sRGT%YvaP3} zruB4HmS?Ox4bqU#ow&;HW3{T_cv=UyrlA7zfF_o6SOD|Ocni+pwu6Ul9pESv!!NgD z*zVa^u(nVM5>ocQL>u9kOXkOjPF~JEwt^N!B$wqgW(r$s$XF2IXnP6(GzvBib6KBt z!1>>0&t>OaHhkV+9R1p_{ENFEy#D7u`jg}Hr^k1m9j}fj_4K33Pj-26H@tqk{M;TK z70JVZTk+>O%?AJ=KtmNB(Wh}(3!s@8pS8sbu+8ookun>HQ=_ZPc&0B;k=f`tfaDMi zfkm$-lIdrz&qOVfM#B}MoK3omRf;J)v7%$a-UUh#9e5df zNhwlvj=At!R&u@sKqFWABj!FZ6FX~%6kB!`qBo7m4#fz(fm3u2lAp}j1UfYoX%_LoIbD_SEsU-nTUjCi0%yY&)uJdSlW7q` zSr&`=;`H>)5L^iCeVSn@vn#k-azGynDC~5*Fr@C+sLHlO& z-T(bhUVLE@uI(gL*Mqqy~||Kg2sr%F>8P*n_#M(oG7h0a(sWwR_q z0@Q86M`M} zu6kG2Od;A3C7BBtsjU5^C{pamaUd?4yJ+e{@BG<%16)p%B+-s6suerafk>lj?c>dT zR~EUr|NH07t|~G*ah)II8bULf5(mUrvar5RYAAb13`Pmr&mPK%cMOh#KGb2$| zRo?rYAY*C|A3v(9Iwq~EYPG)DUF@`NYY5RKiN+KiyHFHWRWIg?&1QokOhb`WG{s3Z z>HGfh;INC!!Xu(xY*rzJ+J~5iu5UMO;~WFHY!_2cCO%r%cC%@XBa(%zdl*XAdZ+LV zWDJAICR$NoT~&_Vdb4iY#+M~2Fp+5V63sOAJ-84D1OzQvFsW*jHUWX1i)knX7OuXc zvyY})n3btNSZ^u=Fq`e}(e&1P@Bj6iw-3Mb=&`S6Je@3pZw1@wZqFQd4|MM+G7qNK zw(}1^_UrSMA|rLCIt+jqk)sRPM`1<*?&IKYH|JdiLVs z{kty?_tY4Pi zFIG2r)-QO@Hy#_#rkXCUpG#~S6J~G012m7( zQr{L~YC6#_LGUJuhT2BgH5GqZCp#zd6GEDDOoqkAcitPT{- z%+p+r8)AlyaWKj=)zbT&odqCl)=i976@{ijQz9fFu*?N9xU8x$v&I0Bj3@_$Uv>s& zM4EdV0}((}$AE+)8P*|3ki%2F0|3qUP);-wV*wyABpB_F&{Wk#GE^I5%x)Y8MhKbf zg93q3!H6i=t|p=H%qq6mHzOy}Pp$ zyR^S|cyjV$I+-$99J<+Lf?FjN0>)uLfceb)~?(Ugf2BQsY#GX>G)os*<}+p{lJ z)6RUlY5Li8C({hpZ6}`4mm3r3+#o#{+(#)6=BuuCO%GAMcO1MAo`^QhhKPu1I-P-8 zAA2$J&aGUFfWiCJ^axmm()m!UEZbG=d#oz!>%OyL*c2SDG7woP*Id(^f zmV^+$`m1045C7(0>uw>>;QXzT+W-I{07*naRBW@Vu3bA(?G&SGZz{lpS{qXs+Qm;k zsGmMdNHU!t6QC$CyNeZv68d&>PVK?I^}UOk5~rHwZ~}`b&(_mfTh*CsDQv~2J$mr4 z_m*6>cz)8d?*Nj<$$E42XI%IiC~c=Pbd^a2vDe|mjUzZeuveWi#Q4;27ZKvIvC00@!52*w1(EpfphmnmSQ zQSnu*OA*SpcKFmAHd8S&2X(8lHw9wCt;Y#o?uz3WHE&a-<0O5Y=4OX9&C1#BXkrUS z)7GsO88N?ekjOv);qdzP-}se(`G5SoKl=FN58$5Sj7)WqVTiHa^vA`?!}_EB`rtO* zyH~w&AUAysD3B*TK!mylnMR;#8?y%hDu6kM&$jMCCL#>TV>T$NW_isxDlyCSIi$?! zzp88Sv)2D_waB->{p~;e!#{lY-FK_1`qsC;^?SefdvCn)M*dXSb-(+&zxxM&@CSY0 z|K@N0=I{Uh?_axiEr05hPd@pb-}#+C{nJ04PN%>9+rRzoZ-3jl|1ZA+A~2v_%CTU) z3C%-k#2`i3dE!ZD>Fh$1TD>i|ljRPbJ)5q4seWZ(iuR@_{`ps~o-<^!GY zy5LZR69U5l#6~F_r>dx|0vN^8bX7Z@%GUq^;;6SWm=}c_z-}_Dt1OB=QXCVDj$Ms5 zwt&b{9fSzbSYl3%i6irGKm3Oud-&6*&Yw%N?8Ud-`cHrU7f)XEg62G~%JMgU@fZH$ zPyVQ`DgfBr-0byw&u0pVnTVJPl=l@i07G+83oabm8KluE18Vqm+*CCIo$w@pB4!aS z^*RRCdkF$;Y;(zpDl>zkHe#lTh#(T0DaHVRNNiL?^Ssp{Hkhd4#R&)j1ZV-S02%m z*0Qw2O#R+~kmATTBHca&V~nb{xD#d#{^*gz#@aMZLkKI&%T--k8|7&}E9O^Ub!9Ot z^DLQ{b)IFbgO%OAy~j_TK6&Db(P$_^t+9EYmt`4(N|3D6t!rP;XGD?nRS=FS3F2l& zUDZOf`SQ|Ix7%}Ng$j9+kERo;Lz*Pc`&n5aaepw7X{EJeVkchbo->nB1O^nSs;k&W zoJZbQ8X)5|>!c5U`hh2(d}25n8DkEwAAH42U%tGwEKwG`ugdzfpMUt#uRk6nT$cD} zS;EL_QftVMszW=|Cm;Cyv13={{p^|(gHz+O-|L-!@-dyyi{A3g7yz`0qoVM|G#eL7 z&peYCRb>o;Lhv*%!gyv;I*Kzlp>g5X4m!kaJS0)z1zkji1@m#a{`IHNz2KTMO=)>4 z9u9%IJDQ*P>JvhiU48cI69GX3lvzGHcoe*I;DRU$Fho^9vuOwF((LZV&I1&rpr{wK zo;M^ankF2@2fc*dkvVpJ)7O*jbHR{-3N&z(Dv_u5}-?Ciflb`(Lop;`O%PqHf?|<&+e(sJt?s(*p zNAf%efS>;9pZ@bd|ML%i@Pqw+|DErA=Ud+LmQQ`^QveV`c+;ESw6U>q|NZx0xNzY| ze&k22weNoSyZ@`7)!cza1&KifG$4@%rIuEvEv^qF1Vm`oMTo44dfn1VC@KIjCa9u! z9*DpaA(Kf^2*?;#uVp5!+RlA5SSoCgYZI7ZzYmWrLvHAjt#XCY4@7Y+DAYy9p zBxE=W5~MDzvA(X90GTz8K|!4&qKy(_GTp9(Ai>LQ&I#{?D$49&wMT4%RH?PQt{T{Q zSXCKYLaIf(#s-ln%fwj8lF}HP*v~%x$oGE#58nKpcZlf!@$O&w@gMsBKl_^plPo2m zU;7t7_sP5O`mOi8kC}h;d*A%Fx4rGb2OoSsQ_#wNGb5mcfT-9IqY)uM3zuDVTN~;n zEv#Rmz1lel&OiVpjq@%*Raf45m4HMc_~vaY!rVx+w3_Px0MP0=ir1FdhRCGULeEH1 zjWLE$L_9RUcfyE@AmCAh4+ucUFg7~&u%H(s0pWfQOGIplfJ8(Zejp)|6)-@7R6#-j zU?K&0Y|p*+MDKVH5#SHMHu<#&c7N@4M>0lY{*RyA`og8^r*2y@2>wsycS~ zn2l_jB&*BIS&|xSpM2`cZnrxg4(qz!+Z}H1?n)3;&9nUMrHco8{Vb!M-R;qMEFvpQ zgIQ4k!0KR0yx$oP4Y8_FBhnhj&N)>zaV&s{bZL8YRurzN*Za%C`;OXqG51bm8xvAp z6=RSt#zb5cb8Dm61I?TX!p4+Ukr376sWHYP6h&zP%boF=)2DBI!42!H2SNy+`NC&E z^wAIhz?;8s&>JA)J@@_1>2qh_`06_d>5u>FPoIDMK|urL%S*j19c_=DtG7P;`Qgnk z>Yt306Y-OO^i-VM1IMo385i~W^HNKc+*%YRE%Q=RI-szj5)hW#}8gQxVE>o zNt?meWH1qcD59z<^eeD}fCd0kMZ^nd&))ElUb1oU5U4(I?>!&-zkl!T|MQPWaf|@> z-1S#aJ^93&-}(bY^at;M-(|V~G@@YmYy|{bk&Z=Xf(xL>e$7M|T4xL4kj6`=*@%ek zVVfSVJS$Q_NUc@1w(Xc^LK>$3vppS!hW0N23PkG%kGB_A76axES?~jt5^WV zASfI}eC6wLHNO;}Kb1atBE9-*d)<0;G%iyKKq3mFqNqyvtj7~BzRP|u38?iG)fTa^ z=#n?I9}R7Cf|sj5|92gisRaE0eSGwzAAQF=-f_bXH@xUYFM8km-goBAnTH;F2mnT- z(R<$Wp5Oe<-+aw$UUT!!H^2A2@4f&2`)KdAe5!1pQ7>HvB9tp-dJ0Q(6zA#h^+O1;x%RpB1H%a zkeawk;<%SX7X6!d|JD!vPygiPb=O~a<4y1WKY!=KxpQCp(iaJ7JR1Gc@BQx2{PMqg z`R%W|?xq(4z^6a`>E}5Gyjc1gN3_L2W5^gXmW^qDm>cEsZy00@F>^qkD38@((oM5& zlB6bz*cxjs8`F5cHag?9kWtsh(U*{r0Z0U~5gP+0WCT(K0Tk8RixcolwV+d~L~B$} zNKuSY22mOeK|~M{Sw?GwQ4zgJV-43})kPYc8x=yeRw)W<>e>evd&@a zUUfV_)-lI>{Npd`?-b$G&IBY(%j%xf^S8gSf8%O=Vh~@J__w#zrWHigxbaB{M3|=; zlR>1VrNNa~UUAJeC%U~P%i}1vY&cEREX`Ne4s?6{^^FZ;$~v9p!$N4%B+b5G_pRTIm1NV?sAW$-b|9x>(IHPRwuEkC=?uey>65wv4?V6OvYno zQxx;6t|rrowFXt0hy@d4L+$3%sRVC~0mRqd{v8L89!&=QxSzk`Wv`gbCY#$^!F%uA z*PeXrAKmoABO8a8`u)oi{}3>-M(fbEnJ*{15_YwE^do;+&ML#v@@g+%AGjzUW!bd1 zlo!5x=1lL>usimdCw5ctvK7bYLVXV8$zFCQvs(r)B8d*zAIRaZf` zU(aT9=K??yLb^BZ4Tt^horuVqh>#3fVum%-*NQ#@wN5!%MyRx zM+!niaocY>Ld(}#yb-V^onh-Y(_-UA1hmm6SU^CVaz`W7wkSF_V$dN3Y*7KNgc2-B z!Yx~;kpKXMg*urkD8c&rq1WF2JqPDU%_)jzXab-h1W+F|2zv6hpU&nNhZnxM^VyG2 zKJqu!Upe+~wx@zCDKu{O7g_K#^g$KTMh|A!pk zvRvf3V>B88!1D4k06g^2L(aL^z3z3*u4}Ko_Smsw4?OSy06g%(12^4t(|*6^4R3hE zcs%~Vgy9I45K0RVjMDajyBB#NC>UR@nZ zN5M0K_UgG-)3RW8CZqg-@<6x`=@NC8gK#yRPqv5Ud{)n^PF90wZj{%@R7y!T{ zU;3hV?zUIGYCoh$j~;!VQ^3Sb#7Kn5jEnSQp{2!4)TnQzsVm8D~ zKvbcbff1WTX%@$^u@)NjWnyH5%s@y?Y*)l00}?<0RlDz48({ChRCuZqDIcQfrq&ON+jX~U?EtGdVv6l zCQ=|3L8%c05oe+R&^4f{r*`Y0@Zy6xF6evDKmJWidqJhawuOaAgh?F7ahxRS$*WEt zI(R6Gq9lp)JnwY!G)=QCUtizI^3KZI+ES-~;|(`N935CakY(u=M~_r>l_u$MGM&!m ziH##{OTaTJXwlWwQWHdfIKmoBJ;)wHj*GlA=AF`pIl zX=Q~69QSR~HAZzFF)j7-Zf2-1>S8WZ%4X@a->D~~ zV*6Av-m7O-Ii2~for>}cL>CnHI{izB51+sBS|3?ORRB@gIdb^xFS`EJi*9`8#8HRp z0HO4=esA;G6}v}{O%EO}(^MG%$*?6dfCwBqTid;}7uHTav3&Y0)?r@FkZ^C1muVJa z%*$%BzWmHp2kX=@8%x$ANfarfPUhA5v(w4;(7Je{lqSvx$vcg9Li3Crpk4i>MTxb~ zhE-VtK$OG^aOuK%5jlS1%KZiYa-9Fq%7-*Vo`XDH5K^Qio3xbz*{9>`zEo_Zt-cSo zeO8-fA^btONM#o3PP4SDHguczSZxm(n@R>KG^%Ed=E%Y0cijGchsxu8ip-SAw@$nQ ziYlFnp>r+_!*nuvW_ae|(S!F)|Lk*m&sKUqq@oM~B|zgKx=2GnMMDdSMDX4R?-ym8 z{dhEwDTu@i_wt6U^S6Tb4?4c}*i{kvsh|3(SHALu&_iq! z1sgn!>M~PaO_I^P7S%Y8A~rVbW=S?Dj0ty_dMj%y9*~HF$glnU&%Wf=mtTF|^#HK5 zwP~ZM*MD{j*4EaZ=M-4O)^gLP6lqR$<^YN$C|(tf5s{{ryO@n_JU)MnbBP*bH2mowJ8yzB!<{o;sVG(d^uqgq88bAg7 z-LH(V9@wLOi-^NY3_%`I2)?;FKL7X=?;}`Rhw~;iVWx;VN#dd`tGXO4FB6GjGgw|# zgu1Ra);HEx*EV-{jvqa`GFYC?r-Q*#k|b=IlH`VKubmf#K|~V`M`z1w(&=DTS0Qi~ z`?Qk;k4wGo-eh8pE$hnFHG*VGg3#~eF?(7XEEUt)An!QUB(X%Ub{9-!4i2)jBQB~! zLAp^)D*axEh`o1A?5a9W<7qhs08ovr1;C&I6bJ|ioYy?f5wNQ3qAs1U(=;DXrUW1= zNt{e(lhRjpr9c!%(PuyRne~m0&g$~+Y&4!uh$xAY$VSZ?`TXNwd4KZYp<-t$gZ?Bo z=fimW?B=(>?z${pl2T;mB!b!53;EL*gWsKJD^KIBiU;$Z;jpZxdAe$sGK%AJUJ%#Y z=Y5o!I8EoXd6rKnTVzbZ39}uuiL(4)JrZIk&K6~HAgZho0*Pu_pay5{nPck^1XK<@ zb7}3FGvaCu5fZBK=2q@AB?=fPd$8+z;?ml?r$m-ew z0GQ9F%pAutEcm_8KmLfVvU>xkSSW5Z2#G}(W}!$1&yhAz0R&leYMOI= za?f^N*1dgu`@$1ndZav9zy{W?I#WKiU0ytsJ$7Y${nh!4y48}ppd#EVo;97OCNqI1 z1)_!eL0jf&%SDS<`&w$xjn6;)_}1qlciwsDSHAL<`|i8%avktzfA(kJ^{#g{ugBx@ z(W6IEThKsTplh`@5pgk9h>eOwqf?Fq3PL~vVwjU|Hg_Q*c2#9sp&Ju|2d1pwozLc4 zxlns!Oeo2A6kVnBIuuS4W@12PX5|PNC^QMBJ0YMI5JUE&m0OBgmGlc+G!AE-Yx5%jdrT41kCzN z-0wb`)8ASeRb z$UsvfPzWJ3>H;7HUK=q06;adb;CpH8(;&9ZjkGnuG;9>W2Vr6&3KGzA5Di4CD2jDZ zWfRA-sE6Qyh*3I`7()aK;)&3Q;59%9O8EXSPoJ6ifAPu{VuOUu9Ylg7L}UIw`Xc{j z{JCNDXk)Z%5RsXp#-I*#Ru;~O*{n>{Jj<<(k|>VytkdiF4y>-FacZNO5Dy*PD2lRn zZqVD@cxyajoX=+?8(BtUD5&}<(yAO0>9m*{qe&cfyDNkgya&K;x8uC- zy7^?byR?+Vu^#GnA3bw6j%+{<5_V_9gpG~aMm9mXxV_cMyJa~O)x=g=2d7~iCn8c4 zcdE)ISzeCjG21waJ%o|YhdWzol4of0C{cj%WCSXC)~#GEqN19`X@D9GKk%vhcXxN* z{5{_rTPrA~764FNEsQ|^_o*EJm+?0Qv)Oz&Ef1}(1)#2r;-Wlq%S*k+n-7nMPi}6{ zXMQ*iAhEN%Mhj%D97U-gk4Jm+2@O|FXEpDiO+cr^oWp8lau5i9rt>K!B0EU2w@K+- zEdf-Rn78+2WyQsoNEuBupRo$K(o{}0h{)3BE_;D;2K^2pqqulB?@Vi~X6f!YJo>~k zQ;@KEf>$P`?C#h&C9ERI>Ta&&kqsgk0QTNh)vnZIF8Vv7uF5?*lB%fk*ouNz^@yZE z03<*JtlF^lNa3El@7mqke(Mjv4caxi?ISE67B55mMM8r)1%MW}t^nAYZ!I#31*f5H z*Y6wZfofQ!3%pPFY4ZAoa9f)Pu7?1stX1FL{vB_)@yVBb_N(`uzVw(J3w|w(gDcAUR=W92 z^3+Yqtw+q&wvIyGaFtA(`!wAsY1Tq*S3hmxG5c(wHi8WialteFdrZOKV|eO*)vf+B#zM4XC-DyZXbs>*~pu=k>5EhC#GA!er%LSdHrdEN{25)B4dp&%01 zQH*E=0|l2PX%zw^7(+_PaYQB(5kCtMShK{JLJCAoN|h7m)Y`ZdVIN#5HL}p}+J3Lo zjmKUkj-vysAvS^l0Pp_Ue|FE^fA#)9{fh&K52>nvtgIbybv+&p_e&#NTU*a_3T$Mp zHAsLS(K$raAd0PlNyC(Bl;T5Up(m;#FoFn*h#-g{AvKwaDhZQ{s7MV4(J}=i4pcGC ziH)m@w#q_{Si1oP7FG2DwIR+oYOM&UAg#2C01=a*V!)OFhs=NoL`DP=)DkE{<$c74 z2)zoM2srilQ*MM1iB*75^4JgqE3g8pBWevN-v5=!!<+TbzhZT*8v!w> zbYt=Y(<%%)sTaB|@kb;=LPn-W(A_X`qjjdDgQeA?sGO^Ayy4oyRh_)EyfjF&H1Bo$ zS+C#iEM4k%dinBFKRtBF`|#zjK62uUvC^0K5_KuXguLOnujWhbaQf%t*=9!CDCLyXQV7n zw)ch>vtd=#&d=ww$QtLs2d5}O>v=J=HcH|_QCGDFG^hg3yFg-+BpdXSI7@3BO-8Ye z5Xi7?6f>QxL_KrV<@}SMy65~e=U(^vHyCTYb8*tmmvRxA`wArXI=?LOXM^4cCvwf& z0b7S7!`-Hkt;_;wU_nQc6m_;YoUaXn7b_w7A{y`Y+0OE~h@#ca zVO)+xgPn|JZ6&fv%y|Yw_Vdch+?vsWnmBF&IG8J=%MBG$hsj?)nEVlfBuQT{PTbJ2OruvdbEiJ0p0lG7aMCI zy!Vs);X8Zw?DL$0IEt;c*4j9Vk|c@aIEt(>)+|PgP$k;$9k4a+Ph^dK_N~u?NQ^Z$ zVrxA`bBGH{#b!Z70LWMqMPv-HArrB+Xbd)5n+?7LftakdL`Z~e2niJgR3!vMmXT4B zfe;v!gHYwQ@>&F}0tPa*LJg>F$k-s_TwMoWgLuL?v4+6;TAOwdDH5_Z5<~z4kRWno zIgLN?Sn>Hw_0PO=ZM_$*QIMqzMAM zO6JqLDt#O!%s8EmP8>V-f~&56#ci*MY`ng-YKX^^iA|z7iZ{1+)Wg%KPlw>W_ru}v zne$sggc;my`niX{;C(f%%7g0%%i1Ag?L2@^XT@|@?2RVVVm6u2=4I(65a3f!pWfct zp3jT2DuS2EY*v(004d5+0j5QH?&9{mEGqArO`a!)jn)bKWh=|B=tX9&lOI7`8c%1T z3PHjolzULjIe3FX0w5LT%!|*n6cMa7&bzWMz4wKy2pEFifB${w&YgYz?XT@-IU+_` z5~u0f`YI9b?d&!{>dO-UqVl8Jyqib5wwflfn^*Uijt$jl99A=3Kn#q)c++mr2`t?6uD7HcNP+MO)uE@xsJ1c`x5>YW*+ZvkSIcPR1V!*^iVB*p0`tD#*nlu7T zMw9;5xH~SGtSRS*zkcrU>5(N!icx=WclDXm5hx+DDDTaKcl|Txk3O{*`(U%BH12o@ zoTW;npg~mtf`V5K?GJd7dp~y9sV5)*?jQW2PQSN6X6WkrIuV_F`e|6;Ii7#~TQ&kL z@F|UO-vTZ4_)$C2iGd+rN>KSC&^_b^9A%*t;cuB+9l8RDLubeRcfsy|cf()VXl&OJ4N7 zum9m!9=K!e(L>3j){MYU>z&cwLz7S4Gyjt(<1fvlQ6ML{$gtW{%>vy54V8u#ouYlR z4>V1iCVTs4l|{aFb&)&oyz}>e|M&m&Pye*r?KTa+e!rilX}{n9u^;=fcfIRf%gf8X zUhgM=@+WV*?Y5V{{N(^}#~pWEfBp4ufBV~i<2Qce;>C-<@C(0i=bd+cL;m~!G87j$ zW?G;SnhGFdHh7g=%BxVF+%N78lI06?`1Q>~djS)7=>{~5DRD>vE3@T0}jiAwX0J6lvutcVI zP82y|wH)T9i42fo6M0~^aqwOY1ArP68MEo!V5Kj;e1?n>SB3_wy#vQqRaj8})zAI2 zzxkq&E*MITn`-4Gq?%sOqtKyY`486>zv z(BQ7Y-Q9z`!{F{3+}#}lfeFFg?mX|k@A}p^Kf2efSyO$wy82YrIeYKJOAVkkh-&<+ z2~a-*5m#BRn*=JM^o4##sm!C!&@v;?KBrE{YCyv)`fWu;MRK_P^1Ov$ULyKXpG?yq zL0ra9B~#E!BvsP}x$6#d6WmlVmV#;K<{oKhlq`{0e=bw`6{7cHe({G1Y#qidOjw-<2*KHu{|#lpSSYT>CR)p?j+_^_0QeWdV420 z;MK)t{g)ktJKE3p4jxl}M_r!WQ|2$PYffkR51dESqF1|jo!d5cpNvdwo7=g{PxVjD zyu9nG`$8$a{nuRE8-=QPLl__WocKIFwWcVwf-aL~Md;34! zM&G&8JD%1u0BvR`Rpk{(1CMF8*9AB-+)7l3Ruax8#)?w<+i{9GN$iBWw7(3`|7Ko6 z6>D#JNV!FfPc(7g=QhRx)<%*lW}6bC0ItyKuXegn)8@!qxuQDWH|Vo}Ty07^6~Nq4 zN28?V5G!PYVLe4&7mVY!E`+zuZMib#aM@)NVNq$m?p-kJ>%pd9a*@pb@b&XPc2wlO zhluVyNF8Nmq_;fkBQEh>NxHOt$NS;Z*=8u9x>~cTF=I4ILqH@&9DM zG^fiKvI3q8G)@!lZe&2Xb=wr)PfXkKq8ncK)^|upo8Lu~AJWg&aOrqWTXcI~6H~7Z zTox~&J(r8qLXXL;lkeVL7z$(m{%jE4unAku*vr|+j8}V#7rj3N%A-h%uhlF&C6lJZ z0-$#A=aZjidt2Cu{zIUV1Ke*a47z%Lcb)m132t4y1Kd|_KYpS1gz9X!*SIWo2BeE# zCd54tC_WF^wrr*xJ;c5KiTh8{^>X`n1A&?{Npe-5c%$-^3p#<4PDTySYbdH1959Iy zgA^x@T5QEY@3K2*(i+hOD4Wuup^jRBsU(p$eQ1LPPGNIvP|;(XT1N$wQ#&=FQ`NCk z!$W$>)aJK(1($V6Vwz=?pMtfC0pX(-$8fX^$iI-N;3^n?s{f?xJpg}@3%^?9PZs0R zSfm6_IL{VsLu;zV2$bp5YcH*^u_?-E>X{kN`|f(M0lv>Ye&fD*uglxd+kQJ?el*he zM?IHzz{k?J{Wz{~<`nn6DF4Mp@wu12#83$1qT!;L@oaff2+8bF_C3*kQnvImZJohg zn8Eu&DiX`(?!6}EQ_fi7U`Uz(V&KVmfDoL~wC=FEE2F{phXaB!k(Fuu1KCq>2mw@V z|AMx_NCZefJBf_s!~Ol!nR$b?P{WDWNYU1b6F>`$byS4*F{VJ8@cn_1ouI^s{KZrP z@bkbjJ>Z=5&h|{|c-T(+=@vgb{2|O+w8jyD4YfVh((iDT~UpK+6FcNo-WB^NKQaePzqvbZa#^;nq+Av6jAhIvRU5MPt zM4(wPQ@-nNLRYgXoQ+i7l*i?qPX4gLl8jg<)9!pP;9!=%`yGIy9s27@*>iQ=;586x zpEW&}y5$tb?S3cqwq{UrKb%mPLce8OBy+d3d*5G-5HKbBJd)pJnz^FceSUD9H^|wM z>+`oRR-7lo;aJ)j+Sul)xn*b(F&Lv*fEE8jTM&kB&nI&%vTrrQS+a?evNp6EjIvoywj|DX%rpsfMl0u z6INYEAa0PfO54E#CnAK0{pU(S_{Ib^eQYZ+m}-Hsv#VlIEs!zT-|C1;#_L_JlgOEC z1`Eh|h@7N|(H{;K66bRq1vpQ@el2}r=sN7!`mrg`N;6>ZbqWPs{PMf+J1pOS7^ZlC z`LTUlU7S+OqFh4O21$$>4=XszsK49Kef}EBV#84warU=%_^@$?t6kS`^`NPfm$)tNoU@Y%rM|x^4xDcnr#4r`qfARY zu^Zh#b|6=*&wGW~S*zX?6rcMgn?A5C>~=fWKg}I1zIZ0XTPcYTF3Bqn50PuTQN;a5`N@YmBlFbOwQ~06MeP!P-qv@25tQ&j{z)%Q>qZ~SM1|5huj-g-&>*;i+Y-lb`F&wY{=z1yTsara>XVq^@_t~ z1|w4$T>g%>l|#tmS6#wRj494Q>9TATBx~jXysts~2x1anDHkm8I1nfc;SH6P0mz8d zC5Gj*jRZ8!3AUaixSUj9QSY4>W#Du1yj2*B#+Kg7Ayl^8shwYrA zbxhqrG{~7~>();gHpTd@S8c!ZpL(KuMV~pv)PJqlvGd$*%6>;K;Qr@6At}|B=je)Y znnRi5gX$7d413D2!nj`#k!IUn#Nq;bd<>GSFr z&OWVot+q0saPf3;r4yMdYw9Ff_AGy99Bw=~QCehiM+sjdF|%8$4F$7o$)YL=xV-ZZ zTp|-BGz_)l4WKMcuMl$FpyF{fsc6S5pO;H>XvKfs5q&v2qIeU18p-`}DTKZQ&Uszg ze0vps6KQ%Nl&TT*{W~MO{o|AgCeB9jI(hVZ7^P@uYo~nLld|(~2}#at>6oflIVE~r z`3(ZSj!;Db_0eU}>U3oOHt__T7Y4CVRS~ObVz_mq7S7rr`!7IgLTgH{9p4F~X)5kc zBpwTBQ^fM)NWSk(ydv~6b(oz?C#_)-=rR#lci*eqJ@E&~BOO4zbwz#V)pO1vHA1m{ zi)fi#-~SB!KA#(9f^r#n{)w7h(#O#ZcatNdm9-8V7VE%dYS{uV0pQ_CfKkNwL*eh) zfsv>mW+^$oU)Ah-YW)I;h0Cd_FWSG^_q;yuzp?sVZPQsc<8a&0<7%g|0s`Fv-U}No z&d?FJ19Esq6#acjSUJQy44L2~rGvWR0RS5tiEm0)nKfKqYhNHS2(eCu^X-NU0DqzJ za&cp@wp8|l+<9+@Fs9K-_FIH-!=-?e6 zCK}{Qyg*1OPB4H_MjZ)E@>Z&0(G(!bSXKsLFXQInQIS=ztsvJVw!(={rzvwsgG^YA zQ1Stk42y<-)yrs$e~^HYkox$FD2E_$DnVPd?tSg(UnSuPXQ}-QOeL*kdsrC4%RGV6 zwsN8Itq|`|?7c%vO*ML^Rdos62}ocLNq{WTj0Y(=^0t1!k1IVG#`&)AbhOw%fMKb; zVDm-yamnVctMY``=I_(4?BgGve@A8u7{&#(jHN#H_zw0tn=5|#@};VZJZ&2oe0*`=oMyDZ5zzVsJU-C8V$@%zh*0Y7D(elCw~_!6vV~=?al46D>&qx z6la+Ud@$JO9XLK8Is;wca3jzL5y}k6nUhW73IqqG)#S;N_f$DLt{#493`A6AU-coa zBIOGiB*w#Fn%r?QWjIeq^659hg}Fq)OSk( zrUqXYQ(>}GF|&(}HiV$p)okbAx2}Odj4XZ1WmVI18B3r{D9t_|bM>{VwPrJ^4{}(D z*26_U-1KG{!H*|;>4y)8gsf@WSfRk({dR#`!H*M1%KUm=wH_B^)g<^8*LP;IT7}F% zyoACNK7@yoqIiqeG$@b_e_gofzD~>$F?PMxb)X&ZOi~Y9TBd_|2yL%%4_7PEX`x0( zS`~sexGV_X;~4@VQH%&&%Z|`OrquZl^|UNIz~|ay|3*|ibz^PP#A>eJF)1xi8`TO8 zF(gVS&KV+ANJqenN)LT27sc-Zcs?vaE%J8nvC`kG&Rqw;uhXj3UfHuvK!s(!XQACU z`C+0ri(wRdNhdrf9BN0;s+_z&%D0!$#8gn0zRP7vp_GD%@5wGJjH+hhv2LK8W8k?l z{+ITcGpw0;sg$ z`AE%WfeErO)B*hw#!cYD{6KB0Jd2DwM^9f?M6kv=|oAvc7 zPQUU;9;la>cNj|k!=yPGRFg3m3d;Z!`Bybn^+dzxX(3Yt`unSpX#*VeL-_K*N@q;Q znP#L5A7QG2c$8rSWbh2gNQe|9T(x*q+VAuSd1+e@J!GLf8GGmnNTx?WF*(?&Ln!kI z$oM*i1SU+mPhFqr74==9UszojgY3@kXAAc){skm2j5!6! z=?P=(Md06XWRIMj%ylwe{=3{dFPBXcVBN33l)^3@=#rv%^HkQ@LQ&t?A_a%4>zbUp zb7X3UmgS#6~ zn_5Svz$VmAYg@2of6s2W^aL8sKAqycSbm3yi$YSgnxpJ@UREEzdFG! z?e0cx(^YpLpQkZv*DEdmcxl2&zG^6S-oK9m0BIX$9FAF@MDo*{schAYjv$*3#l$aI zo+y0LfxzAI*T=Pj53~AO1tbKd_`5Sg_u~6IrIYhuRSZk&Pz;P!80gX8EZ=^%FlR_@@{SNiqr{P#g`NW(Cs8iW44n)o8ivX*w(<>P&JlD7KY zR?F?yA4y&@8(lzr9%>*wf6*UY8Y^aP32Z5G)kLYKkvSzex!{31I^d_UFE43^O6a4F zzz$Otc72dCjx91RONtmC9il%?FQJaH)Y;SeSrueL$lTXNz032i%kKL25%YKPd>}Nvw@6@1-UlZz z(n50}FzXIvl8)xE^}$F5F;$QP8El7V1T060m$&Vg1D{jE^fN&z9?a0_m^c*N_0#rF zQB(-JwS4tgYO1E6be5$_3i5VqU0*(s-esFuK?f$i+*HrXv9EugG~{$qC&Ls_yP@mXRDH~%VN{CsNcxAdyRD*nK1v>=TaVfdI|8Zo85N3^U=a_ zdirE$X=Slp3S~niv&;nL*HCb@RV2&-sn#mQ}RrcwoDye z=E{71UQ&W7em|LmZJ9*7L?xw=#{qq}D`?K<-2%|h_w`_OxcgzFX?c6kX)MtsBCW(T ztkg^DR#?KhwAp5LgVvaSUVc8aV{`xwYT~)Z9g+x;KBtE3aT4;x|i3j~w-Z zzN7A;*hq5Tq{c>@?5L{r@VlduS?qK+-=a*jDSpjoFV3i9i=Mw`7&08&#V=m2XMAZk z8T{=pgQY<~IR)LkBpAm)a*aFWE45aDRwwORY?18r)ywOv&eq0(A66>i0>*8bKRDB6 zj#3|qGj}2!tHQR-8d}pFxf!$}Nqx&^cncAI5NQS7u@4>_Q5~*<(q#JnR(jSG;_pvs z%aUT$Tr(|x=0Q>}w57|djhM;Q20MWHct*SEY8`U}ldU+;y}T^xk=~Syg}-Z~Pt2Nn zXe8Sh;gE5t$L0=hYIhD&E5(qXW9Dm2bJ3dt==pCp~ zMy}jkd3L2ld@qEM(1ZuKR(>w|XI@Uf${y8Xg+n!Kr5uJzKtlpTv%>!o?4w_wsO}Q< zD(4pwLEn+RkQN*RH%AFFStlW^K~NTc$3c@4iwZA0JA1Pw{@B*uagu|=)dn$CZ}!-=!+3vxy~Wfx+jlI` zY4~78J(FGm%R7;kOLz?QEuOf=CM;@|-Y_i)m2I zBq?lQ36%t~0KQxTY!uF@#%L_hEdsJu-*806q4>FH)j_;lO)&Xo@kzmoA>6ZhAmuXx zCL1c1<}EEU1ij=B0=04Y%4ca|iLYniz?h}E)-a4d+&~OR?)MF7;qyd{vYMVp66xPK zCQ80xh0ihNO~~mE*5K;!(Ba@&i%WuHzEdb6Dq>oPkD4UuSU5FI(gm>UcRs&eygkQN zcN}IE*AwRw=L%o!JsYtL3$u%qth@bKof5uXQB~c~wyth_9LXOZqUX8u+*IYHA8J2t zm=C}id6Xk|fJQ!?p>_1F9s9)hACc0#SI^|Q`U2*A~p8ZJ{I z1q?0rt4`-Lbqb}<&(|A9qSr)7pgye5>ky$pXR7cK7$Hm3c2)Tx1bg>BB3)SXRKRx+ zk-hPnD%h@Oeo`P?K{D@?l!7N3D1$CEP4A!V2q-nmC=b;`dT#*Aw16 zG7-+?r`>;ud`e|UcYb6X2$l{WC0&)4xT zo&d>iFgq@4_OUFb9rf01VBi|kj8|9qk8>qF{{W7L_qXUO>phH9pBz- zyu-Dp@y@q-R`q|e014(F`8=-Ub&rr=246Ohi0W6DV=3B`&)7UtI~8K=+h1Zt9S&BS zo<6=!&E-Ex@cIx5uNCkn);|7W(Q#EDpT@@$E3?M5_jF@vV@ zZ_-Fvl?&eO+l^vkI?j;$Z{Q}lla!vU})@%Lcd{|+%B4>tyHH!;<}+J6zlWR-i? z*EHKCPT(CpXgCw!v>iSK|967fGGxSsXv^0v6%32I!HNEFQ{HjL2ZbO0Ut735c%N7} z{`V&v8cAJ~|9cT!$rb77){*~r`RLjN_hjdU?YEb0SS37b!R)E^t=nc;INh35FMB)^ z+wcCDy$@7}o{p~Be*1OnuG?+9+hC4mI8!S^} zQM0_>?ekRgJXYiGr|cD^H+nf-hQ>qk>A{{^@^V|tn|0((sCG-{kQWDrXrZ6udRZA3 zxxL?ydwZUKd%nKDt}`CyX;(?bKJ%FN5_!Fd6TMwA-iApXyzaud_+EGa^mKKjMSaeL zC^j0*r(t&7jeLspeuHJN*SBA9-8a1aVD#b*mu0=}=R;o6r`2h@&Gs8jzZ*@~R(Q?U zXO{&;(wKy2-uM66!=w9p6r#yV)V2>JB6mOiyXOzCwO+3N@4iWOievgO_J`p%{N7$5 z0)m2>G@}NuzYT_RbG$EQ0NBFU@etqJhFsIbLaDf++*eqMR|hAjdWJ}hj$`Rp+vp6# z{~3V)Gi*Xf-a5}AH?u!YAN~}^ZNY52VB*|{onWoZ3@up|vhnhUd1h8iQTQzIFH0Y~ z)Oc-fb$Jzn{$?^5|4`<+~beQ$;WSBp8 z`e()-Y!AU6)c{J>scK8Mt$D68%z9p7*MW=F(>xF4NY?cQ^A# z@L%hGj@Q44TnSXzo7Y_cp9(sF;itEnte58%MK?u0BBcHYt-QY}FU{#6>n)aq0WpUC zg!uW>k360(6P~BZp|glbOwx3IAAAM)W7_v4H2^KlTx^A7AW^}y(%B9|kd{zG)b z*zF(UhLQCC)984vg1tLexo^+Sw(Ab}mzLxNI9rOBK@!I#i+>UFl zVhzEpnn@774-&nHkxV`VJaXRFYF^f0P3aH}V!!TSzfPS!E8y2O`n|pWH-de40#H1= zwiI6v6ki`}-X0CvR+_AdIQO4_zx}5r@;{gPDEv6Y+kMgE3vH=pc-U9r>O+AsVf`*x zUk71#%qsT^v!BT^;d0mlRe%EK=IXSt32S3pg?=8X?9Sv%06u!3_Z^P>=L0qzhsjT! zFNJa|E(Y)wD{JnnF=4KHXXCf1RiJF_e*-AySxRCi)R5*4OR58H39Y8zg^S|#JnTP2 zNukd{0LsU-w6vKucu-?M2?zuT^;KWIy}0N77-5h(UEya-VY3aMo=05lmUTW=qLLV% zb{fra6IHd8SB{E``p<>X(a}v+99CrRI8oQR4mW>M#mCPqElrmJg@=cy@uP>GoVgS- z;3_+3m8DQU?9ig-U94#lFp4KMg~H0+|HP54ZigG5FCd09PD?jGBI>^0(Uge4@+pW) zee=6d@|&OJSnvrFi$38GFSB%~R>4xHgnS(UEWe;2G7vCTYhCPdNilx@lKWb3&hmz> zP8o@RvrI@|$Q=Yv2~pFOQQH$Yqr>6kk5Q&fCz5LpV&f27U`g*KLU~wxO3eK1(xM zKR+!ucN^v&2gl!%{4P6;jfKr_x7-BC%@EX;zvEr#gE4W_RE_aCl)j${Om}hJHHAIb z{j${NQ|UO$_*=C-&D+&IUF0uglc;5eE?y=7_2_DjR>mj|9HJ$GI+0~6gX1_w&y$?@ z?d>27>guJvgt3)sS`Go$F1-hTuME(zhcJfY1o9wY;C5nDe?>Hw^A4az6PbPk-#Q+Y`hyHZ6`*Ej)#hzx-GDgl8)@V<= zaI8k?#>W>;=R$5)n}1DaA4n`M|GV{EZd!*ma^BIOJsncp)|=6 z3+0%5env)hLR@NxNrmveC^-P8>dp*IO7+6|8E2dbR~>|4#{6k3HiG8sM?*8?iKWTR z+kaa({jWhsPr5{`Z~86krzVXP;NI}fk63kOeppo^Vvgl{2l_YZ<9e3zEbE<06)PSz zwidi!p+GAOXPW}TkO6CGix^1bb{Ap?fl!mQNpB9oS} ziDrqfL?OjRfZRHo`>$?5a?NcBmUvRqahqepeDC+2FTHC)XbxoeHNDgD&}!0dH;0SM z+_b+p?ZOE=!Y=g_Y_g~zM63XYIvIMXJK?^pX6r=qpt*?4Uwewy$3xOmUis9hs|O6$ zIgF>&?iXp#qjgWwTM?V}s?T0TDu&Ej` z2xiL|!1?I7gz6N)oFl5>Onv8=CL$5IR>OyuH1WUu@+hPwhY*kn0D(@63}Y^gC5~Ps1}PoOr*q9xdjZ>UxWsQPUgL)t5vaMQY!-n2uM@K z5)5GVGS2|tRm?ziesJ;*uP=Ti;Yr2o{(@7UX4v-$j|WV+M09>3I1#`(X4*h(I7lD= z(N{Vi&{pyi6AC$f$Mwv1?(@dWI_-TB$~(UsQdW`YmEEAIVKd=amULDT9Fbd!KP$Td ztT7y)f#)8|{`~T`IJq=3E$e9Fk#qb<=H^G8L}+_HX_=WJiQEzF5$FIF!}uexHi`8- z*A1-DnObrLjda41sd8kvl_5NCr?dait~3w_ZHV}+i#?@xh}asF)7+9?CUK2gdV&TI zkf-rME{jGckxo118?1?@Ar9w6*jEr|E%y+KwXKj7|2cX?6ySa)OyrtV^op}(+xLmw zZR27#&i99<=4d?S(um16v417nkjASq z30hsLgHn&SK?PPZbxX}5y6egezTr|Nh2i09z5yiTo5(l`qY)RA^Qyy&Iqf?~U2G36 zYwhLlhQr7?eBc&%XcqUV)x|eEGOF=%)xhQT$e;ajfCuOjcv=^2g9M*Wt(ODJb_FT* zXT2qUb7iYF)mtyyTUW|~JE`^H4AU@^?%+r=qpO+{Od(dsUyookO+@u-U6s@_G>z}{ zY}nTU*}W(MPyRIk1jD}*lDL5VUil-x8cjkLu~){7lJb<|rqJ(zfMA?J;1~{2nU($i6Q3G-sioJa=-KnGgKY!JBg5wEKlLj>UGf@h10e!>FISGf~IAfu2Xrx064!g)N(|>qnw*53W;d-0WOE233jE zMQ-ayHKUlJUjGQjUmPzBN#~j9JDeSva74WH++aO~G0~Yyy5#!-nnUegH zTg!ECM$-42q9i>1}^Nn2YbJ3AhRe15Il;~LCm!n78RuVMrvsdVtNSu@7r-& zs$d!!4Rpw64P@S^?CYmD!t5BxdG;bfn+v*C*p$XF+aM-N!?02@z*tvgb5@8D@VR?*oQe#zM!E{t3BRmd@&`)t%&FFaWljhixC6 zr;&79JwZCQCw%ki)<)rQjiQw>Q3-?rt9dYIAa+9Z?ZYX)hUm!2w6)Vu?vg5V-}kz~ z&#Y*P1OHaqUDlT-BbsL4!TF0(Ly$LwfVKpdc@S9e%%5>szR`BTXgwJFCRpd2MtrkP zCUv2vxLVZ!SWG@|Vx1S6#vX{2XU2EdS~c6?P<7S@rg!4gXs zu9hkxprI8}J2zEI^64=2CHewF%sxC}?aG2{sU`i?pWIRgw5afdtNhavLji$AQ?ogC zoJQ9{z|IlubTWx^$zbL8;H_g<;|}<6_Rv%a+EnzXUa0^#fIUJt<_4hB7223SY=}{$*0Ki8pX-S}PKOm2>(aw?(YM};|4p`p z4wz-j5x|s3zM2(66auL*9B`1^+MCCVz}jWV7dfi~?w6g!MKUEM zS#Ge{Q^e1lQOSykB*5GNOd}2i3QX;->maqh?4$%@ilX$&*(6ENMo6oLk4QbC0hHvW z2EN^j;8AasOVmuX{|q zJzBgyUrdD!0R7Jj6%OAO8>`c@i2XLPmN#9mNUJ+s&+b>!s>DH&zqttjd5d48LnYXp zuNz?fyh5Y!yS%B@EPM_OMP3xAst)0+vK%jeD6FccxV+fA`IzP%mjoz1Pn!ZBAQB9ZfXKv)hlnvpT``lyakdrxnG~m;(VYMA$ zt{?Ut&c|(Fx9OgzC#ko8XB4mhUZ>yGeIx-N;XWb&$PlKy;Fc?pwbw3Kq?H)n6A?8! zr9bZY!~-l)MegTPO|_A+5wQj@lA>|4<^eY|{ZV&a(Ly`u{jV>(3&+gzdfJlsmB=zx z->I#!tb!`S+vh?k(PIvENDEbBT&i_-)95WywCHG;a5}9h=P1S1!arLmB@CEF$ml8~ zUw{~4Hy~alW0XV_v-LicPEEcV_+us*N3CL}g->Y6Q_{+=iaXR8n|FvUsc8f10ykOD zJT9O+JXYoPErCQ6k*JT+ZkCR$9Zw#oR~wxlpPz4hb6UBh1!ak+f-e;>)N1bI_4GBR zbxLQm(;6S!)%C)`WKGA#;qq3irRNxN>|wlFx?FK00MK+rScVqRJRuAD#+s;|qOxCa zIVHse0YbHwrN4R;=B@1s&ph^gQR z|6ZoAUTa;7%_cXhom6ezMP1^`z`4eA@~U2}DBtVmsAQcr30SUE<&@hLp1`w9IbNla zB)dRgdGWZAPqS!6uFk{r-Rvv~UBy~0=*|??6xHt3Kf$F>zE@+1t+sKgM$d40?9<7u z-%DoCJ;v{rx23-yyw>A3?>CR){0#h#6waRBE}&^XWB}lYe{W20ZBM^aU-6&+rcW?x z!h?$DkJ%co^z%&%HY8ePUu^0khkz~H<4RjT(mx^>iDA1Vqk4o0Xp~}vE94_Gr4D4h@iP3nBk1DBk zb7BRvcM@9Z4Z#qGtR~AkpmDfk7N1gu*K$@#tZvo5bnCZVInaO{Ro-V&mQsTB+C#=e zU2vxxNIk601j|8E%Mh;>>z?{tqIanww<^eZ@Yl9n=`rcs4QKB2fWga|v5uYl+5Gmy z@% z64fH+n3E~xn5hWB>89Ey#N7ncI7#2ltoM9bw!$okV2VLr+cFK5Q~dN)%oEf24cwvO zKl#Q5sMP2dX{s|4;?0iph-;~i$T-842BRy6^uLPm0cKUm$k}b=in!5sv#a_Kg7pggnw2kixos{Ec1t^! zj1ODnSMD{M6IaVewlbg8cKtHEQ7r8rMY}IbdL`uJGM;5ltlVnKYM+Whgkelrs&Ks% zOSdt{q?}lkEVYpsRxICc&BNff(8=IMusRX=Fo_L0$KXZ8rvayxG;rsoepkkRkE@E$ zae_4u_r{9Keis<9_};ZD@5^AJLC5SI?_q4z-+<^Zag6$z;7j-t?M#_PRNM*r4I>?n>w$`~$O<-<)(07~P zK3XzqVsDQcpFOjH0UVO<6VH754jF;k$heaTmwgEH(Z@I%7=fb=#?+u?BZ!burxo)? zMYf5ieWwI-Hf`_n*ume=fdesxizw!p2<+54aNMDA-_0(*g1`wnnKb28*vVoxgmcHy zOV`y18Wp<@Y(Z2^gR2-e>mM7np{-+-vm)k`>)GWb6>*KZznOcgtIw@+8V}{eAU+;q zApCvf4%dGxT-^Kz0uen!NM@6chreA-%m~Z*!VAE%R!wStHr$G> zm}e4YPz%u0GRE@eg0XgsG7$4!Nl9Vb^hr+0$-S2Sa_lMVN1?`7AXu-Da9o8^pa7jx zY+r>qpdj)~RgMpmR9tM%+SWXsLzUnn0Z^TA!ZxGg+c5la=zL0cNq2_PhT=T6{N+-~ zwY1S%4I3j=lj&N@ibD13ZxdNTaXVU$MXPcOt)uTMqceY_$7U^B8r&^{aqoJ-d@sQB z;CxurEVuu5yA>fx6!|*9+~31*XZ7`$)M2dOQ#yTaVMt+^!i4?gTulz&^Izka3l7m% zVzbi3W9nM=+~?=*=l+OQRtk3-1IBXW+b`taVOv%gI1T_l@5;I&k0BEBS9ArbXT|AB9M>-1x7ZdjJgSED-!_N6RZqld4ul^o2QatKB&`tir@Il z=bs5QL&Pd#;54RR4qV7?9h(*nFc_Wes$f~&O>fgyYkliTyn0^Ud(7;hWYv``Mv5;^ z4k_cBoS_ZG^sucRzE>~f);yVg&7#me|Kt${=ejNp9xQcbGyP9bhu7W;G+Q<;d5T3_ zv8Z8(4R4}8N%~vUujVxdCG)^c-cY$i3*6n#V-Buh*nP zIBK9`S@5EW&%$i)IuTah{RN=9Tk&N19?a*y4cn8;b-p1V4DyQJc62&8&2x?(QT(R? z=x#31Wx0((ud6*p;_Q<$#r*CT``J}}f~XW=Ezg_#^q92$fkx!iq?-Xd>tnD-)3!Tq ziyp@7-gtX}zK_F{+nij05UY{1pfPfg@9bHUN;=WYU~&3>sX0-K5!4L;FF?CekP7er zP0(YqsbA=+--caKTCq#%^>~;L7W?lbwfovCs6-3o4x?(8+3T7X$lgI9bv4xQy>S2QeG6^bI*(uI7z`QJvJu&k;z7ToMR+}UbL zZhkg1hW?+>Nh65tHxT8J%a^c=C5ZdT-`NSwv^2S{I2op=k&}{W7ei{X^ceUUr$xd5 zjGO1~!Lq%u3;mj9Xo_=cM3kCdd%ZBISZCF~mHR<6P*Ow65T}X2`6gdP6|~l6N;@gu zzShH?NEi=%-@Oms0N`;D4A<<8NO(tfW(IU-}1SHUziTrS1l>GyFt_c{*=sT{~awL z!vGo}RwLwW$B{O}wE*G(nlrIYVvAH&O&&Qg!uo{CeB(saps$~=rK262mQq^Auc75R zFFE9B`ajI?oekbx|8-vBAsWw|Zo3Brpc4asOjwpk{x22)O;B@)w~RT8_}Dc1 zVvD^_x^^iTCz^ez_ABNtwrRO#MtCrne0q#C3vvMj@?GE6a7i_gSzf((R2+^*M6Pi@T`Z6#gJ=@>(yOFx#B;>9*A_n|)f8twR z6&7jyqhYAyvoqN01E5L|zENK&ndYcIVggCR-!Tt?3~>vo6W{REZ%@$gGTmH+cb+Md zjrYpU?^@8!)@R*z+wX=~-}_Q$njCO7TNsxx9n>TU{W^F35+#TaGKGLK7`IR;S z0g)lVqZa|G7STpkE}0V1;g4NL_iMFVYN>hd+Z;mMo#vTn>$S)7Wp~l&XHmXPBtto^+`1II`6EPU~WHKD5QacjH5WKP{Asg|#qEa4!>gcgszd`+g zz{{^QeI7_jBC4T?ycWl~5W_U3D$1c*zL-MF)qLZGQby5pvB6Ctu<4Rbpn$LqXNO|u zZx6JeLBOVbSmVtRx%pk=ZR$pc(N>b{b?@SA{4|zF?NcH_1uJ;pTQXW#AVrVC4DZ#Y zX~=`>Pn$B%n}?f)D-&97fUSo_{Hs2TQ!CYh6LEc0RkR ze$Hj0D=zM4$J=kEQ~fHpL2kvW_(17Ko&E+Y3U9KYNNU(*@<({IzMB27uFL>cd>JC{ zc-Bg=KbH*JfgWW6u^(f+(j$RY^mk*>_Z2{`4VYYQo_TRhQpfZMcj$hmCQ`e4dQ2eW zNCNv1os4%}VFxGlN8sIJbm zp8^?#LgcNhI<$rJLDr|x6UR4|K4MOGk!~MoN|g?exi%g3R9jg^=bhRhV<0RUSZ8IX z`{l-lJpVR0C)`*8gOJJ?l~N)>SS?N)yJzyc#f)ujDyGDx)9O=&)omV5I28g=wX(TB z&Cv84Q4EBy9rNVVWR3F9vO&k)>{(@xrO6i;{TFyK#05U_Z)9C5%TCj}JV}^0V&6Py zZre{t7efiEPWuzqXBqX%AbG!qD~!7|G`+$fnpo+n57WAQVUeK}LVhddf=K@*B*{3r zr2N?MCC+0Sgc`VRG$8~%0A}pVl)>{t(DD|~%k=95cZ+Z7+Yz>?JM$lz);M3N?B2qc z!_kt6Nr&m_1AB%sLpE$wHX@U-zTLHoRg@frYPcMP_x?3hqTe0H_*-FcfATjef_e6t zcZL^ZtA91sp(VQiwqz1BMlG8o#-k#>=(K0X5`o#%PGx5Rs59T+8_E<>icz%%zew?r z^XJ&DHeU&!9n0JLo=l5A%$2W_(-R$wZe~vABvQOxI9a7y7{Fzguz%vjr)0_P#K)DIB07kM`QAt%t|jAM`!yii>)ZJ2}<5{M^vk zO6|Yekpklvk|gq*J4)(dW=R!cHx2lOS4f=p>+PmT&9=tIUG5;DX;!ob zhyp%hg|Q{mgU^MzS?98k9YCGx0QD@ znQn$MszYDf1vaR^Mu!DN1k5JZua)T)!1k?MlEjwfI!BGPH98Sm1On0XL1?zh;}woD zwE5pqUy6+teKV@HvuZiS1iDbsfZQrryy6YAf z7t$D${`C80*VUz{_~3&#)_}YPmy5lNVR2v8WqDiV`W ziz*QZAA&DHu*L?J7|%^-&X&0zxFWbndj@>&7-Ab|p&I9+wucnkn&qrMc#gK2)eNRx z!s;=7h^#d7IZMSZ5^w#!H+MT(S(Z^HMDl?qx}sqT#zc#vNLc+iO(nGs?}!>Mn%GsV zB&w=Xu?(VUy(BDKgH*K%NQ@h~RYJgukdY>!Bwp2+NtS2i)lKV#JWLW=IXuw5Y5X%R z*;tGs@1=!mHiq^nd&Ew#iJ%PTll3$8-uNt3r6O@Ys6bQ=8>lw>CraHjW7Po7vTQw*PTmUK z0h|K<_L-AQpZYK8-iQBn+b#RXPk!=K_y6LL-|@Q5SAX~Di#H_pnD@^sZUUB^8$0a= zf)scG2*5b712|sLL}CVztLvn#GXQ|=f$tt0gpR#`;N{R$|I=019Q`-p-+ue6Ken{z zogcXtn*hA|3gIHLUqwEiG2Ike11U+$3e3s zNemk%_Q;otrMcO~#rf|(`NWHd4&400v$x%T`_5~xz4e2?@Wg-o&!?Vz21{Z5D-Zkm zQ=Omw-}Kt+!~|rCQKLa51Yd2yYmy{!-m@{xaO{Q{=il3Ip$F*xcKBCTA|TkBJ_Hz;9dMiubIriw(1Yx8t@;YOn-tGdK{tZvF{uiky=$T7FP zXVp4j*qG7CX+?ZYb7nLzLzU{dHmuq(Vl};P7pp7pSjiUDj@_w$s_3O^JfX5*oTcx@ z94A;wwVUQ^zo%52%TRAERP{Hlc$G+%A~rU9Tuv2doJo>IU(foW3%m^|fRj(*p+g8b zh2Nh$x%8TyPdxMNwlBSK$Bl1%X5mO)7CRK1fE>tyM6d{WpbMM?3gC6XKGhwi+X>{r z6fg%I2Nc*0aFB_9xn#_Jr;opR{#eIOpO`!S$$L-U_S#(&|JQ9-P8wDbRcM+fAq0Tp zCU&Y=T3kw!WRU0G-uQLb-+&MnyPa}!TwMr7$x4RECbrYKxu z`tn21Kl}VU-u13G-1??#|Jgq|bnj=5KJxADPI}*bI-mc8%|HEt{7tvPcT40%P^Dg{ z8~xESlG=F(qG%YlmPM4v6h)z`Ns<8Q_Xoz9Ua#jh0PsF&+-w@Cw!|X!AsA*h2BH9G zoyp2TvL&2}*{oTcr~^b~=Je^^#$igj8!`+GIa&D%*D70BBgnY6;LP>rrg5n3W{{ zDk_EztyK8{sVEp)dk7jcOt0J7wPX8BhYnv7QLl}a-GG`}wG?^%q@;CJP1|s>OeR{I zUR#8q)gm0jd7H!`)!$mMsN3Bvr@awX0Z23^VAB{)qNp;UG-8ZAg0zupGrR+zhDrwg7&P5LhF=t7_OrZ|V6p^Xv&DY&{ z)3L*c7iMSkK`tUtHB93Z6H`;ulatf=pg(o&s^ibUc>Klvv&W7fJb2{OpZwImC!e|N zM}Fj*fBH|8vGEgMdC>bX@yy}5KmJ(ulmCmo^9L#GEcrZ1Y@QE@NCat;Iq#Dsao$DJ zAb}K!Ny&^cfQo2utQP}8w6a8sNKl2T)*F&BMo69aMwQ5@hUOJ!W@a*GndZlL(-l!N`)(ckz7g zt9?~0UxGm8#PQ?BU~v5C(S`Xr2{Jb~JLva`*;tz-X}8-giv0A+Q-gk=nbIU36nQ=v z7;8l&%Q|V6j!jI0@aDJNo^`ud?b^l0G{JXmtC1 zm2tVwR}tw&O=MO?uC&!~L>wC8K{g!is#<3bZ3$CFm1J4M%fkfG-rc(n967qKSw5?q zR#c2RrZ=M%+a94NA*#bKMRWNO3vbJ$p$BMXaA|~4*@$ZJa!MGD)(~b>+mNWLN|Tfx#E_?VtpLjksGriOKZ1Kd-PV(@vgWD{o2qzVbz#Jd|0sDbo9TbuP4zR!+Fb52P zC8?wnqc7)y6ToJtH%)XOI(0-3>km!ucx1;lpZL;~cYgfQi4XlS%-${zy0lZ-1d$;H%)a<{YWP`lwge2AgU0pQZvVGI#m&^cQNf4>Rl;faz&}qBCBYVHjpHK17c)rk|e4E zsI>`Evtw|zCm*v!^Na$CHAS9xyBz>&nu0h47mb1dn3ybub+y;Fa7A#DvrxM=Edi^E z$i-vLazrFJci^R$=4NK{LBGGaG<*8g{OoLz7i`!&m*;s1lIMd+REb$dMS?LldK|qE z52{_jCT8a5E{U|y0q97t`t#gv~#wUrUH*JXqIT7h(X^b4QhBs~7+MAl(x%cYl zuG;y+zGsfT@Z#)&!-r>1-uJmLJon_2Kk$xsT>X!J{JoS!QOd6Fh^R}^auRD0cS*6HMV z9zuwlDgkPkhzKewYz$k&5vj{D%@7*7cBvxPCwj4XvY{*B8qWUrcO2$MAW$?NfK+BSta-od`!aAO0in2d98I@ z!?BiSzWg{bwR!wpZx;nXp+Q0u|IxNsM4cLU=#GZ{#$FQ514Pv9!Ny#r$`BPOf`mq@ zO+7`xjd!GFEg&GV_S!wWF9R2e7z#;SrgXLVs!^*^<7g3t>WX-*-n^!!fsMf1EWe>; z6kXS?je??Cf`*r?M5`HU-%I6A!YT(D05+8*g9x`N5r(tHSDdoWmQB$YUT-NJnP+6Q zS(X`Nczt(EKMDK@@V6++?|cald)4^`bQ0=xCyQb;a4h#m5nV+4fxQ5L86X8xpbrQz z1th>M@Hns?*a^G{90U4wGWpX013OgjALQ2)?Vmfb`}xV&cDBBLYUdZ8d;I#j@3TAC zHJRJ@3fS5JwZ?|vRiu+;-g%oO&XqaxNM=KDV`F1^o@bpNL=b)7N#cDe5){D)O_DV2 zWQO^cx7|LybNln#HyxPh%^f&0d*bwy&pm(q$k97)yY0>IdiSXZA1F_rHcMsl=`ZNX zQ=5L`pUmytmKUDXa>5cq?8K@XcgZo<`rvJ1o%f;=RMdfp$kYjEo%F2nx-Nm;tA@!OOwPHmf%$*aS6YZs%j!k*%Tw)U zd5bZIZK5E+>&kX)6y92)j#OJpB<^swJc*BUa{?;=PgFrnylgM2&a5}GH^#78rX#4` z1ghHFi>78jG2TaYSx?u$*BTq#sL5)%tcvK?&6_q&O|Ey|v$l`{wEY*TxP_q@>!-^B zAMMN0YK6wUfmY~AeV1qgi6X92%tfiT7;xp$(dBgV5D9I!k%)Njk|b#?UbVMpMc5E3 zlTV8f}ZnsNJD;7dudIaFJvBF0H!7-!>mh!>m z_`;Ie#k_f}_w>Rde2Aw;Iud|`z>R>fuEI6I0pQs>UC9oh1P%ZbfCU6N4s?L)0aAVN z(9?HrzlPbqbN3DZ-*+GQz;8dd?YB>1qPK3(_`L$}T$-4;%^VSxr8CUVIS~y(;?&6d zu&}TYjjtjhu}SHJ5?t z@blYu-1+(&&A#VO9zVHx;O&>ciqmuBKljsvYj1?LUc^`ms--KLOzh^)IY14w_n{h& z00MYVFzI#4a0iXXf7D{?@m?WwfqEv30(&F;-+$A%vH{PW8BbO<!a7Z6#>E3G7VUuyZbdyJc0UqvDr5hH<1StXWe z1S9ED#)qerIJ@8ioyuLaW%lfFw9p@Nf+JS~ z8aM+Gund&I1aKAzz+qqpxB*xM089ZLV30H=1dztL!TFPmr}n+&z`=4`{-nL|(Bb(< z{swP&J#fQIaGGC1&1ND|4*)4rkpn5E(_@IVWFe(&W`hs4fJ}h_AHC9wwTc{B5iuL3 zLWn-{^z_`dH+{q2D=wegx%1c~Pni)=oBxq>@CvRD&Y#gVv0+DwA=uCZm$x-5OK*OLi|h)AgzynIb6@QLz2CIQ#W(7q2^k= zVl=AryYf6Y)_`MCmKA~BUh=9HXU&j*NZU*ALOPY zBBQM$6-D2Qanx*ba;aBq5^wq6vG^7F7wwKf0{fV04EUv2GO!gG0q20nfF5uFxL?2ruodW}?3+kx8Tv0y zJn^p{*>k1tymIF?cP=fx;=%)j>t2F${K{&ss`5MoBgUW&DQzON^UkQ+-&t!N2}G(a z3TD>E7^S74u2M#m3NA7$V+_Yg$`S{o5PUEu>+I;v%*@R1m_PKywiEyO#Nx3NEB*5G zhfg2unS(iT$ss}=J~9054^O`Df2v-8i=zo;w4o5Aj}eq$JJ%E;b8Y@h4VVBx$px4Q zN@=;}6(Mp^y5<)Zk@sF3BbmcW>jr#~QdL<>XeNY^=ea!iT5Ev75Z6~`5a~S6M${%I(Gc@@uRLPgAWoS*tUIJcVc2V z7!3P^(P%W$o0ypFks|LM5v(;KMq`c8h5$f_F&Nv~vTbV!q2KR^lyK-na8<=I7DXX@ zB&C$mM5MH4j?THNav=z%7l*^qxwGeH=VrHUn?HAEVcU)!yZ7$hvu}T=^HTW@)Kzd> zxfSwA#2Cx6BqD3AWc)S-tZVH^2rN{imO@iHIY5lp>v%R4m1euKI<+|%W{!YLDulFR zPV?ZpP)`cSfMZB0KS?&*gq%d1iGWCP15X3A_E7I0smvTUV1iDb@7ghc?Bq+5+}rR3 z4IDxHxu{K~Wn|<=|1tjgvpJ*GIvra7T!@S*p_uj_n+}v?5j`O@6GbEm&bY6*Hil73 zF^fTJkY|CJY5l{f*0DQah9cr>Os3QT03ZNKL_t(^{bZYRy}a|xOw3Blhl&9vX66uL zx7*3Gtc8wViaeSj0AL!}2>=9pCEopS=I}GG`PAxNM=y?MGVg8g@RkgV{atI=Gu116 zaHFCCmVq_k0I&#*fUUp+a2c={D1jB=A>iA9D}hB|9+*tmJpkx*%F3U-xbV>V<8Rn; z#apLle(&tz?>VEU`1-HCHS5;Y_BXEdOYhtk0S{}m?LY7&%f3hqe4u?e1u`|Xv z@4?Y@xi-;m4GORIL=@?@KPtVMCubbGud-sl=yPvr4{&P@u5Is0EYi&SqRXxOo5GB{w`^vpUOQTEL*8~>1 z6o@pfjW*g7+w)+QW?lZQxTL)=r4#{GSsp)h=1jD#3sj3-a@FJ8DfKR>^^x_a*H!ii%?uYSd~J9qDHX7Nqv`qV@L ziWFXv;3W}x?`yOXV;!YRaHRQdOtxlqyfYnM^PMp!SbqsNFk9;YK^r18I0p49o$C-m zRN`vZya{GzMA5rM03imc`+$gAyV`OfkQwSI0NheO5hAI(I3v_w36A6AHMJUnXPkE-F|fCoyF9@ zJcp^tukOrV28=N=1WB(AAxbqQMT!B@mgTvrs*;&|y&f}%*Z^ND%OcBilQLNVFmvT9 ztrP=3Mnq@we0uw~>!xqnv48*lcYWc^!%tj1dSYQz7C;|}z>bJ5i-VOv`Pk&*dG+4+ zj;7}`qkIfZ5lU-igi>_QMP_Y`Wc&$h8zU>NjI76E6xyS?OG9volHyBRYs4tq$+FBC zBYp}>*Y~`{Zp3Ou)pfEc1h2I=#)QCH8xhbLtCd1ge!U*eOVFNcop`nFNwrwfPQV}V_XgCT!WSO;DW~|N=EkQ)yJA??pW_Ihu zHloMB+u5~!{-y9edsYZCzR%MFIvso+jZRUWO98~j&0gaAu@MM1n{D1C zG3f{Dhzg_>4#yaUPgX6zk3N2Na0gX+x)`2y{K`%z)9R$w z`{!o*EB(0%eb(sHK1?UV;{tF1#>4Lb7J%!4n}Pd*Gr(csDqy~G904l80q1~iC7-LR zJv+8ObmEDdu6*5$>D+bXnRkUh1KtYUj9OIvRoD`3Mk)Ho5|Z%2Sz{$Mqm0%{3k_hc zRiwmeBgWXS5ko{`^1+PCxlX4Wf(I!uaa1PD_v||`w`I#SmtFqwJ$ElW^2FlBwSu_< z7I=?ja1MeU0*%yR{M2#eBkO5hDNzpqQL+bmys!G|lEX*LrB*d=(#nUxwPy}F=Rk1Y z6-6=V50(}eS65c9f6a|^TeiNyet02Gkus(R_3eqdIXih@o`+@{ljp5H!E=gxwaEXC z*P>0Cw2?|P7^RO|6I%+|HYj0S>@{t=xxSQO1~V(J?MBpwWhF@vmO060o4Kvc+0?`d zqSiWaJ<@HT-}VxDu+sXXFlfI<4Iz?o2%|NrKZ|8Zt9#p9ZgtqRgmuO!p$W$%48cN0 zK{YgujEs#J3=uV**(O@rhq2)p+B*%wi#}RTP#&C`C<#Fpi@jd2zH^@KzIt)(Nk9-S z0krs!@pnJFwD{CLue$U8@4oz%_o~S=tH+-?adx(2UBt-y();Zu>odI8Gt>FG#kFl@ zPasSH7B~yc1E=A40S;i`1aJVj3}D~_a1^*67y=4d1*U)=unH8w8pD^xoeM|z?Rmxi zt^4n}aOxe$7P8p~fjQvnuU0GqW)87VWCbb346hVI3{aX#BPtPG=*;>gq9;<4NaB6W zbHmKW7@zD=vn+Ft%CZ8;xd5$XP>sYBQ`6VH_Qu)W+n?UM`>DI{Upju~Q0Xe51UwKc zp1kkjF!=D~4}KtCbuFS%h9a{v%0-5cd7c+#VT=*Meh5L40?1cRYi*Q4aNaov#SkFX zCzNKWstQU`mRlbJh~@U~bhju&$6zYa{DtG9uCvLZZ5g zjcmmjv%y`hxf3{!FTErLx6eh;4c5g4LgOvgoOu1)OWNGb^xVw!CU$;0*>!{j)n)6L z7>I#5f|v->4S*W2l2bP^zyv4~pB6@w6FugEHcVy>545gx>Uc`?Q4RK#vwypI%G@ zJEpd(gO^S5);;$vpa1m-Keux3*xuRgy{&UD(l$m8oE;8t+C{sK-VSti-s$zu`3k@) zumdQPr|L;yA21IPa2R+3m<6r`0&pbd(fG7i2aJH-nZ0*ybwv2&@yFjVIraFd3#fjpa?`9*@fr;AEOhw5|~`+BxFO1q&hbUEKIYnnF*!pTcs!pQmU@P8->S} zXM|#m+8D9+AksF=F2C~No8S3uZ~fl)9DL(9#4S^Y2@eBL0;hnB6}v}|_CNIhbnp7? z1PbLzMWA8|5rolbL;y!t1VvB2c|gZP8~lU ztIE65yQ&zDh>&%%$>}MHV0XG*f!I}5dGCtRDDQMS-3g=uY?VY_7|aMECgzQa$YwT0 zE26Q+JFk_J0!UzvA$pgdAFa!>bj~^NMa>#xtiuW+QVNksotCnyBFFB;M2vAX8da53 zO1M5Eza9MTw5P6!L=&XUyEw5bw2r$5DU>k4_SOG2r z7JwDN1BZZZz-7P)m;rVH&j1-PNPaq3DRtb3BF1~q9ed;MgBI$4-0{@=|JOaVb;l;1 z=~rSSVp6CnXArbfAe~vGi9oJ$3;#M2t?4@0Hl>p0&z5jnV4fy z6vk+ogN(J#x!U1LDd)X4Ntn;<+}AzeH@j`#umUs!y4L?Ps)8_BU5QmW8V9ERNboJ!IQAQw>5up`ZPC`C7!nb{iC)XpAnw&7sfz_FQK z+9XE{yCnJ~Myc3mv~J%tGUL@#XTzX~RE3!Xn3+_)Q^^@7Qj()VwG>7P{%a_b6aXP2 zgis&+*16f)>8Z{18cC|rx)T7Y)lvh9#2_S7jmWHkAa5#RL0FOs-n8xqmVq0A*8#_X2S7KPt8O{?um9^6|MRvt|K8j^ zpIiLwqtEc-DJaa$Om%ymc=p1Rr_Y#(xgHtM3q+l6M~})_R;xe`09XTNfi=JZ0hk27 z3HSnV0k{u%J>Y<=fHS~JU~j5fbFwJ614kJj}ef^H!4zKD5aba-UlKWV>l3lo7``u zH9#Q-??aZ^IzSTwvtmVHMqrR8ZRd9Gdc$|TbLZvz@B8GZPCWeh!-Ha34C@&4OT*qr z|I(g5wdK9}HRau?|B4T0z8KhK}=2Ok74*BM*@63Y@|2&0-@0dtV4H_`75lx5lJbR-ie zcTTKbmzS2Gc%Hw5LKfZlgJcWL`(3#4Hq_C zzE(P1E2^@7_M)-oG+k2xCd?sOn>_2qZWCjvXbLHAOw#JN*L_V2;?!pvC1aGd%8-NqQ5^x3Z2^i4y%+ya_^R^Gt&G(+T=MztT_D}DP_B>;Sd^ zJAj=)2AofIZO)hFcanMJ!s*`RT8`hASOi0EJt!xX^d$NHk4&n=ot_jZNMCY*Vcd$IfxY37!uj3QrcJ(V@yeuF3XLK zX=PQS6=7xOLdplK+CagtA6j4P_H``sC0ctfX(q5|CvTa9_iM|`uBxi4>~uRJ#LQ+k z%e2mlFRZskJqMu=4NN|JS#UTp{|`| zdugk0^5)pa??WUa;FjojUBIQzt!tEk0a`OP)PM3(9ky$A%q9trva`mf#D*y*X zU;#J+ECK`IR+#tFG^W0#dfUxU-~7f;|H*Is^#k{P`h+W%fgIRbxf7>W_RUT0H|A-r zXtIapRWN%%CC9U!!0o`(0Dwtg1?T}oU;?-ZYy%=t0kgmmSOj{&dEhTk9eRCkA2@Xq zgeR95o;>`8>-ZpWA8^|S(a%>wGhK?|!dh{McMn*zVm12;#lTE%ZIV}-nq%mgw$9u}^W;z1QpKl}tQ{$BTe?}@Ly(U}ehpo|_dM)KY(QqFm; zm9<$2UK?YK_TEvQE)x}#(Z)F!g4a4jB3nc7RaHM_AxNeS>ZP6Zj4_;wjf-kZDXLtR zS!;~3#;gs8FVi)8d3N&^(l)Rf&-I1&pUsyq{VlCeFK^z(_AtecjxSTb4G{P7lkvfg`Qz>O_W{l4BT=cn|=CfGahK>cQ8?IMFcU_7m ziN=36XeP~7Xf{YhK1QmgA?v_tGmC4fJYI`1#sMHf8%@?R0GWQNmR6*LNe3Xm?RN5g zyLUfxGcL zCNoA$T6VJw0j!%xP(KJf0^9)10Y3yx0Xu-tCZ^;7Fr+Cv_3oei;cMS;@Bj7he(TRZ zy?Azck+B`vS-B$@7lY0?1F9MbOH#~kU=i30Tn~IYxxX(07lFOND}e`qGr(@(EHDM^ z1C9X)00o>Y%6puj1PrNfoZfQk^B1mtuf1ueG+@!<~;@Tp9p@QB~M_bV2>6 zKTx-w=-hhi+VmE!I~f9N5!oU{#K?7)12>{805Do}WEY*7BX}P=og6GNaUvp-l9WXu z1xL%O%Cam*&8ZkKGZ<{N77j)sMrQ9^Rh4Q}wGGeHzG{Wjm$oknL~zLxwmq?3`cZpp z1jOL`tIGg1sVvJHwpl4b_IVa4XtE#dX)o}`~y1fa=(vG-cEWGz2c&(MvI;I-X zWm&kYT3K2itPO^P(V#zYmGAfaMOkXCvpmx&7lVPwH8s)<%FQt|vvWR#7($TH%+k`* z($bQ|l_cGqnai>)H>pUY1YA;@i)t%O<)|ciEXy)UX_3}kf*4~}xw0%o9VQ+=I&GBF zlD3&%+Y@br05)9KW~Ss;+i)i|w2HhbsK|LQxja6xQ$7SvdRS^opQK$-ODQ5hZ;}Sn zX^u4tBCV6N+P7zCX6>f*fBSseC)I`soML3_5P5UYx4u~$#DIh^Awoo~2edI^B*YaG zYcYPfHsC_pDj?cAYX2O7s(o6=kK1}!!_4i{Gvfe_^mb8}Yinzx;ZUTBR_^Uo49I)$ zz00x;G~R_|^QeRuH>dw`6tKV>f$M-*1N(uaz^j3)QwiQV;2IFoHQ(^MU-^$e{lOo( zde59ETm(A6ZjYV7Oa&7oq+9?{0u^upcnrva*|evtfmPrba2_}aECCvbz!Bg{zyW7~ z3YZ6;3gJ8eVEeZHk1Z{S#gH!GS6f>=f8X-rT`E){cn@Y+gFHth4EtC)=SRzD;qNf? zsHPBA)JBO)LuoBxWtDuEy?5!(i_9zuDb7h|Ulf^CWG1bkh!v4m+L}nrgb+PPuZ*7B zx&52I>)mhvp?^7X?ZGFkz8^RQoMBv89r{20Tm1)rxMT5r4$mB8@(BT?Y=!bZ#292) zVX54ybhElpN=X$`8SsrYq!h;}0niXaQB?rSs*;*{QlusXZ|a&g(R&9#5oKAXv`AlH zj`p?1i{QD!E0=s>!wRfTeq8!7TE6nl9TJ&!x)Y>Q zZ}YRZPPU%!i6~h+6DYD2?P@d}AP_0atlcrc^~CATNUmN_OSDlbK&-SVI3l9Lcn%)- zkHliQEp4dQrEmjrn(l35kvhsgKEm-W3L=%9aGNhQ;kKq%$5$#{ zpb$b?7X7ug!C)YGg@}wXt#7e-_T*VcW2iI^xuLa-7u~i42LJ;400ADD1HQEt4H>_n z=>xC(xnKM#9{t`&|MvXJ88S^BW`D}9ec(LvA(|F}Qz|CJ}VVeHhp`$dj?p7P5s}u$d#98NA%;+9S)Q~^464H) z*4h{XQ*Az}wI(2hNQ5lQob!fs459KdLQ$T-;+EI$I!ciy+wFH2xALyZDH zeedw>nduL_FJArX$|$RC3=t|4DNwMvCa~5DQ4z>{50DR>Wmap7ENXdD$}+=MK^qMy ztt}w+hZ`qWt(0aK^&W(Y7uvU~LX4!eB500Z=S4QVZ5X+*e)Zh`s0}zS9rC29I*4C=B7!C%b!LS$= zqtU1=iefYxjfRpqBi^aZa?fe4O)Ywe;#P?eLoIF?V=1YNT~~f#PA->epz$F%??#-N+*p&7) zMbiUKWJkWNwJ`H4Q4*4)J9cIy8nY&HFpa>4#yC;eh7FA@DT8afTY5F8!-P|-=>+#oB!>1{P6dFVDEt| zi*Dy4@X)El*ZAt~`>vngxqa*0G>kUuhwn+C1m*w_YytKI7l6aSRzLwB@IVPH1J9)7 z8UO*9WxjCc$c}FJ$nDE~O$YSo=AHFdN?TjIK#YlA-tA3l1tKU7W6|j%>%e3v3KT>3 z?sVi+-c`$g-3xSz-iCn$rHtI{%+@!e>XiC1vrMc!T2bvAPzAk%eAP8 zl+xB(2`U-_OL~0(03ZNKL_t(-nBkm{F$(DmhEhf#5fM4>b;?f^$KgEB@;nC!EQkcg z+APbBHpbYO4V8WkVUg!&L@pg7+b`O~W%CV)o>7z{!vQ#Y@3pSwjl;oEDXN?+%Th-9 z-sF_ASz~y?F;-<+jEd#OrD1`3hd2((nKqzl_IT` zv9?*-ky!H)`4GGhWm$^o6*7RwAejeZrxrOXqe&}bvM|AunVk8CTi^b!AOErWn_v4> zW*z|+fKv{GvrFY4{z>(Rf3WTRl3^S22ns|9A?ha7t+hO=DlPV$t1HViPjppPS}U#V zl!X{%(HbjRaE2($Jm)I0L9*7?WNj21lCRh4eQ8=7PkhOB4_{J)gVrk(<)av5H5zGS zymL~N+-8|~mCZ7vwGUz2)~!YxW}cay8)Z2um07!Z@j`!XwJJ+-)~c#XX>Fo`Hri;h zMOR9RcUh>75TImwQ)!tCc<;-q8jVK7(MTjIGUmq`M32p&VvI2cS^32nL6q67LdDEM zM3+R7xv9v&^_pNax*audAq8@Et7E;d#S^iyD3!;)b&X_2+sr@>EU2MO2rkB`wIl#H zTW-aG&}4}=xB)GoNewZQn3XYZ&?5C{>e~TmyM@;4_(mroi+TY#jpSv#!9GOyLN5*&v38VmYN&UPQZ$XqMwC0B`B*HbzI2f$0tyNXY90^obRhH$(WMWXK2+mbi zQD&K)n3xa}1g%O*Scgb9rTsZ@5%?Ftw&dG>FF?R^<1LQy-=mAH7 zEx;781e^d(8yq_KOi7HRi`ZEKw*x=AsVmip!3z3^vEv&yZ<}96TUx?sgu$RP1OQ4S z1`tCL0wE^5;i=wq*)NG4DUH|&{_3(>l58SFVw4iQ^$kiG=l#`Bf~0f-q=-WB63J1i z?4mZBfZzj&0FFf44_^6gAAJ8KS0A|NZ|=BwVdXlYirBI0wtVu={>ifwA9!!L>blZq zK@JPVT#xP6+7QNTEv=PQ#S0-YM^Y+!FSa^L>llLY#MWju72Z>ktj(LHn$|{U5C)9V z$spn-Z(l=LPKy*E29dc)Bp%`fY>dSwVUecClv1_nrc#_Z ziRMs6kWp8uPO}u(5|DbHXh;;DWM%RQ`4A$rq@tmfUz#?%t`JOfi5o_Q(`cfThHJbK zCu;X$bLC|h;y#B)UD47bNGcN&Dr%-X)YpQWFJrwOEs_Rhv#?-uv<)(l!A5r9T%C=# zdcsCcUv20*sh7b(yI>7!vV=txrPRhym;63$iW=fdDJ2Fh+$2x7$;eC4L8E|fFi;4g zs>;D&*zfn9b9DxU_aTHl&qdY0l+D5;IZy%;aT7iA zZFnK>C2D&1o4@;Q4h#R=A1R#p$e{~j^PU4`p7fkLm$rH`oBa%hRYx1?LTE zj!c?jssIU6%po$2wg8MZ-g{y zoMQ}OtX^Q|TE8GuKC^0>uM4@oDcviphcOyZN(pbMwb-H{#bUB7vvzF7-T1*b^BJYs zjZE-$$pj(*-npu(YS6F|HP+~DJtZ)X+;I{-N?sfiIU%iiC-ow?epsU@V~mJ+()sB& zyx`<8R!?_I=|toxJ+4N}>5$~-n~Md<>;gbhO3sjK$PSDJeeyN24MPivv>^r6+%*tc zF%(0C2!2Uo!uPdSlzs7F@Iv;-Oo=I1|a(4G5SwJxmfB;ya3q&9SyMYdH8rTY0U=<+XGC%?I zsdDcUFaj(vLv*_0&yC7ER~MiB><}xv!259K4xIaa;NDd6{>8KfUm;CwaC3f;#FaqDCj$2u*{?2$3TbS$pm4Ui22r`NamTDGMFZnfkd3N)x?K7YG%)8$8uHCzL6Vb;$_Oa%DX8y%r z{KZ|nc6GbmTW`Jf>8GD=K3ZH{{J;l3Fg-mzJ3IR$Kk_5}et%Prq?wpEEKDf{W!kNc zMdT;GavWn>mi4Tul=HqfJ!SKJa%yU3c8-}V=a@O`bS9>zR##V6SC+hY+Gu9Z@=UU4 zjWNa=B63wF>;5`c$Do=i;o)%D?+=E%Wg-%n zKn7Na!>5lOd-&;R9(wYr<+U}87yW#0ap|#V4&C$6KR*7IRN9X~1pCMLQ=*UTdX{);7y*vTu=ctek=!>zB^5kw)6F@tU^h+NLv`?=%>w zoggi0)byH~w_CKzSjEzwhL@IC?*GR}KXd0jxBtWE&Rw{O1Vp^|Pd;<_Q=k9B-+%V5 zhaP=mQ~H11wV*as8^6Om4$!0rp#{WSaj`a};N(!(bYOe4&-0@7dfoS9(mBZ3a zP++1%VyvoaRE*a8YyJLeRXOiHz%g=F`Le7gCVE;MDYh3vsLC=%&a&*}nR6fd&%ggO zzwqyW@TdRneGfg_x`_NofBx|w`l+A&fuHz#3XV?JCz@e?a8%rW=R=?U$$vcce}2I+V|Xj@{lFK1i!baPpQ{}JE>CRG zy7ncffE_z_U^DuE&w*=?9#bby;@kx+F2~Nq{PgVp$?2WSTC%VmIL68fmM*x;Kj{2l zbj?$}ywqAX54jAUMr%swU82}ZtooFaJ2M0yV-Vh2E3LH!AW4(}i0b0s!q^4x#hY6x zrHv)h%G#*)mdp0v`oZse!}q;!b@z^YiJk_IG8TvB==Q%K{>E=lKKfARDqmDFc%?`I zoV4LYD)=C)BWCu_%c3u(??xFRLkN*$jG-Of9F0Z*ab%fj1l-pL|FX1yPAoDQ3~spL zhTs0}-`?>4ul?Gu{pN4}=7&H0;k)m?yVvWz;~noPl7jLBANatdk3M?)?YDpY;~)Rb zXFl^|KlWprbujHwuRTyU;~iRR1FTox#Tcrx^v+d932@%&OioTlAGB5zlat+v367D# zHnVxBYm5a)fVEcIXeM4=U6o`orB&X^Wi~B~GPW{5xUQ2IhQm==mLb&UtMUZ^));M! z)>_hS>cu^?%;#0*8kvO@yJ6Q@-vvbi(v}uxMHf+Cr zKOj*x8!$xsV9=Vq#H>YnURwRsGdGhul1YiUzf4X{Tz&8|h+BEu@zE2fj-Nbz?bTP_ zeBF&N{YGnB4hNp%20v)L$0@XhY|4tEC=b7R9Tyb(M6v-BAfdMn#YX zymXsTAo5z4;O$3j!wR8&b>s%{-n*(Ois9<&%CO&;WvF08fSq$$W;>lujc8*ej%7K_ zGTZHTLiGFg?EHcE-PS%kBKp|he)6wx|J09v@csYp=YIykd*1V&7kvpdunN2qcoQH+ zm}Qx>^a3y7)SjK+^>g3d*}HptuM>$sa_BL;va*X=r#ihOKm!&ifNOwjffZl~OaU2i z8aSRdbx^BrIwkt00KUC^vN%N>hr($D|h_We>;Q8zX3i1EG6)?`Rz+i0e9SS z2R5Vsue|2^$+=x${34!w8mCT#2Om82)H6rVUsx*&E()xzVQC5H&SBwn1zFoF-v zP{u@7AtDmn?!@)q{7v8b6F)rhx*HzK>{Gy5V8L_$(Pu{g@&Aq={lmHQ=esVTavXwI z#2kqbyt7%>C z=R4o|%fI}~?|ILA+HW%Rhd%V7U-*Szxb3#vuD|~Jk9_1Kr%#_2$o%-@kALD5pZJ~M z`JG#Cx#dl7ded+H)^GjsAOG>`)2Cm^zUT$_XfyGotFs|Mz7DTQ6N&PmKPZX<3~jWk z9WT(EoFt{BqKZ<=yQ;so5`wo`u9OPF7saSMF#$rBXU16X!)P#!QtW`aEGzH4B#AU@ zafyF7$0PHr9B}YH_~4zFO1$zN@5i8qTH?)_sj0m?cFfJp0AR55UVKk3EG^H^%}w=s z)|frpw*&b2$3Ole`#*Ks#y@0*uC&s1fMd*sG_8@83M`O|p%Q7-FdvG@TASs$5F|2# zQR*Cw7xXeujkyY}U(L5M2ej8 znFH!9CIAc^KXv-@1N-K;ZJnCzz2d5ao74ZyqOT)KPFX*>6F`jQxi-!yX8~h*U)}>i7Gj(V%jrh>eIy zfQWNduh+{mtF#g+igy)rwAS=`y&JB3#e4t7+i$+{)fh+FG&BFzC+_&3+rIsl*S_Y! z-dz9|78YLg5X8Vvfa;tL08qd?fvaA?Z|m;cdCP6z{jG1K9r@JGZDk0LulD;fYM={L zzz8@EOan{6!+-&9NT%;|K#`Jo0WA422TY}m8w-?xQ~<6*px*4yzvgZC{^lb`{`EO5 zJpk+g0`Qp^q;B~#+n1aIUiGS1VKe%F+xA^=dh0tnQ`_&m9}hl&6UX`V$?D{>{+ToW z!XhqQ#EE0-;fL_dGdOz+r%$@Y#nWZ^Y4Bfm@+Y(0nJk!0f;gI#m?e?03nCw3Nz3=X zcF9YM5Mzu|6l0JFzbHl_I2lg76DzYiO&1(u2wE$t+Q9_f$@W}#-8+ByhhF*aZ+~ib z@(aLW;C#Sfv0r}d6RW@R>+$1%Id%4Y$9shU4hlgN2M(k_iUT|6OGT`S6~*W)VsMDj z2M#fWXl*CYyVhn>b4vO?gy>VcjrTrAA2%sX|0Ua3oL=O}ks}KW3%A~StNb}LGjq!= zx7>BtT>$R7>#o_^*_&>wVzJN*hJ0EJ{~7v6`vM!h0t~Qp?41`&lB%kTQQ@3#{5HJz!ACE)e2M5z$`7Ix?`-!&^P-tVE9ZR( z-8`>Ni-`c-d+)t3y#Jr|60}Hu=|e?LPLd*$M9ms@=!EdbDngYM7}i>yL>Oa1Mp}>q z&`L=e1>M9`QUXgOPeGz&M7EJEM#dtK7JX6=F^xS*6C`TB*4$ccnne1c4R`9ZPM@|n z((bxZQC5}PGB*Q2X`Sc!ru0A3M1JX0kZ@ay$}n?`#A0=iBy?`w?yc84<@=@0rmNhN z_@EW{+3*;~Btu35YRyOWnyfxVw3i3zD%6E$hQqh;&X0#rw6Z@THG7d-@hHW{+7>-#TD%SpZ7 z^&foy-m70Xb_s;3#Tl@8YkH7ef z=~HL(stf@>MrK!5qtX>cF$%$p(*!swMKMJ2O3ti}k)zZAAtj4gS%NWhRaQd11Cl8B zGF)@uD=?2{VPOG)gbAhX*s(+2Tv%AxzI}W1zA2@c2lS@k% zn$@HtRaIq{=Vei3dB)6>)6;9KtAsk}FdB}SIrtztKUY;%QKAkCM5%br%szz5IUl@? z;LLSZ8fMm7HO1&TEiI+0%Xpd;i31?!W{SvrZ%iFxKYRA<3-ABuxdc=X?(60xA_c^{ z>>M*<6nxO6(aPdmW^b)EloHQ%sbChB3Lz-2E3Vb>K1pOaIg8Z2t+i50s@_PHs0AIk zk(#DS6zxuHXs}D~0Zy4dyk5%Cma4=k1ON%hYc|p*-T+Ab?oQqr-;JBp|0=h`<@(C~yTZ-Oc->(gMBi)Nf9C$ zV#1Q44Cm}^dECnJCkZmeb`9$`rx4d=h-o2ms=*J%Y z;zPp_hCoqbPo_ExOX08ns(BbwT-tb0s;EKM7Wmb7!gED)gVU55vpg3sF99gxur2oifnpTXoLI|5 zLSwgDFZHUj3L${N7#lOBW2S~_Xx=Q#vOVKU1>j4qrR+bc9?GScpgEFupHnMicKmm< zf@o=1MG8~@X-rz_qKUjT5{<|##bQE?Xi*&iocB@%yUyBe`JT!1Cvny$7Sq1U8xEM) zTcu(B%-YQEO=~!nCd$xkq}~6mn{CYWZc6{7C3!)ECN3rUIF*+h!xVYDzIL@ySWDU3 z?jjy1DUV0z8iG;dhr6-C&)%B`TXI}y zV&BQks=L3nm)HB=jRpu1`@Rz(L5ZR$QVS_rBZkA09X3P5&<{EML;hnq!j1_!B+ht5 zTOLU>BaNtqi%3ueNsu5&5K9By02{@#6esU4P%|Hr>Wae6+ z26TZwAUw}=z&sG-2V4NAfR1%xC9DF++jBPzts5pa9(BHa@NoLtF<>0n^VXxmz&T+0 zXJ==7`S`OUh9~%1wZ47Z-s^6>?fRSVx#5O~_k7^)^;>q=>VwKx2AgYcyye69f8^Ke z!&kk0DA<1hXV2imIi4Qx+TQ-e|26B!tF>7ZKpU0wMLaVrQ2wYA0Y)qDow)I&I&K{I zZJL1Kof8hMtOo#`vq_TV)G|>@Me&F!rI?Uf=Si*Ey8Xld^>1!{@SfL=J`PMW&h&jR z2%t1g&*&$9ko?IX$N%9^YlmMRuui3EsI-Vtq1b6qw#yQxh;tTTSE_R^$e$Tezu%7{ zSp!$9B-z`xpOw3(Xk%kz0LI71*R5M8?~IR+Uw{4e^3lY^L~*3Gc4lTqjxV=Lr6Qi~ zw`!NWMv5kDZ+UB5eo_8z39=wg5(1(qHi5B{&q8EO;EdJU1Yu~?R4EmN0efGq)kj8G zgSg-8Mg5+&PHV+lE2Vn99ucK!BEAi09T9=ytY!B7ezdT#kfw>O^VymkXS+#feIV7J z$q|TiWgcye^NIJF#7$;0OSz`m<@ijuO8hr2FDEOuMfND~aQuJ56cpz0a`!{llgv8; zuvc7=J4mvGqn8GQaQs)jsKg@Mfn1Y1*yD8p`3if;H4p_ zaxq?b&q@)N20EFG0>NcGs+c{qQ&|GJCn}f2mAgVoeTAZ*p1t?hIhQ196h%>##7QjG zl%&L$)`8aAn814<$1#}e^+phc#uy?_l31ekK@ikxbs|=3$>pegr5+v{05IQPST!;% z4wcEt$(wGv>77r(n~neDz$aE@y`@_9lb`*y=#T#FCEmPa(}|k50uz>Vw6>tVnzz{G3TmohRc78{_){c|4#vHtK=JVIz|0i!e`|{Mq z?wQj=x4#a&0sQ=1V5t;%1-KJvT=~`E%}l_RkH01jC}w!?m{p)EK|o3=tqfbQv~tc8 zsZdw8ZntkckjZM7*XF14V`Na{*$hpt~TyV;%&-RlgN_hKoL9b z6^Jdsq!fEj(?n}gKDE|4rF0P16d7jLx-26^a=R+6JbSIQm&HL5dq~}HW_U$JU_}FK zSKasNPj;gIv8SI8oOdakc7MZ~LH6EuJG$LgFTCiFp7MM5gty+}x9^H7RUL+@maGKr z*^*Yyc@-GRCe%uaXq)#wtW<285-B29N@*p!)g@QuPr3cf`9-#E+cq{fCiH0l?RNXQ z=bpRcjynL{amO8Vb94Lm@0X9h|NZZK?{B;9wiWr^!g^52sjv*PT>cL7Sb(+8IU9zR zN~Nl_VuI3{Hbzp^u>&#K7&9<9JUBF3t=5bQilT@~6s1Yh@Ah2kgyqodcKiJ(O%v;E zw>jTN001BWNkl{Kbl^7&yk;$R*j9>ZF1u7+dR z4i9Bv5d~}j27xz#*ML!A0yqy?AOS2Oi6{gN0Ttj9FbULwwLl28y+79O%mV#1om95X z{#SP2s$z9|-!vz6U=uI}Ft7m314&7ABm_RXBGDOX%S-@PV*Hah$(;>SH%d});k~!c zTkDlF%$@+F_0Z7ht+#*pLl6J@>ebi2awyn;0H@F3{CPilson4FPvgH0f*)0?^QM}z zf>)lEWuN(0eB zMn)d|wNH-Sc^`f~84FV$Z=XnG43ubMF_ z12W{DRYaUxVq)h-7|naHw072cW^FVB#so@flDvZV3XA+p`b9dO&aq?1_f`mFS@We5-d-7B;6^Mkzoh{Zxl>|%OX4w08cP9<47N#Z!}3$hpd;hdF>O06@=Cc!Inb92U+Mxzk~ zq0#}Myl0zw@5z`-z22nkQBX;ePE1|ONKq40C(oQ~)*EY9kNmRKem3|8mUb< zHa2#}OVGdy1ZYabx9Of=zW&wY&wei*UDLeS?WS>p9F9x_Jzx-M0X-lBJP-l{Km&*X z1#AM217`pOYyl#m2?WdldO$DjSetAP>vctc`qhK~`)9s7cvBPD0}v1aF>nmnool_m z`}VdbVD;+NSc&nM1=HGeF-}e7og+Y(ibw+xf`ticTX$WzX6=?&4nBS8&=04cYG1XR zx9&ikCWAw#>#fP4_S!)GBmHDkn$$g6vKFjLD*zF=-|qojsn&={>!7HCpcGkA7V%74 zdC#QCJ7+;eVDF_SaGD|rjCUM{#yQ6xL7<6w?Z!>_{mLi5*^Q38cBIPe`c_?<-Mwu? z;=S#5I;o9Z-*h{{)O7XKxp>oj0>%aco=RWtL4}C}}^{G#N>I+}^!awU5i`8w}izUar*;mSKnJH!O zgD?offQX_f8eKIi%Kyx1C9L#%-84=FFGu};YhWNrQvwQUvLsH{t>3iJo)3ahOsUHi zX?oqRO)V+XN(Vs@#W4s$5QwirqLq*UjdwoJuGCtSwX)mGxvQGUFWLs5?TLH+{;`}- zb8&JKz(BLPVa=MMR?9heX?ps?2XN)%zszheTEwO98I%y7e4PCUfO9Gaph{3( zwhkc?;<)fO6ll?B8lyf#G=Y)LP|+pvEM+C1raFEHR(U zJ}SSHzu@-#!hwTXP1K_&P5~HOv-+B=c5U0TiGkOS9JAJnExhva=Msw+fcH*o%3@Mk zgs6yap^R2?`exQ?fgQ-vuv`$cC-`zq28$(oE(^nDqp@V_7Y9&4q|9ATvXQK@IF8aZ zmb4~jw$_TQlh!&6LK7IJv~zBLe%?8^di82?iYQVHq-mO@DS=w8mI;EKL_{afocmw? zC=<8%i@*6YfCuls{a^pLpZ(;|e>jTcfB)zIrQ7WR_{vwla>Y}y!Yi$+RX_FHzaGEw zh5c=_wLN%hdfs}E)T+GrZw1&0oB$SpK|lj@KowXA3f2E954$sfJ?v_PzMs= z%tAl13Br1{T3a6uKKW;-KYrZ~1YZX>0~UA!`0P7?R;kpU`Uyw86BB@y7=L2|spsWA zYopnFsWRi4;XRRZ-VxxOmDmcvX_7Wuqc`97@Vbqg_dolCS6_Q$cFyj)3acVN((eon zAEMfLrE*80?@H`IN}8=ics-F~CeN1HRVp>D1$MKrz`gT}ih{^j8V9Ad0COQ1hB`~D zsZ>H^0%m6T*jnuwgw@+NKJpvC`t?8mkB3j3VTNjVs%I{&UpvwTbJVw~O`Y=HUUdFs zb9USuJ(g}i5Z-rhx_eJwX;rB@aHy3w#-)}>X-N!V4#Pl{nUo@C?@|Ylf3I{`msQF7 z|5|Ie+k=CH2M!!)Hk)`er^qrxSc0{5xtYAYF>`mJ%`Tmro|&7O4Z|>~glosfs*Q#$ z^VVAST&>rWIBv9>0|SGpwNjxMz|`dUrSs=TR;^x`pP!l>pPQNSc?sDhNqXIGk|eT4 zOl`_Q9K}hJq)94?={B{UZbuuDYE82)0dbPVaZ-qG2|G#UB?g?6f=uwQyDkKgUFiTa&UreRi13cwWd#;j*O9 zi9zxr$u2bl<2XqYdpQb68m6&MeLbR*68H&UlE|DL~ zcT|B+%E$wG)CRy}igK=Zo-baMTkb_WEnm0Re*Z_$T>1F_$A9;~4Gs*HxYDe3b`O*h zlJ}mWJhP%wRGab&c~~p~h^&eYkd^5wlTHeTY=<3dTrYxF@TYxCEFM_X9Hvr_WlO zrZ!Cz(T@^nVx1H51LUG0IXhLg+wF@NFRfm^c4%l&m?BCk=X|%@jiRVh2?qvR63QvK z(K&ru{+HJ_%U6beKl=3VeE!PE|4PpAmW|!XZ~g7R|IAU~ku3KKm z+%J7?7e+n++yq<=ya-$iRNu}oG6gi=sm}ddv@0JyIm2K4pZ}&-t>$nS#at7Sa~=dm zq?KaF*;A|7dMot-G@;X;dG+AahhBLKYJSfiY}|m65e%kG(UW?iX(12bngZXd$D#>fIN2Al@Q z0S30b9Tr)&GMBj$jWhim7XGzohIfn%6BCnT50KW2&$U*WAJnsIG*(@I^TT7CwmtjY z_YWREHaV5--hnv6@NlO&yf3I;2=%>T{pKWUrZ#{{*fKFlX?X<1?P`p%UfkglCjuaZ z40-k?kI&`HHMG{wdGEZ|8U$ypbKaOtMbj(VcI`C}{@SO$`&VB&I6mzGHQ!(FY-^xd zsWo+IeW$}6=M=e?uC7`&Iy!dgmDiI?MiwdY_1?CTB9Sn6*2YmZSQ|>yG>PY$t(KyOF*=Uo zxZju5l_ZXnB#EPlypCyA&KaaajO^+r}+VJw=!q^Yv06_%4WI;>W#bAfRH;$F`= zr-keZ5;c)DNmFOzI1yv%z31Et3SH7Od-fW-Y<`ei0xUI_Vw10I?B8zmmJD)X^_JJQ z&o-lDiJj#rNFE+#%m5coa3TA8{qTJcV3qm-upC3GTA}#qvSkOtqmi`6PM-I zmfar9JSZg}50|m8%m@+LJcw4la{p$c_3!W|eB0LV_XDHTG>xK2YZHbUC{c@vtc9zG zB^;)d?94KFQ4m^@7d8SDgGnhAt}Ns`zic8i=f{$p4Pf?yzzQCT1RSO0behIVB2^Bo zwT^RVn9p;qeV*_o{Wrz{Dox$=^sLrqaA2?~W|UD@~C2l~#}fZf16FaeALZD2Dn>ii}}|Mti}7585_edObx`bBKiz*gWf;OBsw zffi6-sjGMonoOj4f{Xhw^F46x38mbd0Vt4jUMh_ec@T6MY}#^lYiRAkSDrh1==u4n ziCuem!zPUM+|a7iwbs{y%AsoQL6cq+rHWxyCi4rejkR#z=36`R-euydvKDz!c6LP; zg3q0!#^|hSj1mMxQW@Jh2hRlhz^%9R`_cFQ=F4x)&Q%#$NH=q@vZlIr`_79;kEHEL z1-LZZyAYk;eaq0A2kxCa@>=|rM`_!^@V>jTdnc!gOb~$rG62#fC9SkpCJ53bao!oN zUGzTSi@e9JY!Xo3@Z}CP6fV4fjt!_*tKKF6;y6yzwBPGD2L=HoNy1>Iv^Lt>ls!kf zPf^tG_d5%1Ft_LCJbNMu-YczjVr`nHy>1W8Ixr-)ACoLM6-vpoVFD9Jv9(zkkG&_Y zopsKMRBPtS22hk`kteLEQy`9(A|h3U9OOt{s+qo0!NOuZOT)hWo!l*j!r`CwAuBCK z8ILv3{}k(3Fk_^vRM>b)(q&e;74#)z!=;}V#3m|gCFe~B3K*1Yx-N;ll)rvCE-4I~ zU#gN$r2>1!An;-pz3k5%sk}>lk;~h{LWjWBT2*VKC{5F(-|w4JlSwz)h_i%q>``*< zFbuWUN#Z6ZCX*x`8ygG4Q0G$aS*)|)Yc!jcN@X!OOGHJ4&b)-HgyJs(@jG1u z-bwpq;3BXQXs+N%L9}V}%^z6x_5JPL{ps`T23xPr&RXwnqk(Q8-YZ}|FrTwVMgR?r z1M@&1SOts$3fKmm2PT05zytF@yB|fV{mjPg-@kMYs|acbpn*>UCxJ0wEzr%ySVLe- zsZYm&?eBn1@*X$NQMD}c#01XKe-y`+FhssYc<+=lT1)gqgA@_iJ1`9mthw`!hc|EB zvj3SU4(va6aXh*DYD6&xMmj?yF9+3$uzFW5xG_yuIje}YP3>Z37=m+FeqYvSBFc;X zDp7OHq=s{{l$5go!81EAh4k2F6=W1VRA4@M=WTJn|KqPddSI@74PZL4H?yrxn@2Wo zo|v2KYW=iJtL@%}??1Ei)P-w5{Yyh}GXCU~^!Hy2Z@$jle)qz_Fe{Bv6A>8fy@RJz zxO5}|(D!DB-WOP;yy6#cmbTrLyYow^WKo-_eAt^btxXd3Wx~QR1bAV7et6ZYG)Zh~ zE7c0XK@fC1T@V)9?H~x#IG&rGWoA;)THDkbqmv|+I%>{Y0E#u0-22YC)Y(dzjsA85>#yCz=oBCY$qA-e{84TxKCd?|zJe=p_ptJ;+d&TKY%I{eVuc{>MeHRz@lQ<;+xDwWQ-9Oz5J4FVW{BA=H4>-ipyd; zB22#MLMUI0w6b0Wmfms&!YIC5?q_k%{8PN?P`vAwByq1tNs?5mm1?C5Db{7J&iT$l zlnH`BI3-5w0@dYk1k2D^+3UmkEth`+EV?~>5mPI|Ud63j#9WdjkvG^&_G5nQdheW# z<3vsp1VN6RR2T+YYir%))a3m9{Mgu7rBW$4F$L+>7}KcNl~P(Or4{8xk7&u&aT#Ya zGZ-sci9>Q+P6OAxv*VY5@}JO5ownbO181k2qYYeI*gHIMe74(L=oSZPU^{RexCHD5 zPUP<=z(t@1D4+@K0z6=V1egJw_d#k~o=0tR?wR?$51#`1yz2ziW=tNV)f2!lXav}D zSpnXkK_CL}tUOJgJ$WL^d>|k)T8lE1(4Hg$Zk;p6kjfpFT6r*g*$-AWZ{0IGI(F!l z1BYLFa^G_^yLVyJCQc$A8aeMjhYYrbdJ-5)CJAQinkN@wzKmXva|LU`ymk(b0@ehKtXGiXTWMSKuIDl3G zkw+L<=dDdh8EY-z2PrJP@u*gqt<>j6;$)lfiFf9uoD3!#qg!inqX_5w^6Q$Is z-&cy*v$d%Sbg$c;o1P&>S}E_{x{aIq-OkkHg!j&-DSMwLi4?aJb#~``97U9iih>aJ z`?8bEBkqu##()$u{dCVh6YUlTgls=KtIXmcaj25dobz2QN*jHpwNOo0$`%&OlTsw` zX2}?qOr5;r{Ss4M?je9Os+0m$#u#U9O5{r5semJy<0NN<6y6l?Ju#y!%3i`5i~Y<3 zSZ{e-lz~NIt&5(Qjdx*{QNmc4JBnn+i>to!=2B~eoco#DN*J0TFvd9Md~>D%BuOGm zq*(MEJV91ZXrnx3L9{#^Q@%8Lncc2Skw@<2;9T4`lYr)fGjIpT|sYw=J0eeLd2P%lz>A}IZ zx8L#b)=k^@J@?qbgGVMO)7^Uz_b@op8yG$iRL+ILeM;Q`j5w#59cv3u3MMZBk$WE{ z8IqaVX>CN=fwl6?&bu%Sk)w84tF@ANwI-8o14wyi5t`c`e!!;5^WS>>l}<#A%1oz1 zz7_aTyM7KBfcaNTaX8+B<^&1<1^M9EC`rrC*{)4{u`hh#{ z><*7a&g$6uOx|8;rI~$_ChyH0y}z)?GE-6PhvZXQzWUH*FS3)A|8(9jEOf%aSZi&X zGEj9ciuzjVh57k3iM!qI(D1N#{=%6v&bdmp5;huZ#>N2db-V06GBrT%b~@S^+0Xd} zXPtA_(jw7MG*}&Fu6~k&@>EbSGsr?lYf_Y2OIg&roH?@S_7N46%ZZudHb7orWu?Ym zPzdGPs^ybk_A41iD(0w!iU_&4popevZGfzBn#-+V#*%T43r9#UE>vKV@*W)}LPUu| z0q>>8grc0@TkdnYZ1fM-GGEU`*1~Tn9mt{vUD#Dckha@+mTp^FMP!Q*` za)Lqt1jYz>%D5n;6e;iB)YQzS@xhT%9%!|~AP@$L_w20g_j}ISfx&@-u1n(h$~s-< zgq3z9IY3{|VqJkY3jFFjK6vfhACfiQSo`4JW6ymhUc;lEnM<8cV5rr&)ah()HbbAp zu_vIB^H?_mBfw1lWebev8NW?n4(J07fB*&5fljmWoxeQw=NOy&kc`WMC%(mJlUw-8z)<$epPF* zvfe5WPl^}>K*_EnkApksqv?(iOlj$XTrL}ji(QMuG(MJ@~ z3y(c9(ZMDX8!EO&cFG>)gQiR`=>wM zetMt(!Bb|w%@5u0hQ`<`9l~g1Q}$Bw_q_s_?=LK}%%!o+1ag)^vuG0Xpv~f*__D1M zD@C;%rAIDyiF5acoPmg-mb+CHDJC+xngKHlKhzi_ zA%F~EG26n8!CbgWDUZ<<(VPNQC`Itd9J@r4fXAh(yyb3`eH*lxyNd!*p#)iqPm2MU zUoW3zr6xkkC>Fmfh$Kl8$*hqaSF=<=#h2vrN+7MsdKJUISVIRHDHX_bm5cM_*pZ5; zM{&IXEgqAHMZ_0UlmsFoZM0BBGGP!R=j`;<%%w}Mp`p$|tCoGL#N>F%eQ!3K)oL{_ zNJP1hC(Dy79%{*_ST@v!gJeawz7$>MQ-|Z%&--9zU_{ z2fM)Z^upv!=fwD#!#`U8v4_sx_&<&WJ0AK;F6DpO#zI^z$qEp_VD`>uVxxjk#SKaz z_Dq^2fKnvfK<;@0fjv9NJTN?Z>m84*-?VlAbB`Z<<;cXi-M$Om2%{t2!QmIe%EchO zCD1n|(XfZIS~Ghl=?^nIp;*Zl6gg9^sN5-#Jl{J}zHt(zc2ST;Uh`blhg$di!p|9P ze*EaSUs~vaf%$~2TGfo)zJ0Cs?8hH?=+HG+zw*RWr(ZcV9mTVcesALC!@KUgcj(qT zddH4dzxf?~*PY$XTb(oBS$HU|K;_u$Pq)1d;O;h$hE6AP^DOi?i*>y^}(KNNpFh;x7JMV)aw6-smWw_+)=2BdVvV7E~k*TG2 zopO$aDsmsMxY1>~yTIZ|X7sLX%&BbcfXngUlJDmS5J0L_{I4+fK@bQdl9`p(CU=&& zQev?9fe0w7<#EYLpASia-WGir1vMe-QYo%fb~qL9mwCYjI$37^QGzuqw-98>JG3ZM zMmDcAC;o;a{iG1o=SAe2B^2b&3ppi_>*SVEWBJlhdcN|Taq+727mKbDp)}dld7stm zGC?2?51AwByiM)Q%=E;>#K2%WI9RPzD@6f3?>S9vnx?f{rO~Kqqm4GXYe$$O$fJQd z#^NQAtLzk6IY{0I`hWvOB-8;0xCr!s-B*0_aOlRdtIga?exkW{^M=lmh-ljA_08sq z+4&S40X0AYTY(OsfGxm!pbd-zr-2DzE3g%q&*4%XI2FZncoY9n1y}_{uNmO+jbET>8vQp!0;nw)1vq=`IOL*=`mLJCN{woF=iYrT}S zfg<9d(Y)=E4>PduTaUjyw_pM8dau>?EgO3$Pg3-?s~`I4rr-R`t1rH={|7%jc;?dl znM;#@^AB70Y~FLrO*Gq1fB2(x&p2QA!FXU$G6mTC_iQ@f7g(gcVMS@_e^Vn@GR(4D zUZgR;)xp(Tt+4t@ng&6brfFEIFmv4NPft#au3ojU(2o24*5F{j+mj7?r@hecbSt&0 zF{V8?-&t6Q`%x4{QutSvW>QKS%~Ax85XXruq0Tvx5h=Fv-upC7o%bH>)3oq)%X*(( zG605izOZx4JP=f>Lz^$tE3+C?uIyQK1R0Q6GTHznzq(8v#aqA;E*T7;@4V$5rIay2 z`9i4Rt}6xak%tVdwM7CmBdcm(&>g50A<9ds$^Ec|g<8h7WqVw_D4(!M@hDDScpxsn zQeL6)U%h&jvo?w&mu1CfF<~YqMVXJp1llO2bzn?ULwB*z&r&q+nMqMG;Dtv={2gTk zeEIkk_dq#hBOysAHM_j`-Wy{om5MP&d>%?Eh6f{x`ZF`L^Ye49R&!vWQmfU1up<3r zW@~K}MOv#?t7(kUO0v9_7B4-apzP#hTMpKMOIWy!sIIuxfq`6*oq_Yf7GUE_om^vE z1*ZUu=B8DRv#Q%aL)58;n}!Eyt{vr(z5p1`dtiV;sYC)*&RYw13s#QmCy5-?bo347{x$nGs=#9zA{_b6f`WPBn z7#x1dRWDZbU9H-k-L#sdmZ$=+nT4lC%fnm?>`FRnIS!lP}duLsmq=Gaj#wX&aABJHZ zM~*%6&0Lx!K2P^btyNm-d>5{biIZ5CNzWXHVH8DTSdutN(^O!-cRmLqDA<3@td#Q3 zDkUseE-y5NwU&R&B$AcW7s*01#ZP%(R=X;W$wFhuQBYyj%lqtdw+rh=g*nenT>-Wv zc2?{yGTfHCKqPTamzqeG6hJQj*~NXlQdvbeF@A;fU>RGp=%@6g$R#QIRz@Mk)s_4Z zE4B(W1_r|*NRuRr<2Z_vBz9@yy%&iPWDHiPtRf;2B`y9b11~_fi2ztFDZsJZaxa^& z;?MFB$>ocPh$Jg{=i?;RCTKKTK@bq>Ja$STX78hZG(9uj??;VBb6{YgR;!sH$f}Dm zJLlrKPvo1;rZGl>Gcuo2W+!){mDxdD?!Q3N#VYD6+^WFyz^4DAY zz0qPECu&wJR}Br$&drZ|PV+;1!0Eg(x;fIbyA~^$too@7Y6> zB!Vp>=P(S@)BH zZ~p4)YxlnT-S53}^u$azTKM)8dnT{lbN4;rrHgal`3~K6S3I&#YktqT$nQHWf~9*P zWNZT}g^w2x%NMM&*)Co#E@8%)p^?$^r%wV`TBg9&lN`(&RJZGsQIS}C@ z=$_iNxT3;xmp6!oK_#_F0$9Q2Se%+mkpva-jvQEs2a=2YdoBf--r}@*vPpJb%pmq& zXNyaA9zj=yMkkjDm7-cfL=vYk#z>BzEK;JFFWRlS|K2-?WgVkZZcY*U<)wMN1;{|o zY%SaAGJT|c{E7^Iy;e6`8Dqjq#W$PI+9Zk!F%Rc0n4NQ?hwYS;b-M726fBKmtpvn5 zlm$1l3C^KL@w>$Za)}UA1|kIlP^3UmN>{3Nt+mvAcg_Vt;Jp)J>wdpKH#Zl@aiiX7 zwFc_-Mi>U7b;iujyCg}x_svXAq)ZVm`uvuAivp^apNo~d|NDSQXs=$ulD3OY51>Lw zGzeI`2@7Y2I{mAFV??K_;l`o*;B5C8LsY98z*YJ8q|#j-7zO|YKnrldFkykSch&*N z^A#xu&Uno9x}z6gCJOd6s}Ht&UuS557y94-@wcx%_hM!9t;-kFfAN;NLC8CA*>PUw zAjsUHvhRW9kK~$tO4P2w5dVjOVg^BWAOJw#dj;i~iHYG9+h(nG{Y?+7S-<(k7k+T~ z@GDbO@%G(V6Juzw-)tQWs~5uBz0K;KoemU*MB3Suy(2P8X>jI!lBS6jOpR%X1r$qBG<_;wWWYE zS4Sxg4oax8xDATSlr-}&3@VkX42%4mV@JeE-0Srg78bnswOXy!8m!mrm9Qekm<0cc zW_+X32*XMthE}{Nx|f0AoStG#K&7X~Gkfnyh^}e{r(iZujad&QK&AB2F~H=E(s$cd z?Ya8q?fafM$^cNq+Rdu_Mw77%I6`!$S|4fHjh(m;Tr%1-YnNG=M(G?Ouomz@1hi@x z?*YIFFbs?U(*S@JI1fA%Cm-VkAAguy-FyDsV<%=hF9Wllaqj$yFMnn4=WqRIKoRG0 zX|nBXFYYCCFS*Ch!-Ii+K!@A?3+JzBSQf8Mk!DU=Y3$$P_8k?3{vUtB4V-9ozBXhgZGv+V)poe){=+7k2OPTect? z@y+H$)%|0wcDz;pu=QIKTXSHo6-blRRq)<>$Lv{YfJ|P|x>5;~B-KWz){0IyI}%BI zWOXt!Yh^iA1QS-Sx#RZ6@W|s|`s&fwkM^v;_S~iTOJBYE;d@u#e*gT-``S}e&5wN) zo44Nj(MLA#xoZD+A3yTq%kwj{bKm;W?mb&}d}2d*@HO7Pt=szPmZ2%y`vQyngk5#1 zQ8|xPzPHpKEPuSpwJIvLT63V~Z5kO}RkdEXTdmh?je4iOV8XyU%gjO|ku|+isl-Vf zC$TnKDRLlY1VJF?&{-=9w_zAsXOlP)v2EE*M^Tg{DQAoa_W7#Hr449i9vDR;rO4?} zp&(MK2~su;#lBGfE!dP-*v7}lw{6=dOah=_;VcGX^3E(VUCXB@?^rheC8q+FEgwKx zHY@|sdEx|e+g8}8N~Kb+K`%oEQT9{{Ia{?1eR6C{l37>uwurnGW}8ZWf-)j0kMlCH zRYooH=1Or_jW(5P)r5iMcG)y_sgpvSS}pl zfG%JGMX2=wfPi6O0N4t&0g3XQ0=}DI$7FBkh1uY?YfSBl26Ym~1z==8Pe&oOT_>P}{WcMdN zV;=i^`{*}o_kRR?c5J=ss-evrUw{7TBaeOW@R>{9*G|n%{MA+0?QC8+*S_|;6`6v! zZSM;#@(#9`RJM!7ySZH}KM(n*yyR`A)bQx4PJ6)^I~d+b2<6Z`7T2-u0YwK@eK!MCZ;qXVWw$GR8RXY-&lVup)ceMUxO=UjDk**<=yXlN4?6I-`#%?FT$I8sVrl96AsjegU%%n|aY zA7z=MU;&Gi6>Jj%W0tlm7btNqt#w|5Ez6^^)^e^XSBPvdF9y7d;Rk#fv2h-4DKLcm z(6R%HR(w>3FGb(p^=Mz-h&V9XunM&Cfw!Tkom#2eteKhFXpOMKK&{Tgk`pu{prN4G zNPZUJ%6>$FU{rFSl%pfa)2FSq-EI^`eIgR)R1gHl1VmayVgPVnVBK14Z5qW<)Q_C= zS{to&wOVa7>Xk}G>wp;y5*n7ZwpOdxYE`X`bf6qpS~eB{lLv^55>2lqL2-fW@^a;7 zpwJ6>5x5aZfMa=KnyhH^75?Jr4fp=)-B16;4;KIcRSdUqu@6A5q^(qKpfMB2m}_s< z3W1rY^!(E2%;mZxLm|NfDHBiy?gn~57kC{2kOI#GGYh>B{^Pel`t0Ge^U+hBmCJjx z#>~LP^z_t)iN~LQ{>Z+wCk~!^{`{HV+(H~%&j2<6tAH372aWb2|df9RJ^ys`Vh{wJP&?%b~3ylpFN%r2cm>ziSCqF%W-b$gu(*auF5 z*|D|4R8@IhanUAFMlrL^vVnY2WSW^%YfWGjsUQdv8wJLI0cJyb%Z?qbfAyRD)_(8x zA3SwvW`4o>g-5>?&(G|>_an)n1HJEleQ@^H=$4xs0|PhT|M1wZU9Ud=`0;06T$pJu z{P@KkCr|O|<0~`?Z`0lvSfp$KmbeWHmjI;f$Rax={|XfuG-b!~QZty{j?ICAYONOa zx=E7CZa7XPM?)*6f-s~^r`#E>!CbG`=jZ0bN+k$_K9LE6G)=>>lEg`|2ld{QqQC^~ z;k;v?aZasuvdre8P5{uxFqpiz&UwGs+bk|1R=;#%#bp*lp_H=LisEWvR90jPjvYUK z^)**F8%->x@(RuoR8gLzC5*yl(6Hzt5{JbTDJCgng`Qw;^r1DSFN0Pn4c-^dgcffZV8Qn}Yl_@~$F zTbuTJy-uf3M73JA*=&Si7=|H{FngFii|n+xVUi??qJC-}0YP8@)N0jwyvEON-3>Pxi96L1H}`N-!;sf@dL7FqA023mfc!c(1zrv01b3=wrIKa zfHtu1UH<^pR$cw;zp?eDFP>^MXcmo)pb5p;2^;|;U{dRm;Q`x;x(cXZpfWrFbdsc# z`VDK=r%`liZnCP)jiX~wJage}2-^o{fY*TkzNuW_Uv!uNLLdcR2VRfjZ=OD`fG7_; zrA0)SnfauDJvuqQfB%>FpMUD9=g%HJJ>Q9(XTSgvpmTZ(0pq|K;4Cl-Y$_?P487~& zSlV8jJ~d_L&iV5@!yS97yGQM6(+`P$IEUiQLg5UIYf#Sl+gKefgH)Bak7SZ zmPDHzv&grYl%x%_N2;p9;8h>EW7V3C2VQ*QjU%s2O?LKPg|#Vc6b%f$Y$|7h@J?O5 zlilimEVbB;cg%_aQlywg9F{24ftANgGU1fi0uhF1lDZ;>NI7=eXy>gZZmu1@@0WkE zHMZ*2$G>;v#QA>e`%gYQ^V+c+9=U%os6|gbgN1hOuKS|qz~(JGSN*FEr$2bZ(QkeC zrQ^r@bF=GT?XS=zyiI#wV3D%jEiX*P>#Q;<v9b2t zoHiPs(=_$YCD}@?<0#U(`h}z&rb!YQvoPOQIFPT#tBa=275 z&)QU?Hf4550Yqf@c~RpeQ?gnTd@ZHy7qgbn;Yu<0Bpxyjybe4F)PN?C`_}=WamAHy zsk&kGfj#sW&jT1n)1#%S?JN+8zB{R2wPq^SaljHj0IC85wFu2YOqDzg5llJ(v!3THOuWE3eQjh~2z~tG3NCieTSUu!_T7i`!MlS!uAO&r-)Gp8} z^PNy$RX{?!PBtT&2vSyBty{PC;gQdrICUZpbO?oy=%?Jv3=k8_W74z?{xcf6I0#4`^MGx+_CwZ>uQ&#(gQEfU9&e@zb@33?YG{z zdh^DU&+I$;{JwrOz{U5%HS)f|B5&H3fRfDk$-l+Qm2H3v%dz~6j3p5q=GM^A!0@n0 zB?$Qs8EsRliN=!uQYd80s@d=LDOba+)GD=lEwv(jO(qCjR)5#q)GDRC&m_7TaD7)0 zQHASJ^i5c?0F+WTPwS8a#KM&?UuEU-NbIrr39`V=%F*|Z967pY_wH7!MT-f&WnV~U zq|1cR{Mla2JwfhrC?=w8@^Kk1S#;u|(ciLzBu&#W427~&_D>XN6y}N6 znKZj(k(9AZ(et7M1qvxc!16nCfcL(v1y;PjQhuqhQmuwzoWxU86SK40m>>u$l}cEx z*6NLVwNf>Kk$h$Y=0cX9QZBfy!7d3OEV8 zam|Cg`FWfHK*QKn!;#KFidOD~i2x7{<|^+1hzx3*45_VzZH-|7*olF$t7}J}t;|m- zpbxyxcyub7RouxVDcb-5gFpv31vns(hq;gM@7wpqPdxVe>ErWByy&t8c9%qFt0m8e z2V$T#QeCsLxs^7oY4NHXfsp`sWCMmawC8U9qyP1vH_~s~UPY2%qSs$&MYDtL3(d)+ z>iCV}ja#c*DRr={tky~c#OyUGCt^0hL4*=W^dTW?t;}ql1AC>& zfS_~`H1_PdY3;hrhYvpW`YS)4m~LNv4c4wflEgH0xH;T6dcvri`sr}$+AghnPews& zEqhL>^iha|%StGpviC~qAduauGDb_G8zS<|inO&ZG}UcaT{Ai~dT8r2uRXKxwX+wa zD4u!z$vs=vZyjxp)euizbhq4qO*_4546NUL^QYFIyXnS5-~K-E|6`FAZI>H^a?AIi zh5sBS9^O*_L3WnnwD}thrPTV(n`{zy+HIv&nx+Km^?H;+fs9)a$FbJBTC29_=4B%a zLcf=IX3x%;prAE4o8{wpCu|dzN=1|j^<>;s(NFN+ffn_|%9kl_o-k0UwdL@E_#S!D zE-r@rvyWD&9twb7uQxe4H83!M+#^yBzfjpQytNG7G6PcvEAo*%w73kE006<~o{93# zxj0FI(xf(_*1BN+W~U`mq?xlwZH|zrtapwa*9uZu#+@wwEDkQrCucK9Z`uDVXvPH9 zTGa$u;bkcxkR(aB)0>={R7L)-QbDzn*QrtPP?SlU<%R9oS?Ae%=kwAwQIe!_91~HR zCPKlM(UTfLf@_sh#)$t(1|GFq=$x}Q6>6{ZHchN^)_bq=gdOWrrKnP^RWpwW0a@Wd z=iscbH|o`DRclE1i#V6u94I~YRJu>NgiDCXFJY-Kfs!kQ1#{yoHF4*2QLznIkl*_# zPywca4ln_%0}jJ?!)H+gfF7U`?8fLpT(WC`d7uXbz-nN90R^gr)h!qm0hfRs@@5Si ze|6V&kM8PDOb$Ap1r`t0>cyulXO{|qfEKVb z>(ElqkI`_Rm^UiAe#@qh{Wp7t%{^z67kRbYz4aGx?ZXPKOD}!{fAnrgsMKmlRe#3w zHbi55aiO;`6t@REXK-p~u=B>?hRxVQUU_)-1P`r9YvsIS?+Mxo3=!;FS~hYaY-Y}U zAKPyte6QZXBA@H9rKvT>IOmknHt|L)3*Q=B zd+RTJbp5Wahko?zsTU8<&UHJd&QG1et_zno?cMqRviGLZmL*qt;I|{raK|_1%lBT+ z^HiBNNmV7OR3$(v2{i~BA!D!A7`Y7#j3gEkw40&vT8$g2VBtlp?Y0(RgTZZsXbEg1 zl`sZFl~iL^X5~C*Ep!M4X5( zzP)0O<1PEEI7CqD+>fussh> zl(W-GzBqCf4kiHQN^N9(Rjb)b;;2+E&o|~2Q4~c=QFE~wmcnMU8MmWyrRfkcDeD9dNPEdrTX}-$m=pZHWgdD)Ynb zp-=L{%ob@#E&!!Sq&ZV%&u)sIGMQ9lF*wX@jW|wZ?x-2Gk|>gsAmAcU1BQWFzyb=m1u)|rU^C~_?LY+xfZNEQ z8Bse$$?@q!XMgYKFBAS|-n5y~H}YR;XlxDinfdEW&-)I_QxCuQ$mx?;_TNfI9X4Zb z#5Nb_=j)5}eT&z^%R9sEyXy}PBqJ1)B4yYTLsnw!ST#hh82|tv07*naR4MJ8W45U* z0?3(^|DbH*CsK|r@|2$h>#RV0C&^_<3ubZ7d5U~5+_-u7$mptLhh9B#8-aO%EoXPPq&p8JLQX-yXC17D;ejcPuY{>UXJI73@z>G(CXiBtLxXo!^W9})a`MX6 ztLxUT1CS#MN^{W2@7^%up5Mi{MgcM0Y1$|vm5v33*-;t`=N!S4&{P2p@O=m)l8U7> zb0Lq6a}JWlyI`RZ9LJgJfGppUd&w4N!{W2$)`a|b{+hW@?s83swOUoH6jzBEMP8~} zt>!l>_Me=#$*ZoTY*wgJ=Q^<}N-1MZ5ClO`>R~A;GkE18Ir&|zwagB1`Bmk4#D_Wz z!!QhkAk6S9=e9_3eHC$7c{1VBk-A`rZsr|X4H9|Yj6N)W=BXdz5)^xPWf&L+wgOKA z0Ga?nC=6TxG_dx~uHZ6bhz0(t14JBP00tVse*r~e0TS3Z2X7h`U=F3sGL*V$jPzq* zGxVw@>H2_O0BFrqKl#`{iT=ZH{wrrJfC1oIap4851{Q%!KnUCbW`OMgWf3g<|z(1<=_HyMuwi^>W$XbC(lX4srlY?SyEn8oO>{Q|s`3jjCutab!O#`a6r<5jA zjwCf8GZB*u`s=&j|M%yu&778sG#LGKQQi*Q6n<<;xg$L;p~Ttj4AV4VlJ7%C=XSfz%v!4`iY4n^I#r7j29r{qEU(2#kbJ2v zf6CbHdmd%dpIWCG)pMge08-S~-#<7sv@8{$))e#MLxU&P!c7@!}R2aW*W1T1h1xQLs;OX(>gV4*BVfCWGUb)ZJ*?+1-Tuju3`N6hLTSr%}+_UA({==^xzj$SKI&y0fufa^yE(|tq^|vQ# zH(xiW_XH1YF6}JqvWwZX+Ebc^J0rj{2x)HzlOo6I5Y1rgSSiZ<+`%A`cLE@ZW}I^j z$Ck5!g4hyKI6AiVsSl4FKK|F!|U$b zb^6tPR}UY)Idx-!b&e#*Qh_{>NltrSzGT$eD<)`7 zBN4PJl}jr|R_JAlqshy}j zx~Jz}H`u!=BO@!>nJ8-KPD?^L$TJ6i;MnErDV%zST4pEiq9S)D_LltpBwj%JGi5pF zq%}oTCyHW#M5Y>mn1?cSm4fN~`^)VzAXLf~vF~`Er?tmfjF0HS^!4?5zORc8s+s9k zr5cpPNEiIfoI5G^EJZ}Wfw}9;E&eNukY%ZV;CF%d0DFLq00G|vTn83`Q9$*KGe8W) zKnoZGB47b{2_WDK@H9Yp-r>u@&j7ywMG!y%IDG zi~@Se9dS{>#2^r?l~~$v)B6AUi~oGx#_j*^OaJGoE7O`;LUM+I8K4QA0#*a-f%8BN zTmseuA+Q=40x;Zn)h}7e6ExtpXBxd+|8hD+y-6XbG}B;ppt|G1wHr6>KK=Sj2VOdJ z=4$hr#X7`m_{MO%U5^?=jSJ-)_o)l_mv)bNYrLqIILolgX-eZ6pp=)7R1#myfFfnd zG9bY?!nqNMSrY$>$rcI%4y@LiU80l&5fp{h`or&jV$JG}FMadtd-t8%w#BVq3zML~ z-*9;*@Eh7c%Q&EEbr|jm^akjWR+NA>ConD{MQM;E!#QUy5h-g7vV@T==1=PsDMmV* zIBR|1hfj`Z{eAbXSi5fOp?95ob^pQFPu-~c-?M3bd16w37uF^_t9fZNq@NlVAGRvyCB^7ny!o~6Nair)Wt?-`KS-MU|0c}vB$*5ad zym-n|Y9!y=aSh3-FPXM1D@CGmDE>ORr3D2m59N7mvq07yujG?iTG9-?$dPbPpA?_U zWIn~{Hi9hI>bz2^RV#tDHjbkxirej$sLhInPRw?xrHPpcTI>G)Ix>?ca|bSDAQBlf z!p=$J9w$VXF(%`gI!?;WEW)-~-MBm{0TC&sjj_fgp67*ODF{NXmFH>kmonB`37ILC zE7gkDT6J0{U50j2G-t99$RDx03w3}7<$WfbEwY0%dvS0ULmM;3f$82=JG{(|}1O+XLV-@B%Q=xefuFfI+A_2J2Ecx4T_h zYO?PqfgP*!jX`0DvIE!xTm@!;L0}L# z1@r?OnXVHIaFqzYUnPJPsss(RV2vdU1wa$*y+#;D-t%Y`D=-OOg<2=8<)!+PJ>5)-8t`kq(L@Yxqzv%2Gu6WK`Xc15# zW_H#}c0I|+K}emW*)f!SP-LAYD1tW5IOjYaXs5=;H-7YEKlc2y&m2Fxx801lY=X0> z4@7nL1m_vsz~XaVR0> zY3E!V#oG6jr`pzd_3HSp?IRo3Po6z{=Fow^Oz6oU`r*M=6V0~?Grohc$Zbn;tjWoP z{NE)b(VGlS#kr7~helRfYbUQ>bRowp1#$noUZLi4-T1W-m_(h9n`PR;%S4 z3+It%-$h2?YtM7c)|kYY{Eh%5fr!>xdLE0_Jku^CBG30lo6_^N)}9~u1S-(%+V}l> zUtg_OBSqwvm#GGTGiT54-hE$RUtjJoobw_@w7~@~CkIj;=Y~6&X^M16&Vuw%CTfYo zeR?9nv50Db*|KIWNl6M<)0qh=2O_zpfLWxvkVBIK!bnF2=UA!qMO+F~QY%IgQFT`Q z%Tz>fh6rI;3ByvoUSmd*#3DEw$FZbCvTnX7FOR88N2h(+I<`R4Qp5WG)~oV`wD%Xti7}r@S301tqfFoci)* z$VjLuhRgwZXJBRqD@pm==|7ymUEXlZSnY-KRbVpHHT`kmk=r9}6c!AofNug*Kn*wzELk_yfVb*+_^3RP2dK?mMrR#v+PdopcbuB2)UV&V;eaW0 ztSc6{0Bi%sfCV4{7+3?8f$NKnBn*IR6Euq`2Il)KC|3X*R#ba&p%k}<%Vi47mB>;Q zqt))U<1AlsU^oIpkz&PK`=cwypL+j_om+P7J9uE<$)nTz=gnF+Yhe~_dw6cHuX(fH zxa42kk?B1JOUXTx8sO3v6GNqkW+r(+r&DyT9ZrjdMaxjz{WXFj01bx^As6ks)Xwvx_^Af zwyDX<%ZW`kZHwaM&h@&S<(-a2@6)BNv#Dgs?c_*O;_%>UtvyeRyI;0lIZo$;fq?<-X|1$V%Wu?ewOYrHAAj$A z-kS~jEDO`zQ=|wfI^28q7Db;*6ejN?=1|>Ei%Vyhp34>ikYgr-N*DSJo3*bXHl@kg zTo|_~-pb6r@8=g3P?)Aj6f;EXS;owwyOzzH*)tch(QP05J1%Js-i!nk+e8?aQtX>j zZYGz&PlfQA1y1E`P+n<8LP%~QsJ*zEt?A^Vi97RadoV#!X|E%X9Bg zVX%z=2Ydtg0B{Q^0gJ%;OfRGXXkaouHlLlZ1GfMGQ^0=#7GZ#W!2V@=z5+$lwLEiI zC%*oxpZonk`Np;RdD*uTr~qd&L=piE)PNyi4j2L!fN@~ZVK$1}6bHU)wB1bw6(ok{ z5ye5!9|w#|`ML_r@Ya_7pcK~1CCoIiOyYjMZut9IZXM<~&cBp-$JbRK~e<*zDzF>D~LaP!oJ~KH*q{(9?+4b_313@`< zqWNO2Ris49hQV4X>nyUYzgnjhHC!qOMFeYH7*^i>`1i)nojviQbMcPtP=vldSRV|i z7}iFfAH~htO7*f|J{={aL9ipXn@lvS5X78#p69Fx$Xd@=)+D6h5<{c`5_Kg>$ROOJ zM_N8NX7;q_0EGVdrVZ_Oq zp3+JwO(|AL=V+yfA+p#KXp;#LirIw<2G?%dvh#zG=Q%^s4%mIlT^9#@FR&K)t8^WM zv%qHH8^9Xi6!0-%C-47<I)4UfWjZgwT1zav}fnE@5k1VCgCBa#g2FJD9smF|GB)m*uU@+3`+gk9q}0TDicHq_{*z!5KD( z2wf9W;lv!hIdtYSqEwiZQd3dtI+;T{l_k&1EiV}((s>@4_(4!wgYp%7YO*OJkIqAW z`*nN!!p!WH@|+XNYjV_)W#aZ1(Knw1Ekm#ozN-(B0$qau-#ob348$f1n_?Y&jJZh1%3i>z*B$+Oam_f4imr` zU@uSs{wkC8=q?U;4!F2{4>t|C5>&k(7zDGsF>~-gef5jK^1q*)p15r%%s1v!2mx0C z0uta^;3=RAC?J-QnE=je=&(Y1A*<(7MzL%LG*O~`m&YD2Ye~Oo>m=HQC6^MwPLW~- z-B<2=_x6BsrGft8_- zTfvOJ0r-OZEG(cDYZ$v|+U>{>8>Q-%8m&)gd*W|TXfSp@v~O%eiiwnSmNGU`V%(S= zv(ldCg7>`)m)00Xk^zF>E-3O2!y?6bu7?Q8J5vvsK-Yq)>tZ0r8_pF}aCsdW9rJ_W z;<`|%@7R^X5{M)PRGtKfGakNF3WtV=E0qcnDXqk1b6LmYu5$SB zk@f4=`M%#{ltDIg=fp;l5s`C6|08#$T#7ch=$%?6HY2fkQsh;omRtY!$13^t@yYOQyo}NiF1_8d6wcMqnN@CvOP!MyvZ$`%;gKgEd;jKjoAw{u|JsS8 zlZWP#n{3x(am2P;^NaoMx%#b(_Wb?&!3Sy&^qWCSv`ZYZa$v`XNGWKN7)I3z?;?<6 zW;mrZhy;a8N=T)MomEOXYn+231yX?WfO@U}{onObB0hEEd9c~G6-?;s2P?4XwKx!g z6%;#@w3^K;<mejYK!wOSZff0FwH9Zjx4h@$p)oYh8O;1iLr4wtZ z(O8(DPmF=HMB$(kdlhIs(Pm(icsUu4b=6cc+8zz|IWRl<3oh(Q5XQjl4Fr6OXolmF>W)*9z*Zi-KtE6dt^?%MX z;Ih{fSW^L30*=sMM#BRJ%dlEETY4@TM7vq71VlD{1rC@Iw=myAw9HX^c`1Hvoux}E z{KEj0mXQ--5N=qzestyNo~^rIJ+$}0g%dZY+in%?S~NzJ*1+sse{-@vea4)*KX_?~<4La0snqoqGUf_9z6cULe7PE8gG--gXbwsGu`X2x8 zkCLZPAAP}bd;3->pjL+pkU6~ogw`UG2+HR;YDUq;QfWG@9t(q=9`0`@Ye|L9dh7t^ zB#E{1q~{Y6v(rj5V3NdID+GCxBw$vg7@Q=@vcmBIAswc2RRHX4nY8#h|5mURxKm>em!VstbyCh&u1 zvl+#aTsC(qB&7o1H^$7&%q+B8l}g$3{n4S}O0_CCa?UA5Or*7rqe#3%kj)}d6eUU0 zZntH7rBbO>DnS^elV3-STryJMD_(?|4zyUU~x-+ zwWW=i(-@su=g#Ov=0J3KFiKg=jPsJ&TWk~J-3n_31c|IkdnZYRB?~CIPfA601L~C zLZq~T7lGYZKwoHl{tv(T!sRRCT;wtb)uJHDt*ld)fEduCMgk~cEpP^y1ug=cfME{} zfSCt}`+cs1V~i5B|eR{yDq%C$4**t>&wZwj?ESJ@pW2co?I$hX_N{@`>3cusliezICEzL01OVVs8nk+ zH*ZW$PL`|H;T0pTcB?VlSX^AR&W1tg*tOcx#N_0yTesS+mN@eVK~S&PnK_9Q07)Fn z>a#h&khJ6W!lDr8K^Ro3)xn{mYOUsJ&m)y2v9mUgV`h$`n8DifYPFi@d4AxFux1B; zP?~2!krKDoyRG6om#L}g=HlYOz(6sawMcj%^QGW?y6bL~9^=SuaSRF+SMjot;UJs% zbE8kOFf*qaJLT{0%ch220>C!I5Y7=Ptvv~)rc_*C=U625@yy*~)99yE7^4RSyJgB* zKR4e9d@p|~=QxE{GLz>qB`jE^OH(cfdCV+&W!xRTTs&B3nzb_GCrM(BA*FoZ_x;fG zQXSPC^*TX7jsTQOLAhKGd|#0!up)Mhf_or=GCmAW1;9{=|UN02D9;_&_eeNq`2bKnTnO^FSRa0}H@vpaPVDOMqw4HxDo5 zIBbEcOca*FcC?tlIcNYI*^MkVxq&KGC;$K;07*naRAqZVyk!I7Y3Uxc^SqTrq=dI{ z&gm>QsI#f~M_+a5!CjAR-mvq~kpp{=?tT5#MEjcMO=z#;$yRH=-fq+uuZ353g}WZE zJTjV$d)9M_bBR@?!7TAI5KPSJ8p*K(feBhE=d9AoITp1ib{(-qr8R-Ab;@zI8b12I zCpGc0!{4&pyl*EQqrV^Ig8;3A!Qq{kCgv_4yS#GPtX+eFK2&0E#f`AMP^-?AtI*!= z`R4joE0AXhO97aSNf)<55&1!25(5dcbHbdkbDYZ?-s|#C!y=tADBrYn^|N#U;%>gA z=KwC)n>*+PU}i-mdhK$je01}JV03)d$mrjwTRDe9^{4g-a z_(8zTVcCM=2foU3JEcRgO3eZ3nlp12arZ3ZAAm9D@R1`=KJf&-neS?Go_J##Bc~R6 znz%T#_H2=jJwZdA!>H4s&N-F&lL~e#dJN^}inQ*S09IMtuguN4Ac3RKTv%A9J9ZAt zT6#q(rx$Rx7GnUu&F1F#au5df5Vr)C@p7rwzRSeddWX?tbA zIx#{he#;peqwJe4VyxvW0k9o72mrVQT*{O|wgYt_flfzd3w#+klBK}Cr)4t`wda5S z=(jFUT$LAY0}qETHpH~eecFi>t8#z|IqQHR}MAe3FkIoVT@aSi*tRgo7MT(lM8#w4?bLact8(8 zD>lsRn4OZWnVi~QeJ>=Jr9Xr7v{*?<*oZ843)UFL0%DY9N6xF3``+{T2faWadF^j( z(%!in78t0bTtVP_8@H|=TJ_zhPG327?1dW#r&f>J)oW0#qg1s?JRQd`*7`5iE8Bdv zv)LYxt#d{@Lj>h{fpv*<4h(0l?|aM;dvQ@>;O!~z2rQBfRVk1tE|&{r`0clJF49Y$ z_uhlkb!P7**BR{!fJS^y74-0m6+^?r8#ZmaeCg8VOBVqwEG!sff-vwr&-a6sqbrAo zhRfB8BGuR5*FP{QU8GvAhNaLNYpgMeNs=Tbjz58Qu$e}8|G;pnlm6hDdl3n?~7jvIPnee>0DzOneHQi@W!RbI-7 z6ibeTsIUZ2cOlz#`?GTMPKx_tuRRc$$=3- zG5{?_Avqlau*AiSN_ot%EPnh}X}?yf zlmc;7O7oxsaLh^rV8D7o8k;~&oQi4#X$y*sRaVi$h%m_IH7tg4=}eTbMt~x#(jiXL zx67*Nw#fMI${cXCdy9aLY~!`mFSG@meOrJCfRpXT(?_43pO`=#0^>jn zn97d135;dcsvS%lZQugX4~zpN7LzgJk_Ox6g7HBE97pq!N}@%Jf&LmSu-JsjK3?BP zSVJG+d`vH(xePO6XRHvHDU#Ghq6L!Cv9ipd&hgm_gnSjQA6q{*Jo4a<`(Hfp>d`Z& zr=}Xo8s?2y9CyuRey-A*w71Ur=k`=~-B;dIj;ktB$|$ib!e!B9SvYZuj0vf}A{b!D ztf1iJ8(~tE!hW!GTq@NbeeVZ-9UOf1uj7LYd-gy9il9|1PWIMHix2O9Z0+i8M~@!9 z`1;;!H>WqOep!PsB-rkBv6hdZeU7MXiK^AW<&-0n{#22ho zub$JrEAI#_QW$>auMQuJ?&0Q*K?xUzr+nf}56B>GCtFhHC5P0FKc$R8kYT@gdS8G4 zuHCzL?b#hgQDb&i(vm4siAgHeYPnp_o&cg_X04S-U~8-~#`wlJ#@aB66YH$W*f)VA zvaog5x(xId>!vd|X8tWil&fj<9K7r$ilW0ujy&=H_ZNLQint_wjBb#DCC-NV?;-@r z;aA>dJ#B|fJG{p*lwbC?ZLMw_KvlpiKsJ*Bkcd-GV?@&cr?+XP&MC{l(Ym5^J5(HtM(@tw& zHs-XDF%q4^q*bk23rnG=HP{hD_~Fd^qZ{)PDH1FNV~nRY@-}6u(hi;|c8UCS&fI(~ zXI)~6$Fu;QoFBReKm?ifs2O+T@ocU<+98*fCPtm02q$Qi6SLC3cSk0k9??H>3ij+XZ9Vq`M@5CV+qlXYVGB) zd}GDPlaD?A-VK|!oILj0sWXSKUZ35t9-}Kzudqqx!pf1Le7#zk@b%-(_P8;m$YU^| zB=@yAy&+rvrTNC+uJX>nA^?_Ph`bbLn#?mf+rDHlVk}9Q#oe?Dka@FaE9l}xm?>vx zwua)QMgZXZ{)&+iW|pAI+&o{L7&^jSSua;gX-_*V>GTrM_pA}DVywhp=1~$d^Rc*I zrml!$ice{A?o9RsviII|>GbI{?|JO8OaSyY{-o6HGLlac`2l(ONnt6I&Z)O0Jc=_= ze!(2I^dOIXOR?edmdo7JIL9IBvt<`xPPLDUs7O+KXDcsOl4&_je6N^UYdv%8){&#f z&R@K=ES21Dw@i}8C3Rzw40br_x{ixv50M~=OsLn(y*=b4N$snYmc&M4ixE9v5d~2y zbxh7gRGqB4%H>j}T+X}*0ZP?bq$;G6;v|+-jfIY(I@OyuoHSN;O!2L|;7B(S()DR) zpF@5qy*)$lMPNlwy4XBpbPKRZfCv}^E>H@%Br^O8NvEW*R>(o9E zDTUwbZuF1)Tmg6IH~p9@r;|tPE|D}vzVeBa(Yu_#`#HKyvGxDJ1 zp(14+eY+NGZ_Ws68|746wW^m= z{iebi2)LL}#O>u0O$HN~PNcV1i~0L^DP6U_L-G@kST@?D+WyD0Qgmx2s=DvEep3tu zv~rd)=KSq^xEc!MLa@>Q0v_5kB6e1mZVt{bOdclk8Gly?wsw(j*F2A&D-X)}XNyw* z)*uh%=jn2Ia*sr-Yy_hv`A9QjTMe$x>Dx6;4{?GQ^gLMPq~Yh0U4OF#%o}!o#X%au zvPfIE>1k<%swJece%oyR7&yE=ZaxbCQ_QSe$12kGh9)g4dRK?_Q*7to)a^O*2VEcY z4ddlsDc7>zPD*C|JK22WV3kF;bTw4~k$qK%)6vYy!K9MXW=J_jFFuRsuepo<<)Nq;3_2rb zIVE6!1K&E%U@_kBMt+}$(;taS9g!FAYdyg9W3M=xI6_fCP!JVfJrXPINpL{4YcDlB zIy#J|M1>*!@R_tw+q6E>EkT(eI~E9J20$h@(sMYDiMos)zps`;Lgtu!C!j`sUEi6n z2bBHEE4yiq6k=^XqhD9Ch)A(n&ETSD5e)Rb zSHU6|B>cEiwc3Yx*RHhI=F??V!|ivmUNo~nz`STA9JqUXly*uD|;KMJzOl;x3emcW#H>FRQ76o?;5=E z(7pK>y9w2+?Krh z3dd$bWVta2IEQVEsuou8Y;aBtWnO|aZic<~GaOGhdmzsPlGyNBe2&k5;{*Nd?G+s? zW1a$gu2Z^vO;V1WY;DVHRJgNxX6aj9ohQlpot#cmKeoxQ&a4#2oE?50-Uf<{)F4s4 zW0>Af>A;qbyBE)kTa~YqQXdHBz7F}*792yCQ5LO^g&@GJLYmc2gnc+NO+(0Ll>3ca zc*;P4^ZHLH)>^y!$>G%w7gyJ>+x5ksriIxk&L%AUFIY#MB8ATHhwJ6id24i|+^D3pJB|#)8kxq&W9ZT3Rb;DwOj#WiCAipbN(diXn7gLwmJ&lL@ zPnp**Of%xoDdEUg$d04tRCHobDn0j`#v6f`#{-sI;MErU=V_If-s3B^Huvmwv6pM0 z2xLrDPT0HVIdB6{AZtUVB=Uy)v+KbF(AMCS8LOcJx47)m>8MJiaLg%2*|B4C+$U)@Q*6pDD~WYT$TZy# z!L-Cl2AQcDSSI`;fj;Hm$St0ZH*bVda>kLOD0ChQvDI`~z0g+cjx$YA1iPRgKs;V3;_4aOEi z7aTs9FB9J6Bm24XxzS^M5=p0OGhlzWyP?FSlb5IMYpj9D{>ta*lwh=Z{lZ@i;+rY7 z7IC9r6Y93&?&}VoBokQH96vt^{idE0c~~nEdp(k&@E#z#f$CU|Q@&mPh^G`YuF{6_ zJ9h>8?q}F^U#HaEK0E~Oa{-?ohsECd(bxdB3jv!C{+mlnOVMoIUa!x0l;Aqb8-K_@ zX{)Ra<^#v*u3DR%hXsYJ+wC@T%~d5Zl#8mQak8GGOGo?xI$KjS;L|5<1M5=>LL>#~ zsEQ9;nOI>)+}c!t0ylF%fGf3Tp$+#HCa<$>ZzhmyG$4cr=lf%!*xPmf=O1FPWh!5* zfNysukZH=-=`@poCx^_f*zvi!xwe}FPy0>d{*I*^x>skNi7 z^X@k=_*uS4_4v1*9T#L%89iU!<%Vo}|5o~4NJYvFyt=-)T%yEP^7Sv5BwFR95nUSE zY-lOmhm>)v&4&-}BdP#HTl|?1tgci+bXzP{2=Z4sq15$5NlAmYs8><3S$GPjliZ}p zw7WnH>{e3`vxHC@QIBJ2!s6xVN76+hJID?&;0*Fu75F-60^XFAy4-xd(lHToI}LoA zi?^$SEY}2H89xM`!o9(Nft~dh>+cAzSwC~X&?P!MDd`A8KBwvyMNSTaZIRYRNFg6nbl*u9e+-g#|bIvY8Y3CWFr(DP_}v@5cm(K=QoYXycgj2T<}=epPCd< z-TqK%TxWheT5=9m4ovwB#smuT2yh(ma(o+@u=cGBcp5UbK-BSg%xVt1pg&`k`9*)WxoXU;*iwnay;emuu|`x6}cc{nb>&Y{kE zlY*9phy<`kcIl$pruji+CdNbC?rt4Rw9V(v-$uF1>3Xf(?q{r07RS7MecW z7az_zJ^_LRLS~tP%m@u3g3IRRFXtjyPw&Q{iN|9p%s}7sHU^+y{q&cZn3$J;R>mND zg#utu$z5x6Jy2lly3Kv)JYaj6$|Qxg++ z4-XfsEj8LFyOWb?sx5Tx(GBZ4x+eOc8r?3WtdmbOpM2;Ci%6q40Z}5Nt4(ffo{aIz zuw2d#AAJyab($B{QR{>_ctFB@d=DxC&l-?ZodB!hxU=Z!=zoI%DzymoIh~dv%$fkc zi~?bu(v+M^y1eyxMBlL9`Zh19KcdC^ulg|e%d;lu(xl~fG=BZ#ym%bL(`ea0e&Jry zlE-bMdJs2g6h>KwclGkJc7<2MYS{WGu7Ix^*ii|YdL4*Q4pDss*j4S$jJ>6ZH!T-R}pQK4c+k6M>{<$482(S{Qh$i$`VI3F<62^y62wXJb!zEQz9 z!v%=N>C~klc9Kq1naQ$#7fk4HA`+G#MIRL@?dgOR6-m0AhV+BvzEZ2Bp+yH?3In=?qNRNP^TQHK3LvylW$-Ygzy{-WRFrmqy8Lt1PV_o4 z9yBpQF642lRI|xLX9;0;p%vj;Cf#W$QrOMy`oznI5yqt4s8CbuW-;lZntyA^Zqm7b zeP-;LI7$`obLlS@9egP=m6m|C`LF|()>zy;@ZNxWRaH$;_^M}NWtOBDI;Jk_Q8pSu zlmA}#o%VHZEUL>covk4k%QG4ZBKKkDRrjqj_>L{N11|vl$IxvnxojP-zo~Q=;+$Cq zc2hZG5GZx@c1F+R_|FpMt`FF4;OB?NgC~hH%@1i6P5OaV+BMpC^R`XuRho8C(6>ju z?1x#KCX|gz>#0VQ=|_<|Hk8?<81ig}o!no$`xLw&n%MkKEtxxO!rJwHl>S1d`Y0s{ z36YV&%;u)fhqQrw+KQRR@cL>@mVET0aD2^k6B-6a7{&pR_AX5WUWNFJ6wqX&IMxExB>kUwK>=%(!2%_m0w^O0r&7kI){Sz8jiw*R# z*j$4Y0YDB?LXhABFe#)K;`fVUTfO`^rk6^M2}?N*BkASFhMT9?=F*QK@^Dv0%U1|O zB)c)p4gh=tDZ*juo`lRTHIUs+CAa-`C223fj}&Cu%2psk3?oo_%i!WlkJN)HV~=wc z1m`Iw^}?jGkTGj2q=1_*-V);jwq-;g>wY}*F2*6D2w!I~Y#L4w-9h=i!=oEa zL-_>$P2(F!iGfKzFwdNx(Puu(LxR`bRf8{Tz?w6^;$>`QZ$G}H@-ot~@eu!R;uR?# z-bQ6-WqzS*`DY}!{i0{zSNT)|c4fn!-f;ig^P=N88+>Xb27cU$zu4#^?S-n4W5YvX z{wJ8i!a^v2R6X-WSiKSNy&-#40VC%R7{*bI*#z~%oywBL(3r2p@+su{ORpF z-QrQ3+SQcM>$!k#yQn9#>q9o92A$0)aJP`j)*au7aIh>PgHC0J^6f7r)Mc=^DOLh? z*0NuC=W+*IYLOEYw~f<#&Cb|2VNwX+LWMsQP;oet+amFq+YaWhQD|zM1oo9VX`d2B z&Z(XvyJDGH(WF}7l*vCv-}4-A&$J7osD-QcIpdmi`|U0LbH7_Qe74@8(;jv>wdJpr z$x7xUMe@f0?Bs~#CVKSGeU-9htuKFP->;Bl*)93zGSt^fY=HxoZ-k4QVAJu61nYP; z^ZI71BR~h--?U|@JoGT<`;`)_v@;NRS{2VlVkJimR7u`lQy$%Gj&OwdvnBx?W?H7OQwppo(-_m%MLKbQ57d*OrEi0Rd|iY7Ah)Eb<m2~0X1LFhNZ;@zGyRn^BYH`&kF3g?=B~%%Qc9NkIGCjdY~Ae7JpHE_ zl*v{-w-0Y(movTzd7as!V}?wGaL62oqK*0H5qy)|);jgA7`mV&U3b3f4_=(|I~f8E zHjyT2RZQMvHNH^ECXt_x$4V&NEP5Kho!5>0^SBFT;zc1ZH{+c{RDHb$VMQSwC(S(NGtS53?C;P2r)mVv*?GG`@)CzvhH9>1$&L1Q3 z4km$VWbT^|dwvF1Ute`9?p(?&tLW5|FvFJzoeh~%gg3E5lk$+v{08=x_3LPY841eM zxJ@KAnTismBu@Eo{SL_#3N6iVMowAnKhXT-Z%BBD8l2Y%D{F{G;7%6mQo$p^fn%e; zQYjdl6!MAAgKA7Y?gP6k{W~@wLRmjy8qc4eCoGdTx4q|sz^jIVB#=nQU(a@Szlv9g z;H453qI3su59Z5*FMby`o1xJ4_1bMGHTr{2iI&}4YK3QyIe{*;s*ggIPqrwQ|2MU| zjfgHhG+Y;A(95C`0t3P2_Bgo#fXyVwc!s~V&Mj$=Wn*u#UASCMAvD@$&HCEs>^YV4&-^u(!8|PN`3A zKY#wLuRF->xmD=7brpMXz4mo*a5!6Ox;7BRBU~ex4Ra4R?>u|?E`+WqMKtZYo%2WW zZwRAtCI8*NCksnu0}MW~m;TtYB~t6BaDy>cg|!j;ccUZZjm_^bTK$OW zet!OY3y^t(R)uy^b#X~aS`o@dEA+9uh)MQ%si8uU5pN!bU!hQ@T>Zlwft60cA^OrM z?nAwj)KXe#)-Cb(%RG<(uBKrcVU2hh42g3#^rt%v%Gv&}cl-fxIAwfHo+gmj(9n5# z;_A@(N+>fSE{^z+?g2VZOx+L(`+&^Ajj-G`izsFH=C@ebrDBZTY&CiBaw@!}fG?bG z8~Y8%TT(d6XZ>sDeHX_Y*)FupxYS(TZu?kuEy!_}FqDTQvZ^vnqCymaw=+tAE6CqM zAY^a~0}CT01Nk%D>rncjb%S=**wOeJgg71MjU*k01-s-^g*vY3Jp~NTK_=dh5(h<2 zcFpV7m{EgCXWOvRXjpAoDhKQS2fBr{dNEp}7L3QRd=08EAv^#$jx8vo2TUp40kjHA zh#mhg%b!dmOZ-f3k^jjBa7Ya%o>*+kR6O-nple(~=_RO9M>P_PV&cu_8I>d*SA$&3 zaZ)`|5tMO%W)mt(c0GbsZg)saOw;?+_3I#F^NZQ~u>1!YmPwMaU)d=%QkTg+4)*Iy zTT5}VtB~ux9#NOmyZc{*^q01m0P1gq`)7(v-TPC<ZtfQ{USmtrTA`S$^sg~z#aBzP z!F@>y?4Q(AG*`4vDtxr=77V*DIu5d*cC7cueQIdsn-0H@Zc-9wZ2H`+oq0}q=y8|o zrN(5poQ=iu0bA@AMLH-R(=23cOq?ULd&o(Lie_^sY+Xgg4DC9LSWE~63x}liNxM#? zNLzq`6O%a*7YN*DPh;kq+aykW^D@60Xu_+xg~hP1-5G}q{O5=0Z4sOQQJm0u>t#P0 zc(|r*Ka*C@q38A9vj@Bm@PLjio2lHB>JH3a_eG-zO2|&2u;1flu~HV`Wk>972MV(6 zrI~aekLsn~;n_&3I({WE5%#LB`Sr_Y!5ckSpQrpjzNX9b48-^N-R3~h4()SS|3mmi z%2u9M(YA4|+yjH!sWOMD{U60bYv9{$$wm7~HRN_w#bLF%YO{m2Z5Q|AH55zO>Gf`L zI6n~jZ%XtK7$UoTAGEXxM5eV9Bb(HtK1*-T)yo@(f&jx69rnExWH`&Ki~%`DL(z7OYXZ6_nsg(Ypx{QgfBwxzIfIz3Y15|SIfT+tK1!L)KStztMg zQMeqoEaDMa2>Mgcm_e;Vdj=|4KX`aJ86hdgi$aSnw(f+POy!pwp=CWnc~zFKdS#Mi zD$-?HVGdhH3wz9x>yj0TUbu;+FGmMGUJpG1kU)sZ+v|Sp>^eo2$27ufm+QmD+H3ft z5qW6clqHxCT3G-Lwt)L|D5VrY*!sZlI+5|67r1mYViCp|G%fx7$L~NENyx_rkLoOZ zFQj0M#&ZPk*o}mog`EXXo(hIU98DKioeGAGD#-2UPs<>fhF+rHUNckDKk)lOj&KKX zO@eW}?Alhd`#r`4NJ7`gu|K7j&s8ZpCs@-Ce$XM_pBsBgA*P{HFBngS$H zC{StQ`nZjZNN=`Ov1tI?=lO?C94F-`OQ!bI5e25|F4OxK(xz~(is!l3qjAxm_G|S= zq>$@7#|_`9Q!1WgM*{bqnVFOqsV>K%XajdR2GSWwA-3a zt~{QGHP1VgZ$SCut5tL#*)%7&l{Zee7p`nd1gfEio@n6E zws!-ByrlKK>`hNkf4L;3q^y~@-PzfJqKZ8)f3X6+euraNSXlg9R#tbMxAS%W#Q->T zUJZ@2^}KXl_+R`3)2Be7mm$ZOp^q(VE}X8p8Fv`m71J&2w`{sxYE=cub_^vuK$(i} zm#unoh}ET01=~qVa|Ml_1=S&GE-2sfgWV)Ya8J_S)5SLD|>0XgP$0z$1n6#_oG5hetQyCxAAJ&7Fy8 z;@b0*tbJ_W0_z{7n!ZfpIPt9wQ|{VCV~DZa2V_ufYpdJs;WQG3*Vg6fDHqP#!S~s; z9-8YezYD8K)ESe4Nk5J ztd?T&D3SDc?~oikCmh${!Gqw}wB$!Y5V?U#OuciP!0X&V25P^$e2;&z(*6%Zjn)u zw92-39Ky%`&qxoZI|Fin`e^Bk)QHK3g@LY?Ne1=LCXsk(f8LoMxl_T8=@E~^U0 zU>ad3BVM{VE3~Hheir%^w)ARnxl9gb__M=AmJbPkW~Q;>_7EzW;Sn0LLL`-Wl@HV^ zMKzCN7NgH4S-rfc?DDp?f4=DU27?|Bs)CG>6>nP&#GRT)%tpgPC#+K`GTfu%SAOnr zy1?WFO1NwYEHC^jw?jc}a4sTrWe@Dh32d(Im{UArkan*|BuH1cI61iYts&qwcN4F(? zqX}}^0DL`Vd!1p+PdhnfgIu#gOF*CXTmQN5p_DIM=)wQ`C(!R+l8+yS zO>*!wFCeg^5nY7=WP+{x>6wyRCa2)>rsp{e$~4(wrIljk{(Nnc?!TE{^hmz-hQ}HS zRrGp%S&rJ7-wS;ZzJ5g-uQh)uBYOuA&jOeYLb4Ty5k@C+G7E{sKrs}z(mfwMq3`7e z1VIJB05G`#*jnOrMR8Jq04x0$l2&9YDgYMDH&do_ZH)sl1LJRz?dImY*FOH8>j5qf zN8-{d$@Jk)^ed1H$Pr{ZZ;eTdsILMUB#{C*SaasPwXX@KH@zigx@+{T*ogqO`>jMQ zF(M9fRw}HU?Hg%p4o=EYyv^u9-pcM{3}M>=ya>PGoaH#=vf;dGF$?ePKNmI+ssL+N z+2q+aqFje9*L1pP^5jwI(61xjn;9)uw+2voAX;!ze_Wjh^_5U~-vZO#Q7ro@pS+;4 z^Tb|pq%BUmzsW>zmzS4j;lyahZfPkgrIXd+{q*R#L4(|HieYhdu|>R4+h8$_O4+Lt zx=`PN8(e?mja?2z#qRXfI3=dIABYy#dClGQ!h&swRYKDT%j0-Qt z0roUkkVJ%9!stRE7SqiiYumwox_45Dy8kr8C@uO>eoM`MXkF3<{zTd^GXmT9pi|1D zdx)^4W`*eXC~_+1d#EfJgt(qFV(xI^z>O~ehrSEarcn64ffipVbf$dJ)pI`$J%9g2 zr{n1x_r9i4H0mSjCHdB`Pm{S^idibc&#xW(aZTD?noyS+ixH|NbD5w555}Sw0T2ZCeGj6b+DdUh%_3q>)Ic7b zZp&8P| z&yt;B%^zyA6j4A;b*s5NaAF^Cw?bhxA->^}8{Vu?PMS5)h}I}r%Q=qfNH1!6|k z1^PnfPz2F1kPe!0bx+DuPpXpCM`Q_U_Y`al6*p+0cv? zE?h-2ktiGqe#u=U(G~XHOd2s@n8gSVWAGipWQ2yHN{5^SD9xLXr*syaZS9RK3$^0?)$pkbE)Y8ib zR5NnPWSwH`vYxiY=iPyo@+Zp5`YFIB@K-UtNffqgcH;w0ID9+B`p+ zKr@&EuCl+X#IBerZ=$Xj!wxtJxJarJU`KWfZ-2?PsnoL|M>-K`HTx!*kb6v65iw2@ zz~x0|*F*zXvQUpr(ptGm9OrBAd2pKoB4)lgCOmpfbgNZ--SLN1c8h~pm~=)_&lmKi`+nDAX zqEC^=^KK25_uR_sEp9?-7Uql^e9l#OHe3zHh!Gowjg*J0a9!EKC zj*;OJR^*kE9nmQnpb&`WF6P#uGS)Ha{Z`w$>7{i-UUFTCK(1BM7oyw@+|9_PJo>bY zn+1SlMZkocLqtw6R!-cYXqOE_X*~F|UNivcL%oY2LfHSK83RC^gF&!H(l)tTq05_| zxk^=rr4!%6klhc0tBvjTXy~%i`AabrHHVBr}CieQvxpxLL3j`-~#OZrIpPOoB3! zA+AvAdy42Eg{}EbIL`LS(m{8}2V`?t++I-YVuvp|f=yNg+U3Ws>4w`|g3_a%iPv$h z4uIRoi?x)#7Yo3=C>=?*czcETAe^q6pJ1NZ+%=n7B0c9(D%6tBQ_EPj$m> zOM?cR2M^zh{{@yyM06HjI*85`Wh6*$OL!~$J0={tX&<|`+cBQNM|{ofjM!xgpXc7| zuqx%QFJsqQPxBUE@+|u4Ld`7EdEN*0hALIB_Q!jEAbo-N85-a46x|s3EG>zT5y$+} zi~cE#zBurHcvB#WulsGwGj*K04c`on8|h_?QS6=9Y1wn#=d=6ohi$z?mHmDU+_O(` z%h!E%h2YnX8|Nb{nzUGgLao2)**E~25O@hsupKW^!>p+!yA4(Dir?SeaA<7WF+FF! zfm?^NDyO8_l06|Yn9BLi+$K3ujM?~|;jehDS;&@~&|%qaOg%KuWG6*Hmt8)I<9wTQmgEP1L*KLYkzw_;d96~Rzi)3oDw=- z#^1t)J#*Owu8Tc-ZnxVI*b&oGRs@7&Lj#q*TU)_DD12I>vAwH+U>Xv7A6UJ=2LAIA zdVKJC!@}H%&(Z=BsCOyE>q|>t-o!zYGyV#T)t?mY4-c%&H4qXrU20eWF{V-J3FsUK zB<<1T1h8Z4AIFg@EUbuExE5|3wukO9Nx$?`!3}~0;R_BKRf0b6Y{*nx5bH2>!-^nH7hzhamw3y#~d1{3TWeAhJA| zd+u-xAR%uBqf_B43AaVW#*6~w`%p?zUqyW5VR*K%op9I@g;5)W&$`I%0rZL>a8mDO8XvBab0VXD`bz%oIVCo#*BiLqG zAv;=9fR&96>umtws9T|_>;C;&eh`KRIX4n1TUKHQ@)d3qc$E4Ehotl=lyHe;e9|=P zc4vd4rxIsmW%@oNAXD#lKsaaL%l6@&mG|Ph=epZYEMS|HSJZAEPUrRE4Lc|}7E$N5 zBcKSKgdWk+(A`te&!Mp~k#o~fu z#mZuM+_QFtn$}8OQkM3+J4yvfj_x`J_4;#zQpy9)bl#Q+X>}e>NdsIQ;`a{4?ac=T z;B;0Ry~xBm2OoL#dnH{lyz|~JI2wR9x8qz)Z8?0}zQZGvaRA(M7s3h1m2mpeE#jYjL1(4)rt_a&>CKo4H#A?(>aB;t# zN)tFawJm1{)-P!`84Oyz)t~use9+3F4x`~m0Wdn8%rhJwHXV1@xQYGXL1YN)(J@+;m4SfyAZAnRGOq+%t~kd*NF~T^rwW)*2u8=G{WZxb zUi4*s9rAqpw!9!c;+??Zgdx>nJ4G&q zf)R2zsQPviJ(~z|LglC7&tc-1>m0bFh6)I+H`y)z15-UOHX6v2ZVNtx;$BXZI2wwI zil9Y}xz`5U_v60zr{2|xU2I4%y-Y-7kV^A^?cGp8{^DPrdQp^b(O%&mP=h+Zt?~k( zaMtf|uTL-HquKjJBqgQLOa^}r2HM*a&BVJg%q{5tR* z`d&{r5vIgR9ASi$@iurGonrv|^S=$76Z$vq|LpzS`22q@4OLc>6mSZfH#z}(I?(EPOme}-jWC}#r&%RF|N91@|79Q2MaM;VOV8`s zYKxtO>N4uuY%Pio?aKO^fHd+%ZJtzG`Z51CD#{$+0s zi{961u=b7{zVTLu+ztIRg#4F9!V^}=!S^&y!nXSrJIA)Y)JG%9W{36XNEJVG|L8_z ze!oZdAVr5Jzo`pSdzgSJ(@cjeIN+`!|!W$$#t#+G-u^bzn8oe!lO~PO5=}H?#|S z?y4NCJSB{~p`H2sp8@diJ`#q#nAH0u9vyu>Sj+RhgxW!~{c?Srls@5_&q-Av-FtcQgJgDF{yR+G{A%k%rzays^#8pW^R8V;_LcDCuWaX+jf>Zf zrvo6+YPo6A*!N-GQ*71>x^q_5vO&@lJ<|Mb)mS@Dq1@Y>Jgxh2 zkZlMEjc>EZc^V#fWd0{9bZJSqWLEEPH~&Qi*QN|rS^e$4z9z(s@V^%gr9lxR^}2FS z{E0RD+)vn@V6}W8`p{<7;qiK0^L7l)9N83k+zY}AxD163Y0ow1;XVqeLY?qkFqWSw z`2NfUys~%>HAQI9<{TPLi5|8PUyOxn)ol7d_}^8SthYMvtOQj<&rM-dh?=XBzCGTF z8g69z-|k}>g|Pe`9F~H9zHsq&e&Mj$Euu904~T}g=F>g)2qkkTUxFsGEPIu&J3v-y zURQQ^ExU{%N5HqEP$aDT3!me%5{K@mef=t45s}x#c)wreyLj#jXKn`c z*{J<$(SI|D-^&hV;70Vl`oHP9aC3Hagz`5N|Li~GolX-A|NO_tlo8@SY)X(#*E!NU zGP-3!310dk_VV}9-^|PmdT&eavw`3+$Wa$$|26U=igCu4O9LSYCQddX#tVO`%X(TjKj#dW1*NwnknwkfJl9P;Da2$64N~usd3SrCYL%`iV{axQlrfV*hBk}n z1N)53%=D2N?qKE$YB@g?_l*|)DxXxgk4+=VofRSW=|mUFXBofa?brD0Aiasx(=0b~ znH`+Ej7;?Ux(+xv?Cn-N-UGV&_Pj!8N0BJ+q1r5HXlG@0er|r1l_50Mu?u)1nJHE& zuKM-w&OCA#PrkOV9f2qW)TivcKUP_JSIm}Kd2eT@Q>*H$q-7}qdZ)F0>x}J6B{XM_ zqGJzr?VML1!{_LzXHxU5QJfXZrIX6b%8TN-fSj}WdxJiik+%KSiPl&bzNofoxt=gw z91UeSb)|qWyjeo5orlnCPJ!G%`E)Jld?JncL#_g1;q{K5s6*1?X*e$_i-?fb(tZ!m z6Fb~drP<^Q%*d#-fGr~~U0noehu|xhQm}Jb(-(`TXKZD=DuUuLY|F9n>eQPO)M<6K z%*)&_!JC^8Ta!K|rOe(^su<;Uf3wOp%xn2E;nnmNpUM>D1zdKCRMTBi(($HdgIQU= zbuwo0@U?u!C)~CAtMB@kvfCK~1^5Kk18j-D&9QZvg6U>83cn)iseKspIBNST(MXM0fb zR9v3wSY#Mq@oSk@|LL-TM;wMJHREq&77M&IqqnTZPRQoQGhyI8L*Pvj)L~H3F9Gt`qSm}J!n;*aPjhdE!l-i<33R-Wm!TN{!@A!8<{^s_-a!X

wI$e^(H0J#uZ{|ohOyz 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