diff --git a/.github/workflows/continuous_integration.yml b/.github/workflows/continuous_integration.yml index 30dd65f..71af73d 100644 --- a/.github/workflows/continuous_integration.yml +++ b/.github/workflows/continuous_integration.yml @@ -16,7 +16,7 @@ jobs: python-version: ["3.8", '3.11'] steps: - name: Checkout repository - uses: actions/checkout@v3 + uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v5 with: diff --git a/examples/levelling_up.ipynb b/examples/levelling_up.ipynb index 4f028f7..5926aba 100644 --- a/examples/levelling_up.ipynb +++ b/examples/levelling_up.ipynb @@ -12,7 +12,11 @@ "\n", "We compare conventional fairness algorithms that can increase the harm to some groups in the name of equality, against new approaches that only decrease the harm to individuals.\n", "\n", - "The code here reproduces the plots in the [paper](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4331652).\n" + "The code here at the top of the notebook reproduces the plots in the [paper](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4331652).\n", + "\n", + "At the bottom of the file, we additionally show how to enforce levelling up while simultaneously satisfying a definition of fairness such as demographic parity or predictive parity.\n", + "\n", + "This is done by setting an optional argument to `fit` `force_levelling_up='+'`, or `force_levelling_up='-'` depending on if you want the selection rate to only increase or only decrease.\n" ] }, { @@ -34,544 +38,166 @@ "/opt/miniconda3/envs/ag/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", " from .autonotebook import tqdm as notebook_tqdm\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "No path specified. Models will be saved in: \"AutogluonModels/ag-20240617_191910\"\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "No presets specified! To achieve strong results with AutoGluon, it is recommended to use the available presets.\n", - "\tRecommended Presets (For more details refer to https://auto.gluon.ai/stable/tutorials/tabular/tabular-essentials.html#presets):\n", - "\tpresets='best_quality' : Maximize accuracy. Default time_limit=3600.\n", - "\tpresets='high_quality' : Strong accuracy with fast inference speed. Default time_limit=3600.\n", - "\tpresets='good_quality' : Good accuracy with very fast inference speed. Default time_limit=3600.\n", - "\tpresets='medium_quality' : Fast training time, ideal for initial prototyping.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Beginning AutoGluon training ... Time limit = 5s\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "AutoGluon will save models to \"AutogluonModels/ag-20240617_191910\"\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "=================== System Info ===================\n", - "AutoGluon Version: 1.1.0\n", - "Python Version: 3.10.13\n", - "Operating System: Darwin\n", - "Platform Machine: arm64\n", - "Platform Version: Darwin Kernel Version 23.5.0: Wed May 1 20:14:38 PDT 2024; root:xnu-10063.121.3~5/RELEASE_ARM64_T6020\n", - "CPU Count: 10\n", - "Memory Avail: 6.45 GB / 16.00 GB (40.3%)\n", - "Disk Space Avail: 360.81 GB / 460.43 GB (78.4%)\n", - "===================================================\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Train Data Rows: 39073\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Train Data Columns: 14\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Label Column: class\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "AutoGluon infers your prediction problem is: 'binary' (because only two unique label-values observed).\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t2 unique label values: [' <=50K', ' >50K']\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\tIf 'binary' is not the correct problem_type, please manually specify the problem_type parameter during predictor init (You may specify problem_type as one of: ['binary', 'multiclass', 'regression'])\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Problem Type: binary\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Preprocessing data ...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Selected class <--> label mapping: class 1 = >50K, class 0 = <=50K\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\tNote: For your binary classification, AutoGluon arbitrarily selected which label-value represents positive ( >50K) vs negative ( <=50K) class.\n", - "\tTo explicitly set the positive_class, either rename classes to 1 and 0, or specify positive_class in Predictor init.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Using Feature Generators to preprocess the data ...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Fitting AutoMLPipelineFeatureGenerator...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\tAvailable Memory: 6626.69 MB\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\tTrain Data (Original) Memory Usage: 21.86 MB (0.3% of available memory)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\tInferring data type of each feature based on column values. Set feature_metadata_in to manually specify special dtypes of the features.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\tStage 1 Generators:\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t\tFitting AsTypeFeatureGenerator...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t\t\tNote: Converting 1 features to boolean dtype as they only contain 2 unique values.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\tStage 2 Generators:\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t\tFitting FillNaFeatureGenerator...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\tStage 3 Generators:\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t\tFitting IdentityFeatureGenerator...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t\tFitting CategoryFeatureGenerator...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t\t\tFitting CategoryMemoryMinimizeFeatureGenerator...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\tStage 4 Generators:\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t\tFitting DropUniqueFeatureGenerator...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\tStage 5 Generators:\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t\tFitting DropDuplicatesFeatureGenerator...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\tTypes of features in original data (raw dtype, special dtypes):\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t\t('int', []) : 6 | ['age', 'fnlwgt', 'education-num', 'capital-gain', 'capital-loss', ...]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t\t('object', []) : 8 | ['workclass', 'education', 'marital-status', 'occupation', 'relationship', ...]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\tTypes of features in processed data (raw dtype, special dtypes):\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t\t('category', []) : 7 | ['workclass', 'education', 'marital-status', 'occupation', 'relationship', ...]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t\t('int', []) : 6 | ['age', 'fnlwgt', 'education-num', 'capital-gain', 'capital-loss', ...]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t\t('int', ['bool']) : 1 | ['sex']\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t0.1s = Fit runtime\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t14 features in original data used to generate 14 features in processed data.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\tTrain Data (Processed) Memory Usage: 2.09 MB (0.0% of available memory)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Data preprocessing and feature engineering runtime = 0.18s ...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "AutoGluon will gauge predictive performance using evaluation metric: 'accuracy'\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\tTo change this, specify the eval_metric parameter of Predictor()\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Automatically generating train/validation split with holdout_frac=0.0639828014229775, Train Rows: 36573, Val Rows: 2500\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "User-specified model hyperparameters to be fit:\n", - "{\n", - "\t'NN_TORCH': {},\n", - "\t'GBM': [{'extra_trees': True, 'ag_args': {'name_suffix': 'XT'}}, {}, 'GBMLarge'],\n", - "\t'CAT': {},\n", - "\t'XGB': {},\n", - "\t'FASTAI': {},\n", - "\t'RF': [{'criterion': 'gini', 'ag_args': {'name_suffix': 'Gini', 'problem_types': ['binary', 'multiclass']}}, {'criterion': 'entropy', 'ag_args': {'name_suffix': 'Entr', 'problem_types': ['binary', 'multiclass']}}, {'criterion': 'squared_error', 'ag_args': {'name_suffix': 'MSE', 'problem_types': ['regression', 'quantile']}}],\n", - "\t'XT': [{'criterion': 'gini', 'ag_args': {'name_suffix': 'Gini', 'problem_types': ['binary', 'multiclass']}}, {'criterion': 'entropy', 'ag_args': {'name_suffix': 'Entr', 'problem_types': ['binary', 'multiclass']}}, {'criterion': 'squared_error', 'ag_args': {'name_suffix': 'MSE', 'problem_types': ['regression', 'quantile']}}],\n", - "\t'KNN': [{'weights': 'uniform', 'ag_args': {'name_suffix': 'Unif'}}, {'weights': 'distance', 'ag_args': {'name_suffix': 'Dist'}}],\n", - "}\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Fitting 13 L1 models ...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Fitting model: KNeighborsUnif ... Training model for up to 4.82s of the 4.82s of remaining time.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t0.7752\t = Validation score (accuracy)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t1.64s\t = Training runtime\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t0.04s\t = Validation runtime\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Fitting model: KNeighborsDist ... Training model for up to 3.14s of the 3.14s of remaining time.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t0.766\t = Validation score (accuracy)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t0.04s\t = Training runtime\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t0.03s\t = Validation runtime\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Fitting model: LightGBMXT ... Training model for up to 3.06s of the 3.06s of remaining time.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/miniconda3/envs/ag/lib/python3.10/site-packages/dask/dataframe/__init__.py:31: FutureWarning: \n", - "Dask dataframe query planning is disabled because dask-expr is not installed.\n", - "\n", - "You can install it with `pip install dask[dataframe]` or `conda install dask`.\n", - "This will raise in a future version.\n", - "\n", - " warnings.warn(msg, FutureWarning)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\tRan out of time, early stopping on iteration 112. Best iteration is:\n", - "\t[112]\tvalid_set's binary_error: 0.13\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t0.87\t = Validation score (accuracy)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t3.62s\t = Training runtime\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t0.02s\t = Validation runtime\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Fitting model: WeightedEnsemble_L2 ... Training model for up to 4.82s of the -0.64s of remaining time.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\tEnsemble Weights: {'LightGBMXT': 0.8, 'KNeighborsDist': 0.133, 'KNeighborsUnif': 0.067}\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t0.8724\t = Validation score (accuracy)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t0.03s\t = Training runtime\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\t0.0s\t = Validation runtime\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "AutoGluon training complete, total runtime = 5.79s ... Best model: \"WeightedEnsemble_L2\"\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "TabularPredictor saved. To load, use: predictor = TabularPredictor.load(\"AutogluonModels/ag-20240617_191910\")\n" - ] } ], "source": [ "# Load and train a baseline classifier\n", "import matplotlib.pyplot as plt\n", "from autogluon.tabular import TabularDataset, TabularPredictor\n", - "from oxonfair import FairPredictor \n", + "from oxonfair import FairPredictor\n", "from oxonfair.utils import group_metrics as gm\n", "train_data = TabularDataset('https://autogluon.s3.amazonaws.com/datasets/Inc/train.csv')\n", - "test_data = TabularDataset('https://autogluon.s3.amazonaws.com/datasets/Inc/test.csv')\n", - "predictor = TabularPredictor(label='class').fit(train_data=train_data,time_limit=5)\n" + "test_data = TabularDataset('https://autogluon.s3.amazonaws.com/datasets/Inc/test.csv')\n" ] }, { "cell_type": "code", "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No path specified. Models will be saved in: \"AutogluonModels/ag-20240930_175430\"\n", + "Verbosity: 2 (Standard Logging)\n", + "=================== System Info ===================\n", + "AutoGluon Version: 1.1.1\n", + "Python Version: 3.10.14\n", + "Operating System: Darwin\n", + "Platform Machine: arm64\n", + "Platform Version: Darwin Kernel Version 24.0.0: Mon Aug 12 20:52:12 PDT 2024; root:xnu-11215.1.10~2/RELEASE_ARM64_T6020\n", + "CPU Count: 10\n", + "Memory Avail: 4.89 GB / 16.00 GB (30.5%)\n", + "Disk Space Avail: 31.21 GB / 460.43 GB (6.8%)\n", + "===================================================\n", + "No presets specified! To achieve strong results with AutoGluon, it is recommended to use the available presets.\n", + "\tRecommended Presets (For more details refer to https://auto.gluon.ai/stable/tutorials/tabular/tabular-essentials.html#presets):\n", + "\tpresets='best_quality' : Maximize accuracy. Default time_limit=3600.\n", + "\tpresets='high_quality' : Strong accuracy with fast inference speed. Default time_limit=3600.\n", + "\tpresets='good_quality' : Good accuracy with very fast inference speed. Default time_limit=3600.\n", + "\tpresets='medium_quality' : Fast training time, ideal for initial prototyping.\n", + "Beginning AutoGluon training ... Time limit = 25s\n", + "AutoGluon will save models to \"AutogluonModels/ag-20240930_175430\"\n", + "Train Data Rows: 39073\n", + "Train Data Columns: 14\n", + "Label Column: class\n", + "AutoGluon infers your prediction problem is: 'binary' (because only two unique label-values observed).\n", + "\t2 unique label values: [' <=50K', ' >50K']\n", + "\tIf 'binary' is not the correct problem_type, please manually specify the problem_type parameter during Predictor init (You may specify problem_type as one of: ['binary', 'multiclass', 'regression', 'quantile'])\n", + "Problem Type: binary\n", + "Preprocessing data ...\n", + "Selected class <--> label mapping: class 1 = >50K, class 0 = <=50K\n", + "\tNote: For your binary classification, AutoGluon arbitrarily selected which label-value represents positive ( >50K) vs negative ( <=50K) class.\n", + "\tTo explicitly set the positive_class, either rename classes to 1 and 0, or specify positive_class in Predictor init.\n", + "Using Feature Generators to preprocess the data ...\n", + "Fitting AutoMLPipelineFeatureGenerator...\n", + "\tAvailable Memory: 5025.71 MB\n", + "\tTrain Data (Original) Memory Usage: 21.86 MB (0.4% of available memory)\n", + "\tInferring data type of each feature based on column values. Set feature_metadata_in to manually specify special dtypes of the features.\n", + "\tStage 1 Generators:\n", + "\t\tFitting AsTypeFeatureGenerator...\n", + "\t\t\tNote: Converting 1 features to boolean dtype as they only contain 2 unique values.\n", + "\tStage 2 Generators:\n", + "\t\tFitting FillNaFeatureGenerator...\n", + "\tStage 3 Generators:\n", + "\t\tFitting IdentityFeatureGenerator...\n", + "\t\tFitting CategoryFeatureGenerator...\n", + "\t\t\tFitting CategoryMemoryMinimizeFeatureGenerator...\n", + "\tStage 4 Generators:\n", + "\t\tFitting DropUniqueFeatureGenerator...\n", + "\tStage 5 Generators:\n", + "\t\tFitting DropDuplicatesFeatureGenerator...\n", + "\tTypes of features in original data (raw dtype, special dtypes):\n", + "\t\t('int', []) : 6 | ['age', 'fnlwgt', 'education-num', 'capital-gain', 'capital-loss', ...]\n", + "\t\t('object', []) : 8 | ['workclass', 'education', 'marital-status', 'occupation', 'relationship', ...]\n", + "\tTypes of features in processed data (raw dtype, special dtypes):\n", + "\t\t('category', []) : 7 | ['workclass', 'education', 'marital-status', 'occupation', 'relationship', ...]\n", + "\t\t('int', []) : 6 | ['age', 'fnlwgt', 'education-num', 'capital-gain', 'capital-loss', ...]\n", + "\t\t('int', ['bool']) : 1 | ['sex']\n", + "\t0.1s = Fit runtime\n", + "\t14 features in original data used to generate 14 features in processed data.\n", + "\tTrain Data (Processed) Memory Usage: 2.09 MB (0.0% of available memory)\n", + "Data preprocessing and feature engineering runtime = 0.14s ...\n", + "AutoGluon will gauge predictive performance using evaluation metric: 'accuracy'\n", + "\tTo change this, specify the eval_metric parameter of Predictor()\n", + "Automatically generating train/validation split with holdout_frac=0.0639828014229775, Train Rows: 36573, Val Rows: 2500\n", + "User-specified model hyperparameters to be fit:\n", + "{\n", + "\t'NN_TORCH': {},\n", + "\t'GBM': [{'extra_trees': True, 'ag_args': {'name_suffix': 'XT'}}, {}, 'GBMLarge'],\n", + "\t'CAT': {},\n", + "\t'XGB': {},\n", + "\t'FASTAI': {},\n", + "\t'RF': [{'criterion': 'gini', 'ag_args': {'name_suffix': 'Gini', 'problem_types': ['binary', 'multiclass']}}, {'criterion': 'entropy', 'ag_args': {'name_suffix': 'Entr', 'problem_types': ['binary', 'multiclass']}}, {'criterion': 'squared_error', 'ag_args': {'name_suffix': 'MSE', 'problem_types': ['regression', 'quantile']}}],\n", + "\t'XT': [{'criterion': 'gini', 'ag_args': {'name_suffix': 'Gini', 'problem_types': ['binary', 'multiclass']}}, {'criterion': 'entropy', 'ag_args': {'name_suffix': 'Entr', 'problem_types': ['binary', 'multiclass']}}, {'criterion': 'squared_error', 'ag_args': {'name_suffix': 'MSE', 'problem_types': ['regression', 'quantile']}}],\n", + "\t'KNN': [{'weights': 'uniform', 'ag_args': {'name_suffix': 'Unif'}}, {'weights': 'distance', 'ag_args': {'name_suffix': 'Dist'}}],\n", + "}\n", + "Fitting 13 L1 models ...\n", + "Fitting model: KNeighborsUnif ... Training model for up to 24.86s of the 24.86s of remaining time.\n", + "\t0.7752\t = Validation score (accuracy)\n", + "\t1.36s\t = Training runtime\n", + "\t0.04s\t = Validation runtime\n", + "Fitting model: KNeighborsDist ... Training model for up to 23.46s of the 23.45s of remaining time.\n", + "\t0.766\t = Validation score (accuracy)\n", + "\t0.02s\t = Training runtime\n", + "\t0.01s\t = Validation runtime\n", + "Fitting model: LightGBMXT ... Training model for up to 23.41s of the 23.41s of remaining time.\n", + "\tWarning: Exception caused LightGBMXT to fail during training (ImportError)... Skipping this model.\n", + "\t\t`import lightgbm` failed. A quick tip is to install via `pip install autogluon.tabular[lightgbm]==1.1.1`.\n", + "Fitting model: LightGBM ... Training model for up to 23.35s of the 23.35s of remaining time.\n", + "\tWarning: Exception caused LightGBM to fail during training (ImportError)... Skipping this model.\n", + "\t\t`import lightgbm` failed. A quick tip is to install via `pip install autogluon.tabular[lightgbm]==1.1.1`.\n", + "Fitting model: RandomForestGini ... Training model for up to 23.29s of the 23.29s of remaining time.\n", + "\t0.86\t = Validation score (accuracy)\n", + "\t1.1s\t = Training runtime\n", + "\t0.04s\t = Validation runtime\n", + "Fitting model: RandomForestEntr ... Training model for up to 22.04s of the 22.04s of remaining time.\n", + "\t0.8624\t = Validation score (accuracy)\n", + "\t1.11s\t = Training runtime\n", + "\t0.04s\t = Validation runtime\n", + "Fitting model: CatBoost ... Training model for up to 20.77s of the 20.77s of remaining time.\n", + "\tWarning: Exception caused CatBoost to fail during training (ImportError)... Skipping this model.\n", + "\t\t\n", + "Fitting model: ExtraTreesGini ... Training model for up to 20.69s of the 20.69s of remaining time.\n", + "\t0.85\t = Validation score (accuracy)\n", + "\t0.73s\t = Training runtime\n", + "\t0.04s\t = Validation runtime\n", + "Fitting model: ExtraTreesEntr ... Training model for up to 19.73s of the 19.73s of remaining time.\n", + "\t0.8456\t = Validation score (accuracy)\n", + "\t0.76s\t = Training runtime\n", + "\t0.04s\t = Validation runtime\n", + "Fitting model: NeuralNetFastAI ... Training model for up to 18.76s of the 18.76s of remaining time.\n", + "\tWarning: Exception caused NeuralNetFastAI to fail during training (ImportError)... Skipping this model.\n", + "\t\tImport fastai failed. A quick tip is to install via `pip install autogluon.tabular[fastai]==1.1.1`. \n", + "Fitting model: XGBoost ... Training model for up to 18.69s of the 18.69s of remaining time.\n", + "\t0.882\t = Validation score (accuracy)\n", + "\t0.85s\t = Training runtime\n", + "\t0.01s\t = Validation runtime\n", + "Fitting model: NeuralNetTorch ... Training model for up to 17.82s of the 17.82s of remaining time.\n", + "\tRan out of time, stopping training early. (Stopping on epoch 34)\n", + "/opt/miniconda3/envs/ag/lib/python3.10/site-packages/autogluon/tabular/models/tabular_nn/torch/tabular_nn_torch.py:411: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " self.model = torch.load(net_filename)\n", + "\t0.8592\t = Validation score (accuracy)\n", + "\t17.57s\t = Training runtime\n", + "\t0.01s\t = Validation runtime\n", + "Fitting model: WeightedEnsemble_L2 ... Training model for up to 24.86s of the 0.22s of remaining time.\n", + "\tEnsemble Weights: {'XGBoost': 1.0}\n", + "\t0.882\t = Validation score (accuracy)\n", + "\t0.04s\t = Training runtime\n", + "\t0.0s\t = Validation runtime\n", + "AutoGluon training complete, total runtime = 24.85s ... Best model: WeightedEnsemble_L2 | Estimated inference throughput: 240664.7 rows/s (2500 batch size)\n", + "TabularPredictor saved. To load, use: predictor = TabularPredictor.load(\"AutogluonModels/ag-20240930_175430\")\n" + ] + } + ], + "source": [ + "predictor = TabularPredictor(label='class').fit(train_data=train_data,time_limit=25)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2024-06-17T19:19:16.060842Z", @@ -582,14 +208,23 @@ }, "outputs": [], "source": [ - "# Set grid_width to 1000 to reproduce the plots in the paper exactly. \n", - "# Setting it to False will give the default run-time, at the cost of slightly less detailed plots. \n", + "# Set grid_width to 1000 to reproduce the plots in the paper exactly.\n", + "# Setting it to False will give the default run-time, at the cost of slightly less detailed plots.\n", "grid_width = (False,1000)[1]" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now show the standard behaviour when enforcing demographic parity.\n", + "\n", + "We create a new classifier that enforces that the demographic parity (the difference in positive decision rates between men and women) is at most 0.02" + ] + }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 33, "metadata": { "execution": { "iopub.execute_input": "2024-06-17T19:19:16.088278Z", @@ -598,18 +233,29 @@ "shell.execute_reply": "2024-06-17T19:19:16.520478Z" } }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "#Enforcing demographic parity\n", "# Modify predictor to enforce fairness over the train_data with respect to groups given by the column 'sex'\n", "fpredictor = FairPredictor(predictor,train_data,'sex')\n", - "# Maximize accuracy while enforcing that the demographic parity (the difference in positive decision rates between men and women is at most 0.02)\n", + "# Maximize accuracy while enforcing that the demographic parity is at most 0.02\n", "fpredictor.fit(gm.accuracy,gm.demographic_parity,0.02,grid_width=grid_width)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 34, "metadata": { "execution": { "iopub.execute_input": "2024-06-17T19:19:16.527139Z", @@ -625,13 +271,13 @@ "Text(0.5, 1.0, 'Levelling Down: Demographic Parity vs Accuracy trade-off')" ] }, - "execution_count": 4, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -641,14 +287,32 @@ } ], "source": [ + "# Plot the accuracy/demographic trade-off\n", + "# This shows the expected behavior -- there is a smooth trade-off between accuracy and fairness,\n", + "# and then a sudden jump to the constant classifier which is perfectly fair.\n", "\n", "fpredictor.plot_frontier(objective1=gm.demographic_parity,objective2=gm.accuracy, show_updated=False)\n", "plt.title('Levelling Down: Demographic Parity vs Accuracy trade-off')" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now look at the selection rates for men and for women.\n", + "\n", + "What we see is the expected behaviour. A steady trend where the selection rate decrease for one group, and increases for the other, overlayed with jitter caused by quantize artifacts. \n", + "\n", + "The overall pattern is that while for one group we see a potentially desirable trade-off where the selection rate increases at the cost of accuracy, for the other group we see undesirable behaviour where while accuracy also decreases the selection rate also decreases.\n", + "\n", + "If the selection rate corresponds to, for example, offers for loans or scholarships, both forms of decrease are undesirable, and unneeded for the second group.\n", + "\n", + "We can avoid them by levelling-up" + ] + }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 35, "metadata": { "execution": { "iopub.execute_input": "2024-06-17T19:19:18.830727Z", @@ -661,16 +325,16 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 5, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk8AAAHFCAIAAABkZooaAACEQUlEQVR4nO3dd1wTZx8A8OcISdggG0kEBBVQBAQHIAIOnC0WqZuiYt9aF4ijWqvi1loVtKKtA6pVBAVXnaiAKMMFagtuKIggiANwoCT3/vHU80hCEiAJEH7fD3/k7p7n7rmE3C/33DMIkiQRAAAAoNRUmrsAAAAAgNxBtAMAAKD8INoBAABQfhDtAAAAKD+IdgAAAJQfRDsAAADKD6IdAAAA5QfRDgAAgPKDaAcAAED5tYloFxMTQxDE9evXFXxcgiDCw8Px65SUFIIgUlJS8GJ4eDhBEHI6Lt45pqGhweFwBg8evHXr1qqqKjkdsSnwp4OpqamZmpr6+PisXbu2rKysuYumUN7e3t26datva0FBAUEQMTExjdgzQaOrq+vt7X3y5MlGl1PgXzcqKqpxpZKTO3fuEATBZDJLSkqauyxyt2bNmqNHj8p8twIXK5l78eLF2LFjjY2NCYIYOXIkQqigoGD48OH6+voEQYSGhsrpuG0i2rVAU6dOzcjIkOshzpw5k5GRcebMmV9++aVDhw4LFizo2rXrrVu35HrQRouOjs7IyEhKStq2bZuTk9P69evt7OzOnz/f3OVqKczMzDIyMoYPH9647AEBARkZGVeuXNm2bVtpaekXX3zR6IAn8K/b0qLdrl27EEK1tbV79+5t7rLInZyinbytXLnyyJEjmzdvzsjI+PnnnxFCc+bMycrK2rNnT0ZGxpw5c+R0XFU57ReIx+FwOByOXA/h4uJiaGiIX48dO3bmzJleXl5ffvnl/fv32Wy2XA/dCN26dXN1dcWvR40aNWfOnL59+/r7+z948MDExKR5yybR27dvNTQ05HoINpvdp0+fRmc3MTHB2d3d3d3c3GxsbCIiIhoaO/FpKuBft9Fqamr279/v6Oj4/PnzPXv2/PDDDwouwLt379TU1ORXbdNQLa082N9//21tbT1hwgT6ml69euH7PPmBezv04MGD8ePHGxsbs9lsOzu7bdu24fXl5eUsFmvJkiX0xHfv3iUIYsuWLXixtLT0u+++43A4LBbLyspq+fLltbW10hxUoDrI0tJyxIgRZ86c6dGjh7q6uq2t7Z49e+jpL1++7ObmpqamZm5uvmTJkl27dhEEUVBQIP1pOjo6Ll68uLCwMC4ujlq5Z88eR0dHNTU1fX39r776Ki8vD68/efIkQRDXrl3DiwkJCQRB0C+O3bt3HzVqFH5NEMTMmTP37dtnZ2enoaHh6Oj4119/SV8wkTp06LBx48aqqqrffvuNWnn9+vUvv/xSX19fTU3N2dk5Pj6e2oSrQy9evPjtt98aGBjo6Oh88803b968KS0tHT16tJ6enpmZ2bx58z5+/EhlefHixfTp083NzVksVseOHRcvXlxTU0NtffXqVXBwsL6+vpaW1vDhwx8/fkyvl8Yf382bNwMCAtq1a2dtbY2LN3bsWEtLS3V1dUtLy3Hjxv37778CJUxKSpo8ebK+vr6mpuYXX3zx+PFjgRO/du2ap6enhoZGx44d161bx+fz8Xrhmsy7d++OGzfOxMSEzWZ36NDhm2++oZdfDGtrayMjI1y2pKQkPz8/DoejpqZmY2Pz3XffPX/+nEop8jTp/7qWlpb//PNPamoqria1tLSsrq7W09P77rvv6EcsKChgMBgbNmwQKMnHjx+NjY0DAwPpK1+9eqWurh4WFoYQ4vP5q1at6tKli7q6up6eXvfu3SMjI8Wc2tGjRysqKqZOnRoUFHT//v3Lly/Tt9bU1KxYscLOzk5NTc3AwMDHxyc9PR1v4vP5W7dudXJywgfq06fP8ePH8Sb6506d9aRJk/Br/LGeO3duypQpRkZGGhoaNTU1Dx8+nDx5cqdOnTQ0NMzNzb/44os7d+4InOPcuXM7duzIZrONjY2HDRt29+5dkiQ7deo0ePBgesrq6mpdXd0ZM2YInyxBEG/evPnjjz/wm+/t7d3o8ty9e3fIkCEaGhqGhobTpk0TfuRx/vz5AQMG6OjoaGhoeHh4XLhwQcyngOr/cuF/4/Pnz+fl5eFi41rThw8fnj59Gq9p0GWtQdp6tMvNze3Zs+fff/+9cePGv/76a/jw4bNnz16+fDlCyMjIaMSIEX/88Qd1xUEIRUdHs1gs/KuktLS0V69eZ8+eXbp06enTp4ODg9euXfvtt982riS3bt2aO3funDlzjh071r179+Dg4EuXLuFNt2/fHjRo0Nu3b//4448dO3bcvHlz9erVjTjEl19+iRCidrt27drg4OCuXbsmJiZGRkbevn3bzc3twYMHCCEvLy8mk0lVJJ4/f15dXT01NRVHi7Kysr///nvgwIHUnk+ePPnrr7+uWLEiISEBB076dZz6KjbIsGHDGAwGVdrk5GQPD49Xr17t2LHj2LFjTk5OY8aMEahDmzp1qq6u7sGDB3/66acDBw58++23w4cPd3R0PHz4cFBQ0MaNG7du3YpTvn//3sfHZ+/evWFhYSdPnpw4ceLPP//s7++Pt/L5/C+++OLAgQM//PDDkSNHevfuPWTIEOES+vv729jYHDp0aMeOHQihgoKCLl26REREnD17dv369SUlJT179qQHD4RQcHCwiorKgQMHIiIirl696u3t/erVK2praWnphAkTJk6cePz48aFDhy5atOjPP/8U+ebcunWrZ8+emZmZK1asOH369Nq1a2tqaj58+CDNG/vy5cuKigojIyOE0KNHj9zc3LZv337u3LmlS5dmZWX17duX/ptA+DTpjhw50rFjR2dn54yMjIyMjCNHjmhpaU2ZMmX//v2vX7+mkkVFRbFYrClTpghkZzKZEydOTEhIqKyspFbGxsa+f/9+8uTJCKGff/45PDx83LhxJ0+ejIuLCw4Opr9dwnbv3s1msydMmDBlyhSCIHbv3k1tqq2tHTp06MqVK0eMGHHkyJGYmBh3d/fCwkK8ddKkSSEhIT179oyLizt48OCXX37ZoGvulClTmEzmvn37Dh8+zGQynz59amBgsG7dujNnzmzbtk1VVbV379737t3Diauqqvr27fvbb79Nnjz5xIkTO3bs6Ny5c0lJCUEQs2bNSkpKwt9BbO/evZWVlSKjXUZGhrq6+rBhw/CbHxUV1bjyPHv2zMvL6++//46Kitq3b191dfXMmTPpB/rzzz99fX11dHT++OOP+Ph4fX39wYMHiwl4Yr5cuELe2dm5Y8eOuNg9evTIyMgwNTX18PDAa8zMzKR/5xuGbAOio6MRQteuXRPeNHjwYA6H8/r1a2rNzJkz1dTUXrx4QZIk/n137tw5vKm2trZ9+/ajRo3Ci999952Wlta///5L5f3ll18QQv/88w9eRAgtW7YMv05OTkYIJScn48Vly5bR33wLCws1NTVqV+/evdPX1//uu+/w4tdff62pqVleXo4XeTyevb09Qig/P1/k+eKdU+kp7969QwgNHTqUJMmXL1/irwq1tbCwkM1mjx8/Hi/27du3f//++LWNjc38+fNVVFRSU1NJkty/fz9C6P79+9RpmpiYVFZW4sXS0lIVFZW1a9dSe2YwGNSuhIn5dExMTOzs7PBrW1tbZ2fnjx8/UltHjBhhZmbG4/GoncyaNYvaimtFNm3aRK1xcnLq0aMHfo0v3PHx8dTW9evXU581fqa1fft2auvatWvpnyZ+h5cuXVrfSdXW1lZXV2tqakZGRtJP86uvvqLSXLlyBSG0atUqvOjl5YUQysrKohLY29sPHjwYv87Pz0cIRUdH48X+/fvr6emVlZXVVwA6hND06dM/fvz44cOHvLy8oUOHIoS2bdtGT8Pn8z9+/Ihv+I4dOybmNAX+dbt27erl5UVP8OjRIxUVlc2bN+PFd+/eGRgYTJ48WWTZbt++jRD6/fffqTW9evVycXHBr0eMGOHk5CTNOZIkWVBQoKKiMnbsWLzo5eWlqalJ/Vvix3g7d+4Uzoh/US1evFjkbumfO2ZhYREUFIRf44/1m2++qa9UtbW1Hz586NSp05w5c/CaFStWIISSkpKEE1dWVmpra4eEhFBr7O3tfXx86tu5pqYmVZJGl+eHH34gCCInJ4dKM2jQIOpi9ebNG319/S+++ILayuPxHB0de/XqVd8hxH+5SJL08vLq2rUrPYuFhcXw4cPr26GstOl7u/fv31+4cOGrr77S0NCo/WTYsGHv37/PzMxECA0dOtTU1BT/AyGEzp49+/TpU+on6l9//eXj49O+fXsqL76OpKamNqIwTk5OHTp0wK/V1NQ6d+5M1YOlpqb279+feginoqIyevToRhyCpM1lmJGR8e7dO6pCBiHE5XL79+9P/WQbMGDAlStX3r179++//z58+HDs2LFOTk5JSUkIofPnz3fo0KFTp05UXh8fH21tbfzaxMTE2NiYXolXW1srsepDfIEfPnx49+5dfEtN/6RKSkqon6gIoREjRlCv7ezsEEL02lc7OzuqVBcvXtTU1AwICKC24rcClxN/gvQ3edy4ccLFo+pyserq6h9++MHGxkZVVVVVVVVLS+vNmzdU5TBGf1bh7u5uYWGBfwZhpqamvXr1oha7d+9Ofxspb9++TU1NHT16NL4/k0ZUVBSTyWSxWHZ2dunp6StWrJg+fTpCqKysbNq0aVwuV1VVlclkWlhYIIQEyixwmhJ17NhxxIgRUVFR+OM7cOBARUWFwO0CxcHBwcXFhfqK5eXlXb16lfqK9erV69atW9OnTz979iz9/k+k6OhoPp9P5Z0yZcqbN2+oevvTp0+rqakJ31/iTQghkfdPUhJ4i2pra9esWWNvb89isVRVVVks1oMHD6h39fTp0507d6ZXjVC0tbUnT54cExPz5s0bhNDFixdzc3Pre+tkVZ7k5OSuXbs6OjpS6cePH0+9Tk9Pf/HiRVBQEPW94/P5Q4YMuXbtGi5kLQ3+xMV/uZpRm452FRUVtbW1W7duZdIMGzYMIYQroFRVVQMDA48cOYLrT2JiYszMzKiK9WfPnp04cYKet2vXrlTehjIwMKAvstlsfCuGyynQUqNxDTfwpbN9+/Z4nwghgUqD9u3b4/UIoYEDB9bU1Fy+fDkpKcnQ0NDZ2XngwIG4bvPChQsC31UxhW+0N2/eVFRU4NI+e/YMITRv3jz6u42v1/R3W19fn3rNYrGE17x//x6/rqioMDU1pT86NTY2VlVVxadfUVGhqqpKzyvyDRd498aPH//rr79OnTr17NmzV69evXbtmpGRkcD7YGpqKrBIveFI6rfx5cuXPB6vQU1FRo8efe3atevXr9+7d6+iogI/jebz+b6+vomJiQsWLLhw4cLVq1fxjzyBgzaiZikkJOTBgwf4t9G2bdvc3Nx69OhRX+IpU6ZkZGTcvXsXIRQdHc1ms6nfFosWLfrll18yMzOHDh1qYGAwYMCA+voR8fn8mJiY9u3bu7i4vHr16tWrVwMHDtTU1KQqM8vLy9u3b6+iIuKKV15ezmAwBD6aBhF4i8LCwpYsWTJy5MgTJ05kZWVdu3bN0dGRelfLy8vFfHazZs2qqqrC1Se//vorh8Px8/OTa3nwd4Genr6Iv3oBAQH0r9769etJknzx4kVBQQF9Pf6ZKP7L1YzadJvMdu3aMRiMwMBA4Z91VlZW+MXkyZM3bNhw8ODBMWPGHD9+PDQ0lMFg4E2Ghobdu3cXfoSGL9AyZGBggP/nKKWlpY3YD66YxY/Q8IVVoE/S06dPqTvI3r17a2lpnT9/vqCgYMCAAQRBDBgwYOPGjdeuXSssLBT5y1S2Tp48yePxcGlxqRYtWkQ9WqN06dKlETs3MDDAdYbUd7KsrKy2thYfyMDAoLa29sWLF1TAE/mG07/Pr1+//uuvv5YtW7Zw4UK8pqam5sWLFwJZBPZTWlpqY2PT0MLr6+szGIwnT55In8XIyIhq8kr5+++/b926FRMTExQUhNc8fPhQOG8jWvT179+/W7duv/76q5aW1s2bN+t7+oiNGzcuLCwsJiZm9erV+/btGzlyZLt27fAmVVXVsLCwsLCwV69enT9//scffxw8eHBRUZFwC9jz58/jH3MCvxgyMzNzc3Pt7e2NjIwuX77M5/OFA56RkRGPxystLRUZ19lstkDzH+GrtsBb9Oeff37zzTdr1qyh1jx//lxPT486nJjPzsbGZujQodu2bRs6dOjx48eXL19OXXCk16DyGBgYCP9bUq/xN2Lr1q3CTYLxT0CqLRv69GUU/+VqRm363k5DQ8PHxyc7O7t79+6udVHfGTs7u969e0dHRx84cKCmpgY/PMdGjBiBm9IK5JV5tPPy8rp48SJ1E8Pn8w8dOtTQndy6dWvNmjWWlpa4gs7NzU1dXZ1+GXry5MnFixcHDBiAF5lMZr9+/ZKSki5evIjr8T09PVVVVX/66Scc+WRwYvUrLCycN2+erq4ubt3XpUuXTp063bp1y1UIVYPaIAMGDKiurqb3VcLPdfB54Udo9MarBw8eFL9DgiBIkqR37di1axePxxNIhn+zY+np6f/++28j2u+oq6t7eXkdOnSocbUIFHwxopeZ3gJWSvXdgM6ePfvkyZOLFi0yMTH5+uuvxeyhXbt2I0eO3Lt3719//VVaWiqyslFPTy8gIGDGjBn4fkI4we7du1VUVI4ePZpMs2/fPoQQbt48dOjQ9+/fi+waiB9AbN++XWTxLC0t8cNF7OLFi9XV1WJOByFEEAT9XT158mRxcTH9cPfv37948WJ92UNCQm7fvh0UFMRgMMS3epOyEkV8eXx8fP755x96T9wDBw5Qrz08PPT09HJzc4W/eiwWi8ViCX8ZxX+5mlEbure7ePGiwPdk2LBhkZGRffv29fT0/P777y0tLauqqh4+fHjixAn6/+KUKVO+++67p0+furu70+8kVqxYkZSU5O7uPnv27C5durx//76goODUqVM7duyQbYekxYsXnzhxYsCAAYsXL1ZXV9+xYweuMRdZLUO5ceOGrq7ux48fnz59euHChX379hkbG584cQJX8enp6S1ZsuTHH3/85ptvxo0bV1FRsXz5cjU1NdwGARswYMDcuXMRQvhOTl1d3d3d/dy5c927dzc2Npa+/Kqqql5eXuJr7f/++29c9V9WVpaWlhYdHc1gMI4cOUI9mvrtt9+GDh06ePDgSZMmmZubv3jxIi8v7+bNm40I/Aihb775Ztu2bUFBQQUFBQ4ODpcvX16zZs2wYcPwmQ4ZMsTDw2Pu3LmVlZUuLi4ZGRn46yrmDdfR0enXr9+GDRsMDQ0tLS1TU1N3795N/XymXL9+ferUqV9//XVRUdHixYvNzc1xfWxDbdq0qW/fvr179164cKGNjc2zZ8+OHz/+22+/NSj229raWltbL1y4kCRJfX39EydO4LrHBnFwcDh48GBcXFzHjh3V1NQcHBzw+okTJy5atOjSpUs//fQT/pcTY8qUKXFxcTNnzuRwOPRqgy+++AJ3xMRdJiIiIiwsLOgPjLGKiopjx44NHjxYuNJv8+bNe/fuXbt27bhx46Kjo6dNm3bv3j0fHx8+n5+VlWVnZzd27FhPT8/AwMBVq1Y9e/ZsxIgRbDY7OztbQ0Nj1qxZCKHAwMAlS5YsXbrUy8srNzf3119/1dXVFX86I0aMiImJsbW17d69+40bNzZs2EC/IISGhsbFxfn5+S1cuLBXr17v3r1LTU0dMWKEj48PTjBo0CB7e/vk5OSJEyeK/6I5ODikpKScOHHCzMxMW1u7vnoOieXZs2fP8OHDV61aZWJisn//flyrjGlpaW3dujUoKOjFixcBAQHGxsbl5eW3bt0qLy+v7/eB+C9Xc5J3M5iWgHoGLgC3aczPz58yZYq5uTmTyTQyMnJ3d6eayWGvX79WV1dHohp0lZeXz54928rKislk6uvru7i4LF68uLq6Gm9FDWmTKdAkycvLi97ULS0trXfv3mw229TUdP78+biN06tXr0SeLz1isdlsMzMzX1/fyMhIqn0aZdeuXd27d2exWLq6un5+flRrUgz/3OvUqRO1BlfbhoWF0ZMhhGbMmEFfQ2+0hhMINNujo386LBbL2NjYy8trzZo1wg0Ob926NXr0aGNjYyaTaWpq2r9//x07dtB3Qm/YKdwwNSgoSFNTk1qsqKiYNm2amZmZqqqqhYXFokWL3r9/T2198eLF5MmT9fT0NDQ0Bg0ahB9oUQ0sRbZ6ffLkyahRo9q1a6etrT1kyJC///5buPHeuXPnAgMD9fT0cIPYBw8eUNmFG6oFBQVZWFjg1wJtMkmSzM3N/frrrw0MDFgsVocOHSZNmkQvP53wB0TfyaBBg7S1tdu1a/f111/jFvkCTU8FTlPgX7egoMDX1xdHWaq02KRJk1RVVZ88eSLy0HQ8Ho/L5SKhhpEbN250d3c3NDTE5xgcHFxQUCCcPSIiAiF09OhR4U24fWBCQgJJku/evVu6dGmnTp1YLJaBgUH//v3T09OpAmzevLlbt274u+Dm5nbixAm8qaamZsGCBVwuF99S5+TkCH+sAi2KX758GRwcbGxsrKGh0bdv37S0NIGv88uXL0NCQjp06MBkMo2NjYcPH47721FwD7/MzEzx71tOTo6Hhweu18X7b1x58L8B7ncbHBx87Ngx+sWKJMnU1FQ8sheTyTQ3Nx8+fPihQ4fEFEz8l6u52mQSJK2dHmgtfH19CwoK7t+/39wFaSsOHDgwYcKEK1euuLu7N24PMTExkydPvnbtmvDzM6X04cMHS0vLvn370gcBAFJydXWlD+8AZKIN1WS2amFhYc7Ozlwu98WLF/v3709KSqL3nAUyFxsbW1xc7ODgoKKikpmZuWHDhn79+jU61LUp5eXl9+7di46OfvbsGdVmB0ijsrLy77///uuvv27cuHHkyJHmLo6ygWjXOvB4vKVLl5aWlhIEYW9vv2/fvokTJzZ3oZSZtrb2wYMHV61a9ebNGzMzs0mTJq1ataq5C9U6nDx5cvLkyWZmZlFRUWI6HgBhN2/e9PHxMTAwWLZsmbwHjWyDoCYTAACA8mvTPRAAAAC0ERDtAAAAKD+IdgAAAJSfsrVS4fP5T58+1dbWbmkTGAIAAGgQkiSrqqrqG+C0oZQt2j19+hR3UwUAAKAEioqKZDI6lbJFOzymQ1FRkY6OTnOXBQAAQONVVlZyudzGjYUrTNmiHa7A1NHRgWgHAABKQFaPpaCVCgAAAOUn92gXFRVlZWWlpqbm4uKSlpYmnODy5cseHh4GBgbq6uq2trabN2+mb01ISLC3t2ez2fb29jCUDgAAgMaRb7SLi4sLDQ1dvHhxdna2p6fn0KFD8SDrdJqamjNnzrx06VJeXt5PP/30008//f7773hTRkbGmDFjAgMDb926FRgYOHr06KysLLkWGAAAgFKS78hhvXv37tGjBzUNkp2d3ciRI9euXSsmi7+/v6amJp6GccyYMZWVladPn8abhgwZ0q5du9jYWDHZKysrdXV1X79+LfK5HY/H+/jxYyNPBgClwGQyGzEdNgCKJ/563lBybKXy4cOHGzdu0AdB9/X1TU9PF5MlOzs7PT2dGn43IyNjzpw51NbBgwfjiawE1NTU1NTU4NeVlZUi90ySZGlp6atXrxp2DgAoIz09PVNTU+iTCtoUOUa758+f83g8ExMTao2JiUlpaanIxBwOp7y8vLa2Njw8fOrUqXhlaWmpNNnXrl27fPly8YXBoQ7PZwhfctBmkST59u3bsrIyhJCZmVlzFwcAxZF7DwR6aCFJsr5Ik5aWVl1dnZmZuXDhQhsbm3HjxkmffdGiRWFhYfg17p8hkIDH4+FQZ2Bg0JRzAUAJqKurI4TKysqMjY2hShO0HXKMdoaGhgwGg343VlZWRr9Xo7OyskIIOTg4PHv2LDw8HEc7U1NTabKz2Ww2my2mJPhZHZ7PHgCAvwsfP36EaAfaDjm2yWSxWC4uLklJSdSapKQkibM/kyRJPYRzc3OjZz937lxTJo+GCkwAMPgugDZIvjWZYWFhgYGBrq6ubm5uv//+e2Fh4bRp0xBCixYtKi4u3rt3L0Jo27ZtHTp0sLW1RQhdvnz5l19+mTVrFs4eEhLSr1+/9evX+/n5HTt27Pz585cvX5ZrgQEAAMgFj4fS0lBJCTIzQ56eSPH1CqScbdu2zcLCgsVi9ejRIzU1Fa8MCgry8vLCr7ds2dK1a1cNDQ0dHR1nZ+eoqCgej0dlP3ToUJcuXZhMpq2tbUJCgsTDvX79GiH0+vVr+sp3797l5ua+e/dOZmfVGixbtszR0VEBB0IIHTlyRAEHau1qamqsra0vX77cxP0kJycjhF6+fCk+2dy5c2fNmiVyU9v8RoDmlJBAcjgkQv/9cThkY6/njSb3aKdgLT/aBQUFCfzgePDggUz2LBB1qqqqnj9/3sR9WlhYIIRiY2PpK+3t7RFC0dHReLGkpOT9+/dNPFCzoD4CTU3N7t27U2ckMVfjovvWrVv79++PX+fn5yOEsrOzG7GfmpqakpISPp8vPtmzZ8+0tLQeP34svKlFfSOA8ktIIAnic6hDiCQIkiAkBjzZRjsYJ1McHg+lpKDYWJSSgng8me12yJAhJTS4hQ7lw4cPMjmKlpZWQ9ugiux6z+Vyo6OjqcXMzMzS0lJNTU1qjampqfhWQo2mgKEAoqOjS0pKbt26NWbMmMmTJ589e1Z+x9q6dSvVu0Y88f8DLBZLmt5yxsbGvr6+O3bsaEARAZA5Hg+FhCCBYUzwYmioLC+skkC0q1diIrK0RD4+aPx45OODLC1RYqJs9sxms01pGAyGt7f3zJkzw8LCDA0NBw0ahBBKTU3t1asXm802MzNbuHBhbW0tzuvt7T179uwFCxbo6+ubmpqGh4fj9ZaWlgihr776iiAI/Do8PNzJyYk6aHR0tJ2dnZqamq2tbVRUFF5ZUFBAEER8fLy3t7eamtqff/4pXNoJEyakpqYWFRXhxT179kyYMEFV9fMTX4Igjh49Su0tMTHRx8dHQ0PD0dExIyND5Dtw9+7dvn37qqmp2dvbnz9/XmAP9PLw+fwVK1ZwOBw2m+3k5HTmzBm8h5SUFIIgqOECcnJyCIIoKChACMXExOjp6R09erRz585qamqDBg2iCi8M97O2trb+8ccf9fX1z507h9dfu3Zt0KBBhoaGurq6Xl5eN2/erO99RgidOHHCxcVFTU2tY8eOy5cvpz4sups3bz58+HD48OF4Ef/EcXZ2JgjC29sbITRp0iQ80lD79u07d+6MEPrzzz9dXV21tbVNTU3Hjx+PO8kJnDs+2bNnz9rZ2WlpaeEfUtRBv/zyS/FjDwEgd2lp6MkTEetJEhUVIVGDJ8sJRDvREhNRQECdz6i4GAUEyCzgCfvjjz9UVVWvXLny22+/FRcXDxs2rGfPnrdu3dq+ffvu3bup8WVwSk1NzaysrJ9//nnFihW42eq1a9fQpzsV/Jpu586dixcvXr16dV5e3po1a5YsWfLHH39QW3/44YfZs2fn5eUNHjxYuGAmJiaDBw/G6d++fRsXFzdlyhQxJ7J48eJ58+bl5OR07tx53Lhxwpd+Pp8/cuRIDQ2NrKys33//ffHixQIJ6OWJjIzcuHHjL7/8cvv27cGDB3/55ZcPHjyQ+Ga+fft29erVf/zxx5UrVyorK8eOHSs+PY/Hi4+Pf/HiBZPJxGuqqqqCgoLS0tIyMzM7deo0bNiwqqoqJOp9Pnv27MSJE2fPnp2bm/vbb7/FxMSsXr1a+BCXLl3q3LkzNQDS1atXEULnz58vKSlJ/PRfdeHChby8vKSkpL/++gsh9OHDh5UrV966devo0aP5+fmTJk2q72R/+eWXffv2Xbp0qbCwcN68edSmXr16FRUV/fvvvxLfMQDkhfbzq8FbZUsm9aEth0ye29XW1nmeSq9q5nLJ2tomlTAoKIjBYGh+EhAQQJKkl5eXk5MTlebHH3/s0qUL9WBm27ZtWlpauPGOl5dX3759qZQ9e/b84Ycf8GtU93kSvZUKl8s9cOAAtWnlypVubm7kp6dHERER9ZXWwsJi8+bNR48etba25vP5f/zxh7OzM0mSurq61FMu6rh4b7t27cLr//nnH4RQXl6ewD5Pnz6tqqpaUlKCF3G0pu+BXp727duvXr2afr7Tp08nhVpqZGdnI4Ty8/NJksT1rpmZmXhTXl4eQigrK0v47BBCampqmpqauNuZvr6+yGeotbW12traJ06cEDhfzNPTc82aNdTivn37zMzMhHcSEhJCPbQjRT23CwoKMjExqampEc5LkiSOjlVVVQLnjk/24cOHONm2bdtMTEyoXPjrkJKSIrA3eG4HFCc5WcTFlPpLThaTFZ7byZ2877x9fHxyPtmyZQte6erqSiXIy8tzc3OjHsx4eHhUV1c/+VSm7t27UynNzMyoCq76lJeXFxUVBQcHa32yatWqR48eUQnohxZp+PDh1dXVly5d2rNnj/gbO3rx8MBUwsW7d+8el8s1NTXFi7169RJIQJWnsrLy6dOnHh4e1CYPDw8cvcRTVVWldmJra6unp1dfrs2bN+fk5CQlJTk5OW3evNnGxgavLysrmzZtWufOnXV1dXV1daurq4Wn78Bu3LixYsUK6r399ttvS0pK3r59K5Ds3bt3ampq4ovt4ODAYrGoxezsbD8/PwsLC21tbVzbKbIMGhoa1tbW+LXA/wMeNkW4MAAojqcn4nCQ8GNmgkBcLvL0VFhBlG3ucpmQ9523pqYmdVWlr6Rek3XHSCNJEtF6BFO1bXgln88XfzicYOfOnb1796ZW0gfRoB9aJFVV1cDAwGXLlmVlZUmcZZAqHi6wcPHI+geQE1kekaPHqaiooE/vDBLVnkXgEPUd0dTU1MbGxsbG5tChQ87Ozq6urrjF6aRJk8rLyyMiIiwsLNhstpubW30tR/h8/vLly/39/ekrhQOboaHhnTt3RJ/wJ/QTf/Pmja+vr6+v759//mlkZFRYWDh48GCRZRD4fyBpzQFevHiBEDIyMhJ/XADkiMFAkZEoIAARxOe2Kvj7GBGhyF53cG8ngvjBchUwlK69vX16ejp12UpPT9fW1jY3Nxefi8lk8kQ1cDIxMTE3N3/8+LENjUBDUImmTJmSmprq5+fXrl27BmUUZmtrW1hY+OzZM7wo/JSRoqOj0759e/qQAunp6XZ2dujTFZxqkZGTk0PPWFtbe/36dfz63r17r169wsMXiGFjYzNq1KhFixbhxbS0tNmzZw8bNqxr165sNvv58+dUSoH3uUePHvfu3bOpCwdjOmdn57t371KfKb6HE/l5YXfv3n3+/Pm6des8PT1tbW0l3sGL9PfffzOZzK5duzYiLwAy4++PDh9G9CsYh4MOH0Z1fyPKG9zbiYDvvIuLBRvNEgTicBRx5z19+vSIiIhZs2bNnDnz3r17y5YtCwsLE76ACrC0tLxw4YKHhwebzRaISeHh4bNnz9bR0Rk6dGhNTc3169dfvnxJDaUtDTs7u+fPn8tkrNFBgwZZW1sHBQX9/PPPVVVVuJVKffde8+fPX7ZsmbW1tZOTU3R0dE5Ozv79+xFCNjY2XC43PDx81apVDx482LhxIz0Xk8mcNWvWli1bmEzmzJkz+/TpI1xfKmzu3LmOjo7Xr193dXW1sbHZt2+fq6trZWXl/PnzcZUgJvA+L126dMSIEVwu9+uvv1ZRUbl9+/adO3forYowHx+fN2/e/PPPP926dUMIGRsbq6urnzlzhsPhqKmp6erqCqTv0KEDi8XaunXrtGnT/v7775UrV0p+Z4WkpaV5enrSCw9A8/D3R35+zTuWCtzbiYDvvBGqU9WsyDtvc3PzU6dOXb161dHRcdq0acHBwT/99JPEXBs3bkxKSuJyuc7OzgKbpk6dumvXrpiYGAcHBy8vr5iYmIbe2yGEDAwMZHLdZDAYR48era6u7tmz59SpU/Gp1fdMa/bs2XPnzp07d66Dg8OZM2eOHz/eqVMnhBCTyYyNjb17966jo+P69esFoouGhsYPP/wwfvx4Nzc3dXX1gwcPSlMwBweHgQMHLl26FCG0Z8+ely9fOjs7BwYGzp4929jYmEom8D4PHjz4r7/+SkpK6tmzZ58+fTZt2oS75AswMDDw9/fHoRohpKqqumXLlt9++619+/Z+fn7C6Y2MjGJiYg4dOmRvb79u3bpffvlFmlMQEBsb++233zYiIwCyx2Agb280bhzy9m6GYcPkPXe54omc6/b9+/f5+flWVlYSmwnQJSaikJDPzVW4XBQRoeA77zbhypUrffv2ffjwIdXUooliYmJCQ0Nb4My9d+7cGThw4MOHD7W1tRVwuJMnT86fP//27dv0zpFY474RAPw31mVxMSovR0ZGyNwcubuj9HRUUoLwL8Kysv9u3RCqcycnsChdtGs1c5e3di3gzltpHTlyREtLq1OnTg8fPgwJCfHw8JBVqGvJHBwcfv7554KCAgcHBwUc7s2bN9HR0cKhDoBGErgDwBgMEeOh4FGcKipEL3I4KDJS8bcO8E0QB995A5mrqqpasGBBUVGRoaHhwIEDBZ66KTHhUVLlZ/To0Qo7FlB+eMQN4bpAkS2tqMAmchEP1aHwVipQkwlAmwPfCNAwPB6ytBTdDblxcJO//HzxNWayrcmEVioAAADEqm/EjUZT+CCZCKIdAAAACeQ0mqUiB8mEaAcAAEACOY2poYChOmgg2gEAABALj7ghQwofJBNBtAMAACABHnFD0gTC0mqOQTIRRDsAAACS4bEuhe/wREYsA4P/+tiJXGyOQTIR9LdTYuHh4UePHhUYLhk0o4qKCjs7u6tXr1KTnjeOlIPFBAQEuLu7N2g0VADEoUbcUNRYKjImk1nyWg6ZzOYqV8L9i0XOINoIqO4so1VVVc+fP2/iPvGQj7GxsfSVeE4cajZX5eDl5YU/DiaT2bFjx4ULF75//16aXCEhIVIeYu7cuVOmTMGvBWajbZC3b98+e/ZMYrJbt27p6+uLnAmzRX0jAKgPzOaqQDweSklBsbEoJUX0kAGNMmTIkBIagQGa65tHraG0tLQM6LUHUhCeJQ4hxOVy8QTZWGZmZmlpqcQp8WROVm+LGHgi1ocPH/7888/btm0LDw+X4c7fvXu3e/fuqVOnSpNY/Mmqq6vTR6muT/fu3S0tLalxqAFo4yDa1S8xEVlaIh8fNH488vFBlpYoMVEmO2az2aY0DAbD29t75syZYWFhhoaGgwYNQgilpqb26tWLzWabmZktXLiwtrYW5/X29p49e/aCBQv09fVNTU2pKzKuHPvqq68IgsCvw8PDnZycqINGR0fb2dmpqanZ2tpGRUXhlQUFBQRBxMfHe3t7q6mp/fnnn8KlnTBhQmpqalFREV7cs2fPhAkT6KMvbtq0ycHBQVNTk8vlTp8+vbq6Gq+fMmVK9+7da2pqEEIfP350cXGZMGGC8P6rqqomTJigqalpZma2efNmb2/v0NBQ6qRWrVo1adIkXV1dPJZ/QkICnnDO0tKSPt4YQRBHjx6lFvX09GJiYqgTPHjwoLu7u5qaWteuXVNSUur7XDQ0NExNTTt06DBq1KhBgwadO3cOr6+oqBg3bhyHw9HQ0HBwcIiNjcXrJ02alJqaGhkZSRAEQRAFBQUIodzc3GHDhmlpaZmYmAQGBlIT450+fVpVVdXNzQ2XysfHByHUrl07giAmTZqEEBL+H6jvjY2JidHT08Ov8ae8b98+S0tLXV3dsWPHVlVVUWf05ZdfUqUFoMHE/9wX2Cp+sSWQyR1iyyGzmsyEBJIgSIQ+/xEESRBkQkITSxgUFOTn5yew0svLS0tLa/78+Xfv3s3Ly3vy5ImGhsb06dPz8vKOHDliaGi4bNkyKqWOjk54ePj9+/f/+OMPgiDOnTtHkiSe7TM6OrqkpKSsrIwkyWXLljk6OuJcv//+u5mZWUJCwuPHjxMSEvT19WNiYkiSzM/PRwhZWlriTcXFxQIFs7Cw2Lx585dffrly5UqSJN+8eaOjo5Odna2rq0vVZG7evPnixYuPHz++cOFCly5dvv/+e7y+qqqqY8eOoaGhJEn+8MMPHTp0ePXqlfAbMnXqVAsLi/Pnz9+5c+err77S1tam6gYtLCx0dHQ2bNjw4MGDBw8eXL9+XUVFZcWKFffu3YuOjlZXV6fKgOrW4lLFwyfI4XAOHz6cm5s7depUbW1tkRW89DrJnJwcExOT3r1748UnT55s2LAhOzv70aNHW7ZsYTAYmZmZJEm+evXKzc0N3xGWlJTU1tY+ffrU0NBw0aJFeXl5N2/eHDRokI+PD95JSEjIkCFD8Ova2tqEhASE0L1790pKSvDbIvA/IOaNjY6O1tXVxa+XLVumpaXl7+9/586dS5cumZqa/vjjj9RJnTp1is1mC1fJQk0mkCwhgeRwPl8AOZw6Vz+BrQYGpIFBvYsCeaUm25pMiHai1NbW+SDpAY/LJWtrm1LCoKAgBoOh+UlAQABJkl5eXk5OTlSaH3/8sUuXLnw+Hy9u27ZNS0uLx+PhlH379qVS9uzZ84cffsCvBa749GjH5XIPHDhAbVq5cqWbmxv5KRhERETUV1oc7Y4ePWptbc3n8//44w9nZ2eSFk4ExMfHGxgYUIvp6elMJnPJkiWqqqqpqanC6SsrK5lM5qFDh/Diq1evNDQ06NFu5MiRVOLx48cPGjSIWpw/f769vb3IcxeIduvWrcPrP378yOFw1q9fL1wSLy8vJpOpqamJZxVXUVE5fPiwyPdk2LBhc+fOpXLRn9stWbLE19eXWsQ3xPfu3SNJ0s/Pj3poR4p6bifwPyCA/sYKRDsNDY3KykrqPaGCNEmSt27dQggVFBQI7A2iHZBA/M994a3i/xp7qwDP7eSvvkHhZDS2m4+PT84nW7ZswStdXV2pBHl5eW5ubtR03h4eHtXV1U8+Fal79+5USjMzM3xXJ0Z5eXlRUVFwcLDWJ6tWrXr06BGVgH5okYYPH15dXX3p0qU9e/ZMmTJFYGtycvKgQYPMzc21tbW/+eabioqKN2/e4E1ubm7z5s1buXLl3Llz+/XrJ7znx48ff/z4kZpYXFdXt0uXLvQEAm+Lh4cHtejh4fHgwQOeFJUkuP4QIaSqqurq6pqXlycy2YQJE3JycjIyMkaPHj1lypRRo0bh9Tweb/Xq1d27dzcwMNDS0jp37lxhYaHIPdy4cSM5OZl6n21tbRFC+K1+9+6dxCGYBT4IMW8snaWlJTVhnsD/A5599+3bt+KPC0AdPB4KCRGc7gAvhoaiDx9EbBWPytusVZrQA0EU8aO3NXlsN01NTRsbG+GV1GuSJAlaR06SJBFC1Bomk0ltIgiCz+eLPxxOsHPnzt69e1MrGbQWwBKbnKiqqgYGBi5btiwrK+vIkSP0Tf/++++wYcOmTZu2cuVKfX39y5cvBwcHU61d+Hz+lStXGAzGgwcPRO5Z4NSoNSLLJvJtwQiizmweIpvb0BOLXK+rq4s/lz///LNr1667d+8ODg5GCG3cuHHz5s0RERH4KVpoaGh9rUj4fP4XX3yxfv16+kozMzOEkKGh4cuXL8WUCtU9WfFvLJ2Y/4cXL14ghIyMjMQfF4A6xP/cj4pqzAjR1K1C802iBvd2oogfvU3+Y7vZ29unp6dTl+/09HRtbW1zc3PxuZhMpsgbHRMTE3Nz88ePH9vQCDQElWjKlCmpqal+fn7t2rWjr79+/Xptbe3GjRv79OnTuXPnp0+f0rdu2LAhLy8vNTX17Nmz9IadFGtrayaTefXqVbxYWVlZX1xECNnb21++fJlaTE9P79y5Mw7bRkZGJZ9+hTx48EDgbiYzMxO/qK2tvXHjBr7lEoPJZP74448//fQT3k9aWpqfn9/EiRMdHR07duxILyGLxaK/5z169Pjnn38sLS3pbzWOYc7Ozrm5ufSMCCExN6bi31gp/f333xwOx9DQsBF5Qdsl/gc9rVpIxnuWM4h2ouBB4YTvABQ1ttv06dOLiopmzZp19+7dY8eOLVu2LCwsTEVFwodlaWl54cKF0tJS4XuI8PDwtWvXRkZG3r9//86dO9HR0Zs2bWpQkezs7J4/fy4csaytrWtra7du3fr48eN9+/bt2LGD2pSTk7N06dLdu3d7eHhERkaGhIQ8fvxYILu2tnZQUND8+fOTk5P/+eefKVOmqKio1HfvNXfu3AsXLqxcuRK30Pn111/nzZuHN/Xv3//XX3+9efPm9evXp02bRr/dQQht27btyJEjd+/enTFjxsuXL4UrY4WNHz+eIAjceNXGxiYpKSk9PT0vL++7774rLS2lkllaWmZlZRUUFDx//pzP58+YMePFixfjxo27evXq48ePz507N2XKFBzSBg8e/M8//1AfjYWFBUEQf/31V3l5OdXYUso3VnppaWm+vr6NyAjaNPE/6K2t5bVnOYNoJwoeFA6hOgFPgWO7mZubnzp16urVq46OjtOmTQsODv7pp58k5tq4cWNSUhKXy3V2dhbYNHXq1F27dsXExDg4OHh5ecXExDT03g4hZGBggJ8D0Tk5OW3atGn9+vXdunXbv3//2rVr8fr3799PmDBh0qRJX3zxBUIoODh44MCBgYGBwnczmzZtcnNzGzFixMCBAz08PHA3CZEF6NGjR3x8/MGDB7t167Z06dIVK1bgtvv43Llcbr9+/caPHz9v3jwNDQ16xnXr1q1fv97R0TEtLe3YsWPS3OuwWKyZM2f+/PPP1dXVS5Ys6dGjx+DBg729vU1NTUeOHEklmzdvHoPBsLe3NzIyKiwsbN++/ZUrV3g83uDBg7t16xYSEqKrq4t/pjg4OLi6usbHx+OM5ubmy5cvX7hwoYmJycyZM4ULUN8bK733798fOXIE99wAoAHE/9yfPl30VvGaYxhoQTJp69JyyHIsFYEmtlxu07sfAPGqq6t1dXV37dolqx3iNpnZ2dmy2mFTnDx50s7ODretVYBff/2V3oSVDtpkAglwq0t6w0vhNpnSN8uENpktnb8/KihAycnowAGUnIzy8xU/jGlbkJ2dHRsb++jRo5s3b+Lu535+fs1dKLkYNmzYd999V1xcrJjDMZnMrVu3KuZYQNngMaDpbQXoQzkLb22Rw0ALgDaZYjEYzdiCqO345Zdf7t27x2KxXFxc0tLSlLhVRUhIiMKO9b///U9hxwJKiBoDWuRQzsJbUcsbBrquOu22lUBlZaWuru7r1691dHSole/fv8/Pz7eyspLY4QmAtgC+EaBVEHk9bzSoyQQAAKD82lBNppLdxQLQaPBdADLA47W0ukrx2sS9He59BeMnAYDh74JAr0QAGkBuU8TIT5u4t2MwGHp6enj8QA0Njfo6LwOg9EiSfPv2bVlZmZ6eHqPF/xgHLVRiIgoIqDNUZnExCghoCQ0vxWgTrVQQQiRJlpaWvnr1qpnKBUALoqenZ2pqCj/7QGPweMjSUsRQmQSBOByUny/DKk3ZtlJpE/d2CCGCIMzMzIyNjcWPFwyA0mMymXBXBxpP4hQxLbXXVluJdhiDwYDvOQAANJ6cp4iRnzbRSgUAAIBsNPcUMY0G0Q4AAIDUmnuKmEaDaAcAAEBqzT1FTKNBtAMAANAQ4seMbqnaVisVAAAAMiB+zOgWSe73dlFRUXjwWTy8vXCCxMTEQYMGGRkZ6ejouLm5nT17ltoUExND1PX+/Xt5FxgAAIBkeIqYceOQt3fLD3VI3vd2cXFxoaGhUVFRHh4ev/3229ChQ3Nzczt06EBPc+nSpUGDBq1Zs0ZPTy86OvqLL77IysqiZt/W0dG5d+8elRiGbAcAtGniR6cU3iomPbXJ2BghhMrKkJkZcndH6emouBiVlyMjI2Ru3ipm85GKTOaErU+vXr2mTZtGLdra2i5cuFB8Fnt7++XLl+PX0dHRurq6DTqibOe6BQCAFiQhgeRwPs8JzuHUmRBceOv8+fWmF0hM/TEYgmsMDEgDg3oXBcogU61m7vIPHz7cuHHD19eXWuPr65ueni4mC5/Pr6qq0tfXp9ZUV1dbWFhwOJwRI0ZkZ2fLr7QAANCi4dEp6eOY4NEp8XDMwlufPEEbNohOL5yYwuMJrqmoQBUV9S7Sy9CyyTHaPX/+nMfjmZiYUGtMTExKS0vFZNm4ceObN29Gjx6NF21tbWNiYo4fPx4bG6umpubh4fHgwQPhXDU1NZU0sj0LAABofjweCglBAsMa48XQUPThg4itwnCCkBCpEkuJKoNwmGxh5N5KhT7yLEmSYgaijY2NDQ8Pj4uLM8aVyAj16dNn4sSJjo6Onp6e8fHxnTt33rp1q3DGtWvX6n7C5XJlfgoAANDMxI9OGRUleqvI9E+eSJtYStQImS2bHKOdoaEhg8Gg38yVlZXRb/Xo4uLigoOD4+PjBw4cKDKBiopKz549Rd7bLVq06PUnRUVFMik8AAC0IOLHn3z0SFHlqF8LHiETkzba1dbWnj9//rfffquqqkIIPX36tLq6WnwWFovl4uKSlJRErUlKSnJ3dxdOGRsbO2nSpAMHDgwfPry+vZEkmZOTYyZqEDY2m61DI+UZAQBAqyF+/Elra0WVo34teITM/0jTlKWgoMDW1lZDQ4PBYDx69IgkyZCQkO+++05ixoMHDzKZzN27d+fm5oaGhmpqahYUFJAkuXDhwsDAQJzmwIEDqqqq27ZtK/nk1atXeFN4ePiZM2cePXqUnZ09efJkVVXVrKws8UeENpkAACVUW0tyOCRBCDaYJAiSyyVrakRvFf4jCJLDkTaxlH+4DLW1Mj9p2V7PpYp2fn5+EydOrKmp0dLSwtEuJSXFxsZGmrzbtm2zsLBgsVg9evRITU3FK4OCgry8vPBrLy8vgQAcFBSEN4WGhnbo0IHFYhkZGeH2nBIPB9EOAKCcEhJIgqgTpfAi7gAgvFVkWMLppUksfaijyiBrzRDtDAwM7t69S5IkFe3y8/PV1dVlUgLZgmgHAFBaAp3kuFxx/e24XMH+dvT0supvJ1AGmZLt9VyqsVT4fD6vbuvSJ0+eaGtry6AiFQAAgJTEj04pcuvataLT0xO3jbFUCFKKXhdjxozR1dX9/ffftbW1b9++bWRk5Ofn16FDh+joaAUUsUEqKyt1dXVfv34NzVUAAKBVk+31XKpo9/TpUx8fHwaD8eDBA1dX1wcPHhgaGl66dInqGNdyQLQDALQs4ke2lNN+ZHXQZiXb67lUNZnt27fPyck5ePDgjRs3+Hx+cHDwhAkT1NXVm354AABQZomJKCTkc29uDgdFRjZmHrgG7UdWB1UuUt3bXbp0yd3dXVX1c2isra1NT0/v16+fPMvWGHBvBwBoKfBwlPRrLB5MqqETnzZoP7I6aAvQDDWZDAajpKSEXm9ZUVFhbGzMa3kDo0G0AwC0CDwesrQUMUYXQSAOB+XnS1u72KD9yOqgLYNsr+dSjaVCCo1vWVFRoamp2fTDAwCAchI/sqX0o0o2aD+yOqgykvDczt/fHyFEEMSkSZPYbDZeyePxbt++LXIMMAAAAAhJGjdS+lElG7QfWR1UGUmIdrq6ugghkiS1tbWpZiksFqtPnz7ffvut3EsHAACtlPhxI6UfVbJB+5HVQZWRVM/tli9fPm/evFZRdQnP7QAALQJ+hFZcLDiTXOOe20m5H1kdtGVohud2y5YtaxWhDgAAWgoGA0VGIvSpSSSGX0dENCDqNGg/sjqoMpJ2xp/Dhw+PHj26T58+PWjkWjIAAGjd/P3R4cPI3PzzGg6nMT0BGrQfWR1U6UhVk7lly5bFixcHBQXt3Llz8uTJjx49unbt2owZM1avXq2AIjYI1GQCAFoWGEulsZqhv52tre2yZcvGjRunra1969atjh07Ll269MWLF7/++mvTSyBbEO0AAEA5NMNzu8LCQtzfQF1dHc9dHhgYGBsb2/TDAwAAAAog1TiZpqamFRUVFhYWFhYWmZmZjo6O+fn50twUAgBAK1NfHaDEukHhBGKyCGxCtDl08Jw7ArkaXSpAkWYSvODg4PDwcJIkt2/frq6uPnDgQD09vSlTpshkhj3ZgtlcAQCNJzDHKYfzeWZwkevFZBSYSZWeRSCxwPyo9PlUca5Gl6qVk+31XKrndnw+n8/n41Gh4+PjL1++bGNjM23aNBaLJe9g3FDw3A4A0Ej1jac8bx765Rdx4ywLZxRGZUFIcmJ6LuGUUpaq9WuGVioiFRcXm9MbubYMEO0AAI1R33jKCP1XJymA6q+NUL0ZhbPga6Y0iSUSXyqlqNJshlYqAkpLS2fNmmVjY9P0wwMAQItQ33jKCIkIKog2zrKYjMJZnjyRTaiTWCogREK0e/Xq1YQJE4yMjNq3b79lyxY+n7906dKOHTtmZmbu2bNHMUUEAAC5a9yIySUlLXGo5RZYpBZAQpvMH3/88dKlS0FBQWfOnJkzZ86ZM2fev39/+vRpLy8vxZQPAAAUoXEjJrfMcZZbZqmam4Rod/Lkyejo6IEDB06fPt3GxqZz584REREKKRgAACiQpyficESMp4wQYjAQny96nGXceaC+jAKo53bSJJZIYqlAXRJqMp8+fWpvb48Q6tixo5qa2tSpUxVSKgAAUKz6xlMmCBQWJmI9+jTOssiMwvDWyEipEgvkakSpgBAJ0Y7P5zOZTPyawWDATAgAAKVV33jKP/8sYZxl4YxcLpo/H3E4IrIIJzYwQAYGnxfpsYrDQQkJKCGhMaUCdUnogaCiojJ06FA8a/mJEyf69+9PD3iJiYlyL2ADQQ8EAECTwFgqLYZC+9tNnjxZzNbo6Oiml0C2INoBAIBykO31XEIrlRYYzwAAbZ3M575pxH2bmFzS39K14fu2ZiCT8cdaDhgnEwAl16DBIaVJ3IgxMBs3dqWs9tNmyPZ6DtEOANB6JCSQBPE5BiBEEgRJEKIjgTSJJaYRmYC+SM81f369e5PVftqSZhgVuhWB53YAKK36hrIUOTikNIklpkFSj4GJ1Td2ZUOHx2wDY2BKo/nHyQQAgGZQ34iUIgeHlCaxxDTSj4GJ1Td2ZUOHx4QxMOVAqtlcAQCg+Ykf/lFgqzSJG7TDFqJllqo1kDba3b9/PyUlpaysjM/nUyuXLl0qn1IBAIAQ8cM/CmyVJnGDdthCtMxStQZSPbfbuXPn999/b2hoaGpqSnwaqIYgiJs3b8q5eA0Gz+0AUFr4MZvwIJNintuJTywxDUKiE9SnvrErGzo8ppgxMOG5XWNJ9dxu1apVq1evLi0tzcnJyf6kBYY6AIAyq28oSyRqcEhpEktMIyaB8EoxY1eKHB4TxsBUMGkabmpraz969EgmbUDlDXogAKDkBDqicbkN6G8nMrHENCIT1JdLzN5ktZ82oxl6IAQHB/fs2XPatGlyj71NBjWZACg/GEulbVDoOJnY2rVrN23aNHz4cAcHB2pKBITQ7Nmzm14C2YJoBwAAyqEZop2VlZWInATx+PHjppdAtiDaAdDM5H1HIpN7NZFp2vy9VEsj4+u5TOpDWw54bgdAc5L36I4yGfdSZJr582FcypamOUcOw4kJekuhFgbu7QBoNomJKCCAJEnqAkHii4WsphhNTEQBAXXa5eNrEX3/jUsjTDgXULjmGTls7969Dg4O6urq6urq3bt337dvX9OPDQBQHjweCgmhhzqEn5SQCIWGih4Kq+H7FwxReJHaf6PTCBPIBVo/qaLdpk2bvv/++2HDhsXHx8fFxQ0ZMmTatGmbN2+Wd+EAAK1GWhp68kS42odAMhrdUSbjXopJIz4XaP2kGjls69at27dv/+abb/Cin59f165dw8PD58yZI8+yAQBaDX5xiZjfzuK3SkVW4142dJxJGJdSWUj1H1hSUuLu7k5f4+7uXgL/BACAT26Xixu/UfxWqchq3MuGjjMJ41IqC6minY2NTXx8PH1NXFxcp06d5FMkAEDrc9fIswhx+EiwLpOPiELEvWvk2dQDeHoiDgcJN5EjCMTlIk/PpqYRRs8FWj+pot3y5cuXLl06ZMiQlStXrlq1asiQIcuXL1+xYoU0eaOioqysrNTU1FxcXNJE1YAnJiYOGjTIyMhIR0fHzc3t7Nmz9K0JCQn29vZsNtve3v7IkSPSHBEAoHim5owQFIkQogc8/DoURZiaN7nvmkzGvawvjTAYl1L5SNlT4fr16xMmTOjRo4ezs/OECRNu3rwpTa6DBw8ymcydO3fm5uaGhIRoamr++++/AmlCQkLWr19/9erV+/fvL1q0iMlkUjtPT09nMBhr1qzJy8tbs2aNqqpqZmam+CNCfzsAmkVtLcnhkP4ooRB97rX2L+L6owQul6ytldFhZDLupcg0Av3t2uS4lC1Nc/a3a6jevXv36NFj+/bteNHOzm7kyJFr164Vk6Vr165jxozBM+eNGTOmsrLy9OnTeNOQIUPatWsXGxsrJjv0twOgueBubCokry9Ka4+KjVF5OTJ6isxnxXv6fy27OyQej5eSdi+lpASZMbw9Pb0ZIu6+YCwVpSDb67m4NpmVlZX4GJWVlSITiC/Bhw8fbty4sXDhQmqNr69venq6mCx8Pr+qqkpfXx8vZmRk0Jt9Dh48OCIiQjhXTU1NTU0NVWYx+wcAyI+/Pzp8GIWEMPSfvFiPFnLRp4b+YRzEiJRVN+3EY4yQEO//OhGsQhwOihTeN4OBvL0l7Eg4jTS5QKsl7rldu3btysrKEEJ6enrt6sJrxO/6+fPnPB7PxMSEWmNiYlJaWiomy8aNG9+8eTN69Gi8WFpaKk32tWvX6n7C5XLFlwoAID/+/qhgc2ICCuAgWp+24mIUEIASE5u+f3z7+EQu+wZKTty93cWLF/FtVnJycqMPQB9mjCRJMaOOxcbGhoeHHzt2zNjYuEHZFy1aFIYnP0SosrISAh4AzYbHY8wJQUhoNBOCQKGhyM9P8mQ6CNU3/Q0vJe3ityX9SLM05MlHDMF9j+Ax0qEeEtRLXLTz8vLCL6ysrLhcrkDgKSoqEr9rQ0NDBoNBvxsrKyuj36vRxcXFBQcHHzp0aODAgdRKU1NTabKz2Ww2my2+MAAARZA4molAVWFiIgoJ+ZzFwAAhhCoq/lukqikTE1FICOPJk18RQggVIU4IijyC/Kl9uxYlfuSEMMqfCGYE4BOpeiBYWVmVl5fT17x48ULkNEB0LBbLxcUlKSmJWpOUlCTQSx2LjY2dNGnSgQMHhg8fTl/v5uZGz37u3DmR2QEALYU0o5lQhOslKyo+hzr0qZpywQKBZOao+DAK+Ar9V335FUo8jALY5VC/CcSSquEmQZSVldHXFBQUaGhoSMyIeyDs3r07Nzc3NDRUU1OzoKCAJMmFCxcGBgbiNAcOHFBVVd22bVvJJ69evcKbrly5wmAw1q1bl5eXt27dOuiBAEALV3s++XMjfqG/2vPJtKS1dVr8i/ljMIRX8hDxL+KqoFoVVFuIODzhXARByrLrA2gGsr2eSxgnEz8PIwhiyZIlGhoaeCWPx8vKynJycpIYSseMGVNRUbFixYqSkpJu3bqdOnXKwsICIVRSUlJYWIjT/Pbbb7W1tTNmzJgxYwZeExQUFBMTgxByd3c/ePDgTz/9tGTJEmtr67i4uN69ezcmpAMAFCINeVojjjkqVqn76I6PiCeI8xh5en9OKvXozKJmIVBBZAdU5InSEEJc1JC6U9BWSYh22dnZCCGSJO/cucNisfBKFovl6Og4b948aQ4wffr06dOnC6zEwQxLSUkRkz0gICAgIECaAwEAml1JGWMLijyMAviIoAIeNaLK12W0liOyGGjXDJVIGAEMhvMFn0iIdrg15uTJkyMjI6G/NgBAPDMzdAT5B6DDkSiEuuV6gjihKOII8p9tVjdpk5UgM2MjhMrrT2FmBl3GASbVWCqvX7/m8XhUp2+E0IsXL1RVVVtg/IOxVABoRjwesrRExcWIIHmeKM0MlZQgszTkSRIMDgfl59OCDY+HLC3JJ8UEknQJYjAQny8w/yquGu1pkP/rNvT1PEtUXCw4QStBIA4ncWN+SBjjCTTVbJ2aYe7ysWPHHjx4kL4mPj5+7NixTT88AECZUEMukwQjFXkfRONSkTdJMJDwAMsMRua4SLLuKNJk3Z56JEEggkC4Ny0hYrDp8heMMeMYmeNEjwSdOTYiYAyjoV3ReTyUkoJiY1FKCsxbrlykacrSrl273Nxc+pq8vDx9fX2ZtJORLWiTCUCzk2ZYZtwk86u6o0iXIYNyZEAtPmFwM+Yn4D3yOXUGm/4KJdRpenlI8JC1hxJENvkU31RToOQcDgwN3ZyaYVRoTU3NzMxMBwcHas2dO3d69+799u1b+YXhxoGaTABaAolPy1JSkI8PQgipoDp1ngghavEy8uQTjMOHkb8/SrnACx/4ORk1lgqWnIy8PescMiWNgfcvUnKyiKaauPsf/YqIbxdxAYDiKW5UaErPnj1///33rVu3Umt27Njh4uLS9MMDAJSSxAGWqcaSfMRIRXWS0hcJ9N+IYyVlgskE91b3kA3q5o4Q4vFQSIjgsz/xQ56B1kWqaLd69eqBAwfeunVrwIABCKELFy5cu3bt3Llzci4bAKCVq/8WT8ommVSvOfHphbc2NH1DhzwDrY5UrVQ8PDwyMjK4XG58fPyJEydsbGxu377tCRPYAwDESExElpbIxweNH498fJClJb19iKcn4nAkzB9OKSmpNz1BIC4XCV+NGpq+ofeCoNWR6t4OIeTk5LR//365FgUAoDwSE1FAAEmSVLghi4uJgADqIRhuvRkQgAhCsP5QGL4V+/ZbtGxZnfU4mAm29vx0SxkQgCIi6uxfTPpnzyQUAPrttXZynM0VANBG8XgoJIQe6tB/fXsJgvYQ7NPsr+JGECMIxOGg58+RpaWIZBwOiogQbEIiMK2CisrnjgTSpJemANBvr1US015TRUXl2bNnJEkSBKFSF14jk1ahsgU9EABofsnixoYmk5PpaWtryeRk8sABcvlykiBIgqjTW4AgyPnz66yk/pYvF9GRICFBdOLQUDI5uQHpxRcAr4fOCfKmuFGhZTKbKwCgreEXl4hpESCwld6Uslu3OrdZHA7auBGFhYmo6iQItGsXWry4zkqR7Spx4oQE9MsvIiowRaan1FcAaKvZGkk1myv1AgAAJLpdbubUqK3+/sjPr87jsQY1lWxou0rx0zBs3oxmzYK2mspDXLS7ffu2+Mzdu3eXaWEAAMrgrpGnQf3z/tw18nSqP69AR70GNZVsaLtK8elNTBCDAW01lYe4aOfk5EQQBEmSRD3NhHkwihwAQIipOSOk/nl/Zps3oO6vQd3m5NEnr6H7BC2WuP52+fn5jx8/zs/PT0hIsLKyioqKys7Ozs7OjoqKsra2TkhIUFgpAQCtiKcnusbx/xodLkbm1MoniPM1Onyd69+gnroN6jYnjz55Dd0naLmkacrSs2fPkydP0tecPHmyR48eMmknI1vQJhOAlgC3dWSgWi+UPBYd8ELJDFTbuHaMeFfCbTVF7qpBiaVM39B9AlmR7fVcqrFU7ty5Y2VlRV9jZWWVm5srj+gLAGg16p8dB/elM+N8nvenPZfRuOGV8a7MP98lIg5HxEjNuCw1NSg8XHLiBqX390fx8cjQUKoCCL8ZMIVQSyFNSHR2dh4/fvy7d+/w4vv378ePH+/s7CyTeCtbcG8HgILUnYWHL2p2HKovnci+bg0iflcCM/WYm5PLl4s7boPSCyQ2NCTj4yWkod4MmEKoKWR7PZcq2mVlZRkbGxsaGg4YMGDAgAGGhoZGRkZZWVkyKYFsQbQDQBESEviI4NF6XPMQwUfNU7sn3ENcmtpLKdNLk7i+NNAtvYmaYX47hNDbt2///PPPu3fvkiRpb28/fvx4TU1Ned5zNhLMbweA3PF4b00s1SqeCDwI4SPivQFH41m+Intc83iiBxXDI37lC5WlQemlSVxfGoT+2yplwYCwZpjfDiGkoaHxv//9r+nHAwC0dryUNI0KEVd3FURqVBTxUtIYA7wVVhhZ9ShvdHd1MV3URT6lg27pzUWqVioIoX379vXt27d9+/b//vsvQmjz5s3Hjh2TZ8EAAC3UvRRxfarFb5U52fYob0R39cZ1MIdu6YonVbTbvn17WFjY0KFDX758iXuUt2vXLiIiQr5FAwC0SCVIXJ9q8VtlTq6zvDa9+7mUBwIKIFW027p1686dOxcvXqyq+l/Np6ur6507d+RZMABAC8Xw9ixCHDw2Ch0fEYWIy/BWaI9ruc7y2pTu5wghBgO6pbcgUkW7/Px8Z2dn+ho2m/3mzRv5FAkA0KJ5ejNWGESiT4OBYfj1KoMIT2+Ftr7As8IiVCeu1Ddrq/j0GzeitLQ6HePE7xwhlJKC4uPRt9+KSIMnSRBoBSimYEDepIp2VlZWOTk59DWnT5+2t7eXS4kAAC0bg4GG/i56YLAhv/sr/jouZfdz8ennzUNhYcjHB40fj3x8kKUlSkwUt3OEkKXlf+mXLUP6+khfX3CHcXGChxZfMCBXUvVAiI6OXrJkycaNG4ODg3ft2vXo0aO1a9fu2rVr7NixCihig0APBAAUIzERzZnNsypOM0MlJcisgOO5KZLRjNdxHq/OVEESgy49/fPnaPToOvdh+CaMikwCOz92DAUECKYnSbR8OerUSfQOsfh49PXXMjjZNkK213Np+9vt3Llz1apVRUVFCCFzc/Pw8PDg4OCmH17mINoBoDANDTAtk8x77CHUsB2C+ii6v11tbe3+/fu/+OKLb7/99vnz53w+39jYuOkHBgC0dgJz0bVSMu+xhxBMANsSSY52qqqq33//fV5eHkLIkD4wKgAAtH5y7bHXiARATqRqpdK7d+/s7Gx5FwUAABRP5j32YALYlkmqkcOmT58+d+7cJ0+euLi40IfH7N69u9wKBgAAioA7zBUXi+gtwOHU22NPfPoG7RAohlStVFRU6twCEgRBkiRBELyWN1kTtFIBADRUYiIKCEAIfY5PAm0yG5Sex0OrV6Nly+pkEd/IU/p2K8rRMkhKMr6eSzNRQkE9ZDILg2zBjD8AgEYQmIiOy5UwL0996QXWi9xhoye9a2uz5Sl6xp+qqqrMzMyPHz/26tWr5bdSgXs7AEDjNKXHHk6P7/mEr6nLl6PFi//boXAa8feRlEZnbL0U2t/u9u3bQ4cOLS0tJUlSR0fn8OHDAwcObPpR5QeiHQCgWTRlMjyJXfEanbFVk+31XEKbzIULF3bo0CEtLe369eteXl4zZ85s+iEBAED5SNMPT5o0jd45EE9Cm8zr16+fOnXK1dUVIbRnzx5jY+Pq6motLS2FlA0AAFqNpk+Gl5CAEBJdidrETn4ASby3e/78eYcOHfBrAwMDDQ2N8vJy+ZcKAABamaZPhvfrr3UGpG7ozoF4EqIdQRBVVVWVlZWVlZWvX7+mL1ZWViqmiAAA0PI1cTI8SnExCggQDHgNncYPCJMQ7UiS7Ny5c7t27dq1a6evr19dXe3s7NyuXTs9Pb127doppogAANDySTPTnsg0AnDDwdBQRO/P3NBp/IAwCc/tkpOTFVMOAEADtKk+xq0HngwvJORzixIOB0VEfO4hwOMhfX0UEoL270diHgrhtidbt6JZsz5/tn5+KDwcRUaiFy9E7xzB/4V4Mum113JA73Kg/BIS+LQ+xnyl72Pc2tTWksnJ5IEDZHIyWVv7eb1A33BDQ3LIEBH90Ol/1GcrkFdfn1y+vM7OhdMowf+FonuXty7Q3w4oucREclQAiUjqIQQfEQRCRILy9jFWCiL7hku8+uK6ynnz0C+/SOhXrpR9z5tnNtfWAqIdUGY83lsTS7WKJwLP2/mIeG/A0XimpH2MW7/6+oYjhBgMxOdLCHu4W7oAmXRab+EU2ru86aKioqysrNTU1FxcXNJE9YEsKSkZP358ly5dVFRUQkND6ZtiYmKIut6/fy/vAgPQYvFS0jSEQh1CSAWRGhVFvBToY9xC1dc3HCHE4yGSlNBKU+Tw+zLptN6myDfaxcXFhYaGLl68ODs729PTc+jQoYWFhQJpampqjIyMFi9e7OjoKLwHHR2dEho1NTW5FhiAluxeirhexOK3gmYkvvd3aCgyN2/SnqHvuTQaEO0ePnx49uzZd+/eIYSkrP/ctGlTcHDw1KlT7ezsIiIiuFzu9u3bBdJYWlpGRkZ+8803urq6wnsgCMKURvrSAqB8SpC4XsTit4JmJL73t58fKihAmzc3fs/Q91waUkW7ioqKgQMHdu7cediwYSUlJQihqVOnzp07V3yuDx8+3Lhxw9fXl1rj6+ubnp7eoPJVV1dbWFhwOJwRI0bA/OmgjWN4exYhDh8JVnvxEVGIuAxv6GPcQknsG85goFmz6u14zmA0stM69D2nkyrazZkzR1VVtbCwUENDA68ZM2bMmTNnxOd6/vw5j8czMTGh1piYmJSWlkpfOFtb25iYmOPHj8fGxqqpqXl4eDx48EA4WU1NTSWN9PsHoHXx9GasMIhECNEDHn69yiDC07t1NkVoA8T3DUcIpaSg+Hj07bci0hAECgsT3KE0ndbx640bUVoaio1FKSmin/+1IdJ0UzAxMcnJySFJUktL69GjRyRJPn78WFNTU3yu4uJihFB6ejq1ZtWqVV26dKkvvZeXV0hISH1beTyeo6PjrFmzhDctE5gkGPrbAeWVkED6o4RC9Llf1b+I648SWnvPqrZA5ASwAisNDEgDAxFp6CtxMuFPXHj/8+e37h54su1vJ2EsFezNmzfUXR32/PlzNpstPpehoSGDwaDfzJWVldFv9RpERUWlZ8+eIu/tFi1aFPbpx09lZSWXy23cIQBo+fz9EUrw7zvbz6o4zQyVlCCzAo7npkhG6+1T1Xb4+yM/vzpjnRw7JthJ7sULRJJo+XLUqVO9aRBCFRWS9//8ORo9uk5GPAJnq+6B1xRSRbt+/frt3bt35cqVCCGCIPh8/oYNG3x8fMTnYrFYLi4uSUlJX331FV6TlJTk5+fXuIKSJJmTk+Pg4CC8ic1mSwy9ACgNf3/k58dIS/OGAaJaHQYDeXv/95rHQyEhgmEM90bYtetzRzrhNAghgkChocjPT/Cjp/aPe+CJ3LnIjG2BVNFuw4YN3t7e169f//Dhw4IFC/75558XL15cuXJFYsawsLDAwEBXV1c3N7fff/+9sLBw2rRpCKFFixYVFxfv3bsXJ8vJyUEIVVdXl5eX5+TksFgse3t7hNDy5cv79OnTqVOnysrKLVu25OTkbNu2rdGnCoDSoF80QSslsZOct7dUaRq987ZGqmhnb29/+/bt7du3MxiMN2/e+Pv7z5gxw0yKZq1jxoypqKhYsWJFSUlJt27dTp06ZWFhgRAqKSmhd7xzdnbGL27cuHHgwAELC4uCggKE0KtXr/73v/+Vlpbq6uo6OztfunSpV69ejThJAABoaZo++6uYrdADTxiMHAYAAM0gJQWJeRyUnIy8vaVK0+idt3zNMHKYlZXVkiVL7t271/TjAQAAQE2b/VViRzrogSdMqmg3a9asM2fO2NnZubi4RERElLTN22AAAJCdRs/+Ks0krjD7qzCpol1YWNi1a9fu3r07YsSI7du3d+jQwdfXl2pjAgAAoBHw7K/0QTI5nM89BHg8lJKCampQeLiENMKdx6lpYw0NRWcUk5e+E4EEErO0aI3oo5eRkeHk5KSioiKTHn+yBbO5AgBaF5Gzvwp0FTc3J5cvl5CmvqlfDQ3J0FAJU8sKdzwXTqD4vuqyvZ43LNplZWWFhISYmpqqq6uPHj1aJiWQLYh2AIDWLiGBJIg6g6cQBEkQdaJLfWnmz298XiqNcALhP+HdylwzzF1+//79/fv3HzhwoKCgwMfHZ8KECf7+/tra2nK+7WwMaJMJAGjVpJmaVfz0sE2c+hWhencuZrfyINvruVT97WxtbV1dXWfMmDF27FiYdgcAAOSnKb3OkaSpX6XpsY6QVKFOYLctn1TR7u7du507d5Z3UQAAADS913lT8jZiz62lkb5U0Q5CHQAAKIY0U7M2boJWOU392lpmixX33E5fX//+/fuGhobt2rUjRE0y+OLFC3mWrTHguR0AoFXDz9WKiwXHdBZ+9iacBiHEYCA+vzF5BZ7bidy5AOV5brd582bcFGXz5s0iox0ALR/vA+9OVNrbRyUa1mYO0z0ZrDbZsRa0HrhjeEAAIojP8UZkr3ORacLC0C+/NDgvQogk0dSp4hIII0m0cWPr6asuk5adLQf0QAB0GfMTihmfuwgVMzgZ81vVdJagrRI59auUaRqRV2KnPeG5YRXQ664ZeiAwGIySkhJjY2NqTUVFhbGxMa/ldaaHmkxAyVyQ2GtDAEIkNWIQHxEIoavzD/f5uU1OZwlaFR6vztSvIm+h6ksjZd7Vq9GyZXVW4htBPOSK8E4OH0Zff11vepmT7fVcqminoqJSWlpKj3ZPnz61trZ+9+5d00sgWxDtAMb7wHumYWnKeyIwOB4fESUMjunbfKjSBG2cNB37mpK+6RTa327Lli0IIYIgdu3apaWlhVfyeLxLly7Z2to2/fAAyMmdqDQnnohOQyqINOcV5USlOYV6K7xQALQgDZ3xtbXPECsh2m3evBkhRJLkjh07GJ8CN4vFsrS03LFjh9xLB0BjvX0krhOQ+K0AtAUN7XjX2meIlRDt8vPzEUI+Pj6JiYnt2rVTSJEAkAENa3GdgMRvBaAtaGjHO5l31FMwmLscKKdPz+2KVVCd/3B4bgcAJk3HvqakbzrFPbcLCwtbuXKlpqZmWFiYyASbNm1qegkAkAcGi1EYFmm6IYCPCCrg4TaZRWER5hDqQJsnpuPdqFEoLU2wMWdD07c04u7tfHx8jhw5oqen5+PjIyInQVy8eFGeZWsMuLcDdJkLEjtsCmn/qblKMYNbFBYB3Q8AoCQmopCQz81P6FMocDgoMlKwa0FD0zdFM/RAaEUg2gEBMJYKAOLhfnXHjqGIiDrr6+tL19D0jdbM0a6ysvLixYu2trYtswcCRDsAAGioltn3TrbXcxXJSRAaPXr0r7/+ihB69+6dq6vr6NGjHRwcEhISmn54AAAAzU6aSe+akr4lkCraXbp0ydPTEyF05MgRkiRfvXq1ZcuWVatWyblsAAAAFKEt9L2TKtq9fv1aX18fIXTmzJlRo0ZpaGgMHz78wYMHci4bAAAARWgLfe+kinZcLjcjI+PNmzdnzpzx9fVFCL18+VJNTU3OZQMAAKAInp6Iw0HCE7sRBOJykadnU9O3BFJFu9DQ0AkTJnA4nPbt23t7eyOELl265ODgIN+iAQAAUAjclw6hOgFMYGK8pqRvCaSKdtOnT8/IyNizZ8/ly5dVVFQQQh07doTndgAAoDT8/dHhw8jc/POadu1QeDjy8xOd3s8PhYcj+oCShoYoJATp66OWNxccQg3tgYATt+R5zKEHAgAANBqe9C4yEr148d8aafqYa2khFRVUWSkuSyM0Qw8EhNDevXsdHBzU1dXV1dW7d+++b9++ph8bAABAi3LsGAoP/xzqEELFxSggACUmfl6TmIgCAur0QKiu/hzqRGZpCaSKdps2bfr++++HDRsWHx8fFxc3ZMiQadOm4cmAAAAAKAceD4WECA76jBdDQ/+rnxSZRoBAlhZCqppMKyur5cuXf/PNN9SaP/74Izw8HM8H1KJATSYAADROSgoSNSjyf5KTkbe3hDQiszRaM9RklpSUuLu709e4u7uXtMwOhAAAABpFmj7jDbrwt6goIVW0s7GxiY+Pp6+Ji4vr1KmTfIoEAACgGUjTZ7xBPcdbVDdzCXOXY8uXLx8zZsylS5c8PDwIgrh8+fKFCxcE4h8AAIBWDfcZr2++VtxnvL40AuhZWgip7u1GjRp19epVQ0PDo0ePJiYmGhoaXr169auvvpJ34UDT8T7wciJS0mfF5kSk8D60pEfGAIAWpr4+4ySJpk5F8fEoJQUhJCKNAIEsLaStiuRWKlVVVZmZmR8/fuzVq5ehoaFiitVo0EqFTmAu06cMTmFYJMxlCgAQQ6AvnYEBQghVVPy3iPvSISTY3+7tW8Tn/7eoooI0NFB1dZ0sjeh+p9D57W7fvj106NDS0lKSJHV0dA4fPjxw4MCmH1V+INpRMhck9toQgBBJ3b/zEYEQujr/MAQ8AIAYeL7WkhL04AEKD69TaUlN2ernV28aAY2e5VWh0W7YsGEvX77cuHGjmpra8uXL7927d/fu3aYfVX4g2mG8D7xnGpamvCcCVdV8RJQwOKZv82EKbwCAeNJM2VpfGjFZpKfQHgjXr1/funWru7t7jx499uzZ8+DBg2rq7hS0YHei0toLhTqEkAoizXlFd6Ja5GSLAICWRJopW+tLIyZLc5EQ7Z4/f96hQwf82sDAQENDo7y8XP6lAk319pG4fi7itwIAAFK67ncSeiAQBFFVVYWnsiNJEi9WfhoQrY3XFrZkGtbi+rmI3woAAEjput9JeG6noqJCn/EABzzqBa+FNCylged22KfndsUqqM7nC8/tAABSws/k6ut+R39uJ2X3u+Z9bifh3i45ObnpxwCKx2AxCsMiTTcE8BFBBTzcJrMoLMIcQh0AQBLc/S4g4L/+cxjVl+7gQVRejoyM0LffovDwOmkE4E1TpqDwcIQQ8vZG3t7NMONrw+a3a/ng3o5OoL9dMYNbFBYB3Q8AANIT3/1O5Erh7ncsFnr/vk7633+X3CFBoT0QWh2IdgJ4H3h3otLePirRsDZzmO4JFZgAgIYS0/2Obvly1KmT5O53lIQECQEPop04EO0AAEAexHetw0/mHj5E1tZS9UlACHE4qKBAXJVm88xd3mhRUVFWVlZqamouLi5ponpblJSUjB8/vkuXLioqKqGhoQJbExIS7O3t2Wy2vb39kSNH5F1aAAAAIonvWod71EVFSRvqEEJPnii0B558o11cXFxoaOjixYuzs7M9PT2HDh1aWFgokKampsbIyGjx4sWOjo4CmzIyMsaMGRMYGHjr1q3AwMDRo0dnZWXJtcAAAABEkqa33KNHst+nrDSsJrOoqIggCA6HI2X63r179+jRY/v27XjRzs5u5MiRa9euFZnY29vbyckpIiKCWjNmzJjKysrTp0/jxSFDhrRr1y42NlbMEaEmEwAA5EGaWcs3b0Zz5jRgn+InN2+Gmsza2tolS5bo6upaWlpaWFjo6ur+9NNPHz9+FJ/rw4cPN27c8PX1pdb4+vqmp6dLX7iMjAx69sGDB4vMXlNTU0kj/f4BAABICc9sVx+CQFwumj4dcTjiJgOiU/AEeFJFu5kzZ/7+++8///xzdnZ2dnb2zz//vHv37lmzZonP9fz5cx6PZ2JiQq0xMTEpLS2VvnClpaXSZF+7dq3uJ1wuV/r9AwAAkBLuficmkkVEIBZL8ux3lMhIhfa6kyraxcbGxsTEfPfdd927d+/evft33323Z88e8TWKFJFDsUhPmuyLFi16/UlRUVGD9g8AAEBK/v7o8GERd3hc7ucJfXAac/PPWw0MkJZWnfQGBpK7H8ichLFUMDU1NUtLS/oaS0tLFoslPpehoSGDwaDfjZWVldHv1SQyNTWVJjubzWaz2dLvFgAAQOP4+/83s11x8X9jqZibI0/POndpVJqSEmRm9l91ZUrKf1OfN9dYKlJFuxkzZqxcuTI6OhoHlZqamtWrV8+cOVN8LhaL5eLikpSU9NVXX+E1SUlJfn5+0hfOzc0tKSlpzqeHnufOnXN3d5c+OwAAAJljMMQ1LakvzYABaMAAeRVJGlJFu+zs7AsXLnA4HNxJ4NatWx8+fBgwYID/pxvRxMREkRnDwsICAwNdXV3d3Nx+//33wsLCadOmIYQWLVpUXFy8d+9enCwnJwchVF1dXV5enpOTw2Kx7O3tEUIhISH9+vVbv369n5/fsWPHzp8/f/ny5aaeMQAAgLZHqminp6c3atQoalH6liBjxoypqKhYsWJFSUlJt27dTp06ZWFhgRAqKSmhd7xzdnbGL27cuHHgwAELC4uCggKEkLu7+8GDB3/66aclS5ZYW1vHxcX17t1bykMDAAAAFBg5DAAAQEvUykYOAwAAAJqdVDWZVlZWIpv+P378WNblAQAAAGRPqmhHH6z548eP2dnZZ86cmT9/vrwKBQAAAMiUVNEuJCREYM22bduuX78uh/IAAAAAstfI53ZDhw5NSEiQbVEAAAAAOWlktDt8+LC+vr5siwIAAADIiVQ1mc7OzlQrFZIkS0tLy8vLo6Ki5FkwAAAAQGakinYjR46kXquoqBgZGXl7e9va2sqrUAAAAIBMQe9yAAAALZFsr+dS3dshhHg83tGjR/Py8giCsLe3//LLLxmKH8IaAAAAaBSpot3Dhw+HDRtWXFzcpUsXkiTv37/P5XJPnjxpbW0t7/IBAAAATSdVm8zZs2dbW1sXFRXdvHkzOzu7sLDQyspq9uzZ8i4cAAAAIBNS3dulpqZmZmZSXQ4MDAzWrVvn4eEhz4IBAAAAMiPVvR2bza6qqqKvqa6uljh3OQAAANBCSBXtRowY8b///S8rK4skSZIkMzMzp02b9uWXX8q7cAAAAIBMSBXttmzZYm1t7ebmpqampqam5uHhYWNjExkZKe/CAQAAADIh+bkdSZKvX7+OjY19+vRpXl4eSZL29vY2NjYKKBwAAAAgE1JFu06dOv3zzz+dOnWCIAcAAKA1klyTqaKi0qlTp4qKCgWUBgAAAJAHqZ7b/fzzz/Pnz//777/lXRoAAABAHqQaJ7Ndu3Zv376tra1lsVjq6urU+hcvXsizbI0B42QCAIByaIZxMiMiIpp+JAAAAKC5SBXtgoKC5F0OAAAAQH6knQMBIfTPP//weDz8msFgdO3aVT5FAgAAAGRMQiuVtLS0nj174td9+vRxdnZ2cnJycnLq3r37+fPn5V88AAAAQAYkRLuoqKjAwEBqMTk5OT8///HjxyEhIdu3b5dz2QAAAADZkBDtrl271qtXL2qRw+FYWFhYWloGBgZmZGTIuWwAAACAbEiIdsXFxWZmZvj1H3/8YWpqil/r6+tDf3MAAACthYRop62tnZ+fj1/7+/traGjg1/n5+dChDQAAQGshIdr17t177969wutjYmJ69+4tnyIBAAAAMiahB0JYWNjAgQMNDAzmz59vbGyMECorK1u/fv2ff/557tw5hZQQAAAAaCrJI4dFRUXNmTOntrZWR0eHIIjXr1+rqqpu3Lhx5syZiilig8DIYQAAoBxkez2XapzMoqKiw4cPP3jwACHUqVOngIAALpfb9GPLA0Q7AABQDs0Q7VoRiHYAAKAcZHs9l2rGHwAAAKBVg2gHAABA+UG0AwAAoPwkRzsej5eamvry5UsFlAYAAACQB8nRjsFgDB48+NWrV/IvDAAAACAXUtVkOjg4PH78WN5FAQAAAOREqmi3evXqefPm/fXXXyUlJZU08i4cAAAAIBNS9bdTUfkvKBIEgV+QJEkQBDWVecsB/e0AAEA5yPZ6LmGcTCw5ObnpRwIAAACai1TRzsvLS97lAAAAAORH2v52aWlpEydOdHd3Ly4uRgjt27fv8uXL8iwYAAAAIDNSRbuEhITBgwerq6vfvHmzpqYGIVRVVbVmzRo5lw0AAACQDami3apVq3bs2LFz504mk4nXuLu737x5U5q8UVFRVlZWampqLi4uaWlpItOkpqa6uLioqal17Nhxx44d1PqYmBiirvfv30tzUAAAAIBOqmh37969fv360dfo6OhI0988Li4uNDR08eLF2dnZnp6eQ4cOLSwsFEiTn58/bNgwT0/P7OzsH3/8cfbs2QkJCfQDldCoqalJU2AAAACATqpoZ2Zm9vDhQ/qay5cvd+zYUWLGTZs2BQcHT5061c7OLiIigsvlbt++XSDNjh07OnToEBERYWdnN3Xq1ClTpvzyyy/UVoIgTGmkKS0AAAAgQKpo991334WEhGRlZREE8fTp0/3798+bN2/69Onic3348OHGjRu+vr7UGl9f3/T0dIFkGRkZ9DSDBw++fv36x48f8WJ1dbWFhQWHwxkxYkR2drbIA9XU1ECfdwAAAGJI1QNhwYIFr1+/9vHxef/+fb9+/dhs9rx582bOnCk+1/Pnz3k8nomJCbXGxMSktLRUIFlpaalAmtra2ufPn5uZmdna2sbExDg4OFRWVkZGRnp4eNy6datTp04Ce1i7du3y5culOREAAABtk1TRDiG0evXqxYsX5+bm8vl8e3t7LS0tKTNSw6+gTyOwSExDrenTp0+fPn3weg8Pjx49emzdunXLli0C2RctWhQWFoZfV1ZWcrlcKcsGAACgjZAQ7d6+fTt//vyjR49+/Phx4MCBW7ZsMTQ0lHLXhoaGDAaDfjNXVlZGv43DTE1NBdKoqqoaGBgIJFNRUenZs+eDBw+ED8Rms9lstpSlAgAA0AZJeG63bNmymJiY4cOHjx07Nikp6fvvv5d+1ywWy8XFJSkpiVqTlJTk7u4ukMzNzY2e5ty5c66urlRXBwpJkjk5OWZmZtIXAAAAAPgPKVbHjh1jY2Px66ysLFVV1draWvFZ6A4ePMhkMnfv3p2bmxsaGqqpqVlQUECS5MKFCwMDA3Gax48fa2hozJkzJzc3d/fu3Uwm8/Dhw3hTeHj4mTNnHj16lJ2dPXnyZFVV1aysLPFHfP36NULo9evX0hcSAABACyTb67mEmsyioiJPT0/8ulevXqqqqk+fPpX+wdiYMWMqKipWrFhRUlLSrVu3U6dOWVhYIIRKSkqojndWVlanTp2aM2fOtm3b2rdvv2XLllGjRuFNr169+t///ldaWqqrq+vs7Hzp0qVevXo1PKADAABo6yTM+IMfvBkZGeFFbW3t27dvW1lZKaRsjQEz/gAAgHJQ6Iw/JElOmjSJagPy/v37adOmaWpq4sXExMSmlwAAAACQNwnRLigoiL44ceJEeRYGAAAAkAsJ0S46Olox5QAAAADkR9r57QAAAIDWC6IdAAAA5QfRDgAAgPKDaAcAAED5QbQDAACg/CDaAQAAUH4Q7QAAACg/iHYAAACUH0Q7AAAAyg+iHQAAAOUH0Q4AAIDyg2gHAABA+UG0AwAAoPwg2gEAAFB+EO0AAAAoP4h2AAAAlB9EOwAAAMoPoh0AAADlB9EOAACA8oNoBwAAQPlBtAMAAKD8INoBAABQfhDtAAAAKD+IdgAAAJQfRDsAAADKD6IdAAAA5QfRDgAAgPKDaAcAAED5QbQDAACg/CDaAQAAUH4Q7QAAACg/iHYAAACUH0Q7AAAAyg+iHQAAAOUH0Q4AAIDyg2gHAABA+UG0AwAAoPwg2gEAAFB+EO0AAAAoP4h2AAAAlB9EOwAAAMoPoh0AAADlB9EOAACA8oNoBwAAQPnJPdpFRUVZWVmpqam5uLikpaWJTJOamuri4qKmptaxY8cdO3bQNyUkJNjb27PZbHt7+yNHjsi7tAAAAJSSfKNdXFxcaGjo4sWLs7OzPT09hw4dWlhYKJAmPz9/2LBhnp6e2dnZP/744+zZsxMSEvCmjIyMMWPGBAYG3rp1KzAwcPTo0VlZWXItMAAAAKVEkCQpv7337t27R48e27dvx4t2dnYjR45cu3YtPc0PP/xw/PjxvLw8vDht2rRbt25lZGQghMaMGVNZWXn69Gm8aciQIe3atYuNjRVzxMrKSl1d3devX+vo6Mj+fAAAACiKbK/ncry3+/Dhw40bN3x9fak1vr6+6enpAskyMjLoaQYPHnz9+vWPHz+K3CScHSFUU1NTSSPj0wAAAND6yTHaPX/+nMfjmZiYUGtMTExKS0sFkpWWlgqkqa2tff78uchNwtkRQmvXrtX9hMvlyvg0AAAAtH5yb6VCEAT1miRJ+mJ9aehrpMm+aNGi158UFRXJquQAAACUhqr8dm1oaMhgMOh3Y2VlZfR7NczU1FQgjaqqqoGBgchNwtkRQmw2m81my7j0AAAAlIgc7+1YLJaLi0tSUhK1Jikpyd3dXSCZm5sbPc25c+dcXV2ZTKbITcLZAQAAAMlIeTp48CCTydy9e3dubm5oaKimpmZBQQFJkgsXLgwMDMRpHj9+rKGhMWfOnNzc3N27dzOZzMOHD+NNV65cYTAY69aty8vLW7dunaqqamZmpvgjvn79GiH0+vVruZ4XAAAAeZPt9Vy+0Y4kyW3btllYWLBYrB49eqSmpuKVQUFBXl5eVJqUlBRnZ2cWi2Vpabl9+3Z69kOHDnXp0oXJZNra2iYkJEg8HEQ7AABQDrK9nsu3v53iQX87AABQDq2mvx0AAADQQkC0AwAAoPwg2gEAAFB+EO0AAAAoP4h2AAAAlB9EOwAAAMoPoh0AAADlB9EOAACA8oNoBwAAQPnJcQ6EZoGHhoE5XQEAoLXDV3JZDfilbNGuoqICIQRzugIAgHKoqKjQ1dVt+n6ULdrp6+sjhAoLC2Xy7rQQlZWVXC63qKhImQb/hJNqLeCkWgXlOyOE0OvXrzt06ICv6k2nbNFORUUFIaSrq6tMHzmmo6MDJ9UqwEm1Fsp3Usp3RujTVV0G+5HJXgAAAICWDKIdAAAA5ads0Y7NZi9btozNZjd3QWQJTqq1gJNqLZTvpJTvjJCsT0rZZnMFAAAAhCnbvR0AAAAgDKIdAAAA5QfRDgAAgPKDaAcAAED5tbJoFxUVZWVlpaam5uLikpaWJjLN/v37HR0dNTQ0zMzMJk+ejMcSozt48CBBECNHjpR7caXTlJOKiYkh6nr//r0Cyy5aEz+mV69ezZgxw8zMTE1Nzc7O7tSpU4oquDhNOSlvb2+Bj2n48OEKLHu9mvhJRUREdOnSRV1dncvlzpkzpyX876GmndTHjx9XrFhhbW2tpqbm6Oh45swZBRZcHGlOatu2bXZ2durq6l26dNm7dy99U0JCgr29PZvNtre3P3LkiEKKLFlTTuqff/4ZNWqUpaUlQRARERFSHY9sPQ4ePMhkMnfu3JmbmxsSEqKpqfnvv/8KpElLS1NRUYmMjHz8+HFaWlrXrl1HjhxJT1BQUGBubu7p6enn56e4oteviScVHR2to6NTQqPwMxDUxDOqqalxdXUdNmzY5cuXCwoK0tLScnJyFH4Sgpp4UhUVFdQH9PfffzMYjOjoaEWfg5AmntSff/7JZrP379+fn59/9uxZMzOz0NBQhZ+EoCae1IIFC9q3b3/y5MlHjx5FRUWpqandvHlT4SchSJqTioqK0tbWPnjw4KNHj2JjY7W0tI4fP443paenMxiMNWvW5OXlrVmzRlVVNTMzU+EnIaiJJ3X16tV58+bFxsaamppu3rxZmiO2pmjXq1evadOmUYu2trYLFy4USLNhw4aOHTtSi1u2bOFwONRibW2th4fHrl27goKCWki0a+JJRUdH6+rqyr+YDdDEM9q+fXvHjh0/fPiggKJKr+n/e5TNmzdra2tXV1fLqajSa+JJzZgxo3///tSmsLCwvn37yrO8UmniSZmZmf3666/UJj8/vwkTJsizvFKR5qTc3NzmzZtHLYaEhHh4eODXo0ePHjJkCLVp8ODBY8eOlWd5pdLEk6JYWFhIGe1aTU3mhw8fbty44evrS63x9fVNT08XSObu7v7kyZNTp06RJPns2bPDhw/Tq4xWrFhhZGQUHBysoEJLIpOTqq6utrCw4HA4I0aMyM7OVlDR69H0Mzp+/Libm9uMGTNMTEy6deu2Zs0aHo+nuBMQRSYfE2X37t1jx47V1NSUb6ElafpJ9e3b98aNG1evXkUIPX78+NSpU81ePdv0k6qpqVFTU6NSqqurX758WQElF0PKkxIu+dWrVz9+/IgQysjIoGcfPHiwcHYFa/pJNUaDI3IzKS4uRghduXKFWrN69erOnTsLpzx06JCWlpaqqipC6Msvv6TuEi5fvmxubl5eXk6SZAu5t2v6SWVkZOzbty8nJ+fSpUujRo1SV1e/f/++gkovStPPqEuXLmw2e8qUKdevX4+NjdXX11++fLmCSl+Ppp8UJSsrCyGUlZUl3xJLQSYntWXLFiaTiTd9//33iii3WE0/qXHjxtnb29+/f5/H4507d05dXZ3FYimo9PWQ8qQWLVpkamp6/fp1Pp9/7do1Y2NjhNDTp09JkmQymfv376dS7t+/XwlOiqKE93YYQRDUa5Ik6YtYbm7u7Nmzly5deuPGjTNnzuTn50+bNg0hVFVVNXHixJ07dxoaGiq0xFJo9EkhhPr06TNx4kRHR0dPT8/4+PjOnTtv3bpVcUWvR1POiM/nGxsb//777y4uLmPHjl28ePH27dsVV/T6NeWkKLt37+7WrVuvXr3kXlzpNOWkUlJSVq9eHRUVdfPmzcTExL/++mvlypWKK3r9mnJSkZGRnTp1srW1ZbFYM2fOnDx5MoPBUFzR6yfxpJYsWTJ06NA+ffowmUw/P79JkyYhhKjCS8zeLJp4Ug3W2NisaDU1NQwGIzExkVoze/bsfv36CSSbOHFiQEAAtYjb+Tx9+hRX8TE+we3iGAzGw4cPFXQCojTxpIR3OHXqVHoFveI1/Yz69es3YMAAahNukFlTUyPngosjq4/pzZs3Ojo6ERER8i6wNJp+Un379qU/U9m3b5+6ujqPx5NzwcWR1Sf17t27J0+e8Pn8BQsW2Nvby7vY4kl5UtiHDx+Kiopqa2tx+w78cXC53E2bNlFpNm3a1KFDB3kXW7ymnxRFCe/tWCyWi4tLUlIStSYpKcnd3V0g2du3b+mTIeFfASRJ2tra3rlzJ+eTL7/80sfHJycnp3lnOW/iSQkkI0kyJyfHzMxMbuWVrOln5OHh8fDhQz6fjzfdv3/fzMyMxWLJvej1k9XHFB8fX1NTM3HiRDmXVypNPynhTfiaIt9yiyWrT0pNTc3c3Ly2tjYhIcHPz0/OpZZAypPCmEwmh8NhMBgHDx4cMWIEPk03Nzd69nPnztWXXWGaflKN0dCY3Ixwi9Xdu3fn5uaGhoZqamoWFBSQJLlw4cLAwECcJjo6WlVVNSoq6tGjR5cvX3Z1de3Vq5fwrlrIczuyyScVHh5+5syZR48eZWdnT548WVVVtdmfCTXxjAoLC7W0tGbOnHnv3r2//vrL2Nh41apVzXYyn8jkf69v375jxoxphtLXo4kntWzZMm1t7djY2MePH587d87a2nr06NHNdjKfNPGkMjMzExISHj16dOnSpf79+1tZWb18+bK5zoUizUndu3dv37599+/fz8rKGjNmjL6+fn5+Pt505coVBoOxbt26vLy8devWtageCI0+qZqamuzs7OzsbDMzs3nz5mVnZz948ED8EVtTtCNJctu2bRYWFiwWq0ePHqmpqXhlUFCQl5cXlWbLli329vbq6upmZmYTJkx48uSJ8H5aTrQjm3ZSoaGhHTp0YLFYRkZGuFGT4ssvrIkfU3p6eu/evdlsdseOHVevXl1bW6vg8ovUxJO6d+8eQujcuXMKLrZ4TTmpjx8/hoeH447YXC53+vTpLSEwkE07qZSUFDs7OzabbWBgEBgYWFxcrPjyiyTxpHJzc52cnNTV1XV0dPz8/O7evUvPfujQoS5dujCZTFtb24SEBAUXvj5NOan8/HyBOzf65ysSzPgDAABA+bWa53YAAABAo0G0AwAAoPwg2gEAAFB+EO0AAAAoP4h2AAAAlB9EOwAAAMoPoh0AAADlB9EOAACA8oNoB4Dc4cmjhwwZ0twFAaDtgrFUAJC7qVOnamlp7dq1Kzc3t0OHDnI6ysePH5lMppx2DkBrB/d2AMjXmzdv4uPjv//++xEjRsTExFDrjx8/7urqqqamZmho6O/vj1fW1NQsWLCAy+Wy2exOnTrt3r0bIRQTE6Onp0dlPHr0KDUTWHh4uJOT0549ezp27Mhms0mSPHPmTN++ffX09AwMDEaMGPHo0SMq45MnT8aOHauvr6+pqenq6pqVlVVQUKCionL9+nUqzdatWy0sLOBHMFA+EO0AkK+4uLguXbp06dJl4sSJ0dHROJCcPHnS399/+PDh2dnZFy5ccHV1xYm/+eabgwcPbtmyJS8vb8eOHVpaWhL3//Dhw/j4+ISEhJycHITQmzdvwsLCrl27duHCBRUVla+++gpPn1RdXe3l5fX06dPjx4/funVrwYIFfD7f0tJy4MCB0dHR1N6io6MnTZrUQmb7BECWZDumNQBAgLu7O57B9ePHj4aGhklJSSRJurm5TZgwQSAlnicBJ6CLjo7W1dWlFo8cOUJ9c5ctW8ZkMsvKykQeuqysDCF0584dkiR/++03bW3tiooKgTRxcXHt2rV7//49SZI5OTkEQVCTqgCgTODeDgA5unfv3tWrV8eOHYsQUlVVHTNmzJ49exBCOTk5AwYMEEick5PDYDC8vLwadAgLCwsjIyNq8dGjR+PHj+/YsaOOjo6VlRVCqLCwEO/c2dlZX19fIPvIkSNVVVVxBN2zZ4+Pj4+lpWVDTxOAlk+1uQsAgDLbvXt3bW2tubk5XiRJkslkvnz5Ul1dXTixyJUIIRUVFZL2IO3jx4/0rZqamvTFL774gsvl7ty5s3379nw+v1u3bh8+fBCzcxaLFRgYGB0d7e/vf+DAgYiIiAacHgCtB9zbASAvtbW1e/fu3bhxY84nt27dsrCw2L9/f/fu3S9cuCCQ3sHBgc/np6amCqw3MjKqqqp68+YNXsTP50SqqKjIy8v76aefBgwYYGdn9/LlS2pT9+7dc3JyXrx4IZxr6tSp58+fj4qK+vjxI9VeBgBl09xVqQAorSNHjrBYrFevXtFX/vjjj05OTsnJySoqKkuXLs3Nzb19+/b69evx1kmTJnG53CNHjjx+/Dg5OTkuLo4kyYqKCk1NzdmzZz948GD//v3t27dHtOd2jo6O1M55PJ6BgcHEiRMfPHhw4cKFnj17IoSOHDlCkmRNTU3nzp09PT0vX7786NGjw4cP02e6d3d3Z7FY06ZNk+87AkDzgXs7AORl9+7dAwcO1NXVpa8cNWpUTk6Ojo7OoUOHjh8/7uTk1L9//6ysLLx1+/btAQEB06dPt7W1/fbbb/H9nL6+/p9//nnq1CkHB4fY2Njw8PD6jqiionLw4MEbN25069Ztzpw5GzZsoDaxWKxz584ZGxsPGzbMwcFh3bp1DAaD2hocHPzhw4cpU6bI9h0AoOWA3uUAALR69eqDBw/euXOnuQsCgLzAvR0AbVp1dfW1a9e2bt06e/bs5i4LAHIE0Q6ANm3mzJl9+/b18vKCakyg3KAmEwAAgPKDezsAAADKD6IdAAAA5QfRDgAAgPKDaAcAAED5QbQDAACg/CDaAQAAUH4Q7QAAACg/iHYAAACUH0Q7AAAAyu//Z/1iXC71+xgAAAAASUVORK5CYII=", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk8AAAHHCAYAAACmzLxGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACqB0lEQVR4nOzdd1hT1xsH8G8IEDbIngUFB6IiRXFSULFoW2etdbSidbS1DsRdqzjrFhxV6wKr1o2jtrWOiqW46rYKoiiKCG5QQASS8/sjv9xySQIJBBLk/TzPfSDnnnvue5OQvNx77jkCxhgDIYQQQghRiZ62AyCEEEIIqUkoeSKEEEIIUQMlT4QQQgghaqDkiRBCCCFEDZQ8EUIIIYSogZInQgghhBA1UPJECCGEEKIGSp4IIYQQQtRAyRMhhBBCiBooeXoLCQQCzJw5k3scGxsLgUCAtLQ0riw4OBjBwcHVHhshmiB7T58/f77cujXxva7ob5aQ6qTtv5stW7agUaNGMDAwgJWVFVe+ePFi1KtXD0KhEM2bN9dafJQ8VYA6H9xEnoeHBwQCAQQCAfT09GBlZYWmTZtixIgROHv2rLbD05jg4GDecVpYWKBhw4b4/PPPcfToUW2HRyqg5GsqEAhgbW2Nli1bYtOmTZBIJFW679WrVyM2NrZK91GVfvvtNwgEAjg7O1f5c/U2efjwIWbOnInLly9rO5Rqk5ycjMGDB8PT0xPr16/HunXrAABHjhzBpEmT0K5dO8TExOD777/XWoz6Wtsz0aojR45odf/NmzfH+PHjAQCvXr1CUlISdu/ejfXr12PcuHFYtmyZVuPTFFdXV8yfPx8AkJeXh9u3byMuLg5bt25F3759sXXrVhgYGGg5yrebpt/rJV/TJ0+e4KeffsLQoUORkpKCBQsWaGQfn3/+Ofr16weRSMSVrV69Gra2thg8eLBG9lHdtm3bBg8PD6SlpeHPP/9ESEiItkOqER4+fIhZs2bBw8NDq2daqlN8fDwkEgmWL18OLy8vrvzPP/+Enp4eNm7cCENDQy1GSMlTraXtN56Liws+++wzXtnChQsxYMAAREVFoX79+vj666+1FJ3mWFpayh3nggULMGbMGKxevRoeHh5YuHChlqKrWowxFBQUwNjYWKtxaPq9Xvo1/fLLL9GwYUOsWrUKc+bMqVQynJeXB1NTUwiFQgiFQk2EqxPy8vJw4MABzJ8/HzExMdi2bZvOJk+y16Cmys/Ph4mJibbDqJTHjx8DAO9ynazc2NhY699fAF22q1IZGRn44osv4ODgAJFIBB8fH2zatIlb/+jRI+jr62PWrFly2968eRMCgQCrVq3iyrKzsxEeHg43NzeIRCJ4eXlh4cKFFToFXvp6dnx8PAQCAXbt2oV58+bB1dUVRkZG6NSpE27fvi23/Q8//IB69erB2NgYAQEBSEhIqPQ1cmNjY2zZsgXW1taYN28eGGPcury8PIwfP5479oYNG2LJkiW8Or1798a7777La7Nbt24QCAQ4ePAgV3b27FkIBAL8/vvvAP67DJuYmIiIiAjY2dnB1NQUvXr1wpMnT3jt5eTkIDk5GTk5ORU+TqFQiBUrVqBx48ZYtWqVXFtbt26Fv78/jI2NYW1tjX79+iE9PZ1XJzg4GE2aNMHVq1cRFBQEExMTeHl5Yc+ePQCAkydPolWrVjA2NkbDhg1x7NgxuTguXbqErl27wsLCAmZmZujUqRPOnDkjV0+2D2NjY7i6umLu3LmIiYmR65Pj4eGBjz76CH/88QdatGgBY2Nj/PjjjwCAmJgYdOzYEfb29hCJRGjcuDHWrFkjty9ZG0eOHEHz5s1hZGSExo0bIy4uTuFz+ebNm3JfM0Xvy4KCAsycORMNGjSAkZERnJyc0Lt3b6SmpircT1lMTEzQunVr5OXl4cmTJ7h37x5GjhyJhg0bwtjYGDY2Nvjkk0/k+i/J3ncnT57EyJEjYW9vD1dXV9462TYeHh64fv06Tp48yV0yDA4Oxp07dyAQCBAVFSUX16lTpyAQCLB9+3aFcavz+VNUVIRZs2ahfv36MDIygo2NDdq3b6/y5ed9+/bh9evX+OSTT9CvXz/ExcWhoKBArp4qr4vsjETTpk1hZGQEOzs7dOnShetGkZaWBoFAoPASZ+n+oDNnzoRAIMCNGzcwYMAA1KlTB+3btwcgfd8PHjwY9erVg5GRERwdHfHFF1/g2bNncu1mZGRg6NChcHZ2hkgkQt26dfH111+jsLCwUq9RfHw8WrZsCQAYMmQI99rLjk32OXDhwgW89957MDExwbfffgsAOHDgAD788EMuJk9PT8yZMwdisVhuP+vWrYOnpyfv81yRN2/eIDIyEl5eXhCJRHBzc8OkSZPw5s0bhfUVWb16NXx8fCASieDs7IxvvvkG2dnZ3HoPDw9ERkYCAOzs7LjXTCAQICYmBnl5eXLPg1YworaYmBgGgP3zzz9K62RlZTFXV1fm5ubGZs+ezdasWcO6d+/OALCoqCiuXseOHVnjxo3ltp81axYTCoUsKyuLMcZYXl4ea9asGbOxsWHffvstW7t2LRs0aBATCARs7NixvG0BsMjISLl47969y5UFBQWxoKAg7vGJEycYAObn58f8/f1ZVFQUmzlzJjMxMWEBAQG89levXs0AsMDAQLZixQoWERHBrK2tmaenJ69NZdzd3dmHH36odP3QoUMZAPbvv/8yxhiTSCSsY8eOTCAQsGHDhrFVq1axbt26MQAsPDyc227ZsmVMT0+P5eTkcNvVqVOH6enpsQkTJnD1Fi9ezKsne378/PxYx44d2cqVK9n48eOZUChkffv25cUmqxsTE1PucQYFBTEfHx+l6+fMmcMAsEOHDnFlc+fOZQKBgH366ads9erVbNasWczW1pZ5eHiwFy9e8Np2dnZmbm5ubOLEiWzlypWscePGTCgUsh07djBHR0c2c+ZMFh0dzVxcXJilpSV7+fIlt/2///7LTE1NmZOTE5szZw5bsGABq1u3LhOJROzMmTNcvQcPHjBra2tmY2PDZs2axZYsWcIaNWrEfH195d5T7u7uzMvLi9WpU4dNmTKFrV27lp04cYIxxljLli3Z4MGDWVRUFFu5ciV7//33GQC2atUq3nPi7u7OGjRowKysrNiUKVPYsmXLWNOmTZmenh47cuSI3OugymtW+r1eXFzMOnXqxACwfv36sVWrVrH58+ezjh07sv3791foNX333XeZUChkeXl5bPfu3czX15fNmDGDrVu3jn377besTp06zN3dneXl5ckdQ+PGjVlQUBBbuXIlW7BgAW+d7Pndt28fc3V1ZY0aNWJbtmxhW7Zs4Z6Pdu3aMX9/f7mYRo4cyczNzXn7LE3Vz59vv/2WCQQCNnz4cLZ+/Xq2dOlS1r9/fy7e8nTp0oV16tSJMcbYvXv3mEAgYLt27eLVUfV1GTx4MAPAunbtyqKjo9mSJUtYjx492MqVKxljjN29e1fp32jpz8bIyEjuNejRowdbvXo1++GHHxhjjC1ZsoQFBgay2bNns3Xr1rGxY8cyY2NjFhAQwCQSCddGRkYGc3Z2ZiYmJiw8PJytXbuWTZ8+nXl7e3N/sxV9jbKystjs2bMZADZixAjutU9NTWWMSd+Pjo6OzM7Ojo0ePZr9+OOP3HPVs2dP1rdvX7Z48WK2Zs0a9sknnzAAvM9CxhjbsGEDA8Datm3LVqxYwcLDw5mVlRWrV68e7+9GLBaz999/nzvOH3/8kY0aNYrp6+uzHj16KIy/NNnzHRISwlauXMlGjRrFhEIha9myJSssLGSMSd/rvXr1YgDYmjVr2JYtW9iVK1fYli1bWGBgIBOJRHLPgzZQ8lQBqiRPQ4cOZU5OTuzp06e88n79+jFLS0uWn5/PGGPsxx9/ZADYtWvXePUaN27MOnbsyD2eM2cOMzU1ZSkpKbx6U6ZMYUKhkN2/f58rq0zy5O3tzd68ecOVL1++nBffmzdvmI2NDWvZsiUrKiri6sXGxjIAGkmeoqKiGAB24MABxhhj+/fvZwDY3LlzefX69OnDBAIBu337NmOMsX/++YcBYL/99htjjLGrV68yAOyTTz5hrVq14rbr3r078/Pzk3t+QkJCeB+K48aNY0KhkGVnZ8vV1UTytG/fPgaALV++nDHGWFpaGhMKhWzevHm8eteuXWP6+vq88qCgIAaA/fzzz1xZcnIyA8D09PR4CdAff/whF3PPnj2ZoaEh78Pn4cOHzNzcnL333ntc2ejRo5lAIGCXLl3iyp49e8asra0VJk8A2OHDh+WOVfZ+Lyk0NJTVq1ePVyZrY+/evVxZTk4Oc3JyqvBrVvq9vmnTJgaALVu2TC6mkm0pEhQUxBo1asSePHnCnjx5wpKSktiYMWMYANatWzelx3r69GkGgP30009yx9C+fXtWXFzMq6/ob9bHx0fh35fsMyQpKYkrKywsZLa2tiwsLKzM41H188fX17fMv9myPHr0iOnr67P169dzZW3btpX7wlXldfnzzz8ZADZmzBildSqSPPXv31+urqLXcfv27QwA++uvv7iyQYMGMT09PYXfB7KYKvMayT7XFB2P7HNg7dq1KsX/5ZdfMhMTE1ZQUMDFYG9vz5o3b8773F+3bp3c5/mWLVuYnp4eS0hI4LW5du1aBoAlJiaWeRyPHz9mhoaG7P3332disZgrX7VqFQPANm3axJXJXpcnT57w2ggLC2OmpqZl7qe60GW7KsAYw969e9GtWzcwxvD06VNuCQ0NRU5ODi5evAhAeqlJX18fO3fu5Lb/999/cePGDXz66adc2e7duxEYGIg6derw2gsJCYFYLMZff/2lkdiHDBnCu54cGBgIALhz5w4A4Pz583j27BmGDx8Off3/uswNHDgQderU0UgMZmZmAKQdyQHpXTpCoRBjxozh1Rs/fjwYY9zlNz8/P5iZmXHPRUJCAlxdXTFo0CBcvHgR+fn5YIzh77//5o6rpBEjRkAgEPCOXSwW4969e1zZ4MGDwRjTSKfd0scZFxcHiUSCvn378l5jR0dH1K9fHydOnJDbvl+/ftzjhg0bwsrKCt7e3mjVqhVXLvtd9hqKxWIcOXIEPXv2RL169bh6Tk5OGDBgAP7++2+8fPkSAHD48GG0adOG11HV2toaAwcOVHhMdevWRWhoqFx5yX5POTk5ePr0KYKCgnDnzh25y5bOzs7o1asX99jCwgKDBg3CpUuXkJWVxaurymtW2t69e2Fra4vRo0fLrSvZljLJycmws7ODnZ0dvL29sXLlSnz44YfcJfmSx1pUVIRnz57By8sLVlZW3N99ScOHD69U/6a+ffvCyMgI27Zt48r++OMPPH36VK6/XWmqfv5YWVnh+vXruHXrltrx7dixA3p6evj444+5sv79++P333/HixcvuDJVXpe9e/dCIBBwl3UU1amIr776Sq6s5OtYUFCAp0+fonXr1gDAvY4SiQT79+9Ht27d0KJFC6UxVeY1Ko9IJMKQIUPKjP/Vq1d4+vQpAgMDkZ+fj+TkZADSz/PHjx/jq6++4n3uDx48GJaWlrz2du/eDW9vbzRq1Ij3+dSxY0cAkPt8Ku3YsWMoLCxEeHg49PT+Sz2GDx8OCwsL/Prrr+ofvBZR8lQFnjx5guzsbKxbt477kJUtsje5rEOcra0tOnXqhF27dnHb79y5E/r6+ujduzdXduvWLRw+fFiuPVmnS1l7lfXOO+/wHssSItmHnOxLqeQdEACgr68PDw8PjcSQm5sLADA3N+f26ezszD2W8fb25sUkFArRpk0b7np9QkICAgMD0b59e4jFYpw5cwY3btzA8+fPFSZP5R27ppU+zlu3boExhvr168u9zklJSXKvsaurq9wXhqWlJdzc3OTKSh7HkydPkJ+fj4YNG8rF5O3tDYlEwvWxunfvntxrDci//jJ169ZVWJ6YmIiQkBCYmprCysoKdnZ2XN+M0smTl5eX3HE1aNAAAOT6DVXkNUtNTUXDhg15yb86PDw8cPToURw7dgx///03srKycOjQIdja2gIAXr9+jRkzZnD982xtbWFnZ4fs7GyFfeWUPWeqsrKyQrdu3fDzzz9zZdu2bYOLiwv3xaaMqp8/s2fPRnZ2Nho0aICmTZti4sSJuHr1qkrxbd26FQEBAXj27Blu376N27dvw8/PD4WFhdi9ezdXT5XXJTU1Fc7OzrC2tlZp36pS9Bo8f/4cY8eOhYODA4yNjWFnZ8fVk72OT548wcuXL9GkSZMy26/Ma1QeFxcXhR2or1+/jl69esHS0hIWFhaws7PjEjVZ/LLPzvr16/O2NTAw4P1jBUg/n65fvy732ST725R9Pj1//hxZWVncUnpfpT93DA0NUa9evTL/4dFFdLddFZB14P7ss88QFhamsE6zZs243/v164chQ4bg8uXLaN68OXbt2oVOnTpxH8ayNjt37oxJkyYpbE/2Bq4sZf8BsxIds6vav//+C0D5F3RZ2rdvj3nz5qGgoAAJCQmYNm0arKys0KRJEyQkJMDBwQEAFCZP1X3spY9TIpFwHdkVxSI7UyWjLF5tvoaK7qxLTU1Fp06d0KhRIyxbtgxubm4wNDTEb7/9hqioqEqN+aONYzU1NS3zTrHRo0cjJiYG4eHhaNOmDSwtLSEQCNCvXz+Fx6qJuxEHDRqE3bt349SpU2jatCkOHjyIkSNH8v7DV0aVz5/33nsPqampOHDgAI4cOYINGzYgKioKa9euxbBhw5S2fevWLfzzzz8A5L+gAWkCMWLEiAocsXLKzkAp6igto+g16Nu3L06dOoWJEyeiefPmMDMzg0QiQZcuXSr0nq3Ma1QWRbFnZ2cjKCgIFhYWmD17Njw9PWFkZISLFy9i8uTJFYpfIpGgadOmSoeRkf3T1rt3b5w8eZIrDwsLq9HjkylDyVMVsLOzg7m5OcRisUq34/bs2RNffvkld+o8JSUFU6dO5dXx9PREbm6u1m/vdXd3BwDcvn0bHTp04MqLi4uRlpbGSworIjc3F/v27YObmxt3Zsnd3R3Hjh3Dq1eveGefZKeeZTEB0qSosLAQ27dvR0ZGBpckvffee1zy1KBBAy6J0haxWIyff/4ZJiYm3N09np6eYIyhbt26GkuGFbGzs4OJiQlu3rwpty45ORl6enrcB6G7u7vCuy0VlSnzyy+/4M2bNzh48CDvTJGy0/y3b98GY4z3JZiSkgIAGjm76enpibNnz6KoqKhKxtjas2cPwsLCsHTpUq6soKCAd0dRRZR1WapLly6ws7PDtm3b0KpVK+Tn5+Pzzz9XqV1VPn8A6eXaIUOGYMiQIcjNzcV7772HmTNnlpk8bdu2DQYGBtiyZYtcovv3339jxYoVuH//Pt555x2VXhdPT0/88ccfeP78udKzT7Kzj6Wfb3XObLx48QLHjx/HrFmzMGPGDK689GVLOzs7WFhYcP8IlaWir1FFLkfGx8fj2bNniIuLw3vvvceV3717l1dP9tl569Yt3hmwoqIi3L17F76+vlyZp6cnrly5gk6dOpUZ09KlS3lnfp2dnXn7unnzJu+sVmFhIe7evav17zZ10WW7KiAUCvHxxx9j7969Cv+oSt9KbWVlhdDQUOzatQs7duyAoaEhevbsyavTt29fnD59Gn/88Ydce9nZ2SguLtboMSjTokUL2NjYYP369bx9btu2rdKXt16/fo3PP/8cz58/x7Rp07g/0A8++ABisZg3bAMAREVFQSAQoGvXrlxZq1atYGBggIULF8La2ho+Pj4ApEnVmTNncPLkSYVnnVSliaEKxGIxxowZg6SkJIwZMwYWFhYApP+xCYVCzJo1S+7MCWNM4S3SFSEUCvH+++/jwIEDvMtgjx49ws8//4z27dtzMYWGhuL06dO80Y2fP3/O67uhyv5kxyCTk5ODmJgYhfUfPnyIffv2cY9fvnyJn376Cc2bN4ejo6PK+1Xm448/xtOnT+XeT6VjrCihUCjXzsqVK8s886EKU1NTpQmYvr4++vfvj127diE2NhZNmzZV+R8ZVT5/Sr/3zMzM4OXlVe4t6tu2bUNgYCA+/fRT9OnTh7dMnDgRALjb9FV5XT7++GMwxhQOryCrY2FhAVtbW7l+oKtXry4z1pIUvWcBIDo6mvdYT08PPXv2xC+//KJwxomS21f0NZKNOaVO8q0o/sLCQrnnoEWLFrCzs8PatWtRWFjIlcfGxsrtr2/fvsjIyMD69evl9vf69Wvk5eUBAPz9/RESEsItjRs3BgCEhITA0NAQK1as4MW1ceNG5OTk4MMPP1T5+HQBnXmqhE2bNuHw4cNy5WPHjsWCBQtw4sQJtGrVCsOHD0fjxo3x/PlzXLx4EceOHcPz589523z66af47LPPsHr1aoSGhsoNDjZx4kQcPHgQH330EQYPHgx/f3/k5eXh2rVr2LNnD9LS0nin2auKoaEhZs6cidGjR6Njx47o27cv0tLSEBsbC09PT5X/S8rIyMDWrVsBSM823bhxA7t370ZWVhbGjx+PL7/8kqvbrVs3dOjQAdOmTUNaWhp8fX1x5MgRHDhwAOHh4fD09OTqmpiYwN/fH2fOnOHGeAKkZ57y8vKQl5dXqeRp3759GDJkCGJiYlTqNJ6Tk8MdZ35+PjfCeGpqKvr164c5c+ZwdT09PTF37lxMnToVaWlp6NmzJ8zNzXH37l3s27cPI0aMwIQJEyoce0lz587F0aNH0b59e4wcORL6+vr48ccf8ebNGyxatIirN2nSJGzduhWdO3fG6NGjYWpqig0bNuCdd97B8+fPVXq933//fRgaGqJbt2748ssvkZubi/Xr18Pe3h6ZmZly9Rs0aIChQ4fin3/+gYODAzZt2oRHjx4pTbbUNWjQIPz000+IiIjAuXPnEBgYiLy8PBw7dgwjR45Ejx49KtX+Rx99hC1btsDS0hKNGzfG6dOncezYMdjY2FSqXX9/f6xZswZz586Fl5cX7O3teWcLBg0ahBUrVuDEiRNqD7xa3udP48aNERwcDH9/f1hbW+P8+fPYs2cPRo0apbTNs2fP4vbt20rruLi44N1338W2bdswefJklV6XDh064PPPP8eKFStw69Yt7hJaQkICOnTowO1r2LBhWLBgAYYNG4YWLVrgr7/+4s5eqsLCwgLvvfceFi1ahKKiIri4uODIkSNyZ24A4Pvvv8eRI0cQFBSEESNGwNvbG5mZmdi9ezf+/vtv3nNZkdfI09MTVlZWWLt2LczNzWFqaopWrVqV2Veubdu2qFOnDsLCwjBmzBgIBAJs2bJFLhk0MDDA3Llz8eWXX6Jjx4749NNPcffuXcTExMj1efr888+xa9cufPXVVzhx4gTatWsHsViM5ORk7Nq1ixvfTRk7OztMnToVs2bNQpcuXdC9e3fcvHkTq1evRsuWLSvdcb7aVdt9fW8R2W3Eypb09HTGmPQW3W+++Ya5ubkxAwMD5ujoyDp16sTWrVsn1+bLly+ZsbExA8C2bt2qcL+vXr1iU6dOZV5eXszQ0JDZ2tqytm3bsiVLlnBjZDBWuaEKdu/ezdunstt+V6xYwdzd3ZlIJGIBAQEsMTGR+fv7sy5dupT7/MluRwfABAIBs7CwYD4+Pmz48OHs7NmzSo993LhxzNnZmRkYGLD69euzxYsXK7y1fOLEiQwAW7hwIa/cy8uLAZAbG0TZ0BOy50Q2VlHJuqoOVVDyfWFmZsbq16/PPvvsM96YRaXt3buXtW/fnpmamjJTU1PWqFEj9s0337CbN2/y2lY0DIKyYSAAsG+++YZXdvHiRRYaGsrMzMyYiYkJ69ChAzt16pTctpcuXeLGV3F1dWXz589nK1asYAC4cYDK2jdjjB08eJA1a9aMGRkZMQ8PD7Zw4ULu1vTSwx18+OGH7I8//mDNmjVjIpGINWrUSO59qc5rVvq9zpj0Nu5p06axunXrcn+bffr0KXfcmPKGn2CMsRcvXrAhQ4YwW1tbZmZmxkJDQ1lycjJzd3fn3ZZe1pAniv5ms7Ky2IcffsjMzc2VDgvi4+PD9PT02IMHD8qMsbTyPn/mzp3LAgICmJWVFTM2NmaNGjVi8+bN433ulDZ69GiFf28lzZw5kwFgV65cYYyp9roUFxezxYsXs0aNGjFDQ0NmZ2fHunbtyi5cuMDVyc/PZ0OHDmWWlpbM3Nyc9e3blz1+/FjpUAWlb4lnTDrGWa9evZiVlRWztLRkn3zyCXv48KFcG4xJx64aNGgQs7OzYyKRiNWrV4998803vNv/ZSryGh04cIA1btyY6evr8z5/yno/JiYmstatWzNjY2Pm7OzMJk2axA1bUvLvgzHp2H2ycd5atGjB/vrrL4V/N4WFhWzhwoXMx8eHiUQiVqdOHebv789mzZrFjZtXnlWrVrFGjRoxAwMD5uDgwL7++mveGHaM1YyhCgSMVWNPYPLWkkgksLOzQ+/evRWe1iVvl/DwcPz444/Izc3V6DQiHh4eaNKkCQ4dOqSxNmsTPz8/WFtb4/jx49oOhShBr9Hbgfo8EbUVFBTInf796aef8Pz580pNz0J00+vXr3mPnz17hi1btqB9+/Zv1fxrNd358+dx+fJlDBo0SNuhECXoNXp7UJ8norYzZ85g3Lhx+OSTT2BjY4OLFy9i48aNaNKkCT755BNth0c0rE2bNggODoa3tzcePXqEjRs34uXLl5g+fbq2QyOQDnlx4cIFLF26FE5OTrzBLYluoNfo7UPJE1Gbh4cH3NzcsGLFCu6W4UGDBmHBggU6Mds10awPPvgAe/bswbp16yAQCPDuu+9i48aNvFugifbs2bMHs2fPRsOGDbF9+3YYGRlpOyRSCr1Gbx/q80QIIYQQogbq80QIIYQQogZKngghhBBC1EB9nhSQSCR4+PAhzM3NKzVTNyGEEEKqD2MMr169grOzc6XnDSwLJU8KPHz4UG5mekIIIYTUDOnp6XB1da2y9il5UkA2+Wx6ejo3xxchhBBCdNvLly/h5ubGm0S+KlDypIDsUp2FhQUlT4QQQkgNU9VdbqjDOCGEEEKIGih5IoQQQghRAyVPhBBCCCFqoOSJEEIIIUQNlDwRQgghhKiBkidCCCGEEDVQ8kQIIYQQogZKngghhBBC1EDJEyGEEEKIGmiEcUII0XViMZCQAGRmAk5OQGAgIBRqOypCai1KngghRJfFxQFjxwIPHvxX5uoKLF8O9O6tvbgIqcXosh0hhOiquDigTx9+4gQAGRnS8rg47cRFSC1HyRMhhOgisVh6xokx+XWysvBwaT1CSLWi5IkQQnRRQoL8GaeSGAPS06X1CCHVipInQgjRRZmZmq1HCNEYSp4IIUQXOTlpth4hRGMoeSKEEF3Utm35wxEIhdJ6hJBqRckTIYToolOnyu8MLhZL6xFCqhUlT4QQoouozxMhOouSJ0II0UXU54kQnUXJEyGE6KLAQOlI4gKB4vUCAeDmJq1HCKlWlDwRQoguEgqlU7AA8gmU7HF0NM1xR4gWUPJECCG6qndvYM8ewMWFX+7qKi2nue0I0QqaGJgQQnRZ795Ajx7SkcQzM6V9nAID6YwTIVpEyRMhhOg6oRAIDtZ2FISQ/6PLdoQQQgghaqDkiRBCdNTr16/x/fff4/Xr19oOhRBSAiVPhBCia8RiID4eeydMwLRp0xC3Z4+2IyKElEB9ngghRJfExQFjxwIPHmDX/4t2fzkCA01N6e46QnQEJU+EEKIjHm3ahKihQ1H0/8d/CAADWwP8/rQA4z/+GOjWDQaNGyMiIgL29vZajZWQ2kwnLtv98MMP8PDwgJGREVq1aoVz584prbt+/XoEBgaiTp06qFOnDkJCQuTqDx48GAKBgLd06dKlqg+DEEIqTixG5tSpiAawDMAKIz0YuhrB7Ws3GLoaYYWxHpb98guil0fj4cOHWg6WkNpN68nTzp07ERERgcjISFy8eBG+vr4IDQ3F48ePFdaPj49H//79ceLECZw+fRpubm54//33kZGRwavXpUsXZGZmcsv27dur43AIIaRiEhLQ/PFjXADgrQewIgbr3vYwqWcC6972YIUM3nrAhdVr0Lx5c21HS0itpvXkadmyZRg+fDiGDBmCxo0bY+3atTAxMcGmTZsU1t+2bRtGjhyJ5s2bo1GjRtiwYQMkEgmOHz/OqycSieDo6MgtderUqY7DIYSQisnMBAD4AEiUAEzMkJ+Sj6dHniL/Zj6YmCFRAvgYGWk3TkKIdpOnwsJCXLhwASEhIVyZnp4eQkJCcPr0aZXayM/PR1FREaytrXnl8fHxsLe3R8OGDfH111/j2bNnGo2dEEI0ysmJ+/UvABIAz488Q9bPWXh+9BkkABJK1SOEaIdWk6enT59CLBbDwcGBV+7g4ICsrCyV2pg8eTKcnZ15CViXLl3w008/4fjx41i4cCFOnjyJrl27QiwWK2zjzZs3ePnyJW8hhJBqFRgonbNOIEDc/4vaSRhOA2grYQCAOBMTaT1CiFbV6LvtFixYgB07diA+Ph5GJU5l9+vXj/u9adOmaNasGTw9PREfH49OnTrJtTN//nzMmjWrWmImhBCFhEJg+XKgTx/4Q3r5bjwDhADiGbAUgFG/fjSnHSE6QKtnnmxtbSEUCvHo0SNe+aNHj+Do6FjmtkuWLMGCBQtw5MgRNGvWrMy69erVg62tLW7fvq1w/dSpU5GTk8Mt6enp6h0IIYRoQu/ewJ49GOPqikmQJk4AIHRzw6S9ezFm40ZtRkcI+T+tJk+Ghobw9/fndfaWdf5u06aN0u0WLVqEOXPm4PDhw2jRokW5+3nw4AGePXsGJyV9BUQiESwsLHgLIYRoRe/eQFoacOIE8PPP0p9379IAmYToEK1ftouIiEBYWBhatGiBgIAAREdHIy8vD0OGDAEADBo0CC4uLpg/fz4AYOHChZgxYwZ+/vlneHh4cH2jzMzMYGZmhtzcXMyaNQsff/wxHB0dkZqaikmTJsHLywuhoaFaO05CCFGZUAgEB2s7CkKIElpPnj799FM8efIEM2bMQFZWFpo3b47Dhw9zncjv378PPb3/TpCtWbMGhYWF6NOnD6+dyMhIzJw5E0KhEFevXsXmzZuRnZ0NZ2dnvP/++5gzZw5EIlG1HhshhBBC3j4CxhjTdhC65uXLl7C0tEROTg5dwiOEKCYWAwkJ0vGZnJykd8Ep68ytqC6geHt12iWE8FTX97fWzzwRQkiNU2LyXo6rq/RuudJ9kxTVtbGR/iw5/pyrK9C/P7B9u2rtEkK0hs48KUBnngghSsXFAX36AKU/OgUC6c89e/5LdJTVVYeidgkhClXX9zclTwpQ8kQIUUgsBjw8+GeGShIIpGeK7t6VPi6rrjpKtkuX8AhRqrq+v7U+tx0hhNQYCQllJ0OMAenp0nrl1VVHyXYJIVpHfZ4IIURV/5+8V2P1qmr/hJAqRckTIYSoStVJeatq8l6aFJgQnUDJEyGEqEo2eW9GhuJO4LK+SbKhCMqqq47S7RJCtIr6PBFCiKpkk/cC/90FJyN7HB0trVdWXXWUbpcQonWUPBFCiDr+P3kvXFz45a6u8sMJKKtrY/PfWE8ybm7AxInSdsprlxCiVTRUgQI0VAEhpFw0wjghOofGedIiSp4IIYSQmofGeSKEEEII0UF0tx0hhKiqsBBYvRpITQU8PYGRIwFDQ8V1lV1+U7ecEKJzKHkihBBVTJoELFsmTXJkJkwAIiKARYv4dZVNHKxs4l+aEJiQGoX6PClAfZ4IITyTJgGLFytfP3HifwmUJiYDBmhCYEIqgDqMaxElT4QQTmEhYGLCP+NUmlAI5OdLf2pqMmCAJgQmRE3UYZwQQnTB6tVlJ06AdP3q1ZqdDBigCYEJ0VHU54kQQsqSmqp6PQeHqomBJgQmRKfQmSdCCCmLp6fq9WhCYEJqBerzpAD1eSKEcCrS50kTkwED1OeJEDVRnydCCNEFhobS4QjKEhEhraepyYBLbk8TAhOicyh5IoSQ8ixaJB2OoHQSIxTyhykAlE8GrGziX5oQmJAahy7bKUCX7QghCtEI44ToNBrnSYsoeSKEEEJqHp3u87Rlyxa0a9cOzs7OuHfvHgAgOjoaBw4c0GhwhBBCCCG6Ru3kac2aNYiIiMAHH3yA7OxsiP9/B4qVlRWio6M1HR8hhBBCiE5RO3lauXIl1q9fj2nTpkFY4np8ixYtcO3aNY0GRwghhBCia9ROnu7evQs/Pz+5cpFIhLy8PI0ERQghhBCiq9ROnurWrYvLly/LlR8+fBje3t6aiIkQQgghRGepPbddREQEvvnmGxQUFIAxhnPnzmH79u2YP38+NmzYUBUxEkIIIYToDLWTp2HDhsHY2Bjfffcd8vPzMWDAADg7O2P58uXo169fVcRICCGEEKIzKjXOU35+PnJzc2Fvb6/JmLSOxnkihBBCah6dHeepY8eOyM7OBgCYmJhwidPLly/RsWNHjQZHCCGEEKJr1E6e4uPjUVhYKFdeUFCAhIQEjQRFCCGEEKKrVO7zdPXqVe73GzduICsri3ssFotx+PBhuJSeCJMQQggh5C2jcvLUvHlzCAQCCAQChZfnjI2NsXLlSo0GRwghhBCia1ROnu7evQvGGOrVq4dz587Bzs6OW2doaAh7e3veiOOEEEIIIW8jlZMnd3d3AIBEIqmyYAghhBBCdJ3a4zzJ3LhxA/fv35frPN69e/dKB0UIIYQQoqvUTp7u3LmDXr164dq1axAIBJANEyUQCABIO48TQojOEIuBhAQgMxNwcgICAwFlXQyU1VW3nBDyVlM7eRo7dizq1q2L48ePo27dujh37hyePXuG8ePHY8mSJVURIyGEVExcHDB2LPDgwX9lrq7A8uVA796q1e3fH9i+XfVyRW0TQt4qao8wbmtriz///BPNmjWDpaUlzp07h4YNG+LPP//E+PHjcenSpaqKtdrQCOOEvAXi4oA+fYDSH3H/P0uOPXv+S3KU1VWXorYJIdVGZ0cYF4vFMDc3ByBNpB4+fAhA2qH85s2bmo2OEEIqQiyWnkVSlAzJysLDpfXKqquu0m0TQt5Kal+2a9KkCa5cuYK6deuiVatWWLRoEQwNDbFu3TrUq1evKmIkhBD1JCTwL6eVxhiQni6tB5RdV10l2w4O1ly7hBCdoXby9N133yEvLw8AMHv2bHz00UcIDAyEjY0NduzYofEACSFEbZmZmq1XlTEQQmoctZOn0NBQ7ncvLy8kJyfj+fPnqFOnDnfHHSGEaJWTk2brVWUMhJAaR+0+T4pYW1sjKysLo0aN0kRzhBBSOYGB0jvflP1DJxAAbm7SeuXVVVfJtgkhbyW1kqfr169j1apVWLduHbKzswEAT58+RXh4OOrVq4cTJ05URYyEEKIeoVA6ZAAgnxTJHkdHS+uVVVddpdsmhLyVVE6eDh48CD8/P4wZMwZfffUVWrRogRMnTsDb2xvJycnYt28frl+/XpWxEkKI6nr3lg4Z4OLCL3d1lR9KQFldNzdg4kTpNqqUK2qbEPLWUXmcp4CAALRr1w5z5szBhg0bEBERAR8fH2zatAktW7as6jirFY3zRMhbhEYYJ6TWqK7vb5WTJ0tLS1y4cAFeXl4Qi8UQiUQ4fPgwQkJCqiw4baHkiRBCCKl5dG6QzFevXnGBCIVCGBsb07hOhBBCCKl11Oow/scff+DgwYM4ePAgJBIJjh8/zj2WLRXxww8/wMPDA0ZGRmjVqhXOnTuntO769esRGBiIOnXqoE6dOggJCZGrzxjDjBkz4OTkBGNjY4SEhODWrVsVio0QQgghpCSVL9vp6ZWfZwkEAojVnJJg586dGDRoENauXYtWrVohOjoau3fvxs2bN2Fvby9Xf+DAgWjXrh3atm0LIyMjLFy4kOus7vL/zp4LFy7E/PnzsXnzZtStWxfTp0/HtWvXcOPGDRgZGZUbE122IzrjbehTo4k+R1VRF6B+TIS8Zart+5tpWUBAAPvmm2+4x2KxmDk7O7P58+ertH1xcTEzNzdnmzdvZowxJpFImKOjI1u8eDFXJzs7m4lEIrZ9+3aV2szJyWEAWE5OjhpHQoiG7d3LmKsrY9IJP6SLq6u0vKZQ5xiqs66NjXQpvf3EiTX/OSekFquu72+NDJJZUYWFhbhw4QKv07menh5CQkJw+vRpldrIz89HUVERrK2tAQB3795FVlYWr01LS0u0atVK5TYJ0bq4OKBPH/k51zIypOVxcdqJSx3qHEN11332TLqU9OABsHhxzX7OCSHVQqvJ09OnTyEWi+Hg4MArd3BwQFZWlkptTJ48Gc7OzlyyJNtOnTbfvHmDly9f8hZCtEYsBsaOlZ73KE1WFh4uraer1DkGbdRVR015zgkh1Ubtue10yYIFC7Bjxw7Ex8er1JdJmfnz52PWrFkajIyQSkhIkD/7URJjQHq6tF5wcNXEUNl+P+ocA6Ba3fh44No1zbWrjup4zgkhNYZWzzzZ2tpCKBTi0aNHvPJHjx7B0dGxzG2XLFmCBQsW4MiRI2jWrBlXLttOnTanTp2KnJwcbklPT6/I4RCiGZmZmq2nrrg4wMMD6NABGDBA+tPDQ73LVuocg6p1+/YFxo3TfLvqqKrnnBBSo2g1eTI0NIS/vz+OHz/OlcmGQGjTpo3S7RYtWoQ5c+bg8OHDaNGiBW9d3bp14ejoyGvz5cuXOHv2rNI2RSIRLCwseAshWuPkpNl66tBUXyt1jkHVus+fq1ZP3XbVURVtEkJqnor2NH/z5g1LT09n9+7d4y3q2rFjBxOJRCw2NpbduHGDjRgxgllZWbGsrCzGGGOff/45mzJlCld/wYIFzNDQkO3Zs4dlZmZyy6tXr3h1rKys2IEDB9jVq1dZjx49WN26ddnr169VionutiNaVVwsvcNLIODf9SVbBALG3Nyk9apiv4r2qe5+1TmG8uqqs1RHu4QQnVVd399qJ08pKSmsffv2TE9Pj7cIBAKmp6dXoSBWrlzJ3nnnHWZoaMgCAgLYmTNnuHVBQUEsLCyMe+zu7s4AyC2RkZFcHYlEwqZPn84cHByYSCRinTp1Yjdv3lQ5HkqeiNbt3Sv9wi79xS8rq4pb50+cUC2ROHFC88egrK66CU51tUsI0UnV9f2t8iCZMu3atYO+vj6mTJkCJycnCAQC3npfX19NnBDTKhokk+iEuDjp3WIlL6G5uQHR0UDv3prf3/bt0j5O5fn5Z6B/f9XaVOcYFNW1tlb9cp067drYSH+WHK7AzQ3o10/6PFTXc04I0SidmxhYxtTUFBcuXECjRo2qKiato+SJ6IzqHO06Pl7aObw8J06od8dZZUYCF4sBVSYfj4oCRo+mEcYJqeV0Nnlq2bIloqKi0L59+6qKSesoeSK1klgsvasuI0Px2EgCAeDqCty9W33JhC7GRAjRWdX1/a323XYLFy7EpEmTEB8fj2fPntHgkoS8DWRnW/r0kSYppS7Hc4+jo/lJilgsPWO1fbv0Z1mDSFak7q5dwPDh/BgUxQSo3jYhhFSS2oNkykby7tSpE6+cMVahiYEJIVqmqE+Qnh4/AXF1le/3o2g7V1dg+XLV+h2pU1dRHyVZTID07JQqbRNCiAaofdnu5MmTZa4PCgqqVEC6gC7bkVpDNq6Tso+B8HCgRw/5fj/KtpOdDdqz57/ERVN1GQNmzQLq1/+vL9KBA6q3TQh56+lsn6fagJInUivI+hMpm8JEWX8idbYDqqaurGN3ReInhLy1quv7u0Jz22VnZ2Pjxo1ISkoCAPj4+OCLL76ApaWlRoMjhFShis6hVxXz1qlbNzhYN+YAJITUSmp3GD9//jw8PT0RFRWF58+f4/nz51i2bBk8PT1x8eLFqoiREFIVKjqHXlXMW6duXXXjIIQQDVL7zNO4cePQvXt3rF+/Hvr60s2Li4sxbNgwhIeH46+//tJ4kISQKlDROfSqYu69itTV5hyAhJBaTe0+T8bGxrh06ZLcIJk3btxAixYtkJ+fr9EAtYH6PJFaoaJjKKmzHVA1dUv2eaIxoAgh/6ez4zxZWFjg/v37cuXp6ekwNzfXSFCEkGogFEpv5wdUH9dJ3e2qqm5l4ieEkEpSO3n69NNPMXToUOzcuRPp6elIT0/Hjh07MGzYMPRXdb4rQohu6N1beju/iwu/3NW17Nv81dmuqupWJn5CCKkEtS/bFRYWYuLEiVi7di2Ki4sBAAYGBvj666+xYMECiESiKgm0OtFlO1LrVHQ+t8rMW6epupWJnxDyVtH5cZ7y8/ORmpoKAPD09ISJiYlGA9MmSp4IIYSQmkenx3kCABMTEzRt2lSTsRBCCCGE6DyVkqfevXsjNjYWFhYW6F1OH4K4uDiNBEYIIYQQootUSp4sLS0h+P/dKxYWFtzvhBBorr9NZdupzPa60neJEEJqAkbk5OTkMAAsJydH26EQXbd3L2OuroxJRxqSLq6u0vLqbKcy26uzbVXVJYQQDaiu72+1k6cOHTqwFy9eyJXn5OSwDh06aCImraPkiahk717GBAJ+cgBIywQC9RKfyrRTme3V2baq6hJCiIZU1/e32nfb6enpISsrC/b29rzyx48fw8XFBUVFRRo7K6YtdLcdKZdsdGtlE9OqOrp1ZdupzPbqbAtUTV26hEcI0SCdu9vu6tWr3O83btxAVlYW91gsFuPw4cNwKT1QHSFvq4QE5ckBID3Pkp4urRccXOl2js9MgLBTsHyXocrEoc62QNXULeu5IYQQHaVy8tS8eXMIBAIIBAJ07NhRbr2xsTFWrlyp0eAI0VmZmZqpp2I7G+ZmYsdc6Qmb5ctLDJxdmTg0dQzVUZcQQnSIysnT3bt3wRhDvXr1cO7cOdjZ2XHrDA0NYW9vDyGdgie1hZOTZuqp2E4mpPUyMoA+fUrMPFKZODR1DNVRlxBCdEiFRxh/m1GfJ1IecaEYj0w84CjOgB7k/4QkECBT6ArH/LsQGqrQ5ykjQ3o5S0E7D+CKurgLCaTt8LoMoeztVerzpMq2QNXUpX+4CCEaVF3f32pPDDx//nxs2rRJrnzTpk1YuHChRoIiRNclnBJilHg5AGmCU5Ls8WhxNBJOlZMcCIXS63CANKlQ0E44ornECSjVvaiM7bnH0dGKkxR1tq2quoQQUgOpnTz9+OOPaNSokVy5j48P1q5dq5GgCNF1mZnAPvRGH+xBBvg3SjyAK/pgD/aht2rdenr3ll6Hc1HejrIYytoerq4lru+pt2+F21ZVXUIIqWHUvmxnZGSEpKQk1K1bl1d+584dNG7cGAUFBRoNUBvosh0pT3w80KGD9Hc9iBGIBDghE5lwQgICuTNFJ06ocUPZ/0fjvnE8EyPn8ttRRK5tGmGcEFLL6dxQBTJubm5ITEyUS54SExPh7OysscAI0WWBgdKTKBkZgIQJcRLBvPWybj2BgWo0KhQCwcFoGAikxgIsA1DQnUp52//fvkLU2baq6hJCSA2h9mW74cOHIzw8HDExMbh37x7u3buHTZs2Ydy4cRg+fHhVxEiIzqnKbj3UZYgQQnSb2meeJk6ciGfPnmHkyJEoLCwEIL2UN3nyZEydOlXjARKiq2TdesaO/W9MSD2I8bFtAiYMzESAtRMgVu0y1a1bt/Dq1SvpZa5Ll+Dx9CnWjbDF9Dg/ZD0RAjAHUB+urtLEqdJdhujSGyGEVFiFhyrIzc1FUlISjI2NUb9+fYhEIk3HpjXU54moQ5ZbCA/EoeW2sTB6UmJ0bblRLeXdunULDRo0KHc/W7akoH//+pXPW+Li+BlfWXGqU5cQQrSsur6/aZwnBSh5ImqLi5OOXln6z0l2na2MO8wuXrwIf39/LHRygqeh/D8hqYVvMDkzExcuXMC7775bfXFW4pgIIUQbdKrDeO/evREbGwsLCwv0LufDMi4uTiOBEVJjiMXSszOK/g9hTJpshIcDPXoon9wXgKehCI2NjMreT3XFCVTumAgh5C2mUvJkaWkJwf//27S0tKzSgAipcSo7SfClS6rt59IloGXLCoUIoOomAqa76QghtYxKyVNMTIzC3wkhqPwEu0+fqra9qvXU3X9F66lblxBC3hJq321HCCmlkhPsXrxvq9r2tirWU3P/Fa6nbl1CCHlLqJQ8+fn5cZftynPx4sVKBURITSNuG4hHQtfyJwluGyg3XrhYDEyP81NtR34q1lOm5MieZU3YKxt9U526hBBSi6g0SGbPnj3Ro0cP9OjRA6GhoUhNTYVIJEJwcDCCg4NhZGSE1NRUhIaGVnW8hOicsicJBgCGteJhXFci3rYJ+P84TtK76m4UFMgtqYVvpJUr2zGbJvclhBCNUHuogmHDhsHJyQlz5szhlUdGRiI9PR2bNm3SaIDaQEMVEHVs3w4MGAD0QhyWYyzcoLijdZ61K0zX88dHkm57C0D54zylpKSgfv36lQ9Y0dhNbm6KR99Upy4hhGiZzo7zZGlpifPnz8t9iN+6dQstWrRATk6ORgPUBkqeiDpKTxL8LeZhNiIBgHceikEgPWlTYnyk/7a9BeAVBBDDD5dgi6d4Cltcgh8YhNiyxRyffaaBxEmGRhgnhLyFdGqcp5KMjY2RmJgolzwlJibCqKwxagh5S5XsSgQGjMB6MMhfExeAAeCPj/TftvXBmHQe4Iv4bzgCgQBwcwX699dw0DS5LyGEVJjayVN4eDi+/vprXLx4EQEBAQCAs2fPYtOmTZg+fbrGAyRE18m6B/XpA7yHBKWX7QDIjY9UcluBgN83m7oWEUKIblI7eZoyZQrq1auH5cuXY+vWrQAAb29vxMTEoG/fvhoPkJCaQDZJ8J/DM4HnKmxQYnwkRRMMA9DcJMCEEEI0iua2U4D6PJGKEh+PhzCkQ/kVT5yQuxRGXYsIIaRydLbPEwBkZ2djz549uHPnDiZMmABra2tcvHgRDg4OcHFx0XSMhNQYwmA1x1IquS11LSKEkBpBpXGeSrp69SoaNGiAhQsXYvHixcjOzgYgnRB46tSpmo6PkJqFxkcihJC3ntpnniIiIjB48GAsWrQI5ubmXPkHH3yAAQMGaDQ4Qmqk/3diYmPHQlCiExNzcYVgebTCTky3bt3Cq1evIBZL5/99+lQ6G4ufnzTPMjc3L3eMp8pc9iu9bdu2wKlTdAmREEIUUTt5+ueff/Djjz/Klbu4uCArK0sjQRFS08WhN8axHqiLBDghE5lwwl0WiCgIUTp1unXrFho0qNwgmYrGsnR1lZ4EK6/DuaJthUJpQqVuW4QQUhuonTyJRCK8fPlSrjwlJQV2dnYaCYqQmiwuTjr0AGNC3EcwVy54KC0vMUYmAODVq1cAgK29jOFtJ38lPemJBJ/te83VU74/fnlGhuL9qbJtycRJ1bYIIaS2ULvPU/fu3TF79mwUFRUBAAQCAe7fv4/Jkyfj448/1niAhNQkYrH0LI6ivuKysvBwfnIi+93bTg/vOgnlFllCVTqhqej+VNlW3bYIIaQ2UTt5Wrp0KXJzc2Fvb4/Xr18jKCgIXl5eMDc3x7x586oiRkJqjIQE/uWv0kqOkSlz6ZJqbSuqV5H9qbqtOm0RQkhtovZlO0tLSxw9ehSJiYm4cuUKcnNz8e677yIkJKQq4iOkRikx9qXK9Z4+VW0bRfUqsj91t9XUdoQQ8rZQK3kqKiqCsbExLl++jHbt2qFdu3ZVFRchNZKTk/r1bG1V20ZRvYrsT91tNbUdIYS8LdS6bGdgYIB33nkHYg12evjhhx/g4eEBIyMjtGrVCufOnVNa9/r16/j444/h4eEBgUCA6OhouTozZ86EQCDgLY0aNdJYvISURTbRb+khnmQEAsDNjT9Gpp+fam0rqleR/am6rTptEUJIbaJ2n6dp06bh22+/xfPnqkzgVbadO3ciIiICkZGRuHjxInx9fREaGorHjx8rrJ+fn4969ephwYIFcHR0VNquj48PMjMzueXvv/+udKyEqKIiY2TKfk96IsHFTLHckvREwqtX2f2psm1pNL4nIYSUwNTUvHlzZmZmxkQiEWvQoAHz8/PjLeoICAhg33zzDfdYLBYzZ2dnNn/+/HK3dXd3Z1FRUXLlkZGRzNfXV604SsvJyWEAWE5OTqXaIbXX3r2MuboyJu1mLV3c3KTlpaWkpDAA5S4pKSka2Z8q2wqFFWuLEEK0qbq+v9XuMN6jRw8IVD3PX4bCwkJcuHCBN6WLnp4eQkJCcPr06Uq1fevWLTg7O8PIyAht2rTB/Pnz8c477yit/+bNG7x584Z7rGgcK0LU0bs30KOHaiN+169fHykpKZUaYVyd/amyLY0wTgghyqmdPM2cOVMjO3769CnEYjEcHBx45Q4ODkhOTq5wu61atUJsbCwaNmyIzMxMzJo1C4GBgfj3339508mUNH/+fMyaNavC+yREEXUm+i2ZGLVsWfX7U2VbmqSYEEIUU7nPU15eHr7++mu4uLjAzs4O/fr1w5MnT6oytgrp2rUrPvnkEzRr1gyhoaH47bffkJ2djV27dindZurUqcjJyeGW9PT0aoyYEEIIITWJymeepk+fji1btmDgwIEwMjLC9u3bMWLECOzbt69CO7a1tYVQKMSjR4945Y8ePSqzM7i6rKys0KBBA9y+fVtpHZFIBJFIpLF9ElLTVHRSYVW2q8yExYQQootUPvO0b98+xMTE4Mcff8Ty5cvx+++/49ChQyguLq7Qjg0NDeHv74/jx49zZRKJBMePH0ebNm0q1KYiubm5SE1NhRMNTkOIQnFxgIcH0KEDMGCA9KeHh7S8sttVtG1CCNFlKidPDx484A2K6e/vDwMDAzx8+LDCO4+IiMD69euxefNmJCUl4euvv0ZeXh6GDBkCABg0aBCvQ3lhYSEuX76My5cvo7CwEBkZGbh8+TLvrNKECRNw8uRJpKWl4dSpU+jVqxeEQiH69+9f4TgJeVvJJgYuPU2LbCJgZUmOKttVtG1CCNF1Kl+2k0gkMDAw4G+sr1+pATM//fRTPHnyBDNmzEBWVhaaN2+Ow4cPc53I79+/Dz29//K7hw8fwq/ESIFLlizBkiVLEBQUhPj4eADSJK9///549uwZ7Ozs0L59e5w5cwZ2dnYVjpOQt1F5kwoLBNKJgHv04F9mU2W7sWP/e6xO24QQUhMIGFNlTnXpMAJNmjSBvv5/+dbVq1fRqFEjGBoacmUXL17UfJTV7OXLl7C0tEROTg4sLCy0HQ4hVSI+XnoZrTwnTvDvvFN1O1WUbpsQQiqjur6/VT7zFBkZKVfWo0cPjQZDCKk+FZ1UWJMTA9Mkw4SQmqhSyRMhpOaq6KTCmrz3gu7jIITURGrPbUcIeTtUdFJhVbZzda34hMWEEKLrKHkipJaq6KTCqmy3fHnFJywmhBBdR8kTeTuIxdKezNu3S39W4i7Q2qR3b2DPHsDFhV/u6iot79274ttVtG1CCNF1Kt9tV5vQ3XY1TFyc9N74kgMKubpKT33QN7RKaIRxQsjboLq+vyuVPBUUFMDIyEiT8egESp5qENlIjKXfxrJrQ3SKgxBCao3q+v5W+7KdRCLBnDlz4OLiAjMzM9y5cweAdO67jRs3ajxAQpQqb7RGQDoSI13CI4QQokFqJ09z585FbGwsFi1axBscs0mTJtiwYYNGgyOkTAkJ8nN/lMQYkJ4urUd4KtNFrKLbqrIddV0jhNQEaidPP/30E9atW4eBAwdCWKLjgq+vL5KTkzUaHCFlqugoj7VcZSbrpUmECSGkAslTRkYGvLy85MolEgmKioo0EhQhKqnoKI+1WGUm66VJhAkhRErt5Klx48ZIUHAZZM+ePbxJewmpauK2gXgodIUEikdilECADKEbxG1pJEagcl3EKrqtKtuNHUtd1wghNYvK07PIzJgxA2FhYcjIyIBEIkFcXBxu3ryJn376CYcOHaqKGAlRKOGUECvEy7EHfSCBAHr479tXllCNFkdjzCkhTT4L9bqIlX6+KrqtKtuVtb68uAghRBvUPvPUo0cP/PLLLzh27BhMTU0xY8YMJCUl4ZdffkHnzp2rIkZCFMrMBPahN/pgDzLAH4nxAVzRB3uwD72py9P/VaaLGE0iTAgh/1H7zBMABAYG4ujRo5qOhRC1yLoy7UNvHEAPBCIBTshEJpyQgEBIIOTVq+0q00WMJhEmhJD/qD1I5rBhw/DZZ58h+C0+f06DZNYMYrH0bqyMDMX9ZWQT1N69SyNaA5V7viq6rSrbyaZvodeREFJZOjtI5pMnT9ClSxe4ublh4sSJuHz5chWERUj5KjqxbW1VmeeLJhEmhJD/qJ08HThwAJmZmZg+fTr++ecf+Pv7w8fHB99//z3S0tKqIERClKPJZ9VTmeeLJhEmhBCpSk8M/ODBA2zfvh2bNm3CrVu3UFxcrKnYtIYu29U8NPmseirzfNEkwoQQXVVd398V6jAuU1RUhPPnz+Ps2bNIS0uDg4ODpuIitYVsPo74eOnj4GDpouY3plBIt7GrozLPV0W3VWU7eh0JITWB2pftAODEiRMYPnw4HBwcMHjwYFhYWODQoUN4UN6ALYSUFBcHODgAISHA3LnSJSREWkZDShNCCNFRap95cnFxwfPnz9GlSxesW7cO3bp1g0gkqorYyNssLg74+GMwQG58cPbsGQQffwzs3UudXXSArlziA/hlbdsCp06V37YmLwUWFgKrVwOpqUDdukDTpsDTp3SJkZBah6lp3bp17MWLF+puVqPk5OQwACwnJ0fbobydiosZc3FhEumd6QoXCcCYq6u0LtGavXulL0PJl8fVVVpeVdsq2s7GRrqULBMKy2+7MvGXNnGi/D410S4hRHOq6/u70h3G30bUYbyKxccDHTqoVvfECeoEoyWyyXpLf0LIhg8o6y64im6rbDtVlG67MvGXNmkSsHixevsnhFS/6vr+Vil56t27N2JjY2FhYYHe5XwqxL0FfVUoeapakm3boffZANXqbv0ZegP7V3FEpDTZ4JbKujGqMqCmutuWt50qZG3fvg14elYs/tIKCwETE9UmJqYBPQnRLp0aJNPS0hKC//9bZWFhAUtLS6ULIeW5+kT1eTbUqUs0R52JgDW1bXnbqULW9urVFY+/tNWrVUuc1G2XEFJzqdRhPCYmhvs9Nja2qmIhtUSyXSBs4AJXZMh1FpdhANLhimS7QDSvxtiIVE2fRDg1tWIxVKYtddslhNRcag9V0LFjR2RnZ8uVv3z5Eh07dtRETOQt5+gixFisAIM0SSpNVhaO5XB0oWsf2lDTJxH29KxYDJVpS912CSE1l9odxvX09JCVlQV7e3te+ePHj+Hi4oKioiKNBqgN1OepaonFgLs7EJARh3UYAVs8461/Aht8iXX4x7U30tKo74g26OIkwqoo3edJE5MNU58nQmoOnRth/OrVq9zvN27cQFZWFvdYLBbj8OHDcCk9MRUhCgiFwIoVwMcf98YB9EAQ4hGMeABAPIJxEsGQQIi9y+kLSFtkE/r26SNNCEomIKpOIqzutmVtp4qSbRsaVjz+0gwNgYgI1e+2o0mMCakFVB7TQCBgenp6TE9PjwkEArnFxMSEbdy4sWoGVKhmNM5T9di7V37sHtmYPjRejm5QNE6Sm1vFx3lSZduKjvOkqO3KxF9aeeM8VbRdQojm6Nw4T/fu3QNjDPXq1cO5c+dgZ2fHrTM0NIS9vT2Eb8m/W3TZrvpoaGo7UoVohPH/0AjjhOg2nRrnqbah5IkQQgipeXSqz9PBgwfRtWtXGBgY4ODBg2XW7d69u0YCI4QQQgjRRSqdeSp5h52envLRDQQCAcSqjianw2r9mSdNXucghBBCqolOnXmSSCQKfydvobg4sLFjISgxPDNzdYVg+XKasIvorPLyfVX/H9Dk/w0l25KN7PL4Mf0/QsjbQOWhCsqSnZ0NKysrTTRFtCkuDuzjPmBgvJG/2YMM4OM+EOylGU+J7omLA8aO5U/H4uoqHapANkFwWetVbaeyMZVU0XYJIbpB7RHGFy5ciJ07d3KPP/nkE1hbW8PFxQVXrlzRaHCkGonFyB8xFgxM7k2hBwYGIH9EuOqTfBFSDeLipGM5lU5SMjKk5ZMmlb1eNo95ee2oM9+5srYq2y4hRHeofbdd3bp1sW3bNrRt2xZHjx5F3759sXPnTuzatQv379/HkSNHqirWalMb+zyJj8dDGNKh/HrHTkDYKbjqAyKkHLIRyctKUoRC5fl+6dHIlbWjzqjhqsRUkXYJIaqpru9vtc88ZWVlwc3NDQBw6NAh9O3bF++//z4mTZqEf/75R+MBkupxM161mUxVrUdIVUtIKD9JKetEKWNAerp03Kay2pHVS0jQTEwVaZcQolvUTp7q1KmD9PR0AMDhw4cREhICAGCMvRV32tVWmVBtJlNV6xFS1TI1lMenpmpufxWJSVPHQQipPmonT71798aAAQPQuXNnPHv2DF27dgUAXLp0CV5eXhoPkFQPYXAg0uEKCa+r+H8kEOA+3CAMDqzmyAhRzElDebynp+b2V5GYNHUchJDqo3byFBUVhVGjRqFx48Y4evQozMzMAACZmZkYOXKkxgMk1SMwWIjZNssBQC6Bkj2eaxONwGDqnEF0Q2CgtM+QQHG+D0Dal0jZeoEAcHMDRo4sux1ZvUAV/m9QJaaKtEsI0S1qJ08GBgaYMGECli9fDj8/P6583LhxGDZsmEaDI9VHKAS6ruuNT7AHGXDhrXsAV3yCPeiyrjd1bCU6QyiU3u4PyCcrAoF0iYhQvh4AoqMBQ8Oy25HVU+W9X1ZMlWmXEKJb1E6eACA1NRWjR49GSEgIQkJCMGbMGNy5c0fTsZFq1rs3MHBvb7R3SUMwTqA/fkYwTuA917sYuLc3jUlDdE7v3sCePYALP9+Hq6u0fNGistfL3tPltaPOe19ZW5VtlxCiO9QequCPP/5A9+7d0bx5c7Rr1w4AkJiYiCtXruCXX35B586dqyTQ6lQbhyooiWZnITUNjTBOCAGq7/tb7eTJz88PoaGhWLBgAa98ypQpOHLkCC5evKjRALWhtidPhBBCSE2ks8mTkZERrl27hvr16/PKU1JS0KxZMxQUFGg0QG3QWvJEp3wIIYSQCtOpiYFLsrOzw+XLl+WSp8uXL8Nedm6aqI8m5CWkWqnzv0pVXM7LyACePAHs7KT9o+h/JUJqDrWTp+HDh2PEiBG4c+cO2rZtC0Da52nhwoWIkN3aQtRDE/ISUq3UmQS4uiYMpsmCCak51L5sxxhDdHQ0li5diocPHwIAnJ2dMXHiRIwZMwYCVQY40XHVetlOLEa+gweMnj1QeOujBAIU2LjC5BFNgEWIJsgm7i39ySf76Cp5F5w6dSu639Lt0l14hFSczvZ5evPmDYqLi2FqaopXr14BAMzNzaskOG2pzuSJJuQlpPqUN3Fvycl6AdXramrCYJosmJDK0bmJgZ88eYKuXbvCzMwMFhYWaN26NR4/flzpxOmHH36Ah4cHjIyM0KpVK5w7d05p3evXr+Pjjz+Gh4cHBAIBoqOjK92mttGEvIRUn/Im7i05Wa86dSu734q0SQjRHpWTp8mTJ+Py5cuYPXs2lixZguzs7EqPKL5z505EREQgMjISFy9ehK+vL0JDQ/H48WOF9fPz81GvXj0sWLAAjo6OGmlT22hCXkKqj6qT8GZmqldXU/utaH1CSDVjKnJ1dWWHDx/mHqekpDChUMgKCgpUbUJOQEAA++abb7jHYrGYOTs7s/nz55e7rbu7O4uKitJomzI5OTkMAMvJyVF5m4o6cayY3YcrE0PAmPQfT94ihoDdgxs7cay4ymMh5G134oTCPzO55cQJ9epqar/qtEkIkVdd398qn3l6+PAhfH19ucf169eHSCRCZgX/RSosLMSFCxcQEhLClenp6SEkJASnT5+u1jbfvHmDly9f8pbqQhPyElJ9ypu4t+RkverUVXW/5aHJggmpGdSa205YqgejUCgEU6+/Oefp06cQi8VwcHDglTs4OCArK6ta25w/fz4sLS25xc3NrUL7rwiakJeQ6lPeZMLAf5P1qlNX1f2qcjMyTRZMiO5TOXlijKFBgwawtrbmltzcXPj5+fHKaqKpU6ciJyeHW9LT06t1/zQhLyHVR51JgKtiwmBlZ6Dc3GiYAkJqCpUHyYyJidHojm1tbSEUCvHo0SNe+aNHj5R2Bq+qNkUiEUQiUYX2qSm9ewM9egiRkBBMs7MQUsWkf2+qjRquTl119ksjjBNSc6mcPIWFhWl0x4aGhvD398fx48fRs2dPAIBEIsHx48cxatQonWmzOgmFQHCwtqMgpHZQ5+9Nk3+b9HdOSM2n9vQsmhQREYGwsDC0aNECAQEBiI6ORl5eHoYMGQIAGDRoEFxcXDB//nwA0g7hN27c4H7PyMjA5cuXYWZmBi8vL5XaJIQQQgipDK0mT59++imePHmCGTNmICsrC82bN8fhw4e5Dt/379+Hnt5/3bIePnwIPz8/7vGSJUuwZMkSBAUFIT4+XqU2CSGkLLowYfCjR8CzZ4CenvQsVdu2wI8/AqmpgKcnMHIkYGhY4UMkhFSS2tOz1AbVOrcdIURn6OKEwYoIhUBEBLBokXr7IeRtp3PTsxBCyNtMNnFv6QQmI0NaHhdXsboV3W9ZxGJg8WJg0iTVtyGEaE6lzjzJNhWoMnhJDUJnngipXXR9wmBlhEIgP58u4REio9NnnjZu3IgmTZrAyMgIRkZGaNKkCTZs2KDp2AghpFro+oTByojFwOrVFd+eEFIxancYnzFjBpYtW4bRo0ejTZs2AIDTp09j3LhxuH//PmbPnq3xIAkhpCppchJgdepqYgLg1NTKt0EIUY/aydOaNWuwfv169O/fnyvr3r07mjVrhtGjR1PyRAipcZycNFtP1brqtKeMp2fl2yCEqEfty3ZFRUVo0aKFXLm/vz+Ki4s1EhQhhFQnXZ8wWBmhUDpsASGkeqmdPH3++edYs2aNXPm6deswcOBAjQRFCCHVqSZMGKxIRAR1FidEG9S+22706NH46aef4ObmhtatWwMAzp49i/v372PQoEEwMDDg6i5btkyz0VYTutuOkNpJ0XhLbm7SZEiVcZ6U1a3IfstC4zwRolh1fX+rnTx16NBBtYYFAvz5558VCkrbKHkipPaiEcYJqbl0NnmqDSh5IoQQQmoenR7niRBCCCGktlJ7qIIOHTqUOaJ4Tb1URwghhBCiCrWTp+bNm/MeFxUV4fLly/j3338RFhamqbgIIYQQQnSS2slTVFSUwvKZM2ciNze30gERQgghhOgyjfV5+uyzz7Bp0yZNNUcIIYQQopM0ljydPn0aRkZGmmqOEEIIIUQnqX3Zrnep0d8YY8jMzMT58+cxffp0jQVGCCGEEKKL1E6eLC0teY/19PTQsGFDzJ49G++//77GAiOEEEII0UVqJ08xMTFVEQchhJBSXr9+jaioKIwbNw7GxsbaDocQ8n9qJ08yFy5cQFJSEgDAx8cHfn5+GguKEEIIsHfvXkybNg3u7u408TohOkTt5Onx48fo168f4uPjYWVlBQDIzs5Ghw4dsGPHDtjZ2Wk6RkIIqZV27d4NANi9ezclT4ToELWTp9GjR+PVq1e4fv06vL29AQA3btxAWFgYxowZg+3bt2s8SEIIqQ0ePXqEqKgoFBUVAQD++OMI9C0d8PvhPzB+/HgAgIGBASIiImBvb6/NUAmp1dSeGNjS0hLHjh1Dy5YteeXnzp3D+++/j+zsbE3GpxU0MTAhRBsuX76M1m3a4E1BAfSNzWBQxwmWnb5CzvG1KHqRieLXuRAZGeHM6dNysz0QQnR4YmCJRAIDAwO5cgMDA0gkEo0ERQghtVHz5s1x4fx5eDf2ASsuglmbfhA5N4RZm35gxUXwbuyDC+fPU+JEiJapnTx17NgRY8eOxcOHD7myjIwMjBs3Dp06ddJocIQQUtv4+Pgg8e8EMHER3qRfx8vzB/Am/TqYuAiJfyfAx8dH2yESUuupnTytWrUKL1++hIeHBzw9PeHp6Ym6devi5cuXWLlyZVXESAghtcpff/0FiUSCVxd+wYvj6/Hqwi+QSCRISEjQdmiEEFQgeXJzc8PFixfx66+/Ijw8HOHh4fjtt99w8eJFuLq6VkWMhBBSq8TFxQEA2rVtg9OnT6Ntm9a8ckKIdql1t11RURGMjY1x+fJldO7cGZ07d66quAghpNby9/eHj48Pxo8fD6FQiJPxJ7B06VKaP5QQHaFW8mRgYIB33nkHYrG4quIhhJBab8yYMbzHQqEQkyZN0lI0hJDS1L5sN23aNHz77bd4/vx5VcRDCCGEEKLT1B4kc9WqVbh9+zacnZ3h7u4OU1NT3vqLFy9qLDhCCCGEEF2jdvLUs2fPKgiDEEIIIaRmUHuE8dqARhgnhBBCap7q+v5W+8yTzKtXr1Ay79LT04OZmZlGgiKEEEII0VUqdxi/fPkyPvjgA+6xs7Mz6tSpwy1WVlb4559/qiRIQgghhBBdofKZp5UrV6J9+/a8si1btsDFxQWMMWzatAkrVqzAli1bNB4kIYQQQoiuUDl5OnXqFEaNGsUra926NerVqwcAMDY2Rt++fTUbHSGEEEKIjlH5st29e/dgZ2fHPZ49ezZsbW25x05OTnj06JFmoyOEEEII0TEqJ09GRka4d+8e93jcuHG8nuzp6ekwMTHRbHSEEEIIITpG5eTJz88P+/fvV7o+Li4Ofn5+moiJEEIIIURnqdznaeTIkejXrx88PDzw9ddfQ09PmneJxWKsXr0aK1euxM8//1xlgeoisViMoqIibYdBCNEiQ0ND7vOQEFI7qDVI5uTJk7F48WKYm5tzHcXv3LmD3NxcREREYPHixVUWaHUqb5AtxhiysrKQnZ1d/cERQnSKnp4e6tatC0NDQ22HQkitV12DZKo9wviZM2ewfft23Lp1CwBQv3599O/fH61bt66SALWhvCc/MzMT2dnZsLe3h4mJCQQCgRaiJIRom0QiwcOHD2FgYIB33nmHPgsI0TKdHWG8devWb1WipC6xWMwlTjY2NtoOhxCiZXZ2dnj48CGKi4thYGCg7XAIIdWALtSrSdbHie4sJIQA4C7XicViLUdCCKkulDxVEJ2eJ4QA9FlASG1EyRMhhBBCiBrUSp4YY7h//z4KCgqqKh5SC8ycORPNmzfXdhgApGcNyhq/jFSfZ8+ewd7eHmlpaVXSfmxsLKysrNTapl+/fli6dGmVxEMIqbnUTp68vLyQnp5eVfGQKjJ48GAIBAK55fbt21W6X0XJyYQJE3D8+PEq2Z+HhwcEAgF27Nght87HxwcCgQCxsbFcWWZmJrp27Volseiyku8BCwsLtGzZEgcOHFCrjbS0NAgEAly+fFkjMc2bNw89evSAh4cHACA+Ph4CgUBjQ4J8+umnSElJUWub7777DvPmzUNOTo5GYiCEvB3USp709PRQv359PHv2rKriqTXEYiA+Hti+XfqzOvqadunSBZmZmbylbt26cvUKCwurNA4zM7NK36lY1uCkbm5uiImJ4ZWdOXMGWVlZMDU15ZU7OjpCJBJVKpaK0IXBVWNiYpCZmYnz58+jXbt26NOnD65du6aVWPLz87Fx40YMHTpU7W1Vfb8aGxvD3t5erbabNGkCT09PbN26Ve24CCFvL7X7PC1YsAATJ07Ev//+WxXx1ApxcYCHB9ChAzBggPSnh4e0vCqJRCI4OjryFqFQiODgYIwaNQrh4eGwtbVFaGgoAODkyZMICAiASCSCk5MTpkyZguLiYq694OBgjBkzBpMmTYK1tTUcHR0xc+ZMbr3sDEKvXr0gEAi4x4ou223YsAHe3t4wMjJCo0aNsHr1am6d7AzHzp07ERQUBCMjI2zbtk3pcQ4cOBAnT57knSHdtGkTBg4cCH19/ugcJc+MyfYTFxeHDh06wMTEBL6+vjh9+nSZz2tycjLat28PIyMjNG7cGMeOHVPYbun4JRIJZs+eDVdXV4hEIjRv3hyHDx/m2lV05uXy5csQCATcpS3Zpaj9+/ejfv36MDIyQmhoqEpnh62srODo6IgGDRpgzpw5KC4uxokTJ7j1hw8fRvv27WFlZQUbGxt89NFHSE1N5dbLEm8/Pz8IBAIEBwdz68p6PRX57bffIBKJuGFQ0tLS0KFDBwBAnTp1IBAIMHjwYABQ+n5dtmwZmjZtClNTU7i5uWHkyJHIzc3l9lH6sp3sfbhlyxZ4eHjA0tIS/fr1w6tXr3ixdevWTeGZTEJI7aV28jRo0CCcO3cOvr6+MDY2hrW1NW8hZYuLA/r0AR484JdnZEjLqzqBUmbz5s0wNDREYmIi1q5di4yMDHzwwQdo2bIlrly5gjVr1mDjxo2YO3eu3HampqY4e/YsFi1ahNmzZ+Po0aMAgH/++QfAf2c4ZI9L27ZtG2bMmIF58+YhKSkJ33//PaZPn47Nmzfz6k2ZMgVjx45FUlIS94WpiIODA0JDQ7nt8/PzsXPnTnzxxRcqPRfTpk3DhAkTcPnyZTRo0AD9+/fnJY0licVi9OzZEyYmJjh79izWrVuHadOmKaxbOv7ly5dj6dKlWLJkCa5evYrQ0FB0796dG4BWVfn5+Zg3bx5++uknJCYmIjs7G/369VN5++LiYmzcuBEAeKNk5+XlISIiAufPn8fx48ehp6eHXr16QSKRAADOnTsHADh27BgyMzMR9/83r6qvZ0kJCQnw9/fnHru5uWHv3r0AgJs3byIzMxPLly/n1pd+vwLSM+MrVqzA9evXsXnzZvz555+YNGlSmceempqK/fv349ChQzh06BBOnjyJBQsW8OoEBATg3LlzePPmTdlPJCGk9mBqio2NLXOpiFWrVjF3d3cmEolYQEAAO3v2bJn1d+3axRo2bMhEIhFr0qQJ+/XXX3nrw8LCGADeEhoaqnI8OTk5DADLycmRW/f69Wt248YN9vr1a5XbkykuZszVlTFA8SIQMObmJq2naWFhYUwoFDJTU1Nu6dOnD2OMsaCgIObn58er/+2337KGDRsyiUTClf3www/MzMyMicVibrv27dvztmvZsiWbPHky9xgA27dvH69OZGQk8/X15R57enqyn3/+mVdnzpw5rE2bNowxxu7evcsAsOjo6HKP093dnUVFRbH9+/czT09PJpFI2ObNm7njs7S0ZDExMQrjk+1nw4YN3Prr168zACwpKUnh/n7//Xemr6/PMjMzubKjR48qbLd0/M7OzmzevHm8spYtW7KRI0cyxhg7ceIEA8BevHjBrb906RIDwO7evcsYYywmJoYBYGfOnOHqJCUlMQBl/h0BYEZGRszU1JTp6ekxAMzDw4M9e/ZM6TZPnjxhANi1a9d4x3Xp0iVevfJeT0V69OjBvvjiC16ZouNnTPH7VZHdu3czGxsb7nFMTAyztLTkHkdGRjITExP28uVLrmzixImsVatWvHauXLnCALC0tDSF+6nMZwIhRLPK+v7WJLVHGA8LC6tUslbazp07ERERgbVr16JVq1aIjo5GaGgobt68qbB/wqlTp9C/f3/Mnz8fH330EX7++Wf07NkTFy9eRJMmTbh6Xbp04fV70Ua/ltISEuTPOJXEGJCeLq1X4gqIxnTo0AFr1qzhHpfs/1Pyv34ASEpKQps2bXhj2LRr1w65ubl48OAB3nnnHQBAs2bNeNs5OTnh8ePHKseUl5eH1NRUDB06FMOHD+fKi4uLYWlpyavbokULldv98MMP8eWXX+Kvv/7Cpk2bVD7rBPCPycnJCQDw+PFjNGrUSK7uzZs34ebmBkdHR64sICBAYbsl43/58iUePnyIdu3a8eq0a9cOV65cUTlWANDX10fLli25x40aNYKVlRWSkpKUxgIAUVFRCAkJwZ07dzBu3DisWLGCd/b41q1bmDFjBs6ePYunT59yZ5zu37/P+1srSZ3Xs6TXr1/DyMhI5WMu/X4FpGfA5s+fj+TkZLx8+RLFxcUoKChAfn6+0kFtPTw8YG5uzj1W9P41NjYGID3DRwghQAWmZwGkp7pjYmKQmpqK5cuXw97eHr///jveeecd+Pj4qNXWsmXLMHz4cAwZMgQAsHbtWvz666/YtGkTpkyZIld/+fLl6NKlCyZOnAgAmDNnDo4ePYpVq1Zxp++B//r36JLMTM3WU5epqSm8vLyUrquI0tNRCAQC7ktWFbI+KevXr0erVq1464RCYYVj1NfXx+eff47IyEicPXsW+/btU3nbksckSx7VOSZl1H2O9fSkV9VZieknNdnR3NHREV5eXvDy8kJMTAw++OAD3Lhxg/unpVu3bnB3d8f69evh7OwMiUSCJk2alNlBW53XsyRbW1u8ePFC5dhLP5dpaWn46KOP8PXXX2PevHmwtrbG33//jaFDh6KwsFBp8qTK+/f58+cApNOwEEIIUIE+TydPnkTTpk1x9uxZxMXFcR+WV65cQWRkpFptFRYW4sKFCwgJCfkvID09hISEKO2ke/r0aV59AAgNDZWrHx8fD3t7ezRs2BBff/11mXcIvnnzBi9fvuQtVeH/JzE0Vq8qeXt74/Tp07wv7sTERJibm8PV1VXldgwMDMqctsLBwQHOzs64c+cO90UuWxTdCaiOL774AidPnkSPHj1Qp06dSrWlTMOGDZGeno5Hjx5xZcr6dpVkYWEBZ2dnJCYm8soTExPRuHFjAP99WWeWyKYVDQtQXFyM8+fPc49v3ryJ7OxseHt7q3wcAQEB8Pf3x7x58wBIx1y6efMmvvvuO3Tq1Ane3t5yyY2iaUkq+nr6+fnhxo0b5bavzIULFyCRSLB06VK0bt0aDRo0wMOHD1U7+HL8+++/cHV1ha2trUbaI4TUfGonT1OmTMHcuXNx9OhRXufSjh074syZM2q19fTpU4jFYjg4OPDKHRwckJWVpXCbrKyscut36dIFP/30E44fP46FCxfi5MmT6Nq1q9IP4fnz58PS0pJb3Nzc1DoOVQUGAq6ugLLZHAQCwM1NWk/bRo4cifT0dIwePRrJyck4cOAAIiMjERERwZ0RUYWHhweOHz+OrKwspWcWZs2ahfnz52PFihVISUnBtWvXEBMTg2XLllXqGLy9vfH06VO5YQs0qXPnzvD09ERYWBiuXr2KxMREfPfddwDKn7Zj4sSJWLhwIXbu3ImbN29iypQpuHz5MsaOHQsA8PLygpubG2bOnIlbt27h119/VThgo4GBAUaPHo2zZ8/iwoULGDx4MFq3bl3mJTtFwsPD8eOPPyIjIwN16tSBjY0N1q1bh9u3b+PPP/9EREQEr769vT2MjY1x+PBhPHr0iBsLqSKvZ2hoKK5fv857j7i7u0MgEODQoUN48uQJ78650ry8vFBUVISVK1fizp072LJlC+9MdGUkJCTg/fff10hbhJC3g9rJ07Vr19CrVy+5cnt7ezx9+lQjQVVWv3790L17dzRt2hQ9e/bEoUOH8M8//yA+Pl5h/alTpyInJ4dbqmoQUKEQkN0wVPp7VfY4OlpaT9tcXFzw22+/cXdWfvXVVxg6dCiXGKhq6dKlOHr0KNzc3ODn56ewzrBhw7BhwwbExMSgadOmCAoKQmxsbKXPPAGAjY0N12elKgiFQuzfvx+5ublo2bIlhg0bxt1tV14fnjFjxiAiIgLjx49H06ZNcfjwYRw8eBD169cHIE2Ktm/fjuTkZDRr1gwLFy6Uu9sRkE5SPXnyZAwYMADt2rWDmZkZdu7cqfaxdOnSBXXr1sW8efOgp6eHHTt24MKFC2jSpAnGjRuHxYsX8+rr6+tjxYoV+PHHH+Hs7IwePXoAqNjr2bRpU7z77rvYtWsXV+bi4oJZs2ZhypQpcHBwwKhRo5Ru7+vri2XLlmHhwoVo0qQJtm3bhvnz56v9HJRWUFCA/fv38/pvEUKI2nfbubi4sMTERMYYY2ZmZiw1NZUxxlhcXByrV6+eWm29efOGCYVCubuxBg0axLp3765wGzc3NxYVFcUrmzFjBmvWrFmZ+7K1tWVr165VKa6quttOZu9e+bvu3Nyk5aTm+/vvvxkAdvv27SrfV+k7yGqyQ4cOMW9vb+5uTl2wevVq1rlz5zLr0N12hOiO6rrbTu0zT/369cPkyZORlZXFda5MTEzEhAkTMGjQILXaMjQ0hL+/P2+qDolEguPHj6NNmzYKt2nTpo3c1B5Hjx5VWh8AHjx4gGfPnnF3Tmlb795AWhpw4gTw88/Sn3fvSstJzbNv3z4cPXoUaWlpOHbsGEaMGIF27drB09NT26HVKB9++CFGjBiBjIwMbYfCMTAwwMqVK7UdBiFE16ibbb1584YNGzaM6evrM4FAwAwMDJienh777LPPWHEFBijasWMHE4lELDY2lt24cYONGDGCWVlZsaysLMYYY59//jmbMmUKVz8xMZHp6+uzJUuWsKSkJBYZGckMDAy4sWdevXrFJkyYwE6fPs3u3r3Ljh07xt59911Wv359VlBQoFJMVX3mibxdNm/ezOrXr89EIhFzcXFhYWFh7OnTp9Wy77fpzFNNRZ8JhOiO6jrzJGCsxO1UakhPT8e1a9eQm5sLPz8/rp9GRaxatQqLFy9GVlYWmjdvjhUrVnC3OQcHB8PDw4M3mevu3bvx3XffIS0tDfXr18eiRYvwwQcfAJCOF9OzZ09cunQJ2dnZcHZ2xvvvv485c+bIdTRX5uXLl7C0tEROTg4sLCx46woKCnD37l3UrVtXrXFpCCFvJ/pMIER3lPX9rUkqJ08SiQSLFy/GwYMHUVhYiE6dOiEyMrJKO+NqCyVPhBBV0WcCIbqjupInlfs8zZs3D99++y3MzMzg4uKC5cuX45tvvqmywAghhBBCdJHKydNPP/2E1atX448//sD+/fvxyy+/cDPDE0IIIYTUFionT/fv3+f6FQFASEgIBAKBxkbxJYQQQgipCVROnoqLi+Wu5xsYGGh0ri1CCCGEEF2n8sTAjDEMHjwYIpGIKysoKMBXX33Fm6QzLi5OsxESQgghhOgQlc88hYWFwd7enjcH3GeffQZnZ2deGSHlmTlzJpo3b67tMIiOuXnzJhwdHfHq1asqab8i77vWrVtj7969VRIPIaQGq9JRpGqot3GQzLCwMAZAbrl161aV7heA3PQ7r169qrJBJN3d3RkAtn37drl1jRs3ZgBYTExMley7JgsKCuLeEyKRiNWvX599//33TCKRqNWOu7u73PRJqurVqxebO3cu91jTA4BW5H33yy+/MC8vrzKnjKmpnwmEvI10dnoWojmvX7/G999/j9evX1fL/rp06YLMzEzeomiy1sLCwiqNw8zMDDY2NpVqo6y+dm5uboiJieGVnTlzBllZWbxLzLqkqp9zVQwfPhyZmZm4efMmpk6dihkzZmDt2rXVsu/79+/j0KFDGDx4sNrbqvrcVeR917VrV7x69Qq///672nERQt5elDxp0d69ezFt2rRq6ycmEong6OjIW4RCIYKDgzFq1CiEh4fD1tYWoaGhAICTJ08iICAAIpEITk5OmDJlCoqLi7n2goODMWbMGEyaNAnW1tZwdHTEzJkzufUeHh4AgF69ekEgEHCPFV0+2bBhA7y9vWFkZIRGjRph9erV3Lq0tDQIBALs3LkTQUFBMDIywrZt25Qe58CBA3Hy5Emkp6dzZZs2bcLAgQOhr8/v5rds2TI0bdoUpqamcHNzw8iRI5Gbm8ut/+KLL9CsWTO8efMGgPSL2s/Pr8x5HF+9eoWBAwfC1NQUTk5OiIqKQnBwMMLDw3nPzZw5czBo0CBYWFhgxIgRAKTvCR8fH4hEInh4eGDp0qW8tgUCAfbv388rs7Ky4kbglz1XO3bsQNu2bWFkZIQmTZrg5MmTSuOVMTExgaOjI9zd3TFkyBA0a9YMR48e5danpqaiR48ecHBwgJmZGVq2bIljx45x64ODg3Hv3j2MGzcOAoEAAoGAW/f3338jMDAQxsbGcHNzw5gxY5CXl8et37VrF3x9feHi4gIAiI+Px5AhQ5CTk8O1JXtvKXvuJk+ejAYNGsDExAT16tXD9OnTeUl26ffd4MGD0bNnTyxZsgROTk6wsbHBN998w9tGKBTigw8+wI4dO8p9/gghtQclT1q0a/duANLpZrRt8+bNMDQ0RGJiItauXYuMjAx88MEHaNmyJa5cuYI1a9Zg48aNmDt3rtx2pqamOHv2LBYtWoTZs2dzX7j//PMPACAmJgaZmZnc49K2bduGGTNmYN68eUhKSsL333+P6dOnY/Pmzbx6U6ZMwdixY5GUlMQleIo4ODggNDSU2z4/Px87d+7EF198IVdXT08PK1aswPXr17F582b8+eefmDRpErd+xYoVyMvLw5QpUwAA06ZNQ3Z2NlatWqV0/xEREUhMTMTBgwdx9OhRJCQk4OLFi3L1lixZAl9fX1y6dAnTp0/HhQsX0LdvX/Tr1w/Xrl3DzJkzMX36dN7URKqaOHEixo8fj0uXLqFNmzbo1q0bnj17ptK2jDEkJCQgOTkZhoaGXHlubi4++OADHD9+HJcuXUKXLl3QrVs33L9/H4D0ZhFXV1fMnj2bO7MJSJOuLl264OOPP8bVq1exc+dO/P333xg1ahTXdkJCAlq0aME9btu2LaKjo2FhYcG1NWHCBKXPHQCYm5sjNjYWN27cwPLly7F+/XpERUWVeawnTpxAamoqTpw4gc2bNyM2Nlbu+Q4ICEBCQoJKzx0hpJao0ouCNVRV9XnKyspikydPZhERESwiIoIZioyYvqUDMxQZcWWTJ09mjx490sRh8ISFhTGhUMhMTU25pU+fPowxaX8XPz8/Xv1vv/2WNWzYkNfn5YcffmBmZmZc/4+goCDWvn173nYtW7ZkkydP5h5DQZ+nyMhI5uvryz329PRkP//8M6/OnDlzWJs2bRhjjN29e5cBYNHR0eUep6zPzf79+5mnpyeTSCRs8+bN3PFZWlqW2edp9+7dzMbGhld26tQpZmBgwKZPn8709fVZQkKC0u1fvnzJDAwM2O7du7my7OxsZmJiwsaOHcuLs2fPnrxtBwwYwDp37swrmzhxImvcuDH3WNHzWfKYZM/VggULuPVFRUXM1dWVLVy4UGncQUFBzMDAgJmamjIDAwMGgBkZGbHExESl2zDGmI+PD1u5ciXvuEr3eRo6dCgbMWIErywhIYHp6elxf0e+vr5s9uzZvDrK+jwpeu4UWbx4MfP39+cel37fhYWFMXd3d96E5p988gn79NNPee0cOHCA6enpKe33RH2eCNEd1dXnSeWhCkjlZWZmInr5crwpKIC+sRkMbNxg3ekr5BxfixVr1qH4dS5ERkbo168f7O3tNb7/Dh06YM2aNdzjkv1//P39eXWTkpLQpk0b3qWXdu3aITc3Fw8ePMA777wDAGjWrBlvOycnJzx+/FjlmPLy8pCamoqhQ4di+PDhXHlxcbHc3Zslz0yU58MPP8SXX36Jv/76C5s2bVJ41gkAjh07hvnz5yM5ORkvX75EcXExCgoKkJ+fDxMTEwBAmzZtMGHCBMyZMweTJ09G+/btle73zp07KCoqQkBAAFdmaWmJhg0bytUtfTxJSUno0aMHr6xdu3aIjo6GWCyGUChU+fjbtGnD/a6vr48WLVogKSmpzG0GDhyIadOm4cWLF4iMjETbtm3Rtm1bbn1ubi5mzpyJX3/9FZmZmSguLsbr16+5M0/KXLlyBVevXuVdamWMQSKR4O7du/D29sbr16/VmhdO0Xth586dWLFiBVJTU5Gbm4vi4uJy57by8fHhPa9OTk64du0ar46xsTEkEgnevHnzVs7lSQhRHyVP1ah58+a4cP48Pun7KVJu3YZZm34QOTeEWZt+eH5wEbwb+2D3rp3w8fGpkv2bmprCy8tL6bqKMDAw4D0WCARqTdkj61+0fv16tGrVireudLKgToz6+vr4/PPPERkZibNnz2Lfvn1yddLS0vDRRx/h66+/xrx582BtbY2///4bQ4cORWFhIZc8SSQSJCYmQigU4vbt2yrHUJ6KPOcCgQCs1Fzemhqo1tLSknt/7Nq1C15eXmjdujVCQkIAABMmTMDRo0exZMkSeHl5wdjYGH369Cm3w3Zubi6+/PJLjBkzRm6dLAm3tbXFixcvVI619HN3+vRpDBw4ELNmzUJoaCgsLS2xY8cOuT5jpany/n3+/DlMTU0pcSKEcCh5qmY+Pj5I/DsBtra2eJN+HcXZWRC/egYmLkLi3wmoU6eOtkMEAHh7e2Pv3r1gjHFnnxITE2Fubg5XV1eV2zEwMIBYLFa63sHBAc7Ozrhz5w4GDhxY6bhL+uKLL7BkyRJ8+umnCp/XCxcuQCKRYOnSpdDTk3b/27Vrl1y9xYsXIzk5GSdPnkRoaChiYmIwZMgQhfusV68eDAwM8M8//3CJQU5ODlJSUvDee++VGa+3tzcSExN5ZYmJiWjQoAGXSNrZ2XF9iQDg1q1byM/Pl2vrzJkz3P6Ki4tx4cIFXh+j8piZmWHs2LGYMGECLl26BIFAgMTERAwePBi9evUCIE2K0tLSeNsZGhrKvd7vvvsubty4oTRxBwA/Pz/cuHGj3LaUOXXqFNzd3TFt2jSu7N69eyptW55///0Xfn5+GmmLEPJ2oA7jWvDXX39BIpHg1YVf8OL4ery68AskEolOdUodOXIk0tPTMXr0aCQnJ+PAgQOIjIxEREQEl2iowsPDA8ePH0dWVpbSMwuzZs3C/PnzsWLFCqSkpODatWuIiYnBsmXLKnUM3t7eePr0qdywBTJeXl4oKirCypUrcefOHWzZskXu1vxLly5hxowZ2LBhA9q1a4dly5Zh7NixuHPnjsI2zc3NERYWhokTJ+LEiRO4fv06hg4dCj09Pd4lUEXGjx+P48ePY86cOUhJScHmzZuxatUqXkfpjh07YtWqVbh06RLOnz+Pr776Su7sCQD88MMP2LdvH5KTk/HNN9/gxYsXSi9dKvPll18iJSWFGySyfv36iIuLw+XLl3HlyhUMGDBA7iyNh4cH/vrrL2RkZODp06cApHfBnTp1CqNGjcLly5dx69YtHDhwgJfMhYaG4vTp07xkycPDA7m5uTh+/DiePn2qMEmUqV+/Pu7fv48dO3YgNTUVK1asUHi2sSISEhLw/vvva6QtQsjbgZInLZANTdCubRucPn0abdu05pXrAhcXF/z22284d+4cfH198dVXX2Ho0KH47rvv1Gpn6dKlOHr0KNzc3JT+9z5s2DBs2LABMTExaNq0KYKCghAbG6twDCp12djYKL3c4uvri2XLlmHhwoVo0qQJtm3bhvnz53PrCwoK8Nlnn2Hw4MHo1q0bAGDEiBHo0KEDPv/8c6VnRZYtW4Y2bdrgo48+QkhICNq1a8cNw1CWd999F7t27cKOHTvQpEkTzJgxA7Nnz+aNfbR06VK4ubkhMDAQAwYMwIQJE7jLiyUtWLAACxYsgK+vL/7++28cPHgQtra25T1dPNbW1hg0aBBmzpwJiUSCZcuWoU6dOmjbti26deuG0NBQvPvuu7xtZs+ejbS0NHh6esLOzg6AtF/cyZMnkZKSgsDAQPj5+WHGjBlwdnbmtuvatSv09fV5Qx+0bdsWX331FT799FPY2dlh0aJFSmPt3r07xo0bh1GjRqF58+Y4deoUdxdeZWRkZODUqVNKzzQSQmonASvdgYLg5cuXsLS0RE5OjlyH04KCAty9exd169ZVq4NrSStWrEBBQQHGjx8PoVAIsViMpUuXwsjISGG/EFKz5eXlwcXFBUuXLsXQoUOrdF9paWmoW7cuLl26VOOmwPnhhx9w8OBB/PHHH9oOhTN58mS8ePEC69atU1pHE58JhBDNKOv7W5Ooz5MWlE6QhEIhb2whUrNdunQJycnJCAgIQE5ODmbPng0AcnfSEb4vv/wS2dnZePXqFczNzbUdDgDA3t4eERER2g6DEKJjKHkipAosWbIEN2/ehKGhIfz9/ZGQkKD2ZbPaRl9fn9fhWxeMHz9e2yEQQnQQJU+EaJifnx8uXLiglX17eHjIDWVACCFEs6jDOCGEEEKIGih5IoQQQghRAyVPhBBCCCFqoOSJEEIIIUQNlDwRQgghhKiBkidS7WbOnKkzAzgKBALs379f22EQAM+ePYO9vb3cfHnVYcqUKRg9enS175cQUjNR8lRLDB48GAKBQG65fft2le5XUXIyYcIEHD9+vEr25+HhAYFAgB07dsit8/HxgUAgQGxsLFeWmZmJrl27Vkksuqzke8DCwgItW7bEgQMH1GojLS0NAoEAly9f1khM8+bNQ48ePeDh4QEAiI+Ph0AgQHZ2tkbaB5THPGHCBGzevFnpnIWEEFISJU+1SJcuXZCZmclbFM0fV1hYWKVxmJmZwcbGplJtFBUVKV3n5uYmNxnwmTNnkJWVBVNTU165o6MjRCJRpWKpiLLiry4xMTHIzMzE+fPn0a5dO/Tp0wfXrl3TSiz5+fnYuHFjlU9fo4ytrS1CQ0OxZs0areyfEFKzUPJUzW7duoWLFy8qXW7dulVl+xaJRHB0dOQtQqEQwcHBGDVqFMLDw7kvEQA4efIkAgICIBKJ4OTkhClTpqC4uJhrLzg4GGPGjMGkSZNgbW0NR0dHzJw5k1svO4PQq1cvCAQC7rGiy3YbNmzgJs9t1KgRVq9eza2TnS3YuXMngoKCYGRkhG3btik9zoEDB+LkyZNIT0/nyjZt2oSBAwdCX58/LmzJM2Oy/cTFxaFDhw4wMTGBr68vTp8+XebzmpycjPbt28PIyAiNGzfGsWPHFLZbOn6JRILZs2fD1dUVIpEIzZs3x+HDh7l2FZ15uXz5MgQCAXdpKzY2FlZWVti/fz/q168PIyMjhIaG8o5dGSsrKzg6OqJBgwaYM2cOiouLceLECW794cOH0b59e1hZWcHGxgYfffQRUlNTufWyxNvPzw8CgQDBwcHcurJeT0V+++03iEQitG7dmnvOOnToAACoU6cOBAIBN0GyRCLB/PnzUbduXRgbG8PX1xd79uzh2nrx4gUGDhwIOzs7GBsbo379+lwyXVbM3bp1U3jGkhBC5DAiJycnhwFgOTk5cutev37Nbty4wV6/fq12uykpKQxAuUtKSoomDoMnLCyM9ejRQ+G6oKAgZmZmxiZOnMiSk5NZcnIye/DgATMxMWEjR45kSUlJbN++fczW1pZFRkbytrOwsGAzZ85kKSkpbPPmzUwgELAjR44wxhh7/PgxA8BiYmJYZmYme/z4MWOMscjISObr68u1s3XrVubk5MT27t3L7ty5w/bu3cusra1ZbGwsY4yxu3fvMgDMw8ODq/Pw4UOFx+Lu7s6ioqJY9+7d2Zw5cxhjjOXl5TELCwt26dIlZmlpyWJiYrj6ANi+fft4+2nUqBE7dOgQu3nzJuvTpw9zd3dnRUVFCvdXXFzMGjZsyDp37swuX77MEhISWEBAgMJ2S8e/bNkyZmFhwbZv386Sk5PZpEmTmIGBAff6nzhxggFgL1684PZ36dIlBoDdvXuXMcZYTEwMMzAwYC1atGCnTp1i58+fZwEBAaxt27YK41V03EVFRSwqKooBYGvWrOHq7Nmzh+3du5fdunWLXbp0iXXr1o01bdqUicVixhhj586dYwDYsWPHWGZmJnv27JlKr6ciY8aMYV26dOE9r3v37mUA2M2bN1lmZibLzs5mjDE2d+5c1qhRI3b48GGWmprKYmJimEgkYvHx8Ywxxr755hvWvHlz9s8//7C7d++yo0ePsoMHD5YZM2OMJSUl8Z5bVVXmM4EQolllfX9rEiVPClRV8nThwgUGgG3tZcwujDCVW7b2MmYA2IULFzRxGDxhYWFMKBQyU1NTbunTpw9jTJoE+fn58ep/++23rGHDhkwikXBlP/zwAzMzM+O+PIOCglj79u1527Vs2ZJNnjyZe1zyS1qmdPLk6enJfv75Z16dOXPmsDZt2jDG/ks+oqOjyz1OWfK0f/9+5unpySQSCdu8eTN3fKokTxs2bODWX79+nQFgSUlJCvf3+++/M319fZaZmcmVHT16VGG7peN3dnZm8+bN45W1bNmSjRw5kjGmevIEgJ05c4arI0sCzp49q/R5AsCMjIyYqakp09PT45K7kslEaU+ePGEA2LVr13jHdenSJV698l5PRXr06MG++OILXpmi4y8oKGAmJibs1KlTvLpDhw5l/fv3Z4wx1q1bNzZkyBCF+1EWM2P//d3LkjBVUfJEiO6oruSJ5rbTAm87PbzrJKz2/Xbo0IHXp6Nk/x9/f39e3aSkJLRp0wYCgYAra9euHXJzc/HgwQO88847AIBmzZrxtnNycsLjx49VjikvLw+pqakYOnQohg8fzpUXFxfD0tKSV7dFixYqt/vhhx/iyy+/xF9//YVNmzbhiy++UHnbksfk5OQEAHj8+DEaNWokV/fmzZtwc3ODo6MjVxYQEKCw3ZLxv3z5Eg8fPkS7du14ddq1a4crV66oHCsgnVC3ZcuW3ONGjRrBysoKSUlJSmMBgKioKISEhODOnTsYN24cVqxYAWtra279rVu3MGPGDJw9exZPnz6FRCIBANy/fx9NmjRR2KY6r2dJr1+/hpGRUbnHevv2beTn56Nz58688sLCQvj5+QEAvv76a3z88ce4ePEi3n//ffTs2RNt27Ytt21jY2MA0v5XhBBSFkqeahFTU1N4eXkpXVcRBgYGvMcCgYD7klVFbm4uAGD9+vVo1aoVb51QyE8w1YlRX18fn3/+OSIjI3H27Fns27dP5W1LHpMseVTnmJRR9znW05N2SWQlJvrVZEdzR0dHeHl5wcvLCzExMfjggw9w48YN2NvbA5D2AXJ3d8f69evh7OwMiUSCJk2alHlDgTqvZ0m2trZ48eJFuTHL2v/111/h4uLCWyfr+N+1a1fcu3cPv/32G44ePYpOnTrhm2++wZIlS8ps+/nz5wAAOzu7cuMghNRu1GGcKOTt7Y3Tp0/zvrgTExNhbm4OV1dXldsxMDCAWCxWut7BwQHOzs64c+cO90UuWxTdCaiOL774AidPnkSPHj1Qp06dSrWlTMOGDZGeno5Hjx5xZf/880+521lYWMDZ2RmJiYm88sTERDRu3BjAf1/imZmZ3HpFwwIUFxfj/Pnz3OObN28iOzsb3t7eKh9HQEAA/P39MW/ePADSMZdu3ryJ7777Dp06dYK3t7dccmNoaAgAvNe3oq+nn58fbty4UW77jRs3hkgkwv379+Xad3Nz4+rZ2dkhLCwMW7duRXR0NNatW6e0TZl///0XBgYG8PHxKf8JI4TUanTmiSg0cuRIREdHY/To0Rg1ahRu3ryJyMhIREREcGdEVOHh4YHjx4+jXbt2EIlECpOYWbNmYcyYMbC0tESXLl3w5s0bnD9/Hi9evEBERESFj8Hb2xtPnz6FiYlJhdsoT+fOneHp6YmwsDAsWrQIr169wnfffQcAvEueikycOBGRkZHw9PRE8+bNERMTg8uXL3N3EsoSgpkzZ2LevHlISUnB0qVL5doxMDDA6NGjsWLFCujr62PUqFFo3bp1mZfsFAkPD0evXr0wadIkODk5wcbGBuvWrYOTkxPu37+PKVOm8Orb29vD2NgYhw8fhqurK4yMjGBpaVmh1zM0NBRTp07FixcvuPeIu7s7BAIBDh06hA8++ADGxsYwNzfHhAkTMG7cOEgkErRv3x45OTlITEyEhYUFwsLCMGPGDPj7+8PHxwdv3rzBoUOHuERSWcwAkJCQgMDAQO7yHSGEKENnnohCLi4u+O2333Du3Dn4+vriq6++wtChQ7nEQFVLly7F0aNH4ebmxvVJKW3YsGHYsGEDYmJi0LRpUwQFBSE2NrbSZ54AwMbGpkq/DIVCIfbv34/c3Fy0bNkSw4YNw7Rp0wCg3D48Y8aMQUREBMaPH4+mTZvi8OHDOHjwIOrXrw9AmhRt374dycnJaNasGRYuXIi5c+fKtWNiYoLJkydjwIABaNeuHczMzLBz5061j6VLly6oW7cu5s2bBz09PezYsQMXLlxAkyZNMG7cOCxevJhXX19fHytWrMCPP/4IZ2dn9OjRA0DFXs+mTZvi3Xffxa5du7gyFxcXzJo1C1OmTIGDgwNGjRoFAJgzZw6mT5+O+fPnw9vbG126dMGvv/7KtW9oaIipU6eiWbNmeO+99yAUCrkhCJTFDAA7duzg9dMihBBlBKzkdRkCQNqZ19LSEjk5ObCwsOCtKygowN27d1G3bl2VOriWdPHiRfj7+2NrL2N428nnrUlPJPhs32tcuHAB7777bqWOgWhPYmIi2rdvj9u3b8PT07NK9xUbG4vw8HCNjsKtLb/++ismTpyIf//9V62zm5rw+++/Y/z48bh69arcWGDlqcxnAiFEs8r6/tYkumxXjczNzQEAn+17rVI9UjPs27cPZmZmqF+/Pm7fvo2xY8eiXbt2VZ44vW0+/PBD3Lp1CxkZGbz+S9UhLy8PMTExaidOhJDaiT4pqlH9+vWRkpKCV69eKa1jbm7OXbYhNcOrV68wefJk3L9/H7a2tggJCVHYN4mULzw8XCv77dOnj1b2SwipmeiynQJVddmOEPL2oc8EQnRHdV22ow7jhBBCCCFqoOSJEEIIIUQNlDwRQgghhKiBkidCCCGEEDVQ8kQIIYQQogZKngghhBBC1EDJE6l2M2fORPPmzbUdBtExN2/ehKOjY5njoFWVfv360dhchBCVUfJUSwwePBgCgUBuuX37dpXuVyAQYP/+/byyCRMm4Pjx41WyPw8PDwgEAm4us5J8fHwgEAgQGxtbJfuuyYKDg7n3hJGRERo0aID58+dD3WHgPDw8EB0dXaEYpk6ditGjR3Mj7MfGxsLKyqpCbSkTHx8PgUAgN53Nd999h3nz5iEnJ0ej+yOEvJ0oeapFunTpgszMTN6iaLLWwsLCKo3DzMwMNjY2lWqjqKhI6To3NzfExMTwys6cOYOsrCyYmppWar9Vpaqfc1UMHz4cmZmZuHnzJqZOnYoZM2Zg7dq11bLv+/fv49ChQxg8eHC17K+0Jk2awNPTE1u3btXK/gkhNQslT9oiFgPx8cD27dKfYnGV71IkEsHR0ZG3CIVCBAcHY9SoUQgPD4etrS1CQ0MBACdPnkRAQABEIhGcnJwwZcoUFBcXc+0FBwdjzJgxmDRpEqytreHo6IiZM2dy6z08PAAAvXr1gkAg4B4rumy3YcMGeHt7w8jICI0aNcLq1au5dWlpaRAIBNi5cyeCgoJgZGSEbdu2KT3OgQMH4uTJk0hPT+fKNm3ahIEDB8rNXbZs2TI0bdoUpqamcHNzw8iRI5Gbm8ut/+KLL9CsWTO8efMGgDTJ8fPzw6BBg5Tu/9WrVxg4cCBMTU3h5OSEqKgoBAcH86Ye8fDwwJw5czBo0CBYWFhgxIgRAIC9e/fCx8cHIpEIHh4ecpeSFJ3Js7Ky4s6myZ6rHTt2oG3btjAyMkKTJk1w8uRJpfHKmJiYwNHREe7u7hgyZAiaNWuGo0ePcutTU1PRo0cPODg4wMzMDC1btsSxY8e49cHBwbh37x7GjRvHncWS+fvvvxEYGAhjY2O4ublhzJgxyMvL49bv2rULvr6+cHFxASA9QzRkyBDk5ORwbcneW2/evMGECRPg4uICU1NTtGrVCvHx8Vxb9+7dQ7du3VCnTh2YmprCx8cHv/32G9LS0tChQwcAQJ06dSAQCHjJWrdu3RSesSSEEDmMyMnJyWEAWE5Ojty6169fsxs3brDXr19XfAd79zLm6soY8N/i6iotryJhYWGsR48eCtcFBQUxMzMzNnHiRJacnMySk5PZgwcPmImJCRs5ciRLSkpi+/btY7a2tiwyMpK3nYWFBZs5cyZLSUlhmzdvZgKBgB05coQxxtjjx48ZABYTE8MyMzPZ48ePGWOMRUZGMl9fX66drVu3MicnJ7Z37152584dtnfvXmZtbc1iY2MZY4zdvXuXAWAeHh5cnYcPHyo8Fnd3dxYVFcW6d+/O5syZwxhjLC8vj1lYWLBLly4xS0tLFhMTw9WPiopif/75J7t79y47fvw4a9iwIfv666+59a9evWL16tVj4eHhjDHGJkyYwDw8PBS+N2SGDRvG3N3d2bFjx9i1a9dYr169mLm5ORs7diwvTgsLC7ZkyRJ2+/Ztdvv2bXb+/Hmmp6fHZs+ezW7evMliYmKYsbExL14AbN++fbz9lTwm2XPl6urK9uzZw27cuMGGDRvGzM3N2dOnT5XGHBQUxMUnkUjYX3/9xUxMTNinn37K1bl8+TJbu3Ytu3btGktJSWHfffcdMzIyYvfu3WOMMfbs2TPm6urKZs+ezTIzM1lmZiZjjLHbt28zU1NTFhUVxVJSUlhiYiLz8/NjgwcP5tru3r07++qrr7jHb968YdHR0czCwoJr69WrV9zz27ZtW/bXX3+x27dvs8WLFzORSMRSUlIYY4x9+OGHrHPnzuzq1assNTWV/fLLL+zkyZOsuLiY7d27lwFgN2/eZJmZmSw7O5vb5++//84MDQ1ZQUGB0udJEY18JhBCNKKs729NouRJgSpNnvbuZUwg4CdOgLRMIKiyBCosLIwJhUJmamrKLX369GGMSb84/fz8ePW//fZb1rBhQyaRSLiyH374gZmZmTGxWMxt1759e952LVu2ZJMnT+YeK/qyL508eXp6sp9//plXZ86cOaxNmzaMsf8Sgujo6HKPU5Y87d+/n3l6ejKJRMI2b97MHV/p5Km03bt3MxsbG17ZqVOnmIGBAZs+fTrT19dnCQkJSrd/+fIlMzAwYLt37+bKsrOzmYmJiVzy1LNnT962AwYMYJ07d+aVTZw4kTVu3Jh7rGrytGDBAm59UVERc3V1ZQsXLlQad1BQEDMwMGCmpqbMwMCAAWBGRkYsMTFR6TaMMebj48NWrlzJO66oqChenaFDh7IR/2vvvsOiuPb/gb+XhaWLBZVdpSioQAQbAQFvjMqVa0ksN+pVoijWiIpiwatGjKjkuSqPBY2xYa8RjFEuarjYEEWqGhUIYMOuKGKj7Of3h1/252YXcHGHop/X88yjnDlz5pwPw/Jh5szMuHFKZadPnyYdHR3Fz1G7du1o4cKFSnUiIiLIzMxMqezGjRskFospLy9PqbxHjx7073//m4iInJycaMGCBWr7GxcXRwAoPz9fZV16ejoBoOvXr5c7XnU4eWKs9qiu5KlWXLZbs2YNbGxsYGBgADc3NyQmJlZYf//+/bC3t4eBgQGcnJwQHR2ttJ6IMH/+fEilUhgaGsLLywtZWVlCDuH9lJYCAQFv06W/KiubOlWwS3jdunVDWlqaYlm1apViXadOnZTqXr16Fe7u7kqXXjw9PVFYWIjbt28rypydnZW2k0qlePDgwXv36cWLF8jOzsbo0aNhYmKiWBYtWoTs7Gylui4uLu/dbp8+fVBYWIhTp05h8+bN8PPzU1vv999/R48ePdCsWTOYmppi+PDhePz4MV6+fKmo4+7ujhkzZiAkJATTp09Hly5dyt1vTk4OiouL4erqqigzMzNDmzZtVOr+dTxXr16Fp6enUpmnpyeysrJQquEx4e7urvi/rq4uXFxccPXq1Qq38fHxQVpaGuLj49GrVy/MnTsXHh4eivWFhYWYMWMGHBwcUL9+fZiYmODq1au4efNmhe2mp6djy5YtSt9fb29vyOVy5ObmAgBevXr1Xi/VvXTpEkpLS9G6dWul9k6ePKk4XqZMmYJFixbB09MTwcHBuHjxYqXtAoChoSEAKH3vGWNMHd3Kqwhr7969CAwMxLp16+Dm5oYVK1bA29sbGRkZaNKkiUr9s2fPYujQoQgNDUXfvn2xa9cu9O/fHykpKWjbti0A4D//+Q9WrVqFrVu3okWLFvj+++/h7e2NK1eu1Oxbz0+fBt5JPFQQAbduva335Zda372xsTHs7OzKXVcVenp6Sl+LRCLI5fL33r5sftGGDRvg5uamtE4sFle5j7q6uhg+fDiCg4Nx/vx5REVFqdS5fv06+vbti++++w6LFy9Gw4YNcebMGYwePRpFRUUwMjICAMjlcsTHx0MsFmv17sSqxFwkEqncAVfR5HlNmJmZKY6Pffv2wc7ODp07d4aXlxeAt3dJHj9+HMuWLYOdnR0MDQ3xzTffVDrZvbCwEOPHj8eUKVNU1llZWQEAzM3NkZ+fX2kfCwsLIRaLkZycrHJ8mJiYAADGjBkDb29vHDlyBMeOHUNoaCiWL1+OyZMnV9j2kydPAACNGzeutB+MsU9bjZ95CgsLw9ixYzFq1Cg4Ojpi3bp1MDIywubNm9XWX7lyJf7xj39g5syZcHBwQEhICDp27Ijw8HAAb886rVixAvPmzUO/fv3g7OyMbdu24c6dOyoTbavd3bvarScgBwcHJCQkKP2ijo+Ph6mpKZo3b/7e7ejp6VV41qRp06aQyWTIycmBnZ2d0qLuTkBN+Pn54eTJk+jXrx8aNGigsj45ORlyuRzLly9H586d0bp1a9y5c0el3tKlS3Ht2jWcPHkSMTExKnfyvatly5bQ09PDhQsXFGXPnj1DZmZmpf11cHBAfHy8Ull8fDxat26tSBQaN26Mu+8cH1lZWWrPlJw7d07x/5KSEiQnJ8PBwaHSPpQxMTFBQEAAZsyYoTgG4uPjMXLkSAwYMABOTk6wsLDA9evXlbaTSCQq3++OHTviypUrKt9fOzs7SCQSAECHDh1w5cqVStvq0KEDSktL8eDBA5W2LCwsFPUsLS0xYcIEREZGYvr06diwYYOiTQBqj8nLly+jefPmMDc3f+84McY+TTWaPBUVFSE5OVnxly0A6OjowMvLCwkJCWq3SUhIUKoPAN7e3or6ubm5uHfvnlIdMzMzuLm5ldvmmzdvUFBQoLQIQirVbj0BTZw4Ebdu3cLkyZNx7do1/PrrrwgODkZgYCB0dN7/sLGxsUFsbCzu3btX7pmFH374AaGhoVi1ahUyMzNx6dIlREREICws7IPG4ODggEePHpWb7NjZ2aG4uBirV69GTk4Otm/frnJrfmpqKubPn4+NGzfC09MTYWFhCAgIQE5Ojto2TU1N4evri5kzZyIuLg5//PEHRo8eDR0dHaVLoOpMnz4dsbGxCAkJQWZmJrZu3Yrw8HDMmDFDUad79+4IDw9HamoqkpKSMGHCBJWzf8DbS+FRUVG4du0a/P39kZ+fX+6ly/KMHz8emZmZOHDgAACgVatWiIyMRFpaGtLT0zFs2DCVs4w2NjY4deoU8vLy8OjRIwBAUFAQzp49i0mTJiEtLQ1ZWVn49ddfMWnSJMV2ZT/D7yY1NjY2KCwsRGxsLB49eoSXL1+idevW8PHxwYgRIxAZGYnc3FwkJiYiNDQUR44cAQBMnToVR48eRW5uLlJSUhAXF6dIHK2trSESiXD48GE8fPhQ6c7K06dPo2fPnhrFiDH2iRJ0RlUl8vLyCACdPXtWqXzmzJnk6uqqdhs9PT2VycVr1qyhJk2aEBFRfHw8AVC5G2vQoEE0ePBgtW0GBwcTAJVF6xPGS0re3lWnbsJ42aRxS8u39bSssrvt3p3MXObEiRP0+eefk0QiIQsLCwoKCqLi4uIKt+vXrx/5+voqvj506BDZ2dmRrq4uWVtbE5HqhHEiop07d1L79u1JIpFQgwYN6IsvvqDIyEgi+v+ToFNTUysdp7oJy+/664TxsLAwkkqlZGhoSN7e3rRt2zbFhOJXr16Ro6OjymTnr7/+mjw8PKiknO9TQUEBDRs2jIyMjMjCwoLCwsLI1dWVZs+eXWk/f/nlF3J0dCQ9PT2ysrKipUuXKq3Py8ujnj17krGxMbVq1Yqio6PVThjftWsXubq6kkQiIUdHR/rf//5XYdzKOwbGjx9Pn332GZWWllJubi5169aNDA0NydLSksLDw1W2S0hIIGdnZ9LX16d3P14SExPp73//O5mYmJCxsTE5OzvT4sWLFeuLi4tJJpNRTEyM0v4nTJhAjRo1IgCKOz2Liopo/vz5ZGNjQ3p6eiSVSmnAgAF08eJFIiKaNGkS2drakr6+PjVu3JiGDx+udKfhwoULycLCgkQikeJYffXqFZmZmVFCQkKFcVKHJ4wzVnt8Enfb1Zbk6fXr1/Ts2TPFcuvWLeHvtvtrAiXw3Xas5hQWFpKZmRlt3LhR8H1pkmjWNuHh4dSzZ88a2ffatWtV7nR8X5w8MVZ7fBJ325mbm0MsFuP+/ftK5ffv31eav/AuCwuLCuuX/atJm/r6+qhXr57SIpiBA4FffgH+72GACs2bvy0fOFC4fbNqkZqait27dyM7OxspKSnw8fEBAPTr16+Ge1a7jR8/Hl988UWNvNtOT08Pq1evrvb9MsbqphpNniQSCTp16qT0njO5XI7Y2FilW63f5e7urvJetOPHjyvqt2jRAhYWFkp1CgoKcP78+XLbrHYDBwLXrwNxccCuXW//zc3lxOkjsmzZMrRr1w5eXl548eIFTp8+zRORK6Grq4u5c+cq3m1XncaMGaP2cRKMMaZOjT+qIDAwEL6+vnBxcYGrqytWrFiBFy9eYNSoUQCAESNGoFmzZggNDQUABAQEoGvXrli+fDn69OmDPXv2ICkpCevXrwfw9lbuqVOnYtGiRWjVqpXiUQUymQz9+/evqWGqEosFeRwBq3kdOnRAcnJyjezbxsZG45f5MsYY00yNJ09DhgzBw4cPMX/+fNy7dw/t27dHTEwMmjZtCuDtC0PfvbvLw8MDu3btwrx58zBnzhy0atUKBw8eVDzjCQBmzZqFFy9eYNy4cXj69Cm6dOmCmJiYmn3GE2OMMcY+CiLiP1NVFBQUwMzMDM+ePVOZ//T69Wvk5uaiRYsWnIwxxvgzgbFapKLf39pU4w/JrKs452SMAfxZwNiniJMnDZU9kJDff8UYA6B4Pc1fXxfDGPt41ficp7pGLBajfv36ipffGhkZVfrkaMbYx0kul+Phw4cwMjKCri5/nDL2qeCf9iooe15UWQLFGPt06ejowMrKiv+IYuwTwslTFYhEIkilUjRp0kRrb7RnjNVNEolEo/c9MsbqPk6ePoBYLOZ5Dowxxtgnhv9cYowxxhjTACdPjDHGGGMa4OSJMcYYY0wDPOdJjbKH3hUUFNRwTxhjjDH2vsp+bwv98FpOntR4/PgxAMDS0rKGe8IYY4wxTT1+/BhmZmaCtc/JkxoNGzYE8PalxEIGvy4qKCiApaUlbt26Jeh7g+oijk35ODbqcVzKx7EpH8emfM+ePYOVlZXi97hQOHlSo+yZLWZmZnxglqNevXocm3JwbMrHsVGP41I+jk35ODblE/rZazxhnDHGGGNMA5w8McYYY4xpgJMnNfT19REcHAx9ff2a7kqtw7EpH8emfBwb9Tgu5ePYlI9jU77qio2IhL6fjzHGGGPsI8JnnhhjjDHGNMDJE2OMMcaYBjh5YowxxhjTACdPjDHGGGMa+GSSpzVr1sDGxgYGBgZwc3NDYmJihfVXrFiBNm3awNDQEJaWlpg2bRpev36ttu6PP/4IkUiEqVOnCtBzYWk7LgsWLIBIJFJa7O3thR6GIIQ4ZvLy8vDtt9+iUaNGMDQ0hJOTE5KSkoQchiC0HRsbGxuV40YkEsHf31/ooWidtmNTWlqK77//Hi1atIChoSFsbW0REhIi+Lu7hKDt2Dx//hxTp06FtbU1DA0N4eHhgQsXLgg9DEFoEpvi4mIsXLgQtra2MDAwQLt27RATE/NBbdZW2o7LqVOn8NVXX0Emk0EkEuHgwYNV6xh9Avbs2UMSiYQ2b95Mf/zxB40dO5bq169P9+/fV1t/586dpK+vTzt37qTc3Fw6evQoSaVSmjZtmkrdxMREsrGxIWdnZwoICBB4JNolRFyCg4Pps88+o7t37yqWhw8fVteQtEaI2Dx58oSsra1p5MiRdP78ecrJyaGjR4/Sn3/+WV3D0gohYvPgwQOlY+b48eMEgOLi4qppVNohRGwWL15MjRo1osOHD1Nubi7t37+fTExMaOXKldU1LK0QIjaDBw8mR0dHOnnyJGVlZVFwcDDVq1ePbt++XV3D0gpNYzNr1iySyWR05MgRys7OprVr15KBgQGlpKRUuc3aSIi4REdH09y5cykyMpIAUFRUVJX69kkkT66uruTv76/4urS0lGQyGYWGhqqt7+/vT927d1cqCwwMJE9PT6Wy58+fU6tWrej48ePUtWvXOpc8CRGX4OBgateunSD9rU5CxCYoKIi6dOkiTIerkVA/T+8KCAggW1tbksvl2ul0NREiNn369CE/Pz+lOgMHDiQfHx8t9lx42o7Ny5cvSSwW0+HDh5XqdOzYkebOnavl3gtL09hIpVIKDw9XKvvrMaFpm7WREHF514ckTx/9ZbuioiIkJyfDy8tLUaajowMvLy8kJCSo3cbDwwPJycmK04M5OTmIjo5G7969ler5+/ujT58+Sm3XFULGJSsrCzKZDC1btoSPjw9u3rwp3EAEIFRsDh06BBcXFwwaNAhNmjRBhw4dsGHDBmEHo2VCHjfv7mPHjh3w8/ODSCTS/iAEIlRsPDw8EBsbi8zMTABAeno6zpw5g169egk4Gu0SIjYlJSUoLS2FgYGB0naGhoY4c+aMQCPRvqrE5s2bNxWOuypt1jZCxEWbPvoXAz969AilpaVo2rSpUnnTpk1x7do1tdsMGzYMjx49QpcuXUBEKCkpwYQJEzBnzhxFnT179iAlJaXOXl8XKi5ubm7YsmUL2rRpg7t37+KHH37A3/72N1y+fBmmpqaCjklbhIpNTk4OfvrpJwQGBmLOnDm4cOECpkyZAolEAl9fX0HHpC1CxeZdBw8exNOnTzFy5Ehtd19QQsVm9uzZKCgogL29PcRiMUpLS7F48WL4+PgIOh5tEiI2pqamcHd3R0hICBwcHNC0aVPs3r0bCQkJsLOzE3xM2lKV2Hh7eyMsLAxffPEFbG1tERsbi8jISJSWlla5zdpGiLho00d/5qkqTpw4gSVLlmDt2rVISUlBZGQkjhw5gpCQEADArVu3EBAQgJ07d6pkuR+zyuICAL169cKgQYPg7OwMb29vREdH4+nTp9i3b18N9lx47xMbuVyOjh07YsmSJejQoQPGjRuHsWPHYt26dTXYc+G9T2zetWnTJvTq1Qsymayae1r93ic2+/btw86dO7Fr1y6kpKRg69atWLZsGbZu3VqDPRfe+8Rm+/btICI0a9YM+vr6WLVqFYYOHQodnY/7V9vKlSvRqlUr2NvbQyKRYNKkSRg1atRHP+7KVGtcqnSxrw558+YNicVileuaI0aMoK+//lrtNl26dKEZM2YolW3fvp0MDQ2ptLSUoqKiCACJxWLFAoBEIhGJxWIqKSkRajhaI0RcyuPi4kKzZ8/+4D5XF6FiY2VlRaNHj1aqs3btWpLJZNrrvMCEPm6uX79OOjo6dPDgQa32uzoIFZvmzZurzOMICQmhNm3aaK/zAhP6uCksLKQ7d+4Q0dtJ5L1799Ze5wVWldiUefXqFd2+fZvkcjnNmjWLHB0dP7jN2kKIuPwVeM5T+SQSCTp16oTY2FhFmVwuR2xsLNzd3dVu8/LlS5VMVSwWAwCICD169MClS5eQlpamWFxcXODj44O0tDRF3dpMiLioU1hYiOzsbEilUi31XHhCxcbT0xMZGRlKdTIzM2Ftba3N7gtK6OMmIiICTZo0QZ8+fbTcc+EJFZvy6sjlcm12X1BCHzfGxsaQSqXIz8/H0aNH0a9fPy2PQDhViU0ZAwMDNGvWDCUlJThw4IBi3B/SZm0hRFy0qkopVx2zZ88e0tfXpy1bttCVK1do3LhxVL9+fbp37x4REQ0fPlzpzEhwcDCZmprS7t27KScnh44dO0a2trY0ePDgcvdRF++2EyIu06dPpxMnTlBubi7Fx8eTl5cXmZub04MHD6p9fB9CiNgkJiaSrq4uLV68mLKysmjnzp1kZGREO3bsqPbxfQihfp5KS0vJysqKgoKCqnU82iREbHx9falZs2aKRxVERkaSubk5zZo1q9rH9yGEiE1MTAz997//Vaxv164dubm5UVFRUbWP70NoGptz587RgQMHKDs7m06dOkXdu3enFi1aUH5+/nu3WRcIEZfnz59TamoqpaamEgAKCwuj1NRUunHjhkZ9+ySSJyKi1atXk5WVFUkkEnJ1daVz584p1nXt2pV8fX0VXxcXF9OCBQvI1taWDAwMyNLSkiZOnKj0Dfirupg8EWk/LkOGDCGpVEoSiYSaNWtGQ4YMqXPPMSojxDHz22+/Udu2bUlfX5/s7e1p/fr11TQa7RIiNkePHiUAlJGRUU2jEIa2Y1NQUEABAQFkZWVFBgYG1LJlS5o7dy69efOmGkelHdqOzd69e6lly5YkkUjIwsKC/P396enTp9U4Iu3RJDYnTpwgBwcH0tfXp0aNGtHw4cMpLy9PozbrCm3HJS4ujgCoLO+28z5ERHXwMbWMMcYYYzXko5/zxBhjjDGmTZw8McYYY4xpgJMnxhhjjDENcPLEGGOMMaYBTp4YY4wxxjTAyRNjjDHGmAY4eWKMMcYY0wAnT4wxxhhjGuDkiTFWoxISEiAWi+vk++wYY58mfsI4Y6xGjRkzBiYmJti0aRMyMjIgk8lqpB9FRUWQSCQ1sm/GWN3CZ54YYzWmsLAQe/fuxXfffYc+ffpgy5YtSut/++03fP755zAwMIC5uTkGDBigWPfmzRsEBQXB0tIS+vr6sLOzw6ZNmwAAW7ZsQf369ZXaOnjwIEQikeLrBQsWoH379ti4cSNatGgBAwMDAEBMTAy6dOmC+vXro1GjRujbty+ys7OV2rp9+zaGDh2Khg0bwtjYGC4uLjh//jyuX78OHR0dJCUlKdVfsWIFrK2tIZfLPzRkjLFagJMnxliN2bdvH+zt7dGmTRt8++232Lx5M8pOhh85cgQDBgxA7969kZqaitjYWLi6uiq2HTFiBHbv3o1Vq1bh6tWr+Pnnn2FiYqLR/v/8808cOHAAkZGRSEtLAwC8ePECgYGBSEpKQmxsLHR0dDBgwABF4lNYWIiuXbsiLy8Phw4dQnp6OmbNmgW5XA4bGxt4eXkhIiJCaT8REREYOXIkdHT4I5exj0IVX3TMGGMfzMPDg1asWEFERMXFxWRubk5xcXFEROTu7k4+Pj5qt8vIyCAAdPz4cbXrIyIiyMzMTKksKiqK3v3ICw4OJj09PXrw4EGFfXz48CEBoEuXLhER0c8//0ympqb0+PFjtfX37t1LDRo0oNevXxMRUXJyMolEIsrNza1wP4yxuoP/DGKM1YiMjAwkJiZi6NChAABdXV0MGTJEcektLS0NPXr0ULttWloaxGIxunbt+kF9sLa2RuPGjZXKsrKyMHToULRs2RL16tWDjY0NAODmzZuKfXfo0AENGzZU22b//v0hFosRFRUF4O0lxG7duinaYYzVfbo13QHG2Kdp06ZNKCkpUZogTkTQ19dHeHg4DA0Ny922onUAoKOjo7j8V6a4uFilnrGxsUrZV199BWtra2zYsAEymQxyuRxt27ZFUVHRe+1bIpFgxIgRiIiIwMCBA7Fr1y6sXLmywm0YY3ULn3lijFW7kpISbNu2DcuXL0daWppiSU9Ph0wmw+7du+Hs7IzY2Fi12zs5OUEul+PkyZNq1zdu3BjPnz/HixcvFGVlc5oq8vjxY2RkZGDevHno0aMHHBwckJ+fr1TH2dkZaWlpePLkSbntjBkzBr///jvWrl2LkpISDBw4sNJ9M8bqDj7zxBirdocPH0Z+fj5Gjx4NMzMzpXX//Oc/sWnTJixduhQ9evSAra0t/vWvf6GkpATR0dEICgqCjY0NfH194efnh1WrVqFdu3a4ceMGHjx4gMGDB8PNzQ1GRkaYM2cOpkyZgvPnz6vcyadOgwYN0KhRI6xfvx5SqRQ3b97E7NmzleoMHToUS5YsQf/+/REaGgqpVIrU1FTIZDK4u7sDABwcHNC5c2cEBQXBz8+v0rNVjLG6hc88Mcaq3aZNm+Dl5aWSOAFvk6ekpCQ0bNgQ+/fvx6FDh9C+fXt0794diYmJino//fQTvvnmG0ycOBH29vYYO3as4kxTw4YNsWPHDkRHR8PJyQm7d+/GggULKu2Xjo4O9uzZg+TkZLRt2xbTpk3D0qVLlepIJBIcO3YMTZo0Qe/eveHk5IQff/wRYrFYqd7o0aNRVFQEPz+/KkSIMVab8UMyGWNMACEhIdi/fz8uXrxY011hjGkZn3lijDEtKiwsxOXLlxEeHo7JkyfXdHcYYwLg5IkxxrRo0qRJ6NSpE7788ku+ZMfYR4ov2zHGGGOMaYDPPDHGGGOMaYCTJ8YYY4wxDXDyxBhjjDGmAU6eGGOMMcY0wMkTY4wxxpgGOHlijDHGGNMAJ0+MMcYYYxrg5IkxxhhjTAOcPDHGGGOMaeD/AfmuYQea211dAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -693,9 +357,16 @@ " 'Frontier Min group Rate (test)', 'Frontier Max group Rate(test)'))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instead of enforcing fairness we can simply decide on a minimal selection rate for every group." + ] + }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 36, "metadata": { "execution": { "iopub.execute_input": "2024-06-17T19:19:23.053597Z", @@ -704,15 +375,26 @@ "shell.execute_reply": "2024-06-17T19:19:23.094144Z" } }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "#Contrast with `Leveling-up' and enforcing a minimum selection rate for each group \n", + "#Contrast with `Leveling-up' and enforcing a minimum selection rate for each group\n", "fpredictor.fit(gm.accuracy,gm.pos_pred_rate.min,0.275,grid_width=grid_width)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 37, "metadata": { "execution": { "iopub.execute_input": "2024-06-17T19:19:23.101047Z", @@ -728,13 +410,13 @@ "Text(0.5, 1.0, 'Levelling Up: Minimum Positive Prediction Rate vs Accuracy trade-off')" ] }, - "execution_count": 7, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -751,7 +433,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 23, "metadata": { "execution": { "iopub.execute_input": "2024-06-17T19:19:26.442391Z", @@ -764,16 +446,16 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 8, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -791,9 +473,18 @@ "plt.legend(('Frontier Min group Rate', 'Frontier Max group Rate',))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now plot demographic parity vs accuracy as we enforce minimal rate constraints.\n", + "\n", + "As expected you see the unfairness decrease to near zero and then flatten out. This is overlayed by the same quantization noise as before causing the jittering effect." + ] + }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 24, "metadata": { "execution": { "iopub.execute_input": "2024-06-17T19:19:32.886775Z", @@ -809,13 +500,13 @@ "Text(0.5, 1.0, 'Levelling Up: Minimum Positive Prediction Rate vs Accuracy trade-off')" ] }, - "execution_count": 9, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm8AAAHHCAYAAADpkb+WAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACMG0lEQVR4nO3deVhU5d8G8HsGgVEQkB2UBNFUREVREDdcMEwzcZc0cUnN3MlSf5lopmhaqbmbW7mbZqmFC2qW4h4mLqSEuQEuCCjKOuf9g3cmBwaYGWaYxftzXXMpZ55zznP27zzbEQmCIICIiIiIjIJY3xkgIiIiItUxeCMiIiIyIgzeiIiIiIwIgzciIiIiI8LgjYiIiMiIMHgjIiIiMiIM3oiIiIiMCIM3IiIiIiPC4I2IiIjIiDB40wKRSIRZs2bJ/964cSNEIhFu3boln9ahQwd06NCh0vNmCiqy74YOHQpPT0+t5udVo+x8Ls3x48chEolw/PhxnefL0BQ/T2/dugWRSISNGzdqbR2enp4YOnSo1pZH9CrR9/MgJiYGfn5+kEgkEIlEyMjIAAB8//33aNCgAczNzWFnZ6fSsowieJM9PM6fP6/vrBglkUiEcePGKf3uhx9+qJSHrexBJhKJ8PnnnytNM2jQIIhEIlhbW+s0L8auQ4cO8n0pEolgb2+Pli1bYv369ZBKpZWShxUrVmg1KKkoWdAo+5ibm6NOnToYMmQI/vnnH31nTy2nTp3CrFmz5Dd2QyC7B8s+VapUQc2aNTF06FDcu3dPo2U+f/4cs2bNMupA/9q1axCJRJBIJAZ1vAydKRx7dT1+/Bj9+/dH1apVsXz5cnz//fewsrLC9evXMXToUHh7e2Pt2rVYs2aNSsurouP80v87dOiQvrNgECQSCbZt24YZM2YoTM/OzsZPP/0EiURSYp6K7Lu1a9dWWkBTmWrVqoXo6GgAwMOHD/Hdd99hxIgR+PvvvzF//nytruvdd9/FwIEDYWlpKZ+2YsUKODo6ligFat++PV68eAELCwut5kFVEyZMQMuWLZGfn4+LFy9izZo1OHDgAC5fvgx3d/dKzUvt2rXx4sULmJubqzXfqVOnMHv2bAwdOrTEr/DExESIxfr7zf3ZZ5/By8sLOTk5OH36NDZu3Ig//vgDCQkJSq/dsjx//hyzZ88GAKOtldi8eTNcXV3x5MkT/PDDD3jvvff0nSWjYArHXl3nzp3D06dPMWfOHISEhMinHz9+HFKpFEuWLEHdunVVXp5RlLyZAgsLC7090AxJt27dcPXqVVy6dElh+k8//YS8vDx06dKlxDwV2Xfm5uYKQYepsLW1xeDBgzF48GBMnjwZJ0+eRK1atbBs2TLk5+drdV1mZmbyYv7yiMViSCQSvQUY7dq1w+DBgzFs2DB88803WLRoEdLT07Fp06ZS58nOztZJXmQlMmZmZlpbpqWlpdrBoDa9+eabGDx4MN577z18++23mDJlCpKSkvDzzz/rLU/6IggCtm7dinfeeQfdunXDli1b9J2lUunqHK8sxp5/AHjw4AEAlPhBVtr08phU8Hbv3j0MHz4cLi4usLS0RKNGjbB+/Xr592lpaahSpYo84n9ZYmIiRCIRli1bJp+WkZGBSZMmwcPDA5aWlqhbty4WLFigUUlO8fYwsmqenTt3Yu7cuahVqxYkEgk6d+6Mmzdvlph/+fLlqFOnDqpWrYqAgAD8/vvvOmtH16FDB/j6+uLChQto3bo1qlatCi8vL6xatapE2tu3b+P69esqLzsoKAheXl7YunWrwvQtW7aga9eusLe3V5ofTfdd8TYOsurbRYsWyfdptWrV8MYbb+DOnTsQBAFz5sxBrVq1ULVqVfTs2RPp6ekKyyzexlGmeHskWVXTH3/8gQkTJsDJyQl2dnYYPXo08vLykJGRgSFDhqBGjRqoUaMGPv74YwiCoPK+fFm1atXQqlUrZGdn4+HDhwCAf/75B/369YO9vb38+wMHDpSY95tvvkGjRo1QrVo11KhRAy1atFA4PsXbvHl6euLKlSv47bff5NVosuNTvM3buHHjYG1tjefPn5dYb3h4OFxdXVFYWCif9uuvv6Jdu3awsrJC9erV0b17d1y5ckWjfQIAnTp1AgAkJycDAGbNmgWRSISrV6/inXfeQY0aNdC2bVt5+s2bN8Pf3x9Vq1aFvb09Bg4ciDt37pRY7po1a+Dt7a1wPRZXWpu369evo3///nByckLVqlVRv359fPLJJ/L8ffTRRwAALy8v+f59ed8XL+1U5Tire79RVbt27QAASUlJ8ml5eXmYOXMm/P39YWtrCysrK7Rr1w7Hjh1T2DdOTk4AgNmzZ8u38+Xr6vr16+jbty/s7e0hkUjQokWLcoPE/Px82NvbY9iwYSW+y8rKgkQiwZQpU+TTyjv3y3Ly5EncunULAwcOxMCBA3HixAncvXu3RDpZqUrjxo0hkUjg5OSErl27lmgGtHnzZgQEBMjz0r59e4VaB3XvO7/99hs++OADODs7o1atWgCAf//9Fx988AHq16+PqlWrwsHBAf369VPanjUjIwOTJ0+Gp6cnLC0tUatWLQwZMgSPHj3Cs2fPYGVlhYkTJ5aY7+7duzAzM5PXDBRX3rEfOnQorK2tkZSUhG7duqF69eoYNGgQAOD3339Hv3798Nprr8HS0hIeHh6YPHkyXrx4UWI9e/fuha+vLyQSCXx9ffHjjz8qzY9UKsXixYvRqFEjSCQSuLi4YPTo0Xjy5InS9Mrs2rVLft9wdHTE4MGDFZoTdOjQAREREQCAli1bQiQSyZ9NUVFRAAAnJ6dSj7EyJlNtmpaWhlatWsnbdzk5OeHXX3/FiBEjkJWVhUmTJsHFxQXBwcHYuXOnfIfJ7NixA2ZmZujXrx+AomLd4OBg3Lt3D6NHj8Zrr72GU6dOYfr06UhJScHixYu1ku/58+dDLBZjypQpyMzMxBdffIFBgwbhzJkz8jQrV67EuHHj0K5dO0yePBm3bt1CWFgYatSoIb8ote3Jkyfo1q0b+vfvj/DwcOzcuRNjxoyBhYUFhg8fLk83ZMgQ/Pbbb2oFHeHh4di8eTPmz58PkUiER48e4dChQ/j+++8RExOj8nJU2Xel2bJlC/Ly8jB+/Hikp6fjiy++QP/+/dGpUyccP34cU6dOxc2bN/HNN99gypQpCj8C1DV+/Hi4urpi9uzZOH36NNasWQM7OzucOnUKr732GubNm4dffvkFCxcuhK+vL4YMGaLRev755x+YmZnBzs4OaWlpaN26NZ4/f44JEybAwcEBmzZtwttvv40ffvgBvXr1AlBUrTxhwgT07dsXEydORE5ODv766y+cOXMG77zzjtL1LF68GOPHj4e1tbU86HBxcVGadsCAAVi+fDkOHDggv7aAoutr3759GDp0qLxk6vvvv0dERARCQ0OxYMECPH/+HCtXrkTbtm3x559/atTQWBZUODg4KEzv168f6tWrh3nz5snP3blz5+LTTz9F//798d577+Hhw4f45ptv0L59e/z555/yX8br1q3D6NGj0bp1a0yaNAn//PMP3n77bdjb28PDw6PM/Pz1119o164dzM3NMWrUKHh6eiIpKQn79u3D3Llz0bt3b/z999/Ytm0bvv76azg6OgKA/GFXnKrHWaYi14wysod+jRo15NOysrLw7bffIjw8HCNHjsTTp0+xbt06hIaG4uzZs/Dz84OTkxNWrlyJMWPGoFevXujduzcAoEmTJgCAK1euoE2bNqhZsyamTZsGKysr7Ny5E2FhYdi9e3eJ7ZIxNzdHr169sGfPHqxevVqhxH7v3r3Izc3FwIEDAWh27r9sy5Yt8Pb2RsuWLeHr64tq1aph27Zt8uBbZsSIEdi4cSPefPNNvPfeeygoKMDvv/+O06dPo0WLFgCKgphZs2ahdevW+Oyzz2BhYYEzZ87g6NGjeOONN1Q8Goo++OADODk5YebMmfKSq3PnzuHUqVMYOHAgatWqhVu3bmHlypXo0KEDrl69imrVqgEAnj17hnbt2uHatWsYPnw4mjdvjkePHuHnn3/G3bt34efnh169emHHjh346quvFEqXt23bBkEQ5AFXceUdewAoKChAaGgo2rZti0WLFsnztWvXLjx//hxjxoyBg4MDzp49i2+++QZ3797Frl275PMfOnQIffr0gY+PD6Kjo/H48WMMGzZM6fNy9OjR2LhxI4YNG4YJEyYgOTkZy5Ytw59//omTJ0+WW9Itm7dly5aIjo5GWloalixZgpMnT8rvG5988gnq16+PNWvWyJseeHt7IywsDN999x1+/PFHrFy5EtbW1gr7oUyCEdiwYYMAQDh37lypaUaMGCG4ubkJjx49Upg+cOBAwdbWVnj+/LkgCIKwevVqAYBw+fJlhXQ+Pj5Cp06d5H/PmTNHsLKyEv7++2+FdNOmTRPMzMyE27dvy6cBEKKiokrkNzk5WT4tODhYCA4Olv997NgxAYDQsGFDITc3Vz59yZIlCvnLzc0VHBwchJYtWwr5+fnydBs3bhQAKCyzNACEsWPHKv1u165dAgDh2LFjCnkFIHz55Zfyabm5uYKfn5/g7Ows5OXllUhbnuTkZAGAsHDhQiEhIUEAIPz++++CIAjC8uXLBWtrayE7O1uIiIgQrKysFObVdN8JgiBEREQItWvXLpEPJycnISMjQz59+vTpAgChadOmCvs5PDxcsLCwEHJycuTTih9vmdq1awsRERHyv2XnQWhoqCCVSuXTg4KCBJFIJLz//vvyaQUFBUKtWrVUOp7BwcFCgwYNhIcPHwoPHz4Url27JkyYMEEAIPTo0UMQBEGYNGmSwj4WBEF4+vSp4OXlJXh6egqFhYWCIAhCz549hUaNGpW5PmXnc6NGjZTmVXZsZOeTVCoVatasKfTp00ch3c6dOwUAwokTJ+R5s7OzE0aOHKmQLjU1VbC1tS0xvbT1rl+/Xnj48KFw//594cCBA4Knp6cgEonk946oqCgBgBAeHq4w/61btwQzMzNh7ty5CtMvX74sVKlSRT49Ly9PcHZ2Fvz8/BTOvTVr1pS4HmXn2oYNG+TT2rdvL1SvXl34999/Fdbz8vmxcOHCEvtbpvg5pupxVueaUUZ2Dhw5ckR4+PChcOfOHeGHH34QnJycBEtLS+HOnTvytAUFBQrrEARBePLkieDi4iIMHz5cPu3hw4elXkudO3cWGjdurHDdSaVSoXXr1kK9evXKzOvBgwcFAMK+ffsUpnfr1k2oU6eO/G9Vzv3S5OXlCQ4ODsInn3win/bOO+8ITZs2VUh39OhRAYAwYcKEEsuQHfMbN24IYrFY6NWrl/x4FU8jCOrfd9q2bSsUFBQopJU9B18WFxcnABC+++47+bSZM2cKAIQ9e/aUmm/Zfv71118Vvm/SpEm597Gyjn1ERIQAQJg2bVqJ75TlPzo6WhCJRArXlJ+fn+Dm5qZwjz906JAAQOF58PvvvwsAhC1btigsMyYmRun04mT3A19fX+HFixfy6fv37xcACDNnzpRPKy2Okd2THj58WOa6ijOJalNBELB792706NEDgiDg0aNH8k9oaCgyMzNx8eJFAEDv3r1RpUoV7NixQz5/QkICrl69igEDBsin7dq1C+3atUONGjUUlhcSEoLCwkKcOHFCK3kfNmyYwq9DWTWErIfc+fPn8fjxY4wcORJVqvxXUDpo0CCFX7vaVqVKFYwePVr+t4WFBUaPHo0HDx7gwoUL8unHjx9Xu6qvUaNGaNKkCbZt2wYA2Lp1K3r27Cn/daWq8vZdWfr16wdbW1v534GBgQCAwYMHK+znwMBA5OXladyjDij65f1ye7HAwEAIgoARI0bIp5mZmaFFixYq94y8fv06nJyc4OTkhIYNG+Kbb75B9+7d5SWEv/zyCwICAhSqBK2trTFq1CjcunULV69eBVDUzuLu3bs4d+6cxttXFpFIhH79+uGXX37Bs2fP5NN37NiBmjVryvN3+PBhZGRkIDw8XOF6MzMzQ2BgoEKVW1mGDx8OJycnuLu7o3v37sjOzsamTZvkJRwy77//vsLfe/bsgVQqRf/+/RXW7+rqinr16snXf/78eTx48ADvv/++wrk3dOhQhfNJmYcPH+LEiRMYPnw4XnvttRL7SROqHmeZilwzABASEgInJyd4eHigb9++sLKyws8//6xQomFmZiZfh1QqRXp6OgoKCtCiRQv5fbgs6enpOHr0KPr374+nT5/Kj8Xjx48RGhqKGzdulHk9durUCY6Ojgr3+CdPnuDw4cMK9/iKnPu//vorHj9+jPDwcPm08PBwXLp0SaGaf/fu3RCJRCVqeoD/jvnevXshlUoxc+bMEm1FNT0vAGDkyJEl2ltWrVpV/v/8/Hw8fvwYdevWhZ2dncKx2b17N5o2baq0hFOWp5CQELi7uyu09UtISMBff/2FwYMHa5xvmTFjxpSY9nL+s7Oz8ejRI7Ru3RqCIODPP/8EAKSkpCA+Ph4REREK12SXLl3g4+OjsLxdu3bB1tYWXbp0Ubju/f39YW1tXe59R3Y/+OCDDxQ67HTv3h0NGjRQ2kxFW0wieHv48CEyMjKwZs0a+QNN9pG1fZA1CnR0dETnzp2xc+dO+fw7duxAlSpV5MW3AHDjxg3ExMSUWJ6sl4hseRVV/CYuC8hk9e3//vsvAJTohVKlShWtjldT/Cbh7u4OKysrhWmvv/46AChtH6Gud955B7t27cLNmzdx6tQplaopiitv36kzr+wiL17tJZuuTvuHiqxL1fV4enri8OHDOHLkCP744w+kpqZi//798mq2f//9F/Xr1y8xX8OGDeXfA8DUqVNhbW2NgIAA1KtXD2PHjsXJkyfV28ByDBgwAC9evJC3V3r27Bl++eUX9OvXT37e3bhxA0DRg7f4NXfo0CGVr7eZM2fi8OHDOHr0KP766y/cv38f7777bol0Xl5eCn/fuHEDgiCgXr16JdZ/7do1+fpl+61evXoK88uGJimLLEDy9fVVaVtUoepxlqnINQMUtb09fPgwfvjhB3Tr1g2PHj1S2iFo06ZNaNKkCSQSCRwcHODk5IQDBw4gMzOz3HXcvHkTgiDg008/LXEsZEFQWedDlSpV0KdPH/z000/Izc0FUBSc5+fnKwRvFTn3N2/eDC8vL1haWuLmzZu4efMmvL29Ua1aNYVgJikpCe7u7krb8r6cRiwWlwgsKqr4OQ4AL168wMyZM+XtuB0dHeHk5ISMjAyFY5OUlFTueSoWizFo0CDs3btX3qZ1y5YtkEgkCk0kNFGlShWlVZy3b9/G0KFDYW9vD2trazg5OSE4OBgA5Pkv7RoFUOJauXHjBjIzM+Hs7FziXHv27Jn8PMvMzERqaqr8I2sHLVuXsmuwQYMGJa4/bTKJNm+yDgSDBw+WNwos7uV65IEDB2LYsGGIj4+Hn58fdu7cic6dO8sffLJldunSBR9//LHS5ckCmYoqrSeauqVZZbG0tFTaoBOA/KJTt5t/RYWHh2P69OkYOXIkHBwcNGrXUZF9V9q8FVnmyw3vNV2XqsfdyspKobu5pho2bIjExETs378fMTEx2L17N1asWIGZM2cq7dijiVatWsHT0xM7d+7EO++8g3379uHFixcKD1LZNfz999/D1dW1xDJeLg0tS+PGjVXaLy//gpetXyQS4ddff1V6XExl7MGK3m8CAgLkpZhhYWFo27Yt3nnnHSQmJsr30ebNmzF06FCEhYXho48+grOzs7wB+8sdG0ojOxemTJmC0NBQpWnKG1Jh4MCBWL16NX799VeEhYVh586daNCgAZo2bSpPo+m5n5WVhX379iEnJ0dpgLB161bMnTu3QqVm6ijtvlP8HAeK2t9u2LABkyZNQlBQEGxtbSESiTBw4ECNOuINGTIECxcuxN69exEeHo6tW7firbfeKrcUujyWlpYlSiELCwvRpUsXpKenY+rUqWjQoAGsrKxw7949DB06VKP8S6VSODs7l9pTWNbWdOLEiQo91oODg/U+Rp1JBG9OTk6oXr06CgsLVbpxh4WFYfTo0fJi9b///hvTp09XSOPt7Y1nz55p5QFZEbVr1wZQ9Gu0Y8eO8ukFBQW4deuWSo0ba9eujcTERKXfyabL1iNz//59ZGdnK5S+/f333wCglRK/1157DW3atMHx48cxZswYlR/OhqBGjRolBuTMy8tDSkqKfjKkRGnHXNYz+OXjbWVlhQEDBmDAgAHIy8tD7969MXfuXEyfPr3UoF7dB1P//v2xZMkSZGVlYceOHfD09ESrVq3k33t7ewMAnJ2d9XLNeXt7QxAEeHl5lfnDTLbfbty4Ie/JChRVQSUnJysEB8XJSuYSEhLKzIs6+1ad46xtsoCsY8eOWLZsGaZNmwagaODvOnXqYM+ePQrbUrzqsLTtlO0nc3Nzjc+F9u3bw83NDTt27EDbtm1x9OhReeeal2ly7u/Zswc5OTlYuXKlwg9+oOh+OmPGDJw8eRJt27aFt7c3Dh48iPT09FJL37y9vSGVSnH16lX4+fmVuk3auO/88MMPiIiIwJdffimflpOTU2K53t7e5Z6nQFEpcrNmzbBlyxbUqlULt2/fxjfffFPufJoEtpcvX8bff/+NTZs2KXTqOnz4sEK6l6/R4opfK97e3jhy5AjatGmjNNiV+fjjjxWqgmUl1rJ1JSYmKtwPZNN0ef2ZRLWpmZkZ+vTpg927dys94WRDJ8jY2dkhNDQUO3fuxPbt22FhYYGwsDCFNP3790dcXBwOHjxYYnkZGRkoKCjQ6jaUpkWLFnBwcMDatWsV1rllyxaVqzq6deuG06dPK7RVA4q2Y8uWLfDz8ytR2lFQUIDVq1fL/87Ly8Pq1avh5OQEf39/+XR1hwp52eeff46oqCiMHz9eo/n1xdvbu0SbxzVr1pT6C1gfunXrhrNnzyIuLk4+LTs7G2vWrIGnp6e8iubx48cK81lYWMDHxweCIJQ5XpyVlZVaI8oPGDAAubm52LRpE2JiYtC/f3+F70NDQ2FjY4N58+YpXW/xa1jbevfuDTMzM8yePbtEKZQgCPL91KJFCzg5OWHVqlXIy8uTp9m4cWO5+8PJyQnt27fH+vXrcfv27RLrkJH9YFJl/6p6nHWlQ4cOCAgIwOLFi5GTkwPgv9K9l7fpzJkzCnkEIG/jWnw7nZ2d0aFDB6xevVppYKLKuSAWi9G3b1/s27cP33//PQoKChRKegHNz/3NmzejTp06eP/999G3b1+Fz5QpU2BtbS0vyenTpw8EQVBakifbP2FhYRCLxfjss89KlB69vA+1cd8xMzMrcX5/8803JZbRp08fXLp0SenwGsXnf/fdd3Ho0CEsXrwYDg4OePPNN8vNR2nHvry8F1+/IAhYsmSJQjo3Nzf4+flh06ZNClXBhw8fLtEGtH///igsLMScOXNKrK+goECePx8fH4SEhMg/smdgixYt4OzsjFWrVsmr6IGiNpHXrl1D9+7dVd4+dRlPcQeA9evXKx1KYuLEiZg/fz6OHTuGwMBAjBw5Ej4+PkhPT8fFixdx5MiREmN1DRgwAIMHD8aKFSsQGhpaYoC8jz76CD///DPeeustDB06FP7+/sjOzsbly5fxww8/4NatWyV+demChYUFZs2ahfHjx6NTp07o378/bt26hY0bN8Lb21ulXzDTpk3Drl270L59e4wePRoNGjTA/fv3sXHjRqSkpGDDhg0l5nF3d8eCBQtw69YtvP7669ixYwfi4+OxZs0aha7TmgwVIhMcHCxvr2BM3nvvPbz//vvo06cPunTpgkuXLuHgwYOVcj6oatq0adi2bRvefPNNTJgwAfb29ti0aROSk5Oxe/dueZXEG2+8AVdXV7Rp0wYuLi64du0ali1bhu7du6N69eqlLt/f3x8rV67E559/jrp168LZ2bnEL8+XNW/eHHXr1sUnn3yC3NzcEg9SGxsbrFy5Eu+++y6aN2+OgQMHwsnJCbdv38aBAwfQpk0bhTEYtc3b2xuff/45pk+fLh+Kp3r16khOTsaPP/6IUaNGYcqUKTA3N8fnn3+O0aNHo1OnThgwYACSk5OxYcOGctu8AcDSpUvRtm1bNG/eHKNGjYKXlxdu3bqFAwcOID4+HgDkD4ZPPvkEAwcOhLm5OXr06FGiDSqg+nHWpY8++gj9+vXDxo0b8f777+Ott97Cnj170KtXL3Tv3h3JyclYtWoVfHx8FDqtVK1aFT4+PtixYwdef/112Nvbw9fXF76+vli+fDnatm2Lxo0bY+TIkahTpw7S0tIQFxeHu3fvlhjkW5kBAwbgm2++QVRUFBo3bixvByijybl///59HDt2DBMmTFD6vaWlJUJDQ7Fr1y4sXboUHTt2xLvvvoulS5fixo0b6Nq1K6RSKX7//Xd07NgR48aNk18Xc+bMQbt27dC7d29YWlri3LlzcHd3l4+Xpo37zltvvYXvv/8etra28PHxQVxcHI4cOVJiKJ2PPvoIP/zwA/r164fhw4fD398f6enp+Pnnn7Fq1SqFEuZ33nkHH3/8MX788UeMGTNGpUGkyzr2pWnQoAG8vb0xZcoU3Lt3DzY2Nti9e7fSQozo6Gh0794dbdu2xfDhw5Geni4f0+/lczA4OBijR49GdHQ04uPj8cYbb8Dc3Bw3btzArl27sGTJEvTt27fUPJmbm2PBggUYNmwYgoODER4eLh8qxNPTE5MnTy53X2hMrb6peiLrYlvaR9ZNPS0tTRg7dqzg4eEhmJubC66urkLnzp2FNWvWlFhmVlaWULVqVQGAsHnzZqXrffr0qTB9+nShbt26goWFheDo6Ci0bt1aWLRokcJwGajAUCG7du1SWKey4QUEQRCWLl0q1K5dW7C0tBQCAgKEkydPCv7+/kLXrl1V2od3794V3nvvPaFmzZpClSpVBHt7e+Gtt94STp8+XSJtcHCw0KhRI+H8+fNCUFCQIJFIhNq1awvLli1TmlaV0+jloULKos5QIarsu9KGCimej9KWqax7d2FhoTB16lTB0dFRqFatmhAaGircvHmz1C77qnYNV7btysiOT3mSkpKEvn37CnZ2doJEIhECAgKE/fv3K6RZvXq10L59e8HBwUGwtLQUvL29hY8++kjIzMwssR0vn8+pqalC9+7dherVqysMkVF8qJCXffLJJwIAoW7duqXm+dixY0JoaKhga2srSCQSwdvbWxg6dKhw/vz5Mre1tONXXHnd8nfv3i20bdtWsLKyEqysrIQGDRoIY8eOFRITExXSrVixQvDy8hIsLS2FFi1aCCdOnChxnpZ2LSckJAi9evWSH5f69esLn376qUKaOXPmCDVr1hTEYrHCvi9+jgmCasdZ3ftNcWUN11RYWCh4e3sL3t7eQkFBgSCVSoV58+bJ71fNmjUT9u/fX+JaFARBOHXqlODv7y9YWFiUuI8mJSUJQ4YMEVxdXQVzc3OhZs2awltvvSX88MMPZeZVRiqVCh4eHgIA4fPPPy/xvSrnfnFffvmlAECIjY0tNY1sGKeffvpJEISioVMWLlwoNGjQQLCwsBCcnJyEN998U7hw4YLCfOvXrxeaNWsmWFpaCjVq1BCCg4OFw4cPy7+v6H1HEIqGbBk2bJjg6OgoWFtbC6GhocL169eVnlePHz8Wxo0bJ9SsWVOwsLAQatWqJURERJQYjksQioZhASCcOnWq1P1SXGnHvqz74NWrV4WQkBDB2tpacHR0FEaOHClcunRJ6Tm8e/duoWHDhoKlpaXg4+Mj7NmzR+k5KAhFQ/34+/sLVatWFapXry40btxY+Pjjj4X79++rtC07duyQHzt7e3th0KBBwt27dxXSaHuoEJEgaLFlPFUaqVQKJycn9O7dG2vXrtXqsjt06IBHjx6p1OaBiIhebb169cLly5cr9LYOUo9JtHkzdTk5OSWqJb/77jukp6e/Mi/1JSIiw5OSkoIDBw4oHZKHdMeo2ry9qk6fPo3JkyejX79+cHBwwMWLF7Fu3Tr4+vpWeDwdIiIidSUnJ+PkyZP49ttvYW5urjCoO+kegzcj4OnpCQ8PDyxdulTe5XzIkCGYP3++wmjpREREleG3337DsGHD8Nprr2HTpk1Kx2ck3WGbNyIiIiIjwjZvREREREaEwRsRERGREWGbNw1JpVLcv38f1atXr7R32BEREVHFCIKAp0+fwt3dvVIGstYFBm8aun//Pjw8PPSdDSIiItLAnTt3UKtWLX1nQyMM3jQke33KnTt3YGNjo+fcEBERkSqysrLg4eFR5isADR2DNw3JqkptbGwYvBERERkZY27yZJyVvURERESvKIMI3pYvXw5PT09IJBIEBgbi7NmzpaZdu3Yt2rVrhxo1aqBGjRoICQkpkV4QBMycORNubm6oWrUqQkJCcOPGDYU06enpGDRoEGxsbGBnZ4cRI0bg2bNnOtk+IiIiIm3Re/C2Y8cOREZGIioqChcvXkTTpk0RGhqKBw8eKE1//PhxhIeH49ixY4iLi4OHhwfeeOMN3Lt3T57miy++wNKlS7Fq1SqcOXMGVlZWCA0NRU5OjjzNoEGDcOXKFRw+fBj79+/HiRMnMGrUKJ1vLxEREVFF6P0NC4GBgWjZsiWWLVsGoGgIDg8PD4wfPx7Tpk0rd/7CwkLUqFEDy5Ytw5AhQyAIAtzd3fHhhx9iypQpAIDMzEy4uLhg48aNGDhwIK5duwYfHx+cO3cOLVq0AADExMSgW7duuHv3Ltzd3ctdb1ZWFmxtbZGZmVlmm7fCwkLk5+ersiuIKp25uTnMzMz0nQ0iokqj6vPbkOm1w0JeXh4uXLiA6dOny6eJxWKEhIQgLi5OpWU8f/4c+fn5sLe3B1D0stzU1FSEhITI09ja2iIwMBBxcXEYOHAg4uLiYGdnJw/cACAkJARisRhnzpxBr169SqwnNzcXubm58r+zsrLKzJcgCEhNTUVGRoZK20GkL3Z2dnB1dTXqxrtERK8SvQZvjx49QmFhIVxcXBSmu7i44Pr16yotY+rUqXB3d5cHa6mpqfJlFF+m7LvU1FQ4OzsrfF+lShXY29vL0xQXHR2N2bNnq5Qn2ToyMjLg7OyMatWq8cFIBkcQBDx//lzeRMHNzU3POSIiIlUY9VAh8+fPx/bt23H8+HFIJBKdrmv69OmIjIyU/y0bJ0aZwsJCeeDm4OCg03wRVUTVqlUBAA8ePICzszOrUImIjIBeOyw4OjrCzMwMaWlpCtPT0tLg6upa5ryLFi3C/PnzcejQITRp0kQ+XTZfWct0dXUt0SGioKAA6enppa7X0tJSPqZbeWO7ydq4VatWrcxtIDIEsvOUbTOJiIyDXoM3CwsL+Pv7IzY2Vj5NKpUiNjYWQUFBpc73xRdfYM6cOYiJiVFotwYAXl5ecHV1VVhmVlYWzpw5I19mUFAQMjIycOHCBXmao0ePQiqVIjAwUFubx6pSMgo8T4mIjIveq00jIyMRERGBFi1aICAgAIsXL0Z2djaGDRsGABgyZAhq1qyJ6OhoAMCCBQswc+ZMbN26FZ6envI2atbW1rC2toZIJMKkSZPw+eefo169evDy8sKnn34Kd3d3hIWFAQAaNmyIrl27YuTIkVi1ahXy8/Mxbtw4DBw4UKWepkRERKQbhVIBZ5PT8eBpDpyrSxDgZQ8zMX9kvkzvwduAAQPw8OFDzJw5E6mpqfDz80NMTIy8w8Ht27chFv9XQLhy5Urk5eWhb9++CsuJiorCrFmzAAAff/wxsrOzMWrUKGRkZKBt27aIiYlRaBe3ZcsWjBs3Dp07d4ZYLEafPn2wdOlS3W8wqWTWrFnYu3cv4uPj9Z0VIiKqJDEJKZi97ypSMv8bl9XNVoKoHj7o6stOVTJ6H+fNWJU1TkxOTg6Sk5Ph5eWl844U2jZ06FBs2rSpxPQbN26gbt26OlmnSCTCjz/+KC8ZBYBnz54hNzeXHT4qgTGfr0RkOmISUjBm80UUD0pkZW4rBzfXSgBnCuO86f0NC1S6QqmAuKTH+Cn+HuKSHqNQWjlxdteuXZGSkqLw8fLyUkiTl5en0zxYW1tXOHBjA3wiIuNQKBUwe9/VEoEbAPm02fuuVtpz0NAxeDNQMQkpaLvgKMLXnsbE7fEIX3sabRccRUxCis7XbWlpCVdXV4VP586dMW7cOEyaNAmOjo4IDQ0FAPz2228ICAiApaUl3NzcMG3aNBQUFMiX1aFDB0yYMAEff/wx7O3t4erqKq/eBgBPT08AQK9evSASieR/z5o1C35+fgr5+vbbb9GwYUNIJBI0aNAAK1askH9369YtiEQi7NixA8HBwZBIJNiyZYtO9g8REWnX2eR0harS4gQAKZk5OJucXnmZMmAM3gyQrOi4+ImcmpmDMZsvVkoAp8ymTZtgYWGBkydPYtWqVbh37x66deuGli1b4tKlS1i5ciXWrVuHzz//vMR8VlZWOHPmDL744gt89tlnOHz4MADg3LlzAIANGzYgJSVF/ndxW7ZswcyZMzF37lxcu3YN8+bNw6efflqiinfatGmYOHEirl27Jg8wiYjIsD14Wnrgpkk6U6f3DgukqLyiYxGKio67+LjqrPfN/v37YW1tLf/7zTffBADUq1cPX3zxhXz6J598Ag8PDyxbtgwikQgNGjTA/fv3MXXqVMycOVPe0aRJkyaIioqSL2PZsmWIjY1Fly5d4OTkBOC/VzSVJioqCl9++SV69+4NoGhImKtXr2L16tWIiIiQp5s0aZI8DRERGQfn6qq1t1U1nalj8GZg1Ck6DvLWTWP+jh07YuXKlfK/raysEB4eDn9/f4V0165dQ1BQkMI4YW3atMGzZ89w9+5dvPbaawCgMIgyUPQapuKDJJclOzsbSUlJGDFiBEaOHCmfXlBQAFtbW4W0xcf9IyIiwxfgZQ83WwlSM3OUFl6IALjaFg0bQgzeDI4hFB1bWVkp7VlqZWWl0fLMzc0V/haJRJBKpSrP/+zZMwDA2rVrSwyiXPx1TprmkYiI9MdMLEJUDx+M2XwRIkAhgJMVD0T18OF4b/+Pbd4MjDEVHTds2BBxcXF4ebSZkydPonr16qhVq5bKyzE3N0dhYWGp37u4uMDd3R3//PMP6tatq/Ap3guWiIiMU1dfN6wc3ByutorPN1dbidaGCTEVLHkzMMZUdPzBBx9g8eLFGD9+PMaNG4fExERERUUhMjJSYWDl8nh6eiI2NhZt2rSBpaUlatSoUSLN7NmzMWHCBNja2qJr167Izc3F+fPn8eTJE0RGRmpzs4iISE+6+rqhi48r37BQDpa8GRhZ0THwX1GxjKEVHdesWRO//PILzp49i6ZNm+L999/HiBEjMGPGDLWW8+WXX+Lw4cPw8PBAs2bNlKZ577338O2332LDhg1o3LgxgoODsXHjRpa8ERGZGDOxCEHeDujpVxNB3g4G8bwzNHzDgoZ0/YYFviKEKgvfsEBErxJTeMMCq00NFIuOiYiISBkGbwZMVnRMREREJMM2b0RERERGhMEbERERkRFh8EZERERkRBi8ERERERkRBm9ERERERoTBGxEREZERYfBGREREZEQYvJHW3Lp1CyKRCPHx8SrPs3HjRtjZ2ek9H7omEomwd+9eAIaZPyIiMh4M3kjBnTt3MHz4cLi7u8PCwgK1a9fGxIkT8fjx43Ln9fDwQEpKCnx9fVVe34ABA/D3339XJMtGR939NHToUISFhek2U0REZDQYvBm4Fy9eYN68eXjx4oXO1/XPP/+gRYsWuHHjBrZt24abN29i1apViI2NRVBQENLT00udNy8vD2ZmZnB1dUWVKqq/uKNq1apwdnbWRvZ1Lj8/XyvL0WQ/aUNeXl6lro+IiHSDwZuB2717Nz755BPs2bNH5+saO3YsLCwscOjQIQQHB+O1117Dm2++iSNHjuDevXv45JNP5Gk9PT0xZ84cDBkyBDY2Nhg1apTS6sCff/4Z9erVg0QiQceOHbFp0yaIRCJkZGQAKFltOmvWLPj5+eH777+Hp6cnbG1tMXDgQDx9+lSeJiYmBm3btoWdnR0cHBzw1ltvISkpSa1tleU/PDwcVlZWqFmzJpYvX66QRiQSYeXKlXj77bdhZWWFuXPnAgB++uknNG/eHBKJBHXq1MHs2bNRUFAgn+/GjRto3749JBIJfHx8cPjwYYXlKttPV65cwVtvvQUbGxtUr14d7dq1Q1JSEmbNmoVNmzbhp59+gkgkgkgkwvHjxwEAly9fRqdOnVC1alU4ODhg1KhRePbsmXyZshK7uXPnwt3dHfXr11drHxERkWFi8Gbgfti18///3aXT9aSnp+PgwYP44IMPULVqVYXvXF1dMWjQIOzYsQOCIMinL1q0CE2bNsWff/6JTz/9tMQyk5OT0bdvX4SFheHSpUsYPXq0QgBYmqSkJOzduxf79+/H/v378dtvv2H+/Pny77OzsxEZGYnz588jNjYWYrEYvXr1glQqVWubFy5cKM//tGnTMHHixBKB1qxZs9CrVy9cvnwZw4cPx++//44hQ4Zg4sSJuHr1KlavXo2NGzfKAzupVIrevXvDwsICZ86cwapVqzB16tQy83Hv3j20b98elpaWOHr0KC5cuIDhw4ejoKAAU6ZMQf/+/dG1a1ekpKQgJSUFrVu3RnZ2NkJDQ1GjRg2cO3cOu3btwpEjRzBu3DiFZcfGxiIxMRGHDx/G/v371do/RERkoATSSGZmpgBAyMzMLPHdixcvhKtXrwovXrxQe7mpqanC1KlThcjISCEyMlKQWFoIXnYiQWJpIZ82depUIS0tTRubIXf69GkBgPDjjz8q/f6rr74SAMjXW7t2bSEsLEwhTXJysgBA+PPPPwVBEISpU6cKvr6+Cmk++eQTAYDw5MkTQRAEYcOGDYKtra38+6ioKKFatWpCVlaWfNpHH30kBAYGlpr3hw8fCgCEy5cvK82HMrVr1xa6du2qMG3AgAHCm2++Kf8bgDBp0iSFNJ07dxbmzZunMO37778X3NzcBEEQhIMHDwpVqlQR7t27J//+119/Vdi3xfM3ffp0wcvLS8jLy1Oa14iICKFnz54K09asWSPUqFFDePbsmXzagQMHBLFYLKSmpsrnc3FxEXJzc0vdD4JQsfOViMjYlPX8NhaV2+iGypWSkoIlSxYjJycXdlXN0MjRDCverIYPfs3H+pVLkPGiEBKJJQYOHKiTtmLCSyVr5WnRokWZ3ycmJqJly5YK0wICAspdrqenJ6pXry7/283NDQ8ePJD/fePGDcycORNnzpzBo0eP5CVut2/fVquzRFBQUIm/Fy9erDCt+DZeunQJJ0+elJe0AUBhYSFycnLw/PlzXLt2DR4eHnB3dy91PcXFx8ejXbt2MDc3Vznv165dQ9OmTWFlZSWf1qZNG0ilUiQmJsLFxQUA0LhxY1hYWKi8XCIiMnysNjUwfn5+OH/+Anx9GiCnQEBUOzME1DRDVDsz5BQI8PVpiPPnL8DPz0+r661bty5EIhGuXbum9Ptr166hRo0acHJykk97OXDQpuJBjEgkUqgS7dGjB9LT07F27VqcOXMGZ86cAaCbBvnFt/HZs2eYPXs24uPj5Z/Lly/jxo0bkEgkGq2jeDW1NunqGBERkf4weDNAjRo1wok/TiGvEPj9diGWnM7FiX8LkVcInPjjJBo1aqT1dTo4OKBLly5YsWJFiZ6tqamp2LJlCwYMGACRSKTyMuvXr4/z588rTDt37lyF8vn48WMkJiZixowZ6Ny5Mxo2bIgnT55otKzTp0+X+Lthw4ZlztO8eXMkJiaibt26JT5isRgNGzbEnTt3kJKSUup6imvSpAl+//33UnuzWlhYoLCwUGFaw4YNcenSJWRnZ8unnTx5EmKxmB0TiIhMHIM3A3XixAlIpVIsOZOPSQdzsfRsPqRSKX7//XedrXPZsmXIzc1FaGgoTpw4gTt37iAmJgZdunRBzZo1FaoKVTF69Ghcv34dU6dOxd9//42dO3di48aNAKBWEPiyGjVqwMHBAWvWrMHNmzdx9OhRREZGarSskydP4osvvsDff/+N5cuXY9euXZg4cWKZ88ycORPfffcdZs+ejStXruDatWvYvn07ZsyYAQAICQnB66+/joiICFy6dAm///57uZ00xo0bh6ysLAwcOBDnz5/HjRs38P333yMxMRFAUTXyX3/9hcTERDx69Aj5+fkYNGgQJBIJIiIikJCQgGPHjmH8+PF499135VWmRETGqjKHyTJGDN4MlGxokKDWbRAXF4dWQa0VputCvXr1cP78edSpUwf9+/eHt7c3Ro0ahY4dOyIuLg729vZqLc/Lyws//PAD9uzZgyZNmmDlypXyQMbS0lKjPIrFYmzfvh0XLlyAr68vJk+ejIULF2q0rA8//BDnz59Hs2bN8Pnnn+Orr75CaGhomfOEhoZi//79OHToEFq2bIlWrVrh66+/Ru3ateX5+/HHH/HixQsEBATgvffeKzfodXBwwNGjR/Hs2TMEBwfD398fa9eulVcfjxw5EvXr10eLFi3g5OSEkydPolq1ajh48CDS09PRsmVL9O3bF507d8ayZcs02hdERIakMofJMkYiQZ0W6iSXlZUFW1tbZGZmwsbGRuG7nJwcJCcnw8vLS+N2UEuXLkVOTg4+/PBDmJmZobCwEF9++SUkEgkmTJigjU3Qi7lz52LVqlW4c+eOXvPh6emJSZMmYdKkSXrNhyHQxvlKRKRNYT3fxk8/70NYz5748f9fLagtZT2/jQV7mxqo4gGamZkZPv74Yz3lRnMrVqxAy5Yt4eDggJMnT2LhwoUlxiIjIqJXW1paGr7++mt529+DBw/Cy06EmJhf8eGHHwIo6swWGRlpNG/l0SW9V5suX74cnp6ekEgkCAwMxNmzZ0tNe+XKFfTp0weenp4QiUQlhnUAIP+u+Gfs2LHyNB06dCjx/fvvv6+LzXvl3bhxAz179oSPjw/mzJmDDz/8ELNmzdJ3toiIyIDIhsn66quvsH7lEvg4Atv7VoOPI7B+5RJ89dVXWLJkMe7fv6/vrBoEvZa87dixA5GRkVi1ahUCAwOxePFihIaGIjExUWlk/fz5c9SpUwf9+vXD5MmTlS7z3LlzCj3zEhIS0KVLF/Tr108h3ciRI/HZZ5/J/65WrZqWtope9vXXX+Prr7/WdzZKuHXrlr6zQERE/082TFaPnmG49+8/mPX/w2TNaidF3x8K4OVdF/t+2quT0RaMkV5L3r766iuMHDkSw4YNg4+PD1atWoVq1aph/fr1StO3bNkSCxcuxMCBA0tt8O7k5ARXV1f5Z//+/fD29kZwcLBCumrVqimkM9Z6byIiIlNwR7BHwVufI79QUBgmK79QQMFbn+OOoF6nOVOmt+AtLy8PFy5cQEhIyH+ZEYsREhKCuLg4ra1j8+bNGD58eImhKbZs2QJHR0f4+vpi+vTpeP78eZnLys3NRVZWlsKnPOwLQsaA5ykR6VuhVMDsfVeRcycBgiAoDJMlCAJy71zB7H1XUSjl/QrQY/D26NEjFBYWlhiTysXFBampqVpZx969e5GRkYGhQ4cqTH/nnXewefNmHDt2DNOnT8f333+PwYMHl7ms6Oho2Nrayj8eHh6lppUN8VBeQEhkCGTnqTqv5yIi0qazyelIyczB879PAQCquDeE6+BFqOJeNHB69t8nkZKZg7PJ6frMpsEw6d6m69atw5tvvqnwnkkAGDVqlPz/jRs3hpubGzp37oykpCR4e3srXdb06dMVBoPNysoqNYAzMzODnZ2d/H2c1apV03hQWiJdEQQBz58/x4MHD2BnZwczMzN9Z4mIXlEPnuYAACxc6sLc8TXYtOwFkdgMjgOjkXXuR4jMLBTSver0Frw5OjrCzMwMaWlpCtPT0tLg6upa4eX/+++/OHLkiEoD/AUGBgIAbt68WWrwZmlpqdbAsrJtePmF6kSGyM7OTivXHBGRppyrF40xadPibYXpIrEZbAP7lkj3qtNb8GZhYQF/f3/ExsYiLCwMACCVShEbG6uVccA2bNgAZ2dndO/evdy08fHxAAA3N7cKr1dGJBLBzc0Nzs7Opb6zkkjfzM3NWeJGRHoX4GUPN1sJUjNzoKxVmwiAq60EAV7stADoudo0MjISERERaNGiBQICArB48WJkZ2dj2LBhAIAhQ4agZs2aiI6OBlDUAeHq1avy/9+7dw/x8fGwtrZG3bp15cuVSqXYsGEDIiIiUKWK4iYmJSVh69at6NatGxwcHPDXX39h8uTJaN++PZo0aaL1bTQzM+PDkYiIqAxmYhGievhgzOaLEAEKAZys0VFUDx+YidkECdBz8DZgwAA8fPgQM2fORGpqKvz8/BATEyPvxHD79m2Ixf/1qbh//z6aNWsm/3vRokVYtGgRgoODcfz4cfn0I0eO4Pbt2xg+fHiJdVpYWODIkSPyQNHDwwN9+vSRv1iciIiIKl9XXzesHNwcs/ddRUrmf23bXG0liOrhg66+2qsdM3Z8t6mGTOHdaERERIamUCrgbHI6HjzNgXP1oqpSbZa4mcLz26R7mxIREZFxMROLEOTtoO9sGDS9v9uUiIiIiFTH4I2IiIjIiDB4IyIiIjIiDN6IiIiIjAiDNyIiIiIjwuCNiIiIyIgweCMiIiIyIgzeiIiIiIwIgzciIiIiI8LgjYiIiMiIMHgjIiIiMiIM3oiIiIiMCIM3IiIiIiPC4I2IiIjIiDB4IyIiIjIiDN6IiIiIjAiDNyIiIiIjwuCNiIiIyIgweCMiIiIyIgzeiIiIiIwIgzciIiIiI8LgjYiIiMiIMHgjIiIiMiIM3oiIiIiMCIM3IiIiIiPC4I2IiIjIiDB4IyIiIjIiDN6IiIiIjAiDNyIiIiIjwuCNiIiIyIgweCMiIiIyInoP3pYvXw5PT09IJBIEBgbi7Nmzpaa9cuUK+vTpA09PT4hEIixevLhEmlmzZkEkEil8GjRooJAmJycHY8eOhYODA6ytrdGnTx+kpaVpe9OIiIiItE6vwduOHTsQGRmJqKgoXLx4EU2bNkVoaCgePHigNP3z589Rp04dzJ8/H66urqUut1GjRkhJSZF//vjjD4XvJ0+ejH379mHXrl347bffcP/+ffTu3Vur20ZERESkC3oN3r766iuMHDkSw4YNg4+PD1atWoVq1aph/fr1StO3bNkSCxcuxMCBA2FpaVnqcqtUqQJXV1f5x9HRUf5dZmYm1q1bh6+++gqdOnWCv78/NmzYgFOnTuH06dNa30YiIiIibdJb8JaXl4cLFy4gJCTkv8yIxQgJCUFcXFyFln3jxg24u7ujTp06GDRoEG7fvi3/7sKFC8jPz1dYb4MGDfDaa69VeL1EREREuqa34O3Ro0coLCyEi4uLwnQXFxekpqZqvNzAwEBs3LgRMTExWLlyJZKTk9GuXTs8ffoUAJCamgoLCwvY2dmptd7c3FxkZWUpfIiIiIgqWxV9Z0Db3nzzTfn/mzRpgsDAQNSuXRs7d+7EiBEjNF5udHQ0Zs+erY0sEhEREWlMbyVvjo6OMDMzK9HLMy0trczOCOqys7PD66+/jps3bwIAXF1dkZeXh4yMDLXWO336dGRmZso/d+7c0VoeiYiIiFSlt+DNwsIC/v7+iI2NlU+TSqWIjY1FUFCQ1tbz7NkzJCUlwc3NDQDg7+8Pc3NzhfUmJibi9u3bZa7X0tISNjY2Ch8iIiKiyqbXatPIyEhERESgRYsWCAgIwOLFi5GdnY1hw4YBAIYMGYKaNWsiOjoaQFEnh6tXr8r/f+/ePcTHx8Pa2hp169YFAEyZMgU9evRA7dq1cf/+fURFRcHMzAzh4eEAAFtbW4wYMQKRkZGwt7eHjY0Nxo8fj6CgILRq1UoPe4GIiIhIdXoN3gYMGICHDx9i5syZSE1NhZ+fH2JiYuSdGG7fvg2x+L/Cwfv376NZs2byvxctWoRFixYhODgYx48fBwDcvXsX4eHhePz4MZycnNC2bVucPn0aTk5O8vm+/vpriMVi9OnTB7m5uQgNDcWKFSsqZ6OJiIiIKkAkCIKg70wYo6ysLNja2iIzM5NVqEREREbCFJ7fen89FhERERGpzuSGCiEiIiLjUygVcDY5HQ+e5sC5ugQBXvYwE4v0nS2DxOCNiIiI9ComIQWz911FSmaOfJqbrQRRPXzQ1ddNjzkzTKw2JSIiIr2JSUjBmM0XFQI3AEjNzMGYzRcRk5Cip5wZLgZvREREpBeFUgGz912Fsp6Tsmmz911FoZR9K1/G4I2IiIj04mxyeokSt5cJAFIyc3A2Ob3yMmUEGLwRERGRXqRmlR64vezBU9XSvSoYvBEREVGli0lIwZz9V1RK61xdouPcGBf2NiUiIqJKJeukUF5LNhEAV9uiYUPoPyx5IyIiokpTVieFl8lGeIvq4cPx3oph8EZERESVprxOCjL2VhZYObg5x3lTgsEbERERVRpVOx/M6N6QgVspGLwRERFRpVG184GrbVUd58R4MXgjIiKiShPgZQ83WwlKa8UmQtGrsdhJoXQM3oiIiKjSmIlFiOrhAwAlAjh2UlANgzciIiKqVF193bBycHO42ipWobraSthJQQVqj/P2zz//oE6dOrrICxEREb0iuvq6oYuPK84mp+PB0xw4Vy+qKmWJW/nUDt7q1q2L4OBgjBgxAn379oVEwlGPiYiISH1mYhGCvB30nQ2jo3a16cWLF9GkSRNERkbC1dUVo0ePxtmzZ3WRNyIiIiIqRu3gzc/PD0uWLMH9+/exfv16pKSkoG3btvD19cVXX32Fhw8f6iKfRERERIQKdFioUqUKevfujV27dmHBggW4efMmpkyZAg8PDwwZMgQpKSnazCcRERERoQLB2/nz5/HBBx/Azc0NX331FaZMmYKkpCQcPnwY9+/fR8+ePbWZTyIiIiKCBh0WvvrqK2zYsAGJiYno1q0bvvvuO3Tr1g1icVEc6OXlhY0bN8LT01PbeSUiIiJ65akdvK1cuRLDhw/H0KFD4eamfBwWZ2dnrFu3rsKZIyIiIiJFIkEQBHVmuHXrFl577TV5SZuMIAi4c+cOXnvtNa1m0FBlZWXB1tYWmZmZsLGx0Xd2iIiISAWm8PxWu82bt7c3Hj16VGJ6eno6vLy8tJIpIiIiIlJO7eCttIK6Z8+eccBeIiIiIh1Tuc1bZGQkAEAkEmHmzJmoVq2a/LvCwkKcOXMGfn5+Ws8gEREREf1H5eDtzz//BFBU8nb58mVYWFjIv7OwsEDTpk0xZcoU7eeQiIiIiORUDt6OHTsGABg2bBiWLFlitI38iIiIiIyZ2kOFbNiwQRf5ICIiIiIVqBS89e7dGxs3boSNjQ169+5dZto9e/ZoJWNEREREVJJKvU1tbW0hEonk/y/ro67ly5fD09MTEokEgYGBOHv2bKlpr1y5gj59+sDT0xMikQiLFy8ukSY6OhotW7ZE9erV4ezsjLCwMCQmJiqk6dChA0QikcLn/fffVzvvRERERJVNpZI3WVWpIAiYPXs2nJycULVq1QqvfMeOHYiMjMSqVasQGBiIxYsXIzQ0FImJiXB2di6R/vnz56hTpw769euHyZMnK13mb7/9hrFjx6Jly5YoKCjA//73P7zxxhu4evUqrKys5OlGjhyJzz77TP73y71niYiIiAyVWm9YkEqlkEgkuHLlCurVq1fhlQcGBqJly5ZYtmyZfPkeHh4YP348pk2bVua8np6emDRpEiZNmlRmuocPH8LZ2Rm//fYb2rdvD6Co5M3Pz09pyZ2qTGGEZiIioleNKTy/1RqkVywWo169enj8+HGFV5yXl4cLFy4gJCREYfkhISGIi4ur8PJlMjMzAQD29vYK07ds2QJHR0f4+vpi+vTpeP78udbWSURERKQravc2nT9/Pj766COsXLkSvr6+Gq/40aNHKCwshIuLi8J0FxcXXL9+XePlvkwqlWLSpElo06aNQl7feecd1K5dG+7u7vjrr78wdepUJCYmltnZIjc3F7m5ufK/s7KytJJHIiIiInWoHbwNGTIEz58/R9OmTWFhYVGi7Vt6errWMldRY8eORUJCAv744w+F6aNGjZL/v3HjxnBzc0Pnzp2RlJQEb29vpcuKjo7G7NmzdZpfIiIiovKoHbxVpJ3YyxwdHWFmZoa0tDSF6WlpaXB1da3w8seNG4f9+/fjxIkTqFWrVplpAwMDAQA3b94sNXibPn26/BVhQFHJm4eHR4XzSURERKQOtYO3iIgIrazYwsIC/v7+iI2NRVhYGICias7Y2FiMGzdO4+UKgoDx48fjxx9/xPHjx+Hl5VXuPPHx8QAANze3UtNYWlrC0tJS43wRERERaYPawdvLcnJykJeXpzBNnZ4bkZGRiIiIQIsWLRAQEIDFixcjOzsbw4YNA1BURVuzZk1ER0cDKOrkcPXqVfn/7927h/j4eFhbW6Nu3boAiqpKt27dip9++gnVq1dHamoqgKLx6apWrYqkpCRs3boV3bp1g4ODA/766y9MnjwZ7du3R5MmTSqyO4iIiIh0Tq2hQgAgOzsbU6dOxc6dO5X2Oi0sLFQrA8uWLcPChQuRmpoKPz8/LF26VF6N2aFDB3h6emLjxo0AgFu3biktSQsODsbx48eLNuj/BxMubsOGDRg6dCju3LmDwYMHIyEhAdnZ2fDw8ECvXr0wY8YMtQJPU+hqTERE9Koxhee32sHb2LFjcezYMcyZMwfvvvsuli9fjnv37mH16tWYP38+Bg0apKu8GhRTOPhERESvGlN4fqtdbbpv3z5899136NChA4YNG4Z27dqhbt26qF27NrZs2fLKBG9ERERE+qDWIL1A0VAgderUAVDUvk02NEjbtm1x4sQJ7eaOiIiIiBSoHbzVqVMHycnJAIAGDRpg586dAIpK5Ozs7LSaOSIiIiJSpHbwNmzYMFy6dAkAMG3aNCxfvhwSiQSTJ0/GRx99pPUMEhEREdF/1O6wUNy///6LCxcuoG7duq/UUBum0OCRiIjoVWMKz2+VOyxIpVIsXLgQP//8M/Ly8tC5c2dERUWhdu3aqF27ti7zSERERET/T+Vq07lz5+J///sfrK2tUbNmTSxZsgRjx47VZd6IiIiIqBiVg7fvvvsOK1aswMGDB7F3717s27cPW7ZsgVQq1WX+iIiIiOglKgdvt2/fRrdu3eR/h4SEQCQS4f79+zrJGBERERGVpHLwVlBQAIlEojDN3Nwc+fn5Ws8UERERESmncocFQRAwdOhQWFpayqfl5OTg/fffh5WVlXzanj17tJtDIiIiIpJTOXiLiIgoMW3w4MFazQwRERGZrkKpgLPJ6XjwNAeOVpaACHj0LBfO1SUI8LKHmVik7ywaBZWDtw0bNugyH0RERGTCYhJSMHvfVaRk5ij93s1WgqgePujq61bJOTM+ar9hgYiIiEgdMQkpGLP5YqmBGwCkZuZgzOaLiElIqcScGScGb0RERKQzhVIBs/ddRXmvc5J9P3vfVRRKK/TyJ5PH4I2IiIh05mxyepklbi8TAKRk5uBscrpuM2XkGLwRERGRzjx4qlrgVtF5XiUM3oiIiEhnnKtLyk+khXleJWoHb9HR0Vi/fn2J6evXr8eCBQu0kikiIiIyDQFe9nCzlUCVQUBEKOp1GuBlr+tsGTW1g7fVq1ejQYMGJaY3atQIq1at0kqmiIiIyDSYiUWI6uEDAGUGcLLvonr4cLy3cqgdvKWmpsLNreQYLE5OTkhJYfdeIiIiUtTV1w0rBzeHq23p1aGuthKsHNyc47ypQOVBemU8PDxw8uRJeHl5KUw/efIk3N3dtZYxIiIiMh1dfd3QxceVb1jQArWDt5EjR2LSpEnIz89Hp06dAACxsbH4+OOP8eGHH2o9g0RERGQazMQiBHk76DsbRk/t4O2jjz7C48eP8cEHHyAvLw8AIJFIMHXqVEyfPl3rGSQiIiKi/4gEQdBoGONnz57h2rVrqFq1KurVqwdLS0tt582gZWVlwdbWFpmZmbCxsdF3doiIiEgFpvD8VrvkTcba2hotW7bUZl6IiIiIqBwqBW+9e/fGxo0bYWNjg969e5eZds+ePVrJGBERERGVpFLwZmtrC5FIJP8/EREREemHxm3eXnWmUGdORET0qjGF5zffbUpERERkRNQO3tLS0vDuu+/C3d0dVapUgZmZmcKHiIiIiHRH7d6mQ4cOxe3bt/Hpp5/Czc1N3haOiIiIiHRP7ZK3P/74A1u2bMGYMWMQFhaGnj17KnzUtXz5cnh6ekIikSAwMBBnz54tNe2VK1fQp08feHp6QiQSYfHixRotMycnB2PHjoWDgwOsra3Rp08fpKWlqZ13IiIiosqmdvDm4eEBbfVx2LFjByIjIxEVFYWLFy+iadOmCA0NxYMHD5Smf/78OerUqYP58+fD1dVV42VOnjwZ+/btw65du/Dbb7/h/v375Q6BQkRERGQQBDUdPHhQeOONN4Tk5GR1Zy0hICBAGDt2rPzvwsJCwd3dXYiOji533tq1awtff/212svMyMgQzM3NhV27dsnTXLt2TQAgxMXFqZz3zMxMAYCQmZmp8jxERESkX6bw/FapzVuNGjUU2rZlZ2fD29sb1apVg7m5uULa9PR0lYLGvLw8XLhwQeF9qGKxGCEhIYiLi1NpGZos88KFC8jPz0dISIg8TYMGDfDaa68hLi4OrVq10mjdRERERJVBpeCttLZlFfHo0SMUFhbCxcVFYbqLiwuuX7+us2WmpqbCwsICdnZ2JdKkpqaWuuzc3Fzk5ubK/87KytIoj0REREQVoVLwFhERoet8GLzo6GjMnj1b39kgIiKiV5xGL6YvLCzEjz/+iGvXrgEAfHx80LNnT1SpovriHB0dYWZmVqKXZ1paWqmdEbSxTFdXV+Tl5SEjI0Oh9K289U6fPh2RkZHyv7OysuDh4aFRPomIiIg0pXZv0ytXruD1119HREQEfvzxR/z444+IiIhAvXr1kJCQoPJyLCws4O/vj9jYWPk0qVSK2NhYBAUFqZstlZfp7+8Pc3NzhTSJiYm4fft2meu1tLSEjY2NwoeIiIiosqld8vbee++hUaNGOH/+PGrUqAEAePLkCYYOHYpRo0bh1KlTKi8rMjISERERaNGiBQICArB48WJkZ2dj2LBhAIAhQ4agZs2aiI6OBlDUIeHq1avy/9+7dw/x8fGwtrZG3bp1VVqmra0tRowYgcjISNjb28PGxgbjx49HUFAQOysQERGRwVM7eIuPj1cI3ICi3qhz585Fy5Yt1VrWgAED8PDhQ8ycOROpqanw8/NDTEyMvMPB7du3IRb/Vzh4//59NGvWTP73okWLsGjRIgQHB+P48eMqLRMAvv76a4jFYvTp0we5ubkIDQ3FihUr1N0VRERERJVOJAjqjbjbtGlTfP311+jUqZPC9KNHj2LixIm4fPmyVjNoqLKysmBra4vMzExWoRIRERkJU3h+q93mLTo6GhMmTMAPP/yAu3fv4u7du/jhhx8wadIkLFiwAFlZWfIPEREREWmX2iVvL1djygbulS3i5b9FIhEKCwu1lU+DYwqROxER0avGFJ7fard5O3bsmC7yQUREREQqUDt4Cw4O1kU+iIiIiEgFGg3SCwDPnz/H7du3kZeXpzC9SZMmFc4UERERESmndvD28OFDDBs2DL/++qvS7025nRsRERGRvqnd23TSpEnIyMjAmTNnULVqVcTExGDTpk2oV68efv75Z13kkYiIiIj+n9olb0ePHsVPP/2EFi1aQCwWo3bt2ujSpQtsbGwQHR2N7t276yKfRERERAQNSt6ys7Ph7OwMoOjNCg8fPgQANG7cGBcvXtRu7oiIiIhIgdrBW/369ZGYmAig6G0Lq1evxr1797Bq1Sq4ublpPYNERERE9B+1q00nTpyIlJQUAEBUVBS6du2KLVu2wMLCAhs3btR2/oiIiIjoJWq/YaG458+f4/r163jttdfg6OiorXwZPFMYoZmIiOhVYwrPb7WqTfPz8+Ht7Y1r167Jp1WrVg3Nmzd/pQI3IiIiIn1RK3gzNzdHTk6OrvJCREREROVQu8PC2LFjsWDBAhQUFOgiP0RERGQCCqUC4pIe46f4e4hLeoxCaYVaadFL1O6wcO7cOcTGxuLQoUNo3LgxrKysFL7fs2eP1jJHRERExicmIQWz911FSuZ/tXVuthJE9fBBV1+OTFFRagdvdnZ26NOnjy7yQkREREYuJiEFYzZfRPFyttTMHIzZfBErBzdnAFdBagdvGzZs0EU+iIiIyMgVSgXM3ne1ROAGAAIAEYDZ+66ii48rzMSiSs6d6VC7zRsRERGRMmeT0xWqSosTAKRk5uBscnrlZcoEqV3y1qxZM4hEJaNlkUgEiUSCunXrYujQoejYsaNWMkhERETG4cFT1UakUDUdKad2yVvXrl3xzz//wMrKCh07dkTHjh1hbW2NpKQktGzZEikpKQgJCcFPP/2ki/wSERGRgXKuLtFqOlJO7ZK3R48e4cMPP8Snn36qMP3zzz/Hv//+i0OHDiEqKgpz5sxBz549tZZRIiIiMmwBXvZws5UgNTNHabs3ALC3Mod/7RqVmi9To3bJ286dOxEeHl5i+sCBA7Fz504AQHh4uPzl9URERPRqMBOLENXDB0BR5wRl0rPzEbzwGGISUiovYyZG7eBNIpHg1KlTJaafOnUKEklRMahUKpX/n4iIiF4dXX3dsHJwc7jalh4HyIYNYQCnGbWrTcePH4/3338fFy5cQMuWLQEUDdz77bff4n//+x8A4ODBg/Dz89NqRomIiMg4dPV1Q6cGLmgVHYv07LwS33PYkIoRCYKg9vsqtmzZgmXLlsmrRuvXr4/x48fjnXfeAQC8ePFC3vvUVGVlZcHW1haZmZmwsbHRd3aIiIgMSlzSY4SvPV1uum0jWyHI26ESclTEFJ7fape8AcCgQYMwaNCgUr+vWrWqxhkiIiIi48dhQ3RHo+ANAC5cuIBr164BABo1aoRmzZppLVNERERk3DhsiO6oHbw9ePAAAwcOxPHjx2FnZwcAyMjIQMeOHbF9+3Y4OTlpO49ERERkZMobNkQEwNVWggAv+8rOmtFTu7fp+PHj8fTpU1y5cgXp6elIT09HQkICsrKyMGHCBF3kkYiIiIxMWcOGyP6O6uHDzgoaULvDgq2tLY4cOSLvaSpz9uxZvPHGG8jIyNBm/gyWKTR4JCIi0rWYhBTM3ndV4Z2nbrYSRPXwQVdft0rPjyk8v9WuNpVKpTA3Ny8x3dzcHFKpVCuZIiIiItPQ1dcNXXxccTY5HQ+e5sC5elFVKUvcNKd2tWmnTp0wceJE3L9/Xz7t3r17mDx5Mjp37qxRJpYvXw5PT09IJBIEBgbi7NmzZabftWsXGjRoAIlEgsaNG+OXX35R+F4kEin9LFy4UJ7G09OzxPfz58/XKP9ERERUOjOxCEHeDujpVxNB3g4M3CpI7eBt2bJlyMrKgqenJ7y9veHt7Q0vLy9kZWXhm2++UTsDO3bsQGRkJKKionDx4kU0bdoUoaGhePDggdL0p06dQnh4OEaMGIE///wTYWFhCAsLQ0JCgjxNSkqKwmf9+vUQiUTo06ePwrI+++wzhXTjx49XO/9ERERElUmjQXoFQcCRI0dw/fp1AEDDhg0REhKiUQYCAwPRsmVLLFu2DEBRtayHhwfGjx+PadOmlUg/YMAAZGdnY//+/fJprVq1gp+fH1atWqV0HWFhYXj69CliY2Pl0zw9PTFp0iRMmjRJo3ybQp05ERHRq8YUnt9ql7wBRdWSXbp0wfjx4zF+/HiNA7e8vDxcuHBBYX6xWIyQkBDExcUpnScuLq7E+kJDQ0tNn5aWhgMHDmDEiBElvps/fz4cHBzQrFkzLFy4EAUFBRptBxEREVFl0WiQ3nPnzuHYsWN48OBBiU4KX331lcrLefToEQoLC+Hi4qIw3cXFRV6qV1xqaqrS9KmpqUrTb9q0CdWrV0fv3r0Vpk+YMAHNmzeHvb09Tp06henTpyMlJaXU/Ofm5iI3N1f+d1ZWVrnbR0RERKRtagdv8+bNw4wZM1C/fn24uLhAJPqv0eHL/zcU69evx6BBg0q8ZzUyMlL+/yZNmsDCwgKjR49GdHQ0LC0tSywnOjoas2fP1nl+iYiIiMqidvC2ZMkSrF+/HkOHDq3wyh0dHWFmZoa0tDSF6WlpaXB1dVU6j6urq8rpf//9dyQmJmLHjh3l5iUwMBAFBQW4desW6tevX+L76dOnKwR8WVlZ8PDwKHe5RERERNqkdps3sViMNm3aaGXlFhYW8Pf3V+hIIJVKERsbi6CgIKXzBAUFKaQHgMOHDytNv27dOvj7+6Np06bl5iU+Ph5isRjOzs5Kv7e0tISNjY3Ch4iIiKiyqR28TZ48GcuXL9daBiIjI7F27Vps2rQJ165dw5gxY5CdnY1hw4YBAIYMGYLp06fL00+cOBExMTH48ssvcf36dcyaNQvnz5/HuHHjFJablZWFXbt24b333iuxzri4OCxevBiXLl3CP//8gy1btmDy5MkYPHgwatSoobVtIyIiItI2tatNp0yZgu7du8Pb2xs+Pj4l3rawZ88etZY3YMAAPHz4EDNnzkRqair8/PwQExMj75Rw+/ZtiMX/xZitW7fG1q1bMWPGDPzvf/9DvXr1sHfvXvj6+iosd/v27RAEAeHh4SXWaWlpie3bt2PWrFnIzc2Fl5cXJk+erFAtSkRERGSI1B7nbdy4cfj222/RsWPHEh0WAGDDhg1azaChMoVxYoiIiF41pvD8VrvkbdOmTdi9eze6d++ui/wQERERURnUbvNmb28Pb29vXeSFiIiIiMqhdvA2a9YsREVF4fnz57rIDxERERGVQe1q06VLlyIpKQkuLi7w9PQs0WHh4sWLWsscERERESlSO3gLCwvTQTaIiIiISBVq9zalIqbQW4WIiOhVYwrPb7XbvAFARkYGvv32W0yfPh3p6ekAiqpL7927p9XMEREREZEitatN//rrL4SEhMDW1ha3bt3CyJEjYW9vjz179uD27dv47rvvdJFPIiIiIoIGJW+RkZEYOnQobty4AYlEIp/erVs3nDhxQquZIyIiIiJFagdv586dw+jRo0tMr1mzJlJTU7WSKSIiIiJSTu3gzdLSEllZWSWm//3333ByctJKpoiIiIhIObWDt7fffhufffYZ8vPzAQAikQi3b9/G1KlT0adPH61nkIiIiIj+o3bw9uWXX+LZs2dwdnbGixcvEBwcjLp166J69eqYO3euLvJIRERERP9P7d6mtra2OHz4MP744w/89ddfePbsGZo3b46QkBBd5I+IiIiIXsJBejVkCoP8ERERvWpM4fmtVsmbVCrFxo0bsWfPHty6dQsikQheXl7o27cv3n33XYhEIl3lk4iIiIigRps3QRDw9ttv47333sO9e/fQuHFjNGrUCP/++y+GDh2KXr166TKfRERERAQ1St42btyIEydOIDY2Fh07dlT47ujRowgLC8N3332HIUOGaD2TREREZLgKpQLOJqfjwdMcOFeXIMDLHmZi1sbpispt3t544w106tQJ06ZNU/r9vHnz8Ntvv+HgwYNazaChMoU6cyIiooqKSUjB7H1XkZKZI5/mZitBVA8fdPV102POlDOF57fK1aZ//fUXunbtWur3b775Ji5duqSVTBEREZHhi0lIwZjNFxUCNwBIzczBmM0XEZOQoqecmTaVg7f09HS4uLiU+r2LiwuePHmilUwRERGRYSuUCpi97yqUVd/Jps3edxWFUg5qoW0qB2+FhYWoUqX0JnJmZmYoKCjQSqaIiIjIsJ1NTi9R4vYyAUBKZg7OJqdXXqZeESp3WBAEAUOHDoWlpaXS73Nzc7WWKSIiIjJsD56WHrhpko5Up3LwFhERUW4a9jQlIiJ6NThXl2g1HalO5eBtw4YNuswHERERGZEAL3u42UqQmpmjtN2bCICrbdGwIaRdar+YnoiIiMhMLEJUDx8ARYHay2R/R/Xw4XhvOsDgjYiIiDTS1dcNKwc3h6utYtWoq60EKwc3N8hx3kyBWu82JSIiInpZV183dPFx5RsWKhGDNyIiIqoQM7EIQd4O+s7GK4PVpkRERERGhMEbERERkRFhtSkRERFpTaFUYPs3HWPwRkRERFoRk5CC2fuuKrw2y81WgqgePux5qkUGUW26fPlyeHp6QiKRIDAwEGfPni0z/a5du9CgQQNIJBI0btwYv/zyi8L3Q4cOhUgkUvh07dpVIU16ejoGDRoEGxsb2NnZYcSIEXj27JnWt42IiOhVEJOQgjGbL5Z432lqZg7GbL6ImIQUPeXM9Og9eNuxYwciIyMRFRWFixcvomnTpggNDcWDBw+Upj916hTCw8MxYsQI/PnnnwgLC0NYWBgSEhIU0nXt2hUpKSnyz7Zt2xS+HzRoEK5cuYLDhw9j//79OHHiBEaNGqWz7SQiIjJVhVIBs/ddVfqmBdm02fuuolCqLAWpSyQIgl73ZGBgIFq2bIlly5YBAKRSKTw8PDB+/HhMmzatRPoBAwYgOzsb+/fvl09r1aoV/Pz8sGrVKgBFJW8ZGRnYu3ev0nVeu3YNPj4+OHfuHFq0aAEAiImJQbdu3XD37l24u7uXm++srCzY2toiMzMTNjY26m42ERGRyYhLeozwtafLTbdtZCu9DyliCs9vvZa85eXl4cKFCwgJCZFPE4vFCAkJQVxcnNJ54uLiFNIDQGhoaIn0x48fh7OzM+rXr48xY8bg8ePHCsuws7OTB24AEBISArFYjDNnzihdb25uLrKyshQ+REREBDx4mlN+IjXSUdn0Grw9evQIhYWFcHFxUZju4uKC1NRUpfOkpqaWm75r16747rvvEBsbiwULFuC3337Dm2++icLCQvkynJ2dFZZRpUoV2Nvbl7re6Oho2Nrayj8eHh5qby8REZEpcq4uKT+RGumobCbZ23TgwIHy/zdu3BhNmjSBt7c3jh8/js6dO2u0zOnTpyMyMlL+d1ZWFgM4IiIiAAFe9nCzlSA1M0dpuzcRit53GuBlX9lZM0l6LXlzdHSEmZkZ0tLSFKanpaXB1dVV6Tyurq5qpQeAOnXqwNHRETdv3pQvo3iHiIKCAqSnp5e6HEtLS9jY2Ch8iIiIqOj1WFE9fAAUBWovk/0d1cOH471piV6DNwsLC/j7+yM2NlY+TSqVIjY2FkFBQUrnCQoKUkgPAIcPHy41PQDcvXsXjx8/hpubm3wZGRkZuHDhgjzN0aNHIZVKERgYWJFNMkiFUgFxSY/xU/w9xCU9Zm8fIiLSuq6+blg5uDlcbRWrRl1tJVg5uDnHedMivfc23bFjByIiIrB69WoEBARg8eLF2LlzJ65fvw4XFxcMGTIENWvWRHR0NICioUKCg4Mxf/58dO/eHdu3b8e8efNw8eJF+Pr64tmzZ5g9ezb69OkDV1dXJCUl4eOPP8bTp09x+fJlWFpaAgDefPNNpKWlYdWqVcjPz8ewYcPQokULbN26VaV8G0tvFQ6YSERElcnQ37BgLM/vsui9zduAAQPw8OFDzJw5E6mpqfDz80NMTIy8U8Lt27chFv9XQNi6dWts3boVM2bMwP/+9z/Uq1cPe/fuha+vLwDAzMwMf/31FzZt2oSMjAy4u7vjjTfewJw5c+SBGwBs2bIF48aNQ+fOnSEWi9GnTx8sXbq0cjdex2QDJhaPzmUDJvKXEBERaZuZWKT34UBMnd5L3oyVoUfuhVIBbRccLTHStYys8egfUzsZ1C8iIiIiXTL057cq9P6GBdKNs8nppQZuQNGI1ymZOTibnF55mSIiIqIKY/BmojhgIhERkWli8GaiOGAiERGRaWLwZqJkAyaW1ppNhKJepxwwkYiIyLgweDNRHDCRiIjINDF4M2EcMJGIiMj06H2cN9Ktrr5u6OLjatADJhIREZHqGLy9AjhgIhERkelgtSkRERGREWHwRkRERGREGLwRERERGREGb0RERERGhMEbERERkRFh8EZERERkRBi8ERERERkRBm9ERERERoTBGxEREZERYfBGREREZEQYvBEREREZEb7blIiIiFRWKBVwNjkdD57mwLm6BAFe9jATi/SdrVcKgzciIiJSSUxCCmbvu4qUzBz5NDdbCaJ6+KCrr5sec/ZqYbUpERERlSsmIQVjNl9UCNwAIDUzB2M2X0RMQoqecvbqYfBGREREZSqUCpi97yoEJd/Jps3edxWFUmUpSNsYvBEREVGZzianlyhxe5kAICUzB2eT0ysvU68wBm9ERERUpgdPSw/cNElHFcPgjYiIiMrkXF2i1XRUMQzeiIiIqEwBXvZws5WgtAFBRCjqdRrgZV+Z2XplMXgjuUKpgLikx/gp/h7ikh6z4amB4HEhIn0zE4sQ1cMHAEoEcLK/o3r4cLy3SsJx3ggAx+4xVDwupomDnJIx6urrhpWDm5e4J7nynlTpRIIg8Ge8BrKysmBra4vMzEzY2NjoOzsVIhu7p/iJIHuUrBzcnBelHvC4mCYG5GTsjP3Hhyk8vxm8acgUDj5QdBG2XXC01C7gIhT9qvpjaiejujiNHY+LaWJArhvGHkxQ5TKF5zerTV9x6ozdE+TtUHkZM1LaeojwuJie8gY5FaFokNMuPq4MPNRgDCWZDC5J2wyiw8Ly5cvh6ekJiUSCwMBAnD17tsz0u3btQoMGDSCRSNC4cWP88ssv8u/y8/MxdepUNG7cGFZWVnB3d8eQIUNw//59hWV4enpCJBIpfObPn6+T7TNkHLtHe2ISUtB2wVGErz2NidvjEb72NNouOKrRK2N0fVzYCaLycZBT7TOG1zVp875AJKP34G3Hjh2IjIxEVFQULl68iKZNmyI0NBQPHjxQmv7UqVMIDw/HiBEj8OeffyIsLAxhYWFISEgAADx//hwXL17Ep59+iosXL2LPnj1ITEzE22+/XWJZn332GVJSUuSf8ePH63RbDRHH7tEObT9EdHlc+DDRD/5QKp0mPyaM4XVNxhBcknHSe5u3wMBAtGzZEsuWLQMASKVSeHh4YPz48Zg2bVqJ9AMGDEB2djb2798vn9aqVSv4+flh1apVStdx7tw5BAQE4N9//8Vrr70GoKjkbdKkSZg0aZJG+TaFOnPgv7ZVqZk5Sm+CbFtVPl20T9PVcWGbK/2JS3qM8LWny023bWSrV6oqXNNqT0Pfn8bUbvVVq9Y1hee3Xkve8vLycOHCBYSEhMinicVihISEIC4uTuk8cXFxCukBIDQ0tNT0AJCZmQmRSAQ7OzuF6fPnz4eDgwOaNWuGhQsXoqCgoNRl5ObmIisrS+FjCjh2T8XpojpMF8fFGEoqTNmrMMipuiVoFSmZMvSSTGOpJmdJvHHSa/D26NEjFBYWwsXFRWG6i4sLUlNTlc6TmpqqVvqcnBxMnToV4eHhChH2hAkTsH37dhw7dgyjR4/GvHnz8PHHH5ea1+joaNja2so/Hh4eqm6mwZON3eNqq1gF52or0VtJjDG1ydLVQ0Tbx8WQHybGdLw1Zeo/lNQNAir6Y0LVJgOPnubq5bwy9OASYLWuMTPp3qb5+fno378/BEHAypUrFb6LjIyU/79JkyawsLDA6NGjER0dDUtLyxLLmj59usI8WVlZJhfAdfFxNYiic2PoPfYyXbZP0+ZxMdSHibEd74ow1UFOS6uOlwUByn5sVLRHtawks7SmBQAgFgFzDlyT/63peaVJtaI27gu6rM5k72fjptfgzdHREWZmZkhLS1OYnpaWBldXV6XzuLq6qpReFrj9+++/OHr0aLn12oGBgSgoKMCtW7dQv379Et9bWloqDepMiZlYpPe2Npo8BPStvIeIrG2LptVh2jouuu6cosmDxhiPd0UZ0g8lbdA0CKjojwlZSeaYzRchApSuv3hBmybnlaY/Lip6X9D1jxoOR2Tc9FptamFhAX9/f8TGxsqnSaVSxMbGIigoSOk8QUFBCukB4PDhwwrpZYHbjRs3cOTIETg4lH/ixcfHQywWw9nZWcOtoYoy1jZZxlIdpss2V5q0mzHW460NsoC8p19NBHk7qN120ZCqmDWtjtfGj4nSmhaUtjvVPa8qUq1YkfuCNqszSztftFESb2jn4qtE79WmkZGRiIiIQIsWLRAQEIDFixcjOzsbw4YNAwAMGTIENWvWRHR0NABg4sSJCA4Oxpdffonu3btj+/btOH/+PNasWQOgKHDr27cvLl68iP3796OwsFDeHs7e3h4WFhaIi4vDmTNn0LFjR1SvXh1xcXGYPHkyBg8ejBo1auhnR5BR/xI0huqwskoqKhJkalp6ZszHW18MsYpZ0yBAWyXWxUsyHz3NVagqLU7V80ob1Yqa3Be0WZ1Z1vlS0eDZEM/FV4neg7cBAwbg4cOHmDlzJlJTU+Hn54eYmBh5p4Tbt29DLP6vgLB169bYunUrZsyYgf/973+oV68e9u7dC19fXwDAvXv38PPPPwMA/Pz8FNZ17NgxdOjQAZaWlti+fTtmzZqF3NxceHl5YfLkyQpt2qjyGWqbLFUZQ3WYtoPMijxojP14VzZDrWLWNAjQ5o+Jl5sW/BR/T6X8lHdeaevHhbr3BW2tt7zzZfk7zTQOng31XHyV6D14A4Bx48Zh3LhxSr87fvx4iWn9+vVDv379lKb39PREeUPXNW/eHKdPlz8+EGlOXw189c0Q2g2WR5tBZkUeNKZwvFWhjUbnhty4vCIlaLoosdbWeaXNHxfq3Be0VZ1Z3vky58A1fNrdB2O3qhc8G/K5+CoxiOCNTIu+GviaisoYMFNbQWZFHjT6Ot6a7F9Nj4m2qpYMuYrZTCzC203dsPpEcqlpyipB03aJtbbOK339uNDGelU9X2pYWagdPBvyufgqYfBGWlWR4nRdtckyJsbWjqQiDxp9HG9N9q+mx0SbVUuGXMUck5CCNWUEbqPae5W7ndossdbWeaXqUCRPsvO0kGvV16tK8KnO+dLTr6ZawbMhn4uvEr2/25RMhzZ6DxrigMGVxRgHzKxoD9bKPN6a7F9Nj4m2e9IaahVzWdsp8/OllErvhaiN8+rl3qKlkQrA2K2aXZul9dQsq5cqUHT+DGxZ9hij6p4v6vR+NtRz8VXDkjfSGn018DUFxtqORBulHNo63mVVbWqyfytyTLRdtWSoTQrK205Af1Vo2jivuvq6Yfk7zTBu258lxox7mbrXZnmluaW1BZT5+sgNbD93p9TSX12eL4Z6Lr5qWPJGWqOLBr6ajINljAz51VXl0VYpR0WOd3njzGmyfytyTLRdtaTNsQS1OTaXoVehaeM+UsPKsszATd1rU9XS3K6+bvhjaidMDnld6XLKKv3V5diTxjKupaljyRtpDYvTNWfoD8Hy6LO0VJW2ZbkFUpWW9fL+rcgx0cW1oI2emdpuU/kqXPMVOQ+Klwb7166hdmnu9nO3la6vvNJfXY49aQzjWpo6Bm9UKnV72LE4XXOm8BDUxzApqlZtLurXVKXlOVeXyM/7G2lPVZ6nOF1dCxUJklUJctVd9qtwzWt6bSoLlO2tzJGenV/qMopXp1e0+l2XP6pexeYthoTBGymlyS909hbV3KvwENQFVR9uEKDS/n2SnYe2C46W247r5XmUHRNdXguaBMmqBLnT9lzGrJ+vIjWL1/zLNLk2SwuUywrcXiYrxVO11O/X/686VRY86fJHlTGMa2mq2OaNSqhIr8dXubdoRbAdiWZUfbg9ys4td/++3dQNY7eWPO+VUeWYGNK1oEqQm/E8XyFwA3jNA+pfm6r0wC2PrBRP1VK/7+L+VWjnyXeOmj6RUN7rCEiprKws2NraIjMzEzY2NvrOjtYUSoUySx5kvzL/mNqpzECiMgaaNUXGNs6bvsUlPUb42vLflrJtZCsEeTuUun8/7d4Qcw5cUylwk82j6jExhGvhp/h7mLg9XqN5ec0XUfXaVPWcVKb4vpbdj8saa674/AIAu2rmyHj+Xykf7yGKTOH5zWpTUqCtIQ5YnK4ZbbYjMfWHKQD4164BeysLpJcyUKrsYehfuwbikh4jt0CKRX2bAiLg0bNc+X5RZcgLABjXsS7a1HVUa18awrVQkbaSr8I1r8q1ouq1qWmnItlSPu3eUGEdpb3CShnZ9y8HbgDfOWqKGLyRAmPv9WgKtPEQfBVK8GTbWFbgBhRVhwYvPKZ0X8j2s6rncz0X60oJULQZeBdKBUilAuyqmiPjhWptrpQx1WtenWtFlWtT1UC5+I8O26rmaFvPEZ/tv1ai3eGo9l74+VKKyiXDxb08MLShjRVJmmHwRgpModfjy16F0qfitPlaJm3S5rEobRtf5morwdtN3bDmRHK5+8KQznttBt7KlqUpY7nm1aGtayWvQIrv427h3/Tn8KhRFa42EqRlld3B4bePOmLl8SRsOJmMjBf5yHiRj/1/lWxbmJqZgzUnkrH8nWaoYWWJXxNS8F3cvxptL985ajoYvJECU+r1aIqlT+UFQIb6pgZtHgtVGoTbW5nj6Icd0OnL4yrtiwAv+xLthF5WWee9NgNvVQJcAHC1sUROgRSZz/ON/ppXh7aulehfrmLt78kKA/nKqjjL6oF79HoaFh/5W6WqUBGAOQeu4Y+pnQBA4+ANQIlOKeV5FX8AGwMGb6TAVLr+G2rpU0WoEgBp+7VM2qDtY6FK+7T07HxsPfOvyvsi80VeqYGbLK2uz3ttBt6qBLh2Vc2xfFBztKrjgMNXU1W+5k3lYa6NayX6l6tYfSJZ6bwAUM3CDNl5hfLpskFsu/i4ou2Coyr3SH05L+X9wC5P+rNcldOa4g9gU8GhQqgEY+/6r+2XghsCVYdvMbQ2i7o4Fqrm/d/05yqlS818gdn7rpaZxq6aObr4uKq0PE1p8xVpqgS4GS/yIRaJYCYWqXzNxySkoM38WIXXkLWZH6vRi9m1RdNhMSp6reQVSLH295KB28ue5xXi++EBWDLQD9tGtsIfUzuhq6+byh1klOWlvBfXl8feykKldBUZMop0jyVvpJQxj55tiKVPFaFOiYwhtd0CdHMsVM17bftqKqVLz84rP9B5nq/z80Wbgbcmyyrvmo9JSMH7my+WWEZqVi7e33wRq9T8YaeNEryKlAxV9Fr5Pu5Wme88BYrO77/TnmJEuzoK0zX98STLS3kvri+Lq23VctMYavML+g+DNyqVsXb9N7TSp4pSJwAytDaLujgWqm7ju0Ge+PaP5HLT2Vtbaj2PmtBm4K3pskq75gulAqbtuVzmsqbtuazyw1wb1XEVrY6v6LWiasmusnTq/nhSlpfiwbajlSU+3HWpzDZtbipe+6b2A9gUsdqUTI6hlT5VlDoBkKG9qUEXx0LVbbSoIlYpnauNYZwvsmCitCMjQvkPX1kVYmrmC9hbWVRoWS87nfS4zDaBQFHp5Omkx+UuSxvVcdqojq/otaJqya6ydOUda1XzIgu2e/rVRJt6jpj1tk+Zx1zVa9/UfgCbIgZvZJTKaueijYegIVE3ADKkNou6OhaqbqMq6QzlfKloMBGTkIK2C44ifO1pTN55CenZeaWWKJW3rOLi/nmklXTaagOprfaBFblW3g3yRHm7TywqSlecOu3W1LluZdvjVmx73JQso6x7qKn9ADZFrDYlo1NelYup9JiV0aR6x1DaLGrjWJTWNkrVbSwvnSGdL6W1ZXItp0pR1WFBVFmWcqpue9nptFUdp82SIU2vFYsqYoxs56W0t6nMyHZesKiivIyk1GNtY4nwgNfg6Wil0XWryvaUdw81tOYXVBLfbaohU3g3mjEq7SEluy0V7xlnKt3cZdsNKA8uDL0XsKbHojKPoSGdL+o05i/vfcRA0bh3n77VCK42mgXxJ28+wqBvz5Sbbst7gWhT17HU71V9x+qSgX7o6Vez1O/VfaetutTZ/8rGeROLigK36d18tLoubVD1Hmrs95yymMLzm8Gbhkzh4Bub8h5Syl6gbSpjUgHKg4uK/kovj7Zf06TOstQJ1LXFGM8XXQcyQNF+8f/8cJnt3mpUM8f5GV3K3F/aymt5L2xXdi9QlSZB/MtvWKhtXw3vBnmWWuKmT+reQw3pB402mcLzm9WmZDQ0qXIx1h6zyhSvDrn16Dm2nb2Nr4/ckKfR5o1V2zdudY6FvoYqMMbzpTIal5uJRZjfu7HSoUJkons3LvdY+NeuUeKdni9TtTpOV1XdmvZgtagiLjEciCFS9x5qKM0vqCTD+2lAVApj7wGl6WCiL5MFF5ZVxFh85O8SwwJoawBNfQ/Qqc0BayuTNo6xuiqrcXlXXzesGty8RO9cN1uJSmO8xSSkIHjhsTIDN0D1oEvbHXNMcXDv4tS9hxpjSfSrgiVvZDSMuQdUTEIKZv18VSHYcrWRYNbb2n23pzZKpQxhgE5jDNT1VcVUmY3LNS2JUaVDhSYdKbRZMvQqjG2mzj3UVKtMTQVL3shoGMqQDuqSjUxfopQsKwfva1CKpetSKUMo9TK2QF2fJZWVPbbfy2OLBXk7aOU9q/ZW5vjto44Vqo5Xlh91SkKN8QeDulS9hz7JzuOrsQwcgzcyGvocgFbT6jBVRqafvueyTt7tqelDxhAeYsYUqGuzuk3T88yQxvYrTpX3eKZn5+PCv0+0ut6Xx72TvYe17YKjpQYexvaDQROq3EM/7d4Qcw6YdvWxKWC1KRkVTcfBqoiKVB+c/qf8kemfPM/H6X8elznEwst0/ZAxhIeYIY29Vh5tVbdVtJrKUBuX6+PHgCYdD16Vsc3Ku4faVrUw+epjU8DgjSqNthq/VuZDqqLvT4xT4XVBsnSqBm+6fsgYykNMH4G6JrQRnFT0PJMxxN6y2vgxoO64d5q02TSmHwwVVdY99Kf4eyotw5irj00BgzcTZWi9hPQ57ISmtNNwX9WqBdWrIHT9kNHm8it6HhpqadLLKhqcGEIHEV2q6I8Bde8dFSkJNZYfDNpQ2j3UEEreqXwM3gyItgIuQ+slpK1ShcoiOw4nbz6scPVBUB1HLDuWVO46g+qoVuomo+uHjDaWr63z0BBLk15W0eDE1Hs5VuTHgCb3joqWhBrDDwZtKv7c8a9dwyBK3qlsBhG8LV++HAsXLkRqaiqaNm2Kb775BgEBAaWm37VrFz799FPcunUL9erVw4IFC9CtWzf594IgICoqCmvXrkVGRgbatGmDlStXol69evI06enpGD9+PPbt2wexWIw+ffpgyZIlsLa21um2lkZbDzpDC5SMrVRB2XEoT1kPi1beDrCrZl5muze7auZopcFDWdcPmYos39DOQ12qaEmlIXQQ0TVNfgxoeu/QRsmRof9g0JbSnjtvN3XDmhPJJl99bMz03tt0x44diIyMRFRUFC5evIimTZsiNDQUDx48UJr+1KlTCA8Px4gRI/Dnn38iLCwMYWFhSEhIkKf54osvsHTpUqxatQpnzpyBlZUVQkNDkZPz3wk6aNAgXLlyBYcPH8b+/ftx4sQJjBo1Sufbq4y2hhkwxEEmDWHYCVWVdhzKU95DYH7vxmXOP1+FkenLWr46wzZUxvIN8TzUtYr09nxVqqm6+rrhj6mdsG1kKywZ6IdtI1vhj6mdSt03mt47jKmnsj6V9dxZcyIZo9p7GWTvZSqi93ebBgYGomXLlli2bBkAQCqVwsPDA+PHj8e0adNKpB8wYACys7Oxf/9++bRWrVrBz88Pq1atgiAIcHd3x4cffogpU6YAADIzM+Hi4oKNGzdi4MCBuHbtGnx8fHDu3Dm0aNECABATE4Nu3brh7t27cHd3Lzff2no3mibv6yxNZbzjUF3aehG1rqnycu/i1Dk2RYP0XkFqVq58mquNJWa93cjkboSGeB5WFk2aPujyPZ3GrCL3DlN+qbo2qPrc+e2jjrjw7xOTqz7mu00rKC8vDxcuXMD06dPl08RiMUJCQhAXF6d0nri4OERGRipMCw0Nxd69ewEAycnJSE1NRUhIiPx7W1tbBAYGIi4uDgMHDkRcXBzs7OzkgRsAhISEQCwW48yZM+jVq1eJ9ebm5iI3978Hb1ZWlkbbXJw227sYYvWLsZQqqDIW1cs0eZXPq9KOxhDPw8qiSXXbq9TLUR0VuXe8Sh0PNKHqc+fCv09M7geWqdBr8Pbo0SMUFhbCxcVFYbqLiwuuX7+udJ7U1FSl6VNTU+Xfy6aVlcbZ2Vnh+ypVqsDe3l6eprjo6GjMnj1bxS1TnTYfdIYYKBnKsBPlUTeQ0OQh8Kq0ozHE89DQMdgoqaL3jlfpB5O6XuUfWKbCIDosGIPp06crlPhlZWXBw8OjwsvV5oPOEAMlYylVUPU4jOtYF23qOvIhUAZDPA+NAYMNRdq4d7wqP5jUxR9Yxk+vHRYcHR1hZmaGtLQ0helpaWlwdXVVOo+rq2uZ6WX/lpemeIeIgoICpKenl7peS0tL2NjYKHy0QZuNa/X5+qiyGPKre2RUPQ6Tu7yuk44BpsRQz0NjoOsOKMbGGO4dxoidOoyfXoM3CwsL+Pv7IzY2Vj5NKpUiNjYWQUFBSucJCgpSSA8Ahw8flqf38vKCq6urQpqsrCycOXNGniYoKAgZGRm4cOGCPM3Ro0chlUoRGBiote1ThbYfdIZ6s1O3p1llY8ChXYZ6HpLxMfR7hzHi/c746b236Y4dOxAREYHVq1cjICAAixcvxs6dO3H9+nW4uLhgyJAhqFmzJqKjowEUDRUSHByM+fPno3v37ti+fTvmzZuHixcvwtfXFwCwYMECzJ8/H5s2bYKXlxc+/fRT/PXXX7h69SokkqKHyZtvvom0tDSsWrUK+fn5GDZsGFq0aIGtW7eqlG9t91bR9sC6hvaGBWNhaAMcGzueh0SG61W935lCb1O9B28AsGzZMvkgvX5+fli6dKm8BKxDhw7w9PTExo0b5el37dqFGTNmyAfp/eKLL5QO0rtmzRpkZGSgbdu2WLFiBV5//XV5mvT0dIwbN05hkN6lS5eqPEivLg4+H3SGgceBiF4Vr+L9jsHbK8wUDj4REdGrxhSe33p/wwIRERERqY7BGxEREZERYfBGREREZEQYvBEREREZEQZvREREREaEwRsRERGREWHwRkRERGREGLwRERERGREGb0RERERGpIq+M2CsZC+myMrK0nNOiIiISFWy57Yxv2CKwZuGnj59CgDw8PDQc06IiIhIXU+fPoWtra2+s6ERvttUQ1KpFPfv30f16tUhEpn2S3xLk5WVBQ8PD9y5c8do3w+nC9wvynG/KMf9UjruG+W4X5RTdb8IgoCnT5/C3d0dYrFxth5jyZuGxGIxatWqpe9sGAQbGxveQJTgflGO+0U57pfScd8ox/2inCr7xVhL3GSMM+QkIiIiekUxeCMiIiIyIgzeSGOWlpaIioqCpaWlvrNiULhflON+UY77pXTcN8pxvyj3Ku0XdlggIiIiMiIseSMiIiIyIgzeiIiIiIwIgzciIiIiI8LgjYiIiMiIMHijMi1fvhyenp6QSCQIDAzE2bNnS027Z88etGjRAnZ2drCysoKfnx++//77Ssxt5VFnv7xs+/btEIlECAsL020G9USd/bJx40aIRCKFj0QiqcTcVh51z5eMjAyMHTsWbm5usLS0xOuvv45ffvmlknJbudTZNx06dChxzohEInTv3r0Sc1w51D1nFi9ejPr166Nq1arw8PDA5MmTkZOTU0m5rTzq7Jf8/Hx89tln8Pb2hkQiQdOmTRETE1OJudUhgagU27dvFywsLIT169cLV65cEUaOHCnY2dkJaWlpStMfO3ZM2LNnj3D16lXh5s2bwuLFiwUzMzMhJiamknOuW+ruF5nk5GShZs2aQrt27YSePXtWTmYrkbr7ZcOGDYKNjY2QkpIi/6SmplZyrnVP3f2Sm5srtGjRQujWrZvwxx9/CMnJycLx48eF+Pj4Ss657qm7bx4/fqxwviQkJAhmZmbChg0bKjfjOqbuftmyZYtgaWkpbNmyRUhOThYOHjwouLm5CZMnT67knOuWuvvl448/Ftzd3YUDBw4ISUlJwooVKwSJRCJcvHixknOufQzeqFQBAQHC2LFj5X8XFhYK7u7uQnR0tMrLaNasmTBjxgxdZE9vNNkvBQUFQuvWrYVvv/1WiIiIMMngTd39smHDBsHW1raScqc/6u6XlStXCnXq1BHy8vIqK4t6U9F7zNdffy1Ur15dePbsma6yqBfq7pexY8cKnTp1UpgWGRkptGnTRqf5rGzq7hc3Nzdh2bJlCtN69+4tDBo0SKf5rAysNiWl8vLycOHCBYSEhMinicVihISEIC4urtz5BUFAbGwsEhMT0b59e11mtVJpul8+++wzODs7Y8SIEZWRzUqn6X559uwZateuDQ8PD/Ts2RNXrlypjOxWGk32y88//4ygoCCMHTsWLi4u8PX1xbx581BYWFhZ2a4UFb3HAMC6deswcOBAWFlZ6SqblU6T/dK6dWtcuHBBXoX4zz//4JdffkG3bt0qJc+VQZP9kpubW6IpRtWqVfHHH3/oNK+VgS+mJ6UePXqEwsJCuLi4KEx3cXHB9evXS50vMzMTNWvWRG5uLszMzLBixQp06dJF19mtNJrslz/++APr1q1DfHx8JeRQPzTZL/Xr18f69evRpEkTZGZmYtGiRWjdujWuXLmCWrVqVUa2dU6T/fLPP//g6NGjGDRoEH755RfcvHkTH3zwAfLz8xEVFVUZ2a4Umt5jZM6ePYuEhASsW7dOV1nUC032yzvvvINHjx6hbdu2EAQBBQUFeP/99/G///2vMrJcKTTZL6Ghofjqq6/Qvn17eHt7IzY2Fnv27DGJH0IseSOtql69OuLj43Hu3DnMnTsXkZGROH78uL6zpTdPnz7Fu+++i7Vr18LR0VHf2TEoQUFBGDJkCPz8/BAcHIw9e/bAyckJq1ev1nfW9EoqlcLZ2Rlr1qyBv78/BgwYgE8++QSrVq3Sd9YMyrp169C4cWMEBAToOyt6d/z4ccybNw8rVqzAxYsXsWfPHhw4cABz5szRd9b0asmSJahXrx4aNGgACwsLjBs3DsOGDYNYbPyhD0veSClHR0eYmZkhLS1NYXpaWhpcXV1LnU8sFqNu3boAAD8/P1y7dg3R0dHo0KGDLrNbadTdL0lJSbh16xZ69OghnyaVSgEAVapUQWJiIry9vXWb6Uqg6fnyMnNzczRr1gw3b97URRb1QpP94ubmBnNzc5iZmcmnNWzYEKmpqcjLy4OFhYVO81xZKnLOZGdnY/v27fjss890mUW90GS/fPrpp3j33Xfx3nvvAQAaN26M7OxsjBo1Cp988olJBCua7BcnJyfs3bsXOTk5ePz4Mdzd3TFt2jTUqVOnMrKsU8Z/REknLCws4O/vj9jYWPk0qVSK2NhYBAUFqbwcqVSK3NxcXWRRL9TdLw0aNMDly5cRHx8v/7z99tvo2LEj4uPj4eHhUZnZ1xltnC+FhYW4fPky3NzcdJXNSqfJfmnTpg1u3rwpD/IB4O+//4abm5vJBG5Axc6ZXbt2ITc3F4MHD9Z1NiudJvvl+fPnJQI0WfAvmMjryytyvkgkEtSsWRMFBQXYvXs3evbsqevs6p6eO0yQAdu+fbtgaWkpbNy4Ubh69aowatQowc7OTj6cw7vvvitMmzZNnn7evHnCoUOHhKSkJOHq1avCokWLhCpVqghr167V1ybohLr7pThT7W2q7n6ZPXu2cPDgQSEpKUm4cOGCMHDgQEEikQhXrlzR1ybohLr75fbt20L16tWFcePGCYmJicL+/fsFZ2dn4fPPP9fXJuiMptdS27ZthQEDBlR2diuNuvslKipKqF69urBt2zbhn3/+EQ4dOiR4e3sL/fv319cm6IS6++X06dPC7t27haSkJOHEiRNCp06dBC8vL+HJkyd62gLtYbUplWrAgAF4+PAhZs6cidTUVPj5+SEmJkbeYPT27dsKv/ays7PxwQcf4O7du6hatSoaNGiAzZs3Y8CAAfraBJ1Qd7+8KtTdL0+ePMHIkSORmpqKGjVqwN/fH6dOnYKPj4++NkEn1N0vHh4eOHjwICZPnowmTZqgZs2amDhxIqZOnaqvTdAZTa6lxMRE/PHHHzh06JA+slwp1N0vM2bMgEgkwowZM3Dv3j04OTmhR48emDt3rr42QSfU3S85OTmYMWMG/vnnH1hbW6Nbt274/vvvYWdnp6ct0B6RIJhImSoRERHRK+DVKx4gIiIiMmIM3oiIiIiMCIM3IiIiIiPC4I2IiIjIiDB4IyIiIjIiDN6IiIiIjAiDNyIiIiIjwuCNiIiIyIgweCMigxcXFwczMzN0795d31khItI7vmGBiAzee++9B2tra6xbtw6JiYlwd3fXSz7y8vJM6uXwRGScWPJGRAbt2bNn2LFjB8aMGYPu3btj48aNCt/v27cPLVu2hEQigaOjI3r16iX/Ljc3F1OnToWHhwcsLS1Rt25drFu3DgCwcePGEu843Lt3L0QikfzvWbNmwc/PD99++y28vLwgkUgAADExMWjbti3s7Ozg4OCAt956C0lJSQrLunv3LsLDw2Fvbw8rKyu0aNECZ86cwa1btyAWi3H+/HmF9IsXL0bt2rUhlUorusuIyMQxeCMig7Zz5040aNAA9evXx+DBg7F+/XrIKgwOHDiAXr16oVu3bvjzzz8RGxuLgIAA+bxDhgzBtm3bsHTpUly7dg2rV6+GtbW1Wuu/efMmdu/ejT179iA+Ph4AkJ2djcjISJw/fx6xsbEQi8Xo1auXPPB69uwZgoODce/ePfz888+4dOkSPv74Y0ilUnh6eiIkJAQbNmxQWM+GDRswdOjQEi9iJyIqQSAiMmCtW7cWFi9eLAiCIOTn5wuOjo7CsWPHBEEQhKCgIGHQoEFK50tMTBQACIcPH1b6/YYNGwRbW1uFaT/++KPw8m0xKipKMDc3Fx48eFBmHh8+fCgAEC5fviwIgiCsXr1aqF69uvD48WOl6Xfs2CHUqFFDyMnJEQRBEC5cuCCIRCIhOTm5zPUQEQmCIPAnHhEZrMTERJw9exbh4eEAgCpVqmDAgAHyqs/4+Hh07txZ6bzx8fEwMzNDcHBwhfJQu3ZtODk5KUy7ceMGwsPDUadOHdjY2MDT0xMAcPv2bfm6mzVrBnt7e6XLDAsLg5mZGX788UcARVW4HTt2lC+HiKgsVfSdASKi0qxbtw4FBQUKHRQEQYClpSWWLVuGqlWrljpvWd8BgFgslle/yuTn55dIZ2VlVWJajx49ULt2baxduxbu7u6QSqXw9fVFXl6eSuu2sLDAkCFDsGHDBvTu3Rtbt27FkiVLypyHiEiGJW9EZJAKCgrw3Xff4csvv0R8fLz8c+nSJbi7u2Pbtm1o0qQJYmNjlc7fuHFjSKVS/Pbbb0q/d3JywtOnT5GdnS2fJmvTVpbHjx8jMTERM2bMQOfOndGwYUM8efJEIU2TJk0QHx+P9PT0Upfz3nvv4ciRI1ixYgUKCgrQu3fvctdNRASw5I2IDNT+/fvx5MkTjBgxAra2tgrf9enTB+vWrcPChQvRuXNneHt7Y+DAgSgoKMAvv/yCqVOnwtPTExERERg+fDiWLl2Kpk2b4t9//8WDBw/Qv39/BAYGolq1avjf//6HCRMm4MyZMyV6sipTo0YNODg4YM2aNXBzc8Pt27cxbdo0hTTh4eGYN28ewsLCEB0dDTc3N/z5559wd3dHUFAQAKBhw4Zo1aoVpk6diuHDh5dbWkdEJMOSNyIySOvWrUNISEiJwA0oCt7Onz8Pe3t77Nq1Cz///DP8/PzQqVMnnD17Vp5u5cqV6Nu3Lz744AM0aNAAI0eOlJe02dvbY/Pmzfjll1/QuHFjbNu2DbNmzSo3X2KxGNu3b8eFCxfg6+uLyZMnY+HChQppLCwscOjQITg7O6Nbt25o3Lgx5s+fDzMzM4V0I0aMQF5eHoYPH67BHiKiVxUH6SUi0pM5c+Zg165d+Ouvv/SdFSIyIix5IyKqZM+ePUNCQgKWLVuG8ePH6zs7RGRkGLwREVWycePGwd/fHx06dGCVKRGpjdWmREREREaEJW9ERERERoTBGxEREZERYfBGREREZEQYvBEREREZEQZvREREREaEwRsRERGREWHwRkRERGREGLwRERERGREGb0RERERG5P8AomzZ91lCNxEAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -832,7 +523,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 25, "metadata": { "execution": { "iopub.execute_input": "2024-06-17T19:19:35.958715Z", @@ -845,16 +536,16 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 10, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -876,7 +567,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 26, "metadata": { "execution": { "iopub.execute_input": "2024-06-17T19:19:41.725677Z", @@ -885,7 +576,18 @@ "shell.execute_reply": "2024-06-17T19:19:42.352414Z" } }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "#Do the same thing but for true negative difference. This fairness measure is analgous to equal opportunity but with the target label flipped.\n", "fpredictor = FairPredictor(predictor,train_data,'sex')\n", @@ -895,7 +597,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 27, "metadata": { "execution": { "iopub.execute_input": "2024-06-17T19:19:42.363041Z", @@ -911,13 +613,13 @@ "Text(0.5, 1.0, 'Levelling Down: Difference in True Negative Rate vs Accuracy trade-off')" ] }, - "execution_count": 12, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -935,7 +637,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 28, "metadata": { "execution": { "iopub.execute_input": "2024-06-17T19:19:43.150824Z", @@ -948,16 +650,16 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 13, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -967,7 +669,7 @@ } ], "source": [ - "# plot the trade-off for each group \n", + "# plot the trade-off for each group\n", "fpredictor.plot_frontier(objective1=gm.true_neg_rate.min,objective2=gm.accuracy, color='blue')\n", "fpredictor.plot_frontier(objective1=gm.true_neg_rate.max,objective2=gm.accuracy,new_plot=False,color='red')\n", "#plt.xlim(0.89,0.91)\n", @@ -979,7 +681,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 29, "metadata": { "execution": { "iopub.execute_input": "2024-06-17T19:19:44.607762Z", @@ -988,7 +690,18 @@ "shell.execute_reply": "2024-06-17T19:19:44.627734Z" } }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "#Instead perform levelling up, by increasing the minimal true negative rate per group\n", "fpredictor.fit(gm.accuracy,gm.true_neg_rate.min,0.99,grid_width=grid_width)" @@ -996,7 +709,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 30, "metadata": { "execution": { "iopub.execute_input": "2024-06-17T19:19:44.631829Z", @@ -1012,13 +725,13 @@ "Text(0.5, 1.0, 'Levelling Up: Minimum True NegativeRate vs Accuracy trade-off')" ] }, - "execution_count": 15, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1035,7 +748,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 31, "metadata": { "execution": { "iopub.execute_input": "2024-06-17T19:19:45.931923Z", @@ -1048,16 +761,16 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 16, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1077,7 +790,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 32, "metadata": { "execution": { "iopub.execute_input": "2024-06-17T19:19:48.608996Z", @@ -1093,13 +806,13 @@ "Text(0.5, 1.0, 'Levelling Up: Minimum True NegativeRate vs Accuracy trade-off')" ] }, - "execution_count": 17, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1113,6 +826,192 @@ "fpredictor.plot_frontier(objective1=gm.true_neg_rate.diff,objective2=gm.accuracy, show_updated=False)\n", "plt.title('Levelling Up: Minimum True NegativeRate vs Accuracy trade-off')\n" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we show that you can prevent levelling down by using the constraint `force_levelling_up='+'` when you call fit.\n", + "\n", + "We enforce demographic parity using this constraint.\n", + "\n", + "The curves we see are a subset of those generated by enforcing a minimal selection rate.\n", + "\n", + "The curve shows a steady increase in the minimal selection rate until approximate demographic parity occurs, then there is a jump to the constant classifier that gives everyone a positive decision, which is perfectly fair.\n", + "\n", + "The behavior can be somewhat unpredictable, and you can see the selection rate increasing for all groups, rather than just those with lower selection rates, if this causes a small improvement in fairness. Again this is due to quantization artifacts." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Now we illustrate forced levelling-up. We do not allow offsets to decrease the selection rate.\n", + "fpredictor_up = FairPredictor(predictor, train_data, 'sex')\n", + "# Maximize accuracy while enforcing that the demographic parity (the difference in positive decision rates between men and women is at most 0.02)\n", + "fpredictor_up.fit(gm.accuracy, gm.demographic_parity, 0.02, grid_width=grid_width, force_levelling_up='+')" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Forced levelling-up: Demographic Parity vs Accuracy trade-off')" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fpredictor_up.plot_frontier(objective1=gm.demographic_parity,objective2=gm.accuracy, show_updated=False)\n", + "plt.title('Forced levelling-up: Demographic Parity vs Accuracy trade-off')" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fpredictor_up.plot_frontier(objective1=gm.pos_pred_rate.min,objective2=gm.accuracy, color='blue',show_original=False)\n", + "fpredictor_up.plot_frontier(objective1=gm.pos_pred_rate.max,objective2=gm.accuracy,new_plot=False,color='red',show_original=False)\n", + "plt.xlim(left=0.75)\n", + "plt.title('Levelling Up: Minimum Positive Prediction Rate vs Accuracy trade-off')\n", + "plt.ylabel('Per Group Positive Prediction Rate')\n", + "plt.legend(('Frontier Min group Rate', 'Frontier Max group Rate',))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The same can also be done using `force_levelling_up='-'` if you want to decrease the selection rate.\n", + "\n", + "This is useful for preventing levelling down when enforcing equality of precision or specificity (which are monotone decreasing with respect to the selection rate). " + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Forced levelling-up: Equal Specificity vs Accuracy trade-off')" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHHCAYAAABXx+fLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACCp0lEQVR4nO3de3zL1/8H8FdSbdNWmyp6QWmVoYq6tYrpUGtdV2wuc6nLbLO5dsx1ytxmZmNjjBnmzlyGr5UqNpe61q3qUtRltIrSamlLcn5/+CUTTSufSnp9PR+PPLacz8kn7+TTJG/nKhNCCBARERGVIPKCDoCIiIgovzEBIiIiohKHCRARERGVOEyAiIiIqMRhAkREREQlDhMgIiIiKnGYABEREVGJwwSIiIiIShwmQERERFTiMAEqofr16wc3N7fX1nvnnXfwzjvvmDweQ7way/Xr1yGTybB8+XJt2eTJkyGTyfI/ODJYcblG+/fvh0wmw/79+3XKV65ciZo1a8Lc3Bz29vYA8v45kslkmDx58hvHSpQXy5cvh0wmw/Xr1wvk+ePi4vDuu+9CqVRCJpNh69atAIDjx4+jadOmsLGxgUwmw+nTp/N0fiZAEmj+GPTdxo4dW9DhEeX49ymTyfDpp58WdHiSbd++Hf7+/nB0dIS1tTWqVq2Kbt26ITw8vKBD0+vixYvo168fPDw8sGTJEixevNio5z98+DAmT56MR48eGfW8+UWlUqFChQqQyWT466+/CjqcIuXnn3/W+cdeSRASEoJz585h+vTpWLlyJRo1aoRnz57hgw8+QHJyMn744QesXLkSVapUydP5Sxk53hLh66+/hru7u06Zl5dXAUVDL5s4cWKJT0bbtGmDvn37Zit/6623CiCavPvuu+8wevRo+Pv7Y9y4cbC2tsaVK1ewZ88erFu3DkFBQQUaX4sWLfD06VNYWFhoy/bv3w+1Wo158+ahWrVq2vLdu3fn6TmePn2KUqX++5o+fPgwpkyZgn79+mlbl4qSvXv3IiEhAW5ubli9ejXatm1b0CEVGT///DPKlSuHfv36FXQo+eLp06eIiorChAkTMGTIEG35xYsXcePGDSxZsgQfffTRGz0HE6A8aNu2LRo1amT086anp8PGxsbo5y1JSpUqpfODURK99dZb6N27d0GH8UaeP3+OqVOnok2bNnqTh6SkpAKISpdcLodCodAp08T1anLycpIkxavnL+pWrVqFBg0aICQkBOPHjy+033nPnz+HWq3O83UraIX1fZXi3r17ALJ/lnL6jOUFu8BMYO/evXj77bdhY2MDe3t7vPfee7hw4YJOHc04iNjYWHz44YcoU6YMmjdvrj2+atUq+Pj4wNraGmXKlEGLFi2y/RD89ddf2uextbVF+/btcf78+WzxbN26FV5eXlAoFPDy8sKWLVve6PVlZmYiLCwM1apVg6WlJVxdXfHll18iMzNTW8fLywstW7bM9li1Wo2KFSvi/fff1ymbO3cuateuDYVCAScnJ3zyySd4+PCh5Nj0jS+RyWQYMmSI9n2wtLRE7dq19Xaj7N+/H40aNYJCoYCHhwd++eUXg8es5DQmRN9YpX79+qF06dK4du0aAgMDYWNjgwoVKuDrr7+GEELn8QkJCbh48SKePXtm+BthgMWLF8PDwwNWVlbw8fHBgQMHso1VyWkMgL7XeuDAAXzwwQeoXLmy9u9i5MiRePr0qeTY7t+/j9TUVDRr1kzvcUdHx2yxrF+/HuPHj4ezszNsbGzQqVMn3Lp1K9tjjx49iqCgICiVSlhbW8Pf3x+HDh3KVu/27dsYOHAgKlSoAEtLS7i7u2Pw4MHIysrS+x64ubkhLCwMAFC+fHmd8Tv6xgBlZGRg8uTJeOutt6BQKODi4oIuXbrg6tWr2jovn2Py5MkYPXo0AMDd3V3btXn9+nX4+/ujXr16et+rGjVqIDAwUO8xAOjQoQOqVq2q95ifn5/OP/YiIiLQvHlz2Nvbo3Tp0qhRowbGjx+f47lf9vTpU2zZsgU9evRAt27d8PTpU/z555966/7111/w9/eHra0t7Ozs0LhxY6xZs0anztGjR9GuXTuUKVMGNjY2qFu3LubNm6c9ntO4q1fHP2o+n9999x3mzp0LDw8PWFpaIjY2FllZWZg0aRIaNmwIpVIJGxsbvP3229i3b1+282pa/urUqQOFQoHy5csjKCgIJ06cAIA3ukZubm44f/48/v77b+1117w2zWf077//xmeffQZHR0dUqlQJAHDjxg189tlnqFGjBqysrFC2bFl88MEHesf0nD9/Hq1atYKVlRUqVaqEadOmQa1W643H0N+enJw6dQpt27aFnZ0dSpcujdatW+PIkSPa45MnT9Z2a40ePRoymQxubm7o168f/P39AQAffPCBzvuQFyX7n8p5lJKSgvv37+uUlStXDgCwZ88etG3bFlWrVsXkyZPx9OlT/PTTT2jWrBmio6OzDTz+4IMPUL16dcyYMUP7wzdlyhRMnjwZTZs2xddffw0LCwscPXoUe/fuxbvvvgvgxUDLkJAQBAYGYtasWXjy5AkWLlyI5s2b49SpU9rn2b17N7p27QpPT0/MnDkTDx48QP/+/bUfEKnUajU6deqEgwcP4uOPP0atWrVw7tw5/PDDD7h8+bJ2kFr37t0xefJkJCYmwtnZWfv4gwcP4s6dO+jRo4e27JNPPsHy5cvRv39/DBs2DPHx8Zg/fz5OnTqFQ4cOwdzcPE+xvuzgwYPYvHkzPvvsM9ja2uLHH39E165dcfPmTZQtWxbAiw9lUFAQXFxcMGXKFKhUKnz99dcoX778Gz+/PiqVCkFBQWjSpAm+/fZbhIeHIywsDM+fP8fXX3+trTdu3DisWLEC8fHxBg1cz8jIyPb3CQB2dnbaf9EuXboUn3zyCZo2bYoRI0bg2rVr6NSpExwcHODq6pqn17Nx40Y8efIEgwcPRtmyZXHs2DH89NNP+Pfff7Fx40ZJ53J0dISVlRW2b9+OoUOHwsHB4bWPmT59OmQyGcaMGYOkpCTMnTsXAQEBOH36NKysrAC8+MdJ27Zt0bBhQ4SFhUEul2PZsmVo1aoVDhw4AB8fHwDAnTt34OPjg0ePHuHjjz9GzZo1cfv2bfzxxx948uSJ3paBuXPn4vfff8eWLVuwcOFClC5dGnXr1tUbq0qlQocOHRAZGYkePXpg+PDhePz4MSIiIhATEwMPD49sj+nSpQsuX76MtWvX4ocfftB+55QvXx59+vTBoEGDEBMTo9Mdf/z4cVy+fBkTJ07M8X3r3r07+vbti+PHj6Nx48ba8hs3buDIkSOYPXs2gBc/kB06dEDdunXx9ddfw9LSEleuXNGbPOqzbds2pKWloUePHnB2dsY777yD1atX48MPP9Spt3z5cgwYMAC1a9fGuHHjYG9vj1OnTiE8PFxbNyIiAh06dICLiwuGDx8OZ2dnXLhwATt27MDw4cMNiudVy5YtQ0ZGBj7++GNYWlrCwcEBqamp+PXXX9GzZ08MGjQIjx8/xtKlSxEYGIhjx47B29tb+/iBAwdi+fLlaNu2LT766CM8f/4cBw4cwJEjR9CoUaM3ukZz587F0KFDUbp0aUyYMAEA4OTkpFPns88+Q/ny5TFp0iSkp6drz3348GH06NEDlSpVwvXr17Fw4UK88847iI2NhbW1NQAgMTERLVu2xPPnzzF27FjY2Nhg8eLF2s/Nywz97cnJ+fPn8fbbb8POzg5ffvklzM3N8csvv+Cdd97B33//DV9fX3Tp0gX29vYYOXIkevbsiXbt2qF06dJwcnJCxYoVMWPGDAwbNgyNGzfO9j5IIshgy5YtEwD03jS8vb2Fo6OjePDggbbszJkzQi6Xi759+2rLwsLCBADRs2dPneeIi4sTcrlcdO7cWahUKp1jarVaCCHE48ePhb29vRg0aJDO8cTERKFUKnXKvb29hYuLi3j06JG2bPfu3QKAqFKlymtfs7+/v/D399feX7lypZDL5eLAgQM69RYtWiQAiEOHDgkhhLh06ZIAIH766Sedep999pkoXbq0ePLkiRBCiAMHDggAYvXq1Tr1wsPDs5W/Gkt8fLwAIJYtW6Yt07yvLwMgLCwsxJUrV7RlZ86cyRZfx44dhbW1tbh9+7a2LC4uTpQqVSrbOfXZt2+fACD27dunU64vzpCQEAFADB06VFumVqtF+/bthYWFhbh37162uvHx8a+NIae/TwBi7dq1QgghsrKyhKOjo/D29haZmZnaxy5evFgA0HmPNX/zrz63vtequaYvmzlzppDJZOLGjRvaMn3XSJ9JkyYJAMLGxka0bdtWTJ8+XZw8eTJbPU0sFStWFKmpqdryDRs2CABi3rx5QogX72/16tVFYGCg9rOkidvd3V20adNGW9a3b18hl8vF8ePHsz2f5rH63gPNa3v5+gmR/W/3t99+EwDE999/n+P5hXhxPcPCwrT3Z8+erfd6PHr0SCgUCjFmzBid8mHDhgkbGxuRlpaW7Xk0UlJShKWlpfjiiy90yr/99luda/fDDz/ofW2G6tChg2jWrJn2/uLFi0WpUqVEUlKSzuuwtbUVvr6+4unTpzqP17wvz58/F+7u7qJKlSri4cOHeusIkf091wgJCdH57tN8Pu3s7HRi0TzXy58RIYR4+PChcHJyEgMGDNCW7d27VwAQw4YNy/Z8mpje5BoJIUTt2rX1vh7NZ7R58+bi+fPnOsf0fSajoqIEAPH7779ry0aMGCEAiKNHj2rLkpKShFKp1Pl7k/Lbk5Pg4GBhYWEhrl69qi27c+eOsLW1FS1atNCWaa7L7NmzdR6v+dxt3Ljxtc/1OuwCy4MFCxYgIiJC5wa86Ko4ffo0+vXrp/Mv1rp166JNmzbYuXNntnO9OjNn69atUKvVmDRpEuRy3cuj6YaJiIjAo0eP0LNnT9y/f197MzMzg6+vr7Z5VhNPSEgIlEql9jxt2rSBp6dnnl77xo0bUatWLdSsWVPnuVu1agUA2ud+66234O3tjfXr12sfq1Kp8Mcff6Bjx47af1ls3LgRSqUSbdq00Tlfw4YNUbp0ab1NzXkREBCg86/qunXrws7ODteuXdPGtmfPHgQHB6NChQraetWqVTPpQM2XB/dpuuqysrKwZ88ebfny5cshhDCo9QcA3nvvvWx/nxEREdouyRMnTiApKQmffvqpTktGv379dP5OpHr5X4vp6em4f/8+mjZtCiEETp06Jfl8U6ZMwZo1a1C/fn3s2rULEyZMQMOGDdGgQYNsXcoA0LdvX9ja2mrvv//++3BxcdF+7k6fPo24uDh8+OGHePDggfZvLT09Ha1bt8Y///wDtVoNtVqNrVu3omPHjnrH+hljCv+mTZtQrlw5DB061CjnVyqVeO+997B27VptS7JKpcL69esRHByc63gQOzs7tG3bFhs2bNDpfl2/fj2aNGmCypUrA/hvzMWff/6ZY9dITh48eIBdu3ahZ8+e2rKuXbtCJpNhw4YN2rKIiAg8fvwYY8eOzTb+SfO+nDp1CvHx8RgxYkS2cSBvcm26du2arbXXzMxM+xlRq9VITk7G8+fP0ahRI0RHR2vrbdq0CTKZTNsFqi+mN7lGhhg0aBDMzMx0yl7+TD579gwPHjxAtWrVYG9vrxP/zp070aRJE20LKPCiZbFXr1465zP0tycnKpUKu3fvRnBwsE63q4uLCz788EMcPHgQqampeXr9ecEusDzw8fHR+8V448YNAC/6c19Vq1Yt7Nq1K9vgtFdnk129ehVyuTzXBCUuLg4AtEnHq+zs7HTiqV69erY6NWrU0PkAGCouLg4XLlzIsVvo5cGp3bt3x/jx43H79m1UrFgR+/fvR1JSErp3765zvpSUFJ0xHTmd701ovsRfVqZMGe04o6SkJDx9+lRn5o7Gq2XJycnacSDAiy+ZvCQOcrk829gLzUytN1l3o1KlSggICMjxeE5/F+bm5jmOBTHEzZs3MWnSJGzbti3b+K2UlJQ8nbNnz57o2bMnUlNTcfToUSxfvhxr1qxBx44dERMTo/Mj+errkclkqFatmva91HxuQkJCcny+lJQUZGVlITU11aQzO69evYoaNWoYdcB+3759sX79ehw4cAAtWrTAnj17cPfuXfTp0+e1j+3evTu2bt2KqKgoNG3aFFevXsXJkycxd+5cnTq//vorPvroI4wdOxatW7dGly5d8P7772f7x9qr1q9fj2fPnqF+/fq4cuWKttzX1xerV6/G559/DgDa8U+5vfeG1MmLV7+LNVasWIE5c+ZkG4f3cv2rV6+iQoUKr+2qfZNrlJf4nz59ipkzZ2LZsmW4ffu2ToL78mfyxo0b8PX1zfb4V3/LDP3tefr0abbPvLOzM+7du4cnT57k+BupVqtx69Yt1K5dO6eXaVRMgAqYvj7W19H862vlypU642s0TDkLSq1Wo06dOvj+++/1Hn95/Ej37t0xbtw4bNy4ESNGjMCGDRugVCp1pi+r1Wo4Ojpi9erVes9nrPE3r/7LSEO8MuDYEF26dMHff/+tvR8SEqIdiKiPSqWS/ByFhaGvSaVSoU2bNkhOTsaYMWNQs2ZN2NjY4Pbt2+jXr5/kFoNX2dnZoU2bNmjTpg3Mzc2xYsUKHD16VDsg0hCaGGbPnq0zduNlpUuXRnJy8hvFWlACAwPh5OSEVatWoUWLFli1ahWcnZ1zTYY1OnbsCGtra2zYsAFNmzbFhg0bIJfL8cEHH2jrWFlZ4Z9//sG+ffvwv//9D+Hh4Vi/fj1atWqF3bt35/gZA6D9fOc0qP3atWtvlHzrI5PJ9H6+c/o86vsuXrVqFfr164fg4GCMHj0ajo6OMDMzw8yZM3UGqxvqTa7R6+iLf+jQoVi2bBlGjBgBPz8/7YKCPXr0yNNn0tDfnvXr16N///46x/LyXWtqTICMSDNq/dKlS9mOXbx4EeXKlXttM6eHhwfUajViY2Nz/JLWdOU4Ojrm+sHRxKPJ2l+mL0ZDeHh44MyZM2jduvVrm5vd3d3h4+OD9evXY8iQIdi8eTOCg4NhaWmpc749e/agWbNmeUoGjcXR0REKhULnX6car5bNmTNHp4VD02VWpkwZAMi2SJ2mxeVVarUa165d01mf5/LlywBgcHdXXrz8d/Hyv+SePXuG+Ph4nZkqhr6mc+fO4fLly1ixYoXOGkSa7mFjatSoEVasWIGEhASd8lf/zoUQuHLlinYgsuZzY2dnl+vnpnz58rCzs0NMTIyRI/+Ph4cHjh49imfPnkka5J/bZ87MzAwffvghli9fjlmzZmHr1q16u0X0sbGxQYcOHbBx40Z8//33WL9+Pd5++22d7mDgRatl69at0bp1a3z//feYMWMGJkyYgH379uX4nsbHx+Pw4cMYMmRItoRVrVajT58+WLNmDSZOnKi9RjExMXpbYwHo1MntOpYpU0bbxf2ynD6P+vzxxx+oWrUqNm/erPPev9rV5eHhgV27diE5OTnXVqA3uUZ56d77448/EBISgjlz5mjLMjIysn2eq1SpYtDvhKG/PYGBgXo/++XLl4e1tXWOv5FyuTzPkzDygmOAjMjFxQXe3t5YsWKFzh9YTEwMdu/ejXbt2r32HMHBwZDL5fj666+zZeiaDDowMBB2dnaYMWOG3qnRmvUTXo7n5ebIiIgIxMbG5uUlolu3brh9+zaWLFmS7djTp0+1sw80unfvjiNHjuC3337D/fv3dbq/NOdTqVSYOnVqtvM9f/4831a8NTMzQ0BAALZu3Yo7d+5oy69cuZJtxdqGDRsiICBAe9N0V1apUgVmZmb4559/dOr//PPPOT7v/Pnztf8vhMD8+fNhbm6O1q1ba8uNPQ2+UaNGKF++PBYtWqTTlbd8+fJs77fmC+/l16RSqbKtcKz5An/5X3lCCJ1pyVI8efIEUVFReo9prserzei///47Hj9+rL3/xx9/ICEhQTuGq2HDhvDw8MB3332HtLS0bOfVfG7kcjmCg4Oxfft27RTmlxnjX7Jdu3bF/fv3da6/IefX/AMqp89Fnz598PDhQ3zyySdIS0uTtB5U9+7dcefOHfz66684c+ZMts+qvpYxzT/SXl4C41Wa1p8vv/wS77//vs6tW7du8Pf319Z59913YWtri5kzZyIjI0PnPJr3pUGDBnB3d8fcuXOzvQ8vv3ceHh64ePGi9roCwJkzZwyetQbo/7s+evRotr/Nrl27QgiBKVOmZDvHq9czr9fIxsZG8vehmZlZtuf/6aefsrWCtWvXDkeOHMGxY8e0Zffu3cvWMi/lt+fl70hNsmRmZoZ3330Xf/75p043/927d7FmzRo0b95c242WH9gCZGSzZ89G27Zt4efnh4EDB2qnwSuVSoP29KlWrRomTJiAqVOn4u2330aXLl1gaWmJ48ePo0KFCpg5cybs7OywcOFC9OnTBw0aNECPHj1Qvnx53Lx5E//73//QrFkz7RfrzJkz0b59ezRv3hwDBgxAcnIyfvrpJ9SuXVvvj8Dr9OnTBxs2bMCnn36Kffv2oVmzZlCpVLh48SI2bNiAXbt26YyP6tatG0aNGoVRo0bBwcEh278a/P398cknn2DmzJk4ffo03n33XZibmyMuLg4bN27EvHnzdNYMMqXJkydj9+7daNasGQYPHgyVSoX58+fDy8vLoL1mlEolPvjgA/z000+QyWTw8PDAjh07chzHpFAoEB4ejpCQEPj6+uKvv/7C//73P4wfP16n60/qNPjLly9j1apV2cqdnJy0XUjTpk3DJ598glatWqF79+6Ij4/HsmXLsnVD1K5dG02aNMG4ceO0/7pdt24dnj9/rlOvZs2a8PDwwKhRo3D79m3Y2dlh06ZNeVrLCXiRADVt2hRNmjRBUFAQXF1d8ejRI2zduhUHDhxAcHAw6tevr/MYBwcHNG/eHP3798fdu3cxd+5cVKtWDYMGDQLwIrH59ddf0bZtW9SuXRv9+/dHxYoVcfv2bezbtw92dnbYvn07AGDGjBnYvXs3/P39tcs9JCQkYOPGjTh48OAbL8LWt29f/P777wgNDcWxY8fw9ttvIz09HXv27MFnn32G9957T+/jGjZsCACYMGECevToAXNzc3Ts2FGbGNWvXx9eXl7ayQoNGjQwOKZ27drB1tYWo0aNgpmZGbp27apz/Ouvv8Y///yD9u3bo0qVKkhKSsLPP/+MSpUq6axh9qrVq1fD29s7x3/Zd+rUCUOHDkV0dDQaNGiAH374AR999BEaN26sXSPtzJkzePLkCVasWAG5XI6FCxeiY8eO8Pb2Rv/+/eHi4oKLFy/i/Pnz2LVrFwBgwIAB+P777xEYGIiBAwciKSkJixYtQu3atQ0eaNuhQwds3rwZnTt3Rvv27REfH49FixbB09NT5/uzZcuW6NOnD3788UfExcUhKCgIarUaBw4cQMuWLXUmO+T1GjVs2BALFy7EtGnTUK1aNTg6OuY4Fufl+FeuXAmlUglPT09ERUVhz5492qU/NL788kusXLkSQUFBGD58uHYafJUqVXD27FltPSm/PTmZNm2adj2pzz77DKVKlcIvv/yCzMxMfPvttwa9F0bzxvPIShDNdEN9U2NftmfPHtGsWTNhZWUl7OzsRMeOHUVsbKxOnZymy2r89ttvon79+sLS0lKUKVNG+Pv7i4iICJ06+/btE4GBgUKpVAqFQiE8PDxEv379xIkTJ3Tqbdq0SdSqVUtYWloKT09PsXnz5mxTQXOibyppVlaWmDVrlqhdu7Y2voYNG4opU6aIlJSUbOdo1qyZACA++uijHJ9n8eLFomHDhsLKykrY2tqKOnXqiC+//FLcuXMnx1ikTIP//PPPsz1nlSpVREhIiE5ZZGSkqF+/vrCwsBAeHh7i119/FV988YVQKBQ5xv6ye/fuia5duwpra2tRpkwZ8cknn4iYmBi90+BtbGzE1atXxbvvviusra2Fk5OTCAsLy7b8gbGmwb96HX/++Wfh7u4uLC0tRaNGjcQ///yj93pfvXpVBAQECEtLS+Hk5CTGjx8vIiIisk0Bj42NFQEBAaJ06dKiXLlyYtCgQdrlBl53jV717NkzsWTJEhEcHCyqVKkiLC0thbW1tahfv76YPXu2ztRkzbTYtWvXinHjxglHR0dhZWUl2rdvrzP9XuPUqVOiS5cuomzZssLS0lJUqVJFdOvWTURGRurUu3Hjhujbt68oX768sLS0FFWrVhWff/659rnfZBq8EC+mKE+YMEG4u7sLc3Nz4ezsLN5//32d6cF4ZRq8EEJMnTpVVKxYUcjlcr1/F99++60AIGbMmJHre6xPr169BAAREBCQ7VhkZKR47733RIUKFYSFhYWoUKGC6Nmzp7h8+XKO5zt58qQAIL766qsc61y/fl0AECNHjtSWbdu2TTRt2lT7Herj46NdxkHj4MGDok2bNsLW1lbY2NiIunXrZlt2Y9WqVaJq1arCwsJCeHt7i127duU4Df7V6dZCvJjCPmPGDO3fYP369cWOHTv0fn8+f/5czJ49W9SsWVNYWFiI8uXLi7Zt2+pduiEv1ygxMVG0b99e2Nra6nyec/tdevjwoejfv78oV66cKF26tAgMDBQXL17U+9139uxZ4e/vLxQKhahYsaKYOnWqWLp0aY7LYBjy25OT6OhoERgYKEqXLi2sra1Fy5YtxeHDh3Xq5Mc0eJkQhXBkElEhEhwcjPPnz+vtI8+rfv364Y8//shTK5wpaVZVfXU168Js//79aNmyJTZu3JhvrYWF2bx58zBy5Ehcv35d7+xHKni8RoUDxwARveTVbRvi4uKwc+fON1punSi/CCGwdOlS+Pv784e1kOI1Kjw4BojoJVWrVkW/fv1QtWpV3LhxAwsXLoSFhQW+/PLLgg6NKEfp6enYtm0b9u3bh3PnzuW4xxYVHF6jwocJENFLgoKCsHbtWiQmJsLS0hJ+fn6YMWOG3sUkiQqLe/fu4cMPP4S9vT3Gjx+PTp06FXRI9Apeo8KHY4CIiIioxOEYICIiIipxmAARERFRicMxQHqo1WrcuXMHtra2Rtn5mYiIiExPCIHHjx+jQoUKr92klwmQHnfu3MnX/UiIiIjIeG7duoVKlSrlWocJkB62trYAXryB+bkvCREREeVdamoqXF1dtb/juWECpIem28vOzo4JEBERURFjyPAVDoImIiKiEocJEBEREZU4TICIiIioxOEYoDegUqnw7Nmzgg6DSC9zc3OYmZkVdBhERIUSE6A8EEIgMTERjx49KuhQiHJlb28PZ2dnrmdFRPQKJkB5oEl+HB0dYW1tzR8XKnSEEHjy5AmSkpIAAC4uLgUcERFR4cIESCKVSqVNfsqWLVvQ4RDlyMrKCgCQlJQER0dHdocREb2Eg6Al0oz5sba2LuBIiF5P83fKsWpERLqYAOURu72oKODfKRGRfgWeAC1YsABubm5QKBTw9fXFsWPHcq2/ceNG1KxZEwqFAnXq1MHOnTuz1blw4QI6deoEpVIJGxsbNG7cGDdv3jTVSyAiIiIDqNQC+8//i95Dx2L/+X+hUosCi6VAE6D169cjNDQUYWFhiI6ORr169RAYGKgduPmqw4cPo2fPnhg4cCBOnTqF4OBgBAcHIyYmRlvn6tWraN68OWrWrIn9+/fj7Nmz+Oqrr6BQKPLrZdFrTJ48Gd7e3gUdBhER5aPwmAQ0n7UX74+di9XzZ+H9sXPRfNZehMckFEg8MiFEgaVfvr6+aNy4MebPnw8AUKvVcHV1xdChQzF27Nhs9bt374709HTs2LFDW9akSRN4e3tj0aJFAIAePXrA3NwcK1euzHNcqampUCqVSElJybYXWEZGBuLj4+Hu7l7kkqp+/fphxYoV2crj4uJQrVo1kzynTCbDli1bEBwcrC1LS0tDZmYmB5Hng6L890pExUd4TAIGr4qGAHBv89d4EncM1tV94djlKwDAwt4NEOT15rNVc/v9flWBtQBlZWXh5MmTCAgI+C8YuRwBAQGIiorS+5ioqCid+gAQGBiora9Wq/G///0Pb731FgIDA+Ho6AhfX19s3brVZK8jr1RqgairD/Dn6duIuvog35oBg4KCkJCQoHNzd3fXqZOVlWXSGEqXLv3GyQ8H9RIRFQ13EhIx8POReLD3VyTv/RWZ8dFwt5chM/6ktmzg5yORkHg3X+MqsATo/v37UKlUcHJy0il3cnJCYmKi3sckJibmWj8pKQlpaWn45ptvEBQUhN27d6Nz587o0qUL/v777xxjyczMRGpqqs7NlDTNgD2XHMHwdafRc8mRfGsGtLS0hLOzs86tdevWGDJkCEaMGIFy5cohMDAQAPD333/Dx8cHlpaWcHFxwdixY/H8+XPtud555x0MGzYMX375JRwcHODs7IzJkydrj7u5uQEAOnfuDJlMpr2vrwvs119/Ra1ataBQKFCzZk38/PPP2mPXr1+HTCbD+vXr4e/vD4VCgdWrV5vk/SEiIuOKOHERiYc34/HxrZCd2wav8jKse98aXuVlkJ3bhtTjW5F4eDN2H7+Qr3EV+CBoY1Kr1QCA9957DyNHjoS3tzfGjh2LDh06aLvI9Jk5cyaUSqX25urqarIYNc2ACSkZOuWJKRkYvCq6wPpCV6xYAQsLCxw6dAiLFi3C7du30a5dOzRu3BhnzpzBwoULsXTpUkybNi3b42xsbHD06FF8++23+PrrrxEREQEAOH78OABg2bJlSEhI0N5/1erVqzFp0iRMnz4dFy5cwIwZM/DVV19l664bO3Yshg8fjgsXLmiTNCIiKtzsXavDqe9cKMpVQsZzYKp/KfhUNMNU/1LIeA4oylWCU9+5sHetnq9xFdhCiOXKlYOZmRnu3tVt8rp79y6cnZ31PsbZ2TnX+uXKlUOpUqXg6empU6dWrVo4ePBgjrGMGzcOoaGh2vupqakmSYJUaoEp22Ohr7NLAJABmLI9Fm08nWEmN8305R07dqB06dLa+23btgUAVK9eHd9++622fMKECXB1dcX8+fMhk8lQs2ZN3LlzB2PGjMGkSZMgl7/InevWrYuwsDDtOebPn4/IyEi0adMG5cuXB/Dfdgw5CQsLw5w5c9ClSxcAgLu7O2JjY/HLL78gJCREW2/EiBHaOkREVDQ42ipgUb4KyvX6Drd/7IkDN1W49lCNf1MFnqkEKvb6DmaK0nC0zd9xinlqATpw4AB69+4NPz8/3L59GwCwcuXKXJOMV1lYWKBhw4aIjIzUlqnVakRGRsLPz0/vY/z8/HTqA0BERIS2voWFBRo3boxLly7p1Ll8+TKqVKmSYyyWlpaws7PTuZnCsfjkbC0/LxMAElIycCw+2STPDwAtW7bE6dOntbcff/wRANCwYUOdehcuXICfn5/OOjLNmjVDWloa/v33X21Z3bp1dR7n4uKS4yw+fdLT03H16lUMHDgQpUuX1t6mTZuGq1ev6tRt1KiRweclIqLCwcfdAS5KBbJuxUAIgXlHn2HErkz8eOwZhBDIunUeLkoFfNwd8jUuyS1AmzZtQp8+fdCrVy+cOnUKmZmZAICUlBTMmDFD77o8OQkNDUVISAgaNWoEHx8fzJ07F+np6ejfvz8AoG/fvqhYsSJmzpwJABg+fDj8/f0xZ84ctG/fHuvWrcOJEyewePFi7TlHjx6N7t27o0WLFmjZsiXCw8Oxfft27N+/X+pLNbqkxzknP3mplxc2NjZ6Z3zZ2Njk6Xzm5uY692UymbYr0hBpaWkAgCVLlsDX11fn2KtbN+Q1RiIiKjhmchnCOnri/TUzAAClKtSCg/8ApP79G7JuxSL98iGETRlssp6PnEhOgKZNm4ZFixahb9++WLdunba8WbNm2caHvE737t1x7949TJo0CYmJifD29kZ4eLh2oPPNmze1XS0A0LRpU6xZswYTJ07E+PHjUb16dWzduhVeXl7aOp07d8aiRYswc+ZMDBs2DDVq1MCmTZvQvHlzqS/V6Axt3svvZkB9atWqhU2bNkEIoW0FOnToEGxtbVGpUiWDz2Nubg6VSpXjcScnJ1SoUAHXrl1Dr1693jhuIiIqfIK8XNCnwzvYWckDqNMBMrkZyvWYCZzbgXberkaZAi+V5ATo0qVLaNGiRbZypVKJR48eSQ5gyJAhGDJkiN5j+lptPvjgA3zwwQe5nnPAgAEYMGCA5FhMTdMMmJiSoXcckAyAcwE0A+rz2WefYe7cuRg6dCiGDBmCS5cuISwsDKGhoTpJ6eu4ubkhMjISzZo1g6WlJcqUKZOtzpQpUzBs2DAolUoEBQUhMzMTJ06cwMOHD3XGZhERUdG1cOZXUKkFjsUnI+lxBhxtFfBx75jvLT8akscAOTs748qVK9nKDx48iKpVqxolqOJK0wwIvEh2Xqa5H9bRs8D+GF5WsWJF7Ny5E8eOHUO9evXw6aefYuDAgZg4caKk88yZMwcRERFwdXVF/fr19db56KOP8Ouvv2LZsmWoU6cO/P39sXz58mzrExERUdFmJpfBz6Ms3vOuCD+PsgX6eyd5JeiZM2di1apV+O2339CmTRvs3LkTN27cwMiRI/HVV19h6NChpoo135h6JejwmARM2R6rMyDaRalAWEfPAmkGpOKLK0ETUUkiZSVoyV1gY8eOhVqtRuvWrfHkyRO0aNEClpaWGDVqVLFIfvJDkJcL2ng6v9IM6FAoWn6IiIhKAskJkEwmw4QJEzB69GhcuXIFaWlp8PT01Flbhl5P0wxIRERE+U/yGKABAwbg8ePHsLCwgKenJ3x8fFC6dGmkp6cXyoHHRERERK+SnACtWLECT58+zVb+9OlT/P7770YJioiIiMiUDO4CS01NhRACQgg8fvxYZ0ClSqXCzp074ejoaJIgiYiIiIzJ4ATI3t4eMpkMMpkMb731VrbjMpkMU6ZMMWpwRERERKZgcAK0b98+CCHQqlUrbNq0CQ4O/y3WZ2FhgSpVqqBChQomCZKIiIjImAxOgPz9/QEA8fHxcHV1lbQaMBEREVFhInkavGZX9SdPnuDmzZvIysrSOf7q7uBEREREhY3kZpx79+6hQ4cOsLW1Re3atVG/fn2dGxVP169fh0wmw+nTpw1+zPLly2Fvb1/gcZiaTCbD1q1bARTO+IiIKDvJCdCIESPw6NEjHD16FFZWVggPD8eKFStQvXp1bNu2zRQxkpHcunULAwYMQIUKFbTjtoYPH44HDx689rGurq5ISEiAl5eXwc/XvXt3XL58+U1CLnKkvk/9+vVDcHCwaYMiIqJsJCdAe/fuxffff49GjRpBLpejSpUq6N27N7799lvMnDnTFDEWW0+fPsWMGTP0rqtkbNeuXUOjRo0QFxeHtWvX4sqVK1i0aBEiIyPh5+eH5OTkHB+blZUFMzMzODs7o1Qpw3tNraysiszSCM+ePTPKefLyPhnDq13RRESUO8kJUHp6uvZHrUyZMrh37x4AoE6dOoiOjjZudMXcpk2bMGHCBGzevNnkz/X555/DwsICu3fvhr+/PypXroy2bdtiz549uH37NiZMmKCt6+bmhqlTp6Jv376ws7PDxx9/rLdrZ9u2bahevToUCgVatmyJFStWQCaT4dGjRwCyd4FNnjwZ3t7eWLlyJdzc3KBUKtGjRw88fvxYWyc8PBzNmzeHvb09ypYtiw4dOuDq1auSXqsm/p49e8LGxgYVK1bEggULdOrIZDIsXLgQnTp1go2NDaZPnw4A+PPPP9GgQQMoFApUrVoVU6ZMwfPnz7WPi4uLQ4sWLaBQKODp6YmIiAid8+p7n86fP48OHTrAzs4Otra2ePvtt3H16lVMnjwZK1aswJ9//qldYmL//v0AgHPnzqFVq1awsrJC2bJl8fHHHyMtLU17Tk3L0fTp01GhQgXUqFFD0ntERFTSSU6AatSogUuXLgEA6tWrh19++QW3b9/GokWL4OLCncyl+GPjhv//70aTPk9ycjJ27dqFzz77DFZWVjrHnJ2d0atXL6xfvx5CCG35d999h3r16uHUqVP46quvsp0zPj4e77//PoKDg3HmzBl88sknOklUTq5evYqtW7dix44d2LFjB/7++29888032uPp6ekIDQ3FiRMnEBkZCblcjs6dO0OtVkt6zbNnz9bGP3bsWAwfPjxbsjJ58mR07twZ586dw4ABA3DgwAH07dsXw4cPR2xsLH755RcsX75cmxyp1Wp06dIFFhYWOHr0KBYtWoQxY8bkGsft27e1Gwbv3bsXJ0+exIABA/D8+XOMGjUK3bp1Q1BQEBISEpCQkICmTZsiPT0dgYGBKFOmDI4fP46NGzdiz549GDJkiM65IyMjcenSJURERGDHjh2S3h8iohJPSLRy5UqxbNkyIYQQJ06cEOXKlRNyuVwoFAqxbt06qacrlFJSUgQAkZKSku3Y06dPRWxsrHj69Knk8yYmJooxY8aI0NBQERoaKhSWFsLdXiYUlhbasjFjxoi7d+8a42VoHTlyRAAQW7Zs0Xv8+++/FwC0z1ulShURHBysUyc+Pl4AEKdOnRJCCDFmzBjh5eWlU2fChAkCgHj48KEQQohly5YJpVKpPR4WFiasra1Famqqtmz06NHC19c3x9jv3bsnAIhz587pjUOfKlWqiKCgIJ2y7t27i7Zt22rvAxAjRozQqdO6dWsxY8YMnbKVK1cKFxcXIYQQu3btEqVKlRK3b9/WHv/rr7903ttX4xs3bpxwd3cXWVlZemMNCQkR7733nk7Z4sWLRZkyZURaWpq27H//+5+Qy+UiMTFR+zgnJyeRmZmZ4/sgxJv9vRIRFTW5/X6/SvJAhd69e2v/v2HDhrhx4wYuXryIypUro1y5cm+ekRVjCQkJmDdvLjIyMmFvZYba5czwc1trfPbXM/y2cB4ePVVBobBEjx49TDJ2RrzUwvM6jRo1yvX4pUuX0LhxY50yHx+f157Xzc0Ntra22vsuLi5ISkrS3o+Li8OkSZNw9OhR3L9/X9vyc/PmTUkDsP38/LLdnzt3rk7Zq6/xzJkzOHTokLbFB3ixzUtGRgaePHmCCxcuwNXVVWfBz1ef51WnT5/G22+/DXNzc4Njv3DhAurVqwcbGxttWbNmzaBWq3Hp0iU4OTkBeNHtbGFhYfB5iYjoP2+8mqG1tTUaNGiA0qVL47vvvjNGTMWWt7c3Tpw4CS/Pmsh4LhD2thl8Kpoh7G0zZDwX8PKshRMnTsLb29uoz1utWjXIZDJcuHBB7/ELFy6gTJkyKF++vLbs5R9fY3o1EZDJZDrdWx07dkRycjKWLFmCo0eP4ujRowBMM8j31deYlpaGKVOm4PTp09rbuXPnEBcXp7P3nRSvdjkak6muERFRSSApAbp37x527NiB3bt3Q6VSAXgxe2bevHlwc3PTGctB+tWuXRv/HDyMLBVw4KYK845k4p8bKmSpgH8OHkLt2rWN/pxly5ZFmzZt8PPPP2ebcZaYmIjVq1eje/fukMlkBp+zRo0aOHHihE7Z8ePH3yjOBw8e4NKlS5g4cSJat26NWrVq4eHDh3k615EjR7Ldr1WrVq6PadCgAS5duoRq1aplu8nlctSqVQu3bt1CQkJCjs/zqrp16+LAgQM5zjKzsLDQfpY0atWqhTNnziA9PV1bdujQIcjlcg52JiIyEoMToIMHD6J69ero1KkT2rZti6ZNmyI2Nha1a9fGL7/8gsmTJ+PWrVumjLXY+Oeff6BWqzHv6DOM2JWJH489g1qtxoEDB0z2nPPnz0dmZiYCAwPxzz//4NatWwgPD0ebNm1QsWJFnW4fQ3zyySe4ePEixowZg8uXL2PDhg1Yvnw5AEhKpF5WpkwZlC1bFosXL8aVK1ewd+9ehIaG5ulchw4dwrfffovLly9jwYIF2LhxI4YPH57rYyZNmoTff/8dU6ZMwfnz53HhwgWsW7cOEydOBAAEBATgrbfeQkhICM6cOYMDBw68duD3kCFDkJqaih49euDEiROIi4vDypUrtRMJ3NzccPbsWVy6dAn379/Hs2fP0KtXLygUCoSEhCAmJgb79u3D0KFD0adPH233FxERvRmDE6CJEyeiXbt2OHv2LEJDQ3H8+HF07twZM2bMQGxsLD799FOTNvcXJ5pp735NmyEqKgpN/JrqlJtC9erVceLECVStWhXdunWDh4cHPv74Y7Rs2RJRUVE6m9sawt3dHX/88Qc2b96MunXrYuHChdpkwNLSMk8xyuVyrFu3DidPnoSXlxdGjhyJ2bNn5+lcX3zxBU6cOIH69etj2rRp+P777xEYGJjrYwIDA7UtnI0bN0aTJk3www8/aLd/kcvl2LJlC54+fQofHx989NFHr00cy5Yti7179yItLQ3+/v5o2LAhlixZou0KHDRoEGrUqIFGjRqhfPnyOHToEKytrbFr1y4kJyejcePGeP/999G6dWvMnz8/T+8FERFlJxMGjowtW7YsDhw4AE9PTzx9+hSlS5fG5s2b8d5775k6xnyXmpoKpVKJlJQU2NnZ6RzLyMhAfHw83N3d8zwu5Mcff0RGRga++OILmJmZQaVSYc6cOVAoFBg2bJgxXkKBmD59OhYtWlTgLYFubm4YMWIERowYUaBxFAbG+HslIjIWlVrgWHwykh5nwNFWAR93B5jJ89ZroE9uv9+vMngW2MOHD7WzvKysrGBtbS1pVg7959Ukx8zMDF9++WUBRZN3P//8Mxo3boyyZcvi0KFDmD17dra1aoiIiAAgPCYBU7bHIiElQ1vmolQgrKMngrzyfx1BSdPgY2NjkZiYCODFlOpLly7pDNQEuBt8SRIXF4dp06YhOTkZlStXxhdffIFx48YVdFhERFTIhMckYPCqaLza5ZSYkoHBq6KxsHeDfE+CDO4Ck8vlkMlketeS0ZTLZLJsM1qKIlN3gRHlF/69ElFBU6kFms/aq9Py8zIZAGelAgfHtHrj7jCTdIHFx8e/UVBERERU8hyLT84x+QEAASAhJQPH4pPh51E23+IyOAHSzIShF6SsqkxUUPh3SkQFLelxzslPXuoZyxuvBF3SaKYvP3nypIAjIXo9zd+plK04iIiMydHWsO53Q+sZi+S9wEo6MzMz2Nvba/evsra2zvPCf0SmIoTAkydPkJSUBHt7e5iZmRV0SERUQvm4O8BFqUBiSka2QdDAf2OAfNylrUf3ppgA5YGzszMA6GziSVQY2dvba/9eiYgKgplchrCOnhi8KhoyQCcJ0jQfhHX0NOp6QIYweBZYSWLoKHKVSpXjHk9EBc3c3JwtP0RUaOTHOkAmmQX2sufPn2P//v24evUqPvzwQ9ja2uLOnTuws7ND6dKl8xR0UWRmZsYfGCIiIgMEebmgjaezSVeClkJyAnTjxg0EBQXh5s2byMzMRJs2bWBra4tZs2YhMzMTixYtMkWcREREVMSZyWX5OtU9N5JngQ0fPhyNGjXCw4cPdTY/7dy5MyIjI40aHBEREZEpSG4BOnDgAA4fPgwLCwudcjc3N9y+fdtogRERERGZiuQWILVarXe7i3///Re2trZGCYqIiIjIlCQnQO+++y7mzp2rvS+TyZCWloawsDC0a9fOmLERERERmYTkafD//vsvAgMDIYRAXFwcGjVqhLi4OJQrVw7//PMPHB0dTRVrvpEyjY6IiIgKBym/33laB+j58+dYt24dzp49i7S0NDRo0AC9evXSGRRdlDEBIiIiKnpMug5QRkYGFAoFevfunecAiYiIiAqS5DFAjo6OCAkJQUREBNRqtSliIiIiIjIpyQnQihUr8OTJE7z33nuoWLEiRowYgRMnTpgiNiIiIiKTkJwAde7cGRs3bsTdu3cxY8YMxMbGokmTJnjrrbfw9ddfmyJGIiIiIqMyymaosbGx6NWrF86ePat3jaCihoOgiYiIih4pv9+SW4A0MjIysGHDBgQHB6NBgwZITk7G6NGj83SuBQsWwM3NDQqFAr6+vjh27Fiu9Tdu3IiaNWtCoVCgTp062Llzp87xfv36QSaT6dyCgoLyFBsREREVP5IToF27diEkJAROTk4YPHgwnJycsHv3bty4cQPffPON5ADWr1+P0NBQhIWFITo6GvXq1UNgYCCSkpL01j98+DB69uyJgQMH4tSpUwgODkZwcDBiYmJ06gUFBSEhIUF7W7t2reTYiIiIqHiS3AVmbW2NDh06oFevXmjXrh3Mzc3fKABfX180btwY8+fPB/Biqw1XV1cMHToUY8eOzVa/e/fuSE9Px44dO7RlTZo0gbe3t3Yn+n79+uHRo0fYunVrnmJiFxgREVHRY9IusLt372LDhg1477333jj5ycrKwsmTJxEQEPBfQHI5AgICEBUVpfcxUVFROvUBIDAwMFv9/fv3w9HRETVq1MDgwYPx4MGDN4qViIiIig+DFkJMTU3VZlJCCKSmpuZYV0qLyf3796FSqeDk5KRT7uTkhIsXL+p9TGJiot76iYmJ2vtBQUHo0qUL3N3dcfXqVYwfPx5t27ZFVFQUzMzMsp0zMzMTmZmZ2vu5vT4iIiIq+gxKgMqUKYOEhAQ4OjrC3t4eMpksWx0hBGQyWaGYBdajRw/t/9epUwd169aFh4cH9u/fj9atW2erP3PmTEyZMiU/QyQiIqICZFACtHfvXjg4OAAA9u3bZ7QnL1euHMzMzHD37l2d8rt378LZ2VnvY5ydnSXVB4CqVauiXLlyuHLlit4EaNy4cQgNDdXeT01Nhaurq5SXQkREREWIQQmQv7+/9v/d3d3h6uqarRVICIFbt25JenILCws0bNgQkZGRCA4OBvBiEHRkZCSGDBmi9zF+fn6IjIzEiBEjtGURERHw8/PL8Xn+/fdfPHjwAC4uLnqPW1pawtLSUlLsREREVHRJHgTt7u6Oe/fuZStPTk6Gu7u75ABCQ0OxZMkSrFixAhcuXMDgwYORnp6O/v37AwD69u2LcePGaesPHz4c4eHhmDNnDi5evIjJkyfjxIkT2oQpLS0No0ePxpEjR3D9+nVERkbivffeQ7Vq1RAYGCg5PiIiIip+JO8Grxnr86q0tDQoFArJAXTv3h337t3DpEmTkJiYCG9vb4SHh2sHOt+8eRNy+X95WtOmTbFmzRpMnDgR48ePR/Xq1bF161Z4eXkBAMzMzHD27FmsWLECjx49QoUKFfDuu+9i6tSpbOUhIiIiABLWAdKMkZk3bx4GDRoEa2tr7TGVSoWjR4/CzMwMhw4dMk2k+YjrABERERU9Un6/DW4BOnXqFIAXLUDnzp2DhYWF9piFhQXq1auHUaNG5TFkIiIiovxjcAKkmf3Vv39/zJs3jy0jREREVGRJHgO0bNkyU8RBRERExZhKLXAsPhlJjzPgaKuAj7sDzOTZxxTnF8kJEACcOHECGzZswM2bN5GVlaVzbPPmzUYJjIiIiIqH8JgETNkei4SUDG2Zi1KBsI6eCPLSv0SNqUmeBr9u3To0bdoUFy5cwJYtW/Ds2TOcP38ee/fuhVKpNEWMREREVESFxyRg8KponeQHABJTMjB4VTTCYxIKJC7JCdCMGTPwww8/YPv27bCwsMC8efNw8eJFdOvWDZUrVzZFjERERFQEqdQCU7bHQt90c03ZlO2xUKkNmpBuVJIToKtXr6J9+/YAXsz+Sk9Ph0wmw8iRI7F48WKjB0hERERF07H45GwtPy8TABJSMnAsPjn/gvp/khOgMmXK4PHjxwCAihUrIiYmBgDw6NEjPHnyxLjRERERUZGV9Djn5Ccv9YxJ8iDoFi1aICIiAnXq1MEHH3yA4cOHY+/evYiIiNC70SgRERGVTI62hu0QYWg9Y5KcAM2fPx8ZGS8ytQkTJsDc3ByHDx9G165dMXHiRKMHSEREREWTj7sDXJQKJKZk6B0HJAPgrHwxJT6/GbwVRknCrTCIiIiMQzMLDIBOEqRZAWhh7wZGmwov5fdb8hig1NRUvbfHjx9nWxOIiIiISrYgLxcs7N0Azkrdbi5npcKoyY9UkrvA7O3t9e4Gr1GpUiX069cPYWFhOru4ExERUckU5OWCNp7ORXsl6OXLl2PChAno168ffHx8AADHjh3DihUrMHHiRNy7dw/fffcdLC0tMX78eKMHTEREREWPmVwGP4+yBR2GluQEaMWKFZgzZw66deumLevYsSPq1KmDX375BZGRkahcuTKmT5/OBIiIiIgKJcl9VIcPH0b9+vWzldevXx9RUVEAgObNm+PmzZtvHh0RERGRCUhOgFxdXbF06dJs5UuXLoWrqysA4MGDByhTpsybR0dERERFmkotEHX1Af48fRtRVx8UyLYX+kjuAvvuu+/wwQcf4K+//kLjxo0BvNgd/uLFi/jjjz8AAMePH0f37t2NGykREREVKYVxF3iNPK0DFB8fj19++QWXL18GANSoUQOffPIJ3NzcjB1fgeA6QERERG9Gs/7Pq0mGKdb/0ZDy+82FEPVgAkRERJR3KrVA81l7c9wIVbMC9MExrYw6Fd6kCyECwIEDB9C7d280bdoUt2/fBgCsXLkSBw8ezMvpiIiIqBgpzLvAa0hOgDZt2oTAwEBYWVkhOjoamZmZAICUlBTMmDHD6AESERFR0VKYd4HXkJwATZs2DYsWLcKSJUtgbm6uLW/WrBmio6ONGhwREREVPYV5F3gNyQnQpUuX0KJFi2zlSqUSjx49MkZMREREVIRpdoHPaXSPDC9mgxXELvAakhMgZ2dnXLlyJVv5wYMHUbVqVaMERUREREWXmVyGsI6eAJAtCdLcD+voWaB7gUlOgAYNGoThw4fj6NGjkMlkuHPnDlavXo1Ro0Zh8ODBpoiRiIiIipjCugu8huSFEMeOHQu1Wo3WrVvjyZMnaNGiBSwtLTFq1CgMHTrUFDESERFREVQYd4HXyPM6QFlZWbhy5QrS0tLg6emJ0qVLGzu2AsN1gIiIiIoeKb/fkluANCwsLODp6ZnXhxMREREVGIMToAEDBry2jkwm07tRKhEREVFhYnAC9PDhwxyPqVQq7NmzB5mZmUyAiIiIqNAzOAHasmWL3vI///wT48ePh6WlJSZNmmS0wIiIiKjoUqlFoRz8rJHnMUCHDh3C2LFjER0djSFDhmDs2LEoU6aMMWMjIiKiIig8JgFTtsfq7AfmolQgrKNngU9/15C8DlBsbCw6duyId955B2+99RYuXbqEWbNmMfkhIiIihMckYPCq6GyboSamZGDwqmiExyQUUGS6DE6Abt26hf79+6NevXooVaoUzp49i6VLl6JSpUqmjI+IiIiKCJVaYMr2WOhbX0dTNmV7LFTqPK3AY1QGd4HVqFEDMpkMoaGhaNasGeLi4hAXF5etXqdOnYwaIBERERUNx+KTs7X8vEwASEjJwLH4ZPh5lM2/wPQwOAHKyHjxgmbPno3Zs2frrSOTyaBSqYwTGRERERUpSY9zTn7yUs+UDE6A1Gq1KeMgIiKiIs7RVvH6ShLqmZLkQdBERERE+vi4O8BFqci2A7yGDC9mg/m4O+RnWHoxASIiIiKjMJPLENbxxTZZryZBmvthHT0LxXpATICIiIjIaIK8XLCwdwM4K3W7uZyVCizs3aDQrAOU54UQiYiIiPQJ8nJBG0/n4rkSNBEREVFOzOSyAp/qnps8dYE9evQIv/76K8aNG4fk5GQAQHR0NG7fvm3U4IiIiIhMQXIL0NmzZxEQEAClUonr169j0KBBcHBwwObNm3Hz5k38/vvvpoiTiIiICqnCvvGpPpJbgEJDQ9GvXz/ExcVBofhvgFO7du3wzz//5CmIBQsWwM3NDQqFAr6+vjh27Fiu9Tdu3IiaNWtCoVCgTp062LlzZ451P/30U8hkMsydOzdPsREREVHOwmMS0HzWXvRccgTD151GzyVH0HzW3kKz51dOJCdAx48fxyeffJKtvGLFikhMTJQcwPr16xEaGoqwsDBER0ejXr16CAwMRFJSkt76hw8fRs+ePTFw4ECcOnUKwcHBCA4ORkxMTLa6W7ZswZEjR1ChQgXJcREREVHuisrGp/pIToAsLS2Rmpqarfzy5csoX7685AC+//57DBo0CP3794enpycWLVoEa2tr/Pbbb3rrz5s3D0FBQRg9ejRq1aqFqVOnokGDBpg/f75Ovdu3b2Po0KFYvXo1zM3NJcdFREREOStKG5/qIzkB6tSpE77++ms8e/YMwIv9v27evIkxY8aga9euks6VlZWFkydPIiAg4L+A5HIEBAQgKipK72OioqJ06gNAYGCgTn21Wo0+ffpg9OjRqF27tqSYiIiI6PWkbHxaGElOgObMmYO0tDQ4Ojri6dOn8Pf3R7Vq1WBra4vp06dLOtf9+/ehUqng5OSkU+7k5JRjd1piYuJr68+aNQulSpXCsGHDDIojMzMTqampOjciIiLKWVHa+FQfybPAlEolIiIicPDgQZw9exZpaWlo0KBBtlaZgnLy5EnMmzcP0dHRkMkMG4E+c+ZMTJkyxcSRERERFR9FaeNTffK8EGLz5s3RvHnzN3rycuXKwczMDHfv3tUpv3v3LpydnfU+xtnZOdf6Bw4cQFJSEipXrqw9rlKp8MUXX2Du3Lm4fv16tnOOGzcOoaGh2vupqalwdXXN68siIiIq9jQbnyamZOgdByTDi+0vCsPGp/pIToC+/vrrXI9PmjTJ4HNZWFigYcOGiIyMRHBwMIAX43ciIyMxZMgQvY/x8/NDZGQkRowYoS2LiIiAn58fAKBPnz56xwj16dMH/fv313tOS0tLWFpaGhw3ERFRSafZ+HTwqmjIAJ0kqLBtfKqP5ARoy5YtOvefPXuG+Ph4lCpVCh4eHpISIODFukIhISFo1KgRfHx8MHfuXKSnp2uTlb59+6JixYqYOXMmAGD48OHw9/fHnDlz0L59e6xbtw4nTpzA4sWLAQBly5ZF2bK6S2+bm5vD2dkZNWrUkPpyiYiIKAeajU+nbI/VGRDtrFQgrKNnodn4VB/JCdCpU6eylaWmpqJfv37o3Lmz5AC6d++Oe/fuYdKkSUhMTIS3tzfCw8O1A51v3rwJufy/sdpNmzbFmjVrMHHiRIwfPx7Vq1fH1q1b4eXlJfm5iYiI6M0UhY1P9ZEJIYwyQf/cuXPo2LGj3jE2RU1qaiqUSiVSUlJgZ2dX0OEQERGRAaT8fudpM1R9UlJSkJKSYqzTEREREZmM5C6wH3/8Uee+EAIJCQlYuXIl2rZta7TAiIiIiExFcgL0ww8/6NyXy+UoX748QkJCMG7cOKMFRkRERIVbUdwFXkNyAhQfH2+KOIiIiKgI2Xk2ARP/jEFyepa2zKUIzP7SkDQG6NmzZyhVqpTendeJiIioZJi5MxafrYnWSX6AF3t/FfZd4DUkJUDm5uaoXLkyVCqVqeIhIiKiQmzn2Tv45Z+ce4MECvcu8BqSZ4FNmDAB48ePR3Jy4dzdlYiIiExDpRaY+Ofre4EK8y7wGgaPAfrnn3/g5+eH+fPn48qVK6hQoQKqVKkCGxsbnXrR0dFGD5KIiIgK3rH4ZCSnPzOobmHdBV7D4ASoZcuWSEhI0O7ZRURERCWLlKSmsO4Cr2FwAqRZMDosLMxkwRAREVHhZWhSU9bGotDuAq8haQyQTFY05vYTERGR8fm4O8BF+fokaOp7XoV+PSBJ6wD169cPlpaWudbZvHnzGwVEREREhZOZXIawjp4YvCoaOc3x+qSFO9rVLfzrAElKgGxtbWFlZWWqWIiIiKiQC/JywcLeDTBleywSUv4bE+RgY45p73mhXd0KBRid4QzeDV4ulyMxMRGOjo6mjqnAcTd4IiKi3BXGbTCk/H4b3ALE8T9ERESkYSaXwc+jbEGHkWcGD4I2sKGIiIiIqNAzOAHat28fHBwK95Q2IiIiIkMY3AXm7+9vyjiIiIiI8o3kvcCIiIiIijpJ0+CJiIioZCuMs7/yggkQERERGSQ8JiHb+j8uSgXCOnoiyKvwL374sjwlQGq1GleuXEFSUhLUarXOsRYtWhglMCIiIio8wmMS9K4AnZiSgcGrorGwd4MilQRJToCOHDmCDz/8EDdu3Mg2NV4mk0GlUhktOCIiIip4KrXAlO2xere/EABkAKZsj0UbT+ci0x0meRD0p59+ikaNGiEmJgbJycl4+PCh9pacnGyKGImIiKgAHYtP1un2epUAkJCSgWPxRScPkNwCFBcXhz/++APVqlUzRTxERERUyCQ9zjn5yUu9wkByC5Cvry+uXLliiliIiIioEHK0VRi1XmEguQVo6NCh+OKLL5CYmIg6derA3Nxc53jdunWNFhwREREVPB93B7goFUhMydA7DkgGwFn5Ykp8UWHwbvAacnn2RiOZTAYhRLEZBM3d4ImIiHRpZoEB0EmCNEOeC8MsMJPsBq8RHx+f58CIiIioaArycsHC3g2yrQPkXETXAZLcAlQSsAWIiIhIv8K8ErTRW4C2bduGtm3bwtzcHNu2bcu1bqdOnQyPlIiIiIoUM7kMfh5lCzqMN2ZQC5BcLkdiYiIcHR31jgHSnoxjgIiIiKiAGL0F6OXtLl7d+oKIiIioqJG8DhARERFRUccEiIiIiEocJkBERERU4kheB4iIiIhKpsI8BV4qJkBERET0WuExCdkWQXQpoosgAnnsArt69SomTpyInj17IikpCQDw119/4fz580YNjoiIiAqeZhuMl5MfAEhMycDgVdEIj0kooMjyTnIC9Pfff6NOnTo4evQoNm/ejLS0NADAmTNnEBYWZvQAiYiIqOCo1AJjN5/TuwmqpmzK9lio1EVrYwnJCdDYsWMxbdo0REREwMLCQlveqlUrHDlyxKjBERERUcGavzcOj548y/G4AJCQkoFj8cn5F5QRSE6Azp07h86dO2crd3R0xP37940SFBERERU8lVpg2aHrBtVNepzx+kqFiOQEyN7eHgkJ2fv6Tp06hYoVKxolKCIiIip4x+KT8ehpzq0/L3O0VZg4GuOSnAD16NEDY8aMQWJiImQyGdRqNQ4dOoRRo0ahb9++poiRiIiICoChrTr21ubwcXcwcTTGJTkBmjFjBmrWrAlXV1ekpaXB09MTLVq0QNOmTTFx4kRTxEhEREQFwNBWnf5N3YvcekAG7Qavz61bt3Du3DmkpaWhfv36qF69urFjKzDcDZ6IiOjFGKDms/YiMSVD7yww4EXrz8mJbQpFAiTl9zvPW2G4urqiXbt26Nat2xsnPwsWLICbmxsUCgV8fX1x7NixXOtv3LgRNWvWhEKhQJ06dbBz506d45MnT0bNmjVhY2ODMmXKICAgAEePHn2jGImIiEoaM7kMYR09AQA5pTffdKlTKJIfqSQnQF27dsWsWbOylX/77bf44IMPJAewfv16hIaGIiwsDNHR0ahXrx4CAwO1Cyy+6vDhw+jZsycGDhyIU6dOITg4GMHBwYiJidHWeeuttzB//nycO3cOBw8ehJubG959913cu3dPcnxEREQlWZCXCxb2bgBnpW53mItSgUW9GxTJVaCBPHSBlS9fHnv37kWdOnV0ys+dO4eAgADcvXtXUgC+vr5o3Lgx5s+fDwBQq9VwdXXF0KFDMXbs2Gz1u3fvjvT0dOzYsUNb1qRJE3h7e2PRokV6n0PTJLZnzx60bt36tTGxC4yIiEhXUdgHTMrvt+S9wNLS0nQWQNQwNzdHamqqpHNlZWXh5MmTGDdunLZMLpcjICAAUVFReh8TFRWF0NBQnbLAwEBs3bo1x+dYvHgxlEol6tWrp7dOZmYmMjMztfelvg4iIqLizkwug59H2YIOw2gkd4HVqVMH69evz1a+bt06eHp6SjrX/fv3oVKp4OTkpFPu5OSExMREvY9JTEw0qP6OHTtQunRpKBQK/PDDD4iIiEC5cuX0nnPmzJlQKpXam6urq6TXQUREREWL5Bagr776Cl26dMHVq1fRqlUrAEBkZCTWrl2LjRs3Gj3AvGrZsiVOnz6N+/fvY8mSJejWrRuOHj0KR0fHbHXHjRun06qUmprKJIiIiKgYk5wAdezYEVu3bsWMGTPwxx9/wMrKCnXr1sWePXvg7+8v6VzlypWDmZlZtnFDd+/ehbOzs97HODs7G1TfxsYG1apVQ7Vq1dCkSRNUr14dS5cu1elu07C0tISlpaWk2ImIiIqzojDm501IToAAoH379mjfvv0bP7mFhQUaNmyIyMhIBAcHA3gxCDoyMhJDhgzR+xg/Pz9ERkZixIgR2rKIiAj4+fnl+lxqtVpnnA8RERHpFx6TgCnbY5GQ8t9K0C5KBcI6ehbZWV+vylMCBLwYXJyUlAS1Wq1TXrlyZUnnCQ0NRUhICBo1agQfHx/MnTsX6enp6N+/PwCgb9++qFixImbOnAkAGD58OPz9/TFnzhy0b98e69atw4kTJ7B48WIAQHp6OqZPn45OnTrBxcUF9+/fx4IFC3D79u08TdMnIiIqScJjEjB4VXS2hQ8TUzIweFU0Fhbhqe8vk5wAxcXFYcCAATh8+LBOuRACMpkMKpVK0vm6d++Oe/fuYdKkSUhMTIS3tzfCw8O1A51v3rwJufy/sdpNmzbFmjVrMHHiRIwfPx7Vq1fH1q1b4eXlBQAwMzPDxYsXsWLFCty/fx9ly5ZF48aNceDAAdSuXVvqyyUiIioxVGqBKdtj9a76LPBiMcQp22PRxtO5yHeHSV4HqFmzZihVqhTGjh0LFxcXyGS6b0BOU82LEq4DREREJVHU1QfoueTIa+utHdSkUE6JN+k6QKdPn8bJkydRs2bNPAdIREREhY+hu78bWq8wk7wOkKenJ+7fv2+KWIiIiKgAGbr7u6H1CjPJCdCsWbPw5ZdfYv/+/Xjw4AFSU1N1bkRERFQ0+bg7wEWpyHHjUxlezAbzcXfIz7BMQvIYIM2A5FfH/uR1EHRhxDFARERUUmlmgQHQGQyt+dUvzLPATDoGaN++fXkOjIiIiAo3ze7vr64D5FzM1gGS3AJUErAFiIiISrqiuBK0lN9vyWOAAODAgQPo3bs3mjZtitu3bwMAVq5ciYMHD+bldERERFTIaHZ/f8+7Ivw8yhb65EcqyQnQpk2bEBgYCCsrK0RHR2u3l0hJScGMGTOMHiARERGRsUlOgKZNm4ZFixZhyZIlMDc315Y3a9YM0dHRRg2OiIiI8pdKLRB19QH+PH0bUVcfQKUuniNlJA+CvnTpElq0aJGtXKlU4tGjR8aIiYiIiApASdgEVUNyC5CzszOuXLmSrfzgwYOoWrWqUYIiIiKi/KWZ/v5y8gP8twlqeExCAUVmGpIToEGDBmH48OE4evQoZDIZ7ty5g9WrV2PUqFEYPHiwKWIkIiIiE1KpBcZuPpfjJqjAi01Qi1N3mOQusLFjx0KtVqN169Z48uQJWrRoAUtLS4waNQpDhw41RYxERERkQvP3xuHRk2c5HhcAElIycCw+uVBugpoXkhIglUqFQ4cO4fPPP8fo0aNx5coVpKWlwdPTE6VLlzZVjERERGQiKrXAskPXDapbHDZB1ZCUAJmZmeHdd9/FhQsXYG9vD09PT1PFRURERPngWHwyHj3NufXnZcVhE1QNyWOAvLy8cO3aNVPEQkRERPnM0FYde2vzYrEJqkae1gEaNWoUduzYgYSEBO4GT0REVIQZ2qrTv6l7sVoNWvIg6Hbt2gEAOnXqpLMjfHHaDZ6IiKik8HF3gItSgcSUDL2zwIAXrT9DWlXL17hMjbvBExERlWBmchnCOnpi8KpoyAC9SdA3XeoUq9YfgLvB68Xd4ImIqKQpDqtAS/n9ltwCBLzYDf6XX37BtWvXsHHjRlSsWBErV66Eu7s7mjdvnqegiYiIqOAEebmgjaczjsUnI+lxBhxtFfBxdyh2LT8a3A2eiIiIALzoDvPzKIv3vCvCz6NssU1+AO4GT0REVGKVlJ3f9eFu8ERERCVQcRjz8ya4GzwREVEJU9J2fteHu8ETERGVICq1wJTtsSVq53d9uBs8ERFRCXIsPjlby8/LiuPO7/oYlACdPXsWXl5ekMvlkMlkmDBhAneDJyIiKoIM3furOO38ro9BXWD169fH/fv3AQBVq1bFgwcPYGFhAU9PT/j4+DD5ISIiKiIM3furOO38ro9BCZC9vT3i4+MBANevX4darTZpUERERGQamr2/clrhR4YXs8GK087v+hjUBda1a1f4+/vDxcUFMpkMjRo1gpmZmd66165dM2qAREREZDy57f2lSYrCOnoW60UQAQMToMWLF6NLly64cuUKhg0bhkGDBsHW1tbUsREREZEJBHm5YGHvBtnWAXIuQesAGbQZ6suDoPv3748ff/yxWCdA3AyViIhKApVaFKu9v4y+GWr9+vWRkJAAR0dH/P3338jKyjJKoERERFRwNHt/lUQcBE1EREQlDgdBExERlUDFrftLKg6CJiIiKmFK+kaogIGDoF/GQdBERERFl2Yj1Fd//DVtPwt7NyiySZCU32/Jm6EuW7asWCc/RERExRU3Qv2PQV1gXbp0wfLly2FnZ4cuXbrkWnfz5s1GCYyIiIiMixuh/segBEipVEImk2n/n4iIiIoeboT6H4MSoGXLlun9fyIiIio6uBHqfwxKgF51//59XL9+HTKZDG5ubihbtng3kxERERUHDauUgVwG5DbERy57Ua+4kzQI+vz582jRogWcnJzg6+sLHx8fODo6olWrVrh48aKpYiQiIiIjOHnjYa7JD/AiOTp542H+BFSADG4BSkxMhL+/P8qXL4/vv/8eNWvWhBACsbGxWLJkCVq0aIGYmBg4OjqaMl4iIiLKI44B+o/BLUA//PADqlSpglOnTmH48OEIDAxEUFAQQkNDER0dDVdXV/zwww95CmLBggVwc3ODQqGAr68vjh07lmv9jRs3ombNmlAoFKhTpw527typPfbs2TOMGTMGderUgY2NDSpUqIC+ffvizp07eYqNiIiouOAYoP8YnABFRERgzJgxUCiyvylWVlYYPXo0du3aJTmA9evXIzQ0FGFhYYiOjka9evUQGBiIpKQkvfUPHz6Mnj17YuDAgTh16hSCg4MRHByMmJgYAMCTJ08QHR2Nr776CtHR0di8eTMuXbqETp06SY6NiIioOPFxd4CLUoGcNryQ4cWK0D7uDvkZVoEweCVoe3t7nDhxAtWqVdN7/MqVK2jUqBEePXokKQBfX180btwY8+fPBwCo1Wq4urpi6NChGDt2bLb63bt3R3p6Onbs2KEta9KkCby9vbFo0SK9z3H8+HH4+Pjgxo0bqFy58mtj4krQRERUXGlWggagsyAiV4LOwePHj3M9ma2tLdLS0gyPEkBWVhZOnjyJgICA/wKSyxEQEICoqCi9j4mKitKpDwCBgYE51geAlJQUyGQy2Nvb6z2emZmJ1NRUnRsREVFxFOTlgoW9G8BZqduj46xUFOnkRypJ0+AfP36stwsMeJF1SdxWDPfv34dKpYKTk5NOuZOTU46zyhITE/XWT0xM1Fs/IyMDY8aMQc+ePXNM4GbOnIkpU6ZIip2IiKioCvJyQRtPZ+4GbwghBN56661cj2tWiy4snj17hm7dukEIgYULF+ZYb9y4cQgNDdXeT01Nhaura36ESEREVCDM5LJiv91FbgxOgPbt22f0Jy9XrhzMzMxw9+5dnfK7d+/C2dlZ72OcnZ0Nqq9Jfm7cuIG9e/fm2n1naWkJS0vLPL4KIiIiKmoMToD8/f2N/uQWFhZo2LAhIiMjERwcDODFIOjIyEgMGTJE72P8/PwQGRmJESNGaMsiIiLg5+enva9JfuLi4rBv3z6uVE1EREQ68rQVhjGFhoYiJCQEjRo1go+PD+bOnYv09HT0798fANC3b19UrFgRM2fOBAAMHz4c/v7+mDNnDtq3b49169bhxIkTWLx4MYAXyc/777+P6Oho7NixAyqVSjs+yMHBARYWFgXzQomIiKjQKPAEqHv37rh37x4mTZqExMREeHt7Izw8XDvQ+ebNm5DL/5us1rRpU6xZswYTJ07E+PHjUb16dWzduhVeXl4AgNu3b2Pbtm0AAG9vb53n2rdvH9555518eV1ERESFhUotSvSAZ30MXgeoJOE6QEREVFyExyRgyvZYJKT8t72Fi1KBsI6exW7Ku0nWASIiIqKiRbPo4cvJDwAkpmRg8KpohMckFFBkBe+NEqBbt27h1q1bxoqFiIiIjESlFpiyPRb6unk0ZVO2x0L1uu3hiynJCdDz58/x1VdfQalUws3NDW5ublAqlZg4cSKePXtmihiJiIhIomPxydlafl4mACSkZOBYfHL+BVWISB4EPXToUGzevBnffvutdup5VFQUJk+ejAcPHuS64CARERHlj6THOSc/ealX3EhOgNasWYN169ahbdu22rK6devC1dUVPXv2ZAJERERUCDja6t+6Kq/1ihvJXWCWlpZwc3PLVu7u7s41doiIiAoJH3cHuCgVyGmyuwwvZoP5uDvkZ1iFhuQEaMiQIZg6dSoyMzO1ZZmZmZg+fXqOqzcTERFR/jKTyxDW0VPvMU1SFNbRs8SuByS5C+zUqVOIjIxEpUqVUK9ePQDAmTNnkJWVhdatW6NLly7aups3bzZepERERCSZ0tocj57oTlKytzbHzC51it06QFJIToDs7e3RtWtXnTLunE5ERFS4aNYA0jfJ/eETztqWnAAtW7bMFHEQERGRkeS2BhDwogtsyvZYtPF0LrFdYFwJmoiIqJjhGkCvJ7kFyN3dHTJZztnitWvX3iggIiIiejNcA+j1JCdAI0aM0Ln/7NkznDp1CuHh4Rg9erSx4iIiIqI8Klfa0qB6JXUNICAPCdDw4cP1li9YsAAnTpx444CIiIgo78JjEjB52/lc68gAOJfgNYAAI44Batu2LTZt2mSs0xEREZFEmplfiamZOdbhGkAvSG4Byskff/wBB4eSm0kSEREVpNfN/NJwVioQ1tGzRK8BBOQhAapfv77OIGghBBITE3Hv3j38/PPPRg2OiIiIDPO6mV8a371fD82ql8uHiAo3yQlQcHCwzn25XI7y5cvjnXfeQc2aNY0VFxEREUlg6Iyu++k5d4+VJJIToLCwMFPEQURERG+Au79Lk6cxQCqVClu3bsWFCxcAALVr10anTp1gZmZm1OCIiIjIMJrd3xNTMvSOA+LML12SZ4FduXIFtWrVQt++fbF582Zs3rwZvXv3Ru3atXH16lVTxEhERESv8fLu76/O7eLMr+wkJ0DDhg2Dh4cHbt26hejoaERHR+PmzZtwd3fHsGHDTBEjERERGSDIywULezeAs1K3m8tZqcDC3g1K/Myvl8mEEK+bMafDxsYGR44cQZ06dXTKz5w5g2bNmiEtLc2oARaE1NRUKJVKpKSkwM7OrqDDISIikkSlFjgWn4ykxxlwtH3R7VUSWn6k/H5LHgNkaWmJx48fZytPS0uDhYWF1NMRERGRkZnJZfDzKFvQYRRqkrvAOnTogI8//hhHjx6FEAJCCBw5cgSffvopOnXqZIoYiYiISA+VWiDq6gP8efo2oq4+gEotqVOnRJPcAvTjjz8iJCQEfn5+MDc3BwA8f/4cnTp1wrx584weIBEREWUXHpOAKdtjdRY/dOEqzwaTNAZICIFbt26hfPnyuH37tnYafK1atVCtWjWTBZnfOAaIiIgKM82eX6/+gGtG+ZTUAc8mGwMkhEC1atVw/vx5VK9evVglPUREREVBbnt+CbxIgqZsj0UbT+cSMfA5rySNAZLL5ahevToePHhgqniIiIgoF6/b80sASEjJwLH45PwLqgiSPAj6m2++wejRoxETE2OKeIiIiCgXhu75ZWi9kkryIOi+ffviyZMnqFevHiwsLGBlZaVzPDmZGScREZGpcM8v45CcAM2dO9cEYRAREZEhuOeXcUhOgEJCQkwRBxERERlAs+fX4FXRkAE6SRD3/DJcnnaDB4Dz589DpVJp75uZmaF27dpGCYqIiIhyFuTlggUfNsDEP2OQnJ6lLXfmOkAGM3gQ9IEDB9C4cWPt/SZNmqB+/frw9vaGt7c36tatiz179pgkSCIiIvpPeEwCpv4vVif5cbAxx1ftazH5MZDBCdDPP/+MPn366JTt27cP8fHxuHbtGoYPH46FCxcaPUAiIiL6j2YRxFenwj9Mf4bP15xCeExCAUVWtBicAJ04cQKtWrXSKatUqRKqVKkCNzc39OnTB1FRUUYPkIiIiF4sgHgo7j7GbjqX4yKIwItFELkn2OsZPAbo33//hVKp1N5fsWIFnJ2dtfcdHBy4QCIREZEJ6Nv3S5+XF0HkbvC5M7gFyNbWFlevXtXe79KlC6ytrbX34+PjuW8WERGRkeXU5ZUbLoL4egYnQL6+vvj9999zPL58+XL4+voaJSgiIiLKfd+v3HARxNczuAssNDQUAQEBKFu2LEaPHg1HR0cAQFJSEmbNmoVVq1Zh9+7dJguUiIiopHndvl+v4iKIhjM4AWrZsiV++uknjBw5Et9//z3s7Owgk8mQkpKCUqVKYe7cudkGSRMREVHeSenK4iKI0khaCPGzzz5Dx44d8ccffyAuLg4AUL16dbz//vtwdXU1SYBEREQllZSuLC6CKI3klaBdXV0xcuRIU8RCREREL3ndvl8AYG9ljgW9GqBJ1bJs+ZHA4EHQRERElL80+34B/3Vxacj+//ZN1zpoVq0ckx+JCjwBWrBgAdzc3KBQKODr64tjx47lWn/jxo2oWbMmFAoF6tSpg507d+oc37x5M959912ULVsWMpkMp0+fNmH0REREphXk5YKFvRvAWanbHeasVGBh7wbs8sqjPG+Gagzr169HaGgoFi1aBF9fX8ydOxeBgYG4dOmSdpbZyw4fPoyePXti5syZ6NChA9asWYPg4GBER0fDy8sLAJCeno7mzZujW7duGDRoUH6/JCIiIqML8nJBG09nHItPRtLjDDjavpjpxVafvJMJIQpsvWxfX180btwY8+fPBwCo1Wq4urpi6NChGDt2bLb63bt3R3p6Onbs2KEta9KkCby9vbFo0SKdutevX4e7uztOnToFb29vSXGlpqZCqVQiJSWFizsSEVGBUKkFEx6JpPx+56kF6NGjR/jjjz9w9epVjB49Gg4ODoiOjoaTkxMqVqxo0DmysrJw8uRJjBs3Tlsml8sREBCQ455iUVFRCA0N1SkLDAzE1q1b8/IytDIzM5GZmam9n5qa+kbnIyIiehP6tr5w4Swvo5I8Bujs2bN46623MGvWLHz33Xd49OgRgBdjb15OZl7n/v37UKlUcHJy0il3cnJCYmKi3sckJiZKqm+omTNnQqlUam+c0k9ERAUlp60vElMyMHhVNHd7NxLJCVBoaCj69euHuLg4KBT/Dchq164d/vnnH6MGl1/GjRuHlJQU7e3WrVsFHRIREZVAuW19wd3ejUtyF9jx48fxyy+/ZCuvWLGipJaYcuXKwczMDHfv3tUpv3v3rs4u8y9zdnaWVN9QlpaWsLS0fKNzEBERvanXbX3B3d6NR3ILkKWlpd4xMpcvX0b58uUNPo+FhQUaNmyIyMhIbZlarUZkZCT8/Pz0PsbPz0+nPgBERETkWJ+IiKgoMXTrC+72/uYkJ0CdOnXC119/jWfPngEAZDIZbt68iTFjxqBr166SzhUaGoolS5ZgxYoVuHDhAgYPHoz09HT0798fANC3b1+dcUXDhw9HeHg45syZg4sXL2Ly5Mk4ceIEhgwZoq2TnJyM06dPIzY2FgBw6dIlnD59+o3HCREREZmaoVtfcLf3Nyc5AZozZw7S0tLg6OiIp0+fwt/fH9WqVYOtrS2mT58u6Vzdu3fHd999h0mTJsHb2xunT59GeHi4dqDzzZs3kZDw32Cvpk2bYs2aNVi8eDHq1auHP/74A1u3btWuAQQA27ZtQ/369dG+fXsAQI8ePVC/fv1s0+SJiIgKm4ZVysDBxiLH4zK8mA3G3d7fXJ7XATp48CDOnj2LtLQ0NGjQAAEBAcaOrcBwHSAiIspv+qa+v0yzAhBXf86ZlN/vAl0IsbBiAkRERPlJM/U9tx9krgP0eiZdCPHHH3/UWy6TyaBQKFCtWjW0aNECZmZmUk9NRERU4uQ29V3DwcYcf49uCYtSBb6FZ7EhOQH64YcfcO/ePTx58gRlypQBADx8+BDW1tYoXbo0kpKSULVqVezbt48LChIREeVCpRZYfig+16nvAJCc/gwnbzzk1HcjkpxKzpgxA40bN0ZcXBwePHiABw8e4PLly/D19cW8efNw8+ZNODs7Y+TIkaaIl4iIqFgIj0lA81l7MfV/Fwyqz6nvxiW5BWjixInYtGkTPDw8tGXVqlXDd999h65du+LatWv49ttvJU+JJyIiKikMGfPzKk59Ny7JCVBCQgKeP3+erfz58+fatXYqVKiAx48fv3l0RERExYwhY35eJgPgzKnvRie5C6xly5b45JNPcOrUKW3ZqVOnMHjwYLRq1QoAcO7cObi7uxsvSiIiomLiddtdvEwz9T2soyfM5LJc65I0khOgpUuXwsHBAQ0bNtTuodWoUSM4ODhg6dKlAIDSpUtjzpw5Rg+WiIioqJMylsdZqeC6PyYiuQvM2dkZERERuHjxIi5fvgwAqFGjBmrUqKGt07JlS+NFSEREVIwYOpbnq/a10K+ZO1t+TERyAqRRs2ZN1KxZ05ixEBERFXs+7g5wUSqQmJKhdxyQZswPkx/TylMC9O+//2Lbtm24efMmsrKydI59//33RgmMiIioqFOpBY7FJyPpcQYcbV8MZDaTyxDW0RODV0VDBugkQRzzk38kJ0CRkZHo1KkTqlatiosXL8LLywvXr1+HEAINGjQwRYxERERFjr69vV7ezmJh7wbZjjtzu4t8I3kvMB8fH7Rt2xZTpkyBra0tzpw5A0dHR/Tq1QtBQUEYPHiwqWLNN9wLjIiI3kRO6/y8uqFpTi1ElDcm3QzV1tYWp0+fhoeHB8qUKYODBw+idu3aOHPmDN577z1cv379TWIvFJgAERFRXqnUAs1n7c11V3dnpQIHx7RismNkUn6/JU+Dt7Gx0Y77cXFxwdWrV7XH7t+/L/V0RERExcrr1vkRABJSMnAsPjn/gqJsJI8BatKkCQ4ePIhatWqhXbt2+OKLL3Du3Dls3rwZTZo0MUWMRERERYah6/xwb6+CJTkB+v7775GWlgYAmDJlCtLS0rB+/XpUr16dM8CIiKjEM3SdH+7tVbAkJUAqlQr//vsv6tatC+BFd9iiRYtMEhgREVFR9DA9E3IZoM5hhC339iocJI0BMjMzw7vvvouHDx+aKh4iIqIiKzwmAZ+vOZVj8qPBdX4KnuRB0F5eXrh27ZopYiEiIiqyDNnlXS4DFnzIvb0KA8kJ0LRp0zBq1Cjs2LEDCQkJSE1N1bkRERGVRIbs8q4WQBkbi3yKiHIjeRB0u3btAACdOnWCTPZf850QAjKZDCqVynjRERERFWIvL2QYdzfNoMdw9lfhIDkB2rdvnyniICIiKlL0bXVhCM7+KhwkJ0D+/v6miIOIiKjIyGmri9xw9lfhInkMEAAcOHAAvXv3RtOmTXH79m0AwMqVK3Hw4EGjBkdERFTYGDLY+VXc5b3wkZwAbdq0CYGBgbCyskJ0dDQyMzMBACkpKZgxY4bRAyQiIipMDBns/CpnpUK7ASoVDpK7wKZNm4ZFixahb9++WLdunba8WbNmmDZtmlGDIyIiKmwMHcQ8pKUHqjvZcpf3QkpyAnTp0iW0aNEiW7lSqcSjR4+MERMREVGhZegg5mbVysPPo6yJo6G8ktwF5uzsjCtXrmQrP3jwIKpWrWqUoIiIiAorH3cHuCgVyKk9RwbAhYOdCz3JCdCgQYMwfPhwHD16FDKZDHfu3MHq1asxatQoDB482BQxEhERFRpmchnCOnoCQLYkiIOdiw7JXWBjx46FWq1G69at8eTJE7Ro0QKWlpYYNWoUhg4daooYiYiICpUgLxcs7N0g2zpAzkoFwjp6crBzESATQkiZyaeVlZWFK1euIC0tDZ6enihdurSxYyswqampUCqVSElJgZ2dXUGHQ0REhdTLK0FzsHPBk/L7LbkFaNWqVejSpQusra3h6emZ5yCJiIiKgtySHDO5jAOdiyjJLUDly5fH06dP0alTJ/Tu3RuBgYEwMzMzVXwFgi1AREQE6N/uwoXdXIWWlN9vyYOgExISsG7dOshkMnTr1g0uLi74/PPPcfjw4TwHTEREVNhotrt4ddHDxJQMDF4VjfCYhAKKjIxBcgJUqlQpdOjQAatXr0ZSUhJ++OEHXL9+HS1btoSHh4cpYiQiIspXuW13oSmbsj0WKnWehtFSISB5DNDLrK2tERgYiIcPH+LGjRu4cOGCseIiIiIqMK/b7kIASEjJwLH4ZI4BKqLytBnqkydPsHr1arRr1w4VK1bE3Llz0blzZ5w/f97Y8REREeW7PbGJBtUzdFsMKnwktwD16NEDO3bsgLW1Nbp164avvvoKfn5+poiNiIgo34XHJGDpoesG1TV0WwwqfCQnQGZmZtiwYYPe2V8xMTHw8vIyWnBERET5STP253VkeLHoIbe7KLokJ0CrV6/Wuf/48WOsXbsWv/76K06ePAmVSmW04IiIiEzt5XV+7j/OzHXsj4YAt7so6vI8CPqff/7B0qVLsWnTJlSoUAFdunTBggULjBkbERFRnhmySrO+dX4MMaCZG9cBKuIkJUCJiYlYvnw5li5ditTUVHTr1g2ZmZnYunUrV4UmIqJCw5AFDDXr/ORlInsbT2cjRUoFxeBZYB07dkSNGjVw9uxZzJ07F3fu3MFPP/1kytiIiIgkM2QBw9zW+cmNDC8SKY79KfoMbgH666+/MGzYMAwePBjVq1c3ZUzFFjfNI6LCzNTfUfnxHahSC4zdfO61CxjaKswld3tpIuXYn+LB4BaggwcP4vHjx2jYsCF8fX0xf/583L9/3yhBLFiwAG5ublAoFPD19cWxY8dyrb9x40bUrFkTCoUCderUwc6dO3WOCyEwadIkuLi4wMrKCgEBAYiLizNKrHkVHpOA5rP2oueSIxi+7jR6LjmC5rP2cil1IioUTP0dlV/fgfP3xuHRk2e51klIyUDU1QeSz+2sVGBh7wYc+1NMGJwANWnSBEuWLEFCQgI++eQTrFu3DhUqVIBarUZERAQeP36cpwDWr1+P0NBQhIWFITo6GvXq1UNgYCCSkpL01j98+DB69uyJgQMH4tSpUwgODkZwcDBiYmK0db799lv8+OOPWLRoEY4ePQobGxsEBgYiI6NgFqzifjJEVJiZ+jsqv74DVWqB3w7FG1RXGNj59VX7WpjXwxtrBzXBwTGtmPwUI5J3g3/ZpUuXsHTpUqxcuRKPHj1CmzZtsG3bNknn8PX1RePGjTF//nwAgFqthqurK4YOHYqxY8dmq9+9e3ekp6djx44d2rImTZrA29sbixYtghACFSpUwBdffIFRo0YBAFJSUuDk5ITly5ejR48er43JmLvBq9QCzWftzbGpVbOWxMExrdikSkT5ztTfUfn5HRh19QF6LjliUN0J7Writ0PXkZiSoTcV4ndz0WTS3eBfVqNGDXz77bf4999/sXbtWsmPz8rKwsmTJxEQEPBfQHI5AgICEBUVpfcxUVFROvUBIDAwUFs/Pj4eiYmJOnWUSiV8fX1zPGdmZiZSU1N1bsYiZT8ZIqL8ZurvqPz8DpSyLUW50pYI6/hi9vKr6Q3H+pQMb5QAaZiZmSE4OFhy68/9+/ehUqng5OSkU+7k5ITERP37sCQmJuZaX/NfKeecOXMmlEql9ubq6irpdeTG0A8k95MhooJg6u+o/PwOlLIthbPSCkFeLljYuwGclYpXjnGsT0nwRrvBFxfjxo1DaGio9n5qaqrRkiBDP5DcT4aICoKpv6Py8zvQx90BznaWSEzNzLXey9PYg7xc0MbTmTN0SyCjtADlVbly5WBmZoa7d+/qlN+9exfOzvoXmXJ2ds61vua/Us5paWkJOzs7nZux+Lg7wEWpyNbEqsE1JYioIJn6Oyo/vwPN5DJM7lT7tfVe7doyk8vg51EW73lXhJ9HWSY/JUSBJkAWFhZo2LAhIiMjtWVqtRqRkZE57jDv5+enUx8AIiIitPXd3d3h7OysUyc1NRVHjx4tkF3rzeQy9jMTUaFl6u+o/P4ODPJywaLeDWBvbZ7tWBlrcyxi1xb9vzeaBWYM69evR0hICH755Rf4+Phg7ty52LBhAy5evAgnJyf07dsXFStWxMyZMwG8mAbv7++Pb775Bu3bt8e6deswY8YMREdHa3einzVrFr755husWLEC7u7u+Oqrr3D27FnExsZCoXh9M6sxZ4FpGLIsOxFRQTH1d1R+fweq1AJHrj5A1LX7AF608DSpytad4k7K73eBJ0AAMH/+fMyePRuJiYnw9vbGjz/+CF9fXwDAO++8Azc3Nyxfvlxbf+PGjZg4cSKuX7+O6tWr49tvv0W7du20x4UQCAsLw+LFi/Ho0SM0b94cP//8M9566y2D4jFFAgRwJWgiKtyKw0rQVLIVuQSosDFVAkRERESmk2/rABEREREVRUyAiIiIqMRhAkREREQlDhMgIiIiKnGYABEREVGJwwSIiIiIShwmQERERFTiMAEiIiKiEocJEBEREZU4pQo6gMJIszh2ampqAUdCREREhtL8bhuyyQUTID0eP34MAHB1dS3gSIiIiEiqx48fQ6lU5lqHe4HpoVarcefOHdja2kImK94b9aWmpsLV1RW3bt3ivmeFCK9L4cVrUzjxuhRO+X1dhBB4/PgxKlSoALk891E+bAHSQy6Xo1KlSgUdRr6ys7Pjl0YhxOtSePHaFE68LoVTfl6X17X8aHAQNBEREZU4TICIiIioxGECVMJZWloiLCwMlpaWBR0KvYTXpfDitSmceF0Kp8J8XTgImoiIiEoctgARERFRicMEiIiIiEocJkBERERU4jABIiIiohKHCVAxtGDBAri5uUGhUMDX1xfHjh3Ltf7cuXNRo0YNWFlZwdXVFSNHjkRGRsYbnZOyM/Z1mTlzJho3bgxbW1s4OjoiODgYly5dMvXLKHZM8XnR+OabbyCTyTBixAgTRF68meK63L59G71790bZsmVhZWWFOnXq4MSJE6Z8GcWOsa+LSqXCV199BXd3d1hZWcHDwwNTp041aC+vNyaoWFm3bp2wsLAQv/32mzh//rwYNGiQsLe3F3fv3tVbf/Xq1cLS0lKsXr1axMfHi127dgkXFxcxcuTIPJ+TsjPFdQkMDBTLli0TMTEx4vTp06Jdu3aicuXKIi0tLb9eVpFniuuicezYMeHm5ibq1q0rhg8fbuJXUryY4rokJyeLKlWqiH79+omjR4+Ka9euiV27dokrV67k18sq8kxxXaZPny7Kli0rduzYIeLj48XGjRtF6dKlxbx580z+epgAFTM+Pj7i888/195XqVSiQoUKYubMmXrrf/7556JVq1Y6ZaGhoaJZs2Z5PidlZ4rr8qqkpCQBQPz999/GCboEMNV1efz4sahevbqIiIgQ/v7+TIAkMsV1GTNmjGjevLlpAi4hTHFd2rdvLwYMGKBTp0uXLqJXr15GjFw/doEVI1lZWTh58iQCAgK0ZXK5HAEBAYiKitL7mKZNm+LkyZPaZsxr165h586daNeuXZ7PSbpMcV30SUlJAQA4ODgYMfriy5TX5fPPP0f79u11zk2GMdV12bZtGxo1aoQPPvgAjo6OqF+/PpYsWWLaF1OMmOq6NG3aFJGRkbh8+TIA4MyZMzh48CDatm1rwlfzAjdDLUbu378PlUoFJycnnXInJydcvHhR72M+/PBD3L9/H82bN4cQAs+fP8enn36K8ePH5/mcpMsU1+VVarUaI0aMQLNmzeDl5WX011Acmeq6rFu3DtHR0Th+/LhJ4y+uTHVdrl27hoULFyI0NBTjx4/H8ePHMWzYMFhYWCAkJMSkr6k4MNV1GTt2LFJTU1GzZk2YmZlBpVJh+vTp6NWrl0lfD8BB0CXe/v37MWPGDPz888+Ijo7G5s2b8b///Q9Tp04t6NBKNKnX5fPPP0dMTAzWrVuXz5GWLK+7Lrdu3cLw4cOxevVqKBSKAo625DDk86JWq9GgQQPMmDED9evXx8cff4xBgwZh0aJFBRh58WbIddmwYQNWr16NNWvWIDo6GitWrMB3332HFStWmD5Ak3eyUb7JzMwUZmZmYsuWLTrlffv2FZ06ddL7mObNm4tRo0bplK1cuVJYWVkJlUqVp3OSLlNcl5d9/vnnolKlSuLatWtGjbu4M8V12bJliwAgzMzMtDcAQiaTCTMzM/H8+XNTvZxiw1Sfl8qVK4uBAwfq1Pn5559FhQoVjBd8MWaq61KpUiUxf/58nTpTp04VNWrUMF7wOWALUDFiYWGBhg0bIjIyUlumVqsRGRkJPz8/vY958uQJ5HLdPwMzMzMAgBAiT+ckXaa4Lpr/DhkyBFu2bMHevXvh7u5uoldQPJniurRu3Rrnzp3D6dOntbdGjRqhV69eOH36tLYu5cxUn5dmzZplWybi8uXLqFKlijHDL7ZMdV1yqqNWq40Zvn4mT7EoX61bt05YWlqK5cuXi9jYWPHxxx8Le3t7kZiYKIQQok+fPmLs2LHa+mFhYcLW1lasXbtWXLt2TezevVt4eHiIbt26GXxOej1TXJfBgwcLpVIp9u/fLxISErS3J0+e5PvrK6pMcV1exVlg0pniuhw7dkyUKlVKTJ8+XcTFxYnVq1cLa2trsWrVqnx/fUWVKa5LSEiIqFixonYa/ObNm0W5cuXEl19+afLXwwSoGPrpp59E5cqVhYWFhfDx8RFHjhzRHvP39xchISHa+8+ePROTJ08WHh4eQqFQCFdXV/HZZ5+Jhw8fGnxOMoyxrwsAvbdly5bl34sqBkzxeXkZE6C8McV12b59u/Dy8hKWlpaiZs2aYvHixfn0aooPY1+X1NRUMXz4cFG5cmWhUChE1apVxYQJE0RmZqbJX4tMiPxYbpGIiIio8OAYICIiIipxmAARERFRicMEiIiIiEocJkBERERU4jABIiIiohKHCRARERGVOEyAiIiIqMRhAkREREQlDhMgIipQUVFRMDMzQ/v27Qs6FCIqQbgSNBEVqI8++gilS5fG0qVLcenSJVSoUKFA4sjKyoKFhUWBPDcR5T+2ABFRgUlLS8P69esxePBgtG/fHsuXL9c5vn37djRu3BgKhQLlypVD586dtccyMzMxZswYuLq6wtLSEtWqVcPSpUsBAMuXL4e9vb3OubZu3QqZTKa9P3nyZHh7e+PXX3+Fu7s7FAoFACA8PBzNmzeHvb09ypYtiw4dOuDq1as65/r333/Rs2dPODg4wMbGBo0aNcLRo0dx/fp1yOVynDhxQqf+3LlzUaVKlfzZ4ZqIDMIEiIgKzIYNG1CzZk3UqFEDvXv3xm+//QZNo/T//vc/dO7cGe3atcOpU6cQGRkJHx8f7WP79u2LtWvX4scff8SFCxfwyy+/oHTp0pKe/8qVK9i0aRM2b96M06dPAwDS09MRGhqKEydOIDIyEnK5HJ07d9YmL2lpafD398ft27exbds2nDlzBl9++SXUajXc3NwQEBCAZcuW6TzPsmXL0K9fP8jl/MolKjRMvt0qEVEOmjZtKubOnSuEeLFzdLly5cS+ffuEEEL4+fmJXr166X3cpUuXBAARERGh9/iyZcuEUqnUKduyZYt4+SsvLCxMmJubi6SkpFxjvHfvngAgzp07J4QQ4pdffhG2trbiwYMHeuuvX79elClTRmRkZAghhDh58qSQyWQiPj4+1+chovzFf44QUYG4dOkSjh07hp49ewIASpUqhe7du2u7sU6fPo3WrVvrfezp06dhZmYGf3//N4qhSpUqKF++vE5ZXFwcevbsiapVq8LOzg5ubm4AgJs3b2qfu379+nBwcNB7zuDgYJiZmWHLli0AXnTHtWzZUnseIiocShV0AERUMi1duhTPnz/XGfQshIClpSXmz58PKyurHB+b2zEAkMvl2q40jWfPnmWrZ2Njk62sY8eOqFKlCpYsWYIKFSpArVbDy8sLWVlZBj23hYUF+vbti2XLlqFLly5Ys2YN5s2bl+tjiCj/sQWIiPLd8+fP8fvvv2POnDk4ffq09nbmzBlUqFABa9euRd26dREZGan38XXq1IFarcbff/+t93j58uXx+PFjpKena8s0Y3xy8+DBA1y6dAkTJ05E69atUatWLTx8+FCnTt26dXH69GkkJyfneJ6PPvoIe/bswc8//4znz5+jS5cur31uIspfbAEiony3Y8cOPHz4EAMHDoRSqdQ51rVrVyxduhSzZ89G69at4eHhgR49euD58+fYuXMnxowZAzc3N4SEhGDAgAH48ccfUa9ePdy4cQNJSUno1q0bfH19YW1tjfHjx2PYsGE4evRothlm+pQpUwZly5bF4sWL4eLigps3b2Ls2LE6dXr27IkZM2YgODgYM2fOhIuLC06dOoUKFSrAz88PAFCrVi00adIEY8aMwYABA17bakRE+Y8tQESU75YuXYqAgIBsyQ/wIgE6ceIEHBwcsHHjRmzbtg3e3t5o1aoVjh07pq23cOFCvP/++/jss89Qs2ZNDBo0SNvi4+DggFWrVmHnzp2oU6cO1q5di8mTJ782LrlcjnXr1uHkyZPw8vLCyJEjMXv2bJ06FhYW2L17NxwdHdGuXTvUqVMH33zzDczMzHTqDRw4EFlZWRgwYEAe3iEiMjUuhEhEZAJTp07Fxo0bcfbs2YIOhYj0YAsQEZERpaWlISYmBvPnz8fQoUMLOhwiygETICIiIxoyZAgaNmyId955h91fRIUYu8CIiIioxGELEBEREZU4TICIiIioxGECRERERCUOEyAiIiIqcZgAERERUYnDBIiIiIhKHCZAREREVOIwASIiIqIShwkQERERlTj/B/+bRy9sEBlCAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fpredictor_up.fit(gm.accuracy,gm.true_neg_rate.diff,0.02,grid_width=grid_width,force_levelling_up='-')\n", + "fpredictor_up.plot_frontier(objective1=gm.true_neg_rate.diff,objective2=gm.accuracy, show_updated=False)\n", + "plt.title('Forced levelling-up: Equal Specificity vs Accuracy trade-off')" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fpredictor_up.plot_frontier(objective1=gm.true_neg_rate.min,objective2=gm.accuracy, color='blue',show_original=False,show_updated=False)\n", + "fpredictor_up.plot_frontier(objective1=gm.true_neg_rate.max,objective2=gm.accuracy,new_plot=False,color='red',show_original=False,show_updated=False)\n", + "plt.title('Levelling Up: Minimum True NegativeRate vs Accuracy trade-off')\n", + "plt.ylabel('Per Group True Negative Rate')\n", + "plt.legend(('Frontier Min group TNR','Frontier Max group TNR'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -1131,7 +1030,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.1.-1" + "version": "3.10.14" }, "vscode": { "interpreter": { diff --git a/src/oxonfair/learners/efficient_compute.py b/src/oxonfair/learners/efficient_compute.py index 3ab326d..cf1668d 100644 --- a/src/oxonfair/learners/efficient_compute.py +++ b/src/oxonfair/learners/efficient_compute.py @@ -49,13 +49,14 @@ def compute_metric( def keep_front(solutions: np.ndarray, initial_weights: np.ndarray, directions: np.ndarray, additional_constraints: Sequence, - *, tol=1e-12) -> Tuple[np.ndarray, np.ndarray]: + *, tol=1e-12, force_levelling_up=False) -> Tuple[np.ndarray, np.ndarray]: """Modified from https://stackoverflow.com/questions/32791911/fast-calculation-of-pareto-front-in-python Returns Pareto efficient row subset of solutions and its associated weights Direction if a vector that governs if the frontier should maximize or minimize each direction. Where an element of direction is positive frontier maximizes, negative, it mimizes. + parameters ---------- solutions: a numpy array of values that are evaluated to find the frontier @@ -68,7 +69,12 @@ def keep_front(solutions: np.ndarray, initial_weights: np.ndarray, directions: n additional constrains: vector of floats of size frontier width - 2 These are hard constraints any point will be discarded if solution[i+2]*direction Tuple[np.ndarray, np.ndarray]: + additional_constraints=(), + force_levelling_up=False) -> Tuple[np.ndarray, np.ndarray]: """Efficient grid search. Functions under the assumption data is hard assigned by a group classifer with errors and the alignment need not perfectly correspond to groups @@ -402,8 +435,7 @@ def grid_search(y_true: np.ndarray, proba: np.ndarray, metrics: Tuple[BaseGroupM directions: (optional) a binary vector containing [+1,-1] indicating if greater or lower solutions are prefered """ - assert proba.shape[1] == 2 - assert proba.ndim == 2 + assert proba.ndim == 1 assert y_true.ndim == 1 assert y_true.shape[0] == proba.shape[0] points = y_true.shape[0] @@ -411,7 +443,9 @@ def grid_search(y_true: np.ndarray, proba: np.ndarray, metrics: Tuple[BaseGroupM assert hard_assignment.ndim == 1 assert true_groups.shape[0] == points assert true_groups.ndim == 1 - score = proba[:, 0] - proba[:, 1] + # score = proba[:, 0] - proba[:, 1] + score = proba + if group_response is not False: assert group_response.ndim == 1 assert points == group_response.shape[0] @@ -481,11 +515,13 @@ def mask_weight(weight, mask): if unweighted_path: score, indicies, front, index = grid_search_no_weights(ordered_encode, ass_size, score, - metrics, steps, directions, additional_constraints) + metrics, steps, directions, additional_constraints, + force_levelling_up) else: score, indicies, front, index = grid_search_weights(ordered_encode, ordered_encode2, ass_size, score, metrics, - steps, directions, additional_constraints) + steps, directions, additional_constraints, + force_levelling_up) new_front, new_index = keep_front(score, indicies, directions, additional_constraints) # merge the two existing fronts diff --git a/src/oxonfair/learners/fair.py b/src/oxonfair/learners/fair.py index ee7985d..034b7bf 100644 --- a/src/oxonfair/learners/fair.py +++ b/src/oxonfair/learners/fair.py @@ -134,7 +134,7 @@ def predictor(x): self._internal_groups = self.groups_to_numpy(groups, self.validation_data) self._internal_conditioning_factor = self.cond_fact_to_numpy(conditioning_factor, self.validation_data) assert self._internal_groups.shape[0] == validation_labels.shape[0], 'The size of the groups does not match the dataset size' - assert np.unique(validation_labels).shape[0] == 2, 'More than two target labels used. OxonFair only works with binary predictors' + assert np.unique(validation_labels).shape[0] <= 2, 'More than two target labels used. OxonFair only works with binary predictors' self.inferred_groups = inferred_groups if inferred_groups: @@ -240,8 +240,9 @@ def infered_to_hard(self, infered): def fit(self, objective, constraint=group_metrics.accuracy, value=0.0, *, greater_is_better_obj=None, greater_is_better_const=None, recompute=True, tol=False, grid_width=False, threshold=None, - additional_constraints=()): + additional_constraints=(), force_levelling_up=False): """Fits the chosen predictor to optimize an objective while satisfing a constraint. + parameters ---------- objective: a BaseGroupMetric or Scorable to be optimised @@ -268,6 +269,13 @@ def fit(self, objective, constraint=group_metrics.accuracy, value=0.0, *, threshold: A float between 0 and 1 or None. If threshold is not None, this overwrites the threshold used for assignment to a "don't know class" in the hard assignment of inferened groups. + additional_constraints: A list of tupples of the form (metric, value, direction[optional]). + This will drop all solutions from the pareto frontier that do not satisfy all additional constraints + force_levelling_up: None (default), +1, or -1. + If none, do nothing. + If +1 force all weights found to be non-negative -- i.e. fit can only increase the selection rate. + If -1 force all weights found to be non-positive -- i.e. fit can only decrease the selection rate. + returns ------- Nothing @@ -284,7 +292,8 @@ def fit(self, objective, constraint=group_metrics.accuracy, value=0.0, *, greater_is_better_obj1=greater_is_better_obj, greater_is_better_obj2=greater_is_better_const, tol=tol, grid_width=grid_width, - additional_constraints=additional_constraints) + additional_constraints=additional_constraints, + force_levelling_up=force_levelling_up) if greater_is_better_const: mask = self.frontier[0][1] >= value else: @@ -307,8 +316,10 @@ def fit(self, objective, constraint=group_metrics.accuracy, value=0.0, *, def compute_frontier(self, objective1, objective2, greater_is_better_obj1, greater_is_better_obj2, *, tol=False, - grid_width=False, additional_constraints=()) -> None: + grid_width=False, additional_constraints=(), + force_levelling_up=False) -> None: """ Computes the parato frontier. Internal logic used by fit + parameters ---------- objective1: a BaseGroupMetric or Scorable to be optimised @@ -324,6 +335,7 @@ def compute_frontier(self, objective1, objective2, greater_is_better_obj1, Generally not needed. grid_width: allows manual specification of the grid size. N.B. the overall computational budget is O(grid_width**groups) + returns ------- Nothing @@ -351,10 +363,19 @@ def compute_frontier(self, objective1, objective2, greater_is_better_obj1, values[i] = c[1] proba = self.proba + self.round = tol if tol is not False: proba = np.around(self.proba / tol) * tol + proba = proba[:, 0] - proba[:, 1] + + if force_levelling_up: # Truncate search space + if force_levelling_up == '-': + proba = np.minimum(proba, -1e-6) + else: + proba = np.maximum(proba, 0) + assert force_levelling_up in [False, '+', '-', True], 'force_levelling_up must be one of False, +, - or True' def call_slow(existing_weights=None): fix_obj = [fix_groups_and_conditioning(obj, self._internal_groups, @@ -363,7 +384,7 @@ def call_slow(existing_weights=None): gw = 18 else: gw = grid_width - coarse_thresh = np.asarray(self._val_thresholds, dtype=np.float16) + coarse_thresh = self._val_thresholds # np.asarray(self._val_thresholds, dtype=np.float16) return fair_frontier.build_coarse_to_fine_front(fix_obj, self.y_true, proba, coarse_thresh, @@ -372,7 +393,7 @@ def call_slow(existing_weights=None): initial_divisions=gw, logit_scaling=self.logit_scaling, existing_weights=existing_weights, - additional_constraints=values) + additional_constraints=values) # force_levelling_up=True) def call_fast(grid_width=grid_width): if grid_width is False: @@ -382,7 +403,8 @@ def call_fast(grid_width=grid_width): self._internal_groups, steps=min(30, (30**5)**(1 / self._val_thresholds.shape[1])), directions=direction, factor=self._internal_conditioning_factor, - additional_constraints=values) + additional_constraints=values, + force_levelling_up=force_levelling_up) if self.use_fast == 'hybrid': frontier = call_fast(min(grid_width, min(30, (30**5)**(1 / self._val_thresholds.shape[1])))) @@ -1134,7 +1156,7 @@ def DataDict(target, data, groups=None, conditioning_factor=None) -> dict: def DeepDataDict(target, score, groups, groups_inferred=None, *, conditioning_factor=None) -> dict: - """Wrapper around build_data_dict for deeplearning with inferred attributes. + """Wrapper around DataDict for deeplearning with inferred attributes. It transforms the input data into a dict, and creates helper functions so fairpredictor treats them appropriately. target: a numpy array containing the values the classifier should predict(AKA groundtruth) @@ -1148,7 +1170,7 @@ def DeepDataDict(target, score, groups, groups_inferred=None, *, assert groups.ndim == 1 assert score.shape[0] == target.shape[0] assert target.shape[0] == groups.shape[0] - assert score.shape[1] > 1 + assert score.shape[1] >= 1 if groups_inferred is not None: assert score.shape[1] == 1 assert groups_inferred.ndim == 2 diff --git a/src/oxonfair/learners/fair_frontier.py b/src/oxonfair/learners/fair_frontier.py index 44545e2..5f2ff87 100644 --- a/src/oxonfair/learners/fair_frontier.py +++ b/src/oxonfair/learners/fair_frontier.py @@ -45,9 +45,12 @@ def compute_metrics(metrics: Sequence[Callable], y_true: np.ndarray, proba: np.n then select the max and compute a fairness metric """ scores = np.zeros((len(metrics), weights.shape[-1])) y_true = np.asarray(y_true) - # assert weights[:, 1, :].sum() == 0 + assert proba.ndim == 1 + assert weights.shape[1] == 2 + assert weights.shape[0] == threshold_assignment.shape[1] + #assert weights[:, 1, :].sum() == 0 weights = weights[:, 0, :] - proba = proba[:, 0] - proba[:, 1] + threshold_assignment = np.asarray(threshold_assignment) @@ -218,7 +221,8 @@ def build_coarse_to_fine_front(metrics: Sequence[Callable], refinement_factor: int = 4, logit_scaling: bool = False, existing_weights: Optional[np.ndarray] = None, - additional_constraints: Sequence = None) -> Tuple[np.ndarray, np.ndarray]: + additional_constraints: Sequence = None, + force_levelling_up=False) -> Tuple[np.ndarray, np.ndarray]: """ this function performs coarse-to-fine grid-search for computing the Pareto front """ @@ -227,20 +231,20 @@ def build_coarse_to_fine_front(metrics: Sequence[Callable], assert nr_of_recursive_calls > 0 groups = groups_infered.shape[1] - classes = proba.shape[1] - 1 # n.b. this is really classes-1 - upper_bound = (proba[:, :classes] - proba.min(1)[:, np.newaxis]).max(0) - lower_bound = (proba[:, :classes] - proba.max(1)[:, np.newaxis]).min(0) + classes = 1 # n.b. this is really classes-1 + upper_bound = proba.max() + lower_bound = proba.min() min_initial = np.ones((groups, classes)) - min_initial[:, :] = lower_bound[:, np.newaxis] + min_initial[:, :] = lower_bound max_initial = np.ones((groups, classes)) - max_initial[:, :] = upper_bound[:, np.newaxis] + max_initial[:, :] = upper_bound # perform an initial two stage search, first coarsely over every possible value # then take the front and search over valid values from it weights = make_grid_between_points(min_initial, max_initial, refinement_factor=initial_divisions - 1, logit_scaling=logit_scaling) front = front_from_weights(weights, y_true, proba, groups_infered, metrics) - front, weights = keep_front(front, weights, directions, additional_constraints) + front, weights = keep_front(front, weights, directions, additional_constraints, force_levelling_up=force_levelling_up) # second stage mins = weights[:, :-1].min(-1) # drop zeros maxs = weights[:, :-1].max(-1) @@ -258,7 +262,7 @@ def build_coarse_to_fine_front(metrics: Sequence[Callable], weights = np.concatenate((existing_weights, weights), -1) front = np.concatenate((existing_front, front), -1) - front, weights = keep_front(front, weights, directions, additional_constraints) + front, weights = keep_front(front, weights, directions, additional_constraints, force_levelling_up=force_levelling_up) for _ in range(nr_of_recursive_calls - 1): if weights.shape[-1] != 1: eps /= refinement_factor @@ -267,12 +271,12 @@ def build_coarse_to_fine_front(metrics: Sequence[Callable], metrics) weights = np.concatenate((new_weights, weights), -1) front = np.concatenate((new_front, front), -1) - front, weights = keep_front(front, weights, directions, additional_constraints) + front, weights = keep_front(front, weights, directions, additional_constraints, force_levelling_up=force_levelling_up) # densify the front with uniform interpolation if weights.shape[-1] > 1: weights = linear_interpolate(front, weights, gap=0.02) front = front_from_weights(weights, y_true, proba, groups_infered, metrics) - front, weights = keep_front(front, weights, directions, additional_constraints) + front, weights = keep_front(front, weights, directions, additional_constraints, force_levelling_up=force_levelling_up) return front, weights diff --git a/src/oxonfair/utils/performance.py b/src/oxonfair/utils/performance.py index 1f707a6..79f4e84 100644 --- a/src/oxonfair/utils/performance.py +++ b/src/oxonfair/utils/performance.py @@ -74,7 +74,7 @@ def evaluate_fairness(target, prediction, groups, factor=None, *, a pandas dataset containing rows indexed by fairness measure name """ target = target.squeeze() - assert np.unique(target).shape[0] == 2, 'More than two target labels used. OxonFair only works with binary predictors' + assert np.unique(target).shape[0] <= 2, 'More than two target labels used. OxonFair only works with binary predictors' threshold = find_threshold(threshold, prediction) if groups is None: groups = np.ones_like(target) @@ -116,7 +116,7 @@ def evaluate_per_group(target, prediction, groups, factor=None, *, a pandas dataset containing rows indexed by fairness measure name """ target = target.squeeze() - assert np.unique(target).shape[0] == 2, 'More than two target labels used. OxonFair only works with binary predictors' + assert np.unique(target).shape[0] <= 2, 'More than two target labels used. OxonFair only works with binary predictors' threshold = find_threshold(threshold, prediction) diff --git a/tests/unittests/test_scipy.py b/tests/unittests/test_scipy.py index e147b9c..18c9182 100644 --- a/tests/unittests/test_scipy.py +++ b/tests/unittests/test_scipy.py @@ -279,8 +279,8 @@ def test_recall_diff_hybrid(): test_recall_diff('hybrid') -""" too slow and disabled -def test_many_recall_diff_hybrid(many=200): +""" too slow -- keep disabled unless hunting non-deterministic bugs. +def test_many_recall_diff_hybrid(many=2000): count = 0 for i in range(many): resample() @@ -300,12 +300,12 @@ def test_many_recall_diff_slow(many=200): except: count += 1 assert count == 0 +# """ def test_min_recall_slow(): "test slow pathway" test_min_recall(False) - # """ def test_min_recall_hybrid(): @@ -421,3 +421,43 @@ def test_frontier_slow(): def test_frontier_hybrid(): test_frontier('hybrid') + + +def test_selection_rate_diff_levelling_up(use_fast=True): + """Maximize accuracy while enforcing demographic parity with levelling up.""" + + fpredictor = fair.FairPredictor( + predictor, test_dict, "sex_ Female", use_fast=use_fast) + + fpredictor.fit(gm.accuracy, gm.pos_pred_rate.diff, 0.025, force_levelling_up=True) + + rate = fpredictor.evaluate_groups(metrics={1: gm.pos_pred_rate}, verbose=False)[1] + assert (rate['updated'].drop('Maximum difference') >= rate['original'].drop('Maximum difference')).all() + assert (fpredictor.evaluate_groups() == fpredictor.evaluate_groups(test_dict)).all().all() + # Evaluate the change in fairness (recall difference corresponds to EO) + measures = fpredictor.evaluate_fairness(verbose=False) + + assert measures["original"]["statistical_parity"] > 0.025 + + assert measures["updated"]["statistical_parity"] <= 0.025 + + fpredictor.fit(gm.accuracy, gm.pos_pred_rate.diff, 0.025, force_levelling_up='-') + rate = fpredictor.evaluate_groups(metrics={1: gm.pos_pred_rate}, verbose=False)[1] + assert (rate['updated'].drop('Maximum difference') <= rate['original'].drop('Maximum difference')).all() + # Evaluate the change in fairness (recall difference corresponds to EO) + measures = fpredictor.evaluate_fairness(verbose=False) + + # Evaluate the change in fairness (recall difference corresponds to EO) + measures = fpredictor.evaluate_fairness(verbose=False) + + assert measures["original"]["statistical_parity"] > 0.025 + + assert measures["updated"]["statistical_parity"] <= 0.025 + + +def test_selection_rate_diff_levelling_up_slow(): + test_selection_rate_diff_levelling_up(use_fast=False) + + +def test_selection_rate_diff_levelling_up_hybrid(): + test_selection_rate_diff_levelling_up(use_fast='hybrid') \ No newline at end of file diff --git a/tests/unittests/test_torch.py b/tests/unittests/test_torch.py index 748716f..f239829 100644 --- a/tests/unittests/test_torch.py +++ b/tests/unittests/test_torch.py @@ -64,18 +64,19 @@ def test_1_hot(head_width=4): groups=groups_bin) fpred.fit(gm.accuracy, gm.demographic_parity, 0.01) + assert fpred.evaluate_fairness()['updated']['Statistical Parity'] < 0.01 fair_network = copy.deepcopy(network) fair_network[-1] = fpred.merge_heads_pytorch(network[-1]) output_fair = np.asarray(fair_network(tensor(np.asarray(train['data'])).float()).detach()) if head_width > 2: - assert performance.evaluate_fairness(train['target'], output_fair.reshape(-1), train['groups']).loc['Statistical Parity'] < 0.01 assert (performance.evaluate_fairness(train['target'], output_fair.reshape(-1), train['groups']) == fpred.evaluate_fairness()['updated']).all() assert np.isclose(performance.evaluate(train['target'], output_fair.reshape(-1)), fpred.evaluate()['updated'], atol=0.001).all() + assert performance.evaluate_fairness(train['target'], output_fair.reshape(-1), train['groups']).loc['Statistical Parity'] < 0.01 else: - assert performance.evaluate_fairness(train['target'], output_fair.reshape(-1), groups_bin).loc['Statistical Parity'] < 0.01 assert (performance.evaluate_fairness(train['target'], output_fair.reshape(-1), groups_bin) == fpred.evaluate_fairness()['updated']).all() assert np.isclose(performance.evaluate(train['target'], output_fair.reshape(-1)), fpred.evaluate()['updated'], atol=0.001).all() + assert performance.evaluate_fairness(train['target'], output_fair.reshape(-1), groups_bin).loc['Statistical Parity'] < 0.01 def test_bin(): diff --git a/using_fit.md b/using_fit.md index b9513ab..e052bc2 100644 --- a/using_fit.md +++ b/using_fit.md @@ -59,6 +59,10 @@ Now let's look at some example uses for `.fit`. * Enforce that the selection rate is over 40% for every group. `fpredict.fit(gm.accuracy, gm.pos_pred_rate, 0.4)` This is the levelling-up version of demographic parity. +* Enforce approximate demographic parity while forcing the selection rate to increase for every group (achieving equality while avoiding levelling down) + `fpredict.fit(gm.accuracy, gm.pos_pred_rate.diff, 0.02, force_levelling_up='+')` +* Enforce approximate predictive parity while forcing the selection rate to decrease for every group (achieving equality while avoiding levelling down with respect to precision) + `fpredict.fit(gm.accuracy, gm.precision.diff, 0.02, force_levelling_up='-')` * Pareto efficient minimax fairness This enforces that the accuracy over the worst performing pair of (target label, group) is as high as possible, while maximising the overall accuracy (see [Martenez et al.](https://arxiv.org/abs/2011.01821)) `fpredict.fit(gm.min_accuracy.min, gm.accuracy, 0)`