From 42e9effeb13e6910f17278ede71713a120b9effd Mon Sep 17 00:00:00 2001 From: Zhouyu Li Date: Sun, 13 Jul 2025 15:53:17 -0700 Subject: [PATCH 1/2] Zero Collision Hash Benchmark Framework (#3127) Summary: Pull Request resolved: https://github.com/pytorch/torchrec/pull/3127 Differential Revision: D77033290 --- .../benchmark/benchmark_zch/Readme.md | 98 + .../benchmark/benchmark_zch/arguments.py | 157 + .../benchmark/benchmark_zch/benchmark_zch.py | 631 ++++ .../benchmark_zch/benchmark_zch_utils.py | 316 ++ .../count_dataset_distributions.py | 250 ++ .../benchmark/benchmark_zch/data/Readme.md | 10 + .../benchmark/benchmark_zch/data/__init__.py | 0 .../data/configs/criteo_kaggle.yaml | 3 + .../data/configs/kuairand_1k.yaml | 109 + .../data/configs/kuairand_27k.yaml | 109 + .../data/configs/movielens_1m.yaml | 83 + .../benchmark_zch/data/get_dataloader.py | 52 + .../benchmark_zch/data/get_metric_modules.py | 89 + .../benchmark_zch/data/nonzch_remapper.py | 141 + .../benchmark_zch/data/preprocess/__init__.py | 4 + .../data/preprocess/criteo_kaggle.py | 55 + .../data/preprocess/kuairand_1k.py | 267 ++ .../data/preprocess/kuairand_27k.py | 266 ++ .../data/preprocess/movielens_1m.py | 244 ++ .../figures/eval_metrics_auc.png | Bin 0 -> 40563 bytes .../figures/eval_metrics_mae.png | Bin 0 -> 28372 bytes .../figures/eval_metrics_mse.png | Bin 0 -> 28398 bytes .../benchmark_zch/figures/eval_metrics_ne.png | Bin 0 -> 36851 bytes .../benchmark_zch/models/__init__.py | 6 + .../benchmark_zch/models/apply_optimizers.py | 93 + .../benchmark_zch/models/configs/dlrmv2.yaml | 39 + .../benchmark_zch/models/configs/dlrmv3.yaml | 12 + .../benchmark_zch/models/make_model.py | 60 + .../benchmark_zch/models/models/__init__.py | 2 + .../benchmark_zch/models/models/dlrmv2.py | 97 + .../benchmark_zch/models/models/dlrmv3.py | 193 ++ .../benchmark_zch/models/shard_model.py | 48 + .../plots/plot_dataset_input_stats.ipynb | 349 +++ .../plots/plot_eval_metrics_compare.ipynb | 451 +++ .../plot_imbalanced_num_queries_compare.ipynb | 2664 +++++++++++++++++ .../plots/plot_qps_compare.ipynb | 204 ++ .../plots/plot_training_metrics.ipynb | 160 + .../plots/plot_zch_metrics.ipynb | 272 ++ .../plots/plot_zch_metrics_compare.ipynb | 283 ++ torchrec/modules/hash_mc_modules.py | 22 +- torchrec/modules/mc_adapter.py | 251 ++ 41 files changed, 8088 insertions(+), 2 deletions(-) create mode 100644 torchrec/distributed/benchmark/benchmark_zch/Readme.md create mode 100644 torchrec/distributed/benchmark/benchmark_zch/arguments.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/benchmark_zch.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/benchmark_zch_utils.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/count_dataset_distributions.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/data/Readme.md create mode 100644 torchrec/distributed/benchmark/benchmark_zch/data/__init__.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/data/configs/criteo_kaggle.yaml create mode 100644 torchrec/distributed/benchmark/benchmark_zch/data/configs/kuairand_1k.yaml create mode 100644 torchrec/distributed/benchmark/benchmark_zch/data/configs/kuairand_27k.yaml create mode 100644 torchrec/distributed/benchmark/benchmark_zch/data/configs/movielens_1m.yaml create mode 100644 torchrec/distributed/benchmark/benchmark_zch/data/get_dataloader.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/data/get_metric_modules.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/data/nonzch_remapper.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/data/preprocess/__init__.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/data/preprocess/criteo_kaggle.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/data/preprocess/kuairand_1k.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/data/preprocess/kuairand_27k.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/data/preprocess/movielens_1m.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/figures/eval_metrics_auc.png create mode 100644 torchrec/distributed/benchmark/benchmark_zch/figures/eval_metrics_mae.png create mode 100644 torchrec/distributed/benchmark/benchmark_zch/figures/eval_metrics_mse.png create mode 100644 torchrec/distributed/benchmark/benchmark_zch/figures/eval_metrics_ne.png create mode 100644 torchrec/distributed/benchmark/benchmark_zch/models/__init__.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/models/apply_optimizers.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/models/configs/dlrmv2.yaml create mode 100644 torchrec/distributed/benchmark/benchmark_zch/models/configs/dlrmv3.yaml create mode 100644 torchrec/distributed/benchmark/benchmark_zch/models/make_model.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/models/models/__init__.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/models/models/dlrmv2.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/models/models/dlrmv3.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/models/shard_model.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch/plots/plot_dataset_input_stats.ipynb create mode 100644 torchrec/distributed/benchmark/benchmark_zch/plots/plot_eval_metrics_compare.ipynb create mode 100644 torchrec/distributed/benchmark/benchmark_zch/plots/plot_imbalanced_num_queries_compare.ipynb create mode 100644 torchrec/distributed/benchmark/benchmark_zch/plots/plot_qps_compare.ipynb create mode 100644 torchrec/distributed/benchmark/benchmark_zch/plots/plot_training_metrics.ipynb create mode 100644 torchrec/distributed/benchmark/benchmark_zch/plots/plot_zch_metrics.ipynb create mode 100644 torchrec/distributed/benchmark/benchmark_zch/plots/plot_zch_metrics_compare.ipynb create mode 100644 torchrec/modules/mc_adapter.py diff --git a/torchrec/distributed/benchmark/benchmark_zch/Readme.md b/torchrec/distributed/benchmark/benchmark_zch/Readme.md new file mode 100644 index 000000000..7b1f1d86a --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/Readme.md @@ -0,0 +1,98 @@ +# Zero Collision Hashing (ZCH) Benchmarking Testbed + +This testbed is used to benchmark the performance of ZCH algorithms with respect to the efficiency, accuracy, and collision management performances. Specifically, the testbed collects the following metrics: +- QPS: query per second, the number of input faeture values the model can process in a second. +- Collision rate: the percentage of collisions in the hash table. High collision rate means that lots of potentially irrelevant features are mapped to the same hash value, which can lead to information loss and decreased accuracy. +- NE: normalized entropy, a measure of the confidence of models on the prediction results of classification tasks. +- AUC: area under the curve, a metric used to evaluate the performance of classification models. +- MAE: mean absolute error, a measure of the average magnitude of errors in regression tasks. +- MSE: mean squared error, a measure of the average squared error in regression tasks. + +## Pre-regression +Before running the benchmark, it is important to ensure that the environment is properly set up. The following steps should be taken +1. Prepare Python environment (Python 3.9+) +2. Install the necessary dependencies +```bash +# Install torch and fbgemm_gpu following instructions in https://docs.pytorch.org/FBGEMM/fbgemm_gpu/development/InstallationInstructions.html +pip install --pre torch --index-url https://download.pytorch.org/whl/nightly/cu126/ +pip install --pre fbgemm-gpu --index-url https://download.pytorch.org/whl/nightly/cu126/ +# Install torchrec +pip install torchrec --index-url https://download.pytorch.org/whl/nightly/cu126 +# Install generative recommenders +git clone https://github.com/meta-recsys/generative-recommenders.git +cd generative-recommenders +pip install -e . +``` + +## Running the benchmark +To run the benchmark, use the following command: +```bash +WORLD_SIZE=1 python benchmark_zch.py -- --profiling_result_folder result_tbsize_10000_nonzch_dlrmv3_kuairand1k --dataset_name kuairand_1k --batch_size 16 --learning_rate 0.001 --dense_optim adam --sparse_optim adagrad --epochs 5 --num_embeddings 10000 +``` +More options can be found in the [arguments.py](arguments.py) file. + +## Repository Structure +- [benchmark_zch.py](benchmark_zch.py): the main script for running the benchmark. +- [arguments.py](arguments.py): contains the arguments for the benchmark. +- [benchmark_zch_utils.py](benchmark_zch_utils.py): utility functions for the benchmark. +- [count_dataset_distributions.py](count_dataset_distributions.py): script for counting the distribution of features in the dataset. +- [data](data): directory containing the dataset used in the benchmark. +- [models](models): directory containing the models used in the benchmark. +- [plots](plots): directory containing the plotting notebooks for the benchmark. +- [figures](figures): directory containing the figures generated by the plotting notebooks. + +## To add a new model +To add a new model to the benchmark, follow these steps: +1. Create a new configuration yaml file named as .yaml in the [models/configs](models/configs) directory. + - Besides the basic configurations like embedding dimensions, number of embeddings, etc. the yaml file must also contain the following two fields: + - embedding_module_attribute_path: the path to the embedding module in the model, either the EmbeddingCollection or the EmbeddingBagCollection. + - managed_collision_module_attribute_path: the path to the managed collision module in the model, if once appilied. It should in the following format: "module..mc_embedding_collection._managed_collision_collection._managed_collision_modules". +2. Create a new model class in the [models/models](models/models) directory, named as .py. + - The model class should act as a wrapper for the new model, and it should + - contain the following attributes + - eval_flag (bool): whether the model is in the evaluation or training mode. + - table_configs (List[Dict[str, EmbeddingConfig]]): a list of dictionaries containing the configuration of each embedding table. + - override the following methods + - forward(self, batch: Dict[str, Any]) -> torch.Tensor: the forward method of the model. The forward method should make the model compatible with the ipnut from the Batch dataclass, and output in the format of `summed_loss, (prediction_logits, prediction_labels, prediction_weights)`. + - eval(self) -> None: set the model to the evaluation mode. + - Implement the `make_model_` function in the [models/make_model.py](models/make_model.py) file. The function should takes three parameters: + - args: the arguments passed to the benchmark. + - configs: the configuration of the model and dataset. + - device: the device to run the model on. + The function should return an instance of the new model class. It also contains the code to replace its embedding module with the ZCH embedding module using a `mc_adapter` object. + +3. Add the new model to the [models/__init__.py](models/__init__.py) file with `from ..py import make_model_`. +4. Add the new model to the [models/make_model.py](models/make_model.py) file with + - Add `make_model_` to the `from .models import` line. + - ADD a condition branch `elif model_name == ""` to the `make_model` function, in which + - read the configuration file from `os.path.join(os.path.dirname(__file__), "configs", ".yaml")`. + - read the dataset configuration from `os.path.join(os.path.dirname(__file__), "..", "data", "configs", f"{args.dataset_name}.yaml")`. + - call the make_model_ function with the configuration and dataset configuration. + +## To add a new dataset +To add a new dataset to the benchmark, follow these steps: +1. Create a new configuration yaml file named as .yaml in the [data/configs](data/configs) directory. + - The yaml file must contain the following fields: + - dataset_path: the path to the dataset. + - batch_size: the batch size of the dataset. + - num_workers: the number of workers to load the dataset. + - Besides the three required fields, the yaml file should also contain nenecessary fields for loading and ingesting the dataset. +2. Create a new dataset preprocess script in the [data/preprocess](data/preprocess) directory, named as .py. + - The script should contain a definition to the corresponding Batch dataclass, which should be a dataclass that contains necessary attributes, and override the following methods: + - to(self, device: torch.device, non_blocking: bool = False) -> Batch: the method to move the data to the specified device. + - pin_memory(self) -> Batch: the method to pin the data in memory. + - record_stream(self, stream: torch.cuda.streams.Stream) -> None: the method to record the data stream. + - get_dict(self) -> Dict[str, Any]: the method to get the data as a dictionary of `{: }`. + - The script should also include a dataset class. The dataset class should act as a wrapper for the new dataset, and it should at least override the following methods: + - __init__(self, config: Dict[str, Any], device: torch.device) -> None: the constructor of the dataset class. It should take a dictionary of configuration and a device as input, and initialize the dataset. When initializing the dataset, it must include a `items_in_memory` attribute as a list of Batch dataclass. + - __len__(self) -> int: the length of the dataset. + - __getitem__(self, idx: int) -> Dict[str, Any]: the method to get an item from the dataset. It should take an index as input, and return the data in the format of Batch dataclass. + - load_item(self, idx: int) -> Dict[str, Any]: the method to load an item from the dataset. It should take an index as input, and return the data in the format of Batch dataclass. + - get_sample(self, idx: int) -> Dict[str, Any]: the method to get a sample from the dataset. It should take an index as input, and return the data from the items_in_memory list. + - __getitems__(self, idxs: List[int]) -> List[Dict[str, Any]]: the method to get a list of items from the dataset. It should take a list of indices as input, and return the data in the format of a list of Batch dataclass. + - The script should include a `collate_fn` that takes a list of Batch dataclass and returns a Batch dataclass. + - The script should finally include a `get__dataloader` function that takes three parameters: + - args: the arguments passed to the benchmark. + - configs: the configuration of the model and dataset. + - stage: the stage of the benchmark, either "train" or "val". + The function should return a dataloader for the new dataset. diff --git a/torchrec/distributed/benchmark/benchmark_zch/arguments.py b/torchrec/distributed/benchmark/benchmark_zch/arguments.py new file mode 100644 index 000000000..6fe33694d --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/arguments.py @@ -0,0 +1,157 @@ +import argparse +from typing import List + + +def parse_args(argv: List[str]) -> argparse.Namespace: + parser = argparse.ArgumentParser(description="torchrec dlrm example trainer") + + # Dataset related arguments + parser.add_argument( + "--dataset_name", + type=str, + choices=["movielens_1m", "criteo_kaggle", "kuairand_1k"], + default="movielens_1m", + help="dataset for experiment, current support criteo_1tb, criteo_kaggle, kuairand_1k", + ) + + # Model related arguments + parser.add_argument( + "--model_name", + type=str, + choices=["dlrmv2", "dlrmv3"], + default="dlrmv3", + help="model for experiment, current support dlrmv2, dlrmv3. Dlrmv3 is the default", + ) + parser.add_argument( + "--num_embeddings", # ratio of feature ids to embedding table size # 3 axis: x-bath_idx; y-collisions; zembedding table sizes + type=int, + default=100_000, + help="max_ind_size. The number of embeddings in each embedding table. Defaults" + " to 100_000 if num_embeddings_per_feature is not supplied.", + ) + parser.add_argument( + "--embedding_dim", + type=int, + default=64, + help="Size of each embedding.", + ) + parser.add_argument( + "--seed", + type=int, + help="Random seed for reproducibility.", + default=0, + ) + + # Training related arguments + parser.add_argument( + "--epochs", + type=int, + default=1, + help="number of epochs to train", + ) + parser.add_argument( + "--batch_size", + type=int, + default=4096, + help="batch size to use for training", + ) + parser.add_argument( + "--sparse_optim", + type=str, + default="adagrad", + help="The optimizer to use for sparse parameters.", + ) + parser.add_argument( + "--dense_optim", + type=str, + default="adagrad", + help="The optimizer to use for sparse parameters.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=1.0, + help="Learning rate.", + ) + parser.add_argument( + "--eps", + type=float, + default=1e-8, + help="Epsilon for Adagrad optimizer.", + ) + parser.add_argument( + "--weight_decay", + type=float, + default=0, + help="Weight decay for Adagrad optimizer.", + ) + parser.add_argument( + "--beta1", + type=float, + default=0.95, + help="Beta1 for Adagrad optimizer.", + ) + parser.add_argument( + "--beta2", + type=float, + default=0.999, + help="Beta2 for Adagrad optimizer.", + ) + parser.add_argument( + "--shuffle_batches", + dest="shuffle_batches", + action="store_true", + help="Shuffle each batch during training.", + ) + parser.add_argument( + "--validation_freq_within_epoch", + type=int, + default=None, + help="Frequency at which validation will be run within an epoch.", + ) + parser.set_defaults( + pin_memory=None, + mmap_mode=None, + drop_last=None, + shuffle_batches=None, + shuffle_training_set=None, + ) + parser.add_argument( + "--input_hash_size", + type=int, + default=100_000, + help="Input feature value range", + ) + parser.add_argument( + "--profiling_result_folder", + type=str, + default="profiling_result", + help="Folder to save profiling results", + ) + parser.add_argument( + "--zch_method", + type=str, + help="The method to use for zero collision hashing, blank for no zch", + default="", + ) + parser.add_argument( + "--num_buckets", + type=int, + default=4, + help="Number of buckets for identity table. Only used for MPZCH. The number of ranks WORLD_SIZE must be a factor of num_buckets, and the number of buckets must be a factor of input_hash_size", + ) + parser.add_argument( + "--max_probe", + type=int, + default=None, + help="Number of probes for identity table. Only used for MPZCH", + ) + + # testbed related arguments + parser.add_argument( + "--log_path", + type=str, + default="log", + help="Path to save log file without the suffix", + ) + return parser.parse_args(argv) diff --git a/torchrec/distributed/benchmark/benchmark_zch/benchmark_zch.py b/torchrec/distributed/benchmark/benchmark_zch/benchmark_zch.py new file mode 100644 index 000000000..2f2efe889 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/benchmark_zch.py @@ -0,0 +1,631 @@ +import argparse +import csv +import json +import logging +import multiprocessing +import os +import sys +import time + +from typing import cast, Dict, Iterator, List, Optional + +import numpy as np + +import torch +import torch.nn as nn + +from torch import distributed as dist +from torch.utils.data import DataLoader +from torchrec.metrics.metrics_namespace import MetricPrefix +from torchrec.metrics.rec_metric import RecMetricComputation + +from torchrec.test_utils import get_free_port +from tqdm import tqdm + +from .arguments import parse_args + +from .benchmark_zch_utils import BenchmarkMCProbe, get_logger, get_module_from_instance + +from .data.get_dataloader import get_dataloader +from .data.get_metric_modules import get_metric_modules +from .data.nonzch_remapper import NonZchModRemapperModule +from .models.apply_optimizers import ( + apply_dense_optimizers, + apply_sparse_optimizers, + combine_optimizers, +) +from .models.make_model import make_model +from .models.shard_model import shard_model + + +def main(rank: int, args: argparse.Namespace, queue: multiprocessing.Queue) -> None: + # initialize the rank logger + log_rank_file_path = args.log_path + f"_rank_{rank}.log" + logger = get_logger(log_file_path=f"{log_rank_file_path}") + + # seed everything for reproducibility + logger.info( + f"[rank {rank}] seed everything for reproducibility with seed {args.seed}" + ) + torch.manual_seed(args.seed) + np.random.seed(args.seed) + + # import fbvscode + + # fbvscode.set_trace() + + # setup environment + logger.info(f"[rank {rank}] setup environment") + os.environ["RANK"] = str(rank) + if torch.cuda.is_available(): + device: torch.device = torch.device(f"cuda:{rank}") + backend = "nccl" + torch.cuda.set_device(device) + else: + device: torch.device = torch.device("cpu") + backend = "gloo" + dist.init_process_group(backend=backend, init_method="env://") + world_size = int(os.environ["WORLD_SIZE"]) + logger.info( + f"[rank {rank}] init process group. world size: {world_size}, rank: {rank}, backend: {backend}, device: {device}" + ) + + # get training dataset + logger.info(f"[rank {rank}] get train dataloader") + train_dataloader = get_dataloader(args.dataset_name, args, "train") + + # get metric modules + logger.info(f"[rank {rank}] get metric modules") + metric_modules = get_metric_modules(rank, args, device) + + # make the model + logger.info(f"[rank {rank}] make model") + model, model_configs = make_model(args.model_name, args, device) + + # initialize the non-zch mod module if needed + nonzch_remapper = None + if len(args.zch_method) == 0: + logger.info(f"[rank {rank}] initialize the non-zch mod module") + nonzch_remapper = NonZchModRemapperModule( + # pyre-ignore [6] # NOTE: pyre reports model.table_configs is in type `Union[Module, Tensor]`, but we know it is a list of table configs + table_configs=model.table_configs, + input_hash_size=args.input_hash_size, + device=device, + ) + + # apply optimizer to the sparse arch of the model + logger.info(f"[rank {rank}] apply optimizer to the sparse arch of the model") + apply_sparse_optimizers(model, args) + + # shard the model + logger.info(f"[rank {rank}] shard the model") + model = shard_model(model, device, args) + + # apply optimizer to the dense arch of the model + logger.info(f"[rank {rank}] apply optimizer to the dense arch of the model") + dense_optimizer = apply_dense_optimizers(model, args) + + # combine the sparse and dense optimizers + logger.info(f"[rank {rank}] combine the sparse and dense optimizers") + optimizer = combine_optimizers(model.fused_optimizer, dense_optimizer) + + # create the benchmark probe if needed + logger.info(f"[rank {rank}] create the benchmark probe") + benchmark_probe = None + if len(args.zch_method) > 0: + benchmark_probe = BenchmarkMCProbe( + # pyre-ignore [6] # NOTE: Though in the return type specification to be general we set as nn.Module, but here the returned object is a ManagedCollisionEmbeddingCollection + mcec=get_module_from_instance( + model._dmp_wrapped_module, + model_configs["managed_collision_module_attribute_path"], + ), + mc_method=args.zch_method, + rank=rank, + ) + else: + benchmark_probe = BenchmarkMCProbe( + # pyre-ignore [16] # NOTE: pyre reports nonzch_remapper can be None, but when reach to this branch of condition, we know it is not None + mcec=nonzch_remapper.mod_modules, + mc_method="mpzch", # because non-zch remapper simulates the behavior of mpzch + rank=rank, + ) + + interval_num_batches_show_qps = 50 + + total_time_in_training = 0 + total_num_queries_in_training = 0 + + # train the model + logger.info(f"[rank {rank}] train the model") + for epoch_idx in range(args.epochs): + model.train() + starter_list = [] + ender_list = [] + num_queries_per_batch_list = [] + loss_per_batch_list = [] + pbar = tqdm(train_dataloader, desc=f"Epoch {epoch_idx}") + for batch_idx, batch in enumerate(pbar): + # batch = batch.to(device) + batch = batch.to(device) + # remap the batch if needed + if len(args.zch_method) == 0: + # pyre-ignore [16] # NOTE: pyre reports nonzch_remapper can be None, but when reach to this branch of condition, we know it is not None + batch = nonzch_remapper.remap(batch) + starter, ender = torch.cuda.Event(enable_timing=True), torch.cuda.Event( + enable_timing=True + ) + if True or len(args.zch_method) > 0: + benchmark_probe.record_mcec_state(stage="before_fwd") + # train model + starter.record() + ## zero the gradients + optimizer.zero_grad() + ## forward pass + loss, (loss_values, pred_logits, labels, weights) = model(batch) + ## backward pass + loss.backward() + ## update weights + optimizer.step() + ender.record() + # do statistics + num_queries_per_batch = len(labels) + starter_list.append(starter) + ender_list.append(ender) + num_queries_per_batch_list.append(num_queries_per_batch) + loss_per_batch_list.append(loss.cpu().item()) + if True or len(args.zch_method) > 0: + benchmark_probe.record_mcec_state(stage="after_fwd") + # update zch statistics + benchmark_probe.update() + # push the zch stats to the queue + msg_content = { + "epoch_idx": epoch_idx, + "batch_idx": batch_idx, + "rank": rank, + "mch_stats": benchmark_probe.get_mch_stats(), + } + queue.put( + ("mch_stats", msg_content), + ) + if ( + batch_idx % interval_num_batches_show_qps == 0 + or batch_idx == len(train_dataloader) - 1 + ): + if batch_idx == 0: + # skip the first batch since it is not a full batch + continue + logger.info(f"[rank {rank}] batch_idx: {batch_idx} get the stats") + # synchronize all the threads to get the exact number of batches + torch.cuda.synchronize() + # calculate the qps + # NOTE: why do this qps calculation every interval_num_batches_show_qps batches? + # because performing this calculation needs to synchronize all the ranks by calling torch.cuda.synchronize() + # and this is a heavy operation (takes several milliseconds). So we only do this calculation every + # interval_num_batches_show_qps batches to reduce the overhead. + ## get per batch time list by calculating the time difference between the start and end events of each batch + per_batch_time_list = [] + for i in range(len(starter_list)): + per_batch_time_list.append( + starter_list[i].elapsed_time(ender_list[i]) / 1000 + ) # convert to seconds by dividing by 1000 + ## calculate the total time in the interval + total_time_in_interval = sum(per_batch_time_list) + ## calculate the total number of queries in the interval + total_num_queries_in_interval = sum(num_queries_per_batch_list) + ## fabricate the message and total_num_queries_in_interval to the queue + interval_start_batch_idx = ( + batch_idx - interval_num_batches_show_qps + if batch_idx >= interval_num_batches_show_qps + else 0 + ) # the start batch index of the interval + interval_end_batch_idx = ( + batch_idx # the end batch index of the interval + ) + ## fabricate the message content + msg_content = { + "epoch_idx": epoch_idx, + "rank": rank, + "interval_start_batch_idx": interval_start_batch_idx, + "interval_end_batch_idx": interval_end_batch_idx, + "per_batch_time_list": per_batch_time_list, + "per_batch_num_queries_list": num_queries_per_batch_list, + } + ## put the message into the queue + queue.put(("duration_and_num_queries", msg_content)) + ## also fabricate the message for loss + msg_content = { + "epoch_idx": epoch_idx, + "rank": rank, + "interval_start_batch_idx": interval_start_batch_idx, + "interval_end_batch_idx": interval_end_batch_idx, + "per_batch_loss_list": loss_per_batch_list, + } + ## put the message into the queue + queue.put(("training_metrics", msg_content)) + # calculate QPS per statistic interval + qps_per_interval = ( + total_num_queries_in_interval / total_time_in_interval + ) + total_time_in_training += total_time_in_interval + total_num_queries_in_training += total_num_queries_in_interval + pbar.set_postfix( + { + "QPS": qps_per_interval, + } + ) + pbar.update(interval_num_batches_show_qps) + # reset the lists + starter_list = [] + ender_list = [] + num_queries_per_batch_list = [] + loss_per_batch_list = [] + # release the training dataloader + logger.info(f"[rank {rank}] release the training dataloader") + train_dataloader = None + del train_dataloader + # after training do validation + logger.info(f"[rank {rank}] get test dataloader") + test_dataloader = get_dataloader(args.dataset_name, args, "val") + logger.info(f"[rank {rank}] do validation") + metric_values = evaluation( + metric_modules, + model, + test_dataloader, + device, + nonzch_remapper if len(args.zch_method) == 0 else None, + ) + + # print the evaluation result + print(f"Evaluation result: {metric_values}") + # send the evaluation result to the queue + msg_content = { + "epoch_idx": args.epochs, + "rank": rank, + "eval_result_dict": metric_values, + } + queue.put(("eval_result", msg_content)) + + logger.info( + f"[rank {rank}] finished, sleep for 15 seconds before sending finish signal and exit" + ) + time.sleep(15) + queue.put(("finished", {"rank": rank})) + print("finished") + return + + # print("Total time in training: ", total_time_in_training) + # print("Total number of queries in training: ", total_num_queries_in_training) + # print("Average QPS: ", total_num_queries_in_training / total_time_in_training) + + +def evaluation( + metric_modules: Dict[str, RecMetricComputation], + model: nn.Module, + data_loader: DataLoader, + device: torch.device, + nonzch_remapper: Optional[NonZchModRemapperModule] = None, +) -> Dict[str, float]: + """ + Evaluate the model on the given data loader. + """ + # set model into eval mode + model.eval() + # run evaluation and update metrics + for batch in tqdm(data_loader): + batch = batch.to(device) + if nonzch_remapper is not None: + batch = nonzch_remapper.remap(batch) + with torch.no_grad(): + loss, (loss_values, pred_logits, labels, weights) = model(batch) + # update metrics + for metric_name, metric_module in metric_modules.items(): + metric_module.update( + predictions=pred_logits, + labels=labels, + weights=weights, + ) + # get the metric values + metric_values = {} # {metric_name: metric_value} + for metric_name, metric_module in metric_modules.items(): + metric_computation_reports = metric_module.compute() + for metric_computation_report in metric_computation_reports: + if metric_computation_report.metric_prefix == MetricPrefix.WINDOW: + metric_values[metric_name] = ( + metric_computation_report.value.cpu().numpy().tolist() + ) + break + # reset metrics modules + for metric_module in metric_modules.values(): + metric_module.reset() + # return the metric values + return metric_values + + +def statistic(args: argparse.Namespace, queue: multiprocessing.Queue) -> None: + """ + The process to perform statistic calculations + """ + mch_buffer = ( + {} + ) # {epcoh_idx:{end_batch_idx: {rank: data_dict}}} where data dict is {metric_name: metric_value} + num_processed_batches = 0 # counter of the number of processed batches + world_size = int(os.environ["WORLD_SIZE"]) # world size + finished_counter = 0 # counter of the number of finished processes + + # create a profiling result folder + os.makedirs(args.profiling_result_folder, exist_ok=True) + # create a csv file to save the training_metrics + training_metrics_file_path = os.path.join( + args.profiling_result_folder, "training_metrics.csv" + ) + with open(training_metrics_file_path, "w") as f: + writer = csv.writer(f) + writer.writerow( + [ + "epoch_idx", + "batch_idx", + "rank", + "loss", + ] + ) + # create a csv file to save the zch_metrics + zch_metrics_file_path = os.path.join( + args.profiling_result_folder, "zch_metrics.csv" + ) + with open(zch_metrics_file_path, "w") as f: + writer = csv.writer(f) + writer.writerow( + [ + "epoch_idx", + "batch_idx", + "feature_name", + "hit_cnt", + "total_cnt", + "insert_cnt", + "collision_cnt", + "hit_rate", + "insert_rate", + "collision_rate", + "rank_total_cnt", + "rank_num_empty_slots", + ] + ) + # create a csv file to save the qps_metrics + qps_metrics_file_path = os.path.join( + args.profiling_result_folder, "qps_metrics.csv" + ) + with open(qps_metrics_file_path, "w") as f: + writer = csv.writer(f) + writer.writerow( + [ + "epoch_idx", + "batch_idx", + "rank", + "num_queries", + "duration", + "qps", + ] + ) + # create a csv file to save the eval_metrics + eval_metrics_file_path = os.path.join( + args.profiling_result_folder, "eval_metrics.csv" + ) + with open(eval_metrics_file_path, "w") as f: + writer = csv.writer(f) + writer.writerow(["epoch_idx", "rank", "auc", "ne", "mae", "mse"]) + + while finished_counter < world_size: + try: + # get the data from the queue + msg_type, msg_content = queue.get( + timeout=0.5 + ) # data are put into the queue im the form of (msg_type, epoch_idx, batch_idx, rank, rank_data_dict) + except Exception as e: + # if the queue is empty, check if all the processes have finished + # if finished_counter >= world_size: + # print(f"All processes have finished. {finished_counter} / {world_size}") + # break + # else: + # continue # keep waiting for the queue to be filled + # if queue is empty, check if all the processes have finished + if finished_counter >= world_size: + print(f"All processes have finished. {finished_counter} / {world_size}") + break + else: + continue # keep waiting for the queue to be filled + # when getting the data, check if the data is from the last batch + if ( + msg_type == "finished" + ): # if the message type is "finished", the process has finished + rank = msg_content["rank"] + finished_counter += 1 + print(f"Process {rank} has finished. {finished_counter} / {world_size}") + continue + elif msg_type == "mch_stats": + epoch_idx = msg_content["epoch_idx"] + batch_idx = msg_content["batch_idx"] + rank = msg_content["rank"] + rank_batch_mch_stats = msg_content["mch_stats"] + # other wise, aggregate the data into the buffer + if epoch_idx not in mch_buffer: + mch_buffer[epoch_idx] = {} + if batch_idx not in mch_buffer[epoch_idx]: + mch_buffer[epoch_idx][batch_idx] = {} + mch_buffer[epoch_idx][batch_idx][rank] = rank_batch_mch_stats + num_processed_batches += 1 + # check if we have all the data from all the ranks for a batch in an epoch + # if we have all the data, combine the data from all the ranks + if len(mch_buffer[epoch_idx][batch_idx]) == world_size: + # create a dictionary to store the statistics for each batch + batch_stats = ( + {} + ) # {feature_name: {hit_cnt: 0, total_cnt: 0, insert_cnt: 0, collision_cnt: 0}} + # combine the data from all the ranks + for mch_stats_rank_idx in mch_buffer[epoch_idx][batch_idx].keys(): + rank_batch_mch_stats = mch_buffer[epoch_idx][batch_idx][ + mch_stats_rank_idx + ] + # for each feature table in the mch stats information + for mch_stats_feature_name in rank_batch_mch_stats.keys(): + # create the dictionary for the feature table if not created + if mch_stats_feature_name not in batch_stats: + batch_stats[mch_stats_feature_name] = { + "hit_cnt": 0, + "total_cnt": 0, + "insert_cnt": 0, + "collision_cnt": 0, + "rank_total_cnt": {}, # dictionary of {rank_idx: num_quries_mapped_to_the_rank} + "rank_num_empty_slots": {}, # dictionary of {rank_idx: num_empty_slots} + } + # aggregate the data from all the ranks + ## aggregate the hit count + batch_stats[mch_stats_feature_name][ + "hit_cnt" + ] += rank_batch_mch_stats[mch_stats_feature_name]["hit_cnt"] + ## aggregate the total count + batch_stats[mch_stats_feature_name][ + "total_cnt" + ] += rank_batch_mch_stats[mch_stats_feature_name]["total_cnt"] + ## aggregate the insert count + batch_stats[mch_stats_feature_name][ + "insert_cnt" + ] += rank_batch_mch_stats[mch_stats_feature_name]["insert_cnt"] + ## aggregate the collision count + batch_stats[mch_stats_feature_name][ + "collision_cnt" + ] += rank_batch_mch_stats[mch_stats_feature_name][ + "collision_cnt" + ] + ## for rank total count, get the data from the rank data dict + batch_stats[mch_stats_feature_name]["rank_total_cnt"][ + mch_stats_rank_idx + ] = rank_batch_mch_stats[mch_stats_feature_name][ + "rank_total_cnt" + ] + ## for rank num empty slots, get the data from the rank data dict + batch_stats[mch_stats_feature_name]["rank_num_empty_slots"][ + mch_stats_rank_idx + ] = rank_batch_mch_stats[mch_stats_feature_name][ + "num_empty_slots" + ] + # clear the buffer for the batch + del mch_buffer[epoch_idx][batch_idx] + # save the zch statistics to a file + with open(zch_metrics_file_path, "a") as f: + writer = csv.writer(f) + for feature_name, stats in batch_stats.items(): + hit_rate = stats["hit_cnt"] / stats["total_cnt"] + insert_rate = stats["insert_cnt"] / stats["total_cnt"] + collision_rate = stats["collision_cnt"] / stats["total_cnt"] + rank_total_cnt = json.dumps(stats["rank_total_cnt"]) + rank_num_empty_slots = json.dumps(stats["rank_num_empty_slots"]) + writer.writerow( + [ + epoch_idx, + batch_idx, + feature_name, + stats["hit_cnt"], + stats["total_cnt"], + stats["insert_cnt"], + stats["collision_cnt"], + hit_rate, + insert_rate, + collision_rate, + rank_total_cnt, + rank_num_empty_slots, + ] + ) + elif msg_type == "duration_and_num_queries": + epoch_idx = msg_content["epoch_idx"] + rank = msg_content["rank"] + interval_start_batch_idx = msg_content["interval_start_batch_idx"] + per_batch_time_list = msg_content["per_batch_time_list"] + per_batch_num_queries_list = msg_content["per_batch_num_queries_list"] + # save the qps statistics to a file + with open(qps_metrics_file_path, "a") as f: + writer = csv.writer(f) + for i in range(len(per_batch_time_list)): + writer.writerow( + [ + epoch_idx, + str(interval_start_batch_idx + i), + rank, + per_batch_num_queries_list[i], + per_batch_time_list[i], + ( + per_batch_num_queries_list[i] / per_batch_time_list[i] + if per_batch_time_list[i] > 0 + else 0 + ), + ] + ) + elif msg_type == "training_metrics": + epoch_idx = msg_content["epoch_idx"] + rank = msg_content["rank"] + interval_start_batch_idx = msg_content["interval_start_batch_idx"] + per_batch_loss_list = msg_content["per_batch_loss_list"] + # save the training metrics to a file + with open(training_metrics_file_path, "a") as f: + writer = csv.writer(f) + for i in range(len(per_batch_loss_list)): + writer.writerow( + [ + epoch_idx, + str(interval_start_batch_idx + i), + rank, + per_batch_loss_list[i], + ] + ) + elif msg_type == "eval_result": + epoch_idx = msg_content["epoch_idx"] + rank = msg_content["rank"] + eval_result_dict = msg_content["eval_result_dict"] + # save the evaluation result to a file + with open(eval_metrics_file_path, "a") as f: + writer = csv.writer(f) + writer.writerow( + [ + epoch_idx, + rank, + eval_result_dict["auc"] if "auc" in eval_result_dict else "", + eval_result_dict["ne"] if "ne" in eval_result_dict else "", + eval_result_dict["mae"] if "mae" in eval_result_dict else "", + eval_result_dict["mse"] if "mse" in eval_result_dict else "", + ] + ) + else: + # raise a warning if the message type is not recognized + print("Warning: Unknown message type") + continue + + +if __name__ == "__main__": + args: argparse.Namespace = parse_args(sys.argv[1:]) + + # set environment variables + os.environ["MASTER_ADDR"] = str("localhost") + os.environ["MASTER_PORT"] = str(get_free_port()) + # set a multiprocessing context + ctx: multiprocessing.context.SpawnContext = multiprocessing.get_context("spawn") + # create a queue to communicate between processes + queue: multiprocessing.Queue = ctx.Queue() + # # create a process to perform statistic calculations + stat_process: multiprocessing.context.SpawnProcess = ctx.Process( + target=statistic, args=(args, queue) + ) # create a process to perform statistic calculations + stat_process.start() + # create a process to perform benchmarking + train_processes: List[multiprocessing.context.SpawnProcess] = [] + for rank in range(int(os.environ["WORLD_SIZE"])): + p = ctx.Process( + target=main, + args=(rank, args, queue), + ) + p.start() + train_processes.append(p) + + # wait for the training processes to finish + for p in train_processes: + p.join() + # wait for the statistic process to finish + stat_process.join() diff --git a/torchrec/distributed/benchmark/benchmark_zch/benchmark_zch_utils.py b/torchrec/distributed/benchmark/benchmark_zch/benchmark_zch_utils.py new file mode 100644 index 000000000..98e93a1b7 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/benchmark_zch_utils.py @@ -0,0 +1,316 @@ +import argparse +import copy +import json +import logging +import os +from typing import Any, Dict + +import numpy as np + +import torch +import torch.nn as nn +import yaml +from torchrec.modules.mc_embedding_modules import ManagedCollisionEmbeddingCollection +from torchrec.modules.mc_modules import ( + DistanceLFU_EvictionPolicy, + ManagedCollisionCollection, + MCHManagedCollisionModule, +) + +from torchrec.sparse.jagged_tensor import KeyedJaggedTensor + + +def get_module_from_instance( + instance: torch.nn.Module, attribute_path: str +) -> nn.Module: + """ + Dynamically accesses a submodule from an instance. + Args: + instance: The instance to start from. + module_str (str): A string representing the submodule path, e.g., "B.C". + Returns: + module: The accessed submodule. + """ + module_names = attribute_path.split(".") + module = instance + for name in module_names: + module = getattr(module, name) + return module + + +def get_logger(log_file_path: str = "") -> logging.Logger: + """ + Initialize the logger. + Args: + log_file_path (str): The path to the log file. If empty, the log will be printed to the + console. + Returns: + logger: The initialized logger. + """ + # set basic configuration for the logger + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s %(name)s %(levelname)s %(lineno)d %(module)s %(message)s", + datefmt="%Y-%m-%d %H:%M:%S %a", + ) + # set formatter + formatter = logging.Formatter( + "%(asctime)s %(name)s %(processName)-10s %(levelname)s [%(filename)s %(module)s line: %(lineno)d] %(message)s" + ) + # create a logger + logger: logging.Logger = logging.getLogger() + # append a file handler to the logger if log_file_path is not empty + if log_file_path: + # create a file handler + file_handler = logging.FileHandler( + log_file_path, mode="w" + ) # initialize the file handler + # aet the formatter for the file handler + file_handler.setFormatter(formatter) + # add the file handler to the logger + logger.addHandler(file_handler) # add file handler to logger + return logger + + +class BenchmarkMCProbe(nn.Module): + def __init__( + self, + mcec: Dict[str, ManagedCollisionEmbeddingCollection], + mc_method: str, # method for managing collisions, one of ["zch", "mpzch"] + rank: int, # rank of the current model shard + log_file_folder: str = "benchmark_logs", # folder to store the logging file + ) -> None: + super().__init__() + # self._mcec is a pointer to the mcec object passed in + self._mcec = mcec + # record the mc_method + self._mc_method = mc_method + # initialize the logging file handler + os.makedirs(log_file_folder, exist_ok=True) + self._log_file_path: str = os.path.join(log_file_folder, f"rank_{rank}.json") + self._rank = rank # record the rank of the current model shard + # # get the output_offsets of the mcec + # self.per_table_output_offsets = ( + # {} + # ) # dict of {table_name [str]: output_offsets [torch.Tensor]} TODO: find out relationship between table_name and feature_name + # if self._mc_method == "mpzch" or self._mc_method == "": + # for table_name, mcec_module in self._mcec.items(): + # self.per_table_output_offsets[table_name] = ( + # mcec_module._output_global_offset_tensor + # ) + # create a dictionary to store the state of mcec modules + self.mcec_state: Dict[str, Any] = {} + # create a dictionary to store the statistics of mch modules + self._mch_stats: Dict[str, Any] = ( + {} + ) # dictionary of {table_name [str]: {metric_name [str]: metric_value [int]}} + + # record mcec state to file + def record_mcec_state(self, stage: str) -> None: + """ + record the state of mcec modules to the log file + The recorded state is a dictionary of + {{stage: {table_name: {metric_name: state}}}} + It only covers for the current batch + + params: + stage (str): before_fwd, after_fwd + return: + None + """ + # check if the stage in the desired options + assert stage in ( + "before_fwd", + "after_fwd", + ), f"stage {stage} is not supported, valid options are before_fwd, after_fwd" + # create a dictionary to store the state of mcec modules + if stage not in self.mcec_state: + self.mcec_state[stage] = {} # dict of {table_name: {metric_name: state}} + # if the stage is before_fwd, only record the remapping_table + # save the mcec table state for each embedding table + self.mcec_state[stage][ + "table_state" + ] = {} # dict of {table_name: {"remapping_table": state}} + for table_name, mc_module in self._mcec.items(): + self.mcec_state[stage]["table_state"][table_name] = {} + # + if self._mc_method == "zch": + self.mcec_state[stage]["table_state"][table_name][ + "remapping_table" + ] = mc_module._mch_sorted_raw_ids + # save t + elif self._mc_method == "mpzch" or self._mc_method == "": + self.mcec_state[stage]["table_state"][table_name]["remapping_table"] = ( + # pyre-ignore [29] # NOTE: here we did not specify the type of mc_module._hash_zch_identities, but we know it is a parameter of nn.module without gradients + mc_module._hash_zch_identities.clone() + .to_dense() + .squeeze() + .cpu() + .numpy() + .tolist() + ) + else: + raise NotImplementedError( + f"mc method {self._mc_method} is not supported yet" + ) + # for before_fwd, we only need to record the remapping_table + if stage == "before_fwd": + return + # for after_fwd, we need to record the feature values + # check if the "before_fwd" stage is recorded + assert ( + "before_fwd" in self.mcec_state + ), "before_fwd stage is not recorded, please call record_mcec_state before calling record_mcec_state after_fwd" + # create the dirctionary to store the mcec feature values before forward + self.mcec_state["before_fwd"]["feature_values"] = {} + # create the dirctionary to store the mcec feature values after forward + self.mcec_state[stage]["feature_values"] = {} # dict of {table_name: state} + # save the mcec feature values for each embedding table + for table_name, mc_module in self._mcec.items(): + # record the remapped feature values + if ( + self._mc_method == "mpzch" or self._mc_method == "" + ): # when using mpzch mc modules + # record the remapped feature values first + self.mcec_state[stage]["feature_values"][table_name] = ( + # pyre-ignore [29] # NOTE: here we did not specify the type of mc_module.table_name_on_device_remapped_ids_dict[table_name], but we know it is a tensor for remapped ids + mc_module.table_name_on_device_remapped_ids_dict[table_name] + .cpu() + .numpy() + .tolist() + ) + # record the input feature values + self.mcec_state["before_fwd"]["feature_values"][table_name] = ( + # pyre-ignore [29] # NOTE: here we did not specify the type of mc_module.table_name_on_device_input_ids_dict[table_name], but we know it is a tensor for input ids + mc_module.table_name_on_device_input_ids_dict[table_name] + .cpu() + .numpy() + .tolist() + ) + # check if the input feature values list is empty + if ( + len(self.mcec_state["before_fwd"]["feature_values"][table_name]) + == 0 + ): + # if the input feature values list is empty, make it a list of -2 with the same length as the remapped feature values + self.mcec_state["before_fwd"]["feature_values"][table_name] = [ + -2 + ] * len(self.mcec_state[stage]["feature_values"][table_name]) + else: # when using other zch mc modules # TODO: implement the feature value recording for zch + raise NotImplementedError( + f"zc method {self._mc_method} is not supported yet" + ) + return + + def get_mcec_state(self) -> Dict[str, Dict[str, Dict[str, Dict[str, int]]]]: + """ + get the state of mcec modules + the state is a dictionary of + {{stage: {table_name: {data_name: state}}}} + """ + return self.mcec_state + + def save_mcec_state(self) -> None: + """ + save the state of mcec modules to the log file + """ + with open(self._log_file_path, "w") as f: + json.dump(self.mcec_state, f, indent=4) + + def get_mch_stats(self) -> Dict[str, Dict[str, int]]: + """ + get the statistics of mch modules + the statistics is a dictionary of + {{table_name: {metric_name: metric_value}}} + """ + return self._mch_stats + + def update(self) -> None: + """ + Update the ZCH statistics for the current batch + Params: + None + Return: + None + Require: + self.mcec_state is not None and has recorded both "before_fwd" and "after_fwd" for a batch + Update: + self._mch_stats + """ + # create a dictionary to store the statistics for each batch + batch_stats = ( + {} + ) # table_name: {hit_cnt: 0, total_cnt: 0, insert_cnt: 0, collision_cnt: 0} + # calculate the statistics for each rank + # get the remapping id table before forward pass and the input feature values + rank_feature_value_before_fwd = self.mcec_state["before_fwd"]["feature_values"] + # get the remapping id table after forward pass and the remapped feature ids + rank_feature_value_after_fwd = self.mcec_state["after_fwd"]["feature_values"] + # for each feature table in the remapped information + for ( + feature_name, + remapped_feature_ids, + ) in rank_feature_value_after_fwd.items(): + # create a new diction for the feature table if not created + if feature_name not in batch_stats: + batch_stats[feature_name] = { + "hit_cnt": 0, + "total_cnt": 0, + "insert_cnt": 0, + "collision_cnt": 0, + "rank_total_cnt": 0, + "num_empty_slots": 0, + } + # get the input faeture values + input_feature_values = np.array(rank_feature_value_before_fwd[feature_name]) + # get the values stored in the remapping table for each remapped feature id after forward pass + prev_remapped_values = np.array( + self.mcec_state["before_fwd"]["table_state"][f"{feature_name}"][ + "remapping_table" + ] + )[remapped_feature_ids] + # get the values stored in the remapping table for each remapped feature id before forward pass + after_remapped_values = np.array( + self.mcec_state["after_fwd"]["table_state"][f"{feature_name}"][ + "remapping_table" + ] + )[remapped_feature_ids] + # count the number of same values in prev_remapped_values and after_remapped_values + # hit count = number of remapped values that exist in the remapping table before forward pass + this_rank_hits_count = np.sum(prev_remapped_values == input_feature_values) + batch_stats[feature_name]["hit_cnt"] += int(this_rank_hits_count) + # count the number of insertions + ## insert count = the decreased number of empty slots in the remapping table + ## before and after forward pass + num_empty_slots_before = np.sum( + np.array( + self.mcec_state["before_fwd"]["table_state"][f"{feature_name}"][ + "remapping_table" + ] + ) + == -1 + ) + num_empty_slots_after = np.sum( + np.array( + self.mcec_state["after_fwd"]["table_state"][f"{feature_name}"][ + "remapping_table" + ] + ) + == -1 + ) + this_rank_insert_count = int(num_empty_slots_before - num_empty_slots_after) + batch_stats[feature_name]["insert_cnt"] += int(this_rank_insert_count) + batch_stats[feature_name]["num_empty_slots"] += int(num_empty_slots_after) + # count the number of total values + ## total count = the number of remapped values in the remapping table after forward pass + this_rank_total_count = int(len(remapped_feature_ids)) + # count the number of values redirected to the rank + batch_stats[feature_name]["rank_total_cnt"] = this_rank_total_count + batch_stats[feature_name]["total_cnt"] += this_rank_total_count + # count the number of collisions + # collision count = total count - hit count - insert count + this_rank_collision_count = ( + this_rank_total_count - this_rank_hits_count - this_rank_insert_count + ) + batch_stats[feature_name]["collision_cnt"] += int(this_rank_collision_count) + self._mch_stats = batch_stats diff --git a/torchrec/distributed/benchmark/benchmark_zch/count_dataset_distributions.py b/torchrec/distributed/benchmark/benchmark_zch/count_dataset_distributions.py new file mode 100644 index 000000000..3fbd21e6e --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/count_dataset_distributions.py @@ -0,0 +1,250 @@ +import argparse +import json +import multiprocessing +import os +import sys +from typing import List + +import numpy as np + +import torch +from torch import distributed as dist +from torchrec.test_utils import get_free_port +from tqdm import tqdm + +from .arguments import parse_args + +from .data.get_dataloader import get_dataloader + + +def main( + rank: int, + args: argparse.Namespace, +) -> None: + # seed everything for reproducibility + torch.manual_seed(args.seed) + np.random.seed(args.seed) + # setup environment + os.environ["RANK"] = str(rank) + if torch.cuda.is_available(): + device: torch.device = torch.device(f"cuda:{rank}") + backend = "nccl" + torch.cuda.set_device(device) + else: + device: torch.device = torch.device("cpu") + backend = "gloo" + dist.init_process_group(backend=backend, init_method="env://") + + # get dataset + train_dataloader = get_dataloader(args.dataset_name, args, "train") + # test_dataloader = get_dataloader(args.dataset_name, args, "val") + + # feature value set + feature_name_feature_values_set_dict = {} # {feature_name: set(feature_values)} + feature_name_feature_value_count_dict = {} # {feature_name: feature_value_count} + feature_name_batch_feature_value_set_dict = ( + {} + ) # {feature_name: {batch_id: set(feature_values)}} + # feature remapping dict + feature_name_feature_remapped_values_source_value_num_query_dict = ( + {} + ) # {feature_name: {remapped_value: {source_value: num_query}}} + + pbar = tqdm(train_dataloader, desc=f"Rank {rank}") + for batch_idx, batch in enumerate(pbar): + batch = batch.to(device) + for attr_name, feature_kjt_dict in batch.get_dict().items(): + for feature_name, feature_values_jt in feature_kjt_dict.to_dict().items(): + if feature_name not in feature_name_batch_feature_value_set_dict: + feature_name_batch_feature_value_set_dict[feature_name] = {} + if ( + batch_idx + not in feature_name_batch_feature_value_set_dict[feature_name] + ): + feature_name_batch_feature_value_set_dict[feature_name][ + batch_idx + ] = set() + # update the feature value set and feature value count + if feature_name not in feature_name_feature_values_set_dict: + feature_name_feature_values_set_dict[feature_name] = set() + feature_name_feature_values_set_dict[feature_name].update( + feature_values_jt.values().tolist() + ) + feature_name_batch_feature_value_set_dict[feature_name][ + batch_idx + ].update(feature_values_jt.values().tolist()) + if feature_name not in feature_name_feature_value_count_dict: + feature_name_feature_value_count_dict[feature_name] = {} + if ( + feature_name + not in feature_name_feature_remapped_values_source_value_num_query_dict + ): + feature_name_feature_remapped_values_source_value_num_query_dict[ + feature_name + ] = {} + for feature_value in feature_values_jt.values().tolist(): + if ( + feature_value + not in feature_name_feature_value_count_dict[feature_name] + ): + feature_name_feature_value_count_dict[feature_name][ + feature_value + ] = 0 + feature_name_feature_value_count_dict[feature_name][ + feature_value + ] += 1 + + remapped_value = feature_value % args.num_embeddings + if ( + remapped_value + not in feature_name_feature_remapped_values_source_value_num_query_dict[ + feature_name + ] + ): + feature_name_feature_remapped_values_source_value_num_query_dict[ + feature_name + ][ + remapped_value + ] = {} + if ( + feature_value + not in feature_name_feature_remapped_values_source_value_num_query_dict[ + feature_name + ][ + remapped_value + ] + ): + feature_name_feature_remapped_values_source_value_num_query_dict[ + feature_name + ][ + remapped_value + ][ + feature_value + ] = 0 + feature_name_feature_remapped_values_source_value_num_query_dict[ + feature_name + ][remapped_value][feature_value] += 1 + + # do statistics + stats = {} + # get feature name to number of unique feature values mapping + world_size = int(os.environ["WORLD_SIZE"]) + bucket_size = args.input_hash_size // world_size + for ( + feature_name, + feature_values_set, + ) in feature_name_feature_values_set_dict.items(): + if feature_name not in stats: + stats[feature_name] = {} + print(f"feature_name: {feature_name}, get num_unique_feature_values") + stats[feature_name]["num_unique_feature_values"] = len(feature_values_set) + print( + f"feature_name: {feature_name}, get feature value distribution with respect to the WORLD_SIZE" + ) + stats[feature_name]["feature_value_distribution"] = {} + for feature_value in tqdm(feature_values_set): + feature_value = int(feature_value) % args.input_hash_size + bucket_idx = feature_value // bucket_size + if bucket_idx not in stats[feature_name]["feature_value_distribution"]: + stats[feature_name]["feature_value_distribution"][bucket_idx] = 0 + stats[feature_name]["feature_value_distribution"][bucket_idx] += 1 + print( + f"feature_name: {feature_name}, get feature query distribution with respect to the WORLD_SIZE" + ) + stats[feature_name]["feature_query_distribution"] = {} + for feature_value, feature_value_count in tqdm( + feature_name_feature_value_count_dict[feature_name].items() + ): + bucket_idx = feature_value // bucket_size + if bucket_idx not in stats[feature_name]["feature_query_distribution"]: + stats[feature_name]["feature_query_distribution"][bucket_idx] = 0 + stats[feature_name]["feature_query_distribution"][ + bucket_idx + ] += feature_value_count + print( + f"feature_name: {feature_name}, get feature remapping min-max collision rate" + ) + stats[feature_name]["feature_remapping_collision"] = {} + max_num_collisions = 0 + min_num_collisions = 0 + ds_num_collisions = 0 + num_total_queries = 0 + for remapped_value, source_value_num_query_count in tqdm( + feature_name_feature_remapped_values_source_value_num_query_dict[ + feature_name + ].items() + ): + # fetch the number of queries list for the remapped value + source_value_num_query_count_list = list( + source_value_num_query_count.values() + ) + # get the total number of queries for the remapped value + total_num_query_for_remapped_value = sum(source_value_num_query_count_list) + num_total_queries += total_num_query_for_remapped_value + # get the number of collisions for the remapped value + ## the dataset number of collisions is the number of queries that collide with the first appeared source value that remapped to the remapped value + ds_num_collisions_for_remapped_value = ( + total_num_query_for_remapped_value + - source_value_num_query_count_list[0] + ) + ds_num_collisions += ds_num_collisions_for_remapped_value + ## the max possible number of collisions is the number of queries that collide with the source value that has the minimal number of queries + max_num_collisions_for_remapped_value = ( + total_num_query_for_remapped_value + - min(source_value_num_query_count_list) + ) + max_num_collisions += max_num_collisions_for_remapped_value + ## the min possible number of collisions is the number of queries that collide with the source value that has the maximal number + min_num_collisions_for_remapped_value = ( + total_num_query_for_remapped_value + - max(source_value_num_query_count_list) + ) + min_num_collisions += min_num_collisions_for_remapped_value + # save the results + stats[feature_name]["feature_remapping_collision"][ + "ds_num_collisions" + ] = ds_num_collisions + stats[feature_name]["feature_remapping_collision"][ + "max_num_collisions" + ] = max_num_collisions + stats[feature_name]["feature_remapping_collision"][ + "min_num_collisions" + ] = min_num_collisions + stats[feature_name]["feature_remapping_collision"][ + "num_total_queries" + ] = num_total_queries + stats[feature_name]["feature_remapping_collision"]["ds_num_collisions_rate"] = ( + ds_num_collisions / num_total_queries if num_total_queries > 0 else 0 + ) + stats[feature_name]["feature_remapping_collision"][ + "max_num_collisions_rate" + ] = (max_num_collisions / num_total_queries if num_total_queries > 0 else 0) + stats[feature_name]["feature_remapping_collision"][ + "min_num_collisions_rate" + ] = (min_num_collisions / num_total_queries if num_total_queries > 0 else 0) + + # save results to json + os.makedirs(args.profiling_result_folder, exist_ok=True) + output_json_path = os.path.join( + args.profiling_result_folder, f"dataset_stats_rank_{rank}.json" + ) + with open(output_json_path, "w") as f: + json.dump(stats, f, indent=4) + + +if __name__ == "__main__": + args: argparse.Namespace = parse_args(sys.argv[1:]) + # set environment variables + os.environ["MASTER_ADDR"] = str("localhost") + os.environ["MASTER_PORT"] = str(get_free_port()) + # set a multiprocessing context + ctx: multiprocessing.context.SpawnContext = multiprocessing.get_context("spawn") + # create a process to perform benchmarking + processes: List[multiprocessing.context.SpawnProcess] = [] + for rank in range(int(os.environ["WORLD_SIZE"])): + p: multiprocessing.context.SpawnProcess = ctx.Process( + target=main, + args=(rank, args), + ) + p.start() + processes.append(p) diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/Readme.md b/torchrec/distributed/benchmark/benchmark_zch/data/Readme.md new file mode 100644 index 000000000..77210423a --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/data/Readme.md @@ -0,0 +1,10 @@ +# Datasets for zero collision hash benchmark + +## Folder structure +- `configs/`: Configs for each dataset, named as `{dataset_name}.json` +- `preprocess`: Include scripts to preprocess the dataset to make the returned dataset in the format of + - batch + - dense_features + - sparse_features + - labels +- `get_dataloader.py`: the entry point to get the dataloader for each dataset diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/__init__.py b/torchrec/distributed/benchmark/benchmark_zch/data/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/configs/criteo_kaggle.yaml b/torchrec/distributed/benchmark/benchmark_zch/data/configs/criteo_kaggle.yaml new file mode 100644 index 000000000..852d79631 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/data/configs/criteo_kaggle.yaml @@ -0,0 +1,3 @@ +dataset_path: "/home/lizhouyu/oss_github/dlrm/torchrec_dlrm/criteo_1tb/criteo_kaggle_processed" +batch_size: 4096 +seed: 0 diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/configs/kuairand_1k.yaml b/torchrec/distributed/benchmark/benchmark_zch/data/configs/kuairand_1k.yaml new file mode 100644 index 000000000..436fb4751 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/data/configs/kuairand_1k.yaml @@ -0,0 +1,109 @@ +dataset_path: "/home/lizhouyu/oss_github/generative-recommenders/generative_recommenders/dlrm_v3/data/KuaiRand-1K/data" +batch_size: 16 +train_split_percentage: 0.75 +num_workers: 4 +prefetch_factor: 4 +max_num_candidates: 10 +max_seq_len: 200 +contextual_feature_to_max_length: + user_id: 1 + user_active_degree: 1 + follow_user_num_range: 1 + fans_user_num_range: 1 + friend_user_num_range: 1 + register_days_range: 1 +uih_keys: + - user_id + - user_active_degree + - follow_user_num_range + - fans_user_num_range + - friend_user_num_range + - register_days_range + - video_id + - action_timestamp + - action_weight + - watch_time +candidates_keys: + - item_video_id + - item_action_weight + - item_target_watchtime + - item_query_time +user_embedding_feature_names: + - video_id + - user_id + - user_active_degree + - follow_user_num_range + - fans_user_num_range + - friend_user_num_range + - register_days_range +item_embedding_feature_names: + - item_video_id +uih_post_id_feature_name: video_id +uih_action_time_feature_name: action_timestamp +uih_weight_feature_name: action_weight +candidates_weight_feature_name: item_action_weight +candidates_watchtime_feature_name: item_target_watchtime +candidates_querytime_feature_name: item_query_time +merge_uih_candidate_feature_mapping: + - + - video_id + - item_video_id + - + - action_timestamp + - item_query_time + - + - action_weight + - item_action_weight + - + - watch_time + - item_target_watchtime +hstu_uih_feature_names: + - user_id + - user_active_degree + - follow_user_num_range + - fans_user_num_range + - friend_user_num_range + - register_days_range + - video_id + - action_timestamp + - action_weight + - watch_time +hstu_candidate_feature_names: + - item_video_id + - item_action_weight + - item_target_watchtime + - item_query_time +multitask_configs: + - task_name: is_click + task_weight: 1 + task_type: classification + - task_name: is_like + task_weight: 2 + task_type: classification + - task_name: is_follow + task_weight: 4 + task_type: classification + - task_name: is_comment + task_weight: 8 + task_type: classification + - task_name: is_forward + task_weight: 16 + task_type: classification + - task_name: is_hate + task_weight: 32 + task_type: classification + - task_name: long_view + task_weight: 64 + task_type: classification + - task_name: is_profile_enter + task_weight: 128 + task_type: classification +action_weights: + - 1 + - 2 + - 4 + - 8 + - 16 + - 32 + - 64 + - 128 diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/configs/kuairand_27k.yaml b/torchrec/distributed/benchmark/benchmark_zch/data/configs/kuairand_27k.yaml new file mode 100644 index 000000000..2909796b7 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/data/configs/kuairand_27k.yaml @@ -0,0 +1,109 @@ +dataset_path: "/home/lizhouyu/oss_github/generative-recommenders/generative_recommenders/dlrm_v3/data/KuaiRand-27K/data" +batch_size: 16 +train_split_percentage: 0.75 +num_workers: 4 +prefetch_factor: 4 +max_num_candidates: 10 +max_seq_len: 200 +contextual_feature_to_max_length: + user_id: 1 + user_active_degree: 1 + follow_user_num_range: 1 + fans_user_num_range: 1 + friend_user_num_range: 1 + register_days_range: 1 +uih_keys: + - user_id + - user_active_degree + - follow_user_num_range + - fans_user_num_range + - friend_user_num_range + - register_days_range + - video_id + - action_timestamp + - action_weight + - watch_time +candidates_keys: + - item_video_id + - item_action_weight + - item_target_watchtime + - item_query_time +user_embedding_feature_names: + - video_id + - user_id + - user_active_degree + - follow_user_num_range + - fans_user_num_range + - friend_user_num_range + - register_days_range +item_embedding_feature_names: + - item_video_id +uih_post_id_feature_name: video_id +uih_action_time_feature_name: action_timestamp +uih_weight_feature_name: action_weight +candidates_weight_feature_name: item_action_weight +candidates_watchtime_feature_name: item_target_watchtime +candidates_querytime_feature_name: item_query_time +merge_uih_candidate_feature_mapping: + - + - video_id + - item_video_id + - + - action_timestamp + - item_query_time + - + - action_weight + - item_action_weight + - + - watch_time + - item_target_watchtime +hstu_uih_feature_names: + - user_id + - user_active_degree + - follow_user_num_range + - fans_user_num_range + - friend_user_num_range + - register_days_range + - video_id + - action_timestamp + - action_weight + - watch_time +hstu_candidate_feature_names: + - item_video_id + - item_action_weight + - item_target_watchtime + - item_query_time +multitask_configs: + - task_name: is_click + task_weight: 1 + task_type: classification + - task_name: is_like + task_weight: 2 + task_type: classification + - task_name: is_follow + task_weight: 4 + task_type: classification + - task_name: is_comment + task_weight: 8 + task_type: classification + - task_name: is_forward + task_weight: 16 + task_type: classification + - task_name: is_hate + task_weight: 32 + task_type: classification + - task_name: long_view + task_weight: 64 + task_type: classification + - task_name: is_profile_enter + task_weight: 128 + task_type: classification +action_weights: + - 1 + - 2 + - 4 + - 8 + - 16 + - 32 + - 64 + - 128 diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/configs/movielens_1m.yaml b/torchrec/distributed/benchmark/benchmark_zch/data/configs/movielens_1m.yaml new file mode 100644 index 000000000..065de9ac5 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/data/configs/movielens_1m.yaml @@ -0,0 +1,83 @@ +dataset_path: "/home/lizhouyu/oss_github/generative-recommenders/tmp/data/ml-1m" +batch_size: 16 +train_split_percentage: 0.75 +num_workers: 4 +prefetch_factor: 4 +max_num_candidates: 10 +max_seq_len: 200 +contextual_feature_to_max_length: + user_id: 1 + sex: 1 + age_group: 1 + occupation: 1 + zip_code: 1 +uih_keys: + - user_id + - sex + - age_group + - occupation + - zip_code + - movie_id + - movie_rating + - action_timestamp + - dummy_weights + - dummy_watch_time +candidates_keys: + - item_movie_id + - item_query_time + - item_dummy_weights + - item_dummy_watchtime +user_embedding_feature_names: + - movie_id + - movie_rating + - user_id + - sex + - age_group + - occupation + - zip_code +item_embedding_feature_names: + - item_movie_id +uih_post_id_feature_name: movie_id +uih_action_time_feature_name: action_timestamp +candidates_weight_feature_name: item_dummy_weights +candidates_watchtime_feature_name: item_dummy_watchtime +candidates_querytime_feature_name: item_query_time +contextual_feature_to_min_uih_length: + user_id: 20 + sex: 20 + age_group: 20 + occupation: 20 + zip_code: 20 +merge_uih_candidate_feature_mapping: + - + - movie_id + - item_movie_id + - + - action_timestamp + - item_query_time + - + - dummy_weights + - item_dummy_weights + - + - dummy_watch_time + - item_dummy_watchtime +hstu_uih_feature_names: + - user_id + - sex + - age_group + - occupation + - zip_code + - movie_id + - movie_rating + - action_timestamp + - dummy_weights + - dummy_watch_time +hstu_candidate_feature_names: + - item_movie_id + - item_query_time + - item_dummy_weights + - item_dummy_watchtime +multitask_configs: + - task_name: rating + task_weight: 1 + task_type: regression diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/get_dataloader.py b/torchrec/distributed/benchmark/benchmark_zch/data/get_dataloader.py new file mode 100644 index 000000000..558eb222d --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/data/get_dataloader.py @@ -0,0 +1,52 @@ +import argparse +import os + +from typing import Union + +import yaml +from torch.utils.data import DataLoader + +from .preprocess import ( + get_criteo_kaggle_dataloader, + get_kuairand_1k_dataloader, + get_kuairand_27k_dataloader, + get_movielens_1m_dataloader, +) + + +# from .criteo_kaggle import criteo_kaggle +""" +Get a dataset loader for the zch benchmark +The data in each batch all follows the same format as +- batch + - dense_features: torch.Tensor or None + - sparse_features: KeyedJaggedTensor or None + - labels: torch.Tensor or None +""" + + +def get_dataloader( + dataset_name: str, # the name of the dataset to use + args: argparse.Namespace, # the arguments passed to the script + stage: str = "train", # the stage of the dataset to use, one of "train", "val", "test" +) -> DataLoader: + # get the dataset configuration from the yaml file + assert os.path.exists( + os.path.join(os.path.dirname(__file__), "configs", f"{dataset_name}.yaml") + ), f"Dataset {dataset_name} not found" + with open( + os.path.join(os.path.dirname(__file__), "configs", f"{dataset_name}.yaml"), "r" + ) as f: + dataset_config = yaml.safe_load(f) + # get the dataset + if dataset_name == "movielens_1m": + return get_movielens_1m_dataloader(args, dataset_config, stage) + elif dataset_name == "criteo_kaggle": + return get_criteo_kaggle_dataloader(args, dataset_config, stage) + elif dataset_name == "kuairand_1k": + return get_kuairand_1k_dataloader(args, dataset_config, stage) + elif dataset_name == "kuairand_27k": + return get_kuairand_27k_dataloader(args, dataset_config, stage) + else: + raise NotImplementedError(f"Dataset {dataset_name} is not implemented.") + return None diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/get_metric_modules.py b/torchrec/distributed/benchmark/benchmark_zch/data/get_metric_modules.py new file mode 100644 index 000000000..44a053cce --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/data/get_metric_modules.py @@ -0,0 +1,89 @@ +import argparse +import os +import sys +from typing import Any, Dict, List, Optional, Tuple, Union + +import torch +import yaml + +from torchrec.metrics.auc import AUCMetricComputation +from torchrec.metrics.mae import MAEMetricComputation +from torchrec.metrics.mse import MSEMetricComputation +from torchrec.metrics.ne import NEMetricComputation +from torchrec.metrics.rec_metric import RecMetricComputation + + +def get_metric_modules( + rank: int, args: argparse.Namespace, device: torch.device +) -> Dict[str, RecMetricComputation]: + # get the dataset configuration from the yaml file + dataset_name = args.dataset_name + assert os.path.exists( + os.path.join(os.path.dirname(__file__), "configs", f"{dataset_name}.yaml") + ), f"Dataset {dataset_name} not found" + with open( + os.path.join(os.path.dirname(__file__), "configs", f"{dataset_name}.yaml"), "r" + ) as f: + configs = yaml.safe_load(f) + metric_modules = {} # dictionary of {metric_name: metric_module} + # get the task_type: task_count mapping + task_type_count_dict = {} # dictionary of {task_type: task_count} + ## get the tasks from configs + multitask_configs = configs["multitask_configs"] + ## get the task_type: task_count + for task_info_dict in multitask_configs: + task_type = task_info_dict["task_type"] + if task_type not in task_type_count_dict: + task_type_count_dict[task_type] = 0 + task_type_count_dict[task_type] += 1 + # instantiate the metric modules + for task_type, task_count in task_type_count_dict.items(): + if task_type == "regression": + metric_modules[f"mae"] = MAEMetricComputation( + my_rank=rank, + batch_size=( + configs["batch_size"] + if args.batch_size is None + else args.batch_size + ), + n_tasks=task_count, + window_size=sys.maxsize, + compute_on_all_ranks=True, + ).to(device) + metric_modules[f"mse"] = MSEMetricComputation( + my_rank=rank, + batch_size=( + configs["batch_size"] + if args.batch_size is None + else args.batch_size + ), + n_tasks=task_count, + window_size=sys.maxsize, + compute_on_all_ranks=True, + ).to(device) + elif task_type == "classification": + metric_modules[f"ne"] = NEMetricComputation( + my_rank=rank, + batch_size=( + configs["batch_size"] + if args.batch_size is None + else args.batch_size + ), + n_tasks=task_count, + window_size=sys.maxsize, + compute_on_all_ranks=True, + ).to(device) + metric_modules[f"auc"] = AUCMetricComputation( + my_rank=rank, + batch_size=( + configs["batch_size"] + if args.batch_size is None + else args.batch_size + ), + n_tasks=task_count, + window_size=sys.maxsize, + compute_on_all_ranks=True, + ).to(device) + else: + raise ValueError(f"Unknown task_type: {task_type}") + return metric_modules diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/nonzch_remapper.py b/torchrec/distributed/benchmark/benchmark_zch/data/nonzch_remapper.py new file mode 100644 index 000000000..383a55114 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/data/nonzch_remapper.py @@ -0,0 +1,141 @@ +from dataclasses import dataclass +from typing import Dict, List, Optional, Tuple, Union + +import torch +from torchrec.modules.embedding_configs import EmbeddingBagConfig, EmbeddingConfig +from torchrec.sparse.jagged_tensor import JaggedTensor, KeyedJaggedTensor +from torchrec.streamable import Pipelineable + + +@dataclass +class Batch(Pipelineable): + batch_example_attribute: KeyedJaggedTensor + + def get_dict(self) -> Dict[str, KeyedJaggedTensor]: + return { + "batch_example_attribute": self.batch_example_attribute, + } + + +class NonZchModTableRemapperModule(object): + """ + Managed Collision Module with mod remapping + Given a list of input features, the module will return a list of remapped features + For each input feature value x, the remapped value is x % num_embeddings + """ + + def __init__( + self, + zch_size: int, + input_hash_size: int, + device: torch.device, + ) -> None: + self._zch_size = zch_size + self._input_hash_size = input_hash_size + self._hash_zch_identities: torch.Tensor = ( + torch.zeros(self._zch_size, dtype=torch.int64).to(device) - 1 + ) + self.table_name_on_device_remapped_ids_dict: Dict[str, torch.Tensor] = ( + {} + ) # {table_name: on_device_remapped_ids} + ## on-device input ids + self.table_name_on_device_input_ids_dict: Dict[str, torch.Tensor] = ( + {} + ) # {table_name: input JT values that maps to the current rank} + + def remap( + self, + features: Dict[str, JaggedTensor], + ) -> Dict[str, JaggedTensor]: + with torch.no_grad(): + remapped_features: Dict[str, JaggedTensor] = {} + for name, feature in features.items(): + values = feature.values() + self.table_name_on_device_input_ids_dict[name] = values.clone() + remapped_ids = values % self._zch_size + # update identity table _hash_zch_identities + ## if the slot on _hash_zch_identities indezed by remapped_ids is -1, update it to the input value + ## if the slot on _hash_zch_identities indezed by remapped_ids is not -1, skip the update + ## do that in one pass with torch operations + self._hash_zch_identities[remapped_ids] = torch.where( + self._hash_zch_identities[remapped_ids] == -1, + values, + self._hash_zch_identities[remapped_ids], + ) + self.table_name_on_device_remapped_ids_dict[name] = remapped_ids.clone() + remapped_features[name] = JaggedTensor( + values=remapped_ids, + lengths=feature.lengths(), + offsets=feature.offsets(), + weights=feature.weights_or_none(), + ) + return remapped_features + + +class NonZchModRemapperModule(object): + """ + Managed Collision Module with mod remapping + Given a list of input features, the module will return a list of remapped features + For each input feature value x, the remapped value is x % num_embeddings + """ + + def __init__( + self, + table_configs: List[Union[EmbeddingBagConfig, EmbeddingConfig]], + input_hash_size: int, + device: torch.device, + ) -> None: + self.mod_modules: Dict[str, NonZchModTableRemapperModule] = {} + self.feature_table_name_dict: Dict[str, str] = {} # {feature_name: table_name} + for table_config in table_configs: + table_name = table_config.name + feature_names = table_config.feature_names + for feature_name in feature_names: + self.feature_table_name_dict[feature_name] = table_name + self.mod_modules[table_name] = NonZchModTableRemapperModule( + zch_size=table_config.num_embeddings, + input_hash_size=input_hash_size, + device=device, + ) + self._input_hash_size = input_hash_size + + def remap(self, batch: Batch) -> Batch: + # for all the attributes under batch, like batch.uih_features, batch.candidates_features, + # get the kjt as a dict, and remap the kjt + # where batch is a dataclass defined like + # @dataclass + # class Batch(Pipelineable): + # uih_features: KeyedJaggedTensor + # candidates_features: KeyedJaggedTensor + + # for every attribute in + # for all the attributes under batch, like batch.uih_features, batch.candidates_features, + # get the kjt as a dict, and remap the kjt + # where batch is a dataclass defined like + # @dataclass + # class Batch(Pipelineable): + # uih_features: KeyedJaggedTensor + # candidates_features: KeyedJaggedTensor + + # for every attribute in batch, remap the kjt + for attr_name, feature_kjt_dict in batch.get_dict().items(): + # separate feature kjt with {feature_name_1: feature_kjt_1, feature_name_2: feature_kjt_2, ...} + # to multiple dict with {feature_name_1: jt_1}, {feature_name_2: jt_2}, ... + attr_feature_jt_dict = {} + for feature_name, feature_jt in feature_kjt_dict.to_dict().items(): + if feature_name not in self.feature_table_name_dict: + feature_remapped_jt = JaggedTensor( + values=feature_jt.values() % self._input_hash_size, + lengths=feature_jt.lengths(), + ) + attr_feature_jt_dict[feature_name] = feature_remapped_jt + else: + feature_name_feature_remapped_jt_dict = self.mod_modules[ + self.feature_table_name_dict[feature_name] + ].remap({feature_name: feature_jt}) + attr_feature_jt_dict.update(feature_name_feature_remapped_jt_dict) + feature_kjt_dict = KeyedJaggedTensor.from_jt_dict( + attr_feature_jt_dict + ) # {feature_name: feature_kjt} + setattr(batch, attr_name, feature_kjt_dict) + return batch diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/__init__.py b/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/__init__.py new file mode 100644 index 000000000..fe884acd1 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/__init__.py @@ -0,0 +1,4 @@ +from .criteo_kaggle import get_criteo_kaggle_dataloader +from .kuairand_1k import get_kuairand_1k_dataloader +from .kuairand_27k import get_kuairand_27k_dataloader +from .movielens_1m import get_movielens_1m_dataloader diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/criteo_kaggle.py b/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/criteo_kaggle.py new file mode 100644 index 000000000..aca031c32 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/criteo_kaggle.py @@ -0,0 +1,55 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import os +from typing import Any, Dict, List + +from torch import distributed as dist +from torch.utils.data import DataLoader +from torchrec.datasets.criteo import CAT_FEATURE_COUNT, InMemoryBinaryCriteoIterDataPipe + +STAGES = ["train", "val", "test"] + + +def get_criteo_kaggle_dataloader( + args: argparse.Namespace, + configs: Dict[str, Any], + stage: str = "train", # "train", "val", "test" +) -> DataLoader: + dir_path = configs["dataset_path"] + sparse_part = "sparse.npy" + datapipe = InMemoryBinaryCriteoIterDataPipe + + # criteo_kaggle has no validation set, so use 2nd half of training set for now. + # Setting stage to "test" will get the 2nd half of the dataset. + # Setting root_name to "train" reads from the training set file. + (root_name, stage) = ("train", "train") if stage == "train" else ("train", "test") + stage_files: List[List[str]] = [ + [os.path.join(dir_path, f"{root_name}_dense.npy")], + [os.path.join(dir_path, f"{root_name}_{sparse_part}")], + [os.path.join(dir_path, f"{root_name}_labels.npy")], + ] + batch_size = configs["batch_size"] if args.batch_size is None else args.batch_size + dataloader = DataLoader( + datapipe( + stage, + *stage_files, # pyre-ignore[6] + batch_size=batch_size, + rank=dist.get_rank(), + world_size=dist.get_world_size(), + drop_last=False, + shuffle_batches=args.shuffle_batches, + hashes=( + [args.num_embeddings] * CAT_FEATURE_COUNT + if args.input_hash_size is None + else ([args.input_hash_size] * CAT_FEATURE_COUNT) + ), + ), + batch_size=None, + collate_fn=lambda x: x, + ) + return dataloader diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/kuairand_1k.py b/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/kuairand_1k.py new file mode 100644 index 000000000..56f182a4d --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/kuairand_1k.py @@ -0,0 +1,267 @@ +import argparse + +import json +import os +from dataclasses import dataclass +from functools import partial +from typing import Any, Dict, List, Union + +import pandas as pd +import torch +from generative_recommenders.dlrm_v3.datasets.dataset import kjt_batch_func +from generative_recommenders.dlrm_v3.datasets.utils import ( + maybe_truncate_seq, + separate_uih_candidates, +) + +from torch.utils.data import DataLoader, Dataset +from torch.utils.data.distributed import DistributedSampler + +from torchrec.sparse.jagged_tensor import KeyedJaggedTensor +from torchrec.streamable import Pipelineable + + +@dataclass +class Batch(Pipelineable): + uih_features: KeyedJaggedTensor + candidates_features: KeyedJaggedTensor + + def to(self, device: torch.device, non_blocking: bool = False) -> "Batch": + return Batch( + uih_features=self.uih_features.to(device=device, non_blocking=non_blocking), + candidates_features=self.candidates_features.to( + device=device, non_blocking=non_blocking + ), + ) + + def record_stream(self, stream: torch.Stream) -> None: + # pyre-fixme[6]: For 1st argument expected `Stream` but got `Stream`. + self.uih_features.record_stream(stream) + # pyre-fixme[6]: For 1st argument expected `Stream` but got `Stream`. + self.candidates_features.record_stream(stream) + + def pin_memory(self) -> "Batch": + return Batch( + uih_features=self.uih_features.pin_memory(), + candidates_features=self.candidates_features.pin_memory(), + ) + + def get_dict(self) -> Dict[str, Any]: + return { + "uih_features": self.uih_features, + "candidates_features": self.candidates_features, + } + + +def collate_fn( + batch_list: List[Batch], +) -> Batch: + uih_features_kjt_list = [] + candidates_features_kjt_list = [] + for batch_data in batch_list: + uih_features_kjt_list.append(batch_data.uih_features) + candidates_features_kjt_list.append(batch_data.candidates_features) + + return Batch( + uih_features=kjt_batch_func(uih_features_kjt_list), + candidates_features=kjt_batch_func(candidates_features_kjt_list), + ) + + +def process_and_hash_x( + x: Union[str, List[int], int], hash_size: int +) -> Union[str, List[int], int]: + if isinstance(x, str): + x = json.loads(x) + if isinstance(x, list): + return [x_i % hash_size for x_i in x] + else: + return x % hash_size + + +class KuaiRand1KDataset(Dataset): + def __init__( + self, + args: argparse.Namespace, + configs: Dict[str, Any], + ) -> None: + super().__init__() + # open the seq_logs_frame file + self.seq_logs_frame: pd.DataFrame = pd.read_csv( + os.path.join(configs["dataset_path"], "processed_seqs_hashed.csv"), + delimiter=",", + ) + self._max_num_candidates: int = configs["max_num_candidates"] + self._max_seq_len: int = configs["max_seq_len"] + self._contextual_feature_to_max_length: Dict[str, int] = configs[ + "contextual_feature_to_max_length" + ] + self._max_uih_len: int = ( + self._max_seq_len + - self._max_num_candidates + - len(self._contextual_feature_to_max_length) + ) + self._uih_keys: List[str] = configs["uih_keys"] + self._candidates_keys: List[str] = configs["candidates_keys"] + + for key in self.seq_logs_frame.columns: + self.seq_logs_frame[key] = self.seq_logs_frame[key].apply( + partial( + process_and_hash_x, + hash_size=( + args.input_hash_size + # if len(args.zch_method) > 0 + # else args.num_embeddings + ), + ) + ) + + # define the items memory + self.items_in_memory: Dict[int, Batch] = {} + + def __len__(self) -> int: + return len(self.seq_logs_frame) + + def load_item(self, idx: int) -> Batch: + data = self.seq_logs_frame.iloc[idx] + video_history_uih, video_history_candidates = separate_uih_candidates( + data.video_id, + candidates_max_seq_len=self._max_num_candidates, + ) + action_weights_uih, action_weights_candidates = separate_uih_candidates( + data.action_weights, + candidates_max_seq_len=self._max_num_candidates, + ) + timestamps_uih, _ = separate_uih_candidates( + data.time_ms, + candidates_max_seq_len=self._max_num_candidates, + ) + watch_time_uih, watch_time_candidates = separate_uih_candidates( + data.play_time_ms, + candidates_max_seq_len=self._max_num_candidates, + ) + + video_history_uih = maybe_truncate_seq(video_history_uih, self._max_uih_len) + action_weights_uih = maybe_truncate_seq(action_weights_uih, self._max_uih_len) + timestamps_uih = maybe_truncate_seq(timestamps_uih, self._max_uih_len) + watch_time_uih = maybe_truncate_seq(watch_time_uih, self._max_uih_len) + + uih_seq_len = len(video_history_uih) + assert uih_seq_len == len( + timestamps_uih + ), "history len differs from timestamp len." + assert uih_seq_len == len( + action_weights_uih + ), "history len differs from weights len." + assert uih_seq_len == len( + watch_time_uih + ), "history len differs from watch time len." + + uih_kjt_values: List[Union[torch.Tensor, int]] = [] + uih_kjt_lengths: List[Union[torch.Tensor, int]] = [] + for name, length in self._contextual_feature_to_max_length.items(): + uih_kjt_values.append(data[name]) + uih_kjt_lengths.append(length) + + uih_kjt_values.extend( + video_history_uih + timestamps_uih + action_weights_uih + watch_time_uih + ) + + uih_kjt_lengths.extend( + [ + uih_seq_len + for _ in range( + len(self._uih_keys) - len(self._contextual_feature_to_max_length) + ) + ] + ) + + dummy_query_time = max(timestamps_uih) + uih_features_kjt = KeyedJaggedTensor( + keys=self._uih_keys, + lengths=torch.tensor(uih_kjt_lengths).long(), + values=torch.tensor(uih_kjt_values).long(), + ) + + candidates_kjt_lengths = self._max_num_candidates * torch.ones( + len(self._candidates_keys) + ) + candidates_kjt_values = ( + video_history_candidates + + action_weights_candidates + + watch_time_candidates + + [dummy_query_time] * self._max_num_candidates + ) + candidates_features_kjt = KeyedJaggedTensor( + keys=self._candidates_keys, + lengths=torch.tensor(candidates_kjt_lengths).long(), + values=torch.tensor(candidates_kjt_values).long(), + ) + + batch = Batch( + uih_features=uih_features_kjt, + candidates_features=candidates_features_kjt, + ) + return batch + + def get_item_count(self) -> int: + assert self.seq_logs_frame is not None + return len(self.seq_logs_frame) + + def unload_query_samples(self, sample_list: List[int]) -> None: + self.items_in_memory = {} + + def iloc(self, idx: int) -> pd.DataFrame: + assert self.seq_logs_frame is not None + return self.seq_logs_frame.iloc[idx] + + def load_query_samples(self, sample_list: List[int]) -> None: + max_num_candidates = self._max_num_candidates + self.items_in_memory = {} + for idx in sample_list: + data = self.iloc(idx) + if len(data.video_id) <= max_num_candidates: + continue + sample = self.load_item(idx) + self.items_in_memory[idx] = sample + + def get_sample(self, id: int) -> Batch: + return self.items_in_memory[id] + + def __getitems__(self, indices: List[int]) -> List[Batch]: + self.load_query_samples(indices) + samples = [self.get_sample(i) for i in indices] + self.unload_query_samples(indices) + return samples + + def __getitem__(self, idx: int) -> Batch: + self.load_query_samples([idx]) + sample = self.get_sample(idx) + self.unload_query_samples([idx]) + return sample + + +def get_kuairand_1k_dataloader( + args: argparse.Namespace, configs: Dict[str, Any], stage: str = "train" +) -> DataLoader: + dataset = KuaiRand1KDataset(args=args, configs=configs) + total_items = dataset.get_item_count() + train_split_percentage = configs["train_split_percentage"] + train_size = round(train_split_percentage * total_items) + if stage == "train": + dataset = torch.utils.data.Subset(dataset, range(train_size)) + elif stage == "val": + dataset = torch.utils.data.Subset(dataset, range(train_size, total_items)) + + dataloader = DataLoader( + dataset=dataset, + batch_size=( + configs["batch_size"] if args.batch_size is None else args.batch_size + ), + shuffle=args.shuffle_batches, + collate_fn=collate_fn, + prefetch_factor=configs["prefetch_factor"], + num_workers=configs["num_workers"], + sampler=DistributedSampler(dataset), + ) + return dataloader diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/kuairand_27k.py b/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/kuairand_27k.py new file mode 100644 index 000000000..2aa0245f2 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/kuairand_27k.py @@ -0,0 +1,266 @@ +import argparse + +import json +import os +from dataclasses import dataclass +from functools import partial +from typing import Any, Dict, List, Union + +import pandas as pd +import torch +from generative_recommenders.dlrm_v3.datasets.dataset import kjt_batch_func +from generative_recommenders.dlrm_v3.datasets.utils import ( + maybe_truncate_seq, + separate_uih_candidates, +) + +from torch.utils.data import DataLoader, Dataset +from torch.utils.data.distributed import DistributedSampler +from torchrec.sparse.jagged_tensor import KeyedJaggedTensor +from torchrec.streamable import Pipelineable + + +@dataclass +class Batch(Pipelineable): + uih_features: KeyedJaggedTensor + candidates_features: KeyedJaggedTensor + + def to(self, device: torch.device, non_blocking: bool = False) -> "Batch": + return Batch( + uih_features=self.uih_features.to(device=device, non_blocking=non_blocking), + candidates_features=self.candidates_features.to( + device=device, non_blocking=non_blocking + ), + ) + + def record_stream(self, stream: torch.Stream) -> None: + # pyre-fixme[6]: For 1st argument expected `Stream` but got `Stream`. + self.uih_features.record_stream(stream) + # pyre-fixme[6]: For 1st argument expected `Stream` but got `Stream`. + self.candidates_features.record_stream(stream) + + def pin_memory(self) -> "Batch": + return Batch( + uih_features=self.uih_features.pin_memory(), + candidates_features=self.candidates_features.pin_memory(), + ) + + def get_dict(self) -> Dict[str, Any]: + return { + "uih_features": self.uih_features, + "candidates_features": self.candidates_features, + } + + +def collate_fn( + batch_list: List[Batch], +) -> Batch: + uih_features_kjt_list = [] + candidates_features_kjt_list = [] + for batch_data in batch_list: + uih_features_kjt_list.append(batch_data.uih_features) + candidates_features_kjt_list.append(batch_data.candidates_features) + + return Batch( + uih_features=kjt_batch_func(uih_features_kjt_list), + candidates_features=kjt_batch_func(candidates_features_kjt_list), + ) + + +def process_and_hash_x( + x: Union[str, List[int], int], hash_size: int +) -> Union[str, List[int], int]: + if isinstance(x, str): + x = json.loads(x) + if isinstance(x, list): + return [x_i % hash_size for x_i in x] + else: + return x % hash_size + + +class KuaiRand27KDataset(Dataset): + def __init__( + self, + args: argparse.Namespace, + configs: Dict[str, Any], + ) -> None: + super().__init__() + # open the seq_logs_frame file + self.seq_logs_frame: pd.DataFrame = pd.read_csv( + os.path.join(configs["dataset_path"], "processed_seqs_hashed.csv"), + delimiter=",", + ) + self._max_num_candidates: int = configs["max_num_candidates"] + self._max_seq_len: int = configs["max_seq_len"] + self._contextual_feature_to_max_length: Dict[str, int] = configs[ + "contextual_feature_to_max_length" + ] + self._max_uih_len: int = ( + self._max_seq_len + - self._max_num_candidates + - len(self._contextual_feature_to_max_length) + ) + self._uih_keys: List[str] = configs["uih_keys"] + self._candidates_keys: List[str] = configs["candidates_keys"] + + for key in self.seq_logs_frame.columns: + self.seq_logs_frame[key] = self.seq_logs_frame[key].apply( + partial( + process_and_hash_x, + hash_size=( + args.input_hash_size + # if len(args.zch_method) > 0 + # else args.num_embeddings + ), + ) + ) + + # define the items memory + self.items_in_memory: Dict[int, Batch] = {} + + def __len__(self) -> int: + return len(self.seq_logs_frame) + + def load_item(self, idx: int) -> Batch: + data = self.seq_logs_frame.iloc[idx] + video_history_uih, video_history_candidates = separate_uih_candidates( + data.video_id, + candidates_max_seq_len=self._max_num_candidates, + ) + action_weights_uih, action_weights_candidates = separate_uih_candidates( + data.action_weights, + candidates_max_seq_len=self._max_num_candidates, + ) + timestamps_uih, _ = separate_uih_candidates( + data.time_ms, + candidates_max_seq_len=self._max_num_candidates, + ) + watch_time_uih, watch_time_candidates = separate_uih_candidates( + data.play_time_ms, + candidates_max_seq_len=self._max_num_candidates, + ) + + video_history_uih = maybe_truncate_seq(video_history_uih, self._max_uih_len) + action_weights_uih = maybe_truncate_seq(action_weights_uih, self._max_uih_len) + timestamps_uih = maybe_truncate_seq(timestamps_uih, self._max_uih_len) + watch_time_uih = maybe_truncate_seq(watch_time_uih, self._max_uih_len) + + uih_seq_len = len(video_history_uih) + assert uih_seq_len == len( + timestamps_uih + ), "history len differs from timestamp len." + assert uih_seq_len == len( + action_weights_uih + ), "history len differs from weights len." + assert uih_seq_len == len( + watch_time_uih + ), "history len differs from watch time len." + + uih_kjt_values: List[Union[torch.Tensor, int]] = [] + uih_kjt_lengths: List[Union[torch.Tensor, int]] = [] + for name, length in self._contextual_feature_to_max_length.items(): + uih_kjt_values.append(data[name]) + uih_kjt_lengths.append(length) + + uih_kjt_values.extend( + video_history_uih + timestamps_uih + action_weights_uih + watch_time_uih + ) + + uih_kjt_lengths.extend( + [ + uih_seq_len + for _ in range( + len(self._uih_keys) - len(self._contextual_feature_to_max_length) + ) + ] + ) + + dummy_query_time = max(timestamps_uih) + uih_features_kjt = KeyedJaggedTensor( + keys=self._uih_keys, + lengths=torch.tensor(uih_kjt_lengths).long(), + values=torch.tensor(uih_kjt_values).long(), + ) + + candidates_kjt_lengths = self._max_num_candidates * torch.ones( + len(self._candidates_keys) + ) + candidates_kjt_values = ( + video_history_candidates + + action_weights_candidates + + watch_time_candidates + + [dummy_query_time] * self._max_num_candidates + ) + candidates_features_kjt = KeyedJaggedTensor( + keys=self._candidates_keys, + lengths=torch.tensor(candidates_kjt_lengths).long(), + values=torch.tensor(candidates_kjt_values).long(), + ) + + batch = Batch( + uih_features=uih_features_kjt, + candidates_features=candidates_features_kjt, + ) + return batch + + def get_item_count(self) -> int: + assert self.seq_logs_frame is not None + return len(self.seq_logs_frame) + + def unload_query_samples(self, sample_list: List[int]) -> None: + self.items_in_memory = {} + + def iloc(self, idx: int) -> pd.DataFrame: + assert self.seq_logs_frame is not None + return self.seq_logs_frame.iloc[idx] + + def load_query_samples(self, sample_list: List[int]) -> None: + max_num_candidates = self._max_num_candidates + self.items_in_memory = {} + for idx in sample_list: + data = self.iloc(idx) + if len(data.video_id) <= max_num_candidates: + continue + sample = self.load_item(idx) + self.items_in_memory[idx] = sample + + def get_sample(self, id: int) -> Batch: + return self.items_in_memory[id] + + def __getitems__(self, indices: List[int]) -> List[Batch]: + self.load_query_samples(indices) + samples = [self.get_sample(i) for i in indices] + self.unload_query_samples(indices) + return samples + + def __getitem__(self, idx: int) -> Batch: + self.load_query_samples([idx]) + sample = self.get_sample(idx) + self.unload_query_samples([idx]) + return sample + + +def get_kuairand_27k_dataloader( + args: argparse.Namespace, configs: Dict[str, Any], stage: str = "train" +) -> DataLoader: + dataset = KuaiRand27KDataset(args=args, configs=configs) + total_items = dataset.get_item_count() + train_split_percentage = configs["train_split_percentage"] + train_size = round(train_split_percentage * total_items) + if stage == "train": + dataset = torch.utils.data.Subset(dataset, range(train_size)) + elif stage == "val": + dataset = torch.utils.data.Subset(dataset, range(train_size, total_items)) + + dataloader = DataLoader( + dataset=dataset, + batch_size=( + configs["batch_size"] if args.batch_size is None else args.batch_size + ), + shuffle=args.shuffle_batches, + collate_fn=collate_fn, + prefetch_factor=configs["prefetch_factor"], + num_workers=configs["num_workers"], + sampler=DistributedSampler(dataset), + ) + return dataloader diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/movielens_1m.py b/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/movielens_1m.py new file mode 100644 index 000000000..b92cfd889 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/movielens_1m.py @@ -0,0 +1,244 @@ +import argparse +import os + +from dataclasses import dataclass +from typing import Any, Dict, List, Tuple, Union + +import pandas as pd +import torch +from generative_recommenders.dlrm_v3.datasets.dataset import kjt_batch_func +from generative_recommenders.dlrm_v3.datasets.utils import ( + maybe_truncate_seq, + separate_uih_candidates, +) + +from torch.utils.data import DataLoader, Dataset +from torch.utils.data.distributed import DistributedSampler +from torchrec.sparse.jagged_tensor import KeyedJaggedTensor +from torchrec.streamable import Pipelineable + + +@dataclass +class Batch(Pipelineable): + uih_features: KeyedJaggedTensor + candidates_features: KeyedJaggedTensor + + def to(self, device: torch.device, non_blocking: bool = False) -> "Batch": + return Batch( + uih_features=self.uih_features.to(device=device, non_blocking=non_blocking), + candidates_features=self.candidates_features.to( + device=device, non_blocking=non_blocking + ), + ) + + def record_stream(self, stream: torch.Stream) -> None: + # pyre-fixme[6]: For 1st argument expected `Stream` but got `Stream`. + self.uih_features.record_stream(stream) + # pyre-fixme[6]: For 1st argument expected `Stream` but got `Stream`. + self.candidates_features.record_stream(stream) + + def pin_memory(self) -> "Batch": + return Batch( + uih_features=self.uih_features.pin_memory(), + candidates_features=self.candidates_features.pin_memory(), + ) + + def get_dict(self) -> Dict[str, Any]: + return { + "uih_features": self.uih_features, + "candidates_features": self.candidates_features, + } + + +def collate_fn( + batch_list: List[Batch], +) -> Batch: + uih_features_kjt_list = [] + candidates_features_kjt_list = [] + for batch_data in batch_list: + uih_features_kjt_list.append(batch_data.uih_features) + candidates_features_kjt_list.append(batch_data.candidates_features) + + return Batch( + uih_features=kjt_batch_func(uih_features_kjt_list), + candidates_features=kjt_batch_func(candidates_features_kjt_list), + ) + + +class MovieLens1MDataset(Dataset): + def __init__( + self, + configs: Dict[str, Any], + ) -> None: + super().__init__() + # open the ratings file + self.rating_frame: pd.DataFrame = pd.read_csv( + os.path.join(configs["dataset_path"], "sasrec_format.csv"), delimiter="," + ) + self._max_num_candidates: int = configs["max_num_candidates"] + self._max_seq_len: int = configs["max_seq_len"] + self._contextual_feature_to_max_length: Dict[str, int] = configs[ + "contextual_feature_to_max_length" + ] + self._max_uih_len: int = ( + self._max_seq_len + - self._max_num_candidates + - len(self._contextual_feature_to_max_length) + ) + self._uih_keys: List[str] = configs["uih_keys"] + self._candidates_keys: List[str] = configs["candidates_keys"] + self.items_in_memory: Dict[int, Batch] = {} # initialize the items in memory + + def __len__(self) -> int: + return len(self.rating_frame) + + def load_item(self, idx: int) -> Batch: + data = self.rating_frame.iloc[idx] + movie_history_uih, movie_history_candidates = separate_uih_candidates( + data.sequence_item_ids, + candidates_max_seq_len=self._max_num_candidates, + ) + movie_history_ratings_uih, _ = separate_uih_candidates( + data.sequence_ratings, + candidates_max_seq_len=self._max_num_candidates, + ) + + movie_timestamps_uih, _ = separate_uih_candidates( + data.sequence_timestamps, + candidates_max_seq_len=self._max_num_candidates, + ) + + assert len(movie_history_uih) == len( + movie_timestamps_uih + ), "history len differs from timestamp len." + assert len(movie_history_uih) == len( + movie_history_ratings_uih + ), "history len differs from ratings len." + + movie_history_uih = maybe_truncate_seq(movie_history_uih, self._max_uih_len) + movie_history_ratings_uih = maybe_truncate_seq( + movie_history_ratings_uih, self._max_uih_len + ) + movie_timestamps_uih = maybe_truncate_seq( + movie_timestamps_uih, self._max_uih_len + ) + + uih_kjt_values: List[Union[float, int]] = [] + uih_kjt_lengths: List[int] = [] + for name, length in self._contextual_feature_to_max_length.items(): + uih_kjt_values.append(data[name]) + uih_kjt_lengths.append(length) + + uih_seq_len = len(movie_history_uih) + movie_dummy_weights_uih = [0.0 for _ in range(uih_seq_len)] + movie_dummy_watch_times_uih = [0.0 for _ in range(uih_seq_len)] + uih_kjt_values.extend( + movie_history_uih + + movie_history_ratings_uih + + movie_timestamps_uih + + movie_dummy_weights_uih + + movie_dummy_watch_times_uih + ) + uih_kjt_lengths.extend( + [ + len(movie_history_uih), + len(movie_history_ratings_uih), + len(movie_timestamps_uih), + len(movie_dummy_weights_uih), + len(movie_dummy_watch_times_uih), + ] + ) + + dummy_query_time = max(movie_timestamps_uih) + uih_features_kjt = KeyedJaggedTensor( + keys=self._uih_keys, + lengths=torch.tensor(uih_kjt_lengths).long(), + values=torch.tensor(uih_kjt_values).long(), + ) + + candidates_kjt_lengths = self._max_num_candidates * torch.ones( + len(self._candidates_keys) + ) + candidates_kjt_values = ( + movie_history_candidates + + [dummy_query_time] * self._max_num_candidates # item_query_time + + [1] * self._max_num_candidates # item_dummy_weights + + [1] * self._max_num_candidates # item_dummy_watchtime + ) + candidates_features_kjt = KeyedJaggedTensor( + keys=self._candidates_keys, + lengths=torch.tensor(candidates_kjt_lengths).long(), + values=torch.tensor(candidates_kjt_values).long(), + ) + + batch = Batch( + uih_features=uih_features_kjt, + candidates_features=candidates_features_kjt, + ) + return batch + + def get_item_count(self) -> int: + assert self.rating_frame is not None + return len(self.rating_frame) + + def unload_query_samples(self, sample_list: List[int]) -> None: + self.items_in_memory = {} + + def iloc(self, idx: int) -> pd.DataFrame: + assert self.rating_frame is not None + return self.rating_frame.iloc[idx] + + def load_query_samples(self, sample_list: List[int]) -> None: + max_num_candidates = self._max_num_candidates + self.items_in_memory = {} + for idx in sample_list: + data = self.iloc(idx) + if len(data.sequence_item_ids) <= max_num_candidates: + continue + sample = self.load_item(idx) + self.items_in_memory[idx] = sample + + def get_sample(self, id: int) -> Batch: + return self.items_in_memory[id] + + def __getitems__(self, indices: List[int]) -> List[Batch]: + self.load_query_samples(indices) + samples = [self.get_sample(i) for i in indices] + self.unload_query_samples(indices) + return samples + + def __getitem__(self, idx: int) -> Batch: + self.load_query_samples([idx]) + sample = self.get_sample(idx) + self.unload_query_samples([idx]) + return sample + + +def get_movielens_1m_dataloader( + args: argparse.Namespace, configs: Dict[str, Any], stage: str = "train" +) -> DataLoader: + dataset = MovieLens1MDataset(configs=configs) + total_items = dataset.get_item_count() + train_split_percentage = configs["train_split_percentage"] + if stage == "train": + train_size = round(train_split_percentage * total_items) + dataset = torch.utils.data.Subset(dataset, range(train_size)) + elif stage == "val": + train_size = round(train_split_percentage * total_items) + val_size = round((1 - train_split_percentage) * total_items) + dataset = torch.utils.data.Subset( + dataset, range(train_size, train_size + val_size) + ) + + dataloader = DataLoader( + dataset=dataset, + batch_size=( + configs["batch_size"] if args.batch_size is None else args.batch_size + ), + shuffle=args.shuffle_batches, + collate_fn=collate_fn, + prefetch_factor=configs["prefetch_factor"], + num_workers=configs["num_workers"], + sampler=DistributedSampler(dataset), + ) + return dataloader diff --git a/torchrec/distributed/benchmark/benchmark_zch/figures/eval_metrics_auc.png b/torchrec/distributed/benchmark/benchmark_zch/figures/eval_metrics_auc.png new file mode 100644 index 0000000000000000000000000000000000000000..538636dde2606a0bb89e0b660174cafc526df69e GIT binary patch literal 40563 zcmc$`bzD{7yEVFKB_#x;MNArLkVa5xlx`4^?k+*PMWjJMKtxJfx z%gfAc{%@aPva~T`{$!(K1CDajN>bGpg79?VZ=`R6S??eyY5Ikj@N1{UjY&rh^}}kx zix|2H)PT38s#;!!^*Vm$I}RI8&0$gOd=}56*rmq|Ii$C%H#f^Rx2ML7rQ?$Z;<~89 zC|j-h^;@x6IH_WF`RjBJs0fVL4>4#&RsIO0#0?{MXZn1)mlJ!`w<#)IY`d2c_|cy} z#R`eRuLVfY2;=(gJOD}|K|hEFKs~JlF-wYOe3OPk*%npD;#Z=nMs$eMTI)0Wt(NUYs}j`y0yzc#AuBh$d7wB=u!0Wh5qbV zG~SjIp+i1%bH{&bj!E2|;@=ivl~CnKn`U|k9xs_K)925#n}-4-68<)I0vQUvSicoC z%3lYaW8lrtVt52Sj!NGo3s=jn=iB!DkY>A#v5{kGEaonH@25?eezX0n0*}p?0b;b3 zEuvxzzv21ri~aLwEQo9RgzML@Ul7zkuNT3?Mfv_c(yc%-V-t&($RGOL$~H)plrO7} z4^EG^FVAp@w6q)oTaDT0_NBMy6jt9tbqg=#Rf=g)?$!&htSO{#*zg=sa-){0`8+$t z6{01c_v08IzfTOtfOItmMO+GgJthG?{mi+-6hWx)Xf2}oTbos<%*!UzOBWLH=KFHl zyw*p?xJufdNt$!Vv%T`RyOE!`3Gt>pWow->TbpTEbp{1@D;yOBB znsaw)ZR{yN$cTyQztjimpHpx<5kWKr zfjdzN!#HHJVnBC(IXUBwhXoi{>BB2lKfcdc%wGX5^f^kkmZe9vWnXIl zsz0}j-IKi6@nww<{cy%PAF)8fZW}=X#$xdLH}33Pwd4L69bBcDC9nDhB}r!a6L)-q zdgpjejetzx`+ya-t1Zy-Y3Va@)!&oxZxhTq#)#I)9i{KyZay!`zq_-|BYXWzLzk6GRz3vV|dvr7mF_;7v2EfpWJ z$`w@6Agd_Jog;lgiPsA=Il<&1&lC3EQ7rK%Q&BCMmps>xx(Enp;ge~61qRvD{D%$U z@aIRIC^0qEJ21h&P*X!6NiN+;@`UpD`<&dvc$V2UGbL$h>BeOLfB=R@KCt824If26 zK{%)ww-uPnCJFE@2soDITpng_Dd3IbLQFB*cWks@8+>rC-1ytO34O_{K>|Amf<#2U zSuJJO3N`}+TIi>c;BktsZCOlhZETSJ)O=%)V{^)IV8lXpvUzx*6kBF$vhK$(tE@~S zvyen(hVa9{l|+$CC6XC4Qe%D;!~3LUwinmp0ED z^j7vzh7Z5xWjEJO9YgrDgtHGKp=XXV#bY^&`_Di4$6@4fadM;=lpEAJ@3}k^I64aU zFbzJ7RbgnE6GwE_dhQN#ej7w-^&a42pYv~273!JSM*ML;^a(J2l=kr>fy}xvm_ZS6 zg%>+nweeZCNo>vppP4mL1qHQ>OG{F}6p*$eWJJN{DU&_N%&$2PbI$lHj>X1eDf0yE zzZ*AVy||_?xVnjnkf5&$jtpAd)P3^!R*sGmnwrnT442cu#5qp55DJ{y&_g;FE>ApM z4$aT?*hsORE;6{}wEE6(D9PzSpPAJ|0(Js>O-jmNJKVwW;6{F9^bpcn49ZZcb%+*4 zJQrJdc^xHePNa~g&SwZovHgS(U7elhQZYDb4cCa=z(6TBDiFPkn4_=y&yFBxRy!Hl0%Pr?AQO4{Y96$^c6lp&W7EOLdN1%KBN4(s6 za?QhMCNSWeAg;(maC`6bJVvT@o|E4g_q;{&idi)Kb$z2~nAgn<$>eCS5a-n$CA;ul z70<>eq}b0B85u;3j2?njF687y3em9WAYaULh0mW-FP3cmNL}kO{?c;Nc&m5C&DdQfCj<@s_37q@-RJgV> zXD2IMsU5aP1s9N&p<4p1*dRLMdHW!v9rh1Ry+0HfO1%AnP|?8)KE!!${g0(fW0{vwz z$SWr1VY0`W{0CHwxI+mEaT-bIY zXRfaLW^%dwQO@c0V!c0~2CY)w!i5OW&YzoYFD)4+pTEpj5YARm9i0A|fz>rW?N*6J z7V6OJu>6u~=FImMihdqx)^gGJ>vJDAbhCH7WYNYY1Zg) z>e*JN%{_47v|S?&A{w&ILB3n}LN8Yqhq5N+99jHqC;y1wz)J~0!3h5Xf}witv4s#h zHMQkex}JvpVaE6Q`QdMtxA`0ls#e^4=69>Z(Gd?QY#(AH9)PcZz2S5LqXvm}$(#!b zEkGupymV8Cos5x5qw2%=wfMW^AQipV$Zp8^*&+EN`R(BG`gcESbsI+0Z`pPZH<$vQ z3BxJ~{hZ-1@Fp`glK^Z=lUyp=!nV=ba_l#%*+rrSH>2873nfu22D)@*=R<;#zi$6{ z&09T{roZPt_TrSnG7vX|fVuYIv-8gB#)24wRzzSxKw!kL%Jk}V6tF|}4r@>zF;<5B z`PuQPz3Ky>Wo7%EfJj5@w3mH)Uw~iyOH^O+9cvDH7Rv@!#|H4{^_#t=u5rOzAhpKw zbC3}PHjV05peD&+IXY$+HNuzlAuo@Kos*N+N`!`=pWn}H+Z4 z%YfT`yxo8;=j3#yziVkuAM9F{N)z$g^9v7;*r?Cm3#x%mt0kVZHpjOq+JDy%JnjQO z)sv^5Kc-eGRN>E?u9fRduy-aLfrhKG$t z)a3;ob`|2BUB?C<-}CsAB^6ZjYe`Z%_Y2bY)uzkS1B(rRR+)tQ$G0D3h3?MHw-F8o zM{QUn2ZN)dZ>K)Ll%V3Hjg;&x3zmLB_-nu<=LBA)v^MwW^|0H%u1G#2(vo}f<`E;k zzgqfxw^(aR09ThbRRf>?SnKFVtWAC_Ej`d3PcwSJ;8U-2G1<}ow~`S)GkbAu^$y#? z7N1w8#pTVd+QTj3!{Ncf`Qzma!OGUZ^%5zwjj{sNHkbPyF|%=59&azI!2;3tD8U)! zsrZ(gJesds*J8}3=-?Rc?| znMQkWV{hxnQxKpERYE>3sB+uUk*nnr^Heyi{A981Ej1}Y2k#*$`*qOQCe)mhps-&j z)CYR+?tno%wJnO4GV?l4RXt;6D4q_{ghwD_f4(o|Tw$vp5QcuRf$vrhuuhD6>Fmkv z4v>C2GgDRPhtw^aa7>kOoz4>|`F7il5(?c$^$?~U93@Umf*0fp*+hpE_Iz{mdSCiX ztk>)W1kM(0&#ZQCBztZ#@9Y*@P*xPe_XjGlX=XE^=0i%7@!#ZgxNEq!fJBnoXWW#f zZ6@sh)Ah^A&-++kh1V>={jKjla z*xaZ4ci&XsdrL>HbD^$;D3hW?fL_JeO%@mHjuFJ{6qSZet*JS$LWif^$S+Tq1-Th< z@$kZt=7T!u^JY5oOJ|pG)>$fh;;k-EC$J*QD`qp6FUKs|GG6q_OU6fgwNiPaCzN^k zU~E;lrf%0OwMZk)EwB5GTU6jvdzRh-^W0Or$4ktd7=Bbv+Ge0IFvvC2J8SkS+L3vO zi-#AJJ_hfZ&!C(bE&kT8bHl2=G4)FJBW zK;2ZQnVKBmrcrO&L_SZX%i|5j^Pq4o#Rswtm6tAPy1J=K%X&XZxzKJv2Hmgxwenj( zoAZ6?GcGimM%oy4)Dfx#W1cA6l?g_V#54T+)%ff$iC`lJwdecHOhb+AA1%uXwNyXd z^%}6vst`)S%I_ZjY{`^PkW<&ZX{qg*)vcT-_h@IQ5sxp|6Xfk$!|vFy#bL(!1k38+ z;(-O>VW;tuWmo>oxtwyufx6Y?pXQZ~jRsKq227uA9Xg$MDc>SxK_Yl@=vXp5gqqY6 zjEzAp;{DNTA$NRIaM~O}adD|gR)2l#IJtZzzNBnY=vURJ5|cf}kE3?|r=R&M8ggg#J6xNVfJQ~aU_M`L^d8lRrr@6PnyHPUs(t}1kK_PWz zEYCtzYinznKqLTJ;FRRuQIK>VCJ+G|NG;EM>xl` z(}Y&*9(Tdkt!LBoTYQ!rwKZ14=){a|A0+7-WG&Rf!v!uVKsHy=@JbZ0B~B=F^YQm^ zV9u1~qj4FUNv= zR0p~zCn*71Wzd>T%+q|CL2&!_rm?xb+cXD<$x+FZ*|!7SZwu7?pQH4DeE}D=ZP{n% zXI9(K9OrT!1?xai)6*LnEUf$9Edy?Q!$)zf6G~832h4mC(x`epw!Obx zuE!4#x|bQ4p02ZRJ6|RSrc4xj)Om1mm3idks;}jZdwOTQA_gI*t&gJWd4`KI;hEQ zXyQ7_@7$5)Demcr@r3qpH$Q@cU+SYI-O(a5RfA&fIkUmyLcI3j-wlt6>~#GZ&5(lw z+z-BfDif_Bn(FN~94}3u=HZteo>K2LrrtXWH%b<>lAHO`nw3d6pL8hL(6>SHL)HHL zi+PyAA`Pt@?E~@3rGB(|z5Cad%AV8(fK$y*`u&x?@9c$SBX3dO4lF|RJs$&=NoryC zP3uBd;*@Eypl1miI|Ts(5bE)MpI@^}{Fy<`>+LHN9A~%A;%qqBd3qk*0p%3N26LrG z*z(0LLCvv4*6nQXt35XUJ8Tvk$+OD+B_b3&a&I zukdg#B~8!CZzoU5LY=m#nH##KycLsNA!H(h8yUIv1u zL)AsTBTb~_Eqto5Q_d;hlAQc9ldj0Zf2c18{E#Pp(*hiOG3V-FpQ(GWV+{ta zf7SyGn?JwdV$j=ik7I=uyD^V^&%KLG-T50hH#td2J}W$`D%jl`F9hEb_FK{PpLG{8 z*GYy;A6|2z?B&l~6Dg52eYny8Ut>E%5{gi0VAx%_db0lhug!AHElQk?(R&*su3N68 z_WL-ZTbHf2p27-x$k2>NyR+NzASV&g?eywu6aj%L5WUzeREh}V5KFP)$20RiJADte zXU20=gdarVa4*BRM=cjO{|v#SD;$n;P3#)WT_xJ?Fp+X)?GwHbbp6_4?B^&K^M{^( zeFjZ?BcxEBW97k2hVrFvMli_?-sLViDjGT{!tP9Ojs*)|9A8?s=5oy&9a`G`sVqOZ zCWq5ZKc?hwdks%r?hw9yGdu%wGG?5VAAr$L$0gF`&W*fhXZ5F@n*cMh+P2so9UspH z=hw9SUH?qO`{Ymk_RLt*HKp9*+mL1p?{KT_7CwCPr?;U3uncx~BIavC9dTVcTPiJD z8Oeuq8&EwlBwRQ3t{Lg!s_t$k{=;w*e8FeLWtR&N5bIe8tO$O3>)u@oh$g0kCI+u2 z{KG%HVz^3q+6~LxeA8*m^Aa^sOwXe_JG)|<#`e|uLiZ`UyJpTHEvMnwH@)hi!Yk@K z&2%jFp6W>DHspa=$iGEQ_Qx_MAp!M4RQsB3&EKBonXN5>nf=;}&6M;Ydw!jNuIWch zreW35Z*n-3(=}W8 zfPhb_YMI0BkOzcX(|g@tP6aRaURCYpJIX0(=`I_$;t6<*U!5xP=TDoe)9r9T9*9UK zvE2ci9c2vQAu;jiGlAOAyh*fNC@D87;am4X7F$$bk+5d60%LkxFd#+HiP}&q-1hfr zIdNzQ^4H8#TmW4k2{=;anw$3;7w;%J-DO}PdfXleYLq{g4ydMywN^Kot4m+>7J_nj zH%9P6rneBj2)n`A^iddIS?#a@7MkBU;dVz1h~wvE^m*z*-`XV2CQB(jFPG_!&CPxC z!|?zzob|0e#{*M7;j|A(Xj#oK zz^N9@`ue)Vgq*MitCw-l_LBJ+ET~ENaB5wb+9P{h4=KwLr3tfJOq6z)h@Nv#rDh(g z&>UogVF244mbJbZ$;UNgJ;f(^iepnj5h^X+_M0cn_CAT+8%-aulrVbucS)`fR`BAH zh__GYX?i+s1TWuBZS%>nb5LaiK%i|o9T@63Y4S#pEslt=QH0UNl$~sM*C+uA!t^EK z{GqP@MjM_+u{^_xPVbWcfkLrhJ-1qU1Snl3XyWHAx|6f>Snd^Xl2%xkiWX3>Q|J3C zW8|_?*X_K^@n|oY(b&|Ky0>Kr@Tq^XFp(fCDk{lW(o{cl#b||>s_ecj<2J88H8Q8d zgTS2YojOh)a%9QGec*Zb*kKhe4+D%DtlRFX@K#gtIc_)hZD@RZopgS{sLD=VQ=`26 zR=|lH3vjCQdE=JC22ElKd)jJBxFu>RP%JMG*_K6P?dC{qjy@}9@T&q)wInq44G&Lm zd{D~q1^C*$Y{D3UAcX0&P;rM^ls|o`P1={c1P2?ZxYkfIRml(egk64D%?R z-&(vH!r=p&xU`rPsTi&NVc}rOz0xwJccX6;xt+RJ7?Wz&I$g~ifn{--Cm zKRp@zroXbD1Nbfol-fTu-K(X0;00j7=*o{QnIy4`ZvDQ1+jz<(Hcq2 zlT9otK*KWirhl^gRMZy>E;iJ>9`SvGXpAH5b-X+ec^F8`1qi@OK$PY!cZ^70b4h|^ z7jeDg(`3XDOc8bK4Xixm-BzUFyD7$ab#Wo{X5?Gk+M>{+v?ul_@=DP&d-EoID9}zwkA;`AzTb zR}93J6Q?ABV&@)-cYKOYZU>4n9Zu)Q&}-T1BmHm0+=E2TqD(nEK|MMHj@`BR_$}Lz zIo1rV>ZfX{Mrt~*ic7RLY5H2nf4*ODZ0C!%^vGm#R+{_PBLT;rg&;6lVh8*#_WawQ z-n8BceST*3?bJG>Z|X6iEF*Lf4z{)(0h=6Txz1e#+S=4kPEH}beu`O$uJM~sv%*i@ z;DdSCcS&9B}rz1vJnzxUi-0H&d6mER5{i_u2T0QF@qCI1Y|q=d{DD9Mz>xP`T)&OQRnKH0!}^Y3jXE5IWl0yBa_G#`%=K$>CUP#>-H6{E>k0`K0Hz zUI=unyOJ876ZWuC_Z5$$CKi6g0$_Q5o-toWJrth>>G4ly_>)|X!cKn5?E}h6kcFOp z3H=XzOef0fsmn&7QJ0`JF?KM3le*2Lz^j;Y=9sII=Iz1BiGz~4<}&BXO3gETIYNb z_|zmQaZ*9QPS7cM6V0{wt!?axl$f*)qiWXI$vejZOy%Tx2#4xOdK*ckKlDJQYLZHt zYhyZXPmI9@bUov^gHU>(UQZ3mNYQqkm&2|#D-foVB3_yoL8;$+^n$4V_T@jmavm&v zr%>|>K?^1}pz&~FfQ2=X>lt%%0fyMwJ$U}w0QHZe(Y<#=QV9pyL&lxsHWd?@%b;+- zVhr;j;hqh(|GkbLyjWbmRF)Hj=UZ%;tdf|9gef{~%_+V9My`y1Q`|0RFd&G*E3p+U z&{z2uWcxgT8q#u}y)+}hgGYtW6Em4LOPM=`c6Rl_w*Aq4+%~Y-g2(QJJO@z(WFj0O z<1Mh=`OKsR$;#rn`dw`tgJ|gl&eYOh1XDE^Kr)aC6i$_!nf0f3csX6FGmLC7uUV!# zIAzREyFGBnZ0Z-KYHQehB*wNVNS2k&*GIqs{)RViIHVSp6BWIVj*;Z$!?uV0S_T+Y z^a@E=vy1S74h7&-j?P&rIP_ zU)hkm9{lqbGo-ntDRim>eOvpp_bthMG>Q)-##u$K?!NecW+Ni_ipNcZ zG_fLLv?kfV&x_OIe`bicEOLTRw=#A&%K6^C`N#eT&c}c8pp+W2Xx8H!#87#~3#$%4 z`&c&Tk42)_3M6@ZeXF89%;Si*43s3SR77 zWg~O!3&@=2W2hMltDkBBKh8U*c8ix4Ih_A*fTA8vtIg6rx|S_CmjkQeFj8vai|p5F zX=#+XxnbMm25iD>Lx9wap67d*W%X|#)Qv)381%dtB+j}^(l>^wQN!RZwKQU{#vbp0 zieWwS$7%k@I!@IR7|w>bqmbmSe`8X9{8&cf-nOQ&p)%62oZ*lV!>yA@c*jpxgeD1q zaLvSD9KB4L`uH~;NtC#uNYT+e-||hp)aFqlB^N%C5@DiIc^v6x?E#cDOeHWTHQyJ@ zC^TTg!KA?;E~-z6bqg6H#U?9XAG@2Yl=e(;dKc-R#U2w7koV55IIe}|7=z%(2n$fk;+hdw2*z86V&9Xf9?9*5!-iq{Nf?AB?B=)v>=LfXy#Iv5fdlPMS%| z(n@?~i6iEDzCsmNg+!GHTdf&?*jDz@bHb8lwv7-@CMN3(7PYO_0TP5CFe z9yIE#Xx}ISwM|9|4v;uN!Ssl#>XHg1w6O2YK$*&&cJl|?9JbS?v~-uTiOKV+?5C1R z&#(@sZ2hH!sc6ZbDN{K%fpfJHz~`#ZLz4sv5Zss0(I`6UuEZWE$=9`p4J(RdU z^xE^zmJG`c^+kPNij`SB!IB*>-$JD9|fmdTK8!G;I$PZ80!FtPdN z`!96hjlfNIo?~@#rAIwHJYLGTrdtOV06<{AB4HLX5aY&1NBPa9taFLy-JuTw6ED1ePKlKakEXrP-Ztv6cY zC-3TkVuXp4FkZTKF7VU3f$LhS%22=p-7jW4sKHHe81fQ%1 zYI(thUo^L8A(3wC-CKb?glK&#O|`gcJ%dkVEdhk1v&(HT-{w(P*mbg zxN=?m9bPV6T(@L>=0FB~JrcKpZXn?yd>5)~Y(#mN-7Z=hElJmw7!zhbz2yy11}OSq z9VzF8&vTbxjhyU#GAl#lvlb3PeWoR&&XTn=fabh>$B!DtMZs!wIJbSTmWu=(IUQb_ zN=_Sjd-9V~K;WLU2HLqRF}+F%3OeT5T*CmgUTx^>c`dJ1A6$; zneV_w+4*`qZ|f{0Yv2_?kHz zE*NyQRi_q>hZwk`*}r(7`Zjc60UHeDMfgw_&&ABXr%t?DOK^?*Brh{hPK7f!&oRYe z=ts-cpE1KQRp9w3LK8n)7u0$#W1&?$hXMhe3NWX*RXcyljki|{%JJX?2qRTKn)Vkr zxt)2b0q1&@vV0M^{+WRtZzY-SF&VH+M!0XF(%x%;>o9~hARb2wO{sO#qkB2ja-Chj z?owAzoD}yP7dMt}zRImRk&IKwZaAfON6#Lhgb~$`4|jHUcc1$!_ySVdty@`W3ew=iSo&pi2IFtp#a{+T z<~Dl1EA^kZ3cis@=s0&=Hj2J%QJq&i;=(;(5(1dgU3_hK4-l5t7`{aF?h)K# zK{8d!t&7n%M}dH7t80x!K(Lj_vsLYWK07;#n=OUw8=fzE3aT=cJuk7jrJb6Le^sK) zj}GTKEJ@#PCB|{>#1nQ#BbKBDV%n zBk|l)qqVtD78gyOm}ay!>>lHN=QJ(075O~sFdU1*Y{imvirruq02Z`|JQw$IM7@!EXORrls#;;o++n{}V zd3z#bE8s>-0C2sPV&+bZcu`V*W_&#`OkNAqdDU~K_Ck&JJH+4 zNfaLtFY#~R5ioFt87F~Y0v8u&wLxkS+UyZ_wvCE+?%-}BfZSKC-WwK>_j9yS-}88W zduQYx9(MVB>g((R$4lX}RnLnsm`FA1Cgyb;D|pctxrDR>k^;)m{81s$co7GH8&Epr zvTYfRtL%q(Pl8Wp2+t0J(j(*p<9}I|g9;r5=I`k4KTw&}HhIbBurY=KhUg>l zv(RbQt}u;wB@TEzl`knN znXjBY-I?~hpy#YUMGES{@rR?1T`OindD4b%Mgo$4s$+kdFyPoya))?rh{B|8TP z-Uu}XQ9ww=JIHHjh|_IvHO6OZpU3fn7OWYxJ)#${h`Y+_`K~>6l^YjTJqs`TV)-AF zl})+blS$`(GQIpDJxH|JoV6588Pz8(_T?oh`xb| z5Fi)P&~cL{X=-w-%YA5+u1@NfwrryhUu-U9_71;{Skd z*jwD*_RpgBBy!IBHQf{a-2@c=R<@2;PJ{3yKXD))5RvM@c5U!#;mwk%SXf%}EB<8g zHG?j_qy*=o?DG6TT+yS-iF4A|nwlt_mXj8ULVV%(NFxOn9DwR)Tsa!na_gQey{_yd zlX=zUuF3!5kE}(0l_@FApBYsHwE67>hkj__24Vr63&R>QA9BKA8RHV(#BM?0Wp0F9u9PsD$C(AL#4s`aU`@;j zV7@eXyPO6*hknV?HLiipdUV|(t=`ABfOaws-?}P@jYEE_BK`UECkU+Yw(e)|hlWa# zPC-J4?K%LG!sf)>UswBrmPD@zd7<|5FNM?t#oA$zbwT@r&g_}9WGpMCUfw2ffrDU~ zH~IrwRd)m4GO#!N(Bf?IZ?V)XXgz7?(>=T|L>oEscL4r1F*}?B zRiwYCz;gma4i9SY$TWt8#p15_k=SX(MUC-i*`*cQCG`6gh@Dm?p}ZuUI=Yld@jejV(SP&mH%% z5U70%oIAMS{c*Y5Ie#OCl+(C!V*X(vh}=LqyjgZ>fC6YEURr*jV|y5|SsEDdFZK!) z{Y=J~No=hJm)5@JX;Pu0=2v@(c=Ji492Js#B2iP~mc7SzanUnu1ssCajaRG`Ee61N ze+CDA9j7lzfpiVgME?S0B+jS+KR-4wLV(^W8GlE?BUGS)9$-gaO)5oOUbqfrJFnkC z*w%PEsIa^_az5knT%bT;AxD1x7*c(Tr#F6(1njYOpuSeIo+NPfgC#*RFC)E>urzK6TmsJcXqnzp&0b1J2fElhoyOey zho&AWf%;5}A%G@4l&II2*Rh~pV|LEacgtJuBNax1*yy6Q!|H0|y?@61KnjFAWPqnU zd}h^)$HEsLxv>?XzWA&8`}$HpD7-ySduhJ83A)T=@e-PgfEEZ)I5V)$#OUreNHsM} z`Didn01+279?fgCqrn>eAlG#LQ(1m=OH1Fub32FZu5tR$j4g?KpYX%2i*|O|uZFK| zIBZ#cS6FyuMQ+Yam=%QFT;2l}3o3{P_&pyK4h(YWNXYI2o-PoMexT)O=^S)ENG2tH z$S<{Mz3`Ff9T*77FWYVc!hOlF{O;}?Mo_}& zY~kX<2aL=qTBnTgMLaFouDc8T#8vxS{;^biI4_C_fGd)yrluz1`%vH z8=o^eD2N~k(EcFdgz>_Z^qKb-a@+q<{;nHb>-_AG0Ba1_(!lVq<%*zOv2y|DJpAQu z?P3NNuA5XxtC|rV2I*nx#Xl%a><@JgvZK-^5^=dX4db0F3(A|;kiSk--l~{bbGiy< zd2bxtQL!KpF+;LE&arY@gn{*Frd|6SxsX-SoB&WA|GvJZFI85)a+;rnA?@z`V+k1O zxU0x4{`|wdpyw&-%Wmx^;Q9Ha{5q{70}Wh&nLN<2fesI}>i1up;$o>t^!qQ?*8o-j zS?cD-(h^t?Xk+7iUtVX!UsrbWJb@ye7jy&^ydOiK8ez!;)f?C?$}21Dr+e@Kn1=%> z#aGbhB_=lSC%Wtr8l2=;KJt#ZxR^2H?;3mEKL+(*SP@h6xsQdwr5>LOYKu$w|D5&! zTvPlQ@4&#&>`osAgZfX{=k{L3?2udmKAe~g2NQ8huW`xJW@L-!-dZJ-|MPUp(#`OF zMj=pP0(GLPiYGhZ1|ICk1*rti-Q9_dAKDEX;A%R(Zw}NMrRCvMcd9A64A}Nhtqrle zSNaXuZvH-Z>LPz0S6LVVmpUQNge}JGyqnWbsVyQ?b*3^bOVXsuo#QI3z_6PnV>DH2 zS6^GR3An`qbI;D|WqhVW$q(zw46ufCejp+4kk9kcb&d%19od39lmY}J)tgUQfYBxR znU0SC_xD({ z|5~6_e-hQ$*pCIY32z%gErg%^Qg@s)N(g-z_Lp2?8mPqj@GK1 z^S_d02=(Jjr8aA#5h1KO`e42-xqtMI!|U&8C2P)HM}&Q zRAc8VVZBRn@}K*$OG_L1?MhdEo&ucT|Ei}$eXHINC+YxsS+8(pu?02k-~OE!TUMyo zDPa+8v|d%6kIR3#>$Q_wTvC=$=3d1}Ud|*2dJ&xqMZiKEDm}mtzt+Fra8{uF1Z*0_ zqLcY;YB-4zcCSxPOt9&>0&+L{J0Uc)zOH{b*a>X!h&f*uENc9#1Z5-6`B(__QRxn@ zhY{m@*zeW{{r-+W9;2)Qno9h_tE^^?LAh#MhyrOTNnIJ6#THCjni*7pM>ti^2_)}S zI1GfM|J7}=2c0^xWk&bA3%=(AiHsU;Jr77aa3-{I<){kyGPv>-hI; zlZGEnq+8i&4vE-Hv&gA^B1Y9M{k9`Njm| zSs0~YV3KPMwRPAMV2NYP2#s3Q2d`_E93WrVlzt&SHVWPt^=-Z?NWvVi3X;4#y9kYhy3_ z8s49Wlz@xm$jSBI6E@DyZm4jqW0#LufNL#h1D65Vm{07nNWE z6gF_}6Z46K3WB}V=~u-ptXLkNUMZGS^!T9?4wN4}Hk?5Je2=J+a?D_>i%VPI#Dur) zGV|Dd&gOh~c>9>xh5 zgiAtF_!W>%?8tN!qAEYMfV>nkM4XRrSM3g+LSDXzW#QDFpGR=hFYwdUg{&3=y{Ysc z^qbhm)W7qjstQgvh;6u1Wngcj(!9DmkywT6yfko6BZ2*N-!+^C`1)^urDf684FjrV zGq~e-Lh5yd?4>Ek#>av9ufG(sdR5q=Umb+!Jt*wvJ|eiC9$^7Y6+1uo2M}qo8 zZAwbDDBaa;VHB?N()b($(d#@24^SrnVEUP9D=K0@z@*W{x9x7Wy>m4?ZSO(d2)Bm; zCmAFpREK&tmwLM6>3RH&%5}j=lnPO4L?vPJk^q{qX}+D<&0Js~cnBNctM6QO`@$tF&COuZ5 zG(iwB%l}lrcC0L@fa3yM776Ollqx+L34BJMRd$egUFd0~0G$G~n?pN01s+Lw&OKv5 zo$On(zP>HCV9s~<{-Q#5c8_ueO0z5OKr@T0x`^`Yf%1TX0$~ps0*)S4F#dt+yLan3 z!-KCENh6TJLRPIIuk_Ih;KSD2wLbOa4gst?B;=;?V{-1gj%o$>`6uABf$ISH_q1Hh z32OwcZczTd2-n}2`JK~eY+YJF3M}QEfc!+-3qeth;2BQ73u;UNp;0PE5euLhp?tnH zVdug>ML1_rcb#h*{*J?lMX4jVti}Tv`2hF6)PtyF`$$Q+P3~s011XAvqPlbeMSht0`w zOUEs=|Ee3;>-!p6)yWc{(^6oo8I=U60J{%DEUzLcnI(mS7vvRQ#sxQ9gZ^6}`+OzjOqyLsy7#GF&w%K`}zG6WhG zBRk10d3QRm3iUkM$m&Tfd4a9UQ}O5t6B6`8yOJO|Ihm7(`D)qF-yuPhe5c9- zd|Qyt+JbR;CC=r7>a~_9+s8u2$e4Sywr+_8fsO&dFID|7yOtStn}3SiJJ8C1kHB75 zk&kSU0|0)|mwB%=96);@Pq!NYH3#T;5`X)Q5>k~+X=2)~4k-oSOVa(Ed2}6G!@Dpe z^ji^T_TQ17t9ya2uGq4NN2j49Q$X|sP1D6?jzU-cwZgND_rGn!YXDHf(99B!DLzZR zcCYi*?#e@(pTlR!P6QZ5?*%R>1)q3i|7_18?-k_0mmx(%VIT}QB9cGDU4=U!-n?;C`VT#}xK!N@$5=5CR5nqJd*N|U@Z@diukV-%$vp~`=8P+A zuSIhrMMkHVdTaJwoFm z3Qw@m2nJ-`0tMfD;NWK=4J`+RPjJTDBbyF~&X=+80bLl7LWNa0VlC@gQK_w|FZQoO zWnl6b$4gMW6>N?tL0%u?cH3eT3 z9RZjBA!Bs=?CdHUXiXEYpw4%0d}O=a`L8PB-%VZjxUs!Pm2nheWDlPKEM~Ygqt`_T z*lHn}+joM{8FpxafCeY2zjgv{RktN&U%_@k(7Raj_J+^L7a2>NHIAZw{bfl~4~oiR zzXhJ)F#+JGfJ|GyUYd{_GQ<|fFmpoikJs|)2@yEYKXsD@!ve6(pz2S3m^FICtz`?h z443OowO}TMBdsn1;v^$@S$}oz7(CrVTxRQLVjEv52(4p$pN=l-?z(x-+@fuGs5h1P z8ZgD8skb=$2P99zL|0ej)a<0xT`Qf(TZ60_1SxofUS+(6y!bq92;JP>e*{It>v=`Z zunhTYK8SDS$1UUqx|3u?Nqpgn6NI4U#!t&q=4~)xn%CaY>he12VPy$^G74HNIqR?WuEOIz7a!*o&^_3B#GSBL^dH-B4M1bY`tW}&(R^@2JYnPK zxaUP<5qNBbP88`iv1BhpFT|wv1Xjhk-IvU2qks3=N*GKfvctJKKfFx(1o1yhK%BpS zSCZJrQBe9ucf^c-wY<9WwWVIt!SoFMg|BdV!NsglrH}$ zR<2N#9(eMMCko#orM>>R2;WVdA$}k`l1N#9q7-LDScaZwfYul&6KVx zbRyzpA7BEjeSjZ~PtJ#vT@=N__qeZWjOz*mhRSl%3jrMt>DfGQ+P!-b5x2sD*%Y)n zp+K*bo_yndcu=(uRN*uB1Nec;K;{+qJV%Rf(aBAkSIYwKyuEa z1Vuo^0Fnd*L?kE4IZ2kBlagVBDyod>usyT1J zePEtlLg}uWazLQu&iCz~MfSp9T0j3+#x7fJaK-jA?ah9?Bw>Nk+ zjbB{8W|HK%sRN`k@SO?&h=`);;;9CYp3%ccPn44?HkRJKgi_UqwSDKuK}b}Q(&qUh z629VmVmO!q#Ubh0WegoeNnp5QDALGbeRb-*_Xssod z<64m9OtBG~scKfm$O+=zR|btwuXa51eWvrW?xRc&jb9ZQGQ8e)W+EPMbA*%jc}qb_ zkj;%k>M|s;L2ozP?^hw02{;O$M||(7 z0$#7GJEPK;|9=&0H@2z5~XLLZ5S^<$#a~+ ze$Xy+c;7Y$)Tvt@Mp-H~5icNBQ5jl1!S1ila0U1)K)i@|OLcT|y6;xa)DRX748vsY znUD6D`Q!vbuVbx50-J&$Q2tNhExa@4MO&<(nR@A4g#{9&ah zHNyrCZ6`8QOrHX3@>2GNzEZfDH7zh?z$8XF!X9{IDhafANiYaMO zfIxL7MEJp3v`LsZm55rb0X?_~%Y>4aQFn1nRffmR$oxO_QT~!4L8D8j3-^cn?vQ)T zwdBjUEQ!$=A70vM)-p)i{D4Wf@axx8RSr+3j%U!WLkm3LJ{vng3A`Gs?;+w0CT8>} z0NJRhbq-h>PeY9u^`fKlos);z$;sAMi^UcSV`U!RnuRX)_#+ncdV&=7(_Cknl9aW4 zlKbpR_0Q@wuMsZRKIsf3-0#uQK!FW%nVUCl$Ur$r21X*(qzk#k=F2(rLLHjt*P6zH zn{)0jb4F2;7Cq57A6w;o^1r``v`Aa_*1Y?|6?1o)Qs zLr;8se7rE-PQ(K7dNVo9hzGdU?Ph*kSJP&S!l2B9N=hA^K)4Ulf$3uFX-QsMfKE&R z*{{Z##qIgqx1DZV0uzm8fD%DGph`+x)oSlyFZ-awcMfnhA-U|yOiWs!A8s=|Xt7{H z3)i6&c z5@kT6jG)s{dbe6sVnB%0CUmFU=k=fvOE|lmx0cOBfI&^0@7rw7@C&q~!sWH8&MB zxOggF*R?7$tGmTfP2O8vthstMf8yBc(n|Wei(9ee*SWVxP`fk~j25=9rRo8>!#B|H z@pVpFO;kEdJygbpkd{X*C06E{ z>(Cy8gq(@q>kj(${3_Et105AJ^TWFm5NSqt&7?o*BZHI=)rdQA$0wJTR5(QvA@r^5@t zR$Onnzg+@k1ayta@*S>%)8n9Dlg`j%86%S!EgwCDX2C+p=T{>{9oA3U#zHu143 zM=bt7CRF2}21Ss{DuoL7y&ChE_S2+Iw6xI~8H~(Vk1spnL3Q&00l|Gxu0jFF8;TCG z^ZR808n{3xFw=oM2DAfs*=qip&Z~M|kvkNARSS#C&^x)vL3<&gBf3b2xJYXV-khl@yzHBeIvjKcj3Gx;YgtS!S`U|<1J)+A#AK@b1uyJidt#a< zvtmS=;K)=7l=KCa)|&GGFb}hnnIZN6lw=}peQm~Lw4%9-uw=WcdGio1IT;x)@-d!c z1n3go0{eWH47`Ft92^9i5s~XZn{VAzebG;yV6i)T{N$U@7y9xG3iOn0IKUAD5lp^g z=VvYJ?*@7bY6scazo;|qYuu^{AdD!YGN@+PF_1t|F}b?4xFD!*IjQ>x;%=Ul7{N@4 z%$@_eJ@a86Y#z|_1iCE6g@qEJq&a6Awi-Zom@Z20=FJZsx7V>LU~9KNMEbF<-@kjK z%R$?$XZ)|8JEc1=WXMgGq2WLOA=59Sw}8C`ACRc~2o)q(gbfZI@1W6ReeJZGdLM!) zCAL%kQSpb|DG}N&0CEc4^uBzdrlv|E)A9O#TFC_aQ=;cqP$3CBzK?4EX>z9R+S7fUhO5xPRsYXgd>{!m9vm>kCGj zwE=5F*xY9s_T_`;LZIieo#}-@WJM&gGNTRRDFlI|u<;QzYx&Kan?s&}`Dzi`5hEDB zVsGv9zm5S*WcD8|8^f|`9zoQ>$18c63RlhG4|=`Z;H`zP|Kw=W z9WES%>u$pNKbm0sK|LOPf+GQ17W(|z#3NEJ4N7SU;#{()Q_4(*h=$veBEuuBx<v zMR<#VS95mI9)W-fiZ5Uzf&+977lG9Yi5BA=^HqSNsJ!IoV+KzUcp}OZpa=n3GJ`p*2MSs>|*iJ~D_MO&NH$aK#&Hm9fEKc{*I zo~i0Ln_;8=T3Ohjo)MAbA+NPk(hNoR*F76NyDyqWxK!!%Lv#Ipr{CON1wJ(Tqu~LI z^;GZ)6b$$bP}vfD-)Ghrg83}QO<6$|0YU9-51_5!$Nz#|1pbUUU!g9b4CB!J5$%U| z{AnR(RJrkp87(Ne%uB#43aGY`swb6RQS+bR!3UHir>iD6Peppa1h7d_r7-X` zeuHS~1ZYs6`Or`^=RQi--xlr#SIUds^wYt0`oXGBzmsyGvip;3PXCmaU$D6OVb~4Q z8kgm|cOZg3b3aNc&NJgWR6^^!?T3$<^`w!JOf*yX{}zf^Y+igCko8|H3&D&BglzSb zsh)6C&}Sw7KmfO9Nkc|w>;m6y7V+lT!=wUkB5LJ?W;p#`{&~Qb<+6t zr1ZbSrzC_x5%$YnS0SNXX>LjxZrTd<=+gF6!QQ5)Y5n-)ns0Zh{^2>1L6%~4wc8C1^$LENtMVYbfK+QgAgwA$n z(?NskOkf$k!u(=z?RiToC~PnK`OIfeUfY(Ro=%nQ6)f`<5*CeyArkWiC#(h2X zhAvbg#vfHt;FY_7!IUl**YrJy$|VF|J=q>`Ea4C>+ zMZOdtol2~OHd-lP)b_xK8i}1sJ@64IT8`+R0u+tK{I)EBhlP#QuRY9CTgr)R>(5_# zn1B`^PFId6_W`1;Qig{H1rUeLu0S>p{e?vHtzRpP)qF?u$=x?f=s*zseC&jRe?BrL z{yo1ixttaKux~x?c=_BI|<{~e)n!SH>Ziszrv$rGYaL4-KEIR zCi<<26gM3I=XRA9w5uSWr{mSaMYzMGbZ#xSUgLVB+v@4qy*kIM!OP-mH87Cclo2;C=iK(D8AJsg}Sj$4}*6`9OR zp-cx^w0&0RKzurh^Q^LQ#P!+(D+dRsvc4|uKf0p(hPr=B>eZO(_u%8Dqp^`x zZ=^8b36gKe)P(Yj#wrHMbNpe1`-d3RP1$Qq2;~{SI6V&fOB0+J&mh3iQbuB3%=bquh^x5D9!T3l$J_kyGGQ`5ff z)EJH#V4^^CIyy76ep=7DQa)iU2xbs zxVAa(!-l_NBE?l*&=9)yD= zZI`{*>7)BCVx(v{1mDW;N>d4(e^8RPn0O?jH}{#wvk6=HvPp(}mT`Yq0|*Kql#@^< z{qSw01cBAx`DT5m!~x2ZftGn?DXF4&Ui!!T~vpyoxo$kS19Qz?wc(^h2;KOoRvd| z#x3cJ%%Fw?G=(34B(6}+J8w`rB^^EK`Q34`xn6Nhdn*r zf;DF8yFiITk^Z!N4Ow;0*oKpptsTpYG}F3^KoFSi&LbpXPWX?>zn$;}FWUUu2;G5FNMh(;2sg%*;af`V&CtyMBUnYTJK=WF+ER}Ir{ z(6*kHviQ2?D$fxja)Jh`kF?CdIH#a8-EcaEJvLLSS!1J9wTlk`UuSF!&j&i67Pb8J z5H_GQJpdSmpBl&?4w8SrWRWtKWeA&a>=bY6~~w-tt(?_rnSk?OD51kN8-_rZhcAJ`g_ zh5rx{$)O9XM!x3@jw-`|1TaGRLuHmkY&V-O>WGy#Bz}cgv4E+sR=6AKvm5d+Bz@Lm7b)(vZEQ;{+hikXH;FFn?gRAF4|+2@`yb%cg-x zS~~AaNI}C8aBeD5J}g3TQgFYuXY&Zc^j|=)BRiq^lO4zf==c!rRInn0W4C*AB^ND~ zotru(e?0`pUc{$k|D%5#u+#Qk$dB^_9TJ!&Px9O2 zbv5CXoaj45*%Q)6s0kZmRb|@EFY1|8P}dg?*7nWxl0|hA2=pJTdVc4P{-Q<5)M;+P z15mop5@UY-O#!kYG4Xw6Uj}Oe-7(NecvVeU09^X{^Jbak*5y7-b!a;FAWvaX*sx3O zn7(=Q&I^!UfG!p{Sy|*mBg}aKciR!b2R0GyJA7tKb?|*J$I3$AP$A+Rsxq0h!Sf4% z3IjYr|E$*>>suS=xPCVcDd3!fYzVr47Sqf34o94RtdIa0J8&vM2S;A!7zGdixJUf5{(*9oOhQ*hgaGQQ0)IdC>}KQc-j@3wu{MkOg__RJ z&JlS#UdVPThju3dg#-PuH-o7eQqJru6xm$YW{5H~uGaJR@$l|H%K-jG)7y{GNg~V@ z>C`7$dwPCjaeQkPK$|eR;uJ2{=9)XEG*w!_d^Yhgh$+C$+*YNennSaBAm`&EpzttU#5(9~{4*VKbkEQ?=!x@cF*@Xe zg8j(S_(xV~<>BJtE!3ZIH=Loses8RGPYD`UK+~`QUGAOFyY}LswnWt;02zdN2TxSF zbMF4`tzU!=_V$MR9{+GQ^e7v`!n_@)5}{?%{rU9%jk+c5e&Aa4LizTKb1;{rmY*5> znA!syNhqM-n2BEngao^->Yn)i4SD=o1nu&Koj5xm_e7Vfuq+$nfx0ZtzW(hCrWJJm~ooj?~VTJG;H|O zmH<5|5EuAX-P|cI$6B^e?7Iyfzz4W(we!IYA}9oB1cALpP>l!q0QFyRM}xFV_+yj8 z#p-^W>yd{aB$*{={1@4o@aOc?&|P=fi*2@y%Q!g6@S>Rw%ek!<2$S@rp_HVwA8;cv z8??Z)3XG}*)h&3&5Cjej=!3JLo)86AND%mPL0)XyvxA)#5}U9NZGy_SK&j{Oc$Rjd zlmnMnuA-i+w^zmvRGR9pK6_o@S{JmOQqSkJw5JqpHQKY7sg>lwaF8zV z6%&fX^auhW%XbNb3N`Q~fCnF&3T}6>t7aOXt7KDYdvg@J>YxWd6 ztf;7{k!wSVdcr68G*JEWptAW8NmeTMS396*Q zffE99pA_w4n>#yqvExd(Rl_*gBuJs81I?Qb6o|<}>W77e#5@icJBfl#?soB2MC~qc zA9Y;N;%EpV3xcB9Pj5zZ0e0ev#uG^CN;&%fA8$_j=DPnhAO}+ zjy-oga=Kar=R2Sg(eP5~m7)Kp2B<{}=QuyWWD?to99wTtMkXxxwRU=@CNIW#!Q_SZPPRXCgnd{BILQ9;IpBpl4J0((YxDE-=QVTL%xjP#8TkNBx>o*wH0iLE)z*b- zSsbdr(*!<-CYt6LcDG{WL;up>Y4@EWq^pzLm{C8 zFo+Zawr8RIykY{f7PJ-G5@lof|drPZPdkfsSxSXOeOb%V6dBv6} zHg9t{2L@%-L_P9`L48YnMFCYL6YS830Z%8|(6kXf0-OuK{ObV$<==kRA6V&VjTWTi zceS;(4bAQA?FBqgpLq$~VUTctki=e}M%mX>K;m(c~Z_up6wKtrhF^p&LPtdv3vy30O0+h~%5U!|eMSG%$kWKgQ5Db|L$_&PPiX z4@CN(f@QnC-j360b}I)Tw_@K<%>vYxhW%Frh5!FhfBhddDl$C!-%_h_pIsWY`lG1& zzeJgSH?`l4qj~WUY%~IBvWii!P+z}Lf;^3Y>Ud85pG-B-0r>Per7X$3_{si2ujl+j zzbmXTxkDb3XgeU4LWdvBDsq%mO!|W?;M4`z1Iogmm2x-$gtv94Ed`MBb@KlK9$^r9 z(qcb1KpxvlgnWIt)9Z$RLHkH&>IGN^$g#D`D0_gcQEz^> z6pKTl&YAAj|1{TDG=H`z9Dk}a_|)=ep+5~e1u!`CNm?$90DTJTDd1hZ&+5P^Gv>t* z;7C)yyIPMRio2VXFs#n8;m)&w243|1rA!SmH=KqzNR}E8 z^dr1Ylax&ww)U~K)qhmd&m5PB?5CVf^_XE@j z#3INf2M2whzmRsCHsxr1KlOXB$n*TCy?5}vx?b#@3HLLws=J@x`tfpWshL&>+kXJn zaP^#2&l!F7X3MNWVl0vQFVoUsY}&*oI!dLyR$mG7ab_!bN7*<>b>84ZeRdN2*ZNPF z8;bwCb`WSUUHcHl>p)$L_s!er^mGRBAocfiEGVCB(9<_K-sBwpIuVHA{-uZ7>wP7zlwuABNkX_*;&J~Ehdcq`C0JW2h`v` z4cG0H{ZkAE;JFUyl)GfN3(#6ZeUprNxZ#~>5Q@J^@+gFfZHDf_s2XqYckqn zKP;q}n$9X-0f>QjoZmP*uNh+@%|T$_pfm6WcL;%?77znXWRL`dsp|3VAFhiXUE}0i zP!T|fE<)o2cuyzqUIkVH8mmIc8uMY2sklGmkp0jib&~EtwxJY^bU_g4BrPua%nR|I zoif4#&%q4y*WqhRaGv^{W%TdP-f~{Tpo2fpjswt9;DME(!SRMt?cGgWC~={t?Cc~J zXcv^^-GF(SFz=GUiPp_!x+}1BOith)2n=-rGJ}HrfMSK(%sP`biJ@@jr+fZwm|>(W zyXZ*@7!id?{P=aN$UPd%HUGybN9;_;30<6vWF4SlQ!_pbZ2J8Cb|`@y&C&$_Bn0#U zFdV5||LjP)mr_GSu<@YwP|E@I1PKv5WnAi0^bY1eqQ%MAZ&YBMmlUXQ$2Cv#o(l|= z+B=90PfYk}pWi$NcNhoLE&MM(9Cf(B%%G;29Do^(&*iMHx^49jq-x~@xVU9%1-ftB zRsp|(5j75R8I0y7Ta*9^g&xp)2j9`zwJtKl`+xIphWp_Yor{2Z0HBTrr=?!hh5MSu z*^cS}9unsiT=M8SaT&-2Xn}i78{>jNH?aPv%EI&!3`)$j zgiMTDfTm3^;ogeQ-0W=S3=B~QuqxsK6UmOW-U?DK5pmZ2yD#(vzK{kyWyu{~l4YkN z{A8cEU|9!xA|*_9?ZOt{Ca0&%AsGUDE8=7p)&vC*nCB`3JA!jDI)4_tD2*jhkcXL@ z%eShGuKnE?!miEFP_zWjm+8?oG|%ti(R>Qpbl?-LY~7si&Z8Te8x)z{h`%0Cjd5EN z12Z@89dX;Dwo*ql{K*Z_A9*)(Zh31M+foxNJ*tGk%KIQN`5_Kch8jZQ&Y&C^FQo=veDbvb zmnE@NNlrNyssATcAN$L>cMGljmvEuHC19Qk%D|T_cFUxtROM}L)BxN2>OK~+-aI7v z4A|$02OuV)P{;V|>k0Q2YqXRBLhXj;5Ih82M59IIQbK#|Ke_+zCR+ns&qoRRkaN$X zS!HtCjI&R2b1~SumtA`kiZBb*w_NFalg8=U04Ustwe z(IF-v0eU4{(~I|aXN(57bZsU(+wwkrINr~{g(_GkE z>N|~6P`8owL_w<&1PM!+U{2Y4OeR36hnZmh8xk1z<$EP1A)-`&`!O&HoJ`2vj1gen zKq1-KC7fIq<7n{pfk8UiwufrL5Eb{}9Xh|KOFI{)h2;<xJ{vIW(W^)N90?KPseVmv+p9dQa;B`+xM07eGwp=@P8^ACL}*kk!QeLlh$&;JE;t6x%Oj1sXOhzwo75Le z+}$Z*^3chXVm>=kOx3p6=!hNG%KzmXa+QM$6#`#eO&>#nX}~#N7CZ0a;)24AtS3IQ zowDSt9Gy?VW7*nhPIH{GyL0!h34JhrVA84=IFCH{uA+lr6YPh~+=`dN%cOxgp3`z*sJ3xBkBSxv30Zj!xKL7D zNl6s^+qZ#T0064tA5$(Gc}iX&#)F~O4i2@Dj6DU(I5@tTVaQxK^XGaa6HMve_6q(d zF>xF>vqo^&RY++&wtdz^%iIY=d!1(dc`+dSMDso`zjrOb4u|uVg@xt%^XHeKc?Dsm zt(~tP>dsyGZW4BYS-fnB1?6L!9&O9^#3%BKY8M8p+jjNaJ_!3SzU}r zXbJdwK=MW29%VB5&z_uw$|+;Xo$b@six*U&;Bij;z&is$#`KjijK%OUWytk-w=GaS zwE{}35ZYQ|&b0F|UTODn;4G{I|0^g*Jy#s`Xg{nNpgnp?qd~CtrxoO)tWZA&94Fd4 z)pA{8mRPFPgEGFT_$+^HP7WFDBj>;%hJ!#-;`dVLzZVcSkqsoif3Lm(O=jq;;~+3! zDNVoC1tj1yyzgMb9>a-W3S)p9n><8-0>3$^h=H9rIonc`1@rnRz&>n$wO z?a>8WEW;wbh=^Oq)XIOsGe0M;pYVJ?=>J$Xmjt4I(AME1@ijLx_4HE$qpmVq!|hM| zU#^*p@lU6Z{i~{Z6WODN-Xi;wymg|GVVFm_dAyKDg`~IE*8&iQ_d#jfy*prrl)im5 zq-$rz)?c&uE{spu{SmJu%qSRz{l!z&#nwm%#%DkdsIxYRw{B3wiFd zC6^>T++RuKj!6C_xFthcbxaZ_o$rlVM@F6r4- zYiVS1_*^$pUPGDjvB-!G9 z#=Mvn%Pw$In+1j(4afsjxmYDQ0{+$SB3!4>swct}fIZ0XPESN%F3nuv*s z-@2o8kTgKatS{rC{Q4QYJ=gl-k$D0H4v&+klhTZmsq5wyC1uRb`IwlQ&nekZSKm&9 z-;&kpFMS^x3apSLES9jecsbHDr|$DK(8Q&%C~ddwuDowx#S;_di~6JH@4dxcSD8}o zbm1aLdlrs`hyUp0t&6`gm^xp}2?LZgxVdo&hBT-~$F8pe#$7ebLXwR6oNyYEa0zmH zUeln=_>oF^p{VKL*T?292C$uZsIqyha(f4B1Uwwk;oN#&rTf&!2eoP&~FmnVx#7rr?B+6ozA0OyPJDh1x)-E`>y1EM2 zH2#TRy87d+6+X5zaqU&`E*CPhY;!@+y)< z8Fx6DwnD?IwJX8<$#w7KFcxMZB1PqD6KN)92I+>o_iXX$HD0nX9X_dHeulm!_U4CF z#Y1$E9dh|!c+f$kQCo+HfSLT*NsHxX-b%QX_{2O}Bj@*)ot_a9%o-ZutpfuBX?H&> z5gVRJuuOTynKb@Z`Hu1-mzQtlIfCsrJCY|cn3_mM@(*&+2*NENQu8R&{G}By9#pt+ z5OQ2}39Kp8ipldMLI-C4UmfbmO0(h>6 zy)K^0inzgjpg72HNgBzsb0?r+B!`;_qxcT5HYqBomCAaHK-tmA#2osj9!iN90f+Tn zpov7Ao1?+6Vl3=vj$Np59MmibOGFPMzLAu5d26v}wD5k_sA$V62I|(%?d)d;-|SPmm97 z&9_si`@%f@&8uX(>V&eEY*pWP~T$vRg=XmCt3`RFeBn@NRk_k}YM zbl^QX(JxtRp6{KQlE`dloTf1k3mjkd>#?IFw{P$*M7@B_7Vt8#PVwXj2~7vKePM5N ztj776Aomy~U)&lLfghyZyL)=jK_5NmHfs4!g72oZ?)E9T7r|odt1Fr;K%al@;NGPr zAGg|_HjmQ~;Qtu#yiSL&9;SUWT&q&k+7>H)WA5(u(tsvxSWCfTh5qC9dU$dKP~GUa zC$~>7pdme`fBOa9%6n&r*OpSrX1{n3#xFvMk+wIi6E5jYh72DI9w}&+tZO9~NW4>2 z+sNmkmi+h**UxPuc0;A_Hg*X?Pk%NtjbaTZ3|QN>$snH|4}Ll z3xzwKUK%c6x2Wk!2|mU@(6uuqHK=Y#Qyb{~DEwZx1G?!@@z^$I^%AR}W4ylmL6`0ZSh z4Pjyjqf44I-!DG0*<VxQ>F^pG8(SJL_&uRc zXj14!tYU?dlu6-~02yhz!OBkeS`RBC?KF;0KtbK~@gwov@wzL@$q(2@zcTh54qe{7 zhdXX&Y22@97yRUnZ*@#&CQ0h<$_-W*2ZyhE6W92Txfp-SzLx0-o<0QytLx-Z&;7|$ zYZP~X%8H7KN<%TTIf2lN*^%=!@JRwC2MGaAnAcCK&bhe!VKK|)VMa^Jr$VbXA@bld ze~e$IZmis_6rb7KmXv%Yb|%v6U9hXhq^(n-ZU-XPvd6K5KHj`W<_^iz8Clh((QQql4o0uxSOM9ppE*tavpz8seRqGii+Ml^12y-ol&^3MuU z=Y5`k<3dWue^atW|DLJR=@ub5!2+Eaj{=BjU83^RvV?R zS!#1HZAAo+iLb>_G>jTFGiFO2syU^qe|tNA{ovecSzEkZjIzmxJD(B6%q*q9BHT>< zo+JL?_QY0sZrl>}xbDojT;t&3$7a032H;Cz?4EmgHqZl1>%)Gr+IR>q-Zm?h-^*b8 z#duc};~DR))Cge=Mg)J??KbzF#Y)aMy(B(#(+%OB&bgLQqqxpVBmA({*cM1??1OT~ z=HxU4k-2V~C9>1u@>c%426~28#zU$L%x_GeFXDE*&rgb7O-)Ip=`GXfznVK`B}=or z+UZ=LRV)PcySeGDWX-oXKEqHsm^PE2UqDI2f5ycv7>w|Yo8j#?OJN~q`tXX9Rh(j8x!A55FTPJm>BCpNRJ5RaTUe5T*!YY?WUKsb zZ&HGam$%5ziS*N7jJ^|-Z!lbsqexC3@FI{BJt5Ot?n68S!^2|0@!>lCIQa36Q@p2W zdNU2HR6kwKKO!WQJrm0Z6G?QjYq?9_)JbYRFK{m(>lEzNpARXDZA#@_nl>%G}5m(?Q7z7k9 zY?{$Y@sY_vrx>=<&~_Vc^;g{2rwVSVIlXNOh@^a2#&yE`^J$@r;xA)a^soV;@_>74 z8Z%}jw#Fj6SVuML@qi842RZ(%ofY$S8}_jH|5AWqG!+*njKU|arfYi-c{)TgF2 zk0v?!5qKv^f(w44RpjNK85V+IstNTk3i-~J&HmI)YDT7}kcMf8%sN9@*^{?XI(+Ze zX^gsAy4a&2fUr>97Z)#puT~tkTcpKR@S^QWU;Xo{QC9J1tsZc{qnU>><{fIBX9GN5 zHd@+SSH;T}KN)~>P^zN8)Xq02QcnKb)%&3DY2;Ba zif=Dg7#k<%rl&8v%8b42J5EI$zrLyZ@v?gCozDw%iHGkmIKp}5*1e?nP2X*Bc6N5* z$J-kYV;GEd*HGYVYX(pf%2<8JJwUKt*3?865uthVB-aJl07ohmAd;;7B|*T568?Dt z&wIKTuc4*frug{S>8pp{a-4v9XoO(w1~X&rw<@m$WZ_{>ph z*`G9mLb=CIVAy(l`z)I?szOF*NbZ{Rfn_zwidSY`U2|{Pczx4By}&fAt-qfwOY_8H zR&n2PE*>5s)dHfJuyYWz;Q0guI2@ISCPrlMs;Hb40rSrE5togXXX?dK2|k2c8;yK5 zah&S!93=@^=6Ch4uSGO8_X$D$X|XlZRi@J+B*Vs%3XP{{MHBkD!#!=S9XGtz*V~%C zxzCg^pgS;&^I=PC(erEX0|FFa<^ZooVv10Y95=1r!27$PORx%L4E?pFy+eDoqtpcR zQ+wB;{gCM7_&Tq&u*uXY$E9Z9%DiRn!|z_l#AZ^fCDW$x^1?)_^6mA!5CP}-?D~(y z0Y0V!k)LX(*4Ny3PGwjx-2$0pe!kQ4$-^yEn~*0VkTYB-A(sK0r@ddaIGdRQHye9A z>ynG`^XGig#p%SLsbQmp(btsp!+{|Tw}1!h@dS@NL1=trBp_;ga;vtfQO-_5(m1tK zrZv_hqKH}Iyu=xHE3vn{_YSZG(1*4s6c_tNEzY~yn26$Hg*lgKD`Y3JePMlm(*4PG z|2u!N>*VzSLZy<{?i>d8BOJtGEL%#ofQc>U$}=2Ls(GI}om#3r=r9u?p**_nAdzR= z#_agz8QRC%+x;e88gwTglZ}CN7$dj?H;tB%$3mv$?eueP<;mDU*ceuFB0j zF2oU<1D^`i0)b*rPeoIgmx2&B(AEZlQ#{$dXl@TvKzvVamA~VE(FET5K_WWtwSFisM9pKn9`b zdX=IZ5xKnxBE9kR>a6&JSN1h_w*2EvIN-7O`vgZ8yt#J(#*>}RT;%GSmKj`H)x!W7 z_Yf8-Iygb3IjH>CMe${i*EZG3fmaQnfzhqTI_BntsISa8?gtWps@^ylI^cyq$LfJ- z_L_ypx;7Z=CX>=-vLV zJA_ga`;rTpuAaegPeP=}9b@m zy?Wwkrro_umke|OY#U=~D|Y-4{9{~#F0uYhL55qm+D1laNkOxN>N%I@7;J29W7m}! zBzyMG28ig!Yp>9Zs|B zx$vD41bCjK8_az==I%4B)l^Vzdb->|f)WFi=t;eA$$|9A6bD^}{zo9t)6=pbN5zGk{#b*`r^W1z^jkP~tMjvyhNnk$m6Jp7^^`Yh6-y2}EP5FZPYzqCm+U!!QOrYQ zp6JbIx`T04Dl2^AeClcLA|6owBcNb=PeCt@Qny6U)h$lS%rs2TjLjX- zD#$PJ={GQU-+{xcgTTmEth;Yun}?grN-TygAxu*b6w-rk_H^*Zjm-Xd`mT7b|79zk z`uGnHy556v-#=$lP=@-U3y%A0Y^!wQoeRmzGUiz)i*i#HjZCuhS=ScBMoH{NRBY^Q zVpa2Jr37oy5uLTdkc@3M9YqyzdEO?3>T-qwuYs6Wg{62QomPgBdiCI)kjEzf| zk&P{0=kkwb^@HSGZw|U|)f7xl&*LBxnXacnV{5))pUG((rDjyGUtv$i&XysI-GowL z6G)$E!-G85U|E>Q&Op$vco|o6XVw~e=y-^evvZJrI)x)0$>Xwz8YI-zX)X`XGU;bf zvS2Xg?r0=2Vr6;d6udb7%KmRV2U|~N4Gi>uQ6r%Y%G=;_&=a;3-+Km zqA13LhK32OtRs`)Gp|ooe6j8@a$9DxK5Cb!L&z3Fv`ckyR_&ddG?(uH|H)!~vP=HT zjT-x?fq<5m$ASaz-g3l;Ldoi?9TdMrgI{^W;T9rbGS0lUQxkkS_JW>Xutm>M6d@&5 zYbBIeVCjul<{Ca-pp+CMm2$E4sjC{>*>uZf5rJGLn)L!qe-wiC|Lxo9Am?;sgN`J+ zW4fiM!(U`?4P$bp>fN^w zGb|2G5dM@_46K@Pvf+B9r}l%Ek+JIMH?HU+r=LZf6@&zIPXoQcpwS<$Dp53N3G@%~ zk-4A5$mG1_1>bB-wrW`AqBc9}08?c^xh=V}Md88jdslNg z@}R*Zh!anqPDK#WT7A{2?E z!nTTTEkD!JC^AhBkuKCgC6y>}X*Z=v=CZ|?8>wCFKQ#!noOgJZ51Ex55jjD-#;tBT z_ubdmjF>K(8eW)tAt4^nCP7LUgA<}V9#S5mJ|r$q%owKj5;pBOcU36Pvr|Ek98glY zNQ(^X>QM6j_)*qZPx2VY4fNdjytId5*28d1Q0h&ehTiqq!mLI@+Z2q2bbzV%`T6La zi`j4&=rWPyHY$erJqk2uTI==oofq7{LC=;ZqSHPd$lJgNBNZ5H@J}elkxo%F@E>ZH z%%-uUA`Xv;_;B+iN*@{YaYm35=M6dtW}i$%^#!a+uG7PI`|ca>m{QM!U@3cJRU#-- z-Uv~$J)LvDm~wBWrmLl+!@qp=+WM-^!TAEiDS9{OC71v^BDJ^h`JQW$#Q8M0Ib#ls zk#m$cZeq6tGZ<$S*;9-^6*>_V^u`}R4wG48U-R?X&XkhF4$W`adEK`PPry^#W%nNF z2frCpOl!d3hxcy81E}7RSb`8mqsA zw(1>au&}c$4_0TP?hJFW{6P;@cy^BN4n>N+U zcT$1!&D*yDh3~O4U*Acx5w_pB4SMu;!cWHk9lwO^5uU%YWk*$^yn(>a6L}Fa<0#Z7-5uNDn<$ru4)7s?mDj~;*qdQp?>L&GRPJCMZ0xZ%mUoZ4m^wOH+S^?e zI)6^++?nGRSgeDS#M!g9|7;;-?`VED%u&}7j%{8xAG`H>-^9Q-$`@998YXRxB2?@227m7&{&1w zrAwFUH^Eh)4lcTtA)lzBy_|QDd@Xkz zNB+Dahhl(_+pPaT?YdHqL7{$i&8Jq$q*g1;m=@~O#*DpFQ&MLi<* zX5`r4ynWl(%a31wAP)%@ZB6e^}{ZN952ta#ElOFMIo zUeh!DC9I7f+C`fz9otHix`XATEY*T}A8Z3^)}q-6;5 z8aygZQ+F(%?_ko=&9<~w)p za%<`hbt|j9s}CP(YG`C)%A5)vY5E;DF1SLA^eAGMfKbJ^sUBVw))nTRug=mjrX73z zuGaW!aS#V+H8tiGmT_4U={glUrxbC zK6+2jy8HlhIKQ9(>7$%~c$-)=aWGR}8B-H!g!PV2J+O*DAmY)#V|A_3N5fRBaK3+# zPs~1k+n(W`49d%uO}LWVx!inb&S(b9t|W@)=q2w_ZBCjtq5Y6GQn$s#9v0LioKL)d zT1fP(NtGl@{NVYW?5HL|VKFfQ(&PDV3%VM-Y8J&ozkVH04rU*xyDv;s*mj;-HcO5Qs`}*I z=PWzy5TtP9Mgigd*h$i&fQ~tKaf#uV;m3pfP?w8e%D8Cyljw7!=~;a>)qW}8t!VaD zn1FLP4GgFf^V8GKg|hFvvL!qgMn@zFSs7N&^&?oTx*~Rbk}oRr`d&_t7EhSs$-%O# zS5;FrB=cNGQm7Pu22_JSJcG-{`#D+2y@ek>TqfPOvBCO}Z`!oUu*Su|FRAYmE1Q;v z23K^wP-^Rlgt39a0)|b2x^wV}{1+>WcWAr^ZOpwkJn!M7M{Q*~YRt@$X<6llB87#F zdv;#3t=vAOK<)EPF z{)D=y=>34hV=i5lmXnde=3scRMXPZ+63&&xymR)=uu*3s!)uG-1p7fPfMM=@qmGWkjiUKvTc%_ z^y!+w>C4LWEI@kyNg=+wVy@qWiBDYoJ*7z1 zye9h4wj#IH%#xDVrp^p+LUsLE;FRC$$wLxxB2N1Ly>fV^x?0Kd_RJwywR6vvgFN0{ zMTv_c;dbb8RMccde_-H<8?zv~GtXH8d7cvkQD*~Iyk)heb)s0C7Hz%LRni^R~Bh~ zHm+#$Tl=e9)y(_%CvnXr0L!7;5$x!rVA)V^>6xa@N@$ML z=+fbbuV-dwiCt$|GIDcoy=D{TbE-~pso}UFF7MiNzmCsUWxKBv12StG-cO7Qv{e}! zXY1#y`ZEn>el*k2)lIugpVOxQY*ylwR9f?{S!-Q{usvL@HfXi};E|P;mAc`L7bj1C zGN9PE|FC40wtBCft(S_qNMcw-)bC`q-6%@%DPG>x z4zfH7{)vm7gP8Jvnr!cIU3Jq`VvM$h#O(IGbwtz7j!;}Tbvn)$Ip+UW{)R)su4gSR zEN-IF&x-4OBj+Y41`i%Q=oYHR!i<97Ea12M_j7;u^}#ftjyvAYgPhEM$?+PFK6h#8 z>W-Y-$mLu?qj&c99UFw1vbebDG_&&vQcZkN-oZIk`AIe0yPoV=?TuaJ=gM($(umqt}hlt;Occu09&AS{Z zOxQ1`EX9}BzpQNan0$1p^mhAhQpv-ISEZK%)?X5>h~vfGNd;~9I>uaVyYp1+s}>R} z^>USbJn62COiW@+8ZnrSf{IfAU~|g^rJL}(U^iM>3x|7Tti2NJHL3A0bK>LUmdWwVhYycR^qfu4xgK;R#h=4n-AQKo z>Oz-$S$cf0%|@~2TeGydILs^SeK}ZqNjcjnUsZ!gZTQ{z+f#LO-_4DOr(Sw3EiYSJ z=x0onSQl;EGj%TS^ zY0k{TmgqS_7gDt8$<-)xnQT5A?@_L`D1PViy0^z_&$_0K&5cwa7K=diFftiGH=TIo z{Bh|btwkWG&Md!>Y}Wfbhvw6`rg4xriTcH7O~q$z)&8EV_*`rJx{`u&9XGnNvS!U} zt!wt|$lG1!BjJ&232cNi{n^2@P_F1;Gg8F5J#@A+vA3V~o`03KwnmsWD6)P>%YS4F)d zsJ~KZS2nPXv~;vJ)r#Ks9iK$aDN&j%Urult7;Bbi`QexuA!tx+-H>WLyyiLC=DW74 zj}Z_Q)KFA>clGL33EGm8*OGI^N~cd}jJ=iBXdABK)W(82!oz<--L>00z{q`75QF{b z{ybpS?y3hA7JJ!c-o9>4EgEet(>Y5Up(vMl&g#cTF)>&AEXAXhCSgBVAUdRz-O!Y2UrroZj@`8}zs|L3=@@1_ z38-q{b+#f!c4achaELlO%AHQR#FCJZkdc{b?<{og+#6!!;ee#R*S!@?L&K{~viC8P z>*XUJbG)*St1B?}=>&qRtmp6jdS@a;`)H#ba)pJ?8ChBC*B&ot8p>aLTwGSGbMM|` z@`5;N15DgLZES43N(!DJ^~o;VXMg{Ojb+*?GheFV>`YEQqNPQA9{9|~^M!y=neN3D zmHVs5j;&B?b(AaDuJ?GADOI`6oQHwPq^z0LylAnuuS_IbU&MBtVuATWjM{zbb4|Lj zx^Xe}s=@Aa%;5dM%^H?nhWog^)Vhq3*6lkXNeYfk8 zl{#}{`hG6K=j}QF855SYCi7Q zdwcJc_P?D~vzCIIFLix#5=lG|5z_MVW?a@U^_mCEX1#fHS$btrL;t;7`phmy?5|%Z zaH0#!($j4@VNn+p7kZp(EQwo;J_023MSILWZDB8_Bt;szS36I9nl)FlYFBWQAt`YB z@L2n5arrZ~h6c-arI#ET=M%b=!LHYVPg?d~bnqXK@S?ruPFIWX_E?+rA(}f?weiN+ zw^psKMtR|I;rlpq%FKE)>dscAX?O;`!9~Qx#5AZaY?lbZJfA&J}^wShlFtp8g&&`7WdG6pFdZYC|~nYTUUkq59J=O?Z^(6eVxfJ znXjd#l|40eZqKnMV;w`6TpqP!lcTfklAOci3o>mhjj~}xD_f^V-Z*;rn2Z0~(pW1- zfb|dD#a`ULSFz01v+Oy+bFHMRwxi$1nee?M$#`Y7*ilqcMEsNzSHjCgFDE~IxXGC`X3#l)ak)JjOCjoHCPqX*0RX?;_iuQ@F1s>uBofC8w@0 zR?X08&ar0&1+7KCcVS2rFY~gYahEbUajbUsx$S?pUvwd|3hI>_%Hqa&VNu&T*Ecrm z)YsR?Ru0YjtOu;Dbb3Eooi&b=&ep%fu|XP0O;}jIUR!Hq5pkZmhVkmn5+!-k#?l`? z{G{3=CdyMvF?Gvk(C!!y5+d!I-FI14-wtsRmr-ozg zR+;VBprgr80wOX}QnV8iPS_H}L_{pRbpo){TZi~gpZ@kZ_ zj*<7XO8xiO);*R)R>!9O$%Z})tHHF1?VJLq+~4@^RuxIGdi4a=BEKv0Ol#z>2*ny5 z%U9=Z^VCDP18}~npsZZTV^V=69)PFP>n+wEGtK^o4j=Bct*QOil{T)|fyrP3dgL)~ zdG9a{(D$s_jn)qgt6JLH-6<-UeYJ2056%s%d8e7jEk|Z#W;l-%b@*k3wBf+Cfrnq{ z9vzI*ZatXC!TI|bl6F0Rt|Ywfc6`Uqo$UvMS9F_k9%Texno85pW-i)y^VtHMFZ|&V z5hJtiyM&k9*-8g=nVG|*W;>+N>i4d_=jYFq!0;?6d#(EbD9+h&*r$hJDELW-<0(bDa;#G{?z`3iXKI59HQJot366^t56)t`^ybMw!%tpO2M zw9XsE_M&d{yMuFl*_*yS54SGx?mG;HhO-j3FK5jRuELq!->DEUytbE6O2rE78Wffrsm2^TJuJf(B^bu zl8Y?VZN(?uk!uyUyjn^wd@mqTnNu^l6ZN6v^xK3hU%s4r9vsa3IOb7QRFvk;n`w)m zuWjA7&E;pq2sT6FY-3yJ3o{E;N4awuH=mH`^#uy9jJ)0`f*a+wrNkx2P)a&0P0WiK zk246yeJ$|1djEnTdFz%fZl-6TR4MLR)^#b9`}pxnDebE@g^+mB%S%^x4+`bFW&3sk z2?_ltPo9)NcMf_U6eMH0C~k0+_3}Ks`23tnXV|k?)%k;81GO3^y0n#>UAEu3)1$I2 zhd{WWsb;DbP8FB>QSrS$j)NL)uVZcBErV{UCmFX|{gy?crhpWHR<`?trr)-Z zs6OMUgTE!KqO@}2Y9gLwFLh_=bss)Rsc|;c*7mNQ7mcPA&gfjb_Wt3+hc`GgfnWm0 zlN&07_NqC(GLpd*VV_U;g$Kg1)-qn~@e*^aaqCSpNN6RHL4)m|BIJk(=7 zH$5%A=2J!zkQS_N`&g}@+OhWGqa2~{v+B0s=|V>tro!+IU7G zKB-Qq@^YlH$DPzsi2JC@#wPm(UY;0EK|w0EXXW8TlLZH-#@+dI%1T%qp&Ylp?RI`_ z!D_?UG1BzYUb)h7UD(O@=x*F5{1MJn2)fxl@AZJjaV?8)9cdHmA-v?Ksk{(-_o-nP zh`d*~xaQ!bdE{{<;=gX?DJB;|RCw_t5YL@S%y?Pt?{1nE*8jkxcT%lPWU$kjZLVRN zQ+Xo=%4yfavi?v~*Tj3Aca5>ic3G8_DV5sNbi0+h?%pV}x-)*g1_n%c_O41GD48unMiIs_LD;4rLofBXs}}<{{O+H{En!L3pv~`q|8S>F)4RvBPkz z+lN362(mP=pXi8Atv4vL27-uRAoC`~Y9Q31UL$6jGo7NTv;pfS^2SFtU+JNLa#E68 z8E_-M`F{UWIMwmK1z}PSzWD8X&p9a~mq}4vh(VYY)UT`!wgQwGIpdF=`C^j=bjj$L zJjr9MGQ#yHBFH9F9CDk#IW<;!buPTqJwqS5=rf}zjU1#rlU((X*k#js62ui0YPZ?& z!4QOKClbDoXsS2|?qzS#0bsgm^Cm2CgN%FkUdWR|HsrbJ%o(C_9}?qx_sl^rQ8h>~ z^j@4R-}w^_WYdI$Ker>~j#I-|+~rcDfUb;;46B$+0f+lA1CdA^dE!%*0!Y?Aaw{C_ zgIuW=>e2}aP@%j*Iw~sJ+JxFEmrKZ5q>>D_?PKo|!QhMR8fRSi{(MK?woi85WVWxa zPM{ovh;=BYks^kqf`S|Pd#*n#{{AY0;j^8q1!OO@x`pD?;<}BYI^j35InUfaj%*tp zTaSo1e=5r1;c4FEo9Vnqbx$D2y9hHN&U0;`b<{prSJ;VuD44hzzWz|Qd(ZLIYN%>S z7+mtUxyhk%b!2n5rwI)Anta#rUn+`#h(&TO(=M&McOPC4K1O&tb&jhJ+57edcm|2G z?oHpw$e-fX*gCCu$nG(*8|C@Gf?DtohNbu(>G5aeg1VCNF=qx zaNDAQ&TES6lFHUA?j|S0m#C?IaMJscFyCx#V~+&}?IjC~T!P|}ur;7Ef*X=s)Sr>z zdVSzBs3n%5A$3LqUB1d^uH-*Zxs+Yit4>=)xMEZIGU#OJPLFBi| zbHcudB99Sk;=OwrIboRYB%H|8J(H1@5fLQYYXPLGmUCbx=Bif~Fl!=SKlcT)p8xUf z0P@sceS?(h=v--5G{v+`apz_mzaT#mFjUy!W!KY$P{m5{1sxy@;Gt zTg#9An053q6lbVkXH16qbv+$txzQlCG(8z=)VzKBvcK)>>Pnc5OIV!8?>i7@f$H{o zW3Np(|Mv_R_6>^&N8^EI`Rx)9YRN>&tSDr?(bmQ)%{#YpA21`sc`h`8At~V_4;mi1 zwR88~-1kAzQJsY6%*T!;@r8b^1GR+~<$OH?kyk%lgOKI3ZlZBx%%x_bVYw`bN@eRD zmvp!+i*5l~@ZYUMzCGQ6R`8_NX|m8UnVAk@j>RcBmBadhGvX^wTagR=tzR1s~LNbaaf8 zzMoh~Z5P1(NYfTDjBNsqAS<>E;dDQye<#eUsHo7#0&)x`Q;Nf+EPU-sruC70b8z4z zHyOAs;xbmW$a}%@2<245yxm5_cIK%>7u%64SGOBrJl8s8J+lcKdVc_XyBRSDA?}@fD8=#fgo!xT%*uo- zljRG!MK9+gOL3nhZVU)2FKy5)p~Hw;I>_&(wZ2_tcCHeGD3LyyH z=i>piI*`qAZv8dSCtAtQ(&_dOzXoxntI0&CnhI#ALq?2mG=wv+>BcUWv#sShL0jY0hP>086aDIXatu})k<@H{E@xt!+pk}D zD%P7*=>zL4MoH6u=*u>KuL5lI){De^g)r{)($ecdbW30mfH;LqSx1)v zl7Gz>Bv|9gUG=7(_Vbm6%4?}BfGKX>y#1zQpd=YoJF?3$PkG>I6h}-HoPV~HNIFnH zw1T7udY@HY`#2)Qy@>}s_7wWblT%8{12ld( za|}o8rf+c-?)v#I6)+uy{1bDX_t!*r$BLT11!sW0HX0KFRt{EH8+_7()lk(XD|Mxr zbI0|PNhB_gsH03&I zm4#-uDM~>RMJ3%({~s-~FCg+%teXh0hJEwCYLt5F{X?uJ3@{!r3 zBS3!wsH5thgHKez)JS_^?JgO?f!|2`Z3)R5JC>~%oeqpIAv{ZU3J?Q?5m?5bjxH;y zK@m-T@6Wb;Z*ge}F*X42o{^rdrDB^+eo*%#SDzoaVgM*feK{_%>FWeIW>baR8Q-u- z9SfDO9@+I>u(WDLNnBi?MBIP7sk|080;5PAYr6obotT;g_8Y&~D&IAkB>cMO<0|*y zwaG@bW|CREQD0x9Z4r0Dvi$1Rhmy`nHhv=wQF48@EEQv{s|M95YfMy@r3R1H&ybHZ z)6=7G4LD5l$(Wi6Ar&g=ZEU@nEL6{d&Yxl$2l>nwa%m}^*W^c@E1z{N%bE35D@U%> z*}TtHAb4v?L@$@H@U_sdsn(PAyol6P8q&$HnXtc$}Y*u zrq((C`0L^EEJ3CLOI0?mQXCI#hd7REI_;ds~|2o|3l z>kO_pVd&S9^)Wo(jFWOMvlIMa<;-4ICS_aa!oa{lvC4uaT`@NrErAs`#vfv4PUn<$ zC>H6MyLNJmuch=qPJ3T~k}DB&fQ&EBc1rS6%}9BO>p#6r$!Nh;+oqlGQxzRCNAK3=kl-Az0-2>N}USL?HJ3*&JN`Ux~QyhyZ=#> z@$P(`vz0R`V>P^`!OEQ3WV_1l@$VC`=VkM0mHb@?epf}a+@G3ysZk{BFcm@-KVRwO z#Q%a-z;#k)l{z41m}8A``M$Mu1;0yDiw$;b(kp-0vlXm1%&Zc>WHz~4!NDQf9Kc2gcLI8}*USwc@^HiHNDev`T5I0ifYB;QcEzahHnrozmw&H_Lx9_xu}S{NsrnZ>Nv z8W^>U`X0m0sfO!e5fMiv+TSMEVODuxuw@=?<#Fw8MGACG^|274=P!1U0!gcvC%w-p z?Aar_I$q*q`L%#gNm)f3NLBeSr|2#N`cT2ym{hKzan93Q^UEc)p@fbQH0DDCX-@n+ zZ4z#Lb69&%Wo0D<=`v*+a%^58v#Wt!Z2S2$O>L+l5{wqVlj{JL&WMf!>_tfYdxfP{ z3<>*9#($R7iTEc0)z?@tl}GMdc>26$(tCDRh=eSrrzl5yidt+En4XYI0*FZ{5l{G6 zCx8QqrgEd{eQu(NhxE)^z&?<3^o|N$;hxmd>brrvaR1PY#@oxK!A{4?kVH12Odk|G`#;EU9F(Z z(h!w!KGCnZ6e)atFUCWZewU_*7q%N4R$Wk$?M_Wg``PD=>_4?vZu3)$StK{@>GLsc z4^pM$#}~i4!%wINFJP>Gh1^D~tBj}XRMIPJGx*W!HyuK1sL1mB#ST9YcUPQ3lgrKp zn_vd7qt$O z@pA>}qhGpW0K+*NPU>m@6?O&ahF4J49NNGCL?+P~NK!ChA;}-OVT-<$Y>4grNa@|& z_Wj^L2ikL-fkB(%x-jn1n@s9=5Vj&s7>;+wQjP9-SC$S18Gx1N_TNZjSU?vqY;oB~ zdTlEB5DQzMOFU#`>G@Dj@IJmtC`1P4T;zs%CF`T3%MfBOlW>@NS6f?0Y-&1=05#3v zw9~+HG=1xp6A>5b_@B%&YB$?8b4DOA=#@awE2$j4Hy8rPMV0QaHb#_Bl<&d6P;%c( zop-7>tVfOi1blNunaNyy1S&e)p zE_a0WGJu{?Zt$v}b3B54XTAgY0Om-eG;j1X{bKJ>nb_rID8#w^k>%4=f3$SBJ&+T~ zJh;<(INK;R{cFngWF98ORrRU58YHZ<0c;C*c;_x|ubYBPbZh8%zdI)(^Y&`*h&efi zTx613H16PYxAe>16TTbgduCU~r08^UnH#ww^Id?=ZX6N&`ZpT^7iiYwk@&J0Sp*J# zBl8=!9hA7|5&D*XP)j4YG0sb0ohiYjTfrG%SmqLssS848$xxo%GNZPnKg{-9W+{$|w7{4!^;r#DD+rCyERXq;N&N#x!r&lHS5 zA}XNA{L`7AtB6PrIbk4od1KKE1pLy5L$529&3+_bq~2zj`^EUyk<&U13H z{!(mRV7K}`Ouv{Qz1|g z-}yTnSfKRE>?*kVpw?28n&CnmtcL>zl5i`lE7&1hF+Olzb6d6!+WrTf(N(d`jRt#% zHgKfmRq#0r+tzZUTN0`jc4uzfUJ1lMupr`-u56~emfCks$F>Rt^&o@w;dNt^);k-~ zXl}mKX|u~-TR3{yK968M%7xSr7xVSO>!y>P+0Sd0z(@S#iQj2a(d#DH_mIHz1L=3% z#pJc#hVJw*fq`3`TNk9K3<6;U+tZSF0lAJL?Y=z(5Y zY549M{?L&lZ=jSA5OELLw0W~L*iNi3v|H;ma3HGxEckDDIdO`2?j#s-*8M1jN$NX! zQP_9)(U^=1_vJzl+Z0f^^5L?Bg)%S`BosS_ZYGNb@=%s5<78F6*KPManr;kG0wBs z6j!lgphYV1W~Y9BTP_-nA?N4ORswPmhCI1%_A+?dApv0W9KK&5b%i0Yju^QZL8u(P zK${?H;KM+E4T^|xcm8W&I!%B%4hgwU@#+)tm>p-jS1bwgpYcfk*-A&1bCF3b#_k${ zfq@wrgj-Hd`P6c-WeJKICH}G#-JZ08=I){K0BwMe)AYB+;cx&m#KAY70P1g%4TZ4F ztbVFi*Q^~`ZCE6Ur2elIt6B0f;8|njXoH451%LQ_|E5$n>fUqUjJ@yY| z3(B4lLB!Zq)wo_TEtCZ1=Q)*&M!a@LW*GbVxt-s30*vH4W%@>&(9jf-Evc!i*~RZL zym&AeDw;qJ5kn20pvj_x@w2-aF*Q4P-cPlO-^VEs@Z~M2jsrt1ad{QD{+ek``!zN_ z<$mJ-WMoEJsBIw9Fl}433iAMShP_3|m*0tRK3tZUm#?*=iDkwJ0p)g|9SS-rQ%`Vk z0k;S;u0F&l1eyV7J@U^XTQ?~xgGu@MrOMW&*Wf~EcRt2C+N}`L!uxM`YM~mzI6R)V?(T9M+CUV9?q`qtkRh z9GRWHhm`FC=NA_N^>DOY%09C9763g6R&#CHox`dO+z8+)_R4VhM`p|)ou5AMWoiz4 z#e7^W`iT~d+)f}6E?JTf@@Hlk*7U~e8vP9YXApuL8FF>cDBXBU3Mn|WhYjCuyD&SP z@oHFx&zBs=}Uh<;b~pe>r1wIz;R^&gT^j})kS=QV0(mFAseX7 znGAOR7-r+U2Y*+QKTrPZv=2DW&X4q|4OxDEcOvSX-3y2fF}Y4#0f+HJq=eW~OLo1yM>Kkq+6CFW z<}N{0x6e~2jM)BKph0fJTNmkcE7;lNSGVL`P0yMVqB0yf7_>?&hZPcCWYZb|*v@#h zN_G@h6|lnzy#8WOfD(Y-juYq&U2x2829%|GXNpy!RsYnTe~*5oh)EHsqK4@6@wJo`RsxBux*aE*4jLD@l9KpR+lm){Urx!;Bm4FnW(J#j1{X6&e8d zQNSf&0Kx&mx)O*O$ctZt*%Eu@TKlO~Yi&JD9{60kS8oS#^BwqMUeR z&v8MJoUE%;1fj@E1TC*?RA15I9b~q25W4t*G83zHsw>WHM*^Q(Y0hl#4G`+ zeN+hVZkt9T|bq#eA;zMw#v>KtGXdRj<%T+#{&QX?@gpN|_qc zzz~s5Hq9p+U;=<_eb(11B7=JY)|zsyjWUVpqKL1irY1j^QzBRohAk}hGOfYN%_`~f zm?ub0XWbiDe+GGIzG$d6AX;~p3MyM)6hqoqqG$q$i;I z+Owx^oa?Pt&>%e)pl@9_3abzQD&5#tjy*j3UDPAy-Rd03d4N$R&IT zkdoP+1nR{y6GzM1BmcPpodC6EZy3;ZuR%4AbR@(0x-Pku`D$2}SRop&@5ShvxQ$v_ zqZlcj9U|b2uR#iqD`iH0&etsV*@_I?hmJ?cWBdQIZ!R$Y^&<#Z*Cg}uoQJ3OYiVmC zI=5{3y3ikO9hzk-D`gmW?GecrhBKph&YkiFTi6JNNwygnaI&E_5OlQJS}p5BFl}L$ zAJvK2)?WJuqHq2N8_|M&Do*-W_i8VL6~|Hh7~P>^$jVVd#HsUM;vXI7fZUL;__4he z^si*XR5MIzF+1u2Hxa&}^KB?&;8N z(-(#_Q;mOH`D`b>rpid$#3WQZr@jpk(7k)Fk!!zk7fJ|-s_2$?CmvB4IeB*v$0yC5 zPvk~lDqCRH-k9o6pv(sKvnb-fCI?SodwS*k74gpll%)dgo^j_CJxw1tI#e>}i(mpZr&`df1*($26xO_U_qrdU{8Kj5v`rezy#yM58>v`5_BUcFB zqc8nAprI<{PT|K{b#?V}49vz4detM4p2SFGQ@5~$9H1v)18@3IIfNkJx+7fAx0U~?)~M!s%B`^hjYRj)56kFv2AT$EG*QxM|s`*LmJ7MM0*ocOr8 zb!83*SXoguZ|Ww20_D7@SP7kKbB_dsZb4@kv8(G$bbZR(-vCXe77I1WcmgQ8~s;b;~@@?6a%|*?P|Z>GM39A>_IDt8W`;omnY-0PgtgB z6LP+PL(DWOP%&cekH~{7T<>~BuIe^;Xx}BWM>k9y-^LvVCn%X2kl|>p~^OD8`(sG*O2tF?0yJSk;} z*EH7g>D=Ir&jkY?_BKx)e=is7&9u*$(->_v%ZQi)+7&PVxo)`ArvSkZ2 zdJT?)`)RZPUS)h#G`ZnrE+7f~%doYDiI+qVoD@I;$S^2yS>}Ox^bEIgZHLbr&0{AhBl7 zfbJdGkW|9nF!{ z0sw3E(N&87@9-0?-WVr6*PqA)B2Zf<(!@y{lQn94@TkVfeisu{>kmr}VTaqYTXnPf z1qF2m{Zu+jrR#{mo!GkwdX8;$iTe)iyIlGvrARxcayrOb{*0^q^~cnY%M+S+ua;B0 zz}uP*6VY<))yvZH6zaV~{XJ=mZJ=$;Ekmag_)Gp3EX!2N{!%K@cql)B^R}NFbu$*y z%|c8kL1&#;`uoKVBty2(1V7)Ib8vxUkmG&)E&122` z__W`K+xY$%b27AKL(?zujsXx)DskefPF04d0Y5=s5%rgzx<9+6RPo+3`xlV!JjLEAzO1nr)$RM#0!eVot0To#co>U%Gs%JOGraS6UUK_aH>XEItn&>z zvc{;b1EFVhd_lIoCcc5@!j}!cl+vJs2Y#z|$efUArK)4jfv!oC zVarwp`=Szv9heDDuph2_*9<279CIPLyGEwateYFm^5YA}7hX$u|D{MKcf(r%5JhrS zbNyf@A`|?Y+pr$*ISvL|WSIgma4F5n2@Y;)QFpEu(TQ~d1I>6l(rY}h298uZv5_;f zQtSjdXV-%d%|A?OA-;5ap*9F@9Trx zbQYfm2N1*1eMESK&=mot-=HEMaoQmRRFGwem>~!;(n=h{ml0kB`cebWNLg~*xH{~>2O{)e22p6p>^?(wVEif*G1zsl}$Xr>-RCO zD?)c(go|xSp2o}@20|ZV&VV)zXouQPr}h{(sd>A_zfC0fU~?`4Gn4Q!9pe*Dy+*+w zYPzfXysWOZ$cAO#zNYltK#m+RdYrAGr-1b^k{bf{Xbn>r=t{3tiS7@B)rv7BxC|7< zH-Vx5TGOjbIHk<9)4ZXg;_?d=r?R!B935Itq%rBN&-|-Rn^f&jmJ+RKKkv;S6u2?6 zDAYTVmX+bi?(bhB_Ok26G}3MdeN-CE;WeEL%1UhzMbn>7y;CJ3X07*iO|m+qcA_%= z?%QQ-hVje?23C=~Y2X?_x}G0pP@^K^lgAcSdwEUrJG2Z8c+tR(yIM2tz4(<}VV(na zc4flUc_CZ@$Le>cok;O|E)1@@tiH%#vXnAosfd%4E5j)S19V3`l=ru~T)Dd9I(u?2 zhm2$G{Pw*Zj_kZ&UA}l!|%e9#>L7iY7uPGqy>rpSDz2= zY)+bmv&_3M<&O_8R)W1F&8J5=6WU_44KQ8%ZTl9F+xU1RF`yd4{wb7=L zuslgx3-bvlit4cpLp$_0yXbF?DUv_|ROL}WZcz!CSQbeR?P%_3X zHmwY?7`*CJGaqv)yKq6$TRtn{<6x;>p}vUY;<=n45=fh*wOPVwP!+3db)k+Wu#d3> z1c43n!^{Pg&20(dl*iC&urqhnWeJEcHa7~mEx(g`3f!-rL<^9zLb14k2(TE0d#I^XmK*B=bNcIOMhRi^yk3U($p+1U*G8y)GzHKx_)|}3%(pj z78z+|kevN0=VYN`g5L~9$+=Zsq_*}E{{;#k8XoDZy`0~5ztBh=Tc&?!-0?0W?ftbLf?+0Z zdys7{Nj5!4sPcA%PEBTZc5B{%Kyn|018^$Y5pps|A8uW`TB79?LHo2u*zp>=_YWt18iJfKGw7u>w9;^nd4LjwSmxwf1eO#yQP)WVmhn5Mwh4 zT3D~M0aNE(ej@3v!P!r!dU?j$eq?~ut*)m>Hg!S9G{zH@gcBb>)@+;3J#uL`eB*oZ zF>wDUWVG>N#p`eWLyr@xn!CD0UmVWds*D9}&E>xV?zf%uV$Op1%g~lsjFFduAcm^_ z)&Be^gtVcTb7n!dqJF7q^&KOuKHs5tjM}`b1FwBbgR-?V+p~L;oT*~Yqa1&c3EMO` zV4)2x(MSHO>xG$vW<`9+MK&A;poIL7Zv?1^Gb{N%qBHaGC#vBb^7a;}&HsL>4ge)> z1@NCiI?JZ}Z3E5yyOrsN=jWHAay_pq``OD_666$r8!!vM#!8<$LYl~h}#o)yUJholsDzc^Ps<7Bz-#Uq0#=#?N zPw%XKI;H<^*ji^11XQFU*?-(=VGxalj@bs ze^TlOT#Jyr{B{!sQ$LIvs8Q4 z#{v3)UhEM2*Xyg;lJy$y?q|}{uEUw%k&2E4ZG$8llvSN`)3oVk=15EubO`>V1WNfT zwm?UF+q;BEG}?@PA@nb?+Q2J9U`klced~?7gnJHFq#vg@$gyV|`jLo1>FU2d zw|9MkgNJL-iWark_}<(iN?L|45H(KEZvur0vl~{2jmVdyR{As`@Rp&?3qtwWT|_-> zx7F*6E7b7cJERORRgvl+-|)!0Jtb{cREA;_F?CUTZ>p%o)(Y^KV>a%aX~qMUOJ=XF z?M{Xs6if4YJCUC@*@WfX3rG#&&^}dL>>|Q~T41NTz89H}Z`fejgULLZo2dl;4yTnCr+ZGpM3A>d;92r=jHbzMQQg2%78m7_+SDE-zA(+?1sq$bL~B z9OiRMNXd+nYMeu|1E+mg>#0|Fp-qJDh}e{&x7_STbXHsc6>tN!HMgi| zf7i`H-iQOGUt`r=RGin`3D7@X$kRwqq^Gt^Bo%omUA?&|b!Z&RY|m;frLk!lkm)(Y z2>unl_YQjbQ-N3m&**g9JEL10!g%%Nf9Zw)l^?oEuqG2;2L%WYjfd_tFrX8YB_Ia* zYE0`MSRChESF5Yk1GeDW!bmp4Uaw89d#7)osE`9}A3NPER}+67Vj8+dL-Jz^-c@#V`Y6Ca8^o9O?vvB_i6wywm0i& zDsA+ZYbzAYwvu_=Xn@Y}Vxf%cBADY*K(BKHtA{w6DR$)|M_+foj^#p^j?M%?he_86 zD-t+e|DWQ{JgUiSUE`>?o~nqoqO>56;Dku62*{{X#b|-bq>OPWG6_+HFhmK~idw4_ zoP{t52r>i}3`!uOT8V-aV}J;P%pe4mfB}K?>_F?eUH7hY?^!+f{?UJ2O~Uu(%iiz% zywCI7L588_<>jDU?00n)TX`srzJA4OM!g?4IZDlA*QlCwi1k5}GuH4oQv0~Yfz8dc z2b_jliM{_=8Fs9a<`q$|+DsrPAZc`)MtK;=?kdBnqfB;=l@)dKUyP@=!)AnCdK&m;dxd z-;HzHFb0u3jRZ}0P$wNC-PTBeha~MUrB{cVH!cpNCH!YGffCsie0y>G`FE==dj1d- zf`ap)66L@9buLUSNH}!h)^*w#CHwBVvxJTd-4*wx34*U=NErz|r$JvVJifl3jQhI= z@VTIwxevtT18&2dIV2-(%};0N_O%V;gAdSG8-_-IHg|41kSc8QAM}?Fq+jnG z5m>BMwe%;s|AC4{gm*#aZsn9&=XLZRroVmJA{LAF>2sOa4y`z&S!3_mr_0ETOi02# znTYWYeCgT?^R4gPU93OyghgyVFKY37vTbb+;>w4At%;~3#*E7!PqIbo2-iq5_pZ&e zBNO2ZbIft|=;W-#7oG%-q4V0bX9gL)W0JzLm+sZZ=&*zb*Pp(S=U~jzyK<2b>-5)h zk_!*P0X&o+?wVtuh-j80EstaEf46ggl{?uX3wyUBf(T#yB`57|O4Ps@WE@H{mpy-h zm4I)CVg(tFcbVUoJ?SLT6Fx7{)U{3jm}t&B7xi_pXC4jMI<$;x6kRIw40IL)TT=hm zPjQ*PU@3N}=_*&RBg$<9kR)~&5AT-A!mSpy6qrDT2kq^p%SEF7^a?V)!b@i>DthncfQ@ zcj+_(XA`{n3#*)I3zm-iv9SpJn6u3ziE4Fiqp2yuILdt82Ap$&X7q7op|ndtekVVd zdr#UD;J@gLBV5l6nMk1P*^>RZi#WNLV+8GYcwW(?h6fNi(O~BH3?$bo)4Fn}v(-=2 zK<)TFvV2Ru}3Rt?#c(0s+KLh~b+$cR`uNIr*VI2OX!SP&j_LH7oe7GE~ zVagVzZy-$0R4-One<)JNzeTS_FXVgZ zP`-1R8No^7Z}@-WtjcQ7k73mRBf9Hf{;BVSxN_0Xba7o5p%=-$I3pWV{)=~2WhN;D zTTfC)#j&<_E~_XcWY0*NEW0@`&XQH}o{~%dqx>a^5MWGDvUothte0p6VCwde`KX+` z8T@?1FnRh19uf7k$g)W(jXOH*UnbcRP^F`{?9ngE&%cowL*i7?>OFi|=odI#@aqG1 zV?k)>InKj?K$*!P)I-KslDoVByEAco)a4z~56=D;CR3oLY^N#3?{6;59qkqY z=O=1raK_T*@;V@)IJ}kUB9G+bU*{8$3T+wiTrzhBzouk(;K@Y-QwqoL%;iXE@mctm@NlZd2GvuNJj@5N@Zhr6fFKX_|3 ziQ-{R1R9u3UJ+OIs<`S;h%0AVTvB5Ai=GMtQY(+2zT^RT7{v+`t9f~&7Sf>rf_*njtmcHcv;{psN~KMA%EP@5a18T-rs1-?Kx$6M&?raLJd=J zA@xv_qc`It9TtGm%r3LDijPXFmNEJL{G#OR@>ZTj3v#>+5lqVDjhsaan~d6GKeX}e zEUAWLZ+7{SPfi*@4?0oi&*q#f?Nm{A5-6DMO*2NFMNphS6|J~1SF_^Ps5FvbY~f?~ z9a?V2fSN9OU7Sg%nuybwg!K4eNZMfhUX#WtoP7SyGa#x7`E%+1TG} zeH-r#4tUW>T?}_Z@W?}xsNm ztdae!O=E8iR_Jyyv+o8ns$fTGL<4~x z+aj2M$z?bkHJ-DH7$#v@RV>ps2gurbxnsmn4e>&-_NXDE#I3Qq&UkiUluoqWa+$vi z1gPx3!~qo)a3-Vei%CX;!xEt9F z%NQM+h@By#KWcEdfe9Zj`02wfmrS}2JY0!1=Tn|!GQmSu=+;H385;A~lH#lqyTHY{EL;K64V-I1X%*?7Zt9G{mf?nyYb;(99aA5d7 z-qgwsd8W0j@RAmcg!2&xbQ+NQ}$YU18f8o_OJBBZ`4O$S~vB4b=&WtnZ`xs)`Jfg*CrC6Yt@kR!G1wV3z|o&2wK z8q;|1Hl!`pi@7i3mliAl%hKz4ogt<4btXR|p(K8{X(`bH?_c{o!#QU|&`>{Nv8~c) zUMG%hN-0OxzUHRKX|R)TyubSeDZ^^uY(wqT5^`@nTu|;$+9F8K6iO=$);2ay=@6Vf zEW2;@!j)-|f34yP7EJt+u!~`-PXfee3-O9UX$v2=7{5?#Q3(i%k_81N2hW9PMb)BK zr<$V(t7Qni-@cRBVk!aK7&s}CLPs%yD|99!Pm?n*Pi&Fj8#`bFeiVUsdjn)>V zp-EZplQT8a{mI7JIspm{EDKoXzT2}W4|-KR{G_=b$``?S8}O2T&Wrb0iMq-L znny=eRd389)*!2?smaf0KB@KO+7>N|C-v&T#K#?5x&Qpq#?~%UFvuNFj=Q-9me&jU zUO6jPXyA^{o}+xN3YPLO*E%(p2_6ZB@MY1j`~&&-myc4+jR!hlROX7iMHR^bTGn3g z6vyg~=_{RXe~V#QBnHEi-3zlHBMnbHEUKEC6=-i|Jg@RBw;4v#Hd9c)B)%0aGug72 zm!6XH4WBvqCCs>R3H+WQ5M>XIM+ekk{`DgZftC#;`0|fLI0~%3uU_2br>{=I6CT8c zAL-8-fGZBk$TO15)q;Xoj%PSB@z1`7NW24-Z+clr-`GXeZz7p~0?tsbGNFuwETyLC zs0Sfcs$n4L864kL0=L8D+^M&4VfXp2S+DmZ7I;?jRLjtHsC(>yg23&vT(g-?({j;} zRC>>jPqt1>&Eh3N%Cfbw=NjPJ6Tfj!VH9_S-EkM*9=$@~(YUOLr#=Cyv7RG>DIuCQ z)%*L;ak_lQej!Th<|+tpQI#g1Oei^6%BdYY_Mm4G)=1&4gj*#U#$zq5$*l3Ko_f>4 zS)dsk7X7U(%Nthi`ujC5wabo7gsrgh@q439%2O^XX-(@+|M6&aQ zkYwe8sG5;#)0L~Jy3S1h6W+&;{UCp%cYi5-ASBhE@r)QiIBb^-voF+eX?#Lt$F7fQ zw-C%POA-A|xu&jDT0wzaCJaon!YG?`#jsi^WX{(Mtn#1x#b*afIeKg1>p3@~u=MBo zX=8_NlqVnJ+W^$1qT{n2D}Bh@gdt+y_sqx8H~oiC5P-W69E0_eGeT=iL%5zkrIZ3T zM67motES7nES!bY9Xzn~6T5g9BErxiY+k)sU}8c=fQt~gQTb+I=K6>*6pWEex^uA1 zj)XRl5Chf>(D-yn# zeMY6ufV=z6cGO08^k*?TLX0+00^07hk!`@J&vOUZBG)^}u2s%xed2#Syy@s9KQSwZ zPHJ;Beq>-ppe;~JPhSd2Fre`ti(DrZEGOuau%Ug;%Ak=s=^G0h{wE#J{*N6Gn?Hz1 zJd9Iq=oCpNx~N!#OoMT=od_(FmFf@goWq?Zrjh3{a`>B=Z#^=?nz4Exfr~;xTtI=I zOs?G8*l400ZE+}y?q)322TFwOSQ@WE8H|s*)TcytT)qEf$Uv(bB173e!%N6{BONnm zH+x#|*pVzz$=O15bjkY%CN?hy?1ae2mt;SlMGnj$s3d6m9Yw`jB>m@jhh6-#&7qp4 z>Vn%&3@lsrRZq4tKLX_!(d7{5$HjEuum}7@p7R{JXhp2!yHWt)fln@pn8bv-K&)-= z;&cM=Ksri%PdIkLp3&drasT}-cIQL&B>bKt6GMgvIaB5@{So^dk${f;O(7M0OX>T& zIdxm<&wTQS8kR;TK6>=&aFbwQ`AY5VX|Yv?7-FK0EJBtd(#FBTLT7 z{TUb-&I07STrxh9leIXPpZ%q6)00Zy+q_zz0Z&c2dg9eAPz0fXFf3sd#r0I~Tbpj( z3n&4ScWG$uh>(V384_Emht0{*0Zg5yrlTmaQmh-|f%zUC9Oz61pG&RwP^ zTg*9=qdN5##B~+zhG z2`G{aRhehJUjOI^v+X9t*_P(N+Lk$Dh8CF}3s(|pbCYcos*8#=oCFawXZ~@QzUZir zUmQGeY#n<_)0EzW`lEU6LU&IeP5G9seN(#6lBH zPlVr%NjZNMBl3c;`dqG1^0!Y(o z4|?JoXWi#6($m|Suvww3Hj7q5oNnkBkaK`xs3q*FYCq%6(ixs_+9F7t;QF`9T9nj` zv@#VMUp&>kwi*qjlR#CIhVv#!U9&5N96l0u=5+h}*$e*{4cI#lvPhn?!9hW&oH^_3 z5|R3ZP)Aa=nA#I-AtFGk97n`qI~<)xM>=Hd@4R@djeW1+>t zNRGqcVV*RkFt@zW+!3+jC;r|}gYHk!cRj!q+maMm^5j?{5({t15Me2YpX0({u(Zg| z8^PC(I0Se6C(cZuMuJ*ol7y#@u*W;jjOHa{odpbnGB%S=sgchu1oIeDYYsU;rlTJHPjL|hf`YtVFoobbPwjO0& zXgpw-q6Qgm|r%VB>-bEd%jY_ltuxPrf}K#KwKGNagXGA_?g;H`VF zCF*c*^G2M+6vsQIDqg-v5lj&fZd1%`NcDhowzQ|Ke7zH6*6YHFaxuFeKYqMU`mM}M k)brV2-V^@2k4uw|ZnNf3;<-(drTZzHEWTlH-1WoX0XR!RlK=n! literal 0 HcmV?d00001 diff --git a/torchrec/distributed/benchmark/benchmark_zch/figures/eval_metrics_mse.png b/torchrec/distributed/benchmark/benchmark_zch/figures/eval_metrics_mse.png new file mode 100644 index 0000000000000000000000000000000000000000..173ae8843b4667f4c9084531f46b95105da511db GIT binary patch literal 28398 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 NnyUK2gda{{`VRzv-u(ao literal 0 HcmV?d00001 diff --git a/torchrec/distributed/benchmark/benchmark_zch/figures/eval_metrics_ne.png b/torchrec/distributed/benchmark/benchmark_zch/figures/eval_metrics_ne.png new file mode 100644 index 0000000000000000000000000000000000000000..7e6eab16077c9b5b79170e2adf9828583aa78127 GIT binary patch literal 36851 zcmdSBXH-<%wg$LC0TIbjKtMoH$vNi|5J@6AO3pcFlnj#ONRSKy0+Mr<43b1Za+aJW z=U!EM?|t39aj{Gbv*8lznv#oL~ehImm&^YcU0@E56&x*rZMc*U6g|N4zK`2z?Scj)!y@@{cvX4%~x8=KQEy&DMX zW_b+jEX9A!Pz=-Z6wuZ-x^wrQXzMRGMqN&93JQv=S%rephe8|}XQl(0bvZ;9A4r*t znD_RNJ5TM068H@H7Y*pcPO(BmB)N&GU@*=v-OELBhOs>XQ6f|C47(JLEeu&n6m?$) z{tkO;l)@Wo>a+jY%iH^WdUN_L+-o_m5IDQ}Cci9h>9i0++)<_2TK@k;YcP1VQ);xKzo z8jOSCm5^gyFk#f!_k%-1f*yg%+GER5FZVc88B|DS#S(ji6jw#~VKmNhBG+MPWcnVI zkj9;>uy3DOpG3A(d!Q;^7oO@LJiNUp9}*%-jF@(-?15Ci`RLEzqhI&h*Kd3ijCz&p z$kbJ?^d4=?P*(jhHBBc31FDA z*z#scFb&lYrx4G3Q12Ft*P4+35LN87H}AWE2?Pg=qxO4 z8=uuSHML~yxrzS5m!}QN&Rl? zX|@Z65xYy$=WH?5wA7@vaDN{9%pvpy7wOsu^7}Z+?^S6XY@9etId#0vtj*XIaLHl% z((O38I|dIoLNM7`3XB_B5RT#FaI)>T-S7IEm2|%?BkOVT=hlYWavVJJdnvlXb#f7;_w%Cr8U3ut^NIx z_vf!pzRnFQ9P)w%B1J5aMMtOXS4!U#!5I^53Asb*Zyx%J z)lm{pyGEG>H%3l6EG(=@ccB99-lkP_f5?4 z3U>yAyC^2vveo9~h_F0hqD)8?9A&cDTU;$s%p>~rgTZpy=F73~eoOT76BTJQo+nyi zQIM~Q;7Q-$LbkHzfRtnajkzYW%l1Un_S`lqXL#0YAI`E_)Rmr{SF=}0)NsLSL1hy=+4V|gNO+3bnDATVTYK>$*FF_3<54yQCCYX#sKM`ubFmb%$0?t9 zCzn*+YPB;NBFyAWBq$_A{(uN^13D4;57h^ZdVg*|=66Mc=66?v$yAxiMvjgrMTZh~ zd`SBX3L@a1w+J#0 z3W|&DobI&Y{pXMV{nvEl7&y4*mHd~hv2xu#Ou%m3YL@vlGq_ZaXu$gtbXgdf~4Qn0`Om_&t0$R30S zQ`Qg*&+0~EMZhgzTA5LFYYV=^ZKhzS53fTI$E%#B9RZub0*qG*@OjR{_Qj~m!XSRJ zx6*mSB#>OJS$exbjnUaj9sX&f87Jw;*q8wSJN*_bZi(E{jLb}AywLWch4BFK3{g>0 z$cR1h@l`2Q8ap}Zak)8jBU(HrK^-$6dBmeXJ3SGJ6%Ov=GjW8Ze^3x=KyYyQF~*u5 znEi~g&H0U|l(;A%6IPO@ru0u47;p&)Zo9g=)}Qnwa=5%^CE45Y6&3?qDfIfP-%`U1 zBtJ2)4EEXTp3~yFxw%m>GTxJulgm8pp{GI?ydF7-TN1h6ald{0^n}0Ja}G&aRpl0B zGMM}(@L)BJf(F=3Or^S4bU{IZSrS9!N90eyeOx}|4{oNUq{J=#{K*X>+95wnY!3*Z zM$RG@&S=M!yjHa?17GfY?@Xk%93%XMbNby!7Qlu1;pXM-M71o!#~WZ%j|rg)iOkh0hNUdkn7D6X(lzz z*5MAS=?DQ;ff{qi#)m2mOw5a>`M%3t!{uVCwEjOeWo~b~2LBvwgpsJ(ezk0ptOBLU1 zKd4hpBg~AdnSzxozq**EAku}67B$~Ne0|&2);4A?&>Bo)0AdpIDhPO82ZmnW>-lxc z3%2OJ&Z(Quo2z|Stnjv(nZ`l9>TKiX@yliI=>{9j9D2FRhHGDzhTDnZ7`op3#e2V% zG<7M-9t4`d!rwcM9n|mrX}dSb9jXcr|Tn$9YBa19hBK z|77;+)M1n7^XD&b3kn!=+PfBVPprR!9T9@&wkQ4LZ_bEjFIVUG)1tT^((_R6Q0ye| zxMETG{%R2`q{|uG+>dW=e8;Arak}oUb~m))l7rWCN6_csk^_Y2-p(kp@RRE!($-dS zv=j`}7Wkufqgzea;Bu)D?)~0(Tw5`b$;QJLxh!crr!NbB5=*b&a}>UJEU^2~SQ3xm z?z1%R`eUysVm8Da6o2zMaEO8 z<)0>U%!)QzRiqil^g3-lnL{<>LwiRqxG*1MVOct8~+&C2kocFr=` zaUTi3wZjI)3RNX^G*BGPYnSfg=;={C{l?~vKQSR8a)rL*yJqio+!0@6+ot0^;9F|U z@IHs`ko4!_B}-bn(8<-k`V+6H`dw{Xckk;4WyS;^V!Y7X)w2~ul)k_D28dFs>ma_A z*kC3-Z~tJ58sep{h;8Sh(o*!)REoXBL-LUePs=6G@zWjO^9CDEQZ#2uHhAtu?SS{b zid%YvY~K4r^T4E5y(-4RcqyZ(S^MvUqmIUt=}_0%3!L6K?O-;2HM&m)0{kGc4}FHQ za#Tn6m=&i*>`e{GWyUsR7Y&%YzzxY{|IWYY*NKqH?wr#-r_Z62Zz<#{+;*Jp=s+|i@RbwytL`D$%Zn>)G;a}419+nJ3)b+-Az((~(CUEMpB z_$FtotD6{3wj`(LTDz}@-ny%M&Ajy~j!NW38qT4c7ooHkmoR*lcJL@(X1`TLw}WSH zhrGSsg&CeRgKS>e{q&9J(9fTdS?h^$V>Wue9P+CxOa4*9&otaoeq-E)I~xcbEML@J zuAMD2u;#JPY#Nsl$|$>sPySohVK{Lz$kL*$X#K?J5$wP*l;0_)+FyHFM0A z>U~`elA4fUpYzy<9lxZ>-y#BeR#AhF%o5i zLiX&Ys~4ER=+;^(dPee+fl_{GK6fIvt)sJ3bI8JoEm8J!A)|z}8^I?f;f8Xee`Oeb z;VexdlYRFBDykMHY8{{L-ekYKR}mQ4;<=$Lc+kg@c_Kn^*@y1PXX{Z;@baqAr^-rW z%w{c;-~r~=#L_s42WwLQ_f2Oz=MMr-gA|^RSy-fujEtIB2U7%0V|`98a72h#Ub9Ihrh%*JvAN%Jl56WlleVv7Z>OT7&(m2{ z)3kO*kiC4Rg2X~861**2sQh$)uMJz^lWpcg5ZwHSq8=0IO3QgmjtH~poFmPzF^G*= zaE*LWVU3Ry$bt5cP%<;ycjL_x5H1UAOZ`-c`TiW$je#KZc&cc$RnTQCgh@1x>6Xlk z2V@dXoF%4FC6>FjyZR$PM^8MjDOoPj!Gc4OY50KtLHty-Zw`*N_4eNJacjW-l3iQ= za)N+q-10|kkqH1NTp`cd%-rr!5w;x^zR_B9@@P2zjnVp+0tJD~3`O%g{1*0*ou|y@ znfJA=mm6u)`_?U*^jRpZ;O}O4=j6P=H@L@aQeaTIH!Tmk{vE$Gx{jH2QE zyxDH1)%|qF_X$e%(Zm4{~50D<)7j1pqLIUmJc?!HN9wa(07o>?8C2uULdpR#T2`F*}V?L{jm*RbJ* z1=%^i`r0oyUHgpY0WcW{%}5G0P{R++PQLrjhU@k#Mv9yW4Hp-4X4AIWAEadsdtgVC zr7Lfk9UmXDd|z8>(|FKS&{Q-EI|^@JMmAj{&JH_IYY?<0UdE~eNEqVlx^FY}B?+MQ#xw6Y3bRr{qoZ7^bHx%f zM`%y-l#vq;pI!_|0{|xYBkATYpE`)xVq#)0_05f?U{}js?Y3V|C1vtT;@T@JBC6bt zX{v^BV@Uc;IIgc3MHV(T!g780*HotZq~%+SW-ii|@-mb?j`?gkNlUNlXVja1@z>PX zYo*4K2ngu2Ya9QL>A9UC%j)bhd5wwWCyUy>d|X>C4L3p^|KM*SYnl)h-Twz~yY8s#1+O;eS`wl-eG%^oYnV2l4fVd7P0&S79k z_xkrI-rh~T6s#WwGvAF+`%I*dJhYlV>}Vwgd;dutXkuwr2NU{Dx^?*Hm$QhP9YFwi z^eEeHS0rt|F7SX&|B{!Ji|fQZOR*c5@ctXH_1$J^Jg1wSnzTQt;{rQJP*A6&SG^;4 z)0{7ki059DZU-79{Rl7M=?CwfC-FT{`Fj3pP`+gL+nz9&fk+SuhVCqXKI71|CVT5& zbnYrfO`Y_)xHx!-cds*6z;!oJx47$#f3W@h{6axhVmvpRi08a6t$b+L?)7H;c%!Qb z+$hZ~ErWl&2u(m=+MjFoK`q6nS6^{5bJm3X#B$5q1jru1XE5S*WP(U+>NPdg#grxs ztHOV_RF!hgstK;E=fl&kyOazTm1S-$0Lb9wn@qPV&l?aq|luAepZ`s{tSy7!ED zjkfVMAJlMKkXtmdYSsn!F01@ZYJBI)qwi*o4`U7w^vnd7es{pCN=>7(Xx7q(?yNca z!Kioe)v|D-6YEv$srBJ^5+ip%LbGOLimF)2{>*^7j3E?uH=A8~MA*5`<@MfFkRmpG z8|_{Zbk=T42ni{YAA!RpnWsumzV$M|cUAca)PgvcH&Icp#oX+PvVA4s+gL&HE5nR@ zGYP0X{E@)awGF*v{9NxE)nGOBwn7)ByQOWNH`SZeb;bt+Kz1Rx6qxuR^26j*P#U~0 zd5e<4z8%7RHcf%UZ`;Zh?*D}YxMi9O|wot8auMfA)Wq~uAi0HuEdLdxL-Wkw+{(> z_mxM$MW?dy$1pyW4s!78;Ize)o2%rud6#aD~+xK!e5Lir1 z%uLMSa!VwKr}WqmD;*;N_N;HzXlyTW--~DRx=3LII-R%;krMUetV+)Jq}f zr+p55RIRbmWpP9#1b1uP+{KE=u&>X{*ej~Z(nssQj=AoQVLy|T!zIYUdYo+{E#9Gn z?DpAxGYVAU0D>^X5Syrko;=z1IA;^F9!Q`2zLm(K=(K~JpKrNE@Bp4bBKalB1cn?s z4V_OV$GoX3VRchT39G26XwhqS=WuYGQqsuMrCt%+EeOJ^jA}_0D{`6Yincv%<%=o00Gg$*On}|y=zY# zasspJzc^o@4hBy44}1WrfNfLU2zHuYRJbuKbn-i2y-MlTt8i@LYjS{?h`PQpjG{Ig z17)DgsxIW0l!T12I`~Yx4^~rKn~_n9yPnu(U$rLqv><=~d}?>GHkTqeKK{pwJ%WMZ z!w2>gvtaoB$B(e3iCk81&CJoUL|M8^yU&*72FkzY@5a9&7ycN^(madRI12&L?L%*o zl#ax$$TVK#a$zXFs)|COE*x7y0bB6mm*E}srm}odC*|8FvS~pq)izz%{!-t^#{-J1 zciV&Ne@<~?fw^+{?-Q@wq23~t?veJMZidG&o7wy1{O|QgEmTP(Kmk@Y!G7jt(Q1^` z;kakVf9P=w`SQvR@EL4A+ML3dzc7+!Zpw53P??%PUE$(fyqJ~iY^nCJI34E*GXf5N zGQ{geeT96Jx+H+n4?NFS%J}jHlZk2ZL`SFajcqWJWZqENPgs@V7_t#qQkPvJKY;DR z{f2;mNdLI+m+rxXkqxYoQJ!=F?yU~!iT>PwrIV?q`7@u*uOFODZ*68?)bE8AuGZp4)i~Akg(>K}L;+@67hVmSY?(%#oON z-iv1J;Z@G%(4h-r;(e7Hu?gMM^6NHY7d#xsbUUl`70Vh*pYPKkNamX==w~Rt*~}lS ztF2wgNV6$fr#(F4DSoEC1xuRQwFrA5lQCq51mSl+Ya2D5C+O)vN|MH^2X&ucktGF9!t7*pgG=Wv{Gel?A-W|4odg(W=buzV8jQ$ zN=$wc7^7QpEXPQDr(p*wxoVD8}6(MW#rmvw%FyqyBvKc z<)6Ki`b~O8q?UC*_wHj=*X(CCgkRkp6m%?v2nYJCBtLZROJa@O@O)hB7}W44jjttv zM?c7LHW>v2hirKBD9(@=2_hkb+b|kzf zG}+^+EfO8Q_ZVpiGbKKXa$0DTO07n0eVfK&j+vR+4=K7w8@8)eWanQWOb_-w@;J{7 zfNX<1!2u>dtg_rb-#thcbY==JykcDv^j^S6?JSXu5y0G1H^M&<2rqDtU!!9@SZ5Rf zh$wD6Bu;9lK@HTl;oCXmG@=rkdO~owpvZoN5*HV4y-hT`rySSz9y@ew{E`k?oZ(h)A5I*3%r-JY`E5Ne$I-6&o z)%$Zd;#*ib(f;$T$XgKMf);32zBwh`4uV|vWiv}~gQj+%&3!7$OomSsR_kaYmaVk3 z7b7bb%<)($kD%xID+KkIs4;O>HELE7ci>P9FWh0_e<&l|FQYtu0Ox zYC1ZG%k7NK7S(Oo6%7o?_u5-pl7XGoBPG7a=ngs-sj^;^@NCU?9NB(P4%2tD3b*}H zo>Ds>(#0i%bj9wMT53@e!5oT8la+7!YStbz>XoVQc_N;UlsUNys=YK4%N?8e1^ot|`Q@VSox0)uaZfO=`c^*Ibn(B>qUJ)J@ z-r`NR6QFG~gBk#jFR-@6S433&DHKv1We_AYxFEo2-qN7lt`OD%a=hdxjN*vo=wrl zjWWa=9DU2?t{o#QZg}lH1%mk(t#Z80pI<7T&;7kVuoX4EIo?m3kMPimn54@!1Q8$n zQkUnujR65_A5PD`qvZKHl<`N>5HVf}!TD^e(xO5b^_%c;jE2U4Lf*amdT1UBDE=~2 zH^cz6>|ofXRXZri`S=Oo_DNlao6981Ns2k3_gM10bSV-m5OF_N?R1W!UyRuk(^XwX zZNHyPb((QzB=YoJpxE`Z_Oz1zLTVxoK%T( z!ClaYS7z-2J<=aPz8=I0l|*^2MMissxu^OVwp*`L5a_<8j+pD)8N_?Mo{n4<+H9gQh8e1M-;RAa)G8#i} zAL~MMKEnK*U({Jss;2sNosalaejREl8~(ZW=E4pVWM*St2`-tbn5X=h!BXNy_^G#= zn&teIzTZp!8X-6M18%hxp-96{NkAese{n0A&DsL_pHv+M{(n+a_x9}IS`+zXLGMvy zFfb|fnsu+Zij)1{D4WL6q|3*Tw0oS=5YNl{N5EX`o`P9;K8$Dg+lhH&gKTe=Shw>i ze8mtf3*@(Nm=)u@!pI((B5DNVUCHe))m8(+>p}f7(lmOCBuQW^Mqb`v$mDAF3lZqc z65Obs!(CUH3HN2p0$jQSlmywvgmI3JCfQU#CIG+zucl?ot;u@Ij25xAwJn&63g$aH zeCV}|SF(@nWIZ5;MtzlR#sv@TV=^?$o!_{ z<>vXM)TxIW%sXO{sLM2v-rH~S9(s7Ejd^=D>`xDibkShXh66EzM~dg#wP%T$7^xAv zM%tzUU1ZlQ1;HPt=z54tk~Ud!-`4bpK#wK+?=CWH}i|y?#`&1PbLK zEn7{0GF7Iw>=(wsU+q5BQ&W50139!6At^i_;PRm-4Ir&=jm!tPt)DK~@dJuI9K}3O z`eU5kC_TAQ?Gu6o0%F5nMTC`hqfdN+_79GpIY!B0F%#*vb}YV7^jQuanRp_dBtZ5C z>AGqo67kKThe?D~zUNoPFV&r}Kn#zL*SnKdYB|jDK{KN90^4BjjRYLeJ~MZW=6yt= zl&7=W3^zC282qwzoG*aVZ|~|5&sJShSLKGUqnz~v2-K!aRzvQ|O#IlCl(wJx69a4W z%I7zitb1|(++65{F(poREE%pVrbB#Gox2K-fXZ`H+5UjgTZFCzLYI{oWu zJ^<`lM*V%T&~axPafpP6n{=sD((tOEXR*EKmGq#X%|!HfBld?pyZ0Op2B^NyVITZh zp>kH0DZUa%T-5AWi6@dnqWD88%?+zh*#nX)&X_+q%IpL$I6-m(`E}-)SWPwI3%KmG zROF$<1A+nFJ7NYw#QNdAF+-7704%xvX1`^r&Gysefqp5;6?=k|<~tCGq20oX{#&tp zchJ#WFKZov8GNK^{bOuoj?zd5>(d~j^gNe-E-(J#1%rI*Ku2D(;6K_=Z$TqJe;NW! z!5?ZOMDk9q2FBRf7+N@Se^(avOq5D*ylAJf2O_VLBo7uws+G+h2Kp0rh=kCl?p$P1u-2 z!v~d7?}6aJAS&w}tG?94d#*e@rEQ2Tfm#5s5aRPKC0W1UWzWxp?a`Rwio?t!~I;|LGuF&`z#d{jkkc?`b*ij0DdFv4{>e@tXU zPaZRhdq@%ihDDz<(IX{RCL4~0xSN;bQW9H6?I519`#CUMa~m5mj}?0(qZH8>FD%mz zK&}JuaH1bdrY&7vQ>rs}m2_T(_kFP`>ASH$?x_=2$zT`?AIq)pUm?hSvoQY z5tH)!rgy{Pt1Hv{ZD{f*s(;HJ@PvRzdFZm}_6gK^@LIEh1@RoFrsc@Le6J6Y`%D~* z$7u1;={h=I`%IG4%BJ4V!{6F2bp+-(UEVyX)Z7nBeH-(R#8zr@UN<<{g8kMX8RcYn z@@M3U$R)ul3&9Cru2Mn9)0bH_zwnN?MM6F>#J%qL(ed^IaVb(}D^`49&0Pd~H2*#3kmywXv}Qr~(X31@NS(Z}}Dt*T?m4J9%9T z%h}{kBBX^x#ZA{NfKs>x!AotBTi?ON3<7Xfq4hTJEA@b^^)8^)D)sKNNq9&1MYFVh zWj7J-3f+n0PFUT5eP;FDA*YplQPP7$rXphnbt3$CpMas3+cw| z-~oula0hlY8T4yTOOu;rK^P!M*+jzUx$E=$f=35w`jWpna~XucUmdoM2tB;csVwj$ zq!cRDs=o`AfRNu8eEOm9WOv0JUbmt$?J};Q#}IfH+Y)F=oV83&d8C%OgWz%avdKg<01OT)o#G2xyR|Bw+zs zkx3rfK;Z@|WjsC~)tWp1r8qyifGw7dCxpf=y=~1DI{_YL!N;B0cdLr)NIhqKROK*Y z9bvXGuBUgS^EXI)?c2Fhr6Ez68woAm^RY@5t}&|{!=+3brmjcX#G8}tT=rMjr;lzFP42+ssemso zghNXDu4muge*;J;0VrB?pU}`pIiCR~K*@ZjtWHb)cLq5iII881zf`oIVo2ef*H~^ubv5z(*c^k2qj1zl0k6SY z8UyyE{>E!Qc2ucDbM7RRWuJ-_Oo_e}j$fF7QtSk>q}_Zw@D2!yILHrH7~xkM+hpou zM!t*FC?@iHs$j^%nb&uL8lYhp)>%qd#I4#kQq*+ZHlV@02UW*VgFkP5lwiJJ`m%6OT_Uln{De}{Zn!g$5vL` z)_bcBeBm!&`W`<;L~POZb(w{Y z4}fPIo;2Nh%v>9=`2NM?kDj=$vo5it-T?suCarbnhAOYXy4>l5-BiudxHfu`8tiLh#+`rA>4xMTj^ z)y;5?C-8hZL~ZVrnE6B85}?)T-bHnO`Nyc>+-}4RHx%|`GmXa34wi-&3RB#XvYcgY zpXQU8{W_TZ8ek@uMR&UflUc#LHa6P<@saMNBrQ}ga;RnaS*T-t=00~Vp?ZQSU^vM`f8YKD zNPDfOb5xK?Ednh7-hyFk(IoTc>GQ1_UmX0-sE+OGqPBz*#iYYI$9NY@7qT%6XT<^m z2m(q3I67BX34S&i$A2?BZY_4%!O||3Zl#e z@$9e7;l*bMj0*A|9{&O|JW|5L-j(#}44GA&di9Q7*$@o>oQT_I!=2vJ&zG)jsz59 zn@7Apiv&Ph%jP=32nz@nV~&?7-1!=~h(|8`-u#J6r=*m@!euSDdof}qL5YVFB3}Tg z?u#?5b4|Upq6nRev4mna635lPfR@)^)uvoT3r6(^n{JJl?~10m?Ax;e@llGZ9Cb4s zW!*oJqWl`1=Jf__e*dT`FB~xGolFU{>9ccB*UoO}{6VXN80xP(Hy7659J>%IZ&((4 z9T~=-EZ9}=f7(JhP{I{?LIm<^yPT3c{Y*^Y0rrl6iz^%5HW^5WG=G(QuQn}oscXR% zaD%xHzoU~}Q2}9Krk0mJMh0>Luz6B~N77gQ<|IoZ@{?{CA+zkB0C^WW`dx8Q{4qknrc-PWcG)U+iw{W4!RQ@4cGZ5w{SRoMn8Bpbt{iH({5KdB^ty}YOy)_5>*IcEyW% z=C^7wfQap_^PAf4z2UTJ6rRA=)Q50sGHy)B7XNLGnb^{_vyQB|Mz$}wM5J$X)7+fC z%3&bx-s}|DcxJ3S#O`uMO(A1#8U>z=n`@wa{Fs!nKKp38zaR73#|HrAUn|<5fSQO# z5}_@H(XzkfNrl%kHRGWMF3%D6A>Y0uQG#%i5N1QT{tCPRCWG^(Hwm?_wq9Rz@gL!0 z?9nX^4l4&rgmF7C0xXBpyXrm!l$#?308Kkr1gOSeG>9f(7`p}Rf00;k5TgQEMnP1S zxtRh=KRj&M*hE|aRszJ&9vwf#8s!oHpA`%K2r+nOOj{8dt_>g}p|APNFK}>$J5zPw zlY%?M`Wm3BV6nUV1q=t75rdnNlv*M!g1!!DZEIw_oD4ApDczQ)AFXUC8f0XWQew)3 zxB{mv2sO3(%S!JeBHK%s==VpfY=LTYdjdh#;qvhTd$6^(?9!>8dy7x6uw>>z6lr4g zkl6%iwE|kErZ9?%ilWu+DR%-8cg)EShC4gJU^#JT;<*6@S7BNLa|}WY0B$t`N4^;w z=xkk_?jSC1MC0O(%PSJxIOY zgU`#W0nK?Eq#O40-*G|S7gBH2+#!$q$4(Nq&Ts!3-?t(cNR5ab7!cC~5Jyl>j!CkR zYYTHJe9~}ZPLo~ksJ^fygVGxtXZ{2KIoMygBX7a!8C(()zn)lwhp|0Y_o)$g z%NMN^x1i$TVeswO^SCrPgR5>9B2@RsGW6SvF8tu-4eZAe%pbA--GGZz*lFrdt)_>6 zCsV%@{KF_oge1@wXBHM>rjTOhfC>gt*!_`Uq2UxlPZ;@w{eyqlA5XiJ+>`9xyt%p@ zw!>~z@=F#>34f8jtX^q=K2319wDnIdhznppAR{|98YUta@cEH{Os}xI=p-);SIV^; zVz&;Cjm`dbTxqL1?Cwzjz-;Pv1cN#R#L}y(;-VrH2o5IAoQRaV{smU4!G>hK{DJpl z3<`AT&K|th4Q{?%uXekPK|60;85WL7&j$j_b)$l zuhe`npi>j#9~`*|g1zX8ApHANjH!SFUYbhrtlusC-xRtHE8Z6eXK}?K10sQ_9k+G{D4w?6+pADrv7pDhV_rlpZDR zmVjSI{63`lLRVqGme-nVd}dMwG$}$5yq_?rGe_*i7)Z51d7pmqy!Y10 zEci|hBbXseTlL6)?mq{jd3NbfE;qhF-UcF}1cC+zxHb-%06fmYeb~Zc^SmzsV+chXqZM_+WP*ONaACZJD|_WT^|^RdZWP;PE97wk6PdJhD51jT4(w( zLAO-lSNrErI6oE%J*RsY9#qi#)mDJpBy+hYy~ON0O80s)a_|13Il6yjJbYBM zPXL-)?~%*EaW0ZjagJE#r8el}nvw#EAax8}6O*66@^Rbu3&38WuRv}cgS!wn)^EZw zsq)l}Qxo7s3p)cspnVXG4c={o;s)z#4gRLifnbo-lqxpUR{`%8EYG~kr(!z#CTCNCUV;C?}CZKxy zVbbA?vL;V;`-=$`KkcU3N#swp*@US683il~3cr@qT0ALzP*dc`a;@d$9#q*(z1fP* z-Ct`vX#+9pn=4`QK+3tT& zOJ(rNQ?~Hh+ouC%ih8xlqZ~TfAW)T0s#yFYCRhZ%_Iy{XcDIB)= zK9LdhsZ!(L)hoO0ys11ZAiI6k0+&qT-CYR_$vmcPPlH|`CF^DEUVqmP&yW&0!&x!? zqS^EbjuwgfiGZp(tY6RO76dj9eP<**Jc>uWIT@fY!oOaM?AKkM$Bo{w?I~a?tPp!* z_?mYwp^e?iUO;?QTKaU<&j$UFT1TV*rflZ3l^Fd)xE~dpnIQ81v*r?akr|ADJ$hO-PqVLzpxMqD&Vyv4<{!VO`(Mpgh$kr zf)xe;xBYNL!AnK;fIdTdMY|P7z@NY?Y;k*ZZr{oWukh&%kNb?kRz_H9fq{u$Mb5*; zrB~hvwlB>YBxrAcpF(-z*XHJ}KyjPInxZi>s@NXX2Faa`Ff1oz=pAa-s5fHM#pL0B z@D}s{vvTRP!wpt*=FJ!U+-PTNvSmUQR+4+X?)=0c)o7i15t{g<+dJx0eGBO@N+5SkPtTyNOxqHuN3aCfm&j-2_4oUu9+RxBsczSpM!KitSjXo)$ z)uR)gk?G46vI=zqt6T`1MC|U&QSt_a?6DWP`dJ@>Dtivnlz|t05kKa%nzJ` z4)}p8Od~RvPM*Ta_Z3~2#@*=hXRD};p!0Jxeb~952OaBfg-7CRL~gbq{g1sOoIp5; z;F-U<+O^&5mNw+GsD64{IqV3b&xtsfBb5}T^aYmnW(uL%`^3!KvJt05& zTnQ7^n-{2-oSMDvwc3&9q3HfQwvrC-jg@}1(A>YZL-Rg0#+WZMjX+?n3BH&iLHI9k zra?PZ468dH9-V^tAL1^;u&W&OWFuwu1WaFYboYzgQozRUlTHnq;4r1)f7(jt&7xOF za=%L+^wk+&MCybjvSI=B#-kFR0&ayDe=pkj__@h#sG&gkgF74+=<>asIk)+?+LZAkWMALHsI$1Q>e*}jVeywYBa&s*Ji7+VH-bD_` z!vpX_R$`nE|;UvW{bKUmW0QYpFE)4FAud zL3D4Rt?1{&!*={A;SgWnJvM;MWmSAZru3@FQxE{UJg$N`!}Z0$e^UYEx_*GY0C~6n z)~j03Lqrlp(feJ77Ed-bs@&WcObxY<5+f+Y7C@r*QA-o3P#3nB13!1)LG<+JfF?RU zu!*`I_jE;jKSi6McU08XKvAi`3qPsggue%%m5Ft`hm!FW6B-XksKBb&;e5i zwlP67=SF(-;DFou178T>rA1VAeE$X3-Fsi_xEM+SgdjH7y#EbDwfcihHvGr~fLJhp zMldFsF|ZNjPubaoKnsJ=Yjo!5u1-%+!_&mR#1C%)a?*Ye-ijF#0y8*4ZU^}UeKmAn zgC4FC1;Q>k?-7qyz8 zba$Qz!^B!NNa{~2LEEo#*f;<(*t|(|6kY^~Kde^yyXW2mdu~s^z%8f2&5+1CA;Q4J@p#xr!I3qzkMH->m;l#QJAD?0TfD4U$n`&`U{c+*QTiZ9|<9i6b z5wJ#pqM!smgWz1%m#4zaWFpL@fSQH;G98KkPxYX&3K#U+#U3e$O-`xs+U?zeUbmi>x`am| zMrk)5L#8#B9FtKc{Gf6=NS~%vd0!vo(Yij{)}Kc)PG-2lIbz5>M!P;|9_Gag&&o1oTy$|Uvb6$d{TDFD{sCp55r zrv&|g0OkzT9>{k617T9Xyc^w1aF-7_a66D~8MwUo6BSzjJ3wy}=L=}zyi??$*8NEd z!V^1*mU#q-hTybf7C@UwDjNm#Fa6=`?ZMji^e~j133UYo8UREGm&3lHe^(AM_%YX3 z&}$WyvH3LHCjVD_?*9^Bq4pFhh+bbdHv>VfKS$uRQed`oC4miIsd?MBK_BIA_`t%joE|)ra9g{^OdzKO z?Jc)KsV4r()MTNY1qkDZ7r-$fU(~C{Q*HkOlmH=-2DUCd_nQlVQgBqIb#8F?;~0>2 zEauVs1QF|A($C(kaa^v{=7Qq_EcrwL@D4vD1RQdcS+bU#jtpmez&`L;&=ZTPu<*Nu z^PZ9iH6tU?ONJ(Vcz-WZmV50&v!Jr@f$#O^3q@BaK+XQu?HB$5%S`ow^P^!=z)zk4 z_5ycHjJ=b#qi~}1@>l*6QXCh_X{nrqkfN5F$XWs%r*6KyQrVjF#erL6fdFXU|33XA z3_kIvjr$h2Eq znC_}qLn9KD@*u^(ZndcKVt;#}5rTMlP>2T7!fO&j?HnB?Bn)Z5StM{>3uyIUI;x)Q za8wY&VqsZMH>8v{QRV)9_pY^v!k=6ZG%rZMuw;NlsqbG>P_dhj;e1|Mi4$H`wjhK= z`9t)TDl3o1hjhH$Kpr|lPbnd77rpHDKPvLE`H!zbrY%E74wz#qB* z;bZNBkSt{`z#qa)niYDzdxD0>m756;Fz}uO2Pf^F>2QaWoo0k#HM<=?V%8S~>i^MmxBM!->&8 z$jL6Zv&X=^3xQK*$^=7CO92lF6c)FAz4z1N7M{PVi(f$TgSRL!6gOiQ%A-LET!wWj z_8@eLXAL1kf1v}KLC{F18HrIB9+Y8bW786^=ZgXTl`jQ({au~zB1h4c{*(xise<0c zAjzy2(8614Ip`yutpp@r5950u#>k|Ptq=VydfW1P&AAbrXA;M#Yj#!(&baaLR!ho5 zk7e=<(0=hh;t$2kOLAK2LuLy(iu2&`3qnr%Ab8X^qXpnL4v-_zQ+VP4a&z;juE$6m zpwmDYrwDMT9AG0I!GIw1xn8@~=)#Y^lUmJ2<4y`%y@E&W54DTNn!8e|uk7vZOTYMJ z1CfbRLE+A37wE%ppU6A_Z6#xcl77ucy|@TeJ%SU!?#K{0iw7>Yc-Wkdqd_mfFdZ1K zm{)X-(FhJA0K^itxdk$4dO%lG8`E7i&6e!~z#~j^pCBtY_3FuopG*at*~$P)o^b$e zPzN8!F4YYU@vD5wZ$UVK)iTd3NAt!;n0!q84obH%`m4nl)<=NrP<2hOEW`w7xq#%T zsL0{*2a3Ie2dC>WBUnv(6U*RzB)k4UvVz>v4OA;nF7P!<+eu`g1P5UCw09Sie^Zy} zd6JZ&tx0+9UzvKpN%_Ak@_(!SPjv_*)A;oN>iz@aDlJ5>Ke-#>XK;W80a2=iq9Rpi zR5*o_uSeso!xnWqG(>iItE%xMI7!NW=kgi!m5HaY*2JDm9kd8=H>OqoUjYg1VUGWI zfW$&Hayw~%f8ps`d4I?|693h-tB&ZMQOC#e*HVsh=fjTjVV6=8Ek*xFduJV%)w-_x z0SG85A*h5R7^GN82`C5>q9P#Dhyv2xr6`C<$plnNTDn`L1Vlu-yFa=^@;u|iIj3tc z*IsL1`<(yIyzl~@#K#!#c;6@P`}f3tilpfN)O)~E_=hBvb3aU_P*5^HT5?dXsI4ZS zWi;|*?|HwxN|9p%?2S_7%R{cHHO_naWxW+t>O#){M&3ZGu=$*rr@*(F=D03VJ+AOO z5w1V3aplpkIUYUl7e2#f@J~6mr~&AI@B0)NCx_&d zA;R?h`kgfa^CQl{F}>9nB2hTM+g}=f_YVHEK^C+2*^e z^pG$79dGBUb9;L5Fk-)+kGKfx+zN-zs9()P#1%A0(jjj=hdHa^S-cH#1u9nF+4)Lm zJLFGDK}mUWgctf9AkP^Bk0HjAA3So}5Ov=}#RL9t14%9Gh2I9f(XLRCVE;t|89&4X}JKssG5vkUC>5dba9B#91&bscb->p~Kfv!R)ix76(Xe@>1 zN?|nBdLxUe0a%E9V-oH*bhH3KFU#mJslfY9)@n4}2V+)w!4fTslml(pLQ|5-;AdzO zxtcZJQTp^Se1toJ_8n5?M(@drM-12^*POO5k@8iA4YsFduo@! z-ybfkb_Tm+8|Kd#WZt4wGuq%ROUYhc#dO3!l)c#On;{2Gb*m2EWqh4dfD9s-xhVCM;}4Yx@TiSG?4N@pwGm19`}N-Of}@W zhF#c&LSY4cTS`jGS5R&OA*ZH(d0=Y{1bWc%fwl$&=`O8KXXSgBxVh%4wWL7|hZc3) zQtq>2>|eWHXGs!VLb#tbwQr}pl6Y@oZj9cgbvSg!K z{NEyn{&;5WorJ0~*ui@EveE%sq?e;6-JjUPU^`OgfP+ZhrMi9RK3W3<-?G7tunSc1 z)PRQib3$`LzLMhsOgPD2zna-?&-O?+`;m0cWt|lYgdgoW9v7K9vym}MN`NQ<>Lm^( zyOH%PAk>G3jV{Rg(F5>?7~C6t1mxiJ(|3KD;q1Z1!{taTDk>Vz@R;-P&1-MP3y?Ca zEu;gpec4}aMYPYG`QeKxN;h;;_kFd$dTw`<54s=#B$Ec)Ixv7J7#ZC=S!?!_kmOHp zqd)3}o-Ji8a^!_7S2buX&zZ~`N_gzG_pNo{DTS^zq6uE0kHx7%Em%O(3vqJL;CHUi zdH^5BLr;IQ=o=R{Me!Db{+i$w!9sq2sp-x=0|zM;{M(803IwSP{`wF9sF)Gpe*JH1Mh#Os#TCmQ)tea^s^jr{@08arbdvRQzp#4(AE&?a&vVHNDBJAotar$Aq zLi)~XlR=O+l=&dW9_m;Ka4Yl>J5gqEcDs_S5&N3_J0OYtBaqywBe2sjSCRvJYe#J1 z>h2|dEddbhe%x8qn6Y!fzJjAVKcO5i#P&cAP?*tfXHwdpz+gnc*$27SGv6bi=V+zS z+S_ivh+z?SW*EIwi}j(`@7~QCUD%Xkc{Z{5SNKaO2eYMIywiu8lEH12;L%*3&SVIFTU7(8p zhcEa+OpAknu?6xQMBl8HkQ8{{E#a!!NG^ z<*2KbeZDo9LC@gcVE-{k5~!(`x+2mc;8G*fxp4cQ26;|lboD3^j9dzIv8)dud( zK7{7%J94+O7YqVxrQr8VY6Xj1m-(msnC$vXaI{`dR(7AF`JVN6>!0>Gl5SXYf<@-- zvpI75YqG{T7nNrex(kYmv^KKEph)ZvsH+Fh#Ie`=1U$t!uJ8{XP$J78m%RYR^@f&~ zSAZFSy#;8l@W_jp-hQt%xVLQa(9?Zt#nj4bW(E2xSC#bk1BPR|^Ah&C;bSUFeY&Di zvgv~A89-3m7~Z>g2e`GMFa(lnD19G?BXIr4#skn?fp6FcWW^4D78j(l`HsUG&`~^x zSkDPSlfm@cJ3c(t=J=}#%hc@qu=l~78&(Kvs4!cU=Ys7$D*0piqCK?VzJ6uTSeY_G z^ynlU#~(}yH@D9c)$T*(4GMK0GP#@ z_*f|bZhFqFoY&!Jfrsow7qbV5**R3q8G<+q$WWRrYDZ}1`;d}Ch`?Hi(PfkX75O?y zRM6i^N^-2}BlhAlzYwhwe7=uRtM%ncRQ7>3Lm-Mf4KEsEQv|)vY7VQ~?cv*p=?-}U z(j@;n-pWblrLn}kW z#LDdie#q5_Fn-ug`inc1zyWDPO&wkdrws31Te71mx$Sne0?Drwey{S^f4d*3d4^5x zsN}Eqt2h+Bl$DhuFCQM59djQTIR3d(Mg-uq>py;U#b9gICv?aCaK+-AnRjKFQ0oP# zGclGMLPn=#4|{+Q6eTL%*7`5R9GC|& zjnIxI%8L32fj=$Gh3Mf^f6|@WPn;@!_+1X1GIk5U3kPV_d33; zzJ2u;KI*>%;UvgP3Ru%kcU0kJqeaf6N9p{-?dSmvgkI9Ll5MVVhem$nI$&!of-nxR#1hD`C zFmc-9>zYnlGJX%`e5!7OX|Aeorv*I#%2BO)_PmQT2#|`?7%m~8Ud}@qh>3;wi@6X# z8}5a;TNS{Z(%vm&)-yCLZ|}BwP@y(O*xNo^yvbQ9;aYMm++l2dUQV6$;R)t)|BIYB zMXS@*pqIi!K6R~ff)>L3f;jesXq?{Yo?R;0#v>unj%dFk*mKTF`2^Zk=!$bITAlT% zd5DYrw{U=@P3S}MIptOpOuV5yrkf?%*H)<|V(g5Al=k*Az$Mr)Vuwbg&375YO>5dcn}8M= z)D+iRJ6cE*WQY>viJ(me0?ge0T)715;cDOOAlN|O$Hj%CmVJ=C=|MaIGF22~Gxll% zl-W={s(e2O%hFwtBLNNSZ?;b=gWq3c$r)m8&T3c}ZfqjI1D{R=UYpimdVu`}#3|ty z*qw86!8>Mh_G)`uOUuv=ahgooQ1k@cWU9QQpr*~|^Wv~Y-75Gf;T*+kq!SBtHk16N zVxgi_qEoctP5=rA;oxD^ju+)$2WN?<7i`#|lUhRiTY#|bh)u5LC=N=pI;0V6_c7-e?~w}M3o2u2mAayp74?7X5X%_=R+zl9-c|5 z!%R1b#0QGDwz28=6Nt78ofnV3y8OvXnUr6k#V`Bs*CR3Z&-RBW%0#0O}futrR?t&W) z+fVx}ZrJ{D^TAOL0Gj1HWM2h@KvTCw%O^lL0J}b*;6-1a>L7s)`7PTY>j(b4Lcf1S zJn}QNTpc55(5pW+X?Ah=u+Jm4?Z*<|J}>aPL>@-`xb0r6y(G6JA20mY6>IE}d-n`M ziQ~L)PImUt46w7%{oger;w+=Xx^r1kiF9leQ#H%8|4}_bYYAlvDUVsJ=69?;hO~fo z?3>h8;D+uaAQ%|GwcFLkv^+R!^=Qb>q3CO(0rY=3s{7R2ZmQ1Rvb%n=&v_g#JKMU~ z0>XPn=K=LHX=>~)NP3TlT?8s^=$iLos0YEp=3@`&ua}QVqS~fY)zzNr8PDDKfgz~S zhT#}!{<1z2f`2h-bqP}sc_*si6luRg;jHu35=vAlqJ65^C`gYtv(u!^Wvj$x*^ZNi zcfW;Byyo|BM~cI*z2H2t^|c}O*J=XsF&b;=zxMU4e|p5*o_I()-M&(;Yz-U19i27Y z(X|Df4CL})qiQs^;3qIZc?D9pKFI51E1j+7My_@YU~J>42KO=XWEP-ZcJ0@MK~)Y9 zf4=tiO;mRM-T@ozcvJHnBaW3z@DJ8_@w7Y(_U_D;8GP6mZpgkPLK-G4p=~;wmm(gW z6B=AQ`X=ZNH)aRSQ+?a@r-N=DYVZFTRJkV|yDt7d8LAJc*BXirj+?!V(4_JP zUlkgWm=_qWt{i;uqp1>Y+d>-;yad<2Ju`zcNL!LORP}W=9G_b&w2Q5P|LAJMbP?Xh z@U1H*d^^K);SwUQE@?|eYYZaTj@#V)tqtJ4CmS2oF(AJZPAb=&0WIZ)s@Pj_%Ef{)l+k=XLA z~|e*f=12Kzsi)I7|5{4?nD?7bX)7}}lySOEX5fuGs*KF}CMLXL%TzGm7PKIb9= zBnDW<9Zqha{^l)ETW$k_p<%9|rBf}011qw;qY*XZK0Y}31lXOf=pPF({6M7%^c7Ds zHa(&E$BrV4fpP2g?3wL1=`ing$&3fje>R6rzgYLcSqP~<&ddxO3Xcc(>brL;2m&E5 z8co)4ia>AyszR;K*HiQqr?9KK^G)3v&JmKcXHP0}sJs&1nza*L94Nl=M(_Y|qRl@+ zd98oCW9G|Vq6zWk;=Yk;IGHKqJ~L}c3BC(aL7)HgnX>Pps@)ig{g(cueAjWB0$|f> zOIG)Rg5Hp&u@IbV7M6P<>_cYRd#e7GlZ=A zuk`x=fAGJ*8pA^vgg)}$_7|r&_A)Q)=v1Wh-|Czz;;?x^)SxC%^&J$RJxU+{E zHXg2_2dB!RRSn2l@Ra+2p6kwi1@HELXWIHJE4(m#K(_xUUHhCqk>6gxy#GH7n8ONx z{@8~tGS^VQF9e#%0M_-o@4vcUM_PW0K*IH=G+9dT<|(4MovdMS(}Zd>L3fh+I=j7Oq{_jC zg9vVWNuXZ!_$h1^1+~hG{tT$x$`TFsa7=SDzg)aKUq*wpLD$-P3Cl@}pZ@C$fn=o+ z2Obi&N3EAqjEsV`P0mi83h?Uvle7-@U+e^uyLXo^bsOaH!?A)O5IX={>>sWeK#L6b zEB#6>GB7!X`S4S*7Xsc-Fz7s!n>c{{lbKNVFRVKo(LvCXjl?7%NSLh0x8!N(ZvDSy zf&cJ%h|(tj4|(?d7w{0#Ok!%yFhB;f1nV#p3-RH3TLusv80_6!=9&*32N)1Xr;ldc zoR^0Ju&vC6p(GP9)?EZyfJmfYG)SR6$aLSwWRoD=dy+frjZb=d&TAeeQ3(YG8LpSr z?aCSlN$9|0ihVQv7WVUlXil5xIH>7B>`<=BJpe!qa5$&y_TxYe{{5{YZ~_9-SoX_k z`DJ|Stg{)Y>lp>xpIUo&#ex73%0@f|!CBy*1=}pVY0v)kfqTgv1y`i>-21)>zlr&k?5Wha-LPsiOR>9D@I_hSF)^=1)ar%O=qF-Exh zRe)^=tv$i&y(%h71tr=1{4WDA&139~%*{{|PqFg@PM|XIcREi9y)8W>BRAPJkEA5x zEk`FXd^`cqsEm&<6@5I!TU9o~V(Ng9J`P1D#=>1j=q!}2(Gy|kVf-}`WA6h;4v{ZR zsIVUj_Bd#_b&5aifcMQhJwyE}pj60&Q+s(h7vh)~e5}6$hRvPr9f>m>{QcvhibntW3gMwC=<1uXT%ke^9-;7wxMG?1C_pj;Y~bMkhPQJz ze|_KsC$$)mlhO^=)`BADlw7EQDY>kF0l0-AOs3s9)Y*cn#L+1C^Xr`4|^WtLXpZqcc1*VydE5R}wwB$z-jUaV; zV=sd{)uP8y4QP?}OOZ@v^D7JDs1Sng=)zY6lVNv-+Jm$g8YfHGRBuA1rLSw95!@s2 zU@>lXZi6P6#u0G&zu5vl!>y!8eHw)1@zL+o_k&f(Niiay1|oVe_#A;$Nfab0P|mNO zGASm8=^tpdPzH;X;QescKth7BZ>!xw&&Yrf*;?)^g2##vv!-+FpEt2@VcI}5Z+xWl zXgKTaCy>wE zxBEUW_xs`!lq2EcxfpZU$n$qMg&tiInTt~3m-c#8t_XPu3SmG6g0W3m?ZM{N-;05C z^$BP0GAvi;?b_4O9(@w}(GlP%zQDq*)!>F}ikgJL9{mIz*3x)~V!Lk&l+mcRuCP!9 zcrpWnmY*wSKZ9GA$6@!{Zy%9LctmnccCXe3J8k7>tXB?`uL#_))jO~3)DO;c*ex|@ zCJ$jSn9_o!O5VT_kI)`RC`E!&X)wj6uX@g9sn+@42Pn!{0$~)aG(-J!E+okMNEYXd zm-{^;BGTTk8LTm2~B*AR7aak1mIA8 zdf~e0>{;G32ib$v01A~@2!+2Zr)_)T$*6snf#L;vQ=c3w?xOn_OZ|pCI{(5CgT3-T!?D`tvF;I`~IMp3u2fP>Kw#wzn+g!oJ@oRnf!LubVP-qIMD6%J& z9W;Nl!0Em4_j|IPaC|koK9bOrl=}lfP^;6MIOnLURMZXh^(R`#t`w8`?PWKk-9o7A=%E26-q5p$&WGoDL zW)-<6Hc^-!JC<7!?vP9ZJXkco8R7@BYM+SDKZw<~pZgx5TPC6eX+dNLPPJ~mS}8ORH)d>lI?kX&>}r|6m35eo z+i&&vYg`3iDD*!o!Du+VF-5cAcCGwhJ|HLkZ=mB~u2p3W?ddS6PjUDb*)!VG`+iGfF)`3I> zZa6R?3?#-cUXe(E7X%8~v|IOZp-d!PuxVYp{@vtL?{koVP#o&qJ=&Lx@>PDB{Dciq z_<~|Se9$v>_>QfEQ5^UziNWRqzn}~M@2kos2t_XX{r6aAnB^2*VX2Q!4T$g+mVmAo zG7v7%&TM7H#ayKaG*j4TGS~Fci2mac7XPe zdY2a$rLuGKKw|^*$Vh>A`{FGxV?vhh3GUMV#z-hYNBsaZ)Y(L z42e*)fvk-aJeP>b4by{w@Dv5%DJ10REDF!*W>87Emg#+l#?v(@(=9~(@FD9>fTNc= z?R`U|7H=#t=SOY9R|D?jAMe`p^XKn{)uMW4pO|BK$Ub}mbT|M6fn+dS@wN1$j@=5a z>?HXwLMYFLyeDJll!V9hZP1sm&y7dq7CHeJZf~oI$@jE=Ww<_^_c~M-F2A)U?J>|6 zqHY^>W*6Tvh`FKqI9Qv~ov}MW0T*^~YDOSqFm;9ORhQkr0&HEr&XmY;5%KS1P}O0g+b+h^_PlD{5+*3xbB2b%tyO7aN?Qv%xX0 z4SKZY7_qJ4(aZ1Ul2F4nOS6P?81;>(}p%q$Z)y zWMy?>^#ql)_5Z^41|KrwXEhY_$frWj<}V)j{4$lVCN!JXt8%)#q z%xJu$XIz7aT+GXTd3a*pA3B>Cdaw6(wbsI1f=P^Ds4OAz!K@I|!=;4^u9rEqo*m2g8t;&sRD5uVkw)f*AFb($s0P{d! zD8SDV-#m3-zsJJ;8B5tGqqZB_`#h@7Q#x(e$$|nA_K6^qWmxA|7l^9H&2MV?%Sijg6~dpXIGDAQ#K~h)#S-l>kahPUh4W0m8nD;--u~GH<@}`y8Y_owg3i#N^j5@nK_@n@E1wGR?i#%3 zrgib?0#@V*JPA}*k=ZG1zOHu)29XgWFhMToQ8>j)Yp3=h4#+=5CC&pE+7&QjvdFL&IPI4Eh(9Q(}$u^tk18>pz#7 zF98t{tW5alNDyadf5biVwwlvL36PZKVR^mNaFR;>BJB>+o=b}yr}rx<+2V(|y7)UC zKtM}r)vUBbXGG`WVo zKH$f4on%exd3n~1D*h^0Iz6K zbNegAegI;Miav2pw~Yi4QDsnIKxYhqC1G#*BUplORI8? zuVWa=7-g#qmeiyv`^}q=uKzHXZOqBHCNBz!VcU$~!8`FpEvC{gsi?FUj5#UMgC@T8k^}6tO*bFp$;1qE-Y+XEw z4w}Wq-OA9fltZUZB4{Cu=J+Vb2Sv9Ng6?*f-yIiMEeJ1Y^0+Eops(He<%yZmo zjXh0hr3nXtRQknBl9I7YEp)^O&DpM8me^PrDc{)>xD$4$dVWy`me=}bZ5j*#CPKJ* z_$lkJY+Iy$V7?6+P(_XsMhs(9?)avg4_Qs5Gp{8z3`Ir|n;v^AP_{ELG`*lcd|30o zVjHN&V{>NSwZ9T$6joMluXY%y56KIr6%;H?1*u!{Snus%@DB%-b3E1`y3~DF1K{Ga zCoi&enD?|4cQ2!2B&fO|uD-sP+qvVJ1Z;Lr^x2Q&)oMuV#>rIo+VtqJMD4e#on_+- z45yN>Wn)Y0geqx|Iekq{%0)3+uAqTB?>QCsm6X4x!pbH9z}m`+6lyY}s^9iKQy->% zkjGf0XmF_ur`zWtDe29i`g{MR%6jnWPnfV^Z{uW%2x+SuS-5Y z(oh`HC?e{P(q7{k8C6ZAX#vy%x+-BZP?jvz#&16bHzWW&2h<`Z^fV8j1+7KUeCp$q zTC$N+V#n#_YXF1av{^+!LR9`T){Bt7%|GCtCLf~!kJKNB!x~2e%ahUMUTDYg0yY=( z-3ZK_oT5v&s9!@|n-+;!PTyoO^?eCBjgk*lJc;0feN2dd=rbU8!;rJ#0e=#J`RN>K zTGO65azAJoQl=B)d?@KSi{4{t!b1}qEP_lRXw)`uuH*UF#7QBeLdE7EXhXtt5*iZ2 z8VZu>y_;l8Lb_SH-%HD#U#b^AfO!G)OH*BWQIU}pAtf7e{jKIOGoXsxBX#Ti8-9m4 zJ+r1S=d|r#KT3Q4?j673&SZ#lH=|&v&-7hBku~)@wW%5`%Aw!S@SbUqE6s)7Vz{11 zV`bAGkm_3v#UGR9*=BNHAGS&WbUVH80b&b1j*25tj&EN04~PSHp@Ki#AC?`mko|Ms9;22KdE!BE2KyIN^hY5(-c{K*Zbn^#J+w{6$ z?sKLkh^BzEH42P%aAF^Xk^zhafyDPZ)bYWtpT3nD@H+I_zS(LKTzJY*F@o**wlAFL z=pq1sww803;XXoq;2}l>$n1V+{OyKfF*XGC^?*dyRB!tGK-DF7G-*U-JwRiJXaLI$ zK0qcep^H7c=Nn~eZLDTU*XJsvxmSX$=$EJ)Ya=L72T)db!xS>JCgAVw`w#bdV1 zx*%)l$($v~HTOWg|A|sq>lTMV zx-M}Prp;OkUz)5>b6z6+AW$geP_nslpjO?9@R)0HSu8~`1W1+n;` zNP$8;I@0Ugk>+y{bxU|iR?uJWJo*k$fa?*v8z(`hdpvD`gpDn+AyuwSlN;p|J$Zuj zhTE9~ngOOchci6^5s%`IQGfQMjb{JVpmf%kO4PK8 zoQm=yV)ys0Xp*N$I80}R#9!$OFU(d3EzHvs%6H@+Qpr;9KN!UF@Hv8Wjq*nMGnt^8 zhfTBtH%OjHJ~Y0zx&6_8w&!&HcE4S~)?&|i0fHdzS`_^74yiaOg1$TKj^M((Qto{R z(Z9MgxuWm5NpSYTJ6Em!$I-u%h$1-fPV+GCe)O;Z;!77Mrr}$0e{FVgR18#5cpY<3 z-7z(*7RPm08os#*JN|RRl_qv+u39B+@z}|oBQ_dA8L8BV4h3%XUeLw!=`?I3c5#YR zh>&)wR##UinqRvIT9EQ<4s2Yh5w9r;&ZN2s`?irG;o|UO-V>Yihb3lo%4=sOY>lvv zjvUhSjsZ%>%|f%MavtO})08;xMd8J}Dn8JTTIoJbn`0+*fn5SHr-3Z2&LS?o7VY)j z({uxKbN)wngO`bjTSYBqO&0Foy&GVdW0e`6J2?n z5c~M8Esik7%ZTMZxI_&vD<3F|_0RLvA7d37)8D+$K|A9my|l1UfU)7#u}pmT?p?N% zgu9S>vG~dgX;&ajXfVj35fZ%D*VpIXMvMp(6lvlhrua}eY0FQNn5xkbj`JH}d>vDc zcYR}i_?AG?MMRHQM+9!n8NNG-MiWJr=@>uRuta$^r(%d0S~<_$IM;aRXdu7pJyJ=y z_k|eV`qoEH(O-Y~J@#c&-{W+N$x7Ylt@y!!0uiN_-+jdkX zoBaNGSO=34xh~W;6y19>Ru`U7Qj)C%lg~GF3<^_AW{<9r&NX+&;<&1ytHD>LSSO{; zq$hc7Y>XzNdqx&OHVILgQVy$+SnV{U;LBOFI(zhAZEO&5s;&9}ms=&wKrcNhJ6RQo z)KdKgDy%hlm&TuLKIGZVEoviIOtF6M`wYkI-30^t-~-3{J-t2KF#Z)eoKC^-LPBzk zD|G4#=fb~p5hFd<;KtjwjAf@N=M5T6^eB7KRr%hPllxeRk6&YK(&9f9tz7chE4fV{ zmIKC3Awq9#xvhIObqhmvZ~X;^ZgwNBq|;E*J4IaLrSC*Y%0yx!f66pWwpd@#ughOc zwQeo6?mgv{WmUw&%FiaZG+y^Q&16&b6$N??jHLTdN`9@WyJumsbW+zBdCz{_6+r~6 zCM@-5?$N1LugQi*B~`yNY&@OnlAJ0f*><5`D6OhWJa(=pr6#X0CY*^WRVXJXr|WIT zz1P$|(M8TH9k@SsHEmL^N_rN~zRR%RIp(FHte83@aNcrrB&4-i<#L|>&3^yEuFfQz zH0~>fnz>usTh1-p4syUQfVf#fMJ4`d$jxeL*)weCqq1soU8PT;FDWiHRh{{+M?#g( zUD(XUW66p%OBx!&r6d_YT-nTQ>FG%>FF)aZBy5sj!#VSsZ2aBVEomAuN%IR~rKL#k zwpYYNga3o);P(g)c5q06N(iQyTkCx+mb@cV7K0jElAa4v zQm<@^s-ml_hYLyfekApZZ#j4K1_R-_8paAA+kXtCD23DF0l2YdmRV!YJU6KMu~Va#TNu+Uetk z*O%q{8;*NbCQFP7e}K;y5Dahpu90k#*Ddhp_a88OG3X2hiBN^q(wk6jRy#giIo#Y_e(MO1W(*1Ie?-xw*p1!OBPmhbdw|G)A|BOE2 z8m2J;n9D`j@6Re^uR2#;@-@d*knQ|6DwD%$`8ydzL_~%ZltR1a#h=#oE3Q|2O&v?> z7u=C%U=@mUy5IS=j=iN(yISo6+v!^h7+@#JbzSaWZV0{q(%VztBH8V_2Xx5+?ZsSF zd`G1zmyPwDx~K=qC&RTlN$VoD*w{y@!=Ie&D41N?@!&QMoTKA0GJEcuzq7sE5xvx< zD%dw-XztJhTTf+`*o03_9z@WJpo8xUcpK~Vwi8BkVX||Sy>^RbN?axvcx=8cuB^0v zo47kVIvN{W+ZV`EocAE`LDY#ul$1S@o0sHd)t}Jc)Gf&pDt2IH$)9Q`L0-2k1Uevy zYWb5W(bQGW0Ouy1^@alcK?aJ02j6Rn-d!H}_Sk;X^Ewgn467u+MVvT{eSEw$PQw|R z)-ou1$q{qVyU0G9rAARD>Cs%W>GQZ$L+LKXdqpWT-Z<~s_a3OYvCR}M=JIZ5u`kAX z1}?HYzMs_R)U^s9HHo#G)p%y|Y=)N%Y^Ad1715+0+&i$B^z3b&-Ga0VRVjCHLJ z-PM`xbvS>vL)W59F{L~G{sFup)d&T}aO1{tQ?rcK={h-M=SbMTo5ogPdky@=Tw&Fd zrtzvfM_hcl^$!7K3-6_|qPe^`WfO+5=pXkRw|kvEduO{~#>Rv6W+Q34MmL-UB1P%@ z8Q^YfSHF@UEIT3DROlVjiqVsoT0H(^-8LzEIwm)EPOdSs;^;;0I{~L;8>G`X{8=99 z%(bWXIvk=ong}${Uh5_Auiw7<_ZqiPUeaJId4HSPom?R;{Wku-^;%;S`TKSSO*XTN zgHN*By|c+j`{M5&3QV<#7AI@}_W14x2-7AB|=DJ;D9RK-cu z!5ssSfgTHSJ&tN5_OS(f%eyNEg>c1MRvC`4@!esQh!*WFvbhK3gsNAvtqn|WqoY=< zo&yr&^^J+Uj&Z})(hnCGZDK(4O3I~t_oZitgNk-rt!LdMfB+* zI;z+|%G~~VEqEIZQrdBmU@ul-;oYI69|-(6aQ^>U{P@2JJ^$M;eY1;Oi0K>)DWGFR Pe*?+uvSO*%G@t$-l@9Qp literal 0 HcmV?d00001 diff --git a/torchrec/distributed/benchmark/benchmark_zch/models/__init__.py b/torchrec/distributed/benchmark/benchmark_zch/models/__init__.py new file mode 100644 index 000000000..a1f67f2ac --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/models/__init__.py @@ -0,0 +1,6 @@ +from .apply_optimizers import ( + apply_dense_optimizers, + apply_sparse_optimizers, + combine_optimizers, +) +from .make_model import make_model diff --git a/torchrec/distributed/benchmark/benchmark_zch/models/apply_optimizers.py b/torchrec/distributed/benchmark/benchmark_zch/models/apply_optimizers.py new file mode 100644 index 000000000..091e41d4c --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/models/apply_optimizers.py @@ -0,0 +1,93 @@ +import argparse +import os + +from typing import Callable, List, Union + +import torch +import torch.nn as nn +import torchrec +import yaml +from torch.distributed._shard.sharded_tensor import ShardedTensor +from torchrec.distributed.benchmark.benchmark_zch.benchmark_zch_utils import ( + get_module_from_instance, +) +from torchrec.optim.apply_optimizer_in_backward import apply_optimizer_in_backward +from torchrec.optim.keyed import CombinedOptimizer, KeyedOptimizerWrapper +from torchrec.optim.optimizers import in_backward_optimizer_filter + + +def apply_sparse_optimizers(model: nn.Module, args: argparse.Namespace) -> None: + embedding_optimizer = None + if args.sparse_optim == "adagrad": + embedding_optimizer = torch.optim.Adagrad + elif args.sparse_optim == "sgd": + embedding_optimizer = torch.optim.SGD + elif args.sparse_optim == "rowwiseadagrad": + embedding_optimizer = torchrec.optim.RowWiseAdagrad + else: + raise NotImplementedError("Optimizer not supported") + optimizer_kwargs = {"lr": args.learning_rate} + if args.sparse_optim == "adagrad": + optimizer_kwargs["eps"] = args.eps + elif args.sparse_optim == "rowwiseadagrad": + optimizer_kwargs["eps"] = args.eps + optimizer_kwargs["lr"] = args.learning_rate + optimizer_kwargs["beta1"] = args.beta1 + optimizer_kwargs["beta2"] = args.beta2 + optimizer_kwargs["weight_decay"] = args.weight_decay + # get model's embedding module's attribute path + model_config_file_path = os.path.join( + os.path.dirname(__file__), "configs", f"{args.model_name}.yaml" + ) + with open(model_config_file_path, "r") as f: + model_config = yaml.safe_load(f) + embedding_module_attribute_path = model_config["embedding_module_attribute_path"] + apply_optimizer_in_backward( + embedding_optimizer, + get_module_from_instance(model, embedding_module_attribute_path).parameters(), + optimizer_kwargs, + ) + + +def apply_dense_optimizers( + model: nn.Module, args: argparse.Namespace +) -> KeyedOptimizerWrapper: + def optimizer_with_params() -> ( + Callable[[List[Union[torch.Tensor, ShardedTensor]]], torch.optim.Optimizer] + ): + if args.dense_optim == "adagrad": + return lambda params: torch.optim.Adagrad( + params, lr=args.learning_rate, eps=args.eps + ) + elif args.dense_optim == "sgd": + return lambda params: torch.optim.SGD(params, lr=args.learning_rate) + elif args.dense_optim == "adam": + return lambda params: torch.optim.Adam( + params, lr=args.learning_rate, eps=args.eps, betas=(0.95, 0.999) + ) + else: + raise NotImplementedError("Optimizer not supported") + + # exclude hash identity tables + dense_optimizer_parameters_dict = dict( + in_backward_optimizer_filter(model.named_parameters()) + ) + keys_to_remove = [] + for key in dense_optimizer_parameters_dict.keys(): + if "hash_zch_identities" in key: + keys_to_remove.append(key) + for key in keys_to_remove: + del dense_optimizer_parameters_dict[key] + + dense_optimizer = KeyedOptimizerWrapper( + dense_optimizer_parameters_dict, + optimizer_with_params(), + ) + return dense_optimizer + + +def combine_optimizers( + sparse_optimizers: Union[KeyedOptimizerWrapper, CombinedOptimizer], + dense_optimizers: KeyedOptimizerWrapper, +) -> torch.optim.Optimizer: + return CombinedOptimizer([sparse_optimizers, dense_optimizers]) diff --git a/torchrec/distributed/benchmark/benchmark_zch/models/configs/dlrmv2.yaml b/torchrec/distributed/benchmark/benchmark_zch/models/configs/dlrmv2.yaml new file mode 100644 index 000000000..3cb83d486 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/models/configs/dlrmv2.yaml @@ -0,0 +1,39 @@ +dense_arch_layer_sizes: + - 512 + - 256 + - 64 +over_arch_layer_sizes: + - 512 + - 512 + - 256 + - 1 +embedding_dim: 64 +num_embeddings_per_feature: + cat_0: 100000 + cat_1: 100000 + cat_2: 100000 + cat_3: 100000 + cat_4: 100000 + cat_5: 100000 + cat_6: 100000 + cat_7: 100000 + cat_8: 100000 + cat_9: 100000 + cat_10: 100000 + cat_11: 100000 + cat_12: 100000 + cat_13: 100000 + cat_14: 100000 + cat_15: 100000 + cat_16: 100000 + cat_17: 100000 + cat_18: 100000 + cat_19: 100000 + cat_20: 100000 + cat_21: 100000 + cat_22: 100000 + cat_23: 100000 + cat_24: 100000 + cat_25: 100000 +embedding_module_attribute_path: "dlrm.sparse_arch.embedding_bag_collection" # the attribute path after model +managed_collision_module_attribute_path: "module.dlrm.sparse_arch.embedding_bag_collection.mc_embedding_bag_collection._managed_collision_collection._managed_collision_modules" # the attribute path of managed collision module after model diff --git a/torchrec/distributed/benchmark/benchmark_zch/models/configs/dlrmv3.yaml b/torchrec/distributed/benchmark/benchmark_zch/models/configs/dlrmv3.yaml new file mode 100644 index 000000000..22e3078a5 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/models/configs/dlrmv3.yaml @@ -0,0 +1,12 @@ +hstu_num_heads: 4 # 1 for hstu, 2 for hstu-large +hstu_attn_num_layers: 3 # 2 for hstu, 8 for hstu-large +hstu_embedding_table_dim: 256 +hstu_transducer_embedding_dim: 512 +hstu_attn_linear_dim: 128 +hstu_attn_qk_dim: 128 +hstu_input_dropout_ratio: 0.2 +hstu_linear_dropout_rate: 0.1 +causal_multitask_weights: 0.2 +num_embeddings: 100000 +embedding_module_attribute_path: "dlrm_hstu._embedding_collection" # the attribute path of embedding module after model +managed_collision_module_attribute_path: "module.dlrm_hstu._embedding_collection.mc_embedding_collection._managed_collision_collection._managed_collision_modules" # the attribute path of managed collision module after model diff --git a/torchrec/distributed/benchmark/benchmark_zch/models/make_model.py b/torchrec/distributed/benchmark/benchmark_zch/models/make_model.py new file mode 100644 index 000000000..aa24621fd --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/models/make_model.py @@ -0,0 +1,60 @@ +import argparse +import os +from typing import Any, Dict, Tuple + +import torch + +import torch.nn as nn +import yaml + +from .models import make_model_dlrmv2, make_model_dlrmv3 + + +def make_model( + model_name: str, args: argparse.Namespace, device: torch.device +) -> Tuple[nn.Module, Dict[str, Any]]: + if model_name == "dlrmv2": + # get model configuration from yaml file + with open( + os.path.join(os.path.dirname(__file__), "configs", "dlrmv2.yaml"), "r" + ) as f: + configs = yaml.safe_load(f) + # get dataset configuration from yaml file + with open( + os.path.join( + os.path.dirname(__file__), + "..", + "data", + "configs", + f"{args.dataset_name}.yaml", + ), + "r", + ) as f: + dataset_config = yaml.safe_load(f) + # combine model and dataset configurations + configs.update(dataset_config) + # get the model + return make_model_dlrmv2(args, configs, device), configs + elif model_name == "dlrmv3": + with open( + os.path.join(os.path.dirname(__file__), "configs", "dlrmv3.yaml"), "r" + ) as f: + configs = yaml.safe_load(f) + # get dataset configuration from yaml file + with open( + os.path.join( + os.path.dirname(__file__), + "..", + "data", + "configs", + f"{args.dataset_name}.yaml", + ), + "r", + ) as f: + dataset_config = yaml.safe_load(f) + # combine model and dataset configurations + configs.update(dataset_config) + # get the model + return make_model_dlrmv3(args, configs, device), configs + else: + raise NotImplementedError(f"Model {model_name} is not implemented.") diff --git a/torchrec/distributed/benchmark/benchmark_zch/models/models/__init__.py b/torchrec/distributed/benchmark/benchmark_zch/models/models/__init__.py new file mode 100644 index 000000000..cc8cb2b62 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/models/models/__init__.py @@ -0,0 +1,2 @@ +from .dlrmv2 import make_model_dlrmv2 +from .dlrmv3 import make_model_dlrmv3 diff --git a/torchrec/distributed/benchmark/benchmark_zch/models/models/dlrmv2.py b/torchrec/distributed/benchmark/benchmark_zch/models/models/dlrmv2.py new file mode 100644 index 000000000..c649dbb8c --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/models/models/dlrmv2.py @@ -0,0 +1,97 @@ +import argparse + +from typing import Any, Dict, List, Optional, Tuple + +import torch +import torch.nn as nn +from pyre_extensions import none_throws + +from torchrec.datasets.criteo import DEFAULT_CAT_NAMES, DEFAULT_INT_NAMES + +from torchrec.datasets.utils import Batch + +from torchrec.distributed.comm import get_local_size +from torchrec.models.dlrm import DLRM, DLRMTrain +from torchrec.modules.embedding_configs import EmbeddingBagConfig +from torchrec.modules.embedding_modules import EmbeddingBagCollection +from torchrec.modules.mc_adapter import McEmbeddingBagCollectionAdapter + + +class DLRMv2(nn.Module): + def __init__( + self, + embedding_bag_collection: EmbeddingBagCollection, + dense_in_features: int, + dense_arch_layer_sizes: List[int], + over_arch_layer_sizes: List[int], + dense_device: Optional[torch.device] = None, + ) -> None: + super().__init__() + self.dlrm = DLRM( + embedding_bag_collection=embedding_bag_collection, + dense_in_features=dense_in_features, + dense_arch_layer_sizes=dense_arch_layer_sizes, + over_arch_layer_sizes=over_arch_layer_sizes, + dense_device=dense_device, + ) + self.train_model = DLRMTrain(self.dlrm) + + def forward( + self, batch: Batch + ) -> Tuple[ + torch.Tensor, Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor] + ]: + + loss, (loss_values, pred_logits, labels) = self.train_model(batch) + dummy_weights = torch.ones_like(pred_logits) + return loss, (loss_values, pred_logits, labels, dummy_weights) + + def eval(self) -> None: + self.train_model.eval() + + +def make_model_dlrmv2( + args: argparse.Namespace, configs: Dict[str, Any], device: torch.device +) -> nn.Module: + ebc_configs = [ + EmbeddingBagConfig( + name=f"t_{feature_name}", + embedding_dim=configs["embedding_dim"], + num_embeddings=( + none_throws(configs["num_embeddings_per_feature"])[feature_idx] + if args.num_embeddings is None + else args.num_embeddings + ), + feature_names=[feature_name], + ) + for feature_idx, feature_name in enumerate(DEFAULT_CAT_NAMES) + ] + + if args.zch_method == "" or args.zch_method is None: + ebc = EmbeddingBagCollection(tables=ebc_configs, device=torch.device("meta")) + elif args.zch_method == "mpzch": + ebc = ( + McEmbeddingBagCollectionAdapter( # TODO: add switch for other ZCH or no ZCH + tables=ebc_configs, + input_hash_size=args.input_hash_size, + device=torch.device("meta"), + world_size=get_local_size(), + use_mpzch=True, + mpzch_num_buckets=args.num_buckets, + ) + ) + else: + raise NotImplementedError(f"ZCH method {args.zch_method} is not supported yet.") + + dlrm_model = DLRMv2( + # pyre-ignore [6] # NOTE: Pyre reports that DLRM model's _embedding_bag_collection is EmbeddingBagCollection, but here we assign it with an EmbeddingBagCollectionAdapter. + # This is because we want to implement managed collision functions without changing the DLRM class. The EmbeddingBagCollectionAdapter will simulate all the + # APIs for EmbeddingBagCollection, and we can use it to replace the EmbeddingBagCollection in DLRM for managed collision functions. + embedding_bag_collection=ebc, + dense_in_features=len(DEFAULT_INT_NAMES), + dense_arch_layer_sizes=[int(x) for x in configs["dense_arch_layer_sizes"]], + over_arch_layer_sizes=[int(x) for x in configs["over_arch_layer_sizes"]], + dense_device=device, + ) + + return dlrm_model diff --git a/torchrec/distributed/benchmark/benchmark_zch/models/models/dlrmv3.py b/torchrec/distributed/benchmark/benchmark_zch/models/models/dlrmv3.py new file mode 100644 index 000000000..309c21602 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/models/models/dlrmv3.py @@ -0,0 +1,193 @@ +import argparse +from dataclasses import dataclass +from typing import Any, Dict, List, Optional, Tuple, Union + +import torch +import torch.nn as nn +from generative_recommenders.common import HammerKernel +from generative_recommenders.modules.dlrm_hstu import DlrmHSTU, DlrmHSTUConfig +from generative_recommenders.modules.multitask_module import ( + MultitaskTaskType, + TaskConfig, +) +from torchrec.distributed.comm import get_local_size +from torchrec.modules.embedding_configs import EmbeddingConfig +from torchrec.modules.mc_adapter import McEmbeddingCollectionAdapter +from torchrec.sparse.jagged_tensor import KeyedJaggedTensor +from torchrec.streamable import Pipelineable + + +# Dummy batch data class as an example of features +@dataclass +class Batch(Pipelineable): + uih_features: KeyedJaggedTensor + candidates_features: KeyedJaggedTensor + + +class DLRMv3(nn.Module): + def __init__( + self, + hstu_configs: DlrmHSTUConfig, + embedding_tables: Dict[str, EmbeddingConfig], + is_inference: bool = False, + ) -> None: + super().__init__() + self.dlrm_hstu = DlrmHSTU( + hstu_configs=hstu_configs, + embedding_tables=embedding_tables, + is_inference=is_inference, + ) + self.eval_flag = False + self.table_configs: List[EmbeddingConfig] = list(embedding_tables.values()) + + def forward( + self, + batch: Batch, + ) -> Tuple[ + torch.Tensor, + Tuple[ + torch.Tensor, + torch.Tensor, + torch.Tensor, + torch.Tensor, + ], + ]: + ( + _, + __, + aux_losses, + mt_target_preds, + mt_target_labels, + mt_target_weights, + ) = self.dlrm_hstu( + uih_features=batch.uih_features, + candidates_features=batch.candidates_features, + ) + # convert labels to int64 and squeeze to [batch_size, ] + mt_target_labels = mt_target_labels.squeeze().to(torch.int64) + # convert the predictions to [batch_size, ] + mt_target_preds = mt_target_preds.squeeze() + # return the loss and the predictions + # pyre-ignore[7] # NOTE: aux_losses.values() returns a list of tensors, and taking a sum over tensor list returns a tensor. + return sum(aux_losses.values()), ( + aux_losses, + mt_target_preds.detach(), + mt_target_labels.detach(), + mt_target_weights.detach(), + ) + + def eval(self) -> None: + self.dlrm_hstu.eval() + + +def make_model_dlrmv3( + args: argparse.Namespace, configs: Dict[str, Any], device: torch.device +) -> nn.Module: + + hstu_config = DlrmHSTUConfig( + hstu_num_heads=configs["hstu_num_heads"], + hstu_attn_linear_dim=configs["hstu_attn_linear_dim"], + hstu_attn_qk_dim=configs["hstu_attn_qk_dim"], + hstu_attn_num_layers=configs["hstu_attn_num_layers"], + hstu_embedding_table_dim=configs["hstu_embedding_table_dim"], + hstu_transducer_embedding_dim=configs["hstu_transducer_embedding_dim"], + hstu_group_norm=True, + hstu_input_dropout_ratio=configs["hstu_input_dropout_ratio"], + hstu_linear_dropout_rate=configs["hstu_linear_dropout_rate"], + causal_multitask_weights=configs["causal_multitask_weights"], + ) + + hstu_config.user_embedding_feature_names = configs["user_embedding_feature_names"] + hstu_config.item_embedding_feature_names = configs["item_embedding_feature_names"] + hstu_config.uih_post_id_feature_name = configs["uih_post_id_feature_name"] + hstu_config.uih_weight_feature_name = ( + configs["uih_weight_feature_name"] + if "uih_weight_feature_name" in configs + else None + ) + hstu_config.uih_action_time_feature_name = configs["uih_action_time_feature_name"] + hstu_config.candidates_weight_feature_name = configs[ + "candidates_weight_feature_name" + ] + hstu_config.candidates_watchtime_feature_name = configs[ + "candidates_watchtime_feature_name" + ] + hstu_config.candidates_querytime_feature_name = configs[ + "candidates_querytime_feature_name" + ] + hstu_config.contextual_feature_to_min_uih_length = ( + configs["contextual_feature_to_min_uih_length"] + if "contextual_feature_to_min_uih_length" in configs + else None + ) + hstu_config.merge_uih_candidate_feature_mapping = configs[ + "merge_uih_candidate_feature_mapping" + ] + hstu_config.hstu_uih_feature_names = configs["hstu_uih_feature_names"] + hstu_config.hstu_candidate_feature_names = configs["hstu_candidate_feature_names"] + task_type_list = [] + for i in range(len(configs["multitask_configs"])): + if configs["multitask_configs"][i]["task_type"] == "regression": + task_type_list.append(MultitaskTaskType.REGRESSION) + elif configs["multitask_configs"][i]["task_type"] == "classification": + task_type_list.append(MultitaskTaskType.BINARY_CLASSIFICATION) + else: + raise ValueError( + f"Invalid task type {configs['multitask_configs'][i]['task_type']}, expected regression or classification" + ) + hstu_config.multitask_configs = [ + TaskConfig( + task_name=configs["multitask_configs"][i]["task_name"], + task_weight=configs["multitask_configs"][i]["task_weight"], + task_type=task_type_list[i], + ) + for i in range(len(configs["multitask_configs"])) + ] + hstu_config.action_weights = ( + configs["action_weights"] if "action_weights" in configs else None + ) + + table_config = {} + for i in range(len(configs["user_embedding_feature_names"])): + if configs["user_embedding_feature_names"][i] == "movie_id": + feature_names = ["movie_id", "item_movie_id"] + elif configs["user_embedding_feature_names"][i] == "video_id": + feature_names = ["video_id", "item_video_id"] + else: + feature_names = [configs["user_embedding_feature_names"][i]] + table_config[configs["user_embedding_feature_names"][i]] = EmbeddingConfig( + name=configs["user_embedding_feature_names"][i], + embedding_dim=configs["hstu_embedding_table_dim"], + num_embeddings=( + args.num_embeddings + if args.num_embeddings + else configs["num_embeddings"] + ), + feature_names=feature_names, + ) + + model = DLRMv3( + hstu_configs=hstu_config, + embedding_tables=table_config, + is_inference=False, + ) + model.dlrm_hstu.recursive_setattr("_hammer_kernel", HammerKernel.PYTORCH) + + if args.zch_method == "mpzch": + ec_adapter = ( + McEmbeddingCollectionAdapter( # TODO: add switch for other ZCH or no ZCH + tables=list(table_config.values()), + input_hash_size=args.input_hash_size, + device=device, + world_size=get_local_size(), + zch_method="mpzch", + mpzch_num_buckets=args.num_buckets, + mpzch_max_probe=args.max_probe, + ) + ) + # pyre-ignore [8] # NOTE: Pyre reports that DLRM_HSTU's _embedding_collection is EmbeddingCollection, but here we assign it with an EmbeddingCollectionAdapter. + # This is because we want to implement managed collision functions without changing the DLRM_HSTU class. The EmbeddingCollectionAdapter will simulate all the + # APIs for EmbeddingCollection, and we can use it to replace the EmbeddingCollection in DLRM_HSTU for managed collision functions. + model.dlrm_hstu._embedding_collection = ec_adapter + + return model diff --git a/torchrec/distributed/benchmark/benchmark_zch/models/shard_model.py b/torchrec/distributed/benchmark/benchmark_zch/models/shard_model.py new file mode 100644 index 000000000..7ccc0158d --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/models/shard_model.py @@ -0,0 +1,48 @@ +import argparse +from typing import cast + +import torch +import torch.distributed as dist +import torch.nn as nn +from torchrec.distributed.comm import get_local_size +from torchrec.distributed.mc_modules import ManagedCollisionCollectionSharder +from torchrec.distributed.model_parallel import ( + DistributedModelParallel, + get_default_sharders, +) +from torchrec.distributed.planner import EmbeddingShardingPlanner, Topology +from torchrec.distributed.planner.storage_reservations import ( + HeuristicalStorageReservation, +) +from torchrec.distributed.types import ModuleSharder + + +def shard_model( + model: nn.Module, + device: torch.device, + args: argparse.Namespace, +) -> DistributedModelParallel: + # shard the model + planner = EmbeddingShardingPlanner( + topology=Topology( + local_world_size=get_local_size(), + world_size=dist.get_world_size(), + compute_device=device.type, + ), + batch_size=args.batch_size, + # If experience OOM, increase the percentage. see + # https://pytorch.org/torchrec/torchrec.distributed.planner.html#torchrec.distributed.planner.storage_reservations.HeuristicalStorageReservation + storage_reservation=HeuristicalStorageReservation(percentage=0.05), + ) + + sharders = get_default_sharders() + sharders.append(cast(ModuleSharder[nn.Module], ManagedCollisionCollectionSharder())) + + plan = planner.collective_plan(model, sharders, dist.GroupMember.WORLD) + + model = DistributedModelParallel( + module=model, + device=device, + plan=plan, + ) + return model diff --git a/torchrec/distributed/benchmark/benchmark_zch/plots/plot_dataset_input_stats.ipynb b/torchrec/distributed/benchmark/benchmark_zch/plots/plot_dataset_input_stats.ipynb new file mode 100644 index 000000000..91e221ab6 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/plots/plot_dataset_input_stats.ipynb @@ -0,0 +1,349 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import matplotlib.pyplot as plt\n", + "import json\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "figure_folder = \"/home/lizhouyu/home/lizhouyu/zch_results_figures\"\n", + "os.makedirs(figure_folder, exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "zch_stats_file_folder = \"/home/lizhouyu/home/lizhouyu/zch_results/result_tbsize_10000_nonzch_dlrmv3_kuairand\"\n", + "zch_ds_stats_filename_list = [x for x in os.listdir(zch_stats_file_folder) if x.endswith(\".json\") and x.startswith(\"dataset_stats\")]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "output": { + "id": 1251793066474509, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{1: {'user_id': {'num_unique_feature_values': 185, 'feature_value_distribution': {'0': 185}, 'feature_query_distribution': {'0': 185}}, 'user_active_degree': {'num_unique_feature_values': 5, 'feature_value_distribution': {'0': 5}, 'feature_query_distribution': {'0': 185}}, 'follow_user_num_range': {'num_unique_feature_values': 8, 'feature_value_distribution': {'0': 8}, 'feature_query_distribution': {'0': 185}}, 'fans_user_num_range': {'num_unique_feature_values': 6, 'feature_value_distribution': {'0': 6}, 'feature_query_distribution': {'0': 185}}, 'friend_user_num_range': {'num_unique_feature_values': 7, 'feature_value_distribution': {'0': 7}, 'feature_query_distribution': {'0': 185}}, 'register_days_range': {'num_unique_feature_values': 7, 'feature_value_distribution': {'0': 7}, 'feature_query_distribution': {'0': 185}}, 'video_id': {'num_unique_feature_values': 25476, 'feature_value_distribution': {'0': 6493, '1': 6417, '2': 6374, '3': 6192}, 'feature_query_distribution': {'1': 8545, '0': 8691, '2': 8490, '3': 8314}}, 'action_timestamp': {'num_unique_feature_values': 6349, 'feature_value_distribution': {'2': 1606, '1': 1619, '3': 1597, '0': 1527}, 'feature_query_distribution': {'3': 8489, '2': 8697, '0': 8189, '1': 8665}}, 'action_weight': {'num_unique_feature_values': 44, 'feature_value_distribution': {'0': 44}, 'feature_query_distribution': {'0': 34040}}, 'watch_time': {'num_unique_feature_values': 18843, 'feature_value_distribution': {'0': 11579, '1': 3834, '2': 2086, '3': 1344}, 'feature_query_distribution': {'0': 26309, '3': 1387, '2': 2171, '1': 4173}}, 'item_video_id': {'num_unique_feature_values': 1788, 'feature_value_distribution': {'3': 435, '2': 447, '0': 437, '1': 469}, 'feature_query_distribution': {'3': 447, '1': 485, '0': 458, '2': 460}}, 'item_action_weight': {'num_unique_feature_values': 15, 'feature_value_distribution': {'0': 15}, 'feature_query_distribution': {'0': 1850}}, 'item_target_watchtime': {'num_unique_feature_values': 1516, 'feature_value_distribution': {'0': 1107, '1': 197, '3': 88, '2': 124}, 'feature_query_distribution': {'0': 1439, '1': 198, '2': 125, '3': 88}}, 'item_query_time': {'num_unique_feature_values': 180, 'feature_value_distribution': {'3': 180}, 'feature_query_distribution': {'3': 1850}}}, 2: {'user_id': {'num_unique_feature_values': 185, 'feature_value_distribution': {'0': 185}, 'feature_query_distribution': {'0': 185}}, 'user_active_degree': {'num_unique_feature_values': 5, 'feature_value_distribution': {'0': 5}, 'feature_query_distribution': {'0': 185}}, 'follow_user_num_range': {'num_unique_feature_values': 8, 'feature_value_distribution': {'0': 8}, 'feature_query_distribution': {'0': 185}}, 'fans_user_num_range': {'num_unique_feature_values': 7, 'feature_value_distribution': {'0': 7}, 'feature_query_distribution': {'0': 185}}, 'friend_user_num_range': {'num_unique_feature_values': 7, 'feature_value_distribution': {'0': 7}, 'feature_query_distribution': {'0': 185}}, 'register_days_range': {'num_unique_feature_values': 6, 'feature_value_distribution': {'0': 6}, 'feature_query_distribution': {'0': 185}}, 'video_id': {'num_unique_feature_values': 25385, 'feature_value_distribution': {'0': 6481, '1': 6465, '2': 6261, '3': 6178}, 'feature_query_distribution': {'1': 8658, '0': 8686, '2': 8430, '3': 8266}}, 'action_timestamp': {'num_unique_feature_values': 6488, 'feature_value_distribution': {'2': 1616, '0': 1648, '3': 1632, '1': 1592}, 'feature_query_distribution': {'0': 8653, '1': 8327, '3': 8495, '2': 8565}}, 'action_weight': {'num_unique_feature_values': 46, 'feature_value_distribution': {'0': 46}, 'feature_query_distribution': {'0': 34040}}, 'watch_time': {'num_unique_feature_values': 17771, 'feature_value_distribution': {'0': 11731, '1': 3303, '2': 1719, '3': 1018}, 'feature_query_distribution': {'0': 27634, '3': 1041, '2': 1787, '1': 3578}}, 'item_video_id': {'num_unique_feature_values': 1804, 'feature_value_distribution': {'1': 494, '2': 449, '0': 431, '3': 430}, 'feature_query_distribution': {'1': 511, '0': 441, '2': 461, '3': 437}}, 'item_action_weight': {'num_unique_feature_values': 19, 'feature_value_distribution': {'0': 19}, 'feature_query_distribution': {'0': 1850}}, 'item_target_watchtime': {'num_unique_feature_values': 1478, 'feature_value_distribution': {'0': 1136, '1': 192, '3': 66, '2': 84}, 'feature_query_distribution': {'0': 1507, '1': 192, '3': 66, '2': 85}}, 'item_query_time': {'num_unique_feature_values': 181, 'feature_value_distribution': {'3': 181}, 'feature_query_distribution': {'3': 1850}}}, 3: {'user_id': {'num_unique_feature_values': 185, 'feature_value_distribution': {'0': 185}, 'feature_query_distribution': {'0': 185}}, 'user_active_degree': {'num_unique_feature_values': 6, 'feature_value_distribution': {'0': 6}, 'feature_query_distribution': {'0': 185}}, 'follow_user_num_range': {'num_unique_feature_values': 8, 'feature_value_distribution': {'0': 8}, 'feature_query_distribution': {'0': 185}}, 'fans_user_num_range': {'num_unique_feature_values': 6, 'feature_value_distribution': {'0': 6}, 'feature_query_distribution': {'0': 185}}, 'friend_user_num_range': {'num_unique_feature_values': 7, 'feature_value_distribution': {'0': 7}, 'feature_query_distribution': {'0': 185}}, 'register_days_range': {'num_unique_feature_values': 7, 'feature_value_distribution': {'0': 7}, 'feature_query_distribution': {'0': 185}}, 'video_id': {'num_unique_feature_values': 25342, 'feature_value_distribution': {'0': 6350, '1': 6438, '2': 6431, '3': 6123}, 'feature_query_distribution': {'0': 8509, '3': 8172, '2': 8689, '1': 8670}}, 'action_timestamp': {'num_unique_feature_values': 6309, 'feature_value_distribution': {'1': 1623, '2': 1543, '3': 1533, '0': 1610}, 'feature_query_distribution': {'2': 8511, '3': 8325, '1': 8631, '0': 8573}}, 'action_weight': {'num_unique_feature_values': 42, 'feature_value_distribution': {'0': 42}, 'feature_query_distribution': {'0': 34040}}, 'watch_time': {'num_unique_feature_values': 18795, 'feature_value_distribution': {'0': 11930, '1': 3746, '3': 1286, '2': 1833}, 'feature_query_distribution': {'1': 4105, '0': 26698, '2': 1914, '3': 1323}}, 'item_video_id': {'num_unique_feature_values': 1788, 'feature_value_distribution': {'1': 455, '0': 465, '3': 418, '2': 450}, 'feature_query_distribution': {'2': 464, '3': 425, '0': 490, '1': 471}}, 'item_action_weight': {'num_unique_feature_values': 21, 'feature_value_distribution': {'0': 21}, 'feature_query_distribution': {'0': 1850}}, 'item_target_watchtime': {'num_unique_feature_values': 1465, 'feature_value_distribution': {'0': 1097, '3': 76, '2': 97, '1': 195}, 'feature_query_distribution': {'0': 1482, '1': 195, '3': 76, '2': 97}}, 'item_query_time': {'num_unique_feature_values': 182, 'feature_value_distribution': {'3': 182}, 'feature_query_distribution': {'3': 1850}}}, 0: {'user_id': {'num_unique_feature_values': 185, 'feature_value_distribution': {'0': 185}, 'feature_query_distribution': {'0': 185}}, 'user_active_degree': {'num_unique_feature_values': 5, 'feature_value_distribution': {'0': 5}, 'feature_query_distribution': {'0': 185}}, 'follow_user_num_range': {'num_unique_feature_values': 7, 'feature_value_distribution': {'0': 7}, 'feature_query_distribution': {'0': 185}}, 'fans_user_num_range': {'num_unique_feature_values': 6, 'feature_value_distribution': {'0': 6}, 'feature_query_distribution': {'0': 185}}, 'friend_user_num_range': {'num_unique_feature_values': 7, 'feature_value_distribution': {'0': 7}, 'feature_query_distribution': {'0': 185}}, 'register_days_range': {'num_unique_feature_values': 7, 'feature_value_distribution': {'0': 7}, 'feature_query_distribution': {'0': 185}}, 'video_id': {'num_unique_feature_values': 25227, 'feature_value_distribution': {'0': 6368, '1': 6420, '2': 6330, '3': 6109}, 'feature_query_distribution': {'1': 8686, '0': 8634, '2': 8525, '3': 8195}}, 'action_timestamp': {'num_unique_feature_values': 6198, 'feature_value_distribution': {'0': 1536, '1': 1539, '3': 1527, '2': 1596}, 'feature_query_distribution': {'3': 8327, '2': 8804, '0': 8409, '1': 8500}}, 'action_weight': {'num_unique_feature_values': 45, 'feature_value_distribution': {'0': 45}, 'feature_query_distribution': {'0': 34040}}, 'watch_time': {'num_unique_feature_values': 18490, 'feature_value_distribution': {'0': 11746, '1': 3699, '3': 1187, '2': 1858}, 'feature_query_distribution': {'0': 26851, '1': 4034, '3': 1211, '2': 1944}}, 'item_video_id': {'num_unique_feature_values': 1786, 'feature_value_distribution': {'0': 420, '1': 469, '2': 449, '3': 448}, 'feature_query_distribution': {'0': 441, '2': 463, '3': 465, '1': 481}}, 'item_action_weight': {'num_unique_feature_values': 20, 'feature_value_distribution': {'0': 20}, 'feature_query_distribution': {'0': 1850}}, 'item_target_watchtime': {'num_unique_feature_values': 1538, 'feature_value_distribution': {'0': 1185, '3': 58, '2': 101, '1': 194}, 'feature_query_distribution': {'0': 1495, '1': 196, '2': 101, '3': 58}}, 'item_query_time': {'num_unique_feature_values': 183, 'feature_value_distribution': {'3': 183}, 'feature_query_distribution': {'3': 1850}}}}\n" + ] + } + ], + "source": [ + "rank_idx_ds_stats_dict = {}\n", + "for zch_ds_stats_filename in zch_ds_stats_filename_list:\n", + " rank_idx = int(zch_ds_stats_filename.split(\".\")[0].split(\"_\")[-1])\n", + " with open(os.path.join(zch_stats_file_folder, zch_ds_stats_filename), \"r\") as f:\n", + " rank_idx_ds_stats_dict[rank_idx] = json.load(f)\n", + "print(rank_idx_ds_stats_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot feature value distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "target_feature = \"user_id\"\n", + "WORLD_SIZE = 4\n", + "num_embeddings = 1000\n", + "bucket_size = num_embeddings // WORLD_SIZE" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "output": { + "id": 594752043274197, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{0: 740, 1: 0, 2: 0, 3: 0}\n" + ] + } + ], + "source": [ + "rank_num_feature_values_dict = {}\n", + "for rank_idx in range(WORLD_SIZE):\n", + " for stat_rank_idx in range(WORLD_SIZE):\n", + " if stat_rank_idx not in rank_num_feature_values_dict:\n", + " rank_num_feature_values_dict[stat_rank_idx] = 0\n", + " if str(stat_rank_idx) not in rank_idx_ds_stats_dict[rank_idx][target_feature][\"feature_value_distribution\"]:\n", + " continue\n", + " rank_num_feature_values_dict[stat_rank_idx] += rank_idx_ds_stats_dict[rank_idx][target_feature][\"feature_value_distribution\"][str(stat_rank_idx)]\n", + "print(rank_num_feature_values_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "output": { + "id": 1428419628290327, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0630 001004.403 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.404 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.405 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.405 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.408 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.409 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.410 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.411 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.414 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.415 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.416 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.418 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.420 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.420 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.421 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.422 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.425 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.426 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.427 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.427 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.432 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.432 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.433 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.435 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.437 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.437 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.438 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.439 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.476 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.477 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.477 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.478 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.509 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.510 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.510 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.511 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.515 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.515 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.516 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.517 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.521 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.521 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.522 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.523 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.527 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.527 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.528 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.529 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.534 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.535 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.535 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.537 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.553 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.554 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.554 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.555 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.621 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.622 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.622 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.624 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.626 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.627 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.628 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.628 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.632 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.632 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.633 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.634 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.637 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.638 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.639 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.639 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.642 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.643 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.643 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.644 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.648 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.649 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.650 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.650 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.654 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.655 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.656 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.656 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.660 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.661 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.662 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.664 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.667 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.667 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.669 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.670 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.674 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.675 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.675 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.676 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.678 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.679 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.680 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.680 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.685 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.685 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.686 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.686 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.734 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.735 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.736 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.737 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 001004.740 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 001004.741 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 001004.741 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 001004.742 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot rank_num_feature_values_dict as a bar chart\n", + "# the x-axis is the bucket range, where bucket_range = [bucket_size * rank_idx, bucket_size * (rank_idx + 1)))\n", + "# the y-axis is the number of feature values in each bucket\n", + "fig = plt.figure(figsize=(8, 6))\n", + "font_size = 24\n", + "x_list = []\n", + "y_list = []\n", + "for rank_idx in range(WORLD_SIZE):\n", + " x_list.append(f\"[{bucket_size * rank_idx}, {bucket_size * (rank_idx + 1)})\")\n", + " y_list.append(rank_num_feature_values_dict[rank_idx])\n", + "plt.bar(x_list, y_list)\n", + "plt.xlabel(\"feature value range\", fontsize=font_size)\n", + "plt.ylabel(\"number of feature values\", fontsize=font_size)\n", + "plt.xticks(fontsize=font_size)\n", + "plt.yticks(fontsize=font_size)\n", + "plt.tight_layout()\n", + "# save\n", + "fig.savefig(os.path.join(figure_folder, f\"feature_value_distribution_{target_feature}.png\"))\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the ratio of accumulated_collision_count / accumulated_total_count for each feature\n", + "# each feature name has a line with a different color\n", + "# the x-axis is the batch_idx, the y-axis is the ratio\n", + "fig = plt.figure(figsize=(20, 10))\n", + "x_list = []\n", + "y_list = []\n", + "for feature_name in feature_name_accumulated_collision_count_dict:\n", + " x_list = list(feature_name_accumulated_collision_count_dict[feature_name].keys())\n", + " y_list = [feature_name_accumulated_collision_count_dict[feature_name][x] / feature_name_accumulated_total_count_dict[feature_name][x] for x in x_list]\n", + " plt.plot(x_list, y_list, label=feature_name)\n", + "plt.xlabel(\"batch_idx\")\n", + "plt.ylabel(\"collision rate\")\n", + "plt.title(\"collision rate vs batch_idx\")\n", + "# add a text for each feature name at the last point of the line\n", + "for feature_name in feature_name_accumulated_collision_count_dict:\n", + " x_list = list(feature_name_accumulated_collision_count_dict[feature_name].keys())\n", + " y_list = [feature_name_accumulated_collision_count_dict[feature_name][x] / feature_name_accumulated_total_count_dict[feature_name][x] for x in x_list]\n", + " plt.text(x_list[-1], y_list[-1], feature_name, fontsize=12)\n", + "# plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the average ratio of accumulated_collision_count / accumulated_total_count for all the features\n", + "# the x-axis is the batch_idx, the y-axis is the ratio\n", + "fig = plt.figure(figsize=(8, 6))\n", + "font_size = 24\n", + "x_list = list(average_accumulated_collision_count_dict.keys())\n", + "y_list = list(average_accumulated_collision_count_dict.values())\n", + "plt.plot(x_list, y_list)\n", + "plt.xlabel(\"batch_idx\", fontsize=font_size)\n", + "plt.ylabel(\"average collision rate\", fontsize=font_size)\n", + "# plt.title(\"average collision rate vs batch_idx\", fontsize=font_size)\n", + "plt.xticks(fontsize=font_size)\n", + "plt.yticks(fontsize=font_size)\n", + "# save\n", + "plt.show()\n", + "# plot the ratio of accumulated_collision_count / accumulated_total_count" + ] + } + ], + "metadata": { + "orig_nbformat": 4 + } +} diff --git a/torchrec/distributed/benchmark/benchmark_zch/plots/plot_eval_metrics_compare.ipynb b/torchrec/distributed/benchmark/benchmark_zch/plots/plot_eval_metrics_compare.ipynb new file mode 100644 index 000000000..9a1790ac1 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/plots/plot_eval_metrics_compare.ipynb @@ -0,0 +1,451 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import csv\n", + "import numpy as np\n", + "import pandas as pd\n", + "import re\n", + "import json\n", + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "output": { + "id": 730003346092053, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['result_tbsize_10000_zch_dlrmv3_kuairand27k', 'result_tbsize_10000_nonzch_dlrmv3_kuairand27k']\n" + ] + } + ], + "source": [ + "root_folder = \"/home/lizhouyu/home/lizhouyu/zch_results\"\n", + "stats_folders = [x for x in os.listdir(root_folder) if x.startswith(\"result_tbsize_10000\") and \"kuairand27k\" in x]\n", + "print(stats_folders)\n", + "#" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "figure_folder = \"/data/users/lizhouyu/fbsource/fbcode/torchrec/distributed/benchmark/benchmark_zch/figures\"\n", + "os.makedirs(figure_folder, exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def get_eval_metrics(stats_folder_path):\n", + " eval_metrics_file_path = os.path.join(stats_folder_path, \"eval_metrics.csv\")\n", + " df_stats = pd.read_csv(eval_metrics_file_path)\n", + " # maintain a dictionary of {rank: {metrics: {task_idx: value}}}\n", + " rank_eval_metrics_value = {}\n", + " for index, row in df_stats.iterrows():\n", + " rank_idx = row[\"rank\"]\n", + " if rank_idx not in rank_eval_metrics_value:\n", + " rank_eval_metrics_value[rank_idx] = {}\n", + " # check if the metrics is a list or a single value\n", + " for metric_name in [\"ne\", \"auc\", \"mae\", \"mse\"]:\n", + " if metric_name not in rank_eval_metrics_value[rank_idx]:\n", + " rank_eval_metrics_value[rank_idx][metric_name] = {}\n", + " metric_value = row[metric_name]\n", + " print(metric_name, metric_value, type(metric_value))\n", + " if isinstance(metric_value, str) and (\"[\" in metric_value or \"]\" in metric_value):\n", + " metric_value = metric_value.replace(\"[\", \"\").replace(\"]\", \"\").split(\",\")\n", + " metric_value = [float(x) for x in metric_value]\n", + " if isinstance(metric_value, list):\n", + " for task_idx, task_value in enumerate(metric_value):\n", + " rank_eval_metrics_value[rank_idx][metric_name][task_idx] = task_value\n", + " else:\n", + " rank_eval_metrics_value[rank_idx][metric_name][0] = float(metric_value) if metric_value != \"nan\" else 0.0\n", + "\n", + " # get average qps over all ranks\n", + " average_eval_metrics_value = {} # {metrics: {task_idx: average_value_over_all_ranks}}\n", + " for rank, metric_name_task_id_metric_value_dict in rank_eval_metrics_value.items():\n", + " for metric_name, task_id_metric_value_dict in metric_name_task_id_metric_value_dict.items():\n", + " for task_id, metric_value in task_id_metric_value_dict.items():\n", + " if metric_name not in average_eval_metrics_value:\n", + " average_eval_metrics_value[metric_name] = {}\n", + " if task_id not in average_eval_metrics_value[metric_name]:\n", + " average_eval_metrics_value[metric_name][task_id] = []\n", + " average_eval_metrics_value[metric_name][task_id].append(metric_value)\n", + " for metric_name, task_id_metric_value_list in average_eval_metrics_value.items():\n", + " for task_id, metric_value_list in task_id_metric_value_list.items():\n", + " average_eval_metrics_value[metric_name][task_id] = np.mean(metric_value_list)\n", + " return average_eval_metrics_value" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "re_zch_method_name_pattern = re.compile(r\"\\d+_((non)?zch(.*)?)\")\n", + "re_table_size_pattern = re.compile(r\"result_tbsize_(\\d+)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "output": { + "id": 2253043958485501, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "zch_dlrmv3_kuairand27k 10000\n", + "ne [1.0082555927827888, 0.8971864475100473, 1.081050717655323, 1.0706481519500877, 1.1080358234436172, 1.0940853313027725, 1.0216489750548141, 1.0652245619353071] \n", + "auc [0.6327600479125977, 0.7780923247337341, 0.6339844465255737, 0.6193706393241882, 0.5363970398902893, 0.6150850057601929, 0.6271106600761414, 0.6540845036506653] \n", + "mae nan \n", + "mse nan \n", + "ne [1.0082555927827888, 0.8971864475100473, 1.081050717655323, 1.0706481519500877, 1.1080358234436172, 1.0940853313027725, 1.0216489750548141, 1.0652245619353071] \n", + "auc [0.6327600479125977, 0.7780923247337341, 0.6339844465255737, 0.6193706393241882, 0.5363970398902893, 0.6150850057601929, 0.6271106600761414, 0.6540845036506653] \n", + "mae nan \n", + "mse nan \n", + "ne [1.0082555927827888, 0.8971864475100473, 1.081050717655323, 1.0706481519500877, 1.1080358234436172, 1.0940853313027725, 1.0216489750548141, 1.0652245619353071] \n", + "auc [0.6327600479125977, 0.7780923247337341, 0.6339844465255737, 0.6193706393241882, 0.5363970398902893, 0.6150850057601929, 0.6271106600761414, 0.6540845036506653] \n", + "mae nan \n", + "mse nan \n", + "ne [1.0082555927827888, 0.8971864475100473, 1.081050717655323, 1.0706481519500877, 1.1080358234436172, 1.0940853313027725, 1.0216489750548141, 1.0652245619353071] \n", + "auc [0.6327600479125977, 0.7780923247337341, 0.6339844465255737, 0.6193706393241882, 0.5363970398902893, 0.6150850057601929, 0.6271106600761414, 0.6540845036506653] \n", + "mae nan \n", + "mse nan \n", + "nonzch_dlrmv3_kuairand27k 10000\n", + "ne [1.046645799432464, 0.9173418697036878, 1.0798678758908813, 1.0578123397407198, 1.1531900443020695, 1.1030672323772879, 1.0468359287391686, 1.075794420751179] \n", + "auc [0.6255273222923279, 0.7784473299980164, 0.6177278161048889, 0.615269124507904, 0.4703689217567444, 0.593986451625824, 0.6208029389381409, 0.6659070253372192] \n", + "mae nan \n", + "mse nan \n", + "ne [1.046645799432464, 0.9173418697036878, 1.0798678758908813, 1.0578123397407198, 1.1531900443020695, 1.1030672323772879, 1.0468359287391686, 1.075794420751179] \n", + "auc [0.6255273222923279, 0.7784473299980164, 0.6177278161048889, 0.615269124507904, 0.4703689217567444, 0.593986451625824, 0.6208029389381409, 0.6659070253372192] \n", + "mae nan \n", + "mse nan \n", + "ne [1.046645799432464, 0.9173418697036878, 1.0798678758908813, 1.0578123397407198, 1.1531900443020695, 1.1030672323772879, 1.0468359287391686, 1.075794420751179] \n", + "auc [0.6255273222923279, 0.7784473299980164, 0.6177278161048889, 0.615269124507904, 0.4703689217567444, 0.593986451625824, 0.6208029389381409, 0.6659070253372192] \n", + "mae nan \n", + "mse nan \n", + "ne [1.046645799432464, 0.9173418697036878, 1.0798678758908813, 1.0578123397407198, 1.1531900443020695, 1.1030672323772879, 1.0468359287391686, 1.075794420751179] \n", + "auc [0.6255273222923279, 0.7784473299980164, 0.6177278161048889, 0.615269124507904, 0.4703689217567444, 0.593986451625824, 0.6208029389381409, 0.6659070253372192] \n", + "mae nan \n", + "mse nan \n" + ] + } + ], + "source": [ + "metrics_task_id_table_size_zch_method_avetage_value_dict = {} # a dictionary of {metrics: {task_id: {table_size: {zch_method: average_value}}}}\n", + "for zch_stats_folder in stats_folders:\n", + " zch_method_name = re_zch_method_name_pattern.search(zch_stats_folder).group(1)\n", + " table_size = int(re_table_size_pattern.search(zch_stats_folder).group(1))\n", + " print(zch_method_name, table_size)\n", + " zch_stats_file_folder = os.path.join(root_folder, zch_stats_folder)\n", + " average_eval_metrics_task_id_value = get_eval_metrics(zch_stats_file_folder)\n", + " for metrics_name, task_id_avg_value_dict in average_eval_metrics_task_id_value.items():\n", + " for task_id, avg_value in task_id_avg_value_dict.items():\n", + " if metrics_name not in metrics_task_id_table_size_zch_method_avetage_value_dict:\n", + " metrics_task_id_table_size_zch_method_avetage_value_dict[metrics_name] = {}\n", + " if task_id not in metrics_task_id_table_size_zch_method_avetage_value_dict[metrics_name]:\n", + " metrics_task_id_table_size_zch_method_avetage_value_dict[metrics_name][task_id] = {}\n", + " if table_size not in metrics_task_id_table_size_zch_method_avetage_value_dict[metrics_name][task_id]:\n", + " metrics_task_id_table_size_zch_method_avetage_value_dict[metrics_name][task_id][table_size] = {}\n", + " metrics_task_id_table_size_zch_method_avetage_value_dict[metrics_name][task_id][table_size][zch_method_name] = avg_value" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "output": { + "id": 1748400135794163, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"ne\": {\n", + " \"0\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": 1.0082555927827888,\n", + " \"nonzch_dlrmv3_kuairand27k\": 1.046645799432464\n", + " }\n", + " },\n", + " \"1\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": 0.8971864475100473,\n", + " \"nonzch_dlrmv3_kuairand27k\": 0.9173418697036878\n", + " }\n", + " },\n", + " \"2\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": 1.081050717655323,\n", + " \"nonzch_dlrmv3_kuairand27k\": 1.0798678758908813\n", + " }\n", + " },\n", + " \"3\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": 1.0706481519500877,\n", + " \"nonzch_dlrmv3_kuairand27k\": 1.0578123397407198\n", + " }\n", + " },\n", + " \"4\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": 1.1080358234436172,\n", + " \"nonzch_dlrmv3_kuairand27k\": 1.1531900443020695\n", + " }\n", + " },\n", + " \"5\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": 1.0940853313027725,\n", + " \"nonzch_dlrmv3_kuairand27k\": 1.1030672323772879\n", + " }\n", + " },\n", + " \"6\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": 1.0216489750548141,\n", + " \"nonzch_dlrmv3_kuairand27k\": 1.0468359287391686\n", + " }\n", + " },\n", + " \"7\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": 1.0652245619353071,\n", + " \"nonzch_dlrmv3_kuairand27k\": 1.075794420751179\n", + " }\n", + " }\n", + " },\n", + " \"auc\": {\n", + " \"0\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": 0.6327600479125977,\n", + " \"nonzch_dlrmv3_kuairand27k\": 0.6255273222923279\n", + " }\n", + " },\n", + " \"1\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": 0.7780923247337341,\n", + " \"nonzch_dlrmv3_kuairand27k\": 0.7784473299980164\n", + " }\n", + " },\n", + " \"2\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": 0.6339844465255737,\n", + " \"nonzch_dlrmv3_kuairand27k\": 0.6177278161048889\n", + " }\n", + " },\n", + " \"3\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": 0.6193706393241882,\n", + " \"nonzch_dlrmv3_kuairand27k\": 0.615269124507904\n", + " }\n", + " },\n", + " \"4\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": 0.5363970398902893,\n", + " \"nonzch_dlrmv3_kuairand27k\": 0.4703689217567444\n", + " }\n", + " },\n", + " \"5\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": 0.6150850057601929,\n", + " \"nonzch_dlrmv3_kuairand27k\": 0.593986451625824\n", + " }\n", + " },\n", + " \"6\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": 0.6271106600761414,\n", + " \"nonzch_dlrmv3_kuairand27k\": 0.6208029389381409\n", + " }\n", + " },\n", + " \"7\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": 0.6540845036506653,\n", + " \"nonzch_dlrmv3_kuairand27k\": 0.6659070253372192\n", + " }\n", + " }\n", + " },\n", + " \"mae\": {\n", + " \"0\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": NaN,\n", + " \"nonzch_dlrmv3_kuairand27k\": NaN\n", + " }\n", + " }\n", + " },\n", + " \"mse\": {\n", + " \"0\": {\n", + " \"10000\": {\n", + " \"zch_dlrmv3_kuairand27k\": NaN,\n", + " \"nonzch_dlrmv3_kuairand27k\": NaN\n", + " }\n", + " }\n", + " }\n", + "}\n" + ] + } + ], + "source": [ + "print(json.dumps(metrics_task_id_table_size_zch_method_avetage_value_dict, indent=4))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot collision rate" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "output": { + "id": 753841307214735, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxAAAAJICAYAAADxUwLTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAjqxJREFUeJzs3XlcVPe5P/DPzMAMy7DvsrkBoqiIuCBuMe5GYxaz2yTN0qRp2ixN09vb3t62v942bbM1a02zNHuiiTHGuEbjBoiigiDiArLv+wzMPr8/wBGCwMw5w8wAn/fr5ese5nzP+T7z3KGZh/NdJEVFRWYQERERERFZQersAIiIiIiIaPhgAUFERERERFZjAUFERERERFZjAUFERERERFZjAUFERERERFZjAUFERERERFZjAUFERERERFZjAUFERERERFZjAUFERERERFZjAUFERERERFZjAUFERERERFZjAUFERERERFZjAUFERERERFZjAUFERERERFZjAUFERERERFZzc3YAREREPf3l7y+jorIKnh4e+Mdf/wAAyC8oROaxEygrr0Rbezvc3GQICQ5C0uRELFk8H15eXv3eT6vVISMrG/lnz6G6phZqlRpu7m7w8/XF+HGxmDVzBhLiJzrwHRIRDW8sIIiIyKXI5e6WY5PJhA8/2Yxjx0/2amMwGFBeUYXyiipknziJp37+KPz9/frc6/yFS3jn/Y/R3q7qfb3RCI2mHrV19cg8dgJTkybjvo13wEOhGMJ3RkQ0MrCAICIilyKRXB1du2PXXhw7fhKTEuIwb84shIQEQafX43JpOXbv3Y+Ojk40NjVjy9btePD+e3rd58KlYrz25tswGI2QSCSYNXMGZiRPRYC/H7RaHS6XlePQ4Qw0NjXjTP5ZvPnWe/j5Tx+CVMrRvUREA2EBQURELkUqkQAAtDod9uz7HsuvX4wb167q1Wbi+HEYGxONF195EwCQe6YAnZ2d8PT0BADo9Xq8/+HnluLhofs3Yvq0Kb3vMWEc0tNm45XX/43SsnJcuFiMo5nZWJA+12HvlYhoOOKfWYiIyCWZTCZEjgnH2jUrrnl+4oRxCAkOsrStqKy2nMs5lYem5mYAwIL0uX2Khys8PTxwz523QtJdtBw8nDEE74SIaGRhAUFERC4rbc6sAYcUhYeFWo7bVVfnOZw6nWc5np2aMmAfYyLCER01BgBQXVOLxsYmkVETEY1sLCCIiMhlxcZED3jew9PDcqzT6S3Hl0vLLcdhocGD9hMTHWU5Lq+oEhApEdHowTkQRETksry9+1+eFQCkPSZcm81mAIBOp4NKrba8/sxv/mBTn61tbTbHSUQ0mvAJBBERuawrE6pt0dmpEdVnp0bc9UREIx2fQBAR0YgikV4tOmQyGX79y5/bdL2PUjkEURERjRwsIIiIaETx9Lg6L8JoNCIkJBjubvzPHRGRvXAIExERjSju7u7w8/Wx/Fxf3+DUeIiIRhoWEERENOL0XL2p6Pwlp8ZCRDTSsIAgIqIRZ0byNMvxkYwsGI3GftuazWa88M838Mamd3Ek45iDIiQiGr5YQBAR0YgzI3kqggIDAAA1tXX4ctsOyzKvP7Ttm124VHwZ+WfPofDceQdHSkQ0/HBWGRERjTjubm740d2345XX34LBaMT3h46ivKIK8+fNRlhoKHR6HerqGnA0MxulZV2bzim9vXHLTTc4O3QiIpfHAoKIiEakiRPG4bFHHsA773+M9nYVLhWX4FJxyTXbhoYE48H770FgQIDD4yQiGm5YQBAR0YgVHzcBf/zds8jIOo78s+dQVV0DtUoNSCTw8VEiKnIMpk+dglkzk+HGpV6JiKwiKSoquvagUCIiIiIioh8Y0X9uKS65jP98+BkaGpsAAPfcuQFpc1Lt2sfF4hIcy85BcUkpWlpaoTcY4OnhgdDQECTETUB62mwEBPjbtU8iIiIiImcZkQWE0WjEjl17sfe7gzCZTEPSR6dGgw8/3ozTefl9zqnUaqhK1CguuYx9Bw7ilvVrsSB97pDEQURERETkSCOugKipqcV7H36G8opKAIBUKrV7EaE3GPDK62+htKwCAODr64PFC9IxYcJYKORyNDY2I/vESeSeKYBeb8Cnm7dCoVBgduoMu8ZBRERERORoI6qAOHw0C198tR16vQFSqRSrll+PuoYGHD9xyq797N6731I8BAUG4JmnfgYfpdJyPjoqEsnTk7Brz35s/3Y3AODLbd9gRvJUuHOSHhERERENYyNqI7mDhzOg1xsQFBiAJx9/BKtXLoVUYt+3aDKZcPhIluXnH919e6/ioaflSxdbNjJqb1fh4qViu8ZCRERERORoI+7P4akpybhjw3p4enoOyf0bm5ohlUkhlUrh7eWFCePH9ttWKpVi/PixaGxqBgDU1NQjMSF+SOIiIiIiInKEEVVAbLh5HRLiJw5pHyHBQfjLH38Lk8kErVYLiUQyYHuZVGY51uv1QxobEREREdFQG1EFxFAXDz1JpVKrnnLUNzRYjgMDrV/ONT5+9D2pMJlMqK0sQ1hkDKTSETW6bkgxb8Ixd8Iwb8Iwb8Ixd8Iwb8KM5rydP3/eqnajKysOVlffgOKSUgCATCbj8CUiIiIiGvZYQAwRs9mMTzdvhdnctdF3etpseHt7OTssIiIiIiJRRtQQJleyZet2FJ2/CAAIDAjADauW23T9UG2A58quvOfR+N7FYN6EY+6EYd6EYd6EY+6EYd6EYd4GxwLCzsxmM7Zs3Y7vDx0FAHgoFHj4gR/Z/PShtrJsiCJ0ffXVFc4OYVhi3oRj7oRh3oRh3oRj7oRh3oRh3vrHAsKOtFod/vPRp8jNKwAAeHl54tGH7kd01Bib7xUWGTMEEbo2k8mE+uoKhEREjbpJS2Iwb8Ixd8Iwb8Iwb8Ixd8Iwb8KM5ry1X7xoVTsWEHbS0tKKN//9HsorqgAAAQH++OnD92NMRLig+422D2xPUql0VL9/oZg34Zg7YZg3YZg34Zg7YZg3YZi3/rGAsIPyikq8+dZ7aGltAwCMjY3Gww/cCz9fH2eHRkRERERkVywgRDp/4RLeeOs96HQ6AMCs1Bm4+45b4e7G1BIRERHRyMNvuSJcvFSC1ze9a9lhevXKpVizcpmzwyIiIiLqRaPRoL6+3tlhDAtmsxk6rQ4VFRWQSCTODscuFAoFgoKCIJPJ7HI/FhAC1dbW419v/wd6vR4SiQR3bLgJ8+fNcXZYRERERL1oNBo0NDQgMjLSbl8gRzKz2Qy9Xgd3d/mIKCDMZjM6OztRWVmJkJAQeHp6ir4nZ4YIYDAY8PZ/PkJHRycAYMPN61g8EBERkUti8TC6SSQSeHl5ISIiAk1NTXa5J59AXMNjTzxrOf7j755FUFBgr/O79x1AZVU1AGDOrJlYtGCew2MkIiIishaLB3J3d7fb5ngjpoBob1ehXaXq83pnZ6fluLW1DVXVNb3Oy2QyhIWGWN2PWt2B/QcOW66dO3tmn3v2x9a+iIiIiIhczYgpIA4dycS3u/cN2Gb7t7ux/dvdvV4LDAjAn37/a6v7yT97DhqtFgBgNBrx8mubrL7W1r6IiIiIiFzNiCkgHMVej36IiIiISJy/vfBP7N13AHfdfivuv/fua56vra3D88/9vyGP5f0PP8UHH3/W7/nlS5fgmacet/zc1t6OzV9sQ2ZWNmpqa+Hm5oawsFAsnD8PN994g2Wyc01tHTbe/xP8/LGfYO2alX3uu3vvfvzjxVfw9r9eQUx01BC9u95GTAGxZtUyrFllnyVUX3vpuX7Ppc1JRdqcVLv0Q0RERORUy5cDpaXOjSE2FtizR/DlUqkUm7/chuXLliByTIRdQ7PFhltuxA2rV/R5/esdO/Hxp1uwdMkiy2vV1TV45r/+B3K5HPfcdTsSE+Kg1elw6nQePvj4M3x/8Aief+5P8PX1dfC7sM6IKSCIiIiIyEalpcD5886OQpTJiQno7NTgtTf/jf/74++cFoenp2efJVJLy8qx+YttuHn9WsxInmZ5/f+eewEyNze8/Pxf4eOjtLw+NjYG06cl4bFfPIMtW7/Gj++9x6HvwVosIIiIiIho2JJKpXj8pw/jyWd+g6MZx5A+wNL6u/fuxxdbv0ZFZRXc3d0xJTEBP75vIyZOGAcA+HbXHrz4zzfw+j//jv988Cly8/Lh6eWJ+fPm4rFHHrRpNSu9Xo+//O1FjIkIx4/vu1oInMk/i3PnL+A3zz7Vq3i4Yvy4sXjnX68gIiLc5lw4CgsIIiIiB9i0aRNqqirg4xfg1M2plEolHn74Yaf1TzQUpkyehKXXL8abb72D1JnJUCgUfdrs2vMdnn/pVdx5+y24/rpF6OjoxNvvfYBf/vq3+PebryA4KBAyWddX49fe+DduWr8WP/vpwzh8NBOb/v0eJiXEYfnSJVbH9O77H6GsvAKvvvQ3yN3dLa+fzjsDiUSC2akp/V7rysUDWEAQERE5hlqthrqyCubScucVEP7+QEyMc/omGmIP/fhHuP+hx/DJ51/gvo139Tn/+ZatSJ6W1GtY0LO//AXuue8n2L3nO9x95wbL6wvmp2Hh/HmQSCS49aZ1+PCjz3Cu6ILVBcTp3DPY8uXXeOiBezF+3Nhe5xobm+Dt7QVvb2+b3t8bm97Bprf/0+d1o9Fo033sgQUEERGRg0ja2iCpb4DvNf46OtTatVqYx45lAUEjVoC/P+6950689c77WL70OoyJuDqhWt3RgfKKSixeOL/XNSHBwQgNCcbFS8W9Xp+UEG85lkgkUCqV19xv7FpUKjX+9sI/MW3qFNx607o+593c3GA2m21+f3fdfiuuW7ygz+tHjmbh3+++b/P9xGABQURE5EA+cjmeSktzeL8vZGaizeG9EjnWuhtWYdee7/Dam2/jz3/4reX1jo4OALjmnAOlUomOjs5er3l49C7yJRIA3d/5P/5sCz757AvLueuvW4gnHn/U8vPLr76Jjo4O/OrpX1zzaWNwUCDU6g60trbBz8/6VZb8/HyvucqUv7+f1fewFxYQRERERDQiyGQy/OzRh/DUr/4bGVnZlte9vbqGC7W3932K0NbWjojwMKv7uGH1CixakG752cvr6spLe7/7Ht8fOoL/euZJhIYEX/P6mSnJePu9D3E0MwurVy6/ZpsjGVmIihyDsbGu+cRQ6uwAiIiIiIjsZWrSZFx/3SK8sekd6HV6oPtLfmxMNM7kF/RqW11Ti4bGRiTEx1l9f18fH0SOibD8C/D3B7o3fHv1jbeweOF8LLluYb/Xx02cgOnTkvCfDz5FQ2NTn/Mll0vx3D9extff7LThXTsWCwgiIiIiGlEefuBetLW142hGluW12zfcjNN5+Xjvg49RVl6B/IJC/OVvL8DX1wcrl18vqj+TyYTn/vES3NxkuOeu29DU1HzNf1f86qmfw9PTAz9/6lns2rMPVdXVKC0rx9Zt3+DpZ3+LhPiJeOjHPxIV01DiECYiIiIiGlECAwPwo7tvx5tvvWt5bdn1iwGY8fmWr/D55q2QK+SYPjUJzzz1c5vmIlxLXX0D8gsKAQAPPvLzftvt/XYrACA0NASvvvR3bN32Db7Yuh2v/+ttyGQyREVG4r6Nd2HNquU27TnhaJKioiLbp4HTkIuPj7ei1chiMplQW1mGsMgYSKV8OGYt5k045k4Y5k2Y559/HrVZmQhrbcPT8+Y5vP8XMjPRFhEB32nT8NRTTzm8fzH4mRPmSt70Zili+lt9a/nyrt2onSk2Ftizx7kx9GA2m6HX6+DuLnfqni1Doby8HNHR0f2eP2/lruR8AkFEREQ0WrnQF3caPljGExERERGR1VhAEBERERGR1VhAEBERERGR1VhAEBERERGR1VhAEBERERGR1VhAEBERERGR1biMKxERjRqbNm2CSqVySt8HDx6EtPQy9HqDU/onIrIXFhBERDRqqFQqlJW1oaXF8X1XV2vg32GAUWp0fOdERHbEAoKIiEaVlhbg8mUJFAofh/bb1CSBt0ECeDi02xFh06ZNqKmqgI9fgNN2BlYqlXj44Yed0jeRq2EBQUREo45C4YO0tKcc2ufly98DHL0kiFqthrqyCubScucUEP7+QEyM4/slclEsIIiIiMjlSdraIKlvgK9C4dB+27VamMeOHbEFxPLlQGmpc2OIjQX27BF27T33PYzauvp+z//juT9h+tQkAMC5ovPY/MU25J8tRFtbO3x9fTBh/DjcsHoF5s2dbbnm/Y8+xYcff45vtn4KxTU+b08/+1vodHq88uJzwoIeAVhAEBER0YCcOfkcPSagj9Mb8L+33ebQvl/IzESbQ3t0rNJS4Px5Z0ch3Ksv/x0mo6nXa0aTEf/12z/CZDZhUnwcAODbXXvw8qv/wnWL5uN3//VLhAQHo6GxCd/u2ovf//EvuGPDzXjg/o1OehfDDwsIIiIiGpAzJ5+DE9BpAP5+fn1ee++Dj1FZVY2Xn/8rFAoFiksu45+vbcLN69fiJw/eZ2kXFhaKKZMnwd/fD59/8RWWXr8YsTHRDn4HwxMLCCIiIhqUsyafgxPQyQYFZ8/hk8++wL0b70R83AQAwNZt38DT0wP3bbzzmtdsvOt23LJ+LQIDAxwc7fDFAoKIiIis4ozJ5+AEdLJSR0cnnvvHS0icFI/bb73J8vrpvHwkT5t6zfkMAODhoYCHh2Pn1gx3LCCIyGmcPa7abDajvbUZ4WOi8MgjjzgtDiIiEu/VN99Ca2sbnvu/P0Amk1leb2xs6jVJ2lq33nnfNV/X6XSIj5soKtbhjgUEETmNs8dVFxWdgNnUjtAwP3R0dDglBq4tT0Qk3qEjGdi77wB++eTjiAgP63XOzU0Gs9ls8z1fefE5uLu793n9r397UVSsIwELCCJyKmeOq66r0yNQ2g65UY22vDyH98+15YmIxGtobMJLr7yB+fPmYsWyJX3OBwcFobq6xur7dai7/qAklUogk15j3xEJoNfrUFNj/T1tJZPJEBISMmT3F4sFBBE5nTPHVXtrtPBv1sC3utqhfY/0teWJiBzBbDbj78//E+7u7njy549es83MlGTs2r0PKpUaSqV3n/NGoxHbv92NFUuvg6enp+VphbGzEybDNSbfmEyAyQRTZ6f93xAAyGSAXD4097YTFhBENOp5ubnhqbQ0h/Ypdm15Z84f4dwRInIVX2z9GidP5+L//vg7+Pr6XrPN2jUr8e2uvXh909v41VM/73P+o08246NPNyM+bgImT0qwvC7R6SC91g1NZsBshlSvt+db6b612eWLB7CAICIanpw5f8RsNkPu1gEfP7XjOyci6lZSUop3/vMRrlu0ABPGj0NTU3OfNgqFHDHRUXji8Ufwwsuvo72tHTevX4vIMRFoaGzENzv34Lv9B/GTB+/rVTwAgFQiQbhS2eeecpkMMJuueU6sGpUKJivaORsLCCKiYcpZ80e02jaEhlzz73JERHZRX18Po3HgjQN37t4LvV6PAwcP48DBw9dsMz99Ln7ywL2YOiURv/uvX2L33v147h8voa2tHUofJeImjMd///opxE+cYJnToNVpAQAGnW4I3tnIwAKCiGgYc8b8kYyM5wE4b/ldIrKf2FhnR3DtGIxGI3Q6EwaqIVatWI1VK1YPev/Ozq6/6UeER+O+jfcO2AYAVixdhjXXLYLbNeZPA8Dzv3pi0D5HOhYQRERkk4qKLNTV1kOj9YVE0s9/YYcYl78lso89e5wdQf+MRkCnAyQSxz7xNBoBmblrtSW6NhYQRERkE6NRC3d9G+RVKi5/S0RDSiKRQqkMd2ifOl07YPu2EaMKCwgiIrKZt47L3xIRjVZ2LSCMRiOKL5eivLwSbW3t6NRosHrFUvj5+fZq03N7cSIiGp6G4/K3REQknl0KCL3BgJ279+FoZjbU3bv3XbF4YXqvAuLg4QwczzmNu26/BdFRY+zRPY0QmzZtQk1VBXz8AjiumoiISKQr/11dunwl5E7aW8DVd1QmYUQXEO3tKrz02r9QW1tvVfszBYUor6jEC/98A4/95MeYOGGc2BBohFCr1VBXVsFcWu6cAoLjqomIaAS58t9VQ3v70O2aPJBhsKMyCSO6gNj0zvuW4sHd3R1TEhMQEx2Fr3fsumZ7pXfXFuJ6vR7vvv8xfv/fzzitKibXI2lrg6S+Ab4KhUP75bhqIiIaiSRtbdA1NQE6HaQO/OPccNlReTTR6/WQSu2zopWoAiI3rwAll8sAAFOnJOLuO26FUtlVIPRXQDxw3904dCQTn3+xDa1t7cjKzsHC+Y4dQ0uuzUcu57hqIiIiO7n47beYNH48IqOjIbPTF8jBDJcdlUcDs9mMzs5ONDQ02G04magC4lTuGQDAmIhwPHj/PVZPjl44Pw25ZwpQdP4izuSfZQFBRERENEQ66+sRevQoqqdNg1kuBxzwJKKspQUGhQJuPj7Q6/W2X19WhvZ2A7RaN/j72369GDU1RVCYOqCUmiEJd+wSsmLz1h+FQoHIyEi7LWQkqoAoKe16+rAgfa7NAc2ZNRNF5y+iqrpGTAhERERENAgPlQpRGRkO629zZibaIiLgO20a0tPTbb9+82bk5bWhutoXaWm2Xy/GJ588hgjNJUzzMOCfd97p0L7F5s1RRBUQqnYVACAq0vbVlIKDArru8YNVm+ypuOQy/vPhZ2hobAIA3HPnBqTNSbVrH9U1tcjKzkHhufNoaW2FVquDj9IbERHhSEmeitmpKVy2loiIiIhGDFEFhNHUNbrNzc32L8hSqaz7/9p/LJ7RaMSOXXux97uDMJmGbgTezt37sHPPfhiNxl6vN7e0ormlFWcLi3Dg4FE8eP89CA0JHrI4iIiIiIgcRVQBoVR6o6WlFQ2NTYiOirTp2qru3UuvrMpkLzU1tXjvw89QXlEJdBcoQ1FE7Nq7H9/s3AsA8PBQYNGCeUiImwgPDw80NDYiI+s4zhVdQGVVNV59820888Rj8PFR2j0OIiIiIiJHElVAREeOQUtLK47nnMKM6VOtvs5kMuH7Q13j8GKibSs8BnL4aBa++Go79HoDpFIpVi2/HnUNDTh+4pTd+gCA2tp67OguHry9vfD0L36KsNCrs9pjY6Iwc8Z0fLF1O/YfPILGxiZ8tX0nNt61wa5xEBERkWvbtGkTVCqVU/o+ePAgpKWXodcbnNI/jVyiCohpUyfjTEEh8s6cxaEjmVatpqTRaPHhJ5stk6enJU0WE0IvBw9nQK83ICgwAPdtvBPjx8Xi/Y8+t9v9r9i1d7/lqcZN69b0Kh56Wr9uNc4UFKK+oRHZJ05i1YrrERwUaPd4iIiIyDWpVCqUlbWhpcXxfVdXa+DfYYBRarSiNZH1RBUQs1NTsHvvATQ0NuHzL7ahoLAIc2al9Brvr1Z3oK6+AXX1DTh/4SKyj5+CSq0GAIQEB2FW6gzx76KH1JRk3LFhPTw9Pe163ysMBgPy8gsAAJ6enkidmdxvW5lMhnlzZ2HbN7tgMplwOvcMli5ZNCRxERERkWtqaQEuX5ZAofBxaL9NTRJ4GySAh0O7pVFAVAEhk8nw0I834sVX/gWNRoOCs+dQcPZcrzYvvfqva17r4eGBh3680a6TqDfcvA4J8RPtdr9rKS4phUajBQBMGBcLd7eBUxgfdzWegsIiFhBERESjkELhg7S0pxza5+XL3wMcvURDQPS398gxEXjmyccQGxNl9TXjxsbgV0/9DGMi7Ls5x1AXDwB67VsRFTX48rVRkRGQdG/YUlXFPS+IiIiIaHgT9QTiirDQEDzz5M9w4VIxTp0+g8ulZWhqakGnRgOJRAJPTw8EBwUiNiYaKclTMX7cWHt06xS1dfWW48AA/0Hbu7m5wcdHiba2dqjUaqjUaruvPGVPnOxFRERERAOxSwFxRdyE8YibMN6et3Q5KpXacqxUWrcsq4+yq4C4cr0rFxCc7EVEREREA7FrATEaaHU6y/Fg8x+ucOvRTqvVDdj2iqHcAG8gZrMZzc1mlJZKIJc7Z7KXWWGG2Wx2aN9ms9nyz1m5F+pKvMMtbvwg747+//m14nBGn0I/c66QO+ZNGGf1LSZ3rpA38DMnGPMmzHDMm6OwgLCRXq+3HLsJKCD0Bv2Aba+orSwTEJ147a3N6OzQAOYATJ3ygEP7vnTpOwCA0WiAqq3VoX3rtBp0dqghaW12Wu7Fqq+ucHYINrvyedNp5Q7//zm6V1XDMP3MOTN3zJswzswbROaOv6v8zNmKeRNmuHwfEVVAXLhULKpzk9EEnV6PqVMSRd3Hkdzd3S3HeoN1Y/UNPdrJe1w/kLDIGAHRiefjFwBPrzbIFR5Q+vo5tG83NzfAAMhkbg7vW67wgKeXN3z8ApyWe6FMJhPqqysQEhFl11XNHMGZnzcM888cf1eZN1uJyR1/V/mZsxXzJoyzv4+0X7xoVTtRBcTLr24SczkAQCKR4JUX/iL6Po6ikMstxz2fRgykZzuFQmHVNc76IiiRSHr9c2YMzuhTIpEMuy/hV0il0mEXuyt83jBMP3OukDvmTRhn9S0md66QN/AzJxjzJsxwzJujOD0yZ46lFMLH5+rE6fZ261Yram1rsxz7+lg38ZqIiIiIyBWJegIxZ1aKVe2MJhNU7SqUV1RB3dEBD4UC1y2aDy+vodkteiiFh4Vajpuamgdtr9XqoFZ3AAD8/HyHbIdsIiIiIiJHEFVAbLzrNpvam0wm5JzKxZat25Fx7DgeefA+RFuxGZsriYq8Gm9ZReWg7UvLyi3H0ZHD670SEREREf2QQ4cwSaVSzJo5A7947GF0dHTgtX+9jXYnbVom1NjYaCiVXfs4FJeUQqPVDtj+bGGR5Xja1MlDHh8RERER0VByyhyIMRHhmDd3NlQqNQ4fyXJGCIJJpVKkJE8DAOh0OmRl5/TbVqPRWs7L5XJMn5rksDiJiIiIiIaC0yZRX9mxOvdMgbNC6NdjTzxr+dfY2NTn/IplSyzLuW7fsQuVVdV92phMJnzy+ZeWJyxLFs+3PLkgIiIiIhqunLaRnJt7V9fNzS12uV97u+qaw6E6Ozstx62tbaiqrul1XiaTISw0xKa+/P18cdstN+KjT7dAo9Hi+Zdfx6IF6UhMiINCIUdtXT0OHc5ESWnXBiDjYmOwYukSwe+NiIiIiMhVOK2AuPKXfZ1eZ5f7HTqSiW937xuwzfZvd2P7t7t7vRYYEIA//f7XNvc3b+4sGAwGfLltB7RaHfbsO4A9+w70aZeYEIf7Nt4Judy6DeSIiIiIiFyZUwoInU6Po5nZAACl9/Ad1rNwfhoSJ8XjaGY2zhYWobmlBXq9Hr4+PoiJjsKsmTMwfdoUZ4dJRERERGQ3ogqIC5eKrW5rNpnR2alBdU0tsrJPoKH7CcT4cbFiQrBYs2oZ1qxaZpd7vfbSc1a3DQkOwvq1q7B+7Sq79E1ERERE5MpEFRAvv7pJVOcSiQSLF6aLugcRERERETmO8yZRu8lwy/q1GD9urLNCICIiIiIiG4kqICaOHwdIrGsrkUjg5uYGXx8loqOjMGP6VPj5+ojpnoiIiIiIHExUAfHE4z+xXyREREREROTynLaRHBERERERDT8sIIiIiIiIyGosIIiIiIiIyGpWzYH4nz9Zvy+CrSQA/vC7Z4fs/kREREREZD9WFRBNTc1DHwkREREREbk8DmEiIiIiIiKrWfUE4tUX/zr0kRARERERkcvjEwgiIiIiIrKa0wqIquoavPzaJny7a5+zQiAiIiIiIhs5rYDQaDS4cLEYGceOOysEIiIiIiKykVVzIKxlMpmgVndAb9D328ZoNKGpqRk7d38HAFCp1PYMgYiIiIiIhpBdCogLF4uxa+9+XCougcFgtOnawAB/e4RANGpt2rQJNVUV8PELgEQicVocSqUSDz/8sNP6JyIiIscQXUAcyTiGz7Z8BbPZLOj6BelpYkMgGtXUajXUlVUwl5Y7r4Dw9wdiYpzTNxERETmUqAKirr4Bm7/82lI8SCQS+Ci9IZFI0NrWDnQ/YTAajWhrV1naRUVGIHJMBKYmTUbytCR7vA+iUU3S1gZJfQN8FQqH992u1cI8diwLCCIiolFCVAFx+GgWjEYjJBIJ1q1ZgQXpafDwUKCqugb/97eXAAB//J9fAwD0BgNyc/Px7e59aGpqwdIli1g8ENmRj1yOp9Ic/0TvhcxMtDm8VyIiInIWUaswXbhYDACYP28Oll2/GB4e/f/1093NDakzk/Hs0z9HTHQk3vvgU3x/OENM90RERERE5GCiCojGpiYAwLSpk62+RqGQ48f33g0fHyW+/Oob1NTWiQmBiIiIiIgcSFQBodFoAQC+Pj69Xu85kdNo7Lsqk5eXJ9LTZsNkMuFoxjExIRARERERkQOJmgPh7u4GnU4PnU7/g9fdLcednRoold59rp0wfiwA4Nz5i2JCIHIJmzZtgkqlckrfBw8ehLT0MvR6g1P6JyIiotFFVAHh7+eHuvoGVFVXY9zYqyuw9JwLUVVdg/i4CX2u9fL0AgA0t7SKCYHIJahUKpSVtaGlxfF9V1dr4N9hgFFq2x4sREREREKIKiCiIsegrr4B3x04jOnTkqD07nrSoPT2hpeXJzo6OnHi5OlrFhBV1dUAAIOBfzWlkaGlBbh8WQKFwseK1vbT1CSBt0ECeDi0WyIiIhqlRBUQydOTcPJ0HurqG/Dn517E9YsXYOmSRQCA8WNjkX/2HDKPnUB0VCQWpM+1XFdbV48du/YB3ImaRhiFwgdpaU85tM/Ll78HWIcTERGRg4gqIGZMn4qY6EiUlVeivV2F0rIKy7m5s1ORf/YczGYzPtvyFXbt3Y/w0BB0dHaiqqoGRpMJADAlMUH8uyAiIiIiIocQtQqTRCLBTx64FzHRkQDQa7J08vQkJE1JtPzc2tqGoguXUF5RZSkefH2UWLZ0sZgQiIiIiIjIgawuIDKPHYder+/zup+fL5558md45MF7MX3qlF7nHrr/HixemA6ZTNbnuriJ4/HE44/0WQKWiIiIiIhcl9VDmD769At8uW0H5qSmYP68OQgPD7Ock0gkvZ42XCGTyXDrTWtxw+rluHy5DCqVGu5yd0RFjkFQYID93gURERERETmETXMgOjs1+P5wBr4/nIEJ48diYXoakqcnXfMJQ08eCgUmJcSJjZWIiIiIiJzM6gIiwN8fzT0Wub9UfBmXii9D+aU30uakIn3eHAQHBQ5VnERERERE5AKsLiD+9Ptfo7DoPI5mZuNMfiGMxq5Nq1RqNfbuP4h9Bw4hIX4iFqTPxdQpiZBKRc3PJiIiIiIiF2TTEKbEhHgkJsRDpVbjWHYOMo+dQE1tHQDAbDbjXNEFnCu6AD8/X6TPnY15abPh7+c7VLETEREREZGDCdoHQuntjeuvW4jrr1uIksulOJqZjVOnz0Cr0wHdS7Z+u3sfdu3dj6Qpk7Bg3lwkToq3d+xERERERORgojaSA4BxY2MxbmwsNtx8I06cPIWMrOOWDeVMJhPyzpxF3pmzCAoMwPz0uUibndprvwgiIiIiIho+RBcQVygUcqSnzUF62hxUVdcgIzMbx3NOQ93RAQBobGrGtu07sWPnHkyfloT58+YgbsJ4e3VPREREREQOYLcCoqcxEeG49eZ1WL9uNU7n5SMz6ziKLlwCABgMRuSczEXOyVyEhYVgwby5WLwwfSjCICIiIiIiOxuSAsJyczc3pKYkIzUlGS0trTh5Og+ncs+g5HIZAKC2th5btm5nAUFERERENEw4bK1Vf38/LFm8AI8+dD9Wr1gKGZd5JSIiIiIadob0CcQVOp0ep/POIOdUHs4VXbDsIUFERERERMPLkBYQpWUVyMjKRs7JXGi02l7n3N3dkZoyHQvS5w5lCEREREREZEd2LyA6OzuRfaJrOdfKquo+5yPCw5A+bw7mzEqBp4eHvbsnIiIiIqIhZLcC4sKlYmRkHsfpvDPQ6w29O3GTYfq0JCxIn4uJ48fZq0siIiIiInIwUQVEu0qFrOwcZGRmo76hsc/54KBApM+bg7Q5qVB6c/M4IiIiIqLhTlABUVBYhIzMbOQXFMJoMvU6J5VKMXVKIuanz0FiQry94iQiIiIiIhdgdQHR3NyCjKzjyMw+gZaW1j7n/f18MW/ubKSnzYafn6+947RJdU0tsrJzUHjuPFpaW6HV6uCj9EZERDhSkqdidmoKZDKZ6H7MZjPOFhbheM5plJaVo7WtDQaDEZ4eHggNDUH8xPFImzsLwUGBdnlfRERERETOZnUB8T9/eg5ms7nXaxKJBJMS4rAgfS6SJk+C1AX2dti5ex927tnfZ6nY5pZWNLe04mxhEQ4cPIoH778HoSHBgvtpbWvHu+9/jAsXi/ucU6nVUJWoUVxyGfv2H8SqlUuxctkSwX0REREREbkKqwuInsWDUumNtNmpmD9vDoJc6K/ru/buxzc79wIAPDwUWLRgHhLiJsLDwwMNjY3IyDqOc0UXUFlVjVfffBvPPPEYfHyUNvej0Wrx8qv/Qm1dPQAgKDAA1y2aj/DwUCi9vdHa1o6zhUU4mnEMBqMR23fshslowuqVS+3+nomIiIiIHMmmORATJ4zDgnlzkTw9yS5DgOyptrYeO7qLB29vLzz9i58iLDTEcj42JgozZ0zHF1u3Y//BI2hsbMJX23di410bbO5r33cHLcVDfNwE/PQnP4a729VURgNImjwJydOS8M/X34LZbMauvfsxd85MBAYE2OX9EhERERE5g9Vjjn7766fwxM9+gpkp012ueED30wdT94Tum9at6VU89LR+3WqEBAcBALJPnERDY5PNfZ08nWc5Xrt6Ra/ioaf4uAmYFD8RAGA0GpGXX2hzX0RERERErsTqAiI8LHRoIxHBYDAgL78AAODp6YnUmcn9tpXJZJg3dxYAwGQy4XTuGZv7a2xqthxHR40ZsG1UVKTluKnHdUREREREw5HzZz3bQXFJKTQaLQBgwrjYfp8IXBEfN9FyXFBYZHN/7u7ulmOTyTxgW1OPZW7d3e2+8TcRERERkUONiAKiqrrGchw1yBMBAIiKjIBEIum6tqpm0PY/NC422nJcUlo2YNuKyqoe18XY3BcRERERkSsZEQXElQnNABAY4D9oezc3N8vqSyq1Giq12qb+lly3wHL89Te7oNXqrtnuXNEFnL9wCQAQHh6KyYkJNvVDRERERORqRsSYGpXqagGgVFq3LKuPUom2tnbL9Upvb6v7S0yIx803rsHWr79FaVk5/vDnv2HJ4gWIHBMBLy9PNDW3IL/gHLJPnITZbIZS6Y0H7r3bJfbJICIiIiISY0QUEFrd1ScAg81/uMKtR7v+niAM5PrrFiIycgwOHDyC/IJCbP362z5tfH19kJI8DcuvX2zz7tw95044ktls7vXPmTE4o0+z2Swo96M1bxCZO1fIG/iZE4x5E4a/q8LxMycM8ybMcMybo4yIAkKv11uO3QQUEHqDfsC216LV6nDh4iVUVlX320alUqOsvBKXSi4jJXmaTfevrRx4bsVQaW9tRmeHBjqtHKq2Vof2bTAYAABGo8Hhfeu0GnR2qCFpbRaU+9GaN4jMnTPzBn7mBGPehOHvqnD8zAnDvAkznPPmKCOigOi5KpK++//pgzH0aCfvcb012lUq/PO1tyyTt2ckT8Wi+fMQFTUGcnd3tLW348LFYuzedwDFJZdRXHIZRfMu4c7bbrK6j7BI50y49vELgKdXG+QKDyh9/Rzat5ubG2AAZDI3h/ctV3jA08sbPn4BgnI/WvMGkblzZt7Az5xgzJsw/F0Vjp85YZg3YYZz3sRqv3jRqnYjooBQyOWW455PIwbSs51CobCpvw8/2WIpHlavXIo1K5f1Oh/g74/ZqSlInjYVL7/2L1wuLceRjCxMGB+L2akpVvXhrPkSEomk1z9nxuCMPiUSiaDcj9a8QWTuXCFv4GdOMOZNGP6uCsfPnDDMmzDDMW+OYtfImptbBnwCUF1Ti7r6Bnt2CQCWFZUAoL1dZdU1rW1tlmNfH+smXqN7ydj8gq4dpQP8/bBy2ZJ+28rl7li/brXl5337D1ndDxERERGRK7LLE4jqmlps+fJrFF24hP965heIHBNxzXbZx09i7/6DmDB+LG6/dT3GRITbo/teu2Rbs9uzVquDWt0BAPDz84Wnp6fVfV28VGI5njhhPGQy2YDtx4+NhUQigdlsRlV1DbRaHRQK+YDXEBERERG5KtFPIC4Wl+DvL76Kou79DnouqdqfS8WX8fcXX+v1ZVyMqMirm8eVVVQO2r60rNxyHB05+MZzPXV0dFqO5fLB507IZDLLIyiz2YxOjcam/oiIiIiIXImoAqKzsxPvvPcRdLqu+QRyufuAY8UiIyMQ4N+10Zter8c773+Mzs7Ofttba2xsNJTKrn0ciktKodFqB2x/trDIcjxt6mSb+vLyuvq0orW1bcC26C6ojEaj5WdvL+ufdhARERERuRpRBcSRjGNo655zsOz6xXjuz79HfNyEftunpiTjT7//NW5cuwoA0NbWjiMZx8SEAHRPOL6yTKpOp0NWdk6/bTUareW8XC7H9KlJNvUVGxNlOb5YXDLoE4Wz585bjsdEhPdaMYqIiIiIaLgRVUDk5XdNJk6enoQbb1hp9SZuy5YsQkry1F73EGvFsiWWL+fbd+y65v4MJpMJn3z+JdpVXUXPksXzLU8uenrsiWct/xobm3qdi4mOsszd0Gi0+GzLV/1u9NHW3o5vdu6x/Dx39kyR75KIiIiIyLlETaKuqa0FAMyaOcPma1NnzsDJ02dQW1snJgQLfz9f3HbLjfjo0y3QaLR4/uXXsWhBOhIT4qBQyFFbV49DhzNRUtq1Kce42BisWNr/Ckr9kUgkuOv2m/Hya29Br9fj+IlTqKmpxby5sxEVGQG5XA61ugMXi0tw+EiWpVgZGxuNRQvm2eW9EhERERE5i6gCQqfVAQACA/xtvtbfr2tjDu0g8xVsMW/uLBgMBny5bQe0Wh327DuAPfsO9GmXmBCH+zbeadUk6GsZNzYWP3v0Abz/0edobGxCeUUVPtvyVb/tpyZNxsY7N1i9SzYRERERkasS9Y3Wy9sL7e0qqNSDr7z0Q1f2YfC086TihfPTkDgpHkczs3G2sAjNLS3Q6/Xw9fFBTHQUZs2cgenTpojuZ+L4cfjdr5/CqdwzyDtzFuUVlWhXqaDXG+DhoUBgQADGxsZgduoMTBg/1i7vjYiIiIjI2UQVEGEhIWhvV+FMfiESE+JtuvZY90Tmnns42EtIcBDWr12F9d2TtW312kvPWdXO3d0ds1NTrN5dmoiIiIhouBM1iTppyiSgezWm3DMFVl1jNpuxc/c+nM7L775HopgQiIiIiIjIgUQ9gViQnoZ9Bw5BpVLjrXc+wKT4iZg+LQmRY8Lh5+cHudwdZrMZGo0WjY1NKL5cipyTuairbwAAKJXemD9vjr3eCxERERERDTFRBYRCIceD99+D1958G3q9AefOX8S58xet69hNhh//6C54KBRiQiAiIiIiIgcSNYQJ3ZOJn/r5o5a9EawRER6GJx9/dMBN54iIiIiIyPXYZV3R6KhI/OZXT6Do/EWczstHaVkFmpqboenepdnDwwOBAQGIjYnC9KlTMCkhzh7dEhERERGRg9l1Y4KE+IlIiJ9oz1sSEREREZELET2EiYiIiIiIRg8WEEREREREZDWrhjBd2fTNw9MD06dO6fO6WHNmz7TLfYiIiIiIaGhZVUB88MlmAEBYaEivAuLK62JIJBIWEEREREREw4TThzCZzWZnh0BERERERFay6gnEqhXXAwCU3t7XfJ2IiIiIiEYHqwqINSuX2fQ6ERERERGNTE4fwkRERERERMOHqI3kNr3zPgBg9YqliIocY6+YiIiIiIjIRYl6AnEmvxB5Z87aLxoiIiIiInJpogqIAH8/AEBnp8Ze8RARERERkQsTVUAkTUkEAGRln7BXPERERERE5MJEFRA3rFqGsbHROHb8JL7c9g00Wq39IiMiIiIiIpcjahJ1a1s77rr9Fpw4eRpHM7JxNDMbCXETETkmAr6+PnB3d4fEivtwJ2oiIiIiouFBVAHx5+de7PNaXv5Z5OVbP7FaIpGwgCAiIiIiGiacvg+E2Wx2dghERERERGQlUU8g5sxKsV8kRERERETk8kQVEBvvus1+kRARERERkctz+hAmIiIiIiIaPkQ9gfjg480AgHVrVsDPz9emaw8cPIoDh45gUvxE3HX7LWLCICIiIiIiBxH1BOLY8RwcO56Djs5Om6/18vRAU1Mzzp2/KCYEIiIiIiJyIKcNYWppbQMAtLe3OysEIiIiIiKykU1DmI5l51zz9bwzZ1FWVmHVPYwmE+rrG3D4aBYAQC6X2xICERERERE5kU0FxAefbL7m69u/3S04gLGxMYKvJSIiIiIix7JpCFNK8lQEBQbYrfPAwABsuHmd3e5HRERERERDy6YnED++924AgEqtRmlpOd546z0AwIL0uVAqva2+j5enJ4KDgzB5UjxkMpmtMRMRERERkZMIWsZV6e2NKZMnWX5eOD8NEeFh9oyLiIiIiIhckKh9IGanpkAi6XqiQEREREREI5+oAuJHd99mv0iIiIiIiMjliSogrsVoNKKquhZtbW3o1GgwZfIkeHp42LsbIiIiIiJyArsVEIVF53HwUAbOnb8Ag8Foef2/n30SnuFXC4iTp/NwubQcq1cuhYdCYa/uiYiIiIjIAUQXECaTCR99ugXHjp+0qv3J03k4nZuP/IJCPP7TBxHg7y82BCIiIiIichCb9oG4ls+2fNWreFB6eyMxIa7f9tXVtQCAuvoGvP3uR2K7JyIiIiIiBxJVQJSVV+JoZjYAICgoEI8+dB/+8qff4rFHHuj3ml8/8wvMTJkOALhcVo7TefliQiAiIiIiIgcSVUBkHjsOAFAqvfH0Lx7FlMmTIJFIBrzG3c0N9959O8LCQgAAJ0/liQmBiIiIiIgcSFQBcfFSCQBg0YJ58PXxsb5TqRQL0tMAAOUVlWJCICIiIiIiBxJVQLS2tgEAJo4fZ/O1Y7p3rm7pvgcREREREbk+UQWEVqsFAHh62r7Pg0f33hAmk0lMCERERERE5ECiCggvby8AQHu7yuZrG5uaAADeXp5iQiAiIiIiIgcStQ9EaEgw2ttVyD97DomT4m269srSr2FhoWJCuKbqmlpkZeeg8Nx5tLS2QqvVwUfpjYiIcKQkT8Xs1BTIZDK79VdaVoGMrOO4cPESWlpbYTKZ4Ovri7Ex0Uibk2pzboiIiIiIXJWoAmLypARcKr6Mo5nZmJ06A7Ex0VZdt//7w8gvKAQAJCbY98v1zt37sHPPfhiNxl6vN7e0ormlFWcLi3Dg4FE8eP89CA0JFtWXyWTC1q+/xYGDR2A2m3uda2xsQmNjE3JO5WLmjGm495477Fq0EBERERE5g6gCYv68Odj73ffQaLV4+bVNWLNyGWbPSoGPUmlpc2VRV61Wh/MXL+HgoaM4d/4i0D0PYv68OeLeQQ+79u7HNzv3dt9bgUUL5iEhbiI8PDzQ0NiIjKzjOFd0AZVV1Xj1zbfxzBOPwcdHOeh9+/PZlq9wJOMYACAkOAjXLZqP6KhIGI1GlFwuw/7vD6NdpULOqTx4eXnhjg032e29EhERERE5g6gCwtvbC3fcdhPe++BT6HR6bP36W2z9+lvLBGkAeOOt92AwGNDWrur1V3qJRII7b7sJXnaaA1FbW48d3cWDt7cXnv7FTxEWGmI5HxsThZkzpuOLrdux/+ARNDY24avtO7Hxrg2C+jt5Os9SPMRNHI9HHroPHgqF5XzcxPGYkTwV/3jxNajUahzJOIbFC+YhvHv1KSIiIiKi4UjUJGoASE1Jxn333NGraNBoNJbjxqZmtLa19yoePDw8cN89d2DmjOliu7fYtXe/ZUWnm9at6VU89LR+3WqEBAcBALJPnERDY5PNfRmNRmzfsRvoftLxwL139yoerggJDsK6G1YgdWYybli9HBKp6HQTERERETmVqCcQV6TOTEZ8/AQcPpqF07n5qKmt6zMnQCKRYExEOGYkT0X63Nmihg79kMFgQF5+AQDA09MTqTOT+20rk8kwb+4sbPtmF0wmE07nnsHSJYts6u/8xUuoq28AACxITxvwvaSnzUF6mv2GaREREREROZNdCggA8PXxwZqVy7Bm5TJotFq0NLegU6OBRCKFp4cHAgL8IZe726u7XopLSqHRdO1JMWFcLNzdBn5b8XETLccFhUU2FxCncwssxzOmJ9kcLxERERHRcGW3AqInD4XCoWP9q6prLMdRUWMGbR8VGQGJRAKz2YyqqppB2/9QccllAICbmxuioyItr5vNZrSrVNBotPBResPTk3tcEBEREdHIMiQFhKPV1tVbjgMD/Adt7+bmBh8fJdra2qFSq6FSq6H09raqL5PJZBm+FBwcCKlUitq6euzZdwCnc/Oh6d6dGwDCw0ORNmcWFs1Pg7v70Dx9ISIiIiJypBFRQKhUasuxUmnd3AofZVcBceV6awuI5pZWGAyGrr68vXEm/yzeef8T6HS6Pm1rauqwddsO5Jw8jUcfvh++Pj5WviMiIiIiItdkdQHxwcebhyQAiQS4505hS6leoe3x5X2w+Q9XuPVop9X2/fLfn54rTKlUarz34aeQy92xfu0qTEuaDF9fH7Sr1MgvKMQ3O/egvV2FsvJKvPXOh3jy8Z9AauVKTFdWlHI0s9nc658zY3BGn2azWVDuR2veIDJ3rpA38DMnGPMmDH9XheNnThjmTZjhmDdHsbqAOHY8Z8iCEFtA6PV6y7GbgAJCb9AP2LYnbY8hSjW1dVAqvfHMkz9DcFCg5XV/P1/MnzcHiQlxeO6FV6BWd6C45DJOnDyN2akpVvVTW1lmdUz21N7ajM4ODXRaOVRtrQ7t+8qTHaPR4PC+dVoNOjvUkLQ2C8r9aM0bRObOmXkDP3OCMW/C8HdVOH7mhGHehBnOeXOUETGEqef8An33/9MHY+jRTi5ifsLqFUt7FQ89BQUFYvXKZdj8xTYAQOaxE1YXEGGRMYJjEsPHLwCeXm2QKzyg9PVzaN9ubm6AAZDJ3Bzet1zhAU8vb/j4BQjK/WjNG0Tmzpl5Az9zgjFvwvB3VTh+5oRh3oQZznkTq/3iRava2VxASCQSREdFYnJiPJImJ9p1PwehFHK55bjn04iB9GynuMYmcP329YO2U5MSB2yfkjzVUkCUXC6DyWSyahiTtUOd7E0ikfT658wYnNGnRCIRlPvRmjeIzJ0r5A38zAnGvAnD31Xh+JkThnkTZjjmzVGsLiAWL5iHEydzoVKrUVZegbLyCuzeewATxo3FrNRkpCRPc9qypT2LmPZ2lVXXtLa1WY59bSiCvH7wHv18fQds7+vjAy8vT3R0dEKv16Ojs9PqCdtERERERK7G6gLi1pvX4aYb16CgsAhZx06g4Ow5GE0mXCwuwcXiEmz+cjumJU3GnFkpSJwU79CqKTws1HLc1NQ8aHutVge1ugMA4Ofna1Ph4+/vB4VCbpl4rdcbIJPJBrxG7u6ODnQCAIwGo9V9ERERERG5GpuGMMlkMkxLmoxpSZOhVncg+8QpZJ/IQXlFFQwGA06ezsPJ03nw9VFiVmoK5sxKwZiI8KGLvltU5NXN48oqKgdtX1pWbjmOjhx847meJBIJxoSHo6S0a2JLXX0DYqIj+21vNpvR0dlp+dnL28um/oiIiIiIXIngSdTe3l64blE6rluUjqrqGmRln8CJnNNoa1ehrV2F7w4cwncHDiEqcgzmzp6J1JRkKJVDM3RnbGw0lEpvqFRqFJeUQqPVwmOAeQ1nC4ssx9OmTra5vymTEywFxLmi8wMWEDW1ddDpuuZbhIYEW73MLBERERGRK7LLOKMxEeG4+cYb8P/+9zd45KH7kDw9CW5uXcN6KiqrsGXrdvz37/+MTW+/j9N5+TAa7TuMRyqVIiV5GgBAp9MhK7v/JWc1Gq3lvFwux/SpSTb3NzMl2TKp5uCRzAH3kcjIzLYcJ06Kt7kvIiIiIiJXYtc/h0ulUiRNnoSkyZPQ0dGJEydP49jxHJSWVcBoMiEv/yzy8s/C28sLM1OmY86smYiNibJL3yuWLUHmsRPQ6/XYvmMX4iaMQ+SYiF5tTCYTPvn8S7SruiZaL1k8/5pPRR574lnL8R9/9yyCfrBMa2hIMNLmpCIj6zhaWlrx4Sebcf+P7uwz7+Pc+Yv4/nCGJTeLF6bb5b0SERERETnLkI2n8fLyxML5aVg4Pw21tfXIOp6D3Lx81NU3QN3RgUNHMnHoSCbCw0Lx218/Jbo/fz9f3HbLjfjo0y3QaLR4/uXXsWhBOhIT4qBQyFFbV49DhzMtQ4/GxcZgxdIlgvu7ce0qXCq+jNq6epw8nYfGpiZct2g+wkJD0dHZiTP5Z3H4aJZlF8F1N6xEaEiw6PdJRERERORMDhmQHxYWghtvWIkVy67DkYxj2PfdQajUaqB7joC9zJs7CwaDAV9u2wGtVoc9+w5gz74DfdolJsThvo13Qi4XvoGc0tsbjz/6IP793oe4XFqO0rIKvPfBp33aSaVSrF29AsuWLBLcFxERERGRqxjyAkKr1eHk6VzknMrDxUvFMPRYxlQikWBKYoJd+1s4Pw2Jk+JxNDMbZwuL0NzSAr1eD18fH8RER2HWzBmYPm2KXfoKCPDH07/4KXJO5SLnZC7KK6ugalfBzd0NgQEBmBQ/EQsXzENIcJBd+iMiIiIicrYhKyAuXipB5rETOJ17Blpd70nGYWEhmDs7FbNTU+Dn62P3vkOCg7B+7SqsX7tK0PWvvfSc1W2lUilmzZyBWTNnCOqLiIiIiGg4sWsB0dLSiqzsHGRln0BDY1Ovcx4eHpg5Yxrmzk7FuLEx9uyWiIiIiIgcRHQBYTAYkJtXgMzsEyg6fxFms9lyTiKRID5uAtJmp2L6tClwdxc+54CIiIiIiJxPcAFRVl6BzGMnkHMyt9dOywAQHBSIObNnYu6smQgI8LdHnERERERE5AJsKiBUKjWyT5xEVnYOqqprep2Ty90xY/o0pM1JxcQJ4+wdJxERERERuQCrC4hN77yPgoJzMHbvawAAMqkU8fETMXPGdMyYPhUKhXyo4iQiIiIiIhdgdQGRd+Ys0D2vITY6CklJiZg6JRGenh4AAHWHGuoOtaAgAgMCBF1HRERERESOZfMcCLPZjMtl5bhcVo5vvt0jOgCJRIJXXviL6PsQEREREdHQkzo7gJ6rNhERERERkWuz+gnEnFkpQxsJERERERG5PKsLiI133Ta0kRARERERkctz+hAmIiIiIiIaPlhAEBERERGR1VhAEBERERGR1VhAEBERERGR1VhAEBERERGR1VhAEBERERGR1VhAEBERERGR1VhAEBERERGR1VhAEBERERGR1VhAEBERERGR1VhAEBERERGR1VhAEBERERGR1dzsebOy8krkFxSivKISrW3t0Gg0eOSh+xAaEmxp09LaBplMCh+l0p5dExERERGRA9ilgKipqcVHn32Bkstlfc4ZjcZePx8+kon9B4/g5hvXYEH6XHt0T0REREREDiK6gCi5XIZ/vv4W9Hq9Ve3PFBRCr9fjsy1fwWgyYfGCeWJDICIiIiIiBxE1B0Kv1+Pf735gKR5ioqOw4eZ1ePoXj/Z7zby5s+Dh4QEA+OrrHWhuaRETAhEREREROZCoJxAZWcfR2tYOALhx7SosW7Jo0GsWL0xHTHQU/vn6JhgMRhzNzMYNq5aLCYOIiIiIiBxE1BOIgsIiAEDS5ElWFQ9XjB8Xi9SUZABA0flLYkIgIiIiIiIHElVAVFZVAwBmpc6w+dqpUyYDAOrq6sWEQEREREREDiSqgFCrOwAAIcHBg7b9IX9/PwBAp0YjJgQiIiIiInIgUQWETNZ1udlssvlavaFr4rXc3V1MCERERERE5ECiCghfHx8AQEVltc3XXrp0uesevj5iQiAiIiIiIgcSVUCMHxcLADh8NAsmk/VPIdrbVThw8AgAYML4sWJCICIiIiIiBxJVQKTO7FpJqaKyCv/56DOrNpMrLinFi6+8CZVa3XWP7tWYiIiIiIjI9YnaByIxIR6TEuJwrugCck7mouj8RcyYPhWhIVcnVRcUFqG4pBR19Q04f+Eiyiuqrl4/KR4J8RPFvQMiIiIiInIYUQUEADxw71146dVNqKyqhkqlxuGjWb3Of/X1t9e8LioyAj/+0Z1iuyciIiIiIgcSNYQJADw9PfHLJx/D0iWLoFDIB23v4eGBZdcvxi+feAyenp5iuyciIiIiIgcS/QQCANzd3LB+7SqsWn49zp4rwuXScjQ1NaNTo4FEIoGnhweCgwMRGxONxIR4yOVcupWIiIiIaDiySwFxhUIhx4zpUzFj+lR73paIiIiIiFyE6CFMREREREQ0erCAICIiIiIiq4kawvTWOx/AXe4OmVQKQCLoHlKpBJ6engjw98eE8bGIiY4SExIREREREQ0hUQVE7pkC+0XSbUxEODbcvA5xE8fb/d5ERERERCSOyw1hqqquwT9ffwuncs84OxQiIiIiIvoBUU8g/vy/v0GnRoOzhUX4esduGAwGhIeFInFSPKIix8Db2wtSiQQqdQeqa2pReO48Kiqr4OXliRtvWInQkBCYzWZotVrU1tUj90wBSi6XwWw248OPNyNuwngold72e7dERERERCSKqALCz88X+WfPYevX38LX1wd33nYzkiZP6rf9jTesRGHReXz86ZfYsnU7Hrp/IyYnJgAApgJYumQRMrKy8cnnW6HV6XAk4xhWLl8iJkQiIiIiIrIjUQVEZVU1PtvyFbw8PfH0Lx5FYEDAoNckJsTjicd/guee/yfe/eAT/OaZJxAQ4G85P2/ubFwqvoxjx0+isOi8oAKiuqYWWdk5KDx3Hi2trdBqdfBReiMiIhwpyVMxOzUFMpnM5vtaq7WtHX/+6wtQd3QAAO65cwPS5qQOWX9ERERERI4iag7EgYNHYDKZsHTJQquKhyuCAgNw/eKF6OzU4NDRrD7nZyRPAwDU1tXbHNPO3fvwl7+/jH37D6KyqhpqdQcMBgOaW1pxtrAIH36yBc89/wrq6htsvre1PvnsC0vxQEREREQ0koh6AnHxUgkAYPy4sTZfO2FC1zX5BYW48YaVvc75+foCADo7Om265669+/HNzr0AAA8PBRYtmIeEuInw8PBAQ2MjMrKO41zRBVRWVePVN9/GM088Bh8fpc2xDyQrOwdnCgrtek8iIiIiIlchqoBoaW0FAEgktu8BIZN2DSFqbm7pc06lVgEApDYMM6qtrceO7uLB29sLT//ipwgLDbGcj42JwswZ0/HF1u3Yf/AIGhub8NX2ndh41wabY+9PS0srtmzdDgDw9/NFS2ub3e5NREREROQKRA1hUigUAIBLxSU2X1taXgEAMJvNfc4VFV0Eur+EW2vX3v0wmUwAgJvWrelVPPS0ft1qhAQHAQCyT5xEQ2OTzbH356PPvkBnZyc8PT2xZPECu92XiIiIiMhViCogwsNCAQB7vzto05yC9nYV9n33PQAgMLD33InSsgoc7p4XERsbbdX9DAYD8vK7NrXz9PRE6szkftvKZDLMmzsLAGAymXDaTvtNZGRl42xhEQBg3ZoV8PLysst9iYiIiIhciagCIqV7snNHZyf+9sKr+GbnHpRXVFmeBPxQXX0DDhw8gr8+/0/L8J4p3cu4AsBX23fipVffhFanAwDMnjnDqjiKS0qh0WgBABPGxcLdbeCRWfFxEy3HBd1f+sVobm7BF199AwBIiJ+IBelzRd+TiIiIiMgViZoDMX/eHGRkHUdlVTU0Gg127dmPXXv2QyqVwtdHCblcDolUAr1Oj7Z2FQwGQ6/rvb28sHTJIsvP1dU10Ou72kxLmmzZI2IwVdU1luOoqDGDto+KjIBEIoHZbEZVVc2g7Qfz4adboNFo4aFQ4O47bhU0J4SIiIiIaDgQ9QRCJpPh8Z8+iIkTxvV63WQyoaW1DXX1DaitrUdTc0uf4sHfzxc/e/SBXjtNh3bPW5iZMh33bbzD6jh6Lvca2GNPif64ublZVl9SqdVQqdVW9/VDh49m4VzRBQDAzevXICjQ+uVsiYiIiIiGG1FPIABA6e2NJ372E+QXFCL7xCmcv3gJKtW1v5C7u7tjbGw0kqclYd7cWXB3d+91fnbqDMxOTUG0FU8ReurZn1Jp3bKsPkol2traLdcrvb0HveaHGhubsPXrHQCAxEnxSE+bY/M9iIiIiIiGE9EFxBVJUxKRNCURAKBWd6C1rQ1arRZmsxnu7nIolV4I8B/46UB0VKSgvq/MmQAw6PyHK9x6tNNqdQO2vRaz2YwPP90CrVYHTw8P3H3HLTbfYyD9zSMZamazudc/Z8bgjD7NZrOg3I/WvEFk7lwhb+BnTjDmTRj+rgrHz5wwzJswwzFvjmK3AqInb28veHsPvApRW3s7CgvPIyQkGOPHxYrqT6/XW47dBBQQeoN+wLbXcvBwBs5fuAQAuOWmtYMWR7aqrSyz6/2s1d7ajM4ODXRaOVRtrQ7t+8owN6PR4PC+dVoNOjvUkLQ2C8r9aM0bRObOmXkDP3OCMW/C8HdVOH7mhGHehBnOeXOUISkgrNHc3IoPPtmM6KgxePbpn4u6V8+hUPofzLXoT885GfIfDKUaTH1DI7Z9sxPofvKSNifVpuutERYZY/d7WsPHLwCeXm2QKzyg9PVzaN9ubm6AAZDJ3Bzet1zhAU8vb/j4BQjK/WjNG0Tmzpl5Az9zgjFvwvB3VTh+5oRh3oQZznkTq/3iRavaOa2AOFt4DvjBBGihFHK55bjn04iB9Gx3ZUM8a5hMJnzw8WbodHp4eXnirttutjFa60iloua3CyaRSHr9c2YMzuhTIpEIyv1ozRtE5s4V8gZ+5gRj3oTh76pw/MwJw7wJMxzz5ih2KSBMJhNyTuXi/IVLaGlt67PiUk9GoxFNzS1oael6JCTv8eVfqCsrKqF7kzprtLa1WY59faybeA0A3x86atl5+45bb4KfDbtlExERERENd6ILiLr6Brz51ns27UTdU0L8RCtaDezKjtgA0NTUPGh7rVYHtboDAODn5wtPT0+r+mlqbsbXO3YDACLHREAileDk6bxrti0rr+h1rFB0FUoR4WGICA+zqj8iIiIiIlcjqoDQ6fR4Y9O7qG9otPlamVSKxMQEbLhpnZgQAABRkVeXfS2rqBy0fWlZueU4OtL6JWMbGposQ58qq6rx9nsfWXXdoSOZOHQkEwCwesVSrFm1zOo+iYiIiIhciagCIiv7hKV4iBwTgfS02QgJDkJLaxs++nQLAOAXjz0Mo9GIxqZmnMo9g3NFFxA3cTzuu+cOuw3/GRsbDaXSGyqVGsUlpdBou3aF7s/ZwiLL8bSpk+0SAxERERHRaCCqgMg7UwAAiI2JwlM/fxQymQwAUFVdY2kTN3G85Tg9bTYKz53Hex98ir+/9Boef+RBhIWFiAkB6J5wnJI8DYeOZEKn0yErOweLF8y7ZluNRous7Byge/7F9KlJVvcTHzcBr730nFVtM4+dwIefbAYA3HPnhiFZqYmIiIiIyNFETe++UigsXphuKR4GkzgpHg/++B60tbXj9U3vCNrE7VpWLFtiWc51+45dqKyq7tPGZDLhk8+/RLuqa6L1ksXzoVT23YH6sSeetfxrbGyyS3xERERERCOBqAJC3dEJ/GASszXiJoxH8rQpaGxqxrHjOWJCsPD388Vtt9wIdD9leP7l17Htm104f+ESSsvKkX3iJF54+Q2cOHkaADAuNgYrli6xS99ERERERKOFqCFMV5fG7b1Gbs+nEZ0aDTw9PPpcOyN5Gk6ePoOcU7lYOD9NTBgW8+bOgsFgwJfbdkCr1WHPvgPYs+9An3aJCXG4b+OdkMtt20COiIiIiGi0E1VAeHl6oq1dheaWFkRHXV3NqOcE5paWVniG9y0gAgMCgO5dne1p4fw0JE6Kx9HMbJwtLEJzSwv0ej18fXwQEx2FWTNnYPq0KXbtk4iIiIhotBBVQISFhaKtXYWcU7mYlnR1NSOl0hsymQxGoxHnii5cc98DVfc8hCv7MdhTSHAQ1q9dhfVrVwm63tqJ0gNJm5PKidNERERENOKImgORmBAHAMg5mYsPP9lsmbgsk8ksRcPe775Hc0tLn2sPZxwDAHh69n06QURERERErknUE4h5c2dj974D0Gq7lk5VqTvwyIP3AgCSpyWhorIKbe0qPPePV5A2dxYiwsPQ0dmJU6fzcKn4MtA9mZmIiIiIiIYHUQWEUumNjXfehnff/xhGkwk+PZZEXbQgDQePZKC9XQWVWo29333f53qJRILrFs0XEwIRERERETmQqCFMAJA8PQlPP/EYkqclITgoyPK6p6cnfvrw/fDz9bl2x1Ipbll/A+LjJogNgYiIiIiIHETUE4grYqIj8eD99/R5PToqEr//72eQfeIULl4qgUqlglwuR2RkBOakpiA4OOia9yMiIiIiItdklwJiIHK5HPPnzcH8eXOGuisiIiIiIhpiogqIvPyzAICxsdHw9bn2UCUiIiIiIho5RM2B2PT2+9j09vtoauq7TCsREREREY08ogoIby+vrptIJfaKh4iIiIiIXJioAiIqMgIAUHy5zF7xEBERERGRCxNVQKxZtQwyqRTf7tyL8opK+0VFREREREQuSVQBMX7cWDzz1M8QEx2J519+HR98/DlyzxSgsbEJer3eflESEREREZFLELUK099eeMVyLJfLcez4SRw7ftKme0gkErzywl/EhEFERERERA4iqoAoKxc/bMlsNou+BxEREREROYaoIUxERERERDS6iHoC8eqLf7VfJERERERE5PL4BIKIiIiIiKzGAoKIiIiIiKwmaghTfzo6OtDW1o5OjQaRY8ZALncfim6IiIiIiMjB7FZA1NTU4tDRLOSfPYempmbL6//97JOICA+z/Hzu/EXU1tZhQfpcSKV8AEJERERENJzYpYDYsWsvdu89AJPJNGjb7OMnkX3iJHJO5eHRh+6Fp6enPUIgIiIiIiIHEP0IYMeuvdi5+ztL8SCRSBAaEtxv+4uXigEAxSWX8d4Hn4rtnoiIiIiIHEhUAVFX34Ddew8AALy8PHHbLTfib3/+H/zPb37Z7zVPP/EY4iaOBwAUFBbh3PmLYkIgIiIiIiIHElVAHMk4BpPJBIVCjqd//lMsnJ826JAkP18fPPrQfQjw9wcAHD9xSkwIRERERETkQKIKiAsXLwEAFqSnISwsxOrr5HI5Fs6fCwC4XFomJgQiIiIiInIgUQVEU1MLAGBS/ESbr42KGgMAaG5pERMCERERERE5kKgCQqPRAACUSm+br1V6d11jNBjFhEBERERERA4kqoC4Mt+ho6PT5mtbWtt63YOIiIiIiFyfqAIiKCgAAFAkYCWlU6fzAADBwYFiQiAiIiIiIgcSVUBMio8DABw8komGhkarrzudm4/s7tWXJiXEiQmBiIiIiIgcSFQBMT99DtzcZNBoNHjhn2/gdG7+gLtRV1XX4OPPvsDb//kIAODm5ob58+aKCYGIiIiIiBzITczFAf7+WLdmJb7ctgNt7Sr8+70PoVDIERwUZGnzyedfwmwG6urroVZ39Lr+xhtWwt/PV0wIRERERETkQKIKCABYsngBDAYjduzcA6PJBK1Wh8qqasv54pLSPtfIpFLcsHo5rls0X2z3RERERETkQKILCABYvnQxkqZMwncHDiE3rwAarfaa7Tw9PTBj+lQsXpiOMRHh9uiaiIiIiIgcyC4FBACMiQjHxrtuwz13mlFTW4empmZ0ajSQSCTw9PBAcHAQQkOC7dUdERERERE5gagCQq/Xw93dvddrEokEEeFhiAgPExsbERERERG5GFGrMP3X7/4fPvp0C85fuGS/iIiIiIiIyGWJegKh0WqReewEMo+dQIC/P2anzsCs1BkIDwu1X4REREREROQy7DYHormlBbv3HcDufQcQEx2J2bNmInXGdCiV3vbqgoiIiIiInExUAfGn3/8aJ0/lIedUHsrKKyyvl5VXoqy8Elu/+gaJk+Ixe1YKpiZNhrub3eoVIiIiIiJyAtEbyV1/3UJcf91CNDQ24eSpXOScyrPsA2E0mZB/9hzyz56Dh4cHUpKnYnZqCiZOGGev+ImIiIiIyIHs9kggOCgQy5deh+VLr0NtXT1yTuYi53QuamvrAQAajQYZWceRkXUcgYEBmJ06A7NTU7i0KxERERHRMDIkY4rCQkOweuVSrF65FFXVNcg5lYuTp/JQ39AIAGhqasauPfuxa89+jI2Jxi+ffGwowiAiIiIiIjsb8kkJYyLCMSYiHGtXr0BlVTVy8wpwpuAsyiuqAACXy8qHOgQiIiIiIrITh85qjggPg1rdAZ1eD5WqA80tLY7snoiIiIiIRBryAkKn06Og8BxOnc7D2cLz0Gi1vQMYgpWZqmtqkZWdg8Jz59HS2gqtVgcfpTciIsItE7llMpld+rpYXIJj2TkoLilFS0sr9AYDPD08EBoagoS4CUhPm42AAH+79EVERERE5GxDUkDodHrkny3EydN5OFtYBJ1O36fNxAnjMGvmDKQkT7Vr3zt378POPfthNBp7vd7c0ormllacLSzCgYNH8eD994iawN2p0eDDjzfjdF5+n3MqtRqqEjWKSy5j34GDuGX9WixInyu4LyIiIiIiV2G3AkKr1SG/oBCncs+goLAIen3fomFMRDhmpc5Aasp0BPjb/6/yu/buxzc79wIAPDwUWLRgHhLiJsLDwwMNjY3IyDqOc0UXUFlVjVfffBvPPPEYfHyUNvejNxjwyutvobSsa+8LX18fLF6QjgkTxkIhl6OxsRnZJ04i90wB9HoDPt28FQqFArNTZ9j9PRMREREROZKoAkKr1eFMwVmcOn0GZ88VQa839GkT4O+P1JnJmDUzGWMiwsV0N6Da2nrs6C4evL298PQvfoqw0BDL+diYKMycMR1fbN2O/QePoLGxCV9t34mNd22wua/de/dbioegwAA889TP4KO8WohER0UieXoSdu3Zj+3f7gYAfLntG8xInsrN9IiIiIhoWBP1bfbZ3/4BBoOxz+teXp6YMX0qZs2c4bBN43bt3Q+TyQQAuGndml7FQ0/r163GmYJC1Dc0IvvESaxacT2CgwKt7sdkMuHwkSzLzz+6+/ZexUNPy5cuRkZWNhqbmtHersLFS8VITIi3+b0REREREbkKUQVEz+LBzc0NU6ckYlbqDExJTLDbJGXr4jAgL78AAODp6YnUmcn9tpXJZJg3dxa2fbMLJpMJp3PPYOmSRVb31djUDKlMCqlUCm8vL0wYP7bftlKpFOPHj0VjUzMAoKamngUEEREREQ1rogoIiUSC+LgJmDVzBpKnJcHDQ2HzPfQGg+hhPcUlpdBoulZ3mjAudtD7xcdNtBwXFBbZVECEBAfhL3/8LUwmE7RaLSQSyYDtZdKrhdS15oUQEREREQ0nor65/7///Q38fH0EXVtTU4sjmdnIPnESf/vz78WEgarqGstxVNSYQdtHRUZAIpHAbDajqqpm0PbXIpVK4enpOWi7+oYGy3FgIJdzJSIiIqLhTVQBYWvxYDAYcPL0GRzJOIbikstiuu6ltq7echxoxZ4Lbm5u8PFRoq2tvWvJVbUaSm9vu8VzRV19A4pLSoHuoVMcvkREREREw51DlgSqqa3D0YxjOHbiJDo6Ou1+f5VKbTlW9jOh+Yd8lF0FxJXr7V1AmM1mfLp5K8xmMwAgPW02vL297NoHEREREZGjDVkBYTAYcCq362nDpeK+TxsUcjlmpkzH/HniN1jT6nSWY2vnU/TcAVur1Q3YVogtW7ej6PxFAEBgQABuWLXcpuuvrCjlaGazudc/Z8bgjD7NZrOg3I/WvEFk7lwhb+BnTjDmTRj+rgrHz5wwzJswwzFvjmL3AqK2th5HMo8h+/hJqDs6+pyPjorE/HmzkZoyAwqF3C599pyc7CaggNAb7De52Ww2Y8vW7fj+0FEAgIdCgYcf+JHNTx9qK8vsFpMt2lub0dmhgU4rh6qt1aF9Gwxd+4gYjQaH963TatDZoYaktVlQ7kdr3iAyd87MG/iZE4x5E4a/q8LxMycM8ybMcM6bo9ilgDAajTjVPbfhYnHJNdtMTkzA2tUrEG3FJGdbubu7W471hr6b2V2LoUc7eY/rxdBqdfjPR58iN69rSVkvL088+tD9gt5zWGSMXWKylY9fADy92iBXeEDp6+fQvt3c3AADIJO5ObxvucIDnl7e8PELEJT70Zo3iMydM/MGfuYEY96E4e+qcPzMCcO8CTOc8yZW+8WLVrUTVUDU1tXjaOYxHMu+9tOGuInjceFiMQAgafKkISke0D0c6gprl0rt2U6hsH352R9qaWnFm/9+D+UVVQCAgAB//PTh+wXvvi2VSkXHJIREIun1z5kxOKNPiUQiKPejNW8QmTtXyBv4mROMeROGv6vC8TMnDPMmzHDMm6PYXEAYjUbL3IaLl/o+bfDz9cHc2alIm5OK4OAg/OzJX9sr1n75+FydON3errLqmta2Nsuxr491E6/7U15RiTffeg8trV33HBsbjYcfuFfwErdERERERK7K6gKirr4BRzKO4djxHKjVvZ82SKVSJE2ehHlzZ2FyYoLDK6bwsFDLcVP3rs8D0Wp1lvfg5+dr1X4O/Tl/4RLeeOs96Loncs9KnYG777hV9OZ4RERERESuyOpvuX/8v3/0eS0sNARz56Ri7qyZvZ4COFpU5NWhUWUVlYO2Ly0rtxxHRwofVnXxUgle3/SuZTjU6pVLsWblMsH3IyIiIiJydTb/mVyp9EZ62mwkT5s6ZHMabDU2NhpKpTdUKjWKS0qh0WrhMcC8hrOFRZbjaVMnC+qztrYe/3r7P9Dr9ZBIJLhjw02YP2+OoHsREREREQ0XNo81UqnUOJNfiILCc2hsbBqaqGwklUqRkjwNAKDT6ZCVndNvW41Gazkvl8sxfWqSzf0ZDAa8/Z+PLJvibbh5HYsHIiIiIhoVrH4CERMdhbLyCgBAVXUNqqpr8M23ezB+XCzmzZ2NlOSpkMvts6+DECuWLUHmsRPQ6/XYvmMX4iaMQ+SYiF5tTCYTPvn8S7SruiZaL1k8H0pl3x2oH3viWcvxH3/3LIKCAnud373vACqrqgEAc2bNxKIF84boXRERERERuRarC4hfPfUzVFRW4dCRTOSczLXs/lxcUoriklJs/nIbZs6YjrQ5szBurOPXrfX388Vtt9yIjz7dAo1Gi+dffh2LFqQjMSEOCoUctXX1OHQ4EyWlXZtyjIuNwYqlS2zuR63uwP4DhwEAMpkMc2fPRFV1jVXXymQyhIWG2NwnEREREZGrsGkORFTkGNx1+y24ef0NyD5+Ekczsy1/iddqdcjIOo6MrOMIDwvFvLmzMDs1ZajivqZ5c2fBYDDgy207oNXqsGffAezZd6BPu8SEONy38U7I5bZvIJd/9hw0Wi3QvaTty69tsvrawIAA/On3Q7+sLRERERHRUBG01qiHQoGF89OwcH4aiktKcfhoFk7lnrHs7lxTW4cvt+3Atm922TveQS2cn4bESfE4mpmNs4VFaG5pgV6vh6+PD2KiozBr5gxMnzZF8P1NJpNd4yUiIiIiGk5Eb1Ywflwsxo+LxYab1yLz2AkczcxGXX0D0P0X+iv2fPc9Ojs1mDsndcg3WAsJDsL6tauwfu0qQde/9tJz/Z5Lm9O1SR4RERER0Whkt93OvLy8cP11C3H9dQtx/sIlHDqSiTP5Z2Hs/ot9S0srtn+7G9/u2oukpETMT5uDxEnx9uqeiIiIiIgcYEi2S46Pm4D4uAlob1fhaGY2MrKy0dTcAgAwmkzIzStAbl4BggIDkJ42G8uXXjcUYRARERERkZ3ZvA+ELXx8lFi5fAn+8Ltn8ciD9yJp8iRIJBLL+camZny9Y/dQhkBERERERHY0JE8gfkgikSBpSiKSpiSiubkFRzKOITP7BNra2h3RPRERERER2YlDCoieAgL8sXbNCqxZtQyn8/JxNOOYo0MgIiIiIiKBHF5AXCGVSpGSPA0pydOcFQIREREREdloSOdAEBERERHRyMICgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrMYCgoiIiIiIrObm7ACGQnVNLbKyc1B47jxaWluh1ergo/RGREQ4UpKnYnZqCmQy2bDri4iIiIjI2UZcAbFz9z7s3LMfRqOx1+vNLa1obmnF2cIiHDh4FA/efw9CQ4KHTV9ERERERK5gRBUQu/buxzc79wIAPDwUWLRgHhLiJsLDwwMNjY3IyDqOc0UXUFlVjVfffBvPPPEYfHyULt8XEREREZGrGDEFRG1tPXZ0f6H39vbC07/4KcJCQyznY2OiMHPGdHyxdTv2HzyCxsYmfLV9JzbetcGl+yIiIiIiciUjZhL1rr37YTKZAAA3rVvT6wt9T+vXrUZIcBAAIPvESTQ0Nrl0X0RERERErmREFBAGgwF5+QUAAE9PT6TOTO63rUwmw7y5swAAJpMJp3PPuGxfRERERESuZkQUEMUlpdBotACACeNi4e428Mis+LiJluOCwiKX7YuIiIiIyNWMiAKiqrrGchwVNWbQ9lGREZBIJF3XVtUM2t5ZfRERERERuZoRUUDU1tVbjgMD/Adt7+bmZlkRSaVWQ6VWu2RfRERERESuZkQUECrV1S/lSqV1S6X69GjX83pX6ouIiIiIyNWMiGVctTqd5XiwOQlXuPVop9XqBmzrjL6urPLkaGazGWazGVptGzIynndo3wZD19wStcGA5zMyHNp3u05nee9Ccj9a8waRuXNm3sDPnGDMmzD8XRWOnzlhmDdhhnPeHEVSVFRkdnYQYr382iacv3AJAPCLxx5GfNyEQa954Z9v4lJxCQDgyZ8/gonjx7lcX0RERERErmZEDGFyd3e3HOsNBquuMfRoJ+9xvSv1RURERETkakZEAaGQyy3Her3eqmt6tlMoFC7ZFxERERGRqxkRBcSVVY4AoL1dZdU1rW1tlmNfH+smQzu6LyIiIiIiVzMiCojwsFDLcVNT86DttVod1OoOAICfny88PT1dsi8iIiIiIlczIgqIqMirG7qVVVQO2r60rNxyHB05+GZwzuqLiIiIiMjVjIgCYmxsNJRKbwBAcUkpNFrtgO3PFhZZjqdNneyyfRERERERuZoRUUBIpVKkJE8DAOh0OmRl5/TbVqPRWs7L5XJMn5rksn0REREREbmaEVFAAMCKZUssS6xu37ELlVXVfdqYTCZ88vmXaFd1TX5esni+5WlCT4898azlX2Nj05D2RUREREQ0nIyInagBwN/PF7fdciM++nQLNBotnn/5dSxakI7EhDgoFHLU1tXj0OFMlJSWAQDGxcZgxdIlLt8XifO7P/wVTc1dk91fe+k5Z4czbDBvwjBvwjBvwjF3wjBvwjBvwo203I2YAgIA5s2dBYPBgC+37YBWq8OefQewZ9+BPu0SE+Jw38Y7IZcL39TNkX05yvkLl/Dya5vscq85s2biR3ffZpd7uTrmTRjmTRjmTTjmThjmTRjmTTjmzvWNqAICABbOT0PipHgczczG2cIiNLe0QK/Xw9fHBzHRUZg1cwamT5sy7PoiIiIiInIFI66AAICQ4CCsX7sK69euEnS9LY+WxPblSmJjovHfzz7Z7/m8M2ex/dvdAICJE8bh9lvX99vWaxTtd8G8CcO8CcO8CcfcCcO8CcO8Ccfcub4RWUCQMAqFHGMiwvs9X1pWYTn2UCgGbDuaMG/CMG/CMG/CMXfCMG/CMG/CMXeub8SswkREREREREOPTyBoyFRV1yDz2AlcKi5BQ0MTOjUauLnJ4KNUWuaITJs6GRKJZMD7nCkoRM7JXJSVV6C1tQ06vR7u7m4I8PdHbEwUUlOSMTkxQXCcJpMJm95+H2cKCgEAU5Mm46H774FMJhN8TzGYN2GYN2GYN+GYO2GYN2GYN+GYO/tjAUFDYts3u7D3u+9hNpt7va7TmdDY1IzGpmacyj2DyZPi8dCPN0Iul/e5h0ajxb/f/QCFRRf6nNNqdaiprUNNbR2OHT+JpMmT8MB99wha7eqzLdssv6xxE8bjgXvvctovK/MmDPMmDPMmHHMnDPMmDPMmHHM3NFhAkN19fzjDsqStm5sbrluYjoSEifBRKqHT6VFaVo69+w+itbUNZ8+dx2dbvsLGu/ousfb5F19ZflnHRIRj0YJ5iAgPg1wuh0qtQmlZBY5kHENzcwvyz57D5i+34e47brUp1l179uNIRhYAIDoqEj956F7LJoGOxrwJw7wJw7wJx9wJw7wJw7wJx9wNHRYQZFcmkwm7dn9n+fmODTchbU5qrzbjx8ViWtJk/OmvL0Cv1+PY8ZNYs2oZAgMCLG06OjpwPOc00L1x31M/fwSeP1hJITEhHgvmzcUL/3wDNbV1yMrOwdo1K+Dr42NVrMeycyyrOISGBOOxR34MTw8PUe9fKOZNGOZNGOZNOOZOGOZNGOZNOOZuaLGAILvq7NQgdWYyVGo1Ojs1mDUz+ZrtgoICkTR5Ek7lnoHZbMaFC8WYM3um5XxdfSNMJhMAYOzYmD6/rFd4e3vhtltuRElpGYICAyCVWrcuQGHReXz02RcAAH9/Pzz+0wfho1QKeMf2wbwJw7wJw7wJx9wJw7wJw7wJx9wNLRYQZFfe3l649aa1VrUNCQ6yHLe2tfU65+5+9aNZWVkNvcEAd7drf1wT4iciIX6i1TGWV1Th3+98CKPRCKW3Nx5/9MFef21wBuZNGOZNGOZNOOZOGOZNGOZNOOZuaLGAoCGn0+mgVndAq9XC1GMSU6dGYznW6w29rgkPC4W/ny9aWttQ39CIl155EzesXo6EuIlWV/XX0tjUjDc2vQONVguFQo6f/uR+hIeFCr7fUGLehGHehGHehGPuhGHehGHehGPu7IcFBA2J2rp6HDycgYLCIjQ2NvVZ/WAwMpkMd952M/719vswmUy4XFqOV994G56enkiIm4C4uAmYFD/Rpl+2jo4OvP6vd9Da1g4A+PG9dyM2Jtrm9zaUmDdhmDdhmDfhmDthmDdhmDfhmLuhwQKC7C4rOweffP4lDAaDFa37lzQlEU8+/gg+/+IrlFdUAQA6OztxOi8fp/Pyge7HjnPnpGLxwnR4KBQD3u/Nf/8HNbV1lp/PFhYhafIkUTHaE/MmDPMmDPMmHHMnDPMmDPMmHHM3dFhAkF2VlVfio0+3WCYcRUWOwfXXLcT4cbFQKr17/VLt2LkX3+7eN+D9xo+Lxa9/+QuUllUg90w+Cs9dQHlFpeUvCPUNjdi+YzcOH8nEww/ci9iYqH7vdan4MiQSCdzd3aDT6XHwcAYS4idi+tQpdnv/QjFvwjBvwjBvwjF3wjBvwjBvwjF3Q4sFBNnVvv0HLb+s48eNxc8fe6jfyUZGk9Hq+8bGRCE2Jgrr1qxER0cHzl8oxqm8M8jNy4deb0BLaxveeOtd/P43v+x3hQR3d3dsvGsDpFIp/v3uhwCAjz7ZgpioSAQE+At6v/bCvAnDvAnDvAnH3AnDvAnDvAnH3A0t4bM/iK7hYnGJ5Xjl8iX9/rKiewKREF5eXkienoT7N96J3/zqSQQHBQIA2ttVyD5xqt/rnnz8J5g5YzpmTJ+K9LTZAAB1Rwfe/eATy//IOAvzJgzzJgzzJhxzJwzzJgzzJhxzN7RYQJBdqVRqy/GY8LB+2+l0OhScLRLdX2hIMFYuv97yc1V1bb9te05QuvWmtZYJT5eKL+PbXQM/uhxqzJswzJswzJtwzJ0wzJswzJtwzN3QYgFBdiXvse16R2dnv+127d2Pzh7nf/j48MDBo/j3ex/i1Tf+PeiKCUqld4/+rRuVJ5fL8eN774Jb918kdu3dj/MXLll17VBg3oRh3oRh3oRj7oRh3oRh3oRj7oYWCwiyq6jIMZbjk6fyrtnm+8MZ2LPve8RNGG95ramppVeby2VlOHX6DAqLLmDvdwf77c9sNuNYdo7l57FjY6yONXJMBG5at9pyn/c+/LTXXywciXkThnkThnkTjrkThnkThnkTjrkbWpxETXY1d04qLlwqBgDs+e576A16JE1OhJubDDW19cg8dgLFJZeROCkey69fjJdf2wQAyMsvwImTpxEcFITIMeFYvWIp8s6chU6nw7ZvdqLo/AWkzJiOkOAgeHl5QqfTo7auDseOn8SFi139RY6JsHkFg8UL01FYdAH5BYVobW3DBx9/jkceug8SiWQIstM/5k0Y5k0Y5k045k4Y5k0Y5k045m5osYAgu5ozKwX5BYU4lXsGJpMJ3x04jO8OHO7VJj5uAh647264yWRQKr2hUqmh1erw7vufAAD++LtnERYagp88eC/e/c/HUKnVOHf+Is6dv9hvv+PGxuCh+zdaHgHaYuOdG/B/f38Jra1tyD97Dvu/P4zrr1so4N0Lx7wJw7wJw7wJx9wJw7wJw7wJx9wNLRYQZFcSiQQ/vvcuZB47jqzsHFRV18CgN8DX1xeRY8IxZ/ZMTJ86xbL9+2M/eQBbtm5HZWUVJFIpoqPGwMPDAwAwKX4i/vd3v8Kx7BycPXce1dW1aFepYDAYoJDL4e/vh+joSKQkT8PUKYmCq3Sl0hs/uvt2y/jGr7/ZhbiJ4xET3f8azvbGvAnDvAnDvAnH3AnDvAnDvAnH3A0tSVFRkW17ehMRERER0ajFSdRERERERGQ1FhBERERERGQ1FhBERERERGQ1FhBERERERGQ1FhBERERERGQ1FhBERERERGQ1FhBERERERGQ1FhBERERERGQ1FhBERERERGQ1FhBERERERGQ1FhBERERERGQ1N2cHQKNbdU0tsrJzUHjuPFpaW6HV6uCj9EZERDhSkqdidmoKZDKZs8N0acUll/GfDz9DQ2MTAOCeOzcgbU6qs8NyWReLS3AsOwfFJaVoaWmF3mCAp4cHQkNDkBA3AelpsxEQ4O/sMF2KyWTC6bx8nDydh/LySrS1t8NoNMHT0wNhoSGImzgeaXNmITgo0NmhDhutbe34819fgLqjA+DvrcXFSyV48ZU3bbomODgIf/jtr4YspuGotKwCGVnHceHiJbS0tsJkMsHX1xdjY6KRNicViZPinR2iSzh/4RJefm2ToGsDAwLwp9//2u4xDRcsIMhpdu7eh5179sNoNPZ6vbmlFc0trThbWIQDB4/iwfvvQWhIsNPidFVGoxE7du3F3u8OwmQyOTscl9ep0eDDjzfjdF5+n3MqtRqqEjWKSy5j34GDuGX9WixIn+uUOF1NbW093nn/Y1RUVvU5p1KpoVKpcan4MvZ9dxA3rF6OZdcvdkqcw80nn31hKR7oqs7OTmeHMKyZTCZs/fpbHDh4BGazude5xsYmNDY2IedULmbOmIZ777mDf6AjwVhAkFPs2rsf3+zcCwDw8FBg0YJ5SIibCA8PDzQ0NiIj6zjOFV1AZVU1Xn3zbTzzxGPw8VE6O2yXUVNTi/c+/AzlFZUAAKlUyiJiAHqDAa+8/hZKyyoAAL6+Pli8IB0TJoyFQi5HY2Mzsk+cRO6ZAuj1Bny6eSsUCgVmp85wduhO1djUjBf++QZUajUAICw0BIsXpiM8LBQeHgo0NDbhRM5p5J4pgMFoxFfbd0Imk2HJ4gXODt2lZWXn4ExBobPDcEkdnRrL8bIlizB7Vsqg17i58avMFZ9t+QpHMo4BAEKCg3DdovmIjoqE0WhEyeUy7P/+MNpVKuScyoOXlxfu2HCTs0N2qtiYaPz3s09a3b6qugbvvv8JAGBSwsQhjMz18beOHK62th47uosHb28vPP2LnyIsNMRyPjYmCjNnTMcXW7dj/8EjaGxswlfbd2LjXRucGLXrOHw0C198tR16vQFSqRSrll+PuoYGHD9xytmhuazde/dbioegwAA889TP4KO8WpBGR0UieXoSdu3Zj+3f7gYAfLntG8xIngr3Ufzl5PMtX1mKhxnTp+LH994FqfTq1LmY6CikJE/D7r0H8PWOXQCA7d/uRtrcWfD08HBa3K6spaUVW7ZuBwD4+/mipbXN2SG5lI6Oq08gQkODMSYi3KnxDCcnT+dZioe4iePxyEP3wUOhsJyPmzgeM5Kn4h8vvgaVWo0jGceweME8hIeHOTFq51Io5FZ/xkwmEz76dAsAQKn0xvq1q4c4OtfGSdTkcLv27rf8tfymdWt6FQ89rV+3GiHBQQCA7BMnLWP8R7uDhzOg1xsQFBiAJx9/BKtXLoVUwl/l/phMJhw+kmX5+Ud3396reOhp+dLFCAoMAAC0t6tw8VKxw+J0Nc0tLSgoLAK6nxJuvOu2XsVDT8uuX4QAfz8AgE6nx/nzlxwa63Dy0WdfoLOzE56ennxScw09hzB5eno6NZbhxGg0YvuOrj9+eHgo8MC9d/cqHq4ICQ7CuhtWIHVmMm5YvRySfn6nqa/vDx3F5dJyAMAt62+At7eXs0NyqtH7pzVyCoPBgLz8AqD7Pw6pM5P7bSuTyTBv7ixs+2ZX1yTO3DNYumSRA6N1Xakpybhjw3r+B9YKjU3NkMqkkEql8PbywoTxY/ttK5VKMX78WDQ2NQMAamrqkZgwOicbqtUdmD5tCtTqDkSNiYBCIe+3rVQqxdjYGDS3nAEANLe2OjDS4SMjKxtnu4uydWtWwN3d3dkhuZwOFhCCnL94CXX1DQCABelpAw75TU+bg/S0OQ6MbvhrbmnB9m/3AAAmjB+L2amDD60b6VhAkEMVl5RCo9ECACaMix10eEh83NUxhgWFRSwgAGy4eR0S4kf32EtbhAQH4S9//C1MJhO0Wi0kEsmA7WXSq5MK9Xq9AyJ0TVGRY/DQ/Rutbm8yX52Do5Dzi/EPNTe34IuvvgEAJMRPxIL0ucjKznF2WC6n1xMIDoOz2uncAsvxjOlJTo1lJPrq653Q6XSQSqW47ZYbnR2OS2ABQQ5VVV1jOY6KGjNo+6jICEgkEpjNZlRV1QzafjRg8SCMVCq16i+a9Q0NluPAQC7nag29Xo/i4lLLzxPGj3NqPK7ow0+3QKPRwkOhwN133DpoITta9ZwD4enJAsJaxSWXge4J5dFRkZbXzWYz2lUqaDRa+Ci9+VRHgOKSyzhx8jQAIG1OKqIiB//uMhqwgCCHqq2rtxwHWrHWvpubG3x8lGhra+9aalOthtLbe4ijpNGqrr4BxSVdX4RlMtmoHb5kC6PRiE8+/xLtKhUAYHZqCpdd/oHDR7NwrugCAODm9Wss82yor84eqzDJZDIcOpKJ3DMFqKyqRkdHJ9zd3RDg74+4ieOxIH0uJ1l3z/O6MnwpODgQUqkUtXX12LPvAE7n5kOj1VrahoeHIm3OLCyan8YhdFa68uRQLpdjzarlzg7HZbCAIIdSqdSWY2U/E1l/yEfZVUBcuZ4FBA0Fs9mMTzdvtaydnp42e9RPkvshrVaHxqYmmM1mqNUdKC2vQGbWccsfBlJTknHnbTc7O0yX0tjYhK1f7wAAJE6K59jzQfScA/H3F19Fe7uq13mj0YjqmlpU19Ti8NEsLFk8H+vXru53gv9o0NzSCoPBAABQenvjTP5ZvPP+J9DpdH3a1tTUYeu2Hcg5eRqPPnw/fH18nBDx8HGmoNAycXrxwnT4+TJfV7CAIIfS9vgfNGuXx+y5xrdW2/d/EInsYcvW7Sg6fxHo3mH0Bv6lqY/SsvI+u7Z6eXkiPW025s6eifHj+p+gPhqZzWZ8+OkWaLU6eHp44O47bnF2SC6vZwHR3q5CbEw05s6eiajICLi5uaG+oRE5J3ORe6YAZrMZ3x04DK1WN6oLV43m6lMblUqN9z78FHK5O9avXYVpSZPh6+uDdpUa+QWF+GbnHrS3q1BWXom33vkQTz7+k1FdfA3m211dS87L5XJcfx1XTeuJBQQ5VM9JqdZu/tOznd4weie10tAwm83YsnU7vj90FADgoVDg4Qd+xKcPVuro6MSp3DPQanWQy+UcH9zDwcMZOH+ha0nbW25aiwB/zqkZjHv3sFWpRILly5Zg8YJ5vc7HRHftE5R94hTe/+gzmM1mHMk4hmlJkzFl8iSnxe1M2h5DlGpq66BUeuOZJ3+G4KBAy+v+fr6YP28OEhPi8NwLr0Ct7rCM7eeKQtd2rugCysq7NmtNTZnO0Q8/wAKCHKrnmEt99yPXwRh6tJNzzCbZkVarw38++hS5eV0rmHh5eeLRh+5HtBUT/Eej+LgJeO2l52AymdDZqUF1bS1OnT6DI0ezcOLkaZw8nYc7NqznMB0A9Q2N2PbNTgBA0pREpM1JdXZIw8Lv//sZq9rNTp2BsrJyHOgu/PcdODRqC4gfWr1iaa/ioaegoECsXrkMm7/YBgDIPHaCBUQ/Dh7OsBwvSE9zaiyuiM+tyKEU8qtryVu7RGbPdoprbIxDJERLSytefOUNS/EQEOCPJx9/BOPHxTo7NJcnlUrh7e2FiePHYcPN6/D0E4/B08MDJpMJn3y+1bIizGhlMpnwwcebodPp4eXlibtG8fCaobR4Ybrl+FLx5WuO+R8NfvjfxalJiQO2T0meajkuuVxm2diVrmpuaUH+2XMAgNiYKMRERw56zWjDAoIcqufmNj+cHNef1rY2y7HvAJvjEFmrvKISf3/xVZRXVAEAxsZG45knf8YVXQSKiY7EyhXXA91DwvZ8d9DZITnV94eO4lJxCQDgjltvgp+fr7NDGpGCg4Msy5IajUa0tLYNes1I5PWDpVn9fAf+vPn6+MDLq+savV7fa94Jdck5lWcprJKnTR20/WjEIUzkUOFhoZbjpu7dfgei1eqgVncAAPz8fLmGNYl2/sIlvPHWe5a/Vs5KnYG777jV6kn9dG1Jkydh67au1YZG8xOIpuZmfL1jNwAgckwEJFIJTp7Ou2bbsvKKXsdXdvuOCA9DRHiYgyIe3uRyd8vmcwYrh8WONP7+flAo5JZFRvR6A2Qy2YDXyN3d0YGuvBkNRofEOZyc6vE7mzSFQ+Ouhf/FJIfqOcGyrKJy0PalZeWW42hOziSRLl4qweub3rUMi1u9cinWrFzm7LBcUlV1DerqGtDa1oaEuAkIH+QLrUePXYO1Gu2AbUeyhoYmy+ersqoab7/3kVXXHTqSiUNHMoHuMexrVvFzORiTyWT5AxMAeI/SSa4SiQRjwsNRUloGdO9nM9CQG7PZ3OupgxcXjOhFpVajtKyruA8MCOCT6X6wgCCHGhsbDaXSGyqVGsUlpdBou3Zm7c/ZwiLL8bSpkx0UJY1EtbX1+Nfb/4Fer4dEIsEdG27C/Hmc7NufAwePICPrOGBlodXc3GI5VipH5xc5EufCpWIUFV1EU3MzJicmIDUlecD2pWUVlqcOvr4+o3qN/imTEywFxLmi8wMWEDW1ddDpuorc0JBgPn39gYuXSiz7AcXGRjk7HJfFTw05lFQqRUryNBw6kgmdToes7Jw+y/RdodFokZWdA3SvwTx9apKDo6WRwmAw4O3/fISOjq6/um24eR2Lh0FMio+zFBDZJ05h5bIlAw6LyD1TYDkeOzbGITG6oisrVVkj89gJfPjJZgDAPXduGPUrNdXXN2Dnnu8AAKXlFUhJnjbgHgUHDh6xHE+dMvDE4ZFuZkoyduzaB7PZjINHMrFoQbplSNwPZWRmW44TJ8U7MMrhoeRymeU4kk8f+sVJ1ORwK5YtsSznun3HLlRWVfdp07Way5doV3VNtF6yeD7/qkmC7d53wPI5mzNrJhb1U7TSVdOnTUFAQNe+BQ0Njdj85df9rtZy4VIxvj909ctc2pxZDouTRo6ZM5Ita+3X1NRh85df99v24OEM5JzKBbr3Clp+/WKHxemKQkOCLQVoS0srPvxk8zV/X8+dv4jvu5cnlUqlvVayoi41tXWW4zEREU6NxZXxCQQ5nL+fL2675UZ89OkWaDRaPP/y61i0IB2JCXFQKOSoravHocOZlsex42JjsGLpEmeH7RLa21WWoqqnzh7jWVtb21BVXdPrvEwmQ1hoiENidDVqdQf2HzgMdOdh7uyZffLTn9GcNzc3N/zortvw2ptvw2A04vDRLJSWVSA9bTYix4TDzc0NLS2tOFNQiMxjJyxfVlJTkpHE9fhJAIVCjrtuvwVvvfsBzGYzDh3JRMnlMixIn4PQkBDI5XLU1zcgO+cUCrqX2ASAu267GcHBQU6N3RXcuHYVLhVfRm1dPU6ezkNjUxOuWzQfYaGh6OjsxJn8szh8NMvyu7ruhpUIDQl2dtgup66u3nLsO4qHxQ1GUlRUZHZ2EDQ6HTqSiS+37RhwP4jEhDjct/FOPn3otmPnXny7e5/N1wUGBOBPv//1kMTk6o4dP4n3P/pM0LWjOW9XFJ2/iA8+2dxrjkN/Fs5Pwy3rb7B6l/nRjkOYru10bj4+/vyLXhOkr8XLyxN3334rkqdzeOsVzc0t+Pd7H+JyaXm/baRSKdauXoHlS0f3U5v+/Oo3f4C6o+uz97tfPzXoAhKjFf9Xnpxm4fw0JE6Kx9HMbJwtLEJzSwv0ej18fXwQEx2FWTNnYPq0Kc4Ok4Y5bpIkTkL8RPzPf/0SOadycabgLCoqqtCuUsFgMMLTwwPBwUGYMH4s0uakcrUSsovk6UmIj5uAY8dzUHD2HKpqaqFWd0AiAby8vBA5JgKTJyUgbU4qPDy4uWhPAQH+ePoXP0XOqVzknMxFeWUVVO0quLm7ITAgAJPiJ2LhgnkI4RObfmm0V1eR67m6HPXGJxBERERERGQ1TqImIiIiIiKrsYAgIiIiIiKrsYAgIiIiIiKrsYAgIiIiIiKrsYAgIiIiIiKrsYAgIiIiIiKrsYAgIiIiIiKrsYAgIiIiIiKrsYAgIiIiIiKrsYAgIiIiIiKrsYAg+v/t3Wl0VOUdx/HvZJnJBiQkQMgKIRshyBI2pSIURZRqiwUVEJFNUA/20Hq0xx67edqj7aliq0UpgguCIlJRVPblBIEAYUlCVgiQQEgCSZiQyTKZTPpCGIkQGIZlUvl9Xj137jPP/d95M/Obe5/nioiIiIjTFCBERERERMRpXu4uQERE5Hp56U+vUFlVBcBb8151dzkiIj9KChAiIreg/ILDvPHWgusy1uCBKTw+6eHrMtb/i4qKSn7/8ncBxWg08vrfXr6oz5U+Yw8PD/x8ffHz8yUkuCMxMd1IiOtBTPduN7R2EZFrpQAhIiLiBna7nRqLhRqLhfJTp8nOzWc1EBEexqi7h5PSr4+7SxQRuSQFCBGRW1B0VCS/e2Fuq/szMrP58uu1AMT26M4j437Ral8/X98bUuOPSaeQYJ6c/niL15qamrDU1mE+Y+bwkaMczM7ljLma4ydKWPT+UjKyspkw/iF8fExuq1tE5FIUIEREbkEmk5GwrqGt7j9WdNzR9jGZLttXrszLy+uyn+HgQSk0NTWxc1c6K1etpr6+gT3p+zGbq5nz1Aw8PT1var0iIpejVZhERETaAE9PT4bePogXfvMsQYEdACg4VMinK79wd2kiIi3oCoSIiFwXJSdL2ZG2h8OFRzh9upK6+nq8vDxpFxBAVGQEA1P6cVvvJAwGw2XHyTyYQ/reAxQVH8dsrsba2Ii3txdBgYFER0UwoH9fknomuFyn3W5nwbsfkHkwB4DeyUnMnPpYm/mXv3OnEGZOm8w/3phPU1MT27ancdedd9A1tIu7SxMRAQUIERG5HlatXsP6jVtobm5u8brVaqeisoqKyir2HcgkKTGemdMmYzQaLxqjvr6BhYs/JCev4KJ9DQ1WSsvKKS0rJ233XpKTEpn+xGMYjd5XXesnK1Y5wkNcjximT5nYZsLDedFRkQwa0I8daXtobm5m3YYtTHnsEXeXJSICChAiInKttqRuZ92GzXDuXv8Rw4aSkBBLu4AArNZGjhUVs37TVszmarJz8/lkxedMnnjxsq/LP/vcER7CuoY6/nU3Go3UWGo4VnScbdvTqKo6Q1Z2Lp+uXMWkR8ddVa1r1m1i2/adAERGhDNr5hS8va8+hNwMd915BzvS9gCQnZNHc3PzFa/eiIjcDAoQIiLiMrvdzpq1Gx3bj44fy+2DB7ToE9M9mtuSk3j5lddobGwkbfdextx3Dx2Dghx9amtr2Z2+H4DADu359bOz8f3B6k49E+K5844hvPbP+ZSWlbNzVzoPjLmX9u3aOVVr2q50x8pSnTuF8Mzsafj6+FzT+d9IEeFh+Pn5UltbR43FwomSk0SEh7m7LBERBQgREXFdXV09A1L6UmOxUFdXz8CUvpfsFxzckeSkRPYdyKS5uZmCgkIGD0px7C8/VYHdbgegW7eoi8LDef7+fjz8y59z5FgRwR2D8PBwbi2QnLx8PvrkMwACAzsw5+kZtAsIcOGMbx6DwUBY11AOHT4CQEVFlQKEiLQJChAiIuIyf38/xo19wKm+nUKCHW1zdXWLfd7e338dnThxkkabDW+vS39FJcTHkhAf63SNxcdLWLhoCU1NTQT4+zPnqRktrn60Zf7+fo52jcXi1lpERM5TgBARkevKarVisdTS0NCA/YJJ1XX19Y52Y6OtxXtCu3QmsEN7zpirOXW6gnn/epuf3T+KhLhYp68yXEpFZRXzFyyivqEBk8nI07OmEtqls8vj3WwXTja3Wq1urUVE5DwFCBERuWZl5afYmrqdgzl5VFRUXrQa05V4enoy4eGHeOfdD7Db7Rw9Vsyb89/F19eXhLgexMX1IDE+9qp+/NfW1vLvdxZhrj4LwLQpk4iOirzqc3OnhvoGR9tkunjlKhERd1CAEBGRa7JzVzrLlq/EZrM50bt1yb16MnfObJZ/9jnFx0sAqKurY39GFvszsuDcbVBDBg9g+LCh+JhMlx3v7YXvU1pW7tjOzskjOSnxmmq82SqrzjjagR06uLUWEZHzFCBERMRlRcUn+OjjFY4J0BHhYYwcMYyY7tEEBPi3+JH/1Tfr+XrthsuOF9M9mt8+9yuOFR3nQGYWObkFFB8/4biicep0BV9+tZbUbTt4cvoUoqMiWh3rcOFRDAYD3t5eWK2NbE3dTkJ8LH1697pu538jWa1WSkvLHNtdu+pBciLSNihAiIiIyzZs2uoIDzHdu/HsMzNbnfzcZG9yetzoqAiioyJ4cMxoamtryS8oZF9GJgcysmhstHHGXM38/yzmDy8+1+qKTd7e3kyeOB4PDw8WLl4CwEfLVhAVEU5QUKBL53szZefmY2v67jPr0rkTQYFtv2YRuTW4PjNNRERueYcKjzjao0f9tNXwwLkJza7w8/Ojb59kpk6ewIvPzyUkuCMAZ8/WsGvPvlbfN3fOLFL69aFfn94MvX0QAJbaWhZ/uMwRetqyranbHe3WlscVEXEHBQgREXFZTc33S4uGhbZ+i43VauVgdt41H69zpxBGjxrp2C45WdZq3wsnTI8b+4BjAvbhwqN8vebyt1K5W/q+A+QXHAbAx2TiJ0OHuLskEREHBQgREXGZ0dvb0a6tq2u135r1m6i7YP8Pb2favPVbFr63hDfnL7ziCk4BAf4XHN+5O3GNRiPTpkzE69wVkjXrNzl+oLc1x4qKWXruoXcAY+67p80/9E5Ebi0KECIi4rILn4y8d1/GJftsSd3Oug1biOsR43itsvJMiz5Hi4rYtz+TnLwC1m/c2urxmpubSduV7tju1i3K6VrDw7oy9sH7HeO8t+TjFldQ3M1ut5P67U7mvbmA+nPLt/btk8yIu37i7tJERFrQJGoREXHZkMEDKDhcCMC6jVtotDWSnNQTLy9PSstOsSNtD4VHjtIzMZ5RI4fzxlsLAMjIOsievfsJCQ4mPCyU+++9m4zMbKxWK6tWf0NefgH9+/WhU0gwfn6+WK2NlJWXk7Z7LwWHvjteeFjXq15RafiwoeTkFZB1MAezuZoPly5n9swnMBgMN+DT+Z7NZqPkZOklXzebqzlyrIj0vQc4XVHp2DdwQD8mTxh/w2sTEblaChAiIuKywQP7k3Uwh30HMrHb7WzcnMrGzakt+sTH9WD6E5Pw8vQkIMCfmhoLDQ1WFn+wDIA/v/QCXTp3YtaMKSx+fyk1Fgu5+YfIzT/U6nG7d4ti5tTJjluSrsbkCeP569/nYTZXk5Wdy6YtqYwcMcyFs3feqdMV/OXV153qG9wxiAfHjGaAJk6LSBulACEiIi4zGAxMmzKRHWm72bkrnZKTpdgabbRv357wsFAGD0qhT+9eeHh8d8fsM7Oms+K/X3LiRAkGDw8iI8Lw8fEBIDE+lj++9Dxpu9LJzs3n5MkyztbUYLPZMBmNBAZ2IDIynP59b6N3r54u/zMfEODP45Meccy3+GL1GuJiY4iKbP2ZEjeKh4cHJpOJjkGBREdFkNyrJ8lJiXh6et70WkREnGXIy8u7/Gw1ERERERGRczSJWkREREREnKYAISIiIiIiTlOAEBERERERpylAiIiIiIiI0xQgRERERETEaQoQIiIiIiLiNAUIERERERFxmgKEiIiIiIg4TQFCREREREScpgAhIiIiIiJOU4AQERERERGnKUCIiIiIiIjTFCBERERERMRpChAiIiIiIuI0BQgREREREXGaAoSIiIiIiDjtf3qv2cbB7izMAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxAAAAJICAYAAADxUwLTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAbbhJREFUeJzt3Xd0VNe99vFnVEa90YSQhGiSEL2IXo1xiR077h33ksTXdmzHcW5ucvPe5KY4uXGJa9zjXjA2xtg0g+lC9CIJgRCIooJQrzMjzbx/AGPJKpzRjEYCvp+1WDmas/fZv8HO8nl0zt7blJ2d7RAAAAAAGODT1QUAAAAAOHsQIAAAAAAYRoAAAAAAYBgBAgAAAIBhBAgAAAAAhhEgAAAAABhGgAAAAABgGAECAAAAgGEECAAAAACGESAAAAAAGEaAAAAAAGAYAQIAAACAYQQIAAAAAIYRIAAAAAAYRoAAAAAAYJhfVxcAADj3/eXvz+nosXyZzWY987c/qrGxUWnpW5SWvk3HjxfLYrUqIiJcSUMGae4FsxQd3dvZNyNzr9as26ijx/JVVV2j4OAgDRqQoIsunKWBAxJaHa+urk4b0jYrMytbBUXHVVtbK7vdoaDAQPXu3VPJiUM0dfIE9ezZo926LRarNqSla0/mXhUUFqmmukZ+/n6KCA/XoIEJmjB+rJKThnj87wsAujNTdna2o6uLAACc2/7x3EvKPZgns9msv//593r51be0d19Oq22DgoL0yIP3Kz6unz7/8mutWLm61XY+Pj564J7bNWJ4SrPPc3IP6rU331V1dU27Nfn5+uqG667StCkTWz2/b/8BvfnOB6qqqm73OiNHDNOd825SYEBAu+0A4FzBEwgAQKczmb5/Y/bLxUu0LydX06dO1rgxIxUUFKTjx4u1ZPlKFRQWqa6uTp9/uViTUsdpxcrVGj1quKZOmqCIiHCVlVfo21VrlHPgoOx2uz75bKGGDxsqk8kkSaqurtGrr7+jmtpaSdLE1HEaPWq4ekRFyuFwqLy8UrszMpW+ZbsaGhv14ScL1KdPLyUOHtSs3v0HcvXiK2+oobFRJpNJE8aP1dgxIxUVGSGLxapDh49ozdoNKikt0+49mXrltbf18M/vk48PbwYDOPcRIAAAnc7n1A2+zWbTqtXrddvN12vShHHO8/3jY5WUNFi//+NTslptyt6Xo0N5h3XBzGm67porne3i42KVMjRJ//O/f1NZeYVKSst0+MhRJfSPlyRt2bbDGR5mTp+iG6+7qlkdCf2l0aOGa+zokXrp1bfkcDi04tvVzQKEzWbTO+994gwP9901T6NHDW92nSGDB2ralIl6/qXXlXf4iPbn5Gr9xnTNmDa5k/4GAaD74FclAACvcTgcShoyqFl4OC08LEyJQwY7f/b389eVP/5Ri3b+fn4aOWKY8+dj+YXO48Ki487jYSnJbdYxfNhQXf2Ty3Xd1Vdq1oypzc5t3b5LpWVlkqQZ0ya3CA+nBQUG6rabr3M+/Vi9dkOb4wHAuYQAAQDwqtTxY9o816dXT+fxiOEpMpv9W2/Xu5fzuKbm+7kO/v7ftz+Ud7jdOuZeMFMXzJrWImhs37HLeTwxtWXQaapfTF/Fx/WTJBUUFqmkpLTd9gBwLiBAAAC8KrZfTJvnAgMDnccxMdFttgtoMmHZarM5j5uuiLR0+SrNX/Clik+UuFTfobwjzuPoPr3abStJ/ePjnMdHjua7NBYAnI2YAwEA8KqgoKA2z51+HUiSgoMCDbVTk7UEh6ckK3X8GG3ZukMOh0Or1qzXqjXrFd2nt5KThihxyCANTRqi4ODgVq9rtVpV3eSJxhO/+R8XvplUUVnpUnsAOBsRIAAAXuXT9Oa/HU1XbjLKZDLpjltvVFy/GC1d8Z3q6uokSUXHi1V0vFhr1m2Uj4+PkhIH64KZ01osAVtXV+/ymM3617vXHwDOBgQIAMA5xcfHRxddOFuzZkzTnsws7cnYq+x9+1VecfLpgN1u197s/dqbvV+jRw7XnfNuds61MPl8H258fX31618+7NLYYaGhHv42AND9ECAAAOcks9lf48aM0rgxo6RTKzRl7d2nzVt3KO/wyXkOO3dn6LMvvtLNN1wtnVpZ6bTGxkb17t1L/n78pxIAmmISNQDgvNA3uo8umDVdv3rsP3TrTdc5P9+Qlu581cnf318R4WHOc8XFJ7qkVgDozggQAIDzztTJE5ybx9ntdhUWFTvPnd6UTpKy9x3okvoAoDsjQAAAzgllZeVasPArPffiq/puzfoztg8J/X4lpqb7TYw99cqTJK3bkKbGxsY2r+FwOPT0P1/Wy6++pXUbNrlVPwCcLQgQAIBzQmBggNasS9O+/Qf0zbJvlV9Q2Gbb8vIKZWfnSKeWle3Tp7fz3NgxI9WzR5R0at7EgoWL5XA4Wr3Owq+W6EDuIe3J3Kusvfs8/p0AoDtiZhgA4JwQFBSkSy+ao0VfL1V1dY3+8exLSh0/VilDExURHiZ/f39VV9foUN4RrVm3wbnk6iVzZzebKO3v56fbb71Rz7/0mhoaG/XdmvU6cjRf06dOVHSfPrLarDp+/ITWb0x3TsYODQnRtVf/uMu+OwB4EwECAHDOuOSiC1RdU6Pv1qxXvcWidRvStG5DWqttfXx8dMncC3TRhbNbnBsyeKAe/Ok9evOdD1RVVa0DuQd1IPdgq9fp07uX7r3rNvWIivL49wGA7ogAAQA4Z5hMJl139RWaMilVmzZv1YHcQzpxotT5tCEoMFC9e/dU4uBBmjwpVdFNXl36oaTEwfrD757UhrTN2pO5V/kFhaqprpFMJoWFhSoutp9GjxyuCePHyI+lXgGcR0zZ2dmtv9gJAAAAAD/AJGoAAAAAhhEgAAAAABhGgAAAAABgGAECAAAAgGEECAAAAACGESAAAAAAGEaAAAAAAGAYO9/AJUlJSV1dAgAAwDnDbrcrJyenq8twCU8gAAAAABhGgAAAAABgGAECAAAAgGEECAAAAACGESAAAAAAGEaAAAAAAGAYAQIAAACAYQQIAAAAAIaxkRwAAEAnqa+vV3FxcVeXgS7Su3dvBQYGdnUZHkeAAAAA6AT19fU6fvy4YmNj5evr29XlwMsaGxt17Ngx9enT55wLEbzCBAAA0AmKi4sJD+cxX19fxcbGnpNPoAgQAAAAnYTwcH47V//5EyAAAAAAGEaAAAAAAGAYk6gBAADgkr89/U8tX7FKt9x4ne6649ZWzxcVHdc/nvrfTq/lnfc+0rsffNzm+YvnztETjz3k/LmyqkqffrZQG9PSVVhUJD8/P0VH99HM6VN1zU9+rKCgIElSYdFxzbvrAT384AO64vJLW1x36fKV+r9nntcb/3pe/ePjOunbdU8ECAAAAG+7+GIpL69ra0hIkJYt63B3Hx8ffbpgoS6+aI5i+8V4tDRXXH/tT/Tjyy5p8fmXi7/RBx/N19w5s5yfFRQU6on//G+ZzWbddsuNSklOlMVq1fYdu/TuBx/ru9Xr9I+n/qjw8HAvf4uzCwECAADA2/LypH37uroKtwxLSVZdXb1efOV1/fkPv+uyOoKCgpxPDU7LO3xEn362UNdcdYXGjhnl/PzPTz0tXz8/PfePvyosLNT5+YCE/ho9aoQefOQJzf/8S919x21e/Q5nGwIEAAAAXObj46OHfn6/Hn3iN1q/YZOmTZ3UZtuly1fqs8+/1NFj+fL399fwlGTdfec8DRk8UJL09ZJleuafL+u1l5/T62++o5279igoOEjTp07Wgz+916XVjGw2m/7yt2fUL6av7r7z+yCwe0+m9u7br988+Viz8HDaoIED9Oa/nldMTF+X/y7ON0yiBgAAQIcMHzZUcy+crVdee1MWi6XVNkuWfav/e+Z5TZ6Uqpef/4f++r+/l9Vm0y9//VudKCmVJPn6nvyd9nMvvKKLL5qj1175p66/9iotWrxE365a7VJNb73zvg4fOar//NWjMvv7Oz/fsWu3TCaTJqaOa7Mv4cEYnkAAAACgw+67+3bddd+D+vCTz3TnvFtanP9k/ucaM2pEs9eCnvzlI7rtzge0dNm3uvXm652fz5o5XTOnT5UkXXf1lXrv/Y+1N3u/Lp47x1AtO3bu1vwFX+q+e+7QoIEDmp0rKSlVSEiwQkJCXPp+L7/6pl59498tPm9sbHTpOucSAgQAAAA6LCoyUnfcdrNee/MdXTz3AvWL+X5CdU1trY4cPabZM6c369O7Vy/16d1LOQdym30+bGiy89hkMik0NFRV1dWG6qiurtHfnv6nRo0cruuuvrLFeT8/PzkcDpe/3y03XqcLZs9o8fm69Wl6/a13XL7euYAAAQAAALdc+eMfacmyb/XiK2/oT//zW+fntbW1ktTqnIPQ0FDV1tY1+ywwMKDZzyaTpFP3/B98PF8ffvyZ89yFF8zULx76mfPn5154RbW1tfrV44/IZDK1GK9Xzx6qqalVRUWlIiKMr7IUERHe6ipTkZERhq9xriFAAAAAwC2+vr76j5/dp8d+9V/akJbu/Dwk+OTrQlVVLZ8iVFZWKaZvtOExfnzZJZo1Y5rz5+Dg71deWv7td/puzTr95xOPqk/vXq32Hz9ujN54+z2t35imyy69uNU26zakKS62nwYk9Ddc1/mISdQAAABw28gRw3ThBbP08qtvyma1Sadu8hP6x2v3noxmbQsKi3SipETJSYmGrx8eFqbYfjHOP1GRkdKpDd9eePk1zZ45XXMumNlm/8QhgzV61Aj9+92PnJO3mzp4KE9P/d9z+vKrb1z41ucnAgQAAAA84v577lBlZZXWb0hzfnbj9ddox649evvdD3T4yFHtycjSX/72tMLDw3TpxRe6NZ7dbtdT//es/Px8ddstN6i0tKzVP6f96rGHFRQUqIcfe1JLlq1QfkGB8g4f0ecLv9LjT/5WyUlDdN/dt7tV0/mAV5gAAADgET16ROn2W2/UK6+95fzsogtnS3Lok/lf6JNPP5c5wKzRI0foiccedmkuQmuOF5/QnowsSdK9P324zXbLv/5cktSnT2+98Ozf9fnCr/TZ54v00r/ekK+vr+JiY3XnvFt0+Y8udmnPifOVKTs72/Xp6DhvJSUldXUJAACcFY4cOaL4+PjWT1588cndqLtSQoK0bFnX1nAeaPffg1NPUXJycrxak7t4AgEAAOBt3LjjLMYcCAAAAACGESAAAAAAGEaAAAAAAGAYAQIAAACAYQQIAAAAAIYRIAAAAAAYRoAAAAAAYBgBAgAAAIBhBAgAAAAAhhEgAAAAABjm19UFAAAAnG8uvljKy+vaGhISpGXLOtb3tjvvV9Hx4jbP/99Tf9TokSMkSXuz9+nTzxZqT2aWKiurFB4epsGDBurHl12iqZMnOvu8895HeveDj7X4i49lNptbXPPxJ38rq9Wm5595qmNFw2MIEAAAAF6Wlyft29fVVXTcC8/9XfZGe7PPGu2N+s/f/kF2h11DkxIlSV8vWabnXviXLpg1Xb/7z1+qd69eOlFSqq+XLNfv//AX3XT9Nbrnrnld9C3QUQQIAAAAuCQyIqLFZ2+/+4GO5RfouX/8VQEBAco9eEj/fPFVXXPVFXrg3jud7aKj+2j4sKGKjIzQJ599obkXzlZC/3gvfwO4gwABAAAAt2Rk7tWHH3+mO+bdrKTEwZKkzxd+paCgQN057+ZW+8y75UZde9UV6tEjysvVwl0ECAAAAHRYbW2dnvq/Z5UyNEk3Xne18/Mdu/ZozKiRCggIaLVfYGCAAgNbP4fujQABAACADnvhlddUUVGpp/78P/L19XV+XlJS2myStFHX3nRHq59brVYlJQ5xq1Z4BgECAAAAHbJm3QYtX7FKv3z0IcX0jW52zs/PVw6Hw+VrvvDs3+Tn1/IW9a9/e8atWuE5BAgAAAC47ERJqZ59/mVNnzpZl1w0p8X5Xj17qqCg0OXrxvSNbnUZV3OAWVarrcP1wnMIEGdQUFiktPStytq7T+UVFbJYrAoLDVFMTF+NGzNSE1PHNXtc153Hqqis0p/++rRqamslSbfdfL2mTEr1SO0AAOD84XA49Pd//FP+/v569OGftdpm/LgxWrJ0haqraxQaGtLifGNjoxZ9vVSXzL1AQUFBXqgankKAaMc3S1fom2Ur1djY2OzzsvIKlZVXKDMrW6tWr9e9d92mPr17dfuxPvz4M2d4AAAA6KjPPv9S23bs1J//8DuFh4e32uaKyy/V10uW66VX39CvHnu4xfn3P/xU73/0qZISB2vY0GQvVA1PIUC0Ycnylfrqm+XSqVUCZs2YquTEIQoMDNSJkhJtSNusvdn7dSy/QC+88oae+MWDCgsL7bZjpaVv1e6MrA7VBwAAcNrBg3l689/v64JZMzR40ECVlpa1aBMQYFb/+Dj94qGf6unnXlJVZZWuueoKxfaL0YmSEn31zTJ9u3K1Hrj3TsLDWYgA0YqiomItPnVDHxISrMcf+bmi+/R2nk/oH6fxY0frs88XaeXqdSopKdUXi77RvFuu75ZjlZdXaP7niyRJkRHhKq+odLlOAAAASVq7fqNsNptWrV6rVavXttrmorkX6FePPayLLrxA/ePj9fnCRfr7M8+rvLxCEeHhGpaSrKf/9icNHzbU6/XDfQSIVixZvlJ2+8nt2a++8vJmN/RNXXXlZdqdkaXiEyVK37JNP7rkQvXq2aPbjfX+x5+prq5OQUFBmjN7hhYsXOxSjQAAwLMSErq6go7XcPttN+n2224y3D45aYh+/cSjbl/3H0/9r+Ex0bkIED/Q0NCgXXsyJElBQUFKHT+mzba+vr6aOnmCFn61RHa7XTt27tbcObO61Vgb0tKVmZUtSbry8kvk7+9vuD4AANA5li3r6gqAjvPp6gK6m9yDeaqvt0iSBg9MkH8r6xA31XRDk4xTN+rdZayysnJ99sVX0qn0P2PaZJfqAwAAAH6IAPED+U3WK46L63fG9nGxMTKZTCf75ru21nFnj/XeR/NVX29RYECAbr3pOmdfAAAAoKM8+gpTY2Ojcg/l6ciRY6qsrFJdfb0uu2SuIiLCm7Xx1L4JnaHoeLHzuEdU5Bnb+/n5KSwsVJWVVaquqVF1TY1CQ1qudeztsdauT9Pe7P2SpGuuulw9e0QZqgkAAABoj0cChK2hQd8sXaH1G9NVU9N8n4HZM6c1CxCr127Q5q07dMuN1yrewG/dva26usZ5HBpqbKnUsNCTN/Wn+xsNEJ01VklJqT7/8uRE6ZShSZo2ZZKhawMAAABn4naAqKqq1rMv/ktFRcUGWku7M7J05OgxPf3Pl/XgA3dryOCB7pbgURar1Xl8pjkJp/k1aWexWNtt29ljORwOvffRfFksVgUFBurWm641XI8Rp1eMAgAA7XM4HHI4HF1dBrqYw+Fo9/7pbLy3cjtAvPrmO87w4O/vr+EpyeofH6cvFy9ptf3p35jbbDa99c4H+v1/PSGz2exuGR5js9mcx34duKm3NdjabdvZY61eu0H79h+QJF179RWKijzzq1GuKDp22KPXAwDgXGWps6i+vq5bv7qNztXY2ChLXd05d//kVoDYuStDBw+d/AsZOTxFt950nUJDTwaEtgLEPXfeqjXrNuqTzxaqorJKaelbNXP6FHfK8Kimy5zaGhoM9Wlo0s7swjKpnh6r+ESJFn71jSRpxPAUTZmUargWo6Jj+3v8mgAAnIsi6ut1/HixYmNjCRHnocbGRhUUFCo2Pl6BgYFttrPb7arKzfVqbe5yK0Bs37lbktQvpq/uves2w//nmDl9inbuzlD2vhzt3pPZrQJEQJOnIU2fELSnabuAgIAuGctut+vdDz6V1WpTcHCQbrnhGsN1uMLHh4W7AAAwIjg4WNHR0SosLORVpvNUdHR0u+HhbOVWgDiYd/Lpw4xpk11O1pMmjFf2vpxmS5l2B2Fh309mrqqqNtSnorLSeRweZmwytKfH+m7Neh3IPShJuum6q5tNXAcAAF0jMDBQcXFxXV0G4FFuBYjqUze9cbGur6bUq+fJZUWrf7BqU1frG93HeVxaWnbG9haL1bnyVEREuIKCgrw+VmlZmb5cvFSSFNsvRiYfk7bt2NXqNQ4fOdrsOCDg5FOQmL7Riukbbbh2AAAAnJ/cChCNp2aN+/m5/l6fj4/vqf/tXq/ENA1Dh48eO2P7vMNHnMfxLgYpT4114kSp89WmY/kFeuPt9w2Nv2bdRq1Zt1GSdNklc3X5jy5yqX4AAACcf9y6ez89YfpESanLffMLCk5ew+CeCd4yICHe+b1yD+ap3mJpt31mVrbzeNTIYd12LAAAAMAT3HoCER/bT+XlFdq8dbvGjh5puJ/dbtd3azZIkvrHx7pTgsf5+Pho3JhRWrNuo6xWq9LSt2r2jKmttq2vtygtfaskyWw2a/TIEV0yVlLiYL347FOGxty4aYve+/BTSdJtN1/fKSs1AQAA4Nzl1hOI078F37U70/kqzJnU11v05r8/cE6eHjWi+/0m/ZKL5jiXWF20eImO5Re0aGO32/XhJwtUVX1yHsic2dOdTxOaevAXTzr/lLTypMaTYwEAAACdza0nEBNTx2np8lU6UVKqTz5bqIysbE2aME59evdytqmpqdXx4hM6XnxC+/bnKH3zdlXX1EiSevfqqQmpY93/Fh4WGRGuG679id7/aL7q6y36x3MvadaMaUpJTlRAgFlFx4u1Zu1G5ypUAxP665K5c7r9WAAAAIC73AoQvr6+uu/ueXrm+X+pvr5eGZl7lZG5t1mbZ1/4V6t9AwMDdd/d87rdJOrTpk6eoIaGBi1YuFgWi1XLVqzSshWrWrRLSU7UnfNultlsfAO5rhwLAAAAcIdbAUKnlg194tEH9c77Hyvv8FEDPaSBA/pr3i03NHtS0R3NnD5FKUOTtH5jujKzslVWXi6bzabwsDD1j4/ThPFjNXrU8LNuLAAAAKCjTNnZ2R7bGnH/gVxt37Fbh/IOq7S0XHX19TKZTAoKClSvnj2U0D9e48aM1KCBAzw1JLwsKSmpq0sAAAA4Z9jtduXk5HR1GS5x+wlEU4mDBylx8CBPXhIAAABAN9I9JyAAAAAA6JYIEAAAAAAMc+sVpv0Hct0a3N5ol9Vm08jhKW5dBwAAAIB3uBUgnnvhVbcLMJlMev7pv7h9HQAAAACdr8tfYXI4PLYIFAAAAIBO5tYTiEkTxhlq12i3q7qqWkeO5qumtlaBAQG6YNZ0BQcHuTM8AAAAAC/z6D4QZ2K327V1+07N/3yR/Pz89NN771R8XD9vDQ8PYB8IAAAAzzkb94Hw6itMPj4+mjB+rB558H7V1tbqxX+9oarqam+WAAAAAMANXTIHol9MX02dPFHV1TVauy6tK0oAAAAA0AFdNon69I7VO3dndFUJAAAAAFzUZQHCz//k/O2ysvKuKgEAAACAi7osQJSUlEqSrDZrV5UAAAAAwEVdEiCsVpvWb0yXJIWGhHRFCQAAAAA6wK19IPYfyDXc1mF3qK6uXgWFRUpL36ITp55ADBqY4E4JAAAAALzIrQDx3AuvujW4yWTS7JnT3LoGAAAAAO9xK0C4NbCfr6696goNGjigq0oAAAAA4CK3AsSQQQMlk7G2JpNJfn5+Cg8LVXx8nMaOHqmI8DB3hgcAAADgZW4FiF889IDnKgEAAADQ7XXZMq4AAAAAzj4ECAAAAACGESAAAAAAGGZoDsR///GpTivAJOl/fvdkp10fAAAAgOcYChClpWWdXwkAAACAbo9XmAAAAAAYZugJxAvP/LXzKwEAAADQ7fEEAgAAAIBhXRYg8gsK9dyLr+rrJSu6qgQAAAAALuqyAFFfX6/9ObnasGlzV5UAAAAAwEWG5kAYZbfbVVNTK1uDrc02jY12lZaW6Zul30qSqqtrPFkCAAAAgE7kkQCxPydXS5av1IHcg2poaHSpb4+oSE+UAAAAAMAL3A4Q6zZs0sfzv5DD4ehQ/xnTprhbAgAAAAAvcStAHC8+oU8XfOkMDyaTSWGhITKZTKqorJJOPWFobGxUZVW1s11cbIxi+8Vo5IhhGjNqhCe+BwAAAAAvcCtArF2fpsbGRplMJl15+SWaMW2KAgMDlF9QqD//7VlJ0h/++9eSJFtDg3bu3KOvl65QaWm55s6ZRXgAAAAAzjJurcK0PydXkjR96iRddOFsBQYGtNnW389PqePH6MnHH1b/+Fi9/e5H+m7tBneGBwAAAOBlbgWIktJSSdKokcMM9wkIMOvuO25VWFioFnzxlQqLjrtTAgAAAAAvcitA1NdbJEnhYWHNPjeZTM7jxsaWqzIFBwdp2pSJstvtWr9hkzslAAAAAPAitwKEv//JKRRWq+0Hn/s7j+vq6lvtO3jQAEnS3n057pQAAAAAwIvcChCRERGSpPyCgmafN50LkV9Q2Grf4KBgSVJZeYU7JQAAAADwIrcCRFxsP0nSt6vWqrrm+x2lQ0NCFBwcJEnasm1Hq31Ph46GhgZ3SgAAAADgRW4FiDGjTy7Derz4hP701DNasXK189ygAQmSpI2btmjt+rRm/YqOF2vxkhUSO1EDAAAAZxW39oEYO3qk+sfH6vCRY6qqqlbe4aPOc5MnpmpP5l45HA59PP8LLVm+Un379FZtXZ3y8wvVaLdLkoanJLv/LQAAAAB4hVtPIEwmkx645w71j4+VJIWGhjjPjRk9QiOGpzh/rqioVPb+AzpyNN8ZHsLDQnXR3NnulAAAAADAi0zZ2dkOIw03btqs1HFjmq2wdJrD4VBG5l75+flpaHKi8/PGxkZ9/uXXzh2rm0ocMkg333CN+vTu5YnvAS9JSkrq6hIAAADOGXa7XTk5Z9eqpIYDxH88+msFBQVqUuo4TZ86SX37RhsepN5i0aFDh1VdXSN/s7/iYvupZ48od+pGFyFAAAAAeM7ZGCBcmgNRV1ev79Zu0HdrN2jwoAGaOW2KxoweIV9f33b7BQYENHsyAQAAAODsZDhAREVGqqy83PnzgdxDOpB7SKELQjRlUqqmTZ2kXj17dFadAAAAALoBw68wSVJW9j6t35iu3XuyWsxpMJlMSk4aohnTJmvk8BT5+Lg1PxvdFK8wAQAAeM7Z+AqTSwHitOqaGm1K36qNm7aosOh4i/MREeGaNnmipk6ZqMiIcE/Vim6AAAEAAOA5502AaOrgoTyt35iu7Tt2y2K1Njvn4+OjEcOHasbUyUoZyo3nuYAAAQAA4DnnZYA4zWKxasu27dqQtrnZhnKn9ewRpenTJmvKxNRm+0Xg7EKAAAAA8JzzOkA0lV9QqA0b07V56w7V1NY2O+fn56vRo0Zo+tRJShw8yNNDo5MRIAAAADyHAPEDDQ0N2rFrjzambVb2/gMtzkdH99aMqZM1e+a0zirBIwoKi5SWvlVZe/epvKJCFotVYaEhionpq3FjRmpi6rgzLmXbFWPl5B7UpvStyj2Yp/LyCtkaGhQUGKg+fXorOXGwpk2ZqKioSJfqI0AAAAB4DgGiHeXlFdq2Y5e279ytg4cONzv3wjN/9UYJHfLN0hX6ZtnKFqtONRXbL0b33nWb27tqe2qsuvp6vffBp9qxa0+74/n7++naq67QjGmTDddIgAAAAPAcAoQBtbV1+m7Nei1dvlKNdrvUjQPEkuUrtWjxUklSYGCAZs2YquTEIQoMDNSJkhJtSNusvdn7JUk9e/bQE794UGFhoV06lq2hQc/882XnPJTw8DDNnjFNgwcPUIDZrJKSMqVv2aaduzOcfe647SZNTB1rqE4CBAAAgOecjQHCpZ2oO8pqtWnHrt3aun2X9mbvb/c37N1FUVGxFn+zXJIUEhKsxx/5uaL79HaeT+gfp/FjR+uzzxdp5ep1Kikp1ReLvtG8W67v0rGWLl/pDA89e0Tpicf+Q2Gh3weN+LhYjRk9QkuWrdSir08GlgULv9LYMSPl7+eVfx0AAABwFuvU3d7yDh/Vh58s0G/++3/1zvufKCNzrzM8+Pv7a8qkVP3qsf/ozBI6bMnylbKfekJy9ZWXN7uhb+qqKy9T7149JUnpW7bpRElpl41lt9u1dl2a8+fbb72xWXho6uK5s9WzR5QkqaqqWjkHcl2uGwAAAOcfj//Kua6uTulbTi7neiy/oMX5mL7RmjZ1kiZNGKegwEBPD+8RDQ0N2rXn5Cs+QUFBSh0/ps22vr6+mjp5ghZ+tUR2u107du7W3DmzumSsktIy+fj6yMfHRyHBwRo8aECb1/Lx8dGgQQNUUlomSSosLFZKMq8nAQAAoH0eCxD7D+Rqw8bN2rFrt2y2huaDnFq6dca0yRoyaKCnhuw0uQfzVF9vkSQNHphwxld7khKHOI8zsrJdChCeHKt3r576yx9+K7vdLovFIpPJ1O61fH2+X83JZrMZrhkAAADnL7cCRFV1tdLSt2rDxnQVnyhpcb5Xzx6aNnWSpkxKVWjI2bN5XH5BofM4Lq7fGdvHxcbIZDLJ4XAoP7/wjO07eywfHx8FBQWd8VrFJ044j3v0cG05VwAAAJyfOhQgMrKytWFjuvZkZDlXUjrNx8dHI4enaPq0SWftKzFFx4udxz0M7JPg5+ensLBQVVZWqbqmRtU1NYYDkzfHaup48QnlHsyTTr0adbb+swIAAIB3GQ4QZWXl2pC2WRvTt6i8vKLF+ciIcE2dPFHTpkxURES4p+v0qurqGudxaBuTkH8oLPTkTf3p/kZv6r051mkOh0Mfffq5HI6TK/hOmzJRISHBLl0DAAAA5yfDAeK///iU84bzNJPJpKHJiZoxbbJGDBsqH59OXdTJayxWq/PY6NKmfk3aWSzWdtt21Vinzf98kbL3nVxvuEdUlH78o4sN97X/4IkTAAAAOu5svLcyHCCahofQ0BBNmZiq6VMnqWfPHp1VW5dpOqHYrwM39bYG4xOSvTmWw+HQ/M8X6bs16yVJgQEBuv+e2116+lB07LCBVgAAADhXuTQHYsjggZoxdbLGjB4hX19fAz3OTv7+/s5jW0NDu21Pa2jSztykf3cZy2Kx6t/vf6Sdu04uGRscHKSf3XeX4g1M3G4qOra/S+0BAADQNrvdrqrcs2s/LsMB4re/fkx9o/t0bjXdRIDZ7Dw2urxp03YBAQHdaqzy8gq98vrbOnI0X5IUFRWpn99/l/rF9DVc52nnymtqAAAA6BjDAeJ8CQ+SFBb2/WTmqqpqQ30qKiudx+FhxiZDe2OsI0eP6ZXX3lZ5xck+AxLidf89dygiPMxwjQAAAMBpHt+J+lzQNCyVntqpuT0Wi1U1NbWSpIiIcEN7MHhjrH37D+jl196W9dRE7QmpY3XrTdcZnqwNAAAA/BB3kq2Ii/1+XsDho8fO2D7v8BHncXysa3MKOmusnAMH9dKrbzlfd7rs0rm6/NKLXKoNAAAA+CFeaG/FgIR4hYae3Fsh92Ce6i2WdttnZmU7j0eNHNblYxUVFetfb/xbNptNJpNJN99wDeEBAAAAHkGAaIWPj4/GjRklSbJarUpL39pm2/p6i/O82WzW6JEjunSshoYGvfHv91VbWydJuv6aKzV96iSXagIAAADaQoBowyUXzXEusbpo8RIdyy9o0cZut+vDTxaoqvrk5Oc5s6c7nyY09eAvnnT+KSkp7dSxlq5Y5ew/acJ4zZoxtQPfHgAAAGgdcyDaEBkRrhuu/Yne/2i+6ust+sdzL2nWjGlKSU5UQIBZRceLtWbtRh3MO7mx2sCE/rpk7pwuHaumplYrV62VJPn6+mryxPHKLyg0VIOvr6+i+/TuUP0AAAA4fxAg2jF18gQ1NDRowcLFslisWrZilZatWNWiXUpyou6cd7PMZuMbyHXGWHsy9zrnUDQ2Nuq5F181PH6PqCj98fe/7nD9AAAAOD8QIM5g5vQpShmapPUb05WZla2y8nLZbDaFh4Wpf3ycJowfq9GjhneLsex2u0fqAAAAANpiys7OdnjqYmVl5QoNC21zn4GCwiL5+vqqT+9enhoSXpaUlNTVJQAAAJwz7Ha7cnJyuroMl3jkCURBYZHmL/hS2fsP6D+feESx/WJabZe+eZuWr1ytwYMG6MbrrlK/mL6eGB4AAACAl7i9ClNO7kH9/ZkXlL3/gCSpurrmjH0O5B7S3595UTkHDro7PAAAAAAvcitA1NXV6c2335fVenK3Y7PZXyaTqc32sbExioqMlCTZbDa9+c4Hqqurc6cEAAAAAF7k1itM6zZsUmXVyX0JLrpwti67dG6b8x8kKXXcGKWOG6PlK1dr4aJvVFlZpXUbNumiC2e7UwYAAAAAL3HrCcSuPVmSpDGjR+gnP7603fDQ1EVzZmncmJHNrgEAAACg+3MrQBQWFUmSJowf63Lf1FN9ioqOu1MCAAAAAC9yK0BYLVZJUo+oSJf7RkZESJIspzY+AwAAAND9uRUggkOCJUnVNWdeeemHKiorJUlBwUHulAAAAADAi9wKENG9e0uSdndgHsOm9K2SpL7RfdwpAQAAAIAXuRUgRgwfKp1ajWnn7gxDfRwOh75ZukI7du05dY0Ud0oAAAAA4EVuLeM6Y9oUrVi1RtXVNXrtzXc1NGmIRo8aodh+fRURESGz2V8Oh0P19RaVlJQq91Cetm7bqePFJyRJoaEhmj51kqe+CwAAAIBO5laACAgw6967btOLr7whm61Be/flaO++HGMD+/nq7ttvUWBAgDslAAAAAPAit15hkqQhgwbqsYd/pn4xfQ33iekbrUcf+pmSEge7OzwAAAAALzJlZ2c7PHWx7H052rFrj/IOH1VpWZnq6+slSYGBgeoRFaWE/nEaPXK4hiYnempIeFlSUlJXlwAAAHDOsNvtyskx9gZPd+HWK0w/lJw0RMlJQzx5SQAAAADdiNuvMAEAAAA4fxAgAAAAABhm6BWm05u+BQYFavTI4S0+d9ekieM9ch0AAAAAnctQgHj3w08lSdF9ejcLEKc/d4fJZCJAAAAAAGeJLn+FyeHw2CJQAAAAADqZoScQP7rkQklSaEhIq58DAAAAOD94dB8InPvYBwIAAMBzzsZ9ILr8FSYAAAAAZw+3NpJ79c13JEmXXTJXcbH9PFUTAAAAgG7KrScQu/dkadfuTM9VAwAAAKBbcytAREVGSJLq6uo9VQ8AAACAbsytADFieIokKS19i6fqAQAAANCNuRUgfvyjizQgIV6bNm/TgoVfqd5i8VxlAAAAALodt5ZxLSgsksPh0JZtO7R+Q7oaGhuUnDhEsf1iFB4eJn9/f5kMXIedqM8eLOMKAADgOWfjMq5urcL0p6eeafHZrj2Z2rXH+MRqk8lEgAAAAADOEl2+D4TDwT52AAAAwNnCrScQkyaM81wlAAAAALo9twLEvFtu8FwlAAAAALq9Ln+FCQAAAMDZw60nEO9+8Kkk6crLL1FERLhLfVetXq9Va9ZpaNIQ3XLjte6UAQAAAMBL3HoCsWnzVm3avFW1dXUu9w0OClRpaZn27ju7lq0CAAAAzmdd9gpTeUWlJKmqqqqrSgAAAADgIpdeYdqUvrXVz3ftztThw0cNXaPRbldx8QmtXZ8mSTKbza6UAAAAAKALuRQg3v3w01Y/X/T10g4XMCChf4f7AgAAAPAul15hGjdmpHr2iPLY4D16ROn6a6702PUAAAAAdC6XnkDcfcetkqTqmhrl5R3Ry6+9LUmaMW2yQkNDDF8nOChIvXr11LChSfL19XW1ZgAAAABdpEPLuIaGhGj4sKHOn2dOn6KYvtGerAsAAABAN+TWPhATU8fJZDr5RAEAAADAuc+tAHH7rTd4rhIAAAAA3Z5bAaI1jY2Nyi8oUmVlperq6zV82FAFBQZ6ehgAAAAAXcBjASIre59Wr9mgvfv2q6Gh0fn5fz35qIL6fh8gtu3YpUN5R3TZpXMVGBDgqeEBAAAAeIHbAcJut+v9j+Zr0+Zthtpv27FLO3bu0Z6MLD3083sVFRnpbgkAAAAAvMSlfSBa8/H8L5qFh9CQEKUkJ7bZvqCgSJJ0vPiE3njrfXeHBwAAAOBFbgWIw0eOaf3GdElSz5499LP77tRf/vhbPfjTe9rs8+snHtH4caMlSYcOH9GOXXvcKQEAAACAF7kVIDZu2ixJCg0N0eOP/EzDhw2VyWRqt4+/n5/uuPVGRUf3liRt277LnRIAAAAAeJFbASLnwEFJ0qwZUxUeFmZ8UB8fzZg2RZJ05Ogxd0oAAAAA4EVuBYiKikpJ0pBBA13u2+/UztXlp64BAAAAoPtzaxUmi8UiSQoKcn2fh8BTe0PY7XZ3Suh0BYVFSkvfqqy9+1ReUSGLxaqw0BDFxPTVuDEjNTF1nHx9fbvdWN6sGwAAAOcPtwJEcEiwqqqqVVVV7XLfktJSSVJIcJA7JXSqb5au0DfLVqqxsbHZ52XlFSorr1BmVrZWrV6ve++6TX169+o2Y3mzbgAAAJxf3AoQfXr3UlVVtfZk7lXK0CSX+p5e+jU6uo87JXSaJctX6qtvlkuSAgMDNGvGVCUnDlFgYKBOlJRoQ9pm7c3er2P5BXrhlTf0xC8eVFhYaJeP5c26AQAAcP5xK0AMG5qsA7mHtH5juiamjlVC/3hD/VZ+t1Z7MrIkSSnJrgUPbygqKtbiUzfhISHBevyRnyu6T2/n+YT+cRo/drQ++3yRVq5ep5KSUn2x6BvNu+X6Lh3Lm3UDAADg/OTWJOrpUycpMCBADQ0Neu7FV/XtqjWqqm7+OtPpRV0tFqt2Z2TphZdf14KFi6VT8yCmT53kTgmdYsnylc65GVdfeXmzm/CmrrryMvXu1VOSlL5lm06UlHbpWN6sGwAAAOcnt55AhIQE66Ybrtbb734kq9Wmz7/8Wp9/+bVzgrQkvfza22poaFBlVbUcDofzc5PJpJtvuFrB3WwORENDg3btyZAkBQUFKXX8mDbb+vr6aurkCVr41RLZ7Xbt2Llbc+fM6pKxvFk3AAAAzl9uPYGQpNRxY3TnbTc1Cw319fXO45LSMlVUVjULD4GBgbrztps0fuxod4f3uNyDeaqvP7m61OCBCfL3az9jJSUOcR5nZGV32VjerBsAAADnL7eeQJyWOn6MkpIGa+36NO3YuUeFRcebBQadeuLQL6avxo4ZqWmTJ3bbibv5BYXO47i4fmdsHxcbI5PJJIfDofz8wjO276yxvFk3AAAAzl8eCRCSFB4WpssvvUiXX3qR6i0WlZeVq66+XiaTj4ICAxUVFSmz2d9Tw3WaouPFzuMeUZFnbO/n56ewsFBVVlapuqZG1TU1Cg0J8fpY3qwbAAAA5y+PBYimAgMC1PfUTtNnm+rqGudxaKixpyRhoSdvxE/3N3oj7smxvFk3AAAAzl+dEiDOZhar1Xl8pnkEp/k1aWexWNtt21ljeavu7r5zOAAAwNnkbLy3IkD8gM1mcx77deBG3NZga7dtZ43lrbqLjh021A4AAADnJsMB4t0PPu2UAkwm6babu89GZv7+38/TsDU0GOrT0KSd2d/4PA9PjuWtuqNj+xtqBwAAgDOz2+2qys3t6jJcYjhAbNq8tdOK6E4BIsBsdh43/a1+e5q2CwgI6JKxvFW3j4/bK/8CAADgLMbd4A80XV62qqq63banVVRWOo/DXVie1pNjebNuAAAAnL9cngNhMpkUHxerYSlJGjEspdvu59BRfaP7OI9LS8vO2N5isaqmplaSFBERrqAg4ztre3Isb9YNAACA85fhADF7xlRt2bZT1TU1OnzkqA4fOaqly1dp8MABmpA6RuPGjDonbkLjYr/fhO3w0WNnbJ93+IjzOD72zBu4ddZY3qwbAAAA5y/DAeK6a67U1T+5XBlZ2UrbtEUZmXvVaLcrJ/egcnIP6tMFizRqxDBNmjBOKUOTztp35QckxCs0NETV1TXKPZineotFge3MD8jMynYejxo5rMvG8mbdAAAAOH+5dJfv6+urUSOG6f57btef//BbXXvVFYqPO/nb64aGBm3bsUsvv/a2fvv//qzPv/xa+QWFnVV3p/Hx8dG4MaMkSVarVWnpbU8er6+3OM+bzWaNHjmiy8byZt0AAAA4f3V4H4iQkGBdMGuaLpg1TfkFhUpL36ItW3eosqpalVXV+nbVGn27ao3iYvtp8sTxSh03RqGhZ8dOx5dcNEcbN22RzWbTosVLlDh4oGL7xTRrY7fb9eEnC1RVfXLC8pzZ01v9fg/+4knn8R9+96R69uzRaWN58loAAABAa0zZ2dkOT13Mbrcrc+8+paVv0Z6MLDU0NDrP+fr4aPiwoZo4YZxGDk+Rr6+vp4btFBvSNuv9j+ZLkgICzJo1Y5pSkhMVEGBW0fFirVm7UQfzTm6qNjChvx5+8H6ZzS33UjhTgPDkWJ6+VmuSkpIMtwUAAED77Ha7cnJyuroMl3g0QDRVW1unLdt2aNPmrco7fLTZuZDgYI0fN1qTJoxXQv+4zhjeI9as26gFCxe3u69CSnKi7px3c5u/xTcSIDw1Vmdc64cIEAAAAJ5DgGhDUVGx0jZv1c5de3S8+ESzc32j++i3v36ss0vosOITJVq/MV2ZWdkqKy+XzWZTeFiY+sfHacL4sRo9ani7/Y0GCE+M1VnXaooAAQAA4DkEiDOot1i0bsMmrfh2taprapyfv/DMX71VAtxEgAAAAPCcszFAdHgStVEWi1XbduzU1u27lHMgt9m8CJPJpOEpyZ1dAgAAAAAP6bQAkXPgoDZu2qIdO3fLYrU2Oxcd3VuTJ6ZqYuo4RYSHdVYJAAAAADzMowGivLxCaelblZa+RSdKSpudCwwM1PixozR5YqoGDujvyWEBAAAAeInbAaKhoUE7d2VoY/oWZe/LkcPx/ZQKk8mkpMTBmjIxVaNHDZe/v/HlQgEAAAB0Px0OEIePHNXGTVu0ddtO1dbVNTvXq2cPTZo4XpMnjFdUVKQn6gQAAADQDbgUIKqra5S+ZZvS0rcqv6Cw2Tmz2V9jR4/SlEmpGjJ4oKfrBAAAANANGA4Qr775jjIy9qrRbnd+5uvjo6SkIRo/drTGjh6pgABzZ9UJAAAAoBswHCB27c6UTs1rSIiP04gRKRo5PEVBQYGSpJraGtXU1pzhKq3rERXVoX4AAAAAvMvlORAOh0OHDh/RocNH9NXXy9wuwGQy6fmn/+L2dQAAAAB0Pp+uLqDpqk0AAAAAujfDTyAmTRjXuZUAAAAA6PYMB4h5t9zQuZUAAAAA6Pa6/BUmAAAAAGcPAgQAAAAAwwgQAAAAAAwjQAAAAAAwjAABAAAAwDACBAAAAADDCBAAAAAADCNAAAAAADCMAAEAAADAMAIEAAAAAMMIEAAAAAAMI0AAAAAAMMzPkxc7fOSY9mRk6cjRY6qorFJ9fb1+et+d6tO7l7NNeUWlfH19FBYa6smhAQAAAHiBRwJEYWGR3v/4Mx08dLjFucbGxmY/r123UStXr9M1P7lcM6ZN9sTwAAAAALzE7QBx8NBh/fOl12Sz2Qy1352RJZvNpo/nf6FGu12zZ0x1twQAAAAAXuLWHAibzabX33rXGR76x8fp+muu1OOP/KzNPlMnT1BgYKAk6YsvF6usvNydEgAAAAB4kVtPIDakbVZFZZUk6SdX/EgXzZl1xj6zZ05T//g4/fOlV9XQ0Kj1G9P14x9d7E4ZAAAAALzErScQGVnZkqQRw4YaCg+nDRqYoNRxYyRJ2fsOuFMCAAAAAC9yK0Acyy+QJE1IHety35HDh0mSjh8vdqcEAAAAAF7kVoCoqamVJPXu1euMbX8oMjJCklRXX+9OCQAAAAC8yK0A4et7srvDYXe5r63h5MRrs7+/OyUAAAAA8CK3AkR4WJgk6eixApf7Hjhw6OQ1wsPcKQEAAACAF7kVIAYNTJAkrV2fJrvd+FOIqqpqrVq9TpI0eNAAd0oAAAAA4EVuBYjU8SdXUjp6LF//fv9jQ5vJ5R7M0zPPv6LqmpqT1zi1GhMAAACA7s+tfSBSkpM0NDlRe7P3a+u2ncrel6Oxo0eqT+/vJ1VnZGUr92Cejhef0L79OTpyNP/7/kOTlJw0xL1vAAAAAMBrTNnZ2Q53LlBXV6dnX3jVuaSrUXGxMXrkwfsVFBTkzvDwsqSkpK4uAQAA4Jxht9uVk5PT1WW4xK1XmCQpKChIv3z0Qc2dM0sBAeYztg8MDNRFF87WL3/xIOEBAAAAOMu4/QSiKYvFqsy92TqUd0SlpWWqq6+XyWRSUGCgevXqoYT+8UpJTpLZzNKtZyueQAAAAHjO2fgEwq05ED8UEGDW2NEjNXb0SE9eFgAAAEA34fYrTAAAAADOHwQIAAAAAIa59QrTa2++K3+zv3x9fCSZOnQNHx+TgoKCFBUZqcGDEtQ/Ps6dkgAAAAB0IrcCxM7dGZ6r5JR+MX11/TVXKnHIII9fGwAAAIB7ut0rTPkFhfrnS69p+87dXV0KAAAAgB9w6wnEn/7fb1RXX6/MrGx9uXipGhoa1De6j1KGJikutp9CQoLlYzKpuqZWBYVFytq7T0eP5Ss4OEg/+fGl6tO7txwOhywWi4qOF2vn7gwdPHRYDodD733wqRIHD1JoaIjnvi0AAAAAt7i9D8T6jen66NPPFR4epptvuEYjhg1tt31W9j598NECVddU67675mlYSnKz8xvS0vXhJ5/L4XDoxz+6WJdePMed8uBh7AMBAADgOWfjPhBuvcJ0LL9AH8//QsFBQXr8kZ+dMTxIUkpykn7x0APy9/fXW+9+qLKy8mbnp06eqImpY6VTYQMAAABA9+FWgFi1ep3sdrvmzpmpHlFRhvv17BGlC2fPVF1dvdasT2txfuyYUZKkouPF7pQHAAAAwMPcChA5Bw5KkgYNHOBy38GDT/bZk5HV4lxEeLgkqa62zp3yAAAAAHiYWwGivKJCkmQyub4HhK+PryS1eIVJkqprqk8W5+vrTnkAAAAAPMytABEQECBJOpB70OW+eUeOSpIcjpZzuLOzT04kiYwId6c8AAAAAB7m1jKufaP76EDuIS3/drVGjxqhPr17GepXVVWtFd9+J0nq0aP53Im8w0e19tS8iISEeHfK84iCwiKlpW9V1t59Kq+okMViVVhoiGJi+mrcmJGamDpOvh58UuKp8XJyD2pT+lblHsxTeXmFbA0NCgoMVJ8+vZWcOFjTpkxUVFSkx+oGAADA+cGtZVxXr92gTxd8KUkKDAzU7JlTNXrkCMX26ysfn5YPN44Xn1BG5l6tWLVGFRWVkqS5F8zUVVdeJkn6YtE3Wr12vWy2BknSz++/q8Uyr970zdIV+mbZSjU2NrbZJrZfjO696zbD4amzx6urr9d7H3yqHbv2tDuWv7+frr3qCs2YNtmlGlnGFQAAwHPOxmVc3QoQjY2N+tvTL+hYfkGzz318fBQeFiqz2SyTj0k2q02VVdVqaGho1i4kOFi/+8/HnZvFvfzqW8rIypYkjRoxTPffc3tHS3PbkuUrtWjxUklSYGCAZs2YquTEIQoMDNSJkhJtSNusvdn7JUk9e/bQE794UGFhoV06nq2hQc/882XlHT75elh4eJhmz5imwYMHKMBsVklJmdK3bNPO3RnOPnfcdpNz2VwjCBAAAACec94FCEmqrqnR62+951yRyajIiHA9cO8dio+LdX722RdfadXqdRo/brRuvfFamc1md0rrsKKiYv3vU0/LbrcrJCRYjz/yc0X36d2i3WefL9LK1eskSZMnpmreLdd36XhffbNM3yz9Vjq1VO4Tj/2HwkJbhpoly1Zq0dcnw0pYWKj++Pv/lL+fsbfZCBAAAACeczYGCLcmUUtSaEiIfvEfD+in996hcWNGOZ8mtMbf31+JQwbp+muu1O//64lm4UGSJqaO1ZOPP6y75t3cZeFBp54G2O12SdLVV17e6s28JF115WXq3aunJCl9yzadKCntsvHsdrvWrvt+T43bb72x1fAgSRfPna2ep+aeVFVVK+dAbofqBgAAwPnHrUnUTY0YnqIRw1MkSTU1taqorJTFYpHD4ZC/v1mhocGKimx/0u4PA0VXaGho0K49J1/xCQoKUur4MW229fX11dTJE7TwqyWy2+3asXO35s6Z1SXjlZSWycfXRz4+PgoJDtbgQW3vzeHj46NBgwaopLRMklRYWKyUZJ4sAAAA4Mw8FiCaCgkJVkhIcLttKquqlJW1T71799KggQmdUUaH5B7MU329RZI0eGDCGV/tSUoc4jzOyMp2OUB4arzevXrqL3/4rex2uywWyxn35ji9D4ck2Ww2l2oGAADA+cvtV5g6qqysQu9++Kk+XbCwq0poVX5BofM4Lq7fGdvHxcY4b9bz8wvP2L6zx/Px8VFQUNAZr1N84oTzuEcPlnMFAACAMV0WIDKz9kqSio4Xd1UJrWpaTw8D+yT4+fk5V0OqrqlRdU1Ntx5Pp5bTzT2YJ516LYrXlwAAAGCUR15hstvt2rp9p/btP6DyisoWy7U21djYqNKycpWXV0hSl06Wbk119fc35KFtTEL+obDQUFVWVjn7h4a0PZG8q8dzOBz66NPPnTuAT5sy8YyvmwEAAACnuR0gjhef0Cuvva3jxScMtG4pOWmIgVbtq6ioVEFhUYf7BwSYNXDAyXkYFqvV+bnRpU39mrSzWKzttv0hb483//NFyt53cqmwHlFR+vGPLnap/+nVogAAAOC+s/Heyq0AYbXa9PKrb6n4RInLfX19fJSSkqzrr77SnRIkSZl79+m9Dz/tcP+YvtH67a8fk34wodivAzf0tgbXJiR7azyHw6H5ny/Sd2vWS5ICAwJ0/z23u/z0oejYYZfaAwAA4NziVoBIS9/iDA+x/WI0bcpE9e7VU+UVlXr/o/mSpEcevF+NjY0qKS3T9p27tTd7vxKHDNKdt92kiIhwz3wLD/L393ce29p5Fauppq9smZv07y7jWSxW/fv9j7Rz18nlYoODg/Sz++5SvIFJ2z8UHdvf5T4AAABond1uV1Xu2bUnl1sBYtfukzekCf3j9NjDP5Ov78mlQZuuLJQ4ZJDzeNqUicrau09vv/uR/v7si3rop/cqOrr1TdNcMX7sKA1N7virUKfrlqSAJnMyjC5v2rRdQECAS2N39njl5RV65fW3deRoviQpKipSP7//LvWL6etSnaf5+HTZvHsAAAB0A24FiNNBYfbMac1uwtuTMjRJ9959m55/6XW99Oqb+s2vHlVAgHsTqc1ms8cmY59e4Uindmk2oqKy0nkcHmZsIrQ3xjty9Jheee1tlVecbD8gIV7333OHIsLDXKoRAAAAOM2tXyfX1NZJkvpG93GpX+LgQRozarhKSsu0afNWd0rwuKbfpfTUTs3tsVisqqmplSRFRIQb2oPBG+Pt239AT//zFWd4mJA6Vr946KeEBwAAALjFrQDx/WbHzXc9bvo0oq6+vtW+Y8eMkiRt3b7TnRI8Li72+3kBh48eO2P7vMNHnMfxsa7PKeiM8XIOHNRLr74l66kVni67dK7uvO0mw6s8AQAAAG1xK0AEn/rtd1l5ebPPA5u8l396v4cf6hEVJUkdWsGpMw1IiFdo6Ml9FXIP5qneYmm3fWZWtvN41MhhXT5eUVGx/vXGv2Wz2WQymXTzDdfo8ksvcrkuAAAAoDVuBYjoU6/f/PApQmhoiPMpxN7s/a32ra4++b7/6ddxugsfHx+NO/V0xGq1Ki297Ves6ustzvNms1mjR47o0vEaGhr0xr/fV+2pV8uuv+ZKTZ86yeWaAAAAgLa4FSBSkhMlSVu37dR7H36qY/kF0qlXmGL6RkuSln/7XYsnFJK0dsMmSVJQUKA7JXSKSy6a41xeddHiJc7v1ZTdbteHnyxQ1akgNGf2dOeThB968BdPOv+UlJR22nhLV6xy9p00YbxmzZjagW8PAAAAtM2tl+KnTp6opStWyWI5+Zvz6ppa/fTeOyRJY0aN0NFj+aqsqtZT//e8pkyeoJi+0aqtq9P2Hbt0IPeQJGlgQvfbVyAyIlw3XPsTvf/RfNXXW/SP517SrBnTlJKcqIAAs4qOF2vN2o06mHdyU7WBCf11ydw5XTpeTU2tVq5aK50KcJMnjm+2nG57fH19Fd3H/eV0AQAAcO5zK0CEhoZo3s036K13PlCj3a6wJr8RnzVjilav26CqqmpV19Ro+bfftehvMpl0wazp7pTQaaZOnqCGhgYtWLhYFotVy1as0rIVq1q0S0lO1J3zbpbZ7NoGcp4eb0/mXuf8icbGRj334quGx+4RFaU//v7XbtUPAACA84Pby/KMGT1Cj//iQS1bsUq9evZ0fh4UFKSf33+XXnntbVVUVrXo5+Pjo2t+crmSEge7W0KnmTl9ilKGJmn9xnRlZmWrrLxcNptN4WFh6h8fpwnjx2r0qOHdYjy73e6xOgAAAIC2mLKzsx2dOYDValX6lu3KOXBQ1dXVMpvNio2N0aTUcerVq6eBK6A7SUpK6uoSAAAAzhl2u105OTldXYZLOj1A4NxCgAAAAPCcszFAuPUK0649mdKpvQzCw9jhGAAAADjXubWM66tvvKNX33hHpaUtl2kFAAAAcO5xK0CEBAefvIiPyVP1AAAAAOjG3AoQcbExkqTcQ4c9VQ8AAACAbsytAHH5jy6Sr4+Pvv5muY4cPea5qgAAAAB0S26vwnT0WL6++PJr5eQe1PixozVq5HDF9YtReHiY/P3d21wN3Q+rMAEAAHjOebcK09+eft55bDabtWnzNm3avM2la5hMJj3/9F/cKQMAAACAl7gVIA4fcf+1JYeDbSgAAACAs4VbcyAAAAAAnF/cegLxwjN/9VwlAAAAALo9nkAAAAAAMIwAAQAAAMAwt15hakttba0qK6tUV1+v2H79ZDaznCsAAABwLvBYgCgsLNKa9Wnak7lXpaVlzs//68lHFdM32vnz3n05Kio6rhnTJsvHhwcgAAAAwNnEIwFi8ZLlWrp8lex2+xnbpm/epvQt27R1+y797L47FBQU5IkSAAAAAHiB248AFi9Zrm+WfusMDyaTSX1692qzfc6BXElS7sFDevvdj9wdHgAAAIAXuRUgjhef0NLlqyRJwcFBuuHan+hvf/pv/fdvftlmn8d/8aAShwySJGVkZWvvvrNr624AAADgfOZWgFi3YZPsdrsCAsx6/OGfa+b0KWd8JSkiPEw/u+9ORUVGSpI2b9nuTgkAAAAAvMitALE/54Akaca0KYqO7m24n9ls1szpkyVJh/IOu1MCAAAAAC9yK0CUlpZLkoYmDXG5b1xcP0lSWXm5OyUAAAAA8CK3AkR9fb0kKTQ0xOW+oSEn+zQ2NLpTAgAAAAAvcitAnJ7vUFtb53Lf8orKZtcAAAAA0P25FSB69oySJGV3YCWl7Tt2SZJ69erhTgkAAAAAvMitADE0KVGStHrdRp04UWK4346de5R+avWlocmJ7pQAAAAAwIvcChDTp02Sn5+v6uvr9fQ/X9aOnXva3Y06v6BQH3z8md749/uSJD8/P02fOtmdEgAAAAB4kZ87naMiI3Xl5ZdqwcLFqqyq1utvv6eAALN69ezpbPPhJwvkcEjHi4tVU1PbrP9PfnypIiPC3SkBAAAAgBe5FSAkac7sGWpoaNTib5ap0W6XxWLVsfwC5/ncg3kt+vj6+OjHl12sC2ZNd3d4AAAAAF7kdoCQpIvnztaI4UP17ao12rkrQ/UWS6vtgoICNXb0SM2eOU39Yvp6YmgAAAAAXmTKzs52ePKCDodDhUXHVVpaprr6eplMJgUFBqpXr57q07uXJ4dCF0hKSurqEgAAAM4ZdrtdOTmur2jaldx6AmGz2eTv79/sM5PJpJi+0YrpG+1ubQAAAAC6GbdWYfrP3/2v3v9ovvbtP+C5igAAAAB0W249gai3WLRx0xZt3LRFUZGRmpg6VhNSx6pvdB/PVQgAAACg2/DIJGpJKisv19IVq7R0xSr1j4/VxAnjlTp2tEJDQzw1BAAAAIAu5tYk6rLycm3bvktbt+/S4SNHW5z39fFRytAkTZwwTiNHDJO/n8fyCroIk6gBAAA852ycRO2xVZhOlJRq2/ad2rp9V7N9IE4LDAzUuDEjNTF1nIYMHuiJIdEFCBAAAACec14HiKaKjhdr67ad2rpjp4qKiluc79EjShNTx2pi6jiWdj3LECAAAAA8hwDRivyCQm3dvlPbtu9S8YmSFucH9I/XLx99sDNLgAcRIAAAADznbAwQnT4poV9MX/WL6asrLrtEx/ILtHNXhnZnZOrI0XxJ0qHDRzq7BAAAAAAe4tVZzTF9o1VTUyurzabq6lqVlZd7c3gAAAAAbur0AGG12pSRtVfbd+xSZtY+1VsszQtgZSYAAADgrNEpd+9Wq017MrO0bccuZWZly2q1tWgzZPBATRg/VuPGjOyMEgAAAAB0Ao8FCIvFqj0ZWdq+c7cysrJls7UMDf1i+mpC6liljhutqMhITw0NAAAAwEvcChAWi1W7MzK1fcduZe7Nls3W0KJNVGSkUseP0YTxY9Qvpq87wwEAAADoYm4FiCd/+z9qaGhs8XlwcJDGjh6pCePHsmkcAAAAcA5xK0A0DQ9+fn4aOTxFE1LHanhKsnx9fT1RHwAAAIBuxK0AYTKZlJQ4WBPGj9WYUSMUGBjg8jVsDQ3yZyUmAAAA4Kzg1p37//6/3ygiPKxDfQsLi7RuY7rSt2zT3/70e3fKAAAAAOAlbgUIV8NDQ0ODtu3YrXUbNin34CF3hgYAAADQBbzy7lBh0XGt37BJm7ZsU21tnTeGBAAAANAJOi1ANDQ0aPvOk08bDuS2fNoQYDZr/LjRmj51cmeVAAAAAMDDPB4gioqKtW7jJqVv3qaa2toW5+PjYjV96kSljhurgACzp4cHAAAA0Ik8EiAaGxu1/dTchpzcg622GZaSrCsuu0Txcf08MaTXFBQWKS19q7L27lN5RYUsFqvCQkMUE9NX48aM1MTUcR5dsrYzx6uorNKf/vq0M9jddvP1mjIp1WO1AwAA4NznVoAoOl6s9Rs3aVN6608bEocM0v6cXEnSiGFDz7rw8M3SFfpm2Uo1NjbfLK+svEJl5RXKzMrWqtXrde9dt6lP717dfrwPP/6s1X9OAAAAgFEuB4jGxkbn3IacAy2fNkSEh2nyxFRNmZSqXr166j8e/bWnavWqJctX6qtvlkuSAgMDNGvGVCUnDlFgYKBOlJRoQ9pm7c3er2P5BXrhlTf0xC8eVFhYaLcdLy19q3ZnZHW4PgAAAECuBIjjxSe0bsMmbdq8VTU1zX+L7ePjoxHDhmrq5AkalpIsHx+fzqjVa4qKirX41M18SEiwHn/k54ru09t5PqF/nMaPHa3PPl+klavXqaSkVF8s+kbzbrm+W45XXl6h+Z8vkiRFRoSrvKKyQ3UCAAAAhu/0//Dn/9PK79Y2Cw/RfXrrJ1f8SH/6f7/R/ffcrhHDU8768KBTTwPsdrsk6eorL292M9/UVVdept69ekqS0rds04mS0m453vsff6a6ujoFBQVpzuwZHaoRAAAAkCsB4rTQ0BBdctEFevLxh/W7/3xcF82Z5darO91NQ0ODdu3JkCQFBQUpdfyYNtv6+vpq6uQJkiS73a4dO3d3u/E2pKUrMytbknTl5ZcoODjY5RoBAACA01wOENXVNdq9J0sZWXtV0sHfuHdnuQfzVF9vkSQNHpggf7/23/JKShziPM44daPeXcYrKyvXZ198JUlKThqiGdPYcwMAAADuMTwHon98nA4fOSpJyi8oVH5Bob76epkGDUzQ1MkTNW7MSJnNZ/++DvkFhc7jOAOrRsXFxshkMsnhcCg/v/CM7b053nsfzVd9vUWBAQG69abrZDKZXK4PAAAAaMpwgPjVY/+ho8fytWbdRm3dtlMWq1U69Rv03IN5+nTBQo0fO1pTJk3QwAH9O7PmTlV0vNh53CMq8ozt/fz8FBYWqsrKKlXX1Ki6pkahISFdPt7a9Wnam71fknTNVZerZ48owzUBAAAAbXFpGde42H665cZrdc1VP1b65m1avzFdx/ILJEkWi1Ub0jZrQ9pm9Y3uo6mTJ2hi6rjOqrvTVFfXOI9DQ43N7QgLPXlDf7q/KwGiM8YrKSnV518uliSlDE3StCmTDNcDAAAAtKdDG8kFBgRo5vQpmjl9inIP5mnt+jRt37lbDQ0NkqTCouNasHCxFn61xNP1tqqiolIFhUUd7h8QYNbAAQmS5HyyIumM8xFO82vSzmKxttv2hzw9nsPh0HsfzZfFYlVQYKBuvelal+o5k9OrRQEAAMB9Z+O9lVs7UUvSoIEJGjQwQddfc4U2btqi9RvTdbz4hHRq07nTln37nerq6jV5UqoiwsPcHbaZzL379N6Hn3a4f0zfaP32149Jkmw2m/Nzvw7c0NsabO22/SFPj7d67Qbt239AknTt1VcoKvLMr0W5oujYYY9eDwAAAGcXtwPEacHBwbrwgpm68IKZ2rf/gNas26jdezLVeCpVlZdXaNHXS/X1kuUaMSJF06dMUsrQJE8N7zH+/v7OY9upJypn0tCknblJf2+PV3yiRAu/+kaSNGJ4iqZMSnWpFiOiY8/e+S0AAADdjd1uV1VubleX4RKPBYimkhIHKylxsKqqqrV+Y7o2pKWrtKxcktRot2vnrgzt3JWhnj2iNG3KRF089wK3xhs/dpSGJg8x0LJ1vr6+zuOAJitJNX060J6m7QICAlwa21Pj2e12vfvBp7JabQoODtItN1zjUh1GnQsbBQIAAKDjOiVAnBYWFqpLL56jSy66QBmZe7VuwyZlZGXL4XBIkkpKy/Tl4qVuBwiz2eyxJWSbbopXVVVtqE9FZaXzONzFTfU8Nd53a9brQO5BSdJN112tiIhwl+oAAAAAjOjUAHGayWTSiOEpGjE8RWVl5Vq3YZM2pm9xriTUnfSN7uM8Li0tO2N7i8WqmppaSVJERLiCgoK8Pl5p2ckgJkmx/WJk8jFp245drfY/vZfH6eOAgJPBK6ZvtGL6RrtUOwAAAM4/XgkQTUVFReqKyy/R5T+6SDt27dH6DZu8XUK74mK/38zt8NFjZ2yfd/iI8zg+9swbwXXGeCdOlDpfazqWX6A33n7f0Nhr1m3UmnUbJUmXXTJXl//oIpfrBwAAwPnF6wHiNB8fH40bM0rjxozqqhJaNSAhXqGhIaqurlHuwTzVW07u5NyWzKxs5/GokcO6/XgAAACAO7osQHRXp4PNmnUbZbValZa+VbNnTG21bX29RWnpW6VT8zBGjxzRJeMlJQ7Wi88+ZWi8jZu2OJe8ve3m6ztlpSYAAACcu1hSpxWXXDTHubzqosVLnLttN2W32/XhJwtUVX1y4vOc2dMVGtr6DtQP/uJJ55+SktJOHw8AAADoLDyBaEVkRLhuuPYnev+j+aqvt+gfz72kWTOmKSU5UQEBZhUdL9aatRt1MO/kpmoDE/rrkrlzzprxAAAAgI4iQLRh6uQJamho0IKFi2WxWLVsxSotW7GqRbuU5ETdOe9mmc2ubSDX1eMBAAAAHUGAaMfM6VOUMjRJ6zemKzMrW2Xl5bLZbAoPC1P/+DhNGD9Wo0cNP2vHAwAAAFxlys7OdnR1ETh7JCUldXUJAAAA5wy73a6cnJyuLsMlTKIGAAAAYBgBAgAAAIBhBAgAAAAAhhEgAAAAABhGgAAAAABgGAECAAAAgGEECAAAAACGESAAAAAAGEaAAAAAAGAYAQIAAACAYQQIAAAAAIYRIAAAAAAYRoAAAAAAYBgBAgAAAIBhBAgAAAAAhhEgAAAAABhGgAAAAABgGAECAAAAgGEECAAAAACGESAAAAAAGEaAAAAAAGAYAQIAAACAYQQIAAAAAIYRIAAAAAAYRoAAAAAAYBgBAgAAAIBhBAgAAAAAhhEgAAAAABhGgAAAAABgGAECAAAAgGEECAAAAACGESAAAAAAGEaAAAAAAGAYAQIAAACAYQQIAAAAAIYRIAAAAAAYRoAAAAAAYBgBAgAAAIBhBAgAAAAAhhEgAAAAABhGgAAAAABgGAECAAAAgGEECAAAAACGESAAAAAAGObX1QXg7LJv376uLgEAAABdiCcQAAAAAAwjQAAAAAAwjAABAAAAwDACBAAAAADDCBAAAAAADCNAAAAAADCMAAEAAADAMAIEAAAAAMPYSA4AAAA4R/zuf/6q0rIySdKLzz7VKWMQIAAAAHBe2rf/gJ578VWPXGvShPG6/dYbPHKt7o5XmAAAAAAYxhMIAAAAnJcS+sfrv558tM3zu3ZnatHXSyVJQwYP1I3XXdVm2+CgoE6psTsiQAAAAOC8FBBgVr+Yvm2ezzt81HkcGBDQbtvzCa8wAQAAADCMJxAAAACAB+QXFGrjpi06kHtQJ06Uqq6+Xn5+vgoLDVX/+DhNGD9Wo0YOk8lkavc6uzOytHXbTh0+clQVFZWy2mzy9/dTVGSkEvrHKXXcGA1LSe5wnXa7Xa++8Y52Z2RJkkaOGKb77rpNvr6+hvoTIAAAAAA3LfxqiZZ/+50cDkezz61Wu0pKy1RSWqbtO3dr2NAk3Xf3PJnN5hbXqK+36PW33lVW9v4W5ywWqwqLjquw6Lg2bd6mEcOG6p47b5PZ7O9yrR/PX+gMD4mDB+meO24xHB5EgAAAAADc893aDVq2YpUkyc/PTxfMnKbk5CEKCw2V1WpT3uEjWr5ytSoqKpW5d58+nv+F5t3ScsnXTz77whke+sX01awZUxXTN1pms1nVNdXKO3xU6zZsUllZufZk7tWnCxbq1puuc6nWJctWat2GNElSfFysHrjvDvn7uxZCCBAAAABAB9ntdi1Z+q3z55uuv1pTJqU2azNoYIJGjRimP/71adlsNm3avE2X/+gi9YiKcrapra3V5q07JEmREeF67OGfKugHKzulJCdpxtTJevqfL6uw6LjS0rfqissvUXhYmKFaN6Vvda4q1ad3Lz3407sVFBjo8ncmQAAAAAAdVFdXr9TxY1RdU6O6unpNGD+m1XY9e/bQiGFDtX3nbjkcDu3fn6tJE8c7zx8vLpHdbpckDRjQv0V4OC0kJFg3XPsTHcw7rJ49ouTjY2xNpKzsfXr/488kSZGREXro5/cqLDS0A9+YAAEAAAB0WEhIsK67+gpDbXv36uk8rqisbHbO3//72/Jjxwpka2iQv1/rt+rJSUOUnDTEcI1Hjubr9TffU2Njo0JDQvTQz+5t9vTDVQQIAAAAwIOsVqtqamplsVhkbzKpuq6+3nlsszU069M3uo8iI8JVXlGp4hMlevb5V/Tjyy5WcuIQw08ZWlNSWqaXX31T9RaLAgLM+vkDd6lvdJ8OX08ECAAAAMB9RceLtXrtBmVkZaukpLTFakxn4uvrq5tvuEb/euMd2e12Hco7ohdefkNBQUFKThysxMTBGpo0xKWb/9raWr30rzdVUVklSbr7jluV0D/e5e/2QwQIAAAAwA1p6Vv14ScL1NDQYKB120YMT9GjD/1Un3z2hY4czZck1dXVaceuPdqxa4906jWoyZNSNXvmNAUGBLR7vVde/7cKi447f87MytaIYUPdqlEECAAAAKDjDh85pvc/mu+cAB0X208XXjBTgwYmKDQ0pNlN/uJvluvrpSvavd6ggQn69S8fUd7ho9q5e4+y9u7XkaPHnE80ik+UaNHipVq7bqPuv+cOJfSPa/NaB3IPyWQyyd/fT1arTavXblBy0hCNHjncre9MgAAAAAA6aMXK1c7wMGjgAD384H1tTn5utDcavm5C/zgl9I/TlZdfqtraWu3bn6vtu3Zr5649stkaVF5RqZdfe0u//80v21yxyd/fX/NuuV4+Pj56/a33JEnvfzhf/eNiFRUV2aHvK0kdn5EBAAAAnOdycg86jy+9eE6b4UGnJjR3RHBwsMaMHqG75t2s3/zqUfXq2UOSVFVVrfQt29vs9+hDD2j82NEaO3qkpk2ZKEmqqa3VW+9+6Aw9HUGAAAAAADqourrGedyvb3Sb7axWqzIys90er0/vXrr04gudP+cXFLXZtumE6euuvsI5AftA7iF9vaT9V6naQ4AAAAAAOsjs7+88rq2ra7PdkuUrVdfk/A9fZ1q1er1ef/s9vfDy62dcwSk0NKTJ+MZmJJjNZt19xy3yO/WEZMnyldq3/4Chvj9EgAAAAAA6KC62n/N42/Zdrbb5bu0GLVvxnRIHD3J+Vlpa3qzNocOHtX3HbmVl79fyb1e3OZ7D4dCm9K3OnwcM6G+41th+Mbr6ysuc13n7vY+aPUExiknUAAAAQAdNnpSq/QdyJUnLvv1OtgabRgxLkZ+frwqLirVx0xblHjyklKFJuvjC2XruxVclSbv2ZGjLth3q1bOnYvv11WWXzNWu3ZmyWq1a+NU3yt63X+PGjlbvXj0VHBwkq9WmouPHtWnzNu3POTlebL8Yl1dUmj1zmrKy92tPRpYqKir17gef6Kf33SmTyWT4GgQIAAAAoIMmTRinPRlZ2r5zt+x2u75dtVbfrlrbrE1S4mDdc+et8vP1VWhoiKqra2SxWPXWOx9Kkv7wuycV3ae3Hrj3Dr317w9UXVOjvftytHdfTpvjDhzQX/fdNc/5SpIr5t18vf7892dVUVGpPZl7tfK7tbrwgpmG+xMgAAAAgA4ymUy6+45btHHTZqWlb1V+QaEabA0KDw9XbL++mjRxvEaPHC4fn5MzBx584B7N/3yRjh3Ll8nHR/Fx/RQYGChJGpo0RP/vd7/SpvStyty7TwUFRaqqrlZDQ4MCzGZFRkYoPj5W48aM0sjhKS49NWgqNDREt996o3O+xZdfLVHikEHqH9/2nhLNvnN2drZr+2wDAAAAOG8xiRoAAACAYQQIAAAAAIYRIAAAAAAYRoAAAAAAYBgBAgAAAIBhBAgAAAAAhhEgAAAAABhGgAAAAABgGAECAAAAgGEECAAAAACGESAAAAAAGObX1QUAAAAA55OCwiKlpW9V1t59Kq+okMViVVhoiGJi+mrcmJGamDpOvr6+XV1mm0zZ2dmOri4CAAAAOB98s3SFvlm2Uo2NjW22ie0Xo3vvuk19evfyam1GESAAAAAAL1iyfKUWLV4qSQoMDNCsGVOVnDhEgYGBOlFSog1pm7U3e78kqWfPHnriFw8qLCy0i6tuiQABAAAAdLKiomL971NPy263KyQkWI8/8nNF9+ndot1nny/SytXrJEmTJ6Zq3i3Xd0G17WMSNQAAANDJlixfKbvdLkm6+srLWw0PknTVlZepd6+ekqT0Ldt0oqTUq3UaQYAAAAAAOlFDQ4N27cmQJAUFBSl1/Jg22/r6+mrq5AmSJLvdrh07d3utTqMIEAAAAEAnyj2Yp/p6iyRp8MAE+fu1vxBqUuIQ53FGVnan1+cqAgQAAADQifILCp3HcXH9ztg+LjZGJpPpZN/8wjO29zYCBAAAANCJio4XO497REWesb2fn59z9aXqmhpV19R0an2uIkAAAAAAnai6+vsAEBpqbFnWsCbtmvbvDggQAAAAQCeyWK3O4zPNfzjNr0k7i8XabltvI0AAAAAAnchmszmP/ToQIGwNtnbbehsBAgAAAOhE/v7+zmNbQ4OhPg1N2pmb9O8OCBAAAABAJwowm53HTZ9GtKdpu4CAgE6pq6MIEAAAAEAnOr2ikiRVVVUb6lNRWek8Dg8zNvHaWwgQAAAAQCfqG93HeVxaWnbG9haLVTU1tZKkiIhwBQUFdWp9riJAAAAAAJ0oLvb7zeMOHz12xvZ5h484j+Njz7zxnLcRIAAAAIBONCAhXqGhIZKk3IN5qrdY2m2fmZXtPB41clin1+cqAgQAAADQiXx8fDRuzChJktVqVVr61jbb1tdbnOfNZrNGjxzhtTqNIkAAAAAAneySi+Y4l3NdtHiJjuUXtGhjt9v14ScLVFV9cqL1nNnTnU8uuhNTdna2o6uLAAAAAM51G9I26/2P5kuSAgLMmjVjmlKSExUQYFbR8WKtWbtRB/MOS5IGJvTXww/eL7O5e+0BIQIEAAAA4D1r1m3UgoWL290PIiU5UXfOu7lbPn0QAQIAAADwruITJVq/MV2ZWdkqKy+XzWZTeFiY+sfHacL4sRo9anhXl9guAgQAAAAAw5hEDQAAAMAwAgQAAAAAwwgQAAAAAAwjQAAAAAAwjAABAAAAwDACBAAAAADDCBAAAAAADCNAAAAAADCMAAEAAADAMAIEAAAAAMMIEAAAAAAMI0AAAAAAMMyvqwsAAMCTfvc/f1VpWZkk6cVnn+rqcgDgnEOAAIDz1L79B/Tci6965FqTJozX7bfe4JFrnS1KSkr13388GVDMZrOe+dsfW7Q509+xj4+PgoOCFBwcpF49e2jQoAFKThysQQMHdGrtAOAOAgQAAF3EbreruqZG1TU1Ol58Qpl79+krSXGx/XTx3NkaP3Z0V5cIAC0QIADgPJXQP17/9eSjbZ7ftTtTi75eKkkaMnigbrzuqjbbBgcFdUqN55LevXrq/ntub/ZZY2OjamrrVFFeoQMHDykjc6/KKyp19Fi+3vz3B9q1J1M3X3+NAgMDuqxuAPghAgQAnKcCAszqF9O3zfN5h486jwMDAtptizPz8/Nr9+9w0sTxamxsVFr6Vi1Y+JXq6y3asnWHKioq9dDP7pWvr69X6wWAtrAKEwAA3YSvr6+mTZmoJx9/WFGREZKk/Tm5+nTBl11dGgA48QQCAOAx+QWF2rhpiw7kHtSJE6Wqq6+Xn5+vwkJD1T8+ThPGj9WokcNkMpnavc7ujCxt3bZTh48cVUVFpaw2m/z9/RQVGamE/nFKHTdGw1KSO1yn3W7Xq2+8o90ZWZKkkSOG6b67bus2v+Xv07uX7rt7nv7x3MtqbGzUug2bNGvGVMX0je7q0gCAAAEA8IyFXy3R8m+/k8PhaPa51WpXSWmZSkrLtH3nbg0bmqT77p4ns9nc4hr19Ra9/ta7ysre3+KcxWJVYdFxFRYd16bN2zRi2FDdc+dtMpv9Xa714/kLneEhcfAg3XPHLd0mPJyW0D9eE1PHauOmLXI4HFq24jvdcduNXV0WABAgAADu+27tBi1bsUo69a7/BTOnKTl5iMJCQ2W12pR3+IiWr1ytiopKZe7dp4/nf6F5t7Rc9vWTz75whod+MX2dv3U3m82qrqlW3uGjWrdhk8rKyrUnc68+XbBQt950nUu1Llm2Uus2pEmS4uNi9cB9d8jf3/UQ4g2zZkzVxk1bJEmZWdlyOBxnfHoDAJ2NAAEAcIvdbteSpd86f77p+qs1ZVJqszaDBiZo1Ihh+uNfn5bNZtOmzdt0+Y8uUo+oKGeb2tpabd66Q5IUGRGuxx7+qYJ+sLpTSnKSZkydrKf/+bIKi44rLX2rrrj8EoWHhRmqdVP6VufKUn1699KDP71bQYGBbn3/zhQX20/BwUGqra1TdU2NjuUXKC62X1eXBeA8R4AAALilrq5eqePHqLqmRnV19Zowfkyr7Xr27KERw4Zq+87dcjgc2r8/V5MmjneeP15cIrvdLkkaMKB/i/BwWkhIsG649ic6mHdYPXtEycfH2HogWdn79P7Hn0mSIiMj9NDP71VYaGgHvrH3mEwm9Yvpq5wDByVJJSVlBAgAXY4AAQBwS0hIsK67+gpDbXv36uk8rqisbHbO3//7/yQdO1YgW0OD/P1a/89UctIQJScNMVzjkaP5ev3N99TY2KjQkBA99LN7mz396M5CQoKdx9U1NV1aCwCIAAEA6AxWq1U1NbWyWCyyN5lUXVdf7zy22Rqa9ekb3UeREeEqr6hU8YkSPfv8K/rxZRcrOXGI4acMrSkpLdPLr76peotFAQFm/fyBu9Q3uk+Hr+dtTSebW63WLq0FAESAAAB4StHxYq1eu0EZWdkqKSltsRrTmfj6+urmG67Rv954R3a7XYfyjuiFl99QUFCQkhMHKzFxsIYmDXHp5r+2tlYv/etNVVRWSZLuvuNWJfSPd/m7dSVLvcV5HBDQcuUqAPA2AgQAwG1p6Vv14ScL1NDQYKB120YMT9GjD/1Un3z2hY4czZck1dXVaceuPdqxa4906jWoyZNSNXvmNAUGBLR7vVde/7cKi447f87MytaIYUPdqtHbSsvKnceRERFdWgsAiAABAHDX4SPH9P5H850ToONi++nCC2Zq0MAEhYaGNLvJX/zNcn29dEW71xs0MEG//uUjyjt8VDt371HW3v06cvSY84lG8YkSLVq8VGvXbdT999yhhP5xbV7rQO4hmUwm+fv7yWq1afXaDUpOGqLRI4d77Pt3JqvVqsLCIufPMTFsJAeg6xEgAABuWbFytTM8DBo4QA8/eF+bk58b7Y2Gr5vQP04J/eN05eWXqra2Vvv252r7rt3auWuPbLYGlVdU6uXX3tLvf/PLNlds8vf317xbrpePj49ef+s9SdL7H85X/7hYRUVFduj7elPm3n1qaDz5dxbdp7eiIrt/zQDOfR2flQYAgKSc3IPO40svntNmeNCpCc0dERwcrDGjR+iueTfrN796VL169pAkVVVVK33L9jb7PfrQAxo/drTGjh6paVMmSpJqamv11rsfOkNPd7Z67QbncVvL4wKAtxEgAABuqa7+fmnRfn3bfsXGarUqIzPb7fH69O6lSy++0PlzfkFRm22bTpi+7uornBOwD+Qe0tdL2n+Vqqtt3b5T+/YfkCQFBgRo+rTJXV0SAEgECACAu8z+/s7j2rq6NtstWb5SdU3O//B1plWr1+v1t9/TCy+/fsYVnEJDQ5qMb+xtXLPZrLvvuEV+p56QLFm+0nmD3t3kHT6iD05teidJl//oom6/6R2A8wcBAgDglqY7I2/bvqvVNt+t3aBlK75T4uBBzs9KS8ubtTl0+LC279itrOz9Wv7t6jbHczgc2pS+1fnzgAH9Ddca2y9GV195mfM6b7/3UbMnKF3Nbrdr7fo0PfvCq6o/tXzrmNEjdMGs6V1dGgA4MYkaAOCWyZNStf9AriRp2bffydZg04hhKfLz81VhUbE2btqi3IOHlDI0SRdfOFvPvfiqJGnXngxt2bZDvXr2VGy/vrrskrnatTtTVqtVC7/6Rtn79mvc2NHq3aungoODZLXaVHT8uDZt3qb9OSfHi+0X4/KKSrNnTlNW9n7tychSRUWl3v3gE/30vjtlMpk64W/new0NDcovKGz184qKSh3MO6yt23bqREmp89yE1LGad/P1nV4bALiCAAEAcMukCeO0JyNL23fult1u17er1urbVWubtUlKHKx77rxVfr6+Cg0NUXV1jSwWq95650NJ0h9+96Si+/TWA/feobf+/YGqa2q0d1+O9u7LaXPcgQP667675jlfSXLFvJuv15///qwqKiq1J3OvVn63VhdeMLMD39644hMl+tNTzxhq27NHlK68/FKlMnEaQDdEgAAAuMVkMunuO27Rxk2blZa+VfkFhWqwNSg8PFyx/fpq0sTxGj1yuHx8Tr41++AD92j+54t07Fi+TD4+io/rp8DAQEnS0KQh+n+/+5U2pW9V5t59KigoUlV1tRoaGhRgNisyMkLx8bEaN2aURg5P6fBv5kNDQ3T7rTc651t8+dUSJQ4ZpP7xbe8p0Vl8fHwUEBCgHlGRSugfpxHDUzRi2FD5+vp6vRYAMMKUnZ3d/kw1AAAAADiFSdQAAAAADCNAAAAAADCMAAEAAADAMAIEAAAAAMMIEAAAAAAMI0AAAAAAMIwAAQAAAMAwAgQAAAAAwwgQAAAAAAwjQAAAAAAwjAABAAAAwDACBAAAAADDCBAAAAAADCNAAAAAADCMAAEAAADAMAIEAAAAAMP+P1WexBemhzoCAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# For each metric, plot a bar chart where each bucket is for a task,\n", + "# and in each bucket, every table_size-zch_method combination has a bar\n", + "# the Y-axis shows the average metric value of that setting\n", + "for metric_name in metrics_task_id_table_size_zch_method_avetage_value_dict:\n", + " fig = plt.figure(figsize=(8, 6))\n", + " font_size = 24\n", + " bucket_width = 0.8\n", + " x_ticks = []\n", + " x_labels = []\n", + " for task_id in metrics_task_id_table_size_zch_method_avetage_value_dict[metric_name]:\n", + " task_bucket_offest = task_id + 1.0\n", + " bucket_bar_label_list = []\n", + " bucket_bar_val_list = []\n", + " bucket_bar_color_list = []\n", + " bucket_bar_shadow_list = []\n", + " for table_size in metrics_task_id_table_size_zch_method_avetage_value_dict[metric_name][task_id]:\n", + " for zch_method in metrics_task_id_table_size_zch_method_avetage_value_dict[metric_name][task_id][table_size]:\n", + " metric_value = metrics_task_id_table_size_zch_method_avetage_value_dict[metric_name][task_id][table_size][zch_method]\n", + " bucket_bar_val_list.append(metric_value)\n", + " bucket_bar_label_list.append(f\"{table_size}M-{zch_method}\")\n", + " if \"nonzch\" in zch_method:\n", + " bucket_bar_color_list.append(\"red\")\n", + " bucket_bar_shadow_list.append((0, 0))\n", + " else:\n", + " bucket_bar_color_list.append(\"blue\")\n", + " bucket_bar_shadow_list.append((1, 1))\n", + " bucket_x_step = bucket_width / len(bucket_bar_label_list)\n", + " bucket_x_offset = bucket_x_step / 2\n", + " plt.bar([x * bucket_x_step + task_bucket_offest - bucket_x_offset for x in range(len(bucket_bar_label_list))] , bucket_bar_val_list, width=bucket_x_step, label=bucket_bar_label_list, color=bucket_bar_color_list, alpha=0.5, edgecolor=\"black\", linewidth=2)\n", + " x_ticks.append(task_bucket_offest)\n", + " x_labels.append(f\"Task\\n{task_id}\")\n", + " # maually set legend to show non-zch is a red bar and zch is a blue bar\\\n", + " import matplotlib.patches as mpatches\n", + " # Create custom legend patches\n", + " nonzch_patch = mpatches.Patch(color='red', label='Non-ZCH')\n", + " zch_patch = mpatches.Patch(color='blue', label='ZCH')\n", + " # Add legend to the figure\n", + " plt.legend(handles=[nonzch_patch, zch_patch], loc='upper right')\n", + " # plt.legend()\n", + " plt.xticks(x_ticks, x_labels, fontsize=font_size)\n", + " plt.yticks(fontsize=font_size)\n", + " # plt.legend(fontsize=font_size)\n", + " plt.title(f\"{metric_name}\", fontsize=font_size)\n", + " plt.xlabel(\"Task ID\", fontsize=font_size)\n", + " plt.ylabel(\"Average Metric Value\", fontsize=font_size)\n", + " plt.grid(True)\n", + " plt.tight_layout()\n", + " plt.savefig(os.path.join(figure_folder, f\"eval_metrics_{metric_name}.png\"))\n", + " plt.show()\n", + " plt.close(fig)\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "# plot the ratio of accumulated_collision_count / accumulated_total_count" + ] + } + ], + "metadata": { + "fileHeader": "", + "fileUid": "48f0276b-0d89-4f9f-9a7a-2038c58a3c2e", + "isAdHoc": false, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "bento_kernel_default" + }, + "language_info": { + "name": "plaintext" + }, + "orig_nbformat": 4 + } +} diff --git a/torchrec/distributed/benchmark/benchmark_zch/plots/plot_imbalanced_num_queries_compare.ipynb b/torchrec/distributed/benchmark/benchmark_zch/plots/plot_imbalanced_num_queries_compare.ipynb new file mode 100644 index 000000000..f8214738e --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/plots/plot_imbalanced_num_queries_compare.ipynb @@ -0,0 +1,2664 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import csv\n", + "import numpy as np\n", + "import pandas as pd\n", + "import re\n", + "import os\n", + "import json" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "output": { + "id": 749292667455159, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['result_tbsize_10000_zch_dlrmv3_kuairand', 'result_tbsize_1000_zch_dlrmv3_kuairand']\n" + ] + } + ], + "source": [ + "zch_stats_folders = [x for x in os.listdir(\"/home/lizhouyu/home/lizhouyu/zch_results\") if x.startswith(\"result_tbsize\") and \"nonzch\" not in x]\n", + "print(zch_stats_folders)\n", + "#" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "figure_folder = \"/home/lizhouyu/home/lizhouyu/zch_results_figures\"\n", + "os.makedirs(figure_folder, exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def get_per_rank_num_queries(zch_stats_file_folder):\n", + " zch_stats_file_path = os.path.join(zch_stats_file_folder, 'zch_metrics.csv')\n", + " df_zch_stats = pd.read_csv(zch_stats_file_path)\n", + " # maintain a dictionary of {feature_name: {rank: {batch_idx: num_queries}}}\n", + " feature_name_rank_num_queries_count_dict = {}\n", + " for index, row in df_zch_stats.iterrows():\n", + " feature_name = row[\"feature_name\"]\n", + " batch_idx = row[\"batch_idx\"]\n", + " rank_total_cnt = row[\"rank_total_cnt\"]\n", + " rank_total_cnt_dict = json.loads(rank_total_cnt)\n", + " if feature_name not in feature_name_rank_num_queries_count_dict:\n", + " feature_name_rank_num_queries_count_dict[feature_name] = {}\n", + " for rank_idx, rank_num_queries in rank_total_cnt_dict.items():\n", + " if rank_idx not in feature_name_rank_num_queries_count_dict[feature_name]:\n", + " feature_name_rank_num_queries_count_dict[feature_name][rank_idx] = {}\n", + " feature_name_rank_num_queries_count_dict[feature_name][rank_idx][batch_idx] = rank_num_queries\n", + " return feature_name_rank_num_queries_count_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def get_per_rank_empty_slots(zch_stats_file_folder):\n", + " zch_stats_file_path = os.path.join(zch_stats_file_folder, 'zch_metrics.csv')\n", + " df_zch_stats = pd.read_csv(zch_stats_file_path)\n", + " # maintain a dictionary of {feature_name: {rank: {batch_idx: num_queries}}}\n", + " feature_name_rank_num_queries_count_dict = {}\n", + " for index, row in df_zch_stats.iterrows():\n", + " feature_name = row[\"feature_name\"]\n", + " batch_idx = row[\"batch_idx\"]\n", + " rank_total_cnt = row[\"rank_num_empty_slots\"]\n", + " rank_total_cnt_dict = json.loads(rank_total_cnt)\n", + " if feature_name not in feature_name_rank_num_queries_count_dict:\n", + " feature_name_rank_num_queries_count_dict[feature_name] = {}\n", + " for rank_idx, rank_num_queries in rank_total_cnt_dict.items():\n", + " if rank_idx not in feature_name_rank_num_queries_count_dict[feature_name]:\n", + " feature_name_rank_num_queries_count_dict[feature_name][rank_idx] = {}\n", + " feature_name_rank_num_queries_count_dict[feature_name][rank_idx][batch_idx] = rank_num_queries\n", + " return feature_name_rank_num_queries_count_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "re_zch_method_name_pattern = re.compile(r\"\\d+_((non)?zch(_.*)?)\")\n", + "re_table_size_pattern = re.compile(r\"result_tbsize_(\\d+)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "output": { + "id": 1344910903270019, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "zch_dlrmv3_kuairand 10000\n", + "zch_dlrmv3_kuairand 1000\n", + "{10000: {'zch_dlrmv3_kuairand': {'video_id': {'2': {0: 3065, 1: 3185, 2: 3098, 3: 3149, 4: 3076, 5: 3063, 6: 3166, 7: 3166, 8: 3056, 9: 3053, 10: 3102, 11: 1803}, '1': {0: 3212, 1: 3207, 2: 3113, 3: 3125, 4: 3132, 5: 3113, 6: 3143, 7: 3107, 8: 3189, 9: 3149, 10: 3256, 11: 1761}, '3': {0: 3035, 1: 2902, 2: 2984, 3: 3075, 4: 3037, 5: 3080, 6: 2972, 7: 2983, 8: 3029, 9: 3024, 10: 2965, 11: 1635}, '0': {0: 3104, 1: 3122, 2: 3221, 3: 3067, 4: 3171, 5: 3160, 6: 3135, 7: 3160, 8: 3142, 9: 3190, 10: 3093, 11: 1785}}, 'user_id': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 64, 1: 64, 2: 64, 3: 64, 4: 64, 5: 64, 6: 64, 7: 64, 8: 64, 9: 64, 10: 64, 11: 36}}, 'user_active_degree': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 64, 1: 64, 2: 64, 3: 64, 4: 64, 5: 64, 6: 64, 7: 64, 8: 64, 9: 64, 10: 64, 11: 36}}, 'follow_user_num_range': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 64, 1: 64, 2: 64, 3: 64, 4: 64, 5: 64, 6: 64, 7: 64, 8: 64, 9: 64, 10: 64, 11: 36}}, 'fans_user_num_range': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 64, 1: 64, 2: 64, 3: 64, 4: 64, 5: 64, 6: 64, 7: 64, 8: 64, 9: 64, 10: 64, 11: 36}}, 'friend_user_num_range': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 64, 1: 64, 2: 64, 3: 64, 4: 64, 5: 64, 6: 64, 7: 64, 8: 64, 9: 64, 10: 64, 11: 36}}, 'register_days_range': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 64, 1: 64, 2: 64, 3: 64, 4: 64, 5: 64, 6: 64, 7: 64, 8: 64, 9: 64, 10: 64, 11: 36}}}}, 1000: {'zch_dlrmv3_kuairand': {'video_id': {'2': {0: 3065, 1: 3185, 2: 3098, 3: 3149, 4: 3076, 5: 3063, 6: 3166, 7: 3166, 8: 3056, 9: 3053, 10: 3102, 11: 1803}, '1': {0: 3212, 1: 3207, 2: 3113, 3: 3125, 4: 3132, 5: 3113, 6: 3143, 7: 3107, 8: 3189, 9: 3149, 10: 3256, 11: 1761}, '3': {0: 3035, 1: 2902, 2: 2984, 3: 3075, 4: 3037, 5: 3080, 6: 2972, 7: 2983, 8: 3029, 9: 3024, 10: 2965, 11: 1635}, '0': {0: 3104, 1: 3122, 2: 3221, 3: 3067, 4: 3171, 5: 3160, 6: 3135, 7: 3160, 8: 3142, 9: 3190, 10: 3093, 11: 1785}}, 'user_id': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 64, 1: 64, 2: 64, 3: 64, 4: 64, 5: 64, 6: 64, 7: 64, 8: 64, 9: 64, 10: 64, 11: 36}}, 'user_active_degree': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 64, 1: 64, 2: 64, 3: 64, 4: 64, 5: 64, 6: 64, 7: 64, 8: 64, 9: 64, 10: 64, 11: 36}}, 'follow_user_num_range': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 64, 1: 64, 2: 64, 3: 64, 4: 64, 5: 64, 6: 64, 7: 64, 8: 64, 9: 64, 10: 64, 11: 36}}, 'fans_user_num_range': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 64, 1: 64, 2: 64, 3: 64, 4: 64, 5: 64, 6: 64, 7: 64, 8: 64, 9: 64, 10: 64, 11: 36}}, 'friend_user_num_range': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 64, 1: 64, 2: 64, 3: 64, 4: 64, 5: 64, 6: 64, 7: 64, 8: 64, 9: 64, 10: 64, 11: 36}}, 'register_days_range': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 64, 1: 64, 2: 64, 3: 64, 4: 64, 5: 64, 6: 64, 7: 64, 8: 64, 9: 64, 10: 64, 11: 36}}}}}\n", + "{10000: {'zch_dlrmv3_kuairand': {'video_id': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}}, 'user_id': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}}, 'user_active_degree': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}}, 'follow_user_num_range': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}}, 'fans_user_num_range': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}}, 'friend_user_num_range': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}}, 'register_days_range': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}}}}, 1000: {'zch_dlrmv3_kuairand': {'video_id': {'2': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '3': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}, '0': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}}, 'user_id': {'2': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '1': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '3': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '0': {0: 186, 1: 122, 2: 58, 3: 1, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0}}, 'user_active_degree': {'2': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '1': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '3': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '0': {0: 246, 1: 245, 2: 245, 3: 245, 4: 244, 5: 243, 6: 243, 7: 243, 8: 243, 9: 243, 10: 243, 11: 243}}, 'follow_user_num_range': {'2': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '1': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '3': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '0': {0: 242, 1: 242, 2: 242, 3: 242, 4: 242, 5: 242, 6: 242, 7: 242, 8: 242, 9: 242, 10: 242, 11: 242}}, 'fans_user_num_range': {'2': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '1': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '3': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '0': {0: 245, 1: 244, 2: 244, 3: 243, 4: 242, 5: 242, 6: 242, 7: 242, 8: 242, 9: 242, 10: 242, 11: 242}}, 'friend_user_num_range': {'2': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '1': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '3': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '0': {0: 243, 1: 243, 2: 243, 3: 243, 4: 243, 5: 243, 6: 243, 7: 243, 8: 243, 9: 243, 10: 243, 11: 243}}, 'register_days_range': {'2': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '1': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '3': {0: 250, 1: 250, 2: 250, 3: 250, 4: 250, 5: 250, 6: 250, 7: 250, 8: 250, 9: 250, 10: 250, 11: 250}, '0': {0: 243, 1: 243, 2: 243, 3: 243, 4: 243, 5: 243, 6: 243, 7: 243, 8: 243, 9: 243, 10: 243, 11: 243}}}}}\n" + ] + } + ], + "source": [ + "table_size_zch_method_per_rank_num_queries_dict = {}\n", + "table_size_zch_method_per_rank_num_empty_identity_slots = {}\n", + "for zch_stats_folder in zch_stats_folders:\n", + " zch_method_name = re_zch_method_name_pattern.search(zch_stats_folder).group(1)\n", + " table_size = int(re_table_size_pattern.search(zch_stats_folder).group(1))\n", + " print(zch_method_name, table_size)\n", + " zch_stats_file_folder = os.path.join(\"/home/lizhouyu/home/lizhouyu/zch_results\", zch_stats_folder)\n", + " feature_name_rank_num_queries_count_dict = get_per_rank_num_queries(zch_stats_file_folder)\n", + " feature_name_rank_num_empty_identity_slots = get_per_rank_empty_slots(zch_stats_file_folder)\n", + " if table_size not in table_size_zch_method_per_rank_num_queries_dict:\n", + " table_size_zch_method_per_rank_num_queries_dict[table_size] = {}\n", + " table_size_zch_method_per_rank_num_empty_identity_slots[table_size] = {}\n", + " table_size_zch_method_per_rank_num_queries_dict[table_size][zch_method_name] = feature_name_rank_num_queries_count_dict\n", + " table_size_zch_method_per_rank_num_empty_identity_slots[table_size][zch_method_name] = feature_name_rank_num_empty_identity_slots\n", + "print(table_size_zch_method_per_rank_num_queries_dict)\n", + "print(table_size_zch_method_per_rank_num_empty_identity_slots)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot collision rate" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "output": { + "id": 4050376415234859, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0630 002128.085 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002128.086 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002128.087 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002128.089 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002128.201 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002128.202 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002128.203 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002128.204 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002128.206 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002128.207 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002128.209 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002128.210 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002128.271 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002128.272 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002128.273 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002128.274 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002128.320 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002128.320 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002128.322 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002128.323 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002128.370 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002128.371 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002128.372 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002128.373 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002128.419 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002128.420 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002128.421 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002128.422 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002128.469 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002128.469 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002128.470 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002128.471 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002128.518 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002128.519 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002128.520 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002128.520 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002128.610 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002128.611 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002128.612 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002128.614 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.101 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.102 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.104 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.105 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.145 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.146 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.147 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.148 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.149 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.150 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.151 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.151 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.204 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.205 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.206 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.207 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.258 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.259 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.259 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.261 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.290 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.290 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.291 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.293 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.302 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.303 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.304 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.306 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.333 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.334 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.334 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.337 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.346 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.347 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.348 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.348 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.377 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.378 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.379 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.380 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.390 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.391 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.392 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.392 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.421 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.422 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.422 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.423 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.434 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.434 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.435 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.436 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.464 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.464 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.465 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.466 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.476 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.476 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.477 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.479 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.506 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.507 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.507 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.508 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.564 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.565 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.566 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.566 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.594 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.594 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.595 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.596 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002129.968 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002129.969 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002129.970 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002129.971 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002130.017 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002130.018 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002130.019 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002130.021 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002130.022 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002130.023 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002130.024 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002130.025 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002130.090 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002130.091 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002130.092 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002130.092 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002130.123 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002130.124 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002130.125 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002130.126 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002130.156 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002130.156 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002130.157 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002130.158 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002130.189 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002130.189 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002130.190 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002130.191 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002130.220 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002130.220 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002130.221 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002130.223 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002130.253 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002130.254 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002130.254 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002130.255 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002130.321 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002130.322 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002130.323 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002130.324 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002130.389 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002130.390 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002130.392 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002130.393 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002130.427 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002130.427 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002130.428 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002130.429 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002130.464 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002130.465 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002130.465 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002130.466 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002130.501 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002130.502 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002130.502 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002130.503 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002130.538 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002130.539 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002130.540 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002130.542 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002130.576 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002130.577 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002130.577 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002130.578 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002130.614 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002130.615 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002130.615 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002130.616 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002130.672 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002130.673 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002130.674 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002130.675 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002131.125 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002131.126 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002131.127 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002131.128 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002131.239 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002131.240 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002131.240 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002131.241 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002131.243 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002131.244 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002131.245 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002131.247 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002131.312 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002131.313 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002131.313 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002131.314 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002131.361 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002131.362 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002131.362 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002131.363 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002131.410 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002131.411 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002131.413 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002131.414 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002131.460 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002131.461 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002131.461 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002131.462 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002131.509 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002131.510 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002131.510 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002131.511 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002131.558 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002131.559 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002131.560 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002131.561 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002131.648 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002131.649 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002131.650 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002131.650 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.140 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.141 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.142 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.143 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.184 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.185 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.186 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.187 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.189 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.189 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.190 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.191 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.243 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.244 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.245 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.247 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.274 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.274 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.275 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.276 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.304 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.305 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.306 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.307 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.317 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.318 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.319 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.320 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.349 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.350 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.350 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.351 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.362 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.363 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.363 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.365 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.393 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.394 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.395 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.395 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.406 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.407 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.409 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.409 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.438 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.439 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.440 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.442 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.451 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.452 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.452 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.453 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.481 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.482 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.482 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.483 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.494 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.494 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.496 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.497 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.525 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.526 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.527 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.527 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.608 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.609 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.610 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.612 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.637 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002132.638 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002132.639 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002132.641 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002132.999 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.000 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.001 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.002 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002133.048 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.049 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.049 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.050 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002133.053 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.054 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.054 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.055 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002133.120 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.121 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.122 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.123 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002133.154 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.154 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.156 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.156 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002133.186 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.187 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.188 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.189 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002133.219 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.220 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.221 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.224 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002133.253 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.254 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.254 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.255 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002133.285 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.286 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.287 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.288 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002133.357 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.358 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.359 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.360 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002133.426 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.427 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.428 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.429 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002133.465 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.465 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.466 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.468 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002133.502 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.502 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.503 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.504 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002133.539 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.540 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.541 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.542 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002133.578 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.579 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.579 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.581 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002133.616 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.617 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.617 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.618 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002133.654 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.655 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.656 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.657 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002133.714 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002133.716 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002133.717 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002133.717 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n" + ] + } + ], + "source": [ + "# plot the num_queries vs batch_idx for each table size, zch_method, and feature_name\n", + "for table_size in table_size_zch_method_per_rank_num_queries_dict:\n", + " for zch_method_name in table_size_zch_method_per_rank_num_queries_dict[table_size]:\n", + " # plot len(table_size_zch_method_per_rank_num_queries_dict[table_size][zch_method_name]) subfigures\n", + " # each row has 3 figures\n", + " fig, axs = plt.subplots(len(table_size_zch_method_per_rank_num_queries_dict[table_size][zch_method_name]) // 3 + 1,\n", + " 3,\n", + " figsize=(30, 30))\n", + " plt.title(f\"table size {table_size}, zch_method: {zch_method_name}\")\n", + " subfig_idx = 0\n", + " for feature_name in table_size_zch_method_per_rank_num_queries_dict[table_size][zch_method_name]:\n", + " rank_num_queries_count_dict = table_size_zch_method_per_rank_num_queries_dict[table_size][zch_method_name][feature_name]\n", + " # plot the num_queries vs batch_idx for each rank\n", + " for rank_idx in rank_num_queries_count_dict:\n", + " num_queries_list = list(rank_num_queries_count_dict[rank_idx].values())\n", + " batch_idx_list = list(rank_num_queries_count_dict[rank_idx].keys())\n", + " axs[subfig_idx // 3][subfig_idx % 3].plot(batch_idx_list, num_queries_list, label=f\"rank {rank_idx}\")\n", + " axs[subfig_idx // 3][subfig_idx % 3].set_title(f\"feature {feature_name}\")\n", + " subfig_idx += 1\n", + " fig_path = os.path.join(figure_folder, f\"num_queries_per_rank_table_size_{table_size}_zch_method_{zch_method_name}\")\n", + " plt.tight_layout()\n", + " plt.show()\n", + " fig.savefig(fig_path)\n", + " plt.close()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot collision rate for a specific feature" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "output": { + "id": 1911975122979712, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0630 002134.115 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.116 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.117 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.117 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.141 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.142 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.143 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.144 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.146 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.147 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.147 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.148 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.172 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.173 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.174 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.175 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.183 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.184 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.185 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.186 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.188 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.189 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.190 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.191 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.194 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.195 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.195 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.196 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.198 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.199 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.200 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.201 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.204 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.205 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.205 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.207 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.208 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.209 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.210 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.212 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.214 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.214 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.215 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.216 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.219 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.219 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.220 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.221 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.248 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.249 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.250 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.251 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.254 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.255 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.255 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.256 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.259 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.259 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.260 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.261 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.263 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.263 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.264 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.266 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.271 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.271 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.272 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.273 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.276 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.276 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.277 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.278 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.281 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.281 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.282 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.283 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.285 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.285 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.286 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.287 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.292 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.293 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.294 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.295 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.297 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.297 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.298 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.299 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.303 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.303 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.304 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.304 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.307 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.308 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.309 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.309 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.313 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.314 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.314 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.315 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.318 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.318 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.319 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.323 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.329 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.330 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.332 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.334 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.336 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.340 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.342 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.343 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.344 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.345 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.346 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.347 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.350 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.351 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.351 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.353 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.356 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.356 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.357 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.358 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.361 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.362 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.362 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.365 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.385 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.385 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.386 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.388 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.389 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.392 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.393 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.394 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.395 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.397 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.398 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.398 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.401 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.402 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.402 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.403 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.412 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.413 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.414 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.415 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.446 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.447 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.447 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.449 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.451 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.452 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.452 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.453 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.456 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.457 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.458 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.458 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.491 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.491 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.492 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.493 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.497 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.497 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.498 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.499 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.507 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.507 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.508 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.509 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.511 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.512 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.514 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.514 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.517 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.518 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.519 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.521 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.522 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.523 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.523 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.524 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.527 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.527 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.528 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.529 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.531 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.532 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.532 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.533 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.536 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.537 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.539 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.539 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.541 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.541 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.543 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.543 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.548 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.549 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.550 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.550 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.553 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.554 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.555 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.555 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.558 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.559 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.559 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.561 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.563 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.564 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.565 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.565 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.570 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.570 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.571 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.572 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.574 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.575 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.576 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.577 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.579 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.580 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.580 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.581 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.584 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.585 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.585 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.586 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.589 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.589 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.590 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.590 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.592 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.593 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.594 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.595 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.598 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.599 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.599 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.600 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.603 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.603 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.604 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.606 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.608 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.609 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.609 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.611 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.613 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.614 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.615 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.616 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.618 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.619 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.620 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.621 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.623 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.624 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.624 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.625 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.628 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.628 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.629 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.630 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.633 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.634 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.634 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.636 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.638 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.638 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.640 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.640 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.642 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.643 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.644 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.645 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.676 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.677 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.678 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.678 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.738 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.740 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.740 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.741 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.742 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.744 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.745 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.746 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.774 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.775 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.775 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.776 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.781 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.781 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.782 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.783 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.785 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.786 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.787 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.788 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.790 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.791 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.792 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.793 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.795 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.795 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.796 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.797 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.800 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.801 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.802 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.802 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.805 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.805 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.806 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.807 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.809 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.810 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.811 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.811 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.814 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.815 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.816 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.817 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.821 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.822 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.824 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.824 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.827 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.827 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.828 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.829 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.831 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.832 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.833 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.833 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.836 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.836 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.837 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.838 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.842 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.843 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.844 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.845 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.847 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.848 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.848 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.849 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.851 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.853 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.853 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.854 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.856 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.857 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.858 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.858 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.861 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.861 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.862 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.863 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.865 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.866 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.866 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.867 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.870 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.870 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.871 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.872 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.874 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.875 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.875 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.877 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.880 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.880 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.881 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.882 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.885 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.885 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.886 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.887 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.890 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.890 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.891 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.892 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.895 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.896 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.896 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.897 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.912 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.914 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.914 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.915 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.930 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.931 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.931 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.932 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.939 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.940 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.940 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.941 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.944 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.945 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.946 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.946 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.948 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.950 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.950 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.951 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.953 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.954 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.956 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.956 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.961 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.961 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.962 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.964 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.965 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.966 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.967 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.968 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.969 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.970 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.971 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.971 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.973 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.975 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.975 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.977 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.981 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.982 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.983 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.984 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.987 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.988 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.989 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.989 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.991 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.992 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.993 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.995 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002134.996 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002134.997 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002134.998 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002134.999 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.001 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.002 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.002 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.004 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.006 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.007 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.007 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.009 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.011 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.012 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.012 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.014 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.016 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.017 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.018 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.019 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.022 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.022 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.023 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.025 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.028 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.028 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.030 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.031 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.033 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.033 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.035 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.036 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.038 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.038 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.039 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.041 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.043 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.044 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.044 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.045 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.048 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.049 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.049 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.050 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.053 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.054 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.054 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.055 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.058 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.059 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.060 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.061 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.126 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.127 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.128 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.128 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.153 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.154 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.155 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.156 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.158 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.159 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.160 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.161 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.186 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.187 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.187 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.188 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.198 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.199 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.200 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.200 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.203 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.204 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.205 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.206 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.208 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.209 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.210 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.211 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.212 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.212 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.214 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.215 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.218 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.218 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.219 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.220 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.222 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.223 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.224 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.225 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.228 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.228 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.230 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.231 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.232 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.233 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.234 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.236 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.263 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.264 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.264 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.265 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.268 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.269 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.271 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.271 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.274 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.274 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.275 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.275 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.278 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.279 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.279 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.281 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.285 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.286 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.287 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.287 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.290 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.291 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.291 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.293 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.295 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.296 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.297 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.297 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.300 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.300 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.301 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.302 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.306 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.307 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.308 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.309 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.310 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.311 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.312 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.312 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.316 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.317 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.318 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.319 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.321 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.322 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.323 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.325 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.327 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.328 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.328 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.329 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.332 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.332 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.334 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.335 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.337 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.338 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.339 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.340 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.342 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.344 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.344 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.345 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.347 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.348 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.349 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.349 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.353 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.353 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.354 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.355 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.358 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.359 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.360 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.360 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.364 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.364 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.365 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.366 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.387 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.387 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.388 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.389 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.392 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.392 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.393 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.394 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.396 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.397 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.398 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.399 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.401 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.402 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.402 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.403 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.411 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.412 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.413 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.414 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.446 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.447 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.448 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.449 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.451 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.452 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.452 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.453 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.456 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.457 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.458 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.459 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.492 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.492 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.493 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.494 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.498 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.498 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.499 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.500 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.506 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.507 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.508 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.509 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.510 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.511 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.512 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.513 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.516 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.517 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.518 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.519 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.521 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.522 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.522 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.523 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.526 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.527 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.528 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.528 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.531 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.531 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.532 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.533 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.536 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.536 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.537 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.538 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.540 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.541 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.542 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.543 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.549 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.549 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.550 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.551 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.554 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.554 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.555 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.556 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.559 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.559 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.560 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.560 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.563 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.564 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.564 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.566 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.570 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.571 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.571 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.572 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.574 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.575 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.575 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.577 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.579 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.580 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.580 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.581 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.584 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.584 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.586 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.586 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.588 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.589 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.590 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.591 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.593 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.594 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.594 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.595 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.598 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.598 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.599 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.600 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.602 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.603 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.603 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.605 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.607 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.608 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.608 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.609 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.612 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.613 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.614 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.615 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.617 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.617 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.618 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.619 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.622 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.623 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.623 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.624 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.627 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.628 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.629 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.630 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.635 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.636 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.636 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.639 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.644 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.646 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.647 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.649 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.651 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.652 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.653 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.654 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.684 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.684 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.685 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.686 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.715 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.715 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.716 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.717 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.719 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.720 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.720 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.721 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.751 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.752 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.752 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.753 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.758 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.758 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.759 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.760 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.762 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.762 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.763 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.763 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.766 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.768 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.769 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.770 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.772 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.773 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.773 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.774 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.777 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.778 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.779 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.779 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.782 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.782 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.783 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.783 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.787 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.787 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.788 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.789 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.791 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.792 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.792 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.793 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.799 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.799 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.800 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.800 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.804 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.804 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.805 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.810 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.812 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.813 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.815 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.815 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.818 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.819 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.820 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.820 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.827 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.827 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.828 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.828 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.831 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.832 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.834 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.835 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.837 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.838 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.838 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.839 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.842 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.843 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.843 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.844 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.846 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.847 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.848 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.848 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.852 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.854 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.854 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.855 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.857 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.858 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.859 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.860 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.862 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.863 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.864 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.865 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.867 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.868 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.869 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.869 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.873 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.873 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.874 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.875 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.878 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.879 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.880 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.880 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.883 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.883 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.885 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.886 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.901 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.902 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.903 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.904 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.918 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.919 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.919 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.921 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.927 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.927 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.928 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.929 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.932 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.932 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.933 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.935 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.936 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.937 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.938 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.940 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.941 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.942 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.943 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.944 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.948 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.949 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.951 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.952 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.953 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.954 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.955 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.956 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.959 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.960 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.961 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.962 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.965 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.965 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.966 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.966 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.971 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.972 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.972 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.973 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.975 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.976 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.976 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.977 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.980 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.981 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.982 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.982 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.985 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.985 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.986 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.987 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.991 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.991 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.992 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.993 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.994 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002135.995 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002135.995 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002135.996 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002135.999 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002136.000 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002136.001 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002136.002 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002136.005 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002136.007 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002136.007 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002136.008 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002136.010 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002136.010 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002136.011 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002136.012 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002136.016 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002136.017 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002136.017 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002136.018 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002136.022 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002136.022 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002136.023 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002136.024 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002136.027 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002136.028 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002136.028 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002136.030 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002136.033 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002136.033 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002136.034 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002136.034 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002136.037 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002136.038 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002136.040 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002136.041 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002136.043 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002136.043 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002136.044 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002136.045 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002136.048 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002136.049 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002136.049 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002136.051 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n" + ] + } + ], + "source": [ + "target_feature_name = \"user_id\"\n", + "# plot the num_queries vs batch_idx for each table size, zch_method, and feature_name\n", + "for table_size in table_size_zch_method_per_rank_num_queries_dict:\n", + " for zch_method_name in table_size_zch_method_per_rank_num_queries_dict[table_size]:\n", + " # plot len(table_size_zch_method_per_rank_num_queries_dict[table_size][zch_method_name]) subfigures\n", + " # each row has 3 figures\n", + " fig = plt.figure(figsize=(8, 6))\n", + " font_size = 24\n", + " rank_num_queries_count_dict = table_size_zch_method_per_rank_num_queries_dict[table_size][zch_method_name][target_feature_name]\n", + " # sort rank_num_queries_count_dict by rank_idx\n", + " rank_num_queries_count_dict = dict(sorted(rank_num_queries_count_dict.items()))\n", + " # plot the num_queries vs batch_idx for each rank\n", + " for rank_idx in rank_num_queries_count_dict:\n", + " num_queries_list = list(rank_num_queries_count_dict[rank_idx].values())\n", + " batch_idx_list = list(rank_num_queries_count_dict[rank_idx].keys())\n", + " plt.plot(batch_idx_list, num_queries_list, label=f\"Rank {rank_idx}\", linewidth=3)\n", + " plt.legend(fontsize=font_size * 0.7)\n", + " plt.xlabel(\"Batch index\", fontsize=font_size)\n", + " plt.ylabel(\"Number of remapped feature values\", fontsize=font_size)\n", + " plt.xticks(fontsize=font_size * 0.7)\n", + " plt.yticks(fontsize=font_size * 0.7)\n", + " fig_path = os.path.join(figure_folder, f\"num_queries_per_rank_feature_{target_feature_name}_table_size_{table_size}_zch_method_{zch_method_name}\")\n", + " plt.tight_layout()\n", + " plt.show()\n", + " fig.savefig(fig_path)\n", + " plt.close()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "output": { + "id": 1741253759825202, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0630 002236.545 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.547 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.548 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.549 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.575 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.576 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.576 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.577 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.579 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.580 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.580 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.581 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.644 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.645 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.645 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.647 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.656 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.656 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.657 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.658 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.659 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.661 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.662 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.663 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.666 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.667 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.667 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.668 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.670 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.671 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.672 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.672 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.675 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.676 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.677 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.678 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.681 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.681 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.682 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.683 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.686 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.686 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.687 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.688 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.689 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.691 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.691 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.692 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.716 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.717 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.717 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.718 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.721 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.722 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.722 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.723 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.725 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.726 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.727 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.728 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.731 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.732 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.732 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.733 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.736 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.738 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.738 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.739 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.742 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.742 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.744 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.744 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.746 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.747 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.748 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.749 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.750 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.751 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.752 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.753 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.757 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.758 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.759 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.759 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.762 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.763 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.765 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.765 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.768 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.768 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.769 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.770 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.772 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.774 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.774 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.775 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.777 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.778 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.779 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.781 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.783 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.783 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.784 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.785 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.787 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.788 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.789 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.789 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.792 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.793 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.794 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.795 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.798 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.798 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.799 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.800 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.803 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.804 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.804 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.805 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.808 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.809 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.809 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.810 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.814 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.814 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.815 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.816 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.838 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.840 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.841 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.842 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.844 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.845 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.846 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.847 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.849 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.850 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.850 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.852 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.854 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.855 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.856 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.857 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.865 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.865 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.866 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.867 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.901 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.902 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.904 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.905 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.906 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.907 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.908 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.909 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.912 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.912 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.913 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.914 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.949 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.951 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.951 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.952 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.956 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.957 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.957 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.958 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.966 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.967 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.967 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.969 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.970 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.971 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.973 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.975 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.978 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.979 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.980 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.982 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.983 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.984 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.985 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.987 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.991 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.991 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.992 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.994 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002236.996 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002236.996 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002236.997 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002236.999 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.002 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.002 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.003 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.004 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.006 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.007 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.007 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.008 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.014 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.015 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.016 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.018 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.020 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.021 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.022 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.023 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.025 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.025 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.027 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.028 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.031 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.032 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.033 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.034 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.038 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.039 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.040 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.041 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.043 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.044 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.045 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.047 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.049 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.050 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.052 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.053 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.055 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.056 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.057 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.059 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.061 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.062 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.063 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.065 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.067 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.068 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.069 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.070 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.072 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.073 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.074 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.075 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.078 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.079 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.079 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.081 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.083 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.084 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.086 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.087 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.090 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.091 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.092 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.093 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.096 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.096 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.097 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.099 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.101 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.102 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.104 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.106 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.108 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.108 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.110 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.110 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.113 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.114 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.117 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.117 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.120 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.120 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.121 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.123 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.125 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.126 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.127 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.129 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.161 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.162 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.164 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.165 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.196 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.197 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.198 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.199 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.201 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.202 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.203 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.204 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.236 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.237 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.238 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.239 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.243 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.244 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.245 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.246 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.247 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.249 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.250 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.252 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.254 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.255 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.256 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.258 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.259 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.260 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.261 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.264 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.266 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.266 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.267 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.269 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.271 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.272 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.272 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.274 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.277 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.277 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.279 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.280 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.282 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.283 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.283 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.285 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.289 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.290 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.290 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.291 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.293 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.294 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.295 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.295 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.298 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.299 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.300 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.301 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.304 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.307 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.308 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.309 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.312 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.313 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.314 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.315 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.318 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.318 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.319 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.319 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.323 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.324 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.324 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.325 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.328 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.330 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.331 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.333 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.334 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.335 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.336 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.337 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.340 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.341 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.342 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.342 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.345 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.347 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.348 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.349 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.352 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.352 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.354 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.355 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.357 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.358 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.359 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.360 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.364 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.365 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.365 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.367 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.370 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.371 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.372 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.373 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.376 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.377 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.378 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.379 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.396 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.397 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.398 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.400 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.413 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.414 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.414 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.416 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.422 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.423 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.424 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.425 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.426 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.428 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.429 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.431 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.434 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.434 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.435 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.436 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.439 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.440 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.441 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.443 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.446 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.447 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.448 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.449 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.450 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.452 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.452 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.453 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.457 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.458 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.460 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.460 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.462 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.464 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.466 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.467 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.469 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.470 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.471 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.472 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.476 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.477 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.478 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.478 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.482 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.483 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.484 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.485 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.488 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.488 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.490 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.491 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.494 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.495 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.496 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.497 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.500 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.500 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.501 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.502 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.504 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.506 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.506 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.508 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.510 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.512 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.512 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.514 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.517 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.517 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.518 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.520 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.524 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.524 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.525 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.526 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.529 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.530 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.531 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.533 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.535 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.536 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.537 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.539 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.541 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.542 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.542 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.544 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.547 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.548 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.549 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.550 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.553 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.554 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.555 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.556 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.559 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.560 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.561 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.561 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.631 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.632 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.633 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.634 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.660 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.661 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.662 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.663 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.665 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.666 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.666 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.667 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.695 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.695 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.697 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.697 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.707 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.708 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.709 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.710 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.713 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.713 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.714 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.716 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.719 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.719 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.720 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.721 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.724 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.725 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.726 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.727 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.730 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.731 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.732 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.733 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.735 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.736 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.737 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.737 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.741 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.741 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.742 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.743 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.745 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.746 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.747 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.747 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.777 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.779 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.779 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.780 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.783 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.783 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.785 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.786 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.788 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.789 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.790 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.791 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.794 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.794 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.795 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.796 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.800 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.801 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.802 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.803 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.805 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.806 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.807 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.808 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.811 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.812 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.813 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.815 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.816 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.818 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.818 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.820 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.823 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.825 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.826 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.826 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.829 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.830 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.831 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.831 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.834 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.834 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.835 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.836 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.840 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.841 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.841 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.843 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.846 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.847 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.847 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.848 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.851 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.852 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.853 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.854 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.856 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.857 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.858 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.858 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.861 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.862 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.862 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.863 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.865 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.866 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.867 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.868 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.871 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.873 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.873 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.874 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.878 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.879 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.879 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.880 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.882 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.883 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.884 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.886 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.910 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.911 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.914 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.915 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.917 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.918 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.918 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.920 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.923 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.925 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.925 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.926 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.929 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.930 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.930 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.933 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.941 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.941 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.942 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.943 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.976 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.977 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.978 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.979 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.981 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.982 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.984 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.985 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002237.988 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002237.988 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002237.989 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002237.990 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.025 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.026 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.027 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.028 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.032 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.033 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.034 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.035 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.042 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.043 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.044 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.045 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.046 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.047 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.049 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.049 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.053 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.054 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.055 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.056 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.058 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.059 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.060 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.060 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.064 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.064 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.065 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.065 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.067 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.070 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.070 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.071 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.074 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.074 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.075 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.077 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.079 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.080 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.081 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.081 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.088 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.088 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.089 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.091 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.094 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.094 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.096 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.096 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.098 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.099 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.099 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.101 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.104 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.104 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.106 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.106 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.111 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.112 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.113 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.115 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.117 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.118 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.118 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.120 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.123 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.123 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.124 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.124 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.128 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.129 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.130 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.130 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.133 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.134 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.135 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.136 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.138 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.139 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.141 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.141 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.143 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.144 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.145 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.146 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.148 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.148 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.149 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.150 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.153 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.155 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.157 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.158 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.161 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.162 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.163 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.164 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.167 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.167 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.169 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.169 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.173 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.173 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.175 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.175 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.178 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.179 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.179 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.182 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.184 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.184 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.185 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.185 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.189 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.190 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.190 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.192 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.195 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.196 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.197 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.198 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.229 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.230 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.231 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.232 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.263 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.264 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.265 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.266 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.268 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.269 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.270 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.270 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.337 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.338 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.339 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.339 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.345 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.345 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.346 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.347 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.349 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.350 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.351 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.351 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.355 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.356 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.357 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.358 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.360 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.361 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.361 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.362 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.365 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.366 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.367 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.367 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.369 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.370 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.370 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.371 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.375 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.376 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.376 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.377 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.379 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.380 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.380 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.381 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.387 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.388 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.388 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.390 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.392 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.394 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.394 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.395 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.396 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.397 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.398 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.398 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.400 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.401 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.401 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.402 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.405 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.406 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.407 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.408 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.412 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.413 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.415 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.415 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.418 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.418 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.419 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.419 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.422 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.423 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.423 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.425 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.428 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.431 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.432 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.433 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.435 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.436 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.441 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.442 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.444 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.445 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.447 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.448 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.450 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.451 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.452 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.453 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.455 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.456 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.456 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.457 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.461 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.464 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.466 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.467 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.469 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.470 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.471 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.472 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.475 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.476 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.476 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.477 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.494 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.495 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.497 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.498 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.511 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.512 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.513 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.515 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.521 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.522 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.523 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.524 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.527 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.528 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.528 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.529 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.531 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.532 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.534 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.536 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.539 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.539 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.540 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.541 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.546 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.547 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.549 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.550 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.552 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.553 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.553 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.554 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.556 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.557 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.558 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.561 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.562 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.563 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.564 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.565 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.570 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.570 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.572 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.573 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.576 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.576 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.577 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.578 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.580 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.581 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.582 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.582 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.586 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.586 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.587 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.588 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.591 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.592 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.592 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.593 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.596 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.597 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.598 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.598 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.602 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.603 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.604 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.604 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.607 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.608 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.608 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.610 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.612 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.613 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.614 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.615 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.619 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.619 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.620 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.621 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.624 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.624 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.625 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.626 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.628 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.629 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.630 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.630 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.635 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.635 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.637 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.638 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.641 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.642 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.643 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.644 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.646 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.647 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.648 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.649 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n", + "W0630 002238.652 font_manager.py:1431] findfont: Font family 'Noto Sans TC' not found.\n", + "W0630 002238.653 font_manager.py:1431] findfont: Font family 'Noto Sans SC' not found.\n", + "W0630 002238.653 font_manager.py:1431] findfont: Font family 'Noto Naskh Arabic UI' not found.\n", + "W0630 002238.654 font_manager.py:1431] findfont: Font family 'Noto Sans UI' not found.\n" + ] + } + ], + "source": [ + "# plot the num_queries vs batch_idx for each table size, zch_method, and feature_name\n", + "for table_size in table_size_zch_method_per_rank_num_queries_dict:\n", + " for zch_method_name in table_size_zch_method_per_rank_num_empty_identity_slots[table_size]:\n", + " # plot len(table_size_zch_method_per_rank_num_queries_dict[table_size][zch_method_name]) subfigures\n", + " # each row has 3 figures\n", + " fig = plt.figure(figsize=(8, 6))\n", + " font_size = 24\n", + " rank_num_queries_count_dict = table_size_zch_method_per_rank_num_empty_identity_slots[table_size][zch_method_name][target_feature_name]\n", + " # sort rank_num_queries_count_dict by rank_idx\n", + " rank_num_queries_count_dict = dict(sorted(rank_num_queries_count_dict.items()))\n", + " # plot the num_queries vs batch_idx for each rank\n", + " for rank_idx in rank_num_queries_count_dict:\n", + " num_queries_list = list(rank_num_queries_count_dict[rank_idx].values())\n", + " batch_idx_list = list(rank_num_queries_count_dict[rank_idx].keys())\n", + " plt.plot(batch_idx_list, num_queries_list, label=f\"Rank {rank_idx}\", linewidth=3)\n", + " plt.legend(fontsize=font_size * 0.7)\n", + " plt.xlabel(\"Batch index\", fontsize=font_size)\n", + " plt.ylabel(\"Number of empty identity table slots\", fontsize=font_size)\n", + " plt.xticks(fontsize=font_size * 0.7)\n", + " plt.yticks(fontsize=font_size * 0.7)\n", + " fig_path = os.path.join(figure_folder, f\"num_empty_identity_slots_feature_{target_feature_name}_table_size_{table_size}_zch_method_{zch_method_name}\")\n", + " plt.tight_layout()\n", + " plt.show()\n", + " fig.savefig(fig_path)\n", + " plt.close()\n" + ] + } + ], + "metadata": { + "fileHeader": "", + "fileUid": "6fba0a1e-d141-4b9c-b2ab-040d32740e82", + "isAdHoc": false, + "kernelspec": { + "display_name": "torchrec", + "language": "python", + "name": "bento_kernel_torchrec" + } + } +} diff --git a/torchrec/distributed/benchmark/benchmark_zch/plots/plot_qps_compare.ipynb b/torchrec/distributed/benchmark/benchmark_zch/plots/plot_qps_compare.ipynb new file mode 100644 index 000000000..36d4d1bdc --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/plots/plot_qps_compare.ipynb @@ -0,0 +1,204 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import csv\n", + "import numpy as np\n", + "import pandas as pd\n", + "import re\n", + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "output": { + "id": 1260065985462548, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['result_tbsize_10000_zch_dlrmv3_kuairand27k', 'result_tbsize_10000_nonzch_dlrmv3_kuairand27k']\n" + ] + } + ], + "source": [ + "qps_stats_folders = [x for x in os.listdir(\"/home/lizhouyu/home/lizhouyu/zch_results/\") if x.startswith(\"result_tbsize\")]\n", + "qps_stats_folders = [x for x in qps_stats_folders if \"tbsize_10000\" in x and \"kuairand27k\" in x and \"prehash\" not in x]\n", + "print(qps_stats_folders)\n", + "#" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "figure_folder = \"/home/lizhouyu/home/lizhouyu/zch_results_figures\"\n", + "os.makedirs(figure_folder, exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "def get_average_qps(qps_stats_file_folder):\n", + " qps_stats_file_path = os.path.join(qps_stats_file_folder, 'qps_metrics.csv')\n", + " df_qps_stats = pd.read_csv(qps_stats_file_path)\n", + " # maintain a dictionary of {feature_name: {batch_idx: num_queries_over_all_ranks_at_batch_idx}}\n", + " rank_qps_dict = {}\n", + " for index, row in df_qps_stats.iterrows():\n", + " batch_idx = row[\"batch_idx\"]\n", + " rank_idx = row[\"rank\"]\n", + " qps = row[\"qps\"]\n", + " if rank_idx not in rank_qps_dict:\n", + " rank_qps_dict[rank_idx] = {}\n", + " rank_qps_dict[rank_idx][batch_idx] = qps\n", + " # get average qps over all ranks\n", + " average_qps_dict = {} # {batch_idx: {\"mean\": average_qps_at_batch_idx, \"min\": min_qps_at_batch_idx, \"max\": max_qps_at_batch_idx}}\n", + " for batch_idx in rank_qps_dict[0]:\n", + " batch_per_rank_qps_list = []\n", + " for rank_idx in rank_qps_dict:\n", + " batch_per_rank_qps_list.append(rank_qps_dict[rank_idx][batch_idx])\n", + " batch_per_rank_qps_list = np.array(batch_per_rank_qps_list)\n", + " average_qps_dict[batch_idx] = {\n", + " \"mean\": np.mean(batch_per_rank_qps_list),\n", + " \"min\": np.min(batch_per_rank_qps_list),\n", + " \"max\": np.max(batch_per_rank_qps_list)\n", + " }\n", + " return average_qps_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "re_zch_method_name_pattern = re.compile(r\"\\d+_((non)?zch(.*)?)\")\n", + "re_table_size_pattern = re.compile(r\"result_tbsize_(\\d+)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "output": { + "id": 619250161226680, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "zch_dlrmv3_kuairand27k 10000\n", + "nonzch_dlrmv3_kuairand27k 10000\n" + ] + } + ], + "source": [ + "table_size_zch_method_avetage_qps_dict = {}\n", + "for zch_stats_folder in qps_stats_folders:\n", + " zch_method_name = re_zch_method_name_pattern.search(zch_stats_folder).group(1)\n", + " table_size = int(re_table_size_pattern.search(zch_stats_folder).group(1))\n", + " print(zch_method_name, table_size)\n", + " zch_stats_file_folder = os.path.join(\"/home/lizhouyu/home/lizhouyu/zch_results\", zch_stats_folder)\n", + " average_qps_dict = get_average_qps(zch_stats_file_folder)\n", + " if table_size not in table_size_zch_method_avetage_qps_dict:\n", + " table_size_zch_method_avetage_qps_dict[table_size] = {}\n", + " table_size_zch_method_avetage_qps_dict[table_size][zch_method_name] = average_qps_dict" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot collision rate" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "output": { + "id": 1230691201590721, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAw4AAAJICAYAAADINLOIAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXeYHVd9979Tbt9etepdttx7xx1cwBgbG9tUExJCCwFCAoGEkAR4CaE4mI6N6Ta427j3bsuyJVnF6tJqey+3Tjnn/WNm7p05c2buvbsrayXO53n8eHXL3KnnnO+vSlu3bqUQCAQCgUAgEAgEghDkA70DAoFAIBAIBAKBYPYjhINAIBAIBAKBQCAoixAOAoFAIBAIBAKBoCxCOAgEAoFAIBAIBIKyCOEgEAgEAoFAIBAIyiKEg0AgEAgEAoFAICiLEA4CgUAgEAgEAoGgLEI4CAQCgUAgEAgEgrII4SAQCAQCgUAgEAjKoh7oHRBMnZUrV77lv0kIQX93J9rnLYQsC905GxDXZHYhrsfsQ1yT2YW4HrMPcU1mFwfiemzbtq2iz4m7QyAQCAQCgUAgEJRFCAeBQCAQCAQCgUBQFiEcBAKBQCAQCAQCQVmEcBAIBAKBQCAQCARlEcJBIBAIBAKBQCAQlEUIB4FAIBAIBAKBQFAWIRwEAoFAIBAIBAJBWYRwEAgEAoFAIBAIBGURwkEgEAgEAoFAIBCURQgHgUAgEAgEAoFAUBb1QO/A/mDHrt14+ZW12LV7L8bGxqEbBhLxONraWrFqxTKccdrJaGxsKLud3r5+vPTKWmx5cxvGxsdRKGiorUmho2MOjj/2KJx84vFQFKWifZrJbQkEAoFAIBAIBG81h5RwyOXz+N0f/ox1Gzb63ktnMkjvzmDX7j147MmnceXl78JZZ5wauK0HH34MDz7yBEzT9Lw+OjaO0bFxbN6yFU8+/Tw+dv0H0NbaErpfM7ktgUAgEAgEAoHgQHDICAfdMPDDH/8Cezu7AAB1dbU456wzsGzZYsSiUQwPj+KVV1/D+jc2QdcN3PrnuxCLxXDyicf5tvXQo0/g/gcfBQDE4zGcfdbpWLViOeLxOIaGh/HCS2vw5tbt6O7pxY0/vQlf/MdPoba2hrtfM7ktgUAgEAgEAoHgQHHICIeHH32iKBqamxrxxc9/GrU1pQX4gvnzcOwxR+KhR57AfQ88DAC48577cdyxRyGilk5Df/8g/mIv9FOpJL7w2U+iva21+P6ihfNxwnHH4I677sMTTz+H4eER3H3fg/jgdVf59mkmtyUQCAQCgUAgEBxIDonkaEIInn3upeK/P/T+93lEg5u3X3AOmpsaAQCTk2ns2LnL8/5Djz4BQggA4D2XXepZ6Lu5/LJL0NrSDAB45dXXMDQ84vvMTG5LIBAIBAKBQCA4kBwSwmF4ZBSyIkOWZdTW1GDZ0sWBn5VlGUtd7/f1DRb/NgwDGzZuAgAkEgmceMKxgdtRFAWnn3oSYAuXdevf8Lw/k9sSCAQCgUAgEAgONIdEqFJrSzO+9Z9fBSEEhUIBkiSFfl6RS9WLdF0v/r1r917k8wUAwLIlizwhTDxWrlhe/HvTlq244Lyz98u2BAKBQCAQCASCA80h4XFwkGUZiUSi7OcGh4aKfzc1lcqy9vT2Ff+eP39u2e3Mn9dRFCk9PX2e92ZyWwKBQCAQCAQCwYHmkBIOlTAwOIRdu/cCdojQ4atWFt/rHyiFLTVV0OdBVdViBaR0JoN0JrNftiUQCAQCgUAgEBxo/qqEA6UUt/75LlBKAQBnnHYyUqlk8f10urRYrwlIrmZxJ2G7vz+T2xIIBAKBQCAQCA40h0SOQ6Xcftd92LptBwCgqbER77z47Z73C5pW/LtcToKD6vpcoVD6/kxuKwinYtNbifObB+K3BXzENZldiOsx+xDXZHYhrsfsQ1yT2cVsvh5/FcKBUorb77oPTz3zPAAgHovh7/7mQx5vA5hEaXUKi33dKH1/JrcVRH93Z0Xb3R8M9nYdsN8W8BHXZHYhrsfsQ1yT2YW4HrOPQ+2aUAqUqZczq5mN1+OQFw6FgoZf//5WrN9glUZNJhP4xN9ejwWchOVIJFL8WzeMirZvuD4XdX1/JrcVRPu8hRVtdyYhhGCwtwutHfMhy39VkW6zFnFNZhfiesw+xDWZXYjrMfs4FK9JpkBx61odTUkZ7z5agSwfPAriQFyPyR07KvrcIS0cxsbG8dNf3oJ9XT0AgMbGBnzy767H3I453M/HotHi326PQRjuz8Visf2yrSAO5MMty/IhM7gcKohrMrsQ12P2Ia7J7EJcj9nHoXJNKKW44hc5bOyxQn1e74rgvy+LH+jdqprZeD1m197MIPu6uvGd799YFA2LFy3AFz/36UDRAKBY1Qh2V+lKGJ+YKP5d5/r+TG5LIBAIBAKBQFAZL+02i6IBAG56oTIDrqA8h6THYdv2nfjJL26BZicon3TicXj/Ne8tm6Q8p72t+PfIyGjZ3ykUNGQyWQBAfX2dp4fETG5LIBAIBAKBQFAZm3v9ScWE0IMqXGm2csgJhx07d+PHP/9VMeznkosuwKUXXVjRd+fPK+U9dHZ1l/383s59xb8XzPPmTMzktgQCgUAgEAgElWFwihHlDSAZ5X1aUA2HVKhSf/8gfnbTr6HrOiRJwrVXX1GxaIAdzlRTkwIA7Nq9F/lCIfTzm7dsLf599FGr99u2BAKBQCAQCASVYXKEQ1ajB2JXDjkOGeFgGAZu+vXvkc3mAABXXXEZzjz9lKq2Icsyjj/2aACApml46ZW1gZ/N5wvF96PRKI456sj9ti2BQCAQCAQCQWUYxC8SciLNYUY4ZITDw489ie6eXgDAKSedgLPPOn1K23nHhecVS6ne95eHitt0QwjBH/90JybTVtLzeeecWfQu7K9tCQQCgUAgEAjKwwtVyunC4zATHBI5DplMFk88+SwAQFEUnHryCejp7avou4qioL2ttfjvhvo6XH3lu/H7W29HPl/Ad2/4Mc4+6wwcvmoFYrEo+gcG8cyzL2L3Xqv52pJFC/GOC87jbnsmtyUQCAQCgUAgKA/Pu5AXHocZ4ZAQDhs3v1nMITBNEzf86OcVf7epsRH/9bUveV47/dSTYBgG7rznLygUNDzy2JN45LEnfd89fNUKfOSD1yIaDW7WNpPbEggEAoFAIBCEk87zQpWEx2EmOCSEAyEcn9Q0eduZp+Hww1bi+RdfweYtWzE6NgZd11FXW4uFC+bjpBOOwzFHH/GWb0sgEAgEAoFAEMxkgSMctAOyK4cch4RwOO2UE3HaKSfO+HZbW5px+bsuxuXvunhWbUsgEAgEAoFAwCed978mPA4zwyGTHC0QCAQCgUAgEHA9DiLHYUYQwkEgEAgEAoFAcMjAD1USHoeZQAgHgUAgEAgEAsEhQ0Z4HPYbQjgIBAKBQCAQCA4ZJkWOw35DCAeBQCAQCAQCwSGDqKq0/xDCQSAQCAQCgUBwSKCblNvsTXgcZgYhHAQCgUAgEAgEhwTpAv91keMwMwjhIBAIBAKBQCA4JOB1jYaoqjRjCOEgEAgEAoFAIDgkSAcIBOFxmBmEcBAIBAKBQCAQHBJMBnkcRI7DjCCEg0AgEAgEAoHgkGAyKMdBVFWaEYRwEAgEAoFAIBAcEgTmOAiPw4wghINAIBAIBAKB4JCA18MBIsdhxhDCQSAQCAQCwayiYAjrsGBqpDldoyE8DjOGEA4CgUAgEAhmFUEJrgJBOdJBHgeR4zAjCOEgEAgEAoFgVpEJSHAVCMoRHKokxOhMIISDQCAQCASCWYNJKLJikSeYIkGhSnmR4zAjCOEgEAgEAoFgVrBzkOA9P8vi/Tfn8NuXRGyJoHqCPA6aCRimEKTTRQgHgUAgEAgEs4Kv3pfHmr0EvRMUX76ngG0D5oHeJcFBRpBwAIC88ZbuyiGJEA4CgUAgEAhmBU9tKwkFkwLffOiv2+tAyF+XhXxLn4l0nkxrG0F9HAAgp/11nc/9gXqgd0BwaKBTigFNg0kpWiIRJBXlQO+SQCAQCA4iNE4J1oc3G6CUQpKkA7JPbyWUUpgEUGSAUuBXL+p4fKuB81ap+OhpEcjyoX0O/uFPOfz5NQMxFfjD9QmcvmxqS9SgztEQvRxmBCEcBNNGJwR7CwXo1Br066lQ9AKBQCCojpEsf+54tZPgpEWHtjFqLEvxkd/k8PIeE2cuU3DFsRF89T5rBfzkNhPttRLedXTkQO/mjEAIxeY+gpYaCXPqrMCXl/cY+PNrVhxRwQA+86c8Xv7nFEayFK01UsXCUTdpYDlWHASVlV7fZ6KlRsK8+gO9J8GIUCXBtOnTtKJoAIDpORkF+5uRDBXNlQQCwaxjOM0fl+5ed+ibiW96QcPLe6wwred2mvj8Hd7SQDc+fWiEbBFCcc3NOVz4f1mc9p0MHt1iiYWnt3lzWXrGKe7faGBTj4neicrnq7EsDe0BMpt7OeweIrju5iwu/VEW67pmb26PEA6CacMKBfpX5nEYz9GD4pgppfjnu/I48r/SOP6baby4S2SJCQSC2cNwhj+O3vuGcchXw/nfx8JXtBu6Z9Ykly5QjOcI1neZmHgLm+29tNvEszusRXFeB2540vKqvNHjXyh/4o95XPerPN723Qye2Fp+vnp4s4GrfpnDREA5VgCztszvaJbiupuzGMsBg2mKK3+RxxO7ogd6t7gI4SCYNuxj+NfkcbhznY5P3ZrD9x/XMJmn+Mo9eRzzjTQ+8pscRgPc7vuLTIh7FgCe3WHity/roABGssDXHxAdlgQCwewhSDgMpSnWz/DCeTbBy+3Y33SPEVx8YxYX3ZjFyf8vjU29b42F+/drvN6jtZ0ElFKs7Qy+vhkN+M8y89VoluKTt+awtb+0neSyMcy5fCfaLt2NaGsWmKU5DgWD4oO3ZLFnpHQf5HXg7s2xWWmUFMJBMG3Y23o23uj7gxd2GfjUrXk8vtXEdx7TsPI/0rj5RR0DkxQPbzbw42dm1ieqh1jcXuiM4O/+kMe/35cPtB798Cnv/qzvIqEuXYFAIHgrCRIOsEMsDwVMQvHTZzR85Nc5/PZlDZRSbOwpL4qmkhs+mad4ZLOBPcP+7f/fkxp2D1vndDwP3PjUW7OiVjmrzrWdpKyhbWs/wcBk8Hlas8dE1jXFSRET9ccOQo4SqCkDdccMAbOsqhIhFL99WcNZ3834hNPhc2R86+2Ts7IogEiOFkwfRigcbHYh3aSIKNU/nM9sD7fQPLPdwIdOjuDBTTqOXaDg5MVTf9y+em8ev31Zx5IWGb+7PoH5DaXRt3uM4LP318KkBE9tJ9BN4FuXxz3fLxgUr+717++GbhNnTLFyhaB6/lqqwwgEUyFMOIQZTg4mbn/NKHp7H95iYF6DjB2D5WdNSq3E3kSksvFjKE1w7g+yGLLzRs5bpeArF8WwukPB9gETd67zhv48uNnEf7xtSodUFSpnrr17fWWi5eXdJt51NN/evX3QO78lFqQhufLpo03WOZ9NHocv3VPAb1/271B7rYTffDgGJX1AdqsswuMgmDYHe6jS3hEKcwq1soMqgDhs6CY463sZfO0vGi7/WQ4PbZraiPXCLgM3vaBDMy2ry+dv9wZw3r/RhElLg/EtL+k+r8/T20xu45vX983eBKxDEdF8SCAIZiggORoA9ENkqPr6A97x+78eKHCNOjz6xiufp/78muE5n09sNXHJj7J4abfB7Y2hm8BYfv8bNXiehbvXVzYw/s+jBVx3cxb/clceg7b3gVIrx3Bbv3flISm8c0VnTVWlTIHiD2v8a4JEBPjNRxKYWz97l+fC1CiYNgdzqNLT2w3ct0HHeatUXHJkZaXuTEKhyBLGKshhKNjjIaXArWsNXHRE9eX0Ht7sHVSf3WHiD2s0bO4lWN4qYwOn+sLOIYrlraVJ4J4NfNGyrmtqMs8wKV7YZaI+IeGY+Yd2mcSZwjApdNOaGAQCgZ9Qj8PBZpEKYDTr/feb/aTi5OTeCYIlLZUtKHnhSQUD+Nd7CtjSxz+ZWwdVrFpW0eanzCAn3Ii97pceqUKVgQc3GdBc09uOQYodgyYAE+M5ip9el8DeEYrhDMEbTLhXoS/p/3Fp9lRVWt9lwmROxbJWGf93VRxHz1NAyOy94YVwEEybg9Xj8JeNOv7u93kQCvzxVQO/ux44d2X4qm4iT/HMdgMnLFSqTn5mBUCldI74f+cLd4Qniq3ZY2J5qzXBZDUa+NtT9Th8+Dc5PLHV+u6/XhTFp8+OYs1eEy0pCUtbhZDg8eJuE12jBO88KoLa+MEfrvRGt4mX9xg4c5mKw+aIay6YPmHCwThEPA48eir0JPRVUZZ0MMB7EyQaAODNQQWXVfwLU2MgxKvk8NHTIzh+gYKzV+j4fMBc9+AmA1+5J49bXtIRU/0hSHFe+LE8ezwOa5m5V5aAZz+fPChCWYVwEEybg9Hj0DNO8E93WKIBAAgFvvWQFioc+icIzr8hi+EMRW3M353y3y+J4antRtnch2rZN1q9FFuz18S1J0VAKcWX784jE2Bl6Rmn6J8gaK+r3C26fcAsigYA+OZDGt7oJrjvDUucfPPdMVx/2uwsI3eg+M3LGv7lLuuG+fEzOh7/bBJRdfZPEEGs2Wviip9lYRAgqmi4/5NJHDVPiAfB9DjUcxymOzf2VyEchtLVzxtvDu3fJSGlFAOT4ccgS8Cx8xXEIxIuOExFRClww9Q0E7j5RUst8PIW/nh9Ah/v9r4mSXTGcxwMk0KSAKXKrt6vMcnQHzolclCIBhzqwmHX7j349e9uw9DwCADgA9dehdNOOTHw89u278QNP/r5lH6rqbER//W1L3le27FzN77/w59WtZ2WlmZ8/av/PKV9OGAcZMnRhFD845/zGMt5X3+jh+C5HQbOXM5/LH76rFac2Hgt7Ze1yBjJKqHCwZ2IbZgUBcOqlpGM8gcMk1DsrCBxjuUVO2b2D2t0/Om1cE/Hui6Cd6yuXDjsGfYP/I5oAIBvPlTA+0+KHNQL45nGEQ0AsGOQ4KXdJt624uAdfr/1UAGGfVtqJvAffyngjr/jhAYIBFUwkgke64zZPrFUQHqaFbB7xys/CWH5IkFsHdy/Y1K6YJUZDWP1HLk4H7bWyjh6nhxaqpVHTQxY1KgAjHCAPPNVlfonKWIq0FJT+XxHKfV5+49bcPAYXmZv9sU0ME0T9/7lIXz/hz8rioYDQS6Xq+BTBz8HW6jS/RuNYgMalh8/owU2Gvrps+EjXmNKwhEd4Y/US7tN/OCJAm5/TcOWPoIHNur48t153PG6VZbvpuc1XHBDBp++LYeRDEX3GJ1SQu3OQYI3+0x89V7vTJWMWBUb3FQbrpQu0y8iXQDWdZlTSjg/FOGVkXxh18Edd/Hibu/+H+zHIzjwGCb1xf+7ORSSo/vLWNvLMROhSmHsHZPL9gOaDuW8DQBwyhLvAvqMpdUvqFe0yYjI/rlYkmfW46AZFMMZWrVI6xmnvnvh+IUHj3A4eE1eAfT19eOW392GfV2W1JRlueIkk0ULF+Ar//K5in+rp7cPv/rNHwEAh61a7ns/mytVT7jwvLNx8knHl92mqh58l+RgC1V6/M3glfjT20280WPiuAXe61DJMTUkgPpEuHC4+pclMXnhYQqe3m5CM4E/vWbgVy/qRcvKpl6C5lQBbwvwflTCfz1Y8ImO/3xXDHuGKW58uhS79HqVre3HcuXPxfM7TXTUyVjQJLwO67v953dew1/XeSkYFDHhgRKEUK5K3aGQ47B3eHoH0TdR2Vomp9MpeTcoJGzuI77F+0wR1ofB4ZTF3t8+c7mK/6uyx8TKNhkqJ+xHmuEch/4JCkqtpPPJPK04d+21Tu990JAAljYfPOPjwbdKDeHZ51/CHXffB103IMsyLn77+RgYGsKaV1+v6PuxWBRzO+ZU9FlCCH5/6+0AgJqaFC5/1yW+z2SzpUViW1tLxds+2DjYPA57OcnGDoRajXF+9SHvo8FLUGZpTEpoTEqIqaVqSmE8+qZ38GDdsY9vtRbfU8WdhwAAZy5TcPkxETy13btzG7rMqvoLjFbQiOnp7SbOP0zFgir3+VBkPUeYHQphF5WQ1Sg+c1seT2w1cPoyBT++JoH6xMEzQQreOsLyGwBAO8hzHAoGxabe8g/+35wewU0v8BfKvRUmUQ9Nw7PxRjfBKUum/HUfThVCVOgFYUXLmcsUnL5UqcqruaJNRmc+739DotOuquTkaeR1YNxVDWsoXYVwYLz8xy5QIFeZI3EgOaRClZ5+9gXouoHmpkZ87jN/j0suugCytH8O8alnnseevfsAAFde/k6kUv74XneoUiKR2C/7MRs42DwOnSPewXtOnfeBfWiziQeZngs8qzFLQ0KCIku+8zFVdg4SbOz1/u5pSxR86uwIamPVb+/UJQoSEeBoJol1LAd0jfr3OsgyU84yCAAv7zFx6Y+yOOYbaTy9/a+7eQGv5G25ON9DhT+t1fHAJgN5wxKyv34peNbOarQii6Rg5hjVdeRnSdnH4TKLyoPd4zCULh/SIkvAl98RwyffFsGqNhmnM2E6/ZO0ovm1mjClBY3e+W8jI26GMwRb+03sHiLQjMq3ay2wCbb2k+I+D5YRNEuaJbTVetdskiThj9fH8b9XxPDHjyYQrcAZsrJNwSOjo77XJTl4XquE4QzBNx4s4NuPFLB3hBTTO8dzFH9+TcdvX9aQDciheKPbLIbwvrbPe46PP4jyG3CoeRwA4MTjj8U1V12+Xxfqo2NjuO+BRwAAy5Yuxskn8kOQsn8lwoHFeSRmY5fcnE7Ry8SJ/u+Vcfz9H3Ie1+4/31XAyYsVNKesQYxnNXZTG7M6YuqEYGkb8GbPzOzvg5u8i+4LD1fx8TMjaEhI+AaniU8Ylx6pQpYlzG8AGpPeeuIbekwsaPIO2Ok8v0tpJaFKsK3qA5MU/3ZfAc98/pAbaiqG12djtpQE3N984yFvvMS3HtbwD+eWVG9Op8gUrP4WL+028Ua3iQsOU3G66Ga+X6CUIkMIahQFOqUY0HW0Aohz4sEBIE8ITEqRUvb/wqacx+Fg7+NAKD/fyc2SZgmpmIR/uySOz5xDkdUpTvhWpvi+blrnqVwibjXC4YylCm5dW5pn2Cp+6bwVkrNmr4FlrTLefrgaWMzDzXCGFj0kWQ1IxcqXYmXDlByiERknL1bQUiNjdYdctv/QijYZ63kGLpliIk9BCK3awk8pxbU35/BGt/Xbj2818c8XRvHMDhMPbzaKUQYPbzbw248kPGuf/3mkgO8/Yc3XVxyr+tYTB1N+Aw41j8NVV1yG6z907X5fpN9974PQNA2yLOPqK98d+DmPxyEe36/7dCCglOKJ0VHcNzyMQa20iHUeabZq0WyAV9r0lMUK/v0Srwl/KE1x84ulY1pfZqCqSQAaIdhXKOCKU2ZOLGUZbbCiTYYsS1jWWt2ju6xFKtbalyQJR831DlTOYOjw0m4Dn7w1jy/ckfP1q6i2f8X2AfJXmyjdP0F8QhVvgcfBsfAd6PNeLs56Mk/ROULwnUcL+NStefzkWR3v/WUOj2756/ZS7S8ogH2FAkYNA/2aBgIgY5YWMYZJkHeZ9vs0Df2a9pZ4kcsJh6CiFQcDIxmK9V0mdyxws7ytNC7XxoG2Ggns+raSBOnBKkqxrmr3zgWsuHllr4G/+V0O//uYhk/+MY//e7K8wYpSilc7TWRs67vT4K6cx+GUJcEGg/qEhNoYcMTc8EV2XLW8KAXOPStJFGs7Cb7zmFZx0z2HnnHqmScHJin+6c4C7t1geEKTH99qeprRpQvenMI713k/L0sHn8fhkBIOq1b6E5Rnml279+DV19YBAE475UTMnzc38LPuHIdE4tATDn8cHMQXd+/GbYOD+NrevZgwSk9DViNlq++40SmFNkMu87BJjs1VaE5JqIlJeP9JKk5d4n0cXt1nHQ8hFBvKhCrVJoCd+TwKlOKc1RLOWV25eIhXYVxdYQuGIOGgBjzRZzFJ1mzN/Td6Ssc3nqP48K9zeG6niT+sMfDFO72xoryO2bIEtNUGH7N2kIcZTJUgwZnfzx4H53QH9e+YLvFpdL92u/LHcxRfubeAP75qFEP8KAXue+OvJJbrLcY5x32ahklbMGRJKZRkIG9iZ64AjRCMGQZyhKBAKcaM/S/kynocDpIxJF2g+OStOZzy7TS+/pc8NvaYOOt7Gfzt7/Nl4/RXtpUGcEWWoCoSWhnvQkXCoYocB3YuGS45OPDUNh3/fFehaACgAG54UsOfXwt+Pk1CccXPs7j+N3lcc1MOt7+mYzxnjYPlQhGDPA6w52pVkXAkp3Jhg8tWfO1JESiyhAJvPSFb5+UHT2j4wh2cHIgQqjmnt7vOz4YuM/TePXOZgsbk7IrMKIfwB1fJHXffDwCIRqO49OK3h34256qqpCgKnnnuRax/YxO6e3qRzeYQiahobGjAiuVLcdYZpx50ydOPuWIIJ0wTtw0O4m87OgAAkwWKghH+MGRNExnTRJYQZAlBg6qiIzr9xmHjpomGgOpUe4e9g8kiu+qPLMu48DAVL+0urbT22XH/u4cpt2+DmzrXwKUqEv79vRI+lyd4eTvwzbv4A86lRypY3aHg02dH8PW/aLh1re7zMLiJqcB8Ox51cZMMRYavZf2/vD3KDWE6c7l3QD5qrnfw3dBNiqFlN72gYcI1pv5lo3fRwHocvvyOKK47KYIN3QTv/xXfzaQZQGIai82DlXUBIW6VJM9PB4NSqJKErEZR50rYc/cRmQ6JiOQTP3mdIu4KbQsyHOwcJDhqnoLxHMUn/pjnJoxOVDenHzKYlEK2vYJTgVKryktQGAbvihA7JClfkPGdxwowQfHBM/OexdigrqNBVSvar6mGqJb1OBwkoUo/eUbDXeusB/ynz+q47w2jbIiSw8p2/6K4vU7ylO6spJdDpeVBa2N+g89I1grlGclSfOx3ea539HO35zGvQcLpS/3z7AMbDby029pH3QR++YKO7YMEv3i/XDZUaXGzBEIpZM794yRYX3yEiv96sFCcK89aruA774njJ88WsKBRLjYfZYWDkVZhZkqT0F82GlVVQip3f7q5e72Bf7+EQlUkXyI0y7uPOfiW4YeUx2F/88amLcWE6HPedgbq62pDP+/OcfjO92/EbbffjTe3bsfkZBqmaSKfL6C3rx/PPPcivvk/P8Cd99xfcenY2cD6TMbz76fHx4t/TxaAArOwGNA06IQgq1GM6jr2FgoYMgxk7WPOmjNjUho3DJgBXoe9I6xwKD0Cqzu8i+veSRO6aVZUrrSWUymmNi6jJcAKv6RZwo+vSeDz58cQVWV8491x7Ph6DW64KtgztaxFLg6eUVXCfE5Jz9OWqjhyrv+xZgd41uMwlC7VlX5pd/jxssLhhIVW7OnpSxXuPoHp+qoZ5KAOO6iGoKT6Sj0OZIqhRial2DdC8MRWA5kCKW5rKKTBVjXwROAk4/rfM8z/re2DBDmd4n03ZQOrzBQCkjD3t6fmrSIXMNZplCI9jXHQIOGiK8gbmyEEf/O7LG59keLPLwJf+J0J3fVZ0+XFCmPcMDA0Re9EucXuweJx+N7jXsNN91jl9+wKjieZraxXSffoSnMcGlMSmhmPhmnfQ39aawR6LE0C/OxZ/pvPc7wqT2838Y2HCqFW+3++MApJkgLnbof2Ohk3XBXHkXNlvONwFd95TxyLmmV89twY/vaMaDH/ghUO2V31IIXSPEip19NejqD7M6YCbz/cO58OpimesXtFvb4veMyNKMDFRxx8FrWDT+ocQB546FHA9jacf+5ZZT/vFg6Tk2ksWrgAp558AubP64CqqhgcGsba19Zj/RubQCnF408+i0JBw7VXX1HR/hwIkeH8ZtBv9+bzaI9GMZE3IFMZmm5Z4AEgbRgYKmjIZmQkajiVZgBoplmsv5wxzSkl5RVME+O2hYyFFQ4Lm6TisSxvtV6TFIKms3oQa8vhg1sSGHhhblmNXRun3HPSlOIPNktaZKgy9S0MV7UF/8apS7w9SVIxyWdDnFdP8YXzI7j+tyUXyUmLZNTHvb+1sIGiJuaNQV/fZaDtMBVb+/3H4fyuSSjGmYVJfdx6P6oAf/hoHP9xv4YntnkH5JxGQAjwp9d0/Mf9GmIR4IdXx3HmsoMrtrMS3M/Ixh7+c5LT+fcLy3iOTql86fM7dHz8dzryOvDdxzT8/iNxfPpPeWzupbj4CAU/vDrm8Q5US4wzc4zlCJpTpX/vGeJPylv7TIxlSWjeUIE5P4ZJ8fd/LODBzSYOnyPj5g/EsLCpcrtXuXHrrWTCMNCraViZSPgs84ZpYsQwkApIVi6Hbjekqovzv28Swj0Hu4Y1vLir9Pr2XmDfEMF8V215QghIiCfBoBS9hQIopaiX+XX0dUJgAnD8yu59GWbi8iOKVyxoRmXPzIFkus3TlrX479E2xj7ZP8m/hm4GK6xO1pSU0Jjw7/Ng2sTaznABOJTmX4+Xd/O/d+urhs/T+qsPxrBun4lFzTKuOk4FIQQ6ISg3K1xyhIJLjii5xAghqI9TqHLJ2MJWC6Om/35ct8/EqYsre9YG0/7x7PPnR3DKYhl1cQl7hgm2DZTO5e2vaThnhRzqcXjbcsU3N7uPCbNkzGIRwqFC3ty6HZ37rKZyJx5/DGpSqbLfiagqamtrIEsS3n7heTjnrNM97y9cMB8nHHcMXnn1dfzm97eBUornXngZRx+5GkesPqzs9vu7O6dxRNNjsLcLcxUZPUyszFN9vXhbJAZjIooIJOzTTCTtWWLIMDGiAYMZCYsaCHhT0F5FRo0sQ6cUQ4SgYwrCoV83kJYl7nd39dd7bvsGaRT93dbqWaJAVGlCbPUIYm2W6Nuu5TBRMwagqfgdOW7nPmgyQKxBJ0LTGBnIgEXWJQB+NTAnnkZ/94Dv9VodkNAEyjk7580fQr/Lgi2TOgBea4U53oWja4Grjkzhjk0xtKYIPnvymOd7Diub6/BaT+n7L705iqNrcxiYbPZ91rnXxvISKG3yvGdO9KDfHtxqAHzqBBlPbGv0fKanuwf6GMG/3duItCYDeeBvf5fFgx8e9VmvNdPKmQjK1zhY2LG7GwOTTdz3xidz3OvvkNWAG15MYeuggmuPyeMdK7zWvYIB/GxNEtuGFLxndQHnL/O+/+tnU8jrlveqZ5zi3BtKRowHNpk454V+XLB86gkQ1GwAmOl9b2cvagql+2zj7jgA/zi5sTON0ToCILiIxWS2gL6uQfROymirIbh7cwwPbq4BAGzpI7j+lknc8t7xikozuhns7aruCzOMRik67eTjhKogxiyu04SgzySQVAWRKYT75HRg75iCSMZEhHNuNEoxwqlruq4zCsD7zG7fO4qkWbpH+srsU69pImMvgAqyhHZ7/KUUcL42SgiiQFEYua9H/7h3bG5JmuidLB3EZDqD/u7+is5DJRAKX+LxdFnTpQKon/L3Jwf3YZJ5TTWSnmdlaLT8eehjzuXSRgO7Rv3LvaScx8TAIBJqE3Ku0OIde/qwdm+N5xk/eo6ODX2lwTqb09DfPejZ3kRewtb+RoAzf/HCMzvkPixcSlETpRjstbdLKJJTvDDjrr/TTB8HavonlJe3T+I9S9Oh2zSJdf929nmvw8UrCnj3khGoMgV04OJlcWwbKI13D24ysGZTF/omGgO2DJyzYAz93eHj8IEes3gI4VAhTz/7QvHvs844raLvfO0rX6zocyefeBw6O/fhyWeeBwA89uQzFQmH9nkLK9r+TEIIwWBvF1o75kOdyACmN/j/DQq8o74daiyKmCSjvkFGU8r2OORyyEyYqI0AqUaJa/FMqSrao1EM6jpShoH2KitkGZRiJJeDDKA1kfDESuqEoHvSG4N/1NIWtLvCdhY2Z5A93Fv/ObFwEuktpQVgw4kDiM+1RALRJUxubEFbcwOaWNOQTTJGkWVyJI5cVI/2eS3czy9qzmLPsNcCsbJNwjnHzvVYKM85TMPGfm8Aasd86574wXXA54YJ5jdKUOQ67u8cv6SA13pKo/nuyVrUtbUAyPo+69xrmSECwHsOly+d5ynbqjT4P1PfMhcZQpHWSoP5REHGC4MduO6k0mS0scfEt5/QocpWvsZhcw4+9eA8I8PSHAD8SYGqcbTPC55Q/u2+Av5s55ZsfDSCY5bHccz80n36nUc13GIn4L3QGcVT/5jACldi5RM7/CLWzeOdDXj/2VMv2ECkrM/bpdbN8TxLw2sKAPyrhX2TcSxoVTzvsd6vtBHF3/+lFWv2Esypk2wPR+n33hxSccumOfi3iyvLiTJME8N93WjtmA95itb8mWBcN9BQKECWJTREo6hjvKIxw4CmaYhFImiNlA9hmDQM1Lq2kS5QTEQIYnUyWjlhknlCfAsqAOjf7rd4ZtCIprbSNlrjccQCzp1OCEbyebhr0zXF48gWgMk8ML/R+l46l0NTJII6WS7OI871yBjee2pOQwS9Lsu5GkuifR5fiFcLIRRdY7Qqr1Ul7NymAZh6Yj9vTm9t9m7TVMqfh7G89/k/bG4Mu0b9gnFOUwLt8xrRXJNFlyukqt9sRX/aO3advzqJDX2l/SByxLe/G7caoKi8ZfVhy+dBN+Ep78re0+Vw8rlYaHor4Aqb43kcto3EUdfaiERAedkdA1YFpojiNN8r3Y/z21JYvrR0HT7aQnHjy9li3mHekPC7za3cMRAAmlPAVae3B+ZYuNdab9WYNbljR0WfE8KhAkbHxrBx85sAgEUL52Phgnkz/hvnvO2MonDYuWsPNE1DtEyi8IGcAGVZ5naI7iwU0JnXsQQxSJIMjUil/ZQk5A0JkgTkdAnJmH//c5RClmVM2m5xE0CkiuM0TbP4e1lKUefyOuwa05FjxvTFLYrnPC5plrG2J4n43NLiWUmUHvx3HqPgpajL6h+hoASoT0qB16Ol1kQnM5Yub1MCP7+wScaeYe8gf/UJESiMB+Wjp0fxs+f0ojv/E2dFPNtc1CyF1qo+ep7qGdQ29xHsGOR/1tnuOBPHHo8AqZh3vxqTElTZm8yoEwmTnNjr368x8IFTrOVGXqf42O8LxaT0ztECHvtsspjX4ZQWVQ6SDpvbgh0KyOvB9wsAvLi7dPIIBT55WwEvfrGm+NoPnvTeyN94SMNvPmI1oaykdKYkhf9+OXjx5umCd0wK6ra+e5jimPne1+rikieZes8wLYrnoCoyP31Wx4WHq9wETRbNzhuQZfmAjpu9kxT7ssDcBgk65xpQ+7UJQtDO2U+dUhiUImG/N0YIaiQJirNwkigkCRgvAO31/u9L9vjKsnuQ+IRg/7h3/6SQc5d1jbsOD20x8dnbNBgm8Nnzovj0+REYkgTiOm7nehiU+vJa2AWVQaZ3z7p5fpeBtZ0mrj1RRnvdzN0PazunHlby0dMi3OOrZcLOMlr43K8Z1FcKfWW7ggc2+R/appR1/ptrJI9weJIJNU1FnTKopXFHM/37sWZv5aFajUkJsYiCGKOPaQXPKKUU46ZZrPwVlyS0R6NIuuZIthzrP5ynIt4fxdcfKAmiPSMUm/spjpsvF0OqHQih+OBv8oHjWGutdz/b6qwGrc/tLJ2721/3iobmlITlrTLyOsXXLo2hPlneZXqgxywes2tvZilrX99QjDM79uij9stvtLQ0F/tPmKaJsfGJ/fI7M8kljY14d7M/rGVnPlucggqu9Y1GKDT7OWIX8MXPUIoJwygm5uWqjO9zJ/Sx393OxFxHFX/X6MVNCrK7va5molkP97uPVnH+agmRBq8KUGt01IXEofO8+0tbgh+9pc3+9648zm997KiX8aePJXDBKgUfOyGLf7rA+5lyDW6WMfvQP0Gxpc9/vt3x7GxidCPnuCOK5AuT0ExglNM4bl0XKZa6fXq7WRQNAPBmP/HkWxSMg6us67aB4Hs3X6YDK3sd9gxTbhlch5f3WCeGUgoTgFpmPlrSMj3xxWvGxQrDPSP84zcIsJU5Nw1TyOMAgJ8/W5l190B1Rx5Kl3qY/OCJAi7+vobP3QI8vYVwy08Te/wyKPWMZQ6UUgzZPXM0uxqdO5nU2WS2QJHnXKSgO2hnv/+dvrHKvgugWNq19F2Kz/1JQ8EATGqVv9wyZF0rXvLrsK4X5waHJOORnqmCCn9Yo+Gam3L49iMaLvy/rK/S3lQhhGJtZ3UDlBOmWRsD/vZMvqGwJuY9D5mAzsQOQ5zqP+4yr26cMqDNKe9vPPam9ziOma/4IgTY6wUAr+zxfu/jZ0bQmOTv57yAQhpBydE6pRjSdfRqGnbkcujVtOIcn6cUewsFz3POJkcvaFBw8RGqLz9rYzfhzitv9pNA0QAALSn/Ob1odbgR47qTIvj5++O4+UMJnFaBwWO2IoRDBby+bkPx7yOPKB9CNFWi0dLCz3gL6mZPl4/PnYsvLliAY5h8jzHTBLWnGbcVyV3S1EoO5T+U/XppMTAd4cBOzHuZ5m8LGiWf9Xpxswwz7111WTkNFO89PoL6FCCp3v1OrRhDbUhEVY4TrdJRF7xQuvgI74BywWEK5gRYxU5douLr74zi4yfnqk52ZUMZNNNq/Mbivkw+4RBQf5odnDUjeOH725et6/3QJv8icM3e0oiuGQdPZRUA3CRzh3IN4JKcNcSd6/TAZ8appJPTrcVnByfMOj43jdojh6E2FHxlfKtF5wgfd0Ml3aSh1WTYhoNTSQCHbTmuZEFZ7TgShF7FdvI6RdcYwWjWav717Uc0aCYwkQV+/BAwlvdvy/305TnVlaidB5Gzra1gFloGIbh7vY4P/yaPs7+XxdPbDd/3WTSDYt+Q//XeUebTAQs60+5GXfoYxQ/+QjzGIUKBtXZfHIPZjk4IRg3D92yzz8BUO0e7x6wdgwT/ek+hOKYNpik+8tucp7fIVNkxRKpqepqIAE9/LoUfXBXHs19IYTHHYATb2u+m2FOBUvzvowWc/4MM/uP+fFGgspWLFNkqxsGjyR6/m5hxnB1mjluggHEs+3IWCgb1lZ8+a7mKy4/hh9xdcxJ/4UwC7rNJw8CgrmPMMAKCf6z+JMX9YZ7Vb3Z3Yq05iiOYPhC/eVnHi5xKUJNlEt1ZsQUA7zgiXAwct0BGMir5RPHBhhAOZUhnMtjbaSWnNDU27rdeC4QQZDKl8JhUBcnXswJKfdWLJkmpmVPBsCwxhFJPKAKlwV4HI8Rr4GZU17E3n8eQS2i4hYPbValTil5v6gI3vnVRswyS9x6PrFKoUYJTFiuo4VSgoLqMugCrCgCkYv7XwrwBZy1XcP1pEUQU4IgOGf/znvBY9JhqTQ7VwmvY9sx2/wA6FeEQVf2iZDxgUr17vY6CQfHwFv9vv+yyYGkmhVbGUj+bCPU4lCkrWhvzn9ebX9BCu3ZTSpHTLY8DuwhLLJxA05m9qF09gtYLOjFaRRwyD56Fzl2OtWuUViVOpioc0gVgfXf4D1FKUaAUT++O4KO/zeNbDxeKC8VqrdjusaYcz+40ccPTBdzwZAE3v+C1HkzkgN88x3vWwsc+55UBXce4LRycRdREnuIf/1zAT5/VMTBJ0TlK8enb8p57jT3aTIHi1V3Ut1AEgP5x77+DzhRbPvbJTRSv7PR/bvegtQXWojyk6zAp9fVpSMVYj0PADtjkOM9UXrc6kz+z3cCf1mo467sZ34L3zT6Cf7ojP+3u2K/urc6qcfkxESxokvGeY9TQcCn2PDiVm+5cZ+C7j2vY3Efws+d0fN8uA8uWDW1JSWgOGKed/EPeItjNsfNlRDnGIDcbuonn3EqSVar742dGPAUwGpPAT66N48qTFG7p4SBRkKmgTHHOblwITqgSYK14j5rnPddv9hN84JYcvvWwd0zkhda6aanxn7P5DbJv+8Wfts9HMsI3DB1MHLy+kreIHTt3FweURYvml/28w/adu7B16w6MjI5i9eGrcOLxx4Z+fm9nV9HLUFdXW7ZHxGyBAliZSKBgN3BLQEWtHvXkP+R0oHeS+ErV6YRyqy+4yRPCbSikE4I+1yTeYicS6oxYcL6rE4LuEe+2ecJhcZMMkvfHeRy52GoUoyY4Fnld8TSAY7nuDAnfcDWBu/bE8KRHSZLwzXfH8fV3xipq1pWMSphKv6yYKqExCYy6cqF7OfHkzqLCMP1eg4aACckXqmTwQ5VgL/5ufVXnLordru+CsX8qLY1mCLI6xbyGmSsNO5KVPB1YWcp5HDTOgnbnEMWVv8jh++/lC0lLpNsLZeY2rT+hlHAhycC2+gEA9VNu1sVrxjWRp8UGc0FhSkHUV1EDoa1WwoDLqvrcTgMnLAy+dhql2DtE8PkHakFh4uEtJiQAX3pHDCNZGtrx3I1JKfoLBlqjUW4yZvFzhGJrP8E/3JazLdD8c3HbixSfOsPEQtd9V044OFb/rOs9ZyH+0d/kfDX0h9IUz+00ccFh1lTvvqvuX0tw48OUG3ICAKMZIKfRYuJo0BVlF3+/fZb/nO+1vRqsx2HSNLmigLW0h4Upbu41sW6fiSuOi3g8r89sN/DjZzS8vCf8frxrvYFrTjTxthXeJdFrnSY295l4x+EqWmvDB5+1e6u75688zvot1sjCUsMYnpx59PbXvYPIdx/X8LEzor4eDq01EhoDhEExVImzCHZz3ALFt132emzr976wsk1GQ1JCQ1LBTR9I4JaXNMytl/HR0yJY0a5gWNeRNk3UMLl7PI8DZbxaYQxqGhpUlds52qAUyzv43/vFcxq+eEG0mOtQrmkfTzgAwMWrVbzBqZR0zYkRtNn3UPQgN9kf5Lu//9m9p1TydF4V3obBwSE8+MjjeHnNa3jwkcfL1uJ98unnin8fdcThU9zbtx6TUJxeU49Pz5uHD7S345xUIxZHksVQJQDYPUwwluP1Bii/fWrHL7K4LX/uuEZ2UnKsDgVK0cXEKy7huIYXNEqQiGyVWnWxerHlNdFkznHoMmpCnAJnHS7hhCXW34ubJXzq7MrMDZV2+J2O9aK1pvwQQKk9cGvwLNhQTaiSSTEeIBwAq9cAj+4xK9wDtvgoZ3WsBkopfvm8htO+k8Gp/5PF9x6fnhXezc6RcBES1ODMIUhYbO0nuPLn/qpXsBv3PbLFwGCGenKLYCfxuxlKWCUI01M4ZEopN2RsOEOxrZ8gr9Oq48Yr9TicuUzBu47y3lzP7Qi/KQqE4M+vUE+J4xue1KCbFM/uMLFzsPR91gORNkuN0CYMqw79WD749woGxbYBgoc2G2XDVgoG8L3HvBfAE6pEiKdxIuzcGJNxD5iUoneccBtvAcBf3ijdDI4RbDRN8MOHgkWDgzvPYVMPwRU/y+LiGzN4ZrthVbDTdU9+Q7ZAsTegwELnkN/jQCjfQwZ4K+0gxDt0++s6Lvy/LL5wZwFv/2EWQ3Y/iHs36Lj+t/myosHhtrU6NINiYNIyVt3xuo53/SSLL95ZwFnfzZRdSG7pr2xwWtUu42fXxXHGssrstinmPGQ0IKtRPLXN/3u/fF7DANPDoaVWQirK90oH5Ti4aauVMLde8pU+LhjeQgz9TB+OBY2lbZ67SsVXLo7hk2+LYkW7tSGDUks0Uv/9zJIlJDTHxo1hN1jk5QgZlGLFPP6Wcro132ztN7FriIR6dxFyzthQYwA4Zp6Mb1zGCT04SBEehzL09ZcsdXM7AqQqhxOOOxb33PcQ0pkM+voG8Oc778X73ns597NPP/sC1r6+HgCgqirefv45M7Dn+5+CQbFzmGBSpkX17UwA7mfWJHw3d6VRAnnTLFYRge1tGHNNVsSeZOOyDINRI5r9Os/jwEtQjqoSElGA5BXI0dK25rRbCdvcrq6mP1eC3ea3PyCj1oxhTlIpa2GqlkoFBo/2Oim0+o/D8ztNfO8JzRcLGuRxiCre5nSagdDk3rBOp2v2mJh/rGxb4Wfm3I1lKT7zp5wnCfA7j2o4okPBO8okuFXCzpHwbTjCIK9TfO9xDXuGCT50SgRnLle5HgM3QSF+195srVTn1EnIlmnRQGV7MZy3GgFW43XgeRtgh07cuc7A8tZgd30Q9QElCd1IEvBPF0YxmqG46YXSSViz10ROp56SwJRSfO3+Am5bq2NZu4Rtff7tXfTDLDb3EcRU4KYPJnDOCgUv7DKwusPqhA5bLOiUYmEshjHTtLpv5whaAjwko1lrMb4upOmTGzYJ1W1tHc0SfPOpPBY3KbjmxAh+85KO/37Iis9fPQ845wgJlxwnwVRpaNflh7cYRU+Q86kH1vHFH0vfGLCkzTqf/3J7AVvtJOq//2Met35WQoSJ1e4dC9gQgM4huzKaa6zUnGRwrseB9TLzt/urF7SiV3T7AMGHfp3Drz+UwBfvzHNDsABAkYCLjlDxl42lB+3OdQYeezONibwVIuruaj6et4TIR07jW2kotURzJXz90ijOXll5t2A2OZpQ4NEt/AHiF89rOHKud4U/t16GJElQJH/378aAHAc3x8yzvs+bt3QTxRCmznHv1luYhfXCRtljUDJdgrzJVXqYd1tWEqbkJk8IHjvqKHxk61Z0MXkPbU3A24+W8MgG/83xgVty2DFoXUdek0uHeEi40ap2GWcsVYpCvqNewg/fF59Ww83ZxiEjHCYn05hM+xt55Fzdm8fHJ9DT651BFEVBe1tr4HYHBkrmk7oqwodisSiue9+V+MWvfgtKKZ557kXs3tOJs844BW2trYhGoxgcHMIra1/HJrvUKwBcd/UVaGnxVyqajewbpchpQFZ25RXYaoB9JHnux0pjoNlYxRFO4niOEMQkyRcf6Xx3OEswzhhq2YSxH3R14ZXJSSTOpFDrvKszpVaDRgjfXVrBeCBLEmqT5d3SbzWtZVzUDtfenOMuGIMmnAgzsugmMBbicQjjlT0m3n20Cs0ApIrtTuH845/zvkUbAHzxzjxOXJREM6diRjm29Jnom6A4eZHk8zgcNU/2JARrprWI+uZDBfzieetee3izgRf/OYXWGilwwVMJQeVLeRim1WyOl4cTRLkF545BUpx8K6Wcx2FVu4xbPpTA4mYZ4zkKWSqF0BUMYO1eE2cuL910z+wwi+f19YASkZvtylUFA7jxKQ03PmV5bZJR4FcfTOBtK1RkTBMGgG5Nw45BE39+iWJOjY6vvSOCnz+n48fPaJjXIOHG9yWQ0yh++JSGhqTkSeoPYzRj5YA5OU/OONk1TPG5X1MMpw0ABv6y0cCLu8ziM7ihE9jQSfFGJ/Ddq6knMd33G1nruM5aroLaBp8nN1W0e+gZpSDEysnY2u8WNRSv75Fw8gr288Hb0gwrbyIeofjKo3ns7avBxy8w0dbBr9DDLsyCvI27mZ43r+8jOPob/jjBRMQqftGckvD3Z0VwzHwFD202PPOQU2TALRocdg4F39Pd45ZHthLYnIXyn/e/dvd6vnCYyAMvMMad05bajfg4ny+FKgWPd44QYZOj4RIOBqUYYHMrmG2yC2fH0zBhml7hwFkrVC0cKEVHNIr2aNQjHLL2dv7l3RL+9tQorvq51+PnHrfCjDctKSnQ2CJJEn7xgQR+9YKGvgmKy45WMZdTGvlg5pARDs889yIeePix0M/c98DDuO+Bhz2vNTU24r++9qXA77gTlhPx6lxNxxx9BD72kQ/gD3+6A5lMFvu6uvGH2+7kfjaZTOD973svjj3myKp+40DyjYGdyJomTFAk0xI+1N4O3XBiab0PP2/QqrRACVsdiRf7mzdN6Jxax853dzGDviwBCxu9D35XoYCtuRyiHN02QayKDmzZQcBuOV0BzkBJKcWEaSJHCOaU6dWxv2kPqe7kJsjKHBiq5HNr02kJByeedqbKsT61nT8rDKYpvnpvAT+5NoH1XSaG0gTnrFTL9o749UsavnS3NQkdv0CGqXtPwLHzFV8loYKB4uIW9rF9/3ENX7vUP84cPkfmlsqdLoRaXoewxUxWs2L2D5sjIxGRyoa38EhEgj0lAELLGQPAdSdGilVn6hMSjp4nY11X6Xw8u9MrHH72bHVdsV/a7Qq30YDvPa7h5GVy0RDRlzXwiV8SZAoAQPDr59PF8zCUprju5iwm8/76+eUgFPjlCzp+9LSG2riEj11AkIgBX/+zJSqKxxcQjvXkJortgxTpMs/WXzYaOGu5ilHDwMudGnb1+6d+KWqi5rBRSBJFemsjSF7Fmz0UY1mgb8x/fXrH/B7AnpDylQDQOQg8uI7g2TcBIIZ1v9dw8ydlrihgQ5WCBGu5kBIAOG+Vgl+8P4GIYl1fR6ies0LB41srG1ScakW8vKBKvQ3gHFc5eM/mQ5srfwjPWlbq4B20L2GhSqvtKkRscjTsMSwVsyoejTGhXOXyJpz5kA1VYo2MBqXccOUwcvY8zWodJzdIkiQcvkDCu45Scd8b1Q9o5Y6tMSnh8xfEkClQDExS7rkLY7qJ+vubQ0Y47C/yhZIijcer77R67DFHYuWKZXh5zVps2vwmevr6kclkIUlAMpnEvLkdWH3YKpx2yomIVylMDjRbtQwK1B4wDWBSNyFT65Zih1FehGKloUqsx4GX9JQjhBvT6AiHPUzM9YJGv+tVC3lYx0wTBUq5lo+wKA9ii4SkLCNnmui3/21QCgU44MKhrUzCXzkaAkI2fOe2TKiSm2WtMna6LD9b+gl6xq1/U4pi2MVUMczwUKB7NhiY31DAjU9bi89zVyr4w0eDy2ZlNVoUDQDw2j4CwBuKwJYAREAVmKe3G8jr/nuitVbCFk64TaUQXYYc8T4DL+8x8NgWE6cskdERYBF7YaeBv/tDHsMZigWNEh78dDKoKmcojUkJufHgL5br48B6JM5cpmJdV0kcPL/TAFx9i8NK4VbCy3tMjLkU0tpdsEWDBSue9rGlSznEVOAfL5Xw7Xu8n/3a/daGByYpvn6HtUCb4KexcLn9FROnhySHA8CDmwwcfmof/q+nB5QAqZUtyGzzdi5vOr0XsTZL+cTashh8dCEef0PCU5sols/xH1/nsP93wkKVAGDjPmqLBovRLPDUJorjlvivv8/jwHHDsfkePGIq8O3LY8VFsjsR/8rjIhULhz0jBD94ooCXdps4rF3GNSdGkIpZQmRLX2XbkCQgXuWqK25XzZtKCeVV7aUGd2FnKixUyfE48LzlTvjouGlijLlny3mzHc8C62EwGXHGm9fLUaAUJqWQmcnZbXRMmyYWBZTALQcbhhVEKiZhSZUeJpS5VrOBQ0Y4XHrxhbj04gtnfLv/991vTnsbyWQC5559Js49+8wZ2afZAmsZMEkp255Q7yjHzXGoMB7DoFZismxXR+KNnwVKuQ2VNLvT6j4mv4FX1zpsgHJKH/JyHBIx//fGDQOPjI7imfFxjBoG2iIRfHHBAnS4hIJp52tU0xl7pqm0okwQQdU62KpKuonQ5Gg3n3pbFF+9L1+M06cUeGiTUUwm1E3/9quhnNeCUhRFA+wuqq/sMXDyYv5weU9A2IAb3nnmJUDvG+WLmrCJvRJOzs3Bq5Ge4r+1kRje8+ccKAV+8Tzw6D/IWNHmPalr9pr4wC25oqdg3yjF9x/X8MkKk/vd1Cck9IQIh7CqZLBjit2cuVzBjU+X/r2ui2AyT4vdhoM8ZNXw5qCJdtv7ODQ59an8/CMlfPK0GFJ1JtSkif+5h/XHlshr1n/V8MB6giX13gPuqJM8FdIGMib+b18voFhVteqPHUJuby1IQcW7TpBQV6/jyZaSuyTSqEGt02BMxGASYGsPfOwZ8B9FOY/DvWv97z/7JsVRC733tyzBk7OCAI9DJeFBHzs9gvmN/AHjHatVpKKVbWd9F8F6W6w+vd3Ez56rvDSvQyICxKqMdZckK7l5IqB03vwGCbGI5DG2OLxteWUDZX3CqljnK4kbLXnmeTH/mmHNYTlCMMZEhwVVHXJwhjniEgqOpd3jy5qi9T1LSKmjuo1bpGQJQVv91MbVcsc2XWYum2//cGgFXgneMkxCfQv4H/R24Ufje/D/RndiTcFbBJzncagmjtvxOoS5LCc4i3oCIGsY2GSOo+GUPiQWWh252a7J4IREuRkLEQ4NTMuNUcPAV/bswT3Dwxi1vzeg63hg2G+im6nGVFOlfZrCIchSzE4yWZ0GTnws565ScOFh3g087EoGnG4TuHKlUHk8ysmHcLjlpfKrDl4Mf9B+7A/h0MqYOeUIKc7HBQP457u8F2fnIMH7b876wovuXm9wGxqWo1wOQyLir9riho2PPmmR4vm8SUrhRlmN+ppgTYWNvaVrPupPn6uY45cARy2U0VQnQZYkpKp3XIeSKQC3vOS9UMctULCkuXTO5CgBFO85iS+wDuqiYyWcfIT//laS7huR+sw/ezjVk3oYz8uR87zXLc0ZAzbu89fMjyr+7ue8556X23H2CqW46DpmnozPXxDsyU9GJVx9gleVfvGCaMUL7mpJRCRf0nclsAnSbs5cpuDq4/lGDXd52bBS1pIkFXs6uFndIRfzb3jPZ8GgyBOrOzqbQxhmlfdVUmL+7353qk9yxjR9woH93VTd1Obfcn0vpovwOAgOSaxKSd7bO0cJcranYYIwHUvtj+omkMkD9cnqXK8aIUjIMjdMySEb8N5jY2PomduPJIDkokkQTcGS5ibf51iPw4pEAu9obES9qqLJbnLHC1WKMNbQNRMTRaHhZk/BX/syTwjqAo9o/zNdj0PQgpZ1a/Oqvpy0SMYapvb5slYZc+pkvPMoFfdscIWK7CUYz1HUJyS7ROXU95vXIyGuAvkQx8FIQNWadftMbCjTgAx2QzdJ8hrPgprA9U34txdUvaoSZAmoY1w0EhO29NJub7+Um1/QPJ3eHYYzFI+9WX1McDnhEI9YYjPIG8R6HJJRCScsVPCiKzfh2R1WP4fdw8aMTLw7+4Dz7ZSzkWkIh+OWSKASLVZ8q4nzF9Asq+Za+8BagY+YD9QlgRe3lV5jyyTXJyScu1LF7hdtQcHJw6K6jOMWA4fNBdZOBggHiSK1bByplWOQZIrx9S3I77OKhIxmgPEsRb19b66bTMM8qxcdKsH4hhZkdzTgrJUyNnaHK33NAF7e7t2/iAJEmIUuTzikOcLh99cn0D9BsLWf4KzlarEufxD/elEMugls7TdxzYkRXHeS5VHrnyA49pshzVimQCJSXSECByvPgX9Xt9fJeO/xEXzrYb+iP3VJ6bn/1rvj+PwdpRvv+tO8D1VzChiY9H7/iI7S91VF8hQlgH3tCIDJnN8QGGaV55VgVV0eBzdTeZbTpont2Sz25r0PGhsWNde/DKgINvF7JqE02CM5WxAeB8GUMElwQyAAGGeEAwGwbwj46h+AL/0OuPFBq0rGvnweayYni9UOgnC8AWFeARan7veDI944pbqjh7ihSmyOw4fa23FGXR0OTybRbocY8ZKj2ZCtIY5oAIBhTtfZ/AH2OEw3xyFoQciGErELGwA4dYnfbnGGXQHkvFWqp9uoSVFcJFabIE0p9XQ15iX31pYpBzqcsbbRzyzqf12BtwH2wpeNbc4GeBxYIRJT/aUpqyEeAWqYIu6y6r/vXneVEGUrpLi59dXqXTZBuTDFfVSl0BAOVjjADldy84vndZz6nTTe+eOptEP0s6PPVUWIU8M/UUFFzUUtwJwGCQU7ZBK2cCjHEfOB//2gjOOW+N87ZYWEd58Y/tzWxa3a+Q68PKz3La/F16+2Sm1OEP9DFZuTQeuFnag/fhBqjQ4laaDhpH7A1ctmj6uU86/7BqDETUgqRf0xg5AiJs5YWdl9+8wW7/mNqpLP48Dr48B6HGpigCJLmNug4NxVkbKiAbY1/ztXxHHvJ1JF0QA7Rn+mG04motKU8rPYZnhuGpIS5tbLOH6Bd2dPXqx4PBXvOlrFSYuszyxskvA3p3s3yit0sZrJzfJ1jzathf0oR1/xPBgOQb0bZsrjsDOXw9c7O7G3ENwnBQBaaqcW9lqtx6GaZOcDuyKoDCEcBFOCl6jmZpIRDgWD4OePoujO3LQPeLQrg6/u2YMburvxL7t38ysWOd93GrmVWWgTSjFmGKCUFheYr2WYUY1K3B4OOrPtqCT5kquuaWvD+Q0N3t9ktsPt9WCHUrFCYSrCYSbDm+ri1SfrOTSl+LW9wamqxAqHuAoczan1f4ZdASQZlXA+E670gyc0PLjJQE6rbipJF6yqWtsGrDr8eU7ztdoyi7mHtxg4/ltpHPvNDL56b2lh+uzOylRMPCL5wm2Ccj42MBbamDo1K2Xp+xLqFRWFwTjyPUlkO2uQ3Vvrm5LvdXl4CgHeEAB4cwqJx5V6HALf59xnZy7zz/hsyMt02NFXmvBZj8PVJ8t46Ysp/PYjXkU0t17CZUdbB1ITBz71DuseLxBSXLSwnYBZPv9OCd/7sIxUTMJpnIX3qSskHD4vfBt1CQmnL3WFc3E8DtecJqPGFswjHKNGYn4GkQYNpCBjbG0rhp/twOjzHR4RsrmbIKdR5EwTg2ZJREsKUNeRw9L28scLThnXqOLvT8Pr48Be77oK+oFUiixLmBNSde7Gq+Pc8J2aWLCorERs8ggLVXK8vl9gQrKuO9H7YzUxCXd9PIm1X07hqc+lsKzVO/7yqj25PQ4IqJbHEw4NifD+Qr6EaPvfxJXj4DAV4RBU6IT9XUWWMKeB+9FQylVVckMp9QmW0M9XvztvOUI4CKaEVmbtwAqHO14lGJzwfmYLxosWhlHDwD1DQ4HbKxArlIKtsORmSNfxpd278ekdO/D1vXsxqZnFpGY342vaMb+B08yG2XZUknzl3BbEYjiupsbzGutxCBIO4HgdTI5gKUfY9qtFkiS0TjFc6ZoTgld6rKBgu5k2JCUcPc8/656+tPTaO4/0b/+GJzV89d7q2h071ZxymhX2wXocFNmfiMnD6bJ80wt6sUpXuW6yDomIf9EQVEbS73GQqi7hyP72nEgMw08uwMhz8zD2UgfG17b7wr0eceWRhIVtTYVywmGS6GUbLrEct0AJtcROl7EsMGwLBlY4nLpcRludjPNXKbjWXqClosAPr47j+++N4zcfjeJXn5Bw4jLruN0e1bAch8tPkvDO4+Xioutth0ueY1zSImFZuyVKeJ2AHerj1j1TDFXhnH63UWQ0wEsKAHKMoO7oYUQaNBQGkqBm6Ye39gK9EwQDbKtyAE0JGUQCLjuuepNuRPXH5PNKtk4WWI/DzMaeB1UbW9oi4crjI/jnt/tvwHkNcuDzWsk4wyPM4+h4Cs5bpeJH18RxwWEKvvnuGK7mjM+KbHknePvBCyc9bA7rcfBXy6OU+kqxBhXNcGA9Du5EaYBJiKYUlFLszee5XnseQXMqr0fE3EbuR0OptKoS7GPi9bEKQggHwSELL07czQQtTUQ7Bwn+ss7/+clar5niodHRQJeeZouGsF99cmwMPXazlx35PB4fH8MeJsaRGBLalSjXhc1aKSKyzG3ywj40w4aB2wcHcefQEO4eGsJRqRS+vmgRvjh/vu+7QzMQrpQ1zWnVeWYHz6kkSN/0gTi+erFl4WL3hVIKInuPiReDvbBJxoWHlRYV7ztB9cSOXnCYilqOtfKp7aYvZCgI0yR4bKuB53caVkI/9QuHqMKvUR7G09sNaAYN7U3gxvI4eF8LKk/LVkeJqfzQokqJqhS3FHaj8fQeNJzai4aT+iAn/AvF3cMU2wes1VlQ/sVUKVduNSMZvtAUN7yFTkSRPDHc+4Mdfdakz1pU61PW+ZEkCd97bxzrv5LCpn+vwenLVCSjEtrr5WLsP5huuDUhVnG2ulRTjYTvXRXD8lYZJy6U8V/vVSFJVvOp+uAKwcW+GOesVO399H/GPY7xmmp6odAGEwD1bqh31FrQ75zwPwgtNRJ0SvGJ82UsbSuzeYaoIvmeSYOUxpqcTpEu+Bvf1c1w4vncgKo7jsf6vcf5FW1rjRTscZii0A3zOLpDjK44NoJffTCB60+LVtUNHgHinhVAQaFKbEWlJq9tzUc1HgdCKb7f3Y2v7NmDz+/ciRcmGAskh0o9DgAwr6n6+S8sDIuFVBt+NMt7OEAkRwumSrlQpTQxiiVUf79Gr7iC0p5CAUsC+mWUs7Tfw1QtemByCAmmm5s+GsOygNrNbP5EhONxAICVySS+s3QpOiIRDNmi4W7Xb59ZV4cLGy0zxtJ4HLtc4mWQIxxyhKDynuSW0DAoRaTKicGhQAhislysOGHlOVQ+tC1qknDJkaWZMW2aGDMMzIvFYALoLhSgM9tjF9jOQvKmDyZwx+s6IoqEy4/xDkepmITvXxXH52/P+yoybeoxi/XJw/jSPRp+94r140fNlXHbxxIoMKFKMdVaqFRDTJVCu/WyxFUn3Kb0nUob4sUiAJTKro+S1NF4ei8iDQXk9tZi7NV2xKMyNpuTSLh07OQWflbgQ5sNrGhTfB6HZBTF8rhToVxyt6oAshJ8PngeBwA4a7lacR3+qbCxk+DwebKvkEMjszBic4Xa64ARyj/msByHWk4uyNuPUHHZUdaKs6dQwLh9uPXJ4KTtelucnLtSwX8+wA9Vcvauu1AoW2pAH4tBG/LvXM+otc4Z0PzjWmOtfberFF+/WsbHf06K9xCbZMsSVQCV03TRIFZM+hvdBDUxeHKXUEaUTYW5HM80XMKhvc4yfrirrr3zKBU3vaBzbcdT9TiEeVLY3IRK8jp4fPgUFU9vLx3Hu07wb4f1CgaGKoWIWlSQ4+BmYzaL19Lp4vt/HhzEabW1ocKIJxyubW3F3JhfgVXrcaiJVWdso3Y5+UohB4FFf7bvn2CWopVRAsQOV8pqFGv28id2ovlvvxdDrAmTHKvY5kwGdw8NYXeeH9y8M+8Na9FH45jXyH/oeaFKkm3h7ykUit6CuCyjIxrF/FgMLZEI6lTvaOoe0FqYkks8j0NY+BVvH8kUm+I4EMbLUW1lJTaEIE0I0oRgTz6PPbkccoQgUsYk4QiHiCLhvcdFcPkx/O7Mlx4Zwdp/Tfle39hbfiH9+j6zKBoA4I0egn+/r+ArdxpTJWtxXgW5KsrLqrI1mVfqcWCJKIAcqeyzqVWjiDYVIMlAcskkYu1ZRHnfJfxrvtcOwWJLxdZPc0EWFqoUU61nJuwasPkhDtedFMHi5pldLLr5w/PADQ/4z199Mvx6hC0QqxUOQfHe4R4H6/+r2mVccJjiC1WS7HFqRy6H/9y7FylFwc0rV+LTc+fiH+fNwzLGeGOM+RdcckKHemQ/fj3Ui4e7/NmxTXXW3uqUYl6ThG9cK6Gt3jr+T74dmNcQ7OWIqPyk1a/eW8Bx30zj3T/N4vwbsvjvB71qdiZzHACgI8A44c6R++/L4sUKQkfNk3H1CZEZz3Go1OMwHc5bpeCdq/JQZeCoeRLef6Z/u6yBpRiqxJRirfcP2R6CukVTjsfhOWZNMKjrGC7jIWNDlY5JpXBpc7MvzBgVeEfcSBLwufNigbl9PA7FUCXhcRBMCV6iGssju/JopYmAuvvUVxIStnC4prXVl5QMTg+H19NpfLerC+B4GxzWZ7wmOX0khoZl/P1lrRQ/7u3F+nS6+PqFDQ348Jw5gGOts/eRHQSfGx/H9e3tiMpyRcKB5z4NwkkOZ3+zGqgtHFKKNTNX43YFI4zgKlHrFkDlKlW4LVJlLWQKxXuOVXDXutKNtKmn/A34/x7250Lc/rrhS0qOqv6kv3KM52jFDe0cwcAufkcr/L6qApEQ4fCeY1W8/XAFn/hjATUrvP1T6o8bRGy7fxanAcLBCSljvTL1CW9DsWoJW9A54Q9h4WJBCfy1cQlP/GMKr3WaUGs0XPEDs6r+MJXw1GYmHCYByGXu2bBdCBUOnPPkDgV03/WWF4f/S45QkyQJP7k2gR+/ruM21/uybXT5blcXCpTixYkJXNfailPrrOLQfxr0NmnQx/0r18ZT+hFry6ETADgOrHamZOUxi2T8/jMUlAKyRHHfq8FnKar4qyoBwG9eDo8NLFcdrVo6AkKV3H2AFjbJeO3LKewdoVjWYoWRBQnHxBRzlWoCvidJ3k7Y0yGiSPjPCzL46YeaMGqaGDRKUQMOvlAlwwlVYp6RMh4HZ84b1DS8MjmJjlgM17W2cqsqDWp+V+eb2SzOrK8P3D47l0dDvBMrOoKfI4fzVin4ykUxxFWreay7dHU5KKVcT0rg56v47IFCeBwEU6JcqBIAPLA9j2d38B8ZKUK4cbejhoGtuRzvKz4c0YAQCzz7qj4a5w5qxFUu0aFOUTwD0OZsFqOGAZ0Qz4OTY0KoqKthXCsjHHihSlMRDtPxOFBKPZWZqm2oJkulxYxGCHdfygmHcsmybgqE4HCmLOCWMpV9ntth4JmAe49t5hZVg6tDBVGdcJDs/3tfr9TjoCo0MFTH2W4kzj8fkkIRi/p/J0g4DNoJkqzHoa6K68XdRzU43KiccJCl8PspEZFw/BIZdbXAly737ufCFu9nrzxOLTZGC0suDqOxpvzkPmXhwFkEeq6s61kLs+q6hVpNTMKlR3lPLgHwzX37PGJ/p+211QhBL7NY08ejgEIgRUxAJlCSOmJtweN0dlMzzp3nH2gVWSoaCqIhoWlRTh+HSuDlRE2HuUHJ0UxFoogiYXlrKScuKJdhqhXsUgGhSg0JcD21U8FJ4JckqXjPsVfIF6pk2qFKTMhcQyq86IdhVz/8r85O/HFwEN/r6sLNfX3cHIcPtLf7vl9ujeATDnLwzTSvScLJy0M3h4akdX0XN8sgVRYoqdrjIHIcBIcqvFr6ZlaBkiy9MUZMPL+H/4DJ0eBB5c1sFocnw00WE2WT+YD5ShxdpjeeJLVqFK8mgX/dreDYmhpc3doKBCzET6urw+NjY8V/d2saPrNjBwAgJklYHI/j3xYt4g5Kk6aJNgCL43GcXleH1kgELZEIOqL+GaUa78GMCAcAedfAt7y1yhlasgb9xkiE2xAPdqhBGOWSZd0UCMGR872f3z1EUDAoYgEL/u89XnlAflytPjl6PMfvWhu0fXBKigZVVWKJqGWSKhUKzm1lIVFfg0IAaD6zB+mtjch3e/30TmUVthxruT4M5YiqVpgGr1t2NOJ8hm/5i0f8Xi4WZ9Fz/pESNu2jeGSD1UDty5fLuG8txf1rCZY26fjy2xNoTMVx54YCTl4QwRfuyOPVTu9YdNPfy/jXPxL0j/N/q8lesJuU+jrTOoQLh2ALJ5scjVCPQ/BvsB4edrSNShKWJRLYnC3FmOzM53FibS26CgXf3rWeXzLSjLw4B1KZZP2LVkXKis0wMRhRpxar/1Z5HOaUCe+caY9DUKjSdMKUdEIQcc1d7sUwz/KPgFAlAmCEzXFISdAoRZC9wwBwc1+fJyn/kdFRXNJs5yS67vlFtjfiDy4v2LYsExvFOTbPfpcZP/77fTIe30iRjAI3P0Wxl+mKXp+w7ldJkqATgjHTRK1a2aRBDkGPgxAOginB8zhQQ/akN0my9zOSBKxebGLrkMmdeM6pr8f8WKysaIAdplQOVjQAQGrpBLYB2DYKKJJUFA4AcGVLCwqEIE8IqJ3knJRlbkfqAqVFqwbPmtBZKGBBLIYViQRWJEqrAUop0qaJuCxDtQczYr9eietzJkKViD1wOxPHpUeq+Oq9KHYKvuJYFXeuCynPKFmekzpVRTrAqhRWIQdVTnh5QrC0zbtBgwA7BgiOmOv/Ic2geDlAsPKYSqjS2BQ8DmwMf6WhShElXDhICoEc0qkqxglzirbkofb4xdVQxip9yCZHV+Mh4hFXrfCNUc60WM7jEJTf4MYpbCBJEj57iYKrTzfR0WBd1I+eK+GyEwnqcmPoqG+ELEu44AgFcxIKPnhKFK92lsaJRS3AkjYJP/lbCVf8L//6NNrx7CREOIRVRgnra1DO4+D+e6xuHHPePQhqShhb045Cv6VoZMnfMIz1asqShGXxuEc47LatuJ2cDvduVs2RsH5tHeqOGLG6S3N429Ly5YMiLo9DtDVrJV/bCeUxRZpSY67aGS7HGpT/JZex8r9VfRymKhx0StGnaVjgymXJEYKIk6TMsfwjIFQJlPqqKjWmLKs/zylmUIpRXS8mPDvsyOcD+zisZNYE3ZqGSdNErcK/SVjDWiTE4wA7XPbsI4CoDNz7Kkc4JKXi/Ox4HPQKC5SQKr0IQjgIDlkkKsPsrrWSpCUKSIDClHhkhcOS5XlMHt2NNoWA6DIKg3EkEhTNjVboz8c6OgB70HpoZAS78nmcUluLE2r9NYdeZQadw5NJSHY4UaW4qyjFZBn/unAhcqYJAygOSCfU1uLZcb7psU/TsDOX47pNb+rrw019fWiLRPC9ZVZSRZ4Q3NDdjTcyGbRFIvjiggVFD4QBBFpnHNx9LKbjcXAWNTlbOKQlHfd8IolfPKehvU7Gx8+M4s51IcJMsuThoK4HdvzmNUZyU+lC1Dnm5hgwv0FC15grdKyPLxwm8rSqOHer9GN1E/BEzl8KMggnRCfB/EaloUrRMsnbsQigqAHbkgA14D2eeM/rloBkE8jLXS9Fhq/ykJvoNEKVKgnvYAsMtDDx9fGIBOJ6TBV70frOo1T8z6MSuu376v1nWcfZkJSxosPE9l7/bxU9DiHP7NRzHPyv8UKVcqaJ1+MDkO1qSfXHD2LgwSQACXVx/8KW3R8JwNKEV6Xsshdu5YRDU62VXJ/ZUY+6o725ZWZnPY49zEAbz83F4AiHxIJJNJzah3xXDUZfngMQKTA5uhxuT0tXoYCsaaIjGq3YOszCCwMqN7YhxLOQnOE+DlMVDoOa5mskqrvKnReFA6WeWr7sOFkwKLIa9XkSG0NClQxKcd/ICPc93jeo7bmPSZLnOd+WzXLXBuBUSIxVsMCP2R6Fplq/R9DtcXXEzYRhoLmC+5wEVIsKQoQqCQ5ddAn9z8/xvNR0Vrf3M4xwqF01ikG7rKQcIcjurocxUIff/JN3JH50dBS/GxgAALwwMYErW1pweXMzMoTg5r4+bM5kfJbus+vr8XxIRSZKgfy+GiQWlhbEvMU3ZRJ/Tg0RDjlC8LW9ewN/E4yL9E+Dg3jD7mI9oOu4d2gIH587F7AH03LWC801sBvT6B7tfDNHCKhhYMQwsKo9gu+91xodzTKrbmc3w5pGlQ1VqnDCcyYKg1Ks7pDRNVYagjf38pduw1n/ualLABMBYbGxKYUqUYxXlopTtDKyC+dKvx9VLQtxPCDUJx4tbZvoMmRX0YGxV9sQWRYgHDjFCQCgc8T/elho2TELgd99MIWjvuGvrOMQU52EUf++OHHTQfdMJVZaXyllZoETVwH3qXM8dsmolVz9k5cyWN4BrF5QevqXt0vY3uvfX6cKS9gEH/YEBTWAS0b54Tm8UKUt2SwMV4lVtVaHFCGgusINETqupgavHnccdubzyBECQikmGdGfJQSPjI7iaVd4Jnc/47bxYtzrVSCajOauVnzhfKWiMKOoAsTnpdFwSh8kCUgsSAPow+iLcxCZao6D69zqdojItIwsHE5cVF45vFV9HKYiHLKmiXH72huUQpUkUEqtin1hHZwp9eU4aCYwyrHVNaT8533Q9hKkTRNPcu6xWkUJ9DionNC6rblcsHBgfvu+kRG8MDGBOdEovrxwIfc7jkehieMmcVcwc57B8QqFQ7XlWGe/bBDJ0YIpYBJwK6ywCZduj8O8JmAw6bVi1x05jPEskGG6f7IC4I6hIWzOZvH46ChemZz0iQbZnhjDJvLs7jpoo94ZO0g4uI/iFLvKyFSpsT0XO3M5PDI66nnP7amoJEHaHTJlTMMy4XwrbZros5Mg3Zaccrl2lUxV5RYOYQtRnZCiNSzvCs06osM7YW/u4y98BxnhEFH4llyHmOrPPyjHWFUeB35ydKU4oiYw4TJS2jY1mOMwJUQCPA5yFcIhrCqSqgC6FG5Tc+8jS9HjELAeKxeqZFYQQyzLkscL5X726+ISzjtS9ogGAFjmtYsUcYTDVLtHBHkceGFKCCjHylaYg+t6Bl0rye5LE5EkRGUZTaqKBsYS/7uBgbLloZP2/htMpSU5StDYbFacmyDHTDSc1A/JddoTC9JQ6zXEFOuaVZv3685xoDPhnQXwD+d6H7x/uqD86j8wx2GG+zhMRTiMuwSj4xXQiufKet0xCbnPnE6p7xnVDIphpqJSRLGETto0i4JepxTDhoECpdiQyXCviWYLWvZ3nb9XMR6yZ8bH8WZAhAGvj8OwYYQauxyaOFqkznWenX0sVCgIRDlWgQBW454+jnA4tTEFVY0gqkiQKDBndQ1al8cQUSnqWzX8MK1gwjVoGRnr9ts3BBw2z7LiRqLE1+15RSKBI1Ip38Lb4fBkEilF8bk5F6sJDOsGxg0DkxubbYtWCd7gRWzrhkN7JIJFsRj2lnHfB5FSFJiU4ua+Pt97A7oOjRBEZbki4TDCVGSaahO4YkUk12/qhCBhx4GWzbXgNJNiKVuONUQ45O3kswWxmCenYzUjHLb0WvkoiiR5zsNg1rukq4n78wvcWFWVyhwQw3iOYqLSHAcnOXqKiwZn3+JRAByjfizi8pgwXj5KJCgBxx6U4No54j+usFAlVQGoHO4BiyrBiyZn34OuUTnBxXobgnAfFfu88UTZ8na+h6QxVcpxqOS3WJIxS3yznwkSDu6jc57dAueY5ZgJMxsp23MjJknI2zlVS+NxX6w5y8JYzBO+FI/ZcfBZFUSTPYUuBhb34LbBGpiU4phUCkekgks/xSFh5PkONJ/VA8klbpWkUfQYRRR/2FwYHuFg/3+6wuFTZ0cxOEmxodvEe4+LVNStfMb7OASEKlVTZMLBHV5aoBQJ11yggclxcM8RlPpClTQTGEkzYT2pUmWm7kIBi+NxDGpa8XrwcgZhj/Huak55QrA9l0OjbXw7PJnEXa6y62nTxH93duIDbW24qMlbDzgoTKqSeZbX18Fd8ta9ZZMpV8vjUCzHKoSDoGoMAvSOe2/v1R0y3je/CXlaekRa66JIyQoKlGBckXCe2uDpsEwK1oCwZ5BiYSuQLlAMmTnfg/OlBQus3w146E+zvQLsRH54pAaJ8Tr87MUCSF4FNZlBjze4MEnKsiTh+JqaKQuHGkWBDOBTc+diYzaL3/T3e97v1TQsisc9A5rjPnYzaZo+K4oeUrUiDN5ZZK2MYZ1dK9Eq1eQ46Pbi3xmAc4QgbZrIEeIRDofP8W50ME2xbiSH+qSERbEYkvYEM5zzXtdUWeFQfajSZAEYqTBHYf97HKzEvXjEn1dEiQQ1oOxlkMdhb5WhSqoCSIp1X/AeUSWgAV6sI4343AwK0QQobQjJcQi/4SptoOj+lGGPF849F1NLVlaHpXYVSDluILFoEmZGRb6rpiKPQ9geyZKEVBxIM7Ubgrxi7sWb8xevqpwctfYorJoRtUtTOlXVlnGEQ7OqFhtsnVpbC8IkTMeK96EEYyKKaEvpQDKxAu4btj6bkuVQ4RBVKLTBFIx0BJGGUqK+HDGL44cqA9WMvO7kaOcunq5wqItL+N57Q1yWHIJyHKbcxyEgVKnaHjy6q6gHXHOg4fI8UFdIrPvMaVyPA9A/4RcODnlK0VUoeKIE2Hl3QSyG/1y0CIvjcfQ7ZYApxbZcDtdv2wYZwPxYDMvicaxOJn15jLxKhTyPAyoUDjFOdTeexwEV5iaKcqwCAQCT+ptBza2z3cqul52qCoRSJFSgkXpvNyVhTV6DE1ayaV6neFP3Bn6vSCQQsy3hvIf+nPp6vM1uBHNRUxNOsZvW5A2KRj2BroIMfcQyF1BmPcQTImyokmxv9+XJSfRoGppVFR9ob8cN3d2+7/KoVRTsyufxu4EBbvO3rkIBi+Jxz74UCIHKVIsY5nx3qpWVeN9iB3NFBkjAyqiS8IFyVZXcFpwJ00RMlothXU540pCmFf82ASxp9C9Ohyas+NMxw0BSUWBQinEmhCgVC/eAxFUJsSmUfnQnaodRbABXZTiUQ1E4lLHIxzjCAaaEoLzQoBwHnnDglQl1UBUJ1E4uZKsxwSUi3R6XaEsOzWdZmcf9mMBLkwqiKr+F60x5HIjrzie2ddOJkuFdyZq4hHicoP7tnVDi1sMwsb4ZjTUtxW0EUubZrOEJhwo8Ds7f9ZyLKtmW//qQNS61PQ6T9r8Xx/0f/od585AlBCalODqVws96vRniumIACgFMCfpYzCMc3JSzsjrPJNG8D6cUJYiqlkGh3DjCUuc6HGcBNp18sKkyW6sqscUsHNHtLLQN6hVarJeOHUc1g2Jnv/den9/k3Sc2tJgVcnWKgogs+5KInZAqR7hmTBPfWrIEP+rpwXo7V1AGsDLhf3A+OXcusqaJ19Jp3D40VHy9EudVR6P/tbq4a+xwvV6JECEuT0o59uTzyJgmGghBrMoeT28lQjgIqoZwPA5z6mUozPSr2St1altaGhjhIMetx3gkTbE1k8dL+TG8oU16PnOYqwwbu1C+uLERx9fWYks2CwKgPRrFiXay1GSeonecYKt7TmNyMNxWia3ZLL7b1QUZQFyW0RiJ4GuLFlnWQUXBt5YsQb+moTkS8SUVhlGjKFgYi0EJSCbusi15JiMcUi7hkHPF/LuZqiWNN4ixFpowcVCJxyEsOToR8VYrmTBNJCn1CQdfqVdFQmuNVOxuDACDk1Ys+oRpop1S5EzTtyCriQFh1fim4nEAgH2cBTaP/e1xiLmEw+iLHYBMLQGhUBjZCGSVP11WmuMQU8PDrCKKNeHHVL5wKFaVch1//fEDns88Pz6OVYHCYWY8DsUwCHsid1eMCbqSjSsnIMVLz3vdMcOoT7aEfgcBQuThkRHcOTSEWlVForUdGPMu2oM8BTyPwzkNDXhmfBzbXHlSPI9DzhWC6ODuO7OcWXTJ9jha4xp/WO/no+lhzL3SW02JRznDhlNVieje/ZMjBBFFwu58PvS55eEOVXKuj5MPVmmn35lgpnMcggTHdIUDm+MA+55xYMPk2HG9YAK7Br3XeUlb+D6wYXZOARGT8XSw948iSUgqCr4wfz7uGBrCAyMjWBiLIcEpydoSiQCRiK9RWyUL8aVtVg+YrT3Wv09fCcSifI9DRcKhQo+DSSmu3LzZ89pPGusxt+w333qEcBBUjUmBnoKGxtMHrLrbFNjVrkDGPM/nNGfYkSjiKtBgem83NWWg9sgh7IgpaNLhEw0AcJhrYvuXBQuKlTIMSnHn0BC+0dlZfP+s+np83C7p6oTZZFx+bjZ52x0HOWIYWOty2TfbFj1nSFIkCXNjlr84qOkZjxrbmvKVhQsxYhh4YGQED7tyNbps16x7vcUOrEEWVUc4TFaQ8OUhIDHNTdgcW4nHISxUyd0FVbf7Zjj7pBESaKk0KEV7nVc4DE9aPiJqC5ACIcgwwiEVL1MqVCkvHHi9LXhNEHlMN8ch4s5x4G3fVbVpcCiBSK0GKBSSQhBtzEMJqHUemOMw6r0/4mp4SVRFtibGWEQCOAnjTpO+0vFTT2gKAKzLZHBUUKjSDOc4OJeNcN5jibXmwHa7cERv0GIga5p4eHQUEUnCMTWWGBrUNPx+YAAEQEbToK4YBLYv8HyvnMeBDWGoYa6rHLOOzJ3jkDNNxCQJg7qO9ZkMBjUNLfaCanUqhZSi4J1NTbjfLo95fkODb7tTyaNCmUXVI6Oj2NuWQWqVjvgcb+KOHDGhyNY4X43HQVW8nY09oWlTzAebKskyz2q1yLKERATIsWVPQ4TDkK6D2hZ9x2ufYZ6VYnlv1+seIxVT0YsNe9QMYKfXBoClbeHnOakomBOJoEApdJeRTGMEMiscHAErSxKuam3Fu5qbMV5m7mP7rFSy0JckCd/5gIy711gelstPkjzPetUehxDvm1vQ8oT2FBzhbwlCOAiqRjOAYc1E8/zSgL8XQE1svqfEpEkpDHtBIcuSr4IHANSuHsUoAI02c39rRSKBsRxBVJEQVyVElJIJKsmYozyWOfvvrFs4MDkObos9a72PhiQKl0uGcuMMipIkoTkSwRImNMDxOLgHjTwzuActi3RC0FUoYELXUV+F94G3PcLkVkzX4xA24bubUznem7x9r7DH7sagFB11Et5wRYkNu7TmmGEAlCLNBEXXxCW7jCn/HMVUKbADNQBceayK/74sjqe3Z3wVRCohHpGgETLlMAVHhFnx0ZyFucvjEGvJoenMUmiJMRlBvTIfp9bU4sXRtCcJNShUSWdmuXgk/PxEFFs4BMwmbKiVnOBP9lNpAEeZmO0wHGNCseSkaxtBLGoBtge8zRMOJqX40Nat2G0XeLisuRlXt7biuYkJz3Nn1OStIgO0dGzlqiqxv5ZihYMdquT2OGQJQR2ANzIZfHn37uLrHdEovrN0KQDgmrY2nFJXB0IplnJCl1iPQ6WEeRzWptPorsuh/hh/VRwpSiC7chwqpTZWGq/ZazrVfDDYoq9BVcs2EXMTdC+7PQ7VekF4OWdBHd1zpolBO7x1SNcxPxpFXFECqxm5nyF38rL70wSAyowDe4aJz8Pr5AYFcWFjIy5s9McDGczv8jwObuKyjDgnv8ENe+9WGvpTE5fwgbP83itMwePg3IuESaQmlFrhX/ZrvGszWxfoohyroGr6M4rvgVEgoZ4Th6lRgoTduZYXl+vQqvAHAE2TMDBB0TVKfMmo7M3rfbit/2dCQpU8wiGkRT27Buatib+xeDF3/9nOlvNi3iy3QV1H3o4nhktsuQla2KQJwaRpWhUoqljPBn3UbbkNEw6VzJ9hoUruCiHuKltZOyE6CMvj4P3xYVdeZ54Q5Cn1exxiCFzUwg6xCX0/IiEZDZ6kyxFRLY9W2OI7jErKscL2DLDiWFIIDovU4EcrVkB+eZHnPVmlFVXIioWUUgUAxQ5VCmqix3ocSC6Ckec7PJ+pUZTA74d5O6oN16P2ZA33hB7y+SOavM9rwvX086yImzKZomgAgHuHh7E9lyslfbpQUl7zMZtHsjmTwTc6O/GNvXvRXSj49rOGeRCLoUqMx4FwykayY9iSeBzLEgnuQracpb4wyE+qCFtUjYRYiuUIKebqBDjLuKQ4idEOU80Hgx1rvyefDzVqsASVQHaeYZ0Qy9BRBTwPJy/3iFKKXuZ+69K0YultliwhnjmhECAcQKnP47CplylEEQPa68OPIwjW4+Drdj6FbbJiY8p5gQEeh0quIGH+794Xk/k3y1vpJauG2SpoBLOY7nHZZ3WWJeDl/Bj+PDEEAgoTFIvVJK6tnYtUXEYGwD/u3Bm4zYSkoFZSMUlLj2JClnHnwLD9gFEsMGN4Z02D6ze9O+FxJ1YQquSpLsE8tO4HVpYkzyDG8ziw1j+HGkVBVJKK258XjfpKMXYXClhhh2RpnNJtlUxXuRmo2qBRCiejJFQ4VJLjUEGoksbkbmQICQ07MSjFnFrvjw+5wpYMk4JSf1+Qmnh4WFFUDQ+tshrESXYlqOonHkUhSJtAfCodrdzlWCtIjqZ5VjjYIUQAIlT2hd1IEQKqha/O4mU8MhE7VClogR9jPA4AYKS9B5MxzcDqT2Fx4ZXmNzgQTqhS2BbizOJ8pat7G+85GueEMf6qr8+3HQBQUzrMdEkN1ro8BRnTxA3d3cXQkn/bswc/W7HC831fqFJROFj/1gmxqkdxRA67oAojzONATQljL89B7ZHDSC72hpoGLdIopaH19OWIWSwrXI3Hwd0fg/3lqeaDOY3RYHtH2evo5Muw5zOoBLJzL/domi/3hLVI+/fF/xqv/9i4aXKfCzbev9zr4CTmlwsdW9JWQTlvF1uyWeiEWCHIlOIIO3wOIaFKgftKKfYWCticyeCchgakFMUfqjTFfJeZ8ji4F07sd3n36BSap78lCOEgqJqeSdnXBUyWJExSA11mydpWL0fQ0mAtbDJGeG5AFDJOiTfgsVypAkK7EsMTuVIS3tGkFheZ9cUGQ+yjz/U4VJjjwD60brc0O3fxhpygYahGUVCjKEULW1SW0RaJoN9VJam7UMCyRMKapBjrDypMrOI1hApiuh6HipKjQ4WD9f9BplJUxjRDB2Inx8GNO1Qpp1vHxrrOUzHvfcBi9XEIPihHVIT1MghDUih0CigBC+NyODXtyyVHx6MANZm7VbEqmiFAOMgRgo6Uiq7R4H0r53FQXcnR3O9zcjycUswOFIChmly7YthvV1sxh7q74jL/LxCCN7NZtEYixXwm1qDg9kTyRjPeYvljc+Z4crEclBodsKszR5pzeFXJoH9QRkKW8Wo67YlHX5/J+MaBhfE45mu12NopgxQU6BPWDeKEKjkhJ7zOtUHCQbIXK+5lfViIDjUlmNkIxl6Zg8aIgsK8UkfgoGc5y4TG+PYh6ngcpKpyHNwlS3mhSlOBV7rUoV/TMGIYaFFVtDIhM6rCvy/zkoGcRpElxCdChg3DComqYlHLu9+qtaqH5uwxlvZyHqCl7dWNkf+zb5/n2vzT/PnoKhSwLB73GcyC7llKKX7U04MNmUzxni9QilNra7leHTKFBfl0cxzAGS8MRsDwrptaUbvVtx4hHARV0zOp+EIcFGZSBayFkqoSmJBBOSE4bkxNxinJBhBK0UsKODJSg16zgD26t7tyTgdq7aeetc68MjmJT2zfDtke7y5JtiOTdxWVDglVYieFKONxcA+gPKsQoRQf7+jwlS5khQPsmtRu4VBMkHbFa7utT5UsjfJ2/e1KCNqee5K0BjT+9iryOJQJVSoQ4glTQgWTu0Ep5tR5h/whl3DIaBSy5BcJNXFgnN9gFLBDYcJClRxRESYcYqqVG8DtfaFYiyBSpkla8O9b/6+kqhJ7ySSllHsQlSWkvUYvSCpBfdIK+WITLx3iqhTqkXEWd8HCwRY+LgFACgoYA5xV5hP+gwwVDsFvcSGuUCV3CIFOCL62Zw+6NA0SgM/MnYuT6+p8IYzuRTRP0LP38JxoFHFZ9lmA5xVqMTRWWulGGgtYa45ibUixIufydBcKuG94GA2qig4ljg0DCvJdpXa3TnK0s4jieRyCrLeK3V3aPVaHLRLcoXHJiOTpuRB0bcLClGCLWdl+ZpQqPA4pTkUlhykLh5D+A46lnhfCJAectGFTg0T447pBCAY0zRfOGgbvTFZ7pJVWB6OcUCWWpWUqKrGokuS5Nv/b1VX8m82JDBS7koQJ0/TkZtw5NIQ7XWVY3ZiUVuVxwzQ9DsQ1p7sxACiu13hGkCnW09jvCOEgqJq+tAyJmYokSSpWbii+JlsPh06IVf4wZJtGXoGSknBmotQBciDntY9u1zN4bTKNFlOGIkncAdtdKtWk1JMcTXQZc+Q4aqJWCIJ7f8NCldg1E28uMwG0MX7juCxDlSQkZBmya/A5sbYW7dEo5kWjmB+LFScKw+UF8dSYr8QdalfDYMMXgj7L4y3zOET93oZK4HkcRjOASSgUWUJOo5BljschLiEWCT6HUTU4Ph+uBXGYcKiJA1kNyHHCiK14ZwnmNIUDbwEdU0tClqY0tF64z/O+JAGKHW8dVWTow1Y8B9FlUF0GNSUoinVe9wwHCEWFYtDUocpW80ff8SnOcfLPTyk52vU+lUAKSrE/AgBoMt/yGdb/oto650GhShsymaKApwD+NDRkCYeQcaESj0NUkrCHaR7ZoKo4cbQDa1znO6g0rsNFjY14z6ZNUOwKSUUUoO5o1SMcHI9DzlUHv1KPg8oxlByRSuHz0Wixk++jYyWvgtuLm4hIGHVtK+jajJR59qVIqX9DVaFKrvX2dHIcMqbJrfTjFn/EZeTheXvVgIplbgszO64TO+er3jQrGscR1ItoGvkcLGzlsXL5bdV6HCKShFzAe6y3IOyM8BrDBWFQyjFPhMOGbDlU43HwCQfG49CgqvjSggUY1nXEZdkSODq/R8qBRggHQdUMpmWAmeQVpj44XINa1pX8y4OaEoYnJERlK7HKsTLJjJtOA8UvhrsB2yp3VEhXUthud7f12UxH8c2WVVjQTpBQFE+MqS852vUeGw/Jm3QJpb5Y0RpbOMiShKgkFSeYs+r52WOmK57WXWO+0uKvWUKQpBQTpsmtYFUk4FoUbK+FJEn7NcchGZOq6oXhYHkcvD9OqVWStSFlWfwlAl9ydE0svNxqVJXKJk+jTGOtGrvkK084RJ2k4IDwhXKEeRzcHbHVAHGkOB4HBRh6YoHv/Uib3e01wNotKVYiZ1QFDM7xOc9r0DnmeRxgex3cwiEvBQiHEI9DtcKBlxxNKfWUYgaAPk1DhtOt3e2J5HkceJVg9uS9N+TiWMznmQqqcOVwVCqFh0ZHue+RvPfE18UlUEqLC11eA6qg2112dXB3WBSP4+2NjeguFLAgFvMKB5fHoYbpihy0WA/Lb4Cdq+FoxaBxhNfZPuk21LOLtApD2gw7/6IoHJhEYd2uguMWEYZ9T7nnBTkgOdoNu0fOv3Mc4RAUrhrUxHSmcG+LV46VpVwPBwB4cmwME4aBqCz7vM5hhHkJVrv6PZVjKk3VKCMaHapJjuaFKrmvcq2q4qrWVnQVCmiPRqFQiv5uf4jjbEAIB0HVaKZkh1+UkCQJMebBLi6Cy1h8iCbjF49a313UCnzhMmsRUs6dWC4W1DD99fsbk5IlBJj9ma7H4eHRUbREIji3vh4L43EkZdlzTlRZBsoMkp5QJdfrlVqQxg0D44RA5bh53YRNoQVKEZ8B4aDYaTC8PQ+qcV4Og1I0JSWf5bt7BIjai2ZC/KFKqbh3gc0SUyoLVaoN8Tik4sGhPs62w/YhjJJw8J9R96I6qJLLc/kR3LU3j/HFJurqAW04jvy+koU6qgLREFHkJFdHVcurwhIpE6rkJE1HVUCOGdYimUq+Ltf5gGk4rByrexJ/cWICz4+PY2E8jsubmz3iv0AIDHsBzZZjJXY3ZZZtuZwvPGXEMIpli3nPES+h0ycc4nGkmGo4coCFGgAaVTU0fEXSSyPUoiYJdXHvgoZwFkuKJHGfTydUyfOaLSgkjpfXnVOTZIRDoMeBEQ7aSAzGRNTygmkKiC5DPc7+7QDhsKBRwt4R7/bd95/P41BhUmzGND1N0tgQM40QRBTF12unQAiSrqTesFBNB3Zcd/7NmyUKhOC9p0i4/WX7OzLBmccbmDQUdDD5FTMpHNzzJKW0WCaXx5wGb2WrIB4fHfV54SohbL5fmkggxgi6IKoNbwRzTdh7Kyz0iVci3v09k/O9Gb1++wkhHARVQ+HPBlY4SXQmY5UJwt05dO8g8OoO4PTDrBKvYbA5FSya5n+/IWlN+OViYH05Di4kScLPli+HIsvoLhTwtb178bjLCveZVAqn1NVZ27HPSSUJb4bL4xDkGg1DoxRymcocKDMwaXbS3nRDlSTJSmxkewJgGsLB2jDQViuhx9W5vGuEor3R2qmC7rdEpsp4HGKqhGhIpx1nQVJTxuMwGeBzLwqHakdbO48oNFTJ9ZoSIBw25SfxYmYCaAVqWoHMrjqPcIgo4ccWVb3/Z3HCSoKsw873IipQs3oENSvGuZ/LBvjWKslx2JPP40c9VqvXdZkMIpKE97S0wKQUP+7pwcuTk2iVZXw7n0ezvdCiLsMGz/K5NZv1LZTXptMY1PXiYo2thMOOc7K9b24Wx+M4fLWE/3uQomAfQHMjQVBQwpHJpG+h6nm/XcW6lHV/ffs9cUiSBOK2lAckR8dcXlD366xhxBm7JF4VK5fHgc2bCPQ4MKFK+kgc4695TdXRkxyDC/+YFzTK2DvivWaaa0UYJOrKjcMZ04RpL9RjsuzzRGt2w7Iw4aARUizgEUaQx4FnKMpTistPlvD4Ropxw0DbBV3YldLxmZ0R/HLlSixwCcv9GaoUlqw+pyH4PTeV9l1hYUOh3aiShJXJJN7IZLjvv6upqVj9imckqARHeFYjHDxhTcx7BqWI8s7FDF6//YXo4yCoGkIBiUmOliXJNygbFQoHthzkw+ut/5cbe8vWF2cswIpsNQmSeeX6QkKVeA/JsbW1ODKVwrJEAnOY3Ab3QsIZ7MqJHDBJdt7SstXHcYcRNrE4E2J45+jKBt6ghSZrmawGAqCj3vv9/gkgq1vHxAsVqomX8yiUCWWyb8Rw4SAFehSi7uTlEJSUjmhrtigYEosm0X7pHjyRG0SfpnFDldzdpNUA4ZCjzB3BFAmIqlKx0hWPWIBwiM3JoO6YQQxHstz3S9+3PRYRGnpfdet5rqwN8zg4xolnx71i5A47MfLJsTG8PGll0A8SgtsGB33J0UHlQbfmclwp4x4reIsBN+OmiZgsY2EshkbbC7g4HkcqJuFr75WxsgM4aRmwuCNEGKRSocJhdauKO76g4P7PR3H2Cus32Cow7H7KkuQLLYVtAGIXQY5BSOZ0tXeHKrXUTM3jYOb8N44jQoMWqmyuEwDkDdfvcX67kgWrU8nKCa9l7wpHOLHnwS3AKm5IyPw7rK9IgRDMbZRw8ydkvOuKccipUnO3e5kk4P0ZqhTmSakNGR/dVNrpnSVMOCAkXCkmSfj43Lm4tq0NV7e2FgVetfByhVAm9Ckoqdr5Hm98mdrZeWsRwkFQNZT6PQ4yZyHvnkRDHy7NextmbdNbOY9DuU6erMehPmG523ku+tBQJV73aNcpYB9091451o1KPA7ungZT8Tg4lLM4hb3rTIBhp7bcoXQXCrh/eBjxRROIzclArfe6pafjcaCUor3Wu3NjGStECQHCIRkLT36Olm0AZ/0/bGKsiYctnK3/K3JwCFh8bhptF+1By7ndaLlgHyATJJeMQ0kaeCI7gn/atQvPGoP+fXfNgUEehxz1Tk9sWeKoilDhUPQ4uIRPfG4aTWf1oGbVGJ5KdGFHLlf2+CMqivX53SxRrAl/Sz6LOZfvQvO5+xCfXyqXlQi5Ns64si3nd/dkTBO39Pd7XntmYoIbqsQTDrtyOU/YioMeIupZ4dCgKLi0qQmKJGHUMFCnKGi2BcSpKyX86G9kfPv9CmhI/suRqVRoY8S7hofxld278TfbtuGViQlrP1zv8zwOMicnDQGhSkWPgyQFCodVc4GFDTJqFAWNqopmVUVdQLgke67DhENQVSVeb49USHI0AOwrFNBTKPiMRA5OOBvsPAOeAHAWvTyPg0PQ9ll4ydEIWJw6269PSlhjjnjeu5m5x/eXcKCUhlZXq4lXZhCassdBkkJDZI4MyHk8ta5uRoqa8iIVUCb0yX2NeUYG3lw9+/0N+yFUyTRN9PT2Y2JiArl8HkesPgwJTht7wcELL1SprMchZHtEYxPB7G2WedzLCYs843FoTJYmwHJ1vt2TKm/RL0tScYDnxQ+z2wkSOXlC0FMoIEOIJ9k7qFNlJZT7fGiOg+NxCPlMuRKJO3I53Do4iNixQMyOYR56bGHx/WTl1QZ9EMCXID3m8k6zMfjJqLVgD6uqFK+wj0OoxyGkO7Xb0xCL8MVNauUYJPt3oo0F1B09jFirN3hlCWccdd+aQcKBTdr3CgeKiCohVUmoklL6TsNJ/Z7ffnp8HFGV31q7JByoz1OZ3tqAj57Wjp+kd6NH0yBHCWKteeT2lO7SII8DdSX91nGsiI9wkolzhBQncOp6fnn13k0A5zQ0YCsjSvSQZ5NdNMZkGWsmJ4vdpOfFYrilvx8Duo5+TcNZ9fV4T0tLqDB4ZHQU9w+H1GkFsNeOGR+2j4P1OPiMGwEhG7xQpagrVIkN3Tq8TcURZyu47FSKZKwBb2toQIQpscnCCgeS81+7kseBnykVU4F3HaXivjdK27r8RFepXM7vUtsDVKso3PHY3c8gRwhSnGtSsMuK+zwRTjU8SrlNAHkEhSoFeRwqZUYt1sx9FOZxCBsf3VQqHBpUFR9qa8OgrqNACE6rr4cqSYHRC0vicZxRV4fnbfEcl2WcVFODLy9YUHGBkTAopdxF/VQ8Ds7Yxdsvjl121jFjwmHL1m14+pkX8Oa27TCM0un4yr98Dok5pTvqtXUbsGfvPlxy0QWIV1GveCrs2r0Hv/7dbRgathT6B669CqedcmLod3bs3I3v//CnVf1OS0szvv7Vfw79TG9fP156ZS22vLkNY+PjKBQ01Nak0NExB8cfexROPvF4KFN0ob3VEApfHweZsziuNFTJneMAuxJSJm8t+MKQafj7m5iCBI0J4Kc9PcVqKRKA6+fMQXs06nOfusWCyhyX869yHgfFFffLio9t2Sx+2tuLQV0HtQfJG5cvL74f5uIsR7lPh72v29bJMK9COY8DO3Gyzb4S0wxVYsMU3D0a2EW5syAuG6oU2jna+r1kGY9DYKiS67djKl84mFnvDtasHPP+W1FwfG2NdfUkCkkloLriiciQAyqesMIhuWgCskoQaShArdOg9i1FTSxYDTrH5RxHrD0LOea969dMTOAcZQ7/+/b5U1T/jEiJBEkh6NO8J0UfL7mlgnIc3Is3tkrXh9vb8RpTKQl253ZeqNJn583DqGHgpr4+z+eHdB2NqupZ7FbjcYjKMj4zbx42ZzKoV1W8ODHhqY7UYx83Kxzcv3lPGdHgZoInHKrxOHBCEXfk8/jSli3QCPHUygeApY0K3rtUgRozi98v93Szx8oajlBB3kwiIuFfL4piKE2wZ4TiylOBuU2lXw7zurLjdZ4QZE3Tc401Sn3HCvv68kQesb0Rw4ZRcc+IoORoXilZ0/U3y3uam9kNV/T7lcDmOIRVy6tYOFQogk6vq8OH58zB7lwOkCQsicfRmc+HHt/fd3TgXc3NkAB0RKNIKgpao1H0a5xBt0rMgHs7VDgEVWNyVTxzeHZ8HF/bsweyJCEuy1gQjeLfg5r3HGCmLRwIIfj9rbfj5TWvVfT519ZtwLr1G7Fx0xZ85pMfQ2NDhRk1VWCaJv7y0KN49PGnPUlilZDjuLyny4MPP4YHH3kCJjO5jY6NY3RsHJu3bMWTTz+Pj13/AbS1tsz47880lPoXjzOZ4wAAvWPAoAwgrBRjmfIIewa8+9OQlHBLf79nYH93Swvao1EcnkwibZrFGNdFLlHLHhc73fomZfvz7onZseQ5d2ONomDAlSQ4ZhhIu8rwTcfj4OxTpbkILAVCfMLQTbmqShOsRTHvvb7JEOt/OSilmFPnD1VyyLEVlezLGA25j8qFKjkL5jCrfGiokuu3g/Yj351CcvEk/00ASVnGs9kRtFwwiWiTdZC5rhTIvo7iZ2SFclVhhhkDlYSJ1PJSToCe0JCKJwIlJZscnVo15vuMJEmB1kjne6pK/aFKFBiF5l8sTZSevyCPg/u5Y+Pm84RwEyV1l5ei+IxJEo6tqQEAdBUKeNhe2CftWurs8+9e+JQTDopt+Ty+1kpG38kkSg84woGZGz45dy5+3ddX7C1RKY5oZ6vAsOc3KElUsasnuYlIks8j8zdz5kABsFhNISJLxTtHtkNBgzA5jUCp4RcwkWJ4H387MRVY3Czjzo+n0Jc1MArNW8EmZB/Y9wY1DWnOOoEdxxwmA14fNgyu5yqIQI8Dc37c3oYBzv3wN3O8gn1/hCo553a6HgeDUxo4CMfTRYFi6fSgxoUOkiRhvmvuZo1802HaHgfX3wbntRwhHqOb1Vn8EBUOt91+t0c01KRSWDB/LrZs3c79fG+vFY83MDiEm371e/zT5z413V3w0NfXj1t+dxv2dXUDAGRZrko8ZHOlgf3C887GyScdX/Y7akjpy4cefQL3P/goACAej+Hss07HqhXLEY/HMTQ8jBdeWoM3t25Hd08vbvzpTfjiP34KtbU1Fe/vgYBSy4pcGEgAEsWqdhkrEtEp5zhIHEtp7yiwJSMBy4L3I7+vFgOv1Nj7JKH94r2+/XTTkJB8bnQntOB9bW14X1sbhnUdzUyys8os+iVJwpCuQyMEg5rms7A7gxU7Mbt7ObRHoz63a1ehgMPsBK+wChuVQAISmCrxXuSn6XFgK9Qkl0xicnMzzIx1XuMVlOwLolqPQ00FHoeYYi2WIgFVoJzvxqM0sMSs5XEIDqtwYHsZOOT7UpBMOTDWfUDXcefIEKKl/ohIzM9AH88CsCp4yQrlxgSWa36VixaQivHDjMAkR6v1BcTn+BstTZomqBrewE1VOPcVlTBIvGrPSKuexWSQx8EZU0xqVZpx83hAzwPPop/5PwCcVleHOdEoDkskMC8WgyxJWDPpFXTu8YM94qtbW3FuQwP25vPIUYpaxovczowtA7oOyrFuJ2S5bA4Xj/GAUCV2/JUdsceMh7xQpSRnP86pr0dbNIqYqWIwrxc7RpfzmeuUYmEshjwhyBkGxjWAGBJqDh+xPFlRE1KE4Pl8I65Bc2BytPueUBUKmJXnhQXlFrAEvR7Ug6Ya0cDbPg143S0cehnhUKcovmTfmQxVYvdpuh6HahKjnWRoWlxEly/RzjKTIT9Bex7ao6oKj4OvlPM09nV/M61969zXjedffAUA0NzchKuvuAyrD18FSZLw6c99ifudL33xs/jdH/+Mta+tx57OfVi3YSOOPfrI6exGkWeffwl33H0fdN2ALMu4+O3nY2BoCGtefb3ibWSzJY9DW1sL5nbw3e+V0N8/iL/YoiGVSuILn/0k2ttai+8vWjgfJxx3DO646z488fRzGB4ewd33PYgPXnfVlH/zrYBAgjaUwPBT8wEAn7w+gfOXqtjKdG6sxONATSCzw98QrXcU2DogoTlEOLzwhgJjwjWSsf0lmFCmppTfK8LGWwYNNO6mPzKA67ZsKcYTsziDGzvIuXs5KJKEudEoOl31rD3CIaTCRiW4G8h5Xq/gu5bHgf+eUqOhp20c3+0yUCAEHdEo3tva6lkgsYs4AJDjRlE4TDc5ms1xSOeBzkHgrleALV32ixJFrD0LqZ2gQOqKvQh4uENx+MLBtnxJQG0CmOA4JWsTEmIBOQZuT0RjCtg7ZCUJp5aPQa3RkdlZD2M8htrJGkw0TFRwFkoYdbmicJAY4WCkI6hZtwCHvaMf6wLKFAJAJlqoKDk6FpGQmO8P/3HIRgqwslrY79vPjUp9nixKJPQbjHAYd7ZhRfsGdY52Juwxw/Dd10MBz6bGLKitnym9tjyRwPKEV0SxY0ZYqFJrNIrWaBQxWebGcjcxwmHSNJElxPecJ2W5okpsLM6z576NKaX4QHs73tHYiCFdx7xYrLjtGCMcZEY4KK5FmxuDUkQlCYpshagWXN8nCA6XicsyvrlkCQghGBnow3W/bAchgFqrIdZWerAy1DqOoHKsMdc9IcnwCYcwgwv7TrWmmf1R9Sas3r977mSFQ0c06vfg7If9crYZVn2ukuToahKjbxscxCfmzvUIh3IeBxZJkvCFnTvRr2nI2436Pjpnju8Zr4Qgj0No/qbrb/czWYlwmIrh4K1iWnv24strAAA1NSl84bOfwBGrDyvbYCWiqvjw+9+H9nZrAf3a6xumswsenn72Bei6geamRnzuM3+PSy66ALJU3SG6Q5USU7i53Dz06BNFb8d7LrvUIxrcXH7ZJWhtseIUX3n1tWJOxmyFffad0BV2gnWXL+MJh/SbjRh6fAHMrN+k2DdqeRHC6Bryvu/7CebfF61WfQ9jpfGo7mOTON1V3cgBwoFdCLBNnbpcIiKswkYlVGtFc5MxTX44kkzQcm4XhhrG8Ho6jc3ZLB4fG8NP7fr5Drya+G6v0nSEAwHQUe9/pr95p0s0AKg7dhDNb+vB8NI+3NjTg0hIx1On3GpgHwL7dZNSnLjMf2JqYsDq+fwwpKjq7TzeXGv9XXvEMOqPHUJq+Thaz9+HWMJES6bWvwHbuhuIa3fYhmrGRAQxEvGNyWbWe6CTkUJ4crRLWE1uakbP7cvQf/9i3+cyKj+sxhmCievvIhTo1b3fi8/LYM4VO6DWW6+Xy3Eo14kYAE6vrcU5sSguaWws/XSF4jxszAj6btDdxmvMyOZ3wPY48HIQ3JxeV4cLmVBf59ljPQ4JWUaDqqIpEkF7NIpGW8Cwv6Ey41ZEkrgLGJ1SRGQZiuxd3JcLVWJxFqJsnlvBLiEcGKrkuid4Ft+waxpUBnV/s7Sdsy+ce5AdPd3/7mHulbmunJ0iM3g8vlClt9DjAAB5+36OB8yp5ZAAbMpmsSWXw+58Hp2FArdSWiWYAffVVJKj2Twr8ITDFEON3wqm5XHYsXM3AODss05HXS1/0uMhyzLOOuM03H7nvcWQopnixOOPxTVXXT7lRX92hoSDYRjYsHFTcTsnnnBs4GcVRcHpp56Ee+5/CIQQrFv/Bi447+wp//b+Jkg41Koqzq2vh253VlWlUuxrWySCq1tbizGuUUnCDRsafdt26B0DlKRkdRMlgBLjPLJMWUlf4qX94zUx4AdXxXHqEgXRTYz1sMKBLCLLxZqfchnFXUyO5sQKu5nPdPx0TwphFTYqIfB7FUwqWkCoUrSpACXhH3TfzGZBKMWb2SwSisL1OEiuEJx4FAi2f4dDADTGJRy3QMbr+/hHKccMTwz/6+k0LqrLc63hCOlT4OC8blCKz18qoa2OYmMXkJRkdDTIuPZ0CYko4Xoc2BCpZnuYrD28FEojqRSpJRNo1RuxPa9AiZfOMemuxUnza/HUOL9pmpR23UOMcHCqJ/maWI3EkUiWrsC4UkAiGiKsnD4MzrEQGWZWRq4rhcT80nYmlIB4fMVKziXwF1VILh3HhizHQ6VSyHbCbTzgujiT7wjTUEwBcGZ9PZ4ZHwcF8MG2NlzY0ICRgT60trT4wi/CnrGuQsG3fT0kx8Eh6GzWyDIUZjHIWpEBIKEooR6HdzU3432trVb/ClfzyaLHgeMV4e2TWzhIKIlcZx9VWeYuYJxmapJsC29qCbjnxsehEYIcIZAlCRc3Nfm+6/l9uxs5m+eWt0sIB4UquZ8rgzlWCcBTY2PYlc/jxJoaLGCqkU3X41Apn3+nhO/dX9r6p9/hnzWckFKemHGuhfse83kcYrHAXIlKIZTi1sFBvDg+jrmShE80GWhwmiQy2wxrAFcTB16YmMDjo6OYG43i2rY2XxhVpYY6B2etIE1DOLD371QrLE0lxyGoHKvBEQ7sOF2td+WtZFrCYXzccqsvX7qk6u/OnWPJ77Hx6lzzYVx1xWVYtXJ5BZ8MxuNxmEYZ2V279yKftyzIy5YsQiQkDwIAVq4o7femLVtntXDwl/az/t8aieBrixd7LOcObdEoLmOqP9wQ8giPpgGkE8jdZcUqqfUFtL2jVCZJAmfEZxN6bY/F/14Rx6VHWiaqsLCDMNzfkyUpdAAL8jikFAVwLUJambAFd4xspdbQIIKsaJVuj+dxkFQCsyD7RJxOKW7o7sZaThWb4nddFv9YBMhMcfR2jusjp0bx+j5+r91Ye9YnfDbm0mWFQ5A1zQmVMQEkYxL+7gIFOwdMLFDjmFsvwYjqGDP5eRSsF6K5lnOfAog055GkEtJbG1F/jNXQiRRkyLubMf9t/B0bfGw+FkVdxg028ZhIoNR/j+sjcc+C35AIcooeOB14+jC4MCajcEvACdn/3Fv7VaqPz5ZjVWuCvQVy1LpJ5IBsfGfCZj0OyxIJ/G1HBy5pasJDIyM4z2WVN11FA5x7aULXYQRM1F/Zvds3SoXlOBQJeP4kSUKDqnrCHEcNA/NjMeRM0yoXaxtewiyOTv5UPbMwC0qOdv7PbtGdh6UwfzuJ4TwBo1NqVVCSJcvjYFpJxj/t7S1+Ji7LZYVDJMDjkLc9DkGhSm6R7xFJAH7b348bbS/onUNDOKe+Hle1thb7SlSa4zBdLj5WQrYAbNpHccZhEo5eSPHIyCjezOVwfE0NzqirK4aU8vbJubJF4Ucpepi5dW406q/OVOV+vpHJ4IERK8phFMCDo6O4tr29+JtwnSNFlqBIgMn5kayq4Sc9PaB288SILOND7V43Cy9U6fbDDy8WAfjHnTs9771z0yZ0RKOISRI+0N6Oi8rcTyxyFR3Ny0ECzm2lHge4ipawwl7mlDA+ZD0OBfsmTiSqX2DH7UV5tVWPwpiuaACT4zCV43Lo6S2V9Zs/f27Zz8+f11HsL9DT01f28weSII8DKkiOmypsGIZVitX7YE1ubsIxi4ENndbizCkD2pzyut7dVBpz6REOZbonO+eAfbhisoy4LBdrobNhC+4F0HRDlYIWNK9OTuLmvj40RSK4islNcMM7vEJfCv33LMOFZxSwaV5JxBEgVDTAJRySUWvbnfk87hoagirLeK9d2YplSNexKZPBnnwecUXBJU1NRbF12dEq/u1+fr5BjJO8uyGbgSw1F3uEOMiSUys+3OPATjZOyI0sl64VL1SJFRMttVa+B4vSkcbTdDtqmqwNT2xsQn5fLebHI2gKWD3pI3GccbbrQnE8DoQjHIxMBCbj2ejSCohHVF/vE/cxsCVrjQnvNRuTAjwOMi3tQxWRo47HIYgg4dBkP1fzYjH8TYdVdYo3zzivfHXvXuzO51GnKGhQVVzT1oajUqnAzq5hOQ4OYU8tKxySsoz/t6RkfHMWa2Gdcp3FfD0zhvCSo4sLS86+uj0O7i3JkgTY1l5eqJLhsognVGvAYRdoYQuq4u8HCAen23mgx8GVs8Q2u3vC5YGhAJ4cH8fmbBb/vXgxEorylnkcFFnC1adJwGnWv+8aGip2NH9lchKDuo4vzLfyBHkLTEfIOffgpKvqn8PPe3txx9AQ/nz44cXrUW3o1Z8GvY0l/+IWDs6Lrm1GVMDkjBOPZIY85/KR0VGfcGD7UdQqChbH48hzSgY7OF6WSdOsfsFqRz64qeS+5BGUuxM2SrHHNKjraGfyUkx7WPQlRx+qwiGZSmJyMo3JyfBFA49hW+GmktPLI5hpcq6qSoqi4JnnXsT6Nzahu6cX2WwOkYiKxoYGrFi+FGedcWpg8nT/QOlhbGosX3JWVVXU1tZgYmIS6UwG6UwGNQGdEA807OLL04Sqipv9w2dL+PXTFT7EjKVSggRJJVAShvWeBOS7apDNxTC52/vVlhqXcAiIV/7Ovn0YMQxQSlGjKLiytRWHu1rYu78nlxFIQR4H2J1k++zBk02UzBGCPCGIy/LMJEczjBkGPr9rV3GA0inFxzs6ON8OL7kaodWnRkmqdSSpqFVJ6rtdXcXFU5+m4T8XLfLE4j8wMoLbBgY8g/Kb2Sx+uMzyQMUjEi4+RsJtL/mPs9CXRHxuBnK0dPb2FgqI1+rITnjPuVssBC1Soqrkm2xU2Znc5eI14nkc2N4OzTUS1CTfyk4kCiVuQp+IIL3Z8s5Faywr9cpEwtMdeWJDM+oSEt5zcumcnVpXiz89HrFEtkxhTERBeV41IkEfi0FxCazdhQKSsRRHOFBXcrT3HVY4TEAHZAIQJm5edfWSCCnzy1KpcGBLsTaW8e46ONdtxE6uHjdNjJsmugsF1ASE3IFNsOYsDDRCMKTrxXrsrABgF/tsNR7nOeBZ+t/R2AiNUiy0DW+s8WHSNGEyi7BihTaOx0G1u/EajDHE2WqQx+ELu3ahWVXxLwsW4Bzbo8OOd5VYdp17iw1VcuLQA4WD63X2WHnXrV/XsSmbxYm1tQckx2FfoYC7bdHgcMfQEA5LJnFFS0uoF8Q5Pja/AXZOy4RpQrdFHqYghHihcg5sqBJszyw7TsgSsKtQvpQ9OxbFZLl4v8tM9UIWhVlMx1wFS4LgeRymLBwCQpXAhJZ5vsP8e8TuHs+G14HjcThkhUNbawsmJ9PYuPlNHH7Yyqq+65RwbW9vm84uzDjuHIfvfP9GnygyTRO9ff3o7evHs8+/hPPOOROXv+sSyMzkkE6XXPg1NZWVV62tsYSD8/3ZKhwogGhLDomF1r7enlOxZyCB69raquodcM3pEoYngO4hCWeskPD8bhOv7+Z/Vh+LWQmZMkUiRnHGUgUDbVk0nVlyjRuTEWx+1Ju0qcpAnctxxE6CTlzhcxMTnhCrM+rrvcKhmlAl+/+8z9SpKvp0HSqAVZwcmjHDwJxotGw5VkIpdufzaFRVNHC8BrzB997hYc+A9ez4eKBwCLuK5Tp2c7dnexxSMWuicltcd+fzGDGMYhncPCG4Y3DQZ8nZnsth2DDQansnLj9Bxp9eMn2Dea6zDrl9tZhz+U7Irp4RiXkZZCe8It4dPx8UqhRT/ZNNW60MTFrJm0ULcUBytJvmWkBJccx1LtyLKOf772xqwve7u0EBNEoRvGtxA867SEZdonQtVqaSyO6KQY4ZkGMmJIXCaM5gHxPeQE0J+mjMU1Z1Zy6HVAwYsYc7SSFoPLUP0bYcHtRrsJp2+I7FmIzAzKpYVR/FklQUNBPFbyX/wiWilpJ22UfCSKuB4Upu4cfDuT9OqKlBvaJg1DAwYof9hPHM+DieHBvD3GgUX12wwLfQ/N3AQOj3dU5JV4f/19npyUe5sqUF72nx9uZhF/tBnYZZI8e59fX4IGPBTTHPviMU2VClvfk8duZy0AjBqGGgJRIpFmeIyTIMQnyhSrBzHBRJ8uVlwO5bYLrGO3ahQ11hGA47czm8lk4jJkkwCxrktjQwUOPzODjlaQOrKrmeNU81JU53a4fida4iVOnNbBad+TyOralBG8crWgmEUvyyt5drmf5/nZ04pbbWd0/wkqXDFvh5Qoreo2qXxaGlazmf4fVyqInzBRuPOkVBgRDolPpKliuSFOh5UO1cB0dc1CgKCmV+U5pJ4YDgEESeKEfA/N2jaV7hYP//r8bjsPqwVdi5aw+ef/EVnHzicVi0cEFF33viqWexcdMWAMDhq6oTHPsbt3CYnExj0cIFOPXkEzB/XgdUVcXg0DDWvrYe69/YBEopHn/yWRQKGq69+grPdgquh7xcfoODux9EoVC+8c9MhnlVCiEElEpQ6wvFBNSnC8D4aArXtLRAorTi/YoowAdPl1CHKLLExI4RI3jJaidkAkA6DTw8DMTYNa9EUWDGkfoEEJFL54p9GDVCQAjxVXtQmfMrWwdvDVicWufe3aCghFjngg1xsb/foKpQbIuke6Ib0TS0qapVwYEQGPb+uTEoxTf27cPOfB5RScJn5szBAmZ/Tc73BjkTj2maXEtJWEGXqZRiK4UqSWhVZN9xd+ZyaLQXQQOFQqAlaVjTQGxra0cjxcXHUzzwGueeoRLyPTVILirV4I/M+f/svXecJEd9Nv5UdZq4u7OzefdyVM5ZQkJISFgIBEKIZMAGY4JtXmPwDxsbMPbr8GKMMcZgsAkmGExGgCUkIRSQUEZCOqXLt3e3OU6eDr8/pnq2uro6zM7e3iHu+XzuczszHaqrK3zj8y0CT3kVB10lS2MjQHFQiY2yZXn6U1eAjowNOASm0+hrGXOTrnjfSy7toLw/C6276qsO7YIXojR2/unpNP6e5Q+dkEqxQoEObNH9ByBz4gwyWxpz01UZtiQSmC7bmCg6cEyK+rQ3DHN3uYyUsbT9ZbbPIjHcMH48Vl/AHbMJ1NUUkuvKsCsKrIoKu6Jg/Icb8E9/CPR3Ejx9yMF/SaQjjdqouUHRQjhVeV8HBk+d91W3BudxCFpP6pYF23FwTiaDcwTjjHiO+3m0UsFnWRz+c+Uy1GUIWjVubtWE9U60GlJJW8S8hNl6XfqMoh5akcxp2c5SN01YwnH/PTmJb3IVqK/P5/H+NY39WgewaNsgfM0j9lwK+1+j1HdN91zHcQDbBpXM2ZplecKhdpZKnkrY6sgs8EQGTk1QHCwLlmUFrkOqstTvpmU1hS+L0dvKUGJz2CTE04+2bUvHwP2Li/gUGyvfmprC365b5/MSx8Gd8/O+wn8uLAA/mp7Ga3p7PW3in8n9+6JsFlsTCewsl/G58XHPdcqWhQzrLCvgeYIgE9RNy2rE4rO+srj1T2ZgySbkCog4Xk9KJvGvzGucUxT06HrjGLa3KhLLuwuFXY+6BCsAFMcJzVN0WC4Oj7pkHsWBxd6D7FzLtqXxvbL9WxwJ7vuVySA4SnJeFNpSHC6+8DzcevvPUKlW8YlPfRbXXH0lzj3nTGS5Rdztymq1hmd37sKdd/0cTz+7E2B5DhdfeF57T7DC0FjIECUEL77yclx2yYWe39euadReeOChR/FfX/0GHMfBPffej1NPPhEnnbi9eVydS4INKxDHgz+uboZbJQFg/OD+yGOOBByn2285rFWb7ZmpL0nvC7aNOdvBsEKlFvjFgoJ6XYVJHHRqKoD47Fw+JUMiP2Y0E+WZAxhnRkBHsL7OzM1gvFb2WS6K05MYX/QKdgumBQJgQVVgC+/nDakErkwYqDkOCrPTmKME4wHvnTgOCmyB7BAWktGZafQVFqARIKWqmLNt7Kqb+EKxhIrTKM62wC2UNcfBTZMTeGcmjbmpJUspUShqwq47VPEnr45NjEkryFr1XGDVynrJ75I+UVWxI8T64yoOOqqYnpjFICHgnUtPz0xjTalh7j5QD77OnskxbGTvZcY0cdlmiu29ChwH2HHIwC1PLHnpKofSHsWB5Esgig3H4ip6w8T4wf2wHAfEzvoSqBXiYHrsAOZtGzOWdwHPqArmHYIp20LVcVAvGgC8igl1qpiZ8I6jtN7rC/Ph4XCKA7GXzjfQqIdYKxcRTNjc36hnwuGFho73ZJL44ZiGD/2kQe0q5llUHAeJdKE5/7Inee/wrclJbLKzyJ23RGZRn9cxecs6FGcnMVO1UZ5XAXgJEACgvDCNGa1xv/lH+kA1qzFXqQNzzsCHL6rjiZqJZ0wT99WW5pWrOAStcxOm6QublOFzhRIqjgMTwL45LxnH7QJblcoElIA0b7w1nUSvbWJmopGHRgBkOBNsqezNr6kVFjFjehV2VTAKTVfKzevxMIX5WqiUMTc55nlm2Sg6eOgAZoSOWRQE10qx0OzXAhvbNqWgjP901rIxa9uYZs+mBghnpZkpjBfmMWOaKFh+AWdqcrxJpQkAs8IzETYM7bpXvLPY2lQtppp1Sjx9MTuGcdq43xS3XhiCQYLHzOICZswaapRA5ZS36YD15lPcWCnZNu4aO4wXGK17HSYqVeQIwWxAH47OzWK8XvGsL4ZCkWbrt+f5AGyTXGf08Chs9kxBzxMEXdiD3plOYW6yoZhQ0vCSL3LrH0XeJzoaWs0nEAPA1PjhwCgEm1IQNt5m2FxWQpSA4twsxqslzJkWKo6DrKpgwbJRDjmHKBSOQPe8sLiAmZpckQtDjTZqlJQki864qkjlm0nLQjFikdIVigylmC94uQatSgnQMpg8PBp47tFCW4pDOp3Ca179Cnzxy19HrVbHd3/wY3z3Bz9uJj4DwKc/90WYpomFxYLHbUMIwWtf/QqkjrEchw994H2xjjv37DOwf/8B3HHXzwEAt91xl0dx0DjLRD2mC8/kjtNjWDb6h9fGuu5KomGdKfli4BNGAv3Da/GBvXsxWW/EXD4hFITLqSqSjI5wWzKJN/b3I5miUOsaFApsqFWAB7kTqN0Q/KiDoW4Hk0UHC890LQl+IbkWLvo6dIysXeqndHW3h9ko0dGF/v5+mNNzHjdkf28/+gUrZq1aRZYlUBqFZwCTS6TPdmKgpwc2i3M2KEV/BCuX4zjIF5/FBOflqqcz6M7loBGC/mQSSr2Ozxw4gP2STdnFs2ZDwOrq6WuGzPVoGnqEMfQS08Q/PvGE5zu9u6dpRStYFlTmBdFD6DmTkhC6kUwGO+bkFnRwdKy5bALd/UPYaB3CHk5om9J0dPc18oXshQWg6B07HYqCTkVBZ64H/YxZY6FcxkjCQpbJ6moSuIV7vOpYylPpmVBA66qiNr205iQNFf3Da1GzbaSSfoVIVwn6h9dCqddhCbScvYkEEpSiXC6j5jjoXvT3WTplNJ/LRU+Hg/FasN+G9ziI5xcsCzfPzqLELKtF28a7h4Y4T5rjUYwAgCaS6Btei975WjOV1K6oMIsq1PTSmqP12sBzANH81v9FxwEy3vFkVxqCSk9/LzqSBKWAWhk9fXl05xk17Iz/mG1Da9BnmlDm53EfZ0l1WZWC1rmZkj8JXoZdCzsDhUkROU1D3bZRldUiAXDJ0IjPQ5dPJpv9T8s7gfpSeGs224HunJd2erhQAMpLtU8KhPrGCAB0zs4CFS5xVdPR2zfoqQSdoRQQlKHcwDAsYc/Rp6aAypIymMlk0T/cSMzN2TZqlQr6NK0ZLqjV69BNE/0snNKYXUBBso8NsHVysVxurKsL3tDebE+fh4CBTk0BnPKgkYYIIoYqAYDR3YPOTrmIMjjYj/5eDZbjYIZbPzs0Dc6MfB1ykil09zXa08/CtGzh/OaxjuPr1x0guE7ynqJwA/s3Z5p4rlzG/87OYienyJFUGnpfPx6bnsYz5TLmLQsXd3Tgd/v74QC+9jmOAzK/6Nn+Mr0D6E8m4QQ8TxCqto2K8Jxr8j3oZnsXBdCfSsEwTdSZxzphSLyc3X5L+j+sX4+85q8j46JH02AQgsO1GuYqFXzq8GEUQ5SAfHce/d3dqFerKFoWRlIp0Go1MNQPjLkwWd3nmZNGJuubk3GQVhTYjoOEZC3p49YAHtVqFUZE3YgeXUenqsIYHQXKS3Mjk2rIH72DI75Q+COFxZ07Yx3XdlXrs888HXCAr3/re6iwyVDhJsX0zKzvnEQigdfe8AqcdcZp7d7+qOKyF1zUVBx27d6LWq0GncVBGlw8ZL0e7T0QjzMi4nTB6mEcDdgOIHJTKISAUoqfLyz4mB9czJom3NGQ1zRQSqGpCmBSpHSCoRzxaANEcdB1TsOKXgKQBrC4pwNOWa44yBIvezuIp5/Egkd1xwGl1J+0pSi+/k0pCro0rZHEJcbzsudX2HvRKI31fnKaBnAL/bxlNc+jLHEsjtDjsOdo3pMQ3/07NM2XfFZyHPRSii+OjeG2uTmkKcUfDA+DUq/SQ1QL6S3zsMoKFiXE+gMR8b9LOQ6NONV1ySTAKQ4HqtVme8WN4MRUCn/OlL+08Iy5tIKFSuOJ1vcBXWlgjhluUlTBkK7jIBeipQqKQ0Jt9JMTELtrqI334Ej6k7jfUQrqOKwWgvdd6Rpw18ICput1XNrV1VDoshYOF4PT6x3O+mpo3vtato0fzHi9ARXHQUdTOLPgCB6HmuOAUApDCBivTyegppc2VCtbAdAJPS+3xh1URYtYo8N0lYJSAkPy/I1noBylqn8TVdk77RA8dK7HQTaPTDbe40AnRGoNlSGjKCgBzQrv4nUUST6Rya0rsuqvYjtzgkI/Y5r47vQ0UoqCJKVYn0hgfSLhS6quOQ5USkHYOweArKbhRV1djf4gBFlFafYnD/Gt8MckKIVKKVRuzdMUBQmuj4OK0SXYOSql0CR9I84bkcVOYUQLjkRx+OdDh3C2Oozk2iJq08lm5XkAMPRG+y1hHIRZnyu2jYcKBUzX63h1Xx9GDKO5boqYluzZQ4bR1p7bres4T9exv1bzKA7Plct4y3PPedjBniyVsDGZxKWdndJ7ip6VGpsndgvzApLEfADI67rnGpRSz36iq/65oWW9/ZWhFMMRhjNKKe5aWMBf7dsXq63uXNIUBSnWHkNRpCFyLhRJIUVbsqbYjtPIvaEUJ6dScmWHFTeU9S+R7A/uOZHvgx0jvolGu23vvn6MoG3FAQDOPut0bN26CXf//Bf45WNPYGx8wpcUQgjB0OAAzjj9FFx0/rnIZuMlDB/L6OnJI5lMolwuw7IszM0voK+3kQjHP19c1qn5hSXNv+MY7h9HkgnkCtJ8obQwuG49nTYWPV0B1nR7FQdfgTeBllWsLK0kLfReta9xCQeYvnMEA1nvJi2r4+A4jm9Dk1EQ5pjSAEnis8uRHsaoJEM+gGHFXZotxrYUBTF7QXaGK1jwgvmiZeFwrYbbmLegaNv4+sQECFkLLVdBZvss7IoCmrCQXNMYx09Irh2VOOh6HNJ6o21rBcX4cK2GGkvwEzezbq6PxERIQyVIGQSlqgOFAm+6DPjq3YBjA++6mmJHIuFRHLQub6iEm/BrOQ4rdCYokG4NB8nmJCawy1iV5gam8R9jDUH/1rk5fGLTJuSzBPZssOLAW1/Fyrlpybgs2bYnmMMR5k2VFV8T6VRrMwkk1y6tTZVkQ5jRe+UWy0niFb9dj4ObGxJVQC8I7iYtUgO7HgcZWklwbIUPXSMkkAY16Dq80UFUHGTrQLeqYksyiS7mvbx1bg7f5eL+X57PYz3zZiVYAbYEpehQFBCXXpLN4Q5VxfvWrMEUE3QHdL3RTmEOif0lPqFBqUcYUAiByhtcAp7d7SvCEqhFiP0h0nGq7kbi+K+/t1rFXmM3cucD87/sQfHZJSuxy6okxufrhOBPRkYwWqng+zMzqNg21hoGOlUVT5VKuIftsd+bnsYPTj7Zl1zuQiQUQEDV7+VAHF/PBHgIHi4UcHFA1XhRGXb3iFaj4WcFBSnBFEkRIquSCCoQPsjotX3ntJgA7B6rcsK7GiFQk5h0rB8/eBCPMkrxq3M5vKHfX+bbCaBnRkieVBw6dfeacdaOYwUrMxMAdGSzuObqK3HN1VeiUq1ibnYO5UoFhFAkEwnkcl3QZUTnv+bQda1ZNI4PNRrg2KJmJF4XEdVqDUUWntHZ2dFW1eojDUdSyMmdvnE3aXcy6wpBjVl78zpFUrdRZnKeKAABQO9IBVOHbTgmlc5WrZMToYmD/g7vNbpUFb2aBoUt4J2q6tP0EbBR8guQuFy5C4TSouLwgs5OrEskGuxI7J8Lhyk1cRSHRdsBnysexMYkKg4Fy8J+If55X7WKfupAzdaaykIUulQ1lB6v6XHQG7VKRgzDE0bksM16UzLpUxzEPgF3DgB0JRqKw8/K09iRLeC0a3VsShsY6kijUDZwL3ctz/jgqiLbjiMVcKnSeAcyakme5hIBrEoT+SXvQMGycOfcHPLZrmYyqG0SUKHiNK84iOGxOhMkeWG1yN7nRw8cwMB1ZR8bUdW2G5z8mndM1qaSqE4mcNX6JE7pTOKXjxnYyRjT4sD1OLiKQxArVZTi4D5tRlQcNAd/fIX85Fbqm7SqODhBikPA97UQxUEmGOU0DR9at675ebxex+PFJW9Okt3nos5OXNTZCdtx8Gd79mCyXscH9uyBQSneMjCAvKZBFQR2x63QLUAUeESPaYJ6c9AUod9u7O3FRL2OLwpJua41V6TKbN5XVBxEAw23ktamEtB7Aoo69pU8ioMrSojjIKEoeF1fH54plXCtwGb1hqefbv5dtG18Z2oKb+iTszqKlLmyZ1kuEjHHY5El/8tgUOrxirneh1ZbKFIZd0nGuFgxWTbP7WTrigMJUUhlaCoOnMc/6nwpq5JwzKFqtak0AMDNs7NShkg7ZF8NVBxCW8fOZde8tLMTeVXFvGkirSg4PZ0GCvOR5x8NrJjiwCNhGBgY8GtsPEqlMirVChKGgRRHe/nrBNu2m8I+AKS52O+R4aWib/tHD0Zea9/+A82/1wxHF4w7mrBlHgf2f6uKg8pCGDQFMChBPguMusY3yWykp42h77TGJrPweI//AB4O8RR/A4D3rVmD961Zg8l6vVlMrBQQlhAGmccB3CYed2JtSaUwGBCWZrN/QSwhPBYcG3srFeR0HTlVDVywOlQV4CzwBctCUkbnatRBlfjlnS3HwaCuY6/EUgcAcJOjEzY+fXgM3arqe707y+VIxcF9Ln5DTRtAXwfBTLmKKbuGKbuGp+YKcKiDE4W1RcnUPeR5Cc7jINsQVQWYqNelQoNYVTVKQAZjasnlVFBdwdgPNsCuKOi9cj+03NI74cM2ZKktKUo9yp87Pkq2LaUwrTKWFUMRvG0zCUzfsQY3vJeiM0UwqtsAtaB3B6UGe2GXFSRHFvHxgwWYjoO6bSN7SgKLv/LOS75f3vcygo/+YKkv//xqvblBZyXC2svPls9Dd4TcMz+Pn87NNSstb04mffSnQQK/DCoLR5Ah0OPAs+Esw2ooGgZEr1LNcTxeM7Dx6g5XXsCxAwpSieNXHOoGpZ7rKELl6hv7+jAnURxcIVhm2YWkP8SwS15xWHyyG13njUNJWOgUDBx6b7kRiso8E66yKj6rOyfjCNCPFAp4fYDisCGRwIUdHbiXiwJYKcUhrLAfjyLHrATWd64gLI7FpuLQYhvF4omdkgI+jnBdWUhnXfeOz/6AHM0dxSIO1mrQCUGfpnlouaOgckY5tw+j5I04dRx2Sxivyrbt80bZy/A4xHkf7jUv6+rCedksJut1rE0kYNs2xp+PisMHP/L3IITgXW9/SzNEJy5+ft/9+P4Pb8a2rZvxh+94azvNWDE8t2s3nnlmJ2ZmZ3HiCdsa+Rsh2Ld/tOll6OjIorNjiRFo/bo1yGTSKBSK2L1nHyrVKhIheQs7nnqm+fepp5y4Is9zpBAaqtSqx4EueR7qlHoVBxA4FkAkAp3jBFIqe47pycgXab6VsurRUS5QUSC4b2EBGxIJJAnBkGHE9jiEuWpttliVI5KrAOBfCiWgsB86IXj38DAuCnBxi+EgBcvyJVEDgJ2og5rB9x3WdfzpmjVQCMFErYbDtZq0QFF9TodjEViFxj2cRB23ByRRf3liAvurVYwL7nOZ4sC/MUIIupIEE5b3/iOGgQ2JBK7t7saaRAK33K3h7kc0z9tvhioFWNI01W+V49vCbwwyj4OIZ8plIFVG74sbn2szBogg7Nu1cMUhLQhVrschqODW0+UyPn34MOYqDjLbLRSf6/IkULvPnTYAvbsKojiwSioUVqjuzEwG52az+Mzhw57rWhUVyZ6Kx1qndUo8dVy/nrPNxkUn2XhoJ8G56xS89mwNbgm9NIvf9zyFJFEb3OY/Va97CuPJ5l2rHoegOamwfCPLcTxCRWioUox7ivNb9LyINI1gln73WfmVynYcqeLjC1WK8DhQiXAqo73kPQ6KpICXz+MgPAtvoKmOpzHx4/U4eQT4yOsI3sUlalLNgdZVRX02AU1ZKlApWuRl60MQkpSGWoTFsbTaikPJtj3P98+joz7CERfL9TiIisMzpoXPHD6Mfl3H9b29AGfAciFbJ7fYXbgon8R4rYaxWg1rAmSd+xYWcAeX27YuRi6nC3dealxRxai5LfM4fH96GiohuCqXQ0pRpDmEz5bL+NncHDRCcH1vLwZZbaVABSHg+1Y8DvCYtI5ttKU4zMw2BAArhmAjoqOjEZV7+LCfhu5oYXJyCv/7k9sBAPsOjOLM008NTUq54857mn+fctIJnt8opTjz9FNx1z33oVar4RcPPOyjdnVRqVTxiwceBgDouo7TTjl5hZ5o5dFwWxJfInJQEaAgKM1FoPFZUxrxrr0C855jk2aYiwc2kcbFek+Gz+MgQ122MUc8x+8PDuI1vb14rFDAlyYm8Fy53Ezy+sLWrfEVB+HzoWoVvywUsCaRwKZEAnZIQSMZao6D701P48IOP4Xh58fGcP/ioue7gmX5klL7NA3aYgq0KzhMaWsq1WRguXdhAV+TFM3qt5J49Ccjnu/qejhRwDPlss8DJAtVEnukatuYFBSOEcNAh6riRmZVvJeF7PDQlaUcBpklTcwL4CGGhchyHKJg1xSoGW+7+eRoWZ2GlLAmuYpDGJ/5fzFLccepQHF3p8dU6ypP6QSBmq1h/pFeWFUF3ReMwV7Q8Z7tIzAdx6c42BUFVJiDhPrbwAupHxzdg4WTLORPAnYB2ONswXYkm8elFcVT02EmYG9xx0Gc0KBWFAc1pLjj4VoNb332WQDAm/r7sWCaqDuOJx5afAdx1gHRo8gr9wYhUsOGzrVT9DgQyfG+UCXhsxg+o0pCtiqS64o5DqrQ3iiPg06893BMCp0AnaqCvKp6LNIuhbCuLs1/mcdBFt4j+y5JqW89eGhxEQeqVZzf0eFbmyuOg29MTmJfpYILOzpwUUdHIGMQADxZLOL709PYnExiSzKJzYkEsqqKvKbh9HQaBstbuVUwpLywsxOv6unBplTK83xhlbiry1QcNko8K/cuLmJLMonr2WfR4yDLBdumZnBFbwfmTRNl20bFtvF0qYQBXfes3+JY7lBVIMhLLcCd20luXBKu8rkUhOCUdBoV1qafs+f89tQU9lerePfwsDQU+GOjSxSoY7Ua/nr9ethhczmoUGuM5xKLNUrpIY8xHJFQpThwQ3OKEk74o4Wzzjgd37/pZhSKRYyNTeCb3/kBbnzVddJj77z7Xjz86GMAq7/w4hdd5jvmqisvx333P4R6vY6bfnQztmzagOEhb9Uy27bx3//zHSwyq93ll12MTObYrBgNbn6IY7sZcxjTmsLnOIAJaJpN0CPKu45/kYKb/xC1SkpClWQI2pjDcDpP1SoIzUpEZWkevKAzVa/jb/bvb1bZVdmiF5Q3EITnymWpEPmcJAmvYFk+i2aPpqFASJPVRoYctxnINrSrczlUJhN4VPi+poUrDhO1WnOxPS2dxlitht2VCg7Vapg3TRQsC/93/XqfC/hQreb1QgAYEuJsZR4BV9i3A0KVZMqEC9ES57u+hOVLhFVUQfoEj0NIjgMYuxcPV/AMEyy8N/WOTTcBO20ApT0dAAhyFzboQslcQ6iXVYW1KqqfwCCAkrV5jsQizwu+F3d0wHIcZBQFWUXBcECsdLM4lhgz36LiIK4uKiGx1rAvMUVMYfH/juOAELKs6q+i4MIrDjqlkR4HMcfBktxTnC+ix0EmAIv9JmuHWwOGcl4Kfj0VVxBxLTOIv6/dOSeGmLlKqaFxuVESj4NsBMqEw4Tgcbhjbg7/OdYwZP5getoXp38HJ+A/XixiSNexMSQX8elSCTvYPwDYkkziQ+vWYUsyifey4ntdioJdlYonXOakdBojiQR6Nc3D7hQ2vytsz+D749lSCXOmibymoVtV0amqvvd+cWcnLu7sxDnZLD5xcCmk2hMuGiPHIZNoXPejBw54wlXfNjCAF3Qt1bYR91rRA84jTamHoTFoLqms8rkY3gY2Lm/o7cXV3d342dxcU3EAgAcXF1GyrEhGwL3VKg7XahgK8Y7I3kxcDxWv1D4vPQ5f/to3pd/f9ONbkEzES+a1bRuTk1PYyxSHlWJXWlwsNIVvHmWe6nJ+AYcED4eiKOjva7jkDEPH6268Hp/7wpfhOA7uuuc+7Nm7H5dcdB76enuh6zomJ6fwwMOP4skdS4lWr3v1K9HT4y981NXZgVdf/3J89evfQqVSxcc+8W+49JKLcMK2LTAMHeMTk7jr7vuwZ1+jEM+GdWtx1RWXr0h/HCk0BRlRXlhmqJKhACoFKCVQHYJ+icdBhr40RTpLAmMOwSZhT0Z+flSoUty4aNn9lRaSo/njvjw+3lQaAODmmRlsCqG0+9v167E2kcC/HjyIXwiehEMs0ZiHGCYAV3GQMJMQAigxFQdxgTw7k8Eb+vtx7xR8PVRSaqEKn9vCTYlEIxelVsMf797tOebP1qzxCXciC0qfpvlCAmQeAfc7MyBHIczjIIYqiRuqyyQVBrumQJSdonIcxNjbZqhSTM+UOKdcoTFjAAAB0SwkBktwHEAba4S8iXknjgU4NQpbUEIkcqAH4ohShCrsIptJEFuX+6SigixT+MMUASq0SSNEWhAxCBZT3OqOA12iOEStA7bj+KzwvAfQkFTSdS377lHv37MH8yyRlgD4g6EhZAQvok9hW4ZVUxZm5I4dl6JaZe/TNZ6Igr14DUMSU99k6RKVGzdPSl2adz6PQ4CVV1aZPMlomF3czwmVdcfBaIQl/CsTE/ggl+QuQsxL2SxZy2U5bAlKlzyrId4bHi4NLX/EbXNzHk/CS3I5vF7CFgRJNfMF02wqw75QJck6mUkstZ2H6KUSlc8gxUFrQQnXGMNUp6qiaNue8wj3v4xid1+1inOyWeRU1Re2xeOZcrllxSGuIcfTIwGhhscaWlIc7n/wYen3j/9qx7IbIIb4LBd33XMffnzLbaHH3PTjW3DTj2/xfNedy+GvP/T+5ufTTj0Jb33zG/C1//k2isUSDowexNe+8R3p9VKpJF5/46tw+mnBoUUXnn8OTNPEd77/I1SrNfzktjvwk9vu8B13wrYtePNvv/aYZ55asoB6J4U72OMqDu5yoVCKhNa4lkoI+sTQ/ADFYUuvgmtfksCHQwirdEKYMBQOMVSpFZo40QWuMAtI3Inlbq5zpomHBcX34UJBuuG5mDZNrAXwsu5un+KwX7LpyUKeCpble36dUlCCUI9Dd4jHoakUav4+LNC6XNsS4IYdiWFUYJ6ZAWERPyg874hkkZcqBhyrkmxDDPM4iKFKotVWGmInXkNSCM7jcQhIjubhCh5hoUrem8q/TrPNn+oWCs/kUDmUxrDS6EdRcWgwKhGJ4hDeBlGQVCQ1UXgEscoEhSrJ4sfD1iRxKCYVpSWmFwBYYMq3HjN0CgCeKZVwx9wcDgueMrAx7zAh+9a5OfxiwVugy2D1Ylzh//7FRR/Llk9xEO6xHFZ4n7eA5/pn/2499VTMmSYmAmoXiYqDjPpTY15oX9+5Hgd1aQiL4+PH09P4xuRk41xCMFar4be6u/Fk0VuDBNza6yIolykIspwuHovC2p2X5ZJJclwSlHrouF2Eta4sCVWaEd5Bd0hRWZFFqsoU2qSi+EKVRIpohCkOwvsWjVRiPo8LnRC8pq+vWehSIySw/RoLk0tRCkNQOHjFQbaX7i6XcUIqhSSlCOO+fLpUwgs5z4mI4x6HENz4quuwb/8B7Ns/Kq3V0AoIITjrzNNw3bW/texrHCmcftrJ2LplE+5/8GE8ueNpHBobR7FYAiFAKpXC8NAgTty+DRecdzYSiWjJ9AUXX4ATtm/Fz+97ADueegazc3Oo1+voyGaxds0IzjnrDJx26kmr8mztIsrjINsotySTvjAZlXNxJ5lRUZMoDk6AEVUB8VWvFpFPEZ8w92yphAcXFzHPqiQP6Do2CpagVmKixY2LMktbK6FKHx0d9dAx8pAxPrlwN4YRw8BWVWlWkAaAfRKmCHHTvrCjA6/s6fG44MEW7SjFoSvE4+C+W0mdOMwJFSfeMjCADYkEput1fJxzlS9YFiq23eSy5zegKdP0hRGI1kGZ4iALVfLUcZCFKrXgcRARR3FQu2qoTRvozJvoN1Q88ViqQTXMcOKIfxyJHgd3jMTZqBrF4eRjM826zCrqWHyi4UE1G0W6fYqDW8PB5xGMUByiPA4JQjxWyqARGORxkAqiEXPxunweCVYE8rR0Gk8JCagZIe9CxIJpNpRvRYmd4zBrms2aAiI6GCVjxbY9sdYuEpR6cjEUwSshE9ll61Qr+LdDh5phPC54Bcv1OCghrFSQCJJJqeLQ+F/cS4jiIDG8CAyYmDV70KfrvueatyxMCWP1x0LBRBdvZJWZXQQpqUO6jhHDwAOCcSZK/hEVB5l13XEcn8fBaMHjcEFHB3RCsJ15l/kriYpQd0gdChn97Dxj3BO9ODWJBhOkOIh7TlyPg04p3jk0hLJtoxhA4OFCY/WJCAsz5MOb3P2fBBS7O5kxYcrGIY+nI6rUt6M4uKPkfbt3Y1e5DIUQJCnF7w0MYHOsK6w+WlIcLrnofFxy0fkAqzvwJ+//IADg9a95FXry3bGvk0wmkM93IxlRWbAVXPOSK3HNS65cseulUkm88NKL8cJLL16R6/X25HHdtS/Bdde+ZEWud7QQmOPA/hc36Rt7e3FtPo+Pj456LOoq5+JOsjWBEoJcSog6DvA46DRaOJetk78sFvFPnIB6ZiaD969Zg7MzGVSYmzMu6wUkbnHFdde3EKoUtHgmKUUhJPyETxwcVLyKwwGJNUy0GJ6cSmFA132LuUYpQOXUni4qto2d5TJMx8FjgtLjvhe3eBqPGdsr1vRoGtYnEhiUhKRM1utYYxjoEJgvZup130IdpTjMmybqugmtywLRbNTnDDh1BQm3wFuAd0GXPIOLIM58F1ZJw0VT67HhxFJDGGAJ6jxS6xrCSBnAiJHGBYMD+Njjjfea1IHrzl1SyF3BwZcc3YLHISj0DwBSEhtIjQ0pX+wwUyotszWPg0/JFDw1CUVBhRvXrXocpIpDxHx+UVdXs5pzn6b5wt6iakYscOF+UR4HhY21sGJinYqCedMMLbqm8YqD8LssZC2KjjUKovUagIfKlHLXDBphtqTQZlL1v5tmXRDh+bMnzUBJWKgD+MOdc/jhySf7FMu4RBIbEgl0qapHmJSFrALA7wwM4IRUylMHAjESkUVlU7bOVx1HqvzKkr/F9/qxDRvQz9a5pvHLDVlyHF/oTZjHIUGpT2mfN81G/L+Q41CVaKau4iDuneL7EJ81LFTJfZ6onVQjBDqbT2KYIf9J7I8XdXVhHeu3KMVh2jQxWauhNygfQjJ24vqv3LVstFrFPm7tWWjRA7aaWHZytGEsdeD6dWswGFG34TieH3A9DlZVQX1eB4iDdd206YYVF3szYEPlLY1Jbj1r0LNyrrsAQSehEAxoGj69ZQtKloVfLhbw5cmlJGXHAeYlRgJxM67ZNjYlk/j3rVuxaJpIKUosb4HlOLAkxdkUyeIVhjDeeNfaEgR+Mx8UFj5ZqJIvRpmdI26YY7UaFrrl1lAXX5uYwC6JVwPsmRZME/fUFpA92QRRbBDqYOGJPEqO93ncWhoGpb7ktklG69epqp7Qh2nT9FrAbNvHBy4m1f7J7t2oZO0mDerUT0dQm0p6PA6tJkfL4qlfeBLBHU82+lOhwGvPMNDFYoDGIkIbCpaFt12sQk9aODgDXHEKQUeyMTqyitLc+II8DnFiaoM8eAhQklxd9IdcZWMAMAuN/nWEUKUwj4MtCCBwY+G5z6LgHyS0ByVHJySUrlEeB16YUQjBJZ2dGNB1GIz2ccE08df79wee77IrAcA/b9qEAqvGbjkO+gRhLcm8F5uTSWkyZ4eiNIWvoNwMgxkngopNysSNqAJwURDbcm13N940MOC5XvOaQfUuHAc9qoqK46DK8kI6VP+kC/I4KImlp5g2TfxoZgZnZ7w5klGKw2t6e7HGMJqV6z0CseTcV/f24gRWC+ZFXV0eKulzslnf8S4cx8GisCbJwnIUx8FPTz0VT5dKWLAszJkmFAAHKhVUbNuzl4jvlacMF2loC5blE9LDPA5gnq4Kt866hAiiZ7Vmeq+b3jaLvx5dhEGphxoZkvch9nGU4hAndMf1wEEyTt1PRKI48Hl6UYoDADxVLgcqDivhcRDfVyv1Z1YbbbEqveG1NwAAurrknPFhME0TC4uLSBgJpFLHbpXk4/DCVRyKz+RQfKZRyfN/35/GcJd8swtSHHirfIKLhTcUitPW23hsb+OzE0C5mlQpMpqKzVkdc8ytj0nuAAdYkMi1Ydzkdguxvx/et0/qAlcIaXnCb04mA8MWwgrk8ErLoLAAj9dqKAvF3cRF2+0LccF6qlQChoJdswNmCmoIY5BCCAqWhdvMCWS5kiTF3f51gt/MejXNqzi4eQ7Cs83U6/hVoYB/HB2FDeDleT8xgVhMLCmEOxG18beuLgm0moRmMCpUaaJaxb8cPIh508S1+Tze+eI0bMfB2HQNr79URxfH6iVzlfMoWBY0RcGVpwpJ3ULCrlggrMj43kXh8B2Dg5gzTfz3JDcxQjwOMtRZk6/u7sYPOOWhMtoQ2Gwx0TpMcZB8pxBvOKG4gbcaqmQwtiF+vYnKWTAFxWHYMDyCdZTiscAJaed3dKBoWVLF3W2L254PrluHr05M4NFCoTnqrsrlmsYEN5dB7AODUk8elagEyDwOfzg0hHnTREJRkFNVn0IThSCDkIs4HgeDUvzz5kbwhW3bmBw/jIOLauCci+r3XxYKOENQHGTsSTyGDQOnZTLYwkJ7PAKx8EwfWbfOw5rUSghrxbZ9740Xkv/98GFUbBt12wYhBG/q70efpuH9e/Z4zvnkpk1Nb5jY555x7YY2sY+yfI1vTk5iT6WCv1i3DllFwc/n53H73BxyqoqcYJwB52UUDSQVweOgpuseSzkPX6iS6HEIUGYO1mr46IEDOCmVwgUSanEe/H7rU7YJwU/n5vCDqSmfZ5xXHBIh7E4unimV8IKA+kjtJEeDjUOf4nAM07K2pTicf+5Zyz734KHD+OjHP4VtWzbhD9/5e+004zhWETJ6SD7XQLQSzZkmput1XyiJIVgaXeiU4OrTgWcPAuV6g3VDNv2SCvHEpPu2C4fgwo0Sa5awsPCT1QmgJZQhSDWgLbKyAMBFHR346sSEpy3rmKU9LLb64UIBX5uYwFy9jsNlr5bksIqYJ3HVzH0c6qwvkhJrvwzV8STsmoKzunuxt2M88LggSksxZ0JnFUDdp+7VdezkvBhfnpjAhkTClyA9Y5r42wMHcJhZ8P/10CHfvcR3kBKS34jW6AtDWRIyW/Y4OA7+9fDhZuzzs6Oj+OC6dfjLVxqYmZhFd9+A5/hIxYElAYpIMEGx+SwSj4Nskzo1nfblFvk8BBGos1f2snwe+ysVPDJXQvVwGuV9zNoqKg4heR0y74FYxOyhxUX866FDqNg2qraNtYaBf9+61XdeYKgSs8a736sA1hgGzs5k4FQrSCdTuEtQ0vlrqJI1LFJxME1fgmMQNKY41BwH/bqO94yMYKJWw5OlEpKU4npW9Vplz5EQYrbBxkNoqJLkvr2ahg5VRVZRfPlBcSAqX6KQQzkFJu4IUwhBWhd5rZZClaIIKu6en0ePpmGyXsecaeKSzs5Ij0OZE4b5/22J4CaG3YTtHSLE/AYIHocHFhY8oaOvyOeRV1VfAb2CZQUrDiEeB5ni4BqnPnnwIN42OIgD1arPQ8DDXa98OQ6C4uAaYWTwhSrF9DgAwNcnJ/Gqnh5cECCsy6AxpZtPxRytVnG3xDDXpap4tlTCd6amAgvruXhNby9OSQfT5LfjcQCbs8uhcj5aOGp1HKamGtbaA6P+Tf84jl1EKQ6bk0mclcnAdhw8USrhzvl53MlViryiqwspRcH6REIqpCcUgg39wL+/3sDEAnBzRsEOiefAUEgzmZNIhBLHAd51qX+DjFMNNQ6CwpmUFmpZuOjRNPzN+vW4Z2EB6wwD5zMLS1ZRcKBaxfZkEmXbRsm28dnDh+Gw3xYtKzDxD6xuA684iDkOrjDwOwMD+J2BAXxjYgI3BVyvPqdj+s5GMbfMNeH5JSpnVeWhJLybWYq5mN130C+xgo7X6z6qwOfK5abSEATxHYiWbOoqDtrSAh+HjnXRNPH1yUksWBZe1dODX3J5Ow6Av963D5/dLE9pi1IciixhX0SSUk9/ZhUFPaqKtKIgxeodyBQHGT1oqx4HN1QpQSneu2YNLv+CVyBqJTlatpHyRcxU1ge8siPLWQDvcZAklvKvMa0ouKizExdks5iZGEN33wDuE1iIxFAl9x0sWlZgQTEe85blEaxCFQdKoTmOhy6rT9ebtLM8rbXGFGuZ4hAWqiQtgLaM4mBiu3n4FAfmQX5wcRGjlQomTROW42BLMonhEBrLtIR5La7HYd6y8MXxJQPGWsOIVhxc9iHHARjVKAJCnETFwac8hdxLVBxcJZC/dpU7psw8DwlKPcnS/N/i/OGNI82j2DGynBQXO0olvGfXLinLEw83VMlxHE8Mfz7r9cy2ojiIe1AQq5ILcxn0pAaXqxHGkNilqthbqXiUhrWGgf+7fj3qjOmw5jhIUBqanI2VUBwcxzeefiMUh9m5OTy3czfm5xdQrwdvkJZtYWZmDo8/8STAXJbH8esD2VzgFYc39vfj2nweY7UaniwW8XcHDjR/61AUvHlgABsTCcy4TCQCDEbF15Om6MsQXJPfDKg2/mLfPtzHWQ1UQtCVXLqx2CxDIXjhVv+iJMtxWA6CVANe8IgLNzzixt5ez/em46BLVT2JlBd3dGDOspCkFH+8a5fUsuVil2BNEt3GVdvGoWoVnUwIDeLMBwC7utSXhIQvakEeh0tOAp7gPqdZPokrhAxIFucuVfWFH4gVokUQiRU2KWxQrsdBV5YstDJWJVGZ+ML4eNPD8FSphBFd99TesAF8f2YGL5K0S1QcBnXdowAVGBe/WAnVtTC7WJdINEM+XMgS6XRF8VmffTUcJO3kYUZMD9/1WgxVaobbsJht8T0FhZ4EeRw0Lt4Z7L2LnjRNYCHyeByYAKwRgn8/dAi/DGA74+Fy3nONCzxWC1CqXbhWe5VTHEQYTJGUVY5GQD/bjtPg5Y98GjnieBwUAJ89fBiPcMr0m/r7IxSH4ORotUUDzJxpSvMUeOyvVnGoWoXtOMgqStOgICuyKXotfQXxQt6zLDGaN5QZlALcMa6AnQxQHKShLIwJjB0ARIQq8bAl66hrjHIxH+BxeP0lBD/bsdSWwR4HXl6+JfD9KnuGJKX4j61bUTBNFG0b/z0x4RHkvzc9jefKZSQoxSc2b46Vi6BT2iyIR0IE8Jyq4lFJ3gNhczRsP/RBMhZaUhyE+hN4visO9Xod3/jW93D/g48si551ZHio3SYcxypC5nEQxzcB8GihgC+Pe8NZ3IWWsEVYVuHUoA1Xo7sZJjWKGvFPQo0QKHTJNd6hKLiyqwt1u1FAayCjxKqG2kocIo+g5MLlFFYKOke28BBCmrGZHcJCL4JPXrYki/b/Y1SPbx8cxMUsIVREfUEDVW1Y5aWlgsZRHCS/n7HJwRNcke2UongWIFniWZeq+ihpoxQHnfhpeH0eh2aOAxeqJKvjICgTPCVjxbbxwq4uWHNz2MP19Y9mZrA2ncJItYp9tVojrp1SH53jiKA4OAA+degQrunu9oxLg9IG1SUX1CHGvss8ZwYhvnh3f/E3/zN72hhFlicrAEccVvFdODQiVElnNIQ8gizIQcnRukCF7ArqFSY8247jG7t/vX8/ejUNKiH405ERvKCrS1p4LQgLrXgcIipT8+x0GuOlF2EI1xD1XVk/ux6HZSsOosdBrH3D5pzYt1HCUyrE43BFVxdONNL4yP84cByCnssOeo67tLPT482eNc3IHIfb5+aaCc7nZLP4K1bATaZw7K1W8fOJCVhsnD0q1NlpJVRJtKyL79UVsEUPm/s8slX+I/v2IUlpI+xN0/D3GzcuhSpFrJEybE4k8CinKE8HKA4b+4D3vpTifx8GhnocFDtszAU4gPn5K12jKMXmZBKTtRqmTBNrEwlf2NCT7HPcsatzSplsTLr49OHD+FVI3kMraDfHoe44fiPI81lx+Oznv4ynnn52Wedm0mlc/4pr223CcawiZG5wUYgmAPZXKr5kK9e6T9gGL1trEop341cpUHfk8X+242DesrBgmtAoxUvzeXRQBVo5gRP65ENbdLnXHAcPLCzgtrm5phVqQzKJl0kSbsX7y7AcHoSga0UtPB2q6qtOyoMvUBTmWXGtY+sNw8dIM/9QP2pTXvICg9JQOknVTRIXhC8x0TsjWIdllKxdEXkeLkZ0HRsSCdQcR6qIiQJpM8dBXRJuWs1xAEtC/72BAfzl3r3Nzd0G8KVSGRcvLODm2eCyQiOGgQcFYWS0WoVKyJIgwZEIaJTCci2TQm2BJKW4sbe3OWbSrP6Fz+4Y4XH4w6sJPnnz0jt711XhI1rK0iQoDg8sLOCxYlH6fnmruUaIj2p2OYqDKioOzAI5Ydt4z3PPSa/nKqMVplwULSuycrCLBcuCw4TkkmWhzKyHipAz5RZta9fjcKqQEOwLVZJct+1QJeEeDxYK+LdDh/DOoYbhz/U4tGqYkYUquWesSyQwpBmojtvScBhxPMk8DmINGB41227eSzyPsOsFkVaAs8jLEEXFKr7Xp0olrDMMqVcYAf34JCdgu2GervFW9Di8qKsLh2o1X40SHtuTSY/iMFmvw2GeKh6EELz0TOA1JycwTSr4ywPxQpVkHpqEwMQVFrgU1wLvKmXu0UHniUoDVlpxYP/XbBtPl0pIMJa2BKXo1TSP3GRKDHvPW4/DY796sqk0aJqKk07cjt6eHlQqFdz9818AAF5y1YtgWzamZ2bx5FNPo1yuYMvmjfitq67A+vVroS3zRR3H0YHrcUgML0LrqsFxgK9OF3Celca5LDafBCwStrsAsk1RZrXXKIVGXWECUCgBsRqc4S/P5wHHwYBhYEjXsWhZuOLxxz3nf3LzZoyEeBhlOQ5Pl8v49tRU87sLOjoiFYcgcWo5kz3I4xAVRCWyDQHAGZkMzslmkaEUWxmNIJhAFATXOpZUFKwxDA8jjJ4vSxSHcKYaN/7aoBR1bgN1HAcDmoZFJlylBerbdYbhKRZ4UiqFrKL4chxkeH1/f2jyWlCOA+W8WTIlQcIW6UHJtrE2kcArenrwLW4MFRwnVGkAIE1SdYTxwFsgNWY51yRWtJSi4Fo2ZpOUoltVMVar4ZAg/PpDi7z3v+ZMgvF54IkDDi7eRnBORAUix6Q4OZVqtmnHAa82cvoZJfyLJHndBe9x0Cj1vSfXEic+ryvMnJbJYLhebwpWvbou9Tg0rhX+LGCKx6Jl4fXPPBN9MEPBsmA5Dg5Vq7huxw7Pb5/furVprXfXnjBLIu9x0IW4eAB438gIXsPVT4Bk/ZB5/g9Vq6izYmMV20Ze03xJ9mGQzXfequ1adsM8DvsqFTxRLCLBQq0008QGmeLANd8t8yALgZMpDqKJoYvNAxnqnFAsCuwuO1cYwry9kR4H4b3eMTfnK8QJ3uMQoYC59LafPnwYd83P+6hHt6VSeFk+j3fv2hV4jW3cfuHeuyRhhwLbmwgBHPgpycV2uajbts9T6o5vt6fD+jzuaNWFa7ZiuQ8ziIVBfDv8+5ozzaZ338Xnt271zKn6bxKr0oMPPwoA6OzswHv+6B3IdzfoOQ8dHmsqDtdcvVSUrVar4+Zbb8ett9+JW396J373Ta87rjj8mmFJcSgitb4RevHFKcBR+pcUB0ICY01rtt0IVaIUimThVQmBwRQH1wJMmJDVz353qfREnmywTbMzETzhZAluots9ir4RIaFKrfKjow3Lguy83+7ra8Zm8kXQwmJ/eevYlmTSozhoeX9muibE3ItQWKKrQQh4e/o1+Tz+ZM0ajNVqcBwHI4bhWSw1SvHBtWvxnakpUEJwVa6xnoQxb8R5Psg8DpwFM4xVKerNnMu43F+Wz2NXueyx2AVhnWHglT09WC8pgGkJQrKoOLjfhfUIBfC7zz7rCZ8CKyw2Vhf6QThXVwnefiVpxMPHGJd2VcVfrFvX7MM9uoM/vNNGyWoUsKtvmwjVgF1BgTBjgpjjACbAiGPAveRrOSG6R9PQq2nN2icKm4/NeiUxbO66xOsRB4ss70iE13vKBBqJN048XmXeOFHAlHkOxbvKBL2PjY56vJN/t349Xtwdv2irjGJabJtUceD+fq5c9lADb1IVXBtSYBG8x0bC1iVaz+csy7d250IUhx2lEm546qkmQcOLczmcmEqhatuwYwhH71uzJvC3SI9DzDXftdhrhOAdg4MwmSJ9oFrFbZyiUXEc3D03h+8L9VZcdDPK1aBxZxCCtYYBDUCOzaMeTYMZRg7gOCBK+Npbse3mWpLTNHxp+/ZmIcB1htGsSRPlHVAl4adBcJOZZ5liK15zSNfx+4OD+NC+fb5zV8rjwCsOomJFJEpBhfN+uXjeKg77DzRiDq+8/NKm0hAGXdfwsmuuRkdHB771nR/gc5//Mv7wHW9tpwnHscpozgdJXgP/d9BiUmcJekFJxIQQJBQKWI0CWrJru5AJ6TaAlBG88YuT0ZIkxsWZsKJ4c1o6jY+sXx8reUsE3w/PlErYWS6jZNsoWRa6VBWX53JICmE9CIgZ5auD8pZHjRBc2dWFGdP0VPAGi/sd0nXolPrCy/Seii86Wlf8tSrOzWbx2319sBhbkiKxllbZJgL2npOKAofbYBVC0KmquJ4libuhD7UYfRqWqIiQUCXbCWdV4iHbQF3ljBKCtw8N4X27d3uSpWXo0zScFVA86rRMxutx4AQOnVMc3JZYjoPPj41hWzKJF3R1NZ5NIpj86cgIbuzrw+B/e/Msgob6oK4jqSiYrdcxF/E8BsfetKGP4D/eTrFj1MEJwwQfm/G7zt4+OIiMojQtz3DZyCQ5DgBQsSyf4CV72+784JmJAGC0UsGnDx/Gw4VwykU0PZ7y+gkujSqPblVFh6KgZtvSMUiF8/m/xfnLv4oEE5TE9yi7h7guBLEqedrVolAiM6aIigOVrOl8iI0YMpQkBIZkzknz6Kh/PxE9ehXbhmjmiLIg80LdiakUzubm5cNCTpKIsCt3qirWGAYWLQuLpunzOMRl3nP7TKcUF3G0pI7jeBSHqm37wh55dKsqKCHo0zRpeGue5fj8Q2cWPf2DoFz7gma/QxrjO8zjYLN9ih8/lBAkCPHsVe7dgjwOrRrXejWteU3ZmNyYSCCvqr7w2QcWF/E/U1MgAN7c349vTE42Knk7DqqOgzf09WFTUlJ3TJhzvOIgC58TlSCZvPS8DVVaXGwM1HVrgzVvGS675EI8/MhjeObZnXjs8Sdx2qkntdOM41hFuIs6EQqAuRP+gcVF/HB6GndwSWs8PrxvHzYkEnjvyIg05hkAkgqFYwGaQvBsqYRdlQoO12owHQdrDAOb2cSVKg4RAqTMciZWZ46jOIj3TisKejQtkD4yDPwC8WihgB8KlKjfZCEwGiH4o+HhZtEjmXWEvxa/FOVZ8twzpRJ+OD2Nr/FFwVjNBBmUhAUlbcIqLi3yhkRASFLa5BuHuzlIFAe+TZqQyKoK4WuUEKQUpUFV6BbPYjGiJcvy0FRGsWOJlmwaU3HgR5MszphvvzsGohQHPozhhp6e5vtNUopX5PPN2FjCxwBzFusEpajaNmq2jU8dOoSHCwXcPT+PlKI0BB+JpToozjtopLuxuF2qGqk46AJl6EAXwUBX48pbKimMcWvBb3V3NxLxNc0zXjSWAC6z9ouCSRAJh6g4uP1VtG3cHyEENp/FJWWgFAXhvpd3dXmE1T5Nwz9t2tT8LHouxRwHfl3RKPVQskIwRrjnie9Rxv4jrkXS0BIJfWorkCoOku/CQpV8AhTkioPs9YbVBwlDVwvhWOK6HxWqFPb7K3t68EpWk8NxHJ/iJstdkSFIKBfXMwfA3oqEt5zB3Sv6dD1QcUCLe6oDBxb8oUxv6OvD+kQCCbaGyARg/uln63X859gYdpRKviJtLuK/xSW4zyQbk4QQbE+l8HMhh4XPaZFViw9a28Ue4tURce0lbL/ilUfZe37eKg4W60Rd99Io8tpqrVaDLhEQLzz/bOzZuw+/eOCh44rDrxGa1iBhTLtvfG+lgh+F1BaYrNcxWa+jZNuBi2dGpVisNTwO356a8sSOX5XL4SXMxS5bTKLyAmRKgRiPGscaFIc7PS74NoXFHdcdx3Pstd3duIUTZM4XrNiyNjlMwG0Fer6MMqc46AqJTIJUJMJrlVVohkTIc/9WhGukFAUzpokvbdvW3NS6VBXv373bw77RssdBXUrUDwtVCntGAHjv7t1Yw1zuJ6ZSscJc+DCGa/N5dLGqrVflcsiqanM8ipYpPlSpaJr4x9FR7GB9YAP4t0OH8M+bNiGrKL6+F4XgZj8E7E0ap6SIRalEhIVdiMJ0c9wI57jt1Qjx3a8kXCOoLarwvyvstjLe3bmfUBRfn4keAvFdi2MwrJCcTBCXhWLECVU6I5NBp6Kg7jighKBHYlAQz2pVEJNRo8rW77B1QVR6khRQFf8zLzGMNuK+iWYBBKiOJaH1VEDV+GttKzHrrSoOcQU7Iil22mqokgixejwka9wlnZ24OpfDPCMPQUCtHADSMeMicG8jgIw+4LyOjsiQH/7p371rlyfRW4Z2hOig8LnLu7p8ikMUdpbLuHV2FhTAa/r6mh5nn+IQ4mkr2TZun5tryjEIyGFRCQn09hxttKU4JBIGSqUyFgteLdEwlhSFxUIR+W6/4tDPYlMPHh5rpwnHscpYUhzkFqy4cXmitZnHui4FO+s2NCXcgiWzjvzN/v3YnEigX9fxkfXrfb/LNmwxgTSqKA0kG6/dBtUh2EQ0AzYEHvzmsD2Vwg09PfjJ7Cy6AVwvJHTLthwnxvOJfN6588dRPpBtMuUQCR2ruPCpEsGiwoUquefzC5DocVA44Yz/3nEcXJ7L4YRUCjoLd9kqJPaJkCVHGypw+TYVo3YjPEuWHM0/pWxxX7SspvCekNQhkIHvW0oILmUhRu57cZshCqY6l4BqKAo2JhLNe4MJrvcvLuJVhoFeQUDYEWDJyxoSAZabx4QQpLnx8PqLCb56z1I/fOgaI1TRDmIKEe+a4O6XEqz9ojUuUHHgrsEz/MTJWRKvIQuZ8ikOwrsWqW/F9Y33dkoLJEra43rtFDcvTHLen4yMYNE0MRrCsHYkPA6y996KxyEZsGK6e8zd8/P47NgYBl8Rv51Duo5zslkULQtV226pSvZd8/M4kSNYiJrJy6HedhHX41CRWLhJwPgU68T0qCrWCXlUQf0RVgwuUHgl8vbFCdfley6OzLCiigMbk1uTSZyeTseq1eKCzyGZOnQIf7d+PQghoTkOMmISUZmQGaW056vi0JPPY39pFM88uxPbty7Rb6RTS5Nvz9590vwH11ux0KLGdxxHF1Eeh7ibdGhyLSXYkKco1/3HTdTrmK3XkREYeVzMmSYeKhSwJqDokMril90EX50Qn+t2KMZm4yu61IbHAWxxMx0nkumEX5RVSvHynh5c293dqIrLtdt0HMzU60hS2rS4ukJ7lAV2UNexKBSP41dGWR0HqcdBkgDmLpfue+WvowqbtcKUS5FS0QZweWdnU7j82dwcvjw+3qTePCGZ9CV+ynIc/uqlBlIGAPaoasR+F0UtmaE0lvJYsCykCUFRUkQLIcIrJQQZTpC8sbfXV/n0S+PjuHNuDnsFZfjxYhGm4+DdL9TxiTuWxvtHX5kARc0XQsaDVxxefg7BQzuBZ8YcnLmG4oYzVeg0+KnjcpPzQrVo7RfreESFKrl/NxWHAEFmezKJp4VxzueRiBC9J+14HGQhkzKPw/tGRrDAqGF1QnCgWsWjhUIzXNFFlCLgy3EIPdoPWY0XWR+FeRxEYSkVMG46mQ2g1QJwAHBZZyde3tPjUfLeMzyMfzp4MPQ8AL7cryhhtR1hNtDbLtAsy0JYaEDfi4qDbNwHeRzCFAe3/sm8aSLFeTMJdVAx/XMxjgzAj/U4Hv52+jqozgkhBH88MoLHCgUYlOIfR0dj124Bo86eMU3kNS1ccZC8Q/G96pTi+nweBduGQhq1rAxKfTk7xwraUhw2b1qP/QdGcced92Cgvw9nn3kaFEWBrmvoyXdjanoGt/30Lpxx2ilQBGHlV08+1WiAGl7K+ziOLbi87eI0Xo7HIQy6SqCr/gXj8WIRV/zqV/jYxo24jFlqZQhairKKggfOPBM1RjOXpBQvEihd4ygOMu70tjwOhACOExnq4lEc2HPyS9DHR0fxRLHYDAv4wNq1S7G2kmvIcE13N57lNlpzUfM8HSVyAUFlYSZuLQVxc/uPw4exaJoghKBH03BlVxdyLImNsIXc43FwQ00ExUGMGT5cq3ks77KNS5bj8NtnaJ6NQia4JbmhEKk4KEosrnwLgCJUjoUkQTAhUfCyLASAsOTZ9ZKCSXurVZ/XqGTb2FEs4q0XpfDoqIXHRy1ce6qGy7cpOFAjnjASsf8y3HvsyRJ88x06qKmgM0GgKgQfPXAAo4zu03Qc3NDb23ThB1EMhs0VcQ4EhSrVbBufPHiwoSRQiryq4t0jI8ipaoN8gV0nKCxEJmzrIetYlMdBVBz4NYJKwvJEyNR5jVI8WyphH6cIXpnzG+KiFAdxXLbqcRgxDGxLJvEMp2i1nePAjr3mZBU/eqIh9OoqcNVpre0lPOZY9XUeQWF6Isq2DYurAxPlUbh5Zgav6u1dluchSHEQ69bIhE43CV1M4BcpWGXvJ9DjEBJaVHUcfHR0FL8qFpFTVbx3ZKThySCOr30Jlqskw55KBTvLZXQqCrpVFUlKMWwYR9zjINa0cCmJE8yDdyYL8U0K9OFx0Hz+kOToOIpDWlHw9qEhLFgWejQNGUWBbduQZ4oefbSlOFxw3jm4486fwzRNfPlr/4NfPvYr/P5b3wQAOPGEbbjrnvswevAQ/uXfPoerr7wcgwP9KJXLeOTRx3HHnfcAAIYG+1fmSY5jVRAYqsT+j2slirsQBFoo3cU9wJUatZgTJoBWbNtnqRkK8FbwEJ/yyWIRvywUkNc0OetCBNz+iPIG8OwyiqQWhsnYH1zwRYrcpSpKcTglnUZ3OY2ZZBGODSw+7RVUKCF4aXc3zstmMVqt4ulyGSlK8UyphE5FQYYJbh2qii7mGUorCvZXq/g8V018azKJnKY1noO7dvP52P8pRfGwX0zW6yiwsCeDUh/1oc5Z5Sljr+nVNLxneBhJRUFWUXBCKgUiCT86Yz3w6N7G3wkNuPTEpfZEbSlpRWkW/kpIPAo8/v7AAfzR0JC3QBt7dso8YbKx74ayuf3VHWApHNJ1mI7jqR7+3t278U+bNuEbb/HWu9CIV3EQreEaCwdzBeO0Sj3MZT+ZnfVszi/O5YIVB4FjXQZxfIrkBa7Hoe44Pvrbd7GCZHE8DrJvNW7siBhkRQaLloWShOlJVqTShahEy+4dRDcpKiQJyXFRq64oTC8n2VQU/GX96jMocH/7PA7s2L97uYGkBkwsOrjhQgcpw++NbDxE9IPOSmo5iB6rMLzpmWegEoLLu7rwAo7FSIabZmbw8p6e5SkOAed0KQp4xn+3z54oFvGPo6PNcT2g641cJ65PxcRdmXLSo2n4i7Vr8TdC4m8PW0dqjoNbZ2cxbVmYrNcxxXKv3GJps6aJH87MNOYZaexHV3Z1oWzbqNp2qEL6eKHQJIIAgIs7OvCJzZtjeSjaURzWSfZzWf8nKY0kthDxzwcPYkMi0ahDQwg+sHYtcpoWqjAjQJlw64q0Y4BcLbSlOAwO9OOKyy/Frbf/DACQTC7F0132gotw7y8egGla2LV7Lz7175+XXuP8c89qpwnHscoIDFVaYY+DizBeZ/e+stjzqI2UkAZXvZjfgIAKxiIu7OhAp6riy+Pj2Fetouo4eMfOnTg/m8WntmyJPF+EyizQYR4HyqyxbqCJmEwMieLhWp3vXVjAtycnUXMcX8iFCI0QnDQ9hO88XYFdo7AK3v5QaKPQllts66/27/cshB9etw7bk0l8aN06mGvX4rlyGesMAy947DGP5dNtq8pcs5CEKkFigf7+9LSPeYqHuxF1qipsx8GcZSFBadOypHA0quLY+eNrKP7lf20sVoA3X0qR1JfGXxyPw+VdXbiuuxuzk+P4WKmCAwFx5xpTpub5fAfu96DaFa5w6f4fZCnUCMHZ2axHcZg2TdwxN4eThUJ5qsDwI9vIMyxJHZK5Gxae8pwQCvT5sTH81/g4VBYe8YOTT/bdS7TkB+U4yMIKXMMFXyRvOR4H2W83zczAYArURR0d2JBI4CczM5i3LBiU4kQhz4Z/ig7hPcX1OCCgOFmcZ+HRLh0rJMnNsnaEehxEBYjN+t4sxSdvTMJxHOyvVpseJnFcGQqRskrxEI1AkNRUiILpUobHOLbOLNc8xms13DI7iwwzUnQqSrPGkYu8pmFrMolnhflxUjqNF3Z1NfKluDBTt36D6TioAEiZpk9xECFT7BRCsMYwcF0+j+l6HdOmial6vWGAcBxQAF8WGPf+c8ybh3rfwgLeNTQEQhwM6DreNDDg+b1m201FomLb6FJVdKiqTyh3jR6ysD0R7SgOm5NJnJZONxmbrs7l5N7lZYTGHa7VcJhb499t28hFhOgBQFkyJk1GHvK8VxwA4OUvvRqdnR24+Se3I81tSH29PXjNDa/EV7/+rcCY1DNOOwUXnn9uu004jlVEkOLgLrJxcxzieiaCFhV3Uwm6StTGSJj7fr+gOHQqSiwWlq2pFLamUjhQreJLnBV9uQlzcTwOKcYx7zKrKJKiOGJytetx2Fep4GcBFLk8NHZNhRDUZ/wFyiAQ4pAAS6sivJ950/SFSzTj9YM8DpwQt7NUwqF6HTXbDlUaICgOFdv20Ynyy7jY9pE8wf97g/wdZBUFr8jn8d2AIktpRQElBDa7f5iQk6IU2WUoDi7cX4M8DjqlOL+jA18VaHZlm5hPEZDMuU5VXVIcJB4JHlEKluk4MEMYYy7s6ECnokCnFAZX8NGFzV1HBE+n2vxuOR6HgHnsvtNnymUPdWOnomCLkIjaLG4XUOVdDDMM8jjEUhykZy7B53FYxjolMjrJPB9hY8GXHC3kOBBuHYBEWKQsnDMI25NJrJdYl0WPVRzEqRyNADa3sVoNP+HY7mSKw+mZDE7PZPCeXbs8tXMGdd1TS8KFL1eIUqgR8yxoL04rCl7FauXwsFm4aU5RMMv1mUxBdxzH5crw4e8PHPAoRL/T348X5XI+xcFlXpIZES/u6PDMr3YUB0II/m3LFvzX+DhSlOJMIT/IRRxiiyi47ynM0yZ+V7IsUFbD5jdGcQCry3DpxRegLGjP5597FoaHBnDr7Xdi1+49KBSK0HQdI8ODuODcs3HecW/Drx3cDUis4+BuekfD4yDbTKI2UsoUh1FBcRiOEabEYyU2ZESwubhIcQnh7sQVlzqRMcldrKMqK7twrbNhj+HZ75kVjEeW23RdRUCMv4XAIuSOH771vBJxy+ws7ovLxc/4w4MqLPOt9bcqGG5xultnZ6Vx02Lfh9WWeG1fn19J5J43ahNz+yuIRlEjxJdACwAHJR62KA8CXMYoSkOFdRdxEwyD5vbvDgxgT7ncZCMRQw34UKWgtvBW4CABSjZX3WOjZnGfpmGSE/jmLctjeeSvH0TkQAnxrB9Bb1wUPETF4b8nJvBksYg5y4LlODg/m/UJqu0mR8vaEZdVqW7buGt+3mekkYZccd+J4zCs0NhrenvxUoFVzkWYVT4IRgjrHw/ZGPRVjRbmaIeiBK7LQXWAxHmnx6ikHJe5SURe0zyKgwwl20Y2YJ6Lz+COmwVhD3AVB9n8FMdRuzUNEpTiBZ2doTloy/E4iHDfU5wcB8dxcPPsLL41OYmq4+A1vb24rqcnfPM9RrAiigNcGj0JJeKakWH87ptet1K3OY5jBQEehzhuR6yA4uDeJ+hukTkOTOE4JGz2ccKUeKzEhgzuOXXG9iTbkDKK4qt/ICtEx8NdrOMqDq4wEEKU4/nNkvRzJ8tbcEECQgjckBQ+V4N/Hn5xaqWwnkZIk79dC+hPm3Hey8LcopCRcPxD4u0Jqi3xws5OnJhKNapnU9oUiFoZO+6xGUWRPp/Grt2naR6L5qUSQgFxLgYJ2l2q6tv8ZedHeRxchM1RhTMIiD0d5nFw5we/DhGWMyK+D5FFR+HatC6R8P3Oo1vTkKLUk7gtctG7bekMUO7E9y3zko7Var6YfXEuPFIo4KdcFWEZo5zo9T9SoUo39PTgpd3d2FOpND2PXxgbk3o7oxSHVoTFJKW4d2EB35uaahYv3JBI4HV9fbh3GcyNcT0OsnVarAvEew8ThKBf17HAjKyy5OLmdUwTM6aJqm3jl8JY1CRFOGXPsBz0aBp2hhSTA4Dpej2QiUkcn+76I/ZLt6s4SNq51jDwW7kcyrYNlYVXHWmspOLAjwqZ4lCybXxtYgL/y3mmvjk5iSu6ukBW4VnbRVuKQ5kNLkPXPUXfjuP5i6g6DnEX+3aPa1rcW4hfdvGzuTksWBYWTRPfEOI54zAq8RAFz3Y9DmDCv0zQ7uAsl2IoEH8uj6ZlS7LBvX1wEDtKJdzFbepNqr2YioNMeBOrtSpCkjZYqI7CjRkqPJf4d5zCai50Sj2hIWlKpeFKtAUhl0dWVTHGCeMuRI+DqKx9cO1aDBsGcqq65GHhnnE5igMhBHlJe1xh/g+GhvBX+/bBYkrxpZKET5ESN2judCiK1IsSRc0bhEjFgUEUet3PrVhhdUpRC7GiXtvd7bEMhxXEApv3GwVGqx2C4qAQggRHoStC9JbKjnpE4mUTBW7xPBk1dLsF4Oq27etvURAE85QlKMU4NxceCPAUdkqsE/yztMKqlKQU86bpMQTRgAJwaUrx6t5efIELMRVhsDC5DYkEVEKwu1yWkiPI8sVEjwO/LnRrGlQ2JhYsK1QZu3N+Hl8X9icXKqt8TLhim2I/t1K/hEfU2AfLlwoyuogKy+1zc3imXPZ5912Pg2yPPy2TwTnZLBYsCwOaFuldiQMiYRfjsVKKgzj/ZEa7yXrdozSAkW/80a5dOCWdRo+m4cNr17bdniOFthSH9/3Zh0EIwbvf9TZs3rRh5Vp1HMcsXMVBnMfulJMt9p/dsgVve+45z7FxBeygzcMTqiRB2BLwzwcP4gC3iBFm4Zg2zViMSjxWLFSJ+ztFKeYkx5yUSoV6HDRCAkOVRKvHZZ2duLizE5QQj+KQiONxoI3rzdTrvs0AEosTIcQX35oOYYdyY7/572TUpEEQwwySioI5y4LpOChbFkq2jelaDdvT6eV5HGQc/JLn/uzmzTAJQc22UXUcdKsqdIGukH+qVjZH/thuTfMpDq4V76R0Gv+0aRNmTBOXdnZKrd9R9QVcUEKQk1gZRYthbMUh7DeuTUEeh8Cq1BIYhCDIf3B2JoO3DAxgDZejEBUqVrdtbEwmPYqDzNK8IYRhTbxDXC+AKJiJa45MwG23AJxGKbYkk81k905FwRlCkr0LcRx/fNMmlG0bRcvCJw4exES9jo2JBNbL8j6W63FQFI9nDUwQ7Nc0XJXL4RZOSPuLtWsjaZMNQpBVVfw1KyK6o1jE3x444DtONtaDPA4qIU2DRoeqYkpiHHKVwieKxUClAWzO/fnatThcq2HONGE7Dt74zDPeZ2gjVCkK0/V64Nop8yTJ9gl3LZFdRXeLqjnOiigNiBF+KFMcRFprCuD6nh5kFAVfHB+XVowWvwvK5ZKhZNu4f3Gx5ciH1UZbioOua6jV6kgkjn3XynGsDFzFwa5RWBUFhDroTJKm8CCzcogadyuWpECPA7vfX6xdi5Jt4xsTE55QgbCNUbz/u4aGcH5HB0Z0PVZiNI92LXkuCCFL1aMD2nBmNuvzOPBH6pT6wmWCQpXc9yUKX4mYHoeHFxfxR7t2SX93382+SgX3Ly7icLWKO4RQBb6diiDou7Hf/LtvxeMgCvDuvT564IBnjLx9cBAvCqkFEgRZ5W03Mbpu23hgYQFT1RrI3BwqjoNru7uR4xUl7jx+nLa6PbpUxLKNnicPyGsaNieTgSEz/NiLslLK5m5YqFKnkADuaX9Mj0PcUKUwpSesyJQpEU5e2NmJJFNok5Ti/sVFT1L+g4UC3ilJYv2rdeswVa+j5jjYGkHLLK5RcUd4lOJwJDwOYB6zvztwAGXbxh8PD8cOS00zwomZeh0Xd3aiT9NwQTYLOjvlO5ZvVyv7hFgkEixEjBKC3+7rwxhjv7kil8OaRMLH9iXCYMUc3Z7cmkrh05s34x07d3qOk4UjioqDu17wnsasosAgBP+0cSMqjH2o6jjoVFU4jhPZPrEeiswTGMQmFgWZl0bEdL0OG8D3pqbwZKmEBCFIKArOymSkYaViyCQ4j4NsvBosUbh1s87yITMWdKmq532emErh5awu0kOFQpOm1oUp1BgCgPeuWYPnymV8IqQI4ZmZDB7hwtHazek40mhLcejr7cXowUMYn5jEyPDQyrXqOI5ZuIrDzD3DAIC0ATz6V0sbqGyxFxf0ViZFlMfhhV1dqNg2dpZKXsWhhWu6AogqqYsQhJ/MzOBv9u/3Jd4tJ3bYRbN6dABryunpdPO53YnL309nFJ88SraNuuP4Njh3U/FxxLusMiEdSEk8xezJYhH/ILHSQRC+VUFxUCSCTiuKg2g50ijFWsPwMRBNMAGvVYjJjuC8EBaAT7v0heVGKOdlnZ2eTUn0rsj+jgM3T0dGydpUHAQBIwgqpTBte1lFt8IUh3cPD+MjAmd8854h9+KfKChUSYwvD1N6woQoU8KdviaRaDI/qRJaWbA8CBEnszlqOw7WSn7nESfHQTY6fYqD8LvMvvmBtWthM6+XoSgte1YB4MR0Gp/ftg1V25YqzzxkYSEuEx0ABN2dV+BaqRydpNRnHHFzqHp1He9bs8bz25Cm4d3Dw4HCnEEpulS1SeqgMg9Ej+ApkOU4iEQQroDMr2Gm4+B/Jicb4UpMaXjrwAB0SvGu554LVLZdiIoDJQTvGxnB/mq1cT3bXjZLkBhqCkHw355MNumsD1SreIrbd/s0Tao4iEoDuH6RjfFbZmbwwOIiipaFPxkZWbFQpTDIPA6digJ+B+NDy2Q0v6bj+MhaulQVm0LWAgLg/GzWozgsZx1eTbSlOFz2govwlf/+Jm7+yU9x0gnbj3sefgMgrpPi+JYt9qJw3YriEJgcLVrZhN9b8Ti4gk4rYUZWAFtHO5YCt3q0zOOwIZFARlWbi6wsx0EWqgSWZOenQmyc6TiOJ7k2QWmjrkKoxyFcwXL7N8xVLoYq8QsRldSnELn9wyDbuNKMT51H2bJasmg9WijgvycmfAn14J7HYJSSfG+LlY89ygLvcWhx7LjXkXkcXAt7FG2xC41ZDGWhSFEIUxziehV43L+wgC+Mj2Oejdt1iQQ+vmlT83f36j6PQ8i9TkqloFkmUkaiyefuoh5QdInPI5HlCA3qOnKccAmmLJ+aycR6l3E8DucIXg0liKaUg8yCu50J7MO67qsp0QpoTAU3Kp48qHf4GRpFSQxmqb2xtxczpolb57wBnq6gLhtnvbqO12Yy+N7UlKcqtwuDVSKfE2ikRS+LLMdhJsCyzq9LhBDcJNBKFy0LnSycUawqL0IVFAedUrymr88jxC8XOcn4+Kt166QGE1lydxxWtRSlzf1BNl6/zVFev3tkBK2vShKQcDpfmeKwNpGAw/pXJ8STAxmkOMgU9zByjw5F8Z3zvFYczj/3LNTrddz0o1vwdx/9Z7zkqitw6sknIpVqvXLucfx6QFwnxVj4BCHYlkw2KugSgmfLZXx43z7PMZdEVOTkEeVxAFs8W2E3EsMW6stQHIK2tHbSq9xnesfgIN45NATTcbC7XMZTpRI6VVVaHE2MCZZttvOW5a/ayo57cXc3XtzdDdtxkFEU9DKayahQpbAwBfc5whZLXsER37ECwBG+E0OwwhCU5CYqZGH0jjIULEuqNIB7HpcpiVcqxcq1gTkOLbVmaaydm83i3oUFj9DgvoNm4baIsT2k68v2lgXNJ0Qo0kHzbcY08SCX6CkeFRSqFBaO9OF163Dv3t3I9Q3groUF/AdX1EoWqsTflwSEglBCsFFgX3qyVMKp6XQsxSFOjkOfruP1fX346sQEFAB/LkmYFPs4bFS3K47QCAV3zjTxXLmMveUy6uwZT5XQAgfmprHvdcaEFYW8qmJ9IoE/e+op329NxUH4XmXx807IWpEkBBqlyAgx7uJaJWNrE4ktulW1YVAQ8tFcD7MLVzmNk6TbpA0+AgJmh6r6FL8504yvOMSom8GHTYbNWwANT+gK1FiI6qnzOzpwZiaDquOgxHLhhnU90Gglqw8iy3FAxF7Yqaq+fJHndajSd3/wYwDAGaefil8+9it85b+/CUIIujo70dGRgRYzG/7d73pbO804jlWELcwKUXHIqiq+dsIJ2Fkuo+44+OH0tCfJ67xsFn/FEs7i4OxsFl/ctg1vFhK/fB6HFpKUxXOtZSgOQRvfcpOjwVNJEgKTfebd++5cogGKg8uuYQgWUpnHwRXETcdB2bZhOw56NA0pRYFuWZHJ0UELG09pGeZxCAt1oIRAEd5nKx6HoI1XvGerikNY0u9GPrFWUBzE+wTlOCw3VCmtKL64ZFewSLFaFlGjsp0Qu6D5hCiPQ8D34vsT+285oUrgvKMyFijZmc0q3SHP4VMcikU4vb2xcgjEvTHo/b9nZAQXdnSgS1GwXZKQLJ63nIT/uCCSucnjiWIR7+Zyn/Kqik9s3uy/TsD57rMkKIUW4bnoVBRolKJTUbA1mcTTQjiZu8bxY7tm27AJQdG2QULGvbtWdLaoOMxbli85PRcQvpOg1GO1dtfoOBZ713DDt2al3rtrgOIJLWZNE2skx4qKQ5LR4H5nyp+/woMPh7qxtxdnZjIYr9WwaFn49OHDnmP/z65deFEuh1dLitatJFRCoCoKUgFeFx6W4/g8yQ/1BIsAAP9JSURBVHAVB1ldKUJwfU8PdEJw+9ycJ3SrQ1GkRVSPZbSlONx+x12+7xzHwezcHGbnZLwwx/HrDlFxkI3vXxWL+O+JCWhskvCQuXbDYFAqjbkUPQ6Duo7zslnYbMPYLqkp4kK2+Lc6EY6U4tCtqsgqis99ToXjZKFKKgvxySgKqpzVa15C+3fr3Bw+NzbWjPE/OZXCRzduBJq0lsHtpCSeJyhuqJL/+v5rtxKvG3Ss6LVYKcUhRSmu5za1lKIAXP8/XiyiT9ebXOS8wNhOqBL/lEHWd8LC147kNhRGx7ocj4OYzyIqvUEeh6jNlgQct69axXt27cJpmQz+Py4Wnvc4vKa3F9/ihCG3+qyY5+AWgVspj4OLwRDiBl9ydNhNV0AgaSUMdNo08WSxiCSlSCoKMpQiq6qBSpJ7bYMpvG8ZGIBCCP5dECav7+nBK3p6mh6Q0zIZn+LgrgN8r71/zx6P0BaU++IqDl8aH8fhWg2m48CS5C+IQv6sEKakMOWjFcVBDHWSQSMEjxcKuGl6GtOmiZJlYVsqhau7uyPPjYMuVfUoDjJ6cAQUJ9yUSODqXA4/nZsLzCHjPQ7DhoFhw8BTpZKPthssCbnVwqwytDvyP3rgAHaVyzBCwrGCPA4A8AqWVD1nmh4q1q7fNI/DcfzmIcrjAJZIeIvAUexCFiscBdkk5SeW4zg4PZPBqek0NEJwQgBNoAtxc/vG5GTL7DpBYmw7ioPLAiJTrkQFQZYc7Vr704qCaW4BXjBN3wKfURTPol627aaw06AMDW5nXMVBRsvnIiz0SJEIXnEKwG1OJKBwlIe+e7bpcQiy6JVsGxYLzYPEYn773BweLRTwL8zy6gk54/5udeTwfXRmJoO8qsJ0HCQoxXaO0SerKLGrOS8HYZWjw9S9oM1RVPxiexxCxkjFtvHe2QUYC0UfNTAAPFMu+8L8mldjfP5v6OvDNyYn0atpeBUTAkQvVsm24cT0HrXCqkRZ7owMcViVVhKhSe2S3/6OI0jYkkziQ+vWBRte2P8JxqpzGVuXf7Gw4MlN4XN3CCOOEGvyuEIo3z9i+946OIiLOjrwuqef9nzvjoX/mZwMrTz9nakpPFks4vyODpzf0dEIC+TQxdZ0mRe0LIzDecuCGpBPI0IjBLsrFXyHywUo2vaKKg58pW+xDo4LmceBEII39Pfj9X19eKhQkCagBzE3BbIoroAg3e4VCpaFgm1Li3+6EHMcqraNA9VqoyghIUhQ6kt8v2dhAfcIRQqf1zkOx0OMfvPgrmnJdQsgmg3VAL49WcEFHR1Npg5xQeSxHBabAV3HX6xZg7LjIMkEY3czePWOHdjFVbn8o6GhSMVBJmD8ye7duPmUU2JXKF5O/Yi415QtkmJIkoyO1a2HcBWruJlWFORVFedks56YbrDqoDzKzHUPZoWL8jhEVfQGgP4QLuqoUCUijJM4cb//Z2QEXaqKwQDrVLuKQ1ioUoElNga1lfe+eMKT2ghV4o+/pLOzmTu0zjA8oV1pIexgpTFkGNieTMJmY3eAvfeJWg2fESzFPIKUbLH/qqyokttX7lvrVlWckk6jzsZuGHNJ2bZRBVAN6Qcxb4cPDQSA3xsc9AlmsrCq1zz1FHRCcH1vL/5oeDjwfuIaEualCMstEMeNqDjYjoNFywIFsMjGRVqoJ7JSiBJ4EpIQGx7uMxqUeuZbUFgaYQrViGTOu15nMbeAh+U40vyVTEhxMh6LloWHCgU8VCigV9N8ioPL5CbzvooKyWcPH8bL8nkMSOqyiNAk+WyygnzLhRiqMx3QnrDK14R50ONcHxEhgceCBV5WyE2EGKo0Vqt5cjwJgBNCoiFcPK8Vhy2bN65cS47j1wLuppQ9cQZqtrGY/O0B4J82bmwqDmEFT2SLdBRSioLTMxlUWBx+bwjzS5yrT0oWwcu7umIrDThCHgcXRJI4J7InUW7jBFuQKFMoLuW8JwYh6NN13zsRF/QSpzg0rh/cvjCPA/99B6Oh4xW7V/f24p2Dg6FUi7Lk6Djvxh1bQYuaT3FocaOVeRze2NeHjKp6BAMZdSzffv7X5RaACzveFzsfwLa1Unhjfz9u6OnBXiG8bsGy8GwIH33cHAewTdv1RLgj+axsFmcx1qEBxnAUhDhFmETPCQn4n4dsXNYY/XHUWhc0DoKOjetxEEd1wbLwLqH+wK2nnOKjJ14JRAl47rulhEjXaoXN36hcgqfLZWwsl9GpKE2l6o39/fgvVg06r6o4l42NsNoQnzl8GN+dmsKQruOl3d2oOg7qtt1sZ9DznJxKeYr/AcA3JyexXlBec5LE6DBkFQVvGRzE/w2gMH5xLochXcdZmYzvvR9gIXduuNBbBwdj3VOGfl3HkK43ySBun5trhh1f0tGBadPEBR0dPu+IOB9kc/KDa9fiRInwTIBA9qRjweMQ5Qk6K5NBXtM8oUqismGwiuFROBYUpTA8r0OVdu/Ziy995RuYmm7Qnr3htTfggvPOjn3+zt17cP8DD2P3nn2Ym5tH3TSRTCTQ19eLbVs24aILzkUuFxzisnPXHnz8k59pqc09PXn81V/8aUvnrCaaoUrEO4l4YSXMkrscjwO7QaOKpPD1ctz0sqqMbuhBXMg2gq9v3x6reE4caKLiEJA74G6KCvF+duFe46RUCt21GmosBlOMGZ0zTTywsIDTMhkMGQYTouR9SalccfibdeuwUSh6dUYm41Ecni2VpOwcnuvLchziKA4RSe5ixed2PQ7nZrN4sSQ0QOpxiJHX0KrHIUjYlD39Ed+IJNeXhUd1KAquyOUwqGmBdQ5kileJUxxkyYdRT/cjgfpSBnFMN+lYQ+6RohSDuo4kpdjNjXPE6PMgz5MMhJBgCtOINVA2yo+EtwExnjkVw+PgVonn34cYvvnA4iIeYMxbJ6dSeP/atbiyqwtDuo7Jeh2XdHQ0x4vbd06AJXe8XsdlnZ14AWdwcZXIQBIIyfe7KxWckclgUyKBGdPEnGmiW1VjrV0u0pTipd3deGRxEQ8XCr76B1flcjgrm0VWUbBDoBUGVy8hKFwzLl6Wz+Nl+Tz+9eBB/IJjOAOAu1lYjYwGWlQcOiUMTQalPo83XMUhIoStLZBwOlYZipaFr09MoOY4UoOji7WGgc9u3QoI+SAyj8xCQL4Ij7jFFY8WnpeKg2VZ+NHNt+LW2++EvQwLd7lSwVe+9k388vEnfL8VikUU9hSxe89e3HbHnbj+umtxyUXny68TUf3x1xFLioP3e35if4FZfWQ4XKvh82Nj+N2BgVj3q9k2niyVMFqtomRZSCsKru7ubi7o4vSKsyycnE57BImrczn0tljiXdx4OxQFW2K4IOPCx9XO/S0KoQSAm/4qsz46joM/W7u2uamsNQyMS2hF/2LfPvzJyAhe19cHLcTlQAmRegzWJRLYJvTBmZmMJ6n02XLZkw8QdH0RCUFZMij1sVq4Ft6ga8tClZwAKk4ZxOU+MEY/yuMg5KW4aCfHwfN9i9dZCcjuKQp7OVXFJ1mex+ZEInBzTEiEHl7Jk63oUc/8gCD8yCCGMDavKXj3eCQVpUkq8KlDh3AfF6scJUTzTxmpZIS876gCcDJjypESS6JCLJoeB4lnxAWvOLqe17AcnTSnIJzMwlRFwVlh1wkac2K7tQiPQ1A46VXd3biKGRMsx4HpOKEkESIIo6F988AAXmfb+G2BTbDGeYbD6ly0cs8whFnHD0nqX4iKg0IIOlk9DBdB9NCEkAZrl2RsHC2Pg+04uGN+PvI4fm/hR6pPcSAEZ2SzmLMszNbrvoR+F8c9DquMsbFxfPEr38CB0UZCDqW0JeWhbpr45L99Dvv2jwIAOjqyuOySi7Bp03oYuo7p6Vk88NAjeOxXT6JeN/H1b34XhmHg3LPP8F2rVF6yQF15+aU495wzI++vrpDF+kjBVRzEcd1KmMUjhQJ+N+axM6aJtz77rOe7S7u6moumKCTKrJEifqu7Gw8tLuKe+XmcnE7j1b29LU8E8fiVTkgUNzK+f8VNgXCCgEzoNtkG5oKGsBq5SommBL/PoBwHWSjPGQKHe8m2sbNc9ikYPGT0od2qiptOOgnTptm89+8/+6wnTjjS4yA8s8Pcz2FJ3DzE5wuM0Zf0bTIgVIm3hi63AJyIY0ZxCCvQFvKsCa5PXPBhZcvxOMTZAYLmXJjHgUerzChiDZYwkJDk6H5dx0mpVLOQ3ZBgBJGtTEfL4+DOjbD7yxSHMzMZDNfrKFgWdgghQjIPlXh9hSn+gSGW3DX0GO9FNvf7BCu6m4sWN3yVF7o1QlAnxEetXeW87pkQWSFODYw4kBU5c3FYYnyShe7lBMVhzjSlY5mwfyohxwzLUFzLP19clF+fKsJzjNXruHt+HmXbxqVdXXhNX5+vzhWe7zkOxxru/vkv8O3v3YR63QSlFC958YswMTWFBx96NPY1brn1p02lId+dw/ve8wfIcsLPmpFhnH7aybj5Jz/FTT++BQDwne//EGecfgo0MW68tKRN9vX1YGgwnpX9WEZzHgihSq24EluZFLJjTdsGXCuT8Ntnxsawp1rFmZkMXhXA+5xRFPy/jRtxuFptskW0mpvgq9ba0tnRkBVFC7p3Y3Nq/C2b0D7FISTm3VVKwjaeoBwHmSO3T4iVBavAHKY4UElYBiUEOVX1MFK8KJeD5TiNYlHM/R22oMmUpbJtx85tiUv/KRNkeGVCJtQsZ/wEKg5HYdORtSVMcQhroVtEj/cotetxiKPYi2OeCv9H3aOVStaAnykt6tig931dTw+u6+nBrnJZGgoqe/YjlfESlruEGKFKEITPv9m3D0+WSk2ay5d2d/sUB1nfSaluHSeQfvXu+XlkFQW24+D1fX2h13a/F/PQ3tTfLz02SEn6szVrPIxTfzoy0vzbHTs6pZ6Eft7jEJa3tFIeh7CEa9Hj6/YJFeZoTlWxh/s8U6/L66awMS5jljpaHoc4CtjVuRzewL37sBwHAE1WpgqXSyPiWPc4HNuBVC3izrvvRb1uIt+dwx//4dvxW1dfAUriP6Jt27j7nl80P7/x9Td6lAYeL77iMuS7cwCAxcUCdu7a7TuGD1VKJp8f1bSDQpVaEVZamRSyYz10j5Lfb5mdxROS+E8RYTR9rZyLI1B0KczjIIIy9y4km5TjOKjatqfPqEubJ7mWu+EYER4HmVcgqA9OF1iuHuEKZskQZKUT39Gre3txbjaL/dUq9ler+O7UlCcsSoSMAlZW/TMIPitYwHGyzSAphFrxkClKcXAshSrFyXGIqzhA0oelCMUhqj6BbGS+UKhgHxSqdCx4HMJClaJwLOU48KFKQeCf02LjyO1Z2bogexaZcQUhFuRFy8I3JifxvelpzzFBz2MLxhiEeHGD1olr83m8JJfDOsPAy/J5vIAbj+59/2RkBB9Ztw7/sGEDPr5xIzYnkx4SiyCjx0ooDg5j44oL13MblSA9Z5qBioNLDCJiNRQH2e+UkEgDgOv1dj0N/HwLI2UoW5bUyHRqOo3Nx7i8+LzyOADA2WeejtfccN2yBPXpmVlQhYJSinQqhU0bgyscU0qxceN6TM806hWMjU3ihG1bPceUnteKw/I9DnHCiVzIJu0rduzAz08/HQijRY2x0PAbVMseB+HzSnscRMtdWP9SIcfhV8UiPnnwIOpsc+vXNE/1VspYPtKK4nNFNz0OYTkOtNF3GiEeC2cQXemmZBLg6no8tLgYmuegBLw/2eYxXa97KveKYRo8NEqRU9VmESeNEEzX61IqRxnE5+Pbn+Is5FGKg4+/P4BhJgqtJEcfSTxVKuHmmRlM1OuwHAc5VcV1PT1+xaEFYSYpFNErC5szAPx0bg67ymVozBt1cWcnLhaUARcypTbKQ9BcH4SQpSAsJ7zCjeeOEk7CkqObxwR8v5qKQ9wch7hKkGjxjStAimuLO1eiLMh1x/Ek0AbdT0wYRkhtmqC+NijFmwcGmvPEEEKVAMgFSO56GUqlwulKhCqVbTuUglqEqzAkBG+heI0nSyXp+3c9DhqlgLAvrYYFXtzP+O/Dcmxc45PjzkE+VClMceAIH3h8ZP16rDGMZeXnrhaeV4rDDa98GbZt9Ze3j4venjz+7iN/Adu2Ua1WIxc3hS699Lok497jcQjhGP91QlCOQysbUSvTQbYROYL1XIY4ioDHCtxmqFLdcbCnUkGPqkayBsWBuFBGehzYz+6I5BfuuiTHAWzTERUH12pEQ5OjG/9/bONG7K1UMF6vNyu9TtfrPraNSzo78clDh7zPE3j14LFECEHVtlG0LOiUQpcs9FGWttf19mLesrA5mcT6RKKlDSkoVIkw6tkSC8eShiqFWFqXG6p0rHgc9lQq+MrERPPzWsPAdT09jZBCDq14HMQ+LLFxyl9xR7HoEeCyihKoOFzU0YGnhETEoNoAYhub30aMlVYrWcN9h47TVqhS81oB369qqFLcHIeY15Plc4kImlOeY7jQnyj84+go/nHTJqBFgTUV4HEI21sULsTT4wEX2vkPBw7gYLUKlRCkKMW7h4fxgq4uZBQFUxKWnpXwOMRhItuUSKBTVVGx7WZCumg4EefyRFCoEkuOPloeB0oIFFYhnIcuIeLg8UihgC+NjSGjKDi3owOncR72KMXBkIR2heWVHCt4XikO7SgNPCilsTwEk1xYRHe3n5aVz3FIJp9fioM4C/ml4fcGBvA5oeAYj1bCeiKZSdoQnsQkvFbQp2l419AQPsUJxK/asQN/OjKCG7kY2eUiiBpSBuqhZfUvvNOmic8ePtzMBRjUdbx9cLDhWhcUXnfDiarjAAAXdnbikUKhKTT+JxPQ/mWzdx6uTSRwdS6Hm2dnQQC8bXBw2RbPBxcXQ4uKBcUwu3jjwACeWybbWZBgqBPioXrdnEziRFXFDm5DT1DaOF6W2CspeBcHx0pytDhW3X4SlbodpRLewCr0Duk6rs3n8bYArnlR+HDDAfgN1ucxCBGWbuztxdcmJlBi53xo3Tr8iKu6KztfzG0IuvqDi4vYVS77GFLieFjcpN04ydG/DqFKsVmVYt5fnM8yy6+sX2R5RIhpieeLuMXdFxKU4gmmyHarKrpVFcOGge2pVLi3mFsT+L1M7MdZ0/S0y/XABeaqLeP9imfcynmJ+evy+Qev7+vDViFfTZy7V3d345bZ2eY4vLKrKzTHQdb2FfE4RFxDBWBLErPjjJlbWY0LnVKcGlNxqNg2CCFICZ7/44rD8xgTk1PYvaeRDa8oii9MCQDKHKuSoii465778NivnsTBQ4dRKpWhaSpyXV3YsnkjLrno/F+L5OmlOeWdXPxC/ZaBAZRtG7sqFVzb3Y0/37vXc2wr1tWozTLo1zgeBMqSMJdTlC6vafjdgQH8bG4OT3LJeitRAM4F7yIN22j5nAAaYLG5k6OU0wjBO4aGpJtOK4oDYoZnqADePDCAK1g8r1jrIS5+VSx66C5liLK0tWNpPTWdRlZRmhSL65gXUaO08Y+9L9kYSFDa3JhkbTKXs9GHeGZWE+LG6gr0Ye79Q7VaKJ/5mZkMkkzZMijFejeczHFw38IC7ltY8OXKhG3wXaqKv+3M4kHNwLpEAi/L5/F9IR8mKFRJlhzNU0b+slDwzC8XcYQdV3BcCY9DEE+96HE4cqUA4+c4xB2hoodAFjojq1kgfuPOyTiWeL6/4gqsaUqxs1zG3dw4ODOTwQmpVKS3WNZm8b5BYXVBlKzL8ThkFAW8Ki179g5V9dQzmJeEFInrX17T8McjI7htdhb9uo5X9fSEhip956ST8PqnnvIo4qsRqqS4uYKi4tBCX4qVo8OqTY/X63iiWERa8PwfVxyep3AcB1//5nebA+SiC85FOu1nieFzHD768X/F4qJ3o7MsC4fHxnF4bBx3//wXuPyyi3Hdtb8FegwX/wgMVeL+1ijF6/v6MG2aGJQUehFp69pBkKAetwfTlLaV2CxuyitpyfMoDiHHEWHTibI2GVwsqu+3pgISfD7/WxwmGUIIelQVpuM0q4svBx8fHcVjEUnvURsmkVB9xsWlXV24lP29MZFoFvxyBdY0pU2WrrpwB9fjIBOVKSGgyxiDMpFhtb0NCPE4RMVHhynZfzA8jIPVapNHfiNT0p4olTxePh5RG3yvQnFVLtesExE3VEmW45CgtOkFCWRGCW1NA4rrMYyjOAQc80SxiJ/MzmLWNFG3beQ1DS/N55u/i6LLkfI2gD2HGHrBIxUSsieDOJ9l4TOv6e1tMtW4kOURya4nAy+2xRVYp00T3xU8WDlVjXyvTVILQeFXhXXKZ6BhzxHkcWhF2HWRpBRJXpGRtL1TUTyKg6j8B1XJPiOT8VBzB3kc3D5YTthfFGKFKkm+byVfxOQS+RGjYv2+SsXn+T+uODxP8a3v3oRnnt0JAOjO5fDSl7xYehyvOCwuFrBu7Rqcf+5ZGBkehKqqmJyaxsOPPIbHfvUkHMfB7XfcjWq1hte++pWx2nE0kmcsi91TrBztOJ72OOwzBXBNLocfcW7PrKK03Xb3/KDlkcbsH4MJbcttj7jAtXMtEQp/rZDrEsdpxMmz36PUMp0Q2LYtFfI19zqhQt9SW2QLvKydWUox4Tht9U+cCqyJgPt74Dht191QHAewbdiui9u2m/e2bRs14fK6G44keX7CrFQt94vknLjjfiUhbiJ11q4oT15kW7nns1hf/2dImJoScj2b0Vjatg1Qij/dtcvjKYRs7LJ36bD/wV2fsHXDDKkDEuddODHnhLi+8thZKuGrXI7JRsPAb+Vyzc/WKo+Rr2/fjul6HfurVfzd6KjnN4P1cZOBJqIdQUaQYV1H2bbxmt5eDOs6ni6VPAKb2F+Evcc4JiubO7cdAalLUULfG7A0xhXJukUdB3OmiZJt+6oWq+y8TMCaqHF9m1WUWOxIlFJkKWnO2xd1duJbnDK01jB8Ho550/S0W3XrZrH5GvjYkt8dd021bZyaTqNLVZskGnlVbXvM8vNYBuo4IJJjWqGPN20bJneNKMUhQ6nvHS6yPhXXnGMJK6I4lMtl3PuLB7Ft62aMDA/5fn/40cdw+x134/DYODRNxYb163D1lZdjw/q1K3H7VYPjOPjWd2/Cz+76OQAgYRh421veKPU2AICmqshmM6CE4MVXXo7LLrnQ8/vaNSM464zT8MBDj+K/vvoNOI6De+69H6eefCJOOnF7ZHvGD+5foSeLj/k5A0DGp77PTo5hnEsKnrFszNg2EoqCxZLXSlwrLGD8YHTZ9UA4TvPZ6xV5vHq5sBirf2zHwRxr53JQExb04twMxivRVLBxMGvZmHOtmqqCYsACNmvb6CIEk4cbm3Sp6i/Mw0OzbYwf3I+zHQv3CL8tTByGQikWZnUAWen504dHUU80tunFgvdZzXIxsN8t28Z0O960aiXyEKdaiXzvs6YJs0323AlVwbxloe40Kh3XaIPTfcZsbNBifH91bgazxUXU4fjG2qxto+I4MFocgxZ3PxeUwDMPVwOLwhyoWxZmJsawWArPJalErAPTloV55uJMqgqShOC5EI9TZW4W49VS4O8EwNzUBCqE+ELe+ihFdmHOM3crrH+JQmGxcTtTb7TXpAQ1p3GMU/FX0AWA4uw0xkvhFatn2RgaV8PffRgLWUG4f82sY2ZiKcdsTrAKUzhHdO9IMaupWffelwAoTo6jRAi6VAWUW7OCUC/K3+f/SRrQCEF/rYzxg/sxa5pL+XcAplTFY8EvOw7mLAunAnh3JoVPFILHSa1Wa/ZPulZFH6WYWIbwRktFzI2boe92mq3xBiG+4xZMC18qlvCLmp94ZXF6EuOLc8hUyhigFGNC+2oLc5gpN8ayqlDM2zasiDUvoShIE4LJqQk4AM6wHdxMCAqOAwrgxSrFk3Xv3jKxuIAZa6l9ikJBKMVcxBqbVRWfQD5tWdBB4CgUN8JGUW/0R5+iAAuzGF/w51y0gmnLwqId3CiqUJgOmnuuC1IP3095FEpFTI0fQpHdp1CTrw0uaosL0IX182MHDyJfWMCpekPNjZojRwNt7zB79x3AZz73RRSKRbz21a/0KQ43/+Sn+OH//qT5uV6v48kdT+Opp5/F7/3OG3DKySe224RVQbVaw5e++nU89viTAIBUKol3/N7vYM2IX1Fy8aEPvC/Wtc89+wzs338AdzCF5LY77oqlOPQPr77ilT5UA1CHWB6jt28Q/VzsulKvA/U6+g0Dyv79ACfMdnZ0oX+ghXyOScE9TUjz2ZO1PUDNH1+czXagfyj43fBImSY6lyls0YWnPNRxue4e9HPWvnagmyYoY+oZSCSCObtrNVQnx9A7OAJKKQYLBWBhZ+B1k5qG/uG1uLxWwz/v2OH5bWRoDTKKgu55E4B80esfHkFHgqBi26jW9gGc4NKRzqJ/eI30vD7HaSv+vtPcB9TCN4+udCZyXpQqFZQsC6O1GnaWy9hXreLNfX0tta0/mUS9VkPBsjCcSDRDAyrlMiqWhXfZNoxcHiZzgZ+ZycBiNTX6hXAtwzRRtCzf91FwHAfzQkKuSohnHq4GpkolYG5JQLYJQXffAJSxMUAi9LjoyHaiPyA5GgBovd5YRwD0GAYyioLXqQb+JcDrkO/Oo7+7W/qbbdsoHNyPrp4+ZDUNxmIRJU6g/uCGDTgv61WUq7aNUqWCPk1DNwuvnCuVYAPIs9C7ectCfn4eqIz77tmT70V/AMtTE7VagzK5jRC+7tlZYHFJ4SGKiu6+pfV1qlwGCnweFj3ie4dTqwH1Oj7WY6Js2yhbFqqOgzxLHO1PJDB5eLS5ZgWh69AhoOw3GPT2DYASgn5dR1ZVMV8uN8N5CIABIWG3YtuwqlVsSiZxjuPg3x9/3FfV18UF3d3oHx4GAPwVMzS8d/duPF4KVjZk6OvKoa+rK/TdKvU6aL2OtKL4jrOqVWQPHwZqc77z+vsG0J9O412OgyvLZbxj585m6BwA9OTy6GZ9MGQYSJumLx9BxICuY2H8ENYODGHRttEN4B96LfyqWMSwrmNdIoGJqSmACxer6oZnrA0bRoPmO6AYYfNeyaQv/MiqVmFQirymoWhZmDfN5jteCVjVKrSQPhjQddQdB1QQ5NP1g4C5NL9emc9jWNfxXxMT/hyPRBLd/UMw2PdmcQ9gBSudfbluKKaJh8a960ehowu9uVysObKSWNwZLDfwaEtxqFSr+Ox/fgkFZgWaEbLwDx0ew49uvnXpZqoCQzdQLJVg2za+/N/fxIc/8KdIpY7tGgdzc/P4zH98EQdGG7G1uVwX3vm231nRZObLXnBRU3HYtXsvarUa9IgJc1RyIUgj8tKx4VEeVEo97XE/K5T66M004djlwD3/FT09OK+jA//AVeCEG2sb8x4dmrbsuF9xSRD7oR0YitK8Vth1E6qKKusTSmmk5dpgx8nsKElVbcR6hjyDqlBQSvD7zz7rq+K6Eu82CDKaUxFJrs+CULBtvHPXLo8b+dp8Hn0tbFCKokBXFFDmKXCVjoSqouY4yFCKbsMApbShiOk65k0TpmRcqpRCdZxl9Zt4TivjfqUgKrR19iz9hoGtySSeDWCxiporCv87e66wiuNGxLunIM01yZeXIelLlX2ncNd154WqKFABLDqOlIbz9wcHsSGZjHwXqqJAWea7b15DeBZHfBaRYWgVxgilFLqioD9gLXLvTyPGgGwt0wiByr53341CaTP8SZW8Sw2A5h7rOIGJ+zoheOPAgOd8SineMjiIsm3jqVIJXxr3K4kyZFU1coy766Vs3TQUJTAnoznW2djx0VJzY9ZQFHQQgsWI8Eyd9WlWVVFkSnUnpbi4a4kxskswsD1YKOA/xseRV1Vcm88jwfYPVVF8dMw8KKV+5itKl+QGxwEoXdGxqlAamkumKUqjP8XaRsIYrDsOzuvsxHmdnfju1BS+zZEsmG4YI2vze0ZGULJtVFg42j+Nji4xYlGKE9JpnJxO4+6FBQ/bn86Nh6g5cjTQluLwi/sfwgJL+L3y8kvx4he90PP7bT+9y5NAfMMrXwZVVfGrJ5/Cf37xKyiVyrj/wYfxwksvbqcZRxQHRg/iM5/7IubmG67t9evW4G1veRM6O+RhHMtFT08eyWQS5XIZlmVhbn4Bfb09K3qPlUDDA0dw+FtbADg4bQ3FTe9M+5KK3CWBSIqntBIzGAWXt/3OuTkPp3srisBymJBm63W8+dlnMVr1WuVXkrGEF8jCrOFifwZ5JsTjRcYHhfstTnK0NEfiCCZeRj0XAE9yXxByzFrMo7iMUASdFcHj340sJttttRKQfEcJiaQKDIKYiHo0kqNFznmHhQC+LJ/Hy/J5/M2+fT6qUsRMCHbhPmMmxDMYlcTo/kwl47Que/+SpGj3b4Vrv5h7k1PVQJpZEWJS7HLgq2Iv/D6k6/ijoSHYAHo1bVmJsyuJVu4uW0/49+z+xV8zqJJ0s58cB9fm8w0GNPZbTlUxZ5q4sKMDPRLyDrc2TRhTmIiMokSPcfa7lIktRHHga8g4bK7VbBtV5tXkBXyNECgRxiTCtSGszd2ahj5Nw3S93hxnd83PQwFwfU9P831F7YPSO7C19OHFReyrVBpEE46DCzo7cUKIwSA2YiSqy3YBcQzySprYV6bjeK7Bk4HkVRVDGzbg7w4cQN1x8Lq+PiSYchSHZORYQluKwxM7Gpzc27dtwcuvfYnnN8uy8NjjTwAAurtzePX1L28O3lNOOgEXnn8u7rrnPjz51DPHrOLw7HO78OnPfRE1Fi5yztln4PWveRW0IxRDrOtas2icGUJVeDTh3V8bi7F0kHMLm7gpH4kp4WMOOQL34OEAPqUBK0zHqjJqVZPFmAZBvGdQsqYLdzMSk1f5TSpMcXAvL2O6ONqKQ5xcFb5fXUgFRwGfOnQIs/U6VELQpaq4sbfXV3Vaxt3vfqMGMI7EotoMACXEk+h9NLYbmcBed5ymEhU0J8KYUu6dn8f/TE1h0TRhOg62JpP4wLp1oV6nyOrL7H8qYZ2RMavJaFhdylNKSPNdi4pDuQUlNIjJpRWIY0pM/O9QVZzb0QEA2JxItFTBe7kIexOt3F02tvh3R4X/EaA48PVtFErxqt5eAECPpqFX07C3UkHZtqUCEX+1Vta3jKJEGrB4o4KIFCtyKYPbDre+xyt65EZGhR2jsHEaNDb5+4e9n7OzWZydzeKBhQX8C8du1q1pnrU3ShmW3YOw7786MeGhN3aAlVEcIqAQ4pEj3HW5X9exIZFo1kEa4DzT4ngxhcrjPAiAM7JZ/P3Gjc3v3Pe7nKrzRxNtScCHxxouu3PPPtP3285de1BlAve5Z53h03hP2L4Vd91zX/Maxxp27tqDf/vsF5oVoX/r6itwzdVXHrH72baNIpcIluaKiBxLEHOLggRMfpPeJwjYYbGPy2/XkaNFlSGQBnaF75ukFIuW1ZJCEtfjcEo6ja9v3455y0LNcbCOWxDDbudWqV5tj0MsVqUYxxCm7PKR01HUoQCwq1zGBBf/ek0+7xNApRs9J0DLWkcDvo8D8byjsd3I3rnpOHBVqqBNMExgPlSreTjx+euSADrdKIG4qQhIjB3SwmLC//zflJDmu04Ke1vFtkOTmXkoKyAkiP0YqraskkBSsCzsqVQwUathsl7Hlblc0zDRiodF9k49HgdOgG4WUgu4lmxuiu84qL5Asz0tKg5RAlbT4yD5TSEE6YAxHeZd4+cH396MogQqDvwYjLOHzQiGzW5V9Vwj0uMQ0M+yytFx1uY4iHoqUXHQmYHI9ZwGncPDEjwOnvtL1nnXW/sb5XEostyGnrw/GfTZ53Y1/z75pBN8v3d1NiwgpRYTjlYD4+OT+Pf//BLq9ToIIXjNDa/AxRee19I1ntu1G888sxMzs7M48YRtOPvM00OP37d/tOll6OjIrngo1EpBnMNRigMIwXtHRvD+PXvgsAXmVQHWkSCcm83iAS4M6cWS5GNxaTmSRY4QsriutC8qIRSHiQOVUk+BKhH8Bm5QijSANIDhxFJ1cyVEBgsNVTqC1sw4SkGciqkyYS3O5iRahRKc8OhCFgbS9DgEKJwKli/Q+e52FDacIMXBRaDiENJWsR+rjoNF04TFBCAZvWRkqBL7XxaqJDNmuHM8LFRJCci9Kdl2YHEu8R7tCgliP7ZLNdwuKraNVz/1lOe70zIZrGHeuSPhceCPClqbPQqH46DOeV2bln/JectRHJSQmgY8wkKVACAdEN3At0MMV0xSipJLJ8v1VZeqYrpelwq2rQj9ADAtJBDnNc1z3nLC71wLv7hefHZsDNfm823VAMIyFAeV0kafmWZgiJosVClo9lHJ2HTf45GoW3Ek0Zac4zDzsyF5oc/ubCgOiUQC69aO+M9l/WSFZJwfDZimif/80ldRYlSCN7zyZS0rDQAwOTmF//3J7QCAfQdGcebpp4YmuNxx5xIx5ikSRetYQVyPA+9CviKXw98D2FOp4CXd3ehoMdRrUEhazUrOX2MYzcVSX0EmhiAELa5HwuPQqijuuuWDCtvxm07QAh8nx0FaJfpIehxiCGJxCjzJqmvHiV0WF/cEpT5lRpNYlcIs3WjT40AIgc6ee9GyjniIngwyZdEMiQOO+h4SBbBm25g2zVA++qjYfd6qLL6Hv96/H+dlsxiU7GX8HOE9DmDPLvOEFS0rluKwEh4Hcc0JMzOshjiSoBTdquqxSu8qlzGgadAobUmoPCmd9hRbhDA2xOreCFmbNUpx7/w8/mT37qai2K9p+PEpp3g9FxweLRRw/8ICZljInJgcHIQMI0yIWwAu6DhZVWxwCkHFtvGdqSkULAtl20bJsvCna5ZY7fhxrhKCbk3DVN3PdNaqx2Fa8DjkVdXTd2EjP/DqbB2UzYd5y0I8jsRl3Jd/D9x3OgsD69E0fHDvXjxXLsOgFAYheHF3Ny7s6JArDkGhSpLxEKQ4PK89DolEAsVSyVcRuVQqYe++BsvNlk0bpAvFYqFxjmEcWQGvVdxy2x04eKhB93feOWfhUqH2Qlycdcbp+P5NN6NQLGJsbALf/M4PcOOrrpMee+fd9+LhRx8DAKiqihe/6LI2nuDIQlQcAse3YK3bmkxi2DCQW0Z+iE8blxzz6t5e2EzQXs9Zzo8UghbXlcxxANuEW1VGVLb4VgMWMCMiRhgxcxxkAuMRzXGIce3uGONLkbQzTvVwWRyqTGgU+4Vf/2R9FhTCFAcaIRjUdSxYFhYt65gKVXKxUh6Hsm3jn0dHA5WHVnIcZPeW0XNS0ePg5ji47SRE6gkrxvQSqi0K0jK04nFYrfExoOsexeE/xsZwqFbD6/r6WhrrW5JJXJvP4xMHDza/k3oceKE1xONACfF4l1yDAT82eNy3sID/HFuqiSEasYLgVnSOG7ITqDhEeBwIgG9xrD5g3i6DUpiO45sTeVXFXL3uq2Cvxug/HqLHobsFj0PQ+w8KVRLbdyTg7rGUq9jt9l2HomC6XveEqV7IxrZMcViwLPzRrl1ND7NKCD6yfj2G2NjhPUQ6IRir1XyhX89rj0Nvbx7FfSU8t2s3tm/b0vz+/gcfbWpdQfUI9u5rFFjJcVRf7WBxsdBURniUOTaP+fkFHDo85vldURT09zUSpYrFEn56x93N788/9yzf8UHgrwOmEL3uxuvxuS98GY7j4K577sOevftxyUXnoa+3F7quY3JyCg88/CieZEnmAPC6V78SPT3yeLpjAQ4AUBvJ4SIcAOVuip/O1XFxR4dnQRctc0T4vhW8qqcHp6TTmKrX0a1pOIHjqf/E6Ch+MDODOqtEeWVXFz60fn07jxgLQRvCSodIKSycqBVolOK6nh5YjgOVEHx9ctIjyHk8DsL/ze8DXhQhS5vCscaq1KEoeEGM9WTZHgfhc5D1VAyviBPqsFyFs1/XoRICza1ovKyrtAeNEPQzSmPXYkgAfGtyEiXbxr1CsTUXYXNF7EM3pCToPQ3peuT4CFKSg+4JmeLgfs+O1ZliL4aLvPqpp/Djk0+O9HyuxHzx5TgIfeSw8IkjnffFY1DXfVTNrpLdqpIsGo50rr/jJke73wfltlDuGB7iOnG4Fq8YWJopDlF9LrN08wiqDO2OVYNSH9FD2bLQqaooWJbveSkhyGmavxK1eFxErozocejRtLY9DiSEKGIlBOlQj4OgOPFKF5UY4dw9WZYcXXMcX8Vo3qvM961KKcoSIpx2jQlHGm0pDls2b8LefQdwx533YM3IME7cvhV79x1o1m5QKMXpp57sO69cqeD+Bx4GAGkY03Jw1z334ce33BZ6zE0/vgU3/fgWz3fduRz++kPvBxhLVIUl8lqWhU986rOx789fx8Vpp56Et775Dfja/3wbxWIJB0YP4mvf+I70/FQqidff+Cqcfpq/v44l2A5ANRu5CxoK1QSA9+0GbjvlFKnisPQFkX8fA6dmMliXSOBQrYYtQuGYkm17KqMGWdlXGqvlcQAQmCAXBJUQ/FZ3dzPW8mCthjvmlooI8YoICXgvQR4Hhft+1VmVIkI/4ibdyxSH5eQ4BG1mogAa5+0td2N0z2v2+1HYcCgh+PEpp2B/peKhtb1nfh5TIexwrXgc3PcjUxyuyuXwtxs2RLaTMIUmaFMOSmyXKQ4Kd04Xo80UE09XK9PA53EQfn9gcRGfZAw4CoCNySS+fsKRDYeVWebdXJBWhSKR8cxgyprNFZSMK7SK42rRsvC+3bvxnpGGHOJLXl3mfGp6HNrMcZApw6/q6fG0S1y7PrB3L766fTsKAe2XXdOnOAhsbTzuW1jwVSPvVtX4OQ4Bv7lzU3builjg2TVUQuA4jiekj2+7yoxEfH6ISF3u7qFJRUEv87YYlGLEMKR7icqH1ZGlRH6NkOZY4SEqHsca2lIcLjz/HPz0jrtQq9XxH1/4iu/3c885E5mMlx1o3/5RfOu7N2FmtiHInHHaKe00YUVhH4GXdfppJ2Prlk24/8GH8eSOp3FobBzFYgmEAKlUCsNDgzhx+zZccN7ZSCTaS/5ZDTiOXPoXBWnRctD8dZkLQJBlXFxwg+ILVxoyYfA9w8PYeATCpGQFpqKgc1aSLkXBGsNA3bbhCEV8ms/h2zjk1+W/FxfzEV3H+Yz28UggilWpZttwYlSnlsXRRikOjuPETmAThZM4glK7CmfTOtbWVdqD+ARB3oEBTcMVuRw2hVS49uU4uIqDZI0Oy3uQtTGojwKpdAUPHa98pBQFHYqCfk3DXoE9brXCDWTMLjz4HrNWKXl6SKI4LNfjII4jnSWlB9UvCbPyywwbjxeLsT0OcZBgRR8R0wMdRJoAiZBPAbx/zZrQNWXaNJvnRdXBaLZB+E6ReFhd3CYU+gVLjo6rvAWGKoWEbK7kXFJZUTe+6rOHjpYJ9m4/7SmXcUjwNLmKwxmZDC7IZlF3HPTpOjoVBT+TsMGpvMeBXZ+w72WKQxx68KOJ9kKVevJ4xcuvwbe+e5Pvt8GBflx/3bW+7//n29/Dvv2jAIBtWzbhxBO2tdOEJq55yZW45iXt0aVecN7ZuOC8s1ekPTxSqSReeOnFx2y9ilZgOw5AghlImgiw1C13+gedLy40qzXdXG5sXmQ5O5uVJm63izhsQiI0SlFlC+P1vb24nvGWb0wkvB4H9r8/xyHI3c/dQzjmrGz2iCalR/WDzYSMKHad5YQq2RILcpB3xRceEHrlBtrdGPmCUEcLojAj9ulfrl2LbakUEoRgQ4jSAInyVQ8IVepUFJzUAsc7DbBoIoSuUzSA8Nu8+64/s2ULrn7iCc+5q5XgGLUGrjZVNQBpknliuR4HUXFww8O47+OEKiFEkA4KY2t1Xp6STuP/W7Om4Q2J+axiAUUe4ppnMyNH1NhqhtLE9AqrnBUcglVchMzIkmZMfi7CnjsqVEmGlQxVUpiwHqQ4uDln7ney8DTesEEJAWHhgE5AvpzCrTu8txIsd29Y13GQ3UcnBGdmj01WTRdtSzmXveAiDA70466f34ex8QnomoZtWzbjxVe8UGpBHxkewr79o9i+dTN+902vb/f2x7HKsB2500Cc8OKi2a7iEBTqJG4Sq0lESAXmomPJRhC0sfjeU4uhSvxlxXusFN92EDYlEvj69u2YNU3olKJm23jHzp2eY6q2HcmuI0uOjmq77PegPhZzUuKM+XY9Dm4hsaOqOAif26kYL3ocXEu5eM13DQ3h1BZq3rTqcSCCAQQBFJvS8IRVUhwSlGJI16Xc/TgKxTEBYFBSfdn1GrV6/yFdx2npNEzHgeU4WJ9INCzi/P7C/R0m1ATWcpCEPKGFd6iyJHmXwIHGYFQKa5MLWX5bxbYjaa91xv4jrZfAcj34uaQJoUlhHgOZ51cMMVpOjgOVzTeGI6E4EE5e4NsrFrWVvQMfwQhTtGzJWuDSsIpeLb6I3x+PjOCDe/eiatv4w+FhZBTliETArBRWxDy6betmbNu6Odax551zJs447RRPMvVx/PrAjhmqRITDVszjEGHNvX1uDv/vwAFcncvh1ExmmXeLB/HecZh5VgtBm5HsPaEFxSHM4xAnwbgd6JRi0DCaLnSdEFzS2QmF/ZZVlFib9XJyHGTvNkgQVkVv2yoJkBohRyXHwQV/Z0ci5LeShyETjOos8dB3XAvP7CoO6xIJPCyQacg2QzE5mgZYtI+m4rApmcRNJ5+Mw7WaL/YcEo/DkcjDEtEjURwGOFaZuDhQqeBL4+Oo2DZMFi745e3bcbhWC/Q4hPW7zLrPh8iIAm+cd7jWMKQ5NnEDTMMUapmXtWLbiGOPloXAuNA5xUE67kPadE0+jye4xPcLWXgqf7ew84MpwEPe2woqDpQp/2lKUWDCOT8nVOGdyN4P/15c75frcQgKaRW9+/xYfGFXFz6/bRu6VBW9krlzrGHl4yoisHHDkWe8OY4jB9uGNFRJXKJ8OQ5thlIEWikkk/obk5PYmkweccVBEdy5R7vwEo8gi5QvJMn9Q1QoAjqcLwwn3mM1FCf+jhlFwR8PDzfrd3QpSqx8kOUUgGtVMBQLNK0GVEqPGY+DLOvAHS9x2igr5Gc6ji/2VwuwUAaBMuXqunwe3+FoLAOts/DnOMhGmExpXm1KxaC7HQ2Pg0IIrujqwm2MlGFE17GJ5X+1pEgTgnGBAajuOL6Qs7iKQxBzlozWNepaLjoDwlPjKmhh3oO0ouCv169H0bKgE4IOVW2plkToPd0icbI+CWn7SakULunowN0LCxjSdVzHqioHvQ8RQVcOW7lXOscBADKqigILD+KflxLieSeynUEXntX1XjjMKyZruyc5WjIWjRUoBrlaOGKKQ6VaRbVaAyUEhqFDP8IFuY5jdRCUHO3bDAJyHNpNjhaxWoXYpPeWhFMcK/jYgQP4xeIi6o4D07bxip4eXN3d7XtPsgJKWGZy9JH2OEDcnBg7huy3qGscyVAlCONytbYCWfG51cIPpqexp1zGomXBdByp0t7KpigLN6vYtm+OfW9qChsTCYwYBl7f3x95XdfjIHouggQTMXSCBIwzWXjCalj24+BoeBwIgDf292NjMomSZeEFnZ2Ba00YZIJ+jdXRkBmmlIh1ICpUaTkeh1JAcn7cPShsXqiE4OKOjmb8e4pSn6JxSiqFX3EegLUsvyTMiML3g+wZQ5ObCcHvDw3hrYODjfkk6buwZw8af7JK7WFtbBXuFdz784qVmOMgO0/WVvfvpuIQ4nEQvVoyqtxjY8WIxoopDrv37MVDjzyGXbv3YmJyEvW612WaSCQwONCHbVs24+yzTsdAf99K3fo4VhG2I59I4kIjbrBE+L9VkBgT2PP9Mu/TCsR7zJombGYNO9qYtywPV3fFtqV9EvRegnMcln64pLMTpuOgaFkwKMVZmQwsxzmiggkV/raXadl/bW8vXpbPN2ogEBJZlVrmTQlLauRpa1czVOloeb2+PjGBZ7iaObKqya0kcMsUh5Ik5vehQgEPFQroUJRYioMbayxLuJWBiOOKECiSPo7LuHUkEdvjsBptY+EgL+jslPzUggIpUxxs21dt3T0qqt+loUptehx2cVWtPedGntlAFJnDA4uL+NShQ42aPoRgSzKJD3O1it48MID37t7dtIz/yUg0xb1HcZCxicV4bp+AHXMtjlIcZFgRQVWw+GuEIMPClfjriwU5t6dSSFHaXH9yqtosZDtvmvjp7CxKtt0s9tYvhBopguIg5jg0jzvKOWqtoO33US6X8aWvfANPcEXMZKhUKtizdz/27N2PW267AxecdzZeff3LoR4BFprjOHJo5DhEsyqJgn67ioPowWjeN+Dw1dgcX9Ldja9PTjY/v2/3bvzw5JNjVxc9khA3o29OTYESgoHFRVzW2Ym1LGyguWEK5ysBHcsrFFuSSbzx6aeb1tv/BPCV7dtxQgssN62Cb6fI/NGKQNJvGC1xZcuoCcOEClHBWQ1ohKAa47gjAVHwFmsaAMC7uET2k1IpfICxLEmvJ+nbIMsuWvBmuAmYYshTYE6QZB2TjbMnhGJncWuKrCSCekCkqF6N8Rj2Nlq5vyyMp+Y4vtCypjU3YhxIQ5VWgFXpC2NjyChK89952SxoTNkmauwuWBb2c1S/4sjanEziQ+vW4bFCASen07hYoqz57sn1qyykaTljJLbHIeJ72ZkraXzhx0gnC1fi26vCGxmhU4rfHxzEpw8fBmWeNPf4BcvC58fHPdd/z/Cw53NQqJI4tn9jPA62beOTn/4P7D9wUPq7qipwnEYxNR6O4+DeXzyImdk5/MHb39JOE45jlSFLjg6yZIuWOrShOLTqcVjpCs4y/P7goEdxwNFIGgqAzIL6DdbWNYbRVBxkBZQQElEmeiJW29IqCguOxKsVBwYhkNsJ5dAJwQUdHTAdB8RxoFIa+q75bIPV9DgcDYEVEuFHpjjweLJUClXcFEJwdibT6G/mFQrrRbGSbRDcdUmaZC07XhBQfesaw+NCovWxBLGXVytUKQjthirVbRtJVZWGKkWtP7JnJ/Bbo13EWc9OTKVwO1dgEwDOyWZjG6+i1gdLmCeyKs+bk0lsTiZjFwvVuf1Yds5yDG+yWk6yGR7lcbiquxvfFPKPVgJNrxT3XVZRoEjqOIhtfFFXF86SUKTK5AxxbRE9GK4xQvYejya5RStoS8655977m0qDqio475yzcOrJJ2JoaABdXEyjbduYnZvHocNjePxXT+LBhx+FaVp4+pnncP8DD+O8c89amac5jiMOmcdBtsi4SYgujlSo0nLcnisFWfjKsRCmhAgrlhHjvQRWjuZWQIvRz8W970pA5GvnraktCSSUAi0UDstrGt41NAQwC90aCU89D4UsWQZXa0SolIIeJQq/VhUHxBBg/33rVoxWq80Cb+MSPvVW4TKqtOJxED/L5riMsnG1ULYsfGNyEoumiUXbhuU4uDafb7bJV8dhFdoU9mZbUaRl68lDhQKu7OrysV1hmYYLXhls1eNgEIK8hAXHIGTFjEhRtMY+L2wMUNa+BKuJIaJVw1uQUU8WOhlZTVv4vFLGKPcq/PMSQtApVL3WJJTLQf0qa1tNouiJ+5ZsXP/GeBwefvQxgOUvvPtdb8OakSHpcZRS5LtzyHfncMpJJ+CSi87HJz71WVSrNdz/0CPHFYdfIziSOg6BCcrc300BdZmLAG8VCrpHnO9XEjKx81hJiAwT4DWRg1qqOAQpZEt/y5KhV1VxENz27cZOx0WcMyk3PlYzVGm1vBuye/NYCcUBwtqyEsn37vUeETwEuwPi1GWFLWVz4+R0Gt+bnm67fctB2bbxyUOHPN9dmcstKQ7C8b9OHgfZeH66VMJVuZzXExTT4yBtj4Rj30XQ9T6wdi32Vyo4I5PBe3bvlrZ7peaiOJd8njruPq0I/BpX4VpEqwYw2VX4ZGAr4lgeSUpxWjqNomWBEILUCinl7hOJ4z+nqj7SDRFBLZDNparohRfGsRISMndsSA/RaEtxGBufAABcefmlgUqDDGvXjOCKF74AP7r5Nhw8dLidJhzHKkMWqhSHl7ndCdFqqNLR8jisRohUHIQVQWvH48B369GgoBQXeH4LbdnjsNw2xDiG3yxX0wvVjkLU1n2F/gzLR3ARZ/Ph3/dKKA7uu3iJEA7xklxOeryM9EE2x1/a3Y3PHDqEKRYy9eYYidorBZnwwlt6RcXhaAsnKyFQLzc5WobNyeRSqJLwW9B8OiWViszlWqm94N8Oe2WkpzkSAizT4wD2bCulOMjeqZuDllKUptcQMRTXrakUPr9tGw5Uq+jTtBX35olPHGcvCBqzUsVBUOx8oUqESBPSf52So9t6I1WWsLNl88aWz3ULxlWrRyud7ziWA9txfKFKUclOkNAatowWk6NXQ4Bfjht2tRDX4xCU4xCHjtWUWJVXg4e66XJuIwm5bFnYX6lgV7mMZ0ol7AuwOIfdPwxHq6LC0VIcjpTHgX+nfZqGdw8P452Dg8tqIzjB8tR0Gq/s6QEADOs6fndgQH5/SViITKjSKMWXtm/HDT09+PM1a5phbasBWXv43heTo1dljQq5x0qIgSLtaiuhSld2dXk+D+p6YKjS6ZkMvrJtm+/ecQtNrgaWqzhkFSUwt6fV/TPM45AWlJO44y/IWLhcuCFpy1FcW/E4rDUM3NDTg1fk83hZPo+LOzt9YXW/0aFKmUwGc3PzoMvQCF02pcwRLtJ1HCsLGR1rHKt/u4tA0PmnptN428AAPjs2FqtNKwlZOuaxkuMQJkAakg03rseB//5n8/O+31dDcXDDgHwLbQv3vmV2Fh8dHW1+PjGVwp+vXRvr3FiKA1lq62oirJjUkYQosBEAI4YB07YxJhTwchFHgOA3+bSi4ByWoPi5sbFleSCazC2E4M/WrMEre3rQo2mB1VrjehwAoF/T8PKeHmxIJFZ1HZBt4laIx+Fo5jgkCIEu5Ca1CoNST7VntBiqJCavGty1ZELlGsPAX65dC8txQAD06XrMNWB1xgDfD60I/GEF4lbM48BqTxAurPRoKQ6QJD3HPzXA4yD5btgwfHVsRE+5bH9W8BuSHD00OIC5uXlMTU1j/bo1LZ07OdmIBx0eWr716DhWH7YD1GYSOPy9jSDEwXWnq/jwSxPSY0VX8hFRHDIZnJrJ4FtTU5jhmFVWY3P8wJ49vu+OFY9DmPvV43EQ/m9+H3A6nxwt87iE1TZYKRDmAm/H49BqATihAZGHuBvK0UuZXV2IG+HGZBJvZOE6TxeL+JsDB3zntJrjwOOUdNqXpxAHimDMQMS65PM4hMSuu8Lsar/zKI/Daek0MooC4jjI6zpGVoEuOsg7PGwYIC0qDhd1dODnCwvNz6/t7YUSMPfjKA7nd3QgoyhYYNWYN7JQpaCxllKUJm1wghBsSCaxt1LxUEHLsGphqxHx+cGnBR+7Uh4HwtYGhZDmGhv32keCZWi57yRoTsvGm5Q0RWhDkMfh6HDitY62FIfzzz0LO556Bvfcdz/OPuv0ls6974GHAADnnXNmO004jlWG4wBwCJyaAgdAwlYDrXUr7XEIw9EocvSsEGuKYyjHITarkhuqJBwTpwBcq/ddKfCJjHSZrEqiZT7Kev1sqYQfzcxAZcl6G5NJvDMkHCXMgvl8hKio8swiSlA4RETffHV8HE+Vy1gwTdQdB5d2duI0Zsl7c3+/R3H4/9bEM1wpkrEfNm7E38I8Du71V/udR+U4bEwmsTGZhMqKh60GZD0woOvLyi1619AQDlSrmK7X8fq+PgwxRjMPhSb7P44y+ureXrykuxvjtVojv4EJe4EKoeeDfL3ksdpzn7/LSu0/hKuGHPd4EZQVrCOsMJrJjD2x+2WFQ3dIG4Y9UfC3Wd/IriczQomJ/LJ5EMRCdSyiLcXhzNNPxa+eeAoPPvwovvaNb+P6666FYYRbM2zbxg9+eDOefuY5nH7ayTjz9FPbacJxrDJsYVwHCZgQcxzQnvUg6nwf5eAqLNqyKX6shCq1zKq0jBwH2fOvhuLExyPLmFXioFWPw5Rp4mFOUB2t1eIpDrFb9OsNkQueZ34JGotRm8/dCwt4cHGx+XlrMonT2N9rEwn8+Zo1uG9hASekUriB5StEIZDHPwBxcxz466+2x0E2544OKe8SZD2UiqjOHoQtyST+dsMGAMAQ5y0RlcBWjBZE4rEIap1YxwPC852RyeBRbm14BRuLK7UWviyfxw84xq5rurs9v/PPvZL7jyIJx6XsPRYE8oMgj4Ob2Oxa5lsR3OkKr5/tKA5iqBFlxibZXJfRQojHydpxrBgd46AtxcGyLFz/ipcil+vET277GX75+BM447RTsXH9WuTz3UgkDCiKglqthumZWezfP4pHfvk4ZmbncO7ZZ+DqF78IM7OzoffoDmC7OI6jg1YUB88i1qb1ICq5WhT7flNCRIJwpFiV+O9l/OWrYWVrhioJHodW7iyG1kQpDq0WujtaYStHC2ICJJ8cLfdHRgs54jvivUIKgBPTaZyYTqNLUWKPO3FzjgqHkBW1ChM+1KPwzt2xxisLMsvlqiqxKygY8Vfi+1acg60oDqJQ2ip9Kn/ky/N5PF0qoWzb6FFVvIglX6+UEP+7AwO4a24Oc5aFLlX1JfLza/1KKg4uK5KLFKUYMQzUbNunOAR5HNx35AqarYyBdqMUZFhu//jySAhpKA6cN8VFVKhSWNviVxY6umhLcXj3ez/g+VwqlfHz++7Hz++7P/LcBx56FA889GjoMYQQfPKf/q6dJh7HCqMlxYH7eyUWgbDJN6zrWGS8z5RxQR9ptJPgd6QRtonqMlYl4Zg4isMlnZ3oVtVmbsmlnZ1ttTkugjwO7YQqRSkO4mYQR0g5GmErRwuiNbkcw+MQZf0TFYeqbcN2FUbBKBEXvgrpEePGp2hE3Es9Su9cDHM42gKIrAeWK7SRgHctKg6tMIoRyViQCUNl28YtMzMYrVZhsbH3e4ODnnM3J5P4hw0bcLhWw8ZEAklFWVHlcY1h4B82bsS+SgWnZTJYn/DmFPKGoJUqOgeJ4pBVFCgBCcYyhUDh1tnleBxWWnEgbfSPz+PAhTnGURzirgkr+f6OJI7pdh7LgtlvKsRXQkI0h5XMcUDE5PvbDRtQsm3kVBUDq5D8d6wjrBKujAHHJ1AFdLXCfa8Sgs9u3YpPjI6iQ1Xx3pGRFWh5NNwm+DwObYQqReU4iIpFXMXhN8bjEBKqFJQwH6k4COfdND2N701PNwooUYpT02n84fDwESFdcCEKu1FtXg1yABnEsJKj7XEQ79VuGAZhXmX+uuK7aIVRTObBlr3bsmXhr/fv93z3qt5e37ndmoZuzgO70iGrnYqCE9Np5FS/yOZWInYt4CsF8Z0lmXFA5m2Vrb2EECRcj8NyFIcVVsLbCVXy1WFwFQfubxffnJzERL0Olf12XjYbSPfsa+OviaGpbVYlw9BBGT3acTz/YTsANUyonTXAAeYMFTuKFk5Mp33H8ovYSsQryraFu+fn8S8HD6Jq2zAdB2sTCXxmy5Y27/Trjw2JBF7X24tfFovYUSo1v5cmZck2+qBEQeH0DYkE3jk0hASl6JBsakcCPBXjclmVWg1VEq1IcdhbVjpG91hGSlGgME9fglKMVqv41uQkNEKwEFAMLmq0iIWfLO7/MpvvaLePWwyhjBI8VoMcQAZFsA4fazkO7coHTQrmkGNaDVWKE3cum+dvePppfFmo7SBixePV2fsNekLDVRxW8Jai4S/BCctECA+WPa9GSFOZU7hz4+JI9OFKhSqp3PfiGJkxTUxwFNTbksnnnXzc1k7/53/6f1auJcfxawHbAfT/n73zDo+iWv/4d3Y3u5veG0nohA6hhN4VCwhSFBWxd712Ue/Prlev3Wu9eO2KYkNBepfeQy8JIQkhkN43m60zvz+yu2yZ7W2yeT/Pw8Nmyjlnzply3vO2JBUSxrZls9wL4GKJDMv697c51uLBZxivQ6vxvRSVej2KzJJ3yYO04ic0siMi8ER4OJbV1uKk2YoZnyaCb/XNXjfyKZj8YYvqCJHZB8hahewq7jpHu+vjgA5mqjQpNhZ/DxqEcxoNAODnqiosM3Po5MNdUyVrjGPoTQ+7mxDK2QfT35nT7WF975trHJZUVWFrY6PJdGRGQgL+kZHh1/b4Q+PAV6457poqWX+PXBUcnLUDftA4OAu2IBWJIGJZn75vzMdMbrU4LDEIKkb46jU3F7b2dXAFf7w7feUcba5xiBKLoWVZiA3brYX2UNQ8C9pUiRAeLAebzNH2HopAmCpZv6ADadzWKzwcp81Csg7m0boEE+PKfIJEAh3HQcdxNk6ssDM2rvg4mFUU0MQ19jQO7uCuj4PHgoOH7WtvMAwDxqxPrZNsWXNZXJzbpkrWGMfQn6ZKNscLVeNg9be5hqzV3JlVr0eLC1m9vcU2Spt3/WIMiODoPeOuqZL10XzPNK9ZjtX1hVlNouGH1XJTbXauXyYS+V5YMSvP2mfQWnDg9XHg8UdxN6qSL2G8mPBaaxxMGhQAy/v3R71WiwadDmEiEd45fx4VhgUUGP2evGy70CDBgXALa+douPhR8IXgwPcisd4WyDjICWFhgJngMMkQTUNIZEdE4KOePQFDZtsEnkhIfKuu7ggOwdQ4mDupuQOfqRLnIJa7J87RobbK5AzzHmm1mpzenJKC2UlJUBkizyS74IfkbAXZtN+LCRPj43EKqqmSGY4iLAXjvvSVxsFR293R9vC9szzVOFhPouGH1XKj4OTIVMnXwor5dz2CR3CwaZ8DPBIcfN2HXoyLhdm1lcahrfC25G2cYYHOnFDUPJPgQLhF2+TKcpsrH6JAaRwCadtrfd180RSCjXmYRnv9zzc29t5zfC/zoAgOVvW7Oxnim+DpOM7uxM9T52g2xD4YjjC/UqWVX0OUWOx01dQaax8Ha4yCg1caBx9ry4KVxyVSLIbaIKxZm0bwmU4EAsZMA+xtv/g6LwrfYgnfZMheu60FB2v8pXFwaKrk43G1MFWy0lRb30POrtfoF+FOG/0h4Hpz7xvvZ5FZZCmx1T7OjnY61BaRvBIc3nj7P5BKwyAWiyHyk235ow/d65dyCc9gWVtTJVceRn9pHKxfWBc1GnxZXo65ycm8ESh8ic0qnwAFB4sW2vsI8vk4CFjjwFg5uTmLxc8Hn1mDjuPs5hzw1FSpI2Heoy1WgkOMueDgIk41DkEwVRIqy/r3R7NOhzIzEwkjwdI4WAgOXhfmeMXd/eJsJ3OuPq/W9wzfIkKgfRzEhizNvsTkl8CTXM9djYPxHHe+yP7QOHgj0Bkd9MVm128ezpwzCOnWC4jk42DFxfIK37WEaBew1jHxXP3w+sk5mu/l8t/yclweH+93wcFG4+DX2jyDsfPbHL4II4IWHKyzknvwYuablDryc7DROLiwUCIGOpTGwfz5VlqZKpkLDq72iDMfB5nZR9tTfG2qJESsNQ6B0oqY1+K1j4Pxfz9qh9wNFWqEbxHB55NeF+71cA8zc9sjRiJBuEgENc970fqaXanZXg4Ie/j6ufTWZMg88ahDjYPVecHK7eJPyFSJcAs+5+hAaRxcMVUytcnLulzBUSSTYFOt1eKps2eh0OuhMdhdfmcnhCAD2xV7ITtH8yV+85Wpkj2shUKXfBxC0CnOEX83NKCgtRWtej1K1WqLfVESifuCQyA0DqE0Rnb6y/q9FIh3ozVCM1UCTz/4VOPgZdv46mz7Yb+N/kh6GiYS8WphrSeOrmoc3LkPfD3Z9lYDbOxdYznmAgGDtiRXZKrkAh+99waUra1Yt34ztmzbidjYGAzNGYSunbOQkBAPmUwKjuPQqlKhuroWRcUlOHL0BFpVKlw2aTzGjx0V0AkH4T0sT2ALl9KpB8g52kgwJHwh+ThwHIfjZvkb4GBi7JapEk+HB8NUSWx2Le6G1IQh78AXvXqhVquFzvByj3agofLIVKkDrGab815ZGarN4pebEyMWu/2ud6Zx8JVzdKh8g+xdhRA0DoEIx+ou3vSD+ZmB0Di4Ijg58wnyJZ5oHCQ8ydIcEQwB1xEmwcHwv8Twe2djI0rVatRqteAAFJkFTDEeTxoHM0QiEZavWIPdew9g0vgxuHbmNITZ+fj27N4No0cOx9xZM/Dz739i45ZtULa2Yv4Nc71pAhFgOB5TpUBFVRKaxsF6kvR1ZSUe8nN8dFfhM6VZXluL3OhoDI+OttjOJ9TZe9EJwVTJWlDwxFRJwjAYGh2N8yoVFC6Ep6RwrM6xjrxizoNnzliYPPSPiMD3ffo4LM+ZzbavfBxCXbjjeGyuA4GIuZSUzifhWH08IffmG2H+/uHrz0A7RwcaT3wc3PXBCFagAXuYmyrBTOPwXWUlDioUds8LRY2DV9dz5NgJ7N57ANm9euC6OTPtCg3myOUy3HbzDejaJQu79uzH4aPHvWkCEWA42JoquRRVyQeTKFeco03HBuClMycpyeLvPuHhfq/TVfjU519WVOC36mqb7fYmT3xCghAEB8Yq9KBX2iwX75NMmQz9IyLQOzwcfSMikO5COFFRCH4wHMGXI8SItZ30CSttGB9xEgl6yuXoLpejN8+z5Qsfh1DK7u2qxiFQ12s+ufT2OfBHm32hcRDbKScYPg6BxJOxDaRGxB9YaxzEhu+Qs0WkUBQcvNI47N57AAAwZmSuW+cxDIMJ40aj5Nx57N57ADmDBnjTDCKA8DlHu7yCFSDnaHvH+hq+6AlCwZ59OJ/5h72QlCLGNm+HEAQHPo2Dp/W7et7MxETMTEwEDEJEtAuOiB3NVMmR4OAJI2Ni8Eu/fjitVIID8ExRES6YRQ3yhcYBbtpdC5WtDQ0o12hQrdWCNWh0MmQyIIjhWM3r8YWPg69b7WmbzN839hYH/OXjIJQ71ajlZd3oR2emh0LHOO6MlcbBmeBAeRysKLtwEQCQkpLk9FhrUlNSAAAXDGUQ7QM+HwdXHwmv7VzdcEILxGTA+oPsjv2mv7HnvMsnUNib+ItFgM7qIoXiHO0rjYP1ec16PTbX16OFZXF5XBxSeDQLrtZlrRkJdeyZKvFl1nUHxqDptC7DVxqHUOCrigoLLc49aWmXBIcghWM1Fxy8fg78YPbnzeTHJDjYEcT85eMgJH8cCcNAw3Eu30/BSo7oK6y/OxLSOHiGwmDXpdVaB6Byjt4Q51vR0uJNE4gA42lUJfjAQcgtjUMAXlLWdu9CWrlkDLG3rSdbfKs+9ibefJcjhARw1pMIT/I4mIoy+31KqcRnFy+iXtf2Ptvd1IT/9Ohhc3+7U5OQhEl/E2VH4xAlFpv61BOMPWj3Xvaij4X0zHqDw8zRVscG6potzFl88O739eTL0zaZO7uaZ65nrY7xJUIzVYLxnjOz+Q91RFb3jNhFjYO70aTaA14JDnKZHApdC84UFqFH965unXumsAgAIJPKvGmCQ4qKS/Dd4l9QU1sHAFhw0/UYPXK4y+eXV1Riz76DOHW6AA2NjVCrNYiOikR6ehqG5gzEiOFDIXZRPe/LsoIJ38Khqw+F13aubjihBaInhRDm0BFSPsGBb+JvT93OJzjYGcRAmypZ53HwhHqtFtUaDer0emxtbMSK2lrL/TodStVqdJPLLbaT4MCPPY2D14KDYYJyY3IylCwLLcchVixGpmFFnTQOjrPY2zhHB6hN5pMLn+RxCFJ4zilxcdjc0GD6e3pCgoXGATyCgz+Sl0FggoPETGjqCFgnHnWkcbgiPh56Qxj0lDB7aUXbL14JDp06paHgzFls2Pw3+vfrjaxM1yLKXLhYjg2b/gYApKameNMEXvR6PVat3YANm7aCdSFiCh9r1m3EmvWbTZoRI/UNjahvaMTJU/nYsnUn7r5jAVKSHZtq+bKsYMNyACPyTPXt7QuG7/yEsDBMiI3FtsZGi+2BsCkUso8D7LzQ+AQHe+FMheocLbJKrObpfXV7QQHKrPINWNOq9y6tX6itNDkigmfhQ8IwLvmDOMLYg2NjY03b+oSHo1qrRa1O553gECLjY/3u+bW6Gs16Pa6KjxeGxsHLsoKZb+OO1FTkRkVBwbKIEIkwOCrKwsfB9L9ViGhf4o88Ft5iHF9n+VZCBesFK3sah2kJCZifcmle6+uM3kLAK8Ehd1gOCs6chVqtwXsffoYRw4di0IB+yMhIR1xsrMVkpKGxCRcvluPYiVPYs++Aybxp2JBB3l+FGRUVlfh28S84X3YBMISMdVd4WLthM1au2QAYokBNHD8GvXv1hFwuR01tLXbt2Y/T+Wdw4WI5Pln0FRY+9hCio6P8XpYQYDkOLcWxUF2MAhgOD02UYkF/17RG3k7m+c5Ok0qxMDPTRnAIxKran1Yr1HubmwNQq+tIRSLAauJr1zmaB6EKDtZ5HDy9r1z54PFlTQ29z4BvsDZVGhIVhSczM9FJKsWUo0c9LpffjI7xifmG0LSEnmItOChZFktralDQ2orxsbHoHR6OMJEIUSIR+kdEBLxN3i6qMEFc2e4XGYloiQQKvR4pYWFIDAuD0vBeNd4/5oID44+FKwGaKhnzMiS7EGEuFHBV42Btwiy0BUVf4JXgMGrEcOw/eBgFZ85Cp9Nj15792LVn/6XCJRIwjH0fiKzMTm1J4HzE9p17sHTZCmi1OohEIlx9xWWoqqnB/gOHXC6jsrIaqwwT/cjICDz56INITUk27e/SORPDhgzG0j9XYPPWHaitrcOyFWtwy/zr/VqWUGBZgNOIodO0vTKTIEOmzLUXh9caBzsPIN+acCBW1YpVKr/X4Q18E2O+bfZD2rq2zR9mBI4QAeB8sJrpirOexrDosLS6Go16PcQGLde1iYnoHaAJWHvB2lRJZeg7T50ilXo9vq2sRLVGg1aWhY7jcHNqKuSGenyxChsqGgd7z8Cxlhb8o1MnRIrFiDYz7woExgmTLyb8wQ6ba20qZBJaDf9brET7oX6hOkdnSKUdxhyTzzkaPIKD0C0RfIFXzzTDMHjgntsxMncY736dTmdXaBjQvy8efuAeiHwYomvr9l3QanVITIjH4w/fj2lXXQ4R4175azdsNmkoZs+cbjHRN2fWzGlITmoLz7jvQJ7Jj8JfZQkFV8Jz2sNf5kPWNrzoQHaXjuCbsPE6R9sZF1fNl/wR8cQRIp48Dp6Mt3X/XBYXZ3OM2vD87m1uxuaGBmxoaMAv1dUodWLi1BGxNlUymnl5+txrOQ5fVVTgr7o6bGhowJbGRrSyrIVduaECj9scKu8JR5MThZfmdp5isoH3wXs/0IsTDtthlccBVtfoD2FUiD4OsWIxr3liqGLtHG2EBAcPCAsLwy3zr8f/Pf0Yrrh8Erp0zoSMZwVaIpEgo1M6Jo4fgycffQD3330bIiJ8nzBr+NAc/HPho+jerYvb5+p0Ohw9fgIAEB4ejuHDcuweKxaLMWZUW/4KlmVx+Mgxv5UlJKzn6O4IDv76SAdL4yB0+IQEbzUOfN0aaFMlWI2vvTwUzrDOrp0pk9kkGjOaKlmrn9t7aEF/EGVH4+BpT/Hdv1qWtV319bB8hNB7wtHkpMUowAWwPfCxxsGT7PC+xNR3Vvccw3ON/mgnXz3BJtRyEzjD2lTJiDPBwSuzHoHis2vqlJ6GmdOvAqa3/a1SqaE2rMpJZVLIZTK/32jXz5mJ3tk9PT6/qPgcVKq2Nvfo1sVpJuzsXpfqOnEqH5dPmeiXsoSEtcbBnSH110tPBCBeIoGe48AZYr4HYh1kdmKihZ9DtoAyR8MHGgc+wUHMM4jBEBzMERkzmruJtRCl5zib/jGaKpHg4BwbjYO3ggNPH2s5ziaijVeCgxfnCglH77tgaRxgmGD4SuMgKFMlw/8dWePQ0bA2VTJiIzhY7Q9FjYPfhCG5XAa5PHD2lAC8EhoA4GJ5hel3ZmYnp8dnZqSDYRhwHIeLFyss9vmyLCHhjamSv1b3usjl+LFPH9TpdEiXShHnREjzFXelpWFzQwMa9XpIGQZPZ2UFpF5X4RUceM2P2pdztE39DAPGgwRj1v2j5TibCBgaQ7k2q0gh+DHwFuvM0UaNg6eTc7HBJM38Q/xMcTESJBJEisX4JjsbII0D4OQ6FEHSOMDMgdRbgv6Osf7bygzLwnTSD/eUSUgOkfu1PWJP62X9LdjV1IRqrdbkPP5qly5ICLGQrKGoRfGYyqpq0++EeFt7Z2skEgmio6PQ1NQMRUsLFC0tiIqM9HlZQoLlAJFcB5FMD3BAPcOhRssgyYUHwx+re3VaLZ4tLoaKZaHhOEgYBl/06oXwANhepstk+KVfP6yurcWo6Gj0Fth4jY2NxWGrBIt8Ggf3nKNtNwbb/tjaWdpVrAUHHY/GQc2yYDkOSqvIbHz92NGJtO47jsOOxkbEeyHIy0Qim76v0+nQoNOZPtje3HmhYqHtSJBVeBiS3BeIfZT8yjyKVlCwNlEy/G/ytzGPIOWX6klgCDb23vh8z96Z1la/tyeYkOBghkJxaZIVFeVaSNToqLbJvvF842Tfl2UJCY4DorLrEdWnLSHOdwBqLyTgla7OEwD64+Wn4zgcNGQwN98WKJLDwjAqJgadAxitxFXuTEvDL9XVqNFqTdv4Ykrbd452bVugnaOt8dhUyWqiq7OjcSjXaGwS6XUR4HgHmy5yOX7u0wf3nDmDZsMq96Lycgzw4j0m5REcjNtNJgBevFdCZULmSIz9vrISG+vrEcYwkIlEeDQjA6NiYgLSLrGPfBOCrXEwb4f5/yIrzQP8dE8J5fo7MvbyHTnTPstCcJGJBAcz1BqN6bcznwQjErPj1OpL5/uyLHt4mtzOG/QcZ/MGY1xtC8dZJO7yCTxCgpZlA9o3LMuC47igjAfM+p6vfolhBUxv9rer7eT3Z7C9To5lwVklZQskHMe19b+b9Vs/leVqtcVLXsIwYDkOxVarR8lhYYgTi+32o6PxCGUYAGGGMKrmRDMMesjlOGsWvriTVOpS/9jLtSEzxM1nWRYcyzod+1AfE2dTk4tm3yOFThewfhAZ/M6s63N7PIzjHKTxM9ZtaoPxfW+898zaxvijnQG4/lB/RrzFGL3Run8WJCdjflISilQqVGm1eLK42GK/zMM+FfJ4kOBghtZsZVbiwWRfq7t0vi/LskflhVKXyvUlGk2sjeCgVrYEpS0A0MDzUFWWl0EdQCm/TqdDuFgc9AyR1eVlNtvejYlEjZ4FwCFLIoGksQ6VTfUulcfp42wU75pWBSovVFpsq2dZyBkGiiBdv5bjwHqQoVPXqrT4e59BczUwTILbI8INK9osltdbhkfu6uKzxzceoU65TmfjHKipqcSH0RFoipSjSs8iUyKGnGFc6kMxy+/YK+FYVF88jzqdHlUSscsOiKE6JprWFheOaqOprgaVLU1+bY+RepYFywEM3yqEG+Oh4jg0sSzEQQr/Watn0cCykIlFUBq+LXVaHaIkYkgZBi0sizq9QXAQi8D5+Puj5TjU6fWoDID/Xqg+I95i1DrbC4zRoNOhVmf7vmosL0OrF/eDEMeDBAczwszs9LU6/vwT1ujMjpOane/LsuyRmtHZpXJ9iViiBBjLVf6oyCikZgTHMVim0wG1DRbbEtMyXPK58BWNra1IkclMiakCDcuyqC4vQ3J6pk1eFKlOB1ajgYRh0NnNqE+SMKWNEVBkVBRSMxIttoVptQgXiQLiV8KHjuPA8vgnOCO2rAxQ2eZjSI2MQnJKiunvyvPnLfYPTEhAanq63XIdjUeoU6FQAPWWk9LuGZ0RI5FArtNBp9EgVS53+VkJb1YCettEi+GSMKR2yoJCpUJaeLhTO/pQH5PI8+cBVa0LRwIJiclIjY31e5tgeD/rOQ6JVu9jd8dDxbKQ6XRIDVKWYkajgUinQ4pMZsqQXq9UIj08HBKGgVKvN0WRTJVKvfLr4UPHcWhVqZDqx8h9of6MeIvOENHN3iJFc2srmlUqoNlSiM/M7OKR+VowxqO5sNCl40hwMENm9lIy1xg4wvw4mZndsy/LskcwHm6WY2xMikUME7QXjXUsfgBYWV+PO9PSAtYGMcNALBIF/WUr4mmDcZsnYyTmDcdqW45IJIJILA7a9YsNL3R3nTD57h0YogMZr4XjOJRYJXvrGxHh0rXyjUeo02plOsgAiAkLa0vaZ7wX3egXe/bBMpEIYsM4iUUilz/MoTomz2Zl4anMTBSpVNja2IivKiogBhAlFqPRynRMEsA+CBOLwXCc3fpcHQ9xgNttUz/PvWu890QM0xZ21rBd7od3odjQh4G4/lB9RrxFzHEONZsikQh6q/1iQ54ubxDieJDgYEZ09CUn5uZmhcNjjTQ2XVpdizE735dlCQmO42w0DsGMU8w3Wfz04sWACg5CxibLrhu0TcasJoICDMfqqzwORsLNXtI1Wq2Nc26fiAgPausYtFhNUsMNEyt4eI/YGyOpSEQhKs0IE4kg5ji0sCwGRUbiv716IcogUD1cWIh6M212IEPQSjx8Nq0RCcQ52LwNIrNvn/nU0B/OsEK5/o6Ms3kOwxO2O1Tz/ZDgYEZa6iXzhLo653bgarUGLS1tdtKxsTEIN1Mj+rIsIcFytm+wYE8ag06QowrZ46/aWqyurYXCEFJ0Ulwc7nVgYmONq3kcgn39DMNA7EEkLXumTeaJzKy1DZEiEdKDZC7RHjhgFeHMQujyQICwNwmTBjmTsBBhAHxVXm4aAxGA65KTbSbugew3CcPY+Lx4hIfZ4X0Gz73LF0lJ4qccL4xAvzHEJUQ8ER1DNd8PCQ5mZGZcStRWWnbB6fHnSi/ZPmdlWCZ582VZQsI6ARwEqHEIBsJohSWlKhX2m03kusrlbp3fXjJHw8NV56lxcegsk+G5khKL7RFmk9VzKkv7+q5yOa1wO+D3mhq7+6xDWbqC3ahKhtV0GglLVGaCGmuMomY1mQnkO1PMMBD5IDy2KMiLRHz3rvl3z7jU4M/Qm0L51hGWVGu1ONHSgosaDQ42N1vskwjMxMhXkOBgRtcuWYiKioRC0YKi4nNQqdWQO/A1OHkq3/R70MB+fitLSLAcwFiZKgXz0RDCyzT4LeDHOvfA5oYG6J3YaZrjTgI4ofaBI7qFhyPFkGm8wcyUo7C1FWKGgYZlsazW0uHUXeGLuIRHgoM9HwceE5GODsMwUFs98zKRCNZx5wLZZyJD9lxvCfY7xlS32bWYT56MQqxfBQe/lUx4w/GWFjxVVMS7L1Qn2D69F5uam7F330H8/sdf+OrbH/HJoq9Qa2Wm09raCr3eJ8pLnyMSiTA0ZxAAQKPRYM++g3aPVanUpv1SqRSDBw7wW1lCgs9UKZiTd8FMHAQgwFjTZPWcGcOWugqf4GDPx0GI1+8KDE/egbX19fjwwgX8t7wcADAzMRGDIyMRKxZT4rcAkyCRIJknQlpPgymnEBYOhITayh9HLhIFVeMAH9l5i4JtDmn1P3g07WLSOHRIHAnG9gJwtHd8IhA1KxT4/c8VOHz4GPRWLy6NxjKR2dYdu7F95x7MnzcH/fv18UX1PuXKqVOwe+8BaLVarFi1Fr16dENGJ0u7cJZlseTXP9BsMAOZMmkcoqJss6P6siyhwPEJDsFqjEBWuoXQBj44HhMBdx54hmdgeYUJAfeBM/SG7ND2CGMYzEtONv3NBDAreXtELhJZmMuYw7dq64x/du6MK5ubcc+ZMxbbJ8fFATSZMnFOpUKxSoVSK58ceZA1DvCh87rQxtq6PYwhM7e/EMwiGWGBQ8FBYPesr/BacKiqrsEHHy9yOXLQ8ROn0NjYhEVffoc7b5uPIYMHetsEwBC5qFlh24ZWs6yvjY1NuFheYbFfLBYjNeXSxCAuNgbz5l6LH3/+HSqVGu99+Bkmjh+Lvr17QSaTorKqGtu270bxubbkRd26dMaVl0/hbZMvyxIKvKZKQXw4hGJvLoxWWMI3xXWnv9qLc7Q3WEcBskZryBFhvMeD6c/THngsIwNvmuW9eLjTJX8tT0yVAGB7Y6PF38lhYehniGwVmut57rOuvh6fGzRk5mxvbLQR5IQ2AXcVISxQOdQ4MIxfk4AK5VtHWOJIcCDnaB5YlsXnX35nEhriYmMwdMhgdMnKxDc/LOE9p3u3rjhfdhF6vR4//rwU2T17IDLS+/CG23bsxup1Gx0es2L1OqxYvc5iW0J8PF576VmLbWNG5UKn0+GP5augVmuwfuMWrN+4xaa8vr174fZbboJUaj/ZmC/LEgK8pkrBaoxAEOqrwdu1cV7n6BDTODgTHGDQSMiNH4AQ/RD4ikmxsTitVOJ4Swv6R0ZinHmiMQ/7rlang3lg4LExMaZJVHudBPsaexMU6yhXaMfCb1DHmieqkvXkSW4WetgfkMZBmJDGwU32HziEyqpqAMD4saNw3ewZpmQX9gSHOddOR4/uXfHlN4uhUqmwa+9+TJ0y0Ztm+IUJ40ajb59s7Ny9DydP5aO+oQFarRYx0dHonJWJ3GFDMHhQ/4CXFWzaBAfhaByEQij2gKsah/YqOHAch0YXsrqrWdaU6bg9XmcgCROJcF1yMq4zmHeZfzg91TgszMrCtIQEHFQosL+5GRPMhBGaTLXhzuJNe13oCapm2+p/8Ahg4X62ZyeNgzDhExxGRUdDz3HoFaI5f7wSHI4ePwkA6N6tC264bpbL5w0e2B+DBvbDkaMncPJUvk8Eh+lXT8X0q6d6XY45yUmJmDXjasyacbWgygomQvNxgGHyYL5u7O8XuDXtdeLsDN4ISvYEh3b4UdvZ1IRHz5612BbGMDbRqDRmph7t7yoDi/WTx/D8drcPGQCxEgmmxMVhSlychbM0LVq04Y4Wob32WTCFRD7/HOs+j/Dzd4eEZGFiLThIGAb/yMgAzII4hBpe3eml59vyE4wdNcLtc4cNGQwAqKis8qYJRIBhOaD5WCJqNmeiZksGHgjvhqsTEoLappe7dLH4uzNFvgEAzEpMtPi7q5v9wqtxsJPHoT3Cp0aOk9iupZiHuGyv1xoorAVIPsHBXRwJIzSZasMVwWFaQgJmJSYiTtw+ey2YixOuaBzshQ72Fe1V4At1rAUH8+zRoRqO1avrUrS02U+mpaW6fW5CfDwAQKlsdXosIRxYloOu5dIEtE9YODJkwX08rKOGBPwFK1Dn4CFRUZgQG4ttjY0IF4nwZGamW+e7bKrUTj9ofB/6CJHIRuvwr9JSDIiIQKZMhhvNIiwRtljfCYwPTJVsyjT7TZOpNpyJArlRUXgsIwOJPKFt2wtCE3cC7SsSbM0+wY+14MAZki6KGKbdfhud4eW9aHAY8qBvWIP6X9JOVz86KtaZo3mj7AQYG8EhSO0QGgzD4J1u3fBu9+74KjsbY8wdVV2A3znadmN77W8+29Trk5NtIqMo9HrsaW7G0ZYWco52giPtgMnB1M0+tNFimP3dXu89X+NMgGrW6wW5uOEOQvNxCPRyGQnJwoTvO6IL8bDdXr13o6OjAAAVldVun3uutAwABJ2zgLDFWnAQwrtMH+QER0K28RcxDNIM2ZHdPtfVPA4CvXZnSK3aLQKQExVl1+TA3zbMoYA/TJVI4+AcZ6vfLXZyaxAuwhNVKdDvPVpiFSZ8goOe40J6UcOra+vauc30YdeefW6dp9FosGXbjrYyunb2pglEkBHCXIqzupED3SQhT108NQ+BPUdoPvMlD8oWAtaCA2tQMdsVHMRiQY+1ELDROPCYKrkLCQ7OcTapVISAxiGYePMe9Vkb6F4XJLyCg8DnBd7ilbYtZ/BA5B0+hsKzxVj212rMmjnN6Tm1dfX49oefUVdXDwA+SwBHBAZbU6XgPx5zkpJwWVwcLqjV6CKX+zV7Jx/B7wH7MB6ah8ANH4f2KjhIeO4TLcfZTeIUKRIJeqyFgLOoSp4JsPa1GLQK24YzjYNCr+fNJE+4hklwCOL3ju51YWK9AAUAb58/j9SwMFwWH4/ZSUlBaZc/8UpwGJozCBs2/Y3zZRexccs2nDxdgBHDhyA5+VJHXbhQjsbGJlRV1yD/TCFOnDwNna4teGbnrAzkDBrg/VUQAYPlAJFUD4g4gAOUnA4alvF7RAlHvFlaigqNBkpDvP370tPRPzJwJnBCn0x6OmELeedoO7ap9gRP0jg4JyCmSuY+Du303vM1zvpBy3FYVleHO9PSAtYmwre01/dsqBMtFkNk5WtZpFKhSKVCJ5kMs4PYNn/htX/PvXfeivc+/AwNjU24WF6BZSvWWOz/dvHPvOfFxcbg3jtv9bZ6IsCwHJAw7iKkSSoAwBN1wHNRnTEniFL1zqYmXNRoTH9fF+i2CPyF7kvBQdxe1Qs88IVj1XEcr0ABg4+DsEc6+FjfHuZ/Mx5GH3NoquRBeaGI9Ye8k1QKDcuixizB4acXL+Lz8nJsHDgQ0R74PHVkhPDck8ZBmIgYBvESCWp5kok6yirdnvH6vRsfH4dnFz6KoTkDXZKIGYbBsCGD8ezCRxEX516UFyL4WJsqQQAvVevVNr3dI/1DsK/fGb4UHELpPRjGo1lwpnEIqQ7wA9bPoiMNhMtlWv1NPg628PXDzam2YdJ1HBfw92Mo4Ok71KdtoHtdsHzcsye+y87GiOhoi+2hKjj4ZNkhKjISd952M2pr63Do6HGUnCtFXV0DVCoVGIZBuFyOxKQEdO2chZxBAxAfH+eLaokg0JY52lJ6CHQ8a2usV2LYANvyCv3V4GnUJ75zhBB+11fwaRb2NjXh9rQ03MpxeK6kBAr9pWkW+Ti4jyNnaVexPse8TFqFbcP6HcxyHHKjo3FNQgJW1tWZtssYhqKDeYJAc/UQwqB3RATqtVobQYFPqx0K+FRfmZiYgMsnT/BlkYTAYDnbmXKwHw3SODjGUxMRV30c2it8L3WxQe0Mnkkv+Ti4hrm9r/Wz6ZMpq3mkphD9MLuLtQBlfAfOS05GvU6HnU1NAIAbU1KC6o/WXhGCxoEQNgzD2ISGJ8GBIAyCA2OtcQhaa9ooVqks/j6qUOAKQ2byQCD0V4OnHz0+f4ZQMg3hu5YkQ2ZdjuOgtIp9Tz4OrmEhOFjt87T/zMukMbAlNyYGqwYMwEW1GhqOM618ihgG96enY2p8PFLDwjAiJibYTSWIkIThSfwWqqZKtPRAuAWvxkFgD8eSavcTEnqFwK7fGnKOts9Es2za8RIJcqLaklpqOc7mI0AaB9dwFPXI03eFL6IzhTLhIhHiJBLESCSIlUgQKb60nMMwDHqGh6NPRERQ29ieIY0D4Qw+wYE0DjwsXbYSUmkYRCIRPLUAFIlECA+XIz4+Dt26dka04cNNCA+O4ww+Dpbbg+3jEGyEfvXkHG2fV7p2xXvnz6NZr8c1iYmme5kv024kmXi4hKNkjJ72IEVScs7/FRdja2MjwhgGMpEIcxITcUVCQrCbFRIwCMGXH+FTGEPGaHP4AnCEAl4JDlu27vBdSwwrI/379cGsGVcjLTXFp2UT3mN8JhiRlTouOM0RDEL/nDAM46FTqu22UPJxgCEG922pqVBZvfCVeltPmXCKquQSDMOYXha+iKpkXSaNAT9G0zotx0Gr18Na9KVe8xzSOBCOULMsilQqHFcqLbaTqVIA4DgOx0+cwjvvf4LCs8XBbg5hhSkUK2kcLBD61ftS4xBqggNgOxFt1ulwtKXFYpuMYSChyCouYd5H1v5PZKrkP6yFXXthhQkPoGefcEBBayvuLCiw2R6qgoNXi8VPPPIAWlUqXLhwEavXbYJOp0NEeDh69eyOzIx0REZGgmEYtLQoUV5RifyCQihaWhAREY4rL5+MyMhIcBwHtVqNyqpqHDtxCg0NjVBrNPjqux/x0nMLIZfJfHe1hFdcEhwsV2dDyWHWE4R+9SQ4OMb6kg4pFPixqspiW2+DfXgIXr7PsU76Zm+fp2XSdJgflZV5ndxacOjg72lvod4j7BFvJ6Ei+Tjw0L1bFxw7cQpr1m+CRCzGnGunY8yoXEjsdCLLsti9dz+WrViDDZu34sF770DnrEzT/uvnzMSqtRuwbsMWNDcrsHvPfkyeOM6bJhI+hLVjKdDhNQ4Cv35yjnaM9WVah6vsJJXi6aws3mMJW8yfBxuNg+eFXjJ/8rxpIUurXo+zVtHlbAQHwmPoniMckdDBBAev3iw1tXX49vslYBgGjzx0LyaMG21XaIDBEXrs6JF45MF7oNFo8L+vvofCzCRAJBJhxrQrMWhAPwDAiZOnvWke4WPsaRyCHY412Aj91cAwjEerjXyapFB8D1pfkrWJh9psJTcEL9/nWGgH/BFVKRRvQi85p1bbbJP5yL+EIB8HwjHhIpHN84YQNlXySnD4e+sOqDUaTJ4wDp2zMlw+LyszAxPHj0VDYxN27tpns39E7lAAwMXyCm+aR/gYk/+oSFiZo4ON0K+e8fBB7wjO0eATHKwuXGPuON3B73VXMN5rfD3lC1Mlwha+xRvSOPgOiqpEOIIxSxxqDmkceDh5us0ZpHd2T7fP7du7FwDg8NFjNvsSE9qSdylbW71pHuFjyFSJH6FfvW99HIR+tR5gdU1RYstpmIY0Dm5h1AjwTWY9jqrk5fkdEWvNGfWd55DGgXBGvCF5qMU2BxY47RmvBIf6hgYAgFQqdftcmcHpuba23mafUmkUGOhRFRLtxVTJnr2h3xD4ZJrxMCJIR3WOjrW6f9QcB47s613GpHHgNXXzsAeNmZC9aVgIo7YKJ4wQXu0MFtSbhCOshYTbUlIwKETzknn1Hg6TtElYpefL3D73wsVyAIBWp7PZV1RyDgAQExPtTfMIH2MUHOr3pKFuZxrqdqdhYWoXZMnlQW3X3KQki7+nxscHtH6hf1A8VbPzCg4hOHOzvsw4sa0orOWZmBH8+EPj4Mj8ibDUihmxTj5Ffec5ni6+EB2HRCvBoZEnF1Co4NU0ICkpEQCwftPfFk7OztBotNj893YAQFxsjMW+mppabN22CwCQldnJm+YRPoY1TJ7U5VFQXYiG6nw0LouJD7o6jrWa1AX6BS/0DwqFY3WM9SXxqZyPGN5vIXj5PsdkVsQjrHqdOZpW0XnpGxFhoWEIYxjE8AjAhOfQnUc4wvq70cCzKB4qeCU4DB7YHwDQ0NCIt979GLv37kdLi9Lu8RqNFkeOncB7H36Gisq2OOl9DL4OMGSifvfDz0xCyLAhg71pHuFj+BZdhfAdt15rC7TPhQC6wCGeOkfzaRdCXXCQMgwieSZcJYZQlyF4+T7HeNvwahw8japkOI/6n59wsRgPduoEkUFouCM11eY9SH3nHRTNi3CEtYl0KAsOXi0VT544Fjt27UV9QwPqGxrw489L8RPzB+LjYhEXFweZNAyMSASNRoOmpmbU1tZBb6ZSDQsLw+WTJ5j+PnHyNBSKNqGhW9cuGJozyJvmET6G5REchOAsq7eSaAJtTRP8HnAM+Tg4wewejhCJeDPumsLqCeB+FzqmST6fj4OnZRr+D0FLOZ9xa2oqRkVHo1mvRwRpG3wO3XuEI2wEhxA2VfJKcJBKpXjkoXvw2edfo7qmFgDAcRzq6htQV9/g8FyZVIo7b78ZiYkJpm0pKck4XVCI7t264J47b/GmaYQf4BccgtESS6ybFXBhRuCTScbD1bKOIjiYX1KEWMzrVCqhFW+XEVn9z7fPXSiqkmtEi8WwO10R+HtK6FDvEY4gjYMbJCcl4vlnn8D2XXtx4MAhlJSed3h8YkI8Bg8agMunTEBMtKXzc86gAejdqycGD+rvbbMIP8ArOAhgGeafWVn4R6dOKFap0CM8PODxy4X+QfE4dn4HFBzCDfeOhGGgM9NkDYqMtDmW4MckOPgwqpLpHqbJr2Oof/wGmSoRjojiERzqdbqg+4D6A59ckVgsxqTxYzBp/BhoNBpUVFajsakJarUaHMdBGiZFZFQEUpOTER1tPzxVdq8evmgO4SfaBAeuLQEcx7T9FMC7NFwshphhECORIInHsdXfCKALHOKpBobvPCEIir7G/JKMduH3pafjs4sXwQHIjY5GF0PkMKGPtRAwTrD4bhWP+4/CsXoN3bveQfce4Qi+aHwtej0JDq4glUoNWaQdZ5JWKltxobwcsTExSElOcngsIQw4FmDCWKTPLjJtm3ICWDFgAFI9yOURKgj9g+yxeUgHTABnFBymJySgi0yGVpZFd7NwwyF49T7HkcaBTJX8C/WP/6C+JRyRKZMhSybDebUaAJAhlSIjROdFQROiq2tq8eEn/8MPP/0WrCYQbsJytm9PvUAyRwezBcG/esd4rnFwbVt7x3hJ5utFIgCdZDL0CA+3NFEQwL0udBxqHLw0VaLe9xzqO+8gUyXCEQzD4LGMDORGRWFYVBT+3a1byN4zQdOhGJPGXSwvD1YTCDdhOYBhbB0dhBK/I2iPqMBfDuTj4BhTxB6zcQzVF34g4OtP632elin0Zy3YmEefsk0JR3gDmSoRzsiSyfBoZiYAoLNMFuzm+A2fCQ5FxSXIP3MWjY1N0Grte5PrWT3q6hpQcq4UMPhHCIWCM2fx4af/8+jchPh4vPbSs6a/C88W44OPF7lVRlJSIl55/mmP6g8ELMf/9hSCxiGYEwoBXL1DfKlxEMJQ+xo+jYO9ywzBy/c5/oiqFCORoEGno8mbEyyENo6zEB7o3vUO6j/CGebvp1C+X7wWHBSKFnz13Y84U1jkwtG2dOvS2dsmCJLW1tZgN8HnsBzHr3EIxdmkGwj96n2pcRAL/WI9wCQ4mN3H9vosBC/f5zjM4+Dhu0LMMMiSy1EfwiEOfYkIbVI+y5e1k/AI0kISzmAMAjtC/H7xSnBgWRaf/e9rlJ6/4NH5ndLTMG/utd40wad06ZyF55553OXjL5ZX4JvvlwAA+vTuabFP2aoy/Z46ZSJG5A51Wp5E4N73fD4OEJDDbLBaIfRVUE/Hh9852vv2CA6jTb4LpkqhePm+xmHmaC/KlTAMkoMQNa09Ya5xEHEcdDz7CM8Q+nueCD6Mnd+hhlcz1QN5h01CQ0xMNHKHDUFyUiIULS1YuXo9AGDBTddDr9ejrq4eh48eR2VVNXr17I4br5uN1NRk31yFj5DJpOiUnubSsSzL4seffwcAREVFYtaMaRb7lcpLGoeUlCSXyxUyHAeAR+MgBHEnqA+pQAQne3isceA5MRTDsZKpkm8xOTL7MKoS4R5GjQNI4+Az6NknnEGmSi6Qd+goACA1JRlPPfYgwsPDAcNKvFFwGDVimOn4GdOvxM7de/H7nyvwzQ9L8OB9d9gkgWsv/L1tJ0rOtSW7mzvrGkRGRljsNzdVMvZLe4cTeIjOYLVCGFdvH4qq5Bh3TJWELiQKAaPAwKdxEMq7ImTh0Z5Z7yM8I5RNTwjfYH6PhPLd4tUCUNmFiwCAyyaPd3lyPHb0SNx68w0ou3ARn33+NfR6vTdNCAr1DQ1YYRCMenTvihHDbc2QlCEoOLAs2pK/WSGEVUQKxxoYQvHb6U5UpRC8fL8goolWUDCPqiScsCOhgRC+c4SwsdA4hPD7z6tnQdGiBABkdOrk1nlDBg9Ev769UXahHAfyjnjThKCw7K810Gg0EIlEdn00LDQOZgmk2jN8Pg5iAT0gpHHwP6HoCE+mSr6HoYlrUBExjI3Wge5d76D+I5xBGgcX4Ni2YG8SieUnQiy69LfKkEXPmhHDhgAA9h/I86YJAaeouAQH8g4DAEaPHI7MDH6hydzHITw8dAQH66hKQplIksYhMISiqZJRjeKKqZJEIPe70OGbuBL+hzQO/kMoC2SEcCEfBxcIDw+HoqUFDY1NyOiUbtouk11Ks93U1Ax5sm0ijKSkRABARVW1N00IOEuXrQQASKVSTL/6CrvHtZpFVRKLxdi2YzeOHDuBCxfLoVS2IixMgvi4OPTq2R3jx45qF87TfM7RQhEcgklH+qCEouDgqqmSiO53l6F+Cg7mggNpHHwL9R/hDJGd36GGV4JDcnISFC0tOH7iFPr37W3aHhUVCYZhwHEcCs8WISU5yeZclaptYt3crPCmCQHl2IlTJofoSRPGIjbGvmO3uY/DOx98YnOder0e5RWVKK+oxPadezBl0jjMmjENIgGHrWnTOFhuE8oEgUGIGuALjFAWHJyZKknp/nIZIURa68iIGEYw7+ZQQbhfZkIoMC74yYUCXr3fe/fqgeKSc9ixay9ioqMwdsxIxERHQyKRIDUlGRWVVdiwaSuG5AyysfM3mvvI21Fa7tVrNwAGbcNlk8c7PNZccGhuVqBL5yyMGjEMmRnpkEgkqK6pxcG8Izhy7AQ4jsOmLduhVmtw07w5LreHZVkXjvIdOpa1cY4WB6EdfHAcB45lBdGWQGO8Zl9fO8vyhXJkEWpdbLxvGI671Ic895JYLHapj/01Hu0Ji74UAB1lTDhjv3OczRhwLAtWIJOZ9jgenMDuaV/THsdEcBi/JT7oRyGPh1eCw5jRudiweSv0ej1Wrd2IktIyPHDP7QCAgf37oqKyCtU1tXjn/U8wZdJ4pKelQtnairxDR7H/4CEAQGame47VweJ0/hlTzorhQwcjKjLS4fFhEgmio6MgYhhcMXUKJo0fY7G/c1Ymhg0ZjH0HDuH7H38Bx3HYsWsvBg3oh/79+rjUpsoLpV5ckfvUVkkAxjIBE8OyAW+HPWp1OkQLPImeP6kuL/NpeYomOQDL+7yu8iIkLcJ7kXmDiuNQp9MjViI2rdLqDdvMYUUihIldX3f09Xi0J+r1LMRu9FWgCPUxaWRZ1OlZhIlFEINBnVnUwkqJWHB+J+1pPPQc1yG0OO1pTISG8fljAFSG+WYuIsTx8OrKEuLjMefa6fjtj78AAFFmuQwmTRiL7Tv3QKVWo6q6Bj//9idvGePHjPKmCQFj6/Zdpt/jx452evxLzy10qdwRw4egtPQ8tmzbCQDYuGWby4JDakZnl47zFXEaPXTNCjTsTwFEHMKlwEPT5EhNTAxoO+zR3NqK1BAJfesOLMuiurwMyemZPjV1izqjAaC12JaS3gmpMcKbEHqDimWhVKmQHh5uUi/rOQ6NZlpDAEgNC0OCC5mL/TUe7QmJVotEAWV57ihjItPpoNdokCqVIkwkMpkEA0Ca2f0dbNrjeHAcJ5j+8wftcUyEhvH5EwFIjYhw4Qz7BGM8mgsLXTrOa5Fo4vgxSIiPw+p1mxAdFWXaHhsbgztvm48vv10MjUbLe+6USeORM3iAt03wO/UNDTh+8jQAoEvnTHTOyvBp+ZMmjDUJDmeLSqDRaCCVSp2eF+iHm2NYsK0SKItjAQCyCGBOsnAS+IlFog79whP5+Pr5PpIScej1sdhw74jFl7wcGI6zuU6ZROLWtft6PNoTYWKxIK891MfEeH0SsRgShrG4VpFIJLiJb6iPR3uExsRzJMbnz4fzMyGOh090KQMH9MPAAf1sbLH69e2NF/9vIbZu24nCohIoFApIpVJkZqRj1Mjh6NWjuy+q9zsHDx01XVvOoIE+Lz8pKRHh4eFobW2FXq9HQ2MTr0N5sOGsTN6F5igrsOaEJAKbd/gEhsfJn2+CFRaKF+8nOoJJh5DhjapEY0IQfsX0jIX4s+ZTg3A+qSguNgbXzrjal9UEnEOHj5p+D+jvmhmRu0ilYaakcTqdzi91eIu1rywJDh0PodlI+wJ7ycoYAOa3PEVVch3KdxEczEMLUx4HgggsxhlwqL/9vBIcLlwsBwAkJiRALm8/0ZHcQdHSgnOlbc4pCfHxfsm3wLIsWgxZuAEg0onjdbCwFRwE9ngIrT0hiAD9Xb3HTrIyEQCja6lYiPe7gOm4IQqEgciw+mkUfunOJQj/Q4KDC/z7nQ/BMAwef/h+dO/WxXetEhCFZ4vBGWx0unTJdOmcM2eLkJ9fiLr6evTr2xvDh+Y4PP5caZlJyxATE+0wP0QwsRYcGIFNIkP9YRUCQtMy+QI+UyVY3U9hArMxFTpkqhQcjL1uNJkQA9CRmR1BBATjcxfqXwuvBAe5XA6VSoUwAUXP8DXFJZdCjWa4qG2orq7BmvWbAADnzpdhaM4gh84tW7buMP0e2L+vV+31J2SqRAhtzH2BXVMlhjE59tDEyz1IOxMcrJMZihkGOo4jMzuCCACmWV6IP29eCUbpaSkAgLILF33VHsFRUVll+t0pPd2lc4YNyTHleaioqDKFq+Vj6/ZdOHjoCABAIpHgissmed1mf8FxQHjnJqTNOou0a88CE8/iYRfDdwWC0H5UhUEovg8ZOxNd85cjTbyI9oRp5dPwP2nMCML/GJ+7UP9aeKVxuOLyyfj8y++was169OndE/Fxcb5rmUCoqqo2/Y5x0YRIJpNi/g1z8cU3P4DjOGzbsRvFJaUYP3YkUpKTIZVKUV1dg30HD+GEIcwrAMyfNwdJScLIicAHywKMmINIeil6VqNAHbkJ7+HLG92hNA5mv0njQLQLrJyijb9J8CUI/yOy+j9U8UpwGNi/L+6/53b8sWwl/v32h5g4YQwGD+yP9LRUi5jo7Rlzp+VwNxzABw/qj7tvX4Cffl2KlhYlzpddwE+//MF7bEREOG6+4TrB57RgOc5GlBZS9BThtCR0CUXnaIZh+H0czE2VaMWWaAcwVmFXTRoHAb2nCSJUIedoF/jy28UAgPT0VBQWFmPNuk1Ys24TRCIRIiLCIQ0Lc2rbwAB45YVnvGmGX1Gp1abfcrncrXNzBg9Adq8e2Lv/IE6cPI2LFZVoaVGCYYCIiAhkdEpHvz69MXrk8HYRlYrlADCW69CCcoIUUltClFDUOMAV52i6t4h2grmIS6ZKBBE4KI+DCxw+cpx3O8uyUChavClaMHz03htenR8REY7JE8dh8sRxPmtTsGA520hKQvochfajKgxCVXDg05yZ39uCEpAJwg7W/jpkqkQQgYXpAHMRIc37CIHDCVzjIJyWhC6hmn3WrqmSASGZ5BGEI6w1DhKKckUQAUPUASbWXmkchGxiRPgelieTkJAmVMJpSWjA8XlHhyiOTJVCw1uL6AjYaBwYBhIyUyKIgGFMvBjKeCU4JCbE+64lhOBhOYCx0jgI6ZMU6g8r4T/4XoTGe1tIWjWCcARjbWJHZkoEEVBECH0fByHN+wiBw6dxENSkSkhtIdoVfCZY1rHwCaI9YH6/ihiGBAeCCCCiDrCI6TfBQaPRorGpGSzLunA00R4QfFQlgvAhxjvbK7UsQQQShrHROFBEJYIIHIzVMxiK+Oyb2NKixJ59B3D85GmcP38BKrUaDMPg/55+DOlpqabjzpWWobm5GQP69/VV1USA4HiiKglJcBBOS0IDAQ1tUCBTJaK9YW2qJGIYSIPYHoLoaHQEjYNPBIc9+w7i9z/+ssh5AAAcj3flrj37sXP3XgzNGYTbFtwQMoniOgK8GoegtcaWUH9YA01Hco7mw2iqRIID0Z6wNlUK9dVPghASDMOE/Kqb1++Unbv3YvGS3yyEhrAw+/LIiVOnAQB5h4/azaRMCBOW42yeByHZfwunJUQoYLyfhHSPE4QjrDUOEjJVIoiAYv0MhiJeXV9jYxN+/3MFAEAiEePyyRPwf08/hvffes3uOffffRs6pacBAPbuP4hzpWXeNIEIIHwaBwrHGrqM6iYkfVLgMb4cyceBaE+YC7qhmneFIIRKRzBV8kpw2L5rD7RaHcRiMf5x/92YNXMaOqWnOXxZZWZ0wsMP3I3IyAgAwJ59B7xpAhFAKKpSx2JkVzHGdL8kPLxyjSyo7Qk0ZKpEtDc6wmonQQgZyuPghPyCQgDAmFG56Nmjm8vnRUdHYfzYUVi7fjPOFpV40wQigHAcoC6PAKsWAwyHzHgG47rHBLtZJkL9YQ00DMPg57vCsTRPi4x4Ecb37Fhr76YEcCQ4EO0E6wRwBEEElo6Qx8GrmUB1TS0AYEC/Pm6f261LZwBAXV29N00gAgjLAerKSKgrIwEA8d1EmBgXGexmmQjtRzU4hIkZjO0pQYy84/UuRVUi2iOkcSCI4CHqAM+gV4JDq7IVABAb6/6qc0xMNABAo9V60wQigFhH2RGa/aywWkO0d0ymSsFuCEG4CkVRIoig0hFMlbx6x8jkbTbP1mFYXUHR0gIACJfLvWkCEUBYK8FBJLCnQ2DNCSkEJiMGBDJVItojJDgQRPAg52gnxMfFAQCKPPBTOHb8VFsZ8XHeNIEIIDaCA32hOgQddd4sIptxop3BCFATTBAdCcrj4ITsXj0AAH9v2wmFosXl884WlWDnrr0AgN7ZPb1pAhFAhK5xCPWHlQgwDEPaBqJdwZBpHUEElY7g4+DV9Y0dPQIMw6CpWYEPP/0fSs9fcHi8UqnEug1b8Mmir6BnWYhEIowZletNE4gAYu3jIDTBQWDNCSk6Yt+KaBJGtDNI40AQwaUjmCp55RydlpqCKZPGY9OWbSivqMTb73+M1NRkpCYnm45Zs24jRCIxqqqrceFCOfQsa9o3ZeI4pKYk2ymdEBosxyF2aBVkqUpwHFAcJsIfNamYk5QU7KYBHeBhDRYdtV9F5N9AtDPIrI4ggkwHcI72OjD7rBlXQ6VSY+fuNtOjyspqVFZWm/bnHT7Ge964MSMxa+Y0b6snAgjLAeJwHSTRbZGw1AAadLpgN8tEqD+sRIAhUyWCIAjCDSiPgwswDIOb5s3GoIH9sHHzVpwpLHJ4fO/snrh88gT07ZPtbdVEgGnLHG1pryQR0AMinJaEHgIa5oBBGgeCIAjCHTqCj4PPUsH279sb/fv2hkLRgpLS86irq4dKpQLDMJDL5UhKSkCXrCxERIT7qkoiwLCs7RMhqAeEJnl+oaN2q8iXL0iCIAgi5OkIeRx8/l2Mior0KJM0IXw4DmCsNA5CWpEVTkuIUIAhUyWCIAjCDTqCc7RXC8avvP4O1qzfhJraOt+1iBAsbaZKltuENLESTktCj47at0IyxSMIgiCEDcMwIR/ZzCuNQ3VNLVat2YBVazage7euGJk7FENzBiI8nMyRQhE+HwchhasM7Uc1eHTkfg0L8Q8AQRAE4TsEZb7tJ3xmqlRUXIKi4hL89sdfGNC/D0YOH4r+/fpAROmFQwaWs7V3p/B/RChDGgeCIAjCVUQAOBeOa894JTg8/vD9OHjoCA4fOYamZgUAQKfT4fCR4zh85DgiIyMwfGgORgwfgi6ds3zVZiJIsBwAMfk4dEQENMwBhQQHgiAIwlXIOdoJPbp3RY/uXXH9nJk4U1jUJkQcPY6WFiUAoKVFia3bd2Hr9l1ISU7CyNxhyB2eg4T4eF+1nwggHI/GQUimSh12dutnOnK3hrqtKkEQBEG4g09MlRiGQXavHsju1QM3XDcL+QWFOJB3BEePn0BrqwoAUFVdgxWr12HlmvXo0a0rRo4YiiGDB0Eul/miCUQAYDnO1sdBQBMr4bSEIAiCIAgi9PB5OFaRSIS+fbLRt0829Po5OHm6AAcPHcGx4yehVmvAcRwKi4pRWFSMX5cux8D+/XDnbfN93QzCD1BUJYIgCIIgiI6LX/MbicViDOzfFwP794VWp8Op0wU4cvQETpw8DUVLC7RaHfIOHyXBoZ3AcgAjoqhKHQ3qV4IgCIIgEMjEqGESCQYN6IeM9DR06ZyJjZu3oq6+IVDVEz6ANA4EQRAEQRAdl4AIDqXny5B3+BiOHT+JyqrqQFTpMYVni/HBx4vcOicpKRGvPP+03f3lFZXYs+8gTp0uQENjI9RqDaKjIpGenoahOQMxYvhQiMVCWrvnh+PJ4yCocKxCakuIQV1LEARBEITfBIdzpeeRd/gYDh05hrq6epv9CQnxyB2ag9xhOf5qgke0trb6tLw16zZizfrN0Ov1FtvrGxpR39CIk6fysWXrTtx9xwKkJCf5tG5fw3KAsjgGIikLhuGQnSZCulQa7GaZoLmtfyChgSAIgiAI+FpwKC4pxaEjx3D4yDFeM6TIiAgMHTIIucNy0L1bV19W7TOUhihQADB1ykSMyB3q9ByJhL8b127YjJVrNgAA5HIZJo4fg969ekIul6Omtha79uzH6fwzuHCxHJ8s+goLH3sI0dFRPrwa38JygOJkounvAaPD0DNcHtQ2mUPzW4IgCIIgCP/hteBQXHLOpFloaGi02R8WFoZBA/ohd1gO+vbJFrxJjlJ5SeOQkpKETulpHpVTWVmNVQahITIyAk8++iBSU5JN+7t0zsSwIYOx9M8V2Lx1B2pr67BsxRrcMv96H1yFf2Ct0iGKaKbeYaChJgiCIAjCK8Hh+ZffQENjk812hmHQO7sncocNQc6gAZDJhGPO4gxzU6Xw8HCPy1m7YTNYlgUAzJ453UJoMGfWzGk4duIUqmtqse9AHq6+8jIkJSZ4XK8/sRYchGbCIrDmhAzUrwRBEARBwFvBwVpo6JyVidxhQzB86GBBm9w4QukDwUGn0+Ho8ROmMoY78OMQi8UYMyoXy1euBcuyOHzkGC6fMtGjev0Nx1r+LbQJpdDaQxAEQRAEEUp4baqUnJSI4cNykDtsiOCde13BQuMg98x+v6j4HFQqNQCgR7cuCLPjA2Eku1dP0+8Tp/IFKziwnHVEpaA1hRdGaCqQEIK6liAIgiAIrwSHpx57CF27ZHl0bm1dPfbuO4iMjHQMHtjfm2b4FHMfh3APHX8vlleYfmdmdnJ6fGZGOhiGAcdxuHixwunxwcLGx0EUrJYQgYSEBoIgCIIg4K3g4KnQAAAKRQtWr9uI9LRUQQkOrWZRlcRiMbbt2I0jx07gwsVyKJWtCAuTID4uDr16dsf4saN4nafNc1UkxMc5rVMikSA6OgpNTc1QtLRA0dKCqMhIH16Vb2A5IGnKecCQ02FnrBgX1F2RIZMFu2kEQRAEQRCEnwlY5mhztDod9uw7AACoqa0NRhPsYu7j8M4Hn6C5WWGxX6/Xo7yiEuUVldi+cw+mTBqHWTOmQWS2/K5QtJh+R0W55usRHdUmOBjPF6LgoOc4SJMuCVY1ADQs6/AcIjQgpQNBEARBED4RHJRKJbbt3IOCM2fR2NgErU5n91i9Xg+FosWUEC0iIsIXTfAZ5oJDc7MCXTpnYdSIYcjMSIdEIkF1TS0O5h3BkWMnwHEcNm3ZDrVag5vmzTGdp9ZoTL+d+TcYMc8FoVZrHB5rhA3wpF1vbauENtVDoNtBWGLsf3+NA8tyhn8kPriCv8eDcB8aE2FB4yE8aEyEhZDHwyd5HBZ9+R1aWpQenT9oQD9vm+BTwgxmQyKGwRVTp2DS+DEW+ztnteVf2HfgEL7/8RdwHIcdu/Zi0IB+6N+vDwBAq9WajreXHM4a8+O0Oq3DY41UXih18ap8g7LVVshrqCqHXOC5OToK1eVlfim3vpWBSsohjIbZLfw1HoTn0JgICxoP4UFjIiyEOB5eCQ5KpRL/+/oHt4UGsViM2JhoDBzQDzOnX+VNE3zOS88tdOm4EcOHoLT0PLZs2wkA2Lhlm0lwCAsLMx3nSPtijs7sOKnZ+Y5Izejs0nG+IkxuO84paRlIlbafPB2hCMuyqC4vQ3J6poXJnK+QKDjEhANhYtI4uIK/x4NwHxoTYUHjITxoTIRFMMajubDQpeO8Ehx27t5n8gHo17c3JowbjeSkRNTV1ePTz78GALzywjPQ6/Woq6tH3uGj2HfgELIyM3DL/OvbffjWSRPGmgSHs0Ul0Gg0kEqlkJlNpM21D44wP07morNxoB9ujqe6MJGIXjICQeSnsWBELEQiBiKhxd8VOP4aD8JzaEyEBY2H8KAxERZCHA+vWnPiVD4AoE/vXnjw3jswoF8fpKYkIzY2xnRMYkI8UpKT0Kd3L8y/YS4WPv4Qmpqa8Pb7n+BsUYn3VxBEkpISTUni9Hq9KSGeefI7a+dqezQ2XUqmFyPQ5HnWeRwAQEyxOkMeGmKCIAiCIOCt4FBRUQUAGDdmpMvnZHRKx3133wa9Xocvvv4BipYWF84SLlLpJbMio7lRWmqKaVtdXb3TMtRqjcncKzY2xuOM1f5Gz+MbLaJZZYeARpkgCIIgCK8EB2OW5cSEBLvHcDyr1J3S0zB8aA4ULS3YvfeAN00IKizLWvh3RBpCqGZmXEr6Vlp2wWk550rPm35nZThPGBcsONiOZVDi+RIEQRAEQRABxyvBgTHYXVkLB+YRgswTqpkz0BBN6fCRY940waecOVuElavX4/sff8GBvMNOjz9XWmbSMsTERCM2JhowJMaLimoTIoqKz0GlVjss56TB5AsABg0UVpQpc/Q8ggNpHEIfhvQNBEEQBEF4KzhERbaF57RO4iaXX3Lura2r4z03zuAHUeuCKU+gqK6uwZr1m7B3fx7WrN/kNH7ulq07TL8H9u9r+i0SiTA0ZxAAQKPRYM++g3bLUKnUpv1SqRSDBw7wwZX4B5ZHcCAfh44BDTNBEARBEF4JDulpqQCA3Xv2W2gdoqOiEBbWpnU4fvI077n1DY2AA41EMBg2JMeUsbmiogq//fGX3WO3bt+Fg4eOAAYNyxWXTbLYf+XUKaawrCtWrcWFi+U2ZbAsiyW//oFmRZsD9ZRJ40yaCiHCJ0ZRaH+CIAiCIIiOgVcm6v379cGp/DM4lX8Gnyz6CpdPnoC+fbLBMAwyMzqhuKQUm7Zsx8D+fS3s/vV6PTZt2QYAgpooy2RSzL9hLr745gdwHIdtO3ajuKQU48eOREpyMqRSKaqra7Dv4CGcMBOI5s+bg6SkRIuy4mJjMG/utfjx59+hUqnx3oefYeL4sejbuxdkMikqq6qxbftuFJ9rS+LWrUtnXHn5lIBfsztQVKWOCQ0xQRAEQRDwVnAYNXI41m7YDIWiBfkFhZDJpOjbJxsAMDRnMIpLSqFSqfDufz7F4IEDkJ6WCmWrEseOn0J1TZt5U8/u3XxzJT5i8KD+uPv2Bfjp16VoaVHifNkF/PTLH7zHRkSE4+YbrkPOYH7zojGjcqHT6fDH8lVQqzVYv3EL1m/cYnNc3969cPstN1lEaBIifKZK5OPQMaBRDg3UajWampqgUglH0xsIOI6DRq1BWVkZGHpnBR0aD+FBYyIsvBmPmJgYxMTE+G0cvRIc5DIZ7r5jARZ98R1UKpXJzAcAxo0diW07dqG6phY6nd5k1mOOWCzG5VMmeNMEv5AzeACye/XA3v0HceLkaVysqERLixIMA0RERCCjUzr69emN0SOHW/hz8DFh3Gj07ZONnbv34eSpfNQ3NECr1SImOhqdszKRO2wIBg/qH7Br8wZrUyURT3hWgiCESWNjI5qbm5GYmIikpKQONTngOA5arQZhYdIOdd1ChcZDeNCYCAtPx4NlWTQ0NKC8vBzp6el+GUsmPz/f6+lfQ0MjNm/dgeSkRIwfO8q0vb6+AZ9/9T3KLly0OUcul2PBTdchZ5BwnYGFTnZ2dkDrm/ltA87EVAMiDgwDDOwkwi+5PQPaBsIWlmVReaEUqRmd/ZJhskHJIUYOyhztIv4eD09Qq9Worq5GRkZGh5wU0KRIWNB4CA8aE2Hh7XhUV1cjPDwcUVGuJxQuKChw6TifhOGPi4vFnGun22yPj4/DM08+jNP5Z1B4thjNCgWkUikyMzph8KD+CJfLfVE9ESDEaika9qWZ/p42y7G2hQgd6DvSvmlqakJiYiJNCAiCIDoAsbGxqKurc0twcBW/5+9iGAZ9+2SbfB+I9gtrpZuiOQhBtA9UKhWSkpKC3QyCIAgiAISFhUGr1fqlbGHo0Yl2gXWiP7Jc6RiQgBgakLaBIAiiY+DP9z0JDoTLWGscSHDoONCkkyAIgiAIEhwIl7EVHGgySRAEQRAE0VEgwYFwGdI4dExIPiQIgiAIAoFwjiZCB3VkKxLG1YJjAXAMNjIyzEOXYDeL8DMkNxAEQRAEAdI4EO7Ahukg79SC8MwWhGcpUITmYDeJIAiCsGLB7fdi6rTZqKis8us5/uTJZ57H1GmzceTo8WA3hSAIM0jjQLiMTeZoWovuEJCpEkEQgWb8uDHo0b0bkpISg90Ut1i9dj0+XfQVNBoN3n3zNQx2kORWpVLjl9//wLbtu1BZVQVpmBTdu3fFrJnTMW7MqHZ3DtExII0D4TIcLJ0cxEFrCRFISG4gCP+z6H9fY8Ht9wa7GYJh1oxpePC+u5DRKT3YTXGJVpUKb77zAT746L/QaDROj29RKvHIE89g8U+/QqfTYcqkCRg6ZDDyCwrxyr/ewg8//dKuziE6DqRxIFyGZSwFB4amlARBED7hzNmiYDeB8JCyCxfx0qv/Run5Mlx95eXYdyAPtbV1Ds/56psfUFxyDuPGjMJzzz4JiURiKuuRJ57BDz/+ghHDh6F3ds+AnJPdq4dX9RAdB9I4EC4TG24pKEgorFKHgEyVCMK/cByHwrPFwW4G4SEH8g6jvKISTzz6EJ549CFIxI718QpFC9au2wixWIxHHrrPNDEHgMyMTrjhujngOA5L//yrXZxDdCxI40C4zH0TwvBa6aW/4+U0oyQIgvCGt9//CBs2bgEAKJVKTJ02GwDwwzefIy01BQBwsbwcfy5fhYOHDqO2pg46vR5pqSkYP3Y0bpw3F3K5zG7523fuxm9Ll+HcufNgOQ49e3TDjfPmYmTuMJfap9PpsGrNemzcvBWl58ug0+mQkpyEUSNzceP1cxAbG+PytZaVXcBPvy7F0aPHUVtXD5lMiuSkRIwZNRJzZ89ATMylsp585nkcPXbCwk/AuM0R5v0GgwnRn8tXYuv2nbh4sQLgOKSnp2H8uNG4bs61CJfLLc5ft2Ez3v3gY/TpnY2PP3jLpetKSUrEB++8jt7ZvVw6/uChw9DqdBg0sD/i4+Ns9o8ZPQJffvM99h/Mg16vh1gsDsg5AJB36Ijb9RAdCxIcCJexdo4W01I0QRCEVwwfkgMRw2Ddhs2ICA/HlVdcBgCIiAgHAJScK8UTTz+H5mYFsnv1xKSJ46BSqZF36DB+/Pk3HDpyFO+//TrvBG7T5q1YvORXDBsyGJdNmYjiknM4fuIUXnj5dbz03DMYO2akw7ZptVo8/9LryDt8BHGxMRg7egQ4Djhx8hR+/2M5tu/Yhffffh0pKclOr/Nc6Xk88sSzUCqV6NsnGzmDB4LjOJw8lY+ffvkdO3fvxX/e/TeioiLtlmF0mLbmbFExjh47gTCJxEIQaG5WYOE/X8TZomKkJCdj0oRxUKlUOHbiJL5f/DN27tqL9956DZGR9ut0hTGjHfejNUbtEt+1wLCyL5NJoVC0oLKqCp3S0wNwTjWSkxJQWFTkdj1Ex4IEB8JldJyVczQJDh0CGmaC8B9TJk9Av359sG7DZkRHR+HB++6y2P/Dj7+guVmB6VdfgccefsC0vampCXfd/whOnsrHjp17MHHCWJuyf126DO+99Rr69e1j2vbd4iVY/NOvWPTF1xgzegQYBw/4kl+WIu/wEWT36om333jZNMHWarX46NPPsXb9Jnz82f/w2svPOb3OP5evhFKpxPwbrsPtt86HVqtBWJgUAPD+h59h7fqNWL9xM+bMmmG3jFkzptlsa1Eqcd+DjwEAbrtlvoUG5L9ffI2zRcUYNWI4XnjuaUjDwgAASmUr/vXmu9h/IA/ffP8T/vHAPaZzxo0Zib59siGTSp1ek6dUVFYCAJLtRIxiGAYJ8fEor6hEeXklOqWn+/+cigokJyWgoqLK7XqIjgX5OBAuoyfBoUNCo0wQwePKqVPwyEP34Ybr51hsj4mJwZhRIwAAJ06d5j33sskTLIQGALjx+jmQy+WoqKxCwZlCu/Xq9Xr8tXINAOCh+++yWJUPCwvDQ/ffg6ioSOzdfxBVVdVOr8OYH6JPn2yL7QzD4N67bsPHH7yFqZdNdlqONZ8t+gqVVdUY2L8frp97rWl7Q2Mjtvy9HRKJBP944B6T0ACDNufxRx6ASCTC+o2boVarTfsiIyPROSsTqWbmTr6mpUUJAAgPD7d7TLhB49SiVAbmHMOxxnPdqYfoWJDgQLgMayU40M1DEAThX0bkDsOM6VchPS3VZl9CQjxgNumzZviwITbbZDIZevZoM0M5W1Rit97iknNobGpCeLjcRvgAALlchoED+oHjOBw7cdLpdWRlZgAAvvnuR5wtsnQEj46OQp/e2YiOjnJajjk7d+3F+o1tJl4Ln3wEItGlr9LxE6eg0+mQmZHOKwQkJyWha5fOaG1V4UxhYCNaabVaALBwPLYmzLBPrdYE5BxjCFlP6iE6FmSqRLiM3upvCWkcOgQ0zAQRPDiOw7oNm7Fpy1aUlJxDs6LF5MhqOsYqx44RPmEDABITEgAA9fUNdustr2gzcxGJRPjs8694j6k0aBoullc4vY6b5s3F3n0HUFxyDg88/CSyMjMwfNgQ5A4fiiGDBzqcqPJRX9+A/3z8GQDggfvusrnWCkP7W5StdtuvbG01XGsFBvTv61b93iA1mEHpdDq7x2i1bftkMmlAzjEea9TMuFMP0bEgwYFwGWtTJdI4dAxIbiCI4PHOBx9jw8YtYBgG/fr2RlZmJsLD2xyAT50uwOn8ArvnymX80ZbCDJNDR4nKjOY7LS1K/Ll8pcM2KpWtTq8jISEen330HpYu+wubNm/F+bILOF92AX8uX4n4+DjcedsCXGVwDHeF9z/6DA2NTRgzagTvecbV8OrqGqftb3Gh/b4kymD2pXRg6mPcZzw2UOdERrl/DtGxIMGBcBnycSAIgggc+QWFJqHhtZefswmh+u0PPzkUHDQGsxNr1Jo2oUDmIIxruLzNjr1zVia++vxjD6/AkqioSNy24CbcevONKC4pwbHjp/D3th04fuIU3vvPJ4iOinIa6QkAVq/dgD179yMuLhaPP/ogf/sNwlXu8KF449UXfNJ+X9GpUxoAoLqmlne/Xq83JZAzZs72+zkZbedkGJyd3amH6FjQojHhMhSOtWNCw0wQweG4wXegX9/evHkXyssrHZ5faXBItqbGMClMSkywe256epvpT3VNjVttdpXMjE6Yec3V+OCdN3DrzTcCAP5atcbpeeUVlVj0xdcAgCcefQhxsbG8x6UZTJeqq507bgea7F5tGZcL7WQLLy45B61Oh4T4eFOoW7+fk9x2Ti9DBml36iE6FiQ4EC6TIZViVHQ0eookyImMRHerxDlEaEJyA0EEBiulLjjDhujoaJtj6+rqsWvPPv4TDRw8dMRmW2trq8kpulePHnbb0qVzFuJiY9DaqsL+A3m8x+w/eAjnSs87uKI21Go1du3Zh63bdvLuHzd2FOCCkMKyLN5+70O0tqpw9ZWXY/TIXLvHDujXBxKJBOdKy+y2ceeuvaZoT4FkyOBBkMvlOHkqHzWG1Xtztm7fBRiSrRnD5Qr5HKJjQYID4TLTExPxcY8euEcWhY+6d8f9nToFu0kEQRDtngiDWU1jUyNUqkuhQY2RiE6dyodC0WLa3tjYhFdefxs9uncFANTW1vOWu3b9JpwpPGux7ceff4NGo0GXzlno1q2L3TaJxWLMvKYtb8KX3/6ApuZmi/15h47gpVf/jSefft5pWE6GYfDuBx/j7fc/wsnT+Tb7d+1uE4C6dbHfHhjyUhw/cQrpaal44N47HR4bExODKZMmgOM4fPb5VxYhVwFgw6a/8fK/3sRzL75m4Wze0tKC0vNldrU1vkAul2HWjGlgWRYffbrIwhG58Gwxli1fCYlEYhFeVsjnEB0L8nEgPIJWGjoONNQE4V9iYmKQnJyE6uoa3P+Px5GamoIbr5+D4cOGoGuXLJScO4/7Hnocw4YOhqKlBfsPHMKwIYMx77pZePTJf+LQkaP499sf4PLLJiF32BBT6OxrZ1yNR594FsOHD0FSYiLOFpXg5KnTEIvFeOj+u52268Z5c3D8xCnkHT6C2+9+ELnDhiI8XI7S0jIcO3ESYWFhePyRBxEZEeGwHKlUivvuvgPvf/gpHn/q/zBwQD+kp6WC49pMXwrOFCI6Kgq3LrjRbhmNjU34/oclAIDUlGR88/1PvMdNmTQefXq35Yq4/547UFhUhLxDR3Db3Q9i2JAciMUiFJ4txpnCs4iKisSTjz1kkXV7x669ePeDj9GndzY+/uAtp30EAD/81Jakz4jx9/IVq7Fz917T9gXz5yHGoD265eYbcPT4Cezesx933fcwcgYPRHOzAnv2HYBOp8Pjjzxok1zNn+dwZlorT+ohOg4kOBAE4RCSGwjC/zz1+MP46JNFqKyqhkarRViYBGKxGK+9/DwWffE1Dh85hs1/b0N6WioW3DQP182ZCbFYjBnTr8KmLdtwIO+QyXTHGIt/9rXXoHNWJv5cvgqHDh8DwwA5gwfilvk3YNDA/k7bFBYWhtdffR6r127Axs1/Y8/e/dDp9UhIiMcVl0/BnFnXoEf3bi5d35VTpyApMQHLVqxGwZlCHD9xCiKRCCnJSZgx/SrceP0chzbzrSoVtIbV78NHj+Pw0eO8x/Xo3s0kOERHR+E/7/4by5avwtbtO7Ftxy6A45CYmIBrZ0zD3FkzkJ6e5lL7HbFu/SZTaFpztu/cbfH3nFkzTIKDVCrFO2++ht9+X4bNf2/Dxs1bIZNKkTN4IG64fjYGDxxgU56QzyE6Dkx+fj6/cSQheLKzs104yrewLIvN+SUY06szItyMu034B5ZlUXmhFKkZnS0SIPmufA4iEYkPruLv8fCE8+fPIysrK9jNCBocx0Gr1SAsTEraUgFA4yE8aEyEhS/Gw933fkGB/Qht5gjjq0a0O+i10nGgbwhBEARBECDBgfAEmkgSBEEQBEF0PMjWhHCZ5TU1OKxQoFKjxO4LFzAmNhZT4uKC3SzCz5DamiAIgiAIkOBAuMNBhQKr6gxxnWtrESUWk+BAEARBEATRQSBTJcJlWKskQ5Q5miAIgiAIouNAggPhMnqrv0lwIAiCIAiC6DiQqZIDCouKsXffQRQVn0NDQyO0Oh3C5XKkpCSjd68eGDt6BOLj+U11Cs8W44OPF7lVX1JSIl55/mkftd736K01DkFrCUEQBEEQBBFoSHDgoVWlwuKffuNNMKNoaYGiuAVFxSXYuGUr5s6agfFjR9mW0doaoNYGDhvBgTQOBEEQBEEQHQYSHKzQ6nT4+LMvcK60DAAQExONSePHokePrpBJpaitrce+A3k4cuwEtFodfv7tT8hkMowYPsSiHGWryvR76pSJGJE71GndEoEnVLMWHEQkOBAEQRAEQXQYhD1TDQLrNmw2CQ2JCfFY+MQ/EB0VZdqflZmBnMEDsHb9ZqxYvQ4A8MfylRiSMxBhZhN/pfKSxiElJQmdfJDWPtiwVn9LSHAgCIIgCILoMJBztBksy2L7jj2mv2+9+QYLocGcKy6fhMSEeABAc7MChWeLLPabmyqFh4f7rc2BREc+DgRBEARBEB0WEhzMqK2rh0gsgkgkQnRUFHp072r3WJFIhO5m+ysqqi32K0NQcLDWOJCpEkEQBEEQRMeBTJXMSE5KxL9ffR4sy0KtVjvNmCsWXVpz12q1FvssNA5yuR9aG3jIOZogCIIgCKLjQhoHHkQikUtaguqaGtPvhATLsKzmPg7h4aEpOJCPA0EQBEEQRMeBNA4eUlVdg6LicwAAsViMvr2zLfa3mkVVEovF2LZjN44cO4ELF8uhVLYiLEyC+Lg49OrZHePHjmoXztM2UZWC1hKCIAiCIAgi0NDczwM4jsPPv/0JzjCRHjt6BCIjIyyOMfdxeOeDT/DL78twOv8MmpsV0Ov1UKnUKK+oxLYdu/HG2//BH8tXgmWtvQiEBWWOJgiC8I6KyipMnTYb9zzwSFDbsW7DZkydNhtvv/+RTdsW3H5vUNsmNITaL2+//xGmTpuNdRs2B7spbvPkM89j6rTZOMKTL8vffL/4Z0ydNhvfL/454HWHAqRx8IDf/1yB/IJCAEBCfDyuufoKm2PMBYfmZgW6dM7CqBHDkJmRDolEguqaWhzMO4Ijx06A4zhs2rIdarUGN82b43I7Ai1oWGscGI4TvLDTETCOAY2FMBDieHAcZ1ro6OgEux+M9XPBbouxbs6sTWbtCVTbfFHP6fwzWLrsLxw/cQoNDY2QyWTo2jkLUyZPwPSrr4BY7F0MwGD0iysMGzIYUZER6JyV6dN2BfIa+d5NO3buwYrVa1FYWIRWlQoxMdHo37cP5l03C72ze1kce8sd96GyqhrOGDSwP95987W2OsGZ/hfSeNrD0zZyfpqjkeDgBhzH4fc/V+DvbTsBAHKZDPfedauNtgEAwiQSREdHQcQwuGLqFEwaP8Zif+esTAwbMhj7DhzC9z/+Ao7jsGPXXgwa0A/9+/VxqT2VF0p9dGWukcbqoZeIoWQ5SBiAbahDZasioG0g7FNdXhbsJhBmCGk8NGoNtFpNsJsRdITQBzpjGzguqO3R6XUAAJbVm9phbBsXoLb5oo616zfh00VfgmU59O/XB8OH5qC+vgGHjhzDydP52LlrD1558VmvhIdA94urjB87CuPHjgJ8eG8H6vo4w4RWp9Na1PnJf7/EmnUbIZGIMTRnMOLj43C2qATbd+7Grj37sPCJh03XDACXXzYJimb785DzZReQd/gooqOjTPWwer3pfyGNJx/etE+jVvllnkiCg4uo1Rp89+PPOHL0BAAgIiIcD9xzB7IyO/Ee/9JzC10qd8TwISgtPY8tBmFk45ZtLgsOqRmdXW6/L3gvo20VdXdRKUZ37wyRiCzdhADLsqguL0NyeiaNiQAQ4niUlZUhLEwa7GYEFa1WI4g+kBjbwDBBbY9E3Pb5F4nEpnYY28YEoG2+GI+L5RVY9L9vADB4+flnMGb0CNO+knOleOzJf+LQkWPYuGUbrrn6So/rCWS/BJNAPiOM4d0okYSZ6vx72w6sWbcR0VFReP+d19Glc5bp+MVLfsX3i3/GZ59/hdGjRpiiVd624Ca7dbAsi0eeeAZisRi33zLfVI/IIESKxGJBj6e34yGVyZGakeny8c2FhS4dR4KDCzQ0NGLRl9/ifNlFAEB8fBwevPcOnzk0T5ow1iQ4nC0qgUajgVTq/GYJ5qREJBIJZlJEtEFjIiyENB4MwzgNLx3KmKv6g90PxvqZYLfFWDdj1iaz9jhrm1LZiogIz3IU+Wo8Nv+9DVqdDhPHj8XYMSMt9nXr2gVXXzUVS//8C/sP5GHGtKs8rsedfhEiLMtCo9FCLpfZPSZYz4j5u2nNuo0AgJtumIuuXSwXRuffcB2W/7UajU1NOHHyNHKHDXFa9qo161Fw5izmzJphUR4DxvS/UMfTF+PBMIxfvkEkODjhfNkFLPriWzQ0NgEAunbJwr133YbYmGif1ZGUlIjw8HC0trZCr9ejobEJKclJPivf1wjzMSMIgvANb7//ETZs3OLwmHfffA2DBw0w/a1Wq7F02Qr8vXUHLpaXI1wuR+fOWZg7awbGjB5pt5zVazdg+crVuHihHCKRCNnZPXH7LfNd1jw7Y826jVi2YhXKyi5CLpehb+9s3HaL/VVaPqZOmw0AWPnnz/j4s/9h5+69SElJxueffIDS82W4676HMWhgf7z5r5fw7Q9LsGXrdjQ0NCI5KRHTr74C866bDb1ej59/+wPrN25BdVU1YmKiMXnSBNx1+wJIJBKUV1Ti1jvvh1gsxm8/fYvo6CibdpSXV+DWux6AVCrFrz99gymTJqBnj+5IT0vlbbdxu3mUQ19TeLYIjy98DnqdDv969QUMzRlkun+eevxhXDl1is05Tz7zPI4eO2FzD2m0WqxdtxEbN/+NisoqNDcrEBMTjYH9+2H+jdehezfLpLR89azbsBnvfvAxLps8AdfPnYUPPvoMRUUluPvOWzFn1gyH9fTv2xs33zQPPbp3s6jny2++xy+//YlnnnoUgwYOwNffLsahw0fR1NyM+LhYjBqZi7vuuAWREZZm203Nzfj2+5+wa88+NDU2ITExAePGjsatC27k7cvrZs/E2NEjMXpkrs0+sViM9LRUNDY1oba2zum4KBQt+G7xEkRHR2HBTfOcHm/kq28X4+dfl6JH9254/+3XPRaOQxkSHBxQcOYs/vvFt9Bo2mzMcocPwc03Xocwie+7TSoNMyWN0+l0Pi+fIAiCcI3hQ3IQFRlps728ohJ79u4HAIuJbatKhaf/+RJO5xcgM6MTLp8yCS0tSuzZdwAvvfYmbr7petx+y3yr0hh8t3gJ/lq5BiOGD0Of7F44cvQ4Dh85hmdOv4QvPvsQ6V5qtZf8shRff7cYIpEII0cMQ1JiIopLzuHxhf+HazxYgV/yy1LsP3AIE8aNQWJCAmDw5zPy1rsf4kzhWYwYPhS1tXXYu/8gvvj6e0RERKDgTCH2HcjDiOFDoVC0YM++A/j9j+WQiMW4645bkJ6Wij69s3E6vwC79+7DFZfbTri37tgFABiZOwyRERGIjIhARqd0u+09V3oeMPgU+oOamlo8//LrUKvVePapxzA0Z5DHZen1erz6r7ewd/9BxMXGYNjQHMhkMpwpLMLW7Tuxe+9+fPDOG8ju1cO18lgWr77xDuJiY3H1VVORlZnhtJ7tO/dg7/48m3okhjGub2jEw48/jYT4eIwZPQIKRQv27j+AFavWoqKyCm+8+oLpHI1Gg4X/fBFFRSVIiI/HZVMmgmU5/L11B/Lzz/C2eUTuMIfXVFtfDwCIi41xev1LfvkdTU3NuO/u23mFUD7Wrt+En39dirTUFLz+6vMkNNiBBAc7FJ4txmf/+8aUEXraVZdj+lVT/VIXy7JoaVGa/o7k+WAJCdI4EERowLIc6pTCjyriKgkRDEQi799QUyZPwJTJEyy26fV6PPbkPwEAM6ZfZbH6u/inX3E6vwDjx47Gc88+aXLELbtwEf94bCF+XPIbxo0ZhZ49upvOqaquwa7d+/DN/z5BTEzbREij1eKRx5/B2aJirNu4mUfYcJ36+gYsXvIrAODlF561WMVdsWotPvnvF26XuW3nLvz34/eQkBBv2ma0VT9TeBY9e3THF4s+gjQsDACw7K9V+HTRl/jm+x+REB+Hrz7/GJEREW3BQHbuxqtvvIP1G7fgrjtuAQBMnjgOp/MLsGPXHl7BYfuO3YBhfJyx/0Ae1qzbCJlMiutmz3T7Wp3R2tqK519+HbW1dbj37ttdapMjDuQdxt79B5GQEI8v/vshYqIvWTW8959PsXb9Rnz7w08Wk3NHHMw7jJG5w/HMU4+6VA/HcXj3g4+xfuMWm3pETNsYL/7pV8y85mrcdfsC076Tp/Px6BPPYv+BPJSXV5iE3ZWr16GoqASdOqXjkw/eNk3e1Wo1nn/pXzh6/KRb/ZN36Aiqq2sQHi630NLwUV/fgOUrVyMpMREzr7napfIPHzmGDz9ZhJiYaLzx2osmwZiwhQQHHiorq/H5V99Bq9WCYRjceP1sjBtjX9VszZmzRcjPL0RdfT369e2N4UNzHB5/rrTMpGWIiYn2qRkUQRCEPeqUHAb+qyXYzfAZx56PRFKUf5Y2fvr5d5wuOIOMTum4967bTdt1Oh3WrN0AALjjtpstovdkZnTCtddMQ96hIyguKbUQHJRKJe6+81aT0AAA0rAwjB87GmeLilFS4l00lJ2790Kj0aBPdi8b048Z06/CqjXrcbao2K0yJ4wdYyE0mNPaqsKdt91sEhoAYPy40fh00ZdoamrGQ/ffY2HKkjt8CKRSKerq69HcrEB0dBQmThiLz7/8FgfzjqC1tRXh4ZdWfCsrq1BwphBRUZG8K9NqtRpffbsYSqUS50rLkF9wBv379cE/HrjHa82NNXq9Hq+/+R7OFhVj7qwZuH7OtV6XmZ6WiqcefxhxsTEWQgMAXHXFZVi7fiNOnjrtcnnNzQrccrOtiY6jeqZePgnrN26xW09kZARuvfkGi239+vRGWloqKioqUVxyztTXf2/bARjMj8xX/GUyGe6/907c/48nXL6WpuZmfPjJIgDAvLmzLe4LPn7/YznUag3uuHWmS/6ipefL8Mrrb0EsFuG1l58zaWcIfkhwsEKn0+Gr736EUtlmNnT9nJluCQ0AUF1dgzXrNwEAzp0vw9CcQQ4dVLZs3WH6PbB/X4/bHigE6ktEEAThF/ILCvHjz79BJBLhmaces3AyLS45h2aFArExMbwTjjtuuxl33HazzXaxWMxr2hIfHwsAaGnxTqArPFsEAOhv55sybGiO24KDvbJguJ5+fS39MuJiY02/B1idKxKJEBMTjZqaWrS2tiI6OgqJCQkYOKAfjhw9jn378zBxwljT8dt2tmkbxo0ZbSGcGNFqdfhz+UrT3xmd0jE0ZzASE32/crzoi2+wd/9BTJowDvfdc4dPyuyclWnXpMoorJlbJjgjIT4endJtzbgc1hPvuJ7BAwcgjKfvE+LjUVFRiRZl23ksy6KouAQAMKCf7T3To3s3xMXFoqGh0el1NDY24Z8vvIqL5RUYNLA/brphrsPjW1UqrFyzHjKZFFddcZnT8hsaG/H8S/+CUtmKl194Fv369HZ6TkeHBAcr1m3cggsXywGDHeVEq/wLrjBsSA6Wr1gLRUsLKiqq8Nsff+GG62bxHrt1+y4cPHQEMNgRXnHZJC+vwP+Q3EAQREdBrVbjrff+A71ejwXz56Fvn2yL/cbkU+5OUBMS4nlzC4gNYVJZLxNTGR1Ik+y0KzUl2e0yE+1oGwAgPi7OZoHM/Pr4zhUbjje/1kkTxuHI0ePYsWuPpeCwvc2/Ycqk8bz1R0VFYsPqP6FUtqK8ogKr127A4iW/YsXqtXjzXy/ZOBZ7yp/LV2LZX6uQmpKMp598xKdReQrPFmPpn3/hxMlTqK2rN/lXeoI9zZA39dgL2iKRtI0zy7aNo0KhgFrdVmZikv37z5ngUFVdg38+/wpKz5ehX9/eePXFfzrNx/H31h1QKpW4fMokp2bfGq0GL736JsorKnHjvLm8TtmELSQ4mNHSosTmLdsBwwtv1IhhuFhe4dK5YrHY9CKWyaSYf8NcfPHND+A4Dtt27EZxSSnGjx2JlORkSKVSVFfXYN/BQzhx8pJKcP68OUhKSvTT1REEQRDu8sXX3+P8+QvI7tWTNzqLStUWsScszL3PqcjPqluVWg0YTEP44Fs5dobEQWAQsdhx2EdXE7BNMJg37d1/ABqtFtKwMFTX1CC/4AwSExOc2rdHRISjR/duePjBexEfF4fvFi/Bfz7+Lz56/y2X6ndEXX0DFn3xDWAQGHfv3Y8J49xfXOTjYN5hPP/y69DpdEhJTsa4MaPaksiKRFAqlVi3YbNb5dkbK/v1MFAoWrBh0992y3R1DFXqS4KIzI6pkLP7r7jkHJ578TVU19Qid9gQvPDc06bcDY7YtGUr4EDANGf5X6tNz8mmzX9j3txZLjtSd2RIcDDj+MnTpptIr9fjw0//5/K5CfHxeO2lZ01/Dx7UH3ffvgA//boULS1KnC+7gJ9++YP33IiIcNx8w3XIGez4hSgUGISOMyVBdGQSIhgce17YwRjcISHCt5PxvENH8NfKNZDJpHjmqUd5J05yw2RGbfh2CAWjbbcxwIc1RoFHaMTExGBIziDsP5CHg3mHMXpkLrbv2A2O4zBpwji34tJfMXUKvlu8BKfzz3iVd8KIVqtFn+xeuPKKy/DhJ4vwn4/+i759spGc5F74dNaQNdmcRV98DZ1Oh8smT8DCJx6xuNfKyyvcFhzsYa8ejuNQev68Q8HBVaTSS0KBVqvjFV5VKvvPS8m5Ujz59PNoVihw1RWX4bGHH3BJaGlqasKx4ychk0kxaGB/p8er1GosmD8PZ4uKsXvPfvzn4//ihf9zLXlvR4YEBzP4HmZvyBk8ANm9emDv/oM4cfI0LlZUoqVFCYYBIgxh5Pr16Y3RI4c7TMwiNBgyViKIkEAkYvzmTNzeUSha8O4HH4PjONx9x6127cKNmubKqmqwLCuYpH8J8XGAmcmSNeUVlQFuketMnjgO+w/kYdfuvRg9MhfbDGFYL7OKXPTzr0tRXFKK2ddOR5/e2TblGFeoOY5Dc3Oz14JDXGwM3nnzNcjlMpzOL8C6DZvx9rsf4q03XrEYd6M2yd6coqam1uLv5mYFSs61hY695eYbbSbJrlo+OMNZPRU+uieio6IQJpFAq9Ohtq4OUVGWixMcx6Gikr+umto6/N+Lr6FZocC862bjnjtvdbneI0dPgGVZ9Ovbx66mzZyZ11yN2xbchIbGRtyb/xi27diFdRs28+beIC5BgoMZo0cOx+iRw31aZkREOCZPHIfJE8f5tNxgQtMMgiBCnY8+/RzVNbUYOmQwrp0xze5x3bp2QXRUFJoVCpw6XWCTuM2YUGrmNVfj4QfvDUDL2zDa9J86XWCzj+M4HDh4KGBtcZexo0dBKl2EAwcPo66uHqdOFyArMwO9elrmMDh1ugC79uxDQkI8r+BQcKYQACCXyRza/LuKTCYzLfI9dP/dOHrsBA4fPY7fli7HDdfPNh0XYYge1dTUbFNGZWUVqqprLLZxZlp8PlOZVWvWXzqW4zz2q3BWjzFzs7f1iMVidOnSGYVni3DqdD66dM6y2H/qdD4UClvnf71ej1f+9Raqq2swa+Z0t4QGGELDArDJOm2PWENEs7jYWDz52D/w/Ev/wqeLvsDAAX15HcuJNoSxNEK0K0hwIAgilNm6bSe2bN2O6KgoLHz8YYcTKIlEgqsNOX6+/OZ7C5OlqqpqrF3fNhkL9OLR6FEjIBKJcOzESRzMO2yxb+mffwla4xAREY4Rw4eiprYWvy5dBpZlMWWSbZ6E6VdfAQBY/tcqHD5yzGJfXV09Pv/yW8AQFtYTnw5HhIeH49mFj0EkEuHbH37CmcKzpn1GoW3/wTyLcziOwxdff2+jlYqJjjYlNdt/IM/i+CW/LEV1Ta3pHFeyJtvDYT2/LkVNbZ1P6gGAcWNGAQB+/+MvU7QlGPJffP7lt7w+GKvXbsDp/AL069sb93sQrar0fBngYcK/kbnDMGP6VWhtVeHfb7cFQyD4IY0DQRAEQZjx4adtMePT0lLx69JlvMfkDhuC3OFDAQAL5s/D0aPHcfzEKdx578MYNnQwWlUq7N13AK2tKsy+9hoM6N8voNeQlpqCubNn4Lely/H8y69jZO4wJCTE42xRMQrPFuOmeXPxw0+/gGOF6bM2aeI47Ni1B3+tWA0AmDLZ1tl1RO4wzJs7C78uXYaF/3wRgwb2R2ZGJzQ2NuHQkWNQKpXIysrAvXffzlOD9/Tr2wc33TAXPy75Df9++wN89tF7kMtlGD92FL757kccOXoc//fCqxg6ZDD0ehY7d+8By7KYOH4sNm3ZCs4smtTc2TPx1beL8e4Hn2D3nv0ID5fj2PGTaGlpwQfv/hsvvvIGzpddwIuv/hujR+Xilvk3OGybPezVo2hpwTv/fgWvvvEuynxQz6xrp2P9xs04V3oed933MHKHDQXLsjiQdwgZndJNfizm5lw//9rmBxoREWES+vjok92LN+FeVVUVYMiH5Qn33nU7Dh85htP5Bfjhp1+8SsAYypDgQLgNaRwIgghlmpsVgCEbsvlKsjlRkZEmwSFcLsc7b76GpX/+hb+3bcemLdsgYhh069YF186YhssmTwxo+43cfcetSE5Kwuq167HvQB7kMhn69u2ND955A41NTYAhd5EQGTViOCLCw6FsbUWf7F52TUfuues25OQMwspVa3EqvwAnTp6GVBqGzIxOGDtmFObMmuFSNB5PuWX+DTh48DBOF5zBoi++xmMPP4DIyEi88+ar+OqbH3D0+AkcPnIMiYkJGDd2NG5dcCM+W/QVYOW4fv3cWdDqdFi3fhN27t6LmJhoDBsyGLcuuAlpqSm4/5478NGnn+Nc6XmkpaV43F579dxy841ITIjD/ffcgY99UE9kRATef+d1fPPdj9h3IA+bNv+NhIR4TJ4wDrfdOh/vf/gpYHX/VVW3hTY+cPCQQ1O6qZdP5hUcWgz5tyLMEg26g1wuw7MLH8ejTz6LJb8sxfChOQEX+NsDTH5+vjCXGwinZGfb2nT6G5ZlcaioBEO6dxWME2BHh2VZVF4oRWpGZxoTASDE8Th//jyysrJcODI04TgOWq0GYWFSn8bdJzyDxkN40JgIC1+Mh7vv/YICW38oPoTxVSMIgiAIgiAIQtCQ4EC4Da1FEARBEARBdDzIx4EgCIIgBEhTczMW//Sr2+eZO24TbVBfEoRvIMGBcBvSOBAEQfgfpbIVfy5f6fZ55o7bRBvUlwThG0hwIAiCIAgBkpaagg2r/wx2M0IC6kuC8A3k40AQBEEQBEEQhFNIcCDcRkS2SgRBEARBEB0OEhwIgiAIgiAIgnAKCQ6E25DCgSAIgiAIouNBggPhNiQ4EARBEARBdDxIcCAIgiAIgiAIwikkOBBuQxoHgiAIgiCIjgcJDoTbkOBAEARBEATR8SDBgXAbhiQHgiAIgiCIDgcJDgRBEARBEARBOIUEB8JtGFI5EARBEARBdDhIcCDchsQGgiCI0KKisgpTp83GPQ88EtR2rNuwGVOnzcbb739k07YFt98b1LYJDaH2y9vvf4Sp02Zj3YbNwW6K2zz5zPOYOm02jhw9HvC6v1/8M6ZOm43vF/8c8LrdQRLsBhDtDxIcCIIgCMIxp/MLsPTPFTh24iQaGhohk8nQtUsWLps8EdOvvgJisTjYTfQLw4fkICoyEl06Zwa7KT5l+87dWLlqHc4UnkWrSoWYmGj079cHN1w3G72ze1kcu+D2e1FZVe20zEED++O9t/7lx1b7HhIcCIIgCIIgfMjqtevx4Sefg2VZDOzfDyNzh6Gurh4HDx3ByVP52Ll7L9549YWQFB6mTJ6AKZMnBLsZPuU/H/8Xq9ash0QiwfChOYiPj0Ph2WJs37Ebu3bvwz+ffhwTx481HX/lFZehuVlht7zS82U4mHcYsbExAboC30GCA0EQBEEQhI+4WF6OTz77AgDwygvPYszokaZ9JedK8egTzyLv0BGsWbcR10y7MogtJVzh7607sGrNekRHReGDd99Al85Zpn2Lf/oV3y1ego8+/RwjcochXC4HANwy/wa75bEsi4cffwZisRi3LbgpINfgS8jHgXAbMlUiCIIghIhS2RrsJmDTlm3Q6nQYP3a0hdAAAF27dMbVV00FAOw7cDBILRQGLMtCpVIHuxlOWb1uAwDgphvmWggNxm2xMTFoamrG8ROnXCpv5ep1KDhTiGtnTLMprz1AGgfCbUhwIAgilFmxai0++vRz3H7LfFw7Yxq+/m4x9uw7gPr6BkRFRWL40CG4+85bkJiQYHFe3qEj+HP5SpzOL4CiRYnIiAj07Nkd06++AuPHjva6jrff/wgbNm5x2PZ333wNgwcNMP2tVquxdNkK/L11By6WlyNcLkfnzlmYO2uGzaTWnNVrN2D5ytW4eKEcIpEI2dk9cfst89G/Xx8PetSWdRs2Y+Xq9Si7cBFyuQx9e2fjtlvcW32dOm02AGDlnz/j48/+h5279yIlJRmff/IBSs+X4a77Hsaggf3x5r9ewrc/LMGWrdvR0NCI5KRETL/6Csy7bjb0ej1+/u0PrN+4BdVV1YiJjcGUSeNx520LIJFIUF5RiVvvvB9isRi//fQtoqOjbNpRXl6BW+96AFKpFL/+9A2mTJqAnj26Iz0tlbfdxu2trSqP+s4VCs8W4fGFz0Gv0+Ffr76AoTmDTPfPU48/jCunTrE559nnXsGxE6ds7iGNVou16zZi4+a/UVFZheZmBWJiojGwfz/Mv/E6dO/W1aIcvnrWbdiMdz/4GJdNnoDr587CBx99hqKiEtx9562YM2uGR/V8+c33+OW3P/HMU49i0MAB+PrbxTh0+CiampsRHxeLUSNzcdcdtyAyIsLivKbmZnz7/U/YtWcfmhqbkJiYgHFjR+PWBTfy9uV1s2di7OiRGD0y12afWCxGeloqGpuaUFtb53RcFIoWfLd4CaKjo7DgpnlOjzfy1beL8fOvS9Gjeze8//briIgId/lcX0OCA+E2FI2VIIhQJiys7dOo1qjx+ML/g06nw4jhQ6FWa7DvwEFs3Pw3Cs8WYdEn75ts1H9bugz/++o7iEQiDBuag7TUFNTU1uLAwcM4mHcY18+9FvfedbtXdRidTq0pr6jEnr37AcBiYtuqUuHpf76E0/kFyMzohMunTEJLixJ79h3AS6+9iZtvuh633zLfqjQG3y1egr9WrsGI4cPQJ7sXjhw9jsNHjuGZ0y/hi88+RHp6mlf9u+TXpfjmux8hEokwcsQwJCUmorjkHB5f+H+4ZtpV7pf3y1LsP3AIE8aNMQlaYZJL05u33v0QZwrPYsTwoaitrcPe/QfxxdffIyIiAgVnCrHvQB5GDB8KRUsL9uw9gN+WLodYJMZdd9yC9LRU9OmdjdP5Bdi9dx+uuNx2wr11xy4AwMjcYYiMiEBkRAQyOqXbbe+50vMAgM5Z/nEerqmpxfMvvw61Wo1nn3oMQ3MGeVyWXq/Hq/96C3v3H0RcbAyGDc2BTCbDmcIibN2+E7v37scH77yB7F49XCuPZfHqG+8gLjYWV181FVmZGR7XIzGMcX1DIx5+/GkkxMdjzOgRUChasHf/AaxYtRYVlVV449UXTOdoNBos/OeLKCoqQUJ8PC6bMhEsy+HvrTuQn3+Gt80jcoc5vKba+noAQJwL/gpLfvkdTU3NuO/u23mFUD7Wrt+En39dirTUFLz+6vNBFRpAggNBEAQBAPVarcfnhovFkIv4LV/rdTqA4zwqVy4SIdyO82ijTgfWUG58WJhH5duDYdquZfmKNRg9MhcLn3jYNHmvqKzCXfc9jJJzpTh2/CRyBg/E2aJifPnNDwgLC8Pbb7yCAf37mso6W1SMxxf+H35buhxjR48yrdi7WwfsOJ3q9Xo89uQ/AQAzpl9lsSq7+KdfcTq/AOPHjsZzzz5pKr/swkX847GF+HHJbxg3ZhR69uhuOqequga7du/DN//7BDExbRMhjVaLRx5/BmeLirFu42YeYcN16usb8OOS3wAALz3/DMaMGmHat2LVWnzy3y/cLnPbzl3478fvISEh3rSNMdyPZwrPomeP7vhi0UeQGu6TZX+twqeLvsQ33/+IhPg4fPX5x6ZV6d179+PFV97A+o1bcNcdtwAAJk8ch9P5Bdixaw+v4LB9x27AMD7O2H8gD2vWbYRMJsV1s2e6fa3OaG1txfMvv47a2jrce/ftXjspH8g7jL37DyIhIR5f/PdDxERHm/a9959PsXb9Rnz7w08Wk3NHHMw7jJG5w/HMU496XY/I8Awt/ulXzLzmatx1+wLTvpOn8/HoE89i/4E8lJdXmITdlavXoaioBJ06peOTD942Td7VajWef+lfOHr8pFv9k3foCKqraxAeLrfQ0vBRX9+A5StXIykxETOvudql8g8fOYYPP1mEmJhovPHaizZazmBAggNBEASBy48d8/jcZ7KyMC85mXffdSdPokGn86jce9PScF+nTrz77i4oQJGqzdTj4NChHpXvDJZlcf+9d1hEvklLTUG/Ptk4fPQ4iopLkDN4IFatWQ+WZXH1lZdbCA0A0KN7N1w59TIs+2sV1q7faGPq42od9vjp599xuuAMMjqlW2g0dDod1qxts82+47abLcrPzOiEa6+ZhrxDR1BcUmohOCiVStx9560moQEApGFhGD92NM4WFaOkpNSDnrzEzt17odFokN2rh43px4zpV2HVmvU4W1TsVpkTxo6xEBrMaW1V4c7bbjYJDQAwftxofLroSzQ1NeOh+++xMGUZmTsMUqkUdfX1aG5WIDo6ChMnjMXnX36Lg3lH0NraivDwSyu+lZVVKDhTiKioSN6VabVaja++XQylUolzpWXILziD/v364B8P3OO15sYavV6P1998D2eLijF31gxcP+dar8tMT0vFU48/jLjYGIvJPABcdcVlWLt+I06eOu1yec3NCtxys62Jjjf1REZG4NabLZ2R+/XpjbS0VFRUVKK45Jypr//etgMwmB+Zr/jLZDLcf++duP8fT7h8LU3Nzfjwk0UAgHlzZ1vcF3z8/sdyqNUa3HHrTEilUqflny+7gFdffxtisQivvfycSTsTbEhwINyGLJUIgugI9OrRHXGxsTbbEwyrfi1KJQCYnCKHDcnhLSdn0EAs+2sVTucXeFwHH/kFhfjx598gEonwzFOPQS6XmfYVl5xDs0KB2JgY3gnHHbfdjDtuu9lmu1gs5jVtiY9va2NLS4vd9rhC4dkiAED/vvy+EsOG5rgtOPS3EtbMEYvF6GdVl3l/Wwt6IpEIsTHRqK6pRWtrK6Kjo5CYkICBA/rhyNHj2Lc/DxMnXAq7uW1nm7Zh3JjRFsKJEa1Whz+XrzT9ndEpHUNzBiMx0fcrx4u++AZ79x/EpAnjcN89d/ikzM5ZmXZNqozCWkuL/XvU5pz4eHRKtzXj8qaewQMHIIyn7xPi41FRUWl6hliWRVFxCQBgQD/be6ZH926Ii4tFQ0Oj0+tobGzCP194FRfLKzBoYH/cdMNch8e3qlRYuWY9ZDIprrriMqflNzQ24uXX3oKytRUvv/As+vXp7fScQEGCA+E2FIqLIIiOQEpKEu92saRt9Z5j20ylKiurAACpqSm8xycnt5VTVV3rcR3WqNVqvPXef6DX67Fg/jz07ZNtsd+YfMrdCWpCQjxvbgGxuG26wHpodmbE6EBqr12pKfyaK0ck2tE2AEB8XBxEVmZ05tfHd67xePNrnTRhHI4cPY4du/ZYCg7b2/wbpkwaz1t/VFQkNqz+E0plK8orKrB67QYsXvIrVqxeizf/9ZKNw6+n/Ll8JZb9tQqpKcl4+slHwPjQGbHwbDGW/vkXTpw8hdq6emg0Go/LsqcZ8qaelGT+Z0hieIZYwzOkUCigVreVmZhk//5zJjhUVdfgn8+/gtLzZejXtzdeffGfTvNx/L11B5RKJS6fMgmRPH5K5mi0Grz82puoqKzCjfPm8DplBxMSHAJEeUUl9uw7iFOnC9DQ2Ai1WoPoqEikp6dhaM5AjBg+NCQTwRAEQbRXRC6+k1XqtpCSMhm/+YFxu0plG0XH1Tqs+eLr73H+/AVk9+rJG53FWJfRCdtVRH6OfmHsK6mU3y+Fb+XYGRKJ/WsUix0vdbn63Z1gMG/au/8ANFotpGFhqK6pQX7BGSQmJji1b4+ICEeP7t3w8IP3Ij4uDt8tXoL/fPxffPT+Wy7V74i6+gYs+uIbwCAw7t67HxPGjfG6XBh8Ep5/+XXodDqkJCdj3JhRiI6OgkgkglKpxLoNm90qz95YeVOPq2OoUl8SRGR2TIWc3X/FJefw3IuvobqmFrnDhuCF55425W5wxKYtWwEHAqY5y/9abXpONm7einlzZ7vsSB0ISHAIAGvWbcSa9Zuh1+stttc3NKK+oREnT+Vjy9aduPuOBXYlZ4IgCH+ycaB9O3pn2HNgBoDf+/XzyjnaHl9mZ3u9+u0r5HI5lEqlaTXTGmOs+vBw5xMMV8g7dAR/rVwDmUyKZ556lHfiJDdMZtRqYcXJN9p2a7X8fi98wpUQiImJwZCcQdh/IA8H8w5j9MhcbN+xGxzHYdKEcTZaDUdcMXUKvlu8BKfzz0CpbPU6So5Wq0Wf7F648orL8OEni/Cfj/6Lvn2ykZzk3nyCZVmbbYu++Bo6nQ6XTZ6AhU88YnGvlZdXuC042CMQ9ZgLq1qtDjKZzOYYR3klSs6V4smnn0ezQoGrrrgMjz38gEtCS1NTE44dPwmZTIpBA/s7PV6lVmPBTfNw5uxZ7N13EP/5+L944f8WOj0vUJDg4GfWbtiMlWvaHNTkchkmjh+D3r16Qi6Xo6a2Frv27Mfp/DO4cLEcnyz6Cgsfe0hQkiUfInJyIIiQw9eRiUzlOlgN9oZYP5XrCWlpKSgqKkF5eQVvWMrKKsemTO6gULTg3Q8+BsdxuPuOW+3ahRtNfiqrqsGyrFsTW3+SEB8HAKirq+fdX15RGeAWuc7kieOw/0Aedu3ei9Ejc7HNEIb1MqvIRT//uhTFJaWYfe109OmdbVOOcYWa4zg0Nzd7LTjExcbgnTdfg1wuw+n8AqzbsBlvv/sh3nrjFYtxN2qT+AQEAKixykPQ3KxAybm20LG33HyjzST5YnmFV+0OdD3RUVEIk0ig1elQW1eHqChLkyGO41BRyX//1dTW4f9efA3NCgXmXTcb99x5q8v1Hjl6AizLol/fPrzCijUzr7katy64ETU1NXio4Gls27EL6zZs5s29EQyE8SYJUSorq7HKIDRERkbg6ScexszpV6F3dk906ZyJYUMG4+EH7saUieMAg+3nshVrgtxqgiAIwh0GDWhbRdx/MI93/4GDhwAAA/v387qujz79HNU1tRg6ZDCunTHN7nHdunZBdFQUWltVOHXa1in7q28XY+q02fj4s/953SZ3MNr0ny6wjZnPcZypr4TI2NGjIJVKceDgYdTV1ePU6QJkZWagV09LYfHU6QJs/nsbthr8H6wpOFMIAJDLZA5t/l1FJpOZHOMfuv9upKel4vDR4/ht6XKL4yIM0aOampptyqisqkJ1jaUPDodLGj2+Bc1Va9ZfOtYL7V+g6hGLxejSpTMA4NTpfJv9p07nQ6Gwdf7X6/V45V9vobq6BrNmTndLaIAhNCwMWcNdIdYQ0Sw2NgZPPvYQAODTRV/gYnm5W/X6CxIc/MjaDZtNkv3smdPtOn3NmjkNyUmJAIB9B/JspH6hQQoHgiCIS1wz7UpIJBJs3rINx09YxoE/fuIUNm7eCrFYjOlXX+FVPVu37cSWrdsRHRWFhY8/7NABViKR4OqrpgKGDLvmJktVVdVYu34jYFhFDySjR42ASCTCiZOncfDQYYt9S//8S9Aah4iIcIwYPhQ1tbX4dekysCyLKZNs8yQYx3n5X6tw+IhlmOO6unp8/uW3gCEsrCc+HY4IDw/Hswsfg0gkwrc//IQzhWdN+4xCm7WAy3Ecvvz6e4iszAlioqNNSc32H8izOH7JL0tRXVNr0mi4kjXZHoGqBwDGjRkFAPj9j78sIpa1trbi8y+/5fXBWL12A07nF6Bf396434NoVaXnywAPE/6NyB2GGdOvQmurCv9++z82Ju/BQDi63hBDp9Ph6PETgOFBHj6MP0wfDFLwmFG5WL5yLViWxeEjx3D5lIkBbK17kOBAEARxiS6ds3Df3bfj00Vf4qlnX0TusCFITk5CRWUV8g4dAcuyePC+u9Ctaxev6vnw07aY8Wlpqfh16TLeY3KHDUHu8La8Fgvmz8PRo8dx/MQp3Hnvwxg2dDBaVSrs3XcAra0qzL72GgzwgRbEHdJSUzBn1gz8/sdyvPDyGxiZOwwJCfE4W1SMwrPFuGneXPzw0y92o0kFm0kTx2HHrj34a8VqAMCUybbOriNyh2He3Fn4dekyLPznixg0sD8yMzqhsbEJh44cg1KpRFZWBu69+3aeGrynX98+uOmGufhxyW/499sf4LOP3oNcLsP4saPwzXc/4sjR4/i/F17F0CGDodez2Ll7D1iWxfixo7Fl6w6LVf25s2fiq28X490PPsHuPfsRHi7HseMn0dLSgg/e/TdefOUNnC+7gBdf/TdGj8rFLfNvcNg2ewSqnlnXTsf6jZtxrvQ87rrvYeQOGwqWZXEg7xAyOqWb/FjMzbl+/vUPwKCxMQp9fPTJ7sWbcK/KYKoYExPNc5Zz7r3rdhw+cgyn8wvww0+/eJWA0ReQ4OAniorPmZxsenTrgjAn9rjZvXqafp84lS9owYEgCIKwZNbM6ejSOQt/LFuBU6cLsP/gIURHR2HUiOGYM2uGS06RzmhuVgCGbMjmK8nmREVGmgSHcLkc77z5Gpb++Rf+3rYdm7Zsg4hh0K1bF1w7Yxoumxyc78zdd9yCxIQ4rN2wGfsO5EEuk6Fv39744J030NjUBBgW34TIqBHDEREeDmVrK/pk9+LNSQAA99x1G3JyBmHlqrU4lV+AEydPQyoNQ2ZGJ4wdMwpzZs1wKRqPp9wy/wYcPHgYpwvOYNEXX+Oxhx9AZGQk3nnzVXz1zQ84evwEDh85hsTEBIwbOxq33HwDPjVk7daaZZG/fu4saHU6rFu/CTt370VMTDSGDRmMWxfchLTUFNx/zx346NPPca70PNLSPPfhCVQ9kREReP+d1/HNdz9i34E8bNr8NxIS4jF5wjjcdut8vP/hp4DV/VdV3Rba+MDBQw5N6aZePplXcGhRtgJmpmLuIpfL8OzCx/Hok89iyS9LMXxoTsAFfnOY/Px8YYr17Zy/t+3Eb3/8BQC46oopmDHtSofH63Q6PLbweXAch6jISLz1+otO68jOtnW68jcsy+Li+XPolNVFMM52HR2WZVF5oRSpGZ1pTASAEMfj/PnzyMrKCnYzggbHcdBqNQgLk/o0vj3hGTQewoPGRFj4Yjzcfe8XFNj6QvEhjK9aCGJMvgOzKBKOkEgkJqcgRUsLFF5m5/Qn9EohCIIgCILoeJDg4CfMPfOjolwLrxptdhyfZ79QoMUIgiAIgiCIjgf5OPgJtVmqdGf+DUbMvfntJRIyx14sZn/CsiwYhglK3QQ/xrGgMREGQhwPjuO8CmMYSlA/eE9TczN+XPKr2+cNH3rJcdtIRx8PX/alr+joYyI0PB0PjuP88h0iwcFPmDsX2Uuxbo35cVqd1uGxAFB5odTD1nlPdXlZ0Oom+KExERZCGg+NWgOt1vliRKhDfeAbmhob8efyVW6fFy6XI2fwANPfNB6+60tfQWMiLLwZD41a5Zd5IgkOfsI8NrPWxegQ5l78UhdiO6dmuJZMxJewLIvq8jIkp2cKxvGzo0NjIiyEOB5lZWUIC5MGuxlBxehoSHhPZmYm1q/6w6syaDza8EVf+goaE2Hh7XhIZXKkZrieO6K5sNCl40hw8BMy6aXBNtc+OML8OFfSkgdzUiISiQQzKSLaoDERFkIaD4ZhOnSkFHNVf0fuB6FA4yE8aEyEhS/Gg2EYv3yDhPFVC0HM06YbY287wxi/GgBieNKuEwRBEARBEESwIMHBT6SlXkpQUldX7/R4tVqDlpa29OexsTEIDw/3a/sIgiAIgiAIwh1IcPATmRmdTL9Lyy44Pf5c6XnT7yyzcwmCIAiCIAhCCJDg4Ce6dslCVFQkAKCo+BxUarXD40+eyjf9HjQweKnECYIgCIIgCIIPEhz8hEgkwtCcQQAAjUaDPfsO2j1WpVKb9kulUgwe6PsQawRBdGyElFeCIAiC8B/+zMVBgoMfuXLqFFNY1hWr1uLCxXKbY1iWxZJf/0Czos2BesqkcSZNBUEQhC+IiYlBQ0NDsJtBEARBBACFQoGIiAi/lE3hWP1IXGwM5s29Fj/+/DtUKjXe+/AzTBw/Fn1794JMJkVlVTW2bd+N4nNtCTq6demMKy+fEuxmEwQRYsTExKCiogLV1dWIjY1FWFgYhVwkCIIIMTiOg0KhQH19PTIyMvxSBwkOfmbMqFzodDr8sXwV1GoN1m/cgvUbt9gc17d3L9x+y02QSp0nfiMIgnAHhmGQlpaGlpYW1NXVuZxbJlTgOA4atQpSmZwEJgFA4yE8aEyEhTfjERERgYyMDIjFYr+0jQSHADBh3Gj07ZONnbv34eSpfNQ3NECr1SImOhqdszKRO2wIBg/qH+xmEgQRwjAMg6ioKERFdbwcMSzLovJCKVIzhJPNuyND4yE8aEyEhZDHgwSHAJGclIhZM67GrBlXB7spBEEQBEEQBOE2whJjCIIgCIIgCIIQJCQ4EARBEARBEAThFBIcCIIgCIIgCIJwCgkOBEEQBEEQBEE4hQQHgiAIgiAIgiCcQoIDQRAEQRAEQRBOIcGBIAiCIAiCIAinkOBAEARBEARBEIRTSHAgCIIgCIIgCMIpTH5+PhfsRhAEQRAEQRAEIWxI40AQBEEQBEEQhFNIcCAIgiAIgiAIwikkOBAEQRAEQRAE4RQSHAiCIAiCIAiCcAoJDgRBEARBEARBOIUEB4IgCIIgCIIgnEKCA0EQBEEQBEEQTiHBgSAIgiAIgiAIp0iC3QCifVBeUYk9+w7i1OkCNDQ2Qq3WIDoqEunpaRiaMxAjhg+FWCwOdjPbLYVni/HBx4vcOicpKRGvPP+03f00Zq5TVFyC7xb/gpraOgDAgpuux+iRw10+35d9TePWhidj4o/nCB18TAqLirF330EUFZ9DQ0MjtDodwuVypKQko3evHhg7egTi4+OclkPPiG/wZjzo+fA9LMvi8NHjyDt8FOfPX0BTczP0ehbh4XKkpiSjV8/uGD0yF0mJCU7Lai/PCGWOJpyyZt1GrFm/GXq93u4xGZ3ScfcdC5CSnBTQtoUKx46fxKIvv3PrHEcvdBoz19Dr9Vi1dgM2bNoKlmVN290RHHzZ1zRu3o2Jr58jdOAxaVWpsPin33D46HGHx4WFSTB31gyMHzvK7jH0jHiPL8aDng/fUllZja+//wllFy46PE4iFuOaaVdg6mWT7B7Tnp4REhwIh6zdsBkrVq0DAMjlMkwcPwa9e/WEXC5HTW0tdu3Zj9P5ZwAAiYkJWPjYQ4iOjgpyq9sfe/fn4fsffwEATJ0yESNyhzo9RyKR8D70NGauUVFRiW8X/4LzZRcAACKRyDRRdVVw8GVf07h5Pya+fI7QgcdEq9Phg4/+i3OlZQCAmJhoTBo/Fj16dIVMKkVtbT32HcjDkWMnTOfctuBGjBg+xKYseka8x1fjQc+H76itq8fb730MRUsLACA1JRmTJoxFWmoK5HIZamrrcODgYYsxmTvrGkyZNN6mrPb2jJCpEmGXyspqrFqzAQAQGRmBJx99EKkpyab9XTpnYtiQwVj65wps3roDtbV1WLZiDW6Zf30QW90+USpbTb9TUpLQKT3No3JozFxj+849WLpsBbRaHUQiEa6+4jJU1dRg/4FDLpfhy76mcfPNmPjqOUIHH5N1GzabJqmJCfFY+MQ/EB11aXKRlZmBnMEDsHb9ZqxY3TZJ+WP5SgzJGYgwyaVpBT0jvsFX40HPh+/49fdlJqFhyOCBuPO2+RCJLrkNd87KxNCcQVi3YQv+WrUWALBi9TqMHpWLcLncdFx7fEbIOZqwy9oNm02rfbNnTre4Ac2ZNXMakpMSAQD7DuSZbJIJ12ltvfRCDw8P97gcGjPX2Lp9F7RaHRIT4vH4w/dj2lWXQ8S49zr0ZV/TuPlmTHz1HKEDjwnLsti+Y4/p71tvvsFikmrOFZdPQmJCPACguVmBwrNFFvvpGfEeX44HPR++ob6hASdO5QOGVf1b5s+zEBrMmXrZRMTHxeL/27vzuCjvOw/gnxmOgeFQLjVyg2C8ELkR7yNqtKnVGJPYpDnWbNo0SY/Nq+3utvva7u6rzba5mpo26WazSWqMRzQWFeUQUBRFQBFREQE55L7PuWf/AB9mwgwzwAMU+Lz/epj5PQ/PPF+/+HzndzwAoFKpcedOqdH7kzFHWDiQSRqNBtdv9HWxOTo6Iioy3GxbGxsbLI+LBh5MFCooHLfznCp6RPiDzpgNT1REOH7xxusICvQf9r5iXmvGbcBoYgKR8gjTPCbNLa2Q2kghlUrh4uyM4KAAs22lUimCDN6vq2sUtpkj4hArHmB+iKa7uwdLwxb1TXyOiYJMZm+2rVQqRYC/n/Bza3u7sD1Zc4RDlciksvIKKBRKAEBwoL9Rd6cpoSHzhO2iW8XYsG71mJ/jVGL0TZBBN+ZwMGbW27XjMcwPnWdFS9PEvNaMW5/RxgQi5RGmeUy8PD3wm1//K3Q6HZRKJSQSyZDtbaQDK7Oo1WphmzkiDrHiAeaHaHy852Lv889Y3V6nH1jkQWZvJ2xP1hxhjwOZVFNbJ2z7+My12N7H+yHhD1pNTZ3F9mTMcOypo+PI/qAzZtYb7Q2qmNeacesz2phApDwCYwL0f1NqzbfSjU1Nwra7+8AyoMwRcY02HmB+TAi1Wo2ysgrh5+CgQGF7suYIexzIpPqGgS5OdyvW6La1tYWLizM6OjrR1d2Nru5uODs5jfFZTh29vQph28bGBueyslFQWIT7NbXo6emFnZ0t3GbORMi8IKxMiDM5qY0xGz9iXmvGTTxi5BEYE6s1NDahrLzvpsjGxgYL5ocK7zFHxt9Q8QDzY9xptVocOHQUnV1dAICYqAijFaoma46wcCCTurq6hW1nMxOxvsnFue8f4YP9p8MfBrEYjj393Tt/RGdnl9H7Wq0WtXX1qK2rx/kLl7BuzQps/9ajRhOyGLPxI+a1ZtzEI0YegTGxil6vx5eHj0Gv71vRPSE+Bk5OcuF95sj4shQPMD/GlFKpQnNLC/R6Pbq7e1BRVY3sS1eEG/qoiHA89cQOo30ma46wcCCTlCqVsG1prNwDtgbtlErVkG3JmOEf9M7OLvj7+SIuJhI+3g/B1tYWjU3NyMsvQEFhEfR6PdLSz0OpVBn9IWLMxo+Y15pxE48YeQTGxCpHjiWi+M5dAIC7mxu2bXnE6H3myPiyFA8wP8ZURWUV3tv3kdFrcrkjEuJjEBcTiaDAwZPaJ2uOsHAgkwwnVdmO4B+hWqMesi0Zs+vvNpRKJHhk4zqsWbnc6H0/3771l3Nyr+Kz/Qeh1+uRdfEywhYvxKKFDwOM2bgS81ozbuIRI4/AmAxJr9fjyLFEZJy7AABwkMnw0ovPDvp2mzkyPqyNB5gf466npxdXCwqhVKpgb28PH2/juQeTNUdYOJBJdnYDM//VGo1V+2gM2tkb7E+W/du/vGFVu5ioZaisrEJ6/38SqennhD/ojNn4EfNaM27iESOPwJiYpVSq8On+L1FwvW/ZR7ncEd/f+zx8TUzGZI6MveHEA8yPMRUaEox9774JnU6H3l4FauvrcfVaIbIuXEJu/jXkX7uOJ3dtR0J8rLDPZM0RrqpEJsnsB9Yl/uaSbuYYtpPJZGNyXgSsWZUgbJeW3YOqv4uSMRs/Yl5rxm1imMsjMCYmtbW14533/yTcpLq5zcSPX33Z7DM3mCNja7jxGC7mx8hIpVI4OckxLygQu3Y8hp/+6BU4OjhAp9PhwKFjKCu/J7SdrDnCwoFMcnEZmFzzzQlU5rR3dAjbri7WTc6h4fP09BCW5dNqtWhr77vujNn4EfNaM24Tw1wegTEZpKr6Pn73zh9RVV0DAAjw98UbP/6h2VV3wBwZUyOJx3AxP8Th5+uNzZvWA/3DypLTMoX3JmuOsHAgk+bMniVst7S0WmyvVKrQ3d0DAJgxw3XUj7OnodkbPETmQXcjYzZ+xLzWjNvEMZVHYEyM3Ckpxdt/+LNw4xgdtQw/evVlzHB1GXI/5sjYGGk8RoL5IY7FBsO8DHscJmuOcI4DmWQ4iaey+r7F9hWVVcK2r7flh4/QyOl0OiHhAcCpfwk1xmz8iHmtGbeJYS6PwJgI7paW44OPPhGGNDy6eQO2bt5o1b7MEfGNJh7Dxfwwr6a2Dg0NTWjv6MD8kGDMmTN7yPYOBk/pVvY/3RmTOEdYOJBJAf6+cHZ2QldXd9+jzJVKOAwxBu7mrWJhO2zJwnE6y6mhpLQMxcV30dLaioUL5iMqInzI9hWV1cK3P66uLsI3TYzZ+BHzWjNu4hArj8CYAADq6xvx4cefQq1WQyKR4Mld38GK5bFW7NmHOSKu0caD+SGe9MwsXLx0BbCyeGttbRO2nZ0HCrDJmiMcqkQmSaVSRISHAQBUKhUu5eSZbatQKIX37e3tsXTJ4nE7z6mgsbEJSclpuHwlH0nJadDpdEO2T8/MEraXLFogbDNm40fMa824iUOsPAJjAo1Gg48/3Y+enr51/3fteGxYN6lgjohKjHgwP8TzcGiIsJ2TexVarXbI9gWFRcJ2QICfsD1Zc4SFA5m1aeM6YYmvxJOncb+mdlCbvpUCBh6pvm7NCqOKmiyLXBYuPLGxrq4Bh4/+zWzbzPMXkXe1AOhfg/mR9WuM3mfMxo+Y15pxGz0x8wjTPCZnUtOFzxsbHYnV31jv31rMEXGIEQ/mh3iWhi2Cm9tMAEBTUzMOH/2b2UKspLQMGecGirD42Gij9ydjjkiKi4v1w9qDppWLl65g/5dHAAAymT1Wr0zAgvkhkMnsUd/QiHPns1FeUQkACPT3w2uvvGQ0oYqsU3C9CH/55HPo9X3p6OvjjZUJsZjl5QV7e3s0NjYhJ+8qim7eFvZ59uknEBsTOehYjNnQOju7hD+ahhJPnsH1GzcBAN96dNOg7lsbGxvMnuVl9JqY13o6x02smIiZR5imMenu7sGvfv1bKJRK2NjY4Icvv2j1jQVzRHxixoP5IZ47JaXY9+ePoenvbfDz9UFCfAy8586Bra0t2traUVh0C9mXc4WiIioiHM8/+9SgY022HGHhQBady8rG0eMnh1wbeMH8EDz3zFNT4tuEiXKt4Aa+OPSV0YQ0U+RyR+zZ/TjCl5rvXmTMzDuZlIJTZ1KHvZ+7mxv+499+Puh1Ma/1dI2bmDERM48wDWNy+Uo+Ptt/cET7MkfEJ3Y8mB/iKb5zF58fOGw0h8GcVSvisXP7NrNPdZ5MOcLJ0WTRqhXxWPBwKC5k5+DmrWK0trVBrVbD1cUFfr4+iI5chqVhiyb6NCe98KWLERoSjMtX8lB08zZq6urR3d0DiQSQy+XwnvsQFj48H/GxUXBwGPphLYzZ+BHzWjNuoydmHmEaxsTS2PeRYI6MnNjxYH6IZ37oPPzqF/+EvKsFKCy6ierqGnR2dUGj0cLRwQGenh4IDgpAfGyUxWdsTKYcYY8DERERERFZxMnRRERERERkEQsHIiIiIiKyiIUDERERERFZxMKBiIiIiIgsYuFAREREREQWsXAgIiIiIiKLWDgQEREREZFFLByIiIiIiMgiFg5ERERERGQRCwciIiIiIrKIhQMREREREVnEwoGIiIiIiCyynegTICIi8bz7/ocoKS0DAPz6lz+Dh4f7RJ/SuPjlv/8WLa2tkEqleP/t30z06QAG5wQA+959c8THyb6ci78eOAwAeHTTBmzdslG0cyQiGg72OBARERERkUXscSAiojH1dWISUtIypt235Z6e7rCz43+zRDR18C8aERGNqYrKqok+hQnx+isvTfQpEBGJikOViIhozOj1elRWVU/0aRARkQhYOBAR0Zipr2+AQqGc6NMgIiIRcKgSEdEUV1BYhOzLuaiuvo/Ozi7IHGSYM3sWIsLDsDIhDjY2Nmb3LSuvQE5uPsrvVaK5uQVKlQp2draY4eqKAH8/xMdGITQkeNB+J5NScOpMqtFrp86kCq+FBAfhR6/+46D97tfU4kJ2DopL7qK9rQNqtRrOzk4I8PdDbEwkwhYvtPpz3ykpxbkL2aisrEZ7RydsbW0we5YXli5ZjNWrlsNBJrP6WCNhzapKCqUS6ZlZKLhehKamZmh1Wri6umJeUCBWrYiDv5+v2eOX3C3De/s+gl6vh6urC375859CLnc02ValUuM/33wbzc0tAIAXnn0akRFLRfmcRDR9sHAgIpqi9AA+/+IQLuXkGb2u6e5Badk9lJbdw6WcXLz2g72Qy+VGbbRaLb44+NWgfQFAqVShobEJDY1NyMnNR1xMJPY8+Tik0tF1Yh8/cRopaRnQ6/VGr7e1d+Da9Ru4dv0GFj4cihee2wNHB4chj3XiVDKSktOMP7dGg4rKalRUViM3/xp+8trLcHQ0faM9HhqbmvHevo/Q2tpm9HpTUzOampqRk5uPndu3QWamwAmZF4S1qxJwNjMLHR2dOH4iCU89scNk26QzqULREBEexqKBiEaEhQMR0RSVkZmFSzl5mBcciIT4GMye5QWNRouS0jKkpGVAoVCiqroGn/71IL7/0vNG+x4/kSQUDY4ODli/bhWCAwMglztCoVDiblk5UtMy0atQ4FJOHtzd3bB188CKSatWxGNZ+BJcL7yJxFNnAAArE+KwakU8AMDe3t749yUmITktAwAwc+YMbFi7Cv5+PgCAmtp6pJzNRFNTM27evoMP/+dTvPaDvWYLlYuXcpCUnIalSxYhJjoC7m5uUCgUuFNSitT0TKjVGtTU1uFkUgoe3/GYqNfcWlqtFn/66BOhaPD09MDGdavh4z0XOp0W92vqkHHuAo4cS0RsdITZ4zy2bTOKbhWjvqERF7JzEBsdgaDAAKM2NbV1SMs4DwBwdXXBk7u+M8afjoimKhYORERTVMb5i1ixPA5P7toOiUQivB4cFIBFCx7GW+/tg1qtwY2bt1FWfk+44ezu7kHmuYtC+5defHbQcKR5wYGYHzIPv393HwAgLf0cHlm/BnZ2dgAAFxdnuLg4o6JyYGK0i7Mz5j40Z9B5VlRWI+VsJgDA08Mdb/z4h3B2dhLeDwoMQFREON586w9oaGxCyd0yXMm7ZvKGWq/X48ixROzcvg3r1qw0ei80JBhzZs/CJ58fAADk5F2dsMLhQnYO6hsagf6i4Wc/edVomFFQYADiYqPwwYf/a7LX5wE7Ozt877u78ft3P4BOp8MXB4/iF2+8Lgw/0+v1OHDoGLRaLQBgz5OPw8lJbvZ4RERD4eRoIqIpytnZCTu3bzUqGh7w9ZmL2OhI4efc/AJhu7e3FysS4hAVEY7oqGUm5zAAQGCAH/x8+3oFlEoV7o1w2dX0c1nC8KStWx4xKhoecHCQYcum9cLP2ZevmDyWXq9HUID/oKLhgYhlYUJvR3d3D5pbWkd0zqN1Je+qsL118waTcxPsbG2xZ/dOk/Ez5O/ni00b1gIAauvqhSIM/QVKWfk9AEBCfAwWL3xYxE9BRNMNexyIiKaoZUuXDBoSZGjJ4oXIungZAHC3tFx43dPTA7us/Cbey9NDWG61vb1j2Oeo0+lwvbAIACCVSrFk8QKzbcMWL8LeF56Bs5MTXF1dzLZbsTzO7HtSqRRenh64X1MLAOjq6oKHu9uwz3s0VCoVyu9VAgAkEgkWLzT/mT09PRAU6I/SsntDHnPLpvW4cfMWqqprcDo5DZHLlsJBJsPxE0kAAA8Pd+zYvk3kT0JE0w0LByKiKSrA32/I970Nhg01NDZCr9eb/XZboVCiu6cHKpXKaPKyWq022NYM+xzrGxqhVKoAAO7ubkNOenZwkCE8bLHFY/r6eg/5voPDwGRjlUo9ZNuxUFffKFxDd3c3syshPeDv62OxcLCxscGze3bjzbfeh1qtwZeHjsLFxQU9Pb2QSCR45uldY76KFBFNfSwciIimKE8P9yHfnzHDVdhWqzVQKBRGqwxVVFbj/IVs3C4uQWtb+5icY4vBUKGZBuczGpZuxKWSgVG631zBaTy0tw9cy5kzZlhs725lj8jch+Zg25aN+DoxCbfv3BVeX7t6BUKCg0Z4tkREA1g4EBFNUYbfrJsilUpha2sLjaavp0CpUguFw+nksziRlDzmN9a9CoWwbd8/sXq0LM0JmGgPelgAwN7e8mcearjZN61fuwq5+QWovl8D9K9Q9djWTSM8UyIiYywciIimKKtuoA0KgwftCwqLhCVU0f+8gDUrE+Dv5wO5XA6ZbOBG9rP9h3D5ivlVfyz/fsNTGf9v/yeCzvCaW9Nep7P62I2NzcJqTeifd1J+r9LsBHciouHgqkpERFOU4Tfbpmi1Wmj6l+kEIBQEKakZwmsR4WF4/ZWXEL50MdzcZhoVDQCg1WkxGo6OA3MaFErlqI41WcgMehBUastzLKy9LjqdDp99cRBqtRp2drZwdHSEXq/HZ18cMurZISIaKRYORERTVEvr0EuNthnMW3BwkMFBJoNarTZaVnXrlo1D9ly0jHI5U8Px+039Tzae6lxcnIXtNitWompqsu66pKRl4l5FX+we3bQBO769FQDQ2tqGI0cTR3y+REQPsHAgIpqiKiw8V+F+bZ2wPWf2LABAd0+vMGRIKpVilpen2f1bW9uEG9WRmj3LSxjD39nZNWTxoNVqcTwxCV8nJuFEUvKofu9EmjPbS9huaWm12KNQfq/C4jFrautw6nQKAMDHey7Wr12F5XHRwhClSzm5KLxxc7SnTkTTHAsHIqIpKv9aoTDx2ZSC60XC9vzQeQAAmcFkXZ1OB6XK/HCnr08kGY2/11kYtmRqrL5UKkXYkoXCz1dy883uf7e0HMlpGUhJy8Dt4pIhf9ffM7lcLjxBW6fT4eatYrNtq6prhGdOmKPVavHZ/oPQaLWQSqXY8+TjwpOjn969U3ia9/6DX6Grq1vUz0JE0wsLByKiKaq1tQ2Jp0x/M19ZVY3c/qcXSyQSREWEAwAcHR3h7jYwfCj/6vVB++p0OhxPTEJu3jWjZT5bWtoGtZUbLO/a0Nhk8lzWrEwQhkOlnj2HGoOekAfUajW+TkwSfo6PjTbzqSeHyGVLhe2TSSlQKAb3OiiVKhw49JXFSe5JyWmoqu5bRWn9mpXwM3iOhZenB7Zu3gD09+h8efiYiJ+CiKYbrqpERDSFGK7Ys3rlcqSezcT9+zWIi42Cl6cnNBoN7pTcRerZc8LE6LiYSOEbcACIi43EqdOpAIDDR/+Gjo4OhIQEQ6/Xo6amDheyc3C/phYJ8TEIDPBHSWkZAODi5SsIDPCDXC5HUKA/AMDTc+BZEgWFRTh+4jTmzPJCS1sbtjyyHgAQGOCHtatX4GzGeSiUSrz17gdYv3YVQkODIZVIUVtXh7T088JqQcFBAYiPjRqX6zlW1qxKQGbWRXR0dKKuvgH//fb72LBuNbznzoFWq0VldQ3SM7PQ3NyCNasSkJ6ZZfI4lVXVOJOSDvQXCY9u3jiozbo1K5F3tQBV1TW4WlCIK3lXER25bMw/IxFNPSwciIimEL1+YDjQlk3r0durQE5uPm6ZGdozP3Qenti53ei1Rzasxe3iEpSVV0CtVuNEUgqQlGLUJioyHLsf347Orm7hWRAdHZ3401/+DwCw7903AQDecx9CUGAAysrvQavVIjk1feD8+gsHANjx7a2QSICzGVlQKJU4eToFJ08b/04AWDA/BC8+twdS6eTuMHdwkOHlf3gO+/78Mbp7elDf0Ij9Xx4xaiORSLDj21sxe5aXUDgYDvdSazT4bP8h6HQ6SCQSPL17p8nnQtjY2ODp3Y/jd+/8ETqdDoe+Oo6QecGiPXCPiKYPFg5ERFOISjWwvKfc0RHf++5uLFm8AJdz8lBdU4uuzi7IHGSY+9AcxERFIC4mctBNuJ2tLV77wV5knL+I/KsFqKtvhF6vx4wZrvD39UZ8XDQWzA8F+p/2/P29z+H4iSTU1TfAzs4OAf5+Rsfb+8J3ceRoIu7cLUVvrwLOTnKjHg4IN8nbEBMVgQvZObhTUoq29nao1Rq4ODvB388XsdGRWBq2aEyv33jy9/PBL//5p0hLP4+im7fR3NICnU4PV1cXBAcGYGVCHIIC/Y0mR6sM5pycPJWM2rp6ADCaCG2Kn6831q1ZidSzmejp6cX+A4fxyssvjvEnJKKpRlJcXDw9nrhDREREREQjNrn7eomIiIiIaFywcCAiIiIiIotYOBARERERkUWcHE1ERNOaVqsVlnoVg4e7O2Qye9GOR0T094KFAxERTWttbe34rzffEe14r7/y0pArHBERTVYcqkRERERERBZxOVYiIiIiIrKIPQ5ERERERGQRCwciIiIiIrKIhQMREREREVnEwoGIiIiIiCxi4UBERERERBaxcCAiIiIiIotYOBARERERkUUsHIiIiIiIyCIWDkREREREZNH/A1MLmaak/JjJAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the average ratio of accumulated_collision_count / accumulated_total_count for all the features\n", + "# the x-axis is the batch_idx, the y-axis is the ratio\n", + "for table_size in table_size_zch_method_avetage_qps_dict:\n", + " fig = plt.figure(figsize=(8, 6))\n", + " font_size = 24\n", + " for zch_method_name in table_size_zch_method_avetage_qps_dict[table_size]:\n", + " x_list = []\n", + " y_list = []\n", + " y_min_list = []\n", + " y_max_list = []\n", + " for batch_idx in table_size_zch_method_avetage_qps_dict[table_size][zch_method_name]:\n", + " x_list.append(batch_idx)\n", + " y_list.append(table_size_zch_method_avetage_qps_dict[table_size][zch_method_name][batch_idx][\"mean\"])\n", + " y_min_list.append(table_size_zch_method_avetage_qps_dict[table_size][zch_method_name][batch_idx][\"min\"])\n", + " y_max_list.append(table_size_zch_method_avetage_qps_dict[table_size][zch_method_name][batch_idx][\"max\"])\n", + " line_style = \"--\" if \"nonzch\" in zch_method_name else \"-\"\n", + " plt.plot(x_list, y_list, label=f\"{zch_method_name}\", linewidth=3, linestyle=line_style)\n", + " plt.fill_between(x_list, y_min_list, y_max_list, alpha=0.2)\n", + " plt.xlabel(\"batch_idx\", fontsize=font_size)\n", + " plt.ylabel(\"average qps rate\", fontsize=font_size)\n", + " # plt.title(\"average collision rate vs batch_idx\", fontsize=font_size)\n", + " plt.xticks(fontsize=font_size)\n", + " plt.yticks(fontsize=font_size)\n", + " plt.legend(fontsize=font_size*0.7, title=f\"table size: {table_size}\", title_fontsize=font_size*0.7)\n", + " # save\n", + " fig_path = os.path.join(figure_folder, f\"average_qps_rate_vs_batch_idx_tbsize_{table_size}.png\")\n", + " plt.tight_layout()\n", + " fig.savefig(fig_path)\n", + " plt.show()\n", + " plt.close()\n", + "# plot the ratio of accumulated_collision_count / accumulated_total_count" + ] + } + ], + "metadata": { + "fileHeader": "", + "fileUid": "48f0276b-0d89-4f9f-9a7a-2038c58a3c2e", + "isAdHoc": false, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "bento_kernel_default" + }, + "language_info": { + "name": "plaintext" + }, + "orig_nbformat": 4 + } +} diff --git a/torchrec/distributed/benchmark/benchmark_zch/plots/plot_training_metrics.ipynb b/torchrec/distributed/benchmark/benchmark_zch/plots/plot_training_metrics.ipynb new file mode 100644 index 000000000..d874a2723 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/plots/plot_training_metrics.ipynb @@ -0,0 +1,160 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import csv\n", + "import numpy as np\n", + "import pandas as pd\n", + "import re\n", + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "~/home/lizhouyu/zch_results/result_tbsize_100000_nonzch_dlrmv3_kuairand/training_metrics.csv\n" + ] + } + ], + "source": [ + "profiling_result_folder = \"~/home/lizhouyu/zch_results/result_tbsize_10000_nonzch_dlrmv3_kuairand\"\n", + "training_metrics_file_path = os.path.join(profiling_result_folder, \"training_metrics.csv\")\n", + "print(training_metrics_file_path)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "figure_folder = \"/home/lizhouyu/zch_results/figures\"\n", + "os.makedirs(figure_folder, exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def get_losses(training_metrics_file_path):\n", + " df_loss_stats = pd.read_csv(training_metrics_file_path)\n", + " # maintain a dictionary of {feature_name: {batch_idx: num_queries_over_all_ranks_at_batch_idx}}\n", + " rank_loss_dict = {}\n", + " for index, row in df_loss_stats.iterrows():\n", + " epoch_idx = row[\"epoch_idx\"]\n", + " batch_idx = row[\"batch_idx\"]\n", + " rank_idx = row[\"rank\"]\n", + " loss = row[\"loss\"]\n", + " if rank_idx not in rank_loss_dict:\n", + " rank_loss_dict[rank_idx] = {}\n", + " if epoch_idx not in rank_loss_dict[rank_idx]:\n", + " rank_loss_dict[rank_idx][epoch_idx] = {}\n", + " rank_loss_dict[rank_idx][epoch_idx][batch_idx] = loss\n", + " # sort the dictionary by epoch_idx and batch_idx\n", + " for rank_idx in rank_loss_dict:\n", + " for epoch_idx in rank_loss_dict[rank_idx]:\n", + " # sort the dictionary by batch_idx\n", + " rank_loss_dict[rank_idx][epoch_idx] = dict(sorted(rank_loss_dict[rank_idx][epoch_idx].items(), key=lambda item: item[0]))\n", + " rank_loss_dict[rank_idx] = dict(sorted(rank_loss_dict[rank_idx].items(), key=lambda item: item[0]))\n", + " return rank_loss_dict" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "rank_loss_dict = get_losses(training_metrics_file_path)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rank 2.0: [0, 1, 2, 3, 4], [1.138333797454834, 0.5457656383514404, 0.3342053592205047, 0.6205226182937622, 0.391040027141571]\n", + "rank 2.0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1.138333797454834, 0.5457656383514404, 0.3342053592205047, 0.6205226182937622, 0.391040027141571, 0.3396586775779724, 0.321709394454956, 0.283235639333725, 0.2897059023380279, 0.3223789036273956]\n", + "rank 2.0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], [1.138333797454834, 0.5457656383514404, 0.3342053592205047, 0.6205226182937622, 0.391040027141571, 0.3396586775779724, 0.321709394454956, 0.283235639333725, 0.2897059023380279, 0.3223789036273956, 0.2584977149963379, 0.2114641666412353, 0.1528449356555938, 0.1568348407745361, 0.1585436761379242]\n", + "rank 2.0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], [1.138333797454834, 0.5457656383514404, 0.3342053592205047, 0.6205226182937622, 0.391040027141571, 0.3396586775779724, 0.321709394454956, 0.283235639333725, 0.2897059023380279, 0.3223789036273956, 0.2584977149963379, 0.2114641666412353, 0.1528449356555938, 0.1568348407745361, 0.1585436761379242, 0.1423344314098358, 0.0571691244840621, 0.10752484947443, 0.1349627524614334, 0.1466308087110519]\n", + "rank 2.0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], [1.138333797454834, 0.5457656383514404, 0.3342053592205047, 0.6205226182937622, 0.391040027141571, 0.3396586775779724, 0.321709394454956, 0.283235639333725, 0.2897059023380279, 0.3223789036273956, 0.2584977149963379, 0.2114641666412353, 0.1528449356555938, 0.1568348407745361, 0.1585436761379242, 0.1423344314098358, 0.0571691244840621, 0.10752484947443, 0.1349627524614334, 0.1466308087110519, 0.0985662415623664, 0.0464043654501438, 0.0745199099183082, 0.0741427764296531, 0.1006815731525421]\n", + "rank 3.0: [0, 1, 2, 3, 4], [1.1382150650024414, 0.5553121566772461, 0.4365339279174804, 0.569819986820221, 0.3744396865367889]\n", + "rank 3.0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1.1382150650024414, 0.5553121566772461, 0.4365339279174804, 0.569819986820221, 0.3744396865367889, 0.414739727973938, 0.3255707025527954, 0.3268932402133941, 0.3034020662307739, 0.3232459723949432]\n", + "rank 3.0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], [1.1382150650024414, 0.5553121566772461, 0.4365339279174804, 0.569819986820221, 0.3744396865367889, 0.414739727973938, 0.3255707025527954, 0.3268932402133941, 0.3034020662307739, 0.3232459723949432, 0.2932410836219787, 0.2323068678379058, 0.1650662720203399, 0.1533084362745285, 0.1558424085378646]\n", + "rank 3.0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], [1.1382150650024414, 0.5553121566772461, 0.4365339279174804, 0.569819986820221, 0.3744396865367889, 0.414739727973938, 0.3255707025527954, 0.3268932402133941, 0.3034020662307739, 0.3232459723949432, 0.2932410836219787, 0.2323068678379058, 0.1650662720203399, 0.1533084362745285, 0.1558424085378646, 0.1498693972826004, 0.163302481174469, 0.0863082036375999, 0.1172765046358108, 0.1370680779218673]\n", + "rank 3.0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], [1.1382150650024414, 0.5553121566772461, 0.4365339279174804, 0.569819986820221, 0.3744396865367889, 0.414739727973938, 0.3255707025527954, 0.3268932402133941, 0.3034020662307739, 0.3232459723949432, 0.2932410836219787, 0.2323068678379058, 0.1650662720203399, 0.1533084362745285, 0.1558424085378646, 0.1498693972826004, 0.163302481174469, 0.0863082036375999, 0.1172765046358108, 0.1370680779218673, 0.1128759309649467, 0.0937347933650016, 0.0475536584854126, 0.0801456496119499, 0.0885656252503395]\n", + "rank 1.0: [0, 1, 2, 3, 4], [1.1458685398101809, 0.5531677007675171, 0.391063779592514, 0.6452085375785828, 0.4466192722320556]\n", + "rank 1.0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1.1458685398101809, 0.5531677007675171, 0.391063779592514, 0.6452085375785828, 0.4466192722320556, 0.3126348257064819, 0.2996817231178283, 0.3103827238082886, 0.3142829835414886, 0.3542587757110595]\n", + "rank 1.0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], [1.1458685398101809, 0.5531677007675171, 0.391063779592514, 0.6452085375785828, 0.4466192722320556, 0.3126348257064819, 0.2996817231178283, 0.3103827238082886, 0.3142829835414886, 0.3542587757110595, 0.2704129815101623, 0.2222327440977096, 0.1495689451694488, 0.151196539402008, 0.1578521430492401]\n", + "rank 1.0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], [1.1458685398101809, 0.5531677007675171, 0.391063779592514, 0.6452085375785828, 0.4466192722320556, 0.3126348257064819, 0.2996817231178283, 0.3103827238082886, 0.3142829835414886, 0.3542587757110595, 0.2704129815101623, 0.2222327440977096, 0.1495689451694488, 0.151196539402008, 0.1578521430492401, 0.1376404762268066, 0.1004212945699691, 0.0882346853613853, 0.1304997652769088, 0.1306755989789962]\n", + "rank 1.0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], [1.1458685398101809, 0.5531677007675171, 0.391063779592514, 0.6452085375785828, 0.4466192722320556, 0.3126348257064819, 0.2996817231178283, 0.3103827238082886, 0.3142829835414886, 0.3542587757110595, 0.2704129815101623, 0.2222327440977096, 0.1495689451694488, 0.151196539402008, 0.1578521430492401, 0.1376404762268066, 0.1004212945699691, 0.0882346853613853, 0.1304997652769088, 0.1306755989789962, 0.1282927095890045, 0.0824838206171989, 0.0545717664062976, 0.0853540301322937, 0.0876660123467445]\n", + "rank 0.0: [0, 1, 2, 3, 4], [1.1445720195770264, 0.5742490887641907, 0.5007436871528625, 0.6135560870170593, 0.3937298655509949]\n", + "rank 0.0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1.1445720195770264, 0.5742490887641907, 0.5007436871528625, 0.6135560870170593, 0.3937298655509949, 0.3147369027137756, 0.4006346762180328, 0.3580551147460937, 0.2609686851501465, 0.3131151795387268]\n", + "rank 0.0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], [1.1445720195770264, 0.5742490887641907, 0.5007436871528625, 0.6135560870170593, 0.3937298655509949, 0.3147369027137756, 0.4006346762180328, 0.3580551147460937, 0.2609686851501465, 0.3131151795387268, 0.279504120349884, 0.2660774290561676, 0.1844844073057174, 0.1144141480326652, 0.1537224799394607]\n", + "rank 0.0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], [1.1445720195770264, 0.5742490887641907, 0.5007436871528625, 0.6135560870170593, 0.3937298655509949, 0.3147369027137756, 0.4006346762180328, 0.3580551147460937, 0.2609686851501465, 0.3131151795387268, 0.279504120349884, 0.2660774290561676, 0.1844844073057174, 0.1144141480326652, 0.1537224799394607, 0.1392649561166763, 0.1666741073131561, 0.120876058936119, 0.0724925026297569, 0.1568393260240554]\n", + "rank 0.0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], [1.1445720195770264, 0.5742490887641907, 0.5007436871528625, 0.6135560870170593, 0.3937298655509949, 0.3147369027137756, 0.4006346762180328, 0.3580551147460937, 0.2609686851501465, 0.3131151795387268, 0.279504120349884, 0.2660774290561676, 0.1844844073057174, 0.1144141480326652, 0.1537224799394607, 0.1392649561166763, 0.1666741073131561, 0.120876058936119, 0.0724925026297569, 0.1568393260240554, 0.1233028396964073, 0.1151823922991752, 0.065762385725975, 0.050499640405178, 0.0846986249089241]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAw8AAAJHCAYAAADWoGpjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAD3pElEQVR4nOzdd3hb1fkH8O/Vlm1JlvfMTpy9N2EnkAQIgRB2KJSWUmZZhV/LKGGV0bIpFNJSCCNA2COLQMiO45CdOHHseO+pYe37+8Ox7Gt5yI5s2fL38zw8lc69uvcoV3Lvq3Pe8wqZmZkiiIiIiIiIOiALdgeIiIiIiKhvYPBARERERER+YfBARERERER+YfBARERERER+YfBARERERER+YfBARERERER+YfBARERERER+YfBARERERER+YfBARERERER+YfBARERERER+UQS7A90pO+ck/rdyFSoqqwAA11+zFLNmTA3oObKyc7BzVwayc3JRU1MLp8sFrUaDuLhYpA0fijNmTYfRGBnQcxIRERERBUNIBg9utxvfrVmP9T9ugsfj6ZZz1NtsWPnhp9i7/6DPNrPFAnOOBdk5J7Hhp01YsvgSnHnGzG7pBxERERFRTwm54KGkpBTvrlyF/IJCAIBMJgt4AOF0ufDqG28jN68AAKDX63DOmWdg6NBBUKtUqKysxq7de7DvwCE4nS58/OkXUKvVmD51UkD7QURERETUk0IqeNi8dQdWf/kNnE4XZDIZFlxwPsoqKpC++9eAnmft+o3ewCE6yogH7r0DuogI7/bUlGRMnDAWa9ZtxDffrwUAfP7Vt5g0cRyUipD6JyciIiKifiSkEqY3bd4Gp9OF6Cgj7rnzViycPxcyIbBv0ePxYPOWHd7nN1x3lSRwaO6CuecgOsoIADCZzMg6kR3QvhARERER9aSQ+xl86uSJuHrpYmi12m45fmVVNWRyGWQyGcLDwjB0yKA295XJZBgyZBAqq6oBACUl5RiVNqJb+kVERERE1N1CKnhYevkipI0Y1q3niI2JxjPLH4bH44HdbocgCO3uL5fJvY+dTme39o2IiIiIqDuF1LSl7g4cmpPJZH6NbpRXVHgfR0VxyVYiIiIi6rtCKnjobcrKK5CdkwsAkMvlnLJERERERH0ag4duIooiPv70C4iiCAA4Y9Z0hIeHBbtbRERERERdFlI5D73JZ198g8xjWQCAKKMRFy+4oFOv12lV3dQzIiIiIgplpnpHtx2bwUOAiaKIz774Bj//shUAoFGrccvNN3R61CE+eUA39bBtHo8H5cUFiE1MgUzGQan+gNe8f+H17n94zfsXXu/+p61rbsrK6rZzMngIILvdgf998DH27T8EAAgL0+KPv78JqSlJnT5WML/0MpmMf3T6GV7z/oXXu//hNe9feL37n5685gweAqSmphZvvvMu8guKAABGYyRuu+UmJCUmBLtrREREREQBweAhAPILCvHm2++iprYOADBoYCpuufk3MOh1we4aEREREVHAMHg4TceOn8C/3n4XDkdDYsq0qZNw3dVXQKngPy0RERERhRbe4Z6GrBM5eOPf//VWjl44fy4umj8v2N0iIiIiIuoWDB66qLS0HG+t+B+cTicEQcDVSy/DnNkzgt0tIiIiIqJuw1T8LnC5XFjxvw9gtdYDAJZevoiBAxERERGFPI48tOL2Pz3ofbz8kQcRHR0l2b52w08oLCoGAMyYNgVnnzm7x/tIRERERNTTQiZ4MJnMMJnNPu319fXex7W1dSgqLpFsl8vliI+L9fs8FosVG3/a7H3tzOlTfI7Zls6ei4iIiIioNwmZ4OGXLdvx/doN7e7zzfdr8c33ayVtUUYjnnjsIb/Pc/DwUdjsdgCA2+3Gy6//2+/XdvZcRERE1HNEUURdXR3q6uqC3ZUuEUURDrsDBQUFEAQh2N2h06TRaKDX66FWq4PdFYmQCR56isfjCXYXiIiIKMBEUURxcTE0Gg2Sk5P7ZIVmURThdDqgVKoYPPRxoiiivr4e5eXl0Ol0MBgMwe6SV8gEDxctmIeLFgRmmdTXX3q2zW2zZkzFrBlTA3IeIiIi6h0sFguUSiWioqL82JuoewmCgLCwMGi1WhQWFkKj0fSaEYi+F1YTERERBZjZbO5Vv+4S4VQQERUV1aum0jF4ICIion7P6XRCqVQGuxtEPrRaLWw2W7C74cXggYiIiOjUr7xEvU1v+1wyeCAiIiIiIr8weCAiIiIiIr+EzGpL1HWWCif2v5sPW2k57OUlEOxbccEH10KQ9a5hMiIiIiIKLgYPBEdxLvT7boW+sUEBWCsuR3icNrgdIyIiIqJehdOWCBGDE3zaTDmlQekLEREREfVeDB4Ix+xKuESNpM2cWxy0/hARERF15L2VH2Pewsvw3sqPg92VfoXTlgiiIMIqGKFHU8BQkVeKYUHtFREREVHP2bvvAFZ/+Q2OHs2EyWxBRHg40tKG4/JLL8aUyRM7dSybzY5Vn32OXzZvQ2lZGVRKFYYMGYTFiy7CnNkzu+099AQGD4ThBhU2KyKhdzUFD5ay8qD2iYiIiKinfLRqNf7zv5UQBAGTJoxHQkIc8gsKsSs9A7vSM/CH392IKy6/1K9jWaxW3HP/X5BzMhdJiQk475yzYLXWY2d6Bh5/8lnccP3VWHbtVd3+nroLgweCWi5DnToSia6mNo+pIphdIiIiIuoRh49m4r/vfQClQoFnnnoME8aN9W5b/+PPeO4fL2PFuytx1plnIC42psPjrfjv+8g5mYs5s2firw/dB4Wi4Xa7oLAId937IN7/YBWmT52CtBF9c44Hcx4IAFCjNUqeK+srg9YXIiIi6ls8Hg9sNnuwu9ElP6zZAFEUsWD+PEngAADzzj8Hw4YOgcvlwq70jA6PZTZbsGbtBsjlctx1+x+8gQMApCQn4aorLocoilj9xdfd8l56AkceCABQGxEFNBtsULuqgtkdIiIi6qXWrt+IF158FeefexaWLlmMF195A9nZJ/G7396AyxdfAgBwOJ1Ys3YDNmz8GSWlZTCZzNDrdRg3ZjSuvfoKDBk8SHLMd/77HlZ9+gUevP9ujB83Fv95dyV+3bsfdSYTjJEGzJwxDTfftAzhYWF+9XHFuyvx8SerMXTIYPzzuacQFtb28vPzzj8HI4YPxdjRo1rdnpyUiKwT2ais6vjeKOPXvXC6XBg/bgyMxkif7bNnTcc7/30P6Rl74Ha7IZfL/Xo/vQmDBwIAWCKlw3AasTpofSEiIuotPB4RVVYx2N3wjwg4XSKUChEQWu9zVJgAWYCKwLo9Hix/+nlEGgxYMH8eUlOSG9rdbix/8lnsTM9ApEGPKZMnQq1W43hWNjZt3ortO9Px4vNPY8Twod5jNf5CX11Tizvv+TOijEbMnjUdZrMFO9N345vv1qCktAxPL3+kw36tWfcjPv5kNRLi4/DU8ofbDRwAYPy4MRg/bkyb2xuDBoPB0OG5s07kAACGDhnc6vaU5CSo1SqYzRaUlpUhKTGxw2P2NgweCADgio+VPFfJTLDX2qA2aNp8DRERUairsooY96Ql2N3oJGebWw48HI6YiMAEDxl79mLGtKl48P67Je279+zFzvQMREUZ8fa/XoZep/Nu+8dLr2PNug149/0PJYGATGiYSb/yw0+w6OIFuPnG673bDh/NxN33PoT03XtQXFyCxETf+lSN9u47gJdfexN6vQ5PP/EooqOiTus9FhQU4vCRTMhkMsyYOrnD/UtKG+pkxcZEt7pdEAREGY0oLilFcXFpnwwemPNAAAB1arxPmymbheKIiIiodSaTGcuuu9KnPTEhHvffcyfuves2SeAAAPMvOB8AcPjI0VaPGR4ehhuuk65ENHpkGhISGu5Tck7mttmfvPwCPP7Us5DLZXjib3/1joR0lcPpxHP/fAUejwcXzD233aClkcViBQBotW2PdmhPjYRYrNbT6l+wcOSBAADJCZFwiRooBJu3zZJXiphJA4PaLyIiIuqdoozGVn85H5CaggGpKa2/JqphgZbGm+yWJowbC6VS2eq5SkpK27zhrqmtxcOPPQmrtR5/e+QhjB6Z1sl3I2W32/H4U8/hyNFjSE1Nxh9vudmv1zmdDaM+zROlW1Ke2ma3O06rj8HC4IEAACMMatgQiQiUeNsq80vB0IGIiIha0xgItCbrRA5Wf/E1Dh0+gsqqajgc/t0ot7UUqkLRkFjs8fjmcjicDjy2/O8oLinF1VcuwawZ0/x+D60xmy145PGncPDQEaQkJ+HZp/7WYd5EI5VKBQBwuVxt7uN0NmxTq1Wn1c9gYfBAAICRRhUyFJGIcDcFD3UlnLZERET9W1SYgAMPhwe7G/4RAafLAaVCBbSR1hAVFph8B7Tz63rGnr14+G9PweVyIS42FnNmz4ROFwGZTAar1Yq16ze2ecyurD701dffw2ZvWCb2x40/48oli6HTRXT6OABQXlGBvzzyBE7m5mH4sKF4avnDMEb6rprUlojwhs+KtZ0pSY3bGvftaxg8EAAgUi1HncqIhPqmNncNC8UREVH/JpMJAUsw7m6iKMLpFKBUChCE4PX5zbf/A5fLhfPPPQsP3HuXJCAoLi5pN3joCpvdjuuvvRInsnOwfUc6Xnr1X3jkLw90+jiVVVW494G/oqS0DNOmTsYjf3kAWk3nFo5JSmrIiyivaL1eltvtRmVlw+pNyUl9L1kaTJim5mpbFIqTWxk8EBERkf9MJjNO5uYDAJZdd7XPSEJRcUkbr+y6RRcvwG+uvwb33n07jMZI/LJlW6cDFKu1Hn999EmUlJbhvHPOwhOP/aXTgQMAjBjeUDU660R2q9tzTubC6XIhymhEXFxsq/v0dgweyKsmXBo8qJ0sFEdERET+E9GUk9Da1KHvfljXtK8YmPoZBr0eABBpMOC+P90BAHj9zbdRVFzs9zFeeOlVnMjOwRmzZuDP993V5eJtkyaMh0ajweEjmaio9L2P2rR5G3CqWFwwR4dOB4MH8jIZpGsSazwsFEdERET+0+t0iDQ03Myn797jbRdFER+tWo3yikrIZA23n5Wt3FyfrhnTpuCSi+ajvt6GZ557CW63u8PX7ErPwOYt25GYEI8H77/b78Dhgf97FL+95Q4cPHTY26bRqLH4koXweDx45fU3JYnTWSdy8OVX30KhUGDpkku7+A6DjzkP5OWIka5woJKZ4Kq3Q6FVB61PRERE1LcsuWwRVry7Ei+8+Bq270iHVqvBgYOHYbFY8OILz+DRx59GfkEhHl3+DGbNnIZl117lx1H9d8vNN2LvvgM4mnkM73+4Cjcuu7bd/T/+9HMAgNEYif++92Gb+yUlJWLxJQu9z4uLS1BaVo76eptkv2XXXYX9Bw9h+4503PyHOzFxwjiYTGbs2LUbLpcL99x1W58sDteIwQN5yVNaKRSXUwbj6NSg9IeIiIj6nqVLFsPpcmHtuh+xdftO6PU6TJk0ATdcfw0S4uNw6+9vwiuvv4XcvHwkJMQF/PwajRoPPXAP7r7vIXy0ajWmTp6IsWNGt7l/WVk5AODwkUwcPpLZ5n7jx42RBA9tUalUeP7vT+DTz77Exp9/wYaNm6BWqTBxwjhctfQyTBg3tovvrHcQMjMzAzPhjAJqxIgRPX7ON/ZXYM6zv4FcZve2Ga77O1LmT+3xvlDP8Hg8KC3MQ3zyAO8wMoUuXu/+h9fcf/n5+UhN7ds/ljWstuSAUqnqs/PpqXVtfT7b+o4fO3as2/rCvyTkNcygQT2kSdO1+YFfFYGIiIiI+iYGD+Q10qiCRSENHqqLWCiOiIiIiBoweCCv5HA5TEppFUVnVXnQ+kNEREREvQuDB/ISBAG1GunIg8zSeoVEIiIiIup/GDyQRHWYdORB5WChOCIiIiJqwOCBJGp10pEHjYfBAxERERE1YPBAEtbIKMlzlWCC22Fvc38iIiIi6j8YPJCEOy7Kp82az6RpIiIiImLwQC3o4sLh9qglbeaTXK6ViIiIiBg8UAsDImSwidK8B3MBC8UREREREYMHamFoGGCVS1dcqirkyAMRERERMXigFgaEiTCppCMPtkrmPBARERERgwdqQaUQUKOWjjzAxEJxRERERMTggVpRGyYdeVDZGTwQEREREYMHakVtRLTkudpdHbS+EBEREVHvweCBfFiiWgQPQh08TkfQ+kNERETU0nsrP8a8hZfhvZUfB7sr/Yoi2B2g3scdH+fTZistR1hKclD6Q0RERNTdNv2yFd+tWYesrGxY6+uh00UgbfgwXHrJQkybOrlTx7LZ7Fj12ef4ZfM2lJaVQaVUYciQQVi86CLMmT2z295DT2DwQD70yQa4PWrIZXZvm+VkGYMHIiIiCjmiKOK5f7yCDRt/hlKpxNQpE2GMjERefgF2pmdgZ3oGbrjuaiy77iq/jmexWnHP/X9BzslcJCUm4LxzzoLVWo+d6Rl4/MlnccP1V2PZtf4dqzdi8EA+BkZrYBeNCENTcThzfglig9orIiIiosDbsHETNmz8GUZjJF564WkkJSZ6t63/8Wc894+XsfKjT3DWmbMxcEBqh8db8d/3kXMyF3Nmz8RfH7oPCkXD7XZBYRHuuvdBvP/BKkyfOgVpI4Z16/vqLsx5IB8jDCpYZdIVl2pYKI6IiIja4PF4YLPZ/diz91m3/kcAwLJrr5IEDgAw7/xzMHzYEHg8HuzO+LXDY5nNFqxZuwFyuRx33f4Hb+AAACnJSbjqisshiiJWf/F1N7yTnsGRB/KRFqnEFmUkYlxNbeaysmB2iYiIiHqJtes34oUXX8X5556FpUsW48VX3kB29kn87rc34PLFlwAAHE4n1qzdgA0bf0ZJaRlMJjP0eh3GjRmNa6++AkMGD5Ic853/vodVn36BB++/G+PHjcV/3l2JX/fuR53JBGOkATNnTMPNNy1DeFiYX31c8e5KfPzJagwdMhj/fO4phIVp29z35puWobyiEuPHjml1e0JCPI5nZaO+3tbheTN+3Quny4Xx48bAaIz02T571nS889/3kJ6xB263G3K53K/305sweCAfOo0MNapIoFnwINZVBLNLREREQeERRdS6XH7sGXyiKMLpckEJAYIgtLqPQaGArI1tneX2eLD86ecRaTBgwfx5SD2VG+l2u7H8yWexMz0DkQY9pkyeCLVajeNZ2di0eSu270zHi88/jRHDh3qP1fgLfXVNLe6858+IMhoxe9Z0mM0W7EzfjW++W4OS0jI8vfyRDvu1Zt2P+PiT1UiIj8NTyx9uN3AAgJFpIzAyre3teXkFAIABA1I6PHfWiRwAwNAhg1vdnpKcBLVaBbPZgtKyMp+Rjr6AwQO1qkZrBKxNz5W2qmB2h4iIKChqXS7MPXAg2N0ImA3jxsGoVAbkWBl79mLGtKl48P67Je279+zFzvQMREUZ8fa/XoZep/Nu+8dLr2PNug149/0PJYGATGiYSb/yw0+w6OIFuPnG673bDh/NxN33PoT03XtQXFyCxMSENvu0d98BvPzam9DrdXj6iUcRHRXV5ffndrvx4cefITcvH4MGpuKMWTM6fE1JacM079iY6Fa3C4KAKKMRxSWlKC4uZfBAoaNWFwU0KyytdjN4ICIioiYmkxnLrrvSpz0xIR7333MnIg16SeAAAPMvOB9r1m3A4SNHWz1meHgYbmixqtHokWlISIhHSUkpck7mthk85OUX4PGnnoVcLsMTf/urdySkM3JycvHDug2oqalF5rHjqKiswrlnn4k7/vg7v6YYWSwNv7xqtW2PdmhPjYRYrNY29+nNGDxQq0yRMZLnatTB43JCpgjMrxVERETUt0UZja3+cj4gNQUDUluf4hMV1bAgS+NNdksTxo2FspWRkSijESUlpW3ecNfU1uLhx56E1VqPvz3yEEa3Nw+pHUXFJfjiq2+9z8ePG4NxY0cjzM9cC6fTCTSbhtUa5altdnvfLMDL4IFa5YzzXZjVUVEBTULfG14jIiKiwGsMBFqTdSIHq7/4GocOH0FlVTUcDv9ulONiY1ptVygafvX3eESfbQ6nA48t/zuKS0px9ZVLMGvGNL/fQ0tnzJ6B9d9/gZraWuTm5WPVJ5/jldffwpp1P+KFZ5+AVqNp9/UqlQoA4GonT8bpbNimVqu63M9gYvBArQpLjITbo4Jc1vRlt+aWMnggIqJ+xaBQYMO4ccHuhl8aEqadUCqU7SZMB0pbv65n7NmLh//2FFwuF+JiYzFn9kzodBGQyWSwWq1Yu35jm8fsyupDX339PWz2hmVif9z4M65cshg6XUSnj9NcpMGAyHEGjBszGv/38HLs2bsPH370KW6+aVm7r4sIDwcAWNuZktS4rXHfvobBA7UqNU4NhycKWlnzQnGliOo4V4iIiChkyAQhYAnG3U0URTghQqlsO3joCW++/R+4XC6cf+5ZeODeuyQBQXFxSbvBQ1fY7HZcf+2VOJGdg+070vHSq//CI395ICDHlslkmHv+Odizdx8yft3XYfCQlNSQj1FeUdnqdrfbjcrKhjzS5KS++YNsSAcP2Tkn8b+Vq1Bx6iJdf81SzJoxNaDnKC4pxY5dGThy9BhqamthtzugiwhHYmICJk8ch+lTJ/fJNXyHRaphFSKhbVZluq6wpN3XEBERUf9mMplxMjcfALDsuqt97oGKigN/L7Ho4gX4zfXXoKa2Frdk/gm/bNmGtes34sJ553X4WovVinff+xBVVdX48313Qa1W++yj1TZMVTKZTB0eb8TwhqrRWSeyW92eczIXTpcLUUYj4lqZIt4XhGTw4Ha78d2a9Vj/4yZ4PJ5uO88Pazfgh3Ub4Xa7Je3VNbWorqnF4SOZ+GnTVvzupuvbnMPXW40yqrBHaUR0s3++urLyYHaJiIiIejkRTTkJrU0d+u6HdU37imJARkgMej1waqrRfX+6Aw8/9iRef/NtjBs7qsOlULUaDX7cuAkmsxnzzj8HM1vJlzh2PAsA2l0ittGkCeOh0Whw+EgmKiqrEBMtXSp20+ZtwKliccEcHTodsmB3INBKSkrx/IuvY+36n+DxeCCTdc9bXLN+I779YT3cbjc0GjUunHcu7rrt9/jzvXfit7+5FiPThgMACouK8dqbK2AymbulH90lLlyGOpW0MqK7hoXiiIiIqG16nQ6Rhoab+fTde7ztoijio1WrUV5R6b03a5y+E0gzpk3BJRfNR329Dc8895LPD7wtyWQyLJg/DwDwxlsrUNbih9LMY8fxxZcNqy+dd85Zkm0P/N+j+O0td+DgocPeNo1GjcWXLITH48Err78pSZzOOpGDL7/6FgqFAkuXXBqQ9xsMITXysHnrDqz+8hs4na6GD8MF56OsogLpu38N6HlKS8vx3Q/rgVPrEd93922Ibzb0NHBACqZMmoDVX3yDjZu2oLKyCl9+8wOWXbs0oP3oTjKZ0FAorlkldkU9gwciIiJq35LLFmHFuyvxwouvYfuOdGi1Ghw4eBgWiwUvvvAMHn38aeQXFOLR5c9g1sxpWHbtVX4c1X+33Hwj9u47gKOZx/D+h6tw47Jr291/2bVX4WjmMew/cAi//cMdmDxpQkMht+JS7N1/AB6PB2efeQYumHuu5HXFxSUoLStHfb1NerzrrsL+g4ewfUc6bv7DnZg4YRxMJjN27NoNl8uFe+66rU8Wh2sUUiMPmzZvg9PpQnSUEffceSsWzp/rrVgYSGvWb/ROh7ps0UWSwKG5xYsWeisM7tq9x5t70VdUh0uXYFM7q4PWFyIiIuobli5ZjBuuvxrRUUZs3b4Tu3bvwehRaXj1peeRkpyEW39/E+LjYpGbl4+ck7kBP79Go8ZDD9wDhUKBj1atlowMtLX/c08/jrvvuBUjhg3DgYOH8cPaDTh+4gTGjxuDP993N/760H1+z2ZRqVR4/u9P4MZl10KhUGDDxk3Yu+8AJk4Yh+f/vhwLLpwboHcaHEJmZqbvgrl91JN//yeSkxJx9dLF3sp+733wCXamZwABSph2uVx48OHlsNns0Gq1eOaJh73FPlqzbsNP+OrbNQCAyxYtxNzzzvbrPCNGjDitfnaFx+NBaWEe4pMHQCaT4f+e3YzrDz7u3S6KAka/+z0LxYWQltecQhuvd//Da+6//Px8pKamBrsbp0UURTidDiiVqj47n55a19bns63v+LFjx7qtLyH1l2Tp5Ytw0w3XtFsS/HRl5+TCZmtYS3jo4IHtBg5olnUPAIeOZHZbv7qDPUY6oiIIIpxVnLpERERE1F+FVPCQNmKYH3udnuZLjKWkJHW4f0pyojf6LyrqW0udquIMcHuk1Q/ri8qC1h8iIiIiCq6QCh56QmmzLPwoY2S7++JU9cXGpcrMFgvMFku39i+QEhPUcHikeQ+WvNKg9YeIiIiIgiukVlvqCWZz081/RIR/pc91ERGoqzN5X+9POfLurE/R0Tkb/3dwpAo2GKFFU8BQV1CCxCD0jbpHy2tOoY3Xu//hNfefKIoQxZBJAw2p90IN17O173EwvuMMHjrJ7nB4H3eU79BI0Ww/u93R7r6NSgvzutC7wCgvLgAAxNoF1Coi0XzsoSq/IKh9o+7ReM2pf+D17n94zTvmsDvgdPr3/9G9Xai8D2risNvavf/qye84g4dOcjqd3seKLgQPTpez3X0bxScP6ELvTo/H40F5cQFiE1Mgk8lgjBfxtSoSaP43yFIXlL5R92h5zSm08Xr3P7zm/isoKIBSqfJjz96tcbUlCi0qtQbxySk+7W19x01ZWd3WFwYPnaRUNi1T6mxWNbA9zasLqpT+LXMazD/yMpkMMpkMGhVQrYmSBA8ySyX/DygENV5z6h94vfsfXvOOCYLQ55c3bT5Vqa+/F5ISBKHd73BPfsf5l6ST1KqmaL75KER7mu+nVqu7pV/dpSasZaG4vlXojoiIiIgCh8FDJzWunAQAJpPZr9fU1tV5H+t1/iVZ9xa1hmjJc5WnDh4/p14RERERUWhh8NBJCfFx3sdVVdUd7m+3O2CxWAEABoO+WwvYdQdLdIzkuSCIcNVw9IGIiIioP2Lw0EkpyU2F4fIKCjvcPzcv3/s4NbnjonK9jSLWALcoTbyyl7JQHBEREVF/xOChkwYNTEVEREOdhuycXNjs9nb3P3wk0/t4/LjR3d6/QIuN18Dhblkorm9VyiYiIiKiwGDw0EkymQyTJ44HADgcDuzYldHmvjab3btdpVJhwrixPdbPQBkYo4K9RZVpcwGrTBMRERH1R1yqtRW3/+lB7+PljzyI6OgoyfYL552H7Tt3w+l04pvv1mD40MFITkqU7OPxePDRJ5/DZG5Iqj7vnDneEYu+ZGSkGuUKIyKbtdWVMHggIiIi6o9CJngwmczeG/Xm6uvrvY9ra+tQVCydciOXyxEfF9upc0Ua9LhyyaX44OPPYLPZ8Y+X38DZZ56BUWnDoVarUFpWjl82b0dObkMlwMEDB+DCued1+b0F05BIBU6oDEhuVtLCXlURzC4RERERUZCETPDwy5bt+H7thnb3+eb7tfjm+7WStiijEU889lCnzzd75jS4XC58/tV3sNsdWLfhJ6zb8JPPfqPShuPGZddApfKvOFxvo9cIqFEbgWbBg2Bm8EBERETUH4VM8BAMZ82ZhVEjR2Dr9l04fCQT1TU1cDqd0Ot0GJCagmlTJmHC+DHB7uZpEQQB1WFRgKWpTeXgUq1EREQUXO+t/Bjvf7gKy669Cjdcf3Wwu9NvhEzwcNGCebhowbyAHOv1l571e9/YmGgsvmQBFl+yICDn7o1qdEagvOl5Y6E4maJvjqYQERERtcZiseCFF1/Dlm07EB8Xi5Xv/rtLx7HZ7Fj12ef4ZfM2lJaVQaVUYciQQVi86CLMmT0z4P3uSVxtiTpkMbYoFAcWiiMiIqLQcjzrBP54533Ysm3HaR3HYrXirnsfxMoPP4HL5cJ555yFyZMmIPNYFh5/8lm8/+GqgPU5GEJm5IG6jxgTCbeoglxweNucFWVQxcQHtV9EREREgfDD2g149Y1/Q6lUYsniS7D6y2+6fKwV/30fOSdzMWf2TPz1ofugUDTcbhcUFuGuex/E+x+swvSpU5A2YlgA30HP4cgDdSgqTgVni0Jx1gJWmSYiIqIGHo8HNlv7hXN7s2++W4OkxAS8/tJzmDVzepePYzZbsGbtBsjlctx1+x+8gQMApCQn4aorLocoilj9xdcB6nnP48gDdSglXg272wiNoqm+g7mwFJ1b4JaIiIhCwdr1G/HCi6/i/HPPwtIli/HiK28gO/skfvfbG3D54ksAAA6nE2vWbsCGjT+jpLQMJpMZer0O48aMxrVXX4EhgwdJjvnOf9/Dqk+/wIP3343x48biP++uxK9796POZIIx0oCZM6bh5puWITwszK8+rnh3JT7+ZDWGDhmMfz73FMLCtO3uf+YZs7B40UJotVpUVlV3+d8m49e9cLpcGD9uDIzGSJ/ts2dNxzv/fQ/pGXvgdrshl8u7fK5gYfBAHRoRqYFVboShWZupmIXiiIgo9IkeEfY6T7C74RdRFOF0ueFWuCEIQqv7qPUyCLLWt3WW2+PB8qefR6TBgAXz5yE1Jbmh3e3G8iefxc70DEQa9JgyeSLUajWOZ2Vj0+at2L4zHS8+/zRGDB/qPVbjL/TVNbW4854/I8poxOxZ02E2W7AzfTe++W4NSkrL8PTyRzrs15p1P+LjT1YjIT4OTy1/uMPAAQCuuWrJaf1bNMo6kQMAGDpkcKvbU5KToFarYDZbUFpWhqTExFb3680YPFCHhkcqsF1pQKLY1GarKG/vJURERCHBXufBR1fkB7sbAXPNZ6nQRAbm1+6MPXsxY9pUPHj/3ZL23Xv2Ymd6BqKijHj7Xy9Dr9N5t/3jpdexZt0GvPv+h5JAQCY0zKRf+eEnWHTxAtx84/XebYePZuLuex9C+u49KC4uQWJiQpt92rvvAF5+7U3o9To8/cSjiI6KCsh79VdJacOPq7Ex0a1uFwQBUUYjiktKUVxc2ieDB+Y8UIdidbKGQnHNiCYWiiMiIurPTCYzll13pU97YkI87r/nTtx7122SwAEA5l9wPgDg8JGjrR4zPDwMN1x3laRt9Mg0JCQ0LNKSczK3zf7k5Rfg8aeehVwuwxN/+6t3JKQnWSxWAIBW2/Zoh/bUSIjFau2xfgUSRx6oQ3KZgOowI2BralPaKoPZJSIiIgqyKKOx1V/OB6SmYEBqSuuviWr4MbLxJrulCePGQqn0rSMVZTSipKS0zRvumtpaPPzYk7Ba6/G3Rx7C6JFpnXw3geF0OoFm07Baozy1zW53tLlPb8bggfxSpYsCmpV2UHnqILpcENr5chAREVHoagwEWpN1Igerv/gahw4fQWVVNRwO/26U42JjWm1XKBqmWnk8os82h9OBx5b/HcUlpbj6yiWYNWOa3+8h0FQqFQDA5XK1uY/T2bBNrVb1WL8CiXd+5BeTwbdQnLOmkrUeiIgopKn1MlzzWWqwu+GXhoRpB5QKVbsJ04HS1q/rGXv24uG/PQWXy4W42FjMmT0TOl0EZDIZrFYr1q7f2OYxu7L60Fdffw+bvWGZ2B83/owrlyyGThfR6eMEQkR4OADA2s6UpMZtjfv2NQweyC/uaD08ohIyweltc1WVM3ggIqKQJsiEgCUYdzdRFCF3yqFUytsMHnrCm2//By6XC+efexYeuPcuSUBQXFzSbvDQFTa7HddfeyVOZOdg+450vPTqv/DIXx4I6Dn8lZTUkMxdXtH69G63243KyoapHMlJfS9ZGkyYJn8ZYtRwuKUrFtiKWSiOiIiImphMZpzMbVidatl1V/uMJBQVlwT8nIsuXoDfXH8N7r37dhiNkfhly7aAByj+GjG8oWp01onsVrfnnMyF0+VClNGIuLi+WTGLwQP5JSFeDUeLKtOWAtZ6ICIioiYimnISWps69N0P65r2FX3zF7rCoNcDACINBtz3pzsAAK+/+TaKiosDcvzOmDRhPDQaDQ4fyURFZZXP9k2btwGnisUFc3TodDB4IL8MjVajXpBWSmShOCIiImpOr9Mh0tBwM5++e4+3XRRFfLRqNcorKiGTNdx+VrZyc326Zkybgksumo/6ehueee4luN3ugJ+j0QP/9yh+e8sdOHjosLdNo1Fj8SUL4fF48Mrrb0oSp7NO5ODLr76FQqHA0iWXdlu/uhtzHsgvaZEqHFRGonmGg7WcheKIiIhIaslli7Di3ZV44cXXsH1HOrRaDQ4cPAyLxYIXX3gGjz7+NPILCvHo8mcwa+Y0LLv2Kj+O6r9bbr4Re/cdwNHMY3j/w1W4cdm17e5fWFSMr7753vu84lS+gslkxhtvrfC2JyUlYvElC73Pi4tLUFpWjvp6m+R4y667CvsPHsL2Hem4+Q93YuKEcTCZzNixazdcLhfuueu2PlkcrhGDB/JLkkGGrWoj0GylNU8dgwciIiKSWrpkMZwuF9au+xFbt++EXq/DlEkTcMP11yAhPg63/v4mvPL6W8jNy0dCQlzAz6/RqPHQA/fg7vsewkerVmPq5IkYO2Z0m/tXVFTii6++9Wm31tdL2sePGyMJHtqiUqnw/N+fwKeffYmNP/+CDRs3Qa1SYeKEcbhq6WWYMG7saby74BMyMzMDM+GMAmrEiBE9fk6Px4PSwjzEJw/wDik299Idn2Ne7Rve53Z5JCa/+1kP95ICqaNrTqGF17v/4TX3X35+PlJT+8aSrG0RRRFOpwNKZdtLtVLf1Nbns63v+LFjx7qtL/xLQn6rDpOutqRy10JspwgKEREREYUWBg/kt9pIafDQWCiOiIiIiPoHBg/kN4fRAI+olLS5qiqC1h8iIiIi6lkMHshvEdG+tR4c5SwUR0RERNRfMHggv8XEKn2qTLNQHBEREVH/weCB/DYoXgObKC0UZ2ahOCIiIqJ+g8ED+W2kUQWLQho8WDltiYiIiKjfYPBAfks1KFCrluY8uGqYME1ERETUXzB4IL9FaoEqjTR4kFu5VCsRERFRf8HggfwmCAKqwqXTllQuFoojIiIi6i8YPFCn1OijJc8FiHDVVgWtP0RERETUcxg8UKfYjJE+heKcleVB6w8RERER9RwGD9Qpmkilb6G4KgYPRERERP0BgwfqlKhYlU/wYCvicq1ERERE/QGDB+qUlAQ1HB5p8GAuKglaf4iIiIio5zB4oE4ZEaWGRS4NHqxlHHkgIiIi6g8YPFCnDI5UoFZlkLQ5qlkojoiIiHrWeys/xryFl+G9lR8Huyv9iiLYHaC+JS5CQLUmCrA1tcksLBRHREREfVt2zkl89Mlq7D9wCKY6EyIjDZg8aQKuv/YqJMTHdepYNpsdqz77HL9s3obSsjKolCoMGTIIixddhDmzZ3bbe+gJHHmgTlHIBVSFtSgU56yB6HYHrU9EREREpyM941fccfcD2PTLVgwaMAAXzDsP8fFxWLt+I2694x7k5OT6fSyL1Yq77n0QKz/8BC6XC+edcxYmT5qAzGNZePzJZ/H+h6u69b10N448UKdV6aOBZnXhBIhw1VRCGd25qJyIiIgo2OptNjz3wktwulx45C8P4Kw5s73bPvv8K7z1zrt45vkX8dbrL0IQhA6Pt+K/7yPnZC7mzJ6Jvz50HxSKhtvtgsIi3HXvg3j/g1WYPnUK0kYM69b31V048kCdZtUb4BGlcaezinkPRERE/ZXH44HNZg92N7pk/YafUFNbh5kzpkkCBwC44vJLMXBAKnJO5iLj130dHststmDN2g2Qy+W46/Y/eAMHAEhJTsJVV1wOURSx+ouvu+W99AQGD9RpaqNvoThnFVdcIiIi6g/Wrt+IeQsvw9+ffxEnsnNwx58ewMWLr8L3a9Z593E4nfj62x9w170P4srrbsKCRUtx1fW/xZPPvIDsnJM+x3znv+9h3sLLsGHjzygrr8Dfn38JV133WyxYtBTX3vA7vPL6W7BYrX73ccW7KzFv4WW49Y57YbXWt7vvzvQMAGgzF2HWjGkN++3a3eF5M37dC6fLhTGjR8JojPTZPnvWdABAesYeuPvolG9OW6JO00c3BA8aRVNlaXspgwciIgo9oscDt7ku2N3wiyiKcLmcEBTKNqfXyCP0EGSB+e3Y7fFg+dPPI9JgwIL585CaktzQ7nZj+ZPPYmd6BiINekyZPBFqtRrHs7KxafNWbN+Zjheffxojhg/1HqvxF/rqmlrcec+fEWU0Yvas6TCbLdiZvhvffLcGJaVleHr5Ix32a826H/HxJ6uREB+Hp5Y/jLAwbbv7Z53IBgAMHTK41e1DhgyS7Nf+sXLaPVZKchLUahXMZgtKy8qQlJjY4TF7GwYP1GkJ8Ro43FGSNgurTBMRUQhym+uQefsVwe5GwKS9/hkUet9fxLsiY89ezJg2FQ/ef7ekffeevdiZnoGoKCPe/tfL0Ot03m3/eOl1rFm3Ae++/6EkEJAJDQHNyg8/waKLF+DmG6/3bjt8NBN33/sQ0nfvQXFxCRITE9rs0959B/Dya29Cr9fh6SceRXRUVJv7AoDD4UBVVTUAIDYmutV9YqIb2otLSjv4FwFKSkvbPZYgCIgyGlFcUori4tI+GTxw2hJ12vBYFeoF6R8eS2nHXygiIiIKHSaTGcuuu9KnPTEhHvffcyfuves2SeAAAPMvOB8AcPjI0VaPGR4ehhuuu0rSNnpkGhIS4gEAOSfbXvUoL78Ajz/1LORyGZ7421+9IyHtaT4VStvGCIVW29BusXQ8bapxn8bXtHq8U+fpzDSs3oQjD9RpQwxK7FFJcx4cTJgmIiLqV6KMxlZ/OR+QmoIBqSmtvyaq4f6hrRvxCePGQqlUtnqukpLSNm+4a2pr8fBjT8JqrcffHnkIo0em+fUenE6X97FS0fptsVLZ0O5wOPw4nhNoNg2r1eOd2ma3d3y83ojBA3VaUqQMP2oiAWdTm2BmoTgiIqL+pDEQaE3WiRys/uJrHDp8BJVV1X7deANAXGxMq+0KhRwA4PGIPtscTgceW/53FJeU4uorl3gTnP2hUjUFKk6XC6pWApfGgEClUvlxvIZ9XC5Xm/s0BixqdcfH640YPFCnhakEVIUZgdqmNqWjGqLbDUEuD2bXiIiIAkoeoUfa658Fuxt+EUURTpcTyg4SpgOlrV/XM/bsxcN/ewoulwtxsbGYM3smdLoIyGQyWK1WrF2/sc1jyrtwH/HV19/DZm9YJvbHjT/jyiWLodNF+PXasLAwCIIAURRhtVqhMhh89mkc7YgID+/weI37WNuZkmTtxPF6IwYP1CWVEdGS4EGACFdtFZRRscHsFhERUUAJMlnAEoy7myiKEJ0OKJQqv4qZdZc33/4PXC4Xzj/3LDxw712SgKC4uKTd4KErbHY7rr/2SpzIzsH2Hel46dV/4ZG/PODXa1VKJWJjYlBWXo7y8gpEthI8lJU1TM1OTu44uTkpqSGZu7yi9RkZbrcblZUNlXaTk/pesjSYME1dZdHrfQvFVZa3uT8RERGFPpPJjJO5+QCAZddd7TOSUFRcEvBzLrp4AX5z/TW49+7bYTRG4pct2zoVoDQuGdu4zGpLx45nAQDSRgz341jDTh2r9WVdc07mwulyIcpoRFxc3/zBlcEDdYncoGilUByDByIiov5MRFNOQmtTh777oamQnCj65i90hUHfMBUr0mDAfX+6AwDw+ptvo6i42K/XNxZu27x1u882t9uNrdt3Au0UkWtu0oTx0Gg0OHwkExWnRhia27R5m/ecwRwdOh0MHqhLIqJ8q0w7OPJARETUr+l1OkQaGm7m03fv8baLooiPVq1GeUUlZKeK1FW2cnN9umZMm4JLLpqP+nobnnnuJb+qOJ9z1hzEx8Uiffce/Lxpi2Tb/1Z+hPLyCkycMA6jRo6QbHvg/x7Fb2+5AwcPHfa2aTRqLL5kITweD155/U1J4nTWiRx8+dW3UCgUWLrk0oC832BgzgN1SUycGg6PNHioL2KtByIiov5uyWWLsOLdlXjhxdewfUc6tFoNDhw8DIvFghdfeAaPPv408gsK8ejyZzBr5jQsu/YqP47qv1tuvhF79x3A0cxjeP/DVbhx2bXt7q9UKvGXB+/Fg3/5G55+7p/4Yd0GJCUmICsrG0ePHUdMdDQeuPcun9cVF5egtKwc9fU2Sfuy667C/oOHsH1HOm7+w52YOGEcTCYzduzaDZfLhXvuuq1PFodrxJEH6pLB8WrYPdKqjWY/Ki8SERFRaFu6ZDFuuP5qREcZsXX7TuzavQejR6Xh1ZeeR0pyEm79/U2Ij4tFbl5+u0XfukqjUeOhB+6BQqHAR6tWS0YG2jJ61Ei88eo/cO7ZZyLnZC7WrvsR1TU1WLzoIrz52j/bXEK2NSqVCs///QncuOxaKBQKbNi4CXv3HcDECePw/N+XY8GFc0/zHQaXkJmZGZgJZxRQI0aM8GOvwPJ4PCgtzEN88gDvkGJb9hW4kHXfuxip+tjb5owZjokv/qsHekqB0plrTn0fr3f/w2vuv/z8fKSmpga7G6dFFEU4nQ4og7zaEgVeW5/Ptr7jx44d67a+8C8JdUlypAw1GunSdaKJheKIiIiIQhmDB+qS6HABVVrptCWlvQaiH4lJRERERNQ3MXigLhEEARXh0oRpAR64agO/cgIRERER9Q4hudpScUkpduzKwJGjx1BTWwu73QFdRDgSExMweeI4TJ86uUvlz1sSRRGHj2QiPWMvcvPyUVtXB5fLDa1Gg7i4WIwYNgSzZk5DTHSUH0fre0z6SHhKFZAJTcuQOavKWWWaiIiIKESFXPDww9oN+GHdRp91fatralFdU4vDRzLx06at+N1N13cqc76l2joT/vvehzie5VtB0GyxwJxjQXbOSWzYuAkL5s/F/HnndflcvZWgl8PhNkKjaKrv4KyqCGqfiIiIiKj7hFTwsGb9Rnz7w3rg1DJdZ585G2nDh0Gj0aCishLbdqTjaOZxFBYV47U3V+CBP93eavXDjtjsdrz82lsoLWu4aY6OMuLcs+cgISEOEeHhqK0z4fCRTGzdthMutxvffLcWHrcHC+f37aW5WtJEKn2Dh8qyoPaJiIiIiLpPyAQPpaXl+O5U4BAeHob77r4N8XFN02cGDkjBlEkTsPqLb7Bx0xZUVlbhy29+wLJrl3b6XBt+3OQNHEYMH4rb/vBbKBVN/5SpAMaOHomJ48filTfehiiKWLN+I2bOmIIoo7GdI/ctUbEqn0JxthIGD0REREShKmQSptes3wiPxwMAuGzRRZLAobnFixYiNiYaALBr9x5UdKE0+p69+72PL1l4oSRwaG7E8KEYOWIYAMDtdmP/wSOdPldvlpqohsMtDR4sLBRHREREFLJCInhwuVzYf/AQAECr1WLqlIlt7iuXyzF75jTgVGGNvfsOdPp8lVXV3sepKUnt7puSkux9XNXsdaFgeJQaZrk0eLBXlre5PxERUW8miqybS71Pb/tchkTwkJ2TC5vNDgAYOnhgmyMBjUYMH+Z9fOhIZqfPp1QqvY89nvYvaONoSMPrQmaWGAAgJVKO2haF4jy1LBRHRER9j1KphNPpDHY3iHzU19dDo9EEuxteIRE8FBWXeB+ndDASAAApyYnesu1FRSUd7t/S4IFN5cFzcvPa3begsKjZ6wZ0+ly9WbxOQJVWGjwobNUQPSwUR0REfUtERARqa2uD3Q0iCVEUUVVVBb1eH+yueIVE8NCYvAwAUcbIdvcFAIVC4V1lyWyxwGyxdOp85517pvfx19+ugd3uaHW/o5nHcez4CQBAQkIcRo9K69R5ejuVQkBFuLSGhQAPXDWhNT2LiIhCX3h4OJxOJ6qqqiSzBoiCQRRFWK1WFBYWQqfTQa1WB7tLXiExj8Zsbrr5j4jwb+lVXUQE6upM3tdHhIf7fb5RaSNw+aUX4Yuvv0duXj4ef+o5nHfOmUhOSkRYmBZV1TU4eOgodu3eA1EUERERjpt/cx1kMv9jtWD84Wo8Z2fOXRuhg6dCWijOUVEKeWRoFsYLNV255tR38Xr3P7zmnRMfH4+6ujoUFBQEuytd5rDboFL3niku1HVqtRrR0dFQq9VtfoeD8R0PieDB7mj65b+jfIdGimb7tTVy0J7zzz0LyclJ+GnTFhw8dARffP29zz56vQ6TJ47HBeefA4Ohc8NNpYXtT4fqTuXF/v/RdIfL4HBHQqNoKg5XkXUEKq3/wRgFX2euOfV9vN79D6955yiFYPeg65QaFQAGi6HA46hHTUW9X/v25Hc8JIKH5glOii4ED05X5xOk7HYHjmedQGFRcZv7mM0W5OUX4kTOSUyeOL5Tx49P7vn8CI/Hg/LiAsQmpvg9SqI2FsPhjpIED+ECEBWE/lPndeWaU9/F693/8Jr3L7ze/U9b19yUldVt5wyJ4KH56kdOl6vdfRu5mu2navZ6f5jMZrzy+tveRO1JE8fh7DmzkZKSBJVSiTqTCcezsrF2w0/IzjmJ7JyTyJx9AtdceZnf5wjml14mk/l9/sho30Jxjopy/tHqYzpzzanv4/Xuf3jN+xde7/6nJ695SHyy1CqV97G/y6w136+zSSgrP/rMGzgsnD8Xv7vxegwfNgRajQZyuRzGyEhMnzoZD957FwadWplpy7Yd2LV7T6fO0xckJrRSKK6YVaaJiIiIQlFIBA+NKycBgMlk9us1tXV13sd6nX9J1ji1LOzBQw2Voo2RBsyfd16b+6pUSixetND7fMPGX/w+T18xNE6NekiDB1sFgwciIiKiUBQSwUNCfJz3sT9VnO12BywWKwDAYNBDq9X6fa6sEznex8OGDoFcLm93/yGDBjbVlCgu6VJydm820KhAnbplobiKNvcnIiIior4rJIKHlOSmwnB5BYUd7p+bl+99nJrccVG55qzWpqx3larjXAm5XO6dgyaKIupttk6dr7dL1MtQ2aJQnNzKQnFEREREoSgkgodBA1MREdGwNGh2Ti5sdnu7+x8+kul9PH7c6E6dKyysaZSitrau3X1xasUlt7vpRjo8zP9Rjr5ApxFQGcZCcURERET9QUgEDzKZzLsUqsPhwI5dGW3ua7PZvdtVKhUmjBvbqXMNHJDifZyVndPhSMLho8e8j5MSEyQrQ4WK6ggdPKJ04S5nVXmb+xMRERFR3xQSwQMAXDjvPO+N+TffrWm1/oLH48FHn3wOk7khqfq8c+Z4Ryyau/1PD3r/q6yskmwbkJqCpMQE4FQgsuqzL9us6ldnMuHbH9Z5n8+cPuU032Xv5NYp4XBLpy65qhk8EBEREYWakKjzAACRBj2uXHIpPvj4M9hsdvzj5Tdw9plnYFTacKjVKpSWleOXzduRk9tQuXnwwAG4cG7bKyW1RRAEXHvV5Xj59bfhdDqRvvtXlJSUYvbM6UhJToRKpYLFYkVWdg42b9nhDVQGDUzF2WfODvj77g3kejkcbqOkUJyzksEDERERUagJmeABAGbPnAaXy4XPv/oOdrsD6zb8hHUbfvLZb1TacNy47Bq/Ep5bM3jQQNzxx5vx3gefoLKyCvkFRVj12Zdt7j9u7Ggsu2ap39Wv+5qIKBUcHmneg4PBAxEREVHICbm72bPmzMKokSOwdfsuHD6SieqaGjidTuh1OgxITcG0KZMwYfyY0z7PsCGD8chD9+LXfQew/8Bh5BcUwmQ2w+l0QaNRI8poxKCBAzB96iQMHTIoIO+tt4qLU/kUirOWsNYDERERUagJueABAGJjorH4kgVYfMmCLr3+9Zee9Ws/pVKJ6VMnY/rUyV06T6gYlKCG3SPNebCVM3ggIiIiCjUhkzBNwTM4SoU6tXTkwV3DQnFEREREoYbBA522JIOAmhZVpmXWKhaKIyIiIgoxDB7otMWEC6hoWShO9MBVy0JxRERERKGEwQOdNplMQFW4Dh5RLml3VnHqEhEREVEoYfBAAeHUKeBsseKSq4pJ00REREShhMEDBYSgk8PeInjgyAMRERFRaGHwQAGhjVTC6WkRPLBQHBEREVFIYfBAAREVq4LdLU2ari/jtCUiIiKiUMLggQIiNVHjk/PA4IGIiIgotDB4oIAYEq2EWSGt9eCq5rQlIiIiolDC4IECIjlSjmpNi0JxlmoWiiMiIiIKIQweKCDi9QIqtdJpS4LoZqE4IiIiohDC4IECQqMUUBmmZ6E4IiIiohDG4IECxt5qoTjmPRARERGFCgYPFDCiTgZHy1oPDB6IiIiIQgaDBwoYlUEJh0+VaQYPRERERKGCwQMFTGSUyid4cFSw1gMRERFRqGDwQAGTmOAbPFhLGTwQERERhQoGDxQwg+PVqEfLaUtcbYmIiIgoVDB4oIBJNcpRo2lR68FcxUJxRERERCGCwQMFTIJehkqttMq0ILrhqqsJWp+IiIiIKHAYPFDAGLRAZZjOp1Acaz0QERERhQYGDxQwgiDAFqGA0y0dfXBWMnggIiIiCgUMHiigXBEyODxRkjYmTRMRERGFBgYPFFByfWuF4rhcKxEREVEoYPBAAaWLaiV44LQlIiIiopDA4IECKjbOt1BcfTmDByIiIqJQwOCBAmpQohp2jzR4cFRy2hIRERFRKGDwQAE1IEqJOpU0eEBdFUSPJ1hdIiIiIqIAYfBAAZVoEFAZ1lqhuOqg9YmIiIiIAoPBAwVUbISASi0LxRERERGFIgYPFFAKuQBruNy3UBxrPRARERH1eQweKOCcEXI4PFyulYiIiCjUMHiggBN0CjjcLatMM3ggIiIi6usYPFDAaSMVPrUeXNUMHoiIiIj6OgYPFHBRsa0VimOtByIiIqK+jsEDBVxqosYn58FRwZEHIiIior6OwQMF3KA4JcwyafAg1lWyUBwRERFRH8fggQIu0SBDdZhB0iZ43HDV1QStT0RERER0+hg8UMAl6AVUavUsFEdEREQUYhg8UMCFqQSYw+VwuqWjD1yulYiIiKhvY/BA3cIRLoPDw1oPRERERKEkKMGDyWyGzW4Pxqmph3h0cp/lWlllmoiIiKhvUwTyYBUVldi4aQumTp6AIYMH+Wxfv3ETNv68GSaTGQCQEB+HixbMw6QJ4wLZDeoF1HolC8URERERhZiAjTwcPHQETz33In7Zsh2FRSU+2z/+9At89c0P3sABAEpKy7Di3Q+wdfvOQHWDeglDjBIOt3Takj1ERh5stW4c/boO+Tus8LjFYHeHiIiIqMcEZOTBZDbj3fc/htPpanjeLEAAgOyck9iyrSlAiIoyIjwsDAWFRRBFEZ998S3Gjh4Fg0EfiO5QL5AY71sozh4CVabdDhE/3FuCmlwnAGDyTZGYcF1ksLtFRERE1CMCEjxs257uzWG4eullOGPWdMn2H3/a7H180fy5WHDhXABAQWERXnrt37DZbNi+azfmzzsvEN2hXmBgghJVojR48NQ2FIoTZH03T79gl9UbOADA/o9rMWapHgpV331PRERERP4KyB3PkcxjAIBJE8ZhzuwZEATBu83hcODQkaMAgMSEeG/gAAApyUk484yZAIDMY1mB6Ar1EslGOaq10l/kBY8bblNt0PoUCMX7bJLnrnoRxXtsbe5PREREFEoCEjyUlTXMZZ800Tfx+VhWNlwuNwBg2pRJPtuHDx0MACgt7ftTWqhJgkFApVbnUyjOWdm3r3PJPt9AIXeLNSh9ISIiIuppAQkeLNZ6AECU0eiz7djxphGFMaPTfLbrdDoAgLW+PhBdoV4iKkyAqdVCcRVB69PpstW6UZ3t9GnP28bEaSIiIuofAjpRW6GQ+7QdO34CABARHo7kpESf7R5Pw6iE6OHNVygRBAG2MJlP0rSzqu+OPJQeaH16kr3O0+Y2IiIiolASkOBBq9UAAGpr6yTttbV1KCgsBgCMGD601dfWnVqZSa1RB6Ir1Iu4I2S+heL68MhDyf62AwROXSIiIqL+ICDBQ0JcHADgSOZxSfvW7bu8j8eOGdnqa49nZQMAoqOiWt1OfZdCr/Cp9eCq6ru1HlrLd2iUu9UKUeToGREREYW2gAQPaWnDAAC/bNmOjT9vRnFJKbbvTMe6H38CACiVSowfO8bndTU1tdiVvgcAMHjQgEB0hXqRcKNvlWlHH02Ytte5UdVKvkMja7kbFZmOHu0TERERUU8LSJ2H2TOnY8OPm2B3OPD5V98BX30n2X72mbOhaTEtae/+g/j62zUwWywAgGlTJgaiKwCA4pJS7NiVgSNHj6GmthZ2uwO6iHAkJiZg8sRxmD51MuRy3/yMrsrNK8C2Hek4nnUCNbW18Hg80Ov1GDQgFbNmTMWokSMCdq6+JD5OA4cnNKpMlxywA80GFtxywBMhh7LW7W3L22pF7EhOvyMiIqLQFZDgwaDX4fprl+Ld9z+G2+2WbBs+bAguWXiBz2s2/rwFZeUN89+nTJ6AwYMGBqIr+GHtBvywbqNPP6pralFdU4vDRzLx06at+N1N1yMuNua0zuXxePDF19/jp01bfKasVFZWobKyChm/7sOUSePxm+uvDmjA0hcMSFL5jDy4q/tmobiWU5ZywpQo1MpxdrPgIXeLBVNu9l1xjIiIiChUBCR4wKkCcUkJCdi6YydKSsuhVCqQNnwYzpg1vdWb5pTkRGTnnMTsmdNw5ZJLA9KHNes34tsf1gMANBo1zj5zNtKGD4NGo0FFZSW27UjH0czjKCwqxmtvrsADf7odOl1El8+36rMvsWXbTgBAbEw0zj17DlJTkuF2u5FzMg8bf94Mk9mMjF/3IywsDFcvvSwg77OvSI5RYK9KulSr4HHBbaqFwtC3brJ9gocIOY7rlTi7pKm9Nt+FmlwHIgeqgtBDIiIiou4XsOABAOLjY3H5pRf7te+c2TNw9pmzER8XG5Bzl5aW47tTgUN4eBjuu/s2ybEHDkjBlEkTsPqLb7Bx0xZUVlbhy29+wLJrl3bpfHv27vcGDsOHDcGtv78RGnXTlJXhw4Zg0sRxeOHF12G2WLBl206cc+ZsJCTEn/Z77SsSDQI2hhsgijIIgsfb7qwq71PBg93kRlV2Uz5DYvgPuAc/oMJqRJHmZshsTfk6uVusDB6IiIgoZAVt7khSYkLAAgecGnXweBpuUC9bdFGbx168aCFiY6IBALt270FFZVWnz+V2u/HNd2uBUyMcN//mOkng0Cg2JhqLLr4QU6dMxMULL+hzU3VOV7xOQF2YDA5PpKTd2cfyHkqb5TsYVAeRql+NMFgxwFWIwZHvS/bN3colW4mIiCh09fjdbElJKfbs3Y8Dh46gzmQKyDFdLhf2HzwEANBqtZjaTvK1XC7H7JnTgFM5C3v3Hej0+Y5lnfDma5x5xqx2pz6dMWsGblp2DebPOy+gwVJfoJQLqA8TfGs9VPet4KFpypIbqfpPJNvihRyoZJXe55XHHDCXunq4h0REREQ9I6DTltIzfsW6DT/j4oUXYMI46dKsFosV7678GEeOHvO2CYKAM8+YiSsuuwSy0/hVPjsnFzabHQAwdPBAKBXtv60Rw4d5Hx86kom5553dqfPt3XfI+3jShLGd7m9/4gyX+wQPfa3WQ/Gp4CFWuwVhyiKf7VrtQTgsTZ+h3C0WjFli8NmPiIiIqK8L2MjD92s24H8rV6G4pBSVLaYCiaKIt1b8TxI4NLb/smU7Vn321Wmdu6i4xPs4JSWpw/1TkhMhCELDa4tKOty/peyckwAAhUKB1JRkb7soiqgzmVBWXoH6+vpOHzcUCTrf4KEvTVuym92oOuGATKhHiu7LVvdRRRySPOfUJSIiIgpVARl5KCouwfdrNzQcUCGHVquRbN+9Zy+yc3KBU9OGpk6egPDwcOzbfxCVVdXYtmMX5syegVQ/bvxbU1rWdDMaZYxsd1+cuunX6SJQV2eC2WKB2WJBRHi4X+fyeDzeKUsxMVGQyWQoLSvHug0/Ye++g7DZ7d59ExLiMGvGNJw9ZxaUSmWX3ltfp41U+lSZdvahkYfGfIck3Q9QylufZpckO4QKOCFC6X1NfbUbWmP/WpqXiIiIQl9AgoftO3cDANRqFe6581akJEuDgF+27PA+vvV3v/EWTVt44Vw8+49XUF5RiZ3pGV0OHsxmi/dxRIR/S6/qIhqCh8bX+xs8VNfUwuVqmNMeER6OAwcP4z/vfQSHw7e6cElJGb746jtk7NmLP95yE/Q6nZ/vCN7k757UeM5AnjsqRgmHRzryYKsoC8r764rivfVQySqREL6+zX3UsEOjOY562+iGBhHI3WbBiAVdXwa4p3THNafei9e7/+E17194vfufYFzzgAQPWSdyAACzpk/1CRzqTCbknGwYdUgbMUxSbVmjUePMM2bi86++804F6gp7sxv3jvIdGima7We3+974t8Vma1rX32y24N2VH0OlUmLxJQswfuxo6PU6mMwWHDx0BN/+sA4mkxl5+YV4+z8rcc+df/A7t6O0MM/vPgVaeXFBwI5lCFO2WiiuJP9kn1h9qiADSNF/Dpng9La5IUOZPBaJ7lJvm6A7BDQGDwCOb6iCYXznV/IKlkBec+r9eL37H17z/oXXu//pyWsekOChMceheWDQ6GhmlvfxlEnjfbanpjbkDHRlydRGTmfTjZ2iC8GD0+Vsd9/m7M2mJZWUliEiIhwP3HMHYqKbpuZEGvSYM3sGRqUNx7P/fBUWixXZOSexe89eTJ862a/zxCcP8GOvwPJ4PCgvLkBsYsppJbA3l2Z14aSsVNImeFyIMRig0PfuWg8Osweeol8QE71T0v5N+Hw4NXosrfzY2xarPIBcNNUMqToKGCNToArv3QFSd1xz6r14vfsfXvP+hde7/2nrmpuystp93ekISPDQOM9fr/edlnM864T38ag03+AiTKsFANhtdp9t/mqeT+B0+bdMpqvZfqrTyEdYeOFcSeDQXHR0FBbOn4dPVzckhG/fudvv4CGYX3qZTBaw86cY5dgTrvcpFOeuroQqMjog5+guZYfqkar7VNJmFsLwnu4qXDagAmgWPMSLRShUlsPlbFiO1+MEitJtGHJe75+6hABfc+r9eL37H17z/oXXu//pyWsekLPI5Q2HEUXRZ1vmsYbIJzYmGsZWkpkbf8k/nSksalVTRd/moxDtab6fupUCb22eq8W+48aOanf/yRPHeR/nnMzrd/MQEw0ymForFNcHkqbLN26CTnVc0vaBbinq5Hokjx0BT5h0OVan/rDkee4WrrpEREREoSUgwUNEeMOvq+UVlZL2wqJiVFXXAABGpg1v9bU1tXUAgLAwbZfP37xIm8lk9us1tXV13sf6doq8tdQ4UtLIoNe3u79ep/O+N6fTCWs/W8I1Qi3ArG2lUFwvDx48TgfkmSslbdWIxZcRFwEApgxUwjBxmmS7Xn1Q8rxgVz1c9v4VLBIREVFoC0jwkJSUAADYnbFX0r5h4y/ex+PGtP4L/cFDRwAAcTExXT5/Qnyc93FVVXWH+9vtDlgsDb8KGwx6aLX+By6RkQao1c1HOjqeJtV8WpTb5fb7XKHCES7rc4Xiyr/7EkqxTNK2SnM9nIISchkwMUUOw8QZku1DxENAs8Rql01E0R4biIiIiEJFQIKHxsDgwKEjeOud/+GXLdvx3gerkJ7xKwDAoNe1OvKQdSIHGb/uBwAMHzaky+dvvsJTXkFhh/vn5uV7H6cmd255WEEQkJSQ4H3eWPOhLaIoSkYbwsLDOnW+UCC2Viiuqv1/t2BymWpR8e0HkrY6x1B8GTkHADAqQYYwlYDwcVMgCk1fITUccBqlCUqcukREREShJCDBw4zpUxAV1XBzeODQEXyy+ivs2v2rd/slF833SeL46psf8PpbK+B2uyGXyTBzxtQun3/QwFRERDTUacjOyZUUamvN4SOZ3sfjx41ud9/WjBmd5n18NPNYu/uWlJbB4Wj4NTouNsbvpWRDiUqv8Kn14Kwsa3P/YCv/ciVgt0jadjmvgetUbs+UAQ3F3xQResgGjpTsJ9NIpy7lb7PC4/bNBSIiIiLqiwISPCgVCtz2+xsRG+O7es6Fc8/FzOlTfNoLioq9U34WXTwf0VFdX7ZTJpNh8sSGZWAdDgd27Mpoc1+bze7drlKpMGHc2E6fb8rkiRAEAQCwacv2dutEbNu+y/u4taVs+4PIaLVPlWl7Lx15sBcXoOrHryVtlfXTkR7eNO2uMXgAgJip0yX7DhL2SY9n8qBkP6cuERERUWgI2M/gCQnxePihe3H46DGUlJZBqVQibfhQJCbEt7p/SnISiotLcOklCzBtyqTTPv+F887D9p274XQ68c13azB86GAkJyVK9vF4PPjok89hMjckVZ93zhzviEVzt//pQe/j5Y88iOgWS7HGxcZg1oyp2LYjHTU1tVj50ae46YZrfEZXjh7Lws+btwGnApxzzjrjtN9nX5SUqPItFFdVDne9FXJt75rGVfrxvwF3U16KR1Qg33Q5cuKa8laaBw+6CTNQ/tm73ueJnhJkR1VAWdWUw5O3xYqkSV1fEICIiIiotwjoHBq5XI5xY0a1mRzd3IVzz8Wiiy70/oJ/uiINely55FJ88PFnsNns+MfLb+DsM8/AqLThUKtVKC0rxy+btyMnt6Fy8+CBA3Dh3PO6fL5LL1mAE9knUVpWjj1796Oyqgrnnj0H8XFxsNbX48DBw9i8dYd3adZFF89HXGzXk8L7suREFcrEFrUw3C4UvPYkBtz7BAS5vK2X9ijLkb0w7dkmaSuxzIXVE4P88IavijFMQKnShJeyyhGjVOK2xAFwhRuhsDQl6lu1h2DA2d7nuVutmHF7FARZYD7rRERERMEStAn4Go3/tRX8NXvmNLhcLnz+1Xew2x1Yt+EnrNvwk89+o9KG48Zl10Cl6npxuIjwcNz5x9/hnXdX4mRuPnLzCvDu+x/77CeTyXDJwgsx77yzWz1Of5AYKcMxrQF19hHQq5tyRMz7d6H4/deQ+Ju7AhZEdpXo8aDkw7ckbU63DsXmhcgPV8Apb+jf2GEu3JedA/upmiY1LhfumDAd9dvWel8XJ98Pe7PgwVrhRsUxB2JHBv4zT0RERNSTui14qK6pQUFBEWpq62Cz2QBBgFajgdEYiYEDUhAR7jtdKBDOmjMLo0aOwNbtu3D4SCaqa2rgdDqh1+kwIDUF06ZMwoTxYwJyLqMxEvfdfRsyft2HjD37kF9YBLPJDIVSgSijESNHDMNZZ85uNRekP0kyCDCFAznlN2J09NNQyptqcVT/+A1U8cmIWXBFUPtYu20DbCelBeEKzYvgFsOQo2sKMoXBVd7AAQB+qa3FvROmSIKHUc7DyDC6IK9u+nrlbrYweCAiIqI+L6DBgyiK2LJtJ37Zsh3FJaXt7jtsyGCcf+6ZGDe286sddSQ2JhqLL1mAxZcs6NLrX3/pWb/3lclkmDZlUkDyNkJVdLgAU5gAuzsOx6vvwMjoFyATmupjlH70FlSxCdBPnROU/nnsNpR+8h9JW70zEWXWswDAGzzItE7kqGsl+4kAdqUMwXBBBpnYMEVNBSdMhixEVjetxJS7xYopvzMGfYSFiIiI6HQEZLUlnFrF6MVX38Sqz77sMHAAgKzsHLy14j28/+GnEEUuZRnKZDIBNm3DTbPZOQzZNTdLdxBFFPzrGdRnHw1K/yp++AyuaunqT3mmpQDkcAlA3ql8B11aDdzw/axusDshDpAGwTLxgOR5XaELNblOEBEREfVlAQseVvzvA2Tn5Hqfa9RqDBk8EFMnT8QZs6Zj9sxpmDJpAgYNSIVS2TTgsTM9A6u//DZQ3aBeyh3RlBRdZZuGw8rLJNtFhx15/3wEjoqOA89ActZUovJbaa5KrX00au3jAAAFp/IdZCo3wofWtnqM3SYTDFOmSdrGuH+FYJB+vVgwjoiIiPq6gExbOnosC0eONiTCxsZE47JLL8KYUWmQt7GKjsPhxJ69+/H1d2tQV2fCps3bcMas6W0u60p9n0KvANC0BGp+/YWYfb4NNZt+8La5aquR98JfMfjRlyAPi+iRfpV99i489qY6DCIE5NUtBdAwUtI4ZSl8eA0gb32EzA3gyLBRSG3Wluguw9GESoTXNi1Rm7vFionXR3bbeyEiIiLqbgEZecjYsxcAYNDrcP+fbsf4saPbDBwAQKVSYub0Kbjvrj9Cq9VAFEVJMTUKPRFG6cpW4XVyiNfcivAx0lwRe+FJ5L+yHKLLhe5myz2Bml/WSNoqrHNQ72oKA7J1CggKd0Pw0I41Gh0c4dLE+Dq3dOpSVZYDpmJOXSIiIqK+KyDBQ+N0pXPPnoPwcP+LfkVHR+HsObMBAMeysgPRFeqlEuI0kucqu4D/HC1H6p2PQZ08ULLNcmgPit59uVtzYURRRMlHbwLNz6HUoMC02Pu0Id9BibChdZCpPJLX3xgvHSXbYTZDPU46dSnVuRfyCOlXLG8rpy4RERFR3xWQ4KHOZAIADBo0oNOvHTF8KHBqaVcKXUkDVLAppcFA0QYrcmRyDLjvKSgM0grUNZt+QMV3q7qtP+Z9O2E59KukzZm8GE6Pwfu8MEwBp1JExIhqyX7nGAy4MT4eimYrJzlFEeWjx0r2G+s4DPtg6Xtm3gMRERH1ZQEJHhx2BwBArer8OvZarRYAYLfZA9EV6qUSjTLsj5J+Pkalq/F6QRFUsQlIvecJCC0+P2Wr3kHtzk0B74vocqHko39L2hTGGBRWz5W0ZeuUCBtcB7nWLWm/KSEBOoUC03U6Sfu6+FR4hKbpeiq4UKXIlOxTesiO+mrp8YiIiIj6ioAED9qwhgCgprb11WjaYzo1atEYRFBoSjLIkB4lvcb6GjlyMizYazYjbOhIpPzx/4AWdRAK3/o7rMcPB7Qv1T9/B0dRnqQtZvFvUS6tEYccvQIRadJRh+k6HcaeKnB4XqQ0+flnhxP2VGkBQrlpLxTaZu9J5NQlIiIi6rsCEjw0VlA+cLDzN3n7DhwCAMRERwWiK9RLJRkE1BnlKA6TJtKP3qXGq4WFEEUR+qlzEH/1LZLtotOJvBcfhaOsKCD9cFvNKPv8PUmbZvAI1OvOgNhsQMAtAGUj66GIkCZu35SQ4H18jsEg+QLZPB7YJkyQ7D/FtgfKNOmISi6DByIiIuqjAhI8pA0fBgDYvnM3Dh3J7HD/RgcOHcG2HekAgJEjhweiK9RLKeQCzh2pRHqM9EZ6yCEVjpZZsaWuDgAQveAKGM+7WLKP21SD3Bf+CrfFdNr9KP/6I7hN0hGyhGv+gNL9DklbQZgC6rHSPJwxYWGYFtG0hKxRqcTkCOmSstsGDpU8j3NXoMJQJmkr/rUeDrM0AZuIiIioLwhI8DBn9gwoFAqIooi33vkfPvj4M2SdyIGzleU2nU4nMo9l4X8rV+HfK96DKIpQKpU484xZgegK9WLzRimwN0oNZ7NZPHK3gLQMFV4rLIRHFCEIAhJvuBMR46UrFzmK85H38t/gcXV9qVNHWTGq1n4uadNNOQPhoyagZL9N0p6XJEIZKQ0obkpIgNBiWlXLqUvfqsJRHx4raaup3QtZs5VqPS4gfydHH4iIiKjvCUiRuMhIAy69eAFWf/kNPB4Ptu/cje07d0MQBOj1OqhVKgCA3W5HncnsswTnFZddAoNe18bRKVScN0IBh1KGg0YVJlU13ZiPTlfjozPrsKa6GgujoiDI5Ui542HkPHEP7PlNS/haj+xD8YoXkXTLAz438f4o/WQFxObBh1yO+Kt/D2e9B+VHpQn7ZRMtkudDNBqcbTCgpXMjI/FcQYH3uUUUYR45EdqM9d62wdV7oB93ASr2NAUouVusGHp+zxTCIyIiIgqUgIw8AMC5Z5+BJYsvgULRFI+Iooja2jqUlVegrLwCtXUmSeCgVqlw7VVLcMas6YHqBvViUeECpg6UY3eMtOZDdKkCCXkKvFlUBKenYTqPXBuOgfc9CUWktPBazZZ1KP/qg06f23r8MOp2/iztz9xLoU5IQdlhuyTfwSMAFeOlIwM3xsdD1krAEqdSYfypBOpGx9LSJM/HOo6gJlm6wlJhej1cdk5dIiIior4lYMEDTgUQjzx0L+aeexbiYmNa3UcQBCQmxGPBhefj0b/cj9kzp7W6H4WmeSPlyNEpUKGWfvRG71Kj0OHA5xUV3jZldBwG3PckZGppsFG++l3UbP3R73OKooiSD/8laZOH6xC7+HoAQMk+6ZSlkgQPnM1SM2LlKlwQ1XZCf8upS5/HJMEtawqiFXCj2HoEQrO37LKJKNwtPS8RERFRbxeQaUvNRUdHYfGihVi8aCFsNjtqampQb2u4SdJqtTBGRkKtVgX6tNRHzBulwFNrHMiI0eDCwqZf94ftU2HzJRa8U1KCS6KjESZvWJVJO2g4Um5/GHkvPgqITb/UF73zApQxcQhPG9fhOet2/oz6rCOStphLr4MiQg+0EjwUj5ROYbopMQ7KdqZJnRcZiZcKC73Py+UKVKeMQkzeAW+bKn834saOQen+pmPnbbVg4Bn+V2QnIiIiCraAjjy0pNGokZAQj8GDBmLwoIFIiI9j4NDPjYiTYUCUgD3RajSfyKNyCBi+T40qlwsflklXJ9JNmomE6/8oaRNdTuS/9CjsJQVoj8fhQOmqFZI2VXwyouZdCgBw1ntQkSkNFgqHNCX6y51yXBrT+ihao2S1GiNb1CnJHyWt9zDJsgey0dIRlLzt9fC4pPk/RERERL1Zp0Yeqqqr/dir66KMxm49PgWfIAiYN1KBFVUiMiOVGF3TlMA8Ol2NwzPseK+0FEtiY2Fslj8TfcFlcJQWoWrdF942t9mEvBf+isGPvQKFzjeZGQCq1n0BZ0WJpC3+qt9BpmhY/qj8sB2eZouCeWQiigc29WmsIxoaWccx9vlGI47W13ufr0kZjEnNtsd4qrBVVgQlmvIjHCYPSvbbkDSZBRKJiIiob+hU8PDo8me7rSOCIODVfz7Tbcen3mPeKAVWbHNid4xGEjwk5CkQXSxHZaIb/y0pwb0pKZLXJVx3K5zlJTD9ut3b5igtRP5Lj2Hgg89BppKOarnqalD+tTS5OixtHHRT53ift1yitSzFDeepAQKPQ4YlsdJlV9tybmQkXi9qKmR3RBeJuog46M1Noyh1J3YjbcQ8VBxrWmkqd4uVwQMRERH1Gd06bakzWi7fSqFr1mA5wlXAMYMSdUppLsGo9IZM5U/Ly1HskNZZEGRyJN/2F2gGDpO0W48dRNE7z/t8hso+fw+eeumqSQnX3ipZ5rVlvkPhkKZgxpJlwOwB/k2zG6zRYIim2bQkQUDB8LGSfVJKMhA3XZrjkLfVCtHDzz4RERH1DZ0aeRg2ZDDQ+eX1iSRUCgHnjFDgu4MuZERrcG5J03SfkXtU2L7ACodSxL+Li/HYwIGS18o1Wgy470lk/+1OuKrKve2123+CKj4ZcUtuBADYC3NR/dO3ktcazpgL7ZCmZVRdNt/6Do35Dh6XgNiqKBjD/P/AnxcZieySpilSO4YMw+hfN3qfj3Ycxck4aUBkrXSj/KgdcS3yIYiIiIh6o04FD3+68w/d1xPqVy4YdSp4iFFLggeNVYYhh1Q4PtGBbysrsSwuDkNaJCMrjTEYeN9TyHnibnhsTa8t/3IlVHFJiDzzApR8/G/A07Q6k6BUIX7pbyXHKTvSSr7DoIaRB2u2AWcndi65//zISLzTLHjYljgAy2RKKD0Nx5TDg9ys/UgeMAq1eU0jHLlbrQweiIiIqE/oNdOWqH85L00OQQCqNHKc0Elj2NG7GqYueQC80SyPoDnNgCFIufMRoEUyc9GKf6Ls8//BvHenpD16wRVQRsdJ2lpOWSpPbsh3ED2A5VgkJg+Qd+o9DddqkaJuKhDhUKpQkCItGKc8vgsDz5AGQ7lbrJy2R0RERH0CgwcKipgIGaakNnz8WlacTs1SQlfVsO2n2locsFhaPYZu/HQk3nCnpE10u1D+xfuSNoXBiJiLr/Z5fVv5DvW5eritSkztZPAgCALOb1Ewbv9wafAwpm4PhNFqSZup0IWak04QERER9XYMHiho5o1qGHE4ZFTBKpfmFoxOb7rBfrWwsM1f5qPOvwTRC5e2e57YJTdCrpUmKrvsrec7iCJgOmpEuApIi+/816NltenNA4ZK++upQWbJSYTHSgOT3C3SxG4iIiKi3ojBAwVNY/DgkgnYGy39NX7UbjWEU1XkMsxmbDeZ2jxO/FW/lyy/2pw6ZRCMZ8/3aS8/Yoen2Y/9HkFE0WAnbAURcJtUmJQqh1zW+dUBRoeFIV6p9D4vi4xBhT5esk/1r7swYI40mGHwQERERH0BgwcKmpHxMqRENtyg746RBg8RtTIMONZ0E/5aYSE8bYw+CDIZUm59SLKSUqOEa2+FIPOdftRWvoP5SEOhws7mOzSSCQLObTH6cGTISMnz2KIMJM2SBg9VJxwwFXHqEhEREfVuDB4oaARB8I4+lIQpkB8mvWFvTJwGgMz6eqxvp8K5TK3BgHufhDIu0dtmmHUeIsZNbXX/or2++Q624jA4axryLzqb79Bcy7yHHYOldSnS7MeQJ7NCbZB+/XK3cvSBiIiIejcGDxRUjcEDAOyOlSZODz6iRJipaerQG8XFcLazKpHCYMTQJ99CwvW3Ien3DyD51gdb3c/l8KCsRb5D0RAXzEeN3ueTUrv+1ZgQEYEoRdP7OpoyBA5507KvcniQtX03Bszm1CUiIiLqWxg8UFDNGixH2Kn76v1RKjiafSJlHgEjdzeNPhTY7fiqoqLd48m1YYi+8HIYz7qw1elKAFB22A60yHfI1cvhKG9YQnVwtICYiK5/NeQtpi45FUocTxku3SkzHQPPkAYPZYftsFa5QERERNRbMXigoNIoBZw9vOFXertchgNGae7DxN0aoNlgw7+Li1Hvdp/WOXfsrJE8r0hyoyLHiMby6VNOY8pSo5arLu0eKg0ehlfvgWKoEsrmFaxFIG9bPYiIiIh6KwYPFHTzRjZN8UlvkTgdVi5DUk7T9kqXCx+Vl3f5XKIo4uRe6fSgwlQP7MXh3ueBCB6m6HTQy5uOs2+QNGk60lOHjPRMpExvUTBuc+s1LYiIiIh6AwYPFHRzRzbdZOdFKFCmkd68n/1rhOT5/0pLUevq2vSeHZV10OVIP/aZCPOOOiBAwYNSEHCWweB9XmGIQnGkdMnWioxdGDgnXNJWvNcGu/n0RlaIiIiIuguDBwq6WJ2sKUFZEHyWbY35VQZVfdPNvdntxrslJV061+c7y6FwNR1LFEQcszcFJ1olMCohMF+Llqsu7R0yQvLcmJeOpKkayJtWpIXoBgp2cOoSERER9U4MHqhXaD516ddoNdzNUwEcwOJM6Y34qvJylDocnTrHAYsFpoPS11jiZbA1m140MUUOhbzzxeFaM0OvR5is6Su2b7B06tIQWxaOF9UgaUqLqUtcdYmIiIh6KQYP1Cs0X7LVopThcKRKsn3oTiWaTyayiyLeLi7u1Dn+W1KC5GylpK3MIB3lCMSUpUZqmQxnNpu6dCxpMGyKpvclg4ijv+zCwBbVpgvS6+GyeQLWDyIiIqJAYfBAvcKYRBmSDE2/+LecumQ64cIVlmhJ29eVlThpkxZ7a0tWfT22VNQiIVchad8tSIOJKQMC+5VovuqSS6HAoQHSVZdch9OROisMQrPTuu0iCjM4dYmIiIh6HwYP1CsIgoC5zaYuZemVsGqlH8+pu7VQC00BhhvAG0VFfh3/f6WliM9XSPIdIABHNdJgIpAjDwBwhl4v6fP+wWmS7QMr98CtFhE/XlogL3czpy4RERFR78PggXqNC5pNXRIFATta1Hwo/rke1xpiJW0/1tTgkKX95U0L7XasrapCUrY0UECCAjZF01dgQJSAWF1gvxJauRyz9Xrv8/2DpMGD3mNGxpbDPgXj8nfUw+Nqu5o2ERERUTAweKBeY/ZQOTTNZhHtjlY3X0EVDouIc45J6ycAwOsdjD68V1oKN+Cb7xAtzauYkhrYUYdGzacuVeqNyI9OkGwv3rUTA1oEDw6zB8X7/JuSRURERNRTGDxQr6FVCjh7WNPoQI1ajpok6Q1+3jorboyX1kvYaTJhZ11dq8escDrxdWUlZC4g8aR05GGfqnunLDU602CAovnUpRajD7qTuxERp0BMWov3ylWXiIiIqJdh8EC9ytxR0hv4jRHSG+rS/XYscBgRq5SOIrxaVARR9J3m82FZGRyi2Gq+ww6P9FzdFTzoFArM0Om8z1su2Tqw/gTy8ip8Vl3K3WaF6OHUJSIiIuo9GDxQr9I8aRoAfg1XQR4h/ZjmrrXglsRESdsRqxU/1tRI2upcLnxWXg4ASG6R76BMUqK+Wb6DRgGMTuy+r0PzqUvHkwahXinN5zj0006fatP1lW6UH7V3W5+IiIiIOovBA/UqCXoZxic3fSzdMgFVI6QrEZ1YZ8bFhigMVEtvwN8oKoKr2ejDJ+XlsHga6iUkn5COVNQmSJ+PS5ZDpQhMcbjWnB0Z6a1T4ZbLcXCgdMlW28F0GFKViBwo7RdXXSIiIqLehMED9TrNV10CgHVa6dSl+moPinfV449JSZL2XLsdX1dWNuzj8eCjU6MOMhd86jscDZPepE8d2L1fBaNCgcntTF1KKvsVLqfLJ3E6d6u11elYRERERMHA4IF6HZ+pS3Y59COkAcSx782YGxmJUWHSm+1/FxfD5vHgy4oK1LhcAIC4AgWUTumowi926Ue/u/Idmms+dall0nSEx4L92w9h4JnS92MqcqE6x9ntfSMiIiLyB4MH6nXGJ8uQoJfe7FeOlN5UF6bXw1rhxp0tRh/KnU58UFqK90tLvW3JJ6TBSNgAJco8PR88nBsZ6V15tibCgNxYad5G4Y6diB6mQkS8tC+5XHWJiIiIegkGD9TrCIKA81uMPqyXK6AMawooRA9wfK0ZM/R6TG82HQgA/lVcjFJn06/1Les72JKloxjJkQIS9N3/VYhVKjE+vCkpet8g6dQlzYl0CIKAAWdIE6ez1ppYMI6IiIh6BQYP1Ctd0CJ42F4oIvlM6U318TVmiB4Rd7QYfWh+my1zAckt8h1O6qTBRE+MOjSSTl1qkfdgzUFVUTkGnyMdZTGXupHzc/tVtImIiIh6AoMH6pXmDJND0+ye3+0BKtK0kn3MJS4U/2rDmPBwnN/spry5uAIF5A7pFKitPVTfoTXNg4espAGwqKUrSR34aSdiR6kRO0q6ktT+j2tZ84GIiIiCjsED9UphKgFzhklv6n8yCzAOlo4aHFtjBgDclpSE1kKACXnSgEM/SIkD0nIQPRo8JKnV3iRvj0yOgwNHSLab9++CIAgYf41B0l5z0on8HfU91k8iIiKi1jB4oF5rXoslWzcec2Po/AhJW+4WC2y1bgzSaLAoOtrnGGPzpcEDBkrzHVRyYGxSz34Nmo8+tMx7iC/5FR6nE6kztT41H/Z/VMtlW4mIiCioGDxQr9VyydZaG1AzQgt5s3tqjxM48WNDPsDvExOhlTV9pIcpNXBnuiXHKDS2LA4ng7obi8O1pvkUqwMtlmzVeuqRtfsgBJmAcVdLRx/Kj9hRss/WY/0kIiIiaonBA/VaSQaZz6jAT/keDJwjTZw+9r0JoigiXqXCK0OHYrpOh3MNBjzsToXLJv2lPkMmDUh6cspSo4EaDYZqGnIdasN1yIlLlmzP3bYDADDk3HCfZVsPfFzbgz0lIiIikmLwQL3avBajD+uOuDF8oXTqUs1JJyqOOgAAk3U6/Gv4cLwwdCjEw9JRh8iBSuwskwYTwQge0HLVpRbVppXHdwMAZAoBY6+Ujj4U7rah4ri9h3pJREREJMXggXq1C1rkPZwo96A+WQVdorT92Pcmn9eW7JdO8dGOUKO2xayfYAUP57eT9xBryYXlVJG74fMjoImUfk0PfMTRByIiIgoOhR/79DnFJaXYsSsDR44eQ01tLex2B3QR4UhMTMDkieMwfepkyOXdd9NYW2fCU3//JyzWhsrA11+zFLNmTO2284Wy8ckyxOkElJmaRgw2ZLoxc0EE9vynadmk7J8tmH5bFJTahhttj0tE6UHpL/SVcSqguul5gl5AkqFn8x0aDdNqkapWI99ux4mEVJg1YYiwNVWSPvzzTky7ahEUahlGX66XvNeTm62oLXDCkKJs4+hERERE3SPkRh5+WLsBzzz/MjZs3ITComJYLFa4XC5U19Ti8JFMrPzoMzz7j1dRVl7RbX34aNVqb+BAp0cmEzA3TRrjbjjqwrALIiA0+/S66kVJIbWKY3affIcDSt/6DoIQnOBBEATv1CVRJsOBFku21u7d5X08cpFOUl0bInBgFUcfiIiIqOeFVPCwZv1GfPvDerjdbmg0alw471zcddvv8ed778Rvf3MtRqYNBwAUFhXjtTdXwGQyB7wPO3Zl4MChIwE/bn82d5T0pn9HjhvuCDlSpkuXYT32Q9P1LNkvHXWIHKjErhbxYrCmLDWSTF1qkfcQVbQXHmdDHoc6Qo6Rl+gk20+sN8NS7uryuT2iiO8rK/F/J0/iM2s93FwCloiIiPwQMsFDaWk5vvthPQAgPDwMf773Tiy6aD7SRgzDwAEpmDJpAu784+9w3tlzAACVlVX48psfAtqHmppafPbFNwCASIM+oMfuz84apoC62eCDywP8fMyF4QukN9Tlh+2oPtlww91ySdPosWocLfVI2qYMCO7Hf3RYGBJUDXUnDgwcAQ+aRhfUHhuK9x1o2neJXrpErQs4tLquS+c9abPhD8eP45HcXGyoqcG7lnr8o7DwdN4KERER9RMhEzysWb8RHk/DzeFliy5CfFxsq/stXrQQsTENxcR27d6DisqqgPXhg1WrUV9fD61Wi/POOTNgx+3vwtUCZg+RjhKsO+JC6gwttFHS9uM/mE/lO0iDB0uSCs1/XFfKgXHJwR15aD51yRQWgZyEFMn27C07vY/DohQYPl8aLGV+a4KtVrqiVHucHg/eLi7G1UeOYI9ZOur2aUUFfqnlVCgiIiJqX0gEDy6XC/sPHgIAaLVaTJ0ysc195XI5Zs+cBgDweDzY2+zX3dOxbccuHD6SCQBYdNGFCAsLC8hxqUHLVZc2ZrogyoBhF0iXbc1ab0bZYTtc9dJpOJla6evHJMqgVQYn36G59qpNC5m7JM/HXqmX5nnYRBz5yneVqdYcsFhw3dGjeLO4GM42pigtz81FpdPZuTdARERE/UpIBA/ZObmw2RrmuA8dPBBKRfuLSI0YPsz7+NCpG/7TUV1dg9VffgsASBsxDGeeMfO0j0lS57eo91BtBXbnuTF8vjR4sNd5kP6WdDTJMECJjBYDTMHOd2g0Pjwc0ac+r/sHS6tNG80FsJcVeZ/rEpUYfI60QN6RL+rgrJdOx2rO4nbjufx83JSZiRO29qtTV7tceDw3FyLzH4iIiKgNIRE8FBWXeB+npCR1uH9KcqJ3lZ2iopIO9+/Iyo8/g81mh0atxnVXXxG0FXxCWapRhtEJ0o/rhiNuGFKUSJigkbRXZDokzxMmqJGR1zLfoXcED3JBwDmnRh9y4lNQp5UGB1mbpaMP466WFo2zmzw49l3row+/1NRg6eHDWFVejpbhgAzA9XFxOFMvzc3ZWleHTysCtxKZ6PHAWVUO0dN2gENERER9R0gED6Vl5d7HUcbIdvcFAIVCAZ2u4Rdrs8UCs8XS4WvasnnrDhzNPA4AuHzxRYiOMnb5WNS+uaNaVptuWG1oRIuK0y3JBqtRbZXePk/tJcEDmq26JAoy7B8kHX2ozNgpeR41RIXUmdJVpg5+Vge3s+n9VTideDA7G/dkZ6O0lWlIaVot3hs5EvekpOCRAQNglEmD3ZcKCpBdX3/a78tVW43sx27HsbuvwfH7boBp3y4/XkVERES9WUgUiTObm27+IyLav5FspIuIQF2dyfv6iPDwDl/TUmVlFb74+jsAwKiRI3DGrBmdPkZbPEH4pbbxnME4tz/mpsnwyk9Nz4+VeZBT4ULqbA2U4QKcltan25zUyQE0JRbHRghIMoi95n1OCg+HQS5HrduN/YPSMOfIHu82feE+uGw2yE6tygQAY6/SI39H0829tcKNrPUmDLswHF9VVeGVoiKY3L6J1GpBwB8SE3FNbCwUggCPxwODTIY/6cLxWG1TArVdFPGXnBy8O2IEVLKu/b4getzIf+Mp2E42BNbOihLkvfAXGM6aj/hr/gB5WOe/b3T6evt3nAKP17x/4fXuf4JxzUMieLA7mqapdJTv0EjRbD+73dHuvq0RRRErP/4MdrsDWo0G1129pNPHaE9pYV5Aj9cZ5cUFQTt3exIFwKg1orq+6Yb2ix0VuGaCDYkzgLyNvq8JTwS2FFoANE1tGhtrR1lR9xUJ7IppSjk2uN04OHAEPIIA2am8A6XHgZxfNiBi1NimnSMBYxpQ3SxdZ/cHlXgm+SQOuFuv/TBRqcDtunAkOm2oLMqXbJuiUmGRVo2v65tqYxy32fCP48fw24iuJf7X//Qt6g/v9Wmv/WUNTPt2IXzJjVAOG92lY9Pp663fceo+vOb9C693/9OT1zwkggdns6kZii4ED05X51eY2bR5G44dPwEAWHLZJTBGdjxdqjPikwcE9Hj+8Hg8KC8uQGxiCmRd/MW5u80bZccne5pukHeW6PCnhXFQLnUgb6Nv/kry5AgcrtQCaIrIZ40IR3xy75pedlFtLTbk5MCsDUdWwgCMKM71bqs5mImhcxdK9p+8rB4/Ptw0Xc9RKsD6qwCMlx7XIJfjT8nJuMhobDUXp/Ga3z90OA5lZUmSqj+vt+G8pGTM0Ol8Xtce67GDqPrx6za3e2qrYPrPPxF57sWIv/r3kGm0be5LgdUXvuMUWLzm/Quvd//T1jU3ZWV12zlDInhQKpuqZzld/lXddTXbT9Xs9f4or6jEV982FJgbO2YUZs2Y2qnX+yOYX3qZTNZr/+jMG6WQBA/bczywOATEDNcgeoQKlceko0jRYzU4slE6lDd1oKLXvb+ZBgPCZTJYPB7sHzxSEjxof12Dul9nI3LKLG9b6owwaAcrUJ/T9G8x5SctToxzorHW3HyjEfelpCDKj8+3VqHAU4MH44ajR+FottrS43l5+HjUKET6GZS7zHUoevMZoPnwqSCDTK2GxybNo6j56VtYDuxG8i33I3xU28srU+D15u84dQ9e8/6F17v/6clrHhKfLHWz+eBOP9epb76fWq32+1wejwfvf/gpHA4nwsK0uPbKyzvZWzod54xQQNks19npBjYdP5U4vcA336UsWglPs1QIuQyYkNJ7kqUbqWQyzDE0rKS0I20C3M0KOggQceLVZ1Ce3TCVzeJ244WCAnw5q0ZyjLhCBVKPK5CoUuGVoUPx1ODBfgUOjYZrtbgzOVnSVu504um8PL+WbxVFEUXv/APOynJJe+zlN2DoM+8gfPQkn9c4K0pw8un7Ufzeaz7BBREREfU+IRE8NK6cBAAmk7ndfRvV1tV5H+t1/iVZA8DPv2zFiewcAMDVV1wGg0Hf4WsocCLUAma1qDa9/tSqS0POjUBYdNO2pCka7KuTvn50ogxhqt65lG7jqktlkTH4ZM4CyTaN24p9Tz+KTzILsfTwYXxcXo6s8Q7UREsToxduNeCTUaNwhkG6pKu/ro6NxcwW05R+rKnB15WVHb62asNXMGVslbSFj5qI2EXXQBUTj4EPPovE39wJQaXxfe36L3Hi4VthyQxM0UYiIiLqHiERPCTEx3kfV1VVd7i/3e6AxWIFABgMemi1/s25rqquxtffrQUAJCclQpAJ2LN3f6v/5eU3Ja7k5Rd424tLSrvwDqm5C1oUjPsx0w23R4QqQoZ5T8dj2IURGHWpDnMeiEFGbov6Dqm9b9Sh0Wy9HupTeQk/TDkL29OkU3kS7QWwffQcyhwNic2iDNhzjrTwm/KICMsx/6butUYmCPjboEEwyKX/Ts8XFCC/nSJz9SePo/TDtyRtcp0ByX98CIKs4ViCTIaouZdi2DP/RljaeJ9jOEoLcfKpe1Hy4ZvwOOw+24mIiCj4QiLnISW5qTBcXkFhh/vn5jWtNpOa3HFRuUYVFVXe6U6FRcVY8e4Hfr3uly3b8cuW7QCAhRfOxUUL5vl9TvI1b5QCD3/TdHNZaRHxa74HUwfKETVUhTMfiAFOTaPJyJfe8E4Z2HuDB61cjjMMBmysqQEEASvmXYGksnIMrG76TE85cQiLdm7EVzPnAgBypjqAH8OBZjOY9n9Ug/OXx3e5H7FKJR4ZOBD3Z2d72+o9Hvz15EmsSEuDskXitbveioLXn4TYYuGB5D88CKUxxuf4qrgkDPrLC6ha/xVKP3kHYvNAQRRR+cNnMO3dieRb/oywYaO6/D6IiIgo8EJi5GHQwFRERDSsG5+dkwubvf1fLQ8faVrjcvw4LhfZ1wyIkiEtXvrRbSwY11xelYgKc+8tDtea85qt2uVQqvDyZctg1kiXS71s+3pMzD6MCHMY3kkbialXSleOyttWj+qTnV9+uLlzIyNxWXS0pO2Q1Yp3iot99i3+3ytwlEiD9uiFS6GbML3N4wsyGaIvvAxDn3wL2uFjfLY7ivORs/xulK56Gx7H6b0XIiIiCpyQGHmQyWSYPHE8ftmyHQ6HAzt2ZeCcM2e3uq/NZseOXRkAAJVKhQnjxra6X2tGDB+K11961q99t+/cjZUffQoAuP6apd2yIlN/Nm+kApmlTTeVG4668Jf50sT33XnSfICocAEDo3pnvkOjMw0GKAUBzlMJyhWGKLy+8Do88MU73toPMoj4w7ercHv0FNy2x4O3rwiH6qNaOExNU7QOfFyLsx6KPa2+3JeSgj1mM3KbBeP/KSnBTL0ek04VY6zZsg61WzdIXqcdMhJxS3/r1znUiSkY/PA/UfnDapSt/i/E5gseiB5UfLsKpl93IPmWP0M7JK29QxEREVEPCImRBwC4cN553iVbv/luDQqLfH8h9Xg8+OiTz2EyNyRVn3fOHO+IRXO3/+lB73+VlVU90HvqrHmjpCMIR0o8yK+W5jfsaRE8TB0ga7XWQW8SIZdjeouE5UMDh+PjM6V1HsLd9Xi86u/ILTLjkv/UI+JM6ec4e6MF5tKu5z7g1DSqJwcNQvN/aQ+AR0+ehMnthr04H8XvviJ5jUwbhpTb/wKZwv9VngSZHDEXXYmhT7zZaoBgL8xF9uN3ovSz/8LThZosREREFDghEzxEGvS4csmlwKnRhX+8/Aa++nYNjh0/gdy8fOzavQf/fPlf2L2noert4IEDcOHc84Lca+qqKQPkMIZJA4ENR6U3yy1HHib38ilLjeYafQvY/TrjfNinnilpG+gqxIPVL6PG4sEDxQqIyqZ/D9EDHPyk9rT7Mjo8HLcmSfOCihwOvJCdjYLXnoTHLs0pSbr5Xqji/M8jak6dPBCDH30FcUt/C0HeYlDU40HFVx8g+9HbUZ/bfYVviIiIqH0hEzwAwOyZ03DVFYuhVCphtzuwbsNPePn1f+O5f76G/61chZzchnXyR6UNx62/vxEqVeeKw1HvIZcJOD9NGgw0z3uwOkQcLm5RHK6PBA8LjEaMDWvIcxBOLZ/66ZgxmHjrg9AMHCrZ9wzbLlxn+hQmuQzbjNJpW8d+MKO+WhpAdcVv4uMxOUK6nLHx6/dhyzshbTv3IhhmnHNa5xLkcsQuuhZDnngDmkHDfbbb87OR/djtKPtyJUQ/C0ISERFR4IRU8AAAZ82Zhb8+eA/mnX8OkpMSERamhVKpQHSUEZMmjMMtv70Bd/zxd61OV6K+5YJR0l+nt51ww2JvyAvYX+iGq1nsIBOAib2wOFxrlDIZ/pOWhv+OGIF148bhgdRUhMvlkKk1SL37ccgjpLVFbjR9jJn16dgSr4G72WCM2yHi8Bd1vifoJLkgYPnAgYg4tXzrlKyDmLd3m2QfdfIgJFz3x9M+VyNN6hAMeexVxF7+G6DFsrFwu1G++l1kL78LtvycgJ2TiIiIOiZkZmZ2XDqWetyIESN6/JwejwelhXmITx7QJ8ra19lEjFlulgQJK67XYOFYJd7Y5MATPzQl+o5JlGHD3aERMJoP7UHusw81zE06xSKE4fbY5zCjwIAplU3vWxUuYOmHqVCFt349O3PN11RV4Z/7f8WTK19CuL2pGrSgUmPI469DkzIoIO+vpfrcLBS+9Rzs+dk+2wSFErGX34CYhVdCaBlkkI++9h2n08dr3r/wevc/bV3zY8eOdds5+cmiPkuv8a02veFowzSdvprv4I+IMZMRf/XvJW3hohWPVz2D9HgRzSdrOSwiMr81BeS8F+r1+Mv6TySBAwCcWHR9twUOAKAdOAxDlr+OmEuvA1r8n6HocqLskxXIWX437IW53dYHIiIiasDggfq0uS2qTW846oLHIyLDZ6Wl0AkeACB6wRUwzJIm/A90FeJ39a/icKT032THB7Ww13twusq+eA+xLfIcdoyYgCdSRuCwxXLax2+PTKFE/BU3Ychjr0CdPNBne332UWQ/fidseb6jE0RERBQ4DB6oT2uZ91BuFvHdQRfKTNLZeKE08gAAgiAg6eZ7fRKoZ9vSYTR+L2lTWD346+PVqLZ2fYai+WAGKr75SNJWaojCf+deDrcg4K8nT6LeffrJ2R3RDhmJIcv/hZiLrwIE6Z8vT70Vhf9+rk8mUledcGDDI6X44neFOPzl6eepEBERdRcGD9SnDYqWYVis9GP83HppReJILTA0pnfXd+iKthKoL7N9AmvkAUlb4n4LLnrVjMzSzt/gu2qrUfjm3wGxKfjwyOV4Y+F1qFdrAQB5djv+UVDQ5ffSGTKVCvFX/R6DH3kJqoQUyTZbbhYqvv+kR/oRCC6bB7vfrsLXfyxC/vZ61Jx0YudrVTi+zhzsrhEREbWKwQP1eRe0KBiXVS6dojN5gLzXF4frKlVsAlLueNjnV/gzdf+GRt5UKDHK4YE+y46LXrdizSH/C62JHg8K3vo7XLXVkvb4K3+HsBYF3b6orMRPNTVdfi+dFTZ8NIY++SbUydJ8i/Iv34e9KK/H+tFVhbvr8cXvinBgVV3z3HcAwPaXK1F90tHWS4mIiIKGwQP1eS3zHlqaEmJTllqKGDMZ8dfcImmTu+oxIv4NyAWrt+2sknpY7CJuet+Gf/5oh8fT8TSmiu8/geVAhvR8E6Yjdv4SPDVoELQtEpifyM1FuaPnbnplag2Sfn+/JHgSnU4UrfgHRM/p53l0B1uNG7/8vRzrHiqFuaT1KVZuu4iflpfDGYBcFSIiokBi8EB93rSBckRq294e6sEDAETPXwLD7PMlbRqxGEMiVwCn1l9KrHcjrbZh1OH59Q7c8qHNWxejNdbjh1H26X8kbQpjNJJv+TMEmQypGg0eSJFOG6p1u/FYbi48Ys+tAB02dCSi5y+RtFmPHULVhq96rA/+EEURx9eZ8flNhTixoeME89o8J7a/XAmxB/8tiYiIOsLggfo8hVzAuWmtjz4IAjA5NfSDB0EQkPTbe3wSqI2afUiO+Mb7/OySpmVWvzvowqVv1aOwzvfPgNtiQsEbTwHNf70XZEj54/9BoY/0Ni2Kjsb5kZGS1+40mfBxeXmg3ppf4pb8Bqq4JElb2Scr4Cgv6dF+tKW2wIm1fy7FlucqYDf5jibEj1Vj0b8SETVMJWk/scGC42uY/0BERL0HgwcKCS1XXWqUFieDThOa+Q4ttZVAnaz7BpHqXwEAg8wuDDI15TwcKRFxxYeRWPY/G1ZsdSCnwgNRFFG04p9wVpRKjhO7+DqEj5ooaRMEAX8ZMACxSqWk/ZXCQhy3WtFTZGoNkn53r6TNY7eh6D8vBvWXe7dTxL4Pa/DV7wtR/KvNZ7sqXMDse6Kx4J8JiB6uxrmPxkIZJv287ni1ClXZzH8gIqLegcEDhYRzhisgb+XTHGpLtHakIYH6EZ9iakMjV3gTqM8vkxZ5s7sFbMx04+Fv7Jj9ggV/+b/PUJe+WbJPWNp4xF56favnjFQosHygtPaCUxTx15MnYevBvIPwURNhPO9iSZvlYAZqNq/tsT40V3bYhq//WIQ9/6mBu5Uc9UFnh+Gy/yQj7SIdBFlDwKBPUmLO/TGS/dwOET8tL4PTyvwHIiIKPgYPFBIiwwTMGOQbKIRacTh/RIyZhPirWyRQy2wYHvUa5IIVQ6udmKlp/UZ0sPMkriyU5jlYFTpsmno/TlQJbf6KP12vx/VxcZK2EzYbXi0sPO330xnxV/8eiqhYSVvJB2/CWVPZY31wmD3Y/kolvru7BDUnfaOG8Fg55j4Zh3MfiUNYtO+I2aCzwjFqsU7SVlfgwrYXmf9ARETBx+CBQsa8VlZdmjygf37EW0ug1ipKvQnUt8vsuHKyArJmM2Q0HhsernoBKkhveJ/S34n/+1mHM/9hwYznLHjoSxvWHXb5JFvfnpSEEVpp5vrH5eXYVlvbHW+xVXJtOJJuulvS5rGaUfzuKz1y45271YIvbi7E0a9NQIvTCTJgzBI9LvtPMlJnhrV7nGm3RCEmTZr/kP2TBZnfMf+BiIiCq3/eWVFIunC09GY4QS9geGz//Ig3JVAPk7Q3JlAXbLHiiTMU2P/XMDxzgQlLJytwv+UdDHRJRwpWh1+Cndpp3uf51SL+t8OJ37xXj9HLzbjyHSve/MWBzFI3lIKApwYNgrpFTY2/5eai2ul/bYn2iKIIp8eDercbJpcLVU4nyhwOVDid3uBAN3GmT+BkytiKul2/BKQPrbFUuPDj38qw8bFyWCt9C/FFDVXh4lcTMf2PUVBqO/5MylUCznkkFqoI6b67Xq9E5XF7QPtORETUGe0vkE/UhwyOkeHBC1T4xwYHtErg6UvVkMn6R7J0a2RqDVL/9DiyH70NblPTr//Jum9gcQ7AgU8iMOvuKFw43IFLVVtQVPej5PXHlEPxjmFZm8d3uIHNWW5sznLj8e+BJEPDqlfzhibiW3eRd79Klwu3Z2VhkEYDlyj6/Of057HHA5coor362EkqFS6KisJF0dFIvP42mA9kwG1qKlpX/N6rCB89EQqdocv/pi153CIyvzUhY0U1nFbfkQ25WsCkGyIxZokeMkXnPou6BCXmPBCDjY+VedvcTuCnJ8qx6I0kn8CCiIioJwiZmZmcRNsLjRgxosfP6fF4UFqYh/jkAZDJ+u6NicUuQi4DNMr+Gzg0Zzm8Fyef/bNk2VW3R4MjtX/FRf+dgpqCX2F640l4bE2J1DJNGOIefgPb6+KxMdONn465UFLn758KEdFnFkGd2HOrLbU0MTwcV+cdQ9J7L0vaDWfMRcqtDwXkHFXZDmx7sRLlR1ofCUieqsGsu6OhS1S2ur2RWxRxwGLBtyU1KKx34rKkSJwfFQn5qRGcXW9W4dBndZLXDDorDOc8Etvpyumh8h0n//Ga9y+83v1PW9f82LFj3XZOjjxQyAlXM2hoLnz0RMRffQtKP3zT2yaX2TBU9xoOf/QE9IVvSQIHAEj67Z9gGJiCiwFcPE4JURRxpMSDjZkubMx0Iz3XDVebi/8IqN4Vj9gL8yDXtDdW0H32WizYG5WEe4aOwaQTh7zttVs3wDDzXOgmzujysV12D/Z9UIsDq2ohtvL2NJEyTP9jFIacF97mzb3d40G6yYSfamqwsboWdZ6mStO7cquRVKTG75MSsMBoxNTfGVF2yC4JUk7+YsWRr0wYvVjf6vGJiIi6C4MHon4gev4S2E4eR+22pqlJWkUpnDvvhVsmTcKNPGs+DLPOk7QJgoDRiXKMTvz/9u46PKozffj494zPxN2DE6C4t2hpqVF3d/fd/VVWut1u3663u9Wtbt29lNIWaSlQKAUKLRYIFiBCXMZnznn/CEwyTGQCITb357q4mJx5js2dc3LueUzP7TOhzqWxtMDH4q1+vsn3UVQTXCuhug1Ur0ojcWoRSld9+aUovDzrbAbv3U6Uu3GOhT3/+zd5f38JvTWq3ZssWuvk+8crqNvna/b9QSdHM/7GBCxxoaN81fn9LK+p4Zvqar6vrcXRyjC2RV43D+3ezbNFRVyRlsbs3yfx9S0lQRPM/fhsJalDzSTnmdt9HkIIIcThkmZL3ZQ0WxIdTXW7KPjjXXiLtrdYxpyZS/+HnkZnsbZY5lCaprF1v8rifD+L8338sMuP98A38sZEJ5YsO4qioWkKqAomncLMgQYm9zFg0uswKErQP+Mh/4fzeo/bzeeVlXxZWUmNP7g6YPqGH7l+wftBy34aOxXT5bdxUkIC8YaWv0PRNA2fS8NV5WfdG9UUfG1vtlxsloHjfpVExujgz63M42HJgYRhdX09vsMc8SneYODSfYnoHg1OWqLTDZz5bAbm6PCGJJZrPPJIzCOLxDvydEWzJUkeuilJHsTR4CkvJf//bkbnrwt5TzGa6P/QU1hy+h/RPuxujWXbG/pJLNziY19187eY4Zk6/n62pUMn8vOqKstqa/m8ooKlNTX4VTC54DefvcDQ4m1BZd/Nu51yUx79VQt9VTPxHgM+u4qnXsVz8P96Fa2VudkUPYy8OI6Rl8VhMDVcM7tcLr6prubb6mo2hDnLtsnrYeYPP5JRs59f8gaxdsAx0EyTpxlf2BjxrSVoWe5UG7MeDK//g1zjkUdiHlkk3pFHkgcRIMmDOFqKF/5IxSu/R1GCn4oL7Veg9TmJ5MFmkgabSM4zE5tpCMx+fDj8qsbrP3j561dual2h7ysKXDbByG9PNpMYFf5+VL9GXZGPql0eqnd5qSv24q5rfOj32lVc9So+hwYamPRljEh+EL3OE9iGy5fChrI/oXJ4zX5ShpmZ8qsk4voa2eRwBBKGXe7whlLVNPCUW4je7ub3Pz1Nf9euwHsFSbl8MPNkNuUOClpH54ezn4shc1dwJ+yJtyRwzHltjyIl13jkkZhHFol35JHkQQRI8iCOpu/veIW46jcCP1c6x1FQfTMQ/ABvilJIGmwm+UAykZxnJipV3+5RfsrqVB6e7+b9tc33FUiMUnjgVHPDxHVNkhVN1agr8VG100v17oZEoXq3h5pCL/52Th2RZltIn7h3gpYV15/MnroL2rUdo01hzHXx1M6Ab2trWFJTQ1mY81hofgV3qRXXvmhcRVGMcW7jz1X/wOyqbrb8+rQhfDRrNjvTcwLLoqoVLn48Dqu98RpV9DDnPxmkDG09EZJrPPJIzCOLxDvySPIgAiR5EEfT/s0uVt3/AYnmlTi8ueytOweN1ocUPcgSr2tMKAabSc4zYUsKb+yF73f4+O0nbrbuP6QtkKYR71GZGqNyUY6CqdLXkCgUevG7O+oWpTI06e/EmBr7fGiawqaK32H39mtzbZ0JLJOMbDzTwxJdLfX+8EaSUj06XMU2XPuicZdEofl0WAzwYNq3TFjzNPibT6ia+j5rLJ+cMIuSpFQAcvONnPlSTFAZT6LGpCeSGZ0e08JW5BqPRBLzyCLxjjySPIgASR7E0Vb0k5Mtn9ZSutmJq+LItmVL0pOcZyJpsJmUvIZmT82NOKRpGjWlPt75wsmS5S4S6/2kufykOn2YW+lb0BEUHURHl5JnexCd0vjAXmvM5L2ce3FZ9bitKm6rhtui4bFoDa+tDa89Fg0tzMvC79Q31C7si8JdZgO1oTbFqIfLx+m4tvpV3N98FLqiXg8tJCV+dCzrfxyfzZpBWUwck7+0Mn5xcAftnUM97L9D4dr0NCbExITUEMk1Hnkk5pFF4h15ZJ4HIUSnyRxjJX2UmdJ9hcTasqgs8FKx1UN5vpvyfDfOqvCf5h0Vfgq/d1L4feN8EdHpBpIHm0joZ8Je5qN6t5fqXR48dg0zcFIHnIM1QUd8XxPxuUYsCXpM0TrM0TqMUTpM0TpMTf43WhUUXV/KPruS/e//L7CNWG8RtxzzAwunnsrnFRWUhtkE6VBavZH6PdG49kXjrTQHNQHTKXDhWAO/OtaL9tbD1P+yOmT96JETyLr5fmpXL6Ps49fwVQVndHpUZuxYxrE7V7H7uBN4ZsaxZOwykLWjscao32YTRfMc3DKjgGNsNq5JT2dGXBy6djYzE0IIIVoiNQ/dlNQ8iM7QUsw1TcNR7qd8q5vy/IaEomKrJ2iegc5kiNaR1N9IQl8T8X0O/N/X2GztRls0n48df7oN1+7G5kuK3kD/h5/BlN2P1fX1fF5RwaLqalytzMUAkK5ZKdkWxf7tUfjqTCHvKwqcPdLAb040k+0rovDfD+Ap3hNSLunU80m7+AYUXcP5qB43lQs+Yf9n76A5QkfGAsAaxa4Jp7Jn3gzM9Y01EKpO46Ob6yjp21C70t9i4eq0NE5KTESvaXKNRxi5r0cWiXfkkWZLIkCSB9EZ2hNzTdOoL/ZRfrB2YquHim1uvI6Ou4W49AqlFj2l1oZ/+60GSq16PGaFW2eauWOmCZvpyL9Fd+7axo4Hb4MmyYG1fx79/vgEir7hAd7h97Ooupq5FRWsqW+YSE8PjI+JIb4uhm+WmdlV1HLl7SnDDNx7komh6Xrqf1nDnqceRnUET8inGIxkXHM3CdNPbnYbfns9Oz98h9qFH2HWPM2WwRbPruI5lDmmoR2oTK6L8/Pu3bW4ohpjk2EycUVqKpNcdnKz+8g1HiHkvh5ZJN6RR5IHESDJg+gMRxpzTdWo2dvQ3KnsQO1ERYGnzU7OBqsSVIOQ0MdEfD8jpZrC7+e6+XZr8+3+cxIUHjnTwuyhR97isvT9/1H+2VtBy9IuvpHkOReGlC3zeCj3eNmwQ89TC/2hHb6bOH6wnntPMjM6W4+maVR+/Qklb/03KFEB0MfGk3vXQ9gGH9Pmse7eVcanj73KjKoFGGj+s3H5UthXdzYVrgmAjt15HuZeUw+HhDVeUfhVTg6nJye3uV/R88l9PbJIvCOPJA8iQJIH0RmORsxVv0b1bu+BvhMe6oq9WBP1jU2O+pmIStG3OH+EpmnM2+Djj3PdFNc2f3s6eZiBh88wk5Nw+Mesejxsf+BmPEWFgWWK0cSAvzyPMTWLCrtGSW3Dv6IalTdWedlQ1HLScGw/PfedbGJS34bERvV5KX71Caq/nR9S1tJnADl3/xlTclrYx1tYqXLzk9s5dd9bzHIubbGc3ZvD3rpzqXEPZ8UpTtbMamaCDeDurCyuSAt//6Jnkvt6ZJF4Rx5JHkSAJA+iM3TnmNvdGo8tcvP8Mi++Zp7ZLUb49QkmbppqwmQIrymTpmnUOKG0TqW4RqN2y0b6v/9/KDTeBjfbjuHXiX/GG+bQSmNydNx/kplpAxvnv/DVVrPniYdw5P8SUj52wjSybrwXncXazNZat7tC5dznHdjKtnNN7ZtMcq9tsWytezB77eey7JZclmXWN1vmlowMrs/IaPdxiJ6jO1/jouNJvCOPJA8iQJIH0Rl6Qsy3lPi5/xM3P+xqvrnOwBQdfz3LzNhcfUNNQY1KSZ1Gaa1GSa1Kaa1Gca1G6YHXrkOmVbi1+kXOtc8LWvaf+Jv4POqUVo/rmAwd951k5sQhwZPmuQp3UPjvB/CWl4ask3LOlaScfTnKEXzWuypUzn3OQXGtxkj3Bq6veZ1h3pb/SNT6R6P/1VW8Gm9hZV1o5+tr09K4NTOz3RP/iZ6hJ1zjouNIvCOPJA8iQJIH0Rl6Ssw1TeODn3w8NM9Nhb1jb1kW1ckL++8mw78/sMyuWLk+9QnKDKH9Agam6Lh3tok5w4NnwwaoXb2cfc/+FdUd3FRIMZnJuuk+4iZO75Bj3lGuct7zDkpqNdA0jnOt4traN+nrCx3JCUBDIX7KiSydfhr/coUORXtpaiq/zsqSBKIX6inXuOgYEu/I0xXJg/xmCSG6PUVRuGCskWW/ieLqyUY68hnXpbPy7/hbgpZFaU7urv4vOjTSYxVGZes47RgDT11k4dtf2ThjpDEocdA0jbJP3mDP4w+GJA7GpBT6PfCfDkscAPon6/jgBhtpMQooCt9bJ3Fj6r/5e/wdVJlSQsoraNQsX8Cof97L35Z/wcCi3Rh9jUnEW/v389c9e1A1+S5JCCFE66TmoZuSmgfRGXpqzNft9XP/Jy7W7z38eScSoxQyYhXSYhXSY3TM3vA4OdsXBJXJuPE+EqfNbnU7qtvFvhcfpXblNyHvWQcOI/fuhzDEJRz2cbZm234/57/gZH9d423cqHm5U/cVs/e8i0Fpvq8DgE+nY09yBjvSc9mensOO9BzGDsjjj/36oZcaiF6jp17j4vBIvCOPNFsSAZI8iM7Qk2PuVzXeWOXlb1+5qW6c2JpYC6TF6kiPVUiLUUiP1TUkCLGNr1NjFMyHdLL22+spuP86fNWNMzvro2MY+Lf/tfjw760so/A/D+LaGXqTjp92MhnX3IXOGDp5XEfaut/P+c87KasPvpWfaa3nvHXvk277Cr3OHda2nCYz1Vn9GHbMaKIHDMU6IA9jggzp2pP15GtctJ/EO/J0RfJw5IOlCyFEF9DrFK6abOKyCUa2lamYDQ3JQpT58L4110dFk3HVnex5/MHAMn99HcWvPUnOHX8MKe8o2Mye/zyIr6Yy+A1FR9olN5J0ynmd0odgcKqe92+wct7zzqD+IJ85o4nrewkjNh5PZtQ8UqO+Raf4Wt2W1ePGunMLVTu3UHVgmSEhGeuAIVgHDMHWfwiWfoPRW21H+ayEEEJ0V5I8CCF6NINeYWi6vkO2FTt+CrGTZlD7w5LAstpV31G7ehmx46cGllUvX0jRS4+ieYM7H+usNrJv+wMxoyZ2yPGEKy9Nzwc3WDnvBSeVTRKIN0xm7kpLwld8MSWO2aRHfUWsKR+rsShoeNrW+KrKqVu9jLrVyxoWKArmzD5YB+RhHTAUa/88LNn9UAzy50QIISKB3O2FEKKJjCtux77xJ/z1tYFlxa88QdTQUeisNkrf+x8V894NWc+UlkXur/6MOatPJx9xgyHpBxKI551UORoSA01ReD41it9U+8CZRGHtpQDoFBeDJpYyYHwx7sIt1BRsRtekuVarNA33vl249+2i+ruv4MBoUta+A7H2H4K1/xBsg4/BmJR69E5WCCFEl5HkQQghmjDEJZB++W3se/avgWW+mkqKX30Cv9NJ/bqVIetEHTOW7Nv/gCE6tpOPNtjQdD3vX2/lghcdVDkaljmMOl7tE82N+bXoDlQ2qJqF/B/6UFI8kFkPnktuHxNr9+zmfyuXklW8mwEle+hXuhebp/nZqQ+ledw4tm7EsXVjYFniyeeSftktMvyrEEL0MpI8CCHEIeKOm0XNikXUr18VWFazInQ0JYDE2Wc3PCTrO6bp1JE6JlPPe9fbuOAFR6AjeWG0kc9zojiz0B5UtqbQy9zbijnu7iTGntgHY2IydxQUUOf3o2gqGZVl9C/Zw/jyYiZVluDdswP8zU/Wd6jKrz7CnJFD4glnHI3TFEII0UUkeRBCiEMoikLmNXdTcP/1qC5H84X0ejKuvIPEWad39uG1aXimnnevt3HhCw5qDlQerEy1UGPUcXFhHcYmXTV8Lo3v/lZOyS8uJt2WyLODBnHrtm3U+KEoKY2ipDSWAYOsVp7uk4t1326cO7bg3N7wz7O/qMXjKHnjGSx9B2EbMKQTzloIIURnkHG8hBCiGcakVNIuubHZ9/TRsfS97x/dMnE4aGRWQwIRa2lctjnBxH+GxFOTEPq90dZ59cy7o4TMaiPPDx5M0iEdoLc5ndy0azf2PgNJOvlcsm/9HYMefY28Zz4k956/kHLOlUSPnBC0jubzsvfJh/DV1Ry9ExVCCNGpJHkQQogWJMw8DdvQUUHLzNl96f/Q00Qdsrw7GpWt593rbMSYG5dVmfU82i+WXzItIeUrt3v47OYiDKtVXhg8mDSjMej9nS4X12/bRrHHE1hmiIkjZuREUs+9kj73/JWk0y4MWsdbUcbe//4FTQ2vuZMQQojuTZIHIYRogaLTkXPbH4gaNgadLYr4mafS749PYErN6OpDC9voHD3vHJJA+HQKb2dG8X7/aDRjcIdmr0Pjm4fKKH3ZwXP9B5FpCp7kbq/bzQ1bt7LH3fzEc2kXXodtyMigZfZf1lD28esdeVpCCCG6iCQPQgjRCkNcAn1/+0+GPvcpWdf9pkdOkDY2tyGBSI0JThR+SjTz+OBY6mNDO3tv/LCW9b+t4omEAeSazUHvFXs83LB1KztdoaMxKXo92bf9AUN8UtDysk/eoK6ZkaqEEEL0LJI8CCFEBBibq+fr261MyvYELd9vNfCvAXFsTjWHrFO2yc2KO8p4pC6XAZbgZk5lXi83bt3KNqczZD1jfCLZt/8BdMF/YvY9+3c8+4s77JyEEEJ0PkkehBAiQqTEKDx9Zh33zjaia1IJ4dErvJ4TxSd9otAOqYRw16r88EAFd69MI89sDXqv0ufjpq1b2ewIHZEqKm8EaRcHdzj32+vY88RDqB5PSHkhhBA9gyQPQggRQXQK3HW8iQ9vtJIR2ySDUBRWpVh4enAc9qhD/jRokP9WHZe+HM9of3CzrRq/n5u2buXn+vqQfSWdch6xE6cHLXPtLqD49Sc7+KyEEEJ0FkkehBAiAk3uZ2DBXTZOyAuuaiiKMvDooDi2JZlC1ilb5+bEf9qYURITtNyuqtxaUMDqurqg5YqikHn9/2HKzA1aXv3tfKqWzO/Q8xFCCNE5JHkQQogIlRSl47WrrPzxNDOGJn8NXAYdL/eN5otsG1pwH2tclSoj/2PkrBVxoDUud6oqdxYU8H1tbVB5vdVGzp0PojMH95kofvUJnLu2HZ0TE0IIcdRI8iCEEBFMp1O4ZbqJT262kR0f3IxpWbqV5wfH4rQE/6nQVMj5WM8Vb8ZjdjSu49Y0fr19O0uqq4PKW7L6kHndb4K34fWy54mH8NuDayuEEEJ0b5I8CCGEYFyungV3RnHKsOCZpXfHGHksL45d8caQdeJ+1nHVk/Gk7G1s+uTVNO7ZsYMFVVXBZY89nsSTzgla5i0rYe+zf0NT1Q4/HyGEEEeHJA9CCCEAiLcp/O8KC//vDDOmJl0h7EYdLwyIYVGGtWlLJQBMFQoXPhPL8BXmQDMmP/D7nTv5rqYmqGzaJTdiHXRM0LL6dT9QPvfto3ZOQgghOpYkD0IIIQIUReG6KSY+u8VGn8TGJkmaorAoy8bLg2JwmYI7Qig+hZkfR3HS21EYD0w87Qfu27EjqBO1zmAk5/YH0MfGB62//8NXqP9lzdE+NSGEEB1AkgchhBAhRmXr+frOKM4cGdyMqSDOxH+GxLE3xhCyzuB1Zi54Mo7EkoZqC4+m8avt29lgtwfKGBOTybntD6A0+fOjaex95hE85aVH85SEEEJ0AEkehBBCNCvWovDsJRb+fo4Zc5Ncodak59lBsSxNs4Ssk7hfzwVPxjLg54Y+Eg5V5Y6CAgqazEQdNWw0qRdeG7Sev76WvU8+jOqVCeSEEKI7C/3qqBcoLill5ao1bN6yleqaGtxuDzHRUWRkpDN29Agmjh+LXq8PY0ttK9ixkx9WrWHHzt1UV9fg9fmwWiykpqaQN2gAU46dSEJCfBhbEkKI7kdRFK6cZGJcjp6b3nKyvbyhY4OqU5ifE8WuaCMX7a7H5GvsDWH0Kpz8VjSfm+spzPNS6/dz67ZtvDR4MDmWhoQjec5FOAs2U7dmeWA9544tlLz5LJlX39kFZyqEECIcSn5+/qH933q0+V8tZP7Xi/H7/S2WycrM4PprLic1Jfmw9+N0uXjjrfdZ9/OGVssZjQbOO/sMpk2Z3K7tDx48+LCP7XCpqkrpvkLSsnLR6aRSKhJIzCPLkcbb7ta47xMXH/7kC1qe6PJz+c460u3B912PSePDW2upyGxYnmEy8dLgwaSZGiag8zvq2fHH2/CU7gtaL+vm+4mfcuJhnKE4lFzjkUXiHXlaivnWrVuP2j57Vc3DlwsW8/n8BQBYLGZmTDuOvEEDsVgslFdU8P3KH9mSv419RcU89exL3HP3bcTERLd7P16fjyefeYHdhXsBiI2NYea0KQwY0BezyURFRRWrVq9l/S8b8Xp9vPP+x5jNZiaOH9Ph5yyEEJ0lyqzw5IUWpg7w8dtPXbi8DcsrLXqeyYvjzEI748vdgfImj8IZL8fw/m012OM1ij0ebt22jRcHDybBaERviybnzgfZ8dAdaJ7G9Yr+928suf2x5PTvitMUQgjRil6TlpaWljHvQOIQFWXj3l/fwZlzTiFv8ED65GYzbswo7rjlembNmApARUUln8ydf1j7+mrB4kDikJSYwO/uvZuTZx/PwP79yMnOYvSo4dx43ZWccdrJgXU++vRzvD5fK1sVQojuT1EULh5v5MvbbeSlNf4J8ekUPu4TxfpEU1D56BodZ7wcg9HV8PMut5vbCgqoO1A7bMntT+Y1dweto3ncDRPIOeo745SEEEK0Q69JHr5csBj1wERD55w5h7TUlGbLnX3maaQkJwGwavVayisq27UfVVVZumxl4OcrL7uImOjmay9OOnEmSYkJANTV1VOwfUe79iWEEN1VXpqeL26zcen4xsnjNEXhw77R7IoOrtROLjZw6hsx6A60asp3Orm7oADngXt2/NTZJMw6PWgdT8k+9r3wLzStV7WsFUKIHq9XJA8+n4+fN2wEwGq1Mn7c6BbL6vV6jps8AQ4kAuvW/9KufVVUVqHT69DpdMRERzOgf98Wy+p0Ovo3eb+kpKxd+xJCiO7MZlJ49HwLT11kwXagwsGnU3h9YAxl5uA/L7lbjcz4yBaYSG6d3c49O3bgOZBApF9+K9b+eUHr1K1eRsUX73XS2QghhAhHr0geduzcjcvV0F52QL8+GA2td+UYPGhg4PXGzfnt2ldKchJ//fMfePxfj/Dg7/8PRVFaLa/XNY7q5PV627UvIYToCc4bY+TrO6I4JqPhT4rToOOVwbHUG4Lvj8f8aGHc4sbhXVfU1vKHXbvwaRo6o4nsO/6IPjo2aJ3Sd1/CvnldJ52JEEKItvSK5KGouCTwOjs7s83y2VkZgYf+oqKSNss3R6fTYbVa2yxXVl4eeJ2YKEO2CiF6pwEpOj67xcaJQxq+MKky63l9YAzeQ75fOfYrG4PXNvaLWFRdzSOFhaiahik5jexbfwdNv5TRVPY+/QjeqnKEEEJ0vV6RPJTub2wOlBjGnAoGgyEwylK93U59k9lPO9L+snJ27NwNB5pLDc3r/OFXhRCis9hMCv+7wso5oxtqf/dEG3m3fzTqIeVOeD+KzO2NNcSfVVTw2N69aJpG9IjxpJx7VVB5X00Ve596GE0GnRBCiC7XK4Zqra9vfPiPbqHz8qFioqOpra0LrB8dFdWhx6RpGu+8/3Ggs9+UYycSFWULe/2Dnb8708F9dsW+RdeQmEeWzoi3XoEnzjcRb4GXV/rYlGDmixyV0/c4Gsv4Fea8Fs0Ht9ZSldZwLG+XlRGl03FTRgZJp1+Mo2AT9vWrAus4tm6k5O3nSLvslqN27L2RXOORReIdeboi5r0ieXB7PIHXbfV3OMjQpJzb7Wm17OH44OO55G8tACAxIYHTTz2pXeuX7ivs8GMKV1nx3i7bt+gaEvPI0hnxvn0sGHxWXlht4/s0K4luleP2uwLvm506zvhfDO/fXoszpuFLlhdLS9HqaznHZsV4xqXoCnegNmmuVPn1x7gTUzGPnHDUj7+3kWs8ski8I09nxrxXJA9NOyIbDiN58Po6riOzpml88PFcvv1uOQAWs5kbr7uyXbUOAGlZuR12TOFSVZWy4r2kZGTLzJQRQmIeWTo73n/Khpx0L3/83MO8HBvxHj/Dqhvvt7FVek5/OYaPb67Fd6AbxEt2J+mJyZydlUv8XX9i9yO/Qmtyj3d+8hppoyZgzuz8e2RPJNd4ZJF4R56WYl5XUHDU9tkrkgejsXGc8XAnYvM1KWdqsv6RcLs9vPrmO6z/uWHYWJvNyi03XENOGJ24D9WVF71Op5ObToSRmEeWzoz3DVPNxNt0/OoDF+/2i+H6/BpyHP7A+2l7DZz0VjTzr6xHO3BIf9mzh2iDgZMGDCHjyjsoeumxQHnV5WTfk3+m30NPo7e0PWiFaCDXeGSReEeezox5r/jNMpsaR+4IdzjUpuXMZvMRH0N1dQ3/fvK/gcQhISGeX91xM/379TnibQshRE92wVgj/7vcis6s8PqgWCpNwX96+m8yMXVu4xwQGvCHnTtZVlNDwszTiJ9+SlB5d1EhRS8+KhPICSFEF+gVycPBkZM4MJNzOGpqawOvY2PC62Tdkj179/HPfz/Fnr1FAPTtk8M9v7qdzIz0I9quEEL0FicNM/DWtVaI1vHqoFgc+uAxXEcttzBqaeMXOX7g3h07WFNXR8ZVd2DpMzCofO0P31L51UeddvxCCCEa9IrkIT0tNfC6srKqzfJutwe7vWHkj7i42LDma2jJ1m3beeyJZ6muaUhGJowfw9133ExcbMxhb1MIIXqj4/ob+PBGG2qygTcGxuA7ZA6IqfOiGPBLYzNSt6bxq+3b2eL1kXPnH9HZgr/oKXnrWWp/XNpZhy+EEKK3JA/ZWY19Cgr37muz/O7CPYHXOVnt749wUMH2nTzz/Mt4Doz2dNopJ3L15ReHPeKTEEJEmpFZej652YYn28SHfYOTAUWDk9+JJm23PrDMrqrcXlDAnpgEsm++P3hjmsbe//4F++b1nXX4QggR8XpF8tC3Tw7R0Q3zNOzYuRuX291q+U2b8wOvR44Ydlj7LC0t47mXXsXr9aIoCpdceC5zTpl9WNsSQohIMvDAbNT2IVa+ygqu+dV5Fc56JZbYisY/TzV+P7cWFFAzbEzIBHKa10vhf/6Ia8+OTjt+IYSIZL0iedDpdIwdPRIAj8fDylVrWizrcrkD75tMJkaNGN7u/fl8Pl569U0cDicAF5x7JlOPm3TYxy+EEJEmK17HJzdbqR4fxY/JwYNWmOwK570Uh8Xe2K6p3Ovl1m3b0E67kITj5wSVVx12dv/zt3jKSzvt+IUQIlL1iuQB4OTZswJDts6d9yX7iopDyqiqytvvfURdfUOn6lkzpwZqLJq67e77Av8qKipD3v9q4TeB7U+aMI4Z0447CmckhBC9W1KUjg9ujKJsZixbY4OHzI4qVzjn1Tj0TQbQ2+fxcNv27Vguu5WYcVOCyvuqKtj9j/vx1dV01uELIURE6jXJQ3xcLBeedxYcqF149PFn+PTzL9m6bTu7C/ewavVaHnv8v6xeuw6Afn1yOfnEWe3ej93uYPE3DR309Ho9kyeOo6i4JKx/pfvLOvishRCiZ4s2K7x+nY39c+IpsuqD3kvapeO0d2NBbVy20+Xizp07ib/pPmx5I4LKe4r3UPjo71Fdzs46fCGEiDi9qmfvcZMn4PP5+OjTebjdHr5e+A1fL/wmpNzQvEFcfcUlmEztnxxuw6YtgT4Vfr+fx59+Pux1ExMSePjB+8MoKYQQkcNiVHjuahv36zWi3q0kztuYLfT52cCMhGiWzGkchnuzw8Fv9uzlgVt/j/mf9+PeuyvwnnP7FvY89TC5d/8ZRQavOGo0TcO+YS2VCz7Bnv8zlpwBpF9xK9ZDhtQVQvQ+ve7OOn3qsQwdMpjlK1axaXM+VdXVeL1eYmNiyM3JZsK4MYwaecxhb19V1TBKCSGEaA+DXuEfV0bxF03D/HYlFrVxArgRS0zUxFtZN6WxRmFtfT3n1NeTddrl/Padp4mtbRymu379KopeeozMG+9BUZSQfYnDp7pdVC9fSNlXH+ErKgwsd+T/zM4/3UHaxTeSeNLZ8rkL0Ysp+fn5MkVnNzR48OBO36eqqpTuKyQtK1emtY8QEvPI0hPirWkaT79Uh+WdSpo2YlKBL6+ys+OY0NH0MitK+cN7/yXa5QhavnHaqTjPvIxBNht5VitJxvbXNvd0HRFzj6qydV8h5Qs+JXblIsxOR6vlo0dPIuuGezDExh/mUYvD1ROucdGxWor51q1bj9o+e13NgxBCiJ5LURRuvz6WV9wq2sfVgeU64IQ3oqi/RWV/rjdonaKkNB476xru+/B5zL7G945ZOp/X9UaeGDMVgCSDgcE2G4OtVgZbreRZreRaLOibfEuuaRoOD9S4Gv73+DQ8PvD4G/53+xuXuZssb3ivyWufhsdP47peDa1eRan3o69XMdb7MThVTPF6+h5nY+oYE8PSdeh0XfuNvaZpFLrdbLTb2WC3U5X/C0NWLGJMwQZStPBq3uvX/cD2391I1k33ET1i3FE/5p5CU1X89joMMXFdfShCHBFJHoQQQnQ7V98Wz9t1flwL6wLLzH445flYvrjOg2egg1q/P/BeQWYfnp5zGXd99hr6Jg+5l307l1pbND/kjabC52NFbS0ramsD7yuqgt5uRq0146o0U19uwl1lRvO18q2toqHoNRS9imLQMOEn1qcS5/UT69GI9arEuDRi3CoJLohxQrRTQ6+2kBj8UMenyfBYjg7fMSaGDrEwLcfM+HQTFr2++XU6SKXXywaHI5AsbHI4cLjdTNq6npN+Wka//a1PvFqUkMKO9Fymbg4eIt1XU8nuf9xH0pyLSD3/anSGyKv1acpdVMjuR3+Pd38xlr6DSD3/GqJHTpDmXaJHkmZL3ZQ0WxKdQWIeWXpavDVN473fleH4MbiZTIlVz8KpceT2g3LFRY3BhdPiwhflZvqu77lxwftB5X06Pf8651o25Q4Ke9++OiOqS0+UWyPaATF2heh6iK5XiK7TEV2rI6pGIapWh8XZ3s/ST1rUIlKsy9A0I/Xe/tR7BlLnHYjHn0hFup/tw73sGO6hKlUjTm8k02Iky2Yk2djwL8lgIMloJMloJNlgIM5gQNfMg2jTmLuBLU0ShY0OB0UeT6BsnL2OWT+v4PifVxLvqA/ZVlPr++axeOw0XENGstnpYvjurdz45TvNrmfpN5js236POS2rnZ9T7+B3Odnxx1vxFO8JWm7LG0nahddhG3z4/TAP1dOucXHkuqLZkiQP3ZQkD6IzSMwjS0+Mt9+j8cGvSnDkB/d12B5j4PtUKwZNQ6+BXtUwaGBQVGbyMcd7Pggq71EsfJV8N9W6HPR+Bb0P9H4FnQ/0ftD7lMD/ugP/WxwKen/HfjMcZdxB37jXiTLuafZ9jz+BOs8A6j0DqfcOoDgmi+3DG5KJklxfiwOs6yGQTBxMLJKNRmJ1OjZXVrBD0bHd6cTfzLp9S/dy0k/LmLR1PUZ/cyUauI0mCsdOgeNPZ3DfgQyyWjHqdPy3qIgXS0qIcdRz41fvMmpXfsi6OouVjKvuJH7q7PA/rF5A0zT2Pfd3apYvbLFMzJhjSb3gGiw5/Y94fz3xGhdHRpIHESDJg+gMEvPI0lPj7a7z89FtxbiKfGGuodEn9m3SohYHLfX4Y9lc8Vvc/pSjcpyt0SsOsmM+ItW2BEUJ/8+uXzNh9/Sl3juQcn1/1g/KYcsoI/sG+FCPoEWTTvUzrmAjJ/+0jMFFu1otqyalkjj7LNJnzkEfFR36vqZx744dfFNTg6KpnPTTci5a+gUGNTQRiTvuBDKuvhO9NXSC1t6o6tv5FL30aNsFFYW4404g9dyrMKVmHPb+euo1Lg6fJA8iQJIH0Rkk5pGlJ8e7rsTLp7cV460Jd7hslQHxz5NkXR201OVLZVPF/fjU2A4/Ro9FwxWn4Y7T8MZr+BMUtHiNbMdqRm98H4uzY2a/dnozqFYHsCOtL2uG5bBudDw+c3g1JFEuBzN/+YET168gqa661bK2oaNIOulcYsZORtG1nqk4/H6uyc+nwOUCoM/+fdzyxVtkVoVOjmpMzSD71t9jGzAkrGPuiaodGlvWFWB7/i70/samYXbFhtcUTbx7f7PrKXoDCbNOJ+WsyzDEJbR7vz35GheHR5IHESDJg+gMEvPI0tPjXZ7v5otfl+B3h/dnS8FLXuLjxJq3BC23e/qwufIeVM0S3o51YIhXMCXpMSfpsSXriEoyEJ1iIC7FSFyKgehkA0Zb8GfqKS2i6NXHsf+yptnNmnP6ETtxBs7tW3AWbMRfX9dsubZ41WhKLf3Jz+7DjyNy2JabhfeQDspZ5SXMXrecKZvXBo1IdSjFaCTu2BNIOukcLH0GtOs4itxursjPp9rXUENk8nq4/NtPmbnhx9DCej2p511N8pyLUHrg7+JBqqqxq1JjU7GfjcUqm4r9bChSqaxy8EzZPeT6gjucP5R4DystE7jA+zVX2d9H72g+odSZLSSech7Jp12A3hZa29Py8fTsa1y0nyQPIkCSB9EZJOaRpTfEu+QXF6ufq8Re4UdvVNAZlIb/jaA3KoFlOlPDa73iIG7Xn9E7dwdtR0saCcf+Dp3ZdGB9Bb2RwPb0RgVjlI6oZD2WBD06ffh9H1Sfl4p571H26ZtoXk/I+4rJQuq5V5B08nmBWbA1TcNTvAfH1o04tjX8O7SDbbj86Cky92FDZj8KU1M5dudPjNy/pdV1DAlJJJ5wJgnHzzmi+RnW1NVxy7ZtQX0rpmz9mZsWfwxOe0j5qGPGkHXTfRgTkg97n53F4dHYXKKyocjPpgOJwqYSFcehIdY07qt6nNnOJUGLP4k6jafibwj8bFWd/DNlHsO2fozqan7uDH10DMmnX0Li7LPQmcxtHmNvuMZF+0jyIAIkeRCdQWIeWSI13t7qCnY+dBfe8pKg5XHHziLr5vs79Jtv+5afKX75P7ibzL7cVPToSWRceQemlPQ2t+Wrq8G5bROObRup3bABd+FWFDU0GTkS1gFDSDr5XGInTA8kMkfqw7Iy/rInOPEZ7KjjTws/wLd9c0h5fUwcWTfcQ8yYyR2y/yOlaRpFNRqbilU2NqlR2FmhoYXxxHSKfSH/V/100LKtxv78pv9D+M16fPVGVHfjZ31ijp2Hoj7GteQztBZqhQwJyaSeeyXx005GaWX43ki9xiOZJA8iQJIH0Rkk5pElkuPtLt7Lzofvwl8X3Ewk6dTzSb/05iPevq+uhtJ3nqf6u6+afd+QkETGFbcRM37aYY/tr/q8uHYVUP3TL1St/hl/yWb06mH0o9DriZs4g8STzsE2cOhhHUtb/r5nD++VBfd3GG4x89dNq6j67G1oZsK5xNlnk3bxjehMpqNyTC1RVY0lBX6+yfc11CiU+KlqfRLtFvXz7uap/fdipjHJcxmt/O3S37AjsaGfjaaCqygKx85Y3CVRoCmkxig8e0otuWvfonrp181+PgCmjBxSz7+G2AnN/x5F8jUeqSR5EAGSPIjOIDGPLJEeb+eOLez6y/+hul1By9MuvpHkORce1jY1TaNm2QJK3n4uJDEBQNGROPssUs+/usNHGNI0jfrtRez7+idqf9mAUp2PVb+3xdGcvP5odhlmMf23F5A49PBH9AmHV9O4fds2VtcHz/swJzGRe53V7Hv27/gqQztTm3P6k3Pb7zFn9Tmqxwdgd2u8t9bLS8s9bC8/skehpCiF0alubvv5N8TW7g1678k5l/Pj4JHNrud36nHsjsW5Mxa13sS9J5m4cVAxZR++Qt3qZS3uz9JvMGkXXEfU8LFBSUSkX+ORSJIHESDJg+gMEvPIIvGG+p9/ZPdjf4BD5jPIuum+ds9B4C4qpOiVx3FsXt/s+5Z+g8m85m6s/Trnfu6xq+xZVk7x4l9wbd+ITbcNi34/HjWRMscUKpyT0DCi6WHURXGMvCQOo/Xo/R5U+3xcuWUL+zzBTa3uysri0igrRS891uwDsmIyk375rSTMPO2ozMBcWKnyv+89vL3aS60LDKrG5P0uBtV6MaoNj0RN86+mR6AAFgNYjWA1KliNYDKAS/WR5XmBNG1l0L52MZNN2sWBbWiAzwh+o4bXqOEzgc+o4TNqeHx6nHYTqWYLZ4+1EOMtQNv4BlrJLy2ei3XwaFLOv5boIUNRFEWu8QgkyYMIkORBdAaJeWSReDeoXr6Qfc/+LXihXk/urx8mZuTENtdXPR7K575F+dx30Pyhc0/oLFZSz7+WxNlntjnE6dHic6sUrXGx+rUqagqab0dvS9Ez4cZE+s20HZWHdIDtTidX5+fjUBub4SjAfwYMYEpsLFXfzKPkjWea7VgeO2Eamdf9Gn1UzBEfh6ZprNjh54XlXr7e7ONAjkB2vZfzd9lJdbU8OV44kq3L6B//StAyuzeXTeW/RcPY4nrhiDVtIifmQ6JMu1ssU+kcS7H7HHzGLIwxKnmnxTP8/Lh2dfQXPZMkDyJAkgfRGSTmkUXi3ah83nuUvvN80DLFZKHv7/7V6vwD9RvWUPzKE3hK9zX7fsz4qWRccRvGxM6fiK45fp+f958touxzlWhf83/u00dZmHRbIon9j05fg++qq/n1jh003XuUTsereXn0s1px7d3F3mcewb1nZ8i6xqQUsm75HVF5Iw5r3y6vxsfrfLz0vYeNxY0JjEHVOKHIwbQSV0uTdofNatjLMcmPoFMakzSfamVj+QO4/alHuPWDNBIsa8mO+RiroaT5EppCufM49tWdiUdNIvUYMzN+l0J0Wsd0hBfdkyQPIkCSB9EZJOaRReIdrOStZ6mY/0HQMn1MHP0eeBxzRnbQcl9NFSVv/peaFYtpjjEplYyr7uw2IwYddDDmL69JZfv7tRxb6qK5uhBFB0POjGHMVfGYYzq+tuR/JSU8XVQUtCzHbOa1vDxiDQZUj5vSt5+ncuGnzR5cytmXkXLW5a2ONNRUSa3KKyu8vL7KS6U9+DEny+7j/J31pB1hbQOATnFxTPL/C3mg31Z1M1Wu8Ue8/VB+kq3fkxXzGWZ9VbMlVM2Aw5uD25+MT5dM9qy+ZE7pgzElHWNyGjrDkdWEiO5FkgcRIMmD6AwS88gi8Q6mqSr7nvs7Nd8vClpuTE6n34OPY4xPQlNVqr79gtJ3X0R11IduRKcj6ZTzST3nCnQWa+cdfJgOxjwpPYfzX3Sze4ub0wsdDKxrvimTOU7HuGsTGHRKdIc2edE0jd/v2sVXVcEPvJNiYnhi4EAMB5pN1a79nqIX/oW/vjZkG7bBw8m+7fet1ur8tMfPC8s9zP3Zh++QAYv0B2obprdQ25A0yET/k6PY7XGz1eVkq9OB3a+iHfgYtIMdIQ7+jMYZW99kxP7gWcz9eacSdexNgZ8V5eA6CmgaPreG36PhczW89rpV9tS62F7jotLhxeBVMHoV9F4wehQMXgWDl4b/PQ2v9ZqXtKhvyIz+AoMudP6MFikKhoRkTAcSCVNKBsaU9IafU9IxJiZ3WVM7cXgkeRABkjyIziAxjywS71Cqz0vhY38ImQXanNOfjKvuoPSdF3AWbGp2XevAoWRe8yssuf076Wjbr2nMi2th9hN2quwax1R7OG2PgwRP80OCJg02Mfn2RFKHhTkLdxicqsoNW7ey2RE8DuolKSn8X05O4GdvZTn7nv0b9s3rQrahj4kj+5bfET1iXGN5v8a8DT5eXO5hTWHz59NabYPOAPEXWFgxzcFyR21Q/4zWzN60miu+ei9omaXvIPr98XF0xsNrAlbq8nDfqjLWqpUYY1uYCVwDnb8hmRjlh4s2LCd19ZfgdTVfvh0UvQFjUirGlLQDSUVGILEwpWSgj40/av1jxOGR5EEESPIgOoPEPLJIvJvndzrY9df/w7UzvD+2Ols0aRdd3zAaUDf/HA+N+debfFz1mhMAo19jeomTGaVODC08Lw+YHcX4GxKwJXZMu/lSj4crtmyhwhfc0fyB3FzOTm6cZVpT/ZR//i77P3wFDn2YVxRSzrkS3YmX8OZqP6+u8FJc2/yjjF7VmFXUcI66ZooY++n45iI76xKdYR1/qtHIzPh4ZtVXE/XP+4I6euusNgY8/CymtMywttWahZu93L2gCl9mLdacOnTG1h/Vkh313LhuGXmrv0NpphN/R1FMZkzJaZiz+5J40jmH3RdFdBxJHkSAJA+iM0jMI4vEu2W+mip2Pnx3ix2hD4o7dhbpl92CIS6h047tSDQX8wc/d/H8ssZvtePdfm6oc5Kwy93sNow2hVGXxzPsnFj0xiP/1vkXu50btm7F22S6ZoOi8OygQYyJjg4q6yjYxN6n/xIyOzjAGssYHom/m1p9bLP76ef2ccU+O5bKZh6m9ZB/iodFU+tR22ilM8BiYWZ8PDPj4hhqs6G6Xex48DY8h8winn3HH4mbOL2Nsw/f3mqVm9508lORD0t2PbZ+tZhTW09yop12xpbuZYrPTU5+Nd4NxZiUMsz6cgy6w5z5riWKQsq5V5Fy5qXdPonuzSR5EAGSPIjOIDGPLBLv1nn2F7Hzz3fhqwntiGpKzSTj6juJHnE0OsEePc3F3OPTOPNZB+v3Bn+j/69RYF1QS01h881l4nIMTLotiazxR963Y25FBX/aHTz0aILBwOtDhpBxyAzTfnsde5/7B/U/rQjZzn59Eg8n3sNmU15gWXYMXO9xY15R3+xEzdXZfuZfUE9FRvMdphVgZFRUIGHItTQ23dI0raGfzPKFQeskzj6LjCvvCP8DCJPHp/HwfDcvLm+IiT7ag61vLba+tehtbXf4zq40curbMZh3g15xYNaXN/wzlGOLqiBjYC06TxmeshI0z+E1e4oePYnsm+/vkCF1RftJ8iACJHkQnUFiHlkk3m1z7trGrkd+g+pq+JZW0RtIOv0iUs68FJ3J3NWH124txXx3hcrsJ+zUNalssBjhi5utqCvs/PRaNV5H848HucdZmXhzIjGZRzZqz7/37uWN/fuDluVZrbw0eDDWA6MqaZrG26u9PLHYzaTCj7mu9g30BGcEPvQ8F3cVe4edyTV9FfiomupdoQmQqtP48QQna2a5mq1t6GexcElKCjPi40k2Nn9uVUvmU/Tio0HLjrSfQzg+/8XLrz5wUX8wXoqGOc2BrV8ttuz6QKfu5uh8MPlLK2O/aybpU2D4hbGMuSoenDV4ykrwlpXgKSs+8H/Dz96K/c3OaXKQMTWD3Dv/hKXPgA44W9EekjyIAEkeRGeQmEcWiXd4XHt2UD73bRSzheRTzsec1aerD+mwtRbzuT97ufGt4G+b89J0fHGbDer9rHmpmoKvmhlhCtAbYfhFcYy8OA6D5fB+l/yaxt3bt/N9bfDISifEx/P3fv1weuE3H7r4ZH3jQ+sI90b+UPkoSWpo7ZA/ZTLrNl6G3x/6kFyW6WPhhXYqMkO/rR9ktXJdejonxMeja6UzsGvPTnb86XY0T2PG1ZH9HNqys1zlhjedQfNVAOhMfvqPqCdlSC27W+k0nbPVwInvRBNVHxqvpDwTM3+fQmwLCaGm+vFVVeApK8G+6SfKPnmTQ6t1FJOZzGvubvdM7eLISPIgAiR5EJ1BYh5ZJN6Rp62Y3/+Ji1dXBn9Lf+kEI4+e19BUp2yzm5VPVVCeHzoDNEBUip4JNyfSd/rhzVJd5/NxVX4+u93B/S0ujkvny7lxbCoJbXeU4K/iTzWPcYxzQ8h7Ll8a26puwelrmKfDr9NY3UJtw1CbjevT05keF9dq0gDgdzk7pZ9DW5xejQfmunlzVWjNSqxF455zNapM+1ijwjZXaCJhrVc48d0o+uSH1pKoZki7ycYJpydjbeP+YN+0jj1P/T/8ddUh7yWccCbpl98i80kAdS6N99Z4OWmYgZyEo3PPleRBBEjyIDqDxDyySLwjT1sxd3k15jztCHlIf/piC+eObnj401SNbV/Vs+alKlzVzQ/LlDjASMpQC0kDTSQONJHQ34jBFN7v2G6Xiyvz86n3B9cKVC7PwLUvuAP18EwdN0wxceZwheqPX6Vi3tsh2/NrJnbXXMbm+EksushO+SG1DSOiorg+PZ0psbFhJTwt9nM48Swyrur4fg7heH+tl/s+duFspnvKZaOcPHJ+EpWqj6W1tXxXU8OPdXX4DnZQV2HUMjPHzbeh94ee/7axblxX6JmaEc+02FhSTM03x/JWlrHniYdwbt8S8p514FBy7vhjt5lpvbPll/p5eYWX99d6cXjg9hkmfn/q0Wn2KMmDCJDkQXQGiXlkkXhHnnBiXlCmcvKTdhxNKheiTPD1nVH0T25cx13vZ91r1Wz+pK7ZjshNKTqI72MkcaCJpEHmhqRigAlTVPPH8H1tLXcVFAT1ZlB9CuWLcvDVmIkxw38usHDqMQYURaGiwM2yf5bj37uGAfEvNjuS0JJhE3nthLPwHvgGfEx0NDekpzMxJqZdtSRV331J0Qv/Clpm6TuIfg88jq6FB+vOkF/q5/o3XBSUhQZjfK6Ol66wkhrT8Hnb/X5W1taypKaGZTU11Pj9JO/Tc/Kb0SSUh3YAqU7y8/Wl9ezP8TPMZmN6XBzT4+IYbLUGfXaq10PJm89SteizkG3oY+PJuf0PRA0d3eHn3h15/RpfbfLxv++9rNgZnLAm2BTW/jYKSweMVnYoSR5EgCQPojNIzCOLxDvyhBvzD37ycse7wc1chmfomHurLeSBp2qnh5VPV1Kyrv2j88RkGUgaYCLpQFKRONCENUGP3a1xyeJ97EsL7kDtsxuIXdeHVy6OYUCKDr9X4+e3qln/Vg3ageczk76cgfHPEm3aFbK/3SmZfHvRzVw0bATjYto/GlBX93Noi92tcc/HLj5eF9qZOTNO4ZUrrYzICk4O/JrGz3Y7S2tqWFZaTZ/3DQz7MfRbcb9OY+UpTn6a7uLglNxpRiPT4+KYER/PpJiYQHOv6mVfU/S//wTNewENM7CnXXg9Sadd0Gsnl9tfp/LGKi+v/+ClpIX5RgAev8DCheM6vimXJA8iQJIH0Rkk5pFF4h152hPzX3/g4u3Vwe1grj3WyCNnhc4yrWkau5c6WPVsJfb9bQ8Z2hpTgp7tRj3b9DpqRtqpHVtHXbzaMGYqMNIWxfODB1G308fSf5RRuT20rY6m82Ad8jYjq5aGvKezRZF1w73Ejp/SruNqsZ/D7Q8QN2lGe0/zqNE0jddXeXngMzeeQ0JhNcITF1o4fUTLD62FLhffflmB+0UPBlfoA37hIC8LL6rHERv8uDjMZuORvn0DQ9k6dxew54mH8O4vDtlG7IRpZN5wD3qr7fBPtBvRNI0fdzc0TZq3wYe3lUtAr4NThhm4fYaJ0TltTCpyGCR5EAGSPIjOIDGPLBLvyNOemDs8Gqc+5WDr/uBmMC9ebmHO8OYfPv1ejdKfXVQUeKjY5qaiwEPtPh8c4ZOFy6pSluWnLNNHeZafyfZo4uYRqG1oqjzdx6IL7ZRl+zl2y09cv/AjjN7QCe+STruAtAuuQzG0PVt2d+zn0Jaf9/m57nUne6tDP/zfnGDi1yeY0Ola/va/rsTL4kfKqNwc2jneGaWy8EI7u4cGJ242nY7f5uRwWlISHJyT49m/Ub/uh5BtmDJzyb3zwR49epnDo/HxOi8vr/CGjHp1qOR4ldMmaIwbohJvhZMSE4/KMUnyIAIkeRCdQWIeWSTekae9Mc8v9XPKUw5cTZ4RYy2w4M4ochPD+53xOlQqt3uoKPBQWeChosBN1S5vsw/+R0LVaaw53sWPJzhRDTArPp7r0tPpV9XQkdd9SI0BgG3wcLJv+wPGxORWt91d+zm0pazWz1Uv1/BTcWiyN2e4gScutGAztZxAqH6Nda81NAtrLgFcP8XF96c58B+y+TmJidyXk0OUXo+mqpR9+iZlH78GWvBGdBYrmdf/X7epudE0DdULPreK363hO/DP79HwudSG/90axeUqy7d4+WmnD58bjKqGUdMw6fyYdCpmRcWoqBjRsKBh8GvovQoGr0aSuo06bTC3fHR05sCQ5EEESPIgOoPEPLJIvCPP4cT8rR89/ObD4G/ux+To+OQmGybD4bVb93s0qnY1JBMl+W7WrnJjrfBiaqPjdUsq0hvmbSjP9nNSQgLXpqcz0No4v4Pf5aT4f/+mZsXikHX1MfFk3/Y7oo8Z2+y2u3s/h9aoqsrewkIeX53GW6tD+0EMz9Dx8lVWsuNb/10oXufku7+V4ygPzfhqsvx8fnEdVWnBwcs1m/lLv34MtTU0Tapbv4p9//0rfntdyDaSTr2AtIuuR9F3fDOetnjsKls+q2Xr/Hrqio+8lqwl0cZt5MR+SIypgC2Vd3LW3NMxHIX7riQPIkCSB9EZJOaRReIdeQ4n5pqmcdu7oZ1wb55m5ME5of0f2qOgTOWa15wUlKkomkayy0+mw0+mw8dInUpKnQ9PfcsZharTWDPTxZoTnZycmsg16en0szR/TJqmUbX4c0reeAbNd0g/CUUh9dyrSD7zUpQmn4t6oJ/DobUW3a2fQ0sOxjs1M4eXV/p58HM36iFPecnRCv+7wsqEPq0/uLtq/Cx/rILC5aEjWakm+GGWgw2T3bhtjTswKAp3ZWVxSUoKiqLg2V/MnicewrW7IGQbtiEjybn9AQxxCUdyymFz1/nZ9HEdmz6uxVN3mFlrGCyGInJiPiLBsi6wzOHNIuP5Z8iOjerw/UnyIAIkeRCdQWIeWSTekedwY17v1jjpCTs7K4IfEV67ysrsoW33GWjOV5t83PGuk7pDuiPoFPj9KWZumd7QFqa+1NfQ3Gmbh7UbanHu9BNdq6M0x8fSs+1MGh3PNWlp5LSQNBzKuSOfPU/+GW95ach70SMnknXzfRhi4gDY99w/qF72dVCZ7tzP4VCHxnvJNh83vemk5pCBsUx6+Mc5Fi4a3/roP5qmkT+3jlXPVuH3hD4ueo0am8e7+Xmqi+qUxgfyKbGxPNSnDwlGI6rHTfErT1C99KuQ9Q0JSeTc/kdsg485ktNulavaz8YPa9n8aS1ex9F75DXqqsiK+YwU6zIUJXQ/+kvuYshpZ3T4fiV5EAGSPIjOIDGPLBLvyHMkMf9ln5/Tn3EEjeCTYIOFd0WRGRf+tlRV47FFHh5dFNoRN8EGz15iZfqg5hMSVdP4tKKCRRXV9LeZuTg1lUxz+yfb8tXXsu+5f1C/bmXIe8akFLJv/yPuokKKXvhn0Hs9oZ9DU83Fe3uZylWvOtheHvq4d9NUIw+cZkbfSkdqDgzP++0jZVTvamZWugN2DvWwbpqLfQN8oECy0cjDffsyMSamoRbom3mUvP50SC2QojeQdtnNJJ54VocO5+qo8LHhg1ry59bhc4X/qKspGj4D+IwaPtMhr43gN2h4TRp+I/gMGiaDi7F1C8irWIxebf7z0cWlkXnVrcRNaN+IX+GQ5EEESPIgOoPEPLJIvCPPkcb85RUefvdpcFXBxL56PrzBikHf9oNerUvj9necLNgS2nZ+eEbDRGbhdsQ+UpqqUj7vXfa//zKHznKn6A2g0wXNU9BT+jk01VK8a5waN7/t5NutoXE4frCeZy+1EmtpPZ4+t8qPz1Wx5bPQPgxNlWf4WDfNxdbRHjQDXJOWxo2ZmRgVBcf2Lex98iG8FWUh68VNOZHMa+5mU4WRd1Z72V2pokDDXBJKQw2V0jB1xIHloBz81+Rns91P6jo7iVuc6FrppL99uIf1U13YY9WG5MDYkCT4DQSGCQZAgziMDIw2k2sxk2U+8E9RiFv+NfVz3262XweAPiaOlLMuJ2HWHHTGo5OASvIgAiR5EJ1BYh5ZJN6R50hjrmka17/h4ouNwf0f7jrexP0nt14DkF/q59rXnexo5hvvc0cb+Oe5rY/8c7TYN69j79OP4KuparVcT+nn0FRr8fb5NR6e7+b5ZaHfjg9I0fHaVdagGcVbUrbFzcYPa9m1xN7qTOP2aJUNx7rYcKybQWkNc0Jkms34aqvZ+8wj2Df+FLJOSVRf7o2+lyJDRrinHJDg9jOj2MnYCjeGFp5sNUVj20gPa2a5qMhozCxUjw5fvRG/3Yiv3ghOIxNSLFw2wsbsvhaMTT5LTVWpWbGY/R+83GxTOADFZCHp1PNInnMhemvH93NoSpIHESDJg+gMEvPIIvGOPB0R8xqnxuwn7OypanxcUBR4+1orM1pobjRvg5e73nNhP6Slkl4HfzzNzA1TjF0647C3uoK9Tz+CY8vPzb7fk/o5NBVOvN/+0ct9n7hCJjaLs8Bzl7Uc00PV7/ex+dNats6rb7WTu8+gkT/GzbYZXu6YlM2JCQlofj/7P3iZ8s/fCd2uYuNvCXez0johrONIdjUkDaMr3LTUBVzVaeSP8bDmeCfVqQ3H6im3ULcpEU+FBc3bsGZGrMIVk4xcNtFIakzw56dpGvZfVlP67ou4Crc3vyOdjoSZp5FyzhUY45PCOv4jJcmDCJDkQXQGiXlkkXhHno6K+dpCP2c968DX5BkxOVph0V22oIcsv6rxjwUenvgmtH9DYpTCC5daOG7A4XW47mgtPcD2tH4OTYUb7x92+bjudRcV9uBHQL0OHppj5trjwk/uvE6Vgq/r2fhRLXX7QoeHbapwkJeoOSbOOy6Td35UyV/0HbeWPEGU5gwp+0bMBbwRcwE+pflO3WlOHzOLnYyo9NDSmfr1GlvGuVlzvIvapANJQ5WZul+ScJfYAu2Tjuuv55pjjZw8zICxmeZ4zh35lL77IvZNobUlB8WMn0rahddhzshp9TPoaJI8iABJHkRnkJhHFol35OnImD/7nYeHvgju/zB1gJ53rrOi1ylUOzRufcfJN820qx+Z1dC/oa35BbpC3doV7HvxX/jrajCmZtD3vr9jSu05/Ryaak+891Q1DJvb3EzJl0008pczze2a10NTNfb84GTjh7WUrHO1WrYySWVZspU1tihS1SL+VPl3+vn2hJTz683UpA6hKu0YKtOGU52ch1amx7qiDvPW0FnED/IZNDZNdLN2pov6+Ibzi/KYGVCTQrIjBjQFVYPUGIWzRxnIS2u+zsJTWkTp+/+j9odvW9yXbfBw0i6+EdugYa2e89EiyYMIkORBdAaJeWSReEeejoy5qmpc9ZqThYd0fr53tolTjjFw7etOdlWEPlJcONbA386xYDV2XTOltqgeN+6iQswZOejMRzaXRVdqb7ztbo073wvt0wIwuZ+eFy6zkBzd/t+bigI3mz6qZftiO1orlREOE/yQaGFdCtxof5bjncta3a6GnnpPX+o8g6jzDKbeMxC/Zgu87zVqbDjWxU/TXThiG34Xc8xmbsrI4KSEBPRh1qb4aqoo+/QNKhd/Dv7me12bs/qSdtH1RI+e1KVN8CR5EAGSPIjOIDGPLBLvyNPRMa+wq8x+3EFxbeOjg04BswGch/TDNejgz2eYuXpy1/ZviCSHE29V1Xh0kYfHmhlKNydB4ZUrrQzLaP9M0A6PxntLXKz5oJa8PU6iQjffeAw6iBtvZeLQb6lb9L8WH9gPpWkKDl82Nf7B/Ny/LwtmZVOW0tBBOd1k4sb0dOYkJWEI8/fP73JSMf8DKr54D9UV2pQKwJCYQup5VxE/dTaKrvNnyD5UVyQP3aPhoRBCCCG6vaQoHc9cYuH8F5z4D7R2UbXQxCE5WuGFyyxM7iePGd2dTqdwz2wzeWk67nrfhatJLPdUaZzxXwdPX2ThlGNan1DuoNJalZdXeHntBw9VjobJPAxxVsba7UyrcJJUHprU6FSoW+Vk0apJ5A5NI9P0Hur+th9+FUUjyriHKOMeMovglDegNDEV4+DhDB05ntj0lLASB83no+rbLyj75PUWR+HS2aJIOeNSEk86G52p/XON9CZyVQshhBAibJP7Gbhntom/fdX8V8ljc3S8eLmVjHZMJCe63pkjjfRN0nHNa06KahprlhweuOZ1F/efrHLnTFOLtUgbivw8v8zDJ+t9ISM5+XQKq2KiWRVrZcLkSsZu89Env/kO6YWb+1LIvRiUeqJN24gxbSPGtJUoYyGK0srYsAekVe6HlYspXbmYUsCYlIptyEhseSOIGjISU3p24Bw0TaP2x6Xsf/8lPCX7mt2eYjSSOPtsks+4BEN0bJv7jwSSPAghhBCiXe6YYeL7HX6+2xb8lHjpBCN/OcuMuR0dbUX3MTJLz/zbbVz7upM1hcEP6n/7ykN+icqj5zf2X1FVjcVb/Ty31MOy7a03NRqaruOmqRbOHh3HD/Za/r2ykP7fGRmyxozBF/r74tOiqXaPodo9BgCd4sIQtw1nv80k6rbRr3QPJn/rozsBeCv2U7N8ITXLFwKgj40nKm8E1gFDqF21FOeOLc2vqCjET5lNynlXYUpOa3M/kUSSByGEEEK0i06n8NSFFi580cmWUhWLoaF/wxWTet7wpiJYaoyOD26wce/HLt5fG/xw/vF6HzsqHDxzsZWlBT5eWO5le1nrtQEn5Om5caqJaQP1gW/8p8fFMeT4PP7QbxevnFLNMSvNjPzeQlRd87VVdfF+1sz0s3lCFn5jFnAisaqfG9z1TN+/F/+2jTi2bWyxn0JT/tpqan9cSu2PS1ssEz1qImkXXo8lt3+b24tEkjwIIYQQot1SYnR8cbuNjUUq/ZN1JEZJbUNvYTEqPH6BhaHpXh6e70ZrMrTO+r0qU/5lb319A5w/1sgNU40MTm2+U3GqycR/Bw3i5ZgSno8q5qcZLgatNzFqqYXUoobH05pEP2uOd7FlnBv1wBOrWVG4ODWVK9LSSDA0PsZqfj+u3QXY83/BseVnHFt/wV9f167ztvbPI+3iG4gaOrpd60UaSR6EEEIIcVisRoXxfbp+xBnR8RRF4ZbpJgal6rjlbSf1LU+rEJAcrXDNsUaunGQMa4hXvaJwfUYG42Ni+P2uXeSP85A/1kNSsR6jR6E0x4d24NfLqCicl5zMNenpJBtDO28rej3W/nlY++fBqeejqSruokIcW35uSCjyf8ZXVdHscZjSs0i94DpiJ0yTkcHCIMmDEEIIIYRo1olDDHx+q42rX2t+Hg8O9Ge4caqJs0cZsBzGfB6jo6N5e8gQHi4sZHF1NRWZjf0n9MBZyclcl55Oejtm/VZ0OizZfbFk9yXxxDPRNA1vWTH2LQ2JhKNgM4pOR+IJZ5Awcw6KQR6JwyWflBBCCCGEaFFemp55t0Zx01vOoI7Rs/L03HRIf4bDFWsw8I9+/fiovJzniouxqyonxMdzQ0YGOeYjHxpVURRMqZmYUjNJmH7yEW8vkknyIIQQQgghWpUYpfD2tVbmb/RRXKsxY5CevLSObbKmKArnpaRwVnIyyoFmTaL7keRBCCGEEEK0yaBXOGNkeJPFHdF+JGno1mQGFyGEEEIIIURYJHkQQgghhBBChEWSByGEEEIIIURYJHkQQgghhBBChEWSByGEEEIIIURYeuVoS8UlpaxctYbNW7ZSXVOD2+0hJjqKjIx0xo4ewcTxY9HrO2Z4sc7clxBCCCGEEF2p1yUP879ayPyvF+P3+4OWV1XXUFVdw6bN+XyzZDnXX3M5qSnJPWZfQgghhBBCdLVelTx8uWAxn89fAIDFYmbGtOPIGzQQi8VCeUUF36/8kS3529hXVMxTz77EPXffRkxMdLfflxBCCCGEEN1Br0keSkvLmHfgYT4qysZv7rqVtNSUwPt9crMZN2YUH348l8VLllFRUcknc+dzxaUXdOt9CSGEEEII0V30mg7TXy5YjKqqAJxz5pygh/mmzj7zNFKSkwBYtXot5RWV3XpfQgghhBBCdBe9Innw+Xz8vGEjAFarlfHjRrdYVq/Xc9zkCQCoqsq69b90230JIYQQQgjRnfSK5GHHzt24XG4ABvTrg9HQemuswYMGBl5v3JzfbfclhBBCCCFEd9Irkoei4pLA6+zszDbLZ2dloChKw7pFJW2W76p9CSGEEEII0Z30iuShdH9Z4HViQnyb5Q0GQ2Dko3q7nXq7vVvuSwghhBBCiO6kV4y2VF/f+EAeHR3ecKgx0dHU1tYF1o+OiupW+zrYIbszHdxnV+xbdA2JeWSReEceiXlkkXhHnq6Iea9IHtweT+B1W30QDjI0Ked2e1ot2xX7Kt1XGPYxdbSy4r1dtm/RNSTmkUXiHXkk5pFF4h15OjPmvSJ58Hq9gdeGw3ig9/q8rZbtin2lZeWGfUwdRVVVyor3kpKRjU7XK1q0iTZIzCOLxDvySMwji8Q78rQU87qCgqO2z16RPBiNxsBrr88X1jq+JuVMTdbvLvvqyotep9PJTSfCSMwji8Q78kjMI4vEO/J0Zsx7RfJgNpkCr5vWDLSmaTmz2dzt9rV169awj6mjHc1sVXRPEvPIIvGOPBLzyCLxjjydGfNekZYeHM0IoK6uPqx1amprA69jY8Lr+NzZ+xJCCCGEEKI76RXJQ3paauB1ZWVVm+Xdbg92uwOAuLhYrFZrt9yXEEIIIYQQ3UmvSB6ysxonayvcu6/N8rsL9wRe52S1PdFbV+1LCCGEEEKI7qRXJA99++QQHd0wd8KOnbtxud2tlt+0OT/weuSIYd12X0IIIYQQQnQnvSJ50Ol0jB09EgCPx8PKVWtaLOtyuQPvm0wmRo0Y3m33JYQQQgghRHfSK5IHgJNnzwoMozp33pfsKyoOKaOqKm+/9xF19Q0dnWfNnBqoRWjqtrvvC/yrqKg8qvsSQgghhBCip+gVQ7UCxMfFcuF5Z/HmOx/gcrl59PFnmDFtCkPzBmE2myjdX8Z3S1ewc3fDzM39+uRy8omzuv2+hBBCCCGE6C56TfIAcNzkCfh8Pj76dB5ut4evF37D1wu/CSk3NG8QV19xCSZT+JPDdeW+hBBCCCGE6A56VfIAMH3qsQwdMpjlK1axaXM+VdXVeL1eYmNiyM3JZsK4MYwaeUyP25cQQgghhBBdTcnPz9e6+iBE1ykuKWXlqjVs3rKV6poa3G4PMdFRZGSkM3b0CCaOH4ter+/qwxRHqGD7Tv795LPtWic5OYmH/nDvUTsm0XF27NzFq2+8S/mBPlqXX3IBx04aH/b6ch/oeQ4n5nIf6HkKduzkh1Vr2LFzN9XVNXh9PqwWC6mpKeQNGsCUYyeSkBDf5nbkGu85jiTmnXWN97qaBxG++V8tZP7Xi/H7/UHLq6prqKquYdPmfL5Zspzrr7mc1JTkLjtOceScTmdXH4I4Cvx+P/O+XMCCRUtQVfWwtiH3gZ7lSGIu94Gew+ly8cZb77Pu5w0h79Xb7dTvtLNj5y4WfrOE884+g2lTJre4LbnGe4aOiHlnXeOSPESoLxcs5vP5CwCwWMzMmHYceYMGYrFYKK+o4PuVP7Ilfxv7iop56tmXuOfu24iJie7qwxaHyeF0BV7PnjWDiRPGtrmOwSC3h+6spKSUV954lz0HJqvU6XTtfpiU+0DPcqQxl/tAz+D1+XjymRfYXbgXgNjYGGZOm8KAAX0xm0xUVFSxavVa1v+yEa/Xxzvvf4zZbGbi+DEh25JrvGfoqJh31jUud4UIVFpaxrwDN5OoKBu/uetW0lJTAu/3yc1m3JhRfPjxXBYvWUZFRSWfzJ3PFZde0IVHLY6Ew9H4bURqajKZGeldejziyCxdvpIPP5mL1+tDp9Nx6kknsL+8nB9X/xT2NuQ+0LN0RMzlPtAzfLVgceAhMikxgXt+fTsx0Y0P9DnZWYweNZwvv17M3C++AuCjTz9nzOgRGJs8CMo13nN0VMw76xrvNfM8iPB9uWBx4Nuqc86cE3QzaersM08jJTkJgFWr1wba1oqep2lVptVq7dJjEUduydLv8Xp9JCUm8Ks7bua0U05Ep7Tvdi73gZ6lI2Iu94HuT1VVli5bGfj5yssuCnqIbOqkE2eSlJgAQF1dPQXbdwS9L9d4z9CRMe+sa1yShwjj8/n4ecNGOPCLNX7c6BbL6vV6jps8AQ78cq9b/0unHafoWA55aOh1xo8dzW/vuYv+/fq0e125D/RMRxJz5D7QI1RUVqHT69DpdMRERzOgf98Wy+p0Ovo3eb+kpCzwWq7xnqOjYk4nXuPSbCnC7Ni5G5fLDcCAfn2CqruaM3jQwMDrjZvzOXHWjKN+jKLjBX0bYbF06bGII3fBuWeSN3hgGCWbJ/eBnudIY47cB3qElOQk/vrnP6CqKm63G0VRWi2v1zWOkOT1egOv5RrvOToq5nTiNS41DxGmqLgk8Do7O7PN8tlZGYFf5KKikjbLi+6paTtIq1UeGnq6I32IlPtAz3OkMUfuAz2KTqcL65vjsvLywOvExMbhO+Ua73mONOZ04jUuNQ8RpnR/YxVXYhhjQxsMBmJioqmtrWsYKsxuJzoq6igfpehoziYjMOj1er5btoL1v2xkX1ExDocTo9FAQnw8gwb2Z9qUydKRspeT+0BkkvtA77K/rJwdO3fDgXgOzRsceE+u8d6ptZjTide4JA8Rpr7eHngd3UKHnEPFRDfcUA6uLzeUnqdpO8h//vsp6urqg973+/0Ul5RSXFLK0uUrmTVzKmefcRo6nVRO9kZyH4hMch/oPTRN4533P0bTGub5nXLsRKKibIH35RrvfdqKOZ14jUvyEGHcHk/gdVttIA9qOgaw2+1ptazonpreUOrq6umTm8PkiePIzsrAYDBQVl7BmrXrWf/LRjRNY9E3S3G7PVxy4bldetzi6JD7QGSS+0Dv8cHHc8nfWgBAYkICp596UtD7co33Pm3FnE68xiV5iDBNO9eEOzFI03Jen7fVsqJ7Mh6oktYpCifNnsXMaccFvZ+b0zDe96rVP/Ham++iaRrLvv+BkcOHccywIV123OLokPtAZJL7QM+naRoffDyXb79bDoDFbObG664M+QZarvHeI9yY04nXuCQPEcZoNAZee32+sNbxNSlnarK+6Dke/P09YZWbOH4MhYV7+ObATWrhN9/JQ0MvJPeByCT3gZ7N7fbw6pvvsP7nhiFYbTYrt9xwDTnNdIiWa7x3aE/M6cRrXBoyRhizyRR4fegQXy1pWs5sNh+V4xLdx8zpUwKvt+/Yhccj1de9jdwHRFvkPtC9VFfX8O8n/xt4iExIiOdXd9zc4pwfco33fO2NeXsdyTUuNQ8RJiamsePUoR1pWlJTWxt4HRsTXscr0XMlJydhtVpxOp34/X6qa2pJTUnu6sMSHUjuA6Itch/oPvbs3cezL7xCdU3DNdi3Tw43XncVcbExLa4j13jPdjgxb68jucYleYgw6WmpgdeVlVVtlne7PdjtDgDi4mJlVtIIYTIZA5PN+MKs8hY9h9wHRDjkPtD1tm7bzn9feCXwrfCE8WO47OLz2+wELdd4z3W4MT8ch3uNS/IQYbKzGtvJFe7d12b53YV7Aq9zstqeaEb0fKqqBv6IAETJcH29jtwHRFvkPtD1Crbv5JnnXw40JzrtlBOZc8rssNaVa7xnOpKYt9eRXOOSPESYvn1yiI6Oor7e3jB9vduNpZW2jZs25wdejxwxrJOOUnSkbdt3kJ9fQGVVFcOG5jF+7OhWy+8u3Bv4BiI2NqZDq0lF9yD3gcgj94GepbS0jOdeehWv14uiKFx8wTlMPW5S2OvLNd7zHGnMO/Malw7TEUan0zF29EgAPB4PK1etabGsy+UOvG8ymRg1YninHafoOGVl5cz/ehE//LiW+V8vQlXVVst/s2RZ4PWIY4Z2whGKzib3gcgj94Gew+fz8dKrb+JwNDQnueDcM9v1EIlc4z1OR8S8M69xSR4i0MmzZwWGcZs770v2FRWHlFFVlbff+4i6+oaOVrNmTiU6Wqqte6JxY0YHZgotKdnP+x991mLZJUu/Z81P6+HAmN8nnTCz045TdC65D0QWuQ/0HF8t/CZwPU6aMI4Zh4zVHy65xnuOjoh5Z17j0mwpAsXHxXLheWfx5jsf4HK5efTxZ5gxbQpD8wZhNpso3V/Gd0tXsHN3IQD9+uRy8omzuvqwxWEym01cetF5vPDy62iaxnfLVrBzVyHTpkwiNSUFk8lEWVk5q9b8xMZNWwLrXXrhuSQnJ3XpsYtQdXX1gT/0TTmbzCxaU1NLUXFJ0Pt6vZ601JTAz3If6Dk6IuZyH+gZ7HYHi79ZCgfiN3niuJC4tkSu8Z6po2Lemde4kp+fr7VrDdFrfLdsBR99Oq/VMaCH5g3i6isukW8ieoF16zfw1nsfBnWQao7NZuWyi85n9Cipuu6O5s1fwBdfLWz3eokJCTz84P0hy+U+0P11ZMzlPtC9/fDjWl57893DWleu8Z6po2PeGde41DxEsOlTj2XokMEsX7GKTZvzqaquxuv1EhsTQ25ONhPGjWHUyGO6+jBFBxk9ajiDBw3ghx/XsHHTFopKSrHbHSgK2Gw2sjIzGDYkj2MnjcdikQmCIoXcByKL3Ae6t7baqR8Ouca7t46OeWdc41LzIIQQQgghhAiLdJgWQgghhBBChEWSByGEEEIIIURYJHkQQgghhBBChEWSByGEEEIIIURYJHkQQgghhBBChEWSByGEEEIIIURYJHkQQgghhBBChEWSByGEEEIIIURYJHkQQgghhBBChEWSByGEEEIIIURYJHkQQgghhBBChEWSByGEEEIIIURYDF19AEIIIVr3nyefY9v2HQD8+YH7SEpK7OpD6hQPPPQ3Kquq0Ol0PPnYX7v6cKDJMQE8/Z+/H/Z2Vvywmjfefh+A004+kTmnzu6wYxRCiKNJah6EEEIIIYQQYZGaByGEEO32ydz5LFj0bcR9a56cnIjRKH86hRCRS+6AQggh2m134Z6uPoQucddtN3b1IQghRJeSZktCCCHaRdM0Cvfs7erDEEII0QUkeRBCCNEupaX7cbncXX0YQgghuoA0WxJCiB5o/S8bWfHDavbu3UddXT1mi5n0tFTGjh7JtCmT0ev1La67Y+duVq1ey85dhVRUVOL2eDAaDcTFxtK3Ty7HThrP4EEDQtabN38BX3y1MGjZF18tDCwbNKA/d99xU8h6+4qKWb5iFfnbCqiprsXr9RIdHUXfPrlMmjiOkcOHhX3eW7dt57vlKygs3EtNbR0Gg5601BRGjRjOjOnHYTGbw97W4QhntCWX2803S5ax/ueNlJdX4Ff9xMbGMrB/P6ZPnUyf3JwWt7+tYAePP/08mqYRGxvDA/f/BpvN2mxZj8fL//v7Y1RUVAJw7ZWXMm7sqA45TyGEaIkkD0II0YNowOtvvcfKVWuClvvsDrbv2MX2HbtYuWo1d956AzabLaiM3+/nrXc/DFkXwO32sL+snP1l5axavZbJE8dx2cXno9MdWQX1p59/yYJF36JpWtDy6ppa1v28gXU/b2DYkMFce/VlWC2WVrf1+RdfM//rRcHn7fOxu3Avuwv3snrtOn59581Yrc0/bHeGsvIKHn/6eaqqqoOWl5dXUF5ewarVaznv7NMxt5DkDBrYn+OnT2HxkmXU1tbx6efzueTCc5stO/+rhYHEYezokZI4CCE6hSQPQgjRg3y7ZBkrV61h4IB+TDl2ImmpKfh8frZt38GCRd/icrnZs7eIV994l1tuvCZo3U8/nx9IHKwWCyfMms6Afn2x2ay4XG4Kduxk4aIlOF0uVq5aQ2JiAnNOaRxJafrUYxkzegQ//7KJuV98BcC0KZOZPvVYAEwmU/D+5s7n60XfAhAfH8eJx0+nT242AEXFpSxYvITy8go2bdnKcy++yp233tBisvL9ylXM/3oRo0Ycw8QJY0lMSMDlcrF123YWfrMEr9dHUXEJ8+Yv4Pxzz+zQzzxcfr+f/z7/ciBxSE5OYvasGWRnZaKqfvYVlfDtd8v54OO5TJowtsXtnHn6KWzcnE/p/jKWr1jFpAlj6d+vb1CZouISFn27FIDY2BguvuCco3x2QgjRQJIHIYToQb5d+j1Tj5vMxRecjaIogeUD+vflmKFDePTxp/F6fWzYtIUdO3cFHjrtdgdLvvs+UP7G664MaZo0cEA/8gYN5F//eRqARd98x0knzMRoNAIQExNNTEw0uwsbO0vHREeTmZEecpy7C/eyYPESAJKTErnnV7cTHR0VeL9/v76MHzuavz/6BPvLytlWsIMf16xr9qFa0zQ++Hgu5519OrNmTgt6b/CgAaSnpfLy628DsGrNT12WPCxfsYrS/WVwIHG479d3BDU56t+vL5MnjeeZ5/7XbO3PQUajkasuv4h//ecZVFXlrXc/4rf33BVoiqZpGm+/9zF+vx+Ayy4+n6goW4vbE0KIjiQdpoUQogeJjo7ivLPnBCUOB+VkZzJpwrjAz6vXrg+8djqdTJ0ymfFjRzNh/Jhm+zQA9OubS25OQ+2A2+1h12EOyfrNd8sCTZXmnHpSUOJwkMVi5tSTTwj8vOKHH5vdlqZp9O/bJyRxOGjsmJGBWg+73UFFZdVhHfOR+nHNT4HXc045sdm+CkaDgcsuOq/Z+DXVJzeHk088HoDiktJAIsaBJGXHzl0ATDl2IsOHDenAsxBCiNZJzYMQQvQgY0aNCGke1NSI4cNY9v0PABRs3xlYnpycxAVhfiOfkpwUGIq1pqa23ceoqio//7IRAJ1Ox4jhQ1ssO3L4Mdxw7RVER0URGxvTYrmpx01u8T2dTkdKchL7iooBqK+vJykxod3HfSQ8Hg87dxUCoCgKw4e1fM7JyUn079eH7Tt2tbrNU08+gQ2bNrNnbxFffr2IcWNGYTGb+fTz+QAkJSVy7tmnd/CZCCFE6yR5EEKIHqRvn9xW389q0oRof1kZmqa1+C23y+XG7nDg8XiCOjR7vd4mr33tPsbS/WW43R4AEhMTWu0IbbGYGT1yeJvbzMnJavV9i6WxA7LH42217NFQUloW+AwTExNaHCHpoD452W0mD3q9nisvu4i/P/okXq+Pd977iJiYGBwOJ4qicMWlFxz10aWEEOJQkjwIIUQPkpyU2Or7cXGxgdderw+XyxU0+tDuwr0sXb6CLfnbqKquOSrHWNmk2VB8k+M5Em09jOuUxla4h47s1Blqaho/y/i4uDbLJ4ZZM5KZkc7pp87mk7nz2bK1ILD8+BlTGTSg/2EerRBCHD5JHoQQogdp+g17c3Q6HQaDAZ+vocbA7fEGkocvv17M5/O/PuoP106XK/DadKCz9ZFqq49AVztY0wJgMrV9zq01PTvUCcdPZ/Xa9ezdVwQHRq46c87Jh3mkQghxZCR5EEKIHiSsh+gmycHB8ut/2RgYXpUD8wnMnDaFPrnZ2Gw2zObGh9nX3nyPH35seTSgtvff9FA6vxagK6hNP/Nwyqtq2NsuK6sIjOLEgX4oO3cVttjpXQghjiYZbUkIIXqQpt9wN8fv9+M7MIQnEEgKFiz8NrBs7OiR3HXbjYweNZyEhPigxAHAr/o5ElZrYx8Hl9t9RNvqKcxNahI83rb7XIT7uaiqymtvvYvX68VoNGC1WtE0jdfeei+ohkcIITqLJA9CCNGDVFa1PgxpdZN+DBaLGYvZjNfrDRpydc6ps1utwag8wqFOm7bnLz8wA3JvFxMTHXhdHcYIVeXl4X0uCxYtYdfuhtiddvKJnHvWHACqqqr54KO5h328QghxuCR5EEKIHmR3G/Mu7CsuCbxOT0sFwO5wBpoP6XQ6UlOSW1y/qqo68LB6uNJSUwJt+uvq6ltNIPx+P5/Onc8nc+fz+fyvj2i/XSk9LSXwurKyqs2ahZ27dre5zaLiEr74cgEA2VmZnHD8dI6bPCHQXGnlqtX8smHTkR66EEK0iyQPQgjRg6xd90ugM3Rz1v+8MfA6b/BAAMxNOvCqqorb03LTp08+nx/UHl9towlTc233dTodI0cMC/z84+q1La5fsH0nXy/6lgWLvmVL/rZW99Wd2Wy2wEzbqqqyaXN+i2X37C0KzEnREr/fz2tvvovP70en03HZxecHZpi+9KLzArN+v/nuh9TX2zv0XIQQojWSPAghRA9SVVXN3C+a/4a+cM9eVh+Y5VhRFMaPHQ2A1WolMaGxKdHan34OWVdVVT6dO5/Va9YFDQFaWVkdUtbWZOjX/WXlzR7LzGlTAk2jFi7+jqImNSIHeb1ePpk7P/DzsZMmtHDWPcO4MaMCr+fNX4DLFVr74HZ7ePu9D9vs+D7/60Xs2dswutIJM6eR22Sei5TkJOacciIcqNl55/2PO/AshBCidTLakhBCdHNNR/KZMe04Fi5ewr59RUyeNJ6U5GR8Ph9btxWwcPF3gc7SkyeOC3wTDjB50ji++HIhAO9/9Bm1tbUMGjQATdMoKiph+YpV7CsqZsqxE+nXtw/btu8A4PsffqRf31xsNhv9+/UBIDm5ca6J9b9s5NPPvyQ9NYXK6mpOPekEAPr1zeX4GVNZ/O1SXG43j/7nGU44fjqDBw9Ap+goLilh0TdLA6MIDejfl2Mnje+Uz/NomTl9CkuWfU9tbR0lpfv5x2NPcuKsGWRlpuP3+yncW8Q3S5ZRUVHJzOlT+GbJsma3U7hnL18t+AYOJAqnnTI7pMysmdNY89N69uwt4qf1v/Djmp+YMG7MUT9HIYSQ5EEIIbo5TWtsGnTqySfgdLpYtXotm1to5pM3eCAXnnd20LKTTjyeLfnb2LFzN16vl8/nL4D5C4LKjB83movOP5u6entgroja2jr++8IrADz9n78DkJWZQf9+fdmxcxd+v5+vF37TeHwHkgeAc8+ag6LA4m+X4XK7mfflAuZ9GbxPgKF5g7ju6svQ6Xp2ZbjFYubm66/m6Wdfwu5wULq/jDff+SCojKIonHvWHNJSUwLJQ9OmX16fj9fefA9VVVEUhUsvOq/ZeSP0ej2XXnQ+//z3U6iqynsffsqggQM6bFI+IYRoiSQPQgjRzXk8jUN/2qxWrrr8IkYMH8oPq9awt6iY+rp6zBYzmRnpTBw/lskTx4U8iBsNBu689Qa+Xfo9a39aT0lpGZqmERcXS5+cLI6dPIGheYPhwKzQt9xwNZ9+Pp+S0v0YjUb69skN2t4N117OBx/NZWvBdpxOF9FRtqCaDgIPyqczcfxYlq9YxdZt26muqcHr9RETHUWf3BwmTRjHqJHHHNXPrzP1yc3mgd/9hkXfLGXjpi1UVFaiqhqxsTEM6NeXaVMm079fn6AO054mfVDmffE1xSWlAEGdo5uTm5PFrJnTWLh4CQ6Hkzfffp/bbr7uKJ+hECLSKfn5+ZExg48QQgghhBDiiPTsOmIhhBBCCCFEp5HkQQghhBBCCBEWSR6EEEIIIYQQYZEO00IIIXodv98fGAa2IyQlJmI2mzpse0II0VNJ8iCEEKLXqa6u4ZG//7vDtnfXbTe2OvKREEJECmm2JIQQQgghhAiLDNUqhBBCCCGECIvUPAghhBBCCCHCIsmDEEIIIYQQIiySPAghhBBCCCHCIsmDEEIIIYQQIiySPAghhBBCCCHCIsmDEEIIIYQQIiySPAghhBBCCCHCIsmDEEIIIYQQIiz/H5lMBhQ0XNb3AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the loss vs batch_idx\n", + "# each rank has a different line\n", + "fig = plt.figure(figsize=(8, 6))\n", + "font_size = 24\n", + "for rank_idx in rank_loss_dict:\n", + " x_list = []\n", + " y_list = []\n", + " num_accumulated = 0\n", + " for epoch_idx in rank_loss_dict[rank_idx]:\n", + " for batch_idx in rank_loss_dict[rank_idx]:\n", + " x_list.append(num_accumulated)\n", + " y_list.append(rank_loss_dict[rank_idx][epoch_idx][batch_idx])\n", + " num_accumulated += 1\n", + " print(f\"rank {rank_idx}: {x_list}, {y_list}\")\n", + " plt.plot(x_list, y_list, label=f\"rank {rank_idx}\", linewidth=3)\n", + "plt.xlabel(\"batch_idx\", fontsize=font_size)\n", + "plt.ylabel(\"loss\", fontsize=font_size)\n", + "# plt.title(\"loss vs batch_idx\", fontsize=font_size)\n", + "plt.xticks(fontsize=font_size)\n", + "plt.yticks(fontsize=font_size)\n", + "plt.legend(fontsize=font_size*0.7)\n", + "# save\n", + "fig_path = os.path.join(figure_folder, \"loss_vs_batch_idx.png\")\n", + "plt.tight_layout()\n", + "fig.savefig(fig_path)\n", + "plt.show()\n", + "plt.close()" + ] + } + ], + "metadata": { + "orig_nbformat": 4 + } +} diff --git a/torchrec/distributed/benchmark/benchmark_zch/plots/plot_zch_metrics.ipynb b/torchrec/distributed/benchmark/benchmark_zch/plots/plot_zch_metrics.ipynb new file mode 100644 index 000000000..740c4bb44 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/plots/plot_zch_metrics.ipynb @@ -0,0 +1,272 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import csv\n", + "import numpy as np\n", + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "output": { + "id": 1462143655128864, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " epoch_idx ... rank_total_cnt\n", + "0 0 ... {\"3\": 9170, \"1\": 757, \"2\": 2643, \"0\": 3814}\n", + "1 0 ... {\"3\": 5285, \"1\": 2972, \"2\": 2369, \"0\": 5758}\n", + "2 0 ... {\"3\": 4258, \"1\": 4099, \"2\": 3749, \"0\": 4278}\n", + "3 0 ... {\"3\": 3580, \"1\": 4208, \"2\": 4561, \"0\": 4035}\n", + "4 0 ... {\"3\": 11408, \"1\": 213, \"2\": 3514, \"0\": 1249}\n", + "\n", + "[5 rows x 11 columns]\n" + ] + } + ], + "source": [ + "zch_stats_file_folder = \"/home/lizhouyu/oss_github/torchrec/torchrec/distributed/benchmark/result_tbsize_1000_zch\"\n", + "zch_stats_file_path = os.path.join(zch_stats_file_folder, 'zch_metrics.csv')\n", + "df_zch_stats = pd.read_csv(zch_stats_file_path)\n", + "print(df_zch_stats.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot number of collisions" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "output": { + "id": 1105084011440388, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'t_cat_0': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 1, 16: 5, 17: 7, 18: 8, 19: 10, 20: 12, 21: 13, 22: 18, 23: 18, 24: 21, 25: 29, 26: 39, 27: 46, 28: 53, 29: 61, 30: 67, 31: 75, 32: 92, 33: 97, 34: 108, 35: 120, 36: 130, 37: 142, 38: 147, 39: 161, 40: 178, 41: 198, 42: 208, 43: 216, 44: 225, 45: 235, 46: 246, 47: 256, 48: 269, 49: 289, 50: 302, 51: 316, 52: 327, 53: 346, 54: 353, 55: 361, 56: 369, 57: 385, 58: 396, 59: 414, 60: 425, 61: 434, 62: 447, 63: 461, 64: 473, 65: 486, 66: 498, 67: 507, 68: 523, 69: 530, 70: 539, 71: 555, 72: 568, 73: 588, 74: 599, 75: 612, 76: 619, 77: 631, 78: 641, 79: 652, 80: 663, 81: 675, 82: 689, 83: 709, 84: 721, 85: 735, 86: 738, 87: 753, 88: 769, 89: 787, 90: 795, 91: 804, 92: 814, 93: 819, 94: 825, 95: 836, 96: 847, 97: 858, 98: 867, 99: 884, 100: 902, 101: 914, 102: 926, 103: 943, 104: 951, 105: 962, 106: 978, 107: 992, 108: 999, 109: 1010, 110: 1025, 111: 1040, 112: 1053, 113: 1066, 114: 1079, 115: 1087, 116: 1094, 117: 1106, 118: 1119, 119: 1134, 120: 1146, 121: 1156, 122: 1166, 123: 1177, 124: 1188, 125: 1197, 126: 1208, 127: 1226, 128: 1234, 129: 1245, 130: 1258, 131: 1266, 132: 1279, 133: 1295, 134: 1313, 135: 1325, 136: 1335, 137: 1344, 138: 1358, 139: 1374, 140: 1383, 141: 1400, 142: 1414, 143: 1427, 144: 1443, 145: 1453, 146: 1462, 147: 1474, 148: 1488, 149: 1500, 150: 1514, 151: 1522, 152: 1537, 153: 1554, 154: 1565, 155: 1579, 156: 1586, 157: 1602, 158: 1619, 159: 1643, 160: 1652, 161: 1658, 162: 1673, 163: 1684, 164: 1695, 165: 1712, 166: 1723, 167: 1733, 168: 1741, 169: 1755, 170: 1762, 171: 1779, 172: 1792, 173: 1802, 174: 1813, 175: 1831, 176: 1848, 177: 1858, 178: 1872, 179: 1886, 180: 1903, 181: 1916, 182: 1936, 183: 1949, 184: 1964, 185: 1975, 186: 1991, 187: 2006, 188: 2023, 189: 2042, 190: 2056, 191: 2071, 192: 2085, 193: 2092, 194: 2111, 195: 2131, 196: 2146, 197: 2163, 198: 2171, 199: 2178, 200: 2189, 201: 2204, 202: 2220, 203: 2236, 204: 2247, 205: 2263, 206: 2273, 207: 2285, 208: 2296, 209: 2304, 210: 2315, 211: 2324, 212: 2335, 213: 2352, 214: 2366, 215: 2377, 216: 2394, 217: 2399, 218: 2407, 219: 2424, 220: 2435, 221: 2450, 222: 2458, 223: 2468, 224: 2477, 225: 2491, 226: 2503, 227: 2510, 228: 2519, 229: 2534, 230: 2545, 231: 2558, 232: 2569, 233: 2580, 234: 2588, 235: 2602, 236: 2611, 237: 2629, 238: 2646, 239: 2663, 240: 2678, 241: 2695, 242: 2710, 243: 2722, 244: 2740, 245: 2759, 246: 2778, 247: 2793, 248: 2807, 249: 2820, 250: 2831, 251: 2841, 252: 2858, 253: 2871, 254: 2893, 255: 2907, 256: 2917, 257: 2929, 258: 2938, 259: 2951, 260: 2964, 261: 2976, 262: 2990, 263: 3004, 264: 3015, 265: 3037, 266: 3058, 267: 3070, 268: 3086, 269: 3105, 270: 3118, 271: 3126, 272: 3136, 273: 3150, 274: 3162, 275: 3173, 276: 3188, 277: 3201, 278: 3215, 279: 3222}, 't_cat_1': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 0, 16: 0, 17: 0, 18: 0, 19: 0, 20: 0, 21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0, 28: 0, 29: 0, 30: 0, 31: 0, 32: 0, 33: 0, 34: 0, 35: 0, 36: 0, 37: 0, 38: 0, 39: 0, 40: 0, 41: 0, 42: 0, 43: 0, 44: 0, 45: 0, 46: 0, 47: 0, 48: 0, 49: 0, 50: 0, 51: 0, 52: 0, 53: 0, 54: 0, 55: 0, 56: 0, 57: 0, 58: 0, 59: 0, 60: 0, 61: 0, 62: 0, 63: 0, 64: 0, 65: 0, 66: 0, 67: 0, 68: 0, 69: 0, 70: 0, 71: 0, 72: 0, 73: 0, 74: 0, 75: 0, 76: 0, 77: 0, 78: 0, 79: 0, 80: 0, 81: 0, 82: 0, 83: 0, 84: 0, 85: 0, 86: 0, 87: 0, 88: 0, 89: 0, 90: 0, 91: 0, 92: 0, 93: 0, 94: 0, 95: 0, 96: 0, 97: 0, 98: 0, 99: 0, 100: 0, 101: 0, 102: 0, 103: 0, 104: 0, 105: 0, 106: 0, 107: 0, 108: 0, 109: 0, 110: 0, 111: 0, 112: 0, 113: 0, 114: 0, 115: 0, 116: 0, 117: 0, 118: 0, 119: 0, 120: 0, 121: 0, 122: 0, 123: 0, 124: 0, 125: 0, 126: 0, 127: 0, 128: 0, 129: 0, 130: 0, 131: 0, 132: 0, 133: 0, 134: 0, 135: 0, 136: 0, 137: 0, 138: 0, 139: 0, 140: 0, 141: 0, 142: 0, 143: 0, 144: 0, 145: 0, 146: 0, 147: 0, 148: 0, 149: 0, 150: 0, 151: 0, 152: 0, 153: 0, 154: 0, 155: 0, 156: 0, 157: 0, 158: 0, 159: 0, 160: 0, 161: 0, 162: 0, 163: 0, 164: 0, 165: 0, 166: 0, 167: 0, 168: 0, 169: 0, 170: 0, 171: 0, 172: 0, 173: 0, 174: 0, 175: 0, 176: 0, 177: 0, 178: 0, 179: 0, 180: 0, 181: 0, 182: 0, 183: 0, 184: 0, 185: 0, 186: 0, 187: 0, 188: 0, 189: 0, 190: 0, 191: 0, 192: 0, 193: 0, 194: 0, 195: 0, 196: 0, 197: 0, 198: 0, 199: 0, 200: 0, 201: 0, 202: 0, 203: 0, 204: 0, 205: 0, 206: 0, 207: 0, 208: 0, 209: 0, 210: 0, 211: 0, 212: 0, 213: 0, 214: 0, 215: 0, 216: 0, 217: 0, 218: 0, 219: 0, 220: 0, 221: 0, 222: 0, 223: 0, 224: 0, 225: 0, 226: 0, 227: 0, 228: 0, 229: 0, 230: 0, 231: 0, 232: 0, 233: 0, 234: 0, 235: 0, 236: 0, 237: 0, 238: 0, 239: 0, 240: 0, 241: 0, 242: 0, 243: 0, 244: 0, 245: 0, 246: 0, 247: 0, 248: 0, 249: 0, 250: 0, 251: 0, 252: 0, 253: 0, 254: 0, 255: 0, 256: 0, 257: 0, 258: 0, 259: 0, 260: 0, 261: 0, 262: 0, 263: 0, 264: 0, 265: 0, 266: 0, 267: 0, 268: 0, 269: 0, 270: 0, 271: 0, 272: 0, 273: 0, 274: 0, 275: 0, 276: 0, 277: 0, 278: 0, 279: 0}, 't_cat_2': {0: 0, 1: 11615, 2: 23122, 3: 34700, 4: 46182, 5: 57742, 6: 69270, 7: 80874, 8: 92450, 9: 104059, 10: 115769, 11: 127427, 12: 139045, 13: 150712, 14: 162301, 15: 173888, 16: 185373, 17: 196947, 18: 208551, 19: 220164, 20: 231834, 21: 243443, 22: 255006, 23: 266570, 24: 278216, 25: 289859, 26: 301398, 27: 313042, 28: 324701, 29: 336260, 30: 347773, 31: 359363, 32: 370917, 33: 382539, 34: 394133, 35: 405749, 36: 417314, 37: 428908, 38: 440529, 39: 452197, 40: 463727, 41: 475327, 42: 486823, 43: 498551, 44: 510120, 45: 521713, 46: 533320, 47: 544915, 48: 556460, 49: 568031, 50: 579488, 51: 591033, 52: 602656, 53: 614189, 54: 625791, 55: 637389, 56: 648893, 57: 660418, 58: 671994, 59: 683628, 60: 695303, 61: 706960, 62: 718551, 63: 730220, 64: 741733, 65: 753324, 66: 764800, 67: 776417, 68: 788107, 69: 799622, 70: 811200, 71: 822812, 72: 834441, 73: 846073, 74: 857552, 75: 869194, 76: 880744, 77: 892250, 78: 903898, 79: 915454, 80: 927100, 81: 938645, 82: 950298, 83: 961941, 84: 973539, 85: 985082, 86: 996630, 87: 1008211, 88: 1019724, 89: 1031274, 90: 1042732, 91: 1054342, 92: 1065807, 93: 1077330, 94: 1088885, 95: 1100469, 96: 1112017, 97: 1123613, 98: 1135168, 99: 1146765, 100: 1158279, 101: 1169891, 102: 1181476, 103: 1193037, 104: 1204679, 105: 1216342, 106: 1227966, 107: 1239684, 108: 1251373, 109: 1262999, 110: 1274511, 111: 1286039, 112: 1297546, 113: 1309126, 114: 1320722, 115: 1332238, 116: 1343828, 117: 1355410, 118: 1367029, 119: 1378655, 120: 1390280, 121: 1401955, 122: 1413550, 123: 1425208, 124: 1436877, 125: 1448473, 126: 1459939, 127: 1471491, 128: 1483106, 129: 1494605, 130: 1506304, 131: 1517841, 132: 1529582, 133: 1541275, 134: 1552920, 135: 1564417, 136: 1575989, 137: 1587517, 138: 1599190, 139: 1610751, 140: 1622275, 141: 1633921, 142: 1645541, 143: 1657102, 144: 1668642, 145: 1680254, 146: 1691851, 147: 1703431, 148: 1715018, 149: 1726549, 150: 1738187, 151: 1749775, 152: 1761388, 153: 1773077, 154: 1784704, 155: 1796227, 156: 1807875, 157: 1819421, 158: 1831054, 159: 1842635, 160: 1854281, 161: 1865871, 162: 1877440, 163: 1889072, 164: 1900642, 165: 1912156, 166: 1923738, 167: 1935273, 168: 1946885, 169: 1958394, 170: 1969895, 171: 1981572, 172: 1993157, 173: 2004800, 174: 2016449, 175: 2028093, 176: 2039694, 177: 2051224, 178: 2062839, 179: 2074290, 180: 2085919, 181: 2097412, 182: 2109040, 183: 2120553, 184: 2132197, 185: 2143750, 186: 2155277, 187: 2166849, 188: 2178300, 189: 2189906, 190: 2201391, 191: 2212932, 192: 2224539, 193: 2236196, 194: 2247711, 195: 2259241, 196: 2270826, 197: 2282489, 198: 2294156, 199: 2305797, 200: 2317339, 201: 2328959, 202: 2340533, 203: 2352102, 204: 2363780, 205: 2375306, 206: 2386903, 207: 2398478, 208: 2410035, 209: 2421495, 210: 2433087, 211: 2444710, 212: 2456275, 213: 2467892, 214: 2479416, 215: 2491136, 216: 2502653, 217: 2514231, 218: 2525899, 219: 2537383, 220: 2548987, 221: 2560530, 222: 2572222, 223: 2583816, 224: 2595437, 225: 2606919, 226: 2618458, 227: 2629995, 228: 2641574, 229: 2653177, 230: 2664781, 231: 2676369, 232: 2687898, 233: 2699499, 234: 2710997, 235: 2722607, 236: 2734193, 237: 2745827, 238: 2757408, 239: 2768971, 240: 2780538, 241: 2792009, 242: 2803557, 243: 2815133, 244: 2826758, 245: 2838311, 246: 2849927, 247: 2861673, 248: 2873331, 249: 2884954, 250: 2896504, 251: 2908128, 252: 2919653, 253: 2931243, 254: 2942838, 255: 2954311, 256: 2965850, 257: 2977409, 258: 2988946, 259: 3000532, 260: 3012049, 261: 3023675, 262: 3035204, 263: 3046650, 264: 3058192, 265: 3069724, 266: 3081173, 267: 3092674, 268: 3104207, 269: 3115814, 270: 3127361, 271: 3138961, 272: 3150483, 273: 3162158, 274: 3173673, 275: 3185271, 276: 3196759, 277: 3208373, 278: 3219901, 279: 3229049}, 't_cat_3': {0: 0, 1: 9024, 2: 17852, 3: 26800, 4: 35625, 5: 44552, 6: 53525, 7: 62414, 8: 71447, 9: 80355, 10: 89371, 11: 98361, 12: 107289, 13: 116362, 14: 125336, 15: 134286, 16: 143220, 17: 152198, 18: 161189, 19: 170168, 20: 179240, 21: 188190, 22: 197169, 23: 206085, 24: 214999, 25: 223994, 26: 233070, 27: 241989, 28: 250932, 29: 259801, 30: 268820, 31: 277830, 32: 286668, 33: 295613, 34: 304613, 35: 313613, 36: 322456, 37: 331344, 38: 340284, 39: 349151, 40: 358021, 41: 367004, 42: 375836, 43: 384914, 44: 393833, 45: 402612, 46: 411534, 47: 420462, 48: 429460, 49: 438375, 50: 447263, 51: 456216, 52: 465342, 53: 474184, 54: 483072, 55: 491992, 56: 500844, 57: 509706, 58: 518574, 59: 527497, 60: 536399, 61: 545352, 62: 554277, 63: 563245, 64: 572226, 65: 581241, 66: 590122, 67: 599073, 68: 608097, 69: 616999, 70: 625974, 71: 634972, 72: 643905, 73: 652886, 74: 661665, 75: 670599, 76: 679517, 77: 688417, 78: 697339, 79: 706348, 80: 715459, 81: 724401, 82: 733402, 83: 742339, 84: 751341, 85: 760248, 86: 769135, 87: 778157, 88: 787117, 89: 796059, 90: 804916, 91: 813944, 92: 822954, 93: 831945, 94: 840782, 95: 849767, 96: 858672, 97: 867615, 98: 876428, 99: 885406, 100: 894294, 101: 903333, 102: 912313, 103: 921226, 104: 930211, 105: 939266, 106: 948261, 107: 957299, 108: 966263, 109: 975151, 110: 984115, 111: 993044, 112: 1001955, 113: 1010858, 114: 1019828, 115: 1028770, 116: 1037897, 117: 1046785, 118: 1055768, 119: 1064791, 120: 1073805, 121: 1082942, 122: 1091989, 123: 1101047, 124: 1110134, 125: 1119032, 126: 1127875, 127: 1136700, 128: 1145565, 129: 1154464, 130: 1163479, 131: 1172340, 132: 1181374, 133: 1190366, 134: 1199377, 135: 1208362, 136: 1217218, 137: 1226142, 138: 1235154, 139: 1244129, 140: 1253012, 141: 1261962, 142: 1270928, 143: 1279824, 144: 1288810, 145: 1297760, 146: 1306671, 147: 1315554, 148: 1324505, 149: 1333426, 150: 1342354, 151: 1351317, 152: 1360347, 153: 1369320, 154: 1378332, 155: 1387204, 156: 1396203, 157: 1405037, 158: 1414017, 159: 1422979, 160: 1431961, 161: 1440948, 162: 1449796, 163: 1458827, 164: 1467854, 165: 1476654, 166: 1485547, 167: 1494412, 168: 1503342, 169: 1512222, 170: 1521094, 171: 1530061, 172: 1539063, 173: 1548141, 174: 1557127, 175: 1566177, 176: 1575173, 177: 1584066, 178: 1592976, 179: 1601820, 180: 1610830, 181: 1619731, 182: 1628607, 183: 1637542, 184: 1646535, 185: 1655386, 186: 1664211, 187: 1673110, 188: 1681979, 189: 1690889, 190: 1699881, 191: 1708772, 192: 1717697, 193: 1726650, 194: 1735574, 195: 1744489, 196: 1753390, 197: 1762394, 198: 1771401, 199: 1780399, 200: 1789349, 201: 1798287, 202: 1807184, 203: 1816167, 204: 1825093, 205: 1833957, 206: 1842795, 207: 1851853, 208: 1860780, 209: 1869666, 210: 1878743, 211: 1887731, 212: 1896701, 213: 1905630, 214: 1914549, 215: 1923451, 216: 1932379, 217: 1941235, 218: 1950262, 219: 1959116, 220: 1968076, 221: 1977012, 222: 1985948, 223: 1994979, 224: 2003939, 225: 2012851, 226: 2021782, 227: 2030728, 228: 2039669, 229: 2048600, 230: 2057546, 231: 2066546, 232: 2075413, 233: 2084316, 234: 2093178, 235: 2102069, 236: 2111039, 237: 2120044, 238: 2128943, 239: 2137934, 240: 2146912, 241: 2155735, 242: 2164679, 243: 2173650, 244: 2182635, 245: 2191583, 246: 2200493, 247: 2209518, 248: 2218530, 249: 2227397, 250: 2236316, 251: 2245326, 252: 2254227, 253: 2263143, 254: 2272117, 255: 2280926, 256: 2289965, 257: 2298963, 258: 2307841, 259: 2316847, 260: 2325736, 261: 2334650, 262: 2343520, 263: 2352427, 264: 2361326, 265: 2370197, 266: 2378940, 267: 2387852, 268: 2396800, 269: 2405775, 270: 2414728, 271: 2423618, 272: 2432568, 273: 2441508, 274: 2450366, 275: 2459398, 276: 2468249, 277: 2477208, 278: 2486069, 279: 2493170}, 't_cat_4': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 0, 16: 0, 17: 0, 18: 0, 19: 0, 20: 0, 21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0, 28: 0, 29: 0, 30: 0, 31: 0, 32: 0, 33: 0, 34: 0, 35: 0, 36: 0, 37: 0, 38: 0, 39: 0, 40: 0, 41: 0, 42: 0, 43: 0, 44: 0, 45: 0, 46: 0, 47: 0, 48: 0, 49: 0, 50: 0, 51: 0, 52: 0, 53: 0, 54: 0, 55: 0, 56: 0, 57: 0, 58: 0, 59: 0, 60: 0, 61: 0, 62: 0, 63: 0, 64: 0, 65: 0, 66: 0, 67: 0, 68: 0, 69: 0, 70: 0, 71: 0, 72: 0, 73: 0, 74: 0, 75: 0, 76: 0, 77: 0, 78: 0, 79: 0, 80: 0, 81: 0, 82: 0, 83: 0, 84: 0, 85: 0, 86: 0, 87: 0, 88: 0, 89: 0, 90: 0, 91: 0, 92: 0, 93: 0, 94: 0, 95: 0, 96: 0, 97: 0, 98: 0, 99: 0, 100: 0, 101: 0, 102: 0, 103: 0, 104: 0, 105: 0, 106: 0, 107: 0, 108: 0, 109: 0, 110: 0, 111: 0, 112: 0, 113: 0, 114: 0, 115: 0, 116: 0, 117: 0, 118: 0, 119: 0, 120: 0, 121: 0, 122: 0, 123: 0, 124: 0, 125: 0, 126: 0, 127: 0, 128: 0, 129: 0, 130: 0, 131: 0, 132: 0, 133: 0, 134: 0, 135: 0, 136: 0, 137: 0, 138: 0, 139: 0, 140: 0, 141: 0, 142: 0, 143: 0, 144: 0, 145: 0, 146: 0, 147: 0, 148: 0, 149: 0, 150: 0, 151: 0, 152: 0, 153: 0, 154: 0, 155: 0, 156: 0, 157: 0, 158: 0, 159: 0, 160: 0, 161: 0, 162: 0, 163: 0, 164: 0, 165: 0, 166: 0, 167: 0, 168: 0, 169: 0, 170: 0, 171: 0, 172: 0, 173: 0, 174: 0, 175: 0, 176: 0, 177: 0, 178: 0, 179: 0, 180: 0, 181: 0, 182: 0, 183: 0, 184: 0, 185: 0, 186: 0, 187: 0, 188: 0, 189: 0, 190: 0, 191: 0, 192: 0, 193: 0, 194: 0, 195: 0, 196: 0, 197: 0, 198: 0, 199: 0, 200: 0, 201: 0, 202: 0, 203: 0, 204: 0, 205: 0, 206: 0, 207: 0, 208: 0, 209: 0, 210: 0, 211: 0, 212: 0, 213: 0, 214: 0, 215: 0, 216: 0, 217: 0, 218: 0, 219: 0, 220: 0, 221: 0, 222: 0, 223: 0, 224: 0, 225: 0, 226: 0, 227: 0, 228: 0, 229: 0, 230: 0, 231: 0, 232: 0, 233: 0, 234: 0, 235: 0, 236: 0, 237: 0, 238: 0, 239: 0, 240: 0, 241: 0, 242: 0, 243: 0, 244: 0, 245: 0, 246: 0, 247: 0, 248: 0, 249: 0, 250: 0, 251: 0, 252: 0, 253: 0, 254: 0, 255: 0, 256: 0, 257: 0, 258: 0, 259: 0, 260: 0, 261: 0, 262: 0, 263: 0, 264: 0, 265: 0, 266: 0, 267: 0, 268: 0, 269: 0, 270: 0, 271: 0, 272: 0, 273: 0, 274: 0, 275: 0, 276: 0, 277: 0, 278: 0, 279: 0}, 't_cat_5': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 0, 16: 0, 17: 0, 18: 0, 19: 0, 20: 0, 21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0, 28: 0, 29: 0, 30: 0, 31: 0, 32: 0, 33: 0, 34: 0, 35: 0, 36: 0, 37: 0, 38: 0, 39: 0, 40: 0, 41: 0, 42: 0, 43: 0, 44: 0, 45: 0, 46: 0, 47: 0, 48: 0, 49: 0, 50: 0, 51: 0, 52: 0, 53: 0, 54: 0, 55: 0, 56: 0, 57: 0, 58: 0, 59: 0, 60: 0, 61: 0, 62: 0, 63: 0, 64: 0, 65: 0, 66: 0, 67: 0, 68: 0, 69: 0, 70: 0, 71: 0, 72: 0, 73: 0, 74: 0, 75: 0, 76: 0, 77: 0, 78: 0, 79: 0, 80: 0, 81: 0, 82: 0, 83: 0, 84: 0, 85: 0, 86: 0, 87: 0, 88: 0, 89: 0, 90: 0, 91: 0, 92: 0, 93: 0, 94: 0, 95: 0, 96: 0, 97: 0, 98: 0, 99: 0, 100: 0, 101: 0, 102: 0, 103: 0, 104: 0, 105: 0, 106: 0, 107: 0, 108: 0, 109: 0, 110: 0, 111: 0, 112: 0, 113: 0, 114: 0, 115: 0, 116: 0, 117: 0, 118: 0, 119: 0, 120: 0, 121: 0, 122: 0, 123: 0, 124: 0, 125: 0, 126: 0, 127: 0, 128: 0, 129: 0, 130: 0, 131: 0, 132: 0, 133: 0, 134: 0, 135: 0, 136: 0, 137: 0, 138: 0, 139: 0, 140: 0, 141: 0, 142: 0, 143: 0, 144: 0, 145: 0, 146: 0, 147: 0, 148: 0, 149: 0, 150: 0, 151: 0, 152: 0, 153: 0, 154: 0, 155: 0, 156: 0, 157: 0, 158: 0, 159: 0, 160: 0, 161: 0, 162: 0, 163: 0, 164: 0, 165: 0, 166: 0, 167: 0, 168: 0, 169: 0, 170: 0, 171: 0, 172: 0, 173: 0, 174: 0, 175: 0, 176: 0, 177: 0, 178: 0, 179: 0, 180: 0, 181: 0, 182: 0, 183: 0, 184: 0, 185: 0, 186: 0, 187: 0, 188: 0, 189: 0, 190: 0, 191: 0, 192: 0, 193: 0, 194: 0, 195: 0, 196: 0, 197: 0, 198: 0, 199: 0, 200: 0, 201: 0, 202: 0, 203: 0, 204: 0, 205: 0, 206: 0, 207: 0, 208: 0, 209: 0, 210: 0, 211: 0, 212: 0, 213: 0, 214: 0, 215: 0, 216: 0, 217: 0, 218: 0, 219: 0, 220: 0, 221: 0, 222: 0, 223: 0, 224: 0, 225: 0, 226: 0, 227: 0, 228: 0, 229: 0, 230: 0, 231: 0, 232: 0, 233: 0, 234: 0, 235: 0, 236: 0, 237: 0, 238: 0, 239: 0, 240: 0, 241: 0, 242: 0, 243: 0, 244: 0, 245: 0, 246: 0, 247: 0, 248: 0, 249: 0, 250: 0, 251: 0, 252: 0, 253: 0, 254: 0, 255: 0, 256: 0, 257: 0, 258: 0, 259: 0, 260: 0, 261: 0, 262: 0, 263: 0, 264: 0, 265: 0, 266: 0, 267: 0, 268: 0, 269: 0, 270: 0, 271: 0, 272: 0, 273: 0, 274: 0, 275: 0, 276: 0, 277: 0, 278: 0, 279: 0}, 't_cat_6': {0: 0, 1: 9650, 2: 19239, 3: 28898, 4: 38582, 5: 48217, 6: 57847, 7: 67473, 8: 77098, 9: 86778, 10: 96455, 11: 105994, 12: 115535, 13: 125197, 14: 134738, 15: 144325, 16: 153865, 17: 163470, 18: 173150, 19: 182761, 20: 192420, 21: 201978, 22: 211524, 23: 221007, 24: 230610, 25: 240265, 26: 249828, 27: 259424, 28: 269107, 29: 278870, 30: 288535, 31: 298235, 32: 307908, 33: 317563, 34: 327174, 35: 336781, 36: 346415, 37: 356003, 38: 365590, 39: 375219, 40: 384746, 41: 394383, 42: 404033, 43: 413650, 44: 423175, 45: 432762, 46: 442338, 47: 451948, 48: 461582, 49: 471150, 50: 480746, 51: 490382, 52: 499931, 53: 509601, 54: 519257, 55: 528774, 56: 538306, 57: 547815, 58: 557430, 59: 567014, 60: 576570, 61: 586256, 62: 595807, 63: 605348, 64: 615046, 65: 624649, 66: 634383, 67: 643870, 68: 653489, 69: 663180, 70: 672714, 71: 682325, 72: 691848, 73: 701424, 74: 710865, 75: 720505, 76: 730052, 77: 739702, 78: 749401, 79: 759038, 80: 768596, 81: 778345, 82: 787949, 83: 797505, 84: 807114, 85: 816709, 86: 826406, 87: 836135, 88: 845681, 89: 855295, 90: 864977, 91: 874581, 92: 884230, 93: 893755, 94: 903366, 95: 912780, 96: 922384, 97: 932076, 98: 941573, 99: 951226, 100: 960828, 101: 970372, 102: 979970, 103: 989511, 104: 999142, 105: 1008727, 106: 1018125, 107: 1027707, 108: 1037308, 109: 1047022, 110: 1056562, 111: 1066190, 112: 1075771, 113: 1085384, 114: 1094868, 115: 1104546, 116: 1114162, 117: 1123788, 118: 1133464, 119: 1143026, 120: 1152584, 121: 1162056, 122: 1171753, 123: 1181402, 124: 1191049, 125: 1200587, 126: 1210091, 127: 1219625, 128: 1229185, 129: 1238806, 130: 1248453, 131: 1258143, 132: 1267743, 133: 1277252, 134: 1286868, 135: 1296581, 136: 1306178, 137: 1315776, 138: 1325266, 139: 1334863, 140: 1344393, 141: 1353909, 142: 1363537, 143: 1373229, 144: 1382808, 145: 1392394, 146: 1401937, 147: 1411651, 148: 1421264, 149: 1430824, 150: 1440391, 151: 1449940, 152: 1459641, 153: 1469247, 154: 1478680, 155: 1488203, 156: 1497939, 157: 1507682, 158: 1517229, 159: 1526776, 160: 1536506, 161: 1546085, 162: 1555725, 163: 1565422, 164: 1574901, 165: 1584482, 166: 1594046, 167: 1603704, 168: 1613143, 169: 1622750, 170: 1632277, 171: 1641908, 172: 1651507, 173: 1661111, 174: 1670646, 175: 1680246, 176: 1689894, 177: 1699455, 178: 1708948, 179: 1718504, 180: 1728175, 181: 1737774, 182: 1747442, 183: 1756979, 184: 1766596, 185: 1776222, 186: 1785827, 187: 1795420, 188: 1804975, 189: 1814595, 190: 1824219, 191: 1833783, 192: 1843391, 193: 1853010, 194: 1862584, 195: 1872086, 196: 1881672, 197: 1891246, 198: 1900745, 199: 1910363, 200: 1920044, 201: 1929548, 202: 1939156, 203: 1948850, 204: 1958534, 205: 1968102, 206: 1977709, 207: 1987282, 208: 1996941, 209: 2006533, 210: 2016047, 211: 2025552, 212: 2035139, 213: 2044724, 214: 2054299, 215: 2063918, 216: 2073588, 217: 2083242, 218: 2092840, 219: 2102594, 220: 2112153, 221: 2121765, 222: 2131345, 223: 2140996, 224: 2150544, 225: 2160177, 226: 2169761, 227: 2179316, 228: 2188909, 229: 2198518, 230: 2208132, 231: 2217753, 232: 2227352, 233: 2237081, 234: 2246569, 235: 2256173, 236: 2265780, 237: 2275314, 238: 2284880, 239: 2294483, 240: 2304108, 241: 2313789, 242: 2323394, 243: 2333047, 244: 2342638, 245: 2352271, 246: 2361807, 247: 2371410, 248: 2380987, 249: 2390512, 250: 2400115, 251: 2409696, 252: 2419264, 253: 2428986, 254: 2438582, 255: 2448268, 256: 2457899, 257: 2467539, 258: 2477048, 259: 2486656, 260: 2496291, 261: 2505949, 262: 2515580, 263: 2525256, 264: 2534894, 265: 2544548, 266: 2554224, 267: 2563817, 268: 2573398, 269: 2583051, 270: 2592878, 271: 2602530, 272: 2612094, 273: 2621803, 274: 2631261, 275: 2640848, 276: 2650439, 277: 2660049, 278: 2669624, 279: 2677048}, 't_cat_7': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 0, 16: 0, 17: 0, 18: 0, 19: 0, 20: 0, 21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0, 28: 0, 29: 0, 30: 0, 31: 0, 32: 0, 33: 0, 34: 0, 35: 0, 36: 0, 37: 0, 38: 0, 39: 0, 40: 0, 41: 0, 42: 0, 43: 0, 44: 0, 45: 0, 46: 0, 47: 0, 48: 0, 49: 0, 50: 0, 51: 0, 52: 0, 53: 0, 54: 0, 55: 0, 56: 0, 57: 0, 58: 0, 59: 0, 60: 0, 61: 0, 62: 0, 63: 0, 64: 0, 65: 0, 66: 0, 67: 0, 68: 0, 69: 0, 70: 0, 71: 0, 72: 0, 73: 0, 74: 0, 75: 0, 76: 0, 77: 0, 78: 0, 79: 0, 80: 0, 81: 0, 82: 0, 83: 0, 84: 0, 85: 0, 86: 0, 87: 0, 88: 0, 89: 0, 90: 0, 91: 0, 92: 0, 93: 0, 94: 0, 95: 0, 96: 0, 97: 0, 98: 0, 99: 0, 100: 0, 101: 0, 102: 0, 103: 0, 104: 0, 105: 0, 106: 0, 107: 0, 108: 0, 109: 0, 110: 0, 111: 0, 112: 0, 113: 0, 114: 0, 115: 0, 116: 0, 117: 0, 118: 0, 119: 0, 120: 0, 121: 0, 122: 0, 123: 0, 124: 0, 125: 0, 126: 0, 127: 0, 128: 0, 129: 0, 130: 0, 131: 0, 132: 0, 133: 0, 134: 0, 135: 0, 136: 0, 137: 0, 138: 0, 139: 0, 140: 0, 141: 0, 142: 0, 143: 0, 144: 0, 145: 0, 146: 0, 147: 0, 148: 0, 149: 0, 150: 0, 151: 0, 152: 0, 153: 0, 154: 0, 155: 0, 156: 0, 157: 0, 158: 0, 159: 0, 160: 0, 161: 0, 162: 0, 163: 0, 164: 0, 165: 0, 166: 0, 167: 0, 168: 0, 169: 0, 170: 0, 171: 0, 172: 0, 173: 0, 174: 0, 175: 0, 176: 0, 177: 0, 178: 0, 179: 0, 180: 0, 181: 0, 182: 0, 183: 0, 184: 0, 185: 0, 186: 0, 187: 0, 188: 0, 189: 0, 190: 0, 191: 0, 192: 0, 193: 0, 194: 0, 195: 0, 196: 0, 197: 0, 198: 0, 199: 0, 200: 0, 201: 0, 202: 0, 203: 0, 204: 0, 205: 0, 206: 0, 207: 0, 208: 0, 209: 0, 210: 0, 211: 0, 212: 0, 213: 0, 214: 0, 215: 0, 216: 0, 217: 0, 218: 0, 219: 0, 220: 0, 221: 0, 222: 0, 223: 0, 224: 0, 225: 0, 226: 0, 227: 0, 228: 0, 229: 0, 230: 0, 231: 0, 232: 0, 233: 0, 234: 0, 235: 0, 236: 0, 237: 0, 238: 0, 239: 0, 240: 0, 241: 0, 242: 0, 243: 0, 244: 0, 245: 0, 246: 0, 247: 0, 248: 0, 249: 0, 250: 0, 251: 0, 252: 0, 253: 0, 254: 0, 255: 0, 256: 0, 257: 0, 258: 0, 259: 0, 260: 0, 261: 0, 262: 0, 263: 0, 264: 0, 265: 0, 266: 0, 267: 0, 268: 0, 269: 0, 270: 0, 271: 0, 272: 0, 273: 0, 274: 0, 275: 0, 276: 0, 277: 0, 278: 0, 279: 0}, 't_cat_8': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 0, 16: 0, 17: 0, 18: 0, 19: 0, 20: 0, 21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0, 28: 0, 29: 0, 30: 0, 31: 0, 32: 0, 33: 0, 34: 0, 35: 0, 36: 0, 37: 0, 38: 0, 39: 0, 40: 0, 41: 0, 42: 0, 43: 0, 44: 0, 45: 0, 46: 0, 47: 0, 48: 0, 49: 0, 50: 0, 51: 0, 52: 0, 53: 0, 54: 0, 55: 0, 56: 0, 57: 0, 58: 0, 59: 0, 60: 0, 61: 0, 62: 0, 63: 0, 64: 0, 65: 0, 66: 0, 67: 0, 68: 0, 69: 0, 70: 0, 71: 0, 72: 0, 73: 0, 74: 0, 75: 0, 76: 0, 77: 0, 78: 0, 79: 0, 80: 0, 81: 0, 82: 0, 83: 0, 84: 0, 85: 0, 86: 0, 87: 0, 88: 0, 89: 0, 90: 0, 91: 0, 92: 0, 93: 0, 94: 0, 95: 0, 96: 0, 97: 0, 98: 0, 99: 0, 100: 0, 101: 0, 102: 0, 103: 0, 104: 0, 105: 0, 106: 0, 107: 0, 108: 0, 109: 0, 110: 0, 111: 0, 112: 0, 113: 0, 114: 0, 115: 0, 116: 0, 117: 0, 118: 0, 119: 0, 120: 0, 121: 0, 122: 0, 123: 0, 124: 0, 125: 0, 126: 0, 127: 0, 128: 0, 129: 0, 130: 0, 131: 0, 132: 0, 133: 0, 134: 0, 135: 0, 136: 0, 137: 0, 138: 0, 139: 0, 140: 0, 141: 0, 142: 0, 143: 0, 144: 0, 145: 0, 146: 0, 147: 0, 148: 0, 149: 0, 150: 0, 151: 0, 152: 0, 153: 0, 154: 0, 155: 0, 156: 0, 157: 0, 158: 0, 159: 0, 160: 0, 161: 0, 162: 0, 163: 0, 164: 0, 165: 0, 166: 0, 167: 0, 168: 0, 169: 0, 170: 0, 171: 0, 172: 0, 173: 0, 174: 0, 175: 0, 176: 0, 177: 0, 178: 0, 179: 0, 180: 0, 181: 0, 182: 0, 183: 0, 184: 0, 185: 0, 186: 0, 187: 0, 188: 0, 189: 0, 190: 0, 191: 0, 192: 0, 193: 0, 194: 0, 195: 0, 196: 0, 197: 0, 198: 0, 199: 0, 200: 0, 201: 0, 202: 0, 203: 0, 204: 0, 205: 0, 206: 0, 207: 0, 208: 0, 209: 0, 210: 0, 211: 0, 212: 0, 213: 0, 214: 0, 215: 0, 216: 0, 217: 0, 218: 0, 219: 0, 220: 0, 221: 0, 222: 0, 223: 0, 224: 0, 225: 0, 226: 0, 227: 0, 228: 0, 229: 0, 230: 0, 231: 0, 232: 0, 233: 0, 234: 0, 235: 0, 236: 0, 237: 0, 238: 0, 239: 0, 240: 0, 241: 0, 242: 0, 243: 0, 244: 0, 245: 0, 246: 0, 247: 0, 248: 0, 249: 0, 250: 0, 251: 0, 252: 0, 253: 0, 254: 0, 255: 0, 256: 0, 257: 0, 258: 0, 259: 0, 260: 0, 261: 0, 262: 0, 263: 0, 264: 0, 265: 0, 266: 0, 267: 0, 268: 0, 269: 0, 270: 0, 271: 0, 272: 0, 273: 0, 274: 0, 275: 0, 276: 0, 277: 0, 278: 0, 279: 0}, 't_cat_9': {0: 0, 1: 7943, 2: 15929, 3: 23876, 4: 31940, 5: 39918, 6: 47972, 7: 55962, 8: 63879, 9: 71739, 10: 79761, 11: 87701, 12: 95698, 13: 103674, 14: 111623, 15: 119622, 16: 127524, 17: 135522, 18: 143524, 19: 151597, 20: 159640, 21: 167509, 22: 175365, 23: 183263, 24: 191205, 25: 199227, 26: 207171, 27: 215102, 28: 223073, 29: 231128, 30: 239112, 31: 247155, 32: 255136, 33: 263164, 34: 271072, 35: 278999, 36: 287061, 37: 295135, 38: 303059, 39: 310987, 40: 319053, 41: 327025, 42: 335000, 43: 342918, 44: 350918, 45: 358773, 46: 366784, 47: 374782, 48: 382791, 49: 390797, 50: 398748, 51: 406720, 52: 414628, 53: 422564, 54: 430518, 55: 438512, 56: 446471, 57: 454479, 58: 462530, 59: 470561, 60: 478454, 61: 486551, 62: 494513, 63: 502437, 64: 510421, 65: 518332, 66: 526278, 67: 534286, 68: 542319, 69: 550291, 70: 558253, 71: 566202, 72: 574077, 73: 581971, 74: 589895, 75: 597884, 76: 605891, 77: 613701, 78: 621660, 79: 629630, 80: 637704, 81: 645654, 82: 653713, 83: 661680, 84: 669612, 85: 677676, 86: 685760, 87: 693759, 88: 701789, 89: 709852, 90: 717895, 91: 725903, 92: 733897, 93: 741804, 94: 749698, 95: 757719, 96: 765664, 97: 773650, 98: 781605, 99: 789545, 100: 797531, 101: 805395, 102: 813303, 103: 821174, 104: 829037, 105: 836995, 106: 844909, 107: 852906, 108: 860759, 109: 868691, 110: 876700, 111: 884677, 112: 892641, 113: 900627, 114: 908440, 115: 916423, 116: 924480, 117: 932414, 118: 940365, 119: 948385, 120: 956306, 121: 964317, 122: 972375, 123: 980382, 124: 988390, 125: 996324, 126: 1004193, 127: 1012231, 128: 1020144, 129: 1028167, 130: 1036044, 131: 1044008, 132: 1051975, 133: 1059797, 134: 1067764, 135: 1075661, 136: 1083569, 137: 1091509, 138: 1099393, 139: 1107339, 140: 1115156, 141: 1123078, 142: 1130929, 143: 1139022, 144: 1147039, 145: 1155031, 146: 1163004, 147: 1170949, 148: 1178866, 149: 1186826, 150: 1194908, 151: 1202853, 152: 1210764, 153: 1218696, 154: 1226561, 155: 1234600, 156: 1242654, 157: 1250685, 158: 1258591, 159: 1266572, 160: 1274481, 161: 1282449, 162: 1290407, 163: 1298385, 164: 1306427, 165: 1314385, 166: 1322400, 167: 1330267, 168: 1338251, 169: 1346090, 170: 1353991, 171: 1361921, 172: 1369990, 173: 1377960, 174: 1386029, 175: 1393984, 176: 1401890, 177: 1409871, 178: 1417805, 179: 1425768, 180: 1433720, 181: 1441783, 182: 1449714, 183: 1457767, 184: 1465744, 185: 1473803, 186: 1481775, 187: 1489658, 188: 1497701, 189: 1505744, 190: 1513788, 191: 1521788, 192: 1529774, 193: 1537710, 194: 1545766, 195: 1553540, 196: 1561551, 197: 1569487, 198: 1577497, 199: 1585502, 200: 1593456, 201: 1601491, 202: 1609470, 203: 1617505, 204: 1625446, 205: 1633450, 206: 1641441, 207: 1649429, 208: 1657406, 209: 1665414, 210: 1673250, 211: 1681223, 212: 1689169, 213: 1697315, 214: 1705255, 215: 1713234, 216: 1721177, 217: 1729070, 218: 1736994, 219: 1744909, 220: 1752902, 221: 1760913, 222: 1768859, 223: 1777051, 224: 1784986, 225: 1793011, 226: 1800936, 227: 1808927, 228: 1816982, 229: 1825090, 230: 1833184, 231: 1841114, 232: 1849054, 233: 1857035, 234: 1864968, 235: 1872931, 236: 1880996, 237: 1888912, 238: 1896945, 239: 1904981, 240: 1912801, 241: 1920736, 242: 1928664, 243: 1936637, 244: 1944619, 245: 1952549, 246: 1960568, 247: 1968568, 248: 1976503, 249: 1984381, 250: 1992349, 251: 2000488, 252: 2008530, 253: 2016550, 254: 2024590, 255: 2032548, 256: 2040473, 257: 2048456, 258: 2056430, 259: 2064431, 260: 2072346, 261: 2080287, 262: 2088171, 263: 2096094, 264: 2104108, 265: 2112222, 266: 2120176, 267: 2128121, 268: 2136100, 269: 2144177, 270: 2152123, 271: 2160127, 272: 2168011, 273: 2176062, 274: 2183872, 275: 2191918, 276: 2200070, 277: 2208018, 278: 2215880, 279: 2222164}, 't_cat_10': {0: 0, 1: 6221, 2: 12431, 3: 18577, 4: 24823, 5: 31185, 6: 37330, 7: 43558, 8: 49803, 9: 56070, 10: 62345, 11: 68454, 12: 74624, 13: 80952, 14: 87132, 15: 93260, 16: 99429, 17: 105673, 18: 111940, 19: 118218, 20: 124499, 21: 130660, 22: 136888, 23: 143133, 24: 149397, 25: 155672, 26: 161886, 27: 168095, 28: 174373, 29: 180665, 30: 187008, 31: 193300, 32: 199589, 33: 205743, 34: 211972, 35: 218326, 36: 224636, 37: 230787, 38: 237049, 39: 243365, 40: 249553, 41: 255849, 42: 262107, 43: 268290, 44: 274519, 45: 280870, 46: 287061, 47: 293246, 48: 299454, 49: 305668, 50: 311898, 51: 318101, 52: 324322, 53: 330602, 54: 336806, 55: 343063, 56: 349215, 57: 355364, 58: 361608, 59: 367774, 60: 374000, 61: 380267, 62: 386507, 63: 392635, 64: 398876, 65: 405062, 66: 411272, 67: 417490, 68: 423701, 69: 429886, 70: 436257, 71: 442473, 72: 448611, 73: 454692, 74: 460843, 75: 467170, 76: 473325, 77: 479509, 78: 485803, 79: 492160, 80: 498381, 81: 504596, 82: 510715, 83: 516911, 84: 523046, 85: 529290, 86: 535582, 87: 541788, 88: 548005, 89: 554295, 90: 560477, 91: 566741, 92: 572887, 93: 579088, 94: 585455, 95: 591680, 96: 597854, 97: 604033, 98: 610182, 99: 616451, 100: 622577, 101: 628743, 102: 634955, 103: 641283, 104: 647488, 105: 653670, 106: 659879, 107: 666084, 108: 672252, 109: 678320, 110: 684466, 111: 690735, 112: 696908, 113: 703027, 114: 709259, 115: 715379, 116: 721492, 117: 727603, 118: 733729, 119: 739867, 120: 746085, 121: 752268, 122: 758429, 123: 764651, 124: 770858, 125: 777114, 126: 783331, 127: 789588, 128: 795704, 129: 801896, 130: 808047, 131: 814180, 132: 820461, 133: 826661, 134: 832741, 135: 838931, 136: 845109, 137: 851309, 138: 857498, 139: 863765, 140: 870066, 141: 876265, 142: 882424, 143: 888658, 144: 894754, 145: 900985, 146: 907247, 147: 913516, 148: 919816, 149: 925967, 150: 932097, 151: 938310, 152: 944608, 153: 950834, 154: 957049, 155: 963272, 156: 969579, 157: 975740, 158: 981920, 159: 988134, 160: 994443, 161: 1000774, 162: 1007008, 163: 1013314, 164: 1019520, 165: 1025671, 166: 1031858, 167: 1038033, 168: 1044306, 169: 1050442, 170: 1056621, 171: 1062910, 172: 1069171, 173: 1075397, 174: 1081615, 175: 1087857, 176: 1094099, 177: 1100268, 178: 1106431, 179: 1112566, 180: 1118837, 181: 1125073, 182: 1131324, 183: 1137423, 184: 1143746, 185: 1149885, 186: 1156057, 187: 1162330, 188: 1168609, 189: 1174839, 190: 1181031, 191: 1187257, 192: 1193487, 193: 1199731, 194: 1205964, 195: 1212055, 196: 1218342, 197: 1224581, 198: 1230702, 199: 1236943, 200: 1243187, 201: 1249488, 202: 1255596, 203: 1261892, 204: 1268133, 205: 1274407, 206: 1280479, 207: 1286616, 208: 1292677, 209: 1298967, 210: 1305184, 211: 1311496, 212: 1317783, 213: 1323976, 214: 1330179, 215: 1336449, 216: 1342624, 217: 1348814, 218: 1355070, 219: 1361392, 220: 1367588, 221: 1373752, 222: 1379930, 223: 1386194, 224: 1392321, 225: 1398532, 226: 1404790, 227: 1411089, 228: 1417420, 229: 1423715, 230: 1429866, 231: 1436001, 232: 1442077, 233: 1448320, 234: 1454529, 235: 1460722, 236: 1466895, 237: 1473081, 238: 1479271, 239: 1485377, 240: 1491608, 241: 1497883, 242: 1504157, 243: 1510463, 244: 1516711, 245: 1522952, 246: 1529090, 247: 1535243, 248: 1541511, 249: 1547716, 250: 1553892, 251: 1560136, 252: 1566394, 253: 1572562, 254: 1578669, 255: 1584945, 256: 1591158, 257: 1597228, 258: 1603443, 259: 1609587, 260: 1615760, 261: 1621927, 262: 1628334, 263: 1634534, 264: 1640709, 265: 1647000, 266: 1653303, 267: 1659524, 268: 1665712, 269: 1672011, 270: 1678255, 271: 1684503, 272: 1690692, 273: 1696922, 274: 1703246, 275: 1709371, 276: 1715645, 277: 1721822, 278: 1727855, 279: 1732720}, 't_cat_11': {0: 0, 1: 11394, 2: 22681, 3: 33966, 4: 45218, 5: 56501, 6: 67819, 7: 79204, 8: 90601, 9: 101950, 10: 113339, 11: 124716, 12: 136084, 13: 147419, 14: 158806, 15: 170144, 16: 181396, 17: 192755, 18: 204033, 19: 215322, 20: 226714, 21: 238081, 22: 249364, 23: 260634, 24: 271972, 25: 283363, 26: 294764, 27: 306119, 28: 317488, 29: 328706, 30: 340032, 31: 351414, 32: 362718, 33: 374040, 34: 385282, 35: 396627, 36: 407877, 37: 419172, 38: 430492, 39: 441839, 40: 453122, 41: 464447, 42: 475647, 43: 487183, 44: 498497, 45: 509793, 46: 521078, 47: 532454, 48: 543802, 49: 555149, 50: 566371, 51: 577640, 52: 589030, 53: 600286, 54: 611588, 55: 622890, 56: 634152, 57: 645461, 58: 656767, 59: 668060, 60: 679446, 61: 690797, 62: 702148, 63: 713544, 64: 724772, 65: 736120, 66: 747352, 67: 758713, 68: 770102, 69: 781386, 70: 792631, 71: 804015, 72: 815413, 73: 826730, 74: 837900, 75: 849261, 76: 860592, 77: 871844, 78: 883222, 79: 894561, 80: 905965, 81: 917270, 82: 928652, 83: 940048, 84: 951436, 85: 962751, 86: 974047, 87: 985336, 88: 996562, 89: 1007846, 90: 1019107, 91: 1030380, 92: 1041712, 93: 1053076, 94: 1064352, 95: 1075720, 96: 1086941, 97: 1098226, 98: 1109576, 99: 1120883, 100: 1132175, 101: 1143451, 102: 1154815, 103: 1166085, 104: 1177424, 105: 1188790, 106: 1200140, 107: 1211559, 108: 1222970, 109: 1234247, 110: 1245527, 111: 1256852, 112: 1268078, 113: 1279437, 114: 1290810, 115: 1302048, 116: 1313408, 117: 1324702, 118: 1336003, 119: 1347385, 120: 1358756, 121: 1370210, 122: 1381606, 123: 1392999, 124: 1404324, 125: 1415663, 126: 1426923, 127: 1438189, 128: 1449534, 129: 1460830, 130: 1472289, 131: 1483566, 132: 1494984, 133: 1506438, 134: 1517833, 135: 1529063, 136: 1540305, 137: 1551622, 138: 1563027, 139: 1574324, 140: 1585628, 141: 1597012, 142: 1608397, 143: 1619714, 144: 1631011, 145: 1642354, 146: 1653671, 147: 1664929, 148: 1676233, 149: 1687539, 150: 1698888, 151: 1710270, 152: 1721630, 153: 1733062, 154: 1744337, 155: 1755676, 156: 1767091, 157: 1778455, 158: 1789815, 159: 1801178, 160: 1812523, 161: 1823835, 162: 1835186, 163: 1846542, 164: 1857861, 165: 1869046, 166: 1880347, 167: 1891593, 168: 1902954, 169: 1914203, 170: 1925430, 171: 1936766, 172: 1948146, 173: 1959529, 174: 1970899, 175: 1982197, 176: 1993537, 177: 2004845, 178: 2016184, 179: 2027407, 180: 2038730, 181: 2049979, 182: 2061271, 183: 2072524, 184: 2083801, 185: 2095130, 186: 2106279, 187: 2117635, 188: 2128897, 189: 2140225, 190: 2151524, 191: 2162848, 192: 2174102, 193: 2185448, 194: 2196665, 195: 2207899, 196: 2219167, 197: 2230605, 198: 2242017, 199: 2253404, 200: 2264686, 201: 2275953, 202: 2287296, 203: 2298627, 204: 2309941, 205: 2321153, 206: 2332459, 207: 2343839, 208: 2355158, 209: 2366392, 210: 2377690, 211: 2389021, 212: 2400369, 213: 2411686, 214: 2423060, 215: 2434380, 216: 2445695, 217: 2457010, 218: 2468406, 219: 2479684, 220: 2491036, 221: 2502318, 222: 2513721, 223: 2524982, 224: 2536343, 225: 2547563, 226: 2558811, 227: 2570056, 228: 2581385, 229: 2592891, 230: 2604199, 231: 2615585, 232: 2626853, 233: 2638032, 234: 2649222, 235: 2660599, 236: 2671886, 237: 2683163, 238: 2694442, 239: 2705722, 240: 2717128, 241: 2728340, 242: 2739676, 243: 2751040, 244: 2762324, 245: 2773649, 246: 2784978, 247: 2796388, 248: 2807729, 249: 2819022, 250: 2830274, 251: 2841668, 252: 2852981, 253: 2864247, 254: 2875568, 255: 2886848, 256: 2898141, 257: 2909423, 258: 2920743, 259: 2932062, 260: 2943346, 261: 2954713, 262: 2965999, 263: 2977186, 264: 2988454, 265: 2999720, 266: 3010982, 267: 3022308, 268: 3033580, 269: 3044832, 270: 3056091, 271: 3067393, 272: 3078702, 273: 3090155, 274: 3101373, 275: 3112741, 276: 3124067, 277: 3135402, 278: 3146717, 279: 3155735}, 't_cat_12': {0: 0, 1: 4628, 2: 9287, 3: 13954, 4: 18738, 5: 23459, 6: 28201, 7: 32769, 8: 37386, 9: 42067, 10: 46771, 11: 51374, 12: 56097, 13: 60796, 14: 65472, 15: 70092, 16: 74707, 17: 79433, 18: 84067, 19: 88765, 20: 93494, 21: 98079, 22: 102706, 23: 107471, 24: 112163, 25: 116766, 26: 121408, 27: 125996, 28: 130659, 29: 135444, 30: 140181, 31: 144804, 32: 149567, 33: 154262, 34: 158870, 35: 163554, 36: 168277, 37: 172908, 38: 177535, 39: 182303, 40: 187044, 41: 191704, 42: 196443, 43: 201229, 44: 205858, 45: 210523, 46: 215186, 47: 219895, 48: 224571, 49: 229207, 50: 233833, 51: 238537, 52: 243197, 53: 247862, 54: 252513, 55: 257201, 56: 261866, 57: 266644, 58: 271354, 59: 275964, 60: 280623, 61: 285299, 62: 289933, 63: 294527, 64: 299234, 65: 303882, 66: 308620, 67: 313292, 68: 317950, 69: 322768, 70: 327424, 71: 332104, 72: 336718, 73: 341419, 74: 346092, 75: 350798, 76: 355524, 77: 360175, 78: 364707, 79: 369454, 80: 374079, 81: 378838, 82: 383454, 83: 388192, 84: 392872, 85: 397518, 86: 402207, 87: 407009, 88: 411612, 89: 416263, 90: 420996, 91: 425625, 92: 430273, 93: 434874, 94: 439584, 95: 444152, 96: 448805, 97: 453532, 98: 458161, 99: 462892, 100: 467500, 101: 472128, 102: 476763, 103: 481450, 104: 486103, 105: 490793, 106: 495452, 107: 500073, 108: 504811, 109: 509498, 110: 514160, 111: 518862, 112: 523540, 113: 528253, 114: 532884, 115: 537480, 116: 542114, 117: 546843, 118: 551627, 119: 556266, 120: 560907, 121: 565473, 122: 570099, 123: 574877, 124: 579572, 125: 584291, 126: 588938, 127: 593525, 128: 598169, 129: 602884, 130: 607467, 131: 612115, 132: 616767, 133: 621374, 134: 626047, 135: 630623, 136: 635293, 137: 639954, 138: 644633, 139: 649342, 140: 654040, 141: 658791, 142: 663510, 143: 668147, 144: 672761, 145: 677324, 146: 682056, 147: 686872, 148: 691473, 149: 696093, 150: 700736, 151: 705298, 152: 709989, 153: 714700, 154: 719365, 155: 724088, 156: 728674, 157: 733365, 158: 738010, 159: 742641, 160: 747354, 161: 752029, 162: 756731, 163: 761447, 164: 766023, 165: 770663, 166: 775338, 167: 779966, 168: 784609, 169: 789216, 170: 793853, 171: 798488, 172: 803247, 173: 807769, 174: 812407, 175: 817091, 176: 821809, 177: 826407, 178: 831014, 179: 835551, 180: 840205, 181: 844972, 182: 849679, 183: 854425, 184: 859199, 185: 863905, 186: 868579, 187: 873305, 188: 878012, 189: 882675, 190: 887478, 191: 892178, 192: 896957, 193: 901667, 194: 906310, 195: 910892, 196: 915622, 197: 920376, 198: 925029, 199: 929701, 200: 934492, 201: 939099, 202: 943736, 203: 948411, 204: 953059, 205: 957782, 206: 962320, 207: 966945, 208: 971558, 209: 976136, 210: 980782, 211: 985497, 212: 990206, 213: 994868, 214: 999608, 215: 1004130, 216: 1008835, 217: 1013512, 218: 1018258, 219: 1023093, 220: 1027689, 221: 1032397, 222: 1037064, 223: 1041846, 224: 1046467, 225: 1051151, 226: 1055881, 227: 1060563, 228: 1065317, 229: 1070084, 230: 1074722, 231: 1079374, 232: 1083934, 233: 1088669, 234: 1093316, 235: 1097992, 236: 1102556, 237: 1107202, 238: 1111854, 239: 1116541, 240: 1121145, 241: 1125830, 242: 1130520, 243: 1135201, 244: 1139971, 245: 1144578, 246: 1149193, 247: 1153839, 248: 1158452, 249: 1163139, 250: 1167826, 251: 1172448, 252: 1177159, 253: 1181847, 254: 1186524, 255: 1191274, 256: 1195952, 257: 1200655, 258: 1205428, 259: 1210093, 260: 1214759, 261: 1219486, 262: 1224358, 263: 1229050, 264: 1233898, 265: 1238574, 266: 1243214, 267: 1247883, 268: 1252554, 269: 1257227, 270: 1261906, 271: 1266546, 272: 1271168, 273: 1275872, 274: 1280516, 275: 1285193, 276: 1289940, 277: 1294498, 278: 1299173, 279: 1302857}, 't_cat_13': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 0, 16: 0, 17: 0, 18: 0, 19: 0, 20: 0, 21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0, 28: 0, 29: 0, 30: 0, 31: 0, 32: 0, 33: 0, 34: 0, 35: 0, 36: 0, 37: 0, 38: 0, 39: 0, 40: 0, 41: 0, 42: 0, 43: 0, 44: 0, 45: 0, 46: 0, 47: 0, 48: 0, 49: 0, 50: 0, 51: 0, 52: 0, 53: 0, 54: 0, 55: 0, 56: 0, 57: 0, 58: 0, 59: 0, 60: 0, 61: 0, 62: 0, 63: 0, 64: 0, 65: 0, 66: 0, 67: 0, 68: 0, 69: 0, 70: 0, 71: 0, 72: 0, 73: 0, 74: 0, 75: 0, 76: 0, 77: 0, 78: 0, 79: 0, 80: 0, 81: 0, 82: 0, 83: 0, 84: 0, 85: 0, 86: 0, 87: 0, 88: 0, 89: 0, 90: 0, 91: 0, 92: 0, 93: 0, 94: 0, 95: 0, 96: 0, 97: 0, 98: 0, 99: 0, 100: 0, 101: 0, 102: 0, 103: 0, 104: 0, 105: 0, 106: 0, 107: 0, 108: 0, 109: 0, 110: 0, 111: 0, 112: 0, 113: 0, 114: 0, 115: 0, 116: 0, 117: 0, 118: 0, 119: 0, 120: 0, 121: 0, 122: 0, 123: 0, 124: 0, 125: 0, 126: 0, 127: 0, 128: 0, 129: 0, 130: 0, 131: 0, 132: 0, 133: 0, 134: 0, 135: 0, 136: 0, 137: 0, 138: 0, 139: 0, 140: 0, 141: 0, 142: 0, 143: 0, 144: 0, 145: 0, 146: 0, 147: 0, 148: 0, 149: 0, 150: 0, 151: 0, 152: 0, 153: 0, 154: 0, 155: 0, 156: 0, 157: 0, 158: 0, 159: 0, 160: 0, 161: 0, 162: 0, 163: 0, 164: 0, 165: 0, 166: 0, 167: 0, 168: 0, 169: 0, 170: 0, 171: 0, 172: 0, 173: 0, 174: 0, 175: 0, 176: 0, 177: 0, 178: 0, 179: 0, 180: 0, 181: 0, 182: 0, 183: 0, 184: 0, 185: 0, 186: 0, 187: 0, 188: 0, 189: 0, 190: 0, 191: 0, 192: 0, 193: 0, 194: 0, 195: 0, 196: 0, 197: 0, 198: 0, 199: 0, 200: 0, 201: 0, 202: 0, 203: 0, 204: 0, 205: 0, 206: 0, 207: 0, 208: 0, 209: 0, 210: 0, 211: 0, 212: 0, 213: 0, 214: 0, 215: 0, 216: 0, 217: 0, 218: 0, 219: 0, 220: 0, 221: 0, 222: 0, 223: 0, 224: 0, 225: 0, 226: 0, 227: 0, 228: 0, 229: 0, 230: 0, 231: 0, 232: 0, 233: 0, 234: 0, 235: 0, 236: 0, 237: 0, 238: 0, 239: 0, 240: 0, 241: 0, 242: 0, 243: 0, 244: 0, 245: 0, 246: 0, 247: 0, 248: 0, 249: 0, 250: 0, 251: 0, 252: 0, 253: 0, 254: 0, 255: 0, 256: 0, 257: 0, 258: 0, 259: 0, 260: 0, 261: 0, 262: 0, 263: 0, 264: 0, 265: 0, 266: 0, 267: 0, 268: 0, 269: 0, 270: 0, 271: 0, 272: 0, 273: 0, 274: 0, 275: 0, 276: 0, 277: 0, 278: 0, 279: 0}, 't_cat_14': {0: 0, 1: 5806, 2: 11716, 3: 17564, 4: 23447, 5: 29344, 6: 35136, 7: 41083, 8: 46914, 9: 52794, 10: 58733, 11: 64575, 12: 70472, 13: 76420, 14: 82346, 15: 88207, 16: 94090, 17: 100104, 18: 106048, 19: 112044, 20: 117958, 21: 123995, 22: 129914, 23: 135764, 24: 141657, 25: 147520, 26: 153428, 27: 159367, 28: 165317, 29: 171192, 30: 177148, 31: 182976, 32: 188875, 33: 194780, 34: 200573, 35: 206484, 36: 212450, 37: 218210, 38: 224071, 39: 229882, 40: 235707, 41: 241544, 42: 247367, 43: 253276, 44: 259207, 45: 265053, 46: 270954, 47: 276823, 48: 282771, 49: 288624, 50: 294515, 51: 300458, 52: 306314, 53: 312235, 54: 318163, 55: 324109, 56: 330055, 57: 335861, 58: 341743, 59: 347583, 60: 353471, 61: 359451, 62: 365309, 63: 371272, 64: 377151, 65: 383047, 66: 388895, 67: 394873, 68: 400806, 69: 406682, 70: 412628, 71: 418527, 72: 424396, 73: 430332, 74: 436185, 75: 442135, 76: 448015, 77: 453822, 78: 459571, 79: 465526, 80: 471449, 81: 477296, 82: 483245, 83: 489116, 84: 495062, 85: 500927, 86: 506807, 87: 512733, 88: 518635, 89: 524442, 90: 530290, 91: 536094, 92: 541890, 93: 547775, 94: 553680, 95: 559471, 96: 565288, 97: 571263, 98: 577090, 99: 583026, 100: 588787, 101: 594675, 102: 600431, 103: 606325, 104: 612163, 105: 617989, 106: 623959, 107: 629857, 108: 635750, 109: 641660, 110: 647605, 111: 653403, 112: 659329, 113: 665271, 114: 671291, 115: 677191, 116: 683049, 117: 688978, 118: 694920, 119: 700788, 120: 706613, 121: 712495, 122: 718378, 123: 724260, 124: 730194, 125: 736037, 126: 741862, 127: 747734, 128: 753613, 129: 759603, 130: 765579, 131: 771492, 132: 777469, 133: 783312, 134: 789254, 135: 795148, 136: 800874, 137: 806702, 138: 812714, 139: 818675, 140: 824519, 141: 830413, 142: 836287, 143: 842199, 144: 848051, 145: 853998, 146: 859863, 147: 865677, 148: 871611, 149: 877591, 150: 883468, 151: 889257, 152: 895181, 153: 901084, 154: 906986, 155: 912969, 156: 918899, 157: 924828, 158: 930719, 159: 936666, 160: 942508, 161: 948323, 162: 954350, 163: 960258, 164: 966230, 165: 972037, 166: 977873, 167: 983769, 168: 989550, 169: 995411, 170: 1001291, 171: 1007145, 172: 1013028, 173: 1018945, 174: 1024879, 175: 1030814, 176: 1036643, 177: 1042585, 178: 1048458, 179: 1054346, 180: 1060224, 181: 1066090, 182: 1071867, 183: 1077746, 184: 1083667, 185: 1089584, 186: 1095466, 187: 1101373, 188: 1107323, 189: 1113254, 190: 1119066, 191: 1125036, 192: 1130851, 193: 1136748, 194: 1142581, 195: 1148473, 196: 1154378, 197: 1160256, 198: 1166088, 199: 1171861, 200: 1177773, 201: 1183633, 202: 1189647, 203: 1195442, 204: 1201453, 205: 1207405, 206: 1213335, 207: 1219242, 208: 1225072, 209: 1230931, 210: 1236794, 211: 1242667, 212: 1248499, 213: 1254250, 214: 1260105, 215: 1266072, 216: 1271909, 217: 1277730, 218: 1283676, 219: 1289586, 220: 1295478, 221: 1301269, 222: 1307145, 223: 1313093, 224: 1319083, 225: 1324880, 226: 1330755, 227: 1336629, 228: 1342567, 229: 1348529, 230: 1354274, 231: 1360270, 232: 1366148, 233: 1372042, 234: 1377960, 235: 1383814, 236: 1389652, 237: 1395480, 238: 1401277, 239: 1407150, 240: 1413082, 241: 1418982, 242: 1424982, 243: 1430951, 244: 1436870, 245: 1442747, 246: 1448612, 247: 1454483, 248: 1460382, 249: 1466272, 250: 1472191, 251: 1478018, 252: 1483926, 253: 1489902, 254: 1495831, 255: 1501614, 256: 1507521, 257: 1513355, 258: 1519339, 259: 1525172, 260: 1530970, 261: 1536861, 262: 1542623, 263: 1548440, 264: 1554272, 265: 1560127, 266: 1565999, 267: 1571888, 268: 1577763, 269: 1583696, 270: 1589634, 271: 1595515, 272: 1601404, 273: 1607376, 274: 1613285, 275: 1619140, 276: 1625025, 277: 1630957, 278: 1636858, 279: 1641445}, 't_cat_15': {0: 0, 1: 10643, 2: 21154, 3: 31640, 4: 42106, 5: 52590, 6: 63155, 7: 73768, 8: 84334, 9: 94993, 10: 105562, 11: 116172, 12: 126746, 13: 137282, 14: 147868, 15: 158464, 16: 169006, 17: 179564, 18: 190145, 19: 200765, 20: 211346, 21: 221962, 22: 232508, 23: 242987, 24: 253529, 25: 264141, 26: 274741, 27: 285322, 28: 295867, 29: 306361, 30: 316897, 31: 327485, 32: 337949, 33: 348484, 34: 359011, 35: 369542, 36: 379984, 37: 390429, 38: 400946, 39: 411430, 40: 421965, 41: 432516, 42: 442909, 43: 453557, 44: 464080, 45: 474597, 46: 485113, 47: 495710, 48: 506224, 49: 516790, 50: 527306, 51: 537832, 52: 548468, 53: 558926, 54: 569415, 55: 579934, 56: 590327, 57: 600777, 58: 611261, 59: 621772, 60: 632342, 61: 642912, 62: 653444, 63: 663975, 64: 674460, 65: 684964, 66: 695413, 67: 705961, 68: 716597, 69: 727116, 70: 737624, 71: 748192, 72: 758638, 73: 769278, 74: 779669, 75: 790230, 76: 800716, 77: 811185, 78: 821778, 79: 832375, 80: 843073, 81: 853549, 82: 864100, 83: 874779, 84: 885323, 85: 895895, 86: 906511, 87: 917105, 88: 927631, 89: 938095, 90: 948489, 91: 959095, 92: 969717, 93: 980252, 94: 990739, 95: 1001403, 96: 1011882, 97: 1022456, 98: 1033085, 99: 1043714, 100: 1054298, 101: 1064896, 102: 1075432, 103: 1085941, 104: 1096476, 105: 1107095, 106: 1117655, 107: 1128221, 108: 1138823, 109: 1149366, 110: 1159813, 111: 1170303, 112: 1180777, 113: 1191222, 114: 1201780, 115: 1212307, 116: 1222939, 117: 1233468, 118: 1244060, 119: 1254630, 120: 1265318, 121: 1275935, 122: 1286535, 123: 1297072, 124: 1307672, 125: 1318262, 126: 1328696, 127: 1339195, 128: 1349714, 129: 1360257, 130: 1370762, 131: 1381238, 132: 1391867, 133: 1402494, 134: 1413196, 135: 1423737, 136: 1434217, 137: 1444700, 138: 1455314, 139: 1465872, 140: 1476347, 141: 1486905, 142: 1497461, 143: 1508026, 144: 1518535, 145: 1529057, 146: 1539606, 147: 1550092, 148: 1560684, 149: 1571176, 150: 1581746, 151: 1592332, 152: 1602936, 153: 1613409, 154: 1623920, 155: 1634507, 156: 1645046, 157: 1655550, 158: 1666151, 159: 1676813, 160: 1687433, 161: 1697994, 162: 1708486, 163: 1719112, 164: 1729726, 165: 1740211, 166: 1750742, 167: 1761178, 168: 1771717, 169: 1782206, 170: 1792673, 171: 1803218, 172: 1813786, 173: 1824409, 174: 1834945, 175: 1845532, 176: 1856025, 177: 1866591, 178: 1877142, 179: 1887597, 180: 1898158, 181: 1908663, 182: 1919275, 183: 1929733, 184: 1940239, 185: 1950770, 186: 1961295, 187: 1971752, 188: 1982234, 189: 1992654, 190: 2003155, 191: 2013628, 192: 2024114, 193: 2034669, 194: 2045242, 195: 2055701, 196: 2066207, 197: 2076810, 198: 2087380, 199: 2097883, 200: 2108462, 201: 2119079, 202: 2129552, 203: 2140004, 204: 2150560, 205: 2161086, 206: 2171510, 207: 2182062, 208: 2192681, 209: 2203173, 210: 2213803, 211: 2224287, 212: 2234749, 213: 2245322, 214: 2255887, 215: 2266459, 216: 2276972, 217: 2287377, 218: 2298032, 219: 2308493, 220: 2319014, 221: 2329524, 222: 2340084, 223: 2350650, 224: 2361263, 225: 2371673, 226: 2382154, 227: 2392685, 228: 2403286, 229: 2413910, 230: 2424585, 231: 2435110, 232: 2445628, 233: 2456141, 234: 2466584, 235: 2477090, 236: 2487636, 237: 2498197, 238: 2508733, 239: 2519309, 240: 2529893, 241: 2540351, 242: 2550987, 243: 2561432, 244: 2571992, 245: 2582527, 246: 2593105, 247: 2603689, 248: 2614212, 249: 2624715, 250: 2635233, 251: 2645823, 252: 2656385, 253: 2666891, 254: 2677403, 255: 2687912, 256: 2698459, 257: 2709041, 258: 2719577, 259: 2730183, 260: 2740687, 261: 2751215, 262: 2761768, 263: 2772161, 264: 2782669, 265: 2793127, 266: 2803630, 267: 2814115, 268: 2824652, 269: 2835252, 270: 2845859, 271: 2856361, 272: 2866899, 273: 2877481, 274: 2887952, 275: 2898522, 276: 2909032, 277: 2919638, 278: 2930097, 279: 2938476}, 't_cat_16': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 0, 16: 0, 17: 0, 18: 0, 19: 0, 20: 0, 21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0, 28: 0, 29: 0, 30: 0, 31: 0, 32: 0, 33: 0, 34: 0, 35: 0, 36: 0, 37: 0, 38: 0, 39: 0, 40: 0, 41: 0, 42: 0, 43: 0, 44: 0, 45: 0, 46: 0, 47: 0, 48: 0, 49: 0, 50: 0, 51: 0, 52: 0, 53: 0, 54: 0, 55: 0, 56: 0, 57: 0, 58: 0, 59: 0, 60: 0, 61: 0, 62: 0, 63: 0, 64: 0, 65: 0, 66: 0, 67: 0, 68: 0, 69: 0, 70: 0, 71: 0, 72: 0, 73: 0, 74: 0, 75: 0, 76: 0, 77: 0, 78: 0, 79: 0, 80: 0, 81: 0, 82: 0, 83: 0, 84: 0, 85: 0, 86: 0, 87: 0, 88: 0, 89: 0, 90: 0, 91: 0, 92: 0, 93: 0, 94: 0, 95: 0, 96: 0, 97: 0, 98: 0, 99: 0, 100: 0, 101: 0, 102: 0, 103: 0, 104: 0, 105: 0, 106: 0, 107: 0, 108: 0, 109: 0, 110: 0, 111: 0, 112: 0, 113: 0, 114: 0, 115: 0, 116: 0, 117: 0, 118: 0, 119: 0, 120: 0, 121: 0, 122: 0, 123: 0, 124: 0, 125: 0, 126: 0, 127: 0, 128: 0, 129: 0, 130: 0, 131: 0, 132: 0, 133: 0, 134: 0, 135: 0, 136: 0, 137: 0, 138: 0, 139: 0, 140: 0, 141: 0, 142: 0, 143: 0, 144: 0, 145: 0, 146: 0, 147: 0, 148: 0, 149: 0, 150: 0, 151: 0, 152: 0, 153: 0, 154: 0, 155: 0, 156: 0, 157: 0, 158: 0, 159: 0, 160: 0, 161: 0, 162: 0, 163: 0, 164: 0, 165: 0, 166: 0, 167: 0, 168: 0, 169: 0, 170: 0, 171: 0, 172: 0, 173: 0, 174: 0, 175: 0, 176: 0, 177: 0, 178: 0, 179: 0, 180: 0, 181: 0, 182: 0, 183: 0, 184: 0, 185: 0, 186: 0, 187: 0, 188: 0, 189: 0, 190: 0, 191: 0, 192: 0, 193: 0, 194: 0, 195: 0, 196: 0, 197: 0, 198: 0, 199: 0, 200: 0, 201: 0, 202: 0, 203: 0, 204: 0, 205: 0, 206: 0, 207: 0, 208: 0, 209: 0, 210: 0, 211: 0, 212: 0, 213: 0, 214: 0, 215: 0, 216: 0, 217: 0, 218: 0, 219: 0, 220: 0, 221: 0, 222: 0, 223: 0, 224: 0, 225: 0, 226: 0, 227: 0, 228: 0, 229: 0, 230: 0, 231: 0, 232: 0, 233: 0, 234: 0, 235: 0, 236: 0, 237: 0, 238: 0, 239: 0, 240: 0, 241: 0, 242: 0, 243: 0, 244: 0, 245: 0, 246: 0, 247: 0, 248: 0, 249: 0, 250: 0, 251: 0, 252: 0, 253: 0, 254: 0, 255: 0, 256: 0, 257: 0, 258: 0, 259: 0, 260: 0, 261: 0, 262: 0, 263: 0, 264: 0, 265: 0, 266: 0, 267: 0, 268: 0, 269: 0, 270: 0, 271: 0, 272: 0, 273: 0, 274: 0, 275: 0, 276: 0, 277: 0, 278: 0, 279: 0}, 't_cat_17': {0: 0, 1: 2147, 2: 4228, 3: 6407, 4: 8525, 5: 10679, 6: 12836, 7: 15006, 8: 17120, 9: 19185, 10: 21347, 11: 23466, 12: 25603, 13: 27760, 14: 29906, 15: 32000, 16: 34088, 17: 36170, 18: 38167, 19: 40318, 20: 42403, 21: 44622, 22: 46866, 23: 49006, 24: 51052, 25: 53234, 26: 55409, 27: 57603, 28: 59794, 29: 61896, 30: 64043, 31: 66171, 32: 68334, 33: 70441, 34: 72601, 35: 74714, 36: 76877, 37: 79061, 38: 81210, 39: 83374, 40: 85450, 41: 87574, 42: 89647, 43: 91790, 44: 93884, 45: 96074, 46: 98204, 47: 100360, 48: 102526, 49: 104632, 50: 106777, 51: 108930, 52: 111008, 53: 113200, 54: 115222, 55: 117357, 56: 119476, 57: 121606, 58: 123687, 59: 125776, 60: 127882, 61: 130086, 62: 132221, 63: 134341, 64: 136468, 65: 138660, 66: 140832, 67: 142987, 68: 145102, 69: 147190, 70: 149304, 71: 151439, 72: 153530, 73: 155648, 74: 157769, 75: 159860, 76: 161936, 77: 164037, 78: 166201, 79: 168370, 80: 170486, 81: 172582, 82: 174756, 83: 176867, 84: 178942, 85: 180995, 86: 183159, 87: 185304, 88: 187384, 89: 189512, 90: 191621, 91: 193726, 92: 195848, 93: 197999, 94: 200112, 95: 202196, 96: 204258, 97: 206391, 98: 208496, 99: 210606, 100: 212693, 101: 214771, 102: 216913, 103: 219061, 104: 221198, 105: 223359, 106: 225485, 107: 227635, 108: 229827, 109: 231983, 110: 234192, 111: 236232, 112: 238409, 113: 240544, 114: 242641, 115: 244694, 116: 246821, 117: 248952, 118: 251055, 119: 253139, 120: 255230, 121: 257420, 122: 259559, 123: 261725, 124: 263879, 125: 266051, 126: 268176, 127: 270284, 128: 272448, 129: 274583, 130: 276796, 131: 278950, 132: 281128, 133: 283217, 134: 285365, 135: 287555, 136: 289662, 137: 291818, 138: 293955, 139: 296060, 140: 298212, 141: 300313, 142: 302510, 143: 304692, 144: 306897, 145: 309015, 146: 311193, 147: 313299, 148: 315389, 149: 317559, 150: 319686, 151: 321881, 152: 324015, 153: 326156, 154: 328301, 155: 330437, 156: 332551, 157: 334676, 158: 336844, 159: 338959, 160: 341133, 161: 343224, 162: 345417, 163: 347578, 164: 349660, 165: 351726, 166: 353817, 167: 356001, 168: 358128, 169: 360235, 170: 362328, 171: 364429, 172: 366564, 173: 368720, 174: 370866, 175: 373014, 176: 375117, 177: 377308, 178: 379482, 179: 381621, 180: 383761, 181: 385878, 182: 388004, 183: 390118, 184: 392306, 185: 394367, 186: 396543, 187: 398728, 188: 400900, 189: 403074, 190: 405191, 191: 407316, 192: 409357, 193: 411473, 194: 413560, 195: 415745, 196: 417855, 197: 419964, 198: 422109, 199: 424256, 200: 426444, 201: 428612, 202: 430718, 203: 432765, 204: 434918, 205: 436983, 206: 439065, 207: 441199, 208: 443316, 209: 445408, 210: 447478, 211: 449730, 212: 451900, 213: 454058, 214: 456252, 215: 458420, 216: 460579, 217: 462638, 218: 464763, 219: 466902, 220: 469027, 221: 471232, 222: 473390, 223: 475507, 224: 477552, 225: 479685, 226: 481850, 227: 484023, 228: 486214, 229: 488431, 230: 490502, 231: 492643, 232: 494778, 233: 496925, 234: 499026, 235: 501200, 236: 503343, 237: 505490, 238: 507607, 239: 509750, 240: 511878, 241: 513990, 242: 516098, 243: 518226, 244: 520399, 245: 522527, 246: 524645, 247: 526819, 248: 528896, 249: 530930, 250: 533027, 251: 535213, 252: 537353, 253: 539428, 254: 541559, 255: 543645, 256: 545785, 257: 547864, 258: 549993, 259: 552187, 260: 554311, 261: 556496, 262: 558595, 263: 560780, 264: 562872, 265: 564986, 266: 567168, 267: 569244, 268: 571329, 269: 573427, 270: 575585, 271: 577755, 272: 579896, 273: 582019, 274: 584136, 275: 586295, 276: 588450, 277: 590599, 278: 592759, 279: 594401}, 't_cat_18': {0: 0, 1: 0, 2: 45, 3: 158, 4: 281, 5: 414, 6: 549, 7: 693, 8: 820, 9: 961, 10: 1087, 11: 1219, 12: 1339, 13: 1475, 14: 1621, 15: 1740, 16: 1874, 17: 2005, 18: 2140, 19: 2256, 20: 2374, 21: 2508, 22: 2633, 23: 2760, 24: 2893, 25: 3031, 26: 3183, 27: 3307, 28: 3456, 29: 3573, 30: 3691, 31: 3813, 32: 3947, 33: 4073, 34: 4205, 35: 4337, 36: 4464, 37: 4576, 38: 4682, 39: 4821, 40: 4931, 41: 5028, 42: 5156, 43: 5283, 44: 5412, 45: 5522, 46: 5627, 47: 5736, 48: 5843, 49: 5969, 50: 6088, 51: 6194, 52: 6342, 53: 6478, 54: 6596, 55: 6713, 56: 6846, 57: 6985, 58: 7101, 59: 7219, 60: 7351, 61: 7466, 62: 7598, 63: 7726, 64: 7839, 65: 7945, 66: 8068, 67: 8210, 68: 8336, 69: 8489, 70: 8620, 71: 8713, 72: 8841, 73: 8979, 74: 9109, 75: 9235, 76: 9339, 77: 9470, 78: 9603, 79: 9720, 80: 9858, 81: 9991, 82: 10097, 83: 10241, 84: 10385, 85: 10514, 86: 10642, 87: 10779, 88: 10909, 89: 11023, 90: 11142, 91: 11277, 92: 11408, 93: 11545, 94: 11661, 95: 11802, 96: 11927, 97: 12041, 98: 12161, 99: 12289, 100: 12408, 101: 12522, 102: 12666, 103: 12781, 104: 12909, 105: 13042, 106: 13183, 107: 13311, 108: 13437, 109: 13583, 110: 13713, 111: 13839, 112: 13952, 113: 14089, 114: 14208, 115: 14352, 116: 14462, 117: 14588, 118: 14715, 119: 14833, 120: 14941, 121: 15075, 122: 15198, 123: 15322, 124: 15450, 125: 15583, 126: 15746, 127: 15877, 128: 16013, 129: 16136, 130: 16256, 131: 16377, 132: 16501, 133: 16633, 134: 16748, 135: 16876, 136: 17007, 137: 17124, 138: 17227, 139: 17362, 140: 17481, 141: 17610, 142: 17763, 143: 17890, 144: 18011, 145: 18130, 146: 18242, 147: 18364, 148: 18506, 149: 18624, 150: 18731, 151: 18869, 152: 18991, 153: 19118, 154: 19253, 155: 19375, 156: 19504, 157: 19631, 158: 19762, 159: 19879, 160: 19995, 161: 20103, 162: 20219, 163: 20350, 164: 20474, 165: 20598, 166: 20726, 167: 20843, 168: 20959, 169: 21088, 170: 21230, 171: 21362, 172: 21494, 173: 21634, 174: 21753, 175: 21889, 176: 22005, 177: 22118, 178: 22249, 179: 22365, 180: 22490, 181: 22629, 182: 22760, 183: 22892, 184: 23020, 185: 23152, 186: 23285, 187: 23408, 188: 23527, 189: 23649, 190: 23769, 191: 23898, 192: 24028, 193: 24142, 194: 24266, 195: 24388, 196: 24488, 197: 24598, 198: 24725, 199: 24851, 200: 24989, 201: 25091, 202: 25200, 203: 25320, 204: 25457, 205: 25582, 206: 25700, 207: 25812, 208: 25930, 209: 26063, 210: 26186, 211: 26309, 212: 26440, 213: 26535, 214: 26673, 215: 26791, 216: 26900, 217: 27040, 218: 27170, 219: 27279, 220: 27404, 221: 27537, 222: 27649, 223: 27778, 224: 27919, 225: 28048, 226: 28168, 227: 28303, 228: 28424, 229: 28561, 230: 28690, 231: 28804, 232: 28938, 233: 29057, 234: 29182, 235: 29298, 236: 29404, 237: 29529, 238: 29679, 239: 29824, 240: 29934, 241: 30055, 242: 30192, 243: 30323, 244: 30435, 245: 30559, 246: 30689, 247: 30818, 248: 30935, 249: 31069, 250: 31198, 251: 31328, 252: 31461, 253: 31596, 254: 31737, 255: 31870, 256: 32017, 257: 32148, 258: 32278, 259: 32402, 260: 32513, 261: 32623, 262: 32756, 263: 32889, 264: 33012, 265: 33142, 266: 33254, 267: 33382, 268: 33514, 269: 33663, 270: 33791, 271: 33923, 272: 34052, 273: 34161, 274: 34300, 275: 34432, 276: 34559, 277: 34667, 278: 34799, 279: 34908}, 't_cat_19': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 0, 16: 0, 17: 0, 18: 0, 19: 0, 20: 0, 21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0, 28: 0, 29: 0, 30: 0, 31: 0, 32: 0, 33: 0, 34: 0, 35: 0, 36: 0, 37: 0, 38: 0, 39: 0, 40: 0, 41: 0, 42: 0, 43: 0, 44: 0, 45: 0, 46: 0, 47: 0, 48: 0, 49: 0, 50: 0, 51: 0, 52: 0, 53: 0, 54: 0, 55: 0, 56: 0, 57: 0, 58: 0, 59: 0, 60: 0, 61: 0, 62: 0, 63: 0, 64: 0, 65: 0, 66: 0, 67: 0, 68: 0, 69: 0, 70: 0, 71: 0, 72: 0, 73: 0, 74: 0, 75: 0, 76: 0, 77: 0, 78: 0, 79: 0, 80: 0, 81: 0, 82: 0, 83: 0, 84: 0, 85: 0, 86: 0, 87: 0, 88: 0, 89: 0, 90: 0, 91: 0, 92: 0, 93: 0, 94: 0, 95: 0, 96: 0, 97: 0, 98: 0, 99: 0, 100: 0, 101: 0, 102: 0, 103: 0, 104: 0, 105: 0, 106: 0, 107: 0, 108: 0, 109: 0, 110: 0, 111: 0, 112: 0, 113: 0, 114: 0, 115: 0, 116: 0, 117: 0, 118: 0, 119: 0, 120: 0, 121: 0, 122: 0, 123: 0, 124: 0, 125: 0, 126: 0, 127: 0, 128: 0, 129: 0, 130: 0, 131: 0, 132: 0, 133: 0, 134: 0, 135: 0, 136: 0, 137: 0, 138: 0, 139: 0, 140: 0, 141: 0, 142: 0, 143: 0, 144: 0, 145: 0, 146: 0, 147: 0, 148: 0, 149: 0, 150: 0, 151: 0, 152: 0, 153: 0, 154: 0, 155: 0, 156: 0, 157: 0, 158: 0, 159: 0, 160: 0, 161: 0, 162: 0, 163: 0, 164: 0, 165: 0, 166: 0, 167: 0, 168: 0, 169: 0, 170: 0, 171: 0, 172: 0, 173: 0, 174: 0, 175: 0, 176: 0, 177: 0, 178: 0, 179: 0, 180: 0, 181: 0, 182: 0, 183: 0, 184: 0, 185: 0, 186: 0, 187: 0, 188: 0, 189: 0, 190: 0, 191: 0, 192: 0, 193: 0, 194: 0, 195: 0, 196: 0, 197: 0, 198: 0, 199: 0, 200: 0, 201: 0, 202: 0, 203: 0, 204: 0, 205: 0, 206: 0, 207: 0, 208: 0, 209: 0, 210: 0, 211: 0, 212: 0, 213: 0, 214: 0, 215: 0, 216: 0, 217: 0, 218: 0, 219: 0, 220: 0, 221: 0, 222: 0, 223: 0, 224: 0, 225: 0, 226: 0, 227: 0, 228: 0, 229: 0, 230: 0, 231: 0, 232: 0, 233: 0, 234: 0, 235: 0, 236: 0, 237: 0, 238: 0, 239: 0, 240: 0, 241: 0, 242: 0, 243: 0, 244: 0, 245: 0, 246: 0, 247: 0, 248: 0, 249: 0, 250: 0, 251: 0, 252: 0, 253: 0, 254: 0, 255: 0, 256: 0, 257: 0, 258: 0, 259: 0, 260: 0, 261: 0, 262: 0, 263: 0, 264: 0, 265: 0, 266: 0, 267: 0, 268: 0, 269: 0, 270: 0, 271: 0, 272: 0, 273: 0, 274: 0, 275: 0, 276: 0, 277: 0, 278: 0, 279: 0}, 't_cat_20': {0: 0, 1: 10696, 2: 21314, 3: 31964, 4: 42502, 5: 53128, 6: 63795, 7: 74580, 8: 85346, 9: 96035, 10: 106756, 11: 117530, 12: 128276, 13: 139035, 14: 149751, 15: 160587, 16: 171250, 17: 181987, 18: 192708, 19: 203438, 20: 214207, 21: 224861, 22: 235533, 23: 246200, 24: 256906, 25: 267666, 26: 278377, 27: 289100, 28: 299773, 29: 310356, 30: 321115, 31: 331880, 32: 342534, 33: 353304, 34: 363954, 35: 374726, 36: 385372, 37: 396066, 38: 406794, 39: 417509, 40: 428144, 41: 438862, 42: 449420, 43: 460215, 44: 470836, 45: 481472, 46: 492075, 47: 502791, 48: 513556, 49: 524260, 50: 534843, 51: 545499, 52: 556161, 53: 566792, 54: 577436, 55: 588145, 56: 598702, 57: 609383, 58: 620057, 59: 630748, 60: 641533, 61: 652251, 62: 662982, 63: 673712, 64: 684371, 65: 695032, 66: 705614, 67: 716280, 68: 727050, 69: 737765, 70: 748439, 71: 759156, 72: 769774, 73: 780566, 74: 791099, 75: 801834, 76: 812456, 77: 823045, 78: 833799, 79: 844577, 80: 855353, 81: 865982, 82: 876740, 83: 887502, 84: 898190, 85: 908873, 86: 919604, 87: 930352, 88: 941046, 89: 951642, 90: 962265, 91: 972980, 92: 983693, 93: 994410, 94: 1005061, 95: 1015769, 96: 1026434, 97: 1037183, 98: 1047885, 99: 1058587, 100: 1069297, 101: 1079999, 102: 1090744, 103: 1101387, 104: 1112183, 105: 1122908, 106: 1133628, 107: 1144392, 108: 1155176, 109: 1165855, 110: 1176491, 111: 1187177, 112: 1197797, 113: 1208446, 114: 1219156, 115: 1229836, 116: 1240621, 117: 1251313, 118: 1262079, 119: 1272738, 120: 1283466, 121: 1294320, 122: 1305100, 123: 1315820, 124: 1326566, 125: 1337228, 126: 1347859, 127: 1358529, 128: 1369224, 129: 1379808, 130: 1390600, 131: 1401218, 132: 1411984, 133: 1422799, 134: 1433617, 135: 1444284, 136: 1454988, 137: 1465607, 138: 1476354, 139: 1487045, 140: 1497691, 141: 1508370, 142: 1519125, 143: 1529812, 144: 1540431, 145: 1551145, 146: 1561820, 147: 1572520, 148: 1583278, 149: 1593857, 150: 1604493, 151: 1615174, 152: 1625985, 153: 1636837, 154: 1647528, 155: 1658258, 156: 1669007, 157: 1679662, 158: 1690433, 159: 1701146, 160: 1711896, 161: 1722636, 162: 1733272, 163: 1744069, 164: 1754720, 165: 1765325, 166: 1775938, 167: 1786591, 168: 1797282, 169: 1807876, 170: 1818472, 171: 1829195, 172: 1839937, 173: 1850750, 174: 1861487, 175: 1872220, 176: 1882907, 177: 1893590, 178: 1904307, 179: 1914867, 180: 1925597, 181: 1936248, 182: 1946927, 183: 1957592, 184: 1968265, 185: 1978922, 186: 1989523, 187: 2000182, 188: 2010785, 189: 2021433, 190: 2032107, 191: 2042711, 192: 2053392, 193: 2064088, 194: 2074732, 195: 2085327, 196: 2095971, 197: 2106830, 198: 2117610, 199: 2128325, 200: 2139000, 201: 2149762, 202: 2160459, 203: 2171177, 204: 2181906, 205: 2192513, 206: 2203181, 207: 2213917, 208: 2224616, 209: 2235296, 210: 2246000, 211: 2256741, 212: 2267440, 213: 2278221, 214: 2288918, 215: 2299556, 216: 2310241, 217: 2320889, 218: 2331677, 219: 2342326, 220: 2353098, 221: 2363734, 222: 2374526, 223: 2385232, 224: 2395976, 225: 2406599, 226: 2417228, 227: 2427858, 228: 2438485, 229: 2449243, 230: 2459927, 231: 2470702, 232: 2481267, 233: 2491910, 234: 2502499, 235: 2513276, 236: 2523952, 237: 2534619, 238: 2545264, 239: 2555987, 240: 2566688, 241: 2577215, 242: 2587945, 243: 2598593, 244: 2609264, 245: 2619997, 246: 2630693, 247: 2641461, 248: 2652196, 249: 2662908, 250: 2673517, 251: 2684250, 252: 2694888, 253: 2705586, 254: 2716288, 255: 2726943, 256: 2737673, 257: 2748411, 258: 2759122, 259: 2769901, 260: 2780510, 261: 2791160, 262: 2801746, 263: 2812327, 264: 2823016, 265: 2833699, 266: 2844276, 267: 2855039, 268: 2865630, 269: 2876311, 270: 2886996, 271: 2897637, 272: 2908277, 273: 2919052, 274: 2929678, 275: 2940407, 276: 2951030, 277: 2961697, 278: 2972315, 279: 2980819}, 't_cat_21': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 0, 16: 0, 17: 0, 18: 0, 19: 0, 20: 0, 21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0, 28: 0, 29: 0, 30: 0, 31: 0, 32: 0, 33: 0, 34: 0, 35: 0, 36: 0, 37: 0, 38: 0, 39: 0, 40: 0, 41: 0, 42: 0, 43: 0, 44: 0, 45: 0, 46: 0, 47: 0, 48: 0, 49: 0, 50: 0, 51: 0, 52: 0, 53: 0, 54: 0, 55: 0, 56: 0, 57: 0, 58: 0, 59: 0, 60: 0, 61: 0, 62: 0, 63: 0, 64: 0, 65: 0, 66: 0, 67: 0, 68: 0, 69: 0, 70: 0, 71: 0, 72: 0, 73: 0, 74: 0, 75: 0, 76: 0, 77: 0, 78: 0, 79: 0, 80: 0, 81: 0, 82: 0, 83: 0, 84: 0, 85: 0, 86: 0, 87: 0, 88: 0, 89: 0, 90: 0, 91: 0, 92: 0, 93: 0, 94: 0, 95: 0, 96: 0, 97: 0, 98: 0, 99: 0, 100: 0, 101: 0, 102: 0, 103: 0, 104: 0, 105: 0, 106: 0, 107: 0, 108: 0, 109: 0, 110: 0, 111: 0, 112: 0, 113: 0, 114: 0, 115: 0, 116: 0, 117: 0, 118: 0, 119: 0, 120: 0, 121: 0, 122: 0, 123: 0, 124: 0, 125: 0, 126: 0, 127: 0, 128: 0, 129: 0, 130: 0, 131: 0, 132: 0, 133: 0, 134: 0, 135: 0, 136: 0, 137: 0, 138: 0, 139: 0, 140: 0, 141: 0, 142: 0, 143: 0, 144: 0, 145: 0, 146: 0, 147: 0, 148: 0, 149: 0, 150: 0, 151: 0, 152: 0, 153: 0, 154: 0, 155: 0, 156: 0, 157: 0, 158: 0, 159: 0, 160: 0, 161: 0, 162: 0, 163: 0, 164: 0, 165: 0, 166: 0, 167: 0, 168: 0, 169: 0, 170: 0, 171: 0, 172: 0, 173: 0, 174: 0, 175: 0, 176: 0, 177: 0, 178: 0, 179: 0, 180: 0, 181: 0, 182: 0, 183: 0, 184: 0, 185: 0, 186: 0, 187: 0, 188: 0, 189: 0, 190: 0, 191: 0, 192: 0, 193: 0, 194: 0, 195: 0, 196: 0, 197: 0, 198: 0, 199: 0, 200: 0, 201: 0, 202: 0, 203: 0, 204: 0, 205: 0, 206: 0, 207: 0, 208: 0, 209: 0, 210: 0, 211: 0, 212: 0, 213: 0, 214: 0, 215: 0, 216: 0, 217: 0, 218: 0, 219: 0, 220: 0, 221: 0, 222: 0, 223: 0, 224: 0, 225: 0, 226: 0, 227: 0, 228: 0, 229: 0, 230: 0, 231: 0, 232: 0, 233: 0, 234: 0, 235: 0, 236: 0, 237: 0, 238: 0, 239: 0, 240: 0, 241: 0, 242: 0, 243: 0, 244: 0, 245: 0, 246: 0, 247: 0, 248: 0, 249: 0, 250: 0, 251: 0, 252: 0, 253: 0, 254: 0, 255: 0, 256: 0, 257: 0, 258: 0, 259: 0, 260: 0, 261: 0, 262: 0, 263: 0, 264: 0, 265: 0, 266: 0, 267: 0, 268: 0, 269: 0, 270: 0, 271: 0, 272: 0, 273: 0, 274: 0, 275: 0, 276: 0, 277: 0, 278: 0, 279: 0}, 't_cat_22': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 0, 16: 0, 17: 0, 18: 0, 19: 0, 20: 0, 21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0, 28: 0, 29: 0, 30: 0, 31: 0, 32: 0, 33: 0, 34: 0, 35: 0, 36: 0, 37: 0, 38: 0, 39: 0, 40: 0, 41: 0, 42: 0, 43: 0, 44: 0, 45: 0, 46: 0, 47: 0, 48: 0, 49: 0, 50: 0, 51: 0, 52: 0, 53: 0, 54: 0, 55: 0, 56: 0, 57: 0, 58: 0, 59: 0, 60: 0, 61: 0, 62: 0, 63: 0, 64: 0, 65: 0, 66: 0, 67: 0, 68: 0, 69: 0, 70: 0, 71: 0, 72: 0, 73: 0, 74: 0, 75: 0, 76: 0, 77: 0, 78: 0, 79: 0, 80: 0, 81: 0, 82: 0, 83: 0, 84: 0, 85: 0, 86: 0, 87: 0, 88: 0, 89: 0, 90: 0, 91: 0, 92: 0, 93: 0, 94: 0, 95: 0, 96: 0, 97: 0, 98: 0, 99: 0, 100: 0, 101: 0, 102: 0, 103: 0, 104: 0, 105: 0, 106: 0, 107: 0, 108: 0, 109: 0, 110: 0, 111: 0, 112: 0, 113: 0, 114: 0, 115: 0, 116: 0, 117: 0, 118: 0, 119: 0, 120: 0, 121: 0, 122: 0, 123: 0, 124: 0, 125: 0, 126: 0, 127: 0, 128: 0, 129: 0, 130: 0, 131: 0, 132: 0, 133: 0, 134: 0, 135: 0, 136: 0, 137: 0, 138: 0, 139: 0, 140: 0, 141: 0, 142: 0, 143: 0, 144: 0, 145: 0, 146: 0, 147: 0, 148: 0, 149: 0, 150: 0, 151: 0, 152: 0, 153: 0, 154: 0, 155: 0, 156: 0, 157: 0, 158: 0, 159: 0, 160: 0, 161: 0, 162: 0, 163: 0, 164: 0, 165: 0, 166: 0, 167: 0, 168: 0, 169: 0, 170: 0, 171: 0, 172: 0, 173: 0, 174: 0, 175: 0, 176: 0, 177: 0, 178: 0, 179: 0, 180: 0, 181: 0, 182: 0, 183: 0, 184: 0, 185: 0, 186: 0, 187: 0, 188: 0, 189: 0, 190: 0, 191: 0, 192: 0, 193: 0, 194: 0, 195: 0, 196: 0, 197: 0, 198: 0, 199: 0, 200: 0, 201: 0, 202: 0, 203: 0, 204: 0, 205: 0, 206: 0, 207: 0, 208: 0, 209: 0, 210: 0, 211: 0, 212: 0, 213: 0, 214: 0, 215: 0, 216: 0, 217: 0, 218: 0, 219: 0, 220: 0, 221: 0, 222: 0, 223: 0, 224: 0, 225: 0, 226: 0, 227: 0, 228: 0, 229: 0, 230: 0, 231: 0, 232: 0, 233: 0, 234: 0, 235: 0, 236: 0, 237: 0, 238: 0, 239: 0, 240: 0, 241: 0, 242: 0, 243: 0, 244: 0, 245: 0, 246: 0, 247: 0, 248: 0, 249: 0, 250: 0, 251: 0, 252: 0, 253: 0, 254: 0, 255: 0, 256: 0, 257: 0, 258: 0, 259: 0, 260: 0, 261: 0, 262: 0, 263: 0, 264: 0, 265: 0, 266: 0, 267: 0, 268: 0, 269: 0, 270: 0, 271: 0, 272: 0, 273: 0, 274: 0, 275: 0, 276: 0, 277: 0, 278: 0, 279: 0}, 't_cat_23': {0: 0, 1: 5880, 2: 11573, 3: 17430, 4: 23163, 5: 28955, 6: 34701, 7: 40593, 8: 46458, 9: 52191, 10: 58059, 11: 63943, 12: 69748, 13: 75644, 14: 81565, 15: 87429, 16: 93169, 17: 99065, 18: 104893, 19: 110867, 20: 116709, 21: 122497, 22: 128371, 23: 134242, 24: 140019, 25: 145900, 26: 151776, 27: 157557, 28: 163519, 29: 169338, 30: 175233, 31: 181090, 32: 186786, 33: 192646, 34: 198428, 35: 204169, 36: 210006, 37: 215809, 38: 221640, 39: 227390, 40: 233130, 41: 238953, 42: 244717, 43: 250514, 44: 256310, 45: 262015, 46: 267780, 47: 273590, 48: 279457, 49: 285263, 50: 290979, 51: 296796, 52: 302611, 53: 308354, 54: 314111, 55: 319938, 56: 325698, 57: 331383, 58: 337227, 59: 342996, 60: 348771, 61: 354563, 62: 360451, 63: 366236, 64: 371985, 65: 377810, 66: 383685, 67: 389512, 68: 395423, 69: 401259, 70: 407091, 71: 412852, 72: 418615, 73: 424484, 74: 430115, 75: 435844, 76: 441623, 77: 447449, 78: 453268, 79: 459181, 80: 465215, 81: 471011, 82: 476921, 83: 482753, 84: 488514, 85: 494254, 86: 500064, 87: 505983, 88: 511766, 89: 517562, 90: 523310, 91: 529080, 92: 534893, 93: 540737, 94: 546439, 95: 552281, 96: 557979, 97: 563807, 98: 569576, 99: 575387, 100: 581076, 101: 586900, 102: 592701, 103: 598424, 104: 604228, 105: 610138, 106: 615955, 107: 621807, 108: 627661, 109: 633407, 110: 639275, 111: 645052, 112: 650823, 113: 656588, 114: 662380, 115: 668136, 116: 673938, 117: 679650, 118: 685489, 119: 691293, 120: 697154, 121: 703150, 122: 709070, 123: 714901, 124: 720743, 125: 726476, 126: 732246, 127: 737997, 128: 743769, 129: 749648, 130: 755555, 131: 761264, 132: 767089, 133: 772951, 134: 778839, 135: 784661, 136: 790424, 137: 796267, 138: 802147, 139: 807922, 140: 813758, 141: 819372, 142: 825276, 143: 831036, 144: 836806, 145: 842661, 146: 848474, 147: 854314, 148: 860253, 149: 866057, 150: 871888, 151: 877740, 152: 883600, 153: 889510, 154: 895322, 155: 901160, 156: 907037, 157: 912774, 158: 918597, 159: 924430, 160: 930276, 161: 936094, 162: 941799, 163: 947618, 164: 953328, 165: 959047, 166: 964822, 167: 970555, 168: 976397, 169: 982148, 170: 987841, 171: 993664, 172: 999626, 173: 1005519, 174: 1011422, 175: 1017234, 176: 1023052, 177: 1028987, 178: 1034892, 179: 1040576, 180: 1046494, 181: 1052363, 182: 1058150, 183: 1063929, 184: 1069773, 185: 1075566, 186: 1081280, 187: 1086985, 188: 1092676, 189: 1098433, 190: 1104169, 191: 1110007, 192: 1115765, 193: 1121542, 194: 1127259, 195: 1133077, 196: 1138918, 197: 1144705, 198: 1150480, 199: 1156366, 200: 1162267, 201: 1168155, 202: 1174040, 203: 1179784, 204: 1185589, 205: 1191454, 206: 1197242, 207: 1203095, 208: 1208832, 209: 1214573, 210: 1220495, 211: 1226364, 212: 1232051, 213: 1237912, 214: 1243718, 215: 1249454, 216: 1255272, 217: 1261078, 218: 1266934, 219: 1272698, 220: 1278452, 221: 1284293, 222: 1290099, 223: 1296023, 224: 1301920, 225: 1307665, 226: 1313491, 227: 1319289, 228: 1325151, 229: 1330977, 230: 1336825, 231: 1342679, 232: 1348483, 233: 1354310, 234: 1360032, 235: 1365881, 236: 1371643, 237: 1377442, 238: 1383168, 239: 1388982, 240: 1394706, 241: 1400451, 242: 1406231, 243: 1412071, 244: 1417813, 245: 1423591, 246: 1429451, 247: 1435361, 248: 1441229, 249: 1447021, 250: 1452807, 251: 1458620, 252: 1464378, 253: 1470213, 254: 1475992, 255: 1481754, 256: 1487684, 257: 1493557, 258: 1499436, 259: 1505310, 260: 1511019, 261: 1516850, 262: 1522633, 263: 1528419, 264: 1534156, 265: 1540008, 266: 1545751, 267: 1551585, 268: 1557377, 269: 1563264, 270: 1569117, 271: 1574878, 272: 1580713, 273: 1586541, 274: 1592434, 275: 1598367, 276: 1604031, 277: 1609892, 278: 1615563, 279: 1620202}, 't_cat_24': {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 0, 16: 0, 17: 0, 18: 0, 19: 0, 20: 0, 21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0, 28: 0, 29: 0, 30: 0, 31: 0, 32: 0, 33: 0, 34: 0, 35: 0, 36: 0, 37: 0, 38: 0, 39: 0, 40: 0, 41: 0, 42: 0, 43: 0, 44: 0, 45: 0, 46: 0, 47: 0, 48: 0, 49: 0, 50: 0, 51: 0, 52: 0, 53: 0, 54: 0, 55: 0, 56: 0, 57: 0, 58: 0, 59: 0, 60: 0, 61: 0, 62: 0, 63: 0, 64: 0, 65: 0, 66: 0, 67: 0, 68: 0, 69: 0, 70: 0, 71: 0, 72: 0, 73: 0, 74: 0, 75: 0, 76: 0, 77: 0, 78: 0, 79: 0, 80: 0, 81: 0, 82: 0, 83: 0, 84: 0, 85: 0, 86: 0, 87: 0, 88: 0, 89: 0, 90: 0, 91: 0, 92: 0, 93: 0, 94: 0, 95: 0, 96: 0, 97: 0, 98: 0, 99: 0, 100: 0, 101: 0, 102: 0, 103: 0, 104: 0, 105: 0, 106: 0, 107: 0, 108: 0, 109: 0, 110: 0, 111: 0, 112: 0, 113: 0, 114: 0, 115: 0, 116: 0, 117: 0, 118: 0, 119: 0, 120: 0, 121: 0, 122: 0, 123: 0, 124: 0, 125: 0, 126: 0, 127: 0, 128: 0, 129: 0, 130: 0, 131: 0, 132: 0, 133: 0, 134: 0, 135: 0, 136: 0, 137: 0, 138: 0, 139: 0, 140: 0, 141: 0, 142: 0, 143: 0, 144: 0, 145: 0, 146: 0, 147: 0, 148: 0, 149: 0, 150: 0, 151: 0, 152: 0, 153: 0, 154: 0, 155: 0, 156: 0, 157: 0, 158: 0, 159: 0, 160: 0, 161: 0, 162: 0, 163: 0, 164: 0, 165: 0, 166: 0, 167: 0, 168: 0, 169: 0, 170: 0, 171: 0, 172: 0, 173: 0, 174: 0, 175: 0, 176: 0, 177: 0, 178: 0, 179: 0, 180: 0, 181: 0, 182: 0, 183: 0, 184: 0, 185: 0, 186: 0, 187: 0, 188: 0, 189: 0, 190: 0, 191: 0, 192: 0, 193: 0, 194: 0, 195: 0, 196: 0, 197: 0, 198: 0, 199: 0, 200: 0, 201: 0, 202: 0, 203: 0, 204: 0, 205: 0, 206: 0, 207: 0, 208: 0, 209: 0, 210: 0, 211: 0, 212: 0, 213: 0, 214: 0, 215: 0, 216: 0, 217: 0, 218: 0, 219: 0, 220: 0, 221: 0, 222: 0, 223: 0, 224: 0, 225: 0, 226: 0, 227: 0, 228: 0, 229: 0, 230: 0, 231: 0, 232: 0, 233: 0, 234: 0, 235: 0, 236: 0, 237: 0, 238: 0, 239: 0, 240: 0, 241: 0, 242: 0, 243: 0, 244: 0, 245: 0, 246: 0, 247: 0, 248: 0, 249: 0, 250: 0, 251: 0, 252: 0, 253: 0, 254: 0, 255: 0, 256: 0, 257: 0, 258: 0, 259: 0, 260: 0, 261: 0, 262: 0, 263: 0, 264: 0, 265: 0, 266: 0, 267: 0, 268: 0, 269: 0, 270: 0, 271: 0, 272: 0, 273: 0, 274: 0, 275: 0, 276: 0, 277: 0, 278: 0, 279: 0}, 't_cat_25': {0: 0, 1: 3718, 2: 7263, 3: 10860, 4: 14497, 5: 18105, 6: 21748, 7: 25419, 8: 29064, 9: 32669, 10: 36292, 11: 39946, 12: 43590, 13: 47289, 14: 50939, 15: 54670, 16: 58342, 17: 62018, 18: 65769, 19: 69493, 20: 73217, 21: 76852, 22: 80598, 23: 84327, 24: 87966, 25: 91620, 26: 95414, 27: 99016, 28: 102656, 29: 106356, 30: 110018, 31: 113768, 32: 117486, 33: 121157, 34: 124892, 35: 128582, 36: 132191, 37: 135809, 38: 139421, 39: 143030, 40: 146689, 41: 150376, 42: 153977, 43: 157574, 44: 161213, 45: 164878, 46: 168598, 47: 172251, 48: 175898, 49: 179573, 50: 183212, 51: 186808, 52: 190557, 53: 194226, 54: 197873, 55: 201548, 56: 205118, 57: 208845, 58: 212525, 59: 216157, 60: 219814, 61: 223429, 62: 227084, 63: 230730, 64: 234368, 65: 238031, 66: 241723, 67: 245375, 68: 249049, 69: 252756, 70: 256315, 71: 259907, 72: 263545, 73: 267289, 74: 270846, 75: 274507, 76: 278207, 77: 281892, 78: 285572, 79: 289198, 80: 292889, 81: 296535, 82: 300223, 83: 303948, 84: 307563, 85: 311267, 86: 314947, 87: 318623, 88: 322282, 89: 325979, 90: 329629, 91: 333231, 92: 336848, 93: 340488, 94: 344025, 95: 347778, 96: 351456, 97: 355182, 98: 358768, 99: 362514, 100: 366165, 101: 369778, 102: 373395, 103: 376963, 104: 380617, 105: 384253, 106: 387834, 107: 391431, 108: 395069, 109: 398741, 110: 402367, 111: 406026, 112: 409680, 113: 413322, 114: 416861, 115: 420501, 116: 424153, 117: 427747, 118: 431368, 119: 434999, 120: 438803, 121: 442628, 122: 446371, 123: 449993, 124: 453693, 125: 457330, 126: 460922, 127: 464508, 128: 468076, 129: 471743, 130: 475309, 131: 478920, 132: 482563, 133: 486255, 134: 489943, 135: 493529, 136: 497192, 137: 500846, 138: 504481, 139: 508035, 140: 511685, 141: 515284, 142: 518929, 143: 522564, 144: 526192, 145: 529876, 146: 533483, 147: 537125, 148: 540702, 149: 544378, 150: 548017, 151: 551703, 152: 555427, 153: 559076, 154: 562786, 155: 566402, 156: 570073, 157: 573715, 158: 577344, 159: 581020, 160: 584788, 161: 588471, 162: 592128, 163: 595826, 164: 599370, 165: 603011, 166: 606615, 167: 610324, 168: 613926, 169: 617580, 170: 621203, 171: 624783, 172: 628510, 173: 632266, 174: 635953, 175: 639525, 176: 643202, 177: 646864, 178: 650599, 179: 654128, 180: 657797, 181: 661482, 182: 665124, 183: 668811, 184: 672484, 185: 676222, 186: 679885, 187: 683482, 188: 687150, 189: 690749, 190: 694410, 191: 698103, 192: 701763, 193: 705450, 194: 709057, 195: 712676, 196: 716309, 197: 719942, 198: 723632, 199: 727283, 200: 730989, 201: 734767, 202: 738344, 203: 741998, 204: 745726, 205: 749365, 206: 752915, 207: 756513, 208: 760127, 209: 763775, 210: 767412, 211: 771022, 212: 774664, 213: 778297, 214: 781928, 215: 785513, 216: 789116, 217: 792777, 218: 796443, 219: 800099, 220: 803733, 221: 807340, 222: 810977, 223: 814547, 224: 818252, 225: 821912, 226: 825534, 227: 829177, 228: 832797, 229: 836435, 230: 840173, 231: 843880, 232: 847467, 233: 851141, 234: 854690, 235: 858332, 236: 861904, 237: 865519, 238: 869184, 239: 872901, 240: 876464, 241: 880015, 242: 883673, 243: 887434, 244: 891077, 245: 894703, 246: 898382, 247: 902091, 248: 905754, 249: 909354, 250: 912992, 251: 916639, 252: 920334, 253: 923934, 254: 927514, 255: 931166, 256: 934740, 257: 938357, 258: 941969, 259: 945583, 260: 949174, 261: 952768, 262: 956403, 263: 960043, 264: 963730, 265: 967398, 266: 970933, 267: 974618, 268: 978259, 269: 981945, 270: 985658, 271: 989285, 272: 993004, 273: 996639, 274: 1000263, 275: 1003958, 276: 1007603, 277: 1011194, 278: 1014866, 279: 1017761}}\n", + "{'t_cat_0': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_1': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_2': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_3': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_4': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_5': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_6': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_7': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_8': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_9': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_10': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_11': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_12': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_13': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_14': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_15': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_16': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_17': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_18': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_19': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_20': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_21': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_22': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_23': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_24': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}, 't_cat_25': {0: 16384, 1: 32768, 2: 49152, 3: 65536, 4: 81920, 5: 98304, 6: 114688, 7: 131072, 8: 147456, 9: 163840, 10: 180224, 11: 196608, 12: 212992, 13: 229376, 14: 245760, 15: 262144, 16: 278528, 17: 294912, 18: 311296, 19: 327680, 20: 344064, 21: 360448, 22: 376832, 23: 393216, 24: 409600, 25: 425984, 26: 442368, 27: 458752, 28: 475136, 29: 491520, 30: 507904, 31: 524288, 32: 540672, 33: 557056, 34: 573440, 35: 589824, 36: 606208, 37: 622592, 38: 638976, 39: 655360, 40: 671744, 41: 688128, 42: 704512, 43: 720896, 44: 737280, 45: 753664, 46: 770048, 47: 786432, 48: 802816, 49: 819200, 50: 835584, 51: 851968, 52: 868352, 53: 884736, 54: 901120, 55: 917504, 56: 933888, 57: 950272, 58: 966656, 59: 983040, 60: 999424, 61: 1015808, 62: 1032192, 63: 1048576, 64: 1064960, 65: 1081344, 66: 1097728, 67: 1114112, 68: 1130496, 69: 1146880, 70: 1163264, 71: 1179648, 72: 1196032, 73: 1212416, 74: 1228800, 75: 1245184, 76: 1261568, 77: 1277952, 78: 1294336, 79: 1310720, 80: 1327104, 81: 1343488, 82: 1359872, 83: 1376256, 84: 1392640, 85: 1409024, 86: 1425408, 87: 1441792, 88: 1458176, 89: 1474560, 90: 1490944, 91: 1507328, 92: 1523712, 93: 1540096, 94: 1556480, 95: 1572864, 96: 1589248, 97: 1605632, 98: 1622016, 99: 1638400, 100: 1654784, 101: 1671168, 102: 1687552, 103: 1703936, 104: 1720320, 105: 1736704, 106: 1753088, 107: 1769472, 108: 1785856, 109: 1802240, 110: 1818624, 111: 1835008, 112: 1851392, 113: 1867776, 114: 1884160, 115: 1900544, 116: 1916928, 117: 1933312, 118: 1949696, 119: 1966080, 120: 1982464, 121: 1998848, 122: 2015232, 123: 2031616, 124: 2048000, 125: 2064384, 126: 2080768, 127: 2097152, 128: 2113536, 129: 2129920, 130: 2146304, 131: 2162688, 132: 2179072, 133: 2195456, 134: 2211840, 135: 2228224, 136: 2244608, 137: 2260992, 138: 2277376, 139: 2293760, 140: 2310144, 141: 2326528, 142: 2342912, 143: 2359296, 144: 2375680, 145: 2392064, 146: 2408448, 147: 2424832, 148: 2441216, 149: 2457600, 150: 2473984, 151: 2490368, 152: 2506752, 153: 2523136, 154: 2539520, 155: 2555904, 156: 2572288, 157: 2588672, 158: 2605056, 159: 2621440, 160: 2637824, 161: 2654208, 162: 2670592, 163: 2686976, 164: 2703360, 165: 2719744, 166: 2736128, 167: 2752512, 168: 2768896, 169: 2785280, 170: 2801664, 171: 2818048, 172: 2834432, 173: 2850816, 174: 2867200, 175: 2883584, 176: 2899968, 177: 2916352, 178: 2932736, 179: 2949120, 180: 2965504, 181: 2981888, 182: 2998272, 183: 3014656, 184: 3031040, 185: 3047424, 186: 3063808, 187: 3080192, 188: 3096576, 189: 3112960, 190: 3129344, 191: 3145728, 192: 3162112, 193: 3178496, 194: 3194880, 195: 3211264, 196: 3227648, 197: 3244032, 198: 3260416, 199: 3276800, 200: 3293184, 201: 3309568, 202: 3325952, 203: 3342336, 204: 3358720, 205: 3375104, 206: 3391488, 207: 3407872, 208: 3424256, 209: 3440640, 210: 3457024, 211: 3473408, 212: 3489792, 213: 3506176, 214: 3522560, 215: 3538944, 216: 3555328, 217: 3571712, 218: 3588096, 219: 3604480, 220: 3620864, 221: 3637248, 222: 3653632, 223: 3670016, 224: 3686400, 225: 3702784, 226: 3719168, 227: 3735552, 228: 3751936, 229: 3768320, 230: 3784704, 231: 3801088, 232: 3817472, 233: 3833856, 234: 3850240, 235: 3866624, 236: 3883008, 237: 3899392, 238: 3915776, 239: 3932160, 240: 3948544, 241: 3964928, 242: 3981312, 243: 3997696, 244: 4014080, 245: 4030464, 246: 4046848, 247: 4063232, 248: 4079616, 249: 4096000, 250: 4112384, 251: 4128768, 252: 4145152, 253: 4161536, 254: 4177920, 255: 4194304, 256: 4210688, 257: 4227072, 258: 4243456, 259: 4259840, 260: 4276224, 261: 4292608, 262: 4308992, 263: 4325376, 264: 4341760, 265: 4358144, 266: 4374528, 267: 4390912, 268: 4407296, 269: 4423680, 270: 4440064, 271: 4456448, 272: 4472832, 273: 4489216, 274: 4505600, 275: 4521984, 276: 4538368, 277: 4554752, 278: 4571136, 279: 4584059}}\n" + ] + } + ], + "source": [ + "# maintain a dictionary of {feature_name: {batch_idx: accumulated_collision_over_all_ranks_at_batch_idx}}\n", + "feature_name_accumulated_collision_count_dict = {}\n", + "feature_name_accumulated_total_count_dict = {}\n", + "for index, row in df_zch_stats.iterrows():\n", + " feature_name = row[\"feature_name\"]\n", + " batch_idx = row[\"batch_idx\"]\n", + " collision_cnt = row[\"collision_cnt\"]\n", + " total_cnt = row[\"total_cnt\"]\n", + " if feature_name not in feature_name_accumulated_collision_count_dict:\n", + " feature_name_accumulated_collision_count_dict[feature_name] = {}\n", + " if batch_idx not in feature_name_accumulated_collision_count_dict[feature_name]:\n", + " feature_name_accumulated_collision_count_dict[feature_name][batch_idx] = 0\n", + " feature_name_accumulated_collision_count_dict[feature_name][batch_idx] += int(collision_cnt)\n", + " if feature_name not in feature_name_accumulated_total_count_dict:\n", + " feature_name_accumulated_total_count_dict[feature_name] = {}\n", + " if batch_idx not in feature_name_accumulated_total_count_dict[feature_name]:\n", + " feature_name_accumulated_total_count_dict[feature_name][batch_idx] = 0\n", + " feature_name_accumulated_total_count_dict[feature_name][batch_idx] += int(total_cnt)\n", + "# sort each feature_name's dict by batch_idx\n", + "for feature_name in feature_name_accumulated_collision_count_dict:\n", + " feature_name_accumulated_collision_count_dict[feature_name] = dict(sorted(feature_name_accumulated_collision_count_dict[feature_name].items()))\n", + " feature_name_accumulated_total_count_dict[feature_name] = dict(sorted(feature_name_accumulated_total_count_dict[feature_name].items()))\n", + "# calculate accumulated collision\n", + "for feature_name in feature_name_accumulated_collision_count_dict:\n", + " for batch_idx in feature_name_accumulated_collision_count_dict[feature_name]:\n", + " if batch_idx == 0:\n", + " continue\n", + " feature_name_accumulated_collision_count_dict[feature_name][batch_idx] = feature_name_accumulated_collision_count_dict[feature_name][batch_idx] + feature_name_accumulated_collision_count_dict[feature_name][batch_idx-1]\n", + " feature_name_accumulated_total_count_dict[feature_name][batch_idx] = feature_name_accumulated_total_count_dict[feature_name][batch_idx] + feature_name_accumulated_total_count_dict[feature_name][batch_idx-1]\n", + "# print(feature_name_accumulated_collision_count_dict)\n", + "print(feature_name_accumulated_collision_count_dict)\n", + "print(feature_name_accumulated_total_count_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "output": { + "id": 1729477831108186, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{1: 0.11662996732271634, 2: 0.15480550130208334, 3: 0.1741814246544471, 4: 0.185748291015625, 5: 0.19358669183193108, 6: 0.19916375128777472, 7: 0.20346890963040865, 8: 0.20676832932692307, 9: 0.20936138446514424, 10: 0.2116270265379152, 11: 0.21340355506310096, 12: 0.21491345287074703, 13: 0.21630876142900068, 14: 0.21744228265224358, 15: 0.21842296306903547, 16: 0.2191932643700509, 17: 0.22000278570713142, 18: 0.2207065844825405, 19: 0.2213916485126202, 20: 0.22201448657137135, 21: 0.22250622302502185, 22: 0.22295826175141095, 23: 0.22335218771910056, 24: 0.22372718224158653, 25: 0.22412244808039017, 26: 0.22448174022881054, 27: 0.22478082677820227, 28: 0.22509895142572944, 29: 0.22536112467447916, 30: 0.2256387185222162, 31: 0.22590042994572565, 32: 0.22610793747268357, 33: 0.2263207068810096, 34: 0.2264932821085165, 35: 0.22668580927400508, 36: 0.22685219493080822, 37: 0.22698894299958883, 38: 0.22713318473018368, 39: 0.2272771982046274, 40: 0.22739088334017354, 41: 0.22752866640195743, 42: 0.22761472862393783, 43: 0.22776997172749125, 44: 0.22786912184495192, 45: 0.22795773509354098, 46: 0.22805261689980566, 47: 0.22815895080566406, 48: 0.2282668851795526, 49: 0.22835491473858174, 50: 0.22841551077311933, 51: 0.22849639350845968, 52: 0.22858923924505625, 53: 0.22865773605824877, 54: 0.22872024216018358, 55: 0.22879489437564388, 56: 0.22883397976235662, 57: 0.22888636905255305, 58: 0.22895162450598924, 59: 0.2290055886293069, 60: 0.22906979035308953, 61: 0.22914967880059708, 62: 0.22920869820283882, 63: 0.2292636357820951, 64: 0.2293124407706176, 65: 0.22936503092447916, 66: 0.2294093240416009, 67: 0.22946339602923502, 68: 0.22953338793156006, 69: 0.2295833713405735, 70: 0.22962619372333762, 71: 0.2296722933777377, 72: 0.2296992825507113, 73: 0.22974974697691983, 74: 0.22974894205729166, 75: 0.2297982281518851, 76: 0.22982864303665085, 77: 0.2298487977398453, 78: 0.229891055514773, 79: 0.22994537353515626, 80: 0.23000545085099122, 81: 0.23003755322540456, 82: 0.2300825711198158, 83: 0.2301263215340974, 84: 0.23015666978930996, 85: 0.23018481095916257, 86: 0.23022393480430758, 87: 0.23026971883707112, 88: 0.23029065606093344, 89: 0.23031449277176816, 90: 0.23033009236481666, 91: 0.23035675865351954, 92: 0.23038047872563844, 93: 0.23040264522970796, 94: 0.230417945027834, 95: 0.23044251172970504, 96: 0.23045268047432593, 97: 0.23048499090892366, 98: 0.23049713348175263, 99: 0.2305291982797476}\n" + ] + } + ], + "source": [ + "# get average accumulated_collision_count for each batch over all the features\n", + "average_accumulated_collision_count_dict = {}\n", + "for batch_idx in range(1, 100):\n", + " accumulated_collision_count_sum = 0\n", + " accumulated_total_count_sum = 0\n", + " for feature_name in feature_name_accumulated_collision_count_dict:\n", + " accumulated_collision_count_sum += feature_name_accumulated_collision_count_dict[feature_name][batch_idx]\n", + " accumulated_total_count_sum += feature_name_accumulated_total_count_dict[feature_name][batch_idx]\n", + " average_accumulated_collision_count_dict[batch_idx] = accumulated_collision_count_sum / accumulated_total_count_sum\n", + "print(average_accumulated_collision_count_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "output": { + "id": 578381482001118, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot collision count for each feature\n", + "# each feature name has a line with a different color\n", + "# the x-axis is the batch_idx, the y-axis is the accumulated_collision_count\n", + "fig = plt.figure(figsize=(20, 10))\n", + "x_list = []\n", + "y_list = []\n", + "for feature_name in feature_name_accumulated_collision_count_dict:\n", + " x_list = list(feature_name_accumulated_collision_count_dict[feature_name].keys())\n", + " y_list = list(feature_name_accumulated_collision_count_dict[feature_name].values())\n", + " plt.plot(x_list, y_list, label=feature_name)\n", + "plt.xlabel(\"batch_idx\")\n", + "plt.ylabel(\"accumulated_collision_count\")\n", + "plt.title(\"accumulated_collision_count vs batch_idx\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "output": { + "id": 1787443788645458, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the ratio of accumulated_collision_count / accumulated_total_count for each feature\n", + "# each feature name has a line with a different color\n", + "# the x-axis is the batch_idx, the y-axis is the ratio\n", + "fig = plt.figure(figsize=(20, 10))\n", + "x_list = []\n", + "y_list = []\n", + "for feature_name in feature_name_accumulated_collision_count_dict:\n", + " x_list = list(feature_name_accumulated_collision_count_dict[feature_name].keys())\n", + " y_list = [feature_name_accumulated_collision_count_dict[feature_name][x] / feature_name_accumulated_total_count_dict[feature_name][x] for x in x_list]\n", + " plt.plot(x_list, y_list, label=feature_name)\n", + "plt.xlabel(\"batch_idx\")\n", + "plt.ylabel(\"collision rate\")\n", + "plt.title(\"collision rate vs batch_idx\")\n", + "# add a text for each feature name at the last point of the line\n", + "for feature_name in feature_name_accumulated_collision_count_dict:\n", + " x_list = list(feature_name_accumulated_collision_count_dict[feature_name].keys())\n", + " y_list = [feature_name_accumulated_collision_count_dict[feature_name][x] / feature_name_accumulated_total_count_dict[feature_name][x] for x in x_list]\n", + " plt.text(x_list[-1], y_list[-1], feature_name, fontsize=12)\n", + "# plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "output": { + "id": 1255274669441522, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the average ratio of accumulated_collision_count / accumulated_total_count for all the features\n", + "# the x-axis is the batch_idx, the y-axis is the ratio\n", + "fig = plt.figure(figsize=(8, 6))\n", + "font_size = 24\n", + "x_list = list(average_accumulated_collision_count_dict.keys())\n", + "y_list = list(average_accumulated_collision_count_dict.values())\n", + "plt.plot(x_list, y_list)\n", + "plt.xlabel(\"batch_idx\", fontsize=font_size)\n", + "plt.ylabel(\"average collision rate\", fontsize=font_size)\n", + "# plt.title(\"average collision rate vs batch_idx\", fontsize=font_size)\n", + "plt.xticks(fontsize=font_size)\n", + "plt.yticks(fontsize=font_size)\n", + "# save\n", + "plt.show()\n", + "# plot the ratio of accumulated_collision_count / accumulated_total_count" + ] + } + ], + "metadata": { + "fileHeader": "", + "fileUid": "6fba0a1e-d141-4b9c-b2ab-040d32740e82", + "isAdHoc": false, + "kernelspec": { + "display_name": "torchrec", + "language": "python", + "name": "bento_kernel_torchrec" + } + } +} diff --git a/torchrec/distributed/benchmark/benchmark_zch/plots/plot_zch_metrics_compare.ipynb b/torchrec/distributed/benchmark/benchmark_zch/plots/plot_zch_metrics_compare.ipynb new file mode 100644 index 000000000..1facde351 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch/plots/plot_zch_metrics_compare.ipynb @@ -0,0 +1,283 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import csv\n", + "import numpy as np\n", + "import pandas as pd\n", + "import re\n", + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "output": { + "id": 1872465900215870, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['result_tbsize_50000_zch_dlrmv3_kuairand27k', 'result_tbsize_50000_nonzch_dlrmv3_kuairand27k']\n" + ] + } + ], + "source": [ + "zch_stats_folders = [x for x in os.listdir(\"/home/lizhouyu/home/lizhouyu/zch_results\") if x.startswith(\"result_tbsize\")]\n", + "zch_stats_folders = [x for x in zch_stats_folders if \"_50000_\" in x and \"kuairand27k\" in x]\n", + "print(zch_stats_folders)\n", + "#" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "figure_folder = \"/home/lizhouyu/home/lizhouyu/zch_results_figures\"\n", + "os.makedirs(figure_folder, exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "def get_average_zch(zch_stats_file_folder):\n", + " zch_stats_file_path = os.path.join(zch_stats_file_folder, 'zch_metrics.csv')\n", + " df_zch_stats = pd.read_csv(zch_stats_file_path)\n", + " # maintain a dictionary of {feature_name: {batch_idx: accumulated_collision_over_all_ranks_at_batch_idx}}\n", + " feature_name_accumulated_collision_count_dict = {}\n", + " feature_name_accumulated_total_count_dict = {}\n", + " batch_count = 0\n", + " for index, row in df_zch_stats.iterrows():\n", + " feature_name = row[\"feature_name\"]\n", + " if feature_name != \"video_id\":\n", + " continue\n", + " batch_count += 1\n", + " batch_idx = row[\"batch_idx\"]\n", + " collision_cnt = row[\"collision_cnt\"]\n", + " total_cnt = row[\"total_cnt\"]\n", + " if feature_name not in feature_name_accumulated_collision_count_dict:\n", + " feature_name_accumulated_collision_count_dict[feature_name] = {}\n", + " if batch_count not in feature_name_accumulated_collision_count_dict[feature_name]:\n", + " feature_name_accumulated_collision_count_dict[feature_name][batch_count] = 0\n", + " feature_name_accumulated_collision_count_dict[feature_name][batch_count] += int(collision_cnt)\n", + " if feature_name not in feature_name_accumulated_total_count_dict:\n", + " feature_name_accumulated_total_count_dict[feature_name] = {}\n", + " if batch_count not in feature_name_accumulated_total_count_dict[feature_name]:\n", + " feature_name_accumulated_total_count_dict[feature_name][batch_count] = 0\n", + " feature_name_accumulated_total_count_dict[feature_name][batch_count] += int(total_cnt)\n", + " # sort each feature_name's dict by batch_idx\n", + " for feature_name in feature_name_accumulated_collision_count_dict:\n", + " feature_name_accumulated_collision_count_dict[feature_name] = dict(sorted(feature_name_accumulated_collision_count_dict[feature_name].items()))\n", + " feature_name_accumulated_total_count_dict[feature_name] = dict(sorted(feature_name_accumulated_total_count_dict[feature_name].items()))\n", + " print(feature_name_accumulated_collision_count_dict)\n", + " # calculate accumulated collision\n", + " for feature_name in feature_name_accumulated_collision_count_dict:\n", + " for batch_count in feature_name_accumulated_collision_count_dict[feature_name]:\n", + " if batch_count == 1:\n", + " continue\n", + " feature_name_accumulated_collision_count_dict[feature_name][batch_count] = feature_name_accumulated_collision_count_dict[feature_name][batch_count] + feature_name_accumulated_collision_count_dict[feature_name][batch_count-1]\n", + " feature_name_accumulated_total_count_dict[feature_name][batch_count] = feature_name_accumulated_total_count_dict[feature_name][batch_count] + feature_name_accumulated_total_count_dict[feature_name][batch_count-1]\n", + " # get average accumulated_collision_count for each batch over all the features\n", + " average_accumulated_collision_count_dict = {}\n", + " for batch_idx in range(1, len(list(feature_name_accumulated_collision_count_dict.values())[0])):\n", + " accumulated_collision_count_sum = 0\n", + " accumulated_total_count_sum = 0\n", + " for feature_name in feature_name_accumulated_collision_count_dict:\n", + " accumulated_collision_count_sum += feature_name_accumulated_collision_count_dict[feature_name][batch_idx]\n", + " accumulated_total_count_sum += feature_name_accumulated_total_count_dict[feature_name][batch_idx]\n", + " average_accumulated_collision_count_dict[batch_idx] = accumulated_collision_count_sum / accumulated_total_count_sum\n", + " return average_accumulated_collision_count_dict, feature_name_accumulated_total_count_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "re_zch_method_name_pattern = re.compile(r\"\\d+_((non)?zch(_.*)?)\")\n", + "re_table_size_pattern = re.compile(r\"result_tbsize_(\\d+)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "output": { + "id": 1295720632224902, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "zch_dlrmv3_kuairand27k 50000\n", + "{'video_id': {1: 1301, 2: 882, 3: 683, 4: 573, 5: 484, 6: 842, 7: 2359, 8: 4059, 9: 4555, 10: 4508, 11: 4596, 12: 4659, 13: 4507, 14: 4617, 15: 4550, 16: 4627, 17: 4675, 18: 4521, 19: 4427, 20: 4771, 21: 4603, 22: 4707, 23: 4705, 24: 4578, 25: 4625, 26: 4674, 27: 4661, 28: 4515, 29: 4648, 30: 4581, 31: 4733, 32: 4763, 33: 4470, 34: 4595, 35: 4555, 36: 4564, 37: 4661, 38: 4445, 39: 4556, 40: 4510, 41: 4647, 42: 4578, 43: 4597, 44: 4691, 45: 4568, 46: 4646, 47: 4716, 48: 4585, 49: 4493, 50: 4597, 51: 4561, 52: 4555, 53: 4666, 54: 4613, 55: 4790, 56: 4420, 57: 4726, 58: 4700, 59: 4527, 60: 4761, 61: 4813, 62: 4617, 63: 4642, 64: 4578, 65: 4633, 66: 4570, 67: 4702, 68: 4796, 69: 4649, 70: 4521, 71: 4863, 72: 4775, 73: 4613, 74: 4700, 75: 4722, 76: 4809, 77: 4521, 78: 4807, 79: 4524, 80: 4566, 81: 4650, 82: 4605, 83: 4650, 84: 4547, 85: 4710, 86: 4529, 87: 4684, 88: 4600, 89: 4850, 90: 4755, 91: 4644, 92: 4586, 93: 4592, 94: 4543, 95: 4729, 96: 4599, 97: 4662, 98: 4648, 99: 4631, 100: 4555, 101: 4680, 102: 4535, 103: 4631, 104: 4709, 105: 4633, 106: 4658, 107: 4665, 108: 4622, 109: 4606, 110: 4619, 111: 4770, 112: 4728, 113: 4692, 114: 4676, 115: 4654, 116: 4548, 117: 4626, 118: 4733, 119: 4779, 120: 4645, 121: 4650, 122: 4669, 123: 4680, 124: 4621, 125: 4577, 126: 4678, 127: 4601, 128: 4655, 129: 4693, 130: 4578, 131: 4725, 132: 4672, 133: 4785, 134: 4672, 135: 4620, 136: 4830, 137: 4629, 138: 4556, 139: 4787, 140: 4700, 141: 4637, 142: 4606, 143: 4516, 144: 4707, 145: 4615, 146: 4455, 147: 4605, 148: 4622, 149: 4659, 150: 4578, 151: 4758, 152: 4440, 153: 4881, 154: 4667, 155: 4557, 156: 4586, 157: 4765, 158: 4654, 159: 4734, 160: 4639, 161: 4780, 162: 4670, 163: 4472, 164: 4694, 165: 4550, 166: 4735, 167: 4514, 168: 4573, 169: 4598, 170: 4742, 171: 4596, 172: 4715, 173: 4551, 174: 4516, 175: 4528, 176: 4857, 177: 4778, 178: 4576, 179: 4610, 180: 4494, 181: 4552, 182: 4609, 183: 4546, 184: 4712, 185: 4536, 186: 4505, 187: 4645, 188: 4624, 189: 4642, 190: 4670, 191: 4653, 192: 4566, 193: 4587, 194: 4590, 195: 4663, 196: 4435, 197: 4684, 198: 4727, 199: 4478, 200: 4809, 201: 4518, 202: 4505, 203: 4667, 204: 4619, 205: 4755, 206: 4709, 207: 4553, 208: 4601, 209: 4554, 210: 4643, 211: 4614, 212: 4616, 213: 4474, 214: 4596, 215: 4748, 216: 4763, 217: 4647, 218: 4710, 219: 4821, 220: 4673, 221: 4550, 222: 4557, 223: 4679, 224: 4724, 225: 4584, 226: 4711, 227: 4628, 228: 4700, 229: 4422, 230: 4626, 231: 4550, 232: 4694, 233: 4589, 234: 4702, 235: 4517, 236: 4705, 237: 4700, 238: 4695, 239: 4618, 240: 4664, 241: 4615, 242: 4601, 243: 4454, 244: 4583, 245: 4575, 246: 4773, 247: 4647, 248: 4744, 249: 4594, 250: 4742, 251: 4665, 252: 4703, 253: 4654, 254: 4876, 255: 4575, 256: 4686, 257: 4713, 258: 4439, 259: 4507, 260: 4692, 261: 4651, 262: 4475, 263: 4839, 264: 4698, 265: 4788, 266: 4635, 267: 4689, 268: 4559, 269: 4617, 270: 4541, 271: 4687, 272: 4449, 273: 4618, 274: 4650, 275: 4610, 276: 4717, 277: 4682, 278: 4778, 279: 4604, 280: 4715, 281: 4733, 282: 4678, 283: 4750, 284: 4733, 285: 4688, 286: 4680, 287: 4724, 288: 4560, 289: 4725, 290: 4696, 291: 4673, 292: 4688, 293: 4706, 294: 4613, 295: 4592, 296: 4725, 297: 4551, 298: 4603, 299: 4663, 300: 4636, 301: 4637, 302: 4716, 303: 4699, 304: 4604, 305: 4590, 306: 4559, 307: 4623, 308: 4654, 309: 4637, 310: 4563, 311: 4676, 312: 4656, 313: 4779, 314: 4630, 315: 921, 316: 0, 317: 0, 318: 0, 319: 0, 320: 18, 321: 457, 322: 2159, 323: 4002, 324: 4555, 325: 4508, 326: 4596, 327: 4659, 328: 4507, 329: 4617, 330: 4550, 331: 4627, 332: 4675, 333: 4521, 334: 4427, 335: 4771, 336: 4603, 337: 4707, 338: 4705, 339: 4578, 340: 4625, 341: 4674, 342: 4661, 343: 4515, 344: 4648, 345: 4581, 346: 4733, 347: 4763, 348: 4470, 349: 4595, 350: 4555, 351: 4564, 352: 4661, 353: 4445, 354: 4556, 355: 4510, 356: 4647, 357: 4578, 358: 4597, 359: 4691, 360: 4568, 361: 4646, 362: 4716, 363: 4585, 364: 4493, 365: 4597, 366: 4561, 367: 4555, 368: 4666, 369: 4613, 370: 4790, 371: 4420, 372: 4726, 373: 4700, 374: 4527, 375: 4761, 376: 4813, 377: 4617, 378: 4642, 379: 4578, 380: 4633, 381: 4570, 382: 4702, 383: 4796, 384: 4649, 385: 4521, 386: 4863, 387: 4775, 388: 4613, 389: 4700, 390: 4722, 391: 4809, 392: 4521, 393: 4807, 394: 4524, 395: 4566, 396: 4650, 397: 4605, 398: 4650, 399: 4547, 400: 4710, 401: 4529, 402: 4684, 403: 4600, 404: 4850, 405: 4755, 406: 4644, 407: 4586, 408: 4592, 409: 4543, 410: 4729, 411: 4599, 412: 4662, 413: 4648, 414: 4631, 415: 4555, 416: 4680, 417: 4535, 418: 4631, 419: 4709, 420: 4633, 421: 4658, 422: 4665, 423: 4622, 424: 4606, 425: 4619, 426: 4770, 427: 4728, 428: 4692, 429: 4676, 430: 4654, 431: 4548, 432: 4626, 433: 4733, 434: 4779, 435: 4645, 436: 4650, 437: 4669, 438: 4680, 439: 4621, 440: 4577, 441: 4678, 442: 4601, 443: 4655, 444: 4693, 445: 4578, 446: 4725, 447: 4672, 448: 4785, 449: 4672, 450: 4620, 451: 4830, 452: 4629, 453: 4556, 454: 4787, 455: 4700, 456: 4637, 457: 4606, 458: 4516, 459: 4707, 460: 4615, 461: 4455, 462: 4605, 463: 4622, 464: 4659, 465: 4578, 466: 4758, 467: 4440, 468: 4881, 469: 4667, 470: 4557, 471: 4586, 472: 4765, 473: 4654, 474: 4734, 475: 4639, 476: 4780, 477: 4670, 478: 4472, 479: 4694, 480: 4550, 481: 4735, 482: 4514, 483: 4573, 484: 4598, 485: 4742, 486: 4596, 487: 4715, 488: 4551, 489: 4516, 490: 4528, 491: 4857, 492: 4778, 493: 4576, 494: 4610, 495: 4494, 496: 4552, 497: 4609, 498: 4546, 499: 4712, 500: 4536, 501: 4505, 502: 4645, 503: 4624, 504: 4642, 505: 4670, 506: 4653, 507: 4566, 508: 4587, 509: 4590, 510: 4663, 511: 4435, 512: 4684, 513: 4727, 514: 4478, 515: 4809, 516: 4518, 517: 4505, 518: 4667, 519: 4619, 520: 4755, 521: 4709, 522: 4553, 523: 4601, 524: 4554, 525: 4643, 526: 4614, 527: 4616, 528: 4474, 529: 4596, 530: 4748, 531: 4763, 532: 4647, 533: 4710, 534: 4821, 535: 4673, 536: 4550, 537: 4557, 538: 4679, 539: 4724, 540: 4584, 541: 4711, 542: 4628, 543: 4700, 544: 4422, 545: 4626, 546: 4550, 547: 4694, 548: 4589, 549: 4702, 550: 4517, 551: 4705, 552: 4700, 553: 4695, 554: 4618, 555: 4664, 556: 4615, 557: 4601, 558: 4454, 559: 4583, 560: 4575, 561: 4773, 562: 4647, 563: 4744, 564: 4594, 565: 4742, 566: 4665, 567: 4703, 568: 4654, 569: 4876, 570: 4575, 571: 4686, 572: 4713, 573: 4439, 574: 4507, 575: 4692, 576: 4651, 577: 4475, 578: 4839, 579: 4698, 580: 4788, 581: 4635, 582: 4689, 583: 4559, 584: 4617, 585: 4541, 586: 4687, 587: 4449, 588: 4618, 589: 4650, 590: 4610, 591: 4717, 592: 4682, 593: 4778, 594: 4604, 595: 4715, 596: 4733, 597: 4678, 598: 4750, 599: 4733, 600: 4688, 601: 4680, 602: 4724, 603: 4560, 604: 4725, 605: 4696, 606: 4673, 607: 4688, 608: 4706, 609: 4613, 610: 4592, 611: 4725, 612: 4551, 613: 4603, 614: 4663, 615: 4636, 616: 4637, 617: 4716, 618: 4699, 619: 4604, 620: 4590, 621: 4559, 622: 4623, 623: 4654, 624: 4637, 625: 4563, 626: 4676, 627: 4656, 628: 4779, 629: 4630, 630: 921, 631: 0, 632: 0, 633: 0, 634: 0, 635: 18, 636: 457, 637: 2159, 638: 4002, 639: 4555, 640: 4508, 641: 4596, 642: 4659, 643: 4507, 644: 4617, 645: 4550, 646: 4627, 647: 4675, 648: 4521, 649: 4427, 650: 4771, 651: 4603, 652: 4707, 653: 4705, 654: 4578, 655: 4625, 656: 4674, 657: 4661, 658: 4515, 659: 4648, 660: 4581, 661: 4733, 662: 4763, 663: 4470, 664: 4595, 665: 4555, 666: 4564, 667: 4661, 668: 4445, 669: 4556, 670: 4510, 671: 4647, 672: 4578, 673: 4597, 674: 4691, 675: 4568, 676: 4646, 677: 4716, 678: 4585, 679: 4493, 680: 4597, 681: 4561, 682: 4555, 683: 4666, 684: 4613, 685: 4790, 686: 4420, 687: 4726, 688: 4700, 689: 4527, 690: 4761, 691: 4813, 692: 4617, 693: 4642, 694: 4578, 695: 4633, 696: 4570, 697: 4702, 698: 4796, 699: 4649, 700: 4521, 701: 4863, 702: 4775, 703: 4613, 704: 4700, 705: 4722, 706: 4809, 707: 4521, 708: 4807, 709: 4524, 710: 4566, 711: 4650, 712: 4605, 713: 4650, 714: 4547, 715: 4710, 716: 4529, 717: 4684, 718: 4600, 719: 4850, 720: 4755, 721: 4644, 722: 4586, 723: 4592, 724: 4543, 725: 4729, 726: 4599, 727: 4662, 728: 4648, 729: 4631, 730: 4555, 731: 4680, 732: 4535, 733: 4631, 734: 4709, 735: 4633, 736: 4658, 737: 4665, 738: 4622, 739: 4606, 740: 4619, 741: 4770, 742: 4728, 743: 4692, 744: 4676, 745: 4654, 746: 4548, 747: 4626, 748: 4733, 749: 4779, 750: 4645, 751: 4650, 752: 4669, 753: 4680, 754: 4621, 755: 4577, 756: 4678, 757: 4601, 758: 4655, 759: 4693, 760: 4578, 761: 4725, 762: 4672, 763: 4785, 764: 4672, 765: 4620, 766: 4830, 767: 4629, 768: 4556, 769: 4787, 770: 4700, 771: 4637, 772: 4606, 773: 4516, 774: 4707, 775: 4615, 776: 4455, 777: 4605, 778: 4622, 779: 4659, 780: 4578, 781: 4758, 782: 4440, 783: 4881, 784: 4667, 785: 4557, 786: 4586, 787: 4765, 788: 4654, 789: 4734, 790: 4639, 791: 4780, 792: 4670, 793: 4472, 794: 4694, 795: 4550, 796: 4735, 797: 4514, 798: 4573, 799: 4598, 800: 4742, 801: 4596, 802: 4715, 803: 4551, 804: 4516, 805: 4528, 806: 4857, 807: 4778, 808: 4576, 809: 4610, 810: 4494, 811: 4552, 812: 4609, 813: 4546, 814: 4712, 815: 4536, 816: 4505, 817: 4645, 818: 4624, 819: 4642, 820: 4670, 821: 4653, 822: 4566, 823: 4587, 824: 4590, 825: 4663, 826: 4435, 827: 4684, 828: 4727, 829: 4478, 830: 4809, 831: 4518, 832: 4505, 833: 4667, 834: 4619, 835: 4755, 836: 4709, 837: 4553, 838: 4601, 839: 4554, 840: 4643, 841: 4614, 842: 4616, 843: 4474, 844: 4596, 845: 4748, 846: 4763, 847: 4647, 848: 4710, 849: 4821, 850: 4673, 851: 4550, 852: 4557, 853: 4679, 854: 4724, 855: 4584, 856: 4711, 857: 4628, 858: 4700, 859: 4422, 860: 4626, 861: 4550, 862: 4694, 863: 4589, 864: 4702, 865: 4517, 866: 4705, 867: 4700, 868: 4695, 869: 4618, 870: 4664, 871: 4615, 872: 4601, 873: 4454, 874: 4583, 875: 4575, 876: 4773, 877: 4647, 878: 4744, 879: 4594, 880: 4742, 881: 4665, 882: 4703, 883: 4654, 884: 4876, 885: 4575, 886: 4686, 887: 4713, 888: 4439, 889: 4507, 890: 4692, 891: 4651, 892: 4475, 893: 4839, 894: 4698, 895: 4788, 896: 4635, 897: 4689, 898: 4559, 899: 4617, 900: 4541, 901: 4687, 902: 4449, 903: 4618, 904: 4650, 905: 4610, 906: 4717, 907: 4682, 908: 4778, 909: 4604, 910: 4715, 911: 4733, 912: 4678, 913: 4750, 914: 4733, 915: 4688, 916: 4680, 917: 4724, 918: 4560, 919: 4725, 920: 4696, 921: 4673, 922: 4688, 923: 4706, 924: 4613, 925: 4592, 926: 4725, 927: 4551, 928: 4603, 929: 4663, 930: 4636, 931: 4637, 932: 4716, 933: 4699, 934: 4604, 935: 4590, 936: 4559, 937: 4623, 938: 4654, 939: 4637, 940: 4563, 941: 4676, 942: 4656, 943: 4779, 944: 4630, 945: 921, 946: 0, 947: 0, 948: 0, 949: 0, 950: 18, 951: 457, 952: 2159, 953: 4002, 954: 4555, 955: 4508, 956: 4596, 957: 4659, 958: 4507, 959: 4617, 960: 4550, 961: 4627, 962: 4675, 963: 4521, 964: 4427, 965: 4771, 966: 4603, 967: 4707, 968: 4705, 969: 4578, 970: 4625, 971: 4674, 972: 4661, 973: 4515, 974: 4648, 975: 4581, 976: 4733, 977: 4763, 978: 4470, 979: 4595, 980: 4555, 981: 4564, 982: 4661, 983: 4445, 984: 4556, 985: 4510, 986: 4647, 987: 4578, 988: 4597, 989: 4691, 990: 4568, 991: 4646, 992: 4716, 993: 4585, 994: 4493, 995: 4597, 996: 4561, 997: 4555, 998: 4666, 999: 4613, 1000: 4790, 1001: 4420, 1002: 4726, 1003: 4700, 1004: 4527, 1005: 4761, 1006: 4813, 1007: 4617, 1008: 4642, 1009: 4578, 1010: 4633, 1011: 4570, 1012: 4702, 1013: 4796, 1014: 4649, 1015: 4521, 1016: 4863, 1017: 4775, 1018: 4613, 1019: 4700, 1020: 4722, 1021: 4809, 1022: 4521, 1023: 4807, 1024: 4524, 1025: 4566, 1026: 4650, 1027: 4605, 1028: 4650, 1029: 4547, 1030: 4710, 1031: 4529, 1032: 4684, 1033: 4600, 1034: 4850, 1035: 4755, 1036: 4644, 1037: 4586, 1038: 4592, 1039: 4543, 1040: 4729, 1041: 4599, 1042: 4662, 1043: 4648, 1044: 4631, 1045: 4555, 1046: 4680, 1047: 4535, 1048: 4631, 1049: 4709, 1050: 4633, 1051: 4658, 1052: 4665, 1053: 4622, 1054: 4606, 1055: 4619, 1056: 4770, 1057: 4728, 1058: 4692, 1059: 4676, 1060: 4654, 1061: 4548, 1062: 4626, 1063: 4733, 1064: 4779, 1065: 4645, 1066: 4650, 1067: 4669, 1068: 4680, 1069: 4621, 1070: 4577, 1071: 4678, 1072: 4601, 1073: 4655, 1074: 4693, 1075: 4578, 1076: 4725, 1077: 4672, 1078: 4785, 1079: 4672, 1080: 4620, 1081: 4830, 1082: 4629, 1083: 4556, 1084: 4787, 1085: 4700, 1086: 4637, 1087: 4606, 1088: 4516, 1089: 4707, 1090: 4615, 1091: 4455, 1092: 4605, 1093: 4622, 1094: 4659, 1095: 4578, 1096: 4758, 1097: 4440, 1098: 4881, 1099: 4667, 1100: 4557, 1101: 4586, 1102: 4765, 1103: 4654, 1104: 4734, 1105: 4639, 1106: 4780, 1107: 4670, 1108: 4472, 1109: 4694, 1110: 4550, 1111: 4735, 1112: 4514, 1113: 4573, 1114: 4598, 1115: 4742, 1116: 4596, 1117: 4715, 1118: 4551, 1119: 4516, 1120: 4528, 1121: 4857, 1122: 4778, 1123: 4576, 1124: 4610, 1125: 4494, 1126: 4552, 1127: 4609, 1128: 4546, 1129: 4712, 1130: 4536, 1131: 4505, 1132: 4645, 1133: 4624, 1134: 4642, 1135: 4670, 1136: 4653, 1137: 4566, 1138: 4587, 1139: 4590, 1140: 4663, 1141: 4435, 1142: 4684, 1143: 4727, 1144: 4478, 1145: 4809, 1146: 4518, 1147: 4505, 1148: 4667, 1149: 4619, 1150: 4755, 1151: 4709, 1152: 4553, 1153: 4601, 1154: 4554, 1155: 4643, 1156: 4614, 1157: 4616, 1158: 4474, 1159: 4596, 1160: 4748, 1161: 4763, 1162: 4647, 1163: 4710, 1164: 4821, 1165: 4673, 1166: 4550, 1167: 4557, 1168: 4679, 1169: 4724, 1170: 4584, 1171: 4711, 1172: 4628, 1173: 4700, 1174: 4422, 1175: 4626, 1176: 4550, 1177: 4694, 1178: 4589, 1179: 4702, 1180: 4517, 1181: 4705, 1182: 4700, 1183: 4695, 1184: 4618, 1185: 4664, 1186: 4615, 1187: 4601, 1188: 4454, 1189: 4583, 1190: 4575, 1191: 4773, 1192: 4647, 1193: 4744, 1194: 4594, 1195: 4742, 1196: 4665, 1197: 4703, 1198: 4654, 1199: 4876, 1200: 4575, 1201: 4686, 1202: 4713, 1203: 4439, 1204: 4507, 1205: 4692, 1206: 4651, 1207: 4475, 1208: 4839, 1209: 4698, 1210: 4788, 1211: 4635, 1212: 4689, 1213: 4559, 1214: 4617, 1215: 4541, 1216: 4687, 1217: 4449, 1218: 4618, 1219: 4650, 1220: 4610, 1221: 4717, 1222: 4682, 1223: 4778, 1224: 4604, 1225: 4715, 1226: 4733, 1227: 4678, 1228: 4750, 1229: 4733, 1230: 4688, 1231: 4680, 1232: 4724, 1233: 4560, 1234: 4725, 1235: 4696, 1236: 4673, 1237: 4688, 1238: 4706, 1239: 4613, 1240: 4592, 1241: 4725, 1242: 4551, 1243: 4603, 1244: 4663, 1245: 4636, 1246: 4637, 1247: 4716, 1248: 4699, 1249: 4604, 1250: 4590, 1251: 4559, 1252: 4623, 1253: 4654, 1254: 4637, 1255: 4563, 1256: 4676, 1257: 4656, 1258: 4779, 1259: 4630, 1260: 921, 1261: 0, 1262: 0, 1263: 0, 1264: 0, 1265: 18, 1266: 457, 1267: 2159, 1268: 4002, 1269: 4555, 1270: 4508, 1271: 4596, 1272: 4659, 1273: 4507, 1274: 4617, 1275: 4550, 1276: 4627, 1277: 4675, 1278: 4521, 1279: 4427, 1280: 4771, 1281: 4603, 1282: 4707, 1283: 4705, 1284: 4578, 1285: 4625, 1286: 4674, 1287: 4661, 1288: 4515, 1289: 4648, 1290: 4581, 1291: 4733, 1292: 4763, 1293: 4470, 1294: 4595, 1295: 4555, 1296: 4564, 1297: 4661, 1298: 4445, 1299: 4556, 1300: 4510, 1301: 4647, 1302: 4578, 1303: 4597, 1304: 4691, 1305: 4568, 1306: 4646, 1307: 4716, 1308: 4585, 1309: 4493, 1310: 4597, 1311: 4561, 1312: 4555, 1313: 4666, 1314: 4613, 1315: 4790, 1316: 4420, 1317: 4726, 1318: 4700, 1319: 4527, 1320: 4761, 1321: 4813, 1322: 4617, 1323: 4642, 1324: 4578, 1325: 4633, 1326: 4570, 1327: 4702, 1328: 4796, 1329: 4649, 1330: 4521, 1331: 4863, 1332: 4775, 1333: 4613, 1334: 4700, 1335: 4722, 1336: 4809, 1337: 4521, 1338: 4807, 1339: 4524, 1340: 4566, 1341: 4650, 1342: 4605, 1343: 4650, 1344: 4547, 1345: 4710, 1346: 4529, 1347: 4684, 1348: 4600, 1349: 4850, 1350: 4755, 1351: 4644, 1352: 4586, 1353: 4592, 1354: 4543, 1355: 4729, 1356: 4599, 1357: 4662, 1358: 4648, 1359: 4631, 1360: 4555, 1361: 4680, 1362: 4535, 1363: 4631, 1364: 4709, 1365: 4633, 1366: 4658, 1367: 4665, 1368: 4622, 1369: 4606, 1370: 4619, 1371: 4770, 1372: 4728, 1373: 4692, 1374: 4676, 1375: 4654, 1376: 4548, 1377: 4626, 1378: 4733, 1379: 4779, 1380: 4645, 1381: 4650, 1382: 4669, 1383: 4680, 1384: 4621, 1385: 4577, 1386: 4678, 1387: 4601, 1388: 4655, 1389: 4693, 1390: 4578, 1391: 4725, 1392: 4672, 1393: 4785, 1394: 4672, 1395: 4620, 1396: 4830, 1397: 4629, 1398: 4556, 1399: 4787, 1400: 4700, 1401: 4637, 1402: 4606, 1403: 4516, 1404: 4707, 1405: 4615, 1406: 4455, 1407: 4605, 1408: 4622, 1409: 4659, 1410: 4578, 1411: 4758, 1412: 4440, 1413: 4881, 1414: 4667, 1415: 4557, 1416: 4586, 1417: 4765, 1418: 4654, 1419: 4734, 1420: 4639, 1421: 4780, 1422: 4670, 1423: 4472, 1424: 4694, 1425: 4550, 1426: 4735, 1427: 4514, 1428: 4573, 1429: 4598, 1430: 4742, 1431: 4596, 1432: 4715, 1433: 4551, 1434: 4516, 1435: 4528, 1436: 4857, 1437: 4778, 1438: 4576, 1439: 4610, 1440: 4494, 1441: 4552, 1442: 4609, 1443: 4546, 1444: 4712, 1445: 4536, 1446: 4505, 1447: 4645, 1448: 4624, 1449: 4642, 1450: 4670, 1451: 4653, 1452: 4566, 1453: 4587, 1454: 4590, 1455: 4663, 1456: 4435, 1457: 4684, 1458: 4727, 1459: 4478, 1460: 4809, 1461: 4518, 1462: 4505, 1463: 4667, 1464: 4619, 1465: 4755, 1466: 4709, 1467: 4553, 1468: 4601, 1469: 4554, 1470: 4643, 1471: 4614, 1472: 4616, 1473: 4474, 1474: 4596, 1475: 4748, 1476: 4763, 1477: 4647, 1478: 4710, 1479: 4821, 1480: 4673, 1481: 4550, 1482: 4557, 1483: 4679, 1484: 4724, 1485: 4584, 1486: 4711, 1487: 4628, 1488: 4700, 1489: 4422, 1490: 4626, 1491: 4550, 1492: 4694, 1493: 4589, 1494: 4702, 1495: 4517, 1496: 4705, 1497: 4700, 1498: 4695, 1499: 4618, 1500: 4664, 1501: 4615, 1502: 4601, 1503: 4454, 1504: 4583, 1505: 4575, 1506: 4773, 1507: 4647, 1508: 4744, 1509: 4594, 1510: 4742, 1511: 4665, 1512: 4703, 1513: 4654, 1514: 4876, 1515: 4575, 1516: 4686, 1517: 4713, 1518: 4439, 1519: 4507, 1520: 4692, 1521: 4651, 1522: 4475, 1523: 4839, 1524: 4698, 1525: 4788, 1526: 4635, 1527: 4689, 1528: 4559, 1529: 4617, 1530: 4541, 1531: 4687, 1532: 4449, 1533: 4618, 1534: 4650, 1535: 4610, 1536: 4717, 1537: 4682, 1538: 4778, 1539: 4604, 1540: 4715, 1541: 4733, 1542: 4678, 1543: 4750, 1544: 4733, 1545: 4688, 1546: 4680, 1547: 4724, 1548: 4560, 1549: 4725, 1550: 4696, 1551: 4673, 1552: 4688, 1553: 4706, 1554: 4613, 1555: 4592, 1556: 4725, 1557: 4551, 1558: 4603, 1559: 4663, 1560: 4636, 1561: 4637, 1562: 4716, 1563: 4699, 1564: 4604, 1565: 4590, 1566: 4559, 1567: 4623, 1568: 4654, 1569: 4637, 1570: 4563, 1571: 4676, 1572: 4656, 1573: 4779, 1574: 4630, 1575: 921}}\n", + "nonzch_dlrmv3_kuairand27k 50000\n", + "{'video_id': {1: 144, 2: 482, 3: 785, 4: 1000, 5: 1286, 6: 1541, 7: 1697, 8: 1902, 9: 2049, 10: 2206, 11: 2342, 12: 2455, 13: 2644, 14: 2823, 15: 2855, 16: 2949, 17: 3102, 18: 3142, 19: 3140, 20: 3397, 21: 3326, 22: 3499, 23: 3496, 24: 3598, 25: 3573, 26: 3792, 27: 3747, 28: 3736, 29: 3955, 30: 3877, 31: 3891, 32: 3997, 33: 3937, 34: 3997, 35: 4139, 36: 4112, 37: 4164, 38: 4073, 39: 4158, 40: 4223, 41: 4181, 42: 4259, 43: 4224, 44: 4281, 45: 4212, 46: 4405, 47: 4437, 48: 4356, 49: 4276, 50: 4345, 51: 4441, 52: 4473, 53: 4579, 54: 4539, 55: 4511, 56: 4390, 57: 4589, 58: 4456, 59: 4457, 60: 4652, 61: 4645, 62: 4414, 63: 4584, 64: 4542, 65: 4582, 66: 4510, 67: 4593, 68: 4753, 69: 4614, 70: 4545, 71: 4594, 72: 4722, 73: 4638, 74: 4693, 75: 4730, 76: 4783, 77: 4683, 78: 4734, 79: 4557, 80: 4602, 81: 4662, 82: 4637, 83: 4636, 84: 4678, 85: 4715, 86: 4634, 87: 4740, 88: 4685, 89: 4766, 90: 4726, 91: 4630, 92: 4628, 93: 4686, 94: 4581, 95: 4734, 96: 4624, 97: 4757, 98: 4738, 99: 4692, 100: 4687, 101: 4757, 102: 4664, 103: 4720, 104: 4689, 105: 4639, 106: 4731, 107: 4743, 108: 4709, 109: 4776, 110: 4756, 111: 4738, 112: 4650, 113: 4701, 114: 4712, 115: 4794, 116: 4678, 117: 4689, 118: 4734, 119: 4794, 120: 4683, 121: 4815, 122: 4853, 123: 4847, 124: 4853, 125: 4800, 126: 4904, 127: 4696, 128: 4731, 129: 4848, 130: 4733, 131: 4891, 132: 4707, 133: 4760, 134: 4722, 135: 4855, 136: 4883, 137: 4823, 138: 4676, 139: 4764, 140: 4778, 141: 4695, 142: 4686, 143: 4676, 144: 4739, 145: 4631, 146: 4651, 147: 4804, 148: 4843, 149: 4651, 150: 4755, 151: 4802, 152: 4723, 153: 4894, 154: 4708, 155: 4743, 156: 4682, 157: 4864, 158: 4798, 159: 4801, 160: 4741, 161: 4767, 162: 4742, 163: 4684, 164: 4763, 165: 4740, 166: 4691, 167: 4733, 168: 4725, 169: 4829, 170: 4764, 171: 4687, 172: 4715, 173: 4725, 174: 4634, 175: 4670, 176: 4768, 177: 4754, 178: 4762, 179: 4756, 180: 4585, 181: 4769, 182: 4630, 183: 4666, 184: 4785, 185: 4748, 186: 4765, 187: 4877, 188: 4690, 189: 4740, 190: 4786, 191: 4712, 192: 4728, 193: 4704, 194: 4668, 195: 4788, 196: 4640, 197: 4732, 198: 4838, 199: 4696, 200: 4903, 201: 4722, 202: 4751, 203: 4788, 204: 4728, 205: 4802, 206: 4872, 207: 4740, 208: 4834, 209: 4746, 210: 4840, 211: 4742, 212: 4773, 213: 4574, 214: 4700, 215: 4807, 216: 4737, 217: 4808, 218: 4819, 219: 4900, 220: 4864, 221: 4817, 222: 4754, 223: 4828, 224: 4798, 225: 4765, 226: 4850, 227: 4710, 228: 4789, 229: 4618, 230: 4843, 231: 4750, 232: 4791, 233: 4746, 234: 4728, 235: 4706, 236: 4798, 237: 4670, 238: 4775, 239: 4813, 240: 4864, 241: 4668, 242: 4771, 243: 4670, 244: 4668, 245: 4643, 246: 4819, 247: 4867, 248: 4839, 249: 4676, 250: 4894, 251: 4791, 252: 4790, 253: 4703, 254: 4817, 255: 4735, 256: 4716, 257: 4788, 258: 4548, 259: 4676, 260: 4853, 261: 4804, 262: 4702, 263: 4916, 264: 4835, 265: 4808, 266: 4648, 267: 4838, 268: 4592, 269: 4683, 270: 4689, 271: 4790, 272: 4643, 273: 4777, 274: 4709, 275: 4757, 276: 4851, 277: 4816, 278: 4914, 279: 4788, 280: 4789, 281: 4845, 282: 4860, 283: 4891, 284: 4741, 285: 4936, 286: 4809, 287: 4775, 288: 4683, 289: 4821, 290: 4771, 291: 4847, 292: 4790, 293: 4810, 294: 4720, 295: 4725, 296: 4804, 297: 4712, 298: 4737, 299: 4826, 300: 4817, 301: 4835, 302: 4781, 303: 4806, 304: 4772, 305: 4731, 306: 4694, 307: 4696, 308: 4751, 309: 4800, 310: 4663, 311: 4883, 312: 4580, 313: 4791, 314: 4892, 315: 914, 316: 144, 317: 482, 318: 785, 319: 1000, 320: 1286, 321: 1541, 322: 1697, 323: 1902, 324: 2049, 325: 2206, 326: 2342, 327: 2455, 328: 2644, 329: 2823, 330: 2855, 331: 2949, 332: 3102, 333: 3142, 334: 3140, 335: 3397, 336: 3326, 337: 3499, 338: 3496, 339: 3598, 340: 3573, 341: 3792, 342: 3747, 343: 3736, 344: 3955, 345: 3877, 346: 3891, 347: 3997, 348: 3937, 349: 3997, 350: 4139, 351: 4112, 352: 4164, 353: 4073, 354: 4158, 355: 4223, 356: 4181, 357: 4259, 358: 4224, 359: 4281, 360: 4212, 361: 4405, 362: 4437, 363: 4356, 364: 4276, 365: 4345, 366: 4441, 367: 4473, 368: 4579, 369: 4539, 370: 4511, 371: 4390, 372: 4589, 373: 4456, 374: 4457, 375: 4652, 376: 4645, 377: 4414, 378: 4584, 379: 4542, 380: 4582, 381: 4510, 382: 4593, 383: 4753, 384: 4614, 385: 4545, 386: 4594, 387: 4722, 388: 4638, 389: 4693, 390: 4730, 391: 4783, 392: 4683, 393: 4734, 394: 4557, 395: 4602, 396: 4662, 397: 4637, 398: 4636, 399: 4678, 400: 4715, 401: 4634, 402: 4740, 403: 4685, 404: 4766, 405: 4726, 406: 4630, 407: 4628, 408: 4686, 409: 4581, 410: 4734, 411: 4624, 412: 4757, 413: 4738, 414: 4692, 415: 4687, 416: 4757, 417: 4664, 418: 4720, 419: 4689, 420: 4639, 421: 4731, 422: 4743, 423: 4709, 424: 4776, 425: 4756, 426: 4738, 427: 4650, 428: 4701, 429: 4712, 430: 4794, 431: 4678, 432: 4689, 433: 4734, 434: 4794, 435: 4683, 436: 4815, 437: 4853, 438: 4847, 439: 4853, 440: 4800, 441: 4904, 442: 4696, 443: 4731, 444: 4848, 445: 4733, 446: 4891, 447: 4707, 448: 4760, 449: 4722, 450: 4855, 451: 4883, 452: 4823, 453: 4676, 454: 4764, 455: 4778, 456: 4695, 457: 4686, 458: 4676, 459: 4739, 460: 4631, 461: 4651, 462: 4804, 463: 4843, 464: 4651, 465: 4755, 466: 4802, 467: 4723, 468: 4894, 469: 4708, 470: 4743, 471: 4682, 472: 4864, 473: 4798, 474: 4801, 475: 4741, 476: 4767, 477: 4742, 478: 4684, 479: 4763, 480: 4740, 481: 4691, 482: 4733, 483: 4725, 484: 4829, 485: 4764, 486: 4687, 487: 4715, 488: 4725, 489: 4634, 490: 4670, 491: 4768, 492: 4754, 493: 4762, 494: 4756, 495: 4585, 496: 4769, 497: 4630, 498: 4666, 499: 4785, 500: 4748, 501: 4765, 502: 4877, 503: 4690, 504: 4740, 505: 4786, 506: 4712, 507: 4728, 508: 4704, 509: 4668, 510: 4788, 511: 4640, 512: 4732, 513: 4838, 514: 4696, 515: 4903, 516: 4722, 517: 4751, 518: 4788, 519: 4728, 520: 4802, 521: 4872, 522: 4740, 523: 4834, 524: 4746, 525: 4840, 526: 4742, 527: 4773, 528: 4574, 529: 4700, 530: 4807, 531: 4737, 532: 4808, 533: 4819, 534: 4900, 535: 4864, 536: 4817, 537: 4754, 538: 4828, 539: 4798, 540: 4765, 541: 4850, 542: 4710, 543: 4789, 544: 4618, 545: 4843, 546: 4750, 547: 4791, 548: 4746, 549: 4728, 550: 4706, 551: 4798, 552: 4670, 553: 4775, 554: 4813, 555: 4864, 556: 4668, 557: 4771, 558: 4670, 559: 4668, 560: 4643, 561: 4819, 562: 4867, 563: 4839, 564: 4676, 565: 4894, 566: 4791, 567: 4790, 568: 4703, 569: 4817, 570: 4735, 571: 4716, 572: 4788, 573: 4548, 574: 4676, 575: 4853, 576: 4804, 577: 4702, 578: 4916, 579: 4835, 580: 4808, 581: 4648, 582: 4838, 583: 4592, 584: 4683, 585: 4689, 586: 4790, 587: 4643, 588: 4777, 589: 4709, 590: 4757, 591: 4851, 592: 4816, 593: 4914, 594: 4788, 595: 4789, 596: 4845, 597: 4860, 598: 4891, 599: 4741, 600: 4936, 601: 4809, 602: 4775, 603: 4683, 604: 4821, 605: 4771, 606: 4847, 607: 4790, 608: 4810, 609: 4720, 610: 4725, 611: 4804, 612: 4712, 613: 4737, 614: 4826, 615: 4817, 616: 4835, 617: 4781, 618: 4806, 619: 4772, 620: 4731, 621: 4694, 622: 4696, 623: 4751, 624: 4800, 625: 4663, 626: 4883, 627: 4580, 628: 4791, 629: 4892, 630: 914, 631: 144, 632: 482, 633: 785, 634: 1000, 635: 1286, 636: 1541, 637: 1697, 638: 1902, 639: 2049, 640: 2206, 641: 2342, 642: 2455, 643: 2644, 644: 2823, 645: 2855, 646: 2949, 647: 3102, 648: 3142, 649: 3140, 650: 3397, 651: 3326, 652: 3499, 653: 3496, 654: 3598, 655: 3573, 656: 3792, 657: 3747, 658: 3736, 659: 3955, 660: 3877, 661: 3891, 662: 3997, 663: 3937, 664: 3997, 665: 4139, 666: 4112, 667: 4164, 668: 4073, 669: 4158, 670: 4223, 671: 4181, 672: 4259, 673: 4224, 674: 4281, 675: 4212, 676: 4405, 677: 4437, 678: 4356, 679: 4276, 680: 4345, 681: 4441, 682: 4473, 683: 4579, 684: 4539, 685: 4511, 686: 4390, 687: 4589, 688: 4456, 689: 4457, 690: 4652, 691: 4645, 692: 4414, 693: 4584, 694: 4542, 695: 4582, 696: 4510, 697: 4593, 698: 4753, 699: 4614, 700: 4545, 701: 4594, 702: 4722, 703: 4638, 704: 4693, 705: 4730, 706: 4783, 707: 4683, 708: 4734, 709: 4557, 710: 4602, 711: 4662, 712: 4637, 713: 4636, 714: 4678, 715: 4715, 716: 4634, 717: 4740, 718: 4685, 719: 4766, 720: 4726, 721: 4630, 722: 4628, 723: 4686, 724: 4581, 725: 4734, 726: 4624, 727: 4757, 728: 4738, 729: 4692, 730: 4687, 731: 4757, 732: 4664, 733: 4720, 734: 4689, 735: 4639, 736: 4731, 737: 4743, 738: 4709, 739: 4776, 740: 4756, 741: 4738, 742: 4650, 743: 4701, 744: 4712, 745: 4794, 746: 4678, 747: 4689, 748: 4734, 749: 4794, 750: 4683, 751: 4815, 752: 4853, 753: 4847, 754: 4853, 755: 4800, 756: 4904, 757: 4696, 758: 4731, 759: 4848, 760: 4733, 761: 4891, 762: 4707, 763: 4760, 764: 4722, 765: 4855, 766: 4883, 767: 4823, 768: 4676, 769: 4764, 770: 4778, 771: 4695, 772: 4686, 773: 4676, 774: 4739, 775: 4631, 776: 4651, 777: 4804, 778: 4843, 779: 4651, 780: 4755, 781: 4802, 782: 4723, 783: 4894, 784: 4708, 785: 4743, 786: 4682, 787: 4864, 788: 4798, 789: 4801, 790: 4741, 791: 4767, 792: 4742, 793: 4684, 794: 4763, 795: 4740, 796: 4691, 797: 4733, 798: 4725, 799: 4829, 800: 4764, 801: 4687, 802: 4715, 803: 4725, 804: 4634, 805: 4670, 806: 4768, 807: 4754, 808: 4762, 809: 4756, 810: 4585, 811: 4769, 812: 4630, 813: 4666, 814: 4785, 815: 4748, 816: 4765, 817: 4877, 818: 4690, 819: 4740, 820: 4786, 821: 4712, 822: 4728, 823: 4704, 824: 4668, 825: 4788, 826: 4640, 827: 4732, 828: 4838, 829: 4696, 830: 4903, 831: 4722, 832: 4751, 833: 4788, 834: 4728, 835: 4802, 836: 4872, 837: 4740, 838: 4834, 839: 4746, 840: 4840, 841: 4742, 842: 4773, 843: 4574, 844: 4700, 845: 4807, 846: 4737, 847: 4808, 848: 4819, 849: 4900, 850: 4864, 851: 4817, 852: 4754, 853: 4828, 854: 4798, 855: 4765, 856: 4850, 857: 4710, 858: 4789, 859: 4618, 860: 4843, 861: 4750, 862: 4791, 863: 4746, 864: 4728, 865: 4706, 866: 4798, 867: 4670, 868: 4775, 869: 4813, 870: 4864, 871: 4668, 872: 4771, 873: 4670, 874: 4668, 875: 4643, 876: 4819, 877: 4867, 878: 4839, 879: 4676, 880: 4894, 881: 4791, 882: 4790, 883: 4703, 884: 4817, 885: 4735, 886: 4716, 887: 4788, 888: 4548, 889: 4676, 890: 4853, 891: 4804, 892: 4702, 893: 4916, 894: 4835, 895: 4808, 896: 4648, 897: 4838, 898: 4592, 899: 4683, 900: 4689, 901: 4790, 902: 4643, 903: 4777, 904: 4709, 905: 4757, 906: 4851, 907: 4816, 908: 4914, 909: 4788, 910: 4789, 911: 4845, 912: 4860, 913: 4891, 914: 4741, 915: 4936, 916: 4809, 917: 4775, 918: 4683, 919: 4821, 920: 4771, 921: 4847, 922: 4790, 923: 4810, 924: 4720, 925: 4725, 926: 4804, 927: 4712, 928: 4737, 929: 4826, 930: 4817, 931: 4835, 932: 4781, 933: 4806, 934: 4772, 935: 4731, 936: 4694, 937: 4696, 938: 4751, 939: 4800, 940: 4663, 941: 4883, 942: 4580, 943: 4791, 944: 4892, 945: 914, 946: 144, 947: 482, 948: 785, 949: 1000, 950: 1286, 951: 1541, 952: 1697, 953: 1902, 954: 2049, 955: 2206, 956: 2342, 957: 2455, 958: 2644, 959: 2823, 960: 2855, 961: 2949, 962: 3102, 963: 3142, 964: 3140, 965: 3397, 966: 3326, 967: 3499, 968: 3496, 969: 3598, 970: 3573, 971: 3792, 972: 3747, 973: 3736, 974: 3955, 975: 3877, 976: 3891, 977: 3997, 978: 3937, 979: 3997, 980: 4139, 981: 4112, 982: 4164, 983: 4073, 984: 4158, 985: 4223, 986: 4181, 987: 4259, 988: 4224, 989: 4281, 990: 4212, 991: 4405, 992: 4437, 993: 4356, 994: 4276, 995: 4345, 996: 4441, 997: 4473, 998: 4579, 999: 4539, 1000: 4511, 1001: 4390, 1002: 4589, 1003: 4456, 1004: 4457, 1005: 4652, 1006: 4645, 1007: 4414, 1008: 4584, 1009: 4542, 1010: 4582, 1011: 4510, 1012: 4593, 1013: 4753, 1014: 4614, 1015: 4545, 1016: 4594, 1017: 4722, 1018: 4638, 1019: 4693, 1020: 4730, 1021: 4783, 1022: 4683, 1023: 4734, 1024: 4557, 1025: 4602, 1026: 4662, 1027: 4637, 1028: 4636, 1029: 4678, 1030: 4715, 1031: 4634, 1032: 4740, 1033: 4685, 1034: 4766, 1035: 4726, 1036: 4630, 1037: 4628, 1038: 4686, 1039: 4581, 1040: 4734, 1041: 4624, 1042: 4757, 1043: 4738, 1044: 4692, 1045: 4687, 1046: 4757, 1047: 4664, 1048: 4720, 1049: 4689, 1050: 4639, 1051: 4731, 1052: 4743, 1053: 4709, 1054: 4776, 1055: 4756, 1056: 4738, 1057: 4650, 1058: 4701, 1059: 4712, 1060: 4794, 1061: 4678, 1062: 4689, 1063: 4734, 1064: 4794, 1065: 4683, 1066: 4815, 1067: 4853, 1068: 4847, 1069: 4853, 1070: 4800, 1071: 4904, 1072: 4696, 1073: 4731, 1074: 4848, 1075: 4733, 1076: 4891, 1077: 4707, 1078: 4760, 1079: 4722, 1080: 4855, 1081: 4883, 1082: 4823, 1083: 4676, 1084: 4764, 1085: 4778, 1086: 4695, 1087: 4686, 1088: 4676, 1089: 4739, 1090: 4631, 1091: 4651, 1092: 4804, 1093: 4843, 1094: 4651, 1095: 4755, 1096: 4802, 1097: 4723, 1098: 4894, 1099: 4708, 1100: 4743, 1101: 4682, 1102: 4864, 1103: 4798, 1104: 4801, 1105: 4741, 1106: 4767, 1107: 4742, 1108: 4684, 1109: 4763, 1110: 4740, 1111: 4691, 1112: 4733, 1113: 4725, 1114: 4829, 1115: 4764, 1116: 4687, 1117: 4715, 1118: 4725, 1119: 4634, 1120: 4670, 1121: 4768, 1122: 4754, 1123: 4762, 1124: 4756, 1125: 4585, 1126: 4769, 1127: 4630, 1128: 4666, 1129: 4785, 1130: 4748, 1131: 4765, 1132: 4877, 1133: 4690, 1134: 4740, 1135: 4786, 1136: 4712, 1137: 4728, 1138: 4704, 1139: 4668, 1140: 4788, 1141: 4640, 1142: 4732, 1143: 4838, 1144: 4696, 1145: 4903, 1146: 4722, 1147: 4751, 1148: 4788, 1149: 4728, 1150: 4802, 1151: 4872, 1152: 4740, 1153: 4834, 1154: 4746, 1155: 4840, 1156: 4742, 1157: 4773, 1158: 4574, 1159: 4700, 1160: 4807, 1161: 4737, 1162: 4808, 1163: 4819, 1164: 4900, 1165: 4864, 1166: 4817, 1167: 4754, 1168: 4828, 1169: 4798, 1170: 4765, 1171: 4850, 1172: 4710, 1173: 4789, 1174: 4618, 1175: 4843, 1176: 4750, 1177: 4791, 1178: 4746, 1179: 4728, 1180: 4706, 1181: 4798, 1182: 4670, 1183: 4775, 1184: 4813, 1185: 4864, 1186: 4668, 1187: 4771, 1188: 4670, 1189: 4668, 1190: 4643, 1191: 4819, 1192: 4867, 1193: 4839, 1194: 4676, 1195: 4894, 1196: 4791, 1197: 4790, 1198: 4703, 1199: 4817, 1200: 4735, 1201: 4716, 1202: 4788, 1203: 4548, 1204: 4676, 1205: 4853, 1206: 4804, 1207: 4702, 1208: 4916, 1209: 4835, 1210: 4808, 1211: 4648, 1212: 4838, 1213: 4592, 1214: 4683, 1215: 4689, 1216: 4790, 1217: 4643, 1218: 4777, 1219: 4709, 1220: 4757, 1221: 4851, 1222: 4816, 1223: 4914, 1224: 4788, 1225: 4789, 1226: 4845, 1227: 4860, 1228: 4891, 1229: 4741, 1230: 4936, 1231: 4809, 1232: 4775, 1233: 4683, 1234: 4821, 1235: 4771, 1236: 4847, 1237: 4790, 1238: 4810, 1239: 4720, 1240: 4725, 1241: 4804, 1242: 4712, 1243: 4737, 1244: 4826, 1245: 4817, 1246: 4835, 1247: 4781, 1248: 4806, 1249: 4772, 1250: 4731, 1251: 4694, 1252: 4696, 1253: 4751, 1254: 4800, 1255: 4663, 1256: 4883, 1257: 4580, 1258: 4791, 1259: 4892, 1260: 914, 1261: 144, 1262: 482, 1263: 785, 1264: 1000, 1265: 1286, 1266: 1541, 1267: 1697, 1268: 1902, 1269: 2049, 1270: 2206, 1271: 2342, 1272: 2455, 1273: 2644, 1274: 2823, 1275: 2855, 1276: 2949, 1277: 3102, 1278: 3142, 1279: 3140, 1280: 3397, 1281: 3326, 1282: 3499, 1283: 3496, 1284: 3598, 1285: 3573, 1286: 3792, 1287: 3747, 1288: 3736, 1289: 3955, 1290: 3877, 1291: 3891, 1292: 3997, 1293: 3937, 1294: 3997, 1295: 4139, 1296: 4112, 1297: 4164, 1298: 4073, 1299: 4158, 1300: 4223, 1301: 4181, 1302: 4259, 1303: 4224, 1304: 4281, 1305: 4212, 1306: 4405, 1307: 4437, 1308: 4356, 1309: 4276, 1310: 4345, 1311: 4441, 1312: 4473, 1313: 4579, 1314: 4539, 1315: 4511, 1316: 4390, 1317: 4589, 1318: 4456, 1319: 4457, 1320: 4652, 1321: 4645, 1322: 4414, 1323: 4584, 1324: 4542, 1325: 4582, 1326: 4510, 1327: 4593, 1328: 4753, 1329: 4614, 1330: 4545, 1331: 4594, 1332: 4722, 1333: 4638, 1334: 4693, 1335: 4730, 1336: 4783, 1337: 4683, 1338: 4734, 1339: 4557, 1340: 4602, 1341: 4662, 1342: 4637, 1343: 4636, 1344: 4678, 1345: 4715, 1346: 4634, 1347: 4740, 1348: 4685, 1349: 4766, 1350: 4726, 1351: 4630, 1352: 4628, 1353: 4686, 1354: 4581, 1355: 4734, 1356: 4624, 1357: 4757, 1358: 4738, 1359: 4692, 1360: 4687, 1361: 4757, 1362: 4664, 1363: 4720, 1364: 4689, 1365: 4639, 1366: 4731, 1367: 4743, 1368: 4709, 1369: 4776, 1370: 4756, 1371: 4738, 1372: 4650, 1373: 4701, 1374: 4712, 1375: 4794, 1376: 4678, 1377: 4689, 1378: 4734, 1379: 4794, 1380: 4683, 1381: 4815, 1382: 4853, 1383: 4847, 1384: 4853, 1385: 4800, 1386: 4904, 1387: 4696, 1388: 4731, 1389: 4848, 1390: 4733, 1391: 4891, 1392: 4707, 1393: 4760, 1394: 4722, 1395: 4855, 1396: 4883, 1397: 4823, 1398: 4676, 1399: 4764, 1400: 4778, 1401: 4695, 1402: 4686, 1403: 4676, 1404: 4739, 1405: 4631, 1406: 4651, 1407: 4804, 1408: 4843, 1409: 4651, 1410: 4755, 1411: 4802, 1412: 4723, 1413: 4894, 1414: 4708, 1415: 4743, 1416: 4682, 1417: 4864, 1418: 4798, 1419: 4801, 1420: 4741, 1421: 4767, 1422: 4742, 1423: 4684, 1424: 4763, 1425: 4740, 1426: 4691, 1427: 4733, 1428: 4725, 1429: 4829, 1430: 4764, 1431: 4687, 1432: 4715, 1433: 4725, 1434: 4634, 1435: 4670, 1436: 4768, 1437: 4754, 1438: 4762, 1439: 4756, 1440: 4585, 1441: 4769, 1442: 4630, 1443: 4666, 1444: 4785, 1445: 4748, 1446: 4765, 1447: 4877, 1448: 4690, 1449: 4740, 1450: 4786, 1451: 4712, 1452: 4728, 1453: 4704, 1454: 4668, 1455: 4788, 1456: 4640, 1457: 4732, 1458: 4838, 1459: 4696, 1460: 4903, 1461: 4722, 1462: 4751, 1463: 4788, 1464: 4728, 1465: 4802, 1466: 4872, 1467: 4740, 1468: 4834, 1469: 4746, 1470: 4840, 1471: 4742, 1472: 4773, 1473: 4574, 1474: 4700, 1475: 4807, 1476: 4737, 1477: 4808, 1478: 4819, 1479: 4900, 1480: 4864, 1481: 4817, 1482: 4754, 1483: 4828, 1484: 4798, 1485: 4765, 1486: 4850, 1487: 4710, 1488: 4789, 1489: 4618, 1490: 4843, 1491: 4750, 1492: 4791, 1493: 4746, 1494: 4728, 1495: 4706, 1496: 4798, 1497: 4670, 1498: 4775, 1499: 4813, 1500: 4864, 1501: 4668, 1502: 4771, 1503: 4670, 1504: 4668, 1505: 4643, 1506: 4819, 1507: 4867, 1508: 4839, 1509: 4676, 1510: 4894, 1511: 4791, 1512: 4790, 1513: 4703, 1514: 4817, 1515: 4735, 1516: 4716, 1517: 4788, 1518: 4548, 1519: 4676, 1520: 4853, 1521: 4804, 1522: 4702, 1523: 4916, 1524: 4835, 1525: 4808, 1526: 4648, 1527: 4838, 1528: 4592, 1529: 4683, 1530: 4689, 1531: 4790, 1532: 4643, 1533: 4777, 1534: 4709, 1535: 4757, 1536: 4851, 1537: 4816, 1538: 4914, 1539: 4788, 1540: 4789, 1541: 4845, 1542: 4860, 1543: 4891, 1544: 4741, 1545: 4936, 1546: 4809, 1547: 4775, 1548: 4683, 1549: 4821, 1550: 4771, 1551: 4847, 1552: 4790, 1553: 4810, 1554: 4720, 1555: 4725, 1556: 4804, 1557: 4712, 1558: 4737, 1559: 4826, 1560: 4817, 1561: 4835, 1562: 4781, 1563: 4806, 1564: 4772, 1565: 4731, 1566: 4694, 1567: 4696, 1568: 4751, 1569: 4800, 1570: 4663, 1571: 4883, 1572: 4580, 1573: 4791, 1574: 4892, 1575: 914}}\n", + "{50000: {'zch_dlrmv3_kuairand27k': {1: 0.10478414948453608, 2: 0.08791076030927836, 3: 0.07694372852233677, 4: 0.06924532860824742, 5: 0.06319265463917526, 6: 0.06396316580756013, 7: 0.0819679675994109, 8: 0.1125865818298969, 9: 0.1408397766323024, 10: 0.16306378865979382, 11: 0.18189140112464855, 12: 0.19800391967353953, 13: 0.2106958762886598, 14: 0.2222075202503682, 15: 0.23182452749140894, 16: 0.24062701353092783, 17: 0.24862132352941177, 18: 0.2550383018327606, 19: 0.26038134156266957, 20: 0.26657538659793817, 21: 0.27153519268532156, 22: 0.27642484770384257, 23: 0.2808823117436127, 24: 0.2845421230670103, 25: 0.2880605670103093, 26: 0.2914601506740682, 27: 0.29456913421153114, 28: 0.2970360824742268, 29: 0.2997022751510843, 30: 0.3020108462199313, 31: 0.3045653890921184, 32: 0.3070357804445876, 33: 0.3086413425492034, 34: 0.3104485673135233, 35: 0.3120604749631811, 36: 0.31364366617589806, 37: 0.3153130401842668, 38: 0.3164366719660837, 39: 0.31773193491488455, 40: 0.3188697939111768, 41: 0.3202212975296563, 42: 0.32137610420893953, 43: 0.3225127849689976, 44: 0.32376987657575523, 45: 0.32475092274040473, 46: 0.32582589418608315, 47: 0.32697508457670516, 48: 0.3278565555201289, 49: 0.32855080992757174, 50: 0.3293848329901956, 51: 0.3301292884240585, 52: 0.3308358143295734, 53: 0.3316843721029195, 54: 0.3324224425199058, 55: 0.33339289009434375, 56: 0.33379648408171014, 57: 0.3346183304270166, 58: 0.3353906321610804, 59: 0.3358859395948415, 60: 0.33667888356357484, 61: 0.3375144925431079, 62: 0.3380684992373672, 63: 0.3386368808798672, 64: 0.3391069482237387, 65: 0.3396307082223186, 66: 0.34006170624604876, 67: 0.3406385326924603, 68: 0.34130974013205434, 69: 0.34178988435864927, 70: 0.3421090181006409, 71: 0.34280716005291306, 72: 0.3433874580192468, 73: 0.34377310273448103, 74: 0.34424302324821976, 75: 0.3447240390501659, 76: 0.34528460265005945, 77: 0.3455293312774206, 78: 0.34606312954506496, 79: 0.3462948650759502, 80: 0.34656309467473495, 81: 0.3469082324488915, 82: 0.34720074811742774, 83: 0.34752988534972507, 84: 0.3477524178839991, 85: 0.3481241767509737, 86: 0.3483177638369333, 87: 0.34865040523950513, 88: 0.3488985993823443, 89: 0.34936747353235575, 90: 0.34974090481943887, 91: 0.3500078777375138, 92: 0.3502182664409, 93: 0.3504293269172474, 94: 0.350593908899122, 95: 0.3509127290301247, 96: 0.3511158320789766, 97: 0.3513670613205432, 98: 0.35160165631333845, 99: 0.351817680340153, 100: 0.3519681677956682, 101: 0.35221536199105846, 102: 0.3523432058638188, 103: 0.35254364000068816, 104: 0.3528006295046214, 105: 0.35299442309315043, 106: 0.3532035568226893, 107: 0.35341405065558984, 108: 0.3535885766960662, 109: 0.3537480768577074, 110: 0.35391419596242135, 111: 0.354186893996456, 112: 0.3544245171887563, 113: 0.3546322735897608, 114: 0.3548250801577578, 115: 0.35499912449658555, 116: 0.3550965652570606, 117: 0.3552460377452013, 118: 0.3554660142880741, 119: 0.3557134290050047, 120: 0.3558667767463402, 121: 0.35602091801209657, 122: 0.35618507627444274, 123: 0.3563537684388093, 124: 0.3564814153221773, 125: 0.3565786675773724, 126: 0.356738940604452, 127: 0.3568478546268191, 128: 0.3569890470299366, 129: 0.35715177693943584, 130: 0.35724075118185367, 131: 0.35741875029974063, 132: 0.3575617120102122, 133: 0.35777095730597286, 134: 0.3579091565914547, 135: 0.35801428341298397, 136: 0.35824223594391663, 137: 0.35834868793146224, 138: 0.3584109896703356, 139: 0.35860625102130456, 140: 0.3587486695624658, 141: 0.3588530795182815, 142: 0.3589384349925297, 143: 0.35897190376467697, 144: 0.35911174204922885, 145: 0.3592007416875391, 146: 0.3591980735227997, 147: 0.3592776311456502, 148: 0.3593653654732303, 149: 0.3594719233594773, 150: 0.3595335657700509, 151: 0.35969040627508714, 152: 0.3596766732145251, 153: 0.3598952802957758, 154: 0.3599991213219084, 155: 0.3600444610962809, 156: 0.36010419275142697, 157: 0.36025499548278767, 158: 0.3603473035393579, 159: 0.36047897639514437, 160: 0.36056117946557165, 161: 0.36071290100681636, 162: 0.3608080581079516, 163: 0.36080420732843244, 164: 0.3609094342532352, 165: 0.3609430916375036, 166: 0.36106610770249714, 167: 0.36108106074600255, 168: 0.36112412245353914, 169: 0.36117858948824305, 170: 0.36130064213389534, 171: 0.3613524977214224, 172: 0.36145947624178687, 173: 0.36148886313724266, 174: 0.3615017106555021, 175: 0.3615199344225776, 176: 0.36168851524976947, 177: 0.36181924168532775, 178: 0.3618570943104065, 179: 0.36190982301271213, 180: 0.3619100591154651, 181: 0.36193610256341796, 182: 0.36198708538770613, 183: 0.36200978245416976, 184: 0.3621048982180777, 185: 0.36212235927412173, 186: 0.3621262084420435, 187: 0.3621903173161286, 188: 0.36224474713455723, 189: 0.36230627187545145, 190: 0.3623790187028999, 191: 0.3624438348539126, 192: 0.36247147901371396, 193: 0.36250760061714715, 194: 0.36254459535257577, 195: 0.36261136323176313, 196: 0.3625837550622885, 197: 0.362658232247181, 198: 0.3627494491037792, 199: 0.3627389673219915, 200: 0.3628618915315096, 201: 0.3628669833681625, 202: 0.3628668412328728, 203: 0.36293097736145064, 204: 0.3629755330443472, 205: 0.3630730883761024, 206: 0.36315171088463966, 207: 0.3631688735962609, 208: 0.36320445844161325, 209: 0.3632215898996587, 210: 0.3632726936602769, 211: 0.3633122429308979, 212: 0.36335217893302324, 213: 0.3633380437261085, 214: 0.36336995840677355, 215: 0.36345851913151533, 216: 0.3635518531707781, 217: 0.36360127104033113, 218: 0.36367351206519505, 219: 0.363785917117414, 220: 0.3638431159774462, 221: 0.36385496941324824, 222: 0.36386925573904555, 223: 0.36392747845804496, 224: 0.3640013620593129, 225: 0.3640244725342662, 226: 0.3640926400122598, 227: 0.3641307568202599, 228: 0.36419397424072164, 229: 0.36415886109941636, 230: 0.36419549240276666, 231: 0.3642171176002527, 232: 0.3642767916598098, 233: 0.36429965561990835, 234: 0.3643612205910194, 235: 0.3643588525503793, 236: 0.3644206687959175, 237: 0.36448026405673195, 238: 0.36453766633026646, 239: 0.36456863809007056, 240: 0.36461478981060164, 241: 0.36464418183847797, 242: 0.36466867123007723, 243: 0.36464423344008773, 244: 0.3646625799274422, 245: 0.3646781465523193, 246: 0.36475841660276437, 247: 0.3647969482396876, 248: 0.36486667311903254, 249: 0.3648873160617069, 250: 0.3649554772431009, 251: 0.36499838586596206, 252: 0.3650530997833562, 253: 0.365091781293795, 254: 0.365200556846902, 255: 0.36521340313580464, 256: 0.36526107336558955, 257: 0.36531683464348774, 258: 0.36528662241417315, 259: 0.365277790735644, 260: 0.3653263386293412, 261: 0.36536186165705153, 262: 0.36534300623647703, 263: 0.36543577235672764, 264: 0.3654848167730952, 265: 0.365560846261724, 266: 0.36558997499441326, 267: 0.36563517571385734, 268: 0.3656409683063775, 269: 0.36566408460614847, 270: 0.36566435748536896, 271: 0.3657080220725436, 272: 0.36568088794708137, 273: 0.3657038143326762, 274: 0.3657359801751431, 275: 0.36575619631621525, 276: 0.36580749204318425, 277: 0.36584824011831213, 278: 0.3659165093899557, 279: 0.36593405641666693, 280: 0.3659834087298916, 281: 0.36603756927361525, 282: 0.3660756364109979, 283: 0.3661339266960274, 284: 0.3661869850678541, 285: 0.3662269533451316, 286: 0.36626438908386943, 287: 0.3663139123899374, 288: 0.366317225517072, 289: 0.3663665019523248, 290: 0.36640738397409656, 291: 0.3664416188606152, 292: 0.36647975686278406, 293: 0.3665225827131144, 294: 0.3665396385314415, 295: 0.3665508449632849, 296: 0.3665981667193659, 297: 0.36659798153583134, 298: 0.36661185250774775, 299: 0.366641793658191, 300: 0.3666642861016709, 301: 0.3666868966786923, 302: 0.36673042733337635, 303: 0.36676915159386836, 304: 0.3667824506460852, 305: 0.36679196532271224, 306: 0.36679325798570295, 307: 0.36681133343722894, 308: 0.3668373983442183, 309: 0.3668588632424049, 310: 0.36686096270856683, 311: 0.36689231432240177, 312: 0.3669183017959014, 313: 0.3669757751773411, 314: 0.36699466195365826, 315: 0.3670117448967611, 316: 0.3658472636279399, 317: 0.36469014848723375, 318: 0.3635403298014274, 319: 0.36239773877322473, 320: 0.3612668496668297, 321: 0.36025345801802855, 322: 0.35967319261623953, 323: 0.35955726951870537, 324: 0.3595798830754477, 325: 0.3595906798598133, 326: 0.3596232067993384, 327: 0.3596710908080746, 328: 0.3596812636411215, 329: 0.3597183711114416, 330: 0.3597388596715731, 331: 0.3597780072956769, 332: 0.35982859213537527, 333: 0.35984153224613663, 334: 0.359831671042981, 335: 0.3599047788448422, 336: 0.35993708028895394, 337: 0.3599941062457025, 338: 0.3600503161961109, 339: 0.360075946557326, 340: 0.36011258660919393, 341: 0.3601606127890739, 342: 0.3602052884921825, 343: 0.36021533723471816, 344: 0.3602565420475204, 345: 0.36028182844016643, 346: 0.36034243548359246, 347: 0.36040967224824166, 348: 0.3604085478992392, 349: 0.36043634576957795, 350: 0.3604547578747395, 351: 0.36047994376765885, 352: 0.3605224385173524, 353: 0.3605152923676755, 354: 0.36053350069465284, 355: 0.3605411453287669, 356: 0.36057981439335873, 357: 0.3606026631257219, 358: 0.36062966841564537, 359: 0.3606776607351826, 360: 0.3606978037502635, 361: 0.36073527741178346, 362: 0.3607881537433668, 363: 0.3608116053931489, 364: 0.36081452463515873, 365: 0.36084042906115227, 366: 0.36085825145415135, 367: 0.3608746567562598, 368: 0.36091532148739086, 369: 0.36094417089389047, 370: 0.3610114801094341, 371: 0.3609979207988867, 372: 0.3610508348645911, 373: 0.36110033855638723, 374: 0.3611097441688401, 375: 0.36116946944525047, 376: 0.3612400398107017, 377: 0.3612682690784205, 378: 0.3613016872537304, 379: 0.36132129801511814, 380: 0.36135248830216316, 381: 0.3613701673939074, 382: 0.3614156457209025, 383: 0.3614806965544043, 384: 0.3615145084302846, 385: 0.3615213087038669, 386: 0.36159958880884213, 387: 0.3616591095853269, 388: 0.3616846222911582, 389: 0.36172805538886993, 390: 0.36177581837914446, 391: 0.3618412958447523, 392: 0.36184713900385035, 393: 0.36191168992482414, 394: 0.3619179388765658, 395: 0.36193273814924065, 396: 0.3619645831414057, 397: 0.36198711875709016, 398: 0.3620186664654984, 399: 0.36202922073981536, 400: 0.3620726113734628, 401: 0.3620793552267068, 402: 0.36211718458258213, 403: 0.36213800318668543, 404: 0.3622086616595667, 405: 0.3622600390426033, 406: 0.3622890975174753, 407: 0.36230651167771183, 408: 0.3623250271593138, 409: 0.3623337829720832, 410: 0.3623791088046348, 411: 0.3623986864087606, 412: 0.3624305095768479, 413: 0.3624594425802296, 414: 0.36248492159227985, 415: 0.36249549809539294, 416: 0.3625302734367422, 417: 0.36253681949255867, 418: 0.36256186871514634, 419: 0.36260182144142106, 420: 0.36262698036334234, 421: 0.36265681177066855, 422: 0.3626878401584952, 423: 0.36271051794148196, 424: 0.3627300432507577, 425: 0.3627519449615565, 426: 0.3628023483929436, 427: 0.3628445776620314, 428: 0.36287982146722386, 429: 0.36291189091535664, 430: 0.36293968217745004, 431: 0.36294749747421984, 432: 0.3629698468619591, 433: 0.36301203409174776, 434: 0.36306257962742733, 435: 0.3630880341810578, 436: 0.36311429715765525, 437: 0.3631439482071566, 438: 0.36317549019535594, 439: 0.3631960431244729, 440: 0.3632084330093085, 441: 0.36323924755776854, 442: 0.3632558649018713, 443: 0.3632822432984403, 444: 0.3633154088121182, 445: 0.36332757181289155, 446: 0.36336627608661515, 447: 0.3633952393502757, 448: 0.36344442611269895, 449: 0.36347308574562776, 450: 0.36349229346861694, 451: 0.36354898802056235, 452: 0.36356954902653854, 453: 0.3635770160574955, 454: 0.36362550591025455, 455: 0.36365835370961896, 456: 0.36367990934513755, 457: 0.36369589705742145, 458: 0.3636959590257914, 459: 0.36372959681269745, 460: 0.3637476523760752, 461: 0.36373692480107706, 462: 0.3637524409214488, 463: 0.3637708524848712, 464: 0.36379561861016885, 465: 0.36380622298200416, 466: 0.3638479480381953, 467: 0.36383455176835633, 468: 0.36389724333461776, 469: 0.3639228512773966, 470: 0.36392946637993234, 471: 0.3639410211778805, 472: 0.3639831253806644, 473: 0.3640061169643413, 474: 0.36404262884819416, 475: 0.3640628500699057, 476: 0.3641068859707036, 477: 0.3641321308399169, 478: 0.36412384915768764, 479: 0.36415299548702423, 480: 0.36415781562090443, 481: 0.36419364702728896, 482: 0.36419233665694195, 483: 0.36420088715611426, 484: 0.36421356964981105, 485: 0.36425015433236013, 486: 0.36426235098052007, 487: 0.36429421181407073, 488: 0.364298828246089, 489: 0.36429765117906315, 490: 0.36429845473508743, 491: 0.3643533146353859, 492: 0.3643949966949746, 493: 0.3644034526294429, 494: 0.36441742699515495, 495: 0.36441243855264827, 496: 0.3644169042931851, 497: 0.36443060472513905, 498: 0.3644340439526081, 499: 0.36446430762718945, 500: 0.36446605203257965, 501: 0.3644627975406894, 502: 0.36448205521652327, 503: 0.364497868037239, 504: 0.36451649925783713, 505: 0.36453952962899006, 506: 0.36455975840996485, 507: 0.36456606374161055, 508: 0.36457567915870315, 509: 0.3645857322159883, 510: 0.3646072931708917, 511: 0.3645927744860316, 512: 0.3646175461573259, 513: 0.3646489831381383, 514: 0.36464121695547363, 515: 0.36468533051413904, 516: 0.36468377756859344, 517: 0.3646802021443075, 518: 0.3647018698495041, 519: 0.3647159929997897, 520: 0.36475116030454535, 521: 0.36477906983405833, 522: 0.3647827638415156, 523: 0.36479384746848964, 524: 0.3647976530578156, 525: 0.36481511956714313, 526: 0.36482807200073986, 527: 0.36484128134600996, 528: 0.3648327455038108, 529: 0.36484284612197515, 530: 0.36487604368702625, 531: 0.3649113947819017, 532: 0.36492902349668965, 533: 0.36495612080192574, 534: 0.36499988443691544, 535: 0.36502116876555013, 536: 0.3650238622591331, 537: 0.3650275972287254, 538: 0.3650496107235631, 539: 0.3650782770796252, 540: 0.3650859236506755, 541: 0.3651124782735046, 542: 0.36512658189227737, 543: 0.36515132945752843, 544: 0.3651347635893125, 545: 0.365148452482462, 546: 0.36515588018898865, 547: 0.365179508384805, 548: 0.3651875942446094, 549: 0.3652122538241775, 550: 0.3652096908272473, 551: 0.36523465978795855, 552: 0.3652588074859027, 553: 0.3652821383832013, 554: 0.36529417349011095, 555: 0.36531285081515563, 556: 0.3653243520068709, 557: 0.36533378439201786, 558: 0.3653219329333132, 559: 0.3653287384770251, 560: 0.36533436735324126, 561: 0.3653684452688033, 562: 0.36538431728946985, 563: 0.36541403022351, 564: 0.3654221849995166, 565: 0.3654514399468689, 566: 0.365469617983805, 567: 0.3654931376749866, 568: 0.36550961599088416, 569: 0.3655575067888364, 570: 0.3655626348235457, 571: 0.3655834249179976, 572: 0.3656079496003371, 573: 0.3655938181492624, 574: 0.36558929152588676, 575: 0.3656107320188017, 576: 0.3656263565761209, 577: 0.3656173237477976, 578: 0.36565911784193406, 579: 0.3656811250659619, 580: 0.3657155722781486, 581: 0.3657286602380602, 582: 0.36574918690466096, 583: 0.36575165756970207, 584: 0.3657621302932352, 585: 0.36576208857056036, 586: 0.3657821425130414, 587: 0.36576942546260394, 588: 0.3657799337515425, 589: 0.3657947883396316, 590: 0.3658041242581645, 591: 0.365828031301775, 592: 0.3658470889381667, 593: 0.36587913950250617, 594: 0.3658874555510475, 595: 0.3659107902840216, 596: 0.3659364825034576, 597: 0.36595465798130095, 598: 0.3659824835601295, 599: 0.3660079270653969, 600: 0.3660272365402163, 601: 0.36604540806329966, 602: 0.3660694141283791, 603: 0.36607140468665816, 604: 0.36609542158223735, 605: 0.36611549292620227, 606: 0.3661324368280536, 607: 0.36615131790493693, 608: 0.36617252454482696, 609: 0.3661813449791468, 610: 0.3661873598822945, 611: 0.36621091120292515, 612: 0.3662114548591508, 613: 0.36621883836552493, 614: 0.36623407909787375, 615: 0.36624572938419725, 616: 0.366257472721131, 617: 0.3662795044728266, 618: 0.3662992462622406, 619: 0.3663065463735116, 620: 0.36631200175246803, 621: 0.3663134134906349, 622: 0.366323119141483, 623: 0.36633680669727675, 624: 0.3663482531198996, 625: 0.3663501138908661, 626: 0.3663665269249698, 627: 0.36638031497399914, 628: 0.366409855072166, 629: 0.36642019656405256, 630: 0.36642890945811046, 631: 0.3658466697688181, 632: 0.36526627745150103, 633: 0.36468772372787345, 634: 0.364110999875178, 635: 0.36353838625483814, 636: 0.36302331687661216, 637: 0.36272562797049046, 638: 0.3626621409054526, 639: 0.36266873576755976, 640: 0.3626693798737168, 641: 0.36268110775234147, 642: 0.3627007230229817, 643: 0.3627011886588394, 644: 0.3627154453603232, 645: 0.36272126990358744, 646: 0.36273670116092505, 647: 0.362758075168722, 648: 0.36276019301672624, 649: 0.3627506090262796, 650: 0.3627837883902231, 651: 0.3627960277103717, 652: 0.3628211091774919, 653: 0.3628458663221502, 654: 0.3628548675844188, 655: 0.3628696352378402, 656: 0.3628903890190603, 657: 0.36290948177330795, 658: 0.36291060040023737, 659: 0.3629280114879717, 660: 0.3629371729567766, 661: 0.3629648739887511, 662: 0.36299615018146497, 663: 0.3629916490120133, 664: 0.3630023614789522, 665: 0.3630081849657531, 666: 0.3630176346200988, 667: 0.3630362492963799, 668: 0.3630286999112563, 669: 0.3630345697553925, 670: 0.36303487859507083, 671: 0.36305167165352226, 672: 0.3630601242591251, 673: 0.3630708311328648, 674: 0.36309276666009405, 675: 0.3630999244274464, 676: 0.36311637707501404, 677: 0.3631411292294225, 678: 0.36315020817093235, 679: 0.3631483207413409, 680: 0.36315878710911015, 681: 0.3631649545673016, 682: 0.3631703935911657, 683: 0.36318893798290347, 684: 0.36320117205989383, 685: 0.36323423229956187, 686: 0.36322364987853006, 687: 0.36324905954399783, 688: 0.3632727082407739, 689: 0.36327465411760296, 690: 0.3633039743348826, 691: 0.3633392851008821, 692: 0.36335162633828705, 693: 0.3633668443924799, 694: 0.36337457320513494, 695: 0.3633886687825682, 696: 0.36339541592147995, 697: 0.36341743329142584, 698: 0.36345025986286383, 699: 0.36346601402381346, 700: 0.36346696044286025, 701: 0.3635072916361951, 702: 0.3635373873338226, 703: 0.36354879318458844, 704: 0.36357014337957455, 705: 0.3635939521513918, 706: 0.36362764181121143, 707: 0.3636283496877747, 708: 0.3636616672029724, 709: 0.36366266657101964, 710: 0.3636684387175649, 711: 0.3636837323248162, 712: 0.36369388056381186, 713: 0.3637090954051618, 714: 0.3637126217017153, 715: 0.3637345420788083, 716: 0.3637359933847487, 717: 0.36375489240811754, 718: 0.36376429413244876, 719: 0.3638017391890147, 720: 0.3638284284123116, 721: 0.3638426152035061, 722: 0.3638502775921101, 723: 0.3638585886691483, 724: 0.36386141318588444, 725: 0.36388494040605524, 726: 0.36389394755821014, 727: 0.3639099253834594, 728: 0.36392430679579524, 729: 0.3639367661763713, 730: 0.36394078707724603, 731: 0.36395860080601256, 732: 0.3639603752065813, 733: 0.36397271712285334, 734: 0.3639936036530444, 735: 0.3640060862553385, 736: 0.3640212768337713, 737: 0.3640371928045952, 738: 0.3640483621614302, 739: 0.3640577534989956, 740: 0.3640685374988573, 741: 0.3640957418415308, 742: 0.36411830351071983, 743: 0.3641368931538865, 744: 0.3641536967619089, 745: 0.36416807143710017, 746: 0.36417093771458486, 747: 0.3641822249991301, 748: 0.3642050289893265, 749: 0.3642327294203103, 750: 0.36424593379689013, 751: 0.3642596403476357, 752: 0.3642753498269355, 753: 0.3642921966590035, 754: 0.364302682472238, 755: 0.3643084362884787, 756: 0.3643249587170059, 757: 0.36433322691698183, 758: 0.3643472236391126, 759: 0.36436522462296966, 760: 0.3643709642370787, 761: 0.36439228071679, 762: 0.3644079269195658, 763: 0.36443548620856947, 764: 0.36445103468823065, 765: 0.36446105580049604, 766: 0.3644931792427441, 767: 0.3645040662281958, 768: 0.3645072525700396, 769: 0.3645346768479887, 770: 0.3645529099236808, 771: 0.36456450017912323, 772: 0.3645728191903015, 773: 0.3645717190318301, 774: 0.36459053969359695, 775: 0.3646001477857908, 776: 0.36459267178141885, 777: 0.36460079694038383, 778: 0.3646106648388113, 779: 0.36462434098932184, 780: 0.364629600214822, 781: 0.3646534482279309, 782: 0.3646444131982515, 783: 0.3646808602315025, 784: 0.36469518284849334, 785: 0.3646981588840924, 786: 0.36470410526014213, 787: 0.3647283940982042, 788: 0.36474125186940315, 789: 0.36476226065435235, 790: 0.3647735103532651, 791: 0.3647991187290385, 792: 0.36481345246064656, 793: 0.36480759775121646, 794: 0.364824324210311, 795: 0.36482638929427297, 796: 0.36484720715528596, 797: 0.36484559266349076, 798: 0.36484994947560523, 799: 0.3648568206834962, 800: 0.36487820232472623, 801: 0.3648848194744528, 802: 0.3649033955733173, 803: 0.3649054418751394, 804: 0.3649039696544771, 805: 0.364903704201283, 806: 0.3649363834510357, 807: 0.36496108079099937, 808: 0.3649655400014963, 809: 0.36497338006574104, 810: 0.3649696426818861, 811: 0.36497168641828787, 812: 0.36497939047981404, 813: 0.3649808215441181, 814: 0.36499870760926156, 815: 0.3649991211457289, 816: 0.36499646763542043, 817: 0.3650076502436431, 818: 0.36501673355451364, 819: 0.36502756838045264, 820: 0.3650411325083375, 821: 0.3650529924148257, 822: 0.36505628167375154, 823: 0.36506162221041344, 824: 0.3650672435845263, 825: 0.3650799923893633, 826: 0.36507043365425, 827: 0.36508519700719216, 828: 0.36510411574981655, 829: 0.3650987485736988, 830: 0.3651255783517419, 831: 0.36512408285456266, 832: 0.36512132998016283, 833: 0.36513427856967295, 834: 0.36514255130909473, 835: 0.3651639484878988, 836: 0.36518085383967797, 837: 0.3651826775362972, 838: 0.36518911939327864, 839: 0.3651910250502123, 840: 0.3652014766387015, 841: 0.36520912053142485, 842: 0.3652169379199351, 843: 0.36521114303500957, 844: 0.36521702712995696, 845: 0.3652374137546552, 846: 0.3652591829401339, 847: 0.3652698484625161, 848: 0.3652864841541808, 849: 0.3653136313902384, 850: 0.36532666346084924, 851: 0.36532800093614715, 852: 0.36532999828467516, 853: 0.36534353284138976, 854: 0.3653612879029055, 855: 0.3653657875897297, 856: 0.36538224948151915, 857: 0.36539085732591065, 858: 0.3654062169079151, 859: 0.3653954243242093, 860: 0.3654037990653175, 861: 0.3654082162682163, 862: 0.3654229226928634, 863: 0.36542777660892534, 864: 0.3654431734397991, 865: 0.3654412756614792, 866: 0.365456900798006, 867: 0.3654720244409998, 868: 0.3654866483270781, 869: 0.36549408816959744, 870: 0.3655057775775932, 871: 0.36551290035611916, 872: 0.36551871118936397, 873: 0.36551092073604163, 874: 0.36551505859294575, 875: 0.3655184491870605, 876: 0.36554007136186495, 877: 0.36555005054253403, 878: 0.36556892198788843, 879: 0.36557397998293567, 880: 0.3655925978160021, 881: 0.3656041205605044, 882: 0.365619093747444, 883: 0.3656295550314049, 884: 0.3656602573476589, 885: 0.36566344518054505, 886: 0.3656767352610034, 887: 0.365692451598101, 888: 0.36568323390566715, 889: 0.3656802092317501, 890: 0.3656939645941668, 891: 0.3657039758925504, 892: 0.3656980433159398, 893: 0.36572501542912855, 894: 0.3657392004762822, 895: 0.36576146804210263, 896: 0.3657699069648733, 897: 0.36578318472698973, 898: 0.36578475146938444, 899: 0.3657915206100298, 900: 0.3657914607623232, 901: 0.3658044763872801, 902: 0.36579617217877863, 903: 0.36580298796610455, 904: 0.3658126449460543, 905: 0.3658187141229071, 906: 0.36583429950718455, 907: 0.3658467367355737, 908: 0.36586767759978034, 909: 0.36587312676192363, 910: 0.3658884062692358, 911: 0.365905246470883, 912: 0.36591718355208175, 913: 0.36593545764269714, 914: 0.36595219089600445, 915: 0.3659649192116814, 916: 0.3659769149823234, 917: 0.3659927561749464, 918: 0.3659941479090069, 919: 0.3660100235777616, 920: 0.36602332124944814, 921: 0.3660345749895439, 922: 0.36604711697786796, 923: 0.36606120527553915, 924: 0.36606714190631096, 925: 0.36607123386323953, 926: 0.3660869059077287, 927: 0.3660873989914068, 928: 0.3660924122424528, 929: 0.3661026258617338, 930: 0.36611047497154725, 931: 0.36611839385544337, 932: 0.36613313497742267, 933: 0.36614637428362146, 934: 0.3661513784031598, 935: 0.3661551636742266, 936: 0.36615626857120886, 937: 0.36616288215465487, 938: 0.36617214817490934, 939: 0.3661799336751257, 940: 0.36618135080335396, 941: 0.36619245392446925, 942: 0.36620182038479454, 943: 0.3662216909817558, 944: 0.3662287843037908, 945: 0.36623463097856024, 946: 0.3658464713961701, 947: 0.3654591337368316, 948: 0.36507261539268804, 949: 0.3646869137669038, 950: 0.3643035563193695, 951: 0.3639582839776951, 952: 0.36375810849027235, 953: 0.3637145194355817, 954: 0.3637178308006641, 955: 0.3637171610647808, 956: 0.3637239258880719, 957: 0.36373599242477556, 958: 0.36373522149363074, 959: 0.36374371447591625, 960: 0.36374655402685313, 961: 0.3637558577354879, 962: 0.3637691711463765, 963: 0.36376954361490693, 964: 0.3637620414103392, 965: 0.3637833399745653, 966: 0.3637905510402482, 967: 0.3638064316041868, 968: 0.3638221124369173, 969: 0.36382717771567913, 970: 0.3638361450581278, 971: 0.3638491686964505, 972: 0.36386108551057006, 973: 0.3638608615059915, 974: 0.36387166401737375, 975: 0.3638768955458637, 976: 0.3638946916441152, 977: 0.3639149306430815, 978: 0.3639109372670183, 979: 0.36391726184300144, 980: 0.36392027772646474, 981: 0.36392576559823897, 982: 0.3639374826092076, 983: 0.363931433024939, 984: 0.36393450425226725, 985: 0.3639337983824057, 986: 0.36394431309039715, 987: 0.36394916166053976, 988: 0.3639555531728073, 989: 0.3639696061238419, 990: 0.36397359875298263, 991: 0.3639839385361065, 992: 0.36399995506996385, 993: 0.3640052872846918, 994: 0.36400313550923596, 995: 0.36400942756221366, 996: 0.36401278852657937, 997: 0.3640156568172851, 998: 0.3640274997362516, 999: 0.3640350352550943, 1000: 0.3640568470361473, 1001: 0.3640487704307122, 1002: 0.36406536766369635, 1003: 0.36408077658973625, 1004: 0.3640813051962214, 1005: 0.3641006322414202, 1006: 0.3641240942697816, 1007: 0.3641317943523945, 1008: 0.3641414816196095, 1009: 0.3641460283297943, 1010: 0.36415496276987286, 1011: 0.36415884820199274, 1012: 0.3641732572441036, 1013: 0.36419512991381164, 1014: 0.3642052544779442, 1015: 0.3642051771240279, 1016: 0.36423227789556667, 1017: 0.36425233897125275, 1018: 0.3642595121152691, 1019: 0.3642735644365789, 1020: 0.3642893305546637, 1021: 0.36431194546806056, 1022: 0.3643117639958111, 1023: 0.36433415476039394, 1024: 0.3643341884379843, 1025: 0.3643375303179151, 1026: 0.36434747573946247, 1027: 0.3643538640924708, 1028: 0.3643637741904474, 1029: 0.36436558346059766, 1030: 0.36438016596297845, 1031: 0.3643805462194087, 1032: 0.3643930518082084, 1033: 0.36439896795508675, 1034: 0.3644243928887545, 1035: 0.3644423580597996, 1036: 0.36445163824302296, 1037: 0.3644563849181312, 1038: 0.3644615891019215, 1039: 0.3644629757295042, 1040: 0.36447879876761646, 1041: 0.36448450921815523, 1042: 0.3644950899296295, 1043: 0.36450456662428965, 1044: 0.3645127104881711, 1045: 0.3645149671842484, 1046: 0.3645268674457017, 1047: 0.36452756408239706, 1048: 0.3645356547923154, 1049: 0.364549733065465, 1050: 0.36455794094110167, 1051: 0.36456805353702637, 1052: 0.36457868405494226, 1053: 0.3645859975748119, 1054: 0.3645920716496491, 1055: 0.36459912898310554, 1056: 0.36461771694357037, 1057: 0.3646330617739126, 1058: 0.36464563052567256, 1059: 0.3646569557498593, 1060: 0.364666584006244, 1061: 0.36466812859712505, 1062: 0.36467559964168367, 1063: 0.3646911828053677, 1064: 0.3647102268278278, 1065: 0.36471907741176085, 1066: 0.3647282900097845, 1067: 0.3647389228486844, 1068: 0.3647503672137532, 1069: 0.3647573345190763, 1070: 0.36476096906456107, 1071: 0.36477220991060255, 1072: 0.3647776311136307, 1073: 0.36478710495603484, 1074: 0.36479941743170846, 1075: 0.3648030708913551, 1076: 0.36481774639349135, 1077: 0.36482842189277404, 1078: 0.36484753973336753, 1079: 0.3648581677231839, 1080: 0.3648648891073514, 1081: 0.3648872804829599, 1082: 0.3648946339285554, 1083: 0.3648965323334222, 1084: 0.3649156300770747, 1085: 0.3649282195264078, 1086: 0.36493610271139776, 1087: 0.3649416691372225, 1088: 0.36494054759605365, 1089: 0.36495358666303734, 1090: 0.3649600855190223, 1091: 0.3649544366151485, 1092: 0.3649598867477495, 1093: 0.3649665824479213, 1094: 0.3649759960720644, 1095: 0.3649794210256379, 1096: 0.3649960974410453, 1097: 0.3649893428005126, 1098: 0.3650150226208682, 1099: 0.3650249367628902, 1100: 0.36502676042312077, 1101: 0.36503070700793433, 1102: 0.3650477585405544, 1103: 0.36505665548952676, 1104: 0.36507138581242304, 1105: 0.36507914939972896, 1106: 0.36509719002398994, 1107: 0.36510717672611026, 1108: 0.365102720162588, 1109: 0.3651144307447223, 1110: 0.3651156480711359, 1111: 0.3651303048143717, 1112: 0.36512889233135726, 1113: 0.3651317614565239, 1114: 0.3651364369506938, 1115: 0.36515152908228565, 1116: 0.3651560337638746, 1117: 0.36516913004124596, 1118: 0.36517036180353685, 1119: 0.3651690665726388, 1120: 0.36516863852635967, 1121: 0.3651919018038596, 1122: 0.3652094399885466, 1123: 0.3652124272608953, 1124: 0.36521785092135617, 1125: 0.3652149417814512, 1126: 0.36521619568458125, 1127: 0.3652215299008694, 1128: 0.3652223463627984, 1129: 0.36523502977861066, 1130: 0.3652351184891236, 1131: 0.36523299458182673, 1132: 0.36524085734669187, 1133: 0.3652472100892673, 1134: 0.3652548328515246, 1135: 0.3652644334453934, 1136: 0.3652728091667046, 1137: 0.3652749937970523, 1138: 0.36527866410383375, 1139: 0.36528254055364523, 1140: 0.3652915789540017, 1141: 0.36528447211243525, 1142: 0.36529497724963556, 1143: 0.36530850057211794, 1144: 0.36530443153111947, 1145: 0.3653237035078316, 1146: 0.36532244562868205, 1147: 0.36532027511214654, 1148: 0.3653294986908531, 1149: 0.3653353342179581, 1150: 0.3653507051400696, 1151: 0.3653628234593179, 1152: 0.36536399041919354, 1153: 0.3653685155888107, 1154: 0.36536974552282114, 1155: 0.3653771929524185, 1156: 0.3653826026052739, 1157: 0.36538814241161016, 1158: 0.36538377493878244, 1159: 0.3653879113156537, 1160: 0.36540261695051207, 1161: 0.36541834002142237, 1162: 0.3654259784273131, 1163: 0.36543797597880917, 1164: 0.36545764983225826, 1165: 0.36546703605238107, 1166: 0.3654678917347225, 1167: 0.36546923009089793, 1168: 0.36547899683925184, 1169: 0.3654918538568096, 1170: 0.36549503086175533, 1171: 0.36550695610596196, 1172: 0.36551314494127485, 1173: 0.36552427743687976, 1174: 0.36551627840401085, 1175: 0.36552230607081965, 1176: 0.3655254404613918, 1177: 0.3655361131957885, 1178: 0.36553957353089495, 1179: 0.3655507637760087, 1180: 0.3655492809770832, 1181: 0.36556064902090285, 1182: 0.36557165636758543, 1183: 0.3655823039337691, 1184: 0.36558768449158197, 1185: 0.36559618905429264, 1186: 0.36560134462693655, 1187: 0.3656055395508131, 1188: 0.3655997404201107, 1189: 0.36560270776041465, 1190: 0.36560512750949536, 1191: 0.36562096107889613, 1192: 0.3656282365457201, 1193: 0.36564206215875683, 1194: 0.3656457250887948, 1195: 0.36565937776913265, 1196: 0.3656678113622327, 1197: 0.3656787930506229, 1198: 0.36568645522082377, 1199: 0.3657090482980859, 1200: 0.3657113590383746, 1201: 0.36572112531127826, 1202: 0.36573268823349936, 1203: 0.36572584930248137, 1204: 0.3657235800610062, 1205: 0.3657337055532932, 1206: 0.36574107039605275, 1207: 0.36573665442734077, 1208: 0.3657565651631055, 1209: 0.3657670302827041, 1210: 0.3657834811423449, 1211: 0.3657897079961953, 1212: 0.3657995204416923, 1213: 0.3658006670584278, 1214: 0.365805667656607, 1215: 0.36580561164842174, 1216: 0.3658152459019875, 1217: 0.36580908099298426, 1218: 0.3658141244746763, 1219: 0.3658212782996682, 1220: 0.3658257742543238, 1221: 0.36583733538785645, 1222: 0.36584656600431986, 1223: 0.3658621165695992, 1224: 0.3658661687506066, 1225: 0.3658775272489617, 1226: 0.3658900520940853, 1227: 0.3658989388683788, 1228: 0.36591254306048027, 1229: 0.36592500872064926, 1230: 0.3659345014382598, 1231: 0.3659434542166501, 1232: 0.3659552747533781, 1233: 0.3659563416095209, 1234: 0.365968197885405, 1235: 0.36597813983396416, 1236: 0.3659865638803338, 1237: 0.3659959529088533, 1238: 0.3660065001439377, 1239: 0.3660109726280948, 1240: 0.36601407112360723, 1241: 0.3660258137753934, 1242: 0.3660262311665412, 1243: 0.3660300240591381, 1244: 0.3660377032895857, 1245: 0.36604361996722606, 1246: 0.36604959189849073, 1247: 0.36606066693451184, 1248: 0.3660706248680818, 1249: 0.3660744285029009, 1250: 0.3660773221701134, 1251: 0.36607821137942853, 1252: 0.36608322452692416, 1253: 0.36609022628062177, 1254: 0.3660961227969735, 1255: 0.3660972513735416, 1256: 0.3661056387475892, 1257: 0.3661127287127167, 1258: 0.36612769792295347, 1259: 0.36613309245531483, 1260: 0.3661374917387851, 1261: 0.3658463721309821, 1262: 0.3655557150996451, 1263: 0.36526551954312836, 1264: 0.3649757843632816, 1265: 0.3646876575156309, 1266: 0.3644279889023321, 1267: 0.36427720838264305, 1268: 0.3642440372020512, 1269: 0.36424610824869535, 1270: 0.36424518757067376, 1271: 0.3642498593357598, 1272: 0.3642585232221586, 1273: 0.36425753150762097, 1274: 0.36426351359231524, 1275: 0.3642652428813691, 1276: 0.36427184235000715, 1277: 0.36428146672109907, 1278: 0.3642813454884586, 1279: 0.36427528970380335, 1280: 0.36429094502475245, 1281: 0.3642959856699871, 1282: 0.36430756912366347, 1283: 0.3643190085973591, 1284: 0.3643224432954473, 1285: 0.3643288261136881, 1286: 0.364338275738912, 1287: 0.36434689499433565, 1288: 0.36434634761652795, 1289: 0.3643541328073201, 1290: 0.3643577119781826, 1291: 0.3643707927631398, 1292: 0.36438572820684356, 1293: 0.36438234258179103, 1294: 0.36438676242931745, 1295: 0.3643886812933014, 1296: 0.364392474742912, 1297: 0.3644009855086106, 1298: 0.3643960459308251, 1299: 0.36439801387413767, 1300: 0.3643971215707408, 1301: 0.3644047336058833, 1302: 0.36440805470153825, 1303: 0.36441254811499285, 1304: 0.3644228553127886, 1305: 0.3644255360855118, 1306: 0.3644330352643824, 1307: 0.3644448475231807, 1308: 0.3644485547265988, 1309: 0.3644465812179338, 1310: 0.3644510210756141, 1311: 0.3644532368739218, 1312: 0.36445508002348015, 1313: 0.3644637464976064, 1314: 0.36446914290637294, 1315: 0.36448539941473135, 1316: 0.36447892935876014, 1317: 0.3644912298599826, 1318: 0.3645026333894298, 1319: 0.3645027151319526, 1320: 0.36451711051363045, 1321: 0.3645346624680523, 1322: 0.3645402166797555, 1323: 0.3645472882457591, 1324: 0.36455044608449816, 1325: 0.36455695076326106, 1326: 0.3645596093822595, 1327: 0.3645702957149378, 1328: 0.36458668116150866, 1329: 0.36459411095475563, 1330: 0.36459375881416667, 1331: 0.3646141539938359, 1332: 0.3646291841361168, 1333: 0.3646343790261374, 1334: 0.36464483190194535, 1335: 0.364656599659057, 1336: 0.3646736076469801, 1337: 0.36467319774763823, 1338: 0.36469004712338554, 1339: 0.3646898064292358, 1340: 0.3646920967916674, 1341: 0.3646994413388985, 1342: 0.36470406750378165, 1343: 0.36471139215088616, 1344: 0.3647125181561378, 1345: 0.36472342739374036, 1346: 0.36472346302060893, 1347: 0.3647327894147466, 1348: 0.3647370706565522, 1349: 0.3647563084578937, 1350: 0.3647698360001584, 1351: 0.36477670978876336, 1352: 0.36478010970776487, 1353: 0.36478386263451335, 1354: 0.36478468812786796, 1355: 0.3647965953982199, 1356: 0.3648007446079692, 1357: 0.3648086360600344, 1358: 0.3648156835046502, 1359: 0.3648217105789251, 1360: 0.3648232169209469, 1361: 0.36483213637952944, 1362: 0.3648324472502655, 1363: 0.3648384442645004, 1364: 0.3648490494315033, 1365: 0.36485514374190187, 1366: 0.3648627067330897, 1367: 0.36487067206395857, 1368: 0.3648760879303252, 1369: 0.3648805522624471, 1370: 0.36488577617781254, 1371: 0.3648998846836822, 1372: 0.36491150104504455, 1373: 0.3649209835381146, 1374: 0.36492951203423407, 1375: 0.3649367363166295, 1376: 0.3649377305831922, 1377: 0.3649432966763905, 1378: 0.36495512370203237, 1379: 0.36496962667134103, 1380: 0.36497626904142794, 1381: 0.36498319407612084, 1382: 0.3649912190275162, 1383: 0.3649998744900062, 1384: 0.3650050756813786, 1385: 0.3650077044853897, 1386: 0.3650162127451411, 1387: 0.36502022669215556, 1388: 0.36502737580261735, 1389: 0.36503672330537534, 1390: 0.3650393778900904, 1391: 0.36505056055804025, 1392: 0.36505865320515996, 1393: 0.3650732833090012, 1394: 0.36508134797841346, 1395: 0.36508639164234347, 1396: 0.3651035727458977, 1397: 0.3651091133380421, 1398: 0.36511043031585755, 1399: 0.3651250758420998, 1400: 0.3651346834373804, 1401: 0.36514064691368325, 1402: 0.3651448167668182, 1403: 0.36514380182789813, 1404: 0.3651537711276381, 1405: 0.36515867064147955, 1406: 0.3651541454025275, 1407: 0.3651582334098363, 1408: 0.3651632903393418, 1409: 0.36517046006354814, 1410: 0.3651729818346987, 1411: 0.3651857988332249, 1412: 0.36518041598583156, 1413: 0.36520023706220667, 1414: 0.36520781193485924, 1415: 0.365209100191694, 1416: 0.3652120400047275, 1417: 0.3652251737854814, 1418: 0.36523196949055486, 1419: 0.36524330697798124, 1420: 0.36524922750749295, 1421: 0.36526315018026173, 1422: 0.3652708083075347, 1423: 0.36526722271203993, 1424: 0.3652762278011617, 1425: 0.3652770623079385, 1426: 0.36528836892826066, 1427: 0.3652871571212763, 1428: 0.3652892824557705, 1429: 0.36529281713959505, 1430: 0.3653044761918365, 1431: 0.365307882453564, 1432: 0.3653179925250654, 1433: 0.36531884948475, 1434: 0.3653177348935151, 1435: 0.36531729693704296, 1436: 0.3653353550541268, 1437: 0.36534894991804473, 1438: 0.36535118578425313, 1439: 0.3653553259268588, 1440: 0.36535295726588873, 1441: 0.36535384115843456, 1442: 0.36535791483936614, 1443: 0.3653584583972562, 1444: 0.36536828143715083, 1445: 0.3653682583877187, 1446: 0.3653665047165616, 1447: 0.36537256391632944, 1448: 0.36537744397253097, 1449: 0.3653833200878796, 1450: 0.36539074692860823, 1451: 0.3653972177187461, 1452: 0.3653988426959477, 1453: 0.3654016321485949, 1454: 0.3654045843145278, 1455: 0.3654115825571066, 1456: 0.36540593010815253, 1457: 0.36541408130353553, 1458: 0.36542460207319527, 1459: 0.3654213314750177, 1460: 0.36543636668339957, 1461: 0.3654353026240173, 1462: 0.3654335222262891, 1463: 0.36544068299846294, 1464: 0.36544518726639774, 1465: 0.36545717922278953, 1466: 0.3654666218297419, 1467: 0.3654674673911243, 1468: 0.3654709512693631, 1469: 0.36547184767452245, 1470: 0.3654776302037128, 1471: 0.365481813432, 1472: 0.36548610064215087, 1473: 0.3654826001467924, 1474: 0.3654857856988147, 1475: 0.36549728549184995, 1476: 0.3655095900214752, 1477: 0.3655155380852472, 1478: 0.36552491889645544, 1479: 0.3655403452727822, 1480: 0.36554767852061676, 1481: 0.36554829770118247, 1482: 0.3655492973227767, 1483: 0.36555693624198826, 1484: 0.3655670126084394, 1485: 0.36556946524320266, 1486: 0.36557881338894616, 1487: 0.3655836432950157, 1488: 0.36559237256777355, 1489: 0.36558601923052425, 1490: 0.365590726192778, 1491: 0.36559315300460715, 1492: 0.3656015278615619, 1493: 0.36560421449968605, 1494: 0.3656130029410776, 1495: 0.36561179072079636, 1496: 0.3656207241844203, 1497: 0.3656293760780958, 1498: 0.3656377469669702, 1499: 0.3656419602480568, 1500: 0.3656486433225609, 1501: 0.36565268236880116, 1502: 0.3656559636404871, 1503: 0.3656513457679692, 1504: 0.36565365749512324, 1505: 0.3656555370683814, 1506: 0.36566802667971043, 1507: 0.36567375073582226, 1508: 0.36568465934546857, 1509: 0.3656875296813135, 1510: 0.36569830775249135, 1511: 0.36570495811424963, 1512: 0.3657136283097022, 1513: 0.3657196728610827, 1514: 0.3657375453056225, 1515: 0.3657393569517433, 1516: 0.36574707632588827, 1517: 0.3657562221483206, 1518: 0.3657507862049075, 1519: 0.3657489708842037, 1520: 0.3657569821843749, 1521: 0.36576280710066655, 1522: 0.36575929036271543, 1523: 0.36577506992435865, 1524: 0.36578336077410845, 1525: 0.3657964043762483, 1526: 0.3658013379602776, 1527: 0.36580911950633027, 1528: 0.3658100235569107, 1529: 0.36581398828110523, 1530: 0.3658139383486015, 1531: 0.3658215858285303, 1532: 0.3658166837811822, 1533: 0.3658206864364631, 1534: 0.36582636764501136, 1535: 0.3658299380803879, 1536: 0.3658391266598962, 1537: 0.3658464652214806, 1538: 0.36585883240303624, 1539: 0.36586205771656033, 1540: 0.36587109665031003, 1541: 0.3658810666438156, 1542: 0.36588814472248177, 1543: 0.36589897997370446, 1544: 0.3659089124554563, 1545: 0.3659164811264047, 1546: 0.3659236223135507, 1547: 0.36593304995296416, 1548: 0.36593391420854215, 1549: 0.3659433750982619, 1550: 0.3659513136110032, 1551: 0.36595804493925704, 1552: 0.36596554767423656, 1553: 0.36597397624185285, 1554: 0.3659775635581974, 1555: 0.36598005622261237, 1556: 0.3659894447414443, 1557: 0.3659898011393238, 1558: 0.36599285098757145, 1559: 0.36599900327316975, 1560: 0.36600375069110874, 1561: 0.36600854371968145, 1562: 0.3660174127643655, 1563: 0.366025392558469, 1564: 0.3660284594831623, 1565: 0.3660308004479488, 1566: 0.3660315406542394, 1567: 0.3660355764104756, 1568: 0.3660412027282078, 1569: 0.36604594734544543, 1570: 0.36604688163017113, 1571: 0.3660536202489348, 1572: 0.366059323404511, 1573: 0.366071330531007, 1574: 0.36607568191554046}, 'nonzch_dlrmv3_kuairand27k': {1: 0.012228260869565218, 2: 0.026579483695652172, 3: 0.039939990942028984, 4: 0.05118461277173913, 5: 0.06278872282608695, 6: 0.07413383152173914, 7: 0.08412994953416149, 8: 0.09380307404891304, 9: 0.10271361714975845, 10: 0.11117527173913043, 11: 0.11914834486166008, 12: 0.1265922214673913, 13: 0.13412547031772576, 14: 0.1416682841614907, 15: 0.14838654891304348, 16: 0.15476392663043478, 17: 0.16115529092071612, 18: 0.167025211352657, 19: 0.1722683066361556, 20: 0.17807829483695653, 21: 0.1830478454968944, 22: 0.18823338685770752, 23: 0.1929569352551985, 24: 0.19764775815217392, 25: 0.20187839673913044, 26: 0.2064988764632107, 27: 0.21063556763285024, 28: 0.2144434200310559, 29: 0.21862994284107945, 30: 0.2223165760869565, 31: 0.22580371230715288, 32: 0.22935419497282608, 33: 0.23253509963768115, 34: 0.23567874840153452, 35: 0.23898728649068324, 36: 0.2420814479638009, 37: 0.2450958788396296, 38: 0.24774825112308071, 39: 0.25044968924622063, 40: 0.2531540483500431, 41: 0.2556394715364634, 42: 0.2581642515984745, 43: 0.26050245896782603, 44: 0.26284439262979503, 45: 0.2649520063714703, 46: 0.267324301470724, 47: 0.2696534601582179, 48: 0.27174224597038166, 49: 0.2736071102976605, 50: 0.27551457174789634, 51: 0.2775070855494756, 52: 0.2794752194207358, 53: 0.28153892992773244, 54: 0.2834632914259113, 55: 0.28527443477831205, 56: 0.28683738804181996, 57: 0.2886419914954989, 58: 0.2902032161987237, 59: 0.29169965481204674, 60: 0.29342222599685763, 61: 0.2950785663964714, 62: 0.29636504105355727, 63: 0.29783984319181234, 64: 0.29921281785199594, 65: 0.30059580584046514, 66: 0.3018442311800146, 67: 0.3031605953591194, 68: 0.3046380692363222, 69: 0.30590162643054253, 70: 0.3070453635514359, 71: 0.3082154912763784, 72: 0.3095040942128991, 73: 0.3106596646183271, 74: 0.31184712176960844, 75: 0.3130448075551177, 76: 0.3142701975447152, 77: 0.31535346137811004, 78: 0.31646447555523616, 79: 0.31735708127377144, 80: 0.31827514092506287, 81: 0.3192334388099387, 82: 0.32014246920382544, 83: 0.32102857002531415, 84: 0.321936034391069, 85: 0.3228591125720623, 86: 0.32368073344485637, 87: 0.32458693780492803, 88: 0.3254194661638027, 89: 0.32631057640742994, 90: 0.3271441377683416, 91: 0.3278697857074863, 92: 0.3285778111736155, 93: 0.3293235732979751, 94: 0.3299586033930401, 95: 0.3307170378051724, 96: 0.3313623600723988, 97: 0.33211081946659987, 98: 0.33282753791732456, 99: 0.33349031597259754, 100: 0.3341355912051702, 101: 0.33482694658812096, 102: 0.3354273134942243, 103: 0.33606219462121073, 104: 0.3366595514994929, 105: 0.33720508900913143, 106: 0.33781404076060395, 107: 0.3384211336712325, 108: 0.33899024783796405, 109: 0.33960112006756554, 110: 0.34018544396149064, 111: 0.3407454672597598, 112: 0.3412287632447745, 113: 0.34174183337116093, 114: 0.3422540961013846, 115: 0.34281800391389433, 116: 0.3432872644638143, 117: 0.3437564872519602, 118: 0.34425014285940475, 119: 0.3447783199905228, 120: 0.34521913901332596, 121: 0.34574531550260174, 122: 0.3462893172822714, 123: 0.346820330332694, 124: 0.347346887340477, 125: 0.3478290112846574, 126: 0.34837357769770694, 127: 0.3487704802930466, 128: 0.3491844021979276, 129: 0.3496689299769456, 130: 0.3500708784353177, 131: 0.3505691166536796, 132: 0.35094142730493033, 133: 0.35134198061704164, 134: 0.35171247244745213, 135: 0.35216114036246515, 136: 0.35262069404775437, 137: 0.353036345896597, 138: 0.3533555118221684, 139: 0.3537238494746373, 140: 0.35409541718479876, 141: 0.3544117239626435, 142: 0.3547181930288942, 143: 0.355014436912888, 144: 0.35534371988625035, 145: 0.35560749880375, 146: 0.35587702383964587, 147: 0.35623127135001104, 148: 0.3566031099178481, 149: 0.3568605256243435, 150: 0.3571733891034304, 151: 0.35750854154071116, 152: 0.3577951460764052, 153: 0.3581729181456539, 154: 0.3584432142221007, 155: 0.35872919861558783, 156: 0.35897830921280055, 157: 0.35932269216018986, 158: 0.3596272413917282, 159: 0.3599295619305415, 160: 0.36019625712358266, 161: 0.36047335343001896, 162: 0.36073392321600156, 163: 0.3609610776774043, 164: 0.36122636980928075, 165: 0.3614766083752501, 166: 0.3616987642699831, 167: 0.3619396173183605, 168: 0.3621735589786414, 169: 0.3624569921353458, 170: 0.36270462014797544, 171: 0.36291111171809626, 172: 0.36312902673139885, 173: 0.3633493311970123, 174: 0.36352268972528495, 175: 0.36371153671642487, 176: 0.36394552407146047, 177: 0.3641701503321817, 178: 0.36439606932544283, 179: 0.3646166173973564, 180: 0.3647540384198938, 181: 0.36497627096377655, 182: 0.3651312028989362, 183: 0.36530114756692517, 184: 0.36552416758704437, 185: 0.36572779198506833, 186: 0.36593698849666817, 187: 0.36619481010766974, 188: 0.36636541817257035, 189: 0.36655668700459165, 190: 0.3667665025282266, 191: 0.36694121910173555, 192: 0.3671211924856174, 193: 0.367288740497398, 194: 0.36743880236889254, 195: 0.36763958490022075, 196: 0.3677741936182704, 197: 0.3679470947778897, 198: 0.3681637127623848, 199: 0.36831755588111414, 200: 0.3685577548969279, 201: 0.368719091629258, 202: 0.3688910226847066, 203: 0.36907673817271974, 204: 0.36923565577097356, 205: 0.36942367767076684, 206: 0.3696387310342553, 207: 0.36979755334393694, 208: 0.3699932266555397, 209: 0.3701512708023256, 210: 0.37034582238615305, 211: 0.3704990873911057, 212: 0.3706633242683196, 213: 0.3707466787763432, 214: 0.3708792549731881, 215: 0.37105286129415394, 216: 0.37119733911535807, 217: 0.37136827077620516, 218: 0.371541919240908, 219: 0.37174539124716005, 220: 0.3719331171430457, 221: 0.37210108380933715, 222: 0.372243437785822, 223: 0.3724126953057316, 224: 0.3725690680939583, 225: 0.37271159566393497, 226: 0.3728848014579478, 227: 0.37300410654342175, 228: 0.3731517896683846, 229: 0.3732347698196583, 230: 0.37340010389978656, 231: 0.37354258836747106, 232: 0.3736861409790771, 233: 0.3738120595681462, 234: 0.3739303692036336, 235: 0.3740397215056849, 236: 0.37418125315317846, 237: 0.37427572402514336, 238: 0.37440686759721875, 239: 0.3745504162713599, 240: 0.3747108150398118, 241: 0.37480081555502776, 242: 0.3749262176629826, 243: 0.3750152898572504, 244: 0.37510293580216836, 245: 0.3751812004883314, 246: 0.37531958758615835, 247: 0.37547335754301736, 248: 0.37561629913014416, 249: 0.37570249963335983, 250: 0.3758620642800511, 251: 0.3759855080995892, 252: 0.3761076351421028, 253: 0.3761995935731659, 254: 0.3763289433650628, 255: 0.3764299697004615, 256: 0.37652390376790285, 257: 0.3766408986999701, 258: 0.37667798765904303, 259: 0.37675676030152894, 260: 0.3768927405125351, 261: 0.3770117351079053, 262: 0.37709675934599585, 263: 0.3772502384647327, 264: 0.37737649863124745, 265: 0.37749315322232785, 266: 0.3775578487093188, 267: 0.3776824921644352, 268: 0.3777282530371313, 269: 0.3778024024877271, 270: 0.3778778898420609, 271: 0.37798447056847445, 272: 0.3780443713435229, 273: 0.3781455173713874, 274: 0.3782248491366619, 275: 0.37831842693145523, 276: 0.37844024982292207, 277: 0.3785504626646122, 278: 0.3786898196261288, 279: 0.3787898250089033, 280: 0.3788894193236088, 281: 0.3790052289880932, 282: 0.3791247344636784, 283: 0.37925269789407917, 284: 0.3793349062104725, 285: 0.37947464306849354, 286: 0.3795756919621515, 287: 0.37966597603563584, 288: 0.3797285048126173, 289: 0.37983115245939697, 290: 0.3799184502024396, 291: 0.38002732720445964, 292: 0.3801188809439745, 293: 0.3802156065172365, 294: 0.3802856771472725, 295: 0.38035671207228205, 296: 0.38044993231964863, 297: 0.38051621861344737, 298: 0.38058918443546325, 299: 0.38068694029532807, 300: 0.380781496719419, 301: 0.3808805032866096, 302: 0.38096366921829683, 303: 0.38105329302616026, 304: 0.3811328291956611, 305: 0.38120042790087444, 306: 0.3812573162872975, 307: 0.38131438728998146, 308: 0.3813862525070213, 309: 0.3814711193072042, 310: 0.3815179080673006, 311: 0.38162447005058786, 312: 0.381647875646653, 313: 0.3817283800554251, 314: 0.3818356876458768, 315: 0.3818548533142614, 316: 0.3806820723091274, 317: 0.37960749134488064, 318: 0.3786208107831688, 319: 0.3776977149991646, 320: 0.37685649656064907, 321: 0.37608816619429475, 322: 0.3753658672011126, 323: 0.37470208646227116, 324: 0.3740810403025807, 325: 0.3735049527981856, 326: 0.37296792501019793, 327: 0.37246360964230574, 328: 0.3720114328251443, 329: 0.371608330301495, 330: 0.371215932232598, 331: 0.370850087472165, 332: 0.37052568418947296, 333: 0.3702134600114632, 334: 0.3699026003320571, 335: 0.36965890915781113, 336: 0.3693986836498036, 337: 0.36918370697821284, 338: 0.36896924991802094, 339: 0.3687816745189089, 340: 0.36858894593445596, 341: 0.36845202046804504, 342: 0.368304697047762, 343: 0.3681555048064156, 344: 0.36806137412271955, 345: 0.3679485452353565, 346: 0.3678398143642364, 347: 0.3677577143193565, 348: 0.3676614111635047, 349: 0.36758029512724444, 350: 0.36753417814612344, 351: 0.36748694573324575, 352: 0.3674474020465588, 353: 0.36738613993173075, 354: 0.36734566292303417, 355: 0.3673209995540274, 356: 0.36728643307393105, 357: 0.3672706577540668, 358: 0.367246649300949, 359: 0.3672362891807128, 360: 0.36720967291951373, 361: 0.3672287092025211, 362: 0.3672551640077384, 363: 0.3672624803393681, 364: 0.3672510501224792, 365: 0.3672557725222809, 366: 0.36728279362150007, 367: 0.36731708832988713, 368: 0.36737571199801655, 369: 0.3674247910979157, 370: 0.36746716352678677, 371: 0.3674815488420023, 372: 0.36754138552392074, 373: 0.36757323741453696, 374: 0.36760246970443106, 375: 0.3676758020838156, 376: 0.36774715907290395, 377: 0.3677659886674041, 378: 0.3678229939776777, 379: 0.36787026649289106, 380: 0.3679262481668648, 381: 0.36796585242507823, 382: 0.3680237402474725, 383: 0.3681168778647734, 384: 0.36817872349479136, 385: 0.3682249948495858, 386: 0.3682818291574104, 387: 0.3683665166928351, 388: 0.3684323426117885, 389: 0.3685098617111484, 390: 0.3685950561099488, 391: 0.368691349168278, 392: 0.36876544067524325, 393: 0.3688501977862834, 394: 0.36889629390923157, 395: 0.3689518509294504, 396: 0.36902002044077464, 397: 0.36908248699954127, 398: 0.3691444251823179, 399: 0.3692150098149366, 400: 0.3692931122073426, 401: 0.36935363527635195, 402: 0.3694362947439724, 403: 0.36950692965778664, 404: 0.36959427523331534, 405: 0.3696727842085225, 406: 0.36973078493394956, 407: 0.36978808190709556, 408: 0.369857193984428, 409: 0.3699041221404539, 410: 0.36998257479596575, 411: 0.3700378709769851, 412: 0.37012036696641376, 413: 0.3701985480575799, 414: 0.3702668962052957, 415: 0.3703338891180738, 416: 0.37041487726234024, 417: 0.3704764994674274, 418: 0.37054922569208937, 419: 0.3706153087591069, 420: 0.37067094699667835, 421: 0.3707449143505737, 422: 0.3708209499921365, 423: 0.37088978628940444, 424: 0.37097174249654635, 425: 0.37104930822102655, 426: 0.37112291390538005, 427: 0.3711786390355684, 428: 0.37124424186664906, 429: 0.3713117199108617, 430: 0.3713951088165248, 431: 0.3714552104744074, 432: 0.37151719981565295, 433: 0.37158774460833977, 434: 0.3716697262382639, 435: 0.37172961960667417, 436: 0.3718149963976861, 437: 0.3719073800781113, 438: 0.37199817561493354, 439: 0.3720897195479215, 440: 0.3721705982765835, 441: 0.3722711737010945, 442: 0.37233125575056686, 443: 0.3723977878652162, 444: 0.3724864391307247, 445: 0.372552704652815, 446: 0.3726488122262146, 447: 0.37270946817865175, 448: 0.37277991779400493, 449: 0.37284285273606876, 450: 0.3729306523223656, 451: 0.373023343728613, 452: 0.37310433096802126, 453: 0.373157352672726, 454: 0.373226630727682, 455: 0.3732982213922069, 456: 0.3733540124223788, 457: 0.3734078834203932, 458: 0.3734596612350647, 459: 0.37352288978694914, 460: 0.37356662919122774, 461: 0.3736131110657142, 462: 0.37368756478277276, 463: 0.37376886222593786, 464: 0.37381460639239367, 465: 0.37387918024536143, 466: 0.37395205661883624, 467: 0.3740102292928956, 468: 0.3740992364538959, 469: 0.3741541254336731, 470: 0.3742151154319469, 471: 0.37426482846163, 472: 0.37434713266451697, 473: 0.37441721813213047, 474: 0.3744875457671007, 475: 0.37454683127088545, 476: 0.37461051381705307, 477: 0.374669470398262, 478: 0.3747178578642532, 479: 0.37478007281683146, 480: 0.3748379519644874, 481: 0.3748869242021204, 482: 0.3749431052974241, 483: 0.37499764439423067, 484: 0.3750702363085993, 485: 0.37513112784238944, 486: 0.3751782909726176, 487: 0.3752301508685777, 488: 0.37528354098303507, 489: 0.375320882419914, 490: 0.375364320772755, 491: 0.37542455995189317, 492: 0.37548213333877367, 493: 0.37554085309725044, 494: 0.37559830156999224, 495: 0.3756261323395753, 496: 0.37568540599924577, 497: 0.3757206508034064, 498: 0.37576190285050093, 499: 0.37582327442855973, 500: 0.3758781055970625, 501: 0.3759356038026368, 502: 0.3760118501669607, 503: 0.3760561701134614, 504: 0.37610875236973484, 505: 0.37616887403219496, 506: 0.3762163181673997, 507: 0.37626625914405154, 508: 0.37631198465594334, 509: 0.37635151428254876, 510: 0.3764109023220379, 511: 0.3764454223790143, 512: 0.37649509116199836, 513: 0.3765621411902226, 514: 0.3766054316390151, 515: 0.3766827415774355, 516: 0.37672991565391417, 517: 0.3767816779907767, 518: 0.37683931557830286, 519: 0.376886897663196, 520: 0.3769464004931909, 521: 0.3770171023011761, 522: 0.37706602463758365, 523: 0.3771300466662384, 524: 0.3771795399951402, 525: 0.37724407322305237, 526: 0.3772925141402125, 527: 0.3773457740842651, 528: 0.37736677585611156, 529: 0.37740795650424197, 530: 0.3774661525620898, 531: 0.3775129168680193, 532: 0.3775708560665928, 533: 0.3776303328123292, 534: 0.3777024875762938, 535: 0.37776864907968577, 536: 0.3778271054619647, 537: 0.3778753657238239, 538: 0.3779351447485426, 539: 0.37798996781172595, 540: 0.3780393899870802, 541: 0.37810199194994837, 542: 0.3781423939414339, 543: 0.37819502060065735, 544: 0.37822071919604533, 545: 0.37828143538673265, 546: 0.37833292314018946, 547: 0.3783851272390522, 548: 0.3784301565100573, 549: 0.3784722329803497, 550: 0.37851075424117236, 551: 0.3785633360190905, 552: 0.37859600554419176, 553: 0.37864470518466753, 554: 0.3786990623812164, 555: 0.3787610386219215, 556: 0.37879281070745696, 557: 0.3788401954658805, 558: 0.3788720162559297, 559: 0.3789034187415219, 560: 0.3789309121702687, 561: 0.37898498873624625, 562: 0.3790461363200263, 563: 0.3791028367058755, 564: 0.3791347568379066, 565: 0.3791993779167678, 566: 0.3792482938307444, 567: 0.37929688695246283, 568: 0.3793322824478365, 569: 0.37938459220624554, 570: 0.37942448365979525, 571: 0.37946140533262634, 572: 0.3795089025792175, 573: 0.3795206132901296, 574: 0.3795512475946252, 575: 0.3796079538025843, 576: 0.3796572282379205, 577: 0.3796912980139712, 578: 0.3797567361899499, 579: 0.3798100508375894, 580: 0.37985922250093984, 581: 0.37988480510546113, 582: 0.3799380625266304, 583: 0.379955253132835, 584: 0.37998563612566816, 585: 0.3800167873139774, 586: 0.3800624892972929, 587: 0.38008673888339334, 588: 0.38013028590469766, 589: 0.3801638669220867, 590: 0.3802042524781331, 591: 0.3802580270113934, 592: 0.3803065919158059, 593: 0.3803690465742329, 594: 0.3804132519626376, 595: 0.3804574514732811, 596: 0.38050949270461465, 597: 0.38056349600217426, 598: 0.3806217267919703, 599: 0.38065846776231466, 600: 0.3807227235387726, 601: 0.3807687954019996, 602: 0.3808099111820043, 603: 0.38083791615592333, 604: 0.38088525736799334, 605: 0.380925413984126, 606: 0.38097610260584036, 607: 0.38101863863595736, 608: 0.38106383181078435, 609: 0.3810963093866367, 610: 0.3811293773500001, 611: 0.3811733317745693, 612: 0.3812043591762962, 613: 0.38123875322317435, 614: 0.3812853610853973, 615: 0.38133057274852594, 616: 0.381378122213234, 617: 0.38141807505020786, 618: 0.38146133833231605, 619: 0.3814997909164891, 620: 0.38153249604589884, 621: 0.3815600292484944, 622: 0.381587747220808, 623: 0.38162288309330034, 624: 0.38166458352297844, 625: 0.3816875109863288, 626: 0.38174024901451, 627: 0.3817517260235033, 628: 0.38179173642167247, 629: 0.381845273340482, 630: 0.3818548533142614, 631: 0.3812675310600324, 632: 0.38072760702409353, 633: 0.38023014831565133, 634: 0.37976313577189696, 635: 0.3793359448534479, 636: 0.3789442373051074, 637: 0.37857461344801535, 638: 0.3782335081144299, 639: 0.3779130592351579, 640: 0.3776145000290005, 641: 0.37733493852747524, 642: 0.377071235598756, 643: 0.3768333800290343, 644: 0.37661992908720265, 645: 0.3764113655815024, 646: 0.37621583779797285, 647: 0.3760410487571103, 648: 0.3758720558998671, 649: 0.3757033227951883, 650: 0.375568771516394, 651: 0.37542534955167306, 652: 0.3753049581454575, 653: 0.37518454528719186, 654: 0.3750777794266582, 655: 0.374968091007825, 656: 0.37488715899174774, 657: 0.3748006429184892, 658: 0.37471296728046943, 659: 0.374653849830639, 660: 0.3745848508816872, 661: 0.3745178643276529, 662: 0.3744647120157074, 663: 0.3744040162486627, 664: 0.3743511963219287, 665: 0.374316713938754, 666: 0.3742816589661002, 667: 0.3742505753023927, 668: 0.3742079878309412, 669: 0.37417634422175455, 670: 0.37415305416362044, 671: 0.3741245051771644, 672: 0.3741059224286125, 673: 0.37408296783597994, 674: 0.3740672808212551, 675: 0.37404293840830205, 676: 0.3740429724540782, 677: 0.37404703015427326, 678: 0.3740409057842092, 679: 0.3740247698124524, 680: 0.3740173192667391, 681: 0.3740218908447808, 682: 0.37403044316713785, 683: 0.37405218169894006, 684: 0.37406887841774233, 685: 0.37408204670125855, 686: 0.37408016177190667, 687: 0.3741029399556163, 688: 0.3741106772673136, 689: 0.37411703658860523, 690: 0.3741474342034976, 691: 0.37417688130065996, 692: 0.37417782762715673, 693: 0.37419965277649825, 694: 0.37421626335562796, 695: 0.37423772515507603, 696: 0.37425031939164055, 697: 0.37427301386937245, 698: 0.37431515527862447, 699: 0.3743402489828674, 700: 0.3743568803196075, 701: 0.3743794140439728, 702: 0.3744174039527409, 703: 0.374445114696678, 704: 0.3744793965195165, 705: 0.37451804812721234, 706: 0.37456297995645654, 707: 0.37459574491651715, 708: 0.37463454853534484, 709: 0.37465199283996653, 710: 0.37467478270293547, 711: 0.3747046912519654, 712: 0.3747315269116252, 713: 0.3747581677405615, 714: 0.3747897406553058, 715: 0.37482562969139166, 716: 0.37485178914603207, 717: 0.37489045888911127, 718: 0.3749225006442968, 719: 0.37496404189252697, 720: 0.3750007388487625, 721: 0.37502600083438775, 722: 0.37505095690525303, 723: 0.3750826717824872, 724: 0.37510195492469617, 725: 0.3751391467419646, 726: 0.37516333984465217, 727: 0.37520303720477505, 728: 0.37524040389491137, 729: 0.3752722971971106, 730: 0.3753035199570566, 731: 0.3753428073960936, 732: 0.3753711738196911, 733: 0.3754059650769595, 734: 0.37543706668738414, 735: 0.3754622935876067, 736: 0.37549809066689854, 737: 0.37553517617709886, 738: 0.37556823987432236, 739: 0.375608930247557, 740: 0.3756472101272671, 741: 0.3756833190105396, 742: 0.375709236494139, 743: 0.3757409260117522, 744: 0.3757737884835153, 745: 0.3758159302112776, 746: 0.3758447246762854, 747: 0.3758746951427232, 748: 0.37590970542850166, 749: 0.375951439729746, 750: 0.3759804665841918, 751: 0.3760243748924827, 752: 0.37607246678281353, 753: 0.37611975251460433, 754: 0.37616758978225606, 755: 0.3762093257039074, 756: 0.37626265867030684, 757: 0.37629246601785443, 758: 0.37632612421763023, 759: 0.3763728125206736, 760: 0.3764064999609189, 761: 0.37645776825161303, 762: 0.37648835151688165, 763: 0.3765247660079099, 764: 0.3765568520426634, 765: 0.3766036498281349, 766: 0.3766534359938148, 767: 0.3766964346938246, 768: 0.37672303192006873, 769: 0.37675929850500156, 770: 0.3767970180061552, 771: 0.37682547798035293, 772: 0.37685287194186423, 773: 0.37687909394385305, 774: 0.3769121749178945, 775: 0.37693376634428766, 776: 0.37695704065262126, 777: 0.3769970122647305, 778: 0.37704114687834955, 779: 0.37706419322344115, 780: 0.3770985270556223, 781: 0.37713789403592357, 782: 0.37716856307622626, 783: 0.37721773858293184, 784: 0.3772465989829974, 785: 0.3772791799261426, 786: 0.37730507342162906, 787: 0.3773505807200992, 788: 0.37738884473776774, 789: 0.37742733512381144, 790: 0.37745926472101055, 791: 0.3774939105608481, 792: 0.3775257825669738, 793: 0.37755135000503826, 794: 0.37758531974480736, 795: 0.3776167419247626, 796: 0.37764284662795483, 797: 0.3776733700646615, 798: 0.3777029637467832, 799: 0.3777435595185592, 800: 0.3777771395596827, 801: 0.377802455361767, 802: 0.37783067880905197, 803: 0.377859891529733, 804: 0.37787940004735254, 805: 0.377902665470761, 806: 0.3779362195123625, 807: 0.3779682139928405, 808: 0.378000971630107, 809: 0.3780330170138103, 810: 0.3780470189154564, 811: 0.3780802922258371, 812: 0.37809891698044756, 813: 0.37812126377513366, 814: 0.37815599539161404, 815: 0.3781867785084594, 816: 0.3782192587775641, 817: 0.37826332437870563, 818: 0.3782878294851122, 819: 0.378317469476886, 820: 0.3783518104495369, 821: 0.3783783979865825, 822: 0.3784065769746881, 823: 0.37843220596146226, 824: 0.3784540550666118, 825: 0.37848822787715014, 826: 0.3785070715996568, 827: 0.37853533552962115, 828: 0.3785744241824217, 829: 0.3785988432955658, 830: 0.3786444245219236, 831: 0.3786713625757982, 832: 0.378701201584331, 833: 0.3787347482574435, 834: 0.37876209284665835, 835: 0.37879691256845915, 836: 0.37883877342454453, 837: 0.3788671151757665, 838: 0.37890493359352434, 839: 0.37893373712874245, 840: 0.3789719936204793, 841: 0.3790002439298053, 842: 0.3790315596557599, 843: 0.37904271523222255, 844: 0.3790665468062878, 845: 0.3791010961026956, 846: 0.3791285233409948, 847: 0.3791630180356973, 848: 0.37919853492070327, 849: 0.3792420856709713, 850: 0.3792819301349603, 851: 0.37931698159652244, 852: 0.37934565912689905, 853: 0.3793816506094629, 854: 0.3794145687206407, 855: 0.3794441257237765, 856: 0.37948206230802023, 857: 0.37950601082740204, 858: 0.37953773746470093, 859: 0.37955245261990467, 860: 0.3795893936673251, 861: 0.3796205473476834, 862: 0.37965219104480674, 863: 0.3796793246948379, 864: 0.3797046228433483, 865: 0.3797276984203644, 866: 0.3797597594411168, 867: 0.37977918511681075, 868: 0.37980885819728777, 869: 0.379842183373466, 870: 0.3798804193712873, 871: 0.37989942150073, 872: 0.379928429769516, 873: 0.37994752809985255, 874: 0.37996638794856874, 875: 0.37998277371235056, 876: 0.3800162159148676, 877: 0.38005423835890256, 878: 0.38008946074512506, 879: 0.3801088256696633, 880: 0.3801492232259342, 881: 0.3801795819540397, 882: 0.38020977524797156, 883: 0.38023151730164984, 884: 0.3802641818794629, 885: 0.3802888894315174, 886: 0.38031171660576363, 887: 0.3803413982934689, 888: 0.3803480187058617, 889: 0.3803668740009949, 890: 0.3804026069595013, 891: 0.38043358072580724, 892: 0.3804547562424209, 893: 0.38049627247826606, 894: 0.3805299872687791, 895: 0.3805610599895321, 896: 0.3805768708165101, 897: 0.3806106671558216, 898: 0.38062108188151167, 899: 0.38064008518671405, 900: 0.3806596133620426, 901: 0.38068863499576694, 902: 0.38070372715788015, 903: 0.38073141065440863, 904: 0.380752633264024, 905: 0.3807783211980339, 906: 0.380812779160545, 907: 0.38084387804126285, 908: 0.3808840904384848, 909: 0.3809124215955838, 910: 0.380940783860652, 911: 0.38097431337314946, 912: 0.3810091684752809, 913: 0.3810468357037096, 914: 0.38107045848735605, 915: 0.38111216010083193, 916: 0.38114197530290894, 917: 0.38116857103998064, 918: 0.3811865828286526, 919: 0.38121733025525933, 920: 0.3812433871680962, 921: 0.3812764075448888, 922: 0.3813040967713421, 923: 0.3813335692882549, 924: 0.38135469159970264, 925: 0.38137622800968485, 926: 0.38140497560923625, 927: 0.3814252180994608, 928: 0.38144770869448436, 929: 0.38147830082747675, 930: 0.38150800377827876, 931: 0.38153928758162886, 932: 0.3815655751067453, 933: 0.38159408568570724, 934: 0.3816194383019466, 935: 0.3816410062122629, 936: 0.38165916511870174, 937: 0.3816774667766561, 938: 0.3817007174748802, 939: 0.3817283577941041, 940: 0.381743540697223, 941: 0.38177858008020255, 942: 0.3817861817561816, 943: 0.3818128019269196, 944: 0.3818484673004695, 945: 0.3818548533142614, 946: 0.3814630976499463, 947: 0.3811025601420389, 948: 0.380769998316922, 949: 0.3804574283935835, 950: 0.3801711502705613, 951: 0.3799083054229795, 952: 0.3796599658756732, 953: 0.37943046348859427, 954: 0.37921456261828407, 955: 0.37901311194624776, 956: 0.37882419577915977, 957: 0.3786457285211683, 958: 0.37848443164764833, 959: 0.3783393635134125, 960: 0.37819743635724123, 961: 0.3780641331744548, 962: 0.37794464859805443, 963: 0.37782894919477517, 964: 0.37771331381751017, 965: 0.3776205927467459, 966: 0.3775218066105957, 967: 0.37743845672861304, 968: 0.3773550156457209, 969: 0.37728070901445115, 970: 0.37720436174027955, 971: 0.3771473738756235, 972: 0.37708656207513963, 973: 0.3770249131095739, 974: 0.37698253351372113, 975: 0.37693343022204945, 976: 0.37688564901357197, 977: 0.37684720264248467, 978: 0.3768036120902793, 979: 0.3767653284714061, 980: 0.3767394589996485, 981: 0.37671319541449244, 982: 0.3766895992331999, 983: 0.3766581699817364, 984: 0.3766341588338709, 985: 0.3766158145330136, 986: 0.37659388115414266, 987: 0.3765787202007182, 988: 0.3765605741630752, 989: 0.37654737146556116, 990: 0.3765282620121463, 991: 0.37652577102077955, 992: 0.37652603126827944, 993: 0.3765193466792133, 994: 0.37650582391229875, 995: 0.37649823199897053, 996: 0.37649886081108064, 997: 0.3765022207558357, 998: 0.3765146159242467, 999: 0.3765235775738653, 1000: 0.37653013759830883, 1001: 0.37652639399538984, 1002: 0.3765395649762519, 1003: 0.3765424439006372, 1004: 0.37654438019937375, 1005: 0.37656283035438387, 1006: 0.3765806513850903, 1007: 0.3765789087480861, 1008: 0.3765915266765038, 1009: 0.3766005760082507, 1010: 0.37661297881120503, 1011: 0.3766192944520788, 1012: 0.3766325794486108, 1013: 0.37665928385493697, 1014: 0.37667426605307414, 1015: 0.3766834316509305, 1016: 0.37669668471995066, 1017: 0.3767206258136059, 1018: 0.376737495517867, 1019: 0.37675892670968847, 1020: 0.37678340370471264, 1021: 0.3768122515407807, 1022: 0.3768327134053702, 1023: 0.3768573789895246, 1024: 0.37686728214432025, 1025: 0.3768809031524229, 1026: 0.37689947564051507, 1027: 0.3769159396898822, 1028: 0.37693228882364477, 1029: 0.37695208058683694, 1030: 0.37697489170162013, 1031: 0.376990970699358, 1032: 0.3770157618421678, 1033: 0.3770359726126373, 1034: 0.3770628125049395, 1035: 0.3770863106047447, 1036: 0.37710187534509504, 1037: 0.37711724582214773, 1038: 0.3771373430061984, 1039: 0.37714879900585685, 1040: 0.37717275577393516, 1041: 0.37718767171677525, 1042: 0.37721342389514245, 1043: 0.3772375759324743, 1044: 0.3772579310101911, 1045: 0.37727783975685664, 1046: 0.3773034068123226, 1047: 0.37732136399585825, 1048: 0.3773438352835377, 1049: 0.3773637481369153, 1050: 0.3773795696037688, 1051: 0.37740281197356484, 1052: 0.3774269810055461, 1053: 0.3774483556052211, 1054: 0.3774751003995307, 1055: 0.37750018072817965, 1056: 0.37752376254223735, 1057: 0.3775402130609342, 1058: 0.3775607355068919, 1059: 0.3775821032474781, 1060: 0.3776100152378701, 1061: 0.3776285684029471, 1062: 0.37764796818655133, 1063: 0.37767093469582286, 1064: 0.3776986578229238, 1065: 0.377717457327584, 1066: 0.3777467613767024, 1067: 0.3777790417319739, 1068: 0.37781078330859513, 1069: 0.3778429430994155, 1070: 0.37787082656640586, 1071: 0.37790692314539304, 1072: 0.3779264370721941, 1073: 0.3779486909373366, 1074: 0.37798017569754055, 1075: 0.3780024963134878, 1076: 0.3780372737628148, 1077: 0.37805744490640286, 1078: 0.3780817632508477, 1079: 0.37810303884348007, 1080: 0.3781347567095899, 1081: 0.3781686203985991, 1082: 0.3781977014937396, 1083: 0.3782151758184827, 1084: 0.37823952748031375, 1085: 0.3782649323981705, 1086: 0.3782837853936248, 1087: 0.37830189890703536, 1088: 0.3783191967526648, 1089: 0.3783413866754703, 1090: 0.3783554275332912, 1091: 0.37837067819587245, 1092: 0.378397826033583, 1093: 0.3784279610437213, 1094: 0.37844310333707626, 1095: 0.37846630164955697, 1096: 0.37849310742030684, 1097: 0.3785137348963855, 1098: 0.3785475798488155, 1099: 0.3785669583518588, 1100: 0.3785890096364088, 1101: 0.378606305246549, 1102: 0.37863762587597166, 1103: 0.37866379681193957, 1104: 0.3786901515089023, 1105: 0.37871183700216887, 1106: 0.3787354839821779, 1107: 0.37875716604858517, 1108: 0.37877435366393514, 1109: 0.3787975730528096, 1110: 0.3788189869738267, 1111: 0.3788366085482416, 1112: 0.37885741292447106, 1113: 0.3788775680853412, 1114: 0.3789056325361979, 1115: 0.37892868502531857, 1116: 0.3789458239076237, 1117: 0.37896506546392006, 1118: 0.37898503377808207, 1119: 0.3789980450955232, 1120: 0.37901376874439624, 1121: 0.37903690457942213, 1122: 0.37905893713137506, 1123: 0.37908153664465816, 1124: 0.37910364154566306, 1125: 0.37911277075741606, 1126: 0.3791357910942755, 1127: 0.37914827371506094, 1128: 0.37916345032771764, 1129: 0.3791875704871437, 1130: 0.379208861190889, 1131: 0.379231393389659, 1132: 0.37926230608196576, 1133: 0.3792791174763035, 1134: 0.3792996516142289, 1135: 0.37932359870258575, 1136: 0.37934195969793266, 1137: 0.37936148593648544, 1138: 0.37937918294762946, 1139: 0.3793941589319427, 1140: 0.37941806698238545, 1141: 0.3794308940481892, 1142: 0.3794505546507308, 1143: 0.37947807321217153, 1144: 0.3794949799354384, 1145: 0.37952724266959453, 1146: 0.37954600762562707, 1147: 0.3795668914950898, 1148: 0.3795904817842611, 1149: 0.3796095868845203, 1150: 0.37963413488908804, 1151: 0.3796638158273671, 1152: 0.3796836937583501, 1153: 0.37971047525302176, 1154: 0.3797307206125139, 1155: 0.3797578569179701, 1156: 0.379777731627589, 1157: 0.3797998520828116, 1158: 0.3798073096630091, 1159: 0.37982400612908573, 1160: 0.3798485236310516, 1161: 0.3798678678009513, 1162: 0.3798923784222215, 1163: 0.37991765171353553, 1164: 0.3799488034583145, 1165: 0.379977271885562, 1166: 0.3800022610780233, 1167: 0.3800226132403038, 1168: 0.3800483221069669, 1169: 0.38007180297358395, 1170: 0.380092843360088, 1171: 0.380120024920952, 1172: 0.3801369945073676, 1173: 0.3801596664388882, 1174: 0.38016990444152743, 1175: 0.3801964205749477, 1176: 0.3802187205299102, 1177: 0.38024139041992433, 1178: 0.38026077091608484, 1179: 0.38027881924214246, 1180: 0.38029525032092426, 1181: 0.38031828272364787, 1182: 0.3803320606444233, 1183: 0.3803533683491484, 1184: 0.3803773711837246, 1185: 0.3804049958779411, 1186: 0.38041851045888686, 1187: 0.38043938645739594, 1188: 0.3804529924913369, 1189: 0.3804664324489285, 1190: 0.3804780620081865, 1191: 0.3805022472558785, 1192: 0.380529818571635, 1193: 0.3805553463200128, 1194: 0.3805692141380012, 1195: 0.38059858262288826, 1196: 0.38062057334045984, 1197: 0.3806424561465371, 1198: 0.38065812256253795, 1199: 0.38068185366811963, 1200: 0.38069973024567216, 1201: 0.38071623076238514, 1202: 0.3807378010136725, 1203: 0.38074235865931844, 1204: 0.3807559554066119, 1205: 0.3807820290100702, 1206: 0.38080460185363413, 1207: 0.38081994609194825, 1208: 0.38085033961851594, 1209: 0.38087498162968486, 1210: 0.38089768402220053, 1211: 0.3809091059847423, 1212: 0.38093384891643856, 1213: 0.38094129363229584, 1214: 0.3809551045996715, 1215: 0.3809693130023336, 1216: 0.38099056580007357, 1217: 0.38100150525328363, 1218: 0.3810217883748759, 1219: 0.38103729135754344, 1220: 0.3810561167979332, 1221: 0.3810814623107257, 1222: 0.38110432906485936, 1223: 0.38113397689264716, 1224: 0.3811548166534393, 1225: 0.3811756917836195, 1226: 0.38120041954772577, 1227: 0.38122614716895087, 1228: 0.38125398088951296, 1229: 0.3812713837298376, 1230: 0.3813022483569699, 1231: 0.3813242840008029, 1232: 0.38134393549852225, 1233: 0.3813572059928526, 1234: 0.38137997079596175, 1235: 0.3813992536799257, 1236: 0.3814237374201895, 1237: 0.38144426058192393, 1238: 0.3814661251664008, 1239: 0.3814817734845392, 1240: 0.3814977396183015, 1241: 0.3815190966651253, 1242: 0.381534116289101, 1243: 0.38155082307828375, 1244: 0.38157359056144435, 1245: 0.38159570629129747, 1246: 0.3816190156722994, 1247: 0.38163860289240836, 1248: 0.38165986317008394, 1249: 0.3816787730612374, 1250: 0.38169486172034756, 1251: 0.38170840799287403, 1252: 0.38172206850693674, 1253: 0.38173944210207794, 1254: 0.38176011275630317, 1255: 0.3817714618899752, 1256: 0.3817976968772678, 1257: 0.38180337958181954, 1258: 0.38182332471723524, 1259: 0.3818500640421548, 1260: 0.3818548533142614, 1261: 0.3815609586935961, 1262: 0.38129033459395945, 1263: 0.3810405661572977, 1264: 0.3808056761581849, 1265: 0.38059040792074517, 1266: 0.38039263000283535, 1267: 0.3802056481679097, 1268: 0.3800327269601932, 1269: 0.37986994166133947, 1270: 0.3797179386653895, 1271: 0.37957528572676447, 1272: 0.3794404212469806, 1273: 0.3793184098235664, 1274: 0.37920855282186555, 1275: 0.3791010054388037, 1276: 0.37899989911342585, 1277: 0.3789091522953944, 1278: 0.37882121262994084, 1279: 0.378733277701063, 1280: 0.3786625748491842, 1281: 0.37858726381110525, 1282: 0.37852355964197654, 1283: 0.37845975595836906, 1284: 0.3784028152413022, 1285: 0.3783443069924877, 1286: 0.37830038858944204, 1287: 0.37825356176468566, 1288: 0.37820608073271267, 1289: 0.37817313834888483, 1290: 0.37813509933215383, 1291: 0.3780980426500854, 1292: 0.37806802840148596, 1293: 0.3780341100338967, 1294: 0.37800419182825085, 1295: 0.3779836553749187, 1296: 0.37796281710274005, 1297: 0.37794398532895956, 1298: 0.3779192139231026, 1299: 0.3779000516322083, 1300: 0.37788517569507285, 1301: 0.37786757425823564, 1302: 0.3778551002187502, 1303: 0.3778403585437512, 1304: 0.3778293609408442, 1305: 0.37781387883830553, 1306: 0.3778110017046547, 1307: 0.3778102133867322, 1308: 0.37780415417906205, 1309: 0.3777929012301116, 1310: 0.377786149677523, 1311: 0.3777856425288797, 1312: 0.37778721259338943, 1313: 0.3777956532096479, 1314: 0.3778014893591381, 1315: 0.37780550388202144, 1316: 0.3778016846820213, 1317: 0.37781073499830575, 1318: 0.3778119616603678, 1319: 0.3778124706730076, 1320: 0.37782555535304263, 1321: 0.3778381690534962, 1322: 0.3778358879738683, 1323: 0.3778445495032016, 1324: 0.3778504973481069, 1325: 0.37785900621572954, 1326: 0.3778628796729909, 1327: 0.3778720720182063, 1328: 0.37789150729611864, 1329: 0.3779020093694475, 1330: 0.37790807902890505, 1331: 0.37791727359585253, 1332: 0.37793463506904484, 1333: 0.3779466058510934, 1334: 0.37796206852232594, 1335: 0.3779798673904091, 1336: 0.3780010167203212, 1337: 0.378015767087113, 1338: 0.3780337402137156, 1339: 0.37804043327560954, 1340: 0.3780499751535859, 1341: 0.3780633116897545, 1342: 0.3780750424346119, 1343: 0.37808669227936303, 1344: 0.37810098502603845, 1345: 0.3781175983010183, 1346: 0.3781290639298661, 1347: 0.37814721154481784, 1348: 0.37816185882963654, 1349: 0.37818159582388394, 1350: 0.37819878119328343, 1351: 0.3782098920003594, 1352: 0.3782208604022135, 1353: 0.37823546177469314, 1354: 0.3782434400636859, 1355: 0.3782610187052587, 1356: 0.3782716657632896, 1357: 0.37829064041201205, 1358: 0.37830839602398847, 1359: 0.3783232440386594, 1360: 0.378337757199418, 1361: 0.37835662726502717, 1362: 0.37836965697140473, 1363: 0.3783861649871499, 1364: 0.3784007140589912, 1365: 0.37841212360233195, 1366: 0.3784292496023214, 1367: 0.378447097745552, 1368: 0.3784628040444469, 1369: 0.3784826534369725, 1370: 0.3785012310812824, 1371: 0.37851866394614897, 1372: 0.378530611444654, 1373: 0.3785457034429867, 1374: 0.37856145491077864, 1375: 0.37858225991158717, 1376: 0.37859585844112315, 1377: 0.3786101171743008, 1378: 0.3786271349669111, 1379: 0.3786478317300172, 1380: 0.3786616515362754, 1381: 0.3786835876164467, 1382: 0.3787078324544046, 1383: 0.3787316728493199, 1384: 0.37875584773974735, 1385: 0.37877673023194813, 1386: 0.3788039697838119, 1387: 0.3788184046641456, 1388: 0.3788349651507579, 1389: 0.37885867185170286, 1390: 0.3788753018922439, 1391: 0.37890157673102437, 1392: 0.3789165620073168, 1393: 0.3789347643696879, 1394: 0.37895062017123693, 1395: 0.3789745686914059, 1396: 0.3790001901201196, 1397: 0.37902211890445087, 1398: 0.3790350657677224, 1399: 0.3790533483463769, 1400: 0.379072455950419, 1401: 0.3790864933904399, 1402: 0.3790999643369174, 1403: 0.37911280933396996, 1404: 0.37912945547588794, 1405: 0.37913978751289446, 1406: 0.37915106314619645, 1407: 0.3791715787895025, 1408: 0.37919442293451866, 1409: 0.37920563563557214, 1410: 0.3792231106879434, 1411: 0.3792433962021711, 1412: 0.37925889059829954, 1413: 0.37928466400595795, 1414: 0.37929920422535, 1415: 0.3793158292483992, 1416: 0.3793287639143053, 1417: 0.37935261289076044, 1418: 0.37937246638032673, 1419: 0.37939247177508, 1420: 0.3794088524022778, 1421: 0.37942676731509994, 1422: 0.3794431605326917, 1423: 0.37945606136200055, 1424: 0.37947366612123523, 1425: 0.3794898722951518, 1426: 0.3795031309116636, 1427: 0.3795188760911514, 1428: 0.37953412232321443, 1429: 0.3795555417897277, 1430: 0.37957306230380455, 1431: 0.37958597829554264, 1432: 0.37960054048711006, 1433: 0.3796156762776405, 1434: 0.37962538955764413, 1435: 0.3796372245744528, 1436: 0.37965485178962216, 1437: 0.37967162517622055, 1438: 0.3796888487001782, 1439: 0.37970569333774584, 1440: 0.3797124071219723, 1441: 0.379729979804569, 1442: 0.37973932351987916, 1443: 0.37975077769531096, 1444: 0.3797692302478074, 1445: 0.379785477804282, 1446: 0.3798027034871555, 1447: 0.3798264932614925, 1448: 0.3798392581830571, 1449: 0.37985494242779794, 1450: 0.3798733051456585, 1451: 0.37988730176579105, 1452: 0.3799022169507696, 1453: 0.3799157056966517, 1454: 0.37992706850695906, 1455: 0.3799454352872205, 1456: 0.3799551252032317, 1457: 0.37997017609562717, 1458: 0.3799913941756514, 1459: 0.3800042993728574, 1460: 0.3800292541406688, 1461: 0.38004363031686594, 1462: 0.3800596750502391, 1463: 0.38007785032164787, 1464: 0.38009251252040954, 1465: 0.3801114538104472, 1466: 0.3801344331873956, 1467: 0.3801497228833453, 1468: 0.38017044160259794, 1469: 0.38018603349576285, 1470: 0.3802070465969772, 1471: 0.3802223608656356, 1472: 0.38023944669257337, 1473: 0.38024501096354696, 1474: 0.38025784305092625, 1475: 0.3802768318031654, 1476: 0.38029175837682205, 1477: 0.38031075596794583, 1478: 0.38033036122364566, 1479: 0.38035460109319175, 1480: 0.38037673789750737, 1481: 0.38039614376257785, 1482: 0.3804119053691454, 1483: 0.3804318925265625, 1484: 0.38045013215144036, 1485: 0.3804664558446708, 1486: 0.3804876257926194, 1487: 0.3805007542741966, 1488: 0.38051838360643114, 1489: 0.38052621516103025, 1490: 0.3805468881152214, 1491: 0.3805642449637172, 1492: 0.3805818984572646, 1493: 0.38059696302531376, 1494: 0.38061098198016624, 1495: 0.3806237297105217, 1496: 0.38064169427842875, 1497: 0.3806523576943653, 1498: 0.38066897234200886, 1499: 0.3806877222721286, 1500: 0.38070934080343116, 1501: 0.3807198171704259, 1502: 0.3807361158093891, 1503: 0.38074667360057024, 1504: 0.3807571041466938, 1505: 0.380766107064621, 1506: 0.3807850440797825, 1507: 0.3808066666704316, 1508: 0.38082668029274397, 1509: 0.3808374742579865, 1510: 0.3808605407642816, 1511: 0.3808777752581995, 1512: 0.38089493061774493, 1513: 0.380907169518737, 1514: 0.3809258004470247, 1515: 0.38093980034601777, 1516: 0.38095271510849216, 1517: 0.38096965208878564, 1518: 0.3809731113209902, 1519: 0.3809837374587514, 1520: 0.3810042598441077, 1521: 0.3810220134742207, 1522: 0.38103404024753085, 1523: 0.38105800943538876, 1524: 0.3810774238244317, 1525: 0.3810953059289951, 1526: 0.38110424141876825, 1527: 0.3811237544384321, 1528: 0.3811295405504786, 1529: 0.381140384126648, 1530: 0.38115154723780204, 1531: 0.3811683100225494, 1532: 0.38117688493072, 1533: 0.38119288754805736, 1534: 0.3812050967476428, 1535: 0.38121995121339464, 1536: 0.3812399944284057, 1537: 0.38125807357172875, 1538: 0.3812815518336791, 1539: 0.38129803204176593, 1540: 0.3813145460620195, 1541: 0.3813341312314946, 1542: 0.3813545187879256, 1543: 0.38137658962824483, 1544: 0.38139036412146193, 1545: 0.3814148617783251, 1546: 0.3814323367675387, 1547: 0.38144791874676465, 1548: 0.38145842282844766, 1549: 0.38147649499373193, 1550: 0.38149179858213317, 1551: 0.38151125241381034, 1552: 0.3815275556269606, 1553: 0.3815449337565044, 1554: 0.38155736084485875, 1555: 0.3815700455516664, 1556: 0.38158703458622834, 1557: 0.38159897332694215, 1558: 0.38161226224980155, 1559: 0.3816303922881915, 1560: 0.3816480080701235, 1561: 0.38166658252964303, 1562: 0.38168219115689733, 1563: 0.38169914093188273, 1564: 0.38171421899007435, 1565: 0.381727048289529, 1566: 0.38173785051538495, 1567: 0.381748747539203, 1568: 0.38176261562356484, 1569: 0.3817791236483516, 1570: 0.38178818475373133, 1571: 0.3818091514076218, 1572: 0.3818136886842859, 1573: 0.3818296352071038, 1574: 0.38185102201092097}}}\n" + ] + } + ], + "source": [ + "table_size_zch_method_avetage_collision_dict = {}\n", + "table_size_zch_method_total_cnt_dict = {}\n", + "for zch_stats_folder in zch_stats_folders:\n", + " zch_method_name = re_zch_method_name_pattern.search(zch_stats_folder).group(1)\n", + " table_size = int(re_table_size_pattern.search(zch_stats_folder).group(1))\n", + " print(zch_method_name, table_size)\n", + " zch_stats_file_folder = os.path.join(\"/home/lizhouyu/home/lizhouyu/zch_results\", zch_stats_folder)\n", + " average_collision_dict, total_cnt_dict = get_average_zch(zch_stats_file_folder)\n", + " if table_size not in table_size_zch_method_avetage_collision_dict:\n", + " table_size_zch_method_avetage_collision_dict[table_size] = {}\n", + " table_size_zch_method_avetage_collision_dict[table_size][zch_method_name] = average_collision_dict\n", + " if table_size not in table_size_zch_method_total_cnt_dict:\n", + " table_size_zch_method_total_cnt_dict[table_size] = {}\n", + " table_size_zch_method_total_cnt_dict[table_size][zch_method_name] = total_cnt_dict\n", + "print(table_size_zch_method_avetage_collision_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot collision rate" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "output": { + "id": 2116764528810244, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the average ratio of accumulated_collision_count / accumulated_total_count for all the features\n", + "# the x-axis is the batch_idx, the y-axis is the ratio\n", + "for table_size in table_size_zch_method_avetage_collision_dict:\n", + " fig = plt.figure(figsize=(8, 6))\n", + " font_size = 24\n", + " for zch_method_name in table_size_zch_method_avetage_collision_dict[table_size]:\n", + " x_list = list(table_size_zch_method_avetage_collision_dict[table_size][zch_method_name].keys())\n", + " y_list = list(table_size_zch_method_avetage_collision_dict[table_size][zch_method_name].values())\n", + " line_style = \"--\" if \"nonzch\" in zch_method_name else \"-\"\n", + " plt.plot(x_list, y_list, label=f\"{zch_method_name}\", linewidth=3, linestyle=line_style)\n", + " plt.xlabel(\"batch_idx\", fontsize=font_size)\n", + " plt.ylabel(\"average collision rate\", fontsize=font_size)\n", + " # plt.title(\"average collision rate vs batch_idx\", fontsize=font_size)\n", + " plt.xticks(fontsize=font_size)\n", + " plt.yticks(fontsize=font_size)\n", + " plt.legend(fontsize=font_size*0.7, title=f\"table size: {table_size}\", title_fontsize=font_size*0.7)\n", + " # save\n", + " fig_path = os.path.join(figure_folder, f\"average_collision_rate_vs_batch_idx_tbsize_{table_size}.png\")\n", + " plt.tight_layout()\n", + " fig.savefig(fig_path)\n", + " plt.show()\n", + " plt.close()\n", + "# plot the ratio of accumulated_collision_count / accumulated_total_count" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "output": { + "id": 1448651826264256, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MPZCH EC\n", + "Original EC\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the average ratio of accumulated_collision_count / accumulated_total_count for all the features\n", + "# the x-axis is the batch_idx, the y-axis is the ratio\n", + "for table_size in table_size_zch_method_avetage_collision_dict:\n", + " fig = plt.figure(figsize=(8, 6))\n", + " font_size = 24\n", + " for zch_method_name in table_size_zch_method_avetage_collision_dict[table_size]:\n", + " x_list = list(table_size_zch_method_avetage_collision_dict[table_size][zch_method_name].keys())\n", + " y_list = list(table_size_zch_method_avetage_collision_dict[table_size][zch_method_name].values())\n", + " line_style = \"--\" if \"nonzch\" in zch_method_name else \"-\"\n", + " label_name = \"Original EC\" if \"nonzch\" in zch_method_name else \"MPZCH EC\"\n", + " plt.plot(x_list, y_list, label=f\"{label_name}\", linewidth=3, linestyle=line_style)\n", + " print(label_name)\n", + " plt.xlabel(\"batch index\", fontsize=font_size)\n", + " plt.ylabel(\"User ID table collision rate\", fontsize=font_size)\n", + " # plt.title(\"average collision rate vs batch_idx\", fontsize=font_size)\n", + " plt.xticks(fontsize=font_size)\n", + " plt.yticks(fontsize=font_size)\n", + " plt.legend(fontsize=font_size*0.7, title=f\"table size: {table_size}\", title_fontsize=font_size*0.7)\n", + " # save\n", + " fig_path = os.path.join(figure_folder, f\"video_id_table_collision_rate_vs_batch_idx_tbsize_{table_size}.png\")\n", + " plt.tight_layout()\n", + " fig.savefig(fig_path)\n", + " plt.show()\n", + " plt.close()\n", + "# plot the ratio of accumulated_collision_count / accumulated_total_count" + ] + } + ], + "metadata": { + "fileHeader": "", + "fileUid": "75fbdc90-117d-4c24-b0b4-2cd83e5801ca", + "isAdHoc": false, + "kernelspec": { + "display_name": "torchrec", + "language": "python", + "name": "bento_kernel_torchrec" + }, + "language_info": { + "name": "plaintext" + }, + "orig_nbformat": 4 + } +} diff --git a/torchrec/modules/hash_mc_modules.py b/torchrec/modules/hash_mc_modules.py index a7be80cab..f77ad317b 100644 --- a/torchrec/modules/hash_mc_modules.py +++ b/torchrec/modules/hash_mc_modules.py @@ -322,6 +322,17 @@ def __init__( self._eviction_policy_name ) + # create two dictionaries to store the input values and remapped ids on the current rank + # these values are used for calculating zch metrics like hit rate and collision rate + ## on-device remapped ids + self.table_name_on_device_remapped_ids_dict: Dict[str, torch.Tensor] = ( + {} + ) # {table_name: on_device_remapped_ids} + ## on-device input ids + self.table_name_on_device_input_ids_dict: Dict[str, torch.Tensor] = ( + {} + ) # {table_name: input JT values that maps to the current rank} + logger.info( f"HashZchManagedCollisionModule: {self._name=}, {self.device=}, " f"{self._zch_size=}, {self._input_hash_size=}, {self._max_probe=}, " @@ -465,8 +476,8 @@ def remap(self, features: Dict[str, JaggedTensor]) -> Dict[str, JaggedTensor]: remapped_features: Dict[str, JaggedTensor] = {} identities_0 = ( self._hash_zch_identities.data.clone() - if self._tb_logging_frequency > 0 - else None + # if self._tb_logging_frequency > 0 + # else None ) for name, feature in features.items(): @@ -488,6 +499,10 @@ def remap(self, features: Dict[str, JaggedTensor]) -> Dict[str, JaggedTensor]: values=values, output_offset=self._output_global_offset_tensor, ) + + # record the input values + self.table_name_on_device_input_ids_dict[name] = values.clone() + num_reserved_slots = self.get_reserved_slots_per_bucket() remapped_ids, evictions = torch.ops.fbgemm.zero_collision_hash( input=values, @@ -512,6 +527,9 @@ def remap(self, features: Dict[str, JaggedTensor]) -> Dict[str, JaggedTensor]: opt_in_rands=opt_in_rands, ) + # record the on-device remapped ids + self.table_name_on_device_remapped_ids_dict[name] = remapped_ids.clone() + if self._scalar_logger is not None: assert identities_0 is not None self._scalar_logger.update( diff --git a/torchrec/modules/mc_adapter.py b/torchrec/modules/mc_adapter.py new file mode 100644 index 000000000..7feba8f81 --- /dev/null +++ b/torchrec/modules/mc_adapter.py @@ -0,0 +1,251 @@ +# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary. + +# pyre-strict +import sys +from typing import Dict, Iterator, List, Optional, Union + +import torch +import torch.nn as nn +from torch.nn.parameter import Parameter +from torchrec.modules.embedding_configs import EmbeddingBagConfig, EmbeddingConfig +from torchrec.modules.embedding_modules import ( + EmbeddingBagCollection, + EmbeddingCollection, +) +from torchrec.modules.hash_mc_evictions import ( + HashZchEvictionConfig, + HashZchEvictionPolicyName, +) +from torchrec.modules.hash_mc_modules import HashZchManagedCollisionModule +from torchrec.modules.mc_embedding_modules import ( + ManagedCollisionEmbeddingBagCollection, + ManagedCollisionEmbeddingCollection, +) +from torchrec.modules.mc_modules import ( + DistanceLFU_EvictionPolicy, + ManagedCollisionCollection, + ManagedCollisionModule, + MCHManagedCollisionModule, +) +from torchrec.sparse.jagged_tensor import JaggedTensor, KeyedJaggedTensor + + +class McEmbeddingCollectionAdapter(nn.Module): + """ + Managed Collision Embedding Collection Adapter + The adapter to convert exiting EmbeddingCollection to Managed Collision Embedding Collection module + The adapter will use the original EmbeddingCollection table but will pass input + """ + + def __init__( + self, + tables: List[EmbeddingConfig], + input_hash_size: int, + device: torch.device, + world_size: int, + eviction_interval: int = 1, + allow_in_place_embed_weight_update: bool = False, + zch_method: str = "", # method for managing collisions, one of ["", "mpzch", "sort_zch"] + mpzch_num_buckets: Optional[int] = 80, + mpzch_max_probe: Optional[ + int + ] = 100, # max_probe for HashZchManagedCollisionModule + ) -> None: + """ + INIT_DOC_STRING + """ + super().__init__() + # create ec from table configs + ec = EmbeddingCollection(tables=tables, device=torch.device("meta")) + # build dictionary for {table_name: table_config} + mc_modules = {} + for table_config in ec.embedding_configs(): + table_name = table_config.name + if zch_method == "mpzch": + # if use MPZCH, create a HashZchManagedCollisionModule + mc_modules[table_name] = HashZchManagedCollisionModule( # MPZCH + is_inference=False, + zch_size=(table_config.num_embeddings), + input_hash_size=input_hash_size, + device=device, + total_num_buckets=( + mpzch_num_buckets if mpzch_num_buckets else world_size + ), # total_num_buckets if not passed, use world_size, WORLD_SIZE should be a factor of total_num_buckets + eviction_policy_name=HashZchEvictionPolicyName.SINGLE_TTL_EVICTION, # defaultly using single ttl eviction policy + eviction_config=HashZchEvictionConfig( + features=table_config.feature_names, + single_ttl=eviction_interval, + ), + ) + elif ( + zch_method == "sort_zch" + ): # if not use MPZCH, create a MCHManagedCollisionModule using the sort ZCH algorithm + mc_modules[table_name] = MCHManagedCollisionModule( # sort ZCH + zch_size=table_config.num_embeddings, + device=device, + input_hash_size=input_hash_size, + eviction_interval=eviction_interval, + eviction_policy=DistanceLFU_EvictionPolicy(), + ) # NOTE: the benchmark for sort ZCH is not implemented yet + else: # if not use MPZCH, create a MCHManagedCollisionModule using the sort ZCH + raise NotImplementedError( + f"zc method {zch_method} is not supported yet" + ) + # create the mcebc module with the mc modules and the original ebc + self.mc_embedding_collection = ( + ManagedCollisionEmbeddingCollection( # ZCH or not + embedding_collection=ec, + managed_collision_collection=ManagedCollisionCollection( + managed_collision_modules=mc_modules, + embedding_configs=ec.embedding_configs(), + ), + allow_in_place_embed_weight_update=allow_in_place_embed_weight_update, + return_remapped_features=False, # not return remapped features + ) + ) + self.remapped_ids: Optional[Dict[str, torch.Tensor]] = ( + None # to store remapped ids + ) + + def forward(self, input: KeyedJaggedTensor) -> Dict[str, JaggedTensor]: + """ + Args: + input (KeyedJaggedTensor): KJT of form [F X B X L]. + Returns: + Dict[str, JaggedTensor]: dictionary of {'feature_name': JaggedTensor} + """ + mc_ec_out, remapped_ids = self.mc_embedding_collection(input) + self.remapped_ids = remapped_ids + return mc_ec_out + + def parameters(self, recurse: bool = True) -> Iterator[Parameter]: + # only return the parameters of the original EmbeddingBagCollection, not _managed_collision_collection modules + return self.mc_embedding_collection._embedding_module.parameters( + recurse=recurse + ) + + def embedding_bag_configs(self) -> List[EmbeddingConfig]: + """ + Returns: + Dict[str, EmbeddingConfig]: dictionary of {'feature_name': EmbeddingConfig} + """ + # pyre-ignore [29] # NOTE: the function "embedding_configs" returns the _embedding_module attribute of the EmbeddingCollection + return self.mc_embedding_collection._embedding_module.embedding_configs() + + +class McEmbeddingBagCollectionAdapter(nn.Module): + """ + Managed Collision Embedding Collection Adapter + The adapter to convert exiting EmbeddingCollection to Managed Collision Embedding Collection module + The adapter will use the original EmbeddingCollection table but will pass input + """ + + def __init__( + self, + tables: List[EmbeddingBagConfig], + input_hash_size: int, + device: torch.device, + world_size: int, + eviction_interval: int = 1, + allow_in_place_embed_weight_update: bool = False, + use_mpzch: bool = False, + mpzch_num_buckets: Optional[int] = None, + mpzch_max_probe: Optional[int] = None, + ) -> None: + """ + Initialize an EmbeddingBagCollectionAdapter. + Parameters: + tables (List[EmbeddingBagConfig]): List of EmbeddingBagConfig. Should be the same as the original EmbeddingBagCollection. + input_hash_size (int): the upper bound of input feature values + device (torch.device): the device to use + world_size (int): the world size + eviction_interval (int): the eviction interval, default to 1 hour + allow_in_place_embed_weight_update (bool): whether to allow in-place embedding weight update + use_mpzch (bool): whether to use MPZCH or not # TODO: change this to a str to support different zch + mpzch_num_buckets (Optional[int]): the number of buckets for MPZCH # TODO: change this to a config dict to support different zch configs + mpzch_max_probe (Optional[int]): the maximum probe range starting from the input feature value's hash index + """ + # super().__init__(tables=tables, device=device) + super().__init__() + # create ebc from table configs + ebc = EmbeddingBagCollection(tables=tables, device=torch.device("meta")) + # build dictionary for {table_name: table_config} + mc_modules = {} + for table_config in ebc.embedding_bag_configs(): + table_name = table_config.name + if use_mpzch: + # if use MPZCH, create a HashZchManagedCollisionModule + mc_modules[table_name] = HashZchManagedCollisionModule( # MPZCH + is_inference=False, + zch_size=(table_config.num_embeddings), + input_hash_size=input_hash_size, + device=device, + total_num_buckets=( + mpzch_num_buckets if mpzch_num_buckets else world_size + ), # total_num_buckets if not passed, use world_size, WORLD_SIZE should be a factor of total_num_buckets + eviction_policy_name=HashZchEvictionPolicyName.SINGLE_TTL_EVICTION, # defaultly using single ttl eviction policy + eviction_config=HashZchEvictionConfig( + features=table_config.feature_names, + single_ttl=eviction_interval, + ), + max_probe=( + mpzch_max_probe + if mpzch_max_probe is not None + and mpzch_max_probe + < (table_config.num_embeddings // world_size) + else table_config.num_embeddings // world_size + ), # max_probe for HashZchManagedCollisionModule + ) + else: # if not use MPZCH, create a MCHManagedCollisionModule using the sort ZCH algorithm + mc_modules[table_name] = MCHManagedCollisionModule( # sort ZCH + zch_size=table_config.num_embeddings, + device=device, + input_hash_size=input_hash_size, + eviction_interval=eviction_interval, + eviction_policy=DistanceLFU_EvictionPolicy(), + ) # NOTE: the benchmark for sort ZCH is not implemented yet + # TODO: add the pure hash module here + + # create the mcebc module with the mc modules and the original ebc + self.mc_embedding_bag_collection = ( + ManagedCollisionEmbeddingBagCollection( # ZCH or not + embedding_bag_collection=ebc, + managed_collision_collection=ManagedCollisionCollection( + managed_collision_modules=mc_modules, + embedding_configs=ebc.embedding_bag_configs(), + ), + allow_in_place_embed_weight_update=allow_in_place_embed_weight_update, + return_remapped_features=False, # not return remapped features + ) + ) + + self.remapped_ids: Optional[Dict[str, torch.Tensor]] = ( + None # to store remapped ids + ) + + def forward(self, input_kjt: KeyedJaggedTensor) -> Dict[str, JaggedTensor]: + """ + Args: + input (KeyedJaggedTensor): KJT of form [F X B X L]. + Returns: + Dict[str, JaggedTensor]: dictionary of {'feature_name': JaggedTensor} + """ + mc_ebc_out, remapped_ids = self.mc_embedding_bag_collection(input_kjt) + self.remapped_ids = remapped_ids + return mc_ebc_out + + def parameters(self, recurse: bool = True) -> Iterator[Parameter]: + # only return the parameters of the original EmbeddingBagCollection, not _managed_collision_collection modules + return self.mc_embedding_bag_collection._embedding_module.parameters( + recurse=recurse + ) + + def embedding_bag_configs(self) -> List[EmbeddingBagConfig]: + """ + Returns: + Dict[str, EmbeddingConfig]: dictionary of {'feature_name': EmbeddingConfig} + """ + return ( + # pyre-ignore [29] # NOTE: the function "embedding_configs" returns the _embedding_module attribute of the EmbeddingCollection + self.mc_embedding_bag_collection._embedding_module.embedding_bag_configs() + ) From 3ba83dc03673cbad7cb102936cd64bc23c592d11 Mon Sep 17 00:00:00 2001 From: Zhouyu Li Date: Mon, 14 Jul 2025 13:03:33 -0700 Subject: [PATCH 2/2] Add tensorboard to display training and evaluation metrics and revise implementation to support DLRMv2 (#3163) Summary: Pull Request resolved: https://github.com/pytorch/torchrec/pull/3163 ### Major changes - Add tensorboard to the benchmark testbed, specifically in `benchmark_zch.py`. - Count the number of unique values received by each rank in each epoch by revising `benchmark_zch_utils.py`. - Revise `data/non_zch_remapper.py` to not depend on `batch.to_dict()` method, instead it fetch dataclass `batch`'s attribute with the built-in `vars()` method. - Revise DLRMv2 model EBC config initialization to make the table name identical with the feature name. - Revise DLRMv2 configuration yaml file to set table size for each feature. - Revise the default value for "num_embeddings" parameter in `arguments.py` to None. Differential Revision: D77841795 --- .../benchmark/benchmark_zch/arguments.py | 10 +- .../benchmark/benchmark_zch/benchmark_zch.py | 317 +++++++++++++++--- .../benchmark_zch/benchmark_zch_utils.py | 34 +- .../count_dataset_distributions.py | 8 + .../data/configs/criteo_kaggle.yaml | 6 +- .../data/configs/kuairand_1k.yaml | 2 +- .../benchmark_zch/data/get_dataloader.py | 8 + .../benchmark_zch/data/get_metric_modules.py | 8 + .../benchmark_zch/data/nonzch_remapper.py | 28 +- .../data/preprocess/kuairand_1k.py | 8 + .../data/preprocess/kuairand_27k.py | 8 + .../data/preprocess/movielens_1m.py | 8 + .../benchmark_zch/models/apply_optimizers.py | 9 + .../benchmark_zch/models/configs/dlrmv2.yaml | 52 +-- .../benchmark_zch/models/make_model.py | 9 + .../benchmark_zch/models/models/dlrmv2.py | 19 +- .../benchmark_zch/models/models/dlrmv3.py | 9 + .../benchmark_zch/models/shard_model.py | 9 + torchrec/modules/mc_adapter.py | 56 ++-- 19 files changed, 486 insertions(+), 122 deletions(-) diff --git a/torchrec/distributed/benchmark/benchmark_zch/arguments.py b/torchrec/distributed/benchmark/benchmark_zch/arguments.py index 6fe33694d..35df8586d 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/arguments.py +++ b/torchrec/distributed/benchmark/benchmark_zch/arguments.py @@ -1,3 +1,11 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +# pyre-strict import argparse from typing import List @@ -25,7 +33,7 @@ def parse_args(argv: List[str]) -> argparse.Namespace: parser.add_argument( "--num_embeddings", # ratio of feature ids to embedding table size # 3 axis: x-bath_idx; y-collisions; zembedding table sizes type=int, - default=100_000, + default=None, help="max_ind_size. The number of embeddings in each embedding table. Defaults" " to 100_000 if num_embeddings_per_feature is not supplied.", ) diff --git a/torchrec/distributed/benchmark/benchmark_zch/benchmark_zch.py b/torchrec/distributed/benchmark/benchmark_zch/benchmark_zch.py index 2f2efe889..fa65be49a 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/benchmark_zch.py +++ b/torchrec/distributed/benchmark/benchmark_zch/benchmark_zch.py @@ -1,3 +1,11 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +# pyre-strict import argparse import csv import json @@ -14,8 +22,11 @@ import torch import torch.nn as nn +from line_profiler import LineProfiler + from torch import distributed as dist from torch.utils.data import DataLoader +from torch.utils.tensorboard import SummaryWriter # @manual //caffe2:torch_tensorboard from torchrec.metrics.metrics_namespace import MetricPrefix from torchrec.metrics.rec_metric import RecMetricComputation @@ -50,10 +61,6 @@ def main(rank: int, args: argparse.Namespace, queue: multiprocessing.Queue) -> N torch.manual_seed(args.seed) np.random.seed(args.seed) - # import fbvscode - - # fbvscode.set_trace() - # setup environment logger.info(f"[rank {rank}] setup environment") os.environ["RANK"] = str(rank) @@ -73,6 +80,9 @@ def main(rank: int, args: argparse.Namespace, queue: multiprocessing.Queue) -> N # get training dataset logger.info(f"[rank {rank}] get train dataloader") train_dataloader = get_dataloader(args.dataset_name, args, "train") + # get test dataset + logger.info(f"[rank {rank}] get test dataloader") + test_dataloader = get_dataloader(args.dataset_name, args, "val") # get metric modules logger.info(f"[rank {rank}] get metric modules") @@ -137,6 +147,7 @@ def main(rank: int, args: argparse.Namespace, queue: multiprocessing.Queue) -> N # train the model logger.info(f"[rank {rank}] train the model") + batch_cnt = 0 for epoch_idx in range(args.epochs): model.train() starter_list = [] @@ -167,26 +178,30 @@ def main(rank: int, args: argparse.Namespace, queue: multiprocessing.Queue) -> N ## update weights optimizer.step() ender.record() - # do statistics - num_queries_per_batch = len(labels) + # update the batch counter + batch_cnt += 1 + # append the start and end events to the lists starter_list.append(starter) ender_list.append(ender) + # do training metrics and QPS statistics + num_queries_per_batch = len(labels) num_queries_per_batch_list.append(num_queries_per_batch) loss_per_batch_list.append(loss.cpu().item()) - if True or len(args.zch_method) > 0: - benchmark_probe.record_mcec_state(stage="after_fwd") - # update zch statistics - benchmark_probe.update() - # push the zch stats to the queue - msg_content = { - "epoch_idx": epoch_idx, - "batch_idx": batch_idx, - "rank": rank, - "mch_stats": benchmark_probe.get_mch_stats(), - } - queue.put( - ("mch_stats", msg_content), - ) + # do zch statistics + benchmark_probe.record_mcec_state(stage="after_fwd") + # update zch statistics + benchmark_probe.update() + # push the zch stats to the queue + msg_content = { + "epoch_idx": epoch_idx, + "batch_idx": batch_idx, + "batch_cnt": batch_cnt, + "rank": rank, + "mch_stats": benchmark_probe.get_mch_stats(), + } + queue.put( + ("mch_stats", msg_content), + ) if ( batch_idx % interval_num_batches_show_qps == 0 or batch_idx == len(train_dataloader) - 1 @@ -218,6 +233,11 @@ def main(rank: int, args: argparse.Namespace, queue: multiprocessing.Queue) -> N if batch_idx >= interval_num_batches_show_qps else 0 ) # the start batch index of the interval + interval_start_batch_cnt = ( + batch_cnt - interval_num_batches_show_qps + if batch_cnt >= interval_num_batches_show_qps + else 0 + ) # the start batch counter of the interval interval_end_batch_idx = ( batch_idx # the end batch index of the interval ) @@ -227,6 +247,8 @@ def main(rank: int, args: argparse.Namespace, queue: multiprocessing.Queue) -> N "rank": rank, "interval_start_batch_idx": interval_start_batch_idx, "interval_end_batch_idx": interval_end_batch_idx, + "interval_start_batch_cnt": interval_start_batch_cnt, + "interval_end_batch_cnt": batch_cnt, "per_batch_time_list": per_batch_time_list, "per_batch_num_queries_list": num_queries_per_batch_list, } @@ -238,6 +260,8 @@ def main(rank: int, args: argparse.Namespace, queue: multiprocessing.Queue) -> N "rank": rank, "interval_start_batch_idx": interval_start_batch_idx, "interval_end_batch_idx": interval_end_batch_idx, + "interval_start_batch_cnt": interval_start_batch_cnt, + "interval_end_batch_cnt": batch_cnt, "per_batch_loss_list": loss_per_batch_list, } ## put the message into the queue @@ -259,31 +283,24 @@ def main(rank: int, args: argparse.Namespace, queue: multiprocessing.Queue) -> N ender_list = [] num_queries_per_batch_list = [] loss_per_batch_list = [] - # release the training dataloader - logger.info(f"[rank {rank}] release the training dataloader") - train_dataloader = None - del train_dataloader - # after training do validation - logger.info(f"[rank {rank}] get test dataloader") - test_dataloader = get_dataloader(args.dataset_name, args, "val") - logger.info(f"[rank {rank}] do validation") - metric_values = evaluation( - metric_modules, - model, - test_dataloader, - device, - nonzch_remapper if len(args.zch_method) == 0 else None, - ) - - # print the evaluation result - print(f"Evaluation result: {metric_values}") - # send the evaluation result to the queue - msg_content = { - "epoch_idx": args.epochs, - "rank": rank, - "eval_result_dict": metric_values, - } - queue.put(("eval_result", msg_content)) + # after training of each epoch, do validation + logger.info(f"[rank {rank}] do validation after training of epoch {epoch_idx}") + metric_values = evaluation( + metric_modules, + model, + test_dataloader, + device, + nonzch_remapper if len(args.zch_method) == 0 else None, + ) + # print the evaluation result + print(f"Evaluation result: {metric_values}") + # send the evaluation result to the queue + msg_content = { + "epoch_idx": epoch_idx, + "rank": rank, + "eval_result_dict": metric_values, + } + queue.put(("eval_result", msg_content)) logger.info( f"[rank {rank}] finished, sleep for 15 seconds before sending finish signal and exit" @@ -317,6 +334,12 @@ def evaluation( batch = nonzch_remapper.remap(batch) with torch.no_grad(): loss, (loss_values, pred_logits, labels, weights) = model(batch) + if len(pred_logits.shape) <= 1: + pred_logits = pred_logits.unsqueeze(0) + if len(labels.shape) <= 1: + labels = labels.unsqueeze(0) + if len(weights.shape) <= 1: + weights = weights.unsqueeze(0) # update metrics for metric_name, metric_module in metric_modules.items(): metric_module.update( @@ -364,6 +387,7 @@ def statistic(args: argparse.Namespace, queue: multiprocessing.Queue) -> None: [ "epoch_idx", "batch_idx", + "batch_cnt", "rank", "loss", ] @@ -378,6 +402,7 @@ def statistic(args: argparse.Namespace, queue: multiprocessing.Queue) -> None: [ "epoch_idx", "batch_idx", + "batch_cnt", "feature_name", "hit_cnt", "total_cnt", @@ -390,6 +415,9 @@ def statistic(args: argparse.Namespace, queue: multiprocessing.Queue) -> None: "rank_num_empty_slots", ] ) + ## create counter for total number of collision and total number of queries + total_num_collisions = {} # feature name: total number of collisions + total_num_queries = {} # feature name: total number of queries # create a csv file to save the qps_metrics qps_metrics_file_path = os.path.join( args.profiling_result_folder, "qps_metrics.csv" @@ -400,6 +428,7 @@ def statistic(args: argparse.Namespace, queue: multiprocessing.Queue) -> None: [ "epoch_idx", "batch_idx", + "batch_cnt", "rank", "num_queries", "duration", @@ -414,6 +443,10 @@ def statistic(args: argparse.Namespace, queue: multiprocessing.Queue) -> None: writer = csv.writer(f) writer.writerow(["epoch_idx", "rank", "auc", "ne", "mae", "mse"]) + # create a tensorboard folder and summary writer + tb_log_folder = os.path.join(args.profiling_result_folder, "tb") + tb_writer = SummaryWriter(log_dir=tb_log_folder) + while finished_counter < world_size: try: # get the data from the queue @@ -444,6 +477,7 @@ def statistic(args: argparse.Namespace, queue: multiprocessing.Queue) -> None: elif msg_type == "mch_stats": epoch_idx = msg_content["epoch_idx"] batch_idx = msg_content["batch_idx"] + batch_cnt = msg_content["batch_cnt"] rank = msg_content["rank"] rank_batch_mch_stats = msg_content["mch_stats"] # other wise, aggregate the data into the buffer @@ -476,6 +510,7 @@ def statistic(args: argparse.Namespace, queue: multiprocessing.Queue) -> None: "collision_cnt": 0, "rank_total_cnt": {}, # dictionary of {rank_idx: num_quries_mapped_to_the_rank} "rank_num_empty_slots": {}, # dictionary of {rank_idx: num_empty_slots} + "rank_num_unique_queries": {}, # dictionary of {rank_idx: num_unique_queries} } # aggregate the data from all the ranks ## aggregate the hit count @@ -508,21 +543,44 @@ def statistic(args: argparse.Namespace, queue: multiprocessing.Queue) -> None: ] = rank_batch_mch_stats[mch_stats_feature_name][ "num_empty_slots" ] + ## for rank num unique queries, get the data from the rank data dict + batch_stats[mch_stats_feature_name]["rank_num_unique_queries"][ + mch_stats_rank_idx + ] = rank_batch_mch_stats[mch_stats_feature_name][ + "num_unique_queries" + ] # clear the buffer for the batch del mch_buffer[epoch_idx][batch_idx] - # save the zch statistics to a file + # save the zch statistics to a file and tensorboard + tb_prefix = "collision management" with open(zch_metrics_file_path, "a") as f: writer = csv.writer(f) for feature_name, stats in batch_stats.items(): + # calculate rate for each rank hit_rate = stats["hit_cnt"] / stats["total_cnt"] insert_rate = stats["insert_cnt"] / stats["total_cnt"] collision_rate = stats["collision_cnt"] / stats["total_cnt"] rank_total_cnt = json.dumps(stats["rank_total_cnt"]) rank_num_empty_slots = json.dumps(stats["rank_num_empty_slots"]) + # update the total number of collisions and total number of queries + if feature_name not in total_num_collisions: + total_num_collisions[feature_name] = 0 + if feature_name not in total_num_queries: + total_num_queries[feature_name] = 0 + total_num_collisions[feature_name] += stats["collision_cnt"] + total_num_queries[feature_name] += stats["total_cnt"] + overall_collision_rate = ( + total_num_collisions[feature_name] + / total_num_queries[feature_name] + if total_num_queries[feature_name] > 0 + else 0 + ) + # write the zch statitics to csv file writer.writerow( [ epoch_idx, batch_idx, + batch_cnt, feature_name, stats["hit_cnt"], stats["total_cnt"], @@ -535,53 +593,178 @@ def statistic(args: argparse.Namespace, queue: multiprocessing.Queue) -> None: rank_num_empty_slots, ] ) + # write the zch statitics to tensorboard + tb_writer.add_scalar( + f"{tb_prefix}/{feature_name}/hit_cnt", + stats["hit_cnt"], + batch_cnt, + ) + tb_writer.add_scalar( + f"{tb_prefix}/{feature_name}/total_cnt", + stats["total_cnt"], + batch_cnt, + ) + tb_writer.add_scalar( + f"{tb_prefix}/{feature_name}/insert_cnt", + stats["insert_cnt"], + batch_cnt, + ) + tb_writer.add_scalar( + f"{tb_prefix}/{feature_name}/collision_cnt", + stats["collision_cnt"], + batch_cnt, + ) + tb_writer.add_scalar( + f"{tb_prefix}/{feature_name}/hit_rate", + hit_rate, + batch_cnt, + ) + tb_writer.add_scalar( + f"{tb_prefix}/{feature_name}/insert_rate", + insert_rate, + batch_cnt, + ) + tb_writer.add_scalar( + f"{tb_prefix}/{feature_name}/collision_rate", + collision_rate, + batch_cnt, + ) + tb_writer.add_scalar( + f"{tb_prefix}/{feature_name}/total_num_collisions", + total_num_collisions[feature_name], + batch_cnt, + ) + tb_writer.add_scalar( + f"{tb_prefix}/{feature_name}/total_num_queries", + total_num_queries[feature_name], + batch_cnt, + ) + tb_writer.add_scalar( + f"{tb_prefix}/{feature_name}/overall_collision_rate", + overall_collision_rate, + batch_cnt, + ) + ## convert rank idx to string for displaying in tensorboard + rank_total_cnt_scalar_dict = dict( + [ + (str(rank_idx), rank_total_cnt) + for (rank_idx, rank_total_cnt) in stats[ + "rank_total_cnt" + ].items() + ] + ) + tb_writer.add_scalars( + f"{tb_prefix}/{feature_name}/number of queries mapped to rank", + rank_total_cnt_scalar_dict, + batch_cnt, + ) + ## convert rank idx to string for displaying in tensorboard + rank_num_empty_slots_scalar_dict = dict( + [ + (str(rank_idx), rank_num_empty_slots) + for (rank_idx, rank_num_empty_slots) in stats[ + "rank_num_empty_slots" + ].items() + ] + ) + tb_writer.add_scalars( + f"{tb_prefix}/{feature_name}/number of empty slots in rank", + rank_num_empty_slots_scalar_dict, + batch_cnt, + ) + ## convert rank idx to string for displaying in tensorboard + rank_num_unique_queries_scalar_dict = dict( + [ + (str(rank_idx), rank_num_unique_queries) + for (rank_idx, rank_num_unique_queries) in stats[ + "rank_num_unique_queries" + ].items() + ] + ) + tb_writer.add_scalars( + f"{tb_prefix}/{feature_name}/number of unique queries in rank", + rank_num_unique_queries_scalar_dict, + batch_cnt, + ) elif msg_type == "duration_and_num_queries": epoch_idx = msg_content["epoch_idx"] rank = msg_content["rank"] interval_start_batch_idx = msg_content["interval_start_batch_idx"] + interval_start_batch_cnt = msg_content["interval_start_batch_cnt"] per_batch_time_list = msg_content["per_batch_time_list"] per_batch_num_queries_list = msg_content["per_batch_num_queries_list"] - # save the qps statistics to a file + # save the qps statistics to a file and tensorboard + tb_prefix = "efficiency" with open(qps_metrics_file_path, "a") as f: writer = csv.writer(f) for i in range(len(per_batch_time_list)): + qps = ( + per_batch_num_queries_list[i] / per_batch_time_list[i] + if per_batch_time_list[i] > 0 + else 0 + ) writer.writerow( [ epoch_idx, str(interval_start_batch_idx + i), + str(interval_start_batch_cnt + i), rank, per_batch_num_queries_list[i], per_batch_time_list[i], - ( - per_batch_num_queries_list[i] / per_batch_time_list[i] - if per_batch_time_list[i] > 0 - else 0 - ), + qps, ] ) + # write the qps statistics to tensorboard + tb_writer.add_scalar( + f"{tb_prefix}/qps", + qps, + interval_start_batch_cnt + i, + ) + tb_writer.add_scalars( + f"{tb_prefix}/number of queries", + {str(rank): per_batch_num_queries_list[i]}, + interval_start_batch_cnt + i, + ) + tb_writer.add_scalars( + f"{tb_prefix}/training duration", + {str(rank): per_batch_time_list[i]}, + interval_start_batch_cnt + i, + ) elif msg_type == "training_metrics": epoch_idx = msg_content["epoch_idx"] rank = msg_content["rank"] interval_start_batch_idx = msg_content["interval_start_batch_idx"] + interval_start_batch_cnt = msg_content["interval_start_batch_cnt"] per_batch_loss_list = msg_content["per_batch_loss_list"] - # save the training metrics to a file + # save the training metrics to a file and tensorboard + tb_prefix = "training" with open(training_metrics_file_path, "a") as f: writer = csv.writer(f) for i in range(len(per_batch_loss_list)): + # write the training metrics to csv file writer.writerow( [ epoch_idx, str(interval_start_batch_idx + i), + str(interval_start_batch_cnt + i), rank, per_batch_loss_list[i], ] ) + # write the training metrics to tensorboard + tb_writer.add_scalars( + f"{tb_prefix}/loss", + {str(rank): per_batch_loss_list[i]}, + interval_start_batch_cnt + i, + ) elif msg_type == "eval_result": epoch_idx = msg_content["epoch_idx"] rank = msg_content["rank"] eval_result_dict = msg_content["eval_result_dict"] - # save the evaluation result to a file + # save the evaluation result to a file and tensorboard + tb_prefix = "evaluation" with open(eval_metrics_file_path, "a") as f: + # write the evaluation result to csv file writer = csv.writer(f) writer.writerow( [ @@ -593,6 +776,30 @@ def statistic(args: argparse.Namespace, queue: multiprocessing.Queue) -> None: eval_result_dict["mse"] if "mse" in eval_result_dict else "", ] ) + # write the evaluation result to tensorboard + # rebuild {task_idx: {metric_name: {rank: metric_value}}} dict + tb_eval_result_dict = ( + {} + ) # {task_idx: {metric_name: {rank: metric_value}}} + for metric_name, task_metric_value_list in eval_result_dict.items(): + for task_idx, metric_value in enumerate(task_metric_value_list): + if task_idx not in tb_eval_result_dict: + tb_eval_result_dict[task_idx] = {} + if metric_name not in tb_eval_result_dict[task_idx]: + tb_eval_result_dict[task_idx][metric_name] = {} + tb_eval_result_dict[task_idx][metric_name][ + str(rank) + ] = metric_value + # display the evaluation result in tensorboard for each task + for task_idx in tb_eval_result_dict.keys(): + for metric_name, metric_value_dict in tb_eval_result_dict[ + task_idx + ].items(): + tb_writer.add_scalars( + f"{tb_prefix}/task_{task_idx}/{metric_name}", + metric_value_dict, + epoch_idx, + ) else: # raise a warning if the message type is not recognized print("Warning: Unknown message type") @@ -602,6 +809,8 @@ def statistic(args: argparse.Namespace, queue: multiprocessing.Queue) -> None: if __name__ == "__main__": args: argparse.Namespace = parse_args(sys.argv[1:]) + __builtins__.__dict__["profile"] = LineProfiler() + # set environment variables os.environ["MASTER_ADDR"] = str("localhost") os.environ["MASTER_PORT"] = str(get_free_port()) diff --git a/torchrec/distributed/benchmark/benchmark_zch/benchmark_zch_utils.py b/torchrec/distributed/benchmark/benchmark_zch/benchmark_zch_utils.py index 98e93a1b7..889ad3b27 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/benchmark_zch_utils.py +++ b/torchrec/distributed/benchmark/benchmark_zch/benchmark_zch_utils.py @@ -1,23 +1,21 @@ -import argparse -import copy +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +# pyre-strict import json import logging import os -from typing import Any, Dict +from typing import Any, Dict, Set import numpy as np import torch import torch.nn as nn -import yaml from torchrec.modules.mc_embedding_modules import ManagedCollisionEmbeddingCollection -from torchrec.modules.mc_modules import ( - DistanceLFU_EvictionPolicy, - ManagedCollisionCollection, - MCHManagedCollisionModule, -) - -from torchrec.sparse.jagged_tensor import KeyedJaggedTensor def get_module_from_instance( @@ -104,6 +102,7 @@ def __init__( self._mch_stats: Dict[str, Any] = ( {} ) # dictionary of {table_name [str]: {metric_name [str]: metric_value [int]}} + self.feature_name_unique_queried_values_set_dict: Dict[str, Set[int]] = {} # record mcec state to file def record_mcec_state(self, stage: str) -> None: @@ -260,6 +259,7 @@ def update(self) -> None: "collision_cnt": 0, "rank_total_cnt": 0, "num_empty_slots": 0, + "num_unique_queries": 0, } # get the input faeture values input_feature_values = np.array(rank_feature_value_before_fwd[feature_name]) @@ -313,4 +313,16 @@ def update(self) -> None: this_rank_total_count - this_rank_hits_count - this_rank_insert_count ) batch_stats[feature_name]["collision_cnt"] += int(this_rank_collision_count) + # get the unique values in the input feature values + if feature_name not in self.feature_name_unique_queried_values_set_dict: + self.feature_name_unique_queried_values_set_dict[feature_name] = set( + input_feature_values.tolist() + ) + else: + self.feature_name_unique_queried_values_set_dict[feature_name].update( + set(input_feature_values.tolist()) + ) + batch_stats[feature_name]["num_unique_queries"] = len( + self.feature_name_unique_queried_values_set_dict[feature_name] + ) self._mch_stats = batch_stats diff --git a/torchrec/distributed/benchmark/benchmark_zch/count_dataset_distributions.py b/torchrec/distributed/benchmark/benchmark_zch/count_dataset_distributions.py index 3fbd21e6e..4185074a7 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/count_dataset_distributions.py +++ b/torchrec/distributed/benchmark/benchmark_zch/count_dataset_distributions.py @@ -1,3 +1,11 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +# pyre-strict import argparse import json import multiprocessing diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/configs/criteo_kaggle.yaml b/torchrec/distributed/benchmark/benchmark_zch/data/configs/criteo_kaggle.yaml index 852d79631..ba94d11ad 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/data/configs/criteo_kaggle.yaml +++ b/torchrec/distributed/benchmark/benchmark_zch/data/configs/criteo_kaggle.yaml @@ -1,3 +1,7 @@ -dataset_path: "/home/lizhouyu/oss_github/dlrm/torchrec_dlrm/criteo_1tb/criteo_kaggle_processed" +dataset_path: "/home/lizhouyu/datasets/criteo_kaggle_processed" batch_size: 4096 seed: 0 +multitask_configs: + - task_name: is_click + task_weight: 1 + task_type: classification diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/configs/kuairand_1k.yaml b/torchrec/distributed/benchmark/benchmark_zch/data/configs/kuairand_1k.yaml index 436fb4751..fe396274d 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/data/configs/kuairand_1k.yaml +++ b/torchrec/distributed/benchmark/benchmark_zch/data/configs/kuairand_1k.yaml @@ -1,4 +1,4 @@ -dataset_path: "/home/lizhouyu/oss_github/generative-recommenders/generative_recommenders/dlrm_v3/data/KuaiRand-1K/data" +dataset_path: "/home/lizhouyu/datasets/kuairand-1k/data" batch_size: 16 train_split_percentage: 0.75 num_workers: 4 diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/get_dataloader.py b/torchrec/distributed/benchmark/benchmark_zch/data/get_dataloader.py index 558eb222d..c0806a6a2 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/data/get_dataloader.py +++ b/torchrec/distributed/benchmark/benchmark_zch/data/get_dataloader.py @@ -1,3 +1,11 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +# pyre-strict import argparse import os diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/get_metric_modules.py b/torchrec/distributed/benchmark/benchmark_zch/data/get_metric_modules.py index 44a053cce..cbf0108ca 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/data/get_metric_modules.py +++ b/torchrec/distributed/benchmark/benchmark_zch/data/get_metric_modules.py @@ -1,3 +1,11 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +# pyre-strict import argparse import os import sys diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/nonzch_remapper.py b/torchrec/distributed/benchmark/benchmark_zch/data/nonzch_remapper.py index 383a55114..d8dac39ac 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/data/nonzch_remapper.py +++ b/torchrec/distributed/benchmark/benchmark_zch/data/nonzch_remapper.py @@ -1,3 +1,11 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +# pyre-strict from dataclasses import dataclass from typing import Dict, List, Optional, Tuple, Union @@ -99,6 +107,24 @@ def __init__( ) self._input_hash_size = input_hash_size + def get_batch_kjt_dict(self, batch: Batch) -> Dict[str, KeyedJaggedTensor]: + """ + Get the KJT in each batch + Parameters: + batch: the batch whose KJT is ought to be fetched + Returns: + batch_kjt_dict: a dictionary of [batch_attribute_name: KeyedJaggedTensor] + where only attributes whose values are KeyedJaggedTensor are fetched. + """ + batch_kjt_dict = {} # create a dictionary for return + batch_attr_dict = vars(batch) # get batch's attributes and values + for batch_attr_name, batch_attr_value in batch_attr_dict.items(): + if isinstance( + batch_attr_value, KeyedJaggedTensor + ): # only fetch attributes whose values are KeyedJaggedTensor + batch_kjt_dict[batch_attr_name] = batch_attr_value + return batch_kjt_dict + def remap(self, batch: Batch) -> Batch: # for all the attributes under batch, like batch.uih_features, batch.candidates_features, # get the kjt as a dict, and remap the kjt @@ -118,7 +144,7 @@ def remap(self, batch: Batch) -> Batch: # candidates_features: KeyedJaggedTensor # for every attribute in batch, remap the kjt - for attr_name, feature_kjt_dict in batch.get_dict().items(): + for attr_name, feature_kjt_dict in self.get_batch_kjt_dict(batch).items(): # separate feature kjt with {feature_name_1: feature_kjt_1, feature_name_2: feature_kjt_2, ...} # to multiple dict with {feature_name_1: jt_1}, {feature_name_2: jt_2}, ... attr_feature_jt_dict = {} diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/kuairand_1k.py b/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/kuairand_1k.py index 56f182a4d..b16d08511 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/kuairand_1k.py +++ b/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/kuairand_1k.py @@ -1,3 +1,11 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +# pyre-strict import argparse import json diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/kuairand_27k.py b/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/kuairand_27k.py index 2aa0245f2..d8e283a6a 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/kuairand_27k.py +++ b/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/kuairand_27k.py @@ -1,3 +1,11 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +# pyre-strict import argparse import json diff --git a/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/movielens_1m.py b/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/movielens_1m.py index b92cfd889..cb6062bc0 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/movielens_1m.py +++ b/torchrec/distributed/benchmark/benchmark_zch/data/preprocess/movielens_1m.py @@ -1,3 +1,11 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +# pyre-strict import argparse import os diff --git a/torchrec/distributed/benchmark/benchmark_zch/models/apply_optimizers.py b/torchrec/distributed/benchmark/benchmark_zch/models/apply_optimizers.py index 091e41d4c..8bce5ffc0 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/models/apply_optimizers.py +++ b/torchrec/distributed/benchmark/benchmark_zch/models/apply_optimizers.py @@ -1,3 +1,12 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +# pyre-strict + import argparse import os diff --git a/torchrec/distributed/benchmark/benchmark_zch/models/configs/dlrmv2.yaml b/torchrec/distributed/benchmark/benchmark_zch/models/configs/dlrmv2.yaml index 3cb83d486..9346755a6 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/models/configs/dlrmv2.yaml +++ b/torchrec/distributed/benchmark/benchmark_zch/models/configs/dlrmv2.yaml @@ -9,31 +9,31 @@ over_arch_layer_sizes: - 1 embedding_dim: 64 num_embeddings_per_feature: - cat_0: 100000 - cat_1: 100000 - cat_2: 100000 - cat_3: 100000 - cat_4: 100000 - cat_5: 100000 - cat_6: 100000 - cat_7: 100000 - cat_8: 100000 - cat_9: 100000 - cat_10: 100000 - cat_11: 100000 - cat_12: 100000 - cat_13: 100000 - cat_14: 100000 - cat_15: 100000 - cat_16: 100000 - cat_17: 100000 - cat_18: 100000 - cat_19: 100000 - cat_20: 100000 - cat_21: 100000 - cat_22: 100000 - cat_23: 100000 - cat_24: 100000 - cat_25: 100000 + cat_0: 40000000 + cat_1: 39060 + cat_2: 17295 + cat_3: 7424 + cat_4: 20265 + cat_5: 3 + cat_6: 7122 + cat_7: 1543 + cat_8: 63 + cat_9: 40000000 + cat_10: 3067956 + cat_11: 405282 + cat_12: 10 + cat_13: 2209 + cat_14: 11938 + cat_15: 155 + cat_16: 4 + cat_17: 976 + cat_18: 14 + cat_19: 40000000 + cat_20: 40000000 + cat_21: 40000000 + cat_22: 590152 + cat_23: 12973 + cat_24: 108 + cat_25: 36 embedding_module_attribute_path: "dlrm.sparse_arch.embedding_bag_collection" # the attribute path after model managed_collision_module_attribute_path: "module.dlrm.sparse_arch.embedding_bag_collection.mc_embedding_bag_collection._managed_collision_collection._managed_collision_modules" # the attribute path of managed collision module after model diff --git a/torchrec/distributed/benchmark/benchmark_zch/models/make_model.py b/torchrec/distributed/benchmark/benchmark_zch/models/make_model.py index aa24621fd..763536b8f 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/models/make_model.py +++ b/torchrec/distributed/benchmark/benchmark_zch/models/make_model.py @@ -1,3 +1,12 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +# pyre-strict + import argparse import os from typing import Any, Dict, Tuple diff --git a/torchrec/distributed/benchmark/benchmark_zch/models/models/dlrmv2.py b/torchrec/distributed/benchmark/benchmark_zch/models/models/dlrmv2.py index c649dbb8c..a67067bee 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/models/models/dlrmv2.py +++ b/torchrec/distributed/benchmark/benchmark_zch/models/models/dlrmv2.py @@ -1,3 +1,12 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +# pyre-strict + import argparse from typing import Any, Dict, List, Optional, Tuple @@ -35,6 +44,9 @@ def __init__( dense_device=dense_device, ) self.train_model = DLRMTrain(self.dlrm) + self.table_configs: List[EmbeddingBagConfig] = list( + embedding_bag_collection.embedding_bag_configs() + ) def forward( self, batch: Batch @@ -55,10 +67,10 @@ def make_model_dlrmv2( ) -> nn.Module: ebc_configs = [ EmbeddingBagConfig( - name=f"t_{feature_name}", + name=f"{feature_name}", embedding_dim=configs["embedding_dim"], num_embeddings=( - none_throws(configs["num_embeddings_per_feature"])[feature_idx] + none_throws(configs["num_embeddings_per_feature"])[feature_name] if args.num_embeddings is None else args.num_embeddings ), @@ -76,8 +88,9 @@ def make_model_dlrmv2( input_hash_size=args.input_hash_size, device=torch.device("meta"), world_size=get_local_size(), - use_mpzch=True, + zch_method="mpzch", mpzch_num_buckets=args.num_buckets, + mpzch_max_probe=args.max_probe, ) ) else: diff --git a/torchrec/distributed/benchmark/benchmark_zch/models/models/dlrmv3.py b/torchrec/distributed/benchmark/benchmark_zch/models/models/dlrmv3.py index 309c21602..5e4b0c73a 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/models/models/dlrmv3.py +++ b/torchrec/distributed/benchmark/benchmark_zch/models/models/dlrmv3.py @@ -1,3 +1,12 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +# pyre-strict + import argparse from dataclasses import dataclass from typing import Any, Dict, List, Optional, Tuple, Union diff --git a/torchrec/distributed/benchmark/benchmark_zch/models/shard_model.py b/torchrec/distributed/benchmark/benchmark_zch/models/shard_model.py index 7ccc0158d..e80fd66e5 100644 --- a/torchrec/distributed/benchmark/benchmark_zch/models/shard_model.py +++ b/torchrec/distributed/benchmark/benchmark_zch/models/shard_model.py @@ -1,3 +1,12 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +# pyre-strict + import argparse from typing import cast diff --git a/torchrec/modules/mc_adapter.py b/torchrec/modules/mc_adapter.py index 7feba8f81..728bb69d7 100644 --- a/torchrec/modules/mc_adapter.py +++ b/torchrec/modules/mc_adapter.py @@ -1,4 +1,9 @@ -# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary. +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. # pyre-strict import sys @@ -148,9 +153,11 @@ def __init__( world_size: int, eviction_interval: int = 1, allow_in_place_embed_weight_update: bool = False, - use_mpzch: bool = False, - mpzch_num_buckets: Optional[int] = None, - mpzch_max_probe: Optional[int] = None, + zch_method: str = "", # method for managing collisions, one of ["", "mpzch", "sort_zch"] + mpzch_num_buckets: Optional[int] = 80, + mpzch_max_probe: Optional[ + int + ] = 100, # max_probe for HashZchManagedCollisionModule ) -> None: """ Initialize an EmbeddingBagCollectionAdapter. @@ -173,30 +180,33 @@ def __init__( mc_modules = {} for table_config in ebc.embedding_bag_configs(): table_name = table_config.name - if use_mpzch: + if zch_method == "mpzch": # if use MPZCH, create a HashZchManagedCollisionModule + num_buckets = mpzch_num_buckets if mpzch_num_buckets else world_size + max_probe = ( + min( + mpzch_max_probe, + table_config.num_embeddings // world_size // num_buckets, + ) + if mpzch_max_probe + else table_config.num_embeddings // world_size // num_buckets + ) mc_modules[table_name] = HashZchManagedCollisionModule( # MPZCH is_inference=False, zch_size=(table_config.num_embeddings), input_hash_size=input_hash_size, device=device, - total_num_buckets=( - mpzch_num_buckets if mpzch_num_buckets else world_size - ), # total_num_buckets if not passed, use world_size, WORLD_SIZE should be a factor of total_num_buckets + total_num_buckets=num_buckets, # total_num_buckets if not passed, use world_size, WORLD_SIZE should be a factor of total_num_buckets + max_probe=max_probe, eviction_policy_name=HashZchEvictionPolicyName.SINGLE_TTL_EVICTION, # defaultly using single ttl eviction policy eviction_config=HashZchEvictionConfig( features=table_config.feature_names, single_ttl=eviction_interval, ), - max_probe=( - mpzch_max_probe - if mpzch_max_probe is not None - and mpzch_max_probe - < (table_config.num_embeddings // world_size) - else table_config.num_embeddings // world_size - ), # max_probe for HashZchManagedCollisionModule ) - else: # if not use MPZCH, create a MCHManagedCollisionModule using the sort ZCH algorithm + elif ( + zch_method == "sort_zch" + ): # if not use MPZCH, create a MCHManagedCollisionModule using the sort ZCH algorithm mc_modules[table_name] = MCHManagedCollisionModule( # sort ZCH zch_size=table_config.num_embeddings, device=device, @@ -204,7 +214,10 @@ def __init__( eviction_interval=eviction_interval, eviction_policy=DistanceLFU_EvictionPolicy(), ) # NOTE: the benchmark for sort ZCH is not implemented yet - # TODO: add the pure hash module here + else: # if not use MPZCH, create a MCHManagedCollisionModule using the sort ZCH + raise NotImplementedError( + f"zc method {zch_method} is not supported yet" + ) # create the mcebc module with the mc modules and the original ebc self.mc_embedding_bag_collection = ( @@ -219,10 +232,6 @@ def __init__( ) ) - self.remapped_ids: Optional[Dict[str, torch.Tensor]] = ( - None # to store remapped ids - ) - def forward(self, input_kjt: KeyedJaggedTensor) -> Dict[str, JaggedTensor]: """ Args: @@ -230,8 +239,7 @@ def forward(self, input_kjt: KeyedJaggedTensor) -> Dict[str, JaggedTensor]: Returns: Dict[str, JaggedTensor]: dictionary of {'feature_name': JaggedTensor} """ - mc_ebc_out, remapped_ids = self.mc_embedding_bag_collection(input_kjt) - self.remapped_ids = remapped_ids + mc_ebc_out, per_table_remapped_id = self.mc_embedding_bag_collection(input_kjt) return mc_ebc_out def parameters(self, recurse: bool = True) -> Iterator[Parameter]: @@ -246,6 +254,6 @@ def embedding_bag_configs(self) -> List[EmbeddingBagConfig]: Dict[str, EmbeddingConfig]: dictionary of {'feature_name': EmbeddingConfig} """ return ( - # pyre-ignore [29] # NOTE: the function "embedding_configs" returns the _embedding_module attribute of the EmbeddingCollection + # pyre-ignore[29]: `Union[BoundMethod[typing.Callable(EmbeddingBagCollection.embedding_bag_configs)[[Named(self, EmbeddingBagCollection)], List[EmbeddingBagConfig]], EmbeddingBagCollection], nn.modules.module.Module, torch._tensor.Tensor]` is not a function. # NOTE: the function "embedding_configs" returns the _embedding_module attribute of the EmbeddingCollection self.mc_embedding_bag_collection._embedding_module.embedding_bag_configs() )